SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/xfs/xfs_rename.c

   1 /*
   2  * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
   3  * All Rights Reserved.
   4  *
   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.
   8  *
   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.
  13  *
  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
  17  */
  18 #include "xfs.h"
  19 #include "xfs_fs.h"
  20 #include "xfs_types.h"
  21 #include "xfs_log.h"
  22 #include "xfs_inum.h"
  23 #include "xfs_trans.h"
  24 #include "xfs_sb.h"
  25 #include "xfs_ag.h"
  26 #include "xfs_dir2.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"
  36 #include "xfs_bmap.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"
  42
  43
  44 /*
  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.
  48  */
  49 STATIC void
  50 xfs_rename_unlock4(
  51         xfs_inode_t     **i_tab,
  52         uint            lock_mode)
  53 {
  54         int     i;
  55
  56         xfs_iunlock(i_tab[0], lock_mode);
  57         for (i = 1; i < 4; i++) {
  58                 if (i_tab[i] == NULL)
  59                         break;
  60
  61                 /*
  62                  * Watch out for duplicate entries in the table.
  63                  */
  64                 if (i_tab[i] != i_tab[i-1])
  65                         xfs_iunlock(i_tab[i], lock_mode);
  66         }
  67 }
  68
  69 /*
  70  * Enter all inodes for a rename transaction into a sorted array.
  71  */
  72 STATIC void
  73 xfs_sort_for_rename(
  74         xfs_inode_t     *dp1,   /* in: old (source) directory inode */
  75         xfs_inode_t     *dp2,   /* in: new (target) directory inode */
  76         xfs_inode_t     *ip1,   /* in: inode of old entry */
  77         xfs_inode_t     *ip2,   /* in: inode of new entry, if it
  78                                    already exists, NULL otherwise. */
  79         xfs_inode_t     **i_tab,/* out: array of inode returned, sorted */
  80         int             *num_inodes)  /* out: number of inodes in array */
  81 {
  82         xfs_inode_t             *temp;
  83         int                     i, j;
  84
  85         /*
  86          * i_tab contains a list of pointers to inodes.  We initialize
  87          * the table here & we'll sort it.  We will then use it to
  88          * order the acquisition of the inode locks.
  89          *
  90          * Note that the table may contain duplicates.  e.g., dp1 == dp2.
  91          */
  92         i_tab[0] = dp1;
  93         i_tab[1] = dp2;
  94         i_tab[2] = ip1;
  95         if (ip2) {
  96                 *num_inodes = 4;
  97                 i_tab[3] = ip2;
  98         } else {
  99                 *num_inodes = 3;
 100                 i_tab[3] = NULL;
 101         }
 102
 103         /*
 104          * Sort the elements via bubble sort.  (Remember, there are at
 105          * most 4 elements to sort, so this is adequate.)
 106          */
 107         for (i = 0; i < *num_inodes; i++) {
 108                 for (j = 1; j < *num_inodes; j++) {
 109                         if (i_tab[j]->i_ino < i_tab[j-1]->i_ino) {
 110                                 temp = i_tab[j];
 111                                 i_tab[j] = i_tab[j-1];
 112                                 i_tab[j-1] = temp;
 113                         }
 114                 }
 115         }
 116 }
 117
 118 /*
 119  * xfs_rename
 120  */
 121 int
 122 xfs_rename(
 123         xfs_inode_t     *src_dp,
 124         struct xfs_name *src_name,
 125         xfs_inode_t     *src_ip,
 126         xfs_inode_t     *target_dp,
 127         struct xfs_name *target_name,
 128         xfs_inode_t     *target_ip)
 129 {
 130         xfs_trans_t     *tp = NULL;
 131         xfs_mount_t     *mp = src_dp->i_mount;
 132         int             new_parent;             /* moving to a new dir */
 133         int             src_is_directory;       /* src_name is a directory */
 134         int             error;
 135         xfs_bmap_free_t free_list;
 136         xfs_fsblock_t   first_block;
 137         int             cancel_flags;
 138         int             committed;
 139         xfs_inode_t     *inodes[4];
 140         int             target_ip_dropped = 0;  /* dropped target_ip link? */
 141         int             spaceres;
 142         int             target_link_zero = 0;
 143         int             num_inodes;
 144
 145         xfs_itrace_entry(src_dp);
 146         xfs_itrace_entry(target_dp);
 147
 148         if (DM_EVENT_ENABLED(src_dp, DM_EVENT_RENAME) ||
 149             DM_EVENT_ENABLED(target_dp, DM_EVENT_RENAME)) {
 150                 error = XFS_SEND_NAMESP(mp, DM_EVENT_RENAME,
 151                                         src_dp, DM_RIGHT_NULL,
 152                                         target_dp, DM_RIGHT_NULL,
 153                                         src_name->name, target_name->name,
 154                                         0, 0, 0);
 155                 if (error)
 156                         return error;
 157         }
 158         /* Return through std_return after this point. */
 159
 160         new_parent = (src_dp != target_dp);
 161         src_is_directory = ((src_ip->i_d.di_mode & S_IFMT) == S_IFDIR);
 162
 163         if (src_is_directory) {
 164                 /*
 165                  * Check for link count overflow on target_dp
 166                  */
 167                 if (target_ip == NULL && new_parent &&
 168                     target_dp->i_d.di_nlink >= XFS_MAXLINK) {
 169                         error = XFS_ERROR(EMLINK);
 170                         goto std_return;
 171                 }
 172         }
 173
 174         xfs_sort_for_rename(src_dp, target_dp, src_ip, target_ip,
 175                                 inodes, &num_inodes);
 176
 177         IHOLD(src_ip);
 178         if (target_ip)
 179                 IHOLD(target_ip);
 180
 181         XFS_BMAP_INIT(&free_list, &first_block);
 182         tp = xfs_trans_alloc(mp, XFS_TRANS_RENAME);
 183         cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
 184         spaceres = XFS_RENAME_SPACE_RES(mp, target_name->len);
 185         error = xfs_trans_reserve(tp, spaceres, XFS_RENAME_LOG_RES(mp), 0,
 186                         XFS_TRANS_PERM_LOG_RES, XFS_RENAME_LOG_COUNT);
 187         if (error == ENOSPC) {
 188                 spaceres = 0;
 189                 error = xfs_trans_reserve(tp, 0, XFS_RENAME_LOG_RES(mp), 0,
 190                                 XFS_TRANS_PERM_LOG_RES, XFS_RENAME_LOG_COUNT);
 191         }
 192         if (error) {
 193                 xfs_trans_cancel(tp, 0);
 194                 goto rele_return;
 195         }
 196
 197         /*
 198          * Attach the dquots to the inodes
 199          */
 200         if ((error = XFS_QM_DQVOPRENAME(mp, inodes))) {
 201                 xfs_trans_cancel(tp, cancel_flags);
 202                 goto rele_return;
 203         }
 204
 205         /*
 206          * Lock all the participating inodes. Depending upon whether
 207          * the target_name exists in the target directory, and
 208          * whether the target directory is the same as the source
 209          * directory, we can lock from 2 to 4 inodes.
 210          */
 211         xfs_lock_inodes(inodes, num_inodes, XFS_ILOCK_EXCL);
 212
 213         /*
 214          * If we are using project inheritance, we only allow renames
 215          * into our tree when the project IDs are the same; else the
 216          * tree quota mechanism would be circumvented.
 217          */
 218         if (unlikely((target_dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
 219                      (target_dp->i_d.di_projid != src_ip->i_d.di_projid))) {
 220                 error = XFS_ERROR(EXDEV);
 221                 xfs_rename_unlock4(inodes, XFS_ILOCK_SHARED);
 222                 xfs_trans_cancel(tp, cancel_flags);
 223                 goto rele_return;
 224         }
 225
 226         /*
 227          * Join all the inodes to the transaction. From this point on,
 228          * we can rely on either trans_commit or trans_cancel to unlock
 229          * them.  Note that we need to add a vnode reference to the
 230          * directories since trans_commit & trans_cancel will decrement
 231          * them when they unlock the inodes.  Also, we need to be careful
 232          * not to add an inode to the transaction more than once.
 233          */
 234         IHOLD(src_dp);
 235         xfs_trans_ijoin(tp, src_dp, XFS_ILOCK_EXCL);
 236         if (new_parent) {
 237                 IHOLD(target_dp);
 238                 xfs_trans_ijoin(tp, target_dp, XFS_ILOCK_EXCL);
 239         }
 240         if ((src_ip != src_dp) && (src_ip != target_dp)) {
 241                 xfs_trans_ijoin(tp, src_ip, XFS_ILOCK_EXCL);
 242         }
 243         if ((target_ip != NULL) &&
 244             (target_ip != src_ip) &&
 245             (target_ip != src_dp) &&
 246             (target_ip != target_dp)) {
 247                 xfs_trans_ijoin(tp, target_ip, XFS_ILOCK_EXCL);
 248         }
 249
 250         /*
 251          * Set up the target.
 252          */
 253         if (target_ip == NULL) {
 254                 /*
 255                  * If there's no space reservation, check the entry will
 256                  * fit before actually inserting it.
 257                  */
 258                 error = xfs_dir_canenter(tp, target_dp, target_name, spaceres);
 259                 if (error)
 260                         goto error_return;
 261                 /*
 262                  * If target does not exist and the rename crosses
 263                  * directories, adjust the target directory link count
 264                  * to account for the ".." reference from the new entry.
 265                  */
 266                 error = xfs_dir_createname(tp, target_dp, target_name,
 267                                                 src_ip->i_ino, &first_block,
 268                                                 &free_list, spaceres);
 269                 if (error == ENOSPC)
 270                         goto error_return;
 271                 if (error)
 272                         goto abort_return;
 273                 xfs_ichgtime(target_dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
 274
 275                 if (new_parent && src_is_directory) {
 276                         error = xfs_bumplink(tp, target_dp);
 277                         if (error)
 278                                 goto abort_return;
 279                 }
 280         } else { /* target_ip != NULL */
 281                 /*
 282                  * If target exists and it's a directory, check that both
 283                  * target and source are directories and that target can be
 284                  * destroyed, or that neither is a directory.
 285                  */
 286                 if ((target_ip->i_d.di_mode & S_IFMT) == S_IFDIR) {
 287                         /*
 288                          * Make sure target dir is empty.
 289                          */
 290                         if (!(xfs_dir_isempty(target_ip)) ||
 291                             (target_ip->i_d.di_nlink > 2)) {
 292                                 error = XFS_ERROR(EEXIST);
 293                                 goto error_return;
 294                         }
 295                 }
 296
 297                 /*
 298                  * Link the source inode under the target name.
 299                  * If the source inode is a directory and we are moving
 300                  * it across directories, its ".." entry will be
 301                  * inconsistent until we replace that down below.
 302                  *
 303                  * In case there is already an entry with the same
 304                  * name at the destination directory, remove it first.
 305                  */
 306                 error = xfs_dir_replace(tp, target_dp, target_name,
 307                                         src_ip->i_ino,
 308                                         &first_block, &free_list, spaceres);
 309                 if (error)
 310                         goto abort_return;
 311                 xfs_ichgtime(target_dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
 312
 313                 /*
 314                  * Decrement the link count on the target since the target
 315                  * dir no longer points to it.
 316                  */
 317                 error = xfs_droplink(tp, target_ip);
 318                 if (error)
 319                         goto abort_return;
 320                 target_ip_dropped = 1;
 321
 322                 if (src_is_directory) {
 323                         /*
 324                          * Drop the link from the old "." entry.
 325                          */
 326                         error = xfs_droplink(tp, target_ip);
 327                         if (error)
 328                                 goto abort_return;
 329                 }
 330
 331                 /* Do this test while we still hold the locks */
 332                 target_link_zero = (target_ip)->i_d.di_nlink==0;
 333
 334         } /* target_ip != NULL */
 335
 336         /*
 337          * Remove the source.
 338          */
 339         if (new_parent && src_is_directory) {
 340                 /*
 341                  * Rewrite the ".." entry to point to the new
 342                  * directory.
 343                  */
 344                 error = xfs_dir_replace(tp, src_ip, &xfs_name_dotdot,
 345                                         target_dp->i_ino,
 346                                         &first_block, &free_list, spaceres);
 347                 ASSERT(error != EEXIST);
 348                 if (error)
 349                         goto abort_return;
 350                 xfs_ichgtime(src_ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
 351
 352         } else {
 353                 /*
 354                  * We always want to hit the ctime on the source inode.
 355                  * We do it in the if clause above for the 'new_parent &&
 356                  * src_is_directory' case, and here we get all the other
 357                  * cases.  This isn't strictly required by the standards
 358                  * since the source inode isn't really being changed,
 359                  * but old unix file systems did it and some incremental
 360                  * backup programs won't work without it.
 361                  */
 362                 xfs_ichgtime(src_ip, XFS_ICHGTIME_CHG);
 363         }
 364
 365         /*
 366          * Adjust the link count on src_dp.  This is necessary when
 367          * renaming a directory, either within one parent when
 368          * the target existed, or across two parent directories.
 369          */
 370         if (src_is_directory && (new_parent || target_ip != NULL)) {
 371
 372                 /*
 373                  * Decrement link count on src_directory since the
 374                  * entry that's moved no longer points to it.
 375                  */
 376                 error = xfs_droplink(tp, src_dp);
 377                 if (error)
 378                         goto abort_return;
 379         }
 380
 381         error = xfs_dir_removename(tp, src_dp, src_name, src_ip->i_ino,
 382                                         &first_block, &free_list, spaceres);
 383         if (error)
 384                 goto abort_return;
 385         xfs_ichgtime(src_dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
 386
 387         /*
 388          * Update the generation counts on all the directory inodes
 389          * that we're modifying.
 390          */
 391         src_dp->i_gen++;
 392         xfs_trans_log_inode(tp, src_dp, XFS_ILOG_CORE);
 393
 394         if (new_parent) {
 395                 target_dp->i_gen++;
 396                 xfs_trans_log_inode(tp, target_dp, XFS_ILOG_CORE);
 397         }
 398
 399         /*
 400          * If there was a target inode, take an extra reference on
 401          * it here so that it doesn't go to xfs_inactive() from
 402          * within the commit.
 403          */
 404         if (target_ip != NULL) {
 405                 IHOLD(target_ip);
 406         }
 407
 408         /*
 409          * If this is a synchronous mount, make sure that the
 410          * rename transaction goes to disk before returning to
 411          * the user.
 412          */
 413         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
 414                 xfs_trans_set_sync(tp);
 415         }
 416
 417         /*
 418          * Take refs. for vop_link_removed calls below.  No need to worry
 419          * about directory refs. because the caller holds them.
 420          *
 421          * Do holds before the xfs_bmap_finish since it might rele them down
 422          * to zero.
 423          */
 424
 425         if (target_ip_dropped)
 426                 IHOLD(target_ip);
 427         IHOLD(src_ip);
 428
 429         error = xfs_bmap_finish(&tp, &free_list, &committed);
 430         if (error) {
 431                 xfs_bmap_cancel(&free_list);
 432                 xfs_trans_cancel(tp, (XFS_TRANS_RELEASE_LOG_RES |
 433                                  XFS_TRANS_ABORT));
 434                 if (target_ip != NULL) {
 435                         IRELE(target_ip);
 436                 }
 437                 if (target_ip_dropped) {
 438                         IRELE(target_ip);
 439                 }
 440                 IRELE(src_ip);
 441                 goto std_return;
 442         }
 443
 444         /*
 445          * trans_commit will unlock src_ip, target_ip & decrement
 446          * the vnode references.
 447          */
 448         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
 449         if (target_ip != NULL)
 450                 IRELE(target_ip);
 451         /*
 452          * Let interposed file systems know about removed links.
 453          */
 454         if (target_ip_dropped)
 455                 IRELE(target_ip);
 456
 457         IRELE(src_ip);
 458
 459         /* Fall through to std_return with error = 0 or errno from
 460          * xfs_trans_commit      */
 461 std_return:
 462         if (DM_EVENT_ENABLED(src_dp, DM_EVENT_POSTRENAME) ||
 463             DM_EVENT_ENABLED(target_dp, DM_EVENT_POSTRENAME)) {
 464                 (void) XFS_SEND_NAMESP (mp, DM_EVENT_POSTRENAME,
 465                                         src_dp, DM_RIGHT_NULL,
 466                                         target_dp, DM_RIGHT_NULL,
 467                                         src_name->name, target_name->name,
 468                                         0, error, 0);
 469         }
 470         return error;
 471
 472  abort_return:
 473         cancel_flags |= XFS_TRANS_ABORT;
 474         /* FALLTHROUGH */
 475  error_return:
 476         xfs_bmap_cancel(&free_list);
 477         xfs_trans_cancel(tp, cancel_flags);
 478         goto std_return;
 479
 480  rele_return:
 481         IRELE(src_ip);
 482         if (target_ip != NULL) {
 483                 IRELE(target_ip);
 484         }
 485         goto std_return;
 486 }