1 /* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0:
6 * Create and rename file, directory, symlinks
8 * Copyright (C) 2002, 2004 Oracle. All rights reserved.
10 * Portions of this code from linux/fs/ext3/dir.c
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)
19 * linux/fs/minix/dir.c
21 * Copyright (C) 1991, 1992 Linux Torvalds
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.
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.
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.
40 #include <linux/types.h>
41 #include <linux/slab.h>
42 #include <linux/highmem.h>
43 #include <linux/quotaops.h>
45 #include <cluster/masklog.h>
53 #include "extent_map.h"
65 #include "ocfs2_trace.h"
67 #include "buffer_head_io.h"
69 static int ocfs2_mknod_locked(struct ocfs2_super
*osb
,
73 struct buffer_head
**new_fe_bh
,
74 struct buffer_head
*parent_fe_bh
,
76 struct ocfs2_alloc_context
*inode_ac
);
78 static int ocfs2_prepare_orphan_dir(struct ocfs2_super
*osb
,
79 struct inode
**ret_orphan_dir
,
82 struct ocfs2_dir_lookup_result
*lookup
,
85 static int ocfs2_orphan_add(struct ocfs2_super
*osb
,
88 struct buffer_head
*fe_bh
,
90 struct ocfs2_dir_lookup_result
*lookup
,
91 struct inode
*orphan_dir_inode
,
94 static int ocfs2_create_symlink_data(struct ocfs2_super
*osb
,
99 static int ocfs2_double_lock(struct ocfs2_super
*osb
,
100 struct buffer_head
**bh1
,
101 struct inode
*inode1
,
102 struct buffer_head
**bh2
,
103 struct inode
*inode2
,
106 static void ocfs2_double_unlock(struct inode
*inode1
, struct inode
*inode2
);
107 /* An orphan dir name is an 8 byte value, printed as a hex string */
108 #define OCFS2_ORPHAN_NAMELEN ((int)(2 * sizeof(u64)))
109 #define OCFS2_DIO_ORPHAN_PREFIX "dio-"
110 #define OCFS2_DIO_ORPHAN_PREFIX_LEN 4
112 static struct dentry
*ocfs2_lookup(struct inode
*dir
, struct dentry
*dentry
,
117 struct inode
*inode
= NULL
;
119 struct ocfs2_inode_info
*oi
;
121 trace_ocfs2_lookup(dir
, dentry
, dentry
->d_name
.len
,
123 (unsigned long long)OCFS2_I(dir
)->ip_blkno
, 0);
125 if (dentry
->d_name
.len
> OCFS2_MAX_FILENAME_LEN
) {
126 ret
= ERR_PTR(-ENAMETOOLONG
);
130 status
= ocfs2_inode_lock_nested(dir
, NULL
, 0, OI_LS_PARENT
);
132 if (status
!= -ENOENT
)
134 ret
= ERR_PTR(status
);
138 status
= ocfs2_lookup_ino_from_name(dir
, dentry
->d_name
.name
,
139 dentry
->d_name
.len
, &blkno
);
143 inode
= ocfs2_iget(OCFS2_SB(dir
->i_sb
), blkno
, 0, 0);
145 ret
= ERR_PTR(-EACCES
);
150 /* Clear any orphaned state... If we were able to look up the
151 * inode from a directory, it certainly can't be orphaned. We
152 * might have the bad state from a node which intended to
153 * orphan this inode but crashed before it could commit the
155 spin_lock(&oi
->ip_lock
);
156 oi
->ip_flags
&= ~OCFS2_INODE_MAYBE_ORPHANED
;
157 spin_unlock(&oi
->ip_lock
);
160 ret
= d_splice_alias(inode
, dentry
);
164 * If d_splice_alias() finds a DCACHE_DISCONNECTED
165 * dentry, it will d_move() it on top of ourse. The
166 * return value will indicate this however, so in
167 * those cases, we switch them around for the locking
170 * NOTE: This dentry already has ->d_op set from
171 * ocfs2_get_parent() and ocfs2_get_dentry()
173 if (!IS_ERR_OR_NULL(ret
))
176 status
= ocfs2_dentry_attach_lock(dentry
, inode
,
177 OCFS2_I(dir
)->ip_blkno
);
180 ret
= ERR_PTR(status
);
184 ocfs2_dentry_attach_gen(dentry
);
187 /* Don't drop the cluster lock until *after* the d_add --
188 * unlink on another node will message us to remove that
189 * dentry under this lock so otherwise we can race this with
190 * the downconvert thread and have a stale dentry. */
191 ocfs2_inode_unlock(dir
, 0);
195 trace_ocfs2_lookup_ret(ret
);
200 static struct inode
*ocfs2_get_init_inode(struct inode
*dir
, umode_t mode
)
204 inode
= new_inode(dir
->i_sb
);
206 mlog(ML_ERROR
, "new_inode failed!\n");
210 /* populate as many fields early on as possible - many of
211 * these are used by the support functions here and in
215 inode_init_owner(inode
, dir
, mode
);
216 dquot_initialize(inode
);
220 static void ocfs2_cleanup_add_entry_failure(struct ocfs2_super
*osb
,
221 struct dentry
*dentry
, struct inode
*inode
)
223 struct ocfs2_dentry_lock
*dl
= dentry
->d_fsdata
;
225 ocfs2_simple_drop_lockres(osb
, &dl
->dl_lockres
);
226 ocfs2_lock_res_free(&dl
->dl_lockres
);
227 BUG_ON(dl
->dl_count
!= 1);
228 spin_lock(&dentry_attach_lock
);
229 dentry
->d_fsdata
= NULL
;
230 spin_unlock(&dentry_attach_lock
);
235 static int ocfs2_mknod(struct inode
*dir
,
236 struct dentry
*dentry
,
241 struct buffer_head
*parent_fe_bh
= NULL
;
242 handle_t
*handle
= NULL
;
243 struct ocfs2_super
*osb
;
244 struct ocfs2_dinode
*dirfe
;
245 struct buffer_head
*new_fe_bh
= NULL
;
246 struct inode
*inode
= NULL
;
247 struct ocfs2_alloc_context
*inode_ac
= NULL
;
248 struct ocfs2_alloc_context
*data_ac
= NULL
;
249 struct ocfs2_alloc_context
*meta_ac
= NULL
;
250 int want_clusters
= 0;
252 int xattr_credits
= 0;
253 struct ocfs2_security_xattr_info si
= {
256 int did_quota_inode
= 0;
257 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
259 int did_block_signals
= 0;
260 struct posix_acl
*default_acl
= NULL
, *acl
= NULL
;
261 struct ocfs2_dentry_lock
*dl
= NULL
;
263 trace_ocfs2_mknod(dir
, dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
,
264 (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
265 (unsigned long)dev
, mode
);
267 dquot_initialize(dir
);
269 /* get our super block */
270 osb
= OCFS2_SB(dir
->i_sb
);
272 status
= ocfs2_inode_lock(dir
, &parent_fe_bh
, 1);
274 if (status
!= -ENOENT
)
279 if (S_ISDIR(mode
) && (dir
->i_nlink
>= ocfs2_link_max(osb
))) {
284 dirfe
= (struct ocfs2_dinode
*) parent_fe_bh
->b_data
;
285 if (!ocfs2_read_links_count(dirfe
)) {
286 /* can't make a file in a deleted directory. */
291 status
= ocfs2_check_dir_for_entry(dir
, dentry
->d_name
.name
,
296 /* get a spot inside the dir. */
297 status
= ocfs2_prepare_dir_for_insert(osb
, dir
, parent_fe_bh
,
299 dentry
->d_name
.len
, &lookup
);
305 /* reserve an inode spot */
306 status
= ocfs2_reserve_new_inode(osb
, &inode_ac
);
308 if (status
!= -ENOSPC
)
313 inode
= ocfs2_get_init_inode(dir
, mode
);
320 /* get security xattr */
321 status
= ocfs2_init_security_get(inode
, dir
, &dentry
->d_name
, &si
);
323 if (status
== -EOPNOTSUPP
)
331 /* calculate meta data/clusters for setting security and acl xattr */
332 status
= ocfs2_calc_xattr_init(dir
, parent_fe_bh
, mode
,
334 &xattr_credits
, &want_meta
);
340 /* Reserve a cluster if creating an extent based directory. */
341 if (S_ISDIR(mode
) && !ocfs2_supports_inline_data(osb
)) {
344 /* Dir indexing requires extra space as well */
345 if (ocfs2_supports_indexed_dirs(osb
))
349 status
= ocfs2_reserve_new_metadata_blocks(osb
, want_meta
, &meta_ac
);
351 if (status
!= -ENOSPC
)
356 status
= ocfs2_reserve_clusters(osb
, want_clusters
, &data_ac
);
358 if (status
!= -ENOSPC
)
363 status
= posix_acl_create(dir
, &mode
, &default_acl
, &acl
);
369 handle
= ocfs2_start_trans(osb
, ocfs2_mknod_credits(osb
->sb
,
372 if (IS_ERR(handle
)) {
373 status
= PTR_ERR(handle
);
379 /* Starting to change things, restart is no longer possible. */
380 ocfs2_block_signals(&oldset
);
381 did_block_signals
= 1;
383 status
= dquot_alloc_inode(inode
);
388 /* do the real work now. */
389 status
= ocfs2_mknod_locked(osb
, dir
, inode
, dev
,
390 &new_fe_bh
, parent_fe_bh
, handle
,
398 status
= ocfs2_fill_new_dir(osb
, handle
, dir
, inode
,
399 new_fe_bh
, data_ac
, meta_ac
);
405 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(dir
),
407 OCFS2_JOURNAL_ACCESS_WRITE
);
412 ocfs2_add_links_count(dirfe
, 1);
413 ocfs2_journal_dirty(handle
, parent_fe_bh
);
418 status
= ocfs2_set_acl(handle
, inode
, new_fe_bh
,
419 ACL_TYPE_DEFAULT
, default_acl
,
422 if (!status
&& acl
) {
423 status
= ocfs2_set_acl(handle
, inode
, new_fe_bh
,
424 ACL_TYPE_ACCESS
, acl
,
434 status
= ocfs2_init_security_set(handle
, inode
, new_fe_bh
, &si
,
443 * Do this before adding the entry to the directory. We add
444 * also set d_op after success so that ->d_iput() will cleanup
445 * the dentry lock even if ocfs2_add_entry() fails below.
447 status
= ocfs2_dentry_attach_lock(dentry
, inode
,
448 OCFS2_I(dir
)->ip_blkno
);
454 dl
= dentry
->d_fsdata
;
456 status
= ocfs2_add_entry(handle
, dentry
, inode
,
457 OCFS2_I(inode
)->ip_blkno
, parent_fe_bh
,
464 insert_inode_hash(inode
);
465 d_instantiate(dentry
, inode
);
469 posix_acl_release(default_acl
);
471 posix_acl_release(acl
);
472 if (status
< 0 && did_quota_inode
)
473 dquot_free_inode(inode
);
475 ocfs2_commit_trans(osb
, handle
);
477 ocfs2_inode_unlock(dir
, 1);
478 if (did_block_signals
)
479 ocfs2_unblock_signals(&oldset
);
482 brelse(parent_fe_bh
);
485 ocfs2_free_dir_lookup_result(&lookup
);
488 ocfs2_free_alloc_context(inode_ac
);
491 ocfs2_free_alloc_context(data_ac
);
494 ocfs2_free_alloc_context(meta_ac
);
497 * We should call iput after the i_mutex of the bitmap been
498 * unlocked in ocfs2_free_alloc_context, or the
499 * ocfs2_delete_inode will mutex_lock again.
501 if ((status
< 0) && inode
) {
503 ocfs2_cleanup_add_entry_failure(osb
, dentry
, inode
);
505 OCFS2_I(inode
)->ip_flags
|= OCFS2_INODE_SKIP_ORPHAN_DIR
;
516 static int __ocfs2_mknod_locked(struct inode
*dir
,
519 struct buffer_head
**new_fe_bh
,
520 struct buffer_head
*parent_fe_bh
,
522 struct ocfs2_alloc_context
*inode_ac
,
523 u64 fe_blkno
, u64 suballoc_loc
, u16 suballoc_bit
)
526 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
527 struct ocfs2_dinode
*fe
= NULL
;
528 struct ocfs2_extent_list
*fel
;
530 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
534 /* populate as many fields early on as possible - many of
535 * these are used by the support functions here and in
537 inode
->i_ino
= ino_from_blkno(osb
->sb
, fe_blkno
);
538 OCFS2_I(inode
)->ip_blkno
= fe_blkno
;
539 spin_lock(&osb
->osb_lock
);
540 inode
->i_generation
= osb
->s_next_generation
++;
541 spin_unlock(&osb
->osb_lock
);
543 *new_fe_bh
= sb_getblk(osb
->sb
, fe_blkno
);
549 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode
), *new_fe_bh
);
551 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
),
553 OCFS2_JOURNAL_ACCESS_CREATE
);
559 fe
= (struct ocfs2_dinode
*) (*new_fe_bh
)->b_data
;
560 memset(fe
, 0, osb
->sb
->s_blocksize
);
562 fe
->i_generation
= cpu_to_le32(inode
->i_generation
);
563 fe
->i_fs_generation
= cpu_to_le32(osb
->fs_generation
);
564 fe
->i_blkno
= cpu_to_le64(fe_blkno
);
565 fe
->i_suballoc_loc
= cpu_to_le64(suballoc_loc
);
566 fe
->i_suballoc_bit
= cpu_to_le16(suballoc_bit
);
567 fe
->i_suballoc_slot
= cpu_to_le16(inode_ac
->ac_alloc_slot
);
568 fe
->i_uid
= cpu_to_le32(i_uid_read(inode
));
569 fe
->i_gid
= cpu_to_le32(i_gid_read(inode
));
570 fe
->i_mode
= cpu_to_le16(inode
->i_mode
);
571 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
))
572 fe
->id1
.dev1
.i_rdev
= cpu_to_le64(huge_encode_dev(dev
));
574 ocfs2_set_links_count(fe
, inode
->i_nlink
);
576 fe
->i_last_eb_blk
= 0;
577 strcpy(fe
->i_signature
, OCFS2_INODE_SIGNATURE
);
578 fe
->i_flags
|= cpu_to_le32(OCFS2_VALID_FL
);
579 fe
->i_atime
= fe
->i_ctime
= fe
->i_mtime
=
580 cpu_to_le64(CURRENT_TIME
.tv_sec
);
581 fe
->i_mtime_nsec
= fe
->i_ctime_nsec
= fe
->i_atime_nsec
=
582 cpu_to_le32(CURRENT_TIME
.tv_nsec
);
586 * If supported, directories start with inline data. If inline
587 * isn't supported, but indexing is, we start them as indexed.
589 feat
= le16_to_cpu(fe
->i_dyn_features
);
590 if (S_ISDIR(inode
->i_mode
) && ocfs2_supports_inline_data(osb
)) {
591 fe
->i_dyn_features
= cpu_to_le16(feat
| OCFS2_INLINE_DATA_FL
);
593 fe
->id2
.i_data
.id_count
= cpu_to_le16(
594 ocfs2_max_inline_data_with_xattr(osb
->sb
, fe
));
596 fel
= &fe
->id2
.i_list
;
597 fel
->l_tree_depth
= 0;
598 fel
->l_next_free_rec
= 0;
599 fel
->l_count
= cpu_to_le16(ocfs2_extent_recs_per_inode(osb
->sb
));
602 ocfs2_journal_dirty(handle
, *new_fe_bh
);
604 ocfs2_populate_inode(inode
, fe
, 1);
605 ocfs2_ci_set_new(osb
, INODE_CACHE(inode
));
606 if (!ocfs2_mount_local(osb
)) {
607 status
= ocfs2_create_new_inode_locks(inode
);
612 oi
->i_sync_tid
= handle
->h_transaction
->t_tid
;
613 oi
->i_datasync_tid
= handle
->h_transaction
->t_tid
;
628 static int ocfs2_mknod_locked(struct ocfs2_super
*osb
,
632 struct buffer_head
**new_fe_bh
,
633 struct buffer_head
*parent_fe_bh
,
635 struct ocfs2_alloc_context
*inode_ac
)
638 u64 suballoc_loc
, fe_blkno
= 0;
643 status
= ocfs2_claim_new_inode(handle
, dir
, parent_fe_bh
,
644 inode_ac
, &suballoc_loc
,
645 &suballoc_bit
, &fe_blkno
);
651 return __ocfs2_mknod_locked(dir
, inode
, dev
, new_fe_bh
,
652 parent_fe_bh
, handle
, inode_ac
,
653 fe_blkno
, suballoc_loc
, suballoc_bit
);
656 static int ocfs2_mkdir(struct inode
*dir
,
657 struct dentry
*dentry
,
662 trace_ocfs2_mkdir(dir
, dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
,
663 OCFS2_I(dir
)->ip_blkno
, mode
);
664 ret
= ocfs2_mknod(dir
, dentry
, mode
| S_IFDIR
, 0);
671 static int ocfs2_create(struct inode
*dir
,
672 struct dentry
*dentry
,
678 trace_ocfs2_create(dir
, dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
,
679 (unsigned long long)OCFS2_I(dir
)->ip_blkno
, mode
);
680 ret
= ocfs2_mknod(dir
, dentry
, mode
| S_IFREG
, 0);
687 static int ocfs2_link(struct dentry
*old_dentry
,
689 struct dentry
*dentry
)
692 struct inode
*inode
= d_inode(old_dentry
);
693 struct inode
*old_dir
= d_inode(old_dentry
->d_parent
);
695 struct buffer_head
*fe_bh
= NULL
;
696 struct buffer_head
*old_dir_bh
= NULL
;
697 struct buffer_head
*parent_fe_bh
= NULL
;
698 struct ocfs2_dinode
*fe
= NULL
;
699 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
700 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
704 trace_ocfs2_link((unsigned long long)OCFS2_I(inode
)->ip_blkno
,
705 old_dentry
->d_name
.len
, old_dentry
->d_name
.name
,
706 dentry
->d_name
.len
, dentry
->d_name
.name
);
708 if (S_ISDIR(inode
->i_mode
))
711 dquot_initialize(dir
);
713 err
= ocfs2_double_lock(osb
, &old_dir_bh
, old_dir
,
714 &parent_fe_bh
, dir
, 0);
721 /* make sure both dirs have bhs
722 * get an extra ref on old_dir_bh if old==new */
725 parent_fe_bh
= old_dir_bh
;
726 get_bh(parent_fe_bh
);
728 mlog(ML_ERROR
, "%s: no old_dir_bh!\n", osb
->uuid_str
);
739 err
= ocfs2_lookup_ino_from_name(old_dir
, old_dentry
->d_name
.name
,
740 old_dentry
->d_name
.len
, &old_de_ino
);
747 * Check whether another node removed the source inode while we
750 if (old_de_ino
!= OCFS2_I(inode
)->ip_blkno
) {
755 err
= ocfs2_check_dir_for_entry(dir
, dentry
->d_name
.name
,
760 err
= ocfs2_prepare_dir_for_insert(osb
, dir
, parent_fe_bh
,
762 dentry
->d_name
.len
, &lookup
);
768 err
= ocfs2_inode_lock(inode
, &fe_bh
, 1);
775 fe
= (struct ocfs2_dinode
*) fe_bh
->b_data
;
776 if (ocfs2_read_links_count(fe
) >= ocfs2_link_max(osb
)) {
778 goto out_unlock_inode
;
781 handle
= ocfs2_start_trans(osb
, ocfs2_link_credits(osb
->sb
));
782 if (IS_ERR(handle
)) {
783 err
= PTR_ERR(handle
);
786 goto out_unlock_inode
;
789 /* Starting to change things, restart is no longer possible. */
790 ocfs2_block_signals(&oldset
);
792 err
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
), fe_bh
,
793 OCFS2_JOURNAL_ACCESS_WRITE
);
800 inode
->i_ctime
= CURRENT_TIME
;
801 ocfs2_set_links_count(fe
, inode
->i_nlink
);
802 fe
->i_ctime
= cpu_to_le64(inode
->i_ctime
.tv_sec
);
803 fe
->i_ctime_nsec
= cpu_to_le32(inode
->i_ctime
.tv_nsec
);
804 ocfs2_journal_dirty(handle
, fe_bh
);
806 err
= ocfs2_add_entry(handle
, dentry
, inode
,
807 OCFS2_I(inode
)->ip_blkno
,
808 parent_fe_bh
, &lookup
);
810 ocfs2_add_links_count(fe
, -1);
816 err
= ocfs2_dentry_attach_lock(dentry
, inode
, OCFS2_I(dir
)->ip_blkno
);
823 d_instantiate(dentry
, inode
);
826 ocfs2_commit_trans(osb
, handle
);
827 ocfs2_unblock_signals(&oldset
);
829 ocfs2_inode_unlock(inode
, 1);
832 ocfs2_double_unlock(old_dir
, dir
);
835 brelse(parent_fe_bh
);
838 ocfs2_free_dir_lookup_result(&lookup
);
847 * Takes and drops an exclusive lock on the given dentry. This will
848 * force other nodes to drop it.
850 static int ocfs2_remote_dentry_delete(struct dentry
*dentry
)
854 ret
= ocfs2_dentry_lock(dentry
, 1);
858 ocfs2_dentry_unlock(dentry
, 1);
863 static inline int ocfs2_inode_is_unlinkable(struct inode
*inode
)
865 if (S_ISDIR(inode
->i_mode
)) {
866 if (inode
->i_nlink
== 2)
871 if (inode
->i_nlink
== 1)
876 static int ocfs2_unlink(struct inode
*dir
,
877 struct dentry
*dentry
)
880 int child_locked
= 0;
881 bool is_unlinkable
= false;
882 struct inode
*inode
= d_inode(dentry
);
883 struct inode
*orphan_dir
= NULL
;
884 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
886 struct ocfs2_dinode
*fe
= NULL
;
887 struct buffer_head
*fe_bh
= NULL
;
888 struct buffer_head
*parent_node_bh
= NULL
;
889 handle_t
*handle
= NULL
;
890 char orphan_name
[OCFS2_ORPHAN_NAMELEN
+ 1];
891 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
892 struct ocfs2_dir_lookup_result orphan_insert
= { NULL
, };
894 trace_ocfs2_unlink(dir
, dentry
, dentry
->d_name
.len
,
896 (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
897 (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
899 dquot_initialize(dir
);
901 BUG_ON(d_inode(dentry
->d_parent
) != dir
);
903 if (inode
== osb
->root_inode
)
906 status
= ocfs2_inode_lock_nested(dir
, &parent_node_bh
, 1,
909 if (status
!= -ENOENT
)
914 status
= ocfs2_find_files_on_disk(dentry
->d_name
.name
,
915 dentry
->d_name
.len
, &blkno
, dir
,
918 if (status
!= -ENOENT
)
923 if (OCFS2_I(inode
)->ip_blkno
!= blkno
) {
926 trace_ocfs2_unlink_noent(
927 (unsigned long long)OCFS2_I(inode
)->ip_blkno
,
928 (unsigned long long)blkno
,
929 OCFS2_I(inode
)->ip_flags
);
933 status
= ocfs2_inode_lock(inode
, &fe_bh
, 1);
935 if (status
!= -ENOENT
)
941 if (S_ISDIR(inode
->i_mode
)) {
942 if (inode
->i_nlink
!= 2 || !ocfs2_empty_dir(inode
)) {
948 status
= ocfs2_remote_dentry_delete(dentry
);
950 /* This remote delete should succeed under all normal
956 if (ocfs2_inode_is_unlinkable(inode
)) {
957 status
= ocfs2_prepare_orphan_dir(osb
, &orphan_dir
,
958 OCFS2_I(inode
)->ip_blkno
,
959 orphan_name
, &orphan_insert
,
965 is_unlinkable
= true;
968 handle
= ocfs2_start_trans(osb
, ocfs2_unlink_credits(osb
->sb
));
969 if (IS_ERR(handle
)) {
970 status
= PTR_ERR(handle
);
976 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
), fe_bh
,
977 OCFS2_JOURNAL_ACCESS_WRITE
);
983 fe
= (struct ocfs2_dinode
*) fe_bh
->b_data
;
985 /* delete the name from the parent dir */
986 status
= ocfs2_delete_entry(handle
, dir
, &lookup
);
992 if (S_ISDIR(inode
->i_mode
))
995 ocfs2_set_links_count(fe
, inode
->i_nlink
);
996 ocfs2_journal_dirty(handle
, fe_bh
);
998 dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
999 if (S_ISDIR(inode
->i_mode
))
1002 status
= ocfs2_mark_inode_dirty(handle
, dir
, parent_node_bh
);
1005 if (S_ISDIR(inode
->i_mode
))
1010 if (is_unlinkable
) {
1011 status
= ocfs2_orphan_add(osb
, handle
, inode
, fe_bh
,
1012 orphan_name
, &orphan_insert
, orphan_dir
, false);
1019 ocfs2_commit_trans(osb
, handle
);
1022 ocfs2_inode_unlock(inode
, 1);
1024 ocfs2_inode_unlock(dir
, 1);
1027 /* This was locked for us in ocfs2_prepare_orphan_dir() */
1028 ocfs2_inode_unlock(orphan_dir
, 1);
1029 mutex_unlock(&orphan_dir
->i_mutex
);
1034 brelse(parent_node_bh
);
1036 ocfs2_free_dir_lookup_result(&orphan_insert
);
1037 ocfs2_free_dir_lookup_result(&lookup
);
1039 if (status
&& (status
!= -ENOTEMPTY
) && (status
!= -ENOENT
))
1045 static int ocfs2_check_if_ancestor(struct ocfs2_super
*osb
,
1046 u64 src_inode_no
, u64 dest_inode_no
)
1049 u64 parent_inode_no
= 0;
1050 u64 child_inode_no
= src_inode_no
;
1051 struct inode
*child_inode
;
1053 #define MAX_LOOKUP_TIMES 32
1055 child_inode
= ocfs2_iget(osb
, child_inode_no
, 0, 0);
1056 if (IS_ERR(child_inode
)) {
1057 ret
= PTR_ERR(child_inode
);
1061 ret
= ocfs2_inode_lock(child_inode
, NULL
, 0);
1069 ret
= ocfs2_lookup_ino_from_name(child_inode
, "..", 2,
1071 ocfs2_inode_unlock(child_inode
, 0);
1078 if (parent_inode_no
== dest_inode_no
) {
1083 if (parent_inode_no
== osb
->root_inode
->i_ino
) {
1088 child_inode_no
= parent_inode_no
;
1090 if (++i
>= MAX_LOOKUP_TIMES
) {
1091 mlog(ML_NOTICE
, "max lookup times reached, filesystem "
1092 "may have nested directories, "
1093 "src inode: %llu, dest inode: %llu.\n",
1094 (unsigned long long)src_inode_no
,
1095 (unsigned long long)dest_inode_no
);
1105 * The only place this should be used is rename and link!
1106 * if they have the same id, then the 1st one is the only one locked.
1108 static int ocfs2_double_lock(struct ocfs2_super
*osb
,
1109 struct buffer_head
**bh1
,
1110 struct inode
*inode1
,
1111 struct buffer_head
**bh2
,
1112 struct inode
*inode2
,
1116 int inode1_is_ancestor
, inode2_is_ancestor
;
1117 struct ocfs2_inode_info
*oi1
= OCFS2_I(inode1
);
1118 struct ocfs2_inode_info
*oi2
= OCFS2_I(inode2
);
1119 struct buffer_head
**tmpbh
;
1120 struct inode
*tmpinode
;
1122 trace_ocfs2_double_lock((unsigned long long)oi1
->ip_blkno
,
1123 (unsigned long long)oi2
->ip_blkno
);
1130 /* we always want to lock the one with the lower lockid first.
1131 * and if they are nested, we lock ancestor first */
1132 if (oi1
->ip_blkno
!= oi2
->ip_blkno
) {
1133 inode1_is_ancestor
= ocfs2_check_if_ancestor(osb
, oi2
->ip_blkno
,
1135 if (inode1_is_ancestor
< 0) {
1136 status
= inode1_is_ancestor
;
1140 inode2_is_ancestor
= ocfs2_check_if_ancestor(osb
, oi1
->ip_blkno
,
1142 if (inode2_is_ancestor
< 0) {
1143 status
= inode2_is_ancestor
;
1147 if ((inode1_is_ancestor
== 1) ||
1148 (oi1
->ip_blkno
< oi2
->ip_blkno
&&
1149 inode2_is_ancestor
== 0)) {
1150 /* switch id1 and id2 around */
1160 status
= ocfs2_inode_lock_nested(inode2
, bh2
, 1,
1161 rename
== 1 ? OI_LS_RENAME1
: OI_LS_PARENT
);
1163 if (status
!= -ENOENT
)
1170 status
= ocfs2_inode_lock_nested(inode1
, bh1
, 1,
1171 rename
== 1 ? OI_LS_RENAME2
: OI_LS_PARENT
);
1174 * An error return must mean that no cluster locks
1175 * were held on function exit.
1177 if (oi1
->ip_blkno
!= oi2
->ip_blkno
) {
1178 ocfs2_inode_unlock(inode2
, 1);
1183 if (status
!= -ENOENT
)
1187 trace_ocfs2_double_lock_end(
1188 (unsigned long long)OCFS2_I(inode1
)->ip_blkno
,
1189 (unsigned long long)OCFS2_I(inode2
)->ip_blkno
);
1197 static void ocfs2_double_unlock(struct inode
*inode1
, struct inode
*inode2
)
1199 ocfs2_inode_unlock(inode1
, 1);
1201 if (inode1
!= inode2
)
1202 ocfs2_inode_unlock(inode2
, 1);
1205 static int ocfs2_rename(struct inode
*old_dir
,
1206 struct dentry
*old_dentry
,
1207 struct inode
*new_dir
,
1208 struct dentry
*new_dentry
)
1210 int status
= 0, rename_lock
= 0, parents_locked
= 0, target_exists
= 0;
1211 int old_child_locked
= 0, new_child_locked
= 0, update_dot_dot
= 0;
1212 struct inode
*old_inode
= d_inode(old_dentry
);
1213 struct inode
*new_inode
= d_inode(new_dentry
);
1214 struct inode
*orphan_dir
= NULL
;
1215 struct ocfs2_dinode
*newfe
= NULL
;
1216 char orphan_name
[OCFS2_ORPHAN_NAMELEN
+ 1];
1217 struct buffer_head
*newfe_bh
= NULL
;
1218 struct buffer_head
*old_inode_bh
= NULL
;
1219 struct ocfs2_super
*osb
= NULL
;
1220 u64 newfe_blkno
, old_de_ino
;
1221 handle_t
*handle
= NULL
;
1222 struct buffer_head
*old_dir_bh
= NULL
;
1223 struct buffer_head
*new_dir_bh
= NULL
;
1224 u32 old_dir_nlink
= old_dir
->i_nlink
;
1225 struct ocfs2_dinode
*old_di
;
1226 struct ocfs2_dir_lookup_result old_inode_dot_dot_res
= { NULL
, };
1227 struct ocfs2_dir_lookup_result target_lookup_res
= { NULL
, };
1228 struct ocfs2_dir_lookup_result old_entry_lookup
= { NULL
, };
1229 struct ocfs2_dir_lookup_result orphan_insert
= { NULL
, };
1230 struct ocfs2_dir_lookup_result target_insert
= { NULL
, };
1231 bool should_add_orphan
= false;
1233 /* At some point it might be nice to break this function up a
1236 trace_ocfs2_rename(old_dir
, old_dentry
, new_dir
, new_dentry
,
1237 old_dentry
->d_name
.len
, old_dentry
->d_name
.name
,
1238 new_dentry
->d_name
.len
, new_dentry
->d_name
.name
);
1240 dquot_initialize(old_dir
);
1241 dquot_initialize(new_dir
);
1243 osb
= OCFS2_SB(old_dir
->i_sb
);
1246 if (!igrab(new_inode
))
1250 /* Assume a directory hierarchy thusly:
1253 * a,b,c, and d are all directories.
1255 * from cwd of 'a' on both nodes:
1259 * And that's why, just like the VFS, we need a file system
1261 if (old_dir
!= new_dir
&& S_ISDIR(old_inode
->i_mode
)) {
1262 status
= ocfs2_rename_lock(osb
);
1269 /* here we cannot guarantee the inodes haven't just been
1270 * changed, so check if they are nested again */
1271 status
= ocfs2_check_if_ancestor(osb
, new_dir
->i_ino
,
1276 } else if (status
== 1) {
1278 trace_ocfs2_rename_not_permitted(
1279 (unsigned long long)old_inode
->i_ino
,
1280 (unsigned long long)new_dir
->i_ino
);
1285 /* if old and new are the same, this'll just do one lock. */
1286 status
= ocfs2_double_lock(osb
, &old_dir_bh
, old_dir
,
1287 &new_dir_bh
, new_dir
, 1);
1294 /* make sure both dirs have bhs
1295 * get an extra ref on old_dir_bh if old==new */
1298 new_dir_bh
= old_dir_bh
;
1301 mlog(ML_ERROR
, "no old_dir_bh!\n");
1308 * Aside from allowing a meta data update, the locking here
1309 * also ensures that the downconvert thread on other nodes
1310 * won't have to concurrently downconvert the inode and the
1313 status
= ocfs2_inode_lock_nested(old_inode
, &old_inode_bh
, 1,
1316 if (status
!= -ENOENT
)
1320 old_child_locked
= 1;
1322 status
= ocfs2_remote_dentry_delete(old_dentry
);
1328 if (S_ISDIR(old_inode
->i_mode
)) {
1329 u64 old_inode_parent
;
1332 status
= ocfs2_find_files_on_disk("..", 2, &old_inode_parent
,
1334 &old_inode_dot_dot_res
);
1340 if (old_inode_parent
!= OCFS2_I(old_dir
)->ip_blkno
) {
1345 if (!new_inode
&& new_dir
!= old_dir
&&
1346 new_dir
->i_nlink
>= ocfs2_link_max(osb
)) {
1352 status
= ocfs2_lookup_ino_from_name(old_dir
, old_dentry
->d_name
.name
,
1353 old_dentry
->d_name
.len
,
1361 * Check for inode number is _not_ due to possible IO errors.
1362 * We might rmdir the source, keep it as pwd of some process
1363 * and merrily kill the link to whatever was created under the
1364 * same name. Goodbye sticky bit ;-<
1366 if (old_de_ino
!= OCFS2_I(old_inode
)->ip_blkno
) {
1371 /* check if the target already exists (in which case we need
1373 status
= ocfs2_find_files_on_disk(new_dentry
->d_name
.name
,
1374 new_dentry
->d_name
.len
,
1375 &newfe_blkno
, new_dir
,
1376 &target_lookup_res
);
1377 /* The only error we allow here is -ENOENT because the new
1378 * file not existing is perfectly valid. */
1379 if ((status
< 0) && (status
!= -ENOENT
)) {
1380 /* If we cannot find the file specified we should just */
1381 /* return the error... */
1388 if (!target_exists
&& new_inode
) {
1390 * Target was unlinked by another node while we were
1391 * waiting to get to ocfs2_rename(). There isn't
1392 * anything we can do here to help the situation, so
1393 * bubble up the appropriate error.
1399 /* In case we need to overwrite an existing file, we blow it
1401 if (target_exists
) {
1402 /* VFS didn't think there existed an inode here, but
1403 * someone else in the cluster must have raced our
1404 * rename to create one. Today we error cleanly, in
1405 * the future we should consider calling iget to build
1406 * a new struct inode for this entry. */
1410 trace_ocfs2_rename_target_exists(new_dentry
->d_name
.len
,
1411 new_dentry
->d_name
.name
);
1415 if (OCFS2_I(new_inode
)->ip_blkno
!= newfe_blkno
) {
1418 trace_ocfs2_rename_disagree(
1419 (unsigned long long)OCFS2_I(new_inode
)->ip_blkno
,
1420 (unsigned long long)newfe_blkno
,
1421 OCFS2_I(new_inode
)->ip_flags
);
1425 status
= ocfs2_inode_lock(new_inode
, &newfe_bh
, 1);
1427 if (status
!= -ENOENT
)
1431 new_child_locked
= 1;
1433 status
= ocfs2_remote_dentry_delete(new_dentry
);
1439 newfe
= (struct ocfs2_dinode
*) newfe_bh
->b_data
;
1441 trace_ocfs2_rename_over_existing(
1442 (unsigned long long)newfe_blkno
, newfe_bh
, newfe_bh
?
1443 (unsigned long long)newfe_bh
->b_blocknr
: 0ULL);
1445 if (S_ISDIR(new_inode
->i_mode
) || (new_inode
->i_nlink
== 1)) {
1446 status
= ocfs2_prepare_orphan_dir(osb
, &orphan_dir
,
1447 OCFS2_I(new_inode
)->ip_blkno
,
1448 orphan_name
, &orphan_insert
,
1454 should_add_orphan
= true;
1457 BUG_ON(d_inode(new_dentry
->d_parent
) != new_dir
);
1459 status
= ocfs2_check_dir_for_entry(new_dir
,
1460 new_dentry
->d_name
.name
,
1461 new_dentry
->d_name
.len
);
1465 status
= ocfs2_prepare_dir_for_insert(osb
, new_dir
, new_dir_bh
,
1466 new_dentry
->d_name
.name
,
1467 new_dentry
->d_name
.len
,
1475 handle
= ocfs2_start_trans(osb
, ocfs2_rename_credits(osb
->sb
));
1476 if (IS_ERR(handle
)) {
1477 status
= PTR_ERR(handle
);
1483 if (target_exists
) {
1484 if (S_ISDIR(new_inode
->i_mode
)) {
1485 if (new_inode
->i_nlink
!= 2 ||
1486 !ocfs2_empty_dir(new_inode
)) {
1487 status
= -ENOTEMPTY
;
1491 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(new_inode
),
1493 OCFS2_JOURNAL_ACCESS_WRITE
);
1499 /* change the dirent to point to the correct inode */
1500 status
= ocfs2_update_entry(new_dir
, handle
, &target_lookup_res
,
1506 new_dir
->i_version
++;
1508 if (S_ISDIR(new_inode
->i_mode
))
1509 ocfs2_set_links_count(newfe
, 0);
1511 ocfs2_add_links_count(newfe
, -1);
1512 ocfs2_journal_dirty(handle
, newfe_bh
);
1513 if (should_add_orphan
) {
1514 status
= ocfs2_orphan_add(osb
, handle
, new_inode
,
1515 newfe_bh
, orphan_name
,
1516 &orphan_insert
, orphan_dir
, false);
1523 /* if the name was not found in new_dir, add it now */
1524 status
= ocfs2_add_entry(handle
, new_dentry
, old_inode
,
1525 OCFS2_I(old_inode
)->ip_blkno
,
1526 new_dir_bh
, &target_insert
);
1529 old_inode
->i_ctime
= CURRENT_TIME
;
1530 mark_inode_dirty(old_inode
);
1532 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(old_inode
),
1534 OCFS2_JOURNAL_ACCESS_WRITE
);
1536 old_di
= (struct ocfs2_dinode
*) old_inode_bh
->b_data
;
1538 old_di
->i_ctime
= cpu_to_le64(old_inode
->i_ctime
.tv_sec
);
1539 old_di
->i_ctime_nsec
= cpu_to_le32(old_inode
->i_ctime
.tv_nsec
);
1540 ocfs2_journal_dirty(handle
, old_inode_bh
);
1545 * Now that the name has been added to new_dir, remove the old name.
1547 * We don't keep any directory entry context around until now
1548 * because the insert might have changed the type of directory
1549 * we're dealing with.
1551 status
= ocfs2_find_entry(old_dentry
->d_name
.name
,
1552 old_dentry
->d_name
.len
, old_dir
,
1557 status
= ocfs2_delete_entry(handle
, old_dir
, &old_entry_lookup
);
1564 drop_nlink(new_inode
);
1565 new_inode
->i_ctime
= CURRENT_TIME
;
1567 old_dir
->i_ctime
= old_dir
->i_mtime
= CURRENT_TIME
;
1569 if (update_dot_dot
) {
1570 status
= ocfs2_update_entry(old_inode
, handle
,
1571 &old_inode_dot_dot_res
, new_dir
);
1572 drop_nlink(old_dir
);
1574 drop_nlink(new_inode
);
1577 mark_inode_dirty(new_dir
);
1580 mark_inode_dirty(old_dir
);
1581 ocfs2_mark_inode_dirty(handle
, old_dir
, old_dir_bh
);
1583 mark_inode_dirty(new_inode
);
1584 ocfs2_mark_inode_dirty(handle
, new_inode
, newfe_bh
);
1587 if (old_dir
!= new_dir
) {
1588 /* Keep the same times on both directories.*/
1589 new_dir
->i_ctime
= new_dir
->i_mtime
= old_dir
->i_ctime
;
1592 * This will also pick up the i_nlink change from the
1595 ocfs2_mark_inode_dirty(handle
, new_dir
, new_dir_bh
);
1598 if (old_dir_nlink
!= old_dir
->i_nlink
) {
1600 mlog(ML_ERROR
, "need to change nlink for old dir "
1601 "%llu from %d to %d but bh is NULL!\n",
1602 (unsigned long long)OCFS2_I(old_dir
)->ip_blkno
,
1603 (int)old_dir_nlink
, old_dir
->i_nlink
);
1605 struct ocfs2_dinode
*fe
;
1606 status
= ocfs2_journal_access_di(handle
,
1607 INODE_CACHE(old_dir
),
1609 OCFS2_JOURNAL_ACCESS_WRITE
);
1610 fe
= (struct ocfs2_dinode
*) old_dir_bh
->b_data
;
1611 ocfs2_set_links_count(fe
, old_dir
->i_nlink
);
1612 ocfs2_journal_dirty(handle
, old_dir_bh
);
1615 ocfs2_dentry_move(old_dentry
, new_dentry
, old_dir
, new_dir
);
1619 ocfs2_rename_unlock(osb
);
1622 ocfs2_commit_trans(osb
, handle
);
1625 ocfs2_double_unlock(old_dir
, new_dir
);
1627 if (old_child_locked
)
1628 ocfs2_inode_unlock(old_inode
, 1);
1630 if (new_child_locked
)
1631 ocfs2_inode_unlock(new_inode
, 1);
1634 /* This was locked for us in ocfs2_prepare_orphan_dir() */
1635 ocfs2_inode_unlock(orphan_dir
, 1);
1636 mutex_unlock(&orphan_dir
->i_mutex
);
1641 sync_mapping_buffers(old_inode
->i_mapping
);
1646 ocfs2_free_dir_lookup_result(&target_lookup_res
);
1647 ocfs2_free_dir_lookup_result(&old_entry_lookup
);
1648 ocfs2_free_dir_lookup_result(&old_inode_dot_dot_res
);
1649 ocfs2_free_dir_lookup_result(&orphan_insert
);
1650 ocfs2_free_dir_lookup_result(&target_insert
);
1653 brelse(old_inode_bh
);
1664 * we expect i_size = strlen(symname). Copy symname into the file
1665 * data, including the null terminator.
1667 static int ocfs2_create_symlink_data(struct ocfs2_super
*osb
,
1669 struct inode
*inode
,
1670 const char *symname
)
1672 struct buffer_head
**bhs
= NULL
;
1674 struct super_block
*sb
= osb
->sb
;
1675 u64 p_blkno
, p_blocks
;
1676 int virtual, blocks
, status
, i
, bytes_left
;
1678 bytes_left
= i_size_read(inode
) + 1;
1679 /* we can't trust i_blocks because we're actually going to
1680 * write i_size + 1 bytes. */
1681 blocks
= (bytes_left
+ sb
->s_blocksize
- 1) >> sb
->s_blocksize_bits
;
1683 trace_ocfs2_create_symlink_data((unsigned long long)inode
->i_blocks
,
1684 i_size_read(inode
), blocks
);
1686 /* Sanity check -- make sure we're going to fit. */
1688 ocfs2_clusters_to_bytes(sb
, OCFS2_I(inode
)->ip_clusters
)) {
1694 bhs
= kcalloc(blocks
, sizeof(struct buffer_head
*), GFP_KERNEL
);
1701 status
= ocfs2_extent_map_get_blocks(inode
, 0, &p_blkno
, &p_blocks
,
1708 /* links can never be larger than one cluster so we know this
1709 * is all going to be contiguous, but do a sanity check
1711 if ((p_blocks
<< sb
->s_blocksize_bits
) < bytes_left
) {
1718 while(bytes_left
> 0) {
1719 c
= &symname
[virtual * sb
->s_blocksize
];
1721 bhs
[virtual] = sb_getblk(sb
, p_blkno
);
1722 if (!bhs
[virtual]) {
1727 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode
),
1730 status
= ocfs2_journal_access(handle
, INODE_CACHE(inode
),
1732 OCFS2_JOURNAL_ACCESS_CREATE
);
1738 memset(bhs
[virtual]->b_data
, 0, sb
->s_blocksize
);
1740 memcpy(bhs
[virtual]->b_data
, c
,
1741 (bytes_left
> sb
->s_blocksize
) ? sb
->s_blocksize
:
1744 ocfs2_journal_dirty(handle
, bhs
[virtual]);
1748 bytes_left
-= sb
->s_blocksize
;
1755 for(i
= 0; i
< blocks
; i
++)
1765 static int ocfs2_symlink(struct inode
*dir
,
1766 struct dentry
*dentry
,
1767 const char *symname
)
1769 int status
, l
, credits
;
1771 struct ocfs2_super
*osb
= NULL
;
1772 struct inode
*inode
= NULL
;
1773 struct super_block
*sb
;
1774 struct buffer_head
*new_fe_bh
= NULL
;
1775 struct buffer_head
*parent_fe_bh
= NULL
;
1776 struct ocfs2_dinode
*fe
= NULL
;
1777 struct ocfs2_dinode
*dirfe
;
1778 handle_t
*handle
= NULL
;
1779 struct ocfs2_alloc_context
*inode_ac
= NULL
;
1780 struct ocfs2_alloc_context
*data_ac
= NULL
;
1781 struct ocfs2_alloc_context
*xattr_ac
= NULL
;
1782 int want_clusters
= 0;
1783 int xattr_credits
= 0;
1784 struct ocfs2_security_xattr_info si
= {
1787 int did_quota
= 0, did_quota_inode
= 0;
1788 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
1790 int did_block_signals
= 0;
1791 struct ocfs2_dentry_lock
*dl
= NULL
;
1793 trace_ocfs2_symlink_begin(dir
, dentry
, symname
,
1794 dentry
->d_name
.len
, dentry
->d_name
.name
);
1796 dquot_initialize(dir
);
1801 l
= strlen(symname
) + 1;
1803 credits
= ocfs2_calc_symlink_credits(sb
);
1805 /* lock the parent directory */
1806 status
= ocfs2_inode_lock(dir
, &parent_fe_bh
, 1);
1808 if (status
!= -ENOENT
)
1813 dirfe
= (struct ocfs2_dinode
*) parent_fe_bh
->b_data
;
1814 if (!ocfs2_read_links_count(dirfe
)) {
1815 /* can't make a file in a deleted directory. */
1820 status
= ocfs2_check_dir_for_entry(dir
, dentry
->d_name
.name
,
1821 dentry
->d_name
.len
);
1825 status
= ocfs2_prepare_dir_for_insert(osb
, dir
, parent_fe_bh
,
1826 dentry
->d_name
.name
,
1827 dentry
->d_name
.len
, &lookup
);
1833 status
= ocfs2_reserve_new_inode(osb
, &inode_ac
);
1835 if (status
!= -ENOSPC
)
1840 inode
= ocfs2_get_init_inode(dir
, S_IFLNK
| S_IRWXUGO
);
1847 /* get security xattr */
1848 status
= ocfs2_init_security_get(inode
, dir
, &dentry
->d_name
, &si
);
1850 if (status
== -EOPNOTSUPP
)
1858 /* calculate meta data/clusters for setting security xattr */
1860 status
= ocfs2_calc_security_init(dir
, &si
, &want_clusters
,
1861 &xattr_credits
, &xattr_ac
);
1868 /* don't reserve bitmap space for fast symlinks. */
1869 if (l
> ocfs2_fast_symlink_chars(sb
))
1872 status
= ocfs2_reserve_clusters(osb
, want_clusters
, &data_ac
);
1874 if (status
!= -ENOSPC
)
1879 handle
= ocfs2_start_trans(osb
, credits
+ xattr_credits
);
1880 if (IS_ERR(handle
)) {
1881 status
= PTR_ERR(handle
);
1887 /* Starting to change things, restart is no longer possible. */
1888 ocfs2_block_signals(&oldset
);
1889 did_block_signals
= 1;
1891 status
= dquot_alloc_inode(inode
);
1894 did_quota_inode
= 1;
1896 trace_ocfs2_symlink_create(dir
, dentry
, dentry
->d_name
.len
,
1897 dentry
->d_name
.name
,
1898 (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
1901 status
= ocfs2_mknod_locked(osb
, dir
, inode
,
1902 0, &new_fe_bh
, parent_fe_bh
, handle
,
1909 fe
= (struct ocfs2_dinode
*) new_fe_bh
->b_data
;
1912 inode
->i_op
= &ocfs2_symlink_inode_operations
;
1913 if (l
> ocfs2_fast_symlink_chars(sb
)) {
1916 status
= dquot_alloc_space_nodirty(inode
,
1917 ocfs2_clusters_to_bytes(osb
->sb
, 1));
1921 inode
->i_mapping
->a_ops
= &ocfs2_aops
;
1922 status
= ocfs2_add_inode_data(osb
, inode
, &offset
, 1, 0,
1924 handle
, data_ac
, NULL
,
1927 if (status
!= -ENOSPC
&& status
!= -EINTR
) {
1929 "Failed to extend file to %llu\n",
1930 (unsigned long long)newsize
);
1936 i_size_write(inode
, newsize
);
1937 inode
->i_blocks
= ocfs2_inode_sector_count(inode
);
1939 inode
->i_mapping
->a_ops
= &ocfs2_fast_symlink_aops
;
1940 memcpy((char *) fe
->id2
.i_symlink
, symname
, l
);
1941 i_size_write(inode
, newsize
);
1942 inode
->i_blocks
= 0;
1945 status
= ocfs2_mark_inode_dirty(handle
, inode
, new_fe_bh
);
1951 if (!ocfs2_inode_is_fast_symlink(inode
)) {
1952 status
= ocfs2_create_symlink_data(osb
, handle
, inode
,
1961 status
= ocfs2_init_security_set(handle
, inode
, new_fe_bh
, &si
,
1970 * Do this before adding the entry to the directory. We add
1971 * also set d_op after success so that ->d_iput() will cleanup
1972 * the dentry lock even if ocfs2_add_entry() fails below.
1974 status
= ocfs2_dentry_attach_lock(dentry
, inode
, OCFS2_I(dir
)->ip_blkno
);
1980 dl
= dentry
->d_fsdata
;
1982 status
= ocfs2_add_entry(handle
, dentry
, inode
,
1983 le64_to_cpu(fe
->i_blkno
), parent_fe_bh
,
1990 insert_inode_hash(inode
);
1991 d_instantiate(dentry
, inode
);
1993 if (status
< 0 && did_quota
)
1994 dquot_free_space_nodirty(inode
,
1995 ocfs2_clusters_to_bytes(osb
->sb
, 1));
1996 if (status
< 0 && did_quota_inode
)
1997 dquot_free_inode(inode
);
1999 ocfs2_commit_trans(osb
, handle
);
2001 ocfs2_inode_unlock(dir
, 1);
2002 if (did_block_signals
)
2003 ocfs2_unblock_signals(&oldset
);
2006 brelse(parent_fe_bh
);
2008 ocfs2_free_dir_lookup_result(&lookup
);
2010 ocfs2_free_alloc_context(inode_ac
);
2012 ocfs2_free_alloc_context(data_ac
);
2014 ocfs2_free_alloc_context(xattr_ac
);
2015 if ((status
< 0) && inode
) {
2017 ocfs2_cleanup_add_entry_failure(osb
, dentry
, inode
);
2019 OCFS2_I(inode
)->ip_flags
|= OCFS2_INODE_SKIP_ORPHAN_DIR
;
2030 static int ocfs2_blkno_stringify(u64 blkno
, char *name
)
2032 int status
, namelen
;
2034 namelen
= snprintf(name
, OCFS2_ORPHAN_NAMELEN
+ 1, "%016llx",
2044 if (namelen
!= OCFS2_ORPHAN_NAMELEN
) {
2050 trace_ocfs2_blkno_stringify(blkno
, name
, namelen
);
2059 static int ocfs2_lookup_lock_orphan_dir(struct ocfs2_super
*osb
,
2060 struct inode
**ret_orphan_dir
,
2061 struct buffer_head
**ret_orphan_dir_bh
)
2063 struct inode
*orphan_dir_inode
;
2064 struct buffer_head
*orphan_dir_bh
= NULL
;
2067 orphan_dir_inode
= ocfs2_get_system_file_inode(osb
,
2068 ORPHAN_DIR_SYSTEM_INODE
,
2070 if (!orphan_dir_inode
) {
2076 mutex_lock(&orphan_dir_inode
->i_mutex
);
2078 ret
= ocfs2_inode_lock(orphan_dir_inode
, &orphan_dir_bh
, 1);
2080 mutex_unlock(&orphan_dir_inode
->i_mutex
);
2081 iput(orphan_dir_inode
);
2087 *ret_orphan_dir
= orphan_dir_inode
;
2088 *ret_orphan_dir_bh
= orphan_dir_bh
;
2093 static int __ocfs2_prepare_orphan_dir(struct inode
*orphan_dir_inode
,
2094 struct buffer_head
*orphan_dir_bh
,
2097 struct ocfs2_dir_lookup_result
*lookup
,
2101 struct ocfs2_super
*osb
= OCFS2_SB(orphan_dir_inode
->i_sb
);
2103 (OCFS2_DIO_ORPHAN_PREFIX_LEN
+ OCFS2_ORPHAN_NAMELEN
) :
2104 OCFS2_ORPHAN_NAMELEN
;
2107 ret
= snprintf(name
, OCFS2_DIO_ORPHAN_PREFIX_LEN
+ 1, "%s",
2108 OCFS2_DIO_ORPHAN_PREFIX
);
2109 if (ret
!= OCFS2_DIO_ORPHAN_PREFIX_LEN
) {
2115 ret
= ocfs2_blkno_stringify(blkno
,
2116 name
+ OCFS2_DIO_ORPHAN_PREFIX_LEN
);
2118 ret
= ocfs2_blkno_stringify(blkno
, name
);
2124 ret
= ocfs2_prepare_dir_for_insert(osb
, orphan_dir_inode
,
2125 orphan_dir_bh
, name
,
2136 * ocfs2_prepare_orphan_dir() - Prepare an orphan directory for
2137 * insertion of an orphan.
2138 * @osb: ocfs2 file system
2139 * @ret_orphan_dir: Orphan dir inode - returned locked!
2140 * @blkno: Actual block number of the inode to be inserted into orphan dir.
2141 * @lookup: dir lookup result, to be passed back into functions like
2144 * Returns zero on success and the ret_orphan_dir, name and lookup
2145 * fields will be populated.
2147 * Returns non-zero on failure.
2149 static int ocfs2_prepare_orphan_dir(struct ocfs2_super
*osb
,
2150 struct inode
**ret_orphan_dir
,
2153 struct ocfs2_dir_lookup_result
*lookup
,
2156 struct inode
*orphan_dir_inode
= NULL
;
2157 struct buffer_head
*orphan_dir_bh
= NULL
;
2160 ret
= ocfs2_lookup_lock_orphan_dir(osb
, &orphan_dir_inode
,
2167 ret
= __ocfs2_prepare_orphan_dir(orphan_dir_inode
, orphan_dir_bh
,
2168 blkno
, name
, lookup
, dio
);
2174 *ret_orphan_dir
= orphan_dir_inode
;
2177 brelse(orphan_dir_bh
);
2180 ocfs2_inode_unlock(orphan_dir_inode
, 1);
2181 mutex_unlock(&orphan_dir_inode
->i_mutex
);
2182 iput(orphan_dir_inode
);
2190 static int ocfs2_orphan_add(struct ocfs2_super
*osb
,
2192 struct inode
*inode
,
2193 struct buffer_head
*fe_bh
,
2195 struct ocfs2_dir_lookup_result
*lookup
,
2196 struct inode
*orphan_dir_inode
,
2199 struct buffer_head
*orphan_dir_bh
= NULL
;
2201 struct ocfs2_dinode
*orphan_fe
;
2202 struct ocfs2_dinode
*fe
= (struct ocfs2_dinode
*) fe_bh
->b_data
;
2204 (OCFS2_DIO_ORPHAN_PREFIX_LEN
+ OCFS2_ORPHAN_NAMELEN
) :
2205 OCFS2_ORPHAN_NAMELEN
;
2207 trace_ocfs2_orphan_add_begin(
2208 (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
2210 status
= ocfs2_read_inode_block(orphan_dir_inode
, &orphan_dir_bh
);
2216 status
= ocfs2_journal_access_di(handle
,
2217 INODE_CACHE(orphan_dir_inode
),
2219 OCFS2_JOURNAL_ACCESS_WRITE
);
2226 * We're going to journal the change of i_flags and i_orphaned_slot.
2227 * It's safe anyway, though some callers may duplicate the journaling.
2228 * Journaling within the func just make the logic look more
2231 status
= ocfs2_journal_access_di(handle
,
2234 OCFS2_JOURNAL_ACCESS_WRITE
);
2240 /* we're a cluster, and nlink can change on disk from
2241 * underneath us... */
2242 orphan_fe
= (struct ocfs2_dinode
*) orphan_dir_bh
->b_data
;
2243 if (S_ISDIR(inode
->i_mode
))
2244 ocfs2_add_links_count(orphan_fe
, 1);
2245 set_nlink(orphan_dir_inode
, ocfs2_read_links_count(orphan_fe
));
2246 ocfs2_journal_dirty(handle
, orphan_dir_bh
);
2248 status
= __ocfs2_add_entry(handle
, orphan_dir_inode
, name
,
2250 OCFS2_I(inode
)->ip_blkno
,
2251 orphan_dir_bh
, lookup
);
2258 /* Update flag OCFS2_DIO_ORPHANED_FL and record the orphan
2261 fe
->i_flags
|= cpu_to_le32(OCFS2_DIO_ORPHANED_FL
);
2262 fe
->i_dio_orphaned_slot
= cpu_to_le16(osb
->slot_num
);
2264 fe
->i_flags
|= cpu_to_le32(OCFS2_ORPHANED_FL
);
2265 OCFS2_I(inode
)->ip_flags
&= ~OCFS2_INODE_SKIP_ORPHAN_DIR
;
2267 /* Record which orphan dir our inode now resides
2268 * in. delete_inode will use this to determine which orphan
2270 fe
->i_orphaned_slot
= cpu_to_le16(osb
->slot_num
);
2273 ocfs2_journal_dirty(handle
, fe_bh
);
2275 trace_ocfs2_orphan_add_end((unsigned long long)OCFS2_I(inode
)->ip_blkno
,
2280 if (S_ISDIR(inode
->i_mode
))
2281 ocfs2_add_links_count(orphan_fe
, -1);
2282 set_nlink(orphan_dir_inode
, ocfs2_read_links_count(orphan_fe
));
2286 brelse(orphan_dir_bh
);
2291 /* unlike orphan_add, we expect the orphan dir to already be locked here. */
2292 int ocfs2_orphan_del(struct ocfs2_super
*osb
,
2294 struct inode
*orphan_dir_inode
,
2295 struct inode
*inode
,
2296 struct buffer_head
*orphan_dir_bh
,
2299 const int namelen
= OCFS2_DIO_ORPHAN_PREFIX_LEN
+ OCFS2_ORPHAN_NAMELEN
;
2300 char name
[namelen
+ 1];
2301 struct ocfs2_dinode
*orphan_fe
;
2303 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
2306 status
= snprintf(name
, OCFS2_DIO_ORPHAN_PREFIX_LEN
+ 1, "%s",
2307 OCFS2_DIO_ORPHAN_PREFIX
);
2308 if (status
!= OCFS2_DIO_ORPHAN_PREFIX_LEN
) {
2314 status
= ocfs2_blkno_stringify(OCFS2_I(inode
)->ip_blkno
,
2315 name
+ OCFS2_DIO_ORPHAN_PREFIX_LEN
);
2317 status
= ocfs2_blkno_stringify(OCFS2_I(inode
)->ip_blkno
, name
);
2323 trace_ocfs2_orphan_del(
2324 (unsigned long long)OCFS2_I(orphan_dir_inode
)->ip_blkno
,
2325 name
, strlen(name
));
2327 /* find it's spot in the orphan directory */
2328 status
= ocfs2_find_entry(name
, strlen(name
), orphan_dir_inode
,
2335 /* remove it from the orphan directory */
2336 status
= ocfs2_delete_entry(handle
, orphan_dir_inode
, &lookup
);
2342 status
= ocfs2_journal_access_di(handle
,
2343 INODE_CACHE(orphan_dir_inode
),
2345 OCFS2_JOURNAL_ACCESS_WRITE
);
2351 /* do the i_nlink dance! :) */
2352 orphan_fe
= (struct ocfs2_dinode
*) orphan_dir_bh
->b_data
;
2353 if (S_ISDIR(inode
->i_mode
))
2354 ocfs2_add_links_count(orphan_fe
, -1);
2355 set_nlink(orphan_dir_inode
, ocfs2_read_links_count(orphan_fe
));
2356 ocfs2_journal_dirty(handle
, orphan_dir_bh
);
2359 ocfs2_free_dir_lookup_result(&lookup
);
2367 * ocfs2_prep_new_orphaned_file() - Prepare the orphan dir to receive a newly
2368 * allocated file. This is different from the typical 'add to orphan dir'
2369 * operation in that the inode does not yet exist. This is a problem because
2370 * the orphan dir stringifies the inode block number to come up with it's
2371 * dirent. Obviously if the inode does not yet exist we have a chicken and egg
2372 * problem. This function works around it by calling deeper into the orphan
2373 * and suballoc code than other callers. Use this only by necessity.
2374 * @dir: The directory which this inode will ultimately wind up under - not the
2376 * @dir_bh: buffer_head the @dir inode block
2377 * @orphan_name: string of length (CFS2_ORPHAN_NAMELEN + 1). Will be filled
2378 * with the string to be used for orphan dirent. Pass back to the orphan dir
2380 * @ret_orphan_dir: orphan dir inode returned to be passed back into orphan
2382 * @ret_di_blkno: block number where the new inode will be allocated.
2383 * @orphan_insert: Dir insert context to be passed back into orphan dir code.
2384 * @ret_inode_ac: Inode alloc context to be passed back to the allocator.
2386 * Returns zero on success and the ret_orphan_dir, name and lookup
2387 * fields will be populated.
2389 * Returns non-zero on failure.
2391 static int ocfs2_prep_new_orphaned_file(struct inode
*dir
,
2392 struct buffer_head
*dir_bh
,
2394 struct inode
**ret_orphan_dir
,
2396 struct ocfs2_dir_lookup_result
*orphan_insert
,
2397 struct ocfs2_alloc_context
**ret_inode_ac
)
2401 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
2402 struct inode
*orphan_dir
= NULL
;
2403 struct buffer_head
*orphan_dir_bh
= NULL
;
2404 struct ocfs2_alloc_context
*inode_ac
= NULL
;
2406 ret
= ocfs2_lookup_lock_orphan_dir(osb
, &orphan_dir
, &orphan_dir_bh
);
2412 /* reserve an inode spot */
2413 ret
= ocfs2_reserve_new_inode(osb
, &inode_ac
);
2420 ret
= ocfs2_find_new_inode_loc(dir
, dir_bh
, inode_ac
,
2427 ret
= __ocfs2_prepare_orphan_dir(orphan_dir
, orphan_dir_bh
,
2428 di_blkno
, orphan_name
, orphan_insert
,
2437 *ret_orphan_dir
= orphan_dir
;
2438 *ret_di_blkno
= di_blkno
;
2439 *ret_inode_ac
= inode_ac
;
2441 * orphan_name and orphan_insert are already up to
2442 * date via prepare_orphan_dir
2445 /* Unroll reserve_new_inode* */
2447 ocfs2_free_alloc_context(inode_ac
);
2449 /* Unroll orphan dir locking */
2450 mutex_unlock(&orphan_dir
->i_mutex
);
2451 ocfs2_inode_unlock(orphan_dir
, 1);
2455 brelse(orphan_dir_bh
);
2460 int ocfs2_create_inode_in_orphan(struct inode
*dir
,
2462 struct inode
**new_inode
)
2464 int status
, did_quota_inode
= 0;
2465 struct inode
*inode
= NULL
;
2466 struct inode
*orphan_dir
= NULL
;
2467 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
2468 struct ocfs2_dinode
*di
= NULL
;
2469 handle_t
*handle
= NULL
;
2470 char orphan_name
[OCFS2_ORPHAN_NAMELEN
+ 1];
2471 struct buffer_head
*parent_di_bh
= NULL
;
2472 struct buffer_head
*new_di_bh
= NULL
;
2473 struct ocfs2_alloc_context
*inode_ac
= NULL
;
2474 struct ocfs2_dir_lookup_result orphan_insert
= { NULL
, };
2475 u64
uninitialized_var(di_blkno
), suballoc_loc
;
2478 status
= ocfs2_inode_lock(dir
, &parent_di_bh
, 1);
2480 if (status
!= -ENOENT
)
2485 status
= ocfs2_prep_new_orphaned_file(dir
, parent_di_bh
,
2486 orphan_name
, &orphan_dir
,
2487 &di_blkno
, &orphan_insert
, &inode_ac
);
2489 if (status
!= -ENOSPC
)
2494 inode
= ocfs2_get_init_inode(dir
, mode
);
2501 handle
= ocfs2_start_trans(osb
, ocfs2_mknod_credits(osb
->sb
, 0, 0));
2502 if (IS_ERR(handle
)) {
2503 status
= PTR_ERR(handle
);
2509 status
= dquot_alloc_inode(inode
);
2512 did_quota_inode
= 1;
2514 status
= ocfs2_claim_new_inode_at_loc(handle
, dir
, inode_ac
,
2516 &suballoc_bit
, di_blkno
);
2523 /* do the real work now. */
2524 status
= __ocfs2_mknod_locked(dir
, inode
,
2525 0, &new_di_bh
, parent_di_bh
, handle
,
2526 inode_ac
, di_blkno
, suballoc_loc
,
2533 di
= (struct ocfs2_dinode
*)new_di_bh
->b_data
;
2534 status
= ocfs2_orphan_add(osb
, handle
, inode
, new_di_bh
, orphan_name
,
2535 &orphan_insert
, orphan_dir
, false);
2541 /* get open lock so that only nodes can't remove it from orphan dir. */
2542 status
= ocfs2_open_lock(inode
);
2546 insert_inode_hash(inode
);
2548 if (status
< 0 && did_quota_inode
)
2549 dquot_free_inode(inode
);
2551 ocfs2_commit_trans(osb
, handle
);
2554 /* This was locked for us in ocfs2_prepare_orphan_dir() */
2555 ocfs2_inode_unlock(orphan_dir
, 1);
2556 mutex_unlock(&orphan_dir
->i_mutex
);
2560 if ((status
< 0) && inode
) {
2566 ocfs2_free_alloc_context(inode_ac
);
2573 ocfs2_free_dir_lookup_result(&orphan_insert
);
2575 ocfs2_inode_unlock(dir
, 1);
2576 brelse(parent_di_bh
);
2580 static int ocfs2_dio_orphan_recovered(struct inode
*inode
)
2583 struct buffer_head
*di_bh
= NULL
;
2584 struct ocfs2_dinode
*di
= NULL
;
2586 ret
= ocfs2_inode_lock(inode
, &di_bh
, 1);
2592 di
= (struct ocfs2_dinode
*) di_bh
->b_data
;
2593 ret
= !(di
->i_flags
& cpu_to_le32(OCFS2_DIO_ORPHANED_FL
));
2594 ocfs2_inode_unlock(inode
, 1);
2600 #define OCFS2_DIO_ORPHANED_FL_CHECK_INTERVAL 10000
2601 int ocfs2_add_inode_to_orphan(struct ocfs2_super
*osb
,
2602 struct inode
*inode
)
2604 char orphan_name
[OCFS2_DIO_ORPHAN_PREFIX_LEN
+ OCFS2_ORPHAN_NAMELEN
+ 1];
2605 struct inode
*orphan_dir_inode
= NULL
;
2606 struct ocfs2_dir_lookup_result orphan_insert
= { NULL
, };
2607 struct buffer_head
*di_bh
= NULL
;
2609 handle_t
*handle
= NULL
;
2610 struct ocfs2_dinode
*di
= NULL
;
2613 status
= ocfs2_inode_lock(inode
, &di_bh
, 1);
2619 di
= (struct ocfs2_dinode
*) di_bh
->b_data
;
2621 * Another append dio crashed?
2622 * If so, wait for recovery first.
2624 if (unlikely(di
->i_flags
& cpu_to_le32(OCFS2_DIO_ORPHANED_FL
))) {
2625 ocfs2_inode_unlock(inode
, 1);
2627 wait_event_interruptible_timeout(OCFS2_I(inode
)->append_dio_wq
,
2628 ocfs2_dio_orphan_recovered(inode
),
2629 msecs_to_jiffies(OCFS2_DIO_ORPHANED_FL_CHECK_INTERVAL
));
2633 status
= ocfs2_prepare_orphan_dir(osb
, &orphan_dir_inode
,
2634 OCFS2_I(inode
)->ip_blkno
,
2640 goto bail_unlock_inode
;
2643 handle
= ocfs2_start_trans(osb
,
2644 OCFS2_INODE_ADD_TO_ORPHAN_CREDITS
);
2645 if (IS_ERR(handle
)) {
2646 status
= PTR_ERR(handle
);
2647 goto bail_unlock_orphan
;
2650 status
= ocfs2_orphan_add(osb
, handle
, inode
, di_bh
, orphan_name
,
2651 &orphan_insert
, orphan_dir_inode
, true);
2655 ocfs2_commit_trans(osb
, handle
);
2658 ocfs2_inode_unlock(orphan_dir_inode
, 1);
2659 mutex_unlock(&orphan_dir_inode
->i_mutex
);
2660 iput(orphan_dir_inode
);
2662 ocfs2_free_dir_lookup_result(&orphan_insert
);
2665 ocfs2_inode_unlock(inode
, 1);
2672 int ocfs2_del_inode_from_orphan(struct ocfs2_super
*osb
,
2673 struct inode
*inode
, int update_isize
,
2676 struct inode
*orphan_dir_inode
= NULL
;
2677 struct buffer_head
*orphan_dir_bh
= NULL
;
2678 struct buffer_head
*di_bh
= NULL
;
2679 struct ocfs2_dinode
*di
= NULL
;
2680 handle_t
*handle
= NULL
;
2683 status
= ocfs2_inode_lock(inode
, &di_bh
, 1);
2688 di
= (struct ocfs2_dinode
*) di_bh
->b_data
;
2690 orphan_dir_inode
= ocfs2_get_system_file_inode(osb
,
2691 ORPHAN_DIR_SYSTEM_INODE
,
2692 le16_to_cpu(di
->i_dio_orphaned_slot
));
2693 if (!orphan_dir_inode
) {
2696 goto bail_unlock_inode
;
2699 mutex_lock(&orphan_dir_inode
->i_mutex
);
2700 status
= ocfs2_inode_lock(orphan_dir_inode
, &orphan_dir_bh
, 1);
2702 mutex_unlock(&orphan_dir_inode
->i_mutex
);
2703 iput(orphan_dir_inode
);
2705 goto bail_unlock_inode
;
2708 handle
= ocfs2_start_trans(osb
,
2709 OCFS2_INODE_DEL_FROM_ORPHAN_CREDITS
);
2710 if (IS_ERR(handle
)) {
2711 status
= PTR_ERR(handle
);
2712 goto bail_unlock_orphan
;
2715 BUG_ON(!(di
->i_flags
& cpu_to_le32(OCFS2_DIO_ORPHANED_FL
)));
2717 status
= ocfs2_orphan_del(osb
, handle
, orphan_dir_inode
,
2718 inode
, orphan_dir_bh
, true);
2724 status
= ocfs2_journal_access_di(handle
,
2727 OCFS2_JOURNAL_ACCESS_WRITE
);
2733 di
->i_flags
&= ~cpu_to_le32(OCFS2_DIO_ORPHANED_FL
);
2734 di
->i_dio_orphaned_slot
= 0;
2737 status
= ocfs2_set_inode_size(handle
, inode
, di_bh
, end
);
2741 ocfs2_journal_dirty(handle
, di_bh
);
2744 ocfs2_commit_trans(osb
, handle
);
2747 ocfs2_inode_unlock(orphan_dir_inode
, 1);
2748 mutex_unlock(&orphan_dir_inode
->i_mutex
);
2749 brelse(orphan_dir_bh
);
2750 iput(orphan_dir_inode
);
2753 ocfs2_inode_unlock(inode
, 1);
2760 int ocfs2_mv_orphaned_inode_to_new(struct inode
*dir
,
2761 struct inode
*inode
,
2762 struct dentry
*dentry
)
2765 struct buffer_head
*parent_di_bh
= NULL
;
2766 handle_t
*handle
= NULL
;
2767 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
2768 struct ocfs2_dinode
*dir_di
, *di
;
2769 struct inode
*orphan_dir_inode
= NULL
;
2770 struct buffer_head
*orphan_dir_bh
= NULL
;
2771 struct buffer_head
*di_bh
= NULL
;
2772 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
2774 trace_ocfs2_mv_orphaned_inode_to_new(dir
, dentry
,
2775 dentry
->d_name
.len
, dentry
->d_name
.name
,
2776 (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
2777 (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
2779 status
= ocfs2_inode_lock(dir
, &parent_di_bh
, 1);
2781 if (status
!= -ENOENT
)
2786 dir_di
= (struct ocfs2_dinode
*) parent_di_bh
->b_data
;
2787 if (!dir_di
->i_links_count
) {
2788 /* can't make a file in a deleted directory. */
2793 status
= ocfs2_check_dir_for_entry(dir
, dentry
->d_name
.name
,
2794 dentry
->d_name
.len
);
2798 /* get a spot inside the dir. */
2799 status
= ocfs2_prepare_dir_for_insert(osb
, dir
, parent_di_bh
,
2800 dentry
->d_name
.name
,
2801 dentry
->d_name
.len
, &lookup
);
2807 orphan_dir_inode
= ocfs2_get_system_file_inode(osb
,
2808 ORPHAN_DIR_SYSTEM_INODE
,
2810 if (!orphan_dir_inode
) {
2816 mutex_lock(&orphan_dir_inode
->i_mutex
);
2818 status
= ocfs2_inode_lock(orphan_dir_inode
, &orphan_dir_bh
, 1);
2821 mutex_unlock(&orphan_dir_inode
->i_mutex
);
2822 iput(orphan_dir_inode
);
2826 status
= ocfs2_read_inode_block(inode
, &di_bh
);
2832 handle
= ocfs2_start_trans(osb
, ocfs2_rename_credits(osb
->sb
));
2833 if (IS_ERR(handle
)) {
2834 status
= PTR_ERR(handle
);
2840 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
),
2841 di_bh
, OCFS2_JOURNAL_ACCESS_WRITE
);
2847 status
= ocfs2_orphan_del(osb
, handle
, orphan_dir_inode
, inode
,
2848 orphan_dir_bh
, false);
2854 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
2855 di
->i_flags
&= ~cpu_to_le32(OCFS2_ORPHANED_FL
);
2856 di
->i_orphaned_slot
= 0;
2857 set_nlink(inode
, 1);
2858 ocfs2_set_links_count(di
, inode
->i_nlink
);
2859 ocfs2_update_inode_fsync_trans(handle
, inode
, 1);
2860 ocfs2_journal_dirty(handle
, di_bh
);
2862 status
= ocfs2_add_entry(handle
, dentry
, inode
,
2863 OCFS2_I(inode
)->ip_blkno
, parent_di_bh
,
2870 status
= ocfs2_dentry_attach_lock(dentry
, inode
,
2871 OCFS2_I(dir
)->ip_blkno
);
2877 d_instantiate(dentry
, inode
);
2880 ocfs2_commit_trans(osb
, handle
);
2882 ocfs2_inode_unlock(orphan_dir_inode
, 1);
2883 mutex_unlock(&orphan_dir_inode
->i_mutex
);
2884 iput(orphan_dir_inode
);
2887 ocfs2_inode_unlock(dir
, 1);
2890 brelse(parent_di_bh
);
2891 brelse(orphan_dir_bh
);
2893 ocfs2_free_dir_lookup_result(&lookup
);
2901 const struct inode_operations ocfs2_dir_iops
= {
2902 .create
= ocfs2_create
,
2903 .lookup
= ocfs2_lookup
,
2905 .unlink
= ocfs2_unlink
,
2906 .rmdir
= ocfs2_unlink
,
2907 .symlink
= ocfs2_symlink
,
2908 .mkdir
= ocfs2_mkdir
,
2909 .mknod
= ocfs2_mknod
,
2910 .rename
= ocfs2_rename
,
2911 .setattr
= ocfs2_setattr
,
2912 .getattr
= ocfs2_getattr
,
2913 .permission
= ocfs2_permission
,
2914 .setxattr
= generic_setxattr
,
2915 .getxattr
= generic_getxattr
,
2916 .listxattr
= ocfs2_listxattr
,
2917 .removexattr
= generic_removexattr
,
2918 .fiemap
= ocfs2_fiemap
,
2919 .get_acl
= ocfs2_iop_get_acl
,
2920 .set_acl
= ocfs2_iop_set_acl
,