1 /* 2 * Copyright (c) 2000-2006 Silicon Graphics, Inc. 3 * Copyright (c) 2012-2013 Red Hat, Inc. 4 * All rights reserved. 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License as 8 * published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it would be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 18 */ 19 #include "xfs.h" 20 #include "xfs_fs.h" 21 #include "xfs_types.h" 22 #include "xfs_bit.h" 23 #include "xfs_log.h" 24 #include "xfs_trans.h" 25 #include "xfs_sb.h" 26 #include "xfs_ag.h" 27 #include "xfs_dir2.h" 28 #include "xfs_mount.h" 29 #include "xfs_da_btree.h" 30 #include "xfs_bmap_btree.h" 31 #include "xfs_ialloc_btree.h" 32 #include "xfs_dinode.h" 33 #include "xfs_inode.h" 34 #include "xfs_inode_item.h" 35 #include "xfs_itable.h" 36 #include "xfs_ialloc.h" 37 #include "xfs_alloc.h" 38 #include "xfs_bmap.h" 39 #include "xfs_error.h" 40 #include "xfs_quota.h" 41 #include "xfs_utils.h" 42 #include "xfs_trans_space.h" 43 #include "xfs_log_priv.h" 44 #include "xfs_trace.h" 45 #include "xfs_symlink.h" 46 #include "xfs_cksum.h" 47 #include "xfs_buf_item.h" 48 49 50 /* 51 * Each contiguous block has a header, so it is not just a simple pathlen 52 * to FSB conversion. 53 */ 54 int 55 xfs_symlink_blocks( 56 struct xfs_mount *mp, 57 int pathlen) 58 { 59 int buflen = XFS_SYMLINK_BUF_SPACE(mp, mp->m_sb.sb_blocksize); 60 61 return (pathlen + buflen - 1) / buflen; 62 } 63 64 static int 65 xfs_symlink_hdr_set( 66 struct xfs_mount *mp, 67 xfs_ino_t ino, 68 uint32_t offset, 69 uint32_t size, 70 struct xfs_buf *bp) 71 { 72 struct xfs_dsymlink_hdr *dsl = bp->b_addr; 73 74 if (!xfs_sb_version_hascrc(&mp->m_sb)) 75 return 0; 76 77 dsl->sl_magic = cpu_to_be32(XFS_SYMLINK_MAGIC); 78 dsl->sl_offset = cpu_to_be32(offset); 79 dsl->sl_bytes = cpu_to_be32(size); 80 uuid_copy(&dsl->sl_uuid, &mp->m_sb.sb_uuid); 81 dsl->sl_owner = cpu_to_be64(ino); 82 dsl->sl_blkno = cpu_to_be64(bp->b_bn); 83 bp->b_ops = &xfs_symlink_buf_ops; 84 85 return sizeof(struct xfs_dsymlink_hdr); 86 } 87 88 /* 89 * Checking of the symlink header is split into two parts. the verifier does 90 * CRC, location and bounds checking, the unpacking function checks the path 91 * parameters and owner. 92 */ 93 bool 94 xfs_symlink_hdr_ok( 95 struct xfs_mount *mp, 96 xfs_ino_t ino, 97 uint32_t offset, 98 uint32_t size, 99 struct xfs_buf *bp) 100 { 101 struct xfs_dsymlink_hdr *dsl = bp->b_addr; 102 103 if (offset != be32_to_cpu(dsl->sl_offset)) 104 return false; 105 if (size != be32_to_cpu(dsl->sl_bytes)) 106 return false; 107 if (ino != be64_to_cpu(dsl->sl_owner)) 108 return false; 109 110 /* ok */ 111 return true; 112 } 113 114 static bool 115 xfs_symlink_verify( 116 struct xfs_buf *bp) 117 { 118 struct xfs_mount *mp = bp->b_target->bt_mount; 119 struct xfs_dsymlink_hdr *dsl = bp->b_addr; 120 121 if (!xfs_sb_version_hascrc(&mp->m_sb)) 122 return false; 123 if (dsl->sl_magic != cpu_to_be32(XFS_SYMLINK_MAGIC)) 124 return false; 125 if (!uuid_equal(&dsl->sl_uuid, &mp->m_sb.sb_uuid)) 126 return false; 127 if (bp->b_bn != be64_to_cpu(dsl->sl_blkno)) 128 return false; 129 if (be32_to_cpu(dsl->sl_offset) + 130 be32_to_cpu(dsl->sl_bytes) >= MAXPATHLEN) 131 return false; 132 if (dsl->sl_owner == 0) 133 return false; 134 135 return true; 136 } 137 138 static void 139 xfs_symlink_read_verify( 140 struct xfs_buf *bp) 141 { 142 struct xfs_mount *mp = bp->b_target->bt_mount; 143 144 /* no verification of non-crc buffers */ 145 if (!xfs_sb_version_hascrc(&mp->m_sb)) 146 return; 147 148 if (!xfs_verify_cksum(bp->b_addr, BBTOB(bp->b_length), 149 offsetof(struct xfs_dsymlink_hdr, sl_crc)) || 150 !xfs_symlink_verify(bp)) { 151 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); 152 xfs_buf_ioerror(bp, EFSCORRUPTED); 153 } 154 } 155 156 static void 157 xfs_symlink_write_verify( 158 struct xfs_buf *bp) 159 { 160 struct xfs_mount *mp = bp->b_target->bt_mount; 161 struct xfs_buf_log_item *bip = bp->b_fspriv; 162 163 /* no verification of non-crc buffers */ 164 if (!xfs_sb_version_hascrc(&mp->m_sb)) 165 return; 166 167 if (!xfs_symlink_verify(bp)) { 168 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr); 169 xfs_buf_ioerror(bp, EFSCORRUPTED); 170 return; 171 } 172 173 if (bip) { 174 struct xfs_dsymlink_hdr *dsl = bp->b_addr; 175 dsl->sl_lsn = cpu_to_be64(bip->bli_item.li_lsn); 176 } 177 xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length), 178 offsetof(struct xfs_dsymlink_hdr, sl_crc)); 179 } 180 181 const struct xfs_buf_ops xfs_symlink_buf_ops = { 182 .verify_read = xfs_symlink_read_verify, 183 .verify_write = xfs_symlink_write_verify, 184 }; 185 186 void 187 xfs_symlink_local_to_remote( 188 struct xfs_trans *tp, 189 struct xfs_buf *bp, 190 struct xfs_inode *ip, 191 struct xfs_ifork *ifp) 192 { 193 struct xfs_mount *mp = ip->i_mount; 194 char *buf; 195 196 if (!xfs_sb_version_hascrc(&mp->m_sb)) { 197 bp->b_ops = NULL; 198 memcpy(bp->b_addr, ifp->if_u1.if_data, ifp->if_bytes); 199 return; 200 } 201 202 /* 203 * As this symlink fits in an inode literal area, it must also fit in 204 * the smallest buffer the filesystem supports. 205 */ 206 ASSERT(BBTOB(bp->b_length) >= 207 ifp->if_bytes + sizeof(struct xfs_dsymlink_hdr)); 208 209 bp->b_ops = &xfs_symlink_buf_ops; 210 211 buf = bp->b_addr; 212 buf += xfs_symlink_hdr_set(mp, ip->i_ino, 0, ifp->if_bytes, bp); 213 memcpy(buf, ifp->if_u1.if_data, ifp->if_bytes); 214 } 215 216 /* ----- Kernel only functions below ----- */ 217 STATIC int 218 xfs_readlink_bmap( 219 struct xfs_inode *ip, 220 char *link) 221 { 222 struct xfs_mount *mp = ip->i_mount; 223 struct xfs_bmbt_irec mval[XFS_SYMLINK_MAPS]; 224 struct xfs_buf *bp; 225 xfs_daddr_t d; 226 char *cur_chunk; 227 int pathlen = ip->i_d.di_size; 228 int nmaps = XFS_SYMLINK_MAPS; 229 int byte_cnt; 230 int n; 231 int error = 0; 232 int fsblocks = 0; 233 int offset; 234 235 fsblocks = xfs_symlink_blocks(mp, pathlen); 236 error = xfs_bmapi_read(ip, 0, fsblocks, mval, &nmaps, 0); 237 if (error) 238 goto out; 239 240 offset = 0; 241 for (n = 0; n < nmaps; n++) { 242 d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock); 243 byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount); 244 245 bp = xfs_buf_read(mp->m_ddev_targp, d, BTOBB(byte_cnt), 0, 246 &xfs_symlink_buf_ops); 247 if (!bp) 248 return XFS_ERROR(ENOMEM); 249 error = bp->b_error; 250 if (error) { 251 xfs_buf_ioerror_alert(bp, __func__); 252 xfs_buf_relse(bp); 253 goto out; 254 } 255 byte_cnt = XFS_SYMLINK_BUF_SPACE(mp, byte_cnt); 256 if (pathlen < byte_cnt) 257 byte_cnt = pathlen; 258 259 cur_chunk = bp->b_addr; 260 if (xfs_sb_version_hascrc(&mp->m_sb)) { 261 if (!xfs_symlink_hdr_ok(mp, ip->i_ino, offset, 262 byte_cnt, bp)) { 263 error = EFSCORRUPTED; 264 xfs_alert(mp, 265 "symlink header does not match required off/len/owner (0x%x/Ox%x,0x%llx)", 266 offset, byte_cnt, ip->i_ino); 267 xfs_buf_relse(bp); 268 goto out; 269 270 } 271 272 cur_chunk += sizeof(struct xfs_dsymlink_hdr); 273 } 274 275 memcpy(link + offset, bp->b_addr, byte_cnt); 276 277 pathlen -= byte_cnt; 278 offset += byte_cnt; 279 280 xfs_buf_relse(bp); 281 } 282 ASSERT(pathlen == 0); 283 284 link[ip->i_d.di_size] = '\0'; 285 error = 0; 286 287 out: 288 return error; 289 } 290 291 int 292 xfs_readlink( 293 struct xfs_inode *ip, 294 char *link) 295 { 296 struct xfs_mount *mp = ip->i_mount; 297 xfs_fsize_t pathlen; 298 int error = 0; 299 300 trace_xfs_readlink(ip); 301 302 if (XFS_FORCED_SHUTDOWN(mp)) 303 return XFS_ERROR(EIO); 304 305 xfs_ilock(ip, XFS_ILOCK_SHARED); 306 307 pathlen = ip->i_d.di_size; 308 if (!pathlen) 309 goto out; 310 311 if (pathlen < 0 || pathlen > MAXPATHLEN) { 312 xfs_alert(mp, "%s: inode (%llu) bad symlink length (%lld)", 313 __func__, (unsigned long long) ip->i_ino, 314 (long long) pathlen); 315 ASSERT(0); 316 error = XFS_ERROR(EFSCORRUPTED); 317 goto out; 318 } 319 320 321 if (ip->i_df.if_flags & XFS_IFINLINE) { 322 memcpy(link, ip->i_df.if_u1.if_data, pathlen); 323 link[pathlen] = '\0'; 324 } else { 325 error = xfs_readlink_bmap(ip, link); 326 } 327 328 out: 329 xfs_iunlock(ip, XFS_ILOCK_SHARED); 330 return error; 331 } 332 333 int 334 xfs_symlink( 335 struct xfs_inode *dp, 336 struct xfs_name *link_name, 337 const char *target_path, 338 umode_t mode, 339 struct xfs_inode **ipp) 340 { 341 struct xfs_mount *mp = dp->i_mount; 342 struct xfs_trans *tp = NULL; 343 struct xfs_inode *ip = NULL; 344 int error = 0; 345 int pathlen; 346 struct xfs_bmap_free free_list; 347 xfs_fsblock_t first_block; 348 bool unlock_dp_on_error = false; 349 uint cancel_flags; 350 int committed; 351 xfs_fileoff_t first_fsb; 352 xfs_filblks_t fs_blocks; 353 int nmaps; 354 struct xfs_bmbt_irec mval[XFS_SYMLINK_MAPS]; 355 xfs_daddr_t d; 356 const char *cur_chunk; 357 int byte_cnt; 358 int n; 359 xfs_buf_t *bp; 360 prid_t prid; 361 struct xfs_dquot *udqp = NULL; 362 struct xfs_dquot *gdqp = NULL; 363 struct xfs_dquot *pdqp = NULL; 364 uint resblks; 365 366 *ipp = NULL; 367 368 trace_xfs_symlink(dp, link_name); 369 370 if (XFS_FORCED_SHUTDOWN(mp)) 371 return XFS_ERROR(EIO); 372 373 /* 374 * Check component lengths of the target path name. 375 */ 376 pathlen = strlen(target_path); 377 if (pathlen >= MAXPATHLEN) /* total string too long */ 378 return XFS_ERROR(ENAMETOOLONG); 379 380 udqp = gdqp = NULL; 381 if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) 382 prid = xfs_get_projid(dp); 383 else 384 prid = XFS_PROJID_DEFAULT; 385 386 /* 387 * Make sure that we have allocated dquot(s) on disk. 388 */ 389 error = xfs_qm_vop_dqalloc(dp, current_fsuid(), current_fsgid(), prid, 390 XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT, &udqp, &gdqp, &pdqp); 391 if (error) 392 goto std_return; 393 394 tp = xfs_trans_alloc(mp, XFS_TRANS_SYMLINK); 395 cancel_flags = XFS_TRANS_RELEASE_LOG_RES; 396 /* 397 * The symlink will fit into the inode data fork? 398 * There can't be any attributes so we get the whole variable part. 399 */ 400 if (pathlen <= XFS_LITINO(mp, dp->i_d.di_version)) 401 fs_blocks = 0; 402 else 403 fs_blocks = xfs_symlink_blocks(mp, pathlen); 404 resblks = XFS_SYMLINK_SPACE_RES(mp, link_name->len, fs_blocks); 405 error = xfs_trans_reserve(tp, resblks, XFS_SYMLINK_LOG_RES(mp), 0, 406 XFS_TRANS_PERM_LOG_RES, XFS_SYMLINK_LOG_COUNT); 407 if (error == ENOSPC && fs_blocks == 0) { 408 resblks = 0; 409 error = xfs_trans_reserve(tp, 0, XFS_SYMLINK_LOG_RES(mp), 0, 410 XFS_TRANS_PERM_LOG_RES, XFS_SYMLINK_LOG_COUNT); 411 } 412 if (error) { 413 cancel_flags = 0; 414 goto error_return; 415 } 416 417 xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT); 418 unlock_dp_on_error = true; 419 420 /* 421 * Check whether the directory allows new symlinks or not. 422 */ 423 if (dp->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) { 424 error = XFS_ERROR(EPERM); 425 goto error_return; 426 } 427 428 /* 429 * Reserve disk quota : blocks and inode. 430 */ 431 error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp, 432 pdqp, resblks, 1, 0); 433 if (error) 434 goto error_return; 435 436 /* 437 * Check for ability to enter directory entry, if no space reserved. 438 */ 439 error = xfs_dir_canenter(tp, dp, link_name, resblks); 440 if (error) 441 goto error_return; 442 /* 443 * Initialize the bmap freelist prior to calling either 444 * bmapi or the directory create code. 445 */ 446 xfs_bmap_init(&free_list, &first_block); 447 448 /* 449 * Allocate an inode for the symlink. 450 */ 451 error = xfs_dir_ialloc(&tp, dp, S_IFLNK | (mode & ~S_IFMT), 1, 0, 452 prid, resblks > 0, &ip, NULL); 453 if (error) { 454 if (error == ENOSPC) 455 goto error_return; 456 goto error1; 457 } 458 459 /* 460 * An error after we've joined dp to the transaction will result in the 461 * transaction cancel unlocking dp so don't do it explicitly in the 462 * error path. 463 */ 464 xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL); 465 unlock_dp_on_error = false; 466 467 /* 468 * Also attach the dquot(s) to it, if applicable. 469 */ 470 xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp); 471 472 if (resblks) 473 resblks -= XFS_IALLOC_SPACE_RES(mp); 474 /* 475 * If the symlink will fit into the inode, write it inline. 476 */ 477 if (pathlen <= XFS_IFORK_DSIZE(ip)) { 478 xfs_idata_realloc(ip, pathlen, XFS_DATA_FORK); 479 memcpy(ip->i_df.if_u1.if_data, target_path, pathlen); 480 ip->i_d.di_size = pathlen; 481 482 /* 483 * The inode was initially created in extent format. 484 */ 485 ip->i_df.if_flags &= ~(XFS_IFEXTENTS | XFS_IFBROOT); 486 ip->i_df.if_flags |= XFS_IFINLINE; 487 488 ip->i_d.di_format = XFS_DINODE_FMT_LOCAL; 489 xfs_trans_log_inode(tp, ip, XFS_ILOG_DDATA | XFS_ILOG_CORE); 490 491 } else { 492 int offset; 493 494 first_fsb = 0; 495 nmaps = XFS_SYMLINK_MAPS; 496 497 error = xfs_bmapi_write(tp, ip, first_fsb, fs_blocks, 498 XFS_BMAPI_METADATA, &first_block, resblks, 499 mval, &nmaps, &free_list); 500 if (error) 501 goto error2; 502 503 if (resblks) 504 resblks -= fs_blocks; 505 ip->i_d.di_size = pathlen; 506 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 507 508 cur_chunk = target_path; 509 offset = 0; 510 for (n = 0; n < nmaps; n++) { 511 char *buf; 512 513 d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock); 514 byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount); 515 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d, 516 BTOBB(byte_cnt), 0); 517 if (!bp) { 518 error = ENOMEM; 519 goto error2; 520 } 521 bp->b_ops = &xfs_symlink_buf_ops; 522 523 byte_cnt = XFS_SYMLINK_BUF_SPACE(mp, byte_cnt); 524 byte_cnt = min(byte_cnt, pathlen); 525 526 buf = bp->b_addr; 527 buf += xfs_symlink_hdr_set(mp, ip->i_ino, offset, 528 byte_cnt, bp); 529 530 memcpy(buf, cur_chunk, byte_cnt); 531 532 cur_chunk += byte_cnt; 533 pathlen -= byte_cnt; 534 offset += byte_cnt; 535 536 xfs_trans_log_buf(tp, bp, 0, (buf + byte_cnt - 1) - 537 (char *)bp->b_addr); 538 } 539 ASSERT(pathlen == 0); 540 } 541 542 /* 543 * Create the directory entry for the symlink. 544 */ 545 error = xfs_dir_createname(tp, dp, link_name, ip->i_ino, 546 &first_block, &free_list, resblks); 547 if (error) 548 goto error2; 549 xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG); 550 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE); 551 552 /* 553 * If this is a synchronous mount, make sure that the 554 * symlink transaction goes to disk before returning to 555 * the user. 556 */ 557 if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) { 558 xfs_trans_set_sync(tp); 559 } 560 561 error = xfs_bmap_finish(&tp, &free_list, &committed); 562 if (error) { 563 goto error2; 564 } 565 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES); 566 xfs_qm_dqrele(udqp); 567 xfs_qm_dqrele(gdqp); 568 xfs_qm_dqrele(pdqp); 569 570 *ipp = ip; 571 return 0; 572 573 error2: 574 IRELE(ip); 575 error1: 576 xfs_bmap_cancel(&free_list); 577 cancel_flags |= XFS_TRANS_ABORT; 578 error_return: 579 xfs_trans_cancel(tp, cancel_flags); 580 xfs_qm_dqrele(udqp); 581 xfs_qm_dqrele(gdqp); 582 xfs_qm_dqrele(pdqp); 583 584 if (unlock_dp_on_error) 585 xfs_iunlock(dp, XFS_ILOCK_EXCL); 586 std_return: 587 return error; 588 } 589 590 /* 591 * Free a symlink that has blocks associated with it. 592 */ 593 STATIC int 594 xfs_inactive_symlink_rmt( 595 xfs_inode_t *ip, 596 xfs_trans_t **tpp) 597 { 598 xfs_buf_t *bp; 599 int committed; 600 int done; 601 int error; 602 xfs_fsblock_t first_block; 603 xfs_bmap_free_t free_list; 604 int i; 605 xfs_mount_t *mp; 606 xfs_bmbt_irec_t mval[XFS_SYMLINK_MAPS]; 607 int nmaps; 608 xfs_trans_t *ntp; 609 int size; 610 xfs_trans_t *tp; 611 612 tp = *tpp; 613 mp = ip->i_mount; 614 ASSERT(ip->i_df.if_flags & XFS_IFEXTENTS); 615 /* 616 * We're freeing a symlink that has some 617 * blocks allocated to it. Free the 618 * blocks here. We know that we've got 619 * either 1 or 2 extents and that we can 620 * free them all in one bunmapi call. 621 */ 622 ASSERT(ip->i_d.di_nextents > 0 && ip->i_d.di_nextents <= 2); 623 624 /* 625 * Lock the inode, fix the size, and join it to the transaction. 626 * Hold it so in the normal path, we still have it locked for 627 * the second transaction. In the error paths we need it 628 * held so the cancel won't rele it, see below. 629 */ 630 size = (int)ip->i_d.di_size; 631 ip->i_d.di_size = 0; 632 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 633 /* 634 * Find the block(s) so we can inval and unmap them. 635 */ 636 done = 0; 637 xfs_bmap_init(&free_list, &first_block); 638 nmaps = ARRAY_SIZE(mval); 639 error = xfs_bmapi_read(ip, 0, xfs_symlink_blocks(mp, size), 640 mval, &nmaps, 0); 641 if (error) 642 goto error0; 643 /* 644 * Invalidate the block(s). No validation is done. 645 */ 646 for (i = 0; i < nmaps; i++) { 647 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, 648 XFS_FSB_TO_DADDR(mp, mval[i].br_startblock), 649 XFS_FSB_TO_BB(mp, mval[i].br_blockcount), 0); 650 if (!bp) { 651 error = ENOMEM; 652 goto error1; 653 } 654 xfs_trans_binval(tp, bp); 655 } 656 /* 657 * Unmap the dead block(s) to the free_list. 658 */ 659 if ((error = xfs_bunmapi(tp, ip, 0, size, XFS_BMAPI_METADATA, nmaps, 660 &first_block, &free_list, &done))) 661 goto error1; 662 ASSERT(done); 663 /* 664 * Commit the first transaction. This logs the EFI and the inode. 665 */ 666 if ((error = xfs_bmap_finish(&tp, &free_list, &committed))) 667 goto error1; 668 /* 669 * The transaction must have been committed, since there were 670 * actually extents freed by xfs_bunmapi. See xfs_bmap_finish. 671 * The new tp has the extent freeing and EFDs. 672 */ 673 ASSERT(committed); 674 /* 675 * The first xact was committed, so add the inode to the new one. 676 * Mark it dirty so it will be logged and moved forward in the log as 677 * part of every commit. 678 */ 679 xfs_trans_ijoin(tp, ip, 0); 680 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 681 /* 682 * Get a new, empty transaction to return to our caller. 683 */ 684 ntp = xfs_trans_dup(tp); 685 /* 686 * Commit the transaction containing extent freeing and EFDs. 687 * If we get an error on the commit here or on the reserve below, 688 * we need to unlock the inode since the new transaction doesn't 689 * have the inode attached. 690 */ 691 error = xfs_trans_commit(tp, 0); 692 tp = ntp; 693 if (error) { 694 ASSERT(XFS_FORCED_SHUTDOWN(mp)); 695 goto error0; 696 } 697 /* 698 * transaction commit worked ok so we can drop the extra ticket 699 * reference that we gained in xfs_trans_dup() 700 */ 701 xfs_log_ticket_put(tp->t_ticket); 702 703 /* 704 * Remove the memory for extent descriptions (just bookkeeping). 705 */ 706 if (ip->i_df.if_bytes) 707 xfs_idata_realloc(ip, -ip->i_df.if_bytes, XFS_DATA_FORK); 708 ASSERT(ip->i_df.if_bytes == 0); 709 /* 710 * Put an itruncate log reservation in the new transaction 711 * for our caller. 712 */ 713 if ((error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0, 714 XFS_TRANS_PERM_LOG_RES, XFS_ITRUNCATE_LOG_COUNT))) { 715 ASSERT(XFS_FORCED_SHUTDOWN(mp)); 716 goto error0; 717 } 718 719 xfs_trans_ijoin(tp, ip, 0); 720 *tpp = tp; 721 return 0; 722 723 error1: 724 xfs_bmap_cancel(&free_list); 725 error0: 726 return error; 727 } 728 729 /* 730 * xfs_inactive_symlink - free a symlink 731 */ 732 int 733 xfs_inactive_symlink( 734 struct xfs_inode *ip, 735 struct xfs_trans **tp) 736 { 737 struct xfs_mount *mp = ip->i_mount; 738 int pathlen; 739 740 trace_xfs_inactive_symlink(ip); 741 742 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 743 744 if (XFS_FORCED_SHUTDOWN(mp)) 745 return XFS_ERROR(EIO); 746 747 /* 748 * Zero length symlinks _can_ exist. 749 */ 750 pathlen = (int)ip->i_d.di_size; 751 if (!pathlen) 752 return 0; 753 754 if (pathlen < 0 || pathlen > MAXPATHLEN) { 755 xfs_alert(mp, "%s: inode (0x%llx) bad symlink length (%d)", 756 __func__, (unsigned long long)ip->i_ino, pathlen); 757 ASSERT(0); 758 return XFS_ERROR(EFSCORRUPTED); 759 } 760 761 if (ip->i_df.if_flags & XFS_IFINLINE) { 762 if (ip->i_df.if_bytes > 0) 763 xfs_idata_realloc(ip, -(ip->i_df.if_bytes), 764 XFS_DATA_FORK); 765 ASSERT(ip->i_df.if_bytes == 0); 766 return 0; 767 } 768 769 /* remove the remote symlink */ 770 return xfs_inactive_symlink_rmt(ip, tp); 771 } 772