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