![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to null.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / STREAMS / coh.386|
Return to null.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / coh.386 |
1.1 root 1: /* $Header: /src386/STREAMS/coh.386/RCS/null.c,v 2.3 93/08/09 13:35:51 bin Exp Locker: bin $ */
2: /* (lgl-
3: * The information contained herein is a trade secret of Mark Williams
4: * Company, and is confidential information. It is provided under a
5: * license agreement, and may be copied or disclosed only under the
6: * terms of that agreement. Any reproduction or disclosure of this
7: * material without the express written authorization of Mark Williams
8: * Company or persuant to the license agreement is unlawful.
9: *
10: * COHERENT Version 2.3.37
11: * Copyright (c) 1982, 1983, 1984.
12: * An unpublished work by Mark Williams Company, Chicago.
13: * All rights reserved.
14: -lgl) */
15: /*
16: * Null and memory driver.
17: * Minor device 0 is /dev/null
18: * Minor device 1 is /dev/mem, physical memory
19: * Minor device 2 is /dev/kmem, kernel data
20: * Minor device 3 is /dev/cmos
21: * Minor device 4 is /dev/boot_gift
22: * Minor device 5 is /dev/clock
23: * Minor device 6 is /dev/ps
24: * Minor device 7 is /dev/kmemhi, virtual memory 0x8000_0000-0xFFFF_FFFF
25: * Minor device 11 is /dev/idle
26: *
27: * $Log: null.c,v $
28: * Revision 2.3 93/08/09 13:35:51 bin
29: * Kernel 82 changes
30: *
31: * Revision 2.2 93/07/26 14:28:57 nigel
32: * Nigel's R80
33: *
34: * Revision 1.7 93/04/14 10:06:37 root
35: * r75
36: *
37: * Revision 1.10 93/03/02 08:16:25 bin
38: * kernel 73 update
39: *
40: * Revision 1.6 92/11/09 17:10:54 root
41: * Just before adding vio segs.
42: *
43: * Revision 1.2 92/01/06 11:59:49 hal
44: * Compile with cc.mwc.
45: *
46: * Revision 1.1 88/03/24 16:14:04 src
47: * Initial revision
48: *
49: */
50:
51: /*
52: * The symbol "DANGEROUS" should be undefined for a production system.
53: */
54: #ifdef TRACER
55: #define NULL_IOCTL /* Allow ioctl()s for /dev/kmem. */
56: #define DANGEROUS /* Allow dangerous ioctl()s for /dev/null. */
57: #endif
58: #define IDLE_DEV
59:
60: #include <kernel/typed.h>
61:
62: #include <sys/coherent.h>
63: #include <sys/con.h>
64: #include <sys/errno.h>
65: #include <sys/stat.h>
66: #include <sys/inode.h>
67: #include <sys/seg.h>
68: #include <sys/coh_ps.h>
69: #include <sys/file.h>
70: #if defined NULL_IOCTL || defined IDLE_DEV
71: #include <sys/null.h>
72: #endif /* NULL_IOCTL || IDLE_DEV */
73:
74:
75: #if TRACER
76: #include <sys/buf.h>
77: #endif
78:
79: /* These are minor numbers. */
80: #define DEV_NULL 0 /* /dev/null */
81: #define DEV_MEM 1 /* /dev/mem */
82: #define DEV_KMEM 2 /* /dev/kmem */
83: #define DEV_CMOS 3 /* /dev/cmos */
84: #define DEV_BOOTGIFT 4 /* /dev/bootgift */
85: #define DEV_CLOCK 5 /* /dev/clock */
86: #define DEV_PS 6 /* /dev/ps */
87: #define DEV_KMEMHI 7 /* /dev/kmemhi */
88: #define DEV_IDLE 11 /* /dev/idle */
89:
90: #define KMEMHI_BASE 0x80000000
91: #define PXCOPY_LIM 4096
92:
93: /*
94: * CMOS devices are limited by an 8 bit address.
95: */
96: #define MAX_CMOS 255
97: #define CMOS_LEN 256
98:
99: /*
100: * The first 14 bytes of the CMOS are the clock.
101: */
102: #define MAX_CLOCK 13
103: #define CLOCK_LEN 14
104:
105: /*
106: * These are definitions for mucking with the CMOS clock.
107: */
108: #define SRA 10 /* Status Register A */
109: #define SRB 11 /* Status Register B */
110: #define SRC 12 /* Status Register C */
111: #define SRD 13 /* Status Register D */
112:
113: #define UIP 0x80 /* Update In Progress bit of SRA. */
114: #define NO_UPD 0x80 /* No Update bit of SRB. */
115:
116: /*
117: * Functions for configuration.
118: */
119: void nlopen();
120: void nlclose();
121: void nlread();
122: void nlwrite();
123: int nlioctl();
124: int nulldev();
125: int nonedev();
126:
127: /*
128: * Configuration table.
129: */
130: CON nlcon ={
131: DFCHR, /* Flags */
132: 0, /* Major index */
133: nlopen, /* Open */
134: nlclose, /* Close */
135: nulldev, /* Block */
136: nlread, /* Read */
137: nlwrite, /* Write */
138: #if defined NULL_IOCTL || defined IDLE_DEV
139: nlioctl, /* Ioctl */
140: #else /* NULL_IOCTL || IDLE_DEV */
141: nonedev, /* Ioctl */
142: #endif /* NULL_IOCTL || IDLE_DEV */
143: nulldev, /* Powerfail */
144: nulldev, /* Timeout */
145: nulldev, /* Load */
146: nulldev /* Unload */
147: };
148:
149: int lock_clock();
150: void unlock_clock();
151:
152: /*
153: * Null/memory open routine.
154: */
155: void
156: nlopen(dev, mode)
157: dev_t dev;
158: int mode;
159: {
160: switch (minor(dev)) {
161: #ifdef IDLE_DEV
162: case DEV_IDLE:
163: #endif
164: case DEV_PS:
165: /* /dev/ps is read only */
166: if (IPR != (IPR & mode))
167: SET_U_ERROR( EACCES, "/dev/ps is read only" );
168: break;
169: default:
170: /*
171: * For minor devices on NULL there is
172: * usually no action for open().
173: */
174: break;
175: }
176: return;
177: } /* nlopen() */
178:
179: /*
180: * Null/memory close routine.
181: */
182: void
183: nlclose(dev, mode)
184: dev_t dev;
185: int mode;
186: {
187: /*
188: * For minor devices on NULL there is
189: * Usually no action for close().
190: */
191: return;
192: } /* nlclose() */
193:
194: /*
195: * Null/memory read routine.
196: */
197: void
198: nlread(dev, iop)
199: dev_t dev;
200: register IO *iop;
201: {
202: register unsigned bytesRead;
203: register PROC *pp1; /* */
204: char psBuf[ARGSZ]; /* buffer for command line
205: * arguments for ps. */
206: stMonitor psData; /* All process data for */
207: UPROC *uprc; /* pointer to u area */
208: int ndpUseg; /* System global address
209: * of U segment */
210: unsigned int seek;
211: unsigned char read_cmos();
212: extern typed_space boot_gift;
213:
214: switch (minor (dev)) {
215: case DEV_NULL:
216: /*
217: * Read nothing.
218: * Do NOT update iop->io_ioc.
219: * This way, caller knows 0 bytes were read.
220: */
221: break;
222:
223: case DEV_MEM: {
224: int src = iop->io_seek;
225: int dest = iop->io.pbase;
226:
227: while (iop->io_ioc) {
228: int numBytes = PXCOPY_LIM;
229: if (numBytes > iop->io_ioc)
230: numBytes = iop->io_ioc;
231:
232: bytesRead = pxcopy (src, dest, numBytes,
233: SEG_386_UD | R_USR);
234: src += bytesRead;
235: dest += bytesRead;
236: iop->io_ioc -= bytesRead;
237: if (u.u_error == EFAULT) {
238: u.u_error = 0;
239: break;
240: }
241: }
242: break;
243: }
244:
245: case DEV_KMEM:
246: iowrite (iop, iop->io_seek, iop->io_ioc);
247: if (u.u_error == EFAULT)
248: u.u_error = 0;
249: break;
250:
251: case DEV_CLOCK:
252: /*
253: * Don't go past the end of the CLOCK.
254: */
255: if (iop->io_seek >= CLOCK_LEN)
256: break;
257:
258: /*
259: * Lock the clock before any reading.
260: */
261:
262: if (lock_clock () == 0) {
263: SET_U_ERROR (EIO, "RT clock will not settle.");
264: break;
265: }
266:
267: /*
268: * Read the requested data out of the CMOS.
269: */
270: for (seek = iop->io_seek; seek < CLOCK_LEN; seek++) {
271: if(ioputc(read_cmos(seek), iop) == -1)
272: break;
273: }
274:
275: /*
276: * Now that we are done reading the CMOS, let
277: * the clock loose.
278: */
279: unlock_clock();
280: break;
281:
282: case DEV_CMOS:
283: /*
284: * Don't go past the end of the CMOS.
285: */
286: if (iop->io_seek >= CMOS_LEN)
287: break;
288:
289: /*
290: * Read the requested data out of the CMOS.
291: */
292: for (seek = iop->io_seek; seek < CMOS_LEN; seek++) {
293: if(ioputc(read_cmos(seek), iop) == -1)
294: break;
295: }
296: break;
297:
298: case DEV_BOOTGIFT:
299: /*
300: * Reads all from the data structure boot_gift.
301: */
302: if (iop->io_seek < BG_LEN) {
303: bytesRead = iop->io_ioc;
304:
305: /*
306: * Copy no more than to the end of boot_gift.
307: */
308: if (iop->io_seek + bytesRead > BG_LEN)
309: bytesRead = BG_LEN - iop->io_seek;
310:
311: iowrite (iop, (char *) (& boot_gift) + iop->io_seek,
312: bytesRead);
313: }
314: break;
315:
316: case DEV_PS:
317: /* Lock the process table. It allows to have an atomic ps. */
318: lock (pnxgate);
319: /* Main driver loop. Go through all processes. Fill struct PS
320: * and send put to user buffer.
321: */
322: for (pp1 = & procq; (pp1 = pp1->p_nforw) != & procq; ) {
323: register int i; /* loop index */
324: register unsigned uLen, /* Process size */
325: uLenR; /* Real process size */
326: register SEG *sp; /* u area segment */
327: int work; /* virtual click number */
328:
329: /* Check if driver can send next proc data */
330: if (iop->io_ioc < sizeof (stMonitor))
331: break;
332:
333: /* Calculate the size of process. */
334: uLen = uLenR = 0;
335: for (i = 0 ; i < NUSEG ; i++) {
336: if ((sp = pp1->p_segp [i]) == NULL)
337: continue;
338: uLenR += sp->s_size;
339: if (i == SIUSERP || i == SIAUXIL)
340: continue;
341: uLen += sp->s_size;
342:
343: }
344:
345: /* Find u area for process pp1 */
346: sp = pp1->p_segp [SIUSERP];
347: ndpUseg = MAPIO (sp->s_vmem, U_OFFSET);
348: work = workAlloc ();
349: ptable1_v [work] =
350: sysmem.u.pbase [btocrd (ndpUseg)] | SEG_RW;
351: uprc = (UPROC *) (ctob (work) + U_OFFSET);
352: memcpy (psData.u_comm, uprc->u_comm, ARGSZ);
353: memcpy (psData.u_sleep, uprc->u_sleep, U_SLEEP_LEN);
354: workFree (work);
355:
356: #ifdef TRACER
357: if (strncmp (psData.u_sleep, "lock",
358: U_SLEEP_LEN) == 0) {
359: GATE * g = pp1->p_event;
360: printf ("[%d] locked at %x lock %s (%d) = %x\n",
361: pp1->p_pid, g, g->_name, g->_count,
362: g->_lock [0]);
363: }
364: if (strncmp (psData.u_sleep, "bpwait",
365: U_SLEEP_LEN) == 0) {
366: BUF * bp = pp1->p_event;
367: printf ("[%d] blocked on %x flags = %x\n",
368: pp1->p_pid, bp, bp->b_flag);
369: }
370: #endif
371:
372: /* fill up stMonitor */
373: psData.p_pid = pp1->p_pid;
374: psData.p_ppid = pp1->p_ppid;
375: psData.p_uid = pp1->p_uid;
376: psData.p_ruid = pp1->p_ruid;
377: psData.p_rgid = pp1->p_rgid;
378: psData.p_state = pp1->p_state;
379: psData.p_flags = pp1->p_flags;
380: psData.rrun = (char *) pp1 != pp1->p_event;
381: psData.p_event = pp1->p_event;
382: psData.p_ttdev = pp1->p_ttdev;
383: psData.p_nice = pp1->p_nice;
384: psData.size = (short) (uLen >> 10);
385: psData.rsize = (short) (uLenR >> 10);
386: psData.p_schedPri = pp1->p_schedPri;
387: psData.p_utime = pp1->p_utime;
388: psData.p_stime = pp1->p_stime;
389:
390: memcpy (psData.pr_argv, psBuf, ARGSZ);
391:
392: /* send data to user */
393: iowrite (iop, (char *) & psData, sizeof (stMonitor));
394: }
395: unlock (pnxgate);
396: break;
397:
398: case DEV_KMEMHI:
399: iowrite (iop, iop->io_seek - KMEMHI_BASE, iop->io_ioc);
400: if (u.u_error == EFAULT)
401: u.u_error = 0;
402: break;
403:
404: default:
405: SET_U_ERROR (ENXIO, "nlread(): illegal minor device for null");
406: }
407: return;
408: }
409:
410: /*
411: * Null/memory write routine.
412: */
413: void
414: nlwrite(dev, iop)
415: dev_t dev;
416: register IO *iop;
417: {
418: register unsigned bytesWrit;
419: unsigned write_cmos();
420: unsigned seek;
421: int ch;
422:
423: switch (minor (dev)) {
424: case DEV_NULL:
425: /*
426: * Tell caller all bytes were written.
427: */
428: iop->io_ioc = 0;
429: break;
430:
431: case DEV_MEM:
432: while (iop->io_ioc) {
433: int src = iop->io.pbase;
434: int dest = iop->io_seek;
435: int numBytes = PXCOPY_LIM;
436: if (numBytes > iop->io_ioc)
437: numBytes = iop->io_ioc;
438:
439: bytesWrit = xpcopy (src, dest, numBytes,
440: SEG_386_UD | R_USR);
441: src += bytesWrit;
442: dest += bytesWrit;
443: iop->io_ioc -= bytesWrit;
444: if (u.u_error == EFAULT) {
445: u.u_error = 0;
446: break;
447: }
448: }
449: break;
450:
451: case DEV_KMEM:
452: ioread (iop, iop->io_seek, iop->io_ioc);
453: break;
454:
455: case DEV_CLOCK:
456: /*
457: * Don't go past the end of the CLOCK.
458: */
459: if (iop->io_seek >= CLOCK_LEN)
460: break;
461:
462: /*
463: * Lock the clock before any writing.
464: */
465: if (lock_clock () == 0) {
466: SET_U_ERROR (EIO, "RT clock will not settle.");
467: break;
468: }
469:
470: /*
471: * Write the requested data into the CMOS.
472: */
473:
474: for (seek = iop->io_seek ; seek < CLOCK_LEN ; seek ++) {
475: if ((ch = iogetc (iop)) == -1)
476: break;
477: write_cmos (seek, ch);
478: }
479:
480: /*
481: * Now that we are done writing the CMOS, let
482: * the clock loose.
483: */
484: unlock_clock ();
485: break;
486:
487: case DEV_CMOS:
488: /*
489: * Don't go past the end of the CMOS.
490: */
491: if (iop->io_seek >= CMOS_LEN)
492: break;
493:
494: /*
495: * Write the requested data into the CMOS.
496: */
497: for (seek = iop->io_seek ; seek < CMOS_LEN ; seek ++) {
498: if ((ch = iogetc (iop)) == -1)
499: break;
500: write_cmos (seek, ch);
501: }
502: break;
503:
504: case DEV_BOOTGIFT:
505: /*
506: * /dev/bootgift is not writable.
507: */
508: break;
509:
510: case DEV_PS:
511: /*
512: * We should not be able to open /dev/ps to write.
513: * Just paranoya.
514: */
515: break;
516:
517: case DEV_KMEMHI:
518: ioread (iop, iop->io_seek - KMEMHI_BASE, iop->io_ioc);
519: break;
520:
521: default:
522: SET_U_ERROR (ENXIO,
523: "nlwrite(): illegal minor device for null");
524: }
525: return;
526: }
527:
528: #if defined NULL_IOCTL || defined IDLE_DEV /* Includes all of nlioctl(). */
529:
530: /*
531: * Do an ioctl call for /dev/null.
532: */
533: int
534: nlioctl(dev, cmd, vec)
535: dev_t dev;
536: int cmd;
537: char * vec;
538: {
539: /* Only /dev/kmem and /dev/idle have an ioctl. */
540: switch (minor (dev)) {
541: #ifdef NULL_IOCTL
542: case DEV_KMEM:
543: switch (cmd) {
544: #ifdef DANGEROUS
545: case NLCALL: /* Call a function. */
546: return docall (vec);
547: #endif /* DANGEROUS */
548: default:
549: SET_U_ERROR (EINVAL,
550: "nioctl(): illegal command for kmem");
551: return -1;
552: }
553: #endif /* NULL_IOCTL */
554: #ifdef IDLE_DEV
555: case DEV_IDLE:
556: if (cmd != NLIDLE) {
557: SET_U_ERROR (EINVAL,
558: "nioctl(): illegal command for idle");
559: return -1;
560: } else {
561: register PROC *pp;
562: register int *mem = vec;
563:
564:
565: pp = & procq; /* point to process queue */
566:
567: if (pp->p_pid != 0) {
568: while ((pp = pp->p_nforw) != &procq)
569: if (pp->p_pid == 0) /* idle process ? */
570: break;
571: }
572:
573: /*
574: * At this point, pp->p_utime and pp->p_stime contain
575: * the idle time of the system process
576: */
577:
578: if (pp->p_pid != 0)
579: putuwd (mem ++, 0);
580: else
581: putuwd (mem ++, pp->p_utime + pp->p_stime);
582: putuwd (mem, lbolt);
583: return 1;
584: }
585:
586: #endif /* IDLE_DEV */
587: default:
588: SET_U_ERROR(EINVAL, "illegal minor device for null ioctl");
589: return -1;
590: } /* switch on minor device */
591:
592: } /* nlioctl() */
593:
594: #endif /* NULL_IOCTL || IDLE_DEV */
595:
596: #ifdef DANGEROUS /* Includes all of docall(). */
597: /*
598: * MASSIVE SECURITY HOLE! This should NOT be included in a distribution
599: * system. Among other problems, it becomes possible to do "setuid(0)".
600: *
601: * Call a function with arguments.
602: *
603: * Takes an array of unsigned ints. The first element is the length of
604: * the whole array, the second element is a pointer to the function to
605: * call, all other elements are arguments. At most 5 arguments may be
606: * passed.
607: *
608: * Returns the return value of the called fuction in uvec[0].
609: */
610: int
611: docall(uvec)
612: unsigned uvec[];
613: {
614: int (* func)();
615: unsigned kvec[7];
616: int retval;
617:
618: printf("NLCALL security hole.\n");
619:
620: /* Fetch the first element of vec. */
621: ukcopy (uvec, kvec, sizeof (unsigned));
622:
623: if (kvec [0] < 2 || kvec[0] > 7) {
624: /* Invalid number of elements in uvec. */
625: SET_U_ERROR (EINVAL, "Invalid number of elements in uvec");
626: return -1;
627: }
628:
629: /* Fetch the whole vector. */
630: ukcopy (uvec, kvec, kvec [0] * sizeof (unsigned));
631:
632: /* Extract the function. */
633: func = (int (*)()) kvec [1];
634:
635: /* Call the function with all arguments. */
636: retval = (* func) (kvec [2], kvec [3], kvec [4], kvec [5], kvec [6]);
637:
638: kucopy (& retval, uvec, sizeof (unsigned));
639: } /* docall() */
640:
641: #endif /* DANGEROUS */
642:
643: /*
644: * int lock_clock() -- Stop the update cycle on the CMOS RT clock and
645: * wait for it to settle. Returns 0 if the clock would not settle
646: * in time.
647: */
648: int
649: lock_clock()
650: {
651: register int i;
652:
653: /*
654: * Wait for the clock to settle. If it does not settle in
655: * a reasonable amount of time, give up.
656: */
657:
658: i = 65536; /* Loop for a longish time. */
659: while (-- i > 0) {
660: if (0 == (UIP & read_cmos (SRA))) {
661: break; /* Break if there is no update in progress. */
662: }
663: }
664:
665: if (0 == i) {
666: /* The clock would not settle. */
667: return 0;
668: }
669:
670: /*
671: * There is a tiny race here--an interrupt could conceivably
672: * come here, thus allowing enough delay for another update to
673: * begin. But if we take interrupts that take a full second
674: * to process, other things are going to break horribly.
675: */
676:
677: /*
678: * Lock out updates.
679: * We set the No Updates bit in Clock Status Register B.
680: */
681: write_cmos (SRB, read_cmos (SRB) | NO_UPD);
682: return 1;
683: } /* lock_clock() */
684:
685: /*
686: * void unlock_clock() -- Restart the update cycle on the CMOS RT clock.
687: */
688: void
689: unlock_clock()
690: {
691: /*
692: * We clear the No Updates bit in Clock Status Register B.
693: */
694: write_cmos (SRB, read_cmos(SRB) & ~ NO_UPD);
695: } /* unlock_clock() */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.