1 /* $NetBSD: puffs_node.c,v 1.19 2011/06/30 20:09:41 wiz Exp $ */
4 * Copyright (c) 2005, 2006, 2007 Antti Kantee. All Rights Reserved.
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.
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
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.
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
32 #include <sys/param.h>
33 #include <sys/fnv_hash.h>
34 #include <sys/malloc.h>
35 #include <sys/mount.h>
36 #include <sys/namei.h>
37 #include <sys/vnode.h>
39 #include <vfs/puffs/puffs_msgif.h>
40 #include <vfs/puffs/puffs_sys.h>
42 static __inline struct puffs_node_hashlist
43 *puffs_cookie2hashlist(struct puffs_mount *, puffs_cookie_t);
44 static struct puffs_node *puffs_cookie2pnode(struct puffs_mount *,
48 * Grab a vnode, intialize all the puffs-dependent stuff.
51 puffs_getvnode(struct mount *mp, puffs_cookie_t ck, enum vtype type,
52 voff_t vsize, struct vnode **vpp)
54 struct puffs_mount *pmp;
55 struct puffs_newcookie *pnc;
57 struct puffs_node *pnode;
58 struct puffs_node_hashlist *plist;
61 pmp = MPTOPUFFSMP(mp);
64 if (type <= VNON || type >= VBAD) {
65 puffs_senderr(pmp, PUFFS_ERR_MAKENODE, EINVAL,
69 if (type == VBLK || type == VCHR) {
70 puffs_senderr(pmp, PUFFS_ERR_MAKENODE, EINVAL,
71 "device nodes are not supported", ck);
74 if (vsize == VNOVAL) {
75 puffs_senderr(pmp, PUFFS_ERR_MAKENODE, EINVAL,
76 "VNOVAL is not a valid size", ck);
80 /* XXX Add VT_PUFFS */
81 error = getnewvnode(VT_SYNTH, mp, &vp, 0, 0);
88 * Creation should not fail after this point. Or if it does,
89 * care must be taken so that VOP_INACTIVE() isn't called.
92 /* dances based on vnode type. almost ufs_vinit(), but not quite */
95 vp->v_ops = &mp->mnt_vn_fifo_ops;
99 if (PUFFS_USE_PAGECACHE(pmp))
100 vinitvmio(vp, vsize, mp->mnt_stat.f_iosize, -1);
108 panic("puffs_getvnode: invalid vtype %d", type);
111 pnode = kmalloc(sizeof(struct puffs_node), M_PUFFS, M_ZERO | M_WAITOK);
113 pnode->pn_cookie = ck;
114 pnode->pn_refcount = 1;
116 /* insert cookie on list, take off of interlock list */
117 lockinit(&pnode->pn_mtx, "puffs pn_mtx", 0, 0);
119 selinit(&pnode->pn_sel);
122 plist = puffs_cookie2hashlist(pmp, ck);
123 lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
124 LIST_INSERT_HEAD(plist, pnode, pn_hashent);
125 if (ck != pmp->pmp_root_cookie) {
126 LIST_FOREACH(pnc, &pmp->pmp_newcookie, pnc_entries) {
127 if (pnc->pnc_cookie == ck) {
128 LIST_REMOVE(pnc, pnc_entries);
133 KKASSERT(pnc != NULL);
135 lockmgr(&pmp->pmp_lock, LK_RELEASE);
140 pnode->pn_serversize = vsize;
144 DPRINTF(("new vnode at %p, pnode %p, cookie %p\n", vp,
145 pnode, pnode->pn_cookie));
150 /* remove staging cookie from list */
151 if (ck != pmp->pmp_root_cookie) {
152 lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
153 LIST_FOREACH(pnc, &pmp->pmp_newcookie, pnc_entries) {
154 if (pnc->pnc_cookie == ck) {
155 LIST_REMOVE(pnc, pnc_entries);
160 KKASSERT(pnc != NULL);
161 lockmgr(&pmp->pmp_lock, LK_RELEASE);
167 /* new node creating for creative vop ops (create, symlink, mkdir, mknod) */
169 puffs_newnode(struct mount *mp, struct vnode *dvp, struct vnode **vpp,
170 puffs_cookie_t ck, enum vtype type)
172 struct puffs_mount *pmp = MPTOPUFFSMP(mp);
173 struct puffs_newcookie *pnc;
177 /* userspace probably has this as a NULL op */
184 * Check for previous node with the same designation.
185 * Explicitly check the root node cookie, since it might be
186 * reclaimed from the kernel when this check is made.
188 lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
189 if (ck == pmp->pmp_root_cookie
190 || puffs_cookie2pnode(pmp, ck) != NULL) {
191 lockmgr(&pmp->pmp_lock, LK_RELEASE);
192 puffs_senderr(pmp, PUFFS_ERR_MAKENODE, EEXIST,
193 "cookie exists", ck);
197 LIST_FOREACH(pnc, &pmp->pmp_newcookie, pnc_entries) {
198 if (pnc->pnc_cookie == ck) {
199 lockmgr(&pmp->pmp_lock, LK_RELEASE);
200 puffs_senderr(pmp, PUFFS_ERR_MAKENODE, EEXIST,
201 "newcookie exists", ck);
205 pnc = kmalloc(sizeof(struct puffs_newcookie), M_PUFFS, M_WAITOK);
206 pnc->pnc_cookie = ck;
207 LIST_INSERT_HEAD(&pmp->pmp_newcookie, pnc, pnc_entries);
208 lockmgr(&pmp->pmp_lock, LK_RELEASE);
210 error = puffs_getvnode(dvp->v_mount, ck, type, 0, &vp);
219 puffs_putvnode(struct vnode *vp)
221 struct puffs_mount *pmp;
222 struct puffs_node *pnode;
224 pmp = VPTOPUFFSMP(vp);
228 if (vp->v_tag != VT_SYNTH)
229 panic("puffs_putvnode: %p not a puffs vnode", vp);
232 puffs_releasenode(pnode);
238 static __inline struct puffs_node_hashlist *
239 puffs_cookie2hashlist(struct puffs_mount *pmp, puffs_cookie_t ck)
243 hash = fnv_32_buf(&ck, sizeof(void *), FNV1_32_INIT);
244 return &pmp->pmp_pnodehash[hash % pmp->pmp_npnodehash];
248 * Translate cookie to puffs_node. Caller must hold pmp_lock
249 * and it will be held upon return.
251 static struct puffs_node *
252 puffs_cookie2pnode(struct puffs_mount *pmp, puffs_cookie_t ck)
254 struct puffs_node_hashlist *plist;
255 struct puffs_node *pnode;
257 plist = puffs_cookie2hashlist(pmp, ck);
258 LIST_FOREACH(pnode, plist, pn_hashent) {
259 if (pnode->pn_cookie == ck)
267 * Make sure root vnode exists and reference it. Does NOT lock.
270 puffs_makeroot(struct puffs_mount *pmp)
276 * pmp_lock must be held if vref()'ing or vrele()'ing the
277 * root vnode. the latter is controlled by puffs_inactive().
279 * pmp_root is set here and cleared in puffs_reclaim().
284 if (vget(vp, LK_EXCLUSIVE) == 0)
289 * So, didn't have the magic root vnode available.
290 * No matter, grab another and stuff it with the cookie.
292 if ((rv = puffs_getvnode(pmp->pmp_mp, pmp->pmp_root_cookie,
293 pmp->pmp_root_vtype, pmp->pmp_root_vsize, &vp)))
297 * Someone magically managed to race us into puffs_getvnode?
298 * Put our previous new vnode back and retry.
300 lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
302 struct puffs_node *pnode = VPTOPP(vp);
304 LIST_REMOVE(pnode, pn_hashent);
305 lockmgr(&pmp->pmp_lock, LK_RELEASE);
311 vsetflags(vp, VROOT);
314 lockmgr(&pmp->pmp_lock, LK_RELEASE);
320 * Locate the in-kernel vnode based on the cookie received given
321 * from userspace. Returns a vnode, if found, NULL otherwise.
322 * The parameter "lock" control whether to lock the possible or
323 * not. Locking always might cause us to lock against ourselves
324 * in situations where we want the vnode but don't care for the
325 * vnode lock, e.g. file server issued putpages.
328 puffs_cookie2vnode(struct puffs_mount *pmp, puffs_cookie_t ck,
329 int willcreate, struct vnode **vpp)
331 struct puffs_node *pnode;
332 struct puffs_newcookie *pnc;
337 * Handle root in a special manner, since we want to make sure
338 * pmp_root is properly set.
340 if (ck == pmp->pmp_root_cookie) {
341 if ((rv = puffs_makeroot(pmp)))
343 *vpp = pmp->pmp_root;
347 lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
348 pnode = puffs_cookie2pnode(pmp, ck);
351 pnc = kmalloc(sizeof(struct puffs_newcookie),
353 pnc->pnc_cookie = ck;
354 LIST_INSERT_HEAD(&pmp->pmp_newcookie, pnc, pnc_entries);
356 lockmgr(&pmp->pmp_lock, LK_RELEASE);
357 return PUFFS_NOSUCHCOOKIE;
361 lockmgr(&pmp->pmp_lock, LK_RELEASE);
363 rv = vget(vp, LK_EXCLUSIVE);
373 puffs_updatenode(struct puffs_node *pn, int flags)
382 if (flags & PUFFS_UPDATEATIME) {
383 pn->pn_mc_atime = ts;
384 pn->pn_stat |= PNODE_METACACHE_ATIME;
386 if (flags & PUFFS_UPDATECTIME) {
387 pn->pn_mc_ctime = ts;
388 pn->pn_stat |= PNODE_METACACHE_CTIME;
390 if (flags & PUFFS_UPDATEMTIME) {
391 pn->pn_mc_mtime = ts;
392 pn->pn_stat |= PNODE_METACACHE_MTIME;
397 puffs_meta_setsize(struct vnode *vp, off_t nsize, int trivial)
399 struct puffs_node *pn = VPTOPP(vp);
400 struct puffs_mount *pmp = VPTOPUFFSMP(vp);
401 int biosize = vp->v_mount->mnt_stat.f_iosize;
405 osize = puffs_meta_getsize(vp);
406 pn->pn_mc_size = nsize;
407 if (pn->pn_serversize != nsize)
408 pn->pn_stat |= PNODE_METACACHE_SIZE;
410 pn->pn_stat &= ~PNODE_METACACHE_SIZE;
412 if (!PUFFS_USE_PAGECACHE(pmp))
416 error = nvtruncbuf(vp, nsize, biosize, -1);
418 error = nvextendbuf(vp, osize, nsize,
419 biosize, biosize, -1, -1,
427 * Add reference to node.
428 * mutex held on entry and return
431 puffs_referencenode(struct puffs_node *pn)
434 KKASSERT(lockstatus(&pn->pn_mtx, curthread) == LK_EXCLUSIVE);
439 * Release pnode structure which dealing with references to the
440 * puffs_node instead of the vnode. Can't use vref()/vrele() on
441 * the vnode there, since that causes the lovely VOP_INACTIVE(),
442 * which in turn causes the lovely deadlock when called by the one
443 * who is supposed to handle it.
446 puffs_releasenode(struct puffs_node *pn)
449 lockmgr(&pn->pn_mtx, LK_EXCLUSIVE);
450 if (--pn->pn_refcount == 0) {
451 lockmgr(&pn->pn_mtx, LK_RELEASE);
452 lockuninit(&pn->pn_mtx);
454 seldestroy(&pn->pn_sel);
458 lockmgr(&pn->pn_mtx, LK_RELEASE);