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