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