Mercurial > illumos > illumos-gate
annotate usr/src/uts/common/fs/hsfs/hsfs_vfsops.c @ 1488:196daa2cf3db
PSARC/2006/034 fsstat
PSARC/2006/116 fsstat update
6335370 RFE: Need generic file system observability (e.g., fsstat)
| author | rsb |
|---|---|
| date | Sat, 25 Feb 2006 01:33:06 -0800 |
| parents | 1aef26bcfa0e |
| children | 8188e64c9073 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2 * CDDL HEADER START | |
| 3 * | |
| 4 * The contents of this file are subject to the terms of the | |
|
1025
1aef26bcfa0e
6300064 hsfs_spec.h has developed a southern drawl.
frankho
parents:
494
diff
changeset
|
5 * Common Development and Distribution License (the "License"). |
|
1aef26bcfa0e
6300064 hsfs_spec.h has developed a southern drawl.
frankho
parents:
494
diff
changeset
|
6 * You may not use this file except in compliance with the License. |
| 0 | 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 /* | |
| 1488 | 22 * Copyright 2006 Sun Microsystems, Inc. All rights reserved. |
| 0 | 23 * Use is subject to license terms. |
| 24 */ | |
| 25 | |
| 26 #pragma ident "%Z%%M% %I% %E% SMI" | |
| 27 | |
| 28 /* | |
| 29 * VFS operations for High Sierra filesystem | |
| 30 */ | |
| 31 | |
| 32 #include <sys/types.h> | |
| 33 #include <sys/isa_defs.h> | |
| 34 #include <sys/t_lock.h> | |
| 35 #include <sys/param.h> | |
| 36 #include <sys/systm.h> | |
| 37 #include <sys/sysmacros.h> | |
| 38 #include <sys/kmem.h> | |
| 39 #include <sys/signal.h> | |
| 40 #include <sys/user.h> | |
| 41 #include <sys/proc.h> | |
| 42 #include <sys/disp.h> | |
| 43 #include <sys/buf.h> | |
| 44 #include <sys/pathname.h> | |
| 45 #include <sys/vfs.h> | |
| 46 #include <sys/vnode.h> | |
| 47 #include <sys/file.h> | |
| 48 #include <sys/uio.h> | |
| 49 #include <sys/conf.h> | |
| 50 #include <sys/policy.h> | |
| 51 | |
| 52 #include <vm/page.h> | |
| 53 | |
| 54 #include <sys/fs/snode.h> | |
| 55 #include <sys/fs/hsfs_spec.h> | |
| 56 #include <sys/fs/hsfs_isospec.h> | |
| 57 #include <sys/fs/hsfs_node.h> | |
| 58 #include <sys/fs/hsfs_impl.h> | |
| 59 #include <sys/fs/hsfs_susp.h> | |
| 60 #include <sys/fs/hsfs_rrip.h> | |
| 61 | |
| 62 #include <sys/statvfs.h> | |
| 63 #include <sys/mount.h> | |
| 64 #include <sys/mntent.h> | |
| 65 #include <sys/swap.h> | |
| 66 #include <sys/errno.h> | |
| 67 #include <sys/debug.h> | |
| 68 #include "fs/fs_subr.h" | |
| 69 #include <sys/cmn_err.h> | |
| 70 #include <sys/bootconf.h> | |
| 71 | |
| 72 /* | |
| 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_RO MNTOPT_RO | |
| 94 | |
| 95 static char *global_cancel[] = { HOPT_NOGLOBAL, NULL }; | |
| 96 static char *noglobal_cancel[] = { HOPT_GLOBAL, NULL }; | |
| 97 static char *mapl_cancel[] = { HOPT_NOMAPLCASE, NULL }; | |
| 98 static char *nomapl_cancel[] = { HOPT_MAPLCASE, NULL }; | |
| 99 static char *ro_cancel[] = { MNTOPT_RW, NULL }; | |
| 100 static char *rr_cancel[] = { HOPT_NRR, NULL }; | |
| 101 static char *nrr_cancel[] = { HOPT_RR, NULL }; | |
| 102 static char *trail_cancel[] = { HOPT_NOTRAILDOT, NULL }; | |
| 103 static char *notrail_cancel[] = { HOPT_TRAILDOT, NULL }; | |
| 104 | |
| 105 static mntopt_t hsfs_options[] = { | |
| 106 { HOPT_GLOBAL, global_cancel, NULL, 0, NULL }, | |
| 107 { HOPT_NOGLOBAL, noglobal_cancel, NULL, MO_DEFAULT, NULL }, | |
| 108 { HOPT_MAPLCASE, mapl_cancel, NULL, MO_DEFAULT, NULL }, | |
| 109 { HOPT_NOMAPLCASE, nomapl_cancel, NULL, 0, NULL }, | |
| 110 { HOPT_RO, ro_cancel, NULL, MO_DEFAULT, NULL }, | |
| 111 { HOPT_RR, rr_cancel, NULL, MO_DEFAULT, NULL }, | |
| 112 { HOPT_NRR, nrr_cancel, NULL, 0, NULL }, | |
| 113 { HOPT_TRAILDOT, trail_cancel, NULL, MO_DEFAULT, NULL }, | |
| 114 { HOPT_NOTRAILDOT, notrail_cancel, NULL, 0, NULL }, | |
| 115 }; | |
| 116 | |
| 117 static mntopts_t hsfs_proto_opttbl = { | |
| 118 sizeof (hsfs_options) / sizeof (mntopt_t), | |
| 119 hsfs_options | |
| 120 }; | |
| 121 | |
| 122 static int hsfsinit(int, char *); | |
| 123 | |
| 124 static vfsdef_t vfw = { | |
| 125 VFSDEF_VERSION, | |
| 126 "hsfs", | |
| 127 hsfsinit, | |
| 1488 | 128 VSW_HASPROTO|VSW_STATS, /* We don't suppport remounting */ |
| 0 | 129 &hsfs_proto_opttbl |
| 130 }; | |
| 131 | |
| 132 static struct modlfs modlfs = { | |
| 133 &mod_fsops, "filesystem for HSFS", &vfw | |
| 134 }; | |
| 135 | |
| 136 static struct modlinkage modlinkage = { | |
| 137 MODREV_1, (void *)&modlfs, NULL | |
| 138 }; | |
| 139 | |
| 140 char _depends_on[] = "fs/specfs"; | |
| 141 | |
| 142 int | |
| 143 _init() | |
| 144 { | |
| 145 return (mod_install(&modlinkage)); | |
| 146 } | |
| 147 | |
| 148 int | |
| 149 _fini() | |
| 150 { | |
| 151 return (EBUSY); | |
| 152 } | |
| 153 | |
| 154 int | |
| 155 _info(struct modinfo *modinfop) | |
| 156 { | |
| 157 return (mod_info(&modlinkage, modinfop)); | |
| 158 } | |
| 159 | |
| 160 #define BDEVFLAG(dev) ((devopsp[getmajor(dev)])->devo_cb_ops->cb_flag) | |
| 161 | |
| 162 kmutex_t hs_mounttab_lock; | |
| 163 struct hsfs *hs_mounttab = NULL; | |
| 164 | |
| 165 /* default mode, uid, gid */ | |
| 166 mode_t hsfs_default_mode = 0555; | |
| 167 uid_t hsfs_default_uid = 0; | |
| 168 gid_t hsfs_default_gid = 3; | |
| 169 | |
| 170 static int hsfs_mount(struct vfs *vfsp, struct vnode *mvp, | |
| 171 struct mounta *uap, struct cred *cr); | |
| 172 static int hsfs_unmount(struct vfs *vfsp, int, struct cred *cr); | |
| 173 static int hsfs_root(struct vfs *vfsp, struct vnode **vpp); | |
| 174 static int hsfs_statvfs(struct vfs *vfsp, struct statvfs64 *sbp); | |
| 175 static int hsfs_vget(struct vfs *vfsp, struct vnode **vpp, struct fid *fidp); | |
| 176 static int hsfs_mountroot(struct vfs *, enum whymountroot); | |
| 177 | |
| 178 static int hs_mountfs(struct vfs *vfsp, dev_t dev, char *path, | |
| 179 mode_t mode, int flags, struct cred *cr, int isroot); | |
| 180 static int hs_findhsvol(struct hsfs *fsp, struct vnode *vp, | |
| 181 struct hs_volume *hvp); | |
| 182 static int hs_parsehsvol(struct hsfs *fsp, uchar_t *volp, | |
| 183 struct hs_volume *hvp); | |
| 184 static int hs_findisovol(struct hsfs *fsp, struct vnode *vp, | |
| 185 struct hs_volume *hvp); | |
| 186 static int hs_parseisovol(struct hsfs *fsp, uchar_t *volp, | |
| 187 struct hs_volume *hvp); | |
| 188 static void hs_copylabel(struct hs_volume *, unsigned char *); | |
| 189 static int hs_getmdev(struct vfs *, char *fspec, int flags, dev_t *pdev, | |
| 190 mode_t *mode, cred_t *cr); | |
| 191 static int hs_findvoldesc(dev_t rdev, int desc_sec); | |
| 192 | |
| 193 static int hsfsfstype; | |
| 194 | |
| 195 static int | |
| 196 hsfsinit(int fstype, char *name) | |
| 197 { | |
| 198 static const fs_operation_def_t hsfs_vfsops_template[] = { | |
| 199 VFSNAME_MOUNT, hsfs_mount, | |
| 200 VFSNAME_UNMOUNT, hsfs_unmount, | |
| 201 VFSNAME_ROOT, hsfs_root, | |
| 202 VFSNAME_STATVFS, hsfs_statvfs, | |
| 203 VFSNAME_VGET, hsfs_vget, | |
| 204 VFSNAME_MOUNTROOT, hsfs_mountroot, | |
| 205 NULL, NULL | |
| 206 }; | |
| 207 int error; | |
| 208 | |
| 209 error = vfs_setfsops(fstype, hsfs_vfsops_template, NULL); | |
| 210 if (error != 0) { | |
| 211 cmn_err(CE_WARN, "hsfsinit: bad vfs ops template"); | |
| 212 return (error); | |
| 213 } | |
| 214 | |
| 215 error = vn_make_ops(name, hsfs_vnodeops_template, &hsfs_vnodeops); | |
| 216 if (error != 0) { | |
| 217 (void) vfs_freevfsops_by_type(fstype); | |
| 218 cmn_err(CE_WARN, "hsfsinit: bad vnode ops template"); | |
| 219 return (error); | |
| 220 } | |
| 221 | |
| 222 hsfsfstype = fstype; | |
| 223 mutex_init(&hs_mounttab_lock, NULL, MUTEX_DEFAULT, NULL); | |
| 224 hs_init_hsnode_cache(); | |
| 225 return (0); | |
| 226 } | |
| 227 | |
| 228 /*ARGSUSED*/ | |
| 229 static int | |
| 230 hsfs_mount(struct vfs *vfsp, struct vnode *mvp, | |
| 231 struct mounta *uap, struct cred *cr) | |
| 232 { | |
| 233 int vnode_busy; | |
| 234 dev_t dev; | |
| 235 struct pathname dpn; | |
| 236 int error; | |
| 237 mode_t mode; | |
| 238 int flags; /* this will hold the mount specific data */ | |
| 239 | |
| 240 if ((error = secpolicy_fs_mount(cr, mvp, vfsp)) != 0) | |
| 241 return (error); | |
| 242 | |
| 243 if (mvp->v_type != VDIR) | |
| 244 return (ENOTDIR); | |
| 245 | |
| 246 /* mount option must be read only, else mount will be rejected */ | |
| 247 if (!(uap->flags & MS_RDONLY)) | |
| 248 return (EROFS); | |
| 249 | |
| 250 /* | |
| 251 * We already told the framework that we don't support remounting. | |
| 252 */ | |
| 253 ASSERT(!(uap->flags & MS_REMOUNT)); | |
| 254 | |
| 255 mutex_enter(&mvp->v_lock); | |
| 256 vnode_busy = (mvp->v_count != 1) || (mvp->v_flag & VROOT); | |
| 257 mutex_exit(&mvp->v_lock); | |
| 258 | |
| 259 if ((uap->flags & MS_OVERLAY) == 0 && vnode_busy) { | |
| 260 return (EBUSY); | |
| 261 } | |
| 262 | |
| 263 /* | |
| 264 * Check for the options that actually affect things | |
| 265 * at our level. | |
| 266 */ | |
| 267 flags = 0; | |
| 268 if (vfs_optionisset(vfsp, HOPT_NOMAPLCASE, NULL)) | |
| 269 flags |= HSFSMNT_NOMAPLCASE; | |
| 270 if (vfs_optionisset(vfsp, HOPT_NOTRAILDOT, NULL)) | |
| 271 flags |= HSFSMNT_NOTRAILDOT; | |
| 272 if (vfs_optionisset(vfsp, HOPT_NRR, NULL)) | |
| 273 flags |= HSFSMNT_NORRIP; | |
| 274 | |
| 275 error = pn_get(uap->dir, (uap->flags & MS_SYSSPACE) ? | |
| 276 UIO_SYSSPACE : UIO_USERSPACE, &dpn); | |
| 277 if (error) | |
| 278 return (error); | |
| 279 | |
| 280 if ((error = hs_getmdev(vfsp, uap->spec, uap->flags, &dev, | |
| 281 &mode, cr)) != 0) { | |
| 282 pn_free(&dpn); | |
| 283 return (error); | |
| 284 } | |
| 285 | |
| 286 /* | |
| 287 * If the device is a tape, return error | |
| 288 */ | |
| 289 if ((BDEVFLAG(dev) & D_TAPE) == D_TAPE) { | |
| 290 pn_free(&dpn); | |
| 291 return (ENOTBLK); | |
| 292 } | |
| 293 | |
| 294 /* | |
| 295 * Mount the filesystem. | |
| 296 */ | |
| 297 error = hs_mountfs(vfsp, dev, dpn.pn_path, mode, flags, cr, 0); | |
| 298 pn_free(&dpn); | |
| 299 return (error); | |
| 300 } | |
| 301 | |
| 302 /*ARGSUSED*/ | |
| 303 static int | |
| 304 hsfs_unmount( | |
| 305 struct vfs *vfsp, | |
| 306 int flag, | |
| 307 struct cred *cr) | |
| 308 { | |
| 309 struct hsfs **tspp; | |
| 310 struct hsfs *fsp; | |
| 311 | |
| 312 if (secpolicy_fs_unmount(cr, vfsp) != 0) | |
| 313 return (EPERM); | |
| 314 | |
| 315 /* | |
| 316 * forced unmount is not supported by this file system | |
| 317 * and thus, ENOTSUP is being returned. | |
| 318 */ | |
| 319 if (flag & MS_FORCE) | |
| 320 return (ENOTSUP); | |
| 321 | |
| 322 fsp = VFS_TO_HSFS(vfsp); | |
| 323 | |
| 324 if (fsp->hsfs_rootvp->v_count != 1) | |
| 325 return (EBUSY); | |
| 326 | |
| 327 /* destroy all old pages and hsnodes for this vfs */ | |
| 328 if (hs_synchash(vfsp)) | |
| 329 return (EBUSY); | |
| 330 | |
| 331 mutex_enter(&hs_mounttab_lock); | |
| 332 for (tspp = &hs_mounttab; *tspp != NULL; tspp = &(*tspp)->hsfs_next) { | |
| 333 if (*tspp == fsp) | |
| 334 break; | |
| 335 } | |
| 336 if (*tspp == NULL) { | |
| 337 mutex_exit(&hs_mounttab_lock); | |
| 338 panic("hsfs_unmount: vfs not mounted?"); | |
| 339 /*NOTREACHED*/ | |
| 340 } | |
| 341 | |
| 342 *tspp = fsp->hsfs_next; | |
| 343 | |
| 344 mutex_exit(&hs_mounttab_lock); | |
| 345 | |
| 346 (void) VOP_CLOSE(fsp->hsfs_devvp, FREAD, 1, (offset_t)0, cr); | |
| 347 VN_RELE(fsp->hsfs_devvp); | |
| 348 /* free path table space */ | |
| 349 if (fsp->hsfs_ptbl != NULL) | |
| 350 kmem_free(fsp->hsfs_ptbl, | |
| 351 (size_t)fsp->hsfs_vol.ptbl_len); | |
| 352 /* free path table index table */ | |
| 353 if (fsp->hsfs_ptbl_idx != NULL) | |
| 354 kmem_free(fsp->hsfs_ptbl_idx, (size_t) | |
| 355 (fsp->hsfs_ptbl_idx_size * sizeof (struct ptable_idx))); | |
| 356 | |
| 357 /* free "mounted on" pathame */ | |
| 358 if (fsp->hsfs_fsmnt != NULL) | |
| 359 kmem_free(fsp->hsfs_fsmnt, strlen(fsp->hsfs_fsmnt) + 1); | |
| 360 | |
| 361 mutex_destroy(&fsp->hsfs_free_lock); | |
| 362 rw_destroy(&fsp->hsfs_hash_lock); | |
| 363 | |
| 364 kmem_free(fsp, sizeof (*fsp)); | |
| 365 return (0); | |
| 366 } | |
| 367 | |
| 368 /*ARGSUSED*/ | |
| 369 static int | |
| 370 hsfs_root(struct vfs *vfsp, struct vnode **vpp) | |
| 371 { | |
| 372 *vpp = (VFS_TO_HSFS(vfsp))->hsfs_rootvp; | |
| 373 VN_HOLD(*vpp); | |
| 374 return (0); | |
| 375 } | |
| 376 | |
| 377 /*ARGSUSED*/ | |
| 378 static int | |
| 379 hsfs_statvfs(struct vfs *vfsp, struct statvfs64 *sbp) | |
| 380 { | |
| 381 struct hsfs *fsp; | |
| 382 dev32_t d32; | |
| 383 | |
| 384 fsp = VFS_TO_HSFS(vfsp); | |
| 385 if (fsp->hsfs_magic != HSFS_MAGIC) | |
| 386 return (EINVAL); | |
| 387 bzero(sbp, sizeof (*sbp)); | |
| 388 sbp->f_bsize = vfsp->vfs_bsize; | |
| 389 sbp->f_frsize = sbp->f_bsize; /* no fragment, same as block size */ | |
| 390 sbp->f_blocks = (fsblkcnt64_t)fsp->hsfs_vol.vol_size; | |
| 391 | |
| 392 sbp->f_bfree = (fsblkcnt64_t)0; | |
| 393 sbp->f_bavail = (fsblkcnt64_t)0; | |
| 394 sbp->f_files = (fsfilcnt64_t)-1; | |
| 395 sbp->f_ffree = (fsfilcnt64_t)0; | |
| 396 sbp->f_favail = (fsfilcnt64_t)0; | |
| 397 (void) cmpldev(&d32, vfsp->vfs_dev); | |
| 398 sbp->f_fsid = d32; | |
| 399 (void) strcpy(sbp->f_basetype, vfssw[vfsp->vfs_fstype].vsw_name); | |
| 400 sbp->f_flag = vf_to_stf(vfsp->vfs_flag); | |
| 401 sbp->f_namemax = fsp->hsfs_namemax; | |
| 402 (void) strcpy(sbp->f_fstr, fsp->hsfs_vol.vol_id); | |
| 403 | |
| 404 return (0); | |
| 405 } | |
| 406 | |
| 407 /* | |
| 408 * Previously nodeid was declared as uint32_t. This has been changed | |
| 409 * to conform better with the ISO9660 standard. The standard states that | |
| 410 * a LBN can be a 32 bit number, as the MAKE_NODEID macro shifts this | |
| 411 * LBN 11 places left (LBN_TO_BYTE) and then shifts the result 5 right | |
| 412 * (divide by 32) we are left with the potential of an overflow if | |
| 413 * confined to a 32 bit value. | |
| 414 */ | |
| 415 | |
| 416 static int | |
| 417 hsfs_vget(struct vfs *vfsp, struct vnode **vpp, struct fid *fidp) | |
| 418 { | |
| 419 struct hsfid *fid; | |
| 420 struct hsfs *fsp; | |
| 421 ino64_t nodeid; | |
| 422 int error; | |
| 423 | |
| 424 fsp = (struct hsfs *)VFS_TO_HSFS(vfsp); | |
| 425 fid = (struct hsfid *)fidp; | |
| 426 | |
| 427 /* | |
| 428 * Look for vnode on hashlist. | |
| 429 * If found, it's now active and the refcnt was incremented. | |
| 430 */ | |
| 431 | |
| 432 rw_enter(&fsp->hsfs_hash_lock, RW_READER); | |
| 433 | |
| 434 nodeid = (ino64_t)MAKE_NODEID(fid->hf_dir_lbn, fid->hf_dir_off, vfsp); | |
| 435 | |
| 436 if ((*vpp = hs_findhash(nodeid, vfsp)) == NULL) { | |
| 437 /* | |
| 438 * Not in cache, so we need to remake it. | |
| 439 * hs_remakenode() will read the directory entry | |
| 440 * and then check again to see if anyone else has | |
| 441 * put it in the cache. | |
| 442 */ | |
| 443 rw_exit(&fsp->hsfs_hash_lock); | |
| 444 error = hs_remakenode(fid->hf_dir_lbn, (uint_t)fid->hf_dir_off, | |
| 445 vfsp, vpp); | |
| 446 return (error); | |
| 447 } | |
| 448 rw_exit(&fsp->hsfs_hash_lock); | |
| 449 return (0); | |
| 450 } | |
| 451 | |
| 452 | |
| 453 #define CHECKSUM_SIZE (64 * 1024) | |
| 454 | |
| 455 /* | |
| 456 * Compute a CD-ROM fsid by checksumming the first 64K of data on the CD | |
| 457 * We use the 'fsp' argument to determine the location of the root | |
| 458 * directory entry, and we start reading from there. | |
| 459 */ | |
| 460 static int | |
| 461 compute_cdrom_id(struct hsfs *fsp, vnode_t *devvp) | |
| 462 { | |
| 463 uint_t secno; | |
| 464 struct hs_volume *hsvp = &fsp->hsfs_vol; | |
| 465 struct buf *bp; | |
| 466 int error; | |
| 467 int fsid; | |
| 468 | |
| 469 secno = hsvp->root_dir.ext_lbn >> hsvp->lbn_secshift; | |
|
494
e082e44c7fce
6244328 hsfs not resistant against malformed ISO9660 filesystems, crashes/hangs
frankho
parents:
0
diff
changeset
|
470 bp = bread(devvp->v_rdev, secno * 4, CHECKSUM_SIZE); |
| 0 | 471 error = geterror(bp); |
|
494
e082e44c7fce
6244328 hsfs not resistant against malformed ISO9660 filesystems, crashes/hangs
frankho
parents:
0
diff
changeset
|
472 |
|
e082e44c7fce
6244328 hsfs not resistant against malformed ISO9660 filesystems, crashes/hangs
frankho
parents:
0
diff
changeset
|
473 /* |
|
e082e44c7fce
6244328 hsfs not resistant against malformed ISO9660 filesystems, crashes/hangs
frankho
parents:
0
diff
changeset
|
474 * An error on read or a partial read means we asked |
|
e082e44c7fce
6244328 hsfs not resistant against malformed ISO9660 filesystems, crashes/hangs
frankho
parents:
0
diff
changeset
|
475 * for a nonexistant/corrupted piece of the device |
|
e082e44c7fce
6244328 hsfs not resistant against malformed ISO9660 filesystems, crashes/hangs
frankho
parents:
0
diff
changeset
|
476 * (including past-the-end of the media). Don't |
|
e082e44c7fce
6244328 hsfs not resistant against malformed ISO9660 filesystems, crashes/hangs
frankho
parents:
0
diff
changeset
|
477 * try to use the checksumming method then. |
|
e082e44c7fce
6244328 hsfs not resistant against malformed ISO9660 filesystems, crashes/hangs
frankho
parents:
0
diff
changeset
|
478 */ |
|
e082e44c7fce
6244328 hsfs not resistant against malformed ISO9660 filesystems, crashes/hangs
frankho
parents:
0
diff
changeset
|
479 if (!error && bp->b_bcount == CHECKSUM_SIZE) { |
| 0 | 480 int *ibuf = (int *)bp->b_un.b_addr; |
| 481 int i; | |
| 482 | |
| 483 fsid = 0; | |
| 484 | |
|
494
e082e44c7fce
6244328 hsfs not resistant against malformed ISO9660 filesystems, crashes/hangs
frankho
parents:
0
diff
changeset
|
485 for (i = 0; i < CHECKSUM_SIZE / sizeof (int); i++) |
| 0 | 486 fsid ^= ibuf[ i ]; |
|
494
e082e44c7fce
6244328 hsfs not resistant against malformed ISO9660 filesystems, crashes/hangs
frankho
parents:
0
diff
changeset
|
487 } else { |
|
e082e44c7fce
6244328 hsfs not resistant against malformed ISO9660 filesystems, crashes/hangs
frankho
parents:
0
diff
changeset
|
488 /* |
|
e082e44c7fce
6244328 hsfs not resistant against malformed ISO9660 filesystems, crashes/hangs
frankho
parents:
0
diff
changeset
|
489 * Fallback - use creation date |
|
e082e44c7fce
6244328 hsfs not resistant against malformed ISO9660 filesystems, crashes/hangs
frankho
parents:
0
diff
changeset
|
490 */ |
| 0 | 491 fsid = hsvp->cre_date.tv_sec; |
|
494
e082e44c7fce
6244328 hsfs not resistant against malformed ISO9660 filesystems, crashes/hangs
frankho
parents:
0
diff
changeset
|
492 } |
| 0 | 493 |
| 494 brelse(bp); | |
| 495 | |
| 496 return (fsid); | |
| 497 } | |
| 498 | |
| 499 | |
| 500 /*ARGSUSED*/ | |
| 501 static int | |
| 502 hs_mountfs( | |
| 503 struct vfs *vfsp, | |
| 504 dev_t dev, | |
| 505 char *path, | |
| 506 mode_t mode, | |
| 507 int mount_flags, | |
| 508 struct cred *cr, | |
| 509 int isroot) | |
| 510 { | |
| 511 struct vnode *devvp; | |
| 512 struct hsfs *tsp; | |
| 513 struct hsfs *fsp = NULL; | |
| 514 struct vattr vap; | |
| 515 struct hsnode *hp; | |
| 516 int error; | |
| 517 struct timeval tv; | |
| 518 int fsid; | |
| 519 int use_rrip = (mount_flags & HSFSMNT_NORRIP) == 0; | |
| 520 | |
| 521 /* | |
| 522 * Open the device | |
| 523 */ | |
| 524 devvp = makespecvp(dev, VBLK); | |
| 525 ASSERT(devvp != 0); | |
| 526 | |
| 527 /* | |
| 528 * Open the target device (file) for read only. | |
| 529 */ | |
| 530 if (error = VOP_OPEN(&devvp, FREAD, cr)) { | |
| 531 VN_RELE(devvp); | |
| 532 return (error); | |
| 533 } | |
| 534 | |
| 535 /* | |
| 536 * Refuse to go any further if this | |
| 537 * device is being used for swapping | |
| 538 */ | |
| 539 if (IS_SWAPVP(common_specvp(devvp))) { | |
| 540 error = EBUSY; | |
| 541 goto cleanup; | |
| 542 } | |
| 543 | |
| 544 vap.va_mask = AT_SIZE; | |
| 545 if ((error = VOP_GETATTR(devvp, &vap, ATTR_COMM, cr)) != 0) { | |
| 546 cmn_err(CE_NOTE, "Cannot get attributes of the CD-ROM driver"); | |
| 547 goto cleanup; | |
| 548 } | |
| 549 | |
| 550 /* | |
| 551 * Make sure we have a nonzero size partition. | |
| 552 * The current version of the SD driver will *not* fail the open | |
| 553 * of such a partition so we have to check for it here. | |
| 554 */ | |
| 555 if (vap.va_size == 0) { | |
| 556 error = ENXIO; | |
| 557 goto cleanup; | |
| 558 } | |
| 559 | |
| 560 /* | |
| 561 * Init a new hsfs structure. | |
| 562 */ | |
| 563 fsp = kmem_zalloc(sizeof (*fsp), KM_SLEEP); | |
| 564 | |
| 565 /* hardwire perms, uid, gid */ | |
| 566 fsp->hsfs_vol.vol_uid = hsfs_default_uid; | |
| 567 fsp->hsfs_vol.vol_gid = hsfs_default_gid; | |
| 568 fsp->hsfs_vol.vol_prot = hsfs_default_mode; | |
| 569 | |
| 570 /* | |
| 571 * Look for a Standard File Structure Volume Descriptor, | |
| 572 * of which there must be at least one. | |
| 573 * If found, check for volume size consistency. | |
| 574 */ | |
|
1025
1aef26bcfa0e
6300064 hsfs_spec.h has developed a southern drawl.
frankho
parents:
494
diff
changeset
|
575 error = hs_findisovol(fsp, devvp, &fsp->hsfs_vol); |
|
1aef26bcfa0e
6300064 hsfs_spec.h has developed a southern drawl.
frankho
parents:
494
diff
changeset
|
576 if (error == EINVAL) /* no iso 9660 - try high sierra ... */ |
|
1aef26bcfa0e
6300064 hsfs_spec.h has developed a southern drawl.
frankho
parents:
494
diff
changeset
|
577 error = hs_findhsvol(fsp, devvp, &fsp->hsfs_vol); |
| 0 | 578 |
| 579 if (error) | |
| 580 goto cleanup; | |
| 581 | |
| 582 /* | |
| 583 * Generate a file system ID from the CD-ROM, | |
| 584 * and check it for uniqueness. | |
| 585 * | |
| 586 * What we are aiming for is some chance of integrity | |
| 587 * across disk change. That is, if a client has an fhandle, | |
| 588 * it will be valid as long as the same disk is mounted. | |
| 589 */ | |
| 590 fsid = compute_cdrom_id(fsp, devvp); | |
| 591 | |
| 592 mutex_enter(&hs_mounttab_lock); | |
| 593 | |
| 594 if (fsid == 0 || fsid == -1) { | |
| 595 uniqtime(&tv); | |
| 596 fsid = tv.tv_sec; | |
| 597 } else /* make sure that the fsid is unique */ | |
| 598 for (tsp = hs_mounttab; tsp != NULL; tsp = tsp->hsfs_next) { | |
| 599 if (fsid == tsp->hsfs_vfs->vfs_fsid.val[0]) { | |
| 600 uniqtime(&tv); | |
| 601 fsid = tv.tv_sec; | |
| 602 break; | |
| 603 } | |
| 604 } | |
| 605 | |
| 606 fsp->hsfs_next = hs_mounttab; | |
| 607 hs_mounttab = fsp; | |
| 608 | |
| 609 fsp->hsfs_devvp = devvp; | |
| 610 fsp->hsfs_vfs = vfsp; | |
| 611 fsp->hsfs_fsmnt = kmem_alloc(strlen(path) + 1, KM_SLEEP); | |
| 612 (void) strcpy(fsp->hsfs_fsmnt, path); | |
| 613 | |
| 614 mutex_init(&fsp->hsfs_free_lock, NULL, MUTEX_DEFAULT, NULL); | |
| 615 rw_init(&fsp->hsfs_hash_lock, NULL, RW_DEFAULT, NULL); | |
| 616 | |
| 617 vfsp->vfs_data = (caddr_t)fsp; | |
| 618 vfsp->vfs_dev = dev; | |
| 619 vfsp->vfs_fstype = hsfsfstype; | |
| 620 vfsp->vfs_bsize = fsp->hsfs_vol.lbn_size; /* %% */ | |
| 621 vfsp->vfs_fsid.val[0] = fsid; | |
| 622 vfsp->vfs_fsid.val[1] = hsfsfstype; | |
| 623 | |
| 624 /* | |
| 625 * If the root directory does not appear to be | |
| 626 * valid, use what it points to as "." instead. | |
| 627 * Some Defense Mapping Agency disks are non-conformant | |
| 628 * in this way. | |
| 629 */ | |
| 630 if (!hsfs_valid_dir(&fsp->hsfs_vol.root_dir)) { | |
| 631 hs_log_bogus_disk_warning(fsp, HSFS_ERR_BAD_ROOT_DIR, 0); | |
| 632 if (hs_remakenode(fsp->hsfs_vol.root_dir.ext_lbn, | |
| 633 (uint_t)0, vfsp, &fsp->hsfs_rootvp)) { | |
| 634 error = EINVAL; | |
|
1025
1aef26bcfa0e
6300064 hsfs_spec.h has developed a southern drawl.
frankho
parents:
494
diff
changeset
|
635 hs_mounttab = hs_mounttab->hsfs_next; |
|
1aef26bcfa0e
6300064 hsfs_spec.h has developed a southern drawl.
frankho
parents:
494
diff
changeset
|
636 mutex_destroy(&fsp->hsfs_free_lock); |
|
1aef26bcfa0e
6300064 hsfs_spec.h has developed a southern drawl.
frankho
parents:
494
diff
changeset
|
637 rw_destroy(&fsp->hsfs_hash_lock); |
|
1aef26bcfa0e
6300064 hsfs_spec.h has developed a southern drawl.
frankho
parents:
494
diff
changeset
|
638 kmem_free(fsp->hsfs_fsmnt, strlen(path) + 1); |
|
494
e082e44c7fce
6244328 hsfs not resistant against malformed ISO9660 filesystems, crashes/hangs
frankho
parents:
0
diff
changeset
|
639 mutex_exit(&hs_mounttab_lock); |
| 0 | 640 goto cleanup; |
| 641 } | |
| 642 } else { | |
| 643 fsp->hsfs_rootvp = hs_makenode(&fsp->hsfs_vol.root_dir, | |
| 644 fsp->hsfs_vol.root_dir.ext_lbn, 0, vfsp); | |
| 645 } | |
| 646 | |
| 647 /* mark vnode as VROOT */ | |
| 648 fsp->hsfs_rootvp->v_flag |= VROOT; | |
| 649 | |
| 650 /* Here we take care of some special case stuff for mountroot */ | |
| 651 if (isroot) { | |
| 652 fsp->hsfs_rootvp->v_rdev = devvp->v_rdev; | |
| 653 rootvp = fsp->hsfs_rootvp; | |
| 654 } | |
| 655 | |
| 656 /* XXX - ignore the path table for now */ | |
| 657 fsp->hsfs_ptbl = NULL; | |
| 658 hp = VTOH(fsp->hsfs_rootvp); | |
| 659 hp->hs_ptbl_idx = NULL; | |
| 660 | |
| 661 if (use_rrip) | |
| 662 hs_check_root_dirent(fsp->hsfs_rootvp, &(hp->hs_dirent)); | |
| 663 | |
| 664 fsp->hsfs_namemax = IS_RRIP_IMPLEMENTED(fsp) | |
| 665 ? RRIP_FILE_NAMELEN | |
| 666 : ISO_FILE_NAMELEN; | |
| 667 /* | |
| 668 * if RRIP, don't copy NOMAPLCASE or NOTRAILDOT to hsfs_flags | |
| 669 */ | |
| 670 if (IS_RRIP_IMPLEMENTED(fsp)) | |
| 671 mount_flags &= ~(HSFSMNT_NOMAPLCASE | HSFSMNT_NOTRAILDOT); | |
| 672 | |
| 673 fsp->hsfs_flags = mount_flags; | |
| 674 | |
| 675 /* set the magic word */ | |
| 676 fsp->hsfs_magic = HSFS_MAGIC; | |
| 677 mutex_exit(&hs_mounttab_lock); | |
| 678 | |
| 679 return (0); | |
| 680 | |
| 681 cleanup: | |
| 682 (void) VOP_CLOSE(devvp, FREAD, 1, (offset_t)0, cr); | |
| 683 VN_RELE(devvp); | |
| 684 if (fsp) | |
| 685 kmem_free(fsp, sizeof (*fsp)); | |
| 686 return (error); | |
| 687 } | |
| 688 | |
| 689 /* | |
| 690 * hs_findhsvol() | |
| 691 * | |
| 692 * Locate the Standard File Structure Volume Descriptor and | |
| 693 * parse it into an hs_volume structure. | |
| 694 * | |
| 695 * XXX - May someday want to look for Coded Character Set FSVD, too. | |
| 696 */ | |
| 697 static int | |
| 698 hs_findhsvol(struct hsfs *fsp, struct vnode *vp, struct hs_volume *hvp) | |
| 699 { | |
| 700 struct buf *secbp; | |
| 701 int i; | |
| 702 uchar_t *volp; | |
| 703 int error; | |
| 704 uint_t secno; | |
| 705 | |
| 706 secno = hs_findvoldesc(vp->v_rdev, HS_VOLDESC_SEC); | |
| 707 secbp = bread(vp->v_rdev, secno * 4, HS_SECTOR_SIZE); | |
| 708 error = geterror(secbp); | |
| 709 | |
| 710 if (error != 0) { | |
| 711 cmn_err(CE_NOTE, "hs_findhsvol: bread: error=(%d)", error); | |
| 712 brelse(secbp); | |
| 713 return (error); | |
| 714 } | |
| 715 | |
| 716 volp = (uchar_t *)secbp->b_un.b_addr; | |
| 717 | |
| 718 while (HSV_DESC_TYPE(volp) != VD_EOV) { | |
| 719 for (i = 0; i < HSV_ID_STRLEN; i++) | |
| 720 if (HSV_STD_ID(volp)[i] != HSV_ID_STRING[i]) | |
| 721 goto cantfind; | |
| 722 if (HSV_STD_VER(volp) != HSV_ID_VER) | |
| 723 goto cantfind; | |
| 724 switch (HSV_DESC_TYPE(volp)) { | |
| 725 case VD_SFS: | |
| 726 /* Standard File Structure */ | |
| 727 fsp->hsfs_vol_type = HS_VOL_TYPE_HS; | |
| 728 error = hs_parsehsvol(fsp, volp, hvp); | |
| 729 brelse(secbp); | |
| 730 return (error); | |
| 731 | |
| 732 case VD_CCFS: | |
| 733 /* Coded Character File Structure */ | |
| 734 case VD_BOOT: | |
| 735 case VD_UNSPEC: | |
| 736 case VD_EOV: | |
| 737 break; | |
| 738 } | |
| 739 brelse(secbp); | |
| 740 ++secno; | |
| 741 secbp = bread(vp->v_rdev, secno * 4, HS_SECTOR_SIZE); | |
| 742 | |
| 743 error = geterror(secbp); | |
| 744 | |
| 745 if (error != 0) { | |
| 746 cmn_err(CE_NOTE, "hs_findhsvol: bread: error=(%d)", | |
| 747 error); | |
| 748 brelse(secbp); | |
| 749 return (error); | |
| 750 } | |
| 751 | |
| 752 volp = (uchar_t *)secbp->b_un.b_addr; | |
| 753 } | |
| 754 cantfind: | |
| 755 brelse(secbp); | |
| 756 return (EINVAL); | |
| 757 } | |
| 758 | |
| 759 /* | |
| 760 * hs_parsehsvol | |
| 761 * | |
| 762 * Parse the Standard File Structure Volume Descriptor into | |
| 763 * an hs_volume structure. We can't just bcopy it into the | |
| 764 * structure because of byte-ordering problems. | |
| 765 * | |
| 766 */ | |
| 767 static int | |
| 768 hs_parsehsvol(struct hsfs *fsp, uchar_t *volp, struct hs_volume *hvp) | |
| 769 { | |
| 770 hvp->vol_size = HSV_VOL_SIZE(volp); | |
| 771 hvp->lbn_size = HSV_BLK_SIZE(volp); | |
| 772 if (hvp->lbn_size == 0) { | |
| 773 cmn_err(CE_NOTE, "hs_parsehsvol: logical block size in the " | |
| 774 "SFSVD is zero"); | |
| 775 return (EINVAL); | |
| 776 } | |
| 777 hvp->lbn_shift = ffs((long)hvp->lbn_size) - 1; | |
| 778 hvp->lbn_secshift = ffs((long)howmany(HS_SECTOR_SIZE, | |
| 779 (int)hvp->lbn_size)) - 1; | |
| 780 hvp->lbn_maxoffset = hvp->lbn_size - 1; | |
| 781 hs_parse_longdate(HSV_cre_date(volp), &hvp->cre_date); | |
| 782 hs_parse_longdate(HSV_mod_date(volp), &hvp->mod_date); | |
| 783 hvp->file_struct_ver = HSV_FILE_STRUCT_VER(volp); | |
| 784 hvp->ptbl_len = HSV_PTBL_SIZE(volp); | |
| 785 hvp->vol_set_size = (ushort_t)HSV_SET_SIZE(volp); | |
| 786 hvp->vol_set_seq = (ushort_t)HSV_SET_SEQ(volp); | |
| 787 #if defined(_LITTLE_ENDIAN) | |
| 788 hvp->ptbl_lbn = HSV_PTBL_MAN_LS(volp); | |
| 789 #else | |
| 790 hvp->ptbl_lbn = HSV_PTBL_MAN_MS(volp); | |
| 791 #endif | |
| 792 hs_copylabel(hvp, HSV_VOL_ID(volp)); | |
| 793 | |
| 794 /* | |
| 795 * Make sure that lbn_size is a power of two and otherwise valid. | |
| 796 */ | |
| 797 if (hvp->lbn_size & ~(1 << hvp->lbn_shift)) { | |
| 798 cmn_err(CE_NOTE, | |
| 799 "hsfs: %d-byte logical block size not supported", | |
| 800 hvp->lbn_size); | |
| 801 return (EINVAL); | |
| 802 } | |
| 803 return (hs_parsedir(fsp, HSV_ROOT_DIR(volp), &hvp->root_dir, | |
| 804 (char *)NULL, (int *)NULL)); | |
| 805 } | |
| 806 | |
| 807 /* | |
| 808 * hs_findisovol() | |
| 809 * | |
| 810 * Locate the Primary Volume Descriptor | |
| 811 * parse it into an hs_volume structure. | |
| 812 * | |
| 813 * XXX - Supplementary, Partition not yet done | |
| 814 */ | |
| 815 static int | |
| 816 hs_findisovol(struct hsfs *fsp, struct vnode *vp, | |
| 817 struct hs_volume *hvp) | |
| 818 { | |
| 819 struct buf *secbp; | |
| 820 int i; | |
| 821 uchar_t *volp; | |
| 822 int error; | |
| 823 uint_t secno; | |
| 824 int foundpvd = 0; | |
| 825 | |
| 826 secno = hs_findvoldesc(vp->v_rdev, ISO_VOLDESC_SEC); | |
| 827 secbp = bread(vp->v_rdev, secno * 4, ISO_SECTOR_SIZE); | |
| 828 error = geterror(secbp); | |
| 829 | |
| 830 if (error != 0) { | |
| 831 cmn_err(CE_NOTE, "hs_findisovol: bread: error=(%d)", error); | |
| 832 brelse(secbp); | |
| 833 return (error); | |
| 834 } | |
| 835 | |
| 836 volp = (uchar_t *)secbp->b_un.b_addr; | |
| 837 | |
| 838 while ((enum iso_voldesc_type) ISO_DESC_TYPE(volp) != ISO_VD_EOV) { | |
| 839 for (i = 0; i < ISO_ID_STRLEN; i++) | |
| 840 if (ISO_STD_ID(volp)[i] != ISO_ID_STRING[i]) | |
| 841 goto cantfind; | |
| 842 if (ISO_STD_VER(volp) != ISO_ID_VER) | |
| 843 goto cantfind; | |
| 844 switch (ISO_DESC_TYPE(volp)) { | |
| 845 case ISO_VD_PVD: | |
| 846 /* Standard File Structure */ | |
| 847 if (foundpvd != 1) { | |
| 848 fsp->hsfs_vol_type = HS_VOL_TYPE_ISO; | |
| 849 if (error = hs_parseisovol(fsp, volp, hvp)) { | |
| 850 brelse(secbp); | |
| 851 return (error); | |
| 852 } | |
| 853 foundpvd = 1; | |
| 854 } | |
| 855 break; | |
| 856 case ISO_VD_SVD: | |
| 857 /* Supplementary Volume Descriptor */ | |
| 858 break; | |
| 859 case ISO_VD_BOOT: | |
| 860 break; | |
| 861 case ISO_VD_VPD: | |
| 862 /* currently cannot handle partition */ | |
| 863 break; | |
| 864 case VD_EOV: | |
| 865 break; | |
| 866 } | |
| 867 brelse(secbp); | |
| 868 ++secno; | |
| 869 secbp = bread(vp->v_rdev, secno * 4, HS_SECTOR_SIZE); | |
| 870 error = geterror(secbp); | |
| 871 | |
| 872 if (error != 0) { | |
| 873 cmn_err(CE_NOTE, "hs_findisovol: bread: error=(%d)", | |
| 874 error); | |
| 875 brelse(secbp); | |
| 876 return (error); | |
| 877 } | |
| 878 | |
| 879 volp = (uchar_t *)secbp->b_un.b_addr; | |
| 880 } | |
| 881 if (foundpvd) { | |
| 882 brelse(secbp); | |
| 883 return (0); | |
| 884 } | |
| 885 cantfind: | |
| 886 brelse(secbp); | |
| 887 return (EINVAL); | |
| 888 } | |
| 889 /* | |
| 890 * hs_parseisovol | |
| 891 * | |
| 892 * Parse the Primary Volume Descriptor into an hs_volume structure. | |
| 893 * | |
| 894 */ | |
| 895 static int | |
| 896 hs_parseisovol(struct hsfs *fsp, uchar_t *volp, struct hs_volume *hvp) | |
| 897 { | |
| 898 hvp->vol_size = ISO_VOL_SIZE(volp); | |
| 899 hvp->lbn_size = ISO_BLK_SIZE(volp); | |
| 900 if (hvp->lbn_size == 0) { | |
| 901 cmn_err(CE_NOTE, "hs_parseisovol: logical block size in the " | |
| 902 "PVD is zero"); | |
| 903 return (EINVAL); | |
| 904 } | |
| 905 hvp->lbn_shift = ffs((long)hvp->lbn_size) - 1; | |
| 906 hvp->lbn_secshift = ffs((long)howmany(ISO_SECTOR_SIZE, | |
| 907 (int)hvp->lbn_size)) - 1; | |
| 908 hvp->lbn_maxoffset = hvp->lbn_size - 1; | |
| 909 hs_parse_longdate(ISO_cre_date(volp), &hvp->cre_date); | |
| 910 hs_parse_longdate(ISO_mod_date(volp), &hvp->mod_date); | |
| 911 hvp->file_struct_ver = ISO_FILE_STRUCT_VER(volp); | |
| 912 hvp->ptbl_len = ISO_PTBL_SIZE(volp); | |
| 913 hvp->vol_set_size = (ushort_t)ISO_SET_SIZE(volp); | |
| 914 hvp->vol_set_seq = (ushort_t)ISO_SET_SEQ(volp); | |
| 915 #if defined(_LITTLE_ENDIAN) | |
| 916 hvp->ptbl_lbn = ISO_PTBL_MAN_LS(volp); | |
| 917 #else | |
| 918 hvp->ptbl_lbn = ISO_PTBL_MAN_MS(volp); | |
| 919 #endif | |
| 920 hs_copylabel(hvp, ISO_VOL_ID(volp)); | |
| 921 | |
| 922 /* | |
| 923 * Make sure that lbn_size is a power of two and otherwise valid. | |
| 924 */ | |
| 925 if (hvp->lbn_size & ~(1 << hvp->lbn_shift)) { | |
| 926 cmn_err(CE_NOTE, | |
| 927 "hsfs: %d-byte logical block size not supported", | |
| 928 hvp->lbn_size); | |
| 929 return (EINVAL); | |
| 930 } | |
| 931 return (hs_parsedir(fsp, ISO_ROOT_DIR(volp), &hvp->root_dir, | |
| 932 (char *)NULL, (int *)NULL)); | |
| 933 } | |
| 934 | |
| 935 /* | |
| 936 * Common code for mount and umount. | |
| 937 * Check that the user's argument is a reasonable | |
| 938 * thing on which to mount, and return the device number if so. | |
| 939 */ | |
| 940 static int | |
| 941 hs_getmdev(struct vfs *vfsp, char *fspec, int flags, dev_t *pdev, mode_t *mode, | |
| 942 cred_t *cr) | |
| 943 { | |
| 944 int error; | |
| 945 struct vnode *vp; | |
| 946 struct vattr vap; | |
| 947 dev_t dev; | |
| 948 | |
| 949 /* | |
| 950 * Get the device to be mounted | |
| 951 */ | |
| 952 error = lookupname(fspec, (flags & MS_SYSSPACE) ? | |
| 953 UIO_SYSSPACE : UIO_USERSPACE, FOLLOW, NULLVPP, &vp); | |
| 954 if (error) { | |
| 955 if (error == ENOENT) { | |
| 956 return (ENODEV); /* needs translation */ | |
| 957 } | |
| 958 return (error); | |
| 959 } | |
| 960 if (vp->v_type != VBLK) { | |
| 961 VN_RELE(vp); | |
| 962 return (ENOTBLK); | |
| 963 } | |
| 964 /* | |
| 965 * Can we read from the device? | |
| 966 */ | |
| 967 if ((error = VOP_ACCESS(vp, VREAD, 0, cr)) != 0 || | |
| 968 (error = secpolicy_spec_open(cr, vp, FREAD)) != 0) { | |
| 969 VN_RELE(vp); | |
| 970 return (error); | |
| 971 } | |
| 972 | |
| 973 vap.va_mask = AT_MODE; /* get protection mode */ | |
| 974 (void) VOP_GETATTR(vp, &vap, 0, CRED()); | |
| 975 *mode = vap.va_mode; | |
| 976 | |
| 977 dev = *pdev = vp->v_rdev; | |
| 978 VN_RELE(vp); | |
| 979 | |
| 980 /* | |
| 981 * Ensure that this device isn't already mounted, | |
| 982 * unless this is a REMOUNT request or we are told to suppress | |
| 983 * mount checks. | |
| 984 */ | |
| 985 if ((flags & MS_NOCHECK) == 0) { | |
| 986 if (vfs_devmounting(dev, vfsp)) | |
| 987 return (EBUSY); | |
| 988 if (vfs_devismounted(dev) && !(flags & MS_REMOUNT)) | |
| 989 return (EBUSY); | |
| 990 } | |
| 991 | |
| 992 if (getmajor(*pdev) >= devcnt) | |
| 993 return (ENXIO); | |
| 994 return (0); | |
| 995 } | |
| 996 | |
| 997 static void | |
| 998 hs_copylabel(struct hs_volume *hvp, unsigned char *label) | |
| 999 { | |
| 1000 /* cdrom volid is at most 32 bytes */ | |
| 1001 bcopy(label, hvp->vol_id, 32); | |
| 1002 hvp->vol_id[31] = NULL; | |
| 1003 } | |
| 1004 | |
| 1005 /* | |
| 1006 * Mount root file system. | |
| 1007 * "why" is ROOT_INIT on initial call, ROOT_REMOUNT if called to | |
| 1008 * remount the root file system, and ROOT_UNMOUNT if called to | |
| 1009 * unmount the root (e.g., as part of a system shutdown). | |
| 1010 * | |
| 1011 * XXX - this may be partially machine-dependent; it, along with the VFS_SWAPVP | |
| 1012 * operation, goes along with auto-configuration. A mechanism should be | |
| 1013 * provided by which machine-INdependent code in the kernel can say "get me the | |
| 1014 * right root file system" and "get me the right initial swap area", and have | |
| 1015 * that done in what may well be a machine-dependent fashion. | |
| 1016 * Unfortunately, it is also file-system-type dependent (NFS gets it via | |
| 1017 * bootparams calls, UFS gets it from various and sundry machine-dependent | |
| 1018 * mechanisms, as SPECFS does for swap). | |
| 1019 */ | |
| 1020 static int | |
| 1021 hsfs_mountroot(struct vfs *vfsp, enum whymountroot why) | |
| 1022 { | |
| 1023 int error; | |
| 1024 struct hsfs *fsp; | |
| 1025 struct hs_volume *fvolp; | |
| 1026 static int hsfsrootdone = 0; | |
| 1027 dev_t rootdev; | |
| 1028 mode_t mode = 0; | |
| 1029 | |
| 1030 if (why == ROOT_INIT) { | |
| 1031 if (hsfsrootdone++) | |
| 1032 return (EBUSY); | |
| 1033 rootdev = getrootdev(); | |
| 1034 if (rootdev == (dev_t)NODEV) | |
| 1035 return (ENODEV); | |
| 1036 vfsp->vfs_dev = rootdev; | |
| 1037 vfsp->vfs_flag |= VFS_RDONLY; | |
| 1038 } else if (why == ROOT_REMOUNT) { | |
| 1039 cmn_err(CE_NOTE, "hsfs_mountroot: ROOT_REMOUNT"); | |
| 1040 return (0); | |
| 1041 } else if (why == ROOT_UNMOUNT) { | |
| 1042 return (0); | |
| 1043 } | |
| 1044 error = vfs_lock(vfsp); | |
| 1045 if (error) { | |
| 1046 cmn_err(CE_NOTE, "hsfs_mountroot: couldn't get vfs_lock"); | |
| 1047 return (error); | |
| 1048 } | |
| 1049 | |
| 1050 error = hs_mountfs(vfsp, rootdev, "/", mode, 1, CRED(), 1); | |
| 1051 /* | |
| 1052 * XXX - assumes root device is not indirect, because we don't set | |
| 1053 * rootvp. Is rootvp used for anything? If so, make another arg | |
| 1054 * to mountfs. | |
| 1055 */ | |
| 1056 if (error) { | |
| 1057 vfs_unlock(vfsp); | |
| 1058 if (rootvp) { | |
| 1059 VN_RELE(rootvp); | |
| 1060 rootvp = (struct vnode *)0; | |
| 1061 } | |
| 1062 return (error); | |
| 1063 } | |
| 1064 if (why == ROOT_INIT) | |
| 1065 vfs_add((struct vnode *)0, vfsp, | |
| 1066 (vfsp->vfs_flag & VFS_RDONLY) ? MS_RDONLY : 0); | |
| 1067 vfs_unlock(vfsp); | |
| 1068 fsp = VFS_TO_HSFS(vfsp); | |
| 1069 fvolp = &fsp->hsfs_vol; | |
| 1070 #ifdef HSFS_CLKSET | |
| 1071 if (fvolp->cre_date.tv_sec == 0) { | |
| 1072 cmn_err(CE_NOTE, "hsfs_mountroot: cre_date.tv_sec == 0"); | |
| 1073 if (fvolp->mod_date.tv_sec == 0) { | |
| 1074 cmn_err(CE_NOTE, "hsfs_mountroot: mod_date.tv_sec == 0"); | |
| 1075 cmn_err(CE_NOTE, "hsfs_mountroot: clkset(-1L)"); | |
| 1076 clkset(-1L); | |
| 1077 } else | |
| 1078 clkset(fvolp->mod_date.tv_sec); | |
| 1079 } else | |
| 1080 clkset(fvolp->mod_date.tv_sec); | |
| 1081 #else /* HSFS_CLKSET */ | |
| 1082 clkset(-1L); | |
| 1083 #endif /* HSFS_CLKSET */ | |
| 1084 return (0); | |
| 1085 } | |
| 1086 | |
| 1087 /* | |
| 1088 * hs_findvoldesc() | |
| 1089 * | |
| 1090 * Return the sector where the volume descriptor lives. This is | |
| 1091 * a fixed value for "normal" cd-rom's, but can change for | |
| 1092 * multisession cd's. | |
| 1093 * | |
| 1094 * desc_sec is the same for high-sierra and iso 9660 formats, why | |
| 1095 * there are two differnt #defines used in the code for this is | |
| 1096 * beyond me. These are standards, cast in concrete, right? | |
| 1097 * To be general, however, this function supports passing in different | |
| 1098 * values. | |
| 1099 */ | |
| 1100 static int | |
| 1101 hs_findvoldesc(dev_t rdev, int desc_sec) | |
| 1102 { | |
| 1103 int secno; | |
| 1104 int error; | |
| 1105 int rval; /* ignored */ | |
| 1106 | |
| 1107 #ifdef CDROMREADOFFSET | |
| 1108 /* | |
| 1109 * Issue the Read Offset ioctl directly to the | |
| 1110 * device. Ignore any errors and set starting | |
| 1111 * secno to the default, otherwise add the | |
| 1112 * VOLDESC sector number to the offset. | |
| 1113 */ | |
| 1114 error = cdev_ioctl(rdev, CDROMREADOFFSET, (intptr_t)&secno, | |
| 1115 FNATIVE|FKIOCTL|FREAD, CRED(), &rval); | |
| 1116 if (error) { | |
| 1117 secno = desc_sec; | |
| 1118 } else { | |
| 1119 secno += desc_sec; | |
| 1120 } | |
| 1121 #else | |
| 1122 secno = desc_sec; | |
| 1123 #endif | |
| 1124 | |
| 1125 return (secno); | |
| 1126 } |