1 /* $NetBSD: puffs_node.c,v 1.36 2014/11/10 18:46:33 maxv 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.36 2014/11/10 18:46:33 maxv Exp $");
34
35 #include <sys/param.h>
36 #include <sys/hash.h>
37 #include <sys/kmem.h>
38 #include <sys/mount.h>
39 #include <sys/namei.h>
40 #include <sys/vnode.h>
41
42 #include <uvm/uvm.h>
43
44 #include <fs/puffs/puffs_msgif.h>
45 #include <fs/puffs/puffs_sys.h>
46
47 #include <miscfs/genfs/genfs_node.h>
48 #include <miscfs/specfs/specdev.h>
49
50 struct pool puffs_pnpool;
51 struct pool puffs_vapool;
52
53 /*
54 * Grab a vnode, intialize all the puffs-dependent stuff.
55 */
56 static int
puffs_getvnode1(struct mount * mp,puffs_cookie_t ck,enum vtype type,voff_t vsize,dev_t rdev,bool may_exist,struct vnode ** vpp)57 puffs_getvnode1(struct mount *mp, puffs_cookie_t ck, enum vtype type,
58 voff_t vsize, dev_t rdev, bool may_exist, struct vnode **vpp)
59 {
60 struct puffs_mount *pmp;
61 struct vnode *vp;
62 struct puffs_node *pnode;
63 int error;
64
65 pmp = MPTOPUFFSMP(mp);
66
67 if (type <= VNON || type >= VBAD) {
68 puffs_senderr(pmp, PUFFS_ERR_MAKENODE, EINVAL,
69 "bad node type", ck);
70 return EPROTO;
71 }
72 if (vsize == VSIZENOTSET) {
73 puffs_senderr(pmp, PUFFS_ERR_MAKENODE, EINVAL,
74 "VSIZENOTSET is not a valid size", ck);
75 return EPROTO;
76 }
77
78 for (;;) {
79 error = vcache_get(mp, &ck, sizeof(ck), &vp);
80 if (error)
81 return error;
82 mutex_enter(vp->v_interlock);
83 pnode = VPTOPP(vp);
84 if (pnode != NULL)
85 break;
86 mutex_exit(vp->v_interlock);
87 vrele(vp);
88 }
89 mutex_enter(&pnode->pn_mtx);
90 mutex_exit(vp->v_interlock);
91
92 /*
93 * Release and error out if caller wants a fresh vnode.
94 */
95 if (vp->v_type != VNON && ! may_exist) {
96 mutex_exit(&pnode->pn_mtx);
97 vrele(vp);
98 return EEXIST;
99 }
100
101 *vpp = vp;
102
103 /*
104 * If fully initialized were done.
105 */
106 if (vp->v_type != VNON) {
107 mutex_exit(&pnode->pn_mtx);
108 return 0;
109 }
110
111 /*
112 * Set type and finalize the initialisation.
113 */
114 vp->v_type = type;
115 if (type == VCHR || type == VBLK) {
116 vp->v_op = puffs_specop_p;
117 spec_node_init(vp, rdev);
118 } else if (type == VFIFO) {
119 vp->v_op = puffs_fifoop_p;
120 } else if (vp->v_type == VREG) {
121 uvm_vnp_setsize(vp, vsize);
122 }
123
124 pnode->pn_serversize = vsize;
125
126 DPRINTF(("new vnode at %p, pnode %p, cookie %p\n", vp,
127 pnode, pnode->pn_cookie));
128
129 mutex_exit(&pnode->pn_mtx);
130
131 return 0;
132 }
133
134 int
puffs_getvnode(struct mount * mp,puffs_cookie_t ck,enum vtype type,voff_t vsize,dev_t rdev,struct vnode ** vpp)135 puffs_getvnode(struct mount *mp, puffs_cookie_t ck, enum vtype type,
136 voff_t vsize, dev_t rdev, struct vnode **vpp)
137 {
138
139 return puffs_getvnode1(mp, ck, type, vsize, rdev, true, vpp);
140 }
141
142 /* new node creating for creative vop ops (create, symlink, mkdir, mknod) */
143 int
puffs_newnode(struct mount * mp,struct vnode * dvp,struct vnode ** vpp,puffs_cookie_t ck,struct componentname * cnp,enum vtype type,dev_t rdev)144 puffs_newnode(struct mount *mp, struct vnode *dvp, struct vnode **vpp,
145 puffs_cookie_t ck, struct componentname *cnp,
146 enum vtype type, dev_t rdev)
147 {
148 struct puffs_mount *pmp = MPTOPUFFSMP(mp);
149 int error;
150
151 /* userspace probably has this as a NULL op */
152 if (ck == NULL)
153 return EOPNOTSUPP;
154
155 /*
156 * Check for previous node with the same designation.
157 * Explicitly check the root node cookie, since it might be
158 * reclaimed from the kernel when this check is made.
159 */
160 if (ck == pmp->pmp_root_cookie) {
161 puffs_senderr(pmp, PUFFS_ERR_MAKENODE, EEXIST,
162 "cookie exists", ck);
163 return EPROTO;
164 }
165
166 KASSERT(curlwp != uvm.pagedaemon_lwp);
167
168 error = puffs_getvnode1(dvp->v_mount, ck, type, 0, rdev, false, vpp);
169 if (error) {
170 if (error == EEXIST) {
171 puffs_senderr(pmp, PUFFS_ERR_MAKENODE, EEXIST,
172 "cookie exists", ck);
173 error = EPROTO;
174 }
175 return error;
176 }
177
178 if (PUFFS_USE_NAMECACHE(pmp))
179 cache_enter(dvp, *vpp, cnp->cn_nameptr, cnp->cn_namelen,
180 cnp->cn_flags);
181
182 puffs_updatenode(VPTOPP(dvp), PUFFS_UPDATECTIME|PUFFS_UPDATEMTIME, 0);
183
184 return 0;
185 }
186
187 void
puffs_putvnode(struct vnode * vp)188 puffs_putvnode(struct vnode *vp)
189 {
190 struct puffs_node *pnode;
191
192 pnode = VPTOPP(vp);
193
194 KASSERT(vp->v_tag == VT_PUFFS);
195
196 vcache_remove(vp->v_mount, &pnode->pn_cookie, sizeof(pnode->pn_cookie));
197 genfs_node_destroy(vp);
198
199 /*
200 * To interlock with puffs_getvnode1().
201 */
202 mutex_enter(vp->v_interlock);
203 vp->v_data = NULL;
204 mutex_exit(vp->v_interlock);
205 puffs_releasenode(pnode);
206 }
207
208 /*
209 * Make sure root vnode exists and reference it. Does NOT lock.
210 */
211 static int
puffs_makeroot(struct puffs_mount * pmp)212 puffs_makeroot(struct puffs_mount *pmp)
213 {
214 struct vnode *vp;
215 int rv;
216
217 /*
218 * pmp_lock must be held if vref()'ing or vrele()'ing the
219 * root vnode. the latter is controlled by puffs_inactive().
220 *
221 * pmp_root is set here and cleared in puffs_reclaim().
222 */
223
224 rv = puffs_getvnode(pmp->pmp_mp, pmp->pmp_root_cookie,
225 pmp->pmp_root_vtype, pmp->pmp_root_vsize, pmp->pmp_root_rdev, &vp);
226 if (rv != 0)
227 return rv;
228
229 mutex_enter(&pmp->pmp_lock);
230 if (pmp->pmp_root == NULL)
231 pmp->pmp_root = vp;
232 mutex_exit(&pmp->pmp_lock);
233
234 return 0;
235 }
236
237 /*
238 * Locate the in-kernel vnode based on the cookie received given
239 * from userspace.
240 *
241 * returns 0 on success. otherwise returns an errno or PUFFS_NOSUCHCOOKIE.
242 *
243 * returns PUFFS_NOSUCHCOOKIE if no vnode for the cookie is found.
244 */
245 int
puffs_cookie2vnode(struct puffs_mount * pmp,puffs_cookie_t ck,struct vnode ** vpp)246 puffs_cookie2vnode(struct puffs_mount *pmp, puffs_cookie_t ck,
247 struct vnode **vpp)
248 {
249 int rv;
250
251 /*
252 * Handle root in a special manner, since we want to make sure
253 * pmp_root is properly set.
254 */
255 if (ck == pmp->pmp_root_cookie) {
256 if ((rv = puffs_makeroot(pmp)))
257 return rv;
258 *vpp = pmp->pmp_root;
259 return 0;
260 }
261
262 rv = vcache_get(PMPTOMP(pmp), &ck, sizeof(ck), vpp);
263 if (rv != 0)
264 return rv;
265 mutex_enter((*vpp)->v_interlock);
266 if ((*vpp)->v_type == VNON) {
267 mutex_exit((*vpp)->v_interlock);
268 /* XXX vrele() calls VOP_INACTIVE() with VNON node */
269 vrele(*vpp);
270 *vpp = NULL;
271 return PUFFS_NOSUCHCOOKIE;
272 }
273 mutex_exit((*vpp)->v_interlock);
274
275 return 0;
276 }
277
278 void
puffs_updatenode(struct puffs_node * pn,int flags,voff_t size)279 puffs_updatenode(struct puffs_node *pn, int flags, voff_t size)
280 {
281 struct timespec ts;
282
283 if (flags == 0)
284 return;
285
286 nanotime(&ts);
287
288 if (flags & PUFFS_UPDATEATIME) {
289 pn->pn_mc_atime = ts;
290 pn->pn_stat |= PNODE_METACACHE_ATIME;
291 }
292 if (flags & PUFFS_UPDATECTIME) {
293 pn->pn_mc_ctime = ts;
294 pn->pn_stat |= PNODE_METACACHE_CTIME;
295 }
296 if (flags & PUFFS_UPDATEMTIME) {
297 pn->pn_mc_mtime = ts;
298 pn->pn_stat |= PNODE_METACACHE_MTIME;
299 }
300 if (flags & PUFFS_UPDATESIZE) {
301 pn->pn_mc_size = size;
302 pn->pn_stat |= PNODE_METACACHE_SIZE;
303 }
304 }
305
306 /*
307 * Add reference to node.
308 * mutex held on entry and return
309 */
310 void
puffs_referencenode(struct puffs_node * pn)311 puffs_referencenode(struct puffs_node *pn)
312 {
313
314 KASSERT(mutex_owned(&pn->pn_mtx));
315 pn->pn_refcount++;
316 }
317
318 /*
319 * Release pnode structure which dealing with references to the
320 * puffs_node instead of the vnode. Can't use vref()/vrele() on
321 * the vnode there, since that causes the lovely VOP_INACTIVE(),
322 * which in turn causes the lovely deadlock when called by the one
323 * who is supposed to handle it.
324 */
325 void
puffs_releasenode(struct puffs_node * pn)326 puffs_releasenode(struct puffs_node *pn)
327 {
328
329 mutex_enter(&pn->pn_mtx);
330 if (--pn->pn_refcount == 0) {
331 mutex_exit(&pn->pn_mtx);
332 mutex_destroy(&pn->pn_mtx);
333 mutex_destroy(&pn->pn_sizemtx);
334 seldestroy(&pn->pn_sel);
335 if (pn->pn_va_cache != NULL)
336 pool_put(&puffs_vapool, pn->pn_va_cache);
337 pool_put(&puffs_pnpool, pn);
338 } else {
339 mutex_exit(&pn->pn_mtx);
340 }
341 }
342