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