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