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 #define MLOG_MASK_PREFIX ML_NAMEI
46 #include <cluster/masklog.h>
54 #include "extent_map.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
,
101 struct nameidata
*nd
)
105 struct inode
*inode
= NULL
;
107 struct ocfs2_inode_info
*oi
;
109 mlog_entry("(0x%p, 0x%p, '%.*s')\n", dir
, dentry
,
110 dentry
->d_name
.len
, dentry
->d_name
.name
);
112 if (dentry
->d_name
.len
> OCFS2_MAX_FILENAME_LEN
) {
113 ret
= ERR_PTR(-ENAMETOOLONG
);
117 mlog(0, "find name %.*s in directory %llu\n", dentry
->d_name
.len
,
118 dentry
->d_name
.name
, (unsigned long long)OCFS2_I(dir
)->ip_blkno
);
120 status
= ocfs2_inode_lock_nested(dir
, NULL
, 0, OI_LS_PARENT
);
122 if (status
!= -ENOENT
)
124 ret
= ERR_PTR(status
);
128 status
= ocfs2_lookup_ino_from_name(dir
, dentry
->d_name
.name
,
129 dentry
->d_name
.len
, &blkno
);
133 inode
= ocfs2_iget(OCFS2_SB(dir
->i_sb
), blkno
, 0, 0);
135 ret
= ERR_PTR(-EACCES
);
140 /* Clear any orphaned state... If we were able to look up the
141 * inode from a directory, it certainly can't be orphaned. We
142 * might have the bad state from a node which intended to
143 * orphan this inode but crashed before it could commit the
145 spin_lock(&oi
->ip_lock
);
146 oi
->ip_flags
&= ~OCFS2_INODE_MAYBE_ORPHANED
;
147 spin_unlock(&oi
->ip_lock
);
150 dentry
->d_op
= &ocfs2_dentry_ops
;
151 ret
= d_splice_alias(inode
, dentry
);
155 * If d_splice_alias() finds a DCACHE_DISCONNECTED
156 * dentry, it will d_move() it on top of ourse. The
157 * return value will indicate this however, so in
158 * those cases, we switch them around for the locking
161 * NOTE: This dentry already has ->d_op set from
162 * ocfs2_get_parent() and ocfs2_get_dentry()
167 status
= ocfs2_dentry_attach_lock(dentry
, inode
,
168 OCFS2_I(dir
)->ip_blkno
);
171 ret
= ERR_PTR(status
);
177 /* Don't drop the cluster lock until *after* the d_add --
178 * unlink on another node will message us to remove that
179 * dentry under this lock so otherwise we can race this with
180 * the downconvert thread and have a stale dentry. */
181 ocfs2_inode_unlock(dir
, 0);
190 static struct inode
*ocfs2_get_init_inode(struct inode
*dir
, int mode
)
194 inode
= new_inode(dir
->i_sb
);
196 mlog(ML_ERROR
, "new_inode failed!\n");
200 /* populate as many fields early on as possible - many of
201 * these are used by the support functions here and in
207 inode
->i_uid
= current_fsuid();
208 if (dir
->i_mode
& S_ISGID
) {
209 inode
->i_gid
= dir
->i_gid
;
213 inode
->i_gid
= current_fsgid();
214 inode
->i_mode
= mode
;
215 dquot_initialize(inode
);
219 static int ocfs2_mknod(struct inode
*dir
,
220 struct dentry
*dentry
,
225 struct buffer_head
*parent_fe_bh
= NULL
;
226 handle_t
*handle
= NULL
;
227 struct ocfs2_super
*osb
;
228 struct ocfs2_dinode
*dirfe
;
229 struct buffer_head
*new_fe_bh
= NULL
;
230 struct inode
*inode
= NULL
;
231 struct ocfs2_alloc_context
*inode_ac
= NULL
;
232 struct ocfs2_alloc_context
*data_ac
= NULL
;
233 struct ocfs2_alloc_context
*meta_ac
= NULL
;
234 int want_clusters
= 0;
236 int xattr_credits
= 0;
237 struct ocfs2_security_xattr_info si
= {
240 int did_quota_inode
= 0;
241 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
243 int did_block_signals
= 0;
245 mlog_entry("(0x%p, 0x%p, %d, %lu, '%.*s')\n", dir
, dentry
, mode
,
246 (unsigned long)dev
, dentry
->d_name
.len
,
247 dentry
->d_name
.name
);
249 dquot_initialize(dir
);
251 /* get our super block */
252 osb
= OCFS2_SB(dir
->i_sb
);
254 status
= ocfs2_inode_lock(dir
, &parent_fe_bh
, 1);
256 if (status
!= -ENOENT
)
261 if (S_ISDIR(mode
) && (dir
->i_nlink
>= ocfs2_link_max(osb
))) {
266 dirfe
= (struct ocfs2_dinode
*) parent_fe_bh
->b_data
;
267 if (!ocfs2_read_links_count(dirfe
)) {
268 /* can't make a file in a deleted directory. */
273 status
= ocfs2_check_dir_for_entry(dir
, dentry
->d_name
.name
,
278 /* get a spot inside the dir. */
279 status
= ocfs2_prepare_dir_for_insert(osb
, dir
, parent_fe_bh
,
281 dentry
->d_name
.len
, &lookup
);
287 /* reserve an inode spot */
288 status
= ocfs2_reserve_new_inode(osb
, &inode_ac
);
290 if (status
!= -ENOSPC
)
295 inode
= ocfs2_get_init_inode(dir
, mode
);
302 /* get security xattr */
303 status
= ocfs2_init_security_get(inode
, dir
, &si
);
305 if (status
== -EOPNOTSUPP
)
313 /* calculate meta data/clusters for setting security and acl xattr */
314 status
= ocfs2_calc_xattr_init(dir
, parent_fe_bh
, mode
,
316 &xattr_credits
, &want_meta
);
322 /* Reserve a cluster if creating an extent based directory. */
323 if (S_ISDIR(mode
) && !ocfs2_supports_inline_data(osb
)) {
326 /* Dir indexing requires extra space as well */
327 if (ocfs2_supports_indexed_dirs(osb
))
331 status
= ocfs2_reserve_new_metadata_blocks(osb
, want_meta
, &meta_ac
);
333 if (status
!= -ENOSPC
)
338 status
= ocfs2_reserve_clusters(osb
, want_clusters
, &data_ac
);
340 if (status
!= -ENOSPC
)
345 handle
= ocfs2_start_trans(osb
, ocfs2_mknod_credits(osb
->sb
,
348 if (IS_ERR(handle
)) {
349 status
= PTR_ERR(handle
);
355 /* Starting to change things, restart is no longer possible. */
356 ocfs2_block_signals(&oldset
);
357 did_block_signals
= 1;
359 status
= dquot_alloc_inode(inode
);
364 mlog_entry("(0x%p, 0x%p, %d, %lu, '%.*s')\n", dir
, dentry
,
365 inode
->i_mode
, (unsigned long)dev
, dentry
->d_name
.len
,
366 dentry
->d_name
.name
);
368 /* do the real work now. */
369 status
= ocfs2_mknod_locked(osb
, dir
, inode
, dev
,
370 &new_fe_bh
, parent_fe_bh
, handle
,
378 status
= ocfs2_fill_new_dir(osb
, handle
, dir
, inode
,
379 new_fe_bh
, data_ac
, meta_ac
);
385 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(dir
),
387 OCFS2_JOURNAL_ACCESS_WRITE
);
392 ocfs2_add_links_count(dirfe
, 1);
393 ocfs2_journal_dirty(handle
, parent_fe_bh
);
397 status
= ocfs2_init_acl(handle
, inode
, dir
, new_fe_bh
, parent_fe_bh
,
405 status
= ocfs2_init_security_set(handle
, inode
, new_fe_bh
, &si
,
414 * Do this before adding the entry to the directory. We add
415 * also set d_op after success so that ->d_iput() will cleanup
416 * the dentry lock even if ocfs2_add_entry() fails below.
418 status
= ocfs2_dentry_attach_lock(dentry
, inode
,
419 OCFS2_I(dir
)->ip_blkno
);
424 dentry
->d_op
= &ocfs2_dentry_ops
;
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
);
438 if (status
< 0 && did_quota_inode
)
439 dquot_free_inode(inode
);
441 ocfs2_commit_trans(osb
, handle
);
443 ocfs2_inode_unlock(dir
, 1);
444 if (did_block_signals
)
445 ocfs2_unblock_signals(&oldset
);
447 if (status
== -ENOSPC
)
448 mlog(0, "Disk is full\n");
451 brelse(parent_fe_bh
);
455 ocfs2_free_dir_lookup_result(&lookup
);
458 ocfs2_free_alloc_context(inode_ac
);
461 ocfs2_free_alloc_context(data_ac
);
464 ocfs2_free_alloc_context(meta_ac
);
467 * We should call iput after the i_mutex of the bitmap been
468 * unlocked in ocfs2_free_alloc_context, or the
469 * ocfs2_delete_inode will mutex_lock again.
471 if ((status
< 0) && inode
) {
472 OCFS2_I(inode
)->ip_flags
|= OCFS2_INODE_SKIP_ORPHAN_DIR
;
482 static int ocfs2_mknod_locked(struct ocfs2_super
*osb
,
486 struct buffer_head
**new_fe_bh
,
487 struct buffer_head
*parent_fe_bh
,
489 struct ocfs2_alloc_context
*inode_ac
)
492 struct ocfs2_dinode
*fe
= NULL
;
493 struct ocfs2_extent_list
*fel
;
494 u64 suballoc_loc
, fe_blkno
= 0;
500 status
= ocfs2_claim_new_inode(handle
, dir
, parent_fe_bh
,
501 inode_ac
, &suballoc_loc
,
502 &suballoc_bit
, &fe_blkno
);
508 /* populate as many fields early on as possible - many of
509 * these are used by the support functions here and in
511 inode
->i_ino
= ino_from_blkno(osb
->sb
, fe_blkno
);
512 OCFS2_I(inode
)->ip_blkno
= fe_blkno
;
513 spin_lock(&osb
->osb_lock
);
514 inode
->i_generation
= osb
->s_next_generation
++;
515 spin_unlock(&osb
->osb_lock
);
517 *new_fe_bh
= sb_getblk(osb
->sb
, fe_blkno
);
523 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode
), *new_fe_bh
);
525 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
),
527 OCFS2_JOURNAL_ACCESS_CREATE
);
533 fe
= (struct ocfs2_dinode
*) (*new_fe_bh
)->b_data
;
534 memset(fe
, 0, osb
->sb
->s_blocksize
);
536 fe
->i_generation
= cpu_to_le32(inode
->i_generation
);
537 fe
->i_fs_generation
= cpu_to_le32(osb
->fs_generation
);
538 fe
->i_blkno
= cpu_to_le64(fe_blkno
);
539 fe
->i_suballoc_loc
= cpu_to_le64(suballoc_loc
);
540 fe
->i_suballoc_bit
= cpu_to_le16(suballoc_bit
);
541 fe
->i_suballoc_slot
= cpu_to_le16(inode_ac
->ac_alloc_slot
);
542 fe
->i_uid
= cpu_to_le32(inode
->i_uid
);
543 fe
->i_gid
= cpu_to_le32(inode
->i_gid
);
544 fe
->i_mode
= cpu_to_le16(inode
->i_mode
);
545 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
))
546 fe
->id1
.dev1
.i_rdev
= cpu_to_le64(huge_encode_dev(dev
));
548 ocfs2_set_links_count(fe
, inode
->i_nlink
);
550 fe
->i_last_eb_blk
= 0;
551 strcpy(fe
->i_signature
, OCFS2_INODE_SIGNATURE
);
552 le32_add_cpu(&fe
->i_flags
, OCFS2_VALID_FL
);
553 fe
->i_atime
= fe
->i_ctime
= fe
->i_mtime
=
554 cpu_to_le64(CURRENT_TIME
.tv_sec
);
555 fe
->i_mtime_nsec
= fe
->i_ctime_nsec
= fe
->i_atime_nsec
=
556 cpu_to_le32(CURRENT_TIME
.tv_nsec
);
560 * If supported, directories start with inline data. If inline
561 * isn't supported, but indexing is, we start them as indexed.
563 feat
= le16_to_cpu(fe
->i_dyn_features
);
564 if (S_ISDIR(inode
->i_mode
) && ocfs2_supports_inline_data(osb
)) {
565 fe
->i_dyn_features
= cpu_to_le16(feat
| OCFS2_INLINE_DATA_FL
);
567 fe
->id2
.i_data
.id_count
= cpu_to_le16(
568 ocfs2_max_inline_data_with_xattr(osb
->sb
, fe
));
570 fel
= &fe
->id2
.i_list
;
571 fel
->l_tree_depth
= 0;
572 fel
->l_next_free_rec
= 0;
573 fel
->l_count
= cpu_to_le16(ocfs2_extent_recs_per_inode(osb
->sb
));
576 ocfs2_journal_dirty(handle
, *new_fe_bh
);
578 ocfs2_populate_inode(inode
, fe
, 1);
579 ocfs2_ci_set_new(osb
, INODE_CACHE(inode
));
580 if (!ocfs2_mount_local(osb
)) {
581 status
= ocfs2_create_new_inode_locks(inode
);
586 status
= 0; /* error in ocfs2_create_new_inode_locks is not
601 static int ocfs2_mkdir(struct inode
*dir
,
602 struct dentry
*dentry
,
607 mlog_entry("(0x%p, 0x%p, %d, '%.*s')\n", dir
, dentry
, mode
,
608 dentry
->d_name
.len
, dentry
->d_name
.name
);
609 ret
= ocfs2_mknod(dir
, dentry
, mode
| S_IFDIR
, 0);
615 static int ocfs2_create(struct inode
*dir
,
616 struct dentry
*dentry
,
618 struct nameidata
*nd
)
622 mlog_entry("(0x%p, 0x%p, %d, '%.*s')\n", dir
, dentry
, mode
,
623 dentry
->d_name
.len
, dentry
->d_name
.name
);
624 ret
= ocfs2_mknod(dir
, dentry
, mode
| S_IFREG
, 0);
630 static int ocfs2_link(struct dentry
*old_dentry
,
632 struct dentry
*dentry
)
635 struct inode
*inode
= old_dentry
->d_inode
;
637 struct buffer_head
*fe_bh
= NULL
;
638 struct buffer_head
*parent_fe_bh
= NULL
;
639 struct ocfs2_dinode
*fe
= NULL
;
640 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
641 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
644 mlog_entry("(inode=%lu, old='%.*s' new='%.*s')\n", inode
->i_ino
,
645 old_dentry
->d_name
.len
, old_dentry
->d_name
.name
,
646 dentry
->d_name
.len
, dentry
->d_name
.name
);
648 if (S_ISDIR(inode
->i_mode
))
651 dquot_initialize(dir
);
653 err
= ocfs2_inode_lock_nested(dir
, &parent_fe_bh
, 1, OI_LS_PARENT
);
665 err
= ocfs2_check_dir_for_entry(dir
, dentry
->d_name
.name
,
670 err
= ocfs2_prepare_dir_for_insert(osb
, dir
, parent_fe_bh
,
672 dentry
->d_name
.len
, &lookup
);
678 err
= ocfs2_inode_lock(inode
, &fe_bh
, 1);
685 fe
= (struct ocfs2_dinode
*) fe_bh
->b_data
;
686 if (ocfs2_read_links_count(fe
) >= ocfs2_link_max(osb
)) {
688 goto out_unlock_inode
;
691 handle
= ocfs2_start_trans(osb
, ocfs2_link_credits(osb
->sb
));
692 if (IS_ERR(handle
)) {
693 err
= PTR_ERR(handle
);
696 goto out_unlock_inode
;
699 /* Starting to change things, restart is no longer possible. */
700 ocfs2_block_signals(&oldset
);
702 err
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
), fe_bh
,
703 OCFS2_JOURNAL_ACCESS_WRITE
);
710 inode
->i_ctime
= CURRENT_TIME
;
711 ocfs2_set_links_count(fe
, inode
->i_nlink
);
712 fe
->i_ctime
= cpu_to_le64(inode
->i_ctime
.tv_sec
);
713 fe
->i_ctime_nsec
= cpu_to_le32(inode
->i_ctime
.tv_nsec
);
714 ocfs2_journal_dirty(handle
, fe_bh
);
716 err
= ocfs2_add_entry(handle
, dentry
, inode
,
717 OCFS2_I(inode
)->ip_blkno
,
718 parent_fe_bh
, &lookup
);
720 ocfs2_add_links_count(fe
, -1);
726 err
= ocfs2_dentry_attach_lock(dentry
, inode
, OCFS2_I(dir
)->ip_blkno
);
732 atomic_inc(&inode
->i_count
);
733 dentry
->d_op
= &ocfs2_dentry_ops
;
734 d_instantiate(dentry
, inode
);
737 ocfs2_commit_trans(osb
, handle
);
738 ocfs2_unblock_signals(&oldset
);
740 ocfs2_inode_unlock(inode
, 1);
743 ocfs2_inode_unlock(dir
, 1);
746 brelse(parent_fe_bh
);
748 ocfs2_free_dir_lookup_result(&lookup
);
756 * Takes and drops an exclusive lock on the given dentry. This will
757 * force other nodes to drop it.
759 static int ocfs2_remote_dentry_delete(struct dentry
*dentry
)
763 ret
= ocfs2_dentry_lock(dentry
, 1);
767 ocfs2_dentry_unlock(dentry
, 1);
772 static inline int inode_is_unlinkable(struct inode
*inode
)
774 if (S_ISDIR(inode
->i_mode
)) {
775 if (inode
->i_nlink
== 2)
780 if (inode
->i_nlink
== 1)
785 static int ocfs2_unlink(struct inode
*dir
,
786 struct dentry
*dentry
)
789 int child_locked
= 0;
790 struct inode
*inode
= dentry
->d_inode
;
791 struct inode
*orphan_dir
= NULL
;
792 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
794 struct ocfs2_dinode
*fe
= NULL
;
795 struct buffer_head
*fe_bh
= NULL
;
796 struct buffer_head
*parent_node_bh
= NULL
;
797 handle_t
*handle
= NULL
;
798 char orphan_name
[OCFS2_ORPHAN_NAMELEN
+ 1];
799 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
800 struct ocfs2_dir_lookup_result orphan_insert
= { NULL
, };
802 mlog_entry("(0x%p, 0x%p, '%.*s')\n", dir
, dentry
,
803 dentry
->d_name
.len
, dentry
->d_name
.name
);
805 dquot_initialize(dir
);
807 BUG_ON(dentry
->d_parent
->d_inode
!= dir
);
809 mlog(0, "ino = %llu\n", (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
811 if (inode
== osb
->root_inode
) {
812 mlog(0, "Cannot delete the root directory\n");
816 status
= ocfs2_inode_lock_nested(dir
, &parent_node_bh
, 1,
819 if (status
!= -ENOENT
)
824 status
= ocfs2_find_files_on_disk(dentry
->d_name
.name
,
825 dentry
->d_name
.len
, &blkno
, dir
,
828 if (status
!= -ENOENT
)
833 if (OCFS2_I(inode
)->ip_blkno
!= blkno
) {
836 mlog(0, "ip_blkno %llu != dirent blkno %llu ip_flags = %x\n",
837 (unsigned long long)OCFS2_I(inode
)->ip_blkno
,
838 (unsigned long long)blkno
, OCFS2_I(inode
)->ip_flags
);
842 status
= ocfs2_inode_lock(inode
, &fe_bh
, 1);
844 if (status
!= -ENOENT
)
850 if (S_ISDIR(inode
->i_mode
)) {
851 if (inode
->i_nlink
!= 2 || !ocfs2_empty_dir(inode
)) {
857 status
= ocfs2_remote_dentry_delete(dentry
);
859 /* This remote delete should succeed under all normal
865 if (inode_is_unlinkable(inode
)) {
866 status
= ocfs2_prepare_orphan_dir(osb
, &orphan_dir
,
867 OCFS2_I(inode
)->ip_blkno
,
868 orphan_name
, &orphan_insert
);
875 handle
= ocfs2_start_trans(osb
, ocfs2_unlink_credits(osb
->sb
));
876 if (IS_ERR(handle
)) {
877 status
= PTR_ERR(handle
);
883 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
), fe_bh
,
884 OCFS2_JOURNAL_ACCESS_WRITE
);
890 fe
= (struct ocfs2_dinode
*) fe_bh
->b_data
;
892 if (inode_is_unlinkable(inode
)) {
893 status
= ocfs2_orphan_add(osb
, handle
, inode
, fe_bh
, orphan_name
,
894 &orphan_insert
, orphan_dir
);
901 /* delete the name from the parent dir */
902 status
= ocfs2_delete_entry(handle
, dir
, &lookup
);
908 if (S_ISDIR(inode
->i_mode
))
911 ocfs2_set_links_count(fe
, inode
->i_nlink
);
912 ocfs2_journal_dirty(handle
, fe_bh
);
914 dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
915 if (S_ISDIR(inode
->i_mode
))
918 status
= ocfs2_mark_inode_dirty(handle
, dir
, parent_node_bh
);
921 if (S_ISDIR(inode
->i_mode
))
927 ocfs2_commit_trans(osb
, handle
);
930 ocfs2_inode_unlock(inode
, 1);
932 ocfs2_inode_unlock(dir
, 1);
935 /* This was locked for us in ocfs2_prepare_orphan_dir() */
936 ocfs2_inode_unlock(orphan_dir
, 1);
937 mutex_unlock(&orphan_dir
->i_mutex
);
942 brelse(parent_node_bh
);
944 ocfs2_free_dir_lookup_result(&orphan_insert
);
945 ocfs2_free_dir_lookup_result(&lookup
);
953 * The only place this should be used is rename!
954 * if they have the same id, then the 1st one is the only one locked.
956 static int ocfs2_double_lock(struct ocfs2_super
*osb
,
957 struct buffer_head
**bh1
,
958 struct inode
*inode1
,
959 struct buffer_head
**bh2
,
960 struct inode
*inode2
)
963 struct ocfs2_inode_info
*oi1
= OCFS2_I(inode1
);
964 struct ocfs2_inode_info
*oi2
= OCFS2_I(inode2
);
965 struct buffer_head
**tmpbh
;
966 struct inode
*tmpinode
;
968 mlog_entry("(inode1 = %llu, inode2 = %llu)\n",
969 (unsigned long long)oi1
->ip_blkno
,
970 (unsigned long long)oi2
->ip_blkno
);
977 /* we always want to lock the one with the lower lockid first. */
978 if (oi1
->ip_blkno
!= oi2
->ip_blkno
) {
979 if (oi1
->ip_blkno
< oi2
->ip_blkno
) {
980 /* switch id1 and id2 around */
981 mlog(0, "switching them around...\n");
991 status
= ocfs2_inode_lock_nested(inode2
, bh2
, 1,
994 if (status
!= -ENOENT
)
1001 status
= ocfs2_inode_lock_nested(inode1
, bh1
, 1, OI_LS_RENAME2
);
1004 * An error return must mean that no cluster locks
1005 * were held on function exit.
1007 if (oi1
->ip_blkno
!= oi2
->ip_blkno
)
1008 ocfs2_inode_unlock(inode2
, 1);
1010 if (status
!= -ENOENT
)
1019 static void ocfs2_double_unlock(struct inode
*inode1
, struct inode
*inode2
)
1021 ocfs2_inode_unlock(inode1
, 1);
1023 if (inode1
!= inode2
)
1024 ocfs2_inode_unlock(inode2
, 1);
1027 static int ocfs2_rename(struct inode
*old_dir
,
1028 struct dentry
*old_dentry
,
1029 struct inode
*new_dir
,
1030 struct dentry
*new_dentry
)
1032 int status
= 0, rename_lock
= 0, parents_locked
= 0, target_exists
= 0;
1033 int old_child_locked
= 0, new_child_locked
= 0, update_dot_dot
= 0;
1034 struct inode
*old_inode
= old_dentry
->d_inode
;
1035 struct inode
*new_inode
= new_dentry
->d_inode
;
1036 struct inode
*orphan_dir
= NULL
;
1037 struct ocfs2_dinode
*newfe
= NULL
;
1038 char orphan_name
[OCFS2_ORPHAN_NAMELEN
+ 1];
1039 struct buffer_head
*newfe_bh
= NULL
;
1040 struct buffer_head
*old_inode_bh
= NULL
;
1041 struct ocfs2_super
*osb
= NULL
;
1042 u64 newfe_blkno
, old_de_ino
;
1043 handle_t
*handle
= NULL
;
1044 struct buffer_head
*old_dir_bh
= NULL
;
1045 struct buffer_head
*new_dir_bh
= NULL
;
1046 nlink_t old_dir_nlink
= old_dir
->i_nlink
;
1047 struct ocfs2_dinode
*old_di
;
1048 struct ocfs2_dir_lookup_result old_inode_dot_dot_res
= { NULL
, };
1049 struct ocfs2_dir_lookup_result target_lookup_res
= { NULL
, };
1050 struct ocfs2_dir_lookup_result old_entry_lookup
= { NULL
, };
1051 struct ocfs2_dir_lookup_result orphan_insert
= { NULL
, };
1052 struct ocfs2_dir_lookup_result target_insert
= { NULL
, };
1054 /* At some point it might be nice to break this function up a
1057 mlog_entry("(0x%p, 0x%p, 0x%p, 0x%p, from='%.*s' to='%.*s')\n",
1058 old_dir
, old_dentry
, new_dir
, new_dentry
,
1059 old_dentry
->d_name
.len
, old_dentry
->d_name
.name
,
1060 new_dentry
->d_name
.len
, new_dentry
->d_name
.name
);
1062 dquot_initialize(old_dir
);
1063 dquot_initialize(new_dir
);
1065 osb
= OCFS2_SB(old_dir
->i_sb
);
1068 if (!igrab(new_inode
))
1072 /* Assume a directory hierarchy thusly:
1075 * a,b,c, and d are all directories.
1077 * from cwd of 'a' on both nodes:
1081 * And that's why, just like the VFS, we need a file system
1083 if (old_dir
!= new_dir
&& S_ISDIR(old_inode
->i_mode
)) {
1084 status
= ocfs2_rename_lock(osb
);
1092 /* if old and new are the same, this'll just do one lock. */
1093 status
= ocfs2_double_lock(osb
, &old_dir_bh
, old_dir
,
1094 &new_dir_bh
, new_dir
);
1101 /* make sure both dirs have bhs
1102 * get an extra ref on old_dir_bh if old==new */
1105 new_dir_bh
= old_dir_bh
;
1108 mlog(ML_ERROR
, "no old_dir_bh!\n");
1115 * Aside from allowing a meta data update, the locking here
1116 * also ensures that the downconvert thread on other nodes
1117 * won't have to concurrently downconvert the inode and the
1120 status
= ocfs2_inode_lock_nested(old_inode
, &old_inode_bh
, 1,
1123 if (status
!= -ENOENT
)
1127 old_child_locked
= 1;
1129 status
= ocfs2_remote_dentry_delete(old_dentry
);
1135 if (S_ISDIR(old_inode
->i_mode
)) {
1136 u64 old_inode_parent
;
1139 status
= ocfs2_find_files_on_disk("..", 2, &old_inode_parent
,
1141 &old_inode_dot_dot_res
);
1147 if (old_inode_parent
!= OCFS2_I(old_dir
)->ip_blkno
) {
1152 if (!new_inode
&& new_dir
!= old_dir
&&
1153 new_dir
->i_nlink
>= ocfs2_link_max(osb
)) {
1159 status
= ocfs2_lookup_ino_from_name(old_dir
, old_dentry
->d_name
.name
,
1160 old_dentry
->d_name
.len
,
1168 * Check for inode number is _not_ due to possible IO errors.
1169 * We might rmdir the source, keep it as pwd of some process
1170 * and merrily kill the link to whatever was created under the
1171 * same name. Goodbye sticky bit ;-<
1173 if (old_de_ino
!= OCFS2_I(old_inode
)->ip_blkno
) {
1178 /* check if the target already exists (in which case we need
1180 status
= ocfs2_find_files_on_disk(new_dentry
->d_name
.name
,
1181 new_dentry
->d_name
.len
,
1182 &newfe_blkno
, new_dir
,
1183 &target_lookup_res
);
1184 /* The only error we allow here is -ENOENT because the new
1185 * file not existing is perfectly valid. */
1186 if ((status
< 0) && (status
!= -ENOENT
)) {
1187 /* If we cannot find the file specified we should just */
1188 /* return the error... */
1195 if (!target_exists
&& new_inode
) {
1197 * Target was unlinked by another node while we were
1198 * waiting to get to ocfs2_rename(). There isn't
1199 * anything we can do here to help the situation, so
1200 * bubble up the appropriate error.
1206 /* In case we need to overwrite an existing file, we blow it
1208 if (target_exists
) {
1209 /* VFS didn't think there existed an inode here, but
1210 * someone else in the cluster must have raced our
1211 * rename to create one. Today we error cleanly, in
1212 * the future we should consider calling iget to build
1213 * a new struct inode for this entry. */
1217 mlog(0, "We found an inode for name %.*s but VFS "
1218 "didn't give us one.\n", new_dentry
->d_name
.len
,
1219 new_dentry
->d_name
.name
);
1223 if (OCFS2_I(new_inode
)->ip_blkno
!= newfe_blkno
) {
1226 mlog(0, "Inode %llu and dir %llu disagree. flags = %x\n",
1227 (unsigned long long)OCFS2_I(new_inode
)->ip_blkno
,
1228 (unsigned long long)newfe_blkno
,
1229 OCFS2_I(new_inode
)->ip_flags
);
1233 status
= ocfs2_inode_lock(new_inode
, &newfe_bh
, 1);
1235 if (status
!= -ENOENT
)
1239 new_child_locked
= 1;
1241 status
= ocfs2_remote_dentry_delete(new_dentry
);
1247 newfe
= (struct ocfs2_dinode
*) newfe_bh
->b_data
;
1249 mlog(0, "aha rename over existing... new_blkno=%llu "
1250 "newfebh=%p bhblocknr=%llu\n",
1251 (unsigned long long)newfe_blkno
, newfe_bh
, newfe_bh
?
1252 (unsigned long long)newfe_bh
->b_blocknr
: 0ULL);
1254 if (S_ISDIR(new_inode
->i_mode
) || (new_inode
->i_nlink
== 1)) {
1255 status
= ocfs2_prepare_orphan_dir(osb
, &orphan_dir
,
1256 OCFS2_I(new_inode
)->ip_blkno
,
1257 orphan_name
, &orphan_insert
);
1264 BUG_ON(new_dentry
->d_parent
->d_inode
!= new_dir
);
1266 status
= ocfs2_check_dir_for_entry(new_dir
,
1267 new_dentry
->d_name
.name
,
1268 new_dentry
->d_name
.len
);
1272 status
= ocfs2_prepare_dir_for_insert(osb
, new_dir
, new_dir_bh
,
1273 new_dentry
->d_name
.name
,
1274 new_dentry
->d_name
.len
,
1282 handle
= ocfs2_start_trans(osb
, ocfs2_rename_credits(osb
->sb
));
1283 if (IS_ERR(handle
)) {
1284 status
= PTR_ERR(handle
);
1290 if (target_exists
) {
1291 if (S_ISDIR(new_inode
->i_mode
)) {
1292 if (new_inode
->i_nlink
!= 2 ||
1293 !ocfs2_empty_dir(new_inode
)) {
1294 status
= -ENOTEMPTY
;
1298 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(new_inode
),
1300 OCFS2_JOURNAL_ACCESS_WRITE
);
1306 if (S_ISDIR(new_inode
->i_mode
) ||
1307 (ocfs2_read_links_count(newfe
) == 1)) {
1308 status
= ocfs2_orphan_add(osb
, handle
, new_inode
,
1309 newfe_bh
, orphan_name
,
1310 &orphan_insert
, orphan_dir
);
1317 /* change the dirent to point to the correct inode */
1318 status
= ocfs2_update_entry(new_dir
, handle
, &target_lookup_res
,
1324 new_dir
->i_version
++;
1326 if (S_ISDIR(new_inode
->i_mode
))
1327 ocfs2_set_links_count(newfe
, 0);
1329 ocfs2_add_links_count(newfe
, -1);
1330 ocfs2_journal_dirty(handle
, newfe_bh
);
1332 /* if the name was not found in new_dir, add it now */
1333 status
= ocfs2_add_entry(handle
, new_dentry
, old_inode
,
1334 OCFS2_I(old_inode
)->ip_blkno
,
1335 new_dir_bh
, &target_insert
);
1338 old_inode
->i_ctime
= CURRENT_TIME
;
1339 mark_inode_dirty(old_inode
);
1341 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(old_inode
),
1343 OCFS2_JOURNAL_ACCESS_WRITE
);
1345 old_di
= (struct ocfs2_dinode
*) old_inode_bh
->b_data
;
1347 old_di
->i_ctime
= cpu_to_le64(old_inode
->i_ctime
.tv_sec
);
1348 old_di
->i_ctime_nsec
= cpu_to_le32(old_inode
->i_ctime
.tv_nsec
);
1349 ocfs2_journal_dirty(handle
, old_inode_bh
);
1354 * Now that the name has been added to new_dir, remove the old name.
1356 * We don't keep any directory entry context around until now
1357 * because the insert might have changed the type of directory
1358 * we're dealing with.
1360 status
= ocfs2_find_entry(old_dentry
->d_name
.name
,
1361 old_dentry
->d_name
.len
, old_dir
,
1366 status
= ocfs2_delete_entry(handle
, old_dir
, &old_entry_lookup
);
1373 new_inode
->i_nlink
--;
1374 new_inode
->i_ctime
= CURRENT_TIME
;
1376 old_dir
->i_ctime
= old_dir
->i_mtime
= CURRENT_TIME
;
1378 if (update_dot_dot
) {
1379 status
= ocfs2_update_entry(old_inode
, handle
,
1380 &old_inode_dot_dot_res
, new_dir
);
1383 new_inode
->i_nlink
--;
1386 mark_inode_dirty(new_dir
);
1389 mark_inode_dirty(old_dir
);
1390 ocfs2_mark_inode_dirty(handle
, old_dir
, old_dir_bh
);
1392 mark_inode_dirty(new_inode
);
1393 ocfs2_mark_inode_dirty(handle
, new_inode
, newfe_bh
);
1396 if (old_dir
!= new_dir
) {
1397 /* Keep the same times on both directories.*/
1398 new_dir
->i_ctime
= new_dir
->i_mtime
= old_dir
->i_ctime
;
1401 * This will also pick up the i_nlink change from the
1404 ocfs2_mark_inode_dirty(handle
, new_dir
, new_dir_bh
);
1407 if (old_dir_nlink
!= old_dir
->i_nlink
) {
1409 mlog(ML_ERROR
, "need to change nlink for old dir "
1410 "%llu from %d to %d but bh is NULL!\n",
1411 (unsigned long long)OCFS2_I(old_dir
)->ip_blkno
,
1412 (int)old_dir_nlink
, old_dir
->i_nlink
);
1414 struct ocfs2_dinode
*fe
;
1415 status
= ocfs2_journal_access_di(handle
,
1416 INODE_CACHE(old_dir
),
1418 OCFS2_JOURNAL_ACCESS_WRITE
);
1419 fe
= (struct ocfs2_dinode
*) old_dir_bh
->b_data
;
1420 ocfs2_set_links_count(fe
, old_dir
->i_nlink
);
1421 ocfs2_journal_dirty(handle
, old_dir_bh
);
1424 ocfs2_dentry_move(old_dentry
, new_dentry
, old_dir
, new_dir
);
1428 ocfs2_rename_unlock(osb
);
1431 ocfs2_commit_trans(osb
, handle
);
1434 ocfs2_double_unlock(old_dir
, new_dir
);
1436 if (old_child_locked
)
1437 ocfs2_inode_unlock(old_inode
, 1);
1439 if (new_child_locked
)
1440 ocfs2_inode_unlock(new_inode
, 1);
1443 /* This was locked for us in ocfs2_prepare_orphan_dir() */
1444 ocfs2_inode_unlock(orphan_dir
, 1);
1445 mutex_unlock(&orphan_dir
->i_mutex
);
1450 sync_mapping_buffers(old_inode
->i_mapping
);
1455 ocfs2_free_dir_lookup_result(&target_lookup_res
);
1456 ocfs2_free_dir_lookup_result(&old_entry_lookup
);
1457 ocfs2_free_dir_lookup_result(&old_inode_dot_dot_res
);
1458 ocfs2_free_dir_lookup_result(&orphan_insert
);
1459 ocfs2_free_dir_lookup_result(&target_insert
);
1462 brelse(old_inode_bh
);
1472 * we expect i_size = strlen(symname). Copy symname into the file
1473 * data, including the null terminator.
1475 static int ocfs2_create_symlink_data(struct ocfs2_super
*osb
,
1477 struct inode
*inode
,
1478 const char *symname
)
1480 struct buffer_head
**bhs
= NULL
;
1482 struct super_block
*sb
= osb
->sb
;
1483 u64 p_blkno
, p_blocks
;
1484 int virtual, blocks
, status
, i
, bytes_left
;
1486 bytes_left
= i_size_read(inode
) + 1;
1487 /* we can't trust i_blocks because we're actually going to
1488 * write i_size + 1 bytes. */
1489 blocks
= (bytes_left
+ sb
->s_blocksize
- 1) >> sb
->s_blocksize_bits
;
1491 mlog_entry("i_blocks = %llu, i_size = %llu, blocks = %d\n",
1492 (unsigned long long)inode
->i_blocks
,
1493 i_size_read(inode
), blocks
);
1495 /* Sanity check -- make sure we're going to fit. */
1497 ocfs2_clusters_to_bytes(sb
, OCFS2_I(inode
)->ip_clusters
)) {
1503 bhs
= kcalloc(blocks
, sizeof(struct buffer_head
*), GFP_KERNEL
);
1510 status
= ocfs2_extent_map_get_blocks(inode
, 0, &p_blkno
, &p_blocks
,
1517 /* links can never be larger than one cluster so we know this
1518 * is all going to be contiguous, but do a sanity check
1520 if ((p_blocks
<< sb
->s_blocksize_bits
) < bytes_left
) {
1527 while(bytes_left
> 0) {
1528 c
= &symname
[virtual * sb
->s_blocksize
];
1530 bhs
[virtual] = sb_getblk(sb
, p_blkno
);
1531 if (!bhs
[virtual]) {
1536 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode
),
1539 status
= ocfs2_journal_access(handle
, INODE_CACHE(inode
),
1541 OCFS2_JOURNAL_ACCESS_CREATE
);
1547 memset(bhs
[virtual]->b_data
, 0, sb
->s_blocksize
);
1549 memcpy(bhs
[virtual]->b_data
, c
,
1550 (bytes_left
> sb
->s_blocksize
) ? sb
->s_blocksize
:
1553 ocfs2_journal_dirty(handle
, bhs
[virtual]);
1557 bytes_left
-= sb
->s_blocksize
;
1564 for(i
= 0; i
< blocks
; i
++)
1573 static int ocfs2_symlink(struct inode
*dir
,
1574 struct dentry
*dentry
,
1575 const char *symname
)
1577 int status
, l
, credits
;
1579 struct ocfs2_super
*osb
= NULL
;
1580 struct inode
*inode
= NULL
;
1581 struct super_block
*sb
;
1582 struct buffer_head
*new_fe_bh
= NULL
;
1583 struct buffer_head
*parent_fe_bh
= NULL
;
1584 struct ocfs2_dinode
*fe
= NULL
;
1585 struct ocfs2_dinode
*dirfe
;
1586 handle_t
*handle
= NULL
;
1587 struct ocfs2_alloc_context
*inode_ac
= NULL
;
1588 struct ocfs2_alloc_context
*data_ac
= NULL
;
1589 struct ocfs2_alloc_context
*xattr_ac
= NULL
;
1590 int want_clusters
= 0;
1591 int xattr_credits
= 0;
1592 struct ocfs2_security_xattr_info si
= {
1595 int did_quota
= 0, did_quota_inode
= 0;
1596 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
1598 int did_block_signals
= 0;
1600 mlog_entry("(0x%p, 0x%p, symname='%s' actual='%.*s')\n", dir
,
1601 dentry
, symname
, dentry
->d_name
.len
, dentry
->d_name
.name
);
1603 dquot_initialize(dir
);
1608 l
= strlen(symname
) + 1;
1610 credits
= ocfs2_calc_symlink_credits(sb
);
1612 /* lock the parent directory */
1613 status
= ocfs2_inode_lock(dir
, &parent_fe_bh
, 1);
1615 if (status
!= -ENOENT
)
1620 dirfe
= (struct ocfs2_dinode
*) parent_fe_bh
->b_data
;
1621 if (!ocfs2_read_links_count(dirfe
)) {
1622 /* can't make a file in a deleted directory. */
1627 status
= ocfs2_check_dir_for_entry(dir
, dentry
->d_name
.name
,
1628 dentry
->d_name
.len
);
1632 status
= ocfs2_prepare_dir_for_insert(osb
, dir
, parent_fe_bh
,
1633 dentry
->d_name
.name
,
1634 dentry
->d_name
.len
, &lookup
);
1640 status
= ocfs2_reserve_new_inode(osb
, &inode_ac
);
1642 if (status
!= -ENOSPC
)
1647 inode
= ocfs2_get_init_inode(dir
, S_IFLNK
| S_IRWXUGO
);
1654 /* get security xattr */
1655 status
= ocfs2_init_security_get(inode
, dir
, &si
);
1657 if (status
== -EOPNOTSUPP
)
1665 /* calculate meta data/clusters for setting security xattr */
1667 status
= ocfs2_calc_security_init(dir
, &si
, &want_clusters
,
1668 &xattr_credits
, &xattr_ac
);
1675 /* don't reserve bitmap space for fast symlinks. */
1676 if (l
> ocfs2_fast_symlink_chars(sb
))
1679 status
= ocfs2_reserve_clusters(osb
, want_clusters
, &data_ac
);
1681 if (status
!= -ENOSPC
)
1686 handle
= ocfs2_start_trans(osb
, credits
+ xattr_credits
);
1687 if (IS_ERR(handle
)) {
1688 status
= PTR_ERR(handle
);
1694 /* Starting to change things, restart is no longer possible. */
1695 ocfs2_block_signals(&oldset
);
1696 did_block_signals
= 1;
1698 status
= dquot_alloc_inode(inode
);
1701 did_quota_inode
= 1;
1703 mlog_entry("(0x%p, 0x%p, %d, '%.*s')\n", dir
, dentry
,
1704 inode
->i_mode
, dentry
->d_name
.len
,
1705 dentry
->d_name
.name
);
1707 status
= ocfs2_mknod_locked(osb
, dir
, inode
,
1708 0, &new_fe_bh
, parent_fe_bh
, handle
,
1715 fe
= (struct ocfs2_dinode
*) new_fe_bh
->b_data
;
1718 if (l
> ocfs2_fast_symlink_chars(sb
)) {
1721 inode
->i_op
= &ocfs2_symlink_inode_operations
;
1722 status
= dquot_alloc_space_nodirty(inode
,
1723 ocfs2_clusters_to_bytes(osb
->sb
, 1));
1727 status
= ocfs2_add_inode_data(osb
, inode
, &offset
, 1, 0,
1729 handle
, data_ac
, NULL
,
1732 if (status
!= -ENOSPC
&& status
!= -EINTR
) {
1734 "Failed to extend file to %llu\n",
1735 (unsigned long long)newsize
);
1741 i_size_write(inode
, newsize
);
1742 inode
->i_blocks
= ocfs2_inode_sector_count(inode
);
1744 inode
->i_op
= &ocfs2_fast_symlink_inode_operations
;
1745 memcpy((char *) fe
->id2
.i_symlink
, symname
, l
);
1746 i_size_write(inode
, newsize
);
1747 inode
->i_blocks
= 0;
1750 status
= ocfs2_mark_inode_dirty(handle
, inode
, new_fe_bh
);
1756 if (!ocfs2_inode_is_fast_symlink(inode
)) {
1757 status
= ocfs2_create_symlink_data(osb
, handle
, inode
,
1766 status
= ocfs2_init_security_set(handle
, inode
, new_fe_bh
, &si
,
1775 * Do this before adding the entry to the directory. We add
1776 * also set d_op after success so that ->d_iput() will cleanup
1777 * the dentry lock even if ocfs2_add_entry() fails below.
1779 status
= ocfs2_dentry_attach_lock(dentry
, inode
, OCFS2_I(dir
)->ip_blkno
);
1784 dentry
->d_op
= &ocfs2_dentry_ops
;
1786 status
= ocfs2_add_entry(handle
, dentry
, inode
,
1787 le64_to_cpu(fe
->i_blkno
), parent_fe_bh
,
1794 insert_inode_hash(inode
);
1795 d_instantiate(dentry
, inode
);
1797 if (status
< 0 && did_quota
)
1798 dquot_free_space_nodirty(inode
,
1799 ocfs2_clusters_to_bytes(osb
->sb
, 1));
1800 if (status
< 0 && did_quota_inode
)
1801 dquot_free_inode(inode
);
1803 ocfs2_commit_trans(osb
, handle
);
1805 ocfs2_inode_unlock(dir
, 1);
1806 if (did_block_signals
)
1807 ocfs2_unblock_signals(&oldset
);
1810 brelse(parent_fe_bh
);
1813 ocfs2_free_dir_lookup_result(&lookup
);
1815 ocfs2_free_alloc_context(inode_ac
);
1817 ocfs2_free_alloc_context(data_ac
);
1819 ocfs2_free_alloc_context(xattr_ac
);
1820 if ((status
< 0) && inode
) {
1821 OCFS2_I(inode
)->ip_flags
|= OCFS2_INODE_SKIP_ORPHAN_DIR
;
1831 static int ocfs2_blkno_stringify(u64 blkno
, char *name
)
1833 int status
, namelen
;
1837 namelen
= snprintf(name
, OCFS2_ORPHAN_NAMELEN
+ 1, "%016llx",
1847 if (namelen
!= OCFS2_ORPHAN_NAMELEN
) {
1853 mlog(0, "built filename '%s' for orphan dir (len=%d)\n", name
,
1862 static int ocfs2_prepare_orphan_dir(struct ocfs2_super
*osb
,
1863 struct inode
**ret_orphan_dir
,
1866 struct ocfs2_dir_lookup_result
*lookup
)
1868 struct inode
*orphan_dir_inode
;
1869 struct buffer_head
*orphan_dir_bh
= NULL
;
1872 status
= ocfs2_blkno_stringify(blkno
, name
);
1878 orphan_dir_inode
= ocfs2_get_system_file_inode(osb
,
1879 ORPHAN_DIR_SYSTEM_INODE
,
1881 if (!orphan_dir_inode
) {
1887 mutex_lock(&orphan_dir_inode
->i_mutex
);
1889 status
= ocfs2_inode_lock(orphan_dir_inode
, &orphan_dir_bh
, 1);
1895 status
= ocfs2_prepare_dir_for_insert(osb
, orphan_dir_inode
,
1896 orphan_dir_bh
, name
,
1897 OCFS2_ORPHAN_NAMELEN
, lookup
);
1899 ocfs2_inode_unlock(orphan_dir_inode
, 1);
1905 *ret_orphan_dir
= orphan_dir_inode
;
1909 mutex_unlock(&orphan_dir_inode
->i_mutex
);
1910 iput(orphan_dir_inode
);
1913 brelse(orphan_dir_bh
);
1919 static int ocfs2_orphan_add(struct ocfs2_super
*osb
,
1921 struct inode
*inode
,
1922 struct buffer_head
*fe_bh
,
1924 struct ocfs2_dir_lookup_result
*lookup
,
1925 struct inode
*orphan_dir_inode
)
1927 struct buffer_head
*orphan_dir_bh
= NULL
;
1929 struct ocfs2_dinode
*orphan_fe
;
1930 struct ocfs2_dinode
*fe
= (struct ocfs2_dinode
*) fe_bh
->b_data
;
1932 mlog_entry("(inode->i_ino = %lu)\n", inode
->i_ino
);
1934 status
= ocfs2_read_inode_block(orphan_dir_inode
, &orphan_dir_bh
);
1940 status
= ocfs2_journal_access_di(handle
,
1941 INODE_CACHE(orphan_dir_inode
),
1943 OCFS2_JOURNAL_ACCESS_WRITE
);
1949 /* we're a cluster, and nlink can change on disk from
1950 * underneath us... */
1951 orphan_fe
= (struct ocfs2_dinode
*) orphan_dir_bh
->b_data
;
1952 if (S_ISDIR(inode
->i_mode
))
1953 ocfs2_add_links_count(orphan_fe
, 1);
1954 orphan_dir_inode
->i_nlink
= ocfs2_read_links_count(orphan_fe
);
1955 ocfs2_journal_dirty(handle
, orphan_dir_bh
);
1957 status
= __ocfs2_add_entry(handle
, orphan_dir_inode
, name
,
1958 OCFS2_ORPHAN_NAMELEN
, inode
,
1959 OCFS2_I(inode
)->ip_blkno
,
1960 orphan_dir_bh
, lookup
);
1967 * We're going to journal the change of i_flags and i_orphaned_slot.
1968 * It's safe anyway, though some callers may duplicate the journaling.
1969 * Journaling within the func just make the logic look more
1972 status
= ocfs2_journal_access_di(handle
,
1975 OCFS2_JOURNAL_ACCESS_WRITE
);
1981 le32_add_cpu(&fe
->i_flags
, OCFS2_ORPHANED_FL
);
1982 OCFS2_I(inode
)->ip_flags
&= ~OCFS2_INODE_SKIP_ORPHAN_DIR
;
1984 /* Record which orphan dir our inode now resides
1985 * in. delete_inode will use this to determine which orphan
1987 fe
->i_orphaned_slot
= cpu_to_le16(osb
->slot_num
);
1989 ocfs2_journal_dirty(handle
, fe_bh
);
1991 mlog(0, "Inode %llu orphaned in slot %d\n",
1992 (unsigned long long)OCFS2_I(inode
)->ip_blkno
, osb
->slot_num
);
1995 brelse(orphan_dir_bh
);
2001 /* unlike orphan_add, we expect the orphan dir to already be locked here. */
2002 int ocfs2_orphan_del(struct ocfs2_super
*osb
,
2004 struct inode
*orphan_dir_inode
,
2005 struct inode
*inode
,
2006 struct buffer_head
*orphan_dir_bh
)
2008 char name
[OCFS2_ORPHAN_NAMELEN
+ 1];
2009 struct ocfs2_dinode
*orphan_fe
;
2011 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
2015 status
= ocfs2_blkno_stringify(OCFS2_I(inode
)->ip_blkno
, name
);
2021 mlog(0, "removing '%s' from orphan dir %llu (namelen=%d)\n",
2022 name
, (unsigned long long)OCFS2_I(orphan_dir_inode
)->ip_blkno
,
2023 OCFS2_ORPHAN_NAMELEN
);
2025 /* find it's spot in the orphan directory */
2026 status
= ocfs2_find_entry(name
, OCFS2_ORPHAN_NAMELEN
, orphan_dir_inode
,
2033 /* remove it from the orphan directory */
2034 status
= ocfs2_delete_entry(handle
, orphan_dir_inode
, &lookup
);
2040 status
= ocfs2_journal_access_di(handle
,
2041 INODE_CACHE(orphan_dir_inode
),
2043 OCFS2_JOURNAL_ACCESS_WRITE
);
2049 /* do the i_nlink dance! :) */
2050 orphan_fe
= (struct ocfs2_dinode
*) orphan_dir_bh
->b_data
;
2051 if (S_ISDIR(inode
->i_mode
))
2052 ocfs2_add_links_count(orphan_fe
, -1);
2053 orphan_dir_inode
->i_nlink
= ocfs2_read_links_count(orphan_fe
);
2054 ocfs2_journal_dirty(handle
, orphan_dir_bh
);
2057 ocfs2_free_dir_lookup_result(&lookup
);
2063 int ocfs2_create_inode_in_orphan(struct inode
*dir
,
2065 struct inode
**new_inode
)
2067 int status
, did_quota_inode
= 0;
2068 struct inode
*inode
= NULL
;
2069 struct inode
*orphan_dir
= NULL
;
2070 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
2071 struct ocfs2_dinode
*di
= NULL
;
2072 handle_t
*handle
= NULL
;
2073 char orphan_name
[OCFS2_ORPHAN_NAMELEN
+ 1];
2074 struct buffer_head
*parent_di_bh
= NULL
;
2075 struct buffer_head
*new_di_bh
= NULL
;
2076 struct ocfs2_alloc_context
*inode_ac
= NULL
;
2077 struct ocfs2_dir_lookup_result orphan_insert
= { NULL
, };
2079 status
= ocfs2_inode_lock(dir
, &parent_di_bh
, 1);
2081 if (status
!= -ENOENT
)
2087 * We give the orphan dir the root blkno to fake an orphan name,
2088 * and allocate enough space for our insertion.
2090 status
= ocfs2_prepare_orphan_dir(osb
, &orphan_dir
,
2092 orphan_name
, &orphan_insert
);
2098 /* reserve an inode spot */
2099 status
= ocfs2_reserve_new_inode(osb
, &inode_ac
);
2101 if (status
!= -ENOSPC
)
2106 inode
= ocfs2_get_init_inode(dir
, mode
);
2113 handle
= ocfs2_start_trans(osb
, ocfs2_mknod_credits(osb
->sb
, 0, 0));
2114 if (IS_ERR(handle
)) {
2115 status
= PTR_ERR(handle
);
2121 status
= dquot_alloc_inode(inode
);
2124 did_quota_inode
= 1;
2127 /* do the real work now. */
2128 status
= ocfs2_mknod_locked(osb
, dir
, inode
,
2129 0, &new_di_bh
, parent_di_bh
, handle
,
2136 status
= ocfs2_blkno_stringify(OCFS2_I(inode
)->ip_blkno
, orphan_name
);
2142 di
= (struct ocfs2_dinode
*)new_di_bh
->b_data
;
2143 status
= ocfs2_orphan_add(osb
, handle
, inode
, new_di_bh
, orphan_name
,
2144 &orphan_insert
, orphan_dir
);
2150 /* get open lock so that only nodes can't remove it from orphan dir. */
2151 status
= ocfs2_open_lock(inode
);
2155 insert_inode_hash(inode
);
2157 if (status
< 0 && did_quota_inode
)
2158 dquot_free_inode(inode
);
2160 ocfs2_commit_trans(osb
, handle
);
2163 /* This was locked for us in ocfs2_prepare_orphan_dir() */
2164 ocfs2_inode_unlock(orphan_dir
, 1);
2165 mutex_unlock(&orphan_dir
->i_mutex
);
2169 if (status
== -ENOSPC
)
2170 mlog(0, "Disk is full\n");
2172 if ((status
< 0) && inode
) {
2178 ocfs2_free_alloc_context(inode_ac
);
2185 ocfs2_free_dir_lookup_result(&orphan_insert
);
2187 ocfs2_inode_unlock(dir
, 1);
2188 brelse(parent_di_bh
);
2192 int ocfs2_mv_orphaned_inode_to_new(struct inode
*dir
,
2193 struct inode
*inode
,
2194 struct dentry
*dentry
)
2197 struct buffer_head
*parent_di_bh
= NULL
;
2198 handle_t
*handle
= NULL
;
2199 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
2200 struct ocfs2_dinode
*dir_di
, *di
;
2201 struct inode
*orphan_dir_inode
= NULL
;
2202 struct buffer_head
*orphan_dir_bh
= NULL
;
2203 struct buffer_head
*di_bh
= NULL
;
2204 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
2206 mlog_entry("(0x%p, 0x%p, %.*s')\n", dir
, dentry
,
2207 dentry
->d_name
.len
, dentry
->d_name
.name
);
2209 status
= ocfs2_inode_lock(dir
, &parent_di_bh
, 1);
2211 if (status
!= -ENOENT
)
2216 dir_di
= (struct ocfs2_dinode
*) parent_di_bh
->b_data
;
2217 if (!dir_di
->i_links_count
) {
2218 /* can't make a file in a deleted directory. */
2223 status
= ocfs2_check_dir_for_entry(dir
, dentry
->d_name
.name
,
2224 dentry
->d_name
.len
);
2228 /* get a spot inside the dir. */
2229 status
= ocfs2_prepare_dir_for_insert(osb
, dir
, parent_di_bh
,
2230 dentry
->d_name
.name
,
2231 dentry
->d_name
.len
, &lookup
);
2237 orphan_dir_inode
= ocfs2_get_system_file_inode(osb
,
2238 ORPHAN_DIR_SYSTEM_INODE
,
2240 if (!orphan_dir_inode
) {
2246 mutex_lock(&orphan_dir_inode
->i_mutex
);
2248 status
= ocfs2_inode_lock(orphan_dir_inode
, &orphan_dir_bh
, 1);
2251 mutex_unlock(&orphan_dir_inode
->i_mutex
);
2252 iput(orphan_dir_inode
);
2256 status
= ocfs2_read_inode_block(inode
, &di_bh
);
2262 handle
= ocfs2_start_trans(osb
, ocfs2_rename_credits(osb
->sb
));
2263 if (IS_ERR(handle
)) {
2264 status
= PTR_ERR(handle
);
2270 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
),
2271 di_bh
, OCFS2_JOURNAL_ACCESS_WRITE
);
2277 status
= ocfs2_orphan_del(osb
, handle
, orphan_dir_inode
, inode
,
2284 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
2285 le32_add_cpu(&di
->i_flags
, -OCFS2_ORPHANED_FL
);
2286 di
->i_orphaned_slot
= 0;
2288 ocfs2_set_links_count(di
, inode
->i_nlink
);
2289 ocfs2_journal_dirty(handle
, di_bh
);
2291 status
= ocfs2_add_entry(handle
, dentry
, inode
,
2292 OCFS2_I(inode
)->ip_blkno
, parent_di_bh
,
2299 status
= ocfs2_dentry_attach_lock(dentry
, inode
,
2300 OCFS2_I(dir
)->ip_blkno
);
2306 dentry
->d_op
= &ocfs2_dentry_ops
;
2307 d_instantiate(dentry
, inode
);
2310 ocfs2_commit_trans(osb
, handle
);
2312 ocfs2_inode_unlock(orphan_dir_inode
, 1);
2313 mutex_unlock(&orphan_dir_inode
->i_mutex
);
2314 iput(orphan_dir_inode
);
2317 ocfs2_inode_unlock(dir
, 1);
2320 brelse(parent_di_bh
);
2321 brelse(orphan_dir_bh
);
2323 ocfs2_free_dir_lookup_result(&lookup
);
2330 const struct inode_operations ocfs2_dir_iops
= {
2331 .create
= ocfs2_create
,
2332 .lookup
= ocfs2_lookup
,
2334 .unlink
= ocfs2_unlink
,
2335 .rmdir
= ocfs2_unlink
,
2336 .symlink
= ocfs2_symlink
,
2337 .mkdir
= ocfs2_mkdir
,
2338 .mknod
= ocfs2_mknod
,
2339 .rename
= ocfs2_rename
,
2340 .setattr
= ocfs2_setattr
,
2341 .getattr
= ocfs2_getattr
,
2342 .permission
= ocfs2_permission
,
2343 .setxattr
= generic_setxattr
,
2344 .getxattr
= generic_getxattr
,
2345 .listxattr
= ocfs2_listxattr
,
2346 .removexattr
= generic_removexattr
,
2347 .fiemap
= ocfs2_fiemap
,