?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
etc/services - sync with NetBSD-8
[minix.git] / sys / fs / puffs / puffs_vnops.c
blobcdd75fef2bbd0f339ece78ffe622d799f199ebdc
1 /* $NetBSD: puffs_vnops.c,v 1.203 2015/04/20 23:03:08 riastradh Exp $ */
2
3 /*
4 * Copyright (c) 2005, 2006, 2007 Antti Kantee. All Rights Reserved.
5 *
6 * Development of this software was supported by the
7 * Google Summer of Code program and the Ulla Tuominen Foundation.
8 * The Google SoC project was mentored by Bill Studenmund.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
20 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
25 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32 #include <sys/cdefs.h>
33 __KERNEL_RCSID(0, "$NetBSD: puffs_vnops.c,v 1.203 2015/04/20 23:03:08 riastradh Exp $");
34
35 #include <sys/param.h>
36 #include <sys/buf.h>
37 #include <sys/lockf.h>
38 #include <sys/malloc.h>
39 #include <sys/mount.h>
40 #include <sys/namei.h>
41 #include <sys/vnode.h>
42 #include <sys/proc.h>
43 #include <sys/kernel.h> /* For hz, hardclock_ticks */
44
45 #include <uvm/uvm.h>
46
47 #include <fs/puffs/puffs_msgif.h>
48 #include <fs/puffs/puffs_sys.h>
49
50 #include <miscfs/fifofs/fifo.h>
51 #include <miscfs/genfs/genfs.h>
52 #include <miscfs/specfs/specdev.h>
53
54 int puffs_vnop_lookup(void *);
55 int puffs_vnop_create(void *);
56 int puffs_vnop_access(void *);
57 int puffs_vnop_mknod(void *);
58 int puffs_vnop_open(void *);
59 int puffs_vnop_close(void *);
60 int puffs_vnop_getattr(void *);
61 int puffs_vnop_setattr(void *);
62 int puffs_vnop_reclaim(void *);
63 int puffs_vnop_readdir(void *);
64 int puffs_vnop_poll(void *);
65 int puffs_vnop_fsync(void *);
66 int puffs_vnop_seek(void *);
67 int puffs_vnop_remove(void *);
68 int puffs_vnop_mkdir(void *);
69 int puffs_vnop_rmdir(void *);
70 int puffs_vnop_link(void *);
71 int puffs_vnop_readlink(void *);
72 int puffs_vnop_symlink(void *);
73 int puffs_vnop_rename(void *);
74 int puffs_vnop_read(void *);
75 int puffs_vnop_write(void *);
76 int puffs_vnop_fallocate(void *);
77 int puffs_vnop_fdiscard(void *);
78 int puffs_vnop_fcntl(void *);
79 int puffs_vnop_ioctl(void *);
80 int puffs_vnop_inactive(void *);
81 int puffs_vnop_print(void *);
82 int puffs_vnop_pathconf(void *);
83 int puffs_vnop_advlock(void *);
84 int puffs_vnop_strategy(void *);
85 int puffs_vnop_bmap(void *);
86 int puffs_vnop_mmap(void *);
87 int puffs_vnop_getpages(void *);
88 int puffs_vnop_abortop(void *);
89 int puffs_vnop_getextattr(void *);
90 int puffs_vnop_setextattr(void *);
91 int puffs_vnop_listextattr(void *);
92 int puffs_vnop_deleteextattr(void *);
93
94 int puffs_vnop_spec_read(void *);
95 int puffs_vnop_spec_write(void *);
96 int puffs_vnop_fifo_read(void *);
97 int puffs_vnop_fifo_write(void *);
98
99 int puffs_vnop_checkop(void *);
100
101 #define puffs_vnop_lock genfs_lock
102 #define puffs_vnop_unlock genfs_unlock
103 #define puffs_vnop_islocked genfs_islocked
104
105 int (**puffs_vnodeop_p)(void *);
106 const struct vnodeopv_entry_desc puffs_vnodeop_entries[] = {
107 { &vop_default_desc, vn_default_error },
108 { &vop_lookup_desc, puffs_vnop_lookup }, /* REAL lookup */
109 { &vop_create_desc, puffs_vnop_checkop }, /* create */
110 { &vop_mknod_desc, puffs_vnop_checkop }, /* mknod */
111 { &vop_open_desc, puffs_vnop_open }, /* REAL open */
112 { &vop_close_desc, puffs_vnop_checkop }, /* close */
113 { &vop_access_desc, puffs_vnop_access }, /* REAL access */
114 { &vop_getattr_desc, puffs_vnop_checkop }, /* getattr */
115 { &vop_setattr_desc, puffs_vnop_checkop }, /* setattr */
116 { &vop_read_desc, puffs_vnop_checkop }, /* read */
117 { &vop_write_desc, puffs_vnop_checkop }, /* write */
118 { &vop_fallocate_desc, puffs_vnop_fallocate }, /* fallocate */
119 { &vop_fdiscard_desc, puffs_vnop_fdiscard }, /* fdiscard */
120 { &vop_fsync_desc, puffs_vnop_fsync }, /* REAL fsync */
121 { &vop_seek_desc, puffs_vnop_checkop }, /* seek */
122 { &vop_remove_desc, puffs_vnop_checkop }, /* remove */
123 { &vop_link_desc, puffs_vnop_checkop }, /* link */
124 { &vop_rename_desc, puffs_vnop_checkop }, /* rename */
125 { &vop_mkdir_desc, puffs_vnop_checkop }, /* mkdir */
126 { &vop_rmdir_desc, puffs_vnop_checkop }, /* rmdir */
127 { &vop_symlink_desc, puffs_vnop_checkop }, /* symlink */
128 { &vop_readdir_desc, puffs_vnop_checkop }, /* readdir */
129 { &vop_readlink_desc, puffs_vnop_checkop }, /* readlink */
130 { &vop_getpages_desc, puffs_vnop_checkop }, /* getpages */
131 { &vop_putpages_desc, genfs_putpages }, /* REAL putpages */
132 { &vop_pathconf_desc, puffs_vnop_checkop }, /* pathconf */
133 { &vop_advlock_desc, puffs_vnop_advlock }, /* advlock */
134 { &vop_strategy_desc, puffs_vnop_strategy }, /* REAL strategy */
135 { &vop_revoke_desc, genfs_revoke }, /* REAL revoke */
136 { &vop_abortop_desc, puffs_vnop_abortop }, /* REAL abortop */
137 { &vop_inactive_desc, puffs_vnop_inactive }, /* REAL inactive */
138 { &vop_reclaim_desc, puffs_vnop_reclaim }, /* REAL reclaim */
139 { &vop_lock_desc, puffs_vnop_lock }, /* REAL lock */
140 { &vop_unlock_desc, puffs_vnop_unlock }, /* REAL unlock */
141 { &vop_bmap_desc, puffs_vnop_bmap }, /* REAL bmap */
142 { &vop_print_desc, puffs_vnop_print }, /* REAL print */
143 { &vop_islocked_desc, puffs_vnop_islocked }, /* REAL islocked */
144 { &vop_bwrite_desc, genfs_nullop }, /* REAL bwrite */
145 { &vop_mmap_desc, puffs_vnop_mmap }, /* REAL mmap */
146 { &vop_poll_desc, puffs_vnop_poll }, /* REAL poll */
147 { &vop_getextattr_desc, puffs_vnop_getextattr }, /* getextattr */
148 { &vop_setextattr_desc, puffs_vnop_setextattr }, /* setextattr */
149 { &vop_listextattr_desc, puffs_vnop_listextattr }, /* listextattr */
150 { &vop_deleteextattr_desc, puffs_vnop_deleteextattr },/* deleteextattr */
151 #if 0
152 { &vop_openextattr_desc, puffs_vnop_checkop }, /* openextattr */
153 { &vop_closeextattr_desc, puffs_vnop_checkop }, /* closeextattr */
154 #endif
155 { &vop_kqfilter_desc, genfs_eopnotsupp }, /* kqfilter XXX */
156 { NULL, NULL }
157 };
158 const struct vnodeopv_desc puffs_vnodeop_opv_desc =
159 { &puffs_vnodeop_p, puffs_vnodeop_entries };
160
161
162 int (**puffs_specop_p)(void *);
163 const struct vnodeopv_entry_desc puffs_specop_entries[] = {
164 { &vop_default_desc, vn_default_error },
165 { &vop_lookup_desc, spec_lookup }, /* lookup, ENOTDIR */
166 { &vop_create_desc, spec_create }, /* genfs_badop */
167 { &vop_mknod_desc, spec_mknod }, /* genfs_badop */
168 { &vop_open_desc, spec_open }, /* spec_open */
169 { &vop_close_desc, spec_close }, /* spec_close */
170 { &vop_access_desc, puffs_vnop_checkop }, /* access */
171 { &vop_getattr_desc, puffs_vnop_checkop }, /* getattr */
172 { &vop_setattr_desc, puffs_vnop_checkop }, /* setattr */
173 { &vop_read_desc, puffs_vnop_spec_read }, /* update, read */
174 { &vop_write_desc, puffs_vnop_spec_write }, /* update, write */
175 { &vop_fallocate_desc, spec_fallocate }, /* fallocate */
176 { &vop_fdiscard_desc, spec_fdiscard }, /* fdiscard */
177 { &vop_ioctl_desc, spec_ioctl }, /* spec_ioctl */
178 { &vop_fcntl_desc, genfs_fcntl }, /* dummy */
179 { &vop_poll_desc, spec_poll }, /* spec_poll */
180 { &vop_kqfilter_desc, spec_kqfilter }, /* spec_kqfilter */
181 { &vop_revoke_desc, spec_revoke }, /* genfs_revoke */
182 { &vop_mmap_desc, spec_mmap }, /* spec_mmap */
183 { &vop_fsync_desc, spec_fsync }, /* vflushbuf */
184 { &vop_seek_desc, spec_seek }, /* genfs_nullop */
185 { &vop_remove_desc, spec_remove }, /* genfs_badop */
186 { &vop_link_desc, spec_link }, /* genfs_badop */
187 { &vop_rename_desc, spec_rename }, /* genfs_badop */
188 { &vop_mkdir_desc, spec_mkdir }, /* genfs_badop */
189 { &vop_rmdir_desc, spec_rmdir }, /* genfs_badop */
190 { &vop_symlink_desc, spec_symlink }, /* genfs_badop */
191 { &vop_readdir_desc, spec_readdir }, /* genfs_badop */
192 { &vop_readlink_desc, spec_readlink }, /* genfs_badop */
193 { &vop_abortop_desc, spec_abortop }, /* genfs_badop */
194 { &vop_inactive_desc, puffs_vnop_inactive }, /* REAL inactive */
195 { &vop_reclaim_desc, puffs_vnop_reclaim }, /* REAL reclaim */
196 { &vop_lock_desc, puffs_vnop_lock }, /* REAL lock */
197 { &vop_unlock_desc, puffs_vnop_unlock }, /* REAL unlock */
198 { &vop_bmap_desc, spec_bmap }, /* dummy */
199 { &vop_strategy_desc, spec_strategy }, /* dev strategy */
200 { &vop_print_desc, puffs_vnop_print }, /* REAL print */
201 { &vop_islocked_desc, puffs_vnop_islocked }, /* REAL islocked */
202 { &vop_pathconf_desc, spec_pathconf }, /* pathconf */
203 { &vop_advlock_desc, spec_advlock }, /* lf_advlock */
204 { &vop_bwrite_desc, vn_bwrite }, /* bwrite */
205 { &vop_getpages_desc, spec_getpages }, /* genfs_getpages */
206 { &vop_putpages_desc, spec_putpages }, /* genfs_putpages */
207 { &vop_getextattr_desc, puffs_vnop_checkop }, /* getextattr */
208 { &vop_setextattr_desc, puffs_vnop_checkop }, /* setextattr */
209 { &vop_listextattr_desc, puffs_vnop_checkop }, /* listextattr */
210 { &vop_deleteextattr_desc, puffs_vnop_checkop },/* deleteextattr */
211 #if 0
212 { &vop_openextattr_desc, _openextattr }, /* openextattr */
213 { &vop_closeextattr_desc, _closeextattr }, /* closeextattr */
214 #endif
215 { NULL, NULL }
216 };
217 const struct vnodeopv_desc puffs_specop_opv_desc =
218 { &puffs_specop_p, puffs_specop_entries };
219
220
221 int (**puffs_fifoop_p)(void *);
222 const struct vnodeopv_entry_desc puffs_fifoop_entries[] = {
223 { &vop_default_desc, vn_default_error },
224 { &vop_lookup_desc, vn_fifo_bypass }, /* lookup, ENOTDIR */
225 { &vop_create_desc, vn_fifo_bypass }, /* genfs_badop */
226 { &vop_mknod_desc, vn_fifo_bypass }, /* genfs_badop */
227 { &vop_open_desc, vn_fifo_bypass }, /* open */
228 { &vop_close_desc, vn_fifo_bypass }, /* close */
229 { &vop_access_desc, puffs_vnop_checkop }, /* access */
230 { &vop_getattr_desc, puffs_vnop_checkop }, /* getattr */
231 { &vop_setattr_desc, puffs_vnop_checkop }, /* setattr */
232 { &vop_read_desc, puffs_vnop_fifo_read }, /* read, update */
233 { &vop_write_desc, puffs_vnop_fifo_write }, /* write, update */
234 { &vop_fallocate_desc, vn_fifo_bypass }, /* fallocate */
235 { &vop_fdiscard_desc, vn_fifo_bypass }, /* fdiscard */
236 { &vop_ioctl_desc, vn_fifo_bypass }, /* ioctl */
237 { &vop_fcntl_desc, genfs_fcntl }, /* dummy */
238 { &vop_poll_desc, vn_fifo_bypass }, /* poll */
239 { &vop_kqfilter_desc, vn_fifo_bypass }, /* kqfilter */
240 { &vop_revoke_desc, vn_fifo_bypass }, /* genfs_revoke */
241 { &vop_mmap_desc, vn_fifo_bypass }, /* genfs_badop */
242 { &vop_fsync_desc, vn_fifo_bypass }, /* genfs_nullop*/
243 { &vop_seek_desc, vn_fifo_bypass }, /* genfs_badop */
244 { &vop_remove_desc, vn_fifo_bypass }, /* genfs_badop */
245 { &vop_link_desc, vn_fifo_bypass }, /* genfs_badop */
246 { &vop_rename_desc, vn_fifo_bypass }, /* genfs_badop */
247 { &vop_mkdir_desc, vn_fifo_bypass }, /* genfs_badop */
248 { &vop_rmdir_desc, vn_fifo_bypass }, /* genfs_badop */
249 { &vop_symlink_desc, vn_fifo_bypass }, /* genfs_badop */
250 { &vop_readdir_desc, vn_fifo_bypass }, /* genfs_badop */
251 { &vop_readlink_desc, vn_fifo_bypass }, /* genfs_badop */
252 { &vop_abortop_desc, vn_fifo_bypass }, /* genfs_badop */
253 { &vop_inactive_desc, puffs_vnop_inactive }, /* REAL inactive */
254 { &vop_reclaim_desc, puffs_vnop_reclaim }, /* REAL reclaim */
255 { &vop_lock_desc, puffs_vnop_lock }, /* REAL lock */
256 { &vop_unlock_desc, puffs_vnop_unlock }, /* REAL unlock */
257 { &vop_bmap_desc, vn_fifo_bypass }, /* dummy */
258 { &vop_strategy_desc, vn_fifo_bypass }, /* genfs_badop */
259 { &vop_print_desc, puffs_vnop_print }, /* REAL print */
260 { &vop_islocked_desc, puffs_vnop_islocked }, /* REAL islocked */
261 { &vop_pathconf_desc, vn_fifo_bypass }, /* pathconf */
262 { &vop_advlock_desc, vn_fifo_bypass }, /* genfs_einval */
263 { &vop_bwrite_desc, vn_bwrite }, /* bwrite */
264 { &vop_putpages_desc, vn_fifo_bypass }, /* genfs_null_putpages*/
265 #if 0
266 { &vop_openextattr_desc, _openextattr }, /* openextattr */
267 { &vop_closeextattr_desc, _closeextattr }, /* closeextattr */
268 #endif
269 { &vop_getextattr_desc, puffs_vnop_checkop }, /* getextattr */
270 { &vop_setextattr_desc, puffs_vnop_checkop }, /* setextattr */
271 { &vop_listextattr_desc, puffs_vnop_checkop }, /* listextattr */
272 { &vop_deleteextattr_desc, puffs_vnop_checkop }, /* deleteextattr */
273 { NULL, NULL }
274 };
275 const struct vnodeopv_desc puffs_fifoop_opv_desc =
276 { &puffs_fifoop_p, puffs_fifoop_entries };
277
278
279 /* "real" vnode operations */
280 int (**puffs_msgop_p)(void *);
281 const struct vnodeopv_entry_desc puffs_msgop_entries[] = {
282 { &vop_default_desc, vn_default_error },
283 { &vop_create_desc, puffs_vnop_create }, /* create */
284 { &vop_mknod_desc, puffs_vnop_mknod }, /* mknod */
285 { &vop_open_desc, puffs_vnop_open }, /* open */
286 { &vop_close_desc, puffs_vnop_close }, /* close */
287 { &vop_access_desc, puffs_vnop_access }, /* access */
288 { &vop_getattr_desc, puffs_vnop_getattr }, /* getattr */
289 { &vop_setattr_desc, puffs_vnop_setattr }, /* setattr */
290 { &vop_read_desc, puffs_vnop_read }, /* read */
291 { &vop_write_desc, puffs_vnop_write }, /* write */
292 { &vop_seek_desc, puffs_vnop_seek }, /* seek */
293 { &vop_remove_desc, puffs_vnop_remove }, /* remove */
294 { &vop_link_desc, puffs_vnop_link }, /* link */
295 { &vop_rename_desc, puffs_vnop_rename }, /* rename */
296 { &vop_mkdir_desc, puffs_vnop_mkdir }, /* mkdir */
297 { &vop_rmdir_desc, puffs_vnop_rmdir }, /* rmdir */
298 { &vop_symlink_desc, puffs_vnop_symlink }, /* symlink */
299 { &vop_readdir_desc, puffs_vnop_readdir }, /* readdir */
300 { &vop_readlink_desc, puffs_vnop_readlink }, /* readlink */
301 { &vop_print_desc, puffs_vnop_print }, /* print */
302 { &vop_islocked_desc, puffs_vnop_islocked }, /* islocked */
303 { &vop_pathconf_desc, puffs_vnop_pathconf }, /* pathconf */
304 { &vop_getpages_desc, puffs_vnop_getpages }, /* getpages */
305 { NULL, NULL }
306 };
307 const struct vnodeopv_desc puffs_msgop_opv_desc =
308 { &puffs_msgop_p, puffs_msgop_entries };
309
310 /*
311 * for dosetattr / update_va
312 */
313 #define SETATTR_CHSIZE 0x01
314 #define SETATTR_ASYNC 0x02
315
316 #define ERROUT(err) \
317 do { \
318 error = err; \
319 goto out; \
320 } while (/*CONSTCOND*/0)
321
322 /*
323 * This is a generic vnode operation handler. It checks if the necessary
324 * operations for the called vnode operation are implemented by userspace
325 * and either returns a dummy return value or proceeds to call the real
326 * vnode operation from puffs_msgop_v.
327 *
328 * XXX: this should described elsewhere and autogenerated, the complexity
329 * of the vnode operations vectors and their interrelationships is also
330 * getting a bit out of hand. Another problem is that we need this same
331 * information in the fs server code, so keeping the two in sync manually
332 * is not a viable (long term) plan.
333 */
334
335 /* not supported, handle locking protocol */
336 #define CHECKOP_NOTSUPP(op) \
337 case VOP_##op##_DESCOFFSET: \
338 if (pmp->pmp_vnopmask[PUFFS_VN_##op] == 0) \
339 return genfs_eopnotsupp(v); \
340 break
341
342 /* always succeed, no locking */
343 #define CHECKOP_SUCCESS(op) \
344 case VOP_##op##_DESCOFFSET: \
345 if (pmp->pmp_vnopmask[PUFFS_VN_##op] == 0) \
346 return 0; \
347 break
348
349 int
350 puffs_vnop_checkop(void *v)
351 {
352 struct vop_generic_args /* {
353 struct vnodeop_desc *a_desc;
354 spooky mystery contents;
355 } */ *ap = v;
356 struct vnodeop_desc *desc = ap->a_desc;
357 struct puffs_mount *pmp;
358 struct vnode *vp;
359 int offset, rv;
360
361 offset = ap->a_desc->vdesc_vp_offsets[0];
362 #ifdef DIAGNOSTIC
363 if (offset == VDESC_NO_OFFSET)
364 panic("puffs_checkop: no vnode, why did you call me?");
365 #endif
366 vp = *VOPARG_OFFSETTO(struct vnode **, offset, ap);
367 pmp = MPTOPUFFSMP(vp->v_mount);
368
369 DPRINTF_VERBOSE(("checkop call %s (%d), vp %p\n",
370 ap->a_desc->vdesc_name, ap->a_desc->vdesc_offset, vp));
371
372 if (!ALLOPS(pmp)) {
373 switch (desc->vdesc_offset) {
374 CHECKOP_NOTSUPP(CREATE);
375 CHECKOP_NOTSUPP(MKNOD);
376 CHECKOP_NOTSUPP(GETATTR);
377 CHECKOP_NOTSUPP(SETATTR);
378 CHECKOP_NOTSUPP(READ);
379 CHECKOP_NOTSUPP(WRITE);
380 CHECKOP_NOTSUPP(FCNTL);
381 CHECKOP_NOTSUPP(IOCTL);
382 CHECKOP_NOTSUPP(REMOVE);
383 CHECKOP_NOTSUPP(LINK);
384 CHECKOP_NOTSUPP(RENAME);
385 CHECKOP_NOTSUPP(MKDIR);
386 CHECKOP_NOTSUPP(RMDIR);
387 CHECKOP_NOTSUPP(SYMLINK);
388 CHECKOP_NOTSUPP(READDIR);
389 CHECKOP_NOTSUPP(READLINK);
390 CHECKOP_NOTSUPP(PRINT);
391 CHECKOP_NOTSUPP(PATHCONF);
392 CHECKOP_NOTSUPP(GETEXTATTR);
393 CHECKOP_NOTSUPP(SETEXTATTR);
394 CHECKOP_NOTSUPP(LISTEXTATTR);
395 CHECKOP_NOTSUPP(DELETEEXTATTR);
396
397 CHECKOP_SUCCESS(ACCESS);
398 CHECKOP_SUCCESS(CLOSE);
399 CHECKOP_SUCCESS(SEEK);
400
401 case VOP_GETPAGES_DESCOFFSET:
402 if (!EXISTSOP(pmp, READ))
403 return genfs_eopnotsupp(v);
404 break;
405
406 default:
407 panic("puffs_checkop: unhandled vnop %d",
408 desc->vdesc_offset);
409 }
410 }
411
412 rv = VOCALL(puffs_msgop_p, ap->a_desc->vdesc_offset, v);
413
414 DPRINTF_VERBOSE(("checkop return %s (%d), vp %p: %d\n",
415 ap->a_desc->vdesc_name, ap->a_desc->vdesc_offset, vp, rv));
416
417 return rv;
418 }
419
420 static int callremove(struct puffs_mount *, puffs_cookie_t, puffs_cookie_t,
421 struct componentname *);
422 static int callrmdir(struct puffs_mount *, puffs_cookie_t, puffs_cookie_t,
423 struct componentname *);
424 static void callinactive(struct puffs_mount *, puffs_cookie_t, int);
425 static void callreclaim(struct puffs_mount *, puffs_cookie_t, int);
426 static int flushvncache(struct vnode *, off_t, off_t, bool);
427 static void update_va(struct vnode *, struct vattr *, struct vattr *,
428 struct timespec *, struct timespec *, int);
429 static void update_parent(struct vnode *, struct vnode *);
430
431
432 #define PUFFS_ABORT_LOOKUP 1
433 #define PUFFS_ABORT_CREATE 2
434 #define PUFFS_ABORT_MKNOD 3
435 #define PUFFS_ABORT_MKDIR 4
436 #define PUFFS_ABORT_SYMLINK 5
437
438 /*
439 * Press the pani^Wabort button! Kernel resource allocation failed.
440 */
441 static void
442 puffs_abortbutton(struct puffs_mount *pmp, int what,
443 puffs_cookie_t dck, puffs_cookie_t ck, struct componentname *cnp)
444 {
445
446 switch (what) {
447 case PUFFS_ABORT_CREATE:
448 case PUFFS_ABORT_MKNOD:
449 case PUFFS_ABORT_SYMLINK:
450 callremove(pmp, dck, ck, cnp);
451 break;
452 case PUFFS_ABORT_MKDIR:
453 callrmdir(pmp, dck, ck, cnp);
454 break;
455 }
456
457 callinactive(pmp, ck, 0);
458 callreclaim(pmp, ck, 1);
459 }
460
461 /*
462 * Begin vnode operations.
463 *
464 * A word from the keymaster about locks: generally we don't want
465 * to use the vnode locks at all: it creates an ugly dependency between
466 * the userlandia file server and the kernel. But we'll play along with
467 * the kernel vnode locks for now. However, even currently we attempt
468 * to release locks as early as possible. This is possible for some
469 * operations which a) don't need a locked vnode after the userspace op
470 * and b) return with the vnode unlocked. Theoretically we could
471 * unlock-do op-lock for others and order the graph in userspace, but I
472 * don't want to think of the consequences for the time being.
473 */
474
475 #define TTL_TO_TIMEOUT(ts) \
476 (hardclock_ticks + (ts->tv_sec * hz) + (ts->tv_nsec * hz / 1000000000))
477 #define TTL_VALID(ts) \
478 ((ts != NULL) && !((ts->tv_sec == 0) && (ts->tv_nsec == 0)))
479 #define TIMED_OUT(expire) \
480 ((int)((unsigned int)hardclock_ticks - (unsigned int)expire) > 0)
481 int
482 puffs_vnop_lookup(void *v)
483 {
484 struct vop_lookup_v2_args /* {
485 const struct vnodeop_desc *a_desc;
486 struct vnode *a_dvp;
487 struct vnode **a_vpp;
488 struct componentname *a_cnp;
489 } */ *ap = v;
490 PUFFS_MSG_VARS(vn, lookup);
491 struct puffs_mount *pmp;
492 struct componentname *cnp;
493 struct vnode *vp, *dvp, *cvp;
494 struct puffs_node *dpn, *cpn;
495 int isdot;
496 int error;
497
498 pmp = MPTOPUFFSMP(ap->a_dvp->v_mount);
499 cnp = ap->a_cnp;
500 dvp = ap->a_dvp;
501 cvp = NULL;
502 cpn = NULL;
503 *ap->a_vpp = NULL;
504
505 /* r/o fs? we check create later to handle EEXIST */
506 if ((cnp->cn_flags & ISLASTCN)
507 && (dvp->v_mount->mnt_flag & MNT_RDONLY)
508 && (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
509 return EROFS;
510
511 isdot = cnp->cn_namelen == 1 && *cnp->cn_nameptr == '.';
512
513 DPRINTF(("puffs_lookup: \"%s\", parent vnode %p, op: %x\n",
514 cnp->cn_nameptr, dvp, cnp->cn_nameiop));
515
516 /*
517 * If dotdot cache is enabled, add reference to .. and return.
518 */
519 if (PUFFS_USE_DOTDOTCACHE(pmp) && (cnp->cn_flags & ISDOTDOT)) {
520 vp = VPTOPP(ap->a_dvp)->pn_parent;
521 vref(vp);
522
523 *ap->a_vpp = vp;
524 return 0;
525 }
526
527 /*
528 * Check if someone fed it into the cache
529 */
530 if (!isdot && PUFFS_USE_NAMECACHE(pmp)) {
531 int found, iswhiteout;
532
533 found = cache_lookup(dvp, cnp->cn_nameptr, cnp->cn_namelen,
534 cnp->cn_nameiop, cnp->cn_flags,
535 &iswhiteout, ap->a_vpp);
536 if (iswhiteout) {
537 cnp->cn_flags |= ISWHITEOUT;
538 }
539
540 if (found && *ap->a_vpp != NULLVP && PUFFS_USE_FS_TTL(pmp)) {
541 cvp = *ap->a_vpp;
542 cpn = VPTOPP(cvp);
543
544 if (TIMED_OUT(cpn->pn_cn_timeout)) {
545 cache_purge(cvp);
546 /*
547 * cached vnode (cvp) is still referenced
548 * so that we can reuse it upon a new
549 * successful lookup.
550 */
551 *ap->a_vpp = NULL;
552 found = 0;
553 }
554 }
555
556 /*
557 * Do not use negative caching, since the filesystem
558 * provides no TTL for it.
559 */
560 if (found && *ap->a_vpp == NULLVP && PUFFS_USE_FS_TTL(pmp))
561 found = 0;
562
563 if (found) {
564 return *ap->a_vpp == NULLVP ? ENOENT : 0;
565 }
566
567 /*
568 * This is what would have been left in ERROR before
569 * the rearrangement of cache_lookup(). What with all
570 * the macros, I am not sure if this is a dead value
571 * below or not.
572 */
573 error = -1;
574 }
575
576 if (isdot) {
577 /* deal with rename lookup semantics */
578 if (cnp->cn_nameiop == RENAME && (cnp->cn_flags & ISLASTCN))
579 return EISDIR;
580
581 vp = ap->a_dvp;
582 vref(vp);
583 *ap->a_vpp = vp;
584 return 0;
585 }
586
587 if (cvp != NULL) {
588 if (vn_lock(cvp, LK_EXCLUSIVE) != 0) {
589 vrele(cvp);
590 cvp = NULL;
591 } else
592 mutex_enter(&cpn->pn_sizemtx);
593 }
594
595 PUFFS_MSG_ALLOC(vn, lookup);
596 puffs_makecn(&lookup_msg->pvnr_cn, &lookup_msg->pvnr_cn_cred,
597 cnp, PUFFS_USE_FULLPNBUF(pmp));
598
599 if (cnp->cn_flags & ISDOTDOT)
600 VOP_UNLOCK(dvp);
601
602 puffs_msg_setinfo(park_lookup, PUFFSOP_VN,
603 PUFFS_VN_LOOKUP, VPTOPNC(dvp));
604 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_lookup, dvp->v_data, NULL, error);
605 DPRINTF(("puffs_lookup: return of the userspace, part %d\n", error));
606
607 /*
608 * In case of error, there is no new vnode to play with, so be
609 * happy with the NULL value given to vpp in the beginning.
610 * Also, check if this really was an error or the target was not
611 * present. Either treat it as a non-error for CREATE/RENAME or
612 * enter the component into the negative name cache (if desired).
613 */
614 if (error) {
615 error = checkerr(pmp, error, __func__);
616 if (error == ENOENT) {
617 /* don't allow to create files on r/o fs */
618 if ((dvp->v_mount->mnt_flag & MNT_RDONLY)
619 && cnp->cn_nameiop == CREATE) {
620 error = EROFS;
621
622 /* adjust values if we are creating */
623 } else if ((cnp->cn_flags & ISLASTCN)
624 && (cnp->cn_nameiop == CREATE
625 || cnp->cn_nameiop == RENAME)) {
626 error = EJUSTRETURN;
627
628 /* save negative cache entry */
629 } else {
630 if (PUFFS_USE_NAMECACHE(pmp) &&
631 !PUFFS_USE_FS_TTL(pmp))
632 cache_enter(dvp, NULL, cnp->cn_nameptr,
633 cnp->cn_namelen, cnp->cn_flags);
634 }
635 }
636 goto out;
637 }
638
639 /*
640 * Check that we don't get our parent node back, that would cause
641 * a pretty obvious deadlock.
642 */
643 dpn = dvp->v_data;
644 if (lookup_msg->pvnr_newnode == dpn->pn_cookie) {
645 puffs_senderr(pmp, PUFFS_ERR_LOOKUP, EINVAL,
646 "lookup produced parent cookie", lookup_msg->pvnr_newnode);
647 error = EPROTO;
648 goto out;
649 }
650
651 /*
652 * Check if we looked up the cached vnode
653 */
654 vp = NULL;
655 if (cvp && (VPTOPP(cvp)->pn_cookie == lookup_msg->pvnr_newnode)) {
656 int grace;
657
658 /*
659 * Bump grace time of this node so that it does not get
660 * reclaimed too fast. We try to increase a bit more the
661 * lifetime of busiest * nodes - with some limits.
662 */
663 grace = 10 * puffs_sopreq_expire_timeout;
664 cpn->pn_cn_grace = hardclock_ticks + grace;
665 vp = cvp;
666 }
667
668 /*
669 * No cached vnode available, or the cached vnode does not
670 * match the userland cookie anymore: is the node known?
671 */
672 if (vp == NULL) {
673 error = puffs_getvnode(dvp->v_mount,
674 lookup_msg->pvnr_newnode, lookup_msg->pvnr_vtype,
675 lookup_msg->pvnr_size, lookup_msg->pvnr_rdev, &vp);
676 if (error) {
677 puffs_abortbutton(pmp, PUFFS_ABORT_LOOKUP,
678 VPTOPNC(dvp), lookup_msg->pvnr_newnode,
679 ap->a_cnp);
680 goto out;
681 }
682
683 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
684 }
685
686 /*
687 * Update cache and TTL
688 */
689 if (PUFFS_USE_FS_TTL(pmp)) {
690 struct timespec *va_ttl = &lookup_msg->pvnr_va_ttl;
691 struct timespec *cn_ttl = &lookup_msg->pvnr_cn_ttl;
692 update_va(vp, NULL, &lookup_msg->pvnr_va,
693 va_ttl, cn_ttl, SETATTR_CHSIZE);
694 }
695
696 KASSERT(lookup_msg->pvnr_newnode == VPTOPP(vp)->pn_cookie);
697 *ap->a_vpp = vp;
698
699 if (PUFFS_USE_NAMECACHE(pmp))
700 cache_enter(dvp, vp, cnp->cn_nameptr, cnp->cn_namelen,
701 cnp->cn_flags);
702
703 /* XXX */
704 if ((lookup_msg->pvnr_cn.pkcn_flags & REQUIREDIR) == 0)
705 cnp->cn_flags &= ~REQUIREDIR;
706 if (lookup_msg->pvnr_cn.pkcn_consume)
707 cnp->cn_consume = MIN(lookup_msg->pvnr_cn.pkcn_consume,
708 strlen(cnp->cn_nameptr) - cnp->cn_namelen);
709
710 VPTOPP(vp)->pn_nlookup++;
711
712 if (PUFFS_USE_DOTDOTCACHE(pmp) &&
713 (VPTOPP(vp)->pn_parent != dvp))
714 update_parent(vp, dvp);
715
716 out:
717 if (cvp != NULL) {
718 mutex_exit(&cpn->pn_sizemtx);
719
720 if (error || (cvp != vp))
721 vput(cvp);
722 }
723 if (error == 0)
724 VOP_UNLOCK(*ap->a_vpp);
725
726 if (cnp->cn_flags & ISDOTDOT)
727 vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
728
729 DPRINTF(("puffs_lookup: returning %d %p\n", error, *ap->a_vpp));
730 PUFFS_MSG_RELEASE(lookup);
731 return error;
732 }
733
734 #define REFPN_AND_UNLOCKVP(a, b) \
735 do { \
736 mutex_enter(&b->pn_mtx); \
737 puffs_referencenode(b); \
738 mutex_exit(&b->pn_mtx); \
739 VOP_UNLOCK(a); \
740 } while (/*CONSTCOND*/0)
741
742 #define REFPN(b) \
743 do { \
744 mutex_enter(&b->pn_mtx); \
745 puffs_referencenode(b); \
746 mutex_exit(&b->pn_mtx); \
747 } while (/*CONSTCOND*/0)
748
749 #define RELEPN_AND_VP(a, b) \
750 do { \
751 puffs_releasenode(b); \
752 vrele(a); \
753 } while (/*CONSTCOND*/0)
754
755 int
756 puffs_vnop_create(void *v)
757 {
758 struct vop_create_v3_args /* {
759 const struct vnodeop_desc *a_desc;
760 struct vnode *a_dvp;
761 struct vnode **a_vpp;
762 struct componentname *a_cnp;
763 struct vattr *a_vap;
764 } */ *ap = v;
765 PUFFS_MSG_VARS(vn, create);
766 struct vnode *dvp = ap->a_dvp;
767 struct puffs_node *dpn = VPTOPP(dvp);
768 struct componentname *cnp = ap->a_cnp;
769 struct mount *mp = dvp->v_mount;
770 struct puffs_mount *pmp = MPTOPUFFSMP(mp);
771 int error;
772
773 DPRINTF(("puffs_create: dvp %p, cnp: %s\n",
774 dvp, ap->a_cnp->cn_nameptr));
775
776 PUFFS_MSG_ALLOC(vn, create);
777 puffs_makecn(&create_msg->pvnr_cn, &create_msg->pvnr_cn_cred,
778 cnp, PUFFS_USE_FULLPNBUF(pmp));
779 create_msg->pvnr_va = *ap->a_vap;
780 puffs_msg_setinfo(park_create, PUFFSOP_VN,
781 PUFFS_VN_CREATE, VPTOPNC(dvp));
782 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_create, dvp->v_data, NULL, error);
783
784 error = checkerr(pmp, error, __func__);
785 if (error)
786 goto out;
787
788 error = puffs_newnode(mp, dvp, ap->a_vpp,
789 create_msg->pvnr_newnode, cnp, ap->a_vap->va_type, 0);
790 if (error) {
791 puffs_abortbutton(pmp, PUFFS_ABORT_CREATE, dpn->pn_cookie,
792 create_msg->pvnr_newnode, cnp);
793 goto out;
794 }
795
796 if (PUFFS_USE_FS_TTL(pmp)) {
797 struct timespec *va_ttl = &create_msg->pvnr_va_ttl;
798 struct timespec *cn_ttl = &create_msg->pvnr_cn_ttl;
799 struct vattr *rvap = &create_msg->pvnr_va;
800
801 update_va(*ap->a_vpp, NULL, rvap,
802 va_ttl, cn_ttl, SETATTR_CHSIZE);
803 }
804
805 VPTOPP(*ap->a_vpp)->pn_nlookup++;
806
807 if (PUFFS_USE_DOTDOTCACHE(pmp) &&
808 (VPTOPP(*ap->a_vpp)->pn_parent != dvp))
809 update_parent(*ap->a_vpp, dvp);
810
811 out:
812 DPRINTF(("puffs_create: return %d\n", error));
813 PUFFS_MSG_RELEASE(create);
814 return error;
815 }
816
817 int
818 puffs_vnop_mknod(void *v)
819 {
820 struct vop_mknod_v3_args /* {
821 const struct vnodeop_desc *a_desc;
822 struct vnode *a_dvp;
823 struct vnode **a_vpp;
824 struct componentname *a_cnp;
825 struct vattr *a_vap;
826 } */ *ap = v;
827 PUFFS_MSG_VARS(vn, mknod);
828 struct vnode *dvp = ap->a_dvp;
829 struct puffs_node *dpn = VPTOPP(dvp);
830 struct componentname *cnp = ap->a_cnp;
831 struct mount *mp = dvp->v_mount;
832 struct puffs_mount *pmp = MPTOPUFFSMP(mp);
833 int error;
834
835 PUFFS_MSG_ALLOC(vn, mknod);
836 puffs_makecn(&mknod_msg->pvnr_cn, &mknod_msg->pvnr_cn_cred,
837 cnp, PUFFS_USE_FULLPNBUF(pmp));
838 mknod_msg->pvnr_va = *ap->a_vap;
839 puffs_msg_setinfo(park_mknod, PUFFSOP_VN,
840 PUFFS_VN_MKNOD, VPTOPNC(dvp));
841
842 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_mknod, dvp->v_data, NULL, error);
843
844 error = checkerr(pmp, error, __func__);
845 if (error)
846 goto out;
847
848 error = puffs_newnode(mp, dvp, ap->a_vpp,
849 mknod_msg->pvnr_newnode, cnp, ap->a_vap->va_type,
850 ap->a_vap->va_rdev);
851 if (error) {
852 puffs_abortbutton(pmp, PUFFS_ABORT_MKNOD, dpn->pn_cookie,
853 mknod_msg->pvnr_newnode, cnp);
854 goto out;
855 }
856
857 if (PUFFS_USE_FS_TTL(pmp)) {
858 struct timespec *va_ttl = &mknod_msg->pvnr_va_ttl;
859 struct timespec *cn_ttl = &mknod_msg->pvnr_cn_ttl;
860 struct vattr *rvap = &mknod_msg->pvnr_va;
861
862 update_va(*ap->a_vpp, NULL, rvap,
863 va_ttl, cn_ttl, SETATTR_CHSIZE);
864 }
865
866 VPTOPP(*ap->a_vpp)->pn_nlookup++;
867
868 if (PUFFS_USE_DOTDOTCACHE(pmp) &&
869 (VPTOPP(*ap->a_vpp)->pn_parent != dvp))
870 update_parent(*ap->a_vpp, dvp);
871
872 out:
873 PUFFS_MSG_RELEASE(mknod);
874 return error;
875 }
876
877 int
878 puffs_vnop_open(void *v)
879 {
880 struct vop_open_args /* {
881 const struct vnodeop_desc *a_desc;
882 struct vnode *a_vp;
883 int a_mode;
884 kauth_cred_t a_cred;
885 } */ *ap = v;
886 PUFFS_MSG_VARS(vn, open);
887 struct vnode *vp = ap->a_vp;
888 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
889 struct puffs_node *pn = VPTOPP(vp);
890 int mode = ap->a_mode;
891 int error;
892
893 DPRINTF(("puffs_open: vp %p, mode 0x%x\n", vp, mode));
894
895 if (vp->v_type == VREG && mode & FWRITE && !EXISTSOP(pmp, WRITE))
896 ERROUT(EROFS);
897
898 if (!EXISTSOP(pmp, OPEN))
899 ERROUT(0);
900
901 PUFFS_MSG_ALLOC(vn, open);
902 open_msg->pvnr_mode = mode;
903 puffs_credcvt(&open_msg->pvnr_cred, ap->a_cred);
904 puffs_msg_setinfo(park_open, PUFFSOP_VN,
905 PUFFS_VN_OPEN, VPTOPNC(vp));
906
907 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_open, vp->v_data, NULL, error);
908 error = checkerr(pmp, error, __func__);
909
910 if (open_msg->pvnr_oflags & PUFFS_OPEN_IO_DIRECT) {
911 /*
912 * Flush cache:
913 * - we do not want to discard cached write by direct write
914 * - read cache is now useless and should be freed
915 */
916 flushvncache(vp, 0, 0, true);
917 if (mode & FREAD)
918 pn->pn_stat |= PNODE_RDIRECT;
919 if (mode & FWRITE)
920 pn->pn_stat |= PNODE_WDIRECT;
921 }
922 out:
923 DPRINTF(("puffs_open: returning %d\n", error));
924 PUFFS_MSG_RELEASE(open);
925 return error;
926 }
927
928 int
929 puffs_vnop_close(void *v)
930 {
931 struct vop_close_args /* {
932 const struct vnodeop_desc *a_desc;
933 struct vnode *a_vp;
934 int a_fflag;
935 kauth_cred_t a_cred;
936 } */ *ap = v;
937 PUFFS_MSG_VARS(vn, close);
938 struct vnode *vp = ap->a_vp;
939 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
940
941 PUFFS_MSG_ALLOC(vn, close);
942 puffs_msg_setfaf(park_close);
943 close_msg->pvnr_fflag = ap->a_fflag;
944 puffs_credcvt(&close_msg->pvnr_cred, ap->a_cred);
945 puffs_msg_setinfo(park_close, PUFFSOP_VN,
946 PUFFS_VN_CLOSE, VPTOPNC(vp));
947
948 puffs_msg_enqueue(pmp, park_close);
949 PUFFS_MSG_RELEASE(close);
950 return 0;
951 }
952
953 int
954 puffs_vnop_access(void *v)
955 {
956 struct vop_access_args /* {
957 const struct vnodeop_desc *a_desc;
958 struct vnode *a_vp;
959 int a_mode;
960 kauth_cred_t a_cred;
961 } */ *ap = v;
962 PUFFS_MSG_VARS(vn, access);
963 struct vnode *vp = ap->a_vp;
964 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
965 int mode = ap->a_mode;
966 int error;
967
968 if (mode & VWRITE) {
969 switch (vp->v_type) {
970 case VDIR:
971 case VLNK:
972 case VREG:
973 if ((vp->v_mount->mnt_flag & MNT_RDONLY)
974 || !EXISTSOP(pmp, WRITE))
975 return EROFS;
976 break;
977 default:
978 break;
979 }
980 }
981
982 if (!EXISTSOP(pmp, ACCESS))
983 return 0;
984
985 PUFFS_MSG_ALLOC(vn, access);
986 access_msg->pvnr_mode = ap->a_mode;
987 puffs_credcvt(&access_msg->pvnr_cred, ap->a_cred);
988 puffs_msg_setinfo(park_access, PUFFSOP_VN,
989 PUFFS_VN_ACCESS, VPTOPNC(vp));
990
991 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_access, vp->v_data, NULL, error);
992 error = checkerr(pmp, error, __func__);
993 PUFFS_MSG_RELEASE(access);
994
995 return error;
996 }
997
998 static void
999 update_va(struct vnode *vp, struct vattr *vap, struct vattr *rvap,
1000 struct timespec *va_ttl, struct timespec *cn_ttl, int flags)
1001 {
1002 struct puffs_node *pn = VPTOPP(vp);
1003 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
1004 int use_metacache;
1005
1006 if (TTL_VALID(cn_ttl)) {
1007 pn->pn_cn_timeout = TTL_TO_TIMEOUT(cn_ttl);
1008 pn->pn_cn_grace = MAX(pn->pn_cn_timeout, pn->pn_cn_grace);
1009 }
1010
1011 /*
1012 * Don't listen to the file server regarding special device
1013 * size info, the file server doesn't know anything about them.
1014 */
1015 if (vp->v_type == VBLK || vp->v_type == VCHR)
1016 rvap->va_size = vp->v_size;
1017
1018 /* Ditto for blocksize (ufs comment: this doesn't belong here) */
1019 if (vp->v_type == VBLK)
1020 rvap->va_blocksize = BLKDEV_IOSIZE;
1021 else if (vp->v_type == VCHR)
1022 rvap->va_blocksize = MAXBSIZE;
1023
1024 if (vap != NULL) {
1025 (void) memcpy(vap, rvap, sizeof(struct vattr));
1026 vap->va_fsid = vp->v_mount->mnt_stat.f_fsidx.__fsid_val[0];
1027
1028 if (PUFFS_USE_METAFLUSH(pmp)) {
1029 if (pn->pn_stat & PNODE_METACACHE_ATIME)
1030 vap->va_atime = pn->pn_mc_atime;
1031 if (pn->pn_stat & PNODE_METACACHE_CTIME)
1032 vap->va_ctime = pn->pn_mc_ctime;
1033 if (pn->pn_stat & PNODE_METACACHE_MTIME)
1034 vap->va_mtime = pn->pn_mc_mtime;
1035 if (pn->pn_stat & PNODE_METACACHE_SIZE)
1036 vap->va_size = pn->pn_mc_size;
1037 }
1038 }
1039
1040 use_metacache = PUFFS_USE_METAFLUSH(pmp) &&
1041 (pn->pn_stat & PNODE_METACACHE_SIZE);
1042 if (!use_metacache && (flags & SETATTR_CHSIZE)) {
1043 if (rvap->va_size != VNOVAL
1044 && vp->v_type != VBLK && vp->v_type != VCHR) {
1045 uvm_vnp_setsize(vp, rvap->va_size);
1046 pn->pn_serversize = rvap->va_size;
1047 }
1048 }
1049
1050 if ((va_ttl != NULL) && TTL_VALID(va_ttl)) {
1051 if (pn->pn_va_cache == NULL)
1052 pn->pn_va_cache = pool_get(&puffs_vapool, PR_WAITOK);
1053
1054 (void)memcpy(pn->pn_va_cache, rvap, sizeof(*rvap));
1055
1056 pn->pn_va_timeout = TTL_TO_TIMEOUT(va_ttl);
1057 }
1058 }
1059
1060 static void
1061 update_parent(struct vnode *vp, struct vnode *dvp)
1062 {
1063 struct puffs_node *pn = VPTOPP(vp);
1064
1065 if (pn->pn_parent != NULL) {
1066 KASSERT(pn->pn_parent != dvp);
1067 vrele(pn->pn_parent);
1068 }
1069
1070 vref(dvp);
1071 pn->pn_parent = dvp;
1072 }
1073
1074 int
1075 puffs_vnop_getattr(void *v)
1076 {
1077 struct vop_getattr_args /* {
1078 const struct vnodeop_desc *a_desc;
1079 struct vnode *a_vp;
1080 struct vattr *a_vap;
1081 kauth_cred_t a_cred;
1082 } */ *ap = v;
1083 PUFFS_MSG_VARS(vn, getattr);
1084 struct vnode *vp = ap->a_vp;
1085 struct mount *mp = vp->v_mount;
1086 struct puffs_mount *pmp = MPTOPUFFSMP(mp);
1087 struct vattr *vap, *rvap;
1088 struct puffs_node *pn = VPTOPP(vp);
1089 struct timespec *va_ttl = NULL;
1090 int error = 0;
1091
1092 /*
1093 * A lock is required so that we do not race with
1094 * setattr, write and fsync when changing vp->v_size.
1095 * This is critical, since setting a stall smaler value
1096 * triggers a file truncate in uvm_vnp_setsize(), which
1097 * most of the time means data corruption (a chunk of
1098 * data is replaced by zeroes). This can be removed if
1099 * we decide one day that VOP_GETATTR must operate on
1100 * a locked vnode.
1101 *
1102 * XXX Should be useless now that VOP_GETATTR has been
1103 * fixed to always require a shared lock at least.
1104 */
1105 mutex_enter(&pn->pn_sizemtx);
1106
1107 REFPN(pn);
1108 vap = ap->a_vap;
1109
1110 if (PUFFS_USE_FS_TTL(pmp)) {
1111 if (!TIMED_OUT(pn->pn_va_timeout)) {
1112 update_va(vp, vap, pn->pn_va_cache,
1113 NULL, NULL, SETATTR_CHSIZE);
1114 goto out2;
1115 }
1116 }
1117
1118 PUFFS_MSG_ALLOC(vn, getattr);
1119 vattr_null(&getattr_msg->pvnr_va);
1120 puffs_credcvt(&getattr_msg->pvnr_cred, ap->a_cred);
1121 puffs_msg_setinfo(park_getattr, PUFFSOP_VN,
1122 PUFFS_VN_GETATTR, VPTOPNC(vp));
1123
1124 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_getattr, vp->v_data, NULL, error);
1125 error = checkerr(pmp, error, __func__);
1126 if (error)
1127 goto out;
1128
1129 rvap = &getattr_msg->pvnr_va;
1130
1131 if (PUFFS_USE_FS_TTL(pmp))
1132 va_ttl = &getattr_msg->pvnr_va_ttl;
1133
1134 update_va(vp, vap, rvap, va_ttl, NULL, SETATTR_CHSIZE);
1135
1136 out:
1137 PUFFS_MSG_RELEASE(getattr);
1138
1139 out2:
1140 puffs_releasenode(pn);
1141
1142 mutex_exit(&pn->pn_sizemtx);
1143
1144 return error;
1145 }
1146
1147 static void
1148 zerofill_lastpage(struct vnode *vp, voff_t off)
1149 {
1150 char zbuf[PAGE_SIZE];
1151 struct iovec iov;
1152 struct uio uio;
1153 vsize_t len;
1154 int error;
1155
1156 if (trunc_page(off) == off)
1157 return;
1158
1159 if (vp->v_writecount == 0)
1160 return;
1161
1162 len = round_page(off) - off;
1163 memset(zbuf, 0, len);
1164
1165 iov.iov_base = zbuf;
1166 iov.iov_len = len;
1167 UIO_SETUP_SYSSPACE(&uio);
1168 uio.uio_iov = &iov;
1169 uio.uio_iovcnt = 1;
1170 uio.uio_offset = off;
1171 uio.uio_resid = len;
1172 uio.uio_rw = UIO_WRITE;
1173
1174 error = ubc_uiomove(&vp->v_uobj, &uio, len,
1175 UVM_ADV_SEQUENTIAL, UBC_WRITE|UBC_UNMAP_FLAG(vp));
1176 if (error) {
1177 DPRINTF(("zero-fill 0x%" PRIxVSIZE "@0x%" PRIx64
1178 " failed: error = %d\n", len, off, error));
1179 }
1180
1181 return;
1182 }
1183
1184 static int
1185 dosetattr(struct vnode *vp, struct vattr *vap, kauth_cred_t cred, int flags)
1186 {
1187 PUFFS_MSG_VARS(vn, setattr);
1188 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
1189 struct puffs_node *pn = vp->v_data;
1190 vsize_t oldsize = vp->v_size;
1191 int error = 0;
1192
1193 KASSERT(!(flags & SETATTR_CHSIZE) || mutex_owned(&pn->pn_sizemtx));
1194
1195 if ((vp->v_mount->mnt_flag & MNT_RDONLY) &&
1196 (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL
1197 || vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL
1198 || vap->va_mode != (mode_t)VNOVAL))
1199 return EROFS;
1200
1201 if ((vp->v_mount->mnt_flag & MNT_RDONLY)
1202 && vp->v_type == VREG && vap->va_size != VNOVAL)
1203 return EROFS;
1204
1205 /*
1206 * Flush metacache first. If we are called with some explicit
1207 * parameters, treat them as information overriding metacache
1208 * information.
1209 */
1210 if (PUFFS_USE_METAFLUSH(pmp) && pn->pn_stat & PNODE_METACACHE_MASK) {
1211 if ((pn->pn_stat & PNODE_METACACHE_ATIME)
1212 && vap->va_atime.tv_sec == VNOVAL)
1213 vap->va_atime = pn->pn_mc_atime;
1214 if ((pn->pn_stat & PNODE_METACACHE_CTIME)
1215 && vap->va_ctime.tv_sec == VNOVAL)
1216 vap->va_ctime = pn->pn_mc_ctime;
1217 if ((pn->pn_stat & PNODE_METACACHE_MTIME)
1218 && vap->va_mtime.tv_sec == VNOVAL)
1219 vap->va_mtime = pn->pn_mc_mtime;
1220 if ((pn->pn_stat & PNODE_METACACHE_SIZE)
1221 && vap->va_size == VNOVAL)
1222 vap->va_size = pn->pn_mc_size;
1223
1224 pn->pn_stat &= ~PNODE_METACACHE_MASK;
1225 }
1226
1227 /*
1228 * Flush attribute cache so that another thread do
1229 * not get a stale value during the operation.
1230 */
1231 if (PUFFS_USE_FS_TTL(pmp))
1232 pn->pn_va_timeout = 0;
1233
1234 PUFFS_MSG_ALLOC(vn, setattr);
1235 (void)memcpy(&setattr_msg->pvnr_va, vap, sizeof(struct vattr));
1236 puffs_credcvt(&setattr_msg->pvnr_cred, cred);
1237 puffs_msg_setinfo(park_setattr, PUFFSOP_VN,
1238 PUFFS_VN_SETATTR, VPTOPNC(vp));
1239 if (flags & SETATTR_ASYNC)
1240 puffs_msg_setfaf(park_setattr);
1241
1242 puffs_msg_enqueue(pmp, park_setattr);
1243 if ((flags & SETATTR_ASYNC) == 0) {
1244 error = puffs_msg_wait2(pmp, park_setattr, vp->v_data, NULL);
1245
1246 if ((error == 0) && PUFFS_USE_FS_TTL(pmp)) {
1247 struct timespec *va_ttl = &setattr_msg->pvnr_va_ttl;
1248 struct vattr *rvap = &setattr_msg->pvnr_va;
1249
1250 update_va(vp, NULL, rvap, va_ttl, NULL, flags);
1251 }
1252 }
1253
1254 PUFFS_MSG_RELEASE(setattr);
1255 if ((flags & SETATTR_ASYNC) == 0) {
1256 error = checkerr(pmp, error, __func__);
1257 if (error)
1258 return error;
1259 } else {
1260 error = 0;
1261 }
1262
1263 if (vap->va_size != VNOVAL) {
1264 /*
1265 * If we truncated the file, make sure the data beyond
1266 * EOF in last page does not remain in cache, otherwise
1267 * if the file is later truncated to a larger size (creating
1268 * a hole), that area will not return zeroes as it
1269 * should.
1270 */
1271 if ((flags & SETATTR_CHSIZE) && PUFFS_USE_PAGECACHE(pmp) &&
1272 (vap->va_size < oldsize))
1273 zerofill_lastpage(vp, vap->va_size);
1274
1275 pn->pn_serversize = vap->va_size;
1276 if (flags & SETATTR_CHSIZE)
1277 uvm_vnp_setsize(vp, vap->va_size);
1278 }
1279
1280 return 0;
1281 }
1282
1283 int
1284 puffs_vnop_setattr(void *v)
1285 {
1286 struct vop_getattr_args /* {
1287 const struct vnodeop_desc *a_desc;
1288 struct vnode *a_vp;
1289 struct vattr *a_vap;
1290 kauth_cred_t a_cred;
1291 } */ *ap = v;
1292 struct puffs_node *pn = ap->a_vp->v_data;
1293 int error;
1294
1295 mutex_enter(&pn->pn_sizemtx);
1296 error = dosetattr(ap->a_vp, ap->a_vap, ap->a_cred, SETATTR_CHSIZE);
1297 mutex_exit(&pn->pn_sizemtx);
1298
1299 return error;
1300 }
1301
1302 static __inline int
1303 doinact(struct puffs_mount *pmp, int iaflag)
1304 {
1305
1306 if (EXISTSOP(pmp, INACTIVE))
1307 if (pmp->pmp_flags & PUFFS_KFLAG_IAONDEMAND)
1308 if (iaflag || ALLOPS(pmp))
1309 return 1;
1310 else
1311 return 0;
1312 else
1313 return 1;
1314 else
1315 return 0;
1316 }
1317
1318 static void
1319 callinactive(struct puffs_mount *pmp, puffs_cookie_t ck, int iaflag)
1320 {
1321 PUFFS_MSG_VARS(vn, inactive);
1322
1323 if (doinact(pmp, iaflag)) {
1324 PUFFS_MSG_ALLOC(vn, inactive);
1325 puffs_msg_setinfo(park_inactive, PUFFSOP_VN,
1326 PUFFS_VN_INACTIVE, ck);
1327 PUFFS_MSG_ENQUEUEWAIT_NOERROR(pmp, park_inactive);
1328 PUFFS_MSG_RELEASE(inactive);
1329 }
1330 }
1331
1332 /* XXX: callinactive can't setback */
1333 int
1334 puffs_vnop_inactive(void *v)
1335 {
1336 struct vop_inactive_args /* {
1337 const struct vnodeop_desc *a_desc;
1338 struct vnode *a_vp;
1339 } */ *ap = v;
1340 PUFFS_MSG_VARS(vn, inactive);
1341 struct vnode *vp = ap->a_vp;
1342 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
1343 struct puffs_node *pnode;
1344 bool recycle = false;
1345
1346 /*
1347 * When puffs_cookie2vnode() misses an entry, vcache_get()
1348 * creates a new node (puffs_vfsop_loadvnode being called to
1349 * initialize the PUFFS part), then it discovers it is VNON,
1350 * and tries to vrele() it. This leads us there, while the
1351 * cookie was stall and the node likely already reclaimed.
1352 */
1353 if (vp->v_type == VNON) {
1354 VOP_UNLOCK(vp);
1355 return 0;
1356 }
1357
1358 pnode = vp->v_data;
1359 mutex_enter(&pnode->pn_sizemtx);
1360
1361 if (doinact(pmp, pnode->pn_stat & PNODE_DOINACT)) {
1362 flushvncache(vp, 0, 0, false);
1363 PUFFS_MSG_ALLOC(vn, inactive);
1364 puffs_msg_setinfo(park_inactive, PUFFSOP_VN,
1365 PUFFS_VN_INACTIVE, VPTOPNC(vp));
1366 PUFFS_MSG_ENQUEUEWAIT2_NOERROR(pmp, park_inactive, vp->v_data,
1367 NULL);
1368 PUFFS_MSG_RELEASE(inactive);
1369 }
1370 pnode->pn_stat &= ~PNODE_DOINACT;
1371
1372 /*
1373 * file server thinks it's gone? then don't be afraid care,
1374 * node's life was already all it would ever be
1375 */
1376 if (pnode->pn_stat & PNODE_NOREFS) {
1377 pnode->pn_stat |= PNODE_DYING;
1378 recycle = true;
1379 }
1380
1381 /*
1382 * Handle node TTL.
1383 * If grace has already timed out, make it reclaimed.
1384 * Otherwise, we queue its expiration by sop thread, so
1385 * that it does not remain for ages in the freelist,
1386 * holding memory in userspace, while we will have
1387 * to look it up again anyway.
1388 */
1389 if (PUFFS_USE_FS_TTL(pmp) && !(vp->v_vflag & VV_ROOT) && !recycle) {
1390 bool incache = !TIMED_OUT(pnode->pn_cn_timeout);
1391 bool ingrace = !TIMED_OUT(pnode->pn_cn_grace);
1392 bool reclaimqueued = pnode->pn_stat & PNODE_SOPEXP;
1393
1394 if (!incache && !ingrace && !reclaimqueued) {
1395 pnode->pn_stat |= PNODE_DYING;
1396 recycle = true;
1397 }
1398
1399 if (!recycle && !reclaimqueued) {
1400 struct puffs_sopreq *psopr;
1401 int at = MAX(pnode->pn_cn_grace, pnode->pn_cn_timeout);
1402
1403 KASSERT(curlwp != uvm.pagedaemon_lwp);
1404 psopr = kmem_alloc(sizeof(*psopr), KM_SLEEP);
1405 psopr->psopr_ck = VPTOPNC(pnode->pn_vp);
1406 psopr->psopr_sopreq = PUFFS_SOPREQ_EXPIRE;
1407 psopr->psopr_at = at;
1408
1409 mutex_enter(&pmp->pmp_sopmtx);
1410
1411 /*
1412 * If thread has disapeared, just give up. The
1413 * fs is being unmounted and the node will be
1414 * be reclaimed anyway.
1415 *
1416 * Otherwise, we queue the request but do not
1417 * immediatly signal the thread, as the node
1418 * has not been expired yet.
1419 */
1420 if (pmp->pmp_sopthrcount == 0) {
1421 kmem_free(psopr, sizeof(*psopr));
1422 } else {
1423 TAILQ_INSERT_TAIL(&pmp->pmp_sopnodereqs,
1424 psopr, psopr_entries);
1425 pnode->pn_stat |= PNODE_SOPEXP;
1426 }
1427
1428 mutex_exit(&pmp->pmp_sopmtx);
1429 }
1430 }
1431
1432 /*
1433 * Wipe direct I/O flags
1434 */
1435 pnode->pn_stat &= ~(PNODE_RDIRECT|PNODE_WDIRECT);
1436
1437 *ap->a_recycle = recycle;
1438
1439 mutex_exit(&pnode->pn_sizemtx);
1440 VOP_UNLOCK(vp);
1441
1442 return 0;
1443 }
1444
1445 static void
1446 callreclaim(struct puffs_mount *pmp, puffs_cookie_t ck, int nlookup)
1447 {
1448 PUFFS_MSG_VARS(vn, reclaim);
1449
1450 if (!EXISTSOP(pmp, RECLAIM))
1451 return;
1452
1453 PUFFS_MSG_ALLOC(vn, reclaim);
1454 reclaim_msg->pvnr_nlookup = nlookup;
1455 puffs_msg_setfaf(park_reclaim);
1456 puffs_msg_setinfo(park_reclaim, PUFFSOP_VN, PUFFS_VN_RECLAIM, ck);
1457
1458 puffs_msg_enqueue(pmp, park_reclaim);
1459 PUFFS_MSG_RELEASE(reclaim);
1460 return;
1461 }
1462
1463 /*
1464 * always FAF, we don't really care if the server wants to fail to
1465 * reclaim the node or not
1466 */
1467 int
1468 puffs_vnop_reclaim(void *v)
1469 {
1470 struct vop_reclaim_args /* {
1471 const struct vnodeop_desc *a_desc;
1472 struct vnode *a_vp;
1473 } */ *ap = v;
1474 struct vnode *vp = ap->a_vp;
1475 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
1476 bool notifyserver = true;
1477
1478 /*
1479 * first things first: check if someone is trying to reclaim the
1480 * root vnode. do not allow that to travel to userspace.
1481 * Note that we don't need to take the lock similarly to
1482 * puffs_root(), since there is only one of us.
1483 */
1484 if (vp->v_vflag & VV_ROOT) {
1485 mutex_enter(&pmp->pmp_lock);
1486 KASSERT(pmp->pmp_root != NULL);
1487 pmp->pmp_root = NULL;
1488 mutex_exit(&pmp->pmp_lock);
1489 notifyserver = false;
1490 }
1491
1492 /*
1493 * purge info from kernel before issueing FAF, since we
1494 * don't really know when we'll get around to it after
1495 * that and someone might race us into node creation
1496 */
1497 mutex_enter(&pmp->pmp_lock);
1498 if (PUFFS_USE_NAMECACHE(pmp))
1499 cache_purge(vp);
1500 mutex_exit(&pmp->pmp_lock);
1501
1502 if (notifyserver) {
1503 int nlookup = VPTOPP(vp)->pn_nlookup;
1504
1505 callreclaim(MPTOPUFFSMP(vp->v_mount), VPTOPNC(vp), nlookup);
1506 }
1507
1508 if (PUFFS_USE_DOTDOTCACHE(pmp)) {
1509 if (__predict_true(VPTOPP(vp)->pn_parent != NULL))
1510 vrele(VPTOPP(vp)->pn_parent);
1511 else
1512 KASSERT(vp->v_type == VNON || (vp->v_vflag & VV_ROOT));
1513 }
1514
1515 puffs_putvnode(vp);
1516
1517 return 0;
1518 }
1519
1520 #define CSIZE sizeof(**ap->a_cookies)
1521 int
1522 puffs_vnop_readdir(void *v)
1523 {
1524 struct vop_readdir_args /* {
1525 const struct vnodeop_desc *a_desc;
1526 struct vnode *a_vp;
1527 struct uio *a_uio;
1528 kauth_cred_t a_cred;
1529 int *a_eofflag;
1530 off_t **a_cookies;
1531 int *a_ncookies;
1532 } */ *ap = v;
1533 PUFFS_MSG_VARS(vn, readdir);
1534 struct vnode *vp = ap->a_vp;
1535 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
1536 size_t argsize, tomove, cookiemem, cookiesmax;
1537 struct uio *uio = ap->a_uio;
1538 size_t howmuch, resid;
1539 int error;
1540
1541 /*
1542 * ok, so we need: resid + cookiemem = maxreq
1543 * => resid + cookiesize * (resid/minsize) = maxreq
1544 * => resid + cookiesize/minsize * resid = maxreq
1545 * => (cookiesize/minsize + 1) * resid = maxreq
1546 * => resid = maxreq / (cookiesize/minsize + 1)
1547 *
1548 * Since cookiesize <= minsize and we're not very big on floats,
1549 * we approximate that to be 1. Therefore:
1550 *
1551 * resid = maxreq / 2;
1552 *
1553 * Well, at least we didn't have to use differential equations
1554 * or the Gram-Schmidt process.
1555 *
1556 * (yes, I'm very afraid of this)
1557 */
1558 KASSERT(CSIZE <= _DIRENT_MINSIZE((struct dirent *)0));
1559
1560 if (ap->a_cookies) {
1561 KASSERT(ap->a_ncookies != NULL);
1562 if (pmp->pmp_args.pa_fhsize == 0)
1563 return EOPNOTSUPP;
1564 resid = PUFFS_TOMOVE(uio->uio_resid, pmp) / 2;
1565 cookiesmax = resid/_DIRENT_MINSIZE((struct dirent *)0);
1566 cookiemem = ALIGN(cookiesmax*CSIZE); /* play safe */
1567 } else {
1568 resid = PUFFS_TOMOVE(uio->uio_resid, pmp);
1569 cookiesmax = 0;
1570 cookiemem = 0;
1571 }
1572
1573 argsize = sizeof(struct puffs_vnmsg_readdir);
1574 tomove = resid + cookiemem;
1575 puffs_msgmem_alloc(argsize + tomove, &park_readdir,
1576 (void *)&readdir_msg, 1);
1577
1578 puffs_credcvt(&readdir_msg->pvnr_cred, ap->a_cred);
1579 readdir_msg->pvnr_offset = uio->uio_offset;
1580 readdir_msg->pvnr_resid = resid;
1581 readdir_msg->pvnr_ncookies = cookiesmax;
1582 readdir_msg->pvnr_eofflag = 0;
1583 readdir_msg->pvnr_dentoff = cookiemem;
1584 puffs_msg_setinfo(park_readdir, PUFFSOP_VN,
1585 PUFFS_VN_READDIR, VPTOPNC(vp));
1586 puffs_msg_setdelta(park_readdir, tomove);
1587
1588 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_readdir, vp->v_data, NULL, error);
1589 error = checkerr(pmp, error, __func__);
1590 if (error)
1591 goto out;
1592
1593 /* userspace is cheating? */
1594 if (readdir_msg->pvnr_resid > resid) {
1595 puffs_senderr(pmp, PUFFS_ERR_READDIR, E2BIG,
1596 "resid grew", VPTOPNC(vp));
1597 ERROUT(EPROTO);
1598 }
1599 if (readdir_msg->pvnr_ncookies > cookiesmax) {
1600 puffs_senderr(pmp, PUFFS_ERR_READDIR, E2BIG,
1601 "too many cookies", VPTOPNC(vp));
1602 ERROUT(EPROTO);
1603 }
1604
1605 /* check eof */
1606 if (readdir_msg->pvnr_eofflag)
1607 *ap->a_eofflag = 1;
1608
1609 /* bouncy-wouncy with the directory data */
1610 howmuch = resid - readdir_msg->pvnr_resid;
1611
1612 /* force eof if no data was returned (getcwd() needs this) */
1613 if (howmuch == 0) {
1614 *ap->a_eofflag = 1;
1615 goto out;
1616 }
1617
1618 error = uiomove(readdir_msg->pvnr_data + cookiemem, howmuch, uio);
1619 if (error)
1620 goto out;
1621
1622 /* provide cookies to caller if so desired */
1623 if (ap->a_cookies) {
1624 KASSERT(curlwp != uvm.pagedaemon_lwp);
1625 *ap->a_cookies = malloc(readdir_msg->pvnr_ncookies*CSIZE,
1626 M_TEMP, M_WAITOK);
1627 *ap->a_ncookies = readdir_msg->pvnr_ncookies;
1628 memcpy(*ap->a_cookies, readdir_msg->pvnr_data,
1629 *ap->a_ncookies*CSIZE);
1630 }
1631
1632 /* next readdir starts here */
1633 uio->uio_offset = readdir_msg->pvnr_offset;
1634
1635 out:
1636 puffs_msgmem_release(park_readdir);
1637 return error;
1638 }
1639 #undef CSIZE
1640
1641 /*
1642 * poll works by consuming the bitmask in pn_revents. If there are
1643 * events available, poll returns immediately. If not, it issues a
1644 * poll to userspace, selrecords itself and returns with no available
1645 * events. When the file server returns, it executes puffs_parkdone_poll(),
1646 * where available events are added to the bitmask. selnotify() is
1647 * then also executed by that function causing us to enter here again
1648 * and hopefully find the missing bits (unless someone got them first,
1649 * in which case it starts all over again).
1650 */
1651 int
1652 puffs_vnop_poll(void *v)
1653 {
1654 struct vop_poll_args /* {
1655 const struct vnodeop_desc *a_desc;
1656 struct vnode *a_vp;
1657 int a_events;
1658 } */ *ap = v;
1659 PUFFS_MSG_VARS(vn, poll);
1660 struct vnode *vp = ap->a_vp;
1661 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
1662 struct puffs_node *pn = vp->v_data;
1663 int events;
1664
1665 if (EXISTSOP(pmp, POLL)) {
1666 mutex_enter(&pn->pn_mtx);
1667 events = pn->pn_revents & ap->a_events;
1668 if (events & ap->a_events) {
1669 pn->pn_revents &= ~ap->a_events;
1670 mutex_exit(&pn->pn_mtx);
1671
1672 return events;
1673 } else {
1674 puffs_referencenode(pn);
1675 mutex_exit(&pn->pn_mtx);
1676
1677 PUFFS_MSG_ALLOC(vn, poll);
1678 poll_msg->pvnr_events = ap->a_events;
1679 puffs_msg_setinfo(park_poll, PUFFSOP_VN,
1680 PUFFS_VN_POLL, VPTOPNC(vp));
1681 puffs_msg_setcall(park_poll, puffs_parkdone_poll, pn);
1682 selrecord(curlwp, &pn->pn_sel);
1683
1684 PUFFS_MSG_ENQUEUEWAIT2_NOERROR(pmp, park_poll,
1685 vp->v_data, NULL);
1686 PUFFS_MSG_RELEASE(poll);
1687
1688 return 0;
1689 }
1690 } else {
1691 return genfs_poll(v);
1692 }
1693 }
1694
1695 static int
1696 flushvncache(struct vnode *vp, off_t offlo, off_t offhi, bool wait)
1697 {
1698 struct puffs_node *pn = VPTOPP(vp);
1699 struct vattr va;
1700 int pflags, error;
1701
1702 /* flush out information from our metacache, see vop_setattr */
1703 if (pn->pn_stat & PNODE_METACACHE_MASK
1704 && (pn->pn_stat & PNODE_DYING) == 0) {
1705 vattr_null(&va);
1706 error = dosetattr(vp, &va, FSCRED,
1707 SETATTR_CHSIZE | (wait ? 0 : SETATTR_ASYNC));
1708 if (error)
1709 return error;
1710 }
1711
1712 /*
1713 * flush pages to avoid being overly dirty
1714 */
1715 pflags = PGO_CLEANIT;
1716 if (wait)
1717 pflags |= PGO_SYNCIO;
1718
1719 mutex_enter(vp->v_interlock);
1720 return VOP_PUTPAGES(vp, trunc_page(offlo), round_page(offhi), pflags);
1721 }
1722
1723 int
1724 puffs_vnop_fsync(void *v)
1725 {
1726 struct vop_fsync_args /* {
1727 const struct vnodeop_desc *a_desc;
1728 struct vnode *a_vp;
1729 kauth_cred_t a_cred;
1730 int a_flags;
1731 off_t a_offlo;
1732 off_t a_offhi;
1733 } */ *ap = v;
1734 PUFFS_MSG_VARS(vn, fsync);
1735 struct vnode *vp;
1736 struct puffs_node *pn;
1737 struct puffs_mount *pmp;
1738 int error, dofaf;
1739
1740 vp = ap->a_vp;
1741 KASSERT(vp != NULL);
1742 pn = VPTOPP(vp);
1743 KASSERT(pn != NULL);
1744 pmp = MPTOPUFFSMP(vp->v_mount);
1745 if (ap->a_flags & FSYNC_WAIT) {
1746 mutex_enter(&pn->pn_sizemtx);
1747 } else {
1748 if (mutex_tryenter(&pn->pn_sizemtx) == 0)
1749 return EDEADLK;
1750 }
1751
1752 error = flushvncache(vp, ap->a_offlo, ap->a_offhi,
1753 (ap->a_flags & FSYNC_WAIT) == FSYNC_WAIT);
1754 if (error)
1755 goto out;
1756
1757 /*
1758 * HELLO! We exit already here if the user server does not
1759 * support fsync OR if we should call fsync for a node which
1760 * has references neither in the kernel or the fs server.
1761 * Otherwise we continue to issue fsync() forward.
1762 */
1763 error = 0;
1764 if (!EXISTSOP(pmp, FSYNC) || (pn->pn_stat & PNODE_DYING))
1765 goto out;
1766
1767 dofaf = (ap->a_flags & FSYNC_WAIT) == 0 || ap->a_flags == FSYNC_LAZY;
1768 /*
1769 * We abuse VXLOCK to mean "vnode is going to die", so we issue
1770 * only FAFs for those. Otherwise there's a danger of deadlock,
1771 * since the execution context here might be the user server
1772 * doing some operation on another fs, which in turn caused a
1773 * vnode to be reclaimed from the freelist for this fs.
1774 */
1775 if (dofaf == 0) {
1776 mutex_enter(vp->v_interlock);
1777 if (vdead_check(vp, VDEAD_NOWAIT) != 0)
1778 dofaf = 1;
1779 mutex_exit(vp->v_interlock);
1780 }
1781
1782 PUFFS_MSG_ALLOC(vn, fsync);
1783 if (dofaf)
1784 puffs_msg_setfaf(park_fsync);
1785
1786 puffs_credcvt(&fsync_msg->pvnr_cred, ap->a_cred);
1787 fsync_msg->pvnr_flags = ap->a_flags;
1788 fsync_msg->pvnr_offlo = ap->a_offlo;
1789 fsync_msg->pvnr_offhi = ap->a_offhi;
1790 puffs_msg_setinfo(park_fsync, PUFFSOP_VN,
1791 PUFFS_VN_FSYNC, VPTOPNC(vp));
1792
1793 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_fsync, vp->v_data, NULL, error);
1794 PUFFS_MSG_RELEASE(fsync);
1795
1796 error = checkerr(pmp, error, __func__);
1797
1798 out:
1799 mutex_exit(&pn->pn_sizemtx);
1800 return error;
1801 }
1802
1803 int
1804 puffs_vnop_seek(void *v)
1805 {
1806 struct vop_seek_args /* {
1807 const struct vnodeop_desc *a_desc;
1808 struct vnode *a_vp;
1809 off_t a_oldoff;
1810 off_t a_newoff;
1811 kauth_cred_t a_cred;
1812 } */ *ap = v;
1813 PUFFS_MSG_VARS(vn, seek);
1814 struct vnode *vp = ap->a_vp;
1815 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
1816 int error;
1817
1818 PUFFS_MSG_ALLOC(vn, seek);
1819 seek_msg->pvnr_oldoff = ap->a_oldoff;
1820 seek_msg->pvnr_newoff = ap->a_newoff;
1821 puffs_credcvt(&seek_msg->pvnr_cred, ap->a_cred);
1822 puffs_msg_setinfo(park_seek, PUFFSOP_VN,
1823 PUFFS_VN_SEEK, VPTOPNC(vp));
1824
1825 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_seek, vp->v_data, NULL, error);
1826 PUFFS_MSG_RELEASE(seek);
1827 return checkerr(pmp, error, __func__);
1828 }
1829
1830 static int
1831 callremove(struct puffs_mount *pmp, puffs_cookie_t dck, puffs_cookie_t ck,
1832 struct componentname *cnp)
1833 {
1834 PUFFS_MSG_VARS(vn, remove);
1835 int error;
1836
1837 PUFFS_MSG_ALLOC(vn, remove);
1838 remove_msg->pvnr_cookie_targ = ck;
1839 puffs_makecn(&remove_msg->pvnr_cn, &remove_msg->pvnr_cn_cred,
1840 cnp, PUFFS_USE_FULLPNBUF(pmp));
1841 puffs_msg_setinfo(park_remove, PUFFSOP_VN, PUFFS_VN_REMOVE, dck);
1842
1843 PUFFS_MSG_ENQUEUEWAIT(pmp, park_remove, error);
1844 PUFFS_MSG_RELEASE(remove);
1845
1846 return checkerr(pmp, error, __func__);
1847 }
1848
1849 /*
1850 * XXX: can't use callremove now because can't catch setbacks with
1851 * it due to lack of a pnode argument.
1852 */
1853 int
1854 puffs_vnop_remove(void *v)
1855 {
1856 struct vop_remove_args /* {
1857 const struct vnodeop_desc *a_desc;
1858 struct vnode *a_dvp;
1859 struct vnode *a_vp;
1860 struct componentname *a_cnp;
1861 } */ *ap = v;
1862 PUFFS_MSG_VARS(vn, remove);
1863 struct vnode *dvp = ap->a_dvp;
1864 struct vnode *vp = ap->a_vp;
1865 struct puffs_node *dpn = VPTOPP(dvp);
1866 struct puffs_node *pn = VPTOPP(vp);
1867 struct componentname *cnp = ap->a_cnp;
1868 struct mount *mp = dvp->v_mount;
1869 struct puffs_mount *pmp = MPTOPUFFSMP(mp);
1870 int error;
1871
1872 PUFFS_MSG_ALLOC(vn, remove);
1873 remove_msg->pvnr_cookie_targ = VPTOPNC(vp);
1874 puffs_makecn(&remove_msg->pvnr_cn, &remove_msg->pvnr_cn_cred,
1875 cnp, PUFFS_USE_FULLPNBUF(pmp));
1876 puffs_msg_setinfo(park_remove, PUFFSOP_VN,
1877 PUFFS_VN_REMOVE, VPTOPNC(dvp));
1878
1879 puffs_msg_enqueue(pmp, park_remove);
1880 REFPN_AND_UNLOCKVP(dvp, dpn);
1881 if (dvp == vp)
1882 REFPN(pn);
1883 else
1884 REFPN_AND_UNLOCKVP(vp, pn);
1885 error = puffs_msg_wait2(pmp, park_remove, dpn, pn);
1886
1887 PUFFS_MSG_RELEASE(remove);
1888
1889 puffs_updatenode(VPTOPP(dvp), PUFFS_UPDATECTIME|PUFFS_UPDATEMTIME, 0);
1890
1891 RELEPN_AND_VP(dvp, dpn);
1892 RELEPN_AND_VP(vp, pn);
1893
1894 error = checkerr(pmp, error, __func__);
1895 return error;
1896 }
1897
1898 int
1899 puffs_vnop_mkdir(void *v)
1900 {
1901 struct vop_mkdir_v3_args /* {
1902 const struct vnodeop_desc *a_desc;
1903 struct vnode *a_dvp;
1904 struct vnode **a_vpp;
1905 struct componentname *a_cnp;
1906 struct vattr *a_vap;
1907 } */ *ap = v;
1908 PUFFS_MSG_VARS(vn, mkdir);
1909 struct vnode *dvp = ap->a_dvp;
1910 struct puffs_node *dpn = VPTOPP(dvp);
1911 struct componentname *cnp = ap->a_cnp;
1912 struct mount *mp = dvp->v_mount;
1913 struct puffs_mount *pmp = MPTOPUFFSMP(mp);
1914 int error;
1915
1916 PUFFS_MSG_ALLOC(vn, mkdir);
1917 puffs_makecn(&mkdir_msg->pvnr_cn, &mkdir_msg->pvnr_cn_cred,
1918 cnp, PUFFS_USE_FULLPNBUF(pmp));
1919 mkdir_msg->pvnr_va = *ap->a_vap;
1920 puffs_msg_setinfo(park_mkdir, PUFFSOP_VN,
1921 PUFFS_VN_MKDIR, VPTOPNC(dvp));
1922
1923 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_mkdir, dvp->v_data, NULL, error);
1924
1925 error = checkerr(pmp, error, __func__);
1926 if (error)
1927 goto out;
1928
1929 error = puffs_newnode(mp, dvp, ap->a_vpp,
1930 mkdir_msg->pvnr_newnode, cnp, VDIR, 0);
1931 if (error) {
1932 puffs_abortbutton(pmp, PUFFS_ABORT_MKDIR, dpn->pn_cookie,
1933 mkdir_msg->pvnr_newnode, cnp);
1934 goto out;
1935 }
1936
1937 if (PUFFS_USE_FS_TTL(pmp)) {
1938 struct timespec *va_ttl = &mkdir_msg->pvnr_va_ttl;
1939 struct timespec *cn_ttl = &mkdir_msg->pvnr_cn_ttl;
1940 struct vattr *rvap = &mkdir_msg->pvnr_va;
1941
1942 update_va(*ap->a_vpp, NULL, rvap,
1943 va_ttl, cn_ttl, SETATTR_CHSIZE);
1944 }
1945
1946 VPTOPP(*ap->a_vpp)->pn_nlookup++;
1947
1948 if (PUFFS_USE_DOTDOTCACHE(pmp) &&
1949 (VPTOPP(*ap->a_vpp)->pn_parent != dvp))
1950 update_parent(*ap->a_vpp, dvp);
1951
1952 out:
1953 PUFFS_MSG_RELEASE(mkdir);
1954 return error;
1955 }
1956
1957 static int
1958 callrmdir(struct puffs_mount *pmp, puffs_cookie_t dck, puffs_cookie_t ck,
1959 struct componentname *cnp)
1960 {
1961 PUFFS_MSG_VARS(vn, rmdir);
1962 int error;
1963
1964 PUFFS_MSG_ALLOC(vn, rmdir);
1965 rmdir_msg->pvnr_cookie_targ = ck;
1966 puffs_makecn(&rmdir_msg->pvnr_cn, &rmdir_msg->pvnr_cn_cred,
1967 cnp, PUFFS_USE_FULLPNBUF(pmp));
1968 puffs_msg_setinfo(park_rmdir, PUFFSOP_VN, PUFFS_VN_RMDIR, dck);
1969
1970 PUFFS_MSG_ENQUEUEWAIT(pmp, park_rmdir, error);
1971 PUFFS_MSG_RELEASE(rmdir);
1972
1973 return checkerr(pmp, error, __func__);
1974 }
1975
1976 int
1977 puffs_vnop_rmdir(void *v)
1978 {
1979 struct vop_rmdir_args /* {
1980 const struct vnodeop_desc *a_desc;
1981 struct vnode *a_dvp;
1982 struct vnode *a_vp;
1983 struct componentname *a_cnp;
1984 } */ *ap = v;
1985 PUFFS_MSG_VARS(vn, rmdir);
1986 struct vnode *dvp = ap->a_dvp;
1987 struct vnode *vp = ap->a_vp;
1988 struct puffs_node *dpn = VPTOPP(dvp);
1989 struct puffs_node *pn = VPTOPP(vp);
1990 struct puffs_mount *pmp = MPTOPUFFSMP(dvp->v_mount);
1991 struct componentname *cnp = ap->a_cnp;
1992 int error;
1993
1994 PUFFS_MSG_ALLOC(vn, rmdir);
1995 rmdir_msg->pvnr_cookie_targ = VPTOPNC(vp);
1996 puffs_makecn(&rmdir_msg->pvnr_cn, &rmdir_msg->pvnr_cn_cred,
1997 cnp, PUFFS_USE_FULLPNBUF(pmp));
1998 puffs_msg_setinfo(park_rmdir, PUFFSOP_VN,
1999 PUFFS_VN_RMDIR, VPTOPNC(dvp));
2000
2001 puffs_msg_enqueue(pmp, park_rmdir);
2002 REFPN_AND_UNLOCKVP(dvp, dpn);
2003 REFPN_AND_UNLOCKVP(vp, pn);
2004 error = puffs_msg_wait2(pmp, park_rmdir, dpn, pn);
2005
2006 PUFFS_MSG_RELEASE(rmdir);
2007
2008 puffs_updatenode(VPTOPP(dvp), PUFFS_UPDATECTIME|PUFFS_UPDATEMTIME, 0);
2009
2010 /* XXX: some call cache_purge() *for both vnodes* here, investigate */
2011 RELEPN_AND_VP(dvp, dpn);
2012 RELEPN_AND_VP(vp, pn);
2013
2014 return error;
2015 }
2016
2017 int
2018 puffs_vnop_link(void *v)
2019 {
2020 struct vop_link_v2_args /* {
2021 const struct vnodeop_desc *a_desc;
2022 struct vnode *a_dvp;
2023 struct vnode *a_vp;
2024 struct componentname *a_cnp;
2025 } */ *ap = v;
2026 PUFFS_MSG_VARS(vn, link);
2027 struct vnode *dvp = ap->a_dvp;
2028 struct vnode *vp = ap->a_vp;
2029 struct puffs_node *dpn = VPTOPP(dvp);
2030 struct puffs_node *pn = VPTOPP(vp);
2031 struct puffs_mount *pmp = MPTOPUFFSMP(dvp->v_mount);
2032 struct componentname *cnp = ap->a_cnp;
2033 int error;
2034
2035 PUFFS_MSG_ALLOC(vn, link);
2036 link_msg->pvnr_cookie_targ = VPTOPNC(vp);
2037 puffs_makecn(&link_msg->pvnr_cn, &link_msg->pvnr_cn_cred,
2038 cnp, PUFFS_USE_FULLPNBUF(pmp));
2039 puffs_msg_setinfo(park_link, PUFFSOP_VN,
2040 PUFFS_VN_LINK, VPTOPNC(dvp));
2041
2042 puffs_msg_enqueue(pmp, park_link);
2043 error = puffs_msg_wait2(pmp, park_link, dpn, pn);
2044
2045 PUFFS_MSG_RELEASE(link);
2046
2047 error = checkerr(pmp, error, __func__);
2048
2049 /*
2050 * XXX: stay in touch with the cache. I don't like this, but
2051 * don't have a better solution either. See also puffs_rename().
2052 */
2053 if (error == 0) {
2054 puffs_updatenode(pn, PUFFS_UPDATECTIME, 0);
2055 puffs_updatenode(VPTOPP(dvp),
2056 PUFFS_UPDATECTIME|PUFFS_UPDATEMTIME, 0);
2057 }
2058
2059 return error;
2060 }
2061
2062 int
2063 puffs_vnop_symlink(void *v)
2064 {
2065 struct vop_symlink_v3_args /* {
2066 const struct vnodeop_desc *a_desc;
2067 struct vnode *a_dvp;
2068 struct vnode **a_vpp;
2069 struct componentname *a_cnp;
2070 struct vattr *a_vap;
2071 char *a_target;
2072 } */ *ap = v;
2073 PUFFS_MSG_VARS(vn, symlink);
2074 struct vnode *dvp = ap->a_dvp;
2075 struct puffs_node *dpn = VPTOPP(dvp);
2076 struct mount *mp = dvp->v_mount;
2077 struct puffs_mount *pmp = MPTOPUFFSMP(dvp->v_mount);
2078 struct componentname *cnp = ap->a_cnp;
2079 int error;
2080
2081 *ap->a_vpp = NULL;
2082
2083 PUFFS_MSG_ALLOC(vn, symlink);
2084 puffs_makecn(&symlink_msg->pvnr_cn, &symlink_msg->pvnr_cn_cred,
2085 cnp, PUFFS_USE_FULLPNBUF(pmp));
2086 symlink_msg->pvnr_va = *ap->a_vap;
2087 (void)strlcpy(symlink_msg->pvnr_link, ap->a_target,
2088 sizeof(symlink_msg->pvnr_link));
2089 puffs_msg_setinfo(park_symlink, PUFFSOP_VN,
2090 PUFFS_VN_SYMLINK, VPTOPNC(dvp));
2091
2092 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_symlink, dvp->v_data, NULL, error);
2093
2094 error = checkerr(pmp, error, __func__);
2095 if (error)
2096 goto out;
2097
2098 error = puffs_newnode(mp, dvp, ap->a_vpp,
2099 symlink_msg->pvnr_newnode, cnp, VLNK, 0);
2100 if (error) {
2101 puffs_abortbutton(pmp, PUFFS_ABORT_SYMLINK, dpn->pn_cookie,
2102 symlink_msg->pvnr_newnode, cnp);
2103 goto out;
2104 }
2105
2106 if (PUFFS_USE_FS_TTL(pmp)) {
2107 struct timespec *va_ttl = &symlink_msg->pvnr_va_ttl;
2108 struct timespec *cn_ttl = &symlink_msg->pvnr_cn_ttl;
2109 struct vattr *rvap = &symlink_msg->pvnr_va;
2110
2111 update_va(*ap->a_vpp, NULL, rvap,
2112 va_ttl, cn_ttl, SETATTR_CHSIZE);
2113 }
2114
2115 VPTOPP(*ap->a_vpp)->pn_nlookup++;
2116
2117 if (PUFFS_USE_DOTDOTCACHE(pmp) &&
2118 (VPTOPP(*ap->a_vpp)->pn_parent != dvp))
2119 update_parent(*ap->a_vpp, dvp);
2120
2121 out:
2122 PUFFS_MSG_RELEASE(symlink);
2123
2124 return error;
2125 }
2126
2127 int
2128 puffs_vnop_readlink(void *v)
2129 {
2130 struct vop_readlink_args /* {
2131 const struct vnodeop_desc *a_desc;
2132 struct vnode *a_vp;
2133 struct uio *a_uio;
2134 kauth_cred_t a_cred;
2135 } */ *ap = v;
2136 PUFFS_MSG_VARS(vn, readlink);
2137 struct vnode *vp = ap->a_vp;
2138 struct puffs_mount *pmp = MPTOPUFFSMP(ap->a_vp->v_mount);
2139 size_t linklen;
2140 int error;
2141
2142 PUFFS_MSG_ALLOC(vn, readlink);
2143 puffs_credcvt(&readlink_msg->pvnr_cred, ap->a_cred);
2144 linklen = sizeof(readlink_msg->pvnr_link);
2145 readlink_msg->pvnr_linklen = linklen;
2146 puffs_msg_setinfo(park_readlink, PUFFSOP_VN,
2147 PUFFS_VN_READLINK, VPTOPNC(vp));
2148
2149 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_readlink, vp->v_data, NULL, error);
2150 error = checkerr(pmp, error, __func__);
2151 if (error)
2152 goto out;
2153
2154 /* bad bad user file server */
2155 if (readlink_msg->pvnr_linklen > linklen) {
2156 puffs_senderr(pmp, PUFFS_ERR_READLINK, E2BIG,
2157 "linklen too big", VPTOPNC(ap->a_vp));
2158 error = EPROTO;
2159 goto out;
2160 }
2161
2162 error = uiomove(&readlink_msg->pvnr_link, readlink_msg->pvnr_linklen,
2163 ap->a_uio);
2164 out:
2165 PUFFS_MSG_RELEASE(readlink);
2166 return error;
2167 }
2168
2169 int
2170 puffs_vnop_rename(void *v)
2171 {
2172 struct vop_rename_args /* {
2173 const struct vnodeop_desc *a_desc;
2174 struct vnode *a_fdvp;
2175 struct vnode *a_fvp;
2176 struct componentname *a_fcnp;
2177 struct vnode *a_tdvp;
2178 struct vnode *a_tvp;
2179 struct componentname *a_tcnp;
2180 } */ *ap = v;
2181 PUFFS_MSG_VARS(vn, rename);
2182 struct vnode *fdvp = ap->a_fdvp, *fvp = ap->a_fvp;
2183 struct vnode *tdvp = ap->a_tdvp, *tvp = ap->a_tvp;
2184 struct puffs_node *fpn = ap->a_fvp->v_data;
2185 struct puffs_mount *pmp = MPTOPUFFSMP(fdvp->v_mount);
2186 int error;
2187 bool doabort = true;
2188
2189 if ((fvp->v_mount != tdvp->v_mount) ||
2190 (tvp && (fvp->v_mount != tvp->v_mount))) {
2191 ERROUT(EXDEV);
2192 }
2193
2194 PUFFS_MSG_ALLOC(vn, rename);
2195 rename_msg->pvnr_cookie_src = VPTOPNC(fvp);
2196 rename_msg->pvnr_cookie_targdir = VPTOPNC(tdvp);
2197 if (tvp)
2198 rename_msg->pvnr_cookie_targ = VPTOPNC(tvp);
2199 else
2200 rename_msg->pvnr_cookie_targ = NULL;
2201 puffs_makecn(&rename_msg->pvnr_cn_src, &rename_msg->pvnr_cn_src_cred,
2202 ap->a_fcnp, PUFFS_USE_FULLPNBUF(pmp));
2203 puffs_makecn(&rename_msg->pvnr_cn_targ, &rename_msg->pvnr_cn_targ_cred,
2204 ap->a_tcnp, PUFFS_USE_FULLPNBUF(pmp));
2205 puffs_msg_setinfo(park_rename, PUFFSOP_VN,
2206 PUFFS_VN_RENAME, VPTOPNC(fdvp));
2207
2208 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_rename, fdvp->v_data, NULL, error);
2209 doabort = false;
2210 PUFFS_MSG_RELEASE(rename);
2211 error = checkerr(pmp, error, __func__);
2212
2213 /*
2214 * XXX: stay in touch with the cache. I don't like this, but
2215 * don't have a better solution either. See also puffs_link().
2216 */
2217 if (error == 0) {
2218 puffs_updatenode(fpn, PUFFS_UPDATECTIME, 0);
2219 puffs_updatenode(VPTOPP(fdvp),
2220 PUFFS_UPDATECTIME|PUFFS_UPDATEMTIME, 0);
2221 if (fdvp != tdvp)
2222 puffs_updatenode(VPTOPP(tdvp),
2223 PUFFS_UPDATECTIME|PUFFS_UPDATEMTIME,
2224 0);
2225
2226 if (PUFFS_USE_DOTDOTCACHE(pmp) &&
2227 (VPTOPP(fvp)->pn_parent != tdvp))
2228 update_parent(fvp, tdvp);
2229 }
2230
2231
2232 out:
2233 if (doabort)
2234 VOP_ABORTOP(tdvp, ap->a_tcnp);
2235 if (tvp != NULL)
2236 vput(tvp);
2237 if (tdvp == tvp)
2238 vrele(tdvp);
2239 else
2240 vput(tdvp);
2241
2242 if (doabort)
2243 VOP_ABORTOP(fdvp, ap->a_fcnp);
2244 vrele(fdvp);
2245 vrele(fvp);
2246
2247 return error;
2248 }
2249
2250 #define RWARGS(cont, iofl, move, offset, creds) \
2251 (cont)->pvnr_ioflag = (iofl); \
2252 (cont)->pvnr_resid = (move); \
2253 (cont)->pvnr_offset = (offset); \
2254 puffs_credcvt(&(cont)->pvnr_cred, creds)
2255
2256 int
2257 puffs_vnop_read(void *v)
2258 {
2259 struct vop_read_args /* {
2260 const struct vnodeop_desc *a_desc;
2261 struct vnode *a_vp;
2262 struct uio *a_uio;
2263 int a_ioflag;
2264 kauth_cred_t a_cred;
2265 } */ *ap = v;
2266 PUFFS_MSG_VARS(vn, read);
2267 struct vnode *vp = ap->a_vp;
2268 struct puffs_node *pn = VPTOPP(vp);
2269 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
2270 struct uio *uio = ap->a_uio;
2271 size_t tomove, argsize;
2272 vsize_t bytelen;
2273 int error;
2274
2275 read_msg = NULL;
2276 error = 0;
2277
2278 /* std sanity */
2279 if (uio->uio_resid == 0)
2280 return 0;
2281 if (uio->uio_offset < 0)
2282 return EFBIG;
2283
2284 /*
2285 * On the case of reading empty files and (vp->v_size != 0) below:
2286 * some filesystems (hint: FUSE and distributed filesystems) still
2287 * expect to get the READ in order to update atime. Reading through
2288 * the case filters empty files, therefore we prefer to bypass the
2289 * cache here.
2290 */
2291 if (vp->v_type == VREG &&
2292 PUFFS_USE_PAGECACHE(pmp) &&
2293 !(pn->pn_stat & PNODE_RDIRECT) &&
2294 (vp->v_size != 0)) {
2295 const int advice = IO_ADV_DECODE(ap->a_ioflag);
2296
2297 while (uio->uio_resid > 0) {
2298 if (vp->v_size <= uio->uio_offset) {
2299 break;
2300 }
2301 bytelen = MIN(uio->uio_resid,
2302 vp->v_size - uio->uio_offset);
2303 if (bytelen == 0)
2304 break;
2305
2306 error = ubc_uiomove(&vp->v_uobj, uio, bytelen, advice,
2307 UBC_READ | UBC_PARTIALOK | UBC_UNMAP_FLAG(vp));
2308 if (error)
2309 break;
2310 }
2311
2312 if ((vp->v_mount->mnt_flag & MNT_NOATIME) == 0)
2313 puffs_updatenode(VPTOPP(vp), PUFFS_UPDATEATIME, 0);
2314 } else {
2315 /*
2316 * in case it's not a regular file or we're operating
2317 * uncached, do read in the old-fashioned style,
2318 * i.e. explicit read operations
2319 */
2320
2321 tomove = PUFFS_TOMOVE(uio->uio_resid, pmp);
2322 argsize = sizeof(struct puffs_vnmsg_read);
2323 puffs_msgmem_alloc(argsize + tomove, &park_read,
2324 (void *)&read_msg, 1);
2325
2326 error = 0;
2327 while (uio->uio_resid > 0) {
2328 tomove = PUFFS_TOMOVE(uio->uio_resid, pmp);
2329 memset(read_msg, 0, argsize); /* XXX: touser KASSERT */
2330 RWARGS(read_msg, ap->a_ioflag, tomove,
2331 uio->uio_offset, ap->a_cred);
2332 puffs_msg_setinfo(park_read, PUFFSOP_VN,
2333 PUFFS_VN_READ, VPTOPNC(vp));
2334 puffs_msg_setdelta(park_read, tomove);
2335
2336 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_read, vp->v_data,
2337 NULL, error);
2338 error = checkerr(pmp, error, __func__);
2339 if (error)
2340 break;
2341
2342 if (read_msg->pvnr_resid > tomove) {
2343 puffs_senderr(pmp, PUFFS_ERR_READ,
2344 E2BIG, "resid grew", VPTOPNC(ap->a_vp));
2345 error = EPROTO;
2346 break;
2347 }
2348
2349 error = uiomove(read_msg->pvnr_data,
2350 tomove - read_msg->pvnr_resid, uio);
2351
2352 /*
2353 * in case the file is out of juice, resid from
2354 * userspace is != 0. and the error-case is
2355 * quite obvious
2356 */
2357 if (error || read_msg->pvnr_resid)
2358 break;
2359 }
2360
2361 puffs_msgmem_release(park_read);
2362 }
2363
2364 return error;
2365 }
2366
2367 /*
2368 * XXX: in case of a failure, this leaves uio in a bad state.
2369 * We could theoretically copy the uio and iovecs and "replay"
2370 * them the right amount after the userspace trip, but don't
2371 * bother for now.
2372 */
2373 int
2374 puffs_vnop_write(void *v)
2375 {
2376 struct vop_write_args /* {
2377 const struct vnodeop_desc *a_desc;
2378 struct vnode *a_vp;
2379 struct uio *a_uio;
2380 int a_ioflag;
2381 kauth_cred_t a_cred;
2382 } */ *ap = v;
2383 PUFFS_MSG_VARS(vn, write);
2384 struct vnode *vp = ap->a_vp;
2385 struct puffs_node *pn = VPTOPP(vp);
2386 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
2387 struct uio *uio = ap->a_uio;
2388 size_t tomove, argsize;
2389 off_t oldoff, newoff, origoff;
2390 vsize_t bytelen;
2391 int error, uflags;
2392 int ubcflags;
2393
2394 error = uflags = 0;
2395 write_msg = NULL;
2396
2397 /* std sanity */
2398 if (uio->uio_resid == 0)
2399 return 0;
2400 if (uio->uio_offset < 0)
2401 return EFBIG;
2402
2403 mutex_enter(&pn->pn_sizemtx);
2404
2405 /*
2406 * userspace *should* be allowed to control this,
2407 * but with UBC it's a bit unclear how to handle it
2408 */
2409 if (ap->a_ioflag & IO_APPEND)
2410 uio->uio_offset = vp->v_size;
2411
2412 origoff = uio->uio_offset;
2413
2414 if (vp->v_type == VREG &&
2415 PUFFS_USE_PAGECACHE(pmp) &&
2416 !(pn->pn_stat & PNODE_WDIRECT)) {
2417 ubcflags = UBC_WRITE | UBC_PARTIALOK | UBC_UNMAP_FLAG(vp);
2418
2419 while (uio->uio_resid > 0) {
2420 oldoff = uio->uio_offset;
2421 bytelen = uio->uio_resid;
2422
2423 newoff = oldoff + bytelen;
2424 if (vp->v_size < newoff) {
2425 uvm_vnp_setwritesize(vp, newoff);
2426 }
2427 error = ubc_uiomove(&vp->v_uobj, uio, bytelen,
2428 UVM_ADV_RANDOM, ubcflags);
2429
2430 /*
2431 * In case of a ubc_uiomove() error,
2432 * opt to not extend the file at all and
2433 * return an error. Otherwise, if we attempt
2434 * to clear the memory we couldn't fault to,
2435 * we might generate a kernel page fault.
2436 */
2437 if (vp->v_size < newoff) {
2438 if (error == 0) {
2439 uflags |= PUFFS_UPDATESIZE;
2440 uvm_vnp_setsize(vp, newoff);
2441 } else {
2442 uvm_vnp_setwritesize(vp, vp->v_size);
2443 }
2444 }
2445 if (error)
2446 break;
2447
2448 /*
2449 * If we're writing large files, flush to file server
2450 * every 64k. Otherwise we can very easily exhaust
2451 * kernel and user memory, as the file server cannot
2452 * really keep up with our writing speed.
2453 *
2454 * Note: this does *NOT* honor MNT_ASYNC, because
2455 * that gives userland too much say in the kernel.
2456 */
2457 if (oldoff >> 16 != uio->uio_offset >> 16) {
2458 mutex_enter(vp->v_interlock);
2459 error = VOP_PUTPAGES(vp, oldoff & ~0xffff,
2460 uio->uio_offset & ~0xffff,
2461 PGO_CLEANIT | PGO_SYNCIO);
2462 if (error)
2463 break;
2464 }
2465 }
2466
2467 /* synchronous I/O? */
2468 if (error == 0 && ap->a_ioflag & IO_SYNC) {
2469 mutex_enter(vp->v_interlock);
2470 error = VOP_PUTPAGES(vp, trunc_page(origoff),
2471 round_page(uio->uio_offset),
2472 PGO_CLEANIT | PGO_SYNCIO);
2473
2474 /* write through page cache? */
2475 } else if (error == 0 && pmp->pmp_flags & PUFFS_KFLAG_WTCACHE) {
2476 mutex_enter(vp->v_interlock);
2477 error = VOP_PUTPAGES(vp, trunc_page(origoff),
2478 round_page(uio->uio_offset), PGO_CLEANIT);
2479 }
2480 } else {
2481 /* tomove is non-increasing */
2482 tomove = PUFFS_TOMOVE(uio->uio_resid, pmp);
2483 argsize = sizeof(struct puffs_vnmsg_write) + tomove;
2484 puffs_msgmem_alloc(argsize, &park_write, (void *)&write_msg,1);
2485
2486 while (uio->uio_resid > 0) {
2487 /* move data to buffer */
2488 tomove = PUFFS_TOMOVE(uio->uio_resid, pmp);
2489 memset(write_msg, 0, argsize); /* XXX: touser KASSERT */
2490 RWARGS(write_msg, ap->a_ioflag, tomove,
2491 uio->uio_offset, ap->a_cred);
2492 error = uiomove(write_msg->pvnr_data, tomove, uio);
2493 if (error)
2494 break;
2495
2496 /* move buffer to userspace */
2497 puffs_msg_setinfo(park_write, PUFFSOP_VN,
2498 PUFFS_VN_WRITE, VPTOPNC(vp));
2499 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_write, vp->v_data,
2500 NULL, error);
2501 error = checkerr(pmp, error, __func__);
2502 if (error)
2503 break;
2504
2505 if (write_msg->pvnr_resid > tomove) {
2506 puffs_senderr(pmp, PUFFS_ERR_WRITE,
2507 E2BIG, "resid grew", VPTOPNC(ap->a_vp));
2508 error = EPROTO;
2509 break;
2510 }
2511
2512 /* adjust file size */
2513 if (vp->v_size < uio->uio_offset) {
2514 uflags |= PUFFS_UPDATESIZE;
2515 uvm_vnp_setsize(vp, uio->uio_offset);
2516 }
2517
2518 /* didn't move everything? bad userspace. bail */
2519 if (write_msg->pvnr_resid != 0) {
2520 error = EIO;
2521 break;
2522 }
2523 }
2524 puffs_msgmem_release(park_write);
2525
2526 /*
2527 * Direct I/O on write but not on read: we must
2528 * invlidate the written pages so that we read
2529 * the written data and not the stalled cache.
2530 */
2531 if ((error == 0) &&
2532 (vp->v_type == VREG) && PUFFS_USE_PAGECACHE(pmp) &&
2533 (pn->pn_stat & PNODE_WDIRECT) &&
2534 !(pn->pn_stat & PNODE_RDIRECT)) {
2535 voff_t off_lo = trunc_page(origoff);
2536 voff_t off_hi = round_page(uio->uio_offset);
2537
2538 mutex_enter(vp->v_uobj.vmobjlock);
2539 error = VOP_PUTPAGES(vp, off_lo, off_hi, PGO_FREE);
2540 }
2541 }
2542
2543 if (vp->v_mount->mnt_flag & MNT_RELATIME)
2544 uflags |= PUFFS_UPDATEATIME;
2545 uflags |= PUFFS_UPDATECTIME;
2546 uflags |= PUFFS_UPDATEMTIME;
2547 puffs_updatenode(VPTOPP(vp), uflags, vp->v_size);
2548
2549 /*
2550 * If we do not use meta flush, we need to update the
2551 * filesystem now, otherwise we will get a stale value
2552 * on the next GETATTR
2553 */
2554 if (!PUFFS_USE_METAFLUSH(pmp) && (uflags & PUFFS_UPDATESIZE)) {
2555 struct vattr va;
2556 int ret;
2557
2558 vattr_null(&va);
2559 va.va_size = vp->v_size;
2560 ret = dosetattr(vp, &va, FSCRED, 0);
2561 if (ret) {
2562 DPRINTF(("dosetattr set size to %jd failed: %d\n",
2563 (intmax_t)vp->v_size, ret));
2564 }
2565 }
2566 mutex_exit(&pn->pn_sizemtx);
2567 return error;
2568 }
2569
2570 int
2571 puffs_vnop_fallocate(void *v)
2572 {
2573 struct vop_fallocate_args /* {
2574 const struct vnodeop_desc *a_desc;
2575 struct vnode *a_vp;
2576 off_t a_pos;
2577 off_t a_len;
2578 } */ *ap = v;
2579 struct vnode *vp = ap->a_vp;
2580 struct puffs_node *pn = VPTOPP(vp);
2581 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
2582 PUFFS_MSG_VARS(vn, fallocate);
2583 int error;
2584
2585 mutex_enter(&pn->pn_sizemtx);
2586
2587 PUFFS_MSG_ALLOC(vn, fallocate);
2588 fallocate_msg->pvnr_off = ap->a_pos;
2589 fallocate_msg->pvnr_len = ap->a_len;
2590 puffs_msg_setinfo(park_fallocate, PUFFSOP_VN,
2591 PUFFS_VN_FALLOCATE, VPTOPNC(vp));
2592
2593 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_fallocate, vp->v_data, NULL, error);
2594 error = checkerr(pmp, error, __func__);
2595 PUFFS_MSG_RELEASE(fallocate);
2596
2597 switch (error) {
2598 case 0:
2599 break;
2600 case EAGAIN:
2601 error = EIO;
2602 /* FALLTHROUGH */
2603 default:
2604 goto out;
2605 }
2606
2607 if (ap->a_pos + ap->a_len > vp->v_size) {
2608 uvm_vnp_setsize(vp, ap->a_pos + ap->a_len);
2609 puffs_updatenode(pn, PUFFS_UPDATESIZE, vp->v_size);
2610 }
2611 out:
2612 mutex_exit(&pn->pn_sizemtx);
2613
2614 return error;
2615 }
2616
2617 int
2618 puffs_vnop_fdiscard(void *v)
2619 {
2620 struct vop_fdiscard_args /* {
2621 const struct vnodeop_desc *a_desc;
2622 struct vnode *a_vp;
2623 off_t a_pos;
2624 off_t a_len;
2625 } */ *ap = v;
2626 struct vnode *vp = ap->a_vp;
2627 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
2628 PUFFS_MSG_VARS(vn, fdiscard);
2629 int error;
2630
2631 PUFFS_MSG_ALLOC(vn, fdiscard);
2632 fdiscard_msg->pvnr_off = ap->a_pos;
2633 fdiscard_msg->pvnr_len = ap->a_len;
2634 puffs_msg_setinfo(park_fdiscard, PUFFSOP_VN,
2635 PUFFS_VN_FALLOCATE, VPTOPNC(vp));
2636
2637 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_fdiscard, vp->v_data, NULL, error);
2638 error = checkerr(pmp, error, __func__);
2639 PUFFS_MSG_RELEASE(fdiscard);
2640
2641 return error;
2642 }
2643
2644 int
2645 puffs_vnop_print(void *v)
2646 {
2647 struct vop_print_args /* {
2648 struct vnode *a_vp;
2649 } */ *ap = v;
2650 PUFFS_MSG_VARS(vn, print);
2651 struct vnode *vp = ap->a_vp;
2652 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
2653 struct puffs_node *pn = vp->v_data;
2654
2655 /* kernel portion */
2656 printf("tag VT_PUFFS, vnode %p, puffs node: %p,\n"
2657 "\tuserspace cookie: %p", vp, pn, pn->pn_cookie);
2658 if (vp->v_type == VFIFO)
2659 VOCALL(fifo_vnodeop_p, VOFFSET(vop_print), v);
2660 printf("\n");
2661
2662 /* userspace portion */
2663 if (EXISTSOP(pmp, PRINT)) {
2664 PUFFS_MSG_ALLOC(vn, print);
2665 puffs_msg_setinfo(park_print, PUFFSOP_VN,
2666 PUFFS_VN_PRINT, VPTOPNC(vp));
2667 PUFFS_MSG_ENQUEUEWAIT2_NOERROR(pmp, park_print, vp->v_data,
2668 NULL);
2669 PUFFS_MSG_RELEASE(print);
2670 }
2671
2672 return 0;
2673 }
2674
2675 int
2676 puffs_vnop_pathconf(void *v)
2677 {
2678 struct vop_pathconf_args /* {
2679 const struct vnodeop_desc *a_desc;
2680 struct vnode *a_vp;
2681 int a_name;
2682 register_t *a_retval;
2683 } */ *ap = v;
2684 PUFFS_MSG_VARS(vn, pathconf);
2685 struct vnode *vp = ap->a_vp;
2686 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
2687 int error;
2688
2689 PUFFS_MSG_ALLOC(vn, pathconf);
2690 pathconf_msg->pvnr_name = ap->a_name;
2691 puffs_msg_setinfo(park_pathconf, PUFFSOP_VN,
2692 PUFFS_VN_PATHCONF, VPTOPNC(vp));
2693 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_pathconf, vp->v_data, NULL, error);
2694 error = checkerr(pmp, error, __func__);
2695 if (!error)
2696 *ap->a_retval = pathconf_msg->pvnr_retval;
2697 PUFFS_MSG_RELEASE(pathconf);
2698
2699 return error;
2700 }
2701
2702 int
2703 puffs_vnop_advlock(void *v)
2704 {
2705 struct vop_advlock_args /* {
2706 const struct vnodeop_desc *a_desc;
2707 struct vnode *a_vp;
2708 void *a_id;
2709 int a_op;
2710 struct flock *a_fl;
2711 int a_flags;
2712 } */ *ap = v;
2713 PUFFS_MSG_VARS(vn, advlock);
2714 struct vnode *vp = ap->a_vp;
2715 struct puffs_node *pn = VPTOPP(vp);
2716 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
2717 int error;
2718
2719 if (!EXISTSOP(pmp, ADVLOCK))
2720 return lf_advlock(ap, &pn->pn_lockf, vp->v_size);
2721
2722 PUFFS_MSG_ALLOC(vn, advlock);
2723 (void)memcpy(&advlock_msg->pvnr_fl, ap->a_fl,
2724 sizeof(advlock_msg->pvnr_fl));
2725 advlock_msg->pvnr_id = ap->a_id;
2726 advlock_msg->pvnr_op = ap->a_op;
2727 advlock_msg->pvnr_flags = ap->a_flags;
2728 puffs_msg_setinfo(park_advlock, PUFFSOP_VN,
2729 PUFFS_VN_ADVLOCK, VPTOPNC(vp));
2730 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_advlock, vp->v_data, NULL, error);
2731 error = checkerr(pmp, error, __func__);
2732 PUFFS_MSG_RELEASE(advlock);
2733
2734 return error;
2735 }
2736
2737 int
2738 puffs_vnop_abortop(void *v)
2739 {
2740 struct vop_abortop_args /* {
2741 struct vnode *a_dvp;
2742 struct componentname *a_cnp;
2743 }; */ *ap = v;
2744 PUFFS_MSG_VARS(vn, abortop);
2745 struct vnode *dvp = ap->a_dvp;
2746 struct puffs_mount *pmp = MPTOPUFFSMP(dvp->v_mount);
2747 struct componentname *cnp = ap->a_cnp;
2748
2749 if (EXISTSOP(pmp, ABORTOP)) {
2750 PUFFS_MSG_ALLOC(vn, abortop);
2751 puffs_makecn(&abortop_msg->pvnr_cn, &abortop_msg->pvnr_cn_cred,
2752 cnp, PUFFS_USE_FULLPNBUF(pmp));
2753 puffs_msg_setfaf(park_abortop);
2754 puffs_msg_setinfo(park_abortop, PUFFSOP_VN,
2755 PUFFS_VN_ABORTOP, VPTOPNC(dvp));
2756
2757 puffs_msg_enqueue(pmp, park_abortop);
2758 PUFFS_MSG_RELEASE(abortop);
2759 }
2760
2761 return genfs_abortop(v);
2762 }
2763
2764 #define BIOASYNC(bp) (bp->b_flags & B_ASYNC)
2765
2766 /*
2767 * This maps itself to PUFFS_VN_READ/WRITE for data transfer.
2768 */
2769 int
2770 puffs_vnop_strategy(void *v)
2771 {
2772 struct vop_strategy_args /* {
2773 const struct vnodeop_desc *a_desc;
2774 struct vnode *a_vp;
2775 struct buf *a_bp;
2776 } */ *ap = v;
2777 PUFFS_MSG_VARS(vn, rw);
2778 struct vnode *vp = ap->a_vp;
2779 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
2780 struct puffs_node *pn;
2781 struct buf *bp;
2782 size_t argsize;
2783 size_t tomove, moved;
2784 int error, dofaf, cansleep, dobiodone;
2785
2786 pmp = MPTOPUFFSMP(vp->v_mount);
2787 bp = ap->a_bp;
2788 error = 0;
2789 dofaf = 0;
2790 cansleep = 0;
2791 pn = VPTOPP(vp);
2792 park_rw = NULL; /* explicit */
2793 dobiodone = 1;
2794
2795 if ((BUF_ISREAD(bp) && !EXISTSOP(pmp, READ))
2796 || (BUF_ISWRITE(bp) && !EXISTSOP(pmp, WRITE)))
2797 ERROUT(EOPNOTSUPP);
2798
2799 /*
2800 * Short-circuit optimization: don't flush buffer in between
2801 * VOP_INACTIVE and VOP_RECLAIM in case the node has no references.
2802 */
2803 if (pn->pn_stat & PNODE_DYING) {
2804 KASSERT(BUF_ISWRITE(bp));
2805 bp->b_resid = 0;
2806 goto out;
2807 }
2808
2809 #ifdef DIAGNOSTIC
2810 if (bp->b_bcount > pmp->pmp_msg_maxsize - PUFFS_MSGSTRUCT_MAX)
2811 panic("puffs_strategy: wildly inappropriate buf bcount %d",
2812 bp->b_bcount);
2813 #endif
2814
2815 /*
2816 * See explanation for the necessity of a FAF in puffs_fsync.
2817 *
2818 * Also, do FAF in case we're suspending.
2819 * See puffs_vfsops.c:pageflush()
2820 */
2821 if (BUF_ISWRITE(bp)) {
2822 mutex_enter(vp->v_interlock);
2823 if (vdead_check(vp, VDEAD_NOWAIT) != 0)
2824 dofaf = 1;
2825 if (pn->pn_stat & PNODE_FAF)
2826 dofaf = 1;
2827 mutex_exit(vp->v_interlock);
2828 }
2829
2830 cansleep = (curlwp == uvm.pagedaemon_lwp || dofaf) ? 0 : 1;
2831
2832 KASSERT(curlwp != uvm.pagedaemon_lwp || dofaf || BIOASYNC(bp));
2833
2834 /* allocate transport structure */
2835 tomove = PUFFS_TOMOVE(bp->b_bcount, pmp);
2836 argsize = sizeof(struct puffs_vnmsg_rw);
2837 error = puffs_msgmem_alloc(argsize + tomove, &park_rw,
2838 (void *)&rw_msg, cansleep);
2839 if (error)
2840 goto out;
2841 RWARGS(rw_msg, 0, tomove, bp->b_blkno << DEV_BSHIFT, FSCRED);
2842
2843 /* 2x2 cases: read/write, faf/nofaf */
2844 if (BUF_ISREAD(bp)) {
2845 puffs_msg_setinfo(park_rw, PUFFSOP_VN,
2846 PUFFS_VN_READ, VPTOPNC(vp));
2847 puffs_msg_setdelta(park_rw, tomove);
2848 if (BIOASYNC(bp)) {
2849 puffs_msg_setcall(park_rw,
2850 puffs_parkdone_asyncbioread, bp);
2851 puffs_msg_enqueue(pmp, park_rw);
2852 dobiodone = 0;
2853 } else {
2854 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_rw, vp->v_data,
2855 NULL, error);
2856 error = checkerr(pmp, error, __func__);
2857 if (error)
2858 goto out;
2859
2860 if (rw_msg->pvnr_resid > tomove) {
2861 puffs_senderr(pmp, PUFFS_ERR_READ,
2862 E2BIG, "resid grew", VPTOPNC(vp));
2863 ERROUT(EPROTO);
2864 }
2865
2866 moved = tomove - rw_msg->pvnr_resid;
2867
2868 (void)memcpy(bp->b_data, rw_msg->pvnr_data, moved);
2869 bp->b_resid = bp->b_bcount - moved;
2870 }
2871 } else {
2872 puffs_msg_setinfo(park_rw, PUFFSOP_VN,
2873 PUFFS_VN_WRITE, VPTOPNC(vp));
2874 /*
2875 * make pages read-only before we write them if we want
2876 * write caching info
2877 */
2878 if (PUFFS_WCACHEINFO(pmp)) {
2879 struct uvm_object *uobj = &vp->v_uobj;
2880 int npages = (bp->b_bcount + PAGE_SIZE-1) >> PAGE_SHIFT;
2881 struct vm_page *vmp;
2882 int i;
2883
2884 for (i = 0; i < npages; i++) {
2885 vmp= uvm_pageratop((vaddr_t)bp->b_data
2886 + (i << PAGE_SHIFT));
2887 DPRINTF(("puffs_strategy: write-protecting "
2888 "vp %p page %p, offset %" PRId64"\n",
2889 vp, vmp, vmp->offset));
2890 mutex_enter(uobj->vmobjlock);
2891 vmp->flags |= PG_RDONLY;
2892 pmap_page_protect(vmp, VM_PROT_READ);
2893 mutex_exit(uobj->vmobjlock);
2894 }
2895 }
2896
2897 (void)memcpy(&rw_msg->pvnr_data, bp->b_data, tomove);
2898 if (dofaf) {
2899 puffs_msg_setfaf(park_rw);
2900 } else if (BIOASYNC(bp)) {
2901 puffs_msg_setcall(park_rw,
2902 puffs_parkdone_asyncbiowrite, bp);
2903 dobiodone = 0;
2904 }
2905
2906 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_rw, vp->v_data, NULL, error);
2907
2908 if (dobiodone == 0)
2909 goto out;
2910
2911 error = checkerr(pmp, error, __func__);
2912 if (error)
2913 goto out;
2914
2915 if (rw_msg->pvnr_resid > tomove) {
2916 puffs_senderr(pmp, PUFFS_ERR_WRITE,
2917 E2BIG, "resid grew", VPTOPNC(vp));
2918 ERROUT(EPROTO);
2919 }
2920
2921 /*
2922 * FAF moved everything. Frankly, we don't
2923 * really have a choice.
2924 */
2925 if (dofaf && error == 0)
2926 moved = tomove;
2927 else
2928 moved = tomove - rw_msg->pvnr_resid;
2929
2930 bp->b_resid = bp->b_bcount - moved;
2931 if (bp->b_resid != 0) {
2932 ERROUT(EIO);
2933 }
2934 }
2935
2936 out:
2937 if (park_rw)
2938 puffs_msgmem_release(park_rw);
2939
2940 if (error)
2941 bp->b_error = error;
2942
2943 if (error || dobiodone)
2944 biodone(bp);
2945
2946 return error;
2947 }
2948
2949 int
2950 puffs_vnop_mmap(void *v)
2951 {
2952 struct vop_mmap_args /* {
2953 const struct vnodeop_desc *a_desc;
2954 struct vnode *a_vp;
2955 vm_prot_t a_prot;
2956 kauth_cred_t a_cred;
2957 } */ *ap = v;
2958 PUFFS_MSG_VARS(vn, mmap);
2959 struct vnode *vp = ap->a_vp;
2960 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
2961 int error;
2962
2963 if (!PUFFS_USE_PAGECACHE(pmp))
2964 return genfs_eopnotsupp(v);
2965
2966 if (EXISTSOP(pmp, MMAP)) {
2967 PUFFS_MSG_ALLOC(vn, mmap);
2968 mmap_msg->pvnr_prot = ap->a_prot;
2969 puffs_credcvt(&mmap_msg->pvnr_cred, ap->a_cred);
2970 puffs_msg_setinfo(park_mmap, PUFFSOP_VN,
2971 PUFFS_VN_MMAP, VPTOPNC(vp));
2972
2973 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_mmap, vp->v_data, NULL, error);
2974 error = checkerr(pmp, error, __func__);
2975 PUFFS_MSG_RELEASE(mmap);
2976 } else {
2977 error = genfs_mmap(v);
2978 }
2979
2980 return error;
2981 }
2982
2983
2984 /*
2985 * The rest don't get a free trip to userspace and back, they
2986 * have to stay within the kernel.
2987 */
2988
2989 /*
2990 * bmap doesn't really make any sense for puffs, so just 1:1 map it.
2991 * well, maybe somehow, somewhere, some day ....
2992 */
2993 int
2994 puffs_vnop_bmap(void *v)
2995 {
2996 struct vop_bmap_args /* {
2997 const struct vnodeop_desc *a_desc;
2998 struct vnode *a_vp;
2999 daddr_t a_bn;
3000 struct vnode **a_vpp;
3001 daddr_t *a_bnp;
3002 int *a_runp;
3003 } */ *ap = v;
3004 struct puffs_mount *pmp;
3005
3006 pmp = MPTOPUFFSMP(ap->a_vp->v_mount);
3007
3008 if (ap->a_vpp)
3009 *ap->a_vpp = ap->a_vp;
3010 if (ap->a_bnp)
3011 *ap->a_bnp = ap->a_bn;
3012 if (ap->a_runp)
3013 *ap->a_runp
3014 = (PUFFS_TOMOVE(pmp->pmp_msg_maxsize, pmp)>>DEV_BSHIFT) - 1;
3015
3016 return 0;
3017 }
3018
3019 /*
3020 * Handle getpages faults in puffs. We let genfs_getpages() do most
3021 * of the dirty work, but we come in this route to do accounting tasks.
3022 * If the user server has specified functions for cache notifications
3023 * about reads and/or writes, we record which type of operation we got,
3024 * for which page range, and proceed to issue a FAF notification to the
3025 * server about it.
3026 */
3027 int
3028 puffs_vnop_getpages(void *v)
3029 {
3030 struct vop_getpages_args /* {
3031 const struct vnodeop_desc *a_desc;
3032 struct vnode *a_vp;
3033 voff_t a_offset;
3034 struct vm_page **a_m;
3035 int *a_count;
3036 int a_centeridx;
3037 vm_prot_t a_access_type;
3038 int a_advice;
3039 int a_flags;
3040 } */ *ap = v;
3041 struct puffs_mount *pmp;
3042 struct puffs_node *pn;
3043 struct vnode *vp;
3044 struct vm_page **pgs;
3045 struct puffs_cacheinfo *pcinfo = NULL;
3046 struct puffs_cacherun *pcrun;
3047 void *parkmem = NULL;
3048 size_t runsizes;
3049 int i, npages, si, streakon;
3050 int error, locked, write;
3051
3052 pmp = MPTOPUFFSMP(ap->a_vp->v_mount);
3053 npages = *ap->a_count;
3054 pgs = ap->a_m;
3055 vp = ap->a_vp;
3056 pn = vp->v_data;
3057 locked = (ap->a_flags & PGO_LOCKED) != 0;
3058 write = (ap->a_access_type & VM_PROT_WRITE) != 0;
3059
3060 /* ccg xnaht - gets Wuninitialized wrong */
3061 pcrun = NULL;
3062 runsizes = 0;
3063
3064 /*
3065 * Check that we aren't trying to fault in pages which our file
3066 * server doesn't know about. This happens if we extend a file by
3067 * skipping some pages and later try to fault in pages which
3068 * are between pn_serversize and vp_size. This check optimizes
3069 * away the common case where a file is being extended.
3070 */
3071 if (ap->a_offset >= pn->pn_serversize && ap->a_offset < vp->v_size) {
3072 struct vattr va;
3073
3074 /* try again later when we can block */
3075 if (locked)
3076 ERROUT(EBUSY);
3077
3078 mutex_exit(vp->v_interlock);
3079 vattr_null(&va);
3080 va.va_size = vp->v_size;
3081 error = dosetattr(vp, &va, FSCRED, 0);
3082 if (error)
3083 ERROUT(error);
3084 mutex_enter(vp->v_interlock);
3085 }
3086
3087 if (write && PUFFS_WCACHEINFO(pmp)) {
3088 #ifdef notnowjohn
3089 /* allocate worst-case memory */
3090 runsizes = ((npages / 2) + 1) * sizeof(struct puffs_cacherun);
3091 KASSERT(curlwp != uvm.pagedaemon_lwp || locked);
3092 pcinfo = kmem_zalloc(sizeof(struct puffs_cacheinfo) + runsize,
3093 locked ? KM_NOSLEEP : KM_SLEEP);
3094
3095 /*
3096 * can't block if we're locked and can't mess up caching
3097 * information for fs server. so come back later, please
3098 */
3099 if (pcinfo == NULL)
3100 ERROUT(ENOMEM);
3101
3102 parkmem = puffs_park_alloc(locked == 0);
3103 if (parkmem == NULL)
3104 ERROUT(ENOMEM);
3105
3106 pcrun = pcinfo->pcache_runs;
3107 #else
3108 (void)parkmem;
3109 #endif
3110 }
3111
3112 error = genfs_getpages(v);
3113 if (error)
3114 goto out;
3115
3116 if (PUFFS_WCACHEINFO(pmp) == 0)
3117 goto out;
3118
3119 /*
3120 * Let's see whose fault it was and inform the user server of
3121 * possibly read/written pages. Map pages from read faults
3122 * strictly read-only, since otherwise we might miss info on
3123 * when the page is actually write-faulted to.
3124 */
3125 if (!locked)
3126 mutex_enter(vp->v_uobj.vmobjlock);
3127 for (i = 0, si = 0, streakon = 0; i < npages; i++) {
3128 if (pgs[i] == NULL || pgs[i] == PGO_DONTCARE) {
3129 if (streakon && write) {
3130 streakon = 0;
3131 pcrun[si].pcache_runend
3132 = trunc_page(pgs[i]->offset) + PAGE_MASK;
3133 si++;
3134 }
3135 continue;
3136 }
3137 if (streakon == 0 && write) {
3138 streakon = 1;
3139 pcrun[si].pcache_runstart = pgs[i]->offset;
3140 }
3141
3142 if (!write)
3143 pgs[i]->flags |= PG_RDONLY;
3144 }
3145 /* was the last page part of our streak? */
3146 if (streakon) {
3147 pcrun[si].pcache_runend
3148 = trunc_page(pgs[i-1]->offset) + PAGE_MASK;
3149 si++;
3150 }
3151 if (!locked)
3152 mutex_exit(vp->v_uobj.vmobjlock);
3153
3154 KASSERT(si <= (npages / 2) + 1);
3155
3156 #ifdef notnowjohn
3157 /* send results to userspace */
3158 if (write)
3159 puffs_cacheop(pmp, parkmem, pcinfo,
3160 sizeof(struct puffs_cacheinfo) + runsizes, VPTOPNC(vp));
3161 #endif
3162
3163 out:
3164 if (error) {
3165 if (pcinfo != NULL)
3166 kmem_free(pcinfo,
3167 sizeof(struct puffs_cacheinfo) + runsizes);
3168 #ifdef notnowjohn
3169 if (parkmem != NULL)
3170 puffs_park_release(parkmem, 1);
3171 #endif
3172 }
3173
3174 return error;
3175 }
3176
3177 /*
3178 * Extended attribute support.
3179 */
3180
3181 int
3182 puffs_vnop_getextattr(void *v)
3183 {
3184 struct vop_getextattr_args /*
3185 struct vnode *a_vp;
3186 int a_attrnamespace;
3187 const char *a_name;
3188 struct uio *a_uio;
3189 size_t *a_size;
3190 kauth_cred_t a_cred;
3191 }; */ *ap = v;
3192 PUFFS_MSG_VARS(vn, getextattr);
3193 struct vnode *vp = ap->a_vp;
3194 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
3195 int attrnamespace = ap->a_attrnamespace;
3196 const char *name = ap->a_name;
3197 struct uio *uio = ap->a_uio;
3198 size_t *sizep = ap->a_size;
3199 size_t tomove, resid;
3200 int error;
3201
3202 if (uio)
3203 resid = uio->uio_resid;
3204 else
3205 resid = 0;
3206
3207 tomove = PUFFS_TOMOVE(resid, pmp);
3208 if (tomove != resid) {
3209 error = E2BIG;
3210 goto out;
3211 }
3212
3213 puffs_msgmem_alloc(sizeof(struct puffs_vnmsg_getextattr) + tomove,
3214 &park_getextattr, (void *)&getextattr_msg, 1);
3215
3216 getextattr_msg->pvnr_attrnamespace = attrnamespace;
3217 strlcpy(getextattr_msg->pvnr_attrname, name,
3218 sizeof(getextattr_msg->pvnr_attrname));
3219 puffs_credcvt(&getextattr_msg->pvnr_cred, ap->a_cred);
3220 if (sizep)
3221 getextattr_msg->pvnr_datasize = 1;
3222 getextattr_msg->pvnr_resid = tomove;
3223
3224 puffs_msg_setinfo(park_getextattr,
3225 PUFFSOP_VN, PUFFS_VN_GETEXTATTR, VPTOPNC(vp));
3226 puffs_msg_setdelta(park_getextattr, tomove);
3227 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_getextattr, vp->v_data, NULL, error);
3228
3229 error = checkerr(pmp, error, __func__);
3230 if (error)
3231 goto out;
3232
3233 resid = getextattr_msg->pvnr_resid;
3234 if (resid > tomove) {
3235 puffs_senderr(pmp, PUFFS_ERR_GETEXTATTR, E2BIG,
3236 "resid grew", VPTOPNC(vp));
3237 error = EPROTO;
3238 goto out;
3239 }
3240
3241 if (sizep)
3242 *sizep = getextattr_msg->pvnr_datasize;
3243 if (uio)
3244 error = uiomove(getextattr_msg->pvnr_data, tomove - resid, uio);
3245
3246 out:
3247 PUFFS_MSG_RELEASE(getextattr);
3248 return error;
3249 }
3250
3251 int
3252 puffs_vnop_setextattr(void *v)
3253 {
3254 struct vop_setextattr_args /* {
3255 struct vnode *a_vp;
3256 int a_attrnamespace;
3257 const char *a_name;
3258 struct uio *a_uio;
3259 kauth_cred_t a_cred;
3260 }; */ *ap = v;
3261 PUFFS_MSG_VARS(vn, setextattr);
3262 struct vnode *vp = ap->a_vp;
3263 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
3264 int attrnamespace = ap->a_attrnamespace;
3265 const char *name = ap->a_name;
3266 struct uio *uio = ap->a_uio;
3267 size_t tomove, resid;
3268 int error;
3269
3270 if (uio)
3271 resid = uio->uio_resid;
3272 else
3273 resid = 0;
3274
3275 tomove = PUFFS_TOMOVE(resid, pmp);
3276 if (tomove != resid) {
3277 error = E2BIG;
3278 goto out;
3279 }
3280
3281 puffs_msgmem_alloc(sizeof(struct puffs_vnmsg_setextattr) + tomove,
3282 &park_setextattr, (void *)&setextattr_msg, 1);
3283
3284 setextattr_msg->pvnr_attrnamespace = attrnamespace;
3285 strlcpy(setextattr_msg->pvnr_attrname, name,
3286 sizeof(setextattr_msg->pvnr_attrname));
3287 puffs_credcvt(&setextattr_msg->pvnr_cred, ap->a_cred);
3288 setextattr_msg->pvnr_resid = tomove;
3289
3290 if (uio) {
3291 error = uiomove(setextattr_msg->pvnr_data, tomove, uio);
3292 if (error)
3293 goto out;
3294 }
3295
3296 puffs_msg_setinfo(park_setextattr,
3297 PUFFSOP_VN, PUFFS_VN_SETEXTATTR, VPTOPNC(vp));
3298 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_setextattr, vp->v_data, NULL, error);
3299
3300 error = checkerr(pmp, error, __func__);
3301 if (error)
3302 goto out;
3303
3304 if (setextattr_msg->pvnr_resid != 0)
3305 error = EIO;
3306
3307 out:
3308 PUFFS_MSG_RELEASE(setextattr);
3309
3310 return error;
3311 }
3312
3313 int
3314 puffs_vnop_listextattr(void *v)
3315 {
3316 struct vop_listextattr_args /* {
3317 struct vnode *a_vp;
3318 int a_attrnamespace;
3319 struct uio *a_uio;
3320 size_t *a_size;
3321 int a_flag,
3322 kauth_cred_t a_cred;
3323 }; */ *ap = v;
3324 PUFFS_MSG_VARS(vn, listextattr);
3325 struct vnode *vp = ap->a_vp;
3326 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
3327 int attrnamespace = ap->a_attrnamespace;
3328 struct uio *uio = ap->a_uio;
3329 size_t *sizep = ap->a_size;
3330 int flag = ap->a_flag;
3331 size_t tomove, resid;
3332 int error;
3333
3334 if (uio)
3335 resid = uio->uio_resid;
3336 else
3337 resid = 0;
3338
3339 tomove = PUFFS_TOMOVE(resid, pmp);
3340 if (tomove != resid) {
3341 error = E2BIG;
3342 goto out;
3343 }
3344
3345 puffs_msgmem_alloc(sizeof(struct puffs_vnmsg_listextattr) + tomove,
3346 &park_listextattr, (void *)&listextattr_msg, 1);
3347
3348 listextattr_msg->pvnr_attrnamespace = attrnamespace;
3349 listextattr_msg->pvnr_flag = flag;
3350 puffs_credcvt(&listextattr_msg->pvnr_cred, ap->a_cred);
3351 listextattr_msg->pvnr_resid = tomove;
3352 if (sizep)
3353 listextattr_msg->pvnr_datasize = 1;
3354
3355 puffs_msg_setinfo(park_listextattr,
3356 PUFFSOP_VN, PUFFS_VN_LISTEXTATTR, VPTOPNC(vp));
3357 puffs_msg_setdelta(park_listextattr, tomove);
3358 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_listextattr, vp->v_data, NULL, error);
3359
3360 error = checkerr(pmp, error, __func__);
3361 if (error)
3362 goto out;
3363
3364 resid = listextattr_msg->pvnr_resid;
3365 if (resid > tomove) {
3366 puffs_senderr(pmp, PUFFS_ERR_LISTEXTATTR, E2BIG,
3367 "resid grew", VPTOPNC(vp));
3368 error = EPROTO;
3369 goto out;
3370 }
3371
3372 if (sizep)
3373 *sizep = listextattr_msg->pvnr_datasize;
3374 if (uio)
3375 error = uiomove(listextattr_msg->pvnr_data, tomove-resid, uio);
3376
3377 out:
3378 PUFFS_MSG_RELEASE(listextattr);
3379 return error;
3380 }
3381
3382 int
3383 puffs_vnop_deleteextattr(void *v)
3384 {
3385 struct vop_deleteextattr_args /* {
3386 struct vnode *a_vp;
3387 int a_attrnamespace;
3388 const char *a_name;
3389 kauth_cred_t a_cred;
3390 }; */ *ap = v;
3391 PUFFS_MSG_VARS(vn, deleteextattr);
3392 struct vnode *vp = ap->a_vp;
3393 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
3394 int attrnamespace = ap->a_attrnamespace;
3395 const char *name = ap->a_name;
3396 int error;
3397
3398 PUFFS_MSG_ALLOC(vn, deleteextattr);
3399 deleteextattr_msg->pvnr_attrnamespace = attrnamespace;
3400 strlcpy(deleteextattr_msg->pvnr_attrname, name,
3401 sizeof(deleteextattr_msg->pvnr_attrname));
3402 puffs_credcvt(&deleteextattr_msg->pvnr_cred, ap->a_cred);
3403
3404 puffs_msg_setinfo(park_deleteextattr,
3405 PUFFSOP_VN, PUFFS_VN_DELETEEXTATTR, VPTOPNC(vp));
3406 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_deleteextattr,
3407 vp->v_data, NULL, error);
3408
3409 error = checkerr(pmp, error, __func__);
3410
3411 PUFFS_MSG_RELEASE(deleteextattr);
3412 return error;
3413 }
3414
3415 /*
3416 * spec & fifo. These call the miscfs spec and fifo vectors, but issue
3417 * FAF update information for the puffs node first.
3418 */
3419 int
3420 puffs_vnop_spec_read(void *v)
3421 {
3422 struct vop_read_args /* {
3423 const struct vnodeop_desc *a_desc;
3424 struct vnode *a_vp;
3425 struct uio *a_uio;
3426 int a_ioflag;
3427 kauth_cred_t a_cred;
3428 } */ *ap = v;
3429
3430 puffs_updatenode(VPTOPP(ap->a_vp), PUFFS_UPDATEATIME, 0);
3431 return VOCALL(spec_vnodeop_p, VOFFSET(vop_read), v);
3432 }
3433
3434 int
3435 puffs_vnop_spec_write(void *v)
3436 {
3437 struct vop_write_args /* {
3438 const struct vnodeop_desc *a_desc;
3439 struct vnode *a_vp;
3440 struct uio *a_uio;
3441 int a_ioflag;
3442 kauth_cred_t a_cred;
3443 } */ *ap = v;
3444
3445 puffs_updatenode(VPTOPP(ap->a_vp), PUFFS_UPDATEMTIME, 0);
3446 return VOCALL(spec_vnodeop_p, VOFFSET(vop_write), v);
3447 }
3448
3449 int
3450 puffs_vnop_fifo_read(void *v)
3451 {
3452 struct vop_read_args /* {
3453 const struct vnodeop_desc *a_desc;
3454 struct vnode *a_vp;
3455 struct uio *a_uio;
3456 int a_ioflag;
3457 kauth_cred_t a_cred;
3458 } */ *ap = v;
3459
3460 puffs_updatenode(VPTOPP(ap->a_vp), PUFFS_UPDATEATIME, 0);
3461 return VOCALL(fifo_vnodeop_p, VOFFSET(vop_read), v);
3462 }
3463
3464 int
3465 puffs_vnop_fifo_write(void *v)
3466 {
3467 struct vop_write_args /* {
3468 const struct vnodeop_desc *a_desc;
3469 struct vnode *a_vp;
3470 struct uio *a_uio;
3471 int a_ioflag;
3472 kauth_cred_t a_cred;
3473 } */ *ap = v;
3474
3475 puffs_updatenode(VPTOPP(ap->a_vp), PUFFS_UPDATEMTIME, 0);
3476 return VOCALL(fifo_vnodeop_p, VOFFSET(vop_write), v);
3477 }
MINIX 3 (repo.or.cz mirror)