src/afs/IRIX/osi_vfsops.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 /*
  11  * osi_vfsops.c for IRIX
  12  */
  13 #include <afsconfig.h>
  14 #include "afs/param.h"
  15
  16 RCSID
  17     ("$Header$");
  18
  19 #include "afs/sysincludes.h"    /* Standard vendor system headers */
  20 #include "afsincludes.h"        /* Afs-based standard headers */
  21 #include "afs/afs_stats.h"      /* statistics stuff */
  22 #include "sys/syssgi.h"
  23
  24
  25 struct vfs *afs_globalVFS = 0;
  26 struct vcache *afs_globalVp = 0;
  27
  28 #ifdef AFS_SGI_VNODE_GLUE
  29 #include <sys/invent.h>
  30 int afs_is_numa_arch;
  31 mutex_t afs_init_kern_lock;
  32 #endif
  33
  34
  35 #define SYS_setgroups SGI_SETGROUPS
  36
  37 int (*nfs_rfsdisptab_v2) () = NULL;
  38
  39 int afs_fstype;
  40 lock_t afs_rxlock;
  41
  42 #include "sys/mload.h"
  43 char *Afs_mversion = M_VERSION;
  44
  45 extern int (*setgroupsp) (int, gid_t *);
  46 extern struct afs_lock afs_xvcache;
  47 extern int idbg_afsuser();
  48 extern void afs_mpservice(void *);
  49
  50 /*
  51  * AFS fs initialization - we also plug system calls here
  52  */
  53 #define NewSystemCall(n,f,a) \
  54         syscallsw[ABI_IRIX5].sc_sysent[(n)-1000].sy_narg = a; \
  55         syscallsw[ABI_IRIX5].sc_sysent[(n)-1000].sy_call = f; \
  56         syscallsw[ABI_IRIX5].sc_sysent[(n)-1000].sy_flags = 0;
  57 extern struct vfsops Afs_vfsops, *afs_vfsopsp;
  58 extern struct vnodeops Afs_vnodeops, *afs_vnodeopsp;
  59 extern void (*afsidestroyp) (struct inode *);
  60 extern void (*afsdptoipp) (struct efs_dinode *, struct inode *);
  61 extern void (*afsiptodpp) (struct inode *, struct efs_dinode *);
  62 extern void afsidestroy(struct inode *);
  63 extern void afsdptoip(struct efs_dinode *, struct inode *);
  64 extern void afsiptodp(struct inode *, struct efs_dinode *);
  65 extern int (*idbg_prafsnodep) (vnode_t *);
  66 extern int (*idbg_afsvfslistp) (void);
  67 extern int idbg_prafsnode(vnode_t *);
  68 extern int idbg_afsvfslist(void);
  69
  70
  71 int
  72 Afs_init(struct vfssw *vswp, int fstype)
  73 {
  74     extern int Afs_syscall(), Afs_xsetgroups(), afs_pioctl(), afs_setpag();
  75     extern int icreate(), iopen(), iinc(), idec();
  76 #ifdef AFS_SGI_XFS_IOPS_ENV
  77     extern int iopen64();
  78 #else
  79     extern int iread(), iwrite();
  80 #endif
  81
  82     AFS_STATCNT(afsinit);
  83     osi_Init();
  84     afs_fstype = fstype;
  85
  86 #ifdef AFS_SGI_VNODE_GLUE
  87     /* Synchronize doing NUMA test. */
  88     mutex_init(&afs_init_kern_lock, MUTEX_DEFAULT, "init_kern_lock");
  89 #endif
  90     /*
  91      * set up pointers from main kernel into us
  92      */
  93     afs_vnodeopsp = &Afs_vnodeops;
  94     afs_vfsopsp = &Afs_vfsops;
  95     afsidestroyp = afsidestroy;
  96     afsiptodpp = afsiptodp;
  97     afsdptoipp = afsdptoip;
  98     idbg_prafsnodep = idbg_prafsnode;
  99     idbg_afsvfslistp = idbg_afsvfslist;
 100     NewSystemCall(AFS_SYSCALL, Afs_syscall, 6);
 101     NewSystemCall(AFS_PIOCTL, afs_pioctl, 4);
 102     NewSystemCall(AFS_SETPAG, afs_setpag, 0);
 103     NewSystemCall(AFS_IOPEN, iopen, 3);
 104     NewSystemCall(AFS_ICREATE, icreate, 6);
 105     NewSystemCall(AFS_IINC, iinc, 3);
 106     NewSystemCall(AFS_IDEC, idec, 3);
 107 #ifdef AFS_SGI_XFS_IOPS_ENV
 108     NewSystemCall(AFS_IOPEN64, iopen64, 4);
 109 #else
 110     NewSystemCall(AFS_IREAD, iread, 6);
 111     NewSystemCall(AFS_IWRITE, iwrite, 6);
 112 #endif
 113
 114     /* last replace these */
 115     setgroupsp = Afs_xsetgroups;
 116
 117     idbg_addfunc("afsuser", idbg_afsuser);
 118     return (0);
 119 }
 120
 121
 122 extern int afs_mount(), afs_unmount(), afs_root(), afs_statfs();
 123 #ifdef AFS_SGI65_ENV
 124 extern int afs_sync(OSI_VFS_DECL(afsp), int flags, struct cred *cr);
 125 #else
 126 extern int afs_sync(OSI_VFS_DECL(afsp), short flags, struct cred *cr);
 127 #endif
 128 extern int afs_vget(OSI_VFS_DECL(afsp), vnode_t ** vpp, struct fid *afidp);
 129 #ifdef MP
 130 struct vfsops afs_lockedvfsops =
 131 #else
 132 struct vfsops Afs_vfsops =
 133 #endif
 134 {
 135 #ifdef AFS_SGI64_ENV
 136 #ifdef AFS_SGI65_ENV
 137     BHV_IDENTITY_INIT_POSITION(VFS_POSITION_BASE),
 138 #else
 139     VFS_POSITION_BASE,
 140 #endif
 141 #endif
 142     afs_mount,
 143 #ifdef AFS_SGI64_ENV
 144     fs_nosys,                   /* rootinit */
 145     fs_nosys,                   /* mntupdate */
 146     fs_dounmount,
 147 #endif
 148     afs_unmount,
 149     afs_root,
 150     afs_statfs,
 151     afs_sync,
 152     afs_vget,
 153     fs_nosys,                   /* mountroot */
 154 #ifdef AFS_SGI65_ENV
 155     fs_nosys,                   /* realvfsops */
 156     fs_import,                  /* import */
 157     fs_nosys,                   /* quotactl */
 158 #else
 159     fs_nosys,                   /* swapvp */
 160 #endif
 161 };
 162 extern struct afs_q VLRU;       /*vcache LRU */
 163
 164 #ifdef AFS_SGI64_ENV
 165 static bhv_desc_t afs_vfs_bhv;
 166 #endif
 167 afs_mount(struct vfs *afsp, vnode_t * mvp, struct mounta *uap,
 168 #ifdef AFS_SGI65_ENV
 169           char *attrs,
 170 #endif
 171           cred_t * cr)
 172 {
 173     AFS_STATCNT(afs_mount);
 174
 175     if (!suser())
 176         return EPERM;
 177
 178     if (mvp->v_type != VDIR)
 179         return ENOTDIR;
 180
 181     if (afs_globalVFS) {        /* Don't allow remounts. */
 182         return EBUSY;
 183     }
 184
 185     afs_globalVFS = afsp;
 186     afsp->vfs_bsize = 8192;
 187     afsp->vfs_fsid.val[0] = AFS_VFSMAGIC;       /* magic */
 188     afsp->vfs_fsid.val[1] = afs_fstype;
 189 #ifdef AFS_SGI64_ENV
 190     vfs_insertbhv(afsp, &afs_vfs_bhv, &Afs_vfsops, &afs_vfs_bhv);
 191 #else
 192     afsp->vfs_data = NULL;
 193 #endif
 194     afsp->vfs_fstype = afs_fstype;
 195     afsp->vfs_dev = 0xbabebabe; /* XXX this should be unique */
 196
 197 #ifndef AFS_NONFSTRANS
 198     if (nfs_rfsdisptab_v2)
 199         afs_xlatorinit_v2(nfs_rfsdisptab_v2);
 200     afs_xlatorinit_v3();
 201 #endif
 202     return 0;
 203 }
 204
 205 afs_unmount(OSI_VFS_ARG(afsp), flags, cr)
 206     OSI_VFS_DECL(afsp);
 207      int flags;
 208      cred_t *cr;
 209 {
 210     extern int afs_afs_cold_shutdown;
 211     struct vcache *tvc;
 212     vnode_t *vp, *rootvp = NULL;
 213     register struct afs_q *tq;
 214     struct afs_q *uq;
 215     int error, fv_slept;
 216     OSI_VFS_CONVERT(afsp);
 217
 218     AFS_STATCNT(afs_unmount);
 219
 220     if (!suser())
 221         return EPERM;
 222
 223     /*
 224      * flush all pages from inactive vnodes - return
 225      * EBUSY if any still in use
 226      */
 227     ObtainWriteLock(&afs_xvcache, 172);
 228     for (tq = VLRU.prev; tq != &VLRU; tq = uq) {
 229         tvc = QTOV(tq);
 230         uq = QPrev(tq);
 231         vp = (vnode_t *) tvc;
 232         if (error = afs_FlushVCache(tvc, &fv_slept))
 233             if (vp->v_flag & VROOT) {
 234                 rootvp = vp;
 235                 continue;
 236             } else {
 237                 ReleaseWriteLock(&afs_xvcache);
 238                 return error;
 239             }
 240     }
 241
 242     /*
 243      * rootvp gets lots of ref counts
 244      */
 245     if (rootvp) {
 246         tvc = VTOAFS(rootvp);
 247         if (tvc->opens || CheckLock(&tvc->lock) || LockWaiters(&tvc->lock)) {
 248             ReleaseWriteLock(&afs_xvcache);
 249             return EBUSY;
 250         }
 251         ReleaseWriteLock(&afs_xvcache);
 252         rootvp->v_count = 1;
 253         AFS_RELE(rootvp);
 254         ObtainWriteLock(&afs_xvcache, 173);
 255         afs_FlushVCache(tvc, &fv_slept);
 256     }
 257     ReleaseWriteLock(&afs_xvcache);
 258     afs_globalVFS = 0;
 259     afs_shutdown();
 260 #ifdef AFS_SGI65_ENV
 261     VFS_REMOVEBHV(afsp, &afs_vfs_bhv);
 262 #endif
 263     return 0;
 264 }
 265
 266
 267
 268 afs_root(OSI_VFS_ARG(afsp), avpp)
 269     OSI_VFS_DECL(afsp);
 270      struct vnode **avpp;
 271 {
 272     register afs_int32 code = 0;
 273     struct vrequest treq;
 274     register struct vcache *tvp = 0;
 275     OSI_VFS_CONVERT(afsp);
 276
 277     AFS_STATCNT(afs_root);
 278     if (afs_globalVp && (afs_globalVp->states & CStatd)) {
 279         tvp = afs_globalVp;
 280     } else {
 281         if (afs_globalVp) {
 282             afs_PutVCache(afs_globalVp);
 283             afs_globalVp = NULL;
 284         }
 285
 286         if (!(code = afs_InitReq(&treq, OSI_GET_CURRENT_CRED()))
 287             && !(code = afs_CheckInit())) {
 288             tvp = afs_GetVCache(&afs_rootFid, &treq, NULL, NULL);
 289             /* we really want this to stay around */
 290             if (tvp) {
 291                 afs_globalVp = tvp;
 292             } else
 293                 code = ENOENT;
 294         }
 295     }
 296     if (tvp) {
 297         int s;
 298         VN_HOLD(AFSTOV(tvp));
 299         s = VN_LOCK(AFSTOV(tvp));
 300         AFSTOV(tvp)->v_flag |= VROOT;
 301         VN_UNLOCK(AFSTOV(tvp), s);
 302
 303         afs_globalVFS = afsp;
 304         *avpp = AFSTOV(tvp);
 305     }
 306
 307     afs_Trace2(afs_iclSetp, CM_TRACE_VFSROOT, ICL_TYPE_POINTER, *avpp,
 308                ICL_TYPE_INT32, code);
 309     return code;
 310 }
 311
 312 afs_statfs(OSI_VFS_ARG(afsp), abp, avp)
 313     OSI_VFS_DECL(afsp);
 314      struct statvfs *abp;
 315      struct vnode *avp;         /* unused */
 316 {
 317     OSI_VFS_CONVERT(afsp);
 318
 319     AFS_STATCNT(afs_statfs);
 320     abp->f_bsize = afsp->vfs_bsize;
 321     abp->f_frsize = afsp->vfs_bsize;
 322     /* Fake a high number below to satisfy programs that use the statfs
 323      * call to make sure that there's enough space in the device partition
 324      * before storing something there.
 325      */
 326     abp->f_blocks = abp->f_bfree = abp->f_bavail = abp->f_files =
 327         abp->f_ffree = abp->f_favail = 900000;
 328
 329     abp->f_fsid = AFS_VFSMAGIC; /* magic */
 330     strcpy(abp->f_basetype, AFS_MOUNT_AFS);
 331     abp->f_flag = 0;
 332     abp->f_namemax = 256;
 333     return 0;
 334 }
 335
 336
 337
 338 /*
 339  * sync's responsibilities include pushing back DELWRI pages
 340  * Things to watch out for:
 341  *      1) don't want to hold off new vnodes in the file system
 342  *              while pushing back pages
 343  *      2) since we can deal with un-referenced vndoes need to watch
 344  *              races with folks who recycle vnodes
 345  * Flags:
 346  *      SYNC_BDFLUSH - do NOT sleep waiting for an inode - also, when
 347  *                      when pushing DELWRI - only push old ones.
 348  *      SYNC_PDFLUSH - push v_dpages.
 349  *      SYNC_ATTR    - sync attributes - note that ordering considerations
 350  *                      dictate that we also flush dirty pages
 351  *      SYNC_WAIT    - do synchronouse writes - inode & delwri
 352  *      SYNC_NOWAIT  - start delayed writes.
 353  *      SYNC_DELWRI  - look at inodes w/ delwri pages. Other flags
 354  *                      decide how to deal with them.
 355  *      SYNC_CLOSE   - flush delwri and invalidate others.
 356  *      SYNC_FSDATA  - push fs data (e.g. superblocks)
 357  */
 358
 359 extern afs_int32 vcachegen;
 360 #define PREEMPT_MASK    0x7f
 361 #ifdef AFS_SGI64_ENV
 362 #define PREEMPT()
 363 #endif
 364
 365 int
 366 afs_sync(OSI_VFS_DECL(afsp),
 367 #ifdef AFS_SGI65_ENV
 368          int flags,
 369 #else
 370          short flags,
 371 #endif
 372          struct cred *cr)
 373 {
 374     /* Why enable the vfs sync operation?? */
 375     int error, lasterr, preempt;
 376     struct vcache *tvc;
 377     struct vnode *vp;
 378     afs_uint32 lvcachegen;
 379     register struct afs_q *tq;
 380     struct afs_q *uq;
 381     int s;
 382     OSI_VFS_CONVERT(afsp);
 383
 384     error = lasterr = 0;
 385     /*
 386      * if not interested in vnodes, skip all this
 387      */
 388 #ifdef AFS_SGI61_ENV
 389     if ((flags & (SYNC_CLOSE | SYNC_DELWRI | SYNC_PDFLUSH)) == 0)
 390         goto end;
 391 #else /* AFS_SGI61_ENV */
 392     if ((flags & (SYNC_CLOSE | SYNC_DELWRI | SYNC_ATTR)) == 0)
 393         goto end;
 394 #endif /* AFS_SGI61_ENV */
 395   loop:
 396     ObtainReadLock(&afs_xvcache);
 397     for (tq = VLRU.prev; tq != &VLRU; tq = uq) {
 398         tvc = QTOV(tq);
 399         uq = QPrev(tq);
 400         vp = (vnode_t *) tvc;
 401         /*
 402          * Since we push all dirty pages on last close/VOP_INACTIVE
 403          * we are only concerned with vnodes with
 404          * active reference counts.
 405          */
 406         s = VN_LOCK(vp);
 407         if (vp->v_count == 0) {
 408             VN_UNLOCK(vp, s);
 409             continue;
 410         }
 411         if ((flags & SYNC_CLOSE) == 0 && !AFS_VN_DIRTY(vp)) {
 412             VN_UNLOCK(vp, s);
 413             continue;
 414         }
 415
 416         /*
 417          * ignore vnodes which need no flushing
 418          */
 419         if (flags & SYNC_DELWRI) {
 420             if (!AFS_VN_DIRTY(vp)) {
 421                 VN_UNLOCK(vp, s);
 422                 continue;
 423             }
 424         }
 425 #ifdef AFS_SGI61_ENV
 426         else if (flags & SYNC_PDFLUSH) {
 427             if (!VN_GET_DPAGES(vp)) {
 428                 VN_UNLOCK(vp, s);
 429                 continue;
 430             }
 431         }
 432 #endif /* AFS_SGI61_ENV */
 433
 434         vp->v_count++;
 435         VN_UNLOCK(vp, s);
 436         lvcachegen = vcachegen;
 437         ReleaseReadLock(&afs_xvcache);
 438
 439         /*
 440          * Try to lock rwlock without sleeping.  If we can't, we must
 441          * sleep for rwlock.
 442          */
 443         if (afs_rwlock_nowait(vp, 1) == 0) {
 444 #ifdef AFS_SGI61_ENV
 445             if (flags & (SYNC_BDFLUSH | SYNC_PDFLUSH))
 446 #else /* AFS_SGI61_ENV */
 447             if (flags & SYNC_BDFLUSH)
 448 #endif /* AFS_SGI61_ENV */
 449             {
 450                 AFS_RELE(vp);
 451                 ObtainReadLock(&afs_xvcache);
 452                 if (vcachegen != lvcachegen) {
 453                     ReleaseReadLock(&afs_xvcache);
 454                     goto loop;
 455                 }
 456                 continue;
 457             }
 458             AFS_RWLOCK(vp, VRWLOCK_WRITE);
 459         }
 460
 461         AFS_GUNLOCK();
 462         if (flags & SYNC_CLOSE) {
 463             PFLUSHINVALVP(vp, (off_t) 0, (off_t) tvc->m.Length);
 464         }
 465 #ifdef AFS_SGI61_ENV
 466         else if (flags & SYNC_PDFLUSH) {
 467             if (VN_GET_DPAGES(vp)) {
 468                 pdflush(vp, B_ASYNC);
 469             }
 470         }
 471 #endif /* AFS_SGI61_ENV */
 472
 473
 474         if ((flags & SYNC_DELWRI) && AFS_VN_DIRTY(vp)) {
 475 #ifdef AFS_SGI61_ENV
 476             PFLUSHVP(vp, (off_t) tvc->m.Length,
 477                      (flags & SYNC_WAIT) ? 0 : B_ASYNC, error);
 478 #else /* AFS_SGI61_ENV */
 479             if (flags & SYNC_WAIT)
 480                 /* push all and wait */
 481                 PFLUSHVP(vp, (off_t) tvc->m.Length, (off_t) 0, error);
 482             else if (flags & SYNC_BDFLUSH) {
 483                 /* push oldest */
 484                 error = pdflush(vp, B_ASYNC);
 485             } else {
 486                 /* push all but don't wait */
 487                 PFLUSHVP(vp, (off_t) tvc->m.Length, (off_t) B_ASYNC, error);
 488             }
 489 #endif /* AFS_SGI61_ENV */
 490         }
 491
 492         /*
 493          * Release vp, check error and whether to preempt, and if
 494          * we let go of xvcache lock and someone has changed the
 495          * VLRU, restart the loop
 496          */
 497         AFS_GLOCK();
 498         AFS_RWUNLOCK(vp, VRWLOCK_WRITE);
 499         AFS_RELE(vp);
 500         if (error)
 501             lasterr = error;
 502         if ((++preempt & PREEMPT_MASK) == 0) {
 503             AFS_GUNLOCK();
 504             PREEMPT();
 505             AFS_GLOCK();
 506         }
 507         ObtainReadLock(&afs_xvcache);
 508         if (vcachegen != lvcachegen) {
 509             ReleaseReadLock(&afs_xvcache);
 510             goto loop;
 511         }
 512     }
 513     ReleaseReadLock(&afs_xvcache);
 514   end:
 515     return lasterr;
 516 }
 517
 518
 519 afs_vget(OSI_VFS_DECL(afsp), vnode_t ** avcp, struct fid * fidp)
 520 {
 521     struct VenusFid vfid;
 522     struct vrequest treq;
 523     register struct cell *tcell;
 524     register afs_int32 code = 0;
 525     afs_int32 ret;
 526
 527 #if defined(AFS_SGI64_ENV) && defined(CKPT) && !defined(_R5000_CVT_WAR)
 528     afs_fid2_t *afid2;
 529 #endif
 530
 531     OSI_VFS_CONVERT(afsp);
 532
 533     AFS_STATCNT(afs_vget);
 534
 535     *avcp = NULL;
 536
 537 #if defined(AFS_SGI64_ENV) && defined(CKPT) && !defined(_R5000_CVT_WAR)
 538     afid2 = (afs_fid2_t *) fidp;
 539     if (afid2->af_len == sizeof(afs_fid2_t) - sizeof(afid2->af_len)) {
 540         /* It's a checkpoint restart fid. */
 541         tcell = afs_GetCellByIndex(afid2->af_cell, READ_LOCK);
 542         if (!tcell) {
 543             code = ENOENT;
 544             goto out;
 545         }
 546         vfid.Cell = tcell->cellNum;
 547         afs_PutCell(tcell, READ_LOCK);
 548         vfid.Fid.Volume = afid2->af_volid;
 549         vfid.Fid.Vnode = afid2->af_vno;
 550         vfid.Fid.Unique = afid2->af_uniq;
 551
 552         if (code = afs_InitReq(&treq, OSI_GET_CURRENT_CRED()))
 553             goto out;
 554         *avcp =
 555             (vnode_t *) afs_GetVCache(&vfid, &treq, NULL, (struct vcache *)0);
 556         if (!*avcp) {
 557             code = ENOENT;
 558         }
 559         goto out;
 560     }
 561 #endif
 562
 563     if (code = afs_InitReq(&treq, OSI_GET_CURRENT_CRED()))
 564         goto out;
 565     code = afs_osi_vget((struct vcache **)avcp, fidp, &treq);
 566
 567   out:
 568     afs_Trace3(afs_iclSetp, CM_TRACE_VGET, ICL_TYPE_POINTER, *avcp,
 569                ICL_TYPE_INT32, treq.uid, ICL_TYPE_FID, &vfid);
 570     code = afs_CheckCode(code, &treq, 42);
 571     return code;
 572 }
 573
 574
 575 #ifdef MP                       /* locked versions of vfs operations. */
 576
 577 /* wrappers for vfs calls */
 578 #ifdef AFS_SGI64_ENV
 579 #define AFS_MP_VFS_ARG(A) bhv_desc_t A
 580 #else
 581 #define AFS_MP_VFS_ARG(A) struct vfs A
 582 #endif
 583
 584 int
 585 mp_afs_mount(struct vfs *a, struct vnode *b, struct mounta *c,
 586 #ifdef AFS_SGI65_ENV
 587              char *d,
 588 #endif
 589              struct cred *e)
 590 {
 591     int rv;
 592     AFS_GLOCK();
 593     rv = afs_lockedvfsops.vfs_mount(a, b, c, d
 594 #ifdef AFS_SGI65_ENV
 595                                     , e
 596 #endif
 597         );
 598     AFS_GUNLOCK();
 599     return rv;
 600 }
 601
 602 int
 603 mp_afs_unmount(AFS_MP_VFS_ARG(*a), int b, struct cred *c)
 604 {
 605     int rv;
 606     AFS_GLOCK();
 607     rv = afs_lockedvfsops.vfs_unmount(a, b, c);
 608     AFS_GUNLOCK();
 609     return rv;
 610 }
 611
 612 int
 613 mp_afs_root(AFS_MP_VFS_ARG(*a), struct vnode **b)
 614 {
 615     int rv;
 616     AFS_GLOCK();
 617     rv = afs_lockedvfsops.vfs_root(a, b);
 618     AFS_GUNLOCK();
 619     return rv;
 620 }
 621
 622 int
 623 mp_afs_statvfs(AFS_MP_VFS_ARG(*a), struct statvfs *b, struct vnode *c)
 624 {
 625     int rv;
 626     AFS_GLOCK();
 627     rv = afs_lockedvfsops.vfs_statvfs(a, b, c);
 628     AFS_GUNLOCK();
 629     return rv;
 630 }
 631
 632 int
 633 mp_afs_sync(AFS_MP_VFS_ARG(*a),
 634 #ifdef AFS_SGI65_ENV
 635             int b,
 636 #else
 637             short b,
 638 #endif
 639             struct cred *c)
 640 {
 641     int rv;
 642     AFS_GLOCK();
 643     rv = afs_lockedvfsops.vfs_sync(a, b, c);
 644     AFS_GUNLOCK();
 645     return rv;
 646 }
 647
 648 int
 649 mp_afs_vget(AFS_MP_VFS_ARG(*a), struct vnode **b, struct fid *c)
 650 {
 651     int rv;
 652     AFS_GLOCK();
 653     rv = afs_lockedvfsops.vfs_vget(a, b, c);
 654     AFS_GUNLOCK();
 655     return rv;
 656 }
 657
 658 struct vfsops Afs_vfsops = {
 659 #ifdef AFS_SGI64_ENV
 660 #ifdef AFS_SGI65_ENV
 661     BHV_IDENTITY_INIT_POSITION(VFS_POSITION_BASE),
 662 #else
 663     VFS_POSITION_BASE,
 664 #endif
 665 #endif
 666     mp_afs_mount,
 667 #ifdef AFS_SGI64_ENV
 668     fs_nosys,                   /* rootinit */
 669     fs_nosys,                   /* mntupdate */
 670     fs_dounmount,
 671 #endif
 672     mp_afs_unmount,
 673     mp_afs_root,
 674     mp_afs_statvfs,
 675     mp_afs_sync,
 676     mp_afs_vget,
 677     fs_nosys,                   /* mountroot */
 678 #ifdef AFS_SGI65_ENV
 679     fs_nosys,                   /* realvfsops */
 680     fs_import,                  /* import */
 681     fs_nosys,                   /* quotactl */
 682 #else
 683     fs_nosys,                   /* swapvp */
 684 #endif
 685 };
 686
 687 #endif /* MP */