1 /* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0:
6 * Creates, reads, walks and deletes directory-nodes
8 * Copyright (C) 2002, 2004 Oracle. All rights reserved.
10 * Portions of this code from linux/fs/ext3/dir.c
12 * Copyright (C) 1992, 1993, 1994, 1995
13 * Remy Card (card@masi.ibp.fr)
14 * Laboratoire MASI - Institut Blaise pascal
15 * Universite Pierre et Marie Curie (Paris VI)
19 * linux/fs/minix/dir.c
21 * Copyright (C) 1991, 1992 Linus Torvalds
23 * This program is free software; you can redistribute it and/or
24 * modify it under the terms of the GNU General Public
25 * License as published by the Free Software Foundation; either
26 * version 2 of the License, or (at your option) any later version.
28 * This program is distributed in the hope that it will be useful,
29 * but WITHOUT ANY WARRANTY; without even the implied warranty of
30 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
31 * General Public License for more details.
33 * You should have received a copy of the GNU General Public
34 * License along with this program; if not, write to the
35 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
36 * Boston, MA 021110-1307, USA.
40 #include <linux/types.h>
41 #include <linux/slab.h>
42 #include <linux/highmem.h>
43 #include <linux/quotaops.h>
44 #include <linux/sort.h>
45 #include <linux/iversion.h>
47 #include <cluster/masklog.h>
52 #include "blockcheck.h"
55 #include "extent_map.h"
64 #include "ocfs2_trace.h"
66 #include "buffer_head_io.h"
68 #define NAMEI_RA_CHUNKS 2
69 #define NAMEI_RA_BLOCKS 4
70 #define NAMEI_RA_SIZE (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS)
72 static unsigned char ocfs2_filetype_table
[] = {
73 DT_UNKNOWN
, DT_REG
, DT_DIR
, DT_CHR
, DT_BLK
, DT_FIFO
, DT_SOCK
, DT_LNK
76 static int ocfs2_do_extend_dir(struct super_block
*sb
,
79 struct buffer_head
*parent_fe_bh
,
80 struct ocfs2_alloc_context
*data_ac
,
81 struct ocfs2_alloc_context
*meta_ac
,
82 struct buffer_head
**new_bh
);
83 static int ocfs2_dir_indexed(struct inode
*inode
);
86 * These are distinct checks because future versions of the file system will
87 * want to have a trailing dirent structure independent of indexing.
89 static int ocfs2_supports_dir_trailer(struct inode
*dir
)
91 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
93 if (OCFS2_I(dir
)->ip_dyn_features
& OCFS2_INLINE_DATA_FL
)
96 return ocfs2_meta_ecc(osb
) || ocfs2_dir_indexed(dir
);
100 * "new' here refers to the point at which we're creating a new
101 * directory via "mkdir()", but also when we're expanding an inline
102 * directory. In either case, we don't yet have the indexing bit set
103 * on the directory, so the standard checks will fail in when metaecc
104 * is turned off. Only directory-initialization type functions should
105 * use this then. Everything else wants ocfs2_supports_dir_trailer()
107 static int ocfs2_new_dir_wants_trailer(struct inode
*dir
)
109 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
111 return ocfs2_meta_ecc(osb
) ||
112 ocfs2_supports_indexed_dirs(osb
);
115 static inline unsigned int ocfs2_dir_trailer_blk_off(struct super_block
*sb
)
117 return sb
->s_blocksize
- sizeof(struct ocfs2_dir_block_trailer
);
120 #define ocfs2_trailer_from_bh(_bh, _sb) ((struct ocfs2_dir_block_trailer *) ((_bh)->b_data + ocfs2_dir_trailer_blk_off((_sb))))
122 /* XXX ocfs2_block_dqtrailer() is similar but not quite - can we make
123 * them more consistent? */
124 struct ocfs2_dir_block_trailer
*ocfs2_dir_trailer_from_size(int blocksize
,
129 p
+= blocksize
- sizeof(struct ocfs2_dir_block_trailer
);
130 return (struct ocfs2_dir_block_trailer
*)p
;
134 * XXX: This is executed once on every dirent. We should consider optimizing
137 static int ocfs2_skip_dir_trailer(struct inode
*dir
,
138 struct ocfs2_dir_entry
*de
,
139 unsigned long offset
,
140 unsigned long blklen
)
142 unsigned long toff
= blklen
- sizeof(struct ocfs2_dir_block_trailer
);
144 if (!ocfs2_supports_dir_trailer(dir
))
153 static void ocfs2_init_dir_trailer(struct inode
*inode
,
154 struct buffer_head
*bh
, u16 rec_len
)
156 struct ocfs2_dir_block_trailer
*trailer
;
158 trailer
= ocfs2_trailer_from_bh(bh
, inode
->i_sb
);
159 strcpy(trailer
->db_signature
, OCFS2_DIR_TRAILER_SIGNATURE
);
160 trailer
->db_compat_rec_len
=
161 cpu_to_le16(sizeof(struct ocfs2_dir_block_trailer
));
162 trailer
->db_parent_dinode
= cpu_to_le64(OCFS2_I(inode
)->ip_blkno
);
163 trailer
->db_blkno
= cpu_to_le64(bh
->b_blocknr
);
164 trailer
->db_free_rec_len
= cpu_to_le16(rec_len
);
167 * Link an unindexed block with a dir trailer structure into the index free
168 * list. This function will modify dirdata_bh, but assumes you've already
169 * passed it to the journal.
171 static int ocfs2_dx_dir_link_trailer(struct inode
*dir
, handle_t
*handle
,
172 struct buffer_head
*dx_root_bh
,
173 struct buffer_head
*dirdata_bh
)
176 struct ocfs2_dx_root_block
*dx_root
;
177 struct ocfs2_dir_block_trailer
*trailer
;
179 ret
= ocfs2_journal_access_dr(handle
, INODE_CACHE(dir
), dx_root_bh
,
180 OCFS2_JOURNAL_ACCESS_WRITE
);
185 trailer
= ocfs2_trailer_from_bh(dirdata_bh
, dir
->i_sb
);
186 dx_root
= (struct ocfs2_dx_root_block
*)dx_root_bh
->b_data
;
188 trailer
->db_free_next
= dx_root
->dr_free_blk
;
189 dx_root
->dr_free_blk
= cpu_to_le64(dirdata_bh
->b_blocknr
);
191 ocfs2_journal_dirty(handle
, dx_root_bh
);
197 static int ocfs2_free_list_at_root(struct ocfs2_dir_lookup_result
*res
)
199 return res
->dl_prev_leaf_bh
== NULL
;
202 void ocfs2_free_dir_lookup_result(struct ocfs2_dir_lookup_result
*res
)
204 brelse(res
->dl_dx_root_bh
);
205 brelse(res
->dl_leaf_bh
);
206 brelse(res
->dl_dx_leaf_bh
);
207 brelse(res
->dl_prev_leaf_bh
);
210 static int ocfs2_dir_indexed(struct inode
*inode
)
212 if (OCFS2_I(inode
)->ip_dyn_features
& OCFS2_INDEXED_DIR_FL
)
217 static inline int ocfs2_dx_root_inline(struct ocfs2_dx_root_block
*dx_root
)
219 return dx_root
->dr_flags
& OCFS2_DX_FLAG_INLINE
;
223 * Hashing code adapted from ext3
225 #define DELTA 0x9E3779B9
227 static void TEA_transform(__u32 buf
[4], __u32
const in
[])
230 __u32 b0
= buf
[0], b1
= buf
[1];
231 __u32 a
= in
[0], b
= in
[1], c
= in
[2], d
= in
[3];
236 b0
+= ((b1
<< 4)+a
) ^ (b1
+sum
) ^ ((b1
>> 5)+b
);
237 b1
+= ((b0
<< 4)+c
) ^ (b0
+sum
) ^ ((b0
>> 5)+d
);
244 static void str2hashbuf(const char *msg
, int len
, __u32
*buf
, int num
)
249 pad
= (__u32
)len
| ((__u32
)len
<< 8);
255 for (i
= 0; i
< len
; i
++) {
258 val
= msg
[i
] + (val
<< 8);
271 static void ocfs2_dx_dir_name_hash(struct inode
*dir
, const char *name
, int len
,
272 struct ocfs2_dx_hinfo
*hinfo
)
274 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
279 * XXX: Is this really necessary, if the index is never looked
280 * at by readdir? Is a hash value of '0' a bad idea?
282 if ((len
== 1 && !strncmp(".", name
, 1)) ||
283 (len
== 2 && !strncmp("..", name
, 2))) {
288 #ifdef OCFS2_DEBUG_DX_DIRS
290 * This makes it very easy to debug indexing problems. We
291 * should never allow this to be selected without hand editing
294 buf
[0] = buf
[1] = len
;
298 memcpy(buf
, osb
->osb_dx_seed
, sizeof(buf
));
302 str2hashbuf(p
, len
, in
, 4);
303 TEA_transform(buf
, in
);
309 hinfo
->major_hash
= buf
[0];
310 hinfo
->minor_hash
= buf
[1];
314 * bh passed here can be an inode block or a dir data block, depending
315 * on the inode inline data flag.
317 static int ocfs2_check_dir_entry(struct inode
* dir
,
318 struct ocfs2_dir_entry
* de
,
319 struct buffer_head
* bh
,
320 unsigned long offset
)
322 const char *error_msg
= NULL
;
323 const int rlen
= le16_to_cpu(de
->rec_len
);
325 if (unlikely(rlen
< OCFS2_DIR_REC_LEN(1)))
326 error_msg
= "rec_len is smaller than minimal";
327 else if (unlikely(rlen
% 4 != 0))
328 error_msg
= "rec_len % 4 != 0";
329 else if (unlikely(rlen
< OCFS2_DIR_REC_LEN(de
->name_len
)))
330 error_msg
= "rec_len is too small for name_len";
332 ((char *) de
- bh
->b_data
) + rlen
> dir
->i_sb
->s_blocksize
))
333 error_msg
= "directory entry across blocks";
335 if (unlikely(error_msg
!= NULL
))
336 mlog(ML_ERROR
, "bad entry in directory #%llu: %s - "
337 "offset=%lu, inode=%llu, rec_len=%d, name_len=%d\n",
338 (unsigned long long)OCFS2_I(dir
)->ip_blkno
, error_msg
,
339 offset
, (unsigned long long)le64_to_cpu(de
->inode
), rlen
,
342 return error_msg
== NULL
? 1 : 0;
345 static inline int ocfs2_match(int len
,
346 const char * const name
,
347 struct ocfs2_dir_entry
*de
)
349 if (len
!= de
->name_len
)
353 return !memcmp(name
, de
->name
, len
);
357 * Returns 0 if not found, -1 on failure, and 1 on success
359 static inline int ocfs2_search_dirblock(struct buffer_head
*bh
,
361 const char *name
, int namelen
,
362 unsigned long offset
,
365 struct ocfs2_dir_entry
**res_dir
)
367 struct ocfs2_dir_entry
*de
;
368 char *dlimit
, *de_buf
;
373 dlimit
= de_buf
+ bytes
;
375 while (de_buf
< dlimit
) {
376 /* this code is executed quadratically often */
377 /* do minimal checking `by hand' */
379 de
= (struct ocfs2_dir_entry
*) de_buf
;
381 if (de_buf
+ namelen
<= dlimit
&&
382 ocfs2_match(namelen
, name
, de
)) {
383 /* found a match - just to be sure, do a full check */
384 if (!ocfs2_check_dir_entry(dir
, de
, bh
, offset
)) {
393 /* prevent looping on a bad block */
394 de_len
= le16_to_cpu(de
->rec_len
);
405 trace_ocfs2_search_dirblock(ret
);
409 static struct buffer_head
*ocfs2_find_entry_id(const char *name
,
412 struct ocfs2_dir_entry
**res_dir
)
415 struct buffer_head
*di_bh
= NULL
;
416 struct ocfs2_dinode
*di
;
417 struct ocfs2_inline_data
*data
;
419 ret
= ocfs2_read_inode_block(dir
, &di_bh
);
425 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
426 data
= &di
->id2
.i_data
;
428 found
= ocfs2_search_dirblock(di_bh
, dir
, name
, namelen
, 0,
429 data
->id_data
, i_size_read(dir
), res_dir
);
438 static int ocfs2_validate_dir_block(struct super_block
*sb
,
439 struct buffer_head
*bh
)
442 struct ocfs2_dir_block_trailer
*trailer
=
443 ocfs2_trailer_from_bh(bh
, sb
);
447 * We don't validate dirents here, that's handled
448 * in-place when the code walks them.
450 trace_ocfs2_validate_dir_block((unsigned long long)bh
->b_blocknr
);
452 BUG_ON(!buffer_uptodate(bh
));
455 * If the ecc fails, we return the error but otherwise
456 * leave the filesystem running. We know any error is
457 * local to this block.
459 * Note that we are safe to call this even if the directory
460 * doesn't have a trailer. Filesystems without metaecc will do
461 * nothing, and filesystems with it will have one.
463 rc
= ocfs2_validate_meta_ecc(sb
, bh
->b_data
, &trailer
->db_check
);
465 mlog(ML_ERROR
, "Checksum failed for dinode %llu\n",
466 (unsigned long long)bh
->b_blocknr
);
472 * Validate a directory trailer.
474 * We check the trailer here rather than in ocfs2_validate_dir_block()
475 * because that function doesn't have the inode to test.
477 static int ocfs2_check_dir_trailer(struct inode
*dir
, struct buffer_head
*bh
)
480 struct ocfs2_dir_block_trailer
*trailer
;
482 trailer
= ocfs2_trailer_from_bh(bh
, dir
->i_sb
);
483 if (!OCFS2_IS_VALID_DIR_TRAILER(trailer
)) {
484 rc
= ocfs2_error(dir
->i_sb
,
485 "Invalid dirblock #%llu: signature = %.*s\n",
486 (unsigned long long)bh
->b_blocknr
, 7,
487 trailer
->db_signature
);
490 if (le64_to_cpu(trailer
->db_blkno
) != bh
->b_blocknr
) {
491 rc
= ocfs2_error(dir
->i_sb
,
492 "Directory block #%llu has an invalid db_blkno of %llu\n",
493 (unsigned long long)bh
->b_blocknr
,
494 (unsigned long long)le64_to_cpu(trailer
->db_blkno
));
497 if (le64_to_cpu(trailer
->db_parent_dinode
) !=
498 OCFS2_I(dir
)->ip_blkno
) {
499 rc
= ocfs2_error(dir
->i_sb
,
500 "Directory block #%llu on dinode #%llu has an invalid parent_dinode of %llu\n",
501 (unsigned long long)bh
->b_blocknr
,
502 (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
503 (unsigned long long)le64_to_cpu(trailer
->db_blkno
));
511 * This function forces all errors to -EIO for consistency with its
512 * predecessor, ocfs2_bread(). We haven't audited what returning the
513 * real error codes would do to callers. We log the real codes with
514 * mlog_errno() before we squash them.
516 static int ocfs2_read_dir_block(struct inode
*inode
, u64 v_block
,
517 struct buffer_head
**bh
, int flags
)
520 struct buffer_head
*tmp
= *bh
;
522 rc
= ocfs2_read_virt_blocks(inode
, v_block
, 1, &tmp
, flags
,
523 ocfs2_validate_dir_block
);
529 if (!(flags
& OCFS2_BH_READAHEAD
) &&
530 ocfs2_supports_dir_trailer(inode
)) {
531 rc
= ocfs2_check_dir_trailer(inode
, tmp
);
540 /* If ocfs2_read_virt_blocks() got us a new bh, pass it up. */
545 return rc
? -EIO
: 0;
549 * Read the block at 'phys' which belongs to this directory
550 * inode. This function does no virtual->physical block translation -
551 * what's passed in is assumed to be a valid directory block.
553 static int ocfs2_read_dir_block_direct(struct inode
*dir
, u64 phys
,
554 struct buffer_head
**bh
)
557 struct buffer_head
*tmp
= *bh
;
559 ret
= ocfs2_read_block(INODE_CACHE(dir
), phys
, &tmp
,
560 ocfs2_validate_dir_block
);
566 if (ocfs2_supports_dir_trailer(dir
)) {
567 ret
= ocfs2_check_dir_trailer(dir
, tmp
);
582 static int ocfs2_validate_dx_root(struct super_block
*sb
,
583 struct buffer_head
*bh
)
586 struct ocfs2_dx_root_block
*dx_root
;
588 BUG_ON(!buffer_uptodate(bh
));
590 dx_root
= (struct ocfs2_dx_root_block
*) bh
->b_data
;
592 ret
= ocfs2_validate_meta_ecc(sb
, bh
->b_data
, &dx_root
->dr_check
);
595 "Checksum failed for dir index root block %llu\n",
596 (unsigned long long)bh
->b_blocknr
);
600 if (!OCFS2_IS_VALID_DX_ROOT(dx_root
)) {
601 ret
= ocfs2_error(sb
,
602 "Dir Index Root # %llu has bad signature %.*s\n",
603 (unsigned long long)le64_to_cpu(dx_root
->dr_blkno
),
604 7, dx_root
->dr_signature
);
610 static int ocfs2_read_dx_root(struct inode
*dir
, struct ocfs2_dinode
*di
,
611 struct buffer_head
**dx_root_bh
)
614 u64 blkno
= le64_to_cpu(di
->i_dx_root
);
615 struct buffer_head
*tmp
= *dx_root_bh
;
617 ret
= ocfs2_read_block(INODE_CACHE(dir
), blkno
, &tmp
,
618 ocfs2_validate_dx_root
);
620 /* If ocfs2_read_block() got us a new bh, pass it up. */
621 if (!ret
&& !*dx_root_bh
)
627 static int ocfs2_validate_dx_leaf(struct super_block
*sb
,
628 struct buffer_head
*bh
)
631 struct ocfs2_dx_leaf
*dx_leaf
= (struct ocfs2_dx_leaf
*)bh
->b_data
;
633 BUG_ON(!buffer_uptodate(bh
));
635 ret
= ocfs2_validate_meta_ecc(sb
, bh
->b_data
, &dx_leaf
->dl_check
);
638 "Checksum failed for dir index leaf block %llu\n",
639 (unsigned long long)bh
->b_blocknr
);
643 if (!OCFS2_IS_VALID_DX_LEAF(dx_leaf
)) {
644 ret
= ocfs2_error(sb
, "Dir Index Leaf has bad signature %.*s\n",
645 7, dx_leaf
->dl_signature
);
651 static int ocfs2_read_dx_leaf(struct inode
*dir
, u64 blkno
,
652 struct buffer_head
**dx_leaf_bh
)
655 struct buffer_head
*tmp
= *dx_leaf_bh
;
657 ret
= ocfs2_read_block(INODE_CACHE(dir
), blkno
, &tmp
,
658 ocfs2_validate_dx_leaf
);
660 /* If ocfs2_read_block() got us a new bh, pass it up. */
661 if (!ret
&& !*dx_leaf_bh
)
668 * Read a series of dx_leaf blocks. This expects all buffer_head
669 * pointers to be NULL on function entry.
671 static int ocfs2_read_dx_leaves(struct inode
*dir
, u64 start
, int num
,
672 struct buffer_head
**dx_leaf_bhs
)
676 ret
= ocfs2_read_blocks(INODE_CACHE(dir
), start
, num
, dx_leaf_bhs
, 0,
677 ocfs2_validate_dx_leaf
);
684 static struct buffer_head
*ocfs2_find_entry_el(const char *name
, int namelen
,
686 struct ocfs2_dir_entry
**res_dir
)
688 struct super_block
*sb
;
689 struct buffer_head
*bh_use
[NAMEI_RA_SIZE
];
690 struct buffer_head
*bh
, *ret
= NULL
;
691 unsigned long start
, block
, b
;
692 int ra_max
= 0; /* Number of bh's in the readahead
694 int ra_ptr
= 0; /* Current index into readahead
701 nblocks
= i_size_read(dir
) >> sb
->s_blocksize_bits
;
702 start
= OCFS2_I(dir
)->ip_dir_start_lookup
;
703 if (start
>= nblocks
)
710 * We deal with the read-ahead logic here.
712 if (ra_ptr
>= ra_max
) {
713 /* Refill the readahead buffer */
716 for (ra_max
= 0; ra_max
< NAMEI_RA_SIZE
; ra_max
++) {
718 * Terminate if we reach the end of the
719 * directory and must wrap, or if our
720 * search has finished at this block.
722 if (b
>= nblocks
|| (num
&& block
== start
)) {
723 bh_use
[ra_max
] = NULL
;
729 err
= ocfs2_read_dir_block(dir
, b
++, &bh
,
734 if ((bh
= bh_use
[ra_ptr
++]) == NULL
)
736 if (ocfs2_read_dir_block(dir
, block
, &bh
, 0)) {
737 /* read error, skip block & hope for the best.
738 * ocfs2_read_dir_block() has released the bh. */
739 mlog(ML_ERROR
, "reading directory %llu, "
741 (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
745 i
= ocfs2_search_dirblock(bh
, dir
, name
, namelen
,
746 block
<< sb
->s_blocksize_bits
,
747 bh
->b_data
, sb
->s_blocksize
,
750 OCFS2_I(dir
)->ip_dir_start_lookup
= block
;
752 goto cleanup_and_exit
;
756 goto cleanup_and_exit
;
759 if (++block
>= nblocks
)
761 } while (block
!= start
);
764 * If the directory has grown while we were searching, then
765 * search the last part of the directory before giving up.
768 nblocks
= i_size_read(dir
) >> sb
->s_blocksize_bits
;
769 if (block
< nblocks
) {
775 /* Clean up the read-ahead blocks */
776 for (; ra_ptr
< ra_max
; ra_ptr
++)
777 brelse(bh_use
[ra_ptr
]);
779 trace_ocfs2_find_entry_el(ret
);
783 static int ocfs2_dx_dir_lookup_rec(struct inode
*inode
,
784 struct ocfs2_extent_list
*el
,
788 unsigned int *ret_clen
)
790 int ret
= 0, i
, found
;
791 struct buffer_head
*eb_bh
= NULL
;
792 struct ocfs2_extent_block
*eb
;
793 struct ocfs2_extent_rec
*rec
= NULL
;
795 if (el
->l_tree_depth
) {
796 ret
= ocfs2_find_leaf(INODE_CACHE(inode
), el
, major_hash
,
803 eb
= (struct ocfs2_extent_block
*) eb_bh
->b_data
;
806 if (el
->l_tree_depth
) {
807 ret
= ocfs2_error(inode
->i_sb
,
808 "Inode %lu has non zero tree depth in btree tree block %llu\n",
810 (unsigned long long)eb_bh
->b_blocknr
);
816 for (i
= le16_to_cpu(el
->l_next_free_rec
) - 1; i
>= 0; i
--) {
817 rec
= &el
->l_recs
[i
];
819 if (le32_to_cpu(rec
->e_cpos
) <= major_hash
) {
826 ret
= ocfs2_error(inode
->i_sb
,
827 "Inode %lu has bad extent record (%u, %u, 0) in btree\n",
829 le32_to_cpu(rec
->e_cpos
),
830 ocfs2_rec_clusters(el
, rec
));
835 *ret_phys_blkno
= le64_to_cpu(rec
->e_blkno
);
837 *ret_cpos
= le32_to_cpu(rec
->e_cpos
);
839 *ret_clen
= le16_to_cpu(rec
->e_leaf_clusters
);
847 * Returns the block index, from the start of the cluster which this
850 static inline unsigned int __ocfs2_dx_dir_hash_idx(struct ocfs2_super
*osb
,
853 return minor_hash
& osb
->osb_dx_mask
;
856 static inline unsigned int ocfs2_dx_dir_hash_idx(struct ocfs2_super
*osb
,
857 struct ocfs2_dx_hinfo
*hinfo
)
859 return __ocfs2_dx_dir_hash_idx(osb
, hinfo
->minor_hash
);
862 static int ocfs2_dx_dir_lookup(struct inode
*inode
,
863 struct ocfs2_extent_list
*el
,
864 struct ocfs2_dx_hinfo
*hinfo
,
869 unsigned int cend
, uninitialized_var(clen
);
870 u32
uninitialized_var(cpos
);
871 u64
uninitialized_var(blkno
);
872 u32 name_hash
= hinfo
->major_hash
;
874 ret
= ocfs2_dx_dir_lookup_rec(inode
, el
, name_hash
, &cpos
, &blkno
,
882 if (name_hash
>= cend
) {
883 /* We want the last cluster */
884 blkno
+= ocfs2_clusters_to_blocks(inode
->i_sb
, clen
- 1);
887 blkno
+= ocfs2_clusters_to_blocks(inode
->i_sb
,
893 * We now have the cluster which should hold our entry. To
894 * find the exact block from the start of the cluster to
895 * search, we take the lower bits of the hash.
897 blkno
+= ocfs2_dx_dir_hash_idx(OCFS2_SB(inode
->i_sb
), hinfo
);
900 *ret_phys_blkno
= blkno
;
909 static int ocfs2_dx_dir_search(const char *name
, int namelen
,
911 struct ocfs2_dx_root_block
*dx_root
,
912 struct ocfs2_dir_lookup_result
*res
)
915 u64
uninitialized_var(phys
);
916 struct buffer_head
*dx_leaf_bh
= NULL
;
917 struct ocfs2_dx_leaf
*dx_leaf
;
918 struct ocfs2_dx_entry
*dx_entry
= NULL
;
919 struct buffer_head
*dir_ent_bh
= NULL
;
920 struct ocfs2_dir_entry
*dir_ent
= NULL
;
921 struct ocfs2_dx_hinfo
*hinfo
= &res
->dl_hinfo
;
922 struct ocfs2_extent_list
*dr_el
;
923 struct ocfs2_dx_entry_list
*entry_list
;
925 ocfs2_dx_dir_name_hash(dir
, name
, namelen
, &res
->dl_hinfo
);
927 if (ocfs2_dx_root_inline(dx_root
)) {
928 entry_list
= &dx_root
->dr_entries
;
932 dr_el
= &dx_root
->dr_list
;
934 ret
= ocfs2_dx_dir_lookup(dir
, dr_el
, hinfo
, NULL
, &phys
);
940 trace_ocfs2_dx_dir_search((unsigned long long)OCFS2_I(dir
)->ip_blkno
,
941 namelen
, name
, hinfo
->major_hash
,
942 hinfo
->minor_hash
, (unsigned long long)phys
);
944 ret
= ocfs2_read_dx_leaf(dir
, phys
, &dx_leaf_bh
);
950 dx_leaf
= (struct ocfs2_dx_leaf
*) dx_leaf_bh
->b_data
;
952 trace_ocfs2_dx_dir_search_leaf_info(
953 le16_to_cpu(dx_leaf
->dl_list
.de_num_used
),
954 le16_to_cpu(dx_leaf
->dl_list
.de_count
));
956 entry_list
= &dx_leaf
->dl_list
;
960 * Empty leaf is legal, so no need to check for that.
963 for (i
= 0; i
< le16_to_cpu(entry_list
->de_num_used
); i
++) {
964 dx_entry
= &entry_list
->de_entries
[i
];
966 if (hinfo
->major_hash
!= le32_to_cpu(dx_entry
->dx_major_hash
)
967 || hinfo
->minor_hash
!= le32_to_cpu(dx_entry
->dx_minor_hash
))
971 * Search unindexed leaf block now. We're not
972 * guaranteed to find anything.
974 ret
= ocfs2_read_dir_block_direct(dir
,
975 le64_to_cpu(dx_entry
->dx_dirent_blk
),
983 * XXX: We should check the unindexed block here,
987 found
= ocfs2_search_dirblock(dir_ent_bh
, dir
, name
, namelen
,
988 0, dir_ent_bh
->b_data
,
989 dir
->i_sb
->s_blocksize
, &dir_ent
);
994 /* This means we found a bad directory entry. */
1009 res
->dl_leaf_bh
= dir_ent_bh
;
1010 res
->dl_entry
= dir_ent
;
1011 res
->dl_dx_leaf_bh
= dx_leaf_bh
;
1012 res
->dl_dx_entry
= dx_entry
;
1023 static int ocfs2_find_entry_dx(const char *name
, int namelen
,
1025 struct ocfs2_dir_lookup_result
*lookup
)
1028 struct buffer_head
*di_bh
= NULL
;
1029 struct ocfs2_dinode
*di
;
1030 struct buffer_head
*dx_root_bh
= NULL
;
1031 struct ocfs2_dx_root_block
*dx_root
;
1033 ret
= ocfs2_read_inode_block(dir
, &di_bh
);
1039 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
1041 ret
= ocfs2_read_dx_root(dir
, di
, &dx_root_bh
);
1046 dx_root
= (struct ocfs2_dx_root_block
*) dx_root_bh
->b_data
;
1048 ret
= ocfs2_dx_dir_search(name
, namelen
, dir
, dx_root
, lookup
);
1055 lookup
->dl_dx_root_bh
= dx_root_bh
;
1064 * Try to find an entry of the provided name within 'dir'.
1066 * If nothing was found, -ENOENT is returned. Otherwise, zero is
1067 * returned and the struct 'res' will contain information useful to
1068 * other directory manipulation functions.
1070 * Caller can NOT assume anything about the contents of the
1071 * buffer_heads - they are passed back only so that it can be passed
1072 * into any one of the manipulation functions (add entry, delete
1073 * entry, etc). As an example, bh in the extent directory case is a
1074 * data block, in the inline-data case it actually points to an inode,
1075 * in the indexed directory case, multiple buffers are involved.
1077 int ocfs2_find_entry(const char *name
, int namelen
,
1078 struct inode
*dir
, struct ocfs2_dir_lookup_result
*lookup
)
1080 struct buffer_head
*bh
;
1081 struct ocfs2_dir_entry
*res_dir
= NULL
;
1083 if (ocfs2_dir_indexed(dir
))
1084 return ocfs2_find_entry_dx(name
, namelen
, dir
, lookup
);
1087 * The unindexed dir code only uses part of the lookup
1088 * structure, so there's no reason to push it down further
1091 if (OCFS2_I(dir
)->ip_dyn_features
& OCFS2_INLINE_DATA_FL
)
1092 bh
= ocfs2_find_entry_id(name
, namelen
, dir
, &res_dir
);
1094 bh
= ocfs2_find_entry_el(name
, namelen
, dir
, &res_dir
);
1099 lookup
->dl_leaf_bh
= bh
;
1100 lookup
->dl_entry
= res_dir
;
1105 * Update inode number and type of a previously found directory entry.
1107 int ocfs2_update_entry(struct inode
*dir
, handle_t
*handle
,
1108 struct ocfs2_dir_lookup_result
*res
,
1109 struct inode
*new_entry_inode
)
1112 ocfs2_journal_access_func access
= ocfs2_journal_access_db
;
1113 struct ocfs2_dir_entry
*de
= res
->dl_entry
;
1114 struct buffer_head
*de_bh
= res
->dl_leaf_bh
;
1117 * The same code works fine for both inline-data and extent
1118 * based directories, so no need to split this up. The only
1119 * difference is the journal_access function.
1122 if (OCFS2_I(dir
)->ip_dyn_features
& OCFS2_INLINE_DATA_FL
)
1123 access
= ocfs2_journal_access_di
;
1125 ret
= access(handle
, INODE_CACHE(dir
), de_bh
,
1126 OCFS2_JOURNAL_ACCESS_WRITE
);
1132 de
->inode
= cpu_to_le64(OCFS2_I(new_entry_inode
)->ip_blkno
);
1133 ocfs2_set_de_type(de
, new_entry_inode
->i_mode
);
1135 ocfs2_journal_dirty(handle
, de_bh
);
1142 * __ocfs2_delete_entry deletes a directory entry by merging it with the
1145 static int __ocfs2_delete_entry(handle_t
*handle
, struct inode
*dir
,
1146 struct ocfs2_dir_entry
*de_del
,
1147 struct buffer_head
*bh
, char *first_de
,
1150 struct ocfs2_dir_entry
*de
, *pde
;
1151 int i
, status
= -ENOENT
;
1152 ocfs2_journal_access_func access
= ocfs2_journal_access_db
;
1154 if (OCFS2_I(dir
)->ip_dyn_features
& OCFS2_INLINE_DATA_FL
)
1155 access
= ocfs2_journal_access_di
;
1159 de
= (struct ocfs2_dir_entry
*) first_de
;
1161 if (!ocfs2_check_dir_entry(dir
, de
, bh
, i
)) {
1167 status
= access(handle
, INODE_CACHE(dir
), bh
,
1168 OCFS2_JOURNAL_ACCESS_WRITE
);
1175 le16_add_cpu(&pde
->rec_len
,
1176 le16_to_cpu(de
->rec_len
));
1178 inode_inc_iversion(dir
);
1179 ocfs2_journal_dirty(handle
, bh
);
1182 i
+= le16_to_cpu(de
->rec_len
);
1184 de
= (struct ocfs2_dir_entry
*)((char *)de
+ le16_to_cpu(de
->rec_len
));
1190 static unsigned int ocfs2_figure_dirent_hole(struct ocfs2_dir_entry
*de
)
1194 if (le64_to_cpu(de
->inode
) == 0)
1195 hole
= le16_to_cpu(de
->rec_len
);
1197 hole
= le16_to_cpu(de
->rec_len
) -
1198 OCFS2_DIR_REC_LEN(de
->name_len
);
1203 static int ocfs2_find_max_rec_len(struct super_block
*sb
,
1204 struct buffer_head
*dirblock_bh
)
1206 int size
, this_hole
, largest_hole
= 0;
1207 char *trailer
, *de_buf
, *limit
, *start
= dirblock_bh
->b_data
;
1208 struct ocfs2_dir_entry
*de
;
1210 trailer
= (char *)ocfs2_trailer_from_bh(dirblock_bh
, sb
);
1211 size
= ocfs2_dir_trailer_blk_off(sb
);
1212 limit
= start
+ size
;
1214 de
= (struct ocfs2_dir_entry
*)de_buf
;
1216 if (de_buf
!= trailer
) {
1217 this_hole
= ocfs2_figure_dirent_hole(de
);
1218 if (this_hole
> largest_hole
)
1219 largest_hole
= this_hole
;
1222 de_buf
+= le16_to_cpu(de
->rec_len
);
1223 de
= (struct ocfs2_dir_entry
*)de_buf
;
1224 } while (de_buf
< limit
);
1226 if (largest_hole
>= OCFS2_DIR_MIN_REC_LEN
)
1227 return largest_hole
;
1231 static void ocfs2_dx_list_remove_entry(struct ocfs2_dx_entry_list
*entry_list
,
1234 int num_used
= le16_to_cpu(entry_list
->de_num_used
);
1236 if (num_used
== 1 || index
== (num_used
- 1))
1239 memmove(&entry_list
->de_entries
[index
],
1240 &entry_list
->de_entries
[index
+ 1],
1241 (num_used
- index
- 1)*sizeof(struct ocfs2_dx_entry
));
1244 memset(&entry_list
->de_entries
[num_used
], 0,
1245 sizeof(struct ocfs2_dx_entry
));
1246 entry_list
->de_num_used
= cpu_to_le16(num_used
);
1249 static int ocfs2_delete_entry_dx(handle_t
*handle
, struct inode
*dir
,
1250 struct ocfs2_dir_lookup_result
*lookup
)
1252 int ret
, index
, max_rec_len
, add_to_free_list
= 0;
1253 struct buffer_head
*dx_root_bh
= lookup
->dl_dx_root_bh
;
1254 struct buffer_head
*leaf_bh
= lookup
->dl_leaf_bh
;
1255 struct ocfs2_dx_leaf
*dx_leaf
;
1256 struct ocfs2_dx_entry
*dx_entry
= lookup
->dl_dx_entry
;
1257 struct ocfs2_dir_block_trailer
*trailer
;
1258 struct ocfs2_dx_root_block
*dx_root
;
1259 struct ocfs2_dx_entry_list
*entry_list
;
1262 * This function gets a bit messy because we might have to
1263 * modify the root block, regardless of whether the indexed
1264 * entries are stored inline.
1268 * *Only* set 'entry_list' here, based on where we're looking
1269 * for the indexed entries. Later, we might still want to
1270 * journal both blocks, based on free list state.
1272 dx_root
= (struct ocfs2_dx_root_block
*)dx_root_bh
->b_data
;
1273 if (ocfs2_dx_root_inline(dx_root
)) {
1274 entry_list
= &dx_root
->dr_entries
;
1276 dx_leaf
= (struct ocfs2_dx_leaf
*) lookup
->dl_dx_leaf_bh
->b_data
;
1277 entry_list
= &dx_leaf
->dl_list
;
1280 /* Neither of these are a disk corruption - that should have
1281 * been caught by lookup, before we got here. */
1282 BUG_ON(le16_to_cpu(entry_list
->de_count
) <= 0);
1283 BUG_ON(le16_to_cpu(entry_list
->de_num_used
) <= 0);
1285 index
= (char *)dx_entry
- (char *)entry_list
->de_entries
;
1286 index
/= sizeof(*dx_entry
);
1288 if (index
>= le16_to_cpu(entry_list
->de_num_used
)) {
1289 mlog(ML_ERROR
, "Dir %llu: Bad dx_entry ptr idx %d, (%p, %p)\n",
1290 (unsigned long long)OCFS2_I(dir
)->ip_blkno
, index
,
1291 entry_list
, dx_entry
);
1296 * We know that removal of this dirent will leave enough room
1297 * for a new one, so add this block to the free list if it
1298 * isn't already there.
1300 trailer
= ocfs2_trailer_from_bh(leaf_bh
, dir
->i_sb
);
1301 if (trailer
->db_free_rec_len
== 0)
1302 add_to_free_list
= 1;
1305 * Add the block holding our index into the journal before
1306 * removing the unindexed entry. If we get an error return
1307 * from __ocfs2_delete_entry(), then it hasn't removed the
1308 * entry yet. Likewise, successful return means we *must*
1309 * remove the indexed entry.
1311 * We're also careful to journal the root tree block here as
1312 * the entry count needs to be updated. Also, we might be
1313 * adding to the start of the free list.
1315 ret
= ocfs2_journal_access_dr(handle
, INODE_CACHE(dir
), dx_root_bh
,
1316 OCFS2_JOURNAL_ACCESS_WRITE
);
1322 if (!ocfs2_dx_root_inline(dx_root
)) {
1323 ret
= ocfs2_journal_access_dl(handle
, INODE_CACHE(dir
),
1324 lookup
->dl_dx_leaf_bh
,
1325 OCFS2_JOURNAL_ACCESS_WRITE
);
1332 trace_ocfs2_delete_entry_dx((unsigned long long)OCFS2_I(dir
)->ip_blkno
,
1335 ret
= __ocfs2_delete_entry(handle
, dir
, lookup
->dl_entry
,
1336 leaf_bh
, leaf_bh
->b_data
, leaf_bh
->b_size
);
1342 max_rec_len
= ocfs2_find_max_rec_len(dir
->i_sb
, leaf_bh
);
1343 trailer
->db_free_rec_len
= cpu_to_le16(max_rec_len
);
1344 if (add_to_free_list
) {
1345 trailer
->db_free_next
= dx_root
->dr_free_blk
;
1346 dx_root
->dr_free_blk
= cpu_to_le64(leaf_bh
->b_blocknr
);
1347 ocfs2_journal_dirty(handle
, dx_root_bh
);
1350 /* leaf_bh was journal_accessed for us in __ocfs2_delete_entry */
1351 ocfs2_journal_dirty(handle
, leaf_bh
);
1353 le32_add_cpu(&dx_root
->dr_num_entries
, -1);
1354 ocfs2_journal_dirty(handle
, dx_root_bh
);
1356 ocfs2_dx_list_remove_entry(entry_list
, index
);
1358 if (!ocfs2_dx_root_inline(dx_root
))
1359 ocfs2_journal_dirty(handle
, lookup
->dl_dx_leaf_bh
);
1365 static inline int ocfs2_delete_entry_id(handle_t
*handle
,
1367 struct ocfs2_dir_entry
*de_del
,
1368 struct buffer_head
*bh
)
1371 struct buffer_head
*di_bh
= NULL
;
1372 struct ocfs2_dinode
*di
;
1373 struct ocfs2_inline_data
*data
;
1375 ret
= ocfs2_read_inode_block(dir
, &di_bh
);
1381 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
1382 data
= &di
->id2
.i_data
;
1384 ret
= __ocfs2_delete_entry(handle
, dir
, de_del
, bh
, data
->id_data
,
1392 static inline int ocfs2_delete_entry_el(handle_t
*handle
,
1394 struct ocfs2_dir_entry
*de_del
,
1395 struct buffer_head
*bh
)
1397 return __ocfs2_delete_entry(handle
, dir
, de_del
, bh
, bh
->b_data
,
1402 * Delete a directory entry. Hide the details of directory
1403 * implementation from the caller.
1405 int ocfs2_delete_entry(handle_t
*handle
,
1407 struct ocfs2_dir_lookup_result
*res
)
1409 if (ocfs2_dir_indexed(dir
))
1410 return ocfs2_delete_entry_dx(handle
, dir
, res
);
1412 if (OCFS2_I(dir
)->ip_dyn_features
& OCFS2_INLINE_DATA_FL
)
1413 return ocfs2_delete_entry_id(handle
, dir
, res
->dl_entry
,
1416 return ocfs2_delete_entry_el(handle
, dir
, res
->dl_entry
,
1421 * Check whether 'de' has enough room to hold an entry of
1422 * 'new_rec_len' bytes.
1424 static inline int ocfs2_dirent_would_fit(struct ocfs2_dir_entry
*de
,
1425 unsigned int new_rec_len
)
1427 unsigned int de_really_used
;
1429 /* Check whether this is an empty record with enough space */
1430 if (le64_to_cpu(de
->inode
) == 0 &&
1431 le16_to_cpu(de
->rec_len
) >= new_rec_len
)
1435 * Record might have free space at the end which we can
1438 de_really_used
= OCFS2_DIR_REC_LEN(de
->name_len
);
1439 if (le16_to_cpu(de
->rec_len
) >= (de_really_used
+ new_rec_len
))
1445 static void ocfs2_dx_dir_leaf_insert_tail(struct ocfs2_dx_leaf
*dx_leaf
,
1446 struct ocfs2_dx_entry
*dx_new_entry
)
1450 i
= le16_to_cpu(dx_leaf
->dl_list
.de_num_used
);
1451 dx_leaf
->dl_list
.de_entries
[i
] = *dx_new_entry
;
1453 le16_add_cpu(&dx_leaf
->dl_list
.de_num_used
, 1);
1456 static void ocfs2_dx_entry_list_insert(struct ocfs2_dx_entry_list
*entry_list
,
1457 struct ocfs2_dx_hinfo
*hinfo
,
1461 struct ocfs2_dx_entry
*dx_entry
;
1463 i
= le16_to_cpu(entry_list
->de_num_used
);
1464 dx_entry
= &entry_list
->de_entries
[i
];
1466 memset(dx_entry
, 0, sizeof(*dx_entry
));
1467 dx_entry
->dx_major_hash
= cpu_to_le32(hinfo
->major_hash
);
1468 dx_entry
->dx_minor_hash
= cpu_to_le32(hinfo
->minor_hash
);
1469 dx_entry
->dx_dirent_blk
= cpu_to_le64(dirent_blk
);
1471 le16_add_cpu(&entry_list
->de_num_used
, 1);
1474 static int __ocfs2_dx_dir_leaf_insert(struct inode
*dir
, handle_t
*handle
,
1475 struct ocfs2_dx_hinfo
*hinfo
,
1477 struct buffer_head
*dx_leaf_bh
)
1480 struct ocfs2_dx_leaf
*dx_leaf
;
1482 ret
= ocfs2_journal_access_dl(handle
, INODE_CACHE(dir
), dx_leaf_bh
,
1483 OCFS2_JOURNAL_ACCESS_WRITE
);
1489 dx_leaf
= (struct ocfs2_dx_leaf
*)dx_leaf_bh
->b_data
;
1490 ocfs2_dx_entry_list_insert(&dx_leaf
->dl_list
, hinfo
, dirent_blk
);
1491 ocfs2_journal_dirty(handle
, dx_leaf_bh
);
1497 static void ocfs2_dx_inline_root_insert(struct inode
*dir
, handle_t
*handle
,
1498 struct ocfs2_dx_hinfo
*hinfo
,
1500 struct ocfs2_dx_root_block
*dx_root
)
1502 ocfs2_dx_entry_list_insert(&dx_root
->dr_entries
, hinfo
, dirent_blk
);
1505 static int ocfs2_dx_dir_insert(struct inode
*dir
, handle_t
*handle
,
1506 struct ocfs2_dir_lookup_result
*lookup
)
1509 struct ocfs2_dx_root_block
*dx_root
;
1510 struct buffer_head
*dx_root_bh
= lookup
->dl_dx_root_bh
;
1512 ret
= ocfs2_journal_access_dr(handle
, INODE_CACHE(dir
), dx_root_bh
,
1513 OCFS2_JOURNAL_ACCESS_WRITE
);
1519 dx_root
= (struct ocfs2_dx_root_block
*)lookup
->dl_dx_root_bh
->b_data
;
1520 if (ocfs2_dx_root_inline(dx_root
)) {
1521 ocfs2_dx_inline_root_insert(dir
, handle
,
1523 lookup
->dl_leaf_bh
->b_blocknr
,
1526 ret
= __ocfs2_dx_dir_leaf_insert(dir
, handle
, &lookup
->dl_hinfo
,
1527 lookup
->dl_leaf_bh
->b_blocknr
,
1528 lookup
->dl_dx_leaf_bh
);
1533 le32_add_cpu(&dx_root
->dr_num_entries
, 1);
1534 ocfs2_journal_dirty(handle
, dx_root_bh
);
1540 static void ocfs2_remove_block_from_free_list(struct inode
*dir
,
1542 struct ocfs2_dir_lookup_result
*lookup
)
1544 struct ocfs2_dir_block_trailer
*trailer
, *prev
;
1545 struct ocfs2_dx_root_block
*dx_root
;
1546 struct buffer_head
*bh
;
1548 trailer
= ocfs2_trailer_from_bh(lookup
->dl_leaf_bh
, dir
->i_sb
);
1550 if (ocfs2_free_list_at_root(lookup
)) {
1551 bh
= lookup
->dl_dx_root_bh
;
1552 dx_root
= (struct ocfs2_dx_root_block
*)bh
->b_data
;
1553 dx_root
->dr_free_blk
= trailer
->db_free_next
;
1555 bh
= lookup
->dl_prev_leaf_bh
;
1556 prev
= ocfs2_trailer_from_bh(bh
, dir
->i_sb
);
1557 prev
->db_free_next
= trailer
->db_free_next
;
1560 trailer
->db_free_rec_len
= cpu_to_le16(0);
1561 trailer
->db_free_next
= cpu_to_le64(0);
1563 ocfs2_journal_dirty(handle
, bh
);
1564 ocfs2_journal_dirty(handle
, lookup
->dl_leaf_bh
);
1568 * This expects that a journal write has been reserved on
1569 * lookup->dl_prev_leaf_bh or lookup->dl_dx_root_bh
1571 static void ocfs2_recalc_free_list(struct inode
*dir
, handle_t
*handle
,
1572 struct ocfs2_dir_lookup_result
*lookup
)
1575 struct ocfs2_dir_block_trailer
*trailer
;
1577 /* Walk dl_leaf_bh to figure out what the new free rec_len is. */
1578 max_rec_len
= ocfs2_find_max_rec_len(dir
->i_sb
, lookup
->dl_leaf_bh
);
1581 * There's still room in this block, so no need to remove it
1582 * from the free list. In this case, we just want to update
1583 * the rec len accounting.
1585 trailer
= ocfs2_trailer_from_bh(lookup
->dl_leaf_bh
, dir
->i_sb
);
1586 trailer
->db_free_rec_len
= cpu_to_le16(max_rec_len
);
1587 ocfs2_journal_dirty(handle
, lookup
->dl_leaf_bh
);
1589 ocfs2_remove_block_from_free_list(dir
, handle
, lookup
);
1593 /* we don't always have a dentry for what we want to add, so people
1594 * like orphan dir can call this instead.
1596 * The lookup context must have been filled from
1597 * ocfs2_prepare_dir_for_insert.
1599 int __ocfs2_add_entry(handle_t
*handle
,
1601 const char *name
, int namelen
,
1602 struct inode
*inode
, u64 blkno
,
1603 struct buffer_head
*parent_fe_bh
,
1604 struct ocfs2_dir_lookup_result
*lookup
)
1606 unsigned long offset
;
1607 unsigned short rec_len
;
1608 struct ocfs2_dir_entry
*de
, *de1
;
1609 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)parent_fe_bh
->b_data
;
1610 struct super_block
*sb
= dir
->i_sb
;
1612 unsigned int size
= sb
->s_blocksize
;
1613 struct buffer_head
*insert_bh
= lookup
->dl_leaf_bh
;
1614 char *data_start
= insert_bh
->b_data
;
1619 if (ocfs2_dir_indexed(dir
)) {
1620 struct buffer_head
*bh
;
1623 * An indexed dir may require that we update the free space
1624 * list. Reserve a write to the previous node in the list so
1625 * that we don't fail later.
1627 * XXX: This can be either a dx_root_block, or an unindexed
1628 * directory tree leaf block.
1630 if (ocfs2_free_list_at_root(lookup
)) {
1631 bh
= lookup
->dl_dx_root_bh
;
1632 retval
= ocfs2_journal_access_dr(handle
,
1633 INODE_CACHE(dir
), bh
,
1634 OCFS2_JOURNAL_ACCESS_WRITE
);
1636 bh
= lookup
->dl_prev_leaf_bh
;
1637 retval
= ocfs2_journal_access_db(handle
,
1638 INODE_CACHE(dir
), bh
,
1639 OCFS2_JOURNAL_ACCESS_WRITE
);
1645 } else if (OCFS2_I(dir
)->ip_dyn_features
& OCFS2_INLINE_DATA_FL
) {
1646 data_start
= di
->id2
.i_data
.id_data
;
1647 size
= i_size_read(dir
);
1649 BUG_ON(insert_bh
!= parent_fe_bh
);
1652 rec_len
= OCFS2_DIR_REC_LEN(namelen
);
1654 de
= (struct ocfs2_dir_entry
*) data_start
;
1656 BUG_ON((char *)de
>= (size
+ data_start
));
1658 /* These checks should've already been passed by the
1659 * prepare function, but I guess we can leave them
1661 if (!ocfs2_check_dir_entry(dir
, de
, insert_bh
, offset
)) {
1665 if (ocfs2_match(namelen
, name
, de
)) {
1670 /* We're guaranteed that we should have space, so we
1671 * can't possibly have hit the trailer...right? */
1672 mlog_bug_on_msg(ocfs2_skip_dir_trailer(dir
, de
, offset
, size
),
1673 "Hit dir trailer trying to insert %.*s "
1674 "(namelen %d) into directory %llu. "
1675 "offset is %lu, trailer offset is %d\n",
1676 namelen
, name
, namelen
,
1677 (unsigned long long)parent_fe_bh
->b_blocknr
,
1678 offset
, ocfs2_dir_trailer_blk_off(dir
->i_sb
));
1680 if (ocfs2_dirent_would_fit(de
, rec_len
)) {
1681 dir
->i_mtime
= dir
->i_ctime
= current_time(dir
);
1682 retval
= ocfs2_mark_inode_dirty(handle
, dir
, parent_fe_bh
);
1688 if (insert_bh
== parent_fe_bh
)
1689 retval
= ocfs2_journal_access_di(handle
,
1692 OCFS2_JOURNAL_ACCESS_WRITE
);
1694 retval
= ocfs2_journal_access_db(handle
,
1697 OCFS2_JOURNAL_ACCESS_WRITE
);
1699 if (!retval
&& ocfs2_dir_indexed(dir
))
1700 retval
= ocfs2_dx_dir_insert(dir
,
1710 /* By now the buffer is marked for journaling */
1711 offset
+= le16_to_cpu(de
->rec_len
);
1712 if (le64_to_cpu(de
->inode
)) {
1713 de1
= (struct ocfs2_dir_entry
*)((char *) de
+
1714 OCFS2_DIR_REC_LEN(de
->name_len
));
1716 cpu_to_le16(le16_to_cpu(de
->rec_len
) -
1717 OCFS2_DIR_REC_LEN(de
->name_len
));
1718 de
->rec_len
= cpu_to_le16(OCFS2_DIR_REC_LEN(de
->name_len
));
1721 de
->file_type
= OCFS2_FT_UNKNOWN
;
1723 de
->inode
= cpu_to_le64(blkno
);
1724 ocfs2_set_de_type(de
, inode
->i_mode
);
1727 de
->name_len
= namelen
;
1728 memcpy(de
->name
, name
, namelen
);
1730 if (ocfs2_dir_indexed(dir
))
1731 ocfs2_recalc_free_list(dir
, handle
, lookup
);
1733 inode_inc_iversion(dir
);
1734 ocfs2_journal_dirty(handle
, insert_bh
);
1739 offset
+= le16_to_cpu(de
->rec_len
);
1740 de
= (struct ocfs2_dir_entry
*) ((char *) de
+ le16_to_cpu(de
->rec_len
));
1743 /* when you think about it, the assert above should prevent us
1744 * from ever getting here. */
1753 static int ocfs2_dir_foreach_blk_id(struct inode
*inode
,
1755 struct dir_context
*ctx
)
1758 unsigned long offset
= ctx
->pos
;
1759 struct buffer_head
*di_bh
= NULL
;
1760 struct ocfs2_dinode
*di
;
1761 struct ocfs2_inline_data
*data
;
1762 struct ocfs2_dir_entry
*de
;
1764 ret
= ocfs2_read_inode_block(inode
, &di_bh
);
1766 mlog(ML_ERROR
, "Unable to read inode block for dir %llu\n",
1767 (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
1771 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
1772 data
= &di
->id2
.i_data
;
1774 while (ctx
->pos
< i_size_read(inode
)) {
1775 /* If the dir block has changed since the last call to
1776 * readdir(2), then we might be pointing to an invalid
1777 * dirent right now. Scan from the start of the block
1779 if (!inode_eq_iversion(inode
, *f_version
)) {
1780 for (i
= 0; i
< i_size_read(inode
) && i
< offset
; ) {
1781 de
= (struct ocfs2_dir_entry
*)
1782 (data
->id_data
+ i
);
1783 /* It's too expensive to do a full
1784 * dirent test each time round this
1785 * loop, but we do have to test at
1786 * least that it is non-zero. A
1787 * failure will be detected in the
1788 * dirent test below. */
1789 if (le16_to_cpu(de
->rec_len
) <
1790 OCFS2_DIR_REC_LEN(1))
1792 i
+= le16_to_cpu(de
->rec_len
);
1794 ctx
->pos
= offset
= i
;
1795 *f_version
= inode_query_iversion(inode
);
1798 de
= (struct ocfs2_dir_entry
*) (data
->id_data
+ ctx
->pos
);
1799 if (!ocfs2_check_dir_entry(inode
, de
, di_bh
, ctx
->pos
)) {
1800 /* On error, skip the f_pos to the end. */
1801 ctx
->pos
= i_size_read(inode
);
1804 offset
+= le16_to_cpu(de
->rec_len
);
1805 if (le64_to_cpu(de
->inode
)) {
1806 unsigned char d_type
= DT_UNKNOWN
;
1808 if (de
->file_type
< OCFS2_FT_MAX
)
1809 d_type
= ocfs2_filetype_table
[de
->file_type
];
1811 if (!dir_emit(ctx
, de
->name
, de
->name_len
,
1812 le64_to_cpu(de
->inode
), d_type
))
1815 ctx
->pos
+= le16_to_cpu(de
->rec_len
);
1823 * NOTE: This function can be called against unindexed directories,
1826 static int ocfs2_dir_foreach_blk_el(struct inode
*inode
,
1828 struct dir_context
*ctx
,
1831 unsigned long offset
, blk
, last_ra_blk
= 0;
1833 struct buffer_head
* bh
, * tmp
;
1834 struct ocfs2_dir_entry
* de
;
1835 struct super_block
* sb
= inode
->i_sb
;
1836 unsigned int ra_sectors
= 16;
1841 offset
= ctx
->pos
& (sb
->s_blocksize
- 1);
1843 while (ctx
->pos
< i_size_read(inode
)) {
1844 blk
= ctx
->pos
>> sb
->s_blocksize_bits
;
1845 if (ocfs2_read_dir_block(inode
, blk
, &bh
, 0)) {
1846 /* Skip the corrupt dirblock and keep trying */
1847 ctx
->pos
+= sb
->s_blocksize
- offset
;
1851 /* The idea here is to begin with 8k read-ahead and to stay
1852 * 4k ahead of our current position.
1854 * TODO: Use the pagecache for this. We just need to
1855 * make sure it's cluster-safe... */
1857 || (((last_ra_blk
- blk
) << 9) <= (ra_sectors
/ 2))) {
1858 for (i
= ra_sectors
>> (sb
->s_blocksize_bits
- 9);
1861 if (!ocfs2_read_dir_block(inode
, ++blk
, &tmp
,
1862 OCFS2_BH_READAHEAD
))
1869 /* If the dir block has changed since the last call to
1870 * readdir(2), then we might be pointing to an invalid
1871 * dirent right now. Scan from the start of the block
1873 if (!inode_eq_iversion(inode
, *f_version
)) {
1874 for (i
= 0; i
< sb
->s_blocksize
&& i
< offset
; ) {
1875 de
= (struct ocfs2_dir_entry
*) (bh
->b_data
+ i
);
1876 /* It's too expensive to do a full
1877 * dirent test each time round this
1878 * loop, but we do have to test at
1879 * least that it is non-zero. A
1880 * failure will be detected in the
1881 * dirent test below. */
1882 if (le16_to_cpu(de
->rec_len
) <
1883 OCFS2_DIR_REC_LEN(1))
1885 i
+= le16_to_cpu(de
->rec_len
);
1888 ctx
->pos
= (ctx
->pos
& ~(sb
->s_blocksize
- 1))
1890 *f_version
= inode_query_iversion(inode
);
1893 while (ctx
->pos
< i_size_read(inode
)
1894 && offset
< sb
->s_blocksize
) {
1895 de
= (struct ocfs2_dir_entry
*) (bh
->b_data
+ offset
);
1896 if (!ocfs2_check_dir_entry(inode
, de
, bh
, offset
)) {
1897 /* On error, skip the f_pos to the
1899 ctx
->pos
= (ctx
->pos
| (sb
->s_blocksize
- 1)) + 1;
1902 if (le64_to_cpu(de
->inode
)) {
1903 unsigned char d_type
= DT_UNKNOWN
;
1905 if (de
->file_type
< OCFS2_FT_MAX
)
1906 d_type
= ocfs2_filetype_table
[de
->file_type
];
1907 if (!dir_emit(ctx
, de
->name
,
1909 le64_to_cpu(de
->inode
),
1916 offset
+= le16_to_cpu(de
->rec_len
);
1917 ctx
->pos
+= le16_to_cpu(de
->rec_len
);
1922 if (!persist
&& stored
)
1928 static int ocfs2_dir_foreach_blk(struct inode
*inode
, u64
*f_version
,
1929 struct dir_context
*ctx
,
1932 if (OCFS2_I(inode
)->ip_dyn_features
& OCFS2_INLINE_DATA_FL
)
1933 return ocfs2_dir_foreach_blk_id(inode
, f_version
, ctx
);
1934 return ocfs2_dir_foreach_blk_el(inode
, f_version
, ctx
, persist
);
1938 * This is intended to be called from inside other kernel functions,
1939 * so we fake some arguments.
1941 int ocfs2_dir_foreach(struct inode
*inode
, struct dir_context
*ctx
)
1943 u64 version
= inode_query_iversion(inode
);
1944 ocfs2_dir_foreach_blk(inode
, &version
, ctx
, true);
1952 int ocfs2_readdir(struct file
*file
, struct dir_context
*ctx
)
1955 struct inode
*inode
= file_inode(file
);
1958 trace_ocfs2_readdir((unsigned long long)OCFS2_I(inode
)->ip_blkno
);
1960 error
= ocfs2_inode_lock_atime(inode
, file
->f_path
.mnt
, &lock_level
, 1);
1961 if (lock_level
&& error
>= 0) {
1962 /* We release EX lock which used to update atime
1963 * and get PR lock again to reduce contention
1964 * on commonly accessed directories. */
1965 ocfs2_inode_unlock(inode
, 1);
1967 error
= ocfs2_inode_lock(inode
, NULL
, 0);
1970 if (error
!= -ENOENT
)
1972 /* we haven't got any yet, so propagate the error. */
1976 error
= ocfs2_dir_foreach_blk(inode
, &file
->f_version
, ctx
, false);
1978 ocfs2_inode_unlock(inode
, lock_level
);
1988 * NOTE: this should always be called with parent dir i_mutex taken.
1990 int ocfs2_find_files_on_disk(const char *name
,
1993 struct inode
*inode
,
1994 struct ocfs2_dir_lookup_result
*lookup
)
1996 int status
= -ENOENT
;
1998 trace_ocfs2_find_files_on_disk(namelen
, name
, blkno
,
1999 (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
2001 status
= ocfs2_find_entry(name
, namelen
, inode
, lookup
);
2005 *blkno
= le64_to_cpu(lookup
->dl_entry
->inode
);
2014 * Convenience function for callers which just want the block number
2015 * mapped to a name and don't require the full dirent info, etc.
2017 int ocfs2_lookup_ino_from_name(struct inode
*dir
, const char *name
,
2018 int namelen
, u64
*blkno
)
2021 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
2023 ret
= ocfs2_find_files_on_disk(name
, namelen
, blkno
, dir
, &lookup
);
2024 ocfs2_free_dir_lookup_result(&lookup
);
2029 /* Check for a name within a directory.
2031 * Return 0 if the name does not exist
2032 * Return -EEXIST if the directory contains the name
2034 * Callers should have i_mutex + a cluster lock on dir
2036 int ocfs2_check_dir_for_entry(struct inode
*dir
,
2041 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
2043 trace_ocfs2_check_dir_for_entry(
2044 (unsigned long long)OCFS2_I(dir
)->ip_blkno
, namelen
, name
);
2046 if (ocfs2_find_entry(name
, namelen
, dir
, &lookup
) == 0) {
2051 ocfs2_free_dir_lookup_result(&lookup
);
2056 struct ocfs2_empty_dir_priv
{
2057 struct dir_context ctx
;
2059 unsigned seen_dot_dot
;
2060 unsigned seen_other
;
2063 static int ocfs2_empty_dir_filldir(struct dir_context
*ctx
, const char *name
,
2064 int name_len
, loff_t pos
, u64 ino
,
2067 struct ocfs2_empty_dir_priv
*p
=
2068 container_of(ctx
, struct ocfs2_empty_dir_priv
, ctx
);
2071 * Check the positions of "." and ".." records to be sure
2072 * they're in the correct place.
2074 * Indexed directories don't need to proceed past the first
2075 * two entries, so we end the scan after seeing '..'. Despite
2076 * that, we allow the scan to proceed In the event that we
2077 * have a corrupted indexed directory (no dot or dot dot
2078 * entries). This allows us to double check for existing
2079 * entries which might not have been found in the index.
2081 if (name_len
== 1 && !strncmp(".", name
, 1) && pos
== 0) {
2086 if (name_len
== 2 && !strncmp("..", name
, 2) &&
2087 pos
== OCFS2_DIR_REC_LEN(1)) {
2088 p
->seen_dot_dot
= 1;
2090 if (p
->dx_dir
&& p
->seen_dot
)
2100 static int ocfs2_empty_dir_dx(struct inode
*inode
,
2101 struct ocfs2_empty_dir_priv
*priv
)
2104 struct buffer_head
*di_bh
= NULL
;
2105 struct buffer_head
*dx_root_bh
= NULL
;
2106 struct ocfs2_dinode
*di
;
2107 struct ocfs2_dx_root_block
*dx_root
;
2111 ret
= ocfs2_read_inode_block(inode
, &di_bh
);
2116 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
2118 ret
= ocfs2_read_dx_root(inode
, di
, &dx_root_bh
);
2123 dx_root
= (struct ocfs2_dx_root_block
*)dx_root_bh
->b_data
;
2125 if (le32_to_cpu(dx_root
->dr_num_entries
) != 2)
2126 priv
->seen_other
= 1;
2135 * routine to check that the specified directory is empty (for rmdir)
2137 * Returns 1 if dir is empty, zero otherwise.
2139 * XXX: This is a performance problem for unindexed directories.
2141 int ocfs2_empty_dir(struct inode
*inode
)
2144 struct ocfs2_empty_dir_priv priv
= {
2145 .ctx
.actor
= ocfs2_empty_dir_filldir
,
2148 if (ocfs2_dir_indexed(inode
)) {
2149 ret
= ocfs2_empty_dir_dx(inode
, &priv
);
2153 * We still run ocfs2_dir_foreach to get the checks
2158 ret
= ocfs2_dir_foreach(inode
, &priv
.ctx
);
2162 if (!priv
.seen_dot
|| !priv
.seen_dot_dot
) {
2163 mlog(ML_ERROR
, "bad directory (dir #%llu) - no `.' or `..'\n",
2164 (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
2166 * XXX: Is it really safe to allow an unlink to continue?
2171 return !priv
.seen_other
;
2175 * Fills "." and ".." dirents in a new directory block. Returns dirent for
2176 * "..", which might be used during creation of a directory with a trailing
2177 * header. It is otherwise safe to ignore the return code.
2179 static struct ocfs2_dir_entry
*ocfs2_fill_initial_dirents(struct inode
*inode
,
2180 struct inode
*parent
,
2184 struct ocfs2_dir_entry
*de
= (struct ocfs2_dir_entry
*)start
;
2186 de
->inode
= cpu_to_le64(OCFS2_I(inode
)->ip_blkno
);
2189 cpu_to_le16(OCFS2_DIR_REC_LEN(de
->name_len
));
2190 strcpy(de
->name
, ".");
2191 ocfs2_set_de_type(de
, S_IFDIR
);
2193 de
= (struct ocfs2_dir_entry
*) ((char *)de
+ le16_to_cpu(de
->rec_len
));
2194 de
->inode
= cpu_to_le64(OCFS2_I(parent
)->ip_blkno
);
2195 de
->rec_len
= cpu_to_le16(size
- OCFS2_DIR_REC_LEN(1));
2197 strcpy(de
->name
, "..");
2198 ocfs2_set_de_type(de
, S_IFDIR
);
2204 * This works together with code in ocfs2_mknod_locked() which sets
2205 * the inline-data flag and initializes the inline-data section.
2207 static int ocfs2_fill_new_dir_id(struct ocfs2_super
*osb
,
2209 struct inode
*parent
,
2210 struct inode
*inode
,
2211 struct buffer_head
*di_bh
)
2214 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
2215 struct ocfs2_inline_data
*data
= &di
->id2
.i_data
;
2216 unsigned int size
= le16_to_cpu(data
->id_count
);
2218 ret
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
), di_bh
,
2219 OCFS2_JOURNAL_ACCESS_WRITE
);
2225 ocfs2_fill_initial_dirents(inode
, parent
, data
->id_data
, size
);
2226 ocfs2_journal_dirty(handle
, di_bh
);
2228 i_size_write(inode
, size
);
2229 set_nlink(inode
, 2);
2230 inode
->i_blocks
= ocfs2_inode_sector_count(inode
);
2232 ret
= ocfs2_mark_inode_dirty(handle
, inode
, di_bh
);
2240 static int ocfs2_fill_new_dir_el(struct ocfs2_super
*osb
,
2242 struct inode
*parent
,
2243 struct inode
*inode
,
2244 struct buffer_head
*fe_bh
,
2245 struct ocfs2_alloc_context
*data_ac
,
2246 struct buffer_head
**ret_new_bh
)
2249 unsigned int size
= osb
->sb
->s_blocksize
;
2250 struct buffer_head
*new_bh
= NULL
;
2251 struct ocfs2_dir_entry
*de
;
2253 if (ocfs2_new_dir_wants_trailer(inode
))
2254 size
= ocfs2_dir_trailer_blk_off(parent
->i_sb
);
2256 status
= ocfs2_do_extend_dir(osb
->sb
, handle
, inode
, fe_bh
,
2257 data_ac
, NULL
, &new_bh
);
2263 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode
), new_bh
);
2265 status
= ocfs2_journal_access_db(handle
, INODE_CACHE(inode
), new_bh
,
2266 OCFS2_JOURNAL_ACCESS_CREATE
);
2271 memset(new_bh
->b_data
, 0, osb
->sb
->s_blocksize
);
2273 de
= ocfs2_fill_initial_dirents(inode
, parent
, new_bh
->b_data
, size
);
2274 if (ocfs2_new_dir_wants_trailer(inode
)) {
2275 int size
= le16_to_cpu(de
->rec_len
);
2278 * Figure out the size of the hole left over after
2279 * insertion of '.' and '..'. The trailer wants this
2282 size
-= OCFS2_DIR_REC_LEN(2);
2283 size
-= sizeof(struct ocfs2_dir_block_trailer
);
2285 ocfs2_init_dir_trailer(inode
, new_bh
, size
);
2288 ocfs2_journal_dirty(handle
, new_bh
);
2290 i_size_write(inode
, inode
->i_sb
->s_blocksize
);
2291 set_nlink(inode
, 2);
2292 inode
->i_blocks
= ocfs2_inode_sector_count(inode
);
2293 status
= ocfs2_mark_inode_dirty(handle
, inode
, fe_bh
);
2301 *ret_new_bh
= new_bh
;
2310 static int ocfs2_dx_dir_attach_index(struct ocfs2_super
*osb
,
2311 handle_t
*handle
, struct inode
*dir
,
2312 struct buffer_head
*di_bh
,
2313 struct buffer_head
*dirdata_bh
,
2314 struct ocfs2_alloc_context
*meta_ac
,
2315 int dx_inline
, u32 num_entries
,
2316 struct buffer_head
**ret_dx_root_bh
)
2319 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*) di_bh
->b_data
;
2320 u16 dr_suballoc_bit
;
2321 u64 suballoc_loc
, dr_blkno
;
2322 unsigned int num_bits
;
2323 struct buffer_head
*dx_root_bh
= NULL
;
2324 struct ocfs2_dx_root_block
*dx_root
;
2325 struct ocfs2_dir_block_trailer
*trailer
=
2326 ocfs2_trailer_from_bh(dirdata_bh
, dir
->i_sb
);
2328 ret
= ocfs2_claim_metadata(handle
, meta_ac
, 1, &suballoc_loc
,
2329 &dr_suballoc_bit
, &num_bits
, &dr_blkno
);
2335 trace_ocfs2_dx_dir_attach_index(
2336 (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
2337 (unsigned long long)dr_blkno
);
2339 dx_root_bh
= sb_getblk(osb
->sb
, dr_blkno
);
2340 if (dx_root_bh
== NULL
) {
2344 ocfs2_set_new_buffer_uptodate(INODE_CACHE(dir
), dx_root_bh
);
2346 ret
= ocfs2_journal_access_dr(handle
, INODE_CACHE(dir
), dx_root_bh
,
2347 OCFS2_JOURNAL_ACCESS_CREATE
);
2353 dx_root
= (struct ocfs2_dx_root_block
*)dx_root_bh
->b_data
;
2354 memset(dx_root
, 0, osb
->sb
->s_blocksize
);
2355 strcpy(dx_root
->dr_signature
, OCFS2_DX_ROOT_SIGNATURE
);
2356 dx_root
->dr_suballoc_slot
= cpu_to_le16(meta_ac
->ac_alloc_slot
);
2357 dx_root
->dr_suballoc_loc
= cpu_to_le64(suballoc_loc
);
2358 dx_root
->dr_suballoc_bit
= cpu_to_le16(dr_suballoc_bit
);
2359 dx_root
->dr_fs_generation
= cpu_to_le32(osb
->fs_generation
);
2360 dx_root
->dr_blkno
= cpu_to_le64(dr_blkno
);
2361 dx_root
->dr_dir_blkno
= cpu_to_le64(OCFS2_I(dir
)->ip_blkno
);
2362 dx_root
->dr_num_entries
= cpu_to_le32(num_entries
);
2363 if (le16_to_cpu(trailer
->db_free_rec_len
))
2364 dx_root
->dr_free_blk
= cpu_to_le64(dirdata_bh
->b_blocknr
);
2366 dx_root
->dr_free_blk
= cpu_to_le64(0);
2369 dx_root
->dr_flags
|= OCFS2_DX_FLAG_INLINE
;
2370 dx_root
->dr_entries
.de_count
=
2371 cpu_to_le16(ocfs2_dx_entries_per_root(osb
->sb
));
2373 dx_root
->dr_list
.l_count
=
2374 cpu_to_le16(ocfs2_extent_recs_per_dx_root(osb
->sb
));
2376 ocfs2_journal_dirty(handle
, dx_root_bh
);
2378 ret
= ocfs2_journal_access_di(handle
, INODE_CACHE(dir
), di_bh
,
2379 OCFS2_JOURNAL_ACCESS_CREATE
);
2385 di
->i_dx_root
= cpu_to_le64(dr_blkno
);
2387 spin_lock(&OCFS2_I(dir
)->ip_lock
);
2388 OCFS2_I(dir
)->ip_dyn_features
|= OCFS2_INDEXED_DIR_FL
;
2389 di
->i_dyn_features
= cpu_to_le16(OCFS2_I(dir
)->ip_dyn_features
);
2390 spin_unlock(&OCFS2_I(dir
)->ip_lock
);
2392 ocfs2_journal_dirty(handle
, di_bh
);
2394 *ret_dx_root_bh
= dx_root_bh
;
2402 static int ocfs2_dx_dir_format_cluster(struct ocfs2_super
*osb
,
2403 handle_t
*handle
, struct inode
*dir
,
2404 struct buffer_head
**dx_leaves
,
2405 int num_dx_leaves
, u64 start_blk
)
2408 struct ocfs2_dx_leaf
*dx_leaf
;
2409 struct buffer_head
*bh
;
2411 for (i
= 0; i
< num_dx_leaves
; i
++) {
2412 bh
= sb_getblk(osb
->sb
, start_blk
+ i
);
2419 ocfs2_set_new_buffer_uptodate(INODE_CACHE(dir
), bh
);
2421 ret
= ocfs2_journal_access_dl(handle
, INODE_CACHE(dir
), bh
,
2422 OCFS2_JOURNAL_ACCESS_CREATE
);
2428 dx_leaf
= (struct ocfs2_dx_leaf
*) bh
->b_data
;
2430 memset(dx_leaf
, 0, osb
->sb
->s_blocksize
);
2431 strcpy(dx_leaf
->dl_signature
, OCFS2_DX_LEAF_SIGNATURE
);
2432 dx_leaf
->dl_fs_generation
= cpu_to_le32(osb
->fs_generation
);
2433 dx_leaf
->dl_blkno
= cpu_to_le64(bh
->b_blocknr
);
2434 dx_leaf
->dl_list
.de_count
=
2435 cpu_to_le16(ocfs2_dx_entries_per_leaf(osb
->sb
));
2437 trace_ocfs2_dx_dir_format_cluster(
2438 (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
2439 (unsigned long long)bh
->b_blocknr
,
2440 le16_to_cpu(dx_leaf
->dl_list
.de_count
));
2442 ocfs2_journal_dirty(handle
, bh
);
2451 * Allocates and formats a new cluster for use in an indexed dir
2452 * leaf. This version will not do the extent insert, so that it can be
2453 * used by operations which need careful ordering.
2455 static int __ocfs2_dx_dir_new_cluster(struct inode
*dir
,
2456 u32 cpos
, handle_t
*handle
,
2457 struct ocfs2_alloc_context
*data_ac
,
2458 struct buffer_head
**dx_leaves
,
2459 int num_dx_leaves
, u64
*ret_phys_blkno
)
2464 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
2467 * XXX: For create, this should claim cluster for the index
2468 * *before* the unindexed insert so that we have a better
2469 * chance of contiguousness as the directory grows in number
2472 ret
= __ocfs2_claim_clusters(handle
, data_ac
, 1, 1, &phys
, &num
);
2479 * Format the new cluster first. That way, we're inserting
2482 phys_blkno
= ocfs2_clusters_to_blocks(osb
->sb
, phys
);
2483 ret
= ocfs2_dx_dir_format_cluster(osb
, handle
, dir
, dx_leaves
,
2484 num_dx_leaves
, phys_blkno
);
2490 *ret_phys_blkno
= phys_blkno
;
2495 static int ocfs2_dx_dir_new_cluster(struct inode
*dir
,
2496 struct ocfs2_extent_tree
*et
,
2497 u32 cpos
, handle_t
*handle
,
2498 struct ocfs2_alloc_context
*data_ac
,
2499 struct ocfs2_alloc_context
*meta_ac
,
2500 struct buffer_head
**dx_leaves
,
2506 ret
= __ocfs2_dx_dir_new_cluster(dir
, cpos
, handle
, data_ac
, dx_leaves
,
2507 num_dx_leaves
, &phys_blkno
);
2513 ret
= ocfs2_insert_extent(handle
, et
, cpos
, phys_blkno
, 1, 0,
2521 static struct buffer_head
**ocfs2_dx_dir_kmalloc_leaves(struct super_block
*sb
,
2522 int *ret_num_leaves
)
2524 int num_dx_leaves
= ocfs2_clusters_to_blocks(sb
, 1);
2525 struct buffer_head
**dx_leaves
;
2527 dx_leaves
= kcalloc(num_dx_leaves
, sizeof(struct buffer_head
*),
2529 if (dx_leaves
&& ret_num_leaves
)
2530 *ret_num_leaves
= num_dx_leaves
;
2535 static int ocfs2_fill_new_dir_dx(struct ocfs2_super
*osb
,
2537 struct inode
*parent
,
2538 struct inode
*inode
,
2539 struct buffer_head
*di_bh
,
2540 struct ocfs2_alloc_context
*data_ac
,
2541 struct ocfs2_alloc_context
*meta_ac
)
2544 struct buffer_head
*leaf_bh
= NULL
;
2545 struct buffer_head
*dx_root_bh
= NULL
;
2546 struct ocfs2_dx_hinfo hinfo
;
2547 struct ocfs2_dx_root_block
*dx_root
;
2548 struct ocfs2_dx_entry_list
*entry_list
;
2551 * Our strategy is to create the directory as though it were
2552 * unindexed, then add the index block. This works with very
2553 * little complication since the state of a new directory is a
2554 * very well known quantity.
2556 * Essentially, we have two dirents ("." and ".."), in the 1st
2557 * block which need indexing. These are easily inserted into
2561 ret
= ocfs2_fill_new_dir_el(osb
, handle
, parent
, inode
, di_bh
,
2568 ret
= ocfs2_dx_dir_attach_index(osb
, handle
, inode
, di_bh
, leaf_bh
,
2569 meta_ac
, 1, 2, &dx_root_bh
);
2574 dx_root
= (struct ocfs2_dx_root_block
*)dx_root_bh
->b_data
;
2575 entry_list
= &dx_root
->dr_entries
;
2577 /* Buffer has been journaled for us by ocfs2_dx_dir_attach_index */
2578 ocfs2_dx_dir_name_hash(inode
, ".", 1, &hinfo
);
2579 ocfs2_dx_entry_list_insert(entry_list
, &hinfo
, leaf_bh
->b_blocknr
);
2581 ocfs2_dx_dir_name_hash(inode
, "..", 2, &hinfo
);
2582 ocfs2_dx_entry_list_insert(entry_list
, &hinfo
, leaf_bh
->b_blocknr
);
2590 int ocfs2_fill_new_dir(struct ocfs2_super
*osb
,
2592 struct inode
*parent
,
2593 struct inode
*inode
,
2594 struct buffer_head
*fe_bh
,
2595 struct ocfs2_alloc_context
*data_ac
,
2596 struct ocfs2_alloc_context
*meta_ac
)
2599 BUG_ON(!ocfs2_supports_inline_data(osb
) && data_ac
== NULL
);
2601 if (OCFS2_I(inode
)->ip_dyn_features
& OCFS2_INLINE_DATA_FL
)
2602 return ocfs2_fill_new_dir_id(osb
, handle
, parent
, inode
, fe_bh
);
2604 if (ocfs2_supports_indexed_dirs(osb
))
2605 return ocfs2_fill_new_dir_dx(osb
, handle
, parent
, inode
, fe_bh
,
2608 return ocfs2_fill_new_dir_el(osb
, handle
, parent
, inode
, fe_bh
,
2612 static int ocfs2_dx_dir_index_block(struct inode
*dir
,
2614 struct buffer_head
**dx_leaves
,
2616 u32
*num_dx_entries
,
2617 struct buffer_head
*dirent_bh
)
2619 int ret
= 0, namelen
, i
;
2620 char *de_buf
, *limit
;
2621 struct ocfs2_dir_entry
*de
;
2622 struct buffer_head
*dx_leaf_bh
;
2623 struct ocfs2_dx_hinfo hinfo
;
2624 u64 dirent_blk
= dirent_bh
->b_blocknr
;
2626 de_buf
= dirent_bh
->b_data
;
2627 limit
= de_buf
+ dir
->i_sb
->s_blocksize
;
2629 while (de_buf
< limit
) {
2630 de
= (struct ocfs2_dir_entry
*)de_buf
;
2632 namelen
= de
->name_len
;
2633 if (!namelen
|| !de
->inode
)
2636 ocfs2_dx_dir_name_hash(dir
, de
->name
, namelen
, &hinfo
);
2638 i
= ocfs2_dx_dir_hash_idx(OCFS2_SB(dir
->i_sb
), &hinfo
);
2639 dx_leaf_bh
= dx_leaves
[i
];
2641 ret
= __ocfs2_dx_dir_leaf_insert(dir
, handle
, &hinfo
,
2642 dirent_blk
, dx_leaf_bh
);
2648 *num_dx_entries
= *num_dx_entries
+ 1;
2651 de_buf
+= le16_to_cpu(de
->rec_len
);
2659 * XXX: This expects dx_root_bh to already be part of the transaction.
2661 static void ocfs2_dx_dir_index_root_block(struct inode
*dir
,
2662 struct buffer_head
*dx_root_bh
,
2663 struct buffer_head
*dirent_bh
)
2665 char *de_buf
, *limit
;
2666 struct ocfs2_dx_root_block
*dx_root
;
2667 struct ocfs2_dir_entry
*de
;
2668 struct ocfs2_dx_hinfo hinfo
;
2669 u64 dirent_blk
= dirent_bh
->b_blocknr
;
2671 dx_root
= (struct ocfs2_dx_root_block
*)dx_root_bh
->b_data
;
2673 de_buf
= dirent_bh
->b_data
;
2674 limit
= de_buf
+ dir
->i_sb
->s_blocksize
;
2676 while (de_buf
< limit
) {
2677 de
= (struct ocfs2_dir_entry
*)de_buf
;
2679 if (!de
->name_len
|| !de
->inode
)
2682 ocfs2_dx_dir_name_hash(dir
, de
->name
, de
->name_len
, &hinfo
);
2684 trace_ocfs2_dx_dir_index_root_block(
2685 (unsigned long long)dir
->i_ino
,
2686 hinfo
.major_hash
, hinfo
.minor_hash
,
2687 de
->name_len
, de
->name
,
2688 le16_to_cpu(dx_root
->dr_entries
.de_num_used
));
2690 ocfs2_dx_entry_list_insert(&dx_root
->dr_entries
, &hinfo
,
2693 le32_add_cpu(&dx_root
->dr_num_entries
, 1);
2695 de_buf
+= le16_to_cpu(de
->rec_len
);
2700 * Count the number of inline directory entries in di_bh and compare
2701 * them against the number of entries we can hold in an inline dx root
2704 static int ocfs2_new_dx_should_be_inline(struct inode
*dir
,
2705 struct buffer_head
*di_bh
)
2707 int dirent_count
= 0;
2708 char *de_buf
, *limit
;
2709 struct ocfs2_dir_entry
*de
;
2710 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
2712 de_buf
= di
->id2
.i_data
.id_data
;
2713 limit
= de_buf
+ i_size_read(dir
);
2715 while (de_buf
< limit
) {
2716 de
= (struct ocfs2_dir_entry
*)de_buf
;
2718 if (de
->name_len
&& de
->inode
)
2721 de_buf
+= le16_to_cpu(de
->rec_len
);
2724 /* We are careful to leave room for one extra record. */
2725 return dirent_count
< ocfs2_dx_entries_per_root(dir
->i_sb
);
2729 * Expand rec_len of the rightmost dirent in a directory block so that it
2730 * contains the end of our valid space for dirents. We do this during
2731 * expansion from an inline directory to one with extents. The first dir block
2732 * in that case is taken from the inline data portion of the inode block.
2734 * This will also return the largest amount of contiguous space for a dirent
2735 * in the block. That value is *not* necessarily the last dirent, even after
2736 * expansion. The directory indexing code wants this value for free space
2737 * accounting. We do this here since we're already walking the entire dir
2740 * We add the dir trailer if this filesystem wants it.
2742 static unsigned int ocfs2_expand_last_dirent(char *start
, unsigned int old_size
,
2745 struct super_block
*sb
= dir
->i_sb
;
2746 struct ocfs2_dir_entry
*de
;
2747 struct ocfs2_dir_entry
*prev_de
;
2748 char *de_buf
, *limit
;
2749 unsigned int new_size
= sb
->s_blocksize
;
2750 unsigned int bytes
, this_hole
;
2751 unsigned int largest_hole
= 0;
2753 if (ocfs2_new_dir_wants_trailer(dir
))
2754 new_size
= ocfs2_dir_trailer_blk_off(sb
);
2756 bytes
= new_size
- old_size
;
2758 limit
= start
+ old_size
;
2760 de
= (struct ocfs2_dir_entry
*)de_buf
;
2762 this_hole
= ocfs2_figure_dirent_hole(de
);
2763 if (this_hole
> largest_hole
)
2764 largest_hole
= this_hole
;
2767 de_buf
+= le16_to_cpu(de
->rec_len
);
2768 de
= (struct ocfs2_dir_entry
*)de_buf
;
2769 } while (de_buf
< limit
);
2771 le16_add_cpu(&prev_de
->rec_len
, bytes
);
2773 /* We need to double check this after modification of the final
2775 this_hole
= ocfs2_figure_dirent_hole(prev_de
);
2776 if (this_hole
> largest_hole
)
2777 largest_hole
= this_hole
;
2779 if (largest_hole
>= OCFS2_DIR_MIN_REC_LEN
)
2780 return largest_hole
;
2785 * We allocate enough clusters to fulfill "blocks_wanted", but set
2786 * i_size to exactly one block. Ocfs2_extend_dir() will handle the
2787 * rest automatically for us.
2789 * *first_block_bh is a pointer to the 1st data block allocated to the
2792 static int ocfs2_expand_inline_dir(struct inode
*dir
, struct buffer_head
*di_bh
,
2793 unsigned int blocks_wanted
,
2794 struct ocfs2_dir_lookup_result
*lookup
,
2795 struct buffer_head
**first_block_bh
)
2797 u32 alloc
, dx_alloc
, bit_off
, len
, num_dx_entries
= 0;
2798 struct super_block
*sb
= dir
->i_sb
;
2799 int ret
, i
, num_dx_leaves
= 0, dx_inline
= 0,
2800 credits
= ocfs2_inline_to_extents_credits(sb
);
2801 u64 dx_insert_blkno
, blkno
,
2802 bytes
= blocks_wanted
<< sb
->s_blocksize_bits
;
2803 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
2804 struct ocfs2_inode_info
*oi
= OCFS2_I(dir
);
2805 struct ocfs2_alloc_context
*data_ac
= NULL
;
2806 struct ocfs2_alloc_context
*meta_ac
= NULL
;
2807 struct buffer_head
*dirdata_bh
= NULL
;
2808 struct buffer_head
*dx_root_bh
= NULL
;
2809 struct buffer_head
**dx_leaves
= NULL
;
2810 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
2812 struct ocfs2_extent_tree et
;
2813 struct ocfs2_extent_tree dx_et
;
2814 int did_quota
= 0, bytes_allocated
= 0;
2816 ocfs2_init_dinode_extent_tree(&et
, INODE_CACHE(dir
), di_bh
);
2818 alloc
= ocfs2_clusters_for_bytes(sb
, bytes
);
2821 down_write(&oi
->ip_alloc_sem
);
2823 if (ocfs2_supports_indexed_dirs(osb
)) {
2824 credits
+= ocfs2_add_dir_index_credits(sb
);
2826 dx_inline
= ocfs2_new_dx_should_be_inline(dir
, di_bh
);
2828 /* Add one more cluster for an index leaf */
2830 dx_leaves
= ocfs2_dx_dir_kmalloc_leaves(sb
,
2839 /* This gets us the dx_root */
2840 ret
= ocfs2_reserve_new_metadata_blocks(osb
, 1, &meta_ac
);
2848 * We should never need more than 2 clusters for the unindexed
2849 * tree - maximum dirent size is far less than one block. In
2850 * fact, the only time we'd need more than one cluster is if
2851 * blocksize == clustersize and the dirent won't fit in the
2852 * extra space that the expansion to a single block gives. As
2853 * of today, that only happens on 4k/4k file systems.
2857 ret
= ocfs2_reserve_clusters(osb
, alloc
+ dx_alloc
, &data_ac
);
2864 * Prepare for worst case allocation scenario of two separate
2865 * extents in the unindexed tree.
2868 credits
+= OCFS2_SUBALLOC_ALLOC
;
2870 handle
= ocfs2_start_trans(osb
, credits
);
2871 if (IS_ERR(handle
)) {
2872 ret
= PTR_ERR(handle
);
2877 ret
= dquot_alloc_space_nodirty(dir
,
2878 ocfs2_clusters_to_bytes(osb
->sb
, alloc
+ dx_alloc
));
2883 if (ocfs2_supports_indexed_dirs(osb
) && !dx_inline
) {
2885 * Allocate our index cluster first, to maximize the
2886 * possibility that unindexed leaves grow
2889 ret
= __ocfs2_dx_dir_new_cluster(dir
, 0, handle
, data_ac
,
2890 dx_leaves
, num_dx_leaves
,
2896 bytes_allocated
+= ocfs2_clusters_to_bytes(dir
->i_sb
, 1);
2900 * Try to claim as many clusters as the bitmap can give though
2901 * if we only get one now, that's enough to continue. The rest
2902 * will be claimed after the conversion to extents.
2904 if (ocfs2_dir_resv_allowed(osb
))
2905 data_ac
->ac_resv
= &oi
->ip_la_data_resv
;
2906 ret
= ocfs2_claim_clusters(handle
, data_ac
, 1, &bit_off
, &len
);
2911 bytes_allocated
+= ocfs2_clusters_to_bytes(dir
->i_sb
, 1);
2914 * Operations are carefully ordered so that we set up the new
2915 * data block first. The conversion from inline data to
2918 blkno
= ocfs2_clusters_to_blocks(dir
->i_sb
, bit_off
);
2919 dirdata_bh
= sb_getblk(sb
, blkno
);
2926 ocfs2_set_new_buffer_uptodate(INODE_CACHE(dir
), dirdata_bh
);
2928 ret
= ocfs2_journal_access_db(handle
, INODE_CACHE(dir
), dirdata_bh
,
2929 OCFS2_JOURNAL_ACCESS_CREATE
);
2935 memcpy(dirdata_bh
->b_data
, di
->id2
.i_data
.id_data
, i_size_read(dir
));
2936 memset(dirdata_bh
->b_data
+ i_size_read(dir
), 0,
2937 sb
->s_blocksize
- i_size_read(dir
));
2938 i
= ocfs2_expand_last_dirent(dirdata_bh
->b_data
, i_size_read(dir
), dir
);
2939 if (ocfs2_new_dir_wants_trailer(dir
)) {
2941 * Prepare the dir trailer up front. It will otherwise look
2942 * like a valid dirent. Even if inserting the index fails
2943 * (unlikely), then all we'll have done is given first dir
2944 * block a small amount of fragmentation.
2946 ocfs2_init_dir_trailer(dir
, dirdata_bh
, i
);
2949 ocfs2_update_inode_fsync_trans(handle
, dir
, 1);
2950 ocfs2_journal_dirty(handle
, dirdata_bh
);
2952 if (ocfs2_supports_indexed_dirs(osb
) && !dx_inline
) {
2954 * Dx dirs with an external cluster need to do this up
2955 * front. Inline dx root's get handled later, after
2956 * we've allocated our root block. We get passed back
2957 * a total number of items so that dr_num_entries can
2958 * be correctly set once the dx_root has been
2961 ret
= ocfs2_dx_dir_index_block(dir
, handle
, dx_leaves
,
2962 num_dx_leaves
, &num_dx_entries
,
2971 * Set extent, i_size, etc on the directory. After this, the
2972 * inode should contain the same exact dirents as before and
2973 * be fully accessible from system calls.
2975 * We let the later dirent insert modify c/mtime - to the user
2976 * the data hasn't changed.
2978 ret
= ocfs2_journal_access_di(handle
, INODE_CACHE(dir
), di_bh
,
2979 OCFS2_JOURNAL_ACCESS_CREATE
);
2985 spin_lock(&oi
->ip_lock
);
2986 oi
->ip_dyn_features
&= ~OCFS2_INLINE_DATA_FL
;
2987 di
->i_dyn_features
= cpu_to_le16(oi
->ip_dyn_features
);
2988 spin_unlock(&oi
->ip_lock
);
2990 ocfs2_dinode_new_extent_list(dir
, di
);
2992 i_size_write(dir
, sb
->s_blocksize
);
2993 dir
->i_mtime
= dir
->i_ctime
= current_time(dir
);
2995 di
->i_size
= cpu_to_le64(sb
->s_blocksize
);
2996 di
->i_ctime
= di
->i_mtime
= cpu_to_le64(dir
->i_ctime
.tv_sec
);
2997 di
->i_ctime_nsec
= di
->i_mtime_nsec
= cpu_to_le32(dir
->i_ctime
.tv_nsec
);
2998 ocfs2_update_inode_fsync_trans(handle
, dir
, 1);
3001 * This should never fail as our extent list is empty and all
3002 * related blocks have been journaled already.
3004 ret
= ocfs2_insert_extent(handle
, &et
, 0, blkno
, len
,
3012 * Set i_blocks after the extent insert for the most up to
3013 * date ip_clusters value.
3015 dir
->i_blocks
= ocfs2_inode_sector_count(dir
);
3017 ocfs2_journal_dirty(handle
, di_bh
);
3019 if (ocfs2_supports_indexed_dirs(osb
)) {
3020 ret
= ocfs2_dx_dir_attach_index(osb
, handle
, dir
, di_bh
,
3021 dirdata_bh
, meta_ac
, dx_inline
,
3022 num_dx_entries
, &dx_root_bh
);
3029 ocfs2_dx_dir_index_root_block(dir
, dx_root_bh
,
3032 ocfs2_init_dx_root_extent_tree(&dx_et
,
3035 ret
= ocfs2_insert_extent(handle
, &dx_et
, 0,
3036 dx_insert_blkno
, 1, 0, NULL
);
3043 * We asked for two clusters, but only got one in the 1st
3044 * pass. Claim the 2nd cluster as a separate extent.
3047 ret
= ocfs2_claim_clusters(handle
, data_ac
, 1, &bit_off
,
3053 blkno
= ocfs2_clusters_to_blocks(dir
->i_sb
, bit_off
);
3055 ret
= ocfs2_insert_extent(handle
, &et
, 1,
3056 blkno
, len
, 0, NULL
);
3061 bytes_allocated
+= ocfs2_clusters_to_bytes(dir
->i_sb
, 1);
3064 *first_block_bh
= dirdata_bh
;
3066 if (ocfs2_supports_indexed_dirs(osb
)) {
3071 * We need to return the correct block within the
3072 * cluster which should hold our entry.
3074 off
= ocfs2_dx_dir_hash_idx(osb
,
3076 get_bh(dx_leaves
[off
]);
3077 lookup
->dl_dx_leaf_bh
= dx_leaves
[off
];
3079 lookup
->dl_dx_root_bh
= dx_root_bh
;
3084 if (ret
< 0 && did_quota
)
3085 dquot_free_space_nodirty(dir
, bytes_allocated
);
3087 ocfs2_commit_trans(osb
, handle
);
3090 up_write(&oi
->ip_alloc_sem
);
3092 ocfs2_free_alloc_context(data_ac
);
3094 ocfs2_free_alloc_context(meta_ac
);
3097 for (i
= 0; i
< num_dx_leaves
; i
++)
3098 brelse(dx_leaves
[i
]);
3108 /* returns a bh of the 1st new block in the allocation. */
3109 static int ocfs2_do_extend_dir(struct super_block
*sb
,
3112 struct buffer_head
*parent_fe_bh
,
3113 struct ocfs2_alloc_context
*data_ac
,
3114 struct ocfs2_alloc_context
*meta_ac
,
3115 struct buffer_head
**new_bh
)
3118 int extend
, did_quota
= 0;
3119 u64 p_blkno
, v_blkno
;
3121 spin_lock(&OCFS2_I(dir
)->ip_lock
);
3122 extend
= (i_size_read(dir
) == ocfs2_clusters_to_bytes(sb
, OCFS2_I(dir
)->ip_clusters
));
3123 spin_unlock(&OCFS2_I(dir
)->ip_lock
);
3126 u32 offset
= OCFS2_I(dir
)->ip_clusters
;
3128 status
= dquot_alloc_space_nodirty(dir
,
3129 ocfs2_clusters_to_bytes(sb
, 1));
3134 status
= ocfs2_add_inode_data(OCFS2_SB(sb
), dir
, &offset
,
3135 1, 0, parent_fe_bh
, handle
,
3136 data_ac
, meta_ac
, NULL
);
3137 BUG_ON(status
== -EAGAIN
);
3144 v_blkno
= ocfs2_blocks_for_bytes(sb
, i_size_read(dir
));
3145 status
= ocfs2_extent_map_get_blocks(dir
, v_blkno
, &p_blkno
, NULL
, NULL
);
3151 *new_bh
= sb_getblk(sb
, p_blkno
);
3159 if (did_quota
&& status
< 0)
3160 dquot_free_space_nodirty(dir
, ocfs2_clusters_to_bytes(sb
, 1));
3165 * Assumes you already have a cluster lock on the directory.
3167 * 'blocks_wanted' is only used if we have an inline directory which
3168 * is to be turned into an extent based one. The size of the dirent to
3169 * insert might be larger than the space gained by growing to just one
3170 * block, so we may have to grow the inode by two blocks in that case.
3172 * If the directory is already indexed, dx_root_bh must be provided.
3174 static int ocfs2_extend_dir(struct ocfs2_super
*osb
,
3176 struct buffer_head
*parent_fe_bh
,
3177 unsigned int blocks_wanted
,
3178 struct ocfs2_dir_lookup_result
*lookup
,
3179 struct buffer_head
**new_de_bh
)
3182 int credits
, num_free_extents
, drop_alloc_sem
= 0;
3184 struct ocfs2_dinode
*fe
= (struct ocfs2_dinode
*) parent_fe_bh
->b_data
;
3185 struct ocfs2_extent_list
*el
= &fe
->id2
.i_list
;
3186 struct ocfs2_alloc_context
*data_ac
= NULL
;
3187 struct ocfs2_alloc_context
*meta_ac
= NULL
;
3188 handle_t
*handle
= NULL
;
3189 struct buffer_head
*new_bh
= NULL
;
3190 struct ocfs2_dir_entry
* de
;
3191 struct super_block
*sb
= osb
->sb
;
3192 struct ocfs2_extent_tree et
;
3193 struct buffer_head
*dx_root_bh
= lookup
->dl_dx_root_bh
;
3195 if (OCFS2_I(dir
)->ip_dyn_features
& OCFS2_INLINE_DATA_FL
) {
3197 * This would be a code error as an inline directory should
3198 * never have an index root.
3202 status
= ocfs2_expand_inline_dir(dir
, parent_fe_bh
,
3203 blocks_wanted
, lookup
,
3210 /* Expansion from inline to an indexed directory will
3211 * have given us this. */
3212 dx_root_bh
= lookup
->dl_dx_root_bh
;
3214 if (blocks_wanted
== 1) {
3216 * If the new dirent will fit inside the space
3217 * created by pushing out to one block, then
3218 * we can complete the operation
3219 * here. Otherwise we have to expand i_size
3220 * and format the 2nd block below.
3222 BUG_ON(new_bh
== NULL
);
3227 * Get rid of 'new_bh' - we want to format the 2nd
3228 * data block and return that instead.
3233 down_write(&OCFS2_I(dir
)->ip_alloc_sem
);
3235 dir_i_size
= i_size_read(dir
);
3236 credits
= OCFS2_SIMPLE_DIR_EXTEND_CREDITS
;
3240 down_write(&OCFS2_I(dir
)->ip_alloc_sem
);
3242 dir_i_size
= i_size_read(dir
);
3243 trace_ocfs2_extend_dir((unsigned long long)OCFS2_I(dir
)->ip_blkno
,
3246 /* dir->i_size is always block aligned. */
3247 spin_lock(&OCFS2_I(dir
)->ip_lock
);
3248 if (dir_i_size
== ocfs2_clusters_to_bytes(sb
, OCFS2_I(dir
)->ip_clusters
)) {
3249 spin_unlock(&OCFS2_I(dir
)->ip_lock
);
3250 ocfs2_init_dinode_extent_tree(&et
, INODE_CACHE(dir
),
3252 num_free_extents
= ocfs2_num_free_extents(&et
);
3253 if (num_free_extents
< 0) {
3254 status
= num_free_extents
;
3259 if (!num_free_extents
) {
3260 status
= ocfs2_reserve_new_metadata(osb
, el
, &meta_ac
);
3262 if (status
!= -ENOSPC
)
3268 status
= ocfs2_reserve_clusters(osb
, 1, &data_ac
);
3270 if (status
!= -ENOSPC
)
3275 if (ocfs2_dir_resv_allowed(osb
))
3276 data_ac
->ac_resv
= &OCFS2_I(dir
)->ip_la_data_resv
;
3278 credits
= ocfs2_calc_extend_credits(sb
, el
);
3280 spin_unlock(&OCFS2_I(dir
)->ip_lock
);
3281 credits
= OCFS2_SIMPLE_DIR_EXTEND_CREDITS
;
3285 if (ocfs2_dir_indexed(dir
))
3286 credits
++; /* For attaching the new dirent block to the
3289 handle
= ocfs2_start_trans(osb
, credits
);
3290 if (IS_ERR(handle
)) {
3291 status
= PTR_ERR(handle
);
3297 status
= ocfs2_do_extend_dir(osb
->sb
, handle
, dir
, parent_fe_bh
,
3298 data_ac
, meta_ac
, &new_bh
);
3304 ocfs2_set_new_buffer_uptodate(INODE_CACHE(dir
), new_bh
);
3306 status
= ocfs2_journal_access_db(handle
, INODE_CACHE(dir
), new_bh
,
3307 OCFS2_JOURNAL_ACCESS_CREATE
);
3312 memset(new_bh
->b_data
, 0, sb
->s_blocksize
);
3314 de
= (struct ocfs2_dir_entry
*) new_bh
->b_data
;
3316 if (ocfs2_supports_dir_trailer(dir
)) {
3317 de
->rec_len
= cpu_to_le16(ocfs2_dir_trailer_blk_off(sb
));
3319 ocfs2_init_dir_trailer(dir
, new_bh
, le16_to_cpu(de
->rec_len
));
3321 if (ocfs2_dir_indexed(dir
)) {
3322 status
= ocfs2_dx_dir_link_trailer(dir
, handle
,
3323 dx_root_bh
, new_bh
);
3330 de
->rec_len
= cpu_to_le16(sb
->s_blocksize
);
3332 ocfs2_update_inode_fsync_trans(handle
, dir
, 1);
3333 ocfs2_journal_dirty(handle
, new_bh
);
3335 dir_i_size
+= dir
->i_sb
->s_blocksize
;
3336 i_size_write(dir
, dir_i_size
);
3337 dir
->i_blocks
= ocfs2_inode_sector_count(dir
);
3338 status
= ocfs2_mark_inode_dirty(handle
, dir
, parent_fe_bh
);
3345 *new_de_bh
= new_bh
;
3349 ocfs2_commit_trans(osb
, handle
);
3351 up_write(&OCFS2_I(dir
)->ip_alloc_sem
);
3354 ocfs2_free_alloc_context(data_ac
);
3356 ocfs2_free_alloc_context(meta_ac
);
3363 static int ocfs2_find_dir_space_id(struct inode
*dir
, struct buffer_head
*di_bh
,
3364 const char *name
, int namelen
,
3365 struct buffer_head
**ret_de_bh
,
3366 unsigned int *blocks_wanted
)
3369 struct super_block
*sb
= dir
->i_sb
;
3370 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
3371 struct ocfs2_dir_entry
*de
, *last_de
= NULL
;
3372 char *de_buf
, *limit
;
3373 unsigned long offset
= 0;
3374 unsigned int rec_len
, new_rec_len
, free_space
= dir
->i_sb
->s_blocksize
;
3377 * This calculates how many free bytes we'd have in block zero, should
3378 * this function force expansion to an extent tree.
3380 if (ocfs2_new_dir_wants_trailer(dir
))
3381 free_space
= ocfs2_dir_trailer_blk_off(sb
) - i_size_read(dir
);
3383 free_space
= dir
->i_sb
->s_blocksize
- i_size_read(dir
);
3385 de_buf
= di
->id2
.i_data
.id_data
;
3386 limit
= de_buf
+ i_size_read(dir
);
3387 rec_len
= OCFS2_DIR_REC_LEN(namelen
);
3389 while (de_buf
< limit
) {
3390 de
= (struct ocfs2_dir_entry
*)de_buf
;
3392 if (!ocfs2_check_dir_entry(dir
, de
, di_bh
, offset
)) {
3396 if (ocfs2_match(namelen
, name
, de
)) {
3401 * No need to check for a trailing dirent record here as
3402 * they're not used for inline dirs.
3405 if (ocfs2_dirent_would_fit(de
, rec_len
)) {
3406 /* Ok, we found a spot. Return this bh and let
3407 * the caller actually fill it in. */
3415 de_buf
+= le16_to_cpu(de
->rec_len
);
3416 offset
+= le16_to_cpu(de
->rec_len
);
3420 * We're going to require expansion of the directory - figure
3421 * out how many blocks we'll need so that a place for the
3422 * dirent can be found.
3425 new_rec_len
= le16_to_cpu(last_de
->rec_len
) + free_space
;
3426 if (new_rec_len
< (rec_len
+ OCFS2_DIR_REC_LEN(last_de
->name_len
)))
3434 static int ocfs2_find_dir_space_el(struct inode
*dir
, const char *name
,
3435 int namelen
, struct buffer_head
**ret_de_bh
)
3437 unsigned long offset
;
3438 struct buffer_head
*bh
= NULL
;
3439 unsigned short rec_len
;
3440 struct ocfs2_dir_entry
*de
;
3441 struct super_block
*sb
= dir
->i_sb
;
3443 int blocksize
= dir
->i_sb
->s_blocksize
;
3445 status
= ocfs2_read_dir_block(dir
, 0, &bh
, 0);
3449 rec_len
= OCFS2_DIR_REC_LEN(namelen
);
3451 de
= (struct ocfs2_dir_entry
*) bh
->b_data
;
3453 if ((char *)de
>= sb
->s_blocksize
+ bh
->b_data
) {
3457 if (i_size_read(dir
) <= offset
) {
3459 * Caller will have to expand this
3465 status
= ocfs2_read_dir_block(dir
,
3466 offset
>> sb
->s_blocksize_bits
,
3471 /* move to next block */
3472 de
= (struct ocfs2_dir_entry
*) bh
->b_data
;
3474 if (!ocfs2_check_dir_entry(dir
, de
, bh
, offset
)) {
3478 if (ocfs2_match(namelen
, name
, de
)) {
3483 if (ocfs2_skip_dir_trailer(dir
, de
, offset
% blocksize
,
3487 if (ocfs2_dirent_would_fit(de
, rec_len
)) {
3488 /* Ok, we found a spot. Return this bh and let
3489 * the caller actually fill it in. */
3496 offset
+= le16_to_cpu(de
->rec_len
);
3497 de
= (struct ocfs2_dir_entry
*)((char *) de
+ le16_to_cpu(de
->rec_len
));
3508 static int dx_leaf_sort_cmp(const void *a
, const void *b
)
3510 const struct ocfs2_dx_entry
*entry1
= a
;
3511 const struct ocfs2_dx_entry
*entry2
= b
;
3512 u32 major_hash1
= le32_to_cpu(entry1
->dx_major_hash
);
3513 u32 major_hash2
= le32_to_cpu(entry2
->dx_major_hash
);
3514 u32 minor_hash1
= le32_to_cpu(entry1
->dx_minor_hash
);
3515 u32 minor_hash2
= le32_to_cpu(entry2
->dx_minor_hash
);
3517 if (major_hash1
> major_hash2
)
3519 if (major_hash1
< major_hash2
)
3523 * It is not strictly necessary to sort by minor
3525 if (minor_hash1
> minor_hash2
)
3527 if (minor_hash1
< minor_hash2
)
3532 static void dx_leaf_sort_swap(void *a
, void *b
, int size
)
3534 struct ocfs2_dx_entry
*entry1
= a
;
3535 struct ocfs2_dx_entry
*entry2
= b
;
3537 BUG_ON(size
!= sizeof(*entry1
));
3539 swap(*entry1
, *entry2
);
3542 static int ocfs2_dx_leaf_same_major(struct ocfs2_dx_leaf
*dx_leaf
)
3544 struct ocfs2_dx_entry_list
*dl_list
= &dx_leaf
->dl_list
;
3545 int i
, num
= le16_to_cpu(dl_list
->de_num_used
);
3547 for (i
= 0; i
< (num
- 1); i
++) {
3548 if (le32_to_cpu(dl_list
->de_entries
[i
].dx_major_hash
) !=
3549 le32_to_cpu(dl_list
->de_entries
[i
+ 1].dx_major_hash
))
3557 * Find the optimal value to split this leaf on. This expects the leaf
3558 * entries to be in sorted order.
3560 * leaf_cpos is the cpos of the leaf we're splitting. insert_hash is
3561 * the hash we want to insert.
3563 * This function is only concerned with the major hash - that which
3564 * determines which cluster an item belongs to.
3566 static int ocfs2_dx_dir_find_leaf_split(struct ocfs2_dx_leaf
*dx_leaf
,
3567 u32 leaf_cpos
, u32 insert_hash
,
3570 struct ocfs2_dx_entry_list
*dl_list
= &dx_leaf
->dl_list
;
3571 int i
, num_used
= le16_to_cpu(dl_list
->de_num_used
);
3575 * There's a couple rare, but nasty corner cases we have to
3576 * check for here. All of them involve a leaf where all value
3577 * have the same hash, which is what we look for first.
3579 * Most of the time, all of the above is false, and we simply
3580 * pick the median value for a split.
3582 allsame
= ocfs2_dx_leaf_same_major(dx_leaf
);
3584 u32 val
= le32_to_cpu(dl_list
->de_entries
[0].dx_major_hash
);
3586 if (val
== insert_hash
) {
3588 * No matter where we would choose to split,
3589 * the new entry would want to occupy the same
3590 * block as these. Since there's no space left
3591 * in their existing block, we know there
3592 * won't be space after the split.
3597 if (val
== leaf_cpos
) {
3599 * Because val is the same as leaf_cpos (which
3600 * is the smallest value this leaf can have),
3601 * yet is not equal to insert_hash, then we
3602 * know that insert_hash *must* be larger than
3603 * val (and leaf_cpos). At least cpos+1 in value.
3605 * We also know then, that there cannot be an
3606 * adjacent extent (otherwise we'd be looking
3607 * at it). Choosing this value gives us a
3608 * chance to get some contiguousness.
3610 *split_hash
= leaf_cpos
+ 1;
3614 if (val
> insert_hash
) {
3616 * val can not be the same as insert hash, and
3617 * also must be larger than leaf_cpos. Also,
3618 * we know that there can't be a leaf between
3619 * cpos and val, otherwise the entries with
3620 * hash 'val' would be there.
3626 *split_hash
= insert_hash
;
3631 * Since the records are sorted and the checks above
3632 * guaranteed that not all records in this block are the same,
3633 * we simple travel forward, from the median, and pick the 1st
3634 * record whose value is larger than leaf_cpos.
3636 for (i
= (num_used
/ 2); i
< num_used
; i
++)
3637 if (le32_to_cpu(dl_list
->de_entries
[i
].dx_major_hash
) >
3641 BUG_ON(i
== num_used
); /* Should be impossible */
3642 *split_hash
= le32_to_cpu(dl_list
->de_entries
[i
].dx_major_hash
);
3647 * Transfer all entries in orig_dx_leaves whose major hash is equal to or
3648 * larger than split_hash into new_dx_leaves. We use a temporary
3649 * buffer (tmp_dx_leaf) to make the changes to the original leaf blocks.
3651 * Since the block offset inside a leaf (cluster) is a constant mask
3652 * of minor_hash, we can optimize - an item at block offset X within
3653 * the original cluster, will be at offset X within the new cluster.
3655 static void ocfs2_dx_dir_transfer_leaf(struct inode
*dir
, u32 split_hash
,
3657 struct ocfs2_dx_leaf
*tmp_dx_leaf
,
3658 struct buffer_head
**orig_dx_leaves
,
3659 struct buffer_head
**new_dx_leaves
,
3664 struct ocfs2_dx_leaf
*orig_dx_leaf
, *new_dx_leaf
;
3665 struct ocfs2_dx_entry_list
*orig_list
, *new_list
, *tmp_list
;
3666 struct ocfs2_dx_entry
*dx_entry
;
3668 tmp_list
= &tmp_dx_leaf
->dl_list
;
3670 for (i
= 0; i
< num_dx_leaves
; i
++) {
3671 orig_dx_leaf
= (struct ocfs2_dx_leaf
*) orig_dx_leaves
[i
]->b_data
;
3672 orig_list
= &orig_dx_leaf
->dl_list
;
3673 new_dx_leaf
= (struct ocfs2_dx_leaf
*) new_dx_leaves
[i
]->b_data
;
3674 new_list
= &new_dx_leaf
->dl_list
;
3676 num_used
= le16_to_cpu(orig_list
->de_num_used
);
3678 memcpy(tmp_dx_leaf
, orig_dx_leaf
, dir
->i_sb
->s_blocksize
);
3679 tmp_list
->de_num_used
= cpu_to_le16(0);
3680 memset(&tmp_list
->de_entries
, 0, sizeof(*dx_entry
)*num_used
);
3682 for (j
= 0; j
< num_used
; j
++) {
3683 dx_entry
= &orig_list
->de_entries
[j
];
3684 major_hash
= le32_to_cpu(dx_entry
->dx_major_hash
);
3685 if (major_hash
>= split_hash
)
3686 ocfs2_dx_dir_leaf_insert_tail(new_dx_leaf
,
3689 ocfs2_dx_dir_leaf_insert_tail(tmp_dx_leaf
,
3692 memcpy(orig_dx_leaf
, tmp_dx_leaf
, dir
->i_sb
->s_blocksize
);
3694 ocfs2_journal_dirty(handle
, orig_dx_leaves
[i
]);
3695 ocfs2_journal_dirty(handle
, new_dx_leaves
[i
]);
3699 static int ocfs2_dx_dir_rebalance_credits(struct ocfs2_super
*osb
,
3700 struct ocfs2_dx_root_block
*dx_root
)
3702 int credits
= ocfs2_clusters_to_blocks(osb
->sb
, 3);
3704 credits
+= ocfs2_calc_extend_credits(osb
->sb
, &dx_root
->dr_list
);
3705 credits
+= ocfs2_quota_trans_credits(osb
->sb
);
3710 * Find the median value in dx_leaf_bh and allocate a new leaf to move
3711 * half our entries into.
3713 static int ocfs2_dx_dir_rebalance(struct ocfs2_super
*osb
, struct inode
*dir
,
3714 struct buffer_head
*dx_root_bh
,
3715 struct buffer_head
*dx_leaf_bh
,
3716 struct ocfs2_dx_hinfo
*hinfo
, u32 leaf_cpos
,
3719 struct ocfs2_dx_leaf
*dx_leaf
= (struct ocfs2_dx_leaf
*)dx_leaf_bh
->b_data
;
3720 int credits
, ret
, i
, num_used
, did_quota
= 0;
3721 u32 cpos
, split_hash
, insert_hash
= hinfo
->major_hash
;
3722 u64 orig_leaves_start
;
3724 struct buffer_head
**orig_dx_leaves
= NULL
;
3725 struct buffer_head
**new_dx_leaves
= NULL
;
3726 struct ocfs2_alloc_context
*data_ac
= NULL
, *meta_ac
= NULL
;
3727 struct ocfs2_extent_tree et
;
3728 handle_t
*handle
= NULL
;
3729 struct ocfs2_dx_root_block
*dx_root
;
3730 struct ocfs2_dx_leaf
*tmp_dx_leaf
= NULL
;
3732 trace_ocfs2_dx_dir_rebalance((unsigned long long)OCFS2_I(dir
)->ip_blkno
,
3733 (unsigned long long)leaf_blkno
,
3736 ocfs2_init_dx_root_extent_tree(&et
, INODE_CACHE(dir
), dx_root_bh
);
3738 dx_root
= (struct ocfs2_dx_root_block
*)dx_root_bh
->b_data
;
3740 * XXX: This is a rather large limit. We should use a more
3743 if (le32_to_cpu(dx_root
->dr_clusters
) == UINT_MAX
)
3746 num_used
= le16_to_cpu(dx_leaf
->dl_list
.de_num_used
);
3747 if (num_used
< le16_to_cpu(dx_leaf
->dl_list
.de_count
)) {
3748 mlog(ML_ERROR
, "DX Dir: %llu, Asked to rebalance empty leaf: "
3749 "%llu, %d\n", (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
3750 (unsigned long long)leaf_blkno
, num_used
);
3755 orig_dx_leaves
= ocfs2_dx_dir_kmalloc_leaves(osb
->sb
, &num_dx_leaves
);
3756 if (!orig_dx_leaves
) {
3762 new_dx_leaves
= ocfs2_dx_dir_kmalloc_leaves(osb
->sb
, NULL
);
3763 if (!new_dx_leaves
) {
3769 ret
= ocfs2_lock_allocators(dir
, &et
, 1, 0, &data_ac
, &meta_ac
);
3776 credits
= ocfs2_dx_dir_rebalance_credits(osb
, dx_root
);
3777 handle
= ocfs2_start_trans(osb
, credits
);
3778 if (IS_ERR(handle
)) {
3779 ret
= PTR_ERR(handle
);
3785 ret
= dquot_alloc_space_nodirty(dir
,
3786 ocfs2_clusters_to_bytes(dir
->i_sb
, 1));
3791 ret
= ocfs2_journal_access_dl(handle
, INODE_CACHE(dir
), dx_leaf_bh
,
3792 OCFS2_JOURNAL_ACCESS_WRITE
);
3799 * This block is changing anyway, so we can sort it in place.
3801 sort(dx_leaf
->dl_list
.de_entries
, num_used
,
3802 sizeof(struct ocfs2_dx_entry
), dx_leaf_sort_cmp
,
3805 ocfs2_journal_dirty(handle
, dx_leaf_bh
);
3807 ret
= ocfs2_dx_dir_find_leaf_split(dx_leaf
, leaf_cpos
, insert_hash
,
3814 trace_ocfs2_dx_dir_rebalance_split(leaf_cpos
, split_hash
, insert_hash
);
3817 * We have to carefully order operations here. There are items
3818 * which want to be in the new cluster before insert, but in
3819 * order to put those items in the new cluster, we alter the
3820 * old cluster. A failure to insert gets nasty.
3822 * So, start by reserving writes to the old
3823 * cluster. ocfs2_dx_dir_new_cluster will reserve writes on
3824 * the new cluster for us, before inserting it. The insert
3825 * won't happen if there's an error before that. Once the
3826 * insert is done then, we can transfer from one leaf into the
3827 * other without fear of hitting any error.
3831 * The leaf transfer wants some scratch space so that we don't
3832 * wind up doing a bunch of expensive memmove().
3834 tmp_dx_leaf
= kmalloc(osb
->sb
->s_blocksize
, GFP_NOFS
);
3841 orig_leaves_start
= ocfs2_block_to_cluster_start(dir
->i_sb
, leaf_blkno
);
3842 ret
= ocfs2_read_dx_leaves(dir
, orig_leaves_start
, num_dx_leaves
,
3850 ret
= ocfs2_dx_dir_new_cluster(dir
, &et
, cpos
, handle
,
3851 data_ac
, meta_ac
, new_dx_leaves
,
3858 for (i
= 0; i
< num_dx_leaves
; i
++) {
3859 ret
= ocfs2_journal_access_dl(handle
, INODE_CACHE(dir
),
3861 OCFS2_JOURNAL_ACCESS_WRITE
);
3867 ret
= ocfs2_journal_access_dl(handle
, INODE_CACHE(dir
),
3869 OCFS2_JOURNAL_ACCESS_WRITE
);
3876 ocfs2_dx_dir_transfer_leaf(dir
, split_hash
, handle
, tmp_dx_leaf
,
3877 orig_dx_leaves
, new_dx_leaves
, num_dx_leaves
);
3880 if (ret
< 0 && did_quota
)
3881 dquot_free_space_nodirty(dir
,
3882 ocfs2_clusters_to_bytes(dir
->i_sb
, 1));
3884 ocfs2_update_inode_fsync_trans(handle
, dir
, 1);
3885 ocfs2_commit_trans(osb
, handle
);
3888 if (orig_dx_leaves
|| new_dx_leaves
) {
3889 for (i
= 0; i
< num_dx_leaves
; i
++) {
3891 brelse(orig_dx_leaves
[i
]);
3893 brelse(new_dx_leaves
[i
]);
3895 kfree(orig_dx_leaves
);
3896 kfree(new_dx_leaves
);
3900 ocfs2_free_alloc_context(meta_ac
);
3902 ocfs2_free_alloc_context(data_ac
);
3908 static int ocfs2_find_dir_space_dx(struct ocfs2_super
*osb
, struct inode
*dir
,
3909 struct buffer_head
*di_bh
,
3910 struct buffer_head
*dx_root_bh
,
3911 const char *name
, int namelen
,
3912 struct ocfs2_dir_lookup_result
*lookup
)
3914 int ret
, rebalanced
= 0;
3915 struct ocfs2_dx_root_block
*dx_root
;
3916 struct buffer_head
*dx_leaf_bh
= NULL
;
3917 struct ocfs2_dx_leaf
*dx_leaf
;
3921 dx_root
= (struct ocfs2_dx_root_block
*)dx_root_bh
->b_data
;
3924 ret
= ocfs2_dx_dir_lookup(dir
, &dx_root
->dr_list
, &lookup
->dl_hinfo
,
3925 &leaf_cpos
, &blkno
);
3931 ret
= ocfs2_read_dx_leaf(dir
, blkno
, &dx_leaf_bh
);
3937 dx_leaf
= (struct ocfs2_dx_leaf
*)dx_leaf_bh
->b_data
;
3939 if (le16_to_cpu(dx_leaf
->dl_list
.de_num_used
) >=
3940 le16_to_cpu(dx_leaf
->dl_list
.de_count
)) {
3943 * Rebalancing should have provided us with
3944 * space in an appropriate leaf.
3946 * XXX: Is this an abnormal condition then?
3947 * Should we print a message here?
3953 ret
= ocfs2_dx_dir_rebalance(osb
, dir
, dx_root_bh
, dx_leaf_bh
,
3954 &lookup
->dl_hinfo
, leaf_cpos
,
3963 * Restart the lookup. The rebalance might have
3964 * changed which block our item fits into. Mark our
3965 * progress, so we only execute this once.
3970 goto restart_search
;
3973 lookup
->dl_dx_leaf_bh
= dx_leaf_bh
;
3981 static int ocfs2_search_dx_free_list(struct inode
*dir
,
3982 struct buffer_head
*dx_root_bh
,
3984 struct ocfs2_dir_lookup_result
*lookup
)
3987 struct buffer_head
*leaf_bh
= NULL
, *prev_leaf_bh
= NULL
;
3988 struct ocfs2_dir_block_trailer
*db
;
3990 int rec_len
= OCFS2_DIR_REC_LEN(namelen
);
3991 struct ocfs2_dx_root_block
*dx_root
;
3993 dx_root
= (struct ocfs2_dx_root_block
*)dx_root_bh
->b_data
;
3994 next_block
= le64_to_cpu(dx_root
->dr_free_blk
);
3996 while (next_block
) {
3997 brelse(prev_leaf_bh
);
3998 prev_leaf_bh
= leaf_bh
;
4001 ret
= ocfs2_read_dir_block_direct(dir
, next_block
, &leaf_bh
);
4007 db
= ocfs2_trailer_from_bh(leaf_bh
, dir
->i_sb
);
4008 if (rec_len
<= le16_to_cpu(db
->db_free_rec_len
)) {
4009 lookup
->dl_leaf_bh
= leaf_bh
;
4010 lookup
->dl_prev_leaf_bh
= prev_leaf_bh
;
4012 prev_leaf_bh
= NULL
;
4016 next_block
= le64_to_cpu(db
->db_free_next
);
4025 brelse(prev_leaf_bh
);
4029 static int ocfs2_expand_inline_dx_root(struct inode
*dir
,
4030 struct buffer_head
*dx_root_bh
)
4032 int ret
, num_dx_leaves
, i
, j
, did_quota
= 0;
4033 struct buffer_head
**dx_leaves
= NULL
;
4034 struct ocfs2_extent_tree et
;
4036 struct ocfs2_alloc_context
*data_ac
= NULL
;
4037 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
4038 handle_t
*handle
= NULL
;
4039 struct ocfs2_dx_root_block
*dx_root
;
4040 struct ocfs2_dx_entry_list
*entry_list
;
4041 struct ocfs2_dx_entry
*dx_entry
;
4042 struct ocfs2_dx_leaf
*target_leaf
;
4044 ret
= ocfs2_reserve_clusters(osb
, 1, &data_ac
);
4050 dx_leaves
= ocfs2_dx_dir_kmalloc_leaves(osb
->sb
, &num_dx_leaves
);
4057 handle
= ocfs2_start_trans(osb
, ocfs2_calc_dxi_expand_credits(osb
->sb
));
4058 if (IS_ERR(handle
)) {
4059 ret
= PTR_ERR(handle
);
4064 ret
= dquot_alloc_space_nodirty(dir
,
4065 ocfs2_clusters_to_bytes(osb
->sb
, 1));
4071 * We do this up front, before the allocation, so that a
4072 * failure to add the dx_root_bh to the journal won't result
4073 * us losing clusters.
4075 ret
= ocfs2_journal_access_dr(handle
, INODE_CACHE(dir
), dx_root_bh
,
4076 OCFS2_JOURNAL_ACCESS_WRITE
);
4082 ret
= __ocfs2_dx_dir_new_cluster(dir
, 0, handle
, data_ac
, dx_leaves
,
4083 num_dx_leaves
, &insert_blkno
);
4090 * Transfer the entries from our dx_root into the appropriate
4093 dx_root
= (struct ocfs2_dx_root_block
*) dx_root_bh
->b_data
;
4094 entry_list
= &dx_root
->dr_entries
;
4096 for (i
= 0; i
< le16_to_cpu(entry_list
->de_num_used
); i
++) {
4097 dx_entry
= &entry_list
->de_entries
[i
];
4099 j
= __ocfs2_dx_dir_hash_idx(osb
,
4100 le32_to_cpu(dx_entry
->dx_minor_hash
));
4101 target_leaf
= (struct ocfs2_dx_leaf
*)dx_leaves
[j
]->b_data
;
4103 ocfs2_dx_dir_leaf_insert_tail(target_leaf
, dx_entry
);
4105 /* Each leaf has been passed to the journal already
4106 * via __ocfs2_dx_dir_new_cluster() */
4109 dx_root
->dr_flags
&= ~OCFS2_DX_FLAG_INLINE
;
4110 memset(&dx_root
->dr_list
, 0, osb
->sb
->s_blocksize
-
4111 offsetof(struct ocfs2_dx_root_block
, dr_list
));
4112 dx_root
->dr_list
.l_count
=
4113 cpu_to_le16(ocfs2_extent_recs_per_dx_root(osb
->sb
));
4115 /* This should never fail considering we start with an empty
4117 ocfs2_init_dx_root_extent_tree(&et
, INODE_CACHE(dir
), dx_root_bh
);
4118 ret
= ocfs2_insert_extent(handle
, &et
, 0, insert_blkno
, 1, 0, NULL
);
4123 ocfs2_update_inode_fsync_trans(handle
, dir
, 1);
4124 ocfs2_journal_dirty(handle
, dx_root_bh
);
4127 if (ret
< 0 && did_quota
)
4128 dquot_free_space_nodirty(dir
,
4129 ocfs2_clusters_to_bytes(dir
->i_sb
, 1));
4131 ocfs2_commit_trans(osb
, handle
);
4135 ocfs2_free_alloc_context(data_ac
);
4138 for (i
= 0; i
< num_dx_leaves
; i
++)
4139 brelse(dx_leaves
[i
]);
4145 static int ocfs2_inline_dx_has_space(struct buffer_head
*dx_root_bh
)
4147 struct ocfs2_dx_root_block
*dx_root
;
4148 struct ocfs2_dx_entry_list
*entry_list
;
4150 dx_root
= (struct ocfs2_dx_root_block
*) dx_root_bh
->b_data
;
4151 entry_list
= &dx_root
->dr_entries
;
4153 if (le16_to_cpu(entry_list
->de_num_used
) >=
4154 le16_to_cpu(entry_list
->de_count
))
4160 static int ocfs2_prepare_dx_dir_for_insert(struct inode
*dir
,
4161 struct buffer_head
*di_bh
,
4164 struct ocfs2_dir_lookup_result
*lookup
)
4166 int ret
, free_dx_root
= 1;
4167 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
4168 struct buffer_head
*dx_root_bh
= NULL
;
4169 struct buffer_head
*leaf_bh
= NULL
;
4170 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
4171 struct ocfs2_dx_root_block
*dx_root
;
4173 ret
= ocfs2_read_dx_root(dir
, di
, &dx_root_bh
);
4179 dx_root
= (struct ocfs2_dx_root_block
*)dx_root_bh
->b_data
;
4180 if (le32_to_cpu(dx_root
->dr_num_entries
) == OCFS2_DX_ENTRIES_MAX
) {
4186 if (ocfs2_dx_root_inline(dx_root
)) {
4187 ret
= ocfs2_inline_dx_has_space(dx_root_bh
);
4193 * We ran out of room in the root block. Expand it to
4194 * an extent, then allow ocfs2_find_dir_space_dx to do
4197 ret
= ocfs2_expand_inline_dx_root(dir
, dx_root_bh
);
4205 * Insert preparation for an indexed directory is split into two
4206 * steps. The call to find_dir_space_dx reserves room in the index for
4207 * an additional item. If we run out of space there, it's a real error
4208 * we can't continue on.
4210 ret
= ocfs2_find_dir_space_dx(osb
, dir
, di_bh
, dx_root_bh
, name
,
4219 * Next, we need to find space in the unindexed tree. This call
4220 * searches using the free space linked list. If the unindexed tree
4221 * lacks sufficient space, we'll expand it below. The expansion code
4222 * is smart enough to add any new blocks to the free space list.
4224 ret
= ocfs2_search_dx_free_list(dir
, dx_root_bh
, namelen
, lookup
);
4225 if (ret
&& ret
!= -ENOSPC
) {
4230 /* Do this up here - ocfs2_extend_dir might need the dx_root */
4231 lookup
->dl_dx_root_bh
= dx_root_bh
;
4234 if (ret
== -ENOSPC
) {
4235 ret
= ocfs2_extend_dir(osb
, dir
, di_bh
, 1, lookup
, &leaf_bh
);
4243 * We make the assumption here that new leaf blocks are added
4244 * to the front of our free list.
4246 lookup
->dl_prev_leaf_bh
= NULL
;
4247 lookup
->dl_leaf_bh
= leaf_bh
;
4257 * Get a directory ready for insert. Any directory allocation required
4258 * happens here. Success returns zero, and enough context in the dir
4259 * lookup result that ocfs2_add_entry() will be able complete the task
4260 * with minimal performance impact.
4262 int ocfs2_prepare_dir_for_insert(struct ocfs2_super
*osb
,
4264 struct buffer_head
*parent_fe_bh
,
4267 struct ocfs2_dir_lookup_result
*lookup
)
4270 unsigned int blocks_wanted
= 1;
4271 struct buffer_head
*bh
= NULL
;
4273 trace_ocfs2_prepare_dir_for_insert(
4274 (unsigned long long)OCFS2_I(dir
)->ip_blkno
, namelen
);
4283 * Do this up front to reduce confusion.
4285 * The directory might start inline, then be turned into an
4286 * indexed one, in which case we'd need to hash deep inside
4287 * ocfs2_find_dir_space_id(). Since
4288 * ocfs2_prepare_dx_dir_for_insert() also needs this hash
4289 * done, there seems no point in spreading out the calls. We
4290 * can optimize away the case where the file system doesn't
4293 if (ocfs2_supports_indexed_dirs(osb
))
4294 ocfs2_dx_dir_name_hash(dir
, name
, namelen
, &lookup
->dl_hinfo
);
4296 if (ocfs2_dir_indexed(dir
)) {
4297 ret
= ocfs2_prepare_dx_dir_for_insert(dir
, parent_fe_bh
,
4298 name
, namelen
, lookup
);
4304 if (OCFS2_I(dir
)->ip_dyn_features
& OCFS2_INLINE_DATA_FL
) {
4305 ret
= ocfs2_find_dir_space_id(dir
, parent_fe_bh
, name
,
4306 namelen
, &bh
, &blocks_wanted
);
4308 ret
= ocfs2_find_dir_space_el(dir
, name
, namelen
, &bh
);
4310 if (ret
&& ret
!= -ENOSPC
) {
4315 if (ret
== -ENOSPC
) {
4317 * We have to expand the directory to add this name.
4321 ret
= ocfs2_extend_dir(osb
, dir
, parent_fe_bh
, blocks_wanted
,
4332 lookup
->dl_leaf_bh
= bh
;
4339 static int ocfs2_dx_dir_remove_index(struct inode
*dir
,
4340 struct buffer_head
*di_bh
,
4341 struct buffer_head
*dx_root_bh
)
4344 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
4345 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
4346 struct ocfs2_dx_root_block
*dx_root
;
4347 struct inode
*dx_alloc_inode
= NULL
;
4348 struct buffer_head
*dx_alloc_bh
= NULL
;
4354 dx_root
= (struct ocfs2_dx_root_block
*) dx_root_bh
->b_data
;
4356 dx_alloc_inode
= ocfs2_get_system_file_inode(osb
,
4357 EXTENT_ALLOC_SYSTEM_INODE
,
4358 le16_to_cpu(dx_root
->dr_suballoc_slot
));
4359 if (!dx_alloc_inode
) {
4364 inode_lock(dx_alloc_inode
);
4366 ret
= ocfs2_inode_lock(dx_alloc_inode
, &dx_alloc_bh
, 1);
4372 handle
= ocfs2_start_trans(osb
, OCFS2_DX_ROOT_REMOVE_CREDITS
);
4373 if (IS_ERR(handle
)) {
4374 ret
= PTR_ERR(handle
);
4379 ret
= ocfs2_journal_access_di(handle
, INODE_CACHE(dir
), di_bh
,
4380 OCFS2_JOURNAL_ACCESS_WRITE
);
4386 spin_lock(&OCFS2_I(dir
)->ip_lock
);
4387 OCFS2_I(dir
)->ip_dyn_features
&= ~OCFS2_INDEXED_DIR_FL
;
4388 di
->i_dyn_features
= cpu_to_le16(OCFS2_I(dir
)->ip_dyn_features
);
4389 spin_unlock(&OCFS2_I(dir
)->ip_lock
);
4390 di
->i_dx_root
= cpu_to_le64(0ULL);
4391 ocfs2_update_inode_fsync_trans(handle
, dir
, 1);
4393 ocfs2_journal_dirty(handle
, di_bh
);
4395 blk
= le64_to_cpu(dx_root
->dr_blkno
);
4396 bit
= le16_to_cpu(dx_root
->dr_suballoc_bit
);
4397 if (dx_root
->dr_suballoc_loc
)
4398 bg_blkno
= le64_to_cpu(dx_root
->dr_suballoc_loc
);
4400 bg_blkno
= ocfs2_which_suballoc_group(blk
, bit
);
4401 ret
= ocfs2_free_suballoc_bits(handle
, dx_alloc_inode
, dx_alloc_bh
,
4407 ocfs2_commit_trans(osb
, handle
);
4410 ocfs2_inode_unlock(dx_alloc_inode
, 1);
4413 inode_unlock(dx_alloc_inode
);
4414 brelse(dx_alloc_bh
);
4416 iput(dx_alloc_inode
);
4420 int ocfs2_dx_dir_truncate(struct inode
*dir
, struct buffer_head
*di_bh
)
4423 unsigned int uninitialized_var(clen
);
4424 u32 major_hash
= UINT_MAX
, p_cpos
, uninitialized_var(cpos
);
4425 u64
uninitialized_var(blkno
);
4426 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
4427 struct buffer_head
*dx_root_bh
= NULL
;
4428 struct ocfs2_dx_root_block
*dx_root
;
4429 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
4430 struct ocfs2_cached_dealloc_ctxt dealloc
;
4431 struct ocfs2_extent_tree et
;
4433 ocfs2_init_dealloc_ctxt(&dealloc
);
4435 if (!ocfs2_dir_indexed(dir
))
4438 ret
= ocfs2_read_dx_root(dir
, di
, &dx_root_bh
);
4443 dx_root
= (struct ocfs2_dx_root_block
*)dx_root_bh
->b_data
;
4445 if (ocfs2_dx_root_inline(dx_root
))
4448 ocfs2_init_dx_root_extent_tree(&et
, INODE_CACHE(dir
), dx_root_bh
);
4450 /* XXX: What if dr_clusters is too large? */
4451 while (le32_to_cpu(dx_root
->dr_clusters
)) {
4452 ret
= ocfs2_dx_dir_lookup_rec(dir
, &dx_root
->dr_list
,
4453 major_hash
, &cpos
, &blkno
, &clen
);
4459 p_cpos
= ocfs2_blocks_to_clusters(dir
->i_sb
, blkno
);
4461 ret
= ocfs2_remove_btree_range(dir
, &et
, cpos
, p_cpos
, clen
, 0,
4462 &dealloc
, 0, false);
4471 major_hash
= cpos
- 1;
4475 ret
= ocfs2_dx_dir_remove_index(dir
, di_bh
, dx_root_bh
);
4481 ocfs2_remove_from_cache(INODE_CACHE(dir
), dx_root_bh
);
4483 ocfs2_schedule_truncate_log_flush(osb
, 1);
4484 ocfs2_run_deallocs(osb
, &dealloc
);