1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* -*- mode: c; c-basic-offset: 8; -*-
3 * vim: noexpandtab sw=8 ts=8 sts=0:
7 * Create and rename file, directory, symlinks
9 * Copyright (C) 2002, 2004 Oracle. All rights reserved.
11 * Portions of this code from linux/fs/ext3/dir.c
13 * Copyright (C) 1992, 1993, 1994, 1995
14 * Remy Card (card@masi.ibp.fr)
15 * Laboratoire MASI - Institut Blaise pascal
16 * Universite Pierre et Marie Curie (Paris VI)
20 * linux/fs/minix/dir.c
22 * Copyright (C) 1991, 1992 Linux Torvalds
26 #include <linux/types.h>
27 #include <linux/slab.h>
28 #include <linux/highmem.h>
29 #include <linux/quotaops.h>
30 #include <linux/iversion.h>
32 #include <cluster/masklog.h>
40 #include "extent_map.h"
52 #include "ocfs2_trace.h"
54 #include "buffer_head_io.h"
56 static int ocfs2_mknod_locked(struct ocfs2_super
*osb
,
60 struct buffer_head
**new_fe_bh
,
61 struct buffer_head
*parent_fe_bh
,
63 struct ocfs2_alloc_context
*inode_ac
);
65 static int ocfs2_prepare_orphan_dir(struct ocfs2_super
*osb
,
66 struct inode
**ret_orphan_dir
,
69 struct ocfs2_dir_lookup_result
*lookup
,
72 static int ocfs2_orphan_add(struct ocfs2_super
*osb
,
75 struct buffer_head
*fe_bh
,
77 struct ocfs2_dir_lookup_result
*lookup
,
78 struct inode
*orphan_dir_inode
,
81 static int ocfs2_create_symlink_data(struct ocfs2_super
*osb
,
86 static int ocfs2_double_lock(struct ocfs2_super
*osb
,
87 struct buffer_head
**bh1
,
89 struct buffer_head
**bh2
,
93 static void ocfs2_double_unlock(struct inode
*inode1
, struct inode
*inode2
);
94 /* An orphan dir name is an 8 byte value, printed as a hex string */
95 #define OCFS2_ORPHAN_NAMELEN ((int)(2 * sizeof(u64)))
97 static struct dentry
*ocfs2_lookup(struct inode
*dir
, struct dentry
*dentry
,
102 struct inode
*inode
= NULL
;
104 struct ocfs2_inode_info
*oi
;
106 trace_ocfs2_lookup(dir
, dentry
, dentry
->d_name
.len
,
108 (unsigned long long)OCFS2_I(dir
)->ip_blkno
, 0);
110 if (dentry
->d_name
.len
> OCFS2_MAX_FILENAME_LEN
) {
111 ret
= ERR_PTR(-ENAMETOOLONG
);
115 status
= ocfs2_inode_lock_nested(dir
, NULL
, 0, OI_LS_PARENT
);
117 if (status
!= -ENOENT
)
119 ret
= ERR_PTR(status
);
123 status
= ocfs2_lookup_ino_from_name(dir
, dentry
->d_name
.name
,
124 dentry
->d_name
.len
, &blkno
);
128 inode
= ocfs2_iget(OCFS2_SB(dir
->i_sb
), blkno
, 0, 0);
130 ret
= ERR_PTR(-EACCES
);
135 /* Clear any orphaned state... If we were able to look up the
136 * inode from a directory, it certainly can't be orphaned. We
137 * might have the bad state from a node which intended to
138 * orphan this inode but crashed before it could commit the
140 spin_lock(&oi
->ip_lock
);
141 oi
->ip_flags
&= ~OCFS2_INODE_MAYBE_ORPHANED
;
142 spin_unlock(&oi
->ip_lock
);
145 ret
= d_splice_alias(inode
, dentry
);
149 * If d_splice_alias() finds a DCACHE_DISCONNECTED
150 * dentry, it will d_move() it on top of ourse. The
151 * return value will indicate this however, so in
152 * those cases, we switch them around for the locking
155 * NOTE: This dentry already has ->d_op set from
156 * ocfs2_get_parent() and ocfs2_get_dentry()
158 if (!IS_ERR_OR_NULL(ret
))
161 status
= ocfs2_dentry_attach_lock(dentry
, inode
,
162 OCFS2_I(dir
)->ip_blkno
);
165 ret
= ERR_PTR(status
);
169 ocfs2_dentry_attach_gen(dentry
);
172 /* Don't drop the cluster lock until *after* the d_add --
173 * unlink on another node will message us to remove that
174 * dentry under this lock so otherwise we can race this with
175 * the downconvert thread and have a stale dentry. */
176 ocfs2_inode_unlock(dir
, 0);
180 trace_ocfs2_lookup_ret(ret
);
185 static struct inode
*ocfs2_get_init_inode(struct inode
*dir
, umode_t mode
)
190 inode
= new_inode(dir
->i_sb
);
192 mlog(ML_ERROR
, "new_inode failed!\n");
193 return ERR_PTR(-ENOMEM
);
196 /* populate as many fields early on as possible - many of
197 * these are used by the support functions here and in
201 inode_init_owner(&init_user_ns
, inode
, dir
, mode
);
202 status
= dquot_initialize(inode
);
204 return ERR_PTR(status
);
209 static void ocfs2_cleanup_add_entry_failure(struct ocfs2_super
*osb
,
210 struct dentry
*dentry
, struct inode
*inode
)
212 struct ocfs2_dentry_lock
*dl
= dentry
->d_fsdata
;
214 ocfs2_simple_drop_lockres(osb
, &dl
->dl_lockres
);
215 ocfs2_lock_res_free(&dl
->dl_lockres
);
216 BUG_ON(dl
->dl_count
!= 1);
217 spin_lock(&dentry_attach_lock
);
218 dentry
->d_fsdata
= NULL
;
219 spin_unlock(&dentry_attach_lock
);
224 static int ocfs2_mknod(struct user_namespace
*mnt_userns
,
226 struct dentry
*dentry
,
231 struct buffer_head
*parent_fe_bh
= NULL
;
232 handle_t
*handle
= NULL
;
233 struct ocfs2_super
*osb
;
234 struct ocfs2_dinode
*dirfe
;
235 struct buffer_head
*new_fe_bh
= NULL
;
236 struct inode
*inode
= NULL
;
237 struct ocfs2_alloc_context
*inode_ac
= NULL
;
238 struct ocfs2_alloc_context
*data_ac
= NULL
;
239 struct ocfs2_alloc_context
*meta_ac
= NULL
;
240 int want_clusters
= 0;
242 int xattr_credits
= 0;
243 struct ocfs2_security_xattr_info si
= {
246 int did_quota_inode
= 0;
247 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
249 int did_block_signals
= 0;
250 struct ocfs2_dentry_lock
*dl
= NULL
;
252 trace_ocfs2_mknod(dir
, dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
,
253 (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
254 (unsigned long)dev
, mode
);
256 status
= dquot_initialize(dir
);
262 /* get our super block */
263 osb
= OCFS2_SB(dir
->i_sb
);
265 status
= ocfs2_inode_lock(dir
, &parent_fe_bh
, 1);
267 if (status
!= -ENOENT
)
272 if (S_ISDIR(mode
) && (dir
->i_nlink
>= ocfs2_link_max(osb
))) {
277 dirfe
= (struct ocfs2_dinode
*) parent_fe_bh
->b_data
;
278 if (!ocfs2_read_links_count(dirfe
)) {
279 /* can't make a file in a deleted directory. */
284 status
= ocfs2_check_dir_for_entry(dir
, dentry
->d_name
.name
,
289 /* get a spot inside the dir. */
290 status
= ocfs2_prepare_dir_for_insert(osb
, dir
, parent_fe_bh
,
292 dentry
->d_name
.len
, &lookup
);
298 /* reserve an inode spot */
299 status
= ocfs2_reserve_new_inode(osb
, &inode_ac
);
301 if (status
!= -ENOSPC
)
306 inode
= ocfs2_get_init_inode(dir
, mode
);
308 status
= PTR_ERR(inode
);
314 /* get security xattr */
315 status
= ocfs2_init_security_get(inode
, dir
, &dentry
->d_name
, &si
);
317 if (status
== -EOPNOTSUPP
)
325 /* calculate meta data/clusters for setting security and acl xattr */
326 status
= ocfs2_calc_xattr_init(dir
, parent_fe_bh
, mode
,
328 &xattr_credits
, &want_meta
);
334 /* Reserve a cluster if creating an extent based directory. */
335 if (S_ISDIR(mode
) && !ocfs2_supports_inline_data(osb
)) {
338 /* Dir indexing requires extra space as well */
339 if (ocfs2_supports_indexed_dirs(osb
))
343 status
= ocfs2_reserve_new_metadata_blocks(osb
, want_meta
, &meta_ac
);
345 if (status
!= -ENOSPC
)
350 status
= ocfs2_reserve_clusters(osb
, want_clusters
, &data_ac
);
352 if (status
!= -ENOSPC
)
357 handle
= ocfs2_start_trans(osb
, ocfs2_mknod_credits(osb
->sb
,
360 if (IS_ERR(handle
)) {
361 status
= PTR_ERR(handle
);
367 /* Starting to change things, restart is no longer possible. */
368 ocfs2_block_signals(&oldset
);
369 did_block_signals
= 1;
371 status
= dquot_alloc_inode(inode
);
376 /* do the real work now. */
377 status
= ocfs2_mknod_locked(osb
, dir
, inode
, dev
,
378 &new_fe_bh
, parent_fe_bh
, handle
,
386 status
= ocfs2_fill_new_dir(osb
, handle
, dir
, inode
,
387 new_fe_bh
, data_ac
, meta_ac
);
393 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(dir
),
395 OCFS2_JOURNAL_ACCESS_WRITE
);
400 ocfs2_add_links_count(dirfe
, 1);
401 ocfs2_journal_dirty(handle
, parent_fe_bh
);
405 status
= ocfs2_init_acl(handle
, inode
, dir
, new_fe_bh
, parent_fe_bh
,
414 status
= ocfs2_init_security_set(handle
, inode
, new_fe_bh
, &si
,
423 * Do this before adding the entry to the directory. We add
424 * also set d_op after success so that ->d_iput() will cleanup
425 * the dentry lock even if ocfs2_add_entry() fails below.
427 status
= ocfs2_dentry_attach_lock(dentry
, inode
,
428 OCFS2_I(dir
)->ip_blkno
);
434 dl
= dentry
->d_fsdata
;
436 status
= ocfs2_add_entry(handle
, dentry
, inode
,
437 OCFS2_I(inode
)->ip_blkno
, parent_fe_bh
,
444 insert_inode_hash(inode
);
445 d_instantiate(dentry
, inode
);
449 if (status
< 0 && S_ISDIR(mode
)) {
450 ocfs2_add_links_count(dirfe
, -1);
455 if (status
< 0 && did_quota_inode
)
456 dquot_free_inode(inode
);
458 ocfs2_commit_trans(osb
, handle
);
460 ocfs2_inode_unlock(dir
, 1);
461 if (did_block_signals
)
462 ocfs2_unblock_signals(&oldset
);
465 brelse(parent_fe_bh
);
468 ocfs2_free_dir_lookup_result(&lookup
);
471 ocfs2_free_alloc_context(inode_ac
);
474 ocfs2_free_alloc_context(data_ac
);
477 ocfs2_free_alloc_context(meta_ac
);
480 * We should call iput after the i_mutex of the bitmap been
481 * unlocked in ocfs2_free_alloc_context, or the
482 * ocfs2_delete_inode will mutex_lock again.
484 if ((status
< 0) && inode
) {
486 ocfs2_cleanup_add_entry_failure(osb
, dentry
, inode
);
488 OCFS2_I(inode
)->ip_flags
|= OCFS2_INODE_SKIP_ORPHAN_DIR
;
499 static int __ocfs2_mknod_locked(struct inode
*dir
,
502 struct buffer_head
**new_fe_bh
,
503 struct buffer_head
*parent_fe_bh
,
505 struct ocfs2_alloc_context
*inode_ac
,
506 u64 fe_blkno
, u64 suballoc_loc
, u16 suballoc_bit
)
509 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
510 struct ocfs2_dinode
*fe
= NULL
;
511 struct ocfs2_extent_list
*fel
;
513 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
514 struct timespec64 ts
;
518 /* populate as many fields early on as possible - many of
519 * these are used by the support functions here and in
521 inode
->i_ino
= ino_from_blkno(osb
->sb
, fe_blkno
);
522 oi
->ip_blkno
= fe_blkno
;
523 spin_lock(&osb
->osb_lock
);
524 inode
->i_generation
= osb
->s_next_generation
++;
525 spin_unlock(&osb
->osb_lock
);
527 *new_fe_bh
= sb_getblk(osb
->sb
, fe_blkno
);
533 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode
), *new_fe_bh
);
535 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
),
537 OCFS2_JOURNAL_ACCESS_CREATE
);
543 fe
= (struct ocfs2_dinode
*) (*new_fe_bh
)->b_data
;
544 memset(fe
, 0, osb
->sb
->s_blocksize
);
546 fe
->i_generation
= cpu_to_le32(inode
->i_generation
);
547 fe
->i_fs_generation
= cpu_to_le32(osb
->fs_generation
);
548 fe
->i_blkno
= cpu_to_le64(fe_blkno
);
549 fe
->i_suballoc_loc
= cpu_to_le64(suballoc_loc
);
550 fe
->i_suballoc_bit
= cpu_to_le16(suballoc_bit
);
551 fe
->i_suballoc_slot
= cpu_to_le16(inode_ac
->ac_alloc_slot
);
552 fe
->i_uid
= cpu_to_le32(i_uid_read(inode
));
553 fe
->i_gid
= cpu_to_le32(i_gid_read(inode
));
554 fe
->i_mode
= cpu_to_le16(inode
->i_mode
);
555 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
))
556 fe
->id1
.dev1
.i_rdev
= cpu_to_le64(huge_encode_dev(dev
));
558 ocfs2_set_links_count(fe
, inode
->i_nlink
);
560 fe
->i_last_eb_blk
= 0;
561 strcpy(fe
->i_signature
, OCFS2_INODE_SIGNATURE
);
562 fe
->i_flags
|= cpu_to_le32(OCFS2_VALID_FL
);
563 ktime_get_real_ts64(&ts
);
564 fe
->i_atime
= fe
->i_ctime
= fe
->i_mtime
=
565 cpu_to_le64(ts
.tv_sec
);
566 fe
->i_mtime_nsec
= fe
->i_ctime_nsec
= fe
->i_atime_nsec
=
567 cpu_to_le32(ts
.tv_nsec
);
571 * If supported, directories start with inline data. If inline
572 * isn't supported, but indexing is, we start them as indexed.
574 feat
= le16_to_cpu(fe
->i_dyn_features
);
575 if (S_ISDIR(inode
->i_mode
) && ocfs2_supports_inline_data(osb
)) {
576 fe
->i_dyn_features
= cpu_to_le16(feat
| OCFS2_INLINE_DATA_FL
);
578 fe
->id2
.i_data
.id_count
= cpu_to_le16(
579 ocfs2_max_inline_data_with_xattr(osb
->sb
, fe
));
581 fel
= &fe
->id2
.i_list
;
582 fel
->l_tree_depth
= 0;
583 fel
->l_next_free_rec
= 0;
584 fel
->l_count
= cpu_to_le16(ocfs2_extent_recs_per_inode(osb
->sb
));
587 ocfs2_journal_dirty(handle
, *new_fe_bh
);
589 ocfs2_populate_inode(inode
, fe
, 1);
590 ocfs2_ci_set_new(osb
, INODE_CACHE(inode
));
591 if (!ocfs2_mount_local(osb
)) {
592 status
= ocfs2_create_new_inode_locks(inode
);
597 ocfs2_update_inode_fsync_trans(handle
, inode
, 1);
612 static int ocfs2_mknod_locked(struct ocfs2_super
*osb
,
616 struct buffer_head
**new_fe_bh
,
617 struct buffer_head
*parent_fe_bh
,
619 struct ocfs2_alloc_context
*inode_ac
)
622 u64 suballoc_loc
, fe_blkno
= 0;
627 status
= ocfs2_claim_new_inode(handle
, dir
, parent_fe_bh
,
628 inode_ac
, &suballoc_loc
,
629 &suballoc_bit
, &fe_blkno
);
635 status
= __ocfs2_mknod_locked(dir
, inode
, dev
, new_fe_bh
,
636 parent_fe_bh
, handle
, inode_ac
,
637 fe_blkno
, suballoc_loc
, suballoc_bit
);
639 u64 bg_blkno
= ocfs2_which_suballoc_group(fe_blkno
, suballoc_bit
);
640 int tmp
= ocfs2_free_suballoc_bits(handle
, inode_ac
->ac_inode
,
641 inode_ac
->ac_bh
, suballoc_bit
, bg_blkno
, 1);
649 static int ocfs2_mkdir(struct user_namespace
*mnt_userns
,
651 struct dentry
*dentry
,
656 trace_ocfs2_mkdir(dir
, dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
,
657 OCFS2_I(dir
)->ip_blkno
, mode
);
658 ret
= ocfs2_mknod(&init_user_ns
, dir
, dentry
, mode
| S_IFDIR
, 0);
665 static int ocfs2_create(struct user_namespace
*mnt_userns
,
667 struct dentry
*dentry
,
673 trace_ocfs2_create(dir
, dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
,
674 (unsigned long long)OCFS2_I(dir
)->ip_blkno
, mode
);
675 ret
= ocfs2_mknod(&init_user_ns
, dir
, dentry
, mode
| S_IFREG
, 0);
682 static int ocfs2_link(struct dentry
*old_dentry
,
684 struct dentry
*dentry
)
687 struct inode
*inode
= d_inode(old_dentry
);
688 struct inode
*old_dir
= d_inode(old_dentry
->d_parent
);
690 struct buffer_head
*fe_bh
= NULL
;
691 struct buffer_head
*old_dir_bh
= NULL
;
692 struct buffer_head
*parent_fe_bh
= NULL
;
693 struct ocfs2_dinode
*fe
= NULL
;
694 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
695 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
699 trace_ocfs2_link((unsigned long long)OCFS2_I(inode
)->ip_blkno
,
700 old_dentry
->d_name
.len
, old_dentry
->d_name
.name
,
701 dentry
->d_name
.len
, dentry
->d_name
.name
);
703 if (S_ISDIR(inode
->i_mode
))
706 err
= dquot_initialize(dir
);
712 err
= ocfs2_double_lock(osb
, &old_dir_bh
, old_dir
,
713 &parent_fe_bh
, dir
, 0);
720 /* make sure both dirs have bhs
721 * get an extra ref on old_dir_bh if old==new */
724 parent_fe_bh
= old_dir_bh
;
725 get_bh(parent_fe_bh
);
727 mlog(ML_ERROR
, "%s: no old_dir_bh!\n", osb
->uuid_str
);
738 err
= ocfs2_lookup_ino_from_name(old_dir
, old_dentry
->d_name
.name
,
739 old_dentry
->d_name
.len
, &old_de_ino
);
746 * Check whether another node removed the source inode while we
749 if (old_de_ino
!= OCFS2_I(inode
)->ip_blkno
) {
754 err
= ocfs2_check_dir_for_entry(dir
, dentry
->d_name
.name
,
759 err
= ocfs2_prepare_dir_for_insert(osb
, dir
, parent_fe_bh
,
761 dentry
->d_name
.len
, &lookup
);
767 err
= ocfs2_inode_lock(inode
, &fe_bh
, 1);
774 fe
= (struct ocfs2_dinode
*) fe_bh
->b_data
;
775 if (ocfs2_read_links_count(fe
) >= ocfs2_link_max(osb
)) {
777 goto out_unlock_inode
;
780 handle
= ocfs2_start_trans(osb
, ocfs2_link_credits(osb
->sb
));
781 if (IS_ERR(handle
)) {
782 err
= PTR_ERR(handle
);
785 goto out_unlock_inode
;
788 /* Starting to change things, restart is no longer possible. */
789 ocfs2_block_signals(&oldset
);
791 err
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
), fe_bh
,
792 OCFS2_JOURNAL_ACCESS_WRITE
);
799 inode
->i_ctime
= current_time(inode
);
800 ocfs2_set_links_count(fe
, inode
->i_nlink
);
801 fe
->i_ctime
= cpu_to_le64(inode
->i_ctime
.tv_sec
);
802 fe
->i_ctime_nsec
= cpu_to_le32(inode
->i_ctime
.tv_nsec
);
803 ocfs2_journal_dirty(handle
, fe_bh
);
805 err
= ocfs2_add_entry(handle
, dentry
, inode
,
806 OCFS2_I(inode
)->ip_blkno
,
807 parent_fe_bh
, &lookup
);
809 ocfs2_add_links_count(fe
, -1);
815 err
= ocfs2_dentry_attach_lock(dentry
, inode
, OCFS2_I(dir
)->ip_blkno
);
822 d_instantiate(dentry
, inode
);
825 ocfs2_commit_trans(osb
, handle
);
826 ocfs2_unblock_signals(&oldset
);
828 ocfs2_inode_unlock(inode
, 1);
831 ocfs2_double_unlock(old_dir
, dir
);
834 brelse(parent_fe_bh
);
837 ocfs2_free_dir_lookup_result(&lookup
);
846 * Takes and drops an exclusive lock on the given dentry. This will
847 * force other nodes to drop it.
849 static int ocfs2_remote_dentry_delete(struct dentry
*dentry
)
853 ret
= ocfs2_dentry_lock(dentry
, 1);
857 ocfs2_dentry_unlock(dentry
, 1);
862 static inline int ocfs2_inode_is_unlinkable(struct inode
*inode
)
864 if (S_ISDIR(inode
->i_mode
)) {
865 if (inode
->i_nlink
== 2)
870 if (inode
->i_nlink
== 1)
875 static int ocfs2_unlink(struct inode
*dir
,
876 struct dentry
*dentry
)
879 int child_locked
= 0;
880 bool is_unlinkable
= false;
881 struct inode
*inode
= d_inode(dentry
);
882 struct inode
*orphan_dir
= NULL
;
883 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
885 struct ocfs2_dinode
*fe
= NULL
;
886 struct buffer_head
*fe_bh
= NULL
;
887 struct buffer_head
*parent_node_bh
= NULL
;
888 handle_t
*handle
= NULL
;
889 char orphan_name
[OCFS2_ORPHAN_NAMELEN
+ 1];
890 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
891 struct ocfs2_dir_lookup_result orphan_insert
= { NULL
, };
893 trace_ocfs2_unlink(dir
, dentry
, dentry
->d_name
.len
,
895 (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
896 (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
898 status
= dquot_initialize(dir
);
904 BUG_ON(d_inode(dentry
->d_parent
) != dir
);
906 if (inode
== osb
->root_inode
)
909 status
= ocfs2_inode_lock_nested(dir
, &parent_node_bh
, 1,
912 if (status
!= -ENOENT
)
917 status
= ocfs2_find_files_on_disk(dentry
->d_name
.name
,
918 dentry
->d_name
.len
, &blkno
, dir
,
921 if (status
!= -ENOENT
)
926 if (OCFS2_I(inode
)->ip_blkno
!= blkno
) {
929 trace_ocfs2_unlink_noent(
930 (unsigned long long)OCFS2_I(inode
)->ip_blkno
,
931 (unsigned long long)blkno
,
932 OCFS2_I(inode
)->ip_flags
);
936 status
= ocfs2_inode_lock(inode
, &fe_bh
, 1);
938 if (status
!= -ENOENT
)
944 if (S_ISDIR(inode
->i_mode
)) {
945 if (inode
->i_nlink
!= 2 || !ocfs2_empty_dir(inode
)) {
951 status
= ocfs2_remote_dentry_delete(dentry
);
953 /* This remote delete should succeed under all normal
959 if (ocfs2_inode_is_unlinkable(inode
)) {
960 status
= ocfs2_prepare_orphan_dir(osb
, &orphan_dir
,
961 OCFS2_I(inode
)->ip_blkno
,
962 orphan_name
, &orphan_insert
,
968 is_unlinkable
= true;
971 handle
= ocfs2_start_trans(osb
, ocfs2_unlink_credits(osb
->sb
));
972 if (IS_ERR(handle
)) {
973 status
= PTR_ERR(handle
);
979 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
), fe_bh
,
980 OCFS2_JOURNAL_ACCESS_WRITE
);
986 fe
= (struct ocfs2_dinode
*) fe_bh
->b_data
;
988 /* delete the name from the parent dir */
989 status
= ocfs2_delete_entry(handle
, dir
, &lookup
);
995 if (S_ISDIR(inode
->i_mode
))
998 ocfs2_set_links_count(fe
, inode
->i_nlink
);
999 ocfs2_journal_dirty(handle
, fe_bh
);
1001 dir
->i_ctime
= dir
->i_mtime
= current_time(dir
);
1002 if (S_ISDIR(inode
->i_mode
))
1005 status
= ocfs2_mark_inode_dirty(handle
, dir
, parent_node_bh
);
1008 if (S_ISDIR(inode
->i_mode
))
1013 if (is_unlinkable
) {
1014 status
= ocfs2_orphan_add(osb
, handle
, inode
, fe_bh
,
1015 orphan_name
, &orphan_insert
, orphan_dir
, false);
1022 ocfs2_commit_trans(osb
, handle
);
1025 /* This was locked for us in ocfs2_prepare_orphan_dir() */
1026 ocfs2_inode_unlock(orphan_dir
, 1);
1027 inode_unlock(orphan_dir
);
1032 ocfs2_inode_unlock(inode
, 1);
1034 ocfs2_inode_unlock(dir
, 1);
1037 brelse(parent_node_bh
);
1039 ocfs2_free_dir_lookup_result(&orphan_insert
);
1040 ocfs2_free_dir_lookup_result(&lookup
);
1042 if (status
&& (status
!= -ENOTEMPTY
) && (status
!= -ENOENT
))
1048 static int ocfs2_check_if_ancestor(struct ocfs2_super
*osb
,
1049 u64 src_inode_no
, u64 dest_inode_no
)
1052 u64 parent_inode_no
= 0;
1053 u64 child_inode_no
= src_inode_no
;
1054 struct inode
*child_inode
;
1056 #define MAX_LOOKUP_TIMES 32
1058 child_inode
= ocfs2_iget(osb
, child_inode_no
, 0, 0);
1059 if (IS_ERR(child_inode
)) {
1060 ret
= PTR_ERR(child_inode
);
1064 ret
= ocfs2_inode_lock(child_inode
, NULL
, 0);
1072 ret
= ocfs2_lookup_ino_from_name(child_inode
, "..", 2,
1074 ocfs2_inode_unlock(child_inode
, 0);
1081 if (parent_inode_no
== dest_inode_no
) {
1086 if (parent_inode_no
== osb
->root_inode
->i_ino
) {
1091 child_inode_no
= parent_inode_no
;
1093 if (++i
>= MAX_LOOKUP_TIMES
) {
1094 mlog_ratelimited(ML_NOTICE
, "max lookup times reached, "
1095 "filesystem may have nested directories, "
1096 "src inode: %llu, dest inode: %llu.\n",
1097 (unsigned long long)src_inode_no
,
1098 (unsigned long long)dest_inode_no
);
1108 * The only place this should be used is rename and link!
1109 * if they have the same id, then the 1st one is the only one locked.
1111 static int ocfs2_double_lock(struct ocfs2_super
*osb
,
1112 struct buffer_head
**bh1
,
1113 struct inode
*inode1
,
1114 struct buffer_head
**bh2
,
1115 struct inode
*inode2
,
1119 int inode1_is_ancestor
, inode2_is_ancestor
;
1120 struct ocfs2_inode_info
*oi1
= OCFS2_I(inode1
);
1121 struct ocfs2_inode_info
*oi2
= OCFS2_I(inode2
);
1123 trace_ocfs2_double_lock((unsigned long long)oi1
->ip_blkno
,
1124 (unsigned long long)oi2
->ip_blkno
);
1131 /* we always want to lock the one with the lower lockid first.
1132 * and if they are nested, we lock ancestor first */
1133 if (oi1
->ip_blkno
!= oi2
->ip_blkno
) {
1134 inode1_is_ancestor
= ocfs2_check_if_ancestor(osb
, oi2
->ip_blkno
,
1136 if (inode1_is_ancestor
< 0) {
1137 status
= inode1_is_ancestor
;
1141 inode2_is_ancestor
= ocfs2_check_if_ancestor(osb
, oi1
->ip_blkno
,
1143 if (inode2_is_ancestor
< 0) {
1144 status
= inode2_is_ancestor
;
1148 if ((inode1_is_ancestor
== 1) ||
1149 (oi1
->ip_blkno
< oi2
->ip_blkno
&&
1150 inode2_is_ancestor
== 0)) {
1151 /* switch id1 and id2 around */
1153 swap(inode2
, inode1
);
1156 status
= ocfs2_inode_lock_nested(inode2
, bh2
, 1,
1157 rename
== 1 ? OI_LS_RENAME1
: OI_LS_PARENT
);
1159 if (status
!= -ENOENT
)
1166 status
= ocfs2_inode_lock_nested(inode1
, bh1
, 1,
1167 rename
== 1 ? OI_LS_RENAME2
: OI_LS_PARENT
);
1170 * An error return must mean that no cluster locks
1171 * were held on function exit.
1173 if (oi1
->ip_blkno
!= oi2
->ip_blkno
) {
1174 ocfs2_inode_unlock(inode2
, 1);
1179 if (status
!= -ENOENT
)
1183 trace_ocfs2_double_lock_end(
1184 (unsigned long long)oi1
->ip_blkno
,
1185 (unsigned long long)oi2
->ip_blkno
);
1193 static void ocfs2_double_unlock(struct inode
*inode1
, struct inode
*inode2
)
1195 ocfs2_inode_unlock(inode1
, 1);
1197 if (inode1
!= inode2
)
1198 ocfs2_inode_unlock(inode2
, 1);
1201 static int ocfs2_rename(struct user_namespace
*mnt_userns
,
1202 struct inode
*old_dir
,
1203 struct dentry
*old_dentry
,
1204 struct inode
*new_dir
,
1205 struct dentry
*new_dentry
,
1208 int status
= 0, rename_lock
= 0, parents_locked
= 0, target_exists
= 0;
1209 int old_child_locked
= 0, new_child_locked
= 0, update_dot_dot
= 0;
1210 struct inode
*old_inode
= d_inode(old_dentry
);
1211 struct inode
*new_inode
= d_inode(new_dentry
);
1212 struct inode
*orphan_dir
= NULL
;
1213 struct ocfs2_dinode
*newfe
= NULL
;
1214 char orphan_name
[OCFS2_ORPHAN_NAMELEN
+ 1];
1215 struct buffer_head
*newfe_bh
= NULL
;
1216 struct buffer_head
*old_inode_bh
= NULL
;
1217 struct ocfs2_super
*osb
= NULL
;
1218 u64 newfe_blkno
, old_de_ino
;
1219 handle_t
*handle
= NULL
;
1220 struct buffer_head
*old_dir_bh
= NULL
;
1221 struct buffer_head
*new_dir_bh
= NULL
;
1222 u32 old_dir_nlink
= old_dir
->i_nlink
;
1223 struct ocfs2_dinode
*old_di
;
1224 struct ocfs2_dir_lookup_result old_inode_dot_dot_res
= { NULL
, };
1225 struct ocfs2_dir_lookup_result target_lookup_res
= { NULL
, };
1226 struct ocfs2_dir_lookup_result old_entry_lookup
= { NULL
, };
1227 struct ocfs2_dir_lookup_result orphan_insert
= { NULL
, };
1228 struct ocfs2_dir_lookup_result target_insert
= { NULL
, };
1229 bool should_add_orphan
= false;
1234 /* At some point it might be nice to break this function up a
1237 trace_ocfs2_rename(old_dir
, old_dentry
, new_dir
, new_dentry
,
1238 old_dentry
->d_name
.len
, old_dentry
->d_name
.name
,
1239 new_dentry
->d_name
.len
, new_dentry
->d_name
.name
);
1241 status
= dquot_initialize(old_dir
);
1246 status
= dquot_initialize(new_dir
);
1252 osb
= OCFS2_SB(old_dir
->i_sb
);
1255 if (!igrab(new_inode
))
1259 /* Assume a directory hierarchy thusly:
1262 * a,b,c, and d are all directories.
1264 * from cwd of 'a' on both nodes:
1268 * And that's why, just like the VFS, we need a file system
1270 if (old_dir
!= new_dir
&& S_ISDIR(old_inode
->i_mode
)) {
1271 status
= ocfs2_rename_lock(osb
);
1278 /* here we cannot guarantee the inodes haven't just been
1279 * changed, so check if they are nested again */
1280 status
= ocfs2_check_if_ancestor(osb
, new_dir
->i_ino
,
1285 } else if (status
== 1) {
1287 trace_ocfs2_rename_not_permitted(
1288 (unsigned long long)old_inode
->i_ino
,
1289 (unsigned long long)new_dir
->i_ino
);
1294 /* if old and new are the same, this'll just do one lock. */
1295 status
= ocfs2_double_lock(osb
, &old_dir_bh
, old_dir
,
1296 &new_dir_bh
, new_dir
, 1);
1303 if (!new_dir
->i_nlink
) {
1308 /* make sure both dirs have bhs
1309 * get an extra ref on old_dir_bh if old==new */
1312 new_dir_bh
= old_dir_bh
;
1315 mlog(ML_ERROR
, "no old_dir_bh!\n");
1322 * Aside from allowing a meta data update, the locking here
1323 * also ensures that the downconvert thread on other nodes
1324 * won't have to concurrently downconvert the inode and the
1327 status
= ocfs2_inode_lock_nested(old_inode
, &old_inode_bh
, 1,
1330 if (status
!= -ENOENT
)
1334 old_child_locked
= 1;
1336 status
= ocfs2_remote_dentry_delete(old_dentry
);
1342 if (S_ISDIR(old_inode
->i_mode
)) {
1343 u64 old_inode_parent
;
1346 status
= ocfs2_find_files_on_disk("..", 2, &old_inode_parent
,
1348 &old_inode_dot_dot_res
);
1354 if (old_inode_parent
!= OCFS2_I(old_dir
)->ip_blkno
) {
1359 if (!new_inode
&& new_dir
!= old_dir
&&
1360 new_dir
->i_nlink
>= ocfs2_link_max(osb
)) {
1366 status
= ocfs2_lookup_ino_from_name(old_dir
, old_dentry
->d_name
.name
,
1367 old_dentry
->d_name
.len
,
1375 * Check for inode number is _not_ due to possible IO errors.
1376 * We might rmdir the source, keep it as pwd of some process
1377 * and merrily kill the link to whatever was created under the
1378 * same name. Goodbye sticky bit ;-<
1380 if (old_de_ino
!= OCFS2_I(old_inode
)->ip_blkno
) {
1385 /* check if the target already exists (in which case we need
1387 status
= ocfs2_find_files_on_disk(new_dentry
->d_name
.name
,
1388 new_dentry
->d_name
.len
,
1389 &newfe_blkno
, new_dir
,
1390 &target_lookup_res
);
1391 /* The only error we allow here is -ENOENT because the new
1392 * file not existing is perfectly valid. */
1393 if ((status
< 0) && (status
!= -ENOENT
)) {
1394 /* If we cannot find the file specified we should just */
1395 /* return the error... */
1402 if (!target_exists
&& new_inode
) {
1404 * Target was unlinked by another node while we were
1405 * waiting to get to ocfs2_rename(). There isn't
1406 * anything we can do here to help the situation, so
1407 * bubble up the appropriate error.
1413 /* In case we need to overwrite an existing file, we blow it
1415 if (target_exists
) {
1416 /* VFS didn't think there existed an inode here, but
1417 * someone else in the cluster must have raced our
1418 * rename to create one. Today we error cleanly, in
1419 * the future we should consider calling iget to build
1420 * a new struct inode for this entry. */
1424 trace_ocfs2_rename_target_exists(new_dentry
->d_name
.len
,
1425 new_dentry
->d_name
.name
);
1429 if (OCFS2_I(new_inode
)->ip_blkno
!= newfe_blkno
) {
1432 trace_ocfs2_rename_disagree(
1433 (unsigned long long)OCFS2_I(new_inode
)->ip_blkno
,
1434 (unsigned long long)newfe_blkno
,
1435 OCFS2_I(new_inode
)->ip_flags
);
1439 status
= ocfs2_inode_lock(new_inode
, &newfe_bh
, 1);
1441 if (status
!= -ENOENT
)
1445 new_child_locked
= 1;
1447 status
= ocfs2_remote_dentry_delete(new_dentry
);
1453 newfe
= (struct ocfs2_dinode
*) newfe_bh
->b_data
;
1455 trace_ocfs2_rename_over_existing(
1456 (unsigned long long)newfe_blkno
, newfe_bh
, newfe_bh
?
1457 (unsigned long long)newfe_bh
->b_blocknr
: 0ULL);
1459 if (S_ISDIR(new_inode
->i_mode
) || (new_inode
->i_nlink
== 1)) {
1460 status
= ocfs2_prepare_orphan_dir(osb
, &orphan_dir
,
1461 OCFS2_I(new_inode
)->ip_blkno
,
1462 orphan_name
, &orphan_insert
,
1468 should_add_orphan
= true;
1471 BUG_ON(d_inode(new_dentry
->d_parent
) != new_dir
);
1473 status
= ocfs2_check_dir_for_entry(new_dir
,
1474 new_dentry
->d_name
.name
,
1475 new_dentry
->d_name
.len
);
1479 status
= ocfs2_prepare_dir_for_insert(osb
, new_dir
, new_dir_bh
,
1480 new_dentry
->d_name
.name
,
1481 new_dentry
->d_name
.len
,
1489 handle
= ocfs2_start_trans(osb
, ocfs2_rename_credits(osb
->sb
));
1490 if (IS_ERR(handle
)) {
1491 status
= PTR_ERR(handle
);
1497 if (target_exists
) {
1498 if (S_ISDIR(new_inode
->i_mode
)) {
1499 if (new_inode
->i_nlink
!= 2 ||
1500 !ocfs2_empty_dir(new_inode
)) {
1501 status
= -ENOTEMPTY
;
1505 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(new_inode
),
1507 OCFS2_JOURNAL_ACCESS_WRITE
);
1513 /* change the dirent to point to the correct inode */
1514 status
= ocfs2_update_entry(new_dir
, handle
, &target_lookup_res
,
1520 inode_inc_iversion(new_dir
);
1522 if (S_ISDIR(new_inode
->i_mode
))
1523 ocfs2_set_links_count(newfe
, 0);
1525 ocfs2_add_links_count(newfe
, -1);
1526 ocfs2_journal_dirty(handle
, newfe_bh
);
1527 if (should_add_orphan
) {
1528 status
= ocfs2_orphan_add(osb
, handle
, new_inode
,
1529 newfe_bh
, orphan_name
,
1530 &orphan_insert
, orphan_dir
, false);
1537 /* if the name was not found in new_dir, add it now */
1538 status
= ocfs2_add_entry(handle
, new_dentry
, old_inode
,
1539 OCFS2_I(old_inode
)->ip_blkno
,
1540 new_dir_bh
, &target_insert
);
1543 old_inode
->i_ctime
= current_time(old_inode
);
1544 mark_inode_dirty(old_inode
);
1546 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(old_inode
),
1548 OCFS2_JOURNAL_ACCESS_WRITE
);
1550 old_di
= (struct ocfs2_dinode
*) old_inode_bh
->b_data
;
1552 old_di
->i_ctime
= cpu_to_le64(old_inode
->i_ctime
.tv_sec
);
1553 old_di
->i_ctime_nsec
= cpu_to_le32(old_inode
->i_ctime
.tv_nsec
);
1554 ocfs2_journal_dirty(handle
, old_inode_bh
);
1559 * Now that the name has been added to new_dir, remove the old name.
1561 * We don't keep any directory entry context around until now
1562 * because the insert might have changed the type of directory
1563 * we're dealing with.
1565 status
= ocfs2_find_entry(old_dentry
->d_name
.name
,
1566 old_dentry
->d_name
.len
, old_dir
,
1569 if (!is_journal_aborted(osb
->journal
->j_journal
)) {
1570 ocfs2_error(osb
->sb
, "new entry %.*s is added, but old entry %.*s "
1572 new_dentry
->d_name
.len
, new_dentry
->d_name
.name
,
1573 old_dentry
->d_name
.len
, old_dentry
->d_name
.name
);
1578 status
= ocfs2_delete_entry(handle
, old_dir
, &old_entry_lookup
);
1581 if (!is_journal_aborted(osb
->journal
->j_journal
)) {
1582 ocfs2_error(osb
->sb
, "new entry %.*s is added, but old entry %.*s "
1584 new_dentry
->d_name
.len
, new_dentry
->d_name
.name
,
1585 old_dentry
->d_name
.len
, old_dentry
->d_name
.name
);
1591 drop_nlink(new_inode
);
1592 new_inode
->i_ctime
= current_time(new_inode
);
1594 old_dir
->i_ctime
= old_dir
->i_mtime
= current_time(old_dir
);
1596 if (update_dot_dot
) {
1597 status
= ocfs2_update_entry(old_inode
, handle
,
1598 &old_inode_dot_dot_res
, new_dir
);
1599 drop_nlink(old_dir
);
1601 drop_nlink(new_inode
);
1604 mark_inode_dirty(new_dir
);
1607 mark_inode_dirty(old_dir
);
1608 ocfs2_mark_inode_dirty(handle
, old_dir
, old_dir_bh
);
1610 mark_inode_dirty(new_inode
);
1611 ocfs2_mark_inode_dirty(handle
, new_inode
, newfe_bh
);
1614 if (old_dir
!= new_dir
) {
1615 /* Keep the same times on both directories.*/
1616 new_dir
->i_ctime
= new_dir
->i_mtime
= old_dir
->i_ctime
;
1619 * This will also pick up the i_nlink change from the
1622 ocfs2_mark_inode_dirty(handle
, new_dir
, new_dir_bh
);
1625 if (old_dir_nlink
!= old_dir
->i_nlink
) {
1627 mlog(ML_ERROR
, "need to change nlink for old dir "
1628 "%llu from %d to %d but bh is NULL!\n",
1629 (unsigned long long)OCFS2_I(old_dir
)->ip_blkno
,
1630 (int)old_dir_nlink
, old_dir
->i_nlink
);
1632 struct ocfs2_dinode
*fe
;
1633 status
= ocfs2_journal_access_di(handle
,
1634 INODE_CACHE(old_dir
),
1636 OCFS2_JOURNAL_ACCESS_WRITE
);
1637 fe
= (struct ocfs2_dinode
*) old_dir_bh
->b_data
;
1638 ocfs2_set_links_count(fe
, old_dir
->i_nlink
);
1639 ocfs2_journal_dirty(handle
, old_dir_bh
);
1642 ocfs2_dentry_move(old_dentry
, new_dentry
, old_dir
, new_dir
);
1646 ocfs2_commit_trans(osb
, handle
);
1649 /* This was locked for us in ocfs2_prepare_orphan_dir() */
1650 ocfs2_inode_unlock(orphan_dir
, 1);
1651 inode_unlock(orphan_dir
);
1655 if (new_child_locked
)
1656 ocfs2_inode_unlock(new_inode
, 1);
1658 if (old_child_locked
)
1659 ocfs2_inode_unlock(old_inode
, 1);
1662 ocfs2_double_unlock(old_dir
, new_dir
);
1665 ocfs2_rename_unlock(osb
);
1668 sync_mapping_buffers(old_inode
->i_mapping
);
1672 ocfs2_free_dir_lookup_result(&target_lookup_res
);
1673 ocfs2_free_dir_lookup_result(&old_entry_lookup
);
1674 ocfs2_free_dir_lookup_result(&old_inode_dot_dot_res
);
1675 ocfs2_free_dir_lookup_result(&orphan_insert
);
1676 ocfs2_free_dir_lookup_result(&target_insert
);
1679 brelse(old_inode_bh
);
1690 * we expect i_size = strlen(symname). Copy symname into the file
1691 * data, including the null terminator.
1693 static int ocfs2_create_symlink_data(struct ocfs2_super
*osb
,
1695 struct inode
*inode
,
1696 const char *symname
)
1698 struct buffer_head
**bhs
= NULL
;
1700 struct super_block
*sb
= osb
->sb
;
1701 u64 p_blkno
, p_blocks
;
1702 int virtual, blocks
, status
, i
, bytes_left
;
1704 bytes_left
= i_size_read(inode
) + 1;
1705 /* we can't trust i_blocks because we're actually going to
1706 * write i_size + 1 bytes. */
1707 blocks
= (bytes_left
+ sb
->s_blocksize
- 1) >> sb
->s_blocksize_bits
;
1709 trace_ocfs2_create_symlink_data((unsigned long long)inode
->i_blocks
,
1710 i_size_read(inode
), blocks
);
1712 /* Sanity check -- make sure we're going to fit. */
1714 ocfs2_clusters_to_bytes(sb
, OCFS2_I(inode
)->ip_clusters
)) {
1720 bhs
= kcalloc(blocks
, sizeof(struct buffer_head
*), GFP_KERNEL
);
1727 status
= ocfs2_extent_map_get_blocks(inode
, 0, &p_blkno
, &p_blocks
,
1734 /* links can never be larger than one cluster so we know this
1735 * is all going to be contiguous, but do a sanity check
1737 if ((p_blocks
<< sb
->s_blocksize_bits
) < bytes_left
) {
1744 while(bytes_left
> 0) {
1745 c
= &symname
[virtual * sb
->s_blocksize
];
1747 bhs
[virtual] = sb_getblk(sb
, p_blkno
);
1748 if (!bhs
[virtual]) {
1753 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode
),
1756 status
= ocfs2_journal_access(handle
, INODE_CACHE(inode
),
1758 OCFS2_JOURNAL_ACCESS_CREATE
);
1764 memset(bhs
[virtual]->b_data
, 0, sb
->s_blocksize
);
1766 memcpy(bhs
[virtual]->b_data
, c
,
1767 (bytes_left
> sb
->s_blocksize
) ? sb
->s_blocksize
:
1770 ocfs2_journal_dirty(handle
, bhs
[virtual]);
1774 bytes_left
-= sb
->s_blocksize
;
1781 for(i
= 0; i
< blocks
; i
++)
1791 static int ocfs2_symlink(struct user_namespace
*mnt_userns
,
1793 struct dentry
*dentry
,
1794 const char *symname
)
1796 int status
, l
, credits
;
1798 struct ocfs2_super
*osb
= NULL
;
1799 struct inode
*inode
= NULL
;
1800 struct super_block
*sb
;
1801 struct buffer_head
*new_fe_bh
= NULL
;
1802 struct buffer_head
*parent_fe_bh
= NULL
;
1803 struct ocfs2_dinode
*fe
= NULL
;
1804 struct ocfs2_dinode
*dirfe
;
1805 handle_t
*handle
= NULL
;
1806 struct ocfs2_alloc_context
*inode_ac
= NULL
;
1807 struct ocfs2_alloc_context
*data_ac
= NULL
;
1808 struct ocfs2_alloc_context
*xattr_ac
= NULL
;
1809 int want_clusters
= 0;
1810 int xattr_credits
= 0;
1811 struct ocfs2_security_xattr_info si
= {
1814 int did_quota
= 0, did_quota_inode
= 0;
1815 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
1817 int did_block_signals
= 0;
1818 struct ocfs2_dentry_lock
*dl
= NULL
;
1820 trace_ocfs2_symlink_begin(dir
, dentry
, symname
,
1821 dentry
->d_name
.len
, dentry
->d_name
.name
);
1823 status
= dquot_initialize(dir
);
1832 l
= strlen(symname
) + 1;
1834 credits
= ocfs2_calc_symlink_credits(sb
);
1836 /* lock the parent directory */
1837 status
= ocfs2_inode_lock(dir
, &parent_fe_bh
, 1);
1839 if (status
!= -ENOENT
)
1844 dirfe
= (struct ocfs2_dinode
*) parent_fe_bh
->b_data
;
1845 if (!ocfs2_read_links_count(dirfe
)) {
1846 /* can't make a file in a deleted directory. */
1851 status
= ocfs2_check_dir_for_entry(dir
, dentry
->d_name
.name
,
1852 dentry
->d_name
.len
);
1856 status
= ocfs2_prepare_dir_for_insert(osb
, dir
, parent_fe_bh
,
1857 dentry
->d_name
.name
,
1858 dentry
->d_name
.len
, &lookup
);
1864 status
= ocfs2_reserve_new_inode(osb
, &inode_ac
);
1866 if (status
!= -ENOSPC
)
1871 inode
= ocfs2_get_init_inode(dir
, S_IFLNK
| S_IRWXUGO
);
1872 if (IS_ERR(inode
)) {
1873 status
= PTR_ERR(inode
);
1879 /* get security xattr */
1880 status
= ocfs2_init_security_get(inode
, dir
, &dentry
->d_name
, &si
);
1882 if (status
== -EOPNOTSUPP
)
1890 /* calculate meta data/clusters for setting security xattr */
1892 status
= ocfs2_calc_security_init(dir
, &si
, &want_clusters
,
1893 &xattr_credits
, &xattr_ac
);
1900 /* don't reserve bitmap space for fast symlinks. */
1901 if (l
> ocfs2_fast_symlink_chars(sb
))
1904 status
= ocfs2_reserve_clusters(osb
, want_clusters
, &data_ac
);
1906 if (status
!= -ENOSPC
)
1911 handle
= ocfs2_start_trans(osb
, credits
+ xattr_credits
);
1912 if (IS_ERR(handle
)) {
1913 status
= PTR_ERR(handle
);
1919 /* Starting to change things, restart is no longer possible. */
1920 ocfs2_block_signals(&oldset
);
1921 did_block_signals
= 1;
1923 status
= dquot_alloc_inode(inode
);
1926 did_quota_inode
= 1;
1928 trace_ocfs2_symlink_create(dir
, dentry
, dentry
->d_name
.len
,
1929 dentry
->d_name
.name
,
1930 (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
1933 status
= ocfs2_mknod_locked(osb
, dir
, inode
,
1934 0, &new_fe_bh
, parent_fe_bh
, handle
,
1941 fe
= (struct ocfs2_dinode
*) new_fe_bh
->b_data
;
1944 inode
->i_op
= &ocfs2_symlink_inode_operations
;
1945 inode_nohighmem(inode
);
1946 if (l
> ocfs2_fast_symlink_chars(sb
)) {
1949 status
= dquot_alloc_space_nodirty(inode
,
1950 ocfs2_clusters_to_bytes(osb
->sb
, 1));
1954 inode
->i_mapping
->a_ops
= &ocfs2_aops
;
1955 status
= ocfs2_add_inode_data(osb
, inode
, &offset
, 1, 0,
1957 handle
, data_ac
, NULL
,
1960 if (status
!= -ENOSPC
&& status
!= -EINTR
) {
1962 "Failed to extend file to %llu\n",
1963 (unsigned long long)newsize
);
1969 i_size_write(inode
, newsize
);
1970 inode
->i_blocks
= ocfs2_inode_sector_count(inode
);
1972 inode
->i_mapping
->a_ops
= &ocfs2_fast_symlink_aops
;
1973 memcpy((char *) fe
->id2
.i_symlink
, symname
, l
);
1974 i_size_write(inode
, newsize
);
1975 inode
->i_blocks
= 0;
1978 status
= ocfs2_mark_inode_dirty(handle
, inode
, new_fe_bh
);
1984 if (!ocfs2_inode_is_fast_symlink(inode
)) {
1985 status
= ocfs2_create_symlink_data(osb
, handle
, inode
,
1994 status
= ocfs2_init_security_set(handle
, inode
, new_fe_bh
, &si
,
2003 * Do this before adding the entry to the directory. We add
2004 * also set d_op after success so that ->d_iput() will cleanup
2005 * the dentry lock even if ocfs2_add_entry() fails below.
2007 status
= ocfs2_dentry_attach_lock(dentry
, inode
, OCFS2_I(dir
)->ip_blkno
);
2013 dl
= dentry
->d_fsdata
;
2015 status
= ocfs2_add_entry(handle
, dentry
, inode
,
2016 le64_to_cpu(fe
->i_blkno
), parent_fe_bh
,
2023 insert_inode_hash(inode
);
2024 d_instantiate(dentry
, inode
);
2026 if (status
< 0 && did_quota
)
2027 dquot_free_space_nodirty(inode
,
2028 ocfs2_clusters_to_bytes(osb
->sb
, 1));
2029 if (status
< 0 && did_quota_inode
)
2030 dquot_free_inode(inode
);
2032 ocfs2_commit_trans(osb
, handle
);
2034 ocfs2_inode_unlock(dir
, 1);
2035 if (did_block_signals
)
2036 ocfs2_unblock_signals(&oldset
);
2039 brelse(parent_fe_bh
);
2041 ocfs2_free_dir_lookup_result(&lookup
);
2043 ocfs2_free_alloc_context(inode_ac
);
2045 ocfs2_free_alloc_context(data_ac
);
2047 ocfs2_free_alloc_context(xattr_ac
);
2048 if ((status
< 0) && inode
) {
2050 ocfs2_cleanup_add_entry_failure(osb
, dentry
, inode
);
2052 OCFS2_I(inode
)->ip_flags
|= OCFS2_INODE_SKIP_ORPHAN_DIR
;
2063 static int ocfs2_blkno_stringify(u64 blkno
, char *name
)
2065 int status
, namelen
;
2067 namelen
= snprintf(name
, OCFS2_ORPHAN_NAMELEN
+ 1, "%016llx",
2077 if (namelen
!= OCFS2_ORPHAN_NAMELEN
) {
2083 trace_ocfs2_blkno_stringify(blkno
, name
, namelen
);
2092 static int ocfs2_lookup_lock_orphan_dir(struct ocfs2_super
*osb
,
2093 struct inode
**ret_orphan_dir
,
2094 struct buffer_head
**ret_orphan_dir_bh
)
2096 struct inode
*orphan_dir_inode
;
2097 struct buffer_head
*orphan_dir_bh
= NULL
;
2100 orphan_dir_inode
= ocfs2_get_system_file_inode(osb
,
2101 ORPHAN_DIR_SYSTEM_INODE
,
2103 if (!orphan_dir_inode
) {
2109 inode_lock(orphan_dir_inode
);
2111 ret
= ocfs2_inode_lock(orphan_dir_inode
, &orphan_dir_bh
, 1);
2113 inode_unlock(orphan_dir_inode
);
2114 iput(orphan_dir_inode
);
2120 *ret_orphan_dir
= orphan_dir_inode
;
2121 *ret_orphan_dir_bh
= orphan_dir_bh
;
2126 static int __ocfs2_prepare_orphan_dir(struct inode
*orphan_dir_inode
,
2127 struct buffer_head
*orphan_dir_bh
,
2130 struct ocfs2_dir_lookup_result
*lookup
,
2134 struct ocfs2_super
*osb
= OCFS2_SB(orphan_dir_inode
->i_sb
);
2136 (OCFS2_DIO_ORPHAN_PREFIX_LEN
+ OCFS2_ORPHAN_NAMELEN
) :
2137 OCFS2_ORPHAN_NAMELEN
;
2140 ret
= snprintf(name
, OCFS2_DIO_ORPHAN_PREFIX_LEN
+ 1, "%s",
2141 OCFS2_DIO_ORPHAN_PREFIX
);
2142 if (ret
!= OCFS2_DIO_ORPHAN_PREFIX_LEN
) {
2148 ret
= ocfs2_blkno_stringify(blkno
,
2149 name
+ OCFS2_DIO_ORPHAN_PREFIX_LEN
);
2151 ret
= ocfs2_blkno_stringify(blkno
, name
);
2157 ret
= ocfs2_prepare_dir_for_insert(osb
, orphan_dir_inode
,
2158 orphan_dir_bh
, name
,
2169 * ocfs2_prepare_orphan_dir() - Prepare an orphan directory for
2170 * insertion of an orphan.
2171 * @osb: ocfs2 file system
2172 * @ret_orphan_dir: Orphan dir inode - returned locked!
2173 * @blkno: Actual block number of the inode to be inserted into orphan dir.
2174 * @lookup: dir lookup result, to be passed back into functions like
2177 * Returns zero on success and the ret_orphan_dir, name and lookup
2178 * fields will be populated.
2180 * Returns non-zero on failure.
2182 static int ocfs2_prepare_orphan_dir(struct ocfs2_super
*osb
,
2183 struct inode
**ret_orphan_dir
,
2186 struct ocfs2_dir_lookup_result
*lookup
,
2189 struct inode
*orphan_dir_inode
= NULL
;
2190 struct buffer_head
*orphan_dir_bh
= NULL
;
2193 ret
= ocfs2_lookup_lock_orphan_dir(osb
, &orphan_dir_inode
,
2200 ret
= __ocfs2_prepare_orphan_dir(orphan_dir_inode
, orphan_dir_bh
,
2201 blkno
, name
, lookup
, dio
);
2207 *ret_orphan_dir
= orphan_dir_inode
;
2210 brelse(orphan_dir_bh
);
2213 ocfs2_inode_unlock(orphan_dir_inode
, 1);
2214 inode_unlock(orphan_dir_inode
);
2215 iput(orphan_dir_inode
);
2223 static int ocfs2_orphan_add(struct ocfs2_super
*osb
,
2225 struct inode
*inode
,
2226 struct buffer_head
*fe_bh
,
2228 struct ocfs2_dir_lookup_result
*lookup
,
2229 struct inode
*orphan_dir_inode
,
2232 struct buffer_head
*orphan_dir_bh
= NULL
;
2234 struct ocfs2_dinode
*orphan_fe
;
2235 struct ocfs2_dinode
*fe
= (struct ocfs2_dinode
*) fe_bh
->b_data
;
2237 (OCFS2_DIO_ORPHAN_PREFIX_LEN
+ OCFS2_ORPHAN_NAMELEN
) :
2238 OCFS2_ORPHAN_NAMELEN
;
2240 trace_ocfs2_orphan_add_begin(
2241 (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
2243 status
= ocfs2_read_inode_block(orphan_dir_inode
, &orphan_dir_bh
);
2249 status
= ocfs2_journal_access_di(handle
,
2250 INODE_CACHE(orphan_dir_inode
),
2252 OCFS2_JOURNAL_ACCESS_WRITE
);
2259 * We're going to journal the change of i_flags and i_orphaned_slot.
2260 * It's safe anyway, though some callers may duplicate the journaling.
2261 * Journaling within the func just make the logic look more
2264 status
= ocfs2_journal_access_di(handle
,
2267 OCFS2_JOURNAL_ACCESS_WRITE
);
2273 /* we're a cluster, and nlink can change on disk from
2274 * underneath us... */
2275 orphan_fe
= (struct ocfs2_dinode
*) orphan_dir_bh
->b_data
;
2276 if (S_ISDIR(inode
->i_mode
))
2277 ocfs2_add_links_count(orphan_fe
, 1);
2278 set_nlink(orphan_dir_inode
, ocfs2_read_links_count(orphan_fe
));
2279 ocfs2_journal_dirty(handle
, orphan_dir_bh
);
2281 status
= __ocfs2_add_entry(handle
, orphan_dir_inode
, name
,
2283 OCFS2_I(inode
)->ip_blkno
,
2284 orphan_dir_bh
, lookup
);
2291 /* Update flag OCFS2_DIO_ORPHANED_FL and record the orphan
2294 fe
->i_flags
|= cpu_to_le32(OCFS2_DIO_ORPHANED_FL
);
2295 fe
->i_dio_orphaned_slot
= cpu_to_le16(osb
->slot_num
);
2297 fe
->i_flags
|= cpu_to_le32(OCFS2_ORPHANED_FL
);
2298 OCFS2_I(inode
)->ip_flags
&= ~OCFS2_INODE_SKIP_ORPHAN_DIR
;
2300 /* Record which orphan dir our inode now resides
2301 * in. delete_inode will use this to determine which orphan
2303 fe
->i_orphaned_slot
= cpu_to_le16(osb
->slot_num
);
2306 ocfs2_journal_dirty(handle
, fe_bh
);
2308 trace_ocfs2_orphan_add_end((unsigned long long)OCFS2_I(inode
)->ip_blkno
,
2313 if (S_ISDIR(inode
->i_mode
))
2314 ocfs2_add_links_count(orphan_fe
, -1);
2315 set_nlink(orphan_dir_inode
, ocfs2_read_links_count(orphan_fe
));
2319 brelse(orphan_dir_bh
);
2324 /* unlike orphan_add, we expect the orphan dir to already be locked here. */
2325 int ocfs2_orphan_del(struct ocfs2_super
*osb
,
2327 struct inode
*orphan_dir_inode
,
2328 struct inode
*inode
,
2329 struct buffer_head
*orphan_dir_bh
,
2332 char name
[OCFS2_DIO_ORPHAN_PREFIX_LEN
+ OCFS2_ORPHAN_NAMELEN
+ 1];
2333 struct ocfs2_dinode
*orphan_fe
;
2335 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
2338 status
= snprintf(name
, OCFS2_DIO_ORPHAN_PREFIX_LEN
+ 1, "%s",
2339 OCFS2_DIO_ORPHAN_PREFIX
);
2340 if (status
!= OCFS2_DIO_ORPHAN_PREFIX_LEN
) {
2346 status
= ocfs2_blkno_stringify(OCFS2_I(inode
)->ip_blkno
,
2347 name
+ OCFS2_DIO_ORPHAN_PREFIX_LEN
);
2349 status
= ocfs2_blkno_stringify(OCFS2_I(inode
)->ip_blkno
, name
);
2355 trace_ocfs2_orphan_del(
2356 (unsigned long long)OCFS2_I(orphan_dir_inode
)->ip_blkno
,
2357 name
, strlen(name
));
2359 status
= ocfs2_journal_access_di(handle
,
2360 INODE_CACHE(orphan_dir_inode
),
2362 OCFS2_JOURNAL_ACCESS_WRITE
);
2368 /* find it's spot in the orphan directory */
2369 status
= ocfs2_find_entry(name
, strlen(name
), orphan_dir_inode
,
2376 /* remove it from the orphan directory */
2377 status
= ocfs2_delete_entry(handle
, orphan_dir_inode
, &lookup
);
2383 /* do the i_nlink dance! :) */
2384 orphan_fe
= (struct ocfs2_dinode
*) orphan_dir_bh
->b_data
;
2385 if (S_ISDIR(inode
->i_mode
))
2386 ocfs2_add_links_count(orphan_fe
, -1);
2387 set_nlink(orphan_dir_inode
, ocfs2_read_links_count(orphan_fe
));
2388 ocfs2_journal_dirty(handle
, orphan_dir_bh
);
2391 ocfs2_free_dir_lookup_result(&lookup
);
2399 * ocfs2_prep_new_orphaned_file() - Prepare the orphan dir to receive a newly
2400 * allocated file. This is different from the typical 'add to orphan dir'
2401 * operation in that the inode does not yet exist. This is a problem because
2402 * the orphan dir stringifies the inode block number to come up with it's
2403 * dirent. Obviously if the inode does not yet exist we have a chicken and egg
2404 * problem. This function works around it by calling deeper into the orphan
2405 * and suballoc code than other callers. Use this only by necessity.
2406 * @dir: The directory which this inode will ultimately wind up under - not the
2408 * @dir_bh: buffer_head the @dir inode block
2409 * @orphan_name: string of length (CFS2_ORPHAN_NAMELEN + 1). Will be filled
2410 * with the string to be used for orphan dirent. Pass back to the orphan dir
2412 * @ret_orphan_dir: orphan dir inode returned to be passed back into orphan
2414 * @ret_di_blkno: block number where the new inode will be allocated.
2415 * @orphan_insert: Dir insert context to be passed back into orphan dir code.
2416 * @ret_inode_ac: Inode alloc context to be passed back to the allocator.
2418 * Returns zero on success and the ret_orphan_dir, name and lookup
2419 * fields will be populated.
2421 * Returns non-zero on failure.
2423 static int ocfs2_prep_new_orphaned_file(struct inode
*dir
,
2424 struct buffer_head
*dir_bh
,
2426 struct inode
**ret_orphan_dir
,
2428 struct ocfs2_dir_lookup_result
*orphan_insert
,
2429 struct ocfs2_alloc_context
**ret_inode_ac
)
2433 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
2434 struct inode
*orphan_dir
= NULL
;
2435 struct buffer_head
*orphan_dir_bh
= NULL
;
2436 struct ocfs2_alloc_context
*inode_ac
= NULL
;
2438 ret
= ocfs2_lookup_lock_orphan_dir(osb
, &orphan_dir
, &orphan_dir_bh
);
2444 /* reserve an inode spot */
2445 ret
= ocfs2_reserve_new_inode(osb
, &inode_ac
);
2452 ret
= ocfs2_find_new_inode_loc(dir
, dir_bh
, inode_ac
,
2459 ret
= __ocfs2_prepare_orphan_dir(orphan_dir
, orphan_dir_bh
,
2460 di_blkno
, orphan_name
, orphan_insert
,
2469 *ret_orphan_dir
= orphan_dir
;
2470 *ret_di_blkno
= di_blkno
;
2471 *ret_inode_ac
= inode_ac
;
2473 * orphan_name and orphan_insert are already up to
2474 * date via prepare_orphan_dir
2477 /* Unroll reserve_new_inode* */
2479 ocfs2_free_alloc_context(inode_ac
);
2481 /* Unroll orphan dir locking */
2482 inode_unlock(orphan_dir
);
2483 ocfs2_inode_unlock(orphan_dir
, 1);
2487 brelse(orphan_dir_bh
);
2492 int ocfs2_create_inode_in_orphan(struct inode
*dir
,
2494 struct inode
**new_inode
)
2496 int status
, did_quota_inode
= 0;
2497 struct inode
*inode
= NULL
;
2498 struct inode
*orphan_dir
= NULL
;
2499 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
2500 handle_t
*handle
= NULL
;
2501 char orphan_name
[OCFS2_ORPHAN_NAMELEN
+ 1];
2502 struct buffer_head
*parent_di_bh
= NULL
;
2503 struct buffer_head
*new_di_bh
= NULL
;
2504 struct ocfs2_alloc_context
*inode_ac
= NULL
;
2505 struct ocfs2_dir_lookup_result orphan_insert
= { NULL
, };
2506 u64 di_blkno
, suballoc_loc
;
2509 status
= ocfs2_inode_lock(dir
, &parent_di_bh
, 1);
2511 if (status
!= -ENOENT
)
2516 status
= ocfs2_prep_new_orphaned_file(dir
, parent_di_bh
,
2517 orphan_name
, &orphan_dir
,
2518 &di_blkno
, &orphan_insert
, &inode_ac
);
2520 if (status
!= -ENOSPC
)
2525 inode
= ocfs2_get_init_inode(dir
, mode
);
2526 if (IS_ERR(inode
)) {
2527 status
= PTR_ERR(inode
);
2533 handle
= ocfs2_start_trans(osb
, ocfs2_mknod_credits(osb
->sb
, 0, 0));
2534 if (IS_ERR(handle
)) {
2535 status
= PTR_ERR(handle
);
2541 status
= dquot_alloc_inode(inode
);
2544 did_quota_inode
= 1;
2546 status
= ocfs2_claim_new_inode_at_loc(handle
, dir
, inode_ac
,
2548 &suballoc_bit
, di_blkno
);
2555 /* do the real work now. */
2556 status
= __ocfs2_mknod_locked(dir
, inode
,
2557 0, &new_di_bh
, parent_di_bh
, handle
,
2558 inode_ac
, di_blkno
, suballoc_loc
,
2565 status
= ocfs2_orphan_add(osb
, handle
, inode
, new_di_bh
, orphan_name
,
2566 &orphan_insert
, orphan_dir
, false);
2572 /* get open lock so that only nodes can't remove it from orphan dir. */
2573 status
= ocfs2_open_lock(inode
);
2577 insert_inode_hash(inode
);
2579 if (status
< 0 && did_quota_inode
)
2580 dquot_free_inode(inode
);
2582 ocfs2_commit_trans(osb
, handle
);
2585 /* This was locked for us in ocfs2_prepare_orphan_dir() */
2586 ocfs2_inode_unlock(orphan_dir
, 1);
2587 inode_unlock(orphan_dir
);
2591 if ((status
< 0) && inode
) {
2597 ocfs2_free_alloc_context(inode_ac
);
2604 ocfs2_free_dir_lookup_result(&orphan_insert
);
2606 ocfs2_inode_unlock(dir
, 1);
2607 brelse(parent_di_bh
);
2611 int ocfs2_add_inode_to_orphan(struct ocfs2_super
*osb
,
2612 struct inode
*inode
)
2614 char orphan_name
[OCFS2_DIO_ORPHAN_PREFIX_LEN
+ OCFS2_ORPHAN_NAMELEN
+ 1];
2615 struct inode
*orphan_dir_inode
= NULL
;
2616 struct ocfs2_dir_lookup_result orphan_insert
= { NULL
, };
2617 struct buffer_head
*di_bh
= NULL
;
2619 handle_t
*handle
= NULL
;
2620 struct ocfs2_dinode
*di
= NULL
;
2622 status
= ocfs2_inode_lock(inode
, &di_bh
, 1);
2628 di
= (struct ocfs2_dinode
*) di_bh
->b_data
;
2630 * Another append dio crashed?
2631 * If so, manually recover it first.
2633 if (unlikely(di
->i_flags
& cpu_to_le32(OCFS2_DIO_ORPHANED_FL
))) {
2634 status
= ocfs2_truncate_file(inode
, di_bh
, i_size_read(inode
));
2636 if (status
!= -ENOSPC
)
2638 goto bail_unlock_inode
;
2641 status
= ocfs2_del_inode_from_orphan(osb
, inode
, di_bh
, 0, 0);
2644 goto bail_unlock_inode
;
2648 status
= ocfs2_prepare_orphan_dir(osb
, &orphan_dir_inode
,
2649 OCFS2_I(inode
)->ip_blkno
,
2655 goto bail_unlock_inode
;
2658 handle
= ocfs2_start_trans(osb
,
2659 OCFS2_INODE_ADD_TO_ORPHAN_CREDITS
);
2660 if (IS_ERR(handle
)) {
2661 status
= PTR_ERR(handle
);
2662 goto bail_unlock_orphan
;
2665 status
= ocfs2_orphan_add(osb
, handle
, inode
, di_bh
, orphan_name
,
2666 &orphan_insert
, orphan_dir_inode
, true);
2670 ocfs2_commit_trans(osb
, handle
);
2673 ocfs2_inode_unlock(orphan_dir_inode
, 1);
2674 inode_unlock(orphan_dir_inode
);
2675 iput(orphan_dir_inode
);
2677 ocfs2_free_dir_lookup_result(&orphan_insert
);
2680 ocfs2_inode_unlock(inode
, 1);
2687 int ocfs2_del_inode_from_orphan(struct ocfs2_super
*osb
,
2688 struct inode
*inode
, struct buffer_head
*di_bh
,
2689 int update_isize
, loff_t end
)
2691 struct inode
*orphan_dir_inode
= NULL
;
2692 struct buffer_head
*orphan_dir_bh
= NULL
;
2693 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
2694 handle_t
*handle
= NULL
;
2697 orphan_dir_inode
= ocfs2_get_system_file_inode(osb
,
2698 ORPHAN_DIR_SYSTEM_INODE
,
2699 le16_to_cpu(di
->i_dio_orphaned_slot
));
2700 if (!orphan_dir_inode
) {
2706 inode_lock(orphan_dir_inode
);
2707 status
= ocfs2_inode_lock(orphan_dir_inode
, &orphan_dir_bh
, 1);
2709 inode_unlock(orphan_dir_inode
);
2710 iput(orphan_dir_inode
);
2715 handle
= ocfs2_start_trans(osb
,
2716 OCFS2_INODE_DEL_FROM_ORPHAN_CREDITS
);
2717 if (IS_ERR(handle
)) {
2718 status
= PTR_ERR(handle
);
2719 goto bail_unlock_orphan
;
2722 BUG_ON(!(di
->i_flags
& cpu_to_le32(OCFS2_DIO_ORPHANED_FL
)));
2724 status
= ocfs2_orphan_del(osb
, handle
, orphan_dir_inode
,
2725 inode
, orphan_dir_bh
, true);
2731 status
= ocfs2_journal_access_di(handle
,
2734 OCFS2_JOURNAL_ACCESS_WRITE
);
2740 di
->i_flags
&= ~cpu_to_le32(OCFS2_DIO_ORPHANED_FL
);
2741 di
->i_dio_orphaned_slot
= 0;
2744 status
= ocfs2_set_inode_size(handle
, inode
, di_bh
, end
);
2748 ocfs2_journal_dirty(handle
, di_bh
);
2751 ocfs2_commit_trans(osb
, handle
);
2754 ocfs2_inode_unlock(orphan_dir_inode
, 1);
2755 inode_unlock(orphan_dir_inode
);
2756 brelse(orphan_dir_bh
);
2757 iput(orphan_dir_inode
);
2763 int ocfs2_mv_orphaned_inode_to_new(struct inode
*dir
,
2764 struct inode
*inode
,
2765 struct dentry
*dentry
)
2768 struct buffer_head
*parent_di_bh
= NULL
;
2769 handle_t
*handle
= NULL
;
2770 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
2771 struct ocfs2_dinode
*dir_di
, *di
;
2772 struct inode
*orphan_dir_inode
= NULL
;
2773 struct buffer_head
*orphan_dir_bh
= NULL
;
2774 struct buffer_head
*di_bh
= NULL
;
2775 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
2777 trace_ocfs2_mv_orphaned_inode_to_new(dir
, dentry
,
2778 dentry
->d_name
.len
, dentry
->d_name
.name
,
2779 (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
2780 (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
2782 status
= ocfs2_inode_lock(dir
, &parent_di_bh
, 1);
2784 if (status
!= -ENOENT
)
2789 dir_di
= (struct ocfs2_dinode
*) parent_di_bh
->b_data
;
2790 if (!dir_di
->i_links_count
) {
2791 /* can't make a file in a deleted directory. */
2796 status
= ocfs2_check_dir_for_entry(dir
, dentry
->d_name
.name
,
2797 dentry
->d_name
.len
);
2801 /* get a spot inside the dir. */
2802 status
= ocfs2_prepare_dir_for_insert(osb
, dir
, parent_di_bh
,
2803 dentry
->d_name
.name
,
2804 dentry
->d_name
.len
, &lookup
);
2810 orphan_dir_inode
= ocfs2_get_system_file_inode(osb
,
2811 ORPHAN_DIR_SYSTEM_INODE
,
2813 if (!orphan_dir_inode
) {
2819 inode_lock(orphan_dir_inode
);
2821 status
= ocfs2_inode_lock(orphan_dir_inode
, &orphan_dir_bh
, 1);
2824 inode_unlock(orphan_dir_inode
);
2825 iput(orphan_dir_inode
);
2829 status
= ocfs2_read_inode_block(inode
, &di_bh
);
2835 handle
= ocfs2_start_trans(osb
, ocfs2_rename_credits(osb
->sb
));
2836 if (IS_ERR(handle
)) {
2837 status
= PTR_ERR(handle
);
2843 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
),
2844 di_bh
, OCFS2_JOURNAL_ACCESS_WRITE
);
2850 status
= ocfs2_orphan_del(osb
, handle
, orphan_dir_inode
, inode
,
2851 orphan_dir_bh
, false);
2857 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
2858 di
->i_flags
&= ~cpu_to_le32(OCFS2_ORPHANED_FL
);
2859 di
->i_orphaned_slot
= 0;
2860 set_nlink(inode
, 1);
2861 ocfs2_set_links_count(di
, inode
->i_nlink
);
2862 ocfs2_update_inode_fsync_trans(handle
, inode
, 1);
2863 ocfs2_journal_dirty(handle
, di_bh
);
2865 status
= ocfs2_add_entry(handle
, dentry
, inode
,
2866 OCFS2_I(inode
)->ip_blkno
, parent_di_bh
,
2873 status
= ocfs2_dentry_attach_lock(dentry
, inode
,
2874 OCFS2_I(dir
)->ip_blkno
);
2880 d_instantiate(dentry
, inode
);
2883 ocfs2_commit_trans(osb
, handle
);
2885 ocfs2_inode_unlock(orphan_dir_inode
, 1);
2886 inode_unlock(orphan_dir_inode
);
2887 iput(orphan_dir_inode
);
2890 ocfs2_inode_unlock(dir
, 1);
2893 brelse(parent_di_bh
);
2894 brelse(orphan_dir_bh
);
2896 ocfs2_free_dir_lookup_result(&lookup
);
2904 const struct inode_operations ocfs2_dir_iops
= {
2905 .create
= ocfs2_create
,
2906 .lookup
= ocfs2_lookup
,
2908 .unlink
= ocfs2_unlink
,
2909 .rmdir
= ocfs2_unlink
,
2910 .symlink
= ocfs2_symlink
,
2911 .mkdir
= ocfs2_mkdir
,
2912 .mknod
= ocfs2_mknod
,
2913 .rename
= ocfs2_rename
,
2914 .setattr
= ocfs2_setattr
,
2915 .getattr
= ocfs2_getattr
,
2916 .permission
= ocfs2_permission
,
2917 .listxattr
= ocfs2_listxattr
,
2918 .fiemap
= ocfs2_fiemap
,
2919 .get_acl
= ocfs2_iop_get_acl
,
2920 .set_acl
= ocfs2_iop_set_acl
,