![[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 [Net/2] / Net2 / kern|
Return to kern_descrip.c CVS log | Up to [Net/2] / Net2 / kern |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986, 1989, 1991 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: * 3. All advertising materials mentioning features or use of this software
14: * must display the following acknowledgement:
15: * This product includes software developed by the University of
16: * California, Berkeley and its contributors.
17: * 4. Neither the name of the University nor the names of its contributors
18: * may be used to endorse or promote products derived from this software
19: * without specific prior written permission.
20: *
21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31: * SUCH DAMAGE.
32: *
33: * @(#)kern_descrip.c 7.28 (Berkeley) 6/25/91
34: */
35:
36: #include "param.h"
37: #include "systm.h"
38: #include "filedesc.h"
39: #include "kernel.h"
40: #include "vnode.h"
41: #include "proc.h"
42: #include "file.h"
43: #include "socket.h"
44: #include "socketvar.h"
45: #include "stat.h"
46: #include "ioctl.h"
47: #include "fcntl.h"
48: #include "malloc.h"
49: #include "syslog.h"
50: #include "resourcevar.h"
51:
52: /*
53: * Descriptor management.
54: */
55: struct file *filehead; /* head of list of open files */
56: int nfiles; /* actual number of open files */
57:
58: /*
59: * System calls on descriptors.
60: */
61: /* ARGSUSED */
62: getdtablesize(p, uap, retval)
63: struct proc *p;
64: struct args *uap;
65: int *retval;
66: {
67:
68: *retval = p->p_rlimit[RLIMIT_OFILE].rlim_cur;
69: return (0);
70: }
71:
72: /*
73: * Duplicate a file descriptor.
74: */
75: /* ARGSUSED */
76: dup(p, uap, retval)
77: struct proc *p;
78: struct args {
79: int i;
80: } *uap;
81: int *retval;
82: {
83: register struct filedesc *fdp = p->p_fd;
84: struct file *fp;
85: int fd, error;
86:
87: /*
88: * XXX Compatibility
89: */
90: if (uap->i &~ 077) { uap->i &= 077; return (dup2(p, uap, retval)); }
91:
92: if ((unsigned)uap->i >= fdp->fd_nfiles ||
93: (fp = fdp->fd_ofiles[uap->i]) == NULL)
94: return (EBADF);
95: if (error = fdalloc(p, 0, &fd))
96: return (error);
97: fdp->fd_ofiles[fd] = fp;
98: fdp->fd_ofileflags[fd] = fdp->fd_ofileflags[uap->i] &~ UF_EXCLOSE;
99: fp->f_count++;
100: if (fd > fdp->fd_lastfile)
101: fdp->fd_lastfile = fd;
102: *retval = fd;
103: return (0);
104: }
105:
106: /*
107: * Duplicate a file descriptor to a particular value.
108: */
109: /* ARGSUSED */
110: dup2(p, uap, retval)
111: struct proc *p;
112: struct args {
113: u_int from;
114: u_int to;
115: } *uap;
116: int *retval;
117: {
118: register struct filedesc *fdp = p->p_fd;
119: register struct file *fp;
120: register u_int old = uap->from, new = uap->to;
121: int i, error;
122:
123: if (old >= fdp->fd_nfiles ||
124: (fp = fdp->fd_ofiles[old]) == NULL ||
125: new >= p->p_rlimit[RLIMIT_OFILE].rlim_cur)
126: return (EBADF);
127: *retval = new;
128: if (old == new)
129: return (0);
130: if (new >= fdp->fd_nfiles) {
131: if (error = fdalloc(p, new, &i))
132: return (error);
133: if (new != i)
134: panic("dup2: fdalloc");
135: } else if (fdp->fd_ofiles[new]) {
136: if (fdp->fd_ofileflags[new] & UF_MAPPED)
137: (void) munmapfd(p, new);
138: /*
139: * dup2() must succeed even if the close has an error.
140: */
141: (void) closef(fdp->fd_ofiles[new], p);
142: }
143: fdp->fd_ofiles[new] = fp;
144: fdp->fd_ofileflags[new] = fdp->fd_ofileflags[old] &~ UF_EXCLOSE;
145: fp->f_count++;
146: if (new > fdp->fd_lastfile)
147: fdp->fd_lastfile = new;
148: return (0);
149: }
150:
151: /*
152: * The file control system call.
153: */
154: /* ARGSUSED */
155: fcntl(p, uap, retval)
156: struct proc *p;
157: register struct args {
158: int fd;
159: int cmd;
160: int arg;
161: } *uap;
162: int *retval;
163: {
164: register struct filedesc *fdp = p->p_fd;
165: register struct file *fp;
166: register char *pop;
167: struct vnode *vp;
168: int i, tmp, error, flg = F_POSIX;
169: struct flock fl;
170:
171: if ((unsigned)uap->fd >= fdp->fd_nfiles ||
172: (fp = fdp->fd_ofiles[uap->fd]) == NULL)
173: return (EBADF);
174: pop = &fdp->fd_ofileflags[uap->fd];
175: switch(uap->cmd) {
176: case F_DUPFD:
177: if ((unsigned)uap->arg >= p->p_rlimit[RLIMIT_OFILE].rlim_cur)
178: return (EINVAL);
179: if (error = fdalloc(p, uap->arg, &i))
180: return (error);
181: fdp->fd_ofiles[i] = fp;
182: fdp->fd_ofileflags[i] = *pop &~ UF_EXCLOSE;
183: fp->f_count++;
184: if (i > fdp->fd_lastfile)
185: fdp->fd_lastfile = i;
186: *retval = i;
187: return (0);
188:
189: case F_GETFD:
190: *retval = *pop & 1;
191: return (0);
192:
193: case F_SETFD:
194: *pop = (*pop &~ 1) | (uap->arg & 1);
195: return (0);
196:
197: case F_GETFL:
198: *retval = OFLAGS(fp->f_flag);
199: return (0);
200:
201: case F_SETFL:
202: fp->f_flag &= ~FCNTLFLAGS;
203: fp->f_flag |= FFLAGS(uap->arg) & FCNTLFLAGS;
204: tmp = fp->f_flag & FNONBLOCK;
205: error = (*fp->f_ops->fo_ioctl)(fp, FIONBIO, (caddr_t)&tmp, p);
206: if (error)
207: return (error);
208: tmp = fp->f_flag & FASYNC;
209: error = (*fp->f_ops->fo_ioctl)(fp, FIOASYNC, (caddr_t)&tmp, p);
210: if (!error)
211: return (0);
212: fp->f_flag &= ~FNONBLOCK;
213: tmp = 0;
214: (void) (*fp->f_ops->fo_ioctl)(fp, FIONBIO, (caddr_t)&tmp, p);
215: return (error);
216:
217: case F_GETOWN:
218: if (fp->f_type == DTYPE_SOCKET) {
219: *retval = ((struct socket *)fp->f_data)->so_pgid;
220: return (0);
221: }
222: error = (*fp->f_ops->fo_ioctl)
223: (fp, (int)TIOCGPGRP, (caddr_t)retval, p);
224: *retval = -*retval;
225: return (error);
226:
227: case F_SETOWN:
228: if (fp->f_type == DTYPE_SOCKET) {
229: ((struct socket *)fp->f_data)->so_pgid = uap->arg;
230: return (0);
231: }
232: if (uap->arg <= 0) {
233: uap->arg = -uap->arg;
234: } else {
235: struct proc *p1 = pfind(uap->arg);
236: if (p1 == 0)
237: return (ESRCH);
238: uap->arg = p1->p_pgrp->pg_id;
239: }
240: return ((*fp->f_ops->fo_ioctl)
241: (fp, (int)TIOCSPGRP, (caddr_t)&uap->arg, p));
242:
243: case F_SETLKW:
244: flg |= F_WAIT;
245: /* Fall into F_SETLK */
246:
247: case F_SETLK:
248: if (fp->f_type != DTYPE_VNODE)
249: return (EBADF);
250: vp = (struct vnode *)fp->f_data;
251: /* Copy in the lock structure */
252: error = copyin((caddr_t)uap->arg, (caddr_t)&fl, sizeof (fl));
253: if (error)
254: return (error);
255: if (fl.l_whence == SEEK_CUR)
256: fl.l_start += fp->f_offset;
257: switch (fl.l_type) {
258:
259: case F_RDLCK:
260: if ((fp->f_flag & FREAD) == 0)
261: return (EBADF);
262: p->p_flag |= SADVLCK;
263: return (VOP_ADVLOCK(vp, (caddr_t)p, F_SETLK, &fl, flg));
264:
265: case F_WRLCK:
266: if ((fp->f_flag & FWRITE) == 0)
267: return (EBADF);
268: p->p_flag |= SADVLCK;
269: return (VOP_ADVLOCK(vp, (caddr_t)p, F_SETLK, &fl, flg));
270:
271: case F_UNLCK:
272: return (VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &fl,
273: F_POSIX));
274:
275: default:
276: return (EINVAL);
277: }
278:
279: case F_GETLK:
280: if (fp->f_type != DTYPE_VNODE)
281: return (EBADF);
282: vp = (struct vnode *)fp->f_data;
283: /* Copy in the lock structure */
284: error = copyin((caddr_t)uap->arg, (caddr_t)&fl, sizeof (fl));
285: if (error)
286: return (error);
287: if (fl.l_whence == SEEK_CUR)
288: fl.l_start += fp->f_offset;
289: if (error = VOP_ADVLOCK(vp, (caddr_t)p, F_GETLK, &fl, F_POSIX))
290: return (error);
291: return (copyout((caddr_t)&fl, (caddr_t)uap->arg, sizeof (fl)));
292:
293: default:
294: return (EINVAL);
295: }
296: /* NOTREACHED */
297: }
298:
299: /*
300: * Close a file descriptor.
301: */
302: /* ARGSUSED */
303: close(p, uap, retval)
304: struct proc *p;
305: struct args {
306: int fd;
307: } *uap;
308: int *retval;
309: {
310: register struct filedesc *fdp = p->p_fd;
311: register struct file *fp;
312: register int fd = uap->fd;
313: register u_char *pf;
314:
315: if ((unsigned)fd >= fdp->fd_nfiles ||
316: (fp = fdp->fd_ofiles[fd]) == NULL)
317: return (EBADF);
318: pf = (u_char *)&fdp->fd_ofileflags[fd];
319: if (*pf & UF_MAPPED)
320: (void) munmapfd(p, fd);
321: fdp->fd_ofiles[fd] = NULL;
322: while (fdp->fd_lastfile > 0 && fdp->fd_ofiles[fdp->fd_lastfile] == NULL)
323: fdp->fd_lastfile--;
324: if (fd < fdp->fd_freefile)
325: fdp->fd_freefile = fd;
326: *pf = 0;
327: return (closef(fp, p));
328: }
329:
330: /*
331: * Return status information about a file descriptor.
332: */
333: /* ARGSUSED */
334: fstat(p, uap, retval)
335: struct proc *p;
336: register struct args {
337: int fd;
338: struct stat *sb;
339: } *uap;
340: int *retval;
341: {
342: register struct filedesc *fdp = p->p_fd;
343: register struct file *fp;
344: struct stat ub;
345: int error;
346:
347: if ((unsigned)uap->fd >= fdp->fd_nfiles ||
348: (fp = fdp->fd_ofiles[uap->fd]) == NULL)
349: return (EBADF);
350: switch (fp->f_type) {
351:
352: case DTYPE_VNODE:
353: error = vn_stat((struct vnode *)fp->f_data, &ub, p);
354: break;
355:
356: case DTYPE_SOCKET:
357: error = soo_stat((struct socket *)fp->f_data, &ub);
358: break;
359:
360: default:
361: panic("fstat");
362: /*NOTREACHED*/
363: }
364: if (error == 0)
365: error = copyout((caddr_t)&ub, (caddr_t)uap->sb, sizeof (ub));
366: return (error);
367: }
368:
369: /*
370: * Allocate a file descriptor for the process.
371: */
372: int fdexpand;
373:
374: fdalloc(p, want, result)
375: struct proc *p;
376: int want;
377: int *result;
378: {
379: register struct filedesc *fdp = p->p_fd;
380: register int i;
381: int lim, last, nfiles;
382: struct file **newofile;
383: char *newofileflags;
384:
385: /*
386: * Search for a free descriptor starting at the higher
387: * of want or fd_freefile. If that fails, consider
388: * expanding the ofile array.
389: */
390: lim = p->p_rlimit[RLIMIT_OFILE].rlim_cur;
391: for (;;) {
392: last = min(fdp->fd_nfiles, lim);
393: if ((i = want) < fdp->fd_freefile)
394: i = fdp->fd_freefile;
395: for (; i < last; i++) {
396: if (fdp->fd_ofiles[i] == NULL) {
397: fdp->fd_ofileflags[i] = 0;
398: if (i > fdp->fd_lastfile)
399: fdp->fd_lastfile = i;
400: if (want <= fdp->fd_freefile)
401: fdp->fd_freefile = i;
402: *result = i;
403: return (0);
404: }
405: }
406:
407: /*
408: * No space in current array. Expand?
409: */
410: if (fdp->fd_nfiles >= lim)
411: return (EMFILE);
412: if (fdp->fd_nfiles < NDEXTENT)
413: nfiles = NDEXTENT;
414: else
415: nfiles = 2 * fdp->fd_nfiles;
416: MALLOC(newofile, struct file **, nfiles * OFILESIZE,
417: M_FILEDESC, M_WAITOK);
418: newofileflags = (char *) &newofile[nfiles];
419: /*
420: * Copy the existing ofile and ofileflags arrays
421: * and zero the new portion of each array.
422: */
423: bcopy(fdp->fd_ofiles, newofile,
424: (i = sizeof(struct file *) * fdp->fd_nfiles));
425: bzero((char *)newofile + i, nfiles * sizeof(struct file *) - i);
426: bcopy(fdp->fd_ofileflags, newofileflags,
427: (i = sizeof(char) * fdp->fd_nfiles));
428: bzero(newofileflags + i, nfiles * sizeof(char) - i);
429: if (fdp->fd_nfiles > NDFILE)
430: FREE(fdp->fd_ofiles, M_FILEDESC);
431: fdp->fd_ofiles = newofile;
432: fdp->fd_ofileflags = newofileflags;
433: fdp->fd_nfiles = nfiles;
434: fdexpand++;
435: }
436: }
437:
438: /*
439: * Check to see whether n user file descriptors
440: * are available to the process p.
441: */
442: fdavail(p, n)
443: struct proc *p;
444: register int n;
445: {
446: register struct filedesc *fdp = p->p_fd;
447: register struct file **fpp;
448: register int i;
449:
450: if ((i = p->p_rlimit[RLIMIT_OFILE].rlim_cur - fdp->fd_nfiles) > 0 &&
451: (n -= i) <= 0)
452: return (1);
453: fpp = &fdp->fd_ofiles[fdp->fd_freefile];
454: for (i = fdp->fd_nfiles - fdp->fd_freefile; --i >= 0; fpp++)
455: if (*fpp == NULL && --n <= 0)
456: return (1);
457: return (0);
458: }
459:
460: /*
461: * Create a new open file structure and allocate
462: * a file decriptor for the process that refers to it.
463: */
464: falloc(p, resultfp, resultfd)
465: register struct proc *p;
466: struct file **resultfp;
467: int *resultfd;
468: {
469: register struct file *fp, *fq, **fpp;
470: int error, i;
471:
472: if (error = fdalloc(p, 0, &i))
473: return (error);
474: if (nfiles >= maxfiles) {
475: tablefull("file");
476: return (ENFILE);
477: }
478: /*
479: * Allocate a new file descriptor.
480: * If the process has file descriptor zero open, add to the list
481: * of open files at that point, otherwise put it at the front of
482: * the list of open files.
483: */
484: nfiles++;
485: MALLOC(fp, struct file *, sizeof(struct file), M_FILE, M_WAITOK);
486: if (fq = p->p_fd->fd_ofiles[0])
487: fpp = &fq->f_filef;
488: else
489: fpp = &filehead;
490: p->p_fd->fd_ofiles[i] = fp;
491: if (fq = *fpp)
492: fq->f_fileb = &fp->f_filef;
493: fp->f_filef = fq;
494: fp->f_fileb = fpp;
495: *fpp = fp;
496: fp->f_count = 1;
497: fp->f_msgcount = 0;
498: fp->f_offset = 0;
499: fp->f_cred = p->p_ucred;
500: crhold(fp->f_cred);
501: if (resultfp)
502: *resultfp = fp;
503: if (resultfd)
504: *resultfd = i;
505: return (0);
506: }
507:
508: /*
509: * Free a file descriptor.
510: */
511: ffree(fp)
512: register struct file *fp;
513: {
514: register struct file *fq;
515:
516: if (fq = fp->f_filef)
517: fq->f_fileb = fp->f_fileb;
518: *fp->f_fileb = fq;
519: crfree(fp->f_cred);
520: #ifdef DIAGNOSTIC
521: fp->f_filef = NULL;
522: fp->f_fileb = NULL;
523: fp->f_count = 0;
524: #endif
525: nfiles--;
526: FREE(fp, M_FILE);
527: }
528:
529: /*
530: * Copy a filedesc structure.
531: */
532: struct filedesc *
533: fdcopy(p)
534: struct proc *p;
535: {
536: register struct filedesc *newfdp, *fdp = p->p_fd;
537: register struct file **fpp;
538: register int i;
539:
540: MALLOC(newfdp, struct filedesc *, sizeof(struct filedesc0),
541: M_FILEDESC, M_WAITOK);
542: bcopy(fdp, newfdp, sizeof(struct filedesc));
543: VREF(newfdp->fd_cdir);
544: if (newfdp->fd_rdir)
545: VREF(newfdp->fd_rdir);
546: newfdp->fd_refcnt = 1;
547:
548: /*
549: * If the number of open files fits in the internal arrays
550: * of the open file structure, use them, otherwise allocate
551: * additional memory for the number of descriptors currently
552: * in use.
553: */
554: if (newfdp->fd_lastfile < NDFILE) {
555: newfdp->fd_ofiles = ((struct filedesc0 *) newfdp)->fd_dfiles;
556: newfdp->fd_ofileflags =
557: ((struct filedesc0 *) newfdp)->fd_dfileflags;
558: i = NDFILE;
559: } else {
560: /*
561: * Compute the smallest multiple of NDEXTENT needed
562: * for the file descriptors currently in use,
563: * allowing the table to shrink.
564: */
565: i = newfdp->fd_nfiles;
566: while (i > 2 * NDEXTENT && i >= newfdp->fd_lastfile * 2)
567: i /= 2;
568: MALLOC(newfdp->fd_ofiles, struct file **, i * OFILESIZE,
569: M_FILEDESC, M_WAITOK);
570: newfdp->fd_ofileflags = (char *) &newfdp->fd_ofiles[i];
571: }
572: newfdp->fd_nfiles = i;
573: bcopy(fdp->fd_ofiles, newfdp->fd_ofiles, i * sizeof(struct file **));
574: bcopy(fdp->fd_ofileflags, newfdp->fd_ofileflags, i * sizeof(char));
575: fpp = newfdp->fd_ofiles;
576: for (i = newfdp->fd_lastfile; i-- >= 0; fpp++)
577: if (*fpp != NULL)
578: (*fpp)->f_count++;
579: return (newfdp);
580: }
581:
582: /*
583: * Release a filedesc structure.
584: */
585: void
586: fdfree(p)
587: struct proc *p;
588: {
589: register struct filedesc *fdp = p->p_fd;
590: struct file **fpp;
591: register int i;
592:
593: if (--fdp->fd_refcnt > 0)
594: return;
595: fpp = fdp->fd_ofiles;
596: for (i = fdp->fd_lastfile; i-- >= 0; fpp++)
597: if (*fpp)
598: (void) closef(*fpp, p);
599: if (fdp->fd_nfiles > NDFILE)
600: FREE(fdp->fd_ofiles, M_FILEDESC);
601: vrele(fdp->fd_cdir);
602: if (fdp->fd_rdir)
603: vrele(fdp->fd_rdir);
604: FREE(fdp, M_FILEDESC);
605: }
606:
607: /*
608: * Internal form of close.
609: * Decrement reference count on file structure.
610: */
611: closef(fp, p)
612: register struct file *fp;
613: register struct proc *p;
614: {
615: struct vnode *vp;
616: struct flock lf;
617: int error;
618:
619: if (fp == NULL)
620: return (0);
621: /*
622: * POSIX record locking dictates that any close releases ALL
623: * locks owned by this process. This is handled by setting
624: * a flag in the unlock to free ONLY locks obeying POSIX
625: * semantics, and not to free BSD-style file locks.
626: */
627: if ((p->p_flag & SADVLCK) && fp->f_type == DTYPE_VNODE) {
628: lf.l_whence = SEEK_SET;
629: lf.l_start = 0;
630: lf.l_len = 0;
631: lf.l_type = F_UNLCK;
632: vp = (struct vnode *)fp->f_data;
633: (void) VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &lf, F_POSIX);
634: }
635: if (--fp->f_count > 0)
636: return (0);
637: if (fp->f_count < 0)
638: panic("closef: count < 0");
639: if ((fp->f_flag & FHASLOCK) && fp->f_type == DTYPE_VNODE) {
640: lf.l_whence = SEEK_SET;
641: lf.l_start = 0;
642: lf.l_len = 0;
643: lf.l_type = F_UNLCK;
644: vp = (struct vnode *)fp->f_data;
645: (void) VOP_ADVLOCK(vp, (caddr_t)fp, F_UNLCK, &lf, F_FLOCK);
646: }
647: error = (*fp->f_ops->fo_close)(fp, p);
648: ffree(fp);
649: return (error);
650: }
651:
652: /*
653: * Apply an advisory lock on a file descriptor.
654: *
655: * Just attempt to get a record lock of the requested type on
656: * the entire file (l_whence = SEEK_SET, l_start = 0, l_len = 0).
657: */
658:
659: /* ARGSUSED */
660: flock(p, uap, retval)
661: struct proc *p;
662: register struct args {
663: int fd;
664: int how;
665: } *uap;
666: int *retval;
667: {
668: register struct filedesc *fdp = p->p_fd;
669: register struct file *fp;
670: struct vnode *vp;
671: struct flock lf;
672: int error;
673:
674: if ((unsigned)uap->fd >= fdp->fd_nfiles ||
675: (fp = fdp->fd_ofiles[uap->fd]) == NULL)
676: return (EBADF);
677: if (fp->f_type != DTYPE_VNODE)
678: return (EOPNOTSUPP);
679: vp = (struct vnode *)fp->f_data;
680: lf.l_whence = SEEK_SET;
681: lf.l_start = 0;
682: lf.l_len = 0;
683: if (uap->how & LOCK_UN) {
684: lf.l_type = F_UNLCK;
685: fp->f_flag &= ~FHASLOCK;
686: return (VOP_ADVLOCK(vp, (caddr_t)fp, F_UNLCK, &lf, F_FLOCK));
687: }
688: if (uap->how & LOCK_EX)
689: lf.l_type = F_WRLCK;
690: else if (uap->how & LOCK_SH)
691: lf.l_type = F_RDLCK;
692: else
693: return (EBADF);
694: fp->f_flag |= FHASLOCK;
695: if (uap->how & LOCK_NB)
696: return (VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, F_FLOCK));
697: return (VOP_ADVLOCK(vp, (caddr_t)fp, F_SETLK, &lf, F_FLOCK|F_WAIT));
698: }
699:
700: /*
701: * File Descriptor pseudo-device driver (/dev/fd/).
702: *
703: * Opening minor device N dup()s the file (if any) connected to file
704: * descriptor N belonging to the calling process. Note that this driver
705: * consists of only the ``open()'' routine, because all subsequent
706: * references to this file will be direct to the other driver.
707: */
708: /* ARGSUSED */
709: fdopen(dev, mode, type)
710: dev_t dev;
711: int mode, type;
712: {
713:
714: /*
715: * XXX Kludge: set curproc->p_dupfd to contain the value of the
716: * the file descriptor being sought for duplication. The error
717: * return ensures that the vnode for this device will be released
718: * by vn_open. Open will detect this special error and take the
719: * actions in dupfdopen below. Other callers of vn_open or VOP_OPEN
720: * will simply report the error.
721: */
722: curproc->p_dupfd = minor(dev); /* XXX */
723: return (ENODEV);
724: }
725:
726: /*
727: * Duplicate the specified descriptor to a free descriptor.
728: */
729: dupfdopen(fdp, indx, dfd, mode)
730: register struct filedesc *fdp;
731: register int indx, dfd;
732: int mode;
733: {
734: register struct file *wfp;
735: struct file *fp;
736:
737: /*
738: * If the to-be-dup'd fd number is greater than the allowed number
739: * of file descriptors, or the fd to be dup'd has already been
740: * closed, reject. Note, check for new == old is necessary as
741: * falloc could allocate an already closed to-be-dup'd descriptor
742: * as the new descriptor.
743: */
744: fp = fdp->fd_ofiles[indx];
745: if ((u_int)dfd >= fdp->fd_nfiles ||
746: (wfp = fdp->fd_ofiles[dfd]) == NULL || fp == wfp)
747: return (EBADF);
748:
749: /*
750: * Check that the mode the file is being opened for is a subset
751: * of the mode of the existing descriptor.
752: */
753: if (((mode & (FREAD|FWRITE)) | wfp->f_flag) != wfp->f_flag)
754: return (EACCES);
755: fdp->fd_ofiles[indx] = wfp;
756: fdp->fd_ofileflags[indx] = fdp->fd_ofileflags[dfd];
757: wfp->f_count++;
758: if (indx > fdp->fd_lastfile)
759: fdp->fd_lastfile = indx;
760: return (0);
761: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.