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