root/isofs/udf/udf_vfsops.c

DEFINITIONS

1. udf_init
2. udf_start
3. udf_mount
4. udf_checktag
5. udf_mountfs
6. udf_unmount
7. udf_root
8. udf_quotactl
9. udf_statfs
10. udf_sync
11. udf_vget
12. udf_fhtovp
13. udf_vptofh
14. udf_sysctl
15. udf_checkexp
16. udf_get_vpartmap
17. udf_get_spartmap
18. udf_find_partmaps

    1 /*      $OpenBSD: udf_vfsops.c,v 1.23 2006/08/07 15:50:42 pedro Exp $   */
    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  */
   31 /*
   32  * Ported to OpenBSD by Pedro Martelletto <pedro@openbsd.org> in February 2005.
   33  */
   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  */
   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>
   69 #include <miscfs/specfs/specdev.h>
   71 #include <isofs/udf/ecma167-udf.h>
   72 #include <isofs/udf/udf.h>
   73 #include <isofs/udf/udf_extern.h>
   75 struct pool udf_trans_pool;
   76 struct pool unode_pool;
   77 struct pool udf_ds_pool;
   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 *);
   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 };
  100 int
udf_init(struct vfsconf *foo)
  102 {
pool_init(&udf_trans_pool, MAXNAMLEN * sizeof(unicode_t), 0, 0, 0,
  104             "udftrpl", &pool_allocator_nointr);
pool_init(&unode_pool, sizeof(struct unode), 0, 0, 0,
  106             "udfndpl", &pool_allocator_nointr);
pool_init(&udf_ds_pool, sizeof(struct udf_dirstream), 0, 0, 0,
  108             "udfdspl", &pool_allocator_nointr);
  110         return (0);
  111 }
  113 int
udf_start(struct mount *mp, int flags, struct proc *p)
  115 {
  116         return (0);
  117 }
  119 int
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;
size_t len;
  126         int error;
  128         if ((mp->mnt_flag & MNT_RDONLY) == 0) {
mp->mnt_flag |= MNT_RDONLY;
printf("udf_mount: enforcing read-only mode\n");
  131         }
  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);
error = copyin(data, &args, sizeof(struct udf_args));
  141         if (error)
  142                 return (error);
  144         if (args.fspec == NULL)
  145                 return (EINVAL);
NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p);
  148         if ((error = namei(ndp)))
  149                 return (error);
devvp = ndp->ni_vp;
  152         if (devvp->v_type != VBLK) {
vrele(devvp);
  154                 return (ENOTBLK);
  155         }
  157         if (major(devvp->v_rdev) >= nblkdev) {
vrele(devvp);
  159                 return (ENXIO);
  160         }
  162         /* Check the access rights on the mount device */
  163         if (p->p_ucred->cr_uid) {
vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
error = VOP_ACCESS(devvp, VREAD, p->p_ucred, p);
VOP_UNLOCK(devvp, 0, p);
  167                 if (error) {
vrele(devvp);
  169                         return (error);
  170                 }
  171         }
  173         if ((error = udf_mountfs(devvp, mp, args.lastblock, p))) {
vrele(devvp);
  175                 return (error);
  176         }
  178         /*
  179          * Keep a copy of the mount information.
  180          */
copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN - 1, &len);
bzero(mp->mnt_stat.f_mntonname + len, MNAMELEN - len);
copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, &len);
bzero(mp->mnt_stat.f_mntfromname + len, MNAMELEN - len);
  186         return (0);
  187 };
  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
udf_checktag(struct desc_tag *tag, uint16_t id)
  195 {
uint8_t *itag;
uint8_t i, cksum = 0;
itag = (uint8_t *)tag;
  201         if (letoh16(tag->id) != id)
  202                 return (EINVAL);
  204         for (i = 0; i < 15; i++)
cksum = cksum + itag[i];
cksum = cksum - itag[4];
  208         if (cksum == tag->cksum)
  209                 return (0);
  211         return (EINVAL);
  212 }
  214 int
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;
uint32_t sector, size, mvds_start, mvds_end;
uint32_t fsd_offset = 0;
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;
  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);
vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
error = vinvalbuf(devvp, V_SAVE, p->p_ucred, p, 0, 0);
VOP_UNLOCK(devvp, 0, p);
  244         if (error)
  245                 return (error);
error = VOP_OPEN(devvp, FREAD, FSCRED, p);
  248         if (error)
  249                 return (error);
MALLOC(ump, struct umount *, sizeof(struct umount), M_UDFMOUNT,
M_WAITOK);
bzero(ump, sizeof(struct umount));
mp->mnt_data = (qaddr_t) ump;
mp->mnt_stat.f_fsid.val[0] = devvp->v_rdev;
mp->mnt_stat.f_fsid.val[1] = makefstype(MOUNT_UDF);
mp->mnt_flag |= MNT_LOCAL;
ump->um_mountp = mp;
ump->um_dev = devvp->v_rdev;
ump->um_devvp = devvp;
bsize = 2048;   /* Should probe the media for its size. */
  266         /* 
  267          * Get the Anchor Volume Descriptor Pointer from sector 256.
  268          * Should also check sector n - 256, n, and 512.
  269          */
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;
bcopy(bp->b_data, &avdp, sizeof(struct anchor_vdp));
brelse(bp);
bp = NULL;
  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          */
mvds_start = letoh32(avdp.main_vds_ex.loc);
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, 
NOCRED, &bp)) != 0) {
printf("Can't read sector %d of VDS\n", sector);
  293                         goto bail;
  294                 }
lvd = (struct logvol_desc *)bp->b_data;
  296                 if (!udf_checktag(&lvd->tag, TAGID_LOGVOL)) {
ump->um_bsize = letoh32(lvd->lb_size);
ump->um_bmask = ump->um_bsize - 1;
ump->um_bshift = ffs(ump->um_bsize) - 1;
fsd_part = letoh16(lvd->_lvd_use.fsd_loc.loc.part_num);
fsd_offset = letoh32(lvd->_lvd_use.fsd_loc.loc.lb_num);
  302                         if (udf_find_partmaps(ump, lvd))
  303                                 break;
logvol_found = 1;
  305                 }
pd = (struct part_desc *)bp->b_data;
  307                 if (!udf_checktag(&pd->tag, TAGID_PARTITION)) {
part_found = 1;
part_num = letoh16(pd->part_num);
ump->um_len = letoh32(pd->part_len);
ump->um_start = letoh32(pd->start_loc);
  312                 }
brelse(bp); 
bp = NULL;
  316                 if ((part_found) && (logvol_found))
  317                         break;
  318         }
  320         if (!part_found || !logvol_found) {
error = EINVAL;
  322                 goto bail;
  323         }
  325         if (fsd_part != part_num) {
printf("FSD does not lie within the partition!\n");
error = EINVAL;
  328                 goto bail;
  329         }
mtx_init(&ump->um_hashmtx, IPL_NONE);
ump->um_hashtbl = hashinit(UDF_HASHTBLSIZE, M_UDFMOUNT, M_WAITOK,
  333             &ump->um_hashsz);
  335         /* Get the VAT, if needed */
  336         if (ump->um_flags & UDF_MNT_FIND_VAT) {
error = udf_vat_get(ump, lb);
  338                 if (error)
  339                         goto bail;
  340         }
  342         /*
  343          * Grab the Fileset Descriptor
  344          * Thanks to Chuck McCrobie <mccrobie@cablespeed.com> for pointing
  345          * me in the right direction here.
  346          */
sector = fsd_offset;
udf_vat_map(ump, &sector);
  349         if ((error = RDSECTOR(devvp, sector, ump->um_bsize, &bp)) != 0) {
printf("Cannot read sector %d of FSD\n", sector);
  351                 goto bail;
  352         }
fsd = (struct fileset_desc *)bp->b_data;
  354         if (!udf_checktag(&fsd->tag, TAGID_FSD)) {
fsd_found = 1;
bcopy(&fsd->rootdir_icb, &ump->um_root_icb,
  357                     sizeof(struct long_ad));
  358         }
brelse(bp);
bp = NULL;
  363         if (!fsd_found) {
printf("Couldn't find the fsd\n");
error = EINVAL;
  366                 goto bail;
  367         }
  369         /*
  370          * Find the file entry for the root directory.
  371          */
sector = letoh32(ump->um_root_icb.loc.lb_num);
size = letoh32(ump->um_root_icb.len);
udf_vat_map(ump, &sector);
  375         if ((error = udf_readlblks(ump, sector, size, &bp)) != 0) {
printf("Cannot read sector %d\n", sector);
  377                 goto bail;
  378         }
root_fentry = (struct file_entry *)bp->b_data;
  381         if ((error = udf_checktag(&root_fentry->tag, TAGID_FENTRY))) {
printf("Invalid root file entry!\n");
  383                 goto bail;
  384         }
brelse(bp);
bp = NULL;
devvp->v_specmountpoint = mp;
  391         return (0);
bail:
  394         if (ump->um_hashtbl != NULL)
free(ump->um_hashtbl, M_UDFMOUNT);
  397         if (ump != NULL) {
FREE(ump, M_UDFMOUNT);
mp->mnt_data = NULL;
mp->mnt_flag &= ~MNT_LOCAL;
  401         }
  402         if (bp != NULL)
brelse(bp);
VOP_CLOSE(devvp, FREAD, FSCRED, p);
  406         return (error);
  407 }
  409 int
udf_unmount(struct mount *mp, int mntflags, struct proc *p)
  411 {
  412         struct umount *ump;
  413         struct vnode *devvp;
  414         int error, flags = 0;
ump = VFSTOUDFFS(mp);
devvp = ump->um_devvp;
  419         if (mntflags & MNT_FORCE)
flags |= FORCECLOSE;
  422         if ((error = vflush(mp, NULL, flags)))
  423                 return (error);
vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
vinvalbuf(devvp, V_SAVE, NOCRED, p, 0, 0);
error = VOP_CLOSE(devvp, FREAD, NOCRED, p);
VOP_UNLOCK(devvp, 0, p);
  429         if (error)
  430                 return (error);
devvp->v_specmountpoint = NULL;
vrele(devvp);
  435         if (ump->um_flags & UDF_MNT_USES_VAT)
free(ump->um_vat, M_UDFMOUNT);
  438         if (ump->um_stbl != NULL)
free(ump->um_stbl, M_UDFMOUNT);
  441         if (ump->um_hashtbl != NULL)
free(ump->um_hashtbl, M_UDFMOUNT);
FREE(ump, M_UDFMOUNT);
mp->mnt_data = (qaddr_t)0;
mp->mnt_flag &= ~MNT_LOCAL;
  449         return (0);
  450 }
  452 int
udf_root(struct mount *mp, struct vnode **vpp)
  454 {
  455         struct umount *ump;
  456         struct vnode *vp;
ino_t id;
  458         int error;
ump = VFSTOUDFFS(mp);
id = udf_getid(&ump->um_root_icb);
error = udf_vget(mp, id, vpp);
  465         if (error)
  466                 return (error);
vp = *vpp;
vp->v_flag |= VROOT;
  471         return (0);
  472 }
  474 int
udf_quotactl(struct mount *mp, int cmds, uid_t uid, caddr_t arg,
  476     struct proc *p)
  477 {
  478         return (EOPNOTSUPP);
  479 }
  481 int
udf_statfs(struct mount *mp, struct statfs *sbp, struct proc *p)
  483 {
  484         struct umount *ump;
ump = VFSTOUDFFS(mp);
sbp->f_bsize = ump->um_bsize;
sbp->f_iosize = ump->um_bsize;
sbp->f_blocks = ump->um_len;
sbp->f_bfree = 0;
sbp->f_bavail = 0;
sbp->f_files = 0;
sbp->f_ffree = 0;
  496         return (0);
  497 }
  499 int
udf_sync(struct mount *mp, int waitfor, struct ucred *cred, struct proc *p)
  501 {
  502         return (0);
  503 }
  505 int
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;
p = curproc;
bp = NULL;
  519         *vpp = NULL;
ump = VFSTOUDFFS(mp);
  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);
  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          */
up = pool_get(&unode_pool, PR_WAITOK);
bzero(up, sizeof(struct unode));
  535         /*
  536          * Copy in the file entry.  Per the spec, the size can only be 1 block.
  537          */
sector = ino;
devvp = ump->um_devvp;
udf_vat_map(ump, &sector);
  541         if ((error = RDSECTOR(devvp, sector, ump->um_bsize, &bp)) != 0) {
printf("Cannot read sector %d\n", sector);
pool_put(&unode_pool, up);
  544                 if (bp != NULL)
brelse(bp);
  546                 return (error);
  547         }
fe = (struct file_entry *)bp->b_data;
  550         if (udf_checktag(&fe->tag, TAGID_FENTRY)) {
printf("Invalid file entry!\n");
pool_put(&unode_pool, up);
brelse(bp);
  554                 return (ENOMEM);
  555         }
size = UDF_FENTRY_SIZE + letoh32(fe->l_ea) + letoh32(fe->l_ad);
up->u_fentry = malloc(size, M_UDFFENTRY, M_NOWAIT);
  560         if (up->u_fentry == NULL) {
pool_put(&unode_pool, up);
brelse(bp);
  563                 return (ENOMEM); /* Cannot allocate file entry block */
  564         }
bcopy(bp->b_data, up->u_fentry, size);
brelse(bp);
bp = NULL;
  571         if ((error = udf_allocv(mp, &vp, p))) {
free(up->u_fentry, M_UDFFENTRY);
pool_put(&unode_pool, up);
  574                 return (error); /* Error from udf_allocv() */
  575         }
up->u_vnode = vp;
up->u_ino = ino;
up->u_devvp = ump->um_devvp;
up->u_dev = ump->um_dev;
up->u_ump = ump;
vp->v_data = up;
VREF(ump->um_devvp);
lockinit(&up->u_lock, PINOD, "unode", 0, 0);
  587         /*
  588          * udf_hashins() will lock the vnode for us.
  589          */
udf_hashins(up);
  592         switch (up->u_fentry->icbtag.file_type) {
  593         default:
vp->v_type = VBAD;
  595                 break;
  596         case UDF_ICB_TYPE_DIR:
vp->v_type = VDIR;
  598                 break;
  599         case UDF_ICB_TYPE_FILE:
vp->v_type = VREG;
  601                 break;
  602         case UDF_ICB_TYPE_BLKDEV:
vp->v_type = VBLK;
  604                 break;
  605         case UDF_ICB_TYPE_CHRDEV:
vp->v_type = VCHR;
  607                 break;
  608         case UDF_ICB_TYPE_FIFO:
vp->v_type = VFIFO;
  610                 break;
  611         case UDF_ICB_TYPE_SOCKET:
vp->v_type = VSOCK;
  613                 break;
  614         case UDF_ICB_TYPE_SYMLINK:
vp->v_type = VLNK;
  616                 break;
  617         case UDF_ICB_TYPE_VAT_150:
vp->v_type = VREG;
  619                 break;
  620         }
  622         *vpp = vp;
  624         return (0);
  625 }
  627 struct ifid {
u_short ifid_len;
u_short ifid_pad;
  630         int     ifid_ino;
  631         long    ifid_start;
  632 };
  634 int
udf_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
  636 {
  637         struct ifid *ifhp;
  638         struct vnode *nvp;
  639         int error;
ifhp = (struct ifid *)fhp;
  643         if ((error = VFS_VGET(mp, ifhp->ifid_ino, &nvp)) != 0) {
  644                 *vpp = NULLVP;
  645                 return (error);
  646         }
  648         *vpp = nvp;
  650         return (0);
  651 }
  653 int
udf_vptofh(struct vnode *vp, struct fid *fhp)
  655 {
  656         struct unode *up;
  657         struct ifid *ifhp;
up = VTOU(vp);
ifhp = (struct ifid *)fhp;
ifhp->ifid_len = sizeof(struct ifid);
ifhp->ifid_ino = up->u_ino;
  664         return (0);
  665 }
  667 int
udf_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
size_t newlen, struct proc *p)
  670 {
  671         return (EINVAL);
  672 }
  674 int
udf_checkexp(struct mount *mp, struct mbuf *nam, int *exflagsp,
  676     struct ucred **credanonp)
  677 {
  678         return (EACCES); /* For the time being */
  679 }
  681 /* Handle a virtual partition map */
  682 int
udf_get_vpartmap(struct umount *ump, struct part_map_virt *pmv)
  684 {
ump->um_flags |= UDF_MNT_FIND_VAT; /* Should do more than this */
  686         return (0);
  687 }
  689 /* Handle a sparable partition map */
  690 int
udf_get_spartmap(struct umount *ump, struct part_map_spare *pms)
  692 {
  693         struct buf *bp;
  694         int i, error;
ump->um_stbl = malloc(letoh32(pms->st_size), M_UDFMOUNT, M_NOWAIT);
  697         if (ump->um_stbl == NULL)
  698                 return (ENOMEM);
bzero(ump->um_stbl, letoh32(pms->st_size));
  702         /* Calculate the number of sectors per packet */
ump->um_psecs = letoh16(pms->packet_len) / ump->um_bsize;
error = udf_readlblks(ump, letoh32(pms->st_loc[0]),
letoh32(pms->st_size), &bp);
  708         if (error) {
  709                 if (bp != NULL)
brelse(bp);
free(ump->um_stbl, M_UDFMOUNT);
  712                 return (error); /* Failed to read sparing table */
  713         }
bcopy(bp->b_data, ump->um_stbl, letoh32(pms->st_size));
brelse(bp);
  718         if (udf_checktag(&ump->um_stbl->tag, 0)) {
free(ump->um_stbl, M_UDFMOUNT);
  720                 return (EINVAL); /* Invalid sparing table found */
  721         }
  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++) {
ump->um_stbl_len = i;
  729                 if (letoh32(ump->um_stbl->entries[i].org) >= 0xfffffff0)
  730                         break;
  731         }
  733         return (0);
  734 }
  736 /* Scan the partition maps */
  737 int
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;
uint8_t *pmap = (uint8_t *) &lvd->maps[0];
  745         for (i = 0; i < letoh32(lvd->n_pm); i++) {
ptype = pmap[0];
psize = pmap[1];
  749                 if (ptype != 1 && ptype != 2)
  750                         return (EINVAL); /* Invalid partition map type */
  752                 if (psize != UDF_PMAP_TYPE1_SIZE &&
psize != UDF_PMAP_TYPE2_SIZE)
  754                         return (EINVAL); /* Invalid partition map size */
  756                 if (ptype == 1) {
pmap += UDF_PMAP_TYPE1_SIZE;
  758                         continue;
  759                 }
  761                 /* Type 2 map. Find out the details */
pmap_id = (struct regid *) &pmap[4];
regid_id[UDF_REGID_ID_SIZE] = '\0';
bcopy(&pmap_id->id[0], &regid_id[0], UDF_REGID_ID_SIZE);
  766                 if (!bcmp(&regid_id[0], "*UDF Virtual Partition",
UDF_REGID_ID_SIZE))
error = udf_get_vpartmap(ump,
  769                             (struct part_map_virt *) pmap);
  770                 else if (!bcmp(&regid_id[0], "*UDF Sparable Partition",
UDF_REGID_ID_SIZE))
error = udf_get_spartmap(ump,
  773                             (struct part_map_spare *) pmap);
  774                 else
  775                         return (EINVAL); /* Unsupported partition map */
  777                 if (error)
  778                         return (error); /* Error getting partition */
pmap += UDF_PMAP_TYPE2_SIZE;
  781         }
  783         return (0);
  784 }