]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - fs/ocfs2/namei.c
projects / mirror_ubuntu-jammy-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
vdpa: ifcvf: free config irq in ifcvf_free_irq()
[mirror_ubuntu-jammy-kernel.git] / fs / ocfs2 / namei.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* -*- mode: c; c-basic-offset: 8; -*-
3 * vim: noexpandtab sw=8 ts=8 sts=0:
4 *
5 * namei.c
6 *
7 * Create and rename file, directory, symlinks
8 *
9 * Copyright (C) 2002, 2004 Oracle. All rights reserved.
10 *
11 * Portions of this code from linux/fs/ext3/dir.c
12 *
13 * Copyright (C) 1992, 1993, 1994, 1995
14 * Remy Card (card@masi.ibp.fr)
15 * Laboratoire MASI - Institut Blaise pascal
16 * Universite Pierre et Marie Curie (Paris VI)
17 *
18 * from
19 *
20 * linux/fs/minix/dir.c
21 *
22 * Copyright (C) 1991, 1992 Linux Torvalds
23 */
24
25 #include <linux/fs.h>
26 #include <linux/types.h>
27 #include <linux/slab.h>
28 #include <linux/highmem.h>
29 #include <linux/quotaops.h>
30 #include <linux/iversion.h>
31
32 #include <cluster/masklog.h>
33
34 #include "ocfs2.h"
35
36 #include "alloc.h"
37 #include "dcache.h"
38 #include "dir.h"
39 #include "dlmglue.h"
40 #include "extent_map.h"
41 #include "file.h"
42 #include "inode.h"
43 #include "journal.h"
44 #include "namei.h"
45 #include "suballoc.h"
46 #include "super.h"
47 #include "symlink.h"
48 #include "sysfile.h"
49 #include "uptodate.h"
50 #include "xattr.h"
51 #include "acl.h"
52 #include "ocfs2_trace.h"
53
54 #include "buffer_head_io.h"
55
56 static int ocfs2_mknod_locked(struct ocfs2_super *osb,
57 struct inode *dir,
58 struct inode *inode,
59 dev_t dev,
60 struct buffer_head **new_fe_bh,
61 struct buffer_head *parent_fe_bh,
62 handle_t *handle,
63 struct ocfs2_alloc_context *inode_ac);
64
65 static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb,
66 struct inode **ret_orphan_dir,
67 u64 blkno,
68 char *name,
69 struct ocfs2_dir_lookup_result *lookup,
70 bool dio);
71
72 static int ocfs2_orphan_add(struct ocfs2_super *osb,
73 handle_t *handle,
74 struct inode *inode,
75 struct buffer_head *fe_bh,
76 char *name,
77 struct ocfs2_dir_lookup_result *lookup,
78 struct inode *orphan_dir_inode,
79 bool dio);
80
81 static int ocfs2_create_symlink_data(struct ocfs2_super *osb,
82 handle_t *handle,
83 struct inode *inode,
84 const char *symname);
85
86 static int ocfs2_double_lock(struct ocfs2_super *osb,
87 struct buffer_head **bh1,
88 struct inode *inode1,
89 struct buffer_head **bh2,
90 struct inode *inode2,
91 int rename);
92
93 static void ocfs2_double_unlock(struct inode *inode1, struct inode *inode2);
94 /* An orphan dir name is an 8 byte value, printed as a hex string */
95 #define OCFS2_ORPHAN_NAMELEN ((int)(2 * sizeof(u64)))
96
97 static struct dentry *ocfs2_lookup(struct inode *dir, struct dentry *dentry,
98 unsigned int flags)
99 {
100 int status;
101 u64 blkno;
102 struct inode *inode = NULL;
103 struct dentry *ret;
104 struct ocfs2_inode_info *oi;
105
106 trace_ocfs2_lookup(dir, dentry, dentry->d_name.len,
107 dentry->d_name.name,
108 (unsigned long long)OCFS2_I(dir)->ip_blkno, 0);
109
110 if (dentry->d_name.len > OCFS2_MAX_FILENAME_LEN) {
111 ret = ERR_PTR(-ENAMETOOLONG);
112 goto bail;
113 }
114
115 status = ocfs2_inode_lock_nested(dir, NULL, 0, OI_LS_PARENT);
116 if (status < 0) {
117 if (status != -ENOENT)
118 mlog_errno(status);
119 ret = ERR_PTR(status);
120 goto bail;
121 }
122
123 status = ocfs2_lookup_ino_from_name(dir, dentry->d_name.name,
124 dentry->d_name.len, &blkno);
125 if (status < 0)
126 goto bail_add;
127
128 inode = ocfs2_iget(OCFS2_SB(dir->i_sb), blkno, 0, 0);
129 if (IS_ERR(inode)) {
130 ret = ERR_PTR(-EACCES);
131 goto bail_unlock;
132 }
133
134 oi = OCFS2_I(inode);
135 /* Clear any orphaned state... If we were able to look up the
136 * inode from a directory, it certainly can't be orphaned. We
137 * might have the bad state from a node which intended to
138 * orphan this inode but crashed before it could commit the
139 * unlink. */
140 spin_lock(&oi->ip_lock);
141 oi->ip_flags &= ~OCFS2_INODE_MAYBE_ORPHANED;
142 spin_unlock(&oi->ip_lock);
143
144 bail_add:
145 ret = d_splice_alias(inode, dentry);
146
147 if (inode) {
148 /*
149 * If d_splice_alias() finds a DCACHE_DISCONNECTED
150 * dentry, it will d_move() it on top of ourse. The
151 * return value will indicate this however, so in
152 * those cases, we switch them around for the locking
153 * code.
154 *
155 * NOTE: This dentry already has ->d_op set from
156 * ocfs2_get_parent() and ocfs2_get_dentry()
157 */
158 if (!IS_ERR_OR_NULL(ret))
159 dentry = ret;
160
161 status = ocfs2_dentry_attach_lock(dentry, inode,
162 OCFS2_I(dir)->ip_blkno);
163 if (status) {
164 mlog_errno(status);
165 ret = ERR_PTR(status);
166 goto bail_unlock;
167 }
168 } else
169 ocfs2_dentry_attach_gen(dentry);
170
171 bail_unlock:
172 /* Don't drop the cluster lock until *after* the d_add --
173 * unlink on another node will message us to remove that
174 * dentry under this lock so otherwise we can race this with
175 * the downconvert thread and have a stale dentry. */
176 ocfs2_inode_unlock(dir, 0);
177
178 bail:
179
180 trace_ocfs2_lookup_ret(ret);
181
182 return ret;
183 }
184
185 static struct inode *ocfs2_get_init_inode(struct inode *dir, umode_t mode)
186 {
187 struct inode *inode;
188 int status;
189
190 inode = new_inode(dir->i_sb);
191 if (!inode) {
192 mlog(ML_ERROR, "new_inode failed!\n");
193 return ERR_PTR(-ENOMEM);
194 }
195
196 /* populate as many fields early on as possible - many of
197 * these are used by the support functions here and in
198 * callers. */
199 if (S_ISDIR(mode))
200 set_nlink(inode, 2);
201 inode_init_owner(inode, dir, mode);
202 status = dquot_initialize(inode);
203 if (status)
204 return ERR_PTR(status);
205
206 return inode;
207 }
208
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
224 static int ocfs2_mknod(struct inode *dir,
225 struct dentry *dentry,
226 umode_t mode,
227 dev_t dev)
228 {
229 int status = 0;
230 struct buffer_head *parent_fe_bh = NULL;
231 handle_t *handle = NULL;
232 struct ocfs2_super *osb;
233 struct ocfs2_dinode *dirfe;
234 struct buffer_head *new_fe_bh = NULL;
235 struct inode *inode = NULL;
236 struct ocfs2_alloc_context *inode_ac = NULL;
237 struct ocfs2_alloc_context *data_ac = NULL;
238 struct ocfs2_alloc_context *meta_ac = NULL;
239 int want_clusters = 0;
240 int want_meta = 0;
241 int xattr_credits = 0;
242 struct ocfs2_security_xattr_info si = {
243 .enable = 1,
244 };
245 int did_quota_inode = 0;
246 struct ocfs2_dir_lookup_result lookup = { NULL, };
247 sigset_t oldset;
248 int did_block_signals = 0;
249 struct ocfs2_dentry_lock *dl = NULL;
250
251 trace_ocfs2_mknod(dir, dentry, dentry->d_name.len, dentry->d_name.name,
252 (unsigned long long)OCFS2_I(dir)->ip_blkno,
253 (unsigned long)dev, mode);
254
255 status = dquot_initialize(dir);
256 if (status) {
257 mlog_errno(status);
258 return status;
259 }
260
261 /* get our super block */
262 osb = OCFS2_SB(dir->i_sb);
263
264 status = ocfs2_inode_lock(dir, &parent_fe_bh, 1);
265 if (status < 0) {
266 if (status != -ENOENT)
267 mlog_errno(status);
268 return status;
269 }
270
271 if (S_ISDIR(mode) && (dir->i_nlink >= ocfs2_link_max(osb))) {
272 status = -EMLINK;
273 goto leave;
274 }
275
276 dirfe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
277 if (!ocfs2_read_links_count(dirfe)) {
278 /* can't make a file in a deleted directory. */
279 status = -ENOENT;
280 goto leave;
281 }
282
283 status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
284 dentry->d_name.len);
285 if (status)
286 goto leave;
287
288 /* get a spot inside the dir. */
289 status = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
290 dentry->d_name.name,
291 dentry->d_name.len, &lookup);
292 if (status < 0) {
293 mlog_errno(status);
294 goto leave;
295 }
296
297 /* reserve an inode spot */
298 status = ocfs2_reserve_new_inode(osb, &inode_ac);
299 if (status < 0) {
300 if (status != -ENOSPC)
301 mlog_errno(status);
302 goto leave;
303 }
304
305 inode = ocfs2_get_init_inode(dir, mode);
306 if (IS_ERR(inode)) {
307 status = PTR_ERR(inode);
308 inode = NULL;
309 mlog_errno(status);
310 goto leave;
311 }
312
313 /* get security xattr */
314 status = ocfs2_init_security_get(inode, dir, &dentry->d_name, &si);
315 if (status) {
316 if (status == -EOPNOTSUPP)
317 si.enable = 0;
318 else {
319 mlog_errno(status);
320 goto leave;
321 }
322 }
323
324 /* calculate meta data/clusters for setting security and acl xattr */
325 status = ocfs2_calc_xattr_init(dir, parent_fe_bh, mode,
326 &si, &want_clusters,
327 &xattr_credits, &want_meta);
328 if (status < 0) {
329 mlog_errno(status);
330 goto leave;
331 }
332
333 /* Reserve a cluster if creating an extent based directory. */
334 if (S_ISDIR(mode) && !ocfs2_supports_inline_data(osb)) {
335 want_clusters += 1;
336
337 /* Dir indexing requires extra space as well */
338 if (ocfs2_supports_indexed_dirs(osb))
339 want_meta++;
340 }
341
342 status = ocfs2_reserve_new_metadata_blocks(osb, want_meta, &meta_ac);
343 if (status < 0) {
344 if (status != -ENOSPC)
345 mlog_errno(status);
346 goto leave;
347 }
348
349 status = ocfs2_reserve_clusters(osb, want_clusters, &data_ac);
350 if (status < 0) {
351 if (status != -ENOSPC)
352 mlog_errno(status);
353 goto leave;
354 }
355
356 handle = ocfs2_start_trans(osb, ocfs2_mknod_credits(osb->sb,
357 S_ISDIR(mode),
358 xattr_credits));
359 if (IS_ERR(handle)) {
360 status = PTR_ERR(handle);
361 handle = NULL;
362 mlog_errno(status);
363 goto leave;
364 }
365
366 /* Starting to change things, restart is no longer possible. */
367 ocfs2_block_signals(&oldset);
368 did_block_signals = 1;
369
370 status = dquot_alloc_inode(inode);
371 if (status)
372 goto leave;
373 did_quota_inode = 1;
374
375 /* do the real work now. */
376 status = ocfs2_mknod_locked(osb, dir, inode, dev,
377 &new_fe_bh, parent_fe_bh, handle,
378 inode_ac);
379 if (status < 0) {
380 mlog_errno(status);
381 goto leave;
382 }
383
384 if (S_ISDIR(mode)) {
385 status = ocfs2_fill_new_dir(osb, handle, dir, inode,
386 new_fe_bh, data_ac, meta_ac);
387 if (status < 0) {
388 mlog_errno(status);
389 goto leave;
390 }
391
392 status = ocfs2_journal_access_di(handle, INODE_CACHE(dir),
393 parent_fe_bh,
394 OCFS2_JOURNAL_ACCESS_WRITE);
395 if (status < 0) {
396 mlog_errno(status);
397 goto leave;
398 }
399 ocfs2_add_links_count(dirfe, 1);
400 ocfs2_journal_dirty(handle, parent_fe_bh);
401 inc_nlink(dir);
402 }
403
404 status = ocfs2_init_acl(handle, inode, dir, new_fe_bh, parent_fe_bh,
405 meta_ac, data_ac);
406
407 if (status < 0) {
408 mlog_errno(status);
409 goto roll_back;
410 }
411
412 if (si.enable) {
413 status = ocfs2_init_security_set(handle, inode, new_fe_bh, &si,
414 meta_ac, data_ac);
415 if (status < 0) {
416 mlog_errno(status);
417 goto roll_back;
418 }
419 }
420
421 /*
422 * Do this before adding the entry to the directory. We add
423 * also set d_op after success so that ->d_iput() will cleanup
424 * the dentry lock even if ocfs2_add_entry() fails below.
425 */
426 status = ocfs2_dentry_attach_lock(dentry, inode,
427 OCFS2_I(dir)->ip_blkno);
428 if (status) {
429 mlog_errno(status);
430 goto roll_back;
431 }
432
433 dl = dentry->d_fsdata;
434
435 status = ocfs2_add_entry(handle, dentry, inode,
436 OCFS2_I(inode)->ip_blkno, parent_fe_bh,
437 &lookup);
438 if (status < 0) {
439 mlog_errno(status);
440 goto roll_back;
441 }
442
443 insert_inode_hash(inode);
444 d_instantiate(dentry, inode);
445 status = 0;
446
447 roll_back:
448 if (status < 0 && S_ISDIR(mode)) {
449 ocfs2_add_links_count(dirfe, -1);
450 drop_nlink(dir);
451 }
452
453 leave:
454 if (status < 0 && did_quota_inode)
455 dquot_free_inode(inode);
456 if (handle)
457 ocfs2_commit_trans(osb, handle);
458
459 ocfs2_inode_unlock(dir, 1);
460 if (did_block_signals)
461 ocfs2_unblock_signals(&oldset);
462
463 brelse(new_fe_bh);
464 brelse(parent_fe_bh);
465 kfree(si.value);
466
467 ocfs2_free_dir_lookup_result(&lookup);
468
469 if (inode_ac)
470 ocfs2_free_alloc_context(inode_ac);
471
472 if (data_ac)
473 ocfs2_free_alloc_context(data_ac);
474
475 if (meta_ac)
476 ocfs2_free_alloc_context(meta_ac);
477
478 /*
479 * We should call iput after the i_mutex of the bitmap been
480 * unlocked in ocfs2_free_alloc_context, or the
481 * ocfs2_delete_inode will mutex_lock again.
482 */
483 if ((status < 0) && inode) {
484 if (dl)
485 ocfs2_cleanup_add_entry_failure(osb, dentry, inode);
486
487 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_SKIP_ORPHAN_DIR;
488 clear_nlink(inode);
489 iput(inode);
490 }
491
492 if (status)
493 mlog_errno(status);
494
495 return status;
496 }
497
498 static int __ocfs2_mknod_locked(struct inode *dir,
499 struct inode *inode,
500 dev_t dev,
501 struct buffer_head **new_fe_bh,
502 struct buffer_head *parent_fe_bh,
503 handle_t *handle,
504 struct ocfs2_alloc_context *inode_ac,
505 u64 fe_blkno, u64 suballoc_loc, u16 suballoc_bit)
506 {
507 int status = 0;
508 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
509 struct ocfs2_dinode *fe = NULL;
510 struct ocfs2_extent_list *fel;
511 u16 feat;
512 struct ocfs2_inode_info *oi = OCFS2_I(inode);
513 struct timespec64 ts;
514
515 *new_fe_bh = NULL;
516
517 /* populate as many fields early on as possible - many of
518 * these are used by the support functions here and in
519 * callers. */
520 inode->i_ino = ino_from_blkno(osb->sb, fe_blkno);
521 oi->ip_blkno = fe_blkno;
522 spin_lock(&osb->osb_lock);
523 inode->i_generation = osb->s_next_generation++;
524 spin_unlock(&osb->osb_lock);
525
526 *new_fe_bh = sb_getblk(osb->sb, fe_blkno);
527 if (!*new_fe_bh) {
528 status = -ENOMEM;
529 mlog_errno(status);
530 goto leave;
531 }
532 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode), *new_fe_bh);
533
534 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode),
535 *new_fe_bh,
536 OCFS2_JOURNAL_ACCESS_CREATE);
537 if (status < 0) {
538 mlog_errno(status);
539 goto leave;
540 }
541
542 fe = (struct ocfs2_dinode *) (*new_fe_bh)->b_data;
543 memset(fe, 0, osb->sb->s_blocksize);
544
545 fe->i_generation = cpu_to_le32(inode->i_generation);
546 fe->i_fs_generation = cpu_to_le32(osb->fs_generation);
547 fe->i_blkno = cpu_to_le64(fe_blkno);
548 fe->i_suballoc_loc = cpu_to_le64(suballoc_loc);
549 fe->i_suballoc_bit = cpu_to_le16(suballoc_bit);
550 fe->i_suballoc_slot = cpu_to_le16(inode_ac->ac_alloc_slot);
551 fe->i_uid = cpu_to_le32(i_uid_read(inode));
552 fe->i_gid = cpu_to_le32(i_gid_read(inode));
553 fe->i_mode = cpu_to_le16(inode->i_mode);
554 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
555 fe->id1.dev1.i_rdev = cpu_to_le64(huge_encode_dev(dev));
556
557 ocfs2_set_links_count(fe, inode->i_nlink);
558
559 fe->i_last_eb_blk = 0;
560 strcpy(fe->i_signature, OCFS2_INODE_SIGNATURE);
561 fe->i_flags |= cpu_to_le32(OCFS2_VALID_FL);
562 ktime_get_real_ts64(&ts);
563 fe->i_atime = fe->i_ctime = fe->i_mtime =
564 cpu_to_le64(ts.tv_sec);
565 fe->i_mtime_nsec = fe->i_ctime_nsec = fe->i_atime_nsec =
566 cpu_to_le32(ts.tv_nsec);
567 fe->i_dtime = 0;
568
569 /*
570 * If supported, directories start with inline data. If inline
571 * isn't supported, but indexing is, we start them as indexed.
572 */
573 feat = le16_to_cpu(fe->i_dyn_features);
574 if (S_ISDIR(inode->i_mode) && ocfs2_supports_inline_data(osb)) {
575 fe->i_dyn_features = cpu_to_le16(feat | OCFS2_INLINE_DATA_FL);
576
577 fe->id2.i_data.id_count = cpu_to_le16(
578 ocfs2_max_inline_data_with_xattr(osb->sb, fe));
579 } else {
580 fel = &fe->id2.i_list;
581 fel->l_tree_depth = 0;
582 fel->l_next_free_rec = 0;
583 fel->l_count = cpu_to_le16(ocfs2_extent_recs_per_inode(osb->sb));
584 }
585
586 ocfs2_journal_dirty(handle, *new_fe_bh);
587
588 ocfs2_populate_inode(inode, fe, 1);
589 ocfs2_ci_set_new(osb, INODE_CACHE(inode));
590 if (!ocfs2_mount_local(osb)) {
591 status = ocfs2_create_new_inode_locks(inode);
592 if (status < 0)
593 mlog_errno(status);
594 }
595
596 ocfs2_update_inode_fsync_trans(handle, inode, 1);
597
598 leave:
599 if (status < 0) {
600 if (*new_fe_bh) {
601 brelse(*new_fe_bh);
602 *new_fe_bh = NULL;
603 }
604 }
605
606 if (status)
607 mlog_errno(status);
608 return status;
609 }
610
611 static int ocfs2_mknod_locked(struct ocfs2_super *osb,
612 struct inode *dir,
613 struct inode *inode,
614 dev_t dev,
615 struct buffer_head **new_fe_bh,
616 struct buffer_head *parent_fe_bh,
617 handle_t *handle,
618 struct ocfs2_alloc_context *inode_ac)
619 {
620 int status = 0;
621 u64 suballoc_loc, fe_blkno = 0;
622 u16 suballoc_bit;
623
624 *new_fe_bh = NULL;
625
626 status = ocfs2_claim_new_inode(handle, dir, parent_fe_bh,
627 inode_ac, &suballoc_loc,
628 &suballoc_bit, &fe_blkno);
629 if (status < 0) {
630 mlog_errno(status);
631 return status;
632 }
633
634 status = __ocfs2_mknod_locked(dir, inode, dev, new_fe_bh,
635 parent_fe_bh, handle, inode_ac,
636 fe_blkno, suballoc_loc, suballoc_bit);
637 if (status < 0) {
638 u64 bg_blkno = ocfs2_which_suballoc_group(fe_blkno, suballoc_bit);
639 int tmp = ocfs2_free_suballoc_bits(handle, inode_ac->ac_inode,
640 inode_ac->ac_bh, suballoc_bit, bg_blkno, 1);
641 if (tmp)
642 mlog_errno(tmp);
643 }
644
645 return status;
646 }
647
648 static int ocfs2_mkdir(struct inode *dir,
649 struct dentry *dentry,
650 umode_t mode)
651 {
652 int ret;
653
654 trace_ocfs2_mkdir(dir, dentry, dentry->d_name.len, dentry->d_name.name,
655 OCFS2_I(dir)->ip_blkno, mode);
656 ret = ocfs2_mknod(dir, dentry, mode | S_IFDIR, 0);
657 if (ret)
658 mlog_errno(ret);
659
660 return ret;
661 }
662
663 static int ocfs2_create(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(dir, dentry, mode | S_IFREG, 0);
673 if (ret)
674 mlog_errno(ret);
675
676 return ret;
677 }
678
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 */
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
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
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
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(ML_NOTICE, "max lookup times reached, filesystem "
1092 "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 */
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
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
1198 static int ocfs2_rename(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 */
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
1787 static int ocfs2_symlink(struct inode *dir,
1788 struct dentry *dentry,
1789 const char *symname)
1790 {
1791 int status, l, credits;
1792 u64 newsize;
1793 struct ocfs2_super *osb = NULL;
1794 struct inode *inode = NULL;
1795 struct super_block *sb;
1796 struct buffer_head *new_fe_bh = NULL;
1797 struct buffer_head *parent_fe_bh = NULL;
1798 struct ocfs2_dinode *fe = NULL;
1799 struct ocfs2_dinode *dirfe;
1800 handle_t *handle = NULL;
1801 struct ocfs2_alloc_context *inode_ac = NULL;
1802 struct ocfs2_alloc_context *data_ac = NULL;
1803 struct ocfs2_alloc_context *xattr_ac = NULL;
1804 int want_clusters = 0;
1805 int xattr_credits = 0;
1806 struct ocfs2_security_xattr_info si = {
1807 .enable = 1,
1808 };
1809 int did_quota = 0, did_quota_inode = 0;
1810 struct ocfs2_dir_lookup_result lookup = { NULL, };
1811 sigset_t oldset;
1812 int did_block_signals = 0;
1813 struct ocfs2_dentry_lock *dl = NULL;
1814
1815 trace_ocfs2_symlink_begin(dir, dentry, symname,
1816 dentry->d_name.len, dentry->d_name.name);
1817
1818 status = dquot_initialize(dir);
1819 if (status) {
1820 mlog_errno(status);
1821 goto bail;
1822 }
1823
1824 sb = dir->i_sb;
1825 osb = OCFS2_SB(sb);
1826
1827 l = strlen(symname) + 1;
1828
1829 credits = ocfs2_calc_symlink_credits(sb);
1830
1831 /* lock the parent directory */
1832 status = ocfs2_inode_lock(dir, &parent_fe_bh, 1);
1833 if (status < 0) {
1834 if (status != -ENOENT)
1835 mlog_errno(status);
1836 return status;
1837 }
1838
1839 dirfe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
1840 if (!ocfs2_read_links_count(dirfe)) {
1841 /* can't make a file in a deleted directory. */
1842 status = -ENOENT;
1843 goto bail;
1844 }
1845
1846 status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
1847 dentry->d_name.len);
1848 if (status)
1849 goto bail;
1850
1851 status = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
1852 dentry->d_name.name,
1853 dentry->d_name.len, &lookup);
1854 if (status < 0) {
1855 mlog_errno(status);
1856 goto bail;
1857 }
1858
1859 status = ocfs2_reserve_new_inode(osb, &inode_ac);
1860 if (status < 0) {
1861 if (status != -ENOSPC)
1862 mlog_errno(status);
1863 goto bail;
1864 }
1865
1866 inode = ocfs2_get_init_inode(dir, S_IFLNK | S_IRWXUGO);
1867 if (IS_ERR(inode)) {
1868 status = PTR_ERR(inode);
1869 inode = NULL;
1870 mlog_errno(status);
1871 goto bail;
1872 }
1873
1874 /* get security xattr */
1875 status = ocfs2_init_security_get(inode, dir, &dentry->d_name, &si);
1876 if (status) {
1877 if (status == -EOPNOTSUPP)
1878 si.enable = 0;
1879 else {
1880 mlog_errno(status);
1881 goto bail;
1882 }
1883 }
1884
1885 /* calculate meta data/clusters for setting security xattr */
1886 if (si.enable) {
1887 status = ocfs2_calc_security_init(dir, &si, &want_clusters,
1888 &xattr_credits, &xattr_ac);
1889 if (status < 0) {
1890 mlog_errno(status);
1891 goto bail;
1892 }
1893 }
1894
1895 /* don't reserve bitmap space for fast symlinks. */
1896 if (l > ocfs2_fast_symlink_chars(sb))
1897 want_clusters += 1;
1898
1899 status = ocfs2_reserve_clusters(osb, want_clusters, &data_ac);
1900 if (status < 0) {
1901 if (status != -ENOSPC)
1902 mlog_errno(status);
1903 goto bail;
1904 }
1905
1906 handle = ocfs2_start_trans(osb, credits + xattr_credits);
1907 if (IS_ERR(handle)) {
1908 status = PTR_ERR(handle);
1909 handle = NULL;
1910 mlog_errno(status);
1911 goto bail;
1912 }
1913
1914 /* Starting to change things, restart is no longer possible. */
1915 ocfs2_block_signals(&oldset);
1916 did_block_signals = 1;
1917
1918 status = dquot_alloc_inode(inode);
1919 if (status)
1920 goto bail;
1921 did_quota_inode = 1;
1922
1923 trace_ocfs2_symlink_create(dir, dentry, dentry->d_name.len,
1924 dentry->d_name.name,
1925 (unsigned long long)OCFS2_I(dir)->ip_blkno,
1926 inode->i_mode);
1927
1928 status = ocfs2_mknod_locked(osb, dir, inode,
1929 0, &new_fe_bh, parent_fe_bh, handle,
1930 inode_ac);
1931 if (status < 0) {
1932 mlog_errno(status);
1933 goto bail;
1934 }
1935
1936 fe = (struct ocfs2_dinode *) new_fe_bh->b_data;
1937 inode->i_rdev = 0;
1938 newsize = l - 1;
1939 inode->i_op = &ocfs2_symlink_inode_operations;
1940 inode_nohighmem(inode);
1941 if (l > ocfs2_fast_symlink_chars(sb)) {
1942 u32 offset = 0;
1943
1944 status = dquot_alloc_space_nodirty(inode,
1945 ocfs2_clusters_to_bytes(osb->sb, 1));
1946 if (status)
1947 goto bail;
1948 did_quota = 1;
1949 inode->i_mapping->a_ops = &ocfs2_aops;
1950 status = ocfs2_add_inode_data(osb, inode, &offset, 1, 0,
1951 new_fe_bh,
1952 handle, data_ac, NULL,
1953 NULL);
1954 if (status < 0) {
1955 if (status != -ENOSPC && status != -EINTR) {
1956 mlog(ML_ERROR,
1957 "Failed to extend file to %llu\n",
1958 (unsigned long long)newsize);
1959 mlog_errno(status);
1960 status = -ENOSPC;
1961 }
1962 goto bail;
1963 }
1964 i_size_write(inode, newsize);
1965 inode->i_blocks = ocfs2_inode_sector_count(inode);
1966 } else {
1967 inode->i_mapping->a_ops = &ocfs2_fast_symlink_aops;
1968 memcpy((char *) fe->id2.i_symlink, symname, l);
1969 i_size_write(inode, newsize);
1970 inode->i_blocks = 0;
1971 }
1972
1973 status = ocfs2_mark_inode_dirty(handle, inode, new_fe_bh);
1974 if (status < 0) {
1975 mlog_errno(status);
1976 goto bail;
1977 }
1978
1979 if (!ocfs2_inode_is_fast_symlink(inode)) {
1980 status = ocfs2_create_symlink_data(osb, handle, inode,
1981 symname);
1982 if (status < 0) {
1983 mlog_errno(status);
1984 goto bail;
1985 }
1986 }
1987
1988 if (si.enable) {
1989 status = ocfs2_init_security_set(handle, inode, new_fe_bh, &si,
1990 xattr_ac, data_ac);
1991 if (status < 0) {
1992 mlog_errno(status);
1993 goto bail;
1994 }
1995 }
1996
1997 /*
1998 * Do this before adding the entry to the directory. We add
1999 * also set d_op after success so that ->d_iput() will cleanup
2000 * the dentry lock even if ocfs2_add_entry() fails below.
2001 */
2002 status = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(dir)->ip_blkno);
2003 if (status) {
2004 mlog_errno(status);
2005 goto bail;
2006 }
2007
2008 dl = dentry->d_fsdata;
2009
2010 status = ocfs2_add_entry(handle, dentry, inode,
2011 le64_to_cpu(fe->i_blkno), parent_fe_bh,
2012 &lookup);
2013 if (status < 0) {
2014 mlog_errno(status);
2015 goto bail;
2016 }
2017
2018 insert_inode_hash(inode);
2019 d_instantiate(dentry, inode);
2020 bail:
2021 if (status < 0 && did_quota)
2022 dquot_free_space_nodirty(inode,
2023 ocfs2_clusters_to_bytes(osb->sb, 1));
2024 if (status < 0 && did_quota_inode)
2025 dquot_free_inode(inode);
2026 if (handle)
2027 ocfs2_commit_trans(osb, handle);
2028
2029 ocfs2_inode_unlock(dir, 1);
2030 if (did_block_signals)
2031 ocfs2_unblock_signals(&oldset);
2032
2033 brelse(new_fe_bh);
2034 brelse(parent_fe_bh);
2035 kfree(si.value);
2036 ocfs2_free_dir_lookup_result(&lookup);
2037 if (inode_ac)
2038 ocfs2_free_alloc_context(inode_ac);
2039 if (data_ac)
2040 ocfs2_free_alloc_context(data_ac);
2041 if (xattr_ac)
2042 ocfs2_free_alloc_context(xattr_ac);
2043 if ((status < 0) && inode) {
2044 if (dl)
2045 ocfs2_cleanup_add_entry_failure(osb, dentry, inode);
2046
2047 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_SKIP_ORPHAN_DIR;
2048 clear_nlink(inode);
2049 iput(inode);
2050 }
2051
2052 if (status)
2053 mlog_errno(status);
2054
2055 return status;
2056 }
2057
2058 static int ocfs2_blkno_stringify(u64 blkno, char *name)
2059 {
2060 int status, namelen;
2061
2062 namelen = snprintf(name, OCFS2_ORPHAN_NAMELEN + 1, "%016llx",
2063 (long long)blkno);
2064 if (namelen <= 0) {
2065 if (namelen)
2066 status = namelen;
2067 else
2068 status = -EINVAL;
2069 mlog_errno(status);
2070 goto bail;
2071 }
2072 if (namelen != OCFS2_ORPHAN_NAMELEN) {
2073 status = -EINVAL;
2074 mlog_errno(status);
2075 goto bail;
2076 }
2077
2078 trace_ocfs2_blkno_stringify(blkno, name, namelen);
2079
2080 status = 0;
2081 bail:
2082 if (status < 0)
2083 mlog_errno(status);
2084 return status;
2085 }
2086
2087 static int ocfs2_lookup_lock_orphan_dir(struct ocfs2_super *osb,
2088 struct inode **ret_orphan_dir,
2089 struct buffer_head **ret_orphan_dir_bh)
2090 {
2091 struct inode *orphan_dir_inode;
2092 struct buffer_head *orphan_dir_bh = NULL;
2093 int ret = 0;
2094
2095 orphan_dir_inode = ocfs2_get_system_file_inode(osb,
2096 ORPHAN_DIR_SYSTEM_INODE,
2097 osb->slot_num);
2098 if (!orphan_dir_inode) {
2099 ret = -ENOENT;
2100 mlog_errno(ret);
2101 return ret;
2102 }
2103
2104 inode_lock(orphan_dir_inode);
2105
2106 ret = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1);
2107 if (ret < 0) {
2108 inode_unlock(orphan_dir_inode);
2109 iput(orphan_dir_inode);
2110
2111 mlog_errno(ret);
2112 return ret;
2113 }
2114
2115 *ret_orphan_dir = orphan_dir_inode;
2116 *ret_orphan_dir_bh = orphan_dir_bh;
2117
2118 return 0;
2119 }
2120
2121 static int __ocfs2_prepare_orphan_dir(struct inode *orphan_dir_inode,
2122 struct buffer_head *orphan_dir_bh,
2123 u64 blkno,
2124 char *name,
2125 struct ocfs2_dir_lookup_result *lookup,
2126 bool dio)
2127 {
2128 int ret;
2129 struct ocfs2_super *osb = OCFS2_SB(orphan_dir_inode->i_sb);
2130 int namelen = dio ?
2131 (OCFS2_DIO_ORPHAN_PREFIX_LEN + OCFS2_ORPHAN_NAMELEN) :
2132 OCFS2_ORPHAN_NAMELEN;
2133
2134 if (dio) {
2135 ret = snprintf(name, OCFS2_DIO_ORPHAN_PREFIX_LEN + 1, "%s",
2136 OCFS2_DIO_ORPHAN_PREFIX);
2137 if (ret != OCFS2_DIO_ORPHAN_PREFIX_LEN) {
2138 ret = -EINVAL;
2139 mlog_errno(ret);
2140 return ret;
2141 }
2142
2143 ret = ocfs2_blkno_stringify(blkno,
2144 name + OCFS2_DIO_ORPHAN_PREFIX_LEN);
2145 } else
2146 ret = ocfs2_blkno_stringify(blkno, name);
2147 if (ret < 0) {
2148 mlog_errno(ret);
2149 return ret;
2150 }
2151
2152 ret = ocfs2_prepare_dir_for_insert(osb, orphan_dir_inode,
2153 orphan_dir_bh, name,
2154 namelen, lookup);
2155 if (ret < 0) {
2156 mlog_errno(ret);
2157 return ret;
2158 }
2159
2160 return 0;
2161 }
2162
2163 /**
2164 * ocfs2_prepare_orphan_dir() - Prepare an orphan directory for
2165 * insertion of an orphan.
2166 * @osb: ocfs2 file system
2167 * @ret_orphan_dir: Orphan dir inode - returned locked!
2168 * @blkno: Actual block number of the inode to be inserted into orphan dir.
2169 * @lookup: dir lookup result, to be passed back into functions like
2170 * ocfs2_orphan_add
2171 *
2172 * Returns zero on success and the ret_orphan_dir, name and lookup
2173 * fields will be populated.
2174 *
2175 * Returns non-zero on failure.
2176 */
2177 static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb,
2178 struct inode **ret_orphan_dir,
2179 u64 blkno,
2180 char *name,
2181 struct ocfs2_dir_lookup_result *lookup,
2182 bool dio)
2183 {
2184 struct inode *orphan_dir_inode = NULL;
2185 struct buffer_head *orphan_dir_bh = NULL;
2186 int ret = 0;
2187
2188 ret = ocfs2_lookup_lock_orphan_dir(osb, &orphan_dir_inode,
2189 &orphan_dir_bh);
2190 if (ret < 0) {
2191 mlog_errno(ret);
2192 return ret;
2193 }
2194
2195 ret = __ocfs2_prepare_orphan_dir(orphan_dir_inode, orphan_dir_bh,
2196 blkno, name, lookup, dio);
2197 if (ret < 0) {
2198 mlog_errno(ret);
2199 goto out;
2200 }
2201
2202 *ret_orphan_dir = orphan_dir_inode;
2203
2204 out:
2205 brelse(orphan_dir_bh);
2206
2207 if (ret) {
2208 ocfs2_inode_unlock(orphan_dir_inode, 1);
2209 inode_unlock(orphan_dir_inode);
2210 iput(orphan_dir_inode);
2211 }
2212
2213 if (ret)
2214 mlog_errno(ret);
2215 return ret;
2216 }
2217
2218 static int ocfs2_orphan_add(struct ocfs2_super *osb,
2219 handle_t *handle,
2220 struct inode *inode,
2221 struct buffer_head *fe_bh,
2222 char *name,
2223 struct ocfs2_dir_lookup_result *lookup,
2224 struct inode *orphan_dir_inode,
2225 bool dio)
2226 {
2227 struct buffer_head *orphan_dir_bh = NULL;
2228 int status = 0;
2229 struct ocfs2_dinode *orphan_fe;
2230 struct ocfs2_dinode *fe = (struct ocfs2_dinode *) fe_bh->b_data;
2231 int namelen = dio ?
2232 (OCFS2_DIO_ORPHAN_PREFIX_LEN + OCFS2_ORPHAN_NAMELEN) :
2233 OCFS2_ORPHAN_NAMELEN;
2234
2235 trace_ocfs2_orphan_add_begin(
2236 (unsigned long long)OCFS2_I(inode)->ip_blkno);
2237
2238 status = ocfs2_read_inode_block(orphan_dir_inode, &orphan_dir_bh);
2239 if (status < 0) {
2240 mlog_errno(status);
2241 goto leave;
2242 }
2243
2244 status = ocfs2_journal_access_di(handle,
2245 INODE_CACHE(orphan_dir_inode),
2246 orphan_dir_bh,
2247 OCFS2_JOURNAL_ACCESS_WRITE);
2248 if (status < 0) {
2249 mlog_errno(status);
2250 goto leave;
2251 }
2252
2253 /*
2254 * We're going to journal the change of i_flags and i_orphaned_slot.
2255 * It's safe anyway, though some callers may duplicate the journaling.
2256 * Journaling within the func just make the logic look more
2257 * straightforward.
2258 */
2259 status = ocfs2_journal_access_di(handle,
2260 INODE_CACHE(inode),
2261 fe_bh,
2262 OCFS2_JOURNAL_ACCESS_WRITE);
2263 if (status < 0) {
2264 mlog_errno(status);
2265 goto leave;
2266 }
2267
2268 /* we're a cluster, and nlink can change on disk from
2269 * underneath us... */
2270 orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data;
2271 if (S_ISDIR(inode->i_mode))
2272 ocfs2_add_links_count(orphan_fe, 1);
2273 set_nlink(orphan_dir_inode, ocfs2_read_links_count(orphan_fe));
2274 ocfs2_journal_dirty(handle, orphan_dir_bh);
2275
2276 status = __ocfs2_add_entry(handle, orphan_dir_inode, name,
2277 namelen, inode,
2278 OCFS2_I(inode)->ip_blkno,
2279 orphan_dir_bh, lookup);
2280 if (status < 0) {
2281 mlog_errno(status);
2282 goto rollback;
2283 }
2284
2285 if (dio) {
2286 /* Update flag OCFS2_DIO_ORPHANED_FL and record the orphan
2287 * slot.
2288 */
2289 fe->i_flags |= cpu_to_le32(OCFS2_DIO_ORPHANED_FL);
2290 fe->i_dio_orphaned_slot = cpu_to_le16(osb->slot_num);
2291 } else {
2292 fe->i_flags |= cpu_to_le32(OCFS2_ORPHANED_FL);
2293 OCFS2_I(inode)->ip_flags &= ~OCFS2_INODE_SKIP_ORPHAN_DIR;
2294
2295 /* Record which orphan dir our inode now resides
2296 * in. delete_inode will use this to determine which orphan
2297 * dir to lock. */
2298 fe->i_orphaned_slot = cpu_to_le16(osb->slot_num);
2299 }
2300
2301 ocfs2_journal_dirty(handle, fe_bh);
2302
2303 trace_ocfs2_orphan_add_end((unsigned long long)OCFS2_I(inode)->ip_blkno,
2304 osb->slot_num);
2305
2306 rollback:
2307 if (status < 0) {
2308 if (S_ISDIR(inode->i_mode))
2309 ocfs2_add_links_count(orphan_fe, -1);
2310 set_nlink(orphan_dir_inode, ocfs2_read_links_count(orphan_fe));
2311 }
2312
2313 leave:
2314 brelse(orphan_dir_bh);
2315
2316 return status;
2317 }
2318
2319 /* unlike orphan_add, we expect the orphan dir to already be locked here. */
2320 int ocfs2_orphan_del(struct ocfs2_super *osb,
2321 handle_t *handle,
2322 struct inode *orphan_dir_inode,
2323 struct inode *inode,
2324 struct buffer_head *orphan_dir_bh,
2325 bool dio)
2326 {
2327 char name[OCFS2_DIO_ORPHAN_PREFIX_LEN + OCFS2_ORPHAN_NAMELEN + 1];
2328 struct ocfs2_dinode *orphan_fe;
2329 int status = 0;
2330 struct ocfs2_dir_lookup_result lookup = { NULL, };
2331
2332 if (dio) {
2333 status = snprintf(name, OCFS2_DIO_ORPHAN_PREFIX_LEN + 1, "%s",
2334 OCFS2_DIO_ORPHAN_PREFIX);
2335 if (status != OCFS2_DIO_ORPHAN_PREFIX_LEN) {
2336 status = -EINVAL;
2337 mlog_errno(status);
2338 return status;
2339 }
2340
2341 status = ocfs2_blkno_stringify(OCFS2_I(inode)->ip_blkno,
2342 name + OCFS2_DIO_ORPHAN_PREFIX_LEN);
2343 } else
2344 status = ocfs2_blkno_stringify(OCFS2_I(inode)->ip_blkno, name);
2345 if (status < 0) {
2346 mlog_errno(status);
2347 goto leave;
2348 }
2349
2350 trace_ocfs2_orphan_del(
2351 (unsigned long long)OCFS2_I(orphan_dir_inode)->ip_blkno,
2352 name, strlen(name));
2353
2354 status = ocfs2_journal_access_di(handle,
2355 INODE_CACHE(orphan_dir_inode),
2356 orphan_dir_bh,
2357 OCFS2_JOURNAL_ACCESS_WRITE);
2358 if (status < 0) {
2359 mlog_errno(status);
2360 goto leave;
2361 }
2362
2363 /* find it's spot in the orphan directory */
2364 status = ocfs2_find_entry(name, strlen(name), orphan_dir_inode,
2365 &lookup);
2366 if (status) {
2367 mlog_errno(status);
2368 goto leave;
2369 }
2370
2371 /* remove it from the orphan directory */
2372 status = ocfs2_delete_entry(handle, orphan_dir_inode, &lookup);
2373 if (status < 0) {
2374 mlog_errno(status);
2375 goto leave;
2376 }
2377
2378 /* do the i_nlink dance! :) */
2379 orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data;
2380 if (S_ISDIR(inode->i_mode))
2381 ocfs2_add_links_count(orphan_fe, -1);
2382 set_nlink(orphan_dir_inode, ocfs2_read_links_count(orphan_fe));
2383 ocfs2_journal_dirty(handle, orphan_dir_bh);
2384
2385 leave:
2386 ocfs2_free_dir_lookup_result(&lookup);
2387
2388 if (status)
2389 mlog_errno(status);
2390 return status;
2391 }
2392
2393 /**
2394 * ocfs2_prep_new_orphaned_file() - Prepare the orphan dir to receive a newly
2395 * allocated file. This is different from the typical 'add to orphan dir'
2396 * operation in that the inode does not yet exist. This is a problem because
2397 * the orphan dir stringifies the inode block number to come up with it's
2398 * dirent. Obviously if the inode does not yet exist we have a chicken and egg
2399 * problem. This function works around it by calling deeper into the orphan
2400 * and suballoc code than other callers. Use this only by necessity.
2401 * @dir: The directory which this inode will ultimately wind up under - not the
2402 * orphan dir!
2403 * @dir_bh: buffer_head the @dir inode block
2404 * @orphan_name: string of length (CFS2_ORPHAN_NAMELEN + 1). Will be filled
2405 * with the string to be used for orphan dirent. Pass back to the orphan dir
2406 * code.
2407 * @ret_orphan_dir: orphan dir inode returned to be passed back into orphan
2408 * dir code.
2409 * @ret_di_blkno: block number where the new inode will be allocated.
2410 * @orphan_insert: Dir insert context to be passed back into orphan dir code.
2411 * @ret_inode_ac: Inode alloc context to be passed back to the allocator.
2412 *
2413 * Returns zero on success and the ret_orphan_dir, name and lookup
2414 * fields will be populated.
2415 *
2416 * Returns non-zero on failure.
2417 */
2418 static int ocfs2_prep_new_orphaned_file(struct inode *dir,
2419 struct buffer_head *dir_bh,
2420 char *orphan_name,
2421 struct inode **ret_orphan_dir,
2422 u64 *ret_di_blkno,
2423 struct ocfs2_dir_lookup_result *orphan_insert,
2424 struct ocfs2_alloc_context **ret_inode_ac)
2425 {
2426 int ret;
2427 u64 di_blkno;
2428 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
2429 struct inode *orphan_dir = NULL;
2430 struct buffer_head *orphan_dir_bh = NULL;
2431 struct ocfs2_alloc_context *inode_ac = NULL;
2432
2433 ret = ocfs2_lookup_lock_orphan_dir(osb, &orphan_dir, &orphan_dir_bh);
2434 if (ret < 0) {
2435 mlog_errno(ret);
2436 return ret;
2437 }
2438
2439 /* reserve an inode spot */
2440 ret = ocfs2_reserve_new_inode(osb, &inode_ac);
2441 if (ret < 0) {
2442 if (ret != -ENOSPC)
2443 mlog_errno(ret);
2444 goto out;
2445 }
2446
2447 ret = ocfs2_find_new_inode_loc(dir, dir_bh, inode_ac,
2448 &di_blkno);
2449 if (ret) {
2450 mlog_errno(ret);
2451 goto out;
2452 }
2453
2454 ret = __ocfs2_prepare_orphan_dir(orphan_dir, orphan_dir_bh,
2455 di_blkno, orphan_name, orphan_insert,
2456 false);
2457 if (ret < 0) {
2458 mlog_errno(ret);
2459 goto out;
2460 }
2461
2462 out:
2463 if (ret == 0) {
2464 *ret_orphan_dir = orphan_dir;
2465 *ret_di_blkno = di_blkno;
2466 *ret_inode_ac = inode_ac;
2467 /*
2468 * orphan_name and orphan_insert are already up to
2469 * date via prepare_orphan_dir
2470 */
2471 } else {
2472 /* Unroll reserve_new_inode* */
2473 if (inode_ac)
2474 ocfs2_free_alloc_context(inode_ac);
2475
2476 /* Unroll orphan dir locking */
2477 inode_unlock(orphan_dir);
2478 ocfs2_inode_unlock(orphan_dir, 1);
2479 iput(orphan_dir);
2480 }
2481
2482 brelse(orphan_dir_bh);
2483
2484 return ret;
2485 }
2486
2487 int ocfs2_create_inode_in_orphan(struct inode *dir,
2488 int mode,
2489 struct inode **new_inode)
2490 {
2491 int status, did_quota_inode = 0;
2492 struct inode *inode = NULL;
2493 struct inode *orphan_dir = NULL;
2494 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
2495 handle_t *handle = NULL;
2496 char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
2497 struct buffer_head *parent_di_bh = NULL;
2498 struct buffer_head *new_di_bh = NULL;
2499 struct ocfs2_alloc_context *inode_ac = NULL;
2500 struct ocfs2_dir_lookup_result orphan_insert = { NULL, };
2501 u64 di_blkno, suballoc_loc;
2502 u16 suballoc_bit;
2503
2504 status = ocfs2_inode_lock(dir, &parent_di_bh, 1);
2505 if (status < 0) {
2506 if (status != -ENOENT)
2507 mlog_errno(status);
2508 return status;
2509 }
2510
2511 status = ocfs2_prep_new_orphaned_file(dir, parent_di_bh,
2512 orphan_name, &orphan_dir,
2513 &di_blkno, &orphan_insert, &inode_ac);
2514 if (status < 0) {
2515 if (status != -ENOSPC)
2516 mlog_errno(status);
2517 goto leave;
2518 }
2519
2520 inode = ocfs2_get_init_inode(dir, mode);
2521 if (IS_ERR(inode)) {
2522 status = PTR_ERR(inode);
2523 inode = NULL;
2524 mlog_errno(status);
2525 goto leave;
2526 }
2527
2528 handle = ocfs2_start_trans(osb, ocfs2_mknod_credits(osb->sb, 0, 0));
2529 if (IS_ERR(handle)) {
2530 status = PTR_ERR(handle);
2531 handle = NULL;
2532 mlog_errno(status);
2533 goto leave;
2534 }
2535
2536 status = dquot_alloc_inode(inode);
2537 if (status)
2538 goto leave;
2539 did_quota_inode = 1;
2540
2541 status = ocfs2_claim_new_inode_at_loc(handle, dir, inode_ac,
2542 &suballoc_loc,
2543 &suballoc_bit, di_blkno);
2544 if (status < 0) {
2545 mlog_errno(status);
2546 goto leave;
2547 }
2548
2549 clear_nlink(inode);
2550 /* do the real work now. */
2551 status = __ocfs2_mknod_locked(dir, inode,
2552 0, &new_di_bh, parent_di_bh, handle,
2553 inode_ac, di_blkno, suballoc_loc,
2554 suballoc_bit);
2555 if (status < 0) {
2556 mlog_errno(status);
2557 goto leave;
2558 }
2559
2560 status = ocfs2_orphan_add(osb, handle, inode, new_di_bh, orphan_name,
2561 &orphan_insert, orphan_dir, false);
2562 if (status < 0) {
2563 mlog_errno(status);
2564 goto leave;
2565 }
2566
2567 /* get open lock so that only nodes can't remove it from orphan dir. */
2568 status = ocfs2_open_lock(inode);
2569 if (status < 0)
2570 mlog_errno(status);
2571
2572 insert_inode_hash(inode);
2573 leave:
2574 if (status < 0 && did_quota_inode)
2575 dquot_free_inode(inode);
2576 if (handle)
2577 ocfs2_commit_trans(osb, handle);
2578
2579 if (orphan_dir) {
2580 /* This was locked for us in ocfs2_prepare_orphan_dir() */
2581 ocfs2_inode_unlock(orphan_dir, 1);
2582 inode_unlock(orphan_dir);
2583 iput(orphan_dir);
2584 }
2585
2586 if ((status < 0) && inode) {
2587 clear_nlink(inode);
2588 iput(inode);
2589 }
2590
2591 if (inode_ac)
2592 ocfs2_free_alloc_context(inode_ac);
2593
2594 brelse(new_di_bh);
2595
2596 if (!status)
2597 *new_inode = inode;
2598
2599 ocfs2_free_dir_lookup_result(&orphan_insert);
2600
2601 ocfs2_inode_unlock(dir, 1);
2602 brelse(parent_di_bh);
2603 return status;
2604 }
2605
2606 int ocfs2_add_inode_to_orphan(struct ocfs2_super *osb,
2607 struct inode *inode)
2608 {
2609 char orphan_name[OCFS2_DIO_ORPHAN_PREFIX_LEN + OCFS2_ORPHAN_NAMELEN + 1];
2610 struct inode *orphan_dir_inode = NULL;
2611 struct ocfs2_dir_lookup_result orphan_insert = { NULL, };
2612 struct buffer_head *di_bh = NULL;
2613 int status = 0;
2614 handle_t *handle = NULL;
2615 struct ocfs2_dinode *di = NULL;
2616
2617 status = ocfs2_inode_lock(inode, &di_bh, 1);
2618 if (status < 0) {
2619 mlog_errno(status);
2620 goto bail;
2621 }
2622
2623 di = (struct ocfs2_dinode *) di_bh->b_data;
2624 /*
2625 * Another append dio crashed?
2626 * If so, manually recover it first.
2627 */
2628 if (unlikely(di->i_flags & cpu_to_le32(OCFS2_DIO_ORPHANED_FL))) {
2629 status = ocfs2_truncate_file(inode, di_bh, i_size_read(inode));
2630 if (status < 0) {
2631 if (status != -ENOSPC)
2632 mlog_errno(status);
2633 goto bail_unlock_inode;
2634 }
2635
2636 status = ocfs2_del_inode_from_orphan(osb, inode, di_bh, 0, 0);
2637 if (status < 0) {
2638 mlog_errno(status);
2639 goto bail_unlock_inode;
2640 }
2641 }
2642
2643 status = ocfs2_prepare_orphan_dir(osb, &orphan_dir_inode,
2644 OCFS2_I(inode)->ip_blkno,
2645 orphan_name,
2646 &orphan_insert,
2647 true);
2648 if (status < 0) {
2649 mlog_errno(status);
2650 goto bail_unlock_inode;
2651 }
2652
2653 handle = ocfs2_start_trans(osb,
2654 OCFS2_INODE_ADD_TO_ORPHAN_CREDITS);
2655 if (IS_ERR(handle)) {
2656 status = PTR_ERR(handle);
2657 goto bail_unlock_orphan;
2658 }
2659
2660 status = ocfs2_orphan_add(osb, handle, inode, di_bh, orphan_name,
2661 &orphan_insert, orphan_dir_inode, true);
2662 if (status)
2663 mlog_errno(status);
2664
2665 ocfs2_commit_trans(osb, handle);
2666
2667 bail_unlock_orphan:
2668 ocfs2_inode_unlock(orphan_dir_inode, 1);
2669 inode_unlock(orphan_dir_inode);
2670 iput(orphan_dir_inode);
2671
2672 ocfs2_free_dir_lookup_result(&orphan_insert);
2673
2674 bail_unlock_inode:
2675 ocfs2_inode_unlock(inode, 1);
2676 brelse(di_bh);
2677
2678 bail:
2679 return status;
2680 }
2681
2682 int ocfs2_del_inode_from_orphan(struct ocfs2_super *osb,
2683 struct inode *inode, struct buffer_head *di_bh,
2684 int update_isize, loff_t end)
2685 {
2686 struct inode *orphan_dir_inode = NULL;
2687 struct buffer_head *orphan_dir_bh = NULL;
2688 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
2689 handle_t *handle = NULL;
2690 int status = 0;
2691
2692 orphan_dir_inode = ocfs2_get_system_file_inode(osb,
2693 ORPHAN_DIR_SYSTEM_INODE,
2694 le16_to_cpu(di->i_dio_orphaned_slot));
2695 if (!orphan_dir_inode) {
2696 status = -ENOENT;
2697 mlog_errno(status);
2698 goto bail;
2699 }
2700
2701 inode_lock(orphan_dir_inode);
2702 status = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1);
2703 if (status < 0) {
2704 inode_unlock(orphan_dir_inode);
2705 iput(orphan_dir_inode);
2706 mlog_errno(status);
2707 goto bail;
2708 }
2709
2710 handle = ocfs2_start_trans(osb,
2711 OCFS2_INODE_DEL_FROM_ORPHAN_CREDITS);
2712 if (IS_ERR(handle)) {
2713 status = PTR_ERR(handle);
2714 goto bail_unlock_orphan;
2715 }
2716
2717 BUG_ON(!(di->i_flags & cpu_to_le32(OCFS2_DIO_ORPHANED_FL)));
2718
2719 status = ocfs2_orphan_del(osb, handle, orphan_dir_inode,
2720 inode, orphan_dir_bh, true);
2721 if (status < 0) {
2722 mlog_errno(status);
2723 goto bail_commit;
2724 }
2725
2726 status = ocfs2_journal_access_di(handle,
2727 INODE_CACHE(inode),
2728 di_bh,
2729 OCFS2_JOURNAL_ACCESS_WRITE);
2730 if (status < 0) {
2731 mlog_errno(status);
2732 goto bail_commit;
2733 }
2734
2735 di->i_flags &= ~cpu_to_le32(OCFS2_DIO_ORPHANED_FL);
2736 di->i_dio_orphaned_slot = 0;
2737
2738 if (update_isize) {
2739 status = ocfs2_set_inode_size(handle, inode, di_bh, end);
2740 if (status)
2741 mlog_errno(status);
2742 } else
2743 ocfs2_journal_dirty(handle, di_bh);
2744
2745 bail_commit:
2746 ocfs2_commit_trans(osb, handle);
2747
2748 bail_unlock_orphan:
2749 ocfs2_inode_unlock(orphan_dir_inode, 1);
2750 inode_unlock(orphan_dir_inode);
2751 brelse(orphan_dir_bh);
2752 iput(orphan_dir_inode);
2753
2754 bail:
2755 return status;
2756 }
2757
2758 int ocfs2_mv_orphaned_inode_to_new(struct inode *dir,
2759 struct inode *inode,
2760 struct dentry *dentry)
2761 {
2762 int status = 0;
2763 struct buffer_head *parent_di_bh = NULL;
2764 handle_t *handle = NULL;
2765 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
2766 struct ocfs2_dinode *dir_di, *di;
2767 struct inode *orphan_dir_inode = NULL;
2768 struct buffer_head *orphan_dir_bh = NULL;
2769 struct buffer_head *di_bh = NULL;
2770 struct ocfs2_dir_lookup_result lookup = { NULL, };
2771
2772 trace_ocfs2_mv_orphaned_inode_to_new(dir, dentry,
2773 dentry->d_name.len, dentry->d_name.name,
2774 (unsigned long long)OCFS2_I(dir)->ip_blkno,
2775 (unsigned long long)OCFS2_I(inode)->ip_blkno);
2776
2777 status = ocfs2_inode_lock(dir, &parent_di_bh, 1);
2778 if (status < 0) {
2779 if (status != -ENOENT)
2780 mlog_errno(status);
2781 return status;
2782 }
2783
2784 dir_di = (struct ocfs2_dinode *) parent_di_bh->b_data;
2785 if (!dir_di->i_links_count) {
2786 /* can't make a file in a deleted directory. */
2787 status = -ENOENT;
2788 goto leave;
2789 }
2790
2791 status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
2792 dentry->d_name.len);
2793 if (status)
2794 goto leave;
2795
2796 /* get a spot inside the dir. */
2797 status = ocfs2_prepare_dir_for_insert(osb, dir, parent_di_bh,
2798 dentry->d_name.name,
2799 dentry->d_name.len, &lookup);
2800 if (status < 0) {
2801 mlog_errno(status);
2802 goto leave;
2803 }
2804
2805 orphan_dir_inode = ocfs2_get_system_file_inode(osb,
2806 ORPHAN_DIR_SYSTEM_INODE,
2807 osb->slot_num);
2808 if (!orphan_dir_inode) {
2809 status = -ENOENT;
2810 mlog_errno(status);
2811 goto leave;
2812 }
2813
2814 inode_lock(orphan_dir_inode);
2815
2816 status = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1);
2817 if (status < 0) {
2818 mlog_errno(status);
2819 inode_unlock(orphan_dir_inode);
2820 iput(orphan_dir_inode);
2821 goto leave;
2822 }
2823
2824 status = ocfs2_read_inode_block(inode, &di_bh);
2825 if (status < 0) {
2826 mlog_errno(status);
2827 goto orphan_unlock;
2828 }
2829
2830 handle = ocfs2_start_trans(osb, ocfs2_rename_credits(osb->sb));
2831 if (IS_ERR(handle)) {
2832 status = PTR_ERR(handle);
2833 handle = NULL;
2834 mlog_errno(status);
2835 goto orphan_unlock;
2836 }
2837
2838 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode),
2839 di_bh, OCFS2_JOURNAL_ACCESS_WRITE);
2840 if (status < 0) {
2841 mlog_errno(status);
2842 goto out_commit;
2843 }
2844
2845 status = ocfs2_orphan_del(osb, handle, orphan_dir_inode, inode,
2846 orphan_dir_bh, false);
2847 if (status < 0) {
2848 mlog_errno(status);
2849 goto out_commit;
2850 }
2851
2852 di = (struct ocfs2_dinode *)di_bh->b_data;
2853 di->i_flags &= ~cpu_to_le32(OCFS2_ORPHANED_FL);
2854 di->i_orphaned_slot = 0;
2855 set_nlink(inode, 1);
2856 ocfs2_set_links_count(di, inode->i_nlink);
2857 ocfs2_update_inode_fsync_trans(handle, inode, 1);
2858 ocfs2_journal_dirty(handle, di_bh);
2859
2860 status = ocfs2_add_entry(handle, dentry, inode,
2861 OCFS2_I(inode)->ip_blkno, parent_di_bh,
2862 &lookup);
2863 if (status < 0) {
2864 mlog_errno(status);
2865 goto out_commit;
2866 }
2867
2868 status = ocfs2_dentry_attach_lock(dentry, inode,
2869 OCFS2_I(dir)->ip_blkno);
2870 if (status) {
2871 mlog_errno(status);
2872 goto out_commit;
2873 }
2874
2875 d_instantiate(dentry, inode);
2876 status = 0;
2877 out_commit:
2878 ocfs2_commit_trans(osb, handle);
2879 orphan_unlock:
2880 ocfs2_inode_unlock(orphan_dir_inode, 1);
2881 inode_unlock(orphan_dir_inode);
2882 iput(orphan_dir_inode);
2883 leave:
2884
2885 ocfs2_inode_unlock(dir, 1);
2886
2887 brelse(di_bh);
2888 brelse(parent_di_bh);
2889 brelse(orphan_dir_bh);
2890
2891 ocfs2_free_dir_lookup_result(&lookup);
2892
2893 if (status)
2894 mlog_errno(status);
2895
2896 return status;
2897 }
2898
2899 const struct inode_operations ocfs2_dir_iops = {
2900 .create = ocfs2_create,
2901 .lookup = ocfs2_lookup,
2902 .link = ocfs2_link,
2903 .unlink = ocfs2_unlink,
2904 .rmdir = ocfs2_unlink,
2905 .symlink = ocfs2_symlink,
2906 .mkdir = ocfs2_mkdir,
2907 .mknod = ocfs2_mknod,
2908 .rename = ocfs2_rename,
2909 .setattr = ocfs2_setattr,
2910 .getattr = ocfs2_getattr,
2911 .permission = ocfs2_permission,
2912 .listxattr = ocfs2_listxattr,
2913 .fiemap = ocfs2_fiemap,
2914 .get_acl = ocfs2_iop_get_acl,
2915 .set_acl = ocfs2_iop_set_acl,
2916 };
Ubuntu Jammy Linux kernel mirror