struct dentry *
vnlayer_get_dentry(
SUPER_T *sb,
void *fhbits
)
{
int error;
VFS_T *vfsp = SBTOVFS(sb);
VNODE_T *vp;
MDKI_FID_T *lfidp = fhbits;
DENT_T *dp;
CALL_DATA_T cd;
mdki_linux_init_call_data(&cd);
error = VFS_VGET(vfsp, &vp, lfidp, &cd);
if (error == 0) {
/* rebind if needed */
if (mfs_rebind_vpp(1, &vp, &cd)) {
MDKI_VFS_LOG(VFS_LOG_ESTALE,
"%s: vp %p rebound\n",
__FUNCTION__, vp);
}
dp = vnlayer_find_dentry(vp);
/* always drop vnode's refcount */
VN_RELE(vp);
} else {
dp = ERR_PTR(mdki_errno_unix_to_linux(error));
}
mdki_linux_destroy_call_data(&cd);
return dp;
}
/* ARGSUSED */
int
cd9660_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
{
struct ifid ifh;
struct iso_node *ip;
struct vnode *nvp;
int error;
if (fhp->fid_len != sizeof(ifh))
return EINVAL;
memcpy(&ifh, fhp, sizeof(ifh));
#ifdef ISOFS_DBG
printf("fhtovp: ino %d, start %ld\n",
ifh.ifid_ino, ifh.ifid_start);
#endif
if ((error = VFS_VGET(mp, ifh.ifid_ino, &nvp)) != 0) {
*vpp = NULLVP;
return (error);
}
ip = VTOI(nvp);
if (ip->inode.iso_mode == 0) {
vput(nvp);
*vpp = NULLVP;
return (ESTALE);
}
*vpp = nvp;
return (0);
}
/*
* File handle to vnode
*
* Have to be really careful about stale file handles:
* - check that the inode number is valid
* - call ext2fs_vget() to get the locked inode
* - check for an unallocated inode (i_mode == 0)
*/
int
ext2fs_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
{
printf("In file: %s, fun: %s,lineno: %d\n",__FILE__, __func__, __LINE__);
struct inode *ip;
struct vnode *nvp;
int error;
struct ufid ufh;
struct m_ext2fs *fs;
if (fhp->fid_len != sizeof(struct ufid))
return EINVAL;
memcpy(&ufh, fhp, sizeof(struct ufid));
fs = VFSTOUFS(mp)->um_e2fs;
if ((ufh.ufid_ino < EXT2_FIRSTINO && ufh.ufid_ino != EXT2_ROOTINO) ||
ufh.ufid_ino >= fs->e2fs_ncg * fs->e2fs.e2fs_ipg)
return (ESTALE);
if ((error = VFS_VGET(mp, ufh.ufid_ino, &nvp)) != 0) {
*vpp = NULLVP;
return (error);
}
ip = VTOI(nvp);
if (ip->i_e2fs_mode == 0 || ip->i_e2fs_dtime != 0 ||
ip->i_e2fs_gen != ufh.ufid_gen) {
vput(nvp);
*vpp = NULLVP;
return (ESTALE);
}
*vpp = nvp;
return (0);
}
/*
* Convert the provided opaque, unique file handle into a vnode.
*
* Returns 0 on success.
*/
static int
efs_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
{
int err;
struct vnode *vp;
struct efs_fid *efp;
struct efs_inode *eip;
if (fhp->fid_len != sizeof(struct efs_fid))
return (EINVAL);
efp = (struct efs_fid *)fhp;
if ((err = VFS_VGET(mp, efp->ef_ino, &vp))) {
*vpp = NULL;
return (err);
}
eip = EFS_VTOI(vp);
if (eip->ei_mode == 0 || eip->ei_gen != efp->ef_gen) {
vput(vp);
*vpp = NULL;
return (ESTALE);
}
*vpp = vp;
return (0);
}
int
layerfs_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
{
struct vnode *vp;
int error;
error = VFS_VGET(MOUNTTOLAYERMOUNT(mp)->layerm_vfs, ino, &vp);
if (error) {
*vpp = NULL;
return error;
}
VOP_UNLOCK(vp);
error = layer_node_create(mp, vp, vpp);
if (error) {
vrele(vp);
*vpp = NULL;
return error;
}
error = vn_lock(*vpp, LK_EXCLUSIVE);
if (error) {
vrele(*vpp);
*vpp = NULL;
return error;
}
return 0;
}
int
fusefs_mkdir(void *v)
{
struct vop_mkdir_args *ap = v;
struct vnode *dvp = ap->a_dvp;
struct vnode **vpp = ap->a_vpp;
struct componentname *cnp = ap->a_cnp;
struct vattr *vap = ap->a_vap;
struct proc *p = cnp->cn_proc;
struct vnode *tdp = NULL;
struct fusefs_node *ip;
struct fusefs_mnt *fmp;
struct fusebuf *fbuf;
int error = 0;
DPRINTF("fusefs_mkdir %s\n", cnp->cn_nameptr);
ip = VTOI(dvp);
fmp = (struct fusefs_mnt *)ip->ufs_ino.i_ump;
if (!fmp->sess_init || (fmp->undef_op & UNDEF_MKDIR)) {
error = ENOSYS;
goto out;
}
fbuf = fb_setup(FUSEFDSIZE + cnp->cn_namelen + 1, ip->ufs_ino.i_number,
FBT_MKDIR, p);
fbuf->fb_io_mode = MAKEIMODE(vap->va_type, vap->va_mode);
memcpy(fbuf->fb_dat, cnp->cn_nameptr, cnp->cn_namelen);
fbuf->fb_dat[cnp->cn_namelen] = '\0';
error = fb_queue(fmp->dev, fbuf);
if (error) {
if (error == ENOSYS)
fmp->undef_op |= UNDEF_MKDIR;
pool_put(&fusefs_fbuf_pool, fbuf);
goto out;
}
if ((error = VFS_VGET(fmp->mp, fbuf->fb_ino, &tdp))) {
pool_put(&fusefs_fbuf_pool, fbuf);
goto out;
}
tdp->v_type = IFTOVT(fbuf->fb_io_mode);
VTOI(tdp)->vtype = tdp->v_type;
if (dvp != NULL && dvp->v_type == VDIR)
VTOI(tdp)->parent = ip->ufs_ino.i_number;
*vpp = tdp;
VN_KNOTE(ap->a_dvp, NOTE_WRITE | NOTE_LINK);
pool_put(&fusefs_fbuf_pool, fbuf);
out:
vput(dvp);
return (error);
}
int
adosfs_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
{
struct ifid ifh;
#if 0
struct anode *ap;
#endif
struct vnode *nvp;
int error;
if (fhp->fid_len != sizeof(struct ifid))
return EINVAL;
#ifdef ADOSFS_DIAGNOSTIC
printf("adfhtovp(%p, %p, %p)\n", mp, fhp, vpp);
#endif
memcpy(&ifh, fhp, sizeof(ifh));
if ((error = VFS_VGET(mp, ifh.ifid_ino, &nvp)) != 0) {
*vpp = NULLVP;
return (error);
}
#if 0
ap = VTOA(nvp);
if (ap->inode.iso_mode == 0) {
vput(nvp);
*vpp = NULLVP;
return (ESTALE);
}
#endif
*vpp = nvp;
return(0);
}
/*
* File handle to vnode
*
* Have to be really careful about stale file handles:
* - check that the inode number is valid
* - call ext2fs_vget() to get the locked inode
* - check for an unallocated inode (i_mode == 0)
* - check that the given client host has export rights and return
* those rights via. exflagsp and credanonp
*/
int
ext2fs_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
{
struct inode *ip;
struct vnode *nvp;
int error;
struct ufid *ufhp;
struct m_ext2fs *fs;
ufhp = (struct ufid *)fhp;
fs = VFSTOUFS(mp)->um_e2fs;
if ((ufhp->ufid_ino < EXT2_FIRSTINO && ufhp->ufid_ino != EXT2_ROOTINO) ||
ufhp->ufid_ino > fs->e2fs_ncg * fs->e2fs.e2fs_ipg)
return (ESTALE);
if ((error = VFS_VGET(mp, ufhp->ufid_ino, &nvp)) != 0) {
*vpp = NULLVP;
return (error);
}
ip = VTOI(nvp);
if (ip->i_e2fs_mode == 0 || ip->i_e2fs_dtime != 0 ||
ip->i_e2fs_gen != ufhp->ufid_gen) {
vput(nvp);
*vpp = NULLVP;
return (ESTALE);
}
*vpp = nvp;
return (0);
}
/*
* File handle to vnode
*
* Have to be really careful about stale file handles:
* - check that the inode number is valid
* - call ext2fs_vget() to get the locked inode
* - check for an unallocated inode (i_mode == 0)
*/
int
ext2fs_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
{
struct inode *ip;
struct vnode *nvp;
int error;
struct ufid ufh;
struct m_ext2fs *fs;
if (fhp->fid_len != sizeof(struct ufid))
return EINVAL;
memcpy(&ufh, fhp, sizeof(struct ufid));
fs = VFSTOUFS(mp)->um_e2fs;
if ((ufh.ufid_ino < EXT2_FIRSTINO && ufh.ufid_ino != EXT2_ROOTINO) ||
ufh.ufid_ino >= fs->e2fs_ncg * fs->e2fs.e2fs_ipg)
return ESTALE;
if ((error = VFS_VGET(mp, ufh.ufid_ino, &nvp)) != 0) {
*vpp = NULLVP;
return error;
}
ip = VTOI(nvp);
if (ip->i_e2fs_mode == 0 || ip->i_e2fs_dtime != 0 ||
ip->i_e2fs_gen != ufh.ufid_gen) {
vput(nvp);
*vpp = NULLVP;
return ESTALE;
}
*vpp = nvp;
return 0;
}
/* get lvp's parent, if possible, even if it isn't set.
lvp is expected to have an iocount before and after this call.
if a dvpp is populated the returned vnode has an iocount. */
static int
null_get_lowerparent(vnode_t lvp, vnode_t * dvpp, vfs_context_t ctx)
{
int error = 0;
struct vnode_attr va;
mount_t mp = vnode_mount(lvp);
vnode_t dvp = vnode_parent(lvp);
if (dvp) {
error = vnode_get(dvp);
goto end;
}
error = ENOENT;
if (!(mp->mnt_kern_flag & MNTK_PATH_FROM_ID)) {
goto end;
}
VATTR_INIT(&va);
VATTR_WANTED(&va, va_parentid);
error = vnode_getattr(lvp, &va, ctx);
if (error || !VATTR_IS_SUPPORTED(&va, va_parentid)) {
goto end;
}
error = VFS_VGET(mp, (ino64_t)va.va_parentid, &dvp, ctx);
end:
if (error == 0) {
*dvpp = dvp;
}
return error;
}
/*
* File handle to vnode
*
* Have to be really careful about stale file handles:
* - check that the inode number is valid
* - call ext2_vget() to get the locked inode
* - check for an unallocated inode (i_mode == 0)
* - check that the given client host has export rights and return
* those rights via. exflagsp and credanonp
*/
static int
ext2_fhtovp(struct mount *mp, struct fid *fhp, int flags, struct vnode **vpp)
{
struct inode *ip;
struct ufid *ufhp;
struct vnode *nvp;
struct m_ext2fs *fs;
int error;
ufhp = (struct ufid *)fhp;
fs = VFSTOEXT2(mp)->um_e2fs;
if (ufhp->ufid_ino < EXT2_ROOTINO ||
ufhp->ufid_ino > fs->e2fs_gcount * fs->e2fs->e2fs_ipg)
return (ESTALE);
error = VFS_VGET(mp, ufhp->ufid_ino, LK_EXCLUSIVE, &nvp);
if (error) {
*vpp = NULLVP;
return (error);
}
ip = VTOI(nvp);
if (ip->i_mode == 0 ||
ip->i_gen != ufhp->ufid_gen || ip->i_nlink <= 0) {
vput(nvp);
*vpp = NULLVP;
return (ESTALE);
}
*vpp = nvp;
vnode_create_vobject(*vpp, 0, curthread);
return (0);
}
static int
vfs_getrealpath(const char * path, char * realpath, size_t bufsize, vfs_context_t ctx)
{
vnode_t vp;
struct mount *mp = NULL;
char *str;
char ch;
uint32_t id;
ino64_t ino;
int error;
int length;
/* Get file system id and move str to next component. */
id = strtoul(path, &str, 10);
if (id == 0 || str[0] != '/') {
return (EINVAL);
}
while (*str == '/') {
str++;
}
ch = *str;
mp = mount_lookupby_volfsid(id, 1);
if (mp == NULL) {
return (EINVAL); /* unexpected failure */
}
/* Check for an alias to a file system root. */
if (ch == '@' && str[1] == '\0') {
ino = 2;
str++;
} else {
/* Get file id and move str to next component. */
ino = strtouq(str, &str, 10);
}
/* Get the target vnode. */
if (ino == 2) {
error = VFS_ROOT(mp, &vp, ctx);
} else {
error = VFS_VGET(mp, ino, &vp, ctx);
}
vfs_unbusy(mp);
if (error) {
goto out;
}
realpath[0] = '\0';
/* Get the absolute path to this vnode. */
error = build_path(vp, realpath, bufsize, &length, 0, ctx);
vnode_put(vp);
if (error == 0 && *str != '\0') {
int attempt = strlcat(realpath, str, MAXPATHLEN);
if (attempt > MAXPATHLEN){
error = ENAMETOOLONG;
}
}
out:
return (error);
}
STATIC struct dentry *
linvfs_get_dentry(
struct super_block *sb,
void *data)
{
vnode_t *vp;
struct inode *inode;
struct dentry *result;
xfs_fid2_t xfid;
vfs_t *vfsp = LINVFS_GET_VFS(sb);
int error;
xfid.fid_len = sizeof(xfs_fid2_t) - sizeof(xfid.fid_len);
xfid.fid_pad = 0;
xfid.fid_gen = ((__u32 *)data)[1];
xfid.fid_ino = ((__u32 *)data)[0];
VFS_VGET(vfsp, &vp, (fid_t *)&xfid, error);
if (error || vp == NULL)
return ERR_PTR(-ESTALE) ;
inode = LINVFS_GET_IP(vp);
result = d_alloc_anon(inode);
if (!result) {
iput(inode);
return ERR_PTR(-ENOMEM);
}
return result;
}
void *
osi_UFSOpen(afs_dcache_id_t *ainode)
{
struct osi_file *afile;
struct vnode *vp;
extern int cacheDiskType;
afs_int32 code;
AFS_STATCNT(osi_UFSOpen);
if (cacheDiskType != AFS_FCACHE_TYPE_UFS)
osi_Panic("UFSOpen called for non-UFS cache\n");
afile = (struct osi_file *)osi_AllocSmallSpace(sizeof(struct osi_file));
AFS_GUNLOCK();
code = VFS_VGET(cacheDev.mp, ainode->ufs, &vp);
AFS_GLOCK();
if (code == 0 && vp->v_type == VNON)
code = ENOENT;
if (code) {
osi_FreeSmallSpace(afile);
osi_Panic("UFSOpen: igetinode failed");
}
VOP_UNLOCK(vp, 0, curproc);
afile->vnode = vp;
#ifdef AFS_OBSD39_ENV
afile->size = VTOI(vp)->i_ffs1_size;
#else
afile->size = VTOI(vp)->i_ffs_size;
#endif
afile->offset = 0;
afile->proc = NULL;
return (void *)afile;
}
void *
osi_UFSOpen(afs_dcache_id_t *ainode)
{
struct osi_file *afile;
struct vnode *vp;
extern int cacheDiskType;
afs_int32 code;
AFS_STATCNT(osi_UFSOpen);
if (cacheDiskType != AFS_FCACHE_TYPE_UFS)
osi_Panic("UFSOpen called for non-UFS cache\n");
afile = (struct osi_file *)osi_AllocSmallSpace(sizeof(struct osi_file));
AFS_GUNLOCK();
code = VFS_VGET(afs_cacheVfsp, (ino_t) ainode->ufs, LK_EXCLUSIVE, &vp);
AFS_GLOCK();
if (code == 0 && vp->v_type == VNON)
code = ENOENT;
if (code) {
osi_FreeSmallSpace(afile);
osi_Panic("UFSOpen: igetinode failed");
}
#if defined(AFS_FBSD80_ENV)
VOP_UNLOCK(vp, 0);
#else
VOP_UNLOCK(vp, 0, curthread);
#endif
afile->vnode = vp;
afile->size = VTOI(vp)->i_size;
afile->offset = 0;
afile->proc = NULL;
return (void *)afile;
}
int
fusefs_symlink(void *v)
{
struct vop_symlink_args *ap = v;
struct vnode **vpp = ap->a_vpp;
struct componentname *cnp = ap->a_cnp;
struct vnode *dvp = ap->a_dvp;
struct proc *p = cnp->cn_proc;
char *target = ap->a_target;
struct fusefs_node *dp;
struct fusefs_mnt *fmp;
struct fusebuf *fbuf;
struct vnode *tdp;
int error = 0;
int len;
dp = VTOI(dvp);
fmp = (struct fusefs_mnt *)dp->ufs_ino.i_ump;
if (!fmp->sess_init || (fmp->undef_op & UNDEF_SYMLINK)) {
error = ENOSYS;
goto bad;
}
len = strlen(target) + 1;
fbuf = fb_setup(len + cnp->cn_namelen + 1, dp->ufs_ino.i_number,
FBT_SYMLINK, p);
memcpy(fbuf->fb_dat, cnp->cn_nameptr, cnp->cn_namelen);
fbuf->fb_dat[cnp->cn_namelen] = '\0';
memcpy(&fbuf->fb_dat[cnp->cn_namelen + 1], target, len);
error = fb_queue(fmp->dev, fbuf);
if (error) {
if (error == ENOSYS)
fmp->undef_op |= UNDEF_SYMLINK;
fb_delete(fbuf);
goto bad;
}
if ((error = VFS_VGET(fmp->mp, fbuf->fb_ino, &tdp))) {
fb_delete(fbuf);
goto bad;
}
tdp->v_type = VLNK;
VTOI(tdp)->vtype = tdp->v_type;
VTOI(tdp)->parent = dp->ufs_ino.i_number;
VN_KNOTE(ap->a_dvp, NOTE_WRITE);
*vpp = tdp;
fb_delete(fbuf);
vput(tdp);
bad:
vput(dvp);
return (error);
}
/*
* Allocate an inode in the file system.
*
* we leave the actual allocation strategy to the (modified)
* ext2_new_inode(), to make sure we get the policies right
*/
int
ext2_valloc(struct vnode *pvp, int mode, struct ucred *cred, struct vnode **vpp)
{
struct inode *pip;
struct ext2_sb_info *fs;
struct inode *ip;
ino_t ino;
int i, error;
*vpp = NULL;
pip = VTOI(pvp);
fs = pip->i_e2fs;
if (fs->s_es->s_free_inodes_count == 0)
goto noinodes;
/* call the Linux routine - it returns the inode number only */
ino = ext2_new_inode(pip, mode);
if (ino == 0)
goto noinodes;
error = VFS_VGET(pvp->v_mount, NULL, ino, vpp);
if (error) {
EXT2_VFREE(pvp, ino, mode);
return (error);
}
ip = VTOI(*vpp);
/*
the question is whether using VGET was such good idea at all -
Linux doesn't read the old inode in when it's allocating a
new one. I will set at least i_size & i_blocks the zero.
*/
ip->i_mode = 0;
ip->i_size = 0;
ip->i_blocks = 0;
ip->i_flags = 0;
/* now we want to make sure that the block pointers are zeroed out */
for (i = 0; i < NDADDR; i++)
ip->i_db[i] = 0;
for (i = 0; i < NIADDR; i++)
ip->i_ib[i] = 0;
/*
* Set up a new generation number for this inode.
* XXX check if this makes sense in ext2
*/
if (ip->i_gen == 0 || ++ip->i_gen == 0)
ip->i_gen = krandom() / 2 + 1;
/*
kprintf("ext2_valloc: allocated inode %d\n", ino);
*/
return (0);
noinodes:
ext2_fserr(fs, cred->cr_uid, "out of inodes");
uprintf("\n%s: create/symlink failed, no inodes free\n", fs->fs_fsmnt);
return (ENOSPC);
}
/*
* Check if source directory is in the path of the target directory.
* Target is supplied locked, source is unlocked.
* The target is always vput before returning.
*/
int
ext2_checkpath(struct inode *source, struct inode *target, struct ucred *cred)
{
struct vnode *vp;
int error, rootino, namlen;
struct dirtemplate dirbuf;
vp = ITOV(target);
if (target->i_number == source->i_number) {
error = EEXIST;
goto out;
}
rootino = ROOTINO;
error = 0;
if (target->i_number == rootino)
goto out;
for (;;) {
if (vp->v_type != VDIR) {
error = ENOTDIR;
break;
}
error = vn_rdwr(UIO_READ, vp, (caddr_t)&dirbuf,
sizeof (struct dirtemplate), (off_t)0,
UIO_SYSSPACE, IO_NODELOCKED, cred, NULL);
if (error != 0)
break;
namlen = dirbuf.dotdot_type; /* like ufs little-endian */
if (namlen != 2 ||
dirbuf.dotdot_name[0] != '.' ||
dirbuf.dotdot_name[1] != '.') {
error = ENOTDIR;
break;
}
if (dirbuf.dotdot_ino == source->i_number) {
error = EINVAL;
break;
}
if (dirbuf.dotdot_ino == rootino)
break;
vput(vp);
if ((error = VFS_VGET(vp->v_mount, NULL, dirbuf.dotdot_ino, &vp)) != 0) {
vp = NULL;
break;
}
}
out:
if (error == ENOTDIR)
kprintf("checkpath: .. not a directory\n");
if (vp != NULL)
vput(vp);
return (error);
}
static int
chfs_root(struct mount *mp, struct vnode **vpp)
{
struct vnode *vp;
int error;
if ((error = VFS_VGET(mp, (ino_t)UFS_ROOTINO, &vp)) != 0)
return error;
*vpp = vp;
return 0;
}
/*
* Return the root of a filesystem.
*/
int
ufs_root(struct mount *mp, struct vnode **vpp)
{
struct vnode *nvp;
int error;
if ((error = VFS_VGET(mp, ROOTINO, &nvp)) != 0)
return (error);
*vpp = nvp;
return (0);
}
/*
* Return the root of a filesystem.
*/
static int
ext2_root(struct mount *mp, int flags, struct vnode **vpp)
{
struct vnode *nvp;
int error;
error = VFS_VGET(mp, EXT2_ROOTINO, LK_EXCLUSIVE, &nvp);
if (error)
return (error);
*vpp = nvp;
return (0);
}
/*
* Return the root vnode.
*
* Returns 0 on success.
*/
static int
efs_root(struct mount *mp, struct vnode **vpp)
{
int err;
struct vnode *vp;
if ((err = VFS_VGET(mp, EFS_ROOTINO, &vp)))
return (err);
*vpp = vp;
return (0);
}
int
adosfs_root(struct mount *mp, struct vnode **vpp)
{
struct vnode *nvp;
int error;
if ((error = VFS_VGET(mp, (ino_t)VFSTOADOSFS(mp)->rootb, &nvp)) != 0)
return (error);
/* XXX verify it's a root block? */
*vpp = nvp;
return (0);
}
static int
ext2_root(struct mount *mp, struct vnode **vpp)
{
struct vnode *nvp;
int error;
error = VFS_VGET(mp, NULL, (ino_t)ROOTINO, &nvp);
if (error)
return (error);
*vpp = nvp;
return (0);
}
/*
* Allocate an inode in the file system.
*
* If allocating a directory, use ext2fs_dirpref to select the inode.
* If allocating in a directory, the following hierarchy is followed:
* 1) allocate the preferred inode.
* 2) allocate an inode in the same cylinder group.
* 3) quadradically rehash into other cylinder groups, until an
* available inode is located.
* If no inode preference is given the following hierarchy is used
* to allocate an inode:
* 1) allocate an inode in cylinder group 0.
* 2) quadradically rehash into other cylinder groups, until an
* available inode is located.
*/
int
ext2fs_valloc(struct vnode *pvp, int mode, kauth_cred_t cred,
struct vnode **vpp)
{
struct inode *pip;
struct m_ext2fs *fs;
struct inode *ip;
ino_t ino, ipref;
int cg, error;
*vpp = NULL;
pip = VTOI(pvp);
fs = pip->i_e2fs;
if (fs->e2fs.e2fs_ficount == 0)
goto noinodes;
if ((mode & IFMT) == IFDIR)
cg = ext2fs_dirpref(fs);
else
cg = ino_to_cg(fs, pip->i_number);
ipref = cg * fs->e2fs.e2fs_ipg + 1;
ino = (ino_t)ext2fs_hashalloc(pip, cg, (long)ipref, mode, ext2fs_nodealloccg);
if (ino == 0)
goto noinodes;
error = VFS_VGET(pvp->v_mount, ino, vpp);
if (error) {
ext2fs_vfree(pvp, ino, mode);
return (error);
}
ip = VTOI(*vpp);
if (ip->i_e2fs_mode && ip->i_e2fs_nlink != 0) {
printf("mode = 0%o, nlinks %d, inum = %llu, fs = %s\n",
ip->i_e2fs_mode, ip->i_e2fs_nlink,
(unsigned long long)ip->i_number, fs->e2fs_fsmnt);
panic("ext2fs_valloc: dup alloc");
}
memset(ip->i_din.e2fs_din, 0, sizeof(struct ext2fs_dinode));
/*
* Set up a new generation number for this inode.
*/
if (++ext2gennumber < time_second)
ext2gennumber = time_second;
ip->i_e2fs_gen = ext2gennumber;
return (0);
noinodes:
ext2fs_fserr(fs, kauth_cred_geteuid(cred), "out of inodes");
uprintf("\n%s: create/symlink failed, no inodes free\n", fs->e2fs_fsmnt);
return (ENOSPC);
}
/*
* Obtain the vnode from the underlying filesystem.
*/
static int
lo_vget(struct vfs *vfsp, struct vnode **vpp, struct fid *fidp)
{
vnode_t *realrootvp;
#ifdef LODEBUG
lo_dprint(4, "lo_vget: %p\n", vfsp);
#endif
(void) lo_realvfs(vfsp, &realrootvp);
if (realrootvp != NULL)
return (VFS_VGET(realrootvp->v_vfsp, vpp, fidp));
else
return (EIO);
}
static int
VMBlockVFSVGet(struct mount *mp, // IN: vmblock file system
ino_t ino, // IN: requested inode number
int flags, // IN: vget(9) locking flags
struct vnode **vpp) // OUT: located vnode
{
int error;
error = VFS_VGET(MNTTOVMBLOCKMNT(mp)->mountVFS, ino, flags, vpp);
if (error) {
return error;
}
return VMBlockNodeGet(mp, *vpp, vpp, NULL);
}
/*
* This function is invoked after a log is replayed to
* disk to perform logical cleanup actions as described by
* the log
*/
void
ffs_wapbl_replay_finish(struct mount *mp)
{
struct wapbl_replay *wr = mp->mnt_wapbl_replay;
int i;
int error;
if (!wr)
return;
KDASSERT((mp->mnt_flag & MNT_RDONLY) == 0);
for (i = 0; i < wr->wr_inodescnt; i++) {
struct vnode *vp;
struct inode *ip;
error = VFS_VGET(mp, wr->wr_inodes[i].wr_inumber, &vp);
if (error) {
printf("ffs_wapbl_replay_finish: "
"unable to cleanup inode %u\n",
wr->wr_inodes[i].wr_inumber);
continue;
}
ip = VTOI(vp);
KDASSERT(wr->wr_inodes[i].wr_inumber == ip->i_number);
#ifdef WAPBL_DEBUG
printf("ffs_wapbl_replay_finish: "
"cleaning inode %llu size=%llu mode=%o nlink=%d\n",
ip->i_number, DIP(ip, size), DIP(ip, mode), DIP(ip, nlink));
#endif
KASSERT(DIP(ip, nlink) == 0);
/*
* The journal may have left partially allocated inodes in mode
* zero. This may occur if a crash occurs betweeen the node
* allocation in ffs_nodeallocg and when the node is properly
* initialized in ufs_makeinode. If so, just dallocate them.
*/
if (DIP(ip, mode) == 0) {
UFS_WAPBL_BEGIN(mp);
ffs_inode_free(ip, ip->i_number,
wr->wr_inodes[i].wr_imode);
UFS_WAPBL_END(mp);
}
vput(vp);
}
wapbl_replay_stop(wr);
wapbl_replay_free(wr);
mp->mnt_wapbl_replay = NULL;
}
int
hfs_root(struct mount *mp, struct vnode **vpp)
{
struct vnode *nvp;
int error;
#ifdef HFS_DEBUG
printf("vfsop = hfs_root()\n");
#endif /* HFS_DEBUG */
if ((error = VFS_VGET(mp, HFS_CNID_ROOT_FOLDER, &nvp)) != 0)
return error;
*vpp = nvp;
return 0;
}
int
v7fs_root(struct mount *mp, struct vnode **vpp)
{
struct vnode *vp;
int error;
DPRINTF("\n");
if ((error = VFS_VGET(mp, V7FS_ROOT_INODE, &vp)) != 0) {
DPRINTF("error=%d\n", error);
return error;
}
*vpp = vp;
DPRINTF("done.\n");
return 0;
}