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