blob: 6b0107f21344734f583ea103b56cc10bee7d6b74 [file] [log] [blame]
Mark Fashehccd979b2005-12-15 14:31:24 -08001/* -*- 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 Linux 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
44#define MLOG_MASK_PREFIX ML_NAMEI
45#include <cluster/masklog.h>
46
47#include "ocfs2.h"
48
49#include "alloc.h"
50#include "dir.h"
51#include "dlmglue.h"
52#include "extent_map.h"
53#include "file.h"
54#include "inode.h"
55#include "journal.h"
56#include "namei.h"
57#include "suballoc.h"
Mark Fasheh316f4b92007-09-07 18:21:26 -070058#include "super.h"
Mark Fashehccd979b2005-12-15 14:31:24 -080059#include "uptodate.h"
60
61#include "buffer_head_io.h"
62
Mark Fasheh316f4b92007-09-07 18:21:26 -070063#define NAMEI_RA_CHUNKS 2
64#define NAMEI_RA_BLOCKS 4
65#define NAMEI_RA_SIZE (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS)
66#define NAMEI_RA_INDEX(c,b) (((c) * NAMEI_RA_BLOCKS) + (b))
67
Mark Fashehccd979b2005-12-15 14:31:24 -080068static unsigned char ocfs2_filetype_table[] = {
69 DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
70};
71
72static int ocfs2_extend_dir(struct ocfs2_super *osb,
73 struct inode *dir,
74 struct buffer_head *parent_fe_bh,
Mark Fasheh5b6a3a22007-09-13 16:33:54 -070075 unsigned int blocks_wanted,
Mark Fashehccd979b2005-12-15 14:31:24 -080076 struct buffer_head **new_de_bh);
Mark Fasheh316f4b92007-09-07 18:21:26 -070077static int ocfs2_do_extend_dir(struct super_block *sb,
78 handle_t *handle,
79 struct inode *dir,
80 struct buffer_head *parent_fe_bh,
81 struct ocfs2_alloc_context *data_ac,
82 struct ocfs2_alloc_context *meta_ac,
83 struct buffer_head **new_bh);
84
Mark Fasheh23193e52007-09-12 13:01:18 -070085/*
86 * bh passed here can be an inode block or a dir data block, depending
87 * on the inode inline data flag.
88 */
Mark Fasheh5eae5b92007-09-10 17:50:51 -070089static int ocfs2_check_dir_entry(struct inode * dir,
90 struct ocfs2_dir_entry * de,
91 struct buffer_head * bh,
92 unsigned long offset)
Mark Fasheh316f4b92007-09-07 18:21:26 -070093{
94 const char *error_msg = NULL;
95 const int rlen = le16_to_cpu(de->rec_len);
96
97 if (rlen < OCFS2_DIR_REC_LEN(1))
98 error_msg = "rec_len is smaller than minimal";
99 else if (rlen % 4 != 0)
100 error_msg = "rec_len % 4 != 0";
101 else if (rlen < OCFS2_DIR_REC_LEN(de->name_len))
102 error_msg = "rec_len is too small for name_len";
103 else if (((char *) de - bh->b_data) + rlen > dir->i_sb->s_blocksize)
104 error_msg = "directory entry across blocks";
105
106 if (error_msg != NULL)
107 mlog(ML_ERROR, "bad entry in directory #%llu: %s - "
108 "offset=%lu, inode=%llu, rec_len=%d, name_len=%d\n",
109 (unsigned long long)OCFS2_I(dir)->ip_blkno, error_msg,
110 offset, (unsigned long long)le64_to_cpu(de->inode), rlen,
111 de->name_len);
112 return error_msg == NULL ? 1 : 0;
113}
114
115static inline int ocfs2_match(int len,
116 const char * const name,
117 struct ocfs2_dir_entry *de)
118{
119 if (len != de->name_len)
120 return 0;
121 if (!de->inode)
122 return 0;
123 return !memcmp(name, de->name, len);
124}
125
126/*
127 * Returns 0 if not found, -1 on failure, and 1 on success
128 */
129static int inline ocfs2_search_dirblock(struct buffer_head *bh,
130 struct inode *dir,
131 const char *name, int namelen,
132 unsigned long offset,
Mark Fasheh23193e52007-09-12 13:01:18 -0700133 char *first_de,
134 unsigned int bytes,
Mark Fasheh316f4b92007-09-07 18:21:26 -0700135 struct ocfs2_dir_entry **res_dir)
136{
137 struct ocfs2_dir_entry *de;
138 char *dlimit, *de_buf;
139 int de_len;
140 int ret = 0;
141
142 mlog_entry_void();
143
Mark Fasheh23193e52007-09-12 13:01:18 -0700144 de_buf = first_de;
145 dlimit = de_buf + bytes;
Mark Fasheh316f4b92007-09-07 18:21:26 -0700146
147 while (de_buf < dlimit) {
148 /* this code is executed quadratically often */
149 /* do minimal checking `by hand' */
150
151 de = (struct ocfs2_dir_entry *) de_buf;
152
153 if (de_buf + namelen <= dlimit &&
154 ocfs2_match(namelen, name, de)) {
155 /* found a match - just to be sure, do a full check */
156 if (!ocfs2_check_dir_entry(dir, de, bh, offset)) {
157 ret = -1;
158 goto bail;
159 }
160 *res_dir = de;
161 ret = 1;
162 goto bail;
163 }
164
165 /* prevent looping on a bad block */
166 de_len = le16_to_cpu(de->rec_len);
167 if (de_len <= 0) {
168 ret = -1;
169 goto bail;
170 }
171
172 de_buf += de_len;
173 offset += de_len;
174 }
175
176bail:
177 mlog_exit(ret);
178 return ret;
179}
180
Mark Fasheh23193e52007-09-12 13:01:18 -0700181static struct buffer_head *ocfs2_find_entry_id(const char *name,
182 int namelen,
183 struct inode *dir,
184 struct ocfs2_dir_entry **res_dir)
185{
186 int ret, found;
187 struct buffer_head *di_bh = NULL;
188 struct ocfs2_dinode *di;
189 struct ocfs2_inline_data *data;
190
191 ret = ocfs2_read_block(OCFS2_SB(dir->i_sb), OCFS2_I(dir)->ip_blkno,
192 &di_bh, OCFS2_BH_CACHED, dir);
193 if (ret) {
194 mlog_errno(ret);
195 goto out;
196 }
197
198 di = (struct ocfs2_dinode *)di_bh->b_data;
199 data = &di->id2.i_data;
200
201 found = ocfs2_search_dirblock(di_bh, dir, name, namelen, 0,
202 data->id_data, i_size_read(dir), res_dir);
203 if (found == 1)
204 return di_bh;
205
206 brelse(di_bh);
207out:
208 return NULL;
209}
210
Adrian Bunk0af4bd32007-10-24 18:23:27 +0200211static struct buffer_head *ocfs2_find_entry_el(const char *name, int namelen,
212 struct inode *dir,
213 struct ocfs2_dir_entry **res_dir)
Mark Fasheh316f4b92007-09-07 18:21:26 -0700214{
215 struct super_block *sb;
216 struct buffer_head *bh_use[NAMEI_RA_SIZE];
217 struct buffer_head *bh, *ret = NULL;
218 unsigned long start, block, b;
219 int ra_max = 0; /* Number of bh's in the readahead
220 buffer, bh_use[] */
221 int ra_ptr = 0; /* Current index into readahead
222 buffer */
223 int num = 0;
224 int nblocks, i, err;
225
226 mlog_entry_void();
227
Mark Fasheh316f4b92007-09-07 18:21:26 -0700228 sb = dir->i_sb;
229
230 nblocks = i_size_read(dir) >> sb->s_blocksize_bits;
231 start = OCFS2_I(dir)->ip_dir_start_lookup;
232 if (start >= nblocks)
233 start = 0;
234 block = start;
235
236restart:
237 do {
238 /*
239 * We deal with the read-ahead logic here.
240 */
241 if (ra_ptr >= ra_max) {
242 /* Refill the readahead buffer */
243 ra_ptr = 0;
244 b = block;
245 for (ra_max = 0; ra_max < NAMEI_RA_SIZE; ra_max++) {
246 /*
247 * Terminate if we reach the end of the
248 * directory and must wrap, or if our
249 * search has finished at this block.
250 */
251 if (b >= nblocks || (num && block == start)) {
252 bh_use[ra_max] = NULL;
253 break;
254 }
255 num++;
256
257 bh = ocfs2_bread(dir, b++, &err, 1);
258 bh_use[ra_max] = bh;
259 }
260 }
261 if ((bh = bh_use[ra_ptr++]) == NULL)
262 goto next;
263 wait_on_buffer(bh);
264 if (!buffer_uptodate(bh)) {
265 /* read error, skip block & hope for the best */
266 ocfs2_error(dir->i_sb, "reading directory %llu, "
267 "offset %lu\n",
268 (unsigned long long)OCFS2_I(dir)->ip_blkno,
269 block);
270 brelse(bh);
271 goto next;
272 }
273 i = ocfs2_search_dirblock(bh, dir, name, namelen,
274 block << sb->s_blocksize_bits,
Mark Fasheh23193e52007-09-12 13:01:18 -0700275 bh->b_data, sb->s_blocksize,
Mark Fasheh316f4b92007-09-07 18:21:26 -0700276 res_dir);
277 if (i == 1) {
278 OCFS2_I(dir)->ip_dir_start_lookup = block;
279 ret = bh;
280 goto cleanup_and_exit;
281 } else {
282 brelse(bh);
283 if (i < 0)
284 goto cleanup_and_exit;
285 }
286 next:
287 if (++block >= nblocks)
288 block = 0;
289 } while (block != start);
290
291 /*
292 * If the directory has grown while we were searching, then
293 * search the last part of the directory before giving up.
294 */
295 block = nblocks;
296 nblocks = i_size_read(dir) >> sb->s_blocksize_bits;
297 if (block < nblocks) {
298 start = 0;
299 goto restart;
300 }
301
302cleanup_and_exit:
303 /* Clean up the read-ahead blocks */
304 for (; ra_ptr < ra_max; ra_ptr++)
305 brelse(bh_use[ra_ptr]);
306
307 mlog_exit_ptr(ret);
308 return ret;
309}
310
Mark Fasheh23193e52007-09-12 13:01:18 -0700311/*
312 * Try to find an entry of the provided name within 'dir'.
313 *
314 * If nothing was found, NULL is returned. Otherwise, a buffer_head
315 * and pointer to the dir entry are passed back.
316 *
317 * Caller can NOT assume anything about the contents of the
318 * buffer_head - it is passed back only so that it can be passed into
319 * any one of the manipulation functions (add entry, delete entry,
320 * etc). As an example, bh in the extent directory case is a data
321 * block, in the inline-data case it actually points to an inode.
322 */
323struct buffer_head *ocfs2_find_entry(const char *name, int namelen,
324 struct inode *dir,
325 struct ocfs2_dir_entry **res_dir)
326{
327 *res_dir = NULL;
328
329 if (OCFS2_I(dir)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
330 return ocfs2_find_entry_id(name, namelen, dir, res_dir);
331
332 return ocfs2_find_entry_el(name, namelen, dir, res_dir);
333}
334
Mark Fasheh5b6a3a22007-09-13 16:33:54 -0700335/*
336 * Update inode number and type of a previously found directory entry.
337 */
Mark Fasheh38760e22007-09-11 17:21:56 -0700338int ocfs2_update_entry(struct inode *dir, handle_t *handle,
339 struct buffer_head *de_bh, struct ocfs2_dir_entry *de,
340 struct inode *new_entry_inode)
341{
342 int ret;
343
Mark Fasheh5b6a3a22007-09-13 16:33:54 -0700344 /*
345 * The same code works fine for both inline-data and extent
346 * based directories, so no need to split this up.
347 */
348
Mark Fasheh38760e22007-09-11 17:21:56 -0700349 ret = ocfs2_journal_access(handle, dir, de_bh,
350 OCFS2_JOURNAL_ACCESS_WRITE);
351 if (ret) {
352 mlog_errno(ret);
353 goto out;
354 }
355
356 de->inode = cpu_to_le64(OCFS2_I(new_entry_inode)->ip_blkno);
357 ocfs2_set_de_type(de, new_entry_inode->i_mode);
358
359 ocfs2_journal_dirty(handle, de_bh);
360
361out:
362 return ret;
363}
364
Mark Fasheh5b6a3a22007-09-13 16:33:54 -0700365static int __ocfs2_delete_entry(handle_t *handle, struct inode *dir,
366 struct ocfs2_dir_entry *de_del,
367 struct buffer_head *bh, char *first_de,
368 unsigned int bytes)
Mark Fasheh316f4b92007-09-07 18:21:26 -0700369{
370 struct ocfs2_dir_entry *de, *pde;
371 int i, status = -ENOENT;
372
373 mlog_entry("(0x%p, 0x%p, 0x%p, 0x%p)\n", handle, dir, de_del, bh);
374
375 i = 0;
376 pde = NULL;
Mark Fasheh5b6a3a22007-09-13 16:33:54 -0700377 de = (struct ocfs2_dir_entry *) first_de;
378 while (i < bytes) {
Mark Fasheh316f4b92007-09-07 18:21:26 -0700379 if (!ocfs2_check_dir_entry(dir, de, bh, i)) {
380 status = -EIO;
381 mlog_errno(status);
382 goto bail;
383 }
384 if (de == de_del) {
385 status = ocfs2_journal_access(handle, dir, bh,
386 OCFS2_JOURNAL_ACCESS_WRITE);
387 if (status < 0) {
388 status = -EIO;
389 mlog_errno(status);
390 goto bail;
391 }
392 if (pde)
393 pde->rec_len =
394 cpu_to_le16(le16_to_cpu(pde->rec_len) +
395 le16_to_cpu(de->rec_len));
396 else
397 de->inode = 0;
398 dir->i_version++;
399 status = ocfs2_journal_dirty(handle, bh);
400 goto bail;
401 }
402 i += le16_to_cpu(de->rec_len);
403 pde = de;
404 de = (struct ocfs2_dir_entry *)((char *)de + le16_to_cpu(de->rec_len));
405 }
406bail:
407 mlog_exit(status);
408 return status;
409}
410
Mark Fasheh5b6a3a22007-09-13 16:33:54 -0700411static inline int ocfs2_delete_entry_id(handle_t *handle,
412 struct inode *dir,
413 struct ocfs2_dir_entry *de_del,
414 struct buffer_head *bh)
415{
416 int ret;
417 struct buffer_head *di_bh = NULL;
418 struct ocfs2_dinode *di;
419 struct ocfs2_inline_data *data;
420
421 ret = ocfs2_read_block(OCFS2_SB(dir->i_sb), OCFS2_I(dir)->ip_blkno,
422 &di_bh, OCFS2_BH_CACHED, dir);
423 if (ret) {
424 mlog_errno(ret);
425 goto out;
426 }
427
428 di = (struct ocfs2_dinode *)di_bh->b_data;
429 data = &di->id2.i_data;
430
431 ret = __ocfs2_delete_entry(handle, dir, de_del, bh, data->id_data,
432 i_size_read(dir));
433
434 brelse(di_bh);
435out:
436 return ret;
437}
438
439static inline int ocfs2_delete_entry_el(handle_t *handle,
440 struct inode *dir,
441 struct ocfs2_dir_entry *de_del,
442 struct buffer_head *bh)
443{
444 return __ocfs2_delete_entry(handle, dir, de_del, bh, bh->b_data,
445 bh->b_size);
446}
447
448/*
449 * ocfs2_delete_entry deletes a directory entry by merging it with the
450 * previous entry
451 */
452int ocfs2_delete_entry(handle_t *handle,
453 struct inode *dir,
454 struct ocfs2_dir_entry *de_del,
455 struct buffer_head *bh)
456{
457 if (OCFS2_I(dir)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
458 return ocfs2_delete_entry_id(handle, dir, de_del, bh);
459
460 return ocfs2_delete_entry_el(handle, dir, de_del, bh);
461}
462
Mark Fasheh8553cf42007-09-13 16:29:01 -0700463/*
464 * Check whether 'de' has enough room to hold an entry of
465 * 'new_rec_len' bytes.
466 */
467static inline int ocfs2_dirent_would_fit(struct ocfs2_dir_entry *de,
468 unsigned int new_rec_len)
469{
470 unsigned int de_really_used;
471
472 /* Check whether this is an empty record with enough space */
473 if (le64_to_cpu(de->inode) == 0 &&
474 le16_to_cpu(de->rec_len) >= new_rec_len)
475 return 1;
476
477 /*
478 * Record might have free space at the end which we can
479 * use.
480 */
481 de_really_used = OCFS2_DIR_REC_LEN(de->name_len);
482 if (le16_to_cpu(de->rec_len) >= (de_really_used + new_rec_len))
483 return 1;
484
485 return 0;
486}
487
Mark Fasheh316f4b92007-09-07 18:21:26 -0700488/* we don't always have a dentry for what we want to add, so people
489 * like orphan dir can call this instead.
490 *
491 * If you pass me insert_bh, I'll skip the search of the other dir
492 * blocks and put the record in there.
493 */
494int __ocfs2_add_entry(handle_t *handle,
495 struct inode *dir,
496 const char *name, int namelen,
497 struct inode *inode, u64 blkno,
498 struct buffer_head *parent_fe_bh,
499 struct buffer_head *insert_bh)
500{
501 unsigned long offset;
502 unsigned short rec_len;
503 struct ocfs2_dir_entry *de, *de1;
Mark Fasheh5b6a3a22007-09-13 16:33:54 -0700504 struct ocfs2_dinode *di = (struct ocfs2_dinode *)parent_fe_bh->b_data;
505 struct super_block *sb = dir->i_sb;
Mark Fasheh316f4b92007-09-07 18:21:26 -0700506 int retval, status;
Mark Fasheh5b6a3a22007-09-13 16:33:54 -0700507 unsigned int size = sb->s_blocksize;
508 char *data_start = insert_bh->b_data;
Mark Fasheh316f4b92007-09-07 18:21:26 -0700509
510 mlog_entry_void();
511
Mark Fasheh316f4b92007-09-07 18:21:26 -0700512 if (!namelen)
513 return -EINVAL;
514
Mark Fasheh5b6a3a22007-09-13 16:33:54 -0700515 if (OCFS2_I(dir)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
516 data_start = di->id2.i_data.id_data;
517 size = i_size_read(dir);
518
519 BUG_ON(insert_bh != parent_fe_bh);
520 }
521
Mark Fasheh316f4b92007-09-07 18:21:26 -0700522 rec_len = OCFS2_DIR_REC_LEN(namelen);
523 offset = 0;
Mark Fasheh5b6a3a22007-09-13 16:33:54 -0700524 de = (struct ocfs2_dir_entry *) data_start;
Mark Fasheh316f4b92007-09-07 18:21:26 -0700525 while (1) {
Mark Fasheh5b6a3a22007-09-13 16:33:54 -0700526 BUG_ON((char *)de >= (size + data_start));
527
Mark Fasheh316f4b92007-09-07 18:21:26 -0700528 /* These checks should've already been passed by the
529 * prepare function, but I guess we can leave them
530 * here anyway. */
531 if (!ocfs2_check_dir_entry(dir, de, insert_bh, offset)) {
532 retval = -ENOENT;
533 goto bail;
534 }
535 if (ocfs2_match(namelen, name, de)) {
536 retval = -EEXIST;
537 goto bail;
538 }
Mark Fasheh8553cf42007-09-13 16:29:01 -0700539
540 if (ocfs2_dirent_would_fit(de, rec_len)) {
Mark Fasheh316f4b92007-09-07 18:21:26 -0700541 dir->i_mtime = dir->i_ctime = CURRENT_TIME;
542 retval = ocfs2_mark_inode_dirty(handle, dir, parent_fe_bh);
543 if (retval < 0) {
544 mlog_errno(retval);
545 goto bail;
546 }
547
548 status = ocfs2_journal_access(handle, dir, insert_bh,
549 OCFS2_JOURNAL_ACCESS_WRITE);
550 /* By now the buffer is marked for journaling */
551 offset += le16_to_cpu(de->rec_len);
552 if (le64_to_cpu(de->inode)) {
553 de1 = (struct ocfs2_dir_entry *)((char *) de +
554 OCFS2_DIR_REC_LEN(de->name_len));
555 de1->rec_len =
556 cpu_to_le16(le16_to_cpu(de->rec_len) -
557 OCFS2_DIR_REC_LEN(de->name_len));
558 de->rec_len = cpu_to_le16(OCFS2_DIR_REC_LEN(de->name_len));
559 de = de1;
560 }
561 de->file_type = OCFS2_FT_UNKNOWN;
562 if (blkno) {
563 de->inode = cpu_to_le64(blkno);
564 ocfs2_set_de_type(de, inode->i_mode);
565 } else
566 de->inode = 0;
567 de->name_len = namelen;
568 memcpy(de->name, name, namelen);
569
570 dir->i_version++;
571 status = ocfs2_journal_dirty(handle, insert_bh);
572 retval = 0;
573 goto bail;
574 }
575 offset += le16_to_cpu(de->rec_len);
576 de = (struct ocfs2_dir_entry *) ((char *) de + le16_to_cpu(de->rec_len));
577 }
578
579 /* when you think about it, the assert above should prevent us
580 * from ever getting here. */
581 retval = -ENOSPC;
582bail:
583
584 mlog_exit(retval);
585 return retval;
586}
587
Mark Fasheh23193e52007-09-12 13:01:18 -0700588static int ocfs2_dir_foreach_blk_id(struct inode *inode,
Mathieu Desnoyers2b47c362007-10-16 23:27:21 -0700589 u64 *f_version,
Mark Fasheh23193e52007-09-12 13:01:18 -0700590 loff_t *f_pos, void *priv,
Mark Fashehe7b34012007-09-24 14:25:27 -0700591 filldir_t filldir, int *filldir_err)
Mark Fasheh23193e52007-09-12 13:01:18 -0700592{
593 int ret, i, filldir_ret;
594 unsigned long offset = *f_pos;
595 struct buffer_head *di_bh = NULL;
596 struct ocfs2_dinode *di;
597 struct ocfs2_inline_data *data;
598 struct ocfs2_dir_entry *de;
599
600 ret = ocfs2_read_block(OCFS2_SB(inode->i_sb), OCFS2_I(inode)->ip_blkno,
601 &di_bh, OCFS2_BH_CACHED, inode);
602 if (ret) {
603 mlog(ML_ERROR, "Unable to read inode block for dir %llu\n",
604 (unsigned long long)OCFS2_I(inode)->ip_blkno);
605 goto out;
606 }
607
608 di = (struct ocfs2_dinode *)di_bh->b_data;
609 data = &di->id2.i_data;
610
611 while (*f_pos < i_size_read(inode)) {
612revalidate:
613 /* If the dir block has changed since the last call to
614 * readdir(2), then we might be pointing to an invalid
615 * dirent right now. Scan from the start of the block
616 * to make sure. */
617 if (*f_version != inode->i_version) {
618 for (i = 0; i < i_size_read(inode) && i < offset; ) {
619 de = (struct ocfs2_dir_entry *)
620 (data->id_data + i);
621 /* It's too expensive to do a full
622 * dirent test each time round this
623 * loop, but we do have to test at
624 * least that it is non-zero. A
625 * failure will be detected in the
626 * dirent test below. */
627 if (le16_to_cpu(de->rec_len) <
628 OCFS2_DIR_REC_LEN(1))
629 break;
630 i += le16_to_cpu(de->rec_len);
631 }
632 *f_pos = offset = i;
633 *f_version = inode->i_version;
634 }
635
636 de = (struct ocfs2_dir_entry *) (data->id_data + *f_pos);
637 if (!ocfs2_check_dir_entry(inode, de, di_bh, *f_pos)) {
638 /* On error, skip the f_pos to the end. */
639 *f_pos = i_size_read(inode);
640 goto out;
641 }
642 offset += le16_to_cpu(de->rec_len);
643 if (le64_to_cpu(de->inode)) {
644 /* We might block in the next section
645 * if the data destination is
646 * currently swapped out. So, use a
647 * version stamp to detect whether or
648 * not the directory has been modified
649 * during the copy operation.
650 */
Mathieu Desnoyers2b47c362007-10-16 23:27:21 -0700651 u64 version = *f_version;
Mark Fasheh23193e52007-09-12 13:01:18 -0700652 unsigned char d_type = DT_UNKNOWN;
653
654 if (de->file_type < OCFS2_FT_MAX)
655 d_type = ocfs2_filetype_table[de->file_type];
656
657 filldir_ret = filldir(priv, de->name,
658 de->name_len,
659 *f_pos,
660 le64_to_cpu(de->inode),
661 d_type);
Mark Fashehe7b34012007-09-24 14:25:27 -0700662 if (filldir_ret) {
663 if (filldir_err)
664 *filldir_err = filldir_ret;
Mark Fasheh23193e52007-09-12 13:01:18 -0700665 break;
Mark Fashehe7b34012007-09-24 14:25:27 -0700666 }
Mark Fasheh23193e52007-09-12 13:01:18 -0700667 if (version != *f_version)
668 goto revalidate;
669 }
670 *f_pos += le16_to_cpu(de->rec_len);
671 }
672
673out:
674 brelse(di_bh);
675
676 return 0;
677}
678
679static int ocfs2_dir_foreach_blk_el(struct inode *inode,
Mathieu Desnoyers2b47c362007-10-16 23:27:21 -0700680 u64 *f_version,
Mark Fasheh23193e52007-09-12 13:01:18 -0700681 loff_t *f_pos, void *priv,
Mark Fashehe7b34012007-09-24 14:25:27 -0700682 filldir_t filldir, int *filldir_err)
Mark Fashehccd979b2005-12-15 14:31:24 -0800683{
684 int error = 0;
Mark Fashehaa958872006-04-21 13:49:02 -0700685 unsigned long offset, blk, last_ra_blk = 0;
686 int i, stored;
Mark Fashehccd979b2005-12-15 14:31:24 -0800687 struct buffer_head * bh, * tmp;
688 struct ocfs2_dir_entry * de;
689 int err;
Mark Fashehccd979b2005-12-15 14:31:24 -0800690 struct super_block * sb = inode->i_sb;
Mark Fashehaa958872006-04-21 13:49:02 -0700691 unsigned int ra_sectors = 16;
Mark Fashehccd979b2005-12-15 14:31:24 -0800692
693 stored = 0;
694 bh = NULL;
695
Mark Fashehb8bc5f42007-09-10 17:17:52 -0700696 offset = (*f_pos) & (sb->s_blocksize - 1);
Mark Fashehccd979b2005-12-15 14:31:24 -0800697
Mark Fashehb8bc5f42007-09-10 17:17:52 -0700698 while (!error && !stored && *f_pos < i_size_read(inode)) {
699 blk = (*f_pos) >> sb->s_blocksize_bits;
Mark Fashehccd979b2005-12-15 14:31:24 -0800700 bh = ocfs2_bread(inode, blk, &err, 0);
701 if (!bh) {
Mark Fashehb06970532006-03-03 10:24:33 -0800702 mlog(ML_ERROR,
703 "directory #%llu contains a hole at offset %lld\n",
704 (unsigned long long)OCFS2_I(inode)->ip_blkno,
Mark Fashehb8bc5f42007-09-10 17:17:52 -0700705 *f_pos);
706 *f_pos += sb->s_blocksize - offset;
Mark Fashehccd979b2005-12-15 14:31:24 -0800707 continue;
708 }
709
Mark Fashehaa958872006-04-21 13:49:02 -0700710 /* The idea here is to begin with 8k read-ahead and to stay
711 * 4k ahead of our current position.
712 *
713 * TODO: Use the pagecache for this. We just need to
714 * make sure it's cluster-safe... */
715 if (!last_ra_blk
716 || (((last_ra_blk - blk) << 9) <= (ra_sectors / 2))) {
717 for (i = ra_sectors >> (sb->s_blocksize_bits - 9);
Mark Fashehccd979b2005-12-15 14:31:24 -0800718 i > 0; i--) {
719 tmp = ocfs2_bread(inode, ++blk, &err, 1);
720 if (tmp)
721 brelse(tmp);
722 }
Mark Fashehaa958872006-04-21 13:49:02 -0700723 last_ra_blk = blk;
724 ra_sectors = 8;
Mark Fashehccd979b2005-12-15 14:31:24 -0800725 }
726
727revalidate:
728 /* If the dir block has changed since the last call to
729 * readdir(2), then we might be pointing to an invalid
730 * dirent right now. Scan from the start of the block
731 * to make sure. */
Mark Fashehb8bc5f42007-09-10 17:17:52 -0700732 if (*f_version != inode->i_version) {
Mark Fashehccd979b2005-12-15 14:31:24 -0800733 for (i = 0; i < sb->s_blocksize && i < offset; ) {
734 de = (struct ocfs2_dir_entry *) (bh->b_data + i);
735 /* It's too expensive to do a full
736 * dirent test each time round this
737 * loop, but we do have to test at
738 * least that it is non-zero. A
739 * failure will be detected in the
740 * dirent test below. */
741 if (le16_to_cpu(de->rec_len) <
742 OCFS2_DIR_REC_LEN(1))
743 break;
744 i += le16_to_cpu(de->rec_len);
745 }
746 offset = i;
Mark Fashehb8bc5f42007-09-10 17:17:52 -0700747 *f_pos = ((*f_pos) & ~(sb->s_blocksize - 1))
Mark Fashehccd979b2005-12-15 14:31:24 -0800748 | offset;
Mark Fashehb8bc5f42007-09-10 17:17:52 -0700749 *f_version = inode->i_version;
Mark Fashehccd979b2005-12-15 14:31:24 -0800750 }
751
Mark Fashehb8bc5f42007-09-10 17:17:52 -0700752 while (!error && *f_pos < i_size_read(inode)
Mark Fashehccd979b2005-12-15 14:31:24 -0800753 && offset < sb->s_blocksize) {
754 de = (struct ocfs2_dir_entry *) (bh->b_data + offset);
755 if (!ocfs2_check_dir_entry(inode, de, bh, offset)) {
756 /* On error, skip the f_pos to the
757 next block. */
Mark Fashehb8bc5f42007-09-10 17:17:52 -0700758 *f_pos = ((*f_pos) | (sb->s_blocksize - 1)) + 1;
Mark Fashehccd979b2005-12-15 14:31:24 -0800759 brelse(bh);
Mark Fashehb8bc5f42007-09-10 17:17:52 -0700760 goto out;
Mark Fashehccd979b2005-12-15 14:31:24 -0800761 }
762 offset += le16_to_cpu(de->rec_len);
763 if (le64_to_cpu(de->inode)) {
764 /* We might block in the next section
765 * if the data destination is
766 * currently swapped out. So, use a
767 * version stamp to detect whether or
768 * not the directory has been modified
769 * during the copy operation.
770 */
Mark Fashehb8bc5f42007-09-10 17:17:52 -0700771 unsigned long version = *f_version;
Mark Fashehccd979b2005-12-15 14:31:24 -0800772 unsigned char d_type = DT_UNKNOWN;
773
774 if (de->file_type < OCFS2_FT_MAX)
775 d_type = ocfs2_filetype_table[de->file_type];
Mark Fashehb8bc5f42007-09-10 17:17:52 -0700776 error = filldir(priv, de->name,
Mark Fashehccd979b2005-12-15 14:31:24 -0800777 de->name_len,
Mark Fashehb8bc5f42007-09-10 17:17:52 -0700778 *f_pos,
Mark Fasheh7e853672007-09-10 17:30:26 -0700779 le64_to_cpu(de->inode),
Mark Fashehccd979b2005-12-15 14:31:24 -0800780 d_type);
Mark Fashehe7b34012007-09-24 14:25:27 -0700781 if (error) {
782 if (filldir_err)
783 *filldir_err = error;
Mark Fashehccd979b2005-12-15 14:31:24 -0800784 break;
Mark Fashehe7b34012007-09-24 14:25:27 -0700785 }
Mark Fashehb8bc5f42007-09-10 17:17:52 -0700786 if (version != *f_version)
Mark Fashehccd979b2005-12-15 14:31:24 -0800787 goto revalidate;
788 stored ++;
789 }
Mark Fashehb8bc5f42007-09-10 17:17:52 -0700790 *f_pos += le16_to_cpu(de->rec_len);
Mark Fashehccd979b2005-12-15 14:31:24 -0800791 }
792 offset = 0;
793 brelse(bh);
794 }
795
796 stored = 0;
Mark Fashehb8bc5f42007-09-10 17:17:52 -0700797out:
798 return stored;
799}
800
Mathieu Desnoyers2b47c362007-10-16 23:27:21 -0700801static int ocfs2_dir_foreach_blk(struct inode *inode, u64 *f_version,
Mark Fashehe7b34012007-09-24 14:25:27 -0700802 loff_t *f_pos, void *priv, filldir_t filldir,
803 int *filldir_err)
Mark Fasheh23193e52007-09-12 13:01:18 -0700804{
805 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
806 return ocfs2_dir_foreach_blk_id(inode, f_version, f_pos, priv,
Mark Fashehe7b34012007-09-24 14:25:27 -0700807 filldir, filldir_err);
Mark Fasheh23193e52007-09-12 13:01:18 -0700808
Mark Fashehe7b34012007-09-24 14:25:27 -0700809 return ocfs2_dir_foreach_blk_el(inode, f_version, f_pos, priv, filldir,
810 filldir_err);
Mark Fasheh23193e52007-09-12 13:01:18 -0700811}
812
Mark Fashehb8bc5f42007-09-10 17:17:52 -0700813/*
Mark Fasheh5eae5b92007-09-10 17:50:51 -0700814 * This is intended to be called from inside other kernel functions,
815 * so we fake some arguments.
816 */
817int ocfs2_dir_foreach(struct inode *inode, loff_t *f_pos, void *priv,
818 filldir_t filldir)
819{
Mark Fashehe7b34012007-09-24 14:25:27 -0700820 int ret = 0, filldir_err = 0;
Mathieu Desnoyers2b47c362007-10-16 23:27:21 -0700821 u64 version = inode->i_version;
Mark Fasheh5eae5b92007-09-10 17:50:51 -0700822
823 while (*f_pos < i_size_read(inode)) {
824 ret = ocfs2_dir_foreach_blk(inode, &version, f_pos, priv,
Mark Fashehe7b34012007-09-24 14:25:27 -0700825 filldir, &filldir_err);
826 if (ret || filldir_err)
Mark Fasheh5eae5b92007-09-10 17:50:51 -0700827 break;
828 }
829
Mark Fashehe7b34012007-09-24 14:25:27 -0700830 if (ret > 0)
831 ret = -EIO;
832
Mark Fasheh5eae5b92007-09-10 17:50:51 -0700833 return 0;
834}
835
836/*
Mark Fashehb8bc5f42007-09-10 17:17:52 -0700837 * ocfs2_readdir()
838 *
839 */
840int ocfs2_readdir(struct file * filp, void * dirent, filldir_t filldir)
841{
842 int error = 0;
843 struct inode *inode = filp->f_path.dentry->d_inode;
844 int lock_level = 0;
845
846 mlog_entry("dirino=%llu\n",
847 (unsigned long long)OCFS2_I(inode)->ip_blkno);
848
Mark Fashehe63aecb62007-10-18 15:30:42 -0700849 error = ocfs2_inode_lock_atime(inode, filp->f_vfsmnt, &lock_level);
Mark Fashehb8bc5f42007-09-10 17:17:52 -0700850 if (lock_level && error >= 0) {
851 /* We release EX lock which used to update atime
852 * and get PR lock again to reduce contention
853 * on commonly accessed directories. */
Mark Fashehe63aecb62007-10-18 15:30:42 -0700854 ocfs2_inode_unlock(inode, 1);
Mark Fashehb8bc5f42007-09-10 17:17:52 -0700855 lock_level = 0;
Mark Fashehe63aecb62007-10-18 15:30:42 -0700856 error = ocfs2_inode_lock(inode, NULL, 0);
Mark Fashehb8bc5f42007-09-10 17:17:52 -0700857 }
858 if (error < 0) {
859 if (error != -ENOENT)
860 mlog_errno(error);
861 /* we haven't got any yet, so propagate the error. */
862 goto bail_nolock;
863 }
864
865 error = ocfs2_dir_foreach_blk(inode, &filp->f_version, &filp->f_pos,
Mark Fashehe7b34012007-09-24 14:25:27 -0700866 dirent, filldir, NULL);
Mark Fashehb8bc5f42007-09-10 17:17:52 -0700867
Mark Fashehe63aecb62007-10-18 15:30:42 -0700868 ocfs2_inode_unlock(inode, lock_level);
Mark Fashehccd979b2005-12-15 14:31:24 -0800869
Mark Fashehaa958872006-04-21 13:49:02 -0700870bail_nolock:
Mark Fashehb8bc5f42007-09-10 17:17:52 -0700871 mlog_exit(error);
Mark Fashehccd979b2005-12-15 14:31:24 -0800872
Mark Fashehb8bc5f42007-09-10 17:17:52 -0700873 return error;
Mark Fashehccd979b2005-12-15 14:31:24 -0800874}
875
876/*
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800877 * NOTE: this should always be called with parent dir i_mutex taken.
Mark Fashehccd979b2005-12-15 14:31:24 -0800878 */
879int ocfs2_find_files_on_disk(const char *name,
880 int namelen,
881 u64 *blkno,
882 struct inode *inode,
883 struct buffer_head **dirent_bh,
884 struct ocfs2_dir_entry **dirent)
885{
886 int status = -ENOENT;
Mark Fashehccd979b2005-12-15 14:31:24 -0800887
Joel Becker2b388c62006-05-10 18:28:59 -0700888 mlog_entry("(name=%.*s, blkno=%p, inode=%p, dirent_bh=%p, dirent=%p)\n",
889 namelen, name, blkno, inode, dirent_bh, dirent);
Mark Fashehccd979b2005-12-15 14:31:24 -0800890
891 *dirent_bh = ocfs2_find_entry(name, namelen, inode, dirent);
892 if (!*dirent_bh || !*dirent) {
893 status = -ENOENT;
894 goto leave;
895 }
896
897 *blkno = le64_to_cpu((*dirent)->inode);
898
899 status = 0;
900leave:
901 if (status < 0) {
902 *dirent = NULL;
903 if (*dirent_bh) {
904 brelse(*dirent_bh);
905 *dirent_bh = NULL;
906 }
907 }
908
909 mlog_exit(status);
910 return status;
911}
912
Mark Fashehbe94d112007-09-11 15:22:06 -0700913/*
914 * Convenience function for callers which just want the block number
915 * mapped to a name and don't require the full dirent info, etc.
916 */
917int ocfs2_lookup_ino_from_name(struct inode *dir, const char *name,
918 int namelen, u64 *blkno)
919{
920 int ret;
921 struct buffer_head *bh = NULL;
922 struct ocfs2_dir_entry *dirent = NULL;
923
924 ret = ocfs2_find_files_on_disk(name, namelen, blkno, dir, &bh, &dirent);
925 brelse(bh);
926
927 return ret;
928}
929
Mark Fashehccd979b2005-12-15 14:31:24 -0800930/* Check for a name within a directory.
931 *
932 * Return 0 if the name does not exist
933 * Return -EEXIST if the directory contains the name
934 *
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800935 * Callers should have i_mutex + a cluster lock on dir
Mark Fashehccd979b2005-12-15 14:31:24 -0800936 */
937int ocfs2_check_dir_for_entry(struct inode *dir,
938 const char *name,
939 int namelen)
940{
941 int ret;
942 struct buffer_head *dirent_bh = NULL;
943 struct ocfs2_dir_entry *dirent = NULL;
944
Mark Fashehb06970532006-03-03 10:24:33 -0800945 mlog_entry("dir %llu, name '%.*s'\n",
946 (unsigned long long)OCFS2_I(dir)->ip_blkno, namelen, name);
Mark Fashehccd979b2005-12-15 14:31:24 -0800947
948 ret = -EEXIST;
949 dirent_bh = ocfs2_find_entry(name, namelen, dir, &dirent);
950 if (dirent_bh)
951 goto bail;
952
953 ret = 0;
954bail:
955 if (dirent_bh)
956 brelse(dirent_bh);
957
958 mlog_exit(ret);
959 return ret;
960}
961
Mark Fasheh0bfbbf62007-09-12 11:19:00 -0700962struct ocfs2_empty_dir_priv {
963 unsigned seen_dot;
964 unsigned seen_dot_dot;
965 unsigned seen_other;
966};
967static int ocfs2_empty_dir_filldir(void *priv, const char *name, int name_len,
968 loff_t pos, u64 ino, unsigned type)
969{
970 struct ocfs2_empty_dir_priv *p = priv;
971
972 /*
973 * Check the positions of "." and ".." records to be sure
974 * they're in the correct place.
975 */
976 if (name_len == 1 && !strncmp(".", name, 1) && pos == 0) {
977 p->seen_dot = 1;
978 return 0;
979 }
980
981 if (name_len == 2 && !strncmp("..", name, 2) &&
982 pos == OCFS2_DIR_REC_LEN(1)) {
983 p->seen_dot_dot = 1;
984 return 0;
985 }
986
987 p->seen_other = 1;
988 return 1;
989}
Mark Fashehccd979b2005-12-15 14:31:24 -0800990/*
991 * routine to check that the specified directory is empty (for rmdir)
Mark Fasheh0bfbbf62007-09-12 11:19:00 -0700992 *
993 * Returns 1 if dir is empty, zero otherwise.
Mark Fashehccd979b2005-12-15 14:31:24 -0800994 */
995int ocfs2_empty_dir(struct inode *inode)
996{
Mark Fasheh0bfbbf62007-09-12 11:19:00 -0700997 int ret;
998 loff_t start = 0;
999 struct ocfs2_empty_dir_priv priv;
Mark Fashehccd979b2005-12-15 14:31:24 -08001000
Mark Fasheh0bfbbf62007-09-12 11:19:00 -07001001 memset(&priv, 0, sizeof(priv));
1002
1003 ret = ocfs2_dir_foreach(inode, &start, &priv, ocfs2_empty_dir_filldir);
1004 if (ret)
1005 mlog_errno(ret);
1006
1007 if (!priv.seen_dot || !priv.seen_dot_dot) {
1008 mlog(ML_ERROR, "bad directory (dir #%llu) - no `.' or `..'\n",
Mark Fashehb06970532006-03-03 10:24:33 -08001009 (unsigned long long)OCFS2_I(inode)->ip_blkno);
Mark Fasheh0bfbbf62007-09-12 11:19:00 -07001010 /*
1011 * XXX: Is it really safe to allow an unlink to continue?
1012 */
Mark Fashehccd979b2005-12-15 14:31:24 -08001013 return 1;
1014 }
1015
Mark Fasheh0bfbbf62007-09-12 11:19:00 -07001016 return !priv.seen_other;
Mark Fashehccd979b2005-12-15 14:31:24 -08001017}
1018
Mark Fasheh5b6a3a22007-09-13 16:33:54 -07001019static void ocfs2_fill_initial_dirents(struct inode *inode,
1020 struct inode *parent,
1021 char *start, unsigned int size)
1022{
1023 struct ocfs2_dir_entry *de = (struct ocfs2_dir_entry *)start;
1024
1025 de->inode = cpu_to_le64(OCFS2_I(inode)->ip_blkno);
1026 de->name_len = 1;
1027 de->rec_len =
1028 cpu_to_le16(OCFS2_DIR_REC_LEN(de->name_len));
1029 strcpy(de->name, ".");
1030 ocfs2_set_de_type(de, S_IFDIR);
1031
1032 de = (struct ocfs2_dir_entry *) ((char *)de + le16_to_cpu(de->rec_len));
1033 de->inode = cpu_to_le64(OCFS2_I(parent)->ip_blkno);
1034 de->rec_len = cpu_to_le16(size - OCFS2_DIR_REC_LEN(1));
1035 de->name_len = 2;
1036 strcpy(de->name, "..");
1037 ocfs2_set_de_type(de, S_IFDIR);
1038}
1039
1040/*
1041 * This works together with code in ocfs2_mknod_locked() which sets
1042 * the inline-data flag and initializes the inline-data section.
1043 */
1044static int ocfs2_fill_new_dir_id(struct ocfs2_super *osb,
1045 handle_t *handle,
1046 struct inode *parent,
1047 struct inode *inode,
1048 struct buffer_head *di_bh)
1049{
1050 int ret;
1051 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
1052 struct ocfs2_inline_data *data = &di->id2.i_data;
1053 unsigned int size = le16_to_cpu(data->id_count);
1054
1055 ret = ocfs2_journal_access(handle, inode, di_bh,
1056 OCFS2_JOURNAL_ACCESS_WRITE);
1057 if (ret) {
1058 mlog_errno(ret);
1059 goto out;
1060 }
1061
1062 ocfs2_fill_initial_dirents(inode, parent, data->id_data, size);
1063
1064 ocfs2_journal_dirty(handle, di_bh);
1065 if (ret) {
1066 mlog_errno(ret);
1067 goto out;
1068 }
1069
1070 i_size_write(inode, size);
1071 inode->i_nlink = 2;
1072 inode->i_blocks = ocfs2_inode_sector_count(inode);
1073
1074 ret = ocfs2_mark_inode_dirty(handle, inode, di_bh);
1075 if (ret < 0)
1076 mlog_errno(ret);
1077
1078out:
1079 return ret;
1080}
1081
1082static int ocfs2_fill_new_dir_el(struct ocfs2_super *osb,
1083 handle_t *handle,
1084 struct inode *parent,
1085 struct inode *inode,
1086 struct buffer_head *fe_bh,
1087 struct ocfs2_alloc_context *data_ac)
Mark Fasheh316f4b92007-09-07 18:21:26 -07001088{
1089 int status;
1090 struct buffer_head *new_bh = NULL;
Mark Fasheh316f4b92007-09-07 18:21:26 -07001091
1092 mlog_entry_void();
1093
1094 status = ocfs2_do_extend_dir(osb->sb, handle, inode, fe_bh,
1095 data_ac, NULL, &new_bh);
1096 if (status < 0) {
1097 mlog_errno(status);
1098 goto bail;
1099 }
1100
1101 ocfs2_set_new_buffer_uptodate(inode, new_bh);
1102
1103 status = ocfs2_journal_access(handle, inode, new_bh,
1104 OCFS2_JOURNAL_ACCESS_CREATE);
1105 if (status < 0) {
1106 mlog_errno(status);
1107 goto bail;
1108 }
1109 memset(new_bh->b_data, 0, osb->sb->s_blocksize);
1110
Mark Fasheh5b6a3a22007-09-13 16:33:54 -07001111 ocfs2_fill_initial_dirents(inode, parent, new_bh->b_data,
1112 osb->sb->s_blocksize);
Mark Fasheh316f4b92007-09-07 18:21:26 -07001113
1114 status = ocfs2_journal_dirty(handle, new_bh);
1115 if (status < 0) {
1116 mlog_errno(status);
1117 goto bail;
1118 }
1119
1120 i_size_write(inode, inode->i_sb->s_blocksize);
1121 inode->i_nlink = 2;
1122 inode->i_blocks = ocfs2_inode_sector_count(inode);
1123 status = ocfs2_mark_inode_dirty(handle, inode, fe_bh);
1124 if (status < 0) {
1125 mlog_errno(status);
1126 goto bail;
1127 }
1128
1129 status = 0;
1130bail:
1131 if (new_bh)
1132 brelse(new_bh);
1133
1134 mlog_exit(status);
1135 return status;
1136}
1137
Mark Fasheh5b6a3a22007-09-13 16:33:54 -07001138int ocfs2_fill_new_dir(struct ocfs2_super *osb,
1139 handle_t *handle,
1140 struct inode *parent,
1141 struct inode *inode,
1142 struct buffer_head *fe_bh,
1143 struct ocfs2_alloc_context *data_ac)
1144{
1145 BUG_ON(!ocfs2_supports_inline_data(osb) && data_ac == NULL);
1146
1147 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
1148 return ocfs2_fill_new_dir_id(osb, handle, parent, inode, fe_bh);
1149
1150 return ocfs2_fill_new_dir_el(osb, handle, parent, inode, fe_bh,
1151 data_ac);
1152}
1153
1154static void ocfs2_expand_last_dirent(char *start, unsigned int old_size,
1155 unsigned int new_size)
1156{
1157 struct ocfs2_dir_entry *de;
1158 struct ocfs2_dir_entry *prev_de;
1159 char *de_buf, *limit;
1160 unsigned int bytes = new_size - old_size;
1161
1162 limit = start + old_size;
1163 de_buf = start;
1164 de = (struct ocfs2_dir_entry *)de_buf;
1165 do {
1166 prev_de = de;
1167 de_buf += le16_to_cpu(de->rec_len);
1168 de = (struct ocfs2_dir_entry *)de_buf;
1169 } while (de_buf < limit);
1170
1171 le16_add_cpu(&prev_de->rec_len, bytes);
1172}
1173
1174/*
1175 * We allocate enough clusters to fulfill "blocks_wanted", but set
1176 * i_size to exactly one block. Ocfs2_extend_dir() will handle the
1177 * rest automatically for us.
1178 *
1179 * *first_block_bh is a pointer to the 1st data block allocated to the
1180 * directory.
1181 */
1182static int ocfs2_expand_inline_dir(struct inode *dir, struct buffer_head *di_bh,
1183 unsigned int blocks_wanted,
1184 struct buffer_head **first_block_bh)
1185{
1186 int ret, credits = OCFS2_INLINE_TO_EXTENTS_CREDITS;
1187 u32 alloc, bit_off, len;
1188 struct super_block *sb = dir->i_sb;
1189 u64 blkno, bytes = blocks_wanted << sb->s_blocksize_bits;
1190 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
1191 struct ocfs2_inode_info *oi = OCFS2_I(dir);
1192 struct ocfs2_alloc_context *data_ac;
1193 struct buffer_head *dirdata_bh = NULL;
1194 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
1195 handle_t *handle;
1196
1197 alloc = ocfs2_clusters_for_bytes(sb, bytes);
1198
1199 /*
1200 * We should never need more than 2 clusters for this -
1201 * maximum dirent size is far less than one block. In fact,
1202 * the only time we'd need more than one cluster is if
1203 * blocksize == clustersize and the dirent won't fit in the
1204 * extra space that the expansion to a single block gives. As
1205 * of today, that only happens on 4k/4k file systems.
1206 */
1207 BUG_ON(alloc > 2);
1208
1209 ret = ocfs2_reserve_clusters(osb, alloc, &data_ac);
1210 if (ret) {
1211 mlog_errno(ret);
1212 goto out;
1213 }
1214
1215 down_write(&oi->ip_alloc_sem);
1216
1217 /*
1218 * Prepare for worst case allocation scenario of two seperate
1219 * extents.
1220 */
1221 if (alloc == 2)
1222 credits += OCFS2_SUBALLOC_ALLOC;
1223
1224 handle = ocfs2_start_trans(osb, credits);
1225 if (IS_ERR(handle)) {
1226 ret = PTR_ERR(handle);
1227 mlog_errno(ret);
1228 goto out_sem;
1229 }
1230
1231 /*
1232 * Try to claim as many clusters as the bitmap can give though
1233 * if we only get one now, that's enough to continue. The rest
1234 * will be claimed after the conversion to extents.
1235 */
1236 ret = ocfs2_claim_clusters(osb, handle, data_ac, 1, &bit_off, &len);
1237 if (ret) {
1238 mlog_errno(ret);
1239 goto out_commit;
1240 }
1241
1242 /*
1243 * Operations are carefully ordered so that we set up the new
1244 * data block first. The conversion from inline data to
1245 * extents follows.
1246 */
1247 blkno = ocfs2_clusters_to_blocks(dir->i_sb, bit_off);
1248 dirdata_bh = sb_getblk(sb, blkno);
1249 if (!dirdata_bh) {
1250 ret = -EIO;
1251 mlog_errno(ret);
1252 goto out_commit;
1253 }
1254
1255 ocfs2_set_new_buffer_uptodate(dir, dirdata_bh);
1256
1257 ret = ocfs2_journal_access(handle, dir, dirdata_bh,
1258 OCFS2_JOURNAL_ACCESS_CREATE);
1259 if (ret) {
1260 mlog_errno(ret);
1261 goto out_commit;
1262 }
1263
1264 memcpy(dirdata_bh->b_data, di->id2.i_data.id_data, i_size_read(dir));
1265 memset(dirdata_bh->b_data + i_size_read(dir), 0,
1266 sb->s_blocksize - i_size_read(dir));
1267 ocfs2_expand_last_dirent(dirdata_bh->b_data, i_size_read(dir),
1268 sb->s_blocksize);
1269
1270 ret = ocfs2_journal_dirty(handle, dirdata_bh);
1271 if (ret) {
1272 mlog_errno(ret);
1273 goto out_commit;
1274 }
1275
1276 /*
1277 * Set extent, i_size, etc on the directory. After this, the
1278 * inode should contain the same exact dirents as before and
1279 * be fully accessible from system calls.
1280 *
1281 * We let the later dirent insert modify c/mtime - to the user
1282 * the data hasn't changed.
1283 */
1284 ret = ocfs2_journal_access(handle, dir, di_bh,
1285 OCFS2_JOURNAL_ACCESS_CREATE);
1286 if (ret) {
1287 mlog_errno(ret);
1288 goto out_commit;
1289 }
1290
1291 spin_lock(&oi->ip_lock);
1292 oi->ip_dyn_features &= ~OCFS2_INLINE_DATA_FL;
1293 di->i_dyn_features = cpu_to_le16(oi->ip_dyn_features);
1294 spin_unlock(&oi->ip_lock);
1295
1296 ocfs2_dinode_new_extent_list(dir, di);
1297
1298 i_size_write(dir, sb->s_blocksize);
1299 dir->i_mtime = dir->i_ctime = CURRENT_TIME;
1300
1301 di->i_size = cpu_to_le64(sb->s_blocksize);
1302 di->i_ctime = di->i_mtime = cpu_to_le64(dir->i_ctime.tv_sec);
1303 di->i_ctime_nsec = di->i_mtime_nsec = cpu_to_le32(dir->i_ctime.tv_nsec);
1304 dir->i_blocks = ocfs2_inode_sector_count(dir);
1305
1306 /*
1307 * This should never fail as our extent list is empty and all
1308 * related blocks have been journaled already.
1309 */
1310 ret = ocfs2_insert_extent(osb, handle, dir, di_bh, 0, blkno, len, 0,
1311 NULL);
1312 if (ret) {
1313 mlog_errno(ret);
1314 goto out;
1315 }
1316
1317 ret = ocfs2_journal_dirty(handle, di_bh);
1318 if (ret) {
1319 mlog_errno(ret);
1320 goto out_commit;
1321 }
1322
1323 /*
1324 * We asked for two clusters, but only got one in the 1st
1325 * pass. Claim the 2nd cluster as a separate extent.
1326 */
1327 if (alloc > len) {
1328 ret = ocfs2_claim_clusters(osb, handle, data_ac, 1, &bit_off,
1329 &len);
1330 if (ret) {
1331 mlog_errno(ret);
1332 goto out_commit;
1333 }
1334 blkno = ocfs2_clusters_to_blocks(dir->i_sb, bit_off);
1335
1336 ret = ocfs2_insert_extent(osb, handle, dir, di_bh, 1, blkno,
1337 len, 0, NULL);
1338 if (ret) {
1339 mlog_errno(ret);
1340 goto out;
1341 }
1342 }
1343
1344 *first_block_bh = dirdata_bh;
1345 dirdata_bh = NULL;
1346
1347out_commit:
1348 ocfs2_commit_trans(osb, handle);
1349
1350out_sem:
1351 up_write(&oi->ip_alloc_sem);
1352
1353out:
1354 if (data_ac)
1355 ocfs2_free_alloc_context(data_ac);
1356
1357 brelse(dirdata_bh);
1358
1359 return ret;
1360}
1361
Mark Fashehccd979b2005-12-15 14:31:24 -08001362/* returns a bh of the 1st new block in the allocation. */
Mark Fasheh316f4b92007-09-07 18:21:26 -07001363static int ocfs2_do_extend_dir(struct super_block *sb,
1364 handle_t *handle,
1365 struct inode *dir,
1366 struct buffer_head *parent_fe_bh,
1367 struct ocfs2_alloc_context *data_ac,
1368 struct ocfs2_alloc_context *meta_ac,
1369 struct buffer_head **new_bh)
Mark Fashehccd979b2005-12-15 14:31:24 -08001370{
1371 int status;
1372 int extend;
Mark Fasheh8110b072007-03-22 16:53:23 -07001373 u64 p_blkno, v_blkno;
Mark Fashehccd979b2005-12-15 14:31:24 -08001374
1375 spin_lock(&OCFS2_I(dir)->ip_lock);
1376 extend = (i_size_read(dir) == ocfs2_clusters_to_bytes(sb, OCFS2_I(dir)->ip_clusters));
1377 spin_unlock(&OCFS2_I(dir)->ip_lock);
1378
1379 if (extend) {
Mark Fashehdcd05382007-01-16 11:32:23 -08001380 u32 offset = OCFS2_I(dir)->ip_clusters;
1381
1382 status = ocfs2_do_extend_allocation(OCFS2_SB(sb), dir, &offset,
Mark Fasheh2ae99a62007-03-09 16:43:28 -08001383 1, 0, parent_fe_bh, handle,
Mark Fashehccd979b2005-12-15 14:31:24 -08001384 data_ac, meta_ac, NULL);
1385 BUG_ON(status == -EAGAIN);
1386 if (status < 0) {
1387 mlog_errno(status);
1388 goto bail;
1389 }
1390 }
1391
Mark Fasheh8110b072007-03-22 16:53:23 -07001392 v_blkno = ocfs2_blocks_for_bytes(sb, i_size_read(dir));
1393 status = ocfs2_extent_map_get_blocks(dir, v_blkno, &p_blkno, NULL, NULL);
Mark Fashehccd979b2005-12-15 14:31:24 -08001394 if (status < 0) {
1395 mlog_errno(status);
1396 goto bail;
1397 }
1398
1399 *new_bh = sb_getblk(sb, p_blkno);
1400 if (!*new_bh) {
1401 status = -EIO;
1402 mlog_errno(status);
1403 goto bail;
1404 }
1405 status = 0;
1406bail:
1407 mlog_exit(status);
1408 return status;
1409}
1410
Mark Fasheh5b6a3a22007-09-13 16:33:54 -07001411/*
1412 * Assumes you already have a cluster lock on the directory.
1413 *
1414 * 'blocks_wanted' is only used if we have an inline directory which
1415 * is to be turned into an extent based one. The size of the dirent to
1416 * insert might be larger than the space gained by growing to just one
1417 * block, so we may have to grow the inode by two blocks in that case.
1418 */
Mark Fashehccd979b2005-12-15 14:31:24 -08001419static int ocfs2_extend_dir(struct ocfs2_super *osb,
1420 struct inode *dir,
1421 struct buffer_head *parent_fe_bh,
Mark Fasheh5b6a3a22007-09-13 16:33:54 -07001422 unsigned int blocks_wanted,
Mark Fashehccd979b2005-12-15 14:31:24 -08001423 struct buffer_head **new_de_bh)
1424{
1425 int status = 0;
Joel Beckeree19a772007-03-28 18:27:07 -07001426 int credits, num_free_extents, drop_alloc_sem = 0;
Mark Fashehccd979b2005-12-15 14:31:24 -08001427 loff_t dir_i_size;
1428 struct ocfs2_dinode *fe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
1429 struct ocfs2_alloc_context *data_ac = NULL;
1430 struct ocfs2_alloc_context *meta_ac = NULL;
Mark Fasheh1fabe142006-10-09 18:11:45 -07001431 handle_t *handle = NULL;
Mark Fashehccd979b2005-12-15 14:31:24 -08001432 struct buffer_head *new_bh = NULL;
1433 struct ocfs2_dir_entry * de;
1434 struct super_block *sb = osb->sb;
1435
1436 mlog_entry_void();
1437
Mark Fasheh5b6a3a22007-09-13 16:33:54 -07001438 if (OCFS2_I(dir)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
1439 status = ocfs2_expand_inline_dir(dir, parent_fe_bh,
1440 blocks_wanted, &new_bh);
1441 if (status) {
1442 mlog_errno(status);
1443 goto bail;
1444 }
1445
1446 if (blocks_wanted == 1) {
1447 /*
1448 * If the new dirent will fit inside the space
1449 * created by pushing out to one block, then
1450 * we can complete the operation
1451 * here. Otherwise we have to expand i_size
1452 * and format the 2nd block below.
1453 */
1454 BUG_ON(new_bh == NULL);
1455 goto bail_bh;
1456 }
1457
1458 /*
1459 * Get rid of 'new_bh' - we want to format the 2nd
1460 * data block and return that instead.
1461 */
1462 brelse(new_bh);
1463 new_bh = NULL;
1464
1465 dir_i_size = i_size_read(dir);
1466 credits = OCFS2_SIMPLE_DIR_EXTEND_CREDITS;
1467 goto do_extend;
1468 }
1469
Mark Fashehccd979b2005-12-15 14:31:24 -08001470 dir_i_size = i_size_read(dir);
Mark Fashehb06970532006-03-03 10:24:33 -08001471 mlog(0, "extending dir %llu (i_size = %lld)\n",
1472 (unsigned long long)OCFS2_I(dir)->ip_blkno, dir_i_size);
Mark Fashehccd979b2005-12-15 14:31:24 -08001473
Mark Fashehccd979b2005-12-15 14:31:24 -08001474 /* dir->i_size is always block aligned. */
1475 spin_lock(&OCFS2_I(dir)->ip_lock);
1476 if (dir_i_size == ocfs2_clusters_to_bytes(sb, OCFS2_I(dir)->ip_clusters)) {
1477 spin_unlock(&OCFS2_I(dir)->ip_lock);
1478 num_free_extents = ocfs2_num_free_extents(osb, dir, fe);
1479 if (num_free_extents < 0) {
1480 status = num_free_extents;
1481 mlog_errno(status);
1482 goto bail;
1483 }
1484
1485 if (!num_free_extents) {
Mark Fashehda5cbf22006-10-06 18:34:35 -07001486 status = ocfs2_reserve_new_metadata(osb, fe, &meta_ac);
Mark Fashehccd979b2005-12-15 14:31:24 -08001487 if (status < 0) {
1488 if (status != -ENOSPC)
1489 mlog_errno(status);
1490 goto bail;
1491 }
1492 }
1493
Mark Fashehda5cbf22006-10-06 18:34:35 -07001494 status = ocfs2_reserve_clusters(osb, 1, &data_ac);
Mark Fashehccd979b2005-12-15 14:31:24 -08001495 if (status < 0) {
1496 if (status != -ENOSPC)
1497 mlog_errno(status);
1498 goto bail;
1499 }
1500
1501 credits = ocfs2_calc_extend_credits(sb, fe, 1);
1502 } else {
1503 spin_unlock(&OCFS2_I(dir)->ip_lock);
1504 credits = OCFS2_SIMPLE_DIR_EXTEND_CREDITS;
1505 }
1506
Mark Fasheh5b6a3a22007-09-13 16:33:54 -07001507do_extend:
Joel Beckeree19a772007-03-28 18:27:07 -07001508 down_write(&OCFS2_I(dir)->ip_alloc_sem);
1509 drop_alloc_sem = 1;
1510
Mark Fasheh65eff9c2006-10-09 17:26:22 -07001511 handle = ocfs2_start_trans(osb, credits);
Mark Fashehccd979b2005-12-15 14:31:24 -08001512 if (IS_ERR(handle)) {
1513 status = PTR_ERR(handle);
1514 handle = NULL;
1515 mlog_errno(status);
1516 goto bail;
1517 }
1518
1519 status = ocfs2_do_extend_dir(osb->sb, handle, dir, parent_fe_bh,
1520 data_ac, meta_ac, &new_bh);
1521 if (status < 0) {
1522 mlog_errno(status);
1523 goto bail;
1524 }
1525
1526 ocfs2_set_new_buffer_uptodate(dir, new_bh);
1527
1528 status = ocfs2_journal_access(handle, dir, new_bh,
1529 OCFS2_JOURNAL_ACCESS_CREATE);
1530 if (status < 0) {
1531 mlog_errno(status);
1532 goto bail;
1533 }
1534 memset(new_bh->b_data, 0, sb->s_blocksize);
1535 de = (struct ocfs2_dir_entry *) new_bh->b_data;
1536 de->inode = 0;
1537 de->rec_len = cpu_to_le16(sb->s_blocksize);
1538 status = ocfs2_journal_dirty(handle, new_bh);
1539 if (status < 0) {
1540 mlog_errno(status);
1541 goto bail;
1542 }
1543
1544 dir_i_size += dir->i_sb->s_blocksize;
1545 i_size_write(dir, dir_i_size);
Mark Fasheh8110b072007-03-22 16:53:23 -07001546 dir->i_blocks = ocfs2_inode_sector_count(dir);
Mark Fashehccd979b2005-12-15 14:31:24 -08001547 status = ocfs2_mark_inode_dirty(handle, dir, parent_fe_bh);
1548 if (status < 0) {
1549 mlog_errno(status);
1550 goto bail;
1551 }
1552
Mark Fasheh5b6a3a22007-09-13 16:33:54 -07001553bail_bh:
Mark Fashehccd979b2005-12-15 14:31:24 -08001554 *new_de_bh = new_bh;
1555 get_bh(*new_de_bh);
1556bail:
Joel Beckeree19a772007-03-28 18:27:07 -07001557 if (drop_alloc_sem)
1558 up_write(&OCFS2_I(dir)->ip_alloc_sem);
Mark Fashehccd979b2005-12-15 14:31:24 -08001559 if (handle)
Mark Fasheh02dc1af2006-10-09 16:48:10 -07001560 ocfs2_commit_trans(osb, handle);
Mark Fashehccd979b2005-12-15 14:31:24 -08001561
1562 if (data_ac)
1563 ocfs2_free_alloc_context(data_ac);
1564 if (meta_ac)
1565 ocfs2_free_alloc_context(meta_ac);
1566
1567 if (new_bh)
1568 brelse(new_bh);
1569
1570 mlog_exit(status);
1571 return status;
1572}
1573
Mark Fasheh5b6a3a22007-09-13 16:33:54 -07001574static int ocfs2_find_dir_space_id(struct inode *dir, struct buffer_head *di_bh,
1575 const char *name, int namelen,
1576 struct buffer_head **ret_de_bh,
1577 unsigned int *blocks_wanted)
1578{
1579 int ret;
1580 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
1581 struct ocfs2_dir_entry *de, *last_de = NULL;
1582 char *de_buf, *limit;
1583 unsigned long offset = 0;
1584 unsigned int rec_len, new_rec_len;
1585
1586 de_buf = di->id2.i_data.id_data;
1587 limit = de_buf + i_size_read(dir);
1588 rec_len = OCFS2_DIR_REC_LEN(namelen);
1589
1590 while (de_buf < limit) {
1591 de = (struct ocfs2_dir_entry *)de_buf;
1592
1593 if (!ocfs2_check_dir_entry(dir, de, di_bh, offset)) {
1594 ret = -ENOENT;
1595 goto out;
1596 }
1597 if (ocfs2_match(namelen, name, de)) {
1598 ret = -EEXIST;
1599 goto out;
1600 }
1601 if (ocfs2_dirent_would_fit(de, rec_len)) {
1602 /* Ok, we found a spot. Return this bh and let
1603 * the caller actually fill it in. */
1604 *ret_de_bh = di_bh;
1605 get_bh(*ret_de_bh);
1606 ret = 0;
1607 goto out;
1608 }
1609
1610 last_de = de;
1611 de_buf += le16_to_cpu(de->rec_len);
1612 offset += le16_to_cpu(de->rec_len);
1613 }
1614
1615 /*
1616 * We're going to require expansion of the directory - figure
1617 * out how many blocks we'll need so that a place for the
1618 * dirent can be found.
1619 */
1620 *blocks_wanted = 1;
1621 new_rec_len = le16_to_cpu(last_de->rec_len) + (dir->i_sb->s_blocksize - i_size_read(dir));
1622 if (new_rec_len < (rec_len + OCFS2_DIR_REC_LEN(last_de->name_len)))
1623 *blocks_wanted = 2;
1624
1625 ret = -ENOSPC;
1626out:
1627 return ret;
1628}
1629
1630static int ocfs2_find_dir_space_el(struct inode *dir, const char *name,
1631 int namelen, struct buffer_head **ret_de_bh)
Mark Fashehccd979b2005-12-15 14:31:24 -08001632{
1633 unsigned long offset;
Mark Fasheh5b6a3a22007-09-13 16:33:54 -07001634 struct buffer_head *bh = NULL;
Mark Fashehccd979b2005-12-15 14:31:24 -08001635 unsigned short rec_len;
Mark Fashehccd979b2005-12-15 14:31:24 -08001636 struct ocfs2_dir_entry *de;
Mark Fasheh5b6a3a22007-09-13 16:33:54 -07001637 struct super_block *sb = dir->i_sb;
Mark Fashehccd979b2005-12-15 14:31:24 -08001638 int status;
1639
Mark Fashehccd979b2005-12-15 14:31:24 -08001640 bh = ocfs2_bread(dir, 0, &status, 0);
1641 if (!bh) {
1642 mlog_errno(status);
1643 goto bail;
1644 }
1645
1646 rec_len = OCFS2_DIR_REC_LEN(namelen);
1647 offset = 0;
1648 de = (struct ocfs2_dir_entry *) bh->b_data;
1649 while (1) {
1650 if ((char *)de >= sb->s_blocksize + bh->b_data) {
1651 brelse(bh);
1652 bh = NULL;
1653
1654 if (i_size_read(dir) <= offset) {
Mark Fasheh5b6a3a22007-09-13 16:33:54 -07001655 /*
1656 * Caller will have to expand this
1657 * directory.
1658 */
1659 status = -ENOSPC;
Mark Fashehccd979b2005-12-15 14:31:24 -08001660 goto bail;
1661 }
1662 bh = ocfs2_bread(dir,
1663 offset >> sb->s_blocksize_bits,
1664 &status,
1665 0);
1666 if (!bh) {
1667 mlog_errno(status);
1668 goto bail;
1669 }
1670 /* move to next block */
1671 de = (struct ocfs2_dir_entry *) bh->b_data;
1672 }
1673 if (!ocfs2_check_dir_entry(dir, de, bh, offset)) {
1674 status = -ENOENT;
1675 goto bail;
1676 }
1677 if (ocfs2_match(namelen, name, de)) {
1678 status = -EEXIST;
1679 goto bail;
1680 }
Mark Fasheh8553cf42007-09-13 16:29:01 -07001681 if (ocfs2_dirent_would_fit(de, rec_len)) {
Mark Fashehccd979b2005-12-15 14:31:24 -08001682 /* Ok, we found a spot. Return this bh and let
1683 * the caller actually fill it in. */
1684 *ret_de_bh = bh;
1685 get_bh(*ret_de_bh);
1686 status = 0;
1687 goto bail;
1688 }
1689 offset += le16_to_cpu(de->rec_len);
1690 de = (struct ocfs2_dir_entry *)((char *) de + le16_to_cpu(de->rec_len));
1691 }
1692
1693 status = 0;
1694bail:
1695 if (bh)
1696 brelse(bh);
1697
1698 mlog_exit(status);
1699 return status;
1700}
Mark Fasheh5b6a3a22007-09-13 16:33:54 -07001701
1702int ocfs2_prepare_dir_for_insert(struct ocfs2_super *osb,
1703 struct inode *dir,
1704 struct buffer_head *parent_fe_bh,
1705 const char *name,
1706 int namelen,
1707 struct buffer_head **ret_de_bh)
1708{
1709 int ret;
1710 unsigned int blocks_wanted = 1;
1711 struct buffer_head *bh = NULL;
1712
1713 mlog(0, "getting ready to insert namelen %d into dir %llu\n",
1714 namelen, (unsigned long long)OCFS2_I(dir)->ip_blkno);
1715
1716 *ret_de_bh = NULL;
1717
1718 if (!namelen) {
1719 ret = -EINVAL;
1720 mlog_errno(ret);
1721 goto out;
1722 }
1723
1724 if (OCFS2_I(dir)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
1725 ret = ocfs2_find_dir_space_id(dir, parent_fe_bh, name,
1726 namelen, &bh, &blocks_wanted);
1727 } else
1728 ret = ocfs2_find_dir_space_el(dir, name, namelen, &bh);
1729
1730 if (ret && ret != -ENOSPC) {
1731 mlog_errno(ret);
1732 goto out;
1733 }
1734
1735 if (ret == -ENOSPC) {
1736 /*
1737 * We have to expand the directory to add this name.
1738 */
1739 BUG_ON(bh);
1740
1741 ret = ocfs2_extend_dir(osb, dir, parent_fe_bh, blocks_wanted,
1742 &bh);
1743 if (ret) {
1744 if (ret != -ENOSPC)
1745 mlog_errno(ret);
1746 goto out;
1747 }
1748
1749 BUG_ON(!bh);
1750 }
1751
1752 *ret_de_bh = bh;
1753 bh = NULL;
1754out:
1755 if (bh)
1756 brelse(bh);
1757 return ret;
1758}