GNU Linux-libre 4.19.211-gnu1
[releases.git] / fs / ocfs2 / dir.c
1 /* -*- mode: c; c-basic-offset: 8; -*-
2  * vim: noexpandtab sw=8 ts=8 sts=0:
3  *
4  * dir.c
5  *
6  * Creates, reads, walks and deletes directory-nodes
7  *
8  * Copyright (C) 2002, 2004 Oracle.  All rights reserved.
9  *
10  *  Portions of this code from linux/fs/ext3/dir.c
11  *
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)
16  *
17  *   from
18  *
19  *   linux/fs/minix/dir.c
20  *
21  *   Copyright (C) 1991, 1992 Linus Torvalds
22  *
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.
27  *
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.
32  *
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.
37  */
38
39 #include <linux/fs.h>
40 #include <linux/types.h>
41 #include <linux/slab.h>
42 #include <linux/highmem.h>
43 #include <linux/quotaops.h>
44 #include <linux/sort.h>
45 #include <linux/iversion.h>
46
47 #include <cluster/masklog.h>
48
49 #include "ocfs2.h"
50
51 #include "alloc.h"
52 #include "blockcheck.h"
53 #include "dir.h"
54 #include "dlmglue.h"
55 #include "extent_map.h"
56 #include "file.h"
57 #include "inode.h"
58 #include "journal.h"
59 #include "namei.h"
60 #include "suballoc.h"
61 #include "super.h"
62 #include "sysfile.h"
63 #include "uptodate.h"
64 #include "ocfs2_trace.h"
65
66 #include "buffer_head_io.h"
67
68 #define NAMEI_RA_CHUNKS  2
69 #define NAMEI_RA_BLOCKS  4
70 #define NAMEI_RA_SIZE        (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS)
71
72 static unsigned char ocfs2_filetype_table[] = {
73         DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
74 };
75
76 static int ocfs2_do_extend_dir(struct super_block *sb,
77                                handle_t *handle,
78                                struct inode *dir,
79                                struct buffer_head *parent_fe_bh,
80                                struct ocfs2_alloc_context *data_ac,
81                                struct ocfs2_alloc_context *meta_ac,
82                                struct buffer_head **new_bh);
83 static int ocfs2_dir_indexed(struct inode *inode);
84
85 /*
86  * These are distinct checks because future versions of the file system will
87  * want to have a trailing dirent structure independent of indexing.
88  */
89 static int ocfs2_supports_dir_trailer(struct inode *dir)
90 {
91         struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
92
93         if (OCFS2_I(dir)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
94                 return 0;
95
96         return ocfs2_meta_ecc(osb) || ocfs2_dir_indexed(dir);
97 }
98
99 /*
100  * "new' here refers to the point at which we're creating a new
101  * directory via "mkdir()", but also when we're expanding an inline
102  * directory. In either case, we don't yet have the indexing bit set
103  * on the directory, so the standard checks will fail in when metaecc
104  * is turned off. Only directory-initialization type functions should
105  * use this then. Everything else wants ocfs2_supports_dir_trailer()
106  */
107 static int ocfs2_new_dir_wants_trailer(struct inode *dir)
108 {
109         struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
110
111         return ocfs2_meta_ecc(osb) ||
112                 ocfs2_supports_indexed_dirs(osb);
113 }
114
115 static inline unsigned int ocfs2_dir_trailer_blk_off(struct super_block *sb)
116 {
117         return sb->s_blocksize - sizeof(struct ocfs2_dir_block_trailer);
118 }
119
120 #define ocfs2_trailer_from_bh(_bh, _sb) ((struct ocfs2_dir_block_trailer *) ((_bh)->b_data + ocfs2_dir_trailer_blk_off((_sb))))
121
122 /* XXX ocfs2_block_dqtrailer() is similar but not quite - can we make
123  * them more consistent? */
124 struct ocfs2_dir_block_trailer *ocfs2_dir_trailer_from_size(int blocksize,
125                                                             void *data)
126 {
127         char *p = data;
128
129         p += blocksize - sizeof(struct ocfs2_dir_block_trailer);
130         return (struct ocfs2_dir_block_trailer *)p;
131 }
132
133 /*
134  * XXX: This is executed once on every dirent. We should consider optimizing
135  * it.
136  */
137 static int ocfs2_skip_dir_trailer(struct inode *dir,
138                                   struct ocfs2_dir_entry *de,
139                                   unsigned long offset,
140                                   unsigned long blklen)
141 {
142         unsigned long toff = blklen - sizeof(struct ocfs2_dir_block_trailer);
143
144         if (!ocfs2_supports_dir_trailer(dir))
145                 return 0;
146
147         if (offset != toff)
148                 return 0;
149
150         return 1;
151 }
152
153 static void ocfs2_init_dir_trailer(struct inode *inode,
154                                    struct buffer_head *bh, u16 rec_len)
155 {
156         struct ocfs2_dir_block_trailer *trailer;
157
158         trailer = ocfs2_trailer_from_bh(bh, inode->i_sb);
159         strcpy(trailer->db_signature, OCFS2_DIR_TRAILER_SIGNATURE);
160         trailer->db_compat_rec_len =
161                         cpu_to_le16(sizeof(struct ocfs2_dir_block_trailer));
162         trailer->db_parent_dinode = cpu_to_le64(OCFS2_I(inode)->ip_blkno);
163         trailer->db_blkno = cpu_to_le64(bh->b_blocknr);
164         trailer->db_free_rec_len = cpu_to_le16(rec_len);
165 }
166 /*
167  * Link an unindexed block with a dir trailer structure into the index free
168  * list. This function will modify dirdata_bh, but assumes you've already
169  * passed it to the journal.
170  */
171 static int ocfs2_dx_dir_link_trailer(struct inode *dir, handle_t *handle,
172                                      struct buffer_head *dx_root_bh,
173                                      struct buffer_head *dirdata_bh)
174 {
175         int ret;
176         struct ocfs2_dx_root_block *dx_root;
177         struct ocfs2_dir_block_trailer *trailer;
178
179         ret = ocfs2_journal_access_dr(handle, INODE_CACHE(dir), dx_root_bh,
180                                       OCFS2_JOURNAL_ACCESS_WRITE);
181         if (ret) {
182                 mlog_errno(ret);
183                 goto out;
184         }
185         trailer = ocfs2_trailer_from_bh(dirdata_bh, dir->i_sb);
186         dx_root = (struct ocfs2_dx_root_block *)dx_root_bh->b_data;
187
188         trailer->db_free_next = dx_root->dr_free_blk;
189         dx_root->dr_free_blk = cpu_to_le64(dirdata_bh->b_blocknr);
190
191         ocfs2_journal_dirty(handle, dx_root_bh);
192
193 out:
194         return ret;
195 }
196
197 static int ocfs2_free_list_at_root(struct ocfs2_dir_lookup_result *res)
198 {
199         return res->dl_prev_leaf_bh == NULL;
200 }
201
202 void ocfs2_free_dir_lookup_result(struct ocfs2_dir_lookup_result *res)
203 {
204         brelse(res->dl_dx_root_bh);
205         brelse(res->dl_leaf_bh);
206         brelse(res->dl_dx_leaf_bh);
207         brelse(res->dl_prev_leaf_bh);
208 }
209
210 static int ocfs2_dir_indexed(struct inode *inode)
211 {
212         if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INDEXED_DIR_FL)
213                 return 1;
214         return 0;
215 }
216
217 static inline int ocfs2_dx_root_inline(struct ocfs2_dx_root_block *dx_root)
218 {
219         return dx_root->dr_flags & OCFS2_DX_FLAG_INLINE;
220 }
221
222 /*
223  * Hashing code adapted from ext3
224  */
225 #define DELTA 0x9E3779B9
226
227 static void TEA_transform(__u32 buf[4], __u32 const in[])
228 {
229         __u32   sum = 0;
230         __u32   b0 = buf[0], b1 = buf[1];
231         __u32   a = in[0], b = in[1], c = in[2], d = in[3];
232         int     n = 16;
233
234         do {
235                 sum += DELTA;
236                 b0 += ((b1 << 4)+a) ^ (b1+sum) ^ ((b1 >> 5)+b);
237                 b1 += ((b0 << 4)+c) ^ (b0+sum) ^ ((b0 >> 5)+d);
238         } while (--n);
239
240         buf[0] += b0;
241         buf[1] += b1;
242 }
243
244 static void str2hashbuf(const char *msg, int len, __u32 *buf, int num)
245 {
246         __u32   pad, val;
247         int     i;
248
249         pad = (__u32)len | ((__u32)len << 8);
250         pad |= pad << 16;
251
252         val = pad;
253         if (len > num*4)
254                 len = num * 4;
255         for (i = 0; i < len; i++) {
256                 if ((i % 4) == 0)
257                         val = pad;
258                 val = msg[i] + (val << 8);
259                 if ((i % 4) == 3) {
260                         *buf++ = val;
261                         val = pad;
262                         num--;
263                 }
264         }
265         if (--num >= 0)
266                 *buf++ = val;
267         while (--num >= 0)
268                 *buf++ = pad;
269 }
270
271 static void ocfs2_dx_dir_name_hash(struct inode *dir, const char *name, int len,
272                                    struct ocfs2_dx_hinfo *hinfo)
273 {
274         struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
275         const char      *p;
276         __u32           in[8], buf[4];
277
278         /*
279          * XXX: Is this really necessary, if the index is never looked
280          * at by readdir? Is a hash value of '0' a bad idea?
281          */
282         if ((len == 1 && !strncmp(".", name, 1)) ||
283             (len == 2 && !strncmp("..", name, 2))) {
284                 buf[0] = buf[1] = 0;
285                 goto out;
286         }
287
288 #ifdef OCFS2_DEBUG_DX_DIRS
289         /*
290          * This makes it very easy to debug indexing problems. We
291          * should never allow this to be selected without hand editing
292          * this file though.
293          */
294         buf[0] = buf[1] = len;
295         goto out;
296 #endif
297
298         memcpy(buf, osb->osb_dx_seed, sizeof(buf));
299
300         p = name;
301         while (len > 0) {
302                 str2hashbuf(p, len, in, 4);
303                 TEA_transform(buf, in);
304                 len -= 16;
305                 p += 16;
306         }
307
308 out:
309         hinfo->major_hash = buf[0];
310         hinfo->minor_hash = buf[1];
311 }
312
313 /*
314  * bh passed here can be an inode block or a dir data block, depending
315  * on the inode inline data flag.
316  */
317 static int ocfs2_check_dir_entry(struct inode * dir,
318                                  struct ocfs2_dir_entry * de,
319                                  struct buffer_head * bh,
320                                  unsigned long offset)
321 {
322         const char *error_msg = NULL;
323         const int rlen = le16_to_cpu(de->rec_len);
324
325         if (unlikely(rlen < OCFS2_DIR_REC_LEN(1)))
326                 error_msg = "rec_len is smaller than minimal";
327         else if (unlikely(rlen % 4 != 0))
328                 error_msg = "rec_len % 4 != 0";
329         else if (unlikely(rlen < OCFS2_DIR_REC_LEN(de->name_len)))
330                 error_msg = "rec_len is too small for name_len";
331         else if (unlikely(
332                  ((char *) de - bh->b_data) + rlen > dir->i_sb->s_blocksize))
333                 error_msg = "directory entry across blocks";
334
335         if (unlikely(error_msg != NULL))
336                 mlog(ML_ERROR, "bad entry in directory #%llu: %s - "
337                      "offset=%lu, inode=%llu, rec_len=%d, name_len=%d\n",
338                      (unsigned long long)OCFS2_I(dir)->ip_blkno, error_msg,
339                      offset, (unsigned long long)le64_to_cpu(de->inode), rlen,
340                      de->name_len);
341
342         return error_msg == NULL ? 1 : 0;
343 }
344
345 static inline int ocfs2_match(int len,
346                               const char * const name,
347                               struct ocfs2_dir_entry *de)
348 {
349         if (len != de->name_len)
350                 return 0;
351         if (!de->inode)
352                 return 0;
353         return !memcmp(name, de->name, len);
354 }
355
356 /*
357  * Returns 0 if not found, -1 on failure, and 1 on success
358  */
359 static inline int ocfs2_search_dirblock(struct buffer_head *bh,
360                                         struct inode *dir,
361                                         const char *name, int namelen,
362                                         unsigned long offset,
363                                         char *first_de,
364                                         unsigned int bytes,
365                                         struct ocfs2_dir_entry **res_dir)
366 {
367         struct ocfs2_dir_entry *de;
368         char *dlimit, *de_buf;
369         int de_len;
370         int ret = 0;
371
372         de_buf = first_de;
373         dlimit = de_buf + bytes;
374
375         while (de_buf < dlimit) {
376                 /* this code is executed quadratically often */
377                 /* do minimal checking `by hand' */
378
379                 de = (struct ocfs2_dir_entry *) de_buf;
380
381                 if (de_buf + namelen <= dlimit &&
382                     ocfs2_match(namelen, name, de)) {
383                         /* found a match - just to be sure, do a full check */
384                         if (!ocfs2_check_dir_entry(dir, de, bh, offset)) {
385                                 ret = -1;
386                                 goto bail;
387                         }
388                         *res_dir = de;
389                         ret = 1;
390                         goto bail;
391                 }
392
393                 /* prevent looping on a bad block */
394                 de_len = le16_to_cpu(de->rec_len);
395                 if (de_len <= 0) {
396                         ret = -1;
397                         goto bail;
398                 }
399
400                 de_buf += de_len;
401                 offset += de_len;
402         }
403
404 bail:
405         trace_ocfs2_search_dirblock(ret);
406         return ret;
407 }
408
409 static struct buffer_head *ocfs2_find_entry_id(const char *name,
410                                                int namelen,
411                                                struct inode *dir,
412                                                struct ocfs2_dir_entry **res_dir)
413 {
414         int ret, found;
415         struct buffer_head *di_bh = NULL;
416         struct ocfs2_dinode *di;
417         struct ocfs2_inline_data *data;
418
419         ret = ocfs2_read_inode_block(dir, &di_bh);
420         if (ret) {
421                 mlog_errno(ret);
422                 goto out;
423         }
424
425         di = (struct ocfs2_dinode *)di_bh->b_data;
426         data = &di->id2.i_data;
427
428         found = ocfs2_search_dirblock(di_bh, dir, name, namelen, 0,
429                                       data->id_data, i_size_read(dir), res_dir);
430         if (found == 1)
431                 return di_bh;
432
433         brelse(di_bh);
434 out:
435         return NULL;
436 }
437
438 static int ocfs2_validate_dir_block(struct super_block *sb,
439                                     struct buffer_head *bh)
440 {
441         int rc;
442         struct ocfs2_dir_block_trailer *trailer =
443                 ocfs2_trailer_from_bh(bh, sb);
444
445
446         /*
447          * We don't validate dirents here, that's handled
448          * in-place when the code walks them.
449          */
450         trace_ocfs2_validate_dir_block((unsigned long long)bh->b_blocknr);
451
452         BUG_ON(!buffer_uptodate(bh));
453
454         /*
455          * If the ecc fails, we return the error but otherwise
456          * leave the filesystem running.  We know any error is
457          * local to this block.
458          *
459          * Note that we are safe to call this even if the directory
460          * doesn't have a trailer.  Filesystems without metaecc will do
461          * nothing, and filesystems with it will have one.
462          */
463         rc = ocfs2_validate_meta_ecc(sb, bh->b_data, &trailer->db_check);
464         if (rc)
465                 mlog(ML_ERROR, "Checksum failed for dinode %llu\n",
466                      (unsigned long long)bh->b_blocknr);
467
468         return rc;
469 }
470
471 /*
472  * Validate a directory trailer.
473  *
474  * We check the trailer here rather than in ocfs2_validate_dir_block()
475  * because that function doesn't have the inode to test.
476  */
477 static int ocfs2_check_dir_trailer(struct inode *dir, struct buffer_head *bh)
478 {
479         int rc = 0;
480         struct ocfs2_dir_block_trailer *trailer;
481
482         trailer = ocfs2_trailer_from_bh(bh, dir->i_sb);
483         if (!OCFS2_IS_VALID_DIR_TRAILER(trailer)) {
484                 rc = ocfs2_error(dir->i_sb,
485                                  "Invalid dirblock #%llu: signature = %.*s\n",
486                                  (unsigned long long)bh->b_blocknr, 7,
487                                  trailer->db_signature);
488                 goto out;
489         }
490         if (le64_to_cpu(trailer->db_blkno) != bh->b_blocknr) {
491                 rc = ocfs2_error(dir->i_sb,
492                                  "Directory block #%llu has an invalid db_blkno of %llu\n",
493                                  (unsigned long long)bh->b_blocknr,
494                                  (unsigned long long)le64_to_cpu(trailer->db_blkno));
495                 goto out;
496         }
497         if (le64_to_cpu(trailer->db_parent_dinode) !=
498             OCFS2_I(dir)->ip_blkno) {
499                 rc = ocfs2_error(dir->i_sb,
500                                  "Directory block #%llu on dinode #%llu has an invalid parent_dinode of %llu\n",
501                                  (unsigned long long)bh->b_blocknr,
502                                  (unsigned long long)OCFS2_I(dir)->ip_blkno,
503                                  (unsigned long long)le64_to_cpu(trailer->db_blkno));
504                 goto out;
505         }
506 out:
507         return rc;
508 }
509
510 /*
511  * This function forces all errors to -EIO for consistency with its
512  * predecessor, ocfs2_bread().  We haven't audited what returning the
513  * real error codes would do to callers.  We log the real codes with
514  * mlog_errno() before we squash them.
515  */
516 static int ocfs2_read_dir_block(struct inode *inode, u64 v_block,
517                                 struct buffer_head **bh, int flags)
518 {
519         int rc = 0;
520         struct buffer_head *tmp = *bh;
521
522         rc = ocfs2_read_virt_blocks(inode, v_block, 1, &tmp, flags,
523                                     ocfs2_validate_dir_block);
524         if (rc) {
525                 mlog_errno(rc);
526                 goto out;
527         }
528
529         if (!(flags & OCFS2_BH_READAHEAD) &&
530             ocfs2_supports_dir_trailer(inode)) {
531                 rc = ocfs2_check_dir_trailer(inode, tmp);
532                 if (rc) {
533                         if (!*bh)
534                                 brelse(tmp);
535                         mlog_errno(rc);
536                         goto out;
537                 }
538         }
539
540         /* If ocfs2_read_virt_blocks() got us a new bh, pass it up. */
541         if (!*bh)
542                 *bh = tmp;
543
544 out:
545         return rc ? -EIO : 0;
546 }
547
548 /*
549  * Read the block at 'phys' which belongs to this directory
550  * inode. This function does no virtual->physical block translation -
551  * what's passed in is assumed to be a valid directory block.
552  */
553 static int ocfs2_read_dir_block_direct(struct inode *dir, u64 phys,
554                                        struct buffer_head **bh)
555 {
556         int ret;
557         struct buffer_head *tmp = *bh;
558
559         ret = ocfs2_read_block(INODE_CACHE(dir), phys, &tmp,
560                                ocfs2_validate_dir_block);
561         if (ret) {
562                 mlog_errno(ret);
563                 goto out;
564         }
565
566         if (ocfs2_supports_dir_trailer(dir)) {
567                 ret = ocfs2_check_dir_trailer(dir, tmp);
568                 if (ret) {
569                         if (!*bh)
570                                 brelse(tmp);
571                         mlog_errno(ret);
572                         goto out;
573                 }
574         }
575
576         if (!ret && !*bh)
577                 *bh = tmp;
578 out:
579         return ret;
580 }
581
582 static int ocfs2_validate_dx_root(struct super_block *sb,
583                                   struct buffer_head *bh)
584 {
585         int ret;
586         struct ocfs2_dx_root_block *dx_root;
587
588         BUG_ON(!buffer_uptodate(bh));
589
590         dx_root = (struct ocfs2_dx_root_block *) bh->b_data;
591
592         ret = ocfs2_validate_meta_ecc(sb, bh->b_data, &dx_root->dr_check);
593         if (ret) {
594                 mlog(ML_ERROR,
595                      "Checksum failed for dir index root block %llu\n",
596                      (unsigned long long)bh->b_blocknr);
597                 return ret;
598         }
599
600         if (!OCFS2_IS_VALID_DX_ROOT(dx_root)) {
601                 ret = ocfs2_error(sb,
602                                   "Dir Index Root # %llu has bad signature %.*s\n",
603                                   (unsigned long long)le64_to_cpu(dx_root->dr_blkno),
604                                   7, dx_root->dr_signature);
605         }
606
607         return ret;
608 }
609
610 static int ocfs2_read_dx_root(struct inode *dir, struct ocfs2_dinode *di,
611                               struct buffer_head **dx_root_bh)
612 {
613         int ret;
614         u64 blkno = le64_to_cpu(di->i_dx_root);
615         struct buffer_head *tmp = *dx_root_bh;
616
617         ret = ocfs2_read_block(INODE_CACHE(dir), blkno, &tmp,
618                                ocfs2_validate_dx_root);
619
620         /* If ocfs2_read_block() got us a new bh, pass it up. */
621         if (!ret && !*dx_root_bh)
622                 *dx_root_bh = tmp;
623
624         return ret;
625 }
626
627 static int ocfs2_validate_dx_leaf(struct super_block *sb,
628                                   struct buffer_head *bh)
629 {
630         int ret;
631         struct ocfs2_dx_leaf *dx_leaf = (struct ocfs2_dx_leaf *)bh->b_data;
632
633         BUG_ON(!buffer_uptodate(bh));
634
635         ret = ocfs2_validate_meta_ecc(sb, bh->b_data, &dx_leaf->dl_check);
636         if (ret) {
637                 mlog(ML_ERROR,
638                      "Checksum failed for dir index leaf block %llu\n",
639                      (unsigned long long)bh->b_blocknr);
640                 return ret;
641         }
642
643         if (!OCFS2_IS_VALID_DX_LEAF(dx_leaf)) {
644                 ret = ocfs2_error(sb, "Dir Index Leaf has bad signature %.*s\n",
645                                   7, dx_leaf->dl_signature);
646         }
647
648         return ret;
649 }
650
651 static int ocfs2_read_dx_leaf(struct inode *dir, u64 blkno,
652                               struct buffer_head **dx_leaf_bh)
653 {
654         int ret;
655         struct buffer_head *tmp = *dx_leaf_bh;
656
657         ret = ocfs2_read_block(INODE_CACHE(dir), blkno, &tmp,
658                                ocfs2_validate_dx_leaf);
659
660         /* If ocfs2_read_block() got us a new bh, pass it up. */
661         if (!ret && !*dx_leaf_bh)
662                 *dx_leaf_bh = tmp;
663
664         return ret;
665 }
666
667 /*
668  * Read a series of dx_leaf blocks. This expects all buffer_head
669  * pointers to be NULL on function entry.
670  */
671 static int ocfs2_read_dx_leaves(struct inode *dir, u64 start, int num,
672                                 struct buffer_head **dx_leaf_bhs)
673 {
674         int ret;
675
676         ret = ocfs2_read_blocks(INODE_CACHE(dir), start, num, dx_leaf_bhs, 0,
677                                 ocfs2_validate_dx_leaf);
678         if (ret)
679                 mlog_errno(ret);
680
681         return ret;
682 }
683
684 static struct buffer_head *ocfs2_find_entry_el(const char *name, int namelen,
685                                                struct inode *dir,
686                                                struct ocfs2_dir_entry **res_dir)
687 {
688         struct super_block *sb;
689         struct buffer_head *bh_use[NAMEI_RA_SIZE];
690         struct buffer_head *bh, *ret = NULL;
691         unsigned long start, block, b;
692         int ra_max = 0;         /* Number of bh's in the readahead
693                                    buffer, bh_use[] */
694         int ra_ptr = 0;         /* Current index into readahead
695                                    buffer */
696         int num = 0;
697         int nblocks, i, err;
698
699         sb = dir->i_sb;
700
701         nblocks = i_size_read(dir) >> sb->s_blocksize_bits;
702         start = OCFS2_I(dir)->ip_dir_start_lookup;
703         if (start >= nblocks)
704                 start = 0;
705         block = start;
706
707 restart:
708         do {
709                 /*
710                  * We deal with the read-ahead logic here.
711                  */
712                 if (ra_ptr >= ra_max) {
713                         /* Refill the readahead buffer */
714                         ra_ptr = 0;
715                         b = block;
716                         for (ra_max = 0; ra_max < NAMEI_RA_SIZE; ra_max++) {
717                                 /*
718                                  * Terminate if we reach the end of the
719                                  * directory and must wrap, or if our
720                                  * search has finished at this block.
721                                  */
722                                 if (b >= nblocks || (num && block == start)) {
723                                         bh_use[ra_max] = NULL;
724                                         break;
725                                 }
726                                 num++;
727
728                                 bh = NULL;
729                                 err = ocfs2_read_dir_block(dir, b++, &bh,
730                                                            OCFS2_BH_READAHEAD);
731                                 bh_use[ra_max] = bh;
732                         }
733                 }
734                 if ((bh = bh_use[ra_ptr++]) == NULL)
735                         goto next;
736                 if (ocfs2_read_dir_block(dir, block, &bh, 0)) {
737                         /* read error, skip block & hope for the best.
738                          * ocfs2_read_dir_block() has released the bh. */
739                         mlog(ML_ERROR, "reading directory %llu, "
740                                     "offset %lu\n",
741                                     (unsigned long long)OCFS2_I(dir)->ip_blkno,
742                                     block);
743                         goto next;
744                 }
745                 i = ocfs2_search_dirblock(bh, dir, name, namelen,
746                                           block << sb->s_blocksize_bits,
747                                           bh->b_data, sb->s_blocksize,
748                                           res_dir);
749                 if (i == 1) {
750                         OCFS2_I(dir)->ip_dir_start_lookup = block;
751                         ret = bh;
752                         goto cleanup_and_exit;
753                 } else {
754                         brelse(bh);
755                         if (i < 0)
756                                 goto cleanup_and_exit;
757                 }
758         next:
759                 if (++block >= nblocks)
760                         block = 0;
761         } while (block != start);
762
763         /*
764          * If the directory has grown while we were searching, then
765          * search the last part of the directory before giving up.
766          */
767         block = nblocks;
768         nblocks = i_size_read(dir) >> sb->s_blocksize_bits;
769         if (block < nblocks) {
770                 start = 0;
771                 goto restart;
772         }
773
774 cleanup_and_exit:
775         /* Clean up the read-ahead blocks */
776         for (; ra_ptr < ra_max; ra_ptr++)
777                 brelse(bh_use[ra_ptr]);
778
779         trace_ocfs2_find_entry_el(ret);
780         return ret;
781 }
782
783 static int ocfs2_dx_dir_lookup_rec(struct inode *inode,
784                                    struct ocfs2_extent_list *el,
785                                    u32 major_hash,
786                                    u32 *ret_cpos,
787                                    u64 *ret_phys_blkno,
788                                    unsigned int *ret_clen)
789 {
790         int ret = 0, i, found;
791         struct buffer_head *eb_bh = NULL;
792         struct ocfs2_extent_block *eb;
793         struct ocfs2_extent_rec *rec = NULL;
794
795         if (el->l_tree_depth) {
796                 ret = ocfs2_find_leaf(INODE_CACHE(inode), el, major_hash,
797                                       &eb_bh);
798                 if (ret) {
799                         mlog_errno(ret);
800                         goto out;
801                 }
802
803                 eb = (struct ocfs2_extent_block *) eb_bh->b_data;
804                 el = &eb->h_list;
805
806                 if (el->l_tree_depth) {
807                         ret = ocfs2_error(inode->i_sb,
808                                           "Inode %lu has non zero tree depth in btree tree block %llu\n",
809                                           inode->i_ino,
810                                           (unsigned long long)eb_bh->b_blocknr);
811                         goto out;
812                 }
813         }
814
815         found = 0;
816         for (i = le16_to_cpu(el->l_next_free_rec) - 1; i >= 0; i--) {
817                 rec = &el->l_recs[i];
818
819                 if (le32_to_cpu(rec->e_cpos) <= major_hash) {
820                         found = 1;
821                         break;
822                 }
823         }
824
825         if (!found) {
826                 ret = ocfs2_error(inode->i_sb,
827                                   "Inode %lu has bad extent record (%u, %u, 0) in btree\n",
828                                   inode->i_ino,
829                                   le32_to_cpu(rec->e_cpos),
830                                   ocfs2_rec_clusters(el, rec));
831                 goto out;
832         }
833
834         if (ret_phys_blkno)
835                 *ret_phys_blkno = le64_to_cpu(rec->e_blkno);
836         if (ret_cpos)
837                 *ret_cpos = le32_to_cpu(rec->e_cpos);
838         if (ret_clen)
839                 *ret_clen = le16_to_cpu(rec->e_leaf_clusters);
840
841 out:
842         brelse(eb_bh);
843         return ret;
844 }
845
846 /*
847  * Returns the block index, from the start of the cluster which this
848  * hash belongs too.
849  */
850 static inline unsigned int __ocfs2_dx_dir_hash_idx(struct ocfs2_super *osb,
851                                                    u32 minor_hash)
852 {
853         return minor_hash & osb->osb_dx_mask;
854 }
855
856 static inline unsigned int ocfs2_dx_dir_hash_idx(struct ocfs2_super *osb,
857                                           struct ocfs2_dx_hinfo *hinfo)
858 {
859         return __ocfs2_dx_dir_hash_idx(osb, hinfo->minor_hash);
860 }
861
862 static int ocfs2_dx_dir_lookup(struct inode *inode,
863                                struct ocfs2_extent_list *el,
864                                struct ocfs2_dx_hinfo *hinfo,
865                                u32 *ret_cpos,
866                                u64 *ret_phys_blkno)
867 {
868         int ret = 0;
869         unsigned int cend, uninitialized_var(clen);
870         u32 uninitialized_var(cpos);
871         u64 uninitialized_var(blkno);
872         u32 name_hash = hinfo->major_hash;
873
874         ret = ocfs2_dx_dir_lookup_rec(inode, el, name_hash, &cpos, &blkno,
875                                       &clen);
876         if (ret) {
877                 mlog_errno(ret);
878                 goto out;
879         }
880
881         cend = cpos + clen;
882         if (name_hash >= cend) {
883                 /* We want the last cluster */
884                 blkno += ocfs2_clusters_to_blocks(inode->i_sb, clen - 1);
885                 cpos += clen - 1;
886         } else {
887                 blkno += ocfs2_clusters_to_blocks(inode->i_sb,
888                                                   name_hash - cpos);
889                 cpos = name_hash;
890         }
891
892         /*
893          * We now have the cluster which should hold our entry. To
894          * find the exact block from the start of the cluster to
895          * search, we take the lower bits of the hash.
896          */
897         blkno += ocfs2_dx_dir_hash_idx(OCFS2_SB(inode->i_sb), hinfo);
898
899         if (ret_phys_blkno)
900                 *ret_phys_blkno = blkno;
901         if (ret_cpos)
902                 *ret_cpos = cpos;
903
904 out:
905
906         return ret;
907 }
908
909 static int ocfs2_dx_dir_search(const char *name, int namelen,
910                                struct inode *dir,
911                                struct ocfs2_dx_root_block *dx_root,
912                                struct ocfs2_dir_lookup_result *res)
913 {
914         int ret, i, found;
915         u64 uninitialized_var(phys);
916         struct buffer_head *dx_leaf_bh = NULL;
917         struct ocfs2_dx_leaf *dx_leaf;
918         struct ocfs2_dx_entry *dx_entry = NULL;
919         struct buffer_head *dir_ent_bh = NULL;
920         struct ocfs2_dir_entry *dir_ent = NULL;
921         struct ocfs2_dx_hinfo *hinfo = &res->dl_hinfo;
922         struct ocfs2_extent_list *dr_el;
923         struct ocfs2_dx_entry_list *entry_list;
924
925         ocfs2_dx_dir_name_hash(dir, name, namelen, &res->dl_hinfo);
926
927         if (ocfs2_dx_root_inline(dx_root)) {
928                 entry_list = &dx_root->dr_entries;
929                 goto search;
930         }
931
932         dr_el = &dx_root->dr_list;
933
934         ret = ocfs2_dx_dir_lookup(dir, dr_el, hinfo, NULL, &phys);
935         if (ret) {
936                 mlog_errno(ret);
937                 goto out;
938         }
939
940         trace_ocfs2_dx_dir_search((unsigned long long)OCFS2_I(dir)->ip_blkno,
941                                   namelen, name, hinfo->major_hash,
942                                   hinfo->minor_hash, (unsigned long long)phys);
943
944         ret = ocfs2_read_dx_leaf(dir, phys, &dx_leaf_bh);
945         if (ret) {
946                 mlog_errno(ret);
947                 goto out;
948         }
949
950         dx_leaf = (struct ocfs2_dx_leaf *) dx_leaf_bh->b_data;
951
952         trace_ocfs2_dx_dir_search_leaf_info(
953                         le16_to_cpu(dx_leaf->dl_list.de_num_used),
954                         le16_to_cpu(dx_leaf->dl_list.de_count));
955
956         entry_list = &dx_leaf->dl_list;
957
958 search:
959         /*
960          * Empty leaf is legal, so no need to check for that.
961          */
962         found = 0;
963         for (i = 0; i < le16_to_cpu(entry_list->de_num_used); i++) {
964                 dx_entry = &entry_list->de_entries[i];
965
966                 if (hinfo->major_hash != le32_to_cpu(dx_entry->dx_major_hash)
967                     || hinfo->minor_hash != le32_to_cpu(dx_entry->dx_minor_hash))
968                         continue;
969
970                 /*
971                  * Search unindexed leaf block now. We're not
972                  * guaranteed to find anything.
973                  */
974                 ret = ocfs2_read_dir_block_direct(dir,
975                                           le64_to_cpu(dx_entry->dx_dirent_blk),
976                                           &dir_ent_bh);
977                 if (ret) {
978                         mlog_errno(ret);
979                         goto out;
980                 }
981
982                 /*
983                  * XXX: We should check the unindexed block here,
984                  * before using it.
985                  */
986
987                 found = ocfs2_search_dirblock(dir_ent_bh, dir, name, namelen,
988                                               0, dir_ent_bh->b_data,
989                                               dir->i_sb->s_blocksize, &dir_ent);
990                 if (found == 1)
991                         break;
992
993                 if (found == -1) {
994                         /* This means we found a bad directory entry. */
995                         ret = -EIO;
996                         mlog_errno(ret);
997                         goto out;
998                 }
999
1000                 brelse(dir_ent_bh);
1001                 dir_ent_bh = NULL;
1002         }
1003
1004         if (found <= 0) {
1005                 ret = -ENOENT;
1006                 goto out;
1007         }
1008
1009         res->dl_leaf_bh = dir_ent_bh;
1010         res->dl_entry = dir_ent;
1011         res->dl_dx_leaf_bh = dx_leaf_bh;
1012         res->dl_dx_entry = dx_entry;
1013
1014         ret = 0;
1015 out:
1016         if (ret) {
1017                 brelse(dx_leaf_bh);
1018                 brelse(dir_ent_bh);
1019         }
1020         return ret;
1021 }
1022
1023 static int ocfs2_find_entry_dx(const char *name, int namelen,
1024                                struct inode *dir,
1025                                struct ocfs2_dir_lookup_result *lookup)
1026 {
1027         int ret;
1028         struct buffer_head *di_bh = NULL;
1029         struct ocfs2_dinode *di;
1030         struct buffer_head *dx_root_bh = NULL;
1031         struct ocfs2_dx_root_block *dx_root;
1032
1033         ret = ocfs2_read_inode_block(dir, &di_bh);
1034         if (ret) {
1035                 mlog_errno(ret);
1036                 goto out;
1037         }
1038
1039         di = (struct ocfs2_dinode *)di_bh->b_data;
1040
1041         ret = ocfs2_read_dx_root(dir, di, &dx_root_bh);
1042         if (ret) {
1043                 mlog_errno(ret);
1044                 goto out;
1045         }
1046         dx_root = (struct ocfs2_dx_root_block *) dx_root_bh->b_data;
1047
1048         ret = ocfs2_dx_dir_search(name, namelen, dir, dx_root, lookup);
1049         if (ret) {
1050                 if (ret != -ENOENT)
1051                         mlog_errno(ret);
1052                 goto out;
1053         }
1054
1055         lookup->dl_dx_root_bh = dx_root_bh;
1056         dx_root_bh = NULL;
1057 out:
1058         brelse(di_bh);
1059         brelse(dx_root_bh);
1060         return ret;
1061 }
1062
1063 /*
1064  * Try to find an entry of the provided name within 'dir'.
1065  *
1066  * If nothing was found, -ENOENT is returned. Otherwise, zero is
1067  * returned and the struct 'res' will contain information useful to
1068  * other directory manipulation functions.
1069  *
1070  * Caller can NOT assume anything about the contents of the
1071  * buffer_heads - they are passed back only so that it can be passed
1072  * into any one of the manipulation functions (add entry, delete
1073  * entry, etc). As an example, bh in the extent directory case is a
1074  * data block, in the inline-data case it actually points to an inode,
1075  * in the indexed directory case, multiple buffers are involved.
1076  */
1077 int ocfs2_find_entry(const char *name, int namelen,
1078                      struct inode *dir, struct ocfs2_dir_lookup_result *lookup)
1079 {
1080         struct buffer_head *bh;
1081         struct ocfs2_dir_entry *res_dir = NULL;
1082
1083         if (ocfs2_dir_indexed(dir))
1084                 return ocfs2_find_entry_dx(name, namelen, dir, lookup);
1085
1086         /*
1087          * The unindexed dir code only uses part of the lookup
1088          * structure, so there's no reason to push it down further
1089          * than this.
1090          */
1091         if (OCFS2_I(dir)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
1092                 bh = ocfs2_find_entry_id(name, namelen, dir, &res_dir);
1093         else
1094                 bh = ocfs2_find_entry_el(name, namelen, dir, &res_dir);
1095
1096         if (bh == NULL)
1097                 return -ENOENT;
1098
1099         lookup->dl_leaf_bh = bh;
1100         lookup->dl_entry = res_dir;
1101         return 0;
1102 }
1103
1104 /*
1105  * Update inode number and type of a previously found directory entry.
1106  */
1107 int ocfs2_update_entry(struct inode *dir, handle_t *handle,
1108                        struct ocfs2_dir_lookup_result *res,
1109                        struct inode *new_entry_inode)
1110 {
1111         int ret;
1112         ocfs2_journal_access_func access = ocfs2_journal_access_db;
1113         struct ocfs2_dir_entry *de = res->dl_entry;
1114         struct buffer_head *de_bh = res->dl_leaf_bh;
1115
1116         /*
1117          * The same code works fine for both inline-data and extent
1118          * based directories, so no need to split this up.  The only
1119          * difference is the journal_access function.
1120          */
1121
1122         if (OCFS2_I(dir)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
1123                 access = ocfs2_journal_access_di;
1124
1125         ret = access(handle, INODE_CACHE(dir), de_bh,
1126                      OCFS2_JOURNAL_ACCESS_WRITE);
1127         if (ret) {
1128                 mlog_errno(ret);
1129                 goto out;
1130         }
1131
1132         de->inode = cpu_to_le64(OCFS2_I(new_entry_inode)->ip_blkno);
1133         ocfs2_set_de_type(de, new_entry_inode->i_mode);
1134
1135         ocfs2_journal_dirty(handle, de_bh);
1136
1137 out:
1138         return ret;
1139 }
1140
1141 /*
1142  * __ocfs2_delete_entry deletes a directory entry by merging it with the
1143  * previous entry
1144  */
1145 static int __ocfs2_delete_entry(handle_t *handle, struct inode *dir,
1146                                 struct ocfs2_dir_entry *de_del,
1147                                 struct buffer_head *bh, char *first_de,
1148                                 unsigned int bytes)
1149 {
1150         struct ocfs2_dir_entry *de, *pde;
1151         int i, status = -ENOENT;
1152         ocfs2_journal_access_func access = ocfs2_journal_access_db;
1153
1154         if (OCFS2_I(dir)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
1155                 access = ocfs2_journal_access_di;
1156
1157         i = 0;
1158         pde = NULL;
1159         de = (struct ocfs2_dir_entry *) first_de;
1160         while (i < bytes) {
1161                 if (!ocfs2_check_dir_entry(dir, de, bh, i)) {
1162                         status = -EIO;
1163                         mlog_errno(status);
1164                         goto bail;
1165                 }
1166                 if (de == de_del)  {
1167                         status = access(handle, INODE_CACHE(dir), bh,
1168                                         OCFS2_JOURNAL_ACCESS_WRITE);
1169                         if (status < 0) {
1170                                 status = -EIO;
1171                                 mlog_errno(status);
1172                                 goto bail;
1173                         }
1174                         if (pde)
1175                                 le16_add_cpu(&pde->rec_len,
1176                                                 le16_to_cpu(de->rec_len));
1177                         de->inode = 0;
1178                         inode_inc_iversion(dir);
1179                         ocfs2_journal_dirty(handle, bh);
1180                         goto bail;
1181                 }
1182                 i += le16_to_cpu(de->rec_len);
1183                 pde = de;
1184                 de = (struct ocfs2_dir_entry *)((char *)de + le16_to_cpu(de->rec_len));
1185         }
1186 bail:
1187         return status;
1188 }
1189
1190 static unsigned int ocfs2_figure_dirent_hole(struct ocfs2_dir_entry *de)
1191 {
1192         unsigned int hole;
1193
1194         if (le64_to_cpu(de->inode) == 0)
1195                 hole = le16_to_cpu(de->rec_len);
1196         else
1197                 hole = le16_to_cpu(de->rec_len) -
1198                         OCFS2_DIR_REC_LEN(de->name_len);
1199
1200         return hole;
1201 }
1202
1203 static int ocfs2_find_max_rec_len(struct super_block *sb,
1204                                   struct buffer_head *dirblock_bh)
1205 {
1206         int size, this_hole, largest_hole = 0;
1207         char *trailer, *de_buf, *limit, *start = dirblock_bh->b_data;
1208         struct ocfs2_dir_entry *de;
1209
1210         trailer = (char *)ocfs2_trailer_from_bh(dirblock_bh, sb);
1211         size = ocfs2_dir_trailer_blk_off(sb);
1212         limit = start + size;
1213         de_buf = start;
1214         de = (struct ocfs2_dir_entry *)de_buf;
1215         do {
1216                 if (de_buf != trailer) {
1217                         this_hole = ocfs2_figure_dirent_hole(de);
1218                         if (this_hole > largest_hole)
1219                                 largest_hole = this_hole;
1220                 }
1221
1222                 de_buf += le16_to_cpu(de->rec_len);
1223                 de = (struct ocfs2_dir_entry *)de_buf;
1224         } while (de_buf < limit);
1225
1226         if (largest_hole >= OCFS2_DIR_MIN_REC_LEN)
1227                 return largest_hole;
1228         return 0;
1229 }
1230
1231 static void ocfs2_dx_list_remove_entry(struct ocfs2_dx_entry_list *entry_list,
1232                                        int index)
1233 {
1234         int num_used = le16_to_cpu(entry_list->de_num_used);
1235
1236         if (num_used == 1 || index == (num_used - 1))
1237                 goto clear;
1238
1239         memmove(&entry_list->de_entries[index],
1240                 &entry_list->de_entries[index + 1],
1241                 (num_used - index - 1)*sizeof(struct ocfs2_dx_entry));
1242 clear:
1243         num_used--;
1244         memset(&entry_list->de_entries[num_used], 0,
1245                sizeof(struct ocfs2_dx_entry));
1246         entry_list->de_num_used = cpu_to_le16(num_used);
1247 }
1248
1249 static int ocfs2_delete_entry_dx(handle_t *handle, struct inode *dir,
1250                                  struct ocfs2_dir_lookup_result *lookup)
1251 {
1252         int ret, index, max_rec_len, add_to_free_list = 0;
1253         struct buffer_head *dx_root_bh = lookup->dl_dx_root_bh;
1254         struct buffer_head *leaf_bh = lookup->dl_leaf_bh;
1255         struct ocfs2_dx_leaf *dx_leaf;
1256         struct ocfs2_dx_entry *dx_entry = lookup->dl_dx_entry;
1257         struct ocfs2_dir_block_trailer *trailer;
1258         struct ocfs2_dx_root_block *dx_root;
1259         struct ocfs2_dx_entry_list *entry_list;
1260
1261         /*
1262          * This function gets a bit messy because we might have to
1263          * modify the root block, regardless of whether the indexed
1264          * entries are stored inline.
1265          */
1266
1267         /*
1268          * *Only* set 'entry_list' here, based on where we're looking
1269          * for the indexed entries. Later, we might still want to
1270          * journal both blocks, based on free list state.
1271          */
1272         dx_root = (struct ocfs2_dx_root_block *)dx_root_bh->b_data;
1273         if (ocfs2_dx_root_inline(dx_root)) {
1274                 entry_list = &dx_root->dr_entries;
1275         } else {
1276                 dx_leaf = (struct ocfs2_dx_leaf *) lookup->dl_dx_leaf_bh->b_data;
1277                 entry_list = &dx_leaf->dl_list;
1278         }
1279
1280         /* Neither of these are a disk corruption - that should have
1281          * been caught by lookup, before we got here. */
1282         BUG_ON(le16_to_cpu(entry_list->de_count) <= 0);
1283         BUG_ON(le16_to_cpu(entry_list->de_num_used) <= 0);
1284
1285         index = (char *)dx_entry - (char *)entry_list->de_entries;
1286         index /= sizeof(*dx_entry);
1287
1288         if (index >= le16_to_cpu(entry_list->de_num_used)) {
1289                 mlog(ML_ERROR, "Dir %llu: Bad dx_entry ptr idx %d, (%p, %p)\n",
1290                      (unsigned long long)OCFS2_I(dir)->ip_blkno, index,
1291                      entry_list, dx_entry);
1292                 return -EIO;
1293         }
1294
1295         /*
1296          * We know that removal of this dirent will leave enough room
1297          * for a new one, so add this block to the free list if it
1298          * isn't already there.
1299          */
1300         trailer = ocfs2_trailer_from_bh(leaf_bh, dir->i_sb);
1301         if (trailer->db_free_rec_len == 0)
1302                 add_to_free_list = 1;
1303
1304         /*
1305          * Add the block holding our index into the journal before
1306          * removing the unindexed entry. If we get an error return
1307          * from __ocfs2_delete_entry(), then it hasn't removed the
1308          * entry yet. Likewise, successful return means we *must*
1309          * remove the indexed entry.
1310          *
1311          * We're also careful to journal the root tree block here as
1312          * the entry count needs to be updated. Also, we might be
1313          * adding to the start of the free list.
1314          */
1315         ret = ocfs2_journal_access_dr(handle, INODE_CACHE(dir), dx_root_bh,
1316                                       OCFS2_JOURNAL_ACCESS_WRITE);
1317         if (ret) {
1318                 mlog_errno(ret);
1319                 goto out;
1320         }
1321
1322         if (!ocfs2_dx_root_inline(dx_root)) {
1323                 ret = ocfs2_journal_access_dl(handle, INODE_CACHE(dir),
1324                                               lookup->dl_dx_leaf_bh,
1325                                               OCFS2_JOURNAL_ACCESS_WRITE);
1326                 if (ret) {
1327                         mlog_errno(ret);
1328                         goto out;
1329                 }
1330         }
1331
1332         trace_ocfs2_delete_entry_dx((unsigned long long)OCFS2_I(dir)->ip_blkno,
1333                                     index);
1334
1335         ret = __ocfs2_delete_entry(handle, dir, lookup->dl_entry,
1336                                    leaf_bh, leaf_bh->b_data, leaf_bh->b_size);
1337         if (ret) {
1338                 mlog_errno(ret);
1339                 goto out;
1340         }
1341
1342         max_rec_len = ocfs2_find_max_rec_len(dir->i_sb, leaf_bh);
1343         trailer->db_free_rec_len = cpu_to_le16(max_rec_len);
1344         if (add_to_free_list) {
1345                 trailer->db_free_next = dx_root->dr_free_blk;
1346                 dx_root->dr_free_blk = cpu_to_le64(leaf_bh->b_blocknr);
1347                 ocfs2_journal_dirty(handle, dx_root_bh);
1348         }
1349
1350         /* leaf_bh was journal_accessed for us in __ocfs2_delete_entry */
1351         ocfs2_journal_dirty(handle, leaf_bh);
1352
1353         le32_add_cpu(&dx_root->dr_num_entries, -1);
1354         ocfs2_journal_dirty(handle, dx_root_bh);
1355
1356         ocfs2_dx_list_remove_entry(entry_list, index);
1357
1358         if (!ocfs2_dx_root_inline(dx_root))
1359                 ocfs2_journal_dirty(handle, lookup->dl_dx_leaf_bh);
1360
1361 out:
1362         return ret;
1363 }
1364
1365 static inline int ocfs2_delete_entry_id(handle_t *handle,
1366                                         struct inode *dir,
1367                                         struct ocfs2_dir_entry *de_del,
1368                                         struct buffer_head *bh)
1369 {
1370         int ret;
1371         struct buffer_head *di_bh = NULL;
1372         struct ocfs2_dinode *di;
1373         struct ocfs2_inline_data *data;
1374
1375         ret = ocfs2_read_inode_block(dir, &di_bh);
1376         if (ret) {
1377                 mlog_errno(ret);
1378                 goto out;
1379         }
1380
1381         di = (struct ocfs2_dinode *)di_bh->b_data;
1382         data = &di->id2.i_data;
1383
1384         ret = __ocfs2_delete_entry(handle, dir, de_del, bh, data->id_data,
1385                                    i_size_read(dir));
1386
1387         brelse(di_bh);
1388 out:
1389         return ret;
1390 }
1391
1392 static inline int ocfs2_delete_entry_el(handle_t *handle,
1393                                         struct inode *dir,
1394                                         struct ocfs2_dir_entry *de_del,
1395                                         struct buffer_head *bh)
1396 {
1397         return __ocfs2_delete_entry(handle, dir, de_del, bh, bh->b_data,
1398                                     bh->b_size);
1399 }
1400
1401 /*
1402  * Delete a directory entry. Hide the details of directory
1403  * implementation from the caller.
1404  */
1405 int ocfs2_delete_entry(handle_t *handle,
1406                        struct inode *dir,
1407                        struct ocfs2_dir_lookup_result *res)
1408 {
1409         if (ocfs2_dir_indexed(dir))
1410                 return ocfs2_delete_entry_dx(handle, dir, res);
1411
1412         if (OCFS2_I(dir)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
1413                 return ocfs2_delete_entry_id(handle, dir, res->dl_entry,
1414                                              res->dl_leaf_bh);
1415
1416         return ocfs2_delete_entry_el(handle, dir, res->dl_entry,
1417                                      res->dl_leaf_bh);
1418 }
1419
1420 /*
1421  * Check whether 'de' has enough room to hold an entry of
1422  * 'new_rec_len' bytes.
1423  */
1424 static inline int ocfs2_dirent_would_fit(struct ocfs2_dir_entry *de,
1425                                          unsigned int new_rec_len)
1426 {
1427         unsigned int de_really_used;
1428
1429         /* Check whether this is an empty record with enough space */
1430         if (le64_to_cpu(de->inode) == 0 &&
1431             le16_to_cpu(de->rec_len) >= new_rec_len)
1432                 return 1;
1433
1434         /*
1435          * Record might have free space at the end which we can
1436          * use.
1437          */
1438         de_really_used = OCFS2_DIR_REC_LEN(de->name_len);
1439         if (le16_to_cpu(de->rec_len) >= (de_really_used + new_rec_len))
1440             return 1;
1441
1442         return 0;
1443 }
1444
1445 static void ocfs2_dx_dir_leaf_insert_tail(struct ocfs2_dx_leaf *dx_leaf,
1446                                           struct ocfs2_dx_entry *dx_new_entry)
1447 {
1448         int i;
1449
1450         i = le16_to_cpu(dx_leaf->dl_list.de_num_used);
1451         dx_leaf->dl_list.de_entries[i] = *dx_new_entry;
1452
1453         le16_add_cpu(&dx_leaf->dl_list.de_num_used, 1);
1454 }
1455
1456 static void ocfs2_dx_entry_list_insert(struct ocfs2_dx_entry_list *entry_list,
1457                                        struct ocfs2_dx_hinfo *hinfo,
1458                                        u64 dirent_blk)
1459 {
1460         int i;
1461         struct ocfs2_dx_entry *dx_entry;
1462
1463         i = le16_to_cpu(entry_list->de_num_used);
1464         dx_entry = &entry_list->de_entries[i];
1465
1466         memset(dx_entry, 0, sizeof(*dx_entry));
1467         dx_entry->dx_major_hash = cpu_to_le32(hinfo->major_hash);
1468         dx_entry->dx_minor_hash = cpu_to_le32(hinfo->minor_hash);
1469         dx_entry->dx_dirent_blk = cpu_to_le64(dirent_blk);
1470
1471         le16_add_cpu(&entry_list->de_num_used, 1);
1472 }
1473
1474 static int __ocfs2_dx_dir_leaf_insert(struct inode *dir, handle_t *handle,
1475                                       struct ocfs2_dx_hinfo *hinfo,
1476                                       u64 dirent_blk,
1477                                       struct buffer_head *dx_leaf_bh)
1478 {
1479         int ret;
1480         struct ocfs2_dx_leaf *dx_leaf;
1481
1482         ret = ocfs2_journal_access_dl(handle, INODE_CACHE(dir), dx_leaf_bh,
1483                                       OCFS2_JOURNAL_ACCESS_WRITE);
1484         if (ret) {
1485                 mlog_errno(ret);
1486                 goto out;
1487         }
1488
1489         dx_leaf = (struct ocfs2_dx_leaf *)dx_leaf_bh->b_data;
1490         ocfs2_dx_entry_list_insert(&dx_leaf->dl_list, hinfo, dirent_blk);
1491         ocfs2_journal_dirty(handle, dx_leaf_bh);
1492
1493 out:
1494         return ret;
1495 }
1496
1497 static void ocfs2_dx_inline_root_insert(struct inode *dir, handle_t *handle,
1498                                         struct ocfs2_dx_hinfo *hinfo,
1499                                         u64 dirent_blk,
1500                                         struct ocfs2_dx_root_block *dx_root)
1501 {
1502         ocfs2_dx_entry_list_insert(&dx_root->dr_entries, hinfo, dirent_blk);
1503 }
1504
1505 static int ocfs2_dx_dir_insert(struct inode *dir, handle_t *handle,
1506                                struct ocfs2_dir_lookup_result *lookup)
1507 {
1508         int ret = 0;
1509         struct ocfs2_dx_root_block *dx_root;
1510         struct buffer_head *dx_root_bh = lookup->dl_dx_root_bh;
1511
1512         ret = ocfs2_journal_access_dr(handle, INODE_CACHE(dir), dx_root_bh,
1513                                       OCFS2_JOURNAL_ACCESS_WRITE);
1514         if (ret) {
1515                 mlog_errno(ret);
1516                 goto out;
1517         }
1518
1519         dx_root = (struct ocfs2_dx_root_block *)lookup->dl_dx_root_bh->b_data;
1520         if (ocfs2_dx_root_inline(dx_root)) {
1521                 ocfs2_dx_inline_root_insert(dir, handle,
1522                                             &lookup->dl_hinfo,
1523                                             lookup->dl_leaf_bh->b_blocknr,
1524                                             dx_root);
1525         } else {
1526                 ret = __ocfs2_dx_dir_leaf_insert(dir, handle, &lookup->dl_hinfo,
1527                                                  lookup->dl_leaf_bh->b_blocknr,
1528                                                  lookup->dl_dx_leaf_bh);
1529                 if (ret)
1530                         goto out;
1531         }
1532
1533         le32_add_cpu(&dx_root->dr_num_entries, 1);
1534         ocfs2_journal_dirty(handle, dx_root_bh);
1535
1536 out:
1537         return ret;
1538 }
1539
1540 static void ocfs2_remove_block_from_free_list(struct inode *dir,
1541                                        handle_t *handle,
1542                                        struct ocfs2_dir_lookup_result *lookup)
1543 {
1544         struct ocfs2_dir_block_trailer *trailer, *prev;
1545         struct ocfs2_dx_root_block *dx_root;
1546         struct buffer_head *bh;
1547
1548         trailer = ocfs2_trailer_from_bh(lookup->dl_leaf_bh, dir->i_sb);
1549
1550         if (ocfs2_free_list_at_root(lookup)) {
1551                 bh = lookup->dl_dx_root_bh;
1552                 dx_root = (struct ocfs2_dx_root_block *)bh->b_data;
1553                 dx_root->dr_free_blk = trailer->db_free_next;
1554         } else {
1555                 bh = lookup->dl_prev_leaf_bh;
1556                 prev = ocfs2_trailer_from_bh(bh, dir->i_sb);
1557                 prev->db_free_next = trailer->db_free_next;
1558         }
1559
1560         trailer->db_free_rec_len = cpu_to_le16(0);
1561         trailer->db_free_next = cpu_to_le64(0);
1562
1563         ocfs2_journal_dirty(handle, bh);
1564         ocfs2_journal_dirty(handle, lookup->dl_leaf_bh);
1565 }
1566
1567 /*
1568  * This expects that a journal write has been reserved on
1569  * lookup->dl_prev_leaf_bh or lookup->dl_dx_root_bh
1570  */
1571 static void ocfs2_recalc_free_list(struct inode *dir, handle_t *handle,
1572                                    struct ocfs2_dir_lookup_result *lookup)
1573 {
1574         int max_rec_len;
1575         struct ocfs2_dir_block_trailer *trailer;
1576
1577         /* Walk dl_leaf_bh to figure out what the new free rec_len is. */
1578         max_rec_len = ocfs2_find_max_rec_len(dir->i_sb, lookup->dl_leaf_bh);
1579         if (max_rec_len) {
1580                 /*
1581                  * There's still room in this block, so no need to remove it
1582                  * from the free list. In this case, we just want to update
1583                  * the rec len accounting.
1584                  */
1585                 trailer = ocfs2_trailer_from_bh(lookup->dl_leaf_bh, dir->i_sb);
1586                 trailer->db_free_rec_len = cpu_to_le16(max_rec_len);
1587                 ocfs2_journal_dirty(handle, lookup->dl_leaf_bh);
1588         } else {
1589                 ocfs2_remove_block_from_free_list(dir, handle, lookup);
1590         }
1591 }
1592
1593 /* we don't always have a dentry for what we want to add, so people
1594  * like orphan dir can call this instead.
1595  *
1596  * The lookup context must have been filled from
1597  * ocfs2_prepare_dir_for_insert.
1598  */
1599 int __ocfs2_add_entry(handle_t *handle,
1600                       struct inode *dir,
1601                       const char *name, int namelen,
1602                       struct inode *inode, u64 blkno,
1603                       struct buffer_head *parent_fe_bh,
1604                       struct ocfs2_dir_lookup_result *lookup)
1605 {
1606         unsigned long offset;
1607         unsigned short rec_len;
1608         struct ocfs2_dir_entry *de, *de1;
1609         struct ocfs2_dinode *di = (struct ocfs2_dinode *)parent_fe_bh->b_data;
1610         struct super_block *sb = dir->i_sb;
1611         int retval;
1612         unsigned int size = sb->s_blocksize;
1613         struct buffer_head *insert_bh = lookup->dl_leaf_bh;
1614         char *data_start = insert_bh->b_data;
1615
1616         if (!namelen)
1617                 return -EINVAL;
1618
1619         if (ocfs2_dir_indexed(dir)) {
1620                 struct buffer_head *bh;
1621
1622                 /*
1623                  * An indexed dir may require that we update the free space
1624                  * list. Reserve a write to the previous node in the list so
1625                  * that we don't fail later.
1626                  *
1627                  * XXX: This can be either a dx_root_block, or an unindexed
1628                  * directory tree leaf block.
1629                  */
1630                 if (ocfs2_free_list_at_root(lookup)) {
1631                         bh = lookup->dl_dx_root_bh;
1632                         retval = ocfs2_journal_access_dr(handle,
1633                                                  INODE_CACHE(dir), bh,
1634                                                  OCFS2_JOURNAL_ACCESS_WRITE);
1635                 } else {
1636                         bh = lookup->dl_prev_leaf_bh;
1637                         retval = ocfs2_journal_access_db(handle,
1638                                                  INODE_CACHE(dir), bh,
1639                                                  OCFS2_JOURNAL_ACCESS_WRITE);
1640                 }
1641                 if (retval) {
1642                         mlog_errno(retval);
1643                         return retval;
1644                 }
1645         } else if (OCFS2_I(dir)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
1646                 data_start = di->id2.i_data.id_data;
1647                 size = i_size_read(dir);
1648
1649                 BUG_ON(insert_bh != parent_fe_bh);
1650         }
1651
1652         rec_len = OCFS2_DIR_REC_LEN(namelen);
1653         offset = 0;
1654         de = (struct ocfs2_dir_entry *) data_start;
1655         while (1) {
1656                 BUG_ON((char *)de >= (size + data_start));
1657
1658                 /* These checks should've already been passed by the
1659                  * prepare function, but I guess we can leave them
1660                  * here anyway. */
1661                 if (!ocfs2_check_dir_entry(dir, de, insert_bh, offset)) {
1662                         retval = -ENOENT;
1663                         goto bail;
1664                 }
1665                 if (ocfs2_match(namelen, name, de)) {
1666                         retval = -EEXIST;
1667                         goto bail;
1668                 }
1669
1670                 /* We're guaranteed that we should have space, so we
1671                  * can't possibly have hit the trailer...right? */
1672                 mlog_bug_on_msg(ocfs2_skip_dir_trailer(dir, de, offset, size),
1673                                 "Hit dir trailer trying to insert %.*s "
1674                                 "(namelen %d) into directory %llu.  "
1675                                 "offset is %lu, trailer offset is %d\n",
1676                                 namelen, name, namelen,
1677                                 (unsigned long long)parent_fe_bh->b_blocknr,
1678                                 offset, ocfs2_dir_trailer_blk_off(dir->i_sb));
1679
1680                 if (ocfs2_dirent_would_fit(de, rec_len)) {
1681                         dir->i_mtime = dir->i_ctime = current_time(dir);
1682                         retval = ocfs2_mark_inode_dirty(handle, dir, parent_fe_bh);
1683                         if (retval < 0) {
1684                                 mlog_errno(retval);
1685                                 goto bail;
1686                         }
1687
1688                         if (insert_bh == parent_fe_bh)
1689                                 retval = ocfs2_journal_access_di(handle,
1690                                                                  INODE_CACHE(dir),
1691                                                                  insert_bh,
1692                                                                  OCFS2_JOURNAL_ACCESS_WRITE);
1693                         else {
1694                                 retval = ocfs2_journal_access_db(handle,
1695                                                                  INODE_CACHE(dir),
1696                                                                  insert_bh,
1697                                               OCFS2_JOURNAL_ACCESS_WRITE);
1698
1699                                 if (!retval && ocfs2_dir_indexed(dir))
1700                                         retval = ocfs2_dx_dir_insert(dir,
1701                                                                 handle,
1702                                                                 lookup);
1703                         }
1704
1705                         if (retval) {
1706                                 mlog_errno(retval);
1707                                 goto bail;
1708                         }
1709
1710                         /* By now the buffer is marked for journaling */
1711                         offset += le16_to_cpu(de->rec_len);
1712                         if (le64_to_cpu(de->inode)) {
1713                                 de1 = (struct ocfs2_dir_entry *)((char *) de +
1714                                         OCFS2_DIR_REC_LEN(de->name_len));
1715                                 de1->rec_len =
1716                                         cpu_to_le16(le16_to_cpu(de->rec_len) -
1717                                         OCFS2_DIR_REC_LEN(de->name_len));
1718                                 de->rec_len = cpu_to_le16(OCFS2_DIR_REC_LEN(de->name_len));
1719                                 de = de1;
1720                         }
1721                         de->file_type = OCFS2_FT_UNKNOWN;
1722                         if (blkno) {
1723                                 de->inode = cpu_to_le64(blkno);
1724                                 ocfs2_set_de_type(de, inode->i_mode);
1725                         } else
1726                                 de->inode = 0;
1727                         de->name_len = namelen;
1728                         memcpy(de->name, name, namelen);
1729
1730                         if (ocfs2_dir_indexed(dir))
1731                                 ocfs2_recalc_free_list(dir, handle, lookup);
1732
1733                         inode_inc_iversion(dir);
1734                         ocfs2_journal_dirty(handle, insert_bh);
1735                         retval = 0;
1736                         goto bail;
1737                 }
1738
1739                 offset += le16_to_cpu(de->rec_len);
1740                 de = (struct ocfs2_dir_entry *) ((char *) de + le16_to_cpu(de->rec_len));
1741         }
1742
1743         /* when you think about it, the assert above should prevent us
1744          * from ever getting here. */
1745         retval = -ENOSPC;
1746 bail:
1747         if (retval)
1748                 mlog_errno(retval);
1749
1750         return retval;
1751 }
1752
1753 static int ocfs2_dir_foreach_blk_id(struct inode *inode,
1754                                     u64 *f_version,
1755                                     struct dir_context *ctx)
1756 {
1757         int ret, i;
1758         unsigned long offset = ctx->pos;
1759         struct buffer_head *di_bh = NULL;
1760         struct ocfs2_dinode *di;
1761         struct ocfs2_inline_data *data;
1762         struct ocfs2_dir_entry *de;
1763
1764         ret = ocfs2_read_inode_block(inode, &di_bh);
1765         if (ret) {
1766                 mlog(ML_ERROR, "Unable to read inode block for dir %llu\n",
1767                      (unsigned long long)OCFS2_I(inode)->ip_blkno);
1768                 goto out;
1769         }
1770
1771         di = (struct ocfs2_dinode *)di_bh->b_data;
1772         data = &di->id2.i_data;
1773
1774         while (ctx->pos < i_size_read(inode)) {
1775                 /* If the dir block has changed since the last call to
1776                  * readdir(2), then we might be pointing to an invalid
1777                  * dirent right now.  Scan from the start of the block
1778                  * to make sure. */
1779                 if (!inode_eq_iversion(inode, *f_version)) {
1780                         for (i = 0; i < i_size_read(inode) && i < offset; ) {
1781                                 de = (struct ocfs2_dir_entry *)
1782                                         (data->id_data + i);
1783                                 /* It's too expensive to do a full
1784                                  * dirent test each time round this
1785                                  * loop, but we do have to test at
1786                                  * least that it is non-zero.  A
1787                                  * failure will be detected in the
1788                                  * dirent test below. */
1789                                 if (le16_to_cpu(de->rec_len) <
1790                                     OCFS2_DIR_REC_LEN(1))
1791                                         break;
1792                                 i += le16_to_cpu(de->rec_len);
1793                         }
1794                         ctx->pos = offset = i;
1795                         *f_version = inode_query_iversion(inode);
1796                 }
1797
1798                 de = (struct ocfs2_dir_entry *) (data->id_data + ctx->pos);
1799                 if (!ocfs2_check_dir_entry(inode, de, di_bh, ctx->pos)) {
1800                         /* On error, skip the f_pos to the end. */
1801                         ctx->pos = i_size_read(inode);
1802                         break;
1803                 }
1804                 offset += le16_to_cpu(de->rec_len);
1805                 if (le64_to_cpu(de->inode)) {
1806                         unsigned char d_type = DT_UNKNOWN;
1807
1808                         if (de->file_type < OCFS2_FT_MAX)
1809                                 d_type = ocfs2_filetype_table[de->file_type];
1810
1811                         if (!dir_emit(ctx, de->name, de->name_len,
1812                                       le64_to_cpu(de->inode), d_type))
1813                                 goto out;
1814                 }
1815                 ctx->pos += le16_to_cpu(de->rec_len);
1816         }
1817 out:
1818         brelse(di_bh);
1819         return 0;
1820 }
1821
1822 /*
1823  * NOTE: This function can be called against unindexed directories,
1824  * and indexed ones.
1825  */
1826 static int ocfs2_dir_foreach_blk_el(struct inode *inode,
1827                                     u64 *f_version,
1828                                     struct dir_context *ctx,
1829                                     bool persist)
1830 {
1831         unsigned long offset, blk, last_ra_blk = 0;
1832         int i;
1833         struct buffer_head * bh, * tmp;
1834         struct ocfs2_dir_entry * de;
1835         struct super_block * sb = inode->i_sb;
1836         unsigned int ra_sectors = 16;
1837         int stored = 0;
1838
1839         bh = NULL;
1840
1841         offset = ctx->pos & (sb->s_blocksize - 1);
1842
1843         while (ctx->pos < i_size_read(inode)) {
1844                 blk = ctx->pos >> sb->s_blocksize_bits;
1845                 if (ocfs2_read_dir_block(inode, blk, &bh, 0)) {
1846                         /* Skip the corrupt dirblock and keep trying */
1847                         ctx->pos += sb->s_blocksize - offset;
1848                         continue;
1849                 }
1850
1851                 /* The idea here is to begin with 8k read-ahead and to stay
1852                  * 4k ahead of our current position.
1853                  *
1854                  * TODO: Use the pagecache for this. We just need to
1855                  * make sure it's cluster-safe... */
1856                 if (!last_ra_blk
1857                     || (((last_ra_blk - blk) << 9) <= (ra_sectors / 2))) {
1858                         for (i = ra_sectors >> (sb->s_blocksize_bits - 9);
1859                              i > 0; i--) {
1860                                 tmp = NULL;
1861                                 if (!ocfs2_read_dir_block(inode, ++blk, &tmp,
1862                                                           OCFS2_BH_READAHEAD))
1863                                         brelse(tmp);
1864                         }
1865                         last_ra_blk = blk;
1866                         ra_sectors = 8;
1867                 }
1868
1869                 /* If the dir block has changed since the last call to
1870                  * readdir(2), then we might be pointing to an invalid
1871                  * dirent right now.  Scan from the start of the block
1872                  * to make sure. */
1873                 if (!inode_eq_iversion(inode, *f_version)) {
1874                         for (i = 0; i < sb->s_blocksize && i < offset; ) {
1875                                 de = (struct ocfs2_dir_entry *) (bh->b_data + i);
1876                                 /* It's too expensive to do a full
1877                                  * dirent test each time round this
1878                                  * loop, but we do have to test at
1879                                  * least that it is non-zero.  A
1880                                  * failure will be detected in the
1881                                  * dirent test below. */
1882                                 if (le16_to_cpu(de->rec_len) <
1883                                     OCFS2_DIR_REC_LEN(1))
1884                                         break;
1885                                 i += le16_to_cpu(de->rec_len);
1886                         }
1887                         offset = i;
1888                         ctx->pos = (ctx->pos & ~(sb->s_blocksize - 1))
1889                                 | offset;
1890                         *f_version = inode_query_iversion(inode);
1891                 }
1892
1893                 while (ctx->pos < i_size_read(inode)
1894                        && offset < sb->s_blocksize) {
1895                         de = (struct ocfs2_dir_entry *) (bh->b_data + offset);
1896                         if (!ocfs2_check_dir_entry(inode, de, bh, offset)) {
1897                                 /* On error, skip the f_pos to the
1898                                    next block. */
1899                                 ctx->pos = (ctx->pos | (sb->s_blocksize - 1)) + 1;
1900                                 break;
1901                         }
1902                         if (le64_to_cpu(de->inode)) {
1903                                 unsigned char d_type = DT_UNKNOWN;
1904
1905                                 if (de->file_type < OCFS2_FT_MAX)
1906                                         d_type = ocfs2_filetype_table[de->file_type];
1907                                 if (!dir_emit(ctx, de->name,
1908                                                 de->name_len,
1909                                                 le64_to_cpu(de->inode),
1910                                                 d_type)) {
1911                                         brelse(bh);
1912                                         return 0;
1913                                 }
1914                                 stored++;
1915                         }
1916                         offset += le16_to_cpu(de->rec_len);
1917                         ctx->pos += le16_to_cpu(de->rec_len);
1918                 }
1919                 offset = 0;
1920                 brelse(bh);
1921                 bh = NULL;
1922                 if (!persist && stored)
1923                         break;
1924         }
1925         return 0;
1926 }
1927
1928 static int ocfs2_dir_foreach_blk(struct inode *inode, u64 *f_version,
1929                                  struct dir_context *ctx,
1930                                  bool persist)
1931 {
1932         if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
1933                 return ocfs2_dir_foreach_blk_id(inode, f_version, ctx);
1934         return ocfs2_dir_foreach_blk_el(inode, f_version, ctx, persist);
1935 }
1936
1937 /*
1938  * This is intended to be called from inside other kernel functions,
1939  * so we fake some arguments.
1940  */
1941 int ocfs2_dir_foreach(struct inode *inode, struct dir_context *ctx)
1942 {
1943         u64 version = inode_query_iversion(inode);
1944         ocfs2_dir_foreach_blk(inode, &version, ctx, true);
1945         return 0;
1946 }
1947
1948 /*
1949  * ocfs2_readdir()
1950  *
1951  */
1952 int ocfs2_readdir(struct file *file, struct dir_context *ctx)
1953 {
1954         int error = 0;
1955         struct inode *inode = file_inode(file);
1956         int lock_level = 0;
1957
1958         trace_ocfs2_readdir((unsigned long long)OCFS2_I(inode)->ip_blkno);
1959
1960         error = ocfs2_inode_lock_atime(inode, file->f_path.mnt, &lock_level, 1);
1961         if (lock_level && error >= 0) {
1962                 /* We release EX lock which used to update atime
1963                  * and get PR lock again to reduce contention
1964                  * on commonly accessed directories. */
1965                 ocfs2_inode_unlock(inode, 1);
1966                 lock_level = 0;
1967                 error = ocfs2_inode_lock(inode, NULL, 0);
1968         }
1969         if (error < 0) {
1970                 if (error != -ENOENT)
1971                         mlog_errno(error);
1972                 /* we haven't got any yet, so propagate the error. */
1973                 goto bail_nolock;
1974         }
1975
1976         error = ocfs2_dir_foreach_blk(inode, &file->f_version, ctx, false);
1977
1978         ocfs2_inode_unlock(inode, lock_level);
1979         if (error)
1980                 mlog_errno(error);
1981
1982 bail_nolock:
1983
1984         return error;
1985 }
1986
1987 /*
1988  * NOTE: this should always be called with parent dir i_mutex taken.
1989  */
1990 int ocfs2_find_files_on_disk(const char *name,
1991                              int namelen,
1992                              u64 *blkno,
1993                              struct inode *inode,
1994                              struct ocfs2_dir_lookup_result *lookup)
1995 {
1996         int status = -ENOENT;
1997
1998         trace_ocfs2_find_files_on_disk(namelen, name, blkno,
1999                                 (unsigned long long)OCFS2_I(inode)->ip_blkno);
2000
2001         status = ocfs2_find_entry(name, namelen, inode, lookup);
2002         if (status)
2003                 goto leave;
2004
2005         *blkno = le64_to_cpu(lookup->dl_entry->inode);
2006
2007         status = 0;
2008 leave:
2009
2010         return status;
2011 }
2012
2013 /*
2014  * Convenience function for callers which just want the block number
2015  * mapped to a name and don't require the full dirent info, etc.
2016  */
2017 int ocfs2_lookup_ino_from_name(struct inode *dir, const char *name,
2018                                int namelen, u64 *blkno)
2019 {
2020         int ret;
2021         struct ocfs2_dir_lookup_result lookup = { NULL, };
2022
2023         ret = ocfs2_find_files_on_disk(name, namelen, blkno, dir, &lookup);
2024         ocfs2_free_dir_lookup_result(&lookup);
2025
2026         return ret;
2027 }
2028
2029 /* Check for a name within a directory.
2030  *
2031  * Return 0 if the name does not exist
2032  * Return -EEXIST if the directory contains the name
2033  *
2034  * Callers should have i_mutex + a cluster lock on dir
2035  */
2036 int ocfs2_check_dir_for_entry(struct inode *dir,
2037                               const char *name,
2038                               int namelen)
2039 {
2040         int ret = 0;
2041         struct ocfs2_dir_lookup_result lookup = { NULL, };
2042
2043         trace_ocfs2_check_dir_for_entry(
2044                 (unsigned long long)OCFS2_I(dir)->ip_blkno, namelen, name);
2045
2046         if (ocfs2_find_entry(name, namelen, dir, &lookup) == 0) {
2047                 ret = -EEXIST;
2048                 mlog_errno(ret);
2049         }
2050
2051         ocfs2_free_dir_lookup_result(&lookup);
2052
2053         return ret;
2054 }
2055
2056 struct ocfs2_empty_dir_priv {
2057         struct dir_context ctx;
2058         unsigned seen_dot;
2059         unsigned seen_dot_dot;
2060         unsigned seen_other;
2061         unsigned dx_dir;
2062 };
2063 static int ocfs2_empty_dir_filldir(struct dir_context *ctx, const char *name,
2064                                    int name_len, loff_t pos, u64 ino,
2065                                    unsigned type)
2066 {
2067         struct ocfs2_empty_dir_priv *p =
2068                 container_of(ctx, struct ocfs2_empty_dir_priv, ctx);
2069
2070         /*
2071          * Check the positions of "." and ".." records to be sure
2072          * they're in the correct place.
2073          *
2074          * Indexed directories don't need to proceed past the first
2075          * two entries, so we end the scan after seeing '..'. Despite
2076          * that, we allow the scan to proceed In the event that we
2077          * have a corrupted indexed directory (no dot or dot dot
2078          * entries). This allows us to double check for existing
2079          * entries which might not have been found in the index.
2080          */
2081         if (name_len == 1 && !strncmp(".", name, 1) && pos == 0) {
2082                 p->seen_dot = 1;
2083                 return 0;
2084         }
2085
2086         if (name_len == 2 && !strncmp("..", name, 2) &&
2087             pos == OCFS2_DIR_REC_LEN(1)) {
2088                 p->seen_dot_dot = 1;
2089
2090                 if (p->dx_dir && p->seen_dot)
2091                         return 1;
2092
2093                 return 0;
2094         }
2095
2096         p->seen_other = 1;
2097         return 1;
2098 }
2099
2100 static int ocfs2_empty_dir_dx(struct inode *inode,
2101                               struct ocfs2_empty_dir_priv *priv)
2102 {
2103         int ret;
2104         struct buffer_head *di_bh = NULL;
2105         struct buffer_head *dx_root_bh = NULL;
2106         struct ocfs2_dinode *di;
2107         struct ocfs2_dx_root_block *dx_root;
2108
2109         priv->dx_dir = 1;
2110
2111         ret = ocfs2_read_inode_block(inode, &di_bh);
2112         if (ret) {
2113                 mlog_errno(ret);
2114                 goto out;
2115         }
2116         di = (struct ocfs2_dinode *)di_bh->b_data;
2117
2118         ret = ocfs2_read_dx_root(inode, di, &dx_root_bh);
2119         if (ret) {
2120                 mlog_errno(ret);
2121                 goto out;
2122         }
2123         dx_root = (struct ocfs2_dx_root_block *)dx_root_bh->b_data;
2124
2125         if (le32_to_cpu(dx_root->dr_num_entries) != 2)
2126                 priv->seen_other = 1;
2127
2128 out:
2129         brelse(di_bh);
2130         brelse(dx_root_bh);
2131         return ret;
2132 }
2133
2134 /*
2135  * routine to check that the specified directory is empty (for rmdir)
2136  *
2137  * Returns 1 if dir is empty, zero otherwise.
2138  *
2139  * XXX: This is a performance problem for unindexed directories.
2140  */
2141 int ocfs2_empty_dir(struct inode *inode)
2142 {
2143         int ret;
2144         struct ocfs2_empty_dir_priv priv = {
2145                 .ctx.actor = ocfs2_empty_dir_filldir,
2146         };
2147
2148         if (ocfs2_dir_indexed(inode)) {
2149                 ret = ocfs2_empty_dir_dx(inode, &priv);
2150                 if (ret)
2151                         mlog_errno(ret);
2152                 /*
2153                  * We still run ocfs2_dir_foreach to get the checks
2154                  * for "." and "..".
2155                  */
2156         }
2157
2158         ret = ocfs2_dir_foreach(inode, &priv.ctx);
2159         if (ret)
2160                 mlog_errno(ret);
2161
2162         if (!priv.seen_dot || !priv.seen_dot_dot) {
2163                 mlog(ML_ERROR, "bad directory (dir #%llu) - no `.' or `..'\n",
2164                      (unsigned long long)OCFS2_I(inode)->ip_blkno);
2165                 /*
2166                  * XXX: Is it really safe to allow an unlink to continue?
2167                  */
2168                 return 1;
2169         }
2170
2171         return !priv.seen_other;
2172 }
2173
2174 /*
2175  * Fills "." and ".." dirents in a new directory block. Returns dirent for
2176  * "..", which might be used during creation of a directory with a trailing
2177  * header. It is otherwise safe to ignore the return code.
2178  */
2179 static struct ocfs2_dir_entry *ocfs2_fill_initial_dirents(struct inode *inode,
2180                                                           struct inode *parent,
2181                                                           char *start,
2182                                                           unsigned int size)
2183 {
2184         struct ocfs2_dir_entry *de = (struct ocfs2_dir_entry *)start;
2185
2186         de->inode = cpu_to_le64(OCFS2_I(inode)->ip_blkno);
2187         de->name_len = 1;
2188         de->rec_len =
2189                 cpu_to_le16(OCFS2_DIR_REC_LEN(de->name_len));
2190         strcpy(de->name, ".");
2191         ocfs2_set_de_type(de, S_IFDIR);
2192
2193         de = (struct ocfs2_dir_entry *) ((char *)de + le16_to_cpu(de->rec_len));
2194         de->inode = cpu_to_le64(OCFS2_I(parent)->ip_blkno);
2195         de->rec_len = cpu_to_le16(size - OCFS2_DIR_REC_LEN(1));
2196         de->name_len = 2;
2197         strcpy(de->name, "..");
2198         ocfs2_set_de_type(de, S_IFDIR);
2199
2200         return de;
2201 }
2202
2203 /*
2204  * This works together with code in ocfs2_mknod_locked() which sets
2205  * the inline-data flag and initializes the inline-data section.
2206  */
2207 static int ocfs2_fill_new_dir_id(struct ocfs2_super *osb,
2208                                  handle_t *handle,
2209                                  struct inode *parent,
2210                                  struct inode *inode,
2211                                  struct buffer_head *di_bh)
2212 {
2213         int ret;
2214         struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
2215         struct ocfs2_inline_data *data = &di->id2.i_data;
2216         unsigned int size = le16_to_cpu(data->id_count);
2217
2218         ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh,
2219                                       OCFS2_JOURNAL_ACCESS_WRITE);
2220         if (ret) {
2221                 mlog_errno(ret);
2222                 goto out;
2223         }
2224
2225         ocfs2_fill_initial_dirents(inode, parent, data->id_data, size);
2226         ocfs2_journal_dirty(handle, di_bh);
2227
2228         i_size_write(inode, size);
2229         set_nlink(inode, 2);
2230         inode->i_blocks = ocfs2_inode_sector_count(inode);
2231
2232         ret = ocfs2_mark_inode_dirty(handle, inode, di_bh);
2233         if (ret < 0)
2234                 mlog_errno(ret);
2235
2236 out:
2237         return ret;
2238 }
2239
2240 static int ocfs2_fill_new_dir_el(struct ocfs2_super *osb,
2241                                  handle_t *handle,
2242                                  struct inode *parent,
2243                                  struct inode *inode,
2244                                  struct buffer_head *fe_bh,
2245                                  struct ocfs2_alloc_context *data_ac,
2246                                  struct buffer_head **ret_new_bh)
2247 {
2248         int status;
2249         unsigned int size = osb->sb->s_blocksize;
2250         struct buffer_head *new_bh = NULL;
2251         struct ocfs2_dir_entry *de;
2252
2253         if (ocfs2_new_dir_wants_trailer(inode))
2254                 size = ocfs2_dir_trailer_blk_off(parent->i_sb);
2255
2256         status = ocfs2_do_extend_dir(osb->sb, handle, inode, fe_bh,
2257                                      data_ac, NULL, &new_bh);
2258         if (status < 0) {
2259                 mlog_errno(status);
2260                 goto bail;
2261         }
2262
2263         ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode), new_bh);
2264
2265         status = ocfs2_journal_access_db(handle, INODE_CACHE(inode), new_bh,
2266                                          OCFS2_JOURNAL_ACCESS_CREATE);
2267         if (status < 0) {
2268                 mlog_errno(status);
2269                 goto bail;
2270         }
2271         memset(new_bh->b_data, 0, osb->sb->s_blocksize);
2272
2273         de = ocfs2_fill_initial_dirents(inode, parent, new_bh->b_data, size);
2274         if (ocfs2_new_dir_wants_trailer(inode)) {
2275                 int size = le16_to_cpu(de->rec_len);
2276
2277                 /*
2278                  * Figure out the size of the hole left over after
2279                  * insertion of '.' and '..'. The trailer wants this
2280                  * information.
2281                  */
2282                 size -= OCFS2_DIR_REC_LEN(2);
2283                 size -= sizeof(struct ocfs2_dir_block_trailer);
2284
2285                 ocfs2_init_dir_trailer(inode, new_bh, size);
2286         }
2287
2288         ocfs2_journal_dirty(handle, new_bh);
2289
2290         i_size_write(inode, inode->i_sb->s_blocksize);
2291         set_nlink(inode, 2);
2292         inode->i_blocks = ocfs2_inode_sector_count(inode);
2293         status = ocfs2_mark_inode_dirty(handle, inode, fe_bh);
2294         if (status < 0) {
2295                 mlog_errno(status);
2296                 goto bail;
2297         }
2298
2299         status = 0;
2300         if (ret_new_bh) {
2301                 *ret_new_bh = new_bh;
2302                 new_bh = NULL;
2303         }
2304 bail:
2305         brelse(new_bh);
2306
2307         return status;
2308 }
2309
2310 static int ocfs2_dx_dir_attach_index(struct ocfs2_super *osb,
2311                                      handle_t *handle, struct inode *dir,
2312                                      struct buffer_head *di_bh,
2313                                      struct buffer_head *dirdata_bh,
2314                                      struct ocfs2_alloc_context *meta_ac,
2315                                      int dx_inline, u32 num_entries,
2316                                      struct buffer_head **ret_dx_root_bh)
2317 {
2318         int ret;
2319         struct ocfs2_dinode *di = (struct ocfs2_dinode *) di_bh->b_data;
2320         u16 dr_suballoc_bit;
2321         u64 suballoc_loc, dr_blkno;
2322         unsigned int num_bits;
2323         struct buffer_head *dx_root_bh = NULL;
2324         struct ocfs2_dx_root_block *dx_root;
2325         struct ocfs2_dir_block_trailer *trailer =
2326                 ocfs2_trailer_from_bh(dirdata_bh, dir->i_sb);
2327
2328         ret = ocfs2_claim_metadata(handle, meta_ac, 1, &suballoc_loc,
2329                                    &dr_suballoc_bit, &num_bits, &dr_blkno);
2330         if (ret) {
2331                 mlog_errno(ret);
2332                 goto out;
2333         }
2334
2335         trace_ocfs2_dx_dir_attach_index(
2336                                 (unsigned long long)OCFS2_I(dir)->ip_blkno,
2337                                 (unsigned long long)dr_blkno);
2338
2339         dx_root_bh = sb_getblk(osb->sb, dr_blkno);
2340         if (dx_root_bh == NULL) {
2341                 ret = -ENOMEM;
2342                 goto out;
2343         }
2344         ocfs2_set_new_buffer_uptodate(INODE_CACHE(dir), dx_root_bh);
2345
2346         ret = ocfs2_journal_access_dr(handle, INODE_CACHE(dir), dx_root_bh,
2347                                       OCFS2_JOURNAL_ACCESS_CREATE);
2348         if (ret < 0) {
2349                 mlog_errno(ret);
2350                 goto out;
2351         }
2352
2353         dx_root = (struct ocfs2_dx_root_block *)dx_root_bh->b_data;
2354         memset(dx_root, 0, osb->sb->s_blocksize);
2355         strcpy(dx_root->dr_signature, OCFS2_DX_ROOT_SIGNATURE);
2356         dx_root->dr_suballoc_slot = cpu_to_le16(meta_ac->ac_alloc_slot);
2357         dx_root->dr_suballoc_loc = cpu_to_le64(suballoc_loc);
2358         dx_root->dr_suballoc_bit = cpu_to_le16(dr_suballoc_bit);
2359         dx_root->dr_fs_generation = cpu_to_le32(osb->fs_generation);
2360         dx_root->dr_blkno = cpu_to_le64(dr_blkno);
2361         dx_root->dr_dir_blkno = cpu_to_le64(OCFS2_I(dir)->ip_blkno);
2362         dx_root->dr_num_entries = cpu_to_le32(num_entries);
2363         if (le16_to_cpu(trailer->db_free_rec_len))
2364                 dx_root->dr_free_blk = cpu_to_le64(dirdata_bh->b_blocknr);
2365         else
2366                 dx_root->dr_free_blk = cpu_to_le64(0);
2367
2368         if (dx_inline) {
2369                 dx_root->dr_flags |= OCFS2_DX_FLAG_INLINE;
2370                 dx_root->dr_entries.de_count =
2371                         cpu_to_le16(ocfs2_dx_entries_per_root(osb->sb));
2372         } else {
2373                 dx_root->dr_list.l_count =
2374                         cpu_to_le16(ocfs2_extent_recs_per_dx_root(osb->sb));
2375         }
2376         ocfs2_journal_dirty(handle, dx_root_bh);
2377
2378         ret = ocfs2_journal_access_di(handle, INODE_CACHE(dir), di_bh,
2379                                       OCFS2_JOURNAL_ACCESS_CREATE);
2380         if (ret) {
2381                 mlog_errno(ret);
2382                 goto out;
2383         }
2384
2385         di->i_dx_root = cpu_to_le64(dr_blkno);
2386
2387         spin_lock(&OCFS2_I(dir)->ip_lock);
2388         OCFS2_I(dir)->ip_dyn_features |= OCFS2_INDEXED_DIR_FL;
2389         di->i_dyn_features = cpu_to_le16(OCFS2_I(dir)->ip_dyn_features);
2390         spin_unlock(&OCFS2_I(dir)->ip_lock);
2391
2392         ocfs2_journal_dirty(handle, di_bh);
2393
2394         *ret_dx_root_bh = dx_root_bh;
2395         dx_root_bh = NULL;
2396
2397 out:
2398         brelse(dx_root_bh);
2399         return ret;
2400 }
2401
2402 static int ocfs2_dx_dir_format_cluster(struct ocfs2_super *osb,
2403                                        handle_t *handle, struct inode *dir,
2404                                        struct buffer_head **dx_leaves,
2405                                        int num_dx_leaves, u64 start_blk)
2406 {
2407         int ret, i;
2408         struct ocfs2_dx_leaf *dx_leaf;
2409         struct buffer_head *bh;
2410
2411         for (i = 0; i < num_dx_leaves; i++) {
2412                 bh = sb_getblk(osb->sb, start_blk + i);
2413                 if (bh == NULL) {
2414                         ret = -ENOMEM;
2415                         goto out;
2416                 }
2417                 dx_leaves[i] = bh;
2418
2419                 ocfs2_set_new_buffer_uptodate(INODE_CACHE(dir), bh);
2420
2421                 ret = ocfs2_journal_access_dl(handle, INODE_CACHE(dir), bh,
2422                                               OCFS2_JOURNAL_ACCESS_CREATE);
2423                 if (ret < 0) {
2424                         mlog_errno(ret);
2425                         goto out;
2426                 }
2427
2428                 dx_leaf = (struct ocfs2_dx_leaf *) bh->b_data;
2429
2430                 memset(dx_leaf, 0, osb->sb->s_blocksize);
2431                 strcpy(dx_leaf->dl_signature, OCFS2_DX_LEAF_SIGNATURE);
2432                 dx_leaf->dl_fs_generation = cpu_to_le32(osb->fs_generation);
2433                 dx_leaf->dl_blkno = cpu_to_le64(bh->b_blocknr);
2434                 dx_leaf->dl_list.de_count =
2435                         cpu_to_le16(ocfs2_dx_entries_per_leaf(osb->sb));
2436
2437                 trace_ocfs2_dx_dir_format_cluster(
2438                                 (unsigned long long)OCFS2_I(dir)->ip_blkno,
2439                                 (unsigned long long)bh->b_blocknr,
2440                                 le16_to_cpu(dx_leaf->dl_list.de_count));
2441
2442                 ocfs2_journal_dirty(handle, bh);
2443         }
2444
2445         ret = 0;
2446 out:
2447         return ret;
2448 }
2449
2450 /*
2451  * Allocates and formats a new cluster for use in an indexed dir
2452  * leaf. This version will not do the extent insert, so that it can be
2453  * used by operations which need careful ordering.
2454  */
2455 static int __ocfs2_dx_dir_new_cluster(struct inode *dir,
2456                                       u32 cpos, handle_t *handle,
2457                                       struct ocfs2_alloc_context *data_ac,
2458                                       struct buffer_head **dx_leaves,
2459                                       int num_dx_leaves, u64 *ret_phys_blkno)
2460 {
2461         int ret;
2462         u32 phys, num;
2463         u64 phys_blkno;
2464         struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
2465
2466         /*
2467          * XXX: For create, this should claim cluster for the index
2468          * *before* the unindexed insert so that we have a better
2469          * chance of contiguousness as the directory grows in number
2470          * of entries.
2471          */
2472         ret = __ocfs2_claim_clusters(handle, data_ac, 1, 1, &phys, &num);
2473         if (ret) {
2474                 mlog_errno(ret);
2475                 goto out;
2476         }
2477
2478         /*
2479          * Format the new cluster first. That way, we're inserting
2480          * valid data.
2481          */
2482         phys_blkno = ocfs2_clusters_to_blocks(osb->sb, phys);
2483         ret = ocfs2_dx_dir_format_cluster(osb, handle, dir, dx_leaves,
2484                                           num_dx_leaves, phys_blkno);
2485         if (ret) {
2486                 mlog_errno(ret);
2487                 goto out;
2488         }
2489
2490         *ret_phys_blkno = phys_blkno;
2491 out:
2492         return ret;
2493 }
2494
2495 static int ocfs2_dx_dir_new_cluster(struct inode *dir,
2496                                     struct ocfs2_extent_tree *et,
2497                                     u32 cpos, handle_t *handle,
2498                                     struct ocfs2_alloc_context *data_ac,
2499                                     struct ocfs2_alloc_context *meta_ac,
2500                                     struct buffer_head **dx_leaves,
2501                                     int num_dx_leaves)
2502 {
2503         int ret;
2504         u64 phys_blkno;
2505
2506         ret = __ocfs2_dx_dir_new_cluster(dir, cpos, handle, data_ac, dx_leaves,
2507                                          num_dx_leaves, &phys_blkno);
2508         if (ret) {
2509                 mlog_errno(ret);
2510                 goto out;
2511         }
2512
2513         ret = ocfs2_insert_extent(handle, et, cpos, phys_blkno, 1, 0,
2514                                   meta_ac);
2515         if (ret)
2516                 mlog_errno(ret);
2517 out:
2518         return ret;
2519 }
2520
2521 static struct buffer_head **ocfs2_dx_dir_kmalloc_leaves(struct super_block *sb,
2522                                                         int *ret_num_leaves)
2523 {
2524         int num_dx_leaves = ocfs2_clusters_to_blocks(sb, 1);
2525         struct buffer_head **dx_leaves;
2526
2527         dx_leaves = kcalloc(num_dx_leaves, sizeof(struct buffer_head *),
2528                             GFP_NOFS);
2529         if (dx_leaves && ret_num_leaves)
2530                 *ret_num_leaves = num_dx_leaves;
2531
2532         return dx_leaves;
2533 }
2534
2535 static int ocfs2_fill_new_dir_dx(struct ocfs2_super *osb,
2536                                  handle_t *handle,
2537                                  struct inode *parent,
2538                                  struct inode *inode,
2539                                  struct buffer_head *di_bh,
2540                                  struct ocfs2_alloc_context *data_ac,
2541                                  struct ocfs2_alloc_context *meta_ac)
2542 {
2543         int ret;
2544         struct buffer_head *leaf_bh = NULL;
2545         struct buffer_head *dx_root_bh = NULL;
2546         struct ocfs2_dx_hinfo hinfo;
2547         struct ocfs2_dx_root_block *dx_root;
2548         struct ocfs2_dx_entry_list *entry_list;
2549
2550         /*
2551          * Our strategy is to create the directory as though it were
2552          * unindexed, then add the index block. This works with very
2553          * little complication since the state of a new directory is a
2554          * very well known quantity.
2555          *
2556          * Essentially, we have two dirents ("." and ".."), in the 1st
2557          * block which need indexing. These are easily inserted into
2558          * the index block.
2559          */
2560
2561         ret = ocfs2_fill_new_dir_el(osb, handle, parent, inode, di_bh,
2562                                     data_ac, &leaf_bh);
2563         if (ret) {
2564                 mlog_errno(ret);
2565                 goto out;
2566         }
2567
2568         ret = ocfs2_dx_dir_attach_index(osb, handle, inode, di_bh, leaf_bh,
2569                                         meta_ac, 1, 2, &dx_root_bh);
2570         if (ret) {
2571                 mlog_errno(ret);
2572                 goto out;
2573         }
2574         dx_root = (struct ocfs2_dx_root_block *)dx_root_bh->b_data;
2575         entry_list = &dx_root->dr_entries;
2576
2577         /* Buffer has been journaled for us by ocfs2_dx_dir_attach_index */
2578         ocfs2_dx_dir_name_hash(inode, ".", 1, &hinfo);
2579         ocfs2_dx_entry_list_insert(entry_list, &hinfo, leaf_bh->b_blocknr);
2580
2581         ocfs2_dx_dir_name_hash(inode, "..", 2, &hinfo);
2582         ocfs2_dx_entry_list_insert(entry_list, &hinfo, leaf_bh->b_blocknr);
2583
2584 out:
2585         brelse(dx_root_bh);
2586         brelse(leaf_bh);
2587         return ret;
2588 }
2589
2590 int ocfs2_fill_new_dir(struct ocfs2_super *osb,
2591                        handle_t *handle,
2592                        struct inode *parent,
2593                        struct inode *inode,
2594                        struct buffer_head *fe_bh,
2595                        struct ocfs2_alloc_context *data_ac,
2596                        struct ocfs2_alloc_context *meta_ac)
2597
2598 {
2599         BUG_ON(!ocfs2_supports_inline_data(osb) && data_ac == NULL);
2600
2601         if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
2602                 return ocfs2_fill_new_dir_id(osb, handle, parent, inode, fe_bh);
2603
2604         if (ocfs2_supports_indexed_dirs(osb))
2605                 return ocfs2_fill_new_dir_dx(osb, handle, parent, inode, fe_bh,
2606                                              data_ac, meta_ac);
2607
2608         return ocfs2_fill_new_dir_el(osb, handle, parent, inode, fe_bh,
2609                                      data_ac, NULL);
2610 }
2611
2612 static int ocfs2_dx_dir_index_block(struct inode *dir,
2613                                     handle_t *handle,
2614                                     struct buffer_head **dx_leaves,
2615                                     int num_dx_leaves,
2616                                     u32 *num_dx_entries,
2617                                     struct buffer_head *dirent_bh)
2618 {
2619         int ret = 0, namelen, i;
2620         char *de_buf, *limit;
2621         struct ocfs2_dir_entry *de;
2622         struct buffer_head *dx_leaf_bh;
2623         struct ocfs2_dx_hinfo hinfo;
2624         u64 dirent_blk = dirent_bh->b_blocknr;
2625
2626         de_buf = dirent_bh->b_data;
2627         limit = de_buf + dir->i_sb->s_blocksize;
2628
2629         while (de_buf < limit) {
2630                 de = (struct ocfs2_dir_entry *)de_buf;
2631
2632                 namelen = de->name_len;
2633                 if (!namelen || !de->inode)
2634                         goto inc;
2635
2636                 ocfs2_dx_dir_name_hash(dir, de->name, namelen, &hinfo);
2637
2638                 i = ocfs2_dx_dir_hash_idx(OCFS2_SB(dir->i_sb), &hinfo);
2639                 dx_leaf_bh = dx_leaves[i];
2640
2641                 ret = __ocfs2_dx_dir_leaf_insert(dir, handle, &hinfo,
2642                                                  dirent_blk, dx_leaf_bh);
2643                 if (ret) {
2644                         mlog_errno(ret);
2645                         goto out;
2646                 }
2647
2648                 *num_dx_entries = *num_dx_entries + 1;
2649
2650 inc:
2651                 de_buf += le16_to_cpu(de->rec_len);
2652         }
2653
2654 out:
2655         return ret;
2656 }
2657
2658 /*
2659  * XXX: This expects dx_root_bh to already be part of the transaction.
2660  */
2661 static void ocfs2_dx_dir_index_root_block(struct inode *dir,
2662                                          struct buffer_head *dx_root_bh,
2663                                          struct buffer_head *dirent_bh)
2664 {
2665         char *de_buf, *limit;
2666         struct ocfs2_dx_root_block *dx_root;
2667         struct ocfs2_dir_entry *de;
2668         struct ocfs2_dx_hinfo hinfo;
2669         u64 dirent_blk = dirent_bh->b_blocknr;
2670
2671         dx_root = (struct ocfs2_dx_root_block *)dx_root_bh->b_data;
2672
2673         de_buf = dirent_bh->b_data;
2674         limit = de_buf + dir->i_sb->s_blocksize;
2675
2676         while (de_buf < limit) {
2677                 de = (struct ocfs2_dir_entry *)de_buf;
2678
2679                 if (!de->name_len || !de->inode)
2680                         goto inc;
2681
2682                 ocfs2_dx_dir_name_hash(dir, de->name, de->name_len, &hinfo);
2683
2684                 trace_ocfs2_dx_dir_index_root_block(
2685                                 (unsigned long long)dir->i_ino,
2686                                 hinfo.major_hash, hinfo.minor_hash,
2687                                 de->name_len, de->name,
2688                                 le16_to_cpu(dx_root->dr_entries.de_num_used));
2689
2690                 ocfs2_dx_entry_list_insert(&dx_root->dr_entries, &hinfo,
2691                                            dirent_blk);
2692
2693                 le32_add_cpu(&dx_root->dr_num_entries, 1);
2694 inc:
2695                 de_buf += le16_to_cpu(de->rec_len);
2696         }
2697 }
2698
2699 /*
2700  * Count the number of inline directory entries in di_bh and compare
2701  * them against the number of entries we can hold in an inline dx root
2702  * block.
2703  */
2704 static int ocfs2_new_dx_should_be_inline(struct inode *dir,
2705                                          struct buffer_head *di_bh)
2706 {
2707         int dirent_count = 0;
2708         char *de_buf, *limit;
2709         struct ocfs2_dir_entry *de;
2710         struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
2711
2712         de_buf = di->id2.i_data.id_data;
2713         limit = de_buf + i_size_read(dir);
2714
2715         while (de_buf < limit) {
2716                 de = (struct ocfs2_dir_entry *)de_buf;
2717
2718                 if (de->name_len && de->inode)
2719                         dirent_count++;
2720
2721                 de_buf += le16_to_cpu(de->rec_len);
2722         }
2723
2724         /* We are careful to leave room for one extra record. */
2725         return dirent_count < ocfs2_dx_entries_per_root(dir->i_sb);
2726 }
2727
2728 /*
2729  * Expand rec_len of the rightmost dirent in a directory block so that it
2730  * contains the end of our valid space for dirents. We do this during
2731  * expansion from an inline directory to one with extents. The first dir block
2732  * in that case is taken from the inline data portion of the inode block.
2733  *
2734  * This will also return the largest amount of contiguous space for a dirent
2735  * in the block. That value is *not* necessarily the last dirent, even after
2736  * expansion. The directory indexing code wants this value for free space
2737  * accounting. We do this here since we're already walking the entire dir
2738  * block.
2739  *
2740  * We add the dir trailer if this filesystem wants it.
2741  */
2742 static unsigned int ocfs2_expand_last_dirent(char *start, unsigned int old_size,
2743                                              struct inode *dir)
2744 {
2745         struct super_block *sb = dir->i_sb;
2746         struct ocfs2_dir_entry *de;
2747         struct ocfs2_dir_entry *prev_de;
2748         char *de_buf, *limit;
2749         unsigned int new_size = sb->s_blocksize;
2750         unsigned int bytes, this_hole;
2751         unsigned int largest_hole = 0;
2752
2753         if (ocfs2_new_dir_wants_trailer(dir))
2754                 new_size = ocfs2_dir_trailer_blk_off(sb);
2755
2756         bytes = new_size - old_size;
2757
2758         limit = start + old_size;
2759         de_buf = start;
2760         de = (struct ocfs2_dir_entry *)de_buf;
2761         do {
2762                 this_hole = ocfs2_figure_dirent_hole(de);
2763                 if (this_hole > largest_hole)
2764                         largest_hole = this_hole;
2765
2766                 prev_de = de;
2767                 de_buf += le16_to_cpu(de->rec_len);
2768                 de = (struct ocfs2_dir_entry *)de_buf;
2769         } while (de_buf < limit);
2770
2771         le16_add_cpu(&prev_de->rec_len, bytes);
2772
2773         /* We need to double check this after modification of the final
2774          * dirent. */
2775         this_hole = ocfs2_figure_dirent_hole(prev_de);
2776         if (this_hole > largest_hole)
2777                 largest_hole = this_hole;
2778
2779         if (largest_hole >= OCFS2_DIR_MIN_REC_LEN)
2780                 return largest_hole;
2781         return 0;
2782 }
2783
2784 /*
2785  * We allocate enough clusters to fulfill "blocks_wanted", but set
2786  * i_size to exactly one block. Ocfs2_extend_dir() will handle the
2787  * rest automatically for us.
2788  *
2789  * *first_block_bh is a pointer to the 1st data block allocated to the
2790  *  directory.
2791  */
2792 static int ocfs2_expand_inline_dir(struct inode *dir, struct buffer_head *di_bh,
2793                                    unsigned int blocks_wanted,
2794                                    struct ocfs2_dir_lookup_result *lookup,
2795                                    struct buffer_head **first_block_bh)
2796 {
2797         u32 alloc, dx_alloc, bit_off, len, num_dx_entries = 0;
2798         struct super_block *sb = dir->i_sb;
2799         int ret, i, num_dx_leaves = 0, dx_inline = 0,
2800                 credits = ocfs2_inline_to_extents_credits(sb);
2801         u64 dx_insert_blkno, blkno,
2802                 bytes = blocks_wanted << sb->s_blocksize_bits;
2803         struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
2804         struct ocfs2_inode_info *oi = OCFS2_I(dir);
2805         struct ocfs2_alloc_context *data_ac = NULL;
2806         struct ocfs2_alloc_context *meta_ac = NULL;
2807         struct buffer_head *dirdata_bh = NULL;
2808         struct buffer_head *dx_root_bh = NULL;
2809         struct buffer_head **dx_leaves = NULL;
2810         struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
2811         handle_t *handle;
2812         struct ocfs2_extent_tree et;
2813         struct ocfs2_extent_tree dx_et;
2814         int did_quota = 0, bytes_allocated = 0;
2815
2816         ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(dir), di_bh);
2817
2818         alloc = ocfs2_clusters_for_bytes(sb, bytes);
2819         dx_alloc = 0;
2820
2821         down_write(&oi->ip_alloc_sem);
2822
2823         if (ocfs2_supports_indexed_dirs(osb)) {
2824                 credits += ocfs2_add_dir_index_credits(sb);
2825
2826                 dx_inline = ocfs2_new_dx_should_be_inline(dir, di_bh);
2827                 if (!dx_inline) {
2828                         /* Add one more cluster for an index leaf */
2829                         dx_alloc++;
2830                         dx_leaves = ocfs2_dx_dir_kmalloc_leaves(sb,
2831                                                                 &num_dx_leaves);
2832                         if (!dx_leaves) {
2833                                 ret = -ENOMEM;
2834                                 mlog_errno(ret);
2835                                 goto out;
2836                         }
2837                 }
2838
2839                 /* This gets us the dx_root */
2840                 ret = ocfs2_reserve_new_metadata_blocks(osb, 1, &meta_ac);
2841                 if (ret) {
2842                         mlog_errno(ret);
2843                         goto out;
2844                 }
2845         }
2846
2847         /*
2848          * We should never need more than 2 clusters for the unindexed
2849          * tree - maximum dirent size is far less than one block. In
2850          * fact, the only time we'd need more than one cluster is if
2851          * blocksize == clustersize and the dirent won't fit in the
2852          * extra space that the expansion to a single block gives. As
2853          * of today, that only happens on 4k/4k file systems.
2854          */
2855         BUG_ON(alloc > 2);
2856
2857         ret = ocfs2_reserve_clusters(osb, alloc + dx_alloc, &data_ac);
2858         if (ret) {
2859                 mlog_errno(ret);
2860                 goto out;
2861         }
2862
2863         /*
2864          * Prepare for worst case allocation scenario of two separate
2865          * extents in the unindexed tree.
2866          */
2867         if (alloc == 2)
2868                 credits += OCFS2_SUBALLOC_ALLOC;
2869
2870         handle = ocfs2_start_trans(osb, credits);
2871         if (IS_ERR(handle)) {
2872                 ret = PTR_ERR(handle);
2873                 mlog_errno(ret);
2874                 goto out;
2875         }
2876
2877         ret = dquot_alloc_space_nodirty(dir,
2878                 ocfs2_clusters_to_bytes(osb->sb, alloc + dx_alloc));
2879         if (ret)
2880                 goto out_commit;
2881         did_quota = 1;
2882
2883         if (ocfs2_supports_indexed_dirs(osb) && !dx_inline) {
2884                 /*
2885                  * Allocate our index cluster first, to maximize the
2886                  * possibility that unindexed leaves grow
2887                  * contiguously.
2888                  */
2889                 ret = __ocfs2_dx_dir_new_cluster(dir, 0, handle, data_ac,
2890                                                  dx_leaves, num_dx_leaves,
2891                                                  &dx_insert_blkno);
2892                 if (ret) {
2893                         mlog_errno(ret);
2894                         goto out_commit;
2895                 }
2896                 bytes_allocated += ocfs2_clusters_to_bytes(dir->i_sb, 1);
2897         }
2898
2899         /*
2900          * Try to claim as many clusters as the bitmap can give though
2901          * if we only get one now, that's enough to continue. The rest
2902          * will be claimed after the conversion to extents.
2903          */
2904         if (ocfs2_dir_resv_allowed(osb))
2905                 data_ac->ac_resv = &oi->ip_la_data_resv;
2906         ret = ocfs2_claim_clusters(handle, data_ac, 1, &bit_off, &len);
2907         if (ret) {
2908                 mlog_errno(ret);
2909                 goto out_commit;
2910         }
2911         bytes_allocated += ocfs2_clusters_to_bytes(dir->i_sb, 1);
2912
2913         /*
2914          * Operations are carefully ordered so that we set up the new
2915          * data block first. The conversion from inline data to
2916          * extents follows.
2917          */
2918         blkno = ocfs2_clusters_to_blocks(dir->i_sb, bit_off);
2919         dirdata_bh = sb_getblk(sb, blkno);
2920         if (!dirdata_bh) {
2921                 ret = -ENOMEM;
2922                 mlog_errno(ret);
2923                 goto out_commit;
2924         }
2925
2926         ocfs2_set_new_buffer_uptodate(INODE_CACHE(dir), dirdata_bh);
2927
2928         ret = ocfs2_journal_access_db(handle, INODE_CACHE(dir), dirdata_bh,
2929                                       OCFS2_JOURNAL_ACCESS_CREATE);
2930         if (ret) {
2931                 mlog_errno(ret);
2932                 goto out_commit;
2933         }
2934
2935         memcpy(dirdata_bh->b_data, di->id2.i_data.id_data, i_size_read(dir));
2936         memset(dirdata_bh->b_data + i_size_read(dir), 0,
2937                sb->s_blocksize - i_size_read(dir));
2938         i = ocfs2_expand_last_dirent(dirdata_bh->b_data, i_size_read(dir), dir);
2939         if (ocfs2_new_dir_wants_trailer(dir)) {
2940                 /*
2941                  * Prepare the dir trailer up front. It will otherwise look
2942                  * like a valid dirent. Even if inserting the index fails
2943                  * (unlikely), then all we'll have done is given first dir
2944                  * block a small amount of fragmentation.
2945                  */
2946                 ocfs2_init_dir_trailer(dir, dirdata_bh, i);
2947         }
2948
2949         ocfs2_update_inode_fsync_trans(handle, dir, 1);
2950         ocfs2_journal_dirty(handle, dirdata_bh);
2951
2952         if (ocfs2_supports_indexed_dirs(osb) && !dx_inline) {
2953                 /*
2954                  * Dx dirs with an external cluster need to do this up
2955                  * front. Inline dx root's get handled later, after
2956                  * we've allocated our root block. We get passed back
2957                  * a total number of items so that dr_num_entries can
2958                  * be correctly set once the dx_root has been
2959                  * allocated.
2960                  */
2961                 ret = ocfs2_dx_dir_index_block(dir, handle, dx_leaves,
2962                                                num_dx_leaves, &num_dx_entries,
2963                                                dirdata_bh);
2964                 if (ret) {
2965                         mlog_errno(ret);
2966                         goto out_commit;
2967                 }
2968         }
2969
2970         /*
2971          * Set extent, i_size, etc on the directory. After this, the
2972          * inode should contain the same exact dirents as before and
2973          * be fully accessible from system calls.
2974          *
2975          * We let the later dirent insert modify c/mtime - to the user
2976          * the data hasn't changed.
2977          */
2978         ret = ocfs2_journal_access_di(handle, INODE_CACHE(dir), di_bh,
2979                                       OCFS2_JOURNAL_ACCESS_CREATE);
2980         if (ret) {
2981                 mlog_errno(ret);
2982                 goto out_commit;
2983         }
2984
2985         spin_lock(&oi->ip_lock);
2986         oi->ip_dyn_features &= ~OCFS2_INLINE_DATA_FL;
2987         di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
2988         spin_unlock(&oi->ip_lock);
2989
2990         ocfs2_dinode_new_extent_list(dir, di);
2991
2992         i_size_write(dir, sb->s_blocksize);
2993         dir->i_mtime = dir->i_ctime = current_time(dir);
2994
2995         di->i_size = cpu_to_le64(sb->s_blocksize);
2996         di->i_ctime = di->i_mtime = cpu_to_le64(dir->i_ctime.tv_sec);
2997         di->i_ctime_nsec = di->i_mtime_nsec = cpu_to_le32(dir->i_ctime.tv_nsec);
2998         ocfs2_update_inode_fsync_trans(handle, dir, 1);
2999
3000         /*
3001          * This should never fail as our extent list is empty and all
3002          * related blocks have been journaled already.
3003          */
3004         ret = ocfs2_insert_extent(handle, &et, 0, blkno, len,
3005                                   0, NULL);
3006         if (ret) {
3007                 mlog_errno(ret);
3008                 goto out_commit;
3009         }
3010
3011         /*
3012          * Set i_blocks after the extent insert for the most up to
3013          * date ip_clusters value.
3014          */
3015         dir->i_blocks = ocfs2_inode_sector_count(dir);
3016
3017         ocfs2_journal_dirty(handle, di_bh);
3018
3019         if (ocfs2_supports_indexed_dirs(osb)) {
3020                 ret = ocfs2_dx_dir_attach_index(osb, handle, dir, di_bh,
3021                                                 dirdata_bh, meta_ac, dx_inline,
3022                                                 num_dx_entries, &dx_root_bh);
3023                 if (ret) {
3024                         mlog_errno(ret);
3025                         goto out_commit;
3026                 }
3027
3028                 if (dx_inline) {
3029                         ocfs2_dx_dir_index_root_block(dir, dx_root_bh,
3030                                                       dirdata_bh);
3031                 } else {
3032                         ocfs2_init_dx_root_extent_tree(&dx_et,
3033                                                        INODE_CACHE(dir),
3034                                                        dx_root_bh);
3035                         ret = ocfs2_insert_extent(handle, &dx_et, 0,
3036                                                   dx_insert_blkno, 1, 0, NULL);
3037                         if (ret)
3038                                 mlog_errno(ret);
3039                 }
3040         }
3041
3042         /*
3043          * We asked for two clusters, but only got one in the 1st
3044          * pass. Claim the 2nd cluster as a separate extent.
3045          */
3046         if (alloc > len) {
3047                 ret = ocfs2_claim_clusters(handle, data_ac, 1, &bit_off,
3048                                            &len);
3049                 if (ret) {
3050                         mlog_errno(ret);
3051                         goto out_commit;
3052                 }
3053                 blkno = ocfs2_clusters_to_blocks(dir->i_sb, bit_off);
3054
3055                 ret = ocfs2_insert_extent(handle, &et, 1,
3056                                           blkno, len, 0, NULL);
3057                 if (ret) {
3058                         mlog_errno(ret);
3059                         goto out_commit;
3060                 }
3061                 bytes_allocated += ocfs2_clusters_to_bytes(dir->i_sb, 1);
3062         }
3063
3064         *first_block_bh = dirdata_bh;
3065         dirdata_bh = NULL;
3066         if (ocfs2_supports_indexed_dirs(osb)) {
3067                 unsigned int off;
3068
3069                 if (!dx_inline) {
3070                         /*
3071                          * We need to return the correct block within the
3072                          * cluster which should hold our entry.
3073                          */
3074                         off = ocfs2_dx_dir_hash_idx(osb,
3075                                                     &lookup->dl_hinfo);
3076                         get_bh(dx_leaves[off]);
3077                         lookup->dl_dx_leaf_bh = dx_leaves[off];
3078                 }
3079                 lookup->dl_dx_root_bh = dx_root_bh;
3080                 dx_root_bh = NULL;
3081         }
3082
3083 out_commit:
3084         if (ret < 0 && did_quota)
3085                 dquot_free_space_nodirty(dir, bytes_allocated);
3086
3087         ocfs2_commit_trans(osb, handle);
3088
3089 out:
3090         up_write(&oi->ip_alloc_sem);
3091         if (data_ac)
3092                 ocfs2_free_alloc_context(data_ac);
3093         if (meta_ac)
3094                 ocfs2_free_alloc_context(meta_ac);
3095
3096         if (dx_leaves) {
3097                 for (i = 0; i < num_dx_leaves; i++)
3098                         brelse(dx_leaves[i]);
3099                 kfree(dx_leaves);
3100         }
3101
3102         brelse(dirdata_bh);
3103         brelse(dx_root_bh);
3104
3105         return ret;
3106 }
3107
3108 /* returns a bh of the 1st new block in the allocation. */
3109 static int ocfs2_do_extend_dir(struct super_block *sb,
3110                                handle_t *handle,
3111                                struct inode *dir,
3112                                struct buffer_head *parent_fe_bh,
3113                                struct ocfs2_alloc_context *data_ac,
3114                                struct ocfs2_alloc_context *meta_ac,
3115                                struct buffer_head **new_bh)
3116 {
3117         int status;
3118         int extend, did_quota = 0;
3119         u64 p_blkno, v_blkno;
3120
3121         spin_lock(&OCFS2_I(dir)->ip_lock);
3122         extend = (i_size_read(dir) == ocfs2_clusters_to_bytes(sb, OCFS2_I(dir)->ip_clusters));
3123         spin_unlock(&OCFS2_I(dir)->ip_lock);
3124
3125         if (extend) {
3126                 u32 offset = OCFS2_I(dir)->ip_clusters;
3127
3128                 status = dquot_alloc_space_nodirty(dir,
3129                                         ocfs2_clusters_to_bytes(sb, 1));
3130                 if (status)
3131                         goto bail;
3132                 did_quota = 1;
3133
3134                 status = ocfs2_add_inode_data(OCFS2_SB(sb), dir, &offset,
3135                                               1, 0, parent_fe_bh, handle,
3136                                               data_ac, meta_ac, NULL);
3137                 BUG_ON(status == -EAGAIN);
3138                 if (status < 0) {
3139                         mlog_errno(status);
3140                         goto bail;
3141                 }
3142         }
3143
3144         v_blkno = ocfs2_blocks_for_bytes(sb, i_size_read(dir));
3145         status = ocfs2_extent_map_get_blocks(dir, v_blkno, &p_blkno, NULL, NULL);
3146         if (status < 0) {
3147                 mlog_errno(status);
3148                 goto bail;
3149         }
3150
3151         *new_bh = sb_getblk(sb, p_blkno);
3152         if (!*new_bh) {
3153                 status = -ENOMEM;
3154                 mlog_errno(status);
3155                 goto bail;
3156         }
3157         status = 0;
3158 bail:
3159         if (did_quota && status < 0)
3160                 dquot_free_space_nodirty(dir, ocfs2_clusters_to_bytes(sb, 1));
3161         return status;
3162 }
3163
3164 /*
3165  * Assumes you already have a cluster lock on the directory.
3166  *
3167  * 'blocks_wanted' is only used if we have an inline directory which
3168  * is to be turned into an extent based one. The size of the dirent to
3169  * insert might be larger than the space gained by growing to just one
3170  * block, so we may have to grow the inode by two blocks in that case.
3171  *
3172  * If the directory is already indexed, dx_root_bh must be provided.
3173  */
3174 static int ocfs2_extend_dir(struct ocfs2_super *osb,
3175                             struct inode *dir,
3176                             struct buffer_head *parent_fe_bh,
3177                             unsigned int blocks_wanted,
3178                             struct ocfs2_dir_lookup_result *lookup,
3179                             struct buffer_head **new_de_bh)
3180 {
3181         int status = 0;
3182         int credits, num_free_extents, drop_alloc_sem = 0;
3183         loff_t dir_i_size;
3184         struct ocfs2_dinode *fe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
3185         struct ocfs2_extent_list *el = &fe->id2.i_list;
3186         struct ocfs2_alloc_context *data_ac = NULL;
3187         struct ocfs2_alloc_context *meta_ac = NULL;
3188         handle_t *handle = NULL;
3189         struct buffer_head *new_bh = NULL;
3190         struct ocfs2_dir_entry * de;
3191         struct super_block *sb = osb->sb;
3192         struct ocfs2_extent_tree et;
3193         struct buffer_head *dx_root_bh = lookup->dl_dx_root_bh;
3194
3195         if (OCFS2_I(dir)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
3196                 /*
3197                  * This would be a code error as an inline directory should
3198                  * never have an index root.
3199                  */
3200                 BUG_ON(dx_root_bh);
3201
3202                 status = ocfs2_expand_inline_dir(dir, parent_fe_bh,
3203                                                  blocks_wanted, lookup,
3204                                                  &new_bh);
3205                 if (status) {
3206                         mlog_errno(status);
3207                         goto bail;
3208                 }
3209
3210                 /* Expansion from inline to an indexed directory will
3211                  * have given us this. */
3212                 dx_root_bh = lookup->dl_dx_root_bh;
3213
3214                 if (blocks_wanted == 1) {
3215                         /*
3216                          * If the new dirent will fit inside the space
3217                          * created by pushing out to one block, then
3218                          * we can complete the operation
3219                          * here. Otherwise we have to expand i_size
3220                          * and format the 2nd block below.
3221                          */
3222                         BUG_ON(new_bh == NULL);
3223                         goto bail_bh;
3224                 }
3225
3226                 /*
3227                  * Get rid of 'new_bh' - we want to format the 2nd
3228                  * data block and return that instead.
3229                  */
3230                 brelse(new_bh);
3231                 new_bh = NULL;
3232
3233                 down_write(&OCFS2_I(dir)->ip_alloc_sem);
3234                 drop_alloc_sem = 1;
3235                 dir_i_size = i_size_read(dir);
3236                 credits = OCFS2_SIMPLE_DIR_EXTEND_CREDITS;
3237                 goto do_extend;
3238         }
3239
3240         down_write(&OCFS2_I(dir)->ip_alloc_sem);
3241         drop_alloc_sem = 1;
3242         dir_i_size = i_size_read(dir);
3243         trace_ocfs2_extend_dir((unsigned long long)OCFS2_I(dir)->ip_blkno,
3244                                dir_i_size);
3245
3246         /* dir->i_size is always block aligned. */
3247         spin_lock(&OCFS2_I(dir)->ip_lock);
3248         if (dir_i_size == ocfs2_clusters_to_bytes(sb, OCFS2_I(dir)->ip_clusters)) {
3249                 spin_unlock(&OCFS2_I(dir)->ip_lock);
3250                 ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(dir),
3251                                               parent_fe_bh);
3252                 num_free_extents = ocfs2_num_free_extents(&et);
3253                 if (num_free_extents < 0) {
3254                         status = num_free_extents;
3255                         mlog_errno(status);
3256                         goto bail;
3257                 }
3258
3259                 if (!num_free_extents) {
3260                         status = ocfs2_reserve_new_metadata(osb, el, &meta_ac);
3261                         if (status < 0) {
3262                                 if (status != -ENOSPC)
3263                                         mlog_errno(status);
3264                                 goto bail;
3265                         }
3266                 }
3267
3268                 status = ocfs2_reserve_clusters(osb, 1, &data_ac);
3269                 if (status < 0) {
3270                         if (status != -ENOSPC)
3271                                 mlog_errno(status);
3272                         goto bail;
3273                 }
3274
3275                 if (ocfs2_dir_resv_allowed(osb))
3276                         data_ac->ac_resv = &OCFS2_I(dir)->ip_la_data_resv;
3277
3278                 credits = ocfs2_calc_extend_credits(sb, el);
3279         } else {
3280                 spin_unlock(&OCFS2_I(dir)->ip_lock);
3281                 credits = OCFS2_SIMPLE_DIR_EXTEND_CREDITS;
3282         }
3283
3284 do_extend:
3285         if (ocfs2_dir_indexed(dir))
3286                 credits++; /* For attaching the new dirent block to the
3287                             * dx_root */
3288
3289         handle = ocfs2_start_trans(osb, credits);
3290         if (IS_ERR(handle)) {
3291                 status = PTR_ERR(handle);
3292                 handle = NULL;
3293                 mlog_errno(status);
3294                 goto bail;
3295         }
3296
3297         status = ocfs2_do_extend_dir(osb->sb, handle, dir, parent_fe_bh,
3298                                      data_ac, meta_ac, &new_bh);
3299         if (status < 0) {
3300                 mlog_errno(status);
3301                 goto bail;
3302         }
3303
3304         ocfs2_set_new_buffer_uptodate(INODE_CACHE(dir), new_bh);
3305
3306         status = ocfs2_journal_access_db(handle, INODE_CACHE(dir), new_bh,
3307                                          OCFS2_JOURNAL_ACCESS_CREATE);
3308         if (status < 0) {
3309                 mlog_errno(status);
3310                 goto bail;
3311         }
3312         memset(new_bh->b_data, 0, sb->s_blocksize);
3313
3314         de = (struct ocfs2_dir_entry *) new_bh->b_data;
3315         de->inode = 0;
3316         if (ocfs2_supports_dir_trailer(dir)) {
3317                 de->rec_len = cpu_to_le16(ocfs2_dir_trailer_blk_off(sb));
3318
3319                 ocfs2_init_dir_trailer(dir, new_bh, le16_to_cpu(de->rec_len));
3320
3321                 if (ocfs2_dir_indexed(dir)) {
3322                         status = ocfs2_dx_dir_link_trailer(dir, handle,
3323                                                            dx_root_bh, new_bh);
3324                         if (status) {
3325                                 mlog_errno(status);
3326                                 goto bail;
3327                         }
3328                 }
3329         } else {
3330                 de->rec_len = cpu_to_le16(sb->s_blocksize);
3331         }
3332         ocfs2_update_inode_fsync_trans(handle, dir, 1);
3333         ocfs2_journal_dirty(handle, new_bh);
3334
3335         dir_i_size += dir->i_sb->s_blocksize;
3336         i_size_write(dir, dir_i_size);
3337         dir->i_blocks = ocfs2_inode_sector_count(dir);
3338         status = ocfs2_mark_inode_dirty(handle, dir, parent_fe_bh);
3339         if (status < 0) {
3340                 mlog_errno(status);
3341                 goto bail;
3342         }
3343
3344 bail_bh:
3345         *new_de_bh = new_bh;
3346         get_bh(*new_de_bh);
3347 bail:
3348         if (handle)
3349                 ocfs2_commit_trans(osb, handle);
3350         if (drop_alloc_sem)
3351                 up_write(&OCFS2_I(dir)->ip_alloc_sem);
3352
3353         if (data_ac)
3354                 ocfs2_free_alloc_context(data_ac);
3355         if (meta_ac)
3356                 ocfs2_free_alloc_context(meta_ac);
3357
3358         brelse(new_bh);
3359
3360         return status;
3361 }
3362
3363 static int ocfs2_find_dir_space_id(struct inode *dir, struct buffer_head *di_bh,
3364                                    const char *name, int namelen,
3365                                    struct buffer_head **ret_de_bh,
3366                                    unsigned int *blocks_wanted)
3367 {
3368         int ret;
3369         struct super_block *sb = dir->i_sb;
3370         struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
3371         struct ocfs2_dir_entry *de, *last_de = NULL;
3372         char *de_buf, *limit;
3373         unsigned long offset = 0;
3374         unsigned int rec_len, new_rec_len, free_space = dir->i_sb->s_blocksize;
3375
3376         /*
3377          * This calculates how many free bytes we'd have in block zero, should
3378          * this function force expansion to an extent tree.
3379          */
3380         if (ocfs2_new_dir_wants_trailer(dir))
3381                 free_space = ocfs2_dir_trailer_blk_off(sb) - i_size_read(dir);
3382         else
3383                 free_space = dir->i_sb->s_blocksize - i_size_read(dir);
3384
3385         de_buf = di->id2.i_data.id_data;
3386         limit = de_buf + i_size_read(dir);
3387         rec_len = OCFS2_DIR_REC_LEN(namelen);
3388
3389         while (de_buf < limit) {
3390                 de = (struct ocfs2_dir_entry *)de_buf;
3391
3392                 if (!ocfs2_check_dir_entry(dir, de, di_bh, offset)) {
3393                         ret = -ENOENT;
3394                         goto out;
3395                 }
3396                 if (ocfs2_match(namelen, name, de)) {
3397                         ret = -EEXIST;
3398                         goto out;
3399                 }
3400                 /*
3401                  * No need to check for a trailing dirent record here as
3402                  * they're not used for inline dirs.
3403                  */
3404
3405                 if (ocfs2_dirent_would_fit(de, rec_len)) {
3406                         /* Ok, we found a spot. Return this bh and let
3407                          * the caller actually fill it in. */
3408                         *ret_de_bh = di_bh;
3409                         get_bh(*ret_de_bh);
3410                         ret = 0;
3411                         goto out;
3412                 }
3413
3414                 last_de = de;
3415                 de_buf += le16_to_cpu(de->rec_len);
3416                 offset += le16_to_cpu(de->rec_len);
3417         }
3418
3419         /*
3420          * We're going to require expansion of the directory - figure
3421          * out how many blocks we'll need so that a place for the
3422          * dirent can be found.
3423          */
3424         *blocks_wanted = 1;
3425         new_rec_len = le16_to_cpu(last_de->rec_len) + free_space;
3426         if (new_rec_len < (rec_len + OCFS2_DIR_REC_LEN(last_de->name_len)))
3427                 *blocks_wanted = 2;
3428
3429         ret = -ENOSPC;
3430 out:
3431         return ret;
3432 }
3433
3434 static int ocfs2_find_dir_space_el(struct inode *dir, const char *name,
3435                                    int namelen, struct buffer_head **ret_de_bh)
3436 {
3437         unsigned long offset;
3438         struct buffer_head *bh = NULL;
3439         unsigned short rec_len;
3440         struct ocfs2_dir_entry *de;
3441         struct super_block *sb = dir->i_sb;
3442         int status;
3443         int blocksize = dir->i_sb->s_blocksize;
3444
3445         status = ocfs2_read_dir_block(dir, 0, &bh, 0);
3446         if (status)
3447                 goto bail;
3448
3449         rec_len = OCFS2_DIR_REC_LEN(namelen);
3450         offset = 0;
3451         de = (struct ocfs2_dir_entry *) bh->b_data;
3452         while (1) {
3453                 if ((char *)de >= sb->s_blocksize + bh->b_data) {
3454                         brelse(bh);
3455                         bh = NULL;
3456
3457                         if (i_size_read(dir) <= offset) {
3458                                 /*
3459                                  * Caller will have to expand this
3460                                  * directory.
3461                                  */
3462                                 status = -ENOSPC;
3463                                 goto bail;
3464                         }
3465                         status = ocfs2_read_dir_block(dir,
3466                                              offset >> sb->s_blocksize_bits,
3467                                              &bh, 0);
3468                         if (status)
3469                                 goto bail;
3470
3471                         /* move to next block */
3472                         de = (struct ocfs2_dir_entry *) bh->b_data;
3473                 }
3474                 if (!ocfs2_check_dir_entry(dir, de, bh, offset)) {
3475                         status = -ENOENT;
3476                         goto bail;
3477                 }
3478                 if (ocfs2_match(namelen, name, de)) {
3479                         status = -EEXIST;
3480                         goto bail;
3481                 }
3482
3483                 if (ocfs2_skip_dir_trailer(dir, de, offset % blocksize,
3484                                            blocksize))
3485                         goto next;
3486
3487                 if (ocfs2_dirent_would_fit(de, rec_len)) {
3488                         /* Ok, we found a spot. Return this bh and let
3489                          * the caller actually fill it in. */
3490                         *ret_de_bh = bh;
3491                         get_bh(*ret_de_bh);
3492                         status = 0;
3493                         goto bail;
3494                 }
3495 next:
3496                 offset += le16_to_cpu(de->rec_len);
3497                 de = (struct ocfs2_dir_entry *)((char *) de + le16_to_cpu(de->rec_len));
3498         }
3499
3500 bail:
3501         brelse(bh);
3502         if (status)
3503                 mlog_errno(status);
3504
3505         return status;
3506 }
3507
3508 static int dx_leaf_sort_cmp(const void *a, const void *b)
3509 {
3510         const struct ocfs2_dx_entry *entry1 = a;
3511         const struct ocfs2_dx_entry *entry2 = b;
3512         u32 major_hash1 = le32_to_cpu(entry1->dx_major_hash);
3513         u32 major_hash2 = le32_to_cpu(entry2->dx_major_hash);
3514         u32 minor_hash1 = le32_to_cpu(entry1->dx_minor_hash);
3515         u32 minor_hash2 = le32_to_cpu(entry2->dx_minor_hash);
3516
3517         if (major_hash1 > major_hash2)
3518                 return 1;
3519         if (major_hash1 < major_hash2)
3520                 return -1;
3521
3522         /*
3523          * It is not strictly necessary to sort by minor
3524          */
3525         if (minor_hash1 > minor_hash2)
3526                 return 1;
3527         if (minor_hash1 < minor_hash2)
3528                 return -1;
3529         return 0;
3530 }
3531
3532 static void dx_leaf_sort_swap(void *a, void *b, int size)
3533 {
3534         struct ocfs2_dx_entry *entry1 = a;
3535         struct ocfs2_dx_entry *entry2 = b;
3536
3537         BUG_ON(size != sizeof(*entry1));
3538
3539         swap(*entry1, *entry2);
3540 }
3541
3542 static int ocfs2_dx_leaf_same_major(struct ocfs2_dx_leaf *dx_leaf)
3543 {
3544         struct ocfs2_dx_entry_list *dl_list = &dx_leaf->dl_list;
3545         int i, num = le16_to_cpu(dl_list->de_num_used);
3546
3547         for (i = 0; i < (num - 1); i++) {
3548                 if (le32_to_cpu(dl_list->de_entries[i].dx_major_hash) !=
3549                     le32_to_cpu(dl_list->de_entries[i + 1].dx_major_hash))
3550                         return 0;
3551         }
3552
3553         return 1;
3554 }
3555
3556 /*
3557  * Find the optimal value to split this leaf on. This expects the leaf
3558  * entries to be in sorted order.
3559  *
3560  * leaf_cpos is the cpos of the leaf we're splitting. insert_hash is
3561  * the hash we want to insert.
3562  *
3563  * This function is only concerned with the major hash - that which
3564  * determines which cluster an item belongs to.
3565  */
3566 static int ocfs2_dx_dir_find_leaf_split(struct ocfs2_dx_leaf *dx_leaf,
3567                                         u32 leaf_cpos, u32 insert_hash,
3568                                         u32 *split_hash)
3569 {
3570         struct ocfs2_dx_entry_list *dl_list = &dx_leaf->dl_list;
3571         int i, num_used = le16_to_cpu(dl_list->de_num_used);
3572         int allsame;
3573
3574         /*
3575          * There's a couple rare, but nasty corner cases we have to
3576          * check for here. All of them involve a leaf where all value
3577          * have the same hash, which is what we look for first.
3578          *
3579          * Most of the time, all of the above is false, and we simply
3580          * pick the median value for a split.
3581          */
3582         allsame = ocfs2_dx_leaf_same_major(dx_leaf);
3583         if (allsame) {
3584                 u32 val = le32_to_cpu(dl_list->de_entries[0].dx_major_hash);
3585
3586                 if (val == insert_hash) {
3587                         /*
3588                          * No matter where we would choose to split,
3589                          * the new entry would want to occupy the same
3590                          * block as these. Since there's no space left
3591                          * in their existing block, we know there
3592                          * won't be space after the split.
3593                          */
3594                         return -ENOSPC;
3595                 }
3596
3597                 if (val == leaf_cpos) {
3598                         /*
3599                          * Because val is the same as leaf_cpos (which
3600                          * is the smallest value this leaf can have),
3601                          * yet is not equal to insert_hash, then we
3602                          * know that insert_hash *must* be larger than
3603                          * val (and leaf_cpos). At least cpos+1 in value.
3604                          *
3605                          * We also know then, that there cannot be an
3606                          * adjacent extent (otherwise we'd be looking
3607                          * at it). Choosing this value gives us a
3608                          * chance to get some contiguousness.
3609                          */
3610                         *split_hash = leaf_cpos + 1;
3611                         return 0;
3612                 }
3613
3614                 if (val > insert_hash) {
3615                         /*
3616                          * val can not be the same as insert hash, and
3617                          * also must be larger than leaf_cpos. Also,
3618                          * we know that there can't be a leaf between
3619                          * cpos and val, otherwise the entries with
3620                          * hash 'val' would be there.
3621                          */
3622                         *split_hash = val;
3623                         return 0;
3624                 }
3625
3626                 *split_hash = insert_hash;
3627                 return 0;
3628         }
3629
3630         /*
3631          * Since the records are sorted and the checks above
3632          * guaranteed that not all records in this block are the same,
3633          * we simple travel forward, from the median, and pick the 1st
3634          * record whose value is larger than leaf_cpos.
3635          */
3636         for (i = (num_used / 2); i < num_used; i++)
3637                 if (le32_to_cpu(dl_list->de_entries[i].dx_major_hash) >
3638                     leaf_cpos)
3639                         break;
3640
3641         BUG_ON(i == num_used); /* Should be impossible */
3642         *split_hash = le32_to_cpu(dl_list->de_entries[i].dx_major_hash);
3643         return 0;
3644 }
3645
3646 /*
3647  * Transfer all entries in orig_dx_leaves whose major hash is equal to or
3648  * larger than split_hash into new_dx_leaves. We use a temporary
3649  * buffer (tmp_dx_leaf) to make the changes to the original leaf blocks.
3650  *
3651  * Since the block offset inside a leaf (cluster) is a constant mask
3652  * of minor_hash, we can optimize - an item at block offset X within
3653  * the original cluster, will be at offset X within the new cluster.
3654  */
3655 static void ocfs2_dx_dir_transfer_leaf(struct inode *dir, u32 split_hash,
3656                                        handle_t *handle,
3657                                        struct ocfs2_dx_leaf *tmp_dx_leaf,
3658                                        struct buffer_head **orig_dx_leaves,
3659                                        struct buffer_head **new_dx_leaves,
3660                                        int num_dx_leaves)
3661 {
3662         int i, j, num_used;
3663         u32 major_hash;
3664         struct ocfs2_dx_leaf *orig_dx_leaf, *new_dx_leaf;
3665         struct ocfs2_dx_entry_list *orig_list, *new_list, *tmp_list;
3666         struct ocfs2_dx_entry *dx_entry;
3667
3668         tmp_list = &tmp_dx_leaf->dl_list;
3669
3670         for (i = 0; i < num_dx_leaves; i++) {
3671                 orig_dx_leaf = (struct ocfs2_dx_leaf *) orig_dx_leaves[i]->b_data;
3672                 orig_list = &orig_dx_leaf->dl_list;
3673                 new_dx_leaf = (struct ocfs2_dx_leaf *) new_dx_leaves[i]->b_data;
3674                 new_list = &new_dx_leaf->dl_list;
3675
3676                 num_used = le16_to_cpu(orig_list->de_num_used);
3677
3678                 memcpy(tmp_dx_leaf, orig_dx_leaf, dir->i_sb->s_blocksize);
3679                 tmp_list->de_num_used = cpu_to_le16(0);
3680                 memset(&tmp_list->de_entries, 0, sizeof(*dx_entry)*num_used);
3681
3682                 for (j = 0; j < num_used; j++) {
3683                         dx_entry = &orig_list->de_entries[j];
3684                         major_hash = le32_to_cpu(dx_entry->dx_major_hash);
3685                         if (major_hash >= split_hash)
3686                                 ocfs2_dx_dir_leaf_insert_tail(new_dx_leaf,
3687                                                               dx_entry);
3688                         else
3689                                 ocfs2_dx_dir_leaf_insert_tail(tmp_dx_leaf,
3690                                                               dx_entry);
3691                 }
3692                 memcpy(orig_dx_leaf, tmp_dx_leaf, dir->i_sb->s_blocksize);
3693
3694                 ocfs2_journal_dirty(handle, orig_dx_leaves[i]);
3695                 ocfs2_journal_dirty(handle, new_dx_leaves[i]);
3696         }
3697 }
3698
3699 static int ocfs2_dx_dir_rebalance_credits(struct ocfs2_super *osb,
3700                                           struct ocfs2_dx_root_block *dx_root)
3701 {
3702         int credits = ocfs2_clusters_to_blocks(osb->sb, 3);
3703
3704         credits += ocfs2_calc_extend_credits(osb->sb, &dx_root->dr_list);
3705         credits += ocfs2_quota_trans_credits(osb->sb);
3706         return credits;
3707 }
3708
3709 /*
3710  * Find the median value in dx_leaf_bh and allocate a new leaf to move
3711  * half our entries into.
3712  */
3713 static int ocfs2_dx_dir_rebalance(struct ocfs2_super *osb, struct inode *dir,
3714                                   struct buffer_head *dx_root_bh,
3715                                   struct buffer_head *dx_leaf_bh,
3716                                   struct ocfs2_dx_hinfo *hinfo, u32 leaf_cpos,
3717                                   u64 leaf_blkno)
3718 {
3719         struct ocfs2_dx_leaf *dx_leaf = (struct ocfs2_dx_leaf *)dx_leaf_bh->b_data;
3720         int credits, ret, i, num_used, did_quota = 0;
3721         u32 cpos, split_hash, insert_hash = hinfo->major_hash;
3722         u64 orig_leaves_start;
3723         int num_dx_leaves;
3724         struct buffer_head **orig_dx_leaves = NULL;
3725         struct buffer_head **new_dx_leaves = NULL;
3726         struct ocfs2_alloc_context *data_ac = NULL, *meta_ac = NULL;
3727         struct ocfs2_extent_tree et;
3728         handle_t *handle = NULL;
3729         struct ocfs2_dx_root_block *dx_root;
3730         struct ocfs2_dx_leaf *tmp_dx_leaf = NULL;
3731
3732         trace_ocfs2_dx_dir_rebalance((unsigned long long)OCFS2_I(dir)->ip_blkno,
3733                                      (unsigned long long)leaf_blkno,
3734                                      insert_hash);
3735
3736         ocfs2_init_dx_root_extent_tree(&et, INODE_CACHE(dir), dx_root_bh);
3737
3738         dx_root = (struct ocfs2_dx_root_block *)dx_root_bh->b_data;
3739         /*
3740          * XXX: This is a rather large limit. We should use a more
3741          * realistic value.
3742          */
3743         if (le32_to_cpu(dx_root->dr_clusters) == UINT_MAX)
3744                 return -ENOSPC;
3745
3746         num_used = le16_to_cpu(dx_leaf->dl_list.de_num_used);
3747         if (num_used < le16_to_cpu(dx_leaf->dl_list.de_count)) {
3748                 mlog(ML_ERROR, "DX Dir: %llu, Asked to rebalance empty leaf: "
3749                      "%llu, %d\n", (unsigned long long)OCFS2_I(dir)->ip_blkno,
3750                      (unsigned long long)leaf_blkno, num_used);
3751                 ret = -EIO;
3752                 goto out;
3753         }
3754
3755         orig_dx_leaves = ocfs2_dx_dir_kmalloc_leaves(osb->sb, &num_dx_leaves);
3756         if (!orig_dx_leaves) {
3757                 ret = -ENOMEM;
3758                 mlog_errno(ret);
3759                 goto out;
3760         }
3761
3762         new_dx_leaves = ocfs2_dx_dir_kmalloc_leaves(osb->sb, NULL);
3763         if (!new_dx_leaves) {
3764                 ret = -ENOMEM;
3765                 mlog_errno(ret);
3766                 goto out;
3767         }
3768
3769         ret = ocfs2_lock_allocators(dir, &et, 1, 0, &data_ac, &meta_ac);
3770         if (ret) {
3771                 if (ret != -ENOSPC)
3772                         mlog_errno(ret);
3773                 goto out;
3774         }
3775
3776         credits = ocfs2_dx_dir_rebalance_credits(osb, dx_root);
3777         handle = ocfs2_start_trans(osb, credits);
3778         if (IS_ERR(handle)) {
3779                 ret = PTR_ERR(handle);
3780                 handle = NULL;
3781                 mlog_errno(ret);
3782                 goto out;
3783         }
3784
3785         ret = dquot_alloc_space_nodirty(dir,
3786                                        ocfs2_clusters_to_bytes(dir->i_sb, 1));
3787         if (ret)
3788                 goto out_commit;
3789         did_quota = 1;
3790
3791         ret = ocfs2_journal_access_dl(handle, INODE_CACHE(dir), dx_leaf_bh,
3792                                       OCFS2_JOURNAL_ACCESS_WRITE);
3793         if (ret) {
3794                 mlog_errno(ret);
3795                 goto out_commit;
3796         }
3797
3798         /*
3799          * This block is changing anyway, so we can sort it in place.
3800          */
3801         sort(dx_leaf->dl_list.de_entries, num_used,
3802              sizeof(struct ocfs2_dx_entry), dx_leaf_sort_cmp,
3803              dx_leaf_sort_swap);
3804
3805         ocfs2_journal_dirty(handle, dx_leaf_bh);
3806
3807         ret = ocfs2_dx_dir_find_leaf_split(dx_leaf, leaf_cpos, insert_hash,
3808                                            &split_hash);
3809         if (ret) {
3810                 mlog_errno(ret);
3811                 goto  out_commit;
3812         }
3813
3814         trace_ocfs2_dx_dir_rebalance_split(leaf_cpos, split_hash, insert_hash);
3815
3816         /*
3817          * We have to carefully order operations here. There are items
3818          * which want to be in the new cluster before insert, but in
3819          * order to put those items in the new cluster, we alter the
3820          * old cluster. A failure to insert gets nasty.
3821          *
3822          * So, start by reserving writes to the old
3823          * cluster. ocfs2_dx_dir_new_cluster will reserve writes on
3824          * the new cluster for us, before inserting it. The insert
3825          * won't happen if there's an error before that. Once the
3826          * insert is done then, we can transfer from one leaf into the
3827          * other without fear of hitting any error.
3828          */
3829
3830         /*
3831          * The leaf transfer wants some scratch space so that we don't
3832          * wind up doing a bunch of expensive memmove().
3833          */
3834         tmp_dx_leaf = kmalloc(osb->sb->s_blocksize, GFP_NOFS);
3835         if (!tmp_dx_leaf) {
3836                 ret = -ENOMEM;
3837                 mlog_errno(ret);
3838                 goto out_commit;
3839         }
3840
3841         orig_leaves_start = ocfs2_block_to_cluster_start(dir->i_sb, leaf_blkno);
3842         ret = ocfs2_read_dx_leaves(dir, orig_leaves_start, num_dx_leaves,
3843                                    orig_dx_leaves);
3844         if (ret) {
3845                 mlog_errno(ret);
3846                 goto out_commit;
3847         }
3848
3849         cpos = split_hash;
3850         ret = ocfs2_dx_dir_new_cluster(dir, &et, cpos, handle,
3851                                        data_ac, meta_ac, new_dx_leaves,
3852                                        num_dx_leaves);
3853         if (ret) {
3854                 mlog_errno(ret);
3855                 goto out_commit;
3856         }
3857
3858         for (i = 0; i < num_dx_leaves; i++) {
3859                 ret = ocfs2_journal_access_dl(handle, INODE_CACHE(dir),
3860                                               orig_dx_leaves[i],
3861                                               OCFS2_JOURNAL_ACCESS_WRITE);
3862                 if (ret) {
3863                         mlog_errno(ret);
3864                         goto out_commit;
3865                 }
3866
3867                 ret = ocfs2_journal_access_dl(handle, INODE_CACHE(dir),
3868                                               new_dx_leaves[i],
3869                                               OCFS2_JOURNAL_ACCESS_WRITE);
3870                 if (ret) {
3871                         mlog_errno(ret);
3872                         goto out_commit;
3873                 }
3874         }
3875
3876         ocfs2_dx_dir_transfer_leaf(dir, split_hash, handle, tmp_dx_leaf,
3877                                    orig_dx_leaves, new_dx_leaves, num_dx_leaves);
3878
3879 out_commit:
3880         if (ret < 0 && did_quota)
3881                 dquot_free_space_nodirty(dir,
3882                                 ocfs2_clusters_to_bytes(dir->i_sb, 1));
3883
3884         ocfs2_update_inode_fsync_trans(handle, dir, 1);
3885         ocfs2_commit_trans(osb, handle);
3886
3887 out:
3888         if (orig_dx_leaves || new_dx_leaves) {
3889                 for (i = 0; i < num_dx_leaves; i++) {
3890                         if (orig_dx_leaves)
3891                                 brelse(orig_dx_leaves[i]);
3892                         if (new_dx_leaves)
3893                                 brelse(new_dx_leaves[i]);
3894                 }
3895                 kfree(orig_dx_leaves);
3896                 kfree(new_dx_leaves);
3897         }
3898
3899         if (meta_ac)
3900                 ocfs2_free_alloc_context(meta_ac);
3901         if (data_ac)
3902                 ocfs2_free_alloc_context(data_ac);
3903
3904         kfree(tmp_dx_leaf);
3905         return ret;
3906 }
3907
3908 static int ocfs2_find_dir_space_dx(struct ocfs2_super *osb, struct inode *dir,
3909                                    struct buffer_head *di_bh,
3910                                    struct buffer_head *dx_root_bh,
3911                                    const char *name, int namelen,
3912                                    struct ocfs2_dir_lookup_result *lookup)
3913 {
3914         int ret, rebalanced = 0;
3915         struct ocfs2_dx_root_block *dx_root;
3916         struct buffer_head *dx_leaf_bh = NULL;
3917         struct ocfs2_dx_leaf *dx_leaf;
3918         u64 blkno;
3919         u32 leaf_cpos;
3920
3921         dx_root = (struct ocfs2_dx_root_block *)dx_root_bh->b_data;
3922
3923 restart_search:
3924         ret = ocfs2_dx_dir_lookup(dir, &dx_root->dr_list, &lookup->dl_hinfo,
3925                                   &leaf_cpos, &blkno);
3926         if (ret) {
3927                 mlog_errno(ret);
3928                 goto out;
3929         }
3930
3931         ret = ocfs2_read_dx_leaf(dir, blkno, &dx_leaf_bh);
3932         if (ret) {
3933                 mlog_errno(ret);
3934                 goto out;
3935         }
3936
3937         dx_leaf = (struct ocfs2_dx_leaf *)dx_leaf_bh->b_data;
3938
3939         if (le16_to_cpu(dx_leaf->dl_list.de_num_used) >=
3940             le16_to_cpu(dx_leaf->dl_list.de_count)) {
3941                 if (rebalanced) {
3942                         /*
3943                          * Rebalancing should have provided us with
3944                          * space in an appropriate leaf.
3945                          *
3946                          * XXX: Is this an abnormal condition then?
3947                          * Should we print a message here?
3948                          */
3949                         ret = -ENOSPC;
3950                         goto out;
3951                 }
3952
3953                 ret = ocfs2_dx_dir_rebalance(osb, dir, dx_root_bh, dx_leaf_bh,
3954                                              &lookup->dl_hinfo, leaf_cpos,
3955                                              blkno);
3956                 if (ret) {
3957                         if (ret != -ENOSPC)
3958                                 mlog_errno(ret);
3959                         goto out;
3960                 }
3961
3962                 /*
3963                  * Restart the lookup. The rebalance might have
3964                  * changed which block our item fits into. Mark our
3965                  * progress, so we only execute this once.
3966                  */
3967                 brelse(dx_leaf_bh);
3968                 dx_leaf_bh = NULL;
3969                 rebalanced = 1;
3970                 goto restart_search;
3971         }
3972
3973         lookup->dl_dx_leaf_bh = dx_leaf_bh;
3974         dx_leaf_bh = NULL;
3975
3976 out:
3977         brelse(dx_leaf_bh);
3978         return ret;
3979 }
3980
3981 static int ocfs2_search_dx_free_list(struct inode *dir,
3982                                      struct buffer_head *dx_root_bh,
3983                                      int namelen,
3984                                      struct ocfs2_dir_lookup_result *lookup)
3985 {
3986         int ret = -ENOSPC;
3987         struct buffer_head *leaf_bh = NULL, *prev_leaf_bh = NULL;
3988         struct ocfs2_dir_block_trailer *db;
3989         u64 next_block;
3990         int rec_len = OCFS2_DIR_REC_LEN(namelen);
3991         struct ocfs2_dx_root_block *dx_root;
3992
3993         dx_root = (struct ocfs2_dx_root_block *)dx_root_bh->b_data;
3994         next_block = le64_to_cpu(dx_root->dr_free_blk);
3995
3996         while (next_block) {
3997                 brelse(prev_leaf_bh);
3998                 prev_leaf_bh = leaf_bh;
3999                 leaf_bh = NULL;
4000
4001                 ret = ocfs2_read_dir_block_direct(dir, next_block, &leaf_bh);
4002                 if (ret) {
4003                         mlog_errno(ret);
4004                         goto out;
4005                 }
4006
4007                 db = ocfs2_trailer_from_bh(leaf_bh, dir->i_sb);
4008                 if (rec_len <= le16_to_cpu(db->db_free_rec_len)) {
4009                         lookup->dl_leaf_bh = leaf_bh;
4010                         lookup->dl_prev_leaf_bh = prev_leaf_bh;
4011                         leaf_bh = NULL;
4012                         prev_leaf_bh = NULL;
4013                         break;
4014                 }
4015
4016                 next_block = le64_to_cpu(db->db_free_next);
4017         }
4018
4019         if (!next_block)
4020                 ret = -ENOSPC;
4021
4022 out:
4023
4024         brelse(leaf_bh);
4025         brelse(prev_leaf_bh);
4026         return ret;
4027 }
4028
4029 static int ocfs2_expand_inline_dx_root(struct inode *dir,
4030                                        struct buffer_head *dx_root_bh)
4031 {
4032         int ret, num_dx_leaves, i, j, did_quota = 0;
4033         struct buffer_head **dx_leaves = NULL;
4034         struct ocfs2_extent_tree et;
4035         u64 insert_blkno;
4036         struct ocfs2_alloc_context *data_ac = NULL;
4037         struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
4038         handle_t *handle = NULL;
4039         struct ocfs2_dx_root_block *dx_root;
4040         struct ocfs2_dx_entry_list *entry_list;
4041         struct ocfs2_dx_entry *dx_entry;
4042         struct ocfs2_dx_leaf *target_leaf;
4043
4044         ret = ocfs2_reserve_clusters(osb, 1, &data_ac);
4045         if (ret) {
4046                 mlog_errno(ret);
4047                 goto out;
4048         }
4049
4050         dx_leaves = ocfs2_dx_dir_kmalloc_leaves(osb->sb, &num_dx_leaves);
4051         if (!dx_leaves) {
4052                 ret = -ENOMEM;
4053                 mlog_errno(ret);
4054                 goto out;
4055         }
4056
4057         handle = ocfs2_start_trans(osb, ocfs2_calc_dxi_expand_credits(osb->sb));
4058         if (IS_ERR(handle)) {
4059                 ret = PTR_ERR(handle);
4060                 mlog_errno(ret);
4061                 goto out;
4062         }
4063
4064         ret = dquot_alloc_space_nodirty(dir,
4065                                        ocfs2_clusters_to_bytes(osb->sb, 1));
4066         if (ret)
4067                 goto out_commit;
4068         did_quota = 1;
4069
4070         /*
4071          * We do this up front, before the allocation, so that a
4072          * failure to add the dx_root_bh to the journal won't result
4073          * us losing clusters.
4074          */
4075         ret = ocfs2_journal_access_dr(handle, INODE_CACHE(dir), dx_root_bh,
4076                                       OCFS2_JOURNAL_ACCESS_WRITE);
4077         if (ret) {
4078                 mlog_errno(ret);
4079                 goto out_commit;
4080         }
4081
4082         ret = __ocfs2_dx_dir_new_cluster(dir, 0, handle, data_ac, dx_leaves,
4083                                          num_dx_leaves, &insert_blkno);
4084         if (ret) {
4085                 mlog_errno(ret);
4086                 goto out_commit;
4087         }
4088
4089         /*
4090          * Transfer the entries from our dx_root into the appropriate
4091          * block
4092          */
4093         dx_root = (struct ocfs2_dx_root_block *) dx_root_bh->b_data;
4094         entry_list = &dx_root->dr_entries;
4095
4096         for (i = 0; i < le16_to_cpu(entry_list->de_num_used); i++) {
4097                 dx_entry = &entry_list->de_entries[i];
4098
4099                 j = __ocfs2_dx_dir_hash_idx(osb,
4100                                             le32_to_cpu(dx_entry->dx_minor_hash));
4101                 target_leaf = (struct ocfs2_dx_leaf *)dx_leaves[j]->b_data;
4102
4103                 ocfs2_dx_dir_leaf_insert_tail(target_leaf, dx_entry);
4104
4105                 /* Each leaf has been passed to the journal already
4106                  * via __ocfs2_dx_dir_new_cluster() */
4107         }
4108
4109         dx_root->dr_flags &= ~OCFS2_DX_FLAG_INLINE;
4110         memset(&dx_root->dr_list, 0, osb->sb->s_blocksize -
4111                offsetof(struct ocfs2_dx_root_block, dr_list));
4112         dx_root->dr_list.l_count =
4113                 cpu_to_le16(ocfs2_extent_recs_per_dx_root(osb->sb));
4114
4115         /* This should never fail considering we start with an empty
4116          * dx_root. */
4117         ocfs2_init_dx_root_extent_tree(&et, INODE_CACHE(dir), dx_root_bh);
4118         ret = ocfs2_insert_extent(handle, &et, 0, insert_blkno, 1, 0, NULL);
4119         if (ret)
4120                 mlog_errno(ret);
4121         did_quota = 0;
4122
4123         ocfs2_update_inode_fsync_trans(handle, dir, 1);
4124         ocfs2_journal_dirty(handle, dx_root_bh);
4125
4126 out_commit:
4127         if (ret < 0 && did_quota)
4128                 dquot_free_space_nodirty(dir,
4129                                           ocfs2_clusters_to_bytes(dir->i_sb, 1));
4130
4131         ocfs2_commit_trans(osb, handle);
4132
4133 out:
4134         if (data_ac)
4135                 ocfs2_free_alloc_context(data_ac);
4136
4137         if (dx_leaves) {
4138                 for (i = 0; i < num_dx_leaves; i++)
4139                         brelse(dx_leaves[i]);
4140                 kfree(dx_leaves);
4141         }
4142         return ret;
4143 }
4144
4145 static int ocfs2_inline_dx_has_space(struct buffer_head *dx_root_bh)
4146 {
4147         struct ocfs2_dx_root_block *dx_root;
4148         struct ocfs2_dx_entry_list *entry_list;
4149
4150         dx_root = (struct ocfs2_dx_root_block *) dx_root_bh->b_data;
4151         entry_list = &dx_root->dr_entries;
4152
4153         if (le16_to_cpu(entry_list->de_num_used) >=
4154             le16_to_cpu(entry_list->de_count))
4155                 return -ENOSPC;
4156
4157         return 0;
4158 }
4159
4160 static int ocfs2_prepare_dx_dir_for_insert(struct inode *dir,
4161                                            struct buffer_head *di_bh,
4162                                            const char *name,
4163                                            int namelen,
4164                                            struct ocfs2_dir_lookup_result *lookup)
4165 {
4166         int ret, free_dx_root = 1;
4167         struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
4168         struct buffer_head *dx_root_bh = NULL;
4169         struct buffer_head *leaf_bh = NULL;
4170         struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
4171         struct ocfs2_dx_root_block *dx_root;
4172
4173         ret = ocfs2_read_dx_root(dir, di, &dx_root_bh);
4174         if (ret) {
4175                 mlog_errno(ret);
4176                 goto out;
4177         }
4178
4179         dx_root = (struct ocfs2_dx_root_block *)dx_root_bh->b_data;
4180         if (le32_to_cpu(dx_root->dr_num_entries) == OCFS2_DX_ENTRIES_MAX) {
4181                 ret = -ENOSPC;
4182                 mlog_errno(ret);
4183                 goto out;
4184         }
4185
4186         if (ocfs2_dx_root_inline(dx_root)) {
4187                 ret = ocfs2_inline_dx_has_space(dx_root_bh);
4188
4189                 if (ret == 0)
4190                         goto search_el;
4191
4192                 /*
4193                  * We ran out of room in the root block. Expand it to
4194                  * an extent, then allow ocfs2_find_dir_space_dx to do
4195                  * the rest.
4196                  */
4197                 ret = ocfs2_expand_inline_dx_root(dir, dx_root_bh);
4198                 if (ret) {
4199                         mlog_errno(ret);
4200                         goto out;
4201                 }
4202         }
4203
4204         /*
4205          * Insert preparation for an indexed directory is split into two
4206          * steps. The call to find_dir_space_dx reserves room in the index for
4207          * an additional item. If we run out of space there, it's a real error
4208          * we can't continue on.
4209          */
4210         ret = ocfs2_find_dir_space_dx(osb, dir, di_bh, dx_root_bh, name,
4211                                       namelen, lookup);
4212         if (ret) {
4213                 mlog_errno(ret);
4214                 goto out;
4215         }
4216
4217 search_el:
4218         /*
4219          * Next, we need to find space in the unindexed tree. This call
4220          * searches using the free space linked list. If the unindexed tree
4221          * lacks sufficient space, we'll expand it below. The expansion code
4222          * is smart enough to add any new blocks to the free space list.
4223          */
4224         ret = ocfs2_search_dx_free_list(dir, dx_root_bh, namelen, lookup);
4225         if (ret && ret != -ENOSPC) {
4226                 mlog_errno(ret);
4227                 goto out;
4228         }
4229
4230         /* Do this up here - ocfs2_extend_dir might need the dx_root */
4231         lookup->dl_dx_root_bh = dx_root_bh;
4232         free_dx_root = 0;
4233
4234         if (ret == -ENOSPC) {
4235                 ret = ocfs2_extend_dir(osb, dir, di_bh, 1, lookup, &leaf_bh);
4236
4237                 if (ret) {
4238                         mlog_errno(ret);
4239                         goto out;
4240                 }
4241
4242                 /*
4243                  * We make the assumption here that new leaf blocks are added
4244                  * to the front of our free list.
4245                  */
4246                 lookup->dl_prev_leaf_bh = NULL;
4247                 lookup->dl_leaf_bh = leaf_bh;
4248         }
4249
4250 out:
4251         if (free_dx_root)
4252                 brelse(dx_root_bh);
4253         return ret;
4254 }
4255
4256 /*
4257  * Get a directory ready for insert. Any directory allocation required
4258  * happens here. Success returns zero, and enough context in the dir
4259  * lookup result that ocfs2_add_entry() will be able complete the task
4260  * with minimal performance impact.
4261  */
4262 int ocfs2_prepare_dir_for_insert(struct ocfs2_super *osb,
4263                                  struct inode *dir,
4264                                  struct buffer_head *parent_fe_bh,
4265                                  const char *name,
4266                                  int namelen,
4267                                  struct ocfs2_dir_lookup_result *lookup)
4268 {
4269         int ret;
4270         unsigned int blocks_wanted = 1;
4271         struct buffer_head *bh = NULL;
4272
4273         trace_ocfs2_prepare_dir_for_insert(
4274                 (unsigned long long)OCFS2_I(dir)->ip_blkno, namelen);
4275
4276         if (!namelen) {
4277                 ret = -EINVAL;
4278                 mlog_errno(ret);
4279                 goto out;
4280         }
4281
4282         /*
4283          * Do this up front to reduce confusion.
4284          *
4285          * The directory might start inline, then be turned into an
4286          * indexed one, in which case we'd need to hash deep inside
4287          * ocfs2_find_dir_space_id(). Since
4288          * ocfs2_prepare_dx_dir_for_insert() also needs this hash
4289          * done, there seems no point in spreading out the calls. We
4290          * can optimize away the case where the file system doesn't
4291          * support indexing.
4292          */
4293         if (ocfs2_supports_indexed_dirs(osb))
4294                 ocfs2_dx_dir_name_hash(dir, name, namelen, &lookup->dl_hinfo);
4295
4296         if (ocfs2_dir_indexed(dir)) {
4297                 ret = ocfs2_prepare_dx_dir_for_insert(dir, parent_fe_bh,
4298                                                       name, namelen, lookup);
4299                 if (ret)
4300                         mlog_errno(ret);
4301                 goto out;
4302         }
4303
4304         if (OCFS2_I(dir)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
4305                 ret = ocfs2_find_dir_space_id(dir, parent_fe_bh, name,
4306                                               namelen, &bh, &blocks_wanted);
4307         } else
4308                 ret = ocfs2_find_dir_space_el(dir, name, namelen, &bh);
4309
4310         if (ret && ret != -ENOSPC) {
4311                 mlog_errno(ret);
4312                 goto out;
4313         }
4314
4315         if (ret == -ENOSPC) {
4316                 /*
4317                  * We have to expand the directory to add this name.
4318                  */
4319                 BUG_ON(bh);
4320
4321                 ret = ocfs2_extend_dir(osb, dir, parent_fe_bh, blocks_wanted,
4322                                        lookup, &bh);
4323                 if (ret) {
4324                         if (ret != -ENOSPC)
4325                                 mlog_errno(ret);
4326                         goto out;
4327                 }
4328
4329                 BUG_ON(!bh);
4330         }
4331
4332         lookup->dl_leaf_bh = bh;
4333         bh = NULL;
4334 out:
4335         brelse(bh);
4336         return ret;
4337 }
4338
4339 static int ocfs2_dx_dir_remove_index(struct inode *dir,
4340                                      struct buffer_head *di_bh,
4341                                      struct buffer_head *dx_root_bh)
4342 {
4343         int ret;
4344         struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
4345         struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
4346         struct ocfs2_dx_root_block *dx_root;
4347         struct inode *dx_alloc_inode = NULL;
4348         struct buffer_head *dx_alloc_bh = NULL;
4349         handle_t *handle;
4350         u64 blk;
4351         u16 bit;
4352         u64 bg_blkno;
4353
4354         dx_root = (struct ocfs2_dx_root_block *) dx_root_bh->b_data;
4355
4356         dx_alloc_inode = ocfs2_get_system_file_inode(osb,
4357                                         EXTENT_ALLOC_SYSTEM_INODE,
4358                                         le16_to_cpu(dx_root->dr_suballoc_slot));
4359         if (!dx_alloc_inode) {
4360                 ret = -ENOMEM;
4361                 mlog_errno(ret);
4362                 goto out;
4363         }
4364         inode_lock(dx_alloc_inode);
4365
4366         ret = ocfs2_inode_lock(dx_alloc_inode, &dx_alloc_bh, 1);
4367         if (ret) {
4368                 mlog_errno(ret);
4369                 goto out_mutex;
4370         }
4371
4372         handle = ocfs2_start_trans(osb, OCFS2_DX_ROOT_REMOVE_CREDITS);
4373         if (IS_ERR(handle)) {
4374                 ret = PTR_ERR(handle);
4375                 mlog_errno(ret);
4376                 goto out_unlock;
4377         }
4378
4379         ret = ocfs2_journal_access_di(handle, INODE_CACHE(dir), di_bh,
4380                                       OCFS2_JOURNAL_ACCESS_WRITE);
4381         if (ret) {
4382                 mlog_errno(ret);
4383                 goto out_commit;
4384         }
4385
4386         spin_lock(&OCFS2_I(dir)->ip_lock);
4387         OCFS2_I(dir)->ip_dyn_features &= ~OCFS2_INDEXED_DIR_FL;
4388         di->i_dyn_features = cpu_to_le16(OCFS2_I(dir)->ip_dyn_features);
4389         spin_unlock(&OCFS2_I(dir)->ip_lock);
4390         di->i_dx_root = cpu_to_le64(0ULL);
4391         ocfs2_update_inode_fsync_trans(handle, dir, 1);
4392
4393         ocfs2_journal_dirty(handle, di_bh);
4394
4395         blk = le64_to_cpu(dx_root->dr_blkno);
4396         bit = le16_to_cpu(dx_root->dr_suballoc_bit);
4397         if (dx_root->dr_suballoc_loc)
4398                 bg_blkno = le64_to_cpu(dx_root->dr_suballoc_loc);
4399         else
4400                 bg_blkno = ocfs2_which_suballoc_group(blk, bit);
4401         ret = ocfs2_free_suballoc_bits(handle, dx_alloc_inode, dx_alloc_bh,
4402                                        bit, bg_blkno, 1);
4403         if (ret)
4404                 mlog_errno(ret);
4405
4406 out_commit:
4407         ocfs2_commit_trans(osb, handle);
4408
4409 out_unlock:
4410         ocfs2_inode_unlock(dx_alloc_inode, 1);
4411
4412 out_mutex:
4413         inode_unlock(dx_alloc_inode);
4414         brelse(dx_alloc_bh);
4415 out:
4416         iput(dx_alloc_inode);
4417         return ret;
4418 }
4419
4420 int ocfs2_dx_dir_truncate(struct inode *dir, struct buffer_head *di_bh)
4421 {
4422         int ret;
4423         unsigned int uninitialized_var(clen);
4424         u32 major_hash = UINT_MAX, p_cpos, uninitialized_var(cpos);
4425         u64 uninitialized_var(blkno);
4426         struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
4427         struct buffer_head *dx_root_bh = NULL;
4428         struct ocfs2_dx_root_block *dx_root;
4429         struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
4430         struct ocfs2_cached_dealloc_ctxt dealloc;
4431         struct ocfs2_extent_tree et;
4432
4433         ocfs2_init_dealloc_ctxt(&dealloc);
4434
4435         if (!ocfs2_dir_indexed(dir))
4436                 return 0;
4437
4438         ret = ocfs2_read_dx_root(dir, di, &dx_root_bh);
4439         if (ret) {
4440                 mlog_errno(ret);
4441                 goto out;
4442         }
4443         dx_root = (struct ocfs2_dx_root_block *)dx_root_bh->b_data;
4444
4445         if (ocfs2_dx_root_inline(dx_root))
4446                 goto remove_index;
4447
4448         ocfs2_init_dx_root_extent_tree(&et, INODE_CACHE(dir), dx_root_bh);
4449
4450         /* XXX: What if dr_clusters is too large? */
4451         while (le32_to_cpu(dx_root->dr_clusters)) {
4452                 ret = ocfs2_dx_dir_lookup_rec(dir, &dx_root->dr_list,
4453                                               major_hash, &cpos, &blkno, &clen);
4454                 if (ret) {
4455                         mlog_errno(ret);
4456                         goto out;
4457                 }
4458
4459                 p_cpos = ocfs2_blocks_to_clusters(dir->i_sb, blkno);
4460
4461                 ret = ocfs2_remove_btree_range(dir, &et, cpos, p_cpos, clen, 0,
4462                                                &dealloc, 0, false);
4463                 if (ret) {
4464                         mlog_errno(ret);
4465                         goto out;
4466                 }
4467
4468                 if (cpos == 0)
4469                         break;
4470
4471                 major_hash = cpos - 1;
4472         }
4473
4474 remove_index:
4475         ret = ocfs2_dx_dir_remove_index(dir, di_bh, dx_root_bh);
4476         if (ret) {
4477                 mlog_errno(ret);
4478                 goto out;
4479         }
4480
4481         ocfs2_remove_from_cache(INODE_CACHE(dir), dx_root_bh);
4482 out:
4483         ocfs2_schedule_truncate_log_flush(osb, 1);
4484         ocfs2_run_deallocs(osb, &dealloc);
4485
4486         brelse(dx_root_bh);
4487         return ret;
4488 }