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 2008 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 * Copyright (c) 2011 Bayard G. Bell. All rights reserved. 25 */ 26 27 #include <sys/types.h> 28 #include <sys/t_lock.h> 29 #include <sys/param.h> 30 #include <sys/time.h> 31 #include <sys/systm.h> 32 #include <sys/sysmacros.h> 33 #include <sys/resource.h> 34 #include <sys/signal.h> 35 #include <sys/cred.h> 36 #include <sys/user.h> 37 #include <sys/buf.h> 38 #include <sys/vfs.h> 39 #include <sys/vfs_opreg.h> 40 #include <sys/stat.h> 41 #include <sys/vnode.h> 42 #include <sys/mode.h> 43 #include <sys/proc.h> 44 #include <sys/disp.h> 45 #include <sys/file.h> 46 #include <sys/fcntl.h> 47 #include <sys/flock.h> 48 #include <sys/kmem.h> 49 #include <sys/uio.h> 50 #include <sys/dnlc.h> 51 #include <sys/conf.h> 52 #include <sys/errno.h> 53 #include <sys/mman.h> 54 #include <sys/fbuf.h> 55 #include <sys/pathname.h> 56 #include <sys/debug.h> 57 #include <sys/vmsystm.h> 58 #include <sys/cmn_err.h> 59 #include <sys/dirent.h> 60 #include <sys/errno.h> 61 #include <sys/modctl.h> 62 #include <sys/statvfs.h> 63 #include <sys/mount.h> 64 #include <sys/sunddi.h> 65 #include <sys/bootconf.h> 66 #include <sys/policy.h> 67 68 #include <vm/hat.h> 69 #include <vm/page.h> 70 #include <vm/pvn.h> 71 #include <vm/as.h> 72 #include <vm/seg.h> 73 #include <vm/seg_map.h> 74 #include <vm/seg_kmem.h> 75 #include <vm/seg_vn.h> 76 #include <vm/rm.h> 77 #include <vm/page.h> 78 #include <sys/swap.h> 79 #include <sys/mntent.h> 80 81 82 #include <fs/fs_subr.h> 83 84 85 #include <sys/fs/udf_volume.h> 86 #include <sys/fs/udf_inode.h> 87 88 89 extern struct vnode *common_specvp(struct vnode *vp); 90 91 extern kmutex_t ud_sync_busy; 92 static int32_t ud_mountfs(struct vfs *, 93 enum whymountroot, dev_t, char *, struct cred *, int32_t); 94 static struct udf_vfs *ud_validate_and_fill_superblock(dev_t, 95 int32_t, uint32_t); 96 void ud_destroy_fsp(struct udf_vfs *); 97 void ud_convert_to_superblock(struct udf_vfs *, 98 struct log_vol_int_desc *); 99 void ud_update_superblock(struct vfs *); 100 int32_t ud_get_last_block(dev_t, daddr_t *); 101 static int32_t ud_val_get_vat(struct udf_vfs *, 102 dev_t, daddr_t, struct ud_map *); 103 int32_t ud_read_sparing_tbls(struct udf_vfs *, 104 dev_t, struct ud_map *, struct pmap_typ2 *); 105 uint32_t ud_get_lbsize(dev_t, uint32_t *); 106 107 static int32_t udf_mount(struct vfs *, 108 struct vnode *, struct mounta *, struct cred *); 109 static int32_t udf_unmount(struct vfs *, int, struct cred *); 110 static int32_t udf_root(struct vfs *, struct vnode **); 111 static int32_t udf_statvfs(struct vfs *, struct statvfs64 *); 112 static int32_t udf_sync(struct vfs *, int16_t, struct cred *); 113 static int32_t udf_vget(struct vfs *, struct vnode **, struct fid *); 114 static int32_t udf_mountroot(struct vfs *vfsp, enum whymountroot); 115 116 static int udfinit(int, char *); 117 118 static mntopts_t udfs_mntopts; 119 120 static vfsdef_t vfw = { 121 VFSDEF_VERSION, 122 "udfs", 123 udfinit, 124 VSW_HASPROTO|VSW_CANREMOUNT|VSW_STATS|VSW_CANLOFI, 125 &udfs_mntopts 126 }; 127 128 static mntopts_t udfs_mntopts = { 129 0, 130 NULL 131 }; 132 133 /* 134 * Module linkage information for the kernel. 135 */ 136 extern struct mod_ops mod_fsops; 137 138 static struct modlfs modlfs = { 139 &mod_fsops, "filesystem for UDFS", &vfw 140 }; 141 142 static struct modlinkage modlinkage = { 143 MODREV_1, (void *)&modlfs, NULL 144 }; 145 146 int32_t udf_fstype = -1; 147 148 int 149 _init() 150 { 151 return (mod_install(&modlinkage)); 152 } 153 154 int 155 _fini() 156 { 157 return (EBUSY); 158 } 159 160 int 161 _info(struct modinfo *modinfop) 162 { 163 return (mod_info(&modlinkage, modinfop)); 164 } 165 166 167 /* -------------------- vfs routines -------------------- */ 168 169 /* 170 * XXX - this appears only to be used by the VM code to handle the case where 171 * UNIX is running off the mini-root. That probably wants to be done 172 * differently. 173 */ 174 struct vnode *rootvp; 175 #ifndef __lint 176 _NOTE(SCHEME_PROTECTS_DATA("safe sharing", rootvp)) 177 #endif 178 static int32_t 179 udf_mount(struct vfs *vfsp, struct vnode *mvp, 180 struct mounta *uap, struct cred *cr) 181 { 182 dev_t dev; 183 struct vnode *lvp = NULL; 184 struct vnode *svp = NULL; 185 struct pathname dpn; 186 int32_t error; 187 enum whymountroot why; 188 int oflag, aflag; 189 190 ud_printf("udf_mount\n"); 191 192 if ((error = secpolicy_fs_mount(cr, mvp, vfsp)) != 0) { 193 return (error); 194 } 195 196 if (mvp->v_type != VDIR) { 197 return (ENOTDIR); 198 } 199 200 mutex_enter(&mvp->v_lock); 201 if ((uap->flags & MS_REMOUNT) == 0 && 202 (uap->flags & MS_OVERLAY) == 0 && 203 (mvp->v_count != 1 || (mvp->v_flag & VROOT))) { 204 mutex_exit(&mvp->v_lock); 205 return (EBUSY); 206 } 207 mutex_exit(&mvp->v_lock); 208 209 if (error = pn_get(uap->dir, UIO_USERSPACE, &dpn)) { 210 return (error); 211 } 212 213 /* 214 * Resolve path name of the file being mounted. 215 */ 216 if (error = lookupname(uap->spec, UIO_USERSPACE, FOLLOW, NULLVPP, 217 &svp)) { 218 pn_free(&dpn); 219 return (error); 220 } 221 222 error = vfs_get_lofi(vfsp, &lvp); 223 224 if (error > 0) { 225 if (error == ENOENT) 226 error = ENODEV; 227 goto out; 228 } else if (error == 0) { 229 dev = lvp->v_rdev; 230 } else { 231 dev = svp->v_rdev; 232 233 if (svp->v_type != VBLK) { 234 error = ENOTBLK; 235 goto out; 236 } 237 } 238 239 /* 240 * Ensure that this device isn't already mounted, 241 * unless this is a REMOUNT request 242 */ 243 if (vfs_devmounting(dev, vfsp)) { 244 error = EBUSY; 245 goto out; 246 } 247 if (vfs_devismounted(dev)) { 248 if (uap->flags & MS_REMOUNT) { 249 why = ROOT_REMOUNT; 250 } else { 251 error = EBUSY; 252 goto out; 253 } 254 } else { 255 why = ROOT_INIT; 256 } 257 if (getmajor(dev) >= devcnt) { 258 error = ENXIO; 259 goto out; 260 } 261 262 /* 263 * If the device is a tape, mount it read only 264 */ 265 if (devopsp[getmajor(dev)]->devo_cb_ops->cb_flag & D_TAPE) { 266 vfsp->vfs_flag |= VFS_RDONLY; 267 } 268 269 if (uap->flags & MS_RDONLY) { 270 vfsp->vfs_flag |= VFS_RDONLY; 271 } 272 273 /* 274 * Set mount options. 275 */ 276 if (uap->flags & MS_RDONLY) { 277 vfs_setmntopt(vfsp, MNTOPT_RO, NULL, 0); 278 } 279 if (uap->flags & MS_NOSUID) { 280 vfs_setmntopt(vfsp, MNTOPT_NOSUID, NULL, 0); 281 } 282 283 /* 284 * Verify that the caller can open the device special file as 285 * required. It is not until this moment that we know whether 286 * we're mounting "ro" or not. 287 */ 288 if ((vfsp->vfs_flag & VFS_RDONLY) != 0) { 289 oflag = FREAD; 290 aflag = VREAD; 291 } else { 292 oflag = FREAD | FWRITE; 293 aflag = VREAD | VWRITE; 294 } 295 296 if (lvp == NULL && 297 (error = secpolicy_spec_open(cr, svp, oflag)) != 0) 298 goto out; 299 300 if ((error = VOP_ACCESS(svp, aflag, 0, cr, NULL)) != 0) 301 goto out; 302 303 /* 304 * Mount the filesystem. 305 */ 306 error = ud_mountfs(vfsp, why, dev, dpn.pn_path, cr, 0); 307 out: 308 VN_RELE(svp); 309 if (lvp != NULL) 310 VN_RELE(lvp); 311 pn_free(&dpn); 312 return (error); 313 } 314 315 316 317 /* 318 * unmount the file system pointed 319 * by vfsp 320 */ 321 /* ARGSUSED */ 322 static int32_t 323 udf_unmount(struct vfs *vfsp, int fflag, struct cred *cr) 324 { 325 struct udf_vfs *udf_vfsp; 326 struct vnode *bvp, *rvp; 327 struct ud_inode *rip; 328 int32_t flag; 329 330 ud_printf("udf_unmount\n"); 331 332 if (secpolicy_fs_unmount(cr, vfsp) != 0) { 333 return (EPERM); 334 } 335 336 /* 337 * forced unmount is not supported by this file system 338 * and thus, ENOTSUP, is being returned. 339 */ 340 if (fflag & MS_FORCE) 341 return (ENOTSUP); 342 343 udf_vfsp = (struct udf_vfs *)vfsp->vfs_data; 344 flag = !(udf_vfsp->udf_flags & UDF_FL_RDONLY); 345 bvp = udf_vfsp->udf_devvp; 346 347 rvp = udf_vfsp->udf_root; 348 ASSERT(rvp != NULL); 349 rip = VTOI(rvp); 350 351 (void) ud_release_cache(udf_vfsp); 352 353 354 /* Flush all inodes except root */ 355 if (ud_iflush(vfsp) < 0) { 356 return (EBUSY); 357 } 358 359 rw_enter(&rip->i_contents, RW_WRITER); 360 (void) ud_syncip(rip, B_INVAL, I_SYNC); 361 rw_exit(&rip->i_contents); 362 363 mutex_enter(&ud_sync_busy); 364 if ((udf_vfsp->udf_flags & UDF_FL_RDONLY) == 0) { 365 bflush(vfsp->vfs_dev); 366 mutex_enter(&udf_vfsp->udf_lock); 367 udf_vfsp->udf_clean = UDF_CLEAN; 368 mutex_exit(&udf_vfsp->udf_lock); 369 ud_update_superblock(vfsp); 370 } 371 mutex_exit(&ud_sync_busy); 372 373 mutex_destroy(&udf_vfsp->udf_lock); 374 mutex_destroy(&udf_vfsp->udf_rename_lck); 375 376 ud_delcache(rip); 377 ITIMES(rip); 378 VN_RELE(rvp); 379 380 ud_destroy_fsp(udf_vfsp); 381 382 (void) VOP_PUTPAGE(bvp, (offset_t)0, (uint32_t)0, B_INVAL, cr, NULL); 383 (void) VOP_CLOSE(bvp, flag, 1, (offset_t)0, cr, NULL); 384 385 (void) bfinval(vfsp->vfs_dev, 1); 386 VN_RELE(bvp); 387 388 389 return (0); 390 } 391 392 393 /* 394 * Get the root vp for the 395 * file system 396 */ 397 static int32_t 398 udf_root(struct vfs *vfsp, struct vnode **vpp) 399 { 400 struct udf_vfs *udf_vfsp; 401 struct vnode *vp; 402 403 ud_printf("udf_root\n"); 404 405 udf_vfsp = (struct udf_vfs *)vfsp->vfs_data; 406 407 ASSERT(udf_vfsp != NULL); 408 ASSERT(udf_vfsp->udf_root != NULL); 409 410 vp = udf_vfsp->udf_root; 411 VN_HOLD(vp); 412 *vpp = vp; 413 return (0); 414 } 415 416 417 /* 418 * Get file system statistics. 419 */ 420 static int32_t 421 udf_statvfs(struct vfs *vfsp, struct statvfs64 *sp) 422 { 423 struct udf_vfs *udf_vfsp; 424 struct ud_part *parts; 425 dev32_t d32; 426 int32_t index; 427 428 ud_printf("udf_statvfs\n"); 429 430 udf_vfsp = (struct udf_vfs *)vfsp->vfs_data; 431 (void) bzero(sp, sizeof (struct statvfs64)); 432 433 mutex_enter(&udf_vfsp->udf_lock); 434 sp->f_bsize = udf_vfsp->udf_lbsize; 435 sp->f_frsize = udf_vfsp->udf_lbsize; 436 sp->f_blocks = 0; 437 sp->f_bfree = 0; 438 parts = udf_vfsp->udf_parts; 439 for (index = 0; index < udf_vfsp->udf_npart; index++) { 440 sp->f_blocks += parts->udp_nblocks; 441 sp->f_bfree += parts->udp_nfree; 442 parts++; 443 } 444 sp->f_bavail = sp->f_bfree; 445 446 /* 447 * Since there are no real inodes allocated 448 * we will approximate 449 * each new file will occupy : 450 * 38(over head each dent) + MAXNAMLEN / 2 + inode_size(==block size) 451 */ 452 sp->f_ffree = sp->f_favail = 453 (sp->f_bavail * sp->f_bsize) / (146 + sp->f_bsize); 454 455 /* 456 * The total number of inodes is 457 * the sum of files + directories + free inodes 458 */ 459 sp->f_files = sp->f_ffree + udf_vfsp->udf_nfiles + udf_vfsp->udf_ndirs; 460 (void) cmpldev(&d32, vfsp->vfs_dev); 461 sp->f_fsid = d32; 462 (void) strcpy(sp->f_basetype, vfssw[vfsp->vfs_fstype].vsw_name); 463 sp->f_flag = vf_to_stf(vfsp->vfs_flag); 464 sp->f_namemax = MAXNAMLEN; 465 (void) strcpy(sp->f_fstr, udf_vfsp->udf_volid); 466 467 mutex_exit(&udf_vfsp->udf_lock); 468 469 return (0); 470 } 471 472 473 /* 474 * Flush any pending I/O to file system vfsp. 475 * The ud_update() routine will only flush *all* udf files. 476 */ 477 /*ARGSUSED*/ 478 /* ARGSUSED */ 479 static int32_t 480 udf_sync(struct vfs *vfsp, int16_t flag, struct cred *cr) 481 { 482 ud_printf("udf_sync\n"); 483 484 ud_update(flag); 485 return (0); 486 } 487 488 489 490 /* ARGSUSED */ 491 static int32_t 492 udf_vget(struct vfs *vfsp, 493 struct vnode **vpp, struct fid *fidp) 494 { 495 int32_t error = 0; 496 struct udf_fid *udfid; 497 struct udf_vfs *udf_vfsp; 498 struct ud_inode *ip; 499 500 ud_printf("udf_vget\n"); 501 502 udf_vfsp = (struct udf_vfs *)vfsp->vfs_data; 503 if (udf_vfsp == NULL) { 504 *vpp = NULL; 505 return (0); 506 } 507 508 udfid = (struct udf_fid *)fidp; 509 if ((error = ud_iget(vfsp, udfid->udfid_prn, 510 udfid->udfid_icb_lbn, &ip, NULL, CRED())) != 0) { 511 *vpp = NULL; 512 return (error); 513 } 514 515 rw_enter(&ip->i_contents, RW_READER); 516 if ((udfid->udfid_uinq_lo != (ip->i_uniqid & 0xffffffff)) || 517 (udfid->udfid_prn != ip->i_icb_prn)) { 518 rw_exit(&ip->i_contents); 519 VN_RELE(ITOV(ip)); 520 *vpp = NULL; 521 return (EINVAL); 522 } 523 rw_exit(&ip->i_contents); 524 525 *vpp = ITOV(ip); 526 return (0); 527 } 528 529 530 /* 531 * Mount root file system. 532 * "why" is ROOT_INIT on initial call, ROOT_REMOUNT if called to 533 * remount the root file system, and ROOT_UNMOUNT if called to 534 * unmount the root (e.g., as part of a system shutdown). 535 * 536 * XXX - this may be partially machine-dependent; it, along with the VFS_SWAPVP 537 * operation, goes along with auto-configuration. A mechanism should be 538 * provided by which machine-INdependent code in the kernel can say "get me the 539 * right root file system" and "get me the right initial swap area", and have 540 * that done in what may well be a machine-dependent fashion. 541 * Unfortunately, it is also file-system-type dependent (NFS gets it via 542 * bootparams calls, UFS gets it from various and sundry machine-dependent 543 * mechanisms, as SPECFS does for swap). 544 */ 545 /* ARGSUSED */ 546 static int32_t 547 udf_mountroot(struct vfs *vfsp, enum whymountroot why) 548 { 549 dev_t rootdev; 550 static int32_t udf_rootdone = 0; 551 struct vnode *vp = NULL; 552 int32_t ovflags, error; 553 ud_printf("udf_mountroot\n"); 554 555 if (why == ROOT_INIT) { 556 if (udf_rootdone++) { 557 return (EBUSY); 558 } 559 rootdev = getrootdev(); 560 if (rootdev == (dev_t)NODEV) { 561 return (ENODEV); 562 } 563 vfsp->vfs_dev = rootdev; 564 vfsp->vfs_flag |= VFS_RDONLY; 565 } else if (why == ROOT_REMOUNT) { 566 vp = ((struct udf_vfs *)vfsp->vfs_data)->udf_devvp; 567 (void) dnlc_purge_vfsp(vfsp, 0); 568 vp = common_specvp(vp); 569 (void) VOP_PUTPAGE(vp, (offset_t)0, 570 (uint32_t)0, B_INVAL, CRED(), NULL); 571 binval(vfsp->vfs_dev); 572 573 ovflags = vfsp->vfs_flag; 574 vfsp->vfs_flag &= ~VFS_RDONLY; 575 vfsp->vfs_flag |= VFS_REMOUNT; 576 rootdev = vfsp->vfs_dev; 577 } else if (why == ROOT_UNMOUNT) { 578 ud_update(0); 579 vp = ((struct udf_vfs *)vfsp->vfs_data)->udf_devvp; 580 (void) VOP_CLOSE(vp, FREAD|FWRITE, 1, 581 (offset_t)0, CRED(), NULL); 582 return (0); 583 } 584 585 if ((error = vfs_lock(vfsp)) != 0) { 586 return (error); 587 } 588 589 error = ud_mountfs(vfsp, why, rootdev, "/", CRED(), 1); 590 if (error) { 591 vfs_unlock(vfsp); 592 if (why == ROOT_REMOUNT) { 593 vfsp->vfs_flag = ovflags; 594 } 595 if (rootvp) { 596 VN_RELE(rootvp); 597 rootvp = (struct vnode *)0; 598 } 599 return (error); 600 } 601 602 if (why == ROOT_INIT) { 603 vfs_add((struct vnode *)0, vfsp, 604 (vfsp->vfs_flag & VFS_RDONLY) ? MS_RDONLY : 0); 605 } 606 vfs_unlock(vfsp); 607 return (0); 608 } 609 610 611 /* ------------------------- local routines ------------------------- */ 612 613 614 static int32_t 615 ud_mountfs(struct vfs *vfsp, 616 enum whymountroot why, dev_t dev, char *name, 617 struct cred *cr, int32_t isroot) 618 { 619 struct vnode *devvp = NULL; 620 int32_t error = 0; 621 int32_t needclose = 0; 622 struct udf_vfs *udf_vfsp = NULL; 623 struct log_vol_int_desc *lvid; 624 struct ud_inode *rip = NULL; 625 struct vnode *rvp = NULL; 626 int32_t i, lbsize; 627 uint32_t avd_loc; 628 struct ud_map *map; 629 int32_t desc_len; 630 631 ud_printf("ud_mountfs\n"); 632 633 if (why == ROOT_INIT) { 634 /* 635 * Open the device. 636 */ 637 devvp = makespecvp(dev, VBLK); 638 639 /* 640 * Open block device mounted on. 641 * When bio is fixed for vnodes this can all be vnode 642 * operations. 643 */ 644 error = VOP_OPEN(&devvp, 645 (vfsp->vfs_flag & VFS_RDONLY) ? FREAD : FREAD|FWRITE, 646 cr, NULL); 647 if (error) { 648 goto out; 649 } 650 needclose = 1; 651 652 /* 653 * Refuse to go any further if this 654 * device is being used for swapping. 655 */ 656 if (IS_SWAPVP(devvp)) { 657 error = EBUSY; 658 goto out; 659 } 660 } 661 662 /* 663 * check for dev already mounted on 664 */ 665 if (vfsp->vfs_flag & VFS_REMOUNT) { 666 struct tag *ttag; 667 int32_t index, count; 668 struct buf *tpt = 0; 669 caddr_t addr; 670 671 672 /* cannot remount to RDONLY */ 673 if (vfsp->vfs_flag & VFS_RDONLY) { 674 return (EINVAL); 675 } 676 677 if (vfsp->vfs_dev != dev) { 678 return (EINVAL); 679 } 680 681 udf_vfsp = (struct udf_vfs *)vfsp->vfs_data; 682 devvp = udf_vfsp->udf_devvp; 683 684 /* 685 * fsck may have altered the file system; discard 686 * as much incore data as possible. Don't flush 687 * if this is a rw to rw remount; it's just resetting 688 * the options. 689 */ 690 if (udf_vfsp->udf_flags & UDF_FL_RDONLY) { 691 (void) dnlc_purge_vfsp(vfsp, 0); 692 (void) VOP_PUTPAGE(devvp, (offset_t)0, (uint_t)0, 693 B_INVAL, CRED(), NULL); 694 (void) ud_iflush(vfsp); 695 bflush(dev); 696 binval(dev); 697 } 698 699 /* 700 * We could read UDF1.50 and write UDF1.50 only 701 * disallow mount of any highier version 702 */ 703 if ((udf_vfsp->udf_miread > UDF_150) || 704 (udf_vfsp->udf_miwrite > UDF_150)) { 705 error = EINVAL; 706 goto remountout; 707 } 708 709 /* 710 * read/write to read/write; all done 711 */ 712 if (udf_vfsp->udf_flags & UDF_FL_RW) { 713 goto remountout; 714 } 715 716 /* 717 * Does the media type allow a writable mount 718 */ 719 if (udf_vfsp->udf_mtype != UDF_MT_OW) { 720 error = EINVAL; 721 goto remountout; 722 } 723 724 /* 725 * Read the metadata 726 * and check if it is possible to 727 * mount in rw mode 728 */ 729 tpt = ud_bread(vfsp->vfs_dev, 730 udf_vfsp->udf_iseq_loc << udf_vfsp->udf_l2d_shift, 731 udf_vfsp->udf_iseq_len); 732 if (tpt->b_flags & B_ERROR) { 733 error = EIO; 734 goto remountout; 735 } 736 count = udf_vfsp->udf_iseq_len / DEV_BSIZE; 737 addr = tpt->b_un.b_addr; 738 for (index = 0; index < count; index ++) { 739 ttag = (struct tag *)(addr + index * DEV_BSIZE); 740 desc_len = udf_vfsp->udf_iseq_len - (index * DEV_BSIZE); 741 if (ud_verify_tag_and_desc(ttag, UD_LOG_VOL_INT, 742 udf_vfsp->udf_iseq_loc + 743 (index >> udf_vfsp->udf_l2d_shift), 744 1, desc_len) == 0) { 745 struct log_vol_int_desc *lvid; 746 747 lvid = (struct log_vol_int_desc *)ttag; 748 749 if (SWAP_32(lvid->lvid_int_type) != 750 LOG_VOL_CLOSE_INT) { 751 error = EINVAL; 752 goto remountout; 753 } 754 755 /* 756 * Copy new data to old data 757 */ 758 bcopy(udf_vfsp->udf_iseq->b_un.b_addr, 759 tpt->b_un.b_addr, udf_vfsp->udf_iseq_len); 760 break; 761 } 762 } 763 764 udf_vfsp->udf_flags = UDF_FL_RW; 765 766 mutex_enter(&udf_vfsp->udf_lock); 767 ud_sbwrite(udf_vfsp); 768 mutex_exit(&udf_vfsp->udf_lock); 769 remountout: 770 if (tpt != NULL) { 771 tpt->b_flags = B_AGE | B_STALE; 772 brelse(tpt); 773 } 774 return (error); 775 } 776 777 ASSERT(devvp != 0); 778 /* 779 * Flush back any dirty pages on the block device to 780 * try and keep the buffer cache in sync with the page 781 * cache if someone is trying to use block devices when 782 * they really should be using the raw device. 783 */ 784 (void) VOP_PUTPAGE(common_specvp(devvp), (offset_t)0, 785 (uint32_t)0, B_INVAL, cr, NULL); 786 787 788 /* 789 * Check if the file system 790 * is a valid udfs and fill 791 * the required fields in udf_vfs 792 */ 793 #ifndef __lint 794 _NOTE(NO_COMPETING_THREADS_NOW); 795 #endif 796 797 if ((lbsize = ud_get_lbsize(dev, &avd_loc)) == 0) { 798 error = EINVAL; 799 goto out; 800 } 801 802 udf_vfsp = ud_validate_and_fill_superblock(dev, lbsize, avd_loc); 803 if (udf_vfsp == NULL) { 804 error = EINVAL; 805 goto out; 806 } 807 808 /* 809 * Fill in vfs private data 810 */ 811 vfsp->vfs_fstype = udf_fstype; 812 vfs_make_fsid(&vfsp->vfs_fsid, dev, udf_fstype); 813 vfsp->vfs_data = (caddr_t)udf_vfsp; 814 vfsp->vfs_dev = dev; 815 vfsp->vfs_flag |= VFS_NOTRUNC; 816 udf_vfsp->udf_devvp = devvp; 817 818 udf_vfsp->udf_fsmnt = kmem_zalloc(strlen(name) + 1, KM_SLEEP); 819 (void) strcpy(udf_vfsp->udf_fsmnt, name); 820 821 udf_vfsp->udf_vfs = vfsp; 822 udf_vfsp->udf_rdclustsz = udf_vfsp->udf_wrclustsz = maxphys; 823 824 udf_vfsp->udf_mod = 0; 825 826 827 lvid = udf_vfsp->udf_lvid; 828 if (vfsp->vfs_flag & VFS_RDONLY) { 829 /* 830 * We could read only UDF1.50 831 * disallow mount of any highier version 832 */ 833 if (udf_vfsp->udf_miread > UDF_150) { 834 error = EINVAL; 835 goto out; 836 } 837 udf_vfsp->udf_flags = UDF_FL_RDONLY; 838 if (SWAP_32(lvid->lvid_int_type) == LOG_VOL_CLOSE_INT) { 839 udf_vfsp->udf_clean = UDF_CLEAN; 840 } else { 841 /* Do we have a VAT at the end of the recorded media */ 842 map = udf_vfsp->udf_maps; 843 for (i = 0; i < udf_vfsp->udf_nmaps; i++) { 844 if (map->udm_flags & UDM_MAP_VPM) { 845 break; 846 } 847 map++; 848 } 849 if (i == udf_vfsp->udf_nmaps) { 850 error = ENOSPC; 851 goto out; 852 } 853 udf_vfsp->udf_clean = UDF_CLEAN; 854 } 855 } else { 856 /* 857 * We could read UDF1.50 and write UDF1.50 only 858 * disallow mount of any highier version 859 */ 860 if ((udf_vfsp->udf_miread > UDF_150) || 861 (udf_vfsp->udf_miwrite > UDF_150)) { 862 error = EINVAL; 863 goto out; 864 } 865 /* 866 * Check if the media allows 867 * us to mount read/write 868 */ 869 if (udf_vfsp->udf_mtype != UDF_MT_OW) { 870 error = EACCES; 871 goto out; 872 } 873 874 /* 875 * Check if we have VAT on a writable media 876 * we cannot use the media in presence of VAT 877 * Dent RW mount. 878 */ 879 map = udf_vfsp->udf_maps; 880 ASSERT(map != NULL); 881 for (i = 0; i < udf_vfsp->udf_nmaps; i++) { 882 if (map->udm_flags & UDM_MAP_VPM) { 883 error = EACCES; 884 goto out; 885 } 886 map++; 887 } 888 889 /* 890 * Check if the domain Id allows 891 * us to write 892 */ 893 if (udf_vfsp->udf_lvd->lvd_dom_id.reg_ids[2] & 0x3) { 894 error = EACCES; 895 goto out; 896 } 897 udf_vfsp->udf_flags = UDF_FL_RW; 898 899 if (SWAP_32(lvid->lvid_int_type) == LOG_VOL_CLOSE_INT) { 900 udf_vfsp->udf_clean = UDF_CLEAN; 901 } else { 902 if (isroot) { 903 udf_vfsp->udf_clean = UDF_DIRTY; 904 } else { 905 error = ENOSPC; 906 goto out; 907 } 908 } 909 } 910 911 mutex_init(&udf_vfsp->udf_lock, NULL, MUTEX_DEFAULT, NULL); 912 913 mutex_init(&udf_vfsp->udf_rename_lck, NULL, MUTEX_DEFAULT, NULL); 914 915 #ifndef __lint 916 _NOTE(COMPETING_THREADS_NOW); 917 #endif 918 if (error = ud_iget(vfsp, udf_vfsp->udf_ricb_prn, 919 udf_vfsp->udf_ricb_loc, &rip, NULL, cr)) { 920 mutex_destroy(&udf_vfsp->udf_lock); 921 goto out; 922 } 923 924 925 /* 926 * Get the root inode and 927 * initialize the root vnode 928 */ 929 rvp = ITOV(rip); 930 mutex_enter(&rvp->v_lock); 931 rvp->v_flag |= VROOT; 932 mutex_exit(&rvp->v_lock); 933 udf_vfsp->udf_root = rvp; 934 935 936 if (why == ROOT_INIT && isroot) 937 rootvp = devvp; 938 939 ud_vfs_add(udf_vfsp); 940 941 if (udf_vfsp->udf_flags == UDF_FL_RW) { 942 udf_vfsp->udf_clean = UDF_DIRTY; 943 ud_update_superblock(vfsp); 944 } 945 946 return (0); 947 948 out: 949 ud_destroy_fsp(udf_vfsp); 950 if (needclose) { 951 (void) VOP_CLOSE(devvp, (vfsp->vfs_flag & VFS_RDONLY) ? 952 FREAD : FREAD|FWRITE, 1, (offset_t)0, cr, NULL); 953 bflush(dev); 954 binval(dev); 955 } 956 VN_RELE(devvp); 957 958 return (error); 959 } 960 961 962 static struct udf_vfs * 963 ud_validate_and_fill_superblock(dev_t dev, int32_t bsize, uint32_t avd_loc) 964 { 965 int32_t error, count, index, shift; 966 uint32_t dummy, vds_loc; 967 caddr_t addr; 968 daddr_t blkno, lblkno; 969 struct buf *secbp, *bp; 970 struct tag *ttag; 971 struct anch_vol_desc_ptr *avdp; 972 struct file_set_desc *fsd; 973 struct udf_vfs *udf_vfsp = NULL; 974 struct pmap_hdr *hdr; 975 struct pmap_typ1 *typ1; 976 struct pmap_typ2 *typ2; 977 struct ud_map *map; 978 int32_t desc_len; 979 980 ud_printf("ud_validate_and_fill_superblock\n"); 981 982 if (bsize < DEV_BSIZE) { 983 return (NULL); 984 } 985 shift = 0; 986 while ((bsize >> shift) > DEV_BSIZE) { 987 shift++; 988 } 989 990 /* 991 * Read Anchor Volume Descriptor 992 * Verify it and get the location of 993 * Main Volume Descriptor Sequence 994 */ 995 secbp = ud_bread(dev, avd_loc << shift, ANCHOR_VOL_DESC_LEN); 996 if ((error = geterror(secbp)) != 0) { 997 cmn_err(CE_NOTE, "udfs : Could not read Anchor Volume Desc %x", 998 error); 999 brelse(secbp); 1000 return (NULL); 1001 } 1002 avdp = (struct anch_vol_desc_ptr *)secbp->b_un.b_addr; 1003 if (ud_verify_tag_and_desc(&avdp->avd_tag, UD_ANCH_VOL_DESC, 1004 avd_loc, 1, ANCHOR_VOL_DESC_LEN) != 0) { 1005 brelse(secbp); 1006 return (NULL); 1007 } 1008 udf_vfsp = (struct udf_vfs *) 1009 kmem_zalloc(sizeof (struct udf_vfs), KM_SLEEP); 1010 udf_vfsp->udf_mvds_loc = SWAP_32(avdp->avd_main_vdse.ext_loc); 1011 udf_vfsp->udf_mvds_len = SWAP_32(avdp->avd_main_vdse.ext_len); 1012 udf_vfsp->udf_rvds_loc = SWAP_32(avdp->avd_res_vdse.ext_loc); 1013 udf_vfsp->udf_rvds_len = SWAP_32(avdp->avd_res_vdse.ext_len); 1014 secbp->b_flags = B_AGE | B_STALE; 1015 brelse(secbp); 1016 1017 /* 1018 * Read Main Volume Descriptor Sequence 1019 * and process it 1020 */ 1021 vds_loc = udf_vfsp->udf_mvds_loc; 1022 secbp = ud_bread(dev, vds_loc << shift, 1023 udf_vfsp->udf_mvds_len); 1024 if ((error = geterror(secbp)) != 0) { 1025 brelse(secbp); 1026 cmn_err(CE_NOTE, "udfs : Could not read Main Volume Desc %x", 1027 error); 1028 1029 vds_loc = udf_vfsp->udf_rvds_loc; 1030 secbp = ud_bread(dev, vds_loc << shift, 1031 udf_vfsp->udf_rvds_len); 1032 if ((error = geterror(secbp)) != 0) { 1033 brelse(secbp); 1034 cmn_err(CE_NOTE, 1035 "udfs : Could not read Res Volume Desc %x", error); 1036 return (NULL); 1037 } 1038 } 1039 1040 udf_vfsp->udf_vds = ngeteblk(udf_vfsp->udf_mvds_len); 1041 bp = udf_vfsp->udf_vds; 1042 bp->b_edev = dev; 1043 bp->b_dev = cmpdev(dev); 1044 bp->b_blkno = vds_loc << shift; 1045 bp->b_bcount = udf_vfsp->udf_mvds_len; 1046 bcopy(secbp->b_un.b_addr, bp->b_un.b_addr, udf_vfsp->udf_mvds_len); 1047 secbp->b_flags |= B_STALE | B_AGE; 1048 brelse(secbp); 1049 1050 1051 count = udf_vfsp->udf_mvds_len / DEV_BSIZE; 1052 addr = bp->b_un.b_addr; 1053 for (index = 0; index < count; index ++) { 1054 ttag = (struct tag *)(addr + index * DEV_BSIZE); 1055 desc_len = udf_vfsp->udf_mvds_len - (index * DEV_BSIZE); 1056 if (ud_verify_tag_and_desc(ttag, UD_PRI_VOL_DESC, 1057 vds_loc + (index >> shift), 1058 1, desc_len) == 0) { 1059 if (udf_vfsp->udf_pvd == NULL) { 1060 udf_vfsp->udf_pvd = 1061 (struct pri_vol_desc *)ttag; 1062 } else { 1063 struct pri_vol_desc *opvd, *npvd; 1064 1065 opvd = udf_vfsp->udf_pvd; 1066 npvd = (struct pri_vol_desc *)ttag; 1067 1068 if ((strncmp(opvd->pvd_vsi, 1069 npvd->pvd_vsi, 128) == 0) && 1070 (strncmp(opvd->pvd_vol_id, 1071 npvd->pvd_vol_id, 32) == 0) && 1072 (strncmp((caddr_t)&opvd->pvd_desc_cs, 1073 (caddr_t)&npvd->pvd_desc_cs, 1074 sizeof (charspec_t)) == 0)) { 1075 1076 if (SWAP_32(opvd->pvd_vdsn) < 1077 SWAP_32(npvd->pvd_vdsn)) { 1078 udf_vfsp->udf_pvd = npvd; 1079 } 1080 } else { 1081 goto out; 1082 } 1083 } 1084 } else if (ud_verify_tag_and_desc(ttag, UD_LOG_VOL_DESC, 1085 vds_loc + (index >> shift), 1086 1, desc_len) == 0) { 1087 struct log_vol_desc *lvd; 1088 1089 lvd = (struct log_vol_desc *)ttag; 1090 if (strncmp(lvd->lvd_dom_id.reg_id, 1091 UDF_DOMAIN_NAME, 23) != 0) { 1092 printf("Domain ID in lvd is not valid\n"); 1093 goto out; 1094 } 1095 1096 if (udf_vfsp->udf_lvd == NULL) { 1097 udf_vfsp->udf_lvd = lvd; 1098 } else { 1099 struct log_vol_desc *olvd; 1100 1101 olvd = udf_vfsp->udf_lvd; 1102 if ((strncmp((caddr_t)&olvd->lvd_desc_cs, 1103 (caddr_t)&lvd->lvd_desc_cs, 1104 sizeof (charspec_t)) == 0) && 1105 (strncmp(olvd->lvd_lvid, 1106 lvd->lvd_lvid, 128) == 0)) { 1107 if (SWAP_32(olvd->lvd_vdsn) < 1108 SWAP_32(lvd->lvd_vdsn)) { 1109 udf_vfsp->udf_lvd = lvd; 1110 } 1111 } else { 1112 goto out; 1113 } 1114 } 1115 } else if (ud_verify_tag_and_desc(ttag, UD_PART_DESC, 1116 vds_loc + (index >> shift), 1117 1, desc_len) == 0) { 1118 int32_t i; 1119 struct phdr_desc *hdr; 1120 struct part_desc *pdesc; 1121 struct ud_part *pnew, *pold, *part; 1122 1123 pdesc = (struct part_desc *)ttag; 1124 pold = udf_vfsp->udf_parts; 1125 for (i = 0; i < udf_vfsp->udf_npart; i++) { 1126 if (pold->udp_number != 1127 SWAP_16(pdesc->pd_pnum)) { 1128 pold++; 1129 continue; 1130 } 1131 1132 if (SWAP_32(pdesc->pd_vdsn) > 1133 pold->udp_seqno) { 1134 pold->udp_seqno = 1135 SWAP_32(pdesc->pd_vdsn); 1136 pold->udp_access = 1137 SWAP_32(pdesc->pd_acc_type); 1138 pold->udp_start = 1139 SWAP_32(pdesc->pd_part_start); 1140 pold->udp_length = 1141 SWAP_32(pdesc->pd_part_length); 1142 } 1143 goto loop_end; 1144 } 1145 pold = udf_vfsp->udf_parts; 1146 udf_vfsp->udf_npart++; 1147 pnew = kmem_zalloc(udf_vfsp->udf_npart * 1148 sizeof (struct ud_part), KM_SLEEP); 1149 udf_vfsp->udf_parts = pnew; 1150 if (pold) { 1151 bcopy(pold, pnew, 1152 sizeof (struct ud_part) * 1153 (udf_vfsp->udf_npart - 1)); 1154 kmem_free(pold, 1155 sizeof (struct ud_part) * 1156 (udf_vfsp->udf_npart - 1)); 1157 } 1158 part = pnew + (udf_vfsp->udf_npart - 1); 1159 part->udp_number = SWAP_16(pdesc->pd_pnum); 1160 part->udp_seqno = SWAP_32(pdesc->pd_vdsn); 1161 part->udp_access = SWAP_32(pdesc->pd_acc_type); 1162 part->udp_start = SWAP_32(pdesc->pd_part_start); 1163 part->udp_length = SWAP_32(pdesc->pd_part_length); 1164 part->udp_last_alloc = 0; 1165 1166 /* 1167 * Figure out space bitmaps 1168 * or space tables 1169 */ 1170 hdr = (struct phdr_desc *)pdesc->pd_pc_use; 1171 if (hdr->phdr_ust.sad_ext_len) { 1172 part->udp_flags = UDP_SPACETBLS; 1173 part->udp_unall_loc = 1174 SWAP_32(hdr->phdr_ust.sad_ext_loc); 1175 part->udp_unall_len = 1176 SWAP_32(hdr->phdr_ust.sad_ext_len); 1177 part->udp_freed_loc = 1178 SWAP_32(hdr->phdr_fst.sad_ext_loc); 1179 part->udp_freed_len = 1180 SWAP_32(hdr->phdr_fst.sad_ext_len); 1181 } else { 1182 part->udp_flags = UDP_BITMAPS; 1183 part->udp_unall_loc = 1184 SWAP_32(hdr->phdr_usb.sad_ext_loc); 1185 part->udp_unall_len = 1186 SWAP_32(hdr->phdr_usb.sad_ext_len); 1187 part->udp_freed_loc = 1188 SWAP_32(hdr->phdr_fsb.sad_ext_loc); 1189 part->udp_freed_len = 1190 SWAP_32(hdr->phdr_fsb.sad_ext_len); 1191 } 1192 } else if (ud_verify_tag_and_desc(ttag, UD_TERM_DESC, 1193 vds_loc + (index >> shift), 1194 1, desc_len) == 0) { 1195 1196 break; 1197 } 1198 loop_end: 1199 ; 1200 } 1201 if ((udf_vfsp->udf_pvd == NULL) || 1202 (udf_vfsp->udf_lvd == NULL) || 1203 (udf_vfsp->udf_parts == NULL)) { 1204 goto out; 1205 } 1206 1207 /* 1208 * Process Primary Volume Descriptor 1209 */ 1210 (void) strncpy(udf_vfsp->udf_volid, udf_vfsp->udf_pvd->pvd_vol_id, 32); 1211 udf_vfsp->udf_volid[31] = '\0'; 1212 udf_vfsp->udf_tsno = SWAP_16(udf_vfsp->udf_pvd->pvd_tag.tag_sno); 1213 1214 /* 1215 * Process Logical Volume Descriptor 1216 */ 1217 udf_vfsp->udf_lbsize = 1218 SWAP_32(udf_vfsp->udf_lvd->lvd_log_bsize); 1219 udf_vfsp->udf_lbmask = udf_vfsp->udf_lbsize - 1; 1220 udf_vfsp->udf_l2d_shift = shift; 1221 udf_vfsp->udf_l2b_shift = shift + DEV_BSHIFT; 1222 1223 /* 1224 * Check if the media is in 1225 * proper domain. 1226 */ 1227 if (strcmp(udf_vfsp->udf_lvd->lvd_dom_id.reg_id, 1228 UDF_DOMAIN_NAME) != 0) { 1229 goto out; 1230 } 1231 1232 /* 1233 * AVDS offset does not match with the lbsize 1234 * in the lvd 1235 */ 1236 if (udf_vfsp->udf_lbsize != bsize) { 1237 goto out; 1238 } 1239 1240 udf_vfsp->udf_iseq_loc = 1241 SWAP_32(udf_vfsp->udf_lvd->lvd_int_seq_ext.ext_loc); 1242 udf_vfsp->udf_iseq_len = 1243 SWAP_32(udf_vfsp->udf_lvd->lvd_int_seq_ext.ext_len); 1244 1245 udf_vfsp->udf_fsd_prn = 1246 SWAP_16(udf_vfsp->udf_lvd->lvd_lvcu.lad_ext_prn); 1247 udf_vfsp->udf_fsd_loc = 1248 SWAP_32(udf_vfsp->udf_lvd->lvd_lvcu.lad_ext_loc); 1249 udf_vfsp->udf_fsd_len = 1250 SWAP_32(udf_vfsp->udf_lvd->lvd_lvcu.lad_ext_len); 1251 1252 1253 /* 1254 * process paritions 1255 */ 1256 udf_vfsp->udf_mtype = udf_vfsp->udf_parts[0].udp_access; 1257 for (index = 0; index < udf_vfsp->udf_npart; index ++) { 1258 if (udf_vfsp->udf_parts[index].udp_access < 1259 udf_vfsp->udf_mtype) { 1260 udf_vfsp->udf_mtype = 1261 udf_vfsp->udf_parts[index].udp_access; 1262 } 1263 } 1264 if ((udf_vfsp->udf_mtype < UDF_MT_RO) || 1265 (udf_vfsp->udf_mtype > UDF_MT_OW)) { 1266 udf_vfsp->udf_mtype = UDF_MT_RO; 1267 } 1268 1269 udf_vfsp->udf_nmaps = 0; 1270 hdr = (struct pmap_hdr *)udf_vfsp->udf_lvd->lvd_pmaps; 1271 count = SWAP_32(udf_vfsp->udf_lvd->lvd_num_pmaps); 1272 for (index = 0; index < count; index++) { 1273 1274 if ((hdr->maph_type == MAP_TYPE1) && 1275 (hdr->maph_length == MAP_TYPE1_LEN)) { 1276 typ1 = (struct pmap_typ1 *)hdr; 1277 1278 map = udf_vfsp->udf_maps; 1279 udf_vfsp->udf_maps = 1280 kmem_zalloc(sizeof (struct ud_map) * 1281 (udf_vfsp->udf_nmaps + 1), KM_SLEEP); 1282 if (map != NULL) { 1283 bcopy(map, udf_vfsp->udf_maps, 1284 sizeof (struct ud_map) * 1285 udf_vfsp->udf_nmaps); 1286 kmem_free(map, sizeof (struct ud_map) * 1287 udf_vfsp->udf_nmaps); 1288 } 1289 map = udf_vfsp->udf_maps + udf_vfsp->udf_nmaps; 1290 map->udm_flags = UDM_MAP_NORM; 1291 map->udm_vsn = SWAP_16(typ1->map1_vsn); 1292 map->udm_pn = SWAP_16(typ1->map1_pn); 1293 udf_vfsp->udf_nmaps ++; 1294 } else if ((hdr->maph_type == MAP_TYPE2) && 1295 (hdr->maph_length == MAP_TYPE2_LEN)) { 1296 typ2 = (struct pmap_typ2 *)hdr; 1297 1298 if (strncmp(typ2->map2_pti.reg_id, 1299 UDF_VIRT_PART, 23) == 0) { 1300 /* 1301 * Add this to the normal 1302 * partition table so that 1303 * we donot 1304 */ 1305 map = udf_vfsp->udf_maps; 1306 udf_vfsp->udf_maps = 1307 kmem_zalloc(sizeof (struct ud_map) * 1308 (udf_vfsp->udf_nmaps + 1), KM_SLEEP); 1309 if (map != NULL) { 1310 bcopy(map, udf_vfsp->udf_maps, 1311 sizeof (struct ud_map) * 1312 udf_vfsp->udf_nmaps); 1313 kmem_free(map, 1314 sizeof (struct ud_map) * 1315 udf_vfsp->udf_nmaps); 1316 } 1317 map = udf_vfsp->udf_maps + udf_vfsp->udf_nmaps; 1318 map->udm_flags = UDM_MAP_VPM; 1319 map->udm_vsn = SWAP_16(typ2->map2_vsn); 1320 map->udm_pn = SWAP_16(typ2->map2_pn); 1321 udf_vfsp->udf_nmaps ++; 1322 if (error = ud_get_last_block(dev, &lblkno)) { 1323 goto out; 1324 } 1325 if (error = ud_val_get_vat(udf_vfsp, dev, 1326 lblkno, map)) { 1327 goto out; 1328 } 1329 } else if (strncmp(typ2->map2_pti.reg_id, 1330 UDF_SPAR_PART, 23) == 0) { 1331 1332 if (SWAP_16(typ2->map2_pl) != 32) { 1333 printf( 1334 "Packet Length is not valid %x\n", 1335 SWAP_16(typ2->map2_pl)); 1336 goto out; 1337 } 1338 if ((typ2->map2_nst < 1) || 1339 (typ2->map2_nst > 4)) { 1340 goto out; 1341 } 1342 map = udf_vfsp->udf_maps; 1343 udf_vfsp->udf_maps = 1344 kmem_zalloc(sizeof (struct ud_map) * 1345 (udf_vfsp->udf_nmaps + 1), 1346 KM_SLEEP); 1347 if (map != NULL) { 1348 bcopy(map, udf_vfsp->udf_maps, 1349 sizeof (struct ud_map) * 1350 udf_vfsp->udf_nmaps); 1351 kmem_free(map, 1352 sizeof (struct ud_map) * 1353 udf_vfsp->udf_nmaps); 1354 } 1355 map = udf_vfsp->udf_maps + udf_vfsp->udf_nmaps; 1356 map->udm_flags = UDM_MAP_SPM; 1357 map->udm_vsn = SWAP_16(typ2->map2_vsn); 1358 map->udm_pn = SWAP_16(typ2->map2_pn); 1359 1360 udf_vfsp->udf_nmaps ++; 1361 1362 if (error = ud_read_sparing_tbls(udf_vfsp, 1363 dev, map, typ2)) { 1364 goto out; 1365 } 1366 } else { 1367 /* 1368 * Unknown type of partition 1369 * Bail out 1370 */ 1371 goto out; 1372 } 1373 } else { 1374 /* 1375 * Unknown type of partition 1376 * Bail out 1377 */ 1378 goto out; 1379 } 1380 hdr = (struct pmap_hdr *)(((uint8_t *)hdr) + hdr->maph_length); 1381 } 1382 1383 1384 /* 1385 * Read Logical Volume Integrity Sequence 1386 * and process it 1387 */ 1388 secbp = ud_bread(dev, udf_vfsp->udf_iseq_loc << shift, 1389 udf_vfsp->udf_iseq_len); 1390 if ((error = geterror(secbp)) != 0) { 1391 cmn_err(CE_NOTE, 1392 "udfs : Could not read Logical Volume Integrity Sequence %x", 1393 error); 1394 brelse(secbp); 1395 goto out; 1396 } 1397 udf_vfsp->udf_iseq = ngeteblk(udf_vfsp->udf_iseq_len); 1398 bp = udf_vfsp->udf_iseq; 1399 bp->b_edev = dev; 1400 bp->b_dev = cmpdev(dev); 1401 bp->b_blkno = udf_vfsp->udf_iseq_loc << shift; 1402 bp->b_bcount = udf_vfsp->udf_iseq_len; 1403 bcopy(secbp->b_un.b_addr, bp->b_un.b_addr, udf_vfsp->udf_iseq_len); 1404 secbp->b_flags |= B_STALE | B_AGE; 1405 brelse(secbp); 1406 1407 count = udf_vfsp->udf_iseq_len / DEV_BSIZE; 1408 addr = bp->b_un.b_addr; 1409 for (index = 0; index < count; index ++) { 1410 ttag = (struct tag *)(addr + index * DEV_BSIZE); 1411 desc_len = udf_vfsp->udf_iseq_len - (index * DEV_BSIZE); 1412 if (ud_verify_tag_and_desc(ttag, UD_LOG_VOL_INT, 1413 udf_vfsp->udf_iseq_loc + (index >> shift), 1414 1, desc_len) == 0) { 1415 1416 struct log_vol_int_desc *lvid; 1417 1418 lvid = (struct log_vol_int_desc *)ttag; 1419 udf_vfsp->udf_lvid = lvid; 1420 1421 if (SWAP_32(lvid->lvid_int_type) == LOG_VOL_CLOSE_INT) { 1422 udf_vfsp->udf_clean = UDF_CLEAN; 1423 } else { 1424 udf_vfsp->udf_clean = UDF_DIRTY; 1425 } 1426 1427 /* 1428 * update superblock with the metadata 1429 */ 1430 ud_convert_to_superblock(udf_vfsp, lvid); 1431 break; 1432 } 1433 } 1434 1435 if (udf_vfsp->udf_lvid == NULL) { 1436 goto out; 1437 } 1438 1439 if ((blkno = ud_xlate_to_daddr(udf_vfsp, 1440 udf_vfsp->udf_fsd_prn, udf_vfsp->udf_fsd_loc, 1441 1, &dummy)) == 0) { 1442 goto out; 1443 } 1444 secbp = ud_bread(dev, blkno << shift, udf_vfsp->udf_fsd_len); 1445 if ((error = geterror(secbp)) != 0) { 1446 cmn_err(CE_NOTE, 1447 "udfs : Could not read File Set Descriptor %x", error); 1448 brelse(secbp); 1449 goto out; 1450 } 1451 fsd = (struct file_set_desc *)secbp->b_un.b_addr; 1452 if (ud_verify_tag_and_desc(&fsd->fsd_tag, UD_FILE_SET_DESC, 1453 udf_vfsp->udf_fsd_loc, 1454 1, udf_vfsp->udf_fsd_len) != 0) { 1455 secbp->b_flags = B_AGE | B_STALE; 1456 brelse(secbp); 1457 goto out; 1458 } 1459 udf_vfsp->udf_ricb_prn = SWAP_16(fsd->fsd_root_icb.lad_ext_prn); 1460 udf_vfsp->udf_ricb_loc = SWAP_32(fsd->fsd_root_icb.lad_ext_loc); 1461 udf_vfsp->udf_ricb_len = SWAP_32(fsd->fsd_root_icb.lad_ext_len); 1462 secbp->b_flags = B_AGE | B_STALE; 1463 brelse(secbp); 1464 udf_vfsp->udf_root_blkno = ud_xlate_to_daddr(udf_vfsp, 1465 udf_vfsp->udf_ricb_prn, udf_vfsp->udf_ricb_loc, 1466 1, &dummy); 1467 1468 return (udf_vfsp); 1469 out: 1470 ud_destroy_fsp(udf_vfsp); 1471 1472 return (NULL); 1473 } 1474 1475 /* 1476 * release/free resources from one ud_map; map data was zalloc'd in 1477 * ud_validate_and_fill_superblock() and fields may later point to 1478 * valid data 1479 */ 1480 static void 1481 ud_free_map(struct ud_map *map) 1482 { 1483 uint32_t n; 1484 1485 if (map->udm_flags & UDM_MAP_VPM) { 1486 if (map->udm_count) { 1487 kmem_free(map->udm_count, 1488 map->udm_nent * sizeof (*map->udm_count)); 1489 map->udm_count = NULL; 1490 } 1491 if (map->udm_bp) { 1492 for (n = 0; n < map->udm_nent; n++) { 1493 if (map->udm_bp[n]) 1494 brelse(map->udm_bp[n]); 1495 } 1496 kmem_free(map->udm_bp, 1497 map->udm_nent * sizeof (*map->udm_bp)); 1498 map->udm_bp = NULL; 1499 } 1500 if (map->udm_addr) { 1501 kmem_free(map->udm_addr, 1502 map->udm_nent * sizeof (*map->udm_addr)); 1503 map->udm_addr = NULL; 1504 } 1505 } 1506 if (map->udm_flags & UDM_MAP_SPM) { 1507 for (n = 0; n < MAX_SPM; n++) { 1508 if (map->udm_sbp[n]) { 1509 brelse(map->udm_sbp[n]); 1510 map->udm_sbp[n] = NULL; 1511 map->udm_spaddr[n] = NULL; 1512 } 1513 } 1514 } 1515 } 1516 1517 void 1518 ud_destroy_fsp(struct udf_vfs *udf_vfsp) 1519 { 1520 int32_t i; 1521 1522 ud_printf("ud_destroy_fsp\n"); 1523 if (udf_vfsp == NULL) 1524 return; 1525 1526 if (udf_vfsp->udf_maps) { 1527 for (i = 0; i < udf_vfsp->udf_nmaps; i++) 1528 ud_free_map(&udf_vfsp->udf_maps[i]); 1529 1530 kmem_free(udf_vfsp->udf_maps, 1531 udf_vfsp->udf_nmaps * sizeof (*udf_vfsp->udf_maps)); 1532 } 1533 1534 if (udf_vfsp->udf_parts) { 1535 kmem_free(udf_vfsp->udf_parts, 1536 udf_vfsp->udf_npart * sizeof (*udf_vfsp->udf_parts)); 1537 } 1538 if (udf_vfsp->udf_iseq) { 1539 udf_vfsp->udf_iseq->b_flags |= (B_STALE|B_AGE); 1540 brelse(udf_vfsp->udf_iseq); 1541 } 1542 if (udf_vfsp->udf_vds) { 1543 udf_vfsp->udf_vds->b_flags |= (B_STALE|B_AGE); 1544 brelse(udf_vfsp->udf_vds); 1545 } 1546 if (udf_vfsp->udf_vfs) 1547 ud_vfs_remove(udf_vfsp); 1548 if (udf_vfsp->udf_fsmnt) { 1549 kmem_free(udf_vfsp->udf_fsmnt, 1550 strlen(udf_vfsp->udf_fsmnt) + 1); 1551 } 1552 kmem_free(udf_vfsp, sizeof (*udf_vfsp)); 1553 } 1554 1555 void 1556 ud_convert_to_superblock(struct udf_vfs *udf_vfsp, 1557 struct log_vol_int_desc *lvid) 1558 { 1559 int32_t i, c; 1560 uint32_t *temp; 1561 struct ud_part *ud_part; 1562 struct lvid_iu *iu; 1563 1564 udf_vfsp->udf_maxuniq = SWAP_64(lvid->lvid_uniqid); 1565 temp = lvid->lvid_fst; 1566 c = SWAP_32(lvid->lvid_npart); 1567 ud_part = udf_vfsp->udf_parts; 1568 for (i = 0; i < c; i++) { 1569 if (i >= udf_vfsp->udf_npart) { 1570 continue; 1571 } 1572 ud_part->udp_nfree = SWAP_32(temp[i]); 1573 ud_part->udp_nblocks = SWAP_32(temp[c + i]); 1574 udf_vfsp->udf_freeblks += SWAP_32(temp[i]); 1575 udf_vfsp->udf_totalblks += SWAP_32(temp[c + i]); 1576 ud_part++; 1577 } 1578 1579 iu = (struct lvid_iu *)(temp + c * 2); 1580 udf_vfsp->udf_nfiles = SWAP_32(iu->lvidiu_nfiles); 1581 udf_vfsp->udf_ndirs = SWAP_32(iu->lvidiu_ndirs); 1582 udf_vfsp->udf_miread = BCD2HEX_16(SWAP_16(iu->lvidiu_mread)); 1583 udf_vfsp->udf_miwrite = BCD2HEX_16(SWAP_16(iu->lvidiu_mwrite)); 1584 udf_vfsp->udf_mawrite = BCD2HEX_16(SWAP_16(iu->lvidiu_maxwr)); 1585 } 1586 1587 void 1588 ud_update_superblock(struct vfs *vfsp) 1589 { 1590 struct udf_vfs *udf_vfsp; 1591 1592 ud_printf("ud_update_superblock\n"); 1593 1594 udf_vfsp = (struct udf_vfs *)vfsp->vfs_data; 1595 1596 mutex_enter(&udf_vfsp->udf_lock); 1597 ud_sbwrite(udf_vfsp); 1598 mutex_exit(&udf_vfsp->udf_lock); 1599 } 1600 1601 1602 #include <sys/dkio.h> 1603 #include <sys/cdio.h> 1604 #include <sys/vtoc.h> 1605 1606 /* 1607 * This part of the code is known 1608 * to work with only sparc. It needs 1609 * to be evluated before using it with x86 1610 */ 1611 int32_t 1612 ud_get_last_block(dev_t dev, daddr_t *blkno) 1613 { 1614 struct vtoc vtoc; 1615 struct dk_cinfo dki_info; 1616 int32_t rval, error; 1617 1618 if ((error = cdev_ioctl(dev, DKIOCGVTOC, (intptr_t)&vtoc, 1619 FKIOCTL|FREAD|FNATIVE, CRED(), &rval)) != 0) { 1620 cmn_err(CE_NOTE, "Could not get the vtoc information"); 1621 return (error); 1622 } 1623 1624 if (vtoc.v_sanity != VTOC_SANE) { 1625 return (EINVAL); 1626 } 1627 if ((error = cdev_ioctl(dev, DKIOCINFO, (intptr_t)&dki_info, 1628 FKIOCTL|FREAD|FNATIVE, CRED(), &rval)) != 0) { 1629 cmn_err(CE_NOTE, "Could not get the slice information"); 1630 return (error); 1631 } 1632 1633 if (dki_info.dki_partition > V_NUMPAR) { 1634 return (EINVAL); 1635 } 1636 1637 1638 *blkno = vtoc.v_part[dki_info.dki_partition].p_size; 1639 1640 return (0); 1641 } 1642 1643 /* Search sequentially N - 2, N, N - 152, N - 150 for vat icb */ 1644 /* 1645 * int32_t ud_sub_blks[] = {2, 0, 152, 150}; 1646 */ 1647 int32_t ud_sub_blks[] = {152, 150, 2, 0}; 1648 int32_t ud_sub_count = 4; 1649 1650 /* 1651 * Validate the VAT ICB 1652 */ 1653 static int32_t 1654 ud_val_get_vat(struct udf_vfs *udf_vfsp, dev_t dev, 1655 daddr_t blkno, struct ud_map *udm) 1656 { 1657 struct buf *secbp; 1658 struct file_entry *fe; 1659 int32_t end_loc, i, j, ad_type; 1660 struct short_ad *sad; 1661 struct long_ad *lad; 1662 uint32_t count, blk; 1663 struct ud_part *ud_part; 1664 int err = 0; 1665 1666 end_loc = (blkno >> udf_vfsp->udf_l2d_shift) - 1; 1667 1668 for (i = 0; i < ud_sub_count; i++) { 1669 udm->udm_vat_icb = end_loc - ud_sub_blks[i]; 1670 1671 secbp = ud_bread(dev, 1672 udm->udm_vat_icb << udf_vfsp->udf_l2d_shift, 1673 udf_vfsp->udf_lbsize); 1674 ASSERT(secbp->b_un.b_addr); 1675 1676 fe = (struct file_entry *)secbp->b_un.b_addr; 1677 if (ud_verify_tag_and_desc(&fe->fe_tag, UD_FILE_ENTRY, 0, 1678 0, 0) == 0) { 1679 if (ud_verify_tag_and_desc(&fe->fe_tag, UD_FILE_ENTRY, 1680 SWAP_32(fe->fe_tag.tag_loc), 1681 1, udf_vfsp->udf_lbsize) == 0) { 1682 if (fe->fe_icb_tag.itag_ftype == 0) { 1683 break; 1684 } 1685 } 1686 } 1687 secbp->b_flags |= B_AGE | B_STALE; 1688 brelse(secbp); 1689 } 1690 if (i == ud_sub_count) { 1691 return (EINVAL); 1692 } 1693 1694 ad_type = SWAP_16(fe->fe_icb_tag.itag_flags) & 0x3; 1695 if (ad_type == ICB_FLAG_ONE_AD) { 1696 udm->udm_nent = 1; 1697 } else if (ad_type == ICB_FLAG_SHORT_AD) { 1698 udm->udm_nent = 1699 SWAP_32(fe->fe_len_adesc) / sizeof (struct short_ad); 1700 } else if (ad_type == ICB_FLAG_LONG_AD) { 1701 udm->udm_nent = 1702 SWAP_32(fe->fe_len_adesc) / sizeof (struct long_ad); 1703 } else { 1704 err = EINVAL; 1705 goto end; 1706 } 1707 1708 udm->udm_count = kmem_zalloc(udm->udm_nent * sizeof (*udm->udm_count), 1709 KM_SLEEP); 1710 udm->udm_bp = kmem_zalloc(udm->udm_nent * sizeof (*udm->udm_bp), 1711 KM_SLEEP); 1712 udm->udm_addr = kmem_zalloc(udm->udm_nent * sizeof (*udm->udm_addr), 1713 KM_SLEEP); 1714 1715 if (ad_type == ICB_FLAG_ONE_AD) { 1716 udm->udm_count[0] = (SWAP_64(fe->fe_info_len) - 36) / 1717 sizeof (uint32_t); 1718 udm->udm_bp[0] = secbp; 1719 udm->udm_addr[0] = (uint32_t *) 1720 &fe->fe_spec[SWAP_32(fe->fe_len_ear)]; 1721 return (0); 1722 } 1723 for (i = 0; i < udm->udm_nent; i++) { 1724 if (ad_type == ICB_FLAG_SHORT_AD) { 1725 sad = (struct short_ad *) 1726 (fe->fe_spec + SWAP_32(fe->fe_len_ear)); 1727 sad += i; 1728 count = SWAP_32(sad->sad_ext_len); 1729 blk = SWAP_32(sad->sad_ext_loc); 1730 } else { 1731 lad = (struct long_ad *) 1732 (fe->fe_spec + SWAP_32(fe->fe_len_ear)); 1733 lad += i; 1734 count = SWAP_32(lad->lad_ext_len); 1735 blk = SWAP_32(lad->lad_ext_loc); 1736 ASSERT(SWAP_16(lad->lad_ext_prn) == udm->udm_pn); 1737 } 1738 if ((count & 0x3FFFFFFF) == 0) { 1739 break; 1740 } 1741 if (i < udm->udm_nent - 1) { 1742 udm->udm_count[i] = count / 4; 1743 } else { 1744 udm->udm_count[i] = (count - 36) / 4; 1745 } 1746 ud_part = udf_vfsp->udf_parts; 1747 for (j = 0; j < udf_vfsp->udf_npart; j++) { 1748 if (udm->udm_pn == ud_part->udp_number) { 1749 blk = ud_part->udp_start + blk; 1750 break; 1751 } 1752 } 1753 if (j == udf_vfsp->udf_npart) { 1754 err = EINVAL; 1755 break; 1756 } 1757 1758 count = (count + DEV_BSIZE - 1) & ~(DEV_BSIZE - 1); 1759 udm->udm_bp[i] = ud_bread(dev, 1760 blk << udf_vfsp->udf_l2d_shift, count); 1761 if ((udm->udm_bp[i]->b_error != 0) || 1762 (udm->udm_bp[i]->b_resid)) { 1763 err = EINVAL; 1764 break; 1765 } 1766 udm->udm_addr[i] = (uint32_t *)udm->udm_bp[i]->b_un.b_addr; 1767 } 1768 1769 end: 1770 if (err) 1771 ud_free_map(udm); 1772 secbp->b_flags |= B_AGE | B_STALE; 1773 brelse(secbp); 1774 return (err); 1775 } 1776 1777 int32_t 1778 ud_read_sparing_tbls(struct udf_vfs *udf_vfsp, 1779 dev_t dev, struct ud_map *map, struct pmap_typ2 *typ2) 1780 { 1781 int32_t index, valid = 0; 1782 uint32_t sz; 1783 struct buf *bp; 1784 struct stbl *stbl; 1785 1786 map->udm_plen = SWAP_16(typ2->map2_pl); 1787 map->udm_nspm = typ2->map2_nst; 1788 map->udm_spsz = SWAP_32(typ2->map2_sest); 1789 sz = (map->udm_spsz + udf_vfsp->udf_lbmask) & ~udf_vfsp->udf_lbmask; 1790 if (sz == 0) { 1791 return (0); 1792 } 1793 1794 for (index = 0; index < map->udm_nspm; index++) { 1795 map->udm_loc[index] = SWAP_32(typ2->map2_st[index]); 1796 1797 bp = ud_bread(dev, 1798 map->udm_loc[index] << udf_vfsp->udf_l2d_shift, sz); 1799 if ((bp->b_error != 0) || (bp->b_resid)) { 1800 brelse(bp); 1801 continue; 1802 } 1803 stbl = (struct stbl *)bp->b_un.b_addr; 1804 if (strncmp(stbl->stbl_si.reg_id, UDF_SPAR_TBL, 23) != 0) { 1805 printf("Sparing Identifier does not match\n"); 1806 bp->b_flags |= B_AGE | B_STALE; 1807 brelse(bp); 1808 continue; 1809 } 1810 map->udm_sbp[index] = bp; 1811 map->udm_spaddr[index] = bp->b_un.b_addr; 1812 #ifdef UNDEF 1813 { 1814 struct stbl_entry *te; 1815 int32_t i, tbl_len; 1816 1817 te = (struct stbl_entry *)&stbl->stbl_entry; 1818 tbl_len = SWAP_16(stbl->stbl_len); 1819 1820 printf("%x %x\n", tbl_len, SWAP_32(stbl->stbl_seqno)); 1821 printf("%x %x\n", bp->b_un.b_addr, te); 1822 1823 for (i = 0; i < tbl_len; i++) { 1824 printf("%x %x\n", SWAP_32(te->sent_ol), SWAP_32(te->sent_ml)); 1825 te ++; 1826 } 1827 } 1828 #endif 1829 valid ++; 1830 } 1831 1832 if (valid) { 1833 return (0); 1834 } 1835 return (EINVAL); 1836 } 1837 1838 uint32_t 1839 ud_get_lbsize(dev_t dev, uint32_t *loc) 1840 { 1841 int32_t bsize, shift, index, end_index; 1842 daddr_t last_block; 1843 uint32_t avd_loc; 1844 struct buf *bp; 1845 struct anch_vol_desc_ptr *avdp; 1846 uint32_t session_offset = 0; 1847 int32_t rval; 1848 1849 if (ud_get_last_block(dev, &last_block) != 0) { 1850 end_index = 1; 1851 } else { 1852 end_index = 3; 1853 } 1854 1855 if (cdev_ioctl(dev, CDROMREADOFFSET, (intptr_t)&session_offset, 1856 FKIOCTL|FREAD|FNATIVE, CRED(), &rval) != 0) { 1857 session_offset = 0; 1858 } 1859 1860 for (index = 0; index < end_index; index++) { 1861 1862 for (bsize = DEV_BSIZE, shift = 0; 1863 bsize <= MAXBSIZE; bsize <<= 1, shift++) { 1864 1865 if (index == 0) { 1866 avd_loc = 256; 1867 if (bsize <= 2048) { 1868 avd_loc += 1869 session_offset * 2048 / bsize; 1870 } else { 1871 avd_loc += 1872 session_offset / (bsize / 2048); 1873 } 1874 } else if (index == 1) { 1875 avd_loc = last_block - (1 << shift); 1876 } else { 1877 avd_loc = last_block - (256 << shift); 1878 } 1879 1880 bp = ud_bread(dev, avd_loc << shift, 1881 ANCHOR_VOL_DESC_LEN); 1882 if (geterror(bp) != 0) { 1883 brelse(bp); 1884 continue; 1885 } 1886 1887 /* 1888 * Verify if we have avdp here 1889 */ 1890 avdp = (struct anch_vol_desc_ptr *)bp->b_un.b_addr; 1891 if (ud_verify_tag_and_desc(&avdp->avd_tag, 1892 UD_ANCH_VOL_DESC, avd_loc, 1893 1, ANCHOR_VOL_DESC_LEN) != 0) { 1894 bp->b_flags |= B_AGE | B_STALE; 1895 brelse(bp); 1896 continue; 1897 } 1898 bp->b_flags |= B_AGE | B_STALE; 1899 brelse(bp); 1900 *loc = avd_loc; 1901 return (bsize); 1902 } 1903 } 1904 1905 /* 1906 * Did not find AVD at all the locations 1907 */ 1908 return (0); 1909 } 1910 1911 static int 1912 udfinit(int fstype, char *name) 1913 { 1914 static const fs_operation_def_t udf_vfsops_template[] = { 1915 VFSNAME_MOUNT, { .vfs_mount = udf_mount }, 1916 VFSNAME_UNMOUNT, { .vfs_unmount = udf_unmount }, 1917 VFSNAME_ROOT, { .vfs_root = udf_root }, 1918 VFSNAME_STATVFS, { .vfs_statvfs = udf_statvfs }, 1919 VFSNAME_SYNC, { .vfs_sync = udf_sync }, 1920 VFSNAME_VGET, { .vfs_vget = udf_vget }, 1921 VFSNAME_MOUNTROOT, { .vfs_mountroot = udf_mountroot }, 1922 NULL, NULL 1923 }; 1924 extern struct vnodeops *udf_vnodeops; 1925 extern const fs_operation_def_t udf_vnodeops_template[]; 1926 int error; 1927 1928 ud_printf("udfinit\n"); 1929 1930 error = vfs_setfsops(fstype, udf_vfsops_template, NULL); 1931 if (error != 0) { 1932 cmn_err(CE_WARN, "udfinit: bad vfs ops template"); 1933 return (error); 1934 } 1935 1936 error = vn_make_ops(name, udf_vnodeops_template, &udf_vnodeops); 1937 if (error != 0) { 1938 (void) vfs_freevfsops_by_type(fstype); 1939 cmn_err(CE_WARN, "udfinit: bad vnode ops template"); 1940 return (error); 1941 } 1942 1943 udf_fstype = fstype; 1944 1945 ud_init_inodes(); 1946 1947 return (0); 1948 } 1949