HCoop / hcoop / debian / openafs.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Import Upstream version 1.8.5
[hcoop/debian/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 {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 {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 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 /*
291 * ._ file attribute mirroring touches this.
292 * we can't flag the vcache as there is none, so fail here.
293 * needed for fsevents support.
294 */
295 if (ap->a_context == afs_osi_ctxtp)
296 return ENOENT;
297 if (vcp->mvstat != AFS_MVSTAT_MTPT) {
298 error = cache_lookup(ap->a_dvp, ap->a_vpp, ap->a_cnp);
299 if (error == -1)
300 return 0;
301 if (error == ENOENT)
302 return error;
303 }
304 #endif
305
306 GETNAME();
307 p = vop_cn_proc;
308
309 lockparent = flags & LOCKPARENT;
310 wantparent = flags & (LOCKPARENT | WANTPARENT);
311
312 if (!vnode_isdir(ap->a_dvp)) {
313 *ap->a_vpp = 0;
314 DROPNAME();
315 return ENOTDIR;
316 }
317 dvp = ap->a_dvp;
318 #ifndef AFS_DARWIN80_ENV
319 if (flags & ISDOTDOT)
320 VOP_UNLOCK(dvp, 0, p);
321 #endif
322 AFS_GLOCK();
323 error = afs_lookup(VTOAFS(dvp), name, &vcp, vop_cn_cred);
324 AFS_GUNLOCK();
325 if (error) {
326 #ifndef AFS_DARWIN80_ENV
327 if (flags & ISDOTDOT)
328 VOP_LOCK(dvp, LK_EXCLUSIVE | LK_RETRY, p);
329 #endif
330 if ((cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME)
331 && (flags & ISLASTCN) && error == ENOENT)
332 error = EJUSTRETURN;
333 #ifndef AFS_DARWIN80_ENV
334 if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
335 cnp->cn_flags |= SAVENAME;
336 #endif
337 DROPNAME();
338 *ap->a_vpp = 0;
339 return (error);
340 }
341 #ifdef AFS_DARWIN80_ENV
342 if ((error=afs_darwin_finalizevnode(vcp, ap->a_dvp, ap->a_cnp, 0, 0))) {
343 DROPNAME();
344 *ap->a_vpp = 0;
345 return error;
346 }
347 #endif
348 vp = AFSTOV(vcp); /* always get a node if no error */
349 #ifndef AFS_DARWIN80_ENV /* XXX needed for multi-mount thing, but can't have it yet */
350 vp->v_vfsp = dvp->v_vfsp;
351
352 if (UBCINFOMISSING(vp) ||
353 UBCINFORECLAIMED(vp)) {
354 ubc_info_init(vp);
355 }
356 #endif
357
358 #ifndef AFS_DARWIN80_ENV
359 /* The parent directory comes in locked. We unlock it on return
360 * unless the caller wants it left locked.
361 * we also always return the vnode locked. */
362
363 if (flags & ISDOTDOT) {
364 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
365 /* always return the child locked */
366 if (lockparent && (flags & ISLASTCN)
367 && (error = vn_lock(dvp, LK_EXCLUSIVE, p))) {
368 vput(vp);
369 DROPNAME();
370 return (error);
371 }
372 } else if (vp == dvp) {
373 /* they're the same; afs_lookup() already ref'ed the leaf.
374 * It came in locked, so we don't need to ref OR lock it */
375 } else {
376 if (!lockparent || !(flags & ISLASTCN))
377 VOP_UNLOCK(dvp, 0, p); /* done with parent. */
378 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
379 /* always return the child locked */
380 }
381 #endif
382 *ap->a_vpp = vp;
383
384 #ifndef AFS_DARWIN80_ENV
385 if ((cnp->cn_nameiop == RENAME && wantparent && (flags & ISLASTCN)
386 || (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))))
387 cnp->cn_flags |= SAVENAME;
388 #endif
389
390 DROPNAME();
391 return error;
392 }
393
394 int
395 afs_vop_create(ap)
396 struct VOPPROT(create_args) /* {
397 * struct vnode *a_dvp;
398 * struct vnode **a_vpp;
399 * struct componentname *a_cnp;
400 * struct vattr *a_vap;
401 * } */ *ap;
402 {
403 int error = 0;
404 struct vcache *vcp;
405 struct vnode *dvp = ap->a_dvp;
406 struct proc *p;
407 GETNAME();
408 p = vop_cn_proc;
409
410 /* vnode layer handles excl/nonexcl */
411 AFS_GLOCK();
412 error =
413 afs_create(VTOAFS(dvp), name, ap->a_vap, NONEXCL, ap->a_vap->va_mode,
414 &vcp, vop_cn_cred);
415 AFS_GUNLOCK();
416 if (error) {
417 #ifndef AFS_DARWIN80_ENV
418 VOP_ABORTOP(dvp, cnp);
419 vput(dvp);
420 #endif
421 DROPNAME();
422 return (error);
423 }
424
425 if (vcp) {
426 #ifdef AFS_DARWIN80_ENV
427 if ((error=afs_darwin_finalizevnode(vcp, ap->a_dvp, ap->a_cnp, 0, 0))) {
428 DROPNAME();
429 *ap->a_vpp=0;
430 return error;
431 }
432 #endif
433 *ap->a_vpp = AFSTOV(vcp);
434 #ifndef AFS_DARWIN80_ENV /* XXX needed for multi-mount thing, but can't have it yet */
435 (*ap->a_vpp)->v_vfsp = dvp->v_vfsp;
436 vn_lock(*ap->a_vpp, LK_EXCLUSIVE | LK_RETRY, p);
437 if (UBCINFOMISSING(*ap->a_vpp) || UBCINFORECLAIMED(*ap->a_vpp)) {
438 vcp->f.states |= CUBCinit;
439 ubc_info_init(*ap->a_vpp);
440 vcp->f.states &= ~CUBCinit;
441 }
442 #endif
443 } else
444 *ap->a_vpp = 0;
445
446 #ifndef AFS_DARWIN80_ENV
447 if ((cnp->cn_flags & SAVESTART) == 0)
448 FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
449 vput(dvp);
450 #endif
451 DROPNAME();
452 return error;
453 }
454
455 int
456 afs_vop_mknod(ap)
457 struct VOPPROT(mknod_args) /* {
458 * struct vnode *a_dvp;
459 * struct vnode **a_vpp;
460 * struct componentname *a_cnp;
461 * struct vattr *a_vap;
462 * } */ *ap;
463 {
464 #ifndef AFS_DARWIN80_ENV
465 FREE_ZONE(ap->a_cnp->cn_pnbuf, ap->a_cnp->cn_pnlen, M_NAMEI);
466 vput(ap->a_dvp);
467 #endif
468 return (ENODEV);
469 }
470
471 int
472 afs_vop_open(ap)
473 struct VOPPROT(open_args) /* {
474 * struct vnode *a_vp;
475 * int a_mode;
476 * struct ucred *a_cred;
477 * struct proc *a_p;
478 * } */ *ap;
479 {
480 int error;
481 struct vnode *vp = ap->a_vp;
482 struct vcache *vc = VTOAFS(vp);
483 #if !defined(AFS_DARWIN80_ENV)
484 int didhold = 0;
485 /*----------------------------------------------------------------
486 * osi_VM_TryReclaim() removes the ubcinfo of a vnode, but that vnode
487 * can later be passed to vn_open(), which will skip the call to
488 * ubc_hold(), and when the ubcinfo is later added, the ui_refcount
489 * will be off. So we compensate by calling ubc_hold() ourselves
490 * when ui_refcount is less than 2. If an error occurs in afs_open()
491 * we must call ubc_rele(), which is what vn_open() would do if it
492 * was able to call ubc_hold() in the first place.
493 *----------------------------------------------------------------*/
494 if (vp->v_type == VREG && !(vp->v_flag & VSYSTEM)
495 && vp->v_ubcinfo->ui_refcount < 2)
496 didhold = ubc_hold(vp);
497 #endif /* !AFS_DARWIN80_ENV */
498 AFS_GLOCK();
499 error = afs_open(&vc, ap->a_mode, vop_cred);
500 #ifdef DIAGNOSTIC
501 if (AFSTOV(vc) != vp)
502 panic("AFS open changed vnode!");
503 #endif
504 osi_FlushPages(vc, vop_cred);
505 AFS_GUNLOCK();
506 #if !defined(AFS_DARWIN80_ENV)
507 if (error && didhold)
508 ubc_rele(vp);
509 #endif /* !AFS_DARWIN80_ENV */
510 return error;
511 }
512
513 int
514 afs_vop_close(ap)
515 struct VOPPROT(close_args) /* {
516 * struct vnode *a_vp;
517 * int a_fflag;
518 * struct ucred *a_cred;
519 * struct proc *a_p;
520 * } */ *ap;
521 {
522 int code;
523 struct vnode *vp = ap->a_vp;
524 struct vcache *avc = VTOAFS(vp);
525 /* allows faking FSE_CONTENT_MODIFIED */
526 if (afs_osi_ctxtp == ap->a_context)
527 return 0;
528 AFS_GLOCK();
529 if (vop_cred)
530 code = afs_close(avc, ap->a_fflag, vop_cred);
531 else
532 code = afs_close(avc, ap->a_fflag, &afs_osi_cred);
533 osi_FlushPages(avc, vop_cred); /* hold GLOCK, but not basic vnode lock */
534 /* This is legit; it just forces the fstrace event to happen */
535 code = afs_CheckCode(code, NULL, 60);
536 AFS_GUNLOCK();
537
538 return code;
539 }
540
541 #ifdef AFS_DARWIN80_ENV
542 extern int afs_fakestat_enable;
543
544 int
545 afs_vop_access(ap)
546 struct VOPPROT(access_args) /* {
547 * struct vnode *a_vp;
548 * int a_action;
549 * vfs_context_t a_context;
550 * } */ *ap;
551 {
552 int code;
553 struct vrequest treq;
554 struct afs_fakestat_state fakestate;
555 struct vcache * tvc = VTOAFS(ap->a_vp);
556 int bits=0;
557 int cmb = CHECK_MODE_BITS;
558 #ifdef AFS_DARWIN80_ENV
559 /*
560 * needed for fsevents. ._ file attribute mirroring touches this.
561 * we can't flag the vcache, as there is none, so fail here.
562 */
563 if (ap->a_context == afs_osi_ctxtp)
564 return ENOENT;
565 #endif
566 AFS_GLOCK();
567 afs_InitFakeStat(&fakestate);
568 if ((code = afs_InitReq(&treq, vop_cred)))
569 goto out2;
570
571 code = afs_TryEvalFakeStat(&tvc, &fakestate, &treq);
572 if (code) {
573 code = afs_CheckCode(code, &treq, 55);
574 goto out;
575 }
576
577 code = afs_VerifyVCache(tvc, &treq);
578 if (code) {
579 code = afs_CheckCode(code, &treq, 56);
580 goto out;
581 }
582 if (afs_fakestat_enable && tvc->mvstat != AFS_MVSTAT_FILE && !(tvc->f.states & CStatd)) {
583 code = 0;
584 goto out;
585 }
586 if (vnode_isdir(ap->a_vp)) {
587 if (ap->a_action & KAUTH_VNODE_LIST_DIRECTORY)
588 bits |= PRSFS_LOOKUP;
589 if (ap->a_action & KAUTH_VNODE_ADD_FILE)
590 bits |= PRSFS_INSERT;
591 if (ap->a_action & KAUTH_VNODE_SEARCH)
592 bits |= PRSFS_LOOKUP;
593 if (ap->a_action & KAUTH_VNODE_DELETE)
594 bits |= PRSFS_DELETE;
595 if (ap->a_action & KAUTH_VNODE_ADD_SUBDIRECTORY)
596 bits |= PRSFS_INSERT;
597 if (ap->a_action & KAUTH_VNODE_DELETE_CHILD)
598 bits |= PRSFS_DELETE;
599 #if 0 /* I'd argue this should be enforced on the parent. But that's ugly */
600 if (ap->a_action & KAUTH_VNODE_READ_ATTRIBUTES)
601 bits |= PRSFS_LOOKUP;
602 if (ap->a_action & KAUTH_VNODE_READ_SECURITY) /* mode bits/gid, not afs acl */
603 bits |= PRSFS_LOOKUP;
604 #endif
605 } else {
606 if (ap->a_action & KAUTH_VNODE_READ_DATA)
607 bits |= PRSFS_READ;
608 if (ap->a_action & KAUTH_VNODE_WRITE_DATA)
609 bits |= PRSFS_WRITE;
610 if (ap->a_action & KAUTH_VNODE_EXECUTE)
611 bits |= PRSFS_READ; /* and mode bits.... */
612 if (ap->a_action & KAUTH_VNODE_READ_ATTRIBUTES)
613 bits |= PRSFS_LOOKUP;
614 if (ap->a_action & KAUTH_VNODE_READ_SECURITY) /* mode bits/gid, not afs acl */
615 bits |= PRSFS_LOOKUP;
616 if ((ap->a_action & ((1 << 25) - 1)) == KAUTH_VNODE_EXECUTE)
617 /* if only exec, don't check for read mode bit */
618 /* high bits of ap->a_action are not for 'generic rights bits', and
619 so should not be checked (KAUTH_VNODE_ACCESS is often present
620 and needs to be masked off) */
621 cmb |= CMB_ALLOW_EXEC_AS_READ;
622 }
623 if (ap->a_action & KAUTH_VNODE_WRITE_ATTRIBUTES)
624 bits |= PRSFS_WRITE;
625 #if 0 /* no extended attributes */
626 if (ap->a_action & KAUTH_VNODE_READ_EXTATTRIBUTES)
627 bits |= PRSFS_READ;
628 if (ap->a_action & KAUTH_VNODE_WRITE_EXTATTRIBUTES)
629 bits |= PRSFS_WRITE;
630 #endif
631 if (ap->a_action & KAUTH_VNODE_WRITE_SECURITY)
632 bits |= PRSFS_WRITE;
633 /* we can't check for KAUTH_VNODE_TAKE_OWNERSHIP, so we always permit it */
634
635 code = afs_AccessOK(tvc, bits, &treq, cmb);
636 /*
637 * Special cased dropbox handling:
638 * cp on 10.4 behaves badly, looping on EACCES
639 * Finder may reopen the file. Let it.
640 */
641 if (code == 0 && ((bits &~(PRSFS_READ|PRSFS_WRITE)) == 0))
642 code = afs_AccessOK(tvc, PRSFS_ADMINISTER|PRSFS_INSERT|bits, &treq, cmb);
643 /* Finder also treats dropboxes as insert+delete. fake it out. */
644 if (code == 0 && (bits == (PRSFS_INSERT|PRSFS_DELETE)))
645 code = afs_AccessOK(tvc, PRSFS_INSERT, &treq, cmb);
646
647 if (code == 1 && vnode_vtype(ap->a_vp) == VREG &&
648 ap->a_action & KAUTH_VNODE_EXECUTE &&
649 (tvc->f.m.Mode & 0100) != 0100) {
650 code = 0;
651 }
652 if (code) {
653 code= 0; /* if access is ok */
654 } else {
655 code = afs_CheckCode(EACCES, &treq, 57); /* failure code */
656 }
657 out:
658 afs_PutFakeStat(&fakestate);
659 out2:
660 AFS_GUNLOCK();
661 return code;
662 }
663 #else
664 int
665 afs_vop_access(ap)
666 struct VOPPROT(access_args) /* {
667 * struct vnode *a_vp;
668 * int a_mode;
669 * struct ucred *a_cred;
670 * struct proc *a_p;
671 * } */ *ap;
672 {
673 int code;
674 AFS_GLOCK();
675 code = afs_access(VTOAFS(ap->a_vp), ap->a_mode, vop_cred);
676 AFS_GUNLOCK();
677 return code;
678 }
679 #endif
680
681 int
682 afs_vop_getattr(ap)
683 struct VOPPROT(getattr_args) /* {
684 * struct vnode *a_vp;
685 * struct vattr *a_vap;
686 * struct ucred *a_cred;
687 * struct proc *a_p;
688 * } */ *ap;
689 {
690 int code;
691
692 #ifdef AFS_DARWIN80_ENV
693 /* CEvent excludes the fsevent. our context excludes the ._ */
694 if ((VTOAFS(ap->a_vp)->f.states & CEvent) ||
695 (ap->a_context == afs_osi_ctxtp)){
696 struct vcache *avc = VTOAFS(ap->a_vp);
697 int isglock = ISAFS_GLOCK();
698
699 /* this is needed because of how and when we re-enter */
700 if (!isglock)
701 AFS_GLOCK();
702 /* do minimal work to return fake result for fsevents */
703 if (afs_fakestat_enable && VTOAFS(ap->a_vp)->mvstat == AFS_MVSTAT_MTPT) {
704 struct afs_fakestat_state fakestat;
705 struct vrequest treq;
706
707 code = afs_InitReq(&treq, vop_cred);
708 if (code) {
709 if (!isglock)
710 AFS_GUNLOCK();
711 return code;
712 }
713 afs_InitFakeStat(&fakestat);
714 /* expects GLOCK */
715 code = afs_TryEvalFakeStat(&avc, &fakestat, &treq);
716 if (code) {
717 if (!isglock)
718 AFS_GUNLOCK();
719 afs_PutFakeStat(&fakestat);
720 return code;
721 }
722 }
723 code = afs_CopyOutAttrs(avc, ap->a_vap);
724 if (!isglock)
725 AFS_GUNLOCK();
726 if (0 && !code) {
727 /* tweak things so finder will recheck */
728 (ap->a_vap)->va_gid = ((ap->a_vap)->va_gid == 1) ? 2 : 1;
729 (ap->a_vap)->va_mode &= ~(VSGID);
730 }
731 } else
732 #endif
733 {
734 AFS_GLOCK();
735 code = afs_getattr(VTOAFS(ap->a_vp), ap->a_vap, vop_cred);
736 /* This is legit; it just forces the fstrace event to happen */
737 code = afs_CheckCode(code, NULL, 58);
738 AFS_GUNLOCK();
739 }
740 #ifdef AFS_DARWIN80_ENV
741 VATTR_SET_SUPPORTED(ap->a_vap, va_type);
742 VATTR_SET_SUPPORTED(ap->a_vap, va_mode);
743 VATTR_SET_SUPPORTED(ap->a_vap, va_uid);
744 VATTR_SET_SUPPORTED(ap->a_vap, va_gid);
745 VATTR_SET_SUPPORTED(ap->a_vap, va_fsid);
746 VATTR_SET_SUPPORTED(ap->a_vap, va_fileid);
747 VATTR_SET_SUPPORTED(ap->a_vap, va_nlink);
748 VATTR_SET_SUPPORTED(ap->a_vap, va_data_size);
749 VATTR_SET_SUPPORTED(ap->a_vap, va_access_time);
750 VATTR_SET_SUPPORTED(ap->a_vap, va_modify_time);
751 VATTR_SET_SUPPORTED(ap->a_vap, va_change_time);
752 VATTR_SET_SUPPORTED(ap->a_vap, va_gen);
753 VATTR_SET_SUPPORTED(ap->a_vap, va_flags);
754 VATTR_SET_SUPPORTED(ap->a_vap, va_iosize);
755 VATTR_SET_SUPPORTED(ap->a_vap, va_total_alloc);
756 #endif
757 return code;
758 }
759
760 int
761 afs_vop_setattr(ap)
762 struct VOPPROT(setattr_args) /* {
763 * struct vnode *a_vp;
764 * struct vattr *a_vap;
765 * struct ucred *a_cred;
766 * struct proc *a_p;
767 * } */ *ap;
768 {
769 int code, pass = 0;
770 struct vcache *avc = VTOAFS(ap->a_vp);
771 #ifdef AFS_DARWIN80_ENV
772 /* fsevents tries to set attributes. drop it. */
773 if (ap->a_context == afs_osi_ctxtp)
774 return 0;
775 #endif
776 AFS_GLOCK();
777 retry:
778 code = afs_setattr(avc, ap->a_vap, vop_cred);
779 /* This is legit; it just forces the fstrace event to happen */
780 code = afs_CheckCode(code, NULL, 59);
781 if (!pass && code == EINVAL && (VATTR_IS_ACTIVE(ap->a_vap, va_mode) &&
782 (vType(avc) == VLNK))) {
783 VATTR_CLEAR_ACTIVE(ap->a_vap, va_mode);
784 pass++;
785 goto retry;
786 }
787 AFS_GUNLOCK();
788 return code;
789 }
790
791 int
792 afs_vop_read(ap)
793 struct VOPPROT(read_args) /* {
794 * struct vnode *a_vp;
795 * struct uio *a_uio;
796 * int a_ioflag;
797 * struct ucred *a_cred;
798 * } */ *ap;
799 {
800 int code;
801 struct vnode *vp = ap->a_vp;
802 struct vcache *avc = VTOAFS(vp);
803
804 if (vnode_isdir(ap->a_vp))
805 return EISDIR;
806 #ifdef AFS_DARWIN80_ENV
807 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);
808 #else
809 if (UBCINFOEXISTS(ap->a_vp)) {
810 ubc_clean(ap->a_vp, 0);
811 }
812 #endif
813 AFS_GLOCK();
814 osi_FlushPages(avc, vop_cred); /* hold GLOCK, but not basic vnode lock */
815 code = afs_read(avc, ap->a_uio, vop_cred, 0);
816 AFS_GUNLOCK();
817 return code;
818 }
819
820 int
821 afs_vop_pagein(ap)
822 struct VOPPROT(pagein_args) /* {
823 * struct vnode *a_vp;
824 * upl_t a_pl;
825 * vm_offset_t a_pl_offset;
826 * off_t a_f_offset;
827 * size_t a_size;
828 * struct ucred *a_cred;
829 * int a_flags;
830 * } */ *ap;
831 {
832 struct vnode *vp = ap->a_vp;
833 upl_t pl = ap->a_pl;
834 size_t size = ap->a_size;
835 off_t f_offset = ap->a_f_offset;
836 vm_offset_t pl_offset = ap->a_pl_offset;
837 int flags = ap->a_flags;
838 struct ucred *cred;
839 vm_offset_t ioaddr;
840 int code;
841 struct vcache *tvc = VTOAFS(vp);
842 int nocommit = flags & UPL_NOCOMMIT;
843 #ifdef AFS_DARWIN80_ENV
844 struct uio *uio;
845 #else
846 struct uio auio;
847 struct iovec aiov;
848 struct uio *uio = &auio;
849
850 memset(&auio, 0, sizeof(auio));
851 memset(&aiov, 0, sizeof(aiov));
852 #endif
853
854 #ifndef AFS_DARWIN80_ENV
855 if (UBCINVALID(vp)) {
856 #if DIAGNOSTIC
857 panic("afs_vop_pagein: invalid vp");
858 #endif /* DIAGNOSTIC */
859 return (EPERM);
860 }
861
862 UBCINFOCHECK("afs_vop_pagein", vp);
863 #endif
864 if (pl == (upl_t) NULL) {
865 panic("afs_vop_pagein: no upl");
866 }
867
868 cred = ubc_getcred(vp);
869 if (cred == NOCRED)
870 cred = vop_cred;
871
872 if (size == 0) {
873 if (!nocommit)
874 OSI_UPL_ABORT_RANGE(pl, pl_offset, size,
875 UPL_ABORT_ERROR | UPL_ABORT_FREE_ON_EMPTY);
876 return (0);
877 }
878 if (f_offset < 0) {
879 if (!nocommit)
880 OSI_UPL_ABORT_RANGE(pl, pl_offset, size,
881 UPL_ABORT_ERROR | UPL_ABORT_FREE_ON_EMPTY);
882 return (EINVAL);
883 }
884 if (f_offset & PAGE_MASK)
885 panic("afs_vop_pagein: offset not page aligned");
886
887 OSI_UPL_MAP(pl, &ioaddr);
888 ioaddr += pl_offset;
889 #ifdef AFS_DARWIN80_ENV
890 uio = uio_create(1, f_offset, UIO_SYSSPACE32, UIO_READ);
891 uio_addiov(uio, CAST_USER_ADDR_T(ioaddr), size);
892 #else
893 auio.uio_iov = &aiov;
894 auio.uio_iovcnt = 1;
895 auio.uio_offset = f_offset;
896 auio.uio_segflg = UIO_SYSSPACE;
897 auio.uio_rw = UIO_READ;
898 auio.uio_procp = NULL;
899 auio.uio_resid = aiov.iov_len = size;
900 aiov.iov_base = (caddr_t) ioaddr;
901 #endif
902 AFS_GLOCK();
903 osi_FlushPages(tvc, vop_cred); /* hold GLOCK, but not basic vnode lock */
904 code = afs_read(tvc, uio, cred, 0);
905 if (code == 0) {
906 ObtainWriteLock(&tvc->lock, 2);
907 tvc->f.states |= CMAPPED;
908 ReleaseWriteLock(&tvc->lock);
909 }
910 AFS_GUNLOCK();
911
912 /* Zero out rest of last page if there wasn't enough data in the file */
913 if (code == 0 && AFS_UIO_RESID(uio) > 0) {
914 #ifdef AFS_DARWIN80_ENV
915 memset(((caddr_t)ioaddr) + (size - AFS_UIO_RESID(uio)), 0,
916 AFS_UIO_RESID(uio));
917 #else
918 memset(aiov.iov_base, 0, auio.uio_resid);
919 #endif
920 }
921
922 OSI_UPL_UNMAP(pl);
923 if (!nocommit) {
924 if (code)
925 OSI_UPL_ABORT_RANGE(pl, pl_offset, size,
926 UPL_ABORT_ERROR | UPL_ABORT_FREE_ON_EMPTY);
927 else
928 OSI_UPL_COMMIT_RANGE(pl, pl_offset, size,
929 UPL_COMMIT_CLEAR_DIRTY |
930 UPL_COMMIT_FREE_ON_EMPTY);
931 }
932 #ifdef AFS_DARWIN80_ENV
933 uio_free(uio);
934 #endif
935 return code;
936 }
937
938 int
939 afs_vop_write(ap)
940 struct VOPPROT(write_args) /* {
941 * struct vnode *a_vp;
942 * struct uio *a_uio;
943 * int a_ioflag;
944 * struct ucred *a_cred;
945 * } */ *ap;
946 {
947 int code;
948 struct vcache *avc = VTOAFS(ap->a_vp);
949 void *object;
950 #ifdef AFS_DARWIN80_ENV
951 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);
952 #else
953 if (UBCINFOEXISTS(ap->a_vp)) {
954 ubc_clean(ap->a_vp, 1);
955 }
956 if (UBCINFOEXISTS(ap->a_vp))
957 osi_VM_NukePages(ap->a_vp, AFS_UIO_OFFSET(ap->a_uio),
958 AFS_UIO_RESID(ap->a_uio));
959 #endif
960 AFS_GLOCK();
961 osi_FlushPages(avc, vop_cred); /* hold GLOCK, but not basic vnode lock */
962 code =
963 afs_write(VTOAFS(ap->a_vp), ap->a_uio, ap->a_ioflag, vop_cred, 0);
964 AFS_GUNLOCK();
965 return code;
966 }
967
968 int
969 afs_vop_pageout(ap)
970 struct VOPPROT(pageout_args) /* {
971 * struct vnode *a_vp;
972 * upl_t a_pl,
973 * vm_offset_t a_pl_offset,
974 * off_t a_f_offset,
975 * size_t a_size,
976 * struct ucred *a_cred,
977 * int a_flags
978 * } */ *ap;
979 {
980 struct vnode *vp = ap->a_vp;
981 upl_t pl = ap->a_pl;
982 size_t size = ap->a_size;
983 off_t f_offset = ap->a_f_offset;
984 vm_offset_t pl_offset = ap->a_pl_offset;
985 int flags = ap->a_flags;
986 struct ucred *cred;
987 vm_offset_t ioaddr;
988 int nocommit = flags & UPL_NOCOMMIT;
989 int iosize;
990 int code;
991 struct vcache *tvc = VTOAFS(vp);
992 #ifdef AFS_DARWIN80_ENV
993 struct uio *uio;
994 #else
995 struct uio auio;
996 struct iovec aiov;
997 struct uio *uio = &auio;
998
999 memset(&auio, 0, sizeof(auio));
1000 memset(&aiov, 0, sizeof(aiov));
1001 #endif
1002
1003 #ifndef AFS_DARWIN80_ENV
1004 if (UBCINVALID(vp)) {
1005 #if DIAGNOSTIC
1006 panic("afs_vop_pageout: invalid vp");
1007 #endif /* DIAGNOSTIC */
1008 return (EPERM);
1009 }
1010
1011 UBCINFOCHECK("afs_vop_pageout", vp);
1012 #endif
1013 if (pl == (upl_t) NULL) {
1014 panic("afs_vop_pageout: no upl");
1015 }
1016 #if !defined(AFS_DARWIN80_ENV) /* XXX nfs now uses it's own bufs (struct nfsbuf)
1017 maybe the generic
1018 layer doesn't have them anymore? In any case,
1019 we can't just copy code from nfs... */
1020 {
1021 int lbn, s;
1022 struct buf *bp;
1023 int biosize = DEV_BSIZE;
1024
1025 lbn = f_offset / DEV_BSIZE;
1026
1027 for (iosize = size; iosize > 0; iosize -= biosize, lbn++) {
1028
1029 s = splbio();
1030 if (bp = incore(vp, lbn)) {
1031 if (ISSET(bp->b_flags, B_BUSY))
1032 panic("nfs_pageout: found BUSY buffer incore\n");
1033
1034 bremfree(bp);
1035 SET(bp->b_flags, (B_BUSY | B_INVAL));
1036 brelse(bp);
1037 }
1038 splx(s);
1039 }
1040 }
1041 #endif
1042 cred = ubc_getcred(vp);
1043 if (cred == NOCRED)
1044 cred = vop_cred;
1045
1046 if (size == 0) {
1047 if (!nocommit)
1048 OSI_UPL_ABORT_RANGE(pl, pl_offset, size,
1049 UPL_ABORT_FREE_ON_EMPTY);
1050 return (0);
1051 }
1052 if (flags & (IO_APPEND | IO_SYNC))
1053 panic("nfs_pageout: (IO_APPEND | IO_SYNC)");
1054 if (f_offset < 0) {
1055 if (!nocommit)
1056 OSI_UPL_ABORT_RANGE(pl, pl_offset, size,
1057 UPL_ABORT_FREE_ON_EMPTY);
1058 return (EINVAL);
1059 }
1060 if (f_offset >= tvc->f.m.Length) {
1061 if (!nocommit)
1062 OSI_UPL_ABORT_RANGE(pl, pl_offset, size,
1063 UPL_ABORT_FREE_ON_EMPTY);
1064 return (EINVAL);
1065 }
1066
1067 if (f_offset & PAGE_MASK)
1068 panic("afs_vop_pageout: offset not page aligned");
1069
1070 /* size will always be a multiple of PAGE_SIZE */
1071 /* pageout isn't supposed to extend files */
1072 if (f_offset + size > tvc->f.m.Length)
1073 iosize = tvc->f.m.Length - f_offset;
1074 else
1075 iosize = size;
1076
1077 if (size > (iosize + (PAGE_SIZE - 1)) & ~PAGE_MASK && !nocommit) {
1078 int iosize_rnd=(iosize + (PAGE_SIZE - 1)) & ~PAGE_MASK;
1079 OSI_UPL_ABORT_RANGE(pl, pl_offset + iosize_rnd,
1080 size - iosize_rnd,
1081 UPL_ABORT_FREE_ON_EMPTY);
1082 }
1083 OSI_UPL_MAP(pl, &ioaddr);
1084 ioaddr += pl_offset;
1085 #ifdef AFS_DARWIN80_ENV
1086 uio = uio_create(1, f_offset, UIO_SYSSPACE32, UIO_READ);
1087 uio_addiov(uio, CAST_USER_ADDR_T(ioaddr), size);
1088 #else
1089 auio.uio_iov = &aiov;
1090 auio.uio_iovcnt = 1;
1091 auio.uio_offset = f_offset;
1092 auio.uio_segflg = UIO_SYSSPACE;
1093 auio.uio_rw = UIO_WRITE;
1094 auio.uio_procp = NULL;
1095 auio.uio_resid = aiov.iov_len = iosize;
1096 aiov.iov_base = (caddr_t) ioaddr;
1097 #endif
1098 {
1099 /* USV?
1100 * check for partial page and clear the
1101 * contents past end of the file before
1102 * releasing it in the VM page cache
1103 */
1104 if ((f_offset < tvc->f.m.Length) && (f_offset + size) > tvc->f.m.Length) {
1105 size_t io = tvc->f.m.Length - f_offset;
1106
1107 memset((caddr_t) (ioaddr + pl_offset + io), 0, size - io);
1108 }
1109 }
1110
1111 AFS_GLOCK();
1112 osi_FlushPages(tvc, vop_cred); /* hold GLOCK, but not basic vnode lock */
1113 ObtainWriteLock(&tvc->lock, 1);
1114 afs_FakeOpen(tvc);
1115 ReleaseWriteLock(&tvc->lock);
1116
1117 code = afs_write(tvc, uio, flags, cred, 0);
1118
1119 ObtainWriteLock(&tvc->lock, 1);
1120 afs_FakeClose(tvc, cred);
1121 ReleaseWriteLock(&tvc->lock);
1122 AFS_GUNLOCK();
1123 OSI_UPL_UNMAP(pl);
1124 if (!nocommit) {
1125 if (code)
1126 OSI_UPL_ABORT_RANGE(pl, pl_offset, size,
1127 UPL_ABORT_FREE_ON_EMPTY);
1128 else
1129 OSI_UPL_COMMIT_RANGE(pl, pl_offset, size,
1130 UPL_COMMIT_CLEAR_DIRTY |
1131 UPL_COMMIT_FREE_ON_EMPTY);
1132 }
1133
1134 #ifdef AFS_DARWIN80_ENV
1135 uio_free(uio);
1136 #endif
1137 return code;
1138 }
1139
1140 int
1141 afs_vop_ioctl(ap)
1142 struct VOPPROT(ioctl_args) /* {
1143 * struct vnode *a_vp;
1144 * int a_command;
1145 * caddr_t a_data;
1146 * int a_fflag;
1147 * struct ucred *a_cred;
1148 * struct proc *a_p;
1149 * } */ *ap;
1150 {
1151 struct vcache *tvc = VTOAFS(ap->a_vp);
1152 struct afs_ioctl data;
1153 int error = 0;
1154
1155 /* in case we ever get in here... */
1156
1157 AFS_STATCNT(afs_ioctl);
1158 if (((ap->a_command >> 8) & 0xff) == 'V') {
1159 /* This is a VICEIOCTL call */
1160 AFS_GLOCK();
1161 error = HandleIoctl(tvc, ap->a_command, ap->a_data);
1162 AFS_GUNLOCK();
1163 return (error);
1164 } else {
1165 /* No-op call; just return. */
1166 return (ENOTTY);
1167 }
1168 }
1169
1170 /* ARGSUSED */
1171 int
1172 afs_vop_select(ap)
1173 struct VOPPROT(select_args) /* {
1174 * struct vnode *a_vp;
1175 * int a_which;
1176 * int a_fflags;
1177 * struct ucred *a_cred;
1178 * struct proc *a_p;
1179 * } */ *ap;
1180 {
1181 /*
1182 * We should really check to see if I/O is possible.
1183 */
1184 return (1);
1185 }
1186
1187 /*
1188 * Mmap a file
1189 *
1190 * NB Currently unsupported.
1191 */
1192 /* ARGSUSED */
1193 int
1194 afs_vop_mmap(ap)
1195 struct VOPPROT(mmap_args) /* {
1196 * struct vnode *a_vp;
1197 * int a_fflags;
1198 * struct ucred *a_cred;
1199 * struct proc *a_p;
1200 * } */ *ap;
1201 {
1202 return (EINVAL);
1203 }
1204
1205 int
1206 afs_vop_fsync(ap)
1207 struct VOPPROT(fsync_args) /* {
1208 * struct vnode *a_vp;
1209 * struct ucred *a_cred;
1210 * int a_waitfor;
1211 * struct proc *a_p;
1212 * } */ *ap;
1213 {
1214 int wait = ap->a_waitfor == MNT_WAIT;
1215 int error;
1216 struct vnode *vp = ap->a_vp;
1217 int haveGlock = ISAFS_GLOCK();
1218
1219 /* in order to recycle faked vnodes for bulkstat */
1220 if (VTOAFS(vp) == NULL)
1221 return ENOTSUP;
1222
1223 /* afs_vop_lookup glocks, can call us through vinvalbuf from GetVCache */
1224 if (!haveGlock) AFS_GLOCK();
1225 if (vop_cred)
1226 error = afs_fsync(VTOAFS(vp), vop_cred);
1227 else
1228 error = afs_fsync(VTOAFS(vp), &afs_osi_cred);
1229 if (!haveGlock) AFS_GUNLOCK();
1230 return error;
1231 }
1232
1233 #ifndef AFS_DARWIN80_ENV
1234 int
1235 afs_vop_seek(ap)
1236 struct VOPPROT(seek_args) /* {
1237 * struct vnode *a_vp;
1238 * off_t a_oldoff;
1239 * off_t a_newoff;
1240 * struct ucred *a_cred;
1241 * } */ *ap;
1242 {
1243 if (ap->a_newoff > ULONG_MAX) /* AFS doesn't support 64-bit offsets */
1244 return EINVAL;
1245 return (0);
1246 }
1247 #endif
1248
1249 int
1250 afs_vop_remove(ap)
1251 struct VOPPROT(remove_args) /* {
1252 * struct vnode *a_dvp;
1253 * struct vnode *a_vp;
1254 * struct componentname *a_cnp;
1255 * } */ *ap;
1256 {
1257 int error = 0;
1258 struct vnode *vp = ap->a_vp;
1259 struct vnode *dvp = ap->a_dvp;
1260
1261 #ifdef AFS_DARWIN80_ENV
1262 if (ap->a_flags & VNODE_REMOVE_NODELETEBUSY) {
1263 /* Caller requested Carbon delete semantics */
1264 if (vnode_isinuse(vp, 0)) {
1265 return EBUSY;
1266 }
1267 }
1268 #endif
1269
1270 GETNAME();
1271 AFS_GLOCK();
1272 error = afs_remove(VTOAFS(dvp), name, vop_cn_cred);
1273 error = afs_CheckCode(error, NULL, 61);
1274 AFS_GUNLOCK();
1275 cache_purge(vp);
1276 if (!error) {
1277 #ifdef AFS_DARWIN80_ENV
1278 struct vcache *tvc = VTOAFS(vp);
1279
1280 if (!(tvc->f.states & CUnlinked)) {
1281 ubc_setsize(vp, (off_t)0);
1282 vnode_recycle(vp);
1283 }
1284 #else
1285 /* necessary so we don't deadlock ourselves in vclean */
1286 VOP_UNLOCK(vp, 0, cnp->cn_proc);
1287
1288 /* If crashes continue in ubc_hold, comment this out */
1289 (void)ubc_uncache(vp);
1290 #endif
1291 } else {
1292 /* should check for PRSFS_INSERT and not PRSFS_DELETE, but the
1293 goal here is to deal with Finder's unhappiness with resource
1294 forks that have no resources in a dropbox setting */
1295 if (name[0] == '.' && name[1] == '_' && error == EACCES)
1296 error = 0;
1297 }
1298
1299 #ifndef AFS_DARWIN80_ENV
1300 vput(dvp);
1301 if (dvp == vp)
1302 vrele(vp);
1303 else
1304 vput(vp);
1305 #endif
1306
1307 #ifndef AFS_DARWIN80_ENV
1308 FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
1309 #endif
1310 DROPNAME();
1311 return error;
1312 }
1313
1314 int
1315 afs_vop_link(ap)
1316 struct VOPPROT(link_args) /* {
1317 * struct vnode *a_vp;
1318 * struct vnode *a_tdvp;
1319 * struct componentname *a_cnp;
1320 * } */ *ap;
1321 {
1322 int error = 0;
1323 struct vnode *dvp = ap->a_tdvp;
1324 struct vnode *vp = ap->a_vp;
1325 struct proc *p;
1326
1327 GETNAME();
1328 p = vop_cn_proc;
1329 if (vnode_isdir(vp)) {
1330 VOP_ABORTOP(vp, cnp);
1331 error = EISDIR;
1332 goto out;
1333 }
1334 #ifndef AFS_DARWIN80_ENV
1335 if (error = vn_lock(vp, LK_EXCLUSIVE, p)) {
1336 VOP_ABORTOP(dvp, cnp);
1337 goto out;
1338 }
1339 #endif
1340 AFS_GLOCK();
1341 error = afs_link(VTOAFS(vp), VTOAFS(dvp), name, vop_cn_cred);
1342 AFS_GUNLOCK();
1343 #ifndef AFS_DARWIN80_ENV
1344 FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
1345 #endif
1346 #ifndef AFS_DARWIN80_ENV
1347 if (dvp != vp)
1348 VOP_UNLOCK(vp, 0, p);
1349 #endif
1350 out:
1351 #ifndef AFS_DARWIN80_ENV
1352 vput(dvp);
1353 #endif
1354 DROPNAME();
1355 return error;
1356 }
1357
1358 int
1359 afs_vop_rename(ap)
1360 struct VOPPROT(rename_args) /* {
1361 * struct vnode *a_fdvp;
1362 * struct vnode *a_fvp;
1363 * struct componentname *a_fcnp;
1364 * struct vnode *a_tdvp;
1365 * struct vnode *a_tvp;
1366 * struct componentname *a_tcnp;
1367 * } */ *ap;
1368 {
1369 int error = 0;
1370 struct componentname *fcnp = ap->a_fcnp;
1371 char *fname;
1372 struct componentname *tcnp = ap->a_tcnp;
1373 char *tname;
1374 struct vnode *tvp = ap->a_tvp;
1375 struct vnode *tdvp = ap->a_tdvp;
1376 struct vnode *fvp = ap->a_fvp;
1377 struct vnode *fdvp = ap->a_fdvp;
1378 struct proc *p;
1379
1380 p = cn_proc(fcnp);
1381
1382 #ifdef AFS_DARWIN80_ENV
1383 /*
1384 * generic code tests for v_mount equality, so we don't have to, but we
1385 * don't get the multiple-mount "benefits" of the old behavior
1386 * the generic code doesn't do this, so we really should, but all the
1387 * vrele's are wrong...
1388 */
1389 #else
1390 /* Check for cross-device rename.
1391 * For AFS, this means anything not in AFS-space
1392 */
1393 if ((0 != strcmp(tdvp->v_mount->mnt_stat.f_fstypename, "afs")) ||
1394 (tvp && (0 != strcmp(tvp->v_mount->mnt_stat.f_fstypename, "afs")))) {
1395 error = EXDEV;
1396 goto abortit;
1397 }
1398
1399 /*
1400 * if fvp == tvp, we're just removing one name of a pair of
1401 * directory entries for the same element. convert call into rename.
1402 ( (pinched from NetBSD 1.0's ufs_rename())
1403 */
1404 if (fvp == tvp) {
1405 if (vnode_isdir(fvp)) {
1406 error = EINVAL;
1407 abortit:
1408 VOP_ABORTOP(tdvp, tcnp); /* XXX, why not in NFS? */
1409 if (tdvp == tvp)
1410 vrele(tdvp);
1411 else
1412 vput(tdvp);
1413 if (tvp)
1414 vput(tvp);
1415 VOP_ABORTOP(fdvp, fcnp); /* XXX, why not in NFS? */
1416 vrele(fdvp);
1417 vrele(fvp);
1418 return (error);
1419 }
1420
1421 /* Release destination completely. */
1422 VOP_ABORTOP(tdvp, tcnp);
1423 vput(tdvp);
1424 vput(tvp);
1425 /* Delete source. */
1426 vrele(fdvp);
1427 vrele(fvp);
1428 fcnp->cn_flags &= ~MODMASK;
1429 fcnp->cn_flags |= LOCKPARENT | LOCKLEAF;
1430 if ((fcnp->cn_flags & SAVESTART) == 0)
1431 panic("afs_rename: lost from startdir");
1432 fcnp->cn_nameiop = DELETE;
1433
1434 VREF(fdvp);
1435 error=relookup(fdvp, &fvp, fcnp);
1436 if (error == 0)
1437 vrele(fdvp);
1438 if (fvp == NULL) {
1439 return (ENOENT);
1440 }
1441 error=VOP_REMOVE(fdvp, fvp, fcnp);
1442
1443 if (fdvp == fvp)
1444 vrele(fdvp);
1445 else
1446 vput(fdvp);
1447 vput(fvp);
1448 return (error);
1449 }
1450 if (error = vn_lock(fvp, LK_EXCLUSIVE, p))
1451 goto abortit;
1452 #endif
1453
1454 MALLOC(fname, char *, fcnp->cn_namelen + 1, M_TEMP, M_WAITOK);
1455 memcpy(fname, fcnp->cn_nameptr, fcnp->cn_namelen);
1456 fname[fcnp->cn_namelen] = '\0';
1457 MALLOC(tname, char *, tcnp->cn_namelen + 1, M_TEMP, M_WAITOK);
1458 memcpy(tname, tcnp->cn_nameptr, tcnp->cn_namelen);
1459 tname[tcnp->cn_namelen] = '\0';
1460
1461
1462 AFS_GLOCK();
1463 /* XXX use "from" or "to" creds? NFS uses "to" creds */
1464 error =
1465 afs_rename(VTOAFS(fdvp), fname, VTOAFS(tdvp), tname, cn_cred(tcnp));
1466
1467 #if !defined(AFS_DARWIN80_ENV)
1468 AFS_GUNLOCK();
1469 VOP_UNLOCK(fvp, 0, p);
1470 if (error)
1471 goto abortit; /* XXX */
1472 if (tdvp == tvp)
1473 vrele(tdvp);
1474 else
1475 vput(tdvp);
1476 if (tvp)
1477 vput(tvp);
1478 vrele(fdvp);
1479 vrele(fvp);
1480 #else
1481 if (error == EXDEV) {
1482 struct brequest *tb;
1483 struct afs_uspc_param mvReq;
1484 struct vcache *tvc;
1485 struct vcache *fvc = VTOAFS(fdvp);
1486 int code = 0;
1487 struct afs_fakestat_state fakestate;
1488 int fakestatdone = 0;
1489
1490 tvc = VTOAFS(tdvp);
1491
1492 /* unrewritten mount point? */
1493 if (tvc->mvstat == AFS_MVSTAT_MTPT) {
1494 if (tvc->mvid.target_root && (tvc->f.states & CMValid)) {
1495 struct vrequest treq;
1496
1497 afs_InitFakeStat(&fakestate);
1498 code = afs_InitReq(&treq, vop_cred);
1499 if (!code) {
1500 fakestatdone = 1;
1501 code = afs_EvalFakeStat(&tvc, &fakestate, &treq);
1502 } else
1503 afs_PutFakeStat(&fakestate);
1504 }
1505 }
1506
1507 if (!code) {
1508 /* at some point in the future we should allow other types */
1509 mvReq.reqtype = AFS_USPC_UMV;
1510 mvReq.req.umv.id = afs_cr_uid(cn_cred(tcnp));
1511 mvReq.req.umv.idtype = IDTYPE_UID;
1512 mvReq.req.umv.sCell = fvc->f.fid.Cell;
1513 mvReq.req.umv.sVolume = fvc->f.fid.Fid.Volume;
1514 mvReq.req.umv.sVnode = fvc->f.fid.Fid.Vnode;
1515 mvReq.req.umv.sUnique = fvc->f.fid.Fid.Unique;
1516 mvReq.req.umv.dCell = tvc->f.fid.Cell;
1517 mvReq.req.umv.dVolume = tvc->f.fid.Fid.Volume;
1518 mvReq.req.umv.dVnode = tvc->f.fid.Fid.Vnode;
1519 mvReq.req.umv.dUnique = tvc->f.fid.Fid.Unique;
1520
1521 /*
1522 * su %d -c mv /afs/.:mount/%d:%d:%d:%d/%s
1523 * /afs/.:mount/%d:%d:%d:%d/%s where:
1524 * mvReq.req.umv.id, fvc->f.fid.Cell, fvc->f.fid.Fid.Volume,
1525 * fvc->f.fid.Fid.Vnode, fvc->f.fid.Fid.Unique, fname,
1526 * tvc->f.fid.Cell, tvc->f.fid.Fid.Volume, tvc->f.fid.Fid.Vnode,
1527 * tvc->f.fid.Fid.Unique, tname
1528 */
1529
1530 tb = afs_BQueue(BOP_MOVE, NULL, 0, 1, cn_cred(tcnp),
1531 0L, 0L, &mvReq, fname, tname);
1532 /* wait to collect result */
1533 while ((tb->flags & BUVALID) == 0) {
1534 tb->flags |= BUWAIT;
1535 afs_osi_Sleep(tb);
1536 }
1537 /* if we succeeded, clear the error. otherwise, EXDEV */
1538 if (mvReq.retval == 0)
1539 error = 0;
1540
1541 afs_BRelease(tb);
1542 }
1543
1544 if (fakestatdone)
1545 afs_PutFakeStat(&fakestate);
1546 }
1547 AFS_GUNLOCK();
1548
1549 cache_purge(fdvp);
1550 cache_purge(fvp);
1551 cache_purge(tdvp);
1552 if (tvp) {
1553 cache_purge(tvp);
1554 if (!error) {
1555 vnode_recycle(tvp);
1556 }
1557 }
1558 if (!error)
1559 cache_enter(tdvp, fvp, tcnp);
1560 #endif
1561 FREE(fname, M_TEMP);
1562 FREE(tname, M_TEMP);
1563 return error;
1564 }
1565
1566 int
1567 afs_vop_mkdir(ap)
1568 struct VOPPROT(mkdir_args) /* {
1569 * struct vnode *a_dvp;
1570 * struct vnode **a_vpp;
1571 * struct componentname *a_cnp;
1572 * struct vattr *a_vap;
1573 * } */ *ap;
1574 {
1575 struct vnode *dvp = ap->a_dvp;
1576 struct vattr *vap = ap->a_vap;
1577 int error = 0;
1578 struct vcache *vcp;
1579 struct proc *p;
1580
1581 GETNAME();
1582 p = vop_cn_proc;
1583 #if defined(DIAGNOSTIC) && !defined(AFS_DARWIN80_ENV)
1584 if ((cnp->cn_flags & HASBUF) == 0)
1585 panic("afs_vop_mkdir: no name");
1586 #endif
1587 AFS_GLOCK();
1588 error = afs_mkdir(VTOAFS(dvp), name, vap, &vcp, vop_cn_cred);
1589 AFS_GUNLOCK();
1590 if (error) {
1591 #ifndef AFS_DARWIN80_ENV
1592 VOP_ABORTOP(dvp, cnp);
1593 vput(dvp);
1594 #endif
1595 DROPNAME();
1596 return (error);
1597 }
1598 if (vcp) {
1599 #ifdef AFS_DARWIN80_ENV
1600 afs_darwin_finalizevnode(vcp, ap->a_dvp, ap->a_cnp, 0, 0);
1601 #endif
1602 *ap->a_vpp = AFSTOV(vcp);
1603 #ifndef AFS_DARWIN80_ENV /* XXX needed for multi-mount thing, but can't have it yet */
1604 (*ap->a_vpp)->v_vfsp = dvp->v_vfsp;
1605 vn_lock(*ap->a_vpp, LK_EXCLUSIVE | LK_RETRY, p);
1606 #endif
1607 } else
1608 *ap->a_vpp = 0;
1609 DROPNAME();
1610 #ifndef AFS_DARWIN80_ENV
1611 FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
1612 vput(dvp);
1613 #endif
1614 return error;
1615 }
1616
1617 int
1618 afs_vop_rmdir(ap)
1619 struct VOPPROT(rmdir_args) /* {
1620 * struct vnode *a_dvp;
1621 * struct vnode *a_vp;
1622 * struct componentname *a_cnp;
1623 * } */ *ap;
1624 {
1625 int error = 0;
1626 struct vnode *vp = ap->a_vp;
1627 struct vnode *dvp = ap->a_dvp;
1628
1629 GETNAME();
1630 if (dvp == vp) {
1631 #ifndef AFS_DARWIN80_ENV
1632 vrele(dvp);
1633 vput(vp);
1634 FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
1635 #endif
1636 DROPNAME();
1637 return (EINVAL);
1638 }
1639
1640 AFS_GLOCK();
1641 error = afs_rmdir(VTOAFS(dvp), name, vop_cn_cred);
1642 AFS_GUNLOCK();
1643 DROPNAME();
1644 cache_purge(dvp);
1645 cache_purge(vp);
1646 #ifndef AFS_DARWIN80_ENV
1647 vput(dvp);
1648 vput(vp);
1649 #endif
1650 return error;
1651 }
1652
1653 int
1654 afs_vop_symlink(ap)
1655 struct VOPPROT(symlink_args) /* {
1656 * struct vnode *a_dvp;
1657 * struct vnode **a_vpp;
1658 * struct componentname *a_cnp;
1659 * struct vattr *a_vap;
1660 * char *a_target;
1661 * } */ *ap;
1662 {
1663 struct vnode *dvp = ap->a_dvp;
1664 struct vcache *pvc = NULL;
1665 int error = 0;
1666
1667 GETNAME();
1668 AFS_GLOCK();
1669 error = afs_symlink(VTOAFS(dvp), name, ap->a_vap, ap->a_target, &pvc,
1670 vop_cn_cred);
1671 AFS_GUNLOCK();
1672 #ifndef AFS_DARWIN80_ENV
1673 FREE_ZONE(cnp->cn_pnbuf, cnp->cn_pnlen, M_NAMEI);
1674 vput(dvp);
1675 #endif
1676 *ap->a_vpp = NULL;
1677 if (!error) {
1678 error = afs_darwin_finalizevnode(pvc, dvp, ap->a_cnp, 0, 0);
1679 if (!error)
1680 *ap->a_vpp = AFSTOV(pvc);
1681 }
1682 DROPNAME();
1683 return error;
1684 }
1685
1686 int
1687 afs_vop_readdir(ap)
1688 struct VOPPROT(readdir_args) /* {
1689 * struct vnode *a_vp;
1690 * struct uio *a_uio;
1691 * struct ucred *a_cred;
1692 * int *a_eofflag;
1693 * u_long *a_cookies;
1694 * int ncookies;
1695 * } */ *ap;
1696 {
1697 int error;
1698 off_t off;
1699 /* printf("readdir %x cookies %x ncookies %d\n", ap->a_vp, ap->a_cookies,
1700 ap->a_ncookies); */
1701 #ifdef AFS_DARWIN80_ENV
1702 /* too much work for now */
1703 /* should only break nfs exports */
1704 if (ap->a_flags & (VNODE_READDIR_EXTENDED | VNODE_READDIR_REQSEEKOFF))
1705 return (EINVAL);
1706 #endif
1707 off = AFS_UIO_OFFSET(ap->a_uio);
1708 AFS_GLOCK();
1709 error =
1710 afs_readdir(VTOAFS(ap->a_vp), ap->a_uio, vop_cred, ap->a_eofflag);
1711 AFS_GUNLOCK();
1712 #ifndef AFS_DARWIN80_ENV
1713 if (!error && ap->a_ncookies != NULL) {
1714 struct uio *uio = ap->a_uio;
1715 const struct dirent *dp, *dp_start, *dp_end;
1716 int ncookies;
1717 u_long *cookies, *cookiep;
1718
1719 if (uio->uio_segflg != UIO_SYSSPACE || uio->uio_iovcnt != 1)
1720 panic("afs_readdir: burned cookies");
1721 dp = (const struct dirent *)
1722 ((const char *)uio->uio_iov->iov_base - (uio->uio_offset - off));
1723
1724 dp_end = (const struct dirent *)uio->uio_iov->iov_base;
1725 for (dp_start = dp, ncookies = 0; dp < dp_end;
1726 dp = (const struct dirent *)((const char *)dp + dp->d_reclen))
1727 ncookies++;
1728
1729 MALLOC(cookies, u_long *, ncookies * sizeof(u_long), M_TEMP,
1730 M_WAITOK);
1731 for (dp = dp_start, cookiep = cookies; dp < dp_end;
1732 dp = (const struct dirent *)((const char *)dp + dp->d_reclen)) {
1733 off += dp->d_reclen;
1734 *cookiep++ = off;
1735 }
1736 *ap->a_cookies = cookies;
1737 *ap->a_ncookies = ncookies;
1738 }
1739 #endif
1740
1741 return error;
1742 }
1743
1744 int
1745 afs_vop_readlink(ap)
1746 struct VOPPROT(readlink_args) /* {
1747 * struct vnode *a_vp;
1748 * struct uio *a_uio;
1749 * struct ucred *a_cred;
1750 * } */ *ap;
1751 {
1752 int error;
1753 /* printf("readlink %x\n", ap->a_vp);*/
1754 AFS_GLOCK();
1755 error = afs_readlink(VTOAFS(ap->a_vp), ap->a_uio, vop_cred);
1756 AFS_GUNLOCK();
1757 return error;
1758 }
1759
1760 extern int prtactive;
1761
1762 int
1763 afs_vop_inactive(ap)
1764 struct VOPPROT(inactive_args) /* {
1765 * struct vnode *a_vp;
1766 * struct proc *a_p;
1767 * } */ *ap;
1768 {
1769 struct vnode *vp = ap->a_vp;
1770 struct vcache *tvc = VTOAFS(vp);
1771 #ifndef AFS_DARWIN80_ENV
1772 if (prtactive && vp->v_usecount != 0)
1773 vprint("afs_vop_inactive(): pushing active", vp);
1774 #endif
1775 if (tvc) {
1776 #ifdef AFS_DARWIN80_ENV
1777 int unlinked = tvc->f.states & CUnlinked;
1778 #endif
1779 AFS_GLOCK();
1780 afs_InactiveVCache(tvc, 0); /* decrs ref counts */
1781 AFS_GUNLOCK();
1782 #ifdef AFS_DARWIN80_ENV
1783 if (unlinked) {
1784 vnode_recycle(vp);
1785 cache_purge(vp);
1786 }
1787 #endif
1788 }
1789 #ifndef AFS_DARWIN80_ENV
1790 VOP_UNLOCK(vp, 0, ap->a_p);
1791 #endif
1792 return 0;
1793 }
1794
1795 int
1796 afs_vop_reclaim(ap)
1797 struct VOPPROT(reclaim_args) /* {
1798 * struct vnode *a_vp;
1799 * } */ *ap;
1800 {
1801 int error = 0;
1802 int sl, writelocked;
1803 struct vnode *vp = ap->a_vp;
1804 struct vcache *tvc = VTOAFS(vp);
1805
1806 osi_Assert(!ISAFS_GLOCK());
1807 cache_purge(vp); /* just in case... */
1808 if (tvc) {
1809 AFS_GLOCK();
1810 writelocked = (0 == NBObtainWriteLock(&afs_xvcache, 335));
1811 if (!writelocked) {
1812 ObtainWriteLock(&afs_xvreclaim, 176);
1813 #ifdef AFS_DARWIN80_ENV
1814 vnode_clearfsnode(AFSTOV(tvc));
1815 vnode_removefsref(AFSTOV(tvc));
1816 #else
1817 tvc->v->v_data = NULL; /* remove from vnode */
1818 #endif
1819 AFSTOV(tvc) = NULL; /* also drop the ptr to vnode */
1820 tvc->f.states |= CVInit; /* also CDeadVnode? */
1821 tvc->nextfree = ReclaimedVCList;
1822 ReclaimedVCList = tvc;
1823 ReleaseWriteLock(&afs_xvreclaim);
1824 } else {
1825 error = afs_FlushVCache(tvc, &sl); /* toss our stuff from vnode */
1826 if (tvc->f.states & (CVInit
1827 #ifdef AFS_DARWIN80_ENV
1828 | CDeadVnode
1829 #endif
1830 )) {
1831 tvc->f.states &= ~(CVInit
1832 #ifdef AFS_DARWIN80_ENV
1833 | CDeadVnode
1834 #endif
1835 );
1836 afs_osi_Wakeup(&tvc->f.states);
1837 }
1838 if (!error && vnode_fsnode(vp))
1839 panic("afs_reclaim: vnode not cleaned");
1840 if (!error && (tvc->v != NULL))
1841 panic("afs_reclaim: vcache not cleaned");
1842 ReleaseWriteLock(&afs_xvcache);
1843 }
1844 AFS_GUNLOCK();
1845 }
1846 return error;
1847 }
1848
1849 /*
1850 * Return POSIX pathconf information applicable to ufs filesystems.
1851 */
1852 afs_vop_pathconf(ap)
1853 struct VOPPROT(pathconf_args) /* {
1854 * struct vnode *a_vp;
1855 * int a_name;
1856 * int *a_retval;
1857 * } */ *ap;
1858 {
1859 AFS_STATCNT(afs_cntl);
1860 switch (ap->a_name) {
1861 case _PC_LINK_MAX:
1862 *ap->a_retval = LINK_MAX;
1863 break;
1864 case _PC_NAME_MAX:
1865 *ap->a_retval = NAME_MAX;
1866 break;
1867 case _PC_PATH_MAX:
1868 *ap->a_retval = PATH_MAX;
1869 break;
1870 case _PC_CHOWN_RESTRICTED:
1871 *ap->a_retval = 1;
1872 break;
1873 case _PC_NO_TRUNC:
1874 *ap->a_retval = 1;
1875 break;
1876 case _PC_PIPE_BUF:
1877 return EINVAL;
1878 break;
1879 case _PC_NAME_CHARS_MAX:
1880 *ap->a_retval = NAME_MAX;
1881 break;
1882 case _PC_CASE_SENSITIVE:
1883 *ap->a_retval = 1;
1884 break;
1885 case _PC_CASE_PRESERVING:
1886 *ap->a_retval = 1;
1887 break;
1888 default:
1889 return EINVAL;
1890 }
1891 return 0;
1892 }
1893
1894 /*
1895 * Advisory record locking support (fcntl() POSIX style)
1896 */
1897 int
1898 afs_vop_advlock(ap)
1899 struct VOPPROT(advlock_args) /* {
1900 * struct vnode *a_vp;
1901 * caddr_t a_id;
1902 * int a_op;
1903 * struct flock *a_fl;
1904 * int a_flags;
1905 * } */ *ap;
1906 {
1907 int error;
1908 struct ucred *tcr;
1909 int clid;
1910 int op;
1911 #ifdef AFS_DARWIN80_ENV
1912 proc_t p;
1913 tcr=vop_cred;
1914 #else
1915 struct proc *p = current_proc();
1916 struct ucred cr;
1917 pcred_readlock(p);
1918 cr = *p->p_cred->pc_ucred;
1919 pcred_unlock(p);
1920 tcr=&cr;
1921 #endif
1922 if (ap->a_flags & F_POSIX) {
1923 #ifdef AFS_DARWIN80_ENV
1924 p = (proc_t) ap->a_id;
1925 clid = proc_pid(p);
1926 #else
1927 p = (struct proc *) ap->a_id;
1928 clid = p->p_pid;
1929 #endif
1930 } else {
1931 clid = (int)ap->a_id;
1932 }
1933 if (ap->a_op == F_UNLCK) {
1934 op = F_SETLK;
1935 } else if (ap->a_op == F_SETLK && ap->a_flags & F_WAIT) {
1936 op = F_SETLKW;
1937 } else {
1938 op = ap->a_op;
1939 }
1940 AFS_GLOCK();
1941 error = afs_lockctl(VTOAFS(ap->a_vp), ap->a_fl, op, tcr, clid);
1942 AFS_GUNLOCK();
1943 return error;
1944 }
1945
1946 int
1947 afs_vop_blktooff(ap)
1948 struct VOPPROT(blktooff_args) /* {
1949 * struct vnode *a_vp;
1950 * daddr_t a_lblkno;
1951 * off_t *a_offset;
1952 * } */ *ap;
1953 {
1954 *ap->a_offset = (off_t) (ap->a_lblkno * DEV_BSIZE);
1955 return 0;
1956 }
1957
1958 int
1959 afs_vop_offtoblk(ap)
1960 struct VOPPROT(offtoblk_args) /* {
1961 * struct vnode *a_vp;
1962 * off_t a_offset;
1963 * daddr_t *a_lblkno;
1964 * } */ *ap;
1965 {
1966 *ap->a_lblkno = (daddr_t) (ap->a_offset / DEV_BSIZE);
1967
1968 return (0);
1969 }
1970
1971 #ifndef AFS_DARWIN80_ENV
1972 int
1973 afs_vop_lock(ap)
1974 struct VOPPROT(lock_args) /* {
1975 * struct vnode *a_vp;
1976 * } */ *ap;
1977 {
1978 struct vnode *vp = ap->a_vp;
1979 struct vcache *avc = VTOAFS(vp);
1980
1981 if (vp->v_tag == VT_NON)
1982 return (ENOENT);
1983
1984 return (lockmgr(&avc->rwlock, ap->a_flags, &vp->v_interlock, ap->a_p));
1985 }
1986
1987 int
1988 afs_vop_unlock(ap)
1989 struct VOPPROT(unlock_args) /* {
1990 * struct vnode *a_vp;
1991 * } */ *ap;
1992 {
1993 struct vnode *vp = ap->a_vp;
1994 struct vcache *avc = VTOAFS(vp);
1995
1996 return (lockmgr
1997 (&avc->rwlock, ap->a_flags | LK_RELEASE, &vp->v_interlock,
1998 ap->a_p));
1999
2000 }
2001
2002 int
2003 afs_vop_truncate(ap)
2004 struct VOPPROT(truncate_args) /* {
2005 * struct vnode *a_vp;
2006 * off_t a_length;
2007 * int a_flags;
2008 * struct ucred *a_cred;
2009 * struct proc *a_p;
2010 * } */ *ap;
2011 {
2012 /* printf("stray afs_vop_truncate\n"); */
2013 return ENOTSUP;
2014 }
2015
2016 int
2017 afs_vop_update(ap)
2018 struct VOPPROT(update_args) /* {
2019 * struct vnode *a_vp;
2020 * struct timeval *a_access;
2021 * struct timeval *a_modify;
2022 * int a_waitfor;
2023 * } */ *ap;
2024 {
2025 /* printf("stray afs_vop_update\n"); */
2026 return ENOTSUP;
2027 }
2028
2029 int
2030 afs_vop_bmap(ap)
2031 struct VOPPROT(bmap_args) /* {
2032 * struct vnode *a_vp;
2033 * daddr_t a_bn;
2034 * struct vnode **a_vpp;
2035 * daddr_t *a_bnp;
2036 * int *a_runp;
2037 * int *a_runb;
2038 * } */ *ap;
2039 {
2040 int error;
2041 if (ap->a_bnp) {
2042 *ap->a_bnp = ap->a_bn * (PAGE_SIZE / DEV_BSIZE);
2043 }
2044 if (ap->a_vpp) {
2045 *ap->a_vpp = ap->a_vp;
2046 }
2047 if (ap->a_runp != NULL)
2048 *ap->a_runp = 0;
2049 #ifdef notyet
2050 if (ap->a_runb != NULL)
2051 *ap->a_runb = 0;
2052 #endif
2053
2054 return 0;
2055 }
2056
2057 int
2058 afs_vop_strategy(ap)
2059 struct VOPPROT(strategy_args) /* {
2060 * struct buf *a_bp;
2061 * } */ *ap;
2062 {
2063 int error;
2064 AFS_GLOCK();
2065 error = afs_ustrategy(ap->a_bp);
2066 AFS_GUNLOCK();
2067 return error;
2068 }
2069
2070 int
2071 afs_vop_print(ap)
2072 struct VOPPROT(print_args) /* {
2073 * struct vnode *a_vp;
2074 * } */ *ap;
2075 {
2076 struct vnode *vp = ap->a_vp;
2077 struct vcache *vc = VTOAFS(ap->a_vp);
2078 int s = vc->f.states;
2079 printf("tag %d, fid: %ld.%x.%x.%x, opens %d, writers %d", vp->v_tag,
2080 vc->f.fid.Cell, vc->f.fid.Fid.Volume, vc->f.fid.Fid.Vnode,
2081 vc->f.fid.Fid.Unique, vc->opens, vc->execsOrWriters);
2082 printf("\n states%s%s%s%s%s", (s & CStatd) ? " statd" : "",
2083 (s & CRO) ? " readonly" : "", (s & CDirty) ? " dirty" : "",
2084 (s & CMAPPED) ? " mapped" : "",
2085 (s & CVFlushed) ? " flush in progress" : "");
2086 if (UBCISVALID(vp)) {
2087 printf("\n UBC: ");
2088 if (UBCINFOEXISTS(vp)) {
2089 printf("exists, ");
2090 printf("refs %d%s%s", vp->v_ubcinfo->ui_refcount,
2091 ubc_issetflags(vp, UI_HASOBJREF) ? " HASOBJREF" : "",
2092 ubc_issetflags(vp, UI_WASMAPPED) ? " WASMAPPED" : "");
2093 } else
2094 printf("does not exist");
2095 }
2096 printf("\n");
2097 return 0;
2098 }
2099
2100 int
2101 afs_vop_islocked(ap)
2102 struct VOPPROT(islocked_args) /* {
2103 * struct vnode *a_vp;
2104 * } */ *ap;
2105 {
2106 struct vcache *vc = VTOAFS(ap->a_vp);
2107 return lockstatus(&vc->rwlock);
2108 }
2109
2110 int
2111 afs_vop_cmap(ap)
2112 struct VOPPROT(cmap_args) /* {
2113 * struct vnode *a_vp;
2114 * off_t a_foffset;
2115 * size_t a_size;
2116 * daddr_t *a_bpn;
2117 * size_t *a_run;
2118 * void *a_poff;
2119 * } */ *ap;
2120 {
2121 *ap->a_bpn = (daddr_t) (ap->a_foffset / DEV_BSIZE);
2122 *ap->a_run = MAX(ap->a_size, AFS_CHUNKSIZE(ap->a_foffset));
2123 return 0;
2124 }
2125 #endif
2126
2127 int
2128 afs_darwin_getnewvnode(struct vcache *avc)
2129 {
2130 #ifdef AFS_DARWIN80_ENV
2131 vnode_t vp;
2132 int error, dead;
2133 struct vnode_fsparam par;
2134
2135 memset(&par, 0, sizeof(struct vnode_fsparam));
2136 par.vnfs_vtype = VNON;
2137 par.vnfs_vops = afs_dead_vnodeop_p;
2138 par.vnfs_flags = VNFS_NOCACHE|VNFS_CANTCACHE;
2139 par.vnfs_mp = afs_globalVFS;
2140 par.vnfs_fsnode = avc;
2141
2142 error = vnode_create(VNCREATE_FLAVOR, VCREATESIZE, &par, &vp);
2143 if (!error) {
2144 vnode_addfsref(vp);
2145 vnode_ref(vp);
2146 avc->v = vp;
2147 vnode_recycle(vp); /* terminate as soon as iocount drops */
2148 avc->f.states |= CDeadVnode;
2149 }
2150 return error;
2151 #else
2152 while (getnewvnode(VT_AFS, afs_globalVFS, afs_vnodeop_p, &avc->v)) {
2153 /* no vnodes available, force an alloc (limits be damned)! */
2154 printf("failed to get vnode\n");
2155 }
2156 avc->v->v_data = (void *)avc;
2157 return 0;
2158 #endif
2159 }
2160 #ifdef AFS_DARWIN80_ENV
2161 /* if this fails, then tvc has been unrefed and may have been freed.
2162 Don't touch! */
2163 int
2164 afs_darwin_finalizevnode(struct vcache *avc, struct vnode *dvp,
2165 struct componentname *cnp, int isroot, int locked)
2166 {
2167 vnode_t ovp;
2168 vnode_t nvp;
2169 int error;
2170 struct vnode_fsparam par;
2171
2172 if (!locked) {
2173 AFS_GLOCK();
2174 ObtainWriteLock(&avc->lock,325);
2175 }
2176 ovp = AFSTOV(avc);
2177
2178 if (!(avc->f.states & CDeadVnode) && vnode_vtype(ovp) != VNON) {
2179 AFS_GUNLOCK();
2180 #if 0 /* unsupported */
2181 if (dvp && cnp)
2182 vnode_update_identity(ovp, dvp, cnp->cn_nameptr, cnp->cn_namelen,
2183 cnp->cn_hash,
2184 VNODE_UPDATE_PARENT|VNODE_UPDATE_NAME);
2185 #endif
2186 /* Can end up in reclaim... drop GLOCK */
2187 vnode_rele(ovp);
2188 AFS_GLOCK();
2189 if (!locked) {
2190 ReleaseWriteLock(&avc->lock);
2191 AFS_GUNLOCK();
2192 }
2193 return 0;
2194 }
2195
2196 if ((avc->f.states & CDeadVnode) && vnode_vtype(ovp) != VNON)
2197 panic("vcache %p should not be CDeadVnode", avc);
2198 AFS_GUNLOCK();
2199 memset(&par, 0, sizeof(struct vnode_fsparam));
2200 par.vnfs_mp = afs_globalVFS;
2201 par.vnfs_vtype = avc->f.m.Type;
2202 par.vnfs_vops = afs_vnodeop_p;
2203 par.vnfs_filesize = avc->f.m.Length;
2204 par.vnfs_fsnode = avc;
2205 par.vnfs_dvp = dvp;
2206 if (cnp && (cnp->cn_flags & ISDOTDOT) == 0)
2207 par.vnfs_cnp = cnp;
2208 if (!dvp || !cnp || (cnp->cn_flags & MAKEENTRY) == 0)
2209 par.vnfs_flags = VNFS_NOCACHE;
2210 if (isroot)
2211 par.vnfs_markroot = 1;
2212 error = vnode_create(VNCREATE_FLAVOR, VCREATESIZE, &par, &nvp);
2213 if (!error) {
2214 vnode_addfsref(nvp);
2215 if ((avc->f.states & CDeadVnode) && vnode_vtype(ovp) != VNON)
2216 printf("vcache %p should not be CDeadVnode", avc);
2217 if (avc->v == ovp) {
2218 if (!(avc->f.states & CVInit)) {
2219 vnode_clearfsnode(ovp);
2220 vnode_removefsref(ovp);
2221 }
2222 /* we're discarding on a fixup. mark for recycle */
2223 if (!(avc->f.states & CDeadVnode))
2224 vnode_recycle(ovp);
2225 }
2226 avc->v = nvp;
2227 avc->f.states &=~ CDeadVnode;
2228 /* If we were carrying an extra ref for dirty, hold/push it. */
2229 if (avc->f.ddirty_flags) {
2230 vnode_get(nvp);
2231 vnode_ref(nvp);
2232 }
2233 /* If we were carrying an extra ref for shadow, hold/push it. */
2234 if (avc->f.shadow.vnode) {
2235 vnode_get(nvp);
2236 vnode_ref(nvp);
2237 }
2238 }
2239 /* Drop any extra dirty ref on the old vnode */
2240 if (avc->f.ddirty_flags) {
2241 vnode_put(ovp);
2242 vnode_rele(ovp);
2243 }
2244 /* Drop any extra shadow ref on the old vnode */
2245 if (avc->f.shadow.vnode) {
2246 vnode_put(ovp);
2247 vnode_rele(ovp);
2248 }
2249 /* If it's ref'd still, unmark stat'd to force new lookup */
2250 if ((vnode_vtype(ovp) != avc->f.m.Type) && VREFCOUNT_GT(avc, 1))
2251 avc->f.states &= ~CStatd;
2252
2253 vnode_put(ovp);
2254 vnode_rele(ovp);
2255 AFS_GLOCK();
2256 if (!locked)
2257 ReleaseWriteLock(&avc->lock);
2258 if (!error)
2259 afs_osi_Wakeup(&avc->f.states);
2260 if (!locked)
2261 AFS_GUNLOCK();
2262 return error;
2263 }
2264 #endif
openafs packaging