1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved. 23 */ 24 25 #include <sys/types.h> 26 #include <sys/t_lock.h> 27 #include <sys/param.h> 28 #include <sys/time.h> 29 #include <sys/systm.h> 30 #include <sys/sysmacros.h> 31 #include <sys/resource.h> 32 #include <sys/signal.h> 33 #include <sys/cred.h> 34 #include <sys/user.h> 35 #include <sys/buf.h> 36 #include <sys/vfs.h> 37 #include <sys/stat.h> 38 #include <sys/vnode.h> 39 #include <sys/mode.h> 40 #include <sys/proc.h> 41 #include <sys/disp.h> 42 #include <sys/file.h> 43 #include <sys/fcntl.h> 44 #include <sys/flock.h> 45 #include <sys/kmem.h> 46 #include <sys/uio.h> 47 #include <sys/dnlc.h> 48 #include <sys/conf.h> 49 #include <sys/errno.h> 50 #include <sys/mman.h> 51 #include <sys/fbuf.h> 52 #include <sys/pathname.h> 53 #include <sys/debug.h> 54 #include <sys/vmsystm.h> 55 #include <sys/cmn_err.h> 56 #include <sys/dirent.h> 57 #include <sys/errno.h> 58 #include <sys/modctl.h> 59 #include <sys/statvfs.h> 60 #include <sys/mount.h> 61 #include <sys/sunddi.h> 62 #include <sys/bootconf.h> 63 #include <sys/policy.h> 64 65 #include <vm/hat.h> 66 #include <vm/page.h> 67 #include <vm/pvn.h> 68 #include <vm/as.h> 69 #include <vm/seg.h> 70 #include <vm/seg_map.h> 71 #include <vm/seg_kmem.h> 72 #include <vm/seg_vn.h> 73 #include <vm/rm.h> 74 #include <vm/page.h> 75 #include <sys/swap.h> 76 77 78 #include <fs/fs_subr.h> 79 80 81 #include <sys/fs/udf_volume.h> 82 #include <sys/fs/udf_inode.h> 83 84 85 struct slot { 86 enum {NONE, COMPACT, FOUND, EXIST} status; 87 off_t offset; /* offset of area with free space */ 88 int size; /* size of area at slotoffset */ 89 struct fbuf *fbp; /* dir buf where slot is */ 90 struct file_id *ep; /* pointer to slot */ 91 off_t endoff; /* last useful location found in search */ 92 }; 93 94 95 int32_t ud_dircheckforname(struct ud_inode *, char *, int, 96 struct slot *, struct ud_inode **, uint8_t *, struct cred *); 97 int32_t ud_dirempty(struct ud_inode *, uint64_t, struct cred *); 98 int32_t str2cmp(char *, int32_t, char *, int32_t, char *, int32_t); 99 int32_t ud_dircheckpath(int32_t, struct ud_inode *, struct cred *); 100 int32_t ud_dirmakeinode(struct ud_inode *, struct ud_inode **, 101 struct vattr *, enum de_op, struct cred *); 102 int32_t ud_diraddentry(struct ud_inode *, char *, 103 enum de_op, int, struct slot *, struct ud_inode *, 104 struct ud_inode *, struct cred *); 105 int32_t ud_dirmakedirect(struct ud_inode *, struct ud_inode *, struct cred *); 106 int32_t ud_dirrename(struct ud_inode *, struct ud_inode *, 107 struct ud_inode *, struct ud_inode *, char *, uint8_t *, 108 struct slot *, struct cred *); 109 int32_t ud_dirprepareentry(struct ud_inode *, 110 struct slot *, uint8_t *, struct cred *); 111 int32_t ud_dirfixdotdot(struct ud_inode *, struct ud_inode *, 112 struct ud_inode *); 113 int32_t ud_write_fid(struct ud_inode *, struct slot *, uint8_t *); 114 115 int 116 ud_dirlook(struct ud_inode *dip, 117 char *namep, struct ud_inode **ipp, struct cred *cr, int32_t skipdnlc) 118 { 119 struct udf_vfs *udf_vfsp; 120 int32_t error = 0, namelen, adhoc_search; 121 u_offset_t offset, adhoc_offset, dirsize, end; 122 struct vnode *dvp, *vp; 123 struct fbuf *fbp; 124 struct file_id *fid; 125 uint8_t *fname, dummy[3]; 126 int32_t id_len, doingchk; 127 uint32_t old_loc; 128 uint16_t old_prn; 129 130 uint8_t *dname; 131 uint8_t *buf = NULL; 132 133 ud_printf("ud_dirlook\n"); 134 135 udf_vfsp = dip->i_udf; 136 137 restart: 138 doingchk = 0; 139 old_prn = 0xFFFF; 140 old_loc = 0; 141 dvp = ITOV(dip); 142 /* 143 * Check accessibility of directory. 144 */ 145 if (dip->i_type != VDIR) { 146 return (ENOTDIR); 147 } 148 if (error = ud_iaccess(dip, IEXEC, cr, 1)) { 149 return (error); 150 } 151 152 /* 153 * Null component name is synonym for directory being searched. 154 */ 155 if (*namep == '\0') { 156 VN_HOLD(dvp); 157 *ipp = dip; 158 return (0); 159 } 160 namelen = strlen(namep); 161 if ((namelen == 1) && 162 (namep[0] == '.') && (namep[1] == '\0')) { 163 /* Current directory */ 164 VN_HOLD(dvp); 165 *ipp = dip; 166 dnlc_enter(dvp, namep, ITOV(*ipp)); 167 return (0); 168 } 169 170 if ((!skipdnlc) && (vp = dnlc_lookup(dvp, namep))) { 171 /* vp is already held from dnlc_lookup */ 172 173 *ipp = VTOI(vp); 174 return (0); 175 } 176 177 dname = kmem_zalloc(1024, KM_SLEEP); 178 buf = kmem_zalloc(udf_vfsp->udf_lbsize, KM_SLEEP); 179 180 /* 181 * Read lock the inode we are searching. You will notice that we 182 * didn't hold the read lock while searching the dnlc. This means 183 * that the entry could now be in the dnlc. This doesn't cause any 184 * problems because dnlc_enter won't add an entry if it is already 185 * there. 186 */ 187 rw_enter(&dip->i_rwlock, RW_READER); 188 189 /* 190 * Take care to look at dip->i_diroff only once, as it 191 * may be changing due to other threads/cpus. 192 */ 193 194 recheck: 195 offset = dip->i_diroff; 196 end = dirsize = dip->i_size; 197 198 if (offset > dirsize) { 199 offset = 0; 200 } 201 adhoc_offset = offset; 202 adhoc_search = (offset == 0) ? 1 : 2; 203 204 fbp = NULL; 205 206 while (adhoc_search--) { 207 while (offset < end) { 208 error = ud_get_next_fid(dip, &fbp, 209 offset, &fid, &fname, buf); 210 if (error != 0) { 211 break; 212 } 213 if ((fid->fid_flags & FID_DELETED) == 0) { 214 if (fid->fid_flags & FID_PARENT) { 215 id_len = 2; 216 fname = dummy; 217 dummy[0] = '.'; 218 dummy[1] = '.'; 219 dummy[2] = '\0'; 220 } else { 221 if ((error = ud_uncompress( 222 fid->fid_idlen, &id_len, 223 fname, dname)) != 0) { 224 break; 225 } 226 fname = (uint8_t *)dname; 227 fname[id_len] = '\0'; 228 } 229 if ((namelen == id_len) && 230 (strncmp(namep, (caddr_t)fname, 231 namelen) == 0)) { 232 uint32_t loc; 233 uint16_t prn; 234 235 236 loc = SWAP_32(fid->fid_icb.lad_ext_loc); 237 prn = SWAP_16(fid->fid_icb.lad_ext_prn); 238 dip->i_diroff = offset + FID_LEN(fid); 239 240 if (doingchk) { 241 if ((loc == old_loc) && 242 (prn == old_prn)) { 243 goto checkok; 244 } else { 245 if (fbp != NULL) { 246 fbrelse(fbp, 247 S_READ); 248 fbp = NULL; 249 } 250 VN_RELE(ITOV(*ipp)); 251 rw_exit(&dip->i_rwlock); 252 goto restart; 253 } 254 /* NOTREACHED */ 255 } 256 257 if (namelen == 2 && 258 fname[0] == '.' && 259 fname[1] == '.') { 260 261 struct timespec32 omtime; 262 263 omtime = dip->i_mtime; 264 rw_exit(&dip->i_rwlock); 265 266 error = ud_iget(dip->i_vfs, prn, 267 loc, ipp, NULL, cr); 268 269 rw_enter(&dip->i_rwlock, 270 RW_READER); 271 272 if (error) { 273 goto done; 274 } 275 276 if ((omtime.tv_sec != 277 dip->i_mtime.tv_sec) || 278 (omtime.tv_nsec != 279 dip->i_mtime.tv_nsec)) { 280 281 doingchk = 1; 282 old_prn = prn; 283 old_loc = loc; 284 dip->i_diroff = 0; 285 if (fbp != NULL) { 286 fbrelse(fbp, 287 S_READ); 288 fbp = NULL; 289 } 290 goto recheck; 291 } 292 } else { 293 294 error = ud_iget(dip->i_vfs, prn, 295 loc, ipp, NULL, cr); 296 } 297 checkok: 298 if (error == 0) { 299 dnlc_enter(dvp, namep, 300 ITOV(*ipp)); 301 } 302 goto done; 303 } 304 } 305 offset += FID_LEN(fid); 306 } 307 if (fbp != NULL) { 308 fbrelse(fbp, S_READ); 309 fbp = NULL; 310 } 311 end = adhoc_offset; 312 offset = 0; 313 } 314 error = ENOENT; 315 done: 316 kmem_free(buf, udf_vfsp->udf_lbsize); 317 kmem_free(dname, 1024); 318 if (fbp != NULL) { 319 fbrelse(fbp, S_READ); 320 } 321 rw_exit(&dip->i_rwlock); 322 return (error); 323 } 324 325 int 326 ud_direnter( 327 struct ud_inode *tdp, 328 char *namep, 329 enum de_op op, 330 struct ud_inode *sdp, 331 struct ud_inode *sip, 332 struct vattr *vap, 333 struct ud_inode **ipp, 334 struct cred *cr, 335 caller_context_t *ctp) 336 { 337 struct udf_vfs *udf_vfsp; 338 struct ud_inode *tip; 339 struct slot slot; 340 int32_t namlen, err; 341 char *s; 342 343 uint8_t *buf = NULL; 344 345 ud_printf("ud_direnter\n"); 346 347 udf_vfsp = tdp->i_udf; 348 /* don't allow '/' characters in pathname component */ 349 for (s = namep, namlen = 0; *s; s++, namlen++) { 350 if (*s == '/') { 351 return (EACCES); 352 } 353 } 354 355 if (namlen == 0) { 356 cmn_err(CE_WARN, "name length == 0 in ud_direnter"); 357 return (EINVAL); 358 } 359 360 ASSERT(RW_WRITE_HELD(&tdp->i_rwlock)); 361 /* 362 * If name is "." or ".." then if this is a create look it up 363 * and return EEXIST. Rename or link TO "." or ".." is forbidden. 364 */ 365 if (namep[0] == '.' && 366 (namlen == 1 || (namlen == 2 && namep[1] == '.'))) { 367 if (op == DE_RENAME) { 368 return (EINVAL); /* *SIGH* should be ENOTEMPTY */ 369 } 370 if (ipp) { 371 /* 372 * ud_dirlook will acquire the i_rwlock 373 */ 374 rw_exit(&tdp->i_rwlock); 375 if (err = ud_dirlook(tdp, namep, ipp, cr, 0)) { 376 rw_enter(&tdp->i_rwlock, RW_WRITER); 377 return (err); 378 } 379 rw_enter(&tdp->i_rwlock, RW_WRITER); 380 } 381 return (EEXIST); 382 } 383 384 tip = NULL; 385 slot.status = NONE; 386 slot.offset = 0; 387 slot.size = 0; 388 slot.fbp = NULL; 389 slot.ep = NULL; 390 slot.endoff = 0; 391 392 /* 393 * For link and rename lock the source entry and check the link count 394 * to see if it has been removed while it was unlocked. If not, we 395 * increment the link count and force the inode to disk to make sure 396 * that it is there before any directory entry that points to it. 397 */ 398 if (op == DE_LINK || op == DE_RENAME) { 399 rw_enter(&sip->i_contents, RW_WRITER); 400 if (sip->i_nlink == 0) { 401 rw_exit(&sip->i_contents); 402 return (ENOENT); 403 } 404 if (sip->i_nlink == MAXLINK) { 405 rw_exit(&sip->i_contents); 406 return (EMLINK); 407 } 408 409 sip->i_nlink++; 410 mutex_enter(&sip->i_tlock); 411 sip->i_flag |= ICHG; 412 mutex_exit(&sip->i_tlock); 413 ud_iupdat(sip, 1); 414 rw_exit(&sip->i_contents); 415 } 416 /* 417 * If target directory has not been removed, then we can consider 418 * allowing file to be created. 419 */ 420 if (tdp->i_nlink == 0) { 421 err = ENOENT; 422 goto out2; 423 } 424 /* 425 * Check accessibility of directory. 426 */ 427 if (tdp->i_type != VDIR) { 428 err = ENOTDIR; 429 goto out2; 430 } 431 /* 432 * Execute access is required to search the directory. 433 */ 434 if (err = ud_iaccess(tdp, IEXEC, cr, 1)) { 435 goto out2; 436 } 437 /* 438 * If this is a rename of a directory and the parent is 439 * different (".." must be changed), then the source 440 * directory must not be in the directory hierarchy 441 * above the target, as this would orphan everything 442 * below the source directory. Also the user must have 443 * write permission in the source so as to be able to 444 * change "..". 445 */ 446 if (op == DE_RENAME) { 447 if (sip == tdp) { 448 err = EINVAL; 449 goto out2; 450 } 451 rw_enter(&sip->i_contents, RW_READER); 452 if ((sip->i_type == VDIR) && (sdp != tdp)) { 453 uint32_t blkno; 454 455 if ((err = ud_iaccess(sip, IWRITE, cr, 0))) { 456 rw_exit(&sip->i_contents); 457 goto out2; 458 } 459 blkno = sip->i_icb_lbano; 460 rw_exit(&sip->i_contents); 461 if ((err = ud_dircheckpath(blkno, tdp, cr))) { 462 goto out2; 463 } 464 } else { 465 rw_exit(&sip->i_contents); 466 } 467 } 468 469 /* 470 * Search for the entry. Return VN_HELD tip if found. 471 */ 472 buf = kmem_zalloc(udf_vfsp->udf_lbsize, KM_SLEEP); 473 rw_enter(&tdp->i_contents, RW_WRITER); 474 if (err = ud_dircheckforname(tdp, 475 namep, namlen, &slot, &tip, buf, cr)) { 476 goto out; 477 } 478 if (tip) { 479 switch (op) { 480 case DE_CREATE : 481 case DE_MKDIR : 482 if (ipp) { 483 *ipp = tip; 484 err = EEXIST; 485 } else { 486 VN_RELE(ITOV(tip)); 487 } 488 break; 489 case DE_RENAME : 490 err = ud_dirrename(sdp, sip, tdp, tip, 491 namep, buf, &slot, cr); 492 /* 493 * We used to VN_RELE() here, but this 494 * was moved down so that we could send 495 * a vnevent after the locks were dropped. 496 */ 497 break; 498 case DE_LINK : 499 /* 500 * Can't link to an existing file. 501 */ 502 VN_RELE(ITOV(tip)); 503 err = EEXIST; 504 break; 505 } 506 } else { 507 /* 508 * The entry does not exist. Check write permission in 509 * directory to see if entry can be created. 510 */ 511 if (err = ud_iaccess(tdp, IWRITE, cr, 0)) { 512 goto out; 513 } 514 if ((op == DE_CREATE) || (op == DE_MKDIR)) { 515 /* 516 * Make new inode and directory entry as required. 517 */ 518 if (err = ud_dirmakeinode(tdp, &sip, vap, op, cr)) 519 goto out; 520 } 521 if (err = ud_diraddentry(tdp, namep, op, 522 namlen, &slot, sip, sdp, cr)) { 523 if ((op == DE_CREATE) || (op == DE_MKDIR)) { 524 /* 525 * Unmake the inode we just made. 526 */ 527 rw_enter(&sip->i_contents, RW_WRITER); 528 if (sip->i_type == VDIR) { 529 tdp->i_nlink--; 530 } 531 sip->i_nlink = 0; 532 mutex_enter(&sip->i_tlock); 533 sip->i_flag |= ICHG; 534 mutex_exit(&sip->i_tlock); 535 rw_exit(&sip->i_contents); 536 VN_RELE(ITOV(sip)); 537 sip = NULL; 538 } 539 } else if (ipp) { 540 *ipp = sip; 541 } else if ((op == DE_CREATE) || (op == DE_MKDIR)) { 542 VN_RELE(ITOV(sip)); 543 } 544 } 545 out: 546 if (buf != NULL) { 547 kmem_free(buf, udf_vfsp->udf_lbsize); 548 } 549 if (slot.fbp) { 550 fbrelse(slot.fbp, S_OTHER); 551 } 552 rw_exit(&tdp->i_contents); 553 554 if (op == DE_RENAME) { 555 /* 556 * If it's all good, send events after locks are dropped 557 * but before vnodes are released. 558 */ 559 if (err == 0) { 560 if (tip) { 561 vnevent_rename_dest(ITOV(tip), ITOV(tdp), 562 namep, ctp); 563 } 564 565 if (sdp != tdp) { 566 vnevent_rename_dest_dir(ITOV(tdp), ctp); 567 } 568 } 569 570 /* 571 * The following VN_RELE() was moved from the 572 * DE_RENAME case above 573 */ 574 if (tip) { 575 VN_RELE(ITOV(tip)); 576 } 577 } 578 579 out2: 580 if (err && ((op == DE_LINK) || (op == DE_RENAME))) { 581 /* 582 * Undo bumped link count. 583 */ 584 rw_enter(&sip->i_contents, RW_WRITER); 585 sip->i_nlink--; 586 rw_exit(&sip->i_contents); 587 588 mutex_enter(&sip->i_tlock); 589 sip->i_flag |= ICHG; 590 mutex_exit(&sip->i_tlock); 591 } 592 return (err); 593 } 594 595 /* 596 * Locking i_contents in this 597 * function seems to be really weird 598 */ 599 int 600 ud_dirremove( 601 struct ud_inode *dp, 602 char *namep, 603 struct ud_inode *oip, 604 struct vnode *cdir, 605 enum dr_op op, 606 struct cred *cr, 607 caller_context_t *ctp) 608 { 609 struct udf_vfs *udf_vfsp; 610 int32_t namelen, err = 0; 611 struct slot slot; 612 struct ud_inode *ip; 613 mode_t mode; 614 struct file_id *fid; 615 uint8_t *buf = NULL; 616 uint32_t tbno; 617 618 ud_printf("ud_dirremove\n"); 619 620 ASSERT(RW_WRITE_HELD(&dp->i_rwlock)); 621 622 udf_vfsp = dp->i_udf; 623 namelen = (int)strlen(namep); 624 if (namelen == 0) { 625 cmn_err(CE_WARN, "name length == 0 in ud_dirremove"); 626 return (EINVAL); 627 } 628 629 /* 630 * return err when removing . and .. 631 */ 632 if (namep[0] == '.') { 633 if (namelen == 1) { 634 return (EINVAL); 635 } else if (namelen == 2 && namep[1] == '.') { 636 return (EEXIST); /* SIGH should be ENOTEMPTY */ 637 } 638 } 639 640 ASSERT(RW_WRITE_HELD(&dp->i_rwlock)); 641 642 /* 643 * Check accessibility of directory. 644 */ 645 if (dp->i_type != VDIR) { 646 return (ENOTDIR); 647 } 648 649 ip = NULL; 650 slot.status = FOUND; /* don't need to look for empty slot */ 651 slot.offset = 0; 652 slot.size = 0; 653 slot.fbp = NULL; 654 slot.ep = NULL; 655 slot.endoff = 0; 656 /* 657 * Execute access is required to search the directory. 658 * Access for write is interpreted as allowing 659 * deletion of files in the directory. 660 */ 661 if (err = ud_iaccess(dp, IEXEC|IWRITE, cr, 1)) { 662 return (err); 663 } 664 665 buf = (uint8_t *)kmem_zalloc(udf_vfsp->udf_lbsize, KM_SLEEP); 666 667 rw_enter(&dp->i_contents, RW_WRITER); 668 669 if (err = ud_dircheckforname(dp, namep, namelen, &slot, &ip, 670 buf, cr)) { 671 goto out_novfs; 672 } 673 if (ip == NULL) { 674 err = ENOENT; 675 goto out_novfs; 676 } 677 if (oip && oip != ip) { 678 err = ENOENT; 679 goto out_novfs; 680 } 681 682 if ((mode = ip->i_type) == VDIR) { 683 /* 684 * vn_vfswlock() prevents races between mount and rmdir. 685 */ 686 if (vn_vfswlock(ITOV(ip))) { 687 err = EBUSY; 688 goto out_novfs; 689 } 690 if (vn_mountedvfs(ITOV(ip)) != NULL && op != DR_RENAME) { 691 err = EBUSY; 692 goto out; 693 } 694 /* 695 * If we are removing a directory, get a lock on it. 696 * If the directory is empty, it will stay empty until 697 * we can remove it. 698 */ 699 rw_enter(&ip->i_rwlock, RW_READER); 700 } 701 /* We must be holding i_contents */ 702 rw_enter(&ip->i_contents, RW_READER); 703 704 if (err = ud_sticky_remove_access(dp, ip, cr)) { 705 rw_exit(&ip->i_contents); 706 if (mode == VDIR) { 707 rw_exit(&ip->i_rwlock); 708 } 709 goto out; 710 } 711 if (op == DR_RMDIR) { 712 /* 713 * For rmdir(2), some special checks are required. 714 * (a) Don't remove any alias of the parent (e.g. "."). 715 * (b) Don't remove the current directory. 716 * (c) Make sure the entry is (still) a directory. 717 * (d) Make sure the directory is empty. 718 */ 719 720 if (dp == ip || ITOV(ip) == cdir) { 721 err = EINVAL; 722 } else if (ip->i_type != VDIR) { 723 err = ENOTDIR; 724 } else if ((ip->i_nlink != 1) || 725 (!ud_dirempty(ip, dp->i_uniqid, cr))) { 726 /* 727 * Directories do not have an 728 * entry for "." so only one link 729 * will be there 730 */ 731 err = EEXIST; /* SIGH should be ENOTEMPTY */ 732 } 733 if (err) { 734 rw_exit(&ip->i_contents); 735 if (mode == VDIR) { 736 rw_exit(&ip->i_rwlock); 737 } 738 goto out; 739 } 740 } else if (op == DR_REMOVE) { 741 /* 742 * unlink(2) requires a different check: allow only 743 * privileged processes to unlink a directory. 744 */ 745 struct vnode *vp = ITOV(ip); 746 747 if (vp->v_type == VDIR && 748 secpolicy_fs_linkdir(cr, vp->v_vfsp)) { 749 err = EPERM; 750 rw_exit(&ip->i_contents); 751 rw_exit(&ip->i_rwlock); 752 goto out; 753 } 754 } 755 rw_exit(&ip->i_contents); 756 757 /* 758 * Remove the cache'd entry, if any. 759 */ 760 dnlc_remove(ITOV(dp), namep); 761 762 /* 763 * We can collapse all the directory 764 * entries that are deleted into one big entry 765 * but the better way is to 766 * defer it till next directory entry 767 * creation. where we can do this 768 * in a more efficient way 769 */ 770 fid = slot.ep; 771 772 /* 773 * If this is the last entry 774 * just truncate the file instead 775 * of marking it deleted 776 */ 777 if ((slot.offset + FID_LEN(fid)) == dp->i_size) { 778 fbrelse(slot.fbp, S_OTHER); 779 if ((err = ud_itrunc(dp, slot.offset, 0, cr)) != 0) { 780 goto out; 781 } 782 } else { 783 fid->fid_flags |= FID_DELETED; 784 785 if ((err = ud_ip_off2bno(dp, slot.offset, &tbno)) != 0) { 786 goto out; 787 } 788 789 ud_make_tag(dp->i_udf, &fid->fid_tag, 790 UD_FILE_ID_DESC, tbno, FID_LEN(fid)); 791 792 err = ud_write_fid(dp, &slot, buf); 793 } 794 795 slot.fbp = NULL; 796 797 /* 798 * If we were removing a directory, it is 'gone' now so we can 799 * unlock it. 800 */ 801 if (mode == VDIR) { 802 rw_exit(&ip->i_rwlock); 803 } 804 805 mutex_enter(&dp->i_tlock); 806 dp->i_flag |= IUPD|ICHG; 807 mutex_exit(&dp->i_tlock); 808 mutex_enter(&ip->i_tlock); 809 ip->i_flag |= ICHG; 810 mutex_exit(&ip->i_tlock); 811 812 if (err != 0) { 813 goto out; 814 } 815 816 rw_enter(&ip->i_contents, RW_WRITER); 817 818 /* 819 * Now dispose of the inode. 820 */ 821 if (ip->i_nlink > 0) { 822 if ((op == DR_RMDIR) && (ip->i_type == VDIR)) { 823 /* 824 * Decrement by 1 because there is no "." 825 * Clear the inode, but there may be other hard 826 * links so don't free the inode. 827 * Decrement the dp linkcount because we're 828 * trashing the ".." entry. 829 */ 830 ip->i_nlink --; 831 dp->i_nlink--; 832 dnlc_remove(ITOV(ip), "."); 833 dnlc_remove(ITOV(ip), ".."); 834 /* 835 * (void) ud_itrunc(ip, 0, 0, cr); 836 */ 837 } else { 838 ip->i_nlink--; 839 } 840 } 841 ITIMES_NOLOCK(dp); 842 ITIMES_NOLOCK(ip); 843 rw_exit(&ip->i_contents); 844 out: 845 if (mode == VDIR) { 846 vn_vfsunlock(ITOV(ip)); 847 } 848 out_novfs: 849 ASSERT(RW_WRITE_HELD(&dp->i_contents)); 850 851 if (slot.fbp != NULL) { 852 fbrelse(slot.fbp, S_OTHER); 853 } 854 rw_exit(&dp->i_contents); 855 856 if (ip) { 857 /* 858 * If no errors, send any events after locks are dropped, 859 * but before the VN_RELE(). 860 */ 861 if (err == 0) { 862 if (op == DR_REMOVE) { 863 vnevent_remove(ITOV(ip), ITOV(dp), namep, ctp); 864 } else if (op == DR_RMDIR) { 865 vnevent_rmdir(ITOV(ip), ITOV(dp), namep, ctp); 866 } 867 } 868 VN_RELE(ITOV(ip)); 869 } 870 871 kmem_free(buf, udf_vfsp->udf_lbsize); 872 return (err); 873 } 874 875 int 876 ud_dircheckforname(struct ud_inode *tdp, 877 char *namep, int32_t namelen, struct slot *slotp, 878 struct ud_inode **ipp, uint8_t *buf, struct cred *cr) 879 { 880 struct udf_vfs *udf_vfsp; 881 uint32_t dirsize, offset; 882 struct fbuf *fbp; 883 struct file_id *fid; 884 int32_t sz, error = 0, sz_req, matched = 0; 885 uint8_t *nm; 886 887 uint8_t *dname; 888 int32_t id_len; 889 890 ud_printf("ud_dircheckforname\n"); 891 892 ASSERT(RW_WRITE_HELD(&tdp->i_rwlock)); 893 fbp = NULL; 894 895 dname = (uint8_t *)kmem_zalloc(1024, KM_SLEEP); 896 897 udf_vfsp = tdp->i_udf; 898 899 offset = 0; 900 dirsize = tdp->i_size; 901 902 if (slotp->status != FOUND) { 903 int32_t temp; 904 905 temp = 1024; /* set to size of dname allocated above */ 906 if ((error = ud_compress(namelen, &temp, 907 (uint8_t *)namep, dname)) != 0) { 908 goto end; 909 } 910 sz_req = F_LEN + temp; 911 sz_req = (sz_req + 3) & ~3; 912 } 913 914 while (offset < dirsize) { 915 if ((error = ud_get_next_fid(tdp, &fbp, 916 offset, &fid, &nm, buf)) != 0) { 917 break; 918 } 919 if ((error = ud_uncompress(fid->fid_idlen, 920 &id_len, nm, dname)) != 0) { 921 break; 922 } 923 if ((fid->fid_flags & FID_DELETED) == 0) { 924 /* Check for name match */ 925 if (((namelen == id_len) && 926 (strncmp(namep, (caddr_t)dname, namelen) == 0)) || 927 ((fid->fid_flags & FID_PARENT) && 928 (namep[0] == '.' && 929 (namelen == 1 || 930 (namelen == 2 && namep[1] == '.'))))) { 931 932 tdp->i_diroff = offset; 933 if ((fid->fid_flags & FID_PARENT) && 934 (namelen == 1) && (namep[0] == '.')) { 935 struct vnode *vp = ITOV(tdp); 936 937 *ipp = tdp; 938 VN_HOLD(vp); 939 } else { 940 uint16_t prn; 941 uint32_t loc; 942 943 prn = SWAP_16(fid->fid_icb.lad_ext_prn); 944 loc = SWAP_32(fid->fid_icb.lad_ext_loc); 945 if ((error = ud_iget(tdp->i_vfs, prn, 946 loc, ipp, NULL, cr)) != 0) { 947 948 fbrelse(fbp, S_OTHER); 949 goto end; 950 } 951 } 952 slotp->status = EXIST; 953 slotp->offset = offset; 954 slotp->size = FID_LEN(fid); 955 slotp->fbp = fbp; 956 slotp->ep = fid; 957 slotp->endoff = 0; 958 goto end; 959 } 960 } else { 961 /* 962 * see if we need to find an 963 * empty slot and the current slot 964 * matches 965 */ 966 if ((slotp->status != FOUND) || (matched == 0)) { 967 sz = FID_LEN(fid); 968 if (sz == sz_req) { 969 slotp->status = FOUND; 970 slotp->offset = offset; 971 slotp->size = sz; 972 } 973 if (matched == 0) { 974 if ((namelen == id_len) && 975 (strncmp(namep, (caddr_t)dname, 976 namelen) == 0)) { 977 matched = 1; 978 slotp->status = FOUND; 979 slotp->offset = offset; 980 slotp->size = sz; 981 } 982 } 983 } 984 } 985 offset += FID_LEN(fid); 986 } 987 if (fbp) { 988 fbrelse(fbp, S_OTHER); 989 } 990 if (slotp->status == NONE) { 991 /* 992 * We didn't find a slot; the new directory entry should be put 993 * at the end of the directory. Return an indication of where 994 * this is, and set "endoff" to zero; since we're going to have 995 * to extend the directory, we're certainly not going to 996 * trucate it. 997 */ 998 slotp->offset = dirsize; 999 if (tdp->i_desc_type == ICB_FLAG_ONE_AD) { 1000 slotp->size = tdp->i_max_emb - tdp->i_size; 1001 } else { 1002 slotp->size = udf_vfsp->udf_lbsize - 1003 slotp->offset & udf_vfsp->udf_lbmask; 1004 } 1005 slotp->endoff = 0; 1006 } 1007 1008 *ipp = NULL; 1009 end: 1010 kmem_free((caddr_t)dname, 1024); 1011 return (error); 1012 } 1013 1014 /* 1015 * Return 1 if the dir has all files 1016 * deleted except the parent 1017 * else return 0 1018 */ 1019 /* ARGSUSED */ 1020 int 1021 ud_dirempty(struct ud_inode *ip, uint64_t ino, struct cred *cr) 1022 { 1023 offset_t off; 1024 int32_t empty = 1, error, count, entry_len, rcount; 1025 struct file_id *fid; 1026 caddr_t addr; 1027 uint32_t tbno; 1028 int32_t desc_len; 1029 1030 ud_printf("ud_dirempty\n"); 1031 1032 ASSERT(RW_LOCK_HELD(&ip->i_contents)); 1033 1034 if (ip->i_size == 0) { 1035 return (empty); 1036 } 1037 1038 desc_len = 1024; 1039 addr = kmem_zalloc(desc_len, KM_SLEEP); 1040 fid = (struct file_id *)addr; 1041 1042 for (off = 0; off < ip->i_size; off += entry_len) { 1043 1044 /* 1045 * First read fid 1046 * and verify checksum 1047 */ 1048 1049 rcount = sizeof (struct file_id); 1050 error = ud_rdwri(UIO_READ, FREAD, ip, addr, rcount, off, 1051 UIO_SYSSPACE, &count, cr); 1052 if ((error != 0) || (count != 0)) { 1053 empty = 0; 1054 break; 1055 } 1056 1057 if ((error = ud_ip_off2bno(ip, off, &tbno)) != 0) { 1058 empty = 0; 1059 break; 1060 } 1061 1062 /* 1063 * We verify the tag id and also the FID_LEN. 1064 * FID_LEN should be <= desc_len. 1065 */ 1066 if (ud_verify_tag_and_desc(&fid->fid_tag, 1067 UD_FILE_ID_DESC, 1068 tbno, 0, desc_len) != 0) { 1069 /* Corrupted directory */ 1070 empty = 0; 1071 break; 1072 } 1073 1074 /* 1075 * Read the fid + iulen + len 1076 * Now verify both checksum andCRC 1077 */ 1078 1079 rcount = FID_LEN(fid); 1080 error = ud_rdwri(UIO_READ, FREAD, ip, addr, rcount, off, 1081 UIO_SYSSPACE, &count, cr); 1082 if ((error != 0) || (count != 0)) { 1083 empty = 0; 1084 break; 1085 } 1086 /* 1087 * Now that the entire decsriptor is read we verify the 1088 * crc. 1089 */ 1090 if (ud_verify_tag_and_desc(&fid->fid_tag, 1091 UD_FILE_ID_DESC, 1092 tbno, 1093 1, rcount) != 0) { 1094 /* Corrupted directory */ 1095 empty = 0; 1096 break; 1097 } 1098 1099 /* 1100 * Is the file deleted 1101 */ 1102 1103 if ((fid->fid_flags & FID_DELETED) == 0) { 1104 if ((fid->fid_flags & FID_PARENT) == 0) { 1105 empty = 0; 1106 break; 1107 } 1108 } 1109 entry_len = FID_LEN(fid); 1110 } 1111 1112 kmem_free(addr, 1024); 1113 1114 return (empty); 1115 } 1116 1117 1118 int 1119 ud_dircheckpath(int32_t blkno, 1120 struct ud_inode *target, struct cred *cr) 1121 { 1122 int32_t err = 0; 1123 struct vfs *vfsp; 1124 struct udf_vfs *udf_vfsp; 1125 struct fbuf *fbp; 1126 struct file_id *fid; 1127 struct ud_inode *ip, *tip; 1128 uint16_t prn; 1129 uint32_t lbno, dummy, tbno; 1130 daddr_t parent_icb_loc; 1131 1132 ud_printf("ud_dircheckpath\n"); 1133 1134 udf_vfsp = target->i_udf; 1135 ip = target; 1136 1137 ASSERT(udf_vfsp != NULL); 1138 ASSERT(MUTEX_HELD(&target->i_udf->udf_rename_lck)); 1139 ASSERT(RW_WRITE_HELD(&ip->i_rwlock)); 1140 1141 if (ip->i_icb_lbano == blkno) { 1142 err = EINVAL; 1143 goto out; 1144 } 1145 if (ip->i_icb_lbano == udf_vfsp->udf_root_blkno) { 1146 goto out; 1147 } 1148 1149 /* 1150 * Search back through the directory tree, using the PARENT entries 1151 * Fail any attempt to move a directory into an ancestor directory. 1152 */ 1153 for (;;) { 1154 if ((err = fbread(ITOV(ip), 0, 1155 udf_vfsp->udf_lbsize, S_READ, &fbp)) != 0) { 1156 break; 1157 } 1158 1159 if ((err = ud_ip_off2bno(ip, 0, &tbno)) != 0) { 1160 break; 1161 } 1162 fid = (struct file_id *)fbp->fb_addr; 1163 /* IS this a valid file_identifier */ 1164 if (ud_verify_tag_and_desc(&fid->fid_tag, 1165 UD_FILE_ID_DESC, 1166 tbno, 1167 1, udf_vfsp->udf_lbsize) != 0) { 1168 break; 1169 } 1170 if ((fid->fid_flags & FID_DELETED) != 0) { 1171 break; 1172 } 1173 if ((fid->fid_flags & FID_PARENT) == 0) { 1174 /* 1175 * This cannot happen unless 1176 * something is grossly wrong 1177 * First entry has to be parent 1178 */ 1179 break; 1180 } 1181 prn = SWAP_16(fid->fid_icb.lad_ext_prn); 1182 lbno = SWAP_32(fid->fid_icb.lad_ext_loc); 1183 parent_icb_loc = 1184 ud_xlate_to_daddr(udf_vfsp, prn, lbno, 1, &dummy); 1185 ASSERT(dummy == 1); 1186 if (parent_icb_loc == blkno) { 1187 err = EINVAL; 1188 break; 1189 } 1190 vfsp = ip->i_vfs; 1191 udf_vfsp = ip->i_udf; 1192 if (parent_icb_loc == udf_vfsp->udf_root_blkno) { 1193 break; 1194 } 1195 if (fbp != NULL) { 1196 fbrelse(fbp, S_OTHER); 1197 fbp = NULL; 1198 } 1199 if (ip != target) { 1200 rw_exit(&ip->i_rwlock); 1201 VN_RELE(ITOV(ip)); 1202 } 1203 1204 /* 1205 * Race to get the inode. 1206 */ 1207 if (err = ud_iget(vfsp, prn, lbno, &tip, NULL, cr)) { 1208 ip = NULL; 1209 break; 1210 } 1211 ip = tip; 1212 rw_enter(&ip->i_rwlock, RW_READER); 1213 } 1214 if (fbp) { 1215 fbrelse(fbp, S_OTHER); 1216 } 1217 out: 1218 if (ip) { 1219 if (ip != target) { 1220 rw_exit(&ip->i_rwlock); 1221 VN_RELE(ITOV(ip)); 1222 } 1223 } 1224 return (err); 1225 } 1226 1227 int 1228 ud_dirmakeinode(struct ud_inode *tdp, struct ud_inode **ipp, 1229 struct vattr *vap, enum de_op op, struct cred *cr) 1230 { 1231 struct ud_inode *ip; 1232 int32_t error; 1233 1234 ASSERT(vap != NULL); 1235 ASSERT(op == DE_CREATE || op == DE_MKDIR); 1236 ASSERT((vap->va_mask & (AT_TYPE|AT_MODE)) == (AT_TYPE|AT_MODE)); 1237 ASSERT(RW_WRITE_HELD(&tdp->i_rwlock)); 1238 1239 /* 1240 * Allocate a new inode. 1241 */ 1242 if ((error = ud_ialloc(tdp, &ip, vap, cr)) != 0) { 1243 return (error); 1244 } 1245 1246 ASSERT(ip != NULL); 1247 1248 rw_enter(&ip->i_contents, RW_WRITER); 1249 1250 if (op == DE_MKDIR) { 1251 error = ud_dirmakedirect(ip, tdp, cr); 1252 } 1253 1254 ip->i_flag |= IACC|IUPD|ICHG; 1255 /* 1256 * Clear IACC and/or IUPD if the caller specified the atime and/or 1257 * mtime fields. They were set from the passed in attributes in 1258 * ud_ialloc(). 1259 */ 1260 if (vap->va_mask & AT_ATIME) 1261 ip->i_flag &= ~IACC; 1262 if (vap->va_mask & AT_MTIME) 1263 ip->i_flag &= ~IUPD; 1264 /* 1265 * push inode before it's name appears in a directory 1266 */ 1267 ud_iupdat(ip, 1); 1268 *ipp = ip; 1269 rw_exit(&ip->i_contents); 1270 return (error); 1271 } 1272 1273 /* 1274 * Enter the file sip in the directory tdp with name namep. 1275 */ 1276 int 1277 ud_diraddentry(struct ud_inode *tdp, char *namep, 1278 enum de_op op, int32_t namelen, struct slot *slotp, 1279 struct ud_inode *sip, struct ud_inode *sdp, struct cred *cr) 1280 { 1281 struct udf_vfs *udf_vfsp; 1282 int32_t error, temp; 1283 struct file_id *fid; 1284 uint8_t *buf = NULL; 1285 1286 ASSERT(RW_WRITE_HELD(&tdp->i_rwlock)); 1287 1288 ud_printf("ud_diraddentry\n"); 1289 1290 udf_vfsp = sip->i_udf; 1291 1292 /* 1293 * Check inode to be linked to see if it is in the 1294 * same filesystem. 1295 */ 1296 if (ITOV(tdp)->v_vfsp != ITOV(sip)->v_vfsp) { 1297 error = EXDEV; 1298 goto bad; 1299 } 1300 1301 if ((op == DE_RENAME) && (sip->i_type == VDIR)) { 1302 if ((error = ud_dirfixdotdot(sip, sdp, tdp)) != 0) { 1303 goto bad; 1304 } 1305 } 1306 1307 buf = (uint8_t *)kmem_zalloc(udf_vfsp->udf_lbsize, KM_SLEEP); 1308 1309 /* 1310 * Fill in entry data. 1311 */ 1312 fid = (struct file_id *)buf; 1313 fid->fid_ver = SWAP_16(1); 1314 if (sip->i_type == VDIR) { 1315 fid->fid_flags = FID_DIR; 1316 } else { 1317 fid->fid_flags = 0; 1318 } 1319 fid->fid_iulen = 0; 1320 1321 fid->fid_icb.lad_ext_len = SWAP_32(sip->i_udf->udf_lbsize); 1322 fid->fid_icb.lad_ext_loc = SWAP_32(sip->i_icb_block); 1323 fid->fid_icb.lad_ext_prn = SWAP_16(sip->i_icb_prn); 1324 fid->fid_iulen = 0; 1325 1326 temp = udf_vfsp->udf_lbsize - F_LEN; 1327 if ((error = ud_compress(namelen, &temp, 1328 (uint8_t *)namep, fid->fid_spec)) == 0) { 1329 fid->fid_idlen = (uint8_t)temp; 1330 error = ud_dirprepareentry(tdp, slotp, buf, cr); 1331 } 1332 1333 kmem_free(buf, udf_vfsp->udf_lbsize); 1334 1335 bad: 1336 return (error); 1337 } 1338 1339 /* 1340 * Write a prototype directory into the empty inode ip, whose parent is dp. 1341 */ 1342 /* ARGSUSED2 */ 1343 int 1344 ud_dirmakedirect(struct ud_inode *ip, 1345 struct ud_inode *dp, struct cred *cr) 1346 { 1347 int32_t err; 1348 uint32_t blkno, size, parent_len, tbno; 1349 struct fbuf *fbp; 1350 struct file_id *fid; 1351 struct icb_ext *iext; 1352 1353 ud_printf("ud_dirmakedirect\n"); 1354 1355 ASSERT(RW_WRITE_HELD(&ip->i_contents)); 1356 ASSERT(RW_WRITE_HELD(&dp->i_rwlock)); 1357 1358 parent_len = sizeof (struct file_id); 1359 1360 if ((ip->i_desc_type != ICB_FLAG_ONE_AD) || 1361 (parent_len > ip->i_max_emb)) { 1362 ASSERT(ip->i_ext); 1363 /* 1364 * Allocate space for the directory we're creating. 1365 */ 1366 if ((err = ud_alloc_space(ip->i_vfs, ip->i_icb_prn, 1367 0, 1, &blkno, &size, 0, 0)) != 0) { 1368 return (err); 1369 } 1370 /* 1371 * init with the size of 1372 * directory with just the 1373 * parent 1374 */ 1375 ip->i_size = sizeof (struct file_id); 1376 ip->i_flag |= IUPD|ICHG|IATTCHG; 1377 iext = ip->i_ext; 1378 iext->ib_prn = ip->i_icb_prn; 1379 iext->ib_block = blkno; 1380 iext->ib_count = ip->i_size; 1381 iext->ib_offset = 0; 1382 ip->i_ext_used = 1; 1383 } else { 1384 ip->i_size = sizeof (struct file_id); 1385 ip->i_flag |= IUPD|ICHG|IATTCHG; 1386 } 1387 1388 ITIMES_NOLOCK(ip); 1389 1390 /* 1391 * Update the dp link count and write out the change. 1392 * This reflects the ".." entry we'll soon write. 1393 */ 1394 if (dp->i_nlink == MAXLINK) { 1395 return (EMLINK); 1396 } 1397 dp->i_nlink++; 1398 dp->i_flag |= ICHG; 1399 ud_iupdat(dp, 1); 1400 1401 /* 1402 * Initialize directory with ".." 1403 * Since the parent directory is locked, we don't have to 1404 * worry about anything changing when we drop the write 1405 * lock on (ip). 1406 */ 1407 rw_exit(&ip->i_contents); 1408 if ((err = fbread(ITOV(ip), (offset_t)0, 1409 ip->i_udf->udf_lbsize, S_WRITE, &fbp)) != 0) { 1410 rw_enter(&ip->i_contents, RW_WRITER); 1411 return (err); 1412 } 1413 1414 bzero(fbp->fb_addr, ip->i_udf->udf_lbsize); 1415 1416 fid = (struct file_id *)fbp->fb_addr; 1417 fid->fid_ver = SWAP_16(1); 1418 fid->fid_flags = FID_DIR | FID_PARENT; 1419 fid->fid_icb.lad_ext_len = SWAP_32(dp->i_udf->udf_lbsize); 1420 fid->fid_icb.lad_ext_loc = SWAP_32(dp->i_icb_block); 1421 fid->fid_icb.lad_ext_prn = SWAP_16(dp->i_icb_prn); 1422 1423 /* 1424 * fid_idlen, fid_iulen and fid_spec are zero 1425 * due to bzero above 1426 */ 1427 1428 if ((err = ud_ip_off2bno(ip, 0, &tbno)) == 0) { 1429 ud_make_tag(ip->i_udf, &fid->fid_tag, 1430 UD_FILE_ID_DESC, tbno, FID_LEN(fid)); 1431 } 1432 1433 err = ud_fbwrite(fbp, ip); 1434 rw_enter(&ip->i_contents, RW_WRITER); 1435 1436 return (err); 1437 } 1438 1439 int 1440 ud_dirrename(struct ud_inode *sdp, struct ud_inode *sip, 1441 struct ud_inode *tdp, struct ud_inode *tip, char *namep, 1442 uint8_t *buf, struct slot *slotp, struct cred *cr) 1443 { 1444 int32_t error = 0, doingdirectory; 1445 struct file_id *fid; 1446 1447 ud_printf("ud_dirrename\n"); 1448 ASSERT(sdp->i_udf != NULL); 1449 ASSERT(MUTEX_HELD(&sdp->i_udf->udf_rename_lck)); 1450 ASSERT(RW_WRITE_HELD(&tdp->i_rwlock)); 1451 ASSERT(RW_WRITE_HELD(&tdp->i_contents)); 1452 ASSERT(buf); 1453 ASSERT(slotp->ep); 1454 1455 fid = slotp->ep; 1456 1457 /* 1458 * Short circuit rename of something to itself. 1459 */ 1460 if (sip->i_icb_lbano == tip->i_icb_lbano) { 1461 return (ESAME); /* special KLUDGE error code */ 1462 } 1463 /* 1464 * Everything is protected under the vfs_rename_lock so the ordering 1465 * of i_contents locks doesn't matter here. 1466 */ 1467 rw_enter(&sip->i_contents, RW_READER); 1468 rw_enter(&tip->i_contents, RW_READER); 1469 1470 /* 1471 * Check that everything is on the same filesystem. 1472 */ 1473 if ((ITOV(tip)->v_vfsp != ITOV(tdp)->v_vfsp) || 1474 (ITOV(tip)->v_vfsp != ITOV(sip)->v_vfsp)) { 1475 error = EXDEV; /* XXX archaic */ 1476 goto out; 1477 } 1478 1479 /* 1480 * Must have write permission to rewrite target entry. 1481 */ 1482 if ((error = ud_iaccess(tdp, IWRITE, cr, 0)) != 0 || 1483 (error = ud_sticky_remove_access(tdp, tip, cr)) != 0) 1484 goto out; 1485 1486 /* 1487 * Ensure source and target are compatible (both directories 1488 * or both not directories). If target is a directory it must 1489 * be empty and have no links to it; in addition it must not 1490 * be a mount point, and both the source and target must be 1491 * writable. 1492 */ 1493 doingdirectory = (sip->i_type == VDIR); 1494 if (tip->i_type == VDIR) { 1495 if (!doingdirectory) { 1496 error = EISDIR; 1497 goto out; 1498 } 1499 /* 1500 * vn_vfswlock will prevent mounts from using the directory 1501 * until we are done. 1502 */ 1503 if (vn_vfswlock(ITOV(tip))) { 1504 error = EBUSY; 1505 goto out; 1506 } 1507 if (vn_mountedvfs(ITOV(tip)) != NULL) { 1508 vn_vfsunlock(ITOV(tip)); 1509 error = EBUSY; 1510 goto out; 1511 } 1512 if (!ud_dirempty(tip, tdp->i_uniqid, cr) || tip->i_nlink > 2) { 1513 vn_vfsunlock(ITOV(tip)); 1514 error = EEXIST; /* SIGH should be ENOTEMPTY */ 1515 goto out; 1516 } 1517 } else if (doingdirectory) { 1518 error = ENOTDIR; 1519 goto out; 1520 } 1521 1522 /* 1523 * Rewrite the inode pointer for target name entry 1524 * from the target inode (ip) to the source inode (sip). 1525 * This prevents the target entry from disappearing 1526 * during a crash. Mark the directory inode to reflect the changes. 1527 */ 1528 dnlc_remove(ITOV(tdp), namep); 1529 fid->fid_icb.lad_ext_prn = SWAP_16(sip->i_icb_prn); 1530 fid->fid_icb.lad_ext_loc = SWAP_32(sip->i_icb_block); 1531 dnlc_enter(ITOV(tdp), namep, ITOV(sip)); 1532 1533 ud_make_tag(tdp->i_udf, &fid->fid_tag, UD_FILE_ID_DESC, 1534 SWAP_32(fid->fid_tag.tag_loc), FID_LEN(fid)); 1535 1536 error = ud_write_fid(tdp, slotp, buf); 1537 1538 if (error) { 1539 if (doingdirectory) { 1540 vn_vfsunlock(ITOV(tip)); 1541 } 1542 goto out; 1543 } 1544 1545 /* 1546 * Upgrade to write lock on tip 1547 */ 1548 rw_exit(&tip->i_contents); 1549 rw_enter(&tip->i_contents, RW_WRITER); 1550 1551 mutex_enter(&tdp->i_tlock); 1552 tdp->i_flag |= IUPD|ICHG; 1553 mutex_exit(&tdp->i_tlock); 1554 /* 1555 * Decrement the link count of the target inode. 1556 * Fix the ".." entry in sip to point to dp. 1557 * This is done after the new entry is on the disk. 1558 */ 1559 tip->i_nlink--; 1560 mutex_enter(&tip->i_tlock); 1561 tip->i_flag |= ICHG; 1562 mutex_exit(&tip->i_tlock); 1563 1564 if (doingdirectory) { 1565 /* 1566 * The entry for tip no longer exists so I can unlock the 1567 * vfslock. 1568 */ 1569 vn_vfsunlock(ITOV(tip)); 1570 /* 1571 * Decrement target link count once more if it was a directory. 1572 */ 1573 if (tip->i_nlink != 0) { 1574 cmn_err(CE_WARN, 1575 "ud_direnter: target directory link count != 0"); 1576 rw_exit(&tip->i_contents); 1577 rw_exit(&sip->i_contents); 1578 return (EINVAL); 1579 } 1580 /* 1581 * Renaming a directory with the parent different 1582 * requires that ".." be rewritten. The window is 1583 * still there for ".." to be inconsistent, but this 1584 * is unavoidable, and a lot shorter than when it was 1585 * done in a user process. We decrement the link 1586 * count in the new parent as appropriate to reflect 1587 * the just-removed target. If the parent is the 1588 * same, this is appropriate since the original 1589 * directory is going away. If the new parent is 1590 * different, dirfixdotdot() will bump the link count 1591 * back. 1592 */ 1593 tdp->i_nlink--; 1594 mutex_enter(&tdp->i_tlock); 1595 tdp->i_flag |= ICHG; 1596 mutex_exit(&tdp->i_tlock); 1597 ITIMES_NOLOCK(tdp); 1598 if (sdp != tdp) { 1599 rw_exit(&tip->i_contents); 1600 rw_exit(&sip->i_contents); 1601 error = ud_dirfixdotdot(sip, sdp, tdp); 1602 return (error); 1603 } 1604 } 1605 1606 out: 1607 rw_exit(&tip->i_contents); 1608 rw_exit(&sip->i_contents); 1609 return (error); 1610 } 1611 1612 1613 /* 1614 * 1. When we find a slot that belonged to a file which was deleted 1615 * and is in the middle of the directory 1616 * 2. There is not empty slot available. The new entry 1617 * will be at the end of the directory and fits in the same block. 1618 * 3. There is no empty slot available. The new 1619 * entry will not fit the left over directory 1620 * so we need to allocate a new block. If 1621 * we cannot allocate a proximity block we need 1622 * to allocate a new icb, and data block. 1623 */ 1624 int 1625 ud_dirprepareentry(struct ud_inode *dp, 1626 struct slot *slotp, uint8_t *buf, struct cred *cr) 1627 { 1628 struct fbuf *fbp; 1629 uint16_t old_dtype; 1630 int32_t error = 0; 1631 uint32_t entrysize, count, offset, tbno, old_size, off; 1632 struct file_id *fid; 1633 int32_t lbsize, lbmask, mask; 1634 1635 ASSERT(RW_WRITE_HELD(&dp->i_rwlock)); 1636 1637 ASSERT((slotp->status == NONE) || (slotp->status == FOUND)); 1638 1639 ud_printf("ud_dirprepareentry\n"); 1640 lbsize = dp->i_udf->udf_lbsize; 1641 lbmask = dp->i_udf->udf_lbmask; 1642 mask = ~lbmask; 1643 1644 fid = (struct file_id *)buf; 1645 entrysize = FID_LEN(fid); 1646 1647 /* 1648 * If we didn't find a slot, then indicate that the 1649 * new slot belongs at the end of the directory. 1650 * If we found a slot, then the new entry can be 1651 * put at slotp->offset. 1652 */ 1653 if (slotp->status == NONE) { 1654 /* 1655 * We did not find a slot, the next 1656 * entry will be in the end of the directory 1657 * see if we can fit the new entry inside 1658 * the old block. If not allocate a new block. 1659 */ 1660 if (entrysize > slotp->size) { 1661 /* 1662 * extend the directory 1663 * size by one new block 1664 */ 1665 old_dtype = dp->i_desc_type; 1666 old_size = (uint32_t)dp->i_size; 1667 error = ud_bmap_write(dp, slotp->offset, 1668 blkoff(dp->i_udf, slotp->offset) + entrysize, 1669 0, cr); 1670 if (error != 0) { 1671 return (error); 1672 } 1673 if (old_dtype != dp->i_desc_type) { 1674 /* 1675 * oops we changed the astrat 1676 * of the file, we have to 1677 * recaliculate tags 1678 * fortunately we donot have more 1679 * than one lbsize to handle here 1680 */ 1681 if ((error = ud_ip_off2bno(dp, 1682 0, &tbno)) != 0) { 1683 return (error); 1684 } 1685 if ((error = fbread(ITOV(dp), 0, 1686 dp->i_udf->udf_lbsize, 1687 S_WRITE, &fbp)) != 0) { 1688 return (error); 1689 } 1690 off = 0; 1691 while (off < old_size) { 1692 struct file_id *tfid; 1693 1694 tfid = (struct file_id *) 1695 (fbp->fb_addr + off); 1696 1697 ud_make_tag(dp->i_udf, &tfid->fid_tag, 1698 UD_FILE_ID_DESC, tbno, 1699 FID_LEN(tfid)); 1700 1701 off += FID_LEN(tfid); 1702 } 1703 if (error = ud_fbwrite(fbp, dp)) { 1704 return (error); 1705 } 1706 } 1707 } else { 1708 /* Extend the directory size */ 1709 if (dp->i_desc_type != ICB_FLAG_ONE_AD) { 1710 ASSERT(dp->i_ext); 1711 dp->i_ext[dp->i_ext_used - 1].ib_count += 1712 entrysize; 1713 } 1714 } 1715 dp->i_size += entrysize; 1716 dp->i_flag |= IUPD|ICHG|IATTCHG; 1717 ITIMES_NOLOCK(dp); 1718 } else if (slotp->status != FOUND) { 1719 cmn_err(CE_WARN, "status is not NONE/FOUND"); 1720 return (EINVAL); 1721 } 1722 1723 if ((error = ud_ip_off2bno(dp, slotp->offset, &tbno)) != 0) { 1724 return (error); 1725 } 1726 ud_make_tag(dp->i_udf, &fid->fid_tag, UD_FILE_ID_DESC, 1727 tbno, FID_LEN(fid)); 1728 1729 /* 1730 * fbread cannot cross a 1731 * MAXBSIZE boundary so handle it here 1732 */ 1733 offset = slotp->offset; 1734 if ((error = fbread(ITOV(dp), offset & mask, lbsize, 1735 S_WRITE, &fbp)) != 0) { 1736 return (error); 1737 } 1738 if ((offset & mask) != ((offset + entrysize) & mask)) { 1739 count = entrysize - ((offset + entrysize) & lbmask); 1740 } else { 1741 count = entrysize; 1742 } 1743 bcopy((caddr_t)buf, fbp->fb_addr + (offset & lbmask), count); 1744 1745 if (error = ud_fbwrite(fbp, dp)) { 1746 return (error); 1747 } 1748 1749 if (entrysize > count) { 1750 if ((error = fbread(ITOV(dp), (offset + entrysize) & mask, 1751 lbsize, S_WRITE, &fbp)) != 0) { 1752 return (error); 1753 } 1754 bcopy((caddr_t)(buf + count), fbp->fb_addr, entrysize - count); 1755 if (error = ud_fbwrite(fbp, dp)) { 1756 return (error); 1757 } 1758 } 1759 1760 dp->i_flag |= IUPD|ICHG|IATTCHG; 1761 ITIMES_NOLOCK(dp); 1762 return (error); 1763 } 1764 1765 1766 /* 1767 * Fix the FID_PARENT entry of the child directory so that it points 1768 * to the new parent directory instead of the old one. Routine 1769 * assumes that dp is a directory and that all the inodes are on 1770 * the same file system. 1771 */ 1772 int 1773 ud_dirfixdotdot(struct ud_inode *dp, 1774 struct ud_inode *opdp, struct ud_inode *npdp) 1775 { 1776 int32_t err = 0; 1777 struct fbuf *fbp; 1778 struct file_id *fid; 1779 uint32_t loc, dummy, tbno; 1780 1781 ud_printf("ud_dirfixdotdot\n"); 1782 1783 ASSERT(opdp->i_type == VDIR); 1784 ASSERT(npdp->i_type == VDIR); 1785 1786 ASSERT(RW_WRITE_HELD(&npdp->i_rwlock)); 1787 1788 err = fbread(ITOV(dp), (offset_t)0, 1789 dp->i_udf->udf_lbsize, S_WRITE, &fbp); 1790 1791 if (err || dp->i_nlink == 0 || 1792 dp->i_size < sizeof (struct file_id)) { 1793 goto bad; 1794 } 1795 1796 if ((err = ud_ip_off2bno(dp, 0, &tbno)) != 0) { 1797 goto bad; 1798 } 1799 1800 fid = (struct file_id *)fbp->fb_addr; 1801 if ((ud_verify_tag_and_desc(&fid->fid_tag, UD_FILE_ID_DESC, 1802 tbno, 1803 1, dp->i_udf->udf_lbsize) != 0) || 1804 ((fid->fid_flags & (FID_DIR | FID_PARENT)) != 1805 (FID_DIR | FID_PARENT))) { 1806 err = ENOTDIR; 1807 goto bad; 1808 } 1809 1810 loc = ud_xlate_to_daddr(dp->i_udf, 1811 SWAP_16(fid->fid_icb.lad_ext_prn), 1812 SWAP_32(fid->fid_icb.lad_ext_loc), 1, &dummy); 1813 ASSERT(dummy == 1); 1814 if (loc == npdp->i_icb_lbano) { 1815 goto bad; 1816 } 1817 1818 /* 1819 * Increment the link count in the new parent inode and force it out. 1820 */ 1821 if (npdp->i_nlink == MAXLINK) { 1822 err = EMLINK; 1823 goto bad; 1824 } 1825 1826 npdp->i_nlink++; 1827 mutex_enter(&npdp->i_tlock); 1828 npdp->i_flag |= ICHG; 1829 mutex_exit(&npdp->i_tlock); 1830 ud_iupdat(npdp, 1); 1831 1832 /* 1833 * Rewrite the child FID_PARENT entry and force it out. 1834 */ 1835 dnlc_remove(ITOV(dp), ".."); 1836 fid->fid_icb.lad_ext_loc = SWAP_32(npdp->i_icb_block); 1837 fid->fid_icb.lad_ext_prn = SWAP_16(npdp->i_icb_prn); 1838 ud_make_tag(npdp->i_udf, &fid->fid_tag, 1839 UD_FILE_ID_DESC, tbno, FID_LEN(fid)); 1840 dnlc_enter(ITOV(dp), "..", ITOV(npdp)); 1841 1842 err = ud_fbwrite(fbp, dp); 1843 fbp = NULL; 1844 if (err != 0) { 1845 goto bad; 1846 } 1847 1848 /* 1849 * Decrement the link count of the old parent inode and force 1850 * it out. If opdp is NULL, then this is a new directory link; 1851 * it has no parent, so we need not do anything. 1852 */ 1853 if (opdp != NULL) { 1854 rw_enter(&opdp->i_contents, RW_WRITER); 1855 if (opdp->i_nlink != 0) { 1856 opdp->i_nlink--; 1857 mutex_enter(&opdp->i_tlock); 1858 opdp->i_flag |= ICHG; 1859 mutex_exit(&opdp->i_tlock); 1860 ud_iupdat(opdp, 1); 1861 } 1862 rw_exit(&opdp->i_contents); 1863 } 1864 return (0); 1865 1866 bad: 1867 if (fbp) { 1868 fbrelse(fbp, S_OTHER); 1869 } 1870 return (err); 1871 } 1872 1873 int32_t 1874 ud_write_fid(struct ud_inode *dp, struct slot *slot, uint8_t *buf) 1875 { 1876 struct udf_vfs *udf_vfsp; 1877 struct fbuf *lfbp; 1878 struct file_id *fid; 1879 int32_t error = 0; 1880 uint32_t lbsize, lbmask, count, old_count; 1881 1882 1883 ASSERT(slot->fbp); 1884 ASSERT(slot->ep); 1885 1886 udf_vfsp = dp->i_udf; 1887 fid = slot->ep; 1888 lbsize = dp->i_udf->udf_lbsize; 1889 lbmask = dp->i_udf->udf_lbmask; 1890 1891 if (((uint8_t *)fid >= buf) && 1892 ((uint8_t *)fid < &buf[udf_vfsp->udf_lbsize])) { 1893 1894 if ((error = fbread(ITOV(dp), 1895 (offset_t)(slot->offset & ~lbmask), 1896 lbsize, S_WRITE, &lfbp)) != 0) { 1897 goto out; 1898 } 1899 1900 1901 /* 1902 * We do not need to write the 1903 * file name. So check if the entry 1904 * does not cross a block boundary 1905 * and write only required portions 1906 */ 1907 if (((slot->offset & lbmask) + 1908 sizeof (struct file_id)) > lbsize) { 1909 1910 if ((slot->offset & lbmask) != 0) { 1911 old_count = lbsize - 1912 (slot->offset & lbmask); 1913 count = (slot->offset + 1914 sizeof (struct file_id)) & 1915 lbmask; 1916 } else { 1917 old_count = 0; 1918 count = sizeof (struct file_id); 1919 } 1920 1921 bcopy(buf, lfbp->fb_addr + 1922 (slot->offset & lbmask), old_count); 1923 bcopy(buf + old_count, 1924 slot->fbp->fb_addr, count); 1925 1926 error = ud_fbwrite(lfbp, dp); 1927 1928 error = ud_fbwrite(slot->fbp, dp); 1929 } else { 1930 bcopy(buf, lfbp->fb_addr + 1931 (slot->offset & lbmask), 1932 sizeof (struct file_id)); 1933 1934 error = ud_fbwrite(lfbp, dp); 1935 1936 fbrelse(slot->fbp, S_OTHER); 1937 } 1938 } else { 1939 if ((error = ud_fbwrite(slot->fbp, dp)) != 0) { 1940 fid->fid_flags &= ~FID_DELETED; 1941 ud_make_tag(dp->i_udf, &fid->fid_tag, UD_FILE_ID_DESC, 1942 SWAP_32(fid->fid_tag.tag_loc), FID_LEN(fid)); 1943 } 1944 } 1945 slot->fbp = NULL; 1946 1947 out: 1948 return (error); 1949 } 1950