/* afs_root - stat the root of the file system. AFS global held on entry. */
static int
afs_root(struct super_block *afsp)
{
afs_int32 code = 0;
struct vcache *tvp = 0;
AFS_STATCNT(afs_root);
if (afs_globalVp && (afs_globalVp->f.states & CStatd)) {
tvp = afs_globalVp;
} else {
struct vrequest *treq = NULL;
cred_t *credp = crref();
if (afs_globalVp) {
afs_PutVCache(afs_globalVp);
afs_globalVp = NULL;
}
if (!(code = afs_CreateReq(&treq, credp)) && !(code = afs_CheckInit())) {
tvp = afs_GetVCache(&afs_rootFid, treq, NULL, NULL);
if (tvp) {
struct inode *ip = AFSTOV(tvp);
struct vattr *vattr = NULL;
code = afs_CreateAttr(&vattr);
if (!code) {
afs_getattr(tvp, vattr, credp);
afs_fill_inode(ip, vattr);
/* setup super_block and mount point inode. */
afs_globalVp = tvp;
#if defined(HAVE_LINUX_D_MAKE_ROOT)
afsp->s_root = d_make_root(ip);
#else
afsp->s_root = d_alloc_root(ip);
#endif
#if !defined(STRUCT_SUPER_BLOCK_HAS_S_D_OP)
afsp->s_root->d_op = &afs_dentry_operations;
#endif
afs_DestroyAttr(vattr);
}
} else
code = EIO;
}
crfree(credp);
afs_DestroyReq(treq);
}
afs_Trace2(afs_iclSetp, CM_TRACE_VFSROOT, ICL_TYPE_POINTER, afs_globalVp,
ICL_TYPE_INT32, code);
return code;
}
/* afs_root - stat the root of the file system. AFS global held on entry. */
static int
afs_root(struct super_block *afsp)
{
afs_int32 code = 0;
struct vrequest treq;
struct vcache *tvp = 0;
AFS_STATCNT(afs_root);
if (afs_globalVp && (afs_globalVp->f.states & CStatd)) {
tvp = afs_globalVp;
} else {
cred_t *credp = crref();
if (afs_globalVp) {
afs_PutVCache(afs_globalVp);
afs_globalVp = NULL;
}
if (!(code = afs_InitReq(&treq, credp)) && !(code = afs_CheckInit())) {
tvp = afs_GetVCache(&afs_rootFid, &treq, NULL, NULL);
if (tvp) {
struct inode *ip = AFSTOV(tvp);
struct vattr vattr;
afs_getattr(tvp, &vattr, credp);
afs_fill_inode(ip, &vattr);
/* setup super_block and mount point inode. */
afs_globalVp = tvp;
#if defined(AFS_LINUX24_ENV)
afsp->s_root = d_alloc_root(ip);
#else
afsp->s_root = d_alloc_root(ip, NULL);
#endif
afsp->s_root->d_op = &afs_dentry_operations;
} else
code = ENOENT;
}
crfree(credp);
}
afs_Trace2(afs_iclSetp, CM_TRACE_VFSROOT, ICL_TYPE_POINTER, afs_globalVp,
ICL_TYPE_INT32, code);
return code;
}
/* afs_notify_change
* Linux version of setattr call. What to change is in the iattr struct.
* We need to set bits in both the Linux inode as well as the vcache.
*/
int
afs_notify_change(struct dentry *dp, struct iattr *iattrp)
{
struct vattr vattr;
cred_t *credp = crref();
struct inode *ip = dp->d_inode;
int code;
VATTR_NULL(&vattr);
iattr2vattr(&vattr, iattrp); /* Convert for AFS vnodeops call. */
AFS_GLOCK();
code = afs_setattr(VTOAFS(ip), &vattr, credp);
if (!code) {
afs_getattr(VTOAFS(ip), &vattr, credp);
vattr2inode(ip, &vattr);
}
AFS_GUNLOCK();
crfree(credp);
return -code;
}
/*
* Given a FID, obtain or construct a dentry, or return an error.
* This should be called with the BKL and AFS_GLOCK held.
*/
static struct dentry *get_dentry_from_fid(cred_t *credp, struct VenusFid *afid)
{
struct vrequest treq;
struct vcache *vcp;
struct vattr vattr;
struct inode *ip;
struct dentry *dp;
afs_int32 code;
code = afs_InitReq(&treq, credp);
if (code) {
#ifdef OSI_EXPORT_DEBUG
printk("afs: get_dentry_from_fid(0x%08x/%d/%d.%d): afs_InitReq: %d\n",
afid->Cell, afid->Fid.Volume, afid->Fid.Vnode, afid->Fid.Unique,
code);
#endif
return ERR_PTR(-afs_CheckCode(code, &treq, 101));
}
vcp = afs_GetVCache(afid, &treq, NULL, NULL);
if (vcp == NULL) {
#ifdef OSI_EXPORT_DEBUG
printk("afs: get_dentry_from_fid(0x%08x/%d/%d.%d): no vcache\n",
afid->Cell, afid->Fid.Volume, afid->Fid.Vnode, afid->Fid.Unique);
#endif
return NULL;
}
/*
* Now, it might be that we just caused a directory vnode to
* spring into existence, in which case its parent FID is unset.
* We need to do something about that, but only because we care
* in our own get_parent(), below -- the common code never looks
* at parentVnode on directories, except for VIOCGETVCXSTATUS.
* So, if this fails, we don't really care very much.
*/
if (vType(vcp) == VDIR && vcp->mvstat != 2 && !vcp->f.parent.vnode)
update_dir_parent(&treq, vcp);
/*
* If this is a volume root directory and fakestat is enabled,
* we might need to replace the directory by a mount point.
*/
code = UnEvalFakeStat(&treq, &vcp);
if (code) {
#ifdef OSI_EXPORT_DEBUG
printk("afs: get_dentry_from_fid(0x%08x/%d/%d.%d): UnEvalFakeStat: %d\n",
afid->Cell, afid->Fid.Volume, afid->Fid.Vnode, afid->Fid.Unique,
code);
#endif
afs_PutVCache(vcp);
return ERR_PTR(-afs_CheckCode(code, &treq, 101));
}
ip = AFSTOV(vcp);
afs_getattr(vcp, &vattr, credp);
afs_fill_inode(ip, &vattr);
/* d_alloc_anon might block, so we shouldn't hold the glock */
AFS_GUNLOCK();
dp = d_alloc_anon(ip);
AFS_GLOCK();
if (!dp) {
iput(ip);
#ifdef OSI_EXPORT_DEBUG
printk("afs: get_dentry_from_fid(0x%08x/%d/%d.%d): out of memory\n",
afid->Cell, afid->Fid.Volume, afid->Fid.Vnode, afid->Fid.Unique);
#endif
return ERR_PTR(-ENOMEM);
}
dp->d_op = &afs_dentry_operations;
return dp;
}
int
afs_CheckRootVolume(void)
{
char rootVolName[32];
struct volume *tvp = NULL;
int usingDynroot = afs_GetDynrootEnable();
int localcell;
AFS_STATCNT(afs_CheckRootVolume);
if (*afs_rootVolumeName == 0) {
strcpy(rootVolName, "root.afs");
} else {
strcpy(rootVolName, afs_rootVolumeName);
}
if (usingDynroot) {
afs_GetDynrootFid(&afs_rootFid);
tvp = afs_GetVolume(&afs_rootFid, NULL, READ_LOCK);
} else {
struct cell *lc = afs_GetPrimaryCell(READ_LOCK);
if (!lc)
return ENOENT;
localcell = lc->cellNum;
afs_PutCell(lc, READ_LOCK);
tvp = afs_GetVolumeByName(rootVolName, localcell, 1, NULL, READ_LOCK);
if (!tvp) {
char buf[128];
int len = strlen(rootVolName);
if ((len < 9) || strcmp(&rootVolName[len - 9], ".readonly")) {
strcpy(buf, rootVolName);
afs_strcat(buf, ".readonly");
tvp = afs_GetVolumeByName(buf, localcell, 1, NULL, READ_LOCK);
}
}
if (tvp) {
int volid = (tvp->roVol ? tvp->roVol : tvp->volume);
afs_rootFid.Cell = localcell;
if (afs_rootFid.Fid.Volume && afs_rootFid.Fid.Volume != volid
&& afs_globalVp) {
/* If we had a root fid before and it changed location we reset
* the afs_globalVp so that it will be reevaluated.
* Just decrement the reference count. This only occurs during
* initial cell setup and can panic the machine if we set the
* count to zero and fs checkv is executed when the current
* directory is /afs.
*/
#ifdef AFS_LINUX20_ENV
{
struct vrequest *treq = NULL;
struct vattr vattr;
cred_t *credp;
struct dentry *dp;
struct vcache *vcp;
afs_rootFid.Fid.Volume = volid;
afs_rootFid.Fid.Vnode = 1;
afs_rootFid.Fid.Unique = 1;
credp = crref();
if (afs_CreateReq(&treq, credp))
goto out;
vcp = afs_GetVCache(&afs_rootFid, treq, NULL, NULL);
if (!vcp)
goto out;
afs_getattr(vcp, &vattr, credp);
afs_fill_inode(AFSTOV(vcp), &vattr);
dp = d_find_alias(AFSTOV(afs_globalVp));
#if defined(AFS_LINUX24_ENV)
#if defined(HAVE_DCACHE_LOCK)
spin_lock(&dcache_lock);
#else
spin_lock(&AFSTOV(vcp)->i_lock);
#endif
#if defined(AFS_LINUX26_ENV)
spin_lock(&dp->d_lock);
#endif
#endif
#if defined(D_ALIAS_IS_HLIST)
hlist_del_init(&dp->d_alias);
hlist_add_head(&dp->d_alias, &(AFSTOV(vcp)->i_dentry));
#else
list_del_init(&dp->d_alias);
list_add(&dp->d_alias, &(AFSTOV(vcp)->i_dentry));
#endif
dp->d_inode = AFSTOV(vcp);
#if defined(AFS_LINUX24_ENV)
#if defined(AFS_LINUX26_ENV)
spin_unlock(&dp->d_lock);
#endif
#if defined(HAVE_DCACHE_LOCK)
spin_unlock(&dcache_lock);
#else
spin_unlock(&AFSTOV(vcp)->i_lock);
#endif
#endif
dput(dp);
AFS_FAST_RELE(afs_globalVp);
afs_globalVp = vcp;
out:
crfree(credp);
afs_DestroyReq(treq);
}
#else
#ifdef AFS_DARWIN80_ENV
afs_PutVCache(afs_globalVp);
#else
AFS_FAST_RELE(afs_globalVp);
#endif
afs_globalVp = 0;
#endif
}
afs_rootFid.Fid.Volume = volid;
afs_rootFid.Fid.Vnode = 1;
afs_rootFid.Fid.Unique = 1;
}
}
if (tvp) {
afs_initState = 300; /* won */
afs_osi_Wakeup(&afs_initState);
afs_PutVolume(tvp, READ_LOCK);
}
if (afs_rootFid.Fid.Volume)
return 0;
else
return ENOENT;
}
