2 * Copyright (c) 2000-2003 Silicon Graphics, Inc. All Rights Reserved.
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of version 2 of the GNU General Public License as
6 * published by the Free Software Foundation.
8 * This program is distributed in the hope that it would be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12 * Further, this software is distributed without any warranty that it is
13 * free of the rightful claim of any third person regarding infringement
14 * or the like. Any license provided herein, whether implied or
15 * otherwise, applies only to this software file. Patent licenses, if
16 * any, provided herein do not apply to combinations of this program with
17 * other software, or any other product whatsoever.
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, write the Free Software Foundation, Inc., 59
21 * Temple Place - Suite 330, Boston MA 02111-1307, USA.
23 * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
24 * Mountain View, CA 94043, or:
28 * For further information regarding this notice, see:
30 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
34 #include "xfs_types.h"
37 #include "xfs_trans.h"
41 #include "xfs_dmapi.h"
42 #include "xfs_mount.h"
43 #include "xfs_da_btree.h"
44 #include "xfs_bmap_btree.h"
45 #include "xfs_dir_sf.h"
46 #include "xfs_dir2_sf.h"
47 #include "xfs_attr_sf.h"
48 #include "xfs_dinode.h"
49 #include "xfs_inode.h"
50 #include "xfs_inode_item.h"
52 #include "xfs_error.h"
53 #include "xfs_quota.h"
54 #include "xfs_refcache.h"
55 #include "xfs_utils.h"
56 #include "xfs_trans_space.h"
57 #include "xfs_dir_leaf.h"
61 * Given an array of up to 4 inode pointers, unlock the pointed to inodes.
62 * If there are fewer than 4 entries in the array, the empty entries will
63 * be at the end and will have NULL pointers in them.
72 xfs_iunlock(i_tab
[0], lock_mode
);
73 for (i
= 1; i
< 4; i
++) {
74 if (i_tab
[i
] == NULL
) {
78 * Watch out for duplicate entries in the table.
80 if (i_tab
[i
] != i_tab
[i
-1]) {
81 xfs_iunlock(i_tab
[i
], lock_mode
);
87 int xfs_rename_skip
, xfs_rename_nskip
;
91 * The following routine will acquire the locks required for a rename
92 * operation. The code understands the semantics of renames and will
93 * validate that name1 exists under dp1 & that name2 may or may not
96 * We are renaming dp1/name1 to dp2/name2.
98 * Return ENOENT if dp1 does not exist, other lookup errors, or 0 for success.
102 xfs_inode_t
*dp1
, /* old (source) directory inode */
103 xfs_inode_t
*dp2
, /* new (target) directory inode */
104 vname_t
*vname1
,/* old entry name */
105 vname_t
*vname2
,/* new entry name */
106 xfs_inode_t
**ipp1
, /* inode of old entry */
107 xfs_inode_t
**ipp2
, /* inode of new entry, if it
108 already exists, NULL otherwise. */
109 xfs_inode_t
**i_tab
,/* array of inode returned, sorted */
110 int *num_inodes
) /* number of inodes in array */
112 xfs_inode_t
*ip1
, *ip2
, *temp
;
113 xfs_ino_t inum1
, inum2
;
117 int diff_dirs
= (dp1
!= dp2
);
122 * First, find out the current inums of the entries so that we
123 * can determine the initial locking order. We'll have to
124 * sanity check stuff after all the locks have been acquired
125 * to see if we still have the right inodes, directories, etc.
127 lock_mode
= xfs_ilock_map_shared(dp1
);
128 error
= xfs_get_dir_entry(vname1
, &ip1
);
130 xfs_iunlock_map_shared(dp1
, lock_mode
);
140 * Unlock dp1 and lock dp2 if they are different.
144 xfs_iunlock_map_shared(dp1
, lock_mode
);
145 lock_mode
= xfs_ilock_map_shared(dp2
);
148 error
= xfs_dir_lookup_int(XFS_ITOBHV(dp2
), lock_mode
,
149 vname2
, &inum2
, &ip2
);
150 if (error
== ENOENT
) { /* target does not need to exist. */
154 * If dp2 and dp1 are the same, the next line unlocks dp1.
157 xfs_iunlock_map_shared(dp2
, lock_mode
);
165 * i_tab contains a list of pointers to inodes. We initialize
166 * the table here & we'll sort it. We will then use it to
167 * order the acquisition of the inode locks.
169 * Note that the table may contain duplicates. e.g., dp1 == dp2.
183 * Sort the elements via bubble sort. (Remember, there are at
184 * most 4 elements to sort, so this is adequate.)
186 for (i
=0; i
< *num_inodes
; i
++) {
187 for (j
=1; j
< *num_inodes
; j
++) {
188 if (i_tab
[j
]->i_ino
< i_tab
[j
-1]->i_ino
) {
190 i_tab
[j
] = i_tab
[j
-1];
197 * We have dp2 locked. If it isn't first, unlock it.
198 * If it is first, tell xfs_lock_inodes so it can skip it
199 * when locking. if dp1 == dp2, xfs_lock_inodes will skip both
200 * since they are equal. xfs_lock_inodes needs all these inodes
201 * so that it can unlock and retry if there might be a dead-lock
202 * potential with the log.
205 if (i_tab
[0] == dp2
&& lock_mode
== XFS_ILOCK_SHARED
) {
209 xfs_lock_inodes(i_tab
, *num_inodes
, 1, XFS_ILOCK_SHARED
);
214 xfs_iunlock_map_shared(dp2
, lock_mode
);
215 xfs_lock_inodes(i_tab
, *num_inodes
, 0, XFS_ILOCK_SHARED
);
219 * Set the return value. Null out any unused entries in i_tab.
221 *ipp1
= *ipp2
= NULL
;
222 for (i
=0; i
< *num_inodes
; i
++) {
223 if (i_tab
[i
]->i_ino
== inum1
) {
226 if (i_tab
[i
]->i_ino
== inum2
) {
241 bhv_desc_t
*src_dir_bdp
,
243 vnode_t
*target_dir_vp
,
244 vname_t
*target_vname
,
248 xfs_inode_t
*src_dp
, *target_dp
, *src_ip
, *target_ip
;
250 int new_parent
; /* moving to a new dir */
251 int src_is_directory
; /* src_name is a directory */
253 xfs_bmap_free_t free_list
;
254 xfs_fsblock_t first_block
;
257 xfs_inode_t
*inodes
[4];
258 int target_ip_dropped
= 0; /* dropped target_ip link? */
260 bhv_desc_t
*target_dir_bdp
;
262 int target_link_zero
= 0;
264 char *src_name
= VNAME(src_vname
);
265 char *target_name
= VNAME(target_vname
);
266 int src_namelen
= VNAMELEN(src_vname
);
267 int target_namelen
= VNAMELEN(target_vname
);
269 src_dir_vp
= BHV_TO_VNODE(src_dir_bdp
);
270 vn_trace_entry(src_dir_vp
, "xfs_rename", (inst_t
*)__return_address
);
271 vn_trace_entry(target_dir_vp
, "xfs_rename", (inst_t
*)__return_address
);
274 * Find the XFS behavior descriptor for the target directory
275 * vnode since it was not handed to us.
277 target_dir_bdp
= vn_bhv_lookup_unlocked(VN_BHV_HEAD(target_dir_vp
),
279 if (target_dir_bdp
== NULL
) {
280 return XFS_ERROR(EXDEV
);
283 src_dp
= XFS_BHVTOI(src_dir_bdp
);
284 target_dp
= XFS_BHVTOI(target_dir_bdp
);
285 mp
= src_dp
->i_mount
;
287 if (DM_EVENT_ENABLED(src_dir_vp
->v_vfsp
, src_dp
, DM_EVENT_RENAME
) ||
288 DM_EVENT_ENABLED(target_dir_vp
->v_vfsp
,
289 target_dp
, DM_EVENT_RENAME
)) {
290 error
= XFS_SEND_NAMESP(mp
, DM_EVENT_RENAME
,
291 src_dir_vp
, DM_RIGHT_NULL
,
292 target_dir_vp
, DM_RIGHT_NULL
,
293 src_name
, target_name
,
299 /* Return through std_return after this point. */
302 * Lock all the participating inodes. Depending upon whether
303 * the target_name exists in the target directory, and
304 * whether the target directory is the same as the source
305 * directory, we can lock from 2 to 4 inodes.
306 * xfs_lock_for_rename() will return ENOENT if src_name
307 * does not exist in the source directory.
310 error
= xfs_lock_for_rename(src_dp
, target_dp
, src_vname
,
311 target_vname
, &src_ip
, &target_ip
, inodes
,
316 * We have nothing locked, no inode references, and
317 * no transaction, so just get out.
322 ASSERT(src_ip
!= NULL
);
324 if ((src_ip
->i_d
.di_mode
& S_IFMT
) == S_IFDIR
) {
326 * Check for link count overflow on target_dp
328 if (target_ip
== NULL
&& (src_dp
!= target_dp
) &&
329 target_dp
->i_d
.di_nlink
>= XFS_MAXLINK
) {
330 error
= XFS_ERROR(EMLINK
);
331 xfs_rename_unlock4(inodes
, XFS_ILOCK_SHARED
);
336 new_parent
= (src_dp
!= target_dp
);
337 src_is_directory
= ((src_ip
->i_d
.di_mode
& S_IFMT
) == S_IFDIR
);
340 * Drop the locks on our inodes so that we can start the transaction.
342 xfs_rename_unlock4(inodes
, XFS_ILOCK_SHARED
);
344 XFS_BMAP_INIT(&free_list
, &first_block
);
345 tp
= xfs_trans_alloc(mp
, XFS_TRANS_RENAME
);
346 cancel_flags
= XFS_TRANS_RELEASE_LOG_RES
;
347 spaceres
= XFS_RENAME_SPACE_RES(mp
, target_namelen
);
348 error
= xfs_trans_reserve(tp
, spaceres
, XFS_RENAME_LOG_RES(mp
), 0,
349 XFS_TRANS_PERM_LOG_RES
, XFS_RENAME_LOG_COUNT
);
350 if (error
== ENOSPC
) {
352 error
= xfs_trans_reserve(tp
, 0, XFS_RENAME_LOG_RES(mp
), 0,
353 XFS_TRANS_PERM_LOG_RES
, XFS_RENAME_LOG_COUNT
);
356 xfs_trans_cancel(tp
, 0);
361 * Attach the dquots to the inodes
363 if ((error
= XFS_QM_DQVOPRENAME(mp
, inodes
))) {
364 xfs_trans_cancel(tp
, cancel_flags
);
369 * Reacquire the inode locks we dropped above.
371 xfs_lock_inodes(inodes
, num_inodes
, 0, XFS_ILOCK_EXCL
);
374 * Join all the inodes to the transaction. From this point on,
375 * we can rely on either trans_commit or trans_cancel to unlock
376 * them. Note that we need to add a vnode reference to the
377 * directories since trans_commit & trans_cancel will decrement
378 * them when they unlock the inodes. Also, we need to be careful
379 * not to add an inode to the transaction more than once.
382 xfs_trans_ijoin(tp
, src_dp
, XFS_ILOCK_EXCL
);
384 VN_HOLD(target_dir_vp
);
385 xfs_trans_ijoin(tp
, target_dp
, XFS_ILOCK_EXCL
);
387 if ((src_ip
!= src_dp
) && (src_ip
!= target_dp
)) {
388 xfs_trans_ijoin(tp
, src_ip
, XFS_ILOCK_EXCL
);
390 if ((target_ip
!= NULL
) &&
391 (target_ip
!= src_ip
) &&
392 (target_ip
!= src_dp
) &&
393 (target_ip
!= target_dp
)) {
394 xfs_trans_ijoin(tp
, target_ip
, XFS_ILOCK_EXCL
);
400 if (target_ip
== NULL
) {
402 * If there's no space reservation, check the entry will
403 * fit before actually inserting it.
406 (error
= XFS_DIR_CANENTER(mp
, tp
, target_dp
, target_name
,
411 * If target does not exist and the rename crosses
412 * directories, adjust the target directory link count
413 * to account for the ".." reference from the new entry.
415 error
= XFS_DIR_CREATENAME(mp
, tp
, target_dp
, target_name
,
416 target_namelen
, src_ip
->i_ino
,
417 &first_block
, &free_list
, spaceres
);
418 if (error
== ENOSPC
) {
424 xfs_ichgtime(target_dp
, XFS_ICHGTIME_MOD
| XFS_ICHGTIME_CHG
);
426 if (new_parent
&& src_is_directory
) {
427 error
= xfs_bumplink(tp
, target_dp
);
432 } else { /* target_ip != NULL */
435 * If target exists and it's a directory, check that both
436 * target and source are directories and that target can be
437 * destroyed, or that neither is a directory.
439 if ((target_ip
->i_d
.di_mode
& S_IFMT
) == S_IFDIR
) {
441 * Make sure target dir is empty.
443 if (!(XFS_DIR_ISEMPTY(target_ip
->i_mount
, target_ip
)) ||
444 (target_ip
->i_d
.di_nlink
> 2)) {
445 error
= XFS_ERROR(EEXIST
);
451 * Link the source inode under the target name.
452 * If the source inode is a directory and we are moving
453 * it across directories, its ".." entry will be
454 * inconsistent until we replace that down below.
456 * In case there is already an entry with the same
457 * name at the destination directory, remove it first.
459 error
= XFS_DIR_REPLACE(mp
, tp
, target_dp
, target_name
,
460 target_namelen
, src_ip
->i_ino
, &first_block
,
461 &free_list
, spaceres
);
465 xfs_ichgtime(target_dp
, XFS_ICHGTIME_MOD
| XFS_ICHGTIME_CHG
);
468 * Decrement the link count on the target since the target
469 * dir no longer points to it.
471 error
= xfs_droplink(tp
, target_ip
);
475 target_ip_dropped
= 1;
477 if (src_is_directory
) {
479 * Drop the link from the old "." entry.
481 error
= xfs_droplink(tp
, target_ip
);
487 /* Do this test while we still hold the locks */
488 target_link_zero
= (target_ip
)->i_d
.di_nlink
==0;
490 } /* target_ip != NULL */
495 if (new_parent
&& src_is_directory
) {
498 * Rewrite the ".." entry to point to the new
501 error
= XFS_DIR_REPLACE(mp
, tp
, src_ip
, "..", 2,
502 target_dp
->i_ino
, &first_block
,
503 &free_list
, spaceres
);
504 ASSERT(error
!= EEXIST
);
508 xfs_ichgtime(src_ip
, XFS_ICHGTIME_MOD
| XFS_ICHGTIME_CHG
);
512 * We always want to hit the ctime on the source inode.
513 * We do it in the if clause above for the 'new_parent &&
514 * src_is_directory' case, and here we get all the other
515 * cases. This isn't strictly required by the standards
516 * since the source inode isn't really being changed,
517 * but old unix file systems did it and some incremental
518 * backup programs won't work without it.
520 xfs_ichgtime(src_ip
, XFS_ICHGTIME_CHG
);
524 * Adjust the link count on src_dp. This is necessary when
525 * renaming a directory, either within one parent when
526 * the target existed, or across two parent directories.
528 if (src_is_directory
&& (new_parent
|| target_ip
!= NULL
)) {
531 * Decrement link count on src_directory since the
532 * entry that's moved no longer points to it.
534 error
= xfs_droplink(tp
, src_dp
);
540 error
= XFS_DIR_REMOVENAME(mp
, tp
, src_dp
, src_name
, src_namelen
,
541 src_ip
->i_ino
, &first_block
, &free_list
, spaceres
);
545 xfs_ichgtime(src_dp
, XFS_ICHGTIME_MOD
| XFS_ICHGTIME_CHG
);
548 * Update the generation counts on all the directory inodes
549 * that we're modifying.
552 xfs_trans_log_inode(tp
, src_dp
, XFS_ILOG_CORE
);
556 xfs_trans_log_inode(tp
, target_dp
, XFS_ILOG_CORE
);
560 * If there was a target inode, take an extra reference on
561 * it here so that it doesn't go to xfs_inactive() from
564 if (target_ip
!= NULL
) {
569 * If this is a synchronous mount, make sure that the
570 * rename transaction goes to disk before returning to
573 if (mp
->m_flags
& (XFS_MOUNT_WSYNC
|XFS_MOUNT_DIRSYNC
)) {
574 xfs_trans_set_sync(tp
);
578 * Take refs. for vop_link_removed calls below. No need to worry
579 * about directory refs. because the caller holds them.
581 * Do holds before the xfs_bmap_finish since it might rele them down
585 if (target_ip_dropped
)
589 error
= xfs_bmap_finish(&tp
, &free_list
, first_block
, &committed
);
591 xfs_bmap_cancel(&free_list
);
592 xfs_trans_cancel(tp
, (XFS_TRANS_RELEASE_LOG_RES
|
594 if (target_ip
!= NULL
) {
597 if (target_ip_dropped
) {
605 * trans_commit will unlock src_ip, target_ip & decrement
606 * the vnode references.
608 error
= xfs_trans_commit(tp
, XFS_TRANS_RELEASE_LOG_RES
, NULL
);
609 if (target_ip
!= NULL
) {
610 xfs_refcache_purge_ip(target_ip
);
614 * Let interposed file systems know about removed links.
616 if (target_ip_dropped
) {
617 VOP_LINK_REMOVED(XFS_ITOV(target_ip
), target_dir_vp
,
624 /* Fall through to std_return with error = 0 or errno from
625 * xfs_trans_commit */
627 if (DM_EVENT_ENABLED(src_dir_vp
->v_vfsp
, src_dp
, DM_EVENT_POSTRENAME
) ||
628 DM_EVENT_ENABLED(target_dir_vp
->v_vfsp
,
629 target_dp
, DM_EVENT_POSTRENAME
)) {
630 (void) XFS_SEND_NAMESP (mp
, DM_EVENT_POSTRENAME
,
631 src_dir_vp
, DM_RIGHT_NULL
,
632 target_dir_vp
, DM_RIGHT_NULL
,
633 src_name
, target_name
,
639 cancel_flags
|= XFS_TRANS_ABORT
;
642 xfs_bmap_cancel(&free_list
);
643 xfs_trans_cancel(tp
, cancel_flags
);
648 if (target_ip
!= NULL
) {