8115 parallel zfs mount

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved.
  23  * Copyright (c) 2011 Bayard G. Bell. All rights reserved.
  24  * Copyright 2013 Joyent, Inc. All rights reserved.
  25  * Copyright (c) 2017 by Delphix. All rights reserved.
  26  */
  27 
  28 /*
  29  * VFS operations for High Sierra filesystem
  30  */
  31 
  32 #include <sys/types.h>
  33 #include <sys/isa_defs.h>
  34 #include <sys/t_lock.h>
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/sysmacros.h>
  38 #include <sys/kmem.h>
  39 #include <sys/signal.h>
  40 #include <sys/user.h>
  41 #include <sys/proc.h>
  42 #include <sys/disp.h>
  43 #include <sys/buf.h>
  44 #include <sys/pathname.h>
  45 #include <sys/vfs.h>
  46 #include <sys/vfs_opreg.h>
  47 #include <sys/vnode.h>
  48 #include <sys/file.h>
  49 #include <sys/uio.h>
  50 #include <sys/conf.h>
  51 #include <sys/policy.h>
  52 
  53 #include <vm/page.h>
  54 
  55 #include <sys/fs/snode.h>
  56 #include <sys/fs/hsfs_spec.h>
  57 #include <sys/fs/hsfs_isospec.h>
  58 #include <sys/fs/hsfs_node.h>
  59 #include <sys/fs/hsfs_impl.h>
  60 #include <sys/fs/hsfs_susp.h>
  61 #include <sys/fs/hsfs_rrip.h>
  62 
  63 #include <sys/statvfs.h>
  64 #include <sys/mount.h>
  65 #include <sys/mntent.h>
  66 #include <sys/swap.h>
  67 #include <sys/errno.h>
  68 #include <sys/debug.h>
  69 #include "fs/fs_subr.h"
  70 #include <sys/cmn_err.h>
  71 #include <sys/bootconf.h>
  72 
  73 #include <sys/sdt.h>
  74 
  75 /*
  76  * These are needed for the CDROMREADOFFSET Code
  77  */
  78 #include <sys/cdio.h>
  79 #include <sys/sunddi.h>
  80 
  81 #define HSFS_CLKSET
  82 
  83 #include <sys/modctl.h>
  84 
  85 /*
  86  * Options for mount.
  87  */
  88 #define HOPT_GLOBAL     MNTOPT_GLOBAL
  89 #define HOPT_NOGLOBAL   MNTOPT_NOGLOBAL
  90 #define HOPT_MAPLCASE   "maplcase"
  91 #define HOPT_NOMAPLCASE "nomaplcase"
  92 #define HOPT_NOTRAILDOT "notraildot"
  93 #define HOPT_TRAILDOT   "traildot"
  94 #define HOPT_NRR        "nrr"
  95 #define HOPT_RR         "rr"
  96 #define HOPT_JOLIET     "joliet"
  97 #define HOPT_NOJOLIET   "nojoliet"
  98 #define HOPT_JOLIETLONG "jolietlong"
  99 #define HOPT_VERS2      "vers2"
 100 #define HOPT_NOVERS2    "novers2"
 101 #define HOPT_RO         MNTOPT_RO
 102 
 103 static char *global_cancel[] = { HOPT_NOGLOBAL, NULL };
 104 static char *noglobal_cancel[] = { HOPT_GLOBAL, NULL };
 105 static char *mapl_cancel[] = { HOPT_NOMAPLCASE, NULL };
 106 static char *nomapl_cancel[] = { HOPT_MAPLCASE, NULL };
 107 static char *ro_cancel[] = { MNTOPT_RW, NULL };
 108 static char *rr_cancel[] = { HOPT_NRR, NULL };
 109 static char *nrr_cancel[] = { HOPT_RR, NULL };
 110 static char *joliet_cancel[] = { HOPT_NOJOLIET, NULL };
 111 static char *nojoliet_cancel[] = { HOPT_JOLIET, NULL };
 112 static char *vers2_cancel[] = { HOPT_NOVERS2, NULL };
 113 static char *novers2_cancel[] = { HOPT_VERS2, NULL };
 114 static char *trail_cancel[] = { HOPT_NOTRAILDOT, NULL };
 115 static char *notrail_cancel[] = { HOPT_TRAILDOT, NULL };
 116 
 117 static mntopt_t hsfs_options[] = {
 118         { HOPT_GLOBAL, global_cancel, NULL, 0, NULL },
 119         { HOPT_NOGLOBAL, noglobal_cancel, NULL, MO_DEFAULT, NULL },
 120         { HOPT_MAPLCASE, mapl_cancel, NULL, MO_DEFAULT, NULL },
 121         { HOPT_NOMAPLCASE, nomapl_cancel, NULL, 0, NULL },
 122         { HOPT_RO, ro_cancel, NULL, MO_DEFAULT, NULL },
 123         { HOPT_RR, rr_cancel, NULL, MO_DEFAULT, NULL },
 124         { HOPT_NRR, nrr_cancel, NULL, 0, NULL },
 125         { HOPT_JOLIET, joliet_cancel, NULL, 0, NULL },
 126         { HOPT_NOJOLIET, nojoliet_cancel, NULL, 0, NULL },
 127         { HOPT_JOLIETLONG, NULL, NULL, 0, NULL },
 128         { HOPT_VERS2, vers2_cancel, NULL, 0, NULL },
 129         { HOPT_NOVERS2, novers2_cancel, NULL, 0, NULL },
 130         { HOPT_TRAILDOT, trail_cancel, NULL, MO_DEFAULT, NULL },
 131         { HOPT_NOTRAILDOT, notrail_cancel, NULL, 0, NULL },
 132         { "sector", NULL, "0", MO_HASVALUE, NULL},
 133 };
 134 
 135 static mntopts_t hsfs_proto_opttbl = {
 136         sizeof (hsfs_options) / sizeof (mntopt_t),
 137         hsfs_options
 138 };
 139 
 140 /*
 141  * Indicates whether to enable the I/O scheduling and readahead logic
 142  * 1 - Enable, 0 - Do not Enable.
 143  * Debugging purposes.
 144  */
 145 int do_schedio = 1;
 146 static int hsfsfstype;
 147 static int hsfsinit(int, char *);
 148 
 149 static vfsdef_t vfw = {
 150         VFSDEF_VERSION,
 151         "hsfs",
 152         hsfsinit,
 153         /* We don't suppport remounting */
 154         VSW_HASPROTO|VSW_STATS|VSW_CANLOFI|VSW_MOUNTDEV,
 155         &hsfs_proto_opttbl
 156 };
 157 
 158 static struct modlfs modlfs = {
 159         &mod_fsops, "filesystem for HSFS", &vfw
 160 };
 161 
 162 static struct modlinkage modlinkage = {
 163         MODREV_1, (void *)&modlfs, NULL
 164 };
 165 
 166 extern void hsched_init_caches(void);
 167 extern void hsched_fini_caches(void);
 168 
 169 
 170 int
 171 _init(void)
 172 {
 173         return (mod_install(&modlinkage));
 174 }
 175 
 176 int
 177 _fini(void)
 178 {
 179         int     error;
 180 
 181         error = mod_remove(&modlinkage);
 182 
 183         DTRACE_PROBE1(mod_remove, int, error);
 184 
 185         if (error)
 186                 return (error);
 187 
 188         mutex_destroy(&hs_mounttab_lock);
 189 
 190         /*
 191          * Tear down the operations vectors
 192          */
 193         (void) vfs_freevfsops_by_type(hsfsfstype);
 194         vn_freevnodeops(hsfs_vnodeops);
 195 
 196         hs_fini_hsnode_cache();
 197         hsched_fini_caches();
 198         return (0);
 199 }
 200 
 201 int
 202 _info(struct modinfo *modinfop)
 203 {
 204         return (mod_info(&modlinkage, modinfop));
 205 }
 206 
 207 #define BDEVFLAG(dev)   ((devopsp[getmajor(dev)])->devo_cb_ops->cb_flag)
 208 
 209 kmutex_t hs_mounttab_lock;
 210 struct hsfs *hs_mounttab = NULL;
 211 
 212 /* default mode, uid, gid */
 213 mode_t hsfs_default_mode = 0555;
 214 uid_t hsfs_default_uid = 0;
 215 gid_t hsfs_default_gid = 3;
 216 
 217 extern void hsched_init(struct hsfs *fsp, int fsid,
 218                                         struct modlinkage *modlinkage);
 219 extern void hsched_fini(struct hsfs_queue *hqueue);
 220 extern void hsfs_init_kstats(struct hsfs *fsp, int fsid);
 221 extern void hsfs_fini_kstats(struct hsfs *fsp);
 222 
 223 static int hsfs_mount(struct vfs *vfsp, struct vnode *mvp,
 224         struct mounta *uap, struct cred *cr);
 225 static int hsfs_unmount(struct vfs *vfsp, int, struct cred *cr);
 226 static int hsfs_root(struct vfs *vfsp, struct vnode **vpp);
 227 static int hsfs_statvfs(struct vfs *vfsp, struct statvfs64 *sbp);
 228 static int hsfs_vget(struct vfs *vfsp, struct vnode **vpp, struct fid *fidp);
 229 static int hsfs_mountroot(struct vfs *, enum whymountroot);
 230 
 231 static int hs_mountfs(struct vfs *vfsp, dev_t dev, char *path,
 232         mode_t mode, int flags, struct cred *cr, int isroot);
 233 static int hs_getrootvp(struct vfs *vfsp, struct hsfs *fsp, size_t pathsize);
 234 static int hs_findhsvol(struct hsfs *fsp, struct vnode *vp,
 235         struct hs_volume *hvp);
 236 static int hs_parsehsvol(struct hsfs *fsp, uchar_t *volp,
 237         struct hs_volume *hvp);
 238 static int hs_findisovol(struct hsfs *fsp, struct vnode *vp,
 239         struct hs_volume *hvp,
 240         struct hs_volume *svp,
 241         struct hs_volume *jvp);
 242 static int hs_joliet_level(uchar_t *volp);
 243 static int hs_parseisovol(struct hsfs *fsp, uchar_t *volp,
 244         struct hs_volume *hvp);
 245 static void hs_copylabel(struct hs_volume *, unsigned char *, int);
 246 static int hs_getmdev(struct vfs *, char *fspec, int flags, dev_t *pdev,
 247         mode_t *mode, cred_t *cr);
 248 static int hs_findvoldesc(dev_t rdev, int desc_sec);
 249 
 250 static int
 251 hsfsinit(int fstype, char *name)
 252 {
 253         static const fs_operation_def_t hsfs_vfsops_template[] = {
 254                 VFSNAME_MOUNT,          { .vfs_mount = hsfs_mount },
 255                 VFSNAME_UNMOUNT,        { .vfs_unmount = hsfs_unmount },
 256                 VFSNAME_ROOT,           { .vfs_root = hsfs_root },
 257                 VFSNAME_STATVFS,        { .vfs_statvfs = hsfs_statvfs },
 258                 VFSNAME_VGET,           { .vfs_vget = hsfs_vget },
 259                 VFSNAME_MOUNTROOT,      { .vfs_mountroot = hsfs_mountroot },
 260                 NULL,                   NULL
 261         };
 262         int error;
 263 
 264         error = vfs_setfsops(fstype, hsfs_vfsops_template, NULL);
 265         if (error != 0) {
 266                 cmn_err(CE_WARN, "hsfsinit: bad vfs ops template");
 267                 return (error);
 268         }
 269 
 270         error = vn_make_ops(name, hsfs_vnodeops_template, &hsfs_vnodeops);
 271         if (error != 0) {
 272                 (void) vfs_freevfsops_by_type(fstype);
 273                 cmn_err(CE_WARN, "hsfsinit: bad vnode ops template");
 274                 return (error);
 275         }
 276 
 277         hsfsfstype = fstype;
 278         mutex_init(&hs_mounttab_lock, NULL, MUTEX_DEFAULT, NULL);
 279         hs_init_hsnode_cache();
 280         hsched_init_caches();
 281         return (0);
 282 }
 283 
 284 /*ARGSUSED*/
 285 static int
 286 hsfs_mount(struct vfs *vfsp, struct vnode *mvp,
 287     struct mounta *uap, struct cred *cr)
 288 {
 289         int             vnode_busy;
 290         dev_t           dev;
 291         struct pathname dpn;
 292         int             error;
 293         mode_t          mode;
 294         int             flags;  /* this will hold the mount specific data */
 295 
 296         if ((error = secpolicy_fs_mount(cr, mvp, vfsp)) != 0)
 297                 return (error);
 298 
 299         if (mvp->v_type != VDIR)
 300                 return (ENOTDIR);
 301 
 302         /* mount option must be read only, else mount will be rejected */
 303         if (!(uap->flags & MS_RDONLY))
 304                 return (EROFS);
 305 
 306         /*
 307          * We already told the framework that we don't support remounting.
 308          */
 309         ASSERT(!(uap->flags & MS_REMOUNT));
 310 
 311         mutex_enter(&mvp->v_lock);
 312         vnode_busy = (mvp->v_count != 1) || (mvp->v_flag & VROOT);
 313         mutex_exit(&mvp->v_lock);
 314 
 315         if ((uap->flags & MS_OVERLAY) == 0 && vnode_busy) {
 316                 return (EBUSY);
 317         }
 318 
 319         /*
 320          * Check for the options that actually affect things
 321          * at our level.
 322          */
 323         flags = 0;
 324         if (vfs_optionisset(vfsp, HOPT_NOMAPLCASE, NULL))
 325                 flags |= HSFSMNT_NOMAPLCASE;
 326         if (vfs_optionisset(vfsp, HOPT_NOTRAILDOT, NULL))
 327                 flags |= HSFSMNT_NOTRAILDOT;
 328         if (vfs_optionisset(vfsp, HOPT_NRR, NULL))
 329                 flags |= HSFSMNT_NORRIP;
 330         if (vfs_optionisset(vfsp, HOPT_NOJOLIET, NULL))
 331                 flags |= HSFSMNT_NOJOLIET;
 332         if (vfs_optionisset(vfsp, HOPT_JOLIETLONG, NULL))
 333                 flags |= HSFSMNT_JOLIETLONG;
 334         if (vfs_optionisset(vfsp, HOPT_NOVERS2, NULL))
 335                 flags |= HSFSMNT_NOVERS2;
 336 
 337         error = pn_get(uap->dir, (uap->flags & MS_SYSSPACE) ?
 338             UIO_SYSSPACE : UIO_USERSPACE, &dpn);
 339         if (error)
 340                 return (error);
 341 
 342         error = hs_getmdev(vfsp, uap->spec, uap->flags, &dev, &mode, cr);
 343         if (error != 0) {
 344                 pn_free(&dpn);
 345                 return (error);
 346         }
 347 
 348         /*
 349          * If the device is a tape, return error
 350          */
 351         if ((BDEVFLAG(dev) & D_TAPE) == D_TAPE)  {
 352                 pn_free(&dpn);
 353                 return (ENOTBLK);
 354         }
 355 
 356         /*
 357          * Mount the filesystem.
 358          */
 359         error = hs_mountfs(vfsp, dev, dpn.pn_path, mode, flags, cr, 0);
 360         pn_free(&dpn);
 361         return (error);
 362 }
 363 
 364 /*ARGSUSED*/
 365 static int
 366 hsfs_unmount(
 367         struct vfs *vfsp,
 368         int flag,
 369         struct cred *cr)
 370 {
 371         struct hsfs **tspp;
 372         struct hsfs *fsp;
 373 
 374         if (secpolicy_fs_unmount(cr, vfsp) != 0)
 375                 return (EPERM);
 376 
 377         /*
 378          * forced unmount is not supported by this file system
 379          * and thus, ENOTSUP is being returned.
 380          */
 381         if (flag & MS_FORCE)
 382                 return (ENOTSUP);
 383 
 384         fsp = VFS_TO_HSFS(vfsp);
 385 
 386         if (fsp->hsfs_rootvp->v_count != 1)
 387                 return (EBUSY);
 388 
 389         /* destroy all old pages and hsnodes for this vfs */
 390         if (hs_synchash(vfsp))
 391                 return (EBUSY);
 392 
 393         mutex_enter(&hs_mounttab_lock);
 394         for (tspp = &hs_mounttab; *tspp != NULL; tspp = &(*tspp)->hsfs_next) {
 395                 if (*tspp == fsp)
 396                         break;
 397         }
 398         if (*tspp == NULL) {
 399                 mutex_exit(&hs_mounttab_lock);
 400                 panic("hsfs_unmount: vfs not mounted?");
 401                 /*NOTREACHED*/
 402         }
 403 
 404         *tspp = fsp->hsfs_next;
 405 
 406         mutex_exit(&hs_mounttab_lock);
 407 
 408         hsfs_fini_kstats(fsp);
 409         (void) VOP_CLOSE(fsp->hsfs_devvp, FREAD, 1, (offset_t)0, cr, NULL);
 410         VN_RELE(fsp->hsfs_devvp);
 411         /* free path table space */
 412         if (fsp->hsfs_ptbl != NULL)
 413                 kmem_free(fsp->hsfs_ptbl, (size_t)fsp->hsfs_vol.ptbl_len);
 414         /* free path table index table */
 415         if (fsp->hsfs_ptbl_idx != NULL)
 416                 kmem_free(fsp->hsfs_ptbl_idx, (size_t)
 417                     (fsp->hsfs_ptbl_idx_size * sizeof (struct ptable_idx)));
 418 
 419         /* free "mounted on" pathame */
 420         if (fsp->hsfs_fsmnt != NULL)
 421                 kmem_free(fsp->hsfs_fsmnt, strlen(fsp->hsfs_fsmnt) + 1);
 422 
 423         hsched_fini(fsp->hqueue);
 424         kmem_free(fsp->hqueue, sizeof (struct hsfs_queue));
 425 
 426         mutex_destroy(&fsp->hsfs_free_lock);
 427         rw_destroy(&fsp->hsfs_hash_lock);
 428 
 429         kmem_free(fsp, sizeof (*fsp));
 430         return (0);
 431 }
 432 
 433 /*ARGSUSED*/
 434 static int
 435 hsfs_root(struct vfs *vfsp, struct vnode **vpp)
 436 {
 437         *vpp = (VFS_TO_HSFS(vfsp))->hsfs_rootvp;
 438         VN_HOLD(*vpp);
 439         return (0);
 440 }
 441 
 442 /*ARGSUSED*/
 443 static int
 444 hsfs_statvfs(struct vfs *vfsp, struct statvfs64 *sbp)
 445 {
 446         struct hsfs *fsp;
 447         dev32_t d32;
 448 
 449         fsp = VFS_TO_HSFS(vfsp);
 450         if (fsp->hsfs_magic != HSFS_MAGIC)
 451                 return (EINVAL);
 452         bzero(sbp, sizeof (*sbp));
 453         sbp->f_bsize = vfsp->vfs_bsize;
 454         sbp->f_frsize = sbp->f_bsize; /* no fragment, same as block size */
 455         sbp->f_blocks = (fsblkcnt64_t)fsp->hsfs_vol.vol_size;
 456 
 457         sbp->f_bfree = (fsblkcnt64_t)0;
 458         sbp->f_bavail = (fsblkcnt64_t)0;
 459         sbp->f_files = (fsfilcnt64_t)-1;
 460         sbp->f_ffree = (fsfilcnt64_t)0;
 461         sbp->f_favail = (fsfilcnt64_t)0;
 462         (void) cmpldev(&d32, vfsp->vfs_dev);
 463         sbp->f_fsid = d32;
 464         (void) strcpy(sbp->f_basetype, vfssw[vfsp->vfs_fstype].vsw_name);
 465         sbp->f_flag = vf_to_stf(vfsp->vfs_flag);
 466         sbp->f_namemax = fsp->hsfs_namemax;
 467         (void) strcpy(sbp->f_fstr, fsp->hsfs_vol.vol_id);
 468 
 469         return (0);
 470 }
 471 
 472 /*
 473  * Previously nodeid was declared as uint32_t. This has been changed
 474  * to conform better with the ISO9660 standard. The standard states that
 475  * a LBN can be a 32 bit number, as the MAKE_NODEID macro shifts this
 476  * LBN 11 places left (LBN_TO_BYTE) and then shifts the result 5 right
 477  * (divide by 32) we are left with the potential of an overflow if
 478  * confined to a 32 bit value.
 479  */
 480 
 481 static int
 482 hsfs_vget(struct vfs *vfsp, struct vnode **vpp, struct fid *fidp)
 483 {
 484         struct hsfid *fid;
 485         struct hsfs *fsp;
 486         ino64_t nodeid;
 487         int error;
 488 
 489         fsp = (struct hsfs *)VFS_TO_HSFS(vfsp);
 490         fid = (struct hsfid *)fidp;
 491 
 492         /*
 493          * Look for vnode on hashlist.
 494          * If found, it's now active and the refcnt was incremented.
 495          */
 496 
 497         rw_enter(&fsp->hsfs_hash_lock, RW_READER);
 498 
 499         nodeid = fid->hf_ino;
 500 
 501         if ((*vpp = hs_findhash(nodeid, fid->hf_dir_lbn,
 502             (uint_t)fid->hf_dir_off, vfsp)) == NULL) {
 503                 /*
 504                  * Not in cache, so we need to remake it.
 505                  * hs_remakenode() will read the directory entry
 506                  * and then check again to see if anyone else has
 507                  * put it in the cache.
 508                  */
 509                 rw_exit(&fsp->hsfs_hash_lock);
 510                 error = hs_remakenode(fid->hf_dir_lbn, (uint_t)fid->hf_dir_off,
 511                     vfsp, vpp);
 512                 return (error);
 513         }
 514         rw_exit(&fsp->hsfs_hash_lock);
 515         return (0);
 516 }
 517 
 518 
 519 #define CHECKSUM_SIZE                           (64 * 1024)
 520 
 521 /*
 522  * Compute a CD-ROM fsid by checksumming the first 64K of data on the CD
 523  * We use the 'fsp' argument to determine the location of the root
 524  * directory entry, and we start reading from there.
 525  */
 526 static int
 527 compute_cdrom_id(struct hsfs *fsp, vnode_t *devvp)
 528 {
 529         uint_t          secno;
 530         struct hs_volume *hsvp = &fsp->hsfs_vol;
 531         struct buf      *bp;
 532         int             error;
 533         int             fsid;
 534 
 535         secno = hsvp->root_dir.ext_lbn >> hsvp->lbn_secshift;
 536         bp = bread(devvp->v_rdev, secno * 4, CHECKSUM_SIZE);
 537         error = geterror(bp);
 538 
 539         /*
 540          * An error on read or a partial read means we asked
 541          * for a nonexistant/corrupted piece of the device
 542          * (including past-the-end of the media). Don't
 543          * try to use the checksumming method then.
 544          */
 545         if (!error && bp->b_bcount == CHECKSUM_SIZE) {
 546                 int *ibuf = (int *)bp->b_un.b_addr;
 547                 int i;
 548 
 549                 fsid = 0;
 550 
 551                 for (i = 0; i < CHECKSUM_SIZE / sizeof (int); i++)
 552                         fsid ^= ibuf[ i ];
 553         } else {
 554                 /*
 555                  * Fallback - use creation date
 556                  */
 557                 fsid = hsvp->cre_date.tv_sec;
 558         }
 559 
 560         brelse(bp);
 561 
 562         return (fsid);
 563 }
 564 
 565 
 566 /*ARGSUSED*/
 567 static int
 568 hs_mountfs(
 569         struct vfs      *vfsp,
 570         dev_t           dev,
 571         char            *path,
 572         mode_t          mode,
 573         int             mount_flags,
 574         struct cred     *cr,
 575         int             isroot)
 576 {
 577         struct vnode    *devvp;
 578         struct hsfs     *tsp;
 579         struct hsfs     *fsp = NULL;
 580         struct vattr    vap;
 581         struct hsnode   *hp;
 582         int             error;
 583         struct timeval  tv;
 584         int             fsid;
 585         int             use_rrip;
 586         int             use_vers2;
 587         int             use_joliet;
 588         int             has_rrip = 0;
 589         int             has_vers2 = 0;
 590         int             has_joliet = 0;
 591         int             force_rrip_off;
 592         int             force_vers2_off;
 593         int             force_joliet_off;
 594         size_t          pathbufsz = strlen(path) + 1;
 595         int             redo_rootvp;
 596 
 597         struct hs_volume *svp = NULL;   /* Supplemental VD for ISO-9660:1999 */
 598         struct hs_volume *jvp = NULL;   /* Joliet VD */
 599 
 600         /*
 601          * The rules for which extension will be used are:
 602          * 1. No specific mount options given:
 603          *      - use rrip if available
 604          *      - use ISO9660:1999 if available
 605          *      - use joliet if available.
 606          * 2. rrip/ISO9660:1999/joliet explicitly disabled via mount option:
 607          *      - use next "lower" extension
 608          * 3. joliet/ISO9660:1999/rrip explicitly requested via mount option:
 609          *      - disable rrip support even if available
 610          *      - disable IOS9660:1999 support even if available
 611          *
 612          * We need to adjust these flags as we discover the extensions
 613          * present. See below. These are just the starting values.
 614          */
 615         use_rrip = (mount_flags & HSFSMNT_NORRIP) == 0;
 616         use_vers2 = (mount_flags & HSFSMNT_NOVERS2) == 0;
 617         use_joliet = (mount_flags & HSFSMNT_NOJOLIET) == 0;
 618 
 619         /*
 620          * Open the device
 621          */
 622         devvp = makespecvp(dev, VBLK);
 623         ASSERT(devvp != 0);
 624 
 625         /*
 626          * Open the target device (file) for read only.
 627          */
 628         if (error = VOP_OPEN(&devvp, FREAD, cr, NULL)) {
 629                 VN_RELE(devvp);
 630                 return (error);
 631         }
 632 
 633         /*
 634          * Refuse to go any further if this
 635          * device is being used for swapping
 636          */
 637         if (IS_SWAPVP(common_specvp(devvp))) {
 638                 error = EBUSY;
 639                 goto cleanup;
 640         }
 641 
 642         vap.va_mask = AT_SIZE;
 643         if ((error = VOP_GETATTR(devvp, &vap, ATTR_COMM, cr, NULL)) != 0) {
 644                 cmn_err(CE_NOTE, "Cannot get attributes of the CD-ROM driver");
 645                 goto cleanup;
 646         }
 647 
 648         /*
 649          * Make sure we have a nonzero size partition.
 650          * The current version of the SD driver will *not* fail the open
 651          * of such a partition so we have to check for it here.
 652          */
 653         if (vap.va_size == 0) {
 654                 error = ENXIO;
 655                 goto cleanup;
 656         }
 657 
 658         /*
 659          * Init a new hsfs structure.
 660          */
 661         fsp = kmem_zalloc(sizeof (*fsp), KM_SLEEP);
 662         svp = kmem_zalloc(sizeof (*svp), KM_SLEEP);
 663         jvp = kmem_zalloc(sizeof (*jvp), KM_SLEEP);
 664 
 665         /* hardwire perms, uid, gid */
 666         fsp->hsfs_vol.vol_uid = hsfs_default_uid;
 667         fsp->hsfs_vol.vol_gid =  hsfs_default_gid;
 668         fsp->hsfs_vol.vol_prot = hsfs_default_mode;
 669         svp->vol_uid = hsfs_default_uid;
 670         svp->vol_gid =  hsfs_default_gid;
 671         svp->vol_prot = hsfs_default_mode;
 672         jvp->vol_uid = hsfs_default_uid;
 673         jvp->vol_gid =  hsfs_default_gid;
 674         jvp->vol_prot = hsfs_default_mode;
 675 
 676         /*
 677          * Look for a Standard File Structure Volume Descriptor,
 678          * of which there must be at least one.
 679          * If found, check for volume size consistency.
 680          *
 681          * If svp->lbn_size is != 0, we did find a ISO-9660:1999 SVD
 682          * If jvp->lbn_size is != 0, we did find a Joliet SVD.
 683          */
 684         fsp->hsfs_namemax = ISO_FILE_NAMELEN;
 685         fsp->hsfs_namelen = ISO_FILE_NAMELEN;
 686         error = hs_findisovol(fsp, devvp, &fsp->hsfs_vol, svp, jvp);
 687         if (error == EINVAL) /* no iso 9660 - try high sierra ... */
 688                 error = hs_findhsvol(fsp, devvp, &fsp->hsfs_vol);
 689 
 690         if (error)
 691                 goto cleanup;
 692 
 693         DTRACE_PROBE4(findvol,
 694             struct hsfs *, fsp,
 695             struct hs_volume *, &fsp->hsfs_vol,
 696             struct hs_volume *, svp,
 697             struct hs_volume *, jvp);
 698 
 699         /*
 700          * Generate a file system ID from the CD-ROM,
 701          * and check it for uniqueness.
 702          *
 703          * What we are aiming for is some chance of integrity
 704          * across disk change.  That is, if a client has an fhandle,
 705          * it will be valid as long as the same disk is mounted.
 706          */
 707         fsid = compute_cdrom_id(fsp, devvp);
 708 
 709         mutex_enter(&hs_mounttab_lock);
 710 
 711         if (fsid == 0 || fsid == -1) {
 712                 uniqtime(&tv);
 713                 fsid = tv.tv_sec;
 714         } else  /* make sure that the fsid is unique */
 715                 for (tsp = hs_mounttab; tsp != NULL; tsp = tsp->hsfs_next) {
 716                         if (fsid == tsp->hsfs_vfs->vfs_fsid.val[0]) {
 717                                 uniqtime(&tv);
 718                                 fsid = tv.tv_sec;
 719                                 break;
 720                         }
 721                 }
 722 
 723         fsp->hsfs_next = hs_mounttab;
 724         hs_mounttab = fsp;
 725 
 726         fsp->hsfs_devvp = devvp;
 727         fsp->hsfs_vfs = vfsp;
 728         fsp->hsfs_fsmnt = kmem_alloc(pathbufsz, KM_SLEEP);
 729         (void) strlcpy(fsp->hsfs_fsmnt, path, pathbufsz);
 730 
 731         mutex_init(&fsp->hsfs_free_lock, NULL, MUTEX_DEFAULT, NULL);
 732         rw_init(&fsp->hsfs_hash_lock, NULL, RW_DEFAULT, NULL);
 733 
 734         vfsp->vfs_data = (caddr_t)fsp;
 735         vfsp->vfs_dev = dev;
 736         vfsp->vfs_fstype = hsfsfstype;
 737         vfsp->vfs_bsize = fsp->hsfs_vol.lbn_size; /* %% */
 738         vfsp->vfs_fsid.val[0] = fsid;
 739         vfsp->vfs_fsid.val[1] =  hsfsfstype;
 740 
 741         if (!hs_getrootvp(vfsp, fsp, pathbufsz)) {
 742                 DTRACE_PROBE1(rootvp__failed, struct hsfs *, fsp);
 743                 error = EINVAL;
 744                 goto cleanup;
 745         }
 746         DTRACE_PROBE1(rootvp, struct hsfs *, fsp);
 747 
 748         /*
 749          * Attempt to discover a RR extension.
 750          */
 751         if (use_rrip) {
 752                 hp = VTOH(fsp->hsfs_rootvp);
 753                 hs_check_root_dirent(fsp->hsfs_rootvp, &(hp->hs_dirent));
 754         }
 755 
 756         has_rrip = IS_RRIP_IMPLEMENTED(fsp);
 757         has_vers2 = (svp->lbn_size != 0);
 758         has_joliet = (jvp->lbn_size != 0);
 759 
 760         DTRACE_PROBE4(voltype__suggested, struct hsfs *, fsp,
 761             int, use_rrip, int, use_vers2, int, use_joliet);
 762 
 763         DTRACE_PROBE4(voltype__actual, struct hsfs *, fsp,
 764             int, has_rrip, int, has_vers2, int, has_joliet);
 765 
 766         DTRACE_PROBE4(findvol,
 767             struct hsfs *, fsp,
 768             struct hs_volume *, &fsp->hsfs_vol,
 769             struct hs_volume *, svp,
 770             struct hs_volume *, jvp);
 771 
 772         force_rrip_off = !use_rrip ||
 773             (vfs_optionisset(vfsp, HOPT_JOLIET, NULL) && has_joliet) ||
 774             (vfs_optionisset(vfsp, HOPT_VERS2, NULL) && has_vers2);
 775 
 776         force_vers2_off = !use_vers2 ||
 777             (vfs_optionisset(vfsp, HOPT_JOLIET, NULL) && has_joliet);
 778 
 779         force_joliet_off = !use_joliet;
 780 
 781         DTRACE_PROBE4(voltype__force_off, struct hsfs *, fsp,
 782             int, force_rrip_off, int, force_vers2_off, int, force_joliet_off);
 783 
 784         /*
 785          * At the moment, we have references of all three possible
 786          * extensions (RR, ISO9660:1999/v2 and Joliet) if present.
 787          *
 788          * The "active" volume descriptor is RRIP (or ISO9660:1988).
 789          * We now switch to the user-requested one.
 790          */
 791         redo_rootvp = 0;
 792 
 793         if (force_rrip_off || !has_rrip) {
 794                 if (has_vers2 && !force_vers2_off) {
 795                         VN_RELE(fsp->hsfs_rootvp);
 796                         bcopy(svp, &fsp->hsfs_vol, sizeof (struct hs_volume));
 797                         fsp->hsfs_vol_type = HS_VOL_TYPE_ISO_V2;
 798                         vfsp->vfs_bsize = fsp->hsfs_vol.lbn_size;
 799                         redo_rootvp = 1;
 800                         has_joliet = 0;
 801                 } else if (has_joliet && !force_joliet_off) {
 802                         VN_RELE(fsp->hsfs_rootvp);
 803                         bcopy(jvp, &fsp->hsfs_vol, sizeof (struct hs_volume));
 804                         fsp->hsfs_vol_type = HS_VOL_TYPE_JOLIET;
 805                         vfsp->vfs_bsize = fsp->hsfs_vol.lbn_size;
 806                         redo_rootvp = 1;
 807                         has_vers2 = 0;
 808                 }
 809         }
 810 
 811         if (redo_rootvp) {
 812                 /*
 813                  * Make sure not to use Rock Ridge.
 814                  */
 815                 UNSET_IMPL_BIT(fsp, RRIP_BIT);
 816                 UNSET_SUSP_BIT(fsp);
 817                 has_rrip = 0;
 818 
 819                 if (!hs_getrootvp(vfsp, fsp, pathbufsz)) {
 820                         DTRACE_PROBE1(rootvp__failed, struct hsfs *, fsp);
 821                         error = EINVAL;
 822                         goto cleanup;
 823                 }
 824                 DTRACE_PROBE1(rootvp, struct hsfs *, fsp);
 825         }
 826         if (IS_RRIP_IMPLEMENTED(fsp)) {
 827                 has_vers2 = 0;
 828                 has_joliet = 0;
 829         }
 830         if (force_vers2_off)
 831                 has_vers2 = 0;
 832         if (force_joliet_off)
 833                 has_joliet = 0;
 834         DTRACE_PROBE4(voltype__taken, struct hsfs *, fsp,
 835             int, has_rrip, int, has_vers2, int, has_joliet);
 836 
 837         /*
 838          * mark root node as VROOT
 839          */
 840         fsp->hsfs_rootvp->v_flag |= VROOT;
 841 
 842         /* Here we take care of some special case stuff for mountroot */
 843         if (isroot) {
 844                 fsp->hsfs_rootvp->v_rdev = devvp->v_rdev;
 845                 rootvp = fsp->hsfs_rootvp;
 846         }
 847 
 848         if (IS_RRIP_IMPLEMENTED(fsp)) {
 849                 /*
 850                  * if RRIP, don't copy NOMAPLCASE or NOTRAILDOT to hsfs_flags
 851                  */
 852                 mount_flags &= ~(HSFSMNT_NOMAPLCASE | HSFSMNT_NOTRAILDOT);
 853 
 854                 fsp->hsfs_namemax = RRIP_FILE_NAMELEN;
 855                 fsp->hsfs_namelen = RRIP_FILE_NAMELEN;
 856 
 857                 ASSERT(vfs_optionisset(vfsp, HOPT_RR, NULL));
 858                 vfs_clearmntopt(vfsp, HOPT_VERS2);
 859                 vfs_clearmntopt(vfsp, HOPT_JOLIET);
 860 
 861         } else switch (fsp->hsfs_vol_type) {
 862 
 863         case HS_VOL_TYPE_HS:
 864         case HS_VOL_TYPE_ISO:
 865         default:
 866                 /*
 867                  * if iso v1, don't allow trailing spaces in iso file names
 868                  */
 869                 mount_flags |= HSFSMNT_NOTRAILSPACE;
 870                 fsp->hsfs_namemax = ISO_NAMELEN_V2_MAX;
 871                 fsp->hsfs_namelen = ISO_FILE_NAMELEN;
 872                 vfs_clearmntopt(vfsp, HOPT_RR);
 873                 vfs_clearmntopt(vfsp, HOPT_VERS2);
 874                 vfs_clearmntopt(vfsp, HOPT_JOLIET);
 875                 break;
 876 
 877         case HS_VOL_TYPE_ISO_V2:
 878                 /*
 879                  * if iso v2, don't copy NOTRAILDOT to hsfs_flags
 880                  */
 881                 mount_flags &= ~HSFSMNT_NOTRAILDOT;
 882                 mount_flags |= HSFSMNT_NOMAPLCASE | HSFSMNT_NOVERSION;
 883                 fsp->hsfs_namemax = ISO_NAMELEN_V2_MAX;
 884                 fsp->hsfs_namelen = ISO_NAMELEN_V2;
 885                 vfs_setmntopt(vfsp, HOPT_VERS2, NULL, 0);
 886                 vfs_clearmntopt(vfsp, HOPT_RR);
 887                 vfs_clearmntopt(vfsp, HOPT_JOLIET);
 888                 break;
 889 
 890         case HS_VOL_TYPE_JOLIET:
 891                 /*
 892                  * if Joliet, don't copy NOMAPLCASE or NOTRAILDOT to hsfs_flags
 893                  */
 894                 mount_flags &= ~(HSFSMNT_NOMAPLCASE | HSFSMNT_NOTRAILDOT);
 895                 mount_flags |= HSFSMNT_NOMAPLCASE;
 896                 if (mount_flags & HSFSMNT_JOLIETLONG)
 897                         fsp->hsfs_namemax = JOLIET_NAMELEN_MAX*3; /* UTF-8 */
 898                 else
 899                         fsp->hsfs_namemax = MAXNAMELEN-1;
 900                 fsp->hsfs_namelen = JOLIET_NAMELEN*2;
 901                 vfs_setmntopt(vfsp, HOPT_JOLIET, NULL, 0);
 902                 vfs_clearmntopt(vfsp, HOPT_RR);
 903                 vfs_clearmntopt(vfsp, HOPT_VERS2);
 904                 break;
 905         }
 906 
 907         /*
 908          * Add the HSFSMNT_INODE pseudo mount flag to the current mount flags.
 909          */
 910         fsp->hsfs_flags = mount_flags | (fsp->hsfs_flags & HSFSMNT_INODE);
 911 
 912         /*
 913          * Setup I/O Scheduling structures
 914          */
 915         if (do_schedio) {
 916                 fsp->hqueue = kmem_alloc(sizeof (struct hsfs_queue), KM_SLEEP);
 917                 hsched_init(fsp, fsid, &modlinkage);
 918         }
 919 
 920         /*
 921          * Setup kstats
 922          */
 923         hsfs_init_kstats(fsp, fsid);
 924 
 925         DTRACE_PROBE1(mount__done, struct hsfs *, fsp);
 926 
 927         /*
 928          * set the magic word
 929          */
 930         fsp->hsfs_magic = HSFS_MAGIC;
 931         mutex_exit(&hs_mounttab_lock);
 932 
 933         kmem_free(svp, sizeof (*svp));
 934         kmem_free(jvp, sizeof (*jvp));
 935 
 936         return (0);
 937 
 938 cleanup:
 939         (void) VOP_CLOSE(devvp, FREAD, 1, (offset_t)0, cr, NULL);
 940         VN_RELE(devvp);
 941         if (fsp)
 942                 kmem_free(fsp, sizeof (*fsp));
 943         if (svp)
 944                 kmem_free(svp, sizeof (*svp));
 945         if (jvp)
 946                 kmem_free(jvp, sizeof (*jvp));
 947         return (error);
 948 }
 949 
 950 /*
 951  * Get the rootvp associated with fsp->hsfs_vol
 952  */
 953 static int
 954 hs_getrootvp(
 955         struct vfs      *vfsp,
 956         struct hsfs     *fsp,
 957         size_t          pathsize)
 958 {
 959         struct hsnode   *hp;
 960 
 961         ASSERT(pathsize == strlen(fsp->hsfs_fsmnt) + 1);
 962 
 963         /*
 964          * If the root directory does not appear to be
 965          * valid, use what it points to as "." instead.
 966          * Some Defense Mapping Agency disks are non-conformant
 967          * in this way.
 968          */
 969         if (!hsfs_valid_dir(&fsp->hsfs_vol.root_dir)) {
 970                 hs_log_bogus_disk_warning(fsp, HSFS_ERR_BAD_ROOT_DIR, 0);
 971                 if (hs_remakenode(fsp->hsfs_vol.root_dir.ext_lbn,
 972                     (uint_t)0, vfsp, &fsp->hsfs_rootvp)) {
 973                         hs_mounttab = hs_mounttab->hsfs_next;
 974                         mutex_destroy(&fsp->hsfs_free_lock);
 975                         rw_destroy(&fsp->hsfs_hash_lock);
 976                         kmem_free(fsp->hsfs_fsmnt, pathsize);
 977                         mutex_exit(&hs_mounttab_lock);
 978                         return (0);
 979                 }
 980         } else {
 981                 fsp->hsfs_rootvp = hs_makenode(&fsp->hsfs_vol.root_dir,
 982                     fsp->hsfs_vol.root_dir.ext_lbn, 0, vfsp);
 983         }
 984 
 985         /* XXX - ignore the path table for now */
 986         fsp->hsfs_ptbl = NULL;
 987         hp = VTOH(fsp->hsfs_rootvp);
 988         hp->hs_ptbl_idx = NULL;
 989 
 990         return (1);
 991 }
 992 
 993 /*
 994  * hs_findhsvol()
 995  *
 996  * Locate the Standard File Structure Volume Descriptor and
 997  * parse it into an hs_volume structure.
 998  *
 999  * XXX - May someday want to look for Coded Character Set FSVD, too.
1000  */
1001 static int
1002 hs_findhsvol(struct hsfs *fsp, struct vnode *vp, struct hs_volume *hvp)
1003 {
1004         struct buf *secbp;
1005         int i;
1006         int n;
1007         uchar_t *volp;
1008         int error;
1009         uint_t secno;
1010 
1011         secno = hs_findvoldesc(vp->v_rdev, HS_VOLDESC_SEC);
1012         secbp = bread(vp->v_rdev, secno * 4, HS_SECTOR_SIZE);
1013         error = geterror(secbp);
1014 
1015         if (error != 0) {
1016                 cmn_err(CE_NOTE, "hs_findhsvol: bread: error=(%d)", error);
1017                 brelse(secbp);
1018                 return (error);
1019         }
1020 
1021         volp = (uchar_t *)secbp->b_un.b_addr;
1022 
1023         /*
1024          * To avoid that we read the whole medium in case that someone prepares
1025          * a malicious "fs image", we read at most 32 blocks.
1026          */
1027         for (n = 0; n < 32 &&
1028             HSV_DESC_TYPE(volp) != VD_EOV; n++) {
1029                 for (i = 0; i < HSV_ID_STRLEN; i++)
1030                         if (HSV_STD_ID(volp)[i] != HSV_ID_STRING[i])
1031                                 goto cantfind;
1032                 if (HSV_STD_VER(volp) != HSV_ID_VER)
1033                         goto cantfind;
1034                 switch (HSV_DESC_TYPE(volp)) {
1035                 case VD_SFS:
1036                         /* Standard File Structure */
1037                         fsp->hsfs_vol_type = HS_VOL_TYPE_HS;
1038                         error = hs_parsehsvol(fsp, volp, hvp);
1039                         brelse(secbp);
1040                         return (error);
1041 
1042                 case VD_CCFS:
1043                         /* Coded Character File Structure */
1044                 case VD_BOOT:
1045                 case VD_UNSPEC:
1046                 case VD_EOV:
1047                         break;
1048                 }
1049                 brelse(secbp);
1050                 ++secno;
1051                 secbp = bread(vp->v_rdev, secno * 4, HS_SECTOR_SIZE);
1052 
1053                 error = geterror(secbp);
1054 
1055                 if (error != 0) {
1056                         cmn_err(CE_NOTE, "hs_findhsvol: bread: error=(%d)",
1057                             error);
1058                         brelse(secbp);
1059                         return (error);
1060                 }
1061 
1062                 volp = (uchar_t *)secbp->b_un.b_addr;
1063         }
1064 cantfind:
1065         brelse(secbp);
1066         return (EINVAL);
1067 }
1068 
1069 /*
1070  * hs_parsehsvol
1071  *
1072  * Parse the Standard File Structure Volume Descriptor into
1073  * an hs_volume structure.  We can't just bcopy it into the
1074  * structure because of byte-ordering problems.
1075  *
1076  */
1077 static int
1078 hs_parsehsvol(struct hsfs *fsp, uchar_t *volp, struct hs_volume *hvp)
1079 {
1080         hvp->vol_size = HSV_VOL_SIZE(volp);
1081         hvp->lbn_size = HSV_BLK_SIZE(volp);
1082         if (hvp->lbn_size == 0) {
1083                 cmn_err(CE_NOTE, "hs_parsehsvol: logical block size in the "
1084                     "SFSVD is zero");
1085                 return (EINVAL);
1086         }
1087         hvp->lbn_shift = ffs((long)hvp->lbn_size) - 1;
1088         hvp->lbn_secshift =
1089             ffs((long)howmany(HS_SECTOR_SIZE, (int)hvp->lbn_size)) - 1;
1090         hvp->lbn_maxoffset = hvp->lbn_size - 1;
1091         hs_parse_longdate(HSV_cre_date(volp), &hvp->cre_date);
1092         hs_parse_longdate(HSV_mod_date(volp), &hvp->mod_date);
1093         hvp->file_struct_ver = HSV_FILE_STRUCT_VER(volp);
1094         hvp->ptbl_len = HSV_PTBL_SIZE(volp);
1095         hvp->vol_set_size = (ushort_t)HSV_SET_SIZE(volp);
1096         hvp->vol_set_seq = (ushort_t)HSV_SET_SEQ(volp);
1097 #if defined(_LITTLE_ENDIAN)
1098         hvp->ptbl_lbn = HSV_PTBL_MAN_LS(volp);
1099 #else
1100         hvp->ptbl_lbn = HSV_PTBL_MAN_MS(volp);
1101 #endif
1102         hs_copylabel(hvp, HSV_VOL_ID(volp), 0);
1103 
1104         /*
1105          * Make sure that lbn_size is a power of two and otherwise valid.
1106          */
1107         if (hvp->lbn_size & ~(1 << hvp->lbn_shift)) {
1108                 cmn_err(CE_NOTE,
1109                     "hsfs: %d-byte logical block size not supported",
1110                     hvp->lbn_size);
1111                 return (EINVAL);
1112         }
1113         return (hs_parsedir(fsp, HSV_ROOT_DIR(volp), &hvp->root_dir,
1114             (char *)NULL, (int *)NULL, HDE_ROOT_DIR_REC_SIZE));
1115 }
1116 
1117 /*
1118  * hs_findisovol()
1119  *
1120  * Locate the Primary Volume Descriptor
1121  * parse it into an hs_volume structure.
1122  *
1123  * XXX - Partition not yet done
1124  *
1125  * Except for fsp->hsfs_vol_type, no fsp member may be modified.
1126  * fsp->hsfs_vol is modified indirectly via the *hvp argument.
1127  */
1128 static int
1129 hs_findisovol(struct hsfs *fsp, struct vnode *vp,
1130     struct hs_volume *hvp,
1131     struct hs_volume *svp,
1132     struct hs_volume *jvp)
1133 {
1134         struct buf *secbp;
1135         int i;
1136         int n;
1137         uchar_t *volp;
1138         int error;
1139         uint_t secno;
1140         int foundpvd = 0;
1141         int foundsvd = 0;
1142         int foundjvd = 0;
1143         int pvd_sum = 0;
1144 
1145         secno = hs_findvoldesc(vp->v_rdev, ISO_VOLDESC_SEC);
1146         secbp = bread(vp->v_rdev, secno * 4, ISO_SECTOR_SIZE);
1147         error = geterror(secbp);
1148 
1149         if (error != 0) {
1150                 cmn_err(CE_NOTE, "hs_findisovol: bread: error=(%d)", error);
1151                 brelse(secbp);
1152                 return (error);
1153         }
1154 
1155         volp = (uchar_t *)secbp->b_un.b_addr;
1156 
1157         /*
1158          * To avoid that we read the whole medium in case that someone prepares
1159          * a malicious "fs image", we read at most 32 blocks.
1160          */
1161         for (n = 0; n < 32 && ISO_DESC_TYPE(volp) != ISO_VD_EOV; n++) {
1162                 for (i = 0; i < ISO_ID_STRLEN; i++)
1163                         if (ISO_STD_ID(volp)[i] != ISO_ID_STRING[i])
1164                                 goto cantfind;
1165                 switch (ISO_DESC_TYPE(volp)) {
1166                 case ISO_VD_PVD:
1167                         /* Standard File Structure */
1168                         if (ISO_STD_VER(volp) != ISO_ID_VER)
1169                                 goto cantfind;
1170                         if (foundpvd != 1) {
1171                                 fsp->hsfs_vol_type = HS_VOL_TYPE_ISO;
1172                                 if (error = hs_parseisovol(fsp, volp, hvp)) {
1173                                         brelse(secbp);
1174                                         return (error);
1175                                 }
1176                                 foundpvd = 1;
1177                                 for (i = 0; i < ISO_SECTOR_SIZE; i++)
1178                                         pvd_sum += volp[i];
1179                         }
1180                         break;
1181                 case ISO_VD_SVD:
1182                         /* Supplementary Volume Descriptor */
1183                         if (ISO_STD_VER(volp) == ISO_ID_VER2 &&
1184                             foundsvd != 1) {
1185                                 fsp->hsfs_vol_type = HS_VOL_TYPE_ISO;
1186                                 if (error = hs_parseisovol(fsp, volp, svp)) {
1187                                         brelse(secbp);
1188                                         return (error);
1189                                 }
1190                                 foundsvd = 1;
1191                         }
1192                         if (hs_joliet_level(volp) >= 1 && foundjvd != 1) {
1193                                 fsp->hsfs_vol_type = HS_VOL_TYPE_ISO;
1194                                 if (error = hs_parseisovol(fsp, volp, jvp)) {
1195                                         brelse(secbp);
1196                                         return (error);
1197                                 }
1198                                 foundjvd = 1;
1199                         }
1200                         break;
1201                 case ISO_VD_BOOT:
1202                         break;
1203                 case ISO_VD_VPD:
1204                         /* currently cannot handle partition */
1205                         break;
1206                 case VD_EOV:
1207                         break;
1208                 }
1209                 brelse(secbp);
1210                 ++secno;
1211                 secbp = bread(vp->v_rdev, secno * 4, HS_SECTOR_SIZE);
1212                 error = geterror(secbp);
1213 
1214                 if (error != 0) {
1215                         cmn_err(CE_NOTE, "hs_findisovol: bread: error=(%d)",
1216                             error);
1217                         brelse(secbp);
1218                         return (error);
1219                 }
1220 
1221                 volp = (uchar_t *)secbp->b_un.b_addr;
1222         }
1223         for (n = 0; n < 16; n++) {
1224                 brelse(secbp);
1225                 ++secno;
1226                 secbp = bread(vp->v_rdev, secno * 4, HS_SECTOR_SIZE);
1227                 error = geterror(secbp);
1228 
1229                 if (error != 0) {
1230                         cmn_err(CE_NOTE, "hs_findisovol: bread: error=(%d)",
1231                             error);
1232                         brelse(secbp);
1233                         return (error);
1234                 }
1235 
1236                 /*
1237                  * Check for the signature from mkisofs that grants that
1238                  * the current filesystem allows to use the extent lbn as
1239                  * inode number even in pure ISO9660 mode.
1240                  */
1241                 volp = (uchar_t *)secbp->b_un.b_addr;
1242                 if (strncmp((char *)volp, "MKI ", 4) == 0) {
1243                         int     sum;
1244 
1245                         sum  = volp[2045];
1246                         sum *= 256;
1247                         sum += volp[2046];
1248                         sum *= 256;
1249                         sum += volp[2047];
1250                         if (sum == pvd_sum)
1251                                 fsp->hsfs_flags |= HSFSMNT_INODE;
1252                         break;
1253                 }
1254         }
1255         if (foundpvd) {
1256                 brelse(secbp);
1257                 return (0);
1258         }
1259 cantfind:
1260         brelse(secbp);
1261         return (EINVAL);
1262 }
1263 
1264 /*
1265  * Return 0 if no Joliet is found
1266  * else return Joliet Level 1..3
1267  */
1268 static int
1269 hs_joliet_level(uchar_t *volp)
1270 {
1271         if (ISO_std_ver(volp)[0] == ISO_ID_VER &&
1272             ISO_svd_esc(volp)[0] == '%' &&
1273             ISO_svd_esc(volp)[1] == '/') {
1274 
1275                 switch (ISO_svd_esc(volp)[2]) {
1276 
1277                 case '@':
1278                         return (1);
1279                 case 'C':
1280                         return (2);
1281                 case 'E':
1282                         return (3);
1283                 }
1284         }
1285         return (0);
1286 }
1287 
1288 /*
1289  * hs_parseisovol
1290  *
1291  * Parse the Primary Volume Descriptor into an hs_volume structure.
1292  *
1293  */
1294 static int
1295 hs_parseisovol(struct hsfs *fsp, uchar_t *volp, struct hs_volume *hvp)
1296 {
1297         hvp->vol_size = ISO_VOL_SIZE(volp);
1298         hvp->lbn_size = ISO_BLK_SIZE(volp);
1299         if (hvp->lbn_size == 0) {
1300                 cmn_err(CE_NOTE, "hs_parseisovol: logical block size in the "
1301                     "PVD is zero");
1302                 return (EINVAL);
1303         }
1304         hvp->lbn_shift = ffs((long)hvp->lbn_size) - 1;
1305         hvp->lbn_secshift =
1306             ffs((long)howmany(ISO_SECTOR_SIZE, (int)hvp->lbn_size)) - 1;
1307         hvp->lbn_maxoffset = hvp->lbn_size - 1;
1308         hs_parse_longdate(ISO_cre_date(volp), &hvp->cre_date);
1309         hs_parse_longdate(ISO_mod_date(volp), &hvp->mod_date);
1310         hvp->file_struct_ver = ISO_FILE_STRUCT_VER(volp);
1311         hvp->ptbl_len = ISO_PTBL_SIZE(volp);
1312         hvp->vol_set_size = (ushort_t)ISO_SET_SIZE(volp);
1313         hvp->vol_set_seq = (ushort_t)ISO_SET_SEQ(volp);
1314 #if defined(_LITTLE_ENDIAN)
1315         hvp->ptbl_lbn = ISO_PTBL_MAN_LS(volp);
1316 #else
1317         hvp->ptbl_lbn = ISO_PTBL_MAN_MS(volp);
1318 #endif
1319         hs_copylabel(hvp, ISO_VOL_ID(volp), hs_joliet_level(volp) >= 1);
1320 
1321         /*
1322          * Make sure that lbn_size is a power of two and otherwise valid.
1323          */
1324         if (hvp->lbn_size & ~(1 << hvp->lbn_shift)) {
1325                 cmn_err(CE_NOTE,
1326                     "hsfs: %d-byte logical block size not supported",
1327                     hvp->lbn_size);
1328                 return (EINVAL);
1329         }
1330         return (hs_parsedir(fsp, ISO_ROOT_DIR(volp), &hvp->root_dir,
1331             (char *)NULL, (int *)NULL, IDE_ROOT_DIR_REC_SIZE));
1332 }
1333 
1334 /*
1335  * Common code for mount and umount.
1336  * Check that the user's argument is a reasonable
1337  * thing on which to mount, and return the device number if so.
1338  */
1339 static int
1340 hs_getmdev(struct vfs *vfsp, char *fspec, int flags, dev_t *pdev, mode_t *mode,
1341     cred_t *cr)
1342 {
1343         int error;
1344         struct vnode *svp = NULL;
1345         struct vnode *lvp = NULL;
1346         struct vnode *bvp;
1347         struct vattr vap;
1348         dev_t dev;
1349         enum uio_seg fromspace = (flags & MS_SYSSPACE) ?
1350             UIO_SYSSPACE : UIO_USERSPACE;
1351 
1352         /*
1353          * Look up the device/file to be mounted.
1354          */
1355         error = lookupname(fspec, fromspace, FOLLOW, NULLVPP, &svp);
1356         if (error) {
1357                 if (error == ENOENT)
1358                         error = ENODEV;
1359                 goto out;
1360         }
1361 
1362         error = vfs_get_lofi(vfsp, &lvp);
1363 
1364         if (error > 0) {
1365                 if (error == ENOENT)
1366                         error = ENODEV;
1367                 goto out;
1368         } else if (error == 0) {
1369                 bvp = lvp;
1370         } else {
1371                 bvp = svp;
1372 
1373                 if (bvp->v_type != VBLK) {
1374                         error = ENOTBLK;
1375                         goto out;
1376                 }
1377 
1378                 if ((error = secpolicy_spec_open(cr, bvp, FREAD)) != 0)
1379                         goto out;
1380         }
1381 
1382         /*
1383          * Can we read from the device/file ?
1384          */
1385         if ((error = VOP_ACCESS(svp, VREAD, 0, cr, NULL)) != 0)
1386                 goto out;
1387 
1388         vap.va_mask = AT_MODE;          /* get protection mode */
1389         (void) VOP_GETATTR(bvp, &vap, 0, CRED(), NULL);
1390         *mode = vap.va_mode;
1391 
1392         dev = *pdev = bvp->v_rdev;
1393 
1394         error = EBUSY;
1395 
1396         /*
1397          * Ensure that this device isn't already mounted,
1398          * unless this is a REMOUNT request or we are told to suppress
1399          * mount checks.
1400          */
1401         if ((flags & MS_NOCHECK) == 0) {
1402                 if (vfs_devmounting(dev, vfsp))
1403                         goto out;
1404                 if (vfs_devismounted(dev) && !(flags & MS_REMOUNT))
1405                         goto out;
1406         }
1407 
1408         if (getmajor(*pdev) >= devcnt) {
1409                 error = ENXIO;
1410                 goto out;
1411         }
1412 
1413         error = 0;
1414 out:
1415         if (svp != NULL)
1416                 VN_RELE(svp);
1417         if (lvp != NULL)
1418                 VN_RELE(lvp);
1419         return (error);
1420 }
1421 
1422 static void
1423 hs_copylabel(struct hs_volume *hvp, unsigned char *label, int isjoliet)
1424 {
1425         char    lbuf[64];       /* hs_joliet_cp() creates 48 bytes at most */
1426 
1427         if (isjoliet) {
1428                 /*
1429                  * hs_joliet_cp() will output 16..48 bytes.
1430                  * We need to clear 'lbuf' to avoid junk chars past byte 15.
1431                  */
1432                 bzero(lbuf, sizeof (lbuf));
1433                 (void) hs_joliet_cp((char *)label, lbuf, 32);
1434                 label = (unsigned char *)lbuf;
1435         }
1436         /* cdrom volid is at most 32 bytes */
1437         bcopy(label, hvp->vol_id, 32);
1438         hvp->vol_id[31] = NULL;
1439 }
1440 
1441 /*
1442  * Mount root file system.
1443  * "why" is ROOT_INIT on initial call, ROOT_REMOUNT if called to
1444  * remount the root file system, and ROOT_UNMOUNT if called to
1445  * unmount the root (e.g., as part of a system shutdown).
1446  *
1447  * XXX - this may be partially machine-dependent; it, along with the VFS_SWAPVP
1448  * operation, goes along with auto-configuration.  A mechanism should be
1449  * provided by which machine-INdependent code in the kernel can say "get me the
1450  * right root file system" and "get me the right initial swap area", and have
1451  * that done in what may well be a machine-dependent fashion.
1452  * Unfortunately, it is also file-system-type dependent (NFS gets it via
1453  * bootparams calls, UFS gets it from various and sundry machine-dependent
1454  * mechanisms, as SPECFS does for swap).
1455  */
1456 static int
1457 hsfs_mountroot(struct vfs *vfsp, enum whymountroot why)
1458 {
1459         int error;
1460         struct hsfs *fsp;
1461         struct hs_volume *fvolp;
1462         static int hsfsrootdone = 0;
1463         dev_t rootdev;
1464         mode_t mode = 0;
1465 
1466         if (why == ROOT_INIT) {
1467                 if (hsfsrootdone++)
1468                         return (EBUSY);
1469                 rootdev = getrootdev();
1470                 if (rootdev == (dev_t)NODEV)
1471                         return (ENODEV);
1472                 vfsp->vfs_dev = rootdev;
1473                 vfsp->vfs_flag |= VFS_RDONLY;
1474         } else if (why == ROOT_REMOUNT) {
1475                 cmn_err(CE_NOTE, "hsfs_mountroot: ROOT_REMOUNT");
1476                 return (0);
1477         } else if (why == ROOT_UNMOUNT) {
1478                 return (0);
1479         }
1480         error = vfs_lock(vfsp);
1481         if (error) {
1482                 cmn_err(CE_NOTE, "hsfs_mountroot: couldn't get vfs_lock");
1483                 return (error);
1484         }
1485 
1486         error = hs_mountfs(vfsp, rootdev, "/", mode, 1, CRED(), 1);
1487         /*
1488          * XXX - assumes root device is not indirect, because we don't set
1489          * rootvp.  Is rootvp used for anything?  If so, make another arg
1490          * to mountfs.
1491          */
1492         if (error) {
1493                 vfs_unlock(vfsp);
1494                 if (rootvp) {
1495                         VN_RELE(rootvp);
1496                         rootvp = (struct vnode *)0;
1497                 }
1498                 return (error);
1499         }
1500         if (why == ROOT_INIT)
1501                 vfs_add((struct vnode *)0, vfsp,
1502                     (vfsp->vfs_flag & VFS_RDONLY) ? MS_RDONLY : 0);
1503         vfs_unlock(vfsp);
1504         fsp = VFS_TO_HSFS(vfsp);
1505         fvolp = &fsp->hsfs_vol;
1506 #ifdef HSFS_CLKSET
1507         if (fvolp->cre_date.tv_sec == 0) {
1508                 cmn_err(CE_NOTE, "hsfs_mountroot: cre_date.tv_sec == 0");
1509                 if (fvolp->mod_date.tv_sec == 0) {
1510                         cmn_err(CE_NOTE,
1511                             "hsfs_mountroot: mod_date.tv_sec == 0");
1512                         cmn_err(CE_NOTE, "hsfs_mountroot: clkset(-1L)");
1513                         clkset(-1L);
1514                 } else {
1515                         clkset(fvolp->mod_date.tv_sec);
1516                 }
1517         } else {
1518                 clkset(fvolp->mod_date.tv_sec);
1519         }
1520 #else   /* HSFS_CLKSET */
1521         clkset(-1L);
1522 #endif  /* HSFS_CLKSET */
1523         return (0);
1524 }
1525 
1526 /*
1527  * hs_findvoldesc()
1528  *
1529  * Return the sector where the volume descriptor lives.  This is
1530  * a fixed value for "normal" cd-rom's, but can change for
1531  * multisession cd's.
1532  *
1533  * desc_sec is the same for high-sierra and iso 9660 formats, why
1534  * there are two different #defines used in the code for this is
1535  * beyond me.  These are standards, cast in concrete, right?
1536  * To be general, however, this function supports passing in different
1537  * values.
1538  */
1539 static int
1540 hs_findvoldesc(dev_t rdev, int desc_sec)
1541 {
1542         int secno;
1543         int error;
1544         int rval;       /* ignored */
1545 
1546 #ifdef CDROMREADOFFSET
1547         /*
1548          * Issue the Read Offset ioctl directly to the
1549          * device. Ignore any errors and set starting
1550          * secno to the default, otherwise add the
1551          * VOLDESC sector number to the offset.
1552          */
1553         error = cdev_ioctl(rdev, CDROMREADOFFSET, (intptr_t)&secno,
1554             FNATIVE|FKIOCTL|FREAD, CRED(), &rval);
1555         if (error) {
1556                 secno = desc_sec;
1557         } else {
1558                 secno += desc_sec;
1559         }
1560 #else
1561         secno = desc_sec;
1562 #endif
1563 
1564         return (secno);
1565 }
--- EOF ---