xref: /linux/fs/ocfs2/namei.c (revision 553c89ec31746ff96fc5562943fe5b1c9b1e9276)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * namei.c
4  *
5  * Create and rename file, directory, symlinks
6  *
7  * Copyright (C) 2002, 2004 Oracle.  All rights reserved.
8  *
9  *  Portions of this code from linux/fs/ext3/dir.c
10  *
11  *  Copyright (C) 1992, 1993, 1994, 1995
12  *  Remy Card (card@masi.ibp.fr)
13  *  Laboratoire MASI - Institut Blaise pascal
14  *  Universite Pierre et Marie Curie (Paris VI)
15  *
16  *   from
17  *
18  *   linux/fs/minix/dir.c
19  *
20  *   Copyright (C) 1991, 1992 Linux Torvalds
21  */
22 
23 #include <linux/fs.h>
24 #include <linux/types.h>
25 #include <linux/slab.h>
26 #include <linux/highmem.h>
27 #include <linux/quotaops.h>
28 #include <linux/iversion.h>
29 
30 #include <cluster/masklog.h>
31 
32 #include "ocfs2.h"
33 
34 #include "alloc.h"
35 #include "dcache.h"
36 #include "dir.h"
37 #include "dlmglue.h"
38 #include "extent_map.h"
39 #include "file.h"
40 #include "inode.h"
41 #include "journal.h"
42 #include "namei.h"
43 #include "suballoc.h"
44 #include "super.h"
45 #include "symlink.h"
46 #include "sysfile.h"
47 #include "uptodate.h"
48 #include "xattr.h"
49 #include "acl.h"
50 #include "ocfs2_trace.h"
51 #include "ioctl.h"
52 
53 #include "buffer_head_io.h"
54 
55 static int ocfs2_mknod_locked(struct ocfs2_super *osb,
56 			      struct inode *dir,
57 			      struct inode *inode,
58 			      dev_t dev,
59 			      struct buffer_head **new_fe_bh,
60 			      struct buffer_head *parent_fe_bh,
61 			      handle_t *handle,
62 			      struct ocfs2_alloc_context *inode_ac);
63 
64 static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb,
65 				    struct inode **ret_orphan_dir,
66 				    u64 blkno,
67 				    char *name,
68 				    struct ocfs2_dir_lookup_result *lookup,
69 				    bool dio);
70 
71 static int ocfs2_orphan_add(struct ocfs2_super *osb,
72 			    handle_t *handle,
73 			    struct inode *inode,
74 			    struct buffer_head *fe_bh,
75 			    char *name,
76 			    struct ocfs2_dir_lookup_result *lookup,
77 			    struct inode *orphan_dir_inode,
78 			    bool dio);
79 
80 static int ocfs2_create_symlink_data(struct ocfs2_super *osb,
81 				     handle_t *handle,
82 				     struct inode *inode,
83 				     const char *symname);
84 
85 static int ocfs2_double_lock(struct ocfs2_super *osb,
86 			     struct buffer_head **bh1,
87 			     struct inode *inode1,
88 			     struct buffer_head **bh2,
89 			     struct inode *inode2,
90 			     int rename);
91 
92 static void ocfs2_double_unlock(struct inode *inode1, struct inode *inode2);
93 /* An orphan dir name is an 8 byte value, printed as a hex string */
94 #define OCFS2_ORPHAN_NAMELEN ((int)(2 * sizeof(u64)))
95 
ocfs2_lookup(struct inode * dir,struct dentry * dentry,unsigned int flags)96 static struct dentry *ocfs2_lookup(struct inode *dir, struct dentry *dentry,
97 				   unsigned int flags)
98 {
99 	int status;
100 	u64 blkno;
101 	struct inode *inode = NULL;
102 	struct dentry *ret;
103 	struct ocfs2_inode_info *oi;
104 
105 	trace_ocfs2_lookup(dir, dentry, dentry->d_name.len,
106 			   dentry->d_name.name,
107 			   (unsigned long long)OCFS2_I(dir)->ip_blkno, 0);
108 
109 	if (dentry->d_name.len > OCFS2_MAX_FILENAME_LEN) {
110 		ret = ERR_PTR(-ENAMETOOLONG);
111 		goto bail;
112 	}
113 
114 	status = ocfs2_inode_lock_nested(dir, NULL, 0, OI_LS_PARENT);
115 	if (status < 0) {
116 		if (status != -ENOENT)
117 			mlog_errno(status);
118 		ret = ERR_PTR(status);
119 		goto bail;
120 	}
121 
122 	status = ocfs2_lookup_ino_from_name(dir, dentry->d_name.name,
123 					    dentry->d_name.len, &blkno);
124 	if (status < 0)
125 		goto bail_add;
126 
127 	inode = ocfs2_iget(OCFS2_SB(dir->i_sb), blkno, 0, 0);
128 	if (IS_ERR(inode)) {
129 		ret = ERR_PTR(-EACCES);
130 		goto bail_unlock;
131 	}
132 
133 	oi = OCFS2_I(inode);
134 	/* Clear any orphaned state... If we were able to look up the
135 	 * inode from a directory, it certainly can't be orphaned. We
136 	 * might have the bad state from a node which intended to
137 	 * orphan this inode but crashed before it could commit the
138 	 * unlink. */
139 	spin_lock(&oi->ip_lock);
140 	oi->ip_flags &= ~OCFS2_INODE_MAYBE_ORPHANED;
141 	spin_unlock(&oi->ip_lock);
142 
143 bail_add:
144 	ret = d_splice_alias(inode, dentry);
145 
146 	if (inode) {
147 		/*
148 		 * If d_splice_alias() finds a DCACHE_DISCONNECTED
149 		 * dentry, it will d_move() it on top of ourse. The
150 		 * return value will indicate this however, so in
151 		 * those cases, we switch them around for the locking
152 		 * code.
153 		 *
154 		 * NOTE: This dentry already has ->d_op set from
155 		 * ocfs2_get_parent() and ocfs2_get_dentry()
156 		 */
157 		if (!IS_ERR_OR_NULL(ret))
158 			dentry = ret;
159 
160 		status = ocfs2_dentry_attach_lock(dentry, inode,
161 						  OCFS2_I(dir)->ip_blkno);
162 		if (status) {
163 			mlog_errno(status);
164 			ret = ERR_PTR(status);
165 			goto bail_unlock;
166 		}
167 	} else
168 		ocfs2_dentry_attach_gen(dentry);
169 
170 bail_unlock:
171 	/* Don't drop the cluster lock until *after* the d_add --
172 	 * unlink on another node will message us to remove that
173 	 * dentry under this lock so otherwise we can race this with
174 	 * the downconvert thread and have a stale dentry. */
175 	ocfs2_inode_unlock(dir, 0);
176 
177 bail:
178 
179 	trace_ocfs2_lookup_ret(ret);
180 
181 	return ret;
182 }
183 
ocfs2_get_init_inode(struct inode * dir,umode_t mode)184 static struct inode *ocfs2_get_init_inode(struct inode *dir, umode_t mode)
185 {
186 	struct inode *inode;
187 	int status;
188 
189 	inode = new_inode(dir->i_sb);
190 	if (!inode) {
191 		mlog(ML_ERROR, "new_inode failed!\n");
192 		return ERR_PTR(-ENOMEM);
193 	}
194 
195 	/* populate as many fields early on as possible - many of
196 	 * these are used by the support functions here and in
197 	 * callers. */
198 	if (S_ISDIR(mode))
199 		set_nlink(inode, 2);
200 	mode = mode_strip_sgid(&nop_mnt_idmap, dir, mode);
201 	inode_init_owner(&nop_mnt_idmap, inode, dir, mode);
202 	status = dquot_initialize(inode);
203 	if (status) {
204 		iput(inode);
205 		return ERR_PTR(status);
206 	}
207 
208 	return inode;
209 }
210 
ocfs2_cleanup_add_entry_failure(struct ocfs2_super * osb,struct dentry * dentry,struct inode * inode)211 static void ocfs2_cleanup_add_entry_failure(struct ocfs2_super *osb,
212 		struct dentry *dentry, struct inode *inode)
213 {
214 	struct ocfs2_dentry_lock *dl = dentry->d_fsdata;
215 
216 	ocfs2_simple_drop_lockres(osb, &dl->dl_lockres);
217 	ocfs2_lock_res_free(&dl->dl_lockres);
218 	BUG_ON(dl->dl_count != 1);
219 	spin_lock(&dentry_attach_lock);
220 	dentry->d_fsdata = NULL;
221 	spin_unlock(&dentry_attach_lock);
222 	kfree(dl);
223 	iput(inode);
224 }
225 
ocfs2_mknod(struct mnt_idmap * idmap,struct inode * dir,struct dentry * dentry,umode_t mode,dev_t dev)226 static int ocfs2_mknod(struct mnt_idmap *idmap,
227 		       struct inode *dir,
228 		       struct dentry *dentry,
229 		       umode_t mode,
230 		       dev_t dev)
231 {
232 	int status = 0;
233 	struct buffer_head *parent_fe_bh = NULL;
234 	handle_t *handle = NULL;
235 	struct ocfs2_super *osb;
236 	struct ocfs2_dinode *dirfe;
237 	struct ocfs2_dinode *fe = NULL;
238 	struct buffer_head *new_fe_bh = NULL;
239 	struct inode *inode = NULL;
240 	struct ocfs2_alloc_context *inode_ac = NULL;
241 	struct ocfs2_alloc_context *data_ac = NULL;
242 	struct ocfs2_alloc_context *meta_ac = NULL;
243 	int want_clusters = 0;
244 	int want_meta = 0;
245 	int xattr_credits = 0;
246 	struct ocfs2_security_xattr_info si = {
247 		.name = NULL,
248 		.enable = 1,
249 	};
250 	int did_quota_inode = 0;
251 	struct ocfs2_dir_lookup_result lookup = { NULL, };
252 	sigset_t oldset;
253 	int did_block_signals = 0;
254 	struct ocfs2_dentry_lock *dl = NULL;
255 
256 	trace_ocfs2_mknod(dir, dentry, dentry->d_name.len, dentry->d_name.name,
257 			  (unsigned long long)OCFS2_I(dir)->ip_blkno,
258 			  (unsigned long)dev, mode);
259 
260 	status = dquot_initialize(dir);
261 	if (status) {
262 		mlog_errno(status);
263 		return status;
264 	}
265 
266 	/* get our super block */
267 	osb = OCFS2_SB(dir->i_sb);
268 
269 	status = ocfs2_inode_lock(dir, &parent_fe_bh, 1);
270 	if (status < 0) {
271 		if (status != -ENOENT)
272 			mlog_errno(status);
273 		return status;
274 	}
275 
276 	if (S_ISDIR(mode) && (dir->i_nlink >= ocfs2_link_max(osb))) {
277 		status = -EMLINK;
278 		goto leave;
279 	}
280 
281 	dirfe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
282 	if (!ocfs2_read_links_count(dirfe)) {
283 		/* can't make a file in a deleted directory. */
284 		status = -ENOENT;
285 		goto leave;
286 	}
287 
288 	status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
289 					   dentry->d_name.len);
290 	if (status)
291 		goto leave;
292 
293 	/* get a spot inside the dir. */
294 	status = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
295 					      dentry->d_name.name,
296 					      dentry->d_name.len, &lookup);
297 	if (status < 0) {
298 		mlog_errno(status);
299 		goto leave;
300 	}
301 
302 	/* reserve an inode spot */
303 	status = ocfs2_reserve_new_inode(osb, &inode_ac);
304 	if (status < 0) {
305 		if (status != -ENOSPC)
306 			mlog_errno(status);
307 		goto leave;
308 	}
309 
310 	inode = ocfs2_get_init_inode(dir, mode);
311 	if (IS_ERR(inode)) {
312 		status = PTR_ERR(inode);
313 		inode = NULL;
314 		mlog_errno(status);
315 		goto leave;
316 	}
317 
318 	/* get security xattr */
319 	status = ocfs2_init_security_get(inode, dir, &dentry->d_name, &si);
320 	if (status) {
321 		if (status == -EOPNOTSUPP)
322 			si.enable = 0;
323 		else {
324 			mlog_errno(status);
325 			goto leave;
326 		}
327 	}
328 
329 	/* calculate meta data/clusters for setting security and acl xattr */
330 	status = ocfs2_calc_xattr_init(dir, parent_fe_bh, mode,
331 				       &si, &want_clusters,
332 				       &xattr_credits, &want_meta);
333 	if (status < 0) {
334 		mlog_errno(status);
335 		goto leave;
336 	}
337 
338 	/* Reserve a cluster if creating an extent based directory. */
339 	if (S_ISDIR(mode) && !ocfs2_supports_inline_data(osb)) {
340 		want_clusters += 1;
341 
342 		/* Dir indexing requires extra space as well */
343 		if (ocfs2_supports_indexed_dirs(osb))
344 			want_meta++;
345 	}
346 
347 	status = ocfs2_reserve_new_metadata_blocks(osb, want_meta, &meta_ac);
348 	if (status < 0) {
349 		if (status != -ENOSPC)
350 			mlog_errno(status);
351 		goto leave;
352 	}
353 
354 	status = ocfs2_reserve_clusters(osb, want_clusters, &data_ac);
355 	if (status < 0) {
356 		if (status != -ENOSPC)
357 			mlog_errno(status);
358 		goto leave;
359 	}
360 
361 	handle = ocfs2_start_trans(osb, ocfs2_mknod_credits(osb->sb,
362 							    S_ISDIR(mode),
363 							    xattr_credits));
364 	if (IS_ERR(handle)) {
365 		status = PTR_ERR(handle);
366 		handle = NULL;
367 		mlog_errno(status);
368 		goto leave;
369 	}
370 
371 	/* Starting to change things, restart is no longer possible. */
372 	ocfs2_block_signals(&oldset);
373 	did_block_signals = 1;
374 
375 	status = dquot_alloc_inode(inode);
376 	if (status)
377 		goto leave;
378 	did_quota_inode = 1;
379 
380 	/* do the real work now. */
381 	status = ocfs2_mknod_locked(osb, dir, inode, dev,
382 				    &new_fe_bh, parent_fe_bh, handle,
383 				    inode_ac);
384 	if (status < 0) {
385 		mlog_errno(status);
386 		goto leave;
387 	}
388 
389 	fe = (struct ocfs2_dinode *) new_fe_bh->b_data;
390 	if (S_ISDIR(mode)) {
391 		status = ocfs2_fill_new_dir(osb, handle, dir, inode,
392 					    new_fe_bh, data_ac, meta_ac);
393 		if (status < 0) {
394 			mlog_errno(status);
395 			goto leave;
396 		}
397 
398 		status = ocfs2_journal_access_di(handle, INODE_CACHE(dir),
399 						 parent_fe_bh,
400 						 OCFS2_JOURNAL_ACCESS_WRITE);
401 		if (status < 0) {
402 			mlog_errno(status);
403 			goto leave;
404 		}
405 		ocfs2_add_links_count(dirfe, 1);
406 		ocfs2_journal_dirty(handle, parent_fe_bh);
407 		inc_nlink(dir);
408 	}
409 
410 	status = ocfs2_init_acl(handle, inode, dir, new_fe_bh, parent_fe_bh,
411 			 meta_ac, data_ac);
412 
413 	if (status < 0) {
414 		mlog_errno(status);
415 		goto roll_back;
416 	}
417 
418 	if (si.enable) {
419 		status = ocfs2_init_security_set(handle, inode, new_fe_bh, &si,
420 						 meta_ac, data_ac);
421 		if (status < 0) {
422 			mlog_errno(status);
423 			goto roll_back;
424 		}
425 	}
426 
427 	/*
428 	 * Do this before adding the entry to the directory. We add
429 	 * also set d_op after success so that ->d_iput() will cleanup
430 	 * the dentry lock even if ocfs2_add_entry() fails below.
431 	 */
432 	status = ocfs2_dentry_attach_lock(dentry, inode,
433 					  OCFS2_I(dir)->ip_blkno);
434 	if (status) {
435 		mlog_errno(status);
436 		goto roll_back;
437 	}
438 
439 	dl = dentry->d_fsdata;
440 
441 	status = ocfs2_add_entry(handle, dentry, inode,
442 				 OCFS2_I(inode)->ip_blkno, parent_fe_bh,
443 				 &lookup);
444 	if (status < 0) {
445 		mlog_errno(status);
446 		goto roll_back;
447 	}
448 
449 	insert_inode_hash(inode);
450 	d_instantiate(dentry, inode);
451 	status = 0;
452 
453 roll_back:
454 	if (status < 0 && S_ISDIR(mode)) {
455 		ocfs2_add_links_count(dirfe, -1);
456 		drop_nlink(dir);
457 	}
458 
459 leave:
460 	if (status < 0 && did_quota_inode)
461 		dquot_free_inode(inode);
462 	if (handle) {
463 		if (status < 0 && fe)
464 			ocfs2_set_links_count(fe, 0);
465 		ocfs2_commit_trans(osb, handle);
466 	}
467 
468 	ocfs2_inode_unlock(dir, 1);
469 	if (did_block_signals)
470 		ocfs2_unblock_signals(&oldset);
471 
472 	brelse(new_fe_bh);
473 	brelse(parent_fe_bh);
474 	kfree(si.value);
475 
476 	ocfs2_free_dir_lookup_result(&lookup);
477 
478 	if (inode_ac)
479 		ocfs2_free_alloc_context(inode_ac);
480 
481 	if (data_ac)
482 		ocfs2_free_alloc_context(data_ac);
483 
484 	if (meta_ac)
485 		ocfs2_free_alloc_context(meta_ac);
486 
487 	/*
488 	 * We should call iput after the i_rwsem of the bitmap been
489 	 * unlocked in ocfs2_free_alloc_context, or the
490 	 * ocfs2_delete_inode will mutex_lock again.
491 	 */
492 	if ((status < 0) && inode) {
493 		if (dl)
494 			ocfs2_cleanup_add_entry_failure(osb, dentry, inode);
495 
496 		OCFS2_I(inode)->ip_flags |= OCFS2_INODE_SKIP_ORPHAN_DIR;
497 		clear_nlink(inode);
498 		iput(inode);
499 	}
500 
501 	if (status)
502 		mlog_errno(status);
503 
504 	return status;
505 }
506 
__ocfs2_mknod_locked(struct inode * dir,struct inode * inode,dev_t dev,struct buffer_head ** new_fe_bh,struct buffer_head * parent_fe_bh,handle_t * handle,struct ocfs2_alloc_context * inode_ac,u64 fe_blkno,u64 suballoc_loc,u16 suballoc_bit)507 static int __ocfs2_mknod_locked(struct inode *dir,
508 				struct inode *inode,
509 				dev_t dev,
510 				struct buffer_head **new_fe_bh,
511 				struct buffer_head *parent_fe_bh,
512 				handle_t *handle,
513 				struct ocfs2_alloc_context *inode_ac,
514 				u64 fe_blkno, u64 suballoc_loc, u16 suballoc_bit)
515 {
516 	int status = 0;
517 	struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
518 	struct ocfs2_dinode *fe = NULL;
519 	struct ocfs2_extent_list *fel;
520 	u16 feat;
521 	struct ocfs2_inode_info *oi = OCFS2_I(inode);
522 	struct timespec64 ts;
523 
524 	*new_fe_bh = NULL;
525 
526 	/* populate as many fields early on as possible - many of
527 	 * these are used by the support functions here and in
528 	 * callers. */
529 	inode->i_ino = ino_from_blkno(osb->sb, fe_blkno);
530 	oi->ip_blkno = fe_blkno;
531 	spin_lock(&osb->osb_lock);
532 	inode->i_generation = osb->s_next_generation++;
533 	spin_unlock(&osb->osb_lock);
534 
535 	*new_fe_bh = sb_getblk(osb->sb, fe_blkno);
536 	if (!*new_fe_bh) {
537 		status = -ENOMEM;
538 		mlog_errno(status);
539 		goto leave;
540 	}
541 	ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode), *new_fe_bh);
542 
543 	status = ocfs2_journal_access_di(handle, INODE_CACHE(inode),
544 					 *new_fe_bh,
545 					 OCFS2_JOURNAL_ACCESS_CREATE);
546 	if (status < 0) {
547 		mlog_errno(status);
548 		goto leave;
549 	}
550 
551 	fe = (struct ocfs2_dinode *) (*new_fe_bh)->b_data;
552 	memset(fe, 0, osb->sb->s_blocksize);
553 
554 	fe->i_generation = cpu_to_le32(inode->i_generation);
555 	fe->i_fs_generation = cpu_to_le32(osb->fs_generation);
556 	fe->i_blkno = cpu_to_le64(fe_blkno);
557 	fe->i_suballoc_loc = cpu_to_le64(suballoc_loc);
558 	fe->i_suballoc_bit = cpu_to_le16(suballoc_bit);
559 	fe->i_suballoc_slot = cpu_to_le16(inode_ac->ac_alloc_slot);
560 	fe->i_uid = cpu_to_le32(i_uid_read(inode));
561 	fe->i_gid = cpu_to_le32(i_gid_read(inode));
562 	fe->i_mode = cpu_to_le16(inode->i_mode);
563 	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
564 		fe->id1.dev1.i_rdev = cpu_to_le64(huge_encode_dev(dev));
565 
566 	ocfs2_set_links_count(fe, inode->i_nlink);
567 
568 	fe->i_last_eb_blk = 0;
569 	strcpy(fe->i_signature, OCFS2_INODE_SIGNATURE);
570 	fe->i_flags |= cpu_to_le32(OCFS2_VALID_FL);
571 	ktime_get_coarse_real_ts64(&ts);
572 	fe->i_atime = fe->i_ctime = fe->i_mtime =
573 		cpu_to_le64(ts.tv_sec);
574 	fe->i_mtime_nsec = fe->i_ctime_nsec = fe->i_atime_nsec =
575 		cpu_to_le32(ts.tv_nsec);
576 	fe->i_dtime = 0;
577 
578 	/*
579 	 * If supported, directories start with inline data. If inline
580 	 * isn't supported, but indexing is, we start them as indexed.
581 	 */
582 	feat = le16_to_cpu(fe->i_dyn_features);
583 	if (S_ISDIR(inode->i_mode) && ocfs2_supports_inline_data(osb)) {
584 		fe->i_dyn_features = cpu_to_le16(feat | OCFS2_INLINE_DATA_FL);
585 
586 		fe->id2.i_data.id_count = cpu_to_le16(
587 				ocfs2_max_inline_data_with_xattr(osb->sb, fe));
588 	} else {
589 		fel = &fe->id2.i_list;
590 		fel->l_tree_depth = 0;
591 		fel->l_next_free_rec = 0;
592 		fel->l_count = cpu_to_le16(ocfs2_extent_recs_per_inode(osb->sb));
593 	}
594 
595 	ocfs2_journal_dirty(handle, *new_fe_bh);
596 
597 	ocfs2_populate_inode(inode, fe, 1);
598 	ocfs2_ci_set_new(osb, INODE_CACHE(inode));
599 	if (!ocfs2_mount_local(osb)) {
600 		status = ocfs2_create_new_inode_locks(inode);
601 		if (status < 0)
602 			mlog_errno(status);
603 	}
604 
605 	ocfs2_update_inode_fsync_trans(handle, inode, 1);
606 
607 leave:
608 	if (status < 0) {
609 		if (*new_fe_bh) {
610 			brelse(*new_fe_bh);
611 			*new_fe_bh = NULL;
612 		}
613 	}
614 
615 	if (status)
616 		mlog_errno(status);
617 	return status;
618 }
619 
ocfs2_mknod_locked(struct ocfs2_super * osb,struct inode * dir,struct inode * inode,dev_t dev,struct buffer_head ** new_fe_bh,struct buffer_head * parent_fe_bh,handle_t * handle,struct ocfs2_alloc_context * inode_ac)620 static int ocfs2_mknod_locked(struct ocfs2_super *osb,
621 			      struct inode *dir,
622 			      struct inode *inode,
623 			      dev_t dev,
624 			      struct buffer_head **new_fe_bh,
625 			      struct buffer_head *parent_fe_bh,
626 			      handle_t *handle,
627 			      struct ocfs2_alloc_context *inode_ac)
628 {
629 	int status = 0;
630 	u64 suballoc_loc, fe_blkno = 0;
631 	u16 suballoc_bit;
632 
633 	*new_fe_bh = NULL;
634 
635 	status = ocfs2_claim_new_inode(handle, dir, parent_fe_bh,
636 				       inode_ac, &suballoc_loc,
637 				       &suballoc_bit, &fe_blkno);
638 	if (status < 0) {
639 		mlog_errno(status);
640 		return status;
641 	}
642 
643 	return __ocfs2_mknod_locked(dir, inode, dev, new_fe_bh,
644 				    parent_fe_bh, handle, inode_ac,
645 				    fe_blkno, suballoc_loc, suballoc_bit);
646 }
647 
ocfs2_mkdir(struct mnt_idmap * idmap,struct inode * dir,struct dentry * dentry,umode_t mode)648 static int ocfs2_mkdir(struct mnt_idmap *idmap,
649 		       struct inode *dir,
650 		       struct dentry *dentry,
651 		       umode_t mode)
652 {
653 	int ret;
654 
655 	trace_ocfs2_mkdir(dir, dentry, dentry->d_name.len, dentry->d_name.name,
656 			  OCFS2_I(dir)->ip_blkno, mode);
657 	ret = ocfs2_mknod(&nop_mnt_idmap, dir, dentry, mode | S_IFDIR, 0);
658 	if (ret)
659 		mlog_errno(ret);
660 
661 	return ret;
662 }
663 
ocfs2_create(struct mnt_idmap * idmap,struct inode * dir,struct dentry * dentry,umode_t mode,bool excl)664 static int ocfs2_create(struct mnt_idmap *idmap,
665 			struct inode *dir,
666 			struct dentry *dentry,
667 			umode_t mode,
668 			bool excl)
669 {
670 	int ret;
671 
672 	trace_ocfs2_create(dir, dentry, dentry->d_name.len, dentry->d_name.name,
673 			   (unsigned long long)OCFS2_I(dir)->ip_blkno, mode);
674 	ret = ocfs2_mknod(&nop_mnt_idmap, dir, dentry, mode | S_IFREG, 0);
675 	if (ret)
676 		mlog_errno(ret);
677 
678 	return ret;
679 }
680 
ocfs2_link(struct dentry * old_dentry,struct inode * dir,struct dentry * dentry)681 static int ocfs2_link(struct dentry *old_dentry,
682 		      struct inode *dir,
683 		      struct dentry *dentry)
684 {
685 	handle_t *handle;
686 	struct inode *inode = d_inode(old_dentry);
687 	struct inode *old_dir = d_inode(old_dentry->d_parent);
688 	int err;
689 	struct buffer_head *fe_bh = NULL;
690 	struct buffer_head *old_dir_bh = NULL;
691 	struct buffer_head *parent_fe_bh = NULL;
692 	struct ocfs2_dinode *fe = NULL;
693 	struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
694 	struct ocfs2_dir_lookup_result lookup = { NULL, };
695 	sigset_t oldset;
696 	u64 old_de_ino;
697 
698 	trace_ocfs2_link((unsigned long long)OCFS2_I(inode)->ip_blkno,
699 			 old_dentry->d_name.len, old_dentry->d_name.name,
700 			 dentry->d_name.len, dentry->d_name.name);
701 
702 	if (S_ISDIR(inode->i_mode))
703 		return -EPERM;
704 
705 	err = dquot_initialize(dir);
706 	if (err) {
707 		mlog_errno(err);
708 		return err;
709 	}
710 
711 	err = ocfs2_double_lock(osb, &old_dir_bh, old_dir,
712 			&parent_fe_bh, dir, 0);
713 	if (err < 0) {
714 		if (err != -ENOENT)
715 			mlog_errno(err);
716 		return err;
717 	}
718 
719 	/* make sure both dirs have bhs
720 	 * get an extra ref on old_dir_bh if old==new */
721 	if (!parent_fe_bh) {
722 		if (old_dir_bh) {
723 			parent_fe_bh = old_dir_bh;
724 			get_bh(parent_fe_bh);
725 		} else {
726 			mlog(ML_ERROR, "%s: no old_dir_bh!\n", osb->uuid_str);
727 			err = -EIO;
728 			goto out;
729 		}
730 	}
731 
732 	if (!dir->i_nlink) {
733 		err = -ENOENT;
734 		goto out;
735 	}
736 
737 	err = ocfs2_lookup_ino_from_name(old_dir, old_dentry->d_name.name,
738 			old_dentry->d_name.len, &old_de_ino);
739 	if (err) {
740 		err = -ENOENT;
741 		goto out;
742 	}
743 
744 	/*
745 	 * Check whether another node removed the source inode while we
746 	 * were in the vfs.
747 	 */
748 	if (old_de_ino != OCFS2_I(inode)->ip_blkno) {
749 		err = -ENOENT;
750 		goto out;
751 	}
752 
753 	err = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
754 					dentry->d_name.len);
755 	if (err)
756 		goto out;
757 
758 	err = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
759 					   dentry->d_name.name,
760 					   dentry->d_name.len, &lookup);
761 	if (err < 0) {
762 		mlog_errno(err);
763 		goto out;
764 	}
765 
766 	err = ocfs2_inode_lock(inode, &fe_bh, 1);
767 	if (err < 0) {
768 		if (err != -ENOENT)
769 			mlog_errno(err);
770 		goto out;
771 	}
772 
773 	fe = (struct ocfs2_dinode *) fe_bh->b_data;
774 	if (ocfs2_read_links_count(fe) >= ocfs2_link_max(osb)) {
775 		err = -EMLINK;
776 		goto out_unlock_inode;
777 	}
778 
779 	handle = ocfs2_start_trans(osb, ocfs2_link_credits(osb->sb));
780 	if (IS_ERR(handle)) {
781 		err = PTR_ERR(handle);
782 		handle = NULL;
783 		mlog_errno(err);
784 		goto out_unlock_inode;
785 	}
786 
787 	/* Starting to change things, restart is no longer possible. */
788 	ocfs2_block_signals(&oldset);
789 
790 	err = ocfs2_journal_access_di(handle, INODE_CACHE(inode), fe_bh,
791 				      OCFS2_JOURNAL_ACCESS_WRITE);
792 	if (err < 0) {
793 		mlog_errno(err);
794 		goto out_commit;
795 	}
796 
797 	inc_nlink(inode);
798 	inode_set_ctime_current(inode);
799 	ocfs2_set_links_count(fe, inode->i_nlink);
800 	fe->i_ctime = cpu_to_le64(inode_get_ctime_sec(inode));
801 	fe->i_ctime_nsec = cpu_to_le32(inode_get_ctime_nsec(inode));
802 	ocfs2_update_inode_fsync_trans(handle, inode, 0);
803 	ocfs2_journal_dirty(handle, fe_bh);
804 
805 	err = ocfs2_add_entry(handle, dentry, inode,
806 			      OCFS2_I(inode)->ip_blkno,
807 			      parent_fe_bh, &lookup);
808 	if (err) {
809 		ocfs2_add_links_count(fe, -1);
810 		drop_nlink(inode);
811 		mlog_errno(err);
812 		goto out_commit;
813 	}
814 
815 	err = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(dir)->ip_blkno);
816 	if (err) {
817 		mlog_errno(err);
818 		goto out_commit;
819 	}
820 
821 	ihold(inode);
822 	d_instantiate(dentry, inode);
823 
824 out_commit:
825 	ocfs2_commit_trans(osb, handle);
826 	ocfs2_unblock_signals(&oldset);
827 out_unlock_inode:
828 	ocfs2_inode_unlock(inode, 1);
829 
830 out:
831 	ocfs2_double_unlock(old_dir, dir);
832 
833 	brelse(fe_bh);
834 	brelse(parent_fe_bh);
835 	brelse(old_dir_bh);
836 
837 	ocfs2_free_dir_lookup_result(&lookup);
838 
839 	if (err)
840 		mlog_errno(err);
841 
842 	return err;
843 }
844 
845 /*
846  * Takes and drops an exclusive lock on the given dentry. This will
847  * force other nodes to drop it.
848  */
ocfs2_remote_dentry_delete(struct dentry * dentry)849 static int ocfs2_remote_dentry_delete(struct dentry *dentry)
850 {
851 	int ret;
852 
853 	ret = ocfs2_dentry_lock(dentry, 1);
854 	if (ret)
855 		mlog_errno(ret);
856 	else
857 		ocfs2_dentry_unlock(dentry, 1);
858 
859 	return ret;
860 }
861 
ocfs2_inode_is_unlinkable(struct inode * inode)862 static inline int ocfs2_inode_is_unlinkable(struct inode *inode)
863 {
864 	if (S_ISDIR(inode->i_mode)) {
865 		if (inode->i_nlink == 2)
866 			return 1;
867 		return 0;
868 	}
869 
870 	if (inode->i_nlink == 1)
871 		return 1;
872 	return 0;
873 }
874 
ocfs2_unlink(struct inode * dir,struct dentry * dentry)875 static int ocfs2_unlink(struct inode *dir,
876 			struct dentry *dentry)
877 {
878 	int status;
879 	int child_locked = 0;
880 	bool is_unlinkable = false;
881 	struct inode *inode = d_inode(dentry);
882 	struct inode *orphan_dir = NULL;
883 	struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
884 	u64 blkno;
885 	struct ocfs2_dinode *fe = NULL;
886 	struct buffer_head *fe_bh = NULL;
887 	struct buffer_head *parent_node_bh = NULL;
888 	handle_t *handle = NULL;
889 	char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
890 	struct ocfs2_dir_lookup_result lookup = { NULL, };
891 	struct ocfs2_dir_lookup_result orphan_insert = { NULL, };
892 
893 	trace_ocfs2_unlink(dir, dentry, dentry->d_name.len,
894 			   dentry->d_name.name,
895 			   (unsigned long long)OCFS2_I(dir)->ip_blkno,
896 			   (unsigned long long)OCFS2_I(inode)->ip_blkno);
897 
898 	status = dquot_initialize(dir);
899 	if (status) {
900 		mlog_errno(status);
901 		return status;
902 	}
903 
904 	BUG_ON(d_inode(dentry->d_parent) != dir);
905 
906 	if (inode == osb->root_inode)
907 		return -EPERM;
908 
909 	status = ocfs2_inode_lock_nested(dir, &parent_node_bh, 1,
910 					 OI_LS_PARENT);
911 	if (status < 0) {
912 		if (status != -ENOENT)
913 			mlog_errno(status);
914 		return status;
915 	}
916 
917 	status = ocfs2_find_files_on_disk(dentry->d_name.name,
918 					  dentry->d_name.len, &blkno, dir,
919 					  &lookup);
920 	if (status < 0) {
921 		if (status != -ENOENT)
922 			mlog_errno(status);
923 		goto leave;
924 	}
925 
926 	if (OCFS2_I(inode)->ip_blkno != blkno) {
927 		status = -ENOENT;
928 
929 		trace_ocfs2_unlink_noent(
930 				(unsigned long long)OCFS2_I(inode)->ip_blkno,
931 				(unsigned long long)blkno,
932 				OCFS2_I(inode)->ip_flags);
933 		goto leave;
934 	}
935 
936 	status = ocfs2_inode_lock(inode, &fe_bh, 1);
937 	if (status < 0) {
938 		if (status != -ENOENT)
939 			mlog_errno(status);
940 		goto leave;
941 	}
942 	child_locked = 1;
943 
944 	if (S_ISDIR(inode->i_mode)) {
945 		if (inode->i_nlink != 2 || !ocfs2_empty_dir(inode)) {
946 			status = -ENOTEMPTY;
947 			goto leave;
948 		}
949 	}
950 
951 	status = ocfs2_remote_dentry_delete(dentry);
952 	if (status < 0) {
953 		/* This remote delete should succeed under all normal
954 		 * circumstances. */
955 		mlog_errno(status);
956 		goto leave;
957 	}
958 
959 	if (ocfs2_inode_is_unlinkable(inode)) {
960 		status = ocfs2_prepare_orphan_dir(osb, &orphan_dir,
961 						  OCFS2_I(inode)->ip_blkno,
962 						  orphan_name, &orphan_insert,
963 						  false);
964 		if (status < 0) {
965 			mlog_errno(status);
966 			goto leave;
967 		}
968 		is_unlinkable = true;
969 	}
970 
971 	handle = ocfs2_start_trans(osb, ocfs2_unlink_credits(osb->sb));
972 	if (IS_ERR(handle)) {
973 		status = PTR_ERR(handle);
974 		handle = NULL;
975 		mlog_errno(status);
976 		goto leave;
977 	}
978 
979 	status = ocfs2_journal_access_di(handle, INODE_CACHE(inode), fe_bh,
980 					 OCFS2_JOURNAL_ACCESS_WRITE);
981 	if (status < 0) {
982 		mlog_errno(status);
983 		goto leave;
984 	}
985 
986 	fe = (struct ocfs2_dinode *) fe_bh->b_data;
987 
988 	/* delete the name from the parent dir */
989 	status = ocfs2_delete_entry(handle, dir, &lookup);
990 	if (status < 0) {
991 		mlog_errno(status);
992 		goto leave;
993 	}
994 
995 	if (S_ISDIR(inode->i_mode))
996 		drop_nlink(inode);
997 	drop_nlink(inode);
998 	ocfs2_set_links_count(fe, inode->i_nlink);
999 	ocfs2_update_inode_fsync_trans(handle, inode, 0);
1000 	ocfs2_journal_dirty(handle, fe_bh);
1001 
1002 	inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
1003 	if (S_ISDIR(inode->i_mode))
1004 		drop_nlink(dir);
1005 
1006 	status = ocfs2_mark_inode_dirty(handle, dir, parent_node_bh);
1007 	if (status < 0) {
1008 		mlog_errno(status);
1009 		if (S_ISDIR(inode->i_mode))
1010 			inc_nlink(dir);
1011 		goto leave;
1012 	}
1013 
1014 	if (is_unlinkable) {
1015 		status = ocfs2_orphan_add(osb, handle, inode, fe_bh,
1016 				orphan_name, &orphan_insert, orphan_dir, false);
1017 		if (status < 0)
1018 			mlog_errno(status);
1019 	}
1020 
1021 leave:
1022 	if (handle)
1023 		ocfs2_commit_trans(osb, handle);
1024 
1025 	if (orphan_dir) {
1026 		/* This was locked for us in ocfs2_prepare_orphan_dir() */
1027 		ocfs2_inode_unlock(orphan_dir, 1);
1028 		inode_unlock(orphan_dir);
1029 		iput(orphan_dir);
1030 	}
1031 
1032 	if (child_locked)
1033 		ocfs2_inode_unlock(inode, 1);
1034 
1035 	ocfs2_inode_unlock(dir, 1);
1036 
1037 	brelse(fe_bh);
1038 	brelse(parent_node_bh);
1039 
1040 	ocfs2_free_dir_lookup_result(&orphan_insert);
1041 	ocfs2_free_dir_lookup_result(&lookup);
1042 
1043 	if (status && (status != -ENOTEMPTY) && (status != -ENOENT))
1044 		mlog_errno(status);
1045 
1046 	return status;
1047 }
1048 
ocfs2_check_if_ancestor(struct ocfs2_super * osb,u64 src_inode_no,u64 dest_inode_no)1049 static int ocfs2_check_if_ancestor(struct ocfs2_super *osb,
1050 		u64 src_inode_no, u64 dest_inode_no)
1051 {
1052 	int ret = 0, i = 0;
1053 	u64 parent_inode_no = 0;
1054 	u64 child_inode_no = src_inode_no;
1055 	struct inode *child_inode;
1056 
1057 #define MAX_LOOKUP_TIMES 32
1058 	while (1) {
1059 		child_inode = ocfs2_iget(osb, child_inode_no, 0, 0);
1060 		if (IS_ERR(child_inode)) {
1061 			ret = PTR_ERR(child_inode);
1062 			break;
1063 		}
1064 
1065 		ret = ocfs2_inode_lock(child_inode, NULL, 0);
1066 		if (ret < 0) {
1067 			iput(child_inode);
1068 			if (ret != -ENOENT)
1069 				mlog_errno(ret);
1070 			break;
1071 		}
1072 
1073 		ret = ocfs2_lookup_ino_from_name(child_inode, "..", 2,
1074 				&parent_inode_no);
1075 		ocfs2_inode_unlock(child_inode, 0);
1076 		iput(child_inode);
1077 		if (ret < 0) {
1078 			ret = -ENOENT;
1079 			break;
1080 		}
1081 
1082 		if (parent_inode_no == dest_inode_no) {
1083 			ret = 1;
1084 			break;
1085 		}
1086 
1087 		if (parent_inode_no == osb->root_inode->i_ino) {
1088 			ret = 0;
1089 			break;
1090 		}
1091 
1092 		child_inode_no = parent_inode_no;
1093 
1094 		if (++i >= MAX_LOOKUP_TIMES) {
1095 			mlog_ratelimited(ML_NOTICE, "max lookup times reached, "
1096 					"filesystem may have nested directories, "
1097 					"src inode: %llu, dest inode: %llu.\n",
1098 					(unsigned long long)src_inode_no,
1099 					(unsigned long long)dest_inode_no);
1100 			ret = 0;
1101 			break;
1102 		}
1103 	}
1104 
1105 	return ret;
1106 }
1107 
1108 /*
1109  * The only place this should be used is rename and link!
1110  * if they have the same id, then the 1st one is the only one locked.
1111  */
ocfs2_double_lock(struct ocfs2_super * osb,struct buffer_head ** bh1,struct inode * inode1,struct buffer_head ** bh2,struct inode * inode2,int rename)1112 static int ocfs2_double_lock(struct ocfs2_super *osb,
1113 			     struct buffer_head **bh1,
1114 			     struct inode *inode1,
1115 			     struct buffer_head **bh2,
1116 			     struct inode *inode2,
1117 			     int rename)
1118 {
1119 	int status;
1120 	int inode1_is_ancestor, inode2_is_ancestor;
1121 	struct ocfs2_inode_info *oi1 = OCFS2_I(inode1);
1122 	struct ocfs2_inode_info *oi2 = OCFS2_I(inode2);
1123 
1124 	trace_ocfs2_double_lock((unsigned long long)oi1->ip_blkno,
1125 				(unsigned long long)oi2->ip_blkno);
1126 
1127 	if (*bh1)
1128 		*bh1 = NULL;
1129 	if (*bh2)
1130 		*bh2 = NULL;
1131 
1132 	/* we always want to lock the one with the lower lockid first.
1133 	 * and if they are nested, we lock ancestor first */
1134 	if (oi1->ip_blkno != oi2->ip_blkno) {
1135 		inode1_is_ancestor = ocfs2_check_if_ancestor(osb, oi2->ip_blkno,
1136 				oi1->ip_blkno);
1137 		if (inode1_is_ancestor < 0) {
1138 			status = inode1_is_ancestor;
1139 			goto bail;
1140 		}
1141 
1142 		inode2_is_ancestor = ocfs2_check_if_ancestor(osb, oi1->ip_blkno,
1143 				oi2->ip_blkno);
1144 		if (inode2_is_ancestor < 0) {
1145 			status = inode2_is_ancestor;
1146 			goto bail;
1147 		}
1148 
1149 		if ((inode1_is_ancestor == 1) ||
1150 				(oi1->ip_blkno < oi2->ip_blkno &&
1151 				inode2_is_ancestor == 0)) {
1152 			/* switch id1 and id2 around */
1153 			swap(bh2, bh1);
1154 			swap(inode2, inode1);
1155 		}
1156 		/* lock id2 */
1157 		status = ocfs2_inode_lock_nested(inode2, bh2, 1,
1158 				rename == 1 ? OI_LS_RENAME1 : OI_LS_PARENT);
1159 		if (status < 0) {
1160 			if (status != -ENOENT)
1161 				mlog_errno(status);
1162 			goto bail;
1163 		}
1164 	}
1165 
1166 	/* lock id1 */
1167 	status = ocfs2_inode_lock_nested(inode1, bh1, 1,
1168 			rename == 1 ?  OI_LS_RENAME2 : OI_LS_PARENT);
1169 	if (status < 0) {
1170 		/*
1171 		 * An error return must mean that no cluster locks
1172 		 * were held on function exit.
1173 		 */
1174 		if (oi1->ip_blkno != oi2->ip_blkno) {
1175 			ocfs2_inode_unlock(inode2, 1);
1176 			brelse(*bh2);
1177 			*bh2 = NULL;
1178 		}
1179 
1180 		if (status != -ENOENT)
1181 			mlog_errno(status);
1182 	}
1183 
1184 	trace_ocfs2_double_lock_end(
1185 			(unsigned long long)oi1->ip_blkno,
1186 			(unsigned long long)oi2->ip_blkno);
1187 
1188 bail:
1189 	if (status)
1190 		mlog_errno(status);
1191 	return status;
1192 }
1193 
ocfs2_double_unlock(struct inode * inode1,struct inode * inode2)1194 static void ocfs2_double_unlock(struct inode *inode1, struct inode *inode2)
1195 {
1196 	ocfs2_inode_unlock(inode1, 1);
1197 
1198 	if (inode1 != inode2)
1199 		ocfs2_inode_unlock(inode2, 1);
1200 }
1201 
ocfs2_rename(struct mnt_idmap * idmap,struct inode * old_dir,struct dentry * old_dentry,struct inode * new_dir,struct dentry * new_dentry,unsigned int flags)1202 static int ocfs2_rename(struct mnt_idmap *idmap,
1203 			struct inode *old_dir,
1204 			struct dentry *old_dentry,
1205 			struct inode *new_dir,
1206 			struct dentry *new_dentry,
1207 			unsigned int flags)
1208 {
1209 	int status = 0, rename_lock = 0, parents_locked = 0, target_exists = 0;
1210 	int old_child_locked = 0, new_child_locked = 0, update_dot_dot = 0;
1211 	struct inode *old_inode = d_inode(old_dentry);
1212 	struct inode *new_inode = d_inode(new_dentry);
1213 	struct inode *orphan_dir = NULL;
1214 	struct ocfs2_dinode *newfe = NULL;
1215 	char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
1216 	struct buffer_head *newfe_bh = NULL;
1217 	struct buffer_head *old_inode_bh = NULL;
1218 	struct ocfs2_super *osb = NULL;
1219 	u64 newfe_blkno, old_de_ino;
1220 	handle_t *handle = NULL;
1221 	struct buffer_head *old_dir_bh = NULL;
1222 	struct buffer_head *new_dir_bh = NULL;
1223 	u32 old_dir_nlink = old_dir->i_nlink;
1224 	struct ocfs2_dinode *old_di;
1225 	struct ocfs2_dir_lookup_result old_inode_dot_dot_res = { NULL, };
1226 	struct ocfs2_dir_lookup_result target_lookup_res = { NULL, };
1227 	struct ocfs2_dir_lookup_result old_entry_lookup = { NULL, };
1228 	struct ocfs2_dir_lookup_result orphan_insert = { NULL, };
1229 	struct ocfs2_dir_lookup_result target_insert = { NULL, };
1230 	bool should_add_orphan = false;
1231 
1232 	if (flags)
1233 		return -EINVAL;
1234 
1235 	/* At some point it might be nice to break this function up a
1236 	 * bit. */
1237 
1238 	trace_ocfs2_rename(old_dir, old_dentry, new_dir, new_dentry,
1239 			   old_dentry->d_name.len, old_dentry->d_name.name,
1240 			   new_dentry->d_name.len, new_dentry->d_name.name);
1241 
1242 	status = dquot_initialize(old_dir);
1243 	if (status) {
1244 		mlog_errno(status);
1245 		goto bail;
1246 	}
1247 	status = dquot_initialize(new_dir);
1248 	if (status) {
1249 		mlog_errno(status);
1250 		goto bail;
1251 	}
1252 
1253 	osb = OCFS2_SB(old_dir->i_sb);
1254 
1255 	if (new_inode) {
1256 		if (!igrab(new_inode))
1257 			BUG();
1258 	}
1259 
1260 	/* Assume a directory hierarchy thusly:
1261 	 * a/b/c
1262 	 * a/d
1263 	 * a,b,c, and d are all directories.
1264 	 *
1265 	 * from cwd of 'a' on both nodes:
1266 	 * node1: mv b/c d
1267 	 * node2: mv d   b/c
1268 	 *
1269 	 * And that's why, just like the VFS, we need a file system
1270 	 * rename lock. */
1271 	if (old_dir != new_dir && S_ISDIR(old_inode->i_mode)) {
1272 		status = ocfs2_rename_lock(osb);
1273 		if (status < 0) {
1274 			mlog_errno(status);
1275 			goto bail;
1276 		}
1277 		rename_lock = 1;
1278 
1279 		/* here we cannot guarantee the inodes haven't just been
1280 		 * changed, so check if they are nested again */
1281 		status = ocfs2_check_if_ancestor(osb, new_dir->i_ino,
1282 				old_inode->i_ino);
1283 		if (status < 0) {
1284 			mlog_errno(status);
1285 			goto bail;
1286 		} else if (status == 1) {
1287 			status = -EPERM;
1288 			trace_ocfs2_rename_not_permitted(
1289 					(unsigned long long)old_inode->i_ino,
1290 					(unsigned long long)new_dir->i_ino);
1291 			goto bail;
1292 		}
1293 	}
1294 
1295 	/* if old and new are the same, this'll just do one lock. */
1296 	status = ocfs2_double_lock(osb, &old_dir_bh, old_dir,
1297 				   &new_dir_bh, new_dir, 1);
1298 	if (status < 0) {
1299 		mlog_errno(status);
1300 		goto bail;
1301 	}
1302 	parents_locked = 1;
1303 
1304 	if (!new_dir->i_nlink) {
1305 		status = -EACCES;
1306 		goto bail;
1307 	}
1308 
1309 	/* make sure both dirs have bhs
1310 	 * get an extra ref on old_dir_bh if old==new */
1311 	if (!new_dir_bh) {
1312 		if (old_dir_bh) {
1313 			new_dir_bh = old_dir_bh;
1314 			get_bh(new_dir_bh);
1315 		} else {
1316 			mlog(ML_ERROR, "no old_dir_bh!\n");
1317 			status = -EIO;
1318 			goto bail;
1319 		}
1320 	}
1321 
1322 	/*
1323 	 * Aside from allowing a meta data update, the locking here
1324 	 * also ensures that the downconvert thread on other nodes
1325 	 * won't have to concurrently downconvert the inode and the
1326 	 * dentry locks.
1327 	 */
1328 	status = ocfs2_inode_lock_nested(old_inode, &old_inode_bh, 1,
1329 					 OI_LS_PARENT);
1330 	if (status < 0) {
1331 		if (status != -ENOENT)
1332 			mlog_errno(status);
1333 		goto bail;
1334 	}
1335 	old_child_locked = 1;
1336 
1337 	status = ocfs2_remote_dentry_delete(old_dentry);
1338 	if (status < 0) {
1339 		mlog_errno(status);
1340 		goto bail;
1341 	}
1342 
1343 	if (S_ISDIR(old_inode->i_mode) && new_dir != old_dir) {
1344 		u64 old_inode_parent;
1345 
1346 		update_dot_dot = 1;
1347 		status = ocfs2_find_files_on_disk("..", 2, &old_inode_parent,
1348 						  old_inode,
1349 						  &old_inode_dot_dot_res);
1350 		if (status) {
1351 			status = -EIO;
1352 			goto bail;
1353 		}
1354 
1355 		if (old_inode_parent != OCFS2_I(old_dir)->ip_blkno) {
1356 			status = -EIO;
1357 			goto bail;
1358 		}
1359 
1360 		if (!new_inode && new_dir->i_nlink >= ocfs2_link_max(osb)) {
1361 			status = -EMLINK;
1362 			goto bail;
1363 		}
1364 	}
1365 
1366 	status = ocfs2_lookup_ino_from_name(old_dir, old_dentry->d_name.name,
1367 					    old_dentry->d_name.len,
1368 					    &old_de_ino);
1369 	if (status) {
1370 		status = -ENOENT;
1371 		goto bail;
1372 	}
1373 
1374 	/*
1375 	 *  Check for inode number is _not_ due to possible IO errors.
1376 	 *  We might rmdir the source, keep it as pwd of some process
1377 	 *  and merrily kill the link to whatever was created under the
1378 	 *  same name. Goodbye sticky bit ;-<
1379 	 */
1380 	if (old_de_ino != OCFS2_I(old_inode)->ip_blkno) {
1381 		status = -ENOENT;
1382 		goto bail;
1383 	}
1384 
1385 	/* check if the target already exists (in which case we need
1386 	 * to delete it */
1387 	status = ocfs2_find_files_on_disk(new_dentry->d_name.name,
1388 					  new_dentry->d_name.len,
1389 					  &newfe_blkno, new_dir,
1390 					  &target_lookup_res);
1391 	/* The only error we allow here is -ENOENT because the new
1392 	 * file not existing is perfectly valid. */
1393 	if ((status < 0) && (status != -ENOENT)) {
1394 		/* If we cannot find the file specified we should just */
1395 		/* return the error... */
1396 		mlog_errno(status);
1397 		goto bail;
1398 	}
1399 	if (status == 0)
1400 		target_exists = 1;
1401 
1402 	if (!target_exists && new_inode) {
1403 		/*
1404 		 * Target was unlinked by another node while we were
1405 		 * waiting to get to ocfs2_rename(). There isn't
1406 		 * anything we can do here to help the situation, so
1407 		 * bubble up the appropriate error.
1408 		 */
1409 		status = -ENOENT;
1410 		goto bail;
1411 	}
1412 
1413 	/* In case we need to overwrite an existing file, we blow it
1414 	 * away first */
1415 	if (target_exists) {
1416 		/* VFS didn't think there existed an inode here, but
1417 		 * someone else in the cluster must have raced our
1418 		 * rename to create one. Today we error cleanly, in
1419 		 * the future we should consider calling iget to build
1420 		 * a new struct inode for this entry. */
1421 		if (!new_inode) {
1422 			status = -EACCES;
1423 
1424 			trace_ocfs2_rename_target_exists(new_dentry->d_name.len,
1425 						new_dentry->d_name.name);
1426 			goto bail;
1427 		}
1428 
1429 		if (OCFS2_I(new_inode)->ip_blkno != newfe_blkno) {
1430 			status = -EACCES;
1431 
1432 			trace_ocfs2_rename_disagree(
1433 			     (unsigned long long)OCFS2_I(new_inode)->ip_blkno,
1434 			     (unsigned long long)newfe_blkno,
1435 			     OCFS2_I(new_inode)->ip_flags);
1436 			goto bail;
1437 		}
1438 
1439 		status = ocfs2_inode_lock(new_inode, &newfe_bh, 1);
1440 		if (status < 0) {
1441 			if (status != -ENOENT)
1442 				mlog_errno(status);
1443 			goto bail;
1444 		}
1445 		new_child_locked = 1;
1446 
1447 		status = ocfs2_remote_dentry_delete(new_dentry);
1448 		if (status < 0) {
1449 			mlog_errno(status);
1450 			goto bail;
1451 		}
1452 
1453 		newfe = (struct ocfs2_dinode *) newfe_bh->b_data;
1454 
1455 		trace_ocfs2_rename_over_existing(
1456 		     (unsigned long long)newfe_blkno, newfe_bh, newfe_bh ?
1457 		     (unsigned long long)newfe_bh->b_blocknr : 0ULL);
1458 
1459 		if (S_ISDIR(new_inode->i_mode) || (new_inode->i_nlink == 1)) {
1460 			status = ocfs2_prepare_orphan_dir(osb, &orphan_dir,
1461 						OCFS2_I(new_inode)->ip_blkno,
1462 						orphan_name, &orphan_insert,
1463 						false);
1464 			if (status < 0) {
1465 				mlog_errno(status);
1466 				goto bail;
1467 			}
1468 			should_add_orphan = true;
1469 		}
1470 	} else {
1471 		BUG_ON(d_inode(new_dentry->d_parent) != new_dir);
1472 
1473 		status = ocfs2_check_dir_for_entry(new_dir,
1474 						   new_dentry->d_name.name,
1475 						   new_dentry->d_name.len);
1476 		if (status)
1477 			goto bail;
1478 
1479 		status = ocfs2_prepare_dir_for_insert(osb, new_dir, new_dir_bh,
1480 						      new_dentry->d_name.name,
1481 						      new_dentry->d_name.len,
1482 						      &target_insert);
1483 		if (status < 0) {
1484 			mlog_errno(status);
1485 			goto bail;
1486 		}
1487 	}
1488 
1489 	handle = ocfs2_start_trans(osb, ocfs2_rename_credits(osb->sb));
1490 	if (IS_ERR(handle)) {
1491 		status = PTR_ERR(handle);
1492 		handle = NULL;
1493 		mlog_errno(status);
1494 		goto bail;
1495 	}
1496 
1497 	if (target_exists) {
1498 		if (S_ISDIR(new_inode->i_mode)) {
1499 			if (new_inode->i_nlink != 2 ||
1500 			    !ocfs2_empty_dir(new_inode)) {
1501 				status = -ENOTEMPTY;
1502 				goto bail;
1503 			}
1504 		}
1505 		status = ocfs2_journal_access_di(handle, INODE_CACHE(new_inode),
1506 						 newfe_bh,
1507 						 OCFS2_JOURNAL_ACCESS_WRITE);
1508 		if (status < 0) {
1509 			mlog_errno(status);
1510 			goto bail;
1511 		}
1512 
1513 		/* change the dirent to point to the correct inode */
1514 		status = ocfs2_update_entry(new_dir, handle, &target_lookup_res,
1515 					    old_inode);
1516 		if (status < 0) {
1517 			mlog_errno(status);
1518 			goto bail;
1519 		}
1520 		inode_inc_iversion(new_dir);
1521 
1522 		if (S_ISDIR(new_inode->i_mode))
1523 			ocfs2_set_links_count(newfe, 0);
1524 		else
1525 			ocfs2_add_links_count(newfe, -1);
1526 		ocfs2_journal_dirty(handle, newfe_bh);
1527 		if (should_add_orphan) {
1528 			status = ocfs2_orphan_add(osb, handle, new_inode,
1529 					newfe_bh, orphan_name,
1530 					&orphan_insert, orphan_dir, false);
1531 			if (status < 0) {
1532 				mlog_errno(status);
1533 				goto bail;
1534 			}
1535 		}
1536 	} else {
1537 		/* if the name was not found in new_dir, add it now */
1538 		status = ocfs2_add_entry(handle, new_dentry, old_inode,
1539 					 OCFS2_I(old_inode)->ip_blkno,
1540 					 new_dir_bh, &target_insert);
1541 		if (status < 0) {
1542 			mlog_errno(status);
1543 			goto bail;
1544 		}
1545 	}
1546 
1547 	inode_set_ctime_current(old_inode);
1548 	mark_inode_dirty(old_inode);
1549 
1550 	status = ocfs2_journal_access_di(handle, INODE_CACHE(old_inode),
1551 					 old_inode_bh,
1552 					 OCFS2_JOURNAL_ACCESS_WRITE);
1553 	if (status >= 0) {
1554 		old_di = (struct ocfs2_dinode *) old_inode_bh->b_data;
1555 
1556 		old_di->i_ctime = cpu_to_le64(inode_get_ctime_sec(old_inode));
1557 		old_di->i_ctime_nsec = cpu_to_le32(inode_get_ctime_nsec(old_inode));
1558 		ocfs2_journal_dirty(handle, old_inode_bh);
1559 	} else
1560 		mlog_errno(status);
1561 
1562 	/*
1563 	 * Now that the name has been added to new_dir, remove the old name.
1564 	 *
1565 	 * We don't keep any directory entry context around until now
1566 	 * because the insert might have changed the type of directory
1567 	 * we're dealing with.
1568 	 */
1569 	status = ocfs2_find_entry(old_dentry->d_name.name,
1570 				  old_dentry->d_name.len, old_dir,
1571 				  &old_entry_lookup);
1572 	if (status) {
1573 		if (!is_journal_aborted(osb->journal->j_journal)) {
1574 			ocfs2_error(osb->sb, "new entry %.*s is added, but old entry %.*s "
1575 					"is not deleted.",
1576 					new_dentry->d_name.len, new_dentry->d_name.name,
1577 					old_dentry->d_name.len, old_dentry->d_name.name);
1578 		}
1579 		goto bail;
1580 	}
1581 
1582 	status = ocfs2_delete_entry(handle, old_dir, &old_entry_lookup);
1583 	if (status < 0) {
1584 		mlog_errno(status);
1585 		if (!is_journal_aborted(osb->journal->j_journal)) {
1586 			ocfs2_error(osb->sb, "new entry %.*s is added, but old entry %.*s "
1587 					"is not deleted.",
1588 					new_dentry->d_name.len, new_dentry->d_name.name,
1589 					old_dentry->d_name.len, old_dentry->d_name.name);
1590 		}
1591 		goto bail;
1592 	}
1593 
1594 	if (new_inode) {
1595 		drop_nlink(new_inode);
1596 		inode_set_ctime_current(new_inode);
1597 	}
1598 	inode_set_mtime_to_ts(old_dir, inode_set_ctime_current(old_dir));
1599 
1600 	if (update_dot_dot) {
1601 		status = ocfs2_update_entry(old_inode, handle,
1602 					    &old_inode_dot_dot_res, new_dir);
1603 		if (status < 0) {
1604 			mlog_errno(status);
1605 			goto bail;
1606 		}
1607 	}
1608 
1609 	if (S_ISDIR(old_inode->i_mode)) {
1610 		drop_nlink(old_dir);
1611 		if (new_inode) {
1612 			drop_nlink(new_inode);
1613 		} else {
1614 			inc_nlink(new_dir);
1615 			mark_inode_dirty(new_dir);
1616 		}
1617 	}
1618 	mark_inode_dirty(old_dir);
1619 	ocfs2_mark_inode_dirty(handle, old_dir, old_dir_bh);
1620 	if (new_inode) {
1621 		mark_inode_dirty(new_inode);
1622 		ocfs2_mark_inode_dirty(handle, new_inode, newfe_bh);
1623 	}
1624 
1625 	if (old_dir != new_dir) {
1626 		/* Keep the same times on both directories.*/
1627 		inode_set_mtime_to_ts(new_dir,
1628 				      inode_set_ctime_to_ts(new_dir, inode_get_ctime(old_dir)));
1629 
1630 		/*
1631 		 * This will also pick up the i_nlink change from the
1632 		 * block above.
1633 		 */
1634 		ocfs2_mark_inode_dirty(handle, new_dir, new_dir_bh);
1635 	}
1636 
1637 	if (old_dir_nlink != old_dir->i_nlink) {
1638 		if (!old_dir_bh) {
1639 			mlog(ML_ERROR, "need to change nlink for old dir "
1640 			     "%llu from %d to %d but bh is NULL!\n",
1641 			     (unsigned long long)OCFS2_I(old_dir)->ip_blkno,
1642 			     (int)old_dir_nlink, old_dir->i_nlink);
1643 		} else {
1644 			struct ocfs2_dinode *fe;
1645 			status = ocfs2_journal_access_di(handle,
1646 							 INODE_CACHE(old_dir),
1647 							 old_dir_bh,
1648 							 OCFS2_JOURNAL_ACCESS_WRITE);
1649 			if (status < 0) {
1650 				mlog_errno(status);
1651 				goto bail;
1652 			}
1653 			fe = (struct ocfs2_dinode *) old_dir_bh->b_data;
1654 			ocfs2_set_links_count(fe, old_dir->i_nlink);
1655 			ocfs2_journal_dirty(handle, old_dir_bh);
1656 		}
1657 	}
1658 	ocfs2_dentry_move(old_dentry, new_dentry, old_dir, new_dir);
1659 	status = 0;
1660 bail:
1661 	if (handle)
1662 		ocfs2_commit_trans(osb, handle);
1663 
1664 	if (orphan_dir) {
1665 		/* This was locked for us in ocfs2_prepare_orphan_dir() */
1666 		ocfs2_inode_unlock(orphan_dir, 1);
1667 		inode_unlock(orphan_dir);
1668 		iput(orphan_dir);
1669 	}
1670 
1671 	if (new_child_locked)
1672 		ocfs2_inode_unlock(new_inode, 1);
1673 
1674 	if (old_child_locked)
1675 		ocfs2_inode_unlock(old_inode, 1);
1676 
1677 	if (parents_locked)
1678 		ocfs2_double_unlock(old_dir, new_dir);
1679 
1680 	if (rename_lock)
1681 		ocfs2_rename_unlock(osb);
1682 
1683 	if (new_inode)
1684 		sync_mapping_buffers(old_inode->i_mapping);
1685 
1686 	iput(new_inode);
1687 
1688 	ocfs2_free_dir_lookup_result(&target_lookup_res);
1689 	ocfs2_free_dir_lookup_result(&old_entry_lookup);
1690 	ocfs2_free_dir_lookup_result(&old_inode_dot_dot_res);
1691 	ocfs2_free_dir_lookup_result(&orphan_insert);
1692 	ocfs2_free_dir_lookup_result(&target_insert);
1693 
1694 	brelse(newfe_bh);
1695 	brelse(old_inode_bh);
1696 	brelse(old_dir_bh);
1697 	brelse(new_dir_bh);
1698 
1699 	if (status)
1700 		mlog_errno(status);
1701 
1702 	return status;
1703 }
1704 
1705 /*
1706  * we expect i_size = strlen(symname). Copy symname into the file
1707  * data, including the null terminator.
1708  */
ocfs2_create_symlink_data(struct ocfs2_super * osb,handle_t * handle,struct inode * inode,const char * symname)1709 static int ocfs2_create_symlink_data(struct ocfs2_super *osb,
1710 				     handle_t *handle,
1711 				     struct inode *inode,
1712 				     const char *symname)
1713 {
1714 	struct buffer_head **bhs = NULL;
1715 	const char *c;
1716 	struct super_block *sb = osb->sb;
1717 	u64 p_blkno, p_blocks;
1718 	int virtual, blocks, status, i, bytes_left;
1719 
1720 	bytes_left = i_size_read(inode) + 1;
1721 	/* we can't trust i_blocks because we're actually going to
1722 	 * write i_size + 1 bytes. */
1723 	blocks = (bytes_left + sb->s_blocksize - 1) >> sb->s_blocksize_bits;
1724 
1725 	trace_ocfs2_create_symlink_data((unsigned long long)inode->i_blocks,
1726 					i_size_read(inode), blocks);
1727 
1728 	/* Sanity check -- make sure we're going to fit. */
1729 	if (bytes_left >
1730 	    ocfs2_clusters_to_bytes(sb, OCFS2_I(inode)->ip_clusters)) {
1731 		status = -EIO;
1732 		mlog_errno(status);
1733 		goto bail;
1734 	}
1735 
1736 	bhs = kcalloc(blocks, sizeof(struct buffer_head *), GFP_KERNEL);
1737 	if (!bhs) {
1738 		status = -ENOMEM;
1739 		mlog_errno(status);
1740 		goto bail;
1741 	}
1742 
1743 	status = ocfs2_extent_map_get_blocks(inode, 0, &p_blkno, &p_blocks,
1744 					     NULL);
1745 	if (status < 0) {
1746 		mlog_errno(status);
1747 		goto bail;
1748 	}
1749 
1750 	/* links can never be larger than one cluster so we know this
1751 	 * is all going to be contiguous, but do a sanity check
1752 	 * anyway. */
1753 	if ((p_blocks << sb->s_blocksize_bits) < bytes_left) {
1754 		status = -EIO;
1755 		mlog_errno(status);
1756 		goto bail;
1757 	}
1758 
1759 	virtual = 0;
1760 	while(bytes_left > 0) {
1761 		c = &symname[virtual * sb->s_blocksize];
1762 
1763 		bhs[virtual] = sb_getblk(sb, p_blkno);
1764 		if (!bhs[virtual]) {
1765 			status = -ENOMEM;
1766 			mlog_errno(status);
1767 			goto bail;
1768 		}
1769 		ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode),
1770 					      bhs[virtual]);
1771 
1772 		status = ocfs2_journal_access(handle, INODE_CACHE(inode),
1773 					      bhs[virtual],
1774 					      OCFS2_JOURNAL_ACCESS_CREATE);
1775 		if (status < 0) {
1776 			mlog_errno(status);
1777 			goto bail;
1778 		}
1779 
1780 		memset(bhs[virtual]->b_data, 0, sb->s_blocksize);
1781 
1782 		memcpy(bhs[virtual]->b_data, c,
1783 		       (bytes_left > sb->s_blocksize) ? sb->s_blocksize :
1784 		       bytes_left);
1785 
1786 		ocfs2_journal_dirty(handle, bhs[virtual]);
1787 
1788 		virtual++;
1789 		p_blkno++;
1790 		bytes_left -= sb->s_blocksize;
1791 	}
1792 
1793 	status = 0;
1794 bail:
1795 
1796 	if (bhs) {
1797 		for(i = 0; i < blocks; i++)
1798 			brelse(bhs[i]);
1799 		kfree(bhs);
1800 	}
1801 
1802 	if (status)
1803 		mlog_errno(status);
1804 	return status;
1805 }
1806 
ocfs2_symlink(struct mnt_idmap * idmap,struct inode * dir,struct dentry * dentry,const char * symname)1807 static int ocfs2_symlink(struct mnt_idmap *idmap,
1808 			 struct inode *dir,
1809 			 struct dentry *dentry,
1810 			 const char *symname)
1811 {
1812 	int status, l, credits;
1813 	u64 newsize;
1814 	struct ocfs2_super *osb = NULL;
1815 	struct inode *inode = NULL;
1816 	struct super_block *sb;
1817 	struct buffer_head *new_fe_bh = NULL;
1818 	struct buffer_head *parent_fe_bh = NULL;
1819 	struct ocfs2_dinode *fe = NULL;
1820 	struct ocfs2_dinode *dirfe;
1821 	handle_t *handle = NULL;
1822 	struct ocfs2_alloc_context *inode_ac = NULL;
1823 	struct ocfs2_alloc_context *data_ac = NULL;
1824 	struct ocfs2_alloc_context *xattr_ac = NULL;
1825 	int want_clusters = 0;
1826 	int xattr_credits = 0;
1827 	struct ocfs2_security_xattr_info si = {
1828 		.name = NULL,
1829 		.enable = 1,
1830 	};
1831 	int did_quota = 0, did_quota_inode = 0;
1832 	struct ocfs2_dir_lookup_result lookup = { NULL, };
1833 	sigset_t oldset;
1834 	int did_block_signals = 0;
1835 	struct ocfs2_dentry_lock *dl = NULL;
1836 
1837 	trace_ocfs2_symlink_begin(dir, dentry, symname,
1838 				  dentry->d_name.len, dentry->d_name.name);
1839 
1840 	status = dquot_initialize(dir);
1841 	if (status) {
1842 		mlog_errno(status);
1843 		goto bail;
1844 	}
1845 
1846 	sb = dir->i_sb;
1847 	osb = OCFS2_SB(sb);
1848 
1849 	l = strlen(symname) + 1;
1850 
1851 	credits = ocfs2_calc_symlink_credits(sb);
1852 
1853 	/* lock the parent directory */
1854 	status = ocfs2_inode_lock(dir, &parent_fe_bh, 1);
1855 	if (status < 0) {
1856 		if (status != -ENOENT)
1857 			mlog_errno(status);
1858 		return status;
1859 	}
1860 
1861 	dirfe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
1862 	if (!ocfs2_read_links_count(dirfe)) {
1863 		/* can't make a file in a deleted directory. */
1864 		status = -ENOENT;
1865 		goto bail;
1866 	}
1867 
1868 	status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
1869 					   dentry->d_name.len);
1870 	if (status)
1871 		goto bail;
1872 
1873 	status = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
1874 					      dentry->d_name.name,
1875 					      dentry->d_name.len, &lookup);
1876 	if (status < 0) {
1877 		mlog_errno(status);
1878 		goto bail;
1879 	}
1880 
1881 	status = ocfs2_reserve_new_inode(osb, &inode_ac);
1882 	if (status < 0) {
1883 		if (status != -ENOSPC)
1884 			mlog_errno(status);
1885 		goto bail;
1886 	}
1887 
1888 	inode = ocfs2_get_init_inode(dir, S_IFLNK | S_IRWXUGO);
1889 	if (IS_ERR(inode)) {
1890 		status = PTR_ERR(inode);
1891 		inode = NULL;
1892 		mlog_errno(status);
1893 		goto bail;
1894 	}
1895 
1896 	/* get security xattr */
1897 	status = ocfs2_init_security_get(inode, dir, &dentry->d_name, &si);
1898 	if (status) {
1899 		if (status == -EOPNOTSUPP)
1900 			si.enable = 0;
1901 		else {
1902 			mlog_errno(status);
1903 			goto bail;
1904 		}
1905 	}
1906 
1907 	/* calculate meta data/clusters for setting security xattr */
1908 	if (si.enable) {
1909 		status = ocfs2_calc_security_init(dir, &si, &want_clusters,
1910 						  &xattr_credits, &xattr_ac);
1911 		if (status < 0) {
1912 			mlog_errno(status);
1913 			goto bail;
1914 		}
1915 	}
1916 
1917 	/* don't reserve bitmap space for fast symlinks. */
1918 	if (l > ocfs2_fast_symlink_chars(sb))
1919 		want_clusters += 1;
1920 
1921 	status = ocfs2_reserve_clusters(osb, want_clusters, &data_ac);
1922 	if (status < 0) {
1923 		if (status != -ENOSPC)
1924 			mlog_errno(status);
1925 		goto bail;
1926 	}
1927 
1928 	handle = ocfs2_start_trans(osb, credits + xattr_credits);
1929 	if (IS_ERR(handle)) {
1930 		status = PTR_ERR(handle);
1931 		handle = NULL;
1932 		mlog_errno(status);
1933 		goto bail;
1934 	}
1935 
1936 	/* Starting to change things, restart is no longer possible. */
1937 	ocfs2_block_signals(&oldset);
1938 	did_block_signals = 1;
1939 
1940 	status = dquot_alloc_inode(inode);
1941 	if (status)
1942 		goto bail;
1943 	did_quota_inode = 1;
1944 
1945 	trace_ocfs2_symlink_create(dir, dentry, dentry->d_name.len,
1946 				   dentry->d_name.name,
1947 				   (unsigned long long)OCFS2_I(dir)->ip_blkno,
1948 				   inode->i_mode);
1949 
1950 	status = ocfs2_mknod_locked(osb, dir, inode,
1951 				    0, &new_fe_bh, parent_fe_bh, handle,
1952 				    inode_ac);
1953 	if (status < 0) {
1954 		mlog_errno(status);
1955 		goto bail;
1956 	}
1957 
1958 	fe = (struct ocfs2_dinode *) new_fe_bh->b_data;
1959 	inode->i_rdev = 0;
1960 	newsize = l - 1;
1961 	inode->i_op = &ocfs2_symlink_inode_operations;
1962 	inode_nohighmem(inode);
1963 	if (l > ocfs2_fast_symlink_chars(sb)) {
1964 		u32 offset = 0;
1965 
1966 		status = dquot_alloc_space_nodirty(inode,
1967 		    ocfs2_clusters_to_bytes(osb->sb, 1));
1968 		if (status)
1969 			goto bail;
1970 		did_quota = 1;
1971 		inode->i_mapping->a_ops = &ocfs2_aops;
1972 		status = ocfs2_add_inode_data(osb, inode, &offset, 1, 0,
1973 					      new_fe_bh,
1974 					      handle, data_ac, NULL,
1975 					      NULL);
1976 		if (status < 0) {
1977 			if (status != -ENOSPC && status != -EINTR) {
1978 				mlog(ML_ERROR,
1979 				     "Failed to extend file to %llu\n",
1980 				     (unsigned long long)newsize);
1981 				mlog_errno(status);
1982 				status = -ENOSPC;
1983 			}
1984 			goto bail;
1985 		}
1986 		i_size_write(inode, newsize);
1987 		inode->i_blocks = ocfs2_inode_sector_count(inode);
1988 	} else {
1989 		inode->i_mapping->a_ops = &ocfs2_fast_symlink_aops;
1990 		memcpy((char *) fe->id2.i_symlink, symname, l);
1991 		i_size_write(inode, newsize);
1992 		inode->i_blocks = 0;
1993 	}
1994 
1995 	status = ocfs2_mark_inode_dirty(handle, inode, new_fe_bh);
1996 	if (status < 0) {
1997 		mlog_errno(status);
1998 		goto bail;
1999 	}
2000 
2001 	if (!ocfs2_inode_is_fast_symlink(inode)) {
2002 		status = ocfs2_create_symlink_data(osb, handle, inode,
2003 						   symname);
2004 		if (status < 0) {
2005 			mlog_errno(status);
2006 			goto bail;
2007 		}
2008 	}
2009 
2010 	if (si.enable) {
2011 		status = ocfs2_init_security_set(handle, inode, new_fe_bh, &si,
2012 						 xattr_ac, data_ac);
2013 		if (status < 0) {
2014 			mlog_errno(status);
2015 			goto bail;
2016 		}
2017 	}
2018 
2019 	/*
2020 	 * Do this before adding the entry to the directory. We add
2021 	 * also set d_op after success so that ->d_iput() will cleanup
2022 	 * the dentry lock even if ocfs2_add_entry() fails below.
2023 	 */
2024 	status = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(dir)->ip_blkno);
2025 	if (status) {
2026 		mlog_errno(status);
2027 		goto bail;
2028 	}
2029 
2030 	dl = dentry->d_fsdata;
2031 
2032 	status = ocfs2_add_entry(handle, dentry, inode,
2033 				 le64_to_cpu(fe->i_blkno), parent_fe_bh,
2034 				 &lookup);
2035 	if (status < 0) {
2036 		mlog_errno(status);
2037 		goto bail;
2038 	}
2039 
2040 	insert_inode_hash(inode);
2041 	d_instantiate(dentry, inode);
2042 bail:
2043 	if (status < 0 && did_quota)
2044 		dquot_free_space_nodirty(inode,
2045 					ocfs2_clusters_to_bytes(osb->sb, 1));
2046 	if (status < 0 && did_quota_inode)
2047 		dquot_free_inode(inode);
2048 	if (handle) {
2049 		if (status < 0 && fe)
2050 			ocfs2_set_links_count(fe, 0);
2051 		ocfs2_commit_trans(osb, handle);
2052 	}
2053 
2054 	ocfs2_inode_unlock(dir, 1);
2055 	if (did_block_signals)
2056 		ocfs2_unblock_signals(&oldset);
2057 
2058 	brelse(new_fe_bh);
2059 	brelse(parent_fe_bh);
2060 	kfree(si.value);
2061 	ocfs2_free_dir_lookup_result(&lookup);
2062 	if (inode_ac)
2063 		ocfs2_free_alloc_context(inode_ac);
2064 	if (data_ac)
2065 		ocfs2_free_alloc_context(data_ac);
2066 	if (xattr_ac)
2067 		ocfs2_free_alloc_context(xattr_ac);
2068 	if ((status < 0) && inode) {
2069 		if (dl)
2070 			ocfs2_cleanup_add_entry_failure(osb, dentry, inode);
2071 
2072 		OCFS2_I(inode)->ip_flags |= OCFS2_INODE_SKIP_ORPHAN_DIR;
2073 		clear_nlink(inode);
2074 		iput(inode);
2075 	}
2076 
2077 	if (status)
2078 		mlog_errno(status);
2079 
2080 	return status;
2081 }
2082 
ocfs2_blkno_stringify(u64 blkno,char * name)2083 static int ocfs2_blkno_stringify(u64 blkno, char *name)
2084 {
2085 	int status, namelen;
2086 
2087 	namelen = snprintf(name, OCFS2_ORPHAN_NAMELEN + 1, "%016llx",
2088 			   (long long)blkno);
2089 	if (namelen <= 0) {
2090 		if (namelen)
2091 			status = namelen;
2092 		else
2093 			status = -EINVAL;
2094 		mlog_errno(status);
2095 		goto bail;
2096 	}
2097 	if (namelen != OCFS2_ORPHAN_NAMELEN) {
2098 		status = -EINVAL;
2099 		mlog_errno(status);
2100 		goto bail;
2101 	}
2102 
2103 	trace_ocfs2_blkno_stringify(blkno, name, namelen);
2104 
2105 	status = 0;
2106 bail:
2107 	if (status < 0)
2108 		mlog_errno(status);
2109 	return status;
2110 }
2111 
ocfs2_lookup_lock_orphan_dir(struct ocfs2_super * osb,struct inode ** ret_orphan_dir,struct buffer_head ** ret_orphan_dir_bh)2112 static int ocfs2_lookup_lock_orphan_dir(struct ocfs2_super *osb,
2113 					struct inode **ret_orphan_dir,
2114 					struct buffer_head **ret_orphan_dir_bh)
2115 {
2116 	struct inode *orphan_dir_inode;
2117 	struct buffer_head *orphan_dir_bh = NULL;
2118 	int ret = 0;
2119 
2120 	orphan_dir_inode = ocfs2_get_system_file_inode(osb,
2121 						       ORPHAN_DIR_SYSTEM_INODE,
2122 						       osb->slot_num);
2123 	if (!orphan_dir_inode) {
2124 		ret = -ENOENT;
2125 		mlog_errno(ret);
2126 		return ret;
2127 	}
2128 
2129 	inode_lock(orphan_dir_inode);
2130 
2131 	ret = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1);
2132 	if (ret < 0) {
2133 		inode_unlock(orphan_dir_inode);
2134 		iput(orphan_dir_inode);
2135 
2136 		mlog_errno(ret);
2137 		return ret;
2138 	}
2139 
2140 	*ret_orphan_dir = orphan_dir_inode;
2141 	*ret_orphan_dir_bh = orphan_dir_bh;
2142 
2143 	return 0;
2144 }
2145 
__ocfs2_prepare_orphan_dir(struct inode * orphan_dir_inode,struct buffer_head * orphan_dir_bh,u64 blkno,char * name,struct ocfs2_dir_lookup_result * lookup,bool dio)2146 static int __ocfs2_prepare_orphan_dir(struct inode *orphan_dir_inode,
2147 				      struct buffer_head *orphan_dir_bh,
2148 				      u64 blkno,
2149 				      char *name,
2150 				      struct ocfs2_dir_lookup_result *lookup,
2151 				      bool dio)
2152 {
2153 	int ret;
2154 	struct ocfs2_super *osb = OCFS2_SB(orphan_dir_inode->i_sb);
2155 	int namelen = dio ?
2156 			(OCFS2_DIO_ORPHAN_PREFIX_LEN + OCFS2_ORPHAN_NAMELEN) :
2157 			OCFS2_ORPHAN_NAMELEN;
2158 
2159 	if (dio) {
2160 		ret = snprintf(name, OCFS2_DIO_ORPHAN_PREFIX_LEN + 1, "%s",
2161 				OCFS2_DIO_ORPHAN_PREFIX);
2162 		if (ret != OCFS2_DIO_ORPHAN_PREFIX_LEN) {
2163 			ret = -EINVAL;
2164 			mlog_errno(ret);
2165 			return ret;
2166 		}
2167 
2168 		ret = ocfs2_blkno_stringify(blkno,
2169 				name + OCFS2_DIO_ORPHAN_PREFIX_LEN);
2170 	} else
2171 		ret = ocfs2_blkno_stringify(blkno, name);
2172 	if (ret < 0) {
2173 		mlog_errno(ret);
2174 		return ret;
2175 	}
2176 
2177 	ret = ocfs2_prepare_dir_for_insert(osb, orphan_dir_inode,
2178 					   orphan_dir_bh, name,
2179 					   namelen, lookup);
2180 	if (ret < 0) {
2181 		mlog_errno(ret);
2182 		return ret;
2183 	}
2184 
2185 	return 0;
2186 }
2187 
2188 /**
2189  * ocfs2_prepare_orphan_dir() - Prepare an orphan directory for
2190  * insertion of an orphan.
2191  * @osb: ocfs2 file system
2192  * @ret_orphan_dir: Orphan dir inode - returned locked!
2193  * @blkno: Actual block number of the inode to be inserted into orphan dir.
2194  * @name: Buffer to store the name of the orphan.
2195  * @lookup: dir lookup result, to be passed back into functions like
2196  *          ocfs2_orphan_add
2197  * @dio: Flag indicating if direct IO is being used or not.
2198  *
2199  * Returns zero on success and the ret_orphan_dir, name and lookup
2200  * fields will be populated.
2201  *
2202  * Returns non-zero on failure.
2203  */
ocfs2_prepare_orphan_dir(struct ocfs2_super * osb,struct inode ** ret_orphan_dir,u64 blkno,char * name,struct ocfs2_dir_lookup_result * lookup,bool dio)2204 static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb,
2205 				    struct inode **ret_orphan_dir,
2206 				    u64 blkno,
2207 				    char *name,
2208 				    struct ocfs2_dir_lookup_result *lookup,
2209 				    bool dio)
2210 {
2211 	struct inode *orphan_dir_inode = NULL;
2212 	struct buffer_head *orphan_dir_bh = NULL;
2213 	int ret = 0;
2214 
2215 	ret = ocfs2_lookup_lock_orphan_dir(osb, &orphan_dir_inode,
2216 					   &orphan_dir_bh);
2217 	if (ret < 0) {
2218 		mlog_errno(ret);
2219 		return ret;
2220 	}
2221 
2222 	ret = __ocfs2_prepare_orphan_dir(orphan_dir_inode, orphan_dir_bh,
2223 					 blkno, name, lookup, dio);
2224 	if (ret < 0) {
2225 		mlog_errno(ret);
2226 		goto out;
2227 	}
2228 
2229 	*ret_orphan_dir = orphan_dir_inode;
2230 
2231 out:
2232 	brelse(orphan_dir_bh);
2233 
2234 	if (ret) {
2235 		ocfs2_inode_unlock(orphan_dir_inode, 1);
2236 		inode_unlock(orphan_dir_inode);
2237 		iput(orphan_dir_inode);
2238 	}
2239 
2240 	if (ret)
2241 		mlog_errno(ret);
2242 	return ret;
2243 }
2244 
ocfs2_orphan_add(struct ocfs2_super * osb,handle_t * handle,struct inode * inode,struct buffer_head * fe_bh,char * name,struct ocfs2_dir_lookup_result * lookup,struct inode * orphan_dir_inode,bool dio)2245 static int ocfs2_orphan_add(struct ocfs2_super *osb,
2246 			    handle_t *handle,
2247 			    struct inode *inode,
2248 			    struct buffer_head *fe_bh,
2249 			    char *name,
2250 			    struct ocfs2_dir_lookup_result *lookup,
2251 			    struct inode *orphan_dir_inode,
2252 			    bool dio)
2253 {
2254 	struct buffer_head *orphan_dir_bh = NULL;
2255 	int status = 0;
2256 	struct ocfs2_dinode *orphan_fe;
2257 	struct ocfs2_dinode *fe = (struct ocfs2_dinode *) fe_bh->b_data;
2258 	int namelen = dio ?
2259 			(OCFS2_DIO_ORPHAN_PREFIX_LEN + OCFS2_ORPHAN_NAMELEN) :
2260 			OCFS2_ORPHAN_NAMELEN;
2261 
2262 	trace_ocfs2_orphan_add_begin(
2263 				(unsigned long long)OCFS2_I(inode)->ip_blkno);
2264 
2265 	status = ocfs2_read_inode_block(orphan_dir_inode, &orphan_dir_bh);
2266 	if (status < 0) {
2267 		mlog_errno(status);
2268 		goto leave;
2269 	}
2270 
2271 	status = ocfs2_journal_access_di(handle,
2272 					 INODE_CACHE(orphan_dir_inode),
2273 					 orphan_dir_bh,
2274 					 OCFS2_JOURNAL_ACCESS_WRITE);
2275 	if (status < 0) {
2276 		mlog_errno(status);
2277 		goto leave;
2278 	}
2279 
2280 	/*
2281 	 * We're going to journal the change of i_flags and i_orphaned_slot.
2282 	 * It's safe anyway, though some callers may duplicate the journaling.
2283 	 * Journaling within the func just make the logic look more
2284 	 * straightforward.
2285 	 */
2286 	status = ocfs2_journal_access_di(handle,
2287 					 INODE_CACHE(inode),
2288 					 fe_bh,
2289 					 OCFS2_JOURNAL_ACCESS_WRITE);
2290 	if (status < 0) {
2291 		mlog_errno(status);
2292 		goto leave;
2293 	}
2294 
2295 	/* we're a cluster, and nlink can change on disk from
2296 	 * underneath us... */
2297 	orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data;
2298 	if (S_ISDIR(inode->i_mode))
2299 		ocfs2_add_links_count(orphan_fe, 1);
2300 	set_nlink(orphan_dir_inode, ocfs2_read_links_count(orphan_fe));
2301 	ocfs2_journal_dirty(handle, orphan_dir_bh);
2302 
2303 	status = __ocfs2_add_entry(handle, orphan_dir_inode, name,
2304 				   namelen, inode,
2305 				   OCFS2_I(inode)->ip_blkno,
2306 				   orphan_dir_bh, lookup);
2307 	if (status < 0) {
2308 		mlog_errno(status);
2309 		goto rollback;
2310 	}
2311 
2312 	if (dio) {
2313 		/* Update flag OCFS2_DIO_ORPHANED_FL and record the orphan
2314 		 * slot.
2315 		 */
2316 		fe->i_flags |= cpu_to_le32(OCFS2_DIO_ORPHANED_FL);
2317 		fe->i_dio_orphaned_slot = cpu_to_le16(osb->slot_num);
2318 	} else {
2319 		fe->i_flags |= cpu_to_le32(OCFS2_ORPHANED_FL);
2320 		OCFS2_I(inode)->ip_flags &= ~OCFS2_INODE_SKIP_ORPHAN_DIR;
2321 
2322 		/* Record which orphan dir our inode now resides
2323 		 * in. delete_inode will use this to determine which orphan
2324 		 * dir to lock. */
2325 		fe->i_orphaned_slot = cpu_to_le16(osb->slot_num);
2326 	}
2327 
2328 	ocfs2_journal_dirty(handle, fe_bh);
2329 
2330 	trace_ocfs2_orphan_add_end((unsigned long long)OCFS2_I(inode)->ip_blkno,
2331 				   osb->slot_num);
2332 
2333 rollback:
2334 	if (status < 0) {
2335 		if (S_ISDIR(inode->i_mode))
2336 			ocfs2_add_links_count(orphan_fe, -1);
2337 		set_nlink(orphan_dir_inode, ocfs2_read_links_count(orphan_fe));
2338 	}
2339 
2340 leave:
2341 	brelse(orphan_dir_bh);
2342 
2343 	return status;
2344 }
2345 
2346 /* unlike orphan_add, we expect the orphan dir to already be locked here. */
ocfs2_orphan_del(struct ocfs2_super * osb,handle_t * handle,struct inode * orphan_dir_inode,struct inode * inode,struct buffer_head * orphan_dir_bh,bool dio)2347 int ocfs2_orphan_del(struct ocfs2_super *osb,
2348 		     handle_t *handle,
2349 		     struct inode *orphan_dir_inode,
2350 		     struct inode *inode,
2351 		     struct buffer_head *orphan_dir_bh,
2352 		     bool dio)
2353 {
2354 	char name[OCFS2_DIO_ORPHAN_PREFIX_LEN + OCFS2_ORPHAN_NAMELEN + 1];
2355 	struct ocfs2_dinode *orphan_fe;
2356 	int status = 0;
2357 	struct ocfs2_dir_lookup_result lookup = { NULL, };
2358 
2359 	if (dio) {
2360 		status = snprintf(name, OCFS2_DIO_ORPHAN_PREFIX_LEN + 1, "%s",
2361 				OCFS2_DIO_ORPHAN_PREFIX);
2362 		if (status != OCFS2_DIO_ORPHAN_PREFIX_LEN) {
2363 			status = -EINVAL;
2364 			mlog_errno(status);
2365 			return status;
2366 		}
2367 
2368 		status = ocfs2_blkno_stringify(OCFS2_I(inode)->ip_blkno,
2369 				name + OCFS2_DIO_ORPHAN_PREFIX_LEN);
2370 	} else
2371 		status = ocfs2_blkno_stringify(OCFS2_I(inode)->ip_blkno, name);
2372 	if (status < 0) {
2373 		mlog_errno(status);
2374 		goto leave;
2375 	}
2376 
2377 	trace_ocfs2_orphan_del(
2378 	     (unsigned long long)OCFS2_I(orphan_dir_inode)->ip_blkno,
2379 	     name, strlen(name));
2380 
2381 	status = ocfs2_journal_access_di(handle,
2382 					 INODE_CACHE(orphan_dir_inode),
2383 					 orphan_dir_bh,
2384 					 OCFS2_JOURNAL_ACCESS_WRITE);
2385 	if (status < 0) {
2386 		mlog_errno(status);
2387 		goto leave;
2388 	}
2389 
2390 	/* find it's spot in the orphan directory */
2391 	status = ocfs2_find_entry(name, strlen(name), orphan_dir_inode,
2392 				  &lookup);
2393 	if (status) {
2394 		mlog_errno(status);
2395 		goto leave;
2396 	}
2397 
2398 	/* remove it from the orphan directory */
2399 	status = ocfs2_delete_entry(handle, orphan_dir_inode, &lookup);
2400 	if (status < 0) {
2401 		mlog_errno(status);
2402 		goto leave;
2403 	}
2404 
2405 	/* do the i_nlink dance! :) */
2406 	orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data;
2407 	if (S_ISDIR(inode->i_mode))
2408 		ocfs2_add_links_count(orphan_fe, -1);
2409 	set_nlink(orphan_dir_inode, ocfs2_read_links_count(orphan_fe));
2410 	ocfs2_journal_dirty(handle, orphan_dir_bh);
2411 
2412 leave:
2413 	ocfs2_free_dir_lookup_result(&lookup);
2414 
2415 	if (status)
2416 		mlog_errno(status);
2417 	return status;
2418 }
2419 
2420 /**
2421  * ocfs2_prep_new_orphaned_file() - Prepare the orphan dir to receive a newly
2422  * allocated file. This is different from the typical 'add to orphan dir'
2423  * operation in that the inode does not yet exist. This is a problem because
2424  * the orphan dir stringifies the inode block number to come up with it's
2425  * dirent. Obviously if the inode does not yet exist we have a chicken and egg
2426  * problem. This function works around it by calling deeper into the orphan
2427  * and suballoc code than other callers. Use this only by necessity.
2428  * @dir: The directory which this inode will ultimately wind up under - not the
2429  * orphan dir!
2430  * @dir_bh: buffer_head the @dir inode block
2431  * @orphan_name: string of length (CFS2_ORPHAN_NAMELEN + 1). Will be filled
2432  * with the string to be used for orphan dirent. Pass back to the orphan dir
2433  * code.
2434  * @ret_orphan_dir: orphan dir inode returned to be passed back into orphan
2435  * dir code.
2436  * @ret_di_blkno: block number where the new inode will be allocated.
2437  * @orphan_insert: Dir insert context to be passed back into orphan dir code.
2438  * @ret_inode_ac: Inode alloc context to be passed back to the allocator.
2439  *
2440  * Returns zero on success and the ret_orphan_dir, name and lookup
2441  * fields will be populated.
2442  *
2443  * Returns non-zero on failure.
2444  */
ocfs2_prep_new_orphaned_file(struct inode * dir,struct buffer_head * dir_bh,char * orphan_name,struct inode ** ret_orphan_dir,u64 * ret_di_blkno,struct ocfs2_dir_lookup_result * orphan_insert,struct ocfs2_alloc_context ** ret_inode_ac)2445 static int ocfs2_prep_new_orphaned_file(struct inode *dir,
2446 					struct buffer_head *dir_bh,
2447 					char *orphan_name,
2448 					struct inode **ret_orphan_dir,
2449 					u64 *ret_di_blkno,
2450 					struct ocfs2_dir_lookup_result *orphan_insert,
2451 					struct ocfs2_alloc_context **ret_inode_ac)
2452 {
2453 	int ret;
2454 	u64 di_blkno;
2455 	struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
2456 	struct inode *orphan_dir = NULL;
2457 	struct buffer_head *orphan_dir_bh = NULL;
2458 	struct ocfs2_alloc_context *inode_ac = NULL;
2459 
2460 	ret = ocfs2_lookup_lock_orphan_dir(osb, &orphan_dir, &orphan_dir_bh);
2461 	if (ret < 0) {
2462 		mlog_errno(ret);
2463 		return ret;
2464 	}
2465 
2466 	/* reserve an inode spot */
2467 	ret = ocfs2_reserve_new_inode(osb, &inode_ac);
2468 	if (ret < 0) {
2469 		if (ret != -ENOSPC)
2470 			mlog_errno(ret);
2471 		goto out;
2472 	}
2473 
2474 	ret = ocfs2_find_new_inode_loc(dir, dir_bh, inode_ac,
2475 				       &di_blkno);
2476 	if (ret) {
2477 		mlog_errno(ret);
2478 		goto out;
2479 	}
2480 
2481 	ret = __ocfs2_prepare_orphan_dir(orphan_dir, orphan_dir_bh,
2482 					 di_blkno, orphan_name, orphan_insert,
2483 					 false);
2484 	if (ret < 0) {
2485 		mlog_errno(ret);
2486 		goto out;
2487 	}
2488 
2489 out:
2490 	if (ret == 0) {
2491 		*ret_orphan_dir = orphan_dir;
2492 		*ret_di_blkno = di_blkno;
2493 		*ret_inode_ac = inode_ac;
2494 		/*
2495 		 * orphan_name and orphan_insert are already up to
2496 		 * date via prepare_orphan_dir
2497 		 */
2498 	} else {
2499 		/* Unroll reserve_new_inode* */
2500 		if (inode_ac)
2501 			ocfs2_free_alloc_context(inode_ac);
2502 
2503 		/* Unroll orphan dir locking */
2504 		inode_unlock(orphan_dir);
2505 		ocfs2_inode_unlock(orphan_dir, 1);
2506 		iput(orphan_dir);
2507 	}
2508 
2509 	brelse(orphan_dir_bh);
2510 
2511 	return ret;
2512 }
2513 
ocfs2_create_inode_in_orphan(struct inode * dir,int mode,struct inode ** new_inode)2514 int ocfs2_create_inode_in_orphan(struct inode *dir,
2515 				 int mode,
2516 				 struct inode **new_inode)
2517 {
2518 	int status, did_quota_inode = 0;
2519 	struct inode *inode = NULL;
2520 	struct inode *orphan_dir = NULL;
2521 	struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
2522 	handle_t *handle = NULL;
2523 	char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
2524 	struct buffer_head *parent_di_bh = NULL;
2525 	struct buffer_head *new_di_bh = NULL;
2526 	struct ocfs2_alloc_context *inode_ac = NULL;
2527 	struct ocfs2_dir_lookup_result orphan_insert = { NULL, };
2528 	u64 di_blkno, suballoc_loc;
2529 	u16 suballoc_bit;
2530 
2531 	status = ocfs2_inode_lock(dir, &parent_di_bh, 1);
2532 	if (status < 0) {
2533 		if (status != -ENOENT)
2534 			mlog_errno(status);
2535 		return status;
2536 	}
2537 
2538 	status = ocfs2_prep_new_orphaned_file(dir, parent_di_bh,
2539 					      orphan_name, &orphan_dir,
2540 					      &di_blkno, &orphan_insert, &inode_ac);
2541 	if (status < 0) {
2542 		if (status != -ENOSPC)
2543 			mlog_errno(status);
2544 		goto leave;
2545 	}
2546 
2547 	inode = ocfs2_get_init_inode(dir, mode);
2548 	if (IS_ERR(inode)) {
2549 		status = PTR_ERR(inode);
2550 		inode = NULL;
2551 		mlog_errno(status);
2552 		goto leave;
2553 	}
2554 
2555 	handle = ocfs2_start_trans(osb, ocfs2_mknod_credits(osb->sb, 0, 0));
2556 	if (IS_ERR(handle)) {
2557 		status = PTR_ERR(handle);
2558 		handle = NULL;
2559 		mlog_errno(status);
2560 		goto leave;
2561 	}
2562 
2563 	status = dquot_alloc_inode(inode);
2564 	if (status)
2565 		goto leave;
2566 	did_quota_inode = 1;
2567 
2568 	status = ocfs2_claim_new_inode_at_loc(handle, dir, inode_ac,
2569 					      &suballoc_loc,
2570 					      &suballoc_bit, di_blkno);
2571 	if (status < 0) {
2572 		mlog_errno(status);
2573 		goto leave;
2574 	}
2575 
2576 	clear_nlink(inode);
2577 	/* do the real work now. */
2578 	status = __ocfs2_mknod_locked(dir, inode,
2579 				      0, &new_di_bh, parent_di_bh, handle,
2580 				      inode_ac, di_blkno, suballoc_loc,
2581 				      suballoc_bit);
2582 	if (status < 0) {
2583 		mlog_errno(status);
2584 		goto leave;
2585 	}
2586 
2587 	status = ocfs2_orphan_add(osb, handle, inode, new_di_bh, orphan_name,
2588 				  &orphan_insert, orphan_dir, false);
2589 	if (status < 0) {
2590 		mlog_errno(status);
2591 		goto leave;
2592 	}
2593 
2594 	/* get open lock so that only nodes can't remove it from orphan dir. */
2595 	status = ocfs2_open_lock(inode);
2596 	if (status < 0)
2597 		mlog_errno(status);
2598 
2599 	insert_inode_hash(inode);
2600 leave:
2601 	if (status < 0 && did_quota_inode)
2602 		dquot_free_inode(inode);
2603 	if (handle)
2604 		ocfs2_commit_trans(osb, handle);
2605 
2606 	if (orphan_dir) {
2607 		/* This was locked for us in ocfs2_prepare_orphan_dir() */
2608 		ocfs2_inode_unlock(orphan_dir, 1);
2609 		inode_unlock(orphan_dir);
2610 		iput(orphan_dir);
2611 	}
2612 
2613 	if ((status < 0) && inode) {
2614 		clear_nlink(inode);
2615 		iput(inode);
2616 	}
2617 
2618 	if (inode_ac)
2619 		ocfs2_free_alloc_context(inode_ac);
2620 
2621 	brelse(new_di_bh);
2622 
2623 	if (!status)
2624 		*new_inode = inode;
2625 
2626 	ocfs2_free_dir_lookup_result(&orphan_insert);
2627 
2628 	ocfs2_inode_unlock(dir, 1);
2629 	brelse(parent_di_bh);
2630 	return status;
2631 }
2632 
ocfs2_add_inode_to_orphan(struct ocfs2_super * osb,struct inode * inode)2633 int ocfs2_add_inode_to_orphan(struct ocfs2_super *osb,
2634 	struct inode *inode)
2635 {
2636 	char orphan_name[OCFS2_DIO_ORPHAN_PREFIX_LEN + OCFS2_ORPHAN_NAMELEN + 1];
2637 	struct inode *orphan_dir_inode = NULL;
2638 	struct ocfs2_dir_lookup_result orphan_insert = { NULL, };
2639 	struct buffer_head *di_bh = NULL;
2640 	int status = 0;
2641 	handle_t *handle = NULL;
2642 	struct ocfs2_dinode *di = NULL;
2643 
2644 	status = ocfs2_inode_lock(inode, &di_bh, 1);
2645 	if (status < 0) {
2646 		mlog_errno(status);
2647 		goto bail;
2648 	}
2649 
2650 	di = (struct ocfs2_dinode *) di_bh->b_data;
2651 	/*
2652 	 * Another append dio crashed?
2653 	 * If so, manually recover it first.
2654 	 */
2655 	if (unlikely(di->i_flags & cpu_to_le32(OCFS2_DIO_ORPHANED_FL))) {
2656 		status = ocfs2_truncate_file(inode, di_bh, i_size_read(inode));
2657 		if (status < 0) {
2658 			if (status != -ENOSPC)
2659 				mlog_errno(status);
2660 			goto bail_unlock_inode;
2661 		}
2662 
2663 		status = ocfs2_del_inode_from_orphan(osb, inode, di_bh, 0, 0);
2664 		if (status < 0) {
2665 			mlog_errno(status);
2666 			goto bail_unlock_inode;
2667 		}
2668 	}
2669 
2670 	status = ocfs2_prepare_orphan_dir(osb, &orphan_dir_inode,
2671 			OCFS2_I(inode)->ip_blkno,
2672 			orphan_name,
2673 			&orphan_insert,
2674 			true);
2675 	if (status < 0) {
2676 		mlog_errno(status);
2677 		goto bail_unlock_inode;
2678 	}
2679 
2680 	handle = ocfs2_start_trans(osb,
2681 			OCFS2_INODE_ADD_TO_ORPHAN_CREDITS);
2682 	if (IS_ERR(handle)) {
2683 		status = PTR_ERR(handle);
2684 		goto bail_unlock_orphan;
2685 	}
2686 
2687 	status = ocfs2_orphan_add(osb, handle, inode, di_bh, orphan_name,
2688 			&orphan_insert, orphan_dir_inode, true);
2689 	if (status)
2690 		mlog_errno(status);
2691 
2692 	ocfs2_commit_trans(osb, handle);
2693 
2694 bail_unlock_orphan:
2695 	ocfs2_inode_unlock(orphan_dir_inode, 1);
2696 	inode_unlock(orphan_dir_inode);
2697 	iput(orphan_dir_inode);
2698 
2699 	ocfs2_free_dir_lookup_result(&orphan_insert);
2700 
2701 bail_unlock_inode:
2702 	ocfs2_inode_unlock(inode, 1);
2703 	brelse(di_bh);
2704 
2705 bail:
2706 	return status;
2707 }
2708 
ocfs2_del_inode_from_orphan(struct ocfs2_super * osb,struct inode * inode,struct buffer_head * di_bh,int update_isize,loff_t end)2709 int ocfs2_del_inode_from_orphan(struct ocfs2_super *osb,
2710 		struct inode *inode, struct buffer_head *di_bh,
2711 		int update_isize, loff_t end)
2712 {
2713 	struct inode *orphan_dir_inode = NULL;
2714 	struct buffer_head *orphan_dir_bh = NULL;
2715 	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
2716 	handle_t *handle = NULL;
2717 	int status = 0;
2718 
2719 	orphan_dir_inode = ocfs2_get_system_file_inode(osb,
2720 			ORPHAN_DIR_SYSTEM_INODE,
2721 			le16_to_cpu(di->i_dio_orphaned_slot));
2722 	if (!orphan_dir_inode) {
2723 		status = -ENOENT;
2724 		mlog_errno(status);
2725 		goto bail;
2726 	}
2727 
2728 	inode_lock(orphan_dir_inode);
2729 	status = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1);
2730 	if (status < 0) {
2731 		inode_unlock(orphan_dir_inode);
2732 		iput(orphan_dir_inode);
2733 		mlog_errno(status);
2734 		goto bail;
2735 	}
2736 
2737 	handle = ocfs2_start_trans(osb,
2738 			OCFS2_INODE_DEL_FROM_ORPHAN_CREDITS);
2739 	if (IS_ERR(handle)) {
2740 		status = PTR_ERR(handle);
2741 		goto bail_unlock_orphan;
2742 	}
2743 
2744 	BUG_ON(!(di->i_flags & cpu_to_le32(OCFS2_DIO_ORPHANED_FL)));
2745 
2746 	status = ocfs2_orphan_del(osb, handle, orphan_dir_inode,
2747 				inode, orphan_dir_bh, true);
2748 	if (status < 0) {
2749 		mlog_errno(status);
2750 		goto bail_commit;
2751 	}
2752 
2753 	status = ocfs2_journal_access_di(handle,
2754 			INODE_CACHE(inode),
2755 			di_bh,
2756 			OCFS2_JOURNAL_ACCESS_WRITE);
2757 	if (status < 0) {
2758 		mlog_errno(status);
2759 		goto bail_commit;
2760 	}
2761 
2762 	di->i_flags &= ~cpu_to_le32(OCFS2_DIO_ORPHANED_FL);
2763 	di->i_dio_orphaned_slot = 0;
2764 
2765 	if (update_isize) {
2766 		status = ocfs2_set_inode_size(handle, inode, di_bh, end);
2767 		if (status)
2768 			mlog_errno(status);
2769 	} else
2770 		ocfs2_journal_dirty(handle, di_bh);
2771 
2772 bail_commit:
2773 	ocfs2_commit_trans(osb, handle);
2774 
2775 bail_unlock_orphan:
2776 	ocfs2_inode_unlock(orphan_dir_inode, 1);
2777 	inode_unlock(orphan_dir_inode);
2778 	brelse(orphan_dir_bh);
2779 	iput(orphan_dir_inode);
2780 
2781 bail:
2782 	return status;
2783 }
2784 
ocfs2_mv_orphaned_inode_to_new(struct inode * dir,struct inode * inode,struct dentry * dentry)2785 int ocfs2_mv_orphaned_inode_to_new(struct inode *dir,
2786 				   struct inode *inode,
2787 				   struct dentry *dentry)
2788 {
2789 	int status = 0;
2790 	struct buffer_head *parent_di_bh = NULL;
2791 	handle_t *handle = NULL;
2792 	struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
2793 	struct ocfs2_dinode *dir_di, *di;
2794 	struct inode *orphan_dir_inode = NULL;
2795 	struct buffer_head *orphan_dir_bh = NULL;
2796 	struct buffer_head *di_bh = NULL;
2797 	struct ocfs2_dir_lookup_result lookup = { NULL, };
2798 
2799 	trace_ocfs2_mv_orphaned_inode_to_new(dir, dentry,
2800 				dentry->d_name.len, dentry->d_name.name,
2801 				(unsigned long long)OCFS2_I(dir)->ip_blkno,
2802 				(unsigned long long)OCFS2_I(inode)->ip_blkno);
2803 
2804 	status = ocfs2_inode_lock(dir, &parent_di_bh, 1);
2805 	if (status < 0) {
2806 		if (status != -ENOENT)
2807 			mlog_errno(status);
2808 		return status;
2809 	}
2810 
2811 	dir_di = (struct ocfs2_dinode *) parent_di_bh->b_data;
2812 	if (!dir_di->i_links_count) {
2813 		/* can't make a file in a deleted directory. */
2814 		status = -ENOENT;
2815 		goto leave;
2816 	}
2817 
2818 	status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
2819 					   dentry->d_name.len);
2820 	if (status)
2821 		goto leave;
2822 
2823 	/* get a spot inside the dir. */
2824 	status = ocfs2_prepare_dir_for_insert(osb, dir, parent_di_bh,
2825 					      dentry->d_name.name,
2826 					      dentry->d_name.len, &lookup);
2827 	if (status < 0) {
2828 		mlog_errno(status);
2829 		goto leave;
2830 	}
2831 
2832 	orphan_dir_inode = ocfs2_get_system_file_inode(osb,
2833 						       ORPHAN_DIR_SYSTEM_INODE,
2834 						       osb->slot_num);
2835 	if (!orphan_dir_inode) {
2836 		status = -ENOENT;
2837 		mlog_errno(status);
2838 		goto leave;
2839 	}
2840 
2841 	inode_lock(orphan_dir_inode);
2842 
2843 	status = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1);
2844 	if (status < 0) {
2845 		mlog_errno(status);
2846 		inode_unlock(orphan_dir_inode);
2847 		iput(orphan_dir_inode);
2848 		goto leave;
2849 	}
2850 
2851 	status = ocfs2_read_inode_block(inode, &di_bh);
2852 	if (status < 0) {
2853 		mlog_errno(status);
2854 		goto orphan_unlock;
2855 	}
2856 
2857 	handle = ocfs2_start_trans(osb, ocfs2_rename_credits(osb->sb));
2858 	if (IS_ERR(handle)) {
2859 		status = PTR_ERR(handle);
2860 		handle = NULL;
2861 		mlog_errno(status);
2862 		goto orphan_unlock;
2863 	}
2864 
2865 	status = ocfs2_journal_access_di(handle, INODE_CACHE(inode),
2866 					 di_bh, OCFS2_JOURNAL_ACCESS_WRITE);
2867 	if (status < 0) {
2868 		mlog_errno(status);
2869 		goto out_commit;
2870 	}
2871 
2872 	status = ocfs2_orphan_del(osb, handle, orphan_dir_inode, inode,
2873 				  orphan_dir_bh, false);
2874 	if (status < 0) {
2875 		mlog_errno(status);
2876 		goto out_commit;
2877 	}
2878 
2879 	di = (struct ocfs2_dinode *)di_bh->b_data;
2880 	di->i_flags &= ~cpu_to_le32(OCFS2_ORPHANED_FL);
2881 	di->i_orphaned_slot = 0;
2882 	set_nlink(inode, 1);
2883 	ocfs2_set_links_count(di, inode->i_nlink);
2884 	ocfs2_update_inode_fsync_trans(handle, inode, 1);
2885 	ocfs2_journal_dirty(handle, di_bh);
2886 
2887 	status = ocfs2_add_entry(handle, dentry, inode,
2888 				 OCFS2_I(inode)->ip_blkno, parent_di_bh,
2889 				 &lookup);
2890 	if (status < 0) {
2891 		mlog_errno(status);
2892 		goto out_commit;
2893 	}
2894 
2895 	status = ocfs2_dentry_attach_lock(dentry, inode,
2896 					  OCFS2_I(dir)->ip_blkno);
2897 	if (status) {
2898 		mlog_errno(status);
2899 		goto out_commit;
2900 	}
2901 
2902 	d_instantiate(dentry, inode);
2903 	status = 0;
2904 out_commit:
2905 	ocfs2_commit_trans(osb, handle);
2906 orphan_unlock:
2907 	ocfs2_inode_unlock(orphan_dir_inode, 1);
2908 	inode_unlock(orphan_dir_inode);
2909 	iput(orphan_dir_inode);
2910 leave:
2911 
2912 	ocfs2_inode_unlock(dir, 1);
2913 
2914 	brelse(di_bh);
2915 	brelse(parent_di_bh);
2916 	brelse(orphan_dir_bh);
2917 
2918 	ocfs2_free_dir_lookup_result(&lookup);
2919 
2920 	if (status)
2921 		mlog_errno(status);
2922 
2923 	return status;
2924 }
2925 
2926 const struct inode_operations ocfs2_dir_iops = {
2927 	.create		= ocfs2_create,
2928 	.lookup		= ocfs2_lookup,
2929 	.link		= ocfs2_link,
2930 	.unlink		= ocfs2_unlink,
2931 	.rmdir		= ocfs2_unlink,
2932 	.symlink	= ocfs2_symlink,
2933 	.mkdir		= ocfs2_mkdir,
2934 	.mknod		= ocfs2_mknod,
2935 	.rename		= ocfs2_rename,
2936 	.setattr	= ocfs2_setattr,
2937 	.getattr	= ocfs2_getattr,
2938 	.permission	= ocfs2_permission,
2939 	.listxattr	= ocfs2_listxattr,
2940 	.fiemap         = ocfs2_fiemap,
2941 	.get_inode_acl	= ocfs2_iop_get_acl,
2942 	.set_acl	= ocfs2_iop_set_acl,
2943 	.fileattr_get	= ocfs2_fileattr_get,
2944 	.fileattr_set	= ocfs2_fileattr_set,
2945 };
2946