puffs_vnops.c revision 1.140
1 /* $NetBSD: puffs_vnops.c,v 1.140 2009/11/19 16:21:04 pooka 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.140 2009/11/19 16:21:04 pooka Exp $"); 34 35 #include <sys/param.h> 36 #include <sys/buf.h> 37 #include <sys/malloc.h> 38 #include <sys/mount.h> 39 #include <sys/namei.h> 40 #include <sys/vnode.h> 41 #include <sys/proc.h> 42 43 #include <uvm/uvm.h> 44 45 #include <fs/puffs/puffs_msgif.h> 46 #include <fs/puffs/puffs_sys.h> 47 48 #include <miscfs/fifofs/fifo.h> 49 #include <miscfs/genfs/genfs.h> 50 #include <miscfs/specfs/specdev.h> 51 52 int puffs_vnop_lookup(void *); 53 int puffs_vnop_create(void *); 54 int puffs_vnop_access(void *); 55 int puffs_vnop_mknod(void *); 56 int puffs_vnop_open(void *); 57 int puffs_vnop_close(void *); 58 int puffs_vnop_getattr(void *); 59 int puffs_vnop_setattr(void *); 60 int puffs_vnop_reclaim(void *); 61 int puffs_vnop_readdir(void *); 62 int puffs_vnop_poll(void *); 63 int puffs_vnop_fsync(void *); 64 int puffs_vnop_seek(void *); 65 int puffs_vnop_remove(void *); 66 int puffs_vnop_mkdir(void *); 67 int puffs_vnop_rmdir(void *); 68 int puffs_vnop_link(void *); 69 int puffs_vnop_readlink(void *); 70 int puffs_vnop_symlink(void *); 71 int puffs_vnop_rename(void *); 72 int puffs_vnop_read(void *); 73 int puffs_vnop_write(void *); 74 int puffs_vnop_fcntl(void *); 75 int puffs_vnop_ioctl(void *); 76 int puffs_vnop_inactive(void *); 77 int puffs_vnop_print(void *); 78 int puffs_vnop_pathconf(void *); 79 int puffs_vnop_advlock(void *); 80 int puffs_vnop_strategy(void *); 81 int puffs_vnop_bmap(void *); 82 int puffs_vnop_mmap(void *); 83 int puffs_vnop_getpages(void *); 84 int puffs_vnop_abortop(void *); 85 86 int puffs_vnop_spec_read(void *); 87 int puffs_vnop_spec_write(void *); 88 int puffs_vnop_fifo_read(void *); 89 int puffs_vnop_fifo_write(void *); 90 91 int puffs_vnop_checkop(void *); 92 93 #define puffs_vnop_lock genfs_lock 94 #define puffs_vnop_unlock genfs_unlock 95 #define puffs_vnop_islocked genfs_islocked 96 97 int (**puffs_vnodeop_p)(void *); 98 const struct vnodeopv_entry_desc puffs_vnodeop_entries[] = { 99 { &vop_default_desc, vn_default_error }, 100 { &vop_lookup_desc, puffs_vnop_lookup }, /* REAL lookup */ 101 { &vop_create_desc, puffs_vnop_checkop }, /* create */ 102 { &vop_mknod_desc, puffs_vnop_checkop }, /* mknod */ 103 { &vop_open_desc, puffs_vnop_open }, /* REAL open */ 104 { &vop_close_desc, puffs_vnop_checkop }, /* close */ 105 { &vop_access_desc, puffs_vnop_access }, /* REAL access */ 106 { &vop_getattr_desc, puffs_vnop_checkop }, /* getattr */ 107 { &vop_setattr_desc, puffs_vnop_checkop }, /* setattr */ 108 { &vop_read_desc, puffs_vnop_checkop }, /* read */ 109 { &vop_write_desc, puffs_vnop_checkop }, /* write */ 110 { &vop_fsync_desc, puffs_vnop_fsync }, /* REAL fsync */ 111 { &vop_seek_desc, puffs_vnop_checkop }, /* seek */ 112 { &vop_remove_desc, puffs_vnop_checkop }, /* remove */ 113 { &vop_link_desc, puffs_vnop_checkop }, /* link */ 114 { &vop_rename_desc, puffs_vnop_checkop }, /* rename */ 115 { &vop_mkdir_desc, puffs_vnop_checkop }, /* mkdir */ 116 { &vop_rmdir_desc, puffs_vnop_checkop }, /* rmdir */ 117 { &vop_symlink_desc, puffs_vnop_checkop }, /* symlink */ 118 { &vop_readdir_desc, puffs_vnop_checkop }, /* readdir */ 119 { &vop_readlink_desc, puffs_vnop_checkop }, /* readlink */ 120 { &vop_getpages_desc, puffs_vnop_checkop }, /* getpages */ 121 { &vop_putpages_desc, genfs_putpages }, /* REAL putpages */ 122 { &vop_pathconf_desc, puffs_vnop_checkop }, /* pathconf */ 123 { &vop_advlock_desc, puffs_vnop_checkop }, /* advlock */ 124 { &vop_strategy_desc, puffs_vnop_strategy }, /* REAL strategy */ 125 { &vop_revoke_desc, genfs_revoke }, /* REAL revoke */ 126 { &vop_abortop_desc, puffs_vnop_abortop }, /* REAL abortop */ 127 { &vop_inactive_desc, puffs_vnop_inactive }, /* REAL inactive */ 128 { &vop_reclaim_desc, puffs_vnop_reclaim }, /* REAL reclaim */ 129 { &vop_lock_desc, puffs_vnop_lock }, /* REAL lock */ 130 { &vop_unlock_desc, puffs_vnop_unlock }, /* REAL unlock */ 131 { &vop_bmap_desc, puffs_vnop_bmap }, /* REAL bmap */ 132 { &vop_print_desc, puffs_vnop_print }, /* REAL print */ 133 { &vop_islocked_desc, puffs_vnop_islocked }, /* REAL islocked */ 134 { &vop_bwrite_desc, genfs_nullop }, /* REAL bwrite */ 135 { &vop_mmap_desc, puffs_vnop_mmap }, /* REAL mmap */ 136 { &vop_poll_desc, puffs_vnop_poll }, /* REAL poll */ 137 138 { &vop_kqfilter_desc, genfs_eopnotsupp }, /* kqfilter XXX */ 139 { NULL, NULL } 140 }; 141 const struct vnodeopv_desc puffs_vnodeop_opv_desc = 142 { &puffs_vnodeop_p, puffs_vnodeop_entries }; 143 144 145 int (**puffs_specop_p)(void *); 146 const struct vnodeopv_entry_desc puffs_specop_entries[] = { 147 { &vop_default_desc, vn_default_error }, 148 { &vop_lookup_desc, spec_lookup }, /* lookup, ENOTDIR */ 149 { &vop_create_desc, spec_create }, /* genfs_badop */ 150 { &vop_mknod_desc, spec_mknod }, /* genfs_badop */ 151 { &vop_open_desc, spec_open }, /* spec_open */ 152 { &vop_close_desc, spec_close }, /* spec_close */ 153 { &vop_access_desc, puffs_vnop_checkop }, /* access */ 154 { &vop_getattr_desc, puffs_vnop_checkop }, /* getattr */ 155 { &vop_setattr_desc, puffs_vnop_checkop }, /* setattr */ 156 { &vop_read_desc, puffs_vnop_spec_read }, /* update, read */ 157 { &vop_write_desc, puffs_vnop_spec_write }, /* update, write */ 158 { &vop_ioctl_desc, spec_ioctl }, /* spec_ioctl */ 159 { &vop_fcntl_desc, genfs_fcntl }, /* dummy */ 160 { &vop_poll_desc, spec_poll }, /* spec_poll */ 161 { &vop_kqfilter_desc, spec_kqfilter }, /* spec_kqfilter */ 162 { &vop_revoke_desc, spec_revoke }, /* genfs_revoke */ 163 { &vop_mmap_desc, spec_mmap }, /* spec_mmap */ 164 { &vop_fsync_desc, spec_fsync }, /* vflushbuf */ 165 { &vop_seek_desc, spec_seek }, /* genfs_nullop */ 166 { &vop_remove_desc, spec_remove }, /* genfs_badop */ 167 { &vop_link_desc, spec_link }, /* genfs_badop */ 168 { &vop_rename_desc, spec_rename }, /* genfs_badop */ 169 { &vop_mkdir_desc, spec_mkdir }, /* genfs_badop */ 170 { &vop_rmdir_desc, spec_rmdir }, /* genfs_badop */ 171 { &vop_symlink_desc, spec_symlink }, /* genfs_badop */ 172 { &vop_readdir_desc, spec_readdir }, /* genfs_badop */ 173 { &vop_readlink_desc, spec_readlink }, /* genfs_badop */ 174 { &vop_abortop_desc, spec_abortop }, /* genfs_badop */ 175 { &vop_inactive_desc, puffs_vnop_inactive }, /* REAL inactive */ 176 { &vop_reclaim_desc, puffs_vnop_reclaim }, /* REAL reclaim */ 177 { &vop_lock_desc, puffs_vnop_lock }, /* REAL lock */ 178 { &vop_unlock_desc, puffs_vnop_unlock }, /* REAL unlock */ 179 { &vop_bmap_desc, spec_bmap }, /* dummy */ 180 { &vop_strategy_desc, spec_strategy }, /* dev strategy */ 181 { &vop_print_desc, puffs_vnop_print }, /* REAL print */ 182 { &vop_islocked_desc, puffs_vnop_islocked }, /* REAL islocked */ 183 { &vop_pathconf_desc, spec_pathconf }, /* pathconf */ 184 { &vop_advlock_desc, spec_advlock }, /* lf_advlock */ 185 { &vop_bwrite_desc, vn_bwrite }, /* bwrite */ 186 { &vop_getpages_desc, spec_getpages }, /* genfs_getpages */ 187 { &vop_putpages_desc, spec_putpages }, /* genfs_putpages */ 188 #if 0 189 { &vop_openextattr_desc, _openextattr }, /* openextattr */ 190 { &vop_closeextattr_desc, _closeextattr }, /* closeextattr */ 191 { &vop_getextattr_desc, _getextattr }, /* getextattr */ 192 { &vop_setextattr_desc, _setextattr }, /* setextattr */ 193 { &vop_listextattr_desc, _listextattr }, /* listextattr */ 194 { &vop_deleteextattr_desc, _deleteextattr }, /* deleteextattr */ 195 #endif 196 { NULL, NULL } 197 }; 198 const struct vnodeopv_desc puffs_specop_opv_desc = 199 { &puffs_specop_p, puffs_specop_entries }; 200 201 202 int (**puffs_fifoop_p)(void *); 203 const struct vnodeopv_entry_desc puffs_fifoop_entries[] = { 204 { &vop_default_desc, vn_default_error }, 205 { &vop_lookup_desc, fifo_lookup }, /* lookup, ENOTDIR */ 206 { &vop_create_desc, fifo_create }, /* genfs_badop */ 207 { &vop_mknod_desc, fifo_mknod }, /* genfs_badop */ 208 { &vop_open_desc, fifo_open }, /* open */ 209 { &vop_close_desc, fifo_close }, /* close */ 210 { &vop_access_desc, puffs_vnop_checkop }, /* access */ 211 { &vop_getattr_desc, puffs_vnop_checkop }, /* getattr */ 212 { &vop_setattr_desc, puffs_vnop_checkop }, /* setattr */ 213 { &vop_read_desc, puffs_vnop_fifo_read }, /* read, update */ 214 { &vop_write_desc, puffs_vnop_fifo_write }, /* write, update */ 215 { &vop_ioctl_desc, fifo_ioctl }, /* ioctl */ 216 { &vop_fcntl_desc, genfs_fcntl }, /* dummy */ 217 { &vop_poll_desc, fifo_poll }, /* poll */ 218 { &vop_kqfilter_desc, fifo_kqfilter }, /* kqfilter */ 219 { &vop_revoke_desc, fifo_revoke }, /* genfs_revoke */ 220 { &vop_mmap_desc, fifo_mmap }, /* genfs_badop */ 221 { &vop_fsync_desc, fifo_fsync }, /* genfs_nullop*/ 222 { &vop_seek_desc, fifo_seek }, /* genfs_badop */ 223 { &vop_remove_desc, fifo_remove }, /* genfs_badop */ 224 { &vop_link_desc, fifo_link }, /* genfs_badop */ 225 { &vop_rename_desc, fifo_rename }, /* genfs_badop */ 226 { &vop_mkdir_desc, fifo_mkdir }, /* genfs_badop */ 227 { &vop_rmdir_desc, fifo_rmdir }, /* genfs_badop */ 228 { &vop_symlink_desc, fifo_symlink }, /* genfs_badop */ 229 { &vop_readdir_desc, fifo_readdir }, /* genfs_badop */ 230 { &vop_readlink_desc, fifo_readlink }, /* genfs_badop */ 231 { &vop_abortop_desc, fifo_abortop }, /* genfs_badop */ 232 { &vop_inactive_desc, puffs_vnop_inactive }, /* REAL inactive */ 233 { &vop_reclaim_desc, puffs_vnop_reclaim }, /* REAL reclaim */ 234 { &vop_lock_desc, puffs_vnop_lock }, /* REAL lock */ 235 { &vop_unlock_desc, puffs_vnop_unlock }, /* REAL unlock */ 236 { &vop_bmap_desc, fifo_bmap }, /* dummy */ 237 { &vop_strategy_desc, fifo_strategy }, /* genfs_badop */ 238 { &vop_print_desc, puffs_vnop_print }, /* REAL print */ 239 { &vop_islocked_desc, puffs_vnop_islocked }, /* REAL islocked */ 240 { &vop_pathconf_desc, fifo_pathconf }, /* pathconf */ 241 { &vop_advlock_desc, fifo_advlock }, /* genfs_einval */ 242 { &vop_bwrite_desc, vn_bwrite }, /* bwrite */ 243 { &vop_putpages_desc, fifo_putpages }, /* genfs_null_putpages*/ 244 #if 0 245 { &vop_openextattr_desc, _openextattr }, /* openextattr */ 246 { &vop_closeextattr_desc, _closeextattr }, /* closeextattr */ 247 { &vop_getextattr_desc, _getextattr }, /* getextattr */ 248 { &vop_setextattr_desc, _setextattr }, /* setextattr */ 249 { &vop_listextattr_desc, _listextattr }, /* listextattr */ 250 { &vop_deleteextattr_desc, _deleteextattr }, /* deleteextattr */ 251 #endif 252 { NULL, NULL } 253 }; 254 const struct vnodeopv_desc puffs_fifoop_opv_desc = 255 { &puffs_fifoop_p, puffs_fifoop_entries }; 256 257 258 /* "real" vnode operations */ 259 int (**puffs_msgop_p)(void *); 260 const struct vnodeopv_entry_desc puffs_msgop_entries[] = { 261 { &vop_default_desc, vn_default_error }, 262 { &vop_create_desc, puffs_vnop_create }, /* create */ 263 { &vop_mknod_desc, puffs_vnop_mknod }, /* mknod */ 264 { &vop_open_desc, puffs_vnop_open }, /* open */ 265 { &vop_close_desc, puffs_vnop_close }, /* close */ 266 { &vop_access_desc, puffs_vnop_access }, /* access */ 267 { &vop_getattr_desc, puffs_vnop_getattr }, /* getattr */ 268 { &vop_setattr_desc, puffs_vnop_setattr }, /* setattr */ 269 { &vop_read_desc, puffs_vnop_read }, /* read */ 270 { &vop_write_desc, puffs_vnop_write }, /* write */ 271 { &vop_seek_desc, puffs_vnop_seek }, /* seek */ 272 { &vop_remove_desc, puffs_vnop_remove }, /* remove */ 273 { &vop_link_desc, puffs_vnop_link }, /* link */ 274 { &vop_rename_desc, puffs_vnop_rename }, /* rename */ 275 { &vop_mkdir_desc, puffs_vnop_mkdir }, /* mkdir */ 276 { &vop_rmdir_desc, puffs_vnop_rmdir }, /* rmdir */ 277 { &vop_symlink_desc, puffs_vnop_symlink }, /* symlink */ 278 { &vop_readdir_desc, puffs_vnop_readdir }, /* readdir */ 279 { &vop_readlink_desc, puffs_vnop_readlink }, /* readlink */ 280 { &vop_print_desc, puffs_vnop_print }, /* print */ 281 { &vop_islocked_desc, puffs_vnop_islocked }, /* islocked */ 282 { &vop_pathconf_desc, puffs_vnop_pathconf }, /* pathconf */ 283 { &vop_advlock_desc, puffs_vnop_advlock }, /* advlock */ 284 { &vop_getpages_desc, puffs_vnop_getpages }, /* getpages */ 285 { NULL, NULL } 286 }; 287 const struct vnodeopv_desc puffs_msgop_opv_desc = 288 { &puffs_msgop_p, puffs_msgop_entries }; 289 290 291 #define ERROUT(err) \ 292 do { \ 293 error = err; \ 294 goto out; \ 295 } while (/*CONSTCOND*/0) 296 297 /* 298 * This is a generic vnode operation handler. It checks if the necessary 299 * operations for the called vnode operation are implemented by userspace 300 * and either returns a dummy return value or proceeds to call the real 301 * vnode operation from puffs_msgop_v. 302 * 303 * XXX: this should described elsewhere and autogenerated, the complexity 304 * of the vnode operations vectors and their interrelationships is also 305 * getting a bit out of hand. Another problem is that we need this same 306 * information in the fs server code, so keeping the two in sync manually 307 * is not a viable (long term) plan. 308 */ 309 310 /* not supported, handle locking protocol */ 311 #define CHECKOP_NOTSUPP(op) \ 312 case VOP_##op##_DESCOFFSET: \ 313 if (pmp->pmp_vnopmask[PUFFS_VN_##op] == 0) \ 314 return genfs_eopnotsupp(v); \ 315 break 316 317 /* always succeed, no locking */ 318 #define CHECKOP_SUCCESS(op) \ 319 case VOP_##op##_DESCOFFSET: \ 320 if (pmp->pmp_vnopmask[PUFFS_VN_##op] == 0) \ 321 return 0; \ 322 break 323 324 int 325 puffs_vnop_checkop(void *v) 326 { 327 struct vop_generic_args /* { 328 struct vnodeop_desc *a_desc; 329 spooky mystery contents; 330 } */ *ap = v; 331 struct vnodeop_desc *desc = ap->a_desc; 332 struct puffs_mount *pmp; 333 struct vnode *vp; 334 int offset, rv; 335 336 offset = ap->a_desc->vdesc_vp_offsets[0]; 337 #ifdef DIAGNOSTIC 338 if (offset == VDESC_NO_OFFSET) 339 panic("puffs_checkop: no vnode, why did you call me?"); 340 #endif 341 vp = *VOPARG_OFFSETTO(struct vnode **, offset, ap); 342 pmp = MPTOPUFFSMP(vp->v_mount); 343 344 DPRINTF_VERBOSE(("checkop call %s (%d), vp %p\n", 345 ap->a_desc->vdesc_name, ap->a_desc->vdesc_offset, vp)); 346 347 if (!ALLOPS(pmp)) { 348 switch (desc->vdesc_offset) { 349 CHECKOP_NOTSUPP(CREATE); 350 CHECKOP_NOTSUPP(MKNOD); 351 CHECKOP_NOTSUPP(GETATTR); 352 CHECKOP_NOTSUPP(SETATTR); 353 CHECKOP_NOTSUPP(READ); 354 CHECKOP_NOTSUPP(WRITE); 355 CHECKOP_NOTSUPP(FCNTL); 356 CHECKOP_NOTSUPP(IOCTL); 357 CHECKOP_NOTSUPP(REMOVE); 358 CHECKOP_NOTSUPP(LINK); 359 CHECKOP_NOTSUPP(RENAME); 360 CHECKOP_NOTSUPP(MKDIR); 361 CHECKOP_NOTSUPP(RMDIR); 362 CHECKOP_NOTSUPP(SYMLINK); 363 CHECKOP_NOTSUPP(READDIR); 364 CHECKOP_NOTSUPP(READLINK); 365 CHECKOP_NOTSUPP(PRINT); 366 CHECKOP_NOTSUPP(PATHCONF); 367 CHECKOP_NOTSUPP(ADVLOCK); 368 369 CHECKOP_SUCCESS(ACCESS); 370 CHECKOP_SUCCESS(CLOSE); 371 CHECKOP_SUCCESS(SEEK); 372 373 case VOP_GETPAGES_DESCOFFSET: 374 if (!EXISTSOP(pmp, READ)) 375 return genfs_eopnotsupp(v); 376 break; 377 378 default: 379 panic("puffs_checkop: unhandled vnop %d", 380 desc->vdesc_offset); 381 } 382 } 383 384 rv = VOCALL(puffs_msgop_p, ap->a_desc->vdesc_offset, v); 385 386 DPRINTF_VERBOSE(("checkop return %s (%d), vp %p: %d\n", 387 ap->a_desc->vdesc_name, ap->a_desc->vdesc_offset, vp, rv)); 388 389 return rv; 390 } 391 392 static int callremove(struct puffs_mount *, puffs_cookie_t, puffs_cookie_t, 393 struct componentname *); 394 static int callrmdir(struct puffs_mount *, puffs_cookie_t, puffs_cookie_t, 395 struct componentname *); 396 static void callinactive(struct puffs_mount *, puffs_cookie_t, int); 397 static void callreclaim(struct puffs_mount *, puffs_cookie_t); 398 399 #define PUFFS_ABORT_LOOKUP 1 400 #define PUFFS_ABORT_CREATE 2 401 #define PUFFS_ABORT_MKNOD 3 402 #define PUFFS_ABORT_MKDIR 4 403 #define PUFFS_ABORT_SYMLINK 5 404 405 /* 406 * Press the pani^Wabort button! Kernel resource allocation failed. 407 */ 408 static void 409 puffs_abortbutton(struct puffs_mount *pmp, int what, 410 puffs_cookie_t dck, puffs_cookie_t ck, struct componentname *cnp) 411 { 412 413 switch (what) { 414 case PUFFS_ABORT_CREATE: 415 case PUFFS_ABORT_MKNOD: 416 case PUFFS_ABORT_SYMLINK: 417 callremove(pmp, dck, ck, cnp); 418 break; 419 case PUFFS_ABORT_MKDIR: 420 callrmdir(pmp, dck, ck, cnp); 421 break; 422 } 423 424 callinactive(pmp, ck, 0); 425 callreclaim(pmp, ck); 426 } 427 428 /* 429 * Begin vnode operations. 430 * 431 * A word from the keymaster about locks: generally we don't want 432 * to use the vnode locks at all: it creates an ugly dependency between 433 * the userlandia file server and the kernel. But we'll play along with 434 * the kernel vnode locks for now. However, even currently we attempt 435 * to release locks as early as possible. This is possible for some 436 * operations which a) don't need a locked vnode after the userspace op 437 * and b) return with the vnode unlocked. Theoretically we could 438 * unlock-do op-lock for others and order the graph in userspace, but I 439 * don't want to think of the consequences for the time being. 440 */ 441 442 int 443 puffs_vnop_lookup(void *v) 444 { 445 struct vop_lookup_args /* { 446 const struct vnodeop_desc *a_desc; 447 struct vnode *a_dvp; 448 struct vnode **a_vpp; 449 struct componentname *a_cnp; 450 } */ *ap = v; 451 PUFFS_MSG_VARS(vn, lookup); 452 struct puffs_mount *pmp; 453 struct componentname *cnp; 454 struct vnode *vp, *dvp; 455 struct puffs_node *dpn; 456 int isdot; 457 int error; 458 459 pmp = MPTOPUFFSMP(ap->a_dvp->v_mount); 460 cnp = ap->a_cnp; 461 dvp = ap->a_dvp; 462 *ap->a_vpp = NULL; 463 464 /* r/o fs? we check create later to handle EEXIST */ 465 if ((cnp->cn_flags & ISLASTCN) 466 && (dvp->v_mount->mnt_flag & MNT_RDONLY) 467 && (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) 468 return EROFS; 469 470 isdot = cnp->cn_namelen == 1 && *cnp->cn_nameptr == '.'; 471 472 DPRINTF(("puffs_lookup: \"%s\", parent vnode %p, op: %x\n", 473 cnp->cn_nameptr, dvp, cnp->cn_nameiop)); 474 475 /* 476 * Check if someone fed it into the cache 477 */ 478 if (PUFFS_USE_NAMECACHE(pmp)) { 479 error = cache_lookup(dvp, ap->a_vpp, cnp); 480 481 if (error >= 0) 482 return error; 483 } 484 485 if (isdot) { 486 vp = ap->a_dvp; 487 vref(vp); 488 *ap->a_vpp = vp; 489 return 0; 490 } 491 492 PUFFS_MSG_ALLOC(vn, lookup); 493 puffs_makecn(&lookup_msg->pvnr_cn, &lookup_msg->pvnr_cn_cred, 494 cnp, PUFFS_USE_FULLPNBUF(pmp)); 495 496 if (cnp->cn_flags & ISDOTDOT) 497 VOP_UNLOCK(dvp, 0); 498 499 puffs_msg_setinfo(park_lookup, PUFFSOP_VN, 500 PUFFS_VN_LOOKUP, VPTOPNC(dvp)); 501 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_lookup, dvp->v_data, NULL, error); 502 DPRINTF(("puffs_lookup: return of the userspace, part %d\n", error)); 503 504 /* 505 * In case of error, there is no new vnode to play with, so be 506 * happy with the NULL value given to vpp in the beginning. 507 * Also, check if this really was an error or the target was not 508 * present. Either treat it as a non-error for CREATE/RENAME or 509 * enter the component into the negative name cache (if desired). 510 */ 511 if (error) { 512 error = checkerr(pmp, error, __func__); 513 if (error == ENOENT) { 514 /* don't allow to create files on r/o fs */ 515 if ((dvp->v_mount->mnt_flag & MNT_RDONLY) 516 && cnp->cn_nameiop == CREATE) { 517 error = EROFS; 518 519 /* adjust values if we are creating */ 520 } else if ((cnp->cn_flags & ISLASTCN) 521 && (cnp->cn_nameiop == CREATE 522 || cnp->cn_nameiop == RENAME)) { 523 cnp->cn_flags |= SAVENAME; 524 error = EJUSTRETURN; 525 526 /* save negative cache entry */ 527 } else { 528 if ((cnp->cn_flags & MAKEENTRY) 529 && PUFFS_USE_NAMECACHE(pmp)) 530 cache_enter(dvp, NULL, cnp); 531 } 532 } 533 goto out; 534 } 535 536 /* 537 * Check that we don't get our parent node back, that would cause 538 * a pretty obvious deadlock. 539 */ 540 dpn = dvp->v_data; 541 if (lookup_msg->pvnr_newnode == dpn->pn_cookie) { 542 puffs_senderr(pmp, PUFFS_ERR_LOOKUP, EINVAL, 543 "lookup produced parent cookie", lookup_msg->pvnr_newnode); 544 error = EPROTO; 545 goto out; 546 } 547 548 error = puffs_cookie2vnode(pmp, lookup_msg->pvnr_newnode, 1, 1, &vp); 549 if (error == PUFFS_NOSUCHCOOKIE) { 550 error = puffs_getvnode(dvp->v_mount, 551 lookup_msg->pvnr_newnode, lookup_msg->pvnr_vtype, 552 lookup_msg->pvnr_size, lookup_msg->pvnr_rdev, &vp); 553 if (error) { 554 puffs_abortbutton(pmp, PUFFS_ABORT_LOOKUP, VPTOPNC(dvp), 555 lookup_msg->pvnr_newnode, ap->a_cnp); 556 goto out; 557 } 558 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 559 } else if (error) { 560 puffs_abortbutton(pmp, PUFFS_ABORT_LOOKUP, VPTOPNC(dvp), 561 lookup_msg->pvnr_newnode, ap->a_cnp); 562 goto out; 563 } 564 565 *ap->a_vpp = vp; 566 567 if ((cnp->cn_flags & MAKEENTRY) != 0 && PUFFS_USE_NAMECACHE(pmp)) 568 cache_enter(dvp, vp, cnp); 569 570 /* XXX */ 571 if ((lookup_msg->pvnr_cn.pkcn_flags & REQUIREDIR) == 0) 572 cnp->cn_flags &= ~REQUIREDIR; 573 if (lookup_msg->pvnr_cn.pkcn_consume) 574 cnp->cn_consume = MIN(lookup_msg->pvnr_cn.pkcn_consume, 575 strlen(cnp->cn_nameptr) - cnp->cn_namelen); 576 577 /* 578 * We need the name in remove and rmdir (well, rename too, but 579 * SAVESTART takes care of that) 580 */ 581 if (cnp->cn_nameiop == DELETE) 582 cnp->cn_flags |= SAVENAME; 583 584 out: 585 if (cnp->cn_flags & ISDOTDOT) 586 vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY); 587 588 DPRINTF(("puffs_lookup: returning %d %p\n", error, *ap->a_vpp)); 589 PUFFS_MSG_RELEASE(lookup); 590 return error; 591 } 592 593 #define REFPN_AND_UNLOCKVP(a, b) \ 594 do { \ 595 mutex_enter(&b->pn_mtx); \ 596 puffs_referencenode(b); \ 597 mutex_exit(&b->pn_mtx); \ 598 VOP_UNLOCK(a, 0); \ 599 } while (/*CONSTCOND*/0) 600 601 #define REFPN(b) \ 602 do { \ 603 mutex_enter(&b->pn_mtx); \ 604 puffs_referencenode(b); \ 605 mutex_exit(&b->pn_mtx); \ 606 } while (/*CONSTCOND*/0) 607 608 #define RELEPN_AND_VP(a, b) \ 609 do { \ 610 puffs_releasenode(b); \ 611 vrele(a); \ 612 } while (/*CONSTCOND*/0) 613 614 int 615 puffs_vnop_create(void *v) 616 { 617 struct vop_create_args /* { 618 const struct vnodeop_desc *a_desc; 619 struct vnode *a_dvp; 620 struct vnode **a_vpp; 621 struct componentname *a_cnp; 622 struct vattr *a_vap; 623 } */ *ap = v; 624 PUFFS_MSG_VARS(vn, create); 625 struct vnode *dvp = ap->a_dvp; 626 struct puffs_node *dpn = VPTOPP(dvp); 627 struct componentname *cnp = ap->a_cnp; 628 struct mount *mp = dvp->v_mount; 629 struct puffs_mount *pmp = MPTOPUFFSMP(mp); 630 int error; 631 632 DPRINTF(("puffs_create: dvp %p, cnp: %s\n", 633 dvp, ap->a_cnp->cn_nameptr)); 634 635 PUFFS_MSG_ALLOC(vn, create); 636 puffs_makecn(&create_msg->pvnr_cn, &create_msg->pvnr_cn_cred, 637 cnp, PUFFS_USE_FULLPNBUF(pmp)); 638 create_msg->pvnr_va = *ap->a_vap; 639 puffs_msg_setinfo(park_create, PUFFSOP_VN, 640 PUFFS_VN_CREATE, VPTOPNC(dvp)); 641 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_create, dvp->v_data, NULL, error); 642 643 error = checkerr(pmp, error, __func__); 644 if (error) 645 goto out; 646 647 error = puffs_newnode(mp, dvp, ap->a_vpp, 648 create_msg->pvnr_newnode, cnp, ap->a_vap->va_type, 0); 649 if (error) 650 puffs_abortbutton(pmp, PUFFS_ABORT_CREATE, dpn->pn_cookie, 651 create_msg->pvnr_newnode, cnp); 652 653 out: 654 vput(dvp); 655 if (error || (cnp->cn_flags & SAVESTART) == 0) 656 PNBUF_PUT(cnp->cn_pnbuf); 657 658 DPRINTF(("puffs_create: return %d\n", error)); 659 PUFFS_MSG_RELEASE(create); 660 return error; 661 } 662 663 int 664 puffs_vnop_mknod(void *v) 665 { 666 struct vop_mknod_args /* { 667 const struct vnodeop_desc *a_desc; 668 struct vnode *a_dvp; 669 struct vnode **a_vpp; 670 struct componentname *a_cnp; 671 struct vattr *a_vap; 672 } */ *ap = v; 673 PUFFS_MSG_VARS(vn, mknod); 674 struct vnode *dvp = ap->a_dvp; 675 struct puffs_node *dpn = VPTOPP(dvp); 676 struct componentname *cnp = ap->a_cnp; 677 struct mount *mp = dvp->v_mount; 678 struct puffs_mount *pmp = MPTOPUFFSMP(mp); 679 int error; 680 681 PUFFS_MSG_ALLOC(vn, mknod); 682 puffs_makecn(&mknod_msg->pvnr_cn, &mknod_msg->pvnr_cn_cred, 683 cnp, PUFFS_USE_FULLPNBUF(pmp)); 684 mknod_msg->pvnr_va = *ap->a_vap; 685 puffs_msg_setinfo(park_mknod, PUFFSOP_VN, 686 PUFFS_VN_MKNOD, VPTOPNC(dvp)); 687 688 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_mknod, dvp->v_data, NULL, error); 689 690 error = checkerr(pmp, error, __func__); 691 if (error) 692 goto out; 693 694 error = puffs_newnode(mp, dvp, ap->a_vpp, 695 mknod_msg->pvnr_newnode, cnp, ap->a_vap->va_type, 696 ap->a_vap->va_rdev); 697 if (error) 698 puffs_abortbutton(pmp, PUFFS_ABORT_MKNOD, dpn->pn_cookie, 699 mknod_msg->pvnr_newnode, cnp); 700 701 out: 702 vput(dvp); 703 PUFFS_MSG_RELEASE(mknod); 704 if (error || (cnp->cn_flags & SAVESTART) == 0) 705 PNBUF_PUT(cnp->cn_pnbuf); 706 return error; 707 } 708 709 int 710 puffs_vnop_open(void *v) 711 { 712 struct vop_open_args /* { 713 const struct vnodeop_desc *a_desc; 714 struct vnode *a_vp; 715 int a_mode; 716 kauth_cred_t a_cred; 717 } */ *ap = v; 718 PUFFS_MSG_VARS(vn, open); 719 struct vnode *vp = ap->a_vp; 720 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount); 721 int mode = ap->a_mode; 722 int error; 723 724 DPRINTF(("puffs_open: vp %p, mode 0x%x\n", vp, mode)); 725 726 if (vp->v_type == VREG && mode & FWRITE && !EXISTSOP(pmp, WRITE)) 727 ERROUT(EROFS); 728 729 if (!EXISTSOP(pmp, OPEN)) 730 ERROUT(0); 731 732 PUFFS_MSG_ALLOC(vn, open); 733 open_msg->pvnr_mode = mode; 734 puffs_credcvt(&open_msg->pvnr_cred, ap->a_cred); 735 puffs_msg_setinfo(park_open, PUFFSOP_VN, 736 PUFFS_VN_OPEN, VPTOPNC(vp)); 737 738 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_open, vp->v_data, NULL, error); 739 error = checkerr(pmp, error, __func__); 740 741 out: 742 DPRINTF(("puffs_open: returning %d\n", error)); 743 PUFFS_MSG_RELEASE(open); 744 return error; 745 } 746 747 int 748 puffs_vnop_close(void *v) 749 { 750 struct vop_close_args /* { 751 const struct vnodeop_desc *a_desc; 752 struct vnode *a_vp; 753 int a_fflag; 754 kauth_cred_t a_cred; 755 } */ *ap = v; 756 PUFFS_MSG_VARS(vn, close); 757 struct vnode *vp = ap->a_vp; 758 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount); 759 760 PUFFS_MSG_ALLOC(vn, close); 761 puffs_msg_setfaf(park_close); 762 close_msg->pvnr_fflag = ap->a_fflag; 763 puffs_credcvt(&close_msg->pvnr_cred, ap->a_cred); 764 puffs_msg_setinfo(park_close, PUFFSOP_VN, 765 PUFFS_VN_CLOSE, VPTOPNC(vp)); 766 767 puffs_msg_enqueue(pmp, park_close); 768 PUFFS_MSG_RELEASE(close); 769 return 0; 770 } 771 772 int 773 puffs_vnop_access(void *v) 774 { 775 struct vop_access_args /* { 776 const struct vnodeop_desc *a_desc; 777 struct vnode *a_vp; 778 int a_mode; 779 kauth_cred_t a_cred; 780 } */ *ap = v; 781 PUFFS_MSG_VARS(vn, access); 782 struct vnode *vp = ap->a_vp; 783 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount); 784 int mode = ap->a_mode; 785 int error; 786 787 if (mode & VWRITE) { 788 switch (vp->v_type) { 789 case VDIR: 790 case VLNK: 791 case VREG: 792 if ((vp->v_mount->mnt_flag & MNT_RDONLY) 793 || !EXISTSOP(pmp, WRITE)) 794 return EROFS; 795 break; 796 default: 797 break; 798 } 799 } 800 801 if (!EXISTSOP(pmp, ACCESS)) 802 return 0; 803 804 PUFFS_MSG_ALLOC(vn, access); 805 access_msg->pvnr_mode = ap->a_mode; 806 puffs_credcvt(&access_msg->pvnr_cred, ap->a_cred); 807 puffs_msg_setinfo(park_access, PUFFSOP_VN, 808 PUFFS_VN_ACCESS, VPTOPNC(vp)); 809 810 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_access, vp->v_data, NULL, error); 811 error = checkerr(pmp, error, __func__); 812 PUFFS_MSG_RELEASE(access); 813 814 return error; 815 } 816 817 int 818 puffs_vnop_getattr(void *v) 819 { 820 struct vop_getattr_args /* { 821 const struct vnodeop_desc *a_desc; 822 struct vnode *a_vp; 823 struct vattr *a_vap; 824 kauth_cred_t a_cred; 825 } */ *ap = v; 826 PUFFS_MSG_VARS(vn, getattr); 827 struct vnode *vp = ap->a_vp; 828 struct mount *mp = vp->v_mount; 829 struct puffs_mount *pmp = MPTOPUFFSMP(mp); 830 struct vattr *vap, *rvap; 831 struct puffs_node *pn; 832 int error = 0; 833 834 vap = ap->a_vap; 835 836 PUFFS_MSG_ALLOC(vn, getattr); 837 vattr_null(&getattr_msg->pvnr_va); 838 puffs_credcvt(&getattr_msg->pvnr_cred, ap->a_cred); 839 puffs_msg_setinfo(park_getattr, PUFFSOP_VN, 840 PUFFS_VN_GETATTR, VPTOPNC(vp)); 841 842 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_getattr, vp->v_data, NULL, error); 843 error = checkerr(pmp, error, __func__); 844 if (error) 845 goto out; 846 847 rvap = &getattr_msg->pvnr_va; 848 /* 849 * Don't listen to the file server regarding special device 850 * size info, the file server doesn't know anything about them. 851 */ 852 if (vp->v_type == VBLK || vp->v_type == VCHR) 853 rvap->va_size = vp->v_size; 854 855 /* Ditto for blocksize (ufs comment: this doesn't belong here) */ 856 if (vp->v_type == VBLK) 857 rvap->va_blocksize = BLKDEV_IOSIZE; 858 else if (vp->v_type == VCHR) 859 rvap->va_blocksize = MAXBSIZE; 860 861 (void) memcpy(vap, rvap, sizeof(struct vattr)); 862 vap->va_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0]; 863 864 pn = VPTOPP(vp); 865 if (pn->pn_stat & PNODE_METACACHE_ATIME) 866 vap->va_atime = pn->pn_mc_atime; 867 if (pn->pn_stat & PNODE_METACACHE_CTIME) 868 vap->va_ctime = pn->pn_mc_ctime; 869 if (pn->pn_stat & PNODE_METACACHE_MTIME) 870 vap->va_mtime = pn->pn_mc_mtime; 871 if (pn->pn_stat & PNODE_METACACHE_SIZE) { 872 vap->va_size = pn->pn_mc_size; 873 } else { 874 if (rvap->va_size != VNOVAL 875 && vp->v_type != VBLK && vp->v_type != VCHR) { 876 uvm_vnp_setsize(vp, rvap->va_size); 877 pn->pn_serversize = rvap->va_size; 878 } 879 } 880 881 out: 882 PUFFS_MSG_RELEASE(getattr); 883 return error; 884 } 885 886 static int 887 dosetattr(struct vnode *vp, struct vattr *vap, kauth_cred_t cred, int chsize) 888 { 889 PUFFS_MSG_VARS(vn, setattr); 890 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount); 891 struct puffs_node *pn = vp->v_data; 892 int error; 893 894 if ((vp->v_mount->mnt_flag & MNT_RDONLY) && 895 (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL 896 || vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL 897 || vap->va_mode != (mode_t)VNOVAL)) 898 return EROFS; 899 900 if ((vp->v_mount->mnt_flag & MNT_RDONLY) 901 && vp->v_type == VREG && vap->va_size != VNOVAL) 902 return EROFS; 903 904 /* 905 * Flush metacache first. If we are called with some explicit 906 * parameters, treat them as information overriding metacache 907 * information. 908 */ 909 if (pn->pn_stat & PNODE_METACACHE_MASK) { 910 if ((pn->pn_stat & PNODE_METACACHE_ATIME) 911 && vap->va_atime.tv_sec == VNOVAL) 912 vap->va_atime = pn->pn_mc_atime; 913 if ((pn->pn_stat & PNODE_METACACHE_CTIME) 914 && vap->va_ctime.tv_sec == VNOVAL) 915 vap->va_ctime = pn->pn_mc_ctime; 916 if ((pn->pn_stat & PNODE_METACACHE_MTIME) 917 && vap->va_mtime.tv_sec == VNOVAL) 918 vap->va_mtime = pn->pn_mc_mtime; 919 if ((pn->pn_stat & PNODE_METACACHE_SIZE) 920 && vap->va_size == VNOVAL) 921 vap->va_size = pn->pn_mc_size; 922 923 pn->pn_stat &= ~PNODE_METACACHE_MASK; 924 } 925 926 PUFFS_MSG_ALLOC(vn, setattr); 927 (void)memcpy(&setattr_msg->pvnr_va, vap, sizeof(struct vattr)); 928 puffs_credcvt(&setattr_msg->pvnr_cred, cred); 929 puffs_msg_setinfo(park_setattr, PUFFSOP_VN, 930 PUFFS_VN_SETATTR, VPTOPNC(vp)); 931 932 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_setattr, vp->v_data, NULL, error); 933 PUFFS_MSG_RELEASE(setattr); 934 error = checkerr(pmp, error, __func__); 935 if (error) 936 return error; 937 938 if (vap->va_size != VNOVAL) { 939 pn->pn_serversize = vap->va_size; 940 if (chsize) 941 uvm_vnp_setsize(vp, vap->va_size); 942 } 943 944 return 0; 945 } 946 947 int 948 puffs_vnop_setattr(void *v) 949 { 950 struct vop_getattr_args /* { 951 const struct vnodeop_desc *a_desc; 952 struct vnode *a_vp; 953 struct vattr *a_vap; 954 kauth_cred_t a_cred; 955 } */ *ap = v; 956 957 return dosetattr(ap->a_vp, ap->a_vap, ap->a_cred, 1); 958 } 959 960 static __inline int 961 doinact(struct puffs_mount *pmp, int iaflag) 962 { 963 964 if (EXISTSOP(pmp, INACTIVE)) 965 if (pmp->pmp_flags & PUFFS_KFLAG_IAONDEMAND) 966 if (iaflag || ALLOPS(pmp)) 967 return 1; 968 else 969 return 0; 970 else 971 return 1; 972 else 973 return 0; 974 } 975 976 static void 977 callinactive(struct puffs_mount *pmp, puffs_cookie_t ck, int iaflag) 978 { 979 int error; 980 PUFFS_MSG_VARS(vn, inactive); 981 982 if (doinact(pmp, iaflag)) { 983 PUFFS_MSG_ALLOC(vn, inactive); 984 puffs_msg_setinfo(park_inactive, PUFFSOP_VN, 985 PUFFS_VN_INACTIVE, ck); 986 987 PUFFS_MSG_ENQUEUEWAIT(pmp, park_inactive, error); 988 PUFFS_MSG_RELEASE(inactive); 989 } 990 } 991 992 /* XXX: callinactive can't setback */ 993 int 994 puffs_vnop_inactive(void *v) 995 { 996 struct vop_inactive_args /* { 997 const struct vnodeop_desc *a_desc; 998 struct vnode *a_vp; 999 } */ *ap = v; 1000 PUFFS_MSG_VARS(vn, inactive); 1001 struct vnode *vp = ap->a_vp; 1002 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount); 1003 struct puffs_node *pnode; 1004 int error; 1005 1006 pnode = vp->v_data; 1007 1008 if (doinact(pmp, pnode->pn_stat & PNODE_DOINACT)) { 1009 PUFFS_MSG_ALLOC(vn, inactive); 1010 puffs_msg_setinfo(park_inactive, PUFFSOP_VN, 1011 PUFFS_VN_INACTIVE, VPTOPNC(vp)); 1012 1013 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_inactive, vp->v_data, 1014 NULL, error); 1015 PUFFS_MSG_RELEASE(inactive); 1016 } 1017 pnode->pn_stat &= ~PNODE_DOINACT; 1018 1019 /* 1020 * file server thinks it's gone? then don't be afraid care, 1021 * node's life was already all it would ever be 1022 */ 1023 if (pnode->pn_stat & PNODE_NOREFS) { 1024 pnode->pn_stat |= PNODE_DYING; 1025 *ap->a_recycle = true; 1026 } 1027 1028 VOP_UNLOCK(vp, 0); 1029 1030 return 0; 1031 } 1032 1033 static void 1034 callreclaim(struct puffs_mount *pmp, puffs_cookie_t ck) 1035 { 1036 PUFFS_MSG_VARS(vn, reclaim); 1037 1038 if (!EXISTSOP(pmp, RECLAIM)) 1039 return; 1040 1041 PUFFS_MSG_ALLOC(vn, reclaim); 1042 puffs_msg_setfaf(park_reclaim); 1043 puffs_msg_setinfo(park_reclaim, PUFFSOP_VN, PUFFS_VN_RECLAIM, ck); 1044 1045 puffs_msg_enqueue(pmp, park_reclaim); 1046 PUFFS_MSG_RELEASE(reclaim); 1047 } 1048 1049 /* 1050 * always FAF, we don't really care if the server wants to fail to 1051 * reclaim the node or not 1052 */ 1053 int 1054 puffs_vnop_reclaim(void *v) 1055 { 1056 struct vop_reclaim_args /* { 1057 const struct vnodeop_desc *a_desc; 1058 struct vnode *a_vp; 1059 } */ *ap = v; 1060 struct vnode *vp = ap->a_vp; 1061 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount); 1062 struct puffs_node *pnode = vp->v_data; 1063 bool notifyserver = true; 1064 1065 /* 1066 * first things first: check if someone is trying to reclaim the 1067 * root vnode. do not allow that to travel to userspace. 1068 * Note that we don't need to take the lock similarly to 1069 * puffs_root(), since there is only one of us. 1070 */ 1071 if (vp->v_vflag & VV_ROOT) { 1072 mutex_enter(&pmp->pmp_lock); 1073 KASSERT(pmp->pmp_root != NULL); 1074 pmp->pmp_root = NULL; 1075 mutex_exit(&pmp->pmp_lock); 1076 notifyserver = false; 1077 } 1078 1079 /* 1080 * purge info from kernel before issueing FAF, since we 1081 * don't really know when we'll get around to it after 1082 * that and someone might race us into node creation 1083 */ 1084 mutex_enter(&pmp->pmp_lock); 1085 LIST_REMOVE(pnode, pn_hashent); 1086 mutex_exit(&pmp->pmp_lock); 1087 if (PUFFS_USE_NAMECACHE(pmp)) 1088 cache_purge(vp); 1089 1090 if (notifyserver) 1091 callreclaim(MPTOPUFFSMP(vp->v_mount), VPTOPNC(vp)); 1092 1093 puffs_putvnode(vp); 1094 1095 return 0; 1096 } 1097 1098 #define CSIZE sizeof(**ap->a_cookies) 1099 int 1100 puffs_vnop_readdir(void *v) 1101 { 1102 struct vop_readdir_args /* { 1103 const struct vnodeop_desc *a_desc; 1104 struct vnode *a_vp; 1105 struct uio *a_uio; 1106 kauth_cred_t a_cred; 1107 int *a_eofflag; 1108 off_t **a_cookies; 1109 int *a_ncookies; 1110 } */ *ap = v; 1111 PUFFS_MSG_VARS(vn, readdir); 1112 struct vnode *vp = ap->a_vp; 1113 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount); 1114 size_t argsize, tomove, cookiemem, cookiesmax; 1115 struct uio *uio = ap->a_uio; 1116 size_t howmuch, resid; 1117 int error; 1118 1119 /* 1120 * ok, so we need: resid + cookiemem = maxreq 1121 * => resid + cookiesize * (resid/minsize) = maxreq 1122 * => resid + cookiesize/minsize * resid = maxreq 1123 * => (cookiesize/minsize + 1) * resid = maxreq 1124 * => resid = maxreq / (cookiesize/minsize + 1) 1125 * 1126 * Since cookiesize <= minsize and we're not very big on floats, 1127 * we approximate that to be 1. Therefore: 1128 * 1129 * resid = maxreq / 2; 1130 * 1131 * Well, at least we didn't have to use differential equations 1132 * or the Gram-Schmidt process. 1133 * 1134 * (yes, I'm very afraid of this) 1135 */ 1136 KASSERT(CSIZE <= _DIRENT_MINSIZE((struct dirent *)0)); 1137 1138 if (ap->a_cookies) { 1139 KASSERT(ap->a_ncookies != NULL); 1140 if (pmp->pmp_args.pa_fhsize == 0) 1141 return EOPNOTSUPP; 1142 resid = PUFFS_TOMOVE(uio->uio_resid, pmp) / 2; 1143 cookiesmax = resid/_DIRENT_MINSIZE((struct dirent *)0); 1144 cookiemem = ALIGN(cookiesmax*CSIZE); /* play safe */ 1145 } else { 1146 resid = PUFFS_TOMOVE(uio->uio_resid, pmp); 1147 cookiesmax = 0; 1148 cookiemem = 0; 1149 } 1150 1151 argsize = sizeof(struct puffs_vnmsg_readdir); 1152 tomove = resid + cookiemem; 1153 puffs_msgmem_alloc(argsize + tomove, &park_readdir, 1154 (void *)&readdir_msg, 1); 1155 1156 puffs_credcvt(&readdir_msg->pvnr_cred, ap->a_cred); 1157 readdir_msg->pvnr_offset = uio->uio_offset; 1158 readdir_msg->pvnr_resid = resid; 1159 readdir_msg->pvnr_ncookies = cookiesmax; 1160 readdir_msg->pvnr_eofflag = 0; 1161 readdir_msg->pvnr_dentoff = cookiemem; 1162 puffs_msg_setinfo(park_readdir, PUFFSOP_VN, 1163 PUFFS_VN_READDIR, VPTOPNC(vp)); 1164 puffs_msg_setdelta(park_readdir, tomove); 1165 1166 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_readdir, vp->v_data, NULL, error); 1167 error = checkerr(pmp, error, __func__); 1168 if (error) 1169 goto out; 1170 1171 /* userspace is cheating? */ 1172 if (readdir_msg->pvnr_resid > resid) { 1173 puffs_senderr(pmp, PUFFS_ERR_READDIR, E2BIG, 1174 "resid grew", VPTOPNC(vp)); 1175 ERROUT(EPROTO); 1176 } 1177 if (readdir_msg->pvnr_ncookies > cookiesmax) { 1178 puffs_senderr(pmp, PUFFS_ERR_READDIR, E2BIG, 1179 "too many cookies", VPTOPNC(vp)); 1180 ERROUT(EPROTO); 1181 } 1182 1183 /* check eof */ 1184 if (readdir_msg->pvnr_eofflag) 1185 *ap->a_eofflag = 1; 1186 1187 /* bouncy-wouncy with the directory data */ 1188 howmuch = resid - readdir_msg->pvnr_resid; 1189 1190 /* force eof if no data was returned (getcwd() needs this) */ 1191 if (howmuch == 0) { 1192 *ap->a_eofflag = 1; 1193 goto out; 1194 } 1195 1196 error = uiomove(readdir_msg->pvnr_data + cookiemem, howmuch, uio); 1197 if (error) 1198 goto out; 1199 1200 /* provide cookies to caller if so desired */ 1201 if (ap->a_cookies) { 1202 *ap->a_cookies = malloc(readdir_msg->pvnr_ncookies*CSIZE, 1203 M_TEMP, M_WAITOK); 1204 *ap->a_ncookies = readdir_msg->pvnr_ncookies; 1205 memcpy(*ap->a_cookies, readdir_msg->pvnr_data, 1206 *ap->a_ncookies*CSIZE); 1207 } 1208 1209 /* next readdir starts here */ 1210 uio->uio_offset = readdir_msg->pvnr_offset; 1211 1212 out: 1213 puffs_msgmem_release(park_readdir); 1214 return error; 1215 } 1216 #undef CSIZE 1217 1218 /* 1219 * poll works by consuming the bitmask in pn_revents. If there are 1220 * events available, poll returns immediately. If not, it issues a 1221 * poll to userspace, selrecords itself and returns with no available 1222 * events. When the file server returns, it executes puffs_parkdone_poll(), 1223 * where available events are added to the bitmask. selnotify() is 1224 * then also executed by that function causing us to enter here again 1225 * and hopefully find the missing bits (unless someone got them first, 1226 * in which case it starts all over again). 1227 */ 1228 int 1229 puffs_vnop_poll(void *v) 1230 { 1231 struct vop_poll_args /* { 1232 const struct vnodeop_desc *a_desc; 1233 struct vnode *a_vp; 1234 int a_events; 1235 } */ *ap = v; 1236 PUFFS_MSG_VARS(vn, poll); 1237 struct vnode *vp = ap->a_vp; 1238 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount); 1239 struct puffs_node *pn = vp->v_data; 1240 int events, error; 1241 1242 if (EXISTSOP(pmp, POLL)) { 1243 mutex_enter(&pn->pn_mtx); 1244 events = pn->pn_revents & ap->a_events; 1245 if (events & ap->a_events) { 1246 pn->pn_revents &= ~ap->a_events; 1247 mutex_exit(&pn->pn_mtx); 1248 1249 return events; 1250 } else { 1251 puffs_referencenode(pn); 1252 mutex_exit(&pn->pn_mtx); 1253 1254 PUFFS_MSG_ALLOC(vn, poll); 1255 poll_msg->pvnr_events = ap->a_events; 1256 puffs_msg_setinfo(park_poll, PUFFSOP_VN, 1257 PUFFS_VN_POLL, VPTOPNC(vp)); 1258 puffs_msg_setcall(park_poll, puffs_parkdone_poll, pn); 1259 selrecord(curlwp, &pn->pn_sel); 1260 1261 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_poll, vp->v_data, 1262 NULL, error); 1263 PUFFS_MSG_RELEASE(poll); 1264 1265 return 0; 1266 } 1267 } else { 1268 return genfs_poll(v); 1269 } 1270 } 1271 1272 int 1273 puffs_vnop_fsync(void *v) 1274 { 1275 struct vop_fsync_args /* { 1276 const struct vnodeop_desc *a_desc; 1277 struct vnode *a_vp; 1278 kauth_cred_t a_cred; 1279 int a_flags; 1280 off_t a_offlo; 1281 off_t a_offhi; 1282 } */ *ap = v; 1283 PUFFS_MSG_VARS(vn, fsync); 1284 struct vnode *vp = ap->a_vp; 1285 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount); 1286 struct puffs_node *pn; 1287 struct vattr va; 1288 int pflags, error, dofaf; 1289 1290 pn = VPTOPP(vp); 1291 1292 /* flush out information from our metacache, see vop_setattr */ 1293 if (pn->pn_stat & PNODE_METACACHE_MASK 1294 && (pn->pn_stat & PNODE_DYING) == 0) { 1295 vattr_null(&va); 1296 error = VOP_SETATTR(vp, &va, FSCRED); 1297 if (error) 1298 return error; 1299 } 1300 1301 /* 1302 * flush pages to avoid being overly dirty 1303 */ 1304 pflags = PGO_CLEANIT; 1305 if (ap->a_flags & FSYNC_WAIT) 1306 pflags |= PGO_SYNCIO; 1307 mutex_enter(&vp->v_interlock); 1308 error = VOP_PUTPAGES(vp, trunc_page(ap->a_offlo), 1309 round_page(ap->a_offhi), pflags); 1310 if (error) 1311 return error; 1312 1313 /* 1314 * HELLO! We exit already here if the user server does not 1315 * support fsync OR if we should call fsync for a node which 1316 * has references neither in the kernel or the fs server. 1317 * Otherwise we continue to issue fsync() forward. 1318 */ 1319 if (!EXISTSOP(pmp, FSYNC) || (pn->pn_stat & PNODE_DYING)) 1320 return 0; 1321 1322 dofaf = (ap->a_flags & FSYNC_WAIT) == 0 || ap->a_flags == FSYNC_LAZY; 1323 /* 1324 * We abuse VXLOCK to mean "vnode is going to die", so we issue 1325 * only FAFs for those. Otherwise there's a danger of deadlock, 1326 * since the execution context here might be the user server 1327 * doing some operation on another fs, which in turn caused a 1328 * vnode to be reclaimed from the freelist for this fs. 1329 */ 1330 if (dofaf == 0) { 1331 mutex_enter(&vp->v_interlock); 1332 if (vp->v_iflag & VI_XLOCK) 1333 dofaf = 1; 1334 mutex_exit(&vp->v_interlock); 1335 } 1336 1337 PUFFS_MSG_ALLOC(vn, fsync); 1338 if (dofaf) 1339 puffs_msg_setfaf(park_fsync); 1340 1341 puffs_credcvt(&fsync_msg->pvnr_cred, ap->a_cred); 1342 fsync_msg->pvnr_flags = ap->a_flags; 1343 fsync_msg->pvnr_offlo = ap->a_offlo; 1344 fsync_msg->pvnr_offhi = ap->a_offhi; 1345 puffs_msg_setinfo(park_fsync, PUFFSOP_VN, 1346 PUFFS_VN_FSYNC, VPTOPNC(vp)); 1347 1348 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_fsync, vp->v_data, NULL, error); 1349 PUFFS_MSG_RELEASE(fsync); 1350 1351 error = checkerr(pmp, error, __func__); 1352 1353 return error; 1354 } 1355 1356 int 1357 puffs_vnop_seek(void *v) 1358 { 1359 struct vop_seek_args /* { 1360 const struct vnodeop_desc *a_desc; 1361 struct vnode *a_vp; 1362 off_t a_oldoff; 1363 off_t a_newoff; 1364 kauth_cred_t a_cred; 1365 } */ *ap = v; 1366 PUFFS_MSG_VARS(vn, seek); 1367 struct vnode *vp = ap->a_vp; 1368 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount); 1369 int error; 1370 1371 PUFFS_MSG_ALLOC(vn, seek); 1372 seek_msg->pvnr_oldoff = ap->a_oldoff; 1373 seek_msg->pvnr_newoff = ap->a_newoff; 1374 puffs_credcvt(&seek_msg->pvnr_cred, ap->a_cred); 1375 puffs_msg_setinfo(park_seek, PUFFSOP_VN, 1376 PUFFS_VN_SEEK, VPTOPNC(vp)); 1377 1378 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_seek, vp->v_data, NULL, error); 1379 PUFFS_MSG_RELEASE(seek); 1380 return checkerr(pmp, error, __func__); 1381 } 1382 1383 static int 1384 callremove(struct puffs_mount *pmp, puffs_cookie_t dck, puffs_cookie_t ck, 1385 struct componentname *cnp) 1386 { 1387 PUFFS_MSG_VARS(vn, remove); 1388 int error; 1389 1390 PUFFS_MSG_ALLOC(vn, remove); 1391 remove_msg->pvnr_cookie_targ = ck; 1392 puffs_makecn(&remove_msg->pvnr_cn, &remove_msg->pvnr_cn_cred, 1393 cnp, PUFFS_USE_FULLPNBUF(pmp)); 1394 puffs_msg_setinfo(park_remove, PUFFSOP_VN, PUFFS_VN_REMOVE, dck); 1395 1396 PUFFS_MSG_ENQUEUEWAIT(pmp, park_remove, error); 1397 PUFFS_MSG_RELEASE(remove); 1398 1399 return checkerr(pmp, error, __func__); 1400 } 1401 1402 /* 1403 * XXX: can't use callremove now because can't catch setbacks with 1404 * it due to lack of a pnode argument. 1405 */ 1406 int 1407 puffs_vnop_remove(void *v) 1408 { 1409 struct vop_remove_args /* { 1410 const struct vnodeop_desc *a_desc; 1411 struct vnode *a_dvp; 1412 struct vnode *a_vp; 1413 struct componentname *a_cnp; 1414 } */ *ap = v; 1415 PUFFS_MSG_VARS(vn, remove); 1416 struct vnode *dvp = ap->a_dvp; 1417 struct vnode *vp = ap->a_vp; 1418 struct puffs_node *dpn = VPTOPP(dvp); 1419 struct puffs_node *pn = VPTOPP(vp); 1420 struct componentname *cnp = ap->a_cnp; 1421 struct mount *mp = dvp->v_mount; 1422 struct puffs_mount *pmp = MPTOPUFFSMP(mp); 1423 int error; 1424 1425 PUFFS_MSG_ALLOC(vn, remove); 1426 remove_msg->pvnr_cookie_targ = VPTOPNC(vp); 1427 puffs_makecn(&remove_msg->pvnr_cn, &remove_msg->pvnr_cn_cred, 1428 cnp, PUFFS_USE_FULLPNBUF(pmp)); 1429 puffs_msg_setinfo(park_remove, PUFFSOP_VN, 1430 PUFFS_VN_REMOVE, VPTOPNC(dvp)); 1431 1432 puffs_msg_enqueue(pmp, park_remove); 1433 REFPN_AND_UNLOCKVP(dvp, dpn); 1434 if (dvp == vp) 1435 REFPN(pn); 1436 else 1437 REFPN_AND_UNLOCKVP(vp, pn); 1438 error = puffs_msg_wait2(pmp, park_remove, dpn, pn); 1439 1440 PUFFS_MSG_RELEASE(remove); 1441 1442 RELEPN_AND_VP(dvp, dpn); 1443 RELEPN_AND_VP(vp, pn); 1444 1445 error = checkerr(pmp, error, __func__); 1446 if (error || (cnp->cn_flags & SAVESTART) == 0) 1447 PNBUF_PUT(cnp->cn_pnbuf); 1448 return error; 1449 } 1450 1451 int 1452 puffs_vnop_mkdir(void *v) 1453 { 1454 struct vop_mkdir_args /* { 1455 const struct vnodeop_desc *a_desc; 1456 struct vnode *a_dvp; 1457 struct vnode **a_vpp; 1458 struct componentname *a_cnp; 1459 struct vattr *a_vap; 1460 } */ *ap = v; 1461 PUFFS_MSG_VARS(vn, mkdir); 1462 struct vnode *dvp = ap->a_dvp; 1463 struct puffs_node *dpn = VPTOPP(dvp); 1464 struct componentname *cnp = ap->a_cnp; 1465 struct mount *mp = dvp->v_mount; 1466 struct puffs_mount *pmp = MPTOPUFFSMP(mp); 1467 int error; 1468 1469 PUFFS_MSG_ALLOC(vn, mkdir); 1470 puffs_makecn(&mkdir_msg->pvnr_cn, &mkdir_msg->pvnr_cn_cred, 1471 cnp, PUFFS_USE_FULLPNBUF(pmp)); 1472 mkdir_msg->pvnr_va = *ap->a_vap; 1473 puffs_msg_setinfo(park_mkdir, PUFFSOP_VN, 1474 PUFFS_VN_MKDIR, VPTOPNC(dvp)); 1475 1476 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_mkdir, dvp->v_data, NULL, error); 1477 1478 error = checkerr(pmp, error, __func__); 1479 if (error) 1480 goto out; 1481 1482 error = puffs_newnode(mp, dvp, ap->a_vpp, 1483 mkdir_msg->pvnr_newnode, cnp, VDIR, 0); 1484 if (error) 1485 puffs_abortbutton(pmp, PUFFS_ABORT_MKDIR, dpn->pn_cookie, 1486 mkdir_msg->pvnr_newnode, cnp); 1487 1488 out: 1489 vput(dvp); 1490 PUFFS_MSG_RELEASE(mkdir); 1491 if (error || (cnp->cn_flags & SAVESTART) == 0) 1492 PNBUF_PUT(cnp->cn_pnbuf); 1493 return error; 1494 } 1495 1496 static int 1497 callrmdir(struct puffs_mount *pmp, puffs_cookie_t dck, puffs_cookie_t ck, 1498 struct componentname *cnp) 1499 { 1500 PUFFS_MSG_VARS(vn, rmdir); 1501 int error; 1502 1503 PUFFS_MSG_ALLOC(vn, rmdir); 1504 rmdir_msg->pvnr_cookie_targ = ck; 1505 puffs_makecn(&rmdir_msg->pvnr_cn, &rmdir_msg->pvnr_cn_cred, 1506 cnp, PUFFS_USE_FULLPNBUF(pmp)); 1507 puffs_msg_setinfo(park_rmdir, PUFFSOP_VN, PUFFS_VN_RMDIR, dck); 1508 1509 PUFFS_MSG_ENQUEUEWAIT(pmp, park_rmdir, error); 1510 PUFFS_MSG_RELEASE(rmdir); 1511 1512 return checkerr(pmp, error, __func__); 1513 } 1514 1515 int 1516 puffs_vnop_rmdir(void *v) 1517 { 1518 struct vop_rmdir_args /* { 1519 const struct vnodeop_desc *a_desc; 1520 struct vnode *a_dvp; 1521 struct vnode *a_vp; 1522 struct componentname *a_cnp; 1523 } */ *ap = v; 1524 PUFFS_MSG_VARS(vn, rmdir); 1525 struct vnode *dvp = ap->a_dvp; 1526 struct vnode *vp = ap->a_vp; 1527 struct puffs_node *dpn = VPTOPP(dvp); 1528 struct puffs_node *pn = VPTOPP(vp); 1529 struct puffs_mount *pmp = MPTOPUFFSMP(dvp->v_mount); 1530 struct componentname *cnp = ap->a_cnp; 1531 int error; 1532 1533 PUFFS_MSG_ALLOC(vn, rmdir); 1534 rmdir_msg->pvnr_cookie_targ = VPTOPNC(vp); 1535 puffs_makecn(&rmdir_msg->pvnr_cn, &rmdir_msg->pvnr_cn_cred, 1536 cnp, PUFFS_USE_FULLPNBUF(pmp)); 1537 puffs_msg_setinfo(park_rmdir, PUFFSOP_VN, 1538 PUFFS_VN_RMDIR, VPTOPNC(dvp)); 1539 1540 puffs_msg_enqueue(pmp, park_rmdir); 1541 REFPN_AND_UNLOCKVP(dvp, dpn); 1542 REFPN_AND_UNLOCKVP(vp, pn); 1543 error = puffs_msg_wait2(pmp, park_rmdir, dpn, pn); 1544 1545 PUFFS_MSG_RELEASE(rmdir); 1546 1547 /* XXX: some call cache_purge() *for both vnodes* here, investigate */ 1548 RELEPN_AND_VP(dvp, dpn); 1549 RELEPN_AND_VP(vp, pn); 1550 1551 if (error || (cnp->cn_flags & SAVESTART) == 0) 1552 PNBUF_PUT(cnp->cn_pnbuf); 1553 1554 return error; 1555 } 1556 1557 int 1558 puffs_vnop_link(void *v) 1559 { 1560 struct vop_link_args /* { 1561 const struct vnodeop_desc *a_desc; 1562 struct vnode *a_dvp; 1563 struct vnode *a_vp; 1564 struct componentname *a_cnp; 1565 } */ *ap = v; 1566 PUFFS_MSG_VARS(vn, link); 1567 struct vnode *dvp = ap->a_dvp; 1568 struct vnode *vp = ap->a_vp; 1569 struct puffs_node *dpn = VPTOPP(dvp); 1570 struct puffs_node *pn = VPTOPP(vp); 1571 struct puffs_mount *pmp = MPTOPUFFSMP(dvp->v_mount); 1572 struct componentname *cnp = ap->a_cnp; 1573 int error; 1574 1575 PUFFS_MSG_ALLOC(vn, link); 1576 link_msg->pvnr_cookie_targ = VPTOPNC(vp); 1577 puffs_makecn(&link_msg->pvnr_cn, &link_msg->pvnr_cn_cred, 1578 cnp, PUFFS_USE_FULLPNBUF(pmp)); 1579 puffs_msg_setinfo(park_link, PUFFSOP_VN, 1580 PUFFS_VN_LINK, VPTOPNC(dvp)); 1581 1582 puffs_msg_enqueue(pmp, park_link); 1583 REFPN_AND_UNLOCKVP(dvp, dpn); 1584 REFPN(pn); 1585 error = puffs_msg_wait2(pmp, park_link, dpn, pn); 1586 1587 PUFFS_MSG_RELEASE(link); 1588 1589 error = checkerr(pmp, error, __func__); 1590 1591 /* 1592 * XXX: stay in touch with the cache. I don't like this, but 1593 * don't have a better solution either. See also puffs_rename(). 1594 */ 1595 if (error == 0) 1596 puffs_updatenode(pn, PUFFS_UPDATECTIME, 0); 1597 1598 PNBUF_PUT(cnp->cn_pnbuf); 1599 RELEPN_AND_VP(dvp, dpn); 1600 puffs_releasenode(pn); 1601 1602 return error; 1603 } 1604 1605 int 1606 puffs_vnop_symlink(void *v) 1607 { 1608 struct vop_symlink_args /* { 1609 const struct vnodeop_desc *a_desc; 1610 struct vnode *a_dvp; 1611 struct vnode **a_vpp; 1612 struct componentname *a_cnp; 1613 struct vattr *a_vap; 1614 char *a_target; 1615 } */ *ap = v; 1616 PUFFS_MSG_VARS(vn, symlink); 1617 struct vnode *dvp = ap->a_dvp; 1618 struct puffs_node *dpn = VPTOPP(dvp); 1619 struct mount *mp = dvp->v_mount; 1620 struct puffs_mount *pmp = MPTOPUFFSMP(dvp->v_mount); 1621 struct componentname *cnp = ap->a_cnp; 1622 int error; 1623 1624 *ap->a_vpp = NULL; 1625 1626 PUFFS_MSG_ALLOC(vn, symlink); 1627 puffs_makecn(&symlink_msg->pvnr_cn, &symlink_msg->pvnr_cn_cred, 1628 cnp, PUFFS_USE_FULLPNBUF(pmp)); 1629 symlink_msg->pvnr_va = *ap->a_vap; 1630 (void)strlcpy(symlink_msg->pvnr_link, ap->a_target, 1631 sizeof(symlink_msg->pvnr_link)); 1632 puffs_msg_setinfo(park_symlink, PUFFSOP_VN, 1633 PUFFS_VN_SYMLINK, VPTOPNC(dvp)); 1634 1635 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_symlink, dvp->v_data, NULL, error); 1636 1637 error = checkerr(pmp, error, __func__); 1638 if (error) 1639 goto out; 1640 1641 error = puffs_newnode(mp, dvp, ap->a_vpp, 1642 symlink_msg->pvnr_newnode, cnp, VLNK, 0); 1643 if (error) 1644 puffs_abortbutton(pmp, PUFFS_ABORT_SYMLINK, dpn->pn_cookie, 1645 symlink_msg->pvnr_newnode, cnp); 1646 1647 out: 1648 vput(dvp); 1649 PUFFS_MSG_RELEASE(symlink); 1650 if (error || (cnp->cn_flags & SAVESTART) == 0) 1651 PNBUF_PUT(cnp->cn_pnbuf); 1652 1653 return error; 1654 } 1655 1656 int 1657 puffs_vnop_readlink(void *v) 1658 { 1659 struct vop_readlink_args /* { 1660 const struct vnodeop_desc *a_desc; 1661 struct vnode *a_vp; 1662 struct uio *a_uio; 1663 kauth_cred_t a_cred; 1664 } */ *ap = v; 1665 PUFFS_MSG_VARS(vn, readlink); 1666 struct vnode *vp = ap->a_vp; 1667 struct puffs_mount *pmp = MPTOPUFFSMP(ap->a_vp->v_mount); 1668 size_t linklen; 1669 int error; 1670 1671 PUFFS_MSG_ALLOC(vn, readlink); 1672 puffs_credcvt(&readlink_msg->pvnr_cred, ap->a_cred); 1673 linklen = sizeof(readlink_msg->pvnr_link); 1674 readlink_msg->pvnr_linklen = linklen; 1675 puffs_msg_setinfo(park_readlink, PUFFSOP_VN, 1676 PUFFS_VN_READLINK, VPTOPNC(vp)); 1677 1678 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_readlink, vp->v_data, NULL, error); 1679 error = checkerr(pmp, error, __func__); 1680 if (error) 1681 goto out; 1682 1683 /* bad bad user file server */ 1684 if (readlink_msg->pvnr_linklen > linklen) { 1685 puffs_senderr(pmp, PUFFS_ERR_READLINK, E2BIG, 1686 "linklen too big", VPTOPNC(ap->a_vp)); 1687 error = EPROTO; 1688 goto out; 1689 } 1690 1691 error = uiomove(&readlink_msg->pvnr_link, readlink_msg->pvnr_linklen, 1692 ap->a_uio); 1693 out: 1694 PUFFS_MSG_RELEASE(readlink); 1695 return error; 1696 } 1697 1698 int 1699 puffs_vnop_rename(void *v) 1700 { 1701 struct vop_rename_args /* { 1702 const struct vnodeop_desc *a_desc; 1703 struct vnode *a_fdvp; 1704 struct vnode *a_fvp; 1705 struct componentname *a_fcnp; 1706 struct vnode *a_tdvp; 1707 struct vnode *a_tvp; 1708 struct componentname *a_tcnp; 1709 } */ *ap = v; 1710 PUFFS_MSG_VARS(vn, rename); 1711 struct vnode *fdvp = ap->a_fdvp, *fvp = ap->a_fvp; 1712 struct vnode *tdvp = ap->a_tdvp, *tvp = ap->a_tvp; 1713 struct puffs_node *fpn = ap->a_fvp->v_data; 1714 struct puffs_mount *pmp = MPTOPUFFSMP(fdvp->v_mount); 1715 int error; 1716 bool doabort = true; 1717 1718 if ((fvp->v_mount != tdvp->v_mount) || 1719 (tvp && (fvp->v_mount != tvp->v_mount))) { 1720 ERROUT(EXDEV); 1721 } 1722 1723 PUFFS_MSG_ALLOC(vn, rename); 1724 rename_msg->pvnr_cookie_src = VPTOPNC(fvp); 1725 rename_msg->pvnr_cookie_targdir = VPTOPNC(tdvp); 1726 if (tvp) 1727 rename_msg->pvnr_cookie_targ = VPTOPNC(tvp); 1728 else 1729 rename_msg->pvnr_cookie_targ = NULL; 1730 puffs_makecn(&rename_msg->pvnr_cn_src, &rename_msg->pvnr_cn_src_cred, 1731 ap->a_fcnp, PUFFS_USE_FULLPNBUF(pmp)); 1732 puffs_makecn(&rename_msg->pvnr_cn_targ, &rename_msg->pvnr_cn_targ_cred, 1733 ap->a_tcnp, PUFFS_USE_FULLPNBUF(pmp)); 1734 puffs_msg_setinfo(park_rename, PUFFSOP_VN, 1735 PUFFS_VN_RENAME, VPTOPNC(fdvp)); 1736 1737 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_rename, fdvp->v_data, NULL, error); 1738 doabort = false; 1739 PUFFS_MSG_RELEASE(rename); 1740 error = checkerr(pmp, error, __func__); 1741 1742 /* 1743 * XXX: stay in touch with the cache. I don't like this, but 1744 * don't have a better solution either. See also puffs_link(). 1745 */ 1746 if (error == 0) 1747 puffs_updatenode(fpn, PUFFS_UPDATECTIME, 0); 1748 1749 out: 1750 if (doabort) 1751 VOP_ABORTOP(tdvp, ap->a_tcnp); 1752 if (tvp != NULL) 1753 vput(tvp); 1754 if (tdvp == tvp) 1755 vrele(tdvp); 1756 else 1757 vput(tdvp); 1758 1759 if (doabort) 1760 VOP_ABORTOP(fdvp, ap->a_fcnp); 1761 vrele(fdvp); 1762 vrele(fvp); 1763 1764 return error; 1765 } 1766 1767 #define RWARGS(cont, iofl, move, offset, creds) \ 1768 (cont)->pvnr_ioflag = (iofl); \ 1769 (cont)->pvnr_resid = (move); \ 1770 (cont)->pvnr_offset = (offset); \ 1771 puffs_credcvt(&(cont)->pvnr_cred, creds) 1772 1773 int 1774 puffs_vnop_read(void *v) 1775 { 1776 struct vop_read_args /* { 1777 const struct vnodeop_desc *a_desc; 1778 struct vnode *a_vp; 1779 struct uio *a_uio; 1780 int a_ioflag; 1781 kauth_cred_t a_cred; 1782 } */ *ap = v; 1783 PUFFS_MSG_VARS(vn, read); 1784 struct vnode *vp = ap->a_vp; 1785 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount); 1786 struct uio *uio = ap->a_uio; 1787 size_t tomove, argsize; 1788 vsize_t bytelen; 1789 int error; 1790 1791 read_msg = NULL; 1792 error = 0; 1793 1794 /* std sanity */ 1795 if (uio->uio_resid == 0) 1796 return 0; 1797 if (uio->uio_offset < 0) 1798 return EINVAL; 1799 1800 if (vp->v_type == VREG && PUFFS_USE_PAGECACHE(pmp)) { 1801 const int advice = IO_ADV_DECODE(ap->a_ioflag); 1802 1803 while (uio->uio_resid > 0) { 1804 bytelen = MIN(uio->uio_resid, 1805 vp->v_size - uio->uio_offset); 1806 if (bytelen == 0) 1807 break; 1808 1809 error = ubc_uiomove(&vp->v_uobj, uio, bytelen, advice, 1810 UBC_READ | UBC_PARTIALOK | UBC_UNMAP_FLAG(vp)); 1811 if (error) 1812 break; 1813 } 1814 1815 if ((vp->v_mount->mnt_flag & MNT_NOATIME) == 0) 1816 puffs_updatenode(VPTOPP(vp), PUFFS_UPDATEATIME, 0); 1817 } else { 1818 /* 1819 * in case it's not a regular file or we're operating 1820 * uncached, do read in the old-fashioned style, 1821 * i.e. explicit read operations 1822 */ 1823 1824 tomove = PUFFS_TOMOVE(uio->uio_resid, pmp); 1825 argsize = sizeof(struct puffs_vnmsg_read); 1826 puffs_msgmem_alloc(argsize + tomove, &park_read, 1827 (void *)&read_msg, 1); 1828 1829 error = 0; 1830 while (uio->uio_resid > 0) { 1831 tomove = PUFFS_TOMOVE(uio->uio_resid, pmp); 1832 memset(read_msg, 0, argsize); /* XXX: touser KASSERT */ 1833 RWARGS(read_msg, ap->a_ioflag, tomove, 1834 uio->uio_offset, ap->a_cred); 1835 puffs_msg_setinfo(park_read, PUFFSOP_VN, 1836 PUFFS_VN_READ, VPTOPNC(vp)); 1837 puffs_msg_setdelta(park_read, tomove); 1838 1839 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_read, vp->v_data, 1840 NULL, error); 1841 error = checkerr(pmp, error, __func__); 1842 if (error) 1843 break; 1844 1845 if (read_msg->pvnr_resid > tomove) { 1846 puffs_senderr(pmp, PUFFS_ERR_READ, 1847 E2BIG, "resid grew", VPTOPNC(ap->a_vp)); 1848 error = EPROTO; 1849 break; 1850 } 1851 1852 error = uiomove(read_msg->pvnr_data, 1853 tomove - read_msg->pvnr_resid, uio); 1854 1855 /* 1856 * in case the file is out of juice, resid from 1857 * userspace is != 0. and the error-case is 1858 * quite obvious 1859 */ 1860 if (error || read_msg->pvnr_resid) 1861 break; 1862 } 1863 1864 puffs_msgmem_release(park_read); 1865 } 1866 1867 return error; 1868 } 1869 1870 /* 1871 * XXX: in case of a failure, this leaves uio in a bad state. 1872 * We could theoretically copy the uio and iovecs and "replay" 1873 * them the right amount after the userspace trip, but don't 1874 * bother for now. 1875 */ 1876 int 1877 puffs_vnop_write(void *v) 1878 { 1879 struct vop_write_args /* { 1880 const struct vnodeop_desc *a_desc; 1881 struct vnode *a_vp; 1882 struct uio *a_uio; 1883 int a_ioflag; 1884 kauth_cred_t a_cred; 1885 } */ *ap = v; 1886 PUFFS_MSG_VARS(vn, write); 1887 struct vnode *vp = ap->a_vp; 1888 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount); 1889 struct uio *uio = ap->a_uio; 1890 size_t tomove, argsize; 1891 off_t oldoff, newoff, origoff; 1892 vsize_t bytelen; 1893 int error, uflags; 1894 int ubcflags; 1895 1896 error = uflags = 0; 1897 write_msg = NULL; 1898 1899 if (vp->v_type == VREG && PUFFS_USE_PAGECACHE(pmp)) { 1900 ubcflags = UBC_WRITE | UBC_PARTIALOK | UBC_UNMAP_FLAG(vp); 1901 1902 /* 1903 * userspace *should* be allowed to control this, 1904 * but with UBC it's a bit unclear how to handle it 1905 */ 1906 if (ap->a_ioflag & IO_APPEND) 1907 uio->uio_offset = vp->v_size; 1908 1909 origoff = uio->uio_offset; 1910 while (uio->uio_resid > 0) { 1911 uflags |= PUFFS_UPDATECTIME; 1912 uflags |= PUFFS_UPDATEMTIME; 1913 oldoff = uio->uio_offset; 1914 bytelen = uio->uio_resid; 1915 1916 newoff = oldoff + bytelen; 1917 if (vp->v_size < newoff) { 1918 uvm_vnp_setwritesize(vp, newoff); 1919 } 1920 error = ubc_uiomove(&vp->v_uobj, uio, bytelen, 1921 UVM_ADV_RANDOM, ubcflags); 1922 1923 /* 1924 * In case of a ubc_uiomove() error, 1925 * opt to not extend the file at all and 1926 * return an error. Otherwise, if we attempt 1927 * to clear the memory we couldn't fault to, 1928 * we might generate a kernel page fault. 1929 */ 1930 if (vp->v_size < newoff) { 1931 if (error == 0) { 1932 uflags |= PUFFS_UPDATESIZE; 1933 uvm_vnp_setsize(vp, newoff); 1934 } else { 1935 uvm_vnp_setwritesize(vp, vp->v_size); 1936 } 1937 } 1938 if (error) 1939 break; 1940 1941 /* 1942 * If we're writing large files, flush to file server 1943 * every 64k. Otherwise we can very easily exhaust 1944 * kernel and user memory, as the file server cannot 1945 * really keep up with our writing speed. 1946 * 1947 * Note: this does *NOT* honor MNT_ASYNC, because 1948 * that gives userland too much say in the kernel. 1949 */ 1950 if (oldoff >> 16 != uio->uio_offset >> 16) { 1951 mutex_enter(&vp->v_interlock); 1952 error = VOP_PUTPAGES(vp, oldoff & ~0xffff, 1953 uio->uio_offset & ~0xffff, 1954 PGO_CLEANIT | PGO_SYNCIO); 1955 if (error) 1956 break; 1957 } 1958 } 1959 1960 /* synchronous I/O? */ 1961 if (error == 0 && ap->a_ioflag & IO_SYNC) { 1962 mutex_enter(&vp->v_interlock); 1963 error = VOP_PUTPAGES(vp, trunc_page(origoff), 1964 round_page(uio->uio_offset), 1965 PGO_CLEANIT | PGO_SYNCIO); 1966 1967 /* write through page cache? */ 1968 } else if (error == 0 && pmp->pmp_flags & PUFFS_KFLAG_WTCACHE) { 1969 mutex_enter(&vp->v_interlock); 1970 error = VOP_PUTPAGES(vp, trunc_page(origoff), 1971 round_page(uio->uio_offset), PGO_CLEANIT); 1972 } 1973 1974 puffs_updatenode(VPTOPP(vp), uflags, vp->v_size); 1975 } else { 1976 /* tomove is non-increasing */ 1977 tomove = PUFFS_TOMOVE(uio->uio_resid, pmp); 1978 argsize = sizeof(struct puffs_vnmsg_write) + tomove; 1979 puffs_msgmem_alloc(argsize, &park_write, (void *)&write_msg,1); 1980 1981 while (uio->uio_resid > 0) { 1982 /* move data to buffer */ 1983 tomove = PUFFS_TOMOVE(uio->uio_resid, pmp); 1984 memset(write_msg, 0, argsize); /* XXX: touser KASSERT */ 1985 RWARGS(write_msg, ap->a_ioflag, tomove, 1986 uio->uio_offset, ap->a_cred); 1987 error = uiomove(write_msg->pvnr_data, tomove, uio); 1988 if (error) 1989 break; 1990 1991 /* move buffer to userspace */ 1992 puffs_msg_setinfo(park_write, PUFFSOP_VN, 1993 PUFFS_VN_WRITE, VPTOPNC(vp)); 1994 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_write, vp->v_data, 1995 NULL, error); 1996 error = checkerr(pmp, error, __func__); 1997 if (error) 1998 break; 1999 2000 if (write_msg->pvnr_resid > tomove) { 2001 puffs_senderr(pmp, PUFFS_ERR_WRITE, 2002 E2BIG, "resid grew", VPTOPNC(ap->a_vp)); 2003 error = EPROTO; 2004 break; 2005 } 2006 2007 /* adjust file size */ 2008 if (vp->v_size < uio->uio_offset) 2009 uvm_vnp_setsize(vp, uio->uio_offset); 2010 2011 /* didn't move everything? bad userspace. bail */ 2012 if (write_msg->pvnr_resid != 0) { 2013 error = EIO; 2014 break; 2015 } 2016 } 2017 puffs_msgmem_release(park_write); 2018 } 2019 2020 return error; 2021 } 2022 2023 int 2024 puffs_vnop_print(void *v) 2025 { 2026 struct vop_print_args /* { 2027 struct vnode *a_vp; 2028 } */ *ap = v; 2029 PUFFS_MSG_VARS(vn, print); 2030 struct vnode *vp = ap->a_vp; 2031 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount); 2032 struct puffs_node *pn = vp->v_data; 2033 int error; 2034 2035 /* kernel portion */ 2036 printf("tag VT_PUFFS, vnode %p, puffs node: %p,\n" 2037 " userspace cookie: %p\n", vp, pn, pn->pn_cookie); 2038 if (vp->v_type == VFIFO) 2039 fifo_printinfo(vp); 2040 2041 /* userspace portion */ 2042 if (EXISTSOP(pmp, PRINT)) { 2043 PUFFS_MSG_ALLOC(vn, print); 2044 puffs_msg_setinfo(park_print, PUFFSOP_VN, 2045 PUFFS_VN_PRINT, VPTOPNC(vp)); 2046 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_print, vp->v_data, 2047 NULL, error); 2048 PUFFS_MSG_RELEASE(print); 2049 } 2050 2051 return 0; 2052 } 2053 2054 int 2055 puffs_vnop_pathconf(void *v) 2056 { 2057 struct vop_pathconf_args /* { 2058 const struct vnodeop_desc *a_desc; 2059 struct vnode *a_vp; 2060 int a_name; 2061 register_t *a_retval; 2062 } */ *ap = v; 2063 PUFFS_MSG_VARS(vn, pathconf); 2064 struct vnode *vp = ap->a_vp; 2065 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount); 2066 int error; 2067 2068 PUFFS_MSG_ALLOC(vn, pathconf); 2069 pathconf_msg->pvnr_name = ap->a_name; 2070 puffs_msg_setinfo(park_pathconf, PUFFSOP_VN, 2071 PUFFS_VN_PATHCONF, VPTOPNC(vp)); 2072 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_pathconf, vp->v_data, NULL, error); 2073 error = checkerr(pmp, error, __func__); 2074 if (!error) 2075 *ap->a_retval = pathconf_msg->pvnr_retval; 2076 PUFFS_MSG_RELEASE(pathconf); 2077 2078 return error; 2079 } 2080 2081 int 2082 puffs_vnop_advlock(void *v) 2083 { 2084 struct vop_advlock_args /* { 2085 const struct vnodeop_desc *a_desc; 2086 struct vnode *a_vp; 2087 void *a_id; 2088 int a_op; 2089 struct flock *a_fl; 2090 int a_flags; 2091 } */ *ap = v; 2092 PUFFS_MSG_VARS(vn, advlock); 2093 struct vnode *vp = ap->a_vp; 2094 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount); 2095 int error; 2096 2097 PUFFS_MSG_ALLOC(vn, advlock); 2098 error = copyin(ap->a_fl, &advlock_msg->pvnr_fl, sizeof(struct flock)); 2099 if (error) 2100 goto out; 2101 advlock_msg->pvnr_id = ap->a_id; 2102 advlock_msg->pvnr_op = ap->a_op; 2103 advlock_msg->pvnr_flags = ap->a_flags; 2104 puffs_msg_setinfo(park_advlock, PUFFSOP_VN, 2105 PUFFS_VN_ADVLOCK, VPTOPNC(vp)); 2106 2107 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_advlock, vp->v_data, NULL, error); 2108 error = checkerr(pmp, error, __func__); 2109 2110 out: 2111 PUFFS_MSG_RELEASE(advlock); 2112 return error; 2113 } 2114 2115 int 2116 puffs_vnop_abortop(void *v) 2117 { 2118 struct vop_abortop_args /* { 2119 struct vnode *a_dvp; 2120 struct componentname *a_cnp; 2121 }; */ *ap = v; 2122 PUFFS_MSG_VARS(vn, abortop); 2123 struct vnode *dvp = ap->a_dvp; 2124 struct puffs_mount *pmp = MPTOPUFFSMP(dvp->v_mount); 2125 struct componentname *cnp = ap->a_cnp; 2126 2127 if (EXISTSOP(pmp, ABORTOP)) { 2128 PUFFS_MSG_ALLOC(vn, abortop); 2129 puffs_makecn(&abortop_msg->pvnr_cn, &abortop_msg->pvnr_cn_cred, 2130 cnp, PUFFS_USE_FULLPNBUF(pmp)); 2131 puffs_msg_setfaf(park_abortop); 2132 puffs_msg_setinfo(park_abortop, PUFFSOP_VN, 2133 PUFFS_VN_ABORTOP, VPTOPNC(dvp)); 2134 2135 puffs_msg_enqueue(pmp, park_abortop); 2136 PUFFS_MSG_RELEASE(abortop); 2137 } 2138 2139 return genfs_abortop(v); 2140 } 2141 2142 #define BIOASYNC(bp) (bp->b_flags & B_ASYNC) 2143 2144 /* 2145 * This maps itself to PUFFS_VN_READ/WRITE for data transfer. 2146 */ 2147 int 2148 puffs_vnop_strategy(void *v) 2149 { 2150 struct vop_strategy_args /* { 2151 const struct vnodeop_desc *a_desc; 2152 struct vnode *a_vp; 2153 struct buf *a_bp; 2154 } */ *ap = v; 2155 PUFFS_MSG_VARS(vn, rw); 2156 struct vnode *vp = ap->a_vp; 2157 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount); 2158 struct puffs_node *pn; 2159 struct buf *bp; 2160 size_t argsize; 2161 size_t tomove, moved; 2162 int error, dofaf, dobiodone; 2163 2164 pmp = MPTOPUFFSMP(vp->v_mount); 2165 bp = ap->a_bp; 2166 error = 0; 2167 dofaf = 0; 2168 pn = VPTOPP(vp); 2169 park_rw = NULL; /* explicit */ 2170 dobiodone = 1; 2171 2172 if ((BUF_ISREAD(bp) && !EXISTSOP(pmp, READ)) 2173 || (BUF_ISWRITE(bp) && !EXISTSOP(pmp, WRITE))) 2174 ERROUT(EOPNOTSUPP); 2175 2176 /* 2177 * Short-circuit optimization: don't flush buffer in between 2178 * VOP_INACTIVE and VOP_RECLAIM in case the node has no references. 2179 */ 2180 if (pn->pn_stat & PNODE_DYING) { 2181 KASSERT(BUF_ISWRITE(bp)); 2182 bp->b_resid = 0; 2183 goto out; 2184 } 2185 2186 #ifdef DIAGNOSTIC 2187 if (bp->b_bcount > pmp->pmp_msg_maxsize - PUFFS_MSGSTRUCT_MAX) 2188 panic("puffs_strategy: wildly inappropriate buf bcount %d", 2189 bp->b_bcount); 2190 #endif 2191 2192 /* 2193 * See explanation for the necessity of a FAF in puffs_fsync. 2194 * 2195 * Also, do FAF in case we're suspending. 2196 * See puffs_vfsops.c:pageflush() 2197 */ 2198 if (BUF_ISWRITE(bp)) { 2199 mutex_enter(&vp->v_interlock); 2200 if (vp->v_iflag & VI_XLOCK) 2201 dofaf = 1; 2202 if (pn->pn_stat & PNODE_FAF) 2203 dofaf = 1; 2204 mutex_exit(&vp->v_interlock); 2205 } 2206 2207 #ifdef DIAGNOSTIC 2208 if (curlwp == uvm.pagedaemon_lwp) 2209 KASSERT(dofaf || BIOASYNC(bp)); 2210 #endif 2211 2212 /* allocate transport structure */ 2213 tomove = PUFFS_TOMOVE(bp->b_bcount, pmp); 2214 argsize = sizeof(struct puffs_vnmsg_rw); 2215 error = puffs_msgmem_alloc(argsize + tomove, &park_rw, 2216 (void *)&rw_msg, dofaf ? 0 : 1); 2217 if (error) 2218 goto out; 2219 RWARGS(rw_msg, 0, tomove, bp->b_blkno << DEV_BSHIFT, FSCRED); 2220 2221 /* 2x2 cases: read/write, faf/nofaf */ 2222 if (BUF_ISREAD(bp)) { 2223 puffs_msg_setinfo(park_rw, PUFFSOP_VN, 2224 PUFFS_VN_READ, VPTOPNC(vp)); 2225 puffs_msg_setdelta(park_rw, tomove); 2226 if (BIOASYNC(bp)) { 2227 puffs_msg_setcall(park_rw, 2228 puffs_parkdone_asyncbioread, bp); 2229 puffs_msg_enqueue(pmp, park_rw); 2230 dobiodone = 0; 2231 } else { 2232 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_rw, vp->v_data, 2233 NULL, error); 2234 error = checkerr(pmp, error, __func__); 2235 if (error) 2236 goto out; 2237 2238 if (rw_msg->pvnr_resid > tomove) { 2239 puffs_senderr(pmp, PUFFS_ERR_READ, 2240 E2BIG, "resid grew", VPTOPNC(vp)); 2241 ERROUT(EPROTO); 2242 } 2243 2244 moved = tomove - rw_msg->pvnr_resid; 2245 2246 (void)memcpy(bp->b_data, rw_msg->pvnr_data, moved); 2247 bp->b_resid = bp->b_bcount - moved; 2248 } 2249 } else { 2250 puffs_msg_setinfo(park_rw, PUFFSOP_VN, 2251 PUFFS_VN_WRITE, VPTOPNC(vp)); 2252 /* 2253 * make pages read-only before we write them if we want 2254 * write caching info 2255 */ 2256 if (PUFFS_WCACHEINFO(pmp)) { 2257 struct uvm_object *uobj = &vp->v_uobj; 2258 int npages = (bp->b_bcount + PAGE_SIZE-1) >> PAGE_SHIFT; 2259 struct vm_page *vmp; 2260 int i; 2261 2262 for (i = 0; i < npages; i++) { 2263 vmp= uvm_pageratop((vaddr_t)bp->b_data 2264 + (i << PAGE_SHIFT)); 2265 DPRINTF(("puffs_strategy: write-protecting " 2266 "vp %p page %p, offset %" PRId64"\n", 2267 vp, vmp, vmp->offset)); 2268 mutex_enter(&uobj->vmobjlock); 2269 vmp->flags |= PG_RDONLY; 2270 pmap_page_protect(vmp, VM_PROT_READ); 2271 mutex_exit(&uobj->vmobjlock); 2272 } 2273 } 2274 2275 (void)memcpy(&rw_msg->pvnr_data, bp->b_data, tomove); 2276 if (dofaf) { 2277 puffs_msg_setfaf(park_rw); 2278 } else if (BIOASYNC(bp)) { 2279 puffs_msg_setcall(park_rw, 2280 puffs_parkdone_asyncbiowrite, bp); 2281 dobiodone = 0; 2282 } 2283 2284 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_rw, vp->v_data, NULL, error); 2285 2286 if (dobiodone == 0) 2287 goto out; 2288 2289 /* 2290 * XXXXXXXX: wrong, but kernel can't survive strategy 2291 * failure currently. Here, have one more X: X. 2292 */ 2293 if (error != ENOMEM) 2294 error = 0; 2295 2296 error = checkerr(pmp, error, __func__); 2297 if (error) 2298 goto out; 2299 2300 if (rw_msg->pvnr_resid > tomove) { 2301 puffs_senderr(pmp, PUFFS_ERR_WRITE, 2302 E2BIG, "resid grew", VPTOPNC(vp)); 2303 ERROUT(EPROTO); 2304 } 2305 2306 /* 2307 * FAF moved everything. Frankly, we don't 2308 * really have a choice. 2309 */ 2310 if (dofaf && error == 0) 2311 moved = tomove; 2312 else 2313 moved = tomove - rw_msg->pvnr_resid; 2314 2315 bp->b_resid = bp->b_bcount - moved; 2316 if (bp->b_resid != 0) { 2317 ERROUT(EIO); 2318 } 2319 } 2320 2321 out: 2322 if (park_rw) 2323 puffs_msgmem_release(park_rw); 2324 2325 if (error) 2326 bp->b_error = error; 2327 2328 if (error || dobiodone) 2329 biodone(bp); 2330 2331 return error; 2332 } 2333 2334 int 2335 puffs_vnop_mmap(void *v) 2336 { 2337 struct vop_mmap_args /* { 2338 const struct vnodeop_desc *a_desc; 2339 struct vnode *a_vp; 2340 vm_prot_t a_prot; 2341 kauth_cred_t a_cred; 2342 } */ *ap = v; 2343 PUFFS_MSG_VARS(vn, mmap); 2344 struct vnode *vp = ap->a_vp; 2345 struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount); 2346 int error; 2347 2348 if (!PUFFS_USE_PAGECACHE(pmp)) 2349 return genfs_eopnotsupp(v); 2350 2351 if (EXISTSOP(pmp, MMAP)) { 2352 PUFFS_MSG_ALLOC(vn, mmap); 2353 mmap_msg->pvnr_prot = ap->a_prot; 2354 puffs_credcvt(&mmap_msg->pvnr_cred, ap->a_cred); 2355 puffs_msg_setinfo(park_mmap, PUFFSOP_VN, 2356 PUFFS_VN_MMAP, VPTOPNC(vp)); 2357 2358 PUFFS_MSG_ENQUEUEWAIT2(pmp, park_mmap, vp->v_data, NULL, error); 2359 error = checkerr(pmp, error, __func__); 2360 PUFFS_MSG_RELEASE(mmap); 2361 } else { 2362 error = genfs_mmap(v); 2363 } 2364 2365 return error; 2366 } 2367 2368 2369 /* 2370 * The rest don't get a free trip to userspace and back, they 2371 * have to stay within the kernel. 2372 */ 2373 2374 /* 2375 * bmap doesn't really make any sense for puffs, so just 1:1 map it. 2376 * well, maybe somehow, somewhere, some day .... 2377 */ 2378 int 2379 puffs_vnop_bmap(void *v) 2380 { 2381 struct vop_bmap_args /* { 2382 const struct vnodeop_desc *a_desc; 2383 struct vnode *a_vp; 2384 daddr_t a_bn; 2385 struct vnode **a_vpp; 2386 daddr_t *a_bnp; 2387 int *a_runp; 2388 } */ *ap = v; 2389 struct puffs_mount *pmp; 2390 2391 pmp = MPTOPUFFSMP(ap->a_vp->v_mount); 2392 2393 if (ap->a_vpp) 2394 *ap->a_vpp = ap->a_vp; 2395 if (ap->a_bnp) 2396 *ap->a_bnp = ap->a_bn; 2397 if (ap->a_runp) 2398 *ap->a_runp 2399 = (PUFFS_TOMOVE(pmp->pmp_msg_maxsize, pmp)>>DEV_BSHIFT) - 1; 2400 2401 return 0; 2402 } 2403 2404 /* 2405 * Handle getpages faults in puffs. We let genfs_getpages() do most 2406 * of the dirty work, but we come in this route to do accounting tasks. 2407 * If the user server has specified functions for cache notifications 2408 * about reads and/or writes, we record which type of operation we got, 2409 * for which page range, and proceed to issue a FAF notification to the 2410 * server about it. 2411 */ 2412 int 2413 puffs_vnop_getpages(void *v) 2414 { 2415 struct vop_getpages_args /* { 2416 const struct vnodeop_desc *a_desc; 2417 struct vnode *a_vp; 2418 voff_t a_offset; 2419 struct vm_page **a_m; 2420 int *a_count; 2421 int a_centeridx; 2422 vm_prot_t a_access_type; 2423 int a_advice; 2424 int a_flags; 2425 } */ *ap = v; 2426 struct puffs_mount *pmp; 2427 struct puffs_node *pn; 2428 struct vnode *vp; 2429 struct vm_page **pgs; 2430 struct puffs_cacheinfo *pcinfo = NULL; 2431 struct puffs_cacherun *pcrun; 2432 void *parkmem = NULL; 2433 size_t runsizes; 2434 int i, npages, si, streakon; 2435 int error, locked, write; 2436 2437 pmp = MPTOPUFFSMP(ap->a_vp->v_mount); 2438 npages = *ap->a_count; 2439 pgs = ap->a_m; 2440 vp = ap->a_vp; 2441 pn = vp->v_data; 2442 locked = (ap->a_flags & PGO_LOCKED) != 0; 2443 write = (ap->a_access_type & VM_PROT_WRITE) != 0; 2444 2445 /* ccg xnaht - gets Wuninitialized wrong */ 2446 pcrun = NULL; 2447 runsizes = 0; 2448 2449 /* 2450 * Check that we aren't trying to fault in pages which our file 2451 * server doesn't know about. This happens if we extend a file by 2452 * skipping some pages and later try to fault in pages which 2453 * are between pn_serversize and vp_size. This check optimizes 2454 * away the common case where a file is being extended. 2455 */ 2456 if (ap->a_offset >= pn->pn_serversize && ap->a_offset < vp->v_size) { 2457 struct vattr va; 2458 2459 /* try again later when we can block */ 2460 if (locked) 2461 ERROUT(EBUSY); 2462 2463 mutex_exit(&vp->v_interlock); 2464 vattr_null(&va); 2465 va.va_size = vp->v_size; 2466 error = dosetattr(vp, &va, FSCRED, 0); 2467 if (error) 2468 ERROUT(error); 2469 mutex_enter(&vp->v_interlock); 2470 } 2471 2472 if (write && PUFFS_WCACHEINFO(pmp)) { 2473 #ifdef notnowjohn 2474 /* allocate worst-case memory */ 2475 runsizes = ((npages / 2) + 1) * sizeof(struct puffs_cacherun); 2476 pcinfo = kmem_zalloc(sizeof(struct puffs_cacheinfo) + runsize, 2477 locked ? KM_NOSLEEP : KM_SLEEP); 2478 2479 /* 2480 * can't block if we're locked and can't mess up caching 2481 * information for fs server. so come back later, please 2482 */ 2483 if (pcinfo == NULL) 2484 ERROUT(ENOMEM); 2485 2486 parkmem = puffs_park_alloc(locked == 0); 2487 if (parkmem == NULL) 2488 ERROUT(ENOMEM); 2489 2490 pcrun = pcinfo->pcache_runs; 2491 #else 2492 (void)parkmem; 2493 #endif 2494 } 2495 2496 error = genfs_getpages(v); 2497 if (error) 2498 goto out; 2499 2500 if (PUFFS_WCACHEINFO(pmp) == 0) 2501 goto out; 2502 2503 /* 2504 * Let's see whose fault it was and inform the user server of 2505 * possibly read/written pages. Map pages from read faults 2506 * strictly read-only, since otherwise we might miss info on 2507 * when the page is actually write-faulted to. 2508 */ 2509 if (!locked) 2510 mutex_enter(&vp->v_uobj.vmobjlock); 2511 for (i = 0, si = 0, streakon = 0; i < npages; i++) { 2512 if (pgs[i] == NULL || pgs[i] == PGO_DONTCARE) { 2513 if (streakon && write) { 2514 streakon = 0; 2515 pcrun[si].pcache_runend 2516 = trunc_page(pgs[i]->offset) + PAGE_MASK; 2517 si++; 2518 } 2519 continue; 2520 } 2521 if (streakon == 0 && write) { 2522 streakon = 1; 2523 pcrun[si].pcache_runstart = pgs[i]->offset; 2524 } 2525 2526 if (!write) 2527 pgs[i]->flags |= PG_RDONLY; 2528 } 2529 /* was the last page part of our streak? */ 2530 if (streakon) { 2531 pcrun[si].pcache_runend 2532 = trunc_page(pgs[i-1]->offset) + PAGE_MASK; 2533 si++; 2534 } 2535 if (!locked) 2536 mutex_exit(&vp->v_uobj.vmobjlock); 2537 2538 KASSERT(si <= (npages / 2) + 1); 2539 2540 #ifdef notnowjohn 2541 /* send results to userspace */ 2542 if (write) 2543 puffs_cacheop(pmp, parkmem, pcinfo, 2544 sizeof(struct puffs_cacheinfo) + runsizes, VPTOPNC(vp)); 2545 #endif 2546 2547 out: 2548 if (error) { 2549 if (pcinfo != NULL) 2550 kmem_free(pcinfo, 2551 sizeof(struct puffs_cacheinfo) + runsizes); 2552 #ifdef notnowjohn 2553 if (parkmem != NULL) 2554 puffs_park_release(parkmem, 1); 2555 #endif 2556 } 2557 2558 return error; 2559 } 2560 2561 /* 2562 * spec & fifo. These call the miscfs spec and fifo vectors, but issue 2563 * FAF update information for the puffs node first. 2564 */ 2565 int 2566 puffs_vnop_spec_read(void *v) 2567 { 2568 struct vop_read_args /* { 2569 const struct vnodeop_desc *a_desc; 2570 struct vnode *a_vp; 2571 struct uio *a_uio; 2572 int a_ioflag; 2573 kauth_cred_t a_cred; 2574 } */ *ap = v; 2575 2576 puffs_updatenode(VPTOPP(ap->a_vp), PUFFS_UPDATEATIME, 0); 2577 return VOCALL(spec_vnodeop_p, VOFFSET(vop_read), v); 2578 } 2579 2580 int 2581 puffs_vnop_spec_write(void *v) 2582 { 2583 struct vop_write_args /* { 2584 const struct vnodeop_desc *a_desc; 2585 struct vnode *a_vp; 2586 struct uio *a_uio; 2587 int a_ioflag; 2588 kauth_cred_t a_cred; 2589 } */ *ap = v; 2590 2591 puffs_updatenode(VPTOPP(ap->a_vp), PUFFS_UPDATEMTIME, 0); 2592 return VOCALL(spec_vnodeop_p, VOFFSET(vop_write), v); 2593 } 2594 2595 int 2596 puffs_vnop_fifo_read(void *v) 2597 { 2598 struct vop_read_args /* { 2599 const struct vnodeop_desc *a_desc; 2600 struct vnode *a_vp; 2601 struct uio *a_uio; 2602 int a_ioflag; 2603 kauth_cred_t a_cred; 2604 } */ *ap = v; 2605 2606 puffs_updatenode(VPTOPP(ap->a_vp), PUFFS_UPDATEATIME, 0); 2607 return VOCALL(fifo_vnodeop_p, VOFFSET(vop_read), v); 2608 } 2609 2610 int 2611 puffs_vnop_fifo_write(void *v) 2612 { 2613 struct vop_write_args /* { 2614 const struct vnodeop_desc *a_desc; 2615 struct vnode *a_vp; 2616 struct uio *a_uio; 2617 int a_ioflag; 2618 kauth_cred_t a_cred; 2619 } */ *ap = v; 2620 2621 puffs_updatenode(VPTOPP(ap->a_vp), PUFFS_UPDATEMTIME, 0); 2622 return VOCALL(fifo_vnodeop_p, VOFFSET(vop_write), v); 2623 } 2624
Indexes created Tue Sep 30 20:09:53 GMT 2025