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