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