1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc. 4 * All Rights Reserved. 5 */ 6 #include "xfs.h" 7 #include "xfs_fs.h" 8 #include "xfs_shared.h" 9 #include "xfs_format.h" 10 #include "xfs_log_format.h" 11 #include "xfs_trans_resv.h" 12 #include "xfs_mount.h" 13 #include "xfs_inode.h" 14 #include "xfs_trans.h" 15 #include "xfs_bmap.h" 16 #include "xfs_dir2.h" 17 #include "xfs_dir2_priv.h" 18 #include "xfs_errortag.h" 19 #include "xfs_error.h" 20 #include "xfs_trace.h" 21 #include "xfs_health.h" 22 #include "xfs_bmap_btree.h" 23 #include "xfs_trans_space.h" 24 #include "xfs_parent.h" 25 #include "xfs_ag.h" 26 #include "xfs_ialloc.h" 27 28 const struct xfs_name xfs_name_dotdot = { 29 .name = (const unsigned char *)"..", 30 .len = 2, 31 .type = XFS_DIR3_FT_DIR, 32 }; 33 34 const struct xfs_name xfs_name_dot = { 35 .name = (const unsigned char *)".", 36 .len = 1, 37 .type = XFS_DIR3_FT_DIR, 38 }; 39 40 /* 41 * Convert inode mode to directory entry filetype 42 */ 43 unsigned char xfs_mode_to_ftype(int mode)44 xfs_mode_to_ftype( 45 int mode) 46 { 47 switch (mode & S_IFMT) { 48 case S_IFREG: 49 return XFS_DIR3_FT_REG_FILE; 50 case S_IFDIR: 51 return XFS_DIR3_FT_DIR; 52 case S_IFCHR: 53 return XFS_DIR3_FT_CHRDEV; 54 case S_IFBLK: 55 return XFS_DIR3_FT_BLKDEV; 56 case S_IFIFO: 57 return XFS_DIR3_FT_FIFO; 58 case S_IFSOCK: 59 return XFS_DIR3_FT_SOCK; 60 case S_IFLNK: 61 return XFS_DIR3_FT_SYMLINK; 62 default: 63 return XFS_DIR3_FT_UNKNOWN; 64 } 65 } 66 67 /* 68 * ASCII case-insensitive (ie. A-Z) support for directories that was 69 * used in IRIX. 70 */ 71 xfs_dahash_t xfs_ascii_ci_hashname(const struct xfs_name * name)72 xfs_ascii_ci_hashname( 73 const struct xfs_name *name) 74 { 75 xfs_dahash_t hash; 76 int i; 77 78 for (i = 0, hash = 0; i < name->len; i++) 79 hash = xfs_ascii_ci_xfrm(name->name[i]) ^ rol32(hash, 7); 80 81 return hash; 82 } 83 84 enum xfs_dacmp xfs_ascii_ci_compname(struct xfs_da_args * args,const unsigned char * name,int len)85 xfs_ascii_ci_compname( 86 struct xfs_da_args *args, 87 const unsigned char *name, 88 int len) 89 { 90 enum xfs_dacmp result; 91 int i; 92 93 if (args->namelen != len) 94 return XFS_CMP_DIFFERENT; 95 96 result = XFS_CMP_EXACT; 97 for (i = 0; i < len; i++) { 98 if (args->name[i] == name[i]) 99 continue; 100 if (xfs_ascii_ci_xfrm(args->name[i]) != 101 xfs_ascii_ci_xfrm(name[i])) 102 return XFS_CMP_DIFFERENT; 103 result = XFS_CMP_CASE; 104 } 105 106 return result; 107 } 108 109 int xfs_da_mount(struct xfs_mount * mp)110 xfs_da_mount( 111 struct xfs_mount *mp) 112 { 113 struct xfs_da_geometry *dageo; 114 115 116 ASSERT(mp->m_sb.sb_versionnum & XFS_SB_VERSION_DIRV2BIT); 117 ASSERT(xfs_dir2_dirblock_bytes(&mp->m_sb) <= XFS_MAX_BLOCKSIZE); 118 119 mp->m_dir_geo = kzalloc(sizeof(struct xfs_da_geometry), 120 GFP_KERNEL | __GFP_RETRY_MAYFAIL); 121 mp->m_attr_geo = kzalloc(sizeof(struct xfs_da_geometry), 122 GFP_KERNEL | __GFP_RETRY_MAYFAIL); 123 if (!mp->m_dir_geo || !mp->m_attr_geo) { 124 kfree(mp->m_dir_geo); 125 kfree(mp->m_attr_geo); 126 return -ENOMEM; 127 } 128 129 /* set up directory geometry */ 130 dageo = mp->m_dir_geo; 131 dageo->blklog = mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog; 132 dageo->fsblog = mp->m_sb.sb_blocklog; 133 dageo->blksize = xfs_dir2_dirblock_bytes(&mp->m_sb); 134 dageo->fsbcount = 1 << mp->m_sb.sb_dirblklog; 135 if (xfs_has_crc(mp)) { 136 dageo->node_hdr_size = sizeof(struct xfs_da3_node_hdr); 137 dageo->leaf_hdr_size = sizeof(struct xfs_dir3_leaf_hdr); 138 dageo->free_hdr_size = sizeof(struct xfs_dir3_free_hdr); 139 dageo->data_entry_offset = 140 sizeof(struct xfs_dir3_data_hdr); 141 } else { 142 dageo->node_hdr_size = sizeof(struct xfs_da_node_hdr); 143 dageo->leaf_hdr_size = sizeof(struct xfs_dir2_leaf_hdr); 144 dageo->free_hdr_size = sizeof(struct xfs_dir2_free_hdr); 145 dageo->data_entry_offset = 146 sizeof(struct xfs_dir2_data_hdr); 147 } 148 dageo->leaf_max_ents = (dageo->blksize - dageo->leaf_hdr_size) / 149 sizeof(struct xfs_dir2_leaf_entry); 150 dageo->free_max_bests = (dageo->blksize - dageo->free_hdr_size) / 151 sizeof(xfs_dir2_data_off_t); 152 153 dageo->data_first_offset = dageo->data_entry_offset + 154 xfs_dir2_data_entsize(mp, 1) + 155 xfs_dir2_data_entsize(mp, 2); 156 157 /* 158 * Now we've set up the block conversion variables, we can calculate the 159 * segment block constants using the geometry structure. 160 */ 161 dageo->datablk = xfs_dir2_byte_to_da(dageo, XFS_DIR2_DATA_OFFSET); 162 dageo->leafblk = xfs_dir2_byte_to_da(dageo, XFS_DIR2_LEAF_OFFSET); 163 dageo->freeblk = xfs_dir2_byte_to_da(dageo, XFS_DIR2_FREE_OFFSET); 164 dageo->node_ents = (dageo->blksize - dageo->node_hdr_size) / 165 (uint)sizeof(xfs_da_node_entry_t); 166 dageo->max_extents = (XFS_DIR2_MAX_SPACES * XFS_DIR2_SPACE_SIZE) >> 167 mp->m_sb.sb_blocklog; 168 dageo->magicpct = (dageo->blksize * 37) / 100; 169 170 /* set up attribute geometry - single fsb only */ 171 dageo = mp->m_attr_geo; 172 dageo->blklog = mp->m_sb.sb_blocklog; 173 dageo->fsblog = mp->m_sb.sb_blocklog; 174 dageo->blksize = 1 << dageo->blklog; 175 dageo->fsbcount = 1; 176 dageo->node_hdr_size = mp->m_dir_geo->node_hdr_size; 177 dageo->node_ents = (dageo->blksize - dageo->node_hdr_size) / 178 (uint)sizeof(xfs_da_node_entry_t); 179 180 if (xfs_has_large_extent_counts(mp)) 181 dageo->max_extents = XFS_MAX_EXTCNT_ATTR_FORK_LARGE; 182 else 183 dageo->max_extents = XFS_MAX_EXTCNT_ATTR_FORK_SMALL; 184 185 dageo->magicpct = (dageo->blksize * 37) / 100; 186 return 0; 187 } 188 189 void xfs_da_unmount(struct xfs_mount * mp)190 xfs_da_unmount( 191 struct xfs_mount *mp) 192 { 193 kfree(mp->m_dir_geo); 194 kfree(mp->m_attr_geo); 195 } 196 197 /* 198 * Return 1 if directory contains only "." and "..". 199 */ 200 static bool xfs_dir_isempty(xfs_inode_t * dp)201 xfs_dir_isempty( 202 xfs_inode_t *dp) 203 { 204 xfs_dir2_sf_hdr_t *sfp; 205 206 ASSERT(S_ISDIR(VFS_I(dp)->i_mode)); 207 if (dp->i_disk_size == 0) /* might happen during shutdown. */ 208 return true; 209 if (dp->i_disk_size > xfs_inode_data_fork_size(dp)) 210 return false; 211 sfp = dp->i_df.if_data; 212 return !sfp->count; 213 } 214 215 /* 216 * Validate a given inode number. 217 */ 218 int xfs_dir_ino_validate(xfs_mount_t * mp,xfs_ino_t ino)219 xfs_dir_ino_validate( 220 xfs_mount_t *mp, 221 xfs_ino_t ino) 222 { 223 bool ino_ok = xfs_verify_dir_ino(mp, ino); 224 225 if (XFS_IS_CORRUPT(mp, !ino_ok) || 226 XFS_TEST_ERROR(false, mp, XFS_ERRTAG_DIR_INO_VALIDATE)) { 227 xfs_warn(mp, "Invalid inode number 0x%Lx", 228 (unsigned long long) ino); 229 return -EFSCORRUPTED; 230 } 231 return 0; 232 } 233 234 /* 235 * Initialize a directory with its "." and ".." entries. 236 */ 237 int xfs_dir_init(xfs_trans_t * tp,xfs_inode_t * dp,xfs_inode_t * pdp)238 xfs_dir_init( 239 xfs_trans_t *tp, 240 xfs_inode_t *dp, 241 xfs_inode_t *pdp) 242 { 243 struct xfs_da_args *args; 244 int error; 245 246 ASSERT(S_ISDIR(VFS_I(dp)->i_mode)); 247 error = xfs_dir_ino_validate(tp->t_mountp, pdp->i_ino); 248 if (error) 249 return error; 250 251 args = kzalloc(sizeof(*args), GFP_KERNEL | __GFP_NOFAIL); 252 if (!args) 253 return -ENOMEM; 254 255 args->geo = dp->i_mount->m_dir_geo; 256 args->dp = dp; 257 args->trans = tp; 258 args->owner = dp->i_ino; 259 error = xfs_dir2_sf_create(args, pdp->i_ino); 260 kfree(args); 261 return error; 262 } 263 264 enum xfs_dir2_fmt xfs_dir2_format(struct xfs_da_args * args,int * error)265 xfs_dir2_format( 266 struct xfs_da_args *args, 267 int *error) 268 { 269 struct xfs_inode *dp = args->dp; 270 struct xfs_mount *mp = dp->i_mount; 271 struct xfs_da_geometry *geo = mp->m_dir_geo; 272 xfs_fileoff_t eof; 273 274 xfs_assert_ilocked(dp, XFS_ILOCK_SHARED | XFS_ILOCK_EXCL); 275 276 *error = 0; 277 if (dp->i_df.if_format == XFS_DINODE_FMT_LOCAL) 278 return XFS_DIR2_FMT_SF; 279 280 *error = xfs_bmap_last_offset(dp, &eof, XFS_DATA_FORK); 281 if (*error) 282 return XFS_DIR2_FMT_ERROR; 283 284 if (eof == XFS_B_TO_FSB(mp, geo->blksize)) { 285 if (XFS_IS_CORRUPT(mp, dp->i_disk_size != geo->blksize)) { 286 xfs_da_mark_sick(args); 287 *error = -EFSCORRUPTED; 288 return XFS_DIR2_FMT_ERROR; 289 } 290 return XFS_DIR2_FMT_BLOCK; 291 } 292 if (eof == geo->leafblk + geo->fsbcount) 293 return XFS_DIR2_FMT_LEAF; 294 return XFS_DIR2_FMT_NODE; 295 } 296 297 int xfs_dir_createname_args(struct xfs_da_args * args)298 xfs_dir_createname_args( 299 struct xfs_da_args *args) 300 { 301 int error; 302 303 if (!args->inumber) 304 args->op_flags |= XFS_DA_OP_JUSTCHECK; 305 306 switch (xfs_dir2_format(args, &error)) { 307 case XFS_DIR2_FMT_SF: 308 return xfs_dir2_sf_addname(args); 309 case XFS_DIR2_FMT_BLOCK: 310 return xfs_dir2_block_addname(args); 311 case XFS_DIR2_FMT_LEAF: 312 return xfs_dir2_leaf_addname(args); 313 case XFS_DIR2_FMT_NODE: 314 return xfs_dir2_node_addname(args); 315 default: 316 return error; 317 } 318 } 319 320 /* 321 * Enter a name in a directory, or check for available space. 322 * If inum is 0, only the available space test is performed. 323 */ 324 int xfs_dir_createname(struct xfs_trans * tp,struct xfs_inode * dp,const struct xfs_name * name,xfs_ino_t inum,xfs_extlen_t total)325 xfs_dir_createname( 326 struct xfs_trans *tp, 327 struct xfs_inode *dp, 328 const struct xfs_name *name, 329 xfs_ino_t inum, /* new entry inode number */ 330 xfs_extlen_t total) /* bmap's total block count */ 331 { 332 struct xfs_da_args *args; 333 int rval; 334 335 ASSERT(S_ISDIR(VFS_I(dp)->i_mode)); 336 337 if (inum) { 338 rval = xfs_dir_ino_validate(tp->t_mountp, inum); 339 if (rval) 340 return rval; 341 XFS_STATS_INC(dp->i_mount, xs_dir_create); 342 } 343 344 args = kzalloc(sizeof(*args), GFP_KERNEL | __GFP_NOFAIL); 345 if (!args) 346 return -ENOMEM; 347 348 args->geo = dp->i_mount->m_dir_geo; 349 args->name = name->name; 350 args->namelen = name->len; 351 args->filetype = name->type; 352 args->hashval = xfs_dir2_hashname(dp->i_mount, name); 353 args->inumber = inum; 354 args->dp = dp; 355 args->total = total; 356 args->whichfork = XFS_DATA_FORK; 357 args->trans = tp; 358 args->op_flags = XFS_DA_OP_ADDNAME | XFS_DA_OP_OKNOENT; 359 args->owner = dp->i_ino; 360 361 rval = xfs_dir_createname_args(args); 362 kfree(args); 363 return rval; 364 } 365 366 /* 367 * If doing a CI lookup and case-insensitive match, dup actual name into 368 * args.value. Return EEXIST for success (ie. name found) or an error. 369 */ 370 int xfs_dir_cilookup_result(struct xfs_da_args * args,const unsigned char * name,int len)371 xfs_dir_cilookup_result( 372 struct xfs_da_args *args, 373 const unsigned char *name, 374 int len) 375 { 376 if (args->cmpresult == XFS_CMP_DIFFERENT) 377 return -ENOENT; 378 if (args->cmpresult != XFS_CMP_CASE || 379 !(args->op_flags & XFS_DA_OP_CILOOKUP)) 380 return -EEXIST; 381 382 args->value = kmemdup(name, len, 383 GFP_KERNEL | __GFP_NOLOCKDEP | __GFP_RETRY_MAYFAIL); 384 if (!args->value) 385 return -ENOMEM; 386 387 args->valuelen = len; 388 return -EEXIST; 389 } 390 391 int xfs_dir_lookup_args(struct xfs_da_args * args)392 xfs_dir_lookup_args( 393 struct xfs_da_args *args) 394 { 395 int error; 396 397 switch (xfs_dir2_format(args, &error)) { 398 case XFS_DIR2_FMT_SF: 399 error = xfs_dir2_sf_lookup(args); 400 break; 401 case XFS_DIR2_FMT_BLOCK: 402 error = xfs_dir2_block_lookup(args); 403 break; 404 case XFS_DIR2_FMT_LEAF: 405 error = xfs_dir2_leaf_lookup(args); 406 break; 407 case XFS_DIR2_FMT_NODE: 408 error = xfs_dir2_node_lookup(args); 409 break; 410 default: 411 break; 412 } 413 414 if (error != -EEXIST) 415 return error; 416 return 0; 417 } 418 419 /* 420 * Lookup a name in a directory, give back the inode number. 421 * If ci_name is not NULL, returns the actual name in ci_name if it differs 422 * to name, or ci_name->name is set to NULL for an exact match. 423 */ 424 425 int xfs_dir_lookup(struct xfs_trans * tp,struct xfs_inode * dp,const struct xfs_name * name,xfs_ino_t * inum,struct xfs_name * ci_name)426 xfs_dir_lookup( 427 struct xfs_trans *tp, 428 struct xfs_inode *dp, 429 const struct xfs_name *name, 430 xfs_ino_t *inum, /* out: inode number */ 431 struct xfs_name *ci_name) /* out: actual name if CI match */ 432 { 433 struct xfs_da_args *args; 434 int rval; 435 int lock_mode; 436 437 ASSERT(S_ISDIR(VFS_I(dp)->i_mode)); 438 XFS_STATS_INC(dp->i_mount, xs_dir_lookup); 439 440 args = kzalloc(sizeof(*args), 441 GFP_KERNEL | __GFP_NOLOCKDEP | __GFP_NOFAIL); 442 args->geo = dp->i_mount->m_dir_geo; 443 args->name = name->name; 444 args->namelen = name->len; 445 args->filetype = name->type; 446 args->hashval = xfs_dir2_hashname(dp->i_mount, name); 447 args->dp = dp; 448 args->whichfork = XFS_DATA_FORK; 449 args->trans = tp; 450 args->op_flags = XFS_DA_OP_OKNOENT; 451 args->owner = dp->i_ino; 452 if (ci_name) 453 args->op_flags |= XFS_DA_OP_CILOOKUP; 454 455 lock_mode = xfs_ilock_data_map_shared(dp); 456 rval = xfs_dir_lookup_args(args); 457 if (!rval) { 458 *inum = args->inumber; 459 if (ci_name) { 460 ci_name->name = args->value; 461 ci_name->len = args->valuelen; 462 } 463 } 464 xfs_iunlock(dp, lock_mode); 465 kfree(args); 466 return rval; 467 } 468 469 int xfs_dir_removename_args(struct xfs_da_args * args)470 xfs_dir_removename_args( 471 struct xfs_da_args *args) 472 { 473 int error; 474 475 switch (xfs_dir2_format(args, &error)) { 476 case XFS_DIR2_FMT_SF: 477 return xfs_dir2_sf_removename(args); 478 case XFS_DIR2_FMT_BLOCK: 479 return xfs_dir2_block_removename(args); 480 case XFS_DIR2_FMT_LEAF: 481 return xfs_dir2_leaf_removename(args); 482 case XFS_DIR2_FMT_NODE: 483 return xfs_dir2_node_removename(args); 484 default: 485 return error; 486 } 487 } 488 489 /* 490 * Remove an entry from a directory. 491 */ 492 int xfs_dir_removename(struct xfs_trans * tp,struct xfs_inode * dp,const struct xfs_name * name,xfs_ino_t ino,xfs_extlen_t total)493 xfs_dir_removename( 494 struct xfs_trans *tp, 495 struct xfs_inode *dp, 496 const struct xfs_name *name, 497 xfs_ino_t ino, 498 xfs_extlen_t total) /* bmap's total block count */ 499 { 500 struct xfs_da_args *args; 501 int rval; 502 503 ASSERT(S_ISDIR(VFS_I(dp)->i_mode)); 504 XFS_STATS_INC(dp->i_mount, xs_dir_remove); 505 506 args = kzalloc(sizeof(*args), GFP_KERNEL | __GFP_NOFAIL); 507 if (!args) 508 return -ENOMEM; 509 510 args->geo = dp->i_mount->m_dir_geo; 511 args->name = name->name; 512 args->namelen = name->len; 513 args->filetype = name->type; 514 args->hashval = xfs_dir2_hashname(dp->i_mount, name); 515 args->inumber = ino; 516 args->dp = dp; 517 args->total = total; 518 args->whichfork = XFS_DATA_FORK; 519 args->trans = tp; 520 args->owner = dp->i_ino; 521 rval = xfs_dir_removename_args(args); 522 kfree(args); 523 return rval; 524 } 525 526 int xfs_dir_replace_args(struct xfs_da_args * args)527 xfs_dir_replace_args( 528 struct xfs_da_args *args) 529 { 530 int error; 531 532 switch (xfs_dir2_format(args, &error)) { 533 case XFS_DIR2_FMT_SF: 534 return xfs_dir2_sf_replace(args); 535 case XFS_DIR2_FMT_BLOCK: 536 return xfs_dir2_block_replace(args); 537 case XFS_DIR2_FMT_LEAF: 538 return xfs_dir2_leaf_replace(args); 539 case XFS_DIR2_FMT_NODE: 540 return xfs_dir2_node_replace(args); 541 default: 542 return error; 543 } 544 } 545 546 /* 547 * Replace the inode number of a directory entry. 548 */ 549 int xfs_dir_replace(struct xfs_trans * tp,struct xfs_inode * dp,const struct xfs_name * name,xfs_ino_t inum,xfs_extlen_t total)550 xfs_dir_replace( 551 struct xfs_trans *tp, 552 struct xfs_inode *dp, 553 const struct xfs_name *name, /* name of entry to replace */ 554 xfs_ino_t inum, /* new inode number */ 555 xfs_extlen_t total) /* bmap's total block count */ 556 { 557 struct xfs_da_args *args; 558 int rval; 559 560 ASSERT(S_ISDIR(VFS_I(dp)->i_mode)); 561 562 rval = xfs_dir_ino_validate(tp->t_mountp, inum); 563 if (rval) 564 return rval; 565 566 args = kzalloc(sizeof(*args), GFP_KERNEL | __GFP_NOFAIL); 567 if (!args) 568 return -ENOMEM; 569 570 args->geo = dp->i_mount->m_dir_geo; 571 args->name = name->name; 572 args->namelen = name->len; 573 args->filetype = name->type; 574 args->hashval = xfs_dir2_hashname(dp->i_mount, name); 575 args->inumber = inum; 576 args->dp = dp; 577 args->total = total; 578 args->whichfork = XFS_DATA_FORK; 579 args->trans = tp; 580 args->owner = dp->i_ino; 581 rval = xfs_dir_replace_args(args); 582 kfree(args); 583 return rval; 584 } 585 586 /* 587 * See if this entry can be added to the directory without allocating space. 588 */ 589 int xfs_dir_canenter(struct xfs_trans * tp,struct xfs_inode * dp,const struct xfs_name * name)590 xfs_dir_canenter( 591 struct xfs_trans *tp, 592 struct xfs_inode *dp, 593 const struct xfs_name *name) /* name of entry to add */ 594 { 595 return xfs_dir_createname(tp, dp, name, 0, 0); 596 } 597 598 /* 599 * Utility routines. 600 */ 601 602 /* 603 * Add a block to the directory. 604 * 605 * This routine is for data and free blocks, not leaf/node blocks which are 606 * handled by xfs_da_grow_inode. 607 */ 608 int xfs_dir2_grow_inode(struct xfs_da_args * args,int space,xfs_dir2_db_t * dbp)609 xfs_dir2_grow_inode( 610 struct xfs_da_args *args, 611 int space, /* v2 dir's space XFS_DIR2_xxx_SPACE */ 612 xfs_dir2_db_t *dbp) /* out: block number added */ 613 { 614 struct xfs_inode *dp = args->dp; 615 struct xfs_mount *mp = dp->i_mount; 616 xfs_fileoff_t bno; /* directory offset of new block */ 617 int count; /* count of filesystem blocks */ 618 int error; 619 620 trace_xfs_dir2_grow_inode(args, space); 621 622 /* 623 * Set lowest possible block in the space requested. 624 */ 625 bno = XFS_B_TO_FSBT(mp, space * XFS_DIR2_SPACE_SIZE); 626 count = args->geo->fsbcount; 627 628 error = xfs_da_grow_inode_int(args, &bno, count); 629 if (error) 630 return error; 631 632 *dbp = xfs_dir2_da_to_db(args->geo, (xfs_dablk_t)bno); 633 634 /* 635 * Update file's size if this is the data space and it grew. 636 */ 637 if (space == XFS_DIR2_DATA_SPACE) { 638 xfs_fsize_t size; /* directory file (data) size */ 639 640 size = XFS_FSB_TO_B(mp, bno + count); 641 if (size > dp->i_disk_size) { 642 dp->i_disk_size = size; 643 xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE); 644 } 645 } 646 return 0; 647 } 648 649 /* 650 * Remove the given block from the directory. 651 * This routine is used for data and free blocks, leaf/node are done 652 * by xfs_da_shrink_inode. 653 */ 654 int xfs_dir2_shrink_inode(struct xfs_da_args * args,xfs_dir2_db_t db,struct xfs_buf * bp)655 xfs_dir2_shrink_inode( 656 struct xfs_da_args *args, 657 xfs_dir2_db_t db, 658 struct xfs_buf *bp) 659 { 660 xfs_fileoff_t bno; /* directory file offset */ 661 xfs_dablk_t da; /* directory file offset */ 662 int done; /* bunmap is finished */ 663 struct xfs_inode *dp; 664 int error; 665 struct xfs_mount *mp; 666 struct xfs_trans *tp; 667 668 trace_xfs_dir2_shrink_inode(args, db); 669 670 dp = args->dp; 671 mp = dp->i_mount; 672 tp = args->trans; 673 da = xfs_dir2_db_to_da(args->geo, db); 674 675 /* Unmap the fsblock(s). */ 676 error = xfs_bunmapi(tp, dp, da, args->geo->fsbcount, 0, 0, &done); 677 if (error) { 678 /* 679 * ENOSPC actually can happen if we're in a removename with no 680 * space reservation, and the resulting block removal would 681 * cause a bmap btree split or conversion from extents to btree. 682 * This can only happen for un-fragmented directory blocks, 683 * since you need to be punching out the middle of an extent. 684 * In this case we need to leave the block in the file, and not 685 * binval it. So the block has to be in a consistent empty 686 * state and appropriately logged. We don't free up the buffer, 687 * the caller can tell it hasn't happened since it got an error 688 * back. 689 */ 690 return error; 691 } 692 ASSERT(done); 693 /* 694 * Invalidate the buffer from the transaction. 695 */ 696 xfs_trans_binval(tp, bp); 697 /* 698 * If it's not a data block, we're done. 699 */ 700 if (db >= xfs_dir2_byte_to_db(args->geo, XFS_DIR2_LEAF_OFFSET)) 701 return 0; 702 /* 703 * If the block isn't the last one in the directory, we're done. 704 */ 705 if (dp->i_disk_size > xfs_dir2_db_off_to_byte(args->geo, db + 1, 0)) 706 return 0; 707 bno = da; 708 if ((error = xfs_bmap_last_before(tp, dp, &bno, XFS_DATA_FORK))) { 709 /* 710 * This can't really happen unless there's kernel corruption. 711 */ 712 return error; 713 } 714 if (db == args->geo->datablk) 715 ASSERT(bno == 0); 716 else 717 ASSERT(bno > 0); 718 /* 719 * Set the size to the new last block. 720 */ 721 dp->i_disk_size = XFS_FSB_TO_B(mp, bno); 722 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE); 723 return 0; 724 } 725 726 /* Returns true if the directory entry name is valid. */ 727 bool xfs_dir2_namecheck(const void * name,size_t length)728 xfs_dir2_namecheck( 729 const void *name, 730 size_t length) 731 { 732 /* 733 * MAXNAMELEN includes the trailing null, but (name/length) leave it 734 * out, so use >= for the length check. 735 */ 736 if (length >= MAXNAMELEN) 737 return false; 738 739 /* There shouldn't be any slashes or nulls here */ 740 return !memchr(name, '/', length) && !memchr(name, 0, length); 741 } 742 743 xfs_dahash_t xfs_dir2_hashname(struct xfs_mount * mp,const struct xfs_name * name)744 xfs_dir2_hashname( 745 struct xfs_mount *mp, 746 const struct xfs_name *name) 747 { 748 if (unlikely(xfs_has_asciici(mp))) 749 return xfs_ascii_ci_hashname(name); 750 return xfs_da_hashname(name->name, name->len); 751 } 752 753 enum xfs_dacmp xfs_dir2_compname(struct xfs_da_args * args,const unsigned char * name,int len)754 xfs_dir2_compname( 755 struct xfs_da_args *args, 756 const unsigned char *name, 757 int len) 758 { 759 if (unlikely(xfs_has_asciici(args->dp->i_mount))) 760 return xfs_ascii_ci_compname(args, name, len); 761 return xfs_da_compname(args, name, len); 762 } 763 764 #ifdef CONFIG_XFS_LIVE_HOOKS 765 /* 766 * Use a static key here to reduce the overhead of directory live update hooks. 767 * If the compiler supports jump labels, the static branch will be replaced by 768 * a nop sled when there are no hook users. Online fsck is currently the only 769 * caller, so this is a reasonable tradeoff. 770 * 771 * Note: Patching the kernel code requires taking the cpu hotplug lock. Other 772 * parts of the kernel allocate memory with that lock held, which means that 773 * XFS callers cannot hold any locks that might be used by memory reclaim or 774 * writeback when calling the static_branch_{inc,dec} functions. 775 */ 776 DEFINE_STATIC_XFS_HOOK_SWITCH(xfs_dir_hooks_switch); 777 778 void xfs_dir_hook_disable(void)779 xfs_dir_hook_disable(void) 780 { 781 xfs_hooks_switch_off(&xfs_dir_hooks_switch); 782 } 783 784 void xfs_dir_hook_enable(void)785 xfs_dir_hook_enable(void) 786 { 787 xfs_hooks_switch_on(&xfs_dir_hooks_switch); 788 } 789 790 /* Call hooks for a directory update relating to a child dirent update. */ 791 inline void xfs_dir_update_hook(struct xfs_inode * dp,struct xfs_inode * ip,int delta,const struct xfs_name * name)792 xfs_dir_update_hook( 793 struct xfs_inode *dp, 794 struct xfs_inode *ip, 795 int delta, 796 const struct xfs_name *name) 797 { 798 if (xfs_hooks_switched_on(&xfs_dir_hooks_switch)) { 799 struct xfs_dir_update_params p = { 800 .dp = dp, 801 .ip = ip, 802 .delta = delta, 803 .name = name, 804 }; 805 struct xfs_mount *mp = ip->i_mount; 806 807 xfs_hooks_call(&mp->m_dir_update_hooks, 0, &p); 808 } 809 } 810 811 /* Call the specified function during a directory update. */ 812 int xfs_dir_hook_add(struct xfs_mount * mp,struct xfs_dir_hook * hook)813 xfs_dir_hook_add( 814 struct xfs_mount *mp, 815 struct xfs_dir_hook *hook) 816 { 817 return xfs_hooks_add(&mp->m_dir_update_hooks, &hook->dirent_hook); 818 } 819 820 /* Stop calling the specified function during a directory update. */ 821 void xfs_dir_hook_del(struct xfs_mount * mp,struct xfs_dir_hook * hook)822 xfs_dir_hook_del( 823 struct xfs_mount *mp, 824 struct xfs_dir_hook *hook) 825 { 826 xfs_hooks_del(&mp->m_dir_update_hooks, &hook->dirent_hook); 827 } 828 829 /* Configure directory update hook functions. */ 830 void xfs_dir_hook_setup(struct xfs_dir_hook * hook,notifier_fn_t mod_fn)831 xfs_dir_hook_setup( 832 struct xfs_dir_hook *hook, 833 notifier_fn_t mod_fn) 834 { 835 xfs_hook_setup(&hook->dirent_hook, mod_fn); 836 } 837 #endif /* CONFIG_XFS_LIVE_HOOKS */ 838 839 /* 840 * Given a directory @dp, a newly allocated inode @ip, and a @name, link @ip 841 * into @dp under the given @name. If @ip is a directory, it will be 842 * initialized. Both inodes must have the ILOCK held and the transaction must 843 * have sufficient blocks reserved. 844 */ 845 int xfs_dir_create_child(struct xfs_trans * tp,unsigned int resblks,struct xfs_dir_update * du)846 xfs_dir_create_child( 847 struct xfs_trans *tp, 848 unsigned int resblks, 849 struct xfs_dir_update *du) 850 { 851 struct xfs_inode *dp = du->dp; 852 const struct xfs_name *name = du->name; 853 struct xfs_inode *ip = du->ip; 854 int error; 855 856 xfs_assert_ilocked(ip, XFS_ILOCK_EXCL); 857 xfs_assert_ilocked(dp, XFS_ILOCK_EXCL); 858 859 error = xfs_dir_createname(tp, dp, name, ip->i_ino, resblks); 860 if (error) { 861 ASSERT(error != -ENOSPC); 862 return error; 863 } 864 865 xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG); 866 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE); 867 868 if (S_ISDIR(VFS_I(ip)->i_mode)) { 869 error = xfs_dir_init(tp, ip, dp); 870 if (error) 871 return error; 872 873 xfs_bumplink(tp, dp); 874 } 875 876 /* 877 * If we have parent pointers, we need to add the attribute containing 878 * the parent information now. 879 */ 880 if (du->ppargs) { 881 error = xfs_parent_addname(tp, du->ppargs, dp, name, ip); 882 if (error) 883 return error; 884 } 885 886 xfs_dir_update_hook(dp, ip, 1, name); 887 return 0; 888 } 889 890 /* 891 * Given a directory @dp, an existing non-directory inode @ip, and a @name, 892 * link @ip into @dp under the given @name. Both inodes must have the ILOCK 893 * held. 894 */ 895 int xfs_dir_add_child(struct xfs_trans * tp,unsigned int resblks,struct xfs_dir_update * du)896 xfs_dir_add_child( 897 struct xfs_trans *tp, 898 unsigned int resblks, 899 struct xfs_dir_update *du) 900 { 901 struct xfs_inode *dp = du->dp; 902 const struct xfs_name *name = du->name; 903 struct xfs_inode *ip = du->ip; 904 struct xfs_mount *mp = tp->t_mountp; 905 int error; 906 907 xfs_assert_ilocked(ip, XFS_ILOCK_EXCL); 908 xfs_assert_ilocked(dp, XFS_ILOCK_EXCL); 909 ASSERT(!S_ISDIR(VFS_I(ip)->i_mode)); 910 911 if (!resblks) { 912 error = xfs_dir_canenter(tp, dp, name); 913 if (error) 914 return error; 915 } 916 917 /* 918 * Handle initial link state of O_TMPFILE inode 919 */ 920 if (VFS_I(ip)->i_nlink == 0) { 921 struct xfs_perag *pag; 922 923 pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino)); 924 error = xfs_iunlink_remove(tp, pag, ip); 925 xfs_perag_put(pag); 926 if (error) 927 return error; 928 } 929 930 error = xfs_dir_createname(tp, dp, name, ip->i_ino, resblks); 931 if (error) 932 return error; 933 934 xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG); 935 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE); 936 937 xfs_bumplink(tp, ip); 938 939 /* 940 * If we have parent pointers, we now need to add the parent record to 941 * the attribute fork of the inode. If this is the initial parent 942 * attribute, we need to create it correctly, otherwise we can just add 943 * the parent to the inode. 944 */ 945 if (du->ppargs) { 946 error = xfs_parent_addname(tp, du->ppargs, dp, name, ip); 947 if (error) 948 return error; 949 } 950 951 xfs_dir_update_hook(dp, ip, 1, name); 952 return 0; 953 } 954 955 /* 956 * Given a directory @dp, a child @ip, and a @name, remove the (@name, @ip) 957 * entry from the directory. Both inodes must have the ILOCK held. 958 */ 959 int xfs_dir_remove_child(struct xfs_trans * tp,unsigned int resblks,struct xfs_dir_update * du)960 xfs_dir_remove_child( 961 struct xfs_trans *tp, 962 unsigned int resblks, 963 struct xfs_dir_update *du) 964 { 965 struct xfs_inode *dp = du->dp; 966 const struct xfs_name *name = du->name; 967 struct xfs_inode *ip = du->ip; 968 int error; 969 970 xfs_assert_ilocked(ip, XFS_ILOCK_EXCL); 971 xfs_assert_ilocked(dp, XFS_ILOCK_EXCL); 972 973 /* 974 * If we're removing a directory perform some additional validation. 975 */ 976 if (S_ISDIR(VFS_I(ip)->i_mode)) { 977 ASSERT(VFS_I(ip)->i_nlink >= 2); 978 if (VFS_I(ip)->i_nlink != 2) 979 return -ENOTEMPTY; 980 if (!xfs_dir_isempty(ip)) 981 return -ENOTEMPTY; 982 983 /* Drop the link from ip's "..". */ 984 error = xfs_droplink(tp, dp); 985 if (error) 986 return error; 987 988 /* Drop the "." link from ip to self. */ 989 error = xfs_droplink(tp, ip); 990 if (error) 991 return error; 992 993 /* 994 * Point the unlinked child directory's ".." entry to the root 995 * directory to eliminate back-references to inodes that may 996 * get freed before the child directory is closed. If the fs 997 * gets shrunk, this can lead to dirent inode validation errors. 998 */ 999 if (dp->i_ino != tp->t_mountp->m_sb.sb_rootino) { 1000 error = xfs_dir_replace(tp, ip, &xfs_name_dotdot, 1001 tp->t_mountp->m_sb.sb_rootino, 0); 1002 if (error) 1003 return error; 1004 } 1005 } else { 1006 /* 1007 * When removing a non-directory we need to log the parent 1008 * inode here. For a directory this is done implicitly 1009 * by the xfs_droplink call for the ".." entry. 1010 */ 1011 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE); 1012 } 1013 xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG); 1014 1015 /* Drop the link from dp to ip. */ 1016 error = xfs_droplink(tp, ip); 1017 if (error) 1018 return error; 1019 1020 error = xfs_dir_removename(tp, dp, name, ip->i_ino, resblks); 1021 if (error) { 1022 ASSERT(error != -ENOENT); 1023 return error; 1024 } 1025 1026 /* Remove parent pointer. */ 1027 if (du->ppargs) { 1028 error = xfs_parent_removename(tp, du->ppargs, dp, name, ip); 1029 if (error) 1030 return error; 1031 } 1032 1033 xfs_dir_update_hook(dp, ip, -1, name); 1034 return 0; 1035 } 1036 1037 /* 1038 * Exchange the entry (@name1, @ip1) in directory @dp1 with the entry (@name2, 1039 * @ip2) in directory @dp2, and update '..' @ip1 and @ip2's entries as needed. 1040 * @ip1 and @ip2 need not be of the same type. 1041 * 1042 * All inodes must have the ILOCK held, and both entries must already exist. 1043 */ 1044 int xfs_dir_exchange_children(struct xfs_trans * tp,struct xfs_dir_update * du1,struct xfs_dir_update * du2,unsigned int spaceres)1045 xfs_dir_exchange_children( 1046 struct xfs_trans *tp, 1047 struct xfs_dir_update *du1, 1048 struct xfs_dir_update *du2, 1049 unsigned int spaceres) 1050 { 1051 struct xfs_inode *dp1 = du1->dp; 1052 const struct xfs_name *name1 = du1->name; 1053 struct xfs_inode *ip1 = du1->ip; 1054 struct xfs_inode *dp2 = du2->dp; 1055 const struct xfs_name *name2 = du2->name; 1056 struct xfs_inode *ip2 = du2->ip; 1057 int ip1_flags = 0; 1058 int ip2_flags = 0; 1059 int dp2_flags = 0; 1060 int error; 1061 1062 /* Swap inode number for dirent in first parent */ 1063 error = xfs_dir_replace(tp, dp1, name1, ip2->i_ino, spaceres); 1064 if (error) 1065 return error; 1066 1067 /* Swap inode number for dirent in second parent */ 1068 error = xfs_dir_replace(tp, dp2, name2, ip1->i_ino, spaceres); 1069 if (error) 1070 return error; 1071 1072 /* 1073 * If we're renaming one or more directories across different parents, 1074 * update the respective ".." entries (and link counts) to match the new 1075 * parents. 1076 */ 1077 if (dp1 != dp2) { 1078 dp2_flags = XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG; 1079 1080 if (S_ISDIR(VFS_I(ip2)->i_mode)) { 1081 error = xfs_dir_replace(tp, ip2, &xfs_name_dotdot, 1082 dp1->i_ino, spaceres); 1083 if (error) 1084 return error; 1085 1086 /* transfer ip2 ".." reference to dp1 */ 1087 if (!S_ISDIR(VFS_I(ip1)->i_mode)) { 1088 error = xfs_droplink(tp, dp2); 1089 if (error) 1090 return error; 1091 xfs_bumplink(tp, dp1); 1092 } 1093 1094 /* 1095 * Although ip1 isn't changed here, userspace needs 1096 * to be warned about the change, so that applications 1097 * relying on it (like backup ones), will properly 1098 * notify the change 1099 */ 1100 ip1_flags |= XFS_ICHGTIME_CHG; 1101 ip2_flags |= XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG; 1102 } 1103 1104 if (S_ISDIR(VFS_I(ip1)->i_mode)) { 1105 error = xfs_dir_replace(tp, ip1, &xfs_name_dotdot, 1106 dp2->i_ino, spaceres); 1107 if (error) 1108 return error; 1109 1110 /* transfer ip1 ".." reference to dp2 */ 1111 if (!S_ISDIR(VFS_I(ip2)->i_mode)) { 1112 error = xfs_droplink(tp, dp1); 1113 if (error) 1114 return error; 1115 xfs_bumplink(tp, dp2); 1116 } 1117 1118 /* 1119 * Although ip2 isn't changed here, userspace needs 1120 * to be warned about the change, so that applications 1121 * relying on it (like backup ones), will properly 1122 * notify the change 1123 */ 1124 ip1_flags |= XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG; 1125 ip2_flags |= XFS_ICHGTIME_CHG; 1126 } 1127 } 1128 1129 if (ip1_flags) { 1130 xfs_trans_ichgtime(tp, ip1, ip1_flags); 1131 xfs_trans_log_inode(tp, ip1, XFS_ILOG_CORE); 1132 } 1133 if (ip2_flags) { 1134 xfs_trans_ichgtime(tp, ip2, ip2_flags); 1135 xfs_trans_log_inode(tp, ip2, XFS_ILOG_CORE); 1136 } 1137 if (dp2_flags) { 1138 xfs_trans_ichgtime(tp, dp2, dp2_flags); 1139 xfs_trans_log_inode(tp, dp2, XFS_ILOG_CORE); 1140 } 1141 xfs_trans_ichgtime(tp, dp1, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG); 1142 xfs_trans_log_inode(tp, dp1, XFS_ILOG_CORE); 1143 1144 /* Schedule parent pointer replacements */ 1145 if (du1->ppargs) { 1146 error = xfs_parent_replacename(tp, du1->ppargs, dp1, name1, 1147 dp2, name2, ip1); 1148 if (error) 1149 return error; 1150 } 1151 1152 if (du2->ppargs) { 1153 error = xfs_parent_replacename(tp, du2->ppargs, dp2, name2, 1154 dp1, name1, ip2); 1155 if (error) 1156 return error; 1157 } 1158 1159 /* 1160 * Inform our hook clients that we've finished an exchange operation as 1161 * follows: removed the source and target files from their directories; 1162 * added the target to the source directory; and added the source to 1163 * the target directory. All inodes are locked, so it's ok to model a 1164 * rename this way so long as we say we deleted entries before we add 1165 * new ones. 1166 */ 1167 xfs_dir_update_hook(dp1, ip1, -1, name1); 1168 xfs_dir_update_hook(dp2, ip2, -1, name2); 1169 xfs_dir_update_hook(dp1, ip2, 1, name1); 1170 xfs_dir_update_hook(dp2, ip1, 1, name2); 1171 return 0; 1172 } 1173 1174 /* 1175 * Given an entry (@src_name, @src_ip) in directory @src_dp, make the entry 1176 * @target_name in directory @target_dp point to @src_ip and remove the 1177 * original entry, cleaning up everything left behind. 1178 * 1179 * Cleanup involves dropping a link count on @target_ip, and either removing 1180 * the (@src_name, @src_ip) entry from @src_dp or simply replacing the entry 1181 * with (@src_name, @wip) if a whiteout inode @wip is supplied. 1182 * 1183 * All inodes must have the ILOCK held. We assume that if @src_ip is a 1184 * directory then its '..' doesn't already point to @target_dp, and that @wip 1185 * is a freshly allocated whiteout. 1186 */ 1187 int xfs_dir_rename_children(struct xfs_trans * tp,struct xfs_dir_update * du_src,struct xfs_dir_update * du_tgt,unsigned int spaceres,struct xfs_dir_update * du_wip)1188 xfs_dir_rename_children( 1189 struct xfs_trans *tp, 1190 struct xfs_dir_update *du_src, 1191 struct xfs_dir_update *du_tgt, 1192 unsigned int spaceres, 1193 struct xfs_dir_update *du_wip) 1194 { 1195 struct xfs_mount *mp = tp->t_mountp; 1196 struct xfs_inode *src_dp = du_src->dp; 1197 const struct xfs_name *src_name = du_src->name; 1198 struct xfs_inode *src_ip = du_src->ip; 1199 struct xfs_inode *target_dp = du_tgt->dp; 1200 const struct xfs_name *target_name = du_tgt->name; 1201 struct xfs_inode *target_ip = du_tgt->ip; 1202 bool new_parent = (src_dp != target_dp); 1203 bool src_is_directory; 1204 int error; 1205 1206 src_is_directory = S_ISDIR(VFS_I(src_ip)->i_mode); 1207 1208 /* 1209 * Check for expected errors before we dirty the transaction 1210 * so we can return an error without a transaction abort. 1211 */ 1212 if (target_ip == NULL) { 1213 /* 1214 * If there's no space reservation, check the entry will 1215 * fit before actually inserting it. 1216 */ 1217 if (!spaceres) { 1218 error = xfs_dir_canenter(tp, target_dp, target_name); 1219 if (error) 1220 return error; 1221 } 1222 } else { 1223 /* 1224 * If target exists and it's a directory, check that whether 1225 * it can be destroyed. 1226 */ 1227 if (S_ISDIR(VFS_I(target_ip)->i_mode) && 1228 (!xfs_dir_isempty(target_ip) || 1229 (VFS_I(target_ip)->i_nlink > 2))) 1230 return -EEXIST; 1231 } 1232 1233 /* 1234 * Directory entry creation below may acquire the AGF. Remove 1235 * the whiteout from the unlinked list first to preserve correct 1236 * AGI/AGF locking order. This dirties the transaction so failures 1237 * after this point will abort and log recovery will clean up the 1238 * mess. 1239 * 1240 * For whiteouts, we need to bump the link count on the whiteout 1241 * inode. After this point, we have a real link, clear the tmpfile 1242 * state flag from the inode so it doesn't accidentally get misused 1243 * in future. 1244 */ 1245 if (du_wip->ip) { 1246 struct xfs_perag *pag; 1247 1248 ASSERT(VFS_I(du_wip->ip)->i_nlink == 0); 1249 1250 pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, du_wip->ip->i_ino)); 1251 error = xfs_iunlink_remove(tp, pag, du_wip->ip); 1252 xfs_perag_put(pag); 1253 if (error) 1254 return error; 1255 1256 xfs_bumplink(tp, du_wip->ip); 1257 } 1258 1259 /* 1260 * Set up the target. 1261 */ 1262 if (target_ip == NULL) { 1263 /* 1264 * If target does not exist and the rename crosses 1265 * directories, adjust the target directory link count 1266 * to account for the ".." reference from the new entry. 1267 */ 1268 error = xfs_dir_createname(tp, target_dp, target_name, 1269 src_ip->i_ino, spaceres); 1270 if (error) 1271 return error; 1272 1273 xfs_trans_ichgtime(tp, target_dp, 1274 XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG); 1275 1276 if (new_parent && src_is_directory) { 1277 xfs_bumplink(tp, target_dp); 1278 } 1279 } else { /* target_ip != NULL */ 1280 /* 1281 * Link the source inode under the target name. 1282 * If the source inode is a directory and we are moving 1283 * it across directories, its ".." entry will be 1284 * inconsistent until we replace that down below. 1285 * 1286 * In case there is already an entry with the same 1287 * name at the destination directory, remove it first. 1288 */ 1289 error = xfs_dir_replace(tp, target_dp, target_name, 1290 src_ip->i_ino, spaceres); 1291 if (error) 1292 return error; 1293 1294 xfs_trans_ichgtime(tp, target_dp, 1295 XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG); 1296 1297 /* 1298 * Decrement the link count on the target since the target 1299 * dir no longer points to it. 1300 */ 1301 error = xfs_droplink(tp, target_ip); 1302 if (error) 1303 return error; 1304 1305 if (src_is_directory) { 1306 /* 1307 * Drop the link from the old "." entry. 1308 */ 1309 error = xfs_droplink(tp, target_ip); 1310 if (error) 1311 return error; 1312 } 1313 } /* target_ip != NULL */ 1314 1315 /* 1316 * Remove the source. 1317 */ 1318 if (new_parent && src_is_directory) { 1319 /* 1320 * Rewrite the ".." entry to point to the new 1321 * directory. 1322 */ 1323 error = xfs_dir_replace(tp, src_ip, &xfs_name_dotdot, 1324 target_dp->i_ino, spaceres); 1325 ASSERT(error != -EEXIST); 1326 if (error) 1327 return error; 1328 } 1329 1330 /* 1331 * We always want to hit the ctime on the source inode. 1332 * 1333 * This isn't strictly required by the standards since the source 1334 * inode isn't really being changed, but old unix file systems did 1335 * it and some incremental backup programs won't work without it. 1336 */ 1337 xfs_trans_ichgtime(tp, src_ip, XFS_ICHGTIME_CHG); 1338 xfs_trans_log_inode(tp, src_ip, XFS_ILOG_CORE); 1339 1340 /* 1341 * Adjust the link count on src_dp. This is necessary when 1342 * renaming a directory, either within one parent when 1343 * the target existed, or across two parent directories. 1344 */ 1345 if (src_is_directory && (new_parent || target_ip != NULL)) { 1346 1347 /* 1348 * Decrement link count on src_directory since the 1349 * entry that's moved no longer points to it. 1350 */ 1351 error = xfs_droplink(tp, src_dp); 1352 if (error) 1353 return error; 1354 } 1355 1356 /* 1357 * For whiteouts, we only need to update the source dirent with the 1358 * inode number of the whiteout inode rather than removing it 1359 * altogether. 1360 */ 1361 if (du_wip->ip) 1362 error = xfs_dir_replace(tp, src_dp, src_name, du_wip->ip->i_ino, 1363 spaceres); 1364 else 1365 error = xfs_dir_removename(tp, src_dp, src_name, src_ip->i_ino, 1366 spaceres); 1367 if (error) 1368 return error; 1369 1370 xfs_trans_ichgtime(tp, src_dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG); 1371 xfs_trans_log_inode(tp, src_dp, XFS_ILOG_CORE); 1372 if (new_parent) 1373 xfs_trans_log_inode(tp, target_dp, XFS_ILOG_CORE); 1374 1375 /* Schedule parent pointer updates. */ 1376 if (du_wip->ppargs) { 1377 error = xfs_parent_addname(tp, du_wip->ppargs, src_dp, 1378 src_name, du_wip->ip); 1379 if (error) 1380 return error; 1381 } 1382 1383 if (du_src->ppargs) { 1384 error = xfs_parent_replacename(tp, du_src->ppargs, src_dp, 1385 src_name, target_dp, target_name, src_ip); 1386 if (error) 1387 return error; 1388 } 1389 1390 if (du_tgt->ppargs) { 1391 error = xfs_parent_removename(tp, du_tgt->ppargs, target_dp, 1392 target_name, target_ip); 1393 if (error) 1394 return error; 1395 } 1396 1397 /* 1398 * Inform our hook clients that we've finished a rename operation as 1399 * follows: removed the source and target files from their directories; 1400 * that we've added the source to the target directory; and finally 1401 * that we've added the whiteout, if there was one. All inodes are 1402 * locked, so it's ok to model a rename this way so long as we say we 1403 * deleted entries before we add new ones. 1404 */ 1405 if (target_ip) 1406 xfs_dir_update_hook(target_dp, target_ip, -1, target_name); 1407 xfs_dir_update_hook(src_dp, src_ip, -1, src_name); 1408 xfs_dir_update_hook(target_dp, src_ip, 1, target_name); 1409 if (du_wip->ip) 1410 xfs_dir_update_hook(src_dp, du_wip->ip, 1, src_name); 1411 return 0; 1412 } 1413