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