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