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