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