kill macos prior to panther
[openafs.git] / src / afs / DARWIN / osi_vnodeops.c
1 /*
2  * Portions Copyright (c) 2003 Apple Computer, Inc.  All rights reserved.
3  */
4 #include <afsconfig.h>
5 #include <afs/param.h>
6
7
8 #include <afs/sysincludes.h>    /* Standard vendor system headers */
9 #include <afsincludes.h>        /* Afs-based standard headers */
10 #include <afs/afs_stats.h>      /* statistics */
11 #include <sys/malloc.h>
12 #include <sys/namei.h>
13 #include <sys/ubc.h>
14 #include <vfs/vfs_support.h>
15 #ifdef AFS_DARWIN80_ENV
16 #include <sys/vnode_if.h>
17 #include <sys/kauth.h>
18 #endif
19
20 #ifdef AFS_DARWIN80_ENV
21 #define VOPPREF(x) &vnop_ ## x
22 #define VOPPROT(x) vnop_ ## x
23 #define OSI_UPL_ABORT_RANGE(pl, offset, size, flags) \
24   ubc_upl_abort_range((pl), (offset), (size), (flags))
25 #define OSI_UPL_COMMIT_RANGE(pl, offset, size, flags) \
26   ubc_upl_commit_range((pl), (offset), (size), (flags))
27 #define OSI_UPL_MAP(upl, offset) ubc_upl_map((upl), (offset))
28 #define OSI_UPL_UNMAP(upl) ubc_upl_unmap((upl))
29 #define VOP_ABORTOP(x, y)
30 #else
31 #define VOPPREF(x) &vop_ ## x
32 #define VOPPROT(x) vop_ ## x
33 #define OSI_UPL_ABORT_RANGE(pl, offset, size, flags) \
34   kernel_upl_abort_range((pl), (offset), (size), (flags))
35 #define OSI_UPL_COMMIT_RANGE(pl, offset, size, flags) \
36   kernel_upl_commit_range((pl), (offset), (size), (flags), \
37                           UPL_GET_INTERNAL_PAGE_LIST((pl)),\
38                                     MAX_UPL_TRANSFER)
39 #define OSI_UPL_MAP(upl, offset) kernel_upl_map(kernel_map, (upl), (offset))
40 #define OSI_UPL_UNMAP(upl) kernel_upl_unmap(kernel_map, (upl))
41 #endif
42
43 extern char afs_zeros[AFS_ZEROS];
44
45 int afs_vop_lookup(struct VOPPROT(lookup_args) *);
46 int afs_vop_create(struct VOPPROT(create_args) *);
47 int afs_vop_mknod(struct VOPPROT(mknod_args) *);
48 int afs_vop_open(struct VOPPROT(open_args) *);
49 int afs_vop_close(struct VOPPROT(close_args) *);
50 int afs_vop_access(struct VOPPROT(access_args) *);
51 int afs_vop_getattr(struct VOPPROT(getattr_args) *);
52 int afs_vop_setattr(struct VOPPROT(setattr_args) *);
53 int afs_vop_read(struct VOPPROT(read_args) *);
54 int afs_vop_write(struct VOPPROT(write_args) *);
55 int afs_vop_pagein(struct VOPPROT(pagein_args) *);
56 int afs_vop_pageout(struct VOPPROT(pageout_args) *);
57 int afs_vop_ioctl(struct VOPPROT(ioctl_args) *);
58 int afs_vop_select(struct VOPPROT(select_args) *);
59 int afs_vop_mmap(struct VOPPROT(mmap_args) *);
60 int afs_vop_fsync(struct VOPPROT(fsync_args) *);
61 int afs_vop_remove(struct VOPPROT(remove_args) *);
62 int afs_vop_link(struct VOPPROT(link_args) *);
63 int afs_vop_rename(struct VOPPROT(rename_args) *);
64 int afs_vop_mkdir(struct VOPPROT(mkdir_args) *);
65 int afs_vop_rmdir(struct VOPPROT(rmdir_args) *);
66 int afs_vop_symlink(struct VOPPROT(symlink_args) *);
67 int afs_vop_readdir(struct VOPPROT(readdir_args) *);
68 int afs_vop_readlink(struct VOPPROT(readlink_args) *);
69 int afs_vop_inactive(struct VOPPROT(inactive_args) *);
70 int afs_vop_reclaim(struct VOPPROT(reclaim_args) *);
71 int afs_vop_strategy(struct VOPPROT(strategy_args) *);
72 int afs_vop_pathconf(struct VOPPROT(pathconf_args) *);
73 int afs_vop_advlock(struct VOPPROT(advlock_args) *);
74 int afs_vop_blktooff __P((struct VOPPROT(blktooff_args) *));
75 int afs_vop_offtoblk __P((struct VOPPROT(offtoblk_args) *));
76 #ifndef AFS_DARWIN80_ENV
77 int afs_vop_truncate(struct VOPPROT(truncate_args) *);
78 int afs_vop_update(struct VOPPROT(update_args) *);
79 int afs_vop_lock(struct VOPPROT(lock_args) *);
80 int afs_vop_unlock(struct VOPPROT(unlock_args) *);
81 int afs_vop_bmap(struct VOPPROT(bmap_args) *);
82 int afs_vop_seek(struct VOPPROT(seek_args) *);
83 int afs_vop_cmap __P((struct VOPPROT(cmap_args) *));
84 int afs_vop_print(struct VOPPROT(print_args) *);
85 int afs_vop_islocked(struct VOPPROT(islocked_args) *);
86 #endif
87
88 #define afs_vop_opnotsupp \
89         ((int (*) __P((struct  vop_reallocblks_args *)))eopnotsupp)
90 #define afs_vop_valloc afs_vop_opnotsupp
91 #define afs_vop_vfree afs_vop_opnotsupp
92 #define afs_vop_blkatoff afs_vop_opnotsupp
93 #define afs_vop_reallocblks afs_vop_opnotsupp
94
95 /* Global vfs data structures for AFS. */
96 int (**afs_vnodeop_p) ();
97
98 #define VOPFUNC int (*)(void *)
99
100 struct vnodeopv_entry_desc afs_vnodeop_entries[] = {
101     {VOPPREF(default_desc), (VOPFUNC)vn_default_error},
102     {VOPPREF(lookup_desc), (VOPFUNC)afs_vop_lookup},    /* lookup */
103     {VOPPREF(create_desc), (VOPFUNC)afs_vop_create},    /* create */
104     {VOPPREF(mknod_desc), (VOPFUNC)afs_vop_mknod},      /* mknod */
105     {VOPPREF(open_desc), (VOPFUNC)afs_vop_open},        /* open */
106     {VOPPREF(close_desc), (VOPFUNC)afs_vop_close},      /* close */
107     {VOPPREF(access_desc), (VOPFUNC)afs_vop_access},    /* access */
108     {VOPPREF(getattr_desc), (VOPFUNC)afs_vop_getattr},  /* getattr */
109     {VOPPREF(setattr_desc), (VOPFUNC)afs_vop_setattr},  /* setattr */
110     {VOPPREF(read_desc), (VOPFUNC)afs_vop_read},        /* read */
111     {VOPPREF(write_desc), (VOPFUNC)afs_vop_write},      /* write */
112     {VOPPREF(pagein_desc), (VOPFUNC)afs_vop_pagein},    /* read */
113     {VOPPREF(pageout_desc), (VOPFUNC)afs_vop_pageout},  /* write */
114     {VOPPREF(ioctl_desc), (VOPFUNC)afs_vop_ioctl},      /* XXX ioctl */
115     {VOPPREF(select_desc), (VOPFUNC)afs_vop_select},    /* select */
116     {VOPPREF(mmap_desc), (VOPFUNC)afs_vop_mmap},        /* mmap */
117     {VOPPREF(fsync_desc), (VOPFUNC)afs_vop_fsync},      /* fsync */
118 #ifndef AFS_DARWIN80_ENV
119     {VOPPREF(seek_desc), (VOPFUNC)afs_vop_seek},        /* seek */
120 #endif
121     {VOPPREF(remove_desc), (VOPFUNC)afs_vop_remove},    /* remove */
122     {VOPPREF(link_desc), (VOPFUNC)afs_vop_link},        /* link */
123     {VOPPREF(rename_desc), (VOPFUNC)afs_vop_rename},    /* rename */
124     {VOPPREF(mkdir_desc), (VOPFUNC)afs_vop_mkdir},      /* mkdir */
125     {VOPPREF(rmdir_desc), (VOPFUNC)afs_vop_rmdir},      /* rmdir */
126     {VOPPREF(symlink_desc), (VOPFUNC)afs_vop_symlink},  /* symlink */
127     {VOPPREF(readdir_desc), (VOPFUNC)afs_vop_readdir},  /* readdir */
128     {VOPPREF(readlink_desc), (VOPFUNC)afs_vop_readlink},        /* readlink */
129 #ifndef AFS_DARWIN80_ENV
130     {VOPPREF(abortop_desc), (VOPFUNC)nop_abortop },             /* abortop */
131 #endif
132     {VOPPREF(inactive_desc), (VOPFUNC)afs_vop_inactive},        /* inactive */
133     {VOPPREF(reclaim_desc), (VOPFUNC)afs_vop_reclaim},  /* reclaim */
134 #ifndef AFS_DARWIN80_ENV
135     {VOPPREF(lock_desc), (VOPFUNC)afs_vop_lock},        /* lock */
136     {VOPPREF(unlock_desc), (VOPFUNC)afs_vop_unlock},    /* unlock */
137     {VOPPREF(bmap_desc), (VOPFUNC)afs_vop_bmap},        /* bmap */
138 #endif
139 #ifdef AFS_DARWIN80_ENV
140     {VOPPREF(strategy_desc), (VOPFUNC)err_strategy},    /* strategy */
141 #else
142     {VOPPREF(strategy_desc), (VOPFUNC)afs_vop_strategy},        /* strategy */
143 #endif
144 #ifndef AFS_DARWIN80_ENV
145     {VOPPREF(print_desc), (VOPFUNC)afs_vop_print},      /* print */
146     {VOPPREF(islocked_desc), (VOPFUNC)afs_vop_islocked},        /* islocked */
147 #endif
148     {VOPPREF(pathconf_desc), (VOPFUNC)afs_vop_pathconf},        /* pathconf */
149     {VOPPREF(advlock_desc), (VOPFUNC)afs_vop_advlock},  /* advlock */
150 #ifndef AFS_DARWIN80_ENV
151     {VOPPREF(blkatoff_desc), (VOPFUNC)afs_vop_blkatoff},        /* blkatoff */
152     {VOPPREF(valloc_desc), (VOPFUNC)afs_vop_valloc},    /* valloc */
153     {VOPPREF(reallocblks_desc), (VOPFUNC)afs_vop_reallocblks},  /* reallocblks */
154     {VOPPREF(vfree_desc), (VOPFUNC)afs_vop_vfree},      /* vfree */
155     {VOPPREF(update_desc), (VOPFUNC)afs_vop_update},    /* update */
156     {VOPPREF(cmap_desc), (VOPFUNC)afs_vop_cmap},        /* cmap */
157     {VOPPREF(truncate_desc), (VOPFUNC)afs_vop_truncate},        /* truncate */
158 #endif
159     {VOPPREF(blktooff_desc), (VOPFUNC)afs_vop_blktooff},        /* blktooff */
160     {VOPPREF(offtoblk_desc), (VOPFUNC)afs_vop_offtoblk},        /* offtoblk */
161     {VOPPREF(bwrite_desc), (VOPFUNC)vn_bwrite},
162     {(struct vnodeop_desc *)NULL, (void (*)())NULL}
163 };
164 struct vnodeopv_desc afs_vnodeop_opv_desc =
165     { &afs_vnodeop_p, afs_vnodeop_entries };
166
167 #ifdef AFS_DARWIN80_ENV
168 /* vfs structures for incompletely initialized vnodes */
169 int (**afs_dead_vnodeop_p) ();
170
171 struct vnodeopv_entry_desc afs_dead_vnodeop_entries[] = {
172     {VOPPREF(default_desc), (VOPFUNC)vn_default_error},
173     {VOPPREF(lookup_desc), (VOPFUNC)vn_default_error},  /* lookup */
174     {VOPPREF(create_desc), (VOPFUNC)err_create},        /* create */
175     {VOPPREF(mknod_desc), (VOPFUNC)err_mknod},  /* mknod */
176     {VOPPREF(open_desc), (VOPFUNC)err_open},    /* open */
177     {VOPPREF(close_desc), (VOPFUNC)err_close},  /* close */
178     {VOPPREF(access_desc), (VOPFUNC)err_access},        /* access */
179     {VOPPREF(getattr_desc), (VOPFUNC)err_getattr},      /* getattr */
180     {VOPPREF(setattr_desc), (VOPFUNC)err_setattr},      /* setattr */
181     {VOPPREF(read_desc), (VOPFUNC)err_read},    /* read */
182     {VOPPREF(write_desc), (VOPFUNC)err_write},  /* write */
183     {VOPPREF(pagein_desc), (VOPFUNC)err_pagein},        /* read */
184     {VOPPREF(pageout_desc), (VOPFUNC)err_pageout},      /* write */
185     {VOPPREF(ioctl_desc), (VOPFUNC)err_ioctl},  /* XXX ioctl */
186     {VOPPREF(select_desc), (VOPFUNC)nop_select},        /* select */
187     {VOPPREF(mmap_desc), (VOPFUNC)err_mmap},    /* mmap */
188     {VOPPREF(fsync_desc), (VOPFUNC)err_fsync},  /* fsync */
189     {VOPPREF(remove_desc), (VOPFUNC)err_remove},        /* remove */
190     {VOPPREF(link_desc), (VOPFUNC)err_link},    /* link */
191     {VOPPREF(rename_desc), (VOPFUNC)err_rename},        /* rename */
192     {VOPPREF(mkdir_desc), (VOPFUNC)err_mkdir},  /* mkdir */
193     {VOPPREF(rmdir_desc), (VOPFUNC)err_rmdir},  /* rmdir */
194     {VOPPREF(symlink_desc), (VOPFUNC)err_symlink},      /* symlink */
195     {VOPPREF(readdir_desc), (VOPFUNC)err_readdir},      /* readdir */
196     {VOPPREF(readlink_desc), (VOPFUNC)err_readlink},    /* readlink */
197     {VOPPREF(inactive_desc), (VOPFUNC)afs_vop_inactive},        /* inactive */
198     {VOPPREF(reclaim_desc), (VOPFUNC)afs_vop_reclaim},  /* reclaim */
199     {VOPPREF(strategy_desc), (VOPFUNC)err_strategy},    /* strategy */
200     {VOPPREF(pathconf_desc), (VOPFUNC)err_pathconf},    /* pathconf */
201     {VOPPREF(advlock_desc), (VOPFUNC)err_advlock},      /* advlock */
202     {VOPPREF(blktooff_desc), (VOPFUNC)err_blktooff},    /* blktooff */
203     {VOPPREF(offtoblk_desc), (VOPFUNC)err_offtoblk},    /* offtoblk */
204     {VOPPREF(bwrite_desc), (VOPFUNC)err_bwrite},
205     {(struct vnodeop_desc *)NULL, (void (*)())NULL}
206 };
207 struct vnodeopv_desc afs_dead_vnodeop_opv_desc =
208     { &afs_dead_vnodeop_p, afs_dead_vnodeop_entries };
209 #endif
210
211 #define GETNAME()       \
212     struct componentname *cnp = ap->a_cnp; \
213     char *name; \
214     MALLOC(name, char *, cnp->cn_namelen+1, M_TEMP, M_WAITOK); \
215     memcpy(name, cnp->cn_nameptr, cnp->cn_namelen); \
216     name[cnp->cn_namelen] = '\0'
217
218 #define DROPNAME() FREE(name, M_TEMP)
219
220 void 
221 darwin_vn_hold(struct vnode *vp)
222 {
223     int haveGlock=ISAFS_GLOCK(); 
224     struct vcache *tvc = VTOAFS(vp);
225
226 #ifndef AFS_DARWIN80_ENV
227     tvc->f.states |= CUBCinit;
228 #endif
229 #ifdef AFS_DARWIN80_ENV
230     osi_Assert((tvc->f.states & CVInit) == 0);
231     if (tvc->f.states & CDeadVnode)
232        osi_Assert(!vnode_isinuse(vp, 1));
233 #endif
234     if (haveGlock) AFS_GUNLOCK(); 
235
236 #ifdef AFS_DARWIN80_ENV
237         if (vnode_get(vp)) {
238            /* being terminated. kernel won't give us a ref. Now what? our
239               callers don't expect us to fail */
240            if (haveGlock) AFS_GLOCK(); 
241            return;
242         }
243         if (vnode_ref(vp)) {
244             vnode_put(vp);
245             if (haveGlock) AFS_GLOCK(); 
246             return;
247         }
248         vnode_put(vp);
249 #else
250     /* vget needed for 0 ref'd vnode in GetVCache to not panic in vref.
251        vref needed for multiref'd vnode in vnop_remove not to deadlock
252        ourselves during vop_inactive, except we also need to not reinst
253        the ubc... so we just call VREF there now anyway. */
254
255     if (VREFCOUNT_GT(tvc, 0))
256         VREF(((struct vnode *)(vp))); 
257      else 
258         afs_vget(afs_globalVFS, 0, (vp));
259 #endif
260
261 #ifndef AFS_DARWIN80_ENV
262     if (UBCINFOMISSING(vp) || UBCINFORECLAIMED(vp)) {
263         ubc_info_init(vp); 
264     }
265 #endif
266
267     if (haveGlock) AFS_GLOCK(); 
268 #ifndef AFS_DARWIN80_ENV
269     tvc->f.states &= ~CUBCinit;
270 #endif
271 }
272 int
273 afs_vop_lookup(ap)
274      struct VOPPROT(lookup_args)/* {
275                                  * struct vnodeop_desc * a_desc;
276                                  * struct vnode *a_dvp;
277                                  * struct vnode **a_vpp;
278                                  * struct componentname *a_cnp;
279                                  * } */ *ap;
280 {
281     int error;
282     struct vcache *vcp;
283     struct vnode *vp, *dvp;
284     register int flags = ap->a_cnp->cn_flags;
285     int lockparent;             /* 1 => lockparent flag is set */
286     int wantparent;             /* 1 => wantparent or lockparent flag */
287     struct proc *p;
288 #ifdef AFS_DARWIN80_ENV
289     vcp = VTOAFS(ap->a_dvp);
290     if (vcp->mvstat != 1) {
291         error = cache_lookup(ap->a_dvp, ap->a_vpp, ap->a_cnp);
292         if (error == -1) 
293             return 0;
294         if (error == ENOENT) 
295             return error;
296     }
297 #endif
298
299     GETNAME();
300     p = vop_cn_proc;
301
302     lockparent = flags & LOCKPARENT;
303     wantparent = flags & (LOCKPARENT | WANTPARENT);
304
305     if (!vnode_isdir(ap->a_dvp)) {
306         *ap->a_vpp = 0;
307         DROPNAME();
308         return ENOTDIR;
309     }
310     dvp = ap->a_dvp;
311 #ifndef AFS_DARWIN80_ENV
312     if (flags & ISDOTDOT)
313         VOP_UNLOCK(dvp, 0, p);
314 #endif
315     AFS_GLOCK();
316     error = afs_lookup(VTOAFS(dvp), name, &vcp, vop_cn_cred);
317     AFS_GUNLOCK();
318     if (error) {
319 #ifndef AFS_DARWIN80_ENV
320         if (flags & ISDOTDOT)
321             VOP_LOCK(dvp, LK_EXCLUSIVE | LK_RETRY, p);
322 #endif
323         if ((cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME)
324             && (flags & ISLASTCN) && error == ENOENT)
325             error = EJUSTRETURN;
326 #ifndef AFS_DARWIN80_ENV
327         if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
328             cnp->cn_flags |= SAVENAME;
329 #endif
330         DROPNAME();
331         *ap->a_vpp = 0;
332         return (error);
333     }
334 #ifdef AFS_DARWIN80_ENV
335     if ((error=afs_darwin_finalizevnode(vcp, ap->a_dvp, ap->a_cnp, 0, 0))) {
336         DROPNAME();
337         *ap->a_vpp = 0;
338         return error;
339     }
340 #endif
341     vp = AFSTOV(vcp);           /* always get a node if no error */
342 #ifndef AFS_DARWIN80_ENV /* XXX needed for multi-mount thing, but can't have it yet */
343     vp->v_vfsp = dvp->v_vfsp;
344
345     if (UBCINFOMISSING(vp) ||
346         UBCINFORECLAIMED(vp)) {
347             ubc_info_init(vp);
348     }
349 #endif
350
351 #ifndef AFS_DARWIN80_ENV
352     /* The parent directory comes in locked.  We unlock it on return
353      * unless the caller wants it left locked.
354      * we also always return the vnode locked. */
355
356     if (flags & ISDOTDOT) {
357         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
358         /* always return the child locked */
359         if (lockparent && (flags & ISLASTCN)
360             && (error = vn_lock(dvp, LK_EXCLUSIVE, p))) {
361             vput(vp);
362             DROPNAME();
363             return (error);
364         }
365     } else if (vp == dvp) {
366         /* they're the same; afs_lookup() already ref'ed the leaf.
367          * It came in locked, so we don't need to ref OR lock it */
368     } else {
369         if (!lockparent || !(flags & ISLASTCN))
370             VOP_UNLOCK(dvp, 0, p);      /* done with parent. */
371         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
372         /* always return the child locked */
373     }
374 #endif
375     *ap->a_vpp = vp;
376
377 #ifndef AFS_DARWIN80_ENV
378     if ((cnp->cn_nameiop == RENAME && wantparent && (flags & ISLASTCN)
379          || (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))))
380         cnp->cn_flags |= SAVENAME;
381 #endif
382
383     DROPNAME();
384     return error;
385 }
386
387 int
388 afs_vop_create(ap)
389      struct VOPPROT(create_args)        /* {
390                                  * struct vnode *a_dvp;
391                                  * struct vnode **a_vpp;
392                                  * struct componentname *a_cnp;
393                                  * struct vattr *a_vap;
394                                  * } */ *ap;
395 {
396     int error = 0;
397     struct vcache *vcp;
398     register struct vnode *dvp = ap->a_dvp;
399     struct proc *p;
400     GETNAME();
401     p = vop_cn_proc;
402
403     /* vnode layer handles excl/nonexcl */
404     AFS_GLOCK();
405     error =
406         afs_create(VTOAFS(dvp), name, ap->a_vap, NONEXCL, ap->a_vap->va_mode,
407                    &vcp, vop_cn_cred);
408     AFS_GUNLOCK();
409     if (error) {
410 #ifndef AFS_DARWIN80_ENV
411         VOP_ABORTOP(dvp, cnp);
412         vput(dvp);
413 #endif
414         DROPNAME();
415         return (error);
416     }
417
418     if (vcp) {
419 #ifdef AFS_DARWIN80_ENV
420       if ((error=afs_darwin_finalizevnode(vcp, ap->a_dvp, ap->a_cnp, 0, 0))) {
421             DROPNAME();
422             *ap->a_vpp=0;
423             return error;
424         }
425 #endif
426         *ap->a_vpp = AFSTOV(vcp);
427 #ifndef AFS_DARWIN80_ENV /* XXX needed for multi-mount thing, but can't have it yet */
428         (*ap->a_vpp)->v_vfsp = dvp->v_vfsp;
429         vn_lock(*ap->a_vpp, LK_EXCLUSIVE | LK_RETRY, p);
430         if (UBCINFOMISSING(*ap->a_vpp) || UBCINFORECLAIMED(*ap->a_vpp)) {
431             vcp->f.states |= CUBCinit;
432             ubc_info_init(*ap->a_vpp);
433             vcp->f.states &= ~CUBCinit;
434         }
435 #endif
436     } else
437         *ap->a_vpp = 0;
438
439 #ifndef AFS_DARWIN80_ENV
440     if ((cnp->cn_flags & SAVESTART) == 0)
441         FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
442     vput(dvp);
443 #endif
444     DROPNAME();
445     return error;
446 }
447
448 int
449 afs_vop_mknod(ap)
450      struct VOPPROT(mknod_args) /* {
451                                  * struct vnode *a_dvp;
452                                  * struct vnode **a_vpp;
453                                  * struct componentname *a_cnp;
454                                  * struct vattr *a_vap;
455                                  * } */ *ap;
456 {
457 #ifndef AFS_DARWIN80_ENV
458     FREE_ZONE(ap->a_cnp->cn_pnbuf, ap->a_cnp->cn_pnlen, M_NAMEI);
459     vput(ap->a_dvp);
460 #endif
461     return (ENODEV);
462 }
463
464 int
465 afs_vop_open(ap)
466      struct VOPPROT(open_args)  /* {
467                                  * struct vnode *a_vp;
468                                  * int  a_mode;
469                                  * struct ucred *a_cred;
470                                  * struct proc *a_p;
471                                  * } */ *ap;
472 {
473     int error;
474     struct vnode *vp = ap->a_vp;
475     struct vcache *vc = VTOAFS(vp);
476 #if !defined(AFS_DARWIN80_ENV)
477     int didhold = 0;
478     /*----------------------------------------------------------------
479      * osi_VM_TryReclaim() removes the ubcinfo of a vnode, but that vnode
480      * can later be passed to vn_open(), which will skip the call to
481      * ubc_hold(), and when the ubcinfo is later added, the ui_refcount
482      * will be off.  So we compensate by calling ubc_hold() ourselves
483      * when ui_refcount is less than 2.  If an error occurs in afs_open()
484      * we must call ubc_rele(), which is what vn_open() would do if it
485      * was able to call ubc_hold() in the first place.
486      *----------------------------------------------------------------*/
487     if (vp->v_type == VREG && !(vp->v_flag & VSYSTEM)
488       && vp->v_ubcinfo->ui_refcount < 2)
489         didhold = ubc_hold(vp);
490 #endif /* !AFS_DARWIN80_ENV */
491     AFS_GLOCK();
492     error = afs_open(&vc, ap->a_mode, vop_cred);
493 #ifdef DIAGNOSTIC
494     if (AFSTOV(vc) != vp)
495         panic("AFS open changed vnode!");
496 #endif
497     osi_FlushPages(vc, vop_cred);
498     AFS_GUNLOCK();
499 #if !defined(AFS_DARWIN80_ENV)
500     if (error && didhold)
501         ubc_rele(vp);
502 #endif /* !AFS_DARWIN80_ENV */
503     return error;
504 }
505
506 int
507 afs_vop_close(ap)
508      struct VOPPROT(close_args) /* {
509                                  * struct vnode *a_vp;
510                                  * int  a_fflag;
511                                  * struct ucred *a_cred;
512                                  * struct proc *a_p;
513                                  * } */ *ap;
514 {
515     int code;
516     struct vnode *vp = ap->a_vp;
517     struct vcache *avc = VTOAFS(vp);
518     AFS_GLOCK();
519     if (vop_cred)
520         code = afs_close(avc, ap->a_fflag, vop_cred);
521     else
522         code = afs_close(avc, ap->a_fflag, &afs_osi_cred);
523     osi_FlushPages(avc, vop_cred);      /* hold bozon lock, but not basic vnode lock */
524     /* This is legit; it just forces the fstrace event to happen */
525     code = afs_CheckCode(code, NULL, 60);
526     AFS_GUNLOCK();
527
528     return code;
529 }
530
531 #ifdef AFS_DARWIN80_ENV
532 extern int afs_fakestat_enable;
533
534 int
535 afs_vop_access(ap)
536      struct VOPPROT(access_args)        /* {
537                                  * struct vnode *a_vp;
538                                  * int  a_action;
539                                  * vfs_context_t a_context;
540                                  * } */ *ap;
541 {
542     int code;
543     struct vrequest treq;
544     struct afs_fakestat_state fakestate;
545     struct vcache * tvc = VTOAFS(ap->a_vp);
546     int bits=0;
547     int cmb = CHECK_MODE_BITS;
548     AFS_GLOCK();
549     afs_InitFakeStat(&fakestate);
550     if ((code = afs_InitReq(&treq, vop_cred)))
551         goto out2;
552
553     code = afs_TryEvalFakeStat(&tvc, &fakestate, &treq);
554     if (code) {
555         code = afs_CheckCode(code, &treq, 55);
556         goto out;
557     }
558
559     code = afs_VerifyVCache(tvc, &treq);
560     if (code) {
561         code = afs_CheckCode(code, &treq, 56);
562         goto out;
563     }
564     if (afs_fakestat_enable && tvc->mvstat && !(tvc->f.states & CStatd)) {
565         code = 0;
566         goto out;
567     }
568     if (vnode_isdir(ap->a_vp)) {
569        if (ap->a_action & KAUTH_VNODE_LIST_DIRECTORY)
570           bits |= PRSFS_LOOKUP;
571        if (ap->a_action & KAUTH_VNODE_ADD_FILE)
572           bits |= PRSFS_INSERT;
573        if (ap->a_action & KAUTH_VNODE_SEARCH)
574           bits |= PRSFS_LOOKUP;
575        if (ap->a_action & KAUTH_VNODE_DELETE)
576           bits |= PRSFS_DELETE;
577        if (ap->a_action & KAUTH_VNODE_ADD_SUBDIRECTORY)
578           bits |= PRSFS_INSERT;
579        if (ap->a_action & KAUTH_VNODE_DELETE_CHILD)
580           bits |= PRSFS_DELETE;
581 #if 0 /* I'd argue this should be enforced on the parent. But that's ugly */
582        if (ap->a_action & KAUTH_VNODE_READ_ATTRIBUTES)
583           bits |= PRSFS_LOOKUP;
584        if (ap->a_action & KAUTH_VNODE_READ_SECURITY) /* mode bits/gid, not afs acl */
585           bits |= PRSFS_LOOKUP;
586 #endif
587     } else {
588        if (ap->a_action & KAUTH_VNODE_READ_DATA)
589           bits |= PRSFS_READ;
590        if (ap->a_action & KAUTH_VNODE_WRITE_DATA)
591           bits |= PRSFS_WRITE;
592        if (ap->a_action & KAUTH_VNODE_EXECUTE)
593           bits |= PRSFS_READ; /* and mode bits.... */
594        if (ap->a_action & KAUTH_VNODE_READ_ATTRIBUTES)
595           bits |= PRSFS_LOOKUP;
596        if (ap->a_action & KAUTH_VNODE_READ_SECURITY) /* mode bits/gid, not afs acl */
597           bits |= PRSFS_LOOKUP;
598        if ((ap->a_action & ((1 << 25) - 1)) == KAUTH_VNODE_EXECUTE)
599           /* if only exec, don't check for read mode bit */
600           /* high bits of ap->a_action are not for 'generic rights bits', and
601              so should not be checked (KAUTH_VNODE_ACCESS is often present
602              and needs to be masked off) */
603           cmb |= CMB_ALLOW_EXEC_AS_READ;
604     }
605     if (ap->a_action & KAUTH_VNODE_WRITE_ATTRIBUTES)
606        bits |= PRSFS_WRITE;
607 #if 0 /* no extended attributes */
608     if (ap->a_action & KAUTH_VNODE_READ_EXTATTRIBUTES)
609        bits |= PRSFS_READ;
610     if (ap->a_action & KAUTH_VNODE_WRITE_EXTATTRIBUTES)
611        bits |= PRSFS_WRITE;
612 #endif
613     if (ap->a_action & KAUTH_VNODE_WRITE_SECURITY)
614        bits |= PRSFS_WRITE;
615     /* we can't check for KAUTH_VNODE_TAKE_OWNERSHIP, so we always permit it */
616     
617     code = afs_AccessOK(tvc, bits, &treq, cmb);
618 #if defined(AFS_DARWIN80_ENV)
619     /* In a dropbox, cp on 10.4 behaves badly, looping on EACCES */
620     /* In a dropbox, Finder may reopen the file. Let it. */
621     if (code == 0 && ((bits &~(PRSFS_READ|PRSFS_WRITE)) == 0)) {
622         code = afs_AccessOK(tvc, PRSFS_ADMINISTER|PRSFS_INSERT|bits, &treq, cmb);
623     }
624 #endif
625     if (code == 1 && vnode_vtype(ap->a_vp) == VREG &&
626         ap->a_action & KAUTH_VNODE_EXECUTE &&
627         (tvc->f.m.Mode & 0100) != 0100) {
628         code = 0;
629     }
630     if (code) {
631         code= 0;               /* if access is ok */
632     } else {
633             code = afs_CheckCode(EACCES, &treq, 57);        /* failure code */
634     }
635 out:
636      afs_PutFakeStat(&fakestate);
637 out2:
638     AFS_GUNLOCK();
639     return code;
640 }
641 #else
642 int
643 afs_vop_access(ap)
644      struct VOPPROT(access_args)        /* {
645                                  * struct vnode *a_vp;
646                                  * int  a_mode;
647                                  * struct ucred *a_cred;
648                                  * struct proc *a_p;
649                                  * } */ *ap;
650 {
651     int code;
652     AFS_GLOCK();
653     code = afs_access(VTOAFS(ap->a_vp), ap->a_mode, vop_cred);
654     AFS_GUNLOCK();
655     return code;
656 }
657 #endif
658
659 int
660 afs_vop_getattr(ap)
661      struct VOPPROT(getattr_args)       /* {
662                                  * struct vnode *a_vp;
663                                  * struct vattr *a_vap;
664                                  * struct ucred *a_cred;
665                                  * struct proc *a_p;
666                                  * } */ *ap;
667 {
668     int code;
669
670     AFS_GLOCK();
671     code = afs_getattr(VTOAFS(ap->a_vp), ap->a_vap, vop_cred);
672     /* This is legit; it just forces the fstrace event to happen */
673     code = afs_CheckCode(code, NULL, 58);
674     AFS_GUNLOCK();
675 #ifdef AFS_DARWIN80_ENV
676     VATTR_SET_SUPPORTED(ap->a_vap, va_type);
677     VATTR_SET_SUPPORTED(ap->a_vap, va_mode);
678     VATTR_SET_SUPPORTED(ap->a_vap, va_uid);
679     VATTR_SET_SUPPORTED(ap->a_vap, va_gid);
680     VATTR_SET_SUPPORTED(ap->a_vap, va_fsid);
681     VATTR_SET_SUPPORTED(ap->a_vap, va_fileid);
682     VATTR_SET_SUPPORTED(ap->a_vap, va_nlink);
683     VATTR_SET_SUPPORTED(ap->a_vap, va_data_size);
684     VATTR_SET_SUPPORTED(ap->a_vap, va_access_time);
685     VATTR_SET_SUPPORTED(ap->a_vap, va_modify_time);
686     VATTR_SET_SUPPORTED(ap->a_vap, va_change_time);
687     VATTR_SET_SUPPORTED(ap->a_vap, va_gen);
688     VATTR_SET_SUPPORTED(ap->a_vap, va_flags);
689     VATTR_SET_SUPPORTED(ap->a_vap, va_iosize);
690     VATTR_SET_SUPPORTED(ap->a_vap, va_total_alloc);
691 #endif
692     return code;
693 }
694
695 int
696 afs_vop_setattr(ap)
697      struct VOPPROT(setattr_args)       /* {
698                                  * struct vnode *a_vp;
699                                  * struct vattr *a_vap;
700                                  * struct ucred *a_cred;
701                                  * struct proc *a_p;
702                                  * } */ *ap;
703 {
704     int code;
705     AFS_GLOCK();
706     code = afs_setattr(VTOAFS(ap->a_vp), ap->a_vap, vop_cred);
707     /* This is legit; it just forces the fstrace event to happen */
708     code = afs_CheckCode(code, NULL, 59);
709     AFS_GUNLOCK();
710     return code;
711 }
712
713 int
714 afs_vop_read(ap)
715      struct VOPPROT(read_args)  /* {
716                                  * struct vnode *a_vp;
717                                  * struct uio *a_uio;
718                                  * int a_ioflag;
719                                  * struct ucred *a_cred;
720                                  * } */ *ap;
721 {
722     int code;
723     struct vnode *vp = ap->a_vp;
724     struct vcache *avc = VTOAFS(vp);
725
726     if (vnode_isdir(ap->a_vp)) 
727         return EISDIR;
728 #ifdef AFS_DARWIN80_ENV
729     ubc_msync_range(ap->a_vp, AFS_UIO_OFFSET(ap->a_uio), AFS_UIO_OFFSET(ap->a_uio) + AFS_UIO_RESID(ap->a_uio), UBC_PUSHDIRTY);
730 #else
731     if (UBCINFOEXISTS(ap->a_vp)) {
732         ubc_clean(ap->a_vp, 0);
733     }
734 #endif
735     AFS_GLOCK();
736     osi_FlushPages(avc, vop_cred);      /* hold bozon lock, but not basic vnode lock */
737     code = afs_read(avc, ap->a_uio, vop_cred, 0, 0, 0);
738     AFS_GUNLOCK();
739     return code;
740 }
741
742 int
743 afs_vop_pagein(ap)
744      struct VOPPROT(pagein_args)        /* {
745                                  * struct vnode *a_vp;
746                                  * upl_t a_pl;
747                                  * vm_offset_t a_pl_offset;
748                                  * off_t a_f_offset;
749                                  * size_t a_size;
750                                  * struct ucred *a_cred;
751                                  * int a_flags;
752                                  * } */ *ap;
753 {
754     register struct vnode *vp = ap->a_vp;
755     upl_t pl = ap->a_pl;
756     size_t size = ap->a_size;
757     off_t f_offset = ap->a_f_offset;
758     vm_offset_t pl_offset = ap->a_pl_offset;
759     int flags = ap->a_flags;
760     struct ucred *cred;
761     vm_offset_t ioaddr;
762 #ifdef AFS_DARWIN80_ENV
763     struct uio *uio;
764 #else
765     struct uio auio;
766     struct iovec aiov;
767     struct uio *uio = &auio;
768 #endif
769     int nocommit = flags & UPL_NOCOMMIT;
770
771     int code;
772     struct vcache *tvc = VTOAFS(vp);
773 #ifndef AFS_DARWIN80_ENV
774     if (UBCINVALID(vp)) {
775 #if DIAGNOSTIC
776         panic("afs_vop_pagein: invalid vp");
777 #endif /* DIAGNOSTIC */
778         return (EPERM);
779     }
780
781     UBCINFOCHECK("afs_vop_pagein", vp);
782 #endif
783     if (pl == (upl_t) NULL) {
784         panic("afs_vop_pagein: no upl");
785     }
786
787     cred = ubc_getcred(vp);
788     if (cred == NOCRED)
789         cred = vop_cred;
790
791     if (size == 0) {
792         if (!nocommit)
793             OSI_UPL_ABORT_RANGE(pl, pl_offset, size,
794                                    UPL_ABORT_ERROR | UPL_ABORT_FREE_ON_EMPTY);
795         return (0);
796     }
797     if (f_offset < 0) {
798         if (!nocommit)
799             OSI_UPL_ABORT_RANGE(pl, pl_offset, size,
800                                    UPL_ABORT_ERROR | UPL_ABORT_FREE_ON_EMPTY);
801         return (EINVAL);
802     }
803     if (f_offset & PAGE_MASK)
804         panic("afs_vop_pagein: offset not page aligned");
805
806     OSI_UPL_MAP(pl, &ioaddr);
807     ioaddr += pl_offset;
808 #ifdef AFS_DARWIN80_ENV
809     uio = uio_create(1, f_offset, UIO_SYSSPACE32, UIO_READ);
810     uio_addiov(uio, CAST_USER_ADDR_T(ioaddr), size);
811 #else
812     auio.uio_iov = &aiov;
813     auio.uio_iovcnt = 1;
814     auio.uio_offset = f_offset;
815     auio.uio_segflg = UIO_SYSSPACE;
816     auio.uio_rw = UIO_READ;
817     auio.uio_procp = NULL;
818     auio.uio_resid = aiov.iov_len = size;
819     aiov.iov_base = (caddr_t) ioaddr;
820 #endif
821     AFS_GLOCK();
822     osi_FlushPages(tvc, vop_cred);      /* hold bozon lock, but not basic vnode lock */
823     code = afs_read(tvc, uio, cred, 0, 0, 0);
824     if (code == 0) {
825         ObtainWriteLock(&tvc->lock, 2);
826         tvc->f.states |= CMAPPED;
827         ReleaseWriteLock(&tvc->lock);
828     }
829     AFS_GUNLOCK();
830
831     /* Zero out rest of last page if there wasn't enough data in the file */
832     if (code == 0 && AFS_UIO_RESID(uio) > 0) {
833 #ifdef AFS_DARWIN80_ENV
834         memset(((caddr_t)ioaddr) + (size - AFS_UIO_RESID(uio)), 0,
835                AFS_UIO_RESID(uio));
836 #else
837         memset(aiov.iov_base, 0, auio.uio_resid);
838 #endif
839     }
840
841     OSI_UPL_UNMAP(pl);
842     if (!nocommit) {
843         if (code)
844             OSI_UPL_ABORT_RANGE(pl, pl_offset, size,
845                                    UPL_ABORT_ERROR | UPL_ABORT_FREE_ON_EMPTY);
846         else
847             OSI_UPL_COMMIT_RANGE(pl, pl_offset, size,
848                                     UPL_COMMIT_CLEAR_DIRTY |
849                                     UPL_COMMIT_FREE_ON_EMPTY);
850     }
851 #ifdef AFS_DARWIN80_ENV
852     uio_free(uio);
853 #endif
854     return code;
855 }
856
857 int
858 afs_vop_write(ap)
859      struct VOPPROT(write_args) /* {
860                                  * struct vnode *a_vp;
861                                  * struct uio *a_uio;
862                                  * int a_ioflag;
863                                  * struct ucred *a_cred;
864                                  * } */ *ap;
865 {
866     int code;
867     struct vcache *avc = VTOAFS(ap->a_vp);
868     void *object;
869 #ifdef AFS_DARWIN80_ENV
870     ubc_msync_range(ap->a_vp, AFS_UIO_OFFSET(ap->a_uio), AFS_UIO_OFFSET(ap->a_uio) + AFS_UIO_RESID(ap->a_uio), UBC_INVALIDATE);
871 #else
872     if (UBCINFOEXISTS(ap->a_vp)) {
873         ubc_clean(ap->a_vp, 1);
874     }
875     if (UBCINFOEXISTS(ap->a_vp))
876         osi_VM_NukePages(ap->a_vp, AFS_UIO_OFFSET(ap->a_uio),
877                          AFS_UIO_RESID(ap->a_uio));
878 #endif
879     AFS_GLOCK();
880     osi_FlushPages(avc, vop_cred);      /* hold bozon lock, but not basic vnode lock */
881     code =
882         afs_write(VTOAFS(ap->a_vp), ap->a_uio, ap->a_ioflag, vop_cred, 0);
883     AFS_GUNLOCK();
884     return code;
885 }
886
887 int
888 afs_vop_pageout(ap)
889      struct VOPPROT(pageout_args)       /* {
890                                  * struct vnode *a_vp;
891                                  * upl_t   a_pl,
892                                  * vm_offset_t   a_pl_offset,
893                                  * off_t         a_f_offset,
894                                  * size_t        a_size,
895                                  * struct ucred *a_cred,
896                                  * int           a_flags
897                                  * } */ *ap;
898 {
899     register struct vnode *vp = ap->a_vp;
900     upl_t pl = ap->a_pl;
901     size_t size = ap->a_size;
902     off_t f_offset = ap->a_f_offset;
903     vm_offset_t pl_offset = ap->a_pl_offset;
904     int flags = ap->a_flags;
905     struct ucred *cred;
906     vm_offset_t ioaddr;
907 #ifdef AFS_DARWIN80_ENV
908     struct uio *uio;
909 #else
910     struct uio auio;
911     struct iovec aiov;
912     struct uio *uio = &auio;
913 #endif
914     int nocommit = flags & UPL_NOCOMMIT;
915     int iosize;
916
917     int code;
918     struct vcache *tvc = VTOAFS(vp);
919 #ifndef AFS_DARWIN80_ENV
920     if (UBCINVALID(vp)) {
921 #if DIAGNOSTIC
922         panic("afs_vop_pageout: invalid vp");
923 #endif /* DIAGNOSTIC */
924         return (EPERM);
925     }
926
927     UBCINFOCHECK("afs_vop_pageout", vp);
928 #endif
929     if (pl == (upl_t) NULL) {
930         panic("afs_vop_pageout: no upl");
931     }
932 #if !defined(AFS_DARWIN80_ENV) /* XXX nfs now uses it's own bufs (struct nfsbuf)
933                                   maybe the generic
934                                   layer doesn't have them anymore? In any case,
935                                   we can't just copy code from nfs... */
936     {
937         int lbn, s;
938         struct buf *bp;
939         int biosize = DEV_BSIZE;
940
941         lbn = f_offset / DEV_BSIZE;
942
943         for (iosize = size; iosize > 0; iosize -= biosize, lbn++) {
944
945             s = splbio();
946             if (bp = incore(vp, lbn)) {
947                 if (ISSET(bp->b_flags, B_BUSY))
948                     panic("nfs_pageout: found BUSY buffer incore\n");
949
950                 bremfree(bp);
951                 SET(bp->b_flags, (B_BUSY | B_INVAL));
952                 brelse(bp);
953             }
954             splx(s);
955         }
956     }
957 #endif
958     cred = ubc_getcred(vp);
959     if (cred == NOCRED)
960         cred = vop_cred;
961
962     if (size == 0) {
963         if (!nocommit)
964             OSI_UPL_ABORT_RANGE(pl, pl_offset, size,
965                                    UPL_ABORT_FREE_ON_EMPTY);
966         return (0);
967     }
968     if (flags & (IO_APPEND | IO_SYNC))
969         panic("nfs_pageout: (IO_APPEND | IO_SYNC)");
970     if (f_offset < 0) {
971         if (!nocommit)
972             OSI_UPL_ABORT_RANGE(pl, pl_offset, size,
973                                    UPL_ABORT_FREE_ON_EMPTY);
974         return (EINVAL);
975     }
976     if (f_offset >= tvc->f.m.Length) {
977         if (!nocommit)
978             OSI_UPL_ABORT_RANGE(pl, pl_offset, size,
979                                    UPL_ABORT_FREE_ON_EMPTY);
980         return (EINVAL);
981     }
982
983     if (f_offset & PAGE_MASK)
984         panic("afs_vop_pageout: offset not page aligned");
985
986     /* size will always be a multiple of PAGE_SIZE */
987     /* pageout isn't supposed to extend files */
988     if (f_offset + size > tvc->f.m.Length) 
989         iosize = tvc->f.m.Length - f_offset;
990     else
991         iosize = size;
992
993     if (size > (iosize + (PAGE_SIZE - 1)) & ~PAGE_MASK && !nocommit)  {
994             int iosize_rnd=(iosize + (PAGE_SIZE - 1)) & ~PAGE_MASK;
995             OSI_UPL_ABORT_RANGE(pl, pl_offset + iosize_rnd,
996                                    size - iosize_rnd,
997                                    UPL_ABORT_FREE_ON_EMPTY);
998     }
999     OSI_UPL_MAP(pl, &ioaddr);
1000     ioaddr += pl_offset;
1001 #ifdef AFS_DARWIN80_ENV
1002     uio = uio_create(1, f_offset, UIO_SYSSPACE32, UIO_READ);
1003     uio_addiov(uio, CAST_USER_ADDR_T(ioaddr), size);
1004 #else
1005     auio.uio_iov = &aiov;
1006     auio.uio_iovcnt = 1;
1007     auio.uio_offset = f_offset;
1008     auio.uio_segflg = UIO_SYSSPACE;
1009     auio.uio_rw = UIO_WRITE;
1010     auio.uio_procp = NULL;
1011     auio.uio_resid = aiov.iov_len = iosize;
1012     aiov.iov_base = (caddr_t) ioaddr;
1013 #endif
1014     {
1015         /* USV?
1016          * check for partial page and clear the
1017          * contents past end of the file before
1018          * releasing it in the VM page cache
1019          */
1020         if ((f_offset < tvc->f.m.Length) && (f_offset + size) > tvc->f.m.Length) {
1021             size_t io = tvc->f.m.Length - f_offset;
1022
1023             memset((caddr_t) (ioaddr + pl_offset + io), 0, size - io);
1024         }
1025     }
1026
1027     AFS_GLOCK();
1028     osi_FlushPages(tvc, vop_cred);      /* hold bozon lock, but not basic vnode lock */
1029     ObtainWriteLock(&tvc->lock, 1);
1030     afs_FakeOpen(tvc);
1031     ReleaseWriteLock(&tvc->lock);
1032
1033     code = afs_write(tvc, uio, flags, cred, 0);
1034
1035     ObtainWriteLock(&tvc->lock, 1);
1036     afs_FakeClose(tvc, cred);
1037     ReleaseWriteLock(&tvc->lock);
1038     AFS_GUNLOCK();
1039     OSI_UPL_UNMAP(pl);
1040     if (!nocommit) {
1041         if (code)
1042             OSI_UPL_ABORT_RANGE(pl, pl_offset, size,
1043                                    UPL_ABORT_FREE_ON_EMPTY);
1044         else
1045             OSI_UPL_COMMIT_RANGE(pl, pl_offset, size,
1046                                     UPL_COMMIT_CLEAR_DIRTY |
1047                                     UPL_COMMIT_FREE_ON_EMPTY);
1048     }
1049
1050 #ifdef AFS_DARWIN80_ENV
1051     uio_free(uio);
1052 #endif
1053     return code;
1054 }
1055
1056 int
1057 afs_vop_ioctl(ap)
1058      struct VOPPROT(ioctl_args) /* {
1059                                  * struct vnode *a_vp;
1060                                  * int  a_command;
1061                                  * caddr_t  a_data;
1062                                  * int  a_fflag;
1063                                  * struct ucred *a_cred;
1064                                  * struct proc *a_p;
1065                                  * } */ *ap;
1066 {
1067     struct vcache *tvc = VTOAFS(ap->a_vp);
1068     struct afs_ioctl data;
1069     int error = 0;
1070
1071     /* in case we ever get in here... */
1072
1073     AFS_STATCNT(afs_ioctl);
1074     if (((ap->a_command >> 8) & 0xff) == 'V') {
1075         /* This is a VICEIOCTL call */
1076         AFS_GLOCK();
1077         error = HandleIoctl(tvc, ap->a_command, ap->a_data);
1078         AFS_GUNLOCK();
1079         return (error);
1080     } else {
1081         /* No-op call; just return. */
1082         return (ENOTTY);
1083     }
1084 }
1085
1086 /* ARGSUSED */
1087 int
1088 afs_vop_select(ap)
1089      struct VOPPROT(select_args)        /* {
1090                                  * struct vnode *a_vp;
1091                                  * int  a_which;
1092                                  * int  a_fflags;
1093                                  * struct ucred *a_cred;
1094                                  * struct proc *a_p;
1095                                  * } */ *ap;
1096 {
1097     /*
1098      * We should really check to see if I/O is possible.
1099      */
1100     return (1);
1101 }
1102
1103 /*
1104  * Mmap a file
1105  *
1106  * NB Currently unsupported.
1107  */
1108 /* ARGSUSED */
1109 int
1110 afs_vop_mmap(ap)
1111      struct VOPPROT(mmap_args)  /* {
1112                                  * struct vnode *a_vp;
1113                                  * int  a_fflags;
1114                                  * struct ucred *a_cred;
1115                                  * struct proc *a_p;
1116                                  * } */ *ap;
1117 {
1118     return (EINVAL);
1119 }
1120
1121 int
1122 afs_vop_fsync(ap)
1123      struct VOPPROT(fsync_args) /* {
1124                                  * struct vnode *a_vp;
1125                                  * struct ucred *a_cred;
1126                                  * int a_waitfor;
1127                                  * struct proc *a_p;
1128                                  * } */ *ap;
1129 {
1130     int wait = ap->a_waitfor == MNT_WAIT;
1131     int error;
1132     register struct vnode *vp = ap->a_vp;
1133     int haveGlock = ISAFS_GLOCK();
1134
1135     /* afs_vop_lookup glocks, can call us through vinvalbuf from GetVCache */
1136     if (!haveGlock) AFS_GLOCK();
1137     if (vop_cred)
1138         error = afs_fsync(VTOAFS(vp), vop_cred);
1139     else
1140         error = afs_fsync(VTOAFS(vp), &afs_osi_cred);
1141     if (!haveGlock) AFS_GUNLOCK();
1142     return error;
1143 }
1144
1145 #ifndef AFS_DARWIN80_ENV
1146 int
1147 afs_vop_seek(ap)
1148      struct VOPPROT(seek_args)  /* {
1149                                  * struct vnode *a_vp;
1150                                  * off_t  a_oldoff;
1151                                  * off_t  a_newoff;
1152                                  * struct ucred *a_cred;
1153                                  * } */ *ap;
1154 {
1155     if (ap->a_newoff > ULONG_MAX)       /* AFS doesn't support 64-bit offsets */
1156         return EINVAL;
1157     return (0);
1158 }
1159 #endif
1160
1161 int
1162 afs_vop_remove(ap)
1163      struct VOPPROT(remove_args)        /* {
1164                                  * struct vnode *a_dvp;
1165                                  * struct vnode *a_vp;
1166                                  * struct componentname *a_cnp;
1167                                  * } */ *ap;
1168 {
1169     int error = 0;
1170     register struct vnode *vp = ap->a_vp;
1171     register struct vnode *dvp = ap->a_dvp;
1172
1173 #ifdef AFS_DARWIN80_ENV
1174     if (ap->a_flags & VNODE_REMOVE_NODELETEBUSY) {
1175             /* Caller requested Carbon delete semantics */
1176             if (vnode_isinuse(vp, 0)) {
1177                     return EBUSY;
1178             }
1179     }
1180 #endif
1181
1182     GETNAME();
1183     AFS_GLOCK();
1184     error = afs_remove(VTOAFS(dvp), name, vop_cn_cred);
1185     error = afs_CheckCode(error, NULL, 61);
1186     AFS_GUNLOCK();
1187     cache_purge(vp);
1188     if (!error) {
1189 #ifdef AFS_DARWIN80_ENV
1190         struct vcache *tvc = VTOAFS(vp);
1191         
1192         if (!(tvc->f.states & CUnlinked)) {
1193             ubc_setsize(vp, (off_t)0);
1194             vnode_recycle(vp);
1195         }
1196 #else
1197         /* necessary so we don't deadlock ourselves in vclean */
1198         VOP_UNLOCK(vp, 0, cnp->cn_proc);
1199
1200         /* If crashes continue in ubc_hold, comment this out */
1201         (void)ubc_uncache(vp);
1202 #endif
1203     } else {
1204         /* should check for PRSFS_INSERT and not PRSFS_DELETE, but the
1205            goal here is to deal with Finder's unhappiness with resource
1206            forks that have no resources in a dropbox setting */
1207         if (name[0] == '.' && name[1] == '_' && error == EACCES) 
1208             error = 0;
1209     }
1210
1211 #ifndef AFS_DARWIN80_ENV
1212     vput(dvp);
1213     if (dvp == vp)
1214         vrele(vp);
1215     else
1216         vput(vp);
1217 #endif
1218
1219 #ifndef AFS_DARWIN80_ENV
1220     FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
1221 #endif
1222     DROPNAME();
1223     return error;
1224 }
1225
1226 int
1227 afs_vop_link(ap)
1228      struct VOPPROT(link_args)  /* {
1229                                  * struct vnode *a_vp;
1230                                  * struct vnode *a_tdvp;
1231                                  * struct componentname *a_cnp;
1232                                  * } */ *ap;
1233 {
1234     int error = 0;
1235     register struct vnode *dvp = ap->a_tdvp;
1236     register struct vnode *vp = ap->a_vp;
1237     struct proc *p;
1238
1239     GETNAME();
1240     p = vop_cn_proc;
1241     if (vnode_isdir(vp)) {
1242         VOP_ABORTOP(vp, cnp);
1243         error = EISDIR;
1244         goto out;
1245     }
1246 #ifndef AFS_DARWIN80_ENV
1247     if (error = vn_lock(vp, LK_EXCLUSIVE, p)) {
1248         VOP_ABORTOP(dvp, cnp);
1249         goto out;
1250     }
1251 #endif
1252     AFS_GLOCK();
1253     error = afs_link(VTOAFS(vp), VTOAFS(dvp), name, vop_cn_cred);
1254     AFS_GUNLOCK();
1255 #ifndef AFS_DARWIN80_ENV
1256     FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
1257 #endif
1258 #ifndef AFS_DARWIN80_ENV
1259     if (dvp != vp)
1260         VOP_UNLOCK(vp, 0, p);
1261 #endif
1262   out:
1263 #ifndef AFS_DARWIN80_ENV
1264     vput(dvp);
1265 #endif
1266     DROPNAME();
1267     return error;
1268 }
1269
1270 int
1271 afs_vop_rename(ap)
1272      struct VOPPROT(rename_args)        /* {
1273                                  * struct vnode *a_fdvp;
1274                                  * struct vnode *a_fvp;
1275                                  * struct componentname *a_fcnp;
1276                                  * struct vnode *a_tdvp;
1277                                  * struct vnode *a_tvp;
1278                                  * struct componentname *a_tcnp;
1279                                  * } */ *ap;
1280 {
1281     int error = 0;
1282     struct componentname *fcnp = ap->a_fcnp;
1283     char *fname;
1284     struct componentname *tcnp = ap->a_tcnp;
1285     char *tname;
1286     struct vnode *tvp = ap->a_tvp;
1287     register struct vnode *tdvp = ap->a_tdvp;
1288     struct vnode *fvp = ap->a_fvp;
1289     register struct vnode *fdvp = ap->a_fdvp;
1290     struct proc *p; 
1291
1292     p = cn_proc(fcnp);
1293
1294 #ifdef AFS_DARWIN80_ENV
1295 /* generic code tests for v_mount equality, so we don't have to, but we don't
1296    get the multiple-mount "benefits" of the old behavior
1297 */
1298 #else
1299     /* Check for cross-device rename.
1300      * For AFS, this means anything not in AFS-space
1301      */
1302     if ((0 != strcmp(tdvp->v_mount->mnt_stat.f_fstypename, "afs")) ||
1303         (tvp && (0 != strcmp(tvp->v_mount->mnt_stat.f_fstypename, "afs")))) {
1304         error = EXDEV;
1305         goto abortit;
1306     }
1307 #endif
1308
1309 #ifdef AFS_DARWIN80_ENV
1310    /* the generic code doesn't do this, so we really should, but all the
1311       vrele's are wrong... */
1312 #else
1313     /*
1314      * if fvp == tvp, we're just removing one name of a pair of
1315      * directory entries for the same element.  convert call into rename.
1316      ( (pinched from NetBSD 1.0's ufs_rename())
1317      */
1318     if (fvp == tvp) {
1319         if (vnode_isdir(fvp)) {
1320             error = EINVAL;
1321           abortit:
1322             VOP_ABORTOP(tdvp, tcnp);    /* XXX, why not in NFS? */
1323             if (tdvp == tvp)
1324                 vrele(tdvp);
1325             else
1326                 vput(tdvp);
1327             if (tvp)
1328                 vput(tvp);
1329             VOP_ABORTOP(fdvp, fcnp);    /* XXX, why not in NFS? */
1330             vrele(fdvp);
1331             vrele(fvp);
1332             return (error);
1333         }
1334
1335         /* Release destination completely. */
1336         VOP_ABORTOP(tdvp, tcnp);
1337         vput(tdvp);
1338         vput(tvp);
1339         /* Delete source. */
1340 #if defined(AFS_DARWIN80_ENV) 
1341
1342         MALLOC(fname, char *, fcnp->cn_namelen + 1, M_TEMP, M_WAITOK);
1343         memcpy(fname, fcnp->cn_nameptr, fcnp->cn_namelen);
1344         fname[fcnp->cn_namelen] = '\0';
1345         AFS_GLOCK();
1346         error = afs_remove(VTOAFS(fdvp), fname, vop_cn_cred);
1347         AFS_GUNLOCK();
1348         FREE(fname, M_TEMP);
1349         cache_purge(fvp);
1350 #else
1351         vrele(fdvp);
1352         vrele(fvp);
1353         fcnp->cn_flags &= ~MODMASK;
1354         fcnp->cn_flags |= LOCKPARENT | LOCKLEAF;
1355         if ((fcnp->cn_flags & SAVESTART) == 0)
1356             panic("afs_rename: lost from startdir");
1357         fcnp->cn_nameiop = DELETE;
1358
1359         VREF(fdvp); 
1360         error=relookup(fdvp, &fvp, fcnp);
1361         if (error == 0)
1362             vrele(fdvp);
1363         if (fvp == NULL) {
1364             return (ENOENT);
1365         }
1366         error=VOP_REMOVE(fdvp, fvp, fcnp);
1367 #endif
1368         
1369         if (fdvp == fvp)
1370             vrele(fdvp);
1371         else
1372             vput(fdvp);
1373         vput(fvp);
1374         return (error);
1375     }
1376 #endif
1377 #if !defined(AFS_DARWIN80_ENV) 
1378     if (error = vn_lock(fvp, LK_EXCLUSIVE, p))
1379         goto abortit;
1380 #endif
1381
1382     MALLOC(fname, char *, fcnp->cn_namelen + 1, M_TEMP, M_WAITOK);
1383     memcpy(fname, fcnp->cn_nameptr, fcnp->cn_namelen);
1384     fname[fcnp->cn_namelen] = '\0';
1385     MALLOC(tname, char *, tcnp->cn_namelen + 1, M_TEMP, M_WAITOK);
1386     memcpy(tname, tcnp->cn_nameptr, tcnp->cn_namelen);
1387     tname[tcnp->cn_namelen] = '\0';
1388
1389
1390     AFS_GLOCK();
1391     /* XXX use "from" or "to" creds? NFS uses "to" creds */
1392     error =
1393         afs_rename(VTOAFS(fdvp), fname, VTOAFS(tdvp), tname, cn_cred(tcnp));
1394     AFS_GUNLOCK();
1395
1396 #if !defined(AFS_DARWIN80_ENV) 
1397     VOP_UNLOCK(fvp, 0, p);
1398 #endif
1399 #ifdef notdef
1400     if (error == EXDEV) {
1401         /* The idea would be to have a userspace handler like afsdb to
1402          * run mv as the user, thus:
1403          */
1404         printf("su %d -c /bin/mv /afs/.:mount/%d:%d:%d:%d/%s /afs/.:mount/%d:%d:%d:%d/%s\n",
1405                afs_cr_uid(cn_cred(tcnp)), fvc->f.fid.Cell, fvc->f.fid.Fid.Volume,
1406                fvc->f.fid.Fid.Vnode, fvc->f.fid.Fid.Unique, fname, 
1407                tvc->f.fid.Cell, tvc->f.fid.Fid.Volume, tvc->f.fid.Fid.Vnode, 
1408                tvc->f.fid.Fid.Unique, tname);
1409     }
1410 #endif
1411 #ifdef AFS_DARWIN80_ENV
1412     cache_purge(fdvp);
1413     cache_purge(fvp);
1414     cache_purge(tdvp);
1415     if (tvp) {
1416        cache_purge(tvp);
1417        if (!error) {
1418           vnode_recycle(tvp);
1419        }
1420     }
1421     if (!error)
1422        cache_enter(tdvp, fvp, tcnp);
1423 #else
1424     if (error)
1425         goto abortit;           /* XXX */
1426     if (tdvp == tvp)
1427         vrele(tdvp);
1428     else
1429         vput(tdvp);
1430     if (tvp)
1431         vput(tvp);
1432     vrele(fdvp);
1433     vrele(fvp);
1434 #endif
1435     FREE(fname, M_TEMP);
1436     FREE(tname, M_TEMP);
1437     return error;
1438 }
1439
1440 int
1441 afs_vop_mkdir(ap)
1442      struct VOPPROT(mkdir_args) /* {
1443                                  * struct vnode *a_dvp;
1444                                  * struct vnode **a_vpp;
1445                                  * struct componentname *a_cnp;
1446                                  * struct vattr *a_vap;
1447                                  * } */ *ap;
1448 {
1449     register struct vnode *dvp = ap->a_dvp;
1450     register struct vattr *vap = ap->a_vap;
1451     int error = 0;
1452     struct vcache *vcp;
1453     struct proc *p;
1454
1455     GETNAME();
1456     p = vop_cn_proc;
1457 #if defined(DIAGNOSTIC) && !defined(AFS_DARWIN80_ENV)
1458     if ((cnp->cn_flags & HASBUF) == 0)
1459         panic("afs_vop_mkdir: no name");
1460 #endif
1461     AFS_GLOCK();
1462     error = afs_mkdir(VTOAFS(dvp), name, vap, &vcp, vop_cn_cred);
1463     AFS_GUNLOCK();
1464     if (error) {
1465 #ifndef AFS_DARWIN80_ENV
1466         VOP_ABORTOP(dvp, cnp);
1467         vput(dvp);
1468 #endif
1469         DROPNAME();
1470         return (error);
1471     }
1472     if (vcp) {
1473 #ifdef AFS_DARWIN80_ENV
1474         afs_darwin_finalizevnode(vcp, ap->a_dvp, ap->a_cnp, 0, 0);
1475 #endif
1476         *ap->a_vpp = AFSTOV(vcp);
1477 #ifndef AFS_DARWIN80_ENV /* XXX needed for multi-mount thing, but can't have it yet */
1478         (*ap->a_vpp)->v_vfsp = dvp->v_vfsp;
1479         vn_lock(*ap->a_vpp, LK_EXCLUSIVE | LK_RETRY, p);
1480 #endif
1481     } else
1482         *ap->a_vpp = 0;
1483     DROPNAME();
1484 #ifndef AFS_DARWIN80_ENV
1485     FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
1486     vput(dvp);
1487 #endif
1488     return error;
1489 }
1490
1491 int
1492 afs_vop_rmdir(ap)
1493      struct VOPPROT(rmdir_args) /* {
1494                                  * struct vnode *a_dvp;
1495                                  * struct vnode *a_vp;
1496                                  * struct componentname *a_cnp;
1497                                  * } */ *ap;
1498 {
1499     int error = 0;
1500     register struct vnode *vp = ap->a_vp;
1501     register struct vnode *dvp = ap->a_dvp;
1502
1503     GETNAME();
1504     if (dvp == vp) {
1505 #ifndef AFS_DARWIN80_ENV
1506         vrele(dvp);
1507         vput(vp);
1508         FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
1509 #endif
1510         DROPNAME();
1511         return (EINVAL);
1512     }
1513
1514     AFS_GLOCK();
1515     error = afs_rmdir(VTOAFS(dvp), name, vop_cn_cred);
1516     AFS_GUNLOCK();
1517     DROPNAME();
1518     cache_purge(dvp);
1519     cache_purge(vp);
1520 #ifndef AFS_DARWIN80_ENV
1521     vput(dvp);
1522     vput(vp);
1523 #endif
1524     return error;
1525 }
1526
1527 int
1528 afs_vop_symlink(ap)
1529      struct VOPPROT(symlink_args)       /* {
1530                                  * struct vnode *a_dvp;
1531                                  * struct vnode **a_vpp;
1532                                  * struct componentname *a_cnp;
1533                                  * struct vattr *a_vap;
1534                                  * char *a_target;
1535                                  * } */ *ap;
1536 {
1537     register struct vnode *dvp = ap->a_dvp;
1538     int error = 0;
1539     /* NFS ignores a_vpp; so do we. */
1540
1541     GETNAME();
1542     AFS_GLOCK();
1543     error =
1544         afs_symlink(VTOAFS(dvp), name, ap->a_vap, ap->a_target, vop_cn_cred);
1545     AFS_GUNLOCK();
1546     DROPNAME();
1547 #ifndef AFS_DARWIN80_ENV
1548     FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
1549     vput(dvp);
1550 #endif
1551     return error;
1552 }
1553
1554 int
1555 afs_vop_readdir(ap)
1556      struct VOPPROT(readdir_args)       /* {
1557                                  * struct vnode *a_vp;
1558                                  * struct uio *a_uio;
1559                                  * struct ucred *a_cred;
1560                                  * int *a_eofflag;
1561                                  * u_long *a_cookies;
1562                                  * int ncookies;
1563                                  * } */ *ap;
1564 {
1565     int error;
1566     off_t off;
1567 /*    printf("readdir %x cookies %x ncookies %d\n", ap->a_vp, ap->a_cookies,
1568            ap->a_ncookies); */
1569 #ifdef AFS_DARWIN80_ENV
1570     /* too much work for now */
1571     /* should only break nfs exports */
1572     if (ap->a_flags & (VNODE_READDIR_EXTENDED | VNODE_READDIR_REQSEEKOFF))
1573          return (EINVAL);
1574 #endif
1575     off = AFS_UIO_OFFSET(ap->a_uio);
1576     AFS_GLOCK();
1577     error =
1578         afs_readdir(VTOAFS(ap->a_vp), ap->a_uio, vop_cred, ap->a_eofflag);
1579     AFS_GUNLOCK();
1580 #ifndef AFS_DARWIN80_ENV
1581     if (!error && ap->a_ncookies != NULL) {
1582         struct uio *uio = ap->a_uio;
1583         const struct dirent *dp, *dp_start, *dp_end;
1584         int ncookies;
1585         u_long *cookies, *cookiep;
1586
1587         if (uio->uio_segflg != UIO_SYSSPACE || uio->uio_iovcnt != 1)
1588             panic("afs_readdir: burned cookies");
1589         dp = (const struct dirent *)
1590             ((const char *)uio->uio_iov->iov_base - (uio->uio_offset - off));
1591
1592         dp_end = (const struct dirent *)uio->uio_iov->iov_base;
1593         for (dp_start = dp, ncookies = 0; dp < dp_end;
1594              dp = (const struct dirent *)((const char *)dp + dp->d_reclen))
1595             ncookies++;
1596
1597         MALLOC(cookies, u_long *, ncookies * sizeof(u_long), M_TEMP,
1598                M_WAITOK);
1599         for (dp = dp_start, cookiep = cookies; dp < dp_end;
1600              dp = (const struct dirent *)((const char *)dp + dp->d_reclen)) {
1601             off += dp->d_reclen;
1602             *cookiep++ = off;
1603         }
1604         *ap->a_cookies = cookies;
1605         *ap->a_ncookies = ncookies;
1606     }
1607 #endif
1608
1609     return error;
1610 }
1611
1612 int
1613 afs_vop_readlink(ap)
1614      struct VOPPROT(readlink_args)      /* {
1615                                  * struct vnode *a_vp;
1616                                  * struct uio *a_uio;
1617                                  * struct ucred *a_cred;
1618                                  * } */ *ap;
1619 {
1620     int error;
1621 /*    printf("readlink %x\n", ap->a_vp);*/
1622     AFS_GLOCK();
1623     error = afs_readlink(VTOAFS(ap->a_vp), ap->a_uio, vop_cred);
1624     AFS_GUNLOCK();
1625     return error;
1626 }
1627
1628 extern int prtactive;
1629
1630 int
1631 afs_vop_inactive(ap)
1632      struct VOPPROT(inactive_args)      /* {
1633                                  * struct vnode *a_vp;
1634                                  * struct proc *a_p;
1635                                  * } */ *ap;
1636 {
1637     register struct vnode *vp = ap->a_vp;
1638     struct vcache *tvc = VTOAFS(vp);
1639 #ifndef AFS_DARWIN80_ENV
1640     if (prtactive && vp->v_usecount != 0)
1641         vprint("afs_vop_inactive(): pushing active", vp);
1642 #endif
1643     if (tvc) {
1644 #ifdef AFS_DARWIN80_ENV
1645         int unlinked = tvc->f.states & CUnlinked;
1646 #endif
1647         AFS_GLOCK();
1648         afs_InactiveVCache(tvc, 0);     /* decrs ref counts */
1649         AFS_GUNLOCK();
1650 #ifdef AFS_DARWIN80_ENV
1651         if (unlinked) {
1652             vnode_recycle(vp);
1653             cache_purge(vp);
1654         }
1655 #endif
1656     }
1657 #ifndef AFS_DARWIN80_ENV
1658     VOP_UNLOCK(vp, 0, ap->a_p);
1659 #endif
1660     return 0;
1661 }
1662
1663 int
1664 afs_vop_reclaim(ap)
1665      struct VOPPROT(reclaim_args)       /* {
1666                                  * struct vnode *a_vp;
1667                                  * } */ *ap;
1668 {
1669     int error = 0;
1670     int sl, writelocked;
1671     register struct vnode *vp = ap->a_vp;
1672     struct vcache *tvc = VTOAFS(vp);
1673
1674     osi_Assert(!ISAFS_GLOCK());
1675     cache_purge(vp);            /* just in case... */
1676     if (tvc) {
1677        AFS_GLOCK();
1678        writelocked = (0 == NBObtainWriteLock(&afs_xvcache, 335));
1679        if (!writelocked) {
1680            ObtainWriteLock(&afs_xvreclaim, 176);
1681 #ifdef AFS_DARWIN80_ENV
1682            vnode_clearfsnode(AFSTOV(tvc));
1683            vnode_removefsref(AFSTOV(tvc));
1684 #else
1685            tvc->v->v_data = NULL;  /* remove from vnode */
1686 #endif
1687            AFSTOV(tvc) = NULL;             /* also drop the ptr to vnode */
1688            tvc->f.states |= CVInit; /* also CDeadVnode? */
1689            tvc->nextfree = ReclaimedVCList;
1690            ReclaimedVCList = tvc;
1691            ReleaseWriteLock(&afs_xvreclaim);
1692        } else {
1693            error = afs_FlushVCache(tvc, &sl);   /* toss our stuff from vnode */
1694            if (tvc->f.states & (CVInit
1695 #ifdef AFS_DARWIN80_ENV
1696                               | CDeadVnode
1697 #endif
1698                    )) {
1699                tvc->f.states &= ~(CVInit
1700 #ifdef AFS_DARWIN80_ENV
1701                                 | CDeadVnode
1702 #endif
1703                    );
1704                afs_osi_Wakeup(&tvc->f.states);
1705            }
1706            if (!error && vnode_fsnode(vp))
1707                panic("afs_reclaim: vnode not cleaned");
1708            if (!error && (tvc->v != NULL)) 
1709                panic("afs_reclaim: vcache not cleaned");
1710            ReleaseWriteLock(&afs_xvcache);
1711        }
1712        AFS_GUNLOCK();
1713     }
1714     return error;
1715 }
1716
1717 /*
1718  * Return POSIX pathconf information applicable to ufs filesystems.
1719  */
1720 afs_vop_pathconf(ap)
1721      struct VOPPROT(pathconf_args)      /* {
1722                                  * struct vnode *a_vp;
1723                                  * int a_name;
1724                                  * int *a_retval;
1725                                  * } */ *ap;
1726 {
1727     AFS_STATCNT(afs_cntl);
1728     switch (ap->a_name) {
1729     case _PC_LINK_MAX:
1730         *ap->a_retval = LINK_MAX;
1731         break;
1732     case _PC_NAME_MAX:
1733         *ap->a_retval = NAME_MAX;
1734         break;
1735     case _PC_PATH_MAX:
1736         *ap->a_retval = PATH_MAX;
1737         break;
1738     case _PC_CHOWN_RESTRICTED:
1739         *ap->a_retval = 1;
1740         break;
1741     case _PC_NO_TRUNC:
1742         *ap->a_retval = 1;
1743         break;
1744     case _PC_PIPE_BUF:
1745         return EINVAL;
1746         break;
1747     case _PC_NAME_CHARS_MAX:
1748         *ap->a_retval = NAME_MAX;
1749         break;
1750     case _PC_CASE_SENSITIVE:
1751         *ap->a_retval = 1;
1752         break;
1753     case _PC_CASE_PRESERVING:
1754         *ap->a_retval = 1;
1755         break;
1756     default:
1757         return EINVAL;
1758     }
1759     return 0;
1760 }
1761
1762 /*
1763  * Advisory record locking support (fcntl() POSIX style)
1764  */
1765 int
1766 afs_vop_advlock(ap)
1767      struct VOPPROT(advlock_args)       /* {
1768                                  * struct vnode *a_vp;
1769                                  * caddr_t  a_id;
1770                                  * int  a_op;
1771                                  * struct flock *a_fl;
1772                                  * int  a_flags;
1773                                  * } */ *ap;
1774 {
1775     int error;
1776     struct ucred *tcr;
1777     int clid;
1778     int op;
1779 #ifdef AFS_DARWIN80_ENV
1780     proc_t p;
1781     tcr=vop_cred;
1782 #else
1783     struct proc *p = current_proc();
1784     struct ucred cr;
1785     pcred_readlock(p);
1786     cr = *p->p_cred->pc_ucred;
1787     pcred_unlock(p);
1788     tcr=&cr;
1789 #endif
1790     if (ap->a_flags & F_POSIX) {
1791 #ifdef AFS_DARWIN80_ENV
1792         p = (proc_t) ap->a_id;
1793         clid = proc_pid(p);
1794 #else
1795         p = (struct proc *) ap->a_id;
1796         clid = p->p_pid;
1797 #endif
1798     } else {
1799         clid = (int)ap->a_id;
1800     }
1801     if (ap->a_op == F_UNLCK) {
1802         op = F_SETLK;
1803     } else if (ap->a_op == F_SETLK && ap->a_flags & F_WAIT) {
1804         op = F_SETLKW;
1805     } else {
1806         op = ap->a_op;
1807     }
1808     AFS_GLOCK();
1809     error = afs_lockctl(VTOAFS(ap->a_vp), ap->a_fl, op, tcr, clid);
1810     AFS_GUNLOCK();
1811     return error;
1812 }
1813
1814 int
1815 afs_vop_blktooff(ap)
1816      struct VOPPROT(blktooff_args)      /* {
1817                                  * struct vnode *a_vp;
1818                                  * daddr_t a_lblkno;
1819                                  * off_t *a_offset;    
1820                                  * } */ *ap;
1821 {
1822     *ap->a_offset = (off_t) (ap->a_lblkno * DEV_BSIZE);
1823     return 0;
1824 }
1825
1826 int
1827 afs_vop_offtoblk(ap)
1828      struct VOPPROT(offtoblk_args)      /* {
1829                                  * struct vnode *a_vp;
1830                                  * off_t a_offset;    
1831                                  * daddr_t *a_lblkno;
1832                                  * } */ *ap;
1833 {
1834     *ap->a_lblkno = (daddr_t) (ap->a_offset / DEV_BSIZE);
1835
1836     return (0);
1837 }
1838
1839 #ifndef AFS_DARWIN80_ENV
1840 int
1841 afs_vop_lock(ap)
1842      struct VOPPROT(lock_args)  /* {
1843                                  * struct vnode *a_vp;
1844                                  * } */ *ap;
1845 {
1846     register struct vnode *vp = ap->a_vp;
1847     register struct vcache *avc = VTOAFS(vp);
1848
1849     if (vp->v_tag == VT_NON)
1850         return (ENOENT);
1851
1852     return (lockmgr(&avc->rwlock, ap->a_flags, &vp->v_interlock, ap->a_p));
1853 }
1854
1855 int
1856 afs_vop_unlock(ap)
1857      struct VOPPROT(unlock_args)        /* {
1858                                  * struct vnode *a_vp;
1859                                  * } */ *ap;
1860 {
1861     struct vnode *vp = ap->a_vp;
1862     struct vcache *avc = VTOAFS(vp);
1863
1864     return (lockmgr
1865             (&avc->rwlock, ap->a_flags | LK_RELEASE, &vp->v_interlock,
1866              ap->a_p));
1867
1868 }
1869
1870 int
1871 afs_vop_truncate(ap)
1872      struct VOPPROT(truncate_args)      /* {
1873                                  * struct vnode *a_vp;
1874                                  * off_t a_length;
1875                                  * int a_flags;
1876                                  * struct ucred *a_cred;
1877                                  * struct proc *a_p;
1878                                  * } */ *ap;
1879 {
1880     printf("stray afs_vop_truncate\n");
1881     return EOPNOTSUPP;
1882 }
1883
1884 int
1885 afs_vop_update(ap)
1886      struct VOPPROT(update_args)        /* {
1887                                  * struct vnode *a_vp;
1888                                  * struct timeval *a_access;
1889                                  * struct timeval *a_modify;
1890                                  * int a_waitfor;
1891                                  * } */ *ap;
1892 {
1893     printf("stray afs_vop_update\n");
1894     return EOPNOTSUPP;
1895 }
1896
1897 int
1898 afs_vop_bmap(ap)
1899      struct VOPPROT(bmap_args)  /* {
1900                                  * struct vnode *a_vp;
1901                                  * daddr_t  a_bn;
1902                                  * struct vnode **a_vpp;
1903                                  * daddr_t *a_bnp;
1904                                  * int *a_runp;
1905                                  * int *a_runb;
1906                                  * } */ *ap;
1907 {
1908     int error;
1909     if (ap->a_bnp) {
1910         *ap->a_bnp = ap->a_bn * (PAGE_SIZE / DEV_BSIZE);
1911     }
1912     if (ap->a_vpp) {
1913         *ap->a_vpp = ap->a_vp;
1914     }
1915     if (ap->a_runp != NULL)
1916         *ap->a_runp = 0;
1917 #ifdef notyet
1918     if (ap->a_runb != NULL)
1919         *ap->a_runb = 0;
1920 #endif
1921
1922     return 0;
1923 }
1924
1925 int
1926 afs_vop_strategy(ap)
1927      struct VOPPROT(strategy_args)      /* {
1928                                  * struct buf *a_bp;
1929                                  * } */ *ap;
1930 {
1931     int error;
1932     AFS_GLOCK();
1933     error = afs_ustrategy(ap->a_bp);
1934     AFS_GUNLOCK();
1935     return error;
1936 }
1937
1938 int
1939 afs_vop_print(ap)
1940      struct VOPPROT(print_args) /* {
1941                                  * struct vnode *a_vp;
1942                                  * } */ *ap;
1943 {
1944     register struct vnode *vp = ap->a_vp;
1945     register struct vcache *vc = VTOAFS(ap->a_vp);
1946     int s = vc->f.states;
1947     printf("tag %d, fid: %ld.%x.%x.%x, opens %d, writers %d", vp->v_tag,
1948            vc->f.fid.Cell, vc->f.fid.Fid.Volume, vc->f.fid.Fid.Vnode,
1949            vc->f.fid.Fid.Unique, vc->opens, vc->execsOrWriters);
1950     printf("\n  states%s%s%s%s%s", (s & CStatd) ? " statd" : "",
1951            (s & CRO) ? " readonly" : "", (s & CDirty) ? " dirty" : "",
1952            (s & CMAPPED) ? " mapped" : "",
1953            (s & CVFlushed) ? " flush in progress" : "");
1954     if (UBCISVALID(vp)) {
1955         printf("\n  UBC: ");
1956         if (UBCINFOEXISTS(vp)) {
1957             printf("exists, ");
1958             printf("refs %d%s%s", vp->v_ubcinfo->ui_refcount,
1959                    ubc_issetflags(vp, UI_HASOBJREF) ? " HASOBJREF" : "",
1960                    ubc_issetflags(vp, UI_WASMAPPED) ? " WASMAPPED" : "");
1961         } else
1962             printf("does not exist");
1963     }
1964     printf("\n");
1965     return 0;
1966 }
1967
1968 int
1969 afs_vop_islocked(ap)
1970      struct VOPPROT(islocked_args)      /* {
1971                                  * struct vnode *a_vp;
1972                                  * } */ *ap;
1973 {
1974     struct vcache *vc = VTOAFS(ap->a_vp);
1975     return lockstatus(&vc->rwlock);
1976 }
1977
1978 int
1979 afs_vop_cmap(ap)
1980      struct VOPPROT(cmap_args)  /* {
1981                                  * struct vnode *a_vp;
1982                                  * off_t a_foffset;    
1983                                  * size_t a_size;
1984                                  * daddr_t *a_bpn;
1985                                  * size_t *a_run;
1986                                  * void *a_poff;
1987                                  * } */ *ap;
1988 {
1989     *ap->a_bpn = (daddr_t) (ap->a_foffset / DEV_BSIZE);
1990     *ap->a_run = MAX(ap->a_size, AFS_CHUNKSIZE(ap->a_foffset));
1991     return 0;
1992 }
1993 #endif
1994
1995 int
1996 afs_darwin_getnewvnode(struct vcache *avc, int recycle)
1997 {
1998 #ifdef AFS_DARWIN80_ENV
1999     vnode_t vp;
2000     int error, dead;
2001     struct vnode_fsparam par;
2002
2003     memset(&par, 0, sizeof(struct vnode_fsparam));
2004     par.vnfs_vtype = VNON;
2005     par.vnfs_vops = afs_dead_vnodeop_p;
2006     par.vnfs_flags = VNFS_NOCACHE|VNFS_CANTCACHE;
2007     par.vnfs_mp = afs_globalVFS;
2008     par.vnfs_fsnode = avc;
2009
2010     error = vnode_create(VNCREATE_FLAVOR, VCREATESIZE, &par, &vp);
2011     if (!error) {
2012       vnode_addfsref(vp);
2013       vnode_ref(vp);
2014       avc->v = vp;
2015       if (recycle)
2016           vnode_recycle(vp); /* terminate as soon as iocount drops */
2017       avc->f.states |= CDeadVnode;
2018     }
2019     return error;
2020 #else
2021     while (getnewvnode(VT_AFS, afs_globalVFS, afs_vnodeop_p, &avc->v)) {
2022         /* no vnodes available, force an alloc (limits be damned)! */
2023         printf("failed to get vnode\n");
2024     }
2025     avc->v->v_data = (void *)avc;
2026     return 0;
2027 #endif
2028 }
2029 #ifdef AFS_DARWIN80_ENV
2030 /* if this fails, then tvc has been unrefed and may have been freed. 
2031    Don't touch! */
2032 int 
2033 afs_darwin_finalizevnode(struct vcache *avc, struct vnode *dvp, struct componentname *cnp, int isroot, int locked)
2034 {
2035     vnode_t ovp;
2036     vnode_t nvp;
2037     int error;
2038     struct vnode_fsparam par;
2039     if (!locked) {
2040         AFS_GLOCK();
2041         ObtainWriteLock(&avc->lock,325);
2042     }
2043     ovp = AFSTOV(avc);
2044     if (!(avc->f.states & CDeadVnode) && vnode_vtype(ovp) != VNON) {
2045         AFS_GUNLOCK();
2046 #if 0 /* unsupported */
2047         if (dvp && cnp)
2048             vnode_update_identity(ovp, dvp, cnp->cn_nameptr, cnp->cn_namelen,
2049                                   cnp->cn_hash,
2050                                   VNODE_UPDATE_PARENT|VNODE_UPDATE_NAME);
2051 #endif
2052         /* Can end up in reclaim... drop GLOCK */
2053         vnode_rele(ovp);
2054         AFS_GLOCK();
2055         if (!locked) {
2056             ReleaseWriteLock(&avc->lock);
2057             AFS_GUNLOCK();
2058         }
2059         return 0;
2060     }
2061     if ((avc->f.states & CDeadVnode) && vnode_vtype(ovp) != VNON)
2062         panic("vcache %p should not be CDeadVnode", avc);
2063     AFS_GUNLOCK();
2064     memset(&par, 0, sizeof(struct vnode_fsparam));
2065     par.vnfs_mp = afs_globalVFS;
2066     par.vnfs_vtype = avc->f.m.Type;
2067     par.vnfs_vops = afs_vnodeop_p;
2068     par.vnfs_filesize = avc->f.m.Length;
2069     par.vnfs_fsnode = avc;
2070     par.vnfs_dvp = dvp;
2071     if (cnp && (cnp->cn_flags & ISDOTDOT) == 0)
2072         par.vnfs_cnp = cnp;
2073     if (!dvp || !cnp || (cnp->cn_flags & MAKEENTRY) == 0)
2074         par.vnfs_flags = VNFS_NOCACHE;
2075     if (isroot)
2076         par.vnfs_markroot = 1;
2077     error = vnode_create(VNCREATE_FLAVOR, VCREATESIZE, &par, &nvp);
2078     if (!error) {
2079         vnode_addfsref(nvp);
2080         if ((avc->f.states & CDeadVnode) && vnode_vtype(ovp) != VNON)
2081             printf("vcache %p should not be CDeadVnode", avc);
2082         if (avc->v == ovp) {
2083             if (avc->f.states & CBulkFetching) {
2084                 vnode_recycle(ovp);
2085             }
2086             if (!(avc->f.states & CVInit)) {
2087                 vnode_clearfsnode(ovp);
2088                 vnode_removefsref(ovp);
2089             }
2090         }
2091         avc->v = nvp;
2092         avc->f.states &=~ CDeadVnode;
2093     }
2094     vnode_put(ovp);
2095     vnode_rele(ovp);
2096     AFS_GLOCK();
2097     if (!locked)
2098         ReleaseWriteLock(&avc->lock);
2099     if (!error)
2100         afs_osi_Wakeup(&avc->f.states);
2101     if (!locked)
2102         AFS_GUNLOCK();
2103     return error;
2104 }
2105 #endif