]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - fs/ocfs2/namei.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'media/v4.13-2' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab...
[mirror_ubuntu-artful-kernel.git] / fs / ocfs2 / namei.c
1 /* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0:
3 *
4 * namei.c
5 *
6 * Create and rename file, directory, symlinks
7 *
8 * Copyright (C) 2002, 2004 Oracle. All rights reserved.
9 *
10 * Portions of this code from linux/fs/ext3/dir.c
11 *
12 * Copyright (C) 1992, 1993, 1994, 1995
13 * Remy Card (card@masi.ibp.fr)
14 * Laboratoire MASI - Institut Blaise pascal
15 * Universite Pierre et Marie Curie (Paris VI)
16 *
17 * from
18 *
19 * linux/fs/minix/dir.c
20 *
21 * Copyright (C) 1991, 1992 Linux Torvalds
22 *
23 * This program is free software; you can redistribute it and/or
24 * modify it under the terms of the GNU General Public
25 * License as published by the Free Software Foundation; either
26 * version 2 of the License, or (at your option) any later version.
27 *
28 * This program is distributed in the hope that it will be useful,
29 * but WITHOUT ANY WARRANTY; without even the implied warranty of
30 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
31 * General Public License for more details.
32 *
33 * You should have received a copy of the GNU General Public
34 * License along with this program; if not, write to the
35 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
36 * Boston, MA 021110-1307, USA.
37 */
38
39 #include <linux/fs.h>
40 #include <linux/types.h>
41 #include <linux/slab.h>
42 #include <linux/highmem.h>
43 #include <linux/quotaops.h>
44
45 #include <cluster/masklog.h>
46
47 #include "ocfs2.h"
48
49 #include "alloc.h"
50 #include "dcache.h"
51 #include "dir.h"
52 #include "dlmglue.h"
53 #include "extent_map.h"
54 #include "file.h"
55 #include "inode.h"
56 #include "journal.h"
57 #include "namei.h"
58 #include "suballoc.h"
59 #include "super.h"
60 #include "symlink.h"
61 #include "sysfile.h"
62 #include "uptodate.h"
63 #include "xattr.h"
64 #include "acl.h"
65 #include "ocfs2_trace.h"
66
67 #include "buffer_head_io.h"
68
69 static int ocfs2_mknod_locked(struct ocfs2_super *osb,
70 struct inode *dir,
71 struct inode *inode,
72 dev_t dev,
73 struct buffer_head **new_fe_bh,
74 struct buffer_head *parent_fe_bh,
75 handle_t *handle,
76 struct ocfs2_alloc_context *inode_ac);
77
78 static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb,
79 struct inode **ret_orphan_dir,
80 u64 blkno,
81 char *name,
82 struct ocfs2_dir_lookup_result *lookup,
83 bool dio);
84
85 static int ocfs2_orphan_add(struct ocfs2_super *osb,
86 handle_t *handle,
87 struct inode *inode,
88 struct buffer_head *fe_bh,
89 char *name,
90 struct ocfs2_dir_lookup_result *lookup,
91 struct inode *orphan_dir_inode,
92 bool dio);
93
94 static int ocfs2_create_symlink_data(struct ocfs2_super *osb,
95 handle_t *handle,
96 struct inode *inode,
97 const char *symname);
98
99 static int ocfs2_double_lock(struct ocfs2_super *osb,
100 struct buffer_head **bh1,
101 struct inode *inode1,
102 struct buffer_head **bh2,
103 struct inode *inode2,
104 int rename);
105
106 static void ocfs2_double_unlock(struct inode *inode1, struct inode *inode2);
107 /* An orphan dir name is an 8 byte value, printed as a hex string */
108 #define OCFS2_ORPHAN_NAMELEN ((int)(2 * sizeof(u64)))
109
110 static struct dentry *ocfs2_lookup(struct inode *dir, struct dentry *dentry,
111 unsigned int flags)
112 {
113 int status;
114 u64 blkno;
115 struct inode *inode = NULL;
116 struct dentry *ret;
117 struct ocfs2_inode_info *oi;
118
119 trace_ocfs2_lookup(dir, dentry, dentry->d_name.len,
120 dentry->d_name.name,
121 (unsigned long long)OCFS2_I(dir)->ip_blkno, 0);
122
123 if (dentry->d_name.len > OCFS2_MAX_FILENAME_LEN) {
124 ret = ERR_PTR(-ENAMETOOLONG);
125 goto bail;
126 }
127
128 status = ocfs2_inode_lock_nested(dir, NULL, 0, OI_LS_PARENT);
129 if (status < 0) {
130 if (status != -ENOENT)
131 mlog_errno(status);
132 ret = ERR_PTR(status);
133 goto bail;
134 }
135
136 status = ocfs2_lookup_ino_from_name(dir, dentry->d_name.name,
137 dentry->d_name.len, &blkno);
138 if (status < 0)
139 goto bail_add;
140
141 inode = ocfs2_iget(OCFS2_SB(dir->i_sb), blkno, 0, 0);
142 if (IS_ERR(inode)) {
143 ret = ERR_PTR(-EACCES);
144 goto bail_unlock;
145 }
146
147 oi = OCFS2_I(inode);
148 /* Clear any orphaned state... If we were able to look up the
149 * inode from a directory, it certainly can't be orphaned. We
150 * might have the bad state from a node which intended to
151 * orphan this inode but crashed before it could commit the
152 * unlink. */
153 spin_lock(&oi->ip_lock);
154 oi->ip_flags &= ~OCFS2_INODE_MAYBE_ORPHANED;
155 spin_unlock(&oi->ip_lock);
156
157 bail_add:
158 ret = d_splice_alias(inode, dentry);
159
160 if (inode) {
161 /*
162 * If d_splice_alias() finds a DCACHE_DISCONNECTED
163 * dentry, it will d_move() it on top of ourse. The
164 * return value will indicate this however, so in
165 * those cases, we switch them around for the locking
166 * code.
167 *
168 * NOTE: This dentry already has ->d_op set from
169 * ocfs2_get_parent() and ocfs2_get_dentry()
170 */
171 if (!IS_ERR_OR_NULL(ret))
172 dentry = ret;
173
174 status = ocfs2_dentry_attach_lock(dentry, inode,
175 OCFS2_I(dir)->ip_blkno);
176 if (status) {
177 mlog_errno(status);
178 ret = ERR_PTR(status);
179 goto bail_unlock;
180 }
181 } else
182 ocfs2_dentry_attach_gen(dentry);
183
184 bail_unlock:
185 /* Don't drop the cluster lock until *after* the d_add --
186 * unlink on another node will message us to remove that
187 * dentry under this lock so otherwise we can race this with
188 * the downconvert thread and have a stale dentry. */
189 ocfs2_inode_unlock(dir, 0);
190
191 bail:
192
193 trace_ocfs2_lookup_ret(ret);
194
195 return ret;
196 }
197
198 static struct inode *ocfs2_get_init_inode(struct inode *dir, umode_t mode)
199 {
200 struct inode *inode;
201 int status;
202
203 inode = new_inode(dir->i_sb);
204 if (!inode) {
205 mlog(ML_ERROR, "new_inode failed!\n");
206 return ERR_PTR(-ENOMEM);
207 }
208
209 /* populate as many fields early on as possible - many of
210 * these are used by the support functions here and in
211 * callers. */
212 if (S_ISDIR(mode))
213 set_nlink(inode, 2);
214 inode_init_owner(inode, dir, mode);
215 status = dquot_initialize(inode);
216 if (status)
217 return ERR_PTR(status);
218
219 return inode;
220 }
221
222 static void ocfs2_cleanup_add_entry_failure(struct ocfs2_super *osb,
223 struct dentry *dentry, struct inode *inode)
224 {
225 struct ocfs2_dentry_lock *dl = dentry->d_fsdata;
226
227 ocfs2_simple_drop_lockres(osb, &dl->dl_lockres);
228 ocfs2_lock_res_free(&dl->dl_lockres);
229 BUG_ON(dl->dl_count != 1);
230 spin_lock(&dentry_attach_lock);
231 dentry->d_fsdata = NULL;
232 spin_unlock(&dentry_attach_lock);
233 kfree(dl);
234 iput(inode);
235 }
236
237 static int ocfs2_mknod(struct inode *dir,
238 struct dentry *dentry,
239 umode_t mode,
240 dev_t dev)
241 {
242 int status = 0;
243 struct buffer_head *parent_fe_bh = NULL;
244 handle_t *handle = NULL;
245 struct ocfs2_super *osb;
246 struct ocfs2_dinode *dirfe;
247 struct buffer_head *new_fe_bh = NULL;
248 struct inode *inode = NULL;
249 struct ocfs2_alloc_context *inode_ac = NULL;
250 struct ocfs2_alloc_context *data_ac = NULL;
251 struct ocfs2_alloc_context *meta_ac = NULL;
252 int want_clusters = 0;
253 int want_meta = 0;
254 int xattr_credits = 0;
255 struct ocfs2_security_xattr_info si = {
256 .enable = 1,
257 };
258 int did_quota_inode = 0;
259 struct ocfs2_dir_lookup_result lookup = { NULL, };
260 sigset_t oldset;
261 int did_block_signals = 0;
262 struct ocfs2_dentry_lock *dl = NULL;
263
264 trace_ocfs2_mknod(dir, dentry, dentry->d_name.len, dentry->d_name.name,
265 (unsigned long long)OCFS2_I(dir)->ip_blkno,
266 (unsigned long)dev, mode);
267
268 status = dquot_initialize(dir);
269 if (status) {
270 mlog_errno(status);
271 return status;
272 }
273
274 /* get our super block */
275 osb = OCFS2_SB(dir->i_sb);
276
277 status = ocfs2_inode_lock(dir, &parent_fe_bh, 1);
278 if (status < 0) {
279 if (status != -ENOENT)
280 mlog_errno(status);
281 return status;
282 }
283
284 if (S_ISDIR(mode) && (dir->i_nlink >= ocfs2_link_max(osb))) {
285 status = -EMLINK;
286 goto leave;
287 }
288
289 dirfe = (struct ocfs2_dinode *) parent_fe_bh->b_data;
290 if (!ocfs2_read_links_count(dirfe)) {
291 /* can't make a file in a deleted directory. */
292 status = -ENOENT;
293 goto leave;
294 }
295
296 status = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
297 dentry->d_name.len);
298 if (status)
299 goto leave;
300
301 /* get a spot inside the dir. */
302 status = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
303 dentry->d_name.name,
304 dentry->d_name.len, &lookup);
305 if (status < 0) {
306 mlog_errno(status);
307 goto leave;
308 }
309
310 /* reserve an inode spot */
311 status = ocfs2_reserve_new_inode(osb, &inode_ac);
312 if (status < 0) {
313 if (status != -ENOSPC)
314 mlog_errno(status);
315 goto leave;
316 }
317
318 inode = ocfs2_get_init_inode(dir, mode);
319 if (IS_ERR(inode)) {
320 status = PTR_ERR(inode);
321 inode = NULL;
322 mlog_errno(status);
323 goto leave;
324 }
325
326 /* get security xattr */
327 status = ocfs2_init_security_get(inode, dir, &dentry->d_name, &si);
328 if (status) {
329 if (status == -EOPNOTSUPP)
330 si.enable = 0;
331 else {
332 mlog_errno(status);
333 goto leave;
334 }
335 }
336
337 /* calculate meta data/clusters for setting security and acl xattr */
338 status = ocfs2_calc_xattr_init(dir, parent_fe_bh, mode,
339 &si, &want_clusters,
340 &xattr_credits, &want_meta);
341 if (status < 0) {
342 mlog_errno(status);
343 goto leave;
344 }
345
346 /* Reserve a cluster if creating an extent based directory. */
347 if (S_ISDIR(mode) && !ocfs2_supports_inline_data(osb)) {
348 want_clusters += 1;
349
350 /* Dir indexing requires extra space as well */
351 if (ocfs2_supports_indexed_dirs(osb))
352 want_meta++;
353 }
354
355 status = ocfs2_reserve_new_metadata_blocks(osb, want_meta, &meta_ac);
356 if (status < 0) {
357 if (status != -ENOSPC)
358 mlog_errno(status);
359 goto leave;
360 }
361
362 status = ocfs2_reserve_clusters(osb, want_clusters, &data_ac);
363 if (status < 0) {
364 if (status != -ENOSPC)
365 mlog_errno(status);
366 goto leave;
367 }
368
369 handle = ocfs2_start_trans(osb, ocfs2_mknod_credits(osb->sb,
370 S_ISDIR(mode),
371 xattr_credits));
372 if (IS_ERR(handle)) {
373 status = PTR_ERR(handle);
374 handle = NULL;
375 mlog_errno(status);
376 goto leave;
377 }
378
379 /* Starting to change things, restart is no longer possible. */
380 ocfs2_block_signals(&oldset);
381 did_block_signals = 1;
382
383 status = dquot_alloc_inode(inode);
384 if (status)
385 goto leave;
386 did_quota_inode = 1;
387
388 /* do the real work now. */
389 status = ocfs2_mknod_locked(osb, dir, inode, dev,
390 &new_fe_bh, parent_fe_bh, handle,
391 inode_ac);
392 if (status < 0) {
393 mlog_errno(status);
394 goto leave;
395 }
396
397 if (S_ISDIR(mode)) {
398 status = ocfs2_fill_new_dir(osb, handle, dir, inode,
399 new_fe_bh, data_ac, meta_ac);
400 if (status < 0) {
401 mlog_errno(status);
402 goto leave;
403 }
404
405 status = ocfs2_journal_access_di(handle, INODE_CACHE(dir),
406 parent_fe_bh,
407 OCFS2_JOURNAL_ACCESS_WRITE);
408 if (status < 0) {
409 mlog_errno(status);
410 goto leave;
411 }
412 ocfs2_add_links_count(dirfe, 1);
413 ocfs2_journal_dirty(handle, parent_fe_bh);
414 inc_nlink(dir);
415 }
416
417 status = ocfs2_init_acl(handle, inode, dir, new_fe_bh, parent_fe_bh,
418 meta_ac, data_ac);
419
420 if (status < 0) {
421 mlog_errno(status);
422 goto leave;
423 }
424
425 if (si.enable) {
426 status = ocfs2_init_security_set(handle, inode, new_fe_bh, &si,
427 meta_ac, data_ac);
428 if (status < 0) {
429 mlog_errno(status);
430 goto leave;
431 }
432 }
433
434 /*
435 * Do this before adding the entry to the directory. We add
436 * also set d_op after success so that ->d_iput() will cleanup
437 * the dentry lock even if ocfs2_add_entry() fails below.
438 */
439 status = ocfs2_dentry_attach_lock(dentry, inode,
440 OCFS2_I(dir)->ip_blkno);
441 if (status) {
442 mlog_errno(status);
443 goto leave;
444 }
445
446 dl = dentry->d_fsdata;
447
448 status = ocfs2_add_entry(handle, dentry, inode,
449 OCFS2_I(inode)->ip_blkno, parent_fe_bh,
450 &lookup);
451 if (status < 0) {
452 mlog_errno(status);
453 goto leave;
454 }
455
456 insert_inode_hash(inode);
457 d_instantiate(dentry, inode);
458 status = 0;
459 leave:
460 if (status < 0 && did_quota_inode)
461 dquot_free_inode(inode);
462 if (handle)
463 ocfs2_commit_trans(osb, handle);
464
465 ocfs2_inode_unlock(dir, 1);
466 if (did_block_signals)
467 ocfs2_unblock_signals(&oldset);
468
469 brelse(new_fe_bh);
470 brelse(parent_fe_bh);
471 kfree(si.value);
472
473 ocfs2_free_dir_lookup_result(&lookup);
474
475 if (inode_ac)
476 ocfs2_free_alloc_context(inode_ac);
477
478 if (data_ac)
479 ocfs2_free_alloc_context(data_ac);
480
481 if (meta_ac)
482 ocfs2_free_alloc_context(meta_ac);
483
484 /*
485 * We should call iput after the i_mutex of the bitmap been
486 * unlocked in ocfs2_free_alloc_context, or the
487 * ocfs2_delete_inode will mutex_lock again.
488 */
489 if ((status < 0) && inode) {
490 if (dl)
491 ocfs2_cleanup_add_entry_failure(osb, dentry, inode);
492
493 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_SKIP_ORPHAN_DIR;
494 clear_nlink(inode);
495 iput(inode);
496 }
497
498 if (status)
499 mlog_errno(status);
500
501 return status;
502 }
503
504 static int __ocfs2_mknod_locked(struct inode *dir,
505 struct inode *inode,
506 dev_t dev,
507 struct buffer_head **new_fe_bh,
508 struct buffer_head *parent_fe_bh,
509 handle_t *handle,
510 struct ocfs2_alloc_context *inode_ac,
511 u64 fe_blkno, u64 suballoc_loc, u16 suballoc_bit)
512 {
513 int status = 0;
514 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
515 struct ocfs2_dinode *fe = NULL;
516 struct ocfs2_extent_list *fel;
517 u16 feat;
518 struct ocfs2_inode_info *oi = OCFS2_I(inode);
519 struct timespec64 ts;
520
521 *new_fe_bh = NULL;
522
523 /* populate as many fields early on as possible - many of
524 * these are used by the support functions here and in
525 * callers. */
526 inode->i_ino = ino_from_blkno(osb->sb, fe_blkno);
527 OCFS2_I(inode)->ip_blkno = fe_blkno;
528 spin_lock(&osb->osb_lock);
529 inode->i_generation = osb->s_next_generation++;
530 spin_unlock(&osb->osb_lock);
531
532 *new_fe_bh = sb_getblk(osb->sb, fe_blkno);
533 if (!*new_fe_bh) {
534 status = -ENOMEM;
535 mlog_errno(status);
536 goto leave;
537 }
538 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode), *new_fe_bh);
539
540 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode),
541 *new_fe_bh,
542 OCFS2_JOURNAL_ACCESS_CREATE);
543 if (status < 0) {
544 mlog_errno(status);
545 goto leave;
546 }
547
548 fe = (struct ocfs2_dinode *) (*new_fe_bh)->b_data;
549 memset(fe, 0, osb->sb->s_blocksize);
550
551 fe->i_generation = cpu_to_le32(inode->i_generation);
552 fe->i_fs_generation = cpu_to_le32(osb->fs_generation);
553 fe->i_blkno = cpu_to_le64(fe_blkno);
554 fe->i_suballoc_loc = cpu_to_le64(suballoc_loc);
555 fe->i_suballoc_bit = cpu_to_le16(suballoc_bit);
556 fe->i_suballoc_slot = cpu_to_le16(inode_ac->ac_alloc_slot);
557 fe->i_uid = cpu_to_le32(i_uid_read(inode));
558 fe->i_gid = cpu_to_le32(i_gid_read(inode));
559 fe->i_mode = cpu_to_le16(inode->i_mode);
560 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
561 fe->id1.dev1.i_rdev = cpu_to_le64(huge_encode_dev(dev));
562
563 ocfs2_set_links_count(fe, inode->i_nlink);
564
565 fe->i_last_eb_blk = 0;
566 strcpy(fe->i_signature, OCFS2_INODE_SIGNATURE);
567 fe->i_flags |= cpu_to_le32(OCFS2_VALID_FL);
568 ktime_get_real_ts64(&ts);
569 fe->i_atime = fe->i_ctime = fe->i_mtime =
570 cpu_to_le64(ts.tv_sec);
571 fe->i_mtime_nsec = fe->i_ctime_nsec = fe->i_atime_nsec =
572 cpu_to_le32(ts.tv_nsec);
573 fe->i_dtime = 0;
574
575 /*
576 * If supported, directories start with inline data. If inline
577 * isn't supported, but indexing is, we start them as indexed.
578 */
579 feat = le16_to_cpu(fe->i_dyn_features);
580 if (S_ISDIR(inode->i_mode) && ocfs2_supports_inline_data(osb)) {
581 fe->i_dyn_features = cpu_to_le16(feat | OCFS2_INLINE_DATA_FL);
582
583 fe->id2.i_data.id_count = cpu_to_le16(
584 ocfs2_max_inline_data_with_xattr(osb->sb, fe));
585 } else {
586 fel = &fe->id2.i_list;
587 fel->l_tree_depth = 0;
588 fel->l_next_free_rec = 0;
589 fel->l_count = cpu_to_le16(ocfs2_extent_recs_per_inode(osb->sb));
590 }
591
592 ocfs2_journal_dirty(handle, *new_fe_bh);
593
594 ocfs2_populate_inode(inode, fe, 1);
595 ocfs2_ci_set_new(osb, INODE_CACHE(inode));
596 if (!ocfs2_mount_local(osb)) {
597 status = ocfs2_create_new_inode_locks(inode);
598 if (status < 0)
599 mlog_errno(status);
600 }
601
602 oi->i_sync_tid = handle->h_transaction->t_tid;
603 oi->i_datasync_tid = handle->h_transaction->t_tid;
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
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 status = __ocfs2_mknod_locked(dir, inode, dev, new_fe_bh,
642 parent_fe_bh, handle, inode_ac,
643 fe_blkno, suballoc_loc, suballoc_bit);
644 if (status < 0) {
645 u64 bg_blkno = ocfs2_which_suballoc_group(fe_blkno, suballoc_bit);
646 int tmp = ocfs2_free_suballoc_bits(handle, inode_ac->ac_inode,
647 inode_ac->ac_bh, suballoc_bit, bg_blkno, 1);
648 if (tmp)
649 mlog_errno(tmp);
650 }
651
652 return status;
653 }
654
655 static int ocfs2_mkdir(struct inode *dir,
656 struct dentry *dentry,
657 umode_t mode)
658 {
659 int ret;
660
661 trace_ocfs2_mkdir(dir, dentry, dentry->d_name.len, dentry->d_name.name,
662 OCFS2_I(dir)->ip_blkno, mode);
663 ret = ocfs2_mknod(dir, dentry, mode | S_IFDIR, 0);
664 if (ret)
665 mlog_errno(ret);
666
667 return ret;
668 }
669
670 static int ocfs2_create(struct inode *dir,
671 struct dentry *dentry,
672 umode_t mode,
673 bool excl)
674 {
675 int ret;
676
677 trace_ocfs2_create(dir, dentry, dentry->d_name.len, dentry->d_name.name,
678 (unsigned long long)OCFS2_I(dir)->ip_blkno, mode);
679 ret = ocfs2_mknod(dir, dentry, mode | S_IFREG, 0);
680 if (ret)
681 mlog_errno(ret);
682
683 return ret;
684 }
685
686 static int ocfs2_link(struct dentry *old_dentry,
687 struct inode *dir,
688 struct dentry *dentry)
689 {
690 handle_t *handle;
691 struct inode *inode = d_inode(old_dentry);
692 struct inode *old_dir = d_inode(old_dentry->d_parent);
693 int err;
694 struct buffer_head *fe_bh = NULL;
695 struct buffer_head *old_dir_bh = NULL;
696 struct buffer_head *parent_fe_bh = NULL;
697 struct ocfs2_dinode *fe = NULL;
698 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
699 struct ocfs2_dir_lookup_result lookup = { NULL, };
700 sigset_t oldset;
701 u64 old_de_ino;
702
703 trace_ocfs2_link((unsigned long long)OCFS2_I(inode)->ip_blkno,
704 old_dentry->d_name.len, old_dentry->d_name.name,
705 dentry->d_name.len, dentry->d_name.name);
706
707 if (S_ISDIR(inode->i_mode))
708 return -EPERM;
709
710 err = dquot_initialize(dir);
711 if (err) {
712 mlog_errno(err);
713 return err;
714 }
715
716 err = ocfs2_double_lock(osb, &old_dir_bh, old_dir,
717 &parent_fe_bh, dir, 0);
718 if (err < 0) {
719 if (err != -ENOENT)
720 mlog_errno(err);
721 return err;
722 }
723
724 /* make sure both dirs have bhs
725 * get an extra ref on old_dir_bh if old==new */
726 if (!parent_fe_bh) {
727 if (old_dir_bh) {
728 parent_fe_bh = old_dir_bh;
729 get_bh(parent_fe_bh);
730 } else {
731 mlog(ML_ERROR, "%s: no old_dir_bh!\n", osb->uuid_str);
732 err = -EIO;
733 goto out;
734 }
735 }
736
737 if (!dir->i_nlink) {
738 err = -ENOENT;
739 goto out;
740 }
741
742 err = ocfs2_lookup_ino_from_name(old_dir, old_dentry->d_name.name,
743 old_dentry->d_name.len, &old_de_ino);
744 if (err) {
745 err = -ENOENT;
746 goto out;
747 }
748
749 /*
750 * Check whether another node removed the source inode while we
751 * were in the vfs.
752 */
753 if (old_de_ino != OCFS2_I(inode)->ip_blkno) {
754 err = -ENOENT;
755 goto out;
756 }
757
758 err = ocfs2_check_dir_for_entry(dir, dentry->d_name.name,
759 dentry->d_name.len);
760 if (err)
761 goto out;
762
763 err = ocfs2_prepare_dir_for_insert(osb, dir, parent_fe_bh,
764 dentry->d_name.name,
765 dentry->d_name.len, &lookup);
766 if (err < 0) {
767 mlog_errno(err);
768 goto out;
769 }
770
771 err = ocfs2_inode_lock(inode, &fe_bh, 1);
772 if (err < 0) {
773 if (err != -ENOENT)
774 mlog_errno(err);
775 goto out;
776 }
777
778 fe = (struct ocfs2_dinode *) fe_bh->b_data;
779 if (ocfs2_read_links_count(fe) >= ocfs2_link_max(osb)) {
780 err = -EMLINK;
781 goto out_unlock_inode;
782 }
783
784 handle = ocfs2_start_trans(osb, ocfs2_link_credits(osb->sb));
785 if (IS_ERR(handle)) {
786 err = PTR_ERR(handle);
787 handle = NULL;
788 mlog_errno(err);
789 goto out_unlock_inode;
790 }
791
792 /* Starting to change things, restart is no longer possible. */
793 ocfs2_block_signals(&oldset);
794
795 err = ocfs2_journal_access_di(handle, INODE_CACHE(inode), fe_bh,
796 OCFS2_JOURNAL_ACCESS_WRITE);
797 if (err < 0) {
798 mlog_errno(err);
799 goto out_commit;
800 }
801
802 inc_nlink(inode);
803 inode->i_ctime = current_time(inode);
804 ocfs2_set_links_count(fe, inode->i_nlink);
805 fe->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
806 fe->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
807 ocfs2_journal_dirty(handle, fe_bh);
808
809 err = ocfs2_add_entry(handle, dentry, inode,
810 OCFS2_I(inode)->ip_blkno,
811 parent_fe_bh, &lookup);
812 if (err) {
813 ocfs2_add_links_count(fe, -1);
814 drop_nlink(inode);
815 mlog_errno(err);
816 goto out_commit;
817 }
818
819 err = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(dir)->ip_blkno);
820 if (err) {
821 mlog_errno(err);
822 goto out_commit;
823 }
824
825 ihold(inode);
826 d_instantiate(dentry, inode);
827
828 out_commit:
829 ocfs2_commit_trans(osb, handle);
830 ocfs2_unblock_signals(&oldset);
831 out_unlock_inode:
832 ocfs2_inode_unlock(inode, 1);
833
834 out:
835 ocfs2_double_unlock(old_dir, dir);
836
837 brelse(fe_bh);
838 brelse(parent_fe_bh);
839 brelse(old_dir_bh);
840
841 ocfs2_free_dir_lookup_result(&lookup);
842
843 if (err)
844 mlog_errno(err);
845
846 return err;
847 }
848
849 /*
850 * Takes and drops an exclusive lock on the given dentry. This will
851 * force other nodes to drop it.
852 */
853 static int ocfs2_remote_dentry_delete(struct dentry *dentry)
854 {
855 int ret;
856
857 ret = ocfs2_dentry_lock(dentry, 1);
858 if (ret)
859 mlog_errno(ret);
860 else
861 ocfs2_dentry_unlock(dentry, 1);
862
863 return ret;
864 }
865
866 static inline int ocfs2_inode_is_unlinkable(struct inode *inode)
867 {
868 if (S_ISDIR(inode->i_mode)) {
869 if (inode->i_nlink == 2)
870 return 1;
871 return 0;
872 }
873
874 if (inode->i_nlink == 1)
875 return 1;
876 return 0;
877 }
878
879 static int ocfs2_unlink(struct inode *dir,
880 struct dentry *dentry)
881 {
882 int status;
883 int child_locked = 0;
884 bool is_unlinkable = false;
885 struct inode *inode = d_inode(dentry);
886 struct inode *orphan_dir = NULL;
887 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
888 u64 blkno;
889 struct ocfs2_dinode *fe = NULL;
890 struct buffer_head *fe_bh = NULL;
891 struct buffer_head *parent_node_bh = NULL;
892 handle_t *handle = NULL;
893 char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
894 struct ocfs2_dir_lookup_result lookup = { NULL, };
895 struct ocfs2_dir_lookup_result orphan_insert = { NULL, };
896
897 trace_ocfs2_unlink(dir, dentry, dentry->d_name.len,
898 dentry->d_name.name,
899 (unsigned long long)OCFS2_I(dir)->ip_blkno,
900 (unsigned long long)OCFS2_I(inode)->ip_blkno);
901
902 status = dquot_initialize(dir);
903 if (status) {
904 mlog_errno(status);
905 return status;
906 }
907
908 BUG_ON(d_inode(dentry->d_parent) != dir);
909
910 if (inode == osb->root_inode)
911 return -EPERM;
912
913 status = ocfs2_inode_lock_nested(dir, &parent_node_bh, 1,
914 OI_LS_PARENT);
915 if (status < 0) {
916 if (status != -ENOENT)
917 mlog_errno(status);
918 return status;
919 }
920
921 status = ocfs2_find_files_on_disk(dentry->d_name.name,
922 dentry->d_name.len, &blkno, dir,
923 &lookup);
924 if (status < 0) {
925 if (status != -ENOENT)
926 mlog_errno(status);
927 goto leave;
928 }
929
930 if (OCFS2_I(inode)->ip_blkno != blkno) {
931 status = -ENOENT;
932
933 trace_ocfs2_unlink_noent(
934 (unsigned long long)OCFS2_I(inode)->ip_blkno,
935 (unsigned long long)blkno,
936 OCFS2_I(inode)->ip_flags);
937 goto leave;
938 }
939
940 status = ocfs2_inode_lock(inode, &fe_bh, 1);
941 if (status < 0) {
942 if (status != -ENOENT)
943 mlog_errno(status);
944 goto leave;
945 }
946 child_locked = 1;
947
948 if (S_ISDIR(inode->i_mode)) {
949 if (inode->i_nlink != 2 || !ocfs2_empty_dir(inode)) {
950 status = -ENOTEMPTY;
951 goto leave;
952 }
953 }
954
955 status = ocfs2_remote_dentry_delete(dentry);
956 if (status < 0) {
957 /* This remote delete should succeed under all normal
958 * circumstances. */
959 mlog_errno(status);
960 goto leave;
961 }
962
963 if (ocfs2_inode_is_unlinkable(inode)) {
964 status = ocfs2_prepare_orphan_dir(osb, &orphan_dir,
965 OCFS2_I(inode)->ip_blkno,
966 orphan_name, &orphan_insert,
967 false);
968 if (status < 0) {
969 mlog_errno(status);
970 goto leave;
971 }
972 is_unlinkable = true;
973 }
974
975 handle = ocfs2_start_trans(osb, ocfs2_unlink_credits(osb->sb));
976 if (IS_ERR(handle)) {
977 status = PTR_ERR(handle);
978 handle = NULL;
979 mlog_errno(status);
980 goto leave;
981 }
982
983 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode), fe_bh,
984 OCFS2_JOURNAL_ACCESS_WRITE);
985 if (status < 0) {
986 mlog_errno(status);
987 goto leave;
988 }
989
990 fe = (struct ocfs2_dinode *) fe_bh->b_data;
991
992 /* delete the name from the parent dir */
993 status = ocfs2_delete_entry(handle, dir, &lookup);
994 if (status < 0) {
995 mlog_errno(status);
996 goto leave;
997 }
998
999 if (S_ISDIR(inode->i_mode))
1000 drop_nlink(inode);
1001 drop_nlink(inode);
1002 ocfs2_set_links_count(fe, inode->i_nlink);
1003 ocfs2_journal_dirty(handle, fe_bh);
1004
1005 dir->i_ctime = dir->i_mtime = current_time(dir);
1006 if (S_ISDIR(inode->i_mode))
1007 drop_nlink(dir);
1008
1009 status = ocfs2_mark_inode_dirty(handle, dir, parent_node_bh);
1010 if (status < 0) {
1011 mlog_errno(status);
1012 if (S_ISDIR(inode->i_mode))
1013 inc_nlink(dir);
1014 goto leave;
1015 }
1016
1017 if (is_unlinkable) {
1018 status = ocfs2_orphan_add(osb, handle, inode, fe_bh,
1019 orphan_name, &orphan_insert, orphan_dir, false);
1020 if (status < 0)
1021 mlog_errno(status);
1022 }
1023
1024 leave:
1025 if (handle)
1026 ocfs2_commit_trans(osb, handle);
1027
1028 if (orphan_dir) {
1029 /* This was locked for us in ocfs2_prepare_orphan_dir() */
1030 ocfs2_inode_unlock(orphan_dir, 1);
1031 inode_unlock(orphan_dir);
1032 iput(orphan_dir);
1033 }
1034
1035 if (child_locked)
1036 ocfs2_inode_unlock(inode, 1);
1037
1038 ocfs2_inode_unlock(dir, 1);
1039
1040 brelse(fe_bh);
1041 brelse(parent_node_bh);
1042
1043 ocfs2_free_dir_lookup_result(&orphan_insert);
1044 ocfs2_free_dir_lookup_result(&lookup);
1045
1046 if (status && (status != -ENOTEMPTY) && (status != -ENOENT))
1047 mlog_errno(status);
1048
1049 return status;
1050 }
1051
1052 static int ocfs2_check_if_ancestor(struct ocfs2_super *osb,
1053 u64 src_inode_no, u64 dest_inode_no)
1054 {
1055 int ret = 0, i = 0;
1056 u64 parent_inode_no = 0;
1057 u64 child_inode_no = src_inode_no;
1058 struct inode *child_inode;
1059
1060 #define MAX_LOOKUP_TIMES 32
1061 while (1) {
1062 child_inode = ocfs2_iget(osb, child_inode_no, 0, 0);
1063 if (IS_ERR(child_inode)) {
1064 ret = PTR_ERR(child_inode);
1065 break;
1066 }
1067
1068 ret = ocfs2_inode_lock(child_inode, NULL, 0);
1069 if (ret < 0) {
1070 iput(child_inode);
1071 if (ret != -ENOENT)
1072 mlog_errno(ret);
1073 break;
1074 }
1075
1076 ret = ocfs2_lookup_ino_from_name(child_inode, "..", 2,
1077 &parent_inode_no);
1078 ocfs2_inode_unlock(child_inode, 0);
1079 iput(child_inode);
1080 if (ret < 0) {
1081 ret = -ENOENT;
1082 break;
1083 }
1084
1085 if (parent_inode_no == dest_inode_no) {
1086 ret = 1;
1087 break;
1088 }
1089
1090 if (parent_inode_no == osb->root_inode->i_ino) {
1091 ret = 0;
1092 break;
1093 }
1094
1095 child_inode_no = parent_inode_no;
1096
1097 if (++i >= MAX_LOOKUP_TIMES) {
1098 mlog(ML_NOTICE, "max lookup times reached, filesystem "
1099 "may have nested directories, "
1100 "src inode: %llu, dest inode: %llu.\n",
1101 (unsigned long long)src_inode_no,
1102 (unsigned long long)dest_inode_no);
1103 ret = 0;
1104 break;
1105 }
1106 }
1107
1108 return ret;
1109 }
1110
1111 /*
1112 * The only place this should be used is rename and link!
1113 * if they have the same id, then the 1st one is the only one locked.
1114 */
1115 static int ocfs2_double_lock(struct ocfs2_super *osb,
1116 struct buffer_head **bh1,
1117 struct inode *inode1,
1118 struct buffer_head **bh2,
1119 struct inode *inode2,
1120 int rename)
1121 {
1122 int status;
1123 int inode1_is_ancestor, inode2_is_ancestor;
1124 struct ocfs2_inode_info *oi1 = OCFS2_I(inode1);
1125 struct ocfs2_inode_info *oi2 = OCFS2_I(inode2);
1126
1127 trace_ocfs2_double_lock((unsigned long long)oi1->ip_blkno,
1128 (unsigned long long)oi2->ip_blkno);
1129
1130 if (*bh1)
1131 *bh1 = NULL;
1132 if (*bh2)
1133 *bh2 = NULL;
1134
1135 /* we always want to lock the one with the lower lockid first.
1136 * and if they are nested, we lock ancestor first */
1137 if (oi1->ip_blkno != oi2->ip_blkno) {
1138 inode1_is_ancestor = ocfs2_check_if_ancestor(osb, oi2->ip_blkno,
1139 oi1->ip_blkno);
1140 if (inode1_is_ancestor < 0) {
1141 status = inode1_is_ancestor;
1142 goto bail;
1143 }
1144
1145 inode2_is_ancestor = ocfs2_check_if_ancestor(osb, oi1->ip_blkno,
1146 oi2->ip_blkno);
1147 if (inode2_is_ancestor < 0) {
1148 status = inode2_is_ancestor;
1149 goto bail;
1150 }
1151
1152 if ((inode1_is_ancestor == 1) ||
1153 (oi1->ip_blkno < oi2->ip_blkno &&
1154 inode2_is_ancestor == 0)) {
1155 /* switch id1 and id2 around */
1156 swap(bh2, bh1);
1157 swap(inode2, inode1);
1158 }
1159 /* lock id2 */
1160 status = ocfs2_inode_lock_nested(inode2, bh2, 1,
1161 rename == 1 ? OI_LS_RENAME1 : OI_LS_PARENT);
1162 if (status < 0) {
1163 if (status != -ENOENT)
1164 mlog_errno(status);
1165 goto bail;
1166 }
1167 }
1168
1169 /* lock id1 */
1170 status = ocfs2_inode_lock_nested(inode1, bh1, 1,
1171 rename == 1 ? OI_LS_RENAME2 : OI_LS_PARENT);
1172 if (status < 0) {
1173 /*
1174 * An error return must mean that no cluster locks
1175 * were held on function exit.
1176 */
1177 if (oi1->ip_blkno != oi2->ip_blkno) {
1178 ocfs2_inode_unlock(inode2, 1);
1179 brelse(*bh2);
1180 *bh2 = NULL;
1181 }
1182
1183 if (status != -ENOENT)
1184 mlog_errno(status);
1185 }
1186
1187 trace_ocfs2_double_lock_end(
1188 (unsigned long long)OCFS2_I(inode1)->ip_blkno,
1189 (unsigned long long)OCFS2_I(inode2)->ip_blkno);
1190
1191 bail:
1192 if (status)
1193 mlog_errno(status);
1194 return status;
1195 }
1196
1197 static void ocfs2_double_unlock(struct inode *inode1, struct inode *inode2)
1198 {
1199 ocfs2_inode_unlock(inode1, 1);
1200
1201 if (inode1 != inode2)
1202 ocfs2_inode_unlock(inode2, 1);
1203 }
1204
1205 static int ocfs2_rename(struct inode *old_dir,
1206 struct dentry *old_dentry,
1207 struct inode *new_dir,
1208 struct dentry *new_dentry,
1209 unsigned int flags)
1210 {
1211 int status = 0, rename_lock = 0, parents_locked = 0, target_exists = 0;
1212 int old_child_locked = 0, new_child_locked = 0, update_dot_dot = 0;
1213 struct inode *old_inode = d_inode(old_dentry);
1214 struct inode *new_inode = d_inode(new_dentry);
1215 struct inode *orphan_dir = NULL;
1216 struct ocfs2_dinode *newfe = NULL;
1217 char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
1218 struct buffer_head *newfe_bh = NULL;
1219 struct buffer_head *old_inode_bh = NULL;
1220 struct ocfs2_super *osb = NULL;
1221 u64 newfe_blkno, old_de_ino;
1222 handle_t *handle = NULL;
1223 struct buffer_head *old_dir_bh = NULL;
1224 struct buffer_head *new_dir_bh = NULL;
1225 u32 old_dir_nlink = old_dir->i_nlink;
1226 struct ocfs2_dinode *old_di;
1227 struct ocfs2_dir_lookup_result old_inode_dot_dot_res = { NULL, };
1228 struct ocfs2_dir_lookup_result target_lookup_res = { NULL, };
1229 struct ocfs2_dir_lookup_result old_entry_lookup = { NULL, };
1230 struct ocfs2_dir_lookup_result orphan_insert = { NULL, };
1231 struct ocfs2_dir_lookup_result target_insert = { NULL, };
1232 bool should_add_orphan = false;
1233
1234 if (flags)
1235 return -EINVAL;
1236
1237 /* At some point it might be nice to break this function up a
1238 * bit. */
1239
1240 trace_ocfs2_rename(old_dir, old_dentry, new_dir, new_dentry,
1241 old_dentry->d_name.len, old_dentry->d_name.name,
1242 new_dentry->d_name.len, new_dentry->d_name.name);
1243
1244 status = dquot_initialize(old_dir);
1245 if (status) {
1246 mlog_errno(status);
1247 goto bail;
1248 }
1249 status = dquot_initialize(new_dir);
1250 if (status) {
1251 mlog_errno(status);
1252 goto bail;
1253 }
1254
1255 osb = OCFS2_SB(old_dir->i_sb);
1256
1257 if (new_inode) {
1258 if (!igrab(new_inode))
1259 BUG();
1260 }
1261
1262 /* Assume a directory hierarchy thusly:
1263 * a/b/c
1264 * a/d
1265 * a,b,c, and d are all directories.
1266 *
1267 * from cwd of 'a' on both nodes:
1268 * node1: mv b/c d
1269 * node2: mv d b/c
1270 *
1271 * And that's why, just like the VFS, we need a file system
1272 * rename lock. */
1273 if (old_dir != new_dir && S_ISDIR(old_inode->i_mode)) {
1274 status = ocfs2_rename_lock(osb);
1275 if (status < 0) {
1276 mlog_errno(status);
1277 goto bail;
1278 }
1279 rename_lock = 1;
1280
1281 /* here we cannot guarantee the inodes haven't just been
1282 * changed, so check if they are nested again */
1283 status = ocfs2_check_if_ancestor(osb, new_dir->i_ino,
1284 old_inode->i_ino);
1285 if (status < 0) {
1286 mlog_errno(status);
1287 goto bail;
1288 } else if (status == 1) {
1289 status = -EPERM;
1290 trace_ocfs2_rename_not_permitted(
1291 (unsigned long long)old_inode->i_ino,
1292 (unsigned long long)new_dir->i_ino);
1293 goto bail;
1294 }
1295 }
1296
1297 /* if old and new are the same, this'll just do one lock. */
1298 status = ocfs2_double_lock(osb, &old_dir_bh, old_dir,
1299 &new_dir_bh, new_dir, 1);
1300 if (status < 0) {
1301 mlog_errno(status);
1302 goto bail;
1303 }
1304 parents_locked = 1;
1305
1306 if (!new_dir->i_nlink) {
1307 status = -EACCES;
1308 goto bail;
1309 }
1310
1311 /* make sure both dirs have bhs
1312 * get an extra ref on old_dir_bh if old==new */
1313 if (!new_dir_bh) {
1314 if (old_dir_bh) {
1315 new_dir_bh = old_dir_bh;
1316 get_bh(new_dir_bh);
1317 } else {
1318 mlog(ML_ERROR, "no old_dir_bh!\n");
1319 status = -EIO;
1320 goto bail;
1321 }
1322 }
1323
1324 /*
1325 * Aside from allowing a meta data update, the locking here
1326 * also ensures that the downconvert thread on other nodes
1327 * won't have to concurrently downconvert the inode and the
1328 * dentry locks.
1329 */
1330 status = ocfs2_inode_lock_nested(old_inode, &old_inode_bh, 1,
1331 OI_LS_PARENT);
1332 if (status < 0) {
1333 if (status != -ENOENT)
1334 mlog_errno(status);
1335 goto bail;
1336 }
1337 old_child_locked = 1;
1338
1339 status = ocfs2_remote_dentry_delete(old_dentry);
1340 if (status < 0) {
1341 mlog_errno(status);
1342 goto bail;
1343 }
1344
1345 if (S_ISDIR(old_inode->i_mode)) {
1346 u64 old_inode_parent;
1347
1348 update_dot_dot = 1;
1349 status = ocfs2_find_files_on_disk("..", 2, &old_inode_parent,
1350 old_inode,
1351 &old_inode_dot_dot_res);
1352 if (status) {
1353 status = -EIO;
1354 goto bail;
1355 }
1356
1357 if (old_inode_parent != OCFS2_I(old_dir)->ip_blkno) {
1358 status = -EIO;
1359 goto bail;
1360 }
1361
1362 if (!new_inode && new_dir != old_dir &&
1363 new_dir->i_nlink >= ocfs2_link_max(osb)) {
1364 status = -EMLINK;
1365 goto bail;
1366 }
1367 }
1368
1369 status = ocfs2_lookup_ino_from_name(old_dir, old_dentry->d_name.name,
1370 old_dentry->d_name.len,
1371 &old_de_ino);
1372 if (status) {
1373 status = -ENOENT;
1374 goto bail;
1375 }
1376
1377 /*
1378 * Check for inode number is _not_ due to possible IO errors.
1379 * We might rmdir the source, keep it as pwd of some process
1380 * and merrily kill the link to whatever was created under the
1381 * same name. Goodbye sticky bit ;-<
1382 */
1383 if (old_de_ino != OCFS2_I(old_inode)->ip_blkno) {
1384 status = -ENOENT;
1385 goto bail;
1386 }
1387
1388 /* check if the target already exists (in which case we need
1389 * to delete it */
1390 status = ocfs2_find_files_on_disk(new_dentry->d_name.name,
1391 new_dentry->d_name.len,
1392 &newfe_blkno, new_dir,
1393 &target_lookup_res);
1394 /* The only error we allow here is -ENOENT because the new
1395 * file not existing is perfectly valid. */
1396 if ((status < 0) && (status != -ENOENT)) {
1397 /* If we cannot find the file specified we should just */
1398 /* return the error... */
1399 mlog_errno(status);
1400 goto bail;
1401 }
1402 if (status == 0)
1403 target_exists = 1;
1404
1405 if (!target_exists && new_inode) {
1406 /*
1407 * Target was unlinked by another node while we were
1408 * waiting to get to ocfs2_rename(). There isn't
1409 * anything we can do here to help the situation, so
1410 * bubble up the appropriate error.
1411 */
1412 status = -ENOENT;
1413 goto bail;
1414 }
1415
1416 /* In case we need to overwrite an existing file, we blow it
1417 * away first */
1418 if (target_exists) {
1419 /* VFS didn't think there existed an inode here, but
1420 * someone else in the cluster must have raced our
1421 * rename to create one. Today we error cleanly, in
1422 * the future we should consider calling iget to build
1423 * a new struct inode for this entry. */
1424 if (!new_inode) {
1425 status = -EACCES;
1426
1427 trace_ocfs2_rename_target_exists(new_dentry->d_name.len,
1428 new_dentry->d_name.name);
1429 goto bail;
1430 }
1431
1432 if (OCFS2_I(new_inode)->ip_blkno != newfe_blkno) {
1433 status = -EACCES;
1434
1435 trace_ocfs2_rename_disagree(
1436 (unsigned long long)OCFS2_I(new_inode)->ip_blkno,
1437 (unsigned long long)newfe_blkno,
1438 OCFS2_I(new_inode)->ip_flags);
1439 goto bail;
1440 }
1441
1442 status = ocfs2_inode_lock(new_inode, &newfe_bh, 1);
1443 if (status < 0) {
1444 if (status != -ENOENT)
1445 mlog_errno(status);
1446 goto bail;
1447 }
1448 new_child_locked = 1;
1449
1450 status = ocfs2_remote_dentry_delete(new_dentry);
1451 if (status < 0) {
1452 mlog_errno(status);
1453 goto bail;
1454 }
1455
1456 newfe = (struct ocfs2_dinode *) newfe_bh->b_data;
1457
1458 trace_ocfs2_rename_over_existing(
1459 (unsigned long long)newfe_blkno, newfe_bh, newfe_bh ?
1460 (unsigned long long)newfe_bh->b_blocknr : 0ULL);
1461
1462 if (S_ISDIR(new_inode->i_mode) || (new_inode->i_nlink == 1)) {
1463 status = ocfs2_prepare_orphan_dir(osb, &orphan_dir,
1464 OCFS2_I(new_inode)->ip_blkno,
1465 orphan_name, &orphan_insert,
1466 false);
1467 if (status < 0) {
1468 mlog_errno(status);
1469 goto bail;
1470 }
1471 should_add_orphan = true;
1472 }
1473 } else {
1474 BUG_ON(d_inode(new_dentry->d_parent) != new_dir);
1475
1476 status = ocfs2_check_dir_for_entry(new_dir,
1477 new_dentry->d_name.name,
1478 new_dentry->d_name.len);
1479 if (status)
1480 goto bail;
1481
1482 status = ocfs2_prepare_dir_for_insert(osb, new_dir, new_dir_bh,
1483 new_dentry->d_name.name,
1484 new_dentry->d_name.len,
1485 &target_insert);
1486 if (status < 0) {
1487 mlog_errno(status);
1488 goto bail;
1489 }
1490 }
1491
1492 handle = ocfs2_start_trans(osb, ocfs2_rename_credits(osb->sb));
1493 if (IS_ERR(handle)) {
1494 status = PTR_ERR(handle);
1495 handle = NULL;
1496 mlog_errno(status);
1497 goto bail;
1498 }
1499
1500 if (target_exists) {
1501 if (S_ISDIR(new_inode->i_mode)) {
1502 if (new_inode->i_nlink != 2 ||
1503 !ocfs2_empty_dir(new_inode)) {
1504 status = -ENOTEMPTY;
1505 goto bail;
1506 }
1507 }
1508 status = ocfs2_journal_access_di(handle, INODE_CACHE(new_inode),
1509 newfe_bh,
1510 OCFS2_JOURNAL_ACCESS_WRITE);
1511 if (status < 0) {
1512 mlog_errno(status);
1513 goto bail;
1514 }
1515
1516 /* change the dirent to point to the correct inode */
1517 status = ocfs2_update_entry(new_dir, handle, &target_lookup_res,
1518 old_inode);
1519 if (status < 0) {
1520 mlog_errno(status);
1521 goto bail;
1522 }
1523 new_dir->i_version++;
1524
1525 if (S_ISDIR(new_inode->i_mode))
1526 ocfs2_set_links_count(newfe, 0);
1527 else
1528 ocfs2_add_links_count(newfe, -1);
1529 ocfs2_journal_dirty(handle, newfe_bh);
1530 if (should_add_orphan) {
1531 status = ocfs2_orphan_add(osb, handle, new_inode,
1532 newfe_bh, orphan_name,
1533 &orphan_insert, orphan_dir, false);
1534 if (status < 0) {
1535 mlog_errno(status);
1536 goto bail;
1537 }
1538 }
1539 } else {
1540 /* if the name was not found in new_dir, add it now */
1541 status = ocfs2_add_entry(handle, new_dentry, old_inode,
1542 OCFS2_I(old_inode)->ip_blkno,
1543 new_dir_bh, &target_insert);
1544 }
1545
1546 old_inode->i_ctime = current_time(old_inode);
1547 mark_inode_dirty(old_inode);
1548
1549 status = ocfs2_journal_access_di(handle, INODE_CACHE(old_inode),
1550 old_inode_bh,
1551 OCFS2_JOURNAL_ACCESS_WRITE);
1552 if (status >= 0) {
1553 old_di = (struct ocfs2_dinode *) old_inode_bh->b_data;
1554
1555 old_di->i_ctime = cpu_to_le64(old_inode->i_ctime.tv_sec);
1556 old_di->i_ctime_nsec = cpu_to_le32(old_inode->i_ctime.tv_nsec);
1557 ocfs2_journal_dirty(handle, old_inode_bh);
1558 } else
1559 mlog_errno(status);
1560
1561 /*
1562 * Now that the name has been added to new_dir, remove the old name.
1563 *
1564 * We don't keep any directory entry context around until now
1565 * because the insert might have changed the type of directory
1566 * we're dealing with.
1567 */
1568 status = ocfs2_find_entry(old_dentry->d_name.name,
1569 old_dentry->d_name.len, old_dir,
1570 &old_entry_lookup);
1571 if (status) {
1572 if (!is_journal_aborted(osb->journal->j_journal)) {
1573 ocfs2_error(osb->sb, "new entry %.*s is added, but old entry %.*s "
1574 "is not deleted.",
1575 new_dentry->d_name.len, new_dentry->d_name.name,
1576 old_dentry->d_name.len, old_dentry->d_name.name);
1577 }
1578 goto bail;
1579 }
1580
1581 status = ocfs2_delete_entry(handle, old_dir, &old_entry_lookup);
1582 if (status < 0) {
1583 mlog_errno(status);
1584 if (!is_journal_aborted(osb->journal->j_journal)) {
1585 ocfs2_error(osb->sb, "new entry %.*s is added, but old entry %.*s "
1586 "is not deleted.",
1587 new_dentry->d_name.len, new_dentry->d_name.name,
1588 old_dentry->d_name.len, old_dentry->d_name.name);
1589 }
1590 goto bail;
1591 }
1592
1593 if (new_inode) {
1594 drop_nlink(new_inode);
1595 new_inode->i_ctime = current_time(new_inode);
1596 }
1597 old_dir->i_ctime = old_dir->i_mtime = current_time(old_dir);
1598
1599 if (update_dot_dot) {
1600 status = ocfs2_update_entry(old_inode, handle,
1601 &old_inode_dot_dot_res, new_dir);
1602 drop_nlink(old_dir);
1603 if (new_inode) {
1604 drop_nlink(new_inode);
1605 } else {
1606 inc_nlink(new_dir);
1607 mark_inode_dirty(new_dir);
1608 }
1609 }
1610 mark_inode_dirty(old_dir);
1611 ocfs2_mark_inode_dirty(handle, old_dir, old_dir_bh);
1612 if (new_inode) {
1613 mark_inode_dirty(new_inode);
1614 ocfs2_mark_inode_dirty(handle, new_inode, newfe_bh);
1615 }
1616
1617 if (old_dir != new_dir) {
1618 /* Keep the same times on both directories.*/
1619 new_dir->i_ctime = new_dir->i_mtime = old_dir->i_ctime;
1620
1621 /*
1622 * This will also pick up the i_nlink change from the
1623 * block above.
1624 */
1625 ocfs2_mark_inode_dirty(handle, new_dir, new_dir_bh);
1626 }
1627
1628 if (old_dir_nlink != old_dir->i_nlink) {
1629 if (!old_dir_bh) {
1630 mlog(ML_ERROR, "need to change nlink for old dir "
1631 "%llu from %d to %d but bh is NULL!\n",
1632 (unsigned long long)OCFS2_I(old_dir)->ip_blkno,
1633 (int)old_dir_nlink, old_dir->i_nlink);
1634 } else {
1635 struct ocfs2_dinode *fe;
1636 status = ocfs2_journal_access_di(handle,
1637 INODE_CACHE(old_dir),
1638 old_dir_bh,
1639 OCFS2_JOURNAL_ACCESS_WRITE);
1640 fe = (struct ocfs2_dinode *) old_dir_bh->b_data;
1641 ocfs2_set_links_count(fe, old_dir->i_nlink);
1642 ocfs2_journal_dirty(handle, old_dir_bh);
1643 }
1644 }
1645 ocfs2_dentry_move(old_dentry, new_dentry, old_dir, new_dir);
1646 status = 0;
1647 bail:
1648 if (handle)
1649 ocfs2_commit_trans(osb, handle);
1650
1651 if (orphan_dir) {
1652 /* This was locked for us in ocfs2_prepare_orphan_dir() */
1653 ocfs2_inode_unlock(orphan_dir, 1);
1654 inode_unlock(orphan_dir);
1655 iput(orphan_dir);
1656 }
1657
1658 if (new_child_locked)
1659 ocfs2_inode_unlock(new_inode, 1);
1660
1661 if (old_child_locked)
1662 ocfs2_inode_unlock(old_inode, 1);
1663
1664 if (parents_locked)
1665 ocfs2_double_unlock(old_dir, new_dir);
1666
1667 if (rename_lock)
1668 ocfs2_rename_unlock(osb);
1669
1670 if (new_inode)
1671 sync_mapping_buffers(old_inode->i_mapping);
1672
1673 iput(new_inode);
1674
1675 ocfs2_free_dir_lookup_result(&target_lookup_res);
1676 ocfs2_free_dir_lookup_result(&old_entry_lookup);
1677 ocfs2_free_dir_lookup_result(&old_inode_dot_dot_res);
1678 ocfs2_free_dir_lookup_result(&orphan_insert);
1679 ocfs2_free_dir_lookup_result(&target_insert);
1680
1681 brelse(newfe_bh);
1682 brelse(old_inode_bh);
1683 brelse(old_dir_bh);
1684 brelse(new_dir_bh);
1685
1686 if (status)
1687 mlog_errno(status);
1688
1689 return status;
1690 }
1691
1692 /*
1693 * we expect i_size = strlen(symname). Copy symname into the file
1694 * data, including the null terminator.
1695 */
1696 static int ocfs2_create_symlink_data(struct ocfs2_super *osb,
1697 handle_t *handle,
1698 struct inode *inode,
1699 const char *symname)
1700 {
1701 struct buffer_head **bhs = NULL;
1702 const char *c;
1703 struct super_block *sb = osb->sb;
1704 u64 p_blkno, p_blocks;
1705 int virtual, blocks, status, i, bytes_left;
1706
1707 bytes_left = i_size_read(inode) + 1;
1708 /* we can't trust i_blocks because we're actually going to
1709 * write i_size + 1 bytes. */
1710 blocks = (bytes_left + sb->s_blocksize - 1) >> sb->s_blocksize_bits;
1711
1712 trace_ocfs2_create_symlink_data((unsigned long long)inode->i_blocks,
1713 i_size_read(inode), blocks);
1714
1715 /* Sanity check -- make sure we're going to fit. */
1716 if (bytes_left >
1717 ocfs2_clusters_to_bytes(sb, OCFS2_I(inode)->ip_clusters)) {
1718 status = -EIO;
1719 mlog_errno(status);
1720 goto bail;
1721 }
1722
1723 bhs = kcalloc(blocks, sizeof(struct buffer_head *), GFP_KERNEL);
1724 if (!bhs) {
1725 status = -ENOMEM;
1726 mlog_errno(status);
1727 goto bail;
1728 }
1729
1730 status = ocfs2_extent_map_get_blocks(inode, 0, &p_blkno, &p_blocks,
1731 NULL);
1732 if (status < 0) {
1733 mlog_errno(status);
1734 goto bail;
1735 }
1736
1737 /* links can never be larger than one cluster so we know this
1738 * is all going to be contiguous, but do a sanity check
1739 * anyway. */
1740 if ((p_blocks << sb->s_blocksize_bits) < bytes_left) {
1741 status = -EIO;
1742 mlog_errno(status);
1743 goto bail;
1744 }
1745
1746 virtual = 0;
1747 while(bytes_left > 0) {
1748 c = &symname[virtual * sb->s_blocksize];
1749
1750 bhs[virtual] = sb_getblk(sb, p_blkno);
1751 if (!bhs[virtual]) {
1752 status = -ENOMEM;
1753 mlog_errno(status);
1754 goto bail;
1755 }
1756 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode),
1757 bhs[virtual]);
1758
1759 status = ocfs2_journal_access(handle, INODE_CACHE(inode),
1760 bhs[virtual],
1761 OCFS2_JOURNAL_ACCESS_CREATE);
1762 if (status < 0) {
1763 mlog_errno(status);
1764 goto bail;
1765 }
1766
1767 memset(bhs[virtual]->b_data, 0, sb->s_blocksize);
1768
1769 memcpy(bhs[virtual]->b_data, c,
1770 (bytes_left > sb->s_blocksize) ? sb->s_blocksize :
1771 bytes_left);
1772
1773 ocfs2_journal_dirty(handle, bhs[virtual]);
1774
1775 virtual++;
1776 p_blkno++;
1777 bytes_left -= sb->s_blocksize;
1778 }
1779
1780 status = 0;
1781 bail:
1782
1783 if (bhs) {
1784 for(i = 0; i < blocks; i++)
1785 brelse(bhs[i]);
1786 kfree(bhs);
1787 }
1788
1789 if (status)
1790 mlog_errno(status);
1791 return status;
1792 }
1793
1794 static int ocfs2_symlink(struct inode *dir,
1795 struct dentry *dentry,
1796 const char *symname)
1797 {
1798 int status, l, credits;
1799 u64 newsize;
1800 struct ocfs2_super *osb = NULL;
1801 struct inode *inode = NULL;
1802 struct super_block *sb;
1803 struct buffer_head *new_fe_bh = NULL;
1804 struct buffer_head *parent_fe_bh = NULL;
1805 struct ocfs2_dinode *fe = NULL;
1806 struct ocfs2_dinode *dirfe;
1807 handle_t *handle = NULL;
1808 struct ocfs2_alloc_context *inode_ac = NULL;
1809 struct ocfs2_alloc_context *data_ac = NULL;
1810 struct ocfs2_alloc_context *xattr_ac = NULL;
1811 int want_clusters = 0;
1812 int xattr_credits = 0;
1813 struct ocfs2_security_xattr_info si = {
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 ocfs2_commit_trans(osb, handle);
2035
2036 ocfs2_inode_unlock(dir, 1);
2037 if (did_block_signals)
2038 ocfs2_unblock_signals(&oldset);
2039
2040 brelse(new_fe_bh);
2041 brelse(parent_fe_bh);
2042 kfree(si.value);
2043 ocfs2_free_dir_lookup_result(&lookup);
2044 if (inode_ac)
2045 ocfs2_free_alloc_context(inode_ac);
2046 if (data_ac)
2047 ocfs2_free_alloc_context(data_ac);
2048 if (xattr_ac)
2049 ocfs2_free_alloc_context(xattr_ac);
2050 if ((status < 0) && inode) {
2051 if (dl)
2052 ocfs2_cleanup_add_entry_failure(osb, dentry, inode);
2053
2054 OCFS2_I(inode)->ip_flags |= OCFS2_INODE_SKIP_ORPHAN_DIR;
2055 clear_nlink(inode);
2056 iput(inode);
2057 }
2058
2059 if (status)
2060 mlog_errno(status);
2061
2062 return status;
2063 }
2064
2065 static int ocfs2_blkno_stringify(u64 blkno, char *name)
2066 {
2067 int status, namelen;
2068
2069 namelen = snprintf(name, OCFS2_ORPHAN_NAMELEN + 1, "%016llx",
2070 (long long)blkno);
2071 if (namelen <= 0) {
2072 if (namelen)
2073 status = namelen;
2074 else
2075 status = -EINVAL;
2076 mlog_errno(status);
2077 goto bail;
2078 }
2079 if (namelen != OCFS2_ORPHAN_NAMELEN) {
2080 status = -EINVAL;
2081 mlog_errno(status);
2082 goto bail;
2083 }
2084
2085 trace_ocfs2_blkno_stringify(blkno, name, namelen);
2086
2087 status = 0;
2088 bail:
2089 if (status < 0)
2090 mlog_errno(status);
2091 return status;
2092 }
2093
2094 static int ocfs2_lookup_lock_orphan_dir(struct ocfs2_super *osb,
2095 struct inode **ret_orphan_dir,
2096 struct buffer_head **ret_orphan_dir_bh)
2097 {
2098 struct inode *orphan_dir_inode;
2099 struct buffer_head *orphan_dir_bh = NULL;
2100 int ret = 0;
2101
2102 orphan_dir_inode = ocfs2_get_system_file_inode(osb,
2103 ORPHAN_DIR_SYSTEM_INODE,
2104 osb->slot_num);
2105 if (!orphan_dir_inode) {
2106 ret = -ENOENT;
2107 mlog_errno(ret);
2108 return ret;
2109 }
2110
2111 inode_lock(orphan_dir_inode);
2112
2113 ret = ocfs2_inode_lock(orphan_dir_inode, &orphan_dir_bh, 1);
2114 if (ret < 0) {
2115 inode_unlock(orphan_dir_inode);
2116 iput(orphan_dir_inode);
2117
2118 mlog_errno(ret);
2119 return ret;
2120 }
2121
2122 *ret_orphan_dir = orphan_dir_inode;
2123 *ret_orphan_dir_bh = orphan_dir_bh;
2124
2125 return 0;
2126 }
2127
2128 static int __ocfs2_prepare_orphan_dir(struct inode *orphan_dir_inode,
2129 struct buffer_head *orphan_dir_bh,
2130 u64 blkno,
2131 char *name,
2132 struct ocfs2_dir_lookup_result *lookup,
2133 bool dio)
2134 {
2135 int ret;
2136 struct ocfs2_super *osb = OCFS2_SB(orphan_dir_inode->i_sb);
2137 int namelen = dio ?
2138 (OCFS2_DIO_ORPHAN_PREFIX_LEN + OCFS2_ORPHAN_NAMELEN) :
2139 OCFS2_ORPHAN_NAMELEN;
2140
2141 if (dio) {
2142 ret = snprintf(name, OCFS2_DIO_ORPHAN_PREFIX_LEN + 1, "%s",
2143 OCFS2_DIO_ORPHAN_PREFIX);
2144 if (ret != OCFS2_DIO_ORPHAN_PREFIX_LEN) {
2145 ret = -EINVAL;
2146 mlog_errno(ret);
2147 return ret;
2148 }
2149
2150 ret = ocfs2_blkno_stringify(blkno,
2151 name + OCFS2_DIO_ORPHAN_PREFIX_LEN);
2152 } else
2153 ret = ocfs2_blkno_stringify(blkno, name);
2154 if (ret < 0) {
2155 mlog_errno(ret);
2156 return ret;
2157 }
2158
2159 ret = ocfs2_prepare_dir_for_insert(osb, orphan_dir_inode,
2160 orphan_dir_bh, name,
2161 namelen, lookup);
2162 if (ret < 0) {
2163 mlog_errno(ret);
2164 return ret;
2165 }
2166
2167 return 0;
2168 }
2169
2170 /**
2171 * ocfs2_prepare_orphan_dir() - Prepare an orphan directory for
2172 * insertion of an orphan.
2173 * @osb: ocfs2 file system
2174 * @ret_orphan_dir: Orphan dir inode - returned locked!
2175 * @blkno: Actual block number of the inode to be inserted into orphan dir.
2176 * @lookup: dir lookup result, to be passed back into functions like
2177 * ocfs2_orphan_add
2178 *
2179 * Returns zero on success and the ret_orphan_dir, name and lookup
2180 * fields will be populated.
2181 *
2182 * Returns non-zero on failure.
2183 */
2184 static int ocfs2_prepare_orphan_dir(struct ocfs2_super *osb,
2185 struct inode **ret_orphan_dir,
2186 u64 blkno,
2187 char *name,
2188 struct ocfs2_dir_lookup_result *lookup,
2189 bool dio)
2190 {
2191 struct inode *orphan_dir_inode = NULL;
2192 struct buffer_head *orphan_dir_bh = NULL;
2193 int ret = 0;
2194
2195 ret = ocfs2_lookup_lock_orphan_dir(osb, &orphan_dir_inode,
2196 &orphan_dir_bh);
2197 if (ret < 0) {
2198 mlog_errno(ret);
2199 return ret;
2200 }
2201
2202 ret = __ocfs2_prepare_orphan_dir(orphan_dir_inode, orphan_dir_bh,
2203 blkno, name, lookup, dio);
2204 if (ret < 0) {
2205 mlog_errno(ret);
2206 goto out;
2207 }
2208
2209 *ret_orphan_dir = orphan_dir_inode;
2210
2211 out:
2212 brelse(orphan_dir_bh);
2213
2214 if (ret) {
2215 ocfs2_inode_unlock(orphan_dir_inode, 1);
2216 inode_unlock(orphan_dir_inode);
2217 iput(orphan_dir_inode);
2218 }
2219
2220 if (ret)
2221 mlog_errno(ret);
2222 return ret;
2223 }
2224
2225 static int ocfs2_orphan_add(struct ocfs2_super *osb,
2226 handle_t *handle,
2227 struct inode *inode,
2228 struct buffer_head *fe_bh,
2229 char *name,
2230 struct ocfs2_dir_lookup_result *lookup,
2231 struct inode *orphan_dir_inode,
2232 bool dio)
2233 {
2234 struct buffer_head *orphan_dir_bh = NULL;
2235 int status = 0;
2236 struct ocfs2_dinode *orphan_fe;
2237 struct ocfs2_dinode *fe = (struct ocfs2_dinode *) fe_bh->b_data;
2238 int namelen = dio ?
2239 (OCFS2_DIO_ORPHAN_PREFIX_LEN + OCFS2_ORPHAN_NAMELEN) :
2240 OCFS2_ORPHAN_NAMELEN;
2241
2242 trace_ocfs2_orphan_add_begin(
2243 (unsigned long long)OCFS2_I(inode)->ip_blkno);
2244
2245 status = ocfs2_read_inode_block(orphan_dir_inode, &orphan_dir_bh);
2246 if (status < 0) {
2247 mlog_errno(status);
2248 goto leave;
2249 }
2250
2251 status = ocfs2_journal_access_di(handle,
2252 INODE_CACHE(orphan_dir_inode),
2253 orphan_dir_bh,
2254 OCFS2_JOURNAL_ACCESS_WRITE);
2255 if (status < 0) {
2256 mlog_errno(status);
2257 goto leave;
2258 }
2259
2260 /*
2261 * We're going to journal the change of i_flags and i_orphaned_slot.
2262 * It's safe anyway, though some callers may duplicate the journaling.
2263 * Journaling within the func just make the logic look more
2264 * straightforward.
2265 */
2266 status = ocfs2_journal_access_di(handle,
2267 INODE_CACHE(inode),
2268 fe_bh,
2269 OCFS2_JOURNAL_ACCESS_WRITE);
2270 if (status < 0) {
2271 mlog_errno(status);
2272 goto leave;
2273 }
2274
2275 /* we're a cluster, and nlink can change on disk from
2276 * underneath us... */
2277 orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data;
2278 if (S_ISDIR(inode->i_mode))
2279 ocfs2_add_links_count(orphan_fe, 1);
2280 set_nlink(orphan_dir_inode, ocfs2_read_links_count(orphan_fe));
2281 ocfs2_journal_dirty(handle, orphan_dir_bh);
2282
2283 status = __ocfs2_add_entry(handle, orphan_dir_inode, name,
2284 namelen, inode,
2285 OCFS2_I(inode)->ip_blkno,
2286 orphan_dir_bh, lookup);
2287 if (status < 0) {
2288 mlog_errno(status);
2289 goto rollback;
2290 }
2291
2292 if (dio) {
2293 /* Update flag OCFS2_DIO_ORPHANED_FL and record the orphan
2294 * slot.
2295 */
2296 fe->i_flags |= cpu_to_le32(OCFS2_DIO_ORPHANED_FL);
2297 fe->i_dio_orphaned_slot = cpu_to_le16(osb->slot_num);
2298 } else {
2299 fe->i_flags |= cpu_to_le32(OCFS2_ORPHANED_FL);
2300 OCFS2_I(inode)->ip_flags &= ~OCFS2_INODE_SKIP_ORPHAN_DIR;
2301
2302 /* Record which orphan dir our inode now resides
2303 * in. delete_inode will use this to determine which orphan
2304 * dir to lock. */
2305 fe->i_orphaned_slot = cpu_to_le16(osb->slot_num);
2306 }
2307
2308 ocfs2_journal_dirty(handle, fe_bh);
2309
2310 trace_ocfs2_orphan_add_end((unsigned long long)OCFS2_I(inode)->ip_blkno,
2311 osb->slot_num);
2312
2313 rollback:
2314 if (status < 0) {
2315 if (S_ISDIR(inode->i_mode))
2316 ocfs2_add_links_count(orphan_fe, -1);
2317 set_nlink(orphan_dir_inode, ocfs2_read_links_count(orphan_fe));
2318 }
2319
2320 leave:
2321 brelse(orphan_dir_bh);
2322
2323 return status;
2324 }
2325
2326 /* unlike orphan_add, we expect the orphan dir to already be locked here. */
2327 int ocfs2_orphan_del(struct ocfs2_super *osb,
2328 handle_t *handle,
2329 struct inode *orphan_dir_inode,
2330 struct inode *inode,
2331 struct buffer_head *orphan_dir_bh,
2332 bool dio)
2333 {
2334 const int namelen = OCFS2_DIO_ORPHAN_PREFIX_LEN + OCFS2_ORPHAN_NAMELEN;
2335 char name[namelen + 1];
2336 struct ocfs2_dinode *orphan_fe;
2337 int status = 0;
2338 struct ocfs2_dir_lookup_result lookup = { NULL, };
2339
2340 if (dio) {
2341 status = snprintf(name, OCFS2_DIO_ORPHAN_PREFIX_LEN + 1, "%s",
2342 OCFS2_DIO_ORPHAN_PREFIX);
2343 if (status != OCFS2_DIO_ORPHAN_PREFIX_LEN) {
2344 status = -EINVAL;
2345 mlog_errno(status);
2346 return status;
2347 }
2348
2349 status = ocfs2_blkno_stringify(OCFS2_I(inode)->ip_blkno,
2350 name + OCFS2_DIO_ORPHAN_PREFIX_LEN);
2351 } else
2352 status = ocfs2_blkno_stringify(OCFS2_I(inode)->ip_blkno, name);
2353 if (status < 0) {
2354 mlog_errno(status);
2355 goto leave;
2356 }
2357
2358 trace_ocfs2_orphan_del(
2359 (unsigned long long)OCFS2_I(orphan_dir_inode)->ip_blkno,
2360 name, strlen(name));
2361
2362 status = ocfs2_journal_access_di(handle,
2363 INODE_CACHE(orphan_dir_inode),
2364 orphan_dir_bh,
2365 OCFS2_JOURNAL_ACCESS_WRITE);
2366 if (status < 0) {
2367 mlog_errno(status);
2368 goto leave;
2369 }
2370
2371 /* find it's spot in the orphan directory */
2372 status = ocfs2_find_entry(name, strlen(name), orphan_dir_inode,
2373 &lookup);
2374 if (status) {
2375 mlog_errno(status);
2376 goto leave;
2377 }
2378
2379 /* remove it from the orphan directory */
2380 status = ocfs2_delete_entry(handle, orphan_dir_inode, &lookup);
2381 if (status < 0) {
2382 mlog_errno(status);
2383 goto leave;
2384 }
2385
2386 /* do the i_nlink dance! :) */
2387 orphan_fe = (struct ocfs2_dinode *) orphan_dir_bh->b_data;
2388 if (S_ISDIR(inode->i_mode))
2389 ocfs2_add_links_count(orphan_fe, -1);
2390 set_nlink(orphan_dir_inode, ocfs2_read_links_count(orphan_fe));
2391 ocfs2_journal_dirty(handle, orphan_dir_bh);
2392
2393 leave:
2394 ocfs2_free_dir_lookup_result(&lookup);
2395
2396 if (status)
2397 mlog_errno(status);
2398 return status;
2399 }
2400
2401 /**
2402 * ocfs2_prep_new_orphaned_file() - Prepare the orphan dir to receive a newly
2403 * allocated file. This is different from the typical 'add to orphan dir'
2404 * operation in that the inode does not yet exist. This is a problem because
2405 * the orphan dir stringifies the inode block number to come up with it's
2406 * dirent. Obviously if the inode does not yet exist we have a chicken and egg
2407 * problem. This function works around it by calling deeper into the orphan
2408 * and suballoc code than other callers. Use this only by necessity.
2409 * @dir: The directory which this inode will ultimately wind up under - not the
2410 * orphan dir!
2411 * @dir_bh: buffer_head the @dir inode block
2412 * @orphan_name: string of length (CFS2_ORPHAN_NAMELEN + 1). Will be filled
2413 * with the string to be used for orphan dirent. Pass back to the orphan dir
2414 * code.
2415 * @ret_orphan_dir: orphan dir inode returned to be passed back into orphan
2416 * dir code.
2417 * @ret_di_blkno: block number where the new inode will be allocated.
2418 * @orphan_insert: Dir insert context to be passed back into orphan dir code.
2419 * @ret_inode_ac: Inode alloc context to be passed back to the allocator.
2420 *
2421 * Returns zero on success and the ret_orphan_dir, name and lookup
2422 * fields will be populated.
2423 *
2424 * Returns non-zero on failure.
2425 */
2426 static int ocfs2_prep_new_orphaned_file(struct inode *dir,
2427 struct buffer_head *dir_bh,
2428 char *orphan_name,
2429 struct inode **ret_orphan_dir,
2430 u64 *ret_di_blkno,
2431 struct ocfs2_dir_lookup_result *orphan_insert,
2432 struct ocfs2_alloc_context **ret_inode_ac)
2433 {
2434 int ret;
2435 u64 di_blkno;
2436 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
2437 struct inode *orphan_dir = NULL;
2438 struct buffer_head *orphan_dir_bh = NULL;
2439 struct ocfs2_alloc_context *inode_ac = NULL;
2440
2441 ret = ocfs2_lookup_lock_orphan_dir(osb, &orphan_dir, &orphan_dir_bh);
2442 if (ret < 0) {
2443 mlog_errno(ret);
2444 return ret;
2445 }
2446
2447 /* reserve an inode spot */
2448 ret = ocfs2_reserve_new_inode(osb, &inode_ac);
2449 if (ret < 0) {
2450 if (ret != -ENOSPC)
2451 mlog_errno(ret);
2452 goto out;
2453 }
2454
2455 ret = ocfs2_find_new_inode_loc(dir, dir_bh, inode_ac,
2456 &di_blkno);
2457 if (ret) {
2458 mlog_errno(ret);
2459 goto out;
2460 }
2461
2462 ret = __ocfs2_prepare_orphan_dir(orphan_dir, orphan_dir_bh,
2463 di_blkno, orphan_name, orphan_insert,
2464 false);
2465 if (ret < 0) {
2466 mlog_errno(ret);
2467 goto out;
2468 }
2469
2470 out:
2471 if (ret == 0) {
2472 *ret_orphan_dir = orphan_dir;
2473 *ret_di_blkno = di_blkno;
2474 *ret_inode_ac = inode_ac;
2475 /*
2476 * orphan_name and orphan_insert are already up to
2477 * date via prepare_orphan_dir
2478 */
2479 } else {
2480 /* Unroll reserve_new_inode* */
2481 if (inode_ac)
2482 ocfs2_free_alloc_context(inode_ac);
2483
2484 /* Unroll orphan dir locking */
2485 inode_unlock(orphan_dir);
2486 ocfs2_inode_unlock(orphan_dir, 1);
2487 iput(orphan_dir);
2488 }
2489
2490 brelse(orphan_dir_bh);
2491
2492 return ret;
2493 }
2494
2495 int ocfs2_create_inode_in_orphan(struct inode *dir,
2496 int mode,
2497 struct inode **new_inode)
2498 {
2499 int status, did_quota_inode = 0;
2500 struct inode *inode = NULL;
2501 struct inode *orphan_dir = NULL;
2502 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
2503 struct ocfs2_dinode *di = NULL;
2504 handle_t *handle = NULL;
2505 char orphan_name[OCFS2_ORPHAN_NAMELEN + 1];
2506 struct buffer_head *parent_di_bh = NULL;
2507 struct buffer_head *new_di_bh = NULL;
2508 struct ocfs2_alloc_context *inode_ac = NULL;
2509 struct ocfs2_dir_lookup_result orphan_insert = { NULL, };
2510 u64 uninitialized_var(di_blkno), suballoc_loc;
2511 u16 suballoc_bit;
2512
2513 status = ocfs2_inode_lock(dir, &parent_di_bh, 1);
2514 if (status < 0) {
2515 if (status != -ENOENT)
2516 mlog_errno(status);
2517 return status;
2518 }
2519
2520 status = ocfs2_prep_new_orphaned_file(dir, parent_di_bh,
2521 orphan_name, &orphan_dir,
2522 &di_blkno, &orphan_insert, &inode_ac);
2523 if (status < 0) {
2524 if (status != -ENOSPC)
2525 mlog_errno(status);
2526 goto leave;
2527 }
2528
2529 inode = ocfs2_get_init_inode(dir, mode);
2530 if (IS_ERR(inode)) {
2531 status = PTR_ERR(inode);
2532 inode = NULL;
2533 mlog_errno(status);
2534 goto leave;
2535 }
2536
2537 handle = ocfs2_start_trans(osb, ocfs2_mknod_credits(osb->sb, 0, 0));
2538 if (IS_ERR(handle)) {
2539 status = PTR_ERR(handle);
2540 handle = NULL;
2541 mlog_errno(status);
2542 goto leave;
2543 }
2544
2545 status = dquot_alloc_inode(inode);
2546 if (status)
2547 goto leave;
2548 did_quota_inode = 1;
2549
2550 status = ocfs2_claim_new_inode_at_loc(handle, dir, inode_ac,
2551 &suballoc_loc,
2552 &suballoc_bit, di_blkno);
2553 if (status < 0) {
2554 mlog_errno(status);
2555 goto leave;
2556 }
2557
2558 clear_nlink(inode);
2559 /* do the real work now. */
2560 status = __ocfs2_mknod_locked(dir, inode,
2561 0, &new_di_bh, parent_di_bh, handle,
2562 inode_ac, di_blkno, suballoc_loc,
2563 suballoc_bit);
2564 if (status < 0) {
2565 mlog_errno(status);
2566 goto leave;
2567 }
2568
2569 di = (struct ocfs2_dinode *)new_di_bh->b_data;
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
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
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
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 };
Ubuntu Artful kernel mirror