Annotation of sys/isofs/udf/udf_vfsops.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: udf_vfsops.c,v 1.23 2006/08/07 15:50:42 pedro Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 2001, 2002 Scott Long <scottl@freebsd.org>
! 5: * All rights reserved.
! 6: *
! 7: * Redistribution and use in source and binary forms, with or without
! 8: * modification, are permitted provided that the following conditions
! 9: * are met:
! 10: * 1. Redistributions of source code must retain the above copyright
! 11: * notice, this list of conditions and the following disclaimer.
! 12: * 2. Redistributions in binary form must reproduce the above copyright
! 13: * notice, this list of conditions and the following disclaimer in the
! 14: * documentation and/or other materials provided with the distribution.
! 15: *
! 16: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
! 17: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 18: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 19: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
! 20: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 21: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 22: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 23: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 24: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 25: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 26: * SUCH DAMAGE.
! 27: *
! 28: * $FreeBSD: src/sys/fs/udf/udf_vfsops.c,v 1.25 2005/01/25 15:52:03 phk Exp $
! 29: */
! 30:
! 31: /*
! 32: * Ported to OpenBSD by Pedro Martelletto <pedro@openbsd.org> in February 2005.
! 33: */
! 34:
! 35: /*
! 36: * Ok, here's how it goes. The UDF specs are pretty clear on how each data
! 37: * structure is made up, but not very clear on how they relate to each other.
! 38: * Here is the skinny... This demostrates a filesystem with one file in the
! 39: * root directory. Subdirectories are treated just as normal files, but they
! 40: * have File Id Descriptors of their children as their file data. As for the
! 41: * Anchor Volume Descriptor Pointer, it can exist in two of the following three
! 42: * places: sector 256, sector n (the max sector of the disk), or sector
! 43: * n - 256. It's a pretty good bet that one will exist at sector 256 though.
! 44: * One caveat is unclosed CD media. For that, sector 256 cannot be written,
! 45: * so the Anchor Volume Descriptor Pointer can exist at sector 512 until the
! 46: * media is closed.
! 47: */
! 48:
! 49: #include <sys/types.h>
! 50: #include <sys/param.h>
! 51: #include <sys/systm.h>
! 52: #include <sys/uio.h>
! 53: #include <sys/buf.h>
! 54: #include <sys/conf.h>
! 55: #include <sys/dirent.h>
! 56: #include <sys/fcntl.h>
! 57: #include <sys/kernel.h>
! 58: #include <sys/malloc.h>
! 59: #include <sys/mutex.h>
! 60: #include <sys/mount.h>
! 61: #include <sys/namei.h>
! 62: #include <sys/pool.h>
! 63: #include <sys/proc.h>
! 64: #include <sys/lock.h>
! 65: #include <sys/queue.h>
! 66: #include <sys/vnode.h>
! 67: #include <sys/endian.h>
! 68:
! 69: #include <miscfs/specfs/specdev.h>
! 70:
! 71: #include <isofs/udf/ecma167-udf.h>
! 72: #include <isofs/udf/udf.h>
! 73: #include <isofs/udf/udf_extern.h>
! 74:
! 75: struct pool udf_trans_pool;
! 76: struct pool unode_pool;
! 77: struct pool udf_ds_pool;
! 78:
! 79: int udf_find_partmaps(struct umount *, struct logvol_desc *);
! 80: int udf_get_vpartmap(struct umount *, struct part_map_virt *);
! 81: int udf_get_spartmap(struct umount *, struct part_map_spare *);
! 82: int udf_mountfs(struct vnode *, struct mount *, uint32_t, struct proc *);
! 83:
! 84: const struct vfsops udf_vfsops = {
! 85: .vfs_fhtovp = udf_fhtovp,
! 86: .vfs_init = udf_init,
! 87: .vfs_mount = udf_mount,
! 88: .vfs_start = udf_start,
! 89: .vfs_root = udf_root,
! 90: .vfs_quotactl = udf_quotactl,
! 91: .vfs_statfs = udf_statfs,
! 92: .vfs_sync = udf_sync,
! 93: .vfs_unmount = udf_unmount,
! 94: .vfs_vget = udf_vget,
! 95: .vfs_vptofh = udf_vptofh,
! 96: .vfs_sysctl = udf_sysctl,
! 97: .vfs_checkexp = udf_checkexp,
! 98: };
! 99:
! 100: int
! 101: udf_init(struct vfsconf *foo)
! 102: {
! 103: pool_init(&udf_trans_pool, MAXNAMLEN * sizeof(unicode_t), 0, 0, 0,
! 104: "udftrpl", &pool_allocator_nointr);
! 105: pool_init(&unode_pool, sizeof(struct unode), 0, 0, 0,
! 106: "udfndpl", &pool_allocator_nointr);
! 107: pool_init(&udf_ds_pool, sizeof(struct udf_dirstream), 0, 0, 0,
! 108: "udfdspl", &pool_allocator_nointr);
! 109:
! 110: return (0);
! 111: }
! 112:
! 113: int
! 114: udf_start(struct mount *mp, int flags, struct proc *p)
! 115: {
! 116: return (0);
! 117: }
! 118:
! 119: int
! 120: udf_mount(struct mount *mp, const char *path, void *data,
! 121: struct nameidata *ndp, struct proc *p)
! 122: {
! 123: struct vnode *devvp; /* vnode of the mount device */
! 124: struct udf_args args;
! 125: size_t len;
! 126: int error;
! 127:
! 128: if ((mp->mnt_flag & MNT_RDONLY) == 0) {
! 129: mp->mnt_flag |= MNT_RDONLY;
! 130: printf("udf_mount: enforcing read-only mode\n");
! 131: }
! 132:
! 133: /*
! 134: * No root filesystem support. Probably not a big deal, since the
! 135: * bootloader doesn't understand UDF.
! 136: */
! 137: if (mp->mnt_flag & MNT_ROOTFS)
! 138: return (EOPNOTSUPP);
! 139:
! 140: error = copyin(data, &args, sizeof(struct udf_args));
! 141: if (error)
! 142: return (error);
! 143:
! 144: if (args.fspec == NULL)
! 145: return (EINVAL);
! 146:
! 147: NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p);
! 148: if ((error = namei(ndp)))
! 149: return (error);
! 150:
! 151: devvp = ndp->ni_vp;
! 152: if (devvp->v_type != VBLK) {
! 153: vrele(devvp);
! 154: return (ENOTBLK);
! 155: }
! 156:
! 157: if (major(devvp->v_rdev) >= nblkdev) {
! 158: vrele(devvp);
! 159: return (ENXIO);
! 160: }
! 161:
! 162: /* Check the access rights on the mount device */
! 163: if (p->p_ucred->cr_uid) {
! 164: vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
! 165: error = VOP_ACCESS(devvp, VREAD, p->p_ucred, p);
! 166: VOP_UNLOCK(devvp, 0, p);
! 167: if (error) {
! 168: vrele(devvp);
! 169: return (error);
! 170: }
! 171: }
! 172:
! 173: if ((error = udf_mountfs(devvp, mp, args.lastblock, p))) {
! 174: vrele(devvp);
! 175: return (error);
! 176: }
! 177:
! 178: /*
! 179: * Keep a copy of the mount information.
! 180: */
! 181: copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN - 1, &len);
! 182: bzero(mp->mnt_stat.f_mntonname + len, MNAMELEN - len);
! 183: copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, &len);
! 184: bzero(mp->mnt_stat.f_mntfromname + len, MNAMELEN - len);
! 185:
! 186: return (0);
! 187: };
! 188:
! 189: /*
! 190: * Check the descriptor tag for both the correct id and correct checksum.
! 191: * Return zero if all is good, EINVAL if not.
! 192: */
! 193: int
! 194: udf_checktag(struct desc_tag *tag, uint16_t id)
! 195: {
! 196: uint8_t *itag;
! 197: uint8_t i, cksum = 0;
! 198:
! 199: itag = (uint8_t *)tag;
! 200:
! 201: if (letoh16(tag->id) != id)
! 202: return (EINVAL);
! 203:
! 204: for (i = 0; i < 15; i++)
! 205: cksum = cksum + itag[i];
! 206: cksum = cksum - itag[4];
! 207:
! 208: if (cksum == tag->cksum)
! 209: return (0);
! 210:
! 211: return (EINVAL);
! 212: }
! 213:
! 214: int
! 215: udf_mountfs(struct vnode *devvp, struct mount *mp, uint32_t lb, struct proc *p)
! 216: {
! 217: struct buf *bp = NULL;
! 218: struct anchor_vdp avdp;
! 219: struct umount *ump = NULL;
! 220: struct part_desc *pd;
! 221: struct logvol_desc *lvd;
! 222: struct fileset_desc *fsd;
! 223: struct file_entry *root_fentry;
! 224: uint32_t sector, size, mvds_start, mvds_end;
! 225: uint32_t fsd_offset = 0;
! 226: uint16_t part_num = 0, fsd_part = 0;
! 227: int error = EINVAL;
! 228: int logvol_found = 0, part_found = 0, fsd_found = 0;
! 229: int bsize;
! 230:
! 231: /*
! 232: * Disallow multiple mounts of the same device.
! 233: * Disallow mounting of a device that is currently in use
! 234: * (except for root, which might share swap device for miniroot).
! 235: * Flush out any old buffers remaining from a previous use.
! 236: */
! 237: if ((error = vfs_mountedon(devvp)))
! 238: return (error);
! 239: if (vcount(devvp) > 1 && devvp != rootvp)
! 240: return (EBUSY);
! 241: vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
! 242: error = vinvalbuf(devvp, V_SAVE, p->p_ucred, p, 0, 0);
! 243: VOP_UNLOCK(devvp, 0, p);
! 244: if (error)
! 245: return (error);
! 246:
! 247: error = VOP_OPEN(devvp, FREAD, FSCRED, p);
! 248: if (error)
! 249: return (error);
! 250:
! 251: MALLOC(ump, struct umount *, sizeof(struct umount), M_UDFMOUNT,
! 252: M_WAITOK);
! 253: bzero(ump, sizeof(struct umount));
! 254:
! 255: mp->mnt_data = (qaddr_t) ump;
! 256: mp->mnt_stat.f_fsid.val[0] = devvp->v_rdev;
! 257: mp->mnt_stat.f_fsid.val[1] = makefstype(MOUNT_UDF);
! 258: mp->mnt_flag |= MNT_LOCAL;
! 259:
! 260: ump->um_mountp = mp;
! 261: ump->um_dev = devvp->v_rdev;
! 262: ump->um_devvp = devvp;
! 263:
! 264: bsize = 2048; /* Should probe the media for its size. */
! 265:
! 266: /*
! 267: * Get the Anchor Volume Descriptor Pointer from sector 256.
! 268: * Should also check sector n - 256, n, and 512.
! 269: */
! 270: sector = 256;
! 271: if ((error = bread(devvp, sector * btodb(bsize), bsize, NOCRED,
! 272: &bp)) != 0)
! 273: goto bail;
! 274: if ((error = udf_checktag((struct desc_tag *)bp->b_data, TAGID_ANCHOR)))
! 275: goto bail;
! 276:
! 277: bcopy(bp->b_data, &avdp, sizeof(struct anchor_vdp));
! 278: brelse(bp);
! 279: bp = NULL;
! 280:
! 281: /*
! 282: * Extract the Partition Descriptor and Logical Volume Descriptor
! 283: * from the Volume Descriptor Sequence.
! 284: * Should we care about the partition type right now?
! 285: * What about multiple partitions?
! 286: */
! 287: mvds_start = letoh32(avdp.main_vds_ex.loc);
! 288: mvds_end = mvds_start + (letoh32(avdp.main_vds_ex.len) - 1) / bsize;
! 289: for (sector = mvds_start; sector < mvds_end; sector++) {
! 290: if ((error = bread(devvp, sector * btodb(bsize), bsize,
! 291: NOCRED, &bp)) != 0) {
! 292: printf("Can't read sector %d of VDS\n", sector);
! 293: goto bail;
! 294: }
! 295: lvd = (struct logvol_desc *)bp->b_data;
! 296: if (!udf_checktag(&lvd->tag, TAGID_LOGVOL)) {
! 297: ump->um_bsize = letoh32(lvd->lb_size);
! 298: ump->um_bmask = ump->um_bsize - 1;
! 299: ump->um_bshift = ffs(ump->um_bsize) - 1;
! 300: fsd_part = letoh16(lvd->_lvd_use.fsd_loc.loc.part_num);
! 301: fsd_offset = letoh32(lvd->_lvd_use.fsd_loc.loc.lb_num);
! 302: if (udf_find_partmaps(ump, lvd))
! 303: break;
! 304: logvol_found = 1;
! 305: }
! 306: pd = (struct part_desc *)bp->b_data;
! 307: if (!udf_checktag(&pd->tag, TAGID_PARTITION)) {
! 308: part_found = 1;
! 309: part_num = letoh16(pd->part_num);
! 310: ump->um_len = letoh32(pd->part_len);
! 311: ump->um_start = letoh32(pd->start_loc);
! 312: }
! 313:
! 314: brelse(bp);
! 315: bp = NULL;
! 316: if ((part_found) && (logvol_found))
! 317: break;
! 318: }
! 319:
! 320: if (!part_found || !logvol_found) {
! 321: error = EINVAL;
! 322: goto bail;
! 323: }
! 324:
! 325: if (fsd_part != part_num) {
! 326: printf("FSD does not lie within the partition!\n");
! 327: error = EINVAL;
! 328: goto bail;
! 329: }
! 330:
! 331: mtx_init(&ump->um_hashmtx, IPL_NONE);
! 332: ump->um_hashtbl = hashinit(UDF_HASHTBLSIZE, M_UDFMOUNT, M_WAITOK,
! 333: &ump->um_hashsz);
! 334:
! 335: /* Get the VAT, if needed */
! 336: if (ump->um_flags & UDF_MNT_FIND_VAT) {
! 337: error = udf_vat_get(ump, lb);
! 338: if (error)
! 339: goto bail;
! 340: }
! 341:
! 342: /*
! 343: * Grab the Fileset Descriptor
! 344: * Thanks to Chuck McCrobie <mccrobie@cablespeed.com> for pointing
! 345: * me in the right direction here.
! 346: */
! 347: sector = fsd_offset;
! 348: udf_vat_map(ump, §or);
! 349: if ((error = RDSECTOR(devvp, sector, ump->um_bsize, &bp)) != 0) {
! 350: printf("Cannot read sector %d of FSD\n", sector);
! 351: goto bail;
! 352: }
! 353: fsd = (struct fileset_desc *)bp->b_data;
! 354: if (!udf_checktag(&fsd->tag, TAGID_FSD)) {
! 355: fsd_found = 1;
! 356: bcopy(&fsd->rootdir_icb, &ump->um_root_icb,
! 357: sizeof(struct long_ad));
! 358: }
! 359:
! 360: brelse(bp);
! 361: bp = NULL;
! 362:
! 363: if (!fsd_found) {
! 364: printf("Couldn't find the fsd\n");
! 365: error = EINVAL;
! 366: goto bail;
! 367: }
! 368:
! 369: /*
! 370: * Find the file entry for the root directory.
! 371: */
! 372: sector = letoh32(ump->um_root_icb.loc.lb_num);
! 373: size = letoh32(ump->um_root_icb.len);
! 374: udf_vat_map(ump, §or);
! 375: if ((error = udf_readlblks(ump, sector, size, &bp)) != 0) {
! 376: printf("Cannot read sector %d\n", sector);
! 377: goto bail;
! 378: }
! 379:
! 380: root_fentry = (struct file_entry *)bp->b_data;
! 381: if ((error = udf_checktag(&root_fentry->tag, TAGID_FENTRY))) {
! 382: printf("Invalid root file entry!\n");
! 383: goto bail;
! 384: }
! 385:
! 386: brelse(bp);
! 387: bp = NULL;
! 388:
! 389: devvp->v_specmountpoint = mp;
! 390:
! 391: return (0);
! 392:
! 393: bail:
! 394: if (ump->um_hashtbl != NULL)
! 395: free(ump->um_hashtbl, M_UDFMOUNT);
! 396:
! 397: if (ump != NULL) {
! 398: FREE(ump, M_UDFMOUNT);
! 399: mp->mnt_data = NULL;
! 400: mp->mnt_flag &= ~MNT_LOCAL;
! 401: }
! 402: if (bp != NULL)
! 403: brelse(bp);
! 404: VOP_CLOSE(devvp, FREAD, FSCRED, p);
! 405:
! 406: return (error);
! 407: }
! 408:
! 409: int
! 410: udf_unmount(struct mount *mp, int mntflags, struct proc *p)
! 411: {
! 412: struct umount *ump;
! 413: struct vnode *devvp;
! 414: int error, flags = 0;
! 415:
! 416: ump = VFSTOUDFFS(mp);
! 417: devvp = ump->um_devvp;
! 418:
! 419: if (mntflags & MNT_FORCE)
! 420: flags |= FORCECLOSE;
! 421:
! 422: if ((error = vflush(mp, NULL, flags)))
! 423: return (error);
! 424:
! 425: vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
! 426: vinvalbuf(devvp, V_SAVE, NOCRED, p, 0, 0);
! 427: error = VOP_CLOSE(devvp, FREAD, NOCRED, p);
! 428: VOP_UNLOCK(devvp, 0, p);
! 429: if (error)
! 430: return (error);
! 431:
! 432: devvp->v_specmountpoint = NULL;
! 433: vrele(devvp);
! 434:
! 435: if (ump->um_flags & UDF_MNT_USES_VAT)
! 436: free(ump->um_vat, M_UDFMOUNT);
! 437:
! 438: if (ump->um_stbl != NULL)
! 439: free(ump->um_stbl, M_UDFMOUNT);
! 440:
! 441: if (ump->um_hashtbl != NULL)
! 442: free(ump->um_hashtbl, M_UDFMOUNT);
! 443:
! 444: FREE(ump, M_UDFMOUNT);
! 445:
! 446: mp->mnt_data = (qaddr_t)0;
! 447: mp->mnt_flag &= ~MNT_LOCAL;
! 448:
! 449: return (0);
! 450: }
! 451:
! 452: int
! 453: udf_root(struct mount *mp, struct vnode **vpp)
! 454: {
! 455: struct umount *ump;
! 456: struct vnode *vp;
! 457: ino_t id;
! 458: int error;
! 459:
! 460: ump = VFSTOUDFFS(mp);
! 461:
! 462: id = udf_getid(&ump->um_root_icb);
! 463:
! 464: error = udf_vget(mp, id, vpp);
! 465: if (error)
! 466: return (error);
! 467:
! 468: vp = *vpp;
! 469: vp->v_flag |= VROOT;
! 470:
! 471: return (0);
! 472: }
! 473:
! 474: int
! 475: udf_quotactl(struct mount *mp, int cmds, uid_t uid, caddr_t arg,
! 476: struct proc *p)
! 477: {
! 478: return (EOPNOTSUPP);
! 479: }
! 480:
! 481: int
! 482: udf_statfs(struct mount *mp, struct statfs *sbp, struct proc *p)
! 483: {
! 484: struct umount *ump;
! 485:
! 486: ump = VFSTOUDFFS(mp);
! 487:
! 488: sbp->f_bsize = ump->um_bsize;
! 489: sbp->f_iosize = ump->um_bsize;
! 490: sbp->f_blocks = ump->um_len;
! 491: sbp->f_bfree = 0;
! 492: sbp->f_bavail = 0;
! 493: sbp->f_files = 0;
! 494: sbp->f_ffree = 0;
! 495:
! 496: return (0);
! 497: }
! 498:
! 499: int
! 500: udf_sync(struct mount *mp, int waitfor, struct ucred *cred, struct proc *p)
! 501: {
! 502: return (0);
! 503: }
! 504:
! 505: int
! 506: udf_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
! 507: {
! 508: struct buf *bp;
! 509: struct vnode *devvp;
! 510: struct umount *ump;
! 511: struct proc *p;
! 512: struct vnode *vp;
! 513: struct unode *up;
! 514: struct file_entry *fe;
! 515: int error, sector, size;
! 516:
! 517: p = curproc;
! 518: bp = NULL;
! 519: *vpp = NULL;
! 520: ump = VFSTOUDFFS(mp);
! 521:
! 522: /* See if we already have this in the cache */
! 523: if ((error = udf_hashlookup(ump, ino, LK_EXCLUSIVE, vpp)) != 0)
! 524: return (error);
! 525: if (*vpp != NULL)
! 526: return (0);
! 527:
! 528: /*
! 529: * Allocate memory and check the tag id's before grabbing a new
! 530: * vnode, since it's hard to roll back if there is a problem.
! 531: */
! 532: up = pool_get(&unode_pool, PR_WAITOK);
! 533: bzero(up, sizeof(struct unode));
! 534:
! 535: /*
! 536: * Copy in the file entry. Per the spec, the size can only be 1 block.
! 537: */
! 538: sector = ino;
! 539: devvp = ump->um_devvp;
! 540: udf_vat_map(ump, §or);
! 541: if ((error = RDSECTOR(devvp, sector, ump->um_bsize, &bp)) != 0) {
! 542: printf("Cannot read sector %d\n", sector);
! 543: pool_put(&unode_pool, up);
! 544: if (bp != NULL)
! 545: brelse(bp);
! 546: return (error);
! 547: }
! 548:
! 549: fe = (struct file_entry *)bp->b_data;
! 550: if (udf_checktag(&fe->tag, TAGID_FENTRY)) {
! 551: printf("Invalid file entry!\n");
! 552: pool_put(&unode_pool, up);
! 553: brelse(bp);
! 554: return (ENOMEM);
! 555: }
! 556:
! 557: size = UDF_FENTRY_SIZE + letoh32(fe->l_ea) + letoh32(fe->l_ad);
! 558:
! 559: up->u_fentry = malloc(size, M_UDFFENTRY, M_NOWAIT);
! 560: if (up->u_fentry == NULL) {
! 561: pool_put(&unode_pool, up);
! 562: brelse(bp);
! 563: return (ENOMEM); /* Cannot allocate file entry block */
! 564: }
! 565:
! 566: bcopy(bp->b_data, up->u_fentry, size);
! 567:
! 568: brelse(bp);
! 569: bp = NULL;
! 570:
! 571: if ((error = udf_allocv(mp, &vp, p))) {
! 572: free(up->u_fentry, M_UDFFENTRY);
! 573: pool_put(&unode_pool, up);
! 574: return (error); /* Error from udf_allocv() */
! 575: }
! 576:
! 577: up->u_vnode = vp;
! 578: up->u_ino = ino;
! 579: up->u_devvp = ump->um_devvp;
! 580: up->u_dev = ump->um_dev;
! 581: up->u_ump = ump;
! 582: vp->v_data = up;
! 583: VREF(ump->um_devvp);
! 584:
! 585: lockinit(&up->u_lock, PINOD, "unode", 0, 0);
! 586:
! 587: /*
! 588: * udf_hashins() will lock the vnode for us.
! 589: */
! 590: udf_hashins(up);
! 591:
! 592: switch (up->u_fentry->icbtag.file_type) {
! 593: default:
! 594: vp->v_type = VBAD;
! 595: break;
! 596: case UDF_ICB_TYPE_DIR:
! 597: vp->v_type = VDIR;
! 598: break;
! 599: case UDF_ICB_TYPE_FILE:
! 600: vp->v_type = VREG;
! 601: break;
! 602: case UDF_ICB_TYPE_BLKDEV:
! 603: vp->v_type = VBLK;
! 604: break;
! 605: case UDF_ICB_TYPE_CHRDEV:
! 606: vp->v_type = VCHR;
! 607: break;
! 608: case UDF_ICB_TYPE_FIFO:
! 609: vp->v_type = VFIFO;
! 610: break;
! 611: case UDF_ICB_TYPE_SOCKET:
! 612: vp->v_type = VSOCK;
! 613: break;
! 614: case UDF_ICB_TYPE_SYMLINK:
! 615: vp->v_type = VLNK;
! 616: break;
! 617: case UDF_ICB_TYPE_VAT_150:
! 618: vp->v_type = VREG;
! 619: break;
! 620: }
! 621:
! 622: *vpp = vp;
! 623:
! 624: return (0);
! 625: }
! 626:
! 627: struct ifid {
! 628: u_short ifid_len;
! 629: u_short ifid_pad;
! 630: int ifid_ino;
! 631: long ifid_start;
! 632: };
! 633:
! 634: int
! 635: udf_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
! 636: {
! 637: struct ifid *ifhp;
! 638: struct vnode *nvp;
! 639: int error;
! 640:
! 641: ifhp = (struct ifid *)fhp;
! 642:
! 643: if ((error = VFS_VGET(mp, ifhp->ifid_ino, &nvp)) != 0) {
! 644: *vpp = NULLVP;
! 645: return (error);
! 646: }
! 647:
! 648: *vpp = nvp;
! 649:
! 650: return (0);
! 651: }
! 652:
! 653: int
! 654: udf_vptofh(struct vnode *vp, struct fid *fhp)
! 655: {
! 656: struct unode *up;
! 657: struct ifid *ifhp;
! 658:
! 659: up = VTOU(vp);
! 660: ifhp = (struct ifid *)fhp;
! 661: ifhp->ifid_len = sizeof(struct ifid);
! 662: ifhp->ifid_ino = up->u_ino;
! 663:
! 664: return (0);
! 665: }
! 666:
! 667: int
! 668: udf_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
! 669: size_t newlen, struct proc *p)
! 670: {
! 671: return (EINVAL);
! 672: }
! 673:
! 674: int
! 675: udf_checkexp(struct mount *mp, struct mbuf *nam, int *exflagsp,
! 676: struct ucred **credanonp)
! 677: {
! 678: return (EACCES); /* For the time being */
! 679: }
! 680:
! 681: /* Handle a virtual partition map */
! 682: int
! 683: udf_get_vpartmap(struct umount *ump, struct part_map_virt *pmv)
! 684: {
! 685: ump->um_flags |= UDF_MNT_FIND_VAT; /* Should do more than this */
! 686: return (0);
! 687: }
! 688:
! 689: /* Handle a sparable partition map */
! 690: int
! 691: udf_get_spartmap(struct umount *ump, struct part_map_spare *pms)
! 692: {
! 693: struct buf *bp;
! 694: int i, error;
! 695:
! 696: ump->um_stbl = malloc(letoh32(pms->st_size), M_UDFMOUNT, M_NOWAIT);
! 697: if (ump->um_stbl == NULL)
! 698: return (ENOMEM);
! 699:
! 700: bzero(ump->um_stbl, letoh32(pms->st_size));
! 701:
! 702: /* Calculate the number of sectors per packet */
! 703: ump->um_psecs = letoh16(pms->packet_len) / ump->um_bsize;
! 704:
! 705: error = udf_readlblks(ump, letoh32(pms->st_loc[0]),
! 706: letoh32(pms->st_size), &bp);
! 707:
! 708: if (error) {
! 709: if (bp != NULL)
! 710: brelse(bp);
! 711: free(ump->um_stbl, M_UDFMOUNT);
! 712: return (error); /* Failed to read sparing table */
! 713: }
! 714:
! 715: bcopy(bp->b_data, ump->um_stbl, letoh32(pms->st_size));
! 716: brelse(bp);
! 717:
! 718: if (udf_checktag(&ump->um_stbl->tag, 0)) {
! 719: free(ump->um_stbl, M_UDFMOUNT);
! 720: return (EINVAL); /* Invalid sparing table found */
! 721: }
! 722:
! 723: /*
! 724: * See how many valid entries there are here. The list is
! 725: * supposed to be sorted, 0xfffffff0 and higher are not valid.
! 726: */
! 727: for (i = 0; i < letoh16(ump->um_stbl->rt_l); i++) {
! 728: ump->um_stbl_len = i;
! 729: if (letoh32(ump->um_stbl->entries[i].org) >= 0xfffffff0)
! 730: break;
! 731: }
! 732:
! 733: return (0);
! 734: }
! 735:
! 736: /* Scan the partition maps */
! 737: int
! 738: udf_find_partmaps(struct umount *ump, struct logvol_desc *lvd)
! 739: {
! 740: struct regid *pmap_id;
! 741: unsigned char regid_id[UDF_REGID_ID_SIZE + 1];
! 742: int i, ptype, psize, error;
! 743: uint8_t *pmap = (uint8_t *) &lvd->maps[0];
! 744:
! 745: for (i = 0; i < letoh32(lvd->n_pm); i++) {
! 746: ptype = pmap[0];
! 747: psize = pmap[1];
! 748:
! 749: if (ptype != 1 && ptype != 2)
! 750: return (EINVAL); /* Invalid partition map type */
! 751:
! 752: if (psize != UDF_PMAP_TYPE1_SIZE &&
! 753: psize != UDF_PMAP_TYPE2_SIZE)
! 754: return (EINVAL); /* Invalid partition map size */
! 755:
! 756: if (ptype == 1) {
! 757: pmap += UDF_PMAP_TYPE1_SIZE;
! 758: continue;
! 759: }
! 760:
! 761: /* Type 2 map. Find out the details */
! 762: pmap_id = (struct regid *) &pmap[4];
! 763: regid_id[UDF_REGID_ID_SIZE] = '\0';
! 764: bcopy(&pmap_id->id[0], ®id_id[0], UDF_REGID_ID_SIZE);
! 765:
! 766: if (!bcmp(®id_id[0], "*UDF Virtual Partition",
! 767: UDF_REGID_ID_SIZE))
! 768: error = udf_get_vpartmap(ump,
! 769: (struct part_map_virt *) pmap);
! 770: else if (!bcmp(®id_id[0], "*UDF Sparable Partition",
! 771: UDF_REGID_ID_SIZE))
! 772: error = udf_get_spartmap(ump,
! 773: (struct part_map_spare *) pmap);
! 774: else
! 775: return (EINVAL); /* Unsupported partition map */
! 776:
! 777: if (error)
! 778: return (error); /* Error getting partition */
! 779:
! 780: pmap += UDF_PMAP_TYPE2_SIZE;
! 781: }
! 782:
! 783: return (0);
! 784: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to udf_vfsops.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / isofs / udf