#include <afsconfig.h>
#include <afs/param.h>
-RCSID
- ("$Header$");
#include <afs/sysincludes.h> /* Standard vendor system headers */
#include <afsincludes.h> /* Afs-based standard headers */
struct mount *afs_globalVFS = NULL;
int afs_pbuf_freecnt = -1;
-#ifdef AFS_FBSD50_ENV
-#define THREAD_OR_PROC struct thread *p
-#else
-#define THREAD_OR_PROC struct proc *p
-#endif
-
-extern int afs3_syscall();
extern int Afs_xsetgroups();
extern int afs_xioctl();
-static sy_call_t *old_handler;
-
+static struct syscall_helper_data afs_syscalls[] = {
+ {
+ .syscall_no = AFS_SYSCALL,
+ .new_sysent = {
+ .sy_narg = 5,
+ .sy_call = (sy_call_t *)afs3_syscall,
+ .sy_auevent = AUE_NULL,
+ },
+ },
+ SYSCALL_INIT_LAST
+};
-int
+static int
afs_init(struct vfsconf *vfc)
{
- if (sysent[AFS_SYSCALL].sy_call != nosys
- && sysent[AFS_SYSCALL].sy_call != lkmnosys) {
- printf("AFS_SYSCALL in use. aborting\n");
- return EBUSY;
+ int code;
+#if defined(FBSD_SYSCALL_REGISTER_TAKES_FLAGS)
+ code = syscall_helper_register(afs_syscalls, 0);
+#else
+ code = syscall_helper_register(afs_syscalls);
+#endif
+ if (code) {
+ printf("AFS_SYSCALL in use, error %i. aborting\n", code);
+ return code;
}
osi_Init();
afs_pbuf_freecnt = nswbuf / 2 + 1;
-#if 0
- sysent[SYS_setgroups].sy_call = Afs_xsetgroups;
- sysent[SYS_ioctl].sy_call = afs_xioctl;
-#endif
- old_handler = sysent[AFS_SYSCALL].sy_call;
- sysent[AFS_SYSCALL].sy_call = afs3_syscall;
- sysent[AFS_SYSCALL].sy_narg = 5;
return 0;
}
-int
+static int
afs_uninit(struct vfsconf *vfc)
{
if (afs_globalVFS)
return EBUSY;
-#if 0
- sysent[SYS_ioctl].sy_call = ioctl;
- sysent[SYS_setgroups].sy_call = setgroups;
-#endif
- sysent[AFS_SYSCALL].sy_narg = 0;
- sysent[AFS_SYSCALL].sy_call = old_handler;
- return 0;
-}
-int
-afs_start(struct mount *mp, int flags, THREAD_OR_PROC)
-{
- return (0); /* nothing to do. ? */
+ return syscall_helper_unregister(afs_syscalls);
}
-#ifdef AFS_FBSD53_ENV
-int
-afs_mount(struct mount *mp, struct thread *td)
+static int
+afs_statfs(struct mount *mp, struct statfs *abp)
{
- int afs_omount(struct mount *mp, char *path, caddr_t data, struct thread *p);
+ AFS_GLOCK();
+ AFS_STATCNT(afs_statfs);
+
+ abp->f_bsize = mp->vfs_bsize;
+ abp->f_iosize = mp->vfs_bsize;
+
+ abp->f_blocks = abp->f_bfree = abp->f_bavail = abp->f_files =
+ abp->f_ffree = AFS_VFS_FAKEFREE;
+
+ abp->f_fsid.val[0] = mp->mnt_stat.f_fsid.val[0];
+ abp->f_fsid.val[1] = mp->mnt_stat.f_fsid.val[1];
+ if (abp != &mp->mnt_stat) {
+ abp->f_type = mp->mnt_vfc->vfc_typenum;
+ memcpy((caddr_t) & abp->f_mntonname[0],
+ (caddr_t) mp->mnt_stat.f_mntonname, MNAMELEN);
+ memcpy((caddr_t) & abp->f_mntfromname[0],
+ (caddr_t) mp->mnt_stat.f_mntfromname, MNAMELEN);
+ }
- return afs_omount(mp, NULL, NULL, td);
+ AFS_GUNLOCK();
+ return 0;
}
-#endif
-int
-#ifdef AFS_FBSD53_ENV
-afs_omount(struct mount *mp, char *path, caddr_t data, struct thread *p)
-#else
-afs_omount(struct mount *mp, char *path, caddr_t data, struct nameidata *ndp,
- THREAD_OR_PROC)
-#endif
+static int
+afs_omount(struct mount *mp, char *path, caddr_t data)
{
/* ndp contains the mounted-from device. Just ignore it.
- * we also don't care about our proc struct. */
+ * we also don't care about our thread struct. */
size_t size;
if (mp->mnt_flag & MNT_UPDATE)
afs_globalVFS = mp;
mp->vfs_bsize = 8192;
vfs_getnewfsid(mp);
+ /*
+ * This is kind of ugly, as the interlock has grown to encompass
+ * more fields over time and there's not a good way to group the
+ * code without duplication.
+ */
+ MNT_ILOCK(mp);
+ mp->mnt_flag &= ~MNT_LOCAL;
+#if __FreeBSD_version < 1000021
+ mp->mnt_kern_flag |= MNTK_MPSAFE; /* solid steel */
+#endif
+ /*
+ * XXX mnt_stat "is considered stable as long as a ref is held".
+ * We should check that we hold the only ref.
+ */
mp->mnt_stat.f_iosize = 8192;
- if (path)
- (void) copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN - 1, &size);
+ if (path != NULL)
+ copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN - 1, &size);
+ else
+ bcopy("/afs", mp->mnt_stat.f_mntonname, size = 4);
memset(mp->mnt_stat.f_mntonname + size, 0, MNAMELEN - size);
memset(mp->mnt_stat.f_mntfromname, 0, MNAMELEN);
strcpy(mp->mnt_stat.f_mntfromname, "AFS");
/* null terminated string "AFS" will fit, just leave it be. */
strcpy(mp->mnt_stat.f_fstypename, "afs");
+ MNT_IUNLOCK(mp);
AFS_GUNLOCK();
- (void)afs_statfs(mp, &mp->mnt_stat, p);
+ afs_statfs(mp, &mp->mnt_stat);
+
return 0;
}
-#ifdef AFS_FBSD60_ENV
static int
-afs_cmount(struct mntarg *ma, void *data, int flags, struct thread *td)
+afs_mount(struct mount *mp)
{
- return kernel_mount(ma, flags);
+ return afs_omount(mp, NULL, NULL);
}
+
+static int
+#if __FreeBSD_version >= 1000004
+afs_cmount(struct mntarg *ma, void *data, uint64_t flags)
+#else
+afs_cmount(struct mntarg *ma, void *data, int flags)
#endif
+{
+ return kernel_mount(ma, flags);
+}
-int
-afs_unmount(struct mount *mp, int flags, THREAD_OR_PROC)
+static int
+afs_unmount(struct mount *mp, int flags)
{
+ int error = 0;
- /*
- * Release any remaining vnodes on this mount point.
- * The `1' means that we hold one extra reference on
- * the root vnode (this is just a guess right now).
- * This has to be done outside the global lock.
- */
-#ifdef AFS_FBSD53_ENV
- vflush(mp, 1, (flags & MNT_FORCE) ? FORCECLOSE : 0, p);
-#else
- vflush(mp, 1, (flags & MNT_FORCE) ? FORCECLOSE : 0);
-#endif
+ AFS_GLOCK();
+ if (afs_globalVp &&
+ ((flags & MNT_FORCE) || !VREFCOUNT_GT(afs_globalVp, 1))) {
+ /* Put back afs_root's ref */
+ struct vcache *gvp = afs_globalVp;
+ afs_globalVp = NULL;
+ afs_PutVCache(gvp);
+ }
+ if (afs_globalVp)
+ error = EBUSY;
+ AFS_GUNLOCK();
+
+ if (!error) {
+ /*
+ * Release any remaining vnodes on this mount point. The second
+ * argument is how many refs we hold on the root vnode. Since we
+ * released our reference to the root vnode up above, give 0.
+ */
+ error = vflush(mp, 0, (flags & MNT_FORCE) ? FORCECLOSE : 0, curthread);
+ }
+ if (error)
+ goto out;
AFS_GLOCK();
AFS_STATCNT(afs_unmount);
afs_globalVFS = 0;
- afs_shutdown();
+ afs_shutdown(AFS_WARM);
AFS_GUNLOCK();
- return 0;
+out:
+ return error;
}
-int
-#ifdef AFS_FBSD53_ENV
-afs_root(struct mount *mp, struct vnode **vpp, struct thread *td)
-#else
-afs_root(struct mount *mp, struct vnode **vpp)
-#endif
+static int
+afs_root(struct mount *mp, int flags, struct vnode **vpp)
{
int error;
struct vrequest treq;
- register struct vcache *tvp = 0;
-#ifdef AFS_FBSD50_ENV
-#ifndef AFS_FBSD53_ENV
+ struct vcache *tvp = 0;
+ struct vcache *gvp;
struct thread *td = curthread;
-#endif
- struct ucred *cr = td->td_ucred;
-#else
- struct proc *p = curproc;
- struct ucred *cr = p->p_cred->pc_ucred;
-#endif
+ struct ucred *cr = osi_curcred();
AFS_GLOCK();
AFS_STATCNT(afs_root);
crhold(cr);
- if (afs_globalVp && (afs_globalVp->states & CStatd)) {
+tryagain:
+ if (afs_globalVp && (afs_globalVp->f.states & CStatd)) {
tvp = afs_globalVp;
error = 0;
} else {
-tryagain:
- if (afs_globalVp) {
- afs_PutVCache(afs_globalVp);
- /* vrele() needed here or not? */
- afs_globalVp = NULL;
- }
-
if (!(error = afs_InitReq(&treq, cr)) && !(error = afs_CheckInit())) {
- tvp = afs_GetVCache(&afs_rootFid, &treq, NULL, NULL);
+ tvp = afs_GetVCache(&afs_rootFid, &treq);
/* we really want this to stay around */
- if (tvp)
+ if (tvp) {
+ gvp = afs_globalVp;
afs_globalVp = tvp;
- else
- error = ENOENT;
+ if (gvp) {
+ afs_PutVCache(gvp);
+ if (tvp != afs_globalVp) {
+ /* someone raced us and won */
+ afs_PutVCache(tvp);
+ goto tryagain;
+ }
+ }
+ } else
+ error = EIO;
}
}
if (tvp) {
struct vnode *vp = AFSTOV(tvp);
-#ifdef AFS_FBSD50_ENV
ASSERT_VI_UNLOCKED(vp, "afs_root");
-#endif
AFS_GUNLOCK();
+ error = vget(vp, LK_EXCLUSIVE | LK_RETRY, td);
+ AFS_GLOCK();
+ /* we dropped the glock, so re-check everything it had serialized */
+ if (!afs_globalVp || !(afs_globalVp->f.states & CStatd) ||
+ tvp != afs_globalVp) {
+ vput(vp);
+ afs_PutVCache(tvp);
+ goto tryagain;
+ }
+ if (error != 0)
+ goto tryagain;
/*
* I'm uncomfortable about this. Shouldn't this happen at a
* higher level, and shouldn't we busy the top-level directory
* to prevent recycling?
*/
-#ifdef AFS_FBSD50_ENV
- error = vget(vp, LK_EXCLUSIVE | LK_RETRY, td);
vp->v_vflag |= VV_ROOT;
-#else
- error = vget(vp, LK_EXCLUSIVE | LK_RETRY, p);
- vp->v_flag |= VROOT;
-#endif
- AFS_GLOCK();
- if (error != 0)
- goto tryagain;
afs_globalVFS = mp;
*vpp = vp;
}
- afs_Trace2(afs_iclSetp, CM_TRACE_VFSROOT, ICL_TYPE_POINTER, *vpp,
+ afs_Trace2(afs_iclSetp, CM_TRACE_VFSROOT, ICL_TYPE_POINTER, tvp ? AFSTOV(tvp) : NULL,
ICL_TYPE_INT32, error);
AFS_GUNLOCK();
crfree(cr);
return error;
}
-int
-afs_statfs(struct mount *mp, struct statfs *abp, THREAD_OR_PROC)
-{
- AFS_GLOCK();
- AFS_STATCNT(afs_statfs);
-
- abp->f_bsize = mp->vfs_bsize;
- abp->f_iosize = mp->vfs_bsize;
-
- /* Fake a high number below to satisfy programs that use the statfs call
- * to make sure that there's enough space in the device partition before
- * storing something there.
- */
- abp->f_blocks = abp->f_bfree = abp->f_bavail = abp->f_files =
- abp->f_ffree = 2000000;
-
- abp->f_fsid.val[0] = mp->mnt_stat.f_fsid.val[0];
- abp->f_fsid.val[1] = mp->mnt_stat.f_fsid.val[1];
- if (abp != &mp->mnt_stat) {
- abp->f_type = mp->mnt_vfc->vfc_typenum;
- memcpy((caddr_t) & abp->f_mntonname[0],
- (caddr_t) mp->mnt_stat.f_mntonname, MNAMELEN);
- memcpy((caddr_t) & abp->f_mntfromname[0],
- (caddr_t) mp->mnt_stat.f_mntfromname, MNAMELEN);
- }
-
- AFS_GUNLOCK();
- return 0;
-}
-
-int
-#ifdef AFS_FBSD60_ENV
-afs_sync(struct mount *mp, int waitfor, struct thread *td)
-#else
-afs_sync(struct mount *mp, int waitfor, struct ucred *cred, THREAD_OR_PROC)
-#endif
+static int
+afs_sync(struct mount *mp, int waitfor)
{
return 0;
}
-#ifdef AFS_FBSD60_ENV
struct vfsops afs_vfsops = {
.vfs_init = afs_init,
.vfs_mount = afs_mount,
.vfs_unmount = afs_unmount,
.vfs_sysctl = vfs_stdsysctl,
};
-#else
-struct vfsops afs_vfsops = {
-#ifdef AFS_FBSD53_ENV
- afs_mount,
-#endif
- afs_omount,
- afs_start,
- afs_unmount,
- afs_root,
- vfs_stdquotactl,
- afs_statfs,
- afs_sync,
- vfs_stdvget,
- vfs_stdfhtovp,
- vfs_stdcheckexp,
- vfs_stdvptofh,
- afs_init,
- afs_uninit,
- vfs_stdextattrctl,
-#ifdef AFS_FBSD50_ENV
- vfs_stdsysctl,
-#endif
-};
-#endif
git://git.openafs.org / openafs.git / blobdiff