freebsd: properly track vcache references

[openafs.git] / src / afs / FBSD / osi_vfsops.c

diff --git a/src/afs/FBSD/osi_vfsops.c b/src/afs/FBSD/osi_vfsops.c
index 95c5ace..b956b80 100644 (file)
--- a/src/afs/FBSD/osi_vfsops.c
+++ b/src/afs/FBSD/osi_vfsops.c
@@ -20,40 +20,72 @@ int afs_pbuf_freecnt = -1;
 extern int Afs_xsetgroups();
 extern int afs_xioctl();
 
+#if !defined(AFS_FBSD90_ENV) && !defined(AFS_FBSD82_ENV)
 static sy_call_t *old_handler;
+#else
+static struct sysent old_sysent;
 
+static struct sysent afs_sysent = {
+    5,                 /* int sy_narg */
+    (sy_call_t *) afs3_syscall,        /* sy_call_t *sy_call */
+#ifdef AFS_FBSD60_ENV
+    AUE_NULL,          /* au_event_t sy_auevent */
+#ifdef AFS_FBSD70_ENV
+    NULL,              /* systrace_args_funt_t sy_systrace_args_func */
+    0,                 /* u_int32_t sy_entry */
+    0,                 /* u_int32_t sy_return */
+#ifdef AFS_FBSD90_ENV
+    0,                 /* u_int32_t sy_flags */
+    0                  /* u_int32_t sy_thrcnt */
+#endif
+#endif
+#endif /* FBSD60 */
+};
+#endif /* FBSD90 */
 
 int
 afs_init(struct vfsconf *vfc)
 {
+    int code;
+    int offset = AFS_SYSCALL;
+#if defined(AFS_FBSD90_ENV) || defined(AFS_FBSD82_ENV)
+    code = syscall_register(&offset, &afs_sysent, &old_sysent);
+    if (code) {
+       printf("AFS_SYSCALL in use, error %i. aborting\n", code);
+       return code;
+    }
+#else
     if (sysent[AFS_SYSCALL].sy_call != nosys
-       && sysent[AFS_SYSCALL].sy_call != lkmnosys) {
-       printf("AFS_SYSCALL in use. aborting\n");
-       return EBUSY;
+        && sysent[AFS_SYSCALL].sy_call != lkmnosys) {
+        printf("AFS_SYSCALL in use. aborting\n");
+        return EBUSY;
     }
+#endif
     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
+#if !defined(AFS_FBSD90_ENV) && !defined(AFS_FBSD82_ENV)
     old_handler = sysent[AFS_SYSCALL].sy_call;
     sysent[AFS_SYSCALL].sy_call = afs3_syscall;
     sysent[AFS_SYSCALL].sy_narg = 5;
+#endif
     return 0;
 }
 
 int
 afs_uninit(struct vfsconf *vfc)
 {
+#if defined(AFS_FBSD90_ENV) || defined(AFS_FBSD82_ENV)
+    int offset = AFS_SYSCALL;
+#endif
+
     if (afs_globalVFS)
        return EBUSY;
-#if 0
-    sysent[SYS_ioctl].sy_call = ioctl;
-    sysent[SYS_setgroups].sy_call = setgroups;
-#endif
+#if defined(AFS_FBSD90_ENV) || defined(AFS_FBSD82_ENV)
+    syscall_deregister(&offset, &old_sysent);
+#else
     sysent[AFS_SYSCALL].sy_narg = 0;
     sysent[AFS_SYSCALL].sy_call = old_handler;
+#endif
     return 0;
 }
 
@@ -155,6 +187,19 @@ afs_unmount(struct mount *mp, int flags)
 afs_unmount(struct mount *mp, int flags, struct thread *p)
 #endif
 {
+    int error = 0;
+
+    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();
 
     /*
      * Release any remaining vnodes on this mount point.
@@ -162,20 +207,25 @@ afs_unmount(struct mount *mp, int flags, struct thread *p)
      * the root vnode (this is just a guess right now).
      * This has to be done outside the global lock.
      */
+    if (!error) {
 #if defined(AFS_FBSD80_ENV)
-  /* do nothing */
+       error = vflush(mp, 1, (flags & MNT_FORCE) ? FORCECLOSE : 0, curthread);
 #elif defined(AFS_FBSD53_ENV)
-    vflush(mp, 1, (flags & MNT_FORCE) ? FORCECLOSE : 0, p);
+       error = vflush(mp, 1, (flags & MNT_FORCE) ? FORCECLOSE : 0, p);
 #else
-    vflush(mp, 1, (flags & MNT_FORCE) ? FORCECLOSE : 0);
+       error = vflush(mp, 1, (flags & MNT_FORCE) ? FORCECLOSE : 0);
 #endif
+    }
+    if (error)
+       goto out;
     AFS_GLOCK();
     AFS_STATCNT(afs_unmount);
     afs_globalVFS = 0;
     afs_shutdown();
     AFS_GUNLOCK();
 
-    return 0;
+out:
+    return error;
 }
 
 int
@@ -191,7 +241,8 @@ afs_root(struct mount *mp, struct vnode **vpp)
 {
     int error;
     struct vrequest treq;
-    register struct vcache *tvp = 0;
+    struct vcache *tvp = 0;
+    struct vcache *gvp;
 #if !defined(AFS_FBSD53_ENV) || defined(AFS_FBSD80_ENV)
     struct thread *td = curthread;
 #endif
@@ -200,22 +251,26 @@ afs_root(struct mount *mp, struct vnode **vpp)
     AFS_GLOCK();
     AFS_STATCNT(afs_root);
     crhold(cr);
+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);
            /* we really want this to stay around */
-           if (tvp)
+           if (tvp) {
+               gvp = afs_globalVp;
                afs_globalVp = tvp;
-           else
+               if (gvp) {
+                   afs_PutVCache(gvp);
+                   if (tvp != afs_globalVp) {
+                       /* someone raced us and won */
+                       afs_PutVCache(tvp);
+                       goto tryagain;
+                   }
+               }
+           } else
                error = ENOENT;
        }
     }
@@ -224,16 +279,23 @@ tryagain:
 
        ASSERT_VI_UNLOCKED(vp, "afs_root");
        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?
         */
-       error = vget(vp, LK_EXCLUSIVE | LK_RETRY, td);
        vp->v_vflag |= VV_ROOT;
-       AFS_GLOCK();
-       if (error != 0)
-               goto tryagain;
 
        afs_globalVFS = mp;
        *vpp = vp;