#include <rev_endian_fs.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/namei.h>
#include <sys/proc.h>
#include <sys/kernel.h>
#include <sys/vnode.h>
#include <sys/socket.h>
#include <sys/mount.h>
#include <sys/buf.h>
#include <sys/mbuf.h>
#include <sys/file.h>
#include <dev/disk.h>
#include <sys/ioctl.h>
#include <sys/errno.h>
#include <sys/malloc.h>
#include <sys/ubc.h>
#include <miscfs/specfs/specdev.h>
#include <ufs/ufs/quota.h>
#include <ufs/ufs/ufsmount.h>
#include <ufs/ufs/inode.h>
#include <ufs/ufs/ufs_extern.h>
#include <ufs/ffs/fs.h>
#include <ufs/ffs/ffs_extern.h>
#if REV_ENDIAN_FS
#include <ufs/ufs/ufs_byte_order.h>
#include <architecture/byte_order.h>
#endif
int ffs_sbupdate __P((struct ufsmount *, int));
struct vfsops ufs_vfsops = {
ffs_mount,
ufs_start,
ffs_unmount,
ufs_root,
ufs_quotactl,
ffs_statfs,
ffs_sync,
ffs_vget,
ffs_fhtovp,
ffs_vptofh,
ffs_init,
ffs_sysctl,
};
extern u_long nextgennumber;
ffs_mountroot()
{
extern struct vnode *rootvp;
struct fs *fs;
struct mount *mp;
struct proc *p = current_proc();
struct ufsmount *ump;
u_int size;
int error;
if (error = bdevvp(rootdev, &rootvp)) {
printf("ffs_mountroot: can't setup bdevvp");
return (error);
}
if (error = vfs_rootmountalloc("ufs", "root_device", &mp))
return (error);
mp->mnt_flag |= MNT_ROOTFS;
if (error = ffs_mountfs(rootvp, mp, p)) {
mp->mnt_vfc->vfc_refcount--;
vfs_unbusy(mp, p);
_FREE_ZONE(mp, sizeof (struct mount), M_MOUNT);
return (error);
}
simple_lock(&mountlist_slock);
CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list);
simple_unlock(&mountlist_slock);
ump = VFSTOUFS(mp);
fs = ump->um_fs;
(void) copystr(mp->mnt_stat.f_mntonname, fs->fs_fsmnt, MNAMELEN - 1, 0);
(void)ffs_statfs(mp, &mp->mnt_stat, p);
vfs_unbusy(mp, p);
inittodr(fs->fs_time);
return (0);
}
int
ffs_mount(mp, path, data, ndp, p)
register struct mount *mp;
char *path;
caddr_t data;
struct nameidata *ndp;
struct proc *p;
{
struct vnode *devvp;
struct ufs_args args;
struct ufsmount *ump;
register struct fs *fs;
u_int size;
int error, flags;
mode_t accessmode;
int ronly;
int reload = 0;
if (error = copyin(data, (caddr_t)&args, sizeof (struct ufs_args)))
return (error);
if (mp->mnt_flag & MNT_UPDATE) {
ump = VFSTOUFS(mp);
fs = ump->um_fs;
if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
flags = WRITECLOSE;
if (mp->mnt_flag & MNT_FORCE)
flags |= FORCECLOSE;
if (error = ffs_flushfiles(mp, flags, p))
return (error);
fs->fs_clean = 1;
fs->fs_ronly = 1;
if (error = ffs_sbupdate(ump, MNT_WAIT)) {
fs->fs_clean = 0;
fs->fs_ronly = 0;
return (error);
}
}
ronly = fs->fs_ronly;
if ((mp->mnt_flag & MNT_RELOAD) || ronly)
reload = 1;
if ((reload) &&
(error = ffs_reload(mp, ndp->ni_cnd.cn_cred, p)))
return (error);
fs->fs_ronly = ronly;
if (!fs->fs_clean && ronly) {
printf("WARNING: trying to mount a dirty file system\n");
if (issingleuser() && (mp->mnt_flag & MNT_ROOTFS)) {
printf("WARNING: R/W mount of %s denied. Filesystem is not clean - run fsck\n",fs->fs_fsmnt);
fs->fs_ronly = 1;
return(EPERM);
}
}
if (ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR)) {
if (p->p_ucred->cr_uid != 0) {
devvp = ump->um_devvp;
vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
if (error = VOP_ACCESS(devvp, VREAD | VWRITE,
p->p_ucred, p)) {
VOP_UNLOCK(devvp, 0, p);
return (error);
}
VOP_UNLOCK(devvp, 0, p);
}
fs->fs_ronly = 0;
fs->fs_clean = 0;
(void) ffs_sbupdate(ump, MNT_WAIT);
}
if (args.fspec == 0) {
return (vfs_export(mp, &ump->um_export, &args.export));
}
}
NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p);
if (error = namei(ndp))
return (error);
devvp = ndp->ni_vp;
if (devvp->v_type != VBLK) {
vrele(devvp);
return (ENOTBLK);
}
if (major(devvp->v_rdev) >= nblkdev) {
vrele(devvp);
return (ENXIO);
}
if (p->p_ucred->cr_uid != 0) {
accessmode = VREAD;
if ((mp->mnt_flag & MNT_RDONLY) == 0)
accessmode |= VWRITE;
vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
if (error = VOP_ACCESS(devvp, accessmode, p->p_ucred, p)) {
vput(devvp);
return (error);
}
VOP_UNLOCK(devvp, 0, p);
}
if ((mp->mnt_flag & MNT_UPDATE) == 0)
error = ffs_mountfs(devvp, mp, p);
else {
if (devvp != ump->um_devvp)
error = EINVAL;
else
vrele(devvp);
}
if (error) {
vrele(devvp);
return (error);
}
ump = VFSTOUFS(mp);
fs = ump->um_fs;
(void) copyinstr(path, fs->fs_fsmnt, sizeof(fs->fs_fsmnt) - 1, &size);
bzero(fs->fs_fsmnt + size, sizeof(fs->fs_fsmnt) - size);
bcopy((caddr_t)fs->fs_fsmnt, (caddr_t)mp->mnt_stat.f_mntonname,
MNAMELEN);
(void) copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1,
&size);
bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
(void)ffs_statfs(mp, &mp->mnt_stat, p);
return (0);
}
ffs_reload(mountp, cred, p)
register struct mount *mountp;
struct ucred *cred;
struct proc *p;
{
register struct vnode *vp, *nvp, *devvp;
struct inode *ip;
struct csum *space;
struct buf *bp;
struct fs *fs, *newfs;
int i, blks, size, error;
u_int64_t maxfilesize;
int32_t *lp;
#if REV_ENDIAN_FS
int rev_endian = (mountp->mnt_flag & MNT_REVEND);
#endif
if ((mountp->mnt_flag & MNT_RDONLY) == 0)
return (EINVAL);
devvp = VFSTOUFS(mountp)->um_devvp;
if (vinvalbuf(devvp, 0, cred, p, 0, 0))
panic("ffs_reload: dirty1");
VOP_DEVBLOCKSIZE(devvp,&size);
if (error = bread(devvp, (ufs_daddr_t)(SBOFF/size), SBSIZE, NOCRED,&bp)) {
brelse(bp);
return (error);
}
newfs = (struct fs *)bp->b_data;
#if REV_ENDIAN_FS
if (rev_endian) {
byte_swap_sbin(newfs);
}
#endif
if (newfs->fs_magic != FS_MAGIC || newfs->fs_bsize > MAXBSIZE ||
newfs->fs_bsize < sizeof(struct fs)) {
#if REV_ENDIAN_FS
if (rev_endian)
byte_swap_sbout(newfs);
#endif
brelse(bp);
return (EIO);
}
fs = VFSTOUFS(mountp)->um_fs;
bcopy(&fs->fs_csp[0], &newfs->fs_csp[0], sizeof(fs->fs_csp));
newfs->fs_maxcluster = fs->fs_maxcluster;
bcopy(newfs, fs, (u_int)fs->fs_sbsize);
if (fs->fs_sbsize < SBSIZE)
bp->b_flags |= B_INVAL;
#if REV_ENDIAN_FS
if (rev_endian)
byte_swap_sbout(newfs);
#endif
brelse(bp);
mountp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
ffs_oldfscompat(fs);
maxfilesize = (u_int64_t)0x100000000;
if (fs->fs_maxfilesize > maxfilesize)
fs->fs_maxfilesize = maxfilesize;
blks = howmany(fs->fs_cssize, fs->fs_fsize);
space = fs->fs_csp[0];
for (i = 0; i < blks; i += fs->fs_frag) {
size = fs->fs_bsize;
if (i + fs->fs_frag > blks)
size = (blks - i) * fs->fs_fsize;
if (error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
NOCRED, &bp)) {
brelse(bp);
return (error);
}
#if REV_ENDIAN_FS
if (rev_endian) {
byte_swap_ints((int *)bp->b_data, size / sizeof(int));
}
#endif
bcopy(bp->b_data, fs->fs_csp[fragstoblks(fs, i)], (u_int)size);
#if REV_ENDIAN_FS
if (rev_endian) {
byte_swap_ints((int *)bp->b_data, size / sizeof(int));
}
#endif
brelse(bp);
}
if (fs->fs_contigsumsize > 0) {
lp = fs->fs_maxcluster;
for (i = 0; i < fs->fs_ncg; i++)
*lp++ = fs->fs_contigsumsize;
}
loop:
simple_lock(&mntvnode_slock);
for (vp = mountp->mnt_vnodelist.lh_first; vp != NULL; vp = nvp) {
if (vp->v_mount != mountp) {
simple_unlock(&mntvnode_slock);
goto loop;
}
nvp = vp->v_mntvnodes.le_next;
if (vrecycle(vp, &mntvnode_slock, p))
goto loop;
simple_lock(&vp->v_interlock);
simple_unlock(&mntvnode_slock);
if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, p)) {
goto loop;
}
if (vinvalbuf(vp, 0, cred, p, 0, 0))
panic("ffs_reload: dirty2");
ip = VTOI(vp);
if (error =
bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
(int)fs->fs_bsize, NOCRED, &bp)) {
brelse(bp);
vput(vp);
return (error);
}
#if REV_ENDIAN_FS
if (rev_endian) {
byte_swap_inode_in(((struct dinode *)bp->b_data +
ino_to_fsbo(fs, ip->i_number)), ip);
} else {
#endif
ip->i_din = *((struct dinode *)bp->b_data +
ino_to_fsbo(fs, ip->i_number));
#if REV_ENDIAN_FS
}
#endif
brelse(bp);
vput(vp);
simple_lock(&mntvnode_slock);
}
simple_unlock(&mntvnode_slock);
return (0);
}
int
ffs_mountfs(devvp, mp, p)
register struct vnode *devvp;
struct mount *mp;
struct proc *p;
{
register struct ufsmount *ump;
struct buf *bp;
register struct fs *fs;
dev_t dev;
struct buf *cgbp;
struct cg *cgp;
int32_t clustersumoff;
caddr_t base, space;
int error, i, blks, size, ronly;
int32_t *lp;
struct ucred *cred;
extern struct vnode *rootvp;
u_int64_t maxfilesize;
u_int dbsize = DEV_BSIZE;
#if REV_ENDIAN_FS
int rev_endian=0;
#endif
dev = devvp->v_rdev;
cred = p ? p->p_ucred : NOCRED;
if (error = vfs_mountedon(devvp))
return (error);
if (vcount(devvp) > 1 && devvp != rootvp)
return (EBUSY);
if (error = vinvalbuf(devvp, V_SAVE, cred, p, 0, 0))
return (error);
ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
if (error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, p))
return (error);
VOP_DEVBLOCKSIZE(devvp,&size);
bp = NULL;
ump = NULL;
if (error = bread(devvp, (ufs_daddr_t)(SBOFF/size), SBSIZE, cred, &bp))
goto out;
fs = (struct fs *)bp->b_data;
#if REV_ENDIAN_FS
if (fs->fs_magic != FS_MAGIC || fs->fs_bsize > MAXBSIZE ||
fs->fs_bsize < sizeof(struct fs)) {
int magic = fs->fs_magic;
byte_swap_ints(&magic, 1);
if (magic != FS_MAGIC) {
error = EINVAL;
goto out;
}
byte_swap_sbin(fs);
if (fs->fs_magic != FS_MAGIC || fs->fs_bsize > MAXBSIZE ||
fs->fs_bsize < sizeof(struct fs)) {
byte_swap_sbout(fs);
error = EINVAL;
goto out;
}
rev_endian=1;
}
#endif
if (fs->fs_magic != FS_MAGIC || fs->fs_bsize > MAXBSIZE ||
fs->fs_bsize < sizeof(struct fs)) {
#if REV_ENDIAN_FS
if (rev_endian)
byte_swap_sbout(fs);
#endif
error = EINVAL;
goto out;
}
if ((fs->fs_bsize > PAGE_SIZE) || (fs->fs_fsize < DIRBLKSIZ) ||
((!(mp->mnt_flag & MNT_ROOTFS)) && (!fs->fs_clean))) {
#if REV_ENDIAN_FS
if (rev_endian)
byte_swap_sbout(fs);
#endif
error = ENOTSUP;
goto out;
}
dbsize = fs->fs_fsize / NSPF(fs);
if(dbsize <= 0 ) {
kprintf("device blocksize computaion failed\n");
} else {
if (VOP_IOCTL(devvp, DKIOCSETBLOCKSIZE, &dbsize, FWRITE, NOCRED,
p) != 0) {
kprintf("failed to set device blocksize\n");
}
set_fsblocksize(devvp);
}
error = vfs_init_io_attributes(devvp, mp);
if (error) {
printf("ffs_mountfs: vfs_init_io_attributes returned %d\n",
error);
goto out;
}
if (fs->fs_postblformat == FS_42POSTBLFMT && !ronly) {
#if REV_ENDIAN_FS
if (rev_endian)
byte_swap_sbout(fs);
#endif
error = EROFS;
goto out;
}
if (ronly == 0){
if (error = bread (devvp, fsbtodb(fs, cgtod(fs, 0)),
(int)fs->fs_cgsize, NOCRED, &cgbp)) {
brelse(cgbp);
goto out;
}
cgp = (struct cg *)cgbp->b_data;
#if REV_ENDIAN_FS
if (rev_endian)
byte_swap_cgin(cgp,fs);
#endif
if (!cg_chkmagic(cgp)){
#if REV_ENDIAN_FS
if (rev_endian)
byte_swap_cgout(cgp,fs);
#endif
brelse(cgbp);
goto out;
}
if (cgp->cg_clustersumoff != 0) {
clustersumoff = cgp->cg_freeoff +
howmany(fs->fs_cpg * fs->fs_spc / NSPF(fs), NBBY);
clustersumoff = roundup(clustersumoff, sizeof(long));
if (cgp->cg_clustersumoff < clustersumoff) {
mp->mnt_flag |= MNT_RDONLY;
ronly = 1;
}
}
#if REV_ENDIAN_FS
if (rev_endian)
byte_swap_cgout(cgp,fs);
#endif
brelse(cgbp);
}
ump = _MALLOC(sizeof *ump, M_UFSMNT, M_WAITOK);
bzero((caddr_t)ump, sizeof *ump);
ump->um_fs = _MALLOC((u_long)fs->fs_sbsize, M_UFSMNT,
M_WAITOK);
bcopy(bp->b_data, ump->um_fs, (u_int)fs->fs_sbsize);
if (fs->fs_sbsize < SBSIZE)
bp->b_flags |= B_INVAL;
#if REV_ENDIAN_FS
if (rev_endian)
byte_swap_sbout(fs);
#endif
brelse(bp);
bp = NULL;
fs = ump->um_fs;
fs->fs_ronly = ronly;
size = fs->fs_cssize;
blks = howmany(size, fs->fs_fsize);
if (fs->fs_contigsumsize > 0)
size += fs->fs_ncg * sizeof(int32_t);
base = space = _MALLOC((u_long)size, M_UFSMNT, M_WAITOK);
base = space;
for (i = 0; i < blks; i += fs->fs_frag) {
size = fs->fs_bsize;
if (i + fs->fs_frag > blks)
size = (blks - i) * fs->fs_fsize;
if (error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
cred, &bp)) {
_FREE(base, M_UFSMNT);
goto out;
}
bcopy(bp->b_data, space, (u_int)size);
#if REV_ENDIAN_FS
if (rev_endian)
byte_swap_ints((int *) space, size / sizeof(int));
#endif
fs->fs_csp[fragstoblks(fs, i)] = (struct csum *)space;
space += size;
brelse(bp);
bp = NULL;
}
if (fs->fs_contigsumsize > 0) {
fs->fs_maxcluster = lp = (int32_t *)space;
for (i = 0; i < fs->fs_ncg; i++)
*lp++ = fs->fs_contigsumsize;
}
mp->mnt_data = (qaddr_t)ump;
mp->mnt_stat.f_fsid.val[0] = (long)dev;
mp->mnt_stat.f_fsid.val[1] = mp->mnt_vfc->vfc_typenum;
#warning hardcoded max symlen and not "mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;"
mp->mnt_maxsymlinklen = 60;
#if REV_ENDIAN_FS
if (rev_endian)
mp->mnt_flag |= MNT_REVEND;
#endif
ump->um_mountp = mp;
ump->um_dev = dev;
ump->um_devvp = devvp;
ump->um_nindir = fs->fs_nindir;
ump->um_bptrtodb = fs->fs_fsbtodb;
ump->um_seqinc = fs->fs_frag;
for (i = 0; i < MAXQUOTAS; i++)
ump->um_quotas[i] = NULLVP;
devvp->v_specflags |= SI_MOUNTEDON;
ffs_oldfscompat(fs);
ump->um_savedmaxfilesize = fs->fs_maxfilesize;
maxfilesize = (u_int64_t)0x100000000;
#if 0
maxfilesize = (u_int64_t)0x40000000 * fs->fs_bsize - 1;
#endif
if (fs->fs_maxfilesize > maxfilesize)
fs->fs_maxfilesize = maxfilesize;
if (ronly == 0) {
fs->fs_clean = 0;
(void) ffs_sbupdate(ump, MNT_WAIT);
}
return (0);
out:
if (bp)
brelse(bp);
(void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, cred, p);
if (ump) {
_FREE(ump->um_fs, M_UFSMNT);
_FREE(ump, M_UFSMNT);
mp->mnt_data = (qaddr_t)0;
}
return (error);
}
ffs_oldfscompat(fs)
struct fs *fs;
{
int i;
fs->fs_npsect = max(fs->fs_npsect, fs->fs_nsect);
fs->fs_interleave = max(fs->fs_interleave, 1);
if (fs->fs_postblformat == FS_42POSTBLFMT)
fs->fs_nrpos = 8;
if (fs->fs_inodefmt < FS_44INODEFMT) {
u_int64_t sizepb = fs->fs_bsize;
fs->fs_maxfilesize = fs->fs_bsize * NDADDR - 1;
for (i = 0; i < NIADDR; i++) {
sizepb *= NINDIR(fs);
fs->fs_maxfilesize += sizepb;
}
fs->fs_qbmask = ~fs->fs_bmask;
fs->fs_qfmask = ~fs->fs_fmask;
}
return (0);
}
int
ffs_unmount(mp, mntflags, p)
struct mount *mp;
int mntflags;
struct proc *p;
{
register struct ufsmount *ump;
register struct fs *fs;
int error, flags;
flags = 0;
if (mntflags & MNT_FORCE)
flags |= FORCECLOSE;
if (error = ffs_flushfiles(mp, flags, p))
return (error);
ump = VFSTOUFS(mp);
fs = ump->um_fs;
if (fs->fs_ronly == 0) {
fs->fs_clean = 1;
if (error = ffs_sbupdate(ump, MNT_WAIT)) {
fs->fs_clean = 0;
#ifdef notyet
return (error);
#endif
}
}
ump->um_devvp->v_specflags &= ~SI_MOUNTEDON;
error = VOP_CLOSE(ump->um_devvp, fs->fs_ronly ? FREAD : FREAD|FWRITE,
NOCRED, p);
vrele(ump->um_devvp);
_FREE(fs->fs_csp[0], M_UFSMNT);
_FREE(fs, M_UFSMNT);
_FREE(ump, M_UFSMNT);
mp->mnt_data = (qaddr_t)0;
#if REV_ENDIAN_FS
mp->mnt_flag &= ~MNT_REVEND;
#endif
return (error);
}
ffs_flushfiles(mp, flags, p)
register struct mount *mp;
int flags;
struct proc *p;
{
register struct ufsmount *ump;
int i, error;
ump = VFSTOUFS(mp);
#if QUOTA
if (mp->mnt_flag & MNT_QUOTA) {
if (error = vflush(mp, NULLVP, SKIPSYSTEM|flags))
return (error);
for (i = 0; i < MAXQUOTAS; i++) {
if (ump->um_quotas[i] == NULLVP)
continue;
quotaoff(p, mp, i);
}
}
#endif
error = vflush(mp, NULLVP, SKIPSWAP|flags);
error = vflush(mp, NULLVP, flags);
return (error);
}
int
ffs_statfs(mp, sbp, p)
struct mount *mp;
register struct statfs *sbp;
struct proc *p;
{
register struct ufsmount *ump;
register struct fs *fs;
ump = VFSTOUFS(mp);
fs = ump->um_fs;
if (fs->fs_magic != FS_MAGIC)
panic("ffs_statfs");
sbp->f_bsize = fs->fs_fsize;
sbp->f_iosize = fs->fs_bsize;
sbp->f_blocks = fs->fs_dsize;
sbp->f_bfree = fs->fs_cstotal.cs_nbfree * fs->fs_frag +
fs->fs_cstotal.cs_nffree;
sbp->f_bavail = freespace(fs, fs->fs_minfree);
sbp->f_files = fs->fs_ncg * fs->fs_ipg - ROOTINO;
sbp->f_ffree = fs->fs_cstotal.cs_nifree;
if (sbp != &mp->mnt_stat) {
sbp->f_type = mp->mnt_vfc->vfc_typenum;
bcopy((caddr_t)mp->mnt_stat.f_mntonname,
(caddr_t)&sbp->f_mntonname[0], MNAMELEN);
bcopy((caddr_t)mp->mnt_stat.f_mntfromname,
(caddr_t)&sbp->f_mntfromname[0], MNAMELEN);
}
return (0);
}
int
ffs_sync(mp, waitfor, cred, p)
struct mount *mp;
int waitfor;
struct ucred *cred;
struct proc *p;
{
struct vnode *nvp, *vp;
struct inode *ip;
struct ufsmount *ump = VFSTOUFS(mp);
struct fs *fs;
int error, allerror = 0;
fs = ump->um_fs;
if (fs->fs_fmod != 0 && fs->fs_ronly != 0) {
printf("fs = %s\n", fs->fs_fsmnt);
panic("update: rofs mod");
}
simple_lock(&mntvnode_slock);
loop:
for (vp = mp->mnt_vnodelist.lh_first;
vp != NULL;
vp = nvp) {
int didhold = 0;
if (vp->v_mount != mp)
goto loop;
simple_lock(&vp->v_interlock);
nvp = vp->v_mntvnodes.le_next;
ip = VTOI(vp);
if ((vp->v_type == VNON) ||
((ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0 &&
vp->v_dirtyblkhd.lh_first == NULL && !(vp->v_flag & VHASDIRTY))) {
simple_unlock(&vp->v_interlock);
continue;
}
simple_unlock(&mntvnode_slock);
error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK, p);
if (error) {
simple_lock(&mntvnode_slock);
if (error == ENOENT)
goto loop;
continue;
}
didhold = ubc_hold(vp);
if (error = VOP_FSYNC(vp, cred, waitfor, p))
allerror = error;
VOP_UNLOCK(vp, 0, p);
if (didhold)
ubc_rele(vp);
vrele(vp);
simple_lock(&mntvnode_slock);
}
simple_unlock(&mntvnode_slock);
if (error = VOP_FSYNC(ump->um_devvp, cred, waitfor, p))
allerror = error;
#if QUOTA
qsync(mp);
#endif
if (fs->fs_fmod != 0) {
fs->fs_fmod = 0;
fs->fs_time = time.tv_sec;
if (error = ffs_sbupdate(ump, waitfor))
allerror = error;
}
return (allerror);
}
int
ffs_vget(mp, ino, vpp)
struct mount *mp;
ino_t ino;
struct vnode **vpp;
{
struct proc *p = current_proc();
struct fs *fs;
struct inode *ip;
struct ufsmount *ump;
struct buf *bp;
struct vnode *vp;
dev_t dev;
int i, type, error;
ump = VFSTOUFS(mp);
dev = ump->um_dev;
if (mp->mnt_kern_flag & MNTK_UNMOUNT) {
*vpp = NULL;
return (EPERM);
}
if ((*vpp = ufs_ihashget(dev, ino)) != NULL) {
vp = *vpp;
UBCINFOCHECK("ffs_vget", vp);
return (0);
}
type = ump->um_devvp->v_tag == VT_MFS ? M_MFSNODE : M_FFSNODE;
MALLOC_ZONE(ip, struct inode *, sizeof(struct inode), type, M_WAITOK);
bzero((caddr_t)ip, sizeof(struct inode));
lockinit(&ip->i_lock, PINOD, "inode", 0, 0);
lockmgr(&ip->i_lock, LK_EXCLUSIVE, (struct slock *)0, p);
ip->i_fs = fs = ump->um_fs;
ip->i_dev = dev;
ip->i_number = ino;
ip->i_flag |= IN_ALLOC;
#if QUOTA
for (i = 0; i < MAXQUOTAS; i++)
ip->i_dquot[i] = NODQUOT;
#endif
if ((*vpp = ufs_ihashget(dev, ino)) != NULL) {
FREE_ZONE(ip, sizeof(struct inode), type);
vp = *vpp;
UBCINFOCHECK("ffs_vget", vp);
return (0);
}
ufs_ihashins(ip);
if (error = getnewvnode(VT_UFS, mp, ffs_vnodeop_p, &vp)) {
ufs_ihashrem(ip);
if (ISSET(ip->i_flag, IN_WALLOC))
wakeup(ip);
FREE_ZONE(ip, sizeof(struct inode), type);
*vpp = NULL;
return (error);
}
vp->v_data = ip;
ip->i_vnode = vp;
CLR(ip->i_flag, IN_ALLOC);
if (ISSET(ip->i_flag, IN_WALLOC))
wakeup(ip);
if (error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),
(int)fs->fs_bsize, NOCRED, &bp)) {
vput(vp);
brelse(bp);
*vpp = NULL;
return (error);
}
#if REV_ENDIAN_FS
if (mp->mnt_flag & MNT_REVEND) {
byte_swap_inode_in(((struct dinode *)bp->b_data + ino_to_fsbo(fs, ino)),ip);
} else {
#endif
ip->i_din = *((struct dinode *)bp->b_data + ino_to_fsbo(fs, ino));
#if REV_ENDIAN_FS
}
#endif
brelse(bp);
if (error = ufs_vinit(mp, ffs_specop_p, FFS_FIFOOPS, &vp)) {
vput(vp);
*vpp = NULL;
return (error);
}
ip->i_devvp = ump->um_devvp;
VREF(ip->i_devvp);
if (ip->i_gen == 0) {
if (++nextgennumber < (u_long)time.tv_sec)
nextgennumber = time.tv_sec;
ip->i_gen = nextgennumber;
if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0)
ip->i_flag |= IN_MODIFIED;
}
if (fs->fs_inodefmt < FS_44INODEFMT) {
ip->i_uid = ip->i_din.di_ouid;
ip->i_gid = ip->i_din.di_ogid;
}
*vpp = vp;
if (UBCINFOMISSING(vp) || UBCINFORECLAIMED(vp))
ubc_info_init(vp);
return (0);
}
int
ffs_fhtovp(mp, fhp, nam, vpp, exflagsp, credanonp)
register struct mount *mp;
struct fid *fhp;
struct mbuf *nam;
struct vnode **vpp;
int *exflagsp;
struct ucred **credanonp;
{
register struct ufid *ufhp;
struct fs *fs;
ufhp = (struct ufid *)fhp;
fs = VFSTOUFS(mp)->um_fs;
if (ufhp->ufid_ino < ROOTINO ||
ufhp->ufid_ino >= fs->fs_ncg * fs->fs_ipg)
return (ESTALE);
return (ufs_check_export(mp, ufhp, nam, vpp, exflagsp, credanonp));
}
ffs_vptofh(vp, fhp)
struct vnode *vp;
struct fid *fhp;
{
register struct inode *ip;
register struct ufid *ufhp;
ip = VTOI(vp);
ufhp = (struct ufid *)fhp;
ufhp->ufid_len = sizeof(struct ufid);
ufhp->ufid_ino = ip->i_number;
ufhp->ufid_gen = ip->i_gen;
return (0);
}
int
ffs_init(vfsp)
struct vfsconf *vfsp;
{
return (ufs_init(vfsp));
}
ffs_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
int *name;
u_int namelen;
void *oldp;
size_t *oldlenp;
void *newp;
size_t newlen;
struct proc *p;
{
extern int doclusterread, doclusterwrite, doreallocblks, doasyncfree;
if (namelen != 1)
return (ENOTDIR);
switch (name[0]) {
case FFS_CLUSTERREAD:
return (sysctl_int(oldp, oldlenp, newp, newlen,
&doclusterread));
case FFS_CLUSTERWRITE:
return (sysctl_int(oldp, oldlenp, newp, newlen,
&doclusterwrite));
case FFS_REALLOCBLKS:
return (sysctl_int(oldp, oldlenp, newp, newlen,
&doreallocblks));
case FFS_ASYNCFREE:
return (sysctl_int(oldp, oldlenp, newp, newlen, &doasyncfree));
default:
return (EOPNOTSUPP);
}
}
int
ffs_sbupdate(mp, waitfor)
struct ufsmount *mp;
int waitfor;
{
register struct fs *dfs, *fs = mp->um_fs;
register struct buf *bp;
int blks;
caddr_t space;
int i, size, error, allerror = 0;
int devBlockSize=0;
#if REV_ENDIAN_FS
int rev_endian=(mp->um_mountp->mnt_flag & MNT_REVEND);
#endif
blks = howmany(fs->fs_cssize, fs->fs_fsize);
space = (caddr_t)fs->fs_csp[0];
for (i = 0; i < blks; i += fs->fs_frag) {
size = fs->fs_bsize;
if (i + fs->fs_frag > blks)
size = (blks - i) * fs->fs_fsize;
bp = getblk(mp->um_devvp, fsbtodb(fs, fs->fs_csaddr + i),
size, 0, 0, BLK_META);
bcopy(space, bp->b_data, (u_int)size);
#if REV_ENDIAN_FS
if (rev_endian) {
byte_swap_ints((int *)bp->b_data, size / sizeof(int));
}
#endif
space += size;
if (waitfor != MNT_WAIT)
bawrite(bp);
else if (error = bwrite(bp))
allerror = error;
}
if (allerror)
return (allerror);
VOP_DEVBLOCKSIZE(mp->um_devvp,&devBlockSize);
bp = getblk(mp->um_devvp, (SBOFF/devBlockSize), (int)fs->fs_sbsize, 0, 0, BLK_META);
bcopy((caddr_t)fs, bp->b_data, (u_int)fs->fs_sbsize);
dfs = (struct fs *)bp->b_data;
if (fs->fs_postblformat == FS_42POSTBLFMT)
dfs->fs_nrpos = -1;
#if REV_ENDIAN_FS
if (rev_endian) {
byte_swap_sbout((struct fs *)bp->b_data);
}
#endif
if (fs->fs_inodefmt < FS_44INODEFMT) {
int32_t *lp, tmp;
lp = (int32_t *)&dfs->fs_qbmask;
tmp = lp[4];
for (i = 4; i > 0; i--)
lp[i] = lp[i-1];
lp[0] = tmp;
}
#if REV_ENDIAN_FS
if (rev_endian) {
dfs->fs_maxfilesize = NXSwapLongLong(mp->um_savedmaxfilesize);
} else {
#endif
dfs->fs_maxfilesize = mp->um_savedmaxfilesize;
#if REV_ENDIAN_FS
}
#endif
if (waitfor != MNT_WAIT)
bawrite(bp);
else if (error = bwrite(bp))
allerror = error;
return (allerror);
}