kern_descrip.c revision 1.130 1 1.130 christos /* $NetBSD: kern_descrip.c,v 1.130 2005/02/12 23:14:03 christos Exp $ */
2 1.22 cgd
3 1.16 cgd /*
4 1.17 cgd * Copyright (c) 1982, 1986, 1989, 1991, 1993
5 1.17 cgd * The Regents of the University of California. All rights reserved.
6 1.16 cgd * (c) UNIX System Laboratories, Inc.
7 1.16 cgd * All or some portions of this file are derived from material licensed
8 1.16 cgd * to the University of California by American Telephone and Telegraph
9 1.16 cgd * Co. or Unix System Laboratories, Inc. and are reproduced herein with
10 1.16 cgd * the permission of UNIX System Laboratories, Inc.
11 1.16 cgd *
12 1.16 cgd * Redistribution and use in source and binary forms, with or without
13 1.16 cgd * modification, are permitted provided that the following conditions
14 1.16 cgd * are met:
15 1.16 cgd * 1. Redistributions of source code must retain the above copyright
16 1.16 cgd * notice, this list of conditions and the following disclaimer.
17 1.16 cgd * 2. Redistributions in binary form must reproduce the above copyright
18 1.16 cgd * notice, this list of conditions and the following disclaimer in the
19 1.16 cgd * documentation and/or other materials provided with the distribution.
20 1.111 agc * 3. Neither the name of the University nor the names of its contributors
21 1.16 cgd * may be used to endorse or promote products derived from this software
22 1.16 cgd * without specific prior written permission.
23 1.16 cgd *
24 1.16 cgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 1.16 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 1.16 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 1.16 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 1.16 cgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 1.16 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 1.16 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 1.16 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 1.16 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 1.16 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 1.16 cgd * SUCH DAMAGE.
35 1.16 cgd *
36 1.51 fvdl * @(#)kern_descrip.c 8.8 (Berkeley) 2/14/95
37 1.16 cgd */
38 1.81 lukem
39 1.81 lukem #include <sys/cdefs.h>
40 1.130 christos __KERNEL_RCSID(0, "$NetBSD: kern_descrip.c,v 1.130 2005/02/12 23:14:03 christos Exp $");
41 1.50 mrg
42 1.16 cgd #include <sys/param.h>
43 1.16 cgd #include <sys/systm.h>
44 1.16 cgd #include <sys/filedesc.h>
45 1.16 cgd #include <sys/kernel.h>
46 1.16 cgd #include <sys/vnode.h>
47 1.16 cgd #include <sys/proc.h>
48 1.16 cgd #include <sys/file.h>
49 1.86 christos #include <sys/namei.h>
50 1.16 cgd #include <sys/socket.h>
51 1.16 cgd #include <sys/socketvar.h>
52 1.16 cgd #include <sys/stat.h>
53 1.16 cgd #include <sys/ioctl.h>
54 1.16 cgd #include <sys/fcntl.h>
55 1.16 cgd #include <sys/malloc.h>
56 1.55 thorpej #include <sys/pool.h>
57 1.16 cgd #include <sys/syslog.h>
58 1.17 cgd #include <sys/unistd.h>
59 1.16 cgd #include <sys/resourcevar.h>
60 1.42 christos #include <sys/conf.h>
61 1.96 jdolecek #include <sys/event.h>
62 1.16 cgd
63 1.25 cgd #include <sys/mount.h>
64 1.99 thorpej #include <sys/sa.h>
65 1.25 cgd #include <sys/syscallargs.h>
66 1.38 christos
67 1.16 cgd /*
68 1.16 cgd * Descriptor management.
69 1.16 cgd */
70 1.72 lukem struct filelist filehead; /* head of list of open files */
71 1.72 lukem int nfiles; /* actual number of open files */
72 1.125 simonb POOL_INIT(file_pool, sizeof(struct file), 0, 0, 0, "filepl",
73 1.125 simonb &pool_allocator_nointr);
74 1.125 simonb POOL_INIT(cwdi_pool, sizeof(struct cwdinfo), 0, 0, 0, "cwdipl",
75 1.125 simonb &pool_allocator_nointr);
76 1.125 simonb POOL_INIT(filedesc0_pool, sizeof(struct filedesc0), 0, 0, 0, "fdescpl",
77 1.125 simonb &pool_allocator_nointr);
78 1.101 thorpej
79 1.102 pk /* Global file list lock */
80 1.102 pk static struct simplelock filelist_slock = SIMPLELOCK_INITIALIZER;
81 1.102 pk
82 1.101 thorpej MALLOC_DEFINE(M_FILE, "file", "Open file structure");
83 1.101 thorpej MALLOC_DEFINE(M_FILEDESC, "file desc", "Open file descriptor table");
84 1.101 thorpej MALLOC_DEFINE(M_IOCTLOPS, "ioctlops", "ioctl data buffer");
85 1.72 lukem
86 1.72 lukem static __inline void fd_used(struct filedesc *, int);
87 1.72 lukem static __inline void fd_unused(struct filedesc *, int);
88 1.115 provos static __inline int find_next_zero(uint32_t *, int, u_int);
89 1.110 fvdl int finishdup(struct proc *, int, int, register_t *);
90 1.115 provos int find_last_set(struct filedesc *, int);
91 1.110 fvdl int fcntl_forfs(int, struct proc *, int, void *);
92 1.94 gehenna
93 1.94 gehenna dev_type_open(filedescopen);
94 1.94 gehenna
95 1.94 gehenna const struct cdevsw filedesc_cdevsw = {
96 1.94 gehenna filedescopen, noclose, noread, nowrite, noioctl,
97 1.96 jdolecek nostop, notty, nopoll, nommap, nokqfilter,
98 1.94 gehenna };
99 1.38 christos
100 1.115 provos static __inline int
101 1.115 provos find_next_zero(uint32_t *bitmap, int want, u_int bits)
102 1.115 provos {
103 1.115 provos int i, off, maxoff;
104 1.115 provos uint32_t sub;
105 1.115 provos
106 1.115 provos if (want > bits)
107 1.115 provos return -1;
108 1.115 provos
109 1.115 provos off = want >> NDENTRYSHIFT;
110 1.115 provos i = want & NDENTRYMASK;
111 1.115 provos if (i) {
112 1.115 provos sub = bitmap[off] | ((u_int)~0 >> (NDENTRIES - i));
113 1.115 provos if (sub != ~0)
114 1.115 provos goto found;
115 1.115 provos off++;
116 1.115 provos }
117 1.115 provos
118 1.115 provos maxoff = NDLOSLOTS(bits);
119 1.115 provos while (off < maxoff) {
120 1.115 provos if ((sub = bitmap[off]) != ~0)
121 1.115 provos goto found;
122 1.115 provos off++;
123 1.115 provos }
124 1.115 provos
125 1.115 provos return (-1);
126 1.115 provos
127 1.115 provos found:
128 1.115 provos return (off << NDENTRYSHIFT) + ffs(~sub) - 1;
129 1.115 provos }
130 1.115 provos
131 1.115 provos int
132 1.115 provos find_last_set(struct filedesc *fd, int last)
133 1.115 provos {
134 1.115 provos int off, i;
135 1.115 provos struct file **ofiles = fd->fd_ofiles;
136 1.115 provos uint32_t *bitmap = fd->fd_lomap;
137 1.115 provos
138 1.115 provos off = (last - 1) >> NDENTRYSHIFT;
139 1.115 provos
140 1.121 provos while (off >= 0 && !bitmap[off])
141 1.115 provos off--;
142 1.115 provos
143 1.115 provos if (off < 0)
144 1.128 cube return (-1);
145 1.115 provos
146 1.115 provos i = ((off + 1) << NDENTRYSHIFT) - 1;
147 1.115 provos if (i >= last)
148 1.115 provos i = last - 1;
149 1.115 provos
150 1.115 provos while (i > 0 && ofiles[i] == NULL)
151 1.115 provos i--;
152 1.115 provos
153 1.115 provos return (i);
154 1.115 provos }
155 1.115 provos
156 1.38 christos static __inline void
157 1.72 lukem fd_used(struct filedesc *fdp, int fd)
158 1.27 mycroft {
159 1.115 provos u_int off = fd >> NDENTRYSHIFT;
160 1.115 provos
161 1.126 pk LOCK_ASSERT(simple_lock_held(&fdp->fd_slock));
162 1.124 yamt KDASSERT((fdp->fd_lomap[off] & (1 << (fd & NDENTRYMASK))) == 0);
163 1.124 yamt
164 1.115 provos fdp->fd_lomap[off] |= 1 << (fd & NDENTRYMASK);
165 1.124 yamt if (fdp->fd_lomap[off] == ~0) {
166 1.124 yamt KDASSERT((fdp->fd_himap[off >> NDENTRYSHIFT] &
167 1.124 yamt (1 << (off & NDENTRYMASK))) == 0);
168 1.115 provos fdp->fd_himap[off >> NDENTRYSHIFT] |= 1 << (off & NDENTRYMASK);
169 1.124 yamt }
170 1.27 mycroft
171 1.27 mycroft if (fd > fdp->fd_lastfile)
172 1.27 mycroft fdp->fd_lastfile = fd;
173 1.27 mycroft }
174 1.27 mycroft
175 1.38 christos static __inline void
176 1.72 lukem fd_unused(struct filedesc *fdp, int fd)
177 1.27 mycroft {
178 1.115 provos u_int off = fd >> NDENTRYSHIFT;
179 1.27 mycroft
180 1.126 pk LOCK_ASSERT(simple_lock_held(&fdp->fd_slock));
181 1.27 mycroft if (fd < fdp->fd_freefile)
182 1.27 mycroft fdp->fd_freefile = fd;
183 1.115 provos
184 1.124 yamt if (fdp->fd_lomap[off] == ~0) {
185 1.124 yamt KDASSERT((fdp->fd_himap[off >> NDENTRYSHIFT] &
186 1.124 yamt (1 << (off & NDENTRYMASK))) != 0);
187 1.124 yamt fdp->fd_himap[off >> NDENTRYSHIFT] &=
188 1.124 yamt ~(1 << (off & NDENTRYMASK));
189 1.124 yamt }
190 1.124 yamt KDASSERT((fdp->fd_lomap[off] & (1 << (fd & NDENTRYMASK))) != 0);
191 1.115 provos fdp->fd_lomap[off] &= ~(1 << (fd & NDENTRYMASK));
192 1.115 provos
193 1.27 mycroft #ifdef DIAGNOSTIC
194 1.27 mycroft if (fd > fdp->fd_lastfile)
195 1.27 mycroft panic("fd_unused: fd_lastfile inconsistent");
196 1.27 mycroft #endif
197 1.115 provos if (fd == fdp->fd_lastfile)
198 1.115 provos fdp->fd_lastfile = find_last_set(fdp, fd);
199 1.27 mycroft }
200 1.27 mycroft
201 1.103 pk /*
202 1.103 pk * Lookup the file structure corresponding to a file descriptor
203 1.103 pk * and return it locked.
204 1.103 pk * Note: typical usage is: `fp = fd_getfile(..); FILE_USE(fp);'
205 1.103 pk * The locking strategy has been optimised for this case, i.e.
206 1.103 pk * fd_getfile() returns the file locked while FILE_USE() will increment
207 1.103 pk * the file's use count and unlock.
208 1.103 pk */
209 1.77 thorpej struct file *
210 1.77 thorpej fd_getfile(struct filedesc *fdp, int fd)
211 1.77 thorpej {
212 1.77 thorpej struct file *fp;
213 1.77 thorpej
214 1.77 thorpej if ((u_int) fd >= fdp->fd_nfiles || (fp = fdp->fd_ofiles[fd]) == NULL)
215 1.77 thorpej return (NULL);
216 1.77 thorpej
217 1.103 pk simple_lock(&fp->f_slock);
218 1.103 pk if (FILE_IS_USABLE(fp) == 0) {
219 1.103 pk simple_unlock(&fp->f_slock);
220 1.77 thorpej return (NULL);
221 1.103 pk }
222 1.77 thorpej
223 1.77 thorpej return (fp);
224 1.77 thorpej }
225 1.77 thorpej
226 1.16 cgd /*
227 1.16 cgd * System calls on descriptors.
228 1.16 cgd */
229 1.18 cgd
230 1.16 cgd /*
231 1.16 cgd * Duplicate a file descriptor.
232 1.16 cgd */
233 1.16 cgd /* ARGSUSED */
234 1.38 christos int
235 1.99 thorpej sys_dup(struct lwp *l, void *v, register_t *retval)
236 1.36 thorpej {
237 1.37 mycroft struct sys_dup_args /* {
238 1.72 lukem syscallarg(int) fd;
239 1.36 thorpej } */ *uap = v;
240 1.72 lukem struct file *fp;
241 1.72 lukem struct filedesc *fdp;
242 1.99 thorpej struct proc *p;
243 1.72 lukem int old, new, error;
244 1.72 lukem
245 1.99 thorpej p = l->l_proc;
246 1.72 lukem fdp = p->p_fd;
247 1.72 lukem old = SCARG(uap, fd);
248 1.16 cgd
249 1.75 thorpej restart:
250 1.77 thorpej if ((fp = fd_getfile(fdp, old)) == NULL)
251 1.16 cgd return (EBADF);
252 1.59 thorpej
253 1.59 thorpej FILE_USE(fp);
254 1.59 thorpej
255 1.59 thorpej if ((error = fdalloc(p, 0, &new)) != 0) {
256 1.76 thorpej if (error == ENOSPC) {
257 1.76 thorpej fdexpand(p);
258 1.110 fvdl FILE_UNUSE(fp, p);
259 1.76 thorpej goto restart;
260 1.76 thorpej }
261 1.110 fvdl FILE_UNUSE(fp, p);
262 1.16 cgd return (error);
263 1.59 thorpej }
264 1.59 thorpej
265 1.59 thorpej /* finishdup() will unuse the descriptors for us */
266 1.110 fvdl return (finishdup(p, old, new, retval));
267 1.16 cgd }
268 1.16 cgd
269 1.16 cgd /*
270 1.16 cgd * Duplicate a file descriptor to a particular value.
271 1.16 cgd */
272 1.16 cgd /* ARGSUSED */
273 1.38 christos int
274 1.99 thorpej sys_dup2(struct lwp *l, void *v, register_t *retval)
275 1.36 thorpej {
276 1.37 mycroft struct sys_dup2_args /* {
277 1.72 lukem syscallarg(int) from;
278 1.72 lukem syscallarg(int) to;
279 1.36 thorpej } */ *uap = v;
280 1.72 lukem struct file *fp;
281 1.72 lukem struct filedesc *fdp;
282 1.99 thorpej struct proc *p;
283 1.72 lukem int old, new, i, error;
284 1.72 lukem
285 1.99 thorpej p = l->l_proc;
286 1.72 lukem fdp = p->p_fd;
287 1.72 lukem old = SCARG(uap, from);
288 1.72 lukem new = SCARG(uap, to);
289 1.16 cgd
290 1.75 thorpej restart:
291 1.77 thorpej if ((fp = fd_getfile(fdp, old)) == NULL)
292 1.77 thorpej return (EBADF);
293 1.77 thorpej
294 1.77 thorpej if ((u_int)new >= p->p_rlimit[RLIMIT_NOFILE].rlim_cur ||
295 1.103 pk (u_int)new >= maxfiles) {
296 1.103 pk simple_unlock(&fp->f_slock);
297 1.16 cgd return (EBADF);
298 1.103 pk }
299 1.77 thorpej
300 1.17 cgd if (old == new) {
301 1.103 pk simple_unlock(&fp->f_slock);
302 1.17 cgd *retval = new;
303 1.16 cgd return (0);
304 1.17 cgd }
305 1.59 thorpej
306 1.59 thorpej FILE_USE(fp);
307 1.59 thorpej
308 1.16 cgd if (new >= fdp->fd_nfiles) {
309 1.59 thorpej if ((error = fdalloc(p, new, &i)) != 0) {
310 1.76 thorpej if (error == ENOSPC) {
311 1.76 thorpej fdexpand(p);
312 1.110 fvdl FILE_UNUSE(fp, p);
313 1.76 thorpej goto restart;
314 1.76 thorpej }
315 1.110 fvdl FILE_UNUSE(fp, p);
316 1.16 cgd return (error);
317 1.59 thorpej }
318 1.16 cgd if (new != i)
319 1.16 cgd panic("dup2: fdalloc");
320 1.126 pk } else {
321 1.126 pk simple_lock(&fdp->fd_slock);
322 1.117 yamt /*
323 1.117 yamt * Mark `new' slot "used" only if it was empty.
324 1.117 yamt */
325 1.126 pk if (fdp->fd_ofiles[new] == NULL)
326 1.126 pk fd_used(fdp, new);
327 1.126 pk simple_unlock(&fdp->fd_slock);
328 1.16 cgd }
329 1.59 thorpej
330 1.75 thorpej /*
331 1.75 thorpej * finishdup() will close the file that's in the `new'
332 1.75 thorpej * slot, if there's one there.
333 1.75 thorpej */
334 1.75 thorpej
335 1.59 thorpej /* finishdup() will unuse the descriptors for us */
336 1.110 fvdl return (finishdup(p, old, new, retval));
337 1.16 cgd }
338 1.16 cgd
339 1.16 cgd /*
340 1.16 cgd * The file control system call.
341 1.16 cgd */
342 1.16 cgd /* ARGSUSED */
343 1.38 christos int
344 1.99 thorpej sys_fcntl(struct lwp *l, void *v, register_t *retval)
345 1.36 thorpej {
346 1.66 augustss struct sys_fcntl_args /* {
347 1.72 lukem syscallarg(int) fd;
348 1.72 lukem syscallarg(int) cmd;
349 1.72 lukem syscallarg(void *) arg;
350 1.36 thorpej } */ *uap = v;
351 1.72 lukem struct filedesc *fdp;
352 1.72 lukem struct file *fp;
353 1.99 thorpej struct proc *p;
354 1.72 lukem struct vnode *vp;
355 1.72 lukem int fd, i, tmp, error, flg, cmd, newmin;
356 1.72 lukem struct flock fl;
357 1.72 lukem
358 1.99 thorpej p = l->l_proc;
359 1.72 lukem fd = SCARG(uap, fd);
360 1.122 christos cmd = SCARG(uap, cmd);
361 1.72 lukem fdp = p->p_fd;
362 1.72 lukem error = 0;
363 1.72 lukem flg = F_POSIX;
364 1.16 cgd
365 1.122 christos switch (cmd) {
366 1.122 christos case F_CLOSEM:
367 1.122 christos if (fd < 0)
368 1.122 christos return EBADF;
369 1.122 christos while (fdp->fd_lastfile >= fd)
370 1.122 christos fdrelease(p, fdp->fd_lastfile);
371 1.122 christos return 0;
372 1.122 christos
373 1.122 christos case F_MAXFD:
374 1.123 jdolecek *retval = fdp->fd_lastfile;
375 1.123 jdolecek return 0;
376 1.122 christos
377 1.122 christos default:
378 1.122 christos /* Handled below */
379 1.122 christos break;
380 1.122 christos }
381 1.122 christos
382 1.75 thorpej restart:
383 1.77 thorpej if ((fp = fd_getfile(fdp, fd)) == NULL)
384 1.16 cgd return (EBADF);
385 1.59 thorpej
386 1.59 thorpej FILE_USE(fp);
387 1.59 thorpej
388 1.61 wrstuden if ((cmd & F_FSCTL)) {
389 1.110 fvdl error = fcntl_forfs(fd, p, cmd, SCARG(uap, arg));
390 1.61 wrstuden goto out;
391 1.61 wrstuden }
392 1.61 wrstuden
393 1.61 wrstuden switch (cmd) {
394 1.17 cgd
395 1.16 cgd case F_DUPFD:
396 1.30 cgd newmin = (long)SCARG(uap, arg);
397 1.27 mycroft if ((u_int)newmin >= p->p_rlimit[RLIMIT_NOFILE].rlim_cur ||
398 1.59 thorpej (u_int)newmin >= maxfiles) {
399 1.59 thorpej error = EINVAL;
400 1.59 thorpej goto out;
401 1.59 thorpej }
402 1.75 thorpej if ((error = fdalloc(p, newmin, &i)) != 0) {
403 1.76 thorpej if (error == ENOSPC) {
404 1.76 thorpej fdexpand(p);
405 1.110 fvdl FILE_UNUSE(fp, p);
406 1.75 thorpej goto restart;
407 1.75 thorpej }
408 1.59 thorpej goto out;
409 1.75 thorpej }
410 1.59 thorpej
411 1.59 thorpej /* finishdup() will unuse the descriptors for us */
412 1.110 fvdl return (finishdup(p, fd, i, retval));
413 1.16 cgd
414 1.16 cgd case F_GETFD:
415 1.27 mycroft *retval = fdp->fd_ofileflags[fd] & UF_EXCLOSE ? 1 : 0;
416 1.59 thorpej break;
417 1.16 cgd
418 1.16 cgd case F_SETFD:
419 1.27 mycroft if ((long)SCARG(uap, arg) & 1)
420 1.27 mycroft fdp->fd_ofileflags[fd] |= UF_EXCLOSE;
421 1.27 mycroft else
422 1.27 mycroft fdp->fd_ofileflags[fd] &= ~UF_EXCLOSE;
423 1.59 thorpej break;
424 1.16 cgd
425 1.16 cgd case F_GETFL:
426 1.16 cgd *retval = OFLAGS(fp->f_flag);
427 1.59 thorpej break;
428 1.16 cgd
429 1.16 cgd case F_SETFL:
430 1.61 wrstuden tmp = FFLAGS((long)SCARG(uap, arg)) & FCNTLFLAGS;
431 1.110 fvdl error = (*fp->f_ops->fo_fcntl)(fp, F_SETFL, &tmp, p);
432 1.61 wrstuden if (error)
433 1.107 dsl break;
434 1.107 dsl i = tmp ^ fp->f_flag;
435 1.107 dsl if (i & FNONBLOCK) {
436 1.107 dsl int fl = tmp & FNONBLOCK;
437 1.110 fvdl error = (*fp->f_ops->fo_ioctl)(fp, FIONBIO, &fl, p);
438 1.107 dsl if (error)
439 1.107 dsl goto reset_fcntl;
440 1.107 dsl }
441 1.107 dsl if (i & FASYNC) {
442 1.107 dsl int fl = tmp & FASYNC;
443 1.110 fvdl error = (*fp->f_ops->fo_ioctl)(fp, FIOASYNC, &fl, p);
444 1.107 dsl if (error) {
445 1.107 dsl if (i & FNONBLOCK) {
446 1.107 dsl tmp = fp->f_flag & FNONBLOCK;
447 1.107 dsl (void)(*fp->f_ops->fo_ioctl)(fp,
448 1.110 fvdl FIONBIO, &tmp, p);
449 1.107 dsl }
450 1.107 dsl goto reset_fcntl;
451 1.107 dsl }
452 1.107 dsl }
453 1.107 dsl fp->f_flag = (fp->f_flag & ~FCNTLFLAGS) | tmp;
454 1.107 dsl break;
455 1.107 dsl reset_fcntl:
456 1.110 fvdl (void)(*fp->f_ops->fo_fcntl)(fp, F_SETFL, &fp->f_flag, p);
457 1.59 thorpej break;
458 1.16 cgd
459 1.16 cgd case F_GETOWN:
460 1.113 jdolecek error = (*fp->f_ops->fo_ioctl)(fp, FIOGETOWN, retval, p);
461 1.59 thorpej break;
462 1.16 cgd
463 1.16 cgd case F_SETOWN:
464 1.113 jdolecek tmp = (int)(intptr_t) SCARG(uap, arg);
465 1.113 jdolecek error = (*fp->f_ops->fo_ioctl)(fp, FIOSETOWN, &tmp, p);
466 1.59 thorpej break;
467 1.16 cgd
468 1.16 cgd case F_SETLKW:
469 1.16 cgd flg |= F_WAIT;
470 1.16 cgd /* Fall into F_SETLK */
471 1.16 cgd
472 1.16 cgd case F_SETLK:
473 1.59 thorpej if (fp->f_type != DTYPE_VNODE) {
474 1.59 thorpej error = EINVAL;
475 1.59 thorpej goto out;
476 1.59 thorpej }
477 1.16 cgd vp = (struct vnode *)fp->f_data;
478 1.16 cgd /* Copy in the lock structure */
479 1.106 dsl error = copyin(SCARG(uap, arg), &fl, sizeof(fl));
480 1.16 cgd if (error)
481 1.59 thorpej goto out;
482 1.16 cgd if (fl.l_whence == SEEK_CUR)
483 1.16 cgd fl.l_start += fp->f_offset;
484 1.16 cgd switch (fl.l_type) {
485 1.16 cgd case F_RDLCK:
486 1.59 thorpej if ((fp->f_flag & FREAD) == 0) {
487 1.59 thorpej error = EBADF;
488 1.59 thorpej goto out;
489 1.59 thorpej }
490 1.16 cgd p->p_flag |= P_ADVLOCK;
491 1.106 dsl error = VOP_ADVLOCK(vp, p, F_SETLK, &fl, flg);
492 1.59 thorpej goto out;
493 1.16 cgd
494 1.16 cgd case F_WRLCK:
495 1.59 thorpej if ((fp->f_flag & FWRITE) == 0) {
496 1.59 thorpej error = EBADF;
497 1.59 thorpej goto out;
498 1.59 thorpej }
499 1.16 cgd p->p_flag |= P_ADVLOCK;
500 1.106 dsl error = VOP_ADVLOCK(vp, p, F_SETLK, &fl, flg);
501 1.59 thorpej goto out;
502 1.16 cgd
503 1.16 cgd case F_UNLCK:
504 1.106 dsl error = VOP_ADVLOCK(vp, p, F_UNLCK, &fl, F_POSIX);
505 1.59 thorpej goto out;
506 1.16 cgd
507 1.16 cgd default:
508 1.59 thorpej error = EINVAL;
509 1.59 thorpej goto out;
510 1.16 cgd }
511 1.16 cgd
512 1.16 cgd case F_GETLK:
513 1.59 thorpej if (fp->f_type != DTYPE_VNODE) {
514 1.59 thorpej error = EINVAL;
515 1.59 thorpej goto out;
516 1.59 thorpej }
517 1.16 cgd vp = (struct vnode *)fp->f_data;
518 1.16 cgd /* Copy in the lock structure */
519 1.106 dsl error = copyin(SCARG(uap, arg), &fl, sizeof(fl));
520 1.16 cgd if (error)
521 1.59 thorpej goto out;
522 1.16 cgd if (fl.l_whence == SEEK_CUR)
523 1.16 cgd fl.l_start += fp->f_offset;
524 1.43 kleink if (fl.l_type != F_RDLCK &&
525 1.43 kleink fl.l_type != F_WRLCK &&
526 1.59 thorpej fl.l_type != F_UNLCK) {
527 1.59 thorpej error = EINVAL;
528 1.59 thorpej goto out;
529 1.59 thorpej }
530 1.106 dsl error = VOP_ADVLOCK(vp, p, F_GETLK, &fl, F_POSIX);
531 1.38 christos if (error)
532 1.59 thorpej goto out;
533 1.106 dsl error = copyout(&fl, SCARG(uap, arg), sizeof(fl));
534 1.59 thorpej break;
535 1.16 cgd
536 1.16 cgd default:
537 1.59 thorpej error = EINVAL;
538 1.16 cgd }
539 1.59 thorpej
540 1.59 thorpej out:
541 1.110 fvdl FILE_UNUSE(fp, p);
542 1.59 thorpej return (error);
543 1.16 cgd }
544 1.16 cgd
545 1.16 cgd /*
546 1.17 cgd * Common code for dup, dup2, and fcntl(F_DUPFD).
547 1.17 cgd */
548 1.17 cgd int
549 1.110 fvdl finishdup(struct proc *p, int old, int new, register_t *retval)
550 1.17 cgd {
551 1.72 lukem struct filedesc *fdp;
552 1.110 fvdl struct file *fp, *delfp;
553 1.72 lukem
554 1.72 lukem fdp = p->p_fd;
555 1.59 thorpej
556 1.59 thorpej /*
557 1.75 thorpej * If there is a file in the new slot, remember it so we
558 1.75 thorpej * can close it after we've finished the dup. We need
559 1.75 thorpej * to do it after the dup is finished, since closing
560 1.75 thorpej * the file may block.
561 1.75 thorpej *
562 1.59 thorpej * Note: `old' is already used for us.
563 1.117 yamt * Note: Caller already marked `new' slot "used".
564 1.59 thorpej */
565 1.126 pk simple_lock(&fdp->fd_slock);
566 1.75 thorpej delfp = fdp->fd_ofiles[new];
567 1.17 cgd
568 1.17 cgd fp = fdp->fd_ofiles[old];
569 1.124 yamt KDASSERT(fp != NULL);
570 1.17 cgd fdp->fd_ofiles[new] = fp;
571 1.17 cgd fdp->fd_ofileflags[new] = fdp->fd_ofileflags[old] &~ UF_EXCLOSE;
572 1.126 pk simple_unlock(&fdp->fd_slock);
573 1.126 pk
574 1.126 pk *retval = new;
575 1.126 pk simple_lock(&fp->f_slock);
576 1.17 cgd fp->f_count++;
577 1.126 pk FILE_UNUSE_HAVELOCK(fp, p);
578 1.75 thorpej
579 1.75 thorpej if (delfp != NULL) {
580 1.103 pk simple_lock(&delfp->f_slock);
581 1.75 thorpej FILE_USE(delfp);
582 1.96 jdolecek if (new < fdp->fd_knlistsize)
583 1.110 fvdl knote_fdclose(p, new);
584 1.110 fvdl (void) closef(delfp, p);
585 1.75 thorpej }
586 1.17 cgd return (0);
587 1.65 thorpej }
588 1.65 thorpej
589 1.65 thorpej void
590 1.72 lukem fdremove(struct filedesc *fdp, int fd)
591 1.65 thorpej {
592 1.65 thorpej
593 1.126 pk simple_lock(&fdp->fd_slock);
594 1.65 thorpej fdp->fd_ofiles[fd] = NULL;
595 1.65 thorpej fd_unused(fdp, fd);
596 1.126 pk simple_unlock(&fdp->fd_slock);
597 1.17 cgd }
598 1.17 cgd
599 1.27 mycroft int
600 1.110 fvdl fdrelease(struct proc *p, int fd)
601 1.72 lukem {
602 1.72 lukem struct filedesc *fdp;
603 1.110 fvdl struct file **fpp, *fp;
604 1.27 mycroft
605 1.72 lukem fdp = p->p_fd;
606 1.126 pk simple_lock(&fdp->fd_slock);
607 1.129 cube if (fd < 0 || fd > fdp->fd_lastfile)
608 1.126 pk goto badf;
609 1.27 mycroft fpp = &fdp->fd_ofiles[fd];
610 1.27 mycroft fp = *fpp;
611 1.27 mycroft if (fp == NULL)
612 1.126 pk goto badf;
613 1.59 thorpej
614 1.103 pk simple_lock(&fp->f_slock);
615 1.103 pk if (!FILE_IS_USABLE(fp)) {
616 1.103 pk simple_unlock(&fp->f_slock);
617 1.126 pk goto badf;
618 1.103 pk }
619 1.103 pk
620 1.59 thorpej FILE_USE(fp);
621 1.59 thorpej
622 1.27 mycroft *fpp = NULL;
623 1.75 thorpej fdp->fd_ofileflags[fd] = 0;
624 1.126 pk fd_unused(fdp, fd);
625 1.126 pk simple_unlock(&fdp->fd_slock);
626 1.96 jdolecek if (fd < fdp->fd_knlistsize)
627 1.110 fvdl knote_fdclose(p, fd);
628 1.110 fvdl return (closef(fp, p));
629 1.126 pk
630 1.126 pk badf:
631 1.126 pk simple_unlock(&fdp->fd_slock);
632 1.126 pk return (EBADF);
633 1.27 mycroft }
634 1.27 mycroft
635 1.17 cgd /*
636 1.16 cgd * Close a file descriptor.
637 1.16 cgd */
638 1.16 cgd /* ARGSUSED */
639 1.38 christos int
640 1.99 thorpej sys_close(struct lwp *l, void *v, register_t *retval)
641 1.36 thorpej {
642 1.37 mycroft struct sys_close_args /* {
643 1.72 lukem syscallarg(int) fd;
644 1.36 thorpej } */ *uap = v;
645 1.72 lukem int fd;
646 1.72 lukem struct filedesc *fdp;
647 1.99 thorpej struct proc *p;
648 1.16 cgd
649 1.99 thorpej p = l->l_proc;
650 1.72 lukem fd = SCARG(uap, fd);
651 1.72 lukem fdp = p->p_fd;
652 1.79 thorpej
653 1.103 pk #if 0
654 1.100 simonb if (fd_getfile(fdp, fd) == NULL)
655 1.16 cgd return (EBADF);
656 1.103 pk #endif
657 1.79 thorpej
658 1.110 fvdl return (fdrelease(p, fd));
659 1.16 cgd }
660 1.16 cgd
661 1.17 cgd /*
662 1.17 cgd * Return status information about a file descriptor.
663 1.17 cgd */
664 1.16 cgd /* ARGSUSED */
665 1.38 christos int
666 1.99 thorpej sys___fstat13(struct lwp *l, void *v, register_t *retval)
667 1.36 thorpej {
668 1.66 augustss struct sys___fstat13_args /* {
669 1.72 lukem syscallarg(int) fd;
670 1.72 lukem syscallarg(struct stat *) sb;
671 1.36 thorpej } */ *uap = v;
672 1.72 lukem int fd;
673 1.72 lukem struct filedesc *fdp;
674 1.72 lukem struct file *fp;
675 1.99 thorpej struct proc *p;
676 1.72 lukem struct stat ub;
677 1.72 lukem int error;
678 1.16 cgd
679 1.99 thorpej p = l->l_proc;
680 1.72 lukem fd = SCARG(uap, fd);
681 1.72 lukem fdp = p->p_fd;
682 1.77 thorpej
683 1.77 thorpej if ((fp = fd_getfile(fdp, fd)) == NULL)
684 1.16 cgd return (EBADF);
685 1.59 thorpej
686 1.59 thorpej FILE_USE(fp);
687 1.110 fvdl error = (*fp->f_ops->fo_stat)(fp, &ub, p);
688 1.110 fvdl FILE_UNUSE(fp, p);
689 1.59 thorpej
690 1.16 cgd if (error == 0)
691 1.52 perry error = copyout(&ub, SCARG(uap, sb), sizeof(ub));
692 1.73 jdolecek
693 1.16 cgd return (error);
694 1.16 cgd }
695 1.16 cgd
696 1.16 cgd /*
697 1.16 cgd * Return pathconf information about a file descriptor.
698 1.16 cgd */
699 1.16 cgd /* ARGSUSED */
700 1.38 christos int
701 1.99 thorpej sys_fpathconf(struct lwp *l, void *v, register_t *retval)
702 1.36 thorpej {
703 1.66 augustss struct sys_fpathconf_args /* {
704 1.72 lukem syscallarg(int) fd;
705 1.72 lukem syscallarg(int) name;
706 1.36 thorpej } */ *uap = v;
707 1.72 lukem int fd;
708 1.72 lukem struct filedesc *fdp;
709 1.72 lukem struct file *fp;
710 1.99 thorpej struct proc *p;
711 1.72 lukem struct vnode *vp;
712 1.72 lukem int error;
713 1.72 lukem
714 1.99 thorpej p = l->l_proc;
715 1.72 lukem fd = SCARG(uap, fd);
716 1.72 lukem fdp = p->p_fd;
717 1.72 lukem error = 0;
718 1.17 cgd
719 1.77 thorpej if ((fp = fd_getfile(fdp, fd)) == NULL)
720 1.17 cgd return (EBADF);
721 1.59 thorpej
722 1.59 thorpej FILE_USE(fp);
723 1.59 thorpej
724 1.17 cgd switch (fp->f_type) {
725 1.16 cgd
726 1.17 cgd case DTYPE_SOCKET:
727 1.78 jdolecek case DTYPE_PIPE:
728 1.25 cgd if (SCARG(uap, name) != _PC_PIPE_BUF)
729 1.59 thorpej error = EINVAL;
730 1.59 thorpej else
731 1.59 thorpej *retval = PIPE_BUF;
732 1.59 thorpej break;
733 1.17 cgd
734 1.17 cgd case DTYPE_VNODE:
735 1.17 cgd vp = (struct vnode *)fp->f_data;
736 1.59 thorpej error = VOP_PATHCONF(vp, SCARG(uap, name), retval);
737 1.59 thorpej break;
738 1.17 cgd
739 1.96 jdolecek case DTYPE_KQUEUE:
740 1.96 jdolecek error = EINVAL;
741 1.96 jdolecek break;
742 1.96 jdolecek
743 1.17 cgd default:
744 1.93 thorpej error = EOPNOTSUPP;
745 1.93 thorpej break;
746 1.17 cgd }
747 1.59 thorpej
748 1.110 fvdl FILE_UNUSE(fp, p);
749 1.59 thorpej return (error);
750 1.16 cgd }
751 1.16 cgd
752 1.16 cgd /*
753 1.16 cgd * Allocate a file descriptor for the process.
754 1.16 cgd */
755 1.76 thorpej int fdexpanded; /* XXX: what else uses this? */
756 1.16 cgd
757 1.38 christos int
758 1.72 lukem fdalloc(struct proc *p, int want, int *result)
759 1.72 lukem {
760 1.72 lukem struct filedesc *fdp;
761 1.126 pk int i, lim, last, error;
762 1.115 provos u_int off, new;
763 1.72 lukem
764 1.72 lukem fdp = p->p_fd;
765 1.126 pk simple_lock(&fdp->fd_slock);
766 1.16 cgd
767 1.16 cgd /*
768 1.16 cgd * Search for a free descriptor starting at the higher
769 1.16 cgd * of want or fd_freefile. If that fails, consider
770 1.16 cgd * expanding the ofile array.
771 1.16 cgd */
772 1.17 cgd lim = min((int)p->p_rlimit[RLIMIT_NOFILE].rlim_cur, maxfiles);
773 1.90 enami last = min(fdp->fd_nfiles, lim);
774 1.115 provos again:
775 1.90 enami if ((i = want) < fdp->fd_freefile)
776 1.90 enami i = fdp->fd_freefile;
777 1.115 provos off = i >> NDENTRYSHIFT;
778 1.115 provos new = find_next_zero(fdp->fd_himap, off,
779 1.115 provos (last + NDENTRIES - 1) >> NDENTRYSHIFT);
780 1.115 provos if (new != -1) {
781 1.115 provos i = find_next_zero(&fdp->fd_lomap[new],
782 1.115 provos new > off ? 0 : i & NDENTRYMASK, NDENTRIES);
783 1.115 provos if (i == -1) {
784 1.115 provos /*
785 1.115 provos * free file descriptor in this block was
786 1.115 provos * below want, try again with higher want.
787 1.115 provos */
788 1.115 provos want = (new + 1) << NDENTRYSHIFT;
789 1.115 provos goto again;
790 1.115 provos }
791 1.115 provos i += (new << NDENTRYSHIFT);
792 1.115 provos if (i < last) {
793 1.115 provos if (fdp->fd_ofiles[i] == NULL) {
794 1.115 provos fd_used(fdp, i);
795 1.115 provos if (want <= fdp->fd_freefile)
796 1.115 provos fdp->fd_freefile = i;
797 1.115 provos *result = i;
798 1.126 pk error = 0;
799 1.126 pk goto out;
800 1.115 provos }
801 1.16 cgd }
802 1.90 enami }
803 1.16 cgd
804 1.126 pk /* No space in current array. Expand or let the caller do it. */
805 1.126 pk error = (fdp->fd_nfiles >= lim) ? EMFILE : ENOSPC;
806 1.76 thorpej
807 1.126 pk out:
808 1.126 pk simple_unlock(&fdp->fd_slock);
809 1.126 pk return (error);
810 1.16 cgd }
811 1.16 cgd
812 1.76 thorpej void
813 1.76 thorpej fdexpand(struct proc *p)
814 1.76 thorpej {
815 1.76 thorpej struct filedesc *fdp;
816 1.126 pk int i, nfiles, oldnfiles;
817 1.76 thorpej struct file **newofile;
818 1.76 thorpej char *newofileflags;
819 1.126 pk uint32_t *newhimap = NULL, *newlomap = NULL;
820 1.76 thorpej
821 1.76 thorpej fdp = p->p_fd;
822 1.76 thorpej
823 1.126 pk restart:
824 1.126 pk oldnfiles = fdp->fd_nfiles;
825 1.126 pk
826 1.126 pk if (oldnfiles < NDEXTENT)
827 1.76 thorpej nfiles = NDEXTENT;
828 1.76 thorpej else
829 1.126 pk nfiles = 2 * oldnfiles;
830 1.126 pk
831 1.76 thorpej newofile = malloc(nfiles * OFILESIZE, M_FILEDESC, M_WAITOK);
832 1.126 pk if (NDHISLOTS(nfiles) > NDHISLOTS(oldnfiles)) {
833 1.126 pk newhimap = malloc(NDHISLOTS(nfiles) * sizeof(uint32_t),
834 1.126 pk M_FILEDESC, M_WAITOK);
835 1.126 pk newlomap = malloc(NDLOSLOTS(nfiles) * sizeof(uint32_t),
836 1.126 pk M_FILEDESC, M_WAITOK);
837 1.126 pk }
838 1.126 pk
839 1.126 pk simple_lock(&fdp->fd_slock);
840 1.126 pk /* lock fdp */
841 1.126 pk if (fdp->fd_nfiles != oldnfiles) {
842 1.126 pk /* fdp changed; retry */
843 1.126 pk simple_unlock(&fdp->fd_slock);
844 1.126 pk free(newofile, M_FILEDESC);
845 1.126 pk if (newhimap != NULL) free(newhimap, M_FILEDESC);
846 1.126 pk if (newlomap != NULL) free(newlomap, M_FILEDESC);
847 1.126 pk goto restart;
848 1.126 pk }
849 1.126 pk
850 1.76 thorpej newofileflags = (char *) &newofile[nfiles];
851 1.76 thorpej /*
852 1.76 thorpej * Copy the existing ofile and ofileflags arrays
853 1.76 thorpej * and zero the new portion of each array.
854 1.76 thorpej */
855 1.76 thorpej memcpy(newofile, fdp->fd_ofiles,
856 1.89 enami (i = sizeof(struct file *) * fdp->fd_nfiles));
857 1.76 thorpej memset((char *)newofile + i, 0,
858 1.76 thorpej nfiles * sizeof(struct file *) - i);
859 1.76 thorpej memcpy(newofileflags, fdp->fd_ofileflags,
860 1.76 thorpej (i = sizeof(char) * fdp->fd_nfiles));
861 1.76 thorpej memset(newofileflags + i, 0, nfiles * sizeof(char) - i);
862 1.126 pk if (oldnfiles > NDFILE)
863 1.76 thorpej free(fdp->fd_ofiles, M_FILEDESC);
864 1.115 provos
865 1.126 pk if (NDHISLOTS(nfiles) > NDHISLOTS(oldnfiles)) {
866 1.115 provos memcpy(newhimap, fdp->fd_himap,
867 1.126 pk (i = NDHISLOTS(oldnfiles) * sizeof(uint32_t)));
868 1.115 provos memset((char *)newhimap + i, 0,
869 1.115 provos NDHISLOTS(nfiles) * sizeof(uint32_t) - i);
870 1.115 provos
871 1.115 provos memcpy(newlomap, fdp->fd_lomap,
872 1.126 pk (i = NDLOSLOTS(oldnfiles) * sizeof(uint32_t)));
873 1.115 provos memset((char *)newlomap + i, 0,
874 1.115 provos NDLOSLOTS(nfiles) * sizeof(uint32_t) - i);
875 1.115 provos
876 1.126 pk if (NDHISLOTS(oldnfiles) > NDHISLOTS(NDFILE)) {
877 1.115 provos free(fdp->fd_himap, M_FILEDESC);
878 1.115 provos free(fdp->fd_lomap, M_FILEDESC);
879 1.115 provos }
880 1.115 provos fdp->fd_himap = newhimap;
881 1.115 provos fdp->fd_lomap = newlomap;
882 1.115 provos }
883 1.115 provos
884 1.76 thorpej fdp->fd_ofiles = newofile;
885 1.76 thorpej fdp->fd_ofileflags = newofileflags;
886 1.76 thorpej fdp->fd_nfiles = nfiles;
887 1.126 pk
888 1.126 pk simple_unlock(&fdp->fd_slock);
889 1.126 pk
890 1.76 thorpej fdexpanded++;
891 1.76 thorpej }
892 1.76 thorpej
893 1.16 cgd /*
894 1.16 cgd * Check to see whether n user file descriptors
895 1.16 cgd * are available to the process p.
896 1.16 cgd */
897 1.38 christos int
898 1.72 lukem fdavail(struct proc *p, int n)
899 1.72 lukem {
900 1.72 lukem struct filedesc *fdp;
901 1.72 lukem struct file **fpp;
902 1.72 lukem int i, lim;
903 1.16 cgd
904 1.72 lukem fdp = p->p_fd;
905 1.17 cgd lim = min((int)p->p_rlimit[RLIMIT_NOFILE].rlim_cur, maxfiles);
906 1.17 cgd if ((i = lim - fdp->fd_nfiles) > 0 && (n -= i) <= 0)
907 1.16 cgd return (1);
908 1.16 cgd fpp = &fdp->fd_ofiles[fdp->fd_freefile];
909 1.56 sommerfe for (i = min(lim,fdp->fd_nfiles) - fdp->fd_freefile; --i >= 0; fpp++)
910 1.16 cgd if (*fpp == NULL && --n <= 0)
911 1.16 cgd return (1);
912 1.16 cgd return (0);
913 1.16 cgd }
914 1.16 cgd
915 1.16 cgd /*
916 1.16 cgd * Create a new open file structure and allocate
917 1.98 wiz * a file descriptor for the process that refers to it.
918 1.16 cgd */
919 1.38 christos int
920 1.72 lukem falloc(struct proc *p, struct file **resultfp, int *resultfd)
921 1.16 cgd {
922 1.72 lukem struct file *fp, *fq;
923 1.72 lukem int error, i;
924 1.16 cgd
925 1.75 thorpej restart:
926 1.75 thorpej if ((error = fdalloc(p, 0, &i)) != 0) {
927 1.76 thorpej if (error == ENOSPC) {
928 1.76 thorpej fdexpand(p);
929 1.75 thorpej goto restart;
930 1.76 thorpej }
931 1.16 cgd return (error);
932 1.75 thorpej }
933 1.102 pk
934 1.102 pk fp = pool_get(&file_pool, PR_WAITOK);
935 1.102 pk simple_lock(&filelist_slock);
936 1.16 cgd if (nfiles >= maxfiles) {
937 1.69 jdolecek tablefull("file", "increase kern.maxfiles or MAXFILES");
938 1.102 pk simple_unlock(&filelist_slock);
939 1.115 provos fd_unused(p->p_fd, i);
940 1.102 pk pool_put(&file_pool, fp);
941 1.16 cgd return (ENFILE);
942 1.16 cgd }
943 1.16 cgd /*
944 1.16 cgd * Allocate a new file descriptor.
945 1.16 cgd * If the process has file descriptor zero open, add to the list
946 1.16 cgd * of open files at that point, otherwise put it at the front of
947 1.16 cgd * the list of open files.
948 1.16 cgd */
949 1.16 cgd nfiles++;
950 1.53 perry memset(fp, 0, sizeof(struct file));
951 1.83 jdolecek fp->f_iflags = FIF_LARVAL;
952 1.38 christos if ((fq = p->p_fd->fd_ofiles[0]) != NULL) {
953 1.24 mycroft LIST_INSERT_AFTER(fq, fp, f_list);
954 1.24 mycroft } else {
955 1.24 mycroft LIST_INSERT_HEAD(&filehead, fp, f_list);
956 1.24 mycroft }
957 1.102 pk simple_unlock(&filelist_slock);
958 1.124 yamt KDASSERT(p->p_fd->fd_ofiles[i] == NULL);
959 1.16 cgd p->p_fd->fd_ofiles[i] = fp;
960 1.103 pk simple_lock_init(&fp->f_slock);
961 1.16 cgd fp->f_count = 1;
962 1.16 cgd fp->f_cred = p->p_ucred;
963 1.16 cgd crhold(fp->f_cred);
964 1.59 thorpej if (resultfp) {
965 1.103 pk fp->f_usecount = 1;
966 1.16 cgd *resultfp = fp;
967 1.59 thorpej }
968 1.16 cgd if (resultfd)
969 1.16 cgd *resultfd = i;
970 1.16 cgd return (0);
971 1.16 cgd }
972 1.16 cgd
973 1.16 cgd /*
974 1.16 cgd * Free a file descriptor.
975 1.16 cgd */
976 1.38 christos void
977 1.72 lukem ffree(struct file *fp)
978 1.16 cgd {
979 1.59 thorpej
980 1.59 thorpej #ifdef DIAGNOSTIC
981 1.59 thorpej if (fp->f_usecount)
982 1.59 thorpej panic("ffree");
983 1.59 thorpej #endif
984 1.59 thorpej
985 1.102 pk simple_lock(&filelist_slock);
986 1.24 mycroft LIST_REMOVE(fp, f_list);
987 1.16 cgd crfree(fp->f_cred);
988 1.16 cgd #ifdef DIAGNOSTIC
989 1.103 pk fp->f_count = 0; /* What's the point? */
990 1.16 cgd #endif
991 1.16 cgd nfiles--;
992 1.102 pk simple_unlock(&filelist_slock);
993 1.55 thorpej pool_put(&file_pool, fp);
994 1.48 thorpej }
995 1.48 thorpej
996 1.48 thorpej /*
997 1.58 thorpej * Create an initial cwdinfo structure, using the same current and root
998 1.58 thorpej * directories as p.
999 1.58 thorpej */
1000 1.58 thorpej struct cwdinfo *
1001 1.72 lukem cwdinit(struct proc *p)
1002 1.58 thorpej {
1003 1.58 thorpej struct cwdinfo *cwdi;
1004 1.58 thorpej
1005 1.58 thorpej cwdi = pool_get(&cwdi_pool, PR_WAITOK);
1006 1.58 thorpej
1007 1.126 pk simple_lock_init(&cwdi->cwdi_slock);
1008 1.58 thorpej cwdi->cwdi_cdir = p->p_cwdi->cwdi_cdir;
1009 1.63 thorpej if (cwdi->cwdi_cdir)
1010 1.63 thorpej VREF(cwdi->cwdi_cdir);
1011 1.58 thorpej cwdi->cwdi_rdir = p->p_cwdi->cwdi_rdir;
1012 1.58 thorpej if (cwdi->cwdi_rdir)
1013 1.58 thorpej VREF(cwdi->cwdi_rdir);
1014 1.60 christos cwdi->cwdi_cmask = p->p_cwdi->cwdi_cmask;
1015 1.58 thorpej cwdi->cwdi_refcnt = 1;
1016 1.58 thorpej
1017 1.58 thorpej return (cwdi);
1018 1.58 thorpej }
1019 1.58 thorpej
1020 1.58 thorpej /*
1021 1.58 thorpej * Make p2 share p1's cwdinfo.
1022 1.58 thorpej */
1023 1.58 thorpej void
1024 1.72 lukem cwdshare(struct proc *p1, struct proc *p2)
1025 1.58 thorpej {
1026 1.126 pk struct cwdinfo *cwdi = p1->p_cwdi;
1027 1.58 thorpej
1028 1.126 pk simple_lock(&cwdi->cwdi_slock);
1029 1.126 pk cwdi->cwdi_refcnt++;
1030 1.126 pk simple_unlock(&cwdi->cwdi_slock);
1031 1.126 pk p2->p_cwdi = cwdi;
1032 1.58 thorpej }
1033 1.58 thorpej
1034 1.58 thorpej /*
1035 1.58 thorpej * Make this process not share its cwdinfo structure, maintaining
1036 1.58 thorpej * all cwdinfo state.
1037 1.58 thorpej */
1038 1.58 thorpej void
1039 1.72 lukem cwdunshare(struct proc *p)
1040 1.58 thorpej {
1041 1.126 pk struct cwdinfo *oldcwdi, *newcwdi;
1042 1.58 thorpej
1043 1.58 thorpej if (p->p_cwdi->cwdi_refcnt == 1)
1044 1.58 thorpej return;
1045 1.58 thorpej
1046 1.58 thorpej newcwdi = cwdinit(p);
1047 1.126 pk oldcwdi = p->p_cwdi;
1048 1.58 thorpej p->p_cwdi = newcwdi;
1049 1.126 pk cwdfree(oldcwdi);
1050 1.58 thorpej }
1051 1.58 thorpej
1052 1.58 thorpej /*
1053 1.58 thorpej * Release a cwdinfo structure.
1054 1.58 thorpej */
1055 1.58 thorpej void
1056 1.126 pk cwdfree(struct cwdinfo *cwdi)
1057 1.58 thorpej {
1058 1.126 pk int n;
1059 1.58 thorpej
1060 1.126 pk simple_lock(&cwdi->cwdi_slock);
1061 1.126 pk n = --cwdi->cwdi_refcnt;
1062 1.126 pk simple_unlock(&cwdi->cwdi_slock);
1063 1.126 pk if (n > 0)
1064 1.58 thorpej return;
1065 1.58 thorpej
1066 1.58 thorpej vrele(cwdi->cwdi_cdir);
1067 1.58 thorpej if (cwdi->cwdi_rdir)
1068 1.58 thorpej vrele(cwdi->cwdi_rdir);
1069 1.58 thorpej pool_put(&cwdi_pool, cwdi);
1070 1.58 thorpej }
1071 1.58 thorpej
1072 1.58 thorpej /*
1073 1.48 thorpej * Create an initial filedesc structure, using the same current and root
1074 1.48 thorpej * directories as p.
1075 1.48 thorpej */
1076 1.48 thorpej struct filedesc *
1077 1.72 lukem fdinit(struct proc *p)
1078 1.48 thorpej {
1079 1.48 thorpej struct filedesc0 *newfdp;
1080 1.48 thorpej
1081 1.64 thorpej newfdp = pool_get(&filedesc0_pool, PR_WAITOK);
1082 1.53 perry memset(newfdp, 0, sizeof(struct filedesc0));
1083 1.48 thorpej
1084 1.48 thorpej fdinit1(newfdp);
1085 1.48 thorpej
1086 1.48 thorpej return (&newfdp->fd_fd);
1087 1.48 thorpej }
1088 1.48 thorpej
1089 1.48 thorpej /*
1090 1.48 thorpej * Initialize a file descriptor table.
1091 1.48 thorpej */
1092 1.48 thorpej void
1093 1.72 lukem fdinit1(struct filedesc0 *newfdp)
1094 1.48 thorpej {
1095 1.48 thorpej
1096 1.48 thorpej newfdp->fd_fd.fd_refcnt = 1;
1097 1.48 thorpej newfdp->fd_fd.fd_ofiles = newfdp->fd_dfiles;
1098 1.48 thorpej newfdp->fd_fd.fd_ofileflags = newfdp->fd_dfileflags;
1099 1.48 thorpej newfdp->fd_fd.fd_nfiles = NDFILE;
1100 1.96 jdolecek newfdp->fd_fd.fd_knlistsize = -1;
1101 1.115 provos newfdp->fd_fd.fd_himap = newfdp->fd_dhimap;
1102 1.115 provos newfdp->fd_fd.fd_lomap = newfdp->fd_dlomap;
1103 1.128 cube newfdp->fd_fd.fd_lastfile = -1;
1104 1.126 pk simple_lock_init(&newfdp->fd_fd.fd_slock);
1105 1.48 thorpej }
1106 1.48 thorpej
1107 1.48 thorpej /*
1108 1.48 thorpej * Make p2 share p1's filedesc structure.
1109 1.48 thorpej */
1110 1.48 thorpej void
1111 1.72 lukem fdshare(struct proc *p1, struct proc *p2)
1112 1.48 thorpej {
1113 1.126 pk struct filedesc *fdp = p1->p_fd;
1114 1.48 thorpej
1115 1.126 pk simple_lock(&fdp->fd_slock);
1116 1.126 pk p2->p_fd = fdp;
1117 1.126 pk fdp->fd_refcnt++;
1118 1.126 pk simple_unlock(&fdp->fd_slock);
1119 1.48 thorpej }
1120 1.48 thorpej
1121 1.48 thorpej /*
1122 1.48 thorpej * Make this process not share its filedesc structure, maintaining
1123 1.48 thorpej * all file descriptor state.
1124 1.48 thorpej */
1125 1.48 thorpej void
1126 1.110 fvdl fdunshare(struct proc *p)
1127 1.48 thorpej {
1128 1.48 thorpej struct filedesc *newfd;
1129 1.48 thorpej
1130 1.48 thorpej if (p->p_fd->fd_refcnt == 1)
1131 1.48 thorpej return;
1132 1.48 thorpej
1133 1.48 thorpej newfd = fdcopy(p);
1134 1.110 fvdl fdfree(p);
1135 1.48 thorpej p->p_fd = newfd;
1136 1.48 thorpej }
1137 1.48 thorpej
1138 1.48 thorpej /*
1139 1.48 thorpej * Clear a process's fd table.
1140 1.48 thorpej */
1141 1.48 thorpej void
1142 1.110 fvdl fdclear(struct proc *p)
1143 1.48 thorpej {
1144 1.48 thorpej struct filedesc *newfd;
1145 1.48 thorpej
1146 1.48 thorpej newfd = fdinit(p);
1147 1.110 fvdl fdfree(p);
1148 1.48 thorpej p->p_fd = newfd;
1149 1.16 cgd }
1150 1.16 cgd
1151 1.16 cgd /*
1152 1.16 cgd * Copy a filedesc structure.
1153 1.16 cgd */
1154 1.16 cgd struct filedesc *
1155 1.72 lukem fdcopy(struct proc *p)
1156 1.16 cgd {
1157 1.72 lukem struct filedesc *newfdp, *fdp;
1158 1.126 pk struct file **fpp, **nfpp;
1159 1.126 pk int i, nfiles, lastfile;
1160 1.16 cgd
1161 1.72 lukem fdp = p->p_fd;
1162 1.64 thorpej newfdp = pool_get(&filedesc0_pool, PR_WAITOK);
1163 1.16 cgd newfdp->fd_refcnt = 1;
1164 1.126 pk simple_lock_init(&newfdp->fd_slock);
1165 1.126 pk
1166 1.126 pk restart:
1167 1.126 pk nfiles = fdp->fd_nfiles;
1168 1.126 pk lastfile = fdp->fd_lastfile;
1169 1.16 cgd
1170 1.16 cgd /*
1171 1.16 cgd * If the number of open files fits in the internal arrays
1172 1.16 cgd * of the open file structure, use them, otherwise allocate
1173 1.16 cgd * additional memory for the number of descriptors currently
1174 1.16 cgd * in use.
1175 1.16 cgd */
1176 1.126 pk if (lastfile < NDFILE) {
1177 1.16 cgd i = NDFILE;
1178 1.16 cgd } else {
1179 1.16 cgd /*
1180 1.16 cgd * Compute the smallest multiple of NDEXTENT needed
1181 1.16 cgd * for the file descriptors currently in use,
1182 1.16 cgd * allowing the table to shrink.
1183 1.16 cgd */
1184 1.126 pk i = nfiles;
1185 1.126 pk while (i >= 2 * NDEXTENT && i > lastfile * 2)
1186 1.16 cgd i /= 2;
1187 1.64 thorpej newfdp->fd_ofiles = malloc(i * OFILESIZE, M_FILEDESC, M_WAITOK);
1188 1.126 pk }
1189 1.126 pk if (NDHISLOTS(i) > NDHISLOTS(NDFILE)) {
1190 1.126 pk newfdp->fd_himap = malloc(NDHISLOTS(i) * sizeof(uint32_t),
1191 1.126 pk M_FILEDESC, M_WAITOK);
1192 1.126 pk newfdp->fd_lomap = malloc(NDLOSLOTS(i) * sizeof(uint32_t),
1193 1.126 pk M_FILEDESC, M_WAITOK);
1194 1.126 pk }
1195 1.126 pk
1196 1.126 pk simple_lock(&fdp->fd_slock);
1197 1.126 pk if (nfiles != fdp->fd_nfiles || lastfile != fdp->fd_lastfile) {
1198 1.126 pk simple_unlock(&fdp->fd_slock);
1199 1.126 pk if (i > NDFILE)
1200 1.126 pk free(newfdp->fd_ofiles, M_FILEDESC);
1201 1.126 pk if (NDHISLOTS(i) > NDHISLOTS(NDFILE)) {
1202 1.126 pk free(newfdp->fd_himap, M_FILEDESC);
1203 1.126 pk free(newfdp->fd_lomap, M_FILEDESC);
1204 1.126 pk }
1205 1.126 pk goto restart;
1206 1.126 pk }
1207 1.126 pk
1208 1.126 pk if (lastfile < NDFILE) {
1209 1.126 pk newfdp->fd_ofiles = ((struct filedesc0 *) newfdp)->fd_dfiles;
1210 1.126 pk newfdp->fd_ofileflags =
1211 1.126 pk ((struct filedesc0 *) newfdp)->fd_dfileflags;
1212 1.126 pk } else {
1213 1.16 cgd newfdp->fd_ofileflags = (char *) &newfdp->fd_ofiles[i];
1214 1.16 cgd }
1215 1.115 provos if (NDHISLOTS(i) <= NDHISLOTS(NDFILE)) {
1216 1.115 provos newfdp->fd_himap =
1217 1.115 provos ((struct filedesc0 *) newfdp)->fd_dhimap;
1218 1.115 provos newfdp->fd_lomap =
1219 1.115 provos ((struct filedesc0 *) newfdp)->fd_dlomap;
1220 1.115 provos }
1221 1.115 provos
1222 1.16 cgd newfdp->fd_nfiles = i;
1223 1.126 pk newfdp->fd_lastfile = lastfile;
1224 1.126 pk newfdp->fd_freefile = fdp->fd_freefile;
1225 1.126 pk
1226 1.128 cube /* Clear the entries that will not be copied over.
1227 1.128 cube * Avoid calling memset with 0 size (i.e. when
1228 1.128 cube * lastfile == i-1 */
1229 1.128 cube if (lastfile < (i-1))
1230 1.128 cube memset(newfdp->fd_ofiles + lastfile + 1, 0,
1231 1.128 cube (i - lastfile - 1) * sizeof(struct file **));
1232 1.53 perry memcpy(newfdp->fd_ofileflags, fdp->fd_ofileflags, i * sizeof(char));
1233 1.120 yamt if (i < NDENTRIES * NDENTRIES)
1234 1.120 yamt i = NDENTRIES * NDENTRIES; /* size of inlined bitmaps */
1235 1.115 provos memcpy(newfdp->fd_himap, fdp->fd_himap, NDHISLOTS(i)*sizeof(uint32_t));
1236 1.115 provos memcpy(newfdp->fd_lomap, fdp->fd_lomap, NDLOSLOTS(i)*sizeof(uint32_t));
1237 1.126 pk
1238 1.126 pk fpp = fdp->fd_ofiles;
1239 1.126 pk nfpp = newfdp->fd_ofiles;
1240 1.126 pk for (i = 0; i <= lastfile; i++, fpp++, nfpp++) {
1241 1.126 pk if ((*nfpp = *fpp) == NULL)
1242 1.126 pk continue;
1243 1.126 pk
1244 1.126 pk if ((*fpp)->f_type == DTYPE_KQUEUE)
1245 1.126 pk /* kq descriptors cannot be copied. */
1246 1.126 pk fdremove(newfdp, i);
1247 1.126 pk else {
1248 1.126 pk simple_lock(&(*fpp)->f_slock);
1249 1.126 pk (*fpp)->f_count++;
1250 1.126 pk simple_unlock(&(*fpp)->f_slock);
1251 1.96 jdolecek }
1252 1.126 pk }
1253 1.126 pk
1254 1.126 pk simple_unlock(&fdp->fd_slock);
1255 1.126 pk
1256 1.126 pk newfdp->fd_knlist = NULL;
1257 1.126 pk newfdp->fd_knlistsize = -1;
1258 1.126 pk newfdp->fd_knhash = NULL;
1259 1.126 pk newfdp->fd_knhashmask = 0;
1260 1.126 pk
1261 1.16 cgd return (newfdp);
1262 1.16 cgd }
1263 1.16 cgd
1264 1.16 cgd /*
1265 1.16 cgd * Release a filedesc structure.
1266 1.16 cgd */
1267 1.16 cgd void
1268 1.110 fvdl fdfree(struct proc *p)
1269 1.16 cgd {
1270 1.72 lukem struct filedesc *fdp;
1271 1.72 lukem struct file **fpp, *fp;
1272 1.72 lukem int i;
1273 1.16 cgd
1274 1.72 lukem fdp = p->p_fd;
1275 1.126 pk simple_lock(&fdp->fd_slock);
1276 1.126 pk i = --fdp->fd_refcnt;
1277 1.126 pk simple_unlock(&fdp->fd_slock);
1278 1.126 pk if (i > 0)
1279 1.16 cgd return;
1280 1.126 pk
1281 1.16 cgd fpp = fdp->fd_ofiles;
1282 1.32 mycroft for (i = fdp->fd_lastfile; i >= 0; i--, fpp++) {
1283 1.32 mycroft fp = *fpp;
1284 1.32 mycroft if (fp != NULL) {
1285 1.32 mycroft *fpp = NULL;
1286 1.103 pk simple_lock(&fp->f_slock);
1287 1.59 thorpej FILE_USE(fp);
1288 1.96 jdolecek if (i < fdp->fd_knlistsize)
1289 1.110 fvdl knote_fdclose(p, fdp->fd_lastfile - i);
1290 1.110 fvdl (void) closef(fp, p);
1291 1.32 mycroft }
1292 1.32 mycroft }
1293 1.32 mycroft p->p_fd = NULL;
1294 1.16 cgd if (fdp->fd_nfiles > NDFILE)
1295 1.64 thorpej free(fdp->fd_ofiles, M_FILEDESC);
1296 1.115 provos if (NDHISLOTS(fdp->fd_nfiles) > NDHISLOTS(NDFILE)) {
1297 1.115 provos free(fdp->fd_himap, M_FILEDESC);
1298 1.115 provos free(fdp->fd_lomap, M_FILEDESC);
1299 1.115 provos }
1300 1.96 jdolecek if (fdp->fd_knlist)
1301 1.96 jdolecek free(fdp->fd_knlist, M_KEVENT);
1302 1.96 jdolecek if (fdp->fd_knhash)
1303 1.96 jdolecek hashdone(fdp->fd_knhash, M_KEVENT);
1304 1.64 thorpej pool_put(&filedesc0_pool, fdp);
1305 1.16 cgd }
1306 1.16 cgd
1307 1.16 cgd /*
1308 1.16 cgd * Internal form of close.
1309 1.16 cgd * Decrement reference count on file structure.
1310 1.17 cgd * Note: p may be NULL when closing a file
1311 1.17 cgd * that was being passed in a message.
1312 1.59 thorpej *
1313 1.59 thorpej * Note: we expect the caller is holding a usecount, and expects us
1314 1.59 thorpej * to drop it (the caller thinks the file is going away forever).
1315 1.16 cgd */
1316 1.38 christos int
1317 1.110 fvdl closef(struct file *fp, struct proc *p)
1318 1.72 lukem {
1319 1.72 lukem struct vnode *vp;
1320 1.72 lukem struct flock lf;
1321 1.72 lukem int error;
1322 1.16 cgd
1323 1.16 cgd if (fp == NULL)
1324 1.16 cgd return (0);
1325 1.59 thorpej
1326 1.16 cgd /*
1327 1.16 cgd * POSIX record locking dictates that any close releases ALL
1328 1.16 cgd * locks owned by this process. This is handled by setting
1329 1.16 cgd * a flag in the unlock to free ONLY locks obeying POSIX
1330 1.16 cgd * semantics, and not to free BSD-style file locks.
1331 1.17 cgd * If the descriptor was in a message, POSIX-style locks
1332 1.17 cgd * aren't passed with the descriptor.
1333 1.16 cgd */
1334 1.16 cgd if (p && (p->p_flag & P_ADVLOCK) && fp->f_type == DTYPE_VNODE) {
1335 1.16 cgd lf.l_whence = SEEK_SET;
1336 1.16 cgd lf.l_start = 0;
1337 1.16 cgd lf.l_len = 0;
1338 1.16 cgd lf.l_type = F_UNLCK;
1339 1.16 cgd vp = (struct vnode *)fp->f_data;
1340 1.106 dsl (void) VOP_ADVLOCK(vp, p, F_UNLCK, &lf, F_POSIX);
1341 1.16 cgd }
1342 1.59 thorpej
1343 1.59 thorpej /*
1344 1.59 thorpej * If WANTCLOSE is set, then the reference count on the file
1345 1.59 thorpej * is 0, but there were multiple users of the file. This can
1346 1.59 thorpej * happen if a filedesc structure is shared by multiple
1347 1.59 thorpej * processes.
1348 1.59 thorpej */
1349 1.103 pk simple_lock(&fp->f_slock);
1350 1.83 jdolecek if (fp->f_iflags & FIF_WANTCLOSE) {
1351 1.59 thorpej /*
1352 1.59 thorpej * Another user of the file is already closing, and is
1353 1.59 thorpej * simply waiting for other users of the file to drain.
1354 1.59 thorpej * Release our usecount, and wake up the closer if it
1355 1.59 thorpej * is the only remaining use.
1356 1.59 thorpej */
1357 1.59 thorpej #ifdef DIAGNOSTIC
1358 1.59 thorpej if (fp->f_count != 0)
1359 1.59 thorpej panic("closef: wantclose and count != 0");
1360 1.59 thorpej if (fp->f_usecount < 2)
1361 1.59 thorpej panic("closef: wantclose and usecount < 2");
1362 1.59 thorpej #endif
1363 1.59 thorpej if (--fp->f_usecount == 1)
1364 1.59 thorpej wakeup(&fp->f_usecount);
1365 1.103 pk simple_unlock(&fp->f_slock);
1366 1.16 cgd return (0);
1367 1.59 thorpej } else {
1368 1.59 thorpej /*
1369 1.59 thorpej * Decrement the reference count. If we were not the
1370 1.59 thorpej * last reference, then release our use and just
1371 1.59 thorpej * return.
1372 1.59 thorpej */
1373 1.59 thorpej if (--fp->f_count > 0) {
1374 1.59 thorpej #ifdef DIAGNOSTIC
1375 1.59 thorpej if (fp->f_usecount < 1)
1376 1.59 thorpej panic("closef: no wantclose and usecount < 1");
1377 1.59 thorpej #endif
1378 1.59 thorpej fp->f_usecount--;
1379 1.103 pk simple_unlock(&fp->f_slock);
1380 1.59 thorpej return (0);
1381 1.59 thorpej }
1382 1.59 thorpej }
1383 1.59 thorpej
1384 1.59 thorpej /*
1385 1.59 thorpej * The reference count is now 0. However, there may be
1386 1.59 thorpej * multiple potential users of this file. This can happen
1387 1.59 thorpej * if multiple processes shared a single filedesc structure.
1388 1.59 thorpej *
1389 1.59 thorpej * Notify these potential users that the file is closing.
1390 1.59 thorpej * This will prevent them from adding additional uses to
1391 1.59 thorpej * the file.
1392 1.59 thorpej */
1393 1.83 jdolecek fp->f_iflags |= FIF_WANTCLOSE;
1394 1.59 thorpej
1395 1.59 thorpej /*
1396 1.59 thorpej * We expect the caller to add a use to the file. So, if we
1397 1.59 thorpej * are the last user, usecount will be 1. If it is not, we
1398 1.59 thorpej * must wait for the usecount to drain. When it drains back
1399 1.59 thorpej * to 1, we will be awakened so that we may proceed with the
1400 1.59 thorpej * close.
1401 1.59 thorpej */
1402 1.59 thorpej #ifdef DIAGNOSTIC
1403 1.59 thorpej if (fp->f_usecount < 1)
1404 1.59 thorpej panic("closef: usecount < 1");
1405 1.59 thorpej #endif
1406 1.59 thorpej while (fp->f_usecount > 1)
1407 1.103 pk (void) ltsleep(&fp->f_usecount, PRIBIO, "closef", 0,
1408 1.103 pk &fp->f_slock);
1409 1.59 thorpej #ifdef DIAGNOSTIC
1410 1.59 thorpej if (fp->f_usecount != 1)
1411 1.59 thorpej panic("closef: usecount != 1");
1412 1.59 thorpej #endif
1413 1.59 thorpej
1414 1.103 pk simple_unlock(&fp->f_slock);
1415 1.16 cgd if ((fp->f_flag & FHASLOCK) && fp->f_type == DTYPE_VNODE) {
1416 1.16 cgd lf.l_whence = SEEK_SET;
1417 1.16 cgd lf.l_start = 0;
1418 1.16 cgd lf.l_len = 0;
1419 1.16 cgd lf.l_type = F_UNLCK;
1420 1.16 cgd vp = (struct vnode *)fp->f_data;
1421 1.106 dsl (void) VOP_ADVLOCK(vp, fp, F_UNLCK, &lf, F_FLOCK);
1422 1.16 cgd }
1423 1.17 cgd if (fp->f_ops)
1424 1.110 fvdl error = (*fp->f_ops->fo_close)(fp, p);
1425 1.17 cgd else
1426 1.17 cgd error = 0;
1427 1.59 thorpej
1428 1.59 thorpej /* Nothing references the file now, drop the final use (us). */
1429 1.59 thorpej fp->f_usecount--;
1430 1.59 thorpej
1431 1.16 cgd ffree(fp);
1432 1.16 cgd return (error);
1433 1.16 cgd }
1434 1.16 cgd
1435 1.16 cgd /*
1436 1.16 cgd * Apply an advisory lock on a file descriptor.
1437 1.16 cgd *
1438 1.16 cgd * Just attempt to get a record lock of the requested type on
1439 1.16 cgd * the entire file (l_whence = SEEK_SET, l_start = 0, l_len = 0).
1440 1.16 cgd */
1441 1.16 cgd /* ARGSUSED */
1442 1.38 christos int
1443 1.99 thorpej sys_flock(struct lwp *l, void *v, register_t *retval)
1444 1.36 thorpej {
1445 1.66 augustss struct sys_flock_args /* {
1446 1.72 lukem syscallarg(int) fd;
1447 1.72 lukem syscallarg(int) how;
1448 1.36 thorpej } */ *uap = v;
1449 1.72 lukem int fd, how, error;
1450 1.99 thorpej struct proc *p;
1451 1.72 lukem struct filedesc *fdp;
1452 1.72 lukem struct file *fp;
1453 1.72 lukem struct vnode *vp;
1454 1.72 lukem struct flock lf;
1455 1.16 cgd
1456 1.99 thorpej p = l->l_proc;
1457 1.72 lukem fd = SCARG(uap, fd);
1458 1.72 lukem how = SCARG(uap, how);
1459 1.72 lukem fdp = p->p_fd;
1460 1.72 lukem error = 0;
1461 1.77 thorpej
1462 1.77 thorpej if ((fp = fd_getfile(fdp, fd)) == NULL)
1463 1.16 cgd return (EBADF);
1464 1.59 thorpej
1465 1.59 thorpej FILE_USE(fp);
1466 1.59 thorpej
1467 1.59 thorpej if (fp->f_type != DTYPE_VNODE) {
1468 1.59 thorpej error = EOPNOTSUPP;
1469 1.59 thorpej goto out;
1470 1.59 thorpej }
1471 1.59 thorpej
1472 1.16 cgd vp = (struct vnode *)fp->f_data;
1473 1.16 cgd lf.l_whence = SEEK_SET;
1474 1.16 cgd lf.l_start = 0;
1475 1.16 cgd lf.l_len = 0;
1476 1.27 mycroft if (how & LOCK_UN) {
1477 1.16 cgd lf.l_type = F_UNLCK;
1478 1.16 cgd fp->f_flag &= ~FHASLOCK;
1479 1.106 dsl error = VOP_ADVLOCK(vp, fp, F_UNLCK, &lf, F_FLOCK);
1480 1.59 thorpej goto out;
1481 1.16 cgd }
1482 1.27 mycroft if (how & LOCK_EX)
1483 1.16 cgd lf.l_type = F_WRLCK;
1484 1.27 mycroft else if (how & LOCK_SH)
1485 1.16 cgd lf.l_type = F_RDLCK;
1486 1.59 thorpej else {
1487 1.59 thorpej error = EINVAL;
1488 1.59 thorpej goto out;
1489 1.59 thorpej }
1490 1.16 cgd fp->f_flag |= FHASLOCK;
1491 1.27 mycroft if (how & LOCK_NB)
1492 1.106 dsl error = VOP_ADVLOCK(vp, fp, F_SETLK, &lf, F_FLOCK);
1493 1.59 thorpej else
1494 1.106 dsl error = VOP_ADVLOCK(vp, fp, F_SETLK, &lf,
1495 1.59 thorpej F_FLOCK|F_WAIT);
1496 1.59 thorpej out:
1497 1.110 fvdl FILE_UNUSE(fp, p);
1498 1.59 thorpej return (error);
1499 1.16 cgd }
1500 1.16 cgd
1501 1.16 cgd /*
1502 1.16 cgd * File Descriptor pseudo-device driver (/dev/fd/).
1503 1.16 cgd *
1504 1.16 cgd * Opening minor device N dup()s the file (if any) connected to file
1505 1.16 cgd * descriptor N belonging to the calling process. Note that this driver
1506 1.16 cgd * consists of only the ``open()'' routine, because all subsequent
1507 1.16 cgd * references to this file will be direct to the other driver.
1508 1.16 cgd */
1509 1.16 cgd /* ARGSUSED */
1510 1.28 mycroft int
1511 1.110 fvdl filedescopen(dev_t dev, int mode, int type, struct proc *p)
1512 1.16 cgd {
1513 1.16 cgd
1514 1.28 mycroft /*
1515 1.112 jdolecek * XXX Kludge: set dupfd to contain the value of the
1516 1.89 enami * the file descriptor being sought for duplication. The error
1517 1.28 mycroft * return ensures that the vnode for this device will be released
1518 1.28 mycroft * by vn_open. Open will detect this special error and take the
1519 1.28 mycroft * actions in dupfdopen below. Other callers of vn_open or VOP_OPEN
1520 1.28 mycroft * will simply report the error.
1521 1.28 mycroft */
1522 1.112 jdolecek curlwp->l_dupfd = minor(dev); /* XXX */
1523 1.127 christos return EDUPFD;
1524 1.27 mycroft }
1525 1.27 mycroft
1526 1.28 mycroft /*
1527 1.28 mycroft * Duplicate the specified descriptor to a free descriptor.
1528 1.118 yamt *
1529 1.118 yamt * 'indx' has been fdalloc'ed (and will be fdremove'ed on error) by the caller.
1530 1.28 mycroft */
1531 1.27 mycroft int
1532 1.110 fvdl dupfdopen(struct proc *p, int indx, int dfd, int mode, int error)
1533 1.72 lukem {
1534 1.110 fvdl struct filedesc *fdp;
1535 1.118 yamt struct file *wfp;
1536 1.27 mycroft
1537 1.72 lukem fdp = p->p_fd;
1538 1.118 yamt
1539 1.118 yamt /* should be cleared by the caller */
1540 1.118 yamt KASSERT(fdp->fd_ofiles[indx] == NULL);
1541 1.118 yamt
1542 1.27 mycroft /*
1543 1.27 mycroft * If the to-be-dup'd fd number is greater than the allowed number
1544 1.27 mycroft * of file descriptors, or the fd to be dup'd has already been
1545 1.118 yamt * closed, reject.
1546 1.27 mycroft */
1547 1.77 thorpej
1548 1.118 yamt /*
1549 1.118 yamt * Note, in the case of indx == dfd, fd_getfile below returns NULL.
1550 1.118 yamt */
1551 1.77 thorpej if ((wfp = fd_getfile(fdp, dfd)) == NULL)
1552 1.77 thorpej return (EBADF);
1553 1.77 thorpej
1554 1.59 thorpej FILE_USE(wfp);
1555 1.59 thorpej
1556 1.27 mycroft /*
1557 1.28 mycroft * There are two cases of interest here.
1558 1.28 mycroft *
1559 1.127 christos * For EDUPFD simply dup (dfd) to file descriptor
1560 1.28 mycroft * (indx) and return.
1561 1.28 mycroft *
1562 1.127 christos * For EMOVEFD steal away the file structure from (dfd) and
1563 1.28 mycroft * store it in (indx). (dfd) is effectively closed by
1564 1.28 mycroft * this operation.
1565 1.28 mycroft *
1566 1.28 mycroft * Any other error code is just returned.
1567 1.27 mycroft */
1568 1.28 mycroft switch (error) {
1569 1.127 christos case EDUPFD:
1570 1.28 mycroft /*
1571 1.28 mycroft * Check that the mode the file is being opened for is a
1572 1.28 mycroft * subset of the mode of the existing descriptor.
1573 1.28 mycroft */
1574 1.59 thorpej if (((mode & (FREAD|FWRITE)) | wfp->f_flag) != wfp->f_flag) {
1575 1.110 fvdl FILE_UNUSE(wfp, p);
1576 1.28 mycroft return (EACCES);
1577 1.59 thorpej }
1578 1.126 pk simple_lock(&fdp->fd_slock);
1579 1.28 mycroft fdp->fd_ofiles[indx] = wfp;
1580 1.28 mycroft fdp->fd_ofileflags[indx] = fdp->fd_ofileflags[dfd];
1581 1.126 pk simple_unlock(&fdp->fd_slock);
1582 1.126 pk simple_lock(&wfp->f_slock);
1583 1.28 mycroft wfp->f_count++;
1584 1.119 yamt /* 'indx' has been fd_used'ed by caller */
1585 1.126 pk FILE_UNUSE_HAVELOCK(wfp, p);
1586 1.28 mycroft return (0);
1587 1.27 mycroft
1588 1.127 christos case EMOVEFD:
1589 1.28 mycroft /*
1590 1.28 mycroft * Steal away the file pointer from dfd, and stuff it into indx.
1591 1.28 mycroft */
1592 1.126 pk simple_lock(&fdp->fd_slock);
1593 1.28 mycroft fdp->fd_ofiles[indx] = fdp->fd_ofiles[dfd];
1594 1.28 mycroft fdp->fd_ofileflags[indx] = fdp->fd_ofileflags[dfd];
1595 1.28 mycroft fdp->fd_ofiles[dfd] = NULL;
1596 1.28 mycroft fdp->fd_ofileflags[dfd] = 0;
1597 1.28 mycroft /*
1598 1.28 mycroft * Complete the clean up of the filedesc structure by
1599 1.28 mycroft * recomputing the various hints.
1600 1.28 mycroft */
1601 1.119 yamt /* 'indx' has been fd_used'ed by caller */
1602 1.28 mycroft fd_unused(fdp, dfd);
1603 1.126 pk simple_unlock(&fdp->fd_slock);
1604 1.110 fvdl FILE_UNUSE(wfp, p);
1605 1.28 mycroft return (0);
1606 1.16 cgd
1607 1.28 mycroft default:
1608 1.110 fvdl FILE_UNUSE(wfp, p);
1609 1.28 mycroft return (error);
1610 1.28 mycroft }
1611 1.28 mycroft /* NOTREACHED */
1612 1.61 wrstuden }
1613 1.61 wrstuden
1614 1.61 wrstuden /*
1615 1.61 wrstuden * fcntl call which is being passed to the file's fs.
1616 1.61 wrstuden */
1617 1.61 wrstuden int
1618 1.110 fvdl fcntl_forfs(int fd, struct proc *p, int cmd, void *arg)
1619 1.61 wrstuden {
1620 1.72 lukem struct file *fp;
1621 1.72 lukem struct filedesc *fdp;
1622 1.72 lukem int error;
1623 1.72 lukem u_int size;
1624 1.106 dsl void *data, *memp;
1625 1.61 wrstuden #define STK_PARAMS 128
1626 1.72 lukem char stkbuf[STK_PARAMS];
1627 1.61 wrstuden
1628 1.61 wrstuden /* fd's value was validated in sys_fcntl before calling this routine */
1629 1.61 wrstuden fdp = p->p_fd;
1630 1.61 wrstuden fp = fdp->fd_ofiles[fd];
1631 1.61 wrstuden
1632 1.61 wrstuden if ((fp->f_flag & (FREAD | FWRITE)) == 0)
1633 1.61 wrstuden return (EBADF);
1634 1.61 wrstuden
1635 1.61 wrstuden /*
1636 1.61 wrstuden * Interpret high order word to find amount of data to be
1637 1.61 wrstuden * copied to/from the user's address space.
1638 1.61 wrstuden */
1639 1.61 wrstuden size = (size_t)F_PARAM_LEN(cmd);
1640 1.61 wrstuden if (size > F_PARAM_MAX)
1641 1.61 wrstuden return (EINVAL);
1642 1.61 wrstuden memp = NULL;
1643 1.61 wrstuden if (size > sizeof(stkbuf)) {
1644 1.106 dsl memp = malloc((u_long)size, M_IOCTLOPS, M_WAITOK);
1645 1.61 wrstuden data = memp;
1646 1.61 wrstuden } else
1647 1.61 wrstuden data = stkbuf;
1648 1.61 wrstuden if (cmd & F_FSIN) {
1649 1.61 wrstuden if (size) {
1650 1.61 wrstuden error = copyin(arg, data, size);
1651 1.61 wrstuden if (error) {
1652 1.61 wrstuden if (memp)
1653 1.61 wrstuden free(memp, M_IOCTLOPS);
1654 1.61 wrstuden return (error);
1655 1.61 wrstuden }
1656 1.61 wrstuden } else
1657 1.106 dsl *(void **)data = arg;
1658 1.61 wrstuden } else if ((cmd & F_FSOUT) && size)
1659 1.61 wrstuden /*
1660 1.61 wrstuden * Zero the buffer so the user always
1661 1.61 wrstuden * gets back something deterministic.
1662 1.61 wrstuden */
1663 1.61 wrstuden memset(data, 0, size);
1664 1.61 wrstuden else if (cmd & F_FSVOID)
1665 1.106 dsl *(void **)data = arg;
1666 1.61 wrstuden
1667 1.61 wrstuden
1668 1.110 fvdl error = (*fp->f_ops->fo_fcntl)(fp, cmd, data, p);
1669 1.61 wrstuden
1670 1.61 wrstuden /*
1671 1.61 wrstuden * Copy any data to user, size was
1672 1.61 wrstuden * already set and checked above.
1673 1.61 wrstuden */
1674 1.61 wrstuden if (error == 0 && (cmd & F_FSOUT) && size)
1675 1.61 wrstuden error = copyout(data, arg, size);
1676 1.61 wrstuden if (memp)
1677 1.61 wrstuden free(memp, M_IOCTLOPS);
1678 1.61 wrstuden return (error);
1679 1.27 mycroft }
1680 1.16 cgd
1681 1.27 mycroft /*
1682 1.27 mycroft * Close any files on exec?
1683 1.27 mycroft */
1684 1.27 mycroft void
1685 1.110 fvdl fdcloseexec(struct proc *p)
1686 1.27 mycroft {
1687 1.110 fvdl struct filedesc *fdp;
1688 1.72 lukem int fd;
1689 1.80 thorpej
1690 1.110 fvdl fdunshare(p);
1691 1.80 thorpej cwdunshare(p);
1692 1.16 cgd
1693 1.72 lukem fdp = p->p_fd;
1694 1.27 mycroft for (fd = 0; fd <= fdp->fd_lastfile; fd++)
1695 1.27 mycroft if (fdp->fd_ofileflags[fd] & UF_EXCLOSE)
1696 1.110 fvdl (void) fdrelease(p, fd);
1697 1.86 christos }
1698 1.86 christos
1699 1.86 christos /*
1700 1.86 christos * It is unsafe for set[ug]id processes to be started with file
1701 1.86 christos * descriptors 0..2 closed, as these descriptors are given implicit
1702 1.86 christos * significance in the Standard C library. fdcheckstd() will create a
1703 1.86 christos * descriptor referencing /dev/null for each of stdin, stdout, and
1704 1.86 christos * stderr that is not already open.
1705 1.86 christos */
1706 1.92 atatat #define CHECK_UPTO 3
1707 1.86 christos int
1708 1.110 fvdl fdcheckstd(p)
1709 1.110 fvdl struct proc *p;
1710 1.109 darrenr {
1711 1.86 christos struct nameidata nd;
1712 1.86 christos struct filedesc *fdp;
1713 1.86 christos struct file *fp;
1714 1.97 scw struct file *devnullfp = NULL; /* Quell compiler warning */
1715 1.91 enami struct proc *pp;
1716 1.86 christos register_t retval;
1717 1.92 atatat int fd, i, error, flags = FREAD|FWRITE, devnull = -1;
1718 1.92 atatat char closed[CHECK_UPTO * 3 + 1], which[3 + 1];
1719 1.86 christos
1720 1.92 atatat closed[0] = '\0';
1721 1.86 christos if ((fdp = p->p_fd) == NULL)
1722 1.89 enami return (0);
1723 1.92 atatat for (i = 0; i < CHECK_UPTO; i++) {
1724 1.86 christos if (fdp->fd_ofiles[i] != NULL)
1725 1.86 christos continue;
1726 1.92 atatat snprintf(which, sizeof(which), ",%d", i);
1727 1.108 itojun strlcat(closed, which, sizeof(closed));
1728 1.86 christos if (devnull < 0) {
1729 1.86 christos if ((error = falloc(p, &fp, &fd)) != 0)
1730 1.89 enami return (error);
1731 1.86 christos NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, "/dev/null",
1732 1.110 fvdl p);
1733 1.86 christos if ((error = vn_open(&nd, flags, 0)) != 0) {
1734 1.110 fvdl FILE_UNUSE(fp, p);
1735 1.86 christos ffree(fp);
1736 1.86 christos fdremove(p->p_fd, fd);
1737 1.89 enami return (error);
1738 1.86 christos }
1739 1.106 dsl fp->f_data = nd.ni_vp;
1740 1.86 christos fp->f_flag = flags;
1741 1.86 christos fp->f_ops = &vnops;
1742 1.86 christos fp->f_type = DTYPE_VNODE;
1743 1.86 christos VOP_UNLOCK(nd.ni_vp, 0);
1744 1.86 christos devnull = fd;
1745 1.88 christos devnullfp = fp;
1746 1.87 christos FILE_SET_MATURE(fp);
1747 1.86 christos } else {
1748 1.86 christos restart:
1749 1.86 christos if ((error = fdalloc(p, 0, &fd)) != 0) {
1750 1.86 christos if (error == ENOSPC) {
1751 1.86 christos fdexpand(p);
1752 1.86 christos goto restart;
1753 1.86 christos }
1754 1.89 enami return (error);
1755 1.86 christos }
1756 1.88 christos
1757 1.104 yamt simple_lock(&devnullfp->f_slock);
1758 1.88 christos FILE_USE(devnullfp);
1759 1.88 christos /* finishdup() will unuse the descriptors for us */
1760 1.110 fvdl if ((error = finishdup(p, devnull, fd, &retval)) != 0)
1761 1.89 enami return (error);
1762 1.86 christos }
1763 1.86 christos }
1764 1.104 yamt if (devnullfp)
1765 1.110 fvdl FILE_UNUSE(devnullfp, p);
1766 1.92 atatat if (closed[0] != '\0') {
1767 1.92 atatat pp = p->p_pptr;
1768 1.92 atatat log(LOG_WARNING, "set{u,g}id pid %d (%s) "
1769 1.92 atatat "was invoked by uid %d ppid %d (%s) "
1770 1.92 atatat "with fd %s closed\n",
1771 1.92 atatat p->p_pid, p->p_comm, pp->p_ucred->cr_uid,
1772 1.92 atatat pp->p_pid, pp->p_comm, &closed[1]);
1773 1.92 atatat }
1774 1.89 enami return (0);
1775 1.16 cgd }
1776 1.92 atatat #undef CHECK_UPTO
1777 1.113 jdolecek
1778 1.113 jdolecek /*
1779 1.113 jdolecek * Sets descriptor owner. If the owner is a process, 'pgid'
1780 1.113 jdolecek * is set to positive value, process ID. If the owner is process group,
1781 1.113 jdolecek * 'pgid' is set to -pg_id.
1782 1.113 jdolecek */
1783 1.113 jdolecek int
1784 1.113 jdolecek fsetown(struct proc *p, pid_t *pgid, int cmd, const void *data)
1785 1.113 jdolecek {
1786 1.113 jdolecek int id = *(int *)data;
1787 1.113 jdolecek int error;
1788 1.113 jdolecek
1789 1.113 jdolecek switch (cmd) {
1790 1.113 jdolecek case TIOCSPGRP:
1791 1.113 jdolecek if (id < 0)
1792 1.113 jdolecek return (EINVAL);
1793 1.113 jdolecek id = -id;
1794 1.113 jdolecek break;
1795 1.113 jdolecek default:
1796 1.113 jdolecek break;
1797 1.113 jdolecek }
1798 1.113 jdolecek
1799 1.113 jdolecek if (id > 0 && !pfind(id))
1800 1.113 jdolecek return (ESRCH);
1801 1.113 jdolecek else if (id < 0 && (error = pgid_in_session(p, -id)))
1802 1.113 jdolecek return (error);
1803 1.113 jdolecek
1804 1.113 jdolecek *pgid = id;
1805 1.113 jdolecek return (0);
1806 1.113 jdolecek }
1807 1.113 jdolecek
1808 1.113 jdolecek /*
1809 1.113 jdolecek * Return descriptor owner information. If the value is positive,
1810 1.113 jdolecek * it's process ID. If it's negative, it's process group ID and
1811 1.113 jdolecek * needs the sign removed before use.
1812 1.113 jdolecek */
1813 1.113 jdolecek int
1814 1.113 jdolecek fgetown(struct proc *p, pid_t pgid, int cmd, void *data)
1815 1.113 jdolecek {
1816 1.113 jdolecek switch (cmd) {
1817 1.113 jdolecek case TIOCGPGRP:
1818 1.113 jdolecek *(int *)data = -pgid;
1819 1.113 jdolecek break;
1820 1.113 jdolecek default:
1821 1.113 jdolecek *(int *)data = pgid;
1822 1.113 jdolecek break;
1823 1.113 jdolecek }
1824 1.113 jdolecek return (0);
1825 1.113 jdolecek }
1826 1.113 jdolecek
1827 1.113 jdolecek /*
1828 1.113 jdolecek * Send signal to descriptor owner, either process or process group.
1829 1.113 jdolecek */
1830 1.113 jdolecek void
1831 1.114 christos fownsignal(pid_t pgid, int signo, int code, int band, void *fdescdata)
1832 1.113 jdolecek {
1833 1.113 jdolecek struct proc *p1;
1834 1.113 jdolecek ksiginfo_t ksi;
1835 1.113 jdolecek
1836 1.113 jdolecek memset(&ksi, 0, sizeof(ksi));
1837 1.114 christos ksi.ksi_signo = signo;
1838 1.113 jdolecek ksi.ksi_code = code;
1839 1.113 jdolecek ksi.ksi_band = band;
1840 1.113 jdolecek
1841 1.113 jdolecek if (pgid > 0 && (p1 = pfind(pgid)))
1842 1.113 jdolecek kpsignal(p1, &ksi, fdescdata);
1843 1.113 jdolecek else if (pgid < 0)
1844 1.113 jdolecek kgsignal(-pgid, &ksi, fdescdata);
1845 1.113 jdolecek }
1846 1.127 christos
1847 1.127 christos int
1848 1.130 christos fdclone(struct proc *p, struct file *fp, int fd, int flag,
1849 1.130 christos const struct fileops *fops, void *data)
1850 1.127 christos {
1851 1.130 christos fp->f_flag = flag;
1852 1.127 christos fp->f_type = DTYPE_MISC;
1853 1.127 christos fp->f_ops = fops;
1854 1.127 christos fp->f_data = data;
1855 1.127 christos
1856 1.127 christos curlwp->l_dupfd = fd;
1857 1.127 christos
1858 1.127 christos FILE_SET_MATURE(fp);
1859 1.127 christos FILE_UNUSE(fp, p);
1860 1.127 christos return EMOVEFD;
1861 1.127 christos }
1862 1.127 christos
1863 1.127 christos /* ARGSUSED */
1864 1.127 christos int
1865 1.127 christos fnullop_fcntl(struct file *fp, u_int cmd, void *data, struct proc *p)
1866 1.127 christos {
1867 1.127 christos if (cmd == F_SETFL)
1868 1.127 christos return 0;
1869 1.127 christos
1870 1.127 christos return EOPNOTSUPP;
1871 1.127 christos }
1872 1.127 christos
1873 1.127 christos /* ARGSUSED */
1874 1.127 christos int
1875 1.127 christos fnullop_poll(struct file *fp, int which, struct proc *p)
1876 1.127 christos {
1877 1.127 christos return 0;
1878 1.127 christos }
1879 1.127 christos
1880 1.127 christos
1881 1.127 christos /* ARGSUSED */
1882 1.127 christos int
1883 1.127 christos fnullop_kqfilter(struct file *fp, struct knote *kn)
1884 1.127 christos {
1885 1.127 christos
1886 1.127 christos return 0;
1887 1.127 christos }
1888 1.127 christos
1889 1.127 christos /* ARGSUSED */
1890 1.127 christos int
1891 1.127 christos fbadop_stat(struct file *fp, struct stat *sb, struct proc *p)
1892 1.127 christos {
1893 1.127 christos return EOPNOTSUPP;
1894 1.127 christos }
1895