![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Plan 9 NeXT] / lucent / sys / src / 9 / gnot|
Return to main.c CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / 9 / gnot |
1.1 root 1: #include "u.h"
2: #include "../port/lib.h"
3: #include "mem.h"
4: #include "dat.h"
5: #include "fns.h"
6: #include "io.h"
7: #include "ureg.h"
8: #include "init.h"
9:
10: #include <libg.h>
11: #include <gnot.h>
12:
13: typedef struct Boot Boot;
14: struct Boot
15: {
16: long station;
17: long traffic;
18: char user[NAMELEN];
19: char server[64];
20: char line[64];
21: char device;
22: };
23: #define BOOT ((Boot*)0)
24:
25: char bootuser[NAMELEN];
26: char bootline[64];
27: char bootserver[72];
28: int bank[2];
29: uchar *sp;
30:
31: extern GBitmap gscreen;
32:
33: void unloadboot(void);
34:
35: void
36: main(void)
37: {
38: u = 0;
39: unloadboot();
40: machinit();
41: active.exiting = 0;
42: active.machs = 1;
43: mmuinit();
44: confinit();
45: xinit();
46: kmapinit();
47: duartinit();
48: screeninit();
49: printinit();
50: print("bank 0: %dM bank 1: %dM\n", bank[0], bank[1]);
51: flushmmu();
52: pageinit();
53: procinit0();
54: initseg();
55: chandevreset();
56: streaminit();
57: swapinit();
58: kmapinit();
59: userinit();
60: schedinit();
61: }
62:
63: void
64: unloadboot(void)
65: {
66: char s[64];
67:
68: memmove(bootuser, BOOT->user, sizeof(bootuser)-1);
69: bootuser[sizeof(bootuser)-1] = 0;
70: memmove(bootline, BOOT->line, sizeof(bootline)-1);
71: bootline[sizeof(bootline)-1] = 0;
72: memmove(s, BOOT->server, sizeof(s) - 1);
73: s[sizeof(s)-1] = 0;
74: switch(BOOT->device){
75: case 'a':
76: sprint(bootserver, "19200!%s", s);
77: break;
78: case 'A':
79: sprint(bootserver, "9600!%s", s);
80: break;
81: case 'i':
82: sprint(bootserver, "incon!%s", s);
83: break;
84: default:
85: /* older boot ROM's don't zero out BOOT->user if it isn't set. */
86: memset(bootuser, 0, sizeof(bootuser));
87: sprint(bootserver, "scsi!%s", s);
88: break;
89: }
90: }
91:
92: void
93: machinit(void)
94: {
95: int n;
96:
97: n = m->machno;
98: memset(m, 0, sizeof(Mach));
99: m->machno = n;
100: m->fpstate = FPinit;
101: fprestore(&initfp);
102: }
103:
104: void
105: mmuinit(void)
106: {
107: ulong l, d, i;
108:
109: /*
110: * Invalidate user addresses
111: */
112: for(l=0; l<4*1024*1024; l+=BY2PG)
113: putmmu(l, INVALIDPTE, 0);
114: /*
115: * Four meg of usable memory, with top 256K for screen
116: */
117: for(i=1,l=KTZERO; i<MB4/BY2PG; l+=BY2PG,i++)
118: putkmmu(l, PPN(l)|PTEVALID|PTEKERNEL);
119: /*
120: * Screen after end
121: */
122: l = PGROUND((ulong)end);
123: gscreen.base = (ulong*)l;
124: for(i=0,d=DISPLAYRAM; i<256*1024/BY2PG; d+=BY2PG,l+=BY2PG,i++)
125: putkmmu(l, PPN(d)|PTEVALID|PTEKERNEL);
126: }
127:
128: void
129: init0(void)
130: {
131: u->nerrlab = 0;
132: m->proc = u->p;
133: u->p->state = Running;
134: u->p->mach = m;
135: spllo();
136:
137: u->slash = (*devtab[0].attach)(0);
138: u->dot = clone(u->slash, 0);
139:
140: kproc("alarm", alarmkproc, 0);
141: chandevinit();
142:
143: if(!waserror()){
144: ksetterm("at&t %s");
145: ksetenv("cputype", "68020");
146: poperror();
147: }
148:
149: touser(sp);
150: }
151:
152: FPsave initfp;
153:
154: void
155: userinit(void)
156: {
157: Proc *p;
158: Segment *s;
159: User *up;
160: KMap *k;
161: Page *pg;
162:
163: p = newproc();
164: p->pgrp = newpgrp();
165: p->egrp = smalloc(sizeof(Egrp));
166: p->egrp->ref = 1;
167: p->fgrp = smalloc(sizeof(Fgrp));
168: p->fgrp->ref = 1;
169: p->procmode = 0640;
170:
171: strcpy(p->text, "*init*");
172: strcpy(p->user, eve);
173: p->fpstate = FPinit;
174:
175: /*
176: * Kernel Stack
177: */
178: p->sched.pc = (ulong)init0;
179: p->sched.sp = USERADDR+BY2PG-5*BY2WD;
180: p->sched.sr = SUPER|SPL(0);
181: p->upage = newpage(1, 0, USERADDR|(p->pid&0xFFFF));
182:
183: /*
184: * User
185: */
186: k = kmap(p->upage);
187: up = (User*)VA(k);
188: up->p = p;
189: kunmap(k);
190:
191: /*
192: * User Stack, copy in boot arguments
193: */
194: s = newseg(SG_STACK, USTKTOP-BY2PG, 1);
195: p->seg[SSEG] = s;
196: pg = newpage(1, 0, USTKTOP-BY2PG);
197: segpage(s, pg);
198: k = kmap(pg);
199: bootargs(VA(k));
200: kunmap(k);
201:
202: /*
203: * Text
204: */
205: s = newseg(SG_TEXT, UTZERO, 1);
206: p->seg[TSEG] = s;
207: segpage(s, newpage(1, 0, UTZERO));
208: k = kmap(s->map[0]->pages[0]);
209: memmove((ulong*)VA(k), initcode, sizeof initcode);
210: kunmap(k);
211:
212: ready(p);
213: }
214:
215: uchar *
216: pusharg(char *p)
217: {
218: int n;
219:
220: n = strlen(p)+1;
221: sp -= n;
222: memmove(sp, p, n);
223: return sp;
224: }
225:
226: void
227: bootargs(ulong base)
228: {
229: int i, ac;
230: uchar *av[32];
231: char *p, *pp;
232: uchar **lsp;
233:
234: sp = (uchar*)base + BY2PG - MAXSYSARG*BY2WD;
235:
236: ac = 0;
237: for(p = bootline; p && *p; p = pp){
238: pp = strchr(p, ' ');
239: if(pp)
240: *pp++ = 0;
241: av[ac++] = pusharg(p);
242: }
243: if(bootuser[0]){
244: av[ac++] = pusharg("-u");
245: av[ac++] = pusharg(bootuser);
246: }
247: av[ac++] = pusharg(bootserver);
248:
249: /* 4 byte word align stack */
250: sp = (uchar*)((ulong)sp & ~3);
251:
252: /* build argc, argv on stack */
253: sp -= (ac+1)*sizeof(sp);
254: lsp = (uchar**)sp;
255: for(i = 0; i < ac; i++)
256: *lsp++ = av[i] + ((USTKTOP - BY2PG) - base);
257: *lsp = 0;
258: sp += (USTKTOP - BY2PG) - base - sizeof(sp);
259: }
260:
261: void
262: exit(int ispanic)
263: {
264: int i;
265:
266: u = 0;
267: wipekeys();
268: spllo();
269: while(consactive())
270: for(i=0; i<1000; i++)
271: ;
272: splhi();
273: if(ispanic)
274: for(;;);
275: firmware();
276: }
277:
278: banksize(int base)
279: {
280: ulong va;
281:
282: if(end > (char *)((KZERO|1024L*1024L)-BY2PG))
283: return 0;
284: va = UZERO; /* user page 1 is free to play with */
285: putmmu(va, PTEVALID|(base+0)*MB/BY2PG, 0);
286: *(ulong*)va = 0; /* 0 at 0M */
287: putmmu(va, PTEVALID|(base+1)*MB/BY2PG, 0);
288: *(ulong*)va = 1; /* 1 at 1M */
289: putmmu(va, PTEVALID|(base+4)*MB/BY2PG, 0);
290: *(ulong*)va = 4; /* 4 at 4M */
291: putmmu(va, PTEVALID|(base+0)*MB/BY2PG, 0);
292: if(*(ulong*)va == 0)
293: return 16;
294: putmmu(va, PTEVALID|(base+1)*MB/BY2PG, 0);
295: if(*(ulong*)va == 1)
296: return 4;
297: putmmu(va, PTEVALID|(base+0)*MB/BY2PG, 0);
298: if(*(ulong*)va == 4)
299: return 1;
300: return 0;
301: }
302:
303: Conf conf;
304:
305: void
306: confinit(void)
307: {
308: int mul, pcnt;
309: ulong ktop;
310:
311: conf.nmach = 1;
312: if(conf.nmach > MAXMACH)
313: panic("confinit");
314: conf.monitor = 1;
315: bank[0] = banksize(0);
316: bank[1] = banksize(16);
317: conf.npage0 = (bank[0]*MB)/BY2PG;
318: conf.base0 = 0;
319: conf.npage1 = (bank[1]*MB)/BY2PG;
320: conf.base1 = 16*MB;
321: conf.npage = conf.npage0+conf.npage1;
322:
323: pcnt = screenbits()-1; /* Calculate % of memory for page pool */
324: pcnt = 70 - (pcnt*10);
325: conf.upages = (conf.npage*pcnt)/100;
326:
327: ktop = PGROUND((ulong)end) + 256*1024; /* cf. mmuinit */
328: ktop = PADDR(ktop);
329: conf.npage0 -= ktop/BY2PG;
330: conf.base0 += ktop;
331:
332: mul = 1 + (conf.npage1>0);
333: conf.nproc = 50*mul;
334: conf.nswap = 4096;
335: conf.nimage = 50;
336: conf.copymode = 0; /* copy on write */
337: conf.portispaged = 0;
338: confinit1(mul);
339: }
340:
341: /*
342: * set up floating point for a new process
343: */
344: void
345: procsetup(Proc *p)
346: {
347: long fpnull;
348:
349: fpnull = 0;
350: splhi();
351: m->fpstate = FPinit;
352: p->fpstate = FPinit;
353: fprestore((FPsave*)&fpnull);
354: spllo();
355: }
356:
357: /*
358: * Save the part of the process state.
359: */
360: void
361: procsave(Proc *p)
362: {
363: Balu *balu = (Balu *)u->balusave;
364:
365: USED(p);
366: fpsave(&u->fpsave);
367: if(u->fpsave.type){
368: if(u->fpsave.size > sizeof u->fpsave.junk)
369: panic("fpsize %d max %d\n", u->fpsave.size, sizeof u->fpsave.junk);
370: fpregsave(u->fpsave.reg);
371: u->p->fpstate = FPactive;
372: m->fpstate = FPdirty;
373: }
374: if(BALU->cr0 != 0xFFFFFFFF) /* balu busy */
375: memmove(balu, BALU, sizeof(Balu));
376: else{
377: balu->cr0 = 0xFFFFFFFF;
378: BALU->cr0 = 0xFFFFFFFF;
379: }
380: }
381:
382: /*
383: * Restore what procsave() saves
384: *
385: * Procsave() makes sure that what state points to is long enough
386: */
387: void
388: procrestore(Proc *p)
389: {
390: Balu *balu = (Balu *)u->balusave;
391:
392: if(p->fpstate != m->fpstate){
393: if(p->fpstate == FPinit){
394: u->p->fpstate = FPinit;
395: fprestore(&initfp);
396: m->fpstate = FPinit;
397: }else{
398: fpregrestore(u->fpsave.reg);
399: fprestore(&u->fpsave);
400: m->fpstate = FPdirty;
401: }
402: }
403: if(balu->cr0 != 0xFFFFFFFF) /* balu busy */
404: memmove(BALU, balu, sizeof BALU);
405: }
406:
407: void
408: buzz(int f, int d)
409: {
410: USED(f, d);
411: }
412:
413: void
414: lights(int val)
415: {
416: USED(val);
417: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.