int
udf_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
{
struct buf *bp;
struct vnode *devvp;
struct umount *ump;
struct proc *p;
struct vnode *vp, *nvp;
struct unode *up;
struct extfile_entry *xfe;
struct file_entry *fe;
int error, sector, size;
p = curproc;
bp = NULL;
*vpp = NULL;
ump = VFSTOUDFFS(mp);
/* See if we already have this in the cache */
if ((error = udf_hashlookup(ump, ino, LK_EXCLUSIVE, vpp)) != 0)
return (error);
if (*vpp != NULL)
return (0);
/*
* Allocate memory and check the tag id's before grabbing a new
* vnode, since it's hard to roll back if there is a problem.
*/
up = pool_get(&unode_pool, PR_WAITOK | PR_ZERO);
/*
* Copy in the file entry. Per the spec, the size can only be 1 block.
*/
sector = ino;
devvp = ump->um_devvp;
udf_vat_map(ump, §or);
if ((error = RDSECTOR(devvp, sector, ump->um_bsize, &bp)) != 0) {
printf("Cannot read sector %d\n", sector);
pool_put(&unode_pool, up);
if (bp != NULL)
brelse(bp);
return (error);
}
xfe = (struct extfile_entry *)bp->b_data;
fe = (struct file_entry *)bp->b_data;
error = udf_checktag(&xfe->tag, TAGID_EXTFENTRY);
if (error == 0) {
size = letoh32(xfe->l_ea) + letoh32(xfe->l_ad);
} else {
error = udf_checktag(&fe->tag, TAGID_FENTRY);
if (error) {
printf("Invalid file entry!\n");
pool_put(&unode_pool, up);
if (bp != NULL)
brelse(bp);
return (ENOMEM);
} else
size = letoh32(fe->l_ea) + letoh32(fe->l_ad);
}
/* Allocate max size of FE/XFE. */
up->u_fentry = malloc(size + UDF_EXTFENTRY_SIZE, M_UDFFENTRY, M_NOWAIT | M_ZERO);
if (up->u_fentry == NULL) {
pool_put(&unode_pool, up);
if (bp != NULL)
brelse(bp);
return (ENOMEM); /* Cannot allocate file entry block */
}
if (udf_checktag(&xfe->tag, TAGID_EXTFENTRY) == 0)
bcopy(bp->b_data, up->u_fentry, size + UDF_EXTFENTRY_SIZE);
else
bcopy(bp->b_data, up->u_fentry, size + UDF_FENTRY_SIZE);
brelse(bp);
bp = NULL;
if ((error = udf_allocv(mp, &vp, p))) {
free(up->u_fentry, M_UDFFENTRY);
pool_put(&unode_pool, up);
return (error); /* Error from udf_allocv() */
}
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);
/*
* udf_hashins() will lock the vnode for us.
*/
udf_hashins(up);
switch (up->u_fentry->icbtag.file_type) {
default:
printf("Unrecognized file type (%d)\n", vp->v_type);
vp->v_type = VREG;
break;
case UDF_ICB_FILETYPE_DIRECTORY:
vp->v_type = VDIR;
break;
case UDF_ICB_FILETYPE_BLOCKDEVICE:
vp->v_type = VBLK;
break;
case UDF_ICB_FILETYPE_CHARDEVICE:
vp->v_type = VCHR;
break;
case UDF_ICB_FILETYPE_FIFO:
vp->v_type = VFIFO;
break;
case UDF_ICB_FILETYPE_SOCKET:
vp->v_type = VSOCK;
break;
case UDF_ICB_FILETYPE_SYMLINK:
vp->v_type = VLNK;
break;
case UDF_ICB_FILETYPE_RANDOMACCESS:
case UDF_ICB_FILETYPE_REALTIME:
case UDF_ICB_FILETYPE_UNKNOWN:
vp->v_type = VREG;
break;
}
/* check if this is a vnode alias */
if ((nvp = checkalias(vp, up->u_dev, ump->um_mountp)) != NULL) {
printf("found a vnode alias\n");
/*
* Discard unneeded vnode, but save its udf_node.
* Note that the lock is carried over in the udf_node
*/
nvp->v_data = vp->v_data;
vp->v_data = NULL;
vp->v_op = spec_vnodeop_p;
vrele(vp);
vgone(vp);
/*
* Reinitialize aliased inode.
*/
vp = nvp;
ump->um_devvp = vp;
}
*vpp = vp;
return (0);
}
int
udf_mountfs(struct vnode *devvp, struct mount *mp, uint32_t lb, struct proc *p)
{
struct buf *bp = NULL;
struct anchor_vdp avdp;
struct umount *ump = NULL;
struct part_desc *pd;
struct logvol_desc *lvd;
struct fileset_desc *fsd;
struct extfile_entry *xfentry;
struct file_entry *fentry;
uint32_t sector, size, mvds_start, mvds_end;
uint32_t fsd_offset = 0;
uint16_t part_num = 0, fsd_part = 0;
int error = EINVAL;
int logvol_found = 0, part_found = 0, fsd_found = 0;
int bsize;
/*
* Disallow multiple mounts of the same device.
* Disallow mounting of a device that is currently in use
* (except for root, which might share swap device for miniroot).
* Flush out any old buffers remaining from a previous use.
*/
if ((error = vfs_mountedon(devvp)))
return (error);
if (vcount(devvp) > 1 && devvp != rootvp)
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);
if (error)
return (error);
error = VOP_OPEN(devvp, FREAD, FSCRED, p);
if (error)
return (error);
ump = malloc(sizeof(*ump), M_UDFMOUNT, M_WAITOK | M_ZERO);
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. */
/*
* Get the Anchor Volume Descriptor Pointer from sector 256.
* Should also check sector n - 256, n, and 512.
*/
sector = 256;
if ((error = bread(devvp, sector * btodb(bsize), bsize, NOCRED,
&bp)) != 0)
goto bail;
if ((error = udf_checktag((struct desc_tag *)bp->b_data, TAGID_ANCHOR)))
goto bail;
bcopy(bp->b_data, &avdp, sizeof(struct anchor_vdp));
brelse(bp);
bp = NULL;
/*
* Extract the Partition Descriptor and Logical Volume Descriptor
* from the Volume Descriptor Sequence.
* Should we care about the partition type right now?
* What about multiple partitions?
*/
mvds_start = letoh32(avdp.main_vds_ex.loc);
mvds_end = mvds_start + (letoh32(avdp.main_vds_ex.len) - 1) / bsize;
for (sector = mvds_start; sector < mvds_end; sector++) {
if ((error = bread(devvp, sector * btodb(bsize), bsize,
NOCRED, &bp)) != 0) {
printf("Can't read sector %d of VDS\n", sector);
goto bail;
}
lvd = (struct logvol_desc *)bp->b_data;
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);
if (udf_find_partmaps(ump, lvd))
break;
logvol_found = 1;
}
pd = (struct part_desc *)bp->b_data;
if (!udf_checktag(&pd->tag, TAGID_PARTITION)) {
part_found = 1;
part_num = letoh16(pd->part_num);
ump->um_len = ump->um_reallen = letoh32(pd->part_len);
ump->um_start = ump->um_realstart = letoh32(pd->start_loc);
}
brelse(bp);
bp = NULL;
if ((part_found) && (logvol_found))
break;
}
if (!part_found || !logvol_found) {
error = EINVAL;
goto bail;
}
if (ISSET(ump->um_flags, UDF_MNT_USES_META)) {
/* Read Metadata File 'File Entry' to find Metadata file. */
struct long_ad *la;
sector = ump->um_start + ump->um_meta_start; /* Set in udf_get_mpartmap() */
if ((error = RDSECTOR(devvp, sector, ump->um_bsize, &bp)) != 0) {
printf("Cannot read sector %d for Metadata File Entry\n", sector);
error = EINVAL;
goto bail;
}
xfentry = (struct extfile_entry *)bp->b_data;
fentry = (struct file_entry *)bp->b_data;
if (udf_checktag(&xfentry->tag, TAGID_EXTFENTRY) == 0)
la = (struct long_ad *)&xfentry->data[letoh32(xfentry->l_ea)];
else if (udf_checktag(&fentry->tag, TAGID_FENTRY) == 0)
la = (struct long_ad *)&fentry->data[letoh32(fentry->l_ea)];
else {
printf("Invalid Metadata File FE @ sector %d! (tag.id %d)\n",
sector, fentry->tag.id);
error = EINVAL;
goto bail;
}
ump->um_meta_start = letoh32(la->loc.lb_num);
ump->um_meta_len = letoh32(la->len);
if (bp != NULL) {
brelse(bp);
bp = NULL;
}
} else if (fsd_part != part_num) {
printf("FSD does not lie within the partition!\n");
error = EINVAL;
goto bail;
}
mtx_init(&ump->um_hashmtx, IPL_NONE);
ump->um_hashtbl = hashinit(UDF_HASHTBLSIZE, M_UDFMOUNT, M_WAITOK,
&ump->um_hashsz);
/* Get the VAT, if needed */
if (ump->um_flags & UDF_MNT_FIND_VAT) {
error = udf_vat_get(ump, lb);
if (error)
goto bail;
}
/*
* Grab the Fileset Descriptor
* Thanks to Chuck McCrobie <*****@*****.**> for pointing
* me in the right direction here.
*/
if (ISSET(ump->um_flags, UDF_MNT_USES_META))
sector = ump->um_meta_start;
else
sector = fsd_offset;
udf_vat_map(ump, §or);
if ((error = RDSECTOR(devvp, sector, ump->um_bsize, &bp)) != 0) {
printf("Cannot read sector %d of FSD\n", sector);
goto bail;
}
fsd = (struct fileset_desc *)bp->b_data;
if (!udf_checktag(&fsd->tag, TAGID_FSD)) {
fsd_found = 1;
bcopy(&fsd->rootdir_icb, &ump->um_root_icb,
sizeof(struct long_ad));
if (ISSET(ump->um_flags, UDF_MNT_USES_META)) {
ump->um_root_icb.loc.lb_num += ump->um_meta_start;
ump->um_root_icb.loc.part_num = part_num;
}
}
brelse(bp);
bp = NULL;
if (!fsd_found) {
printf("Couldn't find the fsd\n");
error = EINVAL;
goto bail;
}
/*
* Find the file entry for the root directory.
*/
sector = letoh32(ump->um_root_icb.loc.lb_num);
size = letoh32(ump->um_root_icb.len);
udf_vat_map(ump, §or);
if ((error = udf_readlblks(ump, sector, size, &bp)) != 0) {
printf("Cannot read sector %d\n", sector);
goto bail;
}
xfentry = (struct extfile_entry *)bp->b_data;
fentry = (struct file_entry *)bp->b_data;
error = udf_checktag(&xfentry->tag, TAGID_EXTFENTRY);
if (error) {
error = udf_checktag(&fentry->tag, TAGID_FENTRY);
if (error) {
printf("Invalid root file entry!\n");
goto bail;
}
}
brelse(bp);
bp = NULL;
devvp->v_specmountpoint = mp;
return (0);
bail:
if (ump->um_hashtbl != NULL)
free(ump->um_hashtbl, M_UDFMOUNT);
if (ump != NULL) {
free(ump, M_UDFMOUNT);
mp->mnt_data = NULL;
mp->mnt_flag &= ~MNT_LOCAL;
}
if (bp != NULL)
brelse(bp);
vn_lock(devvp, LK_EXCLUSIVE|LK_RETRY, p);
VOP_CLOSE(devvp, FREAD, FSCRED, p);
VOP_UNLOCK(devvp, 0, p);
return (error);
}
static int
udf_mountfs(struct vnode *devvp, struct mount *mp)
{
struct buf *bp = NULL;
struct cdev *dev;
struct anchor_vdp avdp;
struct udf_mnt *udfmp = NULL;
struct part_desc *pd;
struct logvol_desc *lvd;
struct fileset_desc *fsd;
struct file_entry *root_fentry;
uint32_t sector, size, mvds_start, mvds_end;
uint32_t logical_secsize;
uint32_t fsd_offset = 0;
uint16_t part_num = 0, fsd_part = 0;
int error = EINVAL;
int logvol_found = 0, part_found = 0, fsd_found = 0;
int bsize;
struct g_consumer *cp;
struct bufobj *bo;
dev = devvp->v_rdev;
dev_ref(dev);
DROP_GIANT();
g_topology_lock();
error = g_vfs_open(devvp, &cp, "udf", 0);
g_topology_unlock();
PICKUP_GIANT();
VOP_UNLOCK(devvp, 0);
if (error)
goto bail;
bo = &devvp->v_bufobj;
if (devvp->v_rdev->si_iosize_max != 0)
mp->mnt_iosize_max = devvp->v_rdev->si_iosize_max;
if (mp->mnt_iosize_max > MAXPHYS)
mp->mnt_iosize_max = MAXPHYS;
/* XXX: should be M_WAITOK */
udfmp = malloc(sizeof(struct udf_mnt), M_UDFMOUNT,
M_NOWAIT | M_ZERO);
if (udfmp == NULL) {
printf("Cannot allocate UDF mount struct\n");
error = ENOMEM;
goto bail;
}
mp->mnt_data = udfmp;
mp->mnt_stat.f_fsid.val[0] = dev2udev(devvp->v_rdev);
mp->mnt_stat.f_fsid.val[1] = mp->mnt_vfc->vfc_typenum;
MNT_ILOCK(mp);
mp->mnt_flag |= MNT_LOCAL;
mp->mnt_kern_flag |= MNTK_LOOKUP_SHARED | MNTK_EXTENDED_SHARED;
MNT_IUNLOCK(mp);
udfmp->im_mountp = mp;
udfmp->im_dev = dev;
udfmp->im_devvp = devvp;
udfmp->im_d2l = NULL;
udfmp->im_cp = cp;
udfmp->im_bo = bo;
#if 0
udfmp->im_l2d = NULL;
#endif
/*
* The UDF specification defines a logical sectorsize of 2048
* for DVD media.
*/
logical_secsize = 2048;
if (((logical_secsize % cp->provider->sectorsize) != 0) ||
(logical_secsize < cp->provider->sectorsize)) {
error = EINVAL;
goto bail;
}
bsize = cp->provider->sectorsize;
/*
* Get the Anchor Volume Descriptor Pointer from sector 256.
* XXX Should also check sector n - 256, n, and 512.
*/
sector = 256;
if ((error = bread(devvp, sector * btodb(logical_secsize), bsize,
NOCRED, &bp)) != 0)
goto bail;
if ((error = udf_checktag((struct desc_tag *)bp->b_data, TAGID_ANCHOR)))
goto bail;
bcopy(bp->b_data, &avdp, sizeof(struct anchor_vdp));
brelse(bp);
bp = NULL;
/*
* Extract the Partition Descriptor and Logical Volume Descriptor
* from the Volume Descriptor Sequence.
* XXX Should we care about the partition type right now?
* XXX What about multiple partitions?
*/
mvds_start = le32toh(avdp.main_vds_ex.loc);
mvds_end = mvds_start + (le32toh(avdp.main_vds_ex.len) - 1) / bsize;
for (sector = mvds_start; sector < mvds_end; sector++) {
if ((error = bread(devvp, sector * btodb(logical_secsize),
bsize, NOCRED, &bp)) != 0) {
printf("Can't read sector %d of VDS\n", sector);
goto bail;
}
lvd = (struct logvol_desc *)bp->b_data;
if (!udf_checktag(&lvd->tag, TAGID_LOGVOL)) {
udfmp->bsize = le32toh(lvd->lb_size);
udfmp->bmask = udfmp->bsize - 1;
udfmp->bshift = ffs(udfmp->bsize) - 1;
fsd_part = le16toh(lvd->_lvd_use.fsd_loc.loc.part_num);
fsd_offset = le32toh(lvd->_lvd_use.fsd_loc.loc.lb_num);
if (udf_find_partmaps(udfmp, lvd))
break;
logvol_found = 1;
}
pd = (struct part_desc *)bp->b_data;
if (!udf_checktag(&pd->tag, TAGID_PARTITION)) {
part_found = 1;
part_num = le16toh(pd->part_num);
udfmp->part_len = le32toh(pd->part_len);
udfmp->part_start = le32toh(pd->start_loc);
}
brelse(bp);
bp = NULL;
if ((part_found) && (logvol_found))
break;
}
if (!part_found || !logvol_found) {
error = EINVAL;
goto bail;
}
if (fsd_part != part_num) {
printf("FSD does not lie within the partition!\n");
error = EINVAL;
goto bail;
}
/*
* Grab the Fileset Descriptor
* Thanks to Chuck McCrobie <*****@*****.**> for pointing
* me in the right direction here.
*/
sector = udfmp->part_start + fsd_offset;
if ((error = RDSECTOR(devvp, sector, udfmp->bsize, &bp)) != 0) {
printf("Cannot read sector %d of FSD\n", sector);
goto bail;
}
fsd = (struct fileset_desc *)bp->b_data;
if (!udf_checktag(&fsd->tag, TAGID_FSD)) {
fsd_found = 1;
bcopy(&fsd->rootdir_icb, &udfmp->root_icb,
sizeof(struct long_ad));
}
brelse(bp);
bp = NULL;
if (!fsd_found) {
printf("Couldn't find the fsd\n");
error = EINVAL;
goto bail;
}
/*
* Find the file entry for the root directory.
*/
sector = le32toh(udfmp->root_icb.loc.lb_num) + udfmp->part_start;
size = le32toh(udfmp->root_icb.len);
if ((error = udf_readdevblks(udfmp, sector, size, &bp)) != 0) {
printf("Cannot read sector %d\n", sector);
goto bail;
}
root_fentry = (struct file_entry *)bp->b_data;
if ((error = udf_checktag(&root_fentry->tag, TAGID_FENTRY))) {
printf("Invalid root file entry!\n");
goto bail;
}
brelse(bp);
bp = NULL;
return 0;
bail:
if (udfmp != NULL)
free(udfmp, M_UDFMOUNT);
if (bp != NULL)
brelse(bp);
if (cp != NULL) {
DROP_GIANT();
g_topology_lock();
g_vfs_close(cp);
g_topology_unlock();
PICKUP_GIANT();
}
dev_rel(dev);
return error;
};
int
udf_vget(struct mount *mp, ino_t ino, int flags, struct vnode **vpp)
{
struct buf *bp;
struct vnode *devvp;
struct udf_mnt *udfmp;
struct thread *td;
struct vnode *vp;
struct udf_node *unode;
struct file_entry *fe;
int error, sector, size;
error = vfs_hash_get(mp, ino, flags, curthread, vpp, NULL, NULL);
if (error || *vpp != NULL)
return (error);
/*
* We must promote to an exclusive lock for vnode creation. This
* can happen if lookup is passed LOCKSHARED.
*/
if ((flags & LK_TYPE_MASK) == LK_SHARED) {
flags &= ~LK_TYPE_MASK;
flags |= LK_EXCLUSIVE;
}
/*
* We do not lock vnode creation as it is believed to be too
* expensive for such rare case as simultaneous creation of vnode
* for same ino by different processes. We just allow them to race
* and check later to decide who wins. Let the race begin!
*/
td = curthread;
udfmp = VFSTOUDFFS(mp);
unode = uma_zalloc(udf_zone_node, M_WAITOK | M_ZERO);
if ((error = udf_allocv(mp, &vp, td))) {
printf("Error from udf_allocv\n");
uma_zfree(udf_zone_node, unode);
return (error);
}
unode->i_vnode = vp;
unode->hash_id = ino;
unode->udfmp = udfmp;
vp->v_data = unode;
lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL);
error = insmntque(vp, mp);
if (error != 0) {
uma_zfree(udf_zone_node, unode);
return (error);
}
error = vfs_hash_insert(vp, ino, flags, td, vpp, NULL, NULL);
if (error || *vpp != NULL)
return (error);
/*
* Copy in the file entry. Per the spec, the size can only be 1 block.
*/
sector = ino + udfmp->part_start;
devvp = udfmp->im_devvp;
if ((error = RDSECTOR(devvp, sector, udfmp->bsize, &bp)) != 0) {
printf("Cannot read sector %d\n", sector);
vgone(vp);
vput(vp);
brelse(bp);
*vpp = NULL;
return (error);
}
fe = (struct file_entry *)bp->b_data;
if (udf_checktag(&fe->tag, TAGID_FENTRY)) {
printf("Invalid file entry!\n");
vgone(vp);
vput(vp);
brelse(bp);
*vpp = NULL;
return (ENOMEM);
}
size = UDF_FENTRY_SIZE + le32toh(fe->l_ea) + le32toh(fe->l_ad);
unode->fentry = malloc(size, M_UDFFENTRY, M_NOWAIT | M_ZERO);
if (unode->fentry == NULL) {
printf("Cannot allocate file entry block\n");
vgone(vp);
vput(vp);
brelse(bp);
*vpp = NULL;
return (ENOMEM);
}
bcopy(bp->b_data, unode->fentry, size);
brelse(bp);
bp = NULL;
switch (unode->fentry->icbtag.file_type) {
default:
vp->v_type = VBAD;
break;
case 4:
vp->v_type = VDIR;
break;
case 5:
vp->v_type = VREG;
break;
case 6:
vp->v_type = VBLK;
break;
case 7:
vp->v_type = VCHR;
break;
case 9:
vp->v_type = VFIFO;
vp->v_op = &udf_fifoops;
break;
case 10:
vp->v_type = VSOCK;
break;
case 12:
vp->v_type = VLNK;
break;
}
if (vp->v_type != VFIFO)
VN_LOCK_ASHARE(vp);
if (ino == udf_getid(&udfmp->root_icb))
vp->v_vflag |= VV_ROOT;
*vpp = vp;
return (0);
}
int
udf_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
{
struct buf *bp;
struct vnode *devvp;
struct umount *ump;
struct proc *p;
struct vnode *vp;
struct unode *up;
struct file_entry *fe;
int error, sector, size;
p = curproc;
bp = NULL;
*vpp = NULL;
ump = VFSTOUDFFS(mp);
/* See if we already have this in the cache */
if ((error = udf_hashlookup(ump, ino, LK_EXCLUSIVE, vpp)) != 0)
return (error);
if (*vpp != NULL)
return (0);
/*
* Allocate memory and check the tag id's before grabbing a new
* vnode, since it's hard to roll back if there is a problem.
*/
up = pool_get(&unode_pool, PR_WAITOK);
bzero(up, sizeof(struct unode));
/*
* Copy in the file entry. Per the spec, the size can only be 1 block.
*/
sector = ino;
devvp = ump->um_devvp;
udf_vat_map(ump, §or);
if ((error = RDSECTOR(devvp, sector, ump->um_bsize, &bp)) != 0) {
printf("Cannot read sector %d\n", sector);
pool_put(&unode_pool, up);
if (bp != NULL)
brelse(bp);
return (error);
}
fe = (struct file_entry *)bp->b_data;
if (udf_checktag(&fe->tag, TAGID_FENTRY)) {
printf("Invalid file entry!\n");
pool_put(&unode_pool, up);
brelse(bp);
return (ENOMEM);
}
size = UDF_FENTRY_SIZE + letoh32(fe->l_ea) + letoh32(fe->l_ad);
up->u_fentry = malloc(size, M_UDFFENTRY, M_NOWAIT);
if (up->u_fentry == NULL) {
pool_put(&unode_pool, up);
brelse(bp);
return (ENOMEM); /* Cannot allocate file entry block */
}
bcopy(bp->b_data, up->u_fentry, size);
brelse(bp);
bp = NULL;
if ((error = udf_allocv(mp, &vp, p))) {
free(up->u_fentry, M_UDFFENTRY);
pool_put(&unode_pool, up);
return (error); /* Error from udf_allocv() */
}
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);
/*
* udf_hashins() will lock the vnode for us.
*/
udf_hashins(up);
switch (up->u_fentry->icbtag.file_type) {
default:
vp->v_type = VBAD;
break;
case UDF_ICB_TYPE_DIR:
vp->v_type = VDIR;
break;
case UDF_ICB_TYPE_FILE:
vp->v_type = VREG;
break;
case UDF_ICB_TYPE_BLKDEV:
vp->v_type = VBLK;
break;
case UDF_ICB_TYPE_CHRDEV:
vp->v_type = VCHR;
break;
case UDF_ICB_TYPE_FIFO:
vp->v_type = VFIFO;
break;
case UDF_ICB_TYPE_SOCKET:
vp->v_type = VSOCK;
break;
case UDF_ICB_TYPE_SYMLINK:
vp->v_type = VLNK;
break;
case UDF_ICB_TYPE_VAT_150:
vp->v_type = VREG;
break;
}
*vpp = vp;
return (0);
}
