src/afs/OBSD/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$
   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 RCSID("$Header$");
 102
 103 #include "afs/sysincludes.h"    /* Standard vendor system headers */
 104 #include "afs/afsincludes.h"    /* Afs-based standard headers */
 105 #include "afs/afs_stats.h" /* statistics */
 106
 107 #include <sys/malloc.h>
 108 #include <sys/namei.h>
 109
 110 #include "afs/afs_cbqueue.h"
 111 #include "afs/nfsclient.h"
 112 #include "afs/afs_osidnlc.h"
 113
 114 #ifdef AFS_DISCON_ENV
 115 extern int afs_FlushVS(struct vcache *tvc);
 116 #endif
 117
 118 #define M_AFSNODE (M_TEMP-1)            /* XXX */
 119
 120 int afs_nbsd_lookup(struct vop_lookup_args *);
 121 int afs_nbsd_create(struct vop_create_args *);
 122 int afs_nbsd_mknod(struct vop_mknod_args *);
 123 int afs_nbsd_open(struct vop_open_args *);
 124 int afs_nbsd_close(struct vop_close_args *);
 125 int afs_nbsd_access(struct vop_access_args *);
 126 int afs_nbsd_getattr(struct vop_getattr_args *);
 127 int afs_nbsd_setattr(struct vop_setattr_args *);
 128 int afs_nbsd_read(struct vop_read_args *);
 129 int afs_nbsd_write(struct vop_write_args *);
 130 int afs_nbsd_ioctl(struct vop_ioctl_args *);
 131 int afs_nbsd_select(struct vop_select_args *);
 132 int afs_nbsd_fsync(struct vop_fsync_args *);
 133 int afs_nbsd_remove(struct vop_remove_args *);
 134 int afs_nbsd_link(struct vop_link_args *);
 135 int afs_nbsd_rename(struct vop_rename_args *);
 136 int afs_nbsd_mkdir(struct vop_mkdir_args *);
 137 int afs_nbsd_rmdir(struct vop_rmdir_args *);
 138 int afs_nbsd_symlink(struct vop_symlink_args *);
 139 int afs_nbsd_readdir(struct vop_readdir_args *);
 140 int afs_nbsd_readlink(struct vop_readlink_args *);
 141 extern int ufs_abortop(struct vop_abortop_args *);
 142 int afs_nbsd_inactive(struct vop_inactive_args *);
 143 int afs_nbsd_reclaim(struct vop_reclaim_args *);
 144 int afs_nbsd_lock(struct vop_lock_args *);
 145 int afs_nbsd_unlock(struct vop_unlock_args *);
 146 int afs_nbsd_bmap(struct vop_bmap_args *);
 147 int afs_nbsd_strategy(struct vop_strategy_args *);
 148 int afs_nbsd_print(struct vop_print_args *);
 149 int afs_nbsd_islocked(struct vop_islocked_args *);
 150 int afs_nbsd_pathconf(struct vop_pathconf_args *);
 151 int afs_nbsd_advlock(struct vop_advlock_args *);
 152
 153 #define afs_nbsd_opnotsupp \
 154         ((int (*) __P((struct  vop_reallocblks_args *)))eopnotsupp)
 155 #define afs_nbsd_reallocblks afs_nbsd_opnotsupp
 156
 157 /* Global vfs data structures for AFS. */
 158 int (**afs_vnodeop_p) __P((void *));
 159 struct vnodeopv_entry_desc afs_vnodeop_entries[] = {
 160         { &vop_default_desc, vn_default_error },
 161         { &vop_lookup_desc, afs_nbsd_lookup },          /* lookup */
 162         { &vop_create_desc, afs_nbsd_create },          /* create */
 163         { &vop_mknod_desc, afs_nbsd_mknod },            /* mknod */
 164         { &vop_open_desc, afs_nbsd_open },              /* open */
 165         { &vop_close_desc, afs_nbsd_close },            /* close */
 166         { &vop_access_desc, afs_nbsd_access },          /* access */
 167         { &vop_getattr_desc, afs_nbsd_getattr },        /* getattr */
 168         { &vop_setattr_desc, afs_nbsd_setattr },        /* setattr */
 169         { &vop_read_desc, afs_nbsd_read },              /* read */
 170         { &vop_write_desc, afs_nbsd_write },            /* write */
 171         { &vop_ioctl_desc, afs_nbsd_ioctl },            /* XXX ioctl */
 172         { &vop_select_desc, afs_nbsd_select },          /* select */
 173         { &vop_fsync_desc, afs_nbsd_fsync },            /* fsync */
 174         { &vop_remove_desc, afs_nbsd_remove },          /* remove */
 175         { &vop_link_desc, afs_nbsd_link },              /* link */
 176         { &vop_rename_desc, afs_nbsd_rename },          /* rename */
 177         { &vop_mkdir_desc, afs_nbsd_mkdir },            /* mkdir */
 178         { &vop_rmdir_desc, afs_nbsd_rmdir },            /* rmdir */
 179         { &vop_symlink_desc, afs_nbsd_symlink },        /* symlink */
 180         { &vop_readdir_desc, afs_nbsd_readdir },        /* readdir */
 181         { &vop_readlink_desc, afs_nbsd_readlink },      /* readlink */
 182         { &vop_abortop_desc, vop_generic_abortop },     /* abortop */
 183         { &vop_inactive_desc, afs_nbsd_inactive },      /* inactive */
 184         { &vop_reclaim_desc, afs_nbsd_reclaim },        /* reclaim */
 185         { &vop_lock_desc, afs_nbsd_lock },              /* lock */
 186         { &vop_unlock_desc, afs_nbsd_unlock },          /* unlock */
 187         { &vop_bmap_desc, afs_nbsd_bmap },              /* bmap */
 188         { &vop_strategy_desc, afs_nbsd_strategy },      /* strategy */
 189         { &vop_print_desc, afs_nbsd_print },            /* print */
 190         { &vop_islocked_desc, afs_nbsd_islocked },      /* islocked */
 191         { &vop_pathconf_desc, afs_nbsd_pathconf },      /* pathconf */
 192         { &vop_advlock_desc, afs_nbsd_advlock },        /* advlock */
 193         { &vop_reallocblks_desc, afs_nbsd_reallocblks }, /* reallocblks */
 194         { &vop_bwrite_desc, vop_generic_bwrite },
 195         { (struct vnodeop_desc *) NULL, (int (*) __P((void *))) NULL}
 196 };
 197 struct vnodeopv_desc afs_vnodeop_opv_desc =
 198         { &afs_vnodeop_p, afs_vnodeop_entries };
 199
 200 #define GETNAME()       \
 201     struct componentname *cnp = ap->a_cnp; \
 202     char *name; \
 203     MALLOC(name, char *, cnp->cn_namelen+1, M_TEMP, M_WAITOK); \
 204     bcopy(cnp->cn_nameptr, name, cnp->cn_namelen); \
 205     name[cnp->cn_namelen] = '\0'
 206
 207 #define DROPNAME() FREE(name, M_TEMP)
 208
 209 int afs_debug;
 210
 211 #undef vrele
 212 #define vrele afs_nbsd_rele
 213 #undef VREF
 214 #define VREF afs_nbsd_ref
 215
 216 extern int afs_lookup();
 217 extern int afs_open();
 218 extern int afs_close();
 219 extern int HandleIoctl(struct vcache *avc, afs_int32 acom, struct afs_ioctl *adata);
 220 extern int afs_fsync();
 221 extern int afs_remove();
 222 extern int afs_link();
 223 extern int afs_rename();
 224 extern int afs_mkdir();
 225 extern int afs_rmdir();
 226 extern int afs_symlink();
 227 extern int afs_readdir();
 228 extern int afs_readlink();
 229
 230 int
 231 afs_nbsd_lookup(ap)
 232 struct vop_lookup_args /* {
 233                           struct vnodeop_desc * a_desc;
 234                           struct vnode *a_dvp;
 235                           struct vnode **a_vpp;
 236                           struct componentname *a_cnp;
 237                           } */ *ap;
 238 {
 239     int code;
 240     struct vcache *vcp;
 241     struct vnode *vp, *dvp;
 242     int flags = ap->a_cnp->cn_flags;
 243     int lockparent;                     /* 1 => lockparent flag is set */
 244     int wantparent;                     /* 1 => wantparent or lockparent flag */
 245
 246     GETNAME();
 247     lockparent = flags & LOCKPARENT;
 248     wantparent = flags & (LOCKPARENT|WANTPARENT);
 249 #ifdef PDIRUNLOCK
 250     cnp->cn_flags &= ~PDIRUNLOCK;
 251 #endif
 252
 253     if (ap->a_dvp->v_type != VDIR) {
 254         *ap->a_vpp = NULL;
 255         DROPNAME();
 256         return ENOTDIR;
 257     }
 258     dvp = ap->a_dvp;
 259     if (afs_debug & AFSDEB_VNLAYER && !(dvp->v_flag & VROOT))
 260         printf("nbsd_lookup dvp %p flags %x name %s cnt %d\n", dvp, flags, name, dvp->v_usecount);
 261     AFS_GLOCK();
 262     code = afs_lookup(VTOAFS(dvp), name, &vcp, cnp->cn_cred);
 263     AFS_GUNLOCK();
 264     if (code) {
 265         if ((cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME) &&
 266             (flags & ISLASTCN) && code == ENOENT)
 267             code = EJUSTRETURN;
 268         if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
 269             cnp->cn_flags |= SAVENAME;
 270         DROPNAME();
 271         *ap->a_vpp = NULL;
 272         return (code);
 273     }
 274     vp = AFSTOV(vcp);                   /* always get a node if no error */
 275
 276     /*
 277      * The parent directory comes in locked.  We unlock it on return
 278      * unless the caller wants it left locked.
 279      * we also always return the vnode locked.
 280      */
 281
 282     if (vp == dvp) {
 283         /* they're the same; afs_lookup() already ref'ed the leaf.
 284            It came in locked, so we don't need to ref OR lock it */
 285         if (afs_debug & AFSDEB_VNLAYER)
 286             printf("ref'ed %p as .\n", dvp);
 287     } else {
 288         if (!lockparent || !(flags & ISLASTCN)) {
 289             VOP_UNLOCK(dvp, 0, curproc);                /* done with parent. */
 290 #ifdef PDIRUNLOCK
 291             cnp->cn_flags |= PDIRUNLOCK;
 292 #endif
 293         }
 294         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, curproc);  /* always return the child locked */
 295         if (afs_debug & AFSDEB_VNLAYER)
 296             printf("locked ret %p from lookup\n", vp);
 297     }
 298     *ap->a_vpp = vp;
 299
 300     if (((cnp->cn_nameiop == RENAME && wantparent && (flags & ISLASTCN))
 301          || (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))))
 302         cnp->cn_flags |= SAVENAME;
 303
 304     DROPNAME();
 305     if (afs_debug & AFSDEB_VNLAYER && !(dvp->v_flag & VROOT))
 306         printf("nbsd_lookup done dvp %p cnt %d\n", dvp, dvp->v_usecount);
 307     return code;
 308 }
 309
 310 int
 311 afs_nbsd_create(ap)
 312         struct vop_create_args /* {
 313                 struct vnode *a_dvp;
 314                 struct vnode **a_vpp;
 315                 struct componentname *a_cnp;
 316                 struct vattr *a_vap;
 317         } */ *ap;
 318 {
 319     int code = 0;
 320     struct vcache *vcp;
 321     struct vnode *dvp = ap->a_dvp;
 322     GETNAME();
 323
 324     if (afs_debug & AFSDEB_VNLAYER)
 325         printf("nbsd_create dvp %p cnt %d\n", dvp, dvp->v_usecount);
 326
 327     /* vnode layer handles excl/nonexcl */
 328
 329     AFS_GLOCK();
 330     code = afs_create(VTOAFS(dvp), name, ap->a_vap, NONEXCL,
 331                        ap->a_vap->va_mode, &vcp,
 332                        cnp->cn_cred);
 333     AFS_GUNLOCK();
 334     if (code) {
 335         VOP_ABORTOP(dvp, cnp);
 336         vput(dvp);
 337         DROPNAME();
 338         return(code);
 339     }
 340
 341     if (vcp) {
 342         *ap->a_vpp = AFSTOV(vcp);
 343         vn_lock(AFSTOV(vcp), LK_EXCLUSIVE | LK_RETRY, curproc);
 344     }
 345     else *ap->a_vpp = 0;
 346
 347     if ((cnp->cn_flags & SAVESTART) == 0)
 348         FREE(cnp->cn_pnbuf, M_NAMEI);
 349     vput(dvp);
 350     DROPNAME();
 351     if (afs_debug & AFSDEB_VNLAYER)
 352         printf("nbsd_create done dvp %p cnt %d\n", dvp, dvp->v_usecount);
 353     return code;
 354 }
 355
 356 int
 357 afs_nbsd_mknod(ap)
 358         struct vop_mknod_args /* {
 359                 struct vnode *a_dvp;
 360                 struct vnode **a_vpp;
 361                 struct componentname *a_cnp;
 362                 struct vattr *a_vap;
 363         } */ *ap;
 364 {
 365     free(ap->a_cnp->cn_pnbuf, M_NAMEI);
 366     vput(ap->a_dvp);
 367     return(ENODEV);
 368 }
 369
 370 int
 371 afs_nbsd_open(ap)
 372         struct vop_open_args /* {
 373                 struct vnode *a_vp;
 374                 int  a_mode;
 375                 struct ucred *a_cred;
 376                 struct proc *a_p;
 377         } */ *ap;
 378 {
 379     int code;
 380     struct vcache *vc = VTOAFS(ap->a_vp);
 381
 382     AFS_GLOCK();
 383     code = afs_open(&vc, ap->a_mode, ap->a_cred);
 384 #ifdef DIAGNOSTIC
 385     if (AFSTOV(vc) != ap->a_vp)
 386         panic("AFS open changed vnode!");
 387 #endif
 388     AFS_GUNLOCK();
 389     return code;
 390 }
 391
 392 int
 393 afs_nbsd_close(ap)
 394         struct vop_close_args /* {
 395                 struct vnode *a_vp;
 396                 int  a_fflag;
 397                 struct ucred *a_cred;
 398                 struct proc *a_p;
 399         } */ *ap;
 400 {
 401     int code;
 402
 403     AFS_GLOCK();
 404     code = afs_close(VTOAFS(ap->a_vp), ap->a_fflag, ap->a_cred, ap->a_p);
 405     AFS_GUNLOCK();
 406     return code;
 407 }
 408
 409 int
 410 afs_nbsd_access(ap)
 411         struct vop_access_args /* {
 412                 struct vnode *a_vp;
 413                 int  a_mode;
 414                 struct ucred *a_cred;
 415                 struct proc *a_p;
 416         } */ *ap;
 417 {
 418     int code;
 419
 420     AFS_GLOCK();
 421     code = afs_access(VTOAFS(ap->a_vp), ap->a_mode, ap->a_cred);
 422     AFS_GUNLOCK();
 423     return code;
 424 }
 425
 426 int
 427 afs_nbsd_getattr(ap)
 428         struct vop_getattr_args /* {
 429                 struct vnode *a_vp;
 430                 struct vattr *a_vap;
 431                 struct ucred *a_cred;
 432                 struct proc *a_p;
 433         } */ *ap;
 434 {
 435     int code;
 436
 437     AFS_GLOCK();
 438     code = afs_getattr(VTOAFS(ap->a_vp), ap->a_vap, ap->a_cred);
 439     AFS_GUNLOCK();
 440     return code;
 441 }
 442
 443 int
 444 afs_nbsd_setattr(ap)
 445         struct vop_setattr_args /* {
 446                 struct vnode *a_vp;
 447                 struct vattr *a_vap;
 448                 struct ucred *a_cred;
 449                 struct proc *a_p;
 450         } */ *ap;
 451 {
 452     int code;
 453
 454     AFS_GLOCK();
 455     code = afs_setattr(VTOAFS(ap->a_vp), ap->a_vap, ap->a_cred);
 456     AFS_GUNLOCK();
 457     return code;
 458 }
 459
 460 int
 461 afs_nbsd_read(ap)
 462         struct vop_read_args /* {
 463                 struct vnode *a_vp;
 464                 struct uio *a_uio;
 465                 int a_ioflag;
 466                 struct ucred *a_cred;
 467         } */ *ap;
 468 {
 469     int code;
 470
 471     AFS_GLOCK();
 472     code = afs_read(VTOAFS(ap->a_vp), ap->a_uio, ap->a_cred, (daddr_t)0, NULL, 0);
 473     AFS_GUNLOCK();
 474     return code;
 475 }
 476
 477 int
 478 afs_nbsd_write(ap)
 479         struct vop_write_args /* {
 480                 struct vnode *a_vp;
 481                 struct uio *a_uio;
 482                 int a_ioflag;
 483                 struct ucred *a_cred;
 484         } */ *ap;
 485 {
 486     int code;
 487
 488 #ifdef UVM
 489     (void) uvm_vnp_uncache(ap->a_vp);   /* toss stale pages */
 490 #else
 491     vnode_pager_uncache(ap->a_vp);
 492 #endif
 493     AFS_GLOCK();
 494     code = afs_write(VTOAFS(ap->a_vp), ap->a_uio, ap->a_ioflag, ap->a_cred, 0);
 495     AFS_GUNLOCK();
 496     return code;
 497 }
 498
 499 int
 500 afs_nbsd_ioctl(ap)
 501         struct vop_ioctl_args /* {
 502                 struct vnode *a_vp;
 503                 int  a_command;
 504                 caddr_t  a_data;
 505                 int  a_fflag;
 506                 struct ucred *a_cred;
 507                 struct proc *a_p;
 508         } */ *ap;
 509 {
 510     int code;
 511
 512     /* in case we ever get in here... */
 513
 514     AFS_STATCNT(afs_ioctl);
 515     AFS_GLOCK();
 516     if (((ap->a_command >> 8) & 0xff) == 'V')
 517         /* This is a VICEIOCTL call */
 518         code = HandleIoctl(VTOAFS(ap->a_vp), ap->a_command, (struct afs_ioctl *) ap->a_data);
 519     else
 520         /* No-op call; just return. */
 521         code = ENOTTY;
 522     AFS_GUNLOCK();
 523     return code;
 524 }
 525
 526 /* ARGSUSED */
 527 int
 528 afs_nbsd_select(ap)
 529         struct vop_select_args /* {
 530                 struct vnode *a_vp;
 531                 int  a_which;
 532                 int  a_fflags;
 533                 struct ucred *a_cred;
 534                 struct proc *a_p;
 535         } */ *ap;
 536 {
 537     /*
 538      * We should really check to see if I/O is possible.
 539      */
 540     return (1);
 541 }
 542
 543 int
 544 afs_nbsd_fsync(ap)
 545         struct vop_fsync_args /* {
 546                 struct vnode *a_vp;
 547                 struct ucred *a_cred;
 548                 int a_waitfor;
 549                 struct proc *a_p;
 550         } */ *ap;
 551 {
 552     int wait = ap->a_waitfor == MNT_WAIT;
 553     struct vnode *vp = ap->a_vp;
 554     int code;
 555
 556     AFS_GLOCK();
 557     vflushbuf(vp, wait);
 558     code = afs_fsync(VTOAFS(vp), ap->a_cred);
 559     AFS_GUNLOCK();
 560     return code;
 561 }
 562
 563 int
 564 afs_nbsd_remove(ap)
 565         struct vop_remove_args /* {
 566                 struct vnode *a_dvp;
 567                 struct vnode *a_vp;
 568                 struct componentname *a_cnp;
 569         } */ *ap;
 570 {
 571     int code;
 572     struct vnode *vp = ap->a_vp;
 573     struct vnode *dvp = ap->a_dvp;
 574
 575     GETNAME();
 576     AFS_GLOCK();
 577     code =  afs_remove(VTOAFS(dvp), name, cnp->cn_cred);
 578     AFS_GUNLOCK();
 579     if (dvp == vp)
 580         vrele(vp);
 581     else
 582         vput(vp);
 583     vput(dvp);
 584     FREE(cnp->cn_pnbuf, M_NAMEI);
 585     DROPNAME();
 586     return code;
 587 }
 588
 589 int
 590 afs_nbsd_link(ap)
 591         struct vop_link_args /* {
 592                 struct vnode *a_vp;
 593                 struct vnode *a_tdvp;
 594                 struct componentname *a_cnp;
 595         } */ *ap;
 596 {
 597     int code;
 598     struct vnode *dvp = ap->a_dvp;
 599     struct vnode *vp = ap->a_vp;
 600
 601     GETNAME();
 602     if (dvp->v_mount != vp->v_mount) {
 603         VOP_ABORTOP(vp, cnp);
 604         code = EXDEV;
 605         goto out;
 606     }
 607     if (vp->v_type == VDIR) {
 608         VOP_ABORTOP(vp, cnp);
 609         code = EISDIR;
 610         goto out;
 611     }
 612     if ((code = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, curproc))) {
 613         VOP_ABORTOP(dvp, cnp);
 614         goto out;
 615     }
 616
 617     AFS_GLOCK();
 618     code = afs_link(VTOAFS(vp), VTOAFS(dvp), name, cnp->cn_cred);
 619     AFS_GUNLOCK();
 620     FREE(cnp->cn_pnbuf, M_NAMEI);
 621     if (dvp != vp)
 622         VOP_UNLOCK(vp, 0, curproc);
 623
 624 out:
 625     vput(dvp);
 626     DROPNAME();
 627     return code;
 628 }
 629
 630 int
 631 afs_nbsd_rename(ap)
 632         struct vop_rename_args  /* {
 633                 struct vnode *a_fdvp;
 634                 struct vnode *a_fvp;
 635                 struct componentname *a_fcnp;
 636                 struct vnode *a_tdvp;
 637                 struct vnode *a_tvp;
 638                 struct componentname *a_tcnp;
 639         } */ *ap;
 640 {
 641     int code = 0;
 642     struct componentname *fcnp = ap->a_fcnp;
 643     char *fname;
 644     struct componentname *tcnp = ap->a_tcnp;
 645     char *tname;
 646     struct vnode *tvp = ap->a_tvp;
 647     struct vnode *tdvp = ap->a_tdvp;
 648     struct vnode *fvp = ap->a_fvp;
 649     struct vnode *fdvp = ap->a_fdvp;
 650
 651     /*
 652      * Check for cross-device rename.
 653      */
 654     if ((fvp->v_mount != tdvp->v_mount) ||
 655         (tvp && (fvp->v_mount != tvp->v_mount))) {
 656         code = EXDEV;
 657 abortit:
 658         VOP_ABORTOP(tdvp, tcnp); /* XXX, why not in NFS? */
 659         if (tdvp == tvp)
 660             vrele(tdvp);
 661         else
 662             vput(tdvp);
 663         if (tvp)
 664             vput(tvp);
 665         VOP_ABORTOP(fdvp, fcnp); /* XXX, why not in NFS? */
 666         vrele(fdvp);
 667         vrele(fvp);
 668         return (code);
 669     }
 670     /*
 671      * if fvp == tvp, we're just removing one name of a pair of
 672      * directory entries for the same element.  convert call into rename.
 673      ( (pinched from NetBSD 1.0's ufs_rename())
 674      */
 675     if (fvp == tvp) {
 676         if (fvp->v_type == VDIR) {
 677             code = EINVAL;
 678             goto abortit;
 679         }
 680
 681         /* Release destination completely. */
 682         VOP_ABORTOP(tdvp, tcnp);
 683         vput(tdvp);
 684         vput(tvp);
 685
 686         /* Delete source. */
 687         vrele(fdvp);
 688         vrele(fvp);
 689         fcnp->cn_flags &= ~MODMASK;
 690         fcnp->cn_flags |= LOCKPARENT | LOCKLEAF;
 691         if ((fcnp->cn_flags & SAVESTART) == 0)
 692             panic("afs_rename: lost from startdir");
 693         fcnp->cn_nameiop = DELETE;
 694         (void) relookup(fdvp, &fvp, fcnp);
 695         return (VOP_REMOVE(fdvp, fvp, fcnp));
 696     }
 697
 698     if ((code = vn_lock(fvp, LK_EXCLUSIVE | LK_RETRY, curproc)))
 699         goto abortit;
 700
 701     MALLOC(fname, char *, fcnp->cn_namelen+1, M_TEMP, M_WAITOK);
 702     bcopy(fcnp->cn_nameptr, fname, fcnp->cn_namelen);
 703     fname[fcnp->cn_namelen] = '\0';
 704     MALLOC(tname, char *, tcnp->cn_namelen+1, M_TEMP, M_WAITOK);
 705     bcopy(tcnp->cn_nameptr, tname, tcnp->cn_namelen);
 706     tname[tcnp->cn_namelen] = '\0';
 707
 708
 709     AFS_GLOCK();
 710     /* XXX use "from" or "to" creds? NFS uses "to" creds */
 711     code = afs_rename(VTOAFS(fdvp), fname, VTOAFS(tdvp), tname, tcnp->cn_cred);
 712     AFS_GUNLOCK();
 713
 714     VOP_UNLOCK(fvp, 0, curproc);
 715     FREE(fname, M_TEMP);
 716     FREE(tname, M_TEMP);
 717     if (code)
 718         goto abortit;                   /* XXX */
 719     if (tdvp == tvp)
 720         vrele(tdvp);
 721     else
 722         vput(tdvp);
 723     if (tvp)
 724         vput(tvp);
 725     vrele(fdvp);
 726     vrele(fvp);
 727     return code;
 728 }
 729
 730 int
 731 afs_nbsd_mkdir(ap)
 732         struct vop_mkdir_args /* {
 733                 struct vnode *a_dvp;
 734                 struct vnode **a_vpp;
 735                 struct componentname *a_cnp;
 736                 struct vattr *a_vap;
 737         } */ *ap;
 738 {
 739     struct vnode *dvp = ap->a_dvp;
 740     struct vattr *vap = ap->a_vap;
 741     int code;
 742     struct vcache *vcp;
 743
 744     GETNAME();
 745 #ifdef DIAGNOSTIC
 746     if ((cnp->cn_flags & HASBUF) == 0)
 747         panic("afs_nbsd_mkdir: no name");
 748 #endif
 749     AFS_GLOCK();
 750     code = afs_mkdir(VTOAFS(dvp), name, vap, &vcp, cnp->cn_cred);
 751     AFS_GUNLOCK();
 752     if (code) {
 753         VOP_ABORTOP(dvp, cnp);
 754         vput(dvp);
 755         DROPNAME();
 756         return(code);
 757     }
 758     if (vcp) {
 759         *ap->a_vpp = AFSTOV(vcp);
 760         vn_lock(AFSTOV(vcp), LK_EXCLUSIVE | LK_RETRY, curproc);
 761     } else
 762         *ap->a_vpp = 0;
 763     DROPNAME();
 764     FREE(cnp->cn_pnbuf, M_NAMEI);
 765     vput(dvp);
 766     return code;
 767 }
 768
 769 int
 770 afs_nbsd_rmdir(ap)
 771         struct vop_rmdir_args /* {
 772                 struct vnode *a_dvp;
 773                 struct vnode *a_vp;
 774                 struct componentname *a_cnp;
 775         } */ *ap;
 776 {
 777     int code;
 778     struct vnode *vp = ap->a_vp;
 779     struct vnode *dvp = ap->a_dvp;
 780
 781     GETNAME();
 782     if (dvp == vp) {
 783         vrele(dvp);
 784         vput(vp);
 785         FREE(cnp->cn_pnbuf, M_NAMEI);
 786         DROPNAME();
 787         return (EINVAL);
 788     }
 789
 790     AFS_GLOCK();
 791     code = afs_rmdir(VTOAFS(dvp), name, cnp->cn_cred);
 792     AFS_GUNLOCK();
 793     DROPNAME();
 794     vput(dvp);
 795     vput(vp);
 796     return code;
 797 }
 798
 799 int
 800 afs_nbsd_symlink(ap)
 801         struct vop_symlink_args /* {
 802                 struct vnode *a_dvp;
 803                 struct vnode **a_vpp;
 804                 struct componentname *a_cnp;
 805                 struct vattr *a_vap;
 806                 char *a_target;
 807         } */ *ap;
 808 {
 809     struct vnode *dvp = ap->a_dvp;
 810     int code;
 811     /* NFS ignores a_vpp; so do we. */
 812
 813     GETNAME();
 814     AFS_GLOCK();
 815     code = afs_symlink(VTOAFS(dvp), name, ap->a_vap, ap->a_target,
 816                         cnp->cn_cred);
 817     AFS_GUNLOCK();
 818     DROPNAME();
 819     FREE(cnp->cn_pnbuf, M_NAMEI);
 820     vput(dvp);
 821     return code;
 822 }
 823
 824 int
 825 afs_nbsd_readdir(ap)
 826         struct vop_readdir_args /* {
 827                 struct vnode *a_vp;
 828                 struct uio *a_uio;
 829                 struct ucred *a_cred;
 830                 int *a_eofflag;
 831                 int *a_ncookies;
 832                 u_long **a_cookies;
 833         } */ *ap;
 834 {
 835     int code;
 836
 837     AFS_GLOCK();
 838 #ifdef AFS_HAVE_COOKIES
 839     printf("readdir %p cookies %p ncookies %d\n", ap->a_vp, ap->a_cookies,
 840            ap->a_ncookies);
 841     code = afs_readdir(VTOAFS(ap->a_vp), ap->a_uio, ap->a_cred,
 842                        ap->a_eofflag, ap->a_ncookies, ap->a_cookies);
 843 #else
 844     code = afs_readdir(VTOAFS(ap->a_vp), ap->a_uio, ap->a_cred, ap->a_eofflag);
 845 #endif
 846     AFS_GUNLOCK();
 847     return code;
 848 }
 849
 850 int
 851 afs_nbsd_readlink(ap)
 852         struct vop_readlink_args /* {
 853                 struct vnode *a_vp;
 854                 struct uio *a_uio;
 855                 struct ucred *a_cred;
 856         } */ *ap;
 857 {
 858     int code;
 859
 860     AFS_GLOCK();
 861     code = afs_readlink(VTOAFS(ap->a_vp), ap->a_uio, ap->a_cred);
 862     AFS_GUNLOCK();
 863     return code;
 864 }
 865
 866 extern int prtactive;
 867
 868 int
 869 afs_nbsd_inactive(ap)
 870         struct vop_inactive_args /* {
 871                 struct vnode *a_vp;
 872         } */ *ap;
 873 {
 874     struct vnode *vp = ap->a_vp;
 875     struct vcache *vc = VTOAFS(vp);
 876     int haveGlock = ISAFS_GLOCK();
 877
 878     AFS_STATCNT(afs_inactive);
 879
 880     if (prtactive && vp->v_usecount != 0)
 881         vprint("afs_nbsd_inactive(): pushing active", vp);
 882
 883     if (!haveGlock)
 884         AFS_GLOCK();
 885     afs_InactiveVCache(vc, 0);   /* decrs ref counts */
 886     if (!haveGlock)
 887         AFS_GUNLOCK();
 888
 889     lockinit(&vc->rwlock, PINOD, "vcache", 0, 0);
 890     return 0;
 891 }
 892
 893 int
 894 afs_nbsd_reclaim(ap)
 895         struct vop_reclaim_args /* {
 896                 struct vnode *a_vp;
 897         } */ *ap;
 898 {
 899     int code, slept;
 900     struct vnode *vp = ap->a_vp;
 901     struct vcache *avc = VTOAFS(vp);
 902     int haveGlock = ISAFS_GLOCK();
 903     int haveVlock = CheckLock(&afs_xvcache);
 904
 905     if (!haveGlock)
 906         AFS_GLOCK();
 907     if (!haveVlock)
 908         ObtainWriteLock(&afs_xvcache, 901);
 909 #ifndef AFS_DISCON_ENV
 910     code = afs_FlushVCache(avc, &slept); /* tosses our stuff from vnode */
 911 #else
 912     /* reclaim the vnode and the in-memory vcache, but keep the on-disk vcache */
 913     code = afs_FlushVS(avc);
 914 #endif
 915     if (!haveVlock)
 916         ReleaseWriteLock(&afs_xvcache);
 917     if (!haveGlock)
 918         AFS_GUNLOCK();
 919     return code;
 920 }
 921
 922 int
 923 afs_nbsd_lock(ap)
 924         struct vop_lock_args /* {
 925                 struct vnode *a_vp;
 926                 int a_flags;
 927                 sturct proc *a_p;
 928         } */ *ap;
 929 {
 930     struct vnode *vp = ap->a_vp;
 931     struct vcache *vc = VTOAFS(vp);
 932
 933     if (!vc)
 934         panic("afs_nbsd_lock: null vcache");
 935     return lockmgr(&vc->rwlock, ap->a_flags | LK_CANRECURSE, &vp->v_interlock, ap->a_p);
 936 }
 937
 938 int
 939 afs_nbsd_unlock(ap)
 940         struct vop_unlock_args /* {
 941                 struct vnode *a_vp;
 942                 int a_flags;
 943                 struct proc *a_p;
 944         } */ *ap;
 945 {
 946     struct vnode *vp = ap->a_vp;
 947     struct vcache *vc = VTOAFS(vp);
 948
 949     if (!vc)
 950         panic("afs_nbsd_unlock: null vcache");
 951     return lockmgr(&vc->rwlock, ap->a_flags | LK_RELEASE, &vp->v_interlock, ap->a_p);
 952 }
 953
 954 int
 955 afs_nbsd_bmap(ap)
 956         struct vop_bmap_args /* {
 957                 struct vnode *a_vp;
 958                 daddr_t  a_bn;
 959                 struct vnode **a_vpp;
 960                 daddr_t *a_bnp;
 961                 int *a_runp;
 962         } */ *ap;
 963 {
 964     struct vcache *vcp = VTOAFS(ap->a_vp);
 965
 966     AFS_STATCNT(afs_bmap);
 967     if (ap->a_bnp)
 968         ap->a_bnp = (daddr_t *) (ap->a_bn * (8192 / DEV_BSIZE));
 969     if (ap->a_vpp)
 970         *ap->a_vpp = (vcp) ? AFSTOV(vcp) : NULL;
 971     return 0;
 972 }
 973
 974 int
 975 afs_nbsd_strategy(ap)
 976     struct vop_strategy_args /* {
 977         struct buf *a_bp;
 978     } */ *ap;
 979 {
 980     struct buf *abp = ap->a_bp;
 981     struct uio tuio;
 982     struct iovec tiovec[1];
 983     struct vcache *tvc = VTOAFS(abp->b_vp);
 984     struct ucred *credp = osi_curcred();
 985     long len = abp->b_bcount;
 986     int code;
 987
 988     AFS_STATCNT(afs_strategy);
 989
 990     tuio.afsio_iov = tiovec;
 991     tuio.afsio_iovcnt = 1;
 992     tuio.afsio_seg = AFS_UIOSYS;
 993     tuio.afsio_resid = len;
 994     tiovec[0].iov_base = abp->b_un.b_addr;
 995     tiovec[0].iov_len = len;
 996
 997     AFS_GLOCK();
 998     if ((abp->b_flags & B_READ) == B_READ) {
 999         code = afs_rdwr(tvc, &tuio, UIO_READ, 0, credp);
1000         if (code == 0 && tuio.afsio_resid > 0)
1001             bzero(abp->b_un.b_addr + len - tuio.afsio_resid, tuio.afsio_resid);
1002     } else
1003         code = afs_rdwr(tvc, &tuio, UIO_WRITE, 0, credp);
1004     AFS_GUNLOCK();
1005
1006     ReleaseWriteLock(&tvc->lock);
1007     AFS_RELE(AFSTOV(tvc));
1008     return code;
1009 }
1010
1011 int
1012 afs_nbsd_print(ap)
1013         struct vop_print_args /* {
1014                 struct vnode *a_vp;
1015         } */ *ap;
1016 {
1017     struct vnode *vp = ap->a_vp;
1018     struct vcache *vc = VTOAFS(ap->a_vp);
1019
1020     printf("tag %d, fid: %d.%x.%x.%x, ", vp->v_tag, vc->fid.Cell,
1021            (int) vc->fid.Fid.Volume, (int) vc->fid.Fid.Vnode, (int) vc->fid.Fid.Unique);
1022     lockmgr_printinfo(&vc->rwlock);
1023     printf("\n");
1024     return 0;
1025 }
1026
1027 int
1028 afs_nbsd_islocked(ap)
1029         struct vop_islocked_args /* {
1030                 struct vnode *a_vp;
1031         } */ *ap;
1032 {
1033     return lockstatus(&VTOAFS(ap->a_vp)->rwlock);
1034 }
1035
1036 /*
1037  * Return POSIX pathconf information applicable to ufs filesystems.
1038  */
1039 int
1040 afs_nbsd_pathconf(ap)
1041         struct vop_pathconf_args /* {
1042                 struct vnode *a_vp;
1043                 int a_name;
1044                 int *a_retval;
1045         } */ *ap;
1046 {
1047     AFS_STATCNT(afs_cntl);
1048     switch (ap->a_name) {
1049     case _PC_LINK_MAX:
1050         *ap->a_retval = LINK_MAX;
1051         break;
1052     case _PC_NAME_MAX:
1053         *ap->a_retval = NAME_MAX;
1054         break;
1055     case _PC_PATH_MAX:
1056         *ap->a_retval = PATH_MAX;
1057         break;
1058     case _PC_CHOWN_RESTRICTED:
1059         *ap->a_retval = 1;
1060         break;
1061     case _PC_NO_TRUNC:
1062         *ap->a_retval = 1;
1063         break;
1064     case _PC_PIPE_BUF:
1065         return EINVAL;
1066         break;
1067     default:
1068         return EINVAL;
1069     }
1070     return 0;
1071 }
1072
1073 extern int
1074 afs_lockctl(struct vcache *avc, struct AFS_FLOCK *af, int acmd, struct AFS_UCRED *acred, pid_t clid);
1075
1076 /*
1077  * Advisory record locking support (fcntl() POSIX style)
1078  */
1079 int
1080 afs_nbsd_advlock(ap)
1081         struct vop_advlock_args /* {
1082                 struct vnode *a_vp;
1083                 caddr_t  a_id;
1084                 int  a_op;
1085                 struct flock *a_fl;
1086                 int  a_flags;
1087         } */ *ap;
1088 {
1089     int code;
1090
1091     AFS_GLOCK();
1092     code = afs_lockctl(VTOAFS(ap->a_vp), ap->a_fl, ap->a_op, osi_curcred(),
1093                        (int) ap->a_id);
1094     AFS_GUNLOCK();
1095     return code;
1096 }