1 /* $NetBSD: puffs_node.c,v 1.29 2013/03/06 11:40:22 yamt 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, the Ulla Tuominen Foundation 8 * and the Finnish Cultural Foundation. 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_node.c,v 1.29 2013/03/06 11:40:22 yamt Exp $"); 34 35 #include <sys/param.h> 36 #include <sys/hash.h> 37 #include <sys/kmem.h> 38 #include <sys/malloc.h> 39 #include <sys/mount.h> 40 #include <sys/namei.h> 41 #include <sys/vnode.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/genfs/genfs_node.h> 49 #include <miscfs/specfs/specdev.h> 50 51 static const struct genfs_ops puffs_genfsops = { 52 .gop_size = puffs_gop_size, 53 .gop_write = genfs_gop_write, 54 .gop_markupdate = puffs_gop_markupdate, 55 #if 0 56 .gop_alloc, should ask userspace 57 #endif 58 }; 59 60 static __inline struct puffs_node_hashlist 61 *puffs_cookie2hashlist(struct puffs_mount *, puffs_cookie_t); 62 static struct puffs_node *puffs_cookie2pnode(struct puffs_mount *, 63 puffs_cookie_t); 64 65 struct pool puffs_pnpool; 66 struct pool puffs_vapool; 67 68 /* 69 * Grab a vnode, intialize all the puffs-dependent stuff. 70 */ 71 int 72 puffs_getvnode(struct mount *mp, puffs_cookie_t ck, enum vtype type, 73 voff_t vsize, dev_t rdev, struct vnode **vpp) 74 { 75 struct puffs_mount *pmp; 76 struct puffs_newcookie *pnc; 77 struct vnode *vp; 78 struct puffs_node *pnode; 79 struct puffs_node_hashlist *plist; 80 int error; 81 82 pmp = MPTOPUFFSMP(mp); 83 84 error = EPROTO; 85 if (type <= VNON || type >= VBAD) { 86 puffs_senderr(pmp, PUFFS_ERR_MAKENODE, EINVAL, 87 "bad node type", ck); 88 goto bad; 89 } 90 if (vsize == VSIZENOTSET) { 91 puffs_senderr(pmp, PUFFS_ERR_MAKENODE, EINVAL, 92 "VSIZENOTSET is not a valid size", ck); 93 goto bad; 94 } 95 96 error = getnewvnode(VT_PUFFS, mp, puffs_vnodeop_p, NULL, &vp); 97 if (error) { 98 goto bad; 99 } 100 vp->v_type = type; 101 102 /* 103 * Creation should not fail after this point. Or if it does, 104 * care must be taken so that VOP_INACTIVE() isn't called. 105 */ 106 107 /* default size */ 108 uvm_vnp_setsize(vp, 0); 109 110 /* dances based on vnode type. almost ufs_vinit(), but not quite */ 111 switch (type) { 112 case VCHR: 113 case VBLK: 114 /* 115 * replace vnode operation vector with the specops vector. 116 * our user server has very little control over the node 117 * if it decides its a character or block special file 118 */ 119 vp->v_op = puffs_specop_p; 120 spec_node_init(vp, rdev); 121 break; 122 123 case VFIFO: 124 vp->v_op = puffs_fifoop_p; 125 break; 126 127 case VREG: 128 uvm_vnp_setsize(vp, vsize); 129 break; 130 131 case VDIR: 132 case VLNK: 133 case VSOCK: 134 break; 135 default: 136 panic("puffs_getvnode: invalid vtype %d", type); 137 } 138 139 pnode = pool_get(&puffs_pnpool, PR_WAITOK); 140 memset(pnode, 0, sizeof(struct puffs_node)); 141 142 pnode->pn_cookie = ck; 143 pnode->pn_refcount = 1; 144 145 /* insert cookie on list, take off of interlock list */ 146 mutex_init(&pnode->pn_mtx, MUTEX_DEFAULT, IPL_NONE); 147 selinit(&pnode->pn_sel); 148 plist = puffs_cookie2hashlist(pmp, ck); 149 mutex_enter(&pmp->pmp_lock); 150 LIST_INSERT_HEAD(plist, pnode, pn_hashent); 151 if (ck != pmp->pmp_root_cookie) { 152 LIST_FOREACH(pnc, &pmp->pmp_newcookie, pnc_entries) { 153 if (pnc->pnc_cookie == ck) { 154 LIST_REMOVE(pnc, pnc_entries); 155 kmem_free(pnc, sizeof(struct puffs_newcookie)); 156 break; 157 } 158 } 159 KASSERT(pnc != NULL); 160 } 161 mutex_init(&pnode->pn_sizemtx, MUTEX_DEFAULT, IPL_NONE); 162 mutex_exit(&pmp->pmp_lock); 163 164 vp->v_data = pnode; 165 vp->v_type = type; 166 pnode->pn_vp = vp; 167 pnode->pn_serversize = vsize; 168 169 genfs_node_init(vp, &puffs_genfsops); 170 *vpp = vp; 171 172 DPRINTF(("new vnode at %p, pnode %p, cookie %p\n", vp, 173 pnode, pnode->pn_cookie)); 174 175 return 0; 176 177 bad: 178 /* remove staging cookie from list */ 179 if (ck != pmp->pmp_root_cookie) { 180 mutex_enter(&pmp->pmp_lock); 181 LIST_FOREACH(pnc, &pmp->pmp_newcookie, pnc_entries) { 182 if (pnc->pnc_cookie == ck) { 183 LIST_REMOVE(pnc, pnc_entries); 184 kmem_free(pnc, sizeof(struct puffs_newcookie)); 185 break; 186 } 187 } 188 KASSERT(pnc != NULL); 189 mutex_exit(&pmp->pmp_lock); 190 } 191 192 return error; 193 } 194 195 /* new node creating for creative vop ops (create, symlink, mkdir, mknod) */ 196 int 197 puffs_newnode(struct mount *mp, struct vnode *dvp, struct vnode **vpp, 198 puffs_cookie_t ck, struct componentname *cnp, 199 enum vtype type, dev_t rdev) 200 { 201 struct puffs_mount *pmp = MPTOPUFFSMP(mp); 202 struct puffs_newcookie *pnc; 203 struct vnode *vp; 204 int error; 205 206 /* userspace probably has this as a NULL op */ 207 if (ck == NULL) { 208 error = EOPNOTSUPP; 209 return error; 210 } 211 212 /* 213 * Check for previous node with the same designation. 214 * Explicitly check the root node cookie, since it might be 215 * reclaimed from the kernel when this check is made. 216 */ 217 mutex_enter(&pmp->pmp_lock); 218 if (ck == pmp->pmp_root_cookie 219 || puffs_cookie2pnode(pmp, ck) != NULL) { 220 mutex_exit(&pmp->pmp_lock); 221 puffs_senderr(pmp, PUFFS_ERR_MAKENODE, EEXIST, 222 "cookie exists", ck); 223 return EPROTO; 224 } 225 226 LIST_FOREACH(pnc, &pmp->pmp_newcookie, pnc_entries) { 227 if (pnc->pnc_cookie == ck) { 228 mutex_exit(&pmp->pmp_lock); 229 puffs_senderr(pmp, PUFFS_ERR_MAKENODE, EEXIST, 230 "newcookie exists", ck); 231 return EPROTO; 232 } 233 } 234 235 KASSERT(curlwp != uvm.pagedaemon_lwp); 236 pnc = kmem_alloc(sizeof(struct puffs_newcookie), KM_SLEEP); 237 pnc->pnc_cookie = ck; 238 LIST_INSERT_HEAD(&pmp->pmp_newcookie, pnc, pnc_entries); 239 mutex_exit(&pmp->pmp_lock); 240 241 error = puffs_getvnode(dvp->v_mount, ck, type, 0, rdev, &vp); 242 if (error) 243 return error; 244 245 vp->v_type = type; 246 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 247 *vpp = vp; 248 249 if (PUFFS_USE_NAMECACHE(pmp)) 250 cache_enter(dvp, vp, cnp->cn_nameptr, cnp->cn_namelen, 251 cnp->cn_flags); 252 253 return 0; 254 } 255 256 void 257 puffs_putvnode(struct vnode *vp) 258 { 259 struct puffs_mount *pmp; 260 struct puffs_node *pnode; 261 262 pmp = VPTOPUFFSMP(vp); 263 pnode = VPTOPP(vp); 264 265 #ifdef DIAGNOSTIC 266 if (vp->v_tag != VT_PUFFS) 267 panic("puffs_putvnode: %p not a puffs vnode", vp); 268 #endif 269 270 genfs_node_destroy(vp); 271 puffs_releasenode(pnode); 272 vp->v_data = NULL; 273 274 return; 275 } 276 277 static __inline struct puffs_node_hashlist * 278 puffs_cookie2hashlist(struct puffs_mount *pmp, puffs_cookie_t ck) 279 { 280 uint32_t hash; 281 282 hash = hash32_buf(&ck, sizeof(ck), HASH32_BUF_INIT); 283 return &pmp->pmp_pnodehash[hash % pmp->pmp_npnodehash]; 284 } 285 286 /* 287 * Translate cookie to puffs_node. Caller must hold pmp_lock 288 * and it will be held upon return. 289 */ 290 static struct puffs_node * 291 puffs_cookie2pnode(struct puffs_mount *pmp, puffs_cookie_t ck) 292 { 293 struct puffs_node_hashlist *plist; 294 struct puffs_node *pnode; 295 296 plist = puffs_cookie2hashlist(pmp, ck); 297 LIST_FOREACH(pnode, plist, pn_hashent) { 298 if (pnode->pn_cookie == ck) 299 break; 300 } 301 302 return pnode; 303 } 304 305 /* 306 * Make sure root vnode exists and reference it. Does NOT lock. 307 */ 308 static int 309 puffs_makeroot(struct puffs_mount *pmp) 310 { 311 struct vnode *vp; 312 int rv; 313 314 /* 315 * pmp_lock must be held if vref()'ing or vrele()'ing the 316 * root vnode. the latter is controlled by puffs_inactive(). 317 * 318 * pmp_root is set here and cleared in puffs_reclaim(). 319 */ 320 retry: 321 mutex_enter(&pmp->pmp_lock); 322 vp = pmp->pmp_root; 323 if (vp) { 324 mutex_enter(vp->v_interlock); 325 mutex_exit(&pmp->pmp_lock); 326 switch (vget(vp, 0)) { 327 case ENOENT: 328 goto retry; 329 case 0: 330 return 0; 331 default: 332 break; 333 } 334 } else 335 mutex_exit(&pmp->pmp_lock); 336 337 /* 338 * So, didn't have the magic root vnode available. 339 * No matter, grab another and stuff it with the cookie. 340 */ 341 if ((rv = puffs_getvnode(pmp->pmp_mp, pmp->pmp_root_cookie, 342 pmp->pmp_root_vtype, pmp->pmp_root_vsize, pmp->pmp_root_rdev, &vp))) 343 return rv; 344 345 /* 346 * Someone magically managed to race us into puffs_getvnode? 347 * Put our previous new vnode back and retry. 348 */ 349 mutex_enter(&pmp->pmp_lock); 350 if (pmp->pmp_root) { 351 struct puffs_node *pnode = vp->v_data; 352 353 LIST_REMOVE(pnode, pn_hashent); 354 mutex_exit(&pmp->pmp_lock); 355 puffs_putvnode(vp); 356 goto retry; 357 } 358 359 /* store cache */ 360 vp->v_vflag |= VV_ROOT; 361 pmp->pmp_root = vp; 362 mutex_exit(&pmp->pmp_lock); 363 364 return 0; 365 } 366 367 /* 368 * Locate the in-kernel vnode based on the cookie received given 369 * from userspace. 370 * The parameter "lock" control whether to lock the possible or 371 * not. Locking always might cause us to lock against ourselves 372 * in situations where we want the vnode but don't care for the 373 * vnode lock, e.g. file server issued putpages. 374 * 375 * returns 0 on success. otherwise returns an errno or PUFFS_NOSUCHCOOKIE. 376 * 377 * returns PUFFS_NOSUCHCOOKIE if no vnode for the cookie is found. 378 * in that case, if willcreate=true, the pmp_newcookie list is populated with 379 * the given cookie. it's the caller's responsibility to consume the entry 380 * with calling puffs_getvnode. 381 */ 382 int 383 puffs_cookie2vnode(struct puffs_mount *pmp, puffs_cookie_t ck, int lock, 384 int willcreate, struct vnode **vpp) 385 { 386 struct puffs_node *pnode; 387 struct puffs_newcookie *pnc; 388 struct vnode *vp; 389 int vgetflags, rv; 390 391 /* 392 * Handle root in a special manner, since we want to make sure 393 * pmp_root is properly set. 394 */ 395 if (ck == pmp->pmp_root_cookie) { 396 if ((rv = puffs_makeroot(pmp))) 397 return rv; 398 if (lock) 399 vn_lock(pmp->pmp_root, LK_EXCLUSIVE | LK_RETRY); 400 401 *vpp = pmp->pmp_root; 402 return 0; 403 } 404 405 retry: 406 mutex_enter(&pmp->pmp_lock); 407 pnode = puffs_cookie2pnode(pmp, ck); 408 if (pnode == NULL) { 409 if (willcreate) { 410 pnc = kmem_alloc(sizeof(struct puffs_newcookie), 411 KM_SLEEP); 412 pnc->pnc_cookie = ck; 413 LIST_INSERT_HEAD(&pmp->pmp_newcookie, pnc, pnc_entries); 414 } 415 mutex_exit(&pmp->pmp_lock); 416 return PUFFS_NOSUCHCOOKIE; 417 } 418 vp = pnode->pn_vp; 419 mutex_enter(vp->v_interlock); 420 mutex_exit(&pmp->pmp_lock); 421 422 vgetflags = 0; 423 if (lock) 424 vgetflags |= LK_EXCLUSIVE; 425 switch (rv = vget(vp, vgetflags)) { 426 case ENOENT: 427 goto retry; 428 case 0: 429 break; 430 default: 431 return rv; 432 } 433 434 *vpp = vp; 435 return 0; 436 } 437 438 void 439 puffs_updatenode(struct puffs_node *pn, int flags, voff_t size) 440 { 441 struct timespec ts; 442 443 if (flags == 0) 444 return; 445 446 nanotime(&ts); 447 448 if (flags & PUFFS_UPDATEATIME) { 449 pn->pn_mc_atime = ts; 450 pn->pn_stat |= PNODE_METACACHE_ATIME; 451 } 452 if (flags & PUFFS_UPDATECTIME) { 453 pn->pn_mc_ctime = ts; 454 pn->pn_stat |= PNODE_METACACHE_CTIME; 455 } 456 if (flags & PUFFS_UPDATEMTIME) { 457 pn->pn_mc_mtime = ts; 458 pn->pn_stat |= PNODE_METACACHE_MTIME; 459 } 460 if (flags & PUFFS_UPDATESIZE) { 461 pn->pn_mc_size = size; 462 pn->pn_stat |= PNODE_METACACHE_SIZE; 463 } 464 } 465 466 /* 467 * Add reference to node. 468 * mutex held on entry and return 469 */ 470 void 471 puffs_referencenode(struct puffs_node *pn) 472 { 473 474 KASSERT(mutex_owned(&pn->pn_mtx)); 475 pn->pn_refcount++; 476 } 477 478 /* 479 * Release pnode structure which dealing with references to the 480 * puffs_node instead of the vnode. Can't use vref()/vrele() on 481 * the vnode there, since that causes the lovely VOP_INACTIVE(), 482 * which in turn causes the lovely deadlock when called by the one 483 * who is supposed to handle it. 484 */ 485 void 486 puffs_releasenode(struct puffs_node *pn) 487 { 488 489 mutex_enter(&pn->pn_mtx); 490 if (--pn->pn_refcount == 0) { 491 mutex_exit(&pn->pn_mtx); 492 mutex_destroy(&pn->pn_mtx); 493 mutex_destroy(&pn->pn_sizemtx); 494 seldestroy(&pn->pn_sel); 495 if (pn->pn_va_cache != NULL) 496 pool_put(&puffs_vapool, pn->pn_va_cache); 497 pool_put(&puffs_pnpool, pn); 498 } else { 499 mutex_exit(&pn->pn_mtx); 500 } 501 } 502