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