src/afs/DARWIN/osi_vfsops.c

   1 /*
   2  * Portions Copyright (c) 2003 Apple Computer, Inc.  All rights reserved.
   3  */
   4 #include <afsconfig.h>
   5 #include <afs/param.h>
   6
   7
   8 #include <afs/sysincludes.h>    /* Standard vendor system headers */
   9 #include <afsincludes.h>        /* Afs-based standard headers */
  10 #include <afs/afs_stats.h>      /* statistics */
  11 #include <sys/malloc.h>
  12 #include <sys/namei.h>
  13 #include <sys/conf.h>
  14 #ifndef AFS_DARWIN80_ENV
  15 #include <sys/syscall.h>
  16 #endif
  17 #include <sys/sysctl.h>
  18 #include "../afs/sysctl.h"
  19
  20 #ifndef M_UFSMNT
  21 #define M_UFSMNT M_TEMP /* DARWIN80 MALLOC doesn't look at the type anyway */
  22 #endif
  23
  24 struct vcache *afs_globalVp = 0;
  25 struct mount *afs_globalVFS = 0;
  26 int afs_vfs_typenum;
  27
  28 int
  29 afs_quotactl()
  30 {
  31     return ENOTSUP;
  32 }
  33
  34 int
  35 afs_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
  36 {
  37     return (EINVAL);
  38 }
  39
  40 int
  41 afs_vptofh(struct vnode *vp, struct fid *fhp)
  42 {
  43     return (EINVAL);
  44 }
  45
  46 #ifdef AFS_DARWIN80_ENV
  47 #define CTX_TYPE vfs_context_t
  48 #define CTX_PROC_CONVERT(C) vfs_context_proc((C))
  49 #define STATFS_TYPE struct vfsstatfs
  50 #else
  51 #define CTX_TYPE struct proc *
  52 #define CTX_PROC_CONVERT(C) (C)
  53 #define STATFS_TYPE struct statfs
  54 #define vfs_statfs(VFS) &(VFS)->mnt_stat
  55 #endif
  56 #define PROC_DECL(out,in) struct proc *out = CTX_PROC_CONVERT(in)
  57
  58 int
  59 afs_start(struct mount *mp, int flags, CTX_TYPE p)
  60 {
  61     return (0);                 /* nothing to do. ? */
  62 }
  63
  64 int
  65 afs_statfs(struct mount *mp, STATFS_TYPE *abp, CTX_TYPE ctx);
  66 #ifdef AFS_DARWIN80_ENV
  67 int
  68 afs_mount(struct mount *mp, vnode_t *devvp, user_addr_t data, vfs_context_t ctx)
  69 #else
  70 int
  71 afs_mount(struct mount *mp, char *path, caddr_t data, struct nameidata *ndp, CTX_TYPE ctx)
  72 #endif
  73 {
  74     /* ndp contains the mounted-from device.  Just ignore it.
  75      * we also don't care about our proc struct. */
  76     size_t size;
  77     int error;
  78 #ifdef AFS_DARWIN80_ENV
  79     struct vfsioattr ioattr;
  80     /* vfs_statfs advertised as RO, but isn't */
  81     /* new api will be needed to initialize this information (nfs needs to
  82        set mntfromname too) */
  83 #endif
  84     STATFS_TYPE *mnt_stat = vfs_statfs(mp);
  85
  86     if (vfs_isupdate(mp))
  87         return EINVAL;
  88
  89     AFS_GLOCK();
  90     AFS_STATCNT(afs_mount);
  91
  92     if (data == 0 && afs_globalVFS) {   /* Don't allow remounts. */
  93         AFS_GUNLOCK();
  94         return (EBUSY);
  95     }
  96
  97     afs_globalVFS = mp;
  98 #ifdef AFS_DARWIN80_ENV
  99     vfs_ioattr(mp, &ioattr);
 100     ioattr.io_devblocksize = (16 * 32768);
 101     vfs_setioattr(mp, &ioattr);
 102     /* f_iosize is handled in VFS_GETATTR */
 103 #else
 104     mp->vfs_bsize = 8192;
 105     mp->mnt_stat.f_iosize = 8192;
 106 #endif
 107     vfs_getnewfsid(mp);
 108
 109 #ifndef AFS_DARWIN80_ENV
 110     (void)copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN - 1, &size);
 111     memset(mp->mnt_stat.f_mntonname + size, 0, MNAMELEN - size);
 112 #endif
 113     memset(mnt_stat->f_mntfromname, 0, MNAMELEN);
 114
 115     if (data == 0) {
 116         strcpy(mnt_stat->f_mntfromname, "AFS");
 117         /* null terminated string "AFS" will fit, just leave it be. */
 118         vfs_setfsprivate(mp, NULL);
 119     } else {
 120         struct VenusFid *rootFid = NULL;
 121         struct volume *tvp;
 122         char volName[MNAMELEN];
 123
 124         (void)copyinstr(data, volName, MNAMELEN - 1, &size);
 125         memset(volName + size, 0, MNAMELEN - size);
 126
 127         if (volName[0] == 0) {
 128             strcpy(mnt_stat->f_mntfromname, "AFS");
 129             vfs_setfsprivate(mp, &afs_rootFid);
 130         } else {
 131             struct cell *localcell = afs_GetPrimaryCell(READ_LOCK);
 132             if (localcell == NULL) {
 133                 AFS_GUNLOCK();
 134                 return ENODEV;
 135             }
 136
 137             /* Set the volume identifier to "AFS:volume.name" */
 138             snprintf(mnt_stat->f_mntfromname, MNAMELEN - 1, "AFS:%s",
 139                      volName);
 140             tvp =
 141                 afs_GetVolumeByName(volName, localcell->cellNum, 1,
 142                                     (struct vrequest *)0, READ_LOCK);
 143
 144             if (tvp) {
 145                 int volid = (tvp->roVol ? tvp->roVol : tvp->volume);
 146                 MALLOC(rootFid, struct VenusFid *, sizeof(*rootFid), M_UFSMNT,
 147                        M_WAITOK);
 148                 rootFid->Cell = localcell->cellNum;
 149                 rootFid->Fid.Volume = volid;
 150                 rootFid->Fid.Vnode = 1;
 151                 rootFid->Fid.Unique = 1;
 152             } else {
 153                 AFS_GUNLOCK();
 154                 return ENODEV;
 155             }
 156
 157             vfs_setfsprivate(mp, &rootFid);
 158         }
 159     }
 160 #ifdef AFS_DARWIN80_ENV
 161     afs_vfs_typenum=vfs_typenum(mp);
 162     vfs_setauthopaque(mp);
 163     vfs_setauthopaqueaccess(mp);
 164 #else
 165     strcpy(mp->mnt_stat.f_fstypename, "afs");
 166 #endif
 167     AFS_GUNLOCK();
 168     (void)afs_statfs(mp, mnt_stat, ctx);
 169     return 0;
 170 }
 171
 172 int
 173 afs_unmount(struct mount *mp, int flags, CTX_TYPE ctx)
 174 {
 175     void *mdata = vfs_fsprivate(mp);
 176     AFS_GLOCK();
 177     AFS_STATCNT(afs_unmount);
 178
 179     if (mdata != (qaddr_t) - 1) {
 180         if (mdata != NULL) {
 181             vfs_setfsprivate(mp, (qaddr_t) - 1);
 182             FREE(mdata, M_UFSMNT);
 183         } else {
 184             if (flags & MNT_FORCE) {
 185                 if (afs_globalVp) {
 186 #ifdef AFS_DARWIN80_ENV
 187                     afs_PutVCache(afs_globalVp);
 188 #else
 189                     AFS_GUNLOCK();
 190                     vrele(AFSTOV(afs_globalVp));
 191                     AFS_GLOCK();
 192 #endif
 193                 }
 194                 afs_globalVp = NULL;
 195                 AFS_GUNLOCK();
 196                 vflush(mp, NULLVP, FORCECLOSE/*0*/);
 197                 AFS_GLOCK();
 198                 afs_globalVFS = 0;
 199                 afs_shutdown();
 200             } else {
 201                 AFS_GUNLOCK();
 202                 return EBUSY;
 203             }
 204         }
 205         vfs_clearflags(mp, MNT_LOCAL);
 206     }
 207
 208     AFS_GUNLOCK();
 209
 210     return 0;
 211 }
 212
 213 #ifdef AFS_DARWIN80_ENV
 214 int
 215 afs_root(struct mount *mp, struct vnode **vpp, vfs_context_t ctx)
 216 #else
 217 int
 218 afs_root(struct mount *mp, struct vnode **vpp)
 219 #endif
 220 {
 221     void *mdata = vfs_fsprivate(mp);
 222     int error;
 223     struct vrequest treq;
 224     struct vcache *tvp = 0;
 225 #ifdef AFS_DARWIN80_ENV
 226     struct ucred *cr = vfs_context_ucred(ctx);
 227     int needref=0;
 228 #else
 229     struct proc *p = current_proc();
 230     struct ucred _cr;
 231     struct ucred *cr = &_cr;
 232
 233     pcred_readlock(p);
 234     _cr = *p->p_cred->pc_ucred;
 235     pcred_unlock(p);
 236 #endif
 237     AFS_GLOCK();
 238     AFS_STATCNT(afs_root);
 239     if (mdata == NULL && afs_globalVp
 240         && (afs_globalVp->f.states & CStatd)) {
 241         tvp = afs_globalVp;
 242         error = 0;
 243 #ifdef AFS_DARWIN80_ENV
 244         needref=1;
 245 #endif
 246     } else if (mdata == (qaddr_t) - 1) {
 247         error = ENOENT;
 248     } else {
 249         struct VenusFid *rootFid = (mdata == NULL)
 250             ? &afs_rootFid : (struct VenusFid *)mdata;
 251
 252         if (!(error = afs_InitReq(&treq, cr)) && !(error = afs_CheckInit())) {
 253             tvp = afs_GetVCache(rootFid, &treq, NULL, NULL);
 254 #ifdef AFS_DARWIN80_ENV
 255             if (tvp) {
 256                 AFS_GUNLOCK();
 257                 error = afs_darwin_finalizevnode(tvp, NULL, NULL, 1, 0);
 258                 AFS_GLOCK();
 259                 if (error)
 260                    tvp = NULL;
 261                 else
 262                    /* re-acquire the usecount that finalizevnode disposed of */
 263                    vnode_ref(AFSTOV(tvp));
 264             }
 265 #endif
 266             /* we really want this to stay around */
 267             if (tvp) {
 268                 if (mdata == NULL) {
 269                     if (afs_globalVp) {
 270                         afs_PutVCache(afs_globalVp);
 271                         afs_globalVp = NULL;
 272                     }
 273                     afs_globalVp = tvp;
 274 #ifdef AFS_DARWIN80_ENV
 275                     needref=1;
 276 #endif
 277                 }
 278             } else
 279                 error = ENOENT;
 280         }
 281     }
 282     if (tvp) {
 283 #ifndef AFS_DARWIN80_ENV /* DARWIN80 caller does not need a usecount reference */
 284         osi_vnhold(tvp, 0);
 285         AFS_GUNLOCK();
 286         vn_lock(AFSTOV(tvp), LK_EXCLUSIVE | LK_RETRY, p);
 287         AFS_GLOCK();
 288 #endif
 289 #ifdef AFS_DARWIN80_ENV
 290         if (needref) /* this iocount is for the caller. the initial iocount
 291                         is for the eventual afs_PutVCache. for mdata != null,
 292                         there will not be a PutVCache, so the caller gets the
 293                         initial (from GetVCache or finalizevnode) iocount*/
 294            vnode_get(AFSTOV(tvp));
 295 #endif
 296         if (mdata == NULL) {
 297             afs_globalVFS = mp;
 298         }
 299         *vpp = AFSTOV(tvp);
 300 #ifndef AFS_DARWIN80_ENV
 301         AFSTOV(tvp)->v_flag |= VROOT;
 302         AFSTOV(tvp)->v_vfsp = mp;
 303 #endif
 304     }
 305
 306     afs_Trace2(afs_iclSetp, CM_TRACE_VFSROOT, ICL_TYPE_POINTER, *vpp,
 307                ICL_TYPE_INT32, error);
 308     AFS_GUNLOCK();
 309     return error;
 310 }
 311
 312 #ifndef AFS_DARWIN80_ENV /* vget vfsop never had this prototype AFAIK */
 313 int
 314 afs_vget(struct mount *mp, int lfl, struct vnode *vp)
 315 {
 316     int error;
 317     //printf("vget called. help!\n");
 318     if (vp->v_usecount < 0) {
 319         vprint("bad usecount", vp);
 320         panic("afs_vget");
 321     }
 322     error = vget(vp, lfl, current_proc());
 323     if (!error)
 324         insmntque(vp, mp);      /* take off free list */
 325     return error;
 326 }
 327
 328 int afs_vfs_vget(struct mount *mp, void *ino, struct vnode **vpp)
 329 {
 330    return ENOENT; /* cannot implement */
 331 }
 332
 333 #endif
 334
 335 int
 336 afs_statfs(struct mount *mp, STATFS_TYPE *abp, CTX_TYPE ctx)
 337 {
 338     STATFS_TYPE *sysstat = vfs_statfs(mp);
 339     AFS_GLOCK();
 340     AFS_STATCNT(afs_statfs);
 341
 342 #ifdef AFS_DARWIN80_ENV
 343     abp->f_iosize = (256 * 1024);
 344     abp->f_bsize = vfs_devblocksize(mp);
 345 #else
 346     abp->f_bsize = mp->vfs_bsize;
 347     abp->f_iosize = mp->vfs_bsize;
 348 #endif
 349 #if 0
 350     abp->f_type = MOUNT_AFS;
 351 #endif
 352
 353     /* Fake a high number below to satisfy programs that use the statfs call
 354      * to make sure that there's enough space in the device partition before
 355      * storing something there.
 356      */
 357     abp->f_blocks = abp->f_bfree = abp->f_bavail = abp->f_files =
 358       abp->f_ffree = 0x7fffffff;
 359
 360     if (abp != sysstat) {
 361         abp->f_fsid.val[0] = sysstat->f_fsid.val[0];
 362         abp->f_fsid.val[1] = sysstat->f_fsid.val[1];
 363 #ifndef AFS_DARWIN80_ENV
 364         abp->f_type = vfs_typenum(mp);
 365 #endif
 366         memcpy((caddr_t) & abp->f_mntonname[0],
 367                (caddr_t) sysstat->f_mntonname, MNAMELEN);
 368         memcpy((caddr_t) & abp->f_mntfromname[0],
 369                (caddr_t) sysstat->f_mntfromname, MNAMELEN);
 370     }
 371
 372     AFS_GUNLOCK();
 373     return 0;
 374 }
 375
 376 #ifdef AFS_DARWIN80_ENV
 377 int
 378 afs_vfs_getattr(struct mount *mp, struct vfs_attr *outattrs,
 379                 vfs_context_t context)
 380 {
 381     VFSATTR_RETURN(outattrs, f_bsize, vfs_devblocksize(mp));
 382     VFSATTR_RETURN(outattrs, f_iosize, vfs_devblocksize(mp));
 383     VFSATTR_RETURN(outattrs, f_blocks, 2000000);
 384     VFSATTR_RETURN(outattrs, f_bfree, 2000000);
 385     VFSATTR_RETURN(outattrs, f_bavail, 2000000);
 386     VFSATTR_RETURN(outattrs, f_files, 2000000);
 387     VFSATTR_RETURN(outattrs, f_ffree, 2000000);
 388     if ( VFSATTR_IS_ACTIVE(outattrs, f_capabilities) )
 389     {
 390          vol_capabilities_attr_t *vcapattrptr;
 391          vcapattrptr = &outattrs->f_capabilities;
 392          vcapattrptr->capabilities[VOL_CAPABILITIES_FORMAT] =
 393                    VOL_CAP_FMT_SYMBOLICLINKS |
 394                    VOL_CAP_FMT_HARDLINKS |
 395                    VOL_CAP_FMT_ZERO_RUNS |
 396                    VOL_CAP_FMT_CASE_SENSITIVE |
 397                    VOL_CAP_FMT_CASE_PRESERVING |
 398                    VOL_CAP_FMT_FAST_STATFS;
 399          vcapattrptr->capabilities[VOL_CAPABILITIES_INTERFACES] =
 400                    VOL_CAP_INT_ADVLOCK |
 401                    VOL_CAP_INT_FLOCK;
 402          vcapattrptr->capabilities[VOL_CAPABILITIES_RESERVED1] = 0;
 403          vcapattrptr->capabilities[VOL_CAPABILITIES_RESERVED2] = 0;
 404
 405          /* Capabilities we know about: */
 406          vcapattrptr->valid[VOL_CAPABILITIES_FORMAT] =
 407                  VOL_CAP_FMT_PERSISTENTOBJECTIDS |
 408                  VOL_CAP_FMT_SYMBOLICLINKS |
 409                  VOL_CAP_FMT_HARDLINKS |
 410                  VOL_CAP_FMT_JOURNAL |
 411                  VOL_CAP_FMT_JOURNAL_ACTIVE |
 412                  VOL_CAP_FMT_NO_ROOT_TIMES |
 413                  VOL_CAP_FMT_SPARSE_FILES |
 414                  VOL_CAP_FMT_ZERO_RUNS |
 415                  VOL_CAP_FMT_CASE_SENSITIVE |
 416                  VOL_CAP_FMT_CASE_PRESERVING |
 417                  VOL_CAP_FMT_FAST_STATFS;
 418          vcapattrptr->valid[VOL_CAPABILITIES_INTERFACES] =
 419                  VOL_CAP_INT_SEARCHFS |
 420                  VOL_CAP_INT_ATTRLIST |
 421                  VOL_CAP_INT_NFSEXPORT |
 422                  VOL_CAP_INT_READDIRATTR |
 423                  VOL_CAP_INT_EXCHANGEDATA |
 424                  VOL_CAP_INT_COPYFILE |
 425                  VOL_CAP_INT_ALLOCATE |
 426                  VOL_CAP_INT_VOL_RENAME |
 427                  VOL_CAP_INT_ADVLOCK |
 428                  VOL_CAP_INT_FLOCK;
 429          vcapattrptr->valid[VOL_CAPABILITIES_RESERVED1] = 0;
 430          vcapattrptr->valid[VOL_CAPABILITIES_RESERVED2] = 0;
 431
 432          VFSATTR_SET_SUPPORTED(outattrs, f_capabilities);
 433     }
 434     return 0;
 435 }
 436 #endif
 437
 438 #ifdef AFS_DARWIN80_ENV
 439 int
 440 afs_sync(struct mount *mp, int waitfor, CTX_TYPE ctx)
 441 #else
 442 int
 443 afs_sync(struct mount *mp, int waitfor, struct ucred *cred, struct proc *p)
 444 #endif
 445 {
 446     return 0;
 447 }
 448
 449 u_int32_t afs_darwin_realmodes = 0;
 450 u_int32_t afs_darwin_fsevents = 0;
 451 extern int AFSDOBULK;
 452
 453 int
 454 afs_sysctl_int(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp,
 455                user_addr_t newp, size_t newlen, u_int32_t *object)
 456 {
 457 #ifdef AFS_DARWIN80_ENV
 458     int error;
 459
 460     if (oldp != USER_ADDR_NULL && oldlenp == NULL)
 461         return (EFAULT);
 462     if (oldp && *oldlenp < sizeof(u_int32_t))
 463         return (ENOMEM);
 464     if (newp && newlen != sizeof(u_int32_t))
 465         return (EINVAL);
 466     *oldlenp = sizeof(u_int32_t);
 467     if (oldp) {
 468         if ((error = copyout(object,
 469                              oldp, sizeof(u_int32_t)))) {
 470             return error;
 471         }
 472     }
 473     if (newp)
 474         return copyin(newp, object, sizeof(u_int32_t));
 475     return 0;
 476 #else
 477     return sysctl_int(oldp, oldlenp, newp, newlen,
 478                       object);
 479 #endif
 480 }
 481
 482 #ifdef AFS_DARWIN80_ENV
 483 int
 484 afs_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp,
 485                user_addr_t newp, size_t newlen, vfs_context_t context)
 486 #else
 487 int
 488 afs_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp,
 489                void *newp, size_t newlen, struct proc *p)
 490 #endif
 491 {
 492     switch (name[0]) {
 493     case AFS_SC_ALL:
 494         /* nothing defined */
 495         break;
 496     case AFS_SC_DARWIN:
 497         if (namelen < 3)
 498             return ENOENT;
 499         switch (name[1]) {
 500         case AFS_SC_DARWIN_ALL:
 501             switch (name[2]) {
 502             case AFS_SC_DARWIN_ALL_REALMODES:
 503                 return afs_sysctl_int(name, namelen, oldp, oldlenp,
 504                                       newp, newlen, &afs_darwin_realmodes);
 505             case AFS_SC_DARWIN_ALL_FSEVENTS:
 506                 return afs_sysctl_int(name, namelen, oldp, oldlenp,
 507                                       newp, newlen, &afs_darwin_fsevents);
 508             case AFS_SC_DARWIN_ALL_BULKSTAT:
 509                 return afs_sysctl_int(name, namelen, oldp, oldlenp,
 510                                       newp, newlen, &AFSDOBULK);
 511             }
 512             break;
 513             /* darwin version specific sysctl's goes here */
 514         }
 515         break;
 516     }
 517     return ENOTSUP;
 518 }
 519
 520 typedef (*PFI) ();
 521 extern int vfs_opv_numops;      /* The total number of defined vnode operations */
 522 extern struct vnodeopv_desc afs_vnodeop_opv_desc;
 523 int
 524 afs_init(struct vfsconf *vfc)
 525 {
 526 #ifndef AFS_DARWIN80_ENV /* vfs_fsadd does all this junk */
 527     int j;
 528     int (**opv_desc_vector) ();
 529     struct vnodeopv_entry_desc *opve_descp;
 530
 531
 532
 533     MALLOC(afs_vnodeop_p, PFI *, vfs_opv_numops * sizeof(PFI), M_TEMP,
 534            M_WAITOK);
 535
 536     memset(afs_vnodeop_p, 0, vfs_opv_numops * sizeof(PFI));
 537
 538     opv_desc_vector = afs_vnodeop_p;
 539     for (j = 0; afs_vnodeop_opv_desc.opv_desc_ops[j].opve_op; j++) {
 540         opve_descp = &(afs_vnodeop_opv_desc.opv_desc_ops[j]);
 541
 542         /*
 543          * Sanity check:  is this operation listed
 544          * in the list of operations?  We check this
 545          * by seeing if its offest is zero.  Since
 546          * the default routine should always be listed
 547          * first, it should be the only one with a zero
 548          * offset.  Any other operation with a zero
 549          * offset is probably not listed in
 550          * vfs_op_descs, and so is probably an error.
 551          *
 552          * A panic here means the layer programmer
 553          * has committed the all-too common bug
 554          * of adding a new operation to the layer's
 555          * list of vnode operations but
 556          * not adding the operation to the system-wide
 557          * list of supported operations.
 558          */
 559         if (opve_descp->opve_op->vdesc_offset == 0
 560             && opve_descp->opve_op->vdesc_offset != VOFFSET(vop_default)) {
 561             printf("afs_init: operation %s not listed in %s.\n",
 562                    opve_descp->opve_op->vdesc_name, "vfs_op_descs");
 563             panic("load_afs: bad operation");
 564         }
 565         /*
 566          * Fill in this entry.
 567          */
 568         opv_desc_vector[opve_descp->opve_op->vdesc_offset] =
 569             opve_descp->opve_impl;
 570     }
 571
 572     /*
 573      * Finally, go back and replace unfilled routines
 574      * with their default.  (Sigh, an O(n^3) algorithm.  I
 575      * could make it better, but that'd be work, and n is small.)
 576      */
 577
 578     /*
 579      * Force every operations vector to have a default routine.
 580      */
 581     opv_desc_vector = afs_vnodeop_p;
 582     if (opv_desc_vector[VOFFSET(vop_default)] == NULL) {
 583         panic("afs_init: operation vector without default routine.");
 584     }
 585     for (j = 0; j < vfs_opv_numops; j++)
 586         if (opv_desc_vector[j] == NULL)
 587             opv_desc_vector[j] = opv_desc_vector[VOFFSET(vop_default)];
 588 #endif
 589     return 0;
 590 }
 591
 592 struct vfsops afs_vfsops = {
 593    afs_mount,
 594    afs_start,
 595    afs_unmount,
 596    afs_root,
 597 #ifdef AFS_DARWIN80_ENV
 598    0,
 599    afs_vfs_getattr,
 600 #else
 601    afs_quotactl,
 602    afs_statfs,
 603 #endif
 604    afs_sync,
 605 #ifdef AFS_DARWIN80_ENV
 606    0,0,0,
 607 #else
 608    afs_vfs_vget,
 609    afs_fhtovp,
 610    afs_vptofh,
 611 #endif
 612    afs_init,
 613    afs_sysctl,
 614 #ifdef AFS_DARWIN80_ENV
 615    0 /*setattr */,
 616    {0}
 617 #endif
 618 };