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
 452 int
 453 afs_sysctl_int(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp,
 454                user_addr_t newp, size_t newlen, u_int32_t *object)
 455 {
 456 #ifdef AFS_DARWIN80_ENV
 457     int error;
 458
 459     if (oldp != USER_ADDR_NULL && oldlenp == NULL)
 460         return (EFAULT);
 461     if (oldp && *oldlenp < sizeof(u_int32_t))
 462         return (ENOMEM);
 463     if (newp && newlen != sizeof(u_int32_t))
 464         return (EINVAL);
 465     *oldlenp = sizeof(u_int32_t);
 466     if (oldp) {
 467         if ((error = copyout(object,
 468                              oldp, sizeof(u_int32_t)))) {
 469             return error;
 470         }
 471     }
 472     if (newp)
 473         return copyin(newp, object, sizeof(u_int32_t));
 474     return 0;
 475 #else
 476     return sysctl_int(oldp, oldlenp, newp, newlen,
 477                       object);
 478 #endif
 479 }
 480
 481 #ifdef AFS_DARWIN80_ENV
 482 int
 483 afs_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp,
 484                user_addr_t newp, size_t newlen, vfs_context_t context)
 485 #else
 486 int
 487 afs_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp,
 488                void *newp, size_t newlen, struct proc *p)
 489 #endif
 490 {
 491     switch (name[0]) {
 492     case AFS_SC_ALL:
 493         /* nothing defined */
 494         break;
 495     case AFS_SC_DARWIN:
 496         if (namelen < 3)
 497             return ENOENT;
 498         switch (name[1]) {
 499         case AFS_SC_DARWIN_ALL:
 500             switch (name[2]) {
 501             case AFS_SC_DARWIN_ALL_REALMODES:
 502                 return afs_sysctl_int(name, namelen, oldp, oldlenp,
 503                                       newp, newlen, &afs_darwin_realmodes);
 504             case AFS_SC_DARWIN_ALL_FSEVENTS:
 505                 return afs_sysctl_int(name, namelen, oldp, oldlenp,
 506                                       newp, newlen, &afs_darwin_fsevents);
 507             }
 508             break;
 509             /* darwin version specific sysctl's goes here */
 510         }
 511         break;
 512     }
 513     return ENOTSUP;
 514 }
 515
 516 typedef (*PFI) ();
 517 extern int vfs_opv_numops;      /* The total number of defined vnode operations */
 518 extern struct vnodeopv_desc afs_vnodeop_opv_desc;
 519 int
 520 afs_init(struct vfsconf *vfc)
 521 {
 522 #ifndef AFS_DARWIN80_ENV /* vfs_fsadd does all this junk */
 523     int j;
 524     int (**opv_desc_vector) ();
 525     struct vnodeopv_entry_desc *opve_descp;
 526
 527
 528
 529     MALLOC(afs_vnodeop_p, PFI *, vfs_opv_numops * sizeof(PFI), M_TEMP,
 530            M_WAITOK);
 531
 532     memset(afs_vnodeop_p, 0, vfs_opv_numops * sizeof(PFI));
 533
 534     opv_desc_vector = afs_vnodeop_p;
 535     for (j = 0; afs_vnodeop_opv_desc.opv_desc_ops[j].opve_op; j++) {
 536         opve_descp = &(afs_vnodeop_opv_desc.opv_desc_ops[j]);
 537
 538         /*
 539          * Sanity check:  is this operation listed
 540          * in the list of operations?  We check this
 541          * by seeing if its offest is zero.  Since
 542          * the default routine should always be listed
 543          * first, it should be the only one with a zero
 544          * offset.  Any other operation with a zero
 545          * offset is probably not listed in
 546          * vfs_op_descs, and so is probably an error.
 547          *
 548          * A panic here means the layer programmer
 549          * has committed the all-too common bug
 550          * of adding a new operation to the layer's
 551          * list of vnode operations but
 552          * not adding the operation to the system-wide
 553          * list of supported operations.
 554          */
 555         if (opve_descp->opve_op->vdesc_offset == 0
 556             && opve_descp->opve_op->vdesc_offset != VOFFSET(vop_default)) {
 557             printf("afs_init: operation %s not listed in %s.\n",
 558                    opve_descp->opve_op->vdesc_name, "vfs_op_descs");
 559             panic("load_afs: bad operation");
 560         }
 561         /*
 562          * Fill in this entry.
 563          */
 564         opv_desc_vector[opve_descp->opve_op->vdesc_offset] =
 565             opve_descp->opve_impl;
 566     }
 567
 568     /*
 569      * Finally, go back and replace unfilled routines
 570      * with their default.  (Sigh, an O(n^3) algorithm.  I
 571      * could make it better, but that'd be work, and n is small.)
 572      */
 573
 574     /*
 575      * Force every operations vector to have a default routine.
 576      */
 577     opv_desc_vector = afs_vnodeop_p;
 578     if (opv_desc_vector[VOFFSET(vop_default)] == NULL) {
 579         panic("afs_init: operation vector without default routine.");
 580     }
 581     for (j = 0; j < vfs_opv_numops; j++)
 582         if (opv_desc_vector[j] == NULL)
 583             opv_desc_vector[j] = opv_desc_vector[VOFFSET(vop_default)];
 584 #endif
 585     return 0;
 586 }
 587
 588 struct vfsops afs_vfsops = {
 589    afs_mount,
 590    afs_start,
 591    afs_unmount,
 592    afs_root,
 593 #ifdef AFS_DARWIN80_ENV
 594    0,
 595    afs_vfs_getattr,
 596 #else
 597    afs_quotactl,
 598    afs_statfs,
 599 #endif
 600    afs_sync,
 601 #ifdef AFS_DARWIN80_ENV
 602    0,0,0,
 603 #else
 604    afs_vfs_vget,
 605    afs_fhtovp,
 606    afs_vptofh,
 607 #endif
 608    afs_init,
 609    afs_sysctl,
 610 #ifdef AFS_DARWIN80_ENV
 611    0 /*setattr */,
 612    {0}
 613 #endif
 614 };