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 */
24
25 /*
26 * VFS operations for High Sierra filesystem
27 */
28
29 #include <sys/types.h>
30 #include <sys/isa_defs.h>
31 #include <sys/t_lock.h>
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/sysmacros.h>
35 #include <sys/kmem.h>
36 #include <sys/signal.h>
37 #include <sys/user.h>
38 #include <sys/proc.h>
39 #include <sys/disp.h>
40 #include <sys/buf.h>
41 #include <sys/pathname.h>
42 #include <sys/vfs.h>
43 #include <sys/vfs_opreg.h>
44 #include <sys/vnode.h>
45 #include <sys/file.h>
46 #include <sys/uio.h>
47 #include <sys/conf.h>
48 #include <sys/policy.h>
49
50 #include <vm/page.h>
51
52 #include <sys/fs/snode.h>
53 #include <sys/fs/hsfs_spec.h>
54 #include <sys/fs/hsfs_isospec.h>
55 #include <sys/fs/hsfs_node.h>
56 #include <sys/fs/hsfs_impl.h>
57 #include <sys/fs/hsfs_susp.h>
58 #include <sys/fs/hsfs_rrip.h>
59
60 #include <sys/statvfs.h>
61 #include <sys/mount.h>
62 #include <sys/mntent.h>
63 #include <sys/swap.h>
64 #include <sys/errno.h>
65 #include <sys/debug.h>
66 #include "fs/fs_subr.h"
67 #include <sys/cmn_err.h>
68 #include <sys/bootconf.h>
69
70 #include <sys/sdt.h>
71
72 /*
73 * These are needed for the CDROMREADOFFSET Code
74 */
75 #include <sys/cdio.h>
76 #include <sys/sunddi.h>
77
78 #define HSFS_CLKSET
79
80 #include <sys/modctl.h>
81
82 /*
83 * Options for mount.
84 */
85 #define HOPT_GLOBAL MNTOPT_GLOBAL
86 #define HOPT_NOGLOBAL MNTOPT_NOGLOBAL
87 #define HOPT_MAPLCASE "maplcase"
88 #define HOPT_NOMAPLCASE "nomaplcase"
89 #define HOPT_NOTRAILDOT "notraildot"
90 #define HOPT_TRAILDOT "traildot"
91 #define HOPT_NRR "nrr"
92 #define HOPT_RR "rr"
93 #define HOPT_JOLIET "joliet"
94 #define HOPT_NOJOLIET "nojoliet"
95 #define HOPT_JOLIETLONG "jolietlong"
96 #define HOPT_VERS2 "vers2"
97 #define HOPT_NOVERS2 "novers2"
98 #define HOPT_RO MNTOPT_RO
99
100 static char *global_cancel[] = { HOPT_NOGLOBAL, NULL };
101 static char *noglobal_cancel[] = { HOPT_GLOBAL, NULL };
102 static char *mapl_cancel[] = { HOPT_NOMAPLCASE, NULL };
103 static char *nomapl_cancel[] = { HOPT_MAPLCASE, NULL };
104 static char *ro_cancel[] = { MNTOPT_RW, NULL };
105 static char *rr_cancel[] = { HOPT_NRR, NULL };
106 static char *nrr_cancel[] = { HOPT_RR, NULL };
107 static char *joliet_cancel[] = { HOPT_NOJOLIET, NULL };
108 static char *nojoliet_cancel[] = { HOPT_JOLIET, NULL };
109 static char *vers2_cancel[] = { HOPT_NOVERS2, NULL };
110 static char *novers2_cancel[] = { HOPT_VERS2, NULL };
111 static char *trail_cancel[] = { HOPT_NOTRAILDOT, NULL };
112 static char *notrail_cancel[] = { HOPT_TRAILDOT, NULL };
113
114 static mntopt_t hsfs_options[] = {
115 { HOPT_GLOBAL, global_cancel, NULL, 0, NULL },
116 { HOPT_NOGLOBAL, noglobal_cancel, NULL, MO_DEFAULT, NULL },
117 { HOPT_MAPLCASE, mapl_cancel, NULL, MO_DEFAULT, NULL },
118 { HOPT_NOMAPLCASE, nomapl_cancel, NULL, 0, NULL },
119 { HOPT_RO, ro_cancel, NULL, MO_DEFAULT, NULL },
120 { HOPT_RR, rr_cancel, NULL, MO_DEFAULT, NULL },
121 { HOPT_NRR, nrr_cancel, NULL, 0, NULL },
122 { HOPT_JOLIET, joliet_cancel, NULL, 0, NULL },
123 { HOPT_NOJOLIET, nojoliet_cancel, NULL, 0, NULL },
124 { HOPT_JOLIETLONG, NULL, NULL, 0, NULL },
125 { HOPT_VERS2, vers2_cancel, NULL, 0, NULL },
126 { HOPT_NOVERS2, novers2_cancel, NULL, 0, NULL },
127 { HOPT_TRAILDOT, trail_cancel, NULL, MO_DEFAULT, NULL },
128 { HOPT_NOTRAILDOT, notrail_cancel, NULL, 0, NULL },
129 { "sector", NULL, "0", MO_HASVALUE, NULL},
130 };
131
132 static mntopts_t hsfs_proto_opttbl = {
133 sizeof (hsfs_options) / sizeof (mntopt_t),
134 hsfs_options
135 };
136
137 /*
138 * Indicates whether to enable the I/O scheduling and readahead logic
139 * 1 - Enable, 0 - Do not Enable.
140 * Debugging purposes.
141 */
142 int do_schedio = 1;
143 static int hsfsfstype;
144 static int hsfsinit(int, char *);
145
146 static vfsdef_t vfw = {
147 VFSDEF_VERSION,
148 "hsfs",
149 hsfsinit,
150 /* We don't suppport remounting */
151 VSW_HASPROTO|VSW_STATS|VSW_CANLOFI|VSW_ZMOUNT,
152 &hsfs_proto_opttbl
153 };
154
155 static struct modlfs modlfs = {
156 &mod_fsops, "filesystem for HSFS", &vfw
157 };
158
159 static struct modlinkage modlinkage = {
160 MODREV_1, (void *)&modlfs, NULL
161 };
162
163 char _depends_on[] = "fs/specfs";
164
165 extern void hsched_init_caches(void);
166 extern void hsched_fini_caches(void);
167
168
169 int
_init(void)170 _init(void)
171 {
172 return (mod_install(&modlinkage));
173 }
174
175 int
_fini(void)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
_info(struct modinfo * modinfop)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
hsfsinit(int fstype,char * name)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
hsfs_mount(struct vfs * vfsp,struct vnode * mvp,struct mounta * uap,struct cred * cr)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
hsfs_unmount(struct vfs * vfsp,int flag,struct cred * cr)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
hsfs_root(struct vfs * vfsp,struct vnode ** vpp)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
hsfs_statvfs(struct vfs * vfsp,struct statvfs64 * sbp)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
hsfs_vget(struct vfs * vfsp,struct vnode ** vpp,struct fid * fidp)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
compute_cdrom_id(struct hsfs * fsp,vnode_t * devvp)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
hs_mountfs(struct vfs * vfsp,dev_t dev,char * path,mode_t mode,int mount_flags,struct cred * cr,int isroot)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
hs_getrootvp(struct vfs * vfsp,struct hsfs * fsp,size_t pathsize)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
hs_findhsvol(struct hsfs * fsp,struct vnode * vp,struct hs_volume * hvp)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
hs_parsehsvol(struct hsfs * fsp,uchar_t * volp,struct hs_volume * hvp)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
hs_findisovol(struct hsfs * fsp,struct vnode * vp,struct hs_volume * hvp,struct hs_volume * svp,struct hs_volume * jvp)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 &&
1161 (enum iso_voldesc_type) 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
hs_joliet_level(uchar_t * volp)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
hs_parseisovol(struct hsfs * fsp,uchar_t * volp,struct hs_volume * hvp)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
hs_getmdev(struct vfs * vfsp,char * fspec,int flags,dev_t * pdev,mode_t * mode,cred_t * cr)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
hs_copylabel(struct hs_volume * hvp,unsigned char * label,int isjoliet)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
hsfs_mountroot(struct vfs * vfsp,enum whymountroot why)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
hs_findvoldesc(dev_t rdev,int desc_sec)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 }
1566