int
adosfs_unmount(struct mount *mp, int mntflags)
{
struct adosfsmount *amp;
int error, flags;
flags = 0;
if (mntflags & MNT_FORCE)
flags |= FORCECLOSE;
if ((error = vflush(mp, NULLVP, flags)) != 0)
return (error);
amp = VFSTOADOSFS(mp);
if (amp->devvp->v_type != VBAD)
spec_node_setmountedfs(amp->devvp, NULL);
vn_lock(amp->devvp, LK_EXCLUSIVE | LK_RETRY);
error = VOP_CLOSE(amp->devvp, FREAD, NOCRED);
vput(amp->devvp);
if (amp->bitmap) {
size_t bitmap_sz = ((amp->numblks + 31) / 32) *
sizeof(*amp->bitmap);
kmem_free(amp->bitmap, bitmap_sz);
}
kmem_free(amp, sizeof(*amp));
mp->mnt_data = NULL;
mp->mnt_flag &= ~MNT_LOCAL;
return (error);
}
/*
* unmount system call
*/
int
ext2fs_unmount(struct mount *mp, int mntflags)
{
struct ufsmount *ump;
struct m_ext2fs *fs;
int error, flags;
flags = 0;
if (mntflags & MNT_FORCE)
flags |= FORCECLOSE;
if ((error = ext2fs_flushfiles(mp, flags)) != 0)
return error;
ump = VFSTOUFS(mp);
fs = ump->um_e2fs;
if (fs->e2fs_ronly == 0 &&
ext2fs_cgupdate(ump, MNT_WAIT) == 0 &&
(fs->e2fs.e2fs_state & E2FS_ERRORS) == 0) {
fs->e2fs.e2fs_state = E2FS_ISCLEAN;
(void) ext2fs_sbupdate(ump, MNT_WAIT);
}
if (ump->um_devvp->v_type != VBAD)
spec_node_setmountedfs(ump->um_devvp, NULL);
vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
error = VOP_CLOSE(ump->um_devvp, fs->e2fs_ronly ? FREAD : FREAD|FWRITE,
NOCRED);
vput(ump->um_devvp);
kmem_free(fs->e2fs_gd, fs->e2fs_ngdb * fs->e2fs_bsize);
kmem_free(fs, sizeof(*fs));
kmem_free(ump, sizeof(*ump));
mp->mnt_data = NULL;
mp->mnt_flag &= ~MNT_LOCAL;
return error;
}
/*
* Unmount the filesystem described by mp.
*/
int
msdosfs_unmount(struct mount *mp, int mntflags)
{
struct msdosfsmount *pmp;
int error, flags;
flags = 0;
if (mntflags & MNT_FORCE)
flags |= FORCECLOSE;
if ((error = vflush(mp, NULLVP, flags)) != 0)
return (error);
pmp = VFSTOMSDOSFS(mp);
if (pmp->pm_devvp->v_type != VBAD)
spec_node_setmountedfs(pmp->pm_devvp, NULL);
#ifdef MSDOSFS_DEBUG
{
struct vnode *vp = pmp->pm_devvp;
printf("msdosfs_umount(): just before calling VOP_CLOSE()\n");
printf("flag %08x, usecount %d, writecount %d, holdcnt %d\n",
vp->v_vflag | vp->v_iflag | vp->v_uflag, vp->v_usecount,
vp->v_writecount, vp->v_holdcnt);
printf("mount %p, op %p\n",
vp->v_mount, vp->v_op);
printf("freef %p, freeb %p, mount %p\n",
vp->v_freelist.tqe_next, vp->v_freelist.tqe_prev,
vp->v_mount);
printf("cleanblkhd %p, dirtyblkhd %p, numoutput %d, type %d\n",
vp->v_cleanblkhd.lh_first,
vp->v_dirtyblkhd.lh_first,
vp->v_numoutput, vp->v_type);
printf("union %p, tag %d, data[0] %08x, data[1] %08x\n",
vp->v_socket, vp->v_tag,
((u_int *)vp->v_data)[0],
((u_int *)vp->v_data)[1]);
}
#endif
vn_lock(pmp->pm_devvp, LK_EXCLUSIVE | LK_RETRY);
(void) VOP_CLOSE(pmp->pm_devvp,
pmp->pm_flags & MSDOSFSMNT_RONLY ? FREAD : FREAD|FWRITE, NOCRED);
vput(pmp->pm_devvp);
msdosfs_fh_destroy(pmp);
free(pmp->pm_inusemap, M_MSDOSFSFAT);
free(pmp, M_MSDOSFSMNT);
mp->mnt_data = NULL;
mp->mnt_flag &= ~MNT_LOCAL;
fstrans_unmount(mp);
return (0);
}
/*
* unmount system call
*/
int
cd9660_unmount(struct mount *mp, int mntflags)
{
struct iso_mnt *isomp;
int error, flags = 0;
if (mntflags & MNT_FORCE)
flags |= FORCECLOSE;
if ((error = vflush(mp, NULLVP, flags)) != 0)
return (error);
isomp = VFSTOISOFS(mp);
if (isomp->im_devvp->v_type != VBAD)
spec_node_setmountedfs(isomp->im_devvp, NULL);
vn_lock(isomp->im_devvp, LK_EXCLUSIVE | LK_RETRY);
error = VOP_CLOSE(isomp->im_devvp, FREAD, NOCRED);
vput(isomp->im_devvp);
free(isomp, M_ISOFSMNT);
mp->mnt_data = NULL;
mp->mnt_flag &= ~MNT_LOCAL;
return (error);
}
int
msdosfs_mountfs(struct vnode *devvp, struct mount *mp, struct lwp *l, struct msdosfs_args *argp)
{
struct msdosfsmount *pmp;
struct buf *bp;
dev_t dev = devvp->v_rdev;
union bootsector *bsp;
struct byte_bpb33 *b33;
struct byte_bpb50 *b50;
struct byte_bpb710 *b710;
uint8_t SecPerClust;
int ronly, error, tmp;
int bsize;
uint64_t psize;
unsigned secsize;
/* Flush out any old buffers remaining from a previous use. */
if ((error = vinvalbuf(devvp, V_SAVE, l->l_cred, l, 0, 0)) != 0)
return (error);
ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
bp = NULL; /* both used in error_exit */
pmp = NULL;
error = fstrans_mount(mp);
if (error)
goto error_exit;
error = getdisksize(devvp, &psize, &secsize);
if (error) {
if (argp->flags & MSDOSFSMNT_GEMDOSFS)
goto error_exit;
/* ok, so it failed. we most likely don't need the info */
secsize = DEV_BSIZE;
psize = 0;
error = 0;
}
if (argp->flags & MSDOSFSMNT_GEMDOSFS) {
bsize = secsize;
if (bsize != 512) {
DPRINTF(("Invalid block bsize %d for GEMDOS\n", bsize));
error = EINVAL;
goto error_exit;
}
} else
bsize = 0;
/*
* Read the boot sector of the filesystem, and then check the
* boot signature. If not a dos boot sector then error out.
*/
if ((error = bread(devvp, 0, secsize, NOCRED, 0, &bp)) != 0)
goto error_exit;
bsp = (union bootsector *)bp->b_data;
b33 = (struct byte_bpb33 *)bsp->bs33.bsBPB;
b50 = (struct byte_bpb50 *)bsp->bs50.bsBPB;
b710 = (struct byte_bpb710 *)bsp->bs710.bsBPB;
if (!(argp->flags & MSDOSFSMNT_GEMDOSFS)) {
if (bsp->bs50.bsBootSectSig0 != BOOTSIG0
|| bsp->bs50.bsBootSectSig1 != BOOTSIG1) {
DPRINTF(("bootsig0 %d bootsig1 %d\n",
bsp->bs50.bsBootSectSig0,
bsp->bs50.bsBootSectSig1));
error = EINVAL;
goto error_exit;
}
}
pmp = malloc(sizeof *pmp, M_MSDOSFSMNT, M_WAITOK);
memset(pmp, 0, sizeof *pmp);
pmp->pm_mountp = mp;
/*
* Compute several useful quantities from the bpb in the
* bootsector. Copy in the dos 5 variant of the bpb then fix up
* the fields that are different between dos 5 and dos 3.3.
*/
SecPerClust = b50->bpbSecPerClust;
pmp->pm_BytesPerSec = getushort(b50->bpbBytesPerSec);
pmp->pm_ResSectors = getushort(b50->bpbResSectors);
pmp->pm_FATs = b50->bpbFATs;
pmp->pm_RootDirEnts = getushort(b50->bpbRootDirEnts);
pmp->pm_Sectors = getushort(b50->bpbSectors);
pmp->pm_FATsecs = getushort(b50->bpbFATsecs);
pmp->pm_SecPerTrack = getushort(b50->bpbSecPerTrack);
pmp->pm_Heads = getushort(b50->bpbHeads);
pmp->pm_Media = b50->bpbMedia;
if (!(argp->flags & MSDOSFSMNT_GEMDOSFS)) {
/* XXX - We should probably check more values here */
if (!pmp->pm_BytesPerSec || !SecPerClust
|| pmp->pm_SecPerTrack > 63) {
DPRINTF(("bytespersec %d secperclust %d "
"secpertrack %d\n",
pmp->pm_BytesPerSec, SecPerClust,
pmp->pm_SecPerTrack));
error = EINVAL;
goto error_exit;
}
}
if (pmp->pm_Sectors == 0) {
pmp->pm_HiddenSects = getulong(b50->bpbHiddenSecs);
pmp->pm_HugeSectors = getulong(b50->bpbHugeSectors);
} else {
pmp->pm_HiddenSects = getushort(b33->bpbHiddenSecs);
pmp->pm_HugeSectors = pmp->pm_Sectors;
}
if (pmp->pm_RootDirEnts == 0) {
unsigned short vers = getushort(b710->bpbFSVers);
/*
* Some say that bsBootSectSig[23] must be zero, but
* Windows does not require this and some digital cameras
* do not set these to zero. Therefore, do not insist.
*/
if (pmp->pm_Sectors || pmp->pm_FATsecs || vers) {
DPRINTF(("sectors %d fatsecs %lu vers %d\n",
pmp->pm_Sectors, pmp->pm_FATsecs, vers));
error = EINVAL;
goto error_exit;
}
pmp->pm_fatmask = FAT32_MASK;
pmp->pm_fatmult = 4;
pmp->pm_fatdiv = 1;
pmp->pm_FATsecs = getulong(b710->bpbBigFATsecs);
/* mirrorring is enabled if the FATMIRROR bit is not set */
if ((getushort(b710->bpbExtFlags) & FATMIRROR) == 0)
pmp->pm_flags |= MSDOSFS_FATMIRROR;
else
pmp->pm_curfat = getushort(b710->bpbExtFlags) & FATNUM;
} else
pmp->pm_flags |= MSDOSFS_FATMIRROR;
if (argp->flags & MSDOSFSMNT_GEMDOSFS) {
if (FAT32(pmp)) {
DPRINTF(("FAT32 for GEMDOS\n"));
/*
* GEMDOS doesn't know FAT32.
*/
error = EINVAL;
goto error_exit;
}
/*
* Check a few values (could do some more):
* - logical sector size: power of 2, >= block size
* - sectors per cluster: power of 2, >= 1
* - number of sectors: >= 1, <= size of partition
*/
if ( (SecPerClust == 0)
|| (SecPerClust & (SecPerClust - 1))
|| (pmp->pm_BytesPerSec < bsize)
|| (pmp->pm_BytesPerSec & (pmp->pm_BytesPerSec - 1))
|| (pmp->pm_HugeSectors == 0)
|| (pmp->pm_HugeSectors * (pmp->pm_BytesPerSec / bsize)
> psize)) {
DPRINTF(("consistency checks for GEMDOS\n"));
error = EINVAL;
goto error_exit;
}
/*
* XXX - Many parts of the msdosfs driver seem to assume that
* the number of bytes per logical sector (BytesPerSec) will
* always be the same as the number of bytes per disk block
* Let's pretend it is.
*/
tmp = pmp->pm_BytesPerSec / bsize;
pmp->pm_BytesPerSec = bsize;
pmp->pm_HugeSectors *= tmp;
pmp->pm_HiddenSects *= tmp;
pmp->pm_ResSectors *= tmp;
pmp->pm_Sectors *= tmp;
pmp->pm_FATsecs *= tmp;
SecPerClust *= tmp;
}
/* Check that fs has nonzero FAT size */
if (pmp->pm_FATsecs == 0) {
DPRINTF(("FATsecs is 0\n"));
error = EINVAL;
goto error_exit;
}
pmp->pm_fatblk = pmp->pm_ResSectors;
if (FAT32(pmp)) {
pmp->pm_rootdirblk = getulong(b710->bpbRootClust);
pmp->pm_firstcluster = pmp->pm_fatblk
+ (pmp->pm_FATs * pmp->pm_FATsecs);
pmp->pm_fsinfo = getushort(b710->bpbFSInfo);
} else {
pmp->pm_rootdirblk = pmp->pm_fatblk +
(pmp->pm_FATs * pmp->pm_FATsecs);
pmp->pm_rootdirsize = (pmp->pm_RootDirEnts * sizeof(struct direntry)
+ pmp->pm_BytesPerSec - 1)
/ pmp->pm_BytesPerSec;/* in sectors */
pmp->pm_firstcluster = pmp->pm_rootdirblk + pmp->pm_rootdirsize;
}
pmp->pm_nmbrofclusters = (pmp->pm_HugeSectors - pmp->pm_firstcluster) /
SecPerClust;
pmp->pm_maxcluster = pmp->pm_nmbrofclusters + 1;
pmp->pm_fatsize = pmp->pm_FATsecs * pmp->pm_BytesPerSec;
if (argp->flags & MSDOSFSMNT_GEMDOSFS) {
if (pmp->pm_nmbrofclusters <= (0xff0 - 2)) {
pmp->pm_fatmask = FAT12_MASK;
pmp->pm_fatmult = 3;
pmp->pm_fatdiv = 2;
} else {
pmp->pm_fatmask = FAT16_MASK;
pmp->pm_fatmult = 2;
pmp->pm_fatdiv = 1;
}
} else if (pmp->pm_fatmask == 0) {
if (pmp->pm_maxcluster
<= ((CLUST_RSRVD - CLUST_FIRST) & FAT12_MASK)) {
/*
* This will usually be a floppy disk. This size makes
* sure that one FAT entry will not be split across
* multiple blocks.
*/
pmp->pm_fatmask = FAT12_MASK;
pmp->pm_fatmult = 3;
pmp->pm_fatdiv = 2;
} else {
pmp->pm_fatmask = FAT16_MASK;
pmp->pm_fatmult = 2;
pmp->pm_fatdiv = 1;
}
}
if (FAT12(pmp))
pmp->pm_fatblocksize = 3 * pmp->pm_BytesPerSec;
else
pmp->pm_fatblocksize = MAXBSIZE;
pmp->pm_fatblocksec = pmp->pm_fatblocksize / pmp->pm_BytesPerSec;
pmp->pm_bnshift = ffs(pmp->pm_BytesPerSec) - 1;
/*
* Compute mask and shift value for isolating cluster relative byte
* offsets and cluster numbers from a file offset.
*/
pmp->pm_bpcluster = SecPerClust * pmp->pm_BytesPerSec;
pmp->pm_crbomask = pmp->pm_bpcluster - 1;
pmp->pm_cnshift = ffs(pmp->pm_bpcluster) - 1;
/*
* Check for valid cluster size
* must be a power of 2
*/
if (pmp->pm_bpcluster ^ (1 << pmp->pm_cnshift)) {
DPRINTF(("bpcluster %lu cnshift %lu\n",
pmp->pm_bpcluster, pmp->pm_cnshift));
error = EINVAL;
goto error_exit;
}
/*
* Cluster size must be within limit of MAXBSIZE.
* Many FAT filesystems will not have clusters larger than
* 32KiB due to limits in Windows versions before Vista.
*/
if (pmp->pm_bpcluster > MAXBSIZE) {
DPRINTF(("bpcluster %lu > MAXBSIZE %d\n",
pmp->pm_bpcluster, MAXBSIZE));
error = EINVAL;
goto error_exit;
}
/*
* Release the bootsector buffer.
*/
brelse(bp, BC_AGE);
bp = NULL;
/*
* Check FSInfo.
*/
if (pmp->pm_fsinfo) {
struct fsinfo *fp;
/*
* XXX If the fsinfo block is stored on media with
* 2KB or larger sectors, is the fsinfo structure
* padded at the end or in the middle?
*/
if ((error = bread(devvp, de_bn2kb(pmp, pmp->pm_fsinfo),
pmp->pm_BytesPerSec, NOCRED, 0, &bp)) != 0)
goto error_exit;
fp = (struct fsinfo *)bp->b_data;
if (!memcmp(fp->fsisig1, "RRaA", 4)
&& !memcmp(fp->fsisig2, "rrAa", 4)
&& !memcmp(fp->fsisig3, "\0\0\125\252", 4)
&& !memcmp(fp->fsisig4, "\0\0\125\252", 4))
pmp->pm_nxtfree = getulong(fp->fsinxtfree);
else
pmp->pm_fsinfo = 0;
brelse(bp, 0);
bp = NULL;
}
/*
* Check and validate (or perhaps invalidate?) the fsinfo structure?
* XXX
*/
if (pmp->pm_fsinfo) {
if ((pmp->pm_nxtfree == 0xffffffffUL) ||
(pmp->pm_nxtfree > pmp->pm_maxcluster))
pmp->pm_fsinfo = 0;
}
/*
* Allocate memory for the bitmap of allocated clusters, and then
* fill it in.
*/
pmp->pm_inusemap = malloc(((pmp->pm_maxcluster + N_INUSEBITS)
/ N_INUSEBITS)
* sizeof(*pmp->pm_inusemap),
M_MSDOSFSFAT, M_WAITOK);
/*
* fillinusemap() needs pm_devvp.
*/
pmp->pm_dev = dev;
pmp->pm_devvp = devvp;
/*
* Have the inuse map filled in.
*/
if ((error = fillinusemap(pmp)) != 0) {
DPRINTF(("fillinusemap %d\n", error));
goto error_exit;
}
/*
* If they want FAT updates to be synchronous then let them suffer
* the performance degradation in exchange for the on disk copy of
* the FAT being correct just about all the time. I suppose this
* would be a good thing to turn on if the kernel is still flakey.
*/
if (mp->mnt_flag & MNT_SYNCHRONOUS)
pmp->pm_flags |= MSDOSFSMNT_WAITONFAT;
/*
* Finish up.
*/
if (ronly)
pmp->pm_flags |= MSDOSFSMNT_RONLY;
else
pmp->pm_fmod = 1;
mp->mnt_data = pmp;
mp->mnt_stat.f_fsidx.__fsid_val[0] = (long)dev;
mp->mnt_stat.f_fsidx.__fsid_val[1] = makefstype(MOUNT_MSDOS);
mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0];
mp->mnt_stat.f_namemax = MSDOSFS_NAMEMAX(pmp);
mp->mnt_flag |= MNT_LOCAL;
mp->mnt_dev_bshift = pmp->pm_bnshift;
mp->mnt_fs_bshift = pmp->pm_cnshift;
/*
* If we ever do quotas for DOS filesystems this would be a place
* to fill in the info in the msdosfsmount structure. You dolt,
* quotas on dos filesystems make no sense because files have no
* owners on dos filesystems. of course there is some empty space
* in the directory entry where we could put uid's and gid's.
*/
spec_node_setmountedfs(devvp, mp);
return (0);
error_exit:
fstrans_unmount(mp);
if (bp)
brelse(bp, BC_AGE);
if (pmp) {
if (pmp->pm_inusemap)
free(pmp->pm_inusemap, M_MSDOSFSFAT);
free(pmp, M_MSDOSFSMNT);
mp->mnt_data = NULL;
}
return (error);
}
/*
* Common code for mount and mountroot
*/
int
ext2fs_mountfs(struct vnode *devvp, struct mount *mp)
{
struct lwp *l = curlwp;
struct ufsmount *ump;
struct buf *bp;
struct ext2fs *fs;
struct m_ext2fs *m_fs;
dev_t dev;
int error, i, ronly;
kauth_cred_t cred;
dev = devvp->v_rdev;
cred = l->l_cred;
/* Flush out any old buffers remaining from a previous use. */
vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
error = vinvalbuf(devvp, V_SAVE, cred, l, 0, 0);
VOP_UNLOCK(devvp);
if (error)
return error;
ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
bp = NULL;
ump = NULL;
/* Read the superblock from disk, and swap it directly. */
error = bread(devvp, SBLOCK, SBSIZE, 0, &bp);
if (error)
goto out;
fs = (struct ext2fs *)bp->b_data;
m_fs = kmem_zalloc(sizeof(struct m_ext2fs), KM_SLEEP);
e2fs_sbload(fs, &m_fs->e2fs);
brelse(bp, 0);
bp = NULL;
/* Once swapped, validate and fill in the superblock. */
error = ext2fs_sbfill(m_fs, ronly);
if (error) {
kmem_free(m_fs, sizeof(struct m_ext2fs));
goto out;
}
m_fs->e2fs_ronly = ronly;
ump = kmem_zalloc(sizeof(*ump), KM_SLEEP);
ump->um_fstype = UFS1;
ump->um_ops = &ext2fs_ufsops;
ump->um_e2fs = m_fs;
if (ronly == 0) {
if (m_fs->e2fs.e2fs_state == E2FS_ISCLEAN)
m_fs->e2fs.e2fs_state = 0;
else
m_fs->e2fs.e2fs_state = E2FS_ERRORS;
m_fs->e2fs_fmod = 1;
}
/* XXX: should be added in ext2fs_sbfill()? */
m_fs->e2fs_gd = kmem_alloc(m_fs->e2fs_ngdb * m_fs->e2fs_bsize, KM_SLEEP);
for (i = 0; i < m_fs->e2fs_ngdb; i++) {
error = bread(devvp,
EXT2_FSBTODB(m_fs, m_fs->e2fs.e2fs_first_dblock +
1 /* superblock */ + i),
m_fs->e2fs_bsize, 0, &bp);
if (error) {
kmem_free(m_fs->e2fs_gd,
m_fs->e2fs_ngdb * m_fs->e2fs_bsize);
goto out;
}
e2fs_cgload((struct ext2_gd *)bp->b_data,
&m_fs->e2fs_gd[
i * m_fs->e2fs_bsize / sizeof(struct ext2_gd)],
m_fs->e2fs_bsize);
brelse(bp, 0);
bp = NULL;
}
error = ext2fs_cg_verify_and_initialize(devvp, m_fs, ronly);
if (error) {
kmem_free(m_fs->e2fs_gd, m_fs->e2fs_ngdb * m_fs->e2fs_bsize);
goto out;
}
mp->mnt_data = ump;
mp->mnt_stat.f_fsidx.__fsid_val[0] = (long)dev;
mp->mnt_stat.f_fsidx.__fsid_val[1] = makefstype(MOUNT_EXT2FS);
mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0];
mp->mnt_stat.f_namemax = EXT2FS_MAXNAMLEN;
mp->mnt_flag |= MNT_LOCAL;
mp->mnt_dev_bshift = DEV_BSHIFT; /* XXX */
mp->mnt_fs_bshift = m_fs->e2fs_bshift;
mp->mnt_iflag |= IMNT_DTYPE;
ump->um_flags = 0;
ump->um_mountp = mp;
ump->um_dev = dev;
ump->um_devvp = devvp;
ump->um_nindir = EXT2_NINDIR(m_fs);
ump->um_lognindir = ffs(EXT2_NINDIR(m_fs)) - 1;
ump->um_bptrtodb = m_fs->e2fs_fsbtodb;
ump->um_seqinc = 1; /* no frags */
ump->um_maxsymlinklen = EXT2_MAXSYMLINKLEN;
ump->um_dirblksiz = m_fs->e2fs_bsize;
ump->um_maxfilesize = ((uint64_t)0x80000000 * m_fs->e2fs_bsize - 1);
spec_node_setmountedfs(devvp, mp);
return 0;
out:
if (bp != NULL)
brelse(bp, 0);
if (ump) {
kmem_free(ump->um_e2fs, sizeof(struct m_ext2fs));
kmem_free(ump, sizeof(*ump));
mp->mnt_data = NULL;
}
return error;
}
/*
* Common code for mount and mountroot
*/
int
ext2fs_mountfs(struct vnode *devvp, struct mount *mp)
{
struct lwp *l = curlwp;
struct ufsmount *ump;
struct buf *bp;
struct ext2fs *fs;
struct m_ext2fs *m_fs;
dev_t dev;
int error, i, ronly;
kauth_cred_t cred;
dev = devvp->v_rdev;
cred = l ? l->l_cred : NOCRED;
/* Flush out any old buffers remaining from a previous use. */
vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
error = vinvalbuf(devvp, V_SAVE, cred, l, 0, 0);
VOP_UNLOCK(devvp);
if (error)
return (error);
ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
bp = NULL;
ump = NULL;
#ifdef DEBUG_EXT2
printf("ext2 sb size: %zu\n", sizeof(struct ext2fs));
#endif
error = bread(devvp, SBLOCK, SBSIZE, cred, 0, &bp);
if (error)
goto out;
fs = (struct ext2fs *)bp->b_data;
error = ext2fs_checksb(fs, ronly);
if (error)
goto out;
ump = kmem_zalloc(sizeof(*ump), KM_SLEEP);
ump->um_fstype = UFS1;
ump->um_ops = &ext2fs_ufsops;
ump->um_e2fs = kmem_zalloc(sizeof(struct m_ext2fs), KM_SLEEP);
e2fs_sbload((struct ext2fs *)bp->b_data, &ump->um_e2fs->e2fs);
brelse(bp, 0);
bp = NULL;
m_fs = ump->um_e2fs;
m_fs->e2fs_ronly = ronly;
#ifdef DEBUG_EXT2
printf("ext2 ino size %zu\n", EXT2_DINODE_SIZE(m_fs));
#endif
if (ronly == 0) {
if (m_fs->e2fs.e2fs_state == E2FS_ISCLEAN)
m_fs->e2fs.e2fs_state = 0;
else
m_fs->e2fs.e2fs_state = E2FS_ERRORS;
m_fs->e2fs_fmod = 1;
}
/* compute dynamic sb infos */
m_fs->e2fs_ncg =
howmany(m_fs->e2fs.e2fs_bcount - m_fs->e2fs.e2fs_first_dblock,
m_fs->e2fs.e2fs_bpg);
m_fs->e2fs_fsbtodb = m_fs->e2fs.e2fs_log_bsize + LOG_MINBSIZE - DEV_BSHIFT;
m_fs->e2fs_bsize = MINBSIZE << m_fs->e2fs.e2fs_log_bsize;
m_fs->e2fs_bshift = LOG_MINBSIZE + m_fs->e2fs.e2fs_log_bsize;
m_fs->e2fs_qbmask = m_fs->e2fs_bsize - 1;
m_fs->e2fs_bmask = ~m_fs->e2fs_qbmask;
m_fs->e2fs_ngdb =
howmany(m_fs->e2fs_ncg, m_fs->e2fs_bsize / sizeof(struct ext2_gd));
m_fs->e2fs_ipb = m_fs->e2fs_bsize / EXT2_DINODE_SIZE(m_fs);
m_fs->e2fs_itpg = m_fs->e2fs.e2fs_ipg / m_fs->e2fs_ipb;
m_fs->e2fs_gd = kmem_alloc(m_fs->e2fs_ngdb * m_fs->e2fs_bsize, KM_SLEEP);
for (i = 0; i < m_fs->e2fs_ngdb; i++) {
error = bread(devvp ,
EXT2_FSBTODB(m_fs, m_fs->e2fs.e2fs_first_dblock +
1 /* superblock */ + i),
m_fs->e2fs_bsize, NOCRED, 0, &bp);
if (error) {
kmem_free(m_fs->e2fs_gd,
m_fs->e2fs_ngdb * m_fs->e2fs_bsize);
goto out;
}
e2fs_cgload((struct ext2_gd *)bp->b_data,
&m_fs->e2fs_gd[
i * m_fs->e2fs_bsize / sizeof(struct ext2_gd)],
m_fs->e2fs_bsize);
brelse(bp, 0);
bp = NULL;
}
mp->mnt_data = ump;
mp->mnt_stat.f_fsidx.__fsid_val[0] = (long)dev;
mp->mnt_stat.f_fsidx.__fsid_val[1] = makefstype(MOUNT_EXT2FS);
mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0];
mp->mnt_stat.f_namemax = EXT2FS_MAXNAMLEN;
mp->mnt_flag |= MNT_LOCAL;
mp->mnt_dev_bshift = DEV_BSHIFT; /* XXX */
mp->mnt_fs_bshift = m_fs->e2fs_bshift;
mp->mnt_iflag |= IMNT_DTYPE;
ump->um_flags = 0;
ump->um_mountp = mp;
ump->um_dev = dev;
ump->um_devvp = devvp;
ump->um_nindir = EXT2_NINDIR(m_fs);
ump->um_lognindir = ffs(EXT2_NINDIR(m_fs)) - 1;
ump->um_bptrtodb = m_fs->e2fs_fsbtodb;
ump->um_seqinc = 1; /* no frags */
ump->um_maxsymlinklen = EXT2_MAXSYMLINKLEN;
ump->um_dirblksiz = m_fs->e2fs_bsize;
ump->um_maxfilesize = ((uint64_t)0x80000000 * m_fs->e2fs_bsize - 1);
spec_node_setmountedfs(devvp, mp);
return (0);
out:
if (bp != NULL)
brelse(bp, 0);
if (ump) {
kmem_free(ump->um_e2fs, sizeof(struct m_ext2fs));
kmem_free(ump, sizeof(*ump));
mp->mnt_data = NULL;
}
return (error);
}
static int
ntfs_unmount(
struct mount *mp,
int mntflags)
{
struct lwp *l = curlwp;
struct ntfsmount *ntmp;
int error, ronly = 0, flags, i;
dprintf(("ntfs_unmount: unmounting...\n"));
ntmp = VFSTONTFS(mp);
flags = 0;
if(mntflags & MNT_FORCE)
flags |= FORCECLOSE;
dprintf(("ntfs_unmount: vflushing...\n"));
error = vflush(mp,NULLVP,flags | SKIPSYSTEM);
if (error) {
dprintf(("ntfs_unmount: vflush failed: %d\n",error));
return (error);
}
/* Check if only system vnodes are rest */
for(i=0;i<NTFS_SYSNODESNUM;i++)
if((ntmp->ntm_sysvn[i]) &&
(ntmp->ntm_sysvn[i]->v_usecount > 1)) return (EBUSY);
/* Dereference all system vnodes */
for(i=0;i<NTFS_SYSNODESNUM;i++)
if(ntmp->ntm_sysvn[i]) vrele(ntmp->ntm_sysvn[i]);
/* vflush system vnodes */
error = vflush(mp,NULLVP,flags);
if (error) {
panic("ntfs_unmount: vflush failed(sysnodes): %d\n",error);
}
/* Check if the type of device node isn't VBAD before
* touching v_specinfo. If the device vnode is revoked, the
* field is NULL and touching it causes null pointer derefercence.
*/
if (ntmp->ntm_devvp->v_type != VBAD)
spec_node_setmountedfs(ntmp->ntm_devvp, NULL);
error = vinvalbuf(ntmp->ntm_devvp, V_SAVE, NOCRED, l, 0, 0);
KASSERT(error == 0);
/* lock the device vnode before calling VOP_CLOSE() */
vn_lock(ntmp->ntm_devvp, LK_EXCLUSIVE | LK_RETRY);
error = VOP_CLOSE(ntmp->ntm_devvp, ronly ? FREAD : FREAD|FWRITE,
NOCRED);
KASSERT(error == 0);
VOP_UNLOCK(ntmp->ntm_devvp);
vrele(ntmp->ntm_devvp);
/* free the toupper table, if this has been last mounted ntfs volume */
ntfs_toupper_unuse();
dprintf(("ntfs_umount: freeing memory...\n"));
mp->mnt_data = NULL;
mp->mnt_flag &= ~MNT_LOCAL;
free(ntmp->ntm_ad, M_NTFSMNT);
free(ntmp, M_NTFSMNT);
return (0);
}
/*
* Common code for mount and mountroot
*/
int
ntfs_mountfs(struct vnode *devvp, struct mount *mp, struct ntfs_args *argsp, struct lwp *l)
{
struct buf *bp;
struct ntfsmount *ntmp;
dev_t dev = devvp->v_rdev;
int error, i;
struct vnode *vp;
ntmp = NULL;
/*
* Flush out any old buffers remaining from a previous use.
*/
vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
error = vinvalbuf(devvp, V_SAVE, l->l_cred, l, 0, 0);
VOP_UNLOCK(devvp);
if (error)
return (error);
bp = NULL;
error = bread(devvp, BBLOCK, BBSIZE, NOCRED, 0, &bp);
if (error)
goto out;
ntmp = malloc( sizeof *ntmp, M_NTFSMNT, M_WAITOK|M_ZERO);
memcpy( &ntmp->ntm_bootfile, bp->b_data, sizeof(struct bootfile) );
brelse( bp , 0 );
bp = NULL;
if (strncmp(ntmp->ntm_bootfile.bf_sysid, NTFS_BBID, NTFS_BBIDLEN)) {
error = EINVAL;
dprintf(("ntfs_mountfs: invalid boot block\n"));
goto out;
}
{
int8_t cpr = ntmp->ntm_mftrecsz;
if( cpr > 0 )
ntmp->ntm_bpmftrec = ntmp->ntm_spc * cpr;
else
ntmp->ntm_bpmftrec = (1 << (-cpr)) / ntmp->ntm_bps;
}
dprintf(("ntfs_mountfs(): bps: %d, spc: %d, media: %x, mftrecsz: %d (%d sects)\n",
ntmp->ntm_bps,ntmp->ntm_spc,ntmp->ntm_bootfile.bf_media,
ntmp->ntm_mftrecsz,ntmp->ntm_bpmftrec));
dprintf(("ntfs_mountfs(): mftcn: 0x%x|0x%x\n",
(u_int32_t)ntmp->ntm_mftcn,(u_int32_t)ntmp->ntm_mftmirrcn));
ntmp->ntm_mountp = mp;
ntmp->ntm_dev = dev;
ntmp->ntm_devvp = devvp;
ntmp->ntm_uid = argsp->uid;
ntmp->ntm_gid = argsp->gid;
ntmp->ntm_mode = argsp->mode;
ntmp->ntm_flag = argsp->flag;
mp->mnt_data = ntmp;
/* set file name encode/decode hooks XXX utf-8 only for now */
ntmp->ntm_wget = ntfs_utf8_wget;
ntmp->ntm_wput = ntfs_utf8_wput;
ntmp->ntm_wcmp = ntfs_utf8_wcmp;
dprintf(("ntfs_mountfs(): case-%s,%s uid: %d, gid: %d, mode: %o\n",
(ntmp->ntm_flag & NTFS_MFLAG_CASEINS)?"insens.":"sens.",
(ntmp->ntm_flag & NTFS_MFLAG_ALLNAMES)?" allnames,":"",
ntmp->ntm_uid, ntmp->ntm_gid, ntmp->ntm_mode));
/*
* We read in some system nodes to do not allow
* reclaim them and to have everytime access to them.
*/
{
int pi[3] = { NTFS_MFTINO, NTFS_ROOTINO, NTFS_BITMAPINO };
for (i=0; i<3; i++) {
error = VFS_VGET(mp, pi[i], &(ntmp->ntm_sysvn[pi[i]]));
if(error)
goto out1;
ntmp->ntm_sysvn[pi[i]]->v_vflag |= VV_SYSTEM;
vref(ntmp->ntm_sysvn[pi[i]]);
vput(ntmp->ntm_sysvn[pi[i]]);
}
}
/* read the Unicode lowercase --> uppercase translation table,
* if necessary */
if ((error = ntfs_toupper_use(mp, ntmp)))
goto out1;
/*
* Scan $BitMap and count free clusters
*/
error = ntfs_calccfree(ntmp, &ntmp->ntm_cfree);
if(error)
goto out1;
/*
* Read and translate to internal format attribute
* definition file.
*/
{
int num,j;
struct attrdef ad;
/* Open $AttrDef */
error = VFS_VGET(mp, NTFS_ATTRDEFINO, &vp );
if(error)
goto out1;
/* Count valid entries */
for(num=0;;num++) {
error = ntfs_readattr(ntmp, VTONT(vp),
NTFS_A_DATA, NULL,
num * sizeof(ad), sizeof(ad),
&ad, NULL);
if (error)
goto out1;
if (ad.ad_name[0] == 0)
break;
}
/* Alloc memory for attribute definitions */
ntmp->ntm_ad = (struct ntvattrdef *) malloc(
num * sizeof(struct ntvattrdef),
M_NTFSMNT, M_WAITOK);
ntmp->ntm_adnum = num;
/* Read them and translate */
for(i=0;i<num;i++){
error = ntfs_readattr(ntmp, VTONT(vp),
NTFS_A_DATA, NULL,
i * sizeof(ad), sizeof(ad),
&ad, NULL);
if (error)
goto out1;
j = 0;
do {
ntmp->ntm_ad[i].ad_name[j] = ad.ad_name[j];
} while(ad.ad_name[j++]);
ntmp->ntm_ad[i].ad_namelen = j - 1;
ntmp->ntm_ad[i].ad_type = ad.ad_type;
}
vput(vp);
}
mp->mnt_stat.f_fsidx.__fsid_val[0] = dev;
mp->mnt_stat.f_fsidx.__fsid_val[1] = makefstype(MOUNT_NTFS);
mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0];
mp->mnt_stat.f_namemax = NTFS_MAXFILENAME;
mp->mnt_flag |= MNT_LOCAL;
spec_node_setmountedfs(devvp, mp);
return (0);
out1:
for(i=0;i<NTFS_SYSNODESNUM;i++)
if(ntmp->ntm_sysvn[i]) vrele(ntmp->ntm_sysvn[i]);
if (vflush(mp,NULLVP,0)) {
dprintf(("ntfs_mountfs: vflush failed\n"));
}
out:
spec_node_setmountedfs(devvp, NULL);
if (bp)
brelse(bp, 0);
if (error) {
if (ntmp) {
if (ntmp->ntm_ad)
free(ntmp->ntm_ad, M_NTFSMNT);
free(ntmp, M_NTFSMNT);
}
}
return (error);
}
static int
chfs_unmount(struct mount *mp, int mntflags)
{
int flags = 0, i = 0;
struct ufsmount *ump;
struct chfs_mount *chmp;
if (mntflags & MNT_FORCE)
flags |= FORCECLOSE;
dbg("[START]\n");
ump = VFSTOUFS(mp);
chmp = ump->um_chfs;
/* Stop GC. */
chfs_gc_thread_stop(chmp);
/* Flush everyt buffer. */
(void)vflush(mp, NULLVP, flags);
if (chmp->chm_wbuf_len) {
mutex_enter(&chmp->chm_lock_mountfields);
chfs_flush_pending_wbuf(chmp);
mutex_exit(&chmp->chm_lock_mountfields);
}
/* Free node references. */
for (i = 0; i < chmp->chm_ebh->peb_nr; i++) {
chfs_free_node_refs(&chmp->chm_blocks[i]);
}
/* Destroy vnode cache hashtable. */
chfs_vnocache_hash_destroy(chmp->chm_vnocache_hash);
/* Close eraseblock handler. */
ebh_close(chmp->chm_ebh);
/* Destroy mutexes. */
rw_destroy(&chmp->chm_lock_wbuf);
mutex_destroy(&chmp->chm_lock_vnocache);
mutex_destroy(&chmp->chm_lock_sizes);
mutex_destroy(&chmp->chm_lock_mountfields);
/* Unmount UFS. */
if (ump->um_devvp->v_type != VBAD) {
spec_node_setmountedfs(ump->um_devvp, NULL);
}
vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
(void)VOP_CLOSE(ump->um_devvp, FREAD|FWRITE, NOCRED);
vput(ump->um_devvp);
mutex_destroy(&ump->um_lock);
/* Everything done. */
kmem_free(ump, sizeof(struct ufsmount));
mp->mnt_data = NULL;
mp->mnt_flag &= ~MNT_LOCAL;
dbg("[END]\n");
return (0);
}
/* chfs_mountfs - init CHFS */
int
chfs_mountfs(struct vnode *devvp, struct mount *mp)
{
struct lwp *l = curlwp;
kauth_cred_t cred;
devmajor_t flash_major;
dev_t dev;
struct ufsmount* ump = NULL;
struct chfs_mount* chmp;
struct vnode *vp;
int err = 0;
dbg("mountfs()\n");
dev = devvp->v_rdev;
cred = l ? l->l_cred : NOCRED;
/* Flush out any old buffers remaining from a previous use. */
vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
err = vinvalbuf(devvp, V_SAVE, cred, l, 0, 0);
VOP_UNLOCK(devvp);
if (err)
return (err);
/* Setup device. */
flash_major = cdevsw_lookup_major(&flash_cdevsw);
if (devvp->v_type != VBLK)
err = ENOTBLK;
else if (bdevsw_lookup(dev) == NULL)
err = ENXIO;
else if (major(dev) != flash_major) {
dbg("major(dev): %d, flash_major: %d\n",
major(dev), flash_major);
err = ENODEV;
}
if (err) {
vrele(devvp);
return (err);
}
/* Connect CHFS to UFS. */
ump = kmem_zalloc(sizeof(struct ufsmount), KM_SLEEP);
ump->um_fstype = UFS1;
ump->um_chfs = kmem_zalloc(sizeof(struct chfs_mount), KM_SLEEP);
mutex_init(&ump->um_lock, MUTEX_DEFAULT, IPL_NONE);
chmp = ump->um_chfs;
/* Initialize erase block handler. */
chmp->chm_ebh = kmem_alloc(sizeof(struct chfs_ebh), KM_SLEEP);
dbg("[]opening flash: %u\n", (unsigned int)devvp->v_rdev);
err = ebh_open(chmp->chm_ebh, devvp->v_rdev);
if (err) {
dbg("error while opening flash\n");
goto fail;
}
//TODO check flash sizes
/* Initialize vnode cache's hashtable and eraseblock array. */
chmp->chm_gbl_version = 0;
chmp->chm_vnocache_hash = chfs_vnocache_hash_init();
chmp->chm_blocks = kmem_zalloc(chmp->chm_ebh->peb_nr *
sizeof(struct chfs_eraseblock), KM_SLEEP);
/* Initialize mutexes. */
mutex_init(&chmp->chm_lock_mountfields, MUTEX_DEFAULT, IPL_NONE);
mutex_init(&chmp->chm_lock_sizes, MUTEX_DEFAULT, IPL_NONE);
mutex_init(&chmp->chm_lock_vnocache, MUTEX_DEFAULT, IPL_NONE);
/* Initialize read/write contants. (from UFS) */
chmp->chm_fs_bmask = -4096;
chmp->chm_fs_bsize = 4096;
chmp->chm_fs_qbmask = 4095;
chmp->chm_fs_bshift = 12;
chmp->chm_fs_fmask = -2048;
chmp->chm_fs_qfmask = 2047;
/* Initialize writebuffer. */
chmp->chm_wbuf_pagesize = chmp->chm_ebh->flash_if->page_size;
dbg("wbuf size: %zu\n", chmp->chm_wbuf_pagesize);
chmp->chm_wbuf = kmem_alloc(chmp->chm_wbuf_pagesize, KM_SLEEP);
rw_init(&chmp->chm_lock_wbuf);
/* Initialize queues. */
TAILQ_INIT(&chmp->chm_free_queue);
TAILQ_INIT(&chmp->chm_clean_queue);
TAILQ_INIT(&chmp->chm_dirty_queue);
TAILQ_INIT(&chmp->chm_very_dirty_queue);
TAILQ_INIT(&chmp->chm_erasable_pending_wbuf_queue);
TAILQ_INIT(&chmp->chm_erase_pending_queue);
/* Initialize flash-specific constants. */
chfs_calc_trigger_levels(chmp);
/* Initialize sizes. */
chmp->chm_nr_free_blocks = 0;
chmp->chm_nr_erasable_blocks = 0;
chmp->chm_max_vno = 2;
chmp->chm_checked_vno = 2;
chmp->chm_unchecked_size = 0;
chmp->chm_used_size = 0;
chmp->chm_dirty_size = 0;
chmp->chm_wasted_size = 0;
chmp->chm_free_size = chmp->chm_ebh->eb_size * chmp->chm_ebh->peb_nr;
/* Build filesystem. */
err = chfs_build_filesystem(chmp);
if (err) {
/* Armageddon and return. */
chfs_vnocache_hash_destroy(chmp->chm_vnocache_hash);
ebh_close(chmp->chm_ebh);
err = EIO;
goto fail;
}
/* Initialize UFS. */
mp->mnt_data = ump;
mp->mnt_stat.f_fsidx.__fsid_val[0] = (long)dev;
mp->mnt_stat.f_fsidx.__fsid_val[1] = makefstype(MOUNT_CHFS);
mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0];
mp->mnt_stat.f_namemax = MAXNAMLEN;
mp->mnt_flag |= MNT_LOCAL;
mp->mnt_fs_bshift = PAGE_SHIFT;
mp->mnt_dev_bshift = DEV_BSHIFT;
mp->mnt_iflag |= IMNT_MPSAFE;
ump->um_flags = 0;
ump->um_mountp = mp;
ump->um_dev = dev;
ump->um_devvp = devvp;
ump->um_maxfilesize = 1048512 * 1024;
/* Allocate the root vnode. */
err = VFS_VGET(mp, CHFS_ROOTINO, &vp);
if (err) {
dbg("error: %d while allocating root node\n", err);
return err;
}
vput(vp);
/* Start GC. */
chfs_gc_thread_start(chmp);
mutex_enter(&chmp->chm_lock_mountfields);
chfs_gc_trigger(chmp);
mutex_exit(&chmp->chm_lock_mountfields);
spec_node_setmountedfs(devvp, mp);
return 0;
fail:
kmem_free(chmp->chm_ebh, sizeof(struct chfs_ebh));
kmem_free(chmp, sizeof(struct chfs_mount));
kmem_free(ump, sizeof(struct ufsmount));
return err;
}
/*
* Common code for mount and mountroot
*/
static int
iso_mountfs(struct vnode *devvp, struct mount *mp, struct lwp *l,
struct iso_args *argp)
{
struct iso_mnt *isomp = (struct iso_mnt *)0;
struct buf *bp = NULL, *pribp = NULL, *supbp = NULL;
dev_t dev = devvp->v_rdev;
int error = EINVAL;
int ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
int iso_bsize;
int iso_blknum;
int joliet_level;
struct iso_volume_descriptor *vdp;
struct iso_supplementary_descriptor *sup;
int sess = 0;
int ext_attr_length;
struct disklabel label;
if (!ronly)
return EROFS;
/* Flush out any old buffers remaining from a previous use. */
if ((error = vinvalbuf(devvp, V_SAVE, l->l_cred, l, 0, 0)) != 0)
return (error);
/* This is the "logical sector size". The standard says this
* should be 2048 or the physical sector size on the device,
* whichever is greater. For now, we'll just use a constant.
*/
iso_bsize = ISO_DEFAULT_BLOCK_SIZE;
error = VOP_IOCTL(devvp, DIOCGDINFO, &label, FREAD, FSCRED);
if (!error) {
/* XXX more sanity checks? */
sess = label.d_partitions[DISKPART(dev)].p_cdsession;
} else {
/* fallback to old method */
error = VOP_IOCTL(devvp, CDIOREADMSADDR, &sess, 0, FSCRED);
if (error)
sess = 0; /* never mind */
}
#ifdef ISO_DEBUG
printf("isofs: session offset (part %"PRId32") %d\n", DISKPART(dev), sess);
#endif
for (iso_blknum = 16; iso_blknum < 100; iso_blknum++) {
if ((error = bread(devvp, (iso_blknum+sess) * btodb(iso_bsize),
iso_bsize, NOCRED, 0, &bp)) != 0)
goto out;
vdp = (struct iso_volume_descriptor *)bp->b_data;
if (memcmp(vdp->id, ISO_STANDARD_ID, sizeof(vdp->id)) != 0) {
error = EINVAL;
goto out;
}
switch (isonum_711(vdp->type)) {
case ISO_VD_PRIMARY:
if (pribp == NULL) {
pribp = bp;
bp = NULL;
}
break;
case ISO_VD_SUPPLEMENTARY:
if (supbp == NULL) {
supbp = bp;
bp = NULL;
}
break;
default:
break;
}
if (isonum_711 (vdp->type) == ISO_VD_END) {
brelse(bp, 0);
bp = NULL;
break;
}
if (bp != NULL) {
brelse(bp, 0);
bp = NULL;
}
}
if (pribp == NULL) {
error = EINVAL;
goto out;
}
isomp = malloc(sizeof *isomp, M_ISOFSMNT, M_WAITOK);
memset(isomp, 0, sizeof *isomp);
if (iso_makemp(isomp, pribp, &ext_attr_length) == -1) {
error = EINVAL;
goto out;
}
isomp->volume_space_size += sess;
brelse(pribp, BC_AGE);
pribp = NULL;
mp->mnt_data = isomp;
mp->mnt_stat.f_fsidx.__fsid_val[0] = (long)dev;
mp->mnt_stat.f_fsidx.__fsid_val[1] = makefstype(MOUNT_CD9660);
mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0];
mp->mnt_stat.f_namemax = ISO_MAXNAMLEN;
mp->mnt_flag |= MNT_LOCAL;
mp->mnt_iflag |= IMNT_MPSAFE;
mp->mnt_dev_bshift = iso_bsize;
mp->mnt_fs_bshift = isomp->im_bshift;
isomp->im_mountp = mp;
isomp->im_dev = dev;
isomp->im_devvp = devvp;
/* Check the Rock Ridge Extension support */
if (!(argp->flags & ISOFSMNT_NORRIP)) {
struct iso_directory_record *rootp;
if ((error = bread(isomp->im_devvp,
(isomp->root_extent + ext_attr_length) <<
(isomp->im_bshift - DEV_BSHIFT),
isomp->logical_block_size, NOCRED,
0, &bp)) != 0)
goto out;
rootp = (struct iso_directory_record *)bp->b_data;
if ((isomp->rr_skip = cd9660_rrip_offset(rootp,isomp)) < 0) {
argp->flags |= ISOFSMNT_NORRIP;
} else {
argp->flags &= ~ISOFSMNT_GENS;
}
/*
* The contents are valid,
* but they will get reread as part of another vnode, so...
*/
brelse(bp, BC_AGE);
bp = NULL;
}
isomp->im_flags = argp->flags & (ISOFSMNT_NORRIP | ISOFSMNT_GENS |
ISOFSMNT_EXTATT | ISOFSMNT_NOJOLIET | ISOFSMNT_RRCASEINS);
if (isomp->im_flags & ISOFSMNT_GENS)
isomp->iso_ftype = ISO_FTYPE_9660;
else if (isomp->im_flags & ISOFSMNT_NORRIP) {
isomp->iso_ftype = ISO_FTYPE_DEFAULT;
if (argp->flags & ISOFSMNT_NOCASETRANS)
isomp->im_flags |= ISOFSMNT_NOCASETRANS;
} else
isomp->iso_ftype = ISO_FTYPE_RRIP;
/* Check the Joliet Extension support */
if ((argp->flags & ISOFSMNT_NORRIP) != 0 &&
(argp->flags & ISOFSMNT_NOJOLIET) == 0 &&
supbp != NULL) {
joliet_level = 0;
sup = (struct iso_supplementary_descriptor *)supbp->b_data;
if ((isonum_711(sup->flags) & 1) == 0) {
if (memcmp(sup->escape, "%/@", 3) == 0)
joliet_level = 1;
if (memcmp(sup->escape, "%/C", 3) == 0)
joliet_level = 2;
if (memcmp(sup->escape, "%/E", 3) == 0)
joliet_level = 3;
}
if (joliet_level != 0) {
if (iso_makemp(isomp, supbp, NULL) == -1) {
error = EINVAL;
goto out;
}
isomp->im_joliet_level = joliet_level;
}
}
if (supbp != NULL) {
brelse(supbp, 0);
supbp = NULL;
}
spec_node_setmountedfs(devvp, mp);
return 0;
out:
if (bp)
brelse(bp, 0);
if (pribp)
brelse(pribp, 0);
if (supbp)
brelse(supbp, 0);
if (isomp) {
free(isomp, M_ISOFSMNT);
mp->mnt_data = NULL;
}
return error;
}
