![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cd9660_vfsops.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / isofs / cd9660|
Return to cd9660_vfsops.c CVS log | Up to [Apple XNU] / XNU / bsd / isofs / cd9660 |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* $NetBSD: cd9660_vfsops.c,v 1.18 1995/03/09 12:05:36 mycroft Exp $ */ ! 23: ! 24: /*- ! 25: * Copyright (c) 1994 ! 26: * The Regents of the University of California. All rights reserved. ! 27: * ! 28: * This code is derived from software contributed to Berkeley ! 29: * by Pace Willisson ([email protected]). The Rock Ridge Extension ! 30: * Support code is derived from software contributed to Berkeley ! 31: * by Atsushi Murai ([email protected]). ! 32: * ! 33: * Redistribution and use in source and binary forms, with or without ! 34: * modification, are permitted provided that the following conditions ! 35: * are met: ! 36: * 1. Redistributions of source code must retain the above copyright ! 37: * notice, this list of conditions and the following disclaimer. ! 38: * 2. Redistributions in binary form must reproduce the above copyright ! 39: * notice, this list of conditions and the following disclaimer in the ! 40: * documentation and/or other materials provided with the distribution. ! 41: * 3. All advertising materials mentioning features or use of this software ! 42: * must display the following acknowledgement: ! 43: * This product includes software developed by the University of ! 44: * California, Berkeley and its contributors. ! 45: * 4. Neither the name of the University nor the names of its contributors ! 46: * may be used to endorse or promote products derived from this software ! 47: * without specific prior written permission. ! 48: * ! 49: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 50: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 51: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 52: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 53: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 54: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 55: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 56: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 57: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 58: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 59: * SUCH DAMAGE. ! 60: * ! 61: * @(#)cd9660_vfsops.c 8.9 (Berkeley) 12/5/94 ! 62: ! 63: ! 64: ! 65: * HISTORY ! 66: * 18-Nov-98 Add support for volfs - djb ! 67: * 22-Jan-98 radar 1669467 - ISO 9660 CD support - jwc ! 68: ! 69: */ ! 70: ! 71: #include <sys/param.h> ! 72: #include <sys/systm.h> ! 73: #include <sys/namei.h> ! 74: #include <sys/proc.h> ! 75: #include <sys/kernel.h> ! 76: #include <sys/vnode.h> ! 77: #include <miscfs/specfs/specdev.h> ! 78: #include <sys/mount.h> ! 79: #include <sys/buf.h> ! 80: #include <sys/file.h> ! 81: #include <sys/disklabel.h> ! 82: #include <sys/ioctl.h> ! 83: #include <sys/errno.h> ! 84: #include <sys/malloc.h> ! 85: #include <sys/stat.h> ! 86: ! 87: #include <isofs/cd9660/iso.h> ! 88: #include <isofs/cd9660/iso_rrip.h> ! 89: #include <isofs/cd9660/cd9660_node.h> ! 90: #include <isofs/cd9660/cd9660_mount.h> ! 91: ! 92: extern int enodev (); ! 93: ! 94: struct vfsops cd9660_vfsops = { ! 95: cd9660_mount, ! 96: cd9660_start, ! 97: cd9660_unmount, ! 98: cd9660_root, ! 99: cd9660_quotactl, ! 100: cd9660_statfs, ! 101: cd9660_sync, ! 102: cd9660_vget, ! 103: cd9660_fhtovp, ! 104: cd9660_vptofh, ! 105: cd9660_init, ! 106: cd9660_sysctl ! 107: }; ! 108: ! 109: /* ! 110: * Called by vfs_mountroot when iso is going to be mounted as root. ! 111: * ! 112: * Name is updated by mount(8) after booting. ! 113: */ ! 114: #define ROOTNAME "root_device" ! 115: ! 116: static int iso_mountfs __P((struct vnode *devvp, struct mount *mp, ! 117: struct proc *p, struct iso_args *argp)); ! 118: #if 1 // radar 1669467 ! 119: static void DRGetTypeCreatorAndFlags( struct iso_mnt * theMountPointPtr, ! 120: struct iso_directory_record * theDirRecPtr, ! 121: u_int32_t * theTypePtr, ! 122: u_int32_t * theCreatorPtr, ! 123: u_int16_t * theFlagsPtr ); // radar 1669467 ! 124: ! 125: int cd9660_vget_internal( struct mount *mp, ! 126: ino_t ino, ! 127: struct vnode **vpp, ! 128: int relocated, ! 129: struct iso_directory_record *isodir, ! 130: struct proc *p ); ! 131: #endif // radar 1669467 ! 132: ! 133: ! 134: int ! 135: cd9660_mountroot() ! 136: { ! 137: register struct mount *mp; ! 138: extern struct vnode *rootvp; ! 139: struct proc *p = current_proc(); /* XXX */ ! 140: struct iso_mnt *imp; ! 141: //register struct fs *fs; radar 1669467 - get rid of warning ! 142: size_t size; ! 143: int error; ! 144: struct iso_args args; ! 145: ! 146: ! 147: /* ! 148: * Get vnodes for swapdev and rootdev. ! 149: */ ! 150: #if 0 ! 151: if (bdevvp(swapdev, &swapdev_vp) || bdevvp(rootdev, &rootvp)) ! 152: panic("cd9660_mountroot: can't setup bdevvp's"); ! 153: #else ! 154: if ( bdevvp(rootdev, &rootvp)) ! 155: panic("cd9660_mountroot: can't setup bdevvp's"); ! 156: ! 157: #endif ! 158: ! 159: MALLOC_ZONE(mp, struct mount *, ! 160: sizeof(struct mount), M_MOUNT, M_WAITOK); ! 161: bzero((char *)mp, (u_long)sizeof(struct mount)); ! 162: mp->mnt_op = &cd9660_vfsops; ! 163: mp->mnt_flag = MNT_RDONLY; ! 164: LIST_INIT(&mp->mnt_vnodelist); ! 165: args.flags = ISOFSMNT_ROOT; ! 166: if ((error = iso_mountfs(rootvp, mp, p, &args))) { ! 167: FREE_ZONE(mp, sizeof (struct mount), M_MOUNT); ! 168: return (error); ! 169: } ! 170: simple_lock(&mountlist_slock); ! 171: #if 0 ! 172: if (error = VFS_LOCK(mp)) { ! 173: (void)cd9660_unmount(mp, 0, p); ! 174: FREE_ZONE(mp, sizeof (struct mount), M_MOUNT); ! 175: return (error); ! 176: } ! 177: #endif ! 178: CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list); ! 179: simple_unlock(&mountlist_slock); ! 180: mp->mnt_vnodecovered = NULLVP; ! 181: imp = VFSTOISOFS(mp); ! 182: (void) copystr("/", mp->mnt_stat.f_mntonname, MNAMELEN - 1, ! 183: &size); ! 184: bzero(mp->mnt_stat.f_mntonname + size, MNAMELEN - size); ! 185: (void) copystr(ROOTNAME, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, ! 186: &size); ! 187: bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); ! 188: (void)cd9660_statfs(mp, &mp->mnt_stat, p); ! 189: // VFS_UNLOCK(mp); ! 190: return (0); ! 191: } ! 192: ! 193: /* ! 194: * VFS Operations. ! 195: * ! 196: * mount system call ! 197: */ ! 198: int ! 199: cd9660_mount(mp, path, data, ndp, p) ! 200: register struct mount *mp; ! 201: char *path; ! 202: caddr_t data; ! 203: struct nameidata *ndp; ! 204: struct proc *p; ! 205: { ! 206: struct vnode *devvp; ! 207: struct iso_args args; ! 208: size_t size; ! 209: int error; ! 210: struct iso_mnt *imp; ! 211: ! 212: if ( (error = copyin(data, (caddr_t)&args, sizeof (struct iso_args))) ) // radar 1669467 - fix compiler warning ! 213: return (error); ! 214: ! 215: if ((mp->mnt_flag & MNT_RDONLY) == 0) ! 216: return (EROFS); ! 217: ! 218: imp = VFSTOISOFS(mp); // radar 1669467 - imp could be used with out getting set up. ! 219: ! 220: /* ! 221: * If updating, check whether changing from read-only to ! 222: * read/write; if there is no device name, that's all we do. ! 223: */ ! 224: if (mp->mnt_flag & MNT_UPDATE) { ! 225: //imp = VFSTOISOFS(mp); radar 1669467 - we do this above now ! 226: if (args.fspec == 0) ! 227: return (vfs_export(mp, &imp->im_export, &args.export)); ! 228: } ! 229: /* ! 230: * Not an update, or updating the name: look up the name ! 231: * and verify that it refers to a sensible block device. ! 232: */ ! 233: NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p); ! 234: if ( (error = namei(ndp)) ) ! 235: return (error); ! 236: devvp = ndp->ni_vp; ! 237: ! 238: if (devvp->v_type != VBLK) { ! 239: vrele(devvp); ! 240: return ENOTBLK; ! 241: } ! 242: if (major(devvp->v_rdev) >= nblkdev) { ! 243: vrele(devvp); ! 244: return ENXIO; ! 245: } ! 246: if ((mp->mnt_flag & MNT_UPDATE) == 0) ! 247: error = iso_mountfs(devvp, mp, p, &args); ! 248: else { ! 249: if (devvp != imp->im_devvp) ! 250: error = EINVAL; /* needs translation */ ! 251: else ! 252: vrele(devvp); ! 253: } ! 254: if (error) { ! 255: vrele(devvp); ! 256: return error; ! 257: } ! 258: ! 259: /* Set the mount flag to indicate that we support volfs */ ! 260: mp->mnt_flag |= MNT_DOVOLFS; ! 261: ! 262: //imp = VFSTOISOFS(mp); radar 1669467 - we do this above now ! 263: (void) copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN - 1, &size); ! 264: bzero(mp->mnt_stat.f_mntonname + size, MNAMELEN - size); ! 265: (void) copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, ! 266: &size); ! 267: bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size); ! 268: return 0; ! 269: } ! 270: ! 271: /* ! 272: * Common code for mount and mountroot ! 273: */ ! 274: static int ! 275: iso_mountfs(devvp, mp, p, argp) ! 276: register struct vnode *devvp; ! 277: struct mount *mp; ! 278: struct proc *p; ! 279: struct iso_args *argp; ! 280: { ! 281: register struct iso_mnt *isomp = (struct iso_mnt *)0; ! 282: struct buf *bp = NULL; ! 283: dev_t dev = devvp->v_rdev; ! 284: int error = EINVAL; ! 285: //int i, size; ! 286: int needclose = 0; ! 287: int ronly = (mp->mnt_flag & MNT_RDONLY) != 0; ! 288: extern struct vnode *rootvp; ! 289: int iso_bsize; ! 290: int iso_blknum; ! 291: struct iso_volume_descriptor *vdp; ! 292: struct iso_primary_descriptor *pri; ! 293: struct iso_directory_record *rootp; ! 294: int logical_block_size; ! 295: #ifdef 0 ! 296: int devBlockSize=0; ! 297: #endif /* NeXT */ ! 298: ! 299: if (!ronly) ! 300: return EROFS; ! 301: ! 302: /* ! 303: * Disallow multiple mounts of the same device. ! 304: * Disallow mounting of a device that is currently in use ! 305: * (except for root, which might share swap device for miniroot). ! 306: * Flush out any old buffers remaining from a previous use. ! 307: */ ! 308: if ( (error = vfs_mountedon(devvp)) ) ! 309: return error; ! 310: if ( vcount(devvp) > 1 && devvp != rootvp ) ! 311: return EBUSY; ! 312: if ( (error = vinvalbuf(devvp, V_SAVE, p->p_ucred, p, 0, 0)) ) ! 313: return (error); ! 314: ! 315: if ( (error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, p)) ) ! 316: return error; ! 317: needclose = 1; ! 318: ! 319: /* This is the "logical sector size". The standard says this ! 320: * should be 2048 or the physical sector size on the device, ! 321: * whichever is greater. For now, we'll just use a constant. ! 322: */ ! 323: iso_bsize = ISO_DEFAULT_BLOCK_SIZE; ! 324: ! 325: for (iso_blknum = 16; iso_blknum < 100; iso_blknum++) { ! 326: ! 327: #if 1 // radar 1669467 ! 328: if ( (error = bread(devvp, iso_blknum, iso_bsize, NOCRED, &bp)) ) ! 329: { ! 330: goto out; ! 331: }; ! 332: #else ! 333: /* Old code that used incorrect block - btodb is wrong - we should read the iso_blknum */ ! 334: if (error = bread(devvp, iso_blknum * btodb(iso_bsize), ! 335: iso_bsize, NOCRED, &bp)) { ! 336: #ifdef DEBUG ! 337: printf("cd9660_vfsops.c: iso_mountfs: bread() returned %d.\n", error); ! 338: #endif ! 339: goto out; ! 340: }; ! 341: #endif // radar 1669467 ! 342: ! 343: vdp = (struct iso_volume_descriptor *)bp->b_data; ! 344: if (bcmp (vdp->volume_desc_id, ISO_STANDARD_ID, sizeof vdp->volume_desc_id) != 0) { ! 345: #ifdef DEBUG ! 346: printf("cd9660_vfsops.c: iso_mountfs: Invalid ID in volume desciptor.\n"); ! 347: #endif ! 348: error = EINVAL; ! 349: goto out; ! 350: } ! 351: ! 352: if (isonum_711 (vdp->type) == ISO_VD_END) { ! 353: #ifdef DEBUG ! 354: printf("cd9660_vfsops.c: iso_mountfs: isonum_711() != ISO_VD_END.\n"); ! 355: #endif ! 356: error = EINVAL; ! 357: goto out; ! 358: } ! 359: ! 360: if (isonum_711 (vdp->type) == ISO_VD_PRIMARY) ! 361: break; ! 362: brelse(bp); ! 363: } ! 364: ! 365: if (isonum_711 (vdp->type) != ISO_VD_PRIMARY) { ! 366: #ifdef DEBUG ! 367: printf("cd9660_vfsops.c: iso_mountfs: isnum_711() != ISO_VD_PRIMARY.\n"); ! 368: #endif ! 369: error = EINVAL; ! 370: goto out; ! 371: } ! 372: ! 373: pri = (struct iso_primary_descriptor *)vdp; ! 374: ! 375: logical_block_size = isonum_723 (pri->logical_block_size); ! 376: ! 377: if (logical_block_size < DEV_BSIZE || logical_block_size > MAXBSIZE ! 378: || (logical_block_size & (logical_block_size - 1)) != 0) { ! 379: error = EINVAL; ! 380: goto out; ! 381: } ! 382: ! 383: rootp = (struct iso_directory_record *)pri->root_directory_record; ! 384: ! 385: // isomp = malloc(sizeof *isomp, M_ISOFSMNT, M_WAITOK); ! 386: MALLOC(isomp, struct iso_mnt *, sizeof *isomp, M_ISOFSMNT, M_WAITOK); ! 387: bzero((caddr_t)isomp, sizeof *isomp); ! 388: isomp->logical_block_size = logical_block_size; ! 389: isomp->volume_space_size = isonum_733 (pri->volume_space_size); ! 390: bcopy (rootp, isomp->root, sizeof isomp->root); ! 391: isomp->root_extent = isonum_733 (rootp->extent); ! 392: isomp->root_size = isonum_733 (rootp->size); ! 393: ! 394: /* ! 395: * getattrlist wants the volume name, create date and modify date ! 396: */ ! 397: ! 398: /* Remove any trailing white space */ ! 399: if ( strlen(pri->volume_id) ) { ! 400: char *myPtr; ! 401: ! 402: myPtr = pri->volume_id + strlen( pri->volume_id ) - 1; ! 403: while ( *myPtr == ' ' && myPtr >= pri->volume_id ) { ! 404: *myPtr = 0x00; ! 405: myPtr--; ! 406: } ! 407: } ! 408: /* YYY need to use secondary volume descriptor name for kanji disks */ ! 409: bcopy(pri->volume_id, isomp->volume_id, sizeof(isomp->volume_id)); ! 410: cd9660_tstamp_conv17(pri->creation_date, &isomp->creation_date); ! 411: cd9660_tstamp_conv17(pri->modification_date, &isomp->modification_date); ! 412: ! 413: #if 0 ! 414: kprintf("\n************************************************************************* \n"); ! 415: kprintf( "iso_mountfs - pri->primary_desc_id is \"%c%c%c%c%c\" \n", ! 416: pri->primary_desc_id[0], pri->primary_desc_id[1], pri->primary_desc_id[2], ! 417: pri->primary_desc_id[3], pri->primary_desc_id[4] ); ! 418: kprintf( "iso_mountfs - pri->CDXASignature is \"%c%c%c%c%c%c%c%c\" \n", ! 419: pri->CDXASignature[0], pri->CDXASignature[1], pri->CDXASignature[2], ! 420: pri->CDXASignature[3], pri->CDXASignature[4], pri->CDXASignature[5], ! 421: pri->CDXASignature[6], pri->CDXASignature[7] ); ! 422: #endif ! 423: ! 424: #if 1 // radar 1669467 ! 425: /* See if this is a CD-XA volume */ ! 426: if ( bcmp( pri->CDXASignature, ISO_XA_ID, sizeof(pri->CDXASignature) ) == 0 ) ! 427: isomp->im_flags2 |= IMF2_IS_CDXA; ! 428: #endif // radar 1669467 ! 429: ! 430: isomp->im_bmask = logical_block_size - 1; ! 431: isomp->im_bshift = 0; ! 432: while ((1 << isomp->im_bshift) < isomp->logical_block_size) ! 433: isomp->im_bshift++; ! 434: ! 435: bp->b_flags |= B_AGE; ! 436: brelse(bp); ! 437: bp = NULL; ! 438: ! 439: mp->mnt_data = (qaddr_t)isomp; ! 440: mp->mnt_stat.f_fsid.val[0] = (long)dev; ! 441: mp->mnt_stat.f_fsid.val[1] = mp->mnt_vfc->vfc_typenum; ! 442: mp->mnt_maxsymlinklen = 0; ! 443: mp->mnt_flag |= MNT_LOCAL; ! 444: isomp->im_mountp = mp; ! 445: isomp->im_dev = dev; ! 446: isomp->im_devvp = devvp; ! 447: devvp->v_specflags |= SI_MOUNTEDON; ! 448: ! 449: /* Check the Rock Ridge Extention support */ ! 450: if (!(argp->flags & ISOFSMNT_NORRIP)) { ! 451: if ( (error = bread(isomp->im_devvp, ! 452: #if 1 // radar 1669467 ! 453: (isomp->root_extent + isonum_711(rootp->ext_attr_length)), ! 454: #else ! 455: (isomp->root_extent + isonum_711(rootp->ext_attr_length)) << ! 456: (isomp->im_bshift - DEV_BSHIFT), ! 457: #endif // radar 1669467 ! 458: isomp->logical_block_size, NOCRED, &bp)) ) ! 459: goto out; ! 460: ! 461: rootp = (struct iso_directory_record *)bp->b_data; ! 462: ! 463: if ((isomp->rr_skip = cd9660_rrip_offset(rootp,isomp)) < 0) { ! 464: argp->flags |= ISOFSMNT_NORRIP; ! 465: } else { ! 466: argp->flags &= ~ISOFSMNT_GENS; ! 467: } ! 468: ! 469: /* ! 470: * The contents are valid, ! 471: * but they will get reread as part of another vnode, so... ! 472: */ ! 473: bp->b_flags |= B_AGE; ! 474: brelse(bp); ! 475: bp = NULL; ! 476: } ! 477: isomp->im_flags = argp->flags&(ISOFSMNT_NORRIP|ISOFSMNT_GENS|ISOFSMNT_EXTATT); ! 478: switch (isomp->im_flags&(ISOFSMNT_NORRIP|ISOFSMNT_GENS)) { ! 479: default: ! 480: isomp->iso_ftype = ISO_FTYPE_DEFAULT; ! 481: break; ! 482: case ISOFSMNT_GENS|ISOFSMNT_NORRIP: ! 483: isomp->iso_ftype = ISO_FTYPE_9660; ! 484: break; ! 485: case 0: ! 486: isomp->iso_ftype = ISO_FTYPE_RRIP; ! 487: break; ! 488: } ! 489: ! 490: return 0; ! 491: out: ! 492: if (bp) ! 493: brelse(bp); ! 494: if (needclose) ! 495: (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, NOCRED, p); ! 496: if (isomp) { ! 497: FREE((caddr_t)isomp, M_ISOFSMNT); ! 498: mp->mnt_data = (qaddr_t)0; ! 499: } ! 500: ! 501: /* Clear the mounted on bit in the devvp If it */ ! 502: /* not set, this is a nop and there is no way to */ ! 503: /* get here with it set unless we did it. If you*/ ! 504: /* are making code changes which makes the above */ ! 505: /* assumption not true, change this code. */ ! 506: ! 507: devvp->v_specflags &= ~SI_MOUNTEDON; ! 508: ! 509: return error; ! 510: } ! 511: ! 512: /* ! 513: * Make a filesystem operational. ! 514: * Nothing to do at the moment. ! 515: */ ! 516: /* ARGSUSED */ ! 517: int ! 518: cd9660_start(mp, flags, p) ! 519: struct mount *mp; ! 520: int flags; ! 521: struct proc *p; ! 522: { ! 523: return 0; ! 524: } ! 525: ! 526: ! 527: /* ! 528: * unmount system call ! 529: */ ! 530: int ! 531: cd9660_unmount(mp, mntflags, p) ! 532: struct mount *mp; ! 533: int mntflags; ! 534: struct proc *p; ! 535: { ! 536: register struct iso_mnt *isomp; ! 537: int error, flags = 0; ! 538: ! 539: if ( (mntflags & MNT_FORCE) ) ! 540: flags |= FORCECLOSE; ! 541: #if 0 ! 542: mntflushbuf(mp, 0); ! 543: if (mntinvalbuf(mp)) ! 544: return EBUSY; ! 545: #endif ! 546: if ( (error = vflush(mp, NULLVP, flags)) ) ! 547: return (error); ! 548: ! 549: isomp = VFSTOISOFS(mp); ! 550: ! 551: #ifdef ISODEVMAP ! 552: if (isomp->iso_ftype == ISO_FTYPE_RRIP) ! 553: iso_dunmap(isomp->im_dev); ! 554: #endif ! 555: ! 556: isomp->im_devvp->v_specflags &= ~SI_MOUNTEDON; ! 557: error = VOP_CLOSE(isomp->im_devvp, FREAD, NOCRED, p); ! 558: vrele(isomp->im_devvp); ! 559: FREE((caddr_t)isomp, M_ISOFSMNT); ! 560: mp->mnt_data = (qaddr_t)0; ! 561: mp->mnt_flag &= ~MNT_LOCAL; ! 562: ! 563: return (error); ! 564: } ! 565: ! 566: /* ! 567: * Return root of a filesystem ! 568: */ ! 569: int ! 570: cd9660_root(mp, vpp) ! 571: struct mount *mp; ! 572: struct vnode **vpp; ! 573: { ! 574: struct iso_mnt *imp = VFSTOISOFS(mp); ! 575: struct iso_directory_record *dp = ! 576: (struct iso_directory_record *)imp->root; ! 577: ino_t ino = isodirino(dp, imp); ! 578: ! 579: /* ! 580: * With RRIP we must use the `.' entry of the root directory. ! 581: * Simply tell vget, that it's a relocated directory. ! 582: */ ! 583: return (cd9660_vget_internal(mp, ino, vpp, ! 584: imp->iso_ftype == ISO_FTYPE_RRIP, dp, current_proc())); ! 585: } ! 586: ! 587: /* ! 588: * Do operations associated with quotas, not supported ! 589: */ ! 590: /* ARGSUSED */ ! 591: int ! 592: cd9660_quotactl(mp, cmd, uid, arg, p) ! 593: struct mount *mp; ! 594: int cmd; ! 595: uid_t uid; ! 596: caddr_t arg; ! 597: struct proc *p; ! 598: { ! 599: ! 600: return (EOPNOTSUPP); ! 601: } ! 602: ! 603: /* ! 604: * Get file system statistics. ! 605: */ ! 606: int ! 607: cd9660_statfs(mp, sbp, p) ! 608: struct mount *mp; ! 609: register struct statfs *sbp; ! 610: struct proc *p; ! 611: { ! 612: register struct iso_mnt *isomp; ! 613: ! 614: isomp = VFSTOISOFS(mp); ! 615: ! 616: #ifdef COMPAT_09 ! 617: sbp->f_type = 5; ! 618: #else ! 619: sbp->f_type = 0; ! 620: #endif ! 621: sbp->f_bsize = isomp->logical_block_size; ! 622: sbp->f_iosize = sbp->f_bsize; /* XXX */ ! 623: sbp->f_blocks = isomp->volume_space_size; ! 624: sbp->f_bfree = 0; /* total free blocks */ ! 625: sbp->f_bavail = 0; /* blocks free for non superuser */ ! 626: sbp->f_files = 0; /* total files */ ! 627: sbp->f_ffree = 0; /* free file nodes */ ! 628: if (sbp != &mp->mnt_stat) { ! 629: bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN); ! 630: bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN); ! 631: } ! 632: ! 633: #if 1 // radar 1669467 ! 634: strncpy( sbp->f_fstypename, mp->mnt_vfc->vfc_name, (MFSNAMELEN - 1) ); ! 635: sbp->f_fstypename[(MFSNAMELEN - 1)] = '\0'; ! 636: #else ! 637: strncpy(sbp->f_fstypename, mp->mnt_vfc->vfc_name, MFSNAMELEN); ! 638: sbp->f_fstypename[MFSNAMELEN] = '\0'; ! 639: #endif // radar 1669467 ! 640: ! 641: /* Use the first spare for flags: */ ! 642: sbp->f_spare[0] = isomp->im_flags; ! 643: ! 644: return 0; ! 645: } ! 646: ! 647: /* ARGSUSED */ ! 648: int ! 649: cd9660_sync(mp, waitfor, cred, p) ! 650: struct mount *mp; ! 651: int waitfor; ! 652: struct ucred *cred; ! 653: struct proc *p; ! 654: { ! 655: ! 656: return (0); ! 657: } ! 658: ! 659: /* ! 660: * File handle to vnode ! 661: * ! 662: * Have to be really careful about stale file handles: ! 663: * - check that the inode number is in range ! 664: * - call iget() to get the locked inode ! 665: * - check for an unallocated inode (i_mode == 0) ! 666: * - check that the generation number matches ! 667: */ ! 668: ! 669: struct ifid { ! 670: ushort ifid_len; ! 671: ushort ifid_pad; ! 672: int ifid_ino; ! 673: long ifid_start; ! 674: }; ! 675: ! 676: /* ARGSUSED */ ! 677: int ! 678: cd9660_fhtovp(mp, fhp, nam, vpp, exflagsp, credanonp) ! 679: register struct mount *mp; ! 680: struct fid *fhp; ! 681: struct mbuf *nam; ! 682: struct vnode **vpp; ! 683: int *exflagsp; ! 684: struct ucred **credanonp; ! 685: { ! 686: struct ifid *ifhp = (struct ifid *)fhp; ! 687: register struct iso_node *ip; ! 688: register struct netcred *np; ! 689: register struct iso_mnt *imp = VFSTOISOFS(mp); ! 690: struct vnode *nvp; ! 691: int error; ! 692: ! 693: #ifdef ISOFS_DBG ! 694: printf("fhtovp: ino %d, start %ld\n", ! 695: ifhp->ifid_ino, ifhp->ifid_start); ! 696: #endif ! 697: ! 698: /* ! 699: * Get the export permission structure for this <mp, client> tuple. ! 700: */ ! 701: np = vfs_export_lookup(mp, &imp->im_export, nam); ! 702: if (np == NULL) ! 703: return (EACCES); ! 704: ! 705: if ( (error = VFS_VGET(mp, &ifhp->ifid_ino, &nvp)) ) { ! 706: *vpp = NULLVP; ! 707: return (error); ! 708: } ! 709: ip = VTOI(nvp); ! 710: if (ip->inode.iso_mode == 0) { ! 711: vput(nvp); ! 712: *vpp = NULLVP; ! 713: return (ESTALE); ! 714: } ! 715: *vpp = nvp; ! 716: *exflagsp = np->netc_exflags; ! 717: *credanonp = &np->netc_anon; ! 718: return (0); ! 719: } ! 720: ! 721: int ! 722: cd9660_vget(mp, ino, vpp) ! 723: struct mount *mp; ! 724: void *ino; ! 725: struct vnode **vpp; ! 726: { ! 727: /* ! 728: * XXXX ! 729: * It would be nice if we didn't always set the `relocated' flag ! 730: * and force the extra read, but I don't want to think about fixing ! 731: * that right now. ! 732: */ ! 733: ! 734: #if 1 // radar 1669467 - fix compiler warning ! 735: ! 736: return ( cd9660_vget_internal( mp, *(ino_t*)ino, vpp, 0, ! 737: (struct iso_directory_record *) 0, ! 738: current_proc()) ); ! 739: ! 740: #else // radar 1669467 ! 741: ! 742: return (cd9660_vget_internal(mp, *(ino_t*)ino, vpp, ! 743: #if 0 ! 744: VFSTOISOFS(mp)->iso_ftype == ISO_FTYPE_RRIP, ! 745: #else ! 746: 0, ! 747: #endif ! 748: (struct iso_directory_entry *)0)); ! 749: #endif // radar 1669467 ! 750: } ! 751: ! 752: int ! 753: cd9660_vget_internal(mp, ino, vpp, relocated, isodir, p) ! 754: struct mount *mp; ! 755: ino_t ino; ! 756: struct vnode **vpp; ! 757: int relocated; ! 758: struct iso_directory_record *isodir; ! 759: struct proc *p; ! 760: { ! 761: register struct iso_mnt *imp; ! 762: struct iso_node *ip; ! 763: struct buf *bp; ! 764: struct vnode *vp, *nvp; ! 765: dev_t dev; ! 766: int error; ! 767: ! 768: imp = VFSTOISOFS(mp); ! 769: dev = imp->im_dev; ! 770: if ((*vpp = cd9660_ihashget(dev, ino, p)) != NULLVP) ! 771: return (0); ! 772: ! 773: MALLOC(ip, struct iso_node *, sizeof(struct iso_node), M_ISOFSNODE, ! 774: M_WAITOK); ! 775: /* Allocate a new vnode/iso_node. */ ! 776: if ( (error = getnewvnode(VT_ISOFS, mp, cd9660_vnodeop_p, &vp)) ) { ! 777: FREE(ip, M_ISOFSNODE); ! 778: *vpp = NULLVP; ! 779: return (error); ! 780: } ! 781: bzero((caddr_t)ip, sizeof(struct iso_node)); ! 782: ! 783: // radar 1669467 - chw initialize the lock structure now that we are using ! 784: // the lock manager ! 785: ! 786: lockinit(&ip->i_lock, PINOD,"inode",0,0); ! 787: vp->v_data = ip; ! 788: ip->i_vnode = vp; ! 789: ip->i_dev = dev; ! 790: ip->i_number = ino; ! 791: ! 792: /* ! 793: * Put it onto its hash chain and lock it so that other requests for ! 794: * this inode will block if they arrive while we are sleeping waiting ! 795: * for old data structures to be purged or for the contents of the ! 796: * disk portion of this inode to be read. ! 797: */ ! 798: cd9660_ihashins(ip); ! 799: ! 800: if (isodir == 0) { ! 801: int lbn, off; ! 802: ! 803: lbn = lblkno(imp, ino); ! 804: if (lbn >= imp->volume_space_size) { ! 805: vput(vp); ! 806: printf("fhtovp: lbn exceed volume space %d\n", lbn); ! 807: return (ESTALE); ! 808: } ! 809: ! 810: off = blkoff(imp, ino); ! 811: if (off + ISO_DIRECTORY_RECORD_SIZE > imp->logical_block_size) { ! 812: vput(vp); ! 813: printf("fhtovp: crosses block boundary %d\n", ! 814: off + ISO_DIRECTORY_RECORD_SIZE); ! 815: return (ESTALE); ! 816: } ! 817: ! 818: error = bread(imp->im_devvp, ! 819: #if 1 // radar 1669467 ! 820: lbn, ! 821: #else ! 822: lbn << (imp->im_bshift - DEV_BSHIFT), ! 823: #endif // radar 1669467 ! 824: imp->logical_block_size, NOCRED, &bp); ! 825: if (error) { ! 826: vput(vp); ! 827: brelse(bp); ! 828: printf("fhtovp: bread error %d\n",error); ! 829: return (error); ! 830: } ! 831: isodir = (struct iso_directory_record *)(bp->b_data + off); ! 832: ! 833: if (off + isonum_711(isodir->length) > ! 834: imp->logical_block_size) { ! 835: vput(vp); ! 836: if (bp != 0) ! 837: brelse(bp); ! 838: printf("fhtovp: directory crosses block boundary %d[off=%d/len=%d]\n", ! 839: off +isonum_711(isodir->length), off, ! 840: isonum_711(isodir->length)); ! 841: return (ESTALE); ! 842: } ! 843: ! 844: /* ! 845: * for directories we can get parentID from adjacent parent directory record ! 846: */ ! 847: if ((isonum_711(isodir->flags) & directoryBit) && (isodir->name[0] == 0)) { ! 848: struct iso_directory_record *pdp; ! 849: ! 850: pdp = (struct iso_directory_record *) ((char *)bp->b_data + isonum_711(isodir->length)); ! 851: if ((isonum_711(pdp->flags) & directoryBit) && (pdp->name[0] == 1)) ! 852: ip->i_parent = isodirino(pdp, imp); ! 853: ! 854: } ! 855: #if 0 ! 856: if (isonum_733(isodir->extent) + ! 857: isonum_711(isodir->ext_attr_length) != ifhp->ifid_start) { ! 858: if (bp != 0) ! 859: brelse(bp); ! 860: printf("fhtovp: file start miss %d vs %d\n", ! 861: isonum_733(isodir->extent) + isonum_711(isodir->ext_attr_length), ! 862: ifhp->ifid_start); ! 863: return (ESTALE); ! 864: } ! 865: #endif ! 866: } else ! 867: bp = 0; ! 868: ! 869: ip->i_mnt = imp; ! 870: ip->i_devvp = imp->im_devvp; ! 871: VREF(ip->i_devvp); ! 872: ! 873: if (relocated) { ! 874: /* ! 875: * On relocated directories we must ! 876: * read the `.' entry out of a dir. ! 877: */ ! 878: ip->iso_start = ino >> imp->im_bshift; ! 879: if (bp != 0) ! 880: brelse(bp); ! 881: if ( (error = VOP_BLKATOFF(vp, (off_t)0, NULL, &bp)) ) { ! 882: vput(vp); ! 883: return (error); ! 884: } ! 885: isodir = (struct iso_directory_record *)bp->b_data; ! 886: } ! 887: ! 888: #if 1 // radar 1669467 ! 889: ! 890: /* go get apple extensions to ISO directory record or use defaults when there are no apple */ ! 891: /* extensions. */ ! 892: if ( (isonum_711( isodir->flags ) & directoryBit) == 0 ) ! 893: { ! 894: /* This is an ISO directory record for a file */ ! 895: DRGetTypeCreatorAndFlags( imp, isodir, &ip->i_FileType, ! 896: &ip->i_Creator, &ip->i_FinderFlags ); ! 897: } ! 898: ! 899: #endif // radar 1669467 ! 900: ! 901: ip->iso_extent = isonum_733(isodir->extent); ! 902: ip->i_size = isonum_733(isodir->size); ! 903: ip->iso_start = isonum_711(isodir->ext_attr_length) + ip->iso_extent; ! 904: ! 905: /* ! 906: * if we have a valid name, fill in i_name ! 907: */ ! 908: if (((u_char)isodir->name[0]) > 1) { ! 909: u_short namelen; ! 910: ! 911: if (imp->iso_ftype == ISO_FTYPE_RRIP) { ! 912: ino_t inump = 0; ! 913: ! 914: cd9660_rrip_getname(isodir, ip->i_name, &namelen, &inump, imp); ! 915: } else { ! 916: isofntrans (isodir->name, isonum_711(isodir->name_len), ! 917: ip->i_name, &namelen, ! 918: imp->iso_ftype == ISO_FTYPE_9660, ! 919: isonum_711(isodir->flags) & associatedBit); ! 920: } ! 921: ! 922: if (namelen > (sizeof(ip->i_name) - 1)) ! 923: namelen = sizeof(ip->i_name) - 1; ! 924: ip->i_name[namelen] = '\0'; ! 925: } ! 926: ! 927: /* ! 928: * Setup time stamp, attribute ! 929: */ ! 930: vp->v_type = VNON; ! 931: switch (imp->iso_ftype) { ! 932: default: /* ISO_FTYPE_9660 */ ! 933: { ! 934: struct buf *bp2; ! 935: int off; ! 936: if ((imp->im_flags & ISOFSMNT_EXTATT) ! 937: && (off = isonum_711(isodir->ext_attr_length))) ! 938: VOP_BLKATOFF(vp, (off_t)-(off << imp->im_bshift), NULL, ! 939: &bp2); ! 940: else ! 941: bp2 = NULL; ! 942: cd9660_defattr(isodir, ip, bp2); ! 943: cd9660_deftstamp(isodir, ip, bp2); ! 944: if (bp2) ! 945: brelse(bp2); ! 946: break; ! 947: } ! 948: case ISO_FTYPE_RRIP: ! 949: cd9660_rrip_analyze(isodir, ip, imp); ! 950: break; ! 951: } ! 952: ! 953: if (bp != 0) ! 954: brelse(bp); ! 955: ! 956: /* ! 957: * Initialize the associated vnode ! 958: */ ! 959: switch (vp->v_type = IFTOVT(ip->inode.iso_mode)) { ! 960: case VFIFO: ! 961: #if FIFO ! 962: vp->v_op = cd9660_fifoop_p; ! 963: break; ! 964: #else ! 965: vput(vp); ! 966: return (EOPNOTSUPP); ! 967: #endif /* FIFO */ ! 968: case VCHR: ! 969: case VBLK: ! 970: /* ! 971: * if device, look at device number table for translation ! 972: */ ! 973: #ifdef ISODEVMAP ! 974: if (dp = iso_dmap(dev, ino, 0)) ! 975: ip->inode.iso_rdev = dp->d_dev; ! 976: #endif ! 977: vp->v_op = cd9660_specop_p; ! 978: if ( (nvp = checkalias(vp, ip->inode.iso_rdev, mp)) ) { ! 979: /* ! 980: * Discard unneeded vnode, but save its iso_node. ! 981: */ ! 982: cd9660_ihashrem(ip); ! 983: VOP_UNLOCK(vp, 0, p); ! 984: nvp->v_data = vp->v_data; ! 985: vp->v_data = NULL; ! 986: vp->v_op = spec_vnodeop_p; ! 987: vrele(vp); ! 988: vgone(vp); ! 989: /* ! 990: * Reinitialize aliased inode. ! 991: */ ! 992: vp = nvp; ! 993: ip->i_vnode = vp; ! 994: cd9660_ihashins(ip); ! 995: } ! 996: break; ! 997: default: // radar 1669467 - fix compiler warning ! 998: break; ! 999: } ! 1000: ! 1001: if (ip->iso_extent == imp->root_extent) { ! 1002: vp->v_flag |= VROOT; ! 1003: ip->i_parent = 1; /* root's parent is always 1 by convention */ ! 1004: } ! 1005: /* ! 1006: * XXX need generation number? ! 1007: */ ! 1008: ! 1009: *vpp = vp; ! 1010: ! 1011: return (0); ! 1012: } ! 1013: ! 1014: ! 1015: /************************************************************************ ! 1016: * ! 1017: * Function: DRGetTypeCreatorAndFlags ! 1018: * ! 1019: * Purpose: Set up the fileType, fileCreator and fileFlags ! 1020: * ! 1021: * Returns: none ! 1022: * ! 1023: * Side Effects: sets *theTypePtr, *theCreatorPtr, and *theFlagsPtr ! 1024: * ! 1025: * Description: ! 1026: * ! 1027: * Revision History: ! 1028: * 28 Jul 88 BL�B Added a new extension type of 6, which allows ! 1029: * the specification of four of the finder flags. ! 1030: * We let the creator of the disk just copy over ! 1031: * the finder flags, but we only look at always ! 1032: * switch launch, system, bundle, and locked bits. ! 1033: * 15 Aug 88 BL�B The Apple extensions to ISO 9660 implemented the ! 1034: * padding field at the end of a directory record ! 1035: * incorrectly. ! 1036: * 19 Jul 89 BG Rewrote routine to handle the "new" Apple ! 1037: * Extensions definition, as well as take into ! 1038: * account the possibility of "other" definitions. ! 1039: * 02 Nov 89 BG Corrected the 'AA' SystemUseID processing to ! 1040: * check for SystemUseID == 2 (HFS). Was incorrectly ! 1041: * checking for SystemUseID == 1 (ProDOS) before. ! 1042: * 18 Mar 92 CMP Fixed the check for whether len_fi was odd or even. ! 1043: * Before it would always assume even for an XA record. ! 1044: * 26 Dec 97 jwc Swiped from MacOS implementation of ISO 9660 CD-ROM support ! 1045: * and modified to work in MacOSX file system. ! 1046: * ! 1047: *********************************************************************** */ ! 1048: ! 1049: static void DRGetTypeCreatorAndFlags( struct iso_mnt * theMountPointPtr, ! 1050: struct iso_directory_record * theDirRecPtr, ! 1051: u_int32_t * theTypePtr, ! 1052: u_int32_t * theCreatorPtr, ! 1053: u_int16_t * theFlagsPtr ) ! 1054: { ! 1055: int foundStuff; ! 1056: u_int32_t myType; ! 1057: u_int32_t myCreator; ! 1058: AppleExtension *myAppleExtPtr; ! 1059: NewAppleExtension *myNewAppleExtPtr; ! 1060: u_int16_t myFinderFlags; ! 1061: char *myPtr; ! 1062: ! 1063: foundStuff = 1; ! 1064: myType = 0L; ! 1065: myCreator = 0L; ! 1066: myFinderFlags = 0; ! 1067: *theFlagsPtr = 0x0000; ! 1068: ! 1069: /* handle the fact that our original apple extensions didn't take ! 1070: into account the padding byte on a file name */ ! 1071: ! 1072: myPtr = &theDirRecPtr->name[ (isonum_711(theDirRecPtr->name_len)) ]; ! 1073: ! 1074: /* if string length is even, bump myPtr for padding byte */ ! 1075: if ( ((isonum_711(theDirRecPtr->name_len)) & 0x01) == 0 ) ! 1076: myPtr++; ! 1077: myAppleExtPtr = (AppleExtension *) myPtr; ! 1078: ! 1079: /* checking for whether or not the new 'AA' code is being called (and if so, correctly) */ ! 1080: if ( (isonum_711(theDirRecPtr->length)) <= ! 1081: ISO_DIRECTORY_RECORD_SIZE + (isonum_711(theDirRecPtr->name_len)) ) ! 1082: { ! 1083: foundStuff = 0; ! 1084: goto DoneLooking; ! 1085: } ! 1086: ! 1087: if ( myAppleExtPtr->signature[0] == 'B' && myAppleExtPtr->signature[1] == 'A' ) ! 1088: { ! 1089: int i; ! 1090: ! 1091: switch ( isonum_711(myAppleExtPtr->systemUseID) ) ! 1092: { ! 1093: case 0x00: /* nothing there. use default */ ! 1094: foundStuff = 0; ! 1095: break; ! 1096: case 0x02: /* no icon */ ! 1097: case 0x04: /* icon, no bundle bit */ ! 1098: for ( i = 0; i < 4; i++ ) ! 1099: myType = (myType << 8) | myAppleExtPtr->fileType[i]; ! 1100: ! 1101: for ( i = 0; i < 4; i++ ) ! 1102: myCreator = (myCreator << 8) | myAppleExtPtr->fileCreator[i]; ! 1103: ! 1104: *theFlagsPtr |= fInitedBit; ! 1105: break; ! 1106: case 0x03: /* no icon, bundle bit */ ! 1107: case 0x05: /* icon and bundle bit */ ! 1108: for ( i = 0; i < 4; i++ ) ! 1109: myType = (myType << 8) | myAppleExtPtr->fileType[i]; ! 1110: ! 1111: for ( i = 0; i < 4; i++ ) ! 1112: myCreator = (myCreator << 8) | myAppleExtPtr->fileCreator[i]; ! 1113: ! 1114: *theFlagsPtr |= fInitedBit | fHasBundleBit; ! 1115: break; ! 1116: case 0x06: /* finder flags in word at end */ ! 1117: for ( i = 0; i < 4; i++ ) ! 1118: myType = (myType << 8) | myAppleExtPtr->fileType[i]; ! 1119: ! 1120: for ( i = 0; i < 4; i++ ) ! 1121: myCreator = (myCreator << 8) | myAppleExtPtr->fileCreator[i]; ! 1122: ! 1123: myFinderFlags = ! 1124: (myAppleExtPtr->finderFlags[0] << 8) | myAppleExtPtr->finderFlags[1]; ! 1125: ! 1126: /* just check the following four bits--all others always set to 0 */ ! 1127: myFinderFlags &= (fAlwaysBit | fSystemBit | fHasBundleBit | fLockedBit); ! 1128: *theFlagsPtr |= (fInitedBit | myFinderFlags); ! 1129: break; ! 1130: default: ! 1131: foundStuff = 0; ! 1132: } ! 1133: goto DoneLooking; ! 1134: } ! 1135: ! 1136: /* ! 1137: * If signature[]s != 'BA', then (1) this is not an old-style disc and we ! 1138: * need to look at ALL available SystemUse possibilities; (2) this could ! 1139: * possibly be a CD-XA style disc and our offset calculations need to ! 1140: * take this into account. ! 1141: */ ! 1142: ! 1143: foundStuff = 0; /* now we default to *false* until we find a good one */ ! 1144: myPtr = (char *) myAppleExtPtr; ! 1145: ! 1146: if ( (theMountPointPtr->im_flags2 & IMF2_IS_CDXA) != 0 ) ! 1147: myPtr += 14;/* add in CD-XA fixed record offset (tnx, Phillips) */ ! 1148: myNewAppleExtPtr = (NewAppleExtension *) myPtr; ! 1149: ! 1150: /* calculate the "real" end of the directory record information */ ! 1151: myPtr = ((char *) theDirRecPtr) + (isonum_711(theDirRecPtr->length)); ! 1152: while( (char *) myNewAppleExtPtr < myPtr ) /* end of directory buffer */ ! 1153: { ! 1154: /* ! 1155: * If we get here, we can assume that ALL further entries in this ! 1156: * directory record are of the form: ! 1157: * ! 1158: * struct OptionalSystemUse ! 1159: * { ! 1160: * byte Signature[2]; ! 1161: * byte systemUseID; ! 1162: * byte OSULength; ! 1163: * byte fileType[4]; # only if HFS ! 1164: * byte fileCreator[4]; # only if HFS ! 1165: * byte finderFlags[2]; # only if HFS ! 1166: * }; ! 1167: * ! 1168: * This means that we can examine the Signature bytes to see if they are 'AA' ! 1169: * (the NEW Apple extension signature). If they are, deal with them. If they ! 1170: * aren't, the OSULength field will tell us how long this extension info is ! 1171: * (including the signature and length bytes) and that will allow us to walk ! 1172: * the OptionalSystemUse records until we hit the end of them or run off the ! 1173: * end of the directory record. ! 1174: */ ! 1175: u_char *myFromPtr, *myToPtr; ! 1176: union ! 1177: { ! 1178: u_int32_t fourchars; ! 1179: u_char chars[4]; ! 1180: } myChars; ! 1181: ! 1182: if ( myNewAppleExtPtr->signature[0] == 'A' && myNewAppleExtPtr->signature[1] == 'A' ) ! 1183: { ! 1184: if ( isonum_711(myNewAppleExtPtr->systemUseID) == 2 ) /* HFS */ ! 1185: { ! 1186: foundStuff = 1; /* we got one! */ ! 1187: ! 1188: myFromPtr = &myNewAppleExtPtr->fileType[0]; ! 1189: myToPtr = &myChars.chars[0]; ! 1190: *myToPtr++ = *myFromPtr++; ! 1191: *myToPtr++ = *myFromPtr++; ! 1192: *myToPtr++ = *myFromPtr++; ! 1193: *myToPtr = *myFromPtr; ! 1194: myType = myChars.fourchars; /* copy file type to user var */ ! 1195: ! 1196: myFromPtr = &myNewAppleExtPtr->fileCreator[0]; ! 1197: myToPtr = &myChars.chars[0]; ! 1198: *myToPtr++ = *myFromPtr++; ! 1199: *myToPtr++ = *myFromPtr++; ! 1200: *myToPtr++ = *myFromPtr++; ! 1201: *myToPtr = *myFromPtr; ! 1202: myCreator = myChars.fourchars; /* copy creator to user var */ ! 1203: ! 1204: myFromPtr = &myNewAppleExtPtr->finderFlags[0]; ! 1205: myToPtr = &myChars.chars[2]; /* *flags* is a short */ ! 1206: myChars.fourchars = 0; ! 1207: *myToPtr++ = *myFromPtr++; ! 1208: *myToPtr = *myFromPtr; ! 1209: myFinderFlags = myChars.fourchars; ! 1210: myFinderFlags &= ( fAlwaysBit | fSystemBit | fHasBundleBit | fLockedBit ); ! 1211: *theFlagsPtr = (myFinderFlags | fInitedBit); /* return Finder flags to user var */ ! 1212: ! 1213: break; /* exit the loop */ ! 1214: } ! 1215: } ! 1216: ! 1217: /* ! 1218: * Check to see if we have a reasonable OSULength value. ! 1219: * ZERO is not an acceptable value. Nor is any value less than 4. ! 1220: */ ! 1221: ! 1222: if ( (isonum_711(myNewAppleExtPtr->OSULength)) < 4 ) ! 1223: break; /* not acceptable - get out! */ ! 1224: ! 1225: /* otherwise, step past this SystemUse record */ ! 1226: (char *)myNewAppleExtPtr += (isonum_711(myNewAppleExtPtr->OSULength)); ! 1227: ! 1228: } // end of while loop ! 1229: ! 1230: DoneLooking: ! 1231: if ( foundStuff != 0 ) ! 1232: { ! 1233: *theTypePtr = myType; ! 1234: *theCreatorPtr = myCreator; ! 1235: } ! 1236: else ! 1237: { ! 1238: *theTypePtr = DEFAULTTYPE; ! 1239: *theCreatorPtr = DEFAULTCREATOR; ! 1240: *theFlagsPtr |= fInitedBit; ! 1241: } ! 1242: ! 1243: return; ! 1244: ! 1245: } /* DRGetTypeCreatorAndFlags */ ! 1246: ! 1247: ! 1248: /* ! 1249: * Vnode pointer to File handle ! 1250: */ ! 1251: /* ARGSUSED */ ! 1252: int ! 1253: cd9660_vptofh(vp, fhp) ! 1254: struct vnode *vp; ! 1255: struct fid *fhp; ! 1256: { ! 1257: register struct iso_node *ip = VTOI(vp); ! 1258: register struct ifid *ifhp; ! 1259: ! 1260: ifhp = (struct ifid *)fhp; ! 1261: ifhp->ifid_len = sizeof(struct ifid); ! 1262: ! 1263: ifhp->ifid_ino = ip->i_number; ! 1264: ifhp->ifid_start = ip->iso_start; ! 1265: ! 1266: #ifdef ISOFS_DBG ! 1267: printf("vptofh: ino %d, start %ld\n", ! 1268: ifhp->ifid_ino,ifhp->ifid_start); ! 1269: #endif ! 1270: return 0; ! 1271: } ! 1272: ! 1273: /* ! 1274: * Fast-FileSystem only? ! 1275: */ ! 1276: int ! 1277: cd9660_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p) ! 1278: int * name; ! 1279: u_int namelen; ! 1280: void* oldp; ! 1281: size_t * oldlenp; ! 1282: void * newp; ! 1283: size_t newlen; ! 1284: struct proc * p; ! 1285: { ! 1286: return EOPNOTSUPP; ! 1287: } ! 1288:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.