src/afs/NBSD/osi_vnodeops.c

   1 /*
   2  * OpenBSD specific vnodeops + other misc interface glue
   3  * Original NetBSD version for Transarc afs by John Kohl <jtk@MIT.EDU>
   4  * OpenBSD version by Jim Rees <rees@umich.edu>
   5  *
   6  * $Id: osi_vnodeops.c,v 1.20 2006/03/09 15:27:17 rees Exp $
   7  */
   8
   9 /*
  10 copyright 2002
  11 the regents of the university of michigan
  12 all rights reserved
  13
  14 permission is granted to use, copy, create derivative works
  15 and redistribute this software and such derivative works
  16 for any purpose, so long as the name of the university of
  17 michigan is not used in any advertising or publicity
  18 pertaining to the use or distribution of this software
  19 without specific, written prior authorization.  if the
  20 above copyright notice or any other identification of the
  21 university of michigan is included in any copy of any
  22 portion of this software, then the disclaimer below must
  23 also be included.
  24
  25 this software is provided as is, without representation
  26 from the university of michigan as to its fitness for any
  27 purpose, and without warranty by the university of
  28 michigan of any kind, either express or implied, including
  29 without limitation the implied warranties of
  30 merchantability and fitness for a particular purpose. the
  31 regents of the university of michigan shall not be liable
  32 for any damages, including special, indirect, incidental, or
  33 consequential damages, with respect to any claim arising
  34 out of or in connection with the use of the software, even
  35 if it has been or is hereafter advised of the possibility of
  36 such damages.
  37 */
  38
  39 /*
  40 Copyright 1995 Massachusetts Institute of Technology.  All Rights
  41 Reserved.
  42
  43 You are hereby granted a worldwide, irrevocable, paid-up, right and
  44 license to use, execute, display, modify, copy and distribute MIT's
  45 Modifications, provided that (i) you abide by the terms and conditions
  46 of your OpenAFS License Agreement, and (ii) you do not use the name
  47 of MIT in any advertising or publicity without the prior written consent
  48 of MIT.  MIT disclaims all liability for your use of MIT's
  49 Modifications.  MIT's Modifications are provided "AS IS" WITHOUT
  50 WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO,
  51 ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
  52 NONINFRINGEMENT.
  53 */
  54
  55 /*
  56  * A bunch of code cribbed from NetBSD ufs_vnops.c, ffs_vnops.c, and
  57  * nfs_vnops.c which carry this copyright:
  58  */
  59 /*
  60  * Copyright (c) 1982, 1986, 1989, 1993
  61  *      The Regents of the University of California.  All rights reserved.
  62  * (c) UNIX System Laboratories, Inc.
  63  * All or some portions of this file are derived from material licensed
  64  * to the University of California by American Telephone and Telegraph
  65  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  66  * the permission of UNIX System Laboratories, Inc.
  67  *
  68  * Redistribution and use in source and binary forms, with or without
  69  * modification, are permitted provided that the following conditions
  70  * are met:
  71  * 1. Redistributions of source code must retain the above copyright
  72  *    notice, this list of conditions and the following disclaimer.
  73  * 2. Redistributions in binary form must reproduce the above copyright
  74  *    notice, this list of conditions and the following disclaimer in the
  75  *    documentation and/or other materials provided with the distribution.
  76  * 3. All advertising materials mentioning features or use of this software
  77  *    must display the following acknowledgement:
  78  *      This product includes software developed by the University of
  79  *      California, Berkeley and its contributors.
  80  * 4. Neither the name of the University nor the names of its contributors
  81  *    may be used to endorse or promote products derived from this software
  82  *    without specific prior written permission.
  83  *
  84  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  85  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  86  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  87  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  88  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  89  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  90  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  91  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  92  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  93  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  94  * SUCH DAMAGE.
  95  *
  96  */
  97
  98 #include <afsconfig.h>
  99 #include "afs/param.h"
 100
 101 #include "afs/sysincludes.h"    /* Standard vendor system headers */
 102 #include "afs/afsincludes.h"    /* Afs-based standard headers */
 103 #include "afs/afs_stats.h"      /* statistics */
 104
 105 #include <sys/malloc.h>
 106 #include <sys/namei.h>
 107 #include <sys/pool.h>
 108 #include <miscfs/genfs/genfs.h>
 109
 110
 111 #include "afs/afs_cbqueue.h"
 112 #include "afs/nfsclient.h"
 113 #include "afs/afs_osidnlc.h"
 114
 115 #define M_AFSNODE (M_TEMP-1)    /* XXX */
 116
 117 int afs_nbsd_lookup(void *);
 118 int afs_nbsd_create(void *);
 119 int afs_nbsd_mknod(void *);
 120 int afs_nbsd_open(void *);
 121 int afs_nbsd_close(void *);
 122 int afs_nbsd_access(void *);
 123 int afs_nbsd_getattr(void *);
 124 int afs_nbsd_setattr(void *);
 125 int afs_nbsd_read(void *);
 126 int afs_nbsd_write(void *);
 127 int afs_nbsd_ioctl(void *);
 128 int afs_nbsd_select(void *);
 129 int afs_nbsd_fsync(void *);
 130 int afs_nbsd_remove(void *);
 131 int afs_nbsd_link(void *);
 132 int afs_nbsd_rename(void *);
 133 int afs_nbsd_mkdir(void *);
 134 int afs_nbsd_rmdir(void *);
 135 int afs_nbsd_symlink(void *);
 136 int afs_nbsd_readdir(void *);
 137 int afs_nbsd_readlink(void *);
 138 int afs_nbsd_inactive(void *);
 139 int afs_nbsd_reclaim(void *);
 140 int afs_nbsd_lock(void *);
 141 int afs_nbsd_unlock(void *);
 142 int afs_nbsd_bmap(void *);
 143 int afs_nbsd_strategy(void *);
 144 int afs_nbsd_print(void *);
 145 int afs_nbsd_islocked(void *);
 146 int afs_nbsd_pathconf(void *);
 147 int afs_nbsd_advlock(void *);
 148
 149 #if LATER
 150 int afs_nbsd_getpages(void*);
 151 #endif
 152
 153 /*
 154  * Implement:
 155  *   vop_getpages (VM)
 156  *   vop_putpages (VM)
 157  *
 158  * Someday:
 159  *   vop_mmap_desc (mmap'd IO)
 160  *
 161  * Skip:
 162  *   vop_*xtattr
 163  *
 164  * Unknown:
 165  *   vop_fcntl
 166  *
 167  */
 168
 169 #define afs_nbsd_opnotsupp \
 170         ((int (*) __P((void *)))eopnotsupp)
 171 #define afs_nbsd_reallocblks afs_nbsd_opnotsupp
 172
 173 /* Global vfs data structures for AFS. */
 174 int (**afs_vnodeop_p) __P((void *));
 175 struct vnodeopv_entry_desc afs_vnodeop_entries[] = {
 176     {&vop_default_desc, vn_default_error},
 177     {&vop_lookup_desc, afs_nbsd_lookup},        /* lookup */
 178     {&vop_create_desc, afs_nbsd_create},        /* create */
 179     {&vop_mknod_desc, afs_nbsd_mknod},          /* mknod */
 180     {&vop_open_desc, afs_nbsd_open},            /* open */
 181     {&vop_close_desc, afs_nbsd_close},          /* close */
 182     {&vop_access_desc, afs_nbsd_access},        /* access */
 183     {&vop_getattr_desc, afs_nbsd_getattr},      /* getattr */
 184     {&vop_setattr_desc, afs_nbsd_setattr},      /* setattr */
 185     {&vop_read_desc, afs_nbsd_read},            /* read */
 186     {&vop_write_desc, afs_nbsd_write},          /* write */
 187     {&vop_ioctl_desc, afs_nbsd_ioctl},          /* XXX ioctl */
 188     {&vop_poll_desc, afs_nbsd_select},          /* select */
 189     {&vop_kqfilter_desc, genfs_kqfilter },      /* kqfilter */
 190     {&vop_fsync_desc, afs_nbsd_fsync},          /* fsync */
 191     {&vop_remove_desc, afs_nbsd_remove},        /* remove */
 192     {&vop_link_desc, afs_nbsd_link},            /* link */
 193     {&vop_rename_desc, afs_nbsd_rename},        /* rename */
 194     {&vop_mkdir_desc, afs_nbsd_mkdir},          /* mkdir */
 195     {&vop_rmdir_desc, afs_nbsd_rmdir},          /* rmdir */
 196     {&vop_symlink_desc, afs_nbsd_symlink},      /* symlink */
 197     {&vop_readdir_desc, afs_nbsd_readdir},      /* readdir */
 198     {&vop_readlink_desc, afs_nbsd_readlink},    /* readlink */
 199     {&vop_abortop_desc, genfs_abortop},         /* abortop */
 200     {&vop_inactive_desc, afs_nbsd_inactive},    /* inactive */
 201     {&vop_reclaim_desc, afs_nbsd_reclaim},      /* reclaim */
 202     {&vop_lock_desc, afs_nbsd_lock},            /* lock */
 203     {&vop_unlock_desc, afs_nbsd_unlock},        /* unlock */
 204     {&vop_bmap_desc, afs_nbsd_bmap},            /* bmap */
 205     {&vop_strategy_desc, afs_nbsd_strategy},    /* strategy */
 206     {&vop_print_desc, afs_nbsd_print},          /* print */
 207     {&vop_islocked_desc, afs_nbsd_islocked},    /* islocked */
 208     {&vop_pathconf_desc, afs_nbsd_pathconf},    /* pathconf */
 209     {&vop_advlock_desc, afs_nbsd_advlock},      /* advlock */
 210 #if 0
 211     {&vop_reallocblks_desc, afs_nbsd_reallocblks},      /* reallocblks */
 212 #endif
 213     {&vop_bwrite_desc, vn_bwrite},      /* bwrite */
 214 #if LATER
 215     { &vop_getpages_desc, ffs_getpages },       /* getpages */
 216     { &vop_putpages_desc, genfs_putpages },     /* putpages */
 217 #endif
 218     {(struct vnodeop_desc *)NULL, (int (*)__P((void *)))NULL}
 219 };
 220 struct vnodeopv_desc afs_vnodeop_opv_desc =
 221     { &afs_vnodeop_p, afs_vnodeop_entries };
 222
 223 #define GETNAME() \
 224     struct componentname *cnp = ap->a_cnp; \
 225     char *name; \
 226     name = PNBUF_GET(); \
 227     bcopy(cnp->cn_nameptr, name, cnp->cn_namelen); \
 228     name[cnp->cn_namelen] = '\0'
 229
 230 #define DROPNAME() PNBUF_PUT(name)
 231 #define DROPCNP PNBUF_PUT
 232
 233 /* toss "stale" pages by shrinking the vnode uobj to a 0-length
 234  * region (see uvm_vnp_setsize in uvm_vnode.c) */
 235 #ifdef AFS_NBSD50_ENV
 236 #define VNP_UNCACHE(vp) \
 237     do {                \
 238         struct uvm_object *uobj = &vp->v_uobj; \
 239         mutex_enter(&uobj->vmobjlock); \
 240         VOP_PUTPAGES( (struct vnode *) uobj, 0 /* offlo */, 0 /* offhi */, PGO_FREE | PGO_SYNCIO); \
 241         mutex_exit(&uobj->vmobjlock); \
 242     } while(0);
 243 #else
 244 #define VNP_UNCACHE(vp) \
 245     do {                \
 246         struct uvm_object *uobj = &vp->v_uobj; \
 247         simple_lock(&uobj->vmobjlock); \
 248         VOP_PUTPAGES( (struct vnode *) uobj, 0 /* offlo */, 0 /* offhi */, PGO_FREE | PGO_SYNCIO); \
 249         simple_unlock(&uobj->vmobjlock); \
 250     } while(0);
 251 #endif
 252
 253 /* psuedo-vnop, wherein we learn that obsd and nbsd disagree
 254  * about vnode refcounting */
 255 void
 256 afs_nbsd_getnewvnode(struct vcache *tvc)
 257 {
 258     while (getnewvnode(VT_AFS, afs_globalVFS, afs_vnodeop_p, &tvc->v)) {
 259         /* no vnodes available, force an alloc (limits be damned)! */
 260         desiredvnodes++;
 261     }
 262     printf("afs_nbsd_getnewvnode: vp %p refs %d\n", tvc->v,
 263           tvc->v->v_usecount);
 264 #ifdef AFS_NBSD50_ENV
 265     mutex_enter(&tvc->v->v_interlock);
 266 #else
 267     simple_lock(&tvc->v->v_interlock);
 268 #endif
 269     tvc->v->v_data = (void *)tvc;
 270 #if 0
 271     tvc->v->v_usecount = 1; /* !locked, and vref w/v_usecount < 1 panics */
 272 #endif
 273 #ifdef AFS_NBSD50_ENV
 274     mutex_exit(&tvc->v->v_interlock);
 275 #else
 276     simple_unlock(&tvc->v->v_interlock);
 277 #endif
 278 }
 279
 280 unsigned long long afs_debug;
 281
 282 int
 283 afs_nbsd_lookup(void *v)
 284 {
 285     struct vop_lookup_args      /* {
 286                                  * struct vnodeop_desc * a_desc;
 287                                  * struct vnode *a_dvp;
 288                                  * struct vnode **a_vpp;
 289                                  * struct componentname *a_cnp;
 290                                  * } */ *ap = v;
 291     int code;
 292     struct vcache *vcp;
 293     struct vnode *vp, *dvp;
 294     int flags = ap->a_cnp->cn_flags;
 295     int lockparent;             /* 1 => lockparent flag is set */
 296
 297     if (afs_debug & AFSDEB_VNLAYER)
 298         printf("nbsd_lookup enter ap %p\n", ap);
 299
 300     GETNAME();
 301     lockparent = flags & LOCKPARENT;
 302     if (ap->a_dvp->v_type != VDIR) {
 303         *ap->a_vpp = NULL;
 304         DROPNAME();
 305         return ENOTDIR;
 306     }
 307     dvp = ap->a_dvp;
 308 /*
 309 *       v_flag was broke up into 3 separate flags. v_vflag is the
 310 *       substitute when referencing V_ROOT (which was also renamed)
 311 *
 312 *       mattjsm
 313 */
 314 #ifdef AFS_NBSD50_ENV
 315     if (afs_debug & AFSDEB_VNLAYER && !(dvp->v_vflag & VV_ROOT))
 316 #else
 317     if (afs_debug & AFSDEB_VNLAYER && !(dvp->v_flag & VROOT))
 318 #endif
 319         printf("nbsd_lookup dvp %p flags %x name %s v_usecnt %d\n", dvp, flags,
 320                name, dvp->v_usecount);
 321     AFS_GLOCK();
 322     code = afs_lookup(VTOAFS(dvp), name, &vcp, cnp->cn_cred);
 323     AFS_GUNLOCK();
 324     if (code) {
 325         if ((cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME)
 326             && (flags & ISLASTCN) && code == ENOENT)
 327             code = EJUSTRETURN;
 328         if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
 329             cnp->cn_flags |= SAVENAME;
 330         DROPNAME();
 331         *ap->a_vpp = NULL;
 332         return (code);
 333     }
 334     vp = AFSTOV(vcp); /* always get a node if no error */
 335
 336     /*
 337      * The parent directory comes in locked.  We unlock it on return
 338      * unless the caller wants it left locked.
 339      * we also always return the vnode locked.
 340      */
 341
 342     if (vp == dvp) {
 343         /* they're the same; afs_lookup() already ref'ed the leaf.
 344          * It came in locked, so we don't need to ref OR lock it */
 345         if (afs_debug & AFSDEB_VNLAYER)
 346             printf("nbsd_lookup: ref'ed %p as .\n", dvp);
 347     } else {
 348         if (!lockparent || !(flags & ISLASTCN)) {
 349             VOP_UNLOCK(dvp, 0); /* done with parent. */
 350         }
 351
 352         if (afs_debug & AFSDEB_VNLAYER)
 353             printf("nbsd_lookup dvp %p flags %x name %s v_usecnt %d\n",
 354                    dvp, flags, name, dvp->v_usecount);
 355
 356         /* XXXX hacked here, recheck OBSD and bundled--NBSD has
 357          * removed PDIRUNLOCK, so we must at least accommodate that
 358          * change. M.*/
 359         if (!VOP_ISLOCKED(vp)) {
 360             vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
 361             if (afs_debug & AFSDEB_VNLAYER)
 362                 printf("nbsd_lookup: omitting to always return child locked\n");
 363             /* vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); *//* always return the child locked */
 364         } else {
 365             if (afs_debug & AFSDEB_VNLAYER)
 366                 printf("lookup: vp %p is locked\n", vp);
 367         }
 368         if (afs_debug & AFSDEB_VNLAYER)
 369             printf("locked ret %p from lookup\n", vp);
 370     }
 371     *ap->a_vpp = vp;
 372
 373     if (((cnp->cn_nameiop == RENAME && (flags & ISLASTCN))
 374      || (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))))
 375     cnp->cn_flags |= SAVENAME;
 376
 377     DROPNAME();
 378 #ifdef AFS_NBSD50_ENV
 379     if (afs_debug & AFSDEB_VNLAYER && !(dvp->v_vflag & VV_ROOT))
 380 #else
 381     if (afs_debug & AFSDEB_VNLAYER && !(dvp->v_flag & VROOT))
 382 #endif
 383         if (afs_debug & AFSDEB_VNLAYER)
 384             printf("nbsd_lookup done ap %p dvp %p cnt %d\n", ap, dvp,
 385                    dvp->v_usecount);
 386     return (code);
 387 }
 388
 389 int
 390 afs_nbsd_create(void *v)
 391 {
 392     struct vop_create_args      /* {
 393                                  * struct vnode *a_dvp;
 394                                  * struct vnode **a_vpp;
 395                                  * struct componentname *a_cnp;
 396                                  * struct vattr *a_vap;
 397                                  * } */ *ap = v;
 398     int code = 0;
 399     struct vcache *vcp;
 400     struct vnode *dvp = ap->a_dvp;
 401     GETNAME();
 402
 403     if (afs_debug & AFSDEB_VNLAYER)
 404         printf("nbsd_create dvp %p cnt %d\n", dvp, dvp->v_usecount);
 405
 406     /* vnode layer handles excl/nonexcl */
 407
 408     AFS_GLOCK();
 409     code =
 410         afs_create(VTOAFS(dvp), name, ap->a_vap, NONEXCL, ap->a_vap->va_mode,
 411                    &vcp, cnp->cn_cred);
 412     AFS_GUNLOCK();
 413     if (code) {
 414         VOP_ABORTOP(dvp, cnp);
 415         vput(dvp);
 416         DROPNAME();
 417         return (code);
 418     }
 419
 420     if (vcp) {
 421         *ap->a_vpp = AFSTOV(vcp);
 422         vn_lock(AFSTOV(vcp), LK_EXCLUSIVE | LK_RETRY);
 423     } else
 424         *ap->a_vpp = 0;
 425
 426     if ((cnp->cn_flags & SAVESTART) == 0)
 427         DROPCNP(cnp);
 428     vput(dvp);
 429     DROPNAME();
 430     if (afs_debug & AFSDEB_VNLAYER)
 431         printf("nbsd_create done dvp %p cnt %d\n", dvp, dvp->v_usecount);
 432     return code;
 433 }
 434
 435 int
 436 afs_nbsd_mknod(void *v)
 437 {
 438     struct vop_mknod_args       /* {
 439                                  * struct vnode *a_dvp;
 440                                  * struct vnode **a_vpp;
 441                                  * struct componentname *a_cnp;
 442                                  * struct vattr *a_vap;
 443                                  * } */ *ap = v;
 444
 445     if (afs_debug & AFSDEB_VNLAYER)
 446         printf("nbsd_mknod: enter ap %p\n", ap);
 447
 448     DROPCNP(ap->a_cnp);
 449     vput(ap->a_dvp);
 450     return (ENODEV);
 451
 452     if (afs_debug & AFSDEB_VNLAYER)
 453         printf("nbsd_mknod: exit ap %p\n", ap);
 454 }
 455
 456 int
 457 afs_nbsd_open(void *v)
 458 {
 459     struct vop_open_args        /* {
 460                                  * struct vnode *a_vp;
 461                                  * int  a_mode;
 462                                  * struct ucred *a_cred;
 463                                  * struct lwp *a_l;
 464                                  * } */ *ap = v;
 465     int code;
 466     struct vnode *vp = ap->a_vp;
 467     struct vcache *vc = VTOAFS(vp);
 468
 469     if (afs_debug & AFSDEB_VNLAYER)
 470         printf("nbsd_open: enter vp %p vc %p\n", vp, vc);
 471
 472     AFS_GLOCK();
 473     code = afs_open(&vc, ap->a_mode, ap->a_cred);
 474 #ifdef DIAGNOSTIC
 475     if (AFSTOV(vc) != ap->a_vp)
 476         panic("nbsd_open: AFS open changed vnode!");
 477 #endif
 478     AFS_GUNLOCK();
 479
 480     if (afs_debug & AFSDEB_VNLAYER)
 481         printf("nbsd_open: exit vp %p vc %p\n", vp, vc);
 482
 483     return (code);
 484 }
 485
 486 int
 487 afs_nbsd_close(void *v)
 488 {
 489     struct vop_close_args       /* {
 490                                  * struct vnode *a_vp;
 491                                  * int  a_fflag;
 492                                  * kauth_cred_t a_cred;
 493                                  * struct lwp *a_l;
 494                                  * } */ *ap = v;
 495     int code;
 496     struct vnode *vp = ap->a_vp;
 497     struct vcache *vc = VTOAFS(vp);
 498
 499     if (afs_debug & AFSDEB_VNLAYER)
 500         printf("nbsd_close: enter vp %p vc %p\n", vp, vc);
 501
 502     AFS_GLOCK();
 503     code = afs_close(VTOAFS(ap->a_vp), ap->a_fflag, ap->a_cred);
 504     AFS_GUNLOCK();
 505
 506     if (afs_debug & AFSDEB_VNLAYER)
 507         printf("nbsd_close: exit vp %p vc %p\n", vp, vc);
 508
 509     return (code);
 510 }
 511
 512 int
 513 afs_nbsd_access(void *v)
 514 {
 515     struct vop_access_args      /* {
 516                                  * struct vnode *a_vp;
 517                                  * int  a_mode;
 518                                  * kauth_cred_t a_cred;
 519                                  * struct lwp *a_l;
 520                                  * } */ *ap = v;
 521     int code;
 522     struct vnode *vp = ap->a_vp;
 523     struct vcache *vc = VTOAFS(vp);
 524
 525     if (afs_debug & AFSDEB_VNLAYER)
 526         printf("nbsd_access: enter vp %p vc %p mode %d\n", vp, vc, ap->a_mode);
 527
 528     AFS_GLOCK();
 529     code = afs_access(VTOAFS(ap->a_vp), ap->a_mode, ap->a_cred);
 530     AFS_GUNLOCK();
 531
 532     if (afs_debug & AFSDEB_VNLAYER)
 533         printf("nbsd_access: exit vp %p vc %p mode %d\n", vp, vc, ap->a_mode);
 534
 535     return (code);
 536 }
 537
 538 int
 539 afs_nbsd_getattr(void *v)
 540 {
 541     struct vop_getattr_args     /* {
 542                                  * struct vnode *a_vp;
 543                                  * struct vattr *a_vap;
 544                                  * kauth_cred_t a_cred;
 545                                  * struct lwp *a_l;
 546                                  * } */ *ap = v;
 547     int code;
 548     struct vnode *vp = ap->a_vp;
 549     struct vcache *vc = VTOAFS(vp);
 550
 551     if (afs_debug & AFSDEB_VNLAYER)
 552         printf("nbsd_getattr: enter vp %p vc %p acred %p\n", vp, vc,
 553                ap->a_cred);
 554
 555     AFS_GLOCK();
 556     code = afs_getattr(VTOAFS(ap->a_vp), ap->a_vap, ap->a_cred);
 557     AFS_GUNLOCK();
 558
 559     if (afs_debug & AFSDEB_VNLAYER)
 560         printf("nbsd_getattr: exit vp %p vc %p acred %p\n", vp, vc,
 561                ap->a_cred);
 562
 563     return (code);
 564 }
 565
 566 int
 567 afs_nbsd_setattr(void *v)
 568 {
 569     struct vop_setattr_args     /* {
 570                                  * struct vnode *a_vp;
 571                                  * struct vattr *a_vap;
 572                                  * kauth_cred_t a_cred;
 573                                  * struct lwp *a_l;
 574                                  * } */ *ap = v;
 575     int code;
 576
 577     if (afs_debug & AFSDEB_VNLAYER)
 578         printf("nbsd_setattr: enter %p\n", ap);
 579
 580     AFS_GLOCK();
 581     code = afs_setattr(VTOAFS(ap->a_vp), ap->a_vap, ap->a_cred);
 582     AFS_GUNLOCK();
 583
 584     if (afs_debug & AFSDEB_VNLAYER)
 585         printf("nbsd_setattr: exit %p\n", ap);
 586
 587     return (code);
 588 }
 589
 590 int
 591 afs_nbsd_read(void *v)
 592 {
 593     struct vop_read_args        /* {
 594                                  * struct vnode *a_vp;
 595                                  * struct uio *a_uio;
 596                                  * int a_ioflag;
 597                                  * kauth_cred_t a_cred;
 598                                  * } */ *ap = v;
 599     int code;
 600
 601     if (afs_debug & AFSDEB_VNLAYER)
 602         printf("nbsd_read enter %p", ap);
 603
 604     AFS_GLOCK();
 605     code =
 606         afs_read(VTOAFS(ap->a_vp), ap->a_uio, ap->a_cred, (daddr_t) 0, NULL,
 607                  0);
 608     AFS_GUNLOCK();
 609
 610     if (afs_debug & AFSDEB_VNLAYER)
 611         printf("nbsd_read exit %p", ap);
 612
 613     return (code);
 614 }
 615
 616 int
 617 afs_nbsd_write(void *v)
 618 {
 619     struct vop_write_args       /* {
 620                                  * struct vnode *a_vp;
 621                                  * struct uio *a_uio;
 622                                  * int a_ioflag;
 623                                  * kauth_cred_t a_cred;
 624                                  * } */ *ap = v;
 625     int code;
 626
 627     if (afs_debug & AFSDEB_VNLAYER)
 628         printf("nbsd_write enter %p", ap);
 629
 630 #if 1
 631     /* all pages are really "stale?" */
 632     VNP_UNCACHE(ap->a_vp);
 633 #else
 634     (void)uvm_vnp_uncache(ap->a_vp);    /* toss stale pages */
 635 #endif
 636     AFS_GLOCK();
 637     code =
 638         afs_write(VTOAFS(ap->a_vp), ap->a_uio, ap->a_ioflag, ap->a_cred, 0);
 639     AFS_GUNLOCK();
 640
 641     if (afs_debug & AFSDEB_VNLAYER)
 642         printf("nbsd_write exit %p", ap);
 643
 644     return (code);
 645 }
 646
 647 int
 648 afs_nbsd_ioctl(void *v)
 649 {
 650     struct vop_ioctl_args       /* {
 651                                  * struct vnode *a_vp;
 652                                  * int  a_command;
 653                                  * caddr_t  a_data;
 654                                  * int  a_fflag;
 655                                  * kauth_cred_t a_cred;
 656                                  * struct lwp *a_l;
 657                                  * } */ *ap = v;
 658     int code;
 659
 660     if (afs_debug & AFSDEB_VNLAYER)
 661         printf("nbsd_ioctl: enter %p\n", ap);
 662
 663     /* in case we ever get in here... */
 664
 665     AFS_STATCNT(afs_ioctl);
 666     AFS_GLOCK();
 667     if (((ap->a_command >> 8) & 0xff) == 'V')
 668         /* This is a VICEIOCTL call */
 669         code =
 670             HandleIoctl(VTOAFS(ap->a_vp), ap->a_command,
 671                         (struct afs_ioctl *)ap->a_data);
 672     else
 673         /* No-op call; just return. */
 674         code = ENOTTY;
 675     AFS_GUNLOCK();
 676
 677     if (afs_debug & AFSDEB_VNLAYER)
 678         printf("nbsd_ioctl: exit %p\n", ap);
 679
 680     return (code);
 681 }
 682
 683 int
 684 afs_nbsd_select(void *v)
 685 {
 686     return 1;
 687 }
 688
 689 int
 690 afs_nbsd_fsync(void *v)
 691 {
 692     struct vop_fsync_args       /* {
 693                                  * struct vnode *a_vp;
 694                                  * kauth_cred_t a_cred;
 695                                  * int a_waitfor;
 696                                  * struct lwp *a_l;
 697                                  * } */ *ap = v;
 698     struct vnode *vp = ap->a_vp;
 699     int code, wait;
 700
 701     if (afs_debug & AFSDEB_VNLAYER)
 702         printf("nbsd_fsync: enter %p\n", ap);
 703
 704     wait = (ap->a_flags & FSYNC_WAIT) != 0;
 705
 706     AFS_GLOCK();
 707     vflushbuf(vp, wait);
 708     code = afs_fsync(VTOAFS(vp), ap->a_cred);
 709     AFS_GUNLOCK();
 710
 711     if (afs_debug & AFSDEB_VNLAYER)
 712         printf("nbsd_fsync: exit %p\n", ap);
 713
 714     return (code);
 715 }
 716
 717 int
 718 afs_nbsd_remove(void *v)
 719 {
 720     struct vop_remove_args      /* {
 721                                  * struct vnode *a_dvp;
 722                                  * struct vnode *a_vp;
 723                                  * struct componentname *a_cnp;
 724                                  * } */ *ap = v;
 725     int code;
 726     struct vnode *vp = ap->a_vp;
 727     struct vnode *dvp = ap->a_dvp;
 728
 729     if (afs_debug & AFSDEB_VNLAYER)
 730         printf("nbsd_remove: enter %p\n", ap);
 731
 732     GETNAME();
 733     AFS_GLOCK();
 734     code = afs_remove(VTOAFS(dvp), name, cnp->cn_cred);
 735     AFS_GUNLOCK();
 736     if (dvp == vp)
 737         vrele(vp);
 738     else
 739         vput(vp);
 740     vput(dvp);
 741     DROPCNP(cnp);
 742     DROPNAME();
 743
 744     if (afs_debug & AFSDEB_VNLAYER)
 745         printf("nbsd_remove: exit %p\n", ap);
 746
 747     return (code);
 748 }
 749
 750 int
 751 afs_nbsd_link(void *v)
 752 {
 753     struct vop_link_args        /* {
 754                                  * struct vnode *a_vp;
 755                                  * struct vnode *a_tdvp;
 756                                  * struct componentname *a_cnp;
 757                                  * } */ *ap = v;
 758     int code;
 759     struct vnode *dvp = ap->a_dvp;
 760     struct vnode *vp = ap->a_vp;
 761
 762     if (afs_debug & AFSDEB_VNLAYER)
 763         printf("nbsd_link: enter %p\n", ap);
 764
 765     GETNAME();
 766     if (dvp->v_mount != vp->v_mount) {
 767         VOP_ABORTOP(vp, cnp);
 768         code = EXDEV;
 769         goto out;
 770     }
 771     if (vp->v_type == VDIR) {
 772         VOP_ABORTOP(vp, cnp);
 773         code = EISDIR;
 774         goto out;
 775     }
 776     if ((code = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY))) {
 777         VOP_ABORTOP(dvp, cnp);
 778         goto out;
 779     }
 780
 781     AFS_GLOCK();
 782     code = afs_link(VTOAFS(vp), VTOAFS(dvp), name, cnp->cn_cred);
 783     AFS_GUNLOCK();
 784     DROPCNP(cnp);
 785     if (dvp != vp)
 786         VOP_UNLOCK(vp, 0);
 787
 788   out:
 789     vput(dvp);
 790     DROPNAME();
 791
 792     if (afs_debug & AFSDEB_VNLAYER)
 793         printf("nbsd_link: exit %p\n", ap);
 794
 795     return (code);
 796 }
 797
 798 int
 799 afs_nbsd_rename(void *v)
 800 {
 801     struct vop_rename_args      /* {
 802                                  * struct vnode *a_fdvp;
 803                                  * struct vnode *a_fvp;
 804                                  * struct componentname *a_fcnp;
 805                                  * struct vnode *a_tdvp;
 806                                  * struct vnode *a_tvp;
 807                                  * struct componentname *a_tcnp;
 808                                  * } */ *ap = v;
 809     int code = 0;
 810     struct componentname *fcnp = ap->a_fcnp;
 811     char *fname;
 812     struct componentname *tcnp = ap->a_tcnp;
 813     char *tname;
 814     struct vnode *tvp = ap->a_tvp;
 815     struct vnode *tdvp = ap->a_tdvp;
 816     struct vnode *fvp = ap->a_fvp;
 817     struct vnode *fdvp = ap->a_fdvp;
 818
 819     if (afs_debug & AFSDEB_VNLAYER)
 820         printf("nbsd_rename: enter %p\n", ap);
 821
 822     /*
 823      * Check for cross-device rename.
 824      */
 825     if ((fvp->v_mount != tdvp->v_mount)
 826         || (tvp && (fvp->v_mount != tvp->v_mount))) {
 827         code = EXDEV;
 828     abortit:
 829         VOP_ABORTOP(tdvp, tcnp);    /* XXX, why not in NFS? */
 830         if (tdvp == tvp)
 831             vrele(tdvp);
 832         else
 833             vput(tdvp);
 834         if (tvp)
 835             vput(tvp);
 836         VOP_ABORTOP(fdvp, fcnp);    /* XXX, why not in NFS? */
 837         vrele(fdvp);
 838         vrele(fvp);
 839         goto out;
 840     }
 841     /*
 842      * if fvp == tvp, we're just removing one name of a pair of
 843      * directory entries for the same element.  convert call into rename.
 844      ( (pinched from NetBSD 1.0's ufs_rename())
 845      */
 846     if (fvp == tvp) {
 847         if (fvp->v_type == VDIR) {
 848             code = EINVAL;
 849             goto abortit;
 850         }
 851
 852         /* Release destination completely. */
 853         VOP_ABORTOP(tdvp, tcnp);
 854         vput(tdvp);
 855         vput(tvp);
 856
 857         /* Delete source. */
 858         vrele(fdvp);
 859         vrele(fvp);
 860         fcnp->cn_flags &= ~MODMASK;
 861         fcnp->cn_flags |= LOCKPARENT | LOCKLEAF;
 862         if ((fcnp->cn_flags & SAVESTART) == 0)
 863             panic("afs_rename: lost from startdir");
 864         fcnp->cn_nameiop = DELETE;
 865         (void)relookup(fdvp, &fvp, fcnp);
 866         code = VOP_REMOVE(fdvp, fvp, fcnp);
 867         goto out;
 868     }
 869
 870     if ((code = vn_lock(fvp, LK_EXCLUSIVE | LK_RETRY)))
 871         goto abortit;
 872
 873     /* XXX GETNAME() ? */
 874     MALLOC(fname, char *, fcnp->cn_namelen + 1, M_TEMP, M_WAITOK);
 875     bcopy(fcnp->cn_nameptr, fname, fcnp->cn_namelen);
 876     fname[fcnp->cn_namelen] = '\0';
 877     MALLOC(tname, char *, tcnp->cn_namelen + 1, M_TEMP, M_WAITOK);
 878     bcopy(tcnp->cn_nameptr, tname, tcnp->cn_namelen);
 879     tname[tcnp->cn_namelen] = '\0';
 880
 881     AFS_GLOCK();
 882     /* XXX use "from" or "to" creds? NFS uses "to" creds */
 883     code =
 884         afs_rename(VTOAFS(fdvp), fname, VTOAFS(tdvp), tname,
 885                    tcnp->cn_cred);
 886     AFS_GUNLOCK();
 887
 888     VOP_UNLOCK(fvp, 0);
 889     FREE(fname, M_TEMP);
 890     FREE(tname, M_TEMP);
 891     if (code)
 892         goto abortit;        /* XXX */
 893     if (tdvp == tvp)
 894         vrele(tdvp);
 895     else
 896         vput(tdvp);
 897     if (tvp)
 898         vput(tvp);
 899     vrele(fdvp);
 900     vrele(fvp);
 901
 902  out:
 903     if (afs_debug & AFSDEB_VNLAYER)
 904         printf("nbsd_rename: exit %p\n", ap);
 905
 906     return (code);
 907 }
 908
 909 int
 910 afs_nbsd_mkdir(void *v)
 911 {
 912     struct vop_mkdir_args       /* {
 913                                  * struct vnode *a_dvp;
 914                                  * struct vnode **a_vpp;
 915                                  * struct componentname *a_cnp;
 916                                  * struct vattr *a_vap;
 917                                  * } */ *ap = v;
 918     struct vnode *dvp = ap->a_dvp;
 919     struct vattr *vap = ap->a_vap;
 920     int code;
 921     struct vcache *vcp;
 922
 923     if (afs_debug & AFSDEB_VNLAYER)
 924         printf("nbsd_mkdir: enter %p\n", ap);
 925
 926     GETNAME();
 927 #ifdef DIAGNOSTIC
 928     if ((cnp->cn_flags & HASBUF) == 0)
 929         panic("afs_nbsd_mkdir: no name");
 930 #endif
 931     AFS_GLOCK();
 932     code = afs_mkdir(VTOAFS(dvp), name, vap, &vcp, cnp->cn_cred);
 933     AFS_GUNLOCK();
 934     if (code) {
 935         VOP_ABORTOP(dvp, cnp);
 936         vput(dvp);
 937         DROPNAME();
 938         goto out;
 939     }
 940     if (vcp) {
 941         *ap->a_vpp = AFSTOV(vcp);
 942         vn_lock(AFSTOV(vcp), LK_EXCLUSIVE | LK_RETRY);
 943     } else
 944         *ap->a_vpp = 0;
 945     DROPCNP(cnp);
 946     DROPNAME();
 947     vput(dvp);
 948
 949  out:
 950     if (afs_debug & AFSDEB_VNLAYER)
 951         printf("nbsd_mkdir: exit %p\n", ap);
 952
 953     return (code);
 954 }
 955
 956 int
 957 afs_nbsd_rmdir(void *v)
 958 {
 959     struct vop_rmdir_args       /* {
 960                                  * struct vnode *a_dvp;
 961                                  * struct vnode *a_vp;
 962                                  * struct componentname *a_cnp;
 963                                  * } */ *ap = v;
 964     int code;
 965     struct vnode *vp = ap->a_vp;
 966     struct vnode *dvp = ap->a_dvp;
 967
 968     if (afs_debug & AFSDEB_VNLAYER)
 969         printf("nbsd_rmdir: enter %p", ap);
 970
 971     GETNAME();
 972     if (dvp == vp) {
 973         vrele(dvp);
 974         vput(vp);
 975         DROPCNP(cnp);
 976         DROPNAME();
 977         code = EINVAL;
 978         goto out;
 979     }
 980
 981     AFS_GLOCK();
 982     code = afs_rmdir(VTOAFS(dvp), name, cnp->cn_cred);
 983     AFS_GUNLOCK();
 984     DROPNAME();
 985     vput(dvp);
 986     vput(vp);
 987
 988  out:
 989     if (afs_debug & AFSDEB_VNLAYER)
 990         printf("nbsd_rmdir: exit %p\n", ap);
 991
 992     return (code);
 993 }
 994
 995 int
 996 afs_nbsd_symlink(void *v)
 997 {
 998     struct vop_symlink_args     /* {
 999                                  * struct vnode *a_dvp;
1000                                  * struct vnode **a_vpp;
1001                                  * struct componentname *a_cnp;
1002                                  * struct vattr *a_vap;
1003                                  * char *a_target;
1004                                  * } */ *ap = v;
1005     struct vnode *dvp = ap->a_dvp;
1006     int code;
1007     /* NFS ignores a_vpp; so do we. */
1008
1009     if (afs_debug & AFSDEB_VNLAYER)
1010         printf("nbsd_symlink: enter %p\n", ap);
1011
1012     GETNAME();
1013     AFS_GLOCK();
1014     code =
1015         afs_symlink(VTOAFS(dvp), name, ap->a_vap, ap->a_target,
1016                     cnp->cn_cred);
1017     AFS_GUNLOCK();
1018     DROPCNP(cnp);
1019     DROPNAME();
1020     vput(dvp);
1021
1022     if (afs_debug & AFSDEB_VNLAYER)
1023         printf("nbsd_symlink: exit %p\n", ap);
1024
1025     return (code);
1026 }
1027
1028 int
1029 nbsd_fake_readdir(struct vnode *vp, struct vcache *vc, struct uio *auio,
1030                   kauth_cred_t acred, int *a_eofflag, int *a_ncookies,
1031                   u_long **a_cookies)
1032 {
1033     static int ino = 2;
1034     afs_int32 code, maxb;
1035     struct dirent *dp;
1036     maxb = auio->uio_resid;
1037
1038     if (afs_debug & AFSDEB_VNLAYER)
1039         printf("nbsd_fake_readdir: enter vp %p vc %p acred %p auio %p "
1040                "uio_offset %d uio_resid %d\n",
1041                vp, vc, acred, auio, (int) auio->uio_offset,
1042                (int) auio->uio_resid);
1043
1044     /* 1. simply returning 0 had good behavior (/afs is empty) */
1045
1046 /*
1047 (gdb) p *auio
1048 $5 = {uio_iov = 0xcbd0ec90, uio_iovcnt = 1, uio_offset = 0, uio_resid = 4096,
1049   uio_rw = UIO_READ, uio_vmspace = 0xcbe8beec}
1050 */
1051     /* ok.  we don't know about cookies, so since auio->uio_resid is 4096,
1052      * what we can legitimately do is move as many appropriately aligned
1053      * NetBSD dirent records into uio_iov[0] as will fit in the total size
1054      * of 4KB.  We do not need to zero-fill anything.  This does not
1055      * terminate the directly listing. If we return 0, VFS will re-enter
1056      * nbsd_readdir to continue reading--to termiate the iteration, we must
1057      * return a non-zero value from nbsd_readdir.  VOP_READDIR(9) appears to
1058      * suggest that enumeration is terminated by setting a_eofflag = 1,
1059      * but as noted there this -can- only be done if VFS passed a value for
1060      * a_eofflag--apparently, this is to do with NFS.  Setting the eof is
1061      * correct but insufficient. */
1062
1063     /* 2. next, let's move ONE entry in by hand--due to termination
1064      * rules, this will actually create file_1 .. file_99 and many
1065      * unecessary nbsd_readdir invocations.  The solution to this is to
1066      * make proper use of auio->uio_offset and auio->uio_resid, together
1067      * when accounting bytes moved each invocation, allowing VFS to
1068      * invoke nbsd_readdir at successive offsets until we have consumed
1069      * all entries in all chunks of the vnode being read--setting a_eofflag
1070      * when this is done.
1071      */
1072
1073     /* this isn't thread safe--we would in fact use incoming offset
1074      * to select the offset of the next AFS dirent, read it, then take
1075      * its values for (modulo volume) inode number and name */
1076     if (auio->uio_offset == 0)
1077         ino = 2;
1078
1079     dp = (struct dirent *) kmem_zalloc(sizeof(struct dirent), KM_SLEEP);
1080     dp->d_ino =  ino;
1081     dp->d_type = DT_REG;
1082     sprintf(dp->d_name, "file_%d", ino);
1083     dp->d_namlen = strlen(dp->d_name);
1084     dp->d_reclen = _DIRENT_SIZE(dp); /* comp reclen from d_namlen and align */
1085     printf("nbsd_fake_readdir: add dirent %s\n", dp->d_name);
1086     code = uiomove(dp, dp->d_reclen, auio);
1087     if (code)
1088         printf("nbsd_fake_readdir: uiomove FAILED\n");
1089     kmem_free(dp, sizeof(struct dirent));
1090     ++ino;
1091
1092     /* terminate enumeration */
1093     if (!code)
1094         if (ino > 100) {
1095             code = EINVAL;
1096             if(a_eofflag)
1097                 *a_eofflag = 1;
1098         }
1099
1100     return (code);
1101 }
1102
1103 int
1104 afs_nbsd_readdir(void *v)
1105 {
1106     struct vop_readdir_args     /* {
1107                                  * struct vnode *a_vp;
1108                                  * struct uio *a_uio;
1109                                  * kauth_cred_t a_cred;
1110                                  * int *a_eofflag;
1111                                  * int *a_ncookies;
1112                                  * u_long **a_cookies;
1113                                  * } */ *ap = v;
1114     int code;
1115     struct vnode *vp = ap->a_vp;
1116     struct vcache *vc = VTOAFS(vp);
1117
1118     if (afs_debug & AFSDEB_VNLAYER)
1119         printf("nbsd_readdir: enter vp %p vc %p acred %p auio %p\n", vp, vc,
1120                ap->a_cred, ap->a_uio);
1121
1122     AFS_GLOCK();
1123 #ifdef AFS_HAVE_COOKIES
1124     printf("readdir %p cookies %p ncookies %d\n", ap->a_vp, ap->a_cookies,
1125            ap->a_ncookies);
1126     code =
1127         afs_readdir(vc, ap->a_uio, ap->a_cred, ap->a_eofflag,
1128                     ap->a_ncookies, ap->a_cookies);
1129 #else
1130     code =
1131         afs_readdir(vc, ap->a_uio, ap->a_cred, ap->a_eofflag);
1132 #endif
1133     AFS_GUNLOCK();
1134
1135     if (afs_debug & AFSDEB_VNLAYER)
1136         printf("nbsd_readdir: exit %p eofflag %d\n", ap, *ap->a_eofflag);
1137
1138     return (code);
1139 }
1140
1141 int
1142 afs_nbsd_readlink(void *v)
1143 {
1144     struct vop_readlink_args    /* {
1145                                  * struct vnode *a_vp;
1146                                  * struct uio *a_uio;
1147                                  * kauth_cred_t a_cred;
1148                                  * } */ *ap = v;
1149     int code;
1150
1151     if (afs_debug & AFSDEB_VNLAYER)
1152         printf("nbsd_readlink: enter %p\n", ap);
1153
1154     AFS_GLOCK();
1155     code = afs_readlink(VTOAFS(ap->a_vp), ap->a_uio, ap->a_cred);
1156     AFS_GUNLOCK();
1157
1158     if (afs_debug & AFSDEB_VNLAYER)
1159         printf("nbsd_readlink: exit %p\n", ap);
1160
1161     return (code);
1162 }
1163
1164 extern int prtactive;
1165
1166 int
1167 afs_nbsd_inactive(void *v)
1168 {
1169     struct vop_inactive_args    /* {
1170                                  * struct vnode *a_vp;
1171                                  * } */ *ap = v;
1172     struct vnode *vp = ap->a_vp;
1173     struct vcache *vc = VTOAFS(vp);
1174     int haveGlock = ISAFS_GLOCK();
1175
1176     AFS_STATCNT(afs_inactive);
1177
1178     if (afs_debug & AFSDEB_VNLAYER)
1179         printf("nbsd_inactive: enter %p\n", ap);
1180
1181     if (prtactive && vp->v_usecount != 0)
1182         vprint("afs_nbsd_inactive: pushing active", vp);
1183
1184     if (!haveGlock)
1185         AFS_GLOCK();
1186     afs_InactiveVCache(vc, 0);  /* decrs ref counts */
1187     if (!haveGlock)
1188         AFS_GUNLOCK();
1189
1190 #ifdef AFS_NBSD50_ENV
1191     mutex_init(&vc->rwlock, MUTEX_DEFAULT, IPL_NONE);
1192 #else
1193     lockinit(&vc->rwlock, PINOD, "vcache", 0, 0);
1194 #endif
1195
1196     if (afs_debug & AFSDEB_VNLAYER)
1197         printf("nbsd_inactive: exit %p\n", ap);
1198
1199     return (0);
1200 }
1201
1202 int
1203 afs_nbsd_reclaim(void *v)
1204 {
1205     struct vop_reclaim_args     /* {
1206                                  * struct vnode *a_vp;
1207                                  * } */ *ap = v;
1208     int code, slept;
1209     struct vnode *vp = ap->a_vp;
1210     struct vcache *avc = VTOAFS(vp);
1211     int haveGlock = ISAFS_GLOCK();
1212     int haveVlock = CheckLock(&afs_xvcache);
1213
1214         if (afs_debug & AFSDEB_VNLAYER)
1215                 printf("nbsd_reclaim: enter %p\n", ap);
1216
1217 #if 0
1218     printf("reclaim usecount %d\n", vp->v_usecount);
1219     /* OK, there are no internal vrefCounts, so there shouldn't
1220      * be any more refs here. */
1221     vp->v_data = NULL;          /* remove from vnode */
1222     avc->v = NULL;              /* also drop the ptr to vnode */
1223
1224         if (afs_debug & AFSDEB_VNLAYER)
1225                 printf("nbsd_reclaim: exit %p\n", ap);
1226
1227     return (0);
1228 #else
1229     if (!haveGlock)
1230                 AFS_GLOCK();
1231     if (!haveVlock)
1232                 ObtainWriteLock(&afs_xvcache, 901);
1233 #ifndef AFS_DISCON_ENV
1234         code = afs_FlushVCache(avc, &slept); /* tosses our stuff from vnode */
1235 #else
1236     /* reclaim the vnode and the in-memory vcache, but keep the on-disk vcache */
1237     code = afs_FlushVCache(avc, &slept);
1238 #endif
1239     if (!haveVlock)
1240                 ReleaseWriteLock(&afs_xvcache);
1241     if (!haveGlock)
1242                 AFS_GUNLOCK();
1243
1244         if (afs_debug & AFSDEB_VNLAYER)
1245                 printf("nbsd_reclaim: exit %p\n", ap);
1246
1247     return code;
1248 #endif /* 0 */
1249 }
1250
1251 int
1252 afs_nbsd_lock(void *v)
1253 {
1254     struct vop_lock_args        /* {
1255                                  * struct vnode *a_vp;
1256                                  * int a_flags;
1257                                  * struct lwp *a_l;
1258                                  * } */ *ap = v;
1259     int code;
1260     struct vnode *vp = ap->a_vp;
1261     int flags = ap->a_flags;
1262
1263     if (afs_debug & AFSDEB_VNLAYER)
1264         printf("nbsd_lock: enter vp %p flags %d\n", vp, flags);
1265
1266     code = genfs_lock(v);
1267
1268     if (afs_debug & AFSDEB_VNLAYER)
1269         printf("nbsd_lock: exit vp %p flags %d\n\n", vp, flags);
1270
1271     return (code);
1272 }
1273
1274 int
1275 afs_nbsd_unlock(void *v)
1276 {
1277     struct vop_unlock_args      /* {
1278                                  * struct vnode *a_vp;
1279                                  * int a_flags;
1280                                  * struct lwp *a_l;
1281                                  * } */ *ap = v;
1282     int code;
1283     struct vnode *vp = ap->a_vp;
1284     int flags = ap->a_flags;
1285
1286     if (afs_debug & AFSDEB_VNLAYER)
1287         printf("nbsd_unlock: enter vp %p flags %d\n", vp, flags);
1288
1289     code = genfs_unlock(v);
1290
1291     if (afs_debug & AFSDEB_VNLAYER)
1292         printf("nbsd_unlock: exit vp %p flags %d\n", vp, flags);
1293
1294     return (code);
1295 }
1296
1297 int
1298 afs_nbsd_islocked(void *v)
1299 {
1300     struct vop_islocked_args    /* {
1301                                  * struct vnode *a_vp;
1302                                  * } */ *ap = v;
1303
1304     int code;
1305     struct vnode *vp = ap->a_vp;
1306
1307     if (afs_debug & AFSDEB_VNLAYER)
1308         printf("nbsd_islocked: enter vp %p flags %d\n", vp);
1309
1310     code = genfs_islocked(v);
1311
1312     if (afs_debug & AFSDEB_VNLAYER)
1313         printf("nbsd_islocked: exit vp %p flags %d\n", vp);
1314
1315     return (code);
1316 }
1317
1318
1319 int
1320 afs_nbsd_bmap(void *v)
1321 {
1322     struct vop_bmap_args        /* {
1323                                  * struct vnode *a_vp;
1324                                  * daddr_t  a_bn;
1325                                  * struct vnode **a_vpp;
1326                                  * daddr_t *a_bnp;
1327                                  * int *a_runp;
1328                                  * } */ *ap = v;
1329     struct vcache *vcp = VTOAFS(ap->a_vp);
1330
1331     AFS_STATCNT(afs_bmap);
1332
1333     if (afs_debug & AFSDEB_VNLAYER)
1334         printf("nbsd_bmap: enter %p\n", ap);
1335
1336     /* borrowed from DARWIN--why notyet? */
1337     if (ap->a_bnp)
1338         *ap->a_bnp = ap->a_bn * (PAGE_SIZE / DEV_BSIZE);
1339     if (ap->a_vpp)
1340         *ap->a_vpp = ap->a_vp;
1341     if (ap->a_runp != NULL)
1342         *ap->a_runp = 0;
1343 #ifdef notyet
1344     if (ap->a_runb != NULL)
1345         *ap->a_runb = 0;
1346 #endif
1347
1348     if (afs_debug & AFSDEB_VNLAYER)
1349         printf("nbsd_bmap: exit %p\n", ap);
1350
1351     return (0);
1352 }
1353
1354 int
1355 afs_nbsd_strategy(void *v)
1356 {
1357     struct vop_strategy_args    /* {
1358                                  * struct buf *a_bp;
1359                                  * } */ *ap = v;
1360     struct buf *abp = ap->a_bp;
1361     struct uio tuio;
1362     struct iovec tiovec[1];
1363     struct vcache *tvc = VTOAFS(abp->b_vp);
1364     afs_ucred_t credp = osi_curcred();
1365     long len = abp->b_bcount;
1366     int code;
1367
1368     AFS_STATCNT(afs_strategy);
1369
1370     if (afs_debug & AFSDEB_VNLAYER)
1371         printf("nbsd_strategy: enter %p\n", ap);
1372
1373     tuio.afsio_iov = tiovec;
1374     tuio.afsio_iovcnt = 1;
1375     tuio.afsio_resid = len;
1376 /*
1377  * b_un was removed in NBSD50...there's no true substitute for the
1378  * b_addr that was in it, but b_blkno is the closest.
1379  *      mattjsm
1380  */
1381 #ifdef AFS_NBSD50_ENV
1382     tiovec[0].iov_base = abp->b_blkno;
1383 #else
1384     tiovec[0].iov_base = abp->b_un.b_addr;
1385 #endif
1386     tiovec[0].iov_len = len;
1387     UIO_SETUP_SYSSPACE(&tuio);
1388
1389     AFS_GLOCK();
1390     if ((abp->b_flags & B_READ) == B_READ) {
1391         code = afs_rdwr(tvc, &tuio, UIO_READ, 0, credp);
1392         if (code == 0 && tuio.afsio_resid > 0)
1393 #ifdef AFS_NBSD50_ENV
1394             bzero(abp->b_blkno + len - tuio.afsio_resid,
1395 #else
1396             bzero(abp->b_un.b_addr + len - tuio.afsio_resid,
1397 #endif
1398                   tuio.afsio_resid);
1399         } else
1400             code = afs_rdwr(tvc, &tuio, UIO_WRITE, 0, credp);
1401     AFS_GUNLOCK();
1402
1403     ReleaseWriteLock(&tvc->lock);
1404     AFS_RELE(AFSTOV(tvc));
1405
1406     if (afs_debug & AFSDEB_VNLAYER)
1407         printf("nbsd_strategy: exit %p\n", ap);
1408
1409     return (code);
1410 }
1411
1412 int
1413 afs_nbsd_print(void *v)
1414 {
1415     struct vop_print_args       /* {
1416                                  * struct vnode *a_vp;
1417                                  * } */ *ap = v;
1418     struct vnode *vp = ap->a_vp;
1419     struct vcache *vc = VTOAFS(ap->a_vp);
1420
1421     printf("tag %d, fid: %d.%x.%x.%x, ", vp->v_tag, vc->f.fid.Cell,
1422            (int)vc->f.fid.Fid.Volume, (int)vc->f.fid.Fid.Vnode,
1423            (int)vc->f.fid.Fid.Unique);
1424 #ifdef AFS_NBSD50_ENV
1425         mutex_owned(&vc->rwlock);
1426 #else
1427     lockmgr_printinfo(&vc->rwlock);
1428 #endif
1429     printf("\n");
1430     return (0);
1431 }
1432
1433 /*
1434  * Return POSIX pathconf information applicable to ufs filesystems.
1435  */
1436 int
1437 afs_nbsd_pathconf(void *v)
1438 {
1439     struct vop_pathconf_args    /* {
1440                                  * struct vnode *a_vp;
1441                                  * int a_name;
1442                                  * int *a_retval;
1443                                  * } */ *ap = v;
1444     int code = 0;
1445
1446     AFS_STATCNT(afs_cntl);
1447
1448     if (afs_debug & AFSDEB_VNLAYER)
1449         printf("nbsd_pathconf: enter %p\n", ap);
1450
1451     switch (ap->a_name) {
1452     case _PC_LINK_MAX:
1453         *ap->a_retval = LINK_MAX;
1454         break;
1455     case _PC_NAME_MAX:
1456         *ap->a_retval = NAME_MAX;
1457         break;
1458     case _PC_PATH_MAX:
1459         *ap->a_retval = PATH_MAX;
1460         break;
1461     case _PC_CHOWN_RESTRICTED:
1462         *ap->a_retval = 1;
1463         break;
1464     case _PC_NO_TRUNC:
1465         *ap->a_retval = 1;
1466         break;
1467     case _PC_PIPE_BUF:
1468         code = EINVAL;
1469         goto out;
1470         break;
1471     default:
1472         code = EINVAL;
1473         goto out;
1474     }
1475
1476 out:
1477     if (afs_debug & AFSDEB_VNLAYER)
1478         printf("nbsd_pathconf: exit %p\n", ap);
1479
1480     return (0);
1481 }
1482
1483 extern int
1484   afs_lockctl(struct vcache *avc, struct AFS_FLOCK *af, int acmd,
1485               afs_ucred_t *acred, pid_t clid);
1486
1487 /*
1488  * Advisory record locking support (fcntl() POSIX style)
1489  */
1490 int
1491 afs_nbsd_advlock(void *v)
1492 {
1493     struct vop_advlock_args     /* {
1494                                  * struct vnode *a_vp;
1495                                  * caddr_t  a_id;
1496                                  * int  a_op;
1497                                  * struct flock *a_fl;
1498                                  * int  a_flags;
1499                                  * } */ *ap = v;
1500     int code;
1501
1502     if (afs_debug & AFSDEB_VNLAYER)
1503         printf("nbsd_pathconf: enter %p\n", ap);
1504
1505     AFS_GLOCK();
1506     code =
1507         afs_lockctl(VTOAFS(ap->a_vp), ap->a_fl, ap->a_op, osi_curcred(),
1508                     (int)ap->a_id);
1509     AFS_GUNLOCK();
1510
1511     if (afs_debug & AFSDEB_VNLAYER)
1512         printf("nbsd_pathconf: exit %p\n", ap);
1513
1514     return (code);
1515 }