2 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 #include "xfs_types.h"
23 #include "xfs_trans.h"
27 #include "xfs_dmapi.h"
28 #include "xfs_mount.h"
29 #include "xfs_da_btree.h"
30 #include "xfs_bmap_btree.h"
31 #include "xfs_dir_sf.h"
32 #include "xfs_dir2_sf.h"
33 #include "xfs_attr_sf.h"
34 #include "xfs_dinode.h"
35 #include "xfs_inode.h"
36 #include "xfs_inode_item.h"
38 #include "xfs_error.h"
39 #include "xfs_quota.h"
40 #include "xfs_refcache.h"
41 #include "xfs_utils.h"
42 #include "xfs_trans_space.h"
43 #include "xfs_dir_leaf.h"
47 * Given an array of up to 4 inode pointers, unlock the pointed to inodes.
48 * If there are fewer than 4 entries in the array, the empty entries will
49 * be at the end and will have NULL pointers in them.
58 xfs_iunlock(i_tab
[0], lock_mode
);
59 for (i
= 1; i
< 4; i
++) {
60 if (i_tab
[i
] == NULL
) {
64 * Watch out for duplicate entries in the table.
66 if (i_tab
[i
] != i_tab
[i
-1]) {
67 xfs_iunlock(i_tab
[i
], lock_mode
);
73 int xfs_rename_skip
, xfs_rename_nskip
;
77 * The following routine will acquire the locks required for a rename
78 * operation. The code understands the semantics of renames and will
79 * validate that name1 exists under dp1 & that name2 may or may not
82 * We are renaming dp1/name1 to dp2/name2.
84 * Return ENOENT if dp1 does not exist, other lookup errors, or 0 for success.
88 xfs_inode_t
*dp1
, /* old (source) directory inode */
89 xfs_inode_t
*dp2
, /* new (target) directory inode */
90 vname_t
*vname1
,/* old entry name */
91 vname_t
*vname2
,/* new entry name */
92 xfs_inode_t
**ipp1
, /* inode of old entry */
93 xfs_inode_t
**ipp2
, /* inode of new entry, if it
94 already exists, NULL otherwise. */
95 xfs_inode_t
**i_tab
,/* array of inode returned, sorted */
96 int *num_inodes
) /* number of inodes in array */
98 xfs_inode_t
*ip1
, *ip2
, *temp
;
99 xfs_ino_t inum1
, inum2
;
103 int diff_dirs
= (dp1
!= dp2
);
108 * First, find out the current inums of the entries so that we
109 * can determine the initial locking order. We'll have to
110 * sanity check stuff after all the locks have been acquired
111 * to see if we still have the right inodes, directories, etc.
113 lock_mode
= xfs_ilock_map_shared(dp1
);
114 error
= xfs_get_dir_entry(vname1
, &ip1
);
116 xfs_iunlock_map_shared(dp1
, lock_mode
);
126 * Unlock dp1 and lock dp2 if they are different.
130 xfs_iunlock_map_shared(dp1
, lock_mode
);
131 lock_mode
= xfs_ilock_map_shared(dp2
);
134 error
= xfs_dir_lookup_int(XFS_ITOBHV(dp2
), lock_mode
,
135 vname2
, &inum2
, &ip2
);
136 if (error
== ENOENT
) { /* target does not need to exist. */
140 * If dp2 and dp1 are the same, the next line unlocks dp1.
143 xfs_iunlock_map_shared(dp2
, lock_mode
);
151 * i_tab contains a list of pointers to inodes. We initialize
152 * the table here & we'll sort it. We will then use it to
153 * order the acquisition of the inode locks.
155 * Note that the table may contain duplicates. e.g., dp1 == dp2.
169 * Sort the elements via bubble sort. (Remember, there are at
170 * most 4 elements to sort, so this is adequate.)
172 for (i
=0; i
< *num_inodes
; i
++) {
173 for (j
=1; j
< *num_inodes
; j
++) {
174 if (i_tab
[j
]->i_ino
< i_tab
[j
-1]->i_ino
) {
176 i_tab
[j
] = i_tab
[j
-1];
183 * We have dp2 locked. If it isn't first, unlock it.
184 * If it is first, tell xfs_lock_inodes so it can skip it
185 * when locking. if dp1 == dp2, xfs_lock_inodes will skip both
186 * since they are equal. xfs_lock_inodes needs all these inodes
187 * so that it can unlock and retry if there might be a dead-lock
188 * potential with the log.
191 if (i_tab
[0] == dp2
&& lock_mode
== XFS_ILOCK_SHARED
) {
195 xfs_lock_inodes(i_tab
, *num_inodes
, 1, XFS_ILOCK_SHARED
);
200 xfs_iunlock_map_shared(dp2
, lock_mode
);
201 xfs_lock_inodes(i_tab
, *num_inodes
, 0, XFS_ILOCK_SHARED
);
205 * Set the return value. Null out any unused entries in i_tab.
207 *ipp1
= *ipp2
= NULL
;
208 for (i
=0; i
< *num_inodes
; i
++) {
209 if (i_tab
[i
]->i_ino
== inum1
) {
212 if (i_tab
[i
]->i_ino
== inum2
) {
227 bhv_desc_t
*src_dir_bdp
,
229 vnode_t
*target_dir_vp
,
230 vname_t
*target_vname
,
234 xfs_inode_t
*src_dp
, *target_dp
, *src_ip
, *target_ip
;
236 int new_parent
; /* moving to a new dir */
237 int src_is_directory
; /* src_name is a directory */
239 xfs_bmap_free_t free_list
;
240 xfs_fsblock_t first_block
;
243 xfs_inode_t
*inodes
[4];
244 int target_ip_dropped
= 0; /* dropped target_ip link? */
247 int target_link_zero
= 0;
249 char *src_name
= VNAME(src_vname
);
250 char *target_name
= VNAME(target_vname
);
251 int src_namelen
= VNAMELEN(src_vname
);
252 int target_namelen
= VNAMELEN(target_vname
);
254 src_dir_vp
= BHV_TO_VNODE(src_dir_bdp
);
255 vn_trace_entry(src_dir_vp
, "xfs_rename", (inst_t
*)__return_address
);
256 vn_trace_entry(target_dir_vp
, "xfs_rename", (inst_t
*)__return_address
);
259 * Find the XFS behavior descriptor for the target directory
260 * vnode since it was not handed to us.
262 target_dp
= xfs_vtoi(target_dir_vp
);
263 if (target_dp
== NULL
) {
264 return XFS_ERROR(EXDEV
);
267 src_dp
= XFS_BHVTOI(src_dir_bdp
);
268 mp
= src_dp
->i_mount
;
270 if (DM_EVENT_ENABLED(src_dir_vp
->v_vfsp
, src_dp
, DM_EVENT_RENAME
) ||
271 DM_EVENT_ENABLED(target_dir_vp
->v_vfsp
,
272 target_dp
, DM_EVENT_RENAME
)) {
273 error
= XFS_SEND_NAMESP(mp
, DM_EVENT_RENAME
,
274 src_dir_vp
, DM_RIGHT_NULL
,
275 target_dir_vp
, DM_RIGHT_NULL
,
276 src_name
, target_name
,
282 /* Return through std_return after this point. */
285 * Lock all the participating inodes. Depending upon whether
286 * the target_name exists in the target directory, and
287 * whether the target directory is the same as the source
288 * directory, we can lock from 2 to 4 inodes.
289 * xfs_lock_for_rename() will return ENOENT if src_name
290 * does not exist in the source directory.
293 error
= xfs_lock_for_rename(src_dp
, target_dp
, src_vname
,
294 target_vname
, &src_ip
, &target_ip
, inodes
,
299 * We have nothing locked, no inode references, and
300 * no transaction, so just get out.
305 ASSERT(src_ip
!= NULL
);
307 if ((src_ip
->i_d
.di_mode
& S_IFMT
) == S_IFDIR
) {
309 * Check for link count overflow on target_dp
311 if (target_ip
== NULL
&& (src_dp
!= target_dp
) &&
312 target_dp
->i_d
.di_nlink
>= XFS_MAXLINK
) {
313 error
= XFS_ERROR(EMLINK
);
314 xfs_rename_unlock4(inodes
, XFS_ILOCK_SHARED
);
319 new_parent
= (src_dp
!= target_dp
);
320 src_is_directory
= ((src_ip
->i_d
.di_mode
& S_IFMT
) == S_IFDIR
);
323 * Drop the locks on our inodes so that we can start the transaction.
325 xfs_rename_unlock4(inodes
, XFS_ILOCK_SHARED
);
327 XFS_BMAP_INIT(&free_list
, &first_block
);
328 tp
= xfs_trans_alloc(mp
, XFS_TRANS_RENAME
);
329 cancel_flags
= XFS_TRANS_RELEASE_LOG_RES
;
330 spaceres
= XFS_RENAME_SPACE_RES(mp
, target_namelen
);
331 error
= xfs_trans_reserve(tp
, spaceres
, XFS_RENAME_LOG_RES(mp
), 0,
332 XFS_TRANS_PERM_LOG_RES
, XFS_RENAME_LOG_COUNT
);
333 if (error
== ENOSPC
) {
335 error
= xfs_trans_reserve(tp
, 0, XFS_RENAME_LOG_RES(mp
), 0,
336 XFS_TRANS_PERM_LOG_RES
, XFS_RENAME_LOG_COUNT
);
339 xfs_trans_cancel(tp
, 0);
344 * Attach the dquots to the inodes
346 if ((error
= XFS_QM_DQVOPRENAME(mp
, inodes
))) {
347 xfs_trans_cancel(tp
, cancel_flags
);
352 * Reacquire the inode locks we dropped above.
354 xfs_lock_inodes(inodes
, num_inodes
, 0, XFS_ILOCK_EXCL
);
357 * Join all the inodes to the transaction. From this point on,
358 * we can rely on either trans_commit or trans_cancel to unlock
359 * them. Note that we need to add a vnode reference to the
360 * directories since trans_commit & trans_cancel will decrement
361 * them when they unlock the inodes. Also, we need to be careful
362 * not to add an inode to the transaction more than once.
365 xfs_trans_ijoin(tp
, src_dp
, XFS_ILOCK_EXCL
);
367 VN_HOLD(target_dir_vp
);
368 xfs_trans_ijoin(tp
, target_dp
, XFS_ILOCK_EXCL
);
370 if ((src_ip
!= src_dp
) && (src_ip
!= target_dp
)) {
371 xfs_trans_ijoin(tp
, src_ip
, XFS_ILOCK_EXCL
);
373 if ((target_ip
!= NULL
) &&
374 (target_ip
!= src_ip
) &&
375 (target_ip
!= src_dp
) &&
376 (target_ip
!= target_dp
)) {
377 xfs_trans_ijoin(tp
, target_ip
, XFS_ILOCK_EXCL
);
383 if (target_ip
== NULL
) {
385 * If there's no space reservation, check the entry will
386 * fit before actually inserting it.
389 (error
= XFS_DIR_CANENTER(mp
, tp
, target_dp
, target_name
,
394 * If target does not exist and the rename crosses
395 * directories, adjust the target directory link count
396 * to account for the ".." reference from the new entry.
398 error
= XFS_DIR_CREATENAME(mp
, tp
, target_dp
, target_name
,
399 target_namelen
, src_ip
->i_ino
,
400 &first_block
, &free_list
, spaceres
);
401 if (error
== ENOSPC
) {
407 xfs_ichgtime(target_dp
, XFS_ICHGTIME_MOD
| XFS_ICHGTIME_CHG
);
409 if (new_parent
&& src_is_directory
) {
410 error
= xfs_bumplink(tp
, target_dp
);
415 } else { /* target_ip != NULL */
418 * If target exists and it's a directory, check that both
419 * target and source are directories and that target can be
420 * destroyed, or that neither is a directory.
422 if ((target_ip
->i_d
.di_mode
& S_IFMT
) == S_IFDIR
) {
424 * Make sure target dir is empty.
426 if (!(XFS_DIR_ISEMPTY(target_ip
->i_mount
, target_ip
)) ||
427 (target_ip
->i_d
.di_nlink
> 2)) {
428 error
= XFS_ERROR(EEXIST
);
434 * Link the source inode under the target name.
435 * If the source inode is a directory and we are moving
436 * it across directories, its ".." entry will be
437 * inconsistent until we replace that down below.
439 * In case there is already an entry with the same
440 * name at the destination directory, remove it first.
442 error
= XFS_DIR_REPLACE(mp
, tp
, target_dp
, target_name
,
443 target_namelen
, src_ip
->i_ino
, &first_block
,
444 &free_list
, spaceres
);
448 xfs_ichgtime(target_dp
, XFS_ICHGTIME_MOD
| XFS_ICHGTIME_CHG
);
451 * Decrement the link count on the target since the target
452 * dir no longer points to it.
454 error
= xfs_droplink(tp
, target_ip
);
458 target_ip_dropped
= 1;
460 if (src_is_directory
) {
462 * Drop the link from the old "." entry.
464 error
= xfs_droplink(tp
, target_ip
);
470 /* Do this test while we still hold the locks */
471 target_link_zero
= (target_ip
)->i_d
.di_nlink
==0;
473 } /* target_ip != NULL */
478 if (new_parent
&& src_is_directory
) {
481 * Rewrite the ".." entry to point to the new
484 error
= XFS_DIR_REPLACE(mp
, tp
, src_ip
, "..", 2,
485 target_dp
->i_ino
, &first_block
,
486 &free_list
, spaceres
);
487 ASSERT(error
!= EEXIST
);
491 xfs_ichgtime(src_ip
, XFS_ICHGTIME_MOD
| XFS_ICHGTIME_CHG
);
495 * We always want to hit the ctime on the source inode.
496 * We do it in the if clause above for the 'new_parent &&
497 * src_is_directory' case, and here we get all the other
498 * cases. This isn't strictly required by the standards
499 * since the source inode isn't really being changed,
500 * but old unix file systems did it and some incremental
501 * backup programs won't work without it.
503 xfs_ichgtime(src_ip
, XFS_ICHGTIME_CHG
);
507 * Adjust the link count on src_dp. This is necessary when
508 * renaming a directory, either within one parent when
509 * the target existed, or across two parent directories.
511 if (src_is_directory
&& (new_parent
|| target_ip
!= NULL
)) {
514 * Decrement link count on src_directory since the
515 * entry that's moved no longer points to it.
517 error
= xfs_droplink(tp
, src_dp
);
523 error
= XFS_DIR_REMOVENAME(mp
, tp
, src_dp
, src_name
, src_namelen
,
524 src_ip
->i_ino
, &first_block
, &free_list
, spaceres
);
528 xfs_ichgtime(src_dp
, XFS_ICHGTIME_MOD
| XFS_ICHGTIME_CHG
);
531 * Update the generation counts on all the directory inodes
532 * that we're modifying.
535 xfs_trans_log_inode(tp
, src_dp
, XFS_ILOG_CORE
);
539 xfs_trans_log_inode(tp
, target_dp
, XFS_ILOG_CORE
);
543 * If there was a target inode, take an extra reference on
544 * it here so that it doesn't go to xfs_inactive() from
547 if (target_ip
!= NULL
) {
552 * If this is a synchronous mount, make sure that the
553 * rename transaction goes to disk before returning to
556 if (mp
->m_flags
& (XFS_MOUNT_WSYNC
|XFS_MOUNT_DIRSYNC
)) {
557 xfs_trans_set_sync(tp
);
561 * Take refs. for vop_link_removed calls below. No need to worry
562 * about directory refs. because the caller holds them.
564 * Do holds before the xfs_bmap_finish since it might rele them down
568 if (target_ip_dropped
)
572 error
= xfs_bmap_finish(&tp
, &free_list
, first_block
, &committed
);
574 xfs_bmap_cancel(&free_list
);
575 xfs_trans_cancel(tp
, (XFS_TRANS_RELEASE_LOG_RES
|
577 if (target_ip
!= NULL
) {
580 if (target_ip_dropped
) {
588 * trans_commit will unlock src_ip, target_ip & decrement
589 * the vnode references.
591 error
= xfs_trans_commit(tp
, XFS_TRANS_RELEASE_LOG_RES
, NULL
);
592 if (target_ip
!= NULL
) {
593 xfs_refcache_purge_ip(target_ip
);
597 * Let interposed file systems know about removed links.
599 if (target_ip_dropped
) {
600 VOP_LINK_REMOVED(XFS_ITOV(target_ip
), target_dir_vp
,
607 /* Fall through to std_return with error = 0 or errno from
608 * xfs_trans_commit */
610 if (DM_EVENT_ENABLED(src_dir_vp
->v_vfsp
, src_dp
, DM_EVENT_POSTRENAME
) ||
611 DM_EVENT_ENABLED(target_dir_vp
->v_vfsp
,
612 target_dp
, DM_EVENT_POSTRENAME
)) {
613 (void) XFS_SEND_NAMESP (mp
, DM_EVENT_POSTRENAME
,
614 src_dir_vp
, DM_RIGHT_NULL
,
615 target_dir_vp
, DM_RIGHT_NULL
,
616 src_name
, target_name
,
622 cancel_flags
|= XFS_TRANS_ABORT
;
625 xfs_bmap_cancel(&free_list
);
626 xfs_trans_cancel(tp
, cancel_flags
);
631 if (target_ip
!= NULL
) {