1 /* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0:
6 * Create and rename file, directory, symlinks
8 * Copyright (C) 2002, 2004 Oracle. All rights reserved.
10 * Portions of this code from linux/fs/ext3/dir.c
12 * Copyright (C) 1992, 1993, 1994, 1995
13 * Remy Card (card@masi.ibp.fr)
14 * Laboratoire MASI - Institut Blaise pascal
15 * Universite Pierre et Marie Curie (Paris VI)
19 * linux/fs/minix/dir.c
21 * Copyright (C) 1991, 1992 Linux Torvalds
23 * This program is free software; you can redistribute it and/or
24 * modify it under the terms of the GNU General Public
25 * License as published by the Free Software Foundation; either
26 * version 2 of the License, or (at your option) any later version.
28 * This program is distributed in the hope that it will be useful,
29 * but WITHOUT ANY WARRANTY; without even the implied warranty of
30 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
31 * General Public License for more details.
33 * You should have received a copy of the GNU General Public
34 * License along with this program; if not, write to the
35 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
36 * Boston, MA 021110-1307, USA.
40 #include <linux/types.h>
41 #include <linux/slab.h>
42 #include <linux/highmem.h>
43 #include <linux/quotaops.h>
45 #include <cluster/masklog.h>
53 #include "extent_map.h"
65 #include "ocfs2_trace.h"
67 #include "buffer_head_io.h"
69 static int ocfs2_mknod_locked(struct ocfs2_super
*osb
,
73 struct buffer_head
**new_fe_bh
,
74 struct buffer_head
*parent_fe_bh
,
76 struct ocfs2_alloc_context
*inode_ac
);
78 static int ocfs2_prepare_orphan_dir(struct ocfs2_super
*osb
,
79 struct inode
**ret_orphan_dir
,
82 struct ocfs2_dir_lookup_result
*lookup
,
85 static int ocfs2_orphan_add(struct ocfs2_super
*osb
,
88 struct buffer_head
*fe_bh
,
90 struct ocfs2_dir_lookup_result
*lookup
,
91 struct inode
*orphan_dir_inode
,
94 static int ocfs2_create_symlink_data(struct ocfs2_super
*osb
,
99 static int ocfs2_double_lock(struct ocfs2_super
*osb
,
100 struct buffer_head
**bh1
,
101 struct inode
*inode1
,
102 struct buffer_head
**bh2
,
103 struct inode
*inode2
,
106 static void ocfs2_double_unlock(struct inode
*inode1
, struct inode
*inode2
);
107 /* An orphan dir name is an 8 byte value, printed as a hex string */
108 #define OCFS2_ORPHAN_NAMELEN ((int)(2 * sizeof(u64)))
110 static struct dentry
*ocfs2_lookup(struct inode
*dir
, struct dentry
*dentry
,
115 struct inode
*inode
= NULL
;
117 struct ocfs2_inode_info
*oi
;
119 trace_ocfs2_lookup(dir
, dentry
, dentry
->d_name
.len
,
121 (unsigned long long)OCFS2_I(dir
)->ip_blkno
, 0);
123 if (dentry
->d_name
.len
> OCFS2_MAX_FILENAME_LEN
) {
124 ret
= ERR_PTR(-ENAMETOOLONG
);
128 status
= ocfs2_inode_lock_nested(dir
, NULL
, 0, OI_LS_PARENT
);
130 if (status
!= -ENOENT
)
132 ret
= ERR_PTR(status
);
136 status
= ocfs2_lookup_ino_from_name(dir
, dentry
->d_name
.name
,
137 dentry
->d_name
.len
, &blkno
);
141 inode
= ocfs2_iget(OCFS2_SB(dir
->i_sb
), blkno
, 0, 0);
143 ret
= ERR_PTR(-EACCES
);
148 /* Clear any orphaned state... If we were able to look up the
149 * inode from a directory, it certainly can't be orphaned. We
150 * might have the bad state from a node which intended to
151 * orphan this inode but crashed before it could commit the
153 spin_lock(&oi
->ip_lock
);
154 oi
->ip_flags
&= ~OCFS2_INODE_MAYBE_ORPHANED
;
155 spin_unlock(&oi
->ip_lock
);
158 ret
= d_splice_alias(inode
, dentry
);
162 * If d_splice_alias() finds a DCACHE_DISCONNECTED
163 * dentry, it will d_move() it on top of ourse. The
164 * return value will indicate this however, so in
165 * those cases, we switch them around for the locking
168 * NOTE: This dentry already has ->d_op set from
169 * ocfs2_get_parent() and ocfs2_get_dentry()
171 if (!IS_ERR_OR_NULL(ret
))
174 status
= ocfs2_dentry_attach_lock(dentry
, inode
,
175 OCFS2_I(dir
)->ip_blkno
);
178 ret
= ERR_PTR(status
);
182 ocfs2_dentry_attach_gen(dentry
);
185 /* Don't drop the cluster lock until *after* the d_add --
186 * unlink on another node will message us to remove that
187 * dentry under this lock so otherwise we can race this with
188 * the downconvert thread and have a stale dentry. */
189 ocfs2_inode_unlock(dir
, 0);
193 trace_ocfs2_lookup_ret(ret
);
198 static struct inode
*ocfs2_get_init_inode(struct inode
*dir
, umode_t mode
)
203 inode
= new_inode(dir
->i_sb
);
205 mlog(ML_ERROR
, "new_inode failed!\n");
206 return ERR_PTR(-ENOMEM
);
209 /* populate as many fields early on as possible - many of
210 * these are used by the support functions here and in
214 inode_init_owner(inode
, dir
, mode
);
215 status
= dquot_initialize(inode
);
217 return ERR_PTR(status
);
222 static void ocfs2_cleanup_add_entry_failure(struct ocfs2_super
*osb
,
223 struct dentry
*dentry
, struct inode
*inode
)
225 struct ocfs2_dentry_lock
*dl
= dentry
->d_fsdata
;
227 ocfs2_simple_drop_lockres(osb
, &dl
->dl_lockres
);
228 ocfs2_lock_res_free(&dl
->dl_lockres
);
229 BUG_ON(dl
->dl_count
!= 1);
230 spin_lock(&dentry_attach_lock
);
231 dentry
->d_fsdata
= NULL
;
232 spin_unlock(&dentry_attach_lock
);
237 static int ocfs2_mknod(struct inode
*dir
,
238 struct dentry
*dentry
,
243 struct buffer_head
*parent_fe_bh
= NULL
;
244 handle_t
*handle
= NULL
;
245 struct ocfs2_super
*osb
;
246 struct ocfs2_dinode
*dirfe
;
247 struct buffer_head
*new_fe_bh
= NULL
;
248 struct inode
*inode
= NULL
;
249 struct ocfs2_alloc_context
*inode_ac
= NULL
;
250 struct ocfs2_alloc_context
*data_ac
= NULL
;
251 struct ocfs2_alloc_context
*meta_ac
= NULL
;
252 int want_clusters
= 0;
254 int xattr_credits
= 0;
255 struct ocfs2_security_xattr_info si
= {
258 int did_quota_inode
= 0;
259 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
261 int did_block_signals
= 0;
262 struct posix_acl
*default_acl
= NULL
, *acl
= NULL
;
263 struct ocfs2_dentry_lock
*dl
= NULL
;
265 trace_ocfs2_mknod(dir
, dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
,
266 (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
267 (unsigned long)dev
, mode
);
269 status
= dquot_initialize(dir
);
275 /* get our super block */
276 osb
= OCFS2_SB(dir
->i_sb
);
278 status
= ocfs2_inode_lock(dir
, &parent_fe_bh
, 1);
280 if (status
!= -ENOENT
)
285 if (S_ISDIR(mode
) && (dir
->i_nlink
>= ocfs2_link_max(osb
))) {
290 dirfe
= (struct ocfs2_dinode
*) parent_fe_bh
->b_data
;
291 if (!ocfs2_read_links_count(dirfe
)) {
292 /* can't make a file in a deleted directory. */
297 status
= ocfs2_check_dir_for_entry(dir
, dentry
->d_name
.name
,
302 /* get a spot inside the dir. */
303 status
= ocfs2_prepare_dir_for_insert(osb
, dir
, parent_fe_bh
,
305 dentry
->d_name
.len
, &lookup
);
311 /* reserve an inode spot */
312 status
= ocfs2_reserve_new_inode(osb
, &inode_ac
);
314 if (status
!= -ENOSPC
)
319 inode
= ocfs2_get_init_inode(dir
, mode
);
321 status
= PTR_ERR(inode
);
327 /* get security xattr */
328 status
= ocfs2_init_security_get(inode
, dir
, &dentry
->d_name
, &si
);
330 if (status
== -EOPNOTSUPP
)
338 /* calculate meta data/clusters for setting security and acl xattr */
339 status
= ocfs2_calc_xattr_init(dir
, parent_fe_bh
, mode
,
341 &xattr_credits
, &want_meta
);
347 /* Reserve a cluster if creating an extent based directory. */
348 if (S_ISDIR(mode
) && !ocfs2_supports_inline_data(osb
)) {
351 /* Dir indexing requires extra space as well */
352 if (ocfs2_supports_indexed_dirs(osb
))
356 status
= ocfs2_reserve_new_metadata_blocks(osb
, want_meta
, &meta_ac
);
358 if (status
!= -ENOSPC
)
363 status
= ocfs2_reserve_clusters(osb
, want_clusters
, &data_ac
);
365 if (status
!= -ENOSPC
)
370 status
= posix_acl_create(dir
, &mode
, &default_acl
, &acl
);
375 /* update inode->i_mode after mask with "umask". */
376 inode
->i_mode
= mode
;
378 handle
= ocfs2_start_trans(osb
, ocfs2_mknod_credits(osb
->sb
,
381 if (IS_ERR(handle
)) {
382 status
= PTR_ERR(handle
);
388 /* Starting to change things, restart is no longer possible. */
389 ocfs2_block_signals(&oldset
);
390 did_block_signals
= 1;
392 status
= dquot_alloc_inode(inode
);
397 /* do the real work now. */
398 status
= ocfs2_mknod_locked(osb
, dir
, inode
, dev
,
399 &new_fe_bh
, parent_fe_bh
, handle
,
407 status
= ocfs2_fill_new_dir(osb
, handle
, dir
, inode
,
408 new_fe_bh
, data_ac
, meta_ac
);
414 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(dir
),
416 OCFS2_JOURNAL_ACCESS_WRITE
);
421 ocfs2_add_links_count(dirfe
, 1);
422 ocfs2_journal_dirty(handle
, parent_fe_bh
);
427 status
= ocfs2_set_acl(handle
, inode
, new_fe_bh
,
428 ACL_TYPE_DEFAULT
, default_acl
,
431 if (!status
&& acl
) {
432 status
= ocfs2_set_acl(handle
, inode
, new_fe_bh
,
433 ACL_TYPE_ACCESS
, acl
,
443 status
= ocfs2_init_security_set(handle
, inode
, new_fe_bh
, &si
,
452 * Do this before adding the entry to the directory. We add
453 * also set d_op after success so that ->d_iput() will cleanup
454 * the dentry lock even if ocfs2_add_entry() fails below.
456 status
= ocfs2_dentry_attach_lock(dentry
, inode
,
457 OCFS2_I(dir
)->ip_blkno
);
463 dl
= dentry
->d_fsdata
;
465 status
= ocfs2_add_entry(handle
, dentry
, inode
,
466 OCFS2_I(inode
)->ip_blkno
, parent_fe_bh
,
473 insert_inode_hash(inode
);
474 d_instantiate(dentry
, inode
);
478 posix_acl_release(default_acl
);
480 posix_acl_release(acl
);
481 if (status
< 0 && did_quota_inode
)
482 dquot_free_inode(inode
);
484 ocfs2_commit_trans(osb
, handle
);
486 ocfs2_inode_unlock(dir
, 1);
487 if (did_block_signals
)
488 ocfs2_unblock_signals(&oldset
);
491 brelse(parent_fe_bh
);
494 ocfs2_free_dir_lookup_result(&lookup
);
497 ocfs2_free_alloc_context(inode_ac
);
500 ocfs2_free_alloc_context(data_ac
);
503 ocfs2_free_alloc_context(meta_ac
);
506 * We should call iput after the i_mutex of the bitmap been
507 * unlocked in ocfs2_free_alloc_context, or the
508 * ocfs2_delete_inode will mutex_lock again.
510 if ((status
< 0) && inode
) {
512 ocfs2_cleanup_add_entry_failure(osb
, dentry
, inode
);
514 OCFS2_I(inode
)->ip_flags
|= OCFS2_INODE_SKIP_ORPHAN_DIR
;
525 static int __ocfs2_mknod_locked(struct inode
*dir
,
528 struct buffer_head
**new_fe_bh
,
529 struct buffer_head
*parent_fe_bh
,
531 struct ocfs2_alloc_context
*inode_ac
,
532 u64 fe_blkno
, u64 suballoc_loc
, u16 suballoc_bit
)
535 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
536 struct ocfs2_dinode
*fe
= NULL
;
537 struct ocfs2_extent_list
*fel
;
539 struct ocfs2_inode_info
*oi
= OCFS2_I(inode
);
543 /* populate as many fields early on as possible - many of
544 * these are used by the support functions here and in
546 inode
->i_ino
= ino_from_blkno(osb
->sb
, fe_blkno
);
547 OCFS2_I(inode
)->ip_blkno
= fe_blkno
;
548 spin_lock(&osb
->osb_lock
);
549 inode
->i_generation
= osb
->s_next_generation
++;
550 spin_unlock(&osb
->osb_lock
);
552 *new_fe_bh
= sb_getblk(osb
->sb
, fe_blkno
);
558 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode
), *new_fe_bh
);
560 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
),
562 OCFS2_JOURNAL_ACCESS_CREATE
);
568 fe
= (struct ocfs2_dinode
*) (*new_fe_bh
)->b_data
;
569 memset(fe
, 0, osb
->sb
->s_blocksize
);
571 fe
->i_generation
= cpu_to_le32(inode
->i_generation
);
572 fe
->i_fs_generation
= cpu_to_le32(osb
->fs_generation
);
573 fe
->i_blkno
= cpu_to_le64(fe_blkno
);
574 fe
->i_suballoc_loc
= cpu_to_le64(suballoc_loc
);
575 fe
->i_suballoc_bit
= cpu_to_le16(suballoc_bit
);
576 fe
->i_suballoc_slot
= cpu_to_le16(inode_ac
->ac_alloc_slot
);
577 fe
->i_uid
= cpu_to_le32(i_uid_read(inode
));
578 fe
->i_gid
= cpu_to_le32(i_gid_read(inode
));
579 fe
->i_mode
= cpu_to_le16(inode
->i_mode
);
580 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
))
581 fe
->id1
.dev1
.i_rdev
= cpu_to_le64(huge_encode_dev(dev
));
583 ocfs2_set_links_count(fe
, inode
->i_nlink
);
585 fe
->i_last_eb_blk
= 0;
586 strcpy(fe
->i_signature
, OCFS2_INODE_SIGNATURE
);
587 fe
->i_flags
|= cpu_to_le32(OCFS2_VALID_FL
);
588 fe
->i_atime
= fe
->i_ctime
= fe
->i_mtime
=
589 cpu_to_le64(CURRENT_TIME
.tv_sec
);
590 fe
->i_mtime_nsec
= fe
->i_ctime_nsec
= fe
->i_atime_nsec
=
591 cpu_to_le32(CURRENT_TIME
.tv_nsec
);
595 * If supported, directories start with inline data. If inline
596 * isn't supported, but indexing is, we start them as indexed.
598 feat
= le16_to_cpu(fe
->i_dyn_features
);
599 if (S_ISDIR(inode
->i_mode
) && ocfs2_supports_inline_data(osb
)) {
600 fe
->i_dyn_features
= cpu_to_le16(feat
| OCFS2_INLINE_DATA_FL
);
602 fe
->id2
.i_data
.id_count
= cpu_to_le16(
603 ocfs2_max_inline_data_with_xattr(osb
->sb
, fe
));
605 fel
= &fe
->id2
.i_list
;
606 fel
->l_tree_depth
= 0;
607 fel
->l_next_free_rec
= 0;
608 fel
->l_count
= cpu_to_le16(ocfs2_extent_recs_per_inode(osb
->sb
));
611 ocfs2_journal_dirty(handle
, *new_fe_bh
);
613 ocfs2_populate_inode(inode
, fe
, 1);
614 ocfs2_ci_set_new(osb
, INODE_CACHE(inode
));
615 if (!ocfs2_mount_local(osb
)) {
616 status
= ocfs2_create_new_inode_locks(inode
);
621 oi
->i_sync_tid
= handle
->h_transaction
->t_tid
;
622 oi
->i_datasync_tid
= handle
->h_transaction
->t_tid
;
637 static int ocfs2_mknod_locked(struct ocfs2_super
*osb
,
641 struct buffer_head
**new_fe_bh
,
642 struct buffer_head
*parent_fe_bh
,
644 struct ocfs2_alloc_context
*inode_ac
)
647 u64 suballoc_loc
, fe_blkno
= 0;
652 status
= ocfs2_claim_new_inode(handle
, dir
, parent_fe_bh
,
653 inode_ac
, &suballoc_loc
,
654 &suballoc_bit
, &fe_blkno
);
660 status
= __ocfs2_mknod_locked(dir
, inode
, dev
, new_fe_bh
,
661 parent_fe_bh
, handle
, inode_ac
,
662 fe_blkno
, suballoc_loc
, suballoc_bit
);
664 u64 bg_blkno
= ocfs2_which_suballoc_group(fe_blkno
, suballoc_bit
);
665 int tmp
= ocfs2_free_suballoc_bits(handle
, inode_ac
->ac_inode
,
666 inode_ac
->ac_bh
, suballoc_bit
, bg_blkno
, 1);
674 static int ocfs2_mkdir(struct inode
*dir
,
675 struct dentry
*dentry
,
680 trace_ocfs2_mkdir(dir
, dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
,
681 OCFS2_I(dir
)->ip_blkno
, mode
);
682 ret
= ocfs2_mknod(dir
, dentry
, mode
| S_IFDIR
, 0);
689 static int ocfs2_create(struct inode
*dir
,
690 struct dentry
*dentry
,
696 trace_ocfs2_create(dir
, dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
,
697 (unsigned long long)OCFS2_I(dir
)->ip_blkno
, mode
);
698 ret
= ocfs2_mknod(dir
, dentry
, mode
| S_IFREG
, 0);
705 static int ocfs2_link(struct dentry
*old_dentry
,
707 struct dentry
*dentry
)
710 struct inode
*inode
= d_inode(old_dentry
);
711 struct inode
*old_dir
= d_inode(old_dentry
->d_parent
);
713 struct buffer_head
*fe_bh
= NULL
;
714 struct buffer_head
*old_dir_bh
= NULL
;
715 struct buffer_head
*parent_fe_bh
= NULL
;
716 struct ocfs2_dinode
*fe
= NULL
;
717 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
718 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
722 trace_ocfs2_link((unsigned long long)OCFS2_I(inode
)->ip_blkno
,
723 old_dentry
->d_name
.len
, old_dentry
->d_name
.name
,
724 dentry
->d_name
.len
, dentry
->d_name
.name
);
726 if (S_ISDIR(inode
->i_mode
))
729 err
= dquot_initialize(dir
);
735 err
= ocfs2_double_lock(osb
, &old_dir_bh
, old_dir
,
736 &parent_fe_bh
, dir
, 0);
743 /* make sure both dirs have bhs
744 * get an extra ref on old_dir_bh if old==new */
747 parent_fe_bh
= old_dir_bh
;
748 get_bh(parent_fe_bh
);
750 mlog(ML_ERROR
, "%s: no old_dir_bh!\n", osb
->uuid_str
);
761 err
= ocfs2_lookup_ino_from_name(old_dir
, old_dentry
->d_name
.name
,
762 old_dentry
->d_name
.len
, &old_de_ino
);
769 * Check whether another node removed the source inode while we
772 if (old_de_ino
!= OCFS2_I(inode
)->ip_blkno
) {
777 err
= ocfs2_check_dir_for_entry(dir
, dentry
->d_name
.name
,
782 err
= ocfs2_prepare_dir_for_insert(osb
, dir
, parent_fe_bh
,
784 dentry
->d_name
.len
, &lookup
);
790 err
= ocfs2_inode_lock(inode
, &fe_bh
, 1);
797 fe
= (struct ocfs2_dinode
*) fe_bh
->b_data
;
798 if (ocfs2_read_links_count(fe
) >= ocfs2_link_max(osb
)) {
800 goto out_unlock_inode
;
803 handle
= ocfs2_start_trans(osb
, ocfs2_link_credits(osb
->sb
));
804 if (IS_ERR(handle
)) {
805 err
= PTR_ERR(handle
);
808 goto out_unlock_inode
;
811 /* Starting to change things, restart is no longer possible. */
812 ocfs2_block_signals(&oldset
);
814 err
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
), fe_bh
,
815 OCFS2_JOURNAL_ACCESS_WRITE
);
822 inode
->i_ctime
= CURRENT_TIME
;
823 ocfs2_set_links_count(fe
, inode
->i_nlink
);
824 fe
->i_ctime
= cpu_to_le64(inode
->i_ctime
.tv_sec
);
825 fe
->i_ctime_nsec
= cpu_to_le32(inode
->i_ctime
.tv_nsec
);
826 ocfs2_journal_dirty(handle
, fe_bh
);
828 err
= ocfs2_add_entry(handle
, dentry
, inode
,
829 OCFS2_I(inode
)->ip_blkno
,
830 parent_fe_bh
, &lookup
);
832 ocfs2_add_links_count(fe
, -1);
838 err
= ocfs2_dentry_attach_lock(dentry
, inode
, OCFS2_I(dir
)->ip_blkno
);
845 d_instantiate(dentry
, inode
);
848 ocfs2_commit_trans(osb
, handle
);
849 ocfs2_unblock_signals(&oldset
);
851 ocfs2_inode_unlock(inode
, 1);
854 ocfs2_double_unlock(old_dir
, dir
);
857 brelse(parent_fe_bh
);
860 ocfs2_free_dir_lookup_result(&lookup
);
869 * Takes and drops an exclusive lock on the given dentry. This will
870 * force other nodes to drop it.
872 static int ocfs2_remote_dentry_delete(struct dentry
*dentry
)
876 ret
= ocfs2_dentry_lock(dentry
, 1);
880 ocfs2_dentry_unlock(dentry
, 1);
885 static inline int ocfs2_inode_is_unlinkable(struct inode
*inode
)
887 if (S_ISDIR(inode
->i_mode
)) {
888 if (inode
->i_nlink
== 2)
893 if (inode
->i_nlink
== 1)
898 static int ocfs2_unlink(struct inode
*dir
,
899 struct dentry
*dentry
)
902 int child_locked
= 0;
903 bool is_unlinkable
= false;
904 struct inode
*inode
= d_inode(dentry
);
905 struct inode
*orphan_dir
= NULL
;
906 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
908 struct ocfs2_dinode
*fe
= NULL
;
909 struct buffer_head
*fe_bh
= NULL
;
910 struct buffer_head
*parent_node_bh
= NULL
;
911 handle_t
*handle
= NULL
;
912 char orphan_name
[OCFS2_ORPHAN_NAMELEN
+ 1];
913 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
914 struct ocfs2_dir_lookup_result orphan_insert
= { NULL
, };
916 trace_ocfs2_unlink(dir
, dentry
, dentry
->d_name
.len
,
918 (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
919 (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
921 status
= dquot_initialize(dir
);
927 BUG_ON(d_inode(dentry
->d_parent
) != dir
);
929 if (inode
== osb
->root_inode
)
932 status
= ocfs2_inode_lock_nested(dir
, &parent_node_bh
, 1,
935 if (status
!= -ENOENT
)
940 status
= ocfs2_find_files_on_disk(dentry
->d_name
.name
,
941 dentry
->d_name
.len
, &blkno
, dir
,
944 if (status
!= -ENOENT
)
949 if (OCFS2_I(inode
)->ip_blkno
!= blkno
) {
952 trace_ocfs2_unlink_noent(
953 (unsigned long long)OCFS2_I(inode
)->ip_blkno
,
954 (unsigned long long)blkno
,
955 OCFS2_I(inode
)->ip_flags
);
959 status
= ocfs2_inode_lock(inode
, &fe_bh
, 1);
961 if (status
!= -ENOENT
)
967 if (S_ISDIR(inode
->i_mode
)) {
968 if (inode
->i_nlink
!= 2 || !ocfs2_empty_dir(inode
)) {
974 status
= ocfs2_remote_dentry_delete(dentry
);
976 /* This remote delete should succeed under all normal
982 if (ocfs2_inode_is_unlinkable(inode
)) {
983 status
= ocfs2_prepare_orphan_dir(osb
, &orphan_dir
,
984 OCFS2_I(inode
)->ip_blkno
,
985 orphan_name
, &orphan_insert
,
991 is_unlinkable
= true;
994 handle
= ocfs2_start_trans(osb
, ocfs2_unlink_credits(osb
->sb
));
995 if (IS_ERR(handle
)) {
996 status
= PTR_ERR(handle
);
1002 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
), fe_bh
,
1003 OCFS2_JOURNAL_ACCESS_WRITE
);
1009 fe
= (struct ocfs2_dinode
*) fe_bh
->b_data
;
1011 /* delete the name from the parent dir */
1012 status
= ocfs2_delete_entry(handle
, dir
, &lookup
);
1018 if (S_ISDIR(inode
->i_mode
))
1021 ocfs2_set_links_count(fe
, inode
->i_nlink
);
1022 ocfs2_journal_dirty(handle
, fe_bh
);
1024 dir
->i_ctime
= dir
->i_mtime
= CURRENT_TIME
;
1025 if (S_ISDIR(inode
->i_mode
))
1028 status
= ocfs2_mark_inode_dirty(handle
, dir
, parent_node_bh
);
1031 if (S_ISDIR(inode
->i_mode
))
1036 if (is_unlinkable
) {
1037 status
= ocfs2_orphan_add(osb
, handle
, inode
, fe_bh
,
1038 orphan_name
, &orphan_insert
, orphan_dir
, false);
1045 ocfs2_commit_trans(osb
, handle
);
1048 /* This was locked for us in ocfs2_prepare_orphan_dir() */
1049 ocfs2_inode_unlock(orphan_dir
, 1);
1050 mutex_unlock(&orphan_dir
->i_mutex
);
1055 ocfs2_inode_unlock(inode
, 1);
1057 ocfs2_inode_unlock(dir
, 1);
1060 brelse(parent_node_bh
);
1062 ocfs2_free_dir_lookup_result(&orphan_insert
);
1063 ocfs2_free_dir_lookup_result(&lookup
);
1065 if (status
&& (status
!= -ENOTEMPTY
) && (status
!= -ENOENT
))
1071 static int ocfs2_check_if_ancestor(struct ocfs2_super
*osb
,
1072 u64 src_inode_no
, u64 dest_inode_no
)
1075 u64 parent_inode_no
= 0;
1076 u64 child_inode_no
= src_inode_no
;
1077 struct inode
*child_inode
;
1079 #define MAX_LOOKUP_TIMES 32
1081 child_inode
= ocfs2_iget(osb
, child_inode_no
, 0, 0);
1082 if (IS_ERR(child_inode
)) {
1083 ret
= PTR_ERR(child_inode
);
1087 ret
= ocfs2_inode_lock(child_inode
, NULL
, 0);
1095 ret
= ocfs2_lookup_ino_from_name(child_inode
, "..", 2,
1097 ocfs2_inode_unlock(child_inode
, 0);
1104 if (parent_inode_no
== dest_inode_no
) {
1109 if (parent_inode_no
== osb
->root_inode
->i_ino
) {
1114 child_inode_no
= parent_inode_no
;
1116 if (++i
>= MAX_LOOKUP_TIMES
) {
1117 mlog(ML_NOTICE
, "max lookup times reached, filesystem "
1118 "may have nested directories, "
1119 "src inode: %llu, dest inode: %llu.\n",
1120 (unsigned long long)src_inode_no
,
1121 (unsigned long long)dest_inode_no
);
1131 * The only place this should be used is rename and link!
1132 * if they have the same id, then the 1st one is the only one locked.
1134 static int ocfs2_double_lock(struct ocfs2_super
*osb
,
1135 struct buffer_head
**bh1
,
1136 struct inode
*inode1
,
1137 struct buffer_head
**bh2
,
1138 struct inode
*inode2
,
1142 int inode1_is_ancestor
, inode2_is_ancestor
;
1143 struct ocfs2_inode_info
*oi1
= OCFS2_I(inode1
);
1144 struct ocfs2_inode_info
*oi2
= OCFS2_I(inode2
);
1146 trace_ocfs2_double_lock((unsigned long long)oi1
->ip_blkno
,
1147 (unsigned long long)oi2
->ip_blkno
);
1154 /* we always want to lock the one with the lower lockid first.
1155 * and if they are nested, we lock ancestor first */
1156 if (oi1
->ip_blkno
!= oi2
->ip_blkno
) {
1157 inode1_is_ancestor
= ocfs2_check_if_ancestor(osb
, oi2
->ip_blkno
,
1159 if (inode1_is_ancestor
< 0) {
1160 status
= inode1_is_ancestor
;
1164 inode2_is_ancestor
= ocfs2_check_if_ancestor(osb
, oi1
->ip_blkno
,
1166 if (inode2_is_ancestor
< 0) {
1167 status
= inode2_is_ancestor
;
1171 if ((inode1_is_ancestor
== 1) ||
1172 (oi1
->ip_blkno
< oi2
->ip_blkno
&&
1173 inode2_is_ancestor
== 0)) {
1174 /* switch id1 and id2 around */
1176 swap(inode2
, inode1
);
1179 status
= ocfs2_inode_lock_nested(inode2
, bh2
, 1,
1180 rename
== 1 ? OI_LS_RENAME1
: OI_LS_PARENT
);
1182 if (status
!= -ENOENT
)
1189 status
= ocfs2_inode_lock_nested(inode1
, bh1
, 1,
1190 rename
== 1 ? OI_LS_RENAME2
: OI_LS_PARENT
);
1193 * An error return must mean that no cluster locks
1194 * were held on function exit.
1196 if (oi1
->ip_blkno
!= oi2
->ip_blkno
) {
1197 ocfs2_inode_unlock(inode2
, 1);
1202 if (status
!= -ENOENT
)
1206 trace_ocfs2_double_lock_end(
1207 (unsigned long long)OCFS2_I(inode1
)->ip_blkno
,
1208 (unsigned long long)OCFS2_I(inode2
)->ip_blkno
);
1216 static void ocfs2_double_unlock(struct inode
*inode1
, struct inode
*inode2
)
1218 ocfs2_inode_unlock(inode1
, 1);
1220 if (inode1
!= inode2
)
1221 ocfs2_inode_unlock(inode2
, 1);
1224 static int ocfs2_rename(struct inode
*old_dir
,
1225 struct dentry
*old_dentry
,
1226 struct inode
*new_dir
,
1227 struct dentry
*new_dentry
)
1229 int status
= 0, rename_lock
= 0, parents_locked
= 0, target_exists
= 0;
1230 int old_child_locked
= 0, new_child_locked
= 0, update_dot_dot
= 0;
1231 struct inode
*old_inode
= d_inode(old_dentry
);
1232 struct inode
*new_inode
= d_inode(new_dentry
);
1233 struct inode
*orphan_dir
= NULL
;
1234 struct ocfs2_dinode
*newfe
= NULL
;
1235 char orphan_name
[OCFS2_ORPHAN_NAMELEN
+ 1];
1236 struct buffer_head
*newfe_bh
= NULL
;
1237 struct buffer_head
*old_inode_bh
= NULL
;
1238 struct ocfs2_super
*osb
= NULL
;
1239 u64 newfe_blkno
, old_de_ino
;
1240 handle_t
*handle
= NULL
;
1241 struct buffer_head
*old_dir_bh
= NULL
;
1242 struct buffer_head
*new_dir_bh
= NULL
;
1243 u32 old_dir_nlink
= old_dir
->i_nlink
;
1244 struct ocfs2_dinode
*old_di
;
1245 struct ocfs2_dir_lookup_result old_inode_dot_dot_res
= { NULL
, };
1246 struct ocfs2_dir_lookup_result target_lookup_res
= { NULL
, };
1247 struct ocfs2_dir_lookup_result old_entry_lookup
= { NULL
, };
1248 struct ocfs2_dir_lookup_result orphan_insert
= { NULL
, };
1249 struct ocfs2_dir_lookup_result target_insert
= { NULL
, };
1250 bool should_add_orphan
= false;
1252 /* At some point it might be nice to break this function up a
1255 trace_ocfs2_rename(old_dir
, old_dentry
, new_dir
, new_dentry
,
1256 old_dentry
->d_name
.len
, old_dentry
->d_name
.name
,
1257 new_dentry
->d_name
.len
, new_dentry
->d_name
.name
);
1259 status
= dquot_initialize(old_dir
);
1264 status
= dquot_initialize(new_dir
);
1270 osb
= OCFS2_SB(old_dir
->i_sb
);
1273 if (!igrab(new_inode
))
1277 /* Assume a directory hierarchy thusly:
1280 * a,b,c, and d are all directories.
1282 * from cwd of 'a' on both nodes:
1286 * And that's why, just like the VFS, we need a file system
1288 if (old_dir
!= new_dir
&& S_ISDIR(old_inode
->i_mode
)) {
1289 status
= ocfs2_rename_lock(osb
);
1296 /* here we cannot guarantee the inodes haven't just been
1297 * changed, so check if they are nested again */
1298 status
= ocfs2_check_if_ancestor(osb
, new_dir
->i_ino
,
1303 } else if (status
== 1) {
1305 trace_ocfs2_rename_not_permitted(
1306 (unsigned long long)old_inode
->i_ino
,
1307 (unsigned long long)new_dir
->i_ino
);
1312 /* if old and new are the same, this'll just do one lock. */
1313 status
= ocfs2_double_lock(osb
, &old_dir_bh
, old_dir
,
1314 &new_dir_bh
, new_dir
, 1);
1321 if (!new_dir
->i_nlink
) {
1326 /* make sure both dirs have bhs
1327 * get an extra ref on old_dir_bh if old==new */
1330 new_dir_bh
= old_dir_bh
;
1333 mlog(ML_ERROR
, "no old_dir_bh!\n");
1340 * Aside from allowing a meta data update, the locking here
1341 * also ensures that the downconvert thread on other nodes
1342 * won't have to concurrently downconvert the inode and the
1345 status
= ocfs2_inode_lock_nested(old_inode
, &old_inode_bh
, 1,
1348 if (status
!= -ENOENT
)
1352 old_child_locked
= 1;
1354 status
= ocfs2_remote_dentry_delete(old_dentry
);
1360 if (S_ISDIR(old_inode
->i_mode
)) {
1361 u64 old_inode_parent
;
1364 status
= ocfs2_find_files_on_disk("..", 2, &old_inode_parent
,
1366 &old_inode_dot_dot_res
);
1372 if (old_inode_parent
!= OCFS2_I(old_dir
)->ip_blkno
) {
1377 if (!new_inode
&& new_dir
!= old_dir
&&
1378 new_dir
->i_nlink
>= ocfs2_link_max(osb
)) {
1384 status
= ocfs2_lookup_ino_from_name(old_dir
, old_dentry
->d_name
.name
,
1385 old_dentry
->d_name
.len
,
1393 * Check for inode number is _not_ due to possible IO errors.
1394 * We might rmdir the source, keep it as pwd of some process
1395 * and merrily kill the link to whatever was created under the
1396 * same name. Goodbye sticky bit ;-<
1398 if (old_de_ino
!= OCFS2_I(old_inode
)->ip_blkno
) {
1403 /* check if the target already exists (in which case we need
1405 status
= ocfs2_find_files_on_disk(new_dentry
->d_name
.name
,
1406 new_dentry
->d_name
.len
,
1407 &newfe_blkno
, new_dir
,
1408 &target_lookup_res
);
1409 /* The only error we allow here is -ENOENT because the new
1410 * file not existing is perfectly valid. */
1411 if ((status
< 0) && (status
!= -ENOENT
)) {
1412 /* If we cannot find the file specified we should just */
1413 /* return the error... */
1420 if (!target_exists
&& new_inode
) {
1422 * Target was unlinked by another node while we were
1423 * waiting to get to ocfs2_rename(). There isn't
1424 * anything we can do here to help the situation, so
1425 * bubble up the appropriate error.
1431 /* In case we need to overwrite an existing file, we blow it
1433 if (target_exists
) {
1434 /* VFS didn't think there existed an inode here, but
1435 * someone else in the cluster must have raced our
1436 * rename to create one. Today we error cleanly, in
1437 * the future we should consider calling iget to build
1438 * a new struct inode for this entry. */
1442 trace_ocfs2_rename_target_exists(new_dentry
->d_name
.len
,
1443 new_dentry
->d_name
.name
);
1447 if (OCFS2_I(new_inode
)->ip_blkno
!= newfe_blkno
) {
1450 trace_ocfs2_rename_disagree(
1451 (unsigned long long)OCFS2_I(new_inode
)->ip_blkno
,
1452 (unsigned long long)newfe_blkno
,
1453 OCFS2_I(new_inode
)->ip_flags
);
1457 status
= ocfs2_inode_lock(new_inode
, &newfe_bh
, 1);
1459 if (status
!= -ENOENT
)
1463 new_child_locked
= 1;
1465 status
= ocfs2_remote_dentry_delete(new_dentry
);
1471 newfe
= (struct ocfs2_dinode
*) newfe_bh
->b_data
;
1473 trace_ocfs2_rename_over_existing(
1474 (unsigned long long)newfe_blkno
, newfe_bh
, newfe_bh
?
1475 (unsigned long long)newfe_bh
->b_blocknr
: 0ULL);
1477 if (S_ISDIR(new_inode
->i_mode
) || (new_inode
->i_nlink
== 1)) {
1478 status
= ocfs2_prepare_orphan_dir(osb
, &orphan_dir
,
1479 OCFS2_I(new_inode
)->ip_blkno
,
1480 orphan_name
, &orphan_insert
,
1486 should_add_orphan
= true;
1489 BUG_ON(d_inode(new_dentry
->d_parent
) != new_dir
);
1491 status
= ocfs2_check_dir_for_entry(new_dir
,
1492 new_dentry
->d_name
.name
,
1493 new_dentry
->d_name
.len
);
1497 status
= ocfs2_prepare_dir_for_insert(osb
, new_dir
, new_dir_bh
,
1498 new_dentry
->d_name
.name
,
1499 new_dentry
->d_name
.len
,
1507 handle
= ocfs2_start_trans(osb
, ocfs2_rename_credits(osb
->sb
));
1508 if (IS_ERR(handle
)) {
1509 status
= PTR_ERR(handle
);
1515 if (target_exists
) {
1516 if (S_ISDIR(new_inode
->i_mode
)) {
1517 if (new_inode
->i_nlink
!= 2 ||
1518 !ocfs2_empty_dir(new_inode
)) {
1519 status
= -ENOTEMPTY
;
1523 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(new_inode
),
1525 OCFS2_JOURNAL_ACCESS_WRITE
);
1531 /* change the dirent to point to the correct inode */
1532 status
= ocfs2_update_entry(new_dir
, handle
, &target_lookup_res
,
1538 new_dir
->i_version
++;
1540 if (S_ISDIR(new_inode
->i_mode
))
1541 ocfs2_set_links_count(newfe
, 0);
1543 ocfs2_add_links_count(newfe
, -1);
1544 ocfs2_journal_dirty(handle
, newfe_bh
);
1545 if (should_add_orphan
) {
1546 status
= ocfs2_orphan_add(osb
, handle
, new_inode
,
1547 newfe_bh
, orphan_name
,
1548 &orphan_insert
, orphan_dir
, false);
1555 /* if the name was not found in new_dir, add it now */
1556 status
= ocfs2_add_entry(handle
, new_dentry
, old_inode
,
1557 OCFS2_I(old_inode
)->ip_blkno
,
1558 new_dir_bh
, &target_insert
);
1561 old_inode
->i_ctime
= CURRENT_TIME
;
1562 mark_inode_dirty(old_inode
);
1564 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(old_inode
),
1566 OCFS2_JOURNAL_ACCESS_WRITE
);
1568 old_di
= (struct ocfs2_dinode
*) old_inode_bh
->b_data
;
1570 old_di
->i_ctime
= cpu_to_le64(old_inode
->i_ctime
.tv_sec
);
1571 old_di
->i_ctime_nsec
= cpu_to_le32(old_inode
->i_ctime
.tv_nsec
);
1572 ocfs2_journal_dirty(handle
, old_inode_bh
);
1577 * Now that the name has been added to new_dir, remove the old name.
1579 * We don't keep any directory entry context around until now
1580 * because the insert might have changed the type of directory
1581 * we're dealing with.
1583 status
= ocfs2_find_entry(old_dentry
->d_name
.name
,
1584 old_dentry
->d_name
.len
, old_dir
,
1587 if (!is_journal_aborted(osb
->journal
->j_journal
)) {
1588 ocfs2_error(osb
->sb
, "new entry %.*s is added, but old entry %.*s "
1590 new_dentry
->d_name
.len
, new_dentry
->d_name
.name
,
1591 old_dentry
->d_name
.len
, old_dentry
->d_name
.name
);
1596 status
= ocfs2_delete_entry(handle
, old_dir
, &old_entry_lookup
);
1599 if (!is_journal_aborted(osb
->journal
->j_journal
)) {
1600 ocfs2_error(osb
->sb
, "new entry %.*s is added, but old entry %.*s "
1602 new_dentry
->d_name
.len
, new_dentry
->d_name
.name
,
1603 old_dentry
->d_name
.len
, old_dentry
->d_name
.name
);
1609 drop_nlink(new_inode
);
1610 new_inode
->i_ctime
= CURRENT_TIME
;
1612 old_dir
->i_ctime
= old_dir
->i_mtime
= CURRENT_TIME
;
1614 if (update_dot_dot
) {
1615 status
= ocfs2_update_entry(old_inode
, handle
,
1616 &old_inode_dot_dot_res
, new_dir
);
1617 drop_nlink(old_dir
);
1619 drop_nlink(new_inode
);
1622 mark_inode_dirty(new_dir
);
1625 mark_inode_dirty(old_dir
);
1626 ocfs2_mark_inode_dirty(handle
, old_dir
, old_dir_bh
);
1628 mark_inode_dirty(new_inode
);
1629 ocfs2_mark_inode_dirty(handle
, new_inode
, newfe_bh
);
1632 if (old_dir
!= new_dir
) {
1633 /* Keep the same times on both directories.*/
1634 new_dir
->i_ctime
= new_dir
->i_mtime
= old_dir
->i_ctime
;
1637 * This will also pick up the i_nlink change from the
1640 ocfs2_mark_inode_dirty(handle
, new_dir
, new_dir_bh
);
1643 if (old_dir_nlink
!= old_dir
->i_nlink
) {
1645 mlog(ML_ERROR
, "need to change nlink for old dir "
1646 "%llu from %d to %d but bh is NULL!\n",
1647 (unsigned long long)OCFS2_I(old_dir
)->ip_blkno
,
1648 (int)old_dir_nlink
, old_dir
->i_nlink
);
1650 struct ocfs2_dinode
*fe
;
1651 status
= ocfs2_journal_access_di(handle
,
1652 INODE_CACHE(old_dir
),
1654 OCFS2_JOURNAL_ACCESS_WRITE
);
1655 fe
= (struct ocfs2_dinode
*) old_dir_bh
->b_data
;
1656 ocfs2_set_links_count(fe
, old_dir
->i_nlink
);
1657 ocfs2_journal_dirty(handle
, old_dir_bh
);
1660 ocfs2_dentry_move(old_dentry
, new_dentry
, old_dir
, new_dir
);
1664 ocfs2_commit_trans(osb
, handle
);
1667 /* This was locked for us in ocfs2_prepare_orphan_dir() */
1668 ocfs2_inode_unlock(orphan_dir
, 1);
1669 mutex_unlock(&orphan_dir
->i_mutex
);
1673 if (new_child_locked
)
1674 ocfs2_inode_unlock(new_inode
, 1);
1676 if (old_child_locked
)
1677 ocfs2_inode_unlock(old_inode
, 1);
1680 ocfs2_double_unlock(old_dir
, new_dir
);
1683 ocfs2_rename_unlock(osb
);
1686 sync_mapping_buffers(old_inode
->i_mapping
);
1691 ocfs2_free_dir_lookup_result(&target_lookup_res
);
1692 ocfs2_free_dir_lookup_result(&old_entry_lookup
);
1693 ocfs2_free_dir_lookup_result(&old_inode_dot_dot_res
);
1694 ocfs2_free_dir_lookup_result(&orphan_insert
);
1695 ocfs2_free_dir_lookup_result(&target_insert
);
1698 brelse(old_inode_bh
);
1709 * we expect i_size = strlen(symname). Copy symname into the file
1710 * data, including the null terminator.
1712 static int ocfs2_create_symlink_data(struct ocfs2_super
*osb
,
1714 struct inode
*inode
,
1715 const char *symname
)
1717 struct buffer_head
**bhs
= NULL
;
1719 struct super_block
*sb
= osb
->sb
;
1720 u64 p_blkno
, p_blocks
;
1721 int virtual, blocks
, status
, i
, bytes_left
;
1723 bytes_left
= i_size_read(inode
) + 1;
1724 /* we can't trust i_blocks because we're actually going to
1725 * write i_size + 1 bytes. */
1726 blocks
= (bytes_left
+ sb
->s_blocksize
- 1) >> sb
->s_blocksize_bits
;
1728 trace_ocfs2_create_symlink_data((unsigned long long)inode
->i_blocks
,
1729 i_size_read(inode
), blocks
);
1731 /* Sanity check -- make sure we're going to fit. */
1733 ocfs2_clusters_to_bytes(sb
, OCFS2_I(inode
)->ip_clusters
)) {
1739 bhs
= kcalloc(blocks
, sizeof(struct buffer_head
*), GFP_KERNEL
);
1746 status
= ocfs2_extent_map_get_blocks(inode
, 0, &p_blkno
, &p_blocks
,
1753 /* links can never be larger than one cluster so we know this
1754 * is all going to be contiguous, but do a sanity check
1756 if ((p_blocks
<< sb
->s_blocksize_bits
) < bytes_left
) {
1763 while(bytes_left
> 0) {
1764 c
= &symname
[virtual * sb
->s_blocksize
];
1766 bhs
[virtual] = sb_getblk(sb
, p_blkno
);
1767 if (!bhs
[virtual]) {
1772 ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode
),
1775 status
= ocfs2_journal_access(handle
, INODE_CACHE(inode
),
1777 OCFS2_JOURNAL_ACCESS_CREATE
);
1783 memset(bhs
[virtual]->b_data
, 0, sb
->s_blocksize
);
1785 memcpy(bhs
[virtual]->b_data
, c
,
1786 (bytes_left
> sb
->s_blocksize
) ? sb
->s_blocksize
:
1789 ocfs2_journal_dirty(handle
, bhs
[virtual]);
1793 bytes_left
-= sb
->s_blocksize
;
1800 for(i
= 0; i
< blocks
; i
++)
1810 static int ocfs2_symlink(struct inode
*dir
,
1811 struct dentry
*dentry
,
1812 const char *symname
)
1814 int status
, l
, credits
;
1816 struct ocfs2_super
*osb
= NULL
;
1817 struct inode
*inode
= NULL
;
1818 struct super_block
*sb
;
1819 struct buffer_head
*new_fe_bh
= NULL
;
1820 struct buffer_head
*parent_fe_bh
= NULL
;
1821 struct ocfs2_dinode
*fe
= NULL
;
1822 struct ocfs2_dinode
*dirfe
;
1823 handle_t
*handle
= NULL
;
1824 struct ocfs2_alloc_context
*inode_ac
= NULL
;
1825 struct ocfs2_alloc_context
*data_ac
= NULL
;
1826 struct ocfs2_alloc_context
*xattr_ac
= NULL
;
1827 int want_clusters
= 0;
1828 int xattr_credits
= 0;
1829 struct ocfs2_security_xattr_info si
= {
1832 int did_quota
= 0, did_quota_inode
= 0;
1833 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
1835 int did_block_signals
= 0;
1836 struct ocfs2_dentry_lock
*dl
= NULL
;
1838 trace_ocfs2_symlink_begin(dir
, dentry
, symname
,
1839 dentry
->d_name
.len
, dentry
->d_name
.name
);
1841 status
= dquot_initialize(dir
);
1850 l
= strlen(symname
) + 1;
1852 credits
= ocfs2_calc_symlink_credits(sb
);
1854 /* lock the parent directory */
1855 status
= ocfs2_inode_lock(dir
, &parent_fe_bh
, 1);
1857 if (status
!= -ENOENT
)
1862 dirfe
= (struct ocfs2_dinode
*) parent_fe_bh
->b_data
;
1863 if (!ocfs2_read_links_count(dirfe
)) {
1864 /* can't make a file in a deleted directory. */
1869 status
= ocfs2_check_dir_for_entry(dir
, dentry
->d_name
.name
,
1870 dentry
->d_name
.len
);
1874 status
= ocfs2_prepare_dir_for_insert(osb
, dir
, parent_fe_bh
,
1875 dentry
->d_name
.name
,
1876 dentry
->d_name
.len
, &lookup
);
1882 status
= ocfs2_reserve_new_inode(osb
, &inode_ac
);
1884 if (status
!= -ENOSPC
)
1889 inode
= ocfs2_get_init_inode(dir
, S_IFLNK
| S_IRWXUGO
);
1890 if (IS_ERR(inode
)) {
1891 status
= PTR_ERR(inode
);
1897 /* get security xattr */
1898 status
= ocfs2_init_security_get(inode
, dir
, &dentry
->d_name
, &si
);
1900 if (status
== -EOPNOTSUPP
)
1908 /* calculate meta data/clusters for setting security xattr */
1910 status
= ocfs2_calc_security_init(dir
, &si
, &want_clusters
,
1911 &xattr_credits
, &xattr_ac
);
1918 /* don't reserve bitmap space for fast symlinks. */
1919 if (l
> ocfs2_fast_symlink_chars(sb
))
1922 status
= ocfs2_reserve_clusters(osb
, want_clusters
, &data_ac
);
1924 if (status
!= -ENOSPC
)
1929 handle
= ocfs2_start_trans(osb
, credits
+ xattr_credits
);
1930 if (IS_ERR(handle
)) {
1931 status
= PTR_ERR(handle
);
1937 /* Starting to change things, restart is no longer possible. */
1938 ocfs2_block_signals(&oldset
);
1939 did_block_signals
= 1;
1941 status
= dquot_alloc_inode(inode
);
1944 did_quota_inode
= 1;
1946 trace_ocfs2_symlink_create(dir
, dentry
, dentry
->d_name
.len
,
1947 dentry
->d_name
.name
,
1948 (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
1951 status
= ocfs2_mknod_locked(osb
, dir
, inode
,
1952 0, &new_fe_bh
, parent_fe_bh
, handle
,
1959 fe
= (struct ocfs2_dinode
*) new_fe_bh
->b_data
;
1962 inode
->i_op
= &ocfs2_symlink_inode_operations
;
1963 if (l
> ocfs2_fast_symlink_chars(sb
)) {
1966 status
= dquot_alloc_space_nodirty(inode
,
1967 ocfs2_clusters_to_bytes(osb
->sb
, 1));
1971 inode
->i_mapping
->a_ops
= &ocfs2_aops
;
1972 status
= ocfs2_add_inode_data(osb
, inode
, &offset
, 1, 0,
1974 handle
, data_ac
, NULL
,
1977 if (status
!= -ENOSPC
&& status
!= -EINTR
) {
1979 "Failed to extend file to %llu\n",
1980 (unsigned long long)newsize
);
1986 i_size_write(inode
, newsize
);
1987 inode
->i_blocks
= ocfs2_inode_sector_count(inode
);
1989 inode
->i_mapping
->a_ops
= &ocfs2_fast_symlink_aops
;
1990 memcpy((char *) fe
->id2
.i_symlink
, symname
, l
);
1991 i_size_write(inode
, newsize
);
1992 inode
->i_blocks
= 0;
1995 status
= ocfs2_mark_inode_dirty(handle
, inode
, new_fe_bh
);
2001 if (!ocfs2_inode_is_fast_symlink(inode
)) {
2002 status
= ocfs2_create_symlink_data(osb
, handle
, inode
,
2011 status
= ocfs2_init_security_set(handle
, inode
, new_fe_bh
, &si
,
2020 * Do this before adding the entry to the directory. We add
2021 * also set d_op after success so that ->d_iput() will cleanup
2022 * the dentry lock even if ocfs2_add_entry() fails below.
2024 status
= ocfs2_dentry_attach_lock(dentry
, inode
, OCFS2_I(dir
)->ip_blkno
);
2030 dl
= dentry
->d_fsdata
;
2032 status
= ocfs2_add_entry(handle
, dentry
, inode
,
2033 le64_to_cpu(fe
->i_blkno
), parent_fe_bh
,
2040 insert_inode_hash(inode
);
2041 d_instantiate(dentry
, inode
);
2043 if (status
< 0 && did_quota
)
2044 dquot_free_space_nodirty(inode
,
2045 ocfs2_clusters_to_bytes(osb
->sb
, 1));
2046 if (status
< 0 && did_quota_inode
)
2047 dquot_free_inode(inode
);
2049 ocfs2_commit_trans(osb
, handle
);
2051 ocfs2_inode_unlock(dir
, 1);
2052 if (did_block_signals
)
2053 ocfs2_unblock_signals(&oldset
);
2056 brelse(parent_fe_bh
);
2058 ocfs2_free_dir_lookup_result(&lookup
);
2060 ocfs2_free_alloc_context(inode_ac
);
2062 ocfs2_free_alloc_context(data_ac
);
2064 ocfs2_free_alloc_context(xattr_ac
);
2065 if ((status
< 0) && inode
) {
2067 ocfs2_cleanup_add_entry_failure(osb
, dentry
, inode
);
2069 OCFS2_I(inode
)->ip_flags
|= OCFS2_INODE_SKIP_ORPHAN_DIR
;
2080 static int ocfs2_blkno_stringify(u64 blkno
, char *name
)
2082 int status
, namelen
;
2084 namelen
= snprintf(name
, OCFS2_ORPHAN_NAMELEN
+ 1, "%016llx",
2094 if (namelen
!= OCFS2_ORPHAN_NAMELEN
) {
2100 trace_ocfs2_blkno_stringify(blkno
, name
, namelen
);
2109 static int ocfs2_lookup_lock_orphan_dir(struct ocfs2_super
*osb
,
2110 struct inode
**ret_orphan_dir
,
2111 struct buffer_head
**ret_orphan_dir_bh
)
2113 struct inode
*orphan_dir_inode
;
2114 struct buffer_head
*orphan_dir_bh
= NULL
;
2117 orphan_dir_inode
= ocfs2_get_system_file_inode(osb
,
2118 ORPHAN_DIR_SYSTEM_INODE
,
2120 if (!orphan_dir_inode
) {
2126 mutex_lock(&orphan_dir_inode
->i_mutex
);
2128 ret
= ocfs2_inode_lock(orphan_dir_inode
, &orphan_dir_bh
, 1);
2130 mutex_unlock(&orphan_dir_inode
->i_mutex
);
2131 iput(orphan_dir_inode
);
2137 *ret_orphan_dir
= orphan_dir_inode
;
2138 *ret_orphan_dir_bh
= orphan_dir_bh
;
2143 static int __ocfs2_prepare_orphan_dir(struct inode
*orphan_dir_inode
,
2144 struct buffer_head
*orphan_dir_bh
,
2147 struct ocfs2_dir_lookup_result
*lookup
,
2151 struct ocfs2_super
*osb
= OCFS2_SB(orphan_dir_inode
->i_sb
);
2153 (OCFS2_DIO_ORPHAN_PREFIX_LEN
+ OCFS2_ORPHAN_NAMELEN
) :
2154 OCFS2_ORPHAN_NAMELEN
;
2157 ret
= snprintf(name
, OCFS2_DIO_ORPHAN_PREFIX_LEN
+ 1, "%s",
2158 OCFS2_DIO_ORPHAN_PREFIX
);
2159 if (ret
!= OCFS2_DIO_ORPHAN_PREFIX_LEN
) {
2165 ret
= ocfs2_blkno_stringify(blkno
,
2166 name
+ OCFS2_DIO_ORPHAN_PREFIX_LEN
);
2168 ret
= ocfs2_blkno_stringify(blkno
, name
);
2174 ret
= ocfs2_prepare_dir_for_insert(osb
, orphan_dir_inode
,
2175 orphan_dir_bh
, name
,
2186 * ocfs2_prepare_orphan_dir() - Prepare an orphan directory for
2187 * insertion of an orphan.
2188 * @osb: ocfs2 file system
2189 * @ret_orphan_dir: Orphan dir inode - returned locked!
2190 * @blkno: Actual block number of the inode to be inserted into orphan dir.
2191 * @lookup: dir lookup result, to be passed back into functions like
2194 * Returns zero on success and the ret_orphan_dir, name and lookup
2195 * fields will be populated.
2197 * Returns non-zero on failure.
2199 static int ocfs2_prepare_orphan_dir(struct ocfs2_super
*osb
,
2200 struct inode
**ret_orphan_dir
,
2203 struct ocfs2_dir_lookup_result
*lookup
,
2206 struct inode
*orphan_dir_inode
= NULL
;
2207 struct buffer_head
*orphan_dir_bh
= NULL
;
2210 ret
= ocfs2_lookup_lock_orphan_dir(osb
, &orphan_dir_inode
,
2217 ret
= __ocfs2_prepare_orphan_dir(orphan_dir_inode
, orphan_dir_bh
,
2218 blkno
, name
, lookup
, dio
);
2224 *ret_orphan_dir
= orphan_dir_inode
;
2227 brelse(orphan_dir_bh
);
2230 ocfs2_inode_unlock(orphan_dir_inode
, 1);
2231 mutex_unlock(&orphan_dir_inode
->i_mutex
);
2232 iput(orphan_dir_inode
);
2240 static int ocfs2_orphan_add(struct ocfs2_super
*osb
,
2242 struct inode
*inode
,
2243 struct buffer_head
*fe_bh
,
2245 struct ocfs2_dir_lookup_result
*lookup
,
2246 struct inode
*orphan_dir_inode
,
2249 struct buffer_head
*orphan_dir_bh
= NULL
;
2251 struct ocfs2_dinode
*orphan_fe
;
2252 struct ocfs2_dinode
*fe
= (struct ocfs2_dinode
*) fe_bh
->b_data
;
2254 (OCFS2_DIO_ORPHAN_PREFIX_LEN
+ OCFS2_ORPHAN_NAMELEN
) :
2255 OCFS2_ORPHAN_NAMELEN
;
2257 trace_ocfs2_orphan_add_begin(
2258 (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
2260 status
= ocfs2_read_inode_block(orphan_dir_inode
, &orphan_dir_bh
);
2266 status
= ocfs2_journal_access_di(handle
,
2267 INODE_CACHE(orphan_dir_inode
),
2269 OCFS2_JOURNAL_ACCESS_WRITE
);
2276 * We're going to journal the change of i_flags and i_orphaned_slot.
2277 * It's safe anyway, though some callers may duplicate the journaling.
2278 * Journaling within the func just make the logic look more
2281 status
= ocfs2_journal_access_di(handle
,
2284 OCFS2_JOURNAL_ACCESS_WRITE
);
2290 /* we're a cluster, and nlink can change on disk from
2291 * underneath us... */
2292 orphan_fe
= (struct ocfs2_dinode
*) orphan_dir_bh
->b_data
;
2293 if (S_ISDIR(inode
->i_mode
))
2294 ocfs2_add_links_count(orphan_fe
, 1);
2295 set_nlink(orphan_dir_inode
, ocfs2_read_links_count(orphan_fe
));
2296 ocfs2_journal_dirty(handle
, orphan_dir_bh
);
2298 status
= __ocfs2_add_entry(handle
, orphan_dir_inode
, name
,
2300 OCFS2_I(inode
)->ip_blkno
,
2301 orphan_dir_bh
, lookup
);
2308 /* Update flag OCFS2_DIO_ORPHANED_FL and record the orphan
2311 fe
->i_flags
|= cpu_to_le32(OCFS2_DIO_ORPHANED_FL
);
2312 fe
->i_dio_orphaned_slot
= cpu_to_le16(osb
->slot_num
);
2314 fe
->i_flags
|= cpu_to_le32(OCFS2_ORPHANED_FL
);
2315 OCFS2_I(inode
)->ip_flags
&= ~OCFS2_INODE_SKIP_ORPHAN_DIR
;
2317 /* Record which orphan dir our inode now resides
2318 * in. delete_inode will use this to determine which orphan
2320 fe
->i_orphaned_slot
= cpu_to_le16(osb
->slot_num
);
2323 ocfs2_journal_dirty(handle
, fe_bh
);
2325 trace_ocfs2_orphan_add_end((unsigned long long)OCFS2_I(inode
)->ip_blkno
,
2330 if (S_ISDIR(inode
->i_mode
))
2331 ocfs2_add_links_count(orphan_fe
, -1);
2332 set_nlink(orphan_dir_inode
, ocfs2_read_links_count(orphan_fe
));
2336 brelse(orphan_dir_bh
);
2341 /* unlike orphan_add, we expect the orphan dir to already be locked here. */
2342 int ocfs2_orphan_del(struct ocfs2_super
*osb
,
2344 struct inode
*orphan_dir_inode
,
2345 struct inode
*inode
,
2346 struct buffer_head
*orphan_dir_bh
,
2349 const int namelen
= OCFS2_DIO_ORPHAN_PREFIX_LEN
+ OCFS2_ORPHAN_NAMELEN
;
2350 char name
[namelen
+ 1];
2351 struct ocfs2_dinode
*orphan_fe
;
2353 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
2356 status
= snprintf(name
, OCFS2_DIO_ORPHAN_PREFIX_LEN
+ 1, "%s",
2357 OCFS2_DIO_ORPHAN_PREFIX
);
2358 if (status
!= OCFS2_DIO_ORPHAN_PREFIX_LEN
) {
2364 status
= ocfs2_blkno_stringify(OCFS2_I(inode
)->ip_blkno
,
2365 name
+ OCFS2_DIO_ORPHAN_PREFIX_LEN
);
2367 status
= ocfs2_blkno_stringify(OCFS2_I(inode
)->ip_blkno
, name
);
2373 trace_ocfs2_orphan_del(
2374 (unsigned long long)OCFS2_I(orphan_dir_inode
)->ip_blkno
,
2375 name
, strlen(name
));
2377 /* find it's spot in the orphan directory */
2378 status
= ocfs2_find_entry(name
, strlen(name
), orphan_dir_inode
,
2385 /* remove it from the orphan directory */
2386 status
= ocfs2_delete_entry(handle
, orphan_dir_inode
, &lookup
);
2392 status
= ocfs2_journal_access_di(handle
,
2393 INODE_CACHE(orphan_dir_inode
),
2395 OCFS2_JOURNAL_ACCESS_WRITE
);
2401 /* do the i_nlink dance! :) */
2402 orphan_fe
= (struct ocfs2_dinode
*) orphan_dir_bh
->b_data
;
2403 if (S_ISDIR(inode
->i_mode
))
2404 ocfs2_add_links_count(orphan_fe
, -1);
2405 set_nlink(orphan_dir_inode
, ocfs2_read_links_count(orphan_fe
));
2406 ocfs2_journal_dirty(handle
, orphan_dir_bh
);
2409 ocfs2_free_dir_lookup_result(&lookup
);
2417 * ocfs2_prep_new_orphaned_file() - Prepare the orphan dir to receive a newly
2418 * allocated file. This is different from the typical 'add to orphan dir'
2419 * operation in that the inode does not yet exist. This is a problem because
2420 * the orphan dir stringifies the inode block number to come up with it's
2421 * dirent. Obviously if the inode does not yet exist we have a chicken and egg
2422 * problem. This function works around it by calling deeper into the orphan
2423 * and suballoc code than other callers. Use this only by necessity.
2424 * @dir: The directory which this inode will ultimately wind up under - not the
2426 * @dir_bh: buffer_head the @dir inode block
2427 * @orphan_name: string of length (CFS2_ORPHAN_NAMELEN + 1). Will be filled
2428 * with the string to be used for orphan dirent. Pass back to the orphan dir
2430 * @ret_orphan_dir: orphan dir inode returned to be passed back into orphan
2432 * @ret_di_blkno: block number where the new inode will be allocated.
2433 * @orphan_insert: Dir insert context to be passed back into orphan dir code.
2434 * @ret_inode_ac: Inode alloc context to be passed back to the allocator.
2436 * Returns zero on success and the ret_orphan_dir, name and lookup
2437 * fields will be populated.
2439 * Returns non-zero on failure.
2441 static int ocfs2_prep_new_orphaned_file(struct inode
*dir
,
2442 struct buffer_head
*dir_bh
,
2444 struct inode
**ret_orphan_dir
,
2446 struct ocfs2_dir_lookup_result
*orphan_insert
,
2447 struct ocfs2_alloc_context
**ret_inode_ac
)
2451 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
2452 struct inode
*orphan_dir
= NULL
;
2453 struct buffer_head
*orphan_dir_bh
= NULL
;
2454 struct ocfs2_alloc_context
*inode_ac
= NULL
;
2456 ret
= ocfs2_lookup_lock_orphan_dir(osb
, &orphan_dir
, &orphan_dir_bh
);
2462 /* reserve an inode spot */
2463 ret
= ocfs2_reserve_new_inode(osb
, &inode_ac
);
2470 ret
= ocfs2_find_new_inode_loc(dir
, dir_bh
, inode_ac
,
2477 ret
= __ocfs2_prepare_orphan_dir(orphan_dir
, orphan_dir_bh
,
2478 di_blkno
, orphan_name
, orphan_insert
,
2487 *ret_orphan_dir
= orphan_dir
;
2488 *ret_di_blkno
= di_blkno
;
2489 *ret_inode_ac
= inode_ac
;
2491 * orphan_name and orphan_insert are already up to
2492 * date via prepare_orphan_dir
2495 /* Unroll reserve_new_inode* */
2497 ocfs2_free_alloc_context(inode_ac
);
2499 /* Unroll orphan dir locking */
2500 mutex_unlock(&orphan_dir
->i_mutex
);
2501 ocfs2_inode_unlock(orphan_dir
, 1);
2505 brelse(orphan_dir_bh
);
2510 int ocfs2_create_inode_in_orphan(struct inode
*dir
,
2512 struct inode
**new_inode
)
2514 int status
, did_quota_inode
= 0;
2515 struct inode
*inode
= NULL
;
2516 struct inode
*orphan_dir
= NULL
;
2517 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
2518 struct ocfs2_dinode
*di
= NULL
;
2519 handle_t
*handle
= NULL
;
2520 char orphan_name
[OCFS2_ORPHAN_NAMELEN
+ 1];
2521 struct buffer_head
*parent_di_bh
= NULL
;
2522 struct buffer_head
*new_di_bh
= NULL
;
2523 struct ocfs2_alloc_context
*inode_ac
= NULL
;
2524 struct ocfs2_dir_lookup_result orphan_insert
= { NULL
, };
2525 u64
uninitialized_var(di_blkno
), suballoc_loc
;
2528 status
= ocfs2_inode_lock(dir
, &parent_di_bh
, 1);
2530 if (status
!= -ENOENT
)
2535 status
= ocfs2_prep_new_orphaned_file(dir
, parent_di_bh
,
2536 orphan_name
, &orphan_dir
,
2537 &di_blkno
, &orphan_insert
, &inode_ac
);
2539 if (status
!= -ENOSPC
)
2544 inode
= ocfs2_get_init_inode(dir
, mode
);
2545 if (IS_ERR(inode
)) {
2546 status
= PTR_ERR(inode
);
2552 handle
= ocfs2_start_trans(osb
, ocfs2_mknod_credits(osb
->sb
, 0, 0));
2553 if (IS_ERR(handle
)) {
2554 status
= PTR_ERR(handle
);
2560 status
= dquot_alloc_inode(inode
);
2563 did_quota_inode
= 1;
2565 status
= ocfs2_claim_new_inode_at_loc(handle
, dir
, inode_ac
,
2567 &suballoc_bit
, di_blkno
);
2574 /* do the real work now. */
2575 status
= __ocfs2_mknod_locked(dir
, inode
,
2576 0, &new_di_bh
, parent_di_bh
, handle
,
2577 inode_ac
, di_blkno
, suballoc_loc
,
2584 di
= (struct ocfs2_dinode
*)new_di_bh
->b_data
;
2585 status
= ocfs2_orphan_add(osb
, handle
, inode
, new_di_bh
, orphan_name
,
2586 &orphan_insert
, orphan_dir
, false);
2592 /* get open lock so that only nodes can't remove it from orphan dir. */
2593 status
= ocfs2_open_lock(inode
);
2597 insert_inode_hash(inode
);
2599 if (status
< 0 && did_quota_inode
)
2600 dquot_free_inode(inode
);
2602 ocfs2_commit_trans(osb
, handle
);
2605 /* This was locked for us in ocfs2_prepare_orphan_dir() */
2606 ocfs2_inode_unlock(orphan_dir
, 1);
2607 mutex_unlock(&orphan_dir
->i_mutex
);
2611 if ((status
< 0) && inode
) {
2617 ocfs2_free_alloc_context(inode_ac
);
2624 ocfs2_free_dir_lookup_result(&orphan_insert
);
2626 ocfs2_inode_unlock(dir
, 1);
2627 brelse(parent_di_bh
);
2631 int ocfs2_add_inode_to_orphan(struct ocfs2_super
*osb
,
2632 struct inode
*inode
)
2634 char orphan_name
[OCFS2_DIO_ORPHAN_PREFIX_LEN
+ OCFS2_ORPHAN_NAMELEN
+ 1];
2635 struct inode
*orphan_dir_inode
= NULL
;
2636 struct ocfs2_dir_lookup_result orphan_insert
= { NULL
, };
2637 struct buffer_head
*di_bh
= NULL
;
2639 handle_t
*handle
= NULL
;
2640 struct ocfs2_dinode
*di
= NULL
;
2642 status
= ocfs2_inode_lock(inode
, &di_bh
, 1);
2648 di
= (struct ocfs2_dinode
*) di_bh
->b_data
;
2650 * Another append dio crashed?
2651 * If so, manually recover it first.
2653 if (unlikely(di
->i_flags
& cpu_to_le32(OCFS2_DIO_ORPHANED_FL
))) {
2654 status
= ocfs2_truncate_file(inode
, di_bh
, i_size_read(inode
));
2656 if (status
!= -ENOSPC
)
2658 goto bail_unlock_inode
;
2661 status
= ocfs2_del_inode_from_orphan(osb
, inode
, di_bh
, 0, 0);
2664 goto bail_unlock_inode
;
2668 status
= ocfs2_prepare_orphan_dir(osb
, &orphan_dir_inode
,
2669 OCFS2_I(inode
)->ip_blkno
,
2675 goto bail_unlock_inode
;
2678 handle
= ocfs2_start_trans(osb
,
2679 OCFS2_INODE_ADD_TO_ORPHAN_CREDITS
);
2680 if (IS_ERR(handle
)) {
2681 status
= PTR_ERR(handle
);
2682 goto bail_unlock_orphan
;
2685 status
= ocfs2_orphan_add(osb
, handle
, inode
, di_bh
, orphan_name
,
2686 &orphan_insert
, orphan_dir_inode
, true);
2690 ocfs2_commit_trans(osb
, handle
);
2693 ocfs2_inode_unlock(orphan_dir_inode
, 1);
2694 mutex_unlock(&orphan_dir_inode
->i_mutex
);
2695 iput(orphan_dir_inode
);
2697 ocfs2_free_dir_lookup_result(&orphan_insert
);
2700 ocfs2_inode_unlock(inode
, 1);
2707 int ocfs2_del_inode_from_orphan(struct ocfs2_super
*osb
,
2708 struct inode
*inode
, struct buffer_head
*di_bh
,
2709 int update_isize
, loff_t end
)
2711 struct inode
*orphan_dir_inode
= NULL
;
2712 struct buffer_head
*orphan_dir_bh
= NULL
;
2713 struct ocfs2_dinode
*di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
2714 handle_t
*handle
= NULL
;
2717 orphan_dir_inode
= ocfs2_get_system_file_inode(osb
,
2718 ORPHAN_DIR_SYSTEM_INODE
,
2719 le16_to_cpu(di
->i_dio_orphaned_slot
));
2720 if (!orphan_dir_inode
) {
2726 mutex_lock(&orphan_dir_inode
->i_mutex
);
2727 status
= ocfs2_inode_lock(orphan_dir_inode
, &orphan_dir_bh
, 1);
2729 mutex_unlock(&orphan_dir_inode
->i_mutex
);
2730 iput(orphan_dir_inode
);
2735 handle
= ocfs2_start_trans(osb
,
2736 OCFS2_INODE_DEL_FROM_ORPHAN_CREDITS
);
2737 if (IS_ERR(handle
)) {
2738 status
= PTR_ERR(handle
);
2739 goto bail_unlock_orphan
;
2742 BUG_ON(!(di
->i_flags
& cpu_to_le32(OCFS2_DIO_ORPHANED_FL
)));
2744 status
= ocfs2_orphan_del(osb
, handle
, orphan_dir_inode
,
2745 inode
, orphan_dir_bh
, true);
2751 status
= ocfs2_journal_access_di(handle
,
2754 OCFS2_JOURNAL_ACCESS_WRITE
);
2760 di
->i_flags
&= ~cpu_to_le32(OCFS2_DIO_ORPHANED_FL
);
2761 di
->i_dio_orphaned_slot
= 0;
2764 status
= ocfs2_set_inode_size(handle
, inode
, di_bh
, end
);
2768 ocfs2_journal_dirty(handle
, di_bh
);
2771 ocfs2_commit_trans(osb
, handle
);
2774 ocfs2_inode_unlock(orphan_dir_inode
, 1);
2775 mutex_unlock(&orphan_dir_inode
->i_mutex
);
2776 brelse(orphan_dir_bh
);
2777 iput(orphan_dir_inode
);
2783 int ocfs2_mv_orphaned_inode_to_new(struct inode
*dir
,
2784 struct inode
*inode
,
2785 struct dentry
*dentry
)
2788 struct buffer_head
*parent_di_bh
= NULL
;
2789 handle_t
*handle
= NULL
;
2790 struct ocfs2_super
*osb
= OCFS2_SB(dir
->i_sb
);
2791 struct ocfs2_dinode
*dir_di
, *di
;
2792 struct inode
*orphan_dir_inode
= NULL
;
2793 struct buffer_head
*orphan_dir_bh
= NULL
;
2794 struct buffer_head
*di_bh
= NULL
;
2795 struct ocfs2_dir_lookup_result lookup
= { NULL
, };
2797 trace_ocfs2_mv_orphaned_inode_to_new(dir
, dentry
,
2798 dentry
->d_name
.len
, dentry
->d_name
.name
,
2799 (unsigned long long)OCFS2_I(dir
)->ip_blkno
,
2800 (unsigned long long)OCFS2_I(inode
)->ip_blkno
);
2802 status
= ocfs2_inode_lock(dir
, &parent_di_bh
, 1);
2804 if (status
!= -ENOENT
)
2809 dir_di
= (struct ocfs2_dinode
*) parent_di_bh
->b_data
;
2810 if (!dir_di
->i_links_count
) {
2811 /* can't make a file in a deleted directory. */
2816 status
= ocfs2_check_dir_for_entry(dir
, dentry
->d_name
.name
,
2817 dentry
->d_name
.len
);
2821 /* get a spot inside the dir. */
2822 status
= ocfs2_prepare_dir_for_insert(osb
, dir
, parent_di_bh
,
2823 dentry
->d_name
.name
,
2824 dentry
->d_name
.len
, &lookup
);
2830 orphan_dir_inode
= ocfs2_get_system_file_inode(osb
,
2831 ORPHAN_DIR_SYSTEM_INODE
,
2833 if (!orphan_dir_inode
) {
2839 mutex_lock(&orphan_dir_inode
->i_mutex
);
2841 status
= ocfs2_inode_lock(orphan_dir_inode
, &orphan_dir_bh
, 1);
2844 mutex_unlock(&orphan_dir_inode
->i_mutex
);
2845 iput(orphan_dir_inode
);
2849 status
= ocfs2_read_inode_block(inode
, &di_bh
);
2855 handle
= ocfs2_start_trans(osb
, ocfs2_rename_credits(osb
->sb
));
2856 if (IS_ERR(handle
)) {
2857 status
= PTR_ERR(handle
);
2863 status
= ocfs2_journal_access_di(handle
, INODE_CACHE(inode
),
2864 di_bh
, OCFS2_JOURNAL_ACCESS_WRITE
);
2870 status
= ocfs2_orphan_del(osb
, handle
, orphan_dir_inode
, inode
,
2871 orphan_dir_bh
, false);
2877 di
= (struct ocfs2_dinode
*)di_bh
->b_data
;
2878 di
->i_flags
&= ~cpu_to_le32(OCFS2_ORPHANED_FL
);
2879 di
->i_orphaned_slot
= 0;
2880 set_nlink(inode
, 1);
2881 ocfs2_set_links_count(di
, inode
->i_nlink
);
2882 ocfs2_update_inode_fsync_trans(handle
, inode
, 1);
2883 ocfs2_journal_dirty(handle
, di_bh
);
2885 status
= ocfs2_add_entry(handle
, dentry
, inode
,
2886 OCFS2_I(inode
)->ip_blkno
, parent_di_bh
,
2893 status
= ocfs2_dentry_attach_lock(dentry
, inode
,
2894 OCFS2_I(dir
)->ip_blkno
);
2900 d_instantiate(dentry
, inode
);
2903 ocfs2_commit_trans(osb
, handle
);
2905 ocfs2_inode_unlock(orphan_dir_inode
, 1);
2906 mutex_unlock(&orphan_dir_inode
->i_mutex
);
2907 iput(orphan_dir_inode
);
2910 ocfs2_inode_unlock(dir
, 1);
2913 brelse(parent_di_bh
);
2914 brelse(orphan_dir_bh
);
2916 ocfs2_free_dir_lookup_result(&lookup
);
2924 const struct inode_operations ocfs2_dir_iops
= {
2925 .create
= ocfs2_create
,
2926 .lookup
= ocfs2_lookup
,
2928 .unlink
= ocfs2_unlink
,
2929 .rmdir
= ocfs2_unlink
,
2930 .symlink
= ocfs2_symlink
,
2931 .mkdir
= ocfs2_mkdir
,
2932 .mknod
= ocfs2_mknod
,
2933 .rename
= ocfs2_rename
,
2934 .setattr
= ocfs2_setattr
,
2935 .getattr
= ocfs2_getattr
,
2936 .permission
= ocfs2_permission
,
2937 .setxattr
= generic_setxattr
,
2938 .getxattr
= generic_getxattr
,
2939 .listxattr
= ocfs2_listxattr
,
2940 .removexattr
= generic_removexattr
,
2941 .fiemap
= ocfs2_fiemap
,
2942 .get_acl
= ocfs2_iop_get_acl
,
2943 .set_acl
= ocfs2_iop_set_acl
,