![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sys_generic.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 sys_generic.c CVS log | Up to [Net/2] / Net2 / kern |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986, 1989 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: * @(#)sys_generic.c 7.30 (Berkeley) 5/30/91
34: */
35:
36: #include "param.h"
37: #include "systm.h"
38: #include "filedesc.h"
39: #include "ioctl.h"
40: #include "file.h"
41: #include "socketvar.h"
42: #include "proc.h"
43: #include "uio.h"
44: #include "kernel.h"
45: #include "stat.h"
46: #include "malloc.h"
47: #ifdef KTRACE
48: #include "ktrace.h"
49: #endif
50:
51: /*
52: * Read system call.
53: */
54: /* ARGSUSED */
55: read(p, uap, retval)
56: struct proc *p;
57: register struct args {
58: int fdes;
59: char *cbuf;
60: unsigned count;
61: } *uap;
62: int *retval;
63: {
64: register struct file *fp;
65: register struct filedesc *fdp = p->p_fd;
66: struct uio auio;
67: struct iovec aiov;
68: long cnt, error = 0;
69: #ifdef KTRACE
70: struct iovec ktriov;
71: #endif
72:
73: if (((unsigned)uap->fdes) >= fdp->fd_nfiles ||
74: (fp = fdp->fd_ofiles[uap->fdes]) == NULL ||
75: (fp->f_flag & FREAD) == 0)
76: return (EBADF);
77: aiov.iov_base = (caddr_t)uap->cbuf;
78: aiov.iov_len = uap->count;
79: auio.uio_iov = &aiov;
80: auio.uio_iovcnt = 1;
81: auio.uio_resid = uap->count;
82: auio.uio_rw = UIO_READ;
83: auio.uio_segflg = UIO_USERSPACE;
84: auio.uio_procp = p;
85: #ifdef KTRACE
86: /*
87: * if tracing, save a copy of iovec
88: */
89: if (KTRPOINT(p, KTR_GENIO))
90: ktriov = aiov;
91: #endif
92: cnt = uap->count;
93: if (error = (*fp->f_ops->fo_read)(fp, &auio, fp->f_cred))
94: if (auio.uio_resid != cnt && (error == ERESTART ||
95: error == EINTR || error == EWOULDBLOCK))
96: error = 0;
97: cnt -= auio.uio_resid;
98: #ifdef KTRACE
99: if (KTRPOINT(p, KTR_GENIO) && error == 0)
100: ktrgenio(p->p_tracep, uap->fdes, UIO_READ, &ktriov, cnt, error);
101: #endif
102: *retval = cnt;
103: return (error);
104: }
105:
106: /*
107: * Scatter read system call.
108: */
109: /* ARGSUSED */
110: readv(p, uap, retval)
111: struct proc *p;
112: register struct args {
113: int fdes;
114: struct iovec *iovp;
115: unsigned iovcnt;
116: } *uap;
117: int *retval;
118: {
119: register struct file *fp;
120: register struct filedesc *fdp = p->p_fd;
121: struct uio auio;
122: register struct iovec *iov;
123: struct iovec *saveiov;
124: struct iovec aiov[UIO_SMALLIOV];
125: long i, cnt, error = 0;
126: unsigned iovlen;
127: #ifdef KTRACE
128: struct iovec *ktriov = NULL;
129: #endif
130:
131: if (((unsigned)uap->fdes) >= fdp->fd_nfiles ||
132: (fp = fdp->fd_ofiles[uap->fdes]) == NULL ||
133: (fp->f_flag & FREAD) == 0)
134: return (EBADF);
135: /* note: can't use iovlen until iovcnt is validated */
136: iovlen = uap->iovcnt * sizeof (struct iovec);
137: if (uap->iovcnt > UIO_SMALLIOV) {
138: if (uap->iovcnt > UIO_MAXIOV)
139: return (EINVAL);
140: MALLOC(iov, struct iovec *, iovlen, M_IOV, M_WAITOK);
141: saveiov = iov;
142: } else
143: iov = aiov;
144: auio.uio_iov = iov;
145: auio.uio_iovcnt = uap->iovcnt;
146: auio.uio_rw = UIO_READ;
147: auio.uio_segflg = UIO_USERSPACE;
148: auio.uio_procp = p;
149: if (error = copyin((caddr_t)uap->iovp, (caddr_t)iov, iovlen))
150: goto done;
151: auio.uio_resid = 0;
152: for (i = 0; i < uap->iovcnt; i++) {
153: if (iov->iov_len < 0) {
154: error = EINVAL;
155: goto done;
156: }
157: auio.uio_resid += iov->iov_len;
158: if (auio.uio_resid < 0) {
159: error = EINVAL;
160: goto done;
161: }
162: iov++;
163: }
164: #ifdef KTRACE
165: /*
166: * if tracing, save a copy of iovec
167: */
168: if (KTRPOINT(p, KTR_GENIO)) {
169: MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK);
170: bcopy((caddr_t)auio.uio_iov, (caddr_t)ktriov, iovlen);
171: }
172: #endif
173: cnt = auio.uio_resid;
174: if (error = (*fp->f_ops->fo_read)(fp, &auio, fp->f_cred))
175: if (auio.uio_resid != cnt && (error == ERESTART ||
176: error == EINTR || error == EWOULDBLOCK))
177: error = 0;
178: cnt -= auio.uio_resid;
179: #ifdef KTRACE
180: if (ktriov != NULL) {
181: if (error == 0)
182: ktrgenio(p->p_tracep, uap->fdes, UIO_READ, ktriov,
183: cnt, error);
184: FREE(ktriov, M_TEMP);
185: }
186: #endif
187: *retval = cnt;
188: done:
189: if (uap->iovcnt > UIO_SMALLIOV)
190: FREE(saveiov, M_IOV);
191: return (error);
192: }
193:
194: /*
195: * Write system call
196: */
197: write(p, uap, retval)
198: struct proc *p;
199: register struct args {
200: int fdes;
201: char *cbuf;
202: unsigned count;
203: } *uap;
204: int *retval;
205: {
206: register struct file *fp;
207: register struct filedesc *fdp = p->p_fd;
208: struct uio auio;
209: struct iovec aiov;
210: long cnt, error = 0;
211: #ifdef KTRACE
212: struct iovec ktriov;
213: #endif
214:
215: if (((unsigned)uap->fdes) >= fdp->fd_nfiles ||
216: (fp = fdp->fd_ofiles[uap->fdes]) == NULL ||
217: (fp->f_flag & FWRITE) == 0)
218: return (EBADF);
219: aiov.iov_base = (caddr_t)uap->cbuf;
220: aiov.iov_len = uap->count;
221: auio.uio_iov = &aiov;
222: auio.uio_iovcnt = 1;
223: auio.uio_resid = uap->count;
224: auio.uio_rw = UIO_WRITE;
225: auio.uio_segflg = UIO_USERSPACE;
226: auio.uio_procp = p;
227: #ifdef KTRACE
228: /*
229: * if tracing, save a copy of iovec
230: */
231: if (KTRPOINT(p, KTR_GENIO))
232: ktriov = aiov;
233: #endif
234: cnt = uap->count;
235: if (error = (*fp->f_ops->fo_write)(fp, &auio, fp->f_cred)) {
236: if (auio.uio_resid != cnt && (error == ERESTART ||
237: error == EINTR || error == EWOULDBLOCK))
238: error = 0;
239: if (error == EPIPE)
240: psignal(p, SIGPIPE);
241: }
242: cnt -= auio.uio_resid;
243: #ifdef KTRACE
244: if (KTRPOINT(p, KTR_GENIO) && error == 0)
245: ktrgenio(p->p_tracep, uap->fdes, UIO_WRITE,
246: &ktriov, cnt, error);
247: #endif
248: *retval = cnt;
249: return (error);
250: }
251:
252: /*
253: * Gather write system call
254: */
255: writev(p, uap, retval)
256: struct proc *p;
257: register struct args {
258: int fdes;
259: struct iovec *iovp;
260: unsigned iovcnt;
261: } *uap;
262: int *retval;
263: {
264: register struct file *fp;
265: register struct filedesc *fdp = p->p_fd;
266: struct uio auio;
267: register struct iovec *iov;
268: struct iovec *saveiov;
269: struct iovec aiov[UIO_SMALLIOV];
270: long i, cnt, error = 0;
271: unsigned iovlen;
272: #ifdef KTRACE
273: struct iovec *ktriov = NULL;
274: #endif
275:
276: if (((unsigned)uap->fdes) >= fdp->fd_nfiles ||
277: (fp = fdp->fd_ofiles[uap->fdes]) == NULL ||
278: (fp->f_flag & FWRITE) == 0)
279: return (EBADF);
280: /* note: can't use iovlen until iovcnt is validated */
281: iovlen = uap->iovcnt * sizeof (struct iovec);
282: if (uap->iovcnt > UIO_SMALLIOV) {
283: if (uap->iovcnt > UIO_MAXIOV)
284: return (EINVAL);
285: MALLOC(iov, struct iovec *, iovlen, M_IOV, M_WAITOK);
286: saveiov = iov;
287: } else
288: iov = aiov;
289: auio.uio_iov = iov;
290: auio.uio_iovcnt = uap->iovcnt;
291: auio.uio_rw = UIO_WRITE;
292: auio.uio_segflg = UIO_USERSPACE;
293: auio.uio_procp = p;
294: if (error = copyin((caddr_t)uap->iovp, (caddr_t)iov, iovlen))
295: goto done;
296: auio.uio_resid = 0;
297: for (i = 0; i < uap->iovcnt; i++) {
298: if (iov->iov_len < 0) {
299: error = EINVAL;
300: goto done;
301: }
302: auio.uio_resid += iov->iov_len;
303: if (auio.uio_resid < 0) {
304: error = EINVAL;
305: goto done;
306: }
307: iov++;
308: }
309: #ifdef KTRACE
310: /*
311: * if tracing, save a copy of iovec
312: */
313: if (KTRPOINT(p, KTR_GENIO)) {
314: MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK);
315: bcopy((caddr_t)auio.uio_iov, (caddr_t)ktriov, iovlen);
316: }
317: #endif
318: cnt = auio.uio_resid;
319: if (error = (*fp->f_ops->fo_write)(fp, &auio, fp->f_cred)) {
320: if (auio.uio_resid != cnt && (error == ERESTART ||
321: error == EINTR || error == EWOULDBLOCK))
322: error = 0;
323: if (error == EPIPE)
324: psignal(p, SIGPIPE);
325: }
326: cnt -= auio.uio_resid;
327: #ifdef KTRACE
328: if (ktriov != NULL) {
329: if (error == 0)
330: ktrgenio(p->p_tracep, uap->fdes, UIO_WRITE,
331: ktriov, cnt, error);
332: FREE(ktriov, M_TEMP);
333: }
334: #endif
335: *retval = cnt;
336: done:
337: if (uap->iovcnt > UIO_SMALLIOV)
338: FREE(saveiov, M_IOV);
339: return (error);
340: }
341:
342: /*
343: * Ioctl system call
344: */
345: /* ARGSUSED */
346: ioctl(p, uap, retval)
347: struct proc *p;
348: register struct args {
349: int fdes;
350: int cmd;
351: caddr_t cmarg;
352: } *uap;
353: int *retval;
354: {
355: register struct file *fp;
356: register struct filedesc *fdp = p->p_fd;
357: register int com, error;
358: register u_int size;
359: caddr_t memp = 0;
360: #define STK_PARAMS 128
361: char stkbuf[STK_PARAMS];
362: caddr_t data = stkbuf;
363: int tmp;
364:
365: if ((unsigned)uap->fdes >= fdp->fd_nfiles ||
366: (fp = fdp->fd_ofiles[uap->fdes]) == NULL)
367: return (EBADF);
368: if ((fp->f_flag & (FREAD|FWRITE)) == 0)
369: return (EBADF);
370: com = uap->cmd;
371:
372: if (com == FIOCLEX) {
373: fdp->fd_ofileflags[uap->fdes] |= UF_EXCLOSE;
374: return (0);
375: }
376: if (com == FIONCLEX) {
377: fdp->fd_ofileflags[uap->fdes] &= ~UF_EXCLOSE;
378: return (0);
379: }
380:
381: /*
382: * Interpret high order word to find
383: * amount of data to be copied to/from the
384: * user's address space.
385: */
386: size = IOCPARM_LEN(com);
387: if (size > IOCPARM_MAX)
388: return (ENOTTY);
389: if (size > sizeof (stkbuf)) {
390: memp = (caddr_t)malloc((u_long)size, M_IOCTLOPS, M_WAITOK);
391: data = memp;
392: }
393: if (com&IOC_IN) {
394: if (size) {
395: error = copyin(uap->cmarg, data, (u_int)size);
396: if (error) {
397: if (memp)
398: free(memp, M_IOCTLOPS);
399: return (error);
400: }
401: } else
402: *(caddr_t *)data = uap->cmarg;
403: } else if ((com&IOC_OUT) && size)
404: /*
405: * Zero the buffer so the user always
406: * gets back something deterministic.
407: */
408: bzero(data, size);
409: else if (com&IOC_VOID)
410: *(caddr_t *)data = uap->cmarg;
411:
412: switch (com) {
413:
414: case FIONBIO:
415: if (tmp = *(int *)data)
416: fp->f_flag |= FNONBLOCK;
417: else
418: fp->f_flag &= ~FNONBLOCK;
419: error = (*fp->f_ops->fo_ioctl)(fp, FIONBIO, (caddr_t)&tmp, p);
420: break;
421:
422: case FIOASYNC:
423: if (tmp = *(int *)data)
424: fp->f_flag |= FASYNC;
425: else
426: fp->f_flag &= ~FASYNC;
427: error = (*fp->f_ops->fo_ioctl)(fp, FIOASYNC, (caddr_t)&tmp, p);
428: break;
429:
430: case FIOSETOWN:
431: tmp = *(int *)data;
432: if (fp->f_type == DTYPE_SOCKET) {
433: ((struct socket *)fp->f_data)->so_pgid = tmp;
434: error = 0;
435: break;
436: }
437: if (tmp <= 0) {
438: tmp = -tmp;
439: } else {
440: struct proc *p1 = pfind(tmp);
441: if (p1 == 0) {
442: error = ESRCH;
443: break;
444: }
445: tmp = p1->p_pgrp->pg_id;
446: }
447: error = (*fp->f_ops->fo_ioctl)
448: (fp, (int)TIOCSPGRP, (caddr_t)&tmp, p);
449: break;
450:
451: case FIOGETOWN:
452: if (fp->f_type == DTYPE_SOCKET) {
453: error = 0;
454: *(int *)data = ((struct socket *)fp->f_data)->so_pgid;
455: break;
456: }
457: error = (*fp->f_ops->fo_ioctl)(fp, (int)TIOCGPGRP, data, p);
458: *(int *)data = -*(int *)data;
459: break;
460:
461: default:
462: error = (*fp->f_ops->fo_ioctl)(fp, com, data, p);
463: /*
464: * Copy any data to user, size was
465: * already set and checked above.
466: */
467: if (error == 0 && (com&IOC_OUT) && size)
468: error = copyout(data, uap->cmarg, (u_int)size);
469: break;
470: }
471: if (memp)
472: free(memp, M_IOCTLOPS);
473: return (error);
474: }
475:
476: int selwait, nselcoll;
477:
478: /*
479: * Select system call.
480: */
481: select(p, uap, retval)
482: register struct proc *p;
483: register struct args {
484: int nd;
485: fd_set *in, *ou, *ex;
486: struct timeval *tv;
487: } *uap;
488: int *retval;
489: {
490: fd_set ibits[3], obits[3];
491: struct timeval atv;
492: int s, ncoll, ni, error = 0, timo;
493:
494: bzero((caddr_t)ibits, sizeof(ibits));
495: bzero((caddr_t)obits, sizeof(obits));
496: if (uap->nd > p->p_fd->fd_nfiles)
497: uap->nd = p->p_fd->fd_nfiles; /* forgiving; slightly wrong */
498: ni = howmany(uap->nd, NFDBITS);
499:
500: #define getbits(name, x) \
501: if (uap->name) { \
502: error = copyin((caddr_t)uap->name, (caddr_t)&ibits[x], \
503: (unsigned)(ni * sizeof(fd_mask))); \
504: if (error) \
505: goto done; \
506: }
507: getbits(in, 0);
508: getbits(ou, 1);
509: getbits(ex, 2);
510: #undef getbits
511:
512: if (uap->tv) {
513: error = copyin((caddr_t)uap->tv, (caddr_t)&atv,
514: sizeof (atv));
515: if (error)
516: goto done;
517: if (itimerfix(&atv)) {
518: error = EINVAL;
519: goto done;
520: }
521: s = splhigh(); timevaladd(&atv, &time); splx(s);
522: timo = hzto(&atv);
523: } else
524: timo = 0;
525: retry:
526: ncoll = nselcoll;
527: p->p_flag |= SSEL;
528: error = selscan(p, ibits, obits, uap->nd, retval);
529: if (error || *retval)
530: goto done;
531: s = splhigh();
532: /* this should be timercmp(&time, &atv, >=) */
533: if (uap->tv && (time.tv_sec > atv.tv_sec ||
534: time.tv_sec == atv.tv_sec && time.tv_usec >= atv.tv_usec)) {
535: splx(s);
536: goto done;
537: }
538: if ((p->p_flag & SSEL) == 0 || nselcoll != ncoll) {
539: splx(s);
540: goto retry;
541: }
542: p->p_flag &= ~SSEL;
543: error = tsleep((caddr_t)&selwait, PSOCK | PCATCH, "select", timo);
544: splx(s);
545: if (error == 0)
546: goto retry;
547: done:
548: p->p_flag &= ~SSEL;
549: /* select is not restarted after signals... */
550: if (error == ERESTART)
551: error = EINTR;
552: if (error == EWOULDBLOCK)
553: error = 0;
554: #define putbits(name, x) \
555: if (uap->name) { \
556: int error2 = copyout((caddr_t)&obits[x], (caddr_t)uap->name, \
557: (unsigned)(ni * sizeof(fd_mask))); \
558: if (error2) \
559: error = error2; \
560: }
561: if (error == 0) {
562: putbits(in, 0);
563: putbits(ou, 1);
564: putbits(ex, 2);
565: #undef putbits
566: }
567: return (error);
568: }
569:
570: selscan(p, ibits, obits, nfd, retval)
571: struct proc *p;
572: fd_set *ibits, *obits;
573: int nfd, *retval;
574: {
575: register struct filedesc *fdp = p->p_fd;
576: register int which, i, j;
577: register fd_mask bits;
578: int flag;
579: struct file *fp;
580: int error = 0, n = 0;
581:
582: for (which = 0; which < 3; which++) {
583: switch (which) {
584:
585: case 0:
586: flag = FREAD; break;
587:
588: case 1:
589: flag = FWRITE; break;
590:
591: case 2:
592: flag = 0; break;
593: }
594: for (i = 0; i < nfd; i += NFDBITS) {
595: bits = ibits[which].fds_bits[i/NFDBITS];
596: while ((j = ffs(bits)) && i + --j < nfd) {
597: bits &= ~(1 << j);
598: fp = fdp->fd_ofiles[i + j];
599: if (fp == NULL) {
600: error = EBADF;
601: break;
602: }
603: if ((*fp->f_ops->fo_select)(fp, flag, p)) {
604: FD_SET(i + j, &obits[which]);
605: n++;
606: }
607: }
608: }
609: }
610: *retval = n;
611: return (error);
612: }
613:
614: /*ARGSUSED*/
615: #ifdef __STDC__
616: seltrue(dev_t dev, int which, struct proc *p)
617: #else
618: seltrue(dev, flag, p)
619: dev_t dev;
620: int flag;
621: struct proc *p;
622: #endif
623: {
624:
625: return (1);
626: }
627:
628: selwakeup(p, coll)
629: register struct proc *p;
630: int coll;
631: {
632:
633: if (coll) {
634: nselcoll++;
635: wakeup((caddr_t)&selwait);
636: }
637: if (p) {
638: int s = splhigh();
639: if (p->p_wchan == (caddr_t)&selwait) {
640: if (p->p_stat == SSLEEP)
641: setrun(p);
642: else
643: unsleep(p);
644: } else if (p->p_flag & SSEL)
645: p->p_flag &= ~SSEL;
646: splx(s);
647: }
648: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.