xref: /openbmc/linux/fs/ocfs2/namei.c (revision e868d61272caa648214046a096e5a6bfc068dc8c)
1 /* -*- mode: c; c-basic-offset: 8; -*-
2  * vim: noexpandtab sw=8 ts=8 sts=0:
3  *
4  * namei.c
5  *
6  * Create and rename file, directory, symlinks
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 "dcache.h"
51 #include "dir.h"
52 #include "dlmglue.h"
53 #include "extent_map.h"
54 #include "file.h"
55 #include "inode.h"
56 #include "journal.h"
57 #include "namei.h"
58 #include "suballoc.h"
59 #include "super.h"
60 #include "symlink.h"
61 #include "sysfile.h"
62 #include "uptodate.h"
63 #include "vote.h"
64 
65 #include "buffer_head_io.h"
66 
67 #define NAMEI_RA_CHUNKS  2
68 #define NAMEI_RA_BLOCKS  4
69 #define NAMEI_RA_SIZE        (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS)
70 #define NAMEI_RA_INDEX(c,b)  (((c) * NAMEI_RA_BLOCKS) + (b))
71 
72 static int inline ocfs2_search_dirblock(struct buffer_head *bh,
73 					struct inode *dir,
74 					const char *name, int namelen,
75 					unsigned long offset,
76 					struct ocfs2_dir_entry **res_dir);
77 
78 static int ocfs2_delete_entry(handle_t *handle,
79 			      struct inode *dir,
80 			      struct ocfs2_dir_entry *de_del,
81 			      struct buffer_head *bh);
82 
83 static int __ocfs2_add_entry(handle_t *handle,
84 			     struct inode *dir,
85 			     const char *name, int namelen,
86 			     struct inode *inode, u64 blkno,
87 			     struct buffer_head *parent_fe_bh,
88 			     struct buffer_head *insert_bh);
89 
90 static int ocfs2_mknod_locked(struct ocfs2_super *osb,
91 			      struct inode *dir,
92 			      struct dentry *dentry, int mode,
93 			      dev_t dev,
94 			      struct buffer_head **new_fe_bh,
95 			      struct buffer_head *parent_fe_bh,
96 			      handle_t *handle,
97 			      struct inode **ret_inode,
98 			      struct ocfs2_alloc_context *inode_ac);
99 
100 static int ocfs2_fill_new_dir(struct ocfs2_super *osb,
101 			      handle_t *handle,
102 			      struct inode *parent,
103 			      struct inode *inode,
104 			      struct buffer_head *fe_bh,
105 			      struct ocfs2_alloc_context *data_ac);
106 
107 static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb,
108 				    struct inode **ret_orphan_dir,
109 				    struct inode *inode,
110 				    char *name,
111 				    struct buffer_head **de_bh);
112 
113 static int ocfs2_orphan_add(struct ocfs2_super *osb,
114 			    handle_t *handle,
115 			    struct inode *inode,
116 			    struct ocfs2_dinode *fe,
117 			    char *name,
118 			    struct buffer_head *de_bh,
119 			    struct inode *orphan_dir_inode);
120 
121 static int ocfs2_create_symlink_data(struct ocfs2_super *osb,
122 				     handle_t *handle,
123 				     struct inode *inode,
124 				     const char *symname);
125 
126 static inline int ocfs2_add_entry(handle_t *handle,
127 				  struct dentry *dentry,
128 				  struct inode *inode, u64 blkno,
129 				  struct buffer_head *parent_fe_bh,
130 				  struct buffer_head *insert_bh)
131 {
132 	return __ocfs2_add_entry(handle, dentry->d_parent->d_inode,
133 				 dentry->d_name.name, dentry->d_name.len,
134 				 inode, blkno, parent_fe_bh, insert_bh);
135 }
136 
137 /* An orphan dir name is an 8 byte value, printed as a hex string */
138 #define OCFS2_ORPHAN_NAMELEN ((int)(2 * sizeof(u64)))
139 
140 static struct dentry *ocfs2_lookup(struct inode *dir, struct dentry *dentry,
141 				   struct nameidata *nd)
142 {
143 	int status;
144 	u64 blkno;
145 	struct buffer_head *dirent_bh = NULL;
146 	struct inode *inode = NULL;
147 	struct dentry *ret;
148 	struct ocfs2_dir_entry *dirent;
149 	struct ocfs2_inode_info *oi;
150 
151 	mlog_entry("(0x%p, 0x%p, '%.*s')\n", dir, dentry,
152 		   dentry->d_name.len, dentry->d_name.name);
153 
154 	if (dentry->d_name.len > OCFS2_MAX_FILENAME_LEN) {
155 		ret = ERR_PTR(-ENAMETOOLONG);
156 		goto bail;
157 	}
158 
159 	mlog(0, "find name %.*s in directory %llu\n", dentry->d_name.len,
160 	     dentry->d_name.name, (unsigned long long)OCFS2_I(dir)->ip_blkno);
161 
162 	status = ocfs2_meta_lock(dir, NULL, 0);
163 	if (status < 0) {
164 		if (status != -ENOENT)
165 			mlog_errno(status);
166 		ret = ERR_PTR(status);
167 		goto bail;
168 	}
169 
170 	status = ocfs2_find_files_on_disk(dentry->d_name.name,
171 					  dentry->d_name.len, &blkno,
172 					  dir, &dirent_bh, &dirent);
173 	if (status < 0)
174 		goto bail_add;
175 
176 	inode = ocfs2_iget(OCFS2_SB(dir->i_sb), blkno, 0);
177 	if (IS_ERR(inode)) {
178 		ret = ERR_PTR(-EACCES);
179 		goto bail_unlock;
180 	}
181 
182 	oi = OCFS2_I(inode);
183 	/* Clear any orphaned state... If we were able to look up the
184 	 * inode from a directory, it certainly can't be orphaned. We
185 	 * might have the bad state from a node which intended to
186 	 * orphan this inode but crashed before it could commit the
187 	 * unlink. */
188 	spin_lock(&oi->ip_lock);
189 	oi->ip_flags &= ~OCFS2_INODE_MAYBE_ORPHANED;
190 	spin_unlock(&oi->ip_lock);
191 
192 bail_add:
193 	dentry->d_op = &ocfs2_dentry_ops;
194 	ret = d_splice_alias(inode, dentry);
195 
196 	if (inode) {
197 		/*
198 		 * If d_splice_alias() finds a DCACHE_DISCONNECTED
199 		 * dentry, it will d_move() it on top of ourse. The
200 		 * return value will indicate this however, so in
201 		 * those cases, we switch them around for the locking
202 		 * code.
203 		 *
204 		 * NOTE: This dentry already has ->d_op set from
205 		 * ocfs2_get_parent() and ocfs2_get_dentry()
206 		 */
207 		if (ret)
208 			dentry = ret;
209 
210 		status = ocfs2_dentry_attach_lock(dentry, inode,
211 						  OCFS2_I(dir)->ip_blkno);
212 		if (status) {
213 			mlog_errno(status);
214 			ret = ERR_PTR(status);
215 			goto bail_unlock;
216 		}
217 	}
218 
219 bail_unlock:
220 	/* Don't drop the cluster lock until *after* the d_add --
221 	 * unlink on another node will message us to remove that
222 	 * dentry under this lock so otherwise we can race this with
223 	 * the vote thread and have a stale dentry. */
224 	ocfs2_meta_unlock(dir, 0);
225 
226 bail:
227 	if (dirent_bh)
228 		brelse(dirent_bh);
229 
230 	mlog_exit_ptr(ret);
231 
232 	return ret;
233 }
234 
235 static int ocfs2_fill_new_dir(struct ocfs2_super *osb,
236 			      handle_t *handle,
237 			      struct inode *parent,
238 			      struct inode *inode,
239 			      struct buffer_head *fe_bh,
240 			      struct ocfs2_alloc_context *data_ac)
241 {
242 	int status;
243 	struct buffer_head *new_bh = NULL;
244 	struct ocfs2_dir_entry *de = NULL;
245 
246 	mlog_entry_void();
247 
248 	status = ocfs2_do_extend_dir(osb->sb, handle, inode, fe_bh,
249 				     data_ac, NULL, &new_bh);
250 	if (status < 0) {
251 		mlog_errno(status);
252 		goto bail;
253 	}
254 
255 	ocfs2_set_new_buffer_uptodate(inode, new_bh);
256 
257 	status = ocfs2_journal_access(handle, inode, new_bh,
258 				      OCFS2_JOURNAL_ACCESS_CREATE);
259 	if (status < 0) {
260 		mlog_errno(status);
261 		goto bail;
262 	}
263 	memset(new_bh->b_data, 0, osb->sb->s_blocksize);
264 
265 	de = (struct ocfs2_dir_entry *) new_bh->b_data;
266 	de->inode = cpu_to_le64(OCFS2_I(inode)->ip_blkno);
267 	de->name_len = 1;
268 	de->rec_len =
269 		cpu_to_le16(OCFS2_DIR_REC_LEN(de->name_len));
270 	strcpy(de->name, ".");
271 	ocfs2_set_de_type(de, S_IFDIR);
272 	de = (struct ocfs2_dir_entry *) ((char *)de + le16_to_cpu(de->rec_len));
273 	de->inode = cpu_to_le64(OCFS2_I(parent)->ip_blkno);
274 	de->rec_len = cpu_to_le16(inode->i_sb->s_blocksize -
275 				  OCFS2_DIR_REC_LEN(1));
276 	de->name_len = 2;
277 	strcpy(de->name, "..");
278 	ocfs2_set_de_type(de, S_IFDIR);
279 
280 	status = ocfs2_journal_dirty(handle, new_bh);
281 	if (status < 0) {
282 		mlog_errno(status);
283 		goto bail;
284 	}
285 
286 	i_size_write(inode, inode->i_sb->s_blocksize);
287 	inode->i_nlink = 2;
288 	inode->i_blocks = ocfs2_inode_sector_count(inode);
289 	status = ocfs2_mark_inode_dirty(handle, inode, fe_bh);
290 	if (status < 0) {
291 		mlog_errno(status);
292 		goto bail;
293 	}
294 
295 	status = 0;
296 bail:
297 	if (new_bh)
298 		brelse(new_bh);
299 
300 	mlog_exit(status);
301 	return status;
302 }
303 
304 static int ocfs2_mknod(struct inode *dir,
305 		       struct dentry *dentry,
306 		       int mode,
307 		       dev_t dev)
308 {
309 	int status = 0;
310 	struct buffer_head *parent_fe_bh = NULL;
311 	handle_t *handle = NULL;
312 	struct ocfs2_super *osb;
313 	struct ocfs2_dinode *dirfe;
314 	struct buffer_head *new_fe_bh = NULL;
315 	struct buffer_head *de_bh = NULL;
316 	struct inode *inode = NULL;
317 	struct ocfs2_alloc_context *inode_ac = NULL;
318 	struct ocfs2_alloc_context *data_ac = NULL;
319 
320 	mlog_entry("(0x%p, 0x%p, %d, %lu, '%.*s')\n", dir, dentry, mode,
321 		   (unsigned long)dev, dentry->d_name.len,
322 		   dentry->d_name.name);
323 
324 	/* get our super block */
325 	osb = OCFS2_SB(dir->i_sb);
326 
327 	status = ocfs2_meta_lock(dir, &parent_fe_bh, 1);
328 	if (status < 0) {
329 		if (status != -ENOENT)
330 			mlog_errno(status);
331 		return status;
332 	}
333 
334 	if (S_ISDIR(mode) && (dir->i_nlink >= OCFS2_LINK_MAX)) {
335 		status = -EMLINK;
336 		goto leave;
337 	}
338 
339 	dirfe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
340 	if (!dirfe->i_links_count) {
341 		/* can't make a file in a deleted directory. */
342 		status = -ENOENT;
343 		goto leave;
344 	}
345 
346 	status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
347 					   dentry->d_name.len);
348 	if (status)
349 		goto leave;
350 
351 	/* get a spot inside the dir. */
352 	status = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
353 					      dentry->d_name.name,
354 					      dentry->d_name.len, &de_bh);
355 	if (status < 0) {
356 		mlog_errno(status);
357 		goto leave;
358 	}
359 
360 	/* reserve an inode spot */
361 	status = ocfs2_reserve_new_inode(osb, &inode_ac);
362 	if (status < 0) {
363 		if (status != -ENOSPC)
364 			mlog_errno(status);
365 		goto leave;
366 	}
367 
368 	/* are we making a directory? If so, reserve a cluster for his
369 	 * 1st extent. */
370 	if (S_ISDIR(mode)) {
371 		status = ocfs2_reserve_clusters(osb, 1, &data_ac);
372 		if (status < 0) {
373 			if (status != -ENOSPC)
374 				mlog_errno(status);
375 			goto leave;
376 		}
377 	}
378 
379 	handle = ocfs2_start_trans(osb, OCFS2_MKNOD_CREDITS);
380 	if (IS_ERR(handle)) {
381 		status = PTR_ERR(handle);
382 		handle = NULL;
383 		mlog_errno(status);
384 		goto leave;
385 	}
386 
387 	/* do the real work now. */
388 	status = ocfs2_mknod_locked(osb, dir, dentry, mode, dev,
389 				    &new_fe_bh, parent_fe_bh, handle,
390 				    &inode, inode_ac);
391 	if (status < 0) {
392 		mlog_errno(status);
393 		goto leave;
394 	}
395 
396 	if (S_ISDIR(mode)) {
397 		status = ocfs2_fill_new_dir(osb, handle, dir, inode,
398 					    new_fe_bh, data_ac);
399 		if (status < 0) {
400 			mlog_errno(status);
401 			goto leave;
402 		}
403 
404 		status = ocfs2_journal_access(handle, dir, parent_fe_bh,
405 					      OCFS2_JOURNAL_ACCESS_WRITE);
406 		if (status < 0) {
407 			mlog_errno(status);
408 			goto leave;
409 		}
410 		le16_add_cpu(&dirfe->i_links_count, 1);
411 		status = ocfs2_journal_dirty(handle, parent_fe_bh);
412 		if (status < 0) {
413 			mlog_errno(status);
414 			goto leave;
415 		}
416 		inc_nlink(dir);
417 	}
418 
419 	status = ocfs2_add_entry(handle, dentry, inode,
420 				 OCFS2_I(inode)->ip_blkno, parent_fe_bh,
421 				 de_bh);
422 	if (status < 0) {
423 		mlog_errno(status);
424 		goto leave;
425 	}
426 
427 	status = ocfs2_dentry_attach_lock(dentry, inode,
428 					  OCFS2_I(dir)->ip_blkno);
429 	if (status) {
430 		mlog_errno(status);
431 		goto leave;
432 	}
433 
434 	insert_inode_hash(inode);
435 	dentry->d_op = &ocfs2_dentry_ops;
436 	d_instantiate(dentry, inode);
437 	status = 0;
438 leave:
439 	if (handle)
440 		ocfs2_commit_trans(osb, handle);
441 
442 	ocfs2_meta_unlock(dir, 1);
443 
444 	if (status == -ENOSPC)
445 		mlog(0, "Disk is full\n");
446 
447 	if (new_fe_bh)
448 		brelse(new_fe_bh);
449 
450 	if (de_bh)
451 		brelse(de_bh);
452 
453 	if (parent_fe_bh)
454 		brelse(parent_fe_bh);
455 
456 	if ((status < 0) && inode)
457 		iput(inode);
458 
459 	if (inode_ac)
460 		ocfs2_free_alloc_context(inode_ac);
461 
462 	if (data_ac)
463 		ocfs2_free_alloc_context(data_ac);
464 
465 	mlog_exit(status);
466 
467 	return status;
468 }
469 
470 static int ocfs2_mknod_locked(struct ocfs2_super *osb,
471 			      struct inode *dir,
472 			      struct dentry *dentry, int mode,
473 			      dev_t dev,
474 			      struct buffer_head **new_fe_bh,
475 			      struct buffer_head *parent_fe_bh,
476 			      handle_t *handle,
477 			      struct inode **ret_inode,
478 			      struct ocfs2_alloc_context *inode_ac)
479 {
480 	int status = 0;
481 	struct ocfs2_dinode *fe = NULL;
482 	struct ocfs2_extent_list *fel;
483 	u64 fe_blkno = 0;
484 	u16 suballoc_bit;
485 	struct inode *inode = NULL;
486 
487 	mlog_entry("(0x%p, 0x%p, %d, %lu, '%.*s')\n", dir, dentry, mode,
488 		   (unsigned long)dev, dentry->d_name.len,
489 		   dentry->d_name.name);
490 
491 	*new_fe_bh = NULL;
492 	*ret_inode = NULL;
493 
494 	status = ocfs2_claim_new_inode(osb, handle, inode_ac, &suballoc_bit,
495 				       &fe_blkno);
496 	if (status < 0) {
497 		mlog_errno(status);
498 		goto leave;
499 	}
500 
501 	inode = new_inode(dir->i_sb);
502 	if (IS_ERR(inode)) {
503 		status = PTR_ERR(inode);
504 		mlog(ML_ERROR, "new_inode failed!\n");
505 		goto leave;
506 	}
507 
508 	/* populate as many fields early on as possible - many of
509 	 * these are used by the support functions here and in
510 	 * callers. */
511 	inode->i_ino = ino_from_blkno(osb->sb, fe_blkno);
512 	OCFS2_I(inode)->ip_blkno = fe_blkno;
513 	if (S_ISDIR(mode))
514 		inode->i_nlink = 2;
515 	else
516 		inode->i_nlink = 1;
517 	inode->i_mode = mode;
518 	spin_lock(&osb->osb_lock);
519 	inode->i_generation = osb->s_next_generation++;
520 	spin_unlock(&osb->osb_lock);
521 
522 	*new_fe_bh = sb_getblk(osb->sb, fe_blkno);
523 	if (!*new_fe_bh) {
524 		status = -EIO;
525 		mlog_errno(status);
526 		goto leave;
527 	}
528 	ocfs2_set_new_buffer_uptodate(inode, *new_fe_bh);
529 
530 	status = ocfs2_journal_access(handle, inode, *new_fe_bh,
531 				      OCFS2_JOURNAL_ACCESS_CREATE);
532 	if (status < 0) {
533 		mlog_errno(status);
534 		goto leave;
535 	}
536 
537 	fe = (struct ocfs2_dinode *) (*new_fe_bh)->b_data;
538 	memset(fe, 0, osb->sb->s_blocksize);
539 
540 	fe->i_generation = cpu_to_le32(inode->i_generation);
541 	fe->i_fs_generation = cpu_to_le32(osb->fs_generation);
542 	fe->i_blkno = cpu_to_le64(fe_blkno);
543 	fe->i_suballoc_bit = cpu_to_le16(suballoc_bit);
544 	fe->i_suballoc_slot = cpu_to_le16(osb->slot_num);
545 	fe->i_uid = cpu_to_le32(current->fsuid);
546 	if (dir->i_mode & S_ISGID) {
547 		fe->i_gid = cpu_to_le32(dir->i_gid);
548 		if (S_ISDIR(mode))
549 			mode |= S_ISGID;
550 	} else
551 		fe->i_gid = cpu_to_le32(current->fsgid);
552 	fe->i_mode = cpu_to_le16(mode);
553 	if (S_ISCHR(mode) || S_ISBLK(mode))
554 		fe->id1.dev1.i_rdev = cpu_to_le64(huge_encode_dev(dev));
555 
556 	fe->i_links_count = cpu_to_le16(inode->i_nlink);
557 
558 	fe->i_last_eb_blk = 0;
559 	strcpy(fe->i_signature, OCFS2_INODE_SIGNATURE);
560 	le32_add_cpu(&fe->i_flags, OCFS2_VALID_FL);
561 	fe->i_atime = fe->i_ctime = fe->i_mtime =
562 		cpu_to_le64(CURRENT_TIME.tv_sec);
563 	fe->i_mtime_nsec = fe->i_ctime_nsec = fe->i_atime_nsec =
564 		cpu_to_le32(CURRENT_TIME.tv_nsec);
565 	fe->i_dtime = 0;
566 
567 	fel = &fe->id2.i_list;
568 	fel->l_tree_depth = 0;
569 	fel->l_next_free_rec = 0;
570 	fel->l_count = cpu_to_le16(ocfs2_extent_recs_per_inode(osb->sb));
571 
572 	status = ocfs2_journal_dirty(handle, *new_fe_bh);
573 	if (status < 0) {
574 		mlog_errno(status);
575 		goto leave;
576 	}
577 
578 	if (ocfs2_populate_inode(inode, fe, 1) < 0) {
579 		mlog(ML_ERROR, "populate inode failed! bh->b_blocknr=%llu, "
580 		     "i_blkno=%llu, i_ino=%lu\n",
581 		     (unsigned long long)(*new_fe_bh)->b_blocknr,
582 		     (unsigned long long)le64_to_cpu(fe->i_blkno),
583 		     inode->i_ino);
584 		BUG();
585 	}
586 
587 	ocfs2_inode_set_new(osb, inode);
588 	if (!ocfs2_mount_local(osb)) {
589 		status = ocfs2_create_new_inode_locks(inode);
590 		if (status < 0)
591 			mlog_errno(status);
592 	}
593 
594 	status = 0; /* error in ocfs2_create_new_inode_locks is not
595 		     * critical */
596 
597 	*ret_inode = inode;
598 leave:
599 	if (status < 0) {
600 		if (*new_fe_bh) {
601 			brelse(*new_fe_bh);
602 			*new_fe_bh = NULL;
603 		}
604 		if (inode)
605 			iput(inode);
606 	}
607 
608 	mlog_exit(status);
609 	return status;
610 }
611 
612 static int ocfs2_mkdir(struct inode *dir,
613 		       struct dentry *dentry,
614 		       int mode)
615 {
616 	int ret;
617 
618 	mlog_entry("(0x%p, 0x%p, %d, '%.*s')\n", dir, dentry, mode,
619 		   dentry->d_name.len, dentry->d_name.name);
620 	ret = ocfs2_mknod(dir, dentry, mode | S_IFDIR, 0);
621 	mlog_exit(ret);
622 
623 	return ret;
624 }
625 
626 static int ocfs2_create(struct inode *dir,
627 			struct dentry *dentry,
628 			int mode,
629 			struct nameidata *nd)
630 {
631 	int ret;
632 
633 	mlog_entry("(0x%p, 0x%p, %d, '%.*s')\n", dir, dentry, mode,
634 		   dentry->d_name.len, dentry->d_name.name);
635 	ret = ocfs2_mknod(dir, dentry, mode | S_IFREG, 0);
636 	mlog_exit(ret);
637 
638 	return ret;
639 }
640 
641 static int ocfs2_link(struct dentry *old_dentry,
642 		      struct inode *dir,
643 		      struct dentry *dentry)
644 {
645 	handle_t *handle;
646 	struct inode *inode = old_dentry->d_inode;
647 	int err;
648 	struct buffer_head *fe_bh = NULL;
649 	struct buffer_head *parent_fe_bh = NULL;
650 	struct buffer_head *de_bh = NULL;
651 	struct ocfs2_dinode *fe = NULL;
652 	struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
653 
654 	mlog_entry("(inode=%lu, old='%.*s' new='%.*s')\n", inode->i_ino,
655 		   old_dentry->d_name.len, old_dentry->d_name.name,
656 		   dentry->d_name.len, dentry->d_name.name);
657 
658 	if (S_ISDIR(inode->i_mode))
659 		return -EPERM;
660 
661 	err = ocfs2_meta_lock(dir, &parent_fe_bh, 1);
662 	if (err < 0) {
663 		if (err != -ENOENT)
664 			mlog_errno(err);
665 		return err;
666 	}
667 
668 	if (!dir->i_nlink) {
669 		err = -ENOENT;
670 		goto out;
671 	}
672 
673 	err = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
674 					dentry->d_name.len);
675 	if (err)
676 		goto out;
677 
678 	err = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
679 					   dentry->d_name.name,
680 					   dentry->d_name.len, &de_bh);
681 	if (err < 0) {
682 		mlog_errno(err);
683 		goto out;
684 	}
685 
686 	err = ocfs2_meta_lock(inode, &fe_bh, 1);
687 	if (err < 0) {
688 		if (err != -ENOENT)
689 			mlog_errno(err);
690 		goto out;
691 	}
692 
693 	fe = (struct ocfs2_dinode *) fe_bh->b_data;
694 	if (le16_to_cpu(fe->i_links_count) >= OCFS2_LINK_MAX) {
695 		err = -EMLINK;
696 		goto out_unlock_inode;
697 	}
698 
699 	handle = ocfs2_start_trans(osb, OCFS2_LINK_CREDITS);
700 	if (IS_ERR(handle)) {
701 		err = PTR_ERR(handle);
702 		handle = NULL;
703 		mlog_errno(err);
704 		goto out_unlock_inode;
705 	}
706 
707 	err = ocfs2_journal_access(handle, inode, fe_bh,
708 				   OCFS2_JOURNAL_ACCESS_WRITE);
709 	if (err < 0) {
710 		mlog_errno(err);
711 		goto out_commit;
712 	}
713 
714 	inc_nlink(inode);
715 	inode->i_ctime = CURRENT_TIME;
716 	fe->i_links_count = cpu_to_le16(inode->i_nlink);
717 	fe->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
718 	fe->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
719 
720 	err = ocfs2_journal_dirty(handle, fe_bh);
721 	if (err < 0) {
722 		le16_add_cpu(&fe->i_links_count, -1);
723 		drop_nlink(inode);
724 		mlog_errno(err);
725 		goto out_commit;
726 	}
727 
728 	err = ocfs2_add_entry(handle, dentry, inode,
729 			      OCFS2_I(inode)->ip_blkno,
730 			      parent_fe_bh, de_bh);
731 	if (err) {
732 		le16_add_cpu(&fe->i_links_count, -1);
733 		drop_nlink(inode);
734 		mlog_errno(err);
735 		goto out_commit;
736 	}
737 
738 	err = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(dir)->ip_blkno);
739 	if (err) {
740 		mlog_errno(err);
741 		goto out_commit;
742 	}
743 
744 	atomic_inc(&inode->i_count);
745 	dentry->d_op = &ocfs2_dentry_ops;
746 	d_instantiate(dentry, inode);
747 
748 out_commit:
749 	ocfs2_commit_trans(osb, handle);
750 out_unlock_inode:
751 	ocfs2_meta_unlock(inode, 1);
752 
753 out:
754 	ocfs2_meta_unlock(dir, 1);
755 
756 	if (de_bh)
757 		brelse(de_bh);
758 	if (fe_bh)
759 		brelse(fe_bh);
760 	if (parent_fe_bh)
761 		brelse(parent_fe_bh);
762 
763 	mlog_exit(err);
764 
765 	return err;
766 }
767 
768 /*
769  * Takes and drops an exclusive lock on the given dentry. This will
770  * force other nodes to drop it.
771  */
772 static int ocfs2_remote_dentry_delete(struct dentry *dentry)
773 {
774 	int ret;
775 
776 	ret = ocfs2_dentry_lock(dentry, 1);
777 	if (ret)
778 		mlog_errno(ret);
779 	else
780 		ocfs2_dentry_unlock(dentry, 1);
781 
782 	return ret;
783 }
784 
785 static inline int inode_is_unlinkable(struct inode *inode)
786 {
787 	if (S_ISDIR(inode->i_mode)) {
788 		if (inode->i_nlink == 2)
789 			return 1;
790 		return 0;
791 	}
792 
793 	if (inode->i_nlink == 1)
794 		return 1;
795 	return 0;
796 }
797 
798 static int ocfs2_unlink(struct inode *dir,
799 			struct dentry *dentry)
800 {
801 	int status;
802 	int child_locked = 0;
803 	struct inode *inode = dentry->d_inode;
804 	struct inode *orphan_dir = NULL;
805 	struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
806 	u64 blkno;
807 	struct ocfs2_dinode *fe = NULL;
808 	struct buffer_head *fe_bh = NULL;
809 	struct buffer_head *parent_node_bh = NULL;
810 	handle_t *handle = NULL;
811 	struct ocfs2_dir_entry *dirent = NULL;
812 	struct buffer_head *dirent_bh = NULL;
813 	char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
814 	struct buffer_head *orphan_entry_bh = NULL;
815 
816 	mlog_entry("(0x%p, 0x%p, '%.*s')\n", dir, dentry,
817 		   dentry->d_name.len, dentry->d_name.name);
818 
819 	BUG_ON(dentry->d_parent->d_inode != dir);
820 
821 	mlog(0, "ino = %llu\n", (unsigned long long)OCFS2_I(inode)->ip_blkno);
822 
823 	if (inode == osb->root_inode) {
824 		mlog(0, "Cannot delete the root directory\n");
825 		return -EPERM;
826 	}
827 
828 	status = ocfs2_meta_lock(dir, &parent_node_bh, 1);
829 	if (status < 0) {
830 		if (status != -ENOENT)
831 			mlog_errno(status);
832 		return status;
833 	}
834 
835 	status = ocfs2_find_files_on_disk(dentry->d_name.name,
836 					  dentry->d_name.len, &blkno,
837 					  dir, &dirent_bh, &dirent);
838 	if (status < 0) {
839 		if (status != -ENOENT)
840 			mlog_errno(status);
841 		goto leave;
842 	}
843 
844 	if (OCFS2_I(inode)->ip_blkno != blkno) {
845 		status = -ENOENT;
846 
847 		mlog(0, "ip_blkno %llu != dirent blkno %llu ip_flags = %x\n",
848 		     (unsigned long long)OCFS2_I(inode)->ip_blkno,
849 		     (unsigned long long)blkno, OCFS2_I(inode)->ip_flags);
850 		goto leave;
851 	}
852 
853 	status = ocfs2_meta_lock(inode, &fe_bh, 1);
854 	if (status < 0) {
855 		if (status != -ENOENT)
856 			mlog_errno(status);
857 		goto leave;
858 	}
859 	child_locked = 1;
860 
861 	if (S_ISDIR(inode->i_mode)) {
862 	       	if (!ocfs2_empty_dir(inode)) {
863 			status = -ENOTEMPTY;
864 			goto leave;
865 		} else if (inode->i_nlink != 2) {
866 			status = -ENOTEMPTY;
867 			goto leave;
868 		}
869 	}
870 
871 	status = ocfs2_remote_dentry_delete(dentry);
872 	if (status < 0) {
873 		/* This vote should succeed under all normal
874 		 * circumstances. */
875 		mlog_errno(status);
876 		goto leave;
877 	}
878 
879 	if (inode_is_unlinkable(inode)) {
880 		status = ocfs2_prepare_orphan_dir(osb, &orphan_dir, inode,
881 						  orphan_name,
882 						  &orphan_entry_bh);
883 		if (status < 0) {
884 			mlog_errno(status);
885 			goto leave;
886 		}
887 	}
888 
889 	handle = ocfs2_start_trans(osb, OCFS2_UNLINK_CREDITS);
890 	if (IS_ERR(handle)) {
891 		status = PTR_ERR(handle);
892 		handle = NULL;
893 		mlog_errno(status);
894 		goto leave;
895 	}
896 
897 	status = ocfs2_journal_access(handle, inode, fe_bh,
898 				      OCFS2_JOURNAL_ACCESS_WRITE);
899 	if (status < 0) {
900 		mlog_errno(status);
901 		goto leave;
902 	}
903 
904 	fe = (struct ocfs2_dinode *) fe_bh->b_data;
905 
906 	if (inode_is_unlinkable(inode)) {
907 		status = ocfs2_orphan_add(osb, handle, inode, fe, orphan_name,
908 					  orphan_entry_bh, orphan_dir);
909 		if (status < 0) {
910 			mlog_errno(status);
911 			goto leave;
912 		}
913 	}
914 
915 	/* delete the name from the parent dir */
916 	status = ocfs2_delete_entry(handle, dir, dirent, dirent_bh);
917 	if (status < 0) {
918 		mlog_errno(status);
919 		goto leave;
920 	}
921 
922 	if (S_ISDIR(inode->i_mode))
923 		drop_nlink(inode);
924 	drop_nlink(inode);
925 	fe->i_links_count = cpu_to_le16(inode->i_nlink);
926 
927 	status = ocfs2_journal_dirty(handle, fe_bh);
928 	if (status < 0) {
929 		mlog_errno(status);
930 		goto leave;
931 	}
932 
933 	dir->i_ctime = dir->i_mtime = CURRENT_TIME;
934 	if (S_ISDIR(inode->i_mode))
935 		drop_nlink(dir);
936 
937 	status = ocfs2_mark_inode_dirty(handle, dir, parent_node_bh);
938 	if (status < 0) {
939 		mlog_errno(status);
940 		if (S_ISDIR(inode->i_mode))
941 			inc_nlink(dir);
942 	}
943 
944 leave:
945 	if (handle)
946 		ocfs2_commit_trans(osb, handle);
947 
948 	if (child_locked)
949 		ocfs2_meta_unlock(inode, 1);
950 
951 	ocfs2_meta_unlock(dir, 1);
952 
953 	if (orphan_dir) {
954 		/* This was locked for us in ocfs2_prepare_orphan_dir() */
955 		ocfs2_meta_unlock(orphan_dir, 1);
956 		mutex_unlock(&orphan_dir->i_mutex);
957 		iput(orphan_dir);
958 	}
959 
960 	if (fe_bh)
961 		brelse(fe_bh);
962 
963 	if (dirent_bh)
964 		brelse(dirent_bh);
965 
966 	if (parent_node_bh)
967 		brelse(parent_node_bh);
968 
969 	if (orphan_entry_bh)
970 		brelse(orphan_entry_bh);
971 
972 	mlog_exit(status);
973 
974 	return status;
975 }
976 
977 /*
978  * The only place this should be used is rename!
979  * if they have the same id, then the 1st one is the only one locked.
980  */
981 static int ocfs2_double_lock(struct ocfs2_super *osb,
982 			     struct buffer_head **bh1,
983 			     struct inode *inode1,
984 			     struct buffer_head **bh2,
985 			     struct inode *inode2)
986 {
987 	int status;
988 	struct ocfs2_inode_info *oi1 = OCFS2_I(inode1);
989 	struct ocfs2_inode_info *oi2 = OCFS2_I(inode2);
990 	struct buffer_head **tmpbh;
991 	struct inode *tmpinode;
992 
993 	mlog_entry("(inode1 = %llu, inode2 = %llu)\n",
994 		   (unsigned long long)oi1->ip_blkno,
995 		   (unsigned long long)oi2->ip_blkno);
996 
997 	if (*bh1)
998 		*bh1 = NULL;
999 	if (*bh2)
1000 		*bh2 = NULL;
1001 
1002 	/* we always want to lock the one with the lower lockid first. */
1003 	if (oi1->ip_blkno != oi2->ip_blkno) {
1004 		if (oi1->ip_blkno < oi2->ip_blkno) {
1005 			/* switch id1 and id2 around */
1006 			mlog(0, "switching them around...\n");
1007 			tmpbh = bh2;
1008 			bh2 = bh1;
1009 			bh1 = tmpbh;
1010 
1011 			tmpinode = inode2;
1012 			inode2 = inode1;
1013 			inode1 = tmpinode;
1014 		}
1015 		/* lock id2 */
1016 		status = ocfs2_meta_lock(inode2, bh2, 1);
1017 		if (status < 0) {
1018 			if (status != -ENOENT)
1019 				mlog_errno(status);
1020 			goto bail;
1021 		}
1022 	}
1023 
1024 	/* lock id1 */
1025 	status = ocfs2_meta_lock(inode1, bh1, 1);
1026 	if (status < 0) {
1027 		/*
1028 		 * An error return must mean that no cluster locks
1029 		 * were held on function exit.
1030 		 */
1031 		if (oi1->ip_blkno != oi2->ip_blkno)
1032 			ocfs2_meta_unlock(inode2, 1);
1033 
1034 		if (status != -ENOENT)
1035 			mlog_errno(status);
1036 	}
1037 
1038 bail:
1039 	mlog_exit(status);
1040 	return status;
1041 }
1042 
1043 static void ocfs2_double_unlock(struct inode *inode1, struct inode *inode2)
1044 {
1045 	ocfs2_meta_unlock(inode1, 1);
1046 
1047 	if (inode1 != inode2)
1048 		ocfs2_meta_unlock(inode2, 1);
1049 }
1050 
1051 #define PARENT_INO(buffer) \
1052 	((struct ocfs2_dir_entry *) \
1053 	 ((char *)buffer + \
1054 	  le16_to_cpu(((struct ocfs2_dir_entry *)buffer)->rec_len)))->inode
1055 
1056 static int ocfs2_rename(struct inode *old_dir,
1057 			struct dentry *old_dentry,
1058 			struct inode *new_dir,
1059 			struct dentry *new_dentry)
1060 {
1061 	int status = 0, rename_lock = 0, parents_locked = 0;
1062 	int old_child_locked = 0, new_child_locked = 0;
1063 	struct inode *old_inode = old_dentry->d_inode;
1064 	struct inode *new_inode = new_dentry->d_inode;
1065 	struct inode *orphan_dir = NULL;
1066 	struct ocfs2_dinode *newfe = NULL;
1067 	char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
1068 	struct buffer_head *orphan_entry_bh = NULL;
1069 	struct buffer_head *newfe_bh = NULL;
1070 	struct buffer_head *old_inode_bh = NULL;
1071 	struct buffer_head *insert_entry_bh = NULL;
1072 	struct ocfs2_super *osb = NULL;
1073 	u64 newfe_blkno;
1074 	handle_t *handle = NULL;
1075 	struct buffer_head *old_dir_bh = NULL;
1076 	struct buffer_head *new_dir_bh = NULL;
1077 	struct ocfs2_dir_entry *old_de = NULL, *new_de = NULL; // dirent for old_dentry
1078 							       // and new_dentry
1079 	struct buffer_head *new_de_bh = NULL, *old_de_bh = NULL; // bhs for above
1080 	struct buffer_head *old_inode_de_bh = NULL; // if old_dentry is a dir,
1081 						    // this is the 1st dirent bh
1082 	nlink_t old_dir_nlink = old_dir->i_nlink;
1083 
1084 	/* At some point it might be nice to break this function up a
1085 	 * bit. */
1086 
1087 	mlog_entry("(0x%p, 0x%p, 0x%p, 0x%p, from='%.*s' to='%.*s')\n",
1088 		   old_dir, old_dentry, new_dir, new_dentry,
1089 		   old_dentry->d_name.len, old_dentry->d_name.name,
1090 		   new_dentry->d_name.len, new_dentry->d_name.name);
1091 
1092 	osb = OCFS2_SB(old_dir->i_sb);
1093 
1094 	if (new_inode) {
1095 		if (!igrab(new_inode))
1096 			BUG();
1097 	}
1098 
1099 	/* Assume a directory hierarchy thusly:
1100 	 * a/b/c
1101 	 * a/d
1102 	 * a,b,c, and d are all directories.
1103 	 *
1104 	 * from cwd of 'a' on both nodes:
1105 	 * node1: mv b/c d
1106 	 * node2: mv d   b/c
1107 	 *
1108 	 * And that's why, just like the VFS, we need a file system
1109 	 * rename lock. */
1110 	if (old_dentry != new_dentry) {
1111 		status = ocfs2_rename_lock(osb);
1112 		if (status < 0) {
1113 			mlog_errno(status);
1114 			goto bail;
1115 		}
1116 		rename_lock = 1;
1117 	}
1118 
1119 	/* if old and new are the same, this'll just do one lock. */
1120 	status = ocfs2_double_lock(osb, &old_dir_bh, old_dir,
1121 				   &new_dir_bh, new_dir);
1122 	if (status < 0) {
1123 		mlog_errno(status);
1124 		goto bail;
1125 	}
1126 	parents_locked = 1;
1127 
1128 	/* make sure both dirs have bhs
1129 	 * get an extra ref on old_dir_bh if old==new */
1130 	if (!new_dir_bh) {
1131 		if (old_dir_bh) {
1132 			new_dir_bh = old_dir_bh;
1133 			get_bh(new_dir_bh);
1134 		} else {
1135 			mlog(ML_ERROR, "no old_dir_bh!\n");
1136 			status = -EIO;
1137 			goto bail;
1138 		}
1139 	}
1140 
1141 	/*
1142 	 * Aside from allowing a meta data update, the locking here
1143 	 * also ensures that the vote thread on other nodes won't have
1144 	 * to concurrently downconvert the inode and the dentry locks.
1145 	 */
1146 	status = ocfs2_meta_lock(old_inode, &old_inode_bh, 1);
1147 	if (status < 0) {
1148 		if (status != -ENOENT)
1149 			mlog_errno(status);
1150 		goto bail;
1151 	}
1152 	old_child_locked = 1;
1153 
1154 	status = ocfs2_remote_dentry_delete(old_dentry);
1155 	if (status < 0) {
1156 		mlog_errno(status);
1157 		goto bail;
1158 	}
1159 
1160 	if (S_ISDIR(old_inode->i_mode)) {
1161 		status = -EIO;
1162 		old_inode_de_bh = ocfs2_bread(old_inode, 0, &status, 0);
1163 		if (!old_inode_de_bh)
1164 			goto bail;
1165 
1166 		status = -EIO;
1167 		if (le64_to_cpu(PARENT_INO(old_inode_de_bh->b_data)) !=
1168 		    OCFS2_I(old_dir)->ip_blkno)
1169 			goto bail;
1170 		status = -EMLINK;
1171 		if (!new_inode && new_dir!=old_dir &&
1172 		    new_dir->i_nlink >= OCFS2_LINK_MAX)
1173 			goto bail;
1174 	}
1175 
1176 	status = -ENOENT;
1177 	old_de_bh = ocfs2_find_entry(old_dentry->d_name.name,
1178 				     old_dentry->d_name.len,
1179 				     old_dir, &old_de);
1180 	if (!old_de_bh)
1181 		goto bail;
1182 
1183 	/*
1184 	 *  Check for inode number is _not_ due to possible IO errors.
1185 	 *  We might rmdir the source, keep it as pwd of some process
1186 	 *  and merrily kill the link to whatever was created under the
1187 	 *  same name. Goodbye sticky bit ;-<
1188 	 */
1189 	if (le64_to_cpu(old_de->inode) != OCFS2_I(old_inode)->ip_blkno)
1190 		goto bail;
1191 
1192 	/* check if the target already exists (in which case we need
1193 	 * to delete it */
1194 	status = ocfs2_find_files_on_disk(new_dentry->d_name.name,
1195 					  new_dentry->d_name.len,
1196 					  &newfe_blkno, new_dir, &new_de_bh,
1197 					  &new_de);
1198 	/* The only error we allow here is -ENOENT because the new
1199 	 * file not existing is perfectly valid. */
1200 	if ((status < 0) && (status != -ENOENT)) {
1201 		/* If we cannot find the file specified we should just */
1202 		/* return the error... */
1203 		mlog_errno(status);
1204 		goto bail;
1205 	}
1206 
1207 	if (!new_de && new_inode)
1208 		mlog(ML_ERROR, "inode %lu does not exist in it's parent "
1209 		     "directory!", new_inode->i_ino);
1210 
1211 	/* In case we need to overwrite an existing file, we blow it
1212 	 * away first */
1213 	if (new_de) {
1214 		/* VFS didn't think there existed an inode here, but
1215 		 * someone else in the cluster must have raced our
1216 		 * rename to create one. Today we error cleanly, in
1217 		 * the future we should consider calling iget to build
1218 		 * a new struct inode for this entry. */
1219 		if (!new_inode) {
1220 			status = -EACCES;
1221 
1222 			mlog(0, "We found an inode for name %.*s but VFS "
1223 			     "didn't give us one.\n", new_dentry->d_name.len,
1224 			     new_dentry->d_name.name);
1225 			goto bail;
1226 		}
1227 
1228 		if (OCFS2_I(new_inode)->ip_blkno != newfe_blkno) {
1229 			status = -EACCES;
1230 
1231 			mlog(0, "Inode %llu and dir %llu disagree. flags = %x\n",
1232 			     (unsigned long long)OCFS2_I(new_inode)->ip_blkno,
1233 			     (unsigned long long)newfe_blkno,
1234 			     OCFS2_I(new_inode)->ip_flags);
1235 			goto bail;
1236 		}
1237 
1238 		status = ocfs2_meta_lock(new_inode, &newfe_bh, 1);
1239 		if (status < 0) {
1240 			if (status != -ENOENT)
1241 				mlog_errno(status);
1242 			goto bail;
1243 		}
1244 		new_child_locked = 1;
1245 
1246 		status = ocfs2_remote_dentry_delete(new_dentry);
1247 		if (status < 0) {
1248 			mlog_errno(status);
1249 			goto bail;
1250 		}
1251 
1252 		newfe = (struct ocfs2_dinode *) newfe_bh->b_data;
1253 
1254 		mlog(0, "aha rename over existing... new_de=%p new_blkno=%llu "
1255 		     "newfebh=%p bhblocknr=%llu\n", new_de,
1256 		     (unsigned long long)newfe_blkno, newfe_bh, newfe_bh ?
1257 		     (unsigned long long)newfe_bh->b_blocknr : 0ULL);
1258 
1259 		if (S_ISDIR(new_inode->i_mode) || (new_inode->i_nlink == 1)) {
1260 			status = ocfs2_prepare_orphan_dir(osb, &orphan_dir,
1261 							  new_inode,
1262 							  orphan_name,
1263 							  &orphan_entry_bh);
1264 			if (status < 0) {
1265 				mlog_errno(status);
1266 				goto bail;
1267 			}
1268 		}
1269 	} else {
1270 		BUG_ON(new_dentry->d_parent->d_inode != new_dir);
1271 
1272 		status = ocfs2_check_dir_for_entry(new_dir,
1273 						   new_dentry->d_name.name,
1274 						   new_dentry->d_name.len);
1275 		if (status)
1276 			goto bail;
1277 
1278 		status = ocfs2_prepare_dir_for_insert(osb, new_dir, new_dir_bh,
1279 						      new_dentry->d_name.name,
1280 						      new_dentry->d_name.len,
1281 						      &insert_entry_bh);
1282 		if (status < 0) {
1283 			mlog_errno(status);
1284 			goto bail;
1285 		}
1286 	}
1287 
1288 	handle = ocfs2_start_trans(osb, OCFS2_RENAME_CREDITS);
1289 	if (IS_ERR(handle)) {
1290 		status = PTR_ERR(handle);
1291 		handle = NULL;
1292 		mlog_errno(status);
1293 		goto bail;
1294 	}
1295 
1296 	if (new_de) {
1297 		if (S_ISDIR(new_inode->i_mode)) {
1298 			if (!ocfs2_empty_dir(new_inode) ||
1299 			    new_inode->i_nlink != 2) {
1300 				status = -ENOTEMPTY;
1301 				goto bail;
1302 			}
1303 		}
1304 		status = ocfs2_journal_access(handle, new_inode, newfe_bh,
1305 					      OCFS2_JOURNAL_ACCESS_WRITE);
1306 		if (status < 0) {
1307 			mlog_errno(status);
1308 			goto bail;
1309 		}
1310 
1311 		if (S_ISDIR(new_inode->i_mode) ||
1312 		    (newfe->i_links_count == cpu_to_le16(1))){
1313 			status = ocfs2_orphan_add(osb, handle, new_inode,
1314 						  newfe, orphan_name,
1315 						  orphan_entry_bh, orphan_dir);
1316 			if (status < 0) {
1317 				mlog_errno(status);
1318 				goto bail;
1319 			}
1320 		}
1321 
1322 		/* change the dirent to point to the correct inode */
1323 		status = ocfs2_journal_access(handle, new_dir, new_de_bh,
1324 					      OCFS2_JOURNAL_ACCESS_WRITE);
1325 		if (status < 0) {
1326 			mlog_errno(status);
1327 			goto bail;
1328 		}
1329 		new_de->inode = cpu_to_le64(OCFS2_I(old_inode)->ip_blkno);
1330 		new_de->file_type = old_de->file_type;
1331 		new_dir->i_version++;
1332 		status = ocfs2_journal_dirty(handle, new_de_bh);
1333 		if (status < 0) {
1334 			mlog_errno(status);
1335 			goto bail;
1336 		}
1337 
1338 		if (S_ISDIR(new_inode->i_mode))
1339 			newfe->i_links_count = 0;
1340 		else
1341 			le16_add_cpu(&newfe->i_links_count, -1);
1342 
1343 		status = ocfs2_journal_dirty(handle, newfe_bh);
1344 		if (status < 0) {
1345 			mlog_errno(status);
1346 			goto bail;
1347 		}
1348 	} else {
1349 		/* if the name was not found in new_dir, add it now */
1350 		status = ocfs2_add_entry(handle, new_dentry, old_inode,
1351 					 OCFS2_I(old_inode)->ip_blkno,
1352 					 new_dir_bh, insert_entry_bh);
1353 	}
1354 
1355 	old_inode->i_ctime = CURRENT_TIME;
1356 	mark_inode_dirty(old_inode);
1357 	ocfs2_mark_inode_dirty(handle, old_inode, old_inode_bh);
1358 
1359 	/* now that the name has been added to new_dir, remove the old name */
1360 	status = ocfs2_delete_entry(handle, old_dir, old_de, old_de_bh);
1361 	if (status < 0) {
1362 		mlog_errno(status);
1363 		goto bail;
1364 	}
1365 
1366 	if (new_inode) {
1367 		new_inode->i_nlink--;
1368 		new_inode->i_ctime = CURRENT_TIME;
1369 	}
1370 	old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
1371 	if (old_inode_de_bh) {
1372 		status = ocfs2_journal_access(handle, old_inode,
1373 					     old_inode_de_bh,
1374 					     OCFS2_JOURNAL_ACCESS_WRITE);
1375 		PARENT_INO(old_inode_de_bh->b_data) =
1376 			cpu_to_le64(OCFS2_I(new_dir)->ip_blkno);
1377 		status = ocfs2_journal_dirty(handle, old_inode_de_bh);
1378 		old_dir->i_nlink--;
1379 		if (new_inode) {
1380 			new_inode->i_nlink--;
1381 		} else {
1382 			inc_nlink(new_dir);
1383 			mark_inode_dirty(new_dir);
1384 		}
1385 	}
1386 	mark_inode_dirty(old_dir);
1387 	ocfs2_mark_inode_dirty(handle, old_dir, old_dir_bh);
1388 	if (new_inode) {
1389 		mark_inode_dirty(new_inode);
1390 		ocfs2_mark_inode_dirty(handle, new_inode, newfe_bh);
1391 	}
1392 
1393 	if (old_dir != new_dir) {
1394 		/* Keep the same times on both directories.*/
1395 		new_dir->i_ctime = new_dir->i_mtime = old_dir->i_ctime;
1396 
1397 		/*
1398 		 * This will also pick up the i_nlink change from the
1399 		 * block above.
1400 		 */
1401 		ocfs2_mark_inode_dirty(handle, new_dir, new_dir_bh);
1402 	}
1403 
1404 	if (old_dir_nlink != old_dir->i_nlink) {
1405 		if (!old_dir_bh) {
1406 			mlog(ML_ERROR, "need to change nlink for old dir "
1407 			     "%llu from %d to %d but bh is NULL!\n",
1408 			     (unsigned long long)OCFS2_I(old_dir)->ip_blkno,
1409 			     (int)old_dir_nlink, old_dir->i_nlink);
1410 		} else {
1411 			struct ocfs2_dinode *fe;
1412 			status = ocfs2_journal_access(handle, old_dir,
1413 						      old_dir_bh,
1414 						      OCFS2_JOURNAL_ACCESS_WRITE);
1415 			fe = (struct ocfs2_dinode *) old_dir_bh->b_data;
1416 			fe->i_links_count = cpu_to_le16(old_dir->i_nlink);
1417 			status = ocfs2_journal_dirty(handle, old_dir_bh);
1418 		}
1419 	}
1420 
1421 	ocfs2_dentry_move(old_dentry, new_dentry, old_dir, new_dir);
1422 	status = 0;
1423 bail:
1424 	if (rename_lock)
1425 		ocfs2_rename_unlock(osb);
1426 
1427 	if (handle)
1428 		ocfs2_commit_trans(osb, handle);
1429 
1430 	if (parents_locked)
1431 		ocfs2_double_unlock(old_dir, new_dir);
1432 
1433 	if (old_child_locked)
1434 		ocfs2_meta_unlock(old_inode, 1);
1435 
1436 	if (new_child_locked)
1437 		ocfs2_meta_unlock(new_inode, 1);
1438 
1439 	if (orphan_dir) {
1440 		/* This was locked for us in ocfs2_prepare_orphan_dir() */
1441 		ocfs2_meta_unlock(orphan_dir, 1);
1442 		mutex_unlock(&orphan_dir->i_mutex);
1443 		iput(orphan_dir);
1444 	}
1445 
1446 	if (new_inode)
1447 		sync_mapping_buffers(old_inode->i_mapping);
1448 
1449 	if (new_inode)
1450 		iput(new_inode);
1451 	if (newfe_bh)
1452 		brelse(newfe_bh);
1453 	if (old_inode_bh)
1454 		brelse(old_inode_bh);
1455 	if (old_dir_bh)
1456 		brelse(old_dir_bh);
1457 	if (new_dir_bh)
1458 		brelse(new_dir_bh);
1459 	if (new_de_bh)
1460 		brelse(new_de_bh);
1461 	if (old_de_bh)
1462 		brelse(old_de_bh);
1463 	if (old_inode_de_bh)
1464 		brelse(old_inode_de_bh);
1465 	if (orphan_entry_bh)
1466 		brelse(orphan_entry_bh);
1467 	if (insert_entry_bh)
1468 		brelse(insert_entry_bh);
1469 
1470 	mlog_exit(status);
1471 
1472 	return status;
1473 }
1474 
1475 /*
1476  * we expect i_size = strlen(symname). Copy symname into the file
1477  * data, including the null terminator.
1478  */
1479 static int ocfs2_create_symlink_data(struct ocfs2_super *osb,
1480 				     handle_t *handle,
1481 				     struct inode *inode,
1482 				     const char *symname)
1483 {
1484 	struct buffer_head **bhs = NULL;
1485 	const char *c;
1486 	struct super_block *sb = osb->sb;
1487 	u64 p_blkno, p_blocks;
1488 	int virtual, blocks, status, i, bytes_left;
1489 
1490 	bytes_left = i_size_read(inode) + 1;
1491 	/* we can't trust i_blocks because we're actually going to
1492 	 * write i_size + 1 bytes. */
1493 	blocks = (bytes_left + sb->s_blocksize - 1) >> sb->s_blocksize_bits;
1494 
1495 	mlog_entry("i_blocks = %llu, i_size = %llu, blocks = %d\n",
1496 			(unsigned long long)inode->i_blocks,
1497 			i_size_read(inode), blocks);
1498 
1499 	/* Sanity check -- make sure we're going to fit. */
1500 	if (bytes_left >
1501 	    ocfs2_clusters_to_bytes(sb, OCFS2_I(inode)->ip_clusters)) {
1502 		status = -EIO;
1503 		mlog_errno(status);
1504 		goto bail;
1505 	}
1506 
1507 	bhs = kcalloc(blocks, sizeof(struct buffer_head *), GFP_KERNEL);
1508 	if (!bhs) {
1509 		status = -ENOMEM;
1510 		mlog_errno(status);
1511 		goto bail;
1512 	}
1513 
1514 	status = ocfs2_extent_map_get_blocks(inode, 0, &p_blkno, &p_blocks,
1515 					     NULL);
1516 	if (status < 0) {
1517 		mlog_errno(status);
1518 		goto bail;
1519 	}
1520 
1521 	/* links can never be larger than one cluster so we know this
1522 	 * is all going to be contiguous, but do a sanity check
1523 	 * anyway. */
1524 	if ((p_blocks << sb->s_blocksize_bits) < bytes_left) {
1525 		status = -EIO;
1526 		mlog_errno(status);
1527 		goto bail;
1528 	}
1529 
1530 	virtual = 0;
1531 	while(bytes_left > 0) {
1532 		c = &symname[virtual * sb->s_blocksize];
1533 
1534 		bhs[virtual] = sb_getblk(sb, p_blkno);
1535 		if (!bhs[virtual]) {
1536 			status = -ENOMEM;
1537 			mlog_errno(status);
1538 			goto bail;
1539 		}
1540 		ocfs2_set_new_buffer_uptodate(inode, bhs[virtual]);
1541 
1542 		status = ocfs2_journal_access(handle, inode, bhs[virtual],
1543 					      OCFS2_JOURNAL_ACCESS_CREATE);
1544 		if (status < 0) {
1545 			mlog_errno(status);
1546 			goto bail;
1547 		}
1548 
1549 		memset(bhs[virtual]->b_data, 0, sb->s_blocksize);
1550 
1551 		memcpy(bhs[virtual]->b_data, c,
1552 		       (bytes_left > sb->s_blocksize) ? sb->s_blocksize :
1553 		       bytes_left);
1554 
1555 		status = ocfs2_journal_dirty(handle, bhs[virtual]);
1556 		if (status < 0) {
1557 			mlog_errno(status);
1558 			goto bail;
1559 		}
1560 
1561 		virtual++;
1562 		p_blkno++;
1563 		bytes_left -= sb->s_blocksize;
1564 	}
1565 
1566 	status = 0;
1567 bail:
1568 
1569 	if (bhs) {
1570 		for(i = 0; i < blocks; i++)
1571 			if (bhs[i])
1572 				brelse(bhs[i]);
1573 		kfree(bhs);
1574 	}
1575 
1576 	mlog_exit(status);
1577 	return status;
1578 }
1579 
1580 static int ocfs2_symlink(struct inode *dir,
1581 			 struct dentry *dentry,
1582 			 const char *symname)
1583 {
1584 	int status, l, credits;
1585 	u64 newsize;
1586 	struct ocfs2_super *osb = NULL;
1587 	struct inode *inode = NULL;
1588 	struct super_block *sb;
1589 	struct buffer_head *new_fe_bh = NULL;
1590 	struct buffer_head *de_bh = NULL;
1591 	struct buffer_head *parent_fe_bh = NULL;
1592 	struct ocfs2_dinode *fe = NULL;
1593 	struct ocfs2_dinode *dirfe;
1594 	handle_t *handle = NULL;
1595 	struct ocfs2_alloc_context *inode_ac = NULL;
1596 	struct ocfs2_alloc_context *data_ac = NULL;
1597 
1598 	mlog_entry("(0x%p, 0x%p, symname='%s' actual='%.*s')\n", dir,
1599 		   dentry, symname, dentry->d_name.len, dentry->d_name.name);
1600 
1601 	sb = dir->i_sb;
1602 	osb = OCFS2_SB(sb);
1603 
1604 	l = strlen(symname) + 1;
1605 
1606 	credits = ocfs2_calc_symlink_credits(sb);
1607 
1608 	/* lock the parent directory */
1609 	status = ocfs2_meta_lock(dir, &parent_fe_bh, 1);
1610 	if (status < 0) {
1611 		if (status != -ENOENT)
1612 			mlog_errno(status);
1613 		return status;
1614 	}
1615 
1616 	dirfe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
1617 	if (!dirfe->i_links_count) {
1618 		/* can't make a file in a deleted directory. */
1619 		status = -ENOENT;
1620 		goto bail;
1621 	}
1622 
1623 	status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
1624 					   dentry->d_name.len);
1625 	if (status)
1626 		goto bail;
1627 
1628 	status = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
1629 					      dentry->d_name.name,
1630 					      dentry->d_name.len, &de_bh);
1631 	if (status < 0) {
1632 		mlog_errno(status);
1633 		goto bail;
1634 	}
1635 
1636 	status = ocfs2_reserve_new_inode(osb, &inode_ac);
1637 	if (status < 0) {
1638 		if (status != -ENOSPC)
1639 			mlog_errno(status);
1640 		goto bail;
1641 	}
1642 
1643 	/* don't reserve bitmap space for fast symlinks. */
1644 	if (l > ocfs2_fast_symlink_chars(sb)) {
1645 		status = ocfs2_reserve_clusters(osb, 1, &data_ac);
1646 		if (status < 0) {
1647 			if (status != -ENOSPC)
1648 				mlog_errno(status);
1649 			goto bail;
1650 		}
1651 	}
1652 
1653 	handle = ocfs2_start_trans(osb, credits);
1654 	if (IS_ERR(handle)) {
1655 		status = PTR_ERR(handle);
1656 		handle = NULL;
1657 		mlog_errno(status);
1658 		goto bail;
1659 	}
1660 
1661 	status = ocfs2_mknod_locked(osb, dir, dentry,
1662 				    S_IFLNK | S_IRWXUGO, 0,
1663 				    &new_fe_bh, parent_fe_bh, handle,
1664 				    &inode, inode_ac);
1665 	if (status < 0) {
1666 		mlog_errno(status);
1667 		goto bail;
1668 	}
1669 
1670 	fe = (struct ocfs2_dinode *) new_fe_bh->b_data;
1671 	inode->i_rdev = 0;
1672 	newsize = l - 1;
1673 	if (l > ocfs2_fast_symlink_chars(sb)) {
1674 		u32 offset = 0;
1675 
1676 		inode->i_op = &ocfs2_symlink_inode_operations;
1677 		status = ocfs2_do_extend_allocation(osb, inode, &offset, 1,
1678 						    new_fe_bh,
1679 						    handle, data_ac, NULL,
1680 						    NULL);
1681 		if (status < 0) {
1682 			if (status != -ENOSPC && status != -EINTR) {
1683 				mlog(ML_ERROR,
1684 				     "Failed to extend file to %llu\n",
1685 				     (unsigned long long)newsize);
1686 				mlog_errno(status);
1687 				status = -ENOSPC;
1688 			}
1689 			goto bail;
1690 		}
1691 		i_size_write(inode, newsize);
1692 		inode->i_blocks = ocfs2_inode_sector_count(inode);
1693 	} else {
1694 		inode->i_op = &ocfs2_fast_symlink_inode_operations;
1695 		memcpy((char *) fe->id2.i_symlink, symname, l);
1696 		i_size_write(inode, newsize);
1697 		inode->i_blocks = 0;
1698 	}
1699 
1700 	status = ocfs2_mark_inode_dirty(handle, inode, new_fe_bh);
1701 	if (status < 0) {
1702 		mlog_errno(status);
1703 		goto bail;
1704 	}
1705 
1706 	if (!ocfs2_inode_is_fast_symlink(inode)) {
1707 		status = ocfs2_create_symlink_data(osb, handle, inode,
1708 						   symname);
1709 		if (status < 0) {
1710 			mlog_errno(status);
1711 			goto bail;
1712 		}
1713 	}
1714 
1715 	status = ocfs2_add_entry(handle, dentry, inode,
1716 				 le64_to_cpu(fe->i_blkno), parent_fe_bh,
1717 				 de_bh);
1718 	if (status < 0) {
1719 		mlog_errno(status);
1720 		goto bail;
1721 	}
1722 
1723 	status = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(dir)->ip_blkno);
1724 	if (status) {
1725 		mlog_errno(status);
1726 		goto bail;
1727 	}
1728 
1729 	insert_inode_hash(inode);
1730 	dentry->d_op = &ocfs2_dentry_ops;
1731 	d_instantiate(dentry, inode);
1732 bail:
1733 	if (handle)
1734 		ocfs2_commit_trans(osb, handle);
1735 
1736 	ocfs2_meta_unlock(dir, 1);
1737 
1738 	if (new_fe_bh)
1739 		brelse(new_fe_bh);
1740 	if (parent_fe_bh)
1741 		brelse(parent_fe_bh);
1742 	if (de_bh)
1743 		brelse(de_bh);
1744 	if (inode_ac)
1745 		ocfs2_free_alloc_context(inode_ac);
1746 	if (data_ac)
1747 		ocfs2_free_alloc_context(data_ac);
1748 	if ((status < 0) && inode)
1749 		iput(inode);
1750 
1751 	mlog_exit(status);
1752 
1753 	return status;
1754 }
1755 
1756 int ocfs2_check_dir_entry(struct inode * dir,
1757 			  struct ocfs2_dir_entry * de,
1758 			  struct buffer_head * bh,
1759 			  unsigned long offset)
1760 {
1761 	const char *error_msg = NULL;
1762 	const int rlen = le16_to_cpu(de->rec_len);
1763 
1764 	if (rlen < OCFS2_DIR_REC_LEN(1))
1765 		error_msg = "rec_len is smaller than minimal";
1766 	else if (rlen % 4 != 0)
1767 		error_msg = "rec_len % 4 != 0";
1768 	else if (rlen < OCFS2_DIR_REC_LEN(de->name_len))
1769 		error_msg = "rec_len is too small for name_len";
1770 	else if (((char *) de - bh->b_data) + rlen > dir->i_sb->s_blocksize)
1771 		error_msg = "directory entry across blocks";
1772 
1773 	if (error_msg != NULL)
1774 		mlog(ML_ERROR, "bad entry in directory #%llu: %s - "
1775 		     "offset=%lu, inode=%llu, rec_len=%d, name_len=%d\n",
1776 		     (unsigned long long)OCFS2_I(dir)->ip_blkno, error_msg,
1777 		     offset, (unsigned long long)le64_to_cpu(de->inode), rlen,
1778 		     de->name_len);
1779 	return error_msg == NULL ? 1 : 0;
1780 }
1781 
1782 /* we don't always have a dentry for what we want to add, so people
1783  * like orphan dir can call this instead.
1784  *
1785  * If you pass me insert_bh, I'll skip the search of the other dir
1786  * blocks and put the record in there.
1787  */
1788 static int __ocfs2_add_entry(handle_t *handle,
1789 			     struct inode *dir,
1790 			     const char *name, int namelen,
1791 			     struct inode *inode, u64 blkno,
1792 			     struct buffer_head *parent_fe_bh,
1793 			     struct buffer_head *insert_bh)
1794 {
1795 	unsigned long offset;
1796 	unsigned short rec_len;
1797 	struct ocfs2_dir_entry *de, *de1;
1798 	struct super_block *sb;
1799 	int retval, status;
1800 
1801 	mlog_entry_void();
1802 
1803 	sb = dir->i_sb;
1804 
1805 	if (!namelen)
1806 		return -EINVAL;
1807 
1808 	rec_len = OCFS2_DIR_REC_LEN(namelen);
1809 	offset = 0;
1810 	de = (struct ocfs2_dir_entry *) insert_bh->b_data;
1811 	while (1) {
1812 		BUG_ON((char *)de >= sb->s_blocksize + insert_bh->b_data);
1813 		/* These checks should've already been passed by the
1814 		 * prepare function, but I guess we can leave them
1815 		 * here anyway. */
1816 		if (!ocfs2_check_dir_entry(dir, de, insert_bh, offset)) {
1817 			retval = -ENOENT;
1818 			goto bail;
1819 		}
1820 		if (ocfs2_match(namelen, name, de)) {
1821 			retval = -EEXIST;
1822 			goto bail;
1823 		}
1824 		if (((le64_to_cpu(de->inode) == 0) &&
1825 		     (le16_to_cpu(de->rec_len) >= rec_len)) ||
1826 		    (le16_to_cpu(de->rec_len) >=
1827 		     (OCFS2_DIR_REC_LEN(de->name_len) + rec_len))) {
1828 			dir->i_mtime = dir->i_ctime = CURRENT_TIME;
1829 			retval = ocfs2_mark_inode_dirty(handle, dir, parent_fe_bh);
1830 			if (retval < 0) {
1831 				mlog_errno(retval);
1832 				goto bail;
1833 			}
1834 
1835 			status = ocfs2_journal_access(handle, dir, insert_bh,
1836 						      OCFS2_JOURNAL_ACCESS_WRITE);
1837 			/* By now the buffer is marked for journaling */
1838 			offset += le16_to_cpu(de->rec_len);
1839 			if (le64_to_cpu(de->inode)) {
1840 				de1 = (struct ocfs2_dir_entry *)((char *) de +
1841 					OCFS2_DIR_REC_LEN(de->name_len));
1842 				de1->rec_len =
1843 					cpu_to_le16(le16_to_cpu(de->rec_len) -
1844 					OCFS2_DIR_REC_LEN(de->name_len));
1845 				de->rec_len = cpu_to_le16(OCFS2_DIR_REC_LEN(de->name_len));
1846 				de = de1;
1847 			}
1848 			de->file_type = OCFS2_FT_UNKNOWN;
1849 			if (blkno) {
1850 				de->inode = cpu_to_le64(blkno);
1851 				ocfs2_set_de_type(de, inode->i_mode);
1852 			} else
1853 				de->inode = 0;
1854 			de->name_len = namelen;
1855 			memcpy(de->name, name, namelen);
1856 
1857 			dir->i_version++;
1858 			status = ocfs2_journal_dirty(handle, insert_bh);
1859 			retval = 0;
1860 			goto bail;
1861 		}
1862 		offset += le16_to_cpu(de->rec_len);
1863 		de = (struct ocfs2_dir_entry *) ((char *) de + le16_to_cpu(de->rec_len));
1864 	}
1865 
1866 	/* when you think about it, the assert above should prevent us
1867 	 * from ever getting here. */
1868 	retval = -ENOSPC;
1869 bail:
1870 
1871 	mlog_exit(retval);
1872 	return retval;
1873 }
1874 
1875 
1876 /*
1877  * ocfs2_delete_entry deletes a directory entry by merging it with the
1878  * previous entry
1879  */
1880 static int ocfs2_delete_entry(handle_t *handle,
1881 			      struct inode *dir,
1882 			      struct ocfs2_dir_entry *de_del,
1883 			      struct buffer_head *bh)
1884 {
1885 	struct ocfs2_dir_entry *de, *pde;
1886 	int i, status = -ENOENT;
1887 
1888 	mlog_entry("(0x%p, 0x%p, 0x%p, 0x%p)\n", handle, dir, de_del, bh);
1889 
1890 	i = 0;
1891 	pde = NULL;
1892 	de = (struct ocfs2_dir_entry *) bh->b_data;
1893 	while (i < bh->b_size) {
1894 		if (!ocfs2_check_dir_entry(dir, de, bh, i)) {
1895 			status = -EIO;
1896 			mlog_errno(status);
1897 			goto bail;
1898 		}
1899 		if (de == de_del)  {
1900 			status = ocfs2_journal_access(handle, dir, bh,
1901 						      OCFS2_JOURNAL_ACCESS_WRITE);
1902 			if (status < 0) {
1903 				status = -EIO;
1904 				mlog_errno(status);
1905 				goto bail;
1906 			}
1907 			if (pde)
1908 				pde->rec_len =
1909 					cpu_to_le16(le16_to_cpu(pde->rec_len) +
1910 						    le16_to_cpu(de->rec_len));
1911 			else
1912 				de->inode = 0;
1913 			dir->i_version++;
1914 			status = ocfs2_journal_dirty(handle, bh);
1915 			goto bail;
1916 		}
1917 		i += le16_to_cpu(de->rec_len);
1918 		pde = de;
1919 		de = (struct ocfs2_dir_entry *)((char *)de + le16_to_cpu(de->rec_len));
1920 	}
1921 bail:
1922 	mlog_exit(status);
1923 	return status;
1924 }
1925 
1926 /*
1927  * Returns 0 if not found, -1 on failure, and 1 on success
1928  */
1929 static int inline ocfs2_search_dirblock(struct buffer_head *bh,
1930 					struct inode *dir,
1931 					const char *name, int namelen,
1932 					unsigned long offset,
1933 					struct ocfs2_dir_entry **res_dir)
1934 {
1935 	struct ocfs2_dir_entry *de;
1936 	char *dlimit, *de_buf;
1937 	int de_len;
1938 	int ret = 0;
1939 
1940 	mlog_entry_void();
1941 
1942 	de_buf = bh->b_data;
1943 	dlimit = de_buf + dir->i_sb->s_blocksize;
1944 
1945 	while (de_buf < dlimit) {
1946 		/* this code is executed quadratically often */
1947 		/* do minimal checking `by hand' */
1948 
1949 		de = (struct ocfs2_dir_entry *) de_buf;
1950 
1951 		if (de_buf + namelen <= dlimit &&
1952 		    ocfs2_match(namelen, name, de)) {
1953 			/* found a match - just to be sure, do a full check */
1954 			if (!ocfs2_check_dir_entry(dir, de, bh, offset)) {
1955 				ret = -1;
1956 				goto bail;
1957 			}
1958 			*res_dir = de;
1959 			ret = 1;
1960 			goto bail;
1961 		}
1962 
1963 		/* prevent looping on a bad block */
1964 		de_len = le16_to_cpu(de->rec_len);
1965 		if (de_len <= 0) {
1966 			ret = -1;
1967 			goto bail;
1968 		}
1969 
1970 		de_buf += de_len;
1971 		offset += de_len;
1972 	}
1973 
1974 bail:
1975 	mlog_exit(ret);
1976 	return ret;
1977 }
1978 
1979 struct buffer_head *ocfs2_find_entry(const char *name, int namelen,
1980 				     struct inode *dir,
1981 				     struct ocfs2_dir_entry **res_dir)
1982 {
1983 	struct super_block *sb;
1984 	struct buffer_head *bh_use[NAMEI_RA_SIZE];
1985 	struct buffer_head *bh, *ret = NULL;
1986 	unsigned long start, block, b;
1987 	int ra_max = 0;		/* Number of bh's in the readahead
1988 				   buffer, bh_use[] */
1989 	int ra_ptr = 0;		/* Current index into readahead
1990 				   buffer */
1991 	int num = 0;
1992 	int nblocks, i, err;
1993 
1994 	mlog_entry_void();
1995 
1996 	*res_dir = NULL;
1997 	sb = dir->i_sb;
1998 
1999 	nblocks = i_size_read(dir) >> sb->s_blocksize_bits;
2000 	start = OCFS2_I(dir)->ip_dir_start_lookup;
2001 	if (start >= nblocks)
2002 		start = 0;
2003 	block = start;
2004 
2005 restart:
2006 	do {
2007 		/*
2008 		 * We deal with the read-ahead logic here.
2009 		 */
2010 		if (ra_ptr >= ra_max) {
2011 			/* Refill the readahead buffer */
2012 			ra_ptr = 0;
2013 			b = block;
2014 			for (ra_max = 0; ra_max < NAMEI_RA_SIZE; ra_max++) {
2015 				/*
2016 				 * Terminate if we reach the end of the
2017 				 * directory and must wrap, or if our
2018 				 * search has finished at this block.
2019 				 */
2020 				if (b >= nblocks || (num && block == start)) {
2021 					bh_use[ra_max] = NULL;
2022 					break;
2023 				}
2024 				num++;
2025 
2026 				bh = ocfs2_bread(dir, b++, &err, 1);
2027 				bh_use[ra_max] = bh;
2028 			}
2029 		}
2030 		if ((bh = bh_use[ra_ptr++]) == NULL)
2031 			goto next;
2032 		wait_on_buffer(bh);
2033 		if (!buffer_uptodate(bh)) {
2034 			/* read error, skip block & hope for the best */
2035 			ocfs2_error(dir->i_sb, "reading directory %llu, "
2036 				    "offset %lu\n",
2037 				    (unsigned long long)OCFS2_I(dir)->ip_blkno,
2038 				    block);
2039 			brelse(bh);
2040 			goto next;
2041 		}
2042 		i = ocfs2_search_dirblock(bh, dir, name, namelen,
2043 					  block << sb->s_blocksize_bits,
2044 					  res_dir);
2045 		if (i == 1) {
2046 			OCFS2_I(dir)->ip_dir_start_lookup = block;
2047 			ret = bh;
2048 			goto cleanup_and_exit;
2049 		} else {
2050 			brelse(bh);
2051 			if (i < 0)
2052 				goto cleanup_and_exit;
2053 		}
2054 	next:
2055 		if (++block >= nblocks)
2056 			block = 0;
2057 	} while (block != start);
2058 
2059 	/*
2060 	 * If the directory has grown while we were searching, then
2061 	 * search the last part of the directory before giving up.
2062 	 */
2063 	block = nblocks;
2064 	nblocks = i_size_read(dir) >> sb->s_blocksize_bits;
2065 	if (block < nblocks) {
2066 		start = 0;
2067 		goto restart;
2068 	}
2069 
2070 cleanup_and_exit:
2071 	/* Clean up the read-ahead blocks */
2072 	for (; ra_ptr < ra_max; ra_ptr++)
2073 		brelse(bh_use[ra_ptr]);
2074 
2075 	mlog_exit_ptr(ret);
2076 	return ret;
2077 }
2078 
2079 static int ocfs2_blkno_stringify(u64 blkno, char *name)
2080 {
2081 	int status, namelen;
2082 
2083 	mlog_entry_void();
2084 
2085 	namelen = snprintf(name, OCFS2_ORPHAN_NAMELEN + 1, "%016llx",
2086 			   (long long)blkno);
2087 	if (namelen <= 0) {
2088 		if (namelen)
2089 			status = namelen;
2090 		else
2091 			status = -EINVAL;
2092 		mlog_errno(status);
2093 		goto bail;
2094 	}
2095 	if (namelen != OCFS2_ORPHAN_NAMELEN) {
2096 		status = -EINVAL;
2097 		mlog_errno(status);
2098 		goto bail;
2099 	}
2100 
2101 	mlog(0, "built filename '%s' for orphan dir (len=%d)\n", name,
2102 	     namelen);
2103 
2104 	status = 0;
2105 bail:
2106 	mlog_exit(status);
2107 	return status;
2108 }
2109 
2110 static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb,
2111 				    struct inode **ret_orphan_dir,
2112 				    struct inode *inode,
2113 				    char *name,
2114 				    struct buffer_head **de_bh)
2115 {
2116 	struct inode *orphan_dir_inode;
2117 	struct buffer_head *orphan_dir_bh = NULL;
2118 	int status = 0;
2119 
2120 	status = ocfs2_blkno_stringify(OCFS2_I(inode)->ip_blkno, name);
2121 	if (status < 0) {
2122 		mlog_errno(status);
2123 		return status;
2124 	}
2125 
2126 	orphan_dir_inode = ocfs2_get_system_file_inode(osb,
2127 						       ORPHAN_DIR_SYSTEM_INODE,
2128 						       osb->slot_num);
2129 	if (!orphan_dir_inode) {
2130 		status = -ENOENT;
2131 		mlog_errno(status);
2132 		return status;
2133 	}
2134 
2135 	mutex_lock(&orphan_dir_inode->i_mutex);
2136 
2137 	status = ocfs2_meta_lock(orphan_dir_inode, &orphan_dir_bh, 1);
2138 	if (status < 0) {
2139 		mlog_errno(status);
2140 		goto leave;
2141 	}
2142 
2143 	status = ocfs2_prepare_dir_for_insert(osb, orphan_dir_inode,
2144 					      orphan_dir_bh, name,
2145 					      OCFS2_ORPHAN_NAMELEN, de_bh);
2146 	if (status < 0) {
2147 		ocfs2_meta_unlock(orphan_dir_inode, 1);
2148 
2149 		mlog_errno(status);
2150 		goto leave;
2151 	}
2152 
2153 	*ret_orphan_dir = orphan_dir_inode;
2154 
2155 leave:
2156 	if (status) {
2157 		mutex_unlock(&orphan_dir_inode->i_mutex);
2158 		iput(orphan_dir_inode);
2159 	}
2160 
2161 	if (orphan_dir_bh)
2162 		brelse(orphan_dir_bh);
2163 
2164 	mlog_exit(status);
2165 	return status;
2166 }
2167 
2168 static int ocfs2_orphan_add(struct ocfs2_super *osb,
2169 			    handle_t *handle,
2170 			    struct inode *inode,
2171 			    struct ocfs2_dinode *fe,
2172 			    char *name,
2173 			    struct buffer_head *de_bh,
2174 			    struct inode *orphan_dir_inode)
2175 {
2176 	struct buffer_head *orphan_dir_bh = NULL;
2177 	int status = 0;
2178 	struct ocfs2_dinode *orphan_fe;
2179 
2180 	mlog_entry("(inode->i_ino = %lu)\n", inode->i_ino);
2181 
2182 	status = ocfs2_read_block(osb,
2183 				  OCFS2_I(orphan_dir_inode)->ip_blkno,
2184 				  &orphan_dir_bh, OCFS2_BH_CACHED,
2185 				  orphan_dir_inode);
2186 	if (status < 0) {
2187 		mlog_errno(status);
2188 		goto leave;
2189 	}
2190 
2191 	status = ocfs2_journal_access(handle, orphan_dir_inode, orphan_dir_bh,
2192 				      OCFS2_JOURNAL_ACCESS_WRITE);
2193 	if (status < 0) {
2194 		mlog_errno(status);
2195 		goto leave;
2196 	}
2197 
2198 	/* we're a cluster, and nlink can change on disk from
2199 	 * underneath us... */
2200 	orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data;
2201 	if (S_ISDIR(inode->i_mode))
2202 		le16_add_cpu(&orphan_fe->i_links_count, 1);
2203 	orphan_dir_inode->i_nlink = le16_to_cpu(orphan_fe->i_links_count);
2204 
2205 	status = ocfs2_journal_dirty(handle, orphan_dir_bh);
2206 	if (status < 0) {
2207 		mlog_errno(status);
2208 		goto leave;
2209 	}
2210 
2211 	status = __ocfs2_add_entry(handle, orphan_dir_inode, name,
2212 				   OCFS2_ORPHAN_NAMELEN, inode,
2213 				   OCFS2_I(inode)->ip_blkno,
2214 				   orphan_dir_bh, de_bh);
2215 	if (status < 0) {
2216 		mlog_errno(status);
2217 		goto leave;
2218 	}
2219 
2220 	le32_add_cpu(&fe->i_flags, OCFS2_ORPHANED_FL);
2221 
2222 	/* Record which orphan dir our inode now resides
2223 	 * in. delete_inode will use this to determine which orphan
2224 	 * dir to lock. */
2225 	fe->i_orphaned_slot = cpu_to_le16(osb->slot_num);
2226 
2227 	mlog(0, "Inode %llu orphaned in slot %d\n",
2228 	     (unsigned long long)OCFS2_I(inode)->ip_blkno, osb->slot_num);
2229 
2230 leave:
2231 	if (orphan_dir_bh)
2232 		brelse(orphan_dir_bh);
2233 
2234 	mlog_exit(status);
2235 	return status;
2236 }
2237 
2238 /* unlike orphan_add, we expect the orphan dir to already be locked here. */
2239 int ocfs2_orphan_del(struct ocfs2_super *osb,
2240 		     handle_t *handle,
2241 		     struct inode *orphan_dir_inode,
2242 		     struct inode *inode,
2243 		     struct buffer_head *orphan_dir_bh)
2244 {
2245 	char name[OCFS2_ORPHAN_NAMELEN + 1];
2246 	struct ocfs2_dinode *orphan_fe;
2247 	int status = 0;
2248 	struct buffer_head *target_de_bh = NULL;
2249 	struct ocfs2_dir_entry *target_de = NULL;
2250 
2251 	mlog_entry_void();
2252 
2253 	status = ocfs2_blkno_stringify(OCFS2_I(inode)->ip_blkno, name);
2254 	if (status < 0) {
2255 		mlog_errno(status);
2256 		goto leave;
2257 	}
2258 
2259 	mlog(0, "removing '%s' from orphan dir %llu (namelen=%d)\n",
2260 	     name, (unsigned long long)OCFS2_I(orphan_dir_inode)->ip_blkno,
2261 	     OCFS2_ORPHAN_NAMELEN);
2262 
2263 	/* find it's spot in the orphan directory */
2264 	target_de_bh = ocfs2_find_entry(name, OCFS2_ORPHAN_NAMELEN,
2265 					orphan_dir_inode, &target_de);
2266 	if (!target_de_bh) {
2267 		status = -ENOENT;
2268 		mlog_errno(status);
2269 		goto leave;
2270 	}
2271 
2272 	/* remove it from the orphan directory */
2273 	status = ocfs2_delete_entry(handle, orphan_dir_inode, target_de,
2274 				    target_de_bh);
2275 	if (status < 0) {
2276 		mlog_errno(status);
2277 		goto leave;
2278 	}
2279 
2280 	status = ocfs2_journal_access(handle,orphan_dir_inode,  orphan_dir_bh,
2281 				      OCFS2_JOURNAL_ACCESS_WRITE);
2282 	if (status < 0) {
2283 		mlog_errno(status);
2284 		goto leave;
2285 	}
2286 
2287 	/* do the i_nlink dance! :) */
2288 	orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data;
2289 	if (S_ISDIR(inode->i_mode))
2290 		le16_add_cpu(&orphan_fe->i_links_count, -1);
2291 	orphan_dir_inode->i_nlink = le16_to_cpu(orphan_fe->i_links_count);
2292 
2293 	status = ocfs2_journal_dirty(handle, orphan_dir_bh);
2294 	if (status < 0) {
2295 		mlog_errno(status);
2296 		goto leave;
2297 	}
2298 
2299 leave:
2300 	if (target_de_bh)
2301 		brelse(target_de_bh);
2302 
2303 	mlog_exit(status);
2304 	return status;
2305 }
2306 
2307 const struct inode_operations ocfs2_dir_iops = {
2308 	.create		= ocfs2_create,
2309 	.lookup		= ocfs2_lookup,
2310 	.link		= ocfs2_link,
2311 	.unlink		= ocfs2_unlink,
2312 	.rmdir		= ocfs2_unlink,
2313 	.symlink	= ocfs2_symlink,
2314 	.mkdir		= ocfs2_mkdir,
2315 	.mknod		= ocfs2_mknod,
2316 	.rename		= ocfs2_rename,
2317 	.setattr	= ocfs2_setattr,
2318 	.getattr	= ocfs2_getattr,
2319 	.permission	= ocfs2_permission,
2320 };
2321