Deleted Added
sdiff udiff text old ( 168720 ) new ( 168764 )
full compact
pseudofs_vnops.c (168720) pseudofs_vnops.c (168764)
1/*-
2 * Copyright (c) 2001 Dag-Erling Co�dan Sm�rgrav
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright

--- 13 unchanged lines hidden (view full) ---

22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
1/*-
2 * Copyright (c) 2001 Dag-Erling Co�dan Sm�rgrav
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright

--- 13 unchanged lines hidden (view full) ---

22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
30__FBSDID("$FreeBSD: head/sys/fs/pseudofs/pseudofs_vnops.c 168720 2007-04-14 14:08:30Z des $");
30__FBSDID("$FreeBSD: head/sys/fs/pseudofs/pseudofs_vnops.c 168764 2007-04-15 17:10:01Z des $");
31
32#include "opt_pseudofs.h"
33
34#include <sys/param.h>
35#include <sys/kernel.h>
36#include <sys/systm.h>
37#include <sys/ctype.h>
38#include <sys/dirent.h>

--- 8 unchanged lines hidden (view full) ---

47#include <sys/sbuf.h>
48#include <sys/sx.h>
49#include <sys/sysctl.h>
50#include <sys/vnode.h>
51
52#include <fs/pseudofs/pseudofs.h>
53#include <fs/pseudofs/pseudofs_internal.h>
54
31
32#include "opt_pseudofs.h"
33
34#include <sys/param.h>
35#include <sys/kernel.h>
36#include <sys/systm.h>
37#include <sys/ctype.h>
38#include <sys/dirent.h>

--- 8 unchanged lines hidden (view full) ---

47#include <sys/sbuf.h>
48#include <sys/sx.h>
49#include <sys/sysctl.h>
50#include <sys/vnode.h>
51
52#include <fs/pseudofs/pseudofs.h>
53#include <fs/pseudofs/pseudofs_internal.h>
54
55#ifdef PSEUDOFS_TRACE
56static int pfs_trace;
57SYSCTL_INT(_vfs_pfs, OID_AUTO, trace, CTLFLAG_RW, &pfs_trace, 0,
58 "enable tracing of pseudofs vnode operations");
59
60#define PFS_TRACE(foo) \
61 do { \
62 if (pfs_trace) { \
63 printf("%s(): line %d: ", __func__, __LINE__); \
64 printf foo ; \
65 printf("\n"); \
66 } \
67 } while (0)
68#define PFS_RETURN(err) \
69 do { \
70 if (pfs_trace) { \
71 printf("%s(): line %d: returning %d\n", \
72 __func__, __LINE__, err); \
73 } \
74 return (err); \
75 } while (0)
76#else
77#define PFS_TRACE(foo) \
78 do { /* nothing */ } while (0)
79#define PFS_RETURN(err) \
80 return (err)
81#endif
82
83/*
55/*
84 *
56 * Returns the fileno, adjusted for target pid
85 */
86static uint32_t
57 */
58static uint32_t
87pfs_fileno(struct pfs_node *pn, pid_t pid)
59pn_fileno(struct pfs_node *pn, pid_t pid)
88{
60{
89 if (!pn->pn_fileno)
90 pfs_fileno_alloc(pn);
61
62 KASSERT(pn->pn_fileno > 0,
63 ("%s(): no fileno allocated", __func__));
91 if (pid != NO_PID)
92 return (pn->pn_fileno * NO_PID + pid);
93 return (pn->pn_fileno);
94}
95
96/*
64 if (pid != NO_PID)
65 return (pn->pn_fileno * NO_PID + pid);
66 return (pn->pn_fileno);
67}
68
69/*
97 * Returns non-zero if given file is visible to given process. If the 'p'
98 * parameter is non-NULL, then it will hold a pointer to the process the
99 * given file belongs to on return and the process will be locked.
70 * Returns non-zero if given file is visible to given thread.
100 */
101static int
71 */
72static int
73pfs_visible_proc(struct thread *td, struct pfs_node *pn, struct proc *proc)
74{
75 int visible;
76
77 if (proc == NULL)
78 return (0);
79
80 PROC_LOCK_ASSERT(proc, MA_OWNED);
81
82 visible = ((proc->p_flag & P_WEXIT) == 0);
83 if (visible)
84 visible = (p_cansee(td, proc) == 0);
85 if (visible && pn->pn_vis != NULL)
86 visible = pn_vis(td, proc, pn);
87 if (!visible)
88 return (0);
89 return (1);
90}
91
92static int
102pfs_visible(struct thread *td, struct pfs_node *pn, pid_t pid, struct proc **p)
103{
104 struct proc *proc;
105
106 PFS_TRACE(("%s (pid: %d, req: %d)",
107 pn->pn_name, pid, td->td_proc->p_pid));
108
93pfs_visible(struct thread *td, struct pfs_node *pn, pid_t pid, struct proc **p)
94{
95 struct proc *proc;
96
97 PFS_TRACE(("%s (pid: %d, req: %d)",
98 pn->pn_name, pid, td->td_proc->p_pid));
99
109 if (pn->pn_flags & PFS_DISABLED)
100 if (p)
101 *p = NULL;
102 if (pid == NO_PID)
103 PFS_RETURN (1);
104 if ((proc = pfind(pid)) == NULL)
110 PFS_RETURN (0);
105 PFS_RETURN (0);
111
112 if (pid != NO_PID) {
113 if ((proc = pfind(pid)) == NULL)
114 PFS_RETURN (0);
115 if (proc->p_flag & P_WEXIT) {
116 PROC_UNLOCK(proc);
117 PFS_RETURN (0);
118 }
119 if (p_cansee(td, proc) != 0 ||
120 (pn->pn_vis != NULL && !(pn->pn_vis)(td, proc, pn))) {
121 PROC_UNLOCK(proc);
122 PFS_RETURN (0);
123 }
124 if (p) {
125 /* We return with the process locked to avoid races. */
106 if (pfs_visible_proc(td, pn, proc)) {
107 if (p)
126 *p = proc;
108 *p = proc;
127 } else
109 else
128 PROC_UNLOCK(proc);
110 PROC_UNLOCK(proc);
129 } else
130 if (p)
131 *p = NULL;
132 PFS_RETURN (1);
111 PFS_RETURN (1);
112 }
113 PROC_UNLOCK(proc);
114 PFS_RETURN (0);
133}
134
135/*
136 * Verify permissions
137 */
138static int
139pfs_access(struct vop_access_args *va)
140{
141 struct vnode *vn = va->a_vp;
115}
116
117/*
118 * Verify permissions
119 */
120static int
121pfs_access(struct vop_access_args *va)
122{
123 struct vnode *vn = va->a_vp;
124 struct pfs_vdata *pvd = vn->v_data;
142 struct vattr vattr;
143 int error;
144
125 struct vattr vattr;
126 int error;
127
145 PFS_TRACE((((struct pfs_vdata *)vn->v_data)->pvd_pn->pn_name));
128 PFS_TRACE(("%s", pvd->pvd_pn->pn_name));
146
147 error = VOP_GETATTR(vn, &vattr, va->a_cred, va->a_td);
148 if (error)
149 PFS_RETURN (error);
150 error = vaccess(vn->v_type, vattr.va_mode, vattr.va_uid,
151 vattr.va_gid, va->a_mode, va->a_cred, NULL);
152 PFS_RETURN (error);
153}
154
155/*
156 * Close a file or directory
157 */
158static int
159pfs_close(struct vop_close_args *va)
160{
161 struct vnode *vn = va->a_vp;
129
130 error = VOP_GETATTR(vn, &vattr, va->a_cred, va->a_td);
131 if (error)
132 PFS_RETURN (error);
133 error = vaccess(vn->v_type, vattr.va_mode, vattr.va_uid,
134 vattr.va_gid, va->a_mode, va->a_cred, NULL);
135 PFS_RETURN (error);
136}
137
138/*
139 * Close a file or directory
140 */
141static int
142pfs_close(struct vop_close_args *va)
143{
144 struct vnode *vn = va->a_vp;
162 struct pfs_vdata *pvd = (struct pfs_vdata *)vn->v_data;
145 struct pfs_vdata *pvd = vn->v_data;
163 struct pfs_node *pn = pvd->pvd_pn;
164 struct proc *proc;
165 int error;
166
146 struct pfs_node *pn = pvd->pvd_pn;
147 struct proc *proc;
148 int error;
149
167 PFS_TRACE((pn->pn_name));
150 PFS_TRACE(("%s", pn->pn_name));
151 pfs_assert_not_owned(pn);
168
169 /*
170 * Do nothing unless this is the last close and the node has a
171 * last-close handler.
172 */
173 if (vrefcnt(vn) > 1 || pn->pn_close == NULL)
174 PFS_RETURN (0);
175
152
153 /*
154 * Do nothing unless this is the last close and the node has a
155 * last-close handler.
156 */
157 if (vrefcnt(vn) > 1 || pn->pn_close == NULL)
158 PFS_RETURN (0);
159
176 if (pvd->pvd_pid != NO_PID)
160 if (pvd->pvd_pid != NO_PID) {
177 proc = pfind(pvd->pvd_pid);
161 proc = pfind(pvd->pvd_pid);
178 else
162 } else {
179 proc = NULL;
163 proc = NULL;
164 }
180
165
181 error = (pn->pn_close)(va->a_td, proc, pn);
166 error = pn_close(va->a_td, proc, pn);
182
183 if (proc != NULL)
184 PROC_UNLOCK(proc);
185
186 PFS_RETURN (error);
187}
188
189/*
190 * Get file attributes
191 */
192static int
193pfs_getattr(struct vop_getattr_args *va)
194{
195 struct vnode *vn = va->a_vp;
167
168 if (proc != NULL)
169 PROC_UNLOCK(proc);
170
171 PFS_RETURN (error);
172}
173
174/*
175 * Get file attributes
176 */
177static int
178pfs_getattr(struct vop_getattr_args *va)
179{
180 struct vnode *vn = va->a_vp;
196 struct pfs_vdata *pvd = (struct pfs_vdata *)vn->v_data;
181 struct pfs_vdata *pvd = vn->v_data;
197 struct pfs_node *pn = pvd->pvd_pn;
198 struct vattr *vap = va->a_vap;
199 struct proc *proc;
200 int error = 0;
201
182 struct pfs_node *pn = pvd->pvd_pn;
183 struct vattr *vap = va->a_vap;
184 struct proc *proc;
185 int error = 0;
186
202 PFS_TRACE((pn->pn_name));
187 PFS_TRACE(("%s", pn->pn_name));
188 pfs_assert_not_owned(pn);
203
204 if (!pfs_visible(curthread, pn, pvd->pvd_pid, &proc))
205 PFS_RETURN (ENOENT);
206
207 VATTR_NULL(vap);
208 vap->va_type = vn->v_type;
189
190 if (!pfs_visible(curthread, pn, pvd->pvd_pid, &proc))
191 PFS_RETURN (ENOENT);
192
193 VATTR_NULL(vap);
194 vap->va_type = vn->v_type;
209 vap->va_fileid = pfs_fileno(pn, pvd->pvd_pid);
195 vap->va_fileid = pn_fileno(pn, pvd->pvd_pid);
210 vap->va_flags = 0;
211 vap->va_blocksize = PAGE_SIZE;
212 vap->va_bytes = vap->va_size = 0;
213 vap->va_fsid = vn->v_mount->mnt_stat.f_fsid.val[0];
214 vap->va_nlink = 1;
215 nanotime(&vap->va_ctime);
216 vap->va_atime = vap->va_mtime = vap->va_ctime;
217
218 switch (pn->pn_type) {
219 case pfstype_procdir:
220 case pfstype_root:
221 case pfstype_dir:
196 vap->va_flags = 0;
197 vap->va_blocksize = PAGE_SIZE;
198 vap->va_bytes = vap->va_size = 0;
199 vap->va_fsid = vn->v_mount->mnt_stat.f_fsid.val[0];
200 vap->va_nlink = 1;
201 nanotime(&vap->va_ctime);
202 vap->va_atime = vap->va_mtime = vap->va_ctime;
203
204 switch (pn->pn_type) {
205 case pfstype_procdir:
206 case pfstype_root:
207 case pfstype_dir:
208#if 0
209 pfs_lock(pn);
210 /* compute link count */
211 pfs_unlock(pn);
212#endif
222 vap->va_mode = 0555;
223 break;
224 case pfstype_file:
225 case pfstype_symlink:
226 vap->va_mode = 0444;
227 break;
228 default:
229 printf("shouldn't be here!\n");
230 vap->va_mode = 0;
231 break;
232 }
233
234 if (proc != NULL) {
235 vap->va_uid = proc->p_ucred->cr_ruid;
236 vap->va_gid = proc->p_ucred->cr_rgid;
237 if (pn->pn_attr != NULL)
213 vap->va_mode = 0555;
214 break;
215 case pfstype_file:
216 case pfstype_symlink:
217 vap->va_mode = 0444;
218 break;
219 default:
220 printf("shouldn't be here!\n");
221 vap->va_mode = 0;
222 break;
223 }
224
225 if (proc != NULL) {
226 vap->va_uid = proc->p_ucred->cr_ruid;
227 vap->va_gid = proc->p_ucred->cr_rgid;
228 if (pn->pn_attr != NULL)
238 error = (pn->pn_attr)(va->a_td, proc, pn, vap);
229 error = pn_attr(va->a_td, proc, pn, vap);
239 PROC_UNLOCK(proc);
240 } else {
241 vap->va_uid = 0;
242 vap->va_gid = 0;
243 }
244
245 PFS_RETURN (error);
246}
247
248/*
249 * Perform an ioctl
250 */
251static int
252pfs_ioctl(struct vop_ioctl_args *va)
253{
254 struct vnode *vn = va->a_vp;
230 PROC_UNLOCK(proc);
231 } else {
232 vap->va_uid = 0;
233 vap->va_gid = 0;
234 }
235
236 PFS_RETURN (error);
237}
238
239/*
240 * Perform an ioctl
241 */
242static int
243pfs_ioctl(struct vop_ioctl_args *va)
244{
245 struct vnode *vn = va->a_vp;
255 struct pfs_vdata *pvd = (struct pfs_vdata *)vn->v_data;
246 struct pfs_vdata *pvd = vn->v_data;
256 struct pfs_node *pn = pvd->pvd_pn;
257 struct proc *proc;
258 int error;
259
260 PFS_TRACE(("%s: %lx", pn->pn_name, va->a_command));
247 struct pfs_node *pn = pvd->pvd_pn;
248 struct proc *proc;
249 int error;
250
251 PFS_TRACE(("%s: %lx", pn->pn_name, va->a_command));
252 pfs_assert_not_owned(pn);
261
262 if (vn->v_type != VREG)
263 PFS_RETURN (EINVAL);
264
265 if (pn->pn_ioctl == NULL)
266 PFS_RETURN (ENOTTY);
267
268 /*
269 * This is necessary because process' privileges may
270 * have changed since the open() call.
271 */
272 if (!pfs_visible(curthread, pn, pvd->pvd_pid, &proc))
273 PFS_RETURN (EIO);
274
253
254 if (vn->v_type != VREG)
255 PFS_RETURN (EINVAL);
256
257 if (pn->pn_ioctl == NULL)
258 PFS_RETURN (ENOTTY);
259
260 /*
261 * This is necessary because process' privileges may
262 * have changed since the open() call.
263 */
264 if (!pfs_visible(curthread, pn, pvd->pvd_pid, &proc))
265 PFS_RETURN (EIO);
266
275 if (proc != NULL) {
276 _PHOLD(proc);
277 PROC_UNLOCK(proc);
278 }
267 error = pn_ioctl(curthread, proc, pn, va->a_command, va->a_data);
279
268
280 error = (pn->pn_ioctl)(curthread, proc, pn, va->a_command, va->a_data);
281
282 if (proc != NULL)
269 if (proc != NULL)
283 PRELE(proc);
270 PROC_UNLOCK(proc);
284
285 PFS_RETURN (error);
286}
287
288/*
289 * Perform getextattr
290 */
291static int
292pfs_getextattr(struct vop_getextattr_args *va)
293{
294 struct vnode *vn = va->a_vp;
271
272 PFS_RETURN (error);
273}
274
275/*
276 * Perform getextattr
277 */
278static int
279pfs_getextattr(struct vop_getextattr_args *va)
280{
281 struct vnode *vn = va->a_vp;
295 struct pfs_vdata *pvd = (struct pfs_vdata *)vn->v_data;
282 struct pfs_vdata *pvd = vn->v_data;
296 struct pfs_node *pn = pvd->pvd_pn;
297 struct proc *proc;
298 int error;
299
283 struct pfs_node *pn = pvd->pvd_pn;
284 struct proc *proc;
285 int error;
286
300 PFS_TRACE((pn->pn_name));
287 PFS_TRACE(("%s", pn->pn_name));
288 pfs_assert_not_owned(pn);
301
302 /*
303 * This is necessary because either process' privileges may
304 * have changed since the open() call.
305 */
306 if (!pfs_visible(curthread, pn, pvd->pvd_pid, &proc))
307 PFS_RETURN (EIO);
308
289
290 /*
291 * This is necessary because either process' privileges may
292 * have changed since the open() call.
293 */
294 if (!pfs_visible(curthread, pn, pvd->pvd_pid, &proc))
295 PFS_RETURN (EIO);
296
309 if (pn->pn_getextattr == NULL) {
310 if (proc != NULL)
311 PROC_UNLOCK(proc);
312 PFS_RETURN (EOPNOTSUPP);
313 }
297 if (pn->pn_getextattr == NULL)
298 error = EOPNOTSUPP;
299 else
300 error = pn_getextattr(curthread, proc, pn,
301 va->a_attrnamespace, va->a_name, va->a_uio,
302 va->a_size, va->a_cred);
314
303
315 if (proc != NULL) {
316 _PHOLD(proc);
304 if (proc != NULL)
317 PROC_UNLOCK(proc);
305 PROC_UNLOCK(proc);
318 }
319
306
320 error = (pn->pn_getextattr)(curthread, proc, pn, va->a_attrnamespace,
321 va->a_name, va->a_uio, va->a_size, va->a_cred);
322
323 if (proc != NULL)
324 PRELE(proc);
325
307 pfs_unlock(pn);
326 PFS_RETURN (error);
327}
328
329/*
330 * Look up a file or directory
331 */
332static int
333pfs_lookup(struct vop_cachedlookup_args *va)
334{
335 struct vnode *vn = va->a_dvp;
336 struct vnode **vpp = va->a_vpp;
337 struct componentname *cnp = va->a_cnp;
308 PFS_RETURN (error);
309}
310
311/*
312 * Look up a file or directory
313 */
314static int
315pfs_lookup(struct vop_cachedlookup_args *va)
316{
317 struct vnode *vn = va->a_dvp;
318 struct vnode **vpp = va->a_vpp;
319 struct componentname *cnp = va->a_cnp;
338 struct pfs_vdata *pvd = (struct pfs_vdata *)vn->v_data;
320 struct pfs_vdata *pvd = vn->v_data;
339 struct pfs_node *pd = pvd->pvd_pn;
340 struct pfs_node *pn, *pdn = NULL;
341 pid_t pid = pvd->pvd_pid;
342 char *pname;
321 struct pfs_node *pd = pvd->pvd_pn;
322 struct pfs_node *pn, *pdn = NULL;
323 pid_t pid = pvd->pvd_pid;
324 char *pname;
343 int error, i, namelen;
325 int error, i, namelen, visible;
344
345 PFS_TRACE(("%.*s", (int)cnp->cn_namelen, cnp->cn_nameptr));
326
327 PFS_TRACE(("%.*s", (int)cnp->cn_namelen, cnp->cn_nameptr));
328 pfs_assert_not_owned(pd);
346
347 if (vn->v_type != VDIR)
348 PFS_RETURN (ENOTDIR);
349
350 error = VOP_ACCESS(vn, VEXEC, cnp->cn_cred, cnp->cn_thread);
351 if (error)
352 PFS_RETURN (error);
353

--- 24 unchanged lines hidden (view full) ---

378 PFS_RETURN (0);
379 }
380
381 /* parent */
382 if (cnp->cn_flags & ISDOTDOT) {
383 if (pd->pn_type == pfstype_root)
384 PFS_RETURN (EIO);
385 VOP_UNLOCK(vn, 0, cnp->cn_thread);
329
330 if (vn->v_type != VDIR)
331 PFS_RETURN (ENOTDIR);
332
333 error = VOP_ACCESS(vn, VEXEC, cnp->cn_cred, cnp->cn_thread);
334 if (error)
335 PFS_RETURN (error);
336

--- 24 unchanged lines hidden (view full) ---

361 PFS_RETURN (0);
362 }
363
364 /* parent */
365 if (cnp->cn_flags & ISDOTDOT) {
366 if (pd->pn_type == pfstype_root)
367 PFS_RETURN (EIO);
368 VOP_UNLOCK(vn, 0, cnp->cn_thread);
386 KASSERT(pd->pn_parent, ("non-root directory has no parent"));
369 KASSERT(pd->pn_parent != NULL,
370 ("%s(): non-root directory has no parent", __func__));
387 /*
388 * This one is tricky. Descendents of procdir nodes
389 * inherit their parent's process affinity, but
390 * there's no easy reverse mapping. For simplicity,
391 * we assume that if this node is a procdir, its
392 * parent isn't (which is correct as long as
393 * descendents of procdir nodes are never procdir
394 * nodes themselves)
395 */
396 if (pd->pn_type == pfstype_procdir)
397 pid = NO_PID;
371 /*
372 * This one is tricky. Descendents of procdir nodes
373 * inherit their parent's process affinity, but
374 * there's no easy reverse mapping. For simplicity,
375 * we assume that if this node is a procdir, its
376 * parent isn't (which is correct as long as
377 * descendents of procdir nodes are never procdir
378 * nodes themselves)
379 */
380 if (pd->pn_type == pfstype_procdir)
381 pid = NO_PID;
382 pfs_lock(pd);
398 pn = pd->pn_parent;
383 pn = pd->pn_parent;
384 pfs_unlock(pd);
399 goto got_pnode;
400 }
401
385 goto got_pnode;
386 }
387
388 pfs_lock(pd);
389
402 /* named node */
403 for (pn = pd->pn_nodes; pn != NULL; pn = pn->pn_next)
404 if (pn->pn_type == pfstype_procdir)
405 pdn = pn;
406 else if (pn->pn_name[namelen] == '\0' &&
390 /* named node */
391 for (pn = pd->pn_nodes; pn != NULL; pn = pn->pn_next)
392 if (pn->pn_type == pfstype_procdir)
393 pdn = pn;
394 else if (pn->pn_name[namelen] == '\0' &&
407 bcmp(pname, pn->pn_name, namelen) == 0)
395 bcmp(pname, pn->pn_name, namelen) == 0) {
396 pfs_unlock(pd);
408 goto got_pnode;
397 goto got_pnode;
398 }
409
410 /* process dependent node */
411 if ((pn = pdn) != NULL) {
412 pid = 0;
413 for (pid = 0, i = 0; i < namelen && isdigit(pname[i]); ++i)
414 if ((pid = pid * 10 + pname[i] - '0') > PID_MAX)
415 break;
399
400 /* process dependent node */
401 if ((pn = pdn) != NULL) {
402 pid = 0;
403 for (pid = 0, i = 0; i < namelen && isdigit(pname[i]); ++i)
404 if ((pid = pid * 10 + pname[i] - '0') > PID_MAX)
405 break;
416 if (i == cnp->cn_namelen)
406 if (i == cnp->cn_namelen) {
407 pfs_unlock(pd);
417 goto got_pnode;
408 goto got_pnode;
409 }
418 }
419
410 }
411
412 pfs_unlock(pd);
413
420 PFS_RETURN (ENOENT);
414 PFS_RETURN (ENOENT);
415
421 got_pnode:
416 got_pnode:
422 if (pn != pd->pn_parent && !pn->pn_parent)
423 pn->pn_parent = pd;
424 if (!pfs_visible(curthread, pn, pvd->pvd_pid, NULL)) {
417 pfs_assert_not_owned(pd);
418 pfs_assert_not_owned(pn);
419 visible = pfs_visible(curthread, pn, pvd->pvd_pid, NULL);
420 if (!visible) {
425 error = ENOENT;
426 goto failed;
427 }
428
429 error = pfs_vncache_alloc(vn->v_mount, vpp, pn, pid);
430 if (error)
431 goto failed;
432

--- 10 unchanged lines hidden (view full) ---

443
444/*
445 * Open a file or directory.
446 */
447static int
448pfs_open(struct vop_open_args *va)
449{
450 struct vnode *vn = va->a_vp;
421 error = ENOENT;
422 goto failed;
423 }
424
425 error = pfs_vncache_alloc(vn->v_mount, vpp, pn, pid);
426 if (error)
427 goto failed;
428

--- 10 unchanged lines hidden (view full) ---

439
440/*
441 * Open a file or directory.
442 */
443static int
444pfs_open(struct vop_open_args *va)
445{
446 struct vnode *vn = va->a_vp;
451 struct pfs_vdata *pvd = (struct pfs_vdata *)vn->v_data;
447 struct pfs_vdata *pvd = vn->v_data;
452 struct pfs_node *pn = pvd->pvd_pn;
453 int mode = va->a_mode;
454
455 PFS_TRACE(("%s (mode 0x%x)", pn->pn_name, mode));
448 struct pfs_node *pn = pvd->pvd_pn;
449 int mode = va->a_mode;
450
451 PFS_TRACE(("%s (mode 0x%x)", pn->pn_name, mode));
452 pfs_assert_not_owned(pn);
456
453
457 /*
458 * check if the file is visible to the caller
459 *
460 * XXX Not sure if this is necessary, as the VFS system calls
461 * XXX pfs_lookup() and pfs_access() first, and pfs_lookup()
462 * XXX calls pfs_visible(). There's a race condition here, but
463 * XXX calling pfs_visible() from here doesn't really close it,
464 * XXX and the only consequence of that race is an EIO further
465 * XXX down the line.
466 */
467 if (!pfs_visible(va->a_td, pn, pvd->pvd_pid, NULL))
468 PFS_RETURN (ENOENT);
469
470 /* check if the requested mode is permitted */
471 if (((mode & FREAD) && !(mode & PFS_RD)) ||
472 ((mode & FWRITE) && !(mode & PFS_WR)))
473 PFS_RETURN (EPERM);
474
475 /* we don't support locking */
476 if ((mode & O_SHLOCK) || (mode & O_EXLOCK))
477 PFS_RETURN (EOPNOTSUPP);
478
479 PFS_RETURN (0);
480}
481
482/*
483 * Read from a file
484 */
485static int
486pfs_read(struct vop_read_args *va)
487{
488 struct vnode *vn = va->a_vp;
454 /* check if the requested mode is permitted */
455 if (((mode & FREAD) && !(mode & PFS_RD)) ||
456 ((mode & FWRITE) && !(mode & PFS_WR)))
457 PFS_RETURN (EPERM);
458
459 /* we don't support locking */
460 if ((mode & O_SHLOCK) || (mode & O_EXLOCK))
461 PFS_RETURN (EOPNOTSUPP);
462
463 PFS_RETURN (0);
464}
465
466/*
467 * Read from a file
468 */
469static int
470pfs_read(struct vop_read_args *va)
471{
472 struct vnode *vn = va->a_vp;
489 struct pfs_vdata *pvd = (struct pfs_vdata *)vn->v_data;
473 struct pfs_vdata *pvd = vn->v_data;
490 struct pfs_node *pn = pvd->pvd_pn;
491 struct uio *uio = va->a_uio;
492 struct proc *proc;
493 struct sbuf *sb = NULL;
494 int error;
495 unsigned int buflen, offset, resid;
496
474 struct pfs_node *pn = pvd->pvd_pn;
475 struct uio *uio = va->a_uio;
476 struct proc *proc;
477 struct sbuf *sb = NULL;
478 int error;
479 unsigned int buflen, offset, resid;
480
497 PFS_TRACE((pn->pn_name));
481 PFS_TRACE(("%s", pn->pn_name));
482 pfs_assert_not_owned(pn);
498
499 if (vn->v_type != VREG)
500 PFS_RETURN (EINVAL);
501
502 if (!(pn->pn_flags & PFS_RD))
503 PFS_RETURN (EBADF);
504
483
484 if (vn->v_type != VREG)
485 PFS_RETURN (EINVAL);
486
487 if (!(pn->pn_flags & PFS_RD))
488 PFS_RETURN (EBADF);
489
505 if (pn->pn_func == NULL)
490 if (pn->pn_fill == NULL)
506 PFS_RETURN (EIO);
507
508 /*
509 * This is necessary because either process' privileges may
510 * have changed since the open() call.
511 */
512 if (!pfs_visible(curthread, pn, pvd->pvd_pid, &proc))
513 PFS_RETURN (EIO);
491 PFS_RETURN (EIO);
492
493 /*
494 * This is necessary because either process' privileges may
495 * have changed since the open() call.
496 */
497 if (!pfs_visible(curthread, pn, pvd->pvd_pid, &proc))
498 PFS_RETURN (EIO);
514
515 if (proc != NULL) {
516 _PHOLD(proc);
517 PROC_UNLOCK(proc);
518 }
519
520 if (pn->pn_flags & PFS_RAWRD) {
499 if (proc != NULL) {
500 _PHOLD(proc);
501 PROC_UNLOCK(proc);
502 }
503
504 if (pn->pn_flags & PFS_RAWRD) {
521 error = (pn->pn_func)(curthread, proc, pn, NULL, uio);
505 PFS_TRACE(("%lu resid", (unsigned long)uio->uio_resid));
506 error = pn_fill(curthread, proc, pn, NULL, uio);
507 PFS_TRACE(("%lu resid", (unsigned long)uio->uio_resid));
522 if (proc != NULL)
523 PRELE(proc);
524 PFS_RETURN (error);
525 }
526
508 if (proc != NULL)
509 PRELE(proc);
510 PFS_RETURN (error);
511 }
512
527 /* Beaucoup sanity checks so we don't ask for bogus allocation. */
513 /* beaucoup sanity checks so we don't ask for bogus allocation */
528 if (uio->uio_offset < 0 || uio->uio_resid < 0 ||
529 (offset = uio->uio_offset) != uio->uio_offset ||
530 (resid = uio->uio_resid) != uio->uio_resid ||
531 (buflen = offset + resid + 1) < offset || buflen > INT_MAX) {
532 if (proc != NULL)
533 PRELE(proc);
534 PFS_RETURN (EINVAL);
535 }
536 if (buflen > MAXPHYS) {
537 if (proc != NULL)
538 PRELE(proc);
539 PFS_RETURN (EIO);
540 }
514 if (uio->uio_offset < 0 || uio->uio_resid < 0 ||
515 (offset = uio->uio_offset) != uio->uio_offset ||
516 (resid = uio->uio_resid) != uio->uio_resid ||
517 (buflen = offset + resid + 1) < offset || buflen > INT_MAX) {
518 if (proc != NULL)
519 PRELE(proc);
520 PFS_RETURN (EINVAL);
521 }
522 if (buflen > MAXPHYS) {
523 if (proc != NULL)
524 PRELE(proc);
525 PFS_RETURN (EIO);
526 }
527
541 sb = sbuf_new(sb, NULL, buflen, 0);
542 if (sb == NULL) {
543 if (proc != NULL)
544 PRELE(proc);
545 PFS_RETURN (EIO);
546 }
547
528 sb = sbuf_new(sb, NULL, buflen, 0);
529 if (sb == NULL) {
530 if (proc != NULL)
531 PRELE(proc);
532 PFS_RETURN (EIO);
533 }
534
548 error = (pn->pn_func)(curthread, proc, pn, sb, uio);
535 error = pn_fill(curthread, proc, pn, sb, uio);
549
550 if (proc != NULL)
551 PRELE(proc);
552
553 if (error) {
554 sbuf_delete(sb);
555 PFS_RETURN (error);
556 }
557
558 sbuf_finish(sb);
559 error = uiomove_frombuf(sbuf_data(sb), sbuf_len(sb), uio);
560 sbuf_delete(sb);
561 PFS_RETURN (error);
562}
563
564/*
565 * Iterate through directory entries
566 */
567static int
536
537 if (proc != NULL)
538 PRELE(proc);
539
540 if (error) {
541 sbuf_delete(sb);
542 PFS_RETURN (error);
543 }
544
545 sbuf_finish(sb);
546 error = uiomove_frombuf(sbuf_data(sb), sbuf_len(sb), uio);
547 sbuf_delete(sb);
548 PFS_RETURN (error);
549}
550
551/*
552 * Iterate through directory entries
553 */
554static int
568pfs_iterate(struct thread *td, pid_t pid, struct pfs_node *pd,
555pfs_iterate(struct thread *td, struct proc *proc, struct pfs_node *pd,
569 struct pfs_node **pn, struct proc **p)
570{
556 struct pfs_node **pn, struct proc **p)
557{
558 int visible;
559
571 sx_assert(&allproc_lock, SX_SLOCKED);
560 sx_assert(&allproc_lock, SX_SLOCKED);
561 pfs_assert_owned(pd);
572 again:
573 if (*pn == NULL) {
574 /* first node */
575 *pn = pd->pn_nodes;
576 } else if ((*pn)->pn_type != pfstype_procdir) {
577 /* next node */
578 *pn = (*pn)->pn_next;
579 }
580 if (*pn != NULL && (*pn)->pn_type == pfstype_procdir) {
581 /* next process */
582 if (*p == NULL)
583 *p = LIST_FIRST(&allproc);
584 else
585 *p = LIST_NEXT(*p, p_list);
586 /* out of processes: next node */
587 if (*p == NULL)
588 *pn = (*pn)->pn_next;
562 again:
563 if (*pn == NULL) {
564 /* first node */
565 *pn = pd->pn_nodes;
566 } else if ((*pn)->pn_type != pfstype_procdir) {
567 /* next node */
568 *pn = (*pn)->pn_next;
569 }
570 if (*pn != NULL && (*pn)->pn_type == pfstype_procdir) {
571 /* next process */
572 if (*p == NULL)
573 *p = LIST_FIRST(&allproc);
574 else
575 *p = LIST_NEXT(*p, p_list);
576 /* out of processes: next node */
577 if (*p == NULL)
578 *pn = (*pn)->pn_next;
579 else
580 PROC_LOCK(*p);
589 }
590
591 if ((*pn) == NULL)
592 return (-1);
593
581 }
582
583 if ((*pn) == NULL)
584 return (-1);
585
594 if (!pfs_visible(td, *pn, *p ? (*p)->p_pid : pid, NULL))
586 if (*p != NULL) {
587 visible = pfs_visible_proc(td, *pn, *p);
588 PROC_UNLOCK(*p);
589 } else if (proc != NULL) {
590 visible = pfs_visible_proc(td, *pn, proc);
591 } else {
592 visible = 1;
593 }
594 if (!visible)
595 goto again;
596
597 return (0);
598}
599
600/*
601 * Return directory entries.
602 */
603static int
604pfs_readdir(struct vop_readdir_args *va)
605{
606 struct vnode *vn = va->a_vp;
595 goto again;
596
597 return (0);
598}
599
600/*
601 * Return directory entries.
602 */
603static int
604pfs_readdir(struct vop_readdir_args *va)
605{
606 struct vnode *vn = va->a_vp;
607 struct pfs_vdata *pvd = (struct pfs_vdata *)vn->v_data;
607 struct pfs_vdata *pvd = vn->v_data;
608 struct pfs_node *pd = pvd->pvd_pn;
609 pid_t pid = pvd->pvd_pid;
608 struct pfs_node *pd = pvd->pvd_pn;
609 pid_t pid = pvd->pvd_pid;
610 struct proc *p, *proc;
610 struct pfs_node *pn;
611 struct dirent *entry;
612 struct uio *uio;
611 struct pfs_node *pn;
612 struct dirent *entry;
613 struct uio *uio;
613 struct proc *p;
614 off_t offset;
615 int error, i, resid;
616 char *buf, *ent;
617
618 KASSERT(pd->pn_info == vn->v_mount->mnt_data,
614 off_t offset;
615 int error, i, resid;
616 char *buf, *ent;
617
618 KASSERT(pd->pn_info == vn->v_mount->mnt_data,
619 ("directory's pn_info does not match mountpoint's mnt_data"));
620 PFS_TRACE((pd->pn_name));
619 ("%s(): pn_info does not match mountpoint", __func__));
620 PFS_TRACE(("%s pid %lu", pd->pn_name, (unsigned long)pid));
621 pfs_assert_not_owned(pd);
621
622 if (vn->v_type != VDIR)
623 PFS_RETURN (ENOTDIR);
624 uio = va->a_uio;
625
622
623 if (vn->v_type != VDIR)
624 PFS_RETURN (ENOTDIR);
625 uio = va->a_uio;
626
626 /* check if the directory is visible to the caller */
627 if (!pfs_visible(curthread, pd, pid, NULL))
628 PFS_RETURN (ENOENT);
629
630 /* only allow reading entire entries */
631 offset = uio->uio_offset;
632 resid = uio->uio_resid;
633 if (offset < 0 || offset % PFS_DELEN != 0 ||
634 (resid && resid < PFS_DELEN))
635 PFS_RETURN (EINVAL);
636 if (resid == 0)
637 PFS_RETURN (0);
638
627 /* only allow reading entire entries */
628 offset = uio->uio_offset;
629 resid = uio->uio_resid;
630 if (offset < 0 || offset % PFS_DELEN != 0 ||
631 (resid && resid < PFS_DELEN))
632 PFS_RETURN (EINVAL);
633 if (resid == 0)
634 PFS_RETURN (0);
635
639 /* skip unwanted entries */
636 /* can't do this while holding the proc lock... */
637 buf = malloc(resid, M_IOV, M_WAITOK | M_ZERO);
640 sx_slock(&allproc_lock);
638 sx_slock(&allproc_lock);
641 for (pn = NULL, p = NULL; offset > 0; offset -= PFS_DELEN)
642 if (pfs_iterate(curthread, pid, pd, &pn, &p) == -1) {
639 pfs_lock(pd);
640
641 /* check if the directory is visible to the caller */
642 if (!pfs_visible(curthread, pd, pid, &proc)) {
643 sx_sunlock(&allproc_lock);
644 pfs_unlock(pd);
645 free(buf, M_IOV);
646 PFS_RETURN (ENOENT);
647 }
648 KASSERT(pid == NO_PID || proc != NULL,
649 ("%s(): no process for pid %lu", __func__, (unsigned long)pid));
650
651 /* skip unwanted entries */
652 for (pn = NULL, p = NULL; offset > 0; offset -= PFS_DELEN) {
653 if (pfs_iterate(curthread, proc, pd, &pn, &p) == -1) {
643 /* nothing left... */
654 /* nothing left... */
655 if (proc != NULL)
656 PROC_UNLOCK(proc);
657 pfs_unlock(pd);
644 sx_sunlock(&allproc_lock);
658 sx_sunlock(&allproc_lock);
659 free(buf, M_IOV);
645 PFS_RETURN (0);
646 }
660 PFS_RETURN (0);
661 }
662 }
647
648 /* fill in entries */
663
664 /* fill in entries */
649 ent = buf = malloc(resid, M_IOV, M_WAITOK | M_ZERO);
650 while (pfs_iterate(curthread, pid, pd, &pn, &p) != -1 &&
665 ent = buf;
666 while (pfs_iterate(curthread, proc, pd, &pn, &p) != -1 &&
651 resid >= PFS_DELEN) {
652 entry = (struct dirent *)ent;
653 entry->d_reclen = PFS_DELEN;
667 resid >= PFS_DELEN) {
668 entry = (struct dirent *)ent;
669 entry->d_reclen = PFS_DELEN;
654 if (!pn->pn_parent)
655 pn->pn_parent = pd;
656 entry->d_fileno = pfs_fileno(pn, pid);
670 entry->d_fileno = pn_fileno(pn, pid);
657 /* PFS_DELEN was picked to fit PFS_NAMLEN */
658 for (i = 0; i < PFS_NAMELEN - 1 && pn->pn_name[i] != '\0'; ++i)
659 entry->d_name[i] = pn->pn_name[i];
660 entry->d_name[i] = 0;
661 entry->d_namlen = i;
662 switch (pn->pn_type) {
663 case pfstype_procdir:
664 KASSERT(p != NULL,

--- 11 unchanged lines hidden (view full) ---

676 entry->d_type = DT_REG;
677 break;
678 case pfstype_symlink:
679 entry->d_type = DT_LNK;
680 break;
681 default:
682 panic("%s has unexpected node type: %d", pn->pn_name, pn->pn_type);
683 }
671 /* PFS_DELEN was picked to fit PFS_NAMLEN */
672 for (i = 0; i < PFS_NAMELEN - 1 && pn->pn_name[i] != '\0'; ++i)
673 entry->d_name[i] = pn->pn_name[i];
674 entry->d_name[i] = 0;
675 entry->d_namlen = i;
676 switch (pn->pn_type) {
677 case pfstype_procdir:
678 KASSERT(p != NULL,

--- 11 unchanged lines hidden (view full) ---

690 entry->d_type = DT_REG;
691 break;
692 case pfstype_symlink:
693 entry->d_type = DT_LNK;
694 break;
695 default:
696 panic("%s has unexpected node type: %d", pn->pn_name, pn->pn_type);
697 }
684 PFS_TRACE((entry->d_name));
698 PFS_TRACE(("%s", entry->d_name));
685 offset += PFS_DELEN;
686 resid -= PFS_DELEN;
687 ent += PFS_DELEN;
688 }
699 offset += PFS_DELEN;
700 resid -= PFS_DELEN;
701 ent += PFS_DELEN;
702 }
703 if (proc != NULL)
704 PROC_UNLOCK(proc);
705 pfs_unlock(pd);
689 sx_sunlock(&allproc_lock);
706 sx_sunlock(&allproc_lock);
707 PFS_TRACE(("%zd bytes", ent - buf));
690 error = uiomove(buf, ent - buf, uio);
691 free(buf, M_IOV);
692 PFS_RETURN (error);
693}
694
695/*
696 * Read a symbolic link
697 */
698static int
699pfs_readlink(struct vop_readlink_args *va)
700{
701 struct vnode *vn = va->a_vp;
708 error = uiomove(buf, ent - buf, uio);
709 free(buf, M_IOV);
710 PFS_RETURN (error);
711}
712
713/*
714 * Read a symbolic link
715 */
716static int
717pfs_readlink(struct vop_readlink_args *va)
718{
719 struct vnode *vn = va->a_vp;
702 struct pfs_vdata *pvd = (struct pfs_vdata *)vn->v_data;
720 struct pfs_vdata *pvd = vn->v_data;
703 struct pfs_node *pn = pvd->pvd_pn;
704 struct uio *uio = va->a_uio;
705 struct proc *proc = NULL;
721 struct pfs_node *pn = pvd->pvd_pn;
722 struct uio *uio = va->a_uio;
723 struct proc *proc = NULL;
706 char buf[MAXPATHLEN];
724 char buf[PATH_MAX];
707 struct sbuf sb;
708 int error;
709
725 struct sbuf sb;
726 int error;
727
710 PFS_TRACE((pn->pn_name));
728 PFS_TRACE(("%s", pn->pn_name));
729 pfs_assert_not_owned(pn);
711
712 if (vn->v_type != VLNK)
713 PFS_RETURN (EINVAL);
714
730
731 if (vn->v_type != VLNK)
732 PFS_RETURN (EINVAL);
733
715 if (pn->pn_func == NULL)
734 if (pn->pn_fill == NULL)
716 PFS_RETURN (EIO);
717
718 if (pvd->pvd_pid != NO_PID) {
719 if ((proc = pfind(pvd->pvd_pid)) == NULL)
720 PFS_RETURN (EIO);
721 if (proc->p_flag & P_WEXIT) {
722 PROC_UNLOCK(proc);
723 PFS_RETURN (EIO);
724 }
725 _PHOLD(proc);
726 PROC_UNLOCK(proc);
727 }
728
729 /* sbuf_new() can't fail with a static buffer */
730 sbuf_new(&sb, buf, sizeof buf, 0);
731
735 PFS_RETURN (EIO);
736
737 if (pvd->pvd_pid != NO_PID) {
738 if ((proc = pfind(pvd->pvd_pid)) == NULL)
739 PFS_RETURN (EIO);
740 if (proc->p_flag & P_WEXIT) {
741 PROC_UNLOCK(proc);
742 PFS_RETURN (EIO);
743 }
744 _PHOLD(proc);
745 PROC_UNLOCK(proc);
746 }
747
748 /* sbuf_new() can't fail with a static buffer */
749 sbuf_new(&sb, buf, sizeof buf, 0);
750
732 error = (pn->pn_func)(curthread, proc, pn, &sb, NULL);
751 error = pn_fill(curthread, proc, pn, &sb, NULL);
733
734 if (proc != NULL)
735 PRELE(proc);
736
737 if (error) {
738 sbuf_delete(&sb);
739 PFS_RETURN (error);
740 }

--- 5 unchanged lines hidden (view full) ---

746}
747
748/*
749 * Reclaim a vnode
750 */
751static int
752pfs_reclaim(struct vop_reclaim_args *va)
753{
752
753 if (proc != NULL)
754 PRELE(proc);
755
756 if (error) {
757 sbuf_delete(&sb);
758 PFS_RETURN (error);
759 }

--- 5 unchanged lines hidden (view full) ---

765}
766
767/*
768 * Reclaim a vnode
769 */
770static int
771pfs_reclaim(struct vop_reclaim_args *va)
772{
754 PFS_TRACE((((struct pfs_vdata *)va->a_vp->v_data)->pvd_pn->pn_name));
773 struct vnode *vn = va->a_vp;
774 struct pfs_vdata *pvd = vn->v_data;
775 struct pfs_node *pn = pvd->pvd_pn;
755
776
777 PFS_TRACE(("%s", pn->pn_name));
778 pfs_assert_not_owned(pn);
779
756 return (pfs_vncache_free(va->a_vp));
757}
758
759/*
760 * Set attributes
761 */
762static int
763pfs_setattr(struct vop_setattr_args *va)
764{
780 return (pfs_vncache_free(va->a_vp));
781}
782
783/*
784 * Set attributes
785 */
786static int
787pfs_setattr(struct vop_setattr_args *va)
788{
765 PFS_TRACE((((struct pfs_vdata *)va->a_vp->v_data)->pvd_pn->pn_name));
789 struct vnode *vn = va->a_vp;
790 struct pfs_vdata *pvd = vn->v_data;
791 struct pfs_node *pn = pvd->pvd_pn;
766
792
793 PFS_TRACE(("%s", pn->pn_name));
794 pfs_assert_not_owned(pn);
795
767 PFS_RETURN (EOPNOTSUPP);
768}
769
770/*
771 * Write to a file
772 */
773static int
774pfs_write(struct vop_write_args *va)
775{
776 struct vnode *vn = va->a_vp;
796 PFS_RETURN (EOPNOTSUPP);
797}
798
799/*
800 * Write to a file
801 */
802static int
803pfs_write(struct vop_write_args *va)
804{
805 struct vnode *vn = va->a_vp;
777 struct pfs_vdata *pvd = (struct pfs_vdata *)vn->v_data;
806 struct pfs_vdata *pvd = vn->v_data;
778 struct pfs_node *pn = pvd->pvd_pn;
779 struct uio *uio = va->a_uio;
780 struct proc *proc;
781 struct sbuf sb;
782 int error;
783
807 struct pfs_node *pn = pvd->pvd_pn;
808 struct uio *uio = va->a_uio;
809 struct proc *proc;
810 struct sbuf sb;
811 int error;
812
784 PFS_TRACE((pn->pn_name));
813 PFS_TRACE(("%s", pn->pn_name));
814 pfs_assert_not_owned(pn);
785
786 if (vn->v_type != VREG)
787 PFS_RETURN (EINVAL);
815
816 if (vn->v_type != VREG)
817 PFS_RETURN (EINVAL);
818 KASSERT(pn->pn_type != pfstype_file,
819 ("%s(): VREG vnode refers to non-file pfs_node", __func__));
788
789 if (!(pn->pn_flags & PFS_WR))
790 PFS_RETURN (EBADF);
791
820
821 if (!(pn->pn_flags & PFS_WR))
822 PFS_RETURN (EBADF);
823
792 if (pn->pn_func == NULL)
824 if (pn->pn_fill == NULL)
793 PFS_RETURN (EIO);
794
795 /*
796 * This is necessary because either process' privileges may
797 * have changed since the open() call.
798 */
799 if (!pfs_visible(curthread, pn, pvd->pvd_pid, &proc))
800 PFS_RETURN (EIO);
825 PFS_RETURN (EIO);
826
827 /*
828 * This is necessary because either process' privileges may
829 * have changed since the open() call.
830 */
831 if (!pfs_visible(curthread, pn, pvd->pvd_pid, &proc))
832 PFS_RETURN (EIO);
801
802 if (proc != NULL) {
803 _PHOLD(proc);
804 PROC_UNLOCK(proc);
805 }
806
807 if (pn->pn_flags & PFS_RAWWR) {
833 if (proc != NULL) {
834 _PHOLD(proc);
835 PROC_UNLOCK(proc);
836 }
837
838 if (pn->pn_flags & PFS_RAWWR) {
808 error = (pn->pn_func)(curthread, proc, pn, NULL, uio);
839 pfs_lock(pn);
840 error = pn_fill(curthread, proc, pn, NULL, uio);
841 pfs_unlock(pn);
809 if (proc != NULL)
810 PRELE(proc);
811 PFS_RETURN (error);
812 }
813
814 sbuf_uionew(&sb, uio, &error);
842 if (proc != NULL)
843 PRELE(proc);
844 PFS_RETURN (error);
845 }
846
847 sbuf_uionew(&sb, uio, &error);
815 if (error)
848 if (error) {
849 if (proc != NULL)
850 PRELE(proc);
816 PFS_RETURN (error);
851 PFS_RETURN (error);
852 }
817
853
818 error = (pn->pn_func)(curthread, proc, pn, &sb, uio);
854 error = pn_fill(curthread, proc, pn, &sb, uio);
819
855
856 sbuf_delete(&sb);
820 if (proc != NULL)
821 PRELE(proc);
857 if (proc != NULL)
858 PRELE(proc);
822
823 sbuf_delete(&sb);
824 PFS_RETURN (error);
825}
826
827/*
828 * Vnode operations
829 */
830struct vop_vector pfs_vnodeops = {
831 .vop_default = &default_vnodeops,

--- 25 unchanged lines hidden --- 		859 PFS_RETURN (error);
860}
861
862/*
863 * Vnode operations
864 */
865struct vop_vector pfs_vnodeops = {
866 .vop_default = &default_vnodeops,

--- 25 unchanged lines hidden ---