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