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_dir2_sf.h"
32 #include "xfs_attr_sf.h"
33 #include "xfs_dinode.h"
34 #include "xfs_inode.h"
35 #include "xfs_inode_item.h"
37 #include "xfs_error.h"
38 #include "xfs_quota.h"
39 #include "xfs_utils.h"
40 #include "xfs_trans_space.h"
41 #include "xfs_vnodeops.h"
45 * Given an array of up to 4 inode pointers, unlock the pointed to inodes.
46 * If there are fewer than 4 entries in the array, the empty entries will
47 * be at the end and will have NULL pointers in them.
56 xfs_iunlock(i_tab
[0], lock_mode
);
57 for (i
= 1; i
< 4; i
++) {
58 if (i_tab
[i
] == NULL
) {
62 * Watch out for duplicate entries in the table.
64 if (i_tab
[i
] != i_tab
[i
-1]) {
65 xfs_iunlock(i_tab
[i
], lock_mode
);
71 int xfs_rename_skip
, xfs_rename_nskip
;
75 * The following routine will acquire the locks required for a rename
76 * operation. The code understands the semantics of renames and will
77 * validate that name1 exists under dp1 & that name2 may or may not
80 * We are renaming dp1/name1 to dp2/name2.
82 * Return ENOENT if dp1 does not exist, other lookup errors, or 0 for success.
86 xfs_inode_t
*dp1
, /* old (source) directory inode */
87 xfs_inode_t
*dp2
, /* new (target) directory inode */
88 bhv_vname_t
*vname1
,/* old entry name */
89 bhv_vname_t
*vname2
,/* new entry name */
90 xfs_inode_t
**ipp1
, /* inode of old entry */
91 xfs_inode_t
**ipp2
, /* inode of new entry, if it
92 already exists, NULL otherwise. */
93 xfs_inode_t
**i_tab
,/* array of inode returned, sorted */
94 int *num_inodes
) /* number of inodes in array */
96 xfs_inode_t
*ip1
= VNAME_TO_INODE(vname1
);
97 xfs_inode_t
*ip2
, *temp
;
98 xfs_ino_t inum1
, inum2
;
102 int diff_dirs
= (dp1
!= dp2
);
107 * First, find out the current inums of the entries so that we
108 * can determine the initial locking order. We'll have to
109 * sanity check stuff after all the locks have been acquired
110 * to see if we still have the right inodes, directories, etc.
112 lock_mode
= xfs_ilock_map_shared(dp1
);
120 * Unlock dp1 and lock dp2 if they are different.
124 xfs_iunlock_map_shared(dp1
, lock_mode
);
125 lock_mode
= xfs_ilock_map_shared(dp2
);
128 error
= xfs_dir_lookup_int(dp2
, lock_mode
, vname2
, &inum2
, &ip2
);
129 if (error
== ENOENT
) { /* target does not need to exist. */
133 * If dp2 and dp1 are the same, the next line unlocks dp1.
136 xfs_iunlock_map_shared(dp2
, lock_mode
);
144 * i_tab contains a list of pointers to inodes. We initialize
145 * the table here & we'll sort it. We will then use it to
146 * order the acquisition of the inode locks.
148 * Note that the table may contain duplicates. e.g., dp1 == dp2.
162 * Sort the elements via bubble sort. (Remember, there are at
163 * most 4 elements to sort, so this is adequate.)
165 for (i
=0; i
< *num_inodes
; i
++) {
166 for (j
=1; j
< *num_inodes
; j
++) {
167 if (i_tab
[j
]->i_ino
< i_tab
[j
-1]->i_ino
) {
169 i_tab
[j
] = i_tab
[j
-1];
176 * We have dp2 locked. If it isn't first, unlock it.
177 * If it is first, tell xfs_lock_inodes so it can skip it
178 * when locking. if dp1 == dp2, xfs_lock_inodes will skip both
179 * since they are equal. xfs_lock_inodes needs all these inodes
180 * so that it can unlock and retry if there might be a dead-lock
181 * potential with the log.
184 if (i_tab
[0] == dp2
&& lock_mode
== XFS_ILOCK_SHARED
) {
188 xfs_lock_inodes(i_tab
, *num_inodes
, 1, XFS_ILOCK_SHARED
);
193 xfs_iunlock_map_shared(dp2
, lock_mode
);
194 xfs_lock_inodes(i_tab
, *num_inodes
, 0, XFS_ILOCK_SHARED
);
198 * Set the return value. Null out any unused entries in i_tab.
200 *ipp1
= *ipp2
= NULL
;
201 for (i
=0; i
< *num_inodes
; i
++) {
202 if (i_tab
[i
]->i_ino
== inum1
) {
205 if (i_tab
[i
]->i_ino
== inum2
) {
221 bhv_vname_t
*src_vname
,
222 bhv_vnode_t
*target_dir_vp
,
223 bhv_vname_t
*target_vname
)
225 bhv_vnode_t
*src_dir_vp
= XFS_ITOV(src_dp
);
227 xfs_inode_t
*target_dp
, *src_ip
, *target_ip
;
228 xfs_mount_t
*mp
= src_dp
->i_mount
;
229 int new_parent
; /* moving to a new dir */
230 int src_is_directory
; /* src_name is a directory */
232 xfs_bmap_free_t free_list
;
233 xfs_fsblock_t first_block
;
236 xfs_inode_t
*inodes
[4];
237 int target_ip_dropped
= 0; /* dropped target_ip link? */
239 int target_link_zero
= 0;
241 char *src_name
= VNAME(src_vname
);
242 char *target_name
= VNAME(target_vname
);
243 int src_namelen
= VNAMELEN(src_vname
);
244 int target_namelen
= VNAMELEN(target_vname
);
246 xfs_itrace_entry(src_dp
);
247 xfs_itrace_entry(xfs_vtoi(target_dir_vp
));
250 * Find the XFS behavior descriptor for the target directory
251 * vnode since it was not handed to us.
253 target_dp
= xfs_vtoi(target_dir_vp
);
254 if (target_dp
== NULL
) {
255 return XFS_ERROR(EXDEV
);
258 if (DM_EVENT_ENABLED(src_dp
, DM_EVENT_RENAME
) ||
259 DM_EVENT_ENABLED(target_dp
, DM_EVENT_RENAME
)) {
260 error
= XFS_SEND_NAMESP(mp
, DM_EVENT_RENAME
,
261 src_dir_vp
, DM_RIGHT_NULL
,
262 target_dir_vp
, DM_RIGHT_NULL
,
263 src_name
, target_name
,
269 /* Return through std_return after this point. */
272 * Lock all the participating inodes. Depending upon whether
273 * the target_name exists in the target directory, and
274 * whether the target directory is the same as the source
275 * directory, we can lock from 2 to 4 inodes.
276 * xfs_lock_for_rename() will return ENOENT if src_name
277 * does not exist in the source directory.
280 error
= xfs_lock_for_rename(src_dp
, target_dp
, src_vname
,
281 target_vname
, &src_ip
, &target_ip
, inodes
,
286 * We have nothing locked, no inode references, and
287 * no transaction, so just get out.
292 ASSERT(src_ip
!= NULL
);
294 if ((src_ip
->i_d
.di_mode
& S_IFMT
) == S_IFDIR
) {
296 * Check for link count overflow on target_dp
298 if (target_ip
== NULL
&& (src_dp
!= target_dp
) &&
299 target_dp
->i_d
.di_nlink
>= XFS_MAXLINK
) {
300 error
= XFS_ERROR(EMLINK
);
301 xfs_rename_unlock4(inodes
, XFS_ILOCK_SHARED
);
307 * If we are using project inheritance, we only allow renames
308 * into our tree when the project IDs are the same; else the
309 * tree quota mechanism would be circumvented.
311 if (unlikely((target_dp
->i_d
.di_flags
& XFS_DIFLAG_PROJINHERIT
) &&
312 (target_dp
->i_d
.di_projid
!= src_ip
->i_d
.di_projid
))) {
313 error
= XFS_ERROR(EXDEV
);
314 xfs_rename_unlock4(inodes
, XFS_ILOCK_SHARED
);
318 new_parent
= (src_dp
!= target_dp
);
319 src_is_directory
= ((src_ip
->i_d
.di_mode
& S_IFMT
) == S_IFDIR
);
322 * Drop the locks on our inodes so that we can start the transaction.
324 xfs_rename_unlock4(inodes
, XFS_ILOCK_SHARED
);
326 XFS_BMAP_INIT(&free_list
, &first_block
);
327 tp
= xfs_trans_alloc(mp
, XFS_TRANS_RENAME
);
328 cancel_flags
= XFS_TRANS_RELEASE_LOG_RES
;
329 spaceres
= XFS_RENAME_SPACE_RES(mp
, target_namelen
);
330 error
= xfs_trans_reserve(tp
, spaceres
, XFS_RENAME_LOG_RES(mp
), 0,
331 XFS_TRANS_PERM_LOG_RES
, XFS_RENAME_LOG_COUNT
);
332 if (error
== ENOSPC
) {
334 error
= xfs_trans_reserve(tp
, 0, XFS_RENAME_LOG_RES(mp
), 0,
335 XFS_TRANS_PERM_LOG_RES
, XFS_RENAME_LOG_COUNT
);
338 xfs_trans_cancel(tp
, 0);
343 * Attach the dquots to the inodes
345 if ((error
= XFS_QM_DQVOPRENAME(mp
, inodes
))) {
346 xfs_trans_cancel(tp
, cancel_flags
);
351 * Reacquire the inode locks we dropped above.
353 xfs_lock_inodes(inodes
, num_inodes
, 0, XFS_ILOCK_EXCL
);
356 * Join all the inodes to the transaction. From this point on,
357 * we can rely on either trans_commit or trans_cancel to unlock
358 * them. Note that we need to add a vnode reference to the
359 * directories since trans_commit & trans_cancel will decrement
360 * them when they unlock the inodes. Also, we need to be careful
361 * not to add an inode to the transaction more than once.
364 xfs_trans_ijoin(tp
, src_dp
, XFS_ILOCK_EXCL
);
366 VN_HOLD(target_dir_vp
);
367 xfs_trans_ijoin(tp
, target_dp
, XFS_ILOCK_EXCL
);
369 if ((src_ip
!= src_dp
) && (src_ip
!= target_dp
)) {
370 xfs_trans_ijoin(tp
, src_ip
, XFS_ILOCK_EXCL
);
372 if ((target_ip
!= NULL
) &&
373 (target_ip
!= src_ip
) &&
374 (target_ip
!= src_dp
) &&
375 (target_ip
!= target_dp
)) {
376 xfs_trans_ijoin(tp
, target_ip
, XFS_ILOCK_EXCL
);
382 if (target_ip
== NULL
) {
384 * If there's no space reservation, check the entry will
385 * fit before actually inserting it.
388 (error
= xfs_dir_canenter(tp
, target_dp
, target_name
,
392 * If target does not exist and the rename crosses
393 * directories, adjust the target directory link count
394 * to account for the ".." reference from the new entry.
396 error
= xfs_dir_createname(tp
, target_dp
, target_name
,
397 target_namelen
, src_ip
->i_ino
,
398 &first_block
, &free_list
, spaceres
);
403 xfs_ichgtime(target_dp
, XFS_ICHGTIME_MOD
| XFS_ICHGTIME_CHG
);
405 if (new_parent
&& src_is_directory
) {
406 error
= xfs_bumplink(tp
, target_dp
);
410 } else { /* target_ip != NULL */
412 * If target exists and it's a directory, check that both
413 * target and source are directories and that target can be
414 * destroyed, or that neither is a directory.
416 if ((target_ip
->i_d
.di_mode
& S_IFMT
) == S_IFDIR
) {
418 * Make sure target dir is empty.
420 if (!(xfs_dir_isempty(target_ip
)) ||
421 (target_ip
->i_d
.di_nlink
> 2)) {
422 error
= XFS_ERROR(EEXIST
);
428 * Link the source inode under the target name.
429 * If the source inode is a directory and we are moving
430 * it across directories, its ".." entry will be
431 * inconsistent until we replace that down below.
433 * In case there is already an entry with the same
434 * name at the destination directory, remove it first.
436 error
= xfs_dir_replace(tp
, target_dp
, target_name
,
437 target_namelen
, src_ip
->i_ino
,
438 &first_block
, &free_list
, spaceres
);
441 xfs_ichgtime(target_dp
, XFS_ICHGTIME_MOD
| XFS_ICHGTIME_CHG
);
444 * Decrement the link count on the target since the target
445 * dir no longer points to it.
447 error
= xfs_droplink(tp
, target_ip
);
450 target_ip_dropped
= 1;
452 if (src_is_directory
) {
454 * Drop the link from the old "." entry.
456 error
= xfs_droplink(tp
, target_ip
);
461 /* Do this test while we still hold the locks */
462 target_link_zero
= (target_ip
)->i_d
.di_nlink
==0;
464 } /* target_ip != NULL */
469 if (new_parent
&& src_is_directory
) {
471 * Rewrite the ".." entry to point to the new
474 error
= xfs_dir_replace(tp
, src_ip
, "..", 2, target_dp
->i_ino
,
475 &first_block
, &free_list
, spaceres
);
476 ASSERT(error
!= EEXIST
);
479 xfs_ichgtime(src_ip
, XFS_ICHGTIME_MOD
| XFS_ICHGTIME_CHG
);
483 * We always want to hit the ctime on the source inode.
484 * We do it in the if clause above for the 'new_parent &&
485 * src_is_directory' case, and here we get all the other
486 * cases. This isn't strictly required by the standards
487 * since the source inode isn't really being changed,
488 * but old unix file systems did it and some incremental
489 * backup programs won't work without it.
491 xfs_ichgtime(src_ip
, XFS_ICHGTIME_CHG
);
495 * Adjust the link count on src_dp. This is necessary when
496 * renaming a directory, either within one parent when
497 * the target existed, or across two parent directories.
499 if (src_is_directory
&& (new_parent
|| target_ip
!= NULL
)) {
502 * Decrement link count on src_directory since the
503 * entry that's moved no longer points to it.
505 error
= xfs_droplink(tp
, src_dp
);
510 error
= xfs_dir_removename(tp
, src_dp
, src_name
, src_namelen
,
511 src_ip
->i_ino
, &first_block
, &free_list
, spaceres
);
514 xfs_ichgtime(src_dp
, XFS_ICHGTIME_MOD
| XFS_ICHGTIME_CHG
);
517 * Update the generation counts on all the directory inodes
518 * that we're modifying.
521 xfs_trans_log_inode(tp
, src_dp
, XFS_ILOG_CORE
);
525 xfs_trans_log_inode(tp
, target_dp
, XFS_ILOG_CORE
);
529 * If there was a target inode, take an extra reference on
530 * it here so that it doesn't go to xfs_inactive() from
533 if (target_ip
!= NULL
) {
538 * If this is a synchronous mount, make sure that the
539 * rename transaction goes to disk before returning to
542 if (mp
->m_flags
& (XFS_MOUNT_WSYNC
|XFS_MOUNT_DIRSYNC
)) {
543 xfs_trans_set_sync(tp
);
547 * Take refs. for vop_link_removed calls below. No need to worry
548 * about directory refs. because the caller holds them.
550 * Do holds before the xfs_bmap_finish since it might rele them down
554 if (target_ip_dropped
)
558 error
= xfs_bmap_finish(&tp
, &free_list
, &committed
);
560 xfs_bmap_cancel(&free_list
);
561 xfs_trans_cancel(tp
, (XFS_TRANS_RELEASE_LOG_RES
|
563 if (target_ip
!= NULL
) {
566 if (target_ip_dropped
) {
574 * trans_commit will unlock src_ip, target_ip & decrement
575 * the vnode references.
577 error
= xfs_trans_commit(tp
, XFS_TRANS_RELEASE_LOG_RES
);
578 if (target_ip
!= NULL
)
581 * Let interposed file systems know about removed links.
583 if (target_ip_dropped
)
588 /* Fall through to std_return with error = 0 or errno from
589 * xfs_trans_commit */
591 if (DM_EVENT_ENABLED(src_dp
, DM_EVENT_POSTRENAME
) ||
592 DM_EVENT_ENABLED(target_dp
, DM_EVENT_POSTRENAME
)) {
593 (void) XFS_SEND_NAMESP (mp
, DM_EVENT_POSTRENAME
,
594 src_dir_vp
, DM_RIGHT_NULL
,
595 target_dir_vp
, DM_RIGHT_NULL
,
596 src_name
, target_name
,
602 cancel_flags
|= XFS_TRANS_ABORT
;
605 xfs_bmap_cancel(&free_list
);
606 xfs_trans_cancel(tp
, cancel_flags
);
611 if (target_ip
!= NULL
) {