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
);
84 static int ocfs2_orphan_add(struct ocfs2_super
*osb
,
87 struct buffer_head
*fe_bh
,
89 struct ocfs2_dir_lookup_result
*lookup
,
90 struct inode
*orphan_dir_inode
);
92 static int ocfs2_create_symlink_data(struct ocfs2_super
*osb
,
97 /* An orphan dir name is an 8 byte value, printed as a hex string */
98 #define OCFS2_ORPHAN_NAMELEN ((int)(2 * sizeof(u64)))
100 static struct dentry
*ocfs2_lookup(struct inode
*dir
, struct dentry
*dentry
,
105 struct inode
*inode
= NULL
;
107 struct ocfs2_inode_info
*oi
;
109 trace_ocfs2_lookup(dir
, dentry
, dentry
->d_name
.len
,
111 (unsigned long long)OCFS2_I(dir
)->ip_blkno
, 0);
113 if (dentry
->d_name
.len
> OCFS2_MAX_FILENAME_LEN
) {
114 ret
= ERR_PTR(-ENAMETOOLONG
);
118 status
= ocfs2_inode_lock_nested(dir
, NULL
, 0, OI_LS_PARENT
);
120 if (status
!= -ENOENT
)
122 ret
= ERR_PTR(status
);
126 status
= ocfs2_lookup_ino_from_name(dir
, dentry
->d_name
.name
,
127 dentry
->d_name
.len
, &blkno
);
131 inode
= ocfs2_iget(OCFS2_SB(dir
->i_sb
), blkno
, 0, 0);
133 ret
= ERR_PTR(-EACCES
);
138 /* Clear any orphaned state... If we were able to look up the
139 * inode from a directory, it certainly can't be orphaned. We
140 * might have the bad state from a node which intended to
141 * orphan this inode but crashed before it could commit the
143 spin_lock(&oi
->ip_lock
);
144 oi
->ip_flags
&= ~OCFS2_INODE_MAYBE_ORPHANED
;
145 spin_unlock(&oi
->ip_lock
);
148 ret
= d_splice_alias(inode
, dentry
);
152 * If d_splice_alias() finds a DCACHE_DISCONNECTED
153 * dentry, it will d_move() it on top of ourse. The
154 * return value will indicate this however, so in
155 * those cases, we switch them around for the locking
158 * NOTE: This dentry already has ->d_op set from
159 * ocfs2_get_parent() and ocfs2_get_dentry()
164 status
= ocfs2_dentry_attach_lock(dentry
, inode
,
165 OCFS2_I(dir
)->ip_blkno
);
168 ret
= ERR_PTR(status
);
172 ocfs2_dentry_attach_gen(dentry
);
175 /* Don't drop the cluster lock until *after* the d_add --
176 * unlink on another node will message us to remove that
177 * dentry under this lock so otherwise we can race this with
178 * the downconvert thread and have a stale dentry. */
179 ocfs2_inode_unlock(dir
, 0);
183 trace_ocfs2_lookup_ret(ret
);
188 static struct inode
*ocfs2_get_init_inode(struct inode
*dir
, umode_t mode
)
192 inode
= new_inode(dir
->i_sb
);
194 mlog(ML_ERROR
, "new_inode failed!\n");
198 /* populate as many fields early on as possible - many of
199 * these are used by the support functions here and in
203 inode_init_owner(inode
, dir
, mode
);
204 dquot_initialize(inode
);
208 static int ocfs2_mknod(struct inode
*dir
,
209 struct dentry
*dentry
,
214 struct buffer_head
*parent_fe_bh
= NULL
;
215 handle_t
*handle
= NULL
;
216 struct ocfs2_super
*osb
;
217 struct ocfs2_dinode
*dirfe
;
218 struct buffer_head
*new_fe_bh
= NULL
;
219 struct inode
*inode
= NULL
;
220 struct ocfs2_alloc_context
*inode_ac
= NULL
;
221 struct ocfs2_alloc_context
*data_ac
= NULL
;
222 struct ocfs2_alloc_context
*meta_ac
= NULL
;
223 int want_clusters
= 0;
225 int xattr_credits
= 0;
226 struct ocfs2_security_xattr_info si
= {
229 int did_quota_inode
= 0;
230 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
232 int did_block_signals
= 0;
233 struct posix_acl
*default_acl
= NULL
, *acl
= NULL
;
235 trace_ocfs2_mknod(dir
, dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
,
236 (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
237 (unsigned long)dev
, mode
);
239 dquot_initialize(dir
);
241 /* get our super block */
242 osb
= OCFS2_SB(dir
->i_sb
);
244 status
= ocfs2_inode_lock(dir
, &parent_fe_bh
, 1);
246 if (status
!= -ENOENT
)
251 if (S_ISDIR(mode
) && (dir
->i_nlink
>= ocfs2_link_max(osb
))) {
256 dirfe
= (struct ocfs2_dinode
*) parent_fe_bh
->b_data
;
257 if (!ocfs2_read_links_count(dirfe
)) {
258 /* can't make a file in a deleted directory. */
263 status
= ocfs2_check_dir_for_entry(dir
, dentry
->d_name
.name
,
268 /* get a spot inside the dir. */
269 status
= ocfs2_prepare_dir_for_insert(osb
, dir
, parent_fe_bh
,
271 dentry
->d_name
.len
, &lookup
);
277 /* reserve an inode spot */
278 status
= ocfs2_reserve_new_inode(osb
, &inode_ac
);
280 if (status
!= -ENOSPC
)
285 inode
= ocfs2_get_init_inode(dir
, mode
);
292 /* get security xattr */
293 status
= ocfs2_init_security_get(inode
, dir
, &dentry
->d_name
, &si
);
295 if (status
== -EOPNOTSUPP
)
303 /* calculate meta data/clusters for setting security and acl xattr */
304 status
= ocfs2_calc_xattr_init(dir
, parent_fe_bh
, mode
,
306 &xattr_credits
, &want_meta
);
312 /* Reserve a cluster if creating an extent based directory. */
313 if (S_ISDIR(mode
) && !ocfs2_supports_inline_data(osb
)) {
316 /* Dir indexing requires extra space as well */
317 if (ocfs2_supports_indexed_dirs(osb
))
321 status
= ocfs2_reserve_new_metadata_blocks(osb
, want_meta
, &meta_ac
);
323 if (status
!= -ENOSPC
)
328 status
= ocfs2_reserve_clusters(osb
, want_clusters
, &data_ac
);
330 if (status
!= -ENOSPC
)
335 status
= posix_acl_create(dir
, &mode
, &default_acl
, &acl
);
341 handle
= ocfs2_start_trans(osb
, ocfs2_mknod_credits(osb
->sb
,
344 if (IS_ERR(handle
)) {
345 status
= PTR_ERR(handle
);
351 /* Starting to change things, restart is no longer possible. */
352 ocfs2_block_signals(&oldset
);
353 did_block_signals
= 1;
355 status
= dquot_alloc_inode(inode
);
360 /* do the real work now. */
361 status
= ocfs2_mknod_locked(osb
, dir
, inode
, dev
,
362 &new_fe_bh
, parent_fe_bh
, handle
,
370 status
= ocfs2_fill_new_dir(osb
, handle
, dir
, inode
,
371 new_fe_bh
, data_ac
, meta_ac
);
377 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(dir
),
379 OCFS2_JOURNAL_ACCESS_WRITE
);
384 ocfs2_add_links_count(dirfe
, 1);
385 ocfs2_journal_dirty(handle
, parent_fe_bh
);
390 status
= ocfs2_set_acl(handle
, inode
, new_fe_bh
,
391 ACL_TYPE_DEFAULT
, default_acl
,
394 if (!status
&& acl
) {
395 status
= ocfs2_set_acl(handle
, inode
, new_fe_bh
,
396 ACL_TYPE_ACCESS
, acl
,
406 status
= ocfs2_init_security_set(handle
, inode
, new_fe_bh
, &si
,
415 * Do this before adding the entry to the directory. We add
416 * also set d_op after success so that ->d_iput() will cleanup
417 * the dentry lock even if ocfs2_add_entry() fails below.
419 status
= ocfs2_dentry_attach_lock(dentry
, inode
,
420 OCFS2_I(dir
)->ip_blkno
);
426 status
= ocfs2_add_entry(handle
, dentry
, inode
,
427 OCFS2_I(inode
)->ip_blkno
, parent_fe_bh
,
434 insert_inode_hash(inode
);
435 d_instantiate(dentry
, inode
);
439 posix_acl_release(default_acl
);
441 posix_acl_release(acl
);
442 if (status
< 0 && did_quota_inode
)
443 dquot_free_inode(inode
);
445 ocfs2_commit_trans(osb
, handle
);
447 ocfs2_inode_unlock(dir
, 1);
448 if (did_block_signals
)
449 ocfs2_unblock_signals(&oldset
);
452 brelse(parent_fe_bh
);
456 ocfs2_free_dir_lookup_result(&lookup
);
459 ocfs2_free_alloc_context(inode_ac
);
462 ocfs2_free_alloc_context(data_ac
);
465 ocfs2_free_alloc_context(meta_ac
);
468 * We should call iput after the i_mutex of the bitmap been
469 * unlocked in ocfs2_free_alloc_context, or the
470 * ocfs2_delete_inode will mutex_lock again.
472 if ((status
< 0) && inode
) {
473 OCFS2_I(inode
)->ip_flags
|= OCFS2_INODE_SKIP_ORPHAN_DIR
;
484 static int __ocfs2_mknod_locked(struct inode
*dir
,
487 struct buffer_head
**new_fe_bh
,
488 struct buffer_head
*parent_fe_bh
,
490 struct ocfs2_alloc_context
*inode_ac
,
491 u64 fe_blkno
, u64 suballoc_loc
, u16 suballoc_bit
)
494 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
495 struct ocfs2_dinode
*fe
= NULL
;
496 struct ocfs2_extent_list
*fel
;
501 /* populate as many fields early on as possible - many of
502 * these are used by the support functions here and in
504 inode
->i_ino
= ino_from_blkno(osb
->sb
, fe_blkno
);
505 OCFS2_I(inode
)->ip_blkno
= fe_blkno
;
506 spin_lock(&osb
->osb_lock
);
507 inode
->i_generation
= osb
->s_next_generation
++;
508 spin_unlock(&osb
->osb_lock
);
510 *new_fe_bh
= sb_getblk(osb
->sb
, fe_blkno
);
516 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode
), *new_fe_bh
);
518 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
),
520 OCFS2_JOURNAL_ACCESS_CREATE
);
526 fe
= (struct ocfs2_dinode
*) (*new_fe_bh
)->b_data
;
527 memset(fe
, 0, osb
->sb
->s_blocksize
);
529 fe
->i_generation
= cpu_to_le32(inode
->i_generation
);
530 fe
->i_fs_generation
= cpu_to_le32(osb
->fs_generation
);
531 fe
->i_blkno
= cpu_to_le64(fe_blkno
);
532 fe
->i_suballoc_loc
= cpu_to_le64(suballoc_loc
);
533 fe
->i_suballoc_bit
= cpu_to_le16(suballoc_bit
);
534 fe
->i_suballoc_slot
= cpu_to_le16(inode_ac
->ac_alloc_slot
);
535 fe
->i_uid
= cpu_to_le32(i_uid_read(inode
));
536 fe
->i_gid
= cpu_to_le32(i_gid_read(inode
));
537 fe
->i_mode
= cpu_to_le16(inode
->i_mode
);
538 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
))
539 fe
->id1
.dev1
.i_rdev
= cpu_to_le64(huge_encode_dev(dev
));
541 ocfs2_set_links_count(fe
, inode
->i_nlink
);
543 fe
->i_last_eb_blk
= 0;
544 strcpy(fe
->i_signature
, OCFS2_INODE_SIGNATURE
);
545 fe
->i_flags
|= cpu_to_le32(OCFS2_VALID_FL
);
546 fe
->i_atime
= fe
->i_ctime
= fe
->i_mtime
=
547 cpu_to_le64(CURRENT_TIME
.tv_sec
);
548 fe
->i_mtime_nsec
= fe
->i_ctime_nsec
= fe
->i_atime_nsec
=
549 cpu_to_le32(CURRENT_TIME
.tv_nsec
);
553 * If supported, directories start with inline data. If inline
554 * isn't supported, but indexing is, we start them as indexed.
556 feat
= le16_to_cpu(fe
->i_dyn_features
);
557 if (S_ISDIR(inode
->i_mode
) && ocfs2_supports_inline_data(osb
)) {
558 fe
->i_dyn_features
= cpu_to_le16(feat
| OCFS2_INLINE_DATA_FL
);
560 fe
->id2
.i_data
.id_count
= cpu_to_le16(
561 ocfs2_max_inline_data_with_xattr(osb
->sb
, fe
));
563 fel
= &fe
->id2
.i_list
;
564 fel
->l_tree_depth
= 0;
565 fel
->l_next_free_rec
= 0;
566 fel
->l_count
= cpu_to_le16(ocfs2_extent_recs_per_inode(osb
->sb
));
569 ocfs2_journal_dirty(handle
, *new_fe_bh
);
571 ocfs2_populate_inode(inode
, fe
, 1);
572 ocfs2_ci_set_new(osb
, INODE_CACHE(inode
));
573 if (!ocfs2_mount_local(osb
)) {
574 status
= ocfs2_create_new_inode_locks(inode
);
579 status
= 0; /* error in ocfs2_create_new_inode_locks is not
595 static int ocfs2_mknod_locked(struct ocfs2_super
*osb
,
599 struct buffer_head
**new_fe_bh
,
600 struct buffer_head
*parent_fe_bh
,
602 struct ocfs2_alloc_context
*inode_ac
)
605 u64 suballoc_loc
, fe_blkno
= 0;
610 status
= ocfs2_claim_new_inode(handle
, dir
, parent_fe_bh
,
611 inode_ac
, &suballoc_loc
,
612 &suballoc_bit
, &fe_blkno
);
618 return __ocfs2_mknod_locked(dir
, inode
, dev
, new_fe_bh
,
619 parent_fe_bh
, handle
, inode_ac
,
620 fe_blkno
, suballoc_loc
, suballoc_bit
);
623 static int ocfs2_mkdir(struct inode
*dir
,
624 struct dentry
*dentry
,
629 trace_ocfs2_mkdir(dir
, dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
,
630 OCFS2_I(dir
)->ip_blkno
, mode
);
631 ret
= ocfs2_mknod(dir
, dentry
, mode
| S_IFDIR
, 0);
638 static int ocfs2_create(struct inode
*dir
,
639 struct dentry
*dentry
,
645 trace_ocfs2_create(dir
, dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
,
646 (unsigned long long)OCFS2_I(dir
)->ip_blkno
, mode
);
647 ret
= ocfs2_mknod(dir
, dentry
, mode
| S_IFREG
, 0);
654 static int ocfs2_link(struct dentry
*old_dentry
,
656 struct dentry
*dentry
)
659 struct inode
*inode
= old_dentry
->d_inode
;
661 struct buffer_head
*fe_bh
= NULL
;
662 struct buffer_head
*parent_fe_bh
= NULL
;
663 struct ocfs2_dinode
*fe
= NULL
;
664 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
665 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
668 trace_ocfs2_link((unsigned long long)OCFS2_I(inode
)->ip_blkno
,
669 old_dentry
->d_name
.len
, old_dentry
->d_name
.name
,
670 dentry
->d_name
.len
, dentry
->d_name
.name
);
672 if (S_ISDIR(inode
->i_mode
))
675 dquot_initialize(dir
);
677 err
= ocfs2_inode_lock_nested(dir
, &parent_fe_bh
, 1, OI_LS_PARENT
);
689 err
= ocfs2_check_dir_for_entry(dir
, dentry
->d_name
.name
,
694 err
= ocfs2_prepare_dir_for_insert(osb
, dir
, parent_fe_bh
,
696 dentry
->d_name
.len
, &lookup
);
702 err
= ocfs2_inode_lock(inode
, &fe_bh
, 1);
709 fe
= (struct ocfs2_dinode
*) fe_bh
->b_data
;
710 if (ocfs2_read_links_count(fe
) >= ocfs2_link_max(osb
)) {
712 goto out_unlock_inode
;
715 handle
= ocfs2_start_trans(osb
, ocfs2_link_credits(osb
->sb
));
716 if (IS_ERR(handle
)) {
717 err
= PTR_ERR(handle
);
720 goto out_unlock_inode
;
723 /* Starting to change things, restart is no longer possible. */
724 ocfs2_block_signals(&oldset
);
726 err
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
), fe_bh
,
727 OCFS2_JOURNAL_ACCESS_WRITE
);
734 inode
->i_ctime
= CURRENT_TIME
;
735 ocfs2_set_links_count(fe
, inode
->i_nlink
);
736 fe
->i_ctime
= cpu_to_le64(inode
->i_ctime
.tv_sec
);
737 fe
->i_ctime_nsec
= cpu_to_le32(inode
->i_ctime
.tv_nsec
);
738 ocfs2_journal_dirty(handle
, fe_bh
);
740 err
= ocfs2_add_entry(handle
, dentry
, inode
,
741 OCFS2_I(inode
)->ip_blkno
,
742 parent_fe_bh
, &lookup
);
744 ocfs2_add_links_count(fe
, -1);
750 err
= ocfs2_dentry_attach_lock(dentry
, inode
, OCFS2_I(dir
)->ip_blkno
);
757 d_instantiate(dentry
, inode
);
760 ocfs2_commit_trans(osb
, handle
);
761 ocfs2_unblock_signals(&oldset
);
763 ocfs2_inode_unlock(inode
, 1);
766 ocfs2_inode_unlock(dir
, 1);
769 brelse(parent_fe_bh
);
771 ocfs2_free_dir_lookup_result(&lookup
);
780 * Takes and drops an exclusive lock on the given dentry. This will
781 * force other nodes to drop it.
783 static int ocfs2_remote_dentry_delete(struct dentry
*dentry
)
787 ret
= ocfs2_dentry_lock(dentry
, 1);
791 ocfs2_dentry_unlock(dentry
, 1);
796 static inline int ocfs2_inode_is_unlinkable(struct inode
*inode
)
798 if (S_ISDIR(inode
->i_mode
)) {
799 if (inode
->i_nlink
== 2)
804 if (inode
->i_nlink
== 1)
809 static int ocfs2_unlink(struct inode
*dir
,
810 struct dentry
*dentry
)
813 int child_locked
= 0;
814 bool is_unlinkable
= false;
815 struct inode
*inode
= dentry
->d_inode
;
816 struct inode
*orphan_dir
= NULL
;
817 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
819 struct ocfs2_dinode
*fe
= NULL
;
820 struct buffer_head
*fe_bh
= NULL
;
821 struct buffer_head
*parent_node_bh
= NULL
;
822 handle_t
*handle
= NULL
;
823 char orphan_name
[OCFS2_ORPHAN_NAMELEN
+ 1];
824 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
825 struct ocfs2_dir_lookup_result orphan_insert
= { NULL
, };
827 trace_ocfs2_unlink(dir
, dentry
, dentry
->d_name
.len
,
829 (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
830 (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
832 dquot_initialize(dir
);
834 BUG_ON(dentry
->d_parent
->d_inode
!= dir
);
836 if (inode
== osb
->root_inode
)
839 status
= ocfs2_inode_lock_nested(dir
, &parent_node_bh
, 1,
842 if (status
!= -ENOENT
)
847 status
= ocfs2_find_files_on_disk(dentry
->d_name
.name
,
848 dentry
->d_name
.len
, &blkno
, dir
,
851 if (status
!= -ENOENT
)
856 if (OCFS2_I(inode
)->ip_blkno
!= blkno
) {
859 trace_ocfs2_unlink_noent(
860 (unsigned long long)OCFS2_I(inode
)->ip_blkno
,
861 (unsigned long long)blkno
,
862 OCFS2_I(inode
)->ip_flags
);
866 status
= ocfs2_inode_lock(inode
, &fe_bh
, 1);
868 if (status
!= -ENOENT
)
874 if (S_ISDIR(inode
->i_mode
)) {
875 if (inode
->i_nlink
!= 2 || !ocfs2_empty_dir(inode
)) {
881 status
= ocfs2_remote_dentry_delete(dentry
);
883 /* This remote delete should succeed under all normal
889 if (ocfs2_inode_is_unlinkable(inode
)) {
890 status
= ocfs2_prepare_orphan_dir(osb
, &orphan_dir
,
891 OCFS2_I(inode
)->ip_blkno
,
892 orphan_name
, &orphan_insert
);
897 is_unlinkable
= true;
900 handle
= ocfs2_start_trans(osb
, ocfs2_unlink_credits(osb
->sb
));
901 if (IS_ERR(handle
)) {
902 status
= PTR_ERR(handle
);
908 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
), fe_bh
,
909 OCFS2_JOURNAL_ACCESS_WRITE
);
915 fe
= (struct ocfs2_dinode
*) fe_bh
->b_data
;
917 /* delete the name from the parent dir */
918 status
= ocfs2_delete_entry(handle
, dir
, &lookup
);
924 if (S_ISDIR(inode
->i_mode
))
927 ocfs2_set_links_count(fe
, inode
->i_nlink
);
928 ocfs2_journal_dirty(handle
, fe_bh
);
930 dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
931 if (S_ISDIR(inode
->i_mode
))
934 status
= ocfs2_mark_inode_dirty(handle
, dir
, parent_node_bh
);
937 if (S_ISDIR(inode
->i_mode
))
943 status
= ocfs2_orphan_add(osb
, handle
, inode
, fe_bh
,
944 orphan_name
, &orphan_insert
, orphan_dir
);
951 ocfs2_commit_trans(osb
, handle
);
954 ocfs2_inode_unlock(inode
, 1);
956 ocfs2_inode_unlock(dir
, 1);
959 /* This was locked for us in ocfs2_prepare_orphan_dir() */
960 ocfs2_inode_unlock(orphan_dir
, 1);
961 mutex_unlock(&orphan_dir
->i_mutex
);
966 brelse(parent_node_bh
);
968 ocfs2_free_dir_lookup_result(&orphan_insert
);
969 ocfs2_free_dir_lookup_result(&lookup
);
971 if (status
&& (status
!= -ENOTEMPTY
) && (status
!= -ENOENT
))
978 * The only place this should be used is rename!
979 * if they have the same id, then the 1st one is the only one locked.
981 static int ocfs2_double_lock(struct ocfs2_super
*osb
,
982 struct buffer_head
**bh1
,
983 struct inode
*inode1
,
984 struct buffer_head
**bh2
,
985 struct inode
*inode2
)
988 struct ocfs2_inode_info
*oi1
= OCFS2_I(inode1
);
989 struct ocfs2_inode_info
*oi2
= OCFS2_I(inode2
);
990 struct buffer_head
**tmpbh
;
991 struct inode
*tmpinode
;
993 trace_ocfs2_double_lock((unsigned long long)oi1
->ip_blkno
,
994 (unsigned long long)oi2
->ip_blkno
);
1001 /* we always want to lock the one with the lower lockid first. */
1002 if (oi1
->ip_blkno
!= oi2
->ip_blkno
) {
1003 if (oi1
->ip_blkno
< oi2
->ip_blkno
) {
1004 /* switch id1 and id2 around */
1014 status
= ocfs2_inode_lock_nested(inode2
, bh2
, 1,
1017 if (status
!= -ENOENT
)
1024 status
= ocfs2_inode_lock_nested(inode1
, bh1
, 1, OI_LS_RENAME2
);
1027 * An error return must mean that no cluster locks
1028 * were held on function exit.
1030 if (oi1
->ip_blkno
!= oi2
->ip_blkno
) {
1031 ocfs2_inode_unlock(inode2
, 1);
1036 if (status
!= -ENOENT
)
1040 trace_ocfs2_double_lock_end(
1041 (unsigned long long)OCFS2_I(inode1
)->ip_blkno
,
1042 (unsigned long long)OCFS2_I(inode2
)->ip_blkno
);
1050 static void ocfs2_double_unlock(struct inode
*inode1
, struct inode
*inode2
)
1052 ocfs2_inode_unlock(inode1
, 1);
1054 if (inode1
!= inode2
)
1055 ocfs2_inode_unlock(inode2
, 1);
1058 static int ocfs2_rename(struct inode
*old_dir
,
1059 struct dentry
*old_dentry
,
1060 struct inode
*new_dir
,
1061 struct dentry
*new_dentry
)
1063 int status
= 0, rename_lock
= 0, parents_locked
= 0, target_exists
= 0;
1064 int old_child_locked
= 0, new_child_locked
= 0, update_dot_dot
= 0;
1065 struct inode
*old_inode
= old_dentry
->d_inode
;
1066 struct inode
*new_inode
= new_dentry
->d_inode
;
1067 struct inode
*orphan_dir
= NULL
;
1068 struct ocfs2_dinode
*newfe
= NULL
;
1069 char orphan_name
[OCFS2_ORPHAN_NAMELEN
+ 1];
1070 struct buffer_head
*newfe_bh
= NULL
;
1071 struct buffer_head
*old_inode_bh
= NULL
;
1072 struct ocfs2_super
*osb
= NULL
;
1073 u64 newfe_blkno
, old_de_ino
;
1074 handle_t
*handle
= NULL
;
1075 struct buffer_head
*old_dir_bh
= NULL
;
1076 struct buffer_head
*new_dir_bh
= NULL
;
1077 u32 old_dir_nlink
= old_dir
->i_nlink
;
1078 struct ocfs2_dinode
*old_di
;
1079 struct ocfs2_dir_lookup_result old_inode_dot_dot_res
= { NULL
, };
1080 struct ocfs2_dir_lookup_result target_lookup_res
= { NULL
, };
1081 struct ocfs2_dir_lookup_result old_entry_lookup
= { NULL
, };
1082 struct ocfs2_dir_lookup_result orphan_insert
= { NULL
, };
1083 struct ocfs2_dir_lookup_result target_insert
= { NULL
, };
1085 /* At some point it might be nice to break this function up a
1088 trace_ocfs2_rename(old_dir
, old_dentry
, new_dir
, new_dentry
,
1089 old_dentry
->d_name
.len
, old_dentry
->d_name
.name
,
1090 new_dentry
->d_name
.len
, new_dentry
->d_name
.name
);
1092 dquot_initialize(old_dir
);
1093 dquot_initialize(new_dir
);
1095 osb
= OCFS2_SB(old_dir
->i_sb
);
1098 if (!igrab(new_inode
))
1102 /* Assume a directory hierarchy thusly:
1105 * a,b,c, and d are all directories.
1107 * from cwd of 'a' on both nodes:
1111 * And that's why, just like the VFS, we need a file system
1113 if (old_dir
!= new_dir
&& S_ISDIR(old_inode
->i_mode
)) {
1114 status
= ocfs2_rename_lock(osb
);
1122 /* if old and new are the same, this'll just do one lock. */
1123 status
= ocfs2_double_lock(osb
, &old_dir_bh
, old_dir
,
1124 &new_dir_bh
, new_dir
);
1131 /* make sure both dirs have bhs
1132 * get an extra ref on old_dir_bh if old==new */
1135 new_dir_bh
= old_dir_bh
;
1138 mlog(ML_ERROR
, "no old_dir_bh!\n");
1145 * Aside from allowing a meta data update, the locking here
1146 * also ensures that the downconvert thread on other nodes
1147 * won't have to concurrently downconvert the inode and the
1150 status
= ocfs2_inode_lock_nested(old_inode
, &old_inode_bh
, 1,
1153 if (status
!= -ENOENT
)
1157 old_child_locked
= 1;
1159 status
= ocfs2_remote_dentry_delete(old_dentry
);
1165 if (S_ISDIR(old_inode
->i_mode
)) {
1166 u64 old_inode_parent
;
1169 status
= ocfs2_find_files_on_disk("..", 2, &old_inode_parent
,
1171 &old_inode_dot_dot_res
);
1177 if (old_inode_parent
!= OCFS2_I(old_dir
)->ip_blkno
) {
1182 if (!new_inode
&& new_dir
!= old_dir
&&
1183 new_dir
->i_nlink
>= ocfs2_link_max(osb
)) {
1189 status
= ocfs2_lookup_ino_from_name(old_dir
, old_dentry
->d_name
.name
,
1190 old_dentry
->d_name
.len
,
1198 * Check for inode number is _not_ due to possible IO errors.
1199 * We might rmdir the source, keep it as pwd of some process
1200 * and merrily kill the link to whatever was created under the
1201 * same name. Goodbye sticky bit ;-<
1203 if (old_de_ino
!= OCFS2_I(old_inode
)->ip_blkno
) {
1208 /* check if the target already exists (in which case we need
1210 status
= ocfs2_find_files_on_disk(new_dentry
->d_name
.name
,
1211 new_dentry
->d_name
.len
,
1212 &newfe_blkno
, new_dir
,
1213 &target_lookup_res
);
1214 /* The only error we allow here is -ENOENT because the new
1215 * file not existing is perfectly valid. */
1216 if ((status
< 0) && (status
!= -ENOENT
)) {
1217 /* If we cannot find the file specified we should just */
1218 /* return the error... */
1225 if (!target_exists
&& new_inode
) {
1227 * Target was unlinked by another node while we were
1228 * waiting to get to ocfs2_rename(). There isn't
1229 * anything we can do here to help the situation, so
1230 * bubble up the appropriate error.
1236 /* In case we need to overwrite an existing file, we blow it
1238 if (target_exists
) {
1239 /* VFS didn't think there existed an inode here, but
1240 * someone else in the cluster must have raced our
1241 * rename to create one. Today we error cleanly, in
1242 * the future we should consider calling iget to build
1243 * a new struct inode for this entry. */
1247 trace_ocfs2_rename_target_exists(new_dentry
->d_name
.len
,
1248 new_dentry
->d_name
.name
);
1252 if (OCFS2_I(new_inode
)->ip_blkno
!= newfe_blkno
) {
1255 trace_ocfs2_rename_disagree(
1256 (unsigned long long)OCFS2_I(new_inode
)->ip_blkno
,
1257 (unsigned long long)newfe_blkno
,
1258 OCFS2_I(new_inode
)->ip_flags
);
1262 status
= ocfs2_inode_lock(new_inode
, &newfe_bh
, 1);
1264 if (status
!= -ENOENT
)
1268 new_child_locked
= 1;
1270 status
= ocfs2_remote_dentry_delete(new_dentry
);
1276 newfe
= (struct ocfs2_dinode
*) newfe_bh
->b_data
;
1278 trace_ocfs2_rename_over_existing(
1279 (unsigned long long)newfe_blkno
, newfe_bh
, newfe_bh
?
1280 (unsigned long long)newfe_bh
->b_blocknr
: 0ULL);
1282 if (S_ISDIR(new_inode
->i_mode
) || (new_inode
->i_nlink
== 1)) {
1283 status
= ocfs2_prepare_orphan_dir(osb
, &orphan_dir
,
1284 OCFS2_I(new_inode
)->ip_blkno
,
1285 orphan_name
, &orphan_insert
);
1292 BUG_ON(new_dentry
->d_parent
->d_inode
!= new_dir
);
1294 status
= ocfs2_check_dir_for_entry(new_dir
,
1295 new_dentry
->d_name
.name
,
1296 new_dentry
->d_name
.len
);
1300 status
= ocfs2_prepare_dir_for_insert(osb
, new_dir
, new_dir_bh
,
1301 new_dentry
->d_name
.name
,
1302 new_dentry
->d_name
.len
,
1310 handle
= ocfs2_start_trans(osb
, ocfs2_rename_credits(osb
->sb
));
1311 if (IS_ERR(handle
)) {
1312 status
= PTR_ERR(handle
);
1318 if (target_exists
) {
1319 if (S_ISDIR(new_inode
->i_mode
)) {
1320 if (new_inode
->i_nlink
!= 2 ||
1321 !ocfs2_empty_dir(new_inode
)) {
1322 status
= -ENOTEMPTY
;
1326 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(new_inode
),
1328 OCFS2_JOURNAL_ACCESS_WRITE
);
1334 if (S_ISDIR(new_inode
->i_mode
) ||
1335 (ocfs2_read_links_count(newfe
) == 1)) {
1336 status
= ocfs2_orphan_add(osb
, handle
, new_inode
,
1337 newfe_bh
, orphan_name
,
1338 &orphan_insert
, orphan_dir
);
1345 /* change the dirent to point to the correct inode */
1346 status
= ocfs2_update_entry(new_dir
, handle
, &target_lookup_res
,
1352 new_dir
->i_version
++;
1354 if (S_ISDIR(new_inode
->i_mode
))
1355 ocfs2_set_links_count(newfe
, 0);
1357 ocfs2_add_links_count(newfe
, -1);
1358 ocfs2_journal_dirty(handle
, newfe_bh
);
1360 /* if the name was not found in new_dir, add it now */
1361 status
= ocfs2_add_entry(handle
, new_dentry
, old_inode
,
1362 OCFS2_I(old_inode
)->ip_blkno
,
1363 new_dir_bh
, &target_insert
);
1366 old_inode
->i_ctime
= CURRENT_TIME
;
1367 mark_inode_dirty(old_inode
);
1369 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(old_inode
),
1371 OCFS2_JOURNAL_ACCESS_WRITE
);
1373 old_di
= (struct ocfs2_dinode
*) old_inode_bh
->b_data
;
1375 old_di
->i_ctime
= cpu_to_le64(old_inode
->i_ctime
.tv_sec
);
1376 old_di
->i_ctime_nsec
= cpu_to_le32(old_inode
->i_ctime
.tv_nsec
);
1377 ocfs2_journal_dirty(handle
, old_inode_bh
);
1382 * Now that the name has been added to new_dir, remove the old name.
1384 * We don't keep any directory entry context around until now
1385 * because the insert might have changed the type of directory
1386 * we're dealing with.
1388 status
= ocfs2_find_entry(old_dentry
->d_name
.name
,
1389 old_dentry
->d_name
.len
, old_dir
,
1394 status
= ocfs2_delete_entry(handle
, old_dir
, &old_entry_lookup
);
1401 drop_nlink(new_inode
);
1402 new_inode
->i_ctime
= CURRENT_TIME
;
1404 old_dir
->i_ctime
= old_dir
->i_mtime
= CURRENT_TIME
;
1406 if (update_dot_dot
) {
1407 status
= ocfs2_update_entry(old_inode
, handle
,
1408 &old_inode_dot_dot_res
, new_dir
);
1409 drop_nlink(old_dir
);
1411 drop_nlink(new_inode
);
1414 mark_inode_dirty(new_dir
);
1417 mark_inode_dirty(old_dir
);
1418 ocfs2_mark_inode_dirty(handle
, old_dir
, old_dir_bh
);
1420 mark_inode_dirty(new_inode
);
1421 ocfs2_mark_inode_dirty(handle
, new_inode
, newfe_bh
);
1424 if (old_dir
!= new_dir
) {
1425 /* Keep the same times on both directories.*/
1426 new_dir
->i_ctime
= new_dir
->i_mtime
= old_dir
->i_ctime
;
1429 * This will also pick up the i_nlink change from the
1432 ocfs2_mark_inode_dirty(handle
, new_dir
, new_dir_bh
);
1435 if (old_dir_nlink
!= old_dir
->i_nlink
) {
1437 mlog(ML_ERROR
, "need to change nlink for old dir "
1438 "%llu from %d to %d but bh is NULL!\n",
1439 (unsigned long long)OCFS2_I(old_dir
)->ip_blkno
,
1440 (int)old_dir_nlink
, old_dir
->i_nlink
);
1442 struct ocfs2_dinode
*fe
;
1443 status
= ocfs2_journal_access_di(handle
,
1444 INODE_CACHE(old_dir
),
1446 OCFS2_JOURNAL_ACCESS_WRITE
);
1447 fe
= (struct ocfs2_dinode
*) old_dir_bh
->b_data
;
1448 ocfs2_set_links_count(fe
, old_dir
->i_nlink
);
1449 ocfs2_journal_dirty(handle
, old_dir_bh
);
1452 ocfs2_dentry_move(old_dentry
, new_dentry
, old_dir
, new_dir
);
1456 ocfs2_rename_unlock(osb
);
1459 ocfs2_commit_trans(osb
, handle
);
1462 ocfs2_double_unlock(old_dir
, new_dir
);
1464 if (old_child_locked
)
1465 ocfs2_inode_unlock(old_inode
, 1);
1467 if (new_child_locked
)
1468 ocfs2_inode_unlock(new_inode
, 1);
1471 /* This was locked for us in ocfs2_prepare_orphan_dir() */
1472 ocfs2_inode_unlock(orphan_dir
, 1);
1473 mutex_unlock(&orphan_dir
->i_mutex
);
1478 sync_mapping_buffers(old_inode
->i_mapping
);
1483 ocfs2_free_dir_lookup_result(&target_lookup_res
);
1484 ocfs2_free_dir_lookup_result(&old_entry_lookup
);
1485 ocfs2_free_dir_lookup_result(&old_inode_dot_dot_res
);
1486 ocfs2_free_dir_lookup_result(&orphan_insert
);
1487 ocfs2_free_dir_lookup_result(&target_insert
);
1490 brelse(old_inode_bh
);
1501 * we expect i_size = strlen(symname). Copy symname into the file
1502 * data, including the null terminator.
1504 static int ocfs2_create_symlink_data(struct ocfs2_super
*osb
,
1506 struct inode
*inode
,
1507 const char *symname
)
1509 struct buffer_head
**bhs
= NULL
;
1511 struct super_block
*sb
= osb
->sb
;
1512 u64 p_blkno
, p_blocks
;
1513 int virtual, blocks
, status
, i
, bytes_left
;
1515 bytes_left
= i_size_read(inode
) + 1;
1516 /* we can't trust i_blocks because we're actually going to
1517 * write i_size + 1 bytes. */
1518 blocks
= (bytes_left
+ sb
->s_blocksize
- 1) >> sb
->s_blocksize_bits
;
1520 trace_ocfs2_create_symlink_data((unsigned long long)inode
->i_blocks
,
1521 i_size_read(inode
), blocks
);
1523 /* Sanity check -- make sure we're going to fit. */
1525 ocfs2_clusters_to_bytes(sb
, OCFS2_I(inode
)->ip_clusters
)) {
1531 bhs
= kcalloc(blocks
, sizeof(struct buffer_head
*), GFP_KERNEL
);
1538 status
= ocfs2_extent_map_get_blocks(inode
, 0, &p_blkno
, &p_blocks
,
1545 /* links can never be larger than one cluster so we know this
1546 * is all going to be contiguous, but do a sanity check
1548 if ((p_blocks
<< sb
->s_blocksize_bits
) < bytes_left
) {
1555 while(bytes_left
> 0) {
1556 c
= &symname
[virtual * sb
->s_blocksize
];
1558 bhs
[virtual] = sb_getblk(sb
, p_blkno
);
1559 if (!bhs
[virtual]) {
1564 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode
),
1567 status
= ocfs2_journal_access(handle
, INODE_CACHE(inode
),
1569 OCFS2_JOURNAL_ACCESS_CREATE
);
1575 memset(bhs
[virtual]->b_data
, 0, sb
->s_blocksize
);
1577 memcpy(bhs
[virtual]->b_data
, c
,
1578 (bytes_left
> sb
->s_blocksize
) ? sb
->s_blocksize
:
1581 ocfs2_journal_dirty(handle
, bhs
[virtual]);
1585 bytes_left
-= sb
->s_blocksize
;
1592 for(i
= 0; i
< blocks
; i
++)
1602 static int ocfs2_symlink(struct inode
*dir
,
1603 struct dentry
*dentry
,
1604 const char *symname
)
1606 int status
, l
, credits
;
1608 struct ocfs2_super
*osb
= NULL
;
1609 struct inode
*inode
= NULL
;
1610 struct super_block
*sb
;
1611 struct buffer_head
*new_fe_bh
= NULL
;
1612 struct buffer_head
*parent_fe_bh
= NULL
;
1613 struct ocfs2_dinode
*fe
= NULL
;
1614 struct ocfs2_dinode
*dirfe
;
1615 handle_t
*handle
= NULL
;
1616 struct ocfs2_alloc_context
*inode_ac
= NULL
;
1617 struct ocfs2_alloc_context
*data_ac
= NULL
;
1618 struct ocfs2_alloc_context
*xattr_ac
= NULL
;
1619 int want_clusters
= 0;
1620 int xattr_credits
= 0;
1621 struct ocfs2_security_xattr_info si
= {
1624 int did_quota
= 0, did_quota_inode
= 0;
1625 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
1627 int did_block_signals
= 0;
1629 trace_ocfs2_symlink_begin(dir
, dentry
, symname
,
1630 dentry
->d_name
.len
, dentry
->d_name
.name
);
1632 dquot_initialize(dir
);
1637 l
= strlen(symname
) + 1;
1639 credits
= ocfs2_calc_symlink_credits(sb
);
1641 /* lock the parent directory */
1642 status
= ocfs2_inode_lock(dir
, &parent_fe_bh
, 1);
1644 if (status
!= -ENOENT
)
1649 dirfe
= (struct ocfs2_dinode
*) parent_fe_bh
->b_data
;
1650 if (!ocfs2_read_links_count(dirfe
)) {
1651 /* can't make a file in a deleted directory. */
1656 status
= ocfs2_check_dir_for_entry(dir
, dentry
->d_name
.name
,
1657 dentry
->d_name
.len
);
1661 status
= ocfs2_prepare_dir_for_insert(osb
, dir
, parent_fe_bh
,
1662 dentry
->d_name
.name
,
1663 dentry
->d_name
.len
, &lookup
);
1669 status
= ocfs2_reserve_new_inode(osb
, &inode_ac
);
1671 if (status
!= -ENOSPC
)
1676 inode
= ocfs2_get_init_inode(dir
, S_IFLNK
| S_IRWXUGO
);
1683 /* get security xattr */
1684 status
= ocfs2_init_security_get(inode
, dir
, &dentry
->d_name
, &si
);
1686 if (status
== -EOPNOTSUPP
)
1694 /* calculate meta data/clusters for setting security xattr */
1696 status
= ocfs2_calc_security_init(dir
, &si
, &want_clusters
,
1697 &xattr_credits
, &xattr_ac
);
1704 /* don't reserve bitmap space for fast symlinks. */
1705 if (l
> ocfs2_fast_symlink_chars(sb
))
1708 status
= ocfs2_reserve_clusters(osb
, want_clusters
, &data_ac
);
1710 if (status
!= -ENOSPC
)
1715 handle
= ocfs2_start_trans(osb
, credits
+ xattr_credits
);
1716 if (IS_ERR(handle
)) {
1717 status
= PTR_ERR(handle
);
1723 /* Starting to change things, restart is no longer possible. */
1724 ocfs2_block_signals(&oldset
);
1725 did_block_signals
= 1;
1727 status
= dquot_alloc_inode(inode
);
1730 did_quota_inode
= 1;
1732 trace_ocfs2_symlink_create(dir
, dentry
, dentry
->d_name
.len
,
1733 dentry
->d_name
.name
,
1734 (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
1737 status
= ocfs2_mknod_locked(osb
, dir
, inode
,
1738 0, &new_fe_bh
, parent_fe_bh
, handle
,
1745 fe
= (struct ocfs2_dinode
*) new_fe_bh
->b_data
;
1748 inode
->i_op
= &ocfs2_symlink_inode_operations
;
1749 if (l
> ocfs2_fast_symlink_chars(sb
)) {
1752 status
= dquot_alloc_space_nodirty(inode
,
1753 ocfs2_clusters_to_bytes(osb
->sb
, 1));
1757 inode
->i_mapping
->a_ops
= &ocfs2_aops
;
1758 status
= ocfs2_add_inode_data(osb
, inode
, &offset
, 1, 0,
1760 handle
, data_ac
, NULL
,
1763 if (status
!= -ENOSPC
&& status
!= -EINTR
) {
1765 "Failed to extend file to %llu\n",
1766 (unsigned long long)newsize
);
1772 i_size_write(inode
, newsize
);
1773 inode
->i_blocks
= ocfs2_inode_sector_count(inode
);
1775 inode
->i_mapping
->a_ops
= &ocfs2_fast_symlink_aops
;
1776 memcpy((char *) fe
->id2
.i_symlink
, symname
, l
);
1777 i_size_write(inode
, newsize
);
1778 inode
->i_blocks
= 0;
1781 status
= ocfs2_mark_inode_dirty(handle
, inode
, new_fe_bh
);
1787 if (!ocfs2_inode_is_fast_symlink(inode
)) {
1788 status
= ocfs2_create_symlink_data(osb
, handle
, inode
,
1797 status
= ocfs2_init_security_set(handle
, inode
, new_fe_bh
, &si
,
1806 * Do this before adding the entry to the directory. We add
1807 * also set d_op after success so that ->d_iput() will cleanup
1808 * the dentry lock even if ocfs2_add_entry() fails below.
1810 status
= ocfs2_dentry_attach_lock(dentry
, inode
, OCFS2_I(dir
)->ip_blkno
);
1816 status
= ocfs2_add_entry(handle
, dentry
, inode
,
1817 le64_to_cpu(fe
->i_blkno
), parent_fe_bh
,
1824 insert_inode_hash(inode
);
1825 d_instantiate(dentry
, inode
);
1827 if (status
< 0 && did_quota
)
1828 dquot_free_space_nodirty(inode
,
1829 ocfs2_clusters_to_bytes(osb
->sb
, 1));
1830 if (status
< 0 && did_quota_inode
)
1831 dquot_free_inode(inode
);
1833 ocfs2_commit_trans(osb
, handle
);
1835 ocfs2_inode_unlock(dir
, 1);
1836 if (did_block_signals
)
1837 ocfs2_unblock_signals(&oldset
);
1840 brelse(parent_fe_bh
);
1843 ocfs2_free_dir_lookup_result(&lookup
);
1845 ocfs2_free_alloc_context(inode_ac
);
1847 ocfs2_free_alloc_context(data_ac
);
1849 ocfs2_free_alloc_context(xattr_ac
);
1850 if ((status
< 0) && inode
) {
1851 OCFS2_I(inode
)->ip_flags
|= OCFS2_INODE_SKIP_ORPHAN_DIR
;
1862 static int ocfs2_blkno_stringify(u64 blkno
, char *name
)
1864 int status
, namelen
;
1866 namelen
= snprintf(name
, OCFS2_ORPHAN_NAMELEN
+ 1, "%016llx",
1876 if (namelen
!= OCFS2_ORPHAN_NAMELEN
) {
1882 trace_ocfs2_blkno_stringify(blkno
, name
, namelen
);
1891 static int ocfs2_lookup_lock_orphan_dir(struct ocfs2_super
*osb
,
1892 struct inode
**ret_orphan_dir
,
1893 struct buffer_head
**ret_orphan_dir_bh
)
1895 struct inode
*orphan_dir_inode
;
1896 struct buffer_head
*orphan_dir_bh
= NULL
;
1899 orphan_dir_inode
= ocfs2_get_system_file_inode(osb
,
1900 ORPHAN_DIR_SYSTEM_INODE
,
1902 if (!orphan_dir_inode
) {
1908 mutex_lock(&orphan_dir_inode
->i_mutex
);
1910 ret
= ocfs2_inode_lock(orphan_dir_inode
, &orphan_dir_bh
, 1);
1912 mutex_unlock(&orphan_dir_inode
->i_mutex
);
1913 iput(orphan_dir_inode
);
1919 *ret_orphan_dir
= orphan_dir_inode
;
1920 *ret_orphan_dir_bh
= orphan_dir_bh
;
1925 static int __ocfs2_prepare_orphan_dir(struct inode
*orphan_dir_inode
,
1926 struct buffer_head
*orphan_dir_bh
,
1929 struct ocfs2_dir_lookup_result
*lookup
)
1932 struct ocfs2_super
*osb
= OCFS2_SB(orphan_dir_inode
->i_sb
);
1934 ret
= ocfs2_blkno_stringify(blkno
, name
);
1940 ret
= ocfs2_prepare_dir_for_insert(osb
, orphan_dir_inode
,
1941 orphan_dir_bh
, name
,
1942 OCFS2_ORPHAN_NAMELEN
, lookup
);
1952 * ocfs2_prepare_orphan_dir() - Prepare an orphan directory for
1953 * insertion of an orphan.
1954 * @osb: ocfs2 file system
1955 * @ret_orphan_dir: Orphan dir inode - returned locked!
1956 * @blkno: Actual block number of the inode to be inserted into orphan dir.
1957 * @lookup: dir lookup result, to be passed back into functions like
1960 * Returns zero on success and the ret_orphan_dir, name and lookup
1961 * fields will be populated.
1963 * Returns non-zero on failure.
1965 static int ocfs2_prepare_orphan_dir(struct ocfs2_super
*osb
,
1966 struct inode
**ret_orphan_dir
,
1969 struct ocfs2_dir_lookup_result
*lookup
)
1971 struct inode
*orphan_dir_inode
= NULL
;
1972 struct buffer_head
*orphan_dir_bh
= NULL
;
1975 ret
= ocfs2_lookup_lock_orphan_dir(osb
, &orphan_dir_inode
,
1982 ret
= __ocfs2_prepare_orphan_dir(orphan_dir_inode
, orphan_dir_bh
,
1983 blkno
, name
, lookup
);
1989 *ret_orphan_dir
= orphan_dir_inode
;
1992 brelse(orphan_dir_bh
);
1995 ocfs2_inode_unlock(orphan_dir_inode
, 1);
1996 mutex_unlock(&orphan_dir_inode
->i_mutex
);
1997 iput(orphan_dir_inode
);
2005 static int ocfs2_orphan_add(struct ocfs2_super
*osb
,
2007 struct inode
*inode
,
2008 struct buffer_head
*fe_bh
,
2010 struct ocfs2_dir_lookup_result
*lookup
,
2011 struct inode
*orphan_dir_inode
)
2013 struct buffer_head
*orphan_dir_bh
= NULL
;
2015 struct ocfs2_dinode
*orphan_fe
;
2016 struct ocfs2_dinode
*fe
= (struct ocfs2_dinode
*) fe_bh
->b_data
;
2018 trace_ocfs2_orphan_add_begin(
2019 (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
2021 status
= ocfs2_read_inode_block(orphan_dir_inode
, &orphan_dir_bh
);
2027 status
= ocfs2_journal_access_di(handle
,
2028 INODE_CACHE(orphan_dir_inode
),
2030 OCFS2_JOURNAL_ACCESS_WRITE
);
2037 * We're going to journal the change of i_flags and i_orphaned_slot.
2038 * It's safe anyway, though some callers may duplicate the journaling.
2039 * Journaling within the func just make the logic look more
2042 status
= ocfs2_journal_access_di(handle
,
2045 OCFS2_JOURNAL_ACCESS_WRITE
);
2051 /* we're a cluster, and nlink can change on disk from
2052 * underneath us... */
2053 orphan_fe
= (struct ocfs2_dinode
*) orphan_dir_bh
->b_data
;
2054 if (S_ISDIR(inode
->i_mode
))
2055 ocfs2_add_links_count(orphan_fe
, 1);
2056 set_nlink(orphan_dir_inode
, ocfs2_read_links_count(orphan_fe
));
2057 ocfs2_journal_dirty(handle
, orphan_dir_bh
);
2059 status
= __ocfs2_add_entry(handle
, orphan_dir_inode
, name
,
2060 OCFS2_ORPHAN_NAMELEN
, inode
,
2061 OCFS2_I(inode
)->ip_blkno
,
2062 orphan_dir_bh
, lookup
);
2068 fe
->i_flags
|= cpu_to_le32(OCFS2_ORPHANED_FL
);
2069 OCFS2_I(inode
)->ip_flags
&= ~OCFS2_INODE_SKIP_ORPHAN_DIR
;
2071 /* Record which orphan dir our inode now resides
2072 * in. delete_inode will use this to determine which orphan
2074 fe
->i_orphaned_slot
= cpu_to_le16(osb
->slot_num
);
2076 ocfs2_journal_dirty(handle
, fe_bh
);
2078 trace_ocfs2_orphan_add_end((unsigned long long)OCFS2_I(inode
)->ip_blkno
,
2083 if (S_ISDIR(inode
->i_mode
))
2084 ocfs2_add_links_count(orphan_fe
, -1);
2085 set_nlink(orphan_dir_inode
, ocfs2_read_links_count(orphan_fe
));
2089 brelse(orphan_dir_bh
);
2094 /* unlike orphan_add, we expect the orphan dir to already be locked here. */
2095 int ocfs2_orphan_del(struct ocfs2_super
*osb
,
2097 struct inode
*orphan_dir_inode
,
2098 struct inode
*inode
,
2099 struct buffer_head
*orphan_dir_bh
)
2101 char name
[OCFS2_ORPHAN_NAMELEN
+ 1];
2102 struct ocfs2_dinode
*orphan_fe
;
2104 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
2106 status
= ocfs2_blkno_stringify(OCFS2_I(inode
)->ip_blkno
, name
);
2112 trace_ocfs2_orphan_del(
2113 (unsigned long long)OCFS2_I(orphan_dir_inode
)->ip_blkno
,
2114 name
, OCFS2_ORPHAN_NAMELEN
);
2116 /* find it's spot in the orphan directory */
2117 status
= ocfs2_find_entry(name
, OCFS2_ORPHAN_NAMELEN
, orphan_dir_inode
,
2124 /* remove it from the orphan directory */
2125 status
= ocfs2_delete_entry(handle
, orphan_dir_inode
, &lookup
);
2131 status
= ocfs2_journal_access_di(handle
,
2132 INODE_CACHE(orphan_dir_inode
),
2134 OCFS2_JOURNAL_ACCESS_WRITE
);
2140 /* do the i_nlink dance! :) */
2141 orphan_fe
= (struct ocfs2_dinode
*) orphan_dir_bh
->b_data
;
2142 if (S_ISDIR(inode
->i_mode
))
2143 ocfs2_add_links_count(orphan_fe
, -1);
2144 set_nlink(orphan_dir_inode
, ocfs2_read_links_count(orphan_fe
));
2145 ocfs2_journal_dirty(handle
, orphan_dir_bh
);
2148 ocfs2_free_dir_lookup_result(&lookup
);
2156 * ocfs2_prep_new_orphaned_file() - Prepare the orphan dir to receive a newly
2157 * allocated file. This is different from the typical 'add to orphan dir'
2158 * operation in that the inode does not yet exist. This is a problem because
2159 * the orphan dir stringifies the inode block number to come up with it's
2160 * dirent. Obviously if the inode does not yet exist we have a chicken and egg
2161 * problem. This function works around it by calling deeper into the orphan
2162 * and suballoc code than other callers. Use this only by necessity.
2163 * @dir: The directory which this inode will ultimately wind up under - not the
2165 * @dir_bh: buffer_head the @dir inode block
2166 * @orphan_name: string of length (CFS2_ORPHAN_NAMELEN + 1). Will be filled
2167 * with the string to be used for orphan dirent. Pass back to the orphan dir
2169 * @ret_orphan_dir: orphan dir inode returned to be passed back into orphan
2171 * @ret_di_blkno: block number where the new inode will be allocated.
2172 * @orphan_insert: Dir insert context to be passed back into orphan dir code.
2173 * @ret_inode_ac: Inode alloc context to be passed back to the allocator.
2175 * Returns zero on success and the ret_orphan_dir, name and lookup
2176 * fields will be populated.
2178 * Returns non-zero on failure.
2180 static int ocfs2_prep_new_orphaned_file(struct inode
*dir
,
2181 struct buffer_head
*dir_bh
,
2183 struct inode
**ret_orphan_dir
,
2185 struct ocfs2_dir_lookup_result
*orphan_insert
,
2186 struct ocfs2_alloc_context
**ret_inode_ac
)
2190 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
2191 struct inode
*orphan_dir
= NULL
;
2192 struct buffer_head
*orphan_dir_bh
= NULL
;
2193 struct ocfs2_alloc_context
*inode_ac
= NULL
;
2195 ret
= ocfs2_lookup_lock_orphan_dir(osb
, &orphan_dir
, &orphan_dir_bh
);
2201 /* reserve an inode spot */
2202 ret
= ocfs2_reserve_new_inode(osb
, &inode_ac
);
2209 ret
= ocfs2_find_new_inode_loc(dir
, dir_bh
, inode_ac
,
2216 ret
= __ocfs2_prepare_orphan_dir(orphan_dir
, orphan_dir_bh
,
2217 di_blkno
, orphan_name
, orphan_insert
);
2225 *ret_orphan_dir
= orphan_dir
;
2226 *ret_di_blkno
= di_blkno
;
2227 *ret_inode_ac
= inode_ac
;
2229 * orphan_name and orphan_insert are already up to
2230 * date via prepare_orphan_dir
2233 /* Unroll reserve_new_inode* */
2235 ocfs2_free_alloc_context(inode_ac
);
2237 /* Unroll orphan dir locking */
2238 mutex_unlock(&orphan_dir
->i_mutex
);
2239 ocfs2_inode_unlock(orphan_dir
, 1);
2243 brelse(orphan_dir_bh
);
2248 int ocfs2_create_inode_in_orphan(struct inode
*dir
,
2250 struct inode
**new_inode
)
2252 int status
, did_quota_inode
= 0;
2253 struct inode
*inode
= NULL
;
2254 struct inode
*orphan_dir
= NULL
;
2255 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
2256 struct ocfs2_dinode
*di
= NULL
;
2257 handle_t
*handle
= NULL
;
2258 char orphan_name
[OCFS2_ORPHAN_NAMELEN
+ 1];
2259 struct buffer_head
*parent_di_bh
= NULL
;
2260 struct buffer_head
*new_di_bh
= NULL
;
2261 struct ocfs2_alloc_context
*inode_ac
= NULL
;
2262 struct ocfs2_dir_lookup_result orphan_insert
= { NULL
, };
2263 u64
uninitialized_var(di_blkno
), suballoc_loc
;
2266 status
= ocfs2_inode_lock(dir
, &parent_di_bh
, 1);
2268 if (status
!= -ENOENT
)
2273 status
= ocfs2_prep_new_orphaned_file(dir
, parent_di_bh
,
2274 orphan_name
, &orphan_dir
,
2275 &di_blkno
, &orphan_insert
, &inode_ac
);
2277 if (status
!= -ENOSPC
)
2282 inode
= ocfs2_get_init_inode(dir
, mode
);
2289 handle
= ocfs2_start_trans(osb
, ocfs2_mknod_credits(osb
->sb
, 0, 0));
2290 if (IS_ERR(handle
)) {
2291 status
= PTR_ERR(handle
);
2297 status
= dquot_alloc_inode(inode
);
2300 did_quota_inode
= 1;
2302 status
= ocfs2_claim_new_inode_at_loc(handle
, dir
, inode_ac
,
2304 &suballoc_bit
, di_blkno
);
2311 /* do the real work now. */
2312 status
= __ocfs2_mknod_locked(dir
, inode
,
2313 0, &new_di_bh
, parent_di_bh
, handle
,
2314 inode_ac
, di_blkno
, suballoc_loc
,
2321 di
= (struct ocfs2_dinode
*)new_di_bh
->b_data
;
2322 status
= ocfs2_orphan_add(osb
, handle
, inode
, new_di_bh
, orphan_name
,
2323 &orphan_insert
, orphan_dir
);
2329 /* get open lock so that only nodes can't remove it from orphan dir. */
2330 status
= ocfs2_open_lock(inode
);
2334 insert_inode_hash(inode
);
2336 if (status
< 0 && did_quota_inode
)
2337 dquot_free_inode(inode
);
2339 ocfs2_commit_trans(osb
, handle
);
2342 /* This was locked for us in ocfs2_prepare_orphan_dir() */
2343 ocfs2_inode_unlock(orphan_dir
, 1);
2344 mutex_unlock(&orphan_dir
->i_mutex
);
2348 if ((status
< 0) && inode
) {
2354 ocfs2_free_alloc_context(inode_ac
);
2361 ocfs2_free_dir_lookup_result(&orphan_insert
);
2363 ocfs2_inode_unlock(dir
, 1);
2364 brelse(parent_di_bh
);
2368 int ocfs2_mv_orphaned_inode_to_new(struct inode
*dir
,
2369 struct inode
*inode
,
2370 struct dentry
*dentry
)
2373 struct buffer_head
*parent_di_bh
= NULL
;
2374 handle_t
*handle
= NULL
;
2375 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
2376 struct ocfs2_dinode
*dir_di
, *di
;
2377 struct inode
*orphan_dir_inode
= NULL
;
2378 struct buffer_head
*orphan_dir_bh
= NULL
;
2379 struct buffer_head
*di_bh
= NULL
;
2380 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
2382 trace_ocfs2_mv_orphaned_inode_to_new(dir
, dentry
,
2383 dentry
->d_name
.len
, dentry
->d_name
.name
,
2384 (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
2385 (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
2387 status
= ocfs2_inode_lock(dir
, &parent_di_bh
, 1);
2389 if (status
!= -ENOENT
)
2394 dir_di
= (struct ocfs2_dinode
*) parent_di_bh
->b_data
;
2395 if (!dir_di
->i_links_count
) {
2396 /* can't make a file in a deleted directory. */
2401 status
= ocfs2_check_dir_for_entry(dir
, dentry
->d_name
.name
,
2402 dentry
->d_name
.len
);
2406 /* get a spot inside the dir. */
2407 status
= ocfs2_prepare_dir_for_insert(osb
, dir
, parent_di_bh
,
2408 dentry
->d_name
.name
,
2409 dentry
->d_name
.len
, &lookup
);
2415 orphan_dir_inode
= ocfs2_get_system_file_inode(osb
,
2416 ORPHAN_DIR_SYSTEM_INODE
,
2418 if (!orphan_dir_inode
) {
2424 mutex_lock(&orphan_dir_inode
->i_mutex
);
2426 status
= ocfs2_inode_lock(orphan_dir_inode
, &orphan_dir_bh
, 1);
2429 mutex_unlock(&orphan_dir_inode
->i_mutex
);
2430 iput(orphan_dir_inode
);
2434 status
= ocfs2_read_inode_block(inode
, &di_bh
);
2440 handle
= ocfs2_start_trans(osb
, ocfs2_rename_credits(osb
->sb
));
2441 if (IS_ERR(handle
)) {
2442 status
= PTR_ERR(handle
);
2448 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
),
2449 di_bh
, OCFS2_JOURNAL_ACCESS_WRITE
);
2455 status
= ocfs2_orphan_del(osb
, handle
, orphan_dir_inode
, inode
,
2462 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
2463 di
->i_flags
&= ~cpu_to_le32(OCFS2_ORPHANED_FL
);
2464 di
->i_orphaned_slot
= 0;
2465 set_nlink(inode
, 1);
2466 ocfs2_set_links_count(di
, inode
->i_nlink
);
2467 ocfs2_journal_dirty(handle
, di_bh
);
2469 status
= ocfs2_add_entry(handle
, dentry
, inode
,
2470 OCFS2_I(inode
)->ip_blkno
, parent_di_bh
,
2477 status
= ocfs2_dentry_attach_lock(dentry
, inode
,
2478 OCFS2_I(dir
)->ip_blkno
);
2484 d_instantiate(dentry
, inode
);
2487 ocfs2_commit_trans(osb
, handle
);
2489 ocfs2_inode_unlock(orphan_dir_inode
, 1);
2490 mutex_unlock(&orphan_dir_inode
->i_mutex
);
2491 iput(orphan_dir_inode
);
2494 ocfs2_inode_unlock(dir
, 1);
2497 brelse(parent_di_bh
);
2498 brelse(orphan_dir_bh
);
2500 ocfs2_free_dir_lookup_result(&lookup
);
2508 const struct inode_operations ocfs2_dir_iops
= {
2509 .create
= ocfs2_create
,
2510 .lookup
= ocfs2_lookup
,
2512 .unlink
= ocfs2_unlink
,
2513 .rmdir
= ocfs2_unlink
,
2514 .symlink
= ocfs2_symlink
,
2515 .mkdir
= ocfs2_mkdir
,
2516 .mknod
= ocfs2_mknod
,
2517 .rename
= ocfs2_rename
,
2518 .setattr
= ocfs2_setattr
,
2519 .getattr
= ocfs2_getattr
,
2520 .permission
= ocfs2_permission
,
2521 .setxattr
= generic_setxattr
,
2522 .getxattr
= generic_getxattr
,
2523 .listxattr
= ocfs2_listxattr
,
2524 .removexattr
= generic_removexattr
,
2525 .fiemap
= ocfs2_fiemap
,
2526 .get_acl
= ocfs2_iop_get_acl
,
2527 .set_acl
= ocfs2_iop_set_acl
,