Commit | Line | Data |
---|---|---|
805e021f CE |
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 |