![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to a.i CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / ccom / vax / tests|
Return to a.i CVS log | Up to [Research Unix] / researchv10no / cmd / ccom / vax / tests |
1.1 root 1: /* machdep.c */
2: typedef unsigned char u_char;
3: typedef unsigned short u_short;
4: typedef unsigned int u_int;
5: typedef unsigned long u_long;
6: typedef struct _physadr { int r[1]; } *physadr;
7: typedef int daddr_t;
8: typedef char * caddr_t;
9: typedef u_short ino_t;
10: typedef int swblk_t;
11: typedef int size_t;
12: typedef int time_t;
13: typedef int label_t[14];
14: typedef short dev_t;
15: typedef int off_t;
16: typedef long portid_t;
17: typedef struct fd_set { int fds_bits[1]; } fd_set;
18: int hz;
19: int timezone;
20: int dstflag;
21: char canonb[256 ];
22: extern char version[];
23: int lbolt;
24: time_t time;
25: time_t bootime;
26: long trannum;
27: int hand;
28: int nblkdev;
29: int nchrdev;
30: int nstream;
31: int nswdev;
32: int mpid;
33: char runin;
34: char runout;
35: int runrun;
36: char kmapwnt;
37: char curpri;
38: int maxmem;
39: int physmem;
40: int nswap;
41: int updlock;
42: daddr_t rablock;
43: extern int intstack[];
44: dev_t rootdev;
45: dev_t dumpdev;
46: long dumplo;
47: dev_t swapdev;
48: dev_t argdev;
49: dev_t pipedev;
50: extern int icode[];
51: extern int szicode;
52: dev_t getmdev();
53: daddr_t bmap();
54: caddr_t calloc();
55: unsigned max();
56: unsigned min();
57: int memall();
58: int uchar(), schar();
59: int vmemall();
60: char *wmemall();
61: swblk_t vtod();
62: extern struct sysent
63: {
64: int sy_narg;
65: int (*sy_call)();
66: } sysent[];
67: extern char vmmap[];
68: int umbabeg,umbaend;
69: int noproc;
70: extern int catcher[256];
71: char *panicstr;
72: int wantin;
73: int boothowto;
74: struct direct
75: {
76: ino_t d_ino;
77: char d_name[14 ];
78: };
79: struct pcb
80: {
81: int pcb_ksp;
82: int pcb_esp;
83: int pcb_ssp;
84: int pcb_usp;
85: int pcb_r0;
86: int pcb_r1;
87: int pcb_r2;
88: int pcb_r3;
89: int pcb_r4;
90: int pcb_r5;
91: int pcb_r6;
92: int pcb_r7;
93: int pcb_r8;
94: int pcb_r9;
95: int pcb_r10;
96: int pcb_r11;
97: int pcb_r12;
98: int pcb_r13;
99: int pcb_pc;
100: int pcb_psl;
101: struct pte *pcb_p0br;
102: int pcb_p0lr;
103: struct pte *pcb_p1br;
104: int pcb_p1lr;
105: int pcb_szpt;
106: int pcb_cmap2;
107: int *pcb_sswap;
108: int pcb_sigc[3];
109: };
110: struct dmap
111: {
112: swblk_t dm_size;
113: swblk_t dm_alloc;
114: swblk_t dm_map[ 32 ];
115: };
116: struct dmap zdmap;
117: struct dblock
118: {
119: swblk_t db_base;
120: swblk_t db_size;
121: };
122: struct vtimes {
123: int vm_utime;
124: int vm_stime;
125:
126: unsigned vm_idsrss;
127: unsigned vm_ixrss;
128: int vm_maxrss;
129: int vm_majflt;
130: int vm_minflt;
131: int vm_nswap;
132: int vm_inblk;
133: int vm_oublk;
134: };
135: struct vtimes zvms;
136:
137:
138: struct user
139: {
140: struct pcb u_pcb;
141: int u_arg[5];
142: label_t u_qsav;
143: char u_segflg;
144: char u_error;
145: short u_uid;
146: short u_gid;
147: short u_ruid;
148: short u_rgid;
149: struct proc *u_procp;
150: int *u_ap;
151: union {
152: struct {
153: int R_val1;
154: int R_val2;
155: } u_rv;
156: off_t r_off;
157: time_t r_time;
158: } u_r;
159: caddr_t u_base;
160: unsigned int u_count;
161: off_t u_offset;
162: struct inode *u_cdir;
163: struct inode *u_rdir;
164: char u_dbuf[14 ];
165: caddr_t u_dirp;
166: struct direct u_dent;
167: struct inode *u_pdir;
168: struct file *u_ofile[20 ];
169: char u_pofile[20 ];
170: label_t u_ssav;
171: int (*u_signal[32])();
172: int u_code;
173: int *u_ar0;
174: struct uprof {
175: short *pr_base;
176: unsigned pr_size;
177: unsigned pr_off;
178: unsigned pr_scale;
179: } u_prof;
180: char u_eosys;
181: char u_sep;
182: dev_t u_ttydev;
183: ino_t u_ttyino;
184: union {
185: struct {
186: int Ux_mag;
187: unsigned Ux_tsize;
188: unsigned Ux_dsize;
189: unsigned Ux_bsize;
190: unsigned Ux_ssize;
191: unsigned Ux_entloc;
192: unsigned Ux_unused;
193: unsigned Ux_relflg;
194: } Ux_A;
195: char ux_shell[32];
196: } u_exdata;
197: char u_comm[14 ];
198: time_t u_start;
199: char u_acflag;
200: short u_fpflag;
201: short u_cmask;
202: size_t u_tsize;
203: size_t u_dsize;
204: size_t u_ssize;
205: struct vtimes u_vm;
206: struct vtimes u_cvm;
207: struct dmap u_dmap;
208: struct dmap u_smap;
209: struct dmap u_cdmap, u_csmap;
210: time_t u_outime;
211: size_t u_odsize, u_ossize;
212: size_t u_vrpages[20 ];
213: int u_limit[8];
214: int u_stack[1];
215:
216: };
217: extern struct user u;
218: extern struct user swaputl;
219: extern struct user forkutl;
220: extern struct user xswaputl;
221: extern struct user xswap2utl;
222: extern struct user pushutl;
223: extern struct user vfutl;
224: extern struct user prusrutl;
225: struct map {
226: struct mapent *m_limit;
227: char *m_name;
228: };
229: struct mapent
230: {
231: int m_size;
232: int m_addr;
233: };
234: struct map *swapmap;
235: int nswapmap;
236: struct map *argmap;
237: struct map *kernelmap;
238:
239: struct pte
240: {
241: unsigned int pg_pfnum:21,
242: :2,
243: pg_vreadm:1,
244: pg_swapm:1,
245: pg_fod:1,
246: pg_m:1,
247: pg_prot:4,
248: pg_v:1;
249: };
250: struct hpte
251: {
252: unsigned int pg_pfnum:21,
253: :2,
254: pg_high:9;
255: };
256: struct fpte
257: {
258: unsigned int pg_blkno:20,
259: pg_fileno:5,
260: pg_fod:1,
261: :1,
262: pg_prot:4,
263: pg_v:1;
264: };
265: struct pte *vtopte();
266: extern struct pte Sysmap[];
267: extern struct pte Usrptmap[];
268: extern struct pte usrpt[];
269: extern struct pte Swapmap[];
270: extern struct pte Forkmap[];
271: extern struct pte Xswapmap[];
272: extern struct pte Xswap2map[];
273: extern struct pte Pushmap[];
274: extern struct pte Vfmap[];
275: extern struct pte mmap[];
276: extern struct pte msgbufmap[];
277: extern struct pte camap[];
278: extern struct pte Nexmap[][16];
279: extern struct pte Prusrmap[];
280:
281:
282: int klseql;
283: int klsdist;
284: int klin;
285: int kltxt;
286: int klout;
287: struct vmmeter
288: {
289: unsigned v_swtch;
290: unsigned v_trap;
291: unsigned v_syscall;
292: unsigned v_intr;
293: unsigned v_pdma;
294: unsigned v_pswpin;
295: unsigned v_pswpout;
296: unsigned v_pgin;
297: unsigned v_pgout;
298: unsigned v_pgpgin;
299: unsigned v_pgpgout;
300: unsigned v_intrans;
301: unsigned v_pgrec;
302: unsigned v_xsfrec;
303: unsigned v_xifrec;
304: unsigned v_exfod;
305: unsigned v_zfod;
306: unsigned v_vrfod;
307: unsigned v_nexfod;
308: unsigned v_nzfod;
309: unsigned v_nvrfod;
310: unsigned v_pgfrec;
311: unsigned v_faults;
312: unsigned v_scan;
313: unsigned v_rev;
314: unsigned v_seqfree;
315: unsigned v_dfree;
316: unsigned v_swpin;
317: unsigned v_swpout;
318: };
319: struct vmmeter cnt, rate, sum;
320: struct vmtotal
321: {
322: short t_rq;
323: short t_dw;
324: short t_pw;
325: short t_sl;
326: short t_sw;
327: int t_vm;
328: int t_avm;
329: short t_rm;
330: short t_arm;
331: int t_vmtxt;
332: int t_avmtxt;
333: short t_rmtxt;
334: short t_armtxt;
335: short t_free;
336: };
337: struct vmtotal total;
338: int freemem;
339: int avefree;
340: int avefree30;
341: int deficit;
342: int nscan;
343: int multprog;
344: int desscan;
345: int maxpgio;
346: int maxslp;
347: int lotsfree;
348: int minfree;
349: int desfree;
350: int saferss;
351: struct forkstat
352: {
353: int cntfork;
354: int cntvfork;
355: int sizfork;
356: int sizvfork;
357: };
358: struct forkstat forkstat;
359: struct swptstat
360: {
361: int pteasy;
362: int ptexpand;
363: int ptshrink;
364: int ptpack;
365: };
366: struct swptstat swptstat;
367: struct proc
368: {
369: struct proc *p_link;
370: struct proc *p_rlink;
371: struct pte *p_addr;
372: char p_usrpri;
373: char p_pri;
374: char p_cpu;
375: char p_stat;
376: char p_time;
377: char p_nice;
378: char p_slptime;
379: char p_cursig;
380: long p_sig;
381: long p_siga0;
382: long p_siga1;
383: int p_flag;
384: short p_uid;
385: short p_pgrp;
386: short p_pid;
387: short p_ppid;
388: short p_poip;
389: short p_szpt;
390: size_t p_tsize;
391: size_t p_dsize;
392: size_t p_ssize;
393: size_t p_rssize;
394: size_t p_maxrss;
395: size_t p_swrss;
396: swblk_t p_swaddr;
397: caddr_t p_wchan;
398: struct text *p_textp;
399: u_short p_clktim;
400: u_short p_tsleep;
401: struct pte *p_p0br;
402: struct proc *p_xlink;
403: short p_cpticks;
404: float p_pctcpu;
405: short p_ndx;
406: short p_idhash;
407: struct proc *p_pptr;
408: struct inode *p_trace;
409: };
410: short pidhash[ 63];
411: struct proc *pfind();
412: struct proc *proc, *procNPROC;
413: int nproc;
414: struct prochd {
415: struct proc *ph_link;
416: struct proc *ph_rlink;
417: } qs[32 ];
418: int whichqs;
419: struct xproc
420: {
421: struct proc *xp_link;
422: struct proc *xp_rlink;
423: struct pte *xp_addr;
424: char xp_usrpri;
425: char xp_pri;
426: char xp_cpu;
427: char xp_stat;
428: char xp_time;
429: char xp_nice;
430: char xp_slptime;
431: char p_cursig;
432: int xp_sig;
433: int xp_siga0;
434: int xp_siga1;
435: int xp_flag;
436: short xp_uid;
437: short xp_pgrp;
438: short xp_pid;
439: short xp_ppid;
440: short xp_xstat;
441: struct vtimes xp_vm;
442: };
443: struct bufhd
444: {
445: long b_flags;
446: struct buf *b_forw, *b_back;
447: };
448: struct buf
449: {
450: long b_flags;
451: struct buf *b_forw, *b_back;
452: struct buf *av_forw, *av_back;
453: long b_bcount;
454: short b_error;
455: dev_t b_dev;
456: union {
457: caddr_t b_addr;
458: int *b_words;
459: struct filsys *b_filsys;
460: struct dinode *b_dino;
461: daddr_t *b_daddr;
462: } b_un;
463: daddr_t b_blkno;
464: long b_resid;
465: struct proc *b_proc;
466: };
467: struct buf *buf;
468: char *buffers;
469: int nbuf;
470: struct buf *swbuf;
471: int nswbuf;
472: short *swsize;
473: int *swpf;
474: struct buf bfreelist[ 3 ];
475: struct buf bswlist;
476: struct buf *bclnlist;
477: struct buf *alloc();
478: struct buf *baddr();
479: struct buf *getblk();
480: struct buf *geteblk();
481: struct buf *bread();
482: struct buf *breada();
483: unsigned minphys();
484: struct uba_hd {
485: struct uba_regs *uh_uba;
486: struct uba_regs *uh_physuba;
487: int (**uh_vec)();
488: struct uba_device *uh_actf;
489: struct uba_device *uh_actl;
490: short uh_mrwant;
491: short uh_bdpwant;
492: int uh_bdpfree;
493: int uh_hangcnt;
494: int uh_zvcnt;
495: int uh_errcnt;
496: int uh_lastiv;
497: short uh_users;
498: short uh_xclu;
499: struct map *uh_map;
500: };
501: struct uba_ctlr {
502: struct uba_driver *um_driver;
503: short um_ctlr;
504: short um_ubanum;
505: short um_alive;
506: int (**um_intr)();
507: caddr_t um_addr;
508: struct uba_hd *um_hd;
509: int um_cmd;
510: int um_ubinfo;
511: struct buf um_tab;
512: };
513: struct uba_device {
514: struct uba_driver *ui_driver;
515: short ui_unit;
516: short ui_ctlr;
517: short ui_ubanum;
518: short ui_slave;
519: int (**ui_intr)();
520: caddr_t ui_addr;
521: short ui_dk;
522: int ui_flags;
523: short ui_alive;
524: short ui_type;
525: caddr_t ui_physaddr;
526: struct uba_device *ui_forw;
527: struct uba_ctlr *ui_mi;
528: struct uba_hd *ui_hd;
529: };
530: struct uba_driver {
531: int (*ud_probe)();
532: int (*ud_slave)();
533: int (*ud_attach)();
534: int (*ud_dgo)();
535: u_short *ud_addr;
536: char *ud_dname;
537: struct uba_device **ud_dinfo;
538: char *ud_mname;
539: struct uba_ctlr **ud_minfo;
540: short ud_xclu;
541: };
542: int numuba;
543: extern struct uba_hd uba_hd[];
544: extern struct uba_ctlr ubminit[];
545: extern struct uba_device ubdinit[];
546: extern struct pte UMEMmap[][16];
547: extern char umem[][16* 512];
548: extern int (*UNIvec[])();
549: struct uba_regs
550: {
551: int uba_cnfgr;
552: int uba_cr;
553: int uba_sr;
554: int uba_dcr;
555: int uba_fmer;
556: int uba_fubar;
557: int pad1[2];
558: int uba_brsvr[4];
559: int uba_brrvr[4];
560: int uba_dpr[16];
561: int pad2[480];
562: struct pte uba_map[496];
563: int pad3[16];
564: };
565:
566:
567: struct bdevsw
568: {
569: int (*d_open)();
570: int (*d_close)();
571: int (*d_strategy)();
572: int (*d_dump)();
573: int d_flags;
574: };
575: extern struct bdevsw bdevsw[];
576: extern struct cdevsw
577: {
578: int (*d_open)();
579: int (*d_close)();
580: int (*d_read)();
581: int (*d_write)();
582: int (*d_ioctl)();
583: int (*d_reset)();
584: struct streamtab *qinfo;
585: };
586: extern struct cdevsw cdevsw[];
587: struct fstypsw {
588: int (*t_put)();
589: struct inode *(*t_get)();
590: int (*t_free)();
591: int (*t_updat)();
592: int (*t_read)();
593: int (*t_write)();
594: int (*t_trunc)();
595: int (*t_stat)();
596: int (*t_nami)();
597: int (*t_mount)();
598: int (*t_ioctl)();
599: };
600: extern struct fstypsw fstypsw[];
601: extern nfstyp;
602: extern struct streamtab {
603: struct qinit *rdinit;
604: struct qinit *wrinit;
605: } *streamtab[];
606: struct swdevt
607: {
608: dev_t sw_dev;
609: int sw_freed;
610: };
611: extern struct swdevt swdevt[];
612: struct mcr {
613: int mc_reg[3];
614: };
615: int nmcr;
616: struct mcr *mcraddr[ 1];
617: union cpusid {
618: int cpusid;
619: struct cpuany {
620: u_int :24,
621: cp_type:8;
622: } cpuany;
623: struct cpu780 {
624: u_int cp_sno:12,
625: cp_plant:3,
626: cp_eco:9,
627: cp_type:8;
628: } cpu780;
629: struct cpu750 {
630: u_int cp_hrev:8,
631: cp_urev:8,
632: :8,
633: cp_type:8;
634: } cpu750;
635:
636: };
637: struct percpu {
638: short pc_cputype;
639: short pc_nnexus;
640: struct nexus *pc_nexbase;
641: caddr_t *pc_umaddr;
642: short pc_nubabdp;
643: short pc_haveubasr;
644: short *pc_nextype;
645: };
646: int cpu;
647: extern struct percpu percpu[];
648: struct inode
649: {
650: short i_flag;
651: u_char i_count;
652: char i_fstyp;
653: dev_t i_dev;
654: long i_number;
655: unsigned short i_mode;
656: short i_nlink;
657: short i_uid;
658: short i_gid;
659: off_t i_size;
660: struct stdata *i_sptr;
661: union {
662: struct {
663: daddr_t I_addr[13];
664: daddr_t I_lastr;
665: } i_f;
666: struct {
667: daddr_t I_rdev;
668: long I_key;
669: } i_d;
670: struct {
671: long I_tag;
672: struct inode *I_cip;
673: } i_a;
674: struct {
675: struct proc *I_proc;
676: int I_sigmask;
677: } i_p;
678: } i_un;
679: short i_hlink;
680: };
681: struct inode *inode, *inodeNINODE;
682: int ninode;
683: struct inode *rootdir;
684: struct inode *ialloc();
685: struct inode *ifind();
686: struct inode *iget();
687: struct inode *owner();
688: struct inode *maknode();
689: struct inode *namei();
690: struct argnamei {
691: short flag;
692: ino_t ino;
693: dev_t idev;
694: short mode;
695: };
696: struct nx {
697: struct inode *dp;
698: char *cp;
699: struct buf *nbp;
700: int nlink;
701: };
702: struct file
703: {
704: short f_flag;
705: short f_count;
706: struct inode *f_inode;
707: off_t f_offset;
708: };
709: struct file *file, *fileNFILE;
710: int nfile;
711: struct file *getf();
712: struct file *falloc();
713: struct text
714: {
715: swblk_t x_daddr[12 ];
716: swblk_t x_ptdaddr;
717: size_t x_size;
718: struct proc *x_caddr;
719: struct inode *x_iptr;
720: short x_rssize;
721: short x_swrss;
722: char x_count;
723: char x_ccount;
724: char x_flag;
725: char x_slptime;
726: short x_poip;
727: };
728: struct text *text, *textNTEXT;
729: int ntext;
730: struct callout {
731: int c_time;
732: caddr_t c_arg;
733: int (*c_func)();
734: struct callout *c_next;
735: };
736: struct callout *callfree, *callout, calltodo;
737: int ncallout;
738: struct cmap
739: {
740: unsigned int c_next:13,
741: c_prev:13,
742: c_lock:1,
743: c_want:1,
744: c_page:16,
745: c_hlink:13,
746: c_intrans:1,
747: c_free:1,
748: c_gone:1,
749: c_type:2,
750: c_blkno:20,
751: c_ndx:10,
752: c_mdev:6;
753: };
754: struct cmap *cmap;
755: struct cmap *ecmap;
756: int ncmap;
757: struct cmap *mfind();
758: int firstfree, maxfree;
759: int ecmx;
760: short cmhash[512 ];
761: struct frame {
762: int fr_handler;
763: u_int fr_psw:16,
764: fr_mask:12,
765: :1,
766: fr_s:1,
767: fr_spa:2;
768: int fr_savap;
769: int fr_savfp;
770: int fr_savpc;
771: };
772: struct rpb {
773: struct rpb *rp_selfref;
774: int (*rp_dumprout)();
775: long rp_checksum;
776: long rp_flag;
777: };
778: extern struct rpb rpb;
779: int icode[] =
780: {
781: 0x9f19af9f,
782: 0x02dd09af,
783: 0xbc5c5ed0,
784: 0x2ffe110b,
785: 0x2f637465,
786: 0x74696e69,
787: 0x00000000,
788: 0x00000014,
789: 0x00000000,
790: };
791: int szicode = sizeof(icode);
792:
793: int nbuf = 0;
794: int nswbuf = 0;
795: startup(firstaddr)
796: int firstaddr;
797: {
798: register int unixsize;
799: register unsigned i;
800: register struct pte *pte;
801: register caddr_t v;
802:
803: maxmem -= 2;
804: pte = msgbufmap;
805: for (i = 0; i < 2; i++)
806: *(int *)pte++ = 0x80000000 | 0x10000000 | (maxmem + i);
807: mtpr(0x39 , 1);
808:
809: printf(version);
810:
811:
812: if (nbuf == 0) {
813: nbuf = (32 * physmem) / ((((unsigned)(1024*1024)+511)>>9));
814: if (nbuf < 32)
815: nbuf = 32;
816: }
817: if (nswbuf == 0) {
818: nswbuf = (nbuf / 2) &~ 1;
819: if (nswbuf > 256)
820: nswbuf = 256;
821: }
822: printf("real mem = %d nbuf = %d nswbuf = %d\n", ((maxmem)<<9),
823: nbuf, nswbuf);
824:
825: v = (caddr_t)(0x80000000 | (firstaddr * 512));
826: (buffers) = ( char *)(v); (v) = (caddr_t)((buffers)+( 4096*nbuf));
827: (buf) = ( struct buf *)(v); (v) = (caddr_t)((buf)+( nbuf));
828: (swbuf) = ( struct buf *)(v); (v) = (caddr_t)((swbuf)+( nswbuf));
829: (swsize) = ( short *)(v); (v) = (caddr_t)((swsize)+( nswbuf));
830: (swpf) = ( int *)(v); (v) = (caddr_t)((swpf)+( nswbuf));
831: (inode) = ( struct inode *)(v); (v) = (caddr_t)(( inodeNINODE) = ((inode)+( ninode)));
832: (file) = ( struct file *)(v); (v) = (caddr_t)(( fileNFILE) = ((file)+( nfile)));
833: (proc) = ( struct proc *)(v); (v) = (caddr_t)(( procNPROC) = ((proc)+( nproc)));
834: (text) = ( struct text *)(v); (v) = (caddr_t)(( textNTEXT) = ((text)+( ntext)));
835: (callout) = ( struct callout *)(v); (v) = (caddr_t)((callout)+( ncallout));
836: (swapmap) = ( struct map *)(v); (v) = (caddr_t)((swapmap)+( nswapmap = nproc * 2));
837: (argmap) = ( struct map *)(v); (v) = (caddr_t)((argmap)+( 16));
838: (kernelmap) = ( struct map *)(v); (v) = (caddr_t)((kernelmap)+( nproc));
839:
840: ncmap = (physmem* 512 - ((int)v &~ 0x80000000)) /
841: ( 512*2 + sizeof (struct cmap));
842: (cmap) = ( struct cmap *)(v); (v) = (caddr_t)(( ecmap) = ((cmap)+( ncmap)));
843: if ((((int)(ecmap+1))&~0x80000000) > (32* ( 512/(sizeof (struct pte))))* 512)
844: panic("sys pt too small");
845:
846: unixsize = ((((unsigned)((int)(ecmap+1) &~ 0x80000000)+511)>>9));
847: if (unixsize >= physmem - 8*8 )
848: panic("no memory");
849: pte = &Sysmap[firstaddr];
850: for (i = firstaddr; i < unixsize; i++) {
851: *(int *)(&Sysmap[i]) = 0x80000000 | 0x10000000 | i;
852: clearseg(i);
853: }
854: mtpr(0x39 , 1);
855:
856: callfree = callout;
857: for (i = 1; i < ncallout; i++)
858: callout[i-1].c_next = &callout[i];
859:
860: meminit(unixsize, maxmem);
861: maxmem = freemem;
862: printf("avail mem = %d\n", ((maxmem)<<9));
863: rminit(kernelmap, (8* ( 512/(sizeof (struct pte)))), 1, "usrpt", nproc);
864:
865: configure();
866:
867: tocons(0xf03 );
868: tocons(0xf04 );
869: }
870: sysphys()
871: {
872: if(!suser())
873: return;
874: u.u_error = 22;
875: }
876: clkinit(base)
877: time_t base;
878: {
879: register unsigned todr = mfpr(0x1b );
880: long deltat;
881: int year = 1970;
882: if (base < 5* ((unsigned)(365* ((unsigned)(24*60*60)) )) ) {
883: printf("WARNING: preposterous time in file system");
884: time = 6* ((unsigned)(365* ((unsigned)(24*60*60)) )) + 186* ((unsigned)(24*60*60)) + ((unsigned)(24*60*60)) /2;
885: clkset();
886: goto check;
887: }
888:
889: if (todr < ((unsigned)(1<<28))) {
890: printf("WARNING: todr too small");
891: time = base;
892:
893: clkset();
894: goto check;
895: }
896:
897: for (time = (todr-((unsigned)(1<<28)))/100; time < base- ((unsigned)(365* ((unsigned)(24*60*60)) )) /2; time += ((unsigned)(365* ((unsigned)(24*60*60)) )) ) {
898: if ( ((year)%4==0) )
899: time += ((unsigned)(24*60*60)) ;
900: year++;
901: }
902:
903: deltat = time - base;
904: if (deltat < 0)
905: deltat = -deltat;
906: if (deltat < 2* ((unsigned)(24*60*60)) )
907: return;
908: printf("WARNING: clock %s %d days",
909: time < base ? "lost" : "gained", deltat / ((unsigned)(24*60*60)) );
910: check:
911: printf(" -- CHECK AND RESET THE DATE!\n");
912: }
913: clkset()
914: {
915: int year = 1970;
916: unsigned secyr;
917: unsigned yrtime = time;
918:
919: for (;;) {
920: secyr = ((unsigned)(365* ((unsigned)(24*60*60)) )) ;
921: if ( ((year)%4==0) )
922: secyr += ((unsigned)(24*60*60)) ;
923: if (yrtime < secyr)
924: break;
925: yrtime -= secyr;
926: year++;
927: }
928: mtpr(0x1b , ((unsigned)(1<<28)) + yrtime*100);
929: }
930: sendsig(p, n)
931: int (*p)();
932: {
933: register int *usp, *regs;
934: regs = u.u_ar0;
935: usp = (int *)regs[(-5)];
936: usp -= 5;
937: if ((int)usp <= (0x80000000-8 * 512) - ((u.u_ssize)<<9))
938: (void) grow((unsigned)usp);
939: ;
940: asm("probew $3,$20,(r11)");
941: asm("beql bad");
942: *usp++ = n;
943: if (n == 4 || n == 8 ) {
944: *usp++ = u.u_code;
945: u.u_code = 0;
946: } else
947: *usp++ = 0;
948: *usp++ = (int)p;
949: *usp++ = regs[(-2)];
950: *usp++ = regs[(-1)];
951: regs[(-5)] = (int)(usp - 5);
952: regs[(-1)] &= ~( 0x80000000 | 0x08000000 );
953: regs[(-2)] = (int)u.u_pcb.pcb_sigc;
954: return;
955: asm("bad:");
956: bad:
957:
958: u.u_signal[4 ] = (int (*)())0;
959: u.u_procp->p_siga0 &= ~(1<<(4 -1));
960: u.u_procp->p_siga1 &= ~(1<<(4 -1));
961: psignal(u.u_procp, 4 );
962: }
963: dorti()
964: {
965: struct frame frame;
966: register int sp;
967: register int reg, mask;
968: extern int ipcreg[];
969: (void) copyin((caddr_t)u.u_ar0[(-20)], (caddr_t)&frame, sizeof (frame));
970: sp = u.u_ar0[(-20)] + sizeof (frame);
971: u.u_ar0[(-2)] = frame.fr_savpc;
972: u.u_ar0[(-20)] = frame.fr_savfp;
973: u.u_ar0[(-21)] = frame.fr_savap;
974: mask = frame.fr_mask;
975: for (reg = 0; reg <= 11; reg++) {
976: if (mask&1) {
977: u.u_ar0[ipcreg[reg]] = fuword((caddr_t)sp);
978: sp += 4;
979: }
980: mask >>= 1;
981: }
982: sp += frame.fr_spa;
983: u.u_ar0[(-1)] = (u.u_ar0[(-1)] & 0xffff0000) | frame.fr_psw;
984: if (frame.fr_s)
985: sp += 4 + 4 * (fuword((caddr_t)sp) & 0xff);
986:
987: u.u_ar0[(-2)] = fuword((caddr_t)sp);
988: sp += 4;
989: u.u_ar0[(-1)] = fuword((caddr_t)sp);
990: sp += 4;
991: u.u_ar0[(-1)] |= (0x00c00000 |0x03000000 );
992: u.u_ar0[(-1)] &= ~( 0x04000000 | 0x001f0000 | 0x3020ff00 );
993: u.u_ar0[(-5)] = (int)sp;
994: }
995: int memintvl = (60*60*30) ;
996: memenable()
997: {
998: register struct mcr *mcr;
999: register int m;
1000: for (m = 0; m < nmcr; m++) {
1001: mcr = mcraddr[m];
1002: switch (cpu) {
1003: }
1004: }
1005: if (memintvl > 0)
1006: timeout(memenable, (caddr_t)0, memintvl);
1007: }
1008: memerr()
1009: {
1010: register struct mcr *mcr;
1011: register int m;
1012: for (m = 0; m < nmcr; m++) {
1013: mcr = mcraddr[m];
1014: switch (cpu) {
1015: }
1016: }
1017: }
1018: tbiscl(v)
1019: unsigned v;
1020: {
1021: register caddr_t addr;
1022: register int i;
1023: asm(".set TBIS,58");
1024: addr = ((caddr_t)((v) << 9 ));
1025: for (i = 0; i < 2; i++) {
1026: asm("mtpr r11,$TBIS");
1027: addr += 512;
1028: }
1029: }
1030:
1031: int waittime = -1;
1032: boot(paniced, arghowto)
1033: int paniced, arghowto;
1034: {
1035: register int howto;
1036: register int devtype;
1037: howto = arghowto;
1038: if ((howto&4 )==0 && waittime < 0 && bfreelist[0].b_forw) {
1039: waittime = 0;
1040: update();
1041: printf("syncing disks... ");
1042: while (++waittime <= 5)
1043: sleep((caddr_t)&lbolt, 25);
1044: printf("done\n");
1045: }
1046: splx(0x1f);
1047: devtype = ((int)(((unsigned)(rootdev)>>8)&0377));
1048: if (howto& 8 ) {
1049: printf("halting (in tight loop); hit\n\t^P\n\tHALT\n\n");
1050: mtpr(0x12 , 0x1f);
1051: for (;;)
1052: ;
1053: } else {
1054: if (paniced == 0 )
1055: doadump();
1056: tocons(0xf02 );
1057: }
1058: for (;;)
1059: asm("halt");
1060:
1061: }
1062: tocons(c)
1063: {
1064: while ((mfpr(0x22 )&0x00000080 ) == 0)
1065: continue;
1066: mtpr(0x23 , c);
1067: }
1068: dumpsys()
1069: {
1070: rpb.rp_flag = 1;
1071: if (( ((int)((dumpdev)&0377))&07) != 1)
1072: return;
1073: printf("\ndumping to dev %x, offset %d\n", dumpdev, dumplo);
1074: printf("dump ");
1075: switch ((*bdevsw[ ((int)(((unsigned)(dumpdev)>>8)&0377))].d_dump)(dumpdev)) {
1076: case 6:
1077: printf("device bad\n");
1078: break;
1079: case 14:
1080: printf("device not ready\n");
1081: break;
1082: case 22:
1083: printf("area improper\n");
1084: break;
1085: case 5:
1086: printf("i/o error");
1087: break;
1088: default:
1089: printf("succeeded");
1090: break;
1091: }
1092: }
1093: struct mc780frame {
1094: int mc8_bcnt;
1095: int mc8_summary;
1096: int mc8_cpues;
1097: int mc8_upc;
1098: int mc8_vaviba;
1099: int mc8_dreg;
1100: int mc8_tber0;
1101: int mc8_tber1;
1102: int mc8_timo;
1103: int mc8_parity;
1104: int mc8_sbier;
1105: int mc8_pc;
1106: int mc8_psl;
1107: };
1108: struct mc750frame {
1109: int mc5_bcnt;
1110: int mc5_summary;
1111: int mc5_va;
1112: int mc5_errpc;
1113: int mc5_mdr;
1114: int mc5_svmode;
1115: int mc5_rdtimo;
1116: int mc5_tbgpar;
1117: int mc5_cacherr;
1118: int mc5_buserr;
1119: int mc5_mcesr;
1120: int mc5_pc;
1121: int mc5_psl;
1122: };
1123: struct mc7ZZframe {
1124: int mc3_bcnt;
1125: int mc3_summary;
1126: int mc3_parm[2];
1127: int mc3_pc;
1128: int mc3_psl;
1129: };
1130: machinecheck(cmcf)
1131: caddr_t cmcf;
1132: {
1133: register u_int type = ((struct mc780frame *)cmcf)->mc8_summary;
1134: printf("machine check %x: ", type);
1135: switch (cpu) {
1136: }
1137: switch (cpu) {
1138: }
1139: panic("mchk");
1140: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.