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 Linux 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>
46 #include <cluster/masklog.h>
51 #include "blockcheck.h"
54 #include "extent_map.h"
63 #include "ocfs2_trace.h"
65 #include "buffer_head_io.h"
67 #define NAMEI_RA_CHUNKS 2
68 #define NAMEI_RA_BLOCKS 4
69 #define NAMEI_RA_SIZE (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS)
71 static unsigned char ocfs2_filetype_table
[] = {
72 DT_UNKNOWN
, DT_REG
, DT_DIR
, DT_CHR
, DT_BLK
, DT_FIFO
, DT_SOCK
, DT_LNK
75 static int ocfs2_do_extend_dir(struct super_block
*sb
,
78 struct buffer_head
*parent_fe_bh
,
79 struct ocfs2_alloc_context
*data_ac
,
80 struct ocfs2_alloc_context
*meta_ac
,
81 struct buffer_head
**new_bh
);
82 static int ocfs2_dir_indexed(struct inode
*inode
);
85 * These are distinct checks because future versions of the file system will
86 * want to have a trailing dirent structure independent of indexing.
88 static int ocfs2_supports_dir_trailer(struct inode
*dir
)
90 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
92 if (OCFS2_I(dir
)->ip_dyn_features
& OCFS2_INLINE_DATA_FL
)
95 return ocfs2_meta_ecc(osb
) || ocfs2_dir_indexed(dir
);
99 * "new' here refers to the point at which we're creating a new
100 * directory via "mkdir()", but also when we're expanding an inline
101 * directory. In either case, we don't yet have the indexing bit set
102 * on the directory, so the standard checks will fail in when metaecc
103 * is turned off. Only directory-initialization type functions should
104 * use this then. Everything else wants ocfs2_supports_dir_trailer()
106 static int ocfs2_new_dir_wants_trailer(struct inode
*dir
)
108 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
110 return ocfs2_meta_ecc(osb
) ||
111 ocfs2_supports_indexed_dirs(osb
);
114 static inline unsigned int ocfs2_dir_trailer_blk_off(struct super_block
*sb
)
116 return sb
->s_blocksize
- sizeof(struct ocfs2_dir_block_trailer
);
119 #define ocfs2_trailer_from_bh(_bh, _sb) ((struct ocfs2_dir_block_trailer *) ((_bh)->b_data + ocfs2_dir_trailer_blk_off((_sb))))
121 /* XXX ocfs2_block_dqtrailer() is similar but not quite - can we make
122 * them more consistent? */
123 struct ocfs2_dir_block_trailer
*ocfs2_dir_trailer_from_size(int blocksize
,
128 p
+= blocksize
- sizeof(struct ocfs2_dir_block_trailer
);
129 return (struct ocfs2_dir_block_trailer
*)p
;
133 * XXX: This is executed once on every dirent. We should consider optimizing
136 static int ocfs2_skip_dir_trailer(struct inode
*dir
,
137 struct ocfs2_dir_entry
*de
,
138 unsigned long offset
,
139 unsigned long blklen
)
141 unsigned long toff
= blklen
- sizeof(struct ocfs2_dir_block_trailer
);
143 if (!ocfs2_supports_dir_trailer(dir
))
152 static void ocfs2_init_dir_trailer(struct inode
*inode
,
153 struct buffer_head
*bh
, u16 rec_len
)
155 struct ocfs2_dir_block_trailer
*trailer
;
157 trailer
= ocfs2_trailer_from_bh(bh
, inode
->i_sb
);
158 strcpy(trailer
->db_signature
, OCFS2_DIR_TRAILER_SIGNATURE
);
159 trailer
->db_compat_rec_len
=
160 cpu_to_le16(sizeof(struct ocfs2_dir_block_trailer
));
161 trailer
->db_parent_dinode
= cpu_to_le64(OCFS2_I(inode
)->ip_blkno
);
162 trailer
->db_blkno
= cpu_to_le64(bh
->b_blocknr
);
163 trailer
->db_free_rec_len
= cpu_to_le16(rec_len
);
166 * Link an unindexed block with a dir trailer structure into the index free
167 * list. This function will modify dirdata_bh, but assumes you've already
168 * passed it to the journal.
170 static int ocfs2_dx_dir_link_trailer(struct inode
*dir
, handle_t
*handle
,
171 struct buffer_head
*dx_root_bh
,
172 struct buffer_head
*dirdata_bh
)
175 struct ocfs2_dx_root_block
*dx_root
;
176 struct ocfs2_dir_block_trailer
*trailer
;
178 ret
= ocfs2_journal_access_dr(handle
, INODE_CACHE(dir
), dx_root_bh
,
179 OCFS2_JOURNAL_ACCESS_WRITE
);
184 trailer
= ocfs2_trailer_from_bh(dirdata_bh
, dir
->i_sb
);
185 dx_root
= (struct ocfs2_dx_root_block
*)dx_root_bh
->b_data
;
187 trailer
->db_free_next
= dx_root
->dr_free_blk
;
188 dx_root
->dr_free_blk
= cpu_to_le64(dirdata_bh
->b_blocknr
);
190 ocfs2_journal_dirty(handle
, dx_root_bh
);
196 static int ocfs2_free_list_at_root(struct ocfs2_dir_lookup_result
*res
)
198 return res
->dl_prev_leaf_bh
== NULL
;
201 void ocfs2_free_dir_lookup_result(struct ocfs2_dir_lookup_result
*res
)
203 brelse(res
->dl_dx_root_bh
);
204 brelse(res
->dl_leaf_bh
);
205 brelse(res
->dl_dx_leaf_bh
);
206 brelse(res
->dl_prev_leaf_bh
);
209 static int ocfs2_dir_indexed(struct inode
*inode
)
211 if (OCFS2_I(inode
)->ip_dyn_features
& OCFS2_INDEXED_DIR_FL
)
216 static inline int ocfs2_dx_root_inline(struct ocfs2_dx_root_block
*dx_root
)
218 return dx_root
->dr_flags
& OCFS2_DX_FLAG_INLINE
;
222 * Hashing code adapted from ext3
224 #define DELTA 0x9E3779B9
226 static void TEA_transform(__u32 buf
[4], __u32
const in
[])
229 __u32 b0
= buf
[0], b1
= buf
[1];
230 __u32 a
= in
[0], b
= in
[1], c
= in
[2], d
= in
[3];
235 b0
+= ((b1
<< 4)+a
) ^ (b1
+sum
) ^ ((b1
>> 5)+b
);
236 b1
+= ((b0
<< 4)+c
) ^ (b0
+sum
) ^ ((b0
>> 5)+d
);
243 static void str2hashbuf(const char *msg
, int len
, __u32
*buf
, int num
)
248 pad
= (__u32
)len
| ((__u32
)len
<< 8);
254 for (i
= 0; i
< len
; i
++) {
257 val
= msg
[i
] + (val
<< 8);
270 static void ocfs2_dx_dir_name_hash(struct inode
*dir
, const char *name
, int len
,
271 struct ocfs2_dx_hinfo
*hinfo
)
273 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
278 * XXX: Is this really necessary, if the index is never looked
279 * at by readdir? Is a hash value of '0' a bad idea?
281 if ((len
== 1 && !strncmp(".", name
, 1)) ||
282 (len
== 2 && !strncmp("..", name
, 2))) {
287 #ifdef OCFS2_DEBUG_DX_DIRS
289 * This makes it very easy to debug indexing problems. We
290 * should never allow this to be selected without hand editing
293 buf
[0] = buf
[1] = len
;
297 memcpy(buf
, osb
->osb_dx_seed
, sizeof(buf
));
301 str2hashbuf(p
, len
, in
, 4);
302 TEA_transform(buf
, in
);
308 hinfo
->major_hash
= buf
[0];
309 hinfo
->minor_hash
= buf
[1];
313 * bh passed here can be an inode block or a dir data block, depending
314 * on the inode inline data flag.
316 static int ocfs2_check_dir_entry(struct inode
* dir
,
317 struct ocfs2_dir_entry
* de
,
318 struct buffer_head
* bh
,
319 unsigned long offset
)
321 const char *error_msg
= NULL
;
322 const int rlen
= le16_to_cpu(de
->rec_len
);
324 if (unlikely(rlen
< OCFS2_DIR_REC_LEN(1)))
325 error_msg
= "rec_len is smaller than minimal";
326 else if (unlikely(rlen
% 4 != 0))
327 error_msg
= "rec_len % 4 != 0";
328 else if (unlikely(rlen
< OCFS2_DIR_REC_LEN(de
->name_len
)))
329 error_msg
= "rec_len is too small for name_len";
331 ((char *) de
- bh
->b_data
) + rlen
> dir
->i_sb
->s_blocksize
))
332 error_msg
= "directory entry across blocks";
334 if (unlikely(error_msg
!= NULL
))
335 mlog(ML_ERROR
, "bad entry in directory #%llu: %s - "
336 "offset=%lu, inode=%llu, rec_len=%d, name_len=%d\n",
337 (unsigned long long)OCFS2_I(dir
)->ip_blkno
, error_msg
,
338 offset
, (unsigned long long)le64_to_cpu(de
->inode
), rlen
,
341 return error_msg
== NULL
? 1 : 0;
344 static inline int ocfs2_match(int len
,
345 const char * const name
,
346 struct ocfs2_dir_entry
*de
)
348 if (len
!= de
->name_len
)
352 return !memcmp(name
, de
->name
, len
);
356 * Returns 0 if not found, -1 on failure, and 1 on success
358 static inline int ocfs2_search_dirblock(struct buffer_head
*bh
,
360 const char *name
, int namelen
,
361 unsigned long offset
,
364 struct ocfs2_dir_entry
**res_dir
)
366 struct ocfs2_dir_entry
*de
;
367 char *dlimit
, *de_buf
;
372 dlimit
= de_buf
+ bytes
;
374 while (de_buf
< dlimit
) {
375 /* this code is executed quadratically often */
376 /* do minimal checking `by hand' */
378 de
= (struct ocfs2_dir_entry
*) de_buf
;
380 if (de_buf
+ namelen
<= dlimit
&&
381 ocfs2_match(namelen
, name
, de
)) {
382 /* found a match - just to be sure, do a full check */
383 if (!ocfs2_check_dir_entry(dir
, de
, bh
, offset
)) {
392 /* prevent looping on a bad block */
393 de_len
= le16_to_cpu(de
->rec_len
);
404 trace_ocfs2_search_dirblock(ret
);
408 static struct buffer_head
*ocfs2_find_entry_id(const char *name
,
411 struct ocfs2_dir_entry
**res_dir
)
414 struct buffer_head
*di_bh
= NULL
;
415 struct ocfs2_dinode
*di
;
416 struct ocfs2_inline_data
*data
;
418 ret
= ocfs2_read_inode_block(dir
, &di_bh
);
424 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
425 data
= &di
->id2
.i_data
;
427 found
= ocfs2_search_dirblock(di_bh
, dir
, name
, namelen
, 0,
428 data
->id_data
, i_size_read(dir
), res_dir
);
437 static int ocfs2_validate_dir_block(struct super_block
*sb
,
438 struct buffer_head
*bh
)
441 struct ocfs2_dir_block_trailer
*trailer
=
442 ocfs2_trailer_from_bh(bh
, sb
);
446 * We don't validate dirents here, that's handled
447 * in-place when the code walks them.
449 trace_ocfs2_validate_dir_block((unsigned long long)bh
->b_blocknr
);
451 BUG_ON(!buffer_uptodate(bh
));
454 * If the ecc fails, we return the error but otherwise
455 * leave the filesystem running. We know any error is
456 * local to this block.
458 * Note that we are safe to call this even if the directory
459 * doesn't have a trailer. Filesystems without metaecc will do
460 * nothing, and filesystems with it will have one.
462 rc
= ocfs2_validate_meta_ecc(sb
, bh
->b_data
, &trailer
->db_check
);
464 mlog(ML_ERROR
, "Checksum failed for dinode %llu\n",
465 (unsigned long long)bh
->b_blocknr
);
471 * Validate a directory trailer.
473 * We check the trailer here rather than in ocfs2_validate_dir_block()
474 * because that function doesn't have the inode to test.
476 static int ocfs2_check_dir_trailer(struct inode
*dir
, struct buffer_head
*bh
)
479 struct ocfs2_dir_block_trailer
*trailer
;
481 trailer
= ocfs2_trailer_from_bh(bh
, dir
->i_sb
);
482 if (!OCFS2_IS_VALID_DIR_TRAILER(trailer
)) {
484 ocfs2_error(dir
->i_sb
,
485 "Invalid dirblock #%llu: "
486 "signature = %.*s\n",
487 (unsigned long long)bh
->b_blocknr
, 7,
488 trailer
->db_signature
);
491 if (le64_to_cpu(trailer
->db_blkno
) != bh
->b_blocknr
) {
493 ocfs2_error(dir
->i_sb
,
494 "Directory block #%llu has an invalid "
496 (unsigned long long)bh
->b_blocknr
,
497 (unsigned long long)le64_to_cpu(trailer
->db_blkno
));
500 if (le64_to_cpu(trailer
->db_parent_dinode
) !=
501 OCFS2_I(dir
)->ip_blkno
) {
503 ocfs2_error(dir
->i_sb
,
504 "Directory block #%llu on dinode "
505 "#%llu has an invalid parent_dinode "
507 (unsigned long long)bh
->b_blocknr
,
508 (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
509 (unsigned long long)le64_to_cpu(trailer
->db_blkno
));
517 * This function forces all errors to -EIO for consistency with its
518 * predecessor, ocfs2_bread(). We haven't audited what returning the
519 * real error codes would do to callers. We log the real codes with
520 * mlog_errno() before we squash them.
522 static int ocfs2_read_dir_block(struct inode
*inode
, u64 v_block
,
523 struct buffer_head
**bh
, int flags
)
526 struct buffer_head
*tmp
= *bh
;
528 rc
= ocfs2_read_virt_blocks(inode
, v_block
, 1, &tmp
, flags
,
529 ocfs2_validate_dir_block
);
535 if (!(flags
& OCFS2_BH_READAHEAD
) &&
536 ocfs2_supports_dir_trailer(inode
)) {
537 rc
= ocfs2_check_dir_trailer(inode
, tmp
);
546 /* If ocfs2_read_virt_blocks() got us a new bh, pass it up. */
551 return rc
? -EIO
: 0;
555 * Read the block at 'phys' which belongs to this directory
556 * inode. This function does no virtual->physical block translation -
557 * what's passed in is assumed to be a valid directory block.
559 static int ocfs2_read_dir_block_direct(struct inode
*dir
, u64 phys
,
560 struct buffer_head
**bh
)
563 struct buffer_head
*tmp
= *bh
;
565 ret
= ocfs2_read_block(INODE_CACHE(dir
), phys
, &tmp
,
566 ocfs2_validate_dir_block
);
572 if (ocfs2_supports_dir_trailer(dir
)) {
573 ret
= ocfs2_check_dir_trailer(dir
, tmp
);
588 static int ocfs2_validate_dx_root(struct super_block
*sb
,
589 struct buffer_head
*bh
)
592 struct ocfs2_dx_root_block
*dx_root
;
594 BUG_ON(!buffer_uptodate(bh
));
596 dx_root
= (struct ocfs2_dx_root_block
*) bh
->b_data
;
598 ret
= ocfs2_validate_meta_ecc(sb
, bh
->b_data
, &dx_root
->dr_check
);
601 "Checksum failed for dir index root block %llu\n",
602 (unsigned long long)bh
->b_blocknr
);
606 if (!OCFS2_IS_VALID_DX_ROOT(dx_root
)) {
608 "Dir Index Root # %llu has bad signature %.*s",
609 (unsigned long long)le64_to_cpu(dx_root
->dr_blkno
),
610 7, dx_root
->dr_signature
);
617 static int ocfs2_read_dx_root(struct inode
*dir
, struct ocfs2_dinode
*di
,
618 struct buffer_head
**dx_root_bh
)
621 u64 blkno
= le64_to_cpu(di
->i_dx_root
);
622 struct buffer_head
*tmp
= *dx_root_bh
;
624 ret
= ocfs2_read_block(INODE_CACHE(dir
), blkno
, &tmp
,
625 ocfs2_validate_dx_root
);
627 /* If ocfs2_read_block() got us a new bh, pass it up. */
628 if (!ret
&& !*dx_root_bh
)
634 static int ocfs2_validate_dx_leaf(struct super_block
*sb
,
635 struct buffer_head
*bh
)
638 struct ocfs2_dx_leaf
*dx_leaf
= (struct ocfs2_dx_leaf
*)bh
->b_data
;
640 BUG_ON(!buffer_uptodate(bh
));
642 ret
= ocfs2_validate_meta_ecc(sb
, bh
->b_data
, &dx_leaf
->dl_check
);
645 "Checksum failed for dir index leaf block %llu\n",
646 (unsigned long long)bh
->b_blocknr
);
650 if (!OCFS2_IS_VALID_DX_LEAF(dx_leaf
)) {
651 ocfs2_error(sb
, "Dir Index Leaf has bad signature %.*s",
652 7, dx_leaf
->dl_signature
);
659 static int ocfs2_read_dx_leaf(struct inode
*dir
, u64 blkno
,
660 struct buffer_head
**dx_leaf_bh
)
663 struct buffer_head
*tmp
= *dx_leaf_bh
;
665 ret
= ocfs2_read_block(INODE_CACHE(dir
), blkno
, &tmp
,
666 ocfs2_validate_dx_leaf
);
668 /* If ocfs2_read_block() got us a new bh, pass it up. */
669 if (!ret
&& !*dx_leaf_bh
)
676 * Read a series of dx_leaf blocks. This expects all buffer_head
677 * pointers to be NULL on function entry.
679 static int ocfs2_read_dx_leaves(struct inode
*dir
, u64 start
, int num
,
680 struct buffer_head
**dx_leaf_bhs
)
684 ret
= ocfs2_read_blocks(INODE_CACHE(dir
), start
, num
, dx_leaf_bhs
, 0,
685 ocfs2_validate_dx_leaf
);
692 static struct buffer_head
*ocfs2_find_entry_el(const char *name
, int namelen
,
694 struct ocfs2_dir_entry
**res_dir
)
696 struct super_block
*sb
;
697 struct buffer_head
*bh_use
[NAMEI_RA_SIZE
];
698 struct buffer_head
*bh
, *ret
= NULL
;
699 unsigned long start
, block
, b
;
700 int ra_max
= 0; /* Number of bh's in the readahead
702 int ra_ptr
= 0; /* Current index into readahead
709 nblocks
= i_size_read(dir
) >> sb
->s_blocksize_bits
;
710 start
= OCFS2_I(dir
)->ip_dir_start_lookup
;
711 if (start
>= nblocks
)
718 * We deal with the read-ahead logic here.
720 if (ra_ptr
>= ra_max
) {
721 /* Refill the readahead buffer */
724 for (ra_max
= 0; ra_max
< NAMEI_RA_SIZE
; ra_max
++) {
726 * Terminate if we reach the end of the
727 * directory and must wrap, or if our
728 * search has finished at this block.
730 if (b
>= nblocks
|| (num
&& block
== start
)) {
731 bh_use
[ra_max
] = NULL
;
737 err
= ocfs2_read_dir_block(dir
, b
++, &bh
,
742 if ((bh
= bh_use
[ra_ptr
++]) == NULL
)
744 if (ocfs2_read_dir_block(dir
, block
, &bh
, 0)) {
745 /* read error, skip block & hope for the best.
746 * ocfs2_read_dir_block() has released the bh. */
747 ocfs2_error(dir
->i_sb
, "reading directory %llu, "
749 (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
753 i
= ocfs2_search_dirblock(bh
, dir
, name
, namelen
,
754 block
<< sb
->s_blocksize_bits
,
755 bh
->b_data
, sb
->s_blocksize
,
758 OCFS2_I(dir
)->ip_dir_start_lookup
= block
;
760 goto cleanup_and_exit
;
764 goto cleanup_and_exit
;
767 if (++block
>= nblocks
)
769 } while (block
!= start
);
772 * If the directory has grown while we were searching, then
773 * search the last part of the directory before giving up.
776 nblocks
= i_size_read(dir
) >> sb
->s_blocksize_bits
;
777 if (block
< nblocks
) {
783 /* Clean up the read-ahead blocks */
784 for (; ra_ptr
< ra_max
; ra_ptr
++)
785 brelse(bh_use
[ra_ptr
]);
787 trace_ocfs2_find_entry_el(ret
);
791 static int ocfs2_dx_dir_lookup_rec(struct inode
*inode
,
792 struct ocfs2_extent_list
*el
,
796 unsigned int *ret_clen
)
798 int ret
= 0, i
, found
;
799 struct buffer_head
*eb_bh
= NULL
;
800 struct ocfs2_extent_block
*eb
;
801 struct ocfs2_extent_rec
*rec
= NULL
;
803 if (el
->l_tree_depth
) {
804 ret
= ocfs2_find_leaf(INODE_CACHE(inode
), el
, major_hash
,
811 eb
= (struct ocfs2_extent_block
*) eb_bh
->b_data
;
814 if (el
->l_tree_depth
) {
815 ocfs2_error(inode
->i_sb
,
816 "Inode %lu has non zero tree depth in "
817 "btree tree block %llu\n", inode
->i_ino
,
818 (unsigned long long)eb_bh
->b_blocknr
);
825 for (i
= le16_to_cpu(el
->l_next_free_rec
) - 1; i
>= 0; i
--) {
826 rec
= &el
->l_recs
[i
];
828 if (le32_to_cpu(rec
->e_cpos
) <= major_hash
) {
835 ocfs2_error(inode
->i_sb
, "Inode %lu has bad extent "
836 "record (%u, %u, 0) in btree", inode
->i_ino
,
837 le32_to_cpu(rec
->e_cpos
),
838 ocfs2_rec_clusters(el
, rec
));
844 *ret_phys_blkno
= le64_to_cpu(rec
->e_blkno
);
846 *ret_cpos
= le32_to_cpu(rec
->e_cpos
);
848 *ret_clen
= le16_to_cpu(rec
->e_leaf_clusters
);
856 * Returns the block index, from the start of the cluster which this
859 static inline unsigned int __ocfs2_dx_dir_hash_idx(struct ocfs2_super
*osb
,
862 return minor_hash
& osb
->osb_dx_mask
;
865 static inline unsigned int ocfs2_dx_dir_hash_idx(struct ocfs2_super
*osb
,
866 struct ocfs2_dx_hinfo
*hinfo
)
868 return __ocfs2_dx_dir_hash_idx(osb
, hinfo
->minor_hash
);
871 static int ocfs2_dx_dir_lookup(struct inode
*inode
,
872 struct ocfs2_extent_list
*el
,
873 struct ocfs2_dx_hinfo
*hinfo
,
878 unsigned int cend
, uninitialized_var(clen
);
879 u32
uninitialized_var(cpos
);
880 u64
uninitialized_var(blkno
);
881 u32 name_hash
= hinfo
->major_hash
;
883 ret
= ocfs2_dx_dir_lookup_rec(inode
, el
, name_hash
, &cpos
, &blkno
,
891 if (name_hash
>= cend
) {
892 /* We want the last cluster */
893 blkno
+= ocfs2_clusters_to_blocks(inode
->i_sb
, clen
- 1);
896 blkno
+= ocfs2_clusters_to_blocks(inode
->i_sb
,
902 * We now have the cluster which should hold our entry. To
903 * find the exact block from the start of the cluster to
904 * search, we take the lower bits of the hash.
906 blkno
+= ocfs2_dx_dir_hash_idx(OCFS2_SB(inode
->i_sb
), hinfo
);
909 *ret_phys_blkno
= blkno
;
918 static int ocfs2_dx_dir_search(const char *name
, int namelen
,
920 struct ocfs2_dx_root_block
*dx_root
,
921 struct ocfs2_dir_lookup_result
*res
)
924 u64
uninitialized_var(phys
);
925 struct buffer_head
*dx_leaf_bh
= NULL
;
926 struct ocfs2_dx_leaf
*dx_leaf
;
927 struct ocfs2_dx_entry
*dx_entry
= NULL
;
928 struct buffer_head
*dir_ent_bh
= NULL
;
929 struct ocfs2_dir_entry
*dir_ent
= NULL
;
930 struct ocfs2_dx_hinfo
*hinfo
= &res
->dl_hinfo
;
931 struct ocfs2_extent_list
*dr_el
;
932 struct ocfs2_dx_entry_list
*entry_list
;
934 ocfs2_dx_dir_name_hash(dir
, name
, namelen
, &res
->dl_hinfo
);
936 if (ocfs2_dx_root_inline(dx_root
)) {
937 entry_list
= &dx_root
->dr_entries
;
941 dr_el
= &dx_root
->dr_list
;
943 ret
= ocfs2_dx_dir_lookup(dir
, dr_el
, hinfo
, NULL
, &phys
);
949 trace_ocfs2_dx_dir_search((unsigned long long)OCFS2_I(dir
)->ip_blkno
,
950 namelen
, name
, hinfo
->major_hash
,
951 hinfo
->minor_hash
, (unsigned long long)phys
);
953 ret
= ocfs2_read_dx_leaf(dir
, phys
, &dx_leaf_bh
);
959 dx_leaf
= (struct ocfs2_dx_leaf
*) dx_leaf_bh
->b_data
;
961 trace_ocfs2_dx_dir_search_leaf_info(
962 le16_to_cpu(dx_leaf
->dl_list
.de_num_used
),
963 le16_to_cpu(dx_leaf
->dl_list
.de_count
));
965 entry_list
= &dx_leaf
->dl_list
;
969 * Empty leaf is legal, so no need to check for that.
972 for (i
= 0; i
< le16_to_cpu(entry_list
->de_num_used
); i
++) {
973 dx_entry
= &entry_list
->de_entries
[i
];
975 if (hinfo
->major_hash
!= le32_to_cpu(dx_entry
->dx_major_hash
)
976 || hinfo
->minor_hash
!= le32_to_cpu(dx_entry
->dx_minor_hash
))
980 * Search unindexed leaf block now. We're not
981 * guaranteed to find anything.
983 ret
= ocfs2_read_dir_block_direct(dir
,
984 le64_to_cpu(dx_entry
->dx_dirent_blk
),
992 * XXX: We should check the unindexed block here,
996 found
= ocfs2_search_dirblock(dir_ent_bh
, dir
, name
, namelen
,
997 0, dir_ent_bh
->b_data
,
998 dir
->i_sb
->s_blocksize
, &dir_ent
);
1003 /* This means we found a bad directory entry. */
1018 res
->dl_leaf_bh
= dir_ent_bh
;
1019 res
->dl_entry
= dir_ent
;
1020 res
->dl_dx_leaf_bh
= dx_leaf_bh
;
1021 res
->dl_dx_entry
= dx_entry
;
1032 static int ocfs2_find_entry_dx(const char *name
, int namelen
,
1034 struct ocfs2_dir_lookup_result
*lookup
)
1037 struct buffer_head
*di_bh
= NULL
;
1038 struct ocfs2_dinode
*di
;
1039 struct buffer_head
*dx_root_bh
= NULL
;
1040 struct ocfs2_dx_root_block
*dx_root
;
1042 ret
= ocfs2_read_inode_block(dir
, &di_bh
);
1048 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
1050 ret
= ocfs2_read_dx_root(dir
, di
, &dx_root_bh
);
1055 dx_root
= (struct ocfs2_dx_root_block
*) dx_root_bh
->b_data
;
1057 ret
= ocfs2_dx_dir_search(name
, namelen
, dir
, dx_root
, lookup
);
1064 lookup
->dl_dx_root_bh
= dx_root_bh
;
1073 * Try to find an entry of the provided name within 'dir'.
1075 * If nothing was found, -ENOENT is returned. Otherwise, zero is
1076 * returned and the struct 'res' will contain information useful to
1077 * other directory manipulation functions.
1079 * Caller can NOT assume anything about the contents of the
1080 * buffer_heads - they are passed back only so that it can be passed
1081 * into any one of the manipulation functions (add entry, delete
1082 * entry, etc). As an example, bh in the extent directory case is a
1083 * data block, in the inline-data case it actually points to an inode,
1084 * in the indexed directory case, multiple buffers are involved.
1086 int ocfs2_find_entry(const char *name
, int namelen
,
1087 struct inode
*dir
, struct ocfs2_dir_lookup_result
*lookup
)
1089 struct buffer_head
*bh
;
1090 struct ocfs2_dir_entry
*res_dir
= NULL
;
1092 if (ocfs2_dir_indexed(dir
))
1093 return ocfs2_find_entry_dx(name
, namelen
, dir
, lookup
);
1096 * The unindexed dir code only uses part of the lookup
1097 * structure, so there's no reason to push it down further
1100 if (OCFS2_I(dir
)->ip_dyn_features
& OCFS2_INLINE_DATA_FL
)
1101 bh
= ocfs2_find_entry_id(name
, namelen
, dir
, &res_dir
);
1103 bh
= ocfs2_find_entry_el(name
, namelen
, dir
, &res_dir
);
1108 lookup
->dl_leaf_bh
= bh
;
1109 lookup
->dl_entry
= res_dir
;
1114 * Update inode number and type of a previously found directory entry.
1116 int ocfs2_update_entry(struct inode
*dir
, handle_t
*handle
,
1117 struct ocfs2_dir_lookup_result
*res
,
1118 struct inode
*new_entry_inode
)
1121 ocfs2_journal_access_func access
= ocfs2_journal_access_db
;
1122 struct ocfs2_dir_entry
*de
= res
->dl_entry
;
1123 struct buffer_head
*de_bh
= res
->dl_leaf_bh
;
1126 * The same code works fine for both inline-data and extent
1127 * based directories, so no need to split this up. The only
1128 * difference is the journal_access function.
1131 if (OCFS2_I(dir
)->ip_dyn_features
& OCFS2_INLINE_DATA_FL
)
1132 access
= ocfs2_journal_access_di
;
1134 ret
= access(handle
, INODE_CACHE(dir
), de_bh
,
1135 OCFS2_JOURNAL_ACCESS_WRITE
);
1141 de
->inode
= cpu_to_le64(OCFS2_I(new_entry_inode
)->ip_blkno
);
1142 ocfs2_set_de_type(de
, new_entry_inode
->i_mode
);
1144 ocfs2_journal_dirty(handle
, de_bh
);
1151 * __ocfs2_delete_entry deletes a directory entry by merging it with the
1154 static int __ocfs2_delete_entry(handle_t
*handle
, struct inode
*dir
,
1155 struct ocfs2_dir_entry
*de_del
,
1156 struct buffer_head
*bh
, char *first_de
,
1159 struct ocfs2_dir_entry
*de
, *pde
;
1160 int i
, status
= -ENOENT
;
1161 ocfs2_journal_access_func access
= ocfs2_journal_access_db
;
1163 if (OCFS2_I(dir
)->ip_dyn_features
& OCFS2_INLINE_DATA_FL
)
1164 access
= ocfs2_journal_access_di
;
1168 de
= (struct ocfs2_dir_entry
*) first_de
;
1170 if (!ocfs2_check_dir_entry(dir
, de
, bh
, i
)) {
1176 status
= access(handle
, INODE_CACHE(dir
), bh
,
1177 OCFS2_JOURNAL_ACCESS_WRITE
);
1184 le16_add_cpu(&pde
->rec_len
,
1185 le16_to_cpu(de
->rec_len
));
1188 ocfs2_journal_dirty(handle
, bh
);
1191 i
+= le16_to_cpu(de
->rec_len
);
1193 de
= (struct ocfs2_dir_entry
*)((char *)de
+ le16_to_cpu(de
->rec_len
));
1199 static unsigned int ocfs2_figure_dirent_hole(struct ocfs2_dir_entry
*de
)
1203 if (le64_to_cpu(de
->inode
) == 0)
1204 hole
= le16_to_cpu(de
->rec_len
);
1206 hole
= le16_to_cpu(de
->rec_len
) -
1207 OCFS2_DIR_REC_LEN(de
->name_len
);
1212 static int ocfs2_find_max_rec_len(struct super_block
*sb
,
1213 struct buffer_head
*dirblock_bh
)
1215 int size
, this_hole
, largest_hole
= 0;
1216 char *trailer
, *de_buf
, *limit
, *start
= dirblock_bh
->b_data
;
1217 struct ocfs2_dir_entry
*de
;
1219 trailer
= (char *)ocfs2_trailer_from_bh(dirblock_bh
, sb
);
1220 size
= ocfs2_dir_trailer_blk_off(sb
);
1221 limit
= start
+ size
;
1223 de
= (struct ocfs2_dir_entry
*)de_buf
;
1225 if (de_buf
!= trailer
) {
1226 this_hole
= ocfs2_figure_dirent_hole(de
);
1227 if (this_hole
> largest_hole
)
1228 largest_hole
= this_hole
;
1231 de_buf
+= le16_to_cpu(de
->rec_len
);
1232 de
= (struct ocfs2_dir_entry
*)de_buf
;
1233 } while (de_buf
< limit
);
1235 if (largest_hole
>= OCFS2_DIR_MIN_REC_LEN
)
1236 return largest_hole
;
1240 static void ocfs2_dx_list_remove_entry(struct ocfs2_dx_entry_list
*entry_list
,
1243 int num_used
= le16_to_cpu(entry_list
->de_num_used
);
1245 if (num_used
== 1 || index
== (num_used
- 1))
1248 memmove(&entry_list
->de_entries
[index
],
1249 &entry_list
->de_entries
[index
+ 1],
1250 (num_used
- index
- 1)*sizeof(struct ocfs2_dx_entry
));
1253 memset(&entry_list
->de_entries
[num_used
], 0,
1254 sizeof(struct ocfs2_dx_entry
));
1255 entry_list
->de_num_used
= cpu_to_le16(num_used
);
1258 static int ocfs2_delete_entry_dx(handle_t
*handle
, struct inode
*dir
,
1259 struct ocfs2_dir_lookup_result
*lookup
)
1261 int ret
, index
, max_rec_len
, add_to_free_list
= 0;
1262 struct buffer_head
*dx_root_bh
= lookup
->dl_dx_root_bh
;
1263 struct buffer_head
*leaf_bh
= lookup
->dl_leaf_bh
;
1264 struct ocfs2_dx_leaf
*dx_leaf
;
1265 struct ocfs2_dx_entry
*dx_entry
= lookup
->dl_dx_entry
;
1266 struct ocfs2_dir_block_trailer
*trailer
;
1267 struct ocfs2_dx_root_block
*dx_root
;
1268 struct ocfs2_dx_entry_list
*entry_list
;
1271 * This function gets a bit messy because we might have to
1272 * modify the root block, regardless of whether the indexed
1273 * entries are stored inline.
1277 * *Only* set 'entry_list' here, based on where we're looking
1278 * for the indexed entries. Later, we might still want to
1279 * journal both blocks, based on free list state.
1281 dx_root
= (struct ocfs2_dx_root_block
*)dx_root_bh
->b_data
;
1282 if (ocfs2_dx_root_inline(dx_root
)) {
1283 entry_list
= &dx_root
->dr_entries
;
1285 dx_leaf
= (struct ocfs2_dx_leaf
*) lookup
->dl_dx_leaf_bh
->b_data
;
1286 entry_list
= &dx_leaf
->dl_list
;
1289 /* Neither of these are a disk corruption - that should have
1290 * been caught by lookup, before we got here. */
1291 BUG_ON(le16_to_cpu(entry_list
->de_count
) <= 0);
1292 BUG_ON(le16_to_cpu(entry_list
->de_num_used
) <= 0);
1294 index
= (char *)dx_entry
- (char *)entry_list
->de_entries
;
1295 index
/= sizeof(*dx_entry
);
1297 if (index
>= le16_to_cpu(entry_list
->de_num_used
)) {
1298 mlog(ML_ERROR
, "Dir %llu: Bad dx_entry ptr idx %d, (%p, %p)\n",
1299 (unsigned long long)OCFS2_I(dir
)->ip_blkno
, index
,
1300 entry_list
, dx_entry
);
1305 * We know that removal of this dirent will leave enough room
1306 * for a new one, so add this block to the free list if it
1307 * isn't already there.
1309 trailer
= ocfs2_trailer_from_bh(leaf_bh
, dir
->i_sb
);
1310 if (trailer
->db_free_rec_len
== 0)
1311 add_to_free_list
= 1;
1314 * Add the block holding our index into the journal before
1315 * removing the unindexed entry. If we get an error return
1316 * from __ocfs2_delete_entry(), then it hasn't removed the
1317 * entry yet. Likewise, successful return means we *must*
1318 * remove the indexed entry.
1320 * We're also careful to journal the root tree block here as
1321 * the entry count needs to be updated. Also, we might be
1322 * adding to the start of the free list.
1324 ret
= ocfs2_journal_access_dr(handle
, INODE_CACHE(dir
), dx_root_bh
,
1325 OCFS2_JOURNAL_ACCESS_WRITE
);
1331 if (!ocfs2_dx_root_inline(dx_root
)) {
1332 ret
= ocfs2_journal_access_dl(handle
, INODE_CACHE(dir
),
1333 lookup
->dl_dx_leaf_bh
,
1334 OCFS2_JOURNAL_ACCESS_WRITE
);
1341 trace_ocfs2_delete_entry_dx((unsigned long long)OCFS2_I(dir
)->ip_blkno
,
1344 ret
= __ocfs2_delete_entry(handle
, dir
, lookup
->dl_entry
,
1345 leaf_bh
, leaf_bh
->b_data
, leaf_bh
->b_size
);
1351 max_rec_len
= ocfs2_find_max_rec_len(dir
->i_sb
, leaf_bh
);
1352 trailer
->db_free_rec_len
= cpu_to_le16(max_rec_len
);
1353 if (add_to_free_list
) {
1354 trailer
->db_free_next
= dx_root
->dr_free_blk
;
1355 dx_root
->dr_free_blk
= cpu_to_le64(leaf_bh
->b_blocknr
);
1356 ocfs2_journal_dirty(handle
, dx_root_bh
);
1359 /* leaf_bh was journal_accessed for us in __ocfs2_delete_entry */
1360 ocfs2_journal_dirty(handle
, leaf_bh
);
1362 le32_add_cpu(&dx_root
->dr_num_entries
, -1);
1363 ocfs2_journal_dirty(handle
, dx_root_bh
);
1365 ocfs2_dx_list_remove_entry(entry_list
, index
);
1367 if (!ocfs2_dx_root_inline(dx_root
))
1368 ocfs2_journal_dirty(handle
, lookup
->dl_dx_leaf_bh
);
1374 static inline int ocfs2_delete_entry_id(handle_t
*handle
,
1376 struct ocfs2_dir_entry
*de_del
,
1377 struct buffer_head
*bh
)
1380 struct buffer_head
*di_bh
= NULL
;
1381 struct ocfs2_dinode
*di
;
1382 struct ocfs2_inline_data
*data
;
1384 ret
= ocfs2_read_inode_block(dir
, &di_bh
);
1390 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
1391 data
= &di
->id2
.i_data
;
1393 ret
= __ocfs2_delete_entry(handle
, dir
, de_del
, bh
, data
->id_data
,
1401 static inline int ocfs2_delete_entry_el(handle_t
*handle
,
1403 struct ocfs2_dir_entry
*de_del
,
1404 struct buffer_head
*bh
)
1406 return __ocfs2_delete_entry(handle
, dir
, de_del
, bh
, bh
->b_data
,
1411 * Delete a directory entry. Hide the details of directory
1412 * implementation from the caller.
1414 int ocfs2_delete_entry(handle_t
*handle
,
1416 struct ocfs2_dir_lookup_result
*res
)
1418 if (ocfs2_dir_indexed(dir
))
1419 return ocfs2_delete_entry_dx(handle
, dir
, res
);
1421 if (OCFS2_I(dir
)->ip_dyn_features
& OCFS2_INLINE_DATA_FL
)
1422 return ocfs2_delete_entry_id(handle
, dir
, res
->dl_entry
,
1425 return ocfs2_delete_entry_el(handle
, dir
, res
->dl_entry
,
1430 * Check whether 'de' has enough room to hold an entry of
1431 * 'new_rec_len' bytes.
1433 static inline int ocfs2_dirent_would_fit(struct ocfs2_dir_entry
*de
,
1434 unsigned int new_rec_len
)
1436 unsigned int de_really_used
;
1438 /* Check whether this is an empty record with enough space */
1439 if (le64_to_cpu(de
->inode
) == 0 &&
1440 le16_to_cpu(de
->rec_len
) >= new_rec_len
)
1444 * Record might have free space at the end which we can
1447 de_really_used
= OCFS2_DIR_REC_LEN(de
->name_len
);
1448 if (le16_to_cpu(de
->rec_len
) >= (de_really_used
+ new_rec_len
))
1454 static void ocfs2_dx_dir_leaf_insert_tail(struct ocfs2_dx_leaf
*dx_leaf
,
1455 struct ocfs2_dx_entry
*dx_new_entry
)
1459 i
= le16_to_cpu(dx_leaf
->dl_list
.de_num_used
);
1460 dx_leaf
->dl_list
.de_entries
[i
] = *dx_new_entry
;
1462 le16_add_cpu(&dx_leaf
->dl_list
.de_num_used
, 1);
1465 static void ocfs2_dx_entry_list_insert(struct ocfs2_dx_entry_list
*entry_list
,
1466 struct ocfs2_dx_hinfo
*hinfo
,
1470 struct ocfs2_dx_entry
*dx_entry
;
1472 i
= le16_to_cpu(entry_list
->de_num_used
);
1473 dx_entry
= &entry_list
->de_entries
[i
];
1475 memset(dx_entry
, 0, sizeof(*dx_entry
));
1476 dx_entry
->dx_major_hash
= cpu_to_le32(hinfo
->major_hash
);
1477 dx_entry
->dx_minor_hash
= cpu_to_le32(hinfo
->minor_hash
);
1478 dx_entry
->dx_dirent_blk
= cpu_to_le64(dirent_blk
);
1480 le16_add_cpu(&entry_list
->de_num_used
, 1);
1483 static int __ocfs2_dx_dir_leaf_insert(struct inode
*dir
, handle_t
*handle
,
1484 struct ocfs2_dx_hinfo
*hinfo
,
1486 struct buffer_head
*dx_leaf_bh
)
1489 struct ocfs2_dx_leaf
*dx_leaf
;
1491 ret
= ocfs2_journal_access_dl(handle
, INODE_CACHE(dir
), dx_leaf_bh
,
1492 OCFS2_JOURNAL_ACCESS_WRITE
);
1498 dx_leaf
= (struct ocfs2_dx_leaf
*)dx_leaf_bh
->b_data
;
1499 ocfs2_dx_entry_list_insert(&dx_leaf
->dl_list
, hinfo
, dirent_blk
);
1500 ocfs2_journal_dirty(handle
, dx_leaf_bh
);
1506 static void ocfs2_dx_inline_root_insert(struct inode
*dir
, handle_t
*handle
,
1507 struct ocfs2_dx_hinfo
*hinfo
,
1509 struct ocfs2_dx_root_block
*dx_root
)
1511 ocfs2_dx_entry_list_insert(&dx_root
->dr_entries
, hinfo
, dirent_blk
);
1514 static int ocfs2_dx_dir_insert(struct inode
*dir
, handle_t
*handle
,
1515 struct ocfs2_dir_lookup_result
*lookup
)
1518 struct ocfs2_dx_root_block
*dx_root
;
1519 struct buffer_head
*dx_root_bh
= lookup
->dl_dx_root_bh
;
1521 ret
= ocfs2_journal_access_dr(handle
, INODE_CACHE(dir
), dx_root_bh
,
1522 OCFS2_JOURNAL_ACCESS_WRITE
);
1528 dx_root
= (struct ocfs2_dx_root_block
*)lookup
->dl_dx_root_bh
->b_data
;
1529 if (ocfs2_dx_root_inline(dx_root
)) {
1530 ocfs2_dx_inline_root_insert(dir
, handle
,
1532 lookup
->dl_leaf_bh
->b_blocknr
,
1535 ret
= __ocfs2_dx_dir_leaf_insert(dir
, handle
, &lookup
->dl_hinfo
,
1536 lookup
->dl_leaf_bh
->b_blocknr
,
1537 lookup
->dl_dx_leaf_bh
);
1542 le32_add_cpu(&dx_root
->dr_num_entries
, 1);
1543 ocfs2_journal_dirty(handle
, dx_root_bh
);
1549 static void ocfs2_remove_block_from_free_list(struct inode
*dir
,
1551 struct ocfs2_dir_lookup_result
*lookup
)
1553 struct ocfs2_dir_block_trailer
*trailer
, *prev
;
1554 struct ocfs2_dx_root_block
*dx_root
;
1555 struct buffer_head
*bh
;
1557 trailer
= ocfs2_trailer_from_bh(lookup
->dl_leaf_bh
, dir
->i_sb
);
1559 if (ocfs2_free_list_at_root(lookup
)) {
1560 bh
= lookup
->dl_dx_root_bh
;
1561 dx_root
= (struct ocfs2_dx_root_block
*)bh
->b_data
;
1562 dx_root
->dr_free_blk
= trailer
->db_free_next
;
1564 bh
= lookup
->dl_prev_leaf_bh
;
1565 prev
= ocfs2_trailer_from_bh(bh
, dir
->i_sb
);
1566 prev
->db_free_next
= trailer
->db_free_next
;
1569 trailer
->db_free_rec_len
= cpu_to_le16(0);
1570 trailer
->db_free_next
= cpu_to_le64(0);
1572 ocfs2_journal_dirty(handle
, bh
);
1573 ocfs2_journal_dirty(handle
, lookup
->dl_leaf_bh
);
1577 * This expects that a journal write has been reserved on
1578 * lookup->dl_prev_leaf_bh or lookup->dl_dx_root_bh
1580 static void ocfs2_recalc_free_list(struct inode
*dir
, handle_t
*handle
,
1581 struct ocfs2_dir_lookup_result
*lookup
)
1584 struct ocfs2_dir_block_trailer
*trailer
;
1586 /* Walk dl_leaf_bh to figure out what the new free rec_len is. */
1587 max_rec_len
= ocfs2_find_max_rec_len(dir
->i_sb
, lookup
->dl_leaf_bh
);
1590 * There's still room in this block, so no need to remove it
1591 * from the free list. In this case, we just want to update
1592 * the rec len accounting.
1594 trailer
= ocfs2_trailer_from_bh(lookup
->dl_leaf_bh
, dir
->i_sb
);
1595 trailer
->db_free_rec_len
= cpu_to_le16(max_rec_len
);
1596 ocfs2_journal_dirty(handle
, lookup
->dl_leaf_bh
);
1598 ocfs2_remove_block_from_free_list(dir
, handle
, lookup
);
1602 /* we don't always have a dentry for what we want to add, so people
1603 * like orphan dir can call this instead.
1605 * The lookup context must have been filled from
1606 * ocfs2_prepare_dir_for_insert.
1608 int __ocfs2_add_entry(handle_t
*handle
,
1610 const char *name
, int namelen
,
1611 struct inode
*inode
, u64 blkno
,
1612 struct buffer_head
*parent_fe_bh
,
1613 struct ocfs2_dir_lookup_result
*lookup
)
1615 unsigned long offset
;
1616 unsigned short rec_len
;
1617 struct ocfs2_dir_entry
*de
, *de1
;
1618 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)parent_fe_bh
->b_data
;
1619 struct super_block
*sb
= dir
->i_sb
;
1621 unsigned int size
= sb
->s_blocksize
;
1622 struct buffer_head
*insert_bh
= lookup
->dl_leaf_bh
;
1623 char *data_start
= insert_bh
->b_data
;
1628 if (ocfs2_dir_indexed(dir
)) {
1629 struct buffer_head
*bh
;
1632 * An indexed dir may require that we update the free space
1633 * list. Reserve a write to the previous node in the list so
1634 * that we don't fail later.
1636 * XXX: This can be either a dx_root_block, or an unindexed
1637 * directory tree leaf block.
1639 if (ocfs2_free_list_at_root(lookup
)) {
1640 bh
= lookup
->dl_dx_root_bh
;
1641 retval
= ocfs2_journal_access_dr(handle
,
1642 INODE_CACHE(dir
), bh
,
1643 OCFS2_JOURNAL_ACCESS_WRITE
);
1645 bh
= lookup
->dl_prev_leaf_bh
;
1646 retval
= ocfs2_journal_access_db(handle
,
1647 INODE_CACHE(dir
), bh
,
1648 OCFS2_JOURNAL_ACCESS_WRITE
);
1654 } else if (OCFS2_I(dir
)->ip_dyn_features
& OCFS2_INLINE_DATA_FL
) {
1655 data_start
= di
->id2
.i_data
.id_data
;
1656 size
= i_size_read(dir
);
1658 BUG_ON(insert_bh
!= parent_fe_bh
);
1661 rec_len
= OCFS2_DIR_REC_LEN(namelen
);
1663 de
= (struct ocfs2_dir_entry
*) data_start
;
1665 BUG_ON((char *)de
>= (size
+ data_start
));
1667 /* These checks should've already been passed by the
1668 * prepare function, but I guess we can leave them
1670 if (!ocfs2_check_dir_entry(dir
, de
, insert_bh
, offset
)) {
1674 if (ocfs2_match(namelen
, name
, de
)) {
1679 /* We're guaranteed that we should have space, so we
1680 * can't possibly have hit the trailer...right? */
1681 mlog_bug_on_msg(ocfs2_skip_dir_trailer(dir
, de
, offset
, size
),
1682 "Hit dir trailer trying to insert %.*s "
1683 "(namelen %d) into directory %llu. "
1684 "offset is %lu, trailer offset is %d\n",
1685 namelen
, name
, namelen
,
1686 (unsigned long long)parent_fe_bh
->b_blocknr
,
1687 offset
, ocfs2_dir_trailer_blk_off(dir
->i_sb
));
1689 if (ocfs2_dirent_would_fit(de
, rec_len
)) {
1690 dir
->i_mtime
= dir
->i_ctime
= CURRENT_TIME
;
1691 retval
= ocfs2_mark_inode_dirty(handle
, dir
, parent_fe_bh
);
1697 if (insert_bh
== parent_fe_bh
)
1698 status
= ocfs2_journal_access_di(handle
,
1701 OCFS2_JOURNAL_ACCESS_WRITE
);
1703 status
= ocfs2_journal_access_db(handle
,
1706 OCFS2_JOURNAL_ACCESS_WRITE
);
1708 if (ocfs2_dir_indexed(dir
)) {
1709 status
= ocfs2_dx_dir_insert(dir
,
1719 /* By now the buffer is marked for journaling */
1720 offset
+= le16_to_cpu(de
->rec_len
);
1721 if (le64_to_cpu(de
->inode
)) {
1722 de1
= (struct ocfs2_dir_entry
*)((char *) de
+
1723 OCFS2_DIR_REC_LEN(de
->name_len
));
1725 cpu_to_le16(le16_to_cpu(de
->rec_len
) -
1726 OCFS2_DIR_REC_LEN(de
->name_len
));
1727 de
->rec_len
= cpu_to_le16(OCFS2_DIR_REC_LEN(de
->name_len
));
1730 de
->file_type
= OCFS2_FT_UNKNOWN
;
1732 de
->inode
= cpu_to_le64(blkno
);
1733 ocfs2_set_de_type(de
, inode
->i_mode
);
1736 de
->name_len
= namelen
;
1737 memcpy(de
->name
, name
, namelen
);
1739 if (ocfs2_dir_indexed(dir
))
1740 ocfs2_recalc_free_list(dir
, handle
, lookup
);
1743 ocfs2_journal_dirty(handle
, insert_bh
);
1748 offset
+= le16_to_cpu(de
->rec_len
);
1749 de
= (struct ocfs2_dir_entry
*) ((char *) de
+ le16_to_cpu(de
->rec_len
));
1752 /* when you think about it, the assert above should prevent us
1753 * from ever getting here. */
1762 static int ocfs2_dir_foreach_blk_id(struct inode
*inode
,
1764 loff_t
*f_pos
, void *priv
,
1765 filldir_t filldir
, int *filldir_err
)
1767 int ret
, i
, filldir_ret
;
1768 unsigned long offset
= *f_pos
;
1769 struct buffer_head
*di_bh
= NULL
;
1770 struct ocfs2_dinode
*di
;
1771 struct ocfs2_inline_data
*data
;
1772 struct ocfs2_dir_entry
*de
;
1774 ret
= ocfs2_read_inode_block(inode
, &di_bh
);
1776 mlog(ML_ERROR
, "Unable to read inode block for dir %llu\n",
1777 (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
1781 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
1782 data
= &di
->id2
.i_data
;
1784 while (*f_pos
< i_size_read(inode
)) {
1786 /* If the dir block has changed since the last call to
1787 * readdir(2), then we might be pointing to an invalid
1788 * dirent right now. Scan from the start of the block
1790 if (*f_version
!= inode
->i_version
) {
1791 for (i
= 0; i
< i_size_read(inode
) && i
< offset
; ) {
1792 de
= (struct ocfs2_dir_entry
*)
1793 (data
->id_data
+ i
);
1794 /* It's too expensive to do a full
1795 * dirent test each time round this
1796 * loop, but we do have to test at
1797 * least that it is non-zero. A
1798 * failure will be detected in the
1799 * dirent test below. */
1800 if (le16_to_cpu(de
->rec_len
) <
1801 OCFS2_DIR_REC_LEN(1))
1803 i
+= le16_to_cpu(de
->rec_len
);
1805 *f_pos
= offset
= i
;
1806 *f_version
= inode
->i_version
;
1809 de
= (struct ocfs2_dir_entry
*) (data
->id_data
+ *f_pos
);
1810 if (!ocfs2_check_dir_entry(inode
, de
, di_bh
, *f_pos
)) {
1811 /* On error, skip the f_pos to the end. */
1812 *f_pos
= i_size_read(inode
);
1815 offset
+= le16_to_cpu(de
->rec_len
);
1816 if (le64_to_cpu(de
->inode
)) {
1817 /* We might block in the next section
1818 * if the data destination is
1819 * currently swapped out. So, use a
1820 * version stamp to detect whether or
1821 * not the directory has been modified
1822 * during the copy operation.
1824 u64 version
= *f_version
;
1825 unsigned char d_type
= DT_UNKNOWN
;
1827 if (de
->file_type
< OCFS2_FT_MAX
)
1828 d_type
= ocfs2_filetype_table
[de
->file_type
];
1830 filldir_ret
= filldir(priv
, de
->name
,
1833 le64_to_cpu(de
->inode
),
1837 *filldir_err
= filldir_ret
;
1840 if (version
!= *f_version
)
1843 *f_pos
+= le16_to_cpu(de
->rec_len
);
1853 * NOTE: This function can be called against unindexed directories,
1856 static int ocfs2_dir_foreach_blk_el(struct inode
*inode
,
1858 loff_t
*f_pos
, void *priv
,
1859 filldir_t filldir
, int *filldir_err
)
1862 unsigned long offset
, blk
, last_ra_blk
= 0;
1864 struct buffer_head
* bh
, * tmp
;
1865 struct ocfs2_dir_entry
* de
;
1866 struct super_block
* sb
= inode
->i_sb
;
1867 unsigned int ra_sectors
= 16;
1872 offset
= (*f_pos
) & (sb
->s_blocksize
- 1);
1874 while (!error
&& !stored
&& *f_pos
< i_size_read(inode
)) {
1875 blk
= (*f_pos
) >> sb
->s_blocksize_bits
;
1876 if (ocfs2_read_dir_block(inode
, blk
, &bh
, 0)) {
1877 /* Skip the corrupt dirblock and keep trying */
1878 *f_pos
+= sb
->s_blocksize
- offset
;
1882 /* The idea here is to begin with 8k read-ahead and to stay
1883 * 4k ahead of our current position.
1885 * TODO: Use the pagecache for this. We just need to
1886 * make sure it's cluster-safe... */
1888 || (((last_ra_blk
- blk
) << 9) <= (ra_sectors
/ 2))) {
1889 for (i
= ra_sectors
>> (sb
->s_blocksize_bits
- 9);
1892 if (!ocfs2_read_dir_block(inode
, ++blk
, &tmp
,
1893 OCFS2_BH_READAHEAD
))
1901 /* If the dir block has changed since the last call to
1902 * readdir(2), then we might be pointing to an invalid
1903 * dirent right now. Scan from the start of the block
1905 if (*f_version
!= inode
->i_version
) {
1906 for (i
= 0; i
< sb
->s_blocksize
&& i
< offset
; ) {
1907 de
= (struct ocfs2_dir_entry
*) (bh
->b_data
+ i
);
1908 /* It's too expensive to do a full
1909 * dirent test each time round this
1910 * loop, but we do have to test at
1911 * least that it is non-zero. A
1912 * failure will be detected in the
1913 * dirent test below. */
1914 if (le16_to_cpu(de
->rec_len
) <
1915 OCFS2_DIR_REC_LEN(1))
1917 i
+= le16_to_cpu(de
->rec_len
);
1920 *f_pos
= ((*f_pos
) & ~(sb
->s_blocksize
- 1))
1922 *f_version
= inode
->i_version
;
1925 while (!error
&& *f_pos
< i_size_read(inode
)
1926 && offset
< sb
->s_blocksize
) {
1927 de
= (struct ocfs2_dir_entry
*) (bh
->b_data
+ offset
);
1928 if (!ocfs2_check_dir_entry(inode
, de
, bh
, offset
)) {
1929 /* On error, skip the f_pos to the
1931 *f_pos
= ((*f_pos
) | (sb
->s_blocksize
- 1)) + 1;
1935 offset
+= le16_to_cpu(de
->rec_len
);
1936 if (le64_to_cpu(de
->inode
)) {
1937 /* We might block in the next section
1938 * if the data destination is
1939 * currently swapped out. So, use a
1940 * version stamp to detect whether or
1941 * not the directory has been modified
1942 * during the copy operation.
1944 unsigned long version
= *f_version
;
1945 unsigned char d_type
= DT_UNKNOWN
;
1947 if (de
->file_type
< OCFS2_FT_MAX
)
1948 d_type
= ocfs2_filetype_table
[de
->file_type
];
1949 error
= filldir(priv
, de
->name
,
1952 le64_to_cpu(de
->inode
),
1956 *filldir_err
= error
;
1959 if (version
!= *f_version
)
1963 *f_pos
+= le16_to_cpu(de
->rec_len
);
1975 static int ocfs2_dir_foreach_blk(struct inode
*inode
, u64
*f_version
,
1976 loff_t
*f_pos
, void *priv
, filldir_t filldir
,
1979 if (OCFS2_I(inode
)->ip_dyn_features
& OCFS2_INLINE_DATA_FL
)
1980 return ocfs2_dir_foreach_blk_id(inode
, f_version
, f_pos
, priv
,
1981 filldir
, filldir_err
);
1983 return ocfs2_dir_foreach_blk_el(inode
, f_version
, f_pos
, priv
, filldir
,
1988 * This is intended to be called from inside other kernel functions,
1989 * so we fake some arguments.
1991 int ocfs2_dir_foreach(struct inode
*inode
, loff_t
*f_pos
, void *priv
,
1994 int ret
= 0, filldir_err
= 0;
1995 u64 version
= inode
->i_version
;
1997 while (*f_pos
< i_size_read(inode
)) {
1998 ret
= ocfs2_dir_foreach_blk(inode
, &version
, f_pos
, priv
,
1999 filldir
, &filldir_err
);
2000 if (ret
|| filldir_err
)
2014 int ocfs2_readdir(struct file
* filp
, void * dirent
, filldir_t filldir
)
2017 struct inode
*inode
= file_inode(filp
);
2020 trace_ocfs2_readdir((unsigned long long)OCFS2_I(inode
)->ip_blkno
);
2022 error
= ocfs2_inode_lock_atime(inode
, filp
->f_path
.mnt
, &lock_level
);
2023 if (lock_level
&& error
>= 0) {
2024 /* We release EX lock which used to update atime
2025 * and get PR lock again to reduce contention
2026 * on commonly accessed directories. */
2027 ocfs2_inode_unlock(inode
, 1);
2029 error
= ocfs2_inode_lock(inode
, NULL
, 0);
2032 if (error
!= -ENOENT
)
2034 /* we haven't got any yet, so propagate the error. */
2038 error
= ocfs2_dir_foreach_blk(inode
, &filp
->f_version
, &filp
->f_pos
,
2039 dirent
, filldir
, NULL
);
2041 ocfs2_inode_unlock(inode
, lock_level
);
2051 * NOTE: this should always be called with parent dir i_mutex taken.
2053 int ocfs2_find_files_on_disk(const char *name
,
2056 struct inode
*inode
,
2057 struct ocfs2_dir_lookup_result
*lookup
)
2059 int status
= -ENOENT
;
2061 trace_ocfs2_find_files_on_disk(namelen
, name
, blkno
,
2062 (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
2064 status
= ocfs2_find_entry(name
, namelen
, inode
, lookup
);
2068 *blkno
= le64_to_cpu(lookup
->dl_entry
->inode
);
2077 * Convenience function for callers which just want the block number
2078 * mapped to a name and don't require the full dirent info, etc.
2080 int ocfs2_lookup_ino_from_name(struct inode
*dir
, const char *name
,
2081 int namelen
, u64
*blkno
)
2084 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
2086 ret
= ocfs2_find_files_on_disk(name
, namelen
, blkno
, dir
, &lookup
);
2087 ocfs2_free_dir_lookup_result(&lookup
);
2092 /* Check for a name within a directory.
2094 * Return 0 if the name does not exist
2095 * Return -EEXIST if the directory contains the name
2097 * Callers should have i_mutex + a cluster lock on dir
2099 int ocfs2_check_dir_for_entry(struct inode
*dir
,
2104 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
2106 trace_ocfs2_check_dir_for_entry(
2107 (unsigned long long)OCFS2_I(dir
)->ip_blkno
, namelen
, name
);
2110 if (ocfs2_find_entry(name
, namelen
, dir
, &lookup
) == 0)
2115 ocfs2_free_dir_lookup_result(&lookup
);
2122 struct ocfs2_empty_dir_priv
{
2124 unsigned seen_dot_dot
;
2125 unsigned seen_other
;
2128 static int ocfs2_empty_dir_filldir(void *priv
, const char *name
, int name_len
,
2129 loff_t pos
, u64 ino
, unsigned type
)
2131 struct ocfs2_empty_dir_priv
*p
= priv
;
2134 * Check the positions of "." and ".." records to be sure
2135 * they're in the correct place.
2137 * Indexed directories don't need to proceed past the first
2138 * two entries, so we end the scan after seeing '..'. Despite
2139 * that, we allow the scan to proceed In the event that we
2140 * have a corrupted indexed directory (no dot or dot dot
2141 * entries). This allows us to double check for existing
2142 * entries which might not have been found in the index.
2144 if (name_len
== 1 && !strncmp(".", name
, 1) && pos
== 0) {
2149 if (name_len
== 2 && !strncmp("..", name
, 2) &&
2150 pos
== OCFS2_DIR_REC_LEN(1)) {
2151 p
->seen_dot_dot
= 1;
2153 if (p
->dx_dir
&& p
->seen_dot
)
2163 static int ocfs2_empty_dir_dx(struct inode
*inode
,
2164 struct ocfs2_empty_dir_priv
*priv
)
2167 struct buffer_head
*di_bh
= NULL
;
2168 struct buffer_head
*dx_root_bh
= NULL
;
2169 struct ocfs2_dinode
*di
;
2170 struct ocfs2_dx_root_block
*dx_root
;
2174 ret
= ocfs2_read_inode_block(inode
, &di_bh
);
2179 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
2181 ret
= ocfs2_read_dx_root(inode
, di
, &dx_root_bh
);
2186 dx_root
= (struct ocfs2_dx_root_block
*)dx_root_bh
->b_data
;
2188 if (le32_to_cpu(dx_root
->dr_num_entries
) != 2)
2189 priv
->seen_other
= 1;
2198 * routine to check that the specified directory is empty (for rmdir)
2200 * Returns 1 if dir is empty, zero otherwise.
2202 * XXX: This is a performance problem for unindexed directories.
2204 int ocfs2_empty_dir(struct inode
*inode
)
2208 struct ocfs2_empty_dir_priv priv
;
2210 memset(&priv
, 0, sizeof(priv
));
2212 if (ocfs2_dir_indexed(inode
)) {
2213 ret
= ocfs2_empty_dir_dx(inode
, &priv
);
2217 * We still run ocfs2_dir_foreach to get the checks
2222 ret
= ocfs2_dir_foreach(inode
, &start
, &priv
, ocfs2_empty_dir_filldir
);
2226 if (!priv
.seen_dot
|| !priv
.seen_dot_dot
) {
2227 mlog(ML_ERROR
, "bad directory (dir #%llu) - no `.' or `..'\n",
2228 (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
2230 * XXX: Is it really safe to allow an unlink to continue?
2235 return !priv
.seen_other
;
2239 * Fills "." and ".." dirents in a new directory block. Returns dirent for
2240 * "..", which might be used during creation of a directory with a trailing
2241 * header. It is otherwise safe to ignore the return code.
2243 static struct ocfs2_dir_entry
*ocfs2_fill_initial_dirents(struct inode
*inode
,
2244 struct inode
*parent
,
2248 struct ocfs2_dir_entry
*de
= (struct ocfs2_dir_entry
*)start
;
2250 de
->inode
= cpu_to_le64(OCFS2_I(inode
)->ip_blkno
);
2253 cpu_to_le16(OCFS2_DIR_REC_LEN(de
->name_len
));
2254 strcpy(de
->name
, ".");
2255 ocfs2_set_de_type(de
, S_IFDIR
);
2257 de
= (struct ocfs2_dir_entry
*) ((char *)de
+ le16_to_cpu(de
->rec_len
));
2258 de
->inode
= cpu_to_le64(OCFS2_I(parent
)->ip_blkno
);
2259 de
->rec_len
= cpu_to_le16(size
- OCFS2_DIR_REC_LEN(1));
2261 strcpy(de
->name
, "..");
2262 ocfs2_set_de_type(de
, S_IFDIR
);
2268 * This works together with code in ocfs2_mknod_locked() which sets
2269 * the inline-data flag and initializes the inline-data section.
2271 static int ocfs2_fill_new_dir_id(struct ocfs2_super
*osb
,
2273 struct inode
*parent
,
2274 struct inode
*inode
,
2275 struct buffer_head
*di_bh
)
2278 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
2279 struct ocfs2_inline_data
*data
= &di
->id2
.i_data
;
2280 unsigned int size
= le16_to_cpu(data
->id_count
);
2282 ret
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
), di_bh
,
2283 OCFS2_JOURNAL_ACCESS_WRITE
);
2289 ocfs2_fill_initial_dirents(inode
, parent
, data
->id_data
, size
);
2290 ocfs2_journal_dirty(handle
, di_bh
);
2292 i_size_write(inode
, size
);
2293 set_nlink(inode
, 2);
2294 inode
->i_blocks
= ocfs2_inode_sector_count(inode
);
2296 ret
= ocfs2_mark_inode_dirty(handle
, inode
, di_bh
);
2304 static int ocfs2_fill_new_dir_el(struct ocfs2_super
*osb
,
2306 struct inode
*parent
,
2307 struct inode
*inode
,
2308 struct buffer_head
*fe_bh
,
2309 struct ocfs2_alloc_context
*data_ac
,
2310 struct buffer_head
**ret_new_bh
)
2313 unsigned int size
= osb
->sb
->s_blocksize
;
2314 struct buffer_head
*new_bh
= NULL
;
2315 struct ocfs2_dir_entry
*de
;
2317 if (ocfs2_new_dir_wants_trailer(inode
))
2318 size
= ocfs2_dir_trailer_blk_off(parent
->i_sb
);
2320 status
= ocfs2_do_extend_dir(osb
->sb
, handle
, inode
, fe_bh
,
2321 data_ac
, NULL
, &new_bh
);
2327 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode
), new_bh
);
2329 status
= ocfs2_journal_access_db(handle
, INODE_CACHE(inode
), new_bh
,
2330 OCFS2_JOURNAL_ACCESS_CREATE
);
2335 memset(new_bh
->b_data
, 0, osb
->sb
->s_blocksize
);
2337 de
= ocfs2_fill_initial_dirents(inode
, parent
, new_bh
->b_data
, size
);
2338 if (ocfs2_new_dir_wants_trailer(inode
)) {
2339 int size
= le16_to_cpu(de
->rec_len
);
2342 * Figure out the size of the hole left over after
2343 * insertion of '.' and '..'. The trailer wants this
2346 size
-= OCFS2_DIR_REC_LEN(2);
2347 size
-= sizeof(struct ocfs2_dir_block_trailer
);
2349 ocfs2_init_dir_trailer(inode
, new_bh
, size
);
2352 ocfs2_journal_dirty(handle
, new_bh
);
2354 i_size_write(inode
, inode
->i_sb
->s_blocksize
);
2355 set_nlink(inode
, 2);
2356 inode
->i_blocks
= ocfs2_inode_sector_count(inode
);
2357 status
= ocfs2_mark_inode_dirty(handle
, inode
, fe_bh
);
2365 *ret_new_bh
= new_bh
;
2374 static int ocfs2_dx_dir_attach_index(struct ocfs2_super
*osb
,
2375 handle_t
*handle
, struct inode
*dir
,
2376 struct buffer_head
*di_bh
,
2377 struct buffer_head
*dirdata_bh
,
2378 struct ocfs2_alloc_context
*meta_ac
,
2379 int dx_inline
, u32 num_entries
,
2380 struct buffer_head
**ret_dx_root_bh
)
2383 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*) di_bh
->b_data
;
2384 u16 dr_suballoc_bit
;
2385 u64 suballoc_loc
, dr_blkno
;
2386 unsigned int num_bits
;
2387 struct buffer_head
*dx_root_bh
= NULL
;
2388 struct ocfs2_dx_root_block
*dx_root
;
2389 struct ocfs2_dir_block_trailer
*trailer
=
2390 ocfs2_trailer_from_bh(dirdata_bh
, dir
->i_sb
);
2392 ret
= ocfs2_claim_metadata(handle
, meta_ac
, 1, &suballoc_loc
,
2393 &dr_suballoc_bit
, &num_bits
, &dr_blkno
);
2399 trace_ocfs2_dx_dir_attach_index(
2400 (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
2401 (unsigned long long)dr_blkno
);
2403 dx_root_bh
= sb_getblk(osb
->sb
, dr_blkno
);
2404 if (dx_root_bh
== NULL
) {
2408 ocfs2_set_new_buffer_uptodate(INODE_CACHE(dir
), dx_root_bh
);
2410 ret
= ocfs2_journal_access_dr(handle
, INODE_CACHE(dir
), dx_root_bh
,
2411 OCFS2_JOURNAL_ACCESS_CREATE
);
2417 dx_root
= (struct ocfs2_dx_root_block
*)dx_root_bh
->b_data
;
2418 memset(dx_root
, 0, osb
->sb
->s_blocksize
);
2419 strcpy(dx_root
->dr_signature
, OCFS2_DX_ROOT_SIGNATURE
);
2420 dx_root
->dr_suballoc_slot
= cpu_to_le16(meta_ac
->ac_alloc_slot
);
2421 dx_root
->dr_suballoc_loc
= cpu_to_le64(suballoc_loc
);
2422 dx_root
->dr_suballoc_bit
= cpu_to_le16(dr_suballoc_bit
);
2423 dx_root
->dr_fs_generation
= cpu_to_le32(osb
->fs_generation
);
2424 dx_root
->dr_blkno
= cpu_to_le64(dr_blkno
);
2425 dx_root
->dr_dir_blkno
= cpu_to_le64(OCFS2_I(dir
)->ip_blkno
);
2426 dx_root
->dr_num_entries
= cpu_to_le32(num_entries
);
2427 if (le16_to_cpu(trailer
->db_free_rec_len
))
2428 dx_root
->dr_free_blk
= cpu_to_le64(dirdata_bh
->b_blocknr
);
2430 dx_root
->dr_free_blk
= cpu_to_le64(0);
2433 dx_root
->dr_flags
|= OCFS2_DX_FLAG_INLINE
;
2434 dx_root
->dr_entries
.de_count
=
2435 cpu_to_le16(ocfs2_dx_entries_per_root(osb
->sb
));
2437 dx_root
->dr_list
.l_count
=
2438 cpu_to_le16(ocfs2_extent_recs_per_dx_root(osb
->sb
));
2440 ocfs2_journal_dirty(handle
, dx_root_bh
);
2442 ret
= ocfs2_journal_access_di(handle
, INODE_CACHE(dir
), di_bh
,
2443 OCFS2_JOURNAL_ACCESS_CREATE
);
2449 di
->i_dx_root
= cpu_to_le64(dr_blkno
);
2451 spin_lock(&OCFS2_I(dir
)->ip_lock
);
2452 OCFS2_I(dir
)->ip_dyn_features
|= OCFS2_INDEXED_DIR_FL
;
2453 di
->i_dyn_features
= cpu_to_le16(OCFS2_I(dir
)->ip_dyn_features
);
2454 spin_unlock(&OCFS2_I(dir
)->ip_lock
);
2456 ocfs2_journal_dirty(handle
, di_bh
);
2458 *ret_dx_root_bh
= dx_root_bh
;
2466 static int ocfs2_dx_dir_format_cluster(struct ocfs2_super
*osb
,
2467 handle_t
*handle
, struct inode
*dir
,
2468 struct buffer_head
**dx_leaves
,
2469 int num_dx_leaves
, u64 start_blk
)
2472 struct ocfs2_dx_leaf
*dx_leaf
;
2473 struct buffer_head
*bh
;
2475 for (i
= 0; i
< num_dx_leaves
; i
++) {
2476 bh
= sb_getblk(osb
->sb
, start_blk
+ i
);
2483 ocfs2_set_new_buffer_uptodate(INODE_CACHE(dir
), bh
);
2485 ret
= ocfs2_journal_access_dl(handle
, INODE_CACHE(dir
), bh
,
2486 OCFS2_JOURNAL_ACCESS_CREATE
);
2492 dx_leaf
= (struct ocfs2_dx_leaf
*) bh
->b_data
;
2494 memset(dx_leaf
, 0, osb
->sb
->s_blocksize
);
2495 strcpy(dx_leaf
->dl_signature
, OCFS2_DX_LEAF_SIGNATURE
);
2496 dx_leaf
->dl_fs_generation
= cpu_to_le32(osb
->fs_generation
);
2497 dx_leaf
->dl_blkno
= cpu_to_le64(bh
->b_blocknr
);
2498 dx_leaf
->dl_list
.de_count
=
2499 cpu_to_le16(ocfs2_dx_entries_per_leaf(osb
->sb
));
2501 trace_ocfs2_dx_dir_format_cluster(
2502 (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
2503 (unsigned long long)bh
->b_blocknr
,
2504 le16_to_cpu(dx_leaf
->dl_list
.de_count
));
2506 ocfs2_journal_dirty(handle
, bh
);
2515 * Allocates and formats a new cluster for use in an indexed dir
2516 * leaf. This version will not do the extent insert, so that it can be
2517 * used by operations which need careful ordering.
2519 static int __ocfs2_dx_dir_new_cluster(struct inode
*dir
,
2520 u32 cpos
, handle_t
*handle
,
2521 struct ocfs2_alloc_context
*data_ac
,
2522 struct buffer_head
**dx_leaves
,
2523 int num_dx_leaves
, u64
*ret_phys_blkno
)
2528 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
2531 * XXX: For create, this should claim cluster for the index
2532 * *before* the unindexed insert so that we have a better
2533 * chance of contiguousness as the directory grows in number
2536 ret
= __ocfs2_claim_clusters(handle
, data_ac
, 1, 1, &phys
, &num
);
2543 * Format the new cluster first. That way, we're inserting
2546 phys_blkno
= ocfs2_clusters_to_blocks(osb
->sb
, phys
);
2547 ret
= ocfs2_dx_dir_format_cluster(osb
, handle
, dir
, dx_leaves
,
2548 num_dx_leaves
, phys_blkno
);
2554 *ret_phys_blkno
= phys_blkno
;
2559 static int ocfs2_dx_dir_new_cluster(struct inode
*dir
,
2560 struct ocfs2_extent_tree
*et
,
2561 u32 cpos
, handle_t
*handle
,
2562 struct ocfs2_alloc_context
*data_ac
,
2563 struct ocfs2_alloc_context
*meta_ac
,
2564 struct buffer_head
**dx_leaves
,
2570 ret
= __ocfs2_dx_dir_new_cluster(dir
, cpos
, handle
, data_ac
, dx_leaves
,
2571 num_dx_leaves
, &phys_blkno
);
2577 ret
= ocfs2_insert_extent(handle
, et
, cpos
, phys_blkno
, 1, 0,
2585 static struct buffer_head
**ocfs2_dx_dir_kmalloc_leaves(struct super_block
*sb
,
2586 int *ret_num_leaves
)
2588 int num_dx_leaves
= ocfs2_clusters_to_blocks(sb
, 1);
2589 struct buffer_head
**dx_leaves
;
2591 dx_leaves
= kcalloc(num_dx_leaves
, sizeof(struct buffer_head
*),
2593 if (dx_leaves
&& ret_num_leaves
)
2594 *ret_num_leaves
= num_dx_leaves
;
2599 static int ocfs2_fill_new_dir_dx(struct ocfs2_super
*osb
,
2601 struct inode
*parent
,
2602 struct inode
*inode
,
2603 struct buffer_head
*di_bh
,
2604 struct ocfs2_alloc_context
*data_ac
,
2605 struct ocfs2_alloc_context
*meta_ac
)
2608 struct buffer_head
*leaf_bh
= NULL
;
2609 struct buffer_head
*dx_root_bh
= NULL
;
2610 struct ocfs2_dx_hinfo hinfo
;
2611 struct ocfs2_dx_root_block
*dx_root
;
2612 struct ocfs2_dx_entry_list
*entry_list
;
2615 * Our strategy is to create the directory as though it were
2616 * unindexed, then add the index block. This works with very
2617 * little complication since the state of a new directory is a
2618 * very well known quantity.
2620 * Essentially, we have two dirents ("." and ".."), in the 1st
2621 * block which need indexing. These are easily inserted into
2625 ret
= ocfs2_fill_new_dir_el(osb
, handle
, parent
, inode
, di_bh
,
2632 ret
= ocfs2_dx_dir_attach_index(osb
, handle
, inode
, di_bh
, leaf_bh
,
2633 meta_ac
, 1, 2, &dx_root_bh
);
2638 dx_root
= (struct ocfs2_dx_root_block
*)dx_root_bh
->b_data
;
2639 entry_list
= &dx_root
->dr_entries
;
2641 /* Buffer has been journaled for us by ocfs2_dx_dir_attach_index */
2642 ocfs2_dx_dir_name_hash(inode
, ".", 1, &hinfo
);
2643 ocfs2_dx_entry_list_insert(entry_list
, &hinfo
, leaf_bh
->b_blocknr
);
2645 ocfs2_dx_dir_name_hash(inode
, "..", 2, &hinfo
);
2646 ocfs2_dx_entry_list_insert(entry_list
, &hinfo
, leaf_bh
->b_blocknr
);
2654 int ocfs2_fill_new_dir(struct ocfs2_super
*osb
,
2656 struct inode
*parent
,
2657 struct inode
*inode
,
2658 struct buffer_head
*fe_bh
,
2659 struct ocfs2_alloc_context
*data_ac
,
2660 struct ocfs2_alloc_context
*meta_ac
)
2663 BUG_ON(!ocfs2_supports_inline_data(osb
) && data_ac
== NULL
);
2665 if (OCFS2_I(inode
)->ip_dyn_features
& OCFS2_INLINE_DATA_FL
)
2666 return ocfs2_fill_new_dir_id(osb
, handle
, parent
, inode
, fe_bh
);
2668 if (ocfs2_supports_indexed_dirs(osb
))
2669 return ocfs2_fill_new_dir_dx(osb
, handle
, parent
, inode
, fe_bh
,
2672 return ocfs2_fill_new_dir_el(osb
, handle
, parent
, inode
, fe_bh
,
2676 static int ocfs2_dx_dir_index_block(struct inode
*dir
,
2678 struct buffer_head
**dx_leaves
,
2680 u32
*num_dx_entries
,
2681 struct buffer_head
*dirent_bh
)
2683 int ret
= 0, namelen
, i
;
2684 char *de_buf
, *limit
;
2685 struct ocfs2_dir_entry
*de
;
2686 struct buffer_head
*dx_leaf_bh
;
2687 struct ocfs2_dx_hinfo hinfo
;
2688 u64 dirent_blk
= dirent_bh
->b_blocknr
;
2690 de_buf
= dirent_bh
->b_data
;
2691 limit
= de_buf
+ dir
->i_sb
->s_blocksize
;
2693 while (de_buf
< limit
) {
2694 de
= (struct ocfs2_dir_entry
*)de_buf
;
2696 namelen
= de
->name_len
;
2697 if (!namelen
|| !de
->inode
)
2700 ocfs2_dx_dir_name_hash(dir
, de
->name
, namelen
, &hinfo
);
2702 i
= ocfs2_dx_dir_hash_idx(OCFS2_SB(dir
->i_sb
), &hinfo
);
2703 dx_leaf_bh
= dx_leaves
[i
];
2705 ret
= __ocfs2_dx_dir_leaf_insert(dir
, handle
, &hinfo
,
2706 dirent_blk
, dx_leaf_bh
);
2712 *num_dx_entries
= *num_dx_entries
+ 1;
2715 de_buf
+= le16_to_cpu(de
->rec_len
);
2723 * XXX: This expects dx_root_bh to already be part of the transaction.
2725 static void ocfs2_dx_dir_index_root_block(struct inode
*dir
,
2726 struct buffer_head
*dx_root_bh
,
2727 struct buffer_head
*dirent_bh
)
2729 char *de_buf
, *limit
;
2730 struct ocfs2_dx_root_block
*dx_root
;
2731 struct ocfs2_dir_entry
*de
;
2732 struct ocfs2_dx_hinfo hinfo
;
2733 u64 dirent_blk
= dirent_bh
->b_blocknr
;
2735 dx_root
= (struct ocfs2_dx_root_block
*)dx_root_bh
->b_data
;
2737 de_buf
= dirent_bh
->b_data
;
2738 limit
= de_buf
+ dir
->i_sb
->s_blocksize
;
2740 while (de_buf
< limit
) {
2741 de
= (struct ocfs2_dir_entry
*)de_buf
;
2743 if (!de
->name_len
|| !de
->inode
)
2746 ocfs2_dx_dir_name_hash(dir
, de
->name
, de
->name_len
, &hinfo
);
2748 trace_ocfs2_dx_dir_index_root_block(
2749 (unsigned long long)dir
->i_ino
,
2750 hinfo
.major_hash
, hinfo
.minor_hash
,
2751 de
->name_len
, de
->name
,
2752 le16_to_cpu(dx_root
->dr_entries
.de_num_used
));
2754 ocfs2_dx_entry_list_insert(&dx_root
->dr_entries
, &hinfo
,
2757 le32_add_cpu(&dx_root
->dr_num_entries
, 1);
2759 de_buf
+= le16_to_cpu(de
->rec_len
);
2764 * Count the number of inline directory entries in di_bh and compare
2765 * them against the number of entries we can hold in an inline dx root
2768 static int ocfs2_new_dx_should_be_inline(struct inode
*dir
,
2769 struct buffer_head
*di_bh
)
2771 int dirent_count
= 0;
2772 char *de_buf
, *limit
;
2773 struct ocfs2_dir_entry
*de
;
2774 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
2776 de_buf
= di
->id2
.i_data
.id_data
;
2777 limit
= de_buf
+ i_size_read(dir
);
2779 while (de_buf
< limit
) {
2780 de
= (struct ocfs2_dir_entry
*)de_buf
;
2782 if (de
->name_len
&& de
->inode
)
2785 de_buf
+= le16_to_cpu(de
->rec_len
);
2788 /* We are careful to leave room for one extra record. */
2789 return dirent_count
< ocfs2_dx_entries_per_root(dir
->i_sb
);
2793 * Expand rec_len of the rightmost dirent in a directory block so that it
2794 * contains the end of our valid space for dirents. We do this during
2795 * expansion from an inline directory to one with extents. The first dir block
2796 * in that case is taken from the inline data portion of the inode block.
2798 * This will also return the largest amount of contiguous space for a dirent
2799 * in the block. That value is *not* necessarily the last dirent, even after
2800 * expansion. The directory indexing code wants this value for free space
2801 * accounting. We do this here since we're already walking the entire dir
2804 * We add the dir trailer if this filesystem wants it.
2806 static unsigned int ocfs2_expand_last_dirent(char *start
, unsigned int old_size
,
2809 struct super_block
*sb
= dir
->i_sb
;
2810 struct ocfs2_dir_entry
*de
;
2811 struct ocfs2_dir_entry
*prev_de
;
2812 char *de_buf
, *limit
;
2813 unsigned int new_size
= sb
->s_blocksize
;
2814 unsigned int bytes
, this_hole
;
2815 unsigned int largest_hole
= 0;
2817 if (ocfs2_new_dir_wants_trailer(dir
))
2818 new_size
= ocfs2_dir_trailer_blk_off(sb
);
2820 bytes
= new_size
- old_size
;
2822 limit
= start
+ old_size
;
2824 de
= (struct ocfs2_dir_entry
*)de_buf
;
2826 this_hole
= ocfs2_figure_dirent_hole(de
);
2827 if (this_hole
> largest_hole
)
2828 largest_hole
= this_hole
;
2831 de_buf
+= le16_to_cpu(de
->rec_len
);
2832 de
= (struct ocfs2_dir_entry
*)de_buf
;
2833 } while (de_buf
< limit
);
2835 le16_add_cpu(&prev_de
->rec_len
, bytes
);
2837 /* We need to double check this after modification of the final
2839 this_hole
= ocfs2_figure_dirent_hole(prev_de
);
2840 if (this_hole
> largest_hole
)
2841 largest_hole
= this_hole
;
2843 if (largest_hole
>= OCFS2_DIR_MIN_REC_LEN
)
2844 return largest_hole
;
2849 * We allocate enough clusters to fulfill "blocks_wanted", but set
2850 * i_size to exactly one block. Ocfs2_extend_dir() will handle the
2851 * rest automatically for us.
2853 * *first_block_bh is a pointer to the 1st data block allocated to the
2856 static int ocfs2_expand_inline_dir(struct inode
*dir
, struct buffer_head
*di_bh
,
2857 unsigned int blocks_wanted
,
2858 struct ocfs2_dir_lookup_result
*lookup
,
2859 struct buffer_head
**first_block_bh
)
2861 u32 alloc
, dx_alloc
, bit_off
, len
, num_dx_entries
= 0;
2862 struct super_block
*sb
= dir
->i_sb
;
2863 int ret
, i
, num_dx_leaves
= 0, dx_inline
= 0,
2864 credits
= ocfs2_inline_to_extents_credits(sb
);
2865 u64 dx_insert_blkno
, blkno
,
2866 bytes
= blocks_wanted
<< sb
->s_blocksize_bits
;
2867 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
2868 struct ocfs2_inode_info
*oi
= OCFS2_I(dir
);
2869 struct ocfs2_alloc_context
*data_ac
= NULL
;
2870 struct ocfs2_alloc_context
*meta_ac
= NULL
;
2871 struct buffer_head
*dirdata_bh
= NULL
;
2872 struct buffer_head
*dx_root_bh
= NULL
;
2873 struct buffer_head
**dx_leaves
= NULL
;
2874 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
2876 struct ocfs2_extent_tree et
;
2877 struct ocfs2_extent_tree dx_et
;
2878 int did_quota
= 0, bytes_allocated
= 0;
2880 ocfs2_init_dinode_extent_tree(&et
, INODE_CACHE(dir
), di_bh
);
2882 alloc
= ocfs2_clusters_for_bytes(sb
, bytes
);
2885 down_write(&oi
->ip_alloc_sem
);
2887 if (ocfs2_supports_indexed_dirs(osb
)) {
2888 credits
+= ocfs2_add_dir_index_credits(sb
);
2890 dx_inline
= ocfs2_new_dx_should_be_inline(dir
, di_bh
);
2892 /* Add one more cluster for an index leaf */
2894 dx_leaves
= ocfs2_dx_dir_kmalloc_leaves(sb
,
2903 /* This gets us the dx_root */
2904 ret
= ocfs2_reserve_new_metadata_blocks(osb
, 1, &meta_ac
);
2912 * We should never need more than 2 clusters for the unindexed
2913 * tree - maximum dirent size is far less than one block. In
2914 * fact, the only time we'd need more than one cluster is if
2915 * blocksize == clustersize and the dirent won't fit in the
2916 * extra space that the expansion to a single block gives. As
2917 * of today, that only happens on 4k/4k file systems.
2921 ret
= ocfs2_reserve_clusters(osb
, alloc
+ dx_alloc
, &data_ac
);
2928 * Prepare for worst case allocation scenario of two separate
2929 * extents in the unindexed tree.
2932 credits
+= OCFS2_SUBALLOC_ALLOC
;
2934 handle
= ocfs2_start_trans(osb
, credits
);
2935 if (IS_ERR(handle
)) {
2936 ret
= PTR_ERR(handle
);
2941 ret
= dquot_alloc_space_nodirty(dir
,
2942 ocfs2_clusters_to_bytes(osb
->sb
, alloc
+ dx_alloc
));
2947 if (ocfs2_supports_indexed_dirs(osb
) && !dx_inline
) {
2949 * Allocate our index cluster first, to maximize the
2950 * possibility that unindexed leaves grow
2953 ret
= __ocfs2_dx_dir_new_cluster(dir
, 0, handle
, data_ac
,
2954 dx_leaves
, num_dx_leaves
,
2960 bytes_allocated
+= ocfs2_clusters_to_bytes(dir
->i_sb
, 1);
2964 * Try to claim as many clusters as the bitmap can give though
2965 * if we only get one now, that's enough to continue. The rest
2966 * will be claimed after the conversion to extents.
2968 if (ocfs2_dir_resv_allowed(osb
))
2969 data_ac
->ac_resv
= &oi
->ip_la_data_resv
;
2970 ret
= ocfs2_claim_clusters(handle
, data_ac
, 1, &bit_off
, &len
);
2975 bytes_allocated
+= ocfs2_clusters_to_bytes(dir
->i_sb
, 1);
2978 * Operations are carefully ordered so that we set up the new
2979 * data block first. The conversion from inline data to
2982 blkno
= ocfs2_clusters_to_blocks(dir
->i_sb
, bit_off
);
2983 dirdata_bh
= sb_getblk(sb
, blkno
);
2990 ocfs2_set_new_buffer_uptodate(INODE_CACHE(dir
), dirdata_bh
);
2992 ret
= ocfs2_journal_access_db(handle
, INODE_CACHE(dir
), dirdata_bh
,
2993 OCFS2_JOURNAL_ACCESS_CREATE
);
2999 memcpy(dirdata_bh
->b_data
, di
->id2
.i_data
.id_data
, i_size_read(dir
));
3000 memset(dirdata_bh
->b_data
+ i_size_read(dir
), 0,
3001 sb
->s_blocksize
- i_size_read(dir
));
3002 i
= ocfs2_expand_last_dirent(dirdata_bh
->b_data
, i_size_read(dir
), dir
);
3003 if (ocfs2_new_dir_wants_trailer(dir
)) {
3005 * Prepare the dir trailer up front. It will otherwise look
3006 * like a valid dirent. Even if inserting the index fails
3007 * (unlikely), then all we'll have done is given first dir
3008 * block a small amount of fragmentation.
3010 ocfs2_init_dir_trailer(dir
, dirdata_bh
, i
);
3013 ocfs2_journal_dirty(handle
, dirdata_bh
);
3015 if (ocfs2_supports_indexed_dirs(osb
) && !dx_inline
) {
3017 * Dx dirs with an external cluster need to do this up
3018 * front. Inline dx root's get handled later, after
3019 * we've allocated our root block. We get passed back
3020 * a total number of items so that dr_num_entries can
3021 * be correctly set once the dx_root has been
3024 ret
= ocfs2_dx_dir_index_block(dir
, handle
, dx_leaves
,
3025 num_dx_leaves
, &num_dx_entries
,
3034 * Set extent, i_size, etc on the directory. After this, the
3035 * inode should contain the same exact dirents as before and
3036 * be fully accessible from system calls.
3038 * We let the later dirent insert modify c/mtime - to the user
3039 * the data hasn't changed.
3041 ret
= ocfs2_journal_access_di(handle
, INODE_CACHE(dir
), di_bh
,
3042 OCFS2_JOURNAL_ACCESS_CREATE
);
3048 spin_lock(&oi
->ip_lock
);
3049 oi
->ip_dyn_features
&= ~OCFS2_INLINE_DATA_FL
;
3050 di
->i_dyn_features
= cpu_to_le16(oi
->ip_dyn_features
);
3051 spin_unlock(&oi
->ip_lock
);
3053 ocfs2_dinode_new_extent_list(dir
, di
);
3055 i_size_write(dir
, sb
->s_blocksize
);
3056 dir
->i_mtime
= dir
->i_ctime
= CURRENT_TIME
;
3058 di
->i_size
= cpu_to_le64(sb
->s_blocksize
);
3059 di
->i_ctime
= di
->i_mtime
= cpu_to_le64(dir
->i_ctime
.tv_sec
);
3060 di
->i_ctime_nsec
= di
->i_mtime_nsec
= cpu_to_le32(dir
->i_ctime
.tv_nsec
);
3063 * This should never fail as our extent list is empty and all
3064 * related blocks have been journaled already.
3066 ret
= ocfs2_insert_extent(handle
, &et
, 0, blkno
, len
,
3074 * Set i_blocks after the extent insert for the most up to
3075 * date ip_clusters value.
3077 dir
->i_blocks
= ocfs2_inode_sector_count(dir
);
3079 ocfs2_journal_dirty(handle
, di_bh
);
3081 if (ocfs2_supports_indexed_dirs(osb
)) {
3082 ret
= ocfs2_dx_dir_attach_index(osb
, handle
, dir
, di_bh
,
3083 dirdata_bh
, meta_ac
, dx_inline
,
3084 num_dx_entries
, &dx_root_bh
);
3091 ocfs2_dx_dir_index_root_block(dir
, dx_root_bh
,
3094 ocfs2_init_dx_root_extent_tree(&dx_et
,
3097 ret
= ocfs2_insert_extent(handle
, &dx_et
, 0,
3098 dx_insert_blkno
, 1, 0, NULL
);
3105 * We asked for two clusters, but only got one in the 1st
3106 * pass. Claim the 2nd cluster as a separate extent.
3109 ret
= ocfs2_claim_clusters(handle
, data_ac
, 1, &bit_off
,
3115 blkno
= ocfs2_clusters_to_blocks(dir
->i_sb
, bit_off
);
3117 ret
= ocfs2_insert_extent(handle
, &et
, 1,
3118 blkno
, len
, 0, NULL
);
3123 bytes_allocated
+= ocfs2_clusters_to_bytes(dir
->i_sb
, 1);
3126 *first_block_bh
= dirdata_bh
;
3128 if (ocfs2_supports_indexed_dirs(osb
)) {
3133 * We need to return the correct block within the
3134 * cluster which should hold our entry.
3136 off
= ocfs2_dx_dir_hash_idx(OCFS2_SB(dir
->i_sb
),
3138 get_bh(dx_leaves
[off
]);
3139 lookup
->dl_dx_leaf_bh
= dx_leaves
[off
];
3141 lookup
->dl_dx_root_bh
= dx_root_bh
;
3146 if (ret
< 0 && did_quota
)
3147 dquot_free_space_nodirty(dir
, bytes_allocated
);
3149 ocfs2_commit_trans(osb
, handle
);
3152 up_write(&oi
->ip_alloc_sem
);
3154 ocfs2_free_alloc_context(data_ac
);
3156 ocfs2_free_alloc_context(meta_ac
);
3159 for (i
= 0; i
< num_dx_leaves
; i
++)
3160 brelse(dx_leaves
[i
]);
3170 /* returns a bh of the 1st new block in the allocation. */
3171 static int ocfs2_do_extend_dir(struct super_block
*sb
,
3174 struct buffer_head
*parent_fe_bh
,
3175 struct ocfs2_alloc_context
*data_ac
,
3176 struct ocfs2_alloc_context
*meta_ac
,
3177 struct buffer_head
**new_bh
)
3180 int extend
, did_quota
= 0;
3181 u64 p_blkno
, v_blkno
;
3183 spin_lock(&OCFS2_I(dir
)->ip_lock
);
3184 extend
= (i_size_read(dir
) == ocfs2_clusters_to_bytes(sb
, OCFS2_I(dir
)->ip_clusters
));
3185 spin_unlock(&OCFS2_I(dir
)->ip_lock
);
3188 u32 offset
= OCFS2_I(dir
)->ip_clusters
;
3190 status
= dquot_alloc_space_nodirty(dir
,
3191 ocfs2_clusters_to_bytes(sb
, 1));
3196 status
= ocfs2_add_inode_data(OCFS2_SB(sb
), dir
, &offset
,
3197 1, 0, parent_fe_bh
, handle
,
3198 data_ac
, meta_ac
, NULL
);
3199 BUG_ON(status
== -EAGAIN
);
3206 v_blkno
= ocfs2_blocks_for_bytes(sb
, i_size_read(dir
));
3207 status
= ocfs2_extent_map_get_blocks(dir
, v_blkno
, &p_blkno
, NULL
, NULL
);
3213 *new_bh
= sb_getblk(sb
, p_blkno
);
3221 if (did_quota
&& status
< 0)
3222 dquot_free_space_nodirty(dir
, ocfs2_clusters_to_bytes(sb
, 1));
3227 * Assumes you already have a cluster lock on the directory.
3229 * 'blocks_wanted' is only used if we have an inline directory which
3230 * is to be turned into an extent based one. The size of the dirent to
3231 * insert might be larger than the space gained by growing to just one
3232 * block, so we may have to grow the inode by two blocks in that case.
3234 * If the directory is already indexed, dx_root_bh must be provided.
3236 static int ocfs2_extend_dir(struct ocfs2_super
*osb
,
3238 struct buffer_head
*parent_fe_bh
,
3239 unsigned int blocks_wanted
,
3240 struct ocfs2_dir_lookup_result
*lookup
,
3241 struct buffer_head
**new_de_bh
)
3244 int credits
, num_free_extents
, drop_alloc_sem
= 0;
3246 struct ocfs2_dinode
*fe
= (struct ocfs2_dinode
*) parent_fe_bh
->b_data
;
3247 struct ocfs2_extent_list
*el
= &fe
->id2
.i_list
;
3248 struct ocfs2_alloc_context
*data_ac
= NULL
;
3249 struct ocfs2_alloc_context
*meta_ac
= NULL
;
3250 handle_t
*handle
= NULL
;
3251 struct buffer_head
*new_bh
= NULL
;
3252 struct ocfs2_dir_entry
* de
;
3253 struct super_block
*sb
= osb
->sb
;
3254 struct ocfs2_extent_tree et
;
3255 struct buffer_head
*dx_root_bh
= lookup
->dl_dx_root_bh
;
3257 if (OCFS2_I(dir
)->ip_dyn_features
& OCFS2_INLINE_DATA_FL
) {
3259 * This would be a code error as an inline directory should
3260 * never have an index root.
3264 status
= ocfs2_expand_inline_dir(dir
, parent_fe_bh
,
3265 blocks_wanted
, lookup
,
3272 /* Expansion from inline to an indexed directory will
3273 * have given us this. */
3274 dx_root_bh
= lookup
->dl_dx_root_bh
;
3276 if (blocks_wanted
== 1) {
3278 * If the new dirent will fit inside the space
3279 * created by pushing out to one block, then
3280 * we can complete the operation
3281 * here. Otherwise we have to expand i_size
3282 * and format the 2nd block below.
3284 BUG_ON(new_bh
== NULL
);
3289 * Get rid of 'new_bh' - we want to format the 2nd
3290 * data block and return that instead.
3295 down_write(&OCFS2_I(dir
)->ip_alloc_sem
);
3297 dir_i_size
= i_size_read(dir
);
3298 credits
= OCFS2_SIMPLE_DIR_EXTEND_CREDITS
;
3302 down_write(&OCFS2_I(dir
)->ip_alloc_sem
);
3304 dir_i_size
= i_size_read(dir
);
3305 trace_ocfs2_extend_dir((unsigned long long)OCFS2_I(dir
)->ip_blkno
,
3308 /* dir->i_size is always block aligned. */
3309 spin_lock(&OCFS2_I(dir
)->ip_lock
);
3310 if (dir_i_size
== ocfs2_clusters_to_bytes(sb
, OCFS2_I(dir
)->ip_clusters
)) {
3311 spin_unlock(&OCFS2_I(dir
)->ip_lock
);
3312 ocfs2_init_dinode_extent_tree(&et
, INODE_CACHE(dir
),
3314 num_free_extents
= ocfs2_num_free_extents(osb
, &et
);
3315 if (num_free_extents
< 0) {
3316 status
= num_free_extents
;
3321 if (!num_free_extents
) {
3322 status
= ocfs2_reserve_new_metadata(osb
, el
, &meta_ac
);
3324 if (status
!= -ENOSPC
)
3330 status
= ocfs2_reserve_clusters(osb
, 1, &data_ac
);
3332 if (status
!= -ENOSPC
)
3337 if (ocfs2_dir_resv_allowed(osb
))
3338 data_ac
->ac_resv
= &OCFS2_I(dir
)->ip_la_data_resv
;
3340 credits
= ocfs2_calc_extend_credits(sb
, el
, 1);
3342 spin_unlock(&OCFS2_I(dir
)->ip_lock
);
3343 credits
= OCFS2_SIMPLE_DIR_EXTEND_CREDITS
;
3347 if (ocfs2_dir_indexed(dir
))
3348 credits
++; /* For attaching the new dirent block to the
3351 handle
= ocfs2_start_trans(osb
, credits
);
3352 if (IS_ERR(handle
)) {
3353 status
= PTR_ERR(handle
);
3359 status
= ocfs2_do_extend_dir(osb
->sb
, handle
, dir
, parent_fe_bh
,
3360 data_ac
, meta_ac
, &new_bh
);
3366 ocfs2_set_new_buffer_uptodate(INODE_CACHE(dir
), new_bh
);
3368 status
= ocfs2_journal_access_db(handle
, INODE_CACHE(dir
), new_bh
,
3369 OCFS2_JOURNAL_ACCESS_CREATE
);
3374 memset(new_bh
->b_data
, 0, sb
->s_blocksize
);
3376 de
= (struct ocfs2_dir_entry
*) new_bh
->b_data
;
3378 if (ocfs2_supports_dir_trailer(dir
)) {
3379 de
->rec_len
= cpu_to_le16(ocfs2_dir_trailer_blk_off(sb
));
3381 ocfs2_init_dir_trailer(dir
, new_bh
, le16_to_cpu(de
->rec_len
));
3383 if (ocfs2_dir_indexed(dir
)) {
3384 status
= ocfs2_dx_dir_link_trailer(dir
, handle
,
3385 dx_root_bh
, new_bh
);
3392 de
->rec_len
= cpu_to_le16(sb
->s_blocksize
);
3394 ocfs2_journal_dirty(handle
, new_bh
);
3396 dir_i_size
+= dir
->i_sb
->s_blocksize
;
3397 i_size_write(dir
, dir_i_size
);
3398 dir
->i_blocks
= ocfs2_inode_sector_count(dir
);
3399 status
= ocfs2_mark_inode_dirty(handle
, dir
, parent_fe_bh
);
3406 *new_de_bh
= new_bh
;
3410 ocfs2_commit_trans(osb
, handle
);
3412 up_write(&OCFS2_I(dir
)->ip_alloc_sem
);
3415 ocfs2_free_alloc_context(data_ac
);
3417 ocfs2_free_alloc_context(meta_ac
);
3424 static int ocfs2_find_dir_space_id(struct inode
*dir
, struct buffer_head
*di_bh
,
3425 const char *name
, int namelen
,
3426 struct buffer_head
**ret_de_bh
,
3427 unsigned int *blocks_wanted
)
3430 struct super_block
*sb
= dir
->i_sb
;
3431 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
3432 struct ocfs2_dir_entry
*de
, *last_de
= NULL
;
3433 char *de_buf
, *limit
;
3434 unsigned long offset
= 0;
3435 unsigned int rec_len
, new_rec_len
, free_space
= dir
->i_sb
->s_blocksize
;
3438 * This calculates how many free bytes we'd have in block zero, should
3439 * this function force expansion to an extent tree.
3441 if (ocfs2_new_dir_wants_trailer(dir
))
3442 free_space
= ocfs2_dir_trailer_blk_off(sb
) - i_size_read(dir
);
3444 free_space
= dir
->i_sb
->s_blocksize
- i_size_read(dir
);
3446 de_buf
= di
->id2
.i_data
.id_data
;
3447 limit
= de_buf
+ i_size_read(dir
);
3448 rec_len
= OCFS2_DIR_REC_LEN(namelen
);
3450 while (de_buf
< limit
) {
3451 de
= (struct ocfs2_dir_entry
*)de_buf
;
3453 if (!ocfs2_check_dir_entry(dir
, de
, di_bh
, offset
)) {
3457 if (ocfs2_match(namelen
, name
, de
)) {
3462 * No need to check for a trailing dirent record here as
3463 * they're not used for inline dirs.
3466 if (ocfs2_dirent_would_fit(de
, rec_len
)) {
3467 /* Ok, we found a spot. Return this bh and let
3468 * the caller actually fill it in. */
3476 de_buf
+= le16_to_cpu(de
->rec_len
);
3477 offset
+= le16_to_cpu(de
->rec_len
);
3481 * We're going to require expansion of the directory - figure
3482 * out how many blocks we'll need so that a place for the
3483 * dirent can be found.
3486 new_rec_len
= le16_to_cpu(last_de
->rec_len
) + free_space
;
3487 if (new_rec_len
< (rec_len
+ OCFS2_DIR_REC_LEN(last_de
->name_len
)))
3495 static int ocfs2_find_dir_space_el(struct inode
*dir
, const char *name
,
3496 int namelen
, struct buffer_head
**ret_de_bh
)
3498 unsigned long offset
;
3499 struct buffer_head
*bh
= NULL
;
3500 unsigned short rec_len
;
3501 struct ocfs2_dir_entry
*de
;
3502 struct super_block
*sb
= dir
->i_sb
;
3504 int blocksize
= dir
->i_sb
->s_blocksize
;
3506 status
= ocfs2_read_dir_block(dir
, 0, &bh
, 0);
3512 rec_len
= OCFS2_DIR_REC_LEN(namelen
);
3514 de
= (struct ocfs2_dir_entry
*) bh
->b_data
;
3516 if ((char *)de
>= sb
->s_blocksize
+ bh
->b_data
) {
3520 if (i_size_read(dir
) <= offset
) {
3522 * Caller will have to expand this
3528 status
= ocfs2_read_dir_block(dir
,
3529 offset
>> sb
->s_blocksize_bits
,
3535 /* move to next block */
3536 de
= (struct ocfs2_dir_entry
*) bh
->b_data
;
3538 if (!ocfs2_check_dir_entry(dir
, de
, bh
, offset
)) {
3542 if (ocfs2_match(namelen
, name
, de
)) {
3547 if (ocfs2_skip_dir_trailer(dir
, de
, offset
% blocksize
,
3551 if (ocfs2_dirent_would_fit(de
, rec_len
)) {
3552 /* Ok, we found a spot. Return this bh and let
3553 * the caller actually fill it in. */
3560 offset
+= le16_to_cpu(de
->rec_len
);
3561 de
= (struct ocfs2_dir_entry
*)((char *) de
+ le16_to_cpu(de
->rec_len
));
3573 static int dx_leaf_sort_cmp(const void *a
, const void *b
)
3575 const struct ocfs2_dx_entry
*entry1
= a
;
3576 const struct ocfs2_dx_entry
*entry2
= b
;
3577 u32 major_hash1
= le32_to_cpu(entry1
->dx_major_hash
);
3578 u32 major_hash2
= le32_to_cpu(entry2
->dx_major_hash
);
3579 u32 minor_hash1
= le32_to_cpu(entry1
->dx_minor_hash
);
3580 u32 minor_hash2
= le32_to_cpu(entry2
->dx_minor_hash
);
3582 if (major_hash1
> major_hash2
)
3584 if (major_hash1
< major_hash2
)
3588 * It is not strictly necessary to sort by minor
3590 if (minor_hash1
> minor_hash2
)
3592 if (minor_hash1
< minor_hash2
)
3597 static void dx_leaf_sort_swap(void *a
, void *b
, int size
)
3599 struct ocfs2_dx_entry
*entry1
= a
;
3600 struct ocfs2_dx_entry
*entry2
= b
;
3601 struct ocfs2_dx_entry tmp
;
3603 BUG_ON(size
!= sizeof(*entry1
));
3610 static int ocfs2_dx_leaf_same_major(struct ocfs2_dx_leaf
*dx_leaf
)
3612 struct ocfs2_dx_entry_list
*dl_list
= &dx_leaf
->dl_list
;
3613 int i
, num
= le16_to_cpu(dl_list
->de_num_used
);
3615 for (i
= 0; i
< (num
- 1); i
++) {
3616 if (le32_to_cpu(dl_list
->de_entries
[i
].dx_major_hash
) !=
3617 le32_to_cpu(dl_list
->de_entries
[i
+ 1].dx_major_hash
))
3625 * Find the optimal value to split this leaf on. This expects the leaf
3626 * entries to be in sorted order.
3628 * leaf_cpos is the cpos of the leaf we're splitting. insert_hash is
3629 * the hash we want to insert.
3631 * This function is only concerned with the major hash - that which
3632 * determines which cluster an item belongs to.
3634 static int ocfs2_dx_dir_find_leaf_split(struct ocfs2_dx_leaf
*dx_leaf
,
3635 u32 leaf_cpos
, u32 insert_hash
,
3638 struct ocfs2_dx_entry_list
*dl_list
= &dx_leaf
->dl_list
;
3639 int i
, num_used
= le16_to_cpu(dl_list
->de_num_used
);
3643 * There's a couple rare, but nasty corner cases we have to
3644 * check for here. All of them involve a leaf where all value
3645 * have the same hash, which is what we look for first.
3647 * Most of the time, all of the above is false, and we simply
3648 * pick the median value for a split.
3650 allsame
= ocfs2_dx_leaf_same_major(dx_leaf
);
3652 u32 val
= le32_to_cpu(dl_list
->de_entries
[0].dx_major_hash
);
3654 if (val
== insert_hash
) {
3656 * No matter where we would choose to split,
3657 * the new entry would want to occupy the same
3658 * block as these. Since there's no space left
3659 * in their existing block, we know there
3660 * won't be space after the split.
3665 if (val
== leaf_cpos
) {
3667 * Because val is the same as leaf_cpos (which
3668 * is the smallest value this leaf can have),
3669 * yet is not equal to insert_hash, then we
3670 * know that insert_hash *must* be larger than
3671 * val (and leaf_cpos). At least cpos+1 in value.
3673 * We also know then, that there cannot be an
3674 * adjacent extent (otherwise we'd be looking
3675 * at it). Choosing this value gives us a
3676 * chance to get some contiguousness.
3678 *split_hash
= leaf_cpos
+ 1;
3682 if (val
> insert_hash
) {
3684 * val can not be the same as insert hash, and
3685 * also must be larger than leaf_cpos. Also,
3686 * we know that there can't be a leaf between
3687 * cpos and val, otherwise the entries with
3688 * hash 'val' would be there.
3694 *split_hash
= insert_hash
;
3699 * Since the records are sorted and the checks above
3700 * guaranteed that not all records in this block are the same,
3701 * we simple travel forward, from the median, and pick the 1st
3702 * record whose value is larger than leaf_cpos.
3704 for (i
= (num_used
/ 2); i
< num_used
; i
++)
3705 if (le32_to_cpu(dl_list
->de_entries
[i
].dx_major_hash
) >
3709 BUG_ON(i
== num_used
); /* Should be impossible */
3710 *split_hash
= le32_to_cpu(dl_list
->de_entries
[i
].dx_major_hash
);
3715 * Transfer all entries in orig_dx_leaves whose major hash is equal to or
3716 * larger than split_hash into new_dx_leaves. We use a temporary
3717 * buffer (tmp_dx_leaf) to make the changes to the original leaf blocks.
3719 * Since the block offset inside a leaf (cluster) is a constant mask
3720 * of minor_hash, we can optimize - an item at block offset X within
3721 * the original cluster, will be at offset X within the new cluster.
3723 static void ocfs2_dx_dir_transfer_leaf(struct inode
*dir
, u32 split_hash
,
3725 struct ocfs2_dx_leaf
*tmp_dx_leaf
,
3726 struct buffer_head
**orig_dx_leaves
,
3727 struct buffer_head
**new_dx_leaves
,
3732 struct ocfs2_dx_leaf
*orig_dx_leaf
, *new_dx_leaf
;
3733 struct ocfs2_dx_entry_list
*orig_list
, *new_list
, *tmp_list
;
3734 struct ocfs2_dx_entry
*dx_entry
;
3736 tmp_list
= &tmp_dx_leaf
->dl_list
;
3738 for (i
= 0; i
< num_dx_leaves
; i
++) {
3739 orig_dx_leaf
= (struct ocfs2_dx_leaf
*) orig_dx_leaves
[i
]->b_data
;
3740 orig_list
= &orig_dx_leaf
->dl_list
;
3741 new_dx_leaf
= (struct ocfs2_dx_leaf
*) new_dx_leaves
[i
]->b_data
;
3742 new_list
= &new_dx_leaf
->dl_list
;
3744 num_used
= le16_to_cpu(orig_list
->de_num_used
);
3746 memcpy(tmp_dx_leaf
, orig_dx_leaf
, dir
->i_sb
->s_blocksize
);
3747 tmp_list
->de_num_used
= cpu_to_le16(0);
3748 memset(&tmp_list
->de_entries
, 0, sizeof(*dx_entry
)*num_used
);
3750 for (j
= 0; j
< num_used
; j
++) {
3751 dx_entry
= &orig_list
->de_entries
[j
];
3752 major_hash
= le32_to_cpu(dx_entry
->dx_major_hash
);
3753 if (major_hash
>= split_hash
)
3754 ocfs2_dx_dir_leaf_insert_tail(new_dx_leaf
,
3757 ocfs2_dx_dir_leaf_insert_tail(tmp_dx_leaf
,
3760 memcpy(orig_dx_leaf
, tmp_dx_leaf
, dir
->i_sb
->s_blocksize
);
3762 ocfs2_journal_dirty(handle
, orig_dx_leaves
[i
]);
3763 ocfs2_journal_dirty(handle
, new_dx_leaves
[i
]);
3767 static int ocfs2_dx_dir_rebalance_credits(struct ocfs2_super
*osb
,
3768 struct ocfs2_dx_root_block
*dx_root
)
3770 int credits
= ocfs2_clusters_to_blocks(osb
->sb
, 2);
3772 credits
+= ocfs2_calc_extend_credits(osb
->sb
, &dx_root
->dr_list
, 1);
3773 credits
+= ocfs2_quota_trans_credits(osb
->sb
);
3778 * Find the median value in dx_leaf_bh and allocate a new leaf to move
3779 * half our entries into.
3781 static int ocfs2_dx_dir_rebalance(struct ocfs2_super
*osb
, struct inode
*dir
,
3782 struct buffer_head
*dx_root_bh
,
3783 struct buffer_head
*dx_leaf_bh
,
3784 struct ocfs2_dx_hinfo
*hinfo
, u32 leaf_cpos
,
3787 struct ocfs2_dx_leaf
*dx_leaf
= (struct ocfs2_dx_leaf
*)dx_leaf_bh
->b_data
;
3788 int credits
, ret
, i
, num_used
, did_quota
= 0;
3789 u32 cpos
, split_hash
, insert_hash
= hinfo
->major_hash
;
3790 u64 orig_leaves_start
;
3792 struct buffer_head
**orig_dx_leaves
= NULL
;
3793 struct buffer_head
**new_dx_leaves
= NULL
;
3794 struct ocfs2_alloc_context
*data_ac
= NULL
, *meta_ac
= NULL
;
3795 struct ocfs2_extent_tree et
;
3796 handle_t
*handle
= NULL
;
3797 struct ocfs2_dx_root_block
*dx_root
;
3798 struct ocfs2_dx_leaf
*tmp_dx_leaf
= NULL
;
3800 trace_ocfs2_dx_dir_rebalance((unsigned long long)OCFS2_I(dir
)->ip_blkno
,
3801 (unsigned long long)leaf_blkno
,
3804 ocfs2_init_dx_root_extent_tree(&et
, INODE_CACHE(dir
), dx_root_bh
);
3806 dx_root
= (struct ocfs2_dx_root_block
*)dx_root_bh
->b_data
;
3808 * XXX: This is a rather large limit. We should use a more
3811 if (le32_to_cpu(dx_root
->dr_clusters
) == UINT_MAX
)
3814 num_used
= le16_to_cpu(dx_leaf
->dl_list
.de_num_used
);
3815 if (num_used
< le16_to_cpu(dx_leaf
->dl_list
.de_count
)) {
3816 mlog(ML_ERROR
, "DX Dir: %llu, Asked to rebalance empty leaf: "
3817 "%llu, %d\n", (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
3818 (unsigned long long)leaf_blkno
, num_used
);
3823 orig_dx_leaves
= ocfs2_dx_dir_kmalloc_leaves(osb
->sb
, &num_dx_leaves
);
3824 if (!orig_dx_leaves
) {
3830 new_dx_leaves
= ocfs2_dx_dir_kmalloc_leaves(osb
->sb
, NULL
);
3831 if (!new_dx_leaves
) {
3837 ret
= ocfs2_lock_allocators(dir
, &et
, 1, 0, &data_ac
, &meta_ac
);
3844 credits
= ocfs2_dx_dir_rebalance_credits(osb
, dx_root
);
3845 handle
= ocfs2_start_trans(osb
, credits
);
3846 if (IS_ERR(handle
)) {
3847 ret
= PTR_ERR(handle
);
3853 ret
= dquot_alloc_space_nodirty(dir
,
3854 ocfs2_clusters_to_bytes(dir
->i_sb
, 1));
3859 ret
= ocfs2_journal_access_dl(handle
, INODE_CACHE(dir
), dx_leaf_bh
,
3860 OCFS2_JOURNAL_ACCESS_WRITE
);
3867 * This block is changing anyway, so we can sort it in place.
3869 sort(dx_leaf
->dl_list
.de_entries
, num_used
,
3870 sizeof(struct ocfs2_dx_entry
), dx_leaf_sort_cmp
,
3873 ocfs2_journal_dirty(handle
, dx_leaf_bh
);
3875 ret
= ocfs2_dx_dir_find_leaf_split(dx_leaf
, leaf_cpos
, insert_hash
,
3882 trace_ocfs2_dx_dir_rebalance_split(leaf_cpos
, split_hash
, insert_hash
);
3885 * We have to carefully order operations here. There are items
3886 * which want to be in the new cluster before insert, but in
3887 * order to put those items in the new cluster, we alter the
3888 * old cluster. A failure to insert gets nasty.
3890 * So, start by reserving writes to the old
3891 * cluster. ocfs2_dx_dir_new_cluster will reserve writes on
3892 * the new cluster for us, before inserting it. The insert
3893 * won't happen if there's an error before that. Once the
3894 * insert is done then, we can transfer from one leaf into the
3895 * other without fear of hitting any error.
3899 * The leaf transfer wants some scratch space so that we don't
3900 * wind up doing a bunch of expensive memmove().
3902 tmp_dx_leaf
= kmalloc(osb
->sb
->s_blocksize
, GFP_NOFS
);
3909 orig_leaves_start
= ocfs2_block_to_cluster_start(dir
->i_sb
, leaf_blkno
);
3910 ret
= ocfs2_read_dx_leaves(dir
, orig_leaves_start
, num_dx_leaves
,
3918 ret
= ocfs2_dx_dir_new_cluster(dir
, &et
, cpos
, handle
,
3919 data_ac
, meta_ac
, new_dx_leaves
,
3926 for (i
= 0; i
< num_dx_leaves
; i
++) {
3927 ret
= ocfs2_journal_access_dl(handle
, INODE_CACHE(dir
),
3929 OCFS2_JOURNAL_ACCESS_WRITE
);
3935 ret
= ocfs2_journal_access_dl(handle
, INODE_CACHE(dir
),
3937 OCFS2_JOURNAL_ACCESS_WRITE
);
3944 ocfs2_dx_dir_transfer_leaf(dir
, split_hash
, handle
, tmp_dx_leaf
,
3945 orig_dx_leaves
, new_dx_leaves
, num_dx_leaves
);
3948 if (ret
< 0 && did_quota
)
3949 dquot_free_space_nodirty(dir
,
3950 ocfs2_clusters_to_bytes(dir
->i_sb
, 1));
3952 ocfs2_commit_trans(osb
, handle
);
3955 if (orig_dx_leaves
|| new_dx_leaves
) {
3956 for (i
= 0; i
< num_dx_leaves
; i
++) {
3958 brelse(orig_dx_leaves
[i
]);
3960 brelse(new_dx_leaves
[i
]);
3962 kfree(orig_dx_leaves
);
3963 kfree(new_dx_leaves
);
3967 ocfs2_free_alloc_context(meta_ac
);
3969 ocfs2_free_alloc_context(data_ac
);
3975 static int ocfs2_find_dir_space_dx(struct ocfs2_super
*osb
, struct inode
*dir
,
3976 struct buffer_head
*di_bh
,
3977 struct buffer_head
*dx_root_bh
,
3978 const char *name
, int namelen
,
3979 struct ocfs2_dir_lookup_result
*lookup
)
3981 int ret
, rebalanced
= 0;
3982 struct ocfs2_dx_root_block
*dx_root
;
3983 struct buffer_head
*dx_leaf_bh
= NULL
;
3984 struct ocfs2_dx_leaf
*dx_leaf
;
3988 dx_root
= (struct ocfs2_dx_root_block
*)dx_root_bh
->b_data
;
3991 ret
= ocfs2_dx_dir_lookup(dir
, &dx_root
->dr_list
, &lookup
->dl_hinfo
,
3992 &leaf_cpos
, &blkno
);
3998 ret
= ocfs2_read_dx_leaf(dir
, blkno
, &dx_leaf_bh
);
4004 dx_leaf
= (struct ocfs2_dx_leaf
*)dx_leaf_bh
->b_data
;
4006 if (le16_to_cpu(dx_leaf
->dl_list
.de_num_used
) >=
4007 le16_to_cpu(dx_leaf
->dl_list
.de_count
)) {
4010 * Rebalancing should have provided us with
4011 * space in an appropriate leaf.
4013 * XXX: Is this an abnormal condition then?
4014 * Should we print a message here?
4020 ret
= ocfs2_dx_dir_rebalance(osb
, dir
, dx_root_bh
, dx_leaf_bh
,
4021 &lookup
->dl_hinfo
, leaf_cpos
,
4030 * Restart the lookup. The rebalance might have
4031 * changed which block our item fits into. Mark our
4032 * progress, so we only execute this once.
4037 goto restart_search
;
4040 lookup
->dl_dx_leaf_bh
= dx_leaf_bh
;
4048 static int ocfs2_search_dx_free_list(struct inode
*dir
,
4049 struct buffer_head
*dx_root_bh
,
4051 struct ocfs2_dir_lookup_result
*lookup
)
4054 struct buffer_head
*leaf_bh
= NULL
, *prev_leaf_bh
= NULL
;
4055 struct ocfs2_dir_block_trailer
*db
;
4057 int rec_len
= OCFS2_DIR_REC_LEN(namelen
);
4058 struct ocfs2_dx_root_block
*dx_root
;
4060 dx_root
= (struct ocfs2_dx_root_block
*)dx_root_bh
->b_data
;
4061 next_block
= le64_to_cpu(dx_root
->dr_free_blk
);
4063 while (next_block
) {
4064 brelse(prev_leaf_bh
);
4065 prev_leaf_bh
= leaf_bh
;
4068 ret
= ocfs2_read_dir_block_direct(dir
, next_block
, &leaf_bh
);
4074 db
= ocfs2_trailer_from_bh(leaf_bh
, dir
->i_sb
);
4075 if (rec_len
<= le16_to_cpu(db
->db_free_rec_len
)) {
4076 lookup
->dl_leaf_bh
= leaf_bh
;
4077 lookup
->dl_prev_leaf_bh
= prev_leaf_bh
;
4079 prev_leaf_bh
= NULL
;
4083 next_block
= le64_to_cpu(db
->db_free_next
);
4092 brelse(prev_leaf_bh
);
4096 static int ocfs2_expand_inline_dx_root(struct inode
*dir
,
4097 struct buffer_head
*dx_root_bh
)
4099 int ret
, num_dx_leaves
, i
, j
, did_quota
= 0;
4100 struct buffer_head
**dx_leaves
= NULL
;
4101 struct ocfs2_extent_tree et
;
4103 struct ocfs2_alloc_context
*data_ac
= NULL
;
4104 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
4105 handle_t
*handle
= NULL
;
4106 struct ocfs2_dx_root_block
*dx_root
;
4107 struct ocfs2_dx_entry_list
*entry_list
;
4108 struct ocfs2_dx_entry
*dx_entry
;
4109 struct ocfs2_dx_leaf
*target_leaf
;
4111 ret
= ocfs2_reserve_clusters(osb
, 1, &data_ac
);
4117 dx_leaves
= ocfs2_dx_dir_kmalloc_leaves(osb
->sb
, &num_dx_leaves
);
4124 handle
= ocfs2_start_trans(osb
, ocfs2_calc_dxi_expand_credits(osb
->sb
));
4125 if (IS_ERR(handle
)) {
4126 ret
= PTR_ERR(handle
);
4131 ret
= dquot_alloc_space_nodirty(dir
,
4132 ocfs2_clusters_to_bytes(osb
->sb
, 1));
4138 * We do this up front, before the allocation, so that a
4139 * failure to add the dx_root_bh to the journal won't result
4140 * us losing clusters.
4142 ret
= ocfs2_journal_access_dr(handle
, INODE_CACHE(dir
), dx_root_bh
,
4143 OCFS2_JOURNAL_ACCESS_WRITE
);
4149 ret
= __ocfs2_dx_dir_new_cluster(dir
, 0, handle
, data_ac
, dx_leaves
,
4150 num_dx_leaves
, &insert_blkno
);
4157 * Transfer the entries from our dx_root into the appropriate
4160 dx_root
= (struct ocfs2_dx_root_block
*) dx_root_bh
->b_data
;
4161 entry_list
= &dx_root
->dr_entries
;
4163 for (i
= 0; i
< le16_to_cpu(entry_list
->de_num_used
); i
++) {
4164 dx_entry
= &entry_list
->de_entries
[i
];
4166 j
= __ocfs2_dx_dir_hash_idx(osb
,
4167 le32_to_cpu(dx_entry
->dx_minor_hash
));
4168 target_leaf
= (struct ocfs2_dx_leaf
*)dx_leaves
[j
]->b_data
;
4170 ocfs2_dx_dir_leaf_insert_tail(target_leaf
, dx_entry
);
4172 /* Each leaf has been passed to the journal already
4173 * via __ocfs2_dx_dir_new_cluster() */
4176 dx_root
->dr_flags
&= ~OCFS2_DX_FLAG_INLINE
;
4177 memset(&dx_root
->dr_list
, 0, osb
->sb
->s_blocksize
-
4178 offsetof(struct ocfs2_dx_root_block
, dr_list
));
4179 dx_root
->dr_list
.l_count
=
4180 cpu_to_le16(ocfs2_extent_recs_per_dx_root(osb
->sb
));
4182 /* This should never fail considering we start with an empty
4184 ocfs2_init_dx_root_extent_tree(&et
, INODE_CACHE(dir
), dx_root_bh
);
4185 ret
= ocfs2_insert_extent(handle
, &et
, 0, insert_blkno
, 1, 0, NULL
);
4190 ocfs2_journal_dirty(handle
, dx_root_bh
);
4193 if (ret
< 0 && did_quota
)
4194 dquot_free_space_nodirty(dir
,
4195 ocfs2_clusters_to_bytes(dir
->i_sb
, 1));
4197 ocfs2_commit_trans(osb
, handle
);
4201 ocfs2_free_alloc_context(data_ac
);
4204 for (i
= 0; i
< num_dx_leaves
; i
++)
4205 brelse(dx_leaves
[i
]);
4211 static int ocfs2_inline_dx_has_space(struct buffer_head
*dx_root_bh
)
4213 struct ocfs2_dx_root_block
*dx_root
;
4214 struct ocfs2_dx_entry_list
*entry_list
;
4216 dx_root
= (struct ocfs2_dx_root_block
*) dx_root_bh
->b_data
;
4217 entry_list
= &dx_root
->dr_entries
;
4219 if (le16_to_cpu(entry_list
->de_num_used
) >=
4220 le16_to_cpu(entry_list
->de_count
))
4226 static int ocfs2_prepare_dx_dir_for_insert(struct inode
*dir
,
4227 struct buffer_head
*di_bh
,
4230 struct ocfs2_dir_lookup_result
*lookup
)
4232 int ret
, free_dx_root
= 1;
4233 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
4234 struct buffer_head
*dx_root_bh
= NULL
;
4235 struct buffer_head
*leaf_bh
= NULL
;
4236 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
4237 struct ocfs2_dx_root_block
*dx_root
;
4239 ret
= ocfs2_read_dx_root(dir
, di
, &dx_root_bh
);
4245 dx_root
= (struct ocfs2_dx_root_block
*)dx_root_bh
->b_data
;
4246 if (le32_to_cpu(dx_root
->dr_num_entries
) == OCFS2_DX_ENTRIES_MAX
) {
4252 if (ocfs2_dx_root_inline(dx_root
)) {
4253 ret
= ocfs2_inline_dx_has_space(dx_root_bh
);
4259 * We ran out of room in the root block. Expand it to
4260 * an extent, then allow ocfs2_find_dir_space_dx to do
4263 ret
= ocfs2_expand_inline_dx_root(dir
, dx_root_bh
);
4271 * Insert preparation for an indexed directory is split into two
4272 * steps. The call to find_dir_space_dx reserves room in the index for
4273 * an additional item. If we run out of space there, it's a real error
4274 * we can't continue on.
4276 ret
= ocfs2_find_dir_space_dx(osb
, dir
, di_bh
, dx_root_bh
, name
,
4285 * Next, we need to find space in the unindexed tree. This call
4286 * searches using the free space linked list. If the unindexed tree
4287 * lacks sufficient space, we'll expand it below. The expansion code
4288 * is smart enough to add any new blocks to the free space list.
4290 ret
= ocfs2_search_dx_free_list(dir
, dx_root_bh
, namelen
, lookup
);
4291 if (ret
&& ret
!= -ENOSPC
) {
4296 /* Do this up here - ocfs2_extend_dir might need the dx_root */
4297 lookup
->dl_dx_root_bh
= dx_root_bh
;
4300 if (ret
== -ENOSPC
) {
4301 ret
= ocfs2_extend_dir(osb
, dir
, di_bh
, 1, lookup
, &leaf_bh
);
4309 * We make the assumption here that new leaf blocks are added
4310 * to the front of our free list.
4312 lookup
->dl_prev_leaf_bh
= NULL
;
4313 lookup
->dl_leaf_bh
= leaf_bh
;
4323 * Get a directory ready for insert. Any directory allocation required
4324 * happens here. Success returns zero, and enough context in the dir
4325 * lookup result that ocfs2_add_entry() will be able complete the task
4326 * with minimal performance impact.
4328 int ocfs2_prepare_dir_for_insert(struct ocfs2_super
*osb
,
4330 struct buffer_head
*parent_fe_bh
,
4333 struct ocfs2_dir_lookup_result
*lookup
)
4336 unsigned int blocks_wanted
= 1;
4337 struct buffer_head
*bh
= NULL
;
4339 trace_ocfs2_prepare_dir_for_insert(
4340 (unsigned long long)OCFS2_I(dir
)->ip_blkno
, namelen
);
4349 * Do this up front to reduce confusion.
4351 * The directory might start inline, then be turned into an
4352 * indexed one, in which case we'd need to hash deep inside
4353 * ocfs2_find_dir_space_id(). Since
4354 * ocfs2_prepare_dx_dir_for_insert() also needs this hash
4355 * done, there seems no point in spreading out the calls. We
4356 * can optimize away the case where the file system doesn't
4359 if (ocfs2_supports_indexed_dirs(osb
))
4360 ocfs2_dx_dir_name_hash(dir
, name
, namelen
, &lookup
->dl_hinfo
);
4362 if (ocfs2_dir_indexed(dir
)) {
4363 ret
= ocfs2_prepare_dx_dir_for_insert(dir
, parent_fe_bh
,
4364 name
, namelen
, lookup
);
4370 if (OCFS2_I(dir
)->ip_dyn_features
& OCFS2_INLINE_DATA_FL
) {
4371 ret
= ocfs2_find_dir_space_id(dir
, parent_fe_bh
, name
,
4372 namelen
, &bh
, &blocks_wanted
);
4374 ret
= ocfs2_find_dir_space_el(dir
, name
, namelen
, &bh
);
4376 if (ret
&& ret
!= -ENOSPC
) {
4381 if (ret
== -ENOSPC
) {
4383 * We have to expand the directory to add this name.
4387 ret
= ocfs2_extend_dir(osb
, dir
, parent_fe_bh
, blocks_wanted
,
4398 lookup
->dl_leaf_bh
= bh
;
4405 static int ocfs2_dx_dir_remove_index(struct inode
*dir
,
4406 struct buffer_head
*di_bh
,
4407 struct buffer_head
*dx_root_bh
)
4410 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
4411 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
4412 struct ocfs2_dx_root_block
*dx_root
;
4413 struct inode
*dx_alloc_inode
= NULL
;
4414 struct buffer_head
*dx_alloc_bh
= NULL
;
4420 dx_root
= (struct ocfs2_dx_root_block
*) dx_root_bh
->b_data
;
4422 dx_alloc_inode
= ocfs2_get_system_file_inode(osb
,
4423 EXTENT_ALLOC_SYSTEM_INODE
,
4424 le16_to_cpu(dx_root
->dr_suballoc_slot
));
4425 if (!dx_alloc_inode
) {
4430 mutex_lock(&dx_alloc_inode
->i_mutex
);
4432 ret
= ocfs2_inode_lock(dx_alloc_inode
, &dx_alloc_bh
, 1);
4438 handle
= ocfs2_start_trans(osb
, OCFS2_DX_ROOT_REMOVE_CREDITS
);
4439 if (IS_ERR(handle
)) {
4440 ret
= PTR_ERR(handle
);
4445 ret
= ocfs2_journal_access_di(handle
, INODE_CACHE(dir
), di_bh
,
4446 OCFS2_JOURNAL_ACCESS_WRITE
);
4452 spin_lock(&OCFS2_I(dir
)->ip_lock
);
4453 OCFS2_I(dir
)->ip_dyn_features
&= ~OCFS2_INDEXED_DIR_FL
;
4454 di
->i_dyn_features
= cpu_to_le16(OCFS2_I(dir
)->ip_dyn_features
);
4455 spin_unlock(&OCFS2_I(dir
)->ip_lock
);
4456 di
->i_dx_root
= cpu_to_le64(0ULL);
4458 ocfs2_journal_dirty(handle
, di_bh
);
4460 blk
= le64_to_cpu(dx_root
->dr_blkno
);
4461 bit
= le16_to_cpu(dx_root
->dr_suballoc_bit
);
4462 if (dx_root
->dr_suballoc_loc
)
4463 bg_blkno
= le64_to_cpu(dx_root
->dr_suballoc_loc
);
4465 bg_blkno
= ocfs2_which_suballoc_group(blk
, bit
);
4466 ret
= ocfs2_free_suballoc_bits(handle
, dx_alloc_inode
, dx_alloc_bh
,
4472 ocfs2_commit_trans(osb
, handle
);
4475 ocfs2_inode_unlock(dx_alloc_inode
, 1);
4478 mutex_unlock(&dx_alloc_inode
->i_mutex
);
4479 brelse(dx_alloc_bh
);
4481 iput(dx_alloc_inode
);
4485 int ocfs2_dx_dir_truncate(struct inode
*dir
, struct buffer_head
*di_bh
)
4488 unsigned int uninitialized_var(clen
);
4489 u32 major_hash
= UINT_MAX
, p_cpos
, uninitialized_var(cpos
);
4490 u64
uninitialized_var(blkno
);
4491 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
4492 struct buffer_head
*dx_root_bh
= NULL
;
4493 struct ocfs2_dx_root_block
*dx_root
;
4494 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
4495 struct ocfs2_cached_dealloc_ctxt dealloc
;
4496 struct ocfs2_extent_tree et
;
4498 ocfs2_init_dealloc_ctxt(&dealloc
);
4500 if (!ocfs2_dir_indexed(dir
))
4503 ret
= ocfs2_read_dx_root(dir
, di
, &dx_root_bh
);
4508 dx_root
= (struct ocfs2_dx_root_block
*)dx_root_bh
->b_data
;
4510 if (ocfs2_dx_root_inline(dx_root
))
4513 ocfs2_init_dx_root_extent_tree(&et
, INODE_CACHE(dir
), dx_root_bh
);
4515 /* XXX: What if dr_clusters is too large? */
4516 while (le32_to_cpu(dx_root
->dr_clusters
)) {
4517 ret
= ocfs2_dx_dir_lookup_rec(dir
, &dx_root
->dr_list
,
4518 major_hash
, &cpos
, &blkno
, &clen
);
4524 p_cpos
= ocfs2_blocks_to_clusters(dir
->i_sb
, blkno
);
4526 ret
= ocfs2_remove_btree_range(dir
, &et
, cpos
, p_cpos
, clen
, 0,
4536 major_hash
= cpos
- 1;
4540 ret
= ocfs2_dx_dir_remove_index(dir
, di_bh
, dx_root_bh
);
4546 ocfs2_remove_from_cache(INODE_CACHE(dir
), dx_root_bh
);
4548 ocfs2_schedule_truncate_log_flush(osb
, 1);
4549 ocfs2_run_deallocs(osb
, &dealloc
);