Annotation of sys/isofs/cd9660/cd9660_vfsops.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: cd9660_vfsops.c,v 1.46 2007/06/08 05:35:32 deraadt Exp $ */
! 2: /* $NetBSD: cd9660_vfsops.c,v 1.26 1997/06/13 15:38:58 pk Exp $ */
! 3:
! 4: /*-
! 5: * Copyright (c) 1994
! 6: * The Regents of the University of California. All rights reserved.
! 7: *
! 8: * This code is derived from software contributed to Berkeley
! 9: * by Pace Willisson (pace@blitz.com). The Rock Ridge Extension
! 10: * Support code is derived from software contributed to Berkeley
! 11: * by Atsushi Murai (amurai@spec.co.jp).
! 12: *
! 13: * Redistribution and use in source and binary forms, with or without
! 14: * modification, are permitted provided that the following conditions
! 15: * are met:
! 16: * 1. Redistributions of source code must retain the above copyright
! 17: * notice, this list of conditions and the following disclaimer.
! 18: * 2. Redistributions in binary form must reproduce the above copyright
! 19: * notice, this list of conditions and the following disclaimer in the
! 20: * documentation and/or other materials provided with the distribution.
! 21: * 3. Neither the name of the University nor the names of its contributors
! 22: * may be used to endorse or promote products derived from this software
! 23: * without specific prior written permission.
! 24: *
! 25: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 26: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 27: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 28: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 29: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 30: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 31: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 32: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 33: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 34: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 35: * SUCH DAMAGE.
! 36: *
! 37: * @(#)cd9660_vfsops.c 8.9 (Berkeley) 12/5/94
! 38: */
! 39:
! 40: #include <sys/param.h>
! 41: #include <sys/systm.h>
! 42: #include <sys/namei.h>
! 43: #include <sys/proc.h>
! 44: #include <sys/kernel.h>
! 45: #include <sys/vnode.h>
! 46: #include <miscfs/specfs/specdev.h>
! 47: #include <sys/mount.h>
! 48: #include <sys/buf.h>
! 49: #include <sys/file.h>
! 50: #include <sys/disklabel.h>
! 51: #include <sys/ioctl.h>
! 52: #include <sys/cdio.h>
! 53: #include <sys/conf.h>
! 54: #include <sys/errno.h>
! 55: #include <sys/malloc.h>
! 56: #include <sys/stat.h>
! 57:
! 58: #include <isofs/cd9660/iso.h>
! 59: #include <isofs/cd9660/cd9660_extern.h>
! 60: #include <isofs/cd9660/iso_rrip.h>
! 61: #include <isofs/cd9660/cd9660_node.h>
! 62:
! 63: const struct vfsops cd9660_vfsops = {
! 64: cd9660_mount,
! 65: cd9660_start,
! 66: cd9660_unmount,
! 67: cd9660_root,
! 68: cd9660_quotactl,
! 69: cd9660_statfs,
! 70: cd9660_sync,
! 71: cd9660_vget,
! 72: cd9660_fhtovp,
! 73: cd9660_vptofh,
! 74: cd9660_init,
! 75: cd9660_sysctl,
! 76: cd9660_check_export
! 77: };
! 78:
! 79: /*
! 80: * Called by vfs_mountroot when iso is going to be mounted as root.
! 81: */
! 82:
! 83: static int iso_mountfs(struct vnode *devvp, struct mount *mp,
! 84: struct proc *p, struct iso_args *argp);
! 85: int iso_disklabelspoof(dev_t dev, void (*strat)(struct buf *),
! 86: struct disklabel *lp);
! 87:
! 88: int
! 89: cd9660_mountroot()
! 90: {
! 91: struct mount *mp;
! 92: extern struct vnode *rootvp;
! 93: struct proc *p = curproc; /* XXX */
! 94: int error;
! 95: struct iso_args args;
! 96:
! 97: /*
! 98: * Get vnodes for swapdev and rootdev.
! 99: */
! 100: if ((error = bdevvp(swapdev, &swapdev_vp)) ||
! 101: (error = bdevvp(rootdev, &rootvp))) {
! 102: printf("cd9660_mountroot: can't setup bdevvp's");
! 103: return (error);
! 104: }
! 105:
! 106: if ((error = vfs_rootmountalloc("cd9660", "root_device", &mp)) != 0)
! 107: return (error);
! 108: args.flags = ISOFSMNT_ROOT;
! 109: if ((error = iso_mountfs(rootvp, mp, p, &args)) != 0) {
! 110: mp->mnt_vfc->vfc_refcount--;
! 111: vfs_unbusy(mp);
! 112: free(mp, M_MOUNT);
! 113: return (error);
! 114: }
! 115:
! 116: CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list);
! 117: (void)cd9660_statfs(mp, &mp->mnt_stat, p);
! 118: vfs_unbusy(mp);
! 119: inittodr(0);
! 120:
! 121: return (0);
! 122: }
! 123:
! 124: /*
! 125: * VFS Operations.
! 126: *
! 127: * mount system call
! 128: */
! 129: int
! 130: cd9660_mount(mp, path, data, ndp, p)
! 131: register struct mount *mp;
! 132: const char *path;
! 133: void *data;
! 134: struct nameidata *ndp;
! 135: struct proc *p;
! 136: {
! 137: struct vnode *devvp;
! 138: struct iso_args args;
! 139: size_t size;
! 140: int error;
! 141: struct iso_mnt *imp = NULL;
! 142:
! 143: error = copyin(data, &args, sizeof (struct iso_args));
! 144: if (error)
! 145: return (error);
! 146:
! 147: if ((mp->mnt_flag & MNT_RDONLY) == 0)
! 148: return (EROFS);
! 149:
! 150: /*
! 151: * If updating, check whether changing from read-only to
! 152: * read/write; if there is no device name, that's all we do.
! 153: */
! 154: if (mp->mnt_flag & MNT_UPDATE) {
! 155: imp = VFSTOISOFS(mp);
! 156: if (args.fspec == 0)
! 157: return (vfs_export(mp, &imp->im_export,
! 158: &args.export_info));
! 159: }
! 160: /*
! 161: * Not an update, or updating the name: look up the name
! 162: * and verify that it refers to a sensible block device.
! 163: */
! 164: NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p);
! 165: if ((error = namei(ndp)) != 0)
! 166: return (error);
! 167: devvp = ndp->ni_vp;
! 168:
! 169: if (devvp->v_type != VBLK) {
! 170: vrele(devvp);
! 171: return (ENOTBLK);
! 172: }
! 173: if (major(devvp->v_rdev) >= nblkdev) {
! 174: vrele(devvp);
! 175: return (ENXIO);
! 176: }
! 177: /*
! 178: * If mount by non-root, then verify that user has necessary
! 179: * permissions on the device.
! 180: */
! 181: if (p->p_ucred->cr_uid != 0) {
! 182: vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
! 183: error = VOP_ACCESS(devvp, VREAD, p->p_ucred, p);
! 184: if (error) {
! 185: vput(devvp);
! 186: return (error);
! 187: }
! 188: VOP_UNLOCK(devvp, 0, p);
! 189: }
! 190: if ((mp->mnt_flag & MNT_UPDATE) == 0)
! 191: error = iso_mountfs(devvp, mp, p, &args);
! 192: else {
! 193: if (devvp != imp->im_devvp)
! 194: error = EINVAL; /* needs translation */
! 195: else
! 196: vrele(devvp);
! 197: }
! 198: if (error) {
! 199: vrele(devvp);
! 200: return (error);
! 201: }
! 202: imp = VFSTOISOFS(mp);
! 203: (void)copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN - 1, &size);
! 204: bzero(mp->mnt_stat.f_mntonname + size, MNAMELEN - size);
! 205: (void)copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1,
! 206: &size);
! 207: bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
! 208: bcopy(&args, &mp->mnt_stat.mount_info.iso_args, sizeof(args));
! 209: (void)cd9660_statfs(mp, &mp->mnt_stat, p);
! 210: return (0);
! 211: }
! 212:
! 213: /*
! 214: * Common code for mount and mountroot
! 215: */
! 216: static int
! 217: iso_mountfs(devvp, mp, p, argp)
! 218: register struct vnode *devvp;
! 219: struct mount *mp;
! 220: struct proc *p;
! 221: struct iso_args *argp;
! 222: {
! 223: register struct iso_mnt *isomp = (struct iso_mnt *)0;
! 224: struct buf *bp = NULL;
! 225: struct buf *pribp = NULL, *supbp = NULL;
! 226: dev_t dev = devvp->v_rdev;
! 227: int error = EINVAL;
! 228: int needclose = 0;
! 229: int ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
! 230: extern struct vnode *rootvp;
! 231: int iso_bsize;
! 232: int iso_blknum;
! 233: int joliet_level;
! 234: struct iso_volume_descriptor *vdp;
! 235: struct iso_primary_descriptor *pri = NULL;
! 236: struct iso_supplementary_descriptor *sup = NULL;
! 237: struct iso_directory_record *rootp;
! 238: int logical_block_size;
! 239: int sess;
! 240:
! 241: if (!ronly)
! 242: return (EROFS);
! 243:
! 244: /*
! 245: * Disallow multiple mounts of the same device.
! 246: * Disallow mounting of a device that is currently in use
! 247: * (except for root, which might share swap device for miniroot).
! 248: * Flush out any old buffers remaining from a previous use.
! 249: */
! 250: if ((error = vfs_mountedon(devvp)) != 0)
! 251: return (error);
! 252: if (vcount(devvp) > 1 && devvp != rootvp)
! 253: return (EBUSY);
! 254: if ((error = vinvalbuf(devvp, V_SAVE, p->p_ucred, p, 0, 0)) != 0)
! 255: return (error);
! 256:
! 257: error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, p);
! 258: if (error)
! 259: return (error);
! 260: needclose = 1;
! 261:
! 262: /*
! 263: * This is the "logical sector size". The standard says this
! 264: * should be 2048 or the physical sector size on the device,
! 265: * whichever is greater. For now, we'll just use a constant.
! 266: */
! 267: iso_bsize = ISO_DEFAULT_BLOCK_SIZE;
! 268:
! 269: if (argp->flags & ISOFSMNT_SESS) {
! 270: sess = argp->sess;
! 271: if (sess < 0)
! 272: sess = 0;
! 273: } else {
! 274: sess = 0;
! 275: error = VOP_IOCTL(devvp, CDIOREADMSADDR, (caddr_t)&sess, 0,
! 276: FSCRED, p);
! 277: if (error)
! 278: sess = 0;
! 279: }
! 280:
! 281: joliet_level = 0;
! 282: for (iso_blknum = 16; iso_blknum < 100; iso_blknum++) {
! 283: if ((error = bread(devvp,
! 284: (iso_blknum + sess) * btodb(iso_bsize),
! 285: iso_bsize, NOCRED, &bp)) != 0)
! 286: goto out;
! 287:
! 288: vdp = (struct iso_volume_descriptor *)bp->b_data;
! 289: if (bcmp (vdp->id, ISO_STANDARD_ID, sizeof vdp->id) != 0) {
! 290: error = EINVAL;
! 291: goto out;
! 292: }
! 293:
! 294: switch (isonum_711 (vdp->type)){
! 295: case ISO_VD_PRIMARY:
! 296: if (pribp == NULL) {
! 297: pribp = bp;
! 298: bp = NULL;
! 299: pri = (struct iso_primary_descriptor *)vdp;
! 300: }
! 301: break;
! 302: case ISO_VD_SUPPLEMENTARY:
! 303: if (supbp == NULL) {
! 304: supbp = bp;
! 305: bp = NULL;
! 306: sup = (struct iso_supplementary_descriptor *)vdp;
! 307:
! 308: if (!(argp->flags & ISOFSMNT_NOJOLIET)) {
! 309: if (bcmp(sup->escape, "%/@", 3) == 0)
! 310: joliet_level = 1;
! 311: if (bcmp(sup->escape, "%/C", 3) == 0)
! 312: joliet_level = 2;
! 313: if (bcmp(sup->escape, "%/E", 3) == 0)
! 314: joliet_level = 3;
! 315:
! 316: if (isonum_711 (sup->flags) & 1)
! 317: joliet_level = 0;
! 318: }
! 319: }
! 320: break;
! 321:
! 322: case ISO_VD_END:
! 323: goto vd_end;
! 324:
! 325: default:
! 326: break;
! 327: }
! 328: if (bp) {
! 329: brelse(bp);
! 330: bp = NULL;
! 331: }
! 332: }
! 333: vd_end:
! 334: if (bp) {
! 335: brelse(bp);
! 336: bp = NULL;
! 337: }
! 338:
! 339: if (pri == NULL) {
! 340: error = EINVAL;
! 341: goto out;
! 342: }
! 343:
! 344: logical_block_size = isonum_723 (pri->logical_block_size);
! 345:
! 346: if (logical_block_size < DEV_BSIZE || logical_block_size > MAXBSIZE
! 347: || (logical_block_size & (logical_block_size - 1)) != 0) {
! 348: error = EINVAL;
! 349: goto out;
! 350: }
! 351:
! 352: rootp = (struct iso_directory_record *)pri->root_directory_record;
! 353:
! 354: isomp = malloc(sizeof *isomp, M_ISOFSMNT, M_WAITOK);
! 355: bzero((caddr_t)isomp, sizeof *isomp);
! 356: isomp->logical_block_size = logical_block_size;
! 357: isomp->volume_space_size = isonum_733 (pri->volume_space_size);
! 358: bcopy (rootp, isomp->root, sizeof isomp->root);
! 359: isomp->root_extent = isonum_733 (rootp->extent);
! 360: isomp->root_size = isonum_733 (rootp->size);
! 361: isomp->joliet_level = 0;
! 362: /*
! 363: * Since an ISO9660 multi-session CD can also access previous sessions,
! 364: * we have to include them into the space considerations.
! 365: */
! 366: isomp->volume_space_size += sess;
! 367: isomp->im_bmask = logical_block_size - 1;
! 368: isomp->im_bshift = ffs(logical_block_size) - 1;
! 369:
! 370: pribp->b_flags |= B_AGE;
! 371: brelse(pribp);
! 372: pribp = NULL;
! 373:
! 374: mp->mnt_data = (qaddr_t)isomp;
! 375: mp->mnt_stat.f_fsid.val[0] = (long)dev;
! 376: mp->mnt_stat.f_fsid.val[1] = mp->mnt_vfc->vfc_typenum;
! 377: mp->mnt_maxsymlinklen = 0;
! 378: mp->mnt_flag |= MNT_LOCAL;
! 379: isomp->im_mountp = mp;
! 380: isomp->im_dev = dev;
! 381: isomp->im_devvp = devvp;
! 382:
! 383: /* Check the Rock Ridge Extension support */
! 384: if (!(argp->flags & ISOFSMNT_NORRIP)) {
! 385: if ((error = bread(isomp->im_devvp, (isomp->root_extent +
! 386: isonum_711(rootp->ext_attr_length)) <<
! 387: (isomp->im_bshift - DEV_BSHIFT),
! 388: isomp->logical_block_size, NOCRED, &bp)) != 0)
! 389: goto out;
! 390:
! 391: rootp = (struct iso_directory_record *)bp->b_data;
! 392:
! 393: if ((isomp->rr_skip = cd9660_rrip_offset(rootp,isomp)) < 0) {
! 394: argp->flags |= ISOFSMNT_NORRIP;
! 395: } else {
! 396: argp->flags &= ~ISOFSMNT_GENS;
! 397: }
! 398:
! 399: /*
! 400: * The contents are valid,
! 401: * but they will get reread as part of another vnode, so...
! 402: */
! 403: bp->b_flags |= B_AGE;
! 404: brelse(bp);
! 405: bp = NULL;
! 406: }
! 407: isomp->im_flags = argp->flags & (ISOFSMNT_NORRIP | ISOFSMNT_GENS |
! 408: ISOFSMNT_EXTATT | ISOFSMNT_NOJOLIET);
! 409: switch (isomp->im_flags & (ISOFSMNT_NORRIP | ISOFSMNT_GENS)) {
! 410: default:
! 411: isomp->iso_ftype = ISO_FTYPE_DEFAULT;
! 412: break;
! 413: case ISOFSMNT_GENS|ISOFSMNT_NORRIP:
! 414: isomp->iso_ftype = ISO_FTYPE_9660;
! 415: break;
! 416: case 0:
! 417: isomp->iso_ftype = ISO_FTYPE_RRIP;
! 418: break;
! 419: }
! 420:
! 421: /* Decide whether to use the Joliet descriptor */
! 422:
! 423: if (isomp->iso_ftype != ISO_FTYPE_RRIP && joliet_level) {
! 424: rootp = (struct iso_directory_record *)
! 425: sup->root_directory_record;
! 426: bcopy(rootp, isomp->root, sizeof isomp->root);
! 427: isomp->root_extent = isonum_733(rootp->extent);
! 428: isomp->root_size = isonum_733(rootp->size);
! 429: isomp->joliet_level = joliet_level;
! 430: supbp->b_flags |= B_AGE;
! 431: }
! 432:
! 433: if (supbp) {
! 434: brelse(supbp);
! 435: supbp = NULL;
! 436: }
! 437:
! 438: devvp->v_specmountpoint = mp;
! 439:
! 440: return (0);
! 441: out:
! 442: if (bp)
! 443: brelse(bp);
! 444: if (supbp)
! 445: brelse(supbp);
! 446: if (needclose)
! 447: (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, NOCRED,
! 448: p);
! 449: if (isomp) {
! 450: free((caddr_t)isomp, M_ISOFSMNT);
! 451: mp->mnt_data = (qaddr_t)0;
! 452: }
! 453: return (error);
! 454: }
! 455:
! 456: /*
! 457: * Test to see if the device is an ISOFS filesystem.
! 458: */
! 459: int
! 460: iso_disklabelspoof(dev, strat, lp)
! 461: dev_t dev;
! 462: void (*strat)(struct buf *);
! 463: register struct disklabel *lp;
! 464: {
! 465: struct buf *bp = NULL;
! 466: struct iso_volume_descriptor *vdp;
! 467: struct iso_primary_descriptor *pri;
! 468: int logical_block_size;
! 469: int error = EINVAL;
! 470: int iso_blknum;
! 471: int i;
! 472:
! 473: bp = geteblk(ISO_DEFAULT_BLOCK_SIZE);
! 474: bp->b_dev = dev;
! 475:
! 476: for (iso_blknum = 16; iso_blknum < 100; iso_blknum++) {
! 477: bp->b_blkno = iso_blknum * btodb(ISO_DEFAULT_BLOCK_SIZE);
! 478: bp->b_bcount = ISO_DEFAULT_BLOCK_SIZE;
! 479: bp->b_flags = B_BUSY | B_READ;
! 480: bp->b_cylinder = bp->b_blkno / lp->d_secpercyl;
! 481:
! 482: /*printf("d_secsize %d iso_blknum %d b_blkno %d bcount %d\n",
! 483: lp->d_secsize, iso_blknum, bp->b_blkno, bp->b_bcount);*/
! 484:
! 485: (*strat)(bp);
! 486:
! 487: if (biowait(bp))
! 488: goto out;
! 489:
! 490: vdp = (struct iso_volume_descriptor *)bp->b_data;
! 491: /*printf("%2x%2x%2x type %2x\n", vdp->id[0], vdp->id[1],
! 492: vdp->id[2], isonum_711(vdp->type));*/
! 493: if (bcmp (vdp->id, ISO_STANDARD_ID, sizeof vdp->id) != 0 ||
! 494: isonum_711 (vdp->type) == ISO_VD_END)
! 495: goto out;
! 496:
! 497: if (isonum_711 (vdp->type) == ISO_VD_PRIMARY)
! 498: break;
! 499: }
! 500:
! 501: if (isonum_711 (vdp->type) != ISO_VD_PRIMARY)
! 502: goto out;
! 503:
! 504: pri = (struct iso_primary_descriptor *)vdp;
! 505: logical_block_size = isonum_723 (pri->logical_block_size);
! 506: if (logical_block_size < DEV_BSIZE || logical_block_size > MAXBSIZE ||
! 507: (logical_block_size & (logical_block_size - 1)) != 0)
! 508: goto out;
! 509:
! 510: /*
! 511: * build a disklabel for the CD
! 512: */
! 513: strncpy(lp->d_typename, pri->volume_id, sizeof lp->d_typename);
! 514: strncpy(lp->d_packname, pri->volume_id+16, sizeof lp->d_packname);
! 515: for (i = 0; i < MAXPARTITIONS; i++) {
! 516: DL_SETPSIZE(&lp->d_partitions[i], 0);
! 517: DL_SETPOFFSET(&lp->d_partitions[i], 0);
! 518: }
! 519: DL_SETPOFFSET(&lp->d_partitions[0], 0);
! 520: DL_SETPSIZE(&lp->d_partitions[0], DL_GETDSIZE(lp));
! 521: lp->d_partitions[0].p_fstype = FS_ISO9660;
! 522: DL_SETPOFFSET(&lp->d_partitions[RAW_PART], 0);
! 523: DL_SETPSIZE(&lp->d_partitions[RAW_PART], DL_GETDSIZE(lp));
! 524: lp->d_partitions[RAW_PART].p_fstype = FS_ISO9660;
! 525: lp->d_npartitions = RAW_PART + 1;
! 526: lp->d_bbsize = 8192; /* fake */
! 527: lp->d_sbsize = 64*1024; /* fake */
! 528: lp->d_version = 1;
! 529:
! 530: lp->d_magic = DISKMAGIC;
! 531: lp->d_magic2 = DISKMAGIC;
! 532: lp->d_checksum = dkcksum(lp);
! 533: error = 0;
! 534: out:
! 535: bp->b_flags |= B_INVAL;
! 536: brelse(bp);
! 537: return (error);
! 538: }
! 539:
! 540: /*
! 541: * Make a filesystem operational.
! 542: * Nothing to do at the moment.
! 543: */
! 544: /* ARGSUSED */
! 545: int
! 546: cd9660_start(mp, flags, p)
! 547: struct mount *mp;
! 548: int flags;
! 549: struct proc *p;
! 550: {
! 551: return (0);
! 552: }
! 553:
! 554: /*
! 555: * unmount system call
! 556: */
! 557: int
! 558: cd9660_unmount(mp, mntflags, p)
! 559: struct mount *mp;
! 560: int mntflags;
! 561: struct proc *p;
! 562: {
! 563: register struct iso_mnt *isomp;
! 564: int error, flags = 0;
! 565:
! 566: if (mntflags & MNT_FORCE)
! 567: flags |= FORCECLOSE;
! 568: #if 0
! 569: mntflushbuf(mp, 0);
! 570: if (mntinvalbuf(mp))
! 571: return (EBUSY);
! 572: #endif
! 573: if ((error = vflush(mp, NULLVP, flags)) != 0)
! 574: return (error);
! 575:
! 576: isomp = VFSTOISOFS(mp);
! 577:
! 578: #ifdef ISODEVMAP
! 579: if (isomp->iso_ftype == ISO_FTYPE_RRIP)
! 580: iso_dunmap(isomp->im_dev);
! 581: #endif
! 582:
! 583: isomp->im_devvp->v_specmountpoint = NULL;
! 584: error = VOP_CLOSE(isomp->im_devvp, FREAD, NOCRED, p);
! 585: vrele(isomp->im_devvp);
! 586: free((caddr_t)isomp, M_ISOFSMNT);
! 587: mp->mnt_data = (qaddr_t)0;
! 588: mp->mnt_flag &= ~MNT_LOCAL;
! 589: return (error);
! 590: }
! 591:
! 592: /*
! 593: * Return root of a filesystem
! 594: */
! 595: int
! 596: cd9660_root(mp, vpp)
! 597: struct mount *mp;
! 598: struct vnode **vpp;
! 599: {
! 600: struct iso_mnt *imp = VFSTOISOFS(mp);
! 601: struct iso_directory_record *dp =
! 602: (struct iso_directory_record *)imp->root;
! 603: ino_t ino = isodirino(dp, imp);
! 604:
! 605: /*
! 606: * With RRIP we must use the `.' entry of the root directory.
! 607: * Simply tell vget, that it's a relocated directory.
! 608: */
! 609: return (cd9660_vget_internal(mp, ino, vpp,
! 610: imp->iso_ftype == ISO_FTYPE_RRIP, dp));
! 611: }
! 612:
! 613: /*
! 614: * Do operations associated with quotas, not supported
! 615: */
! 616: /* ARGSUSED */
! 617: int
! 618: cd9660_quotactl(mp, cmd, uid, arg, p)
! 619: struct mount *mp;
! 620: int cmd;
! 621: uid_t uid;
! 622: caddr_t arg;
! 623: struct proc *p;
! 624: {
! 625:
! 626: return (EOPNOTSUPP);
! 627: }
! 628:
! 629: /*
! 630: * Get file system statistics.
! 631: */
! 632: int
! 633: cd9660_statfs(mp, sbp, p)
! 634: struct mount *mp;
! 635: register struct statfs *sbp;
! 636: struct proc *p;
! 637: {
! 638: register struct iso_mnt *isomp;
! 639:
! 640: isomp = VFSTOISOFS(mp);
! 641:
! 642: sbp->f_bsize = isomp->logical_block_size;
! 643: sbp->f_iosize = sbp->f_bsize; /* XXX */
! 644: sbp->f_blocks = isomp->volume_space_size;
! 645: sbp->f_bfree = 0; /* total free blocks */
! 646: sbp->f_bavail = 0; /* blocks free for non superuser */
! 647: sbp->f_files = 0; /* total files */
! 648: sbp->f_ffree = 0; /* free file nodes */
! 649: if (sbp != &mp->mnt_stat) {
! 650: bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN);
! 651: bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname,
! 652: MNAMELEN);
! 653: bcopy(&mp->mnt_stat.mount_info.iso_args,
! 654: &sbp->mount_info.iso_args, sizeof(struct iso_args));
! 655: }
! 656: /* Use the first spare for flags: */
! 657: sbp->f_spare[0] = isomp->im_flags;
! 658: return (0);
! 659: }
! 660:
! 661: /* ARGSUSED */
! 662: int
! 663: cd9660_sync(mp, waitfor, cred, p)
! 664: struct mount *mp;
! 665: int waitfor;
! 666: struct ucred *cred;
! 667: struct proc *p;
! 668: {
! 669: return (0);
! 670: }
! 671:
! 672: /*
! 673: * File handle to vnode
! 674: *
! 675: * Have to be really careful about stale file handles:
! 676: * - check that the inode number is in range
! 677: * - call iget() to get the locked inode
! 678: * - check for an unallocated inode (i_mode == 0)
! 679: * - check that the generation number matches
! 680: */
! 681:
! 682: struct ifid {
! 683: ushort ifid_len;
! 684: ushort ifid_pad;
! 685: int ifid_ino;
! 686: long ifid_start;
! 687: };
! 688:
! 689: /* ARGSUSED */
! 690: int
! 691: cd9660_fhtovp(mp, fhp, vpp)
! 692: register struct mount *mp;
! 693: struct fid *fhp;
! 694: struct vnode **vpp;
! 695: {
! 696: struct ifid *ifhp = (struct ifid *)fhp;
! 697: register struct iso_node *ip;
! 698: struct vnode *nvp;
! 699: int error;
! 700:
! 701: #ifdef ISOFS_DBG
! 702: printf("fhtovp: ino %d, start %ld\n", ifhp->ifid_ino,
! 703: ifhp->ifid_start);
! 704: #endif
! 705:
! 706: if ((error = VFS_VGET(mp, ifhp->ifid_ino, &nvp)) != 0) {
! 707: *vpp = NULLVP;
! 708: return (error);
! 709: }
! 710: ip = VTOI(nvp);
! 711: if (ip->inode.iso_mode == 0) {
! 712: vput(nvp);
! 713: *vpp = NULLVP;
! 714: return (ESTALE);
! 715: }
! 716: *vpp = nvp;
! 717: return (0);
! 718: }
! 719:
! 720: int
! 721: cd9660_vget(mp, ino, vpp)
! 722: struct mount *mp;
! 723: ino_t ino;
! 724: struct vnode **vpp;
! 725: {
! 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: return (cd9660_vget_internal(mp, ino, vpp,
! 734: #if 0
! 735: VFSTOISOFS(mp)->iso_ftype == ISO_FTYPE_RRIP,
! 736: #else
! 737: 0,
! 738: #endif
! 739: NULL));
! 740: }
! 741:
! 742: int
! 743: cd9660_vget_internal(mp, ino, vpp, relocated, isodir)
! 744: struct mount *mp;
! 745: ino_t ino;
! 746: struct vnode **vpp;
! 747: int relocated;
! 748: struct iso_directory_record *isodir;
! 749: {
! 750: register struct iso_mnt *imp;
! 751: struct iso_node *ip;
! 752: struct buf *bp;
! 753: struct vnode *vp, *nvp;
! 754: dev_t dev;
! 755: int error;
! 756:
! 757: retry:
! 758: imp = VFSTOISOFS(mp);
! 759: dev = imp->im_dev;
! 760: if ((*vpp = cd9660_ihashget(dev, ino)) != NULLVP)
! 761: return (0);
! 762:
! 763: /* Allocate a new vnode/iso_node. */
! 764: if ((error = getnewvnode(VT_ISOFS, mp, cd9660_vnodeop_p, &vp)) != 0) {
! 765: *vpp = NULLVP;
! 766: return (error);
! 767: }
! 768: MALLOC(ip, struct iso_node *, sizeof(struct iso_node), M_ISOFSNODE,
! 769: M_WAITOK);
! 770: bzero((caddr_t)ip, sizeof(struct iso_node));
! 771: lockinit(&ip->i_lock, PINOD, "isoinode", 0, 0);
! 772: vp->v_data = ip;
! 773: ip->i_vnode = vp;
! 774: ip->i_dev = dev;
! 775: ip->i_number = ino;
! 776:
! 777: /*
! 778: * Put it onto its hash chain and lock it so that other requests for
! 779: * this inode will block if they arrive while we are sleeping waiting
! 780: * for old data structures to be purged or for the contents of the
! 781: * disk portion of this inode to be read.
! 782: */
! 783: error = cd9660_ihashins(ip);
! 784:
! 785: if (error) {
! 786: vrele(vp);
! 787:
! 788: if (error == EEXIST)
! 789: goto retry;
! 790:
! 791: return (error);
! 792: }
! 793:
! 794: if (isodir == 0) {
! 795: int lbn, off;
! 796:
! 797: lbn = lblkno(imp, ino);
! 798: if (lbn >= imp->volume_space_size) {
! 799: vput(vp);
! 800: printf("fhtovp: lbn exceed volume space %d\n", lbn);
! 801: return (ESTALE);
! 802: }
! 803:
! 804: off = blkoff(imp, ino);
! 805: if (off + ISO_DIRECTORY_RECORD_SIZE > imp->logical_block_size)
! 806: {
! 807: vput(vp);
! 808: printf("fhtovp: crosses block boundary %d\n",
! 809: off + ISO_DIRECTORY_RECORD_SIZE);
! 810: return (ESTALE);
! 811: }
! 812:
! 813: error = bread(imp->im_devvp,
! 814: lbn << (imp->im_bshift - DEV_BSHIFT),
! 815: imp->logical_block_size, NOCRED, &bp);
! 816: if (error) {
! 817: vput(vp);
! 818: brelse(bp);
! 819: printf("fhtovp: bread error %d\n",error);
! 820: return (error);
! 821: }
! 822: isodir = (struct iso_directory_record *)(bp->b_data + off);
! 823:
! 824: if (off + isonum_711(isodir->length) >
! 825: imp->logical_block_size) {
! 826: vput(vp);
! 827: if (bp != 0)
! 828: brelse(bp);
! 829: printf("fhtovp: directory crosses block boundary %d[off=%d/len=%d]\n",
! 830: off +isonum_711(isodir->length), off,
! 831: isonum_711(isodir->length));
! 832: return (ESTALE);
! 833: }
! 834:
! 835: #if 0
! 836: if (isonum_733(isodir->extent) +
! 837: isonum_711(isodir->ext_attr_length) != ifhp->ifid_start) {
! 838: if (bp != 0)
! 839: brelse(bp);
! 840: printf("fhtovp: file start miss %d vs %d\n",
! 841: isonum_733(isodir->extent) +
! 842: isonum_711(isodir->ext_attr_length),
! 843: ifhp->ifid_start);
! 844: return (ESTALE);
! 845: }
! 846: #endif
! 847: } else
! 848: bp = 0;
! 849:
! 850: ip->i_mnt = imp;
! 851: ip->i_devvp = imp->im_devvp;
! 852: VREF(ip->i_devvp);
! 853:
! 854: if (relocated) {
! 855: /*
! 856: * On relocated directories we must
! 857: * read the `.' entry out of a dir.
! 858: */
! 859: ip->iso_start = ino >> imp->im_bshift;
! 860: if (bp != 0)
! 861: brelse(bp);
! 862: if ((error = cd9660_bufatoff(ip, (off_t)0, NULL, &bp)) != 0) {
! 863: vput(vp);
! 864: return (error);
! 865: }
! 866: isodir = (struct iso_directory_record *)bp->b_data;
! 867: }
! 868:
! 869: ip->iso_extent = isonum_733(isodir->extent);
! 870: ip->i_size = (u_int32_t) isonum_733(isodir->size);
! 871: ip->iso_start = isonum_711(isodir->ext_attr_length) + ip->iso_extent;
! 872:
! 873: /*
! 874: * Setup time stamp, attribute
! 875: */
! 876: vp->v_type = VNON;
! 877: switch (imp->iso_ftype) {
! 878: default: /* ISO_FTYPE_9660 */
! 879: {
! 880: struct buf *bp2;
! 881: int off;
! 882: if ((imp->im_flags & ISOFSMNT_EXTATT) &&
! 883: (off = isonum_711(isodir->ext_attr_length)))
! 884: cd9660_bufatoff(ip, (off_t)-(off << imp->im_bshift),
! 885: NULL, &bp2);
! 886: else
! 887: bp2 = NULL;
! 888: cd9660_defattr(isodir, ip, bp2);
! 889: cd9660_deftstamp(isodir, ip, bp2);
! 890: if (bp2)
! 891: brelse(bp2);
! 892: break;
! 893: }
! 894: case ISO_FTYPE_RRIP:
! 895: cd9660_rrip_analyze(isodir, ip, imp);
! 896: break;
! 897: }
! 898:
! 899: if (bp != 0)
! 900: brelse(bp);
! 901:
! 902: /*
! 903: * Initialize the associated vnode
! 904: */
! 905: switch (vp->v_type = IFTOVT(ip->inode.iso_mode)) {
! 906: case VFIFO:
! 907: #ifdef FIFO
! 908: vp->v_op = cd9660_fifoop_p;
! 909: break;
! 910: #else
! 911: vput(vp);
! 912: return (EOPNOTSUPP);
! 913: #endif /* FIFO */
! 914: case VCHR:
! 915: case VBLK:
! 916: /*
! 917: * if device, look at device number table for translation
! 918: */
! 919: #ifdef ISODEVMAP
! 920: if (dp = iso_dmap(dev, ino, 0))
! 921: ip->inode.iso_rdev = dp->d_dev;
! 922: #endif
! 923: vp->v_op = cd9660_specop_p;
! 924: if ((nvp = checkalias(vp, ip->inode.iso_rdev, mp)) != NULL) {
! 925: /*
! 926: * Discard unneeded vnode, but save its iso_node.
! 927: * Note that the lock is carried over in the iso_node
! 928: */
! 929: nvp->v_data = vp->v_data;
! 930: vp->v_data = NULL;
! 931: vp->v_op = spec_vnodeop_p;
! 932: vrele(vp);
! 933: vgone(vp);
! 934: /*
! 935: * Reinitialize aliased inode.
! 936: */
! 937: vp = nvp;
! 938: ip->i_vnode = vp;
! 939: }
! 940: break;
! 941: case VLNK:
! 942: case VNON:
! 943: case VSOCK:
! 944: case VDIR:
! 945: case VBAD:
! 946: break;
! 947: case VREG:
! 948: uvm_vnp_setsize(vp, ip->i_size);
! 949: break;
! 950: }
! 951:
! 952: if (ip->iso_extent == imp->root_extent)
! 953: vp->v_flag |= VROOT;
! 954:
! 955: /*
! 956: * XXX need generation number?
! 957: */
! 958:
! 959: *vpp = vp;
! 960: return (0);
! 961: }
! 962:
! 963: /*
! 964: * Vnode pointer to File handle
! 965: */
! 966: /* ARGSUSED */
! 967: int
! 968: cd9660_vptofh(vp, fhp)
! 969: struct vnode *vp;
! 970: struct fid *fhp;
! 971: {
! 972: register struct iso_node *ip = VTOI(vp);
! 973: register struct ifid *ifhp;
! 974:
! 975: ifhp = (struct ifid *)fhp;
! 976: ifhp->ifid_len = sizeof(struct ifid);
! 977:
! 978: ifhp->ifid_ino = ip->i_number;
! 979: ifhp->ifid_start = ip->iso_start;
! 980:
! 981: #ifdef ISOFS_DBG
! 982: printf("vptofh: ino %d, start %ld\n",
! 983: ifhp->ifid_ino,ifhp->ifid_start);
! 984: #endif
! 985: return (0);
! 986: }
! 987:
! 988: /*
! 989: * Verify a remote client has export rights and return these rights via
! 990: * exflagsp and credanonp.
! 991: */
! 992: int
! 993: cd9660_check_export(mp, nam, exflagsp, credanonp)
! 994: register struct mount *mp;
! 995: struct mbuf *nam;
! 996: int *exflagsp;
! 997: struct ucred **credanonp;
! 998: {
! 999: register struct netcred *np;
! 1000: register struct iso_mnt *imp = VFSTOISOFS(mp);
! 1001:
! 1002: /*
! 1003: * Get the export permission structure for this <mp, client> tuple.
! 1004: */
! 1005: np = vfs_export_lookup(mp, &imp->im_export, nam);
! 1006: if (np == NULL)
! 1007: return (EACCES);
! 1008:
! 1009: *exflagsp = np->netc_exflags;
! 1010: *credanonp = &np->netc_anon;
! 1011: return (0);
! 1012: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to cd9660_vfsops.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / isofs / cd9660