![[BACK]](/icons/back.gif){kind=icon}
Return to kern_descrip.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / kern|
Return to kern_descrip.c CVS log | Up to [local] / sys / kern |
1.1 nbrk 1: /* $OpenBSD: kern_descrip.c,v 1.76 2007/03/15 10:22:30 art Exp $ */
2: /* $NetBSD: kern_descrip.c,v 1.42 1996/03/30 22:24:38 christos Exp $ */
3:
4: /*
5: * Copyright (c) 1982, 1986, 1989, 1991, 1993
6: * The Regents of the University of California. All rights reserved.
7: * (c) UNIX System Laboratories, Inc.
8: * All or some portions of this file are derived from material licensed
9: * to the University of California by American Telephone and Telegraph
10: * Co. or Unix System Laboratories, Inc. and are reproduced herein with
11: * the permission of UNIX System Laboratories, Inc.
12: *
13: * Redistribution and use in source and binary forms, with or without
14: * modification, are permitted provided that the following conditions
15: * are met:
16: * 1. Redistributions of source code must retain the above copyright
17: * notice, this list of conditions and the following disclaimer.
18: * 2. Redistributions in binary form must reproduce the above copyright
19: * notice, this list of conditions and the following disclaimer in the
20: * documentation and/or other materials provided with the distribution.
21: * 3. Neither the name of the University nor the names of its contributors
22: * may be used to endorse or promote products derived from this software
23: * without specific prior written permission.
24: *
25: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35: * SUCH DAMAGE.
36: *
37: * @(#)kern_descrip.c 8.6 (Berkeley) 4/19/94
38: */
39:
40: #include <sys/param.h>
41: #include <sys/systm.h>
42: #include <sys/filedesc.h>
43: #include <sys/kernel.h>
44: #include <sys/vnode.h>
45: #include <sys/proc.h>
46: #include <sys/file.h>
47: #include <sys/socket.h>
48: #include <sys/socketvar.h>
49: #include <sys/stat.h>
50: #include <sys/ioctl.h>
51: #include <sys/fcntl.h>
52: #include <sys/malloc.h>
53: #include <sys/syslog.h>
54: #include <sys/ucred.h>
55: #include <sys/unistd.h>
56: #include <sys/resourcevar.h>
57: #include <sys/conf.h>
58: #include <sys/mount.h>
59: #include <sys/syscallargs.h>
60: #include <sys/event.h>
61: #include <sys/pool.h>
62:
63: #include <uvm/uvm_extern.h>
64:
65: #include <sys/pipe.h>
66:
67: /*
68: * Descriptor management.
69: */
70: struct filelist filehead; /* head of list of open files */
71: int nfiles; /* actual number of open files */
72:
73: static __inline void fd_used(struct filedesc *, int);
74: static __inline void fd_unused(struct filedesc *, int);
75: static __inline int find_next_zero(u_int *, int, u_int);
76: int finishdup(struct proc *, struct file *, int, int, register_t *);
77: int find_last_set(struct filedesc *, int);
78:
79: struct pool file_pool;
80: struct pool fdesc_pool;
81:
82: void
83: filedesc_init(void)
84: {
85: pool_init(&file_pool, sizeof(struct file), 0, 0, 0, "filepl",
86: &pool_allocator_nointr);
87: pool_init(&fdesc_pool, sizeof(struct filedesc0), 0, 0, 0, "fdescpl",
88: &pool_allocator_nointr);
89: LIST_INIT(&filehead);
90: }
91:
92: static __inline int
93: find_next_zero (u_int *bitmap, int want, u_int bits)
94: {
95: int i, off, maxoff;
96: u_int sub;
97:
98: if (want > bits)
99: return -1;
100:
101: off = want >> NDENTRYSHIFT;
102: i = want & NDENTRYMASK;
103: if (i) {
104: sub = bitmap[off] | ((u_int)~0 >> (NDENTRIES - i));
105: if (sub != ~0)
106: goto found;
107: off++;
108: }
109:
110: maxoff = NDLOSLOTS(bits);
111: while (off < maxoff) {
112: if ((sub = bitmap[off]) != ~0)
113: goto found;
114: off++;
115: }
116:
117: return -1;
118:
119: found:
120: return (off << NDENTRYSHIFT) + ffs(~sub) - 1;
121: }
122:
123: int
124: find_last_set(struct filedesc *fd, int last)
125: {
126: int off, i;
127: struct file **ofiles = fd->fd_ofiles;
128: u_int *bitmap = fd->fd_lomap;
129:
130: off = (last - 1) >> NDENTRYSHIFT;
131:
132: while (off >= 0 && !bitmap[off])
133: off--;
134: if (off < 0)
135: return 0;
136:
137: i = ((off + 1) << NDENTRYSHIFT) - 1;
138: if (i >= last)
139: i = last - 1;
140:
141: while (i > 0 && ofiles[i] == NULL)
142: i--;
143: return i;
144: }
145:
146: static __inline void
147: fd_used(struct filedesc *fdp, int fd)
148: {
149: u_int off = fd >> NDENTRYSHIFT;
150:
151: fdp->fd_lomap[off] |= 1 << (fd & NDENTRYMASK);
152: if (fdp->fd_lomap[off] == ~0)
153: fdp->fd_himap[off >> NDENTRYSHIFT] |= 1 << (off & NDENTRYMASK);
154:
155: if (fd > fdp->fd_lastfile)
156: fdp->fd_lastfile = fd;
157: }
158:
159: static __inline void
160: fd_unused(struct filedesc *fdp, int fd)
161: {
162: u_int off = fd >> NDENTRYSHIFT;
163:
164: if (fd < fdp->fd_freefile)
165: fdp->fd_freefile = fd;
166:
167: if (fdp->fd_lomap[off] == ~0)
168: fdp->fd_himap[off >> NDENTRYSHIFT] &= ~(1 << (off & NDENTRYMASK));
169: fdp->fd_lomap[off] &= ~(1 << (fd & NDENTRYMASK));
170:
171: #ifdef DIAGNOSTIC
172: if (fd > fdp->fd_lastfile)
173: panic("fd_unused: fd_lastfile inconsistent");
174: #endif
175: if (fd == fdp->fd_lastfile)
176: fdp->fd_lastfile = find_last_set(fdp, fd);
177: }
178:
179: struct file *
180: fd_getfile(struct filedesc *fdp, int fd)
181: {
182: struct file *fp;
183:
184: if ((u_int)fd >= fdp->fd_nfiles || (fp = fdp->fd_ofiles[fd]) == NULL)
185: return (NULL);
186:
187: if (!FILE_IS_USABLE(fp))
188: return (NULL);
189:
190: return (fp);
191: }
192:
193: /*
194: * System calls on descriptors.
195: */
196:
197: /*
198: * Duplicate a file descriptor.
199: */
200: /* ARGSUSED */
201: int
202: sys_dup(struct proc *p, void *v, register_t *retval)
203: {
204: struct sys_dup_args /* {
205: syscallarg(int) fd;
206: } */ *uap = v;
207: struct filedesc *fdp = p->p_fd;
208: int old = SCARG(uap, fd);
209: struct file *fp;
210: int new;
211: int error;
212:
213: restart:
214: if ((fp = fd_getfile(fdp, old)) == NULL)
215: return (EBADF);
216: FREF(fp);
217: fdplock(fdp);
218: if ((error = fdalloc(p, 0, &new)) != 0) {
219: FRELE(fp);
220: if (error == ENOSPC) {
221: fdexpand(p);
222: fdpunlock(fdp);
223: goto restart;
224: }
225: goto out;
226: }
227: error = finishdup(p, fp, old, new, retval);
228:
229: out:
230: fdpunlock(fdp);
231: return (error);
232: }
233:
234: /*
235: * Duplicate a file descriptor to a particular value.
236: */
237: /* ARGSUSED */
238: int
239: sys_dup2(struct proc *p, void *v, register_t *retval)
240: {
241: struct sys_dup2_args /* {
242: syscallarg(int) from;
243: syscallarg(int) to;
244: } */ *uap = v;
245: int old = SCARG(uap, from), new = SCARG(uap, to);
246: struct filedesc *fdp = p->p_fd;
247: struct file *fp;
248: int i, error;
249:
250: restart:
251: if ((fp = fd_getfile(fdp, old)) == NULL)
252: return (EBADF);
253: if ((u_int)new >= p->p_rlimit[RLIMIT_NOFILE].rlim_cur ||
254: (u_int)new >= maxfiles)
255: return (EBADF);
256: if (old == new) {
257: /*
258: * NOTE! This doesn't clear the close-on-exec flag. This might
259: * or might not be the intended behavior from the start, but
260: * this is what everyone else does.
261: */
262: *retval = new;
263: return (0);
264: }
265: FREF(fp);
266: fdplock(fdp);
267: if (new >= fdp->fd_nfiles) {
268: if ((error = fdalloc(p, new, &i)) != 0) {
269: FRELE(fp);
270: if (error == ENOSPC) {
271: fdexpand(p);
272: fdpunlock(fdp);
273: goto restart;
274: }
275: goto out;
276: }
277: if (new != i)
278: panic("dup2: fdalloc");
279: }
280: /* finishdup() does FRELE */
281: error = finishdup(p, fp, old, new, retval);
282:
283: out:
284: fdpunlock(fdp);
285: return (error);
286: }
287:
288: /*
289: * The file control system call.
290: */
291: /* ARGSUSED */
292: int
293: sys_fcntl(struct proc *p, void *v, register_t *retval)
294: {
295: struct sys_fcntl_args /* {
296: syscallarg(int) fd;
297: syscallarg(int) cmd;
298: syscallarg(void *) arg;
299: } */ *uap = v;
300: int fd = SCARG(uap, fd);
301: struct filedesc *fdp = p->p_fd;
302: struct file *fp;
303: struct vnode *vp;
304: int i, tmp, newmin, flg = F_POSIX;
305: struct flock fl;
306: int error = 0;
307:
308: restart:
309: if ((fp = fd_getfile(fdp, fd)) == NULL)
310: return (EBADF);
311: FREF(fp);
312: switch (SCARG(uap, cmd)) {
313:
314: case F_DUPFD:
315: newmin = (long)SCARG(uap, arg);
316: if ((u_int)newmin >= p->p_rlimit[RLIMIT_NOFILE].rlim_cur ||
317: (u_int)newmin >= maxfiles) {
318: error = EINVAL;
319: break;
320: }
321: fdplock(fdp);
322: if ((error = fdalloc(p, newmin, &i)) != 0) {
323: if (error == ENOSPC) {
324: fdexpand(p);
325: FRELE(fp);
326: fdpunlock(fdp);
327: goto restart;
328: }
329: }
330: /* finishdup will FRELE for us. */
331: if (!error)
332: error = finishdup(p, fp, fd, i, retval);
333: else
334: FRELE(fp);
335:
336: fdpunlock(fdp);
337: return (error);
338:
339: case F_GETFD:
340: *retval = fdp->fd_ofileflags[fd] & UF_EXCLOSE ? 1 : 0;
341: break;
342:
343: case F_SETFD:
344: if ((long)SCARG(uap, arg) & 1)
345: fdp->fd_ofileflags[fd] |= UF_EXCLOSE;
346: else
347: fdp->fd_ofileflags[fd] &= ~UF_EXCLOSE;
348: break;
349:
350: case F_GETFL:
351: *retval = OFLAGS(fp->f_flag);
352: break;
353:
354: case F_SETFL:
355: fp->f_flag &= ~FCNTLFLAGS;
356: fp->f_flag |= FFLAGS((long)SCARG(uap, arg)) & FCNTLFLAGS;
357: tmp = fp->f_flag & FNONBLOCK;
358: error = (*fp->f_ops->fo_ioctl)(fp, FIONBIO, (caddr_t)&tmp, p);
359: if (error)
360: break;
361: tmp = fp->f_flag & FASYNC;
362: error = (*fp->f_ops->fo_ioctl)(fp, FIOASYNC, (caddr_t)&tmp, p);
363: if (!error)
364: break;
365: fp->f_flag &= ~FNONBLOCK;
366: tmp = 0;
367: (void) (*fp->f_ops->fo_ioctl)(fp, FIONBIO, (caddr_t)&tmp, p);
368: break;
369:
370: case F_GETOWN:
371: if (fp->f_type == DTYPE_SOCKET) {
372: *retval = ((struct socket *)fp->f_data)->so_pgid;
373: break;
374: }
375: error = (*fp->f_ops->fo_ioctl)
376: (fp, TIOCGPGRP, (caddr_t)&tmp, p);
377: *retval = -tmp;
378: break;
379:
380: case F_SETOWN:
381: if (fp->f_type == DTYPE_SOCKET) {
382: struct socket *so = (struct socket *)fp->f_data;
383:
384: so->so_pgid = (long)SCARG(uap, arg);
385: so->so_siguid = p->p_cred->p_ruid;
386: so->so_sigeuid = p->p_ucred->cr_uid;
387: break;
388: }
389: if ((long)SCARG(uap, arg) <= 0) {
390: SCARG(uap, arg) = (void *)(-(long)SCARG(uap, arg));
391: } else {
392: struct proc *p1 = pfind((long)SCARG(uap, arg));
393: if (p1 == 0) {
394: error = ESRCH;
395: break;
396: }
397: SCARG(uap, arg) = (void *)(long)p1->p_pgrp->pg_id;
398: }
399: error = ((*fp->f_ops->fo_ioctl)
400: (fp, TIOCSPGRP, (caddr_t)&SCARG(uap, arg), p));
401: break;
402:
403: case F_SETLKW:
404: flg |= F_WAIT;
405: /* FALLTHROUGH */
406:
407: case F_SETLK:
408: if (fp->f_type != DTYPE_VNODE) {
409: error = EBADF;
410: break;
411: }
412: vp = (struct vnode *)fp->f_data;
413: /* Copy in the lock structure */
414: error = copyin((caddr_t)SCARG(uap, arg), (caddr_t)&fl,
415: sizeof (fl));
416: if (error)
417: break;
418: if (fl.l_whence == SEEK_CUR) {
419: if (fl.l_start == 0 && fl.l_len < 0) {
420: /* lockf(3) compliance hack */
421: fl.l_len = -fl.l_len;
422: fl.l_start = fp->f_offset - fl.l_len;
423: } else
424: fl.l_start += fp->f_offset;
425: }
426: switch (fl.l_type) {
427:
428: case F_RDLCK:
429: if ((fp->f_flag & FREAD) == 0) {
430: error = EBADF;
431: goto out;
432: }
433: atomic_setbits_int(&p->p_flag, P_ADVLOCK);
434: error = (VOP_ADVLOCK(vp, (caddr_t)p, F_SETLK, &fl, flg));
435: goto out;
436:
437: case F_WRLCK:
438: if ((fp->f_flag & FWRITE) == 0) {
439: error = EBADF;
440: goto out;
441: }
442: atomic_setbits_int(&p->p_flag, P_ADVLOCK);
443: error = (VOP_ADVLOCK(vp, (caddr_t)p, F_SETLK, &fl, flg));
444: goto out;
445:
446: case F_UNLCK:
447: error = (VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &fl,
448: F_POSIX));
449: goto out;
450:
451: default:
452: error = EINVAL;
453: goto out;
454: }
455:
456: case F_GETLK:
457: if (fp->f_type != DTYPE_VNODE) {
458: error = EBADF;
459: break;
460: }
461: vp = (struct vnode *)fp->f_data;
462: /* Copy in the lock structure */
463: error = copyin((caddr_t)SCARG(uap, arg), (caddr_t)&fl,
464: sizeof (fl));
465: if (error)
466: break;
467: if (fl.l_whence == SEEK_CUR) {
468: if (fl.l_start == 0 && fl.l_len < 0) {
469: /* lockf(3) compliance hack */
470: fl.l_len = -fl.l_len;
471: fl.l_start = fp->f_offset - fl.l_len;
472: } else
473: fl.l_start += fp->f_offset;
474: }
475: if (fl.l_type != F_RDLCK &&
476: fl.l_type != F_WRLCK &&
477: fl.l_type != F_UNLCK &&
478: fl.l_type != 0) {
479: error = EINVAL;
480: break;
481: }
482: error = VOP_ADVLOCK(vp, (caddr_t)p, F_GETLK, &fl, F_POSIX);
483: if (error)
484: break;
485: error = (copyout((caddr_t)&fl, (caddr_t)SCARG(uap, arg),
486: sizeof (fl)));
487: break;
488:
489: default:
490: error = EINVAL;
491: break;
492: }
493: out:
494: FRELE(fp);
495: return (error);
496: }
497:
498: /*
499: * Common code for dup, dup2, and fcntl(F_DUPFD).
500: */
501: int
502: finishdup(struct proc *p, struct file *fp, int old, int new, register_t *retval)
503: {
504: struct file *oldfp;
505: struct filedesc *fdp = p->p_fd;
506:
507: if (fp->f_count == LONG_MAX-2) {
508: FRELE(fp);
509: return (EDEADLK);
510: }
511:
512: /*
513: * Don't fd_getfile here. We want to closef LARVAL files and
514: * closef can deal with that.
515: */
516: oldfp = fdp->fd_ofiles[new];
517: if (oldfp != NULL)
518: FREF(oldfp);
519:
520: fdp->fd_ofiles[new] = fp;
521: fdp->fd_ofileflags[new] = fdp->fd_ofileflags[old] & ~UF_EXCLOSE;
522: fp->f_count++;
523: FRELE(fp);
524: if (oldfp == NULL)
525: fd_used(fdp, new);
526: *retval = new;
527:
528: if (oldfp != NULL) {
529: if (new < fdp->fd_knlistsize)
530: knote_fdclose(p, new);
531: closef(oldfp, p);
532: }
533:
534: return (0);
535: }
536:
537: void
538: fdremove(struct filedesc *fdp, int fd)
539: {
540: fdp->fd_ofiles[fd] = NULL;
541: fd_unused(fdp, fd);
542: }
543:
544: int
545: fdrelease(struct proc *p, int fd)
546: {
547: struct filedesc *fdp = p->p_fd;
548: struct file **fpp, *fp;
549:
550: /*
551: * Don't fd_getfile here. We want to closef LARVAL files and closef
552: * can deal with that.
553: */
554: fpp = &fdp->fd_ofiles[fd];
555: fp = *fpp;
556: if (fp == NULL)
557: return (EBADF);
558: FREF(fp);
559: *fpp = NULL;
560: fdp->fd_ofileflags[fd] = 0;
561: fd_unused(fdp, fd);
562: if (fd < fdp->fd_knlistsize)
563: knote_fdclose(p, fd);
564: return (closef(fp, p));
565: }
566:
567: /*
568: * Close a file descriptor.
569: */
570: /* ARGSUSED */
571: int
572: sys_close(struct proc *p, void *v, register_t *retval)
573: {
574: struct sys_close_args /* {
575: syscallarg(int) fd;
576: } */ *uap = v;
577: int fd = SCARG(uap, fd), error;
578: struct filedesc *fdp = p->p_fd;
579:
580: if (fd_getfile(fdp, fd) == NULL)
581: return (EBADF);
582: fdplock(fdp);
583: error = fdrelease(p, fd);
584: fdpunlock(fdp);
585:
586: return (error);
587: }
588:
589: /*
590: * Return status information about a file descriptor.
591: */
592: /* ARGSUSED */
593: int
594: sys_fstat(struct proc *p, void *v, register_t *retval)
595: {
596: struct sys_fstat_args /* {
597: syscallarg(int) fd;
598: syscallarg(struct stat *) sb;
599: } */ *uap = v;
600: int fd = SCARG(uap, fd);
601: struct filedesc *fdp = p->p_fd;
602: struct file *fp;
603: struct stat ub;
604: int error;
605:
606: if ((fp = fd_getfile(fdp, fd)) == NULL)
607: return (EBADF);
608: FREF(fp);
609: error = (*fp->f_ops->fo_stat)(fp, &ub, p);
610: FRELE(fp);
611: if (error == 0) {
612: /*
613: * Don't let non-root see generation numbers
614: * (for NFS security)
615: */
616: if (suser(p, 0))
617: ub.st_gen = 0;
618: error = copyout((caddr_t)&ub, (caddr_t)SCARG(uap, sb),
619: sizeof (ub));
620: }
621: return (error);
622: }
623:
624: /*
625: * Return pathconf information about a file descriptor.
626: */
627: /* ARGSUSED */
628: int
629: sys_fpathconf(struct proc *p, void *v, register_t *retval)
630: {
631: struct sys_fpathconf_args /* {
632: syscallarg(int) fd;
633: syscallarg(int) name;
634: } */ *uap = v;
635: int fd = SCARG(uap, fd);
636: struct filedesc *fdp = p->p_fd;
637: struct file *fp;
638: struct vnode *vp;
639: int error;
640:
641: if ((fp = fd_getfile(fdp, fd)) == NULL)
642: return (EBADF);
643: FREF(fp);
644: switch (fp->f_type) {
645: case DTYPE_PIPE:
646: case DTYPE_SOCKET:
647: if (SCARG(uap, name) != _PC_PIPE_BUF) {
648: error = EINVAL;
649: break;
650: }
651: *retval = PIPE_BUF;
652: error = 0;
653: break;
654:
655: case DTYPE_VNODE:
656: vp = (struct vnode *)fp->f_data;
657: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
658: error = VOP_PATHCONF(vp, SCARG(uap, name), retval);
659: VOP_UNLOCK(vp, 0, p);
660: break;
661:
662: default:
663: error = EOPNOTSUPP;
664: break;
665: }
666: FRELE(fp);
667: return (error);
668: }
669:
670: /*
671: * Allocate a file descriptor for the process.
672: */
673: int
674: fdalloc(struct proc *p, int want, int *result)
675: {
676: struct filedesc *fdp = p->p_fd;
677: int lim, last, i;
678: u_int new, off;
679:
680: /*
681: * Search for a free descriptor starting at the higher
682: * of want or fd_freefile. If that fails, consider
683: * expanding the ofile array.
684: */
685: restart:
686: lim = min((int)p->p_rlimit[RLIMIT_NOFILE].rlim_cur, maxfiles);
687: last = min(fdp->fd_nfiles, lim);
688: if ((i = want) < fdp->fd_freefile)
689: i = fdp->fd_freefile;
690: off = i >> NDENTRYSHIFT;
691: new = find_next_zero(fdp->fd_himap, off,
692: (last + NDENTRIES - 1) >> NDENTRYSHIFT);
693: if (new != -1) {
694: i = find_next_zero(&fdp->fd_lomap[new],
695: new > off ? 0 : i & NDENTRYMASK,
696: NDENTRIES);
697: if (i == -1) {
698: /*
699: * Free file descriptor in this block was
700: * below want, try again with higher want.
701: */
702: want = (new + 1) << NDENTRYSHIFT;
703: goto restart;
704: }
705: i += (new << NDENTRYSHIFT);
706: if (i < last) {
707: fd_used(fdp, i);
708: if (want <= fdp->fd_freefile)
709: fdp->fd_freefile = i;
710: *result = i;
711: return (0);
712: }
713: }
714: if (fdp->fd_nfiles >= lim)
715: return (EMFILE);
716:
717: return (ENOSPC);
718: }
719:
720: void
721: fdexpand(struct proc *p)
722: {
723: struct filedesc *fdp = p->p_fd;
724: int nfiles, i;
725: struct file **newofile;
726: char *newofileflags;
727: u_int *newhimap, *newlomap;
728:
729: /*
730: * No space in current array.
731: */
732: if (fdp->fd_nfiles < NDEXTENT)
733: nfiles = NDEXTENT;
734: else
735: nfiles = 2 * fdp->fd_nfiles;
736:
737: newofile = malloc(nfiles * OFILESIZE, M_FILEDESC, M_WAITOK);
738: newofileflags = (char *) &newofile[nfiles];
739:
740: /*
741: * Copy the existing ofile and ofileflags arrays
742: * and zero the new portion of each array.
743: */
744: bcopy(fdp->fd_ofiles, newofile,
745: (i = sizeof(struct file *) * fdp->fd_nfiles));
746: bzero((char *)newofile + i, nfiles * sizeof(struct file *) - i);
747: bcopy(fdp->fd_ofileflags, newofileflags,
748: (i = sizeof(char) * fdp->fd_nfiles));
749: bzero(newofileflags + i, nfiles * sizeof(char) - i);
750:
751: if (fdp->fd_nfiles > NDFILE)
752: free(fdp->fd_ofiles, M_FILEDESC);
753:
754: if (NDHISLOTS(nfiles) > NDHISLOTS(fdp->fd_nfiles)) {
755: newhimap = malloc(NDHISLOTS(nfiles) * sizeof(u_int),
756: M_FILEDESC, M_WAITOK);
757: newlomap = malloc(NDLOSLOTS(nfiles) * sizeof(u_int),
758: M_FILEDESC, M_WAITOK);
759:
760: bcopy(fdp->fd_himap, newhimap,
761: (i = NDHISLOTS(fdp->fd_nfiles) * sizeof(u_int)));
762: bzero((char *)newhimap + i,
763: NDHISLOTS(nfiles) * sizeof(u_int) - i);
764:
765: bcopy(fdp->fd_lomap, newlomap,
766: (i = NDLOSLOTS(fdp->fd_nfiles) * sizeof(u_int)));
767: bzero((char *)newlomap + i,
768: NDLOSLOTS(nfiles) * sizeof(u_int) - i);
769:
770: if (NDHISLOTS(fdp->fd_nfiles) > NDHISLOTS(NDFILE)) {
771: free(fdp->fd_himap, M_FILEDESC);
772: free(fdp->fd_lomap, M_FILEDESC);
773: }
774: fdp->fd_himap = newhimap;
775: fdp->fd_lomap = newlomap;
776: }
777: fdp->fd_ofiles = newofile;
778: fdp->fd_ofileflags = newofileflags;
779: fdp->fd_nfiles = nfiles;
780: }
781:
782: /*
783: * Create a new open file structure and allocate
784: * a file descriptor for the process that refers to it.
785: */
786: int
787: falloc(struct proc *p, struct file **resultfp, int *resultfd)
788: {
789: struct file *fp, *fq;
790: int error, i;
791:
792: restart:
793: if ((error = fdalloc(p, 0, &i)) != 0) {
794: if (error == ENOSPC) {
795: fdexpand(p);
796: goto restart;
797: }
798: return (error);
799: }
800: if (nfiles >= maxfiles) {
801: fd_unused(p->p_fd, i);
802: tablefull("file");
803: return (ENFILE);
804: }
805: /*
806: * Allocate a new file descriptor.
807: * If the process has file descriptor zero open, add to the list
808: * of open files at that point, otherwise put it at the front of
809: * the list of open files.
810: */
811: nfiles++;
812: fp = pool_get(&file_pool, PR_WAITOK);
813: bzero(fp, sizeof(struct file));
814: fp->f_iflags = FIF_LARVAL;
815: if ((fq = p->p_fd->fd_ofiles[0]) != NULL) {
816: LIST_INSERT_AFTER(fq, fp, f_list);
817: } else {
818: LIST_INSERT_HEAD(&filehead, fp, f_list);
819: }
820: p->p_fd->fd_ofiles[i] = fp;
821: fp->f_count = 1;
822: fp->f_cred = p->p_ucred;
823: crhold(fp->f_cred);
824: if (resultfp)
825: *resultfp = fp;
826: if (resultfd)
827: *resultfd = i;
828: FREF(fp);
829: return (0);
830: }
831:
832: /*
833: * Build a new filedesc structure.
834: */
835: struct filedesc *
836: fdinit(struct proc *p)
837: {
838: struct filedesc0 *newfdp;
839: extern int cmask;
840:
841: newfdp = pool_get(&fdesc_pool, PR_WAITOK);
842: bzero(newfdp, sizeof(struct filedesc0));
843: if (p != NULL) {
844: struct filedesc *fdp = p->p_fd;
845:
846: newfdp->fd_fd.fd_cdir = fdp->fd_cdir;
847: VREF(newfdp->fd_fd.fd_cdir);
848: newfdp->fd_fd.fd_rdir = fdp->fd_rdir;
849: if (newfdp->fd_fd.fd_rdir)
850: VREF(newfdp->fd_fd.fd_rdir);
851: }
852: rw_init(&newfdp->fd_fd.fd_lock, "fdlock");
853:
854: /* Create the file descriptor table. */
855: newfdp->fd_fd.fd_refcnt = 1;
856: newfdp->fd_fd.fd_cmask = cmask;
857: newfdp->fd_fd.fd_ofiles = newfdp->fd_dfiles;
858: newfdp->fd_fd.fd_ofileflags = newfdp->fd_dfileflags;
859: newfdp->fd_fd.fd_nfiles = NDFILE;
860: newfdp->fd_fd.fd_himap = newfdp->fd_dhimap;
861: newfdp->fd_fd.fd_lomap = newfdp->fd_dlomap;
862: newfdp->fd_fd.fd_knlistsize = -1;
863:
864: newfdp->fd_fd.fd_freefile = 0;
865: newfdp->fd_fd.fd_lastfile = 0;
866:
867: return (&newfdp->fd_fd);
868: }
869:
870: /*
871: * Share a filedesc structure.
872: */
873: struct filedesc *
874: fdshare(struct proc *p)
875: {
876: p->p_fd->fd_refcnt++;
877: return (p->p_fd);
878: }
879:
880: /*
881: * Copy a filedesc structure.
882: */
883: struct filedesc *
884: fdcopy(struct proc *p)
885: {
886: struct filedesc *newfdp, *fdp = p->p_fd;
887: struct file **fpp;
888: int i;
889:
890: newfdp = pool_get(&fdesc_pool, PR_WAITOK);
891: bcopy(fdp, newfdp, sizeof(struct filedesc));
892: if (newfdp->fd_cdir)
893: VREF(newfdp->fd_cdir);
894: if (newfdp->fd_rdir)
895: VREF(newfdp->fd_rdir);
896: newfdp->fd_refcnt = 1;
897:
898: /*
899: * If the number of open files fits in the internal arrays
900: * of the open file structure, use them, otherwise allocate
901: * additional memory for the number of descriptors currently
902: * in use.
903: */
904: if (newfdp->fd_lastfile < NDFILE) {
905: newfdp->fd_ofiles = ((struct filedesc0 *) newfdp)->fd_dfiles;
906: newfdp->fd_ofileflags =
907: ((struct filedesc0 *) newfdp)->fd_dfileflags;
908: i = NDFILE;
909: } else {
910: /*
911: * Compute the smallest multiple of NDEXTENT needed
912: * for the file descriptors currently in use,
913: * allowing the table to shrink.
914: */
915: i = newfdp->fd_nfiles;
916: while (i >= 2 * NDEXTENT && i > newfdp->fd_lastfile * 2)
917: i /= 2;
918: newfdp->fd_ofiles = malloc(i * OFILESIZE, M_FILEDESC, M_WAITOK);
919: newfdp->fd_ofileflags = (char *) &newfdp->fd_ofiles[i];
920: }
921: if (NDHISLOTS(i) <= NDHISLOTS(NDFILE)) {
922: newfdp->fd_himap =
923: ((struct filedesc0 *) newfdp)->fd_dhimap;
924: newfdp->fd_lomap =
925: ((struct filedesc0 *) newfdp)->fd_dlomap;
926: } else {
927: newfdp->fd_himap = malloc(NDHISLOTS(i) * sizeof(u_int),
928: M_FILEDESC, M_WAITOK);
929: newfdp->fd_lomap = malloc(NDLOSLOTS(i) * sizeof(u_int),
930: M_FILEDESC, M_WAITOK);
931: }
932: newfdp->fd_nfiles = i;
933: bcopy(fdp->fd_ofiles, newfdp->fd_ofiles, i * sizeof(struct file **));
934: bcopy(fdp->fd_ofileflags, newfdp->fd_ofileflags, i * sizeof(char));
935: bcopy(fdp->fd_himap, newfdp->fd_himap, NDHISLOTS(i) * sizeof(u_int));
936: bcopy(fdp->fd_lomap, newfdp->fd_lomap, NDLOSLOTS(i) * sizeof(u_int));
937:
938: /*
939: * kq descriptors cannot be copied.
940: */
941: if (newfdp->fd_knlistsize != -1) {
942: fpp = newfdp->fd_ofiles;
943: for (i = 0; i <= newfdp->fd_lastfile; i++, fpp++)
944: if (*fpp != NULL && (*fpp)->f_type == DTYPE_KQUEUE)
945: fdremove(newfdp, i);
946: newfdp->fd_knlist = NULL;
947: newfdp->fd_knlistsize = -1;
948: newfdp->fd_knhash = NULL;
949: newfdp->fd_knhashmask = 0;
950: }
951:
952: fpp = newfdp->fd_ofiles;
953: for (i = 0; i <= newfdp->fd_lastfile; i++, fpp++)
954: if (*fpp != NULL) {
955: /*
956: * XXX Gruesome hack. If count gets too high, fail
957: * to copy an fd, since fdcopy()'s callers do not
958: * permit it to indicate failure yet.
959: */
960: if ((*fpp)->f_count == LONG_MAX-2)
961: fdremove(newfdp, i);
962: else
963: (*fpp)->f_count++;
964: }
965: return (newfdp);
966: }
967:
968: /*
969: * Release a filedesc structure.
970: */
971: void
972: fdfree(struct proc *p)
973: {
974: struct filedesc *fdp = p->p_fd;
975: struct file **fpp, *fp;
976: int i;
977:
978: if (--fdp->fd_refcnt > 0)
979: return;
980: fpp = fdp->fd_ofiles;
981: for (i = fdp->fd_lastfile; i >= 0; i--, fpp++) {
982: fp = *fpp;
983: if (fp != NULL) {
984: FREF(fp);
985: *fpp = NULL;
986: (void) closef(fp, p);
987: }
988: }
989: p->p_fd = NULL;
990: if (fdp->fd_nfiles > NDFILE)
991: free(fdp->fd_ofiles, M_FILEDESC);
992: if (NDHISLOTS(fdp->fd_nfiles) > NDHISLOTS(NDFILE)) {
993: free(fdp->fd_himap, M_FILEDESC);
994: free(fdp->fd_lomap, M_FILEDESC);
995: }
996: if (fdp->fd_cdir)
997: vrele(fdp->fd_cdir);
998: if (fdp->fd_rdir)
999: vrele(fdp->fd_rdir);
1000: if (fdp->fd_knlist)
1001: FREE(fdp->fd_knlist, M_TEMP);
1002: if (fdp->fd_knhash)
1003: FREE(fdp->fd_knhash, M_TEMP);
1004: pool_put(&fdesc_pool, fdp);
1005: }
1006:
1007: /*
1008: * Internal form of close.
1009: * Decrement reference count on file structure.
1010: * Note: p may be NULL when closing a file
1011: * that was being passed in a message.
1012: *
1013: * The fp must have its usecount bumped and will be FRELEd here.
1014: */
1015: int
1016: closef(struct file *fp, struct proc *p)
1017: {
1018: struct vnode *vp;
1019: struct flock lf;
1020: int error;
1021:
1022: if (fp == NULL)
1023: return (0);
1024:
1025: /*
1026: * POSIX record locking dictates that any close releases ALL
1027: * locks owned by this process. This is handled by setting
1028: * a flag in the unlock to free ONLY locks obeying POSIX
1029: * semantics, and not to free BSD-style file locks.
1030: * If the descriptor was in a message, POSIX-style locks
1031: * aren't passed with the descriptor.
1032: */
1033: if (p && (p->p_flag & P_ADVLOCK) && fp->f_type == DTYPE_VNODE) {
1034: lf.l_whence = SEEK_SET;
1035: lf.l_start = 0;
1036: lf.l_len = 0;
1037: lf.l_type = F_UNLCK;
1038: vp = (struct vnode *)fp->f_data;
1039: (void) VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &lf, F_POSIX);
1040: }
1041:
1042: /*
1043: * Some files passed to this function could be accessed
1044: * without a FILE_IS_USABLE check (and in some cases it's perfectly
1045: * legal), we must beware of files where someone already won the
1046: * race to FIF_WANTCLOSE.
1047: */
1048: if ((fp->f_iflags & FIF_WANTCLOSE) != 0) {
1049: FRELE(fp);
1050: return (0);
1051: }
1052:
1053: if (--fp->f_count > 0) {
1054: FRELE(fp);
1055: return (0);
1056: }
1057:
1058: #ifdef DIAGNOSTIC
1059: if (fp->f_count < 0)
1060: panic("closef: count < 0");
1061: #endif
1062:
1063: /* Wait for the last usecount to drain. */
1064: fp->f_iflags |= FIF_WANTCLOSE;
1065: while (fp->f_usecount > 1)
1066: tsleep(&fp->f_usecount, PRIBIO, "closef", 0);
1067:
1068: if ((fp->f_flag & FHASLOCK) && fp->f_type == DTYPE_VNODE) {
1069: lf.l_whence = SEEK_SET;
1070: lf.l_start = 0;
1071: lf.l_len = 0;
1072: lf.l_type = F_UNLCK;
1073: vp = (struct vnode *)fp->f_data;
1074: (void) VOP_ADVLOCK(vp, (caddr_t)fp, F_UNLCK, &lf, F_FLOCK);
1075: }
1076: if (fp->f_ops)
1077: error = (*fp->f_ops->fo_close)(fp, p);
1078: else
1079: error = 0;
1080:
1081: /* Free fp */
1082: LIST_REMOVE(fp, f_list);
1083: crfree(fp->f_cred);
1084: #ifdef DIAGNOSTIC
1085: if (fp->f_count != 0 || fp->f_usecount != 1)
1086: panic("closef: count: %d/%d", fp->f_count, fp->f_usecount);
1087: #endif
1088: nfiles--;
1089: pool_put(&file_pool, fp);
1090:
1091: return (error);
1092: }
1093:
1094: /*
1095: * Apply an advisory lock on a file descriptor.
1096: *
1097: * Just attempt to get a record lock of the requested type on
1098: * the entire file (l_whence = SEEK_SET, l_start = 0, l_len = 0).
1099: */
1100: /* ARGSUSED */
1101: int
1102: sys_flock(struct proc *p, void *v, register_t *retval)
1103: {
1104: struct sys_flock_args /* {
1105: syscallarg(int) fd;
1106: syscallarg(int) how;
1107: } */ *uap = v;
1108: int fd = SCARG(uap, fd);
1109: int how = SCARG(uap, how);
1110: struct filedesc *fdp = p->p_fd;
1111: struct file *fp;
1112: struct vnode *vp;
1113: struct flock lf;
1114: int error;
1115:
1116: if ((fp = fd_getfile(fdp, fd)) == NULL)
1117: return (EBADF);
1118: if (fp->f_type != DTYPE_VNODE)
1119: return (EOPNOTSUPP);
1120: vp = (struct vnode *)fp->f_data;
1121: lf.l_whence = SEEK_SET;
1122: lf.l_start = 0;
1123: lf.l_len = 0;
1124: if (how & LOCK_UN) {
1125: lf.l_type = F_UNLCK;
1126: fp->f_flag &= ~FHASLOCK;
1127: error = VOP_ADVLOCK(vp, (caddr_t)fp, F_UNLCK, &lf, F_FLOCK);
1128: goto out;
1129: }
1130: if (how & LOCK_EX)
1131: lf.l_type = F_WRLCK;
1132: else if (how & LOCK_SH)
1133: lf.l_type = F_RDLCK;
1134: else {
1135: error = EINVAL;
1136: goto out;
1137: }
1138: fp->f_flag |= FHASLOCK;
1139: if (how & LOCK_NB)
1140: error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, F_FLOCK);
1141: else
1142: error = VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, F_FLOCK|F_WAIT);
1143: out:
1144: return (error);
1145: }
1146:
1147: /*
1148: * File Descriptor pseudo-device driver (/dev/fd/).
1149: *
1150: * Opening minor device N dup()s the file (if any) connected to file
1151: * descriptor N belonging to the calling process. Note that this driver
1152: * consists of only the ``open()'' routine, because all subsequent
1153: * references to this file will be direct to the other driver.
1154: */
1155: /* ARGSUSED */
1156: int
1157: filedescopen(dev_t dev, int mode, int type, struct proc *p)
1158: {
1159:
1160: /*
1161: * XXX Kludge: set curproc->p_dupfd to contain the value of the
1162: * the file descriptor being sought for duplication. The error
1163: * return ensures that the vnode for this device will be released
1164: * by vn_open. Open will detect this special error and take the
1165: * actions in dupfdopen below. Other callers of vn_open or VOP_OPEN
1166: * will simply report the error.
1167: */
1168: p->p_dupfd = minor(dev);
1169: return (ENODEV);
1170: }
1171:
1172: /*
1173: * Duplicate the specified descriptor to a free descriptor.
1174: */
1175: int
1176: dupfdopen(struct filedesc *fdp, int indx, int dfd, int mode, int error)
1177: {
1178: struct file *wfp;
1179:
1180: /*
1181: * Assume that the filename was user-specified; applications do
1182: * not tend to open /dev/fd/# when they can just call dup()
1183: */
1184: if ((curproc->p_flag & (P_SUGIDEXEC | P_SUGID))) {
1185: if (curproc->p_descfd == 255)
1186: return (EPERM);
1187: if (curproc->p_descfd != curproc->p_dupfd)
1188: return (EPERM);
1189: }
1190:
1191: /*
1192: * If the to-be-dup'd fd number is greater than the allowed number
1193: * of file descriptors, or the fd to be dup'd has already been
1194: * closed, reject. Note, there is no need to check for new == old
1195: * because fd_getfile will return NULL if the file at indx is
1196: * newly created by falloc (FIF_LARVAL).
1197: */
1198: if ((wfp = fd_getfile(fdp, dfd)) == NULL)
1199: return (EBADF);
1200:
1201: /*
1202: * There are two cases of interest here.
1203: *
1204: * For ENODEV simply dup (dfd) to file descriptor
1205: * (indx) and return.
1206: *
1207: * For ENXIO steal away the file structure from (dfd) and
1208: * store it in (indx). (dfd) is effectively closed by
1209: * this operation.
1210: *
1211: * Any other error code is just returned.
1212: */
1213: switch (error) {
1214: case ENODEV:
1215: /*
1216: * Check that the mode the file is being opened for is a
1217: * subset of the mode of the existing descriptor.
1218: */
1219: if (((mode & (FREAD|FWRITE)) | wfp->f_flag) != wfp->f_flag)
1220: return (EACCES);
1221: if (wfp->f_count == LONG_MAX-2)
1222: return (EDEADLK);
1223: fdp->fd_ofiles[indx] = wfp;
1224: fdp->fd_ofileflags[indx] = fdp->fd_ofileflags[dfd];
1225: wfp->f_count++;
1226: fd_used(fdp, indx);
1227: return (0);
1228:
1229: case ENXIO:
1230: /*
1231: * Steal away the file pointer from dfd, and stuff it into indx.
1232: */
1233: fdp->fd_ofiles[indx] = fdp->fd_ofiles[dfd];
1234: fdp->fd_ofileflags[indx] = fdp->fd_ofileflags[dfd];
1235: fdp->fd_ofiles[dfd] = NULL;
1236: fdp->fd_ofileflags[dfd] = 0;
1237: /*
1238: * Complete the clean up of the filedesc structure by
1239: * recomputing the various hints.
1240: */
1241: fd_used(fdp, indx);
1242: fd_unused(fdp, dfd);
1243: return (0);
1244:
1245: default:
1246: return (error);
1247: }
1248: /* NOTREACHED */
1249: }
1250:
1251: /*
1252: * Close any files on exec?
1253: */
1254: void
1255: fdcloseexec(struct proc *p)
1256: {
1257: struct filedesc *fdp = p->p_fd;
1258: int fd;
1259:
1260: for (fd = 0; fd <= fdp->fd_lastfile; fd++)
1261: if (fdp->fd_ofileflags[fd] & UF_EXCLOSE)
1262: (void) fdrelease(p, fd);
1263: }
1264:
1265: int
1266: sys_closefrom(struct proc *p, void *v, register_t *retval)
1267: {
1268: struct sys_closefrom_args *uap = v;
1269: struct filedesc *fdp = p->p_fd;
1270: u_int startfd, i;
1271:
1272: startfd = SCARG(uap, fd);
1273: fdplock(fdp);
1274:
1275: if (startfd > fdp->fd_lastfile) {
1276: fdpunlock(fdp);
1277: return (EBADF);
1278: }
1279:
1280: for (i = startfd; i <= fdp->fd_lastfile; i++)
1281: fdrelease(p, i);
1282:
1283: fdpunlock(fdp);
1284: return (0);
1285: }