3 #include "../port/lib.h"
13 /* Firmware compatibility */
14 #define Minfirmrev 326770
15 #define Minfirmdate "22 Jul 2012"
18 * Where configuration info is left for the loaded programme.
20 #define BOOTARGS ((char*)CONFADDR)
21 #define BOOTARGSLEN (MACHADDR-CONFADDR)
23 #define MAXCONFLINE 160
25 uintptr kseg0 = KZERO;
26 Mach* machaddr[MAXMACH];
28 ulong memsize = 128*1024*1024;
31 * Option arguments from the command line.
32 * oargv[0] is the boot file.
35 static char* oargv[20];
36 static char oargb[128];
39 static uintptr sp; /* XXX - must go - user stack of init proc */
41 /* store plan9.ini contents here at least until we stash them in #ec */
42 static char confname[MAXCONF][KNAMELEN];
43 static char confval[MAXCONF][MAXCONFLINE];
46 typedef struct Atag Atag;
48 u32int size; /* size of atag in words, including this header */
49 u32int tag; /* atag type */
51 u32int data[1]; /* actually [size-2] */
58 char cmdline[1]; /* actually [4*(size-2)] */
63 AtagNone = 0x00000000,
64 AtagCore = 0x54410001,
66 AtagCmdline = 0x54410009,
74 for(i = 0; i < nconf; i++)
75 if(cistrcmp(confname[i], name) == 0)
92 addconf(char *name, char *val)
98 if(val == nil || nconf >= MAXCONF)
101 strecpy(confname[i], confname[i]+sizeof(confname[i]), name);
103 strecpy(confval[i], confval[i]+sizeof(confval[i]), val);
119 /* convert to name=value\n format */
128 error("kernel configuration too large");
129 memmove(BOOTARGS, p, n);
130 memset(BOOTARGS + n, '\n', BOOTARGSLEN - n);
136 plan9iniinit(char *s, int cmdline)
142 if((c = *s) < ' ' || c >= 0x80)
145 n = tokenize(s, toks, MAXCONF);
147 n = getfields(s, toks, MAXCONF, 1, "\n");
148 for(i = 0; i < n; i++){
149 if(toks[i][0] == '#')
151 v = strchr(toks[i], '=');
164 if(a->tag != AtagCore){
165 plan9iniinit((char*)a, 0);
168 while(a->tag != AtagNone){
171 /* use only first bank */
172 if(conf.mem[0].limit == 0 && a->mem.size != 0){
173 memsize = a->mem.size;
174 conf.mem[0].base = a->mem.base;
175 conf.mem[0].limit = a->mem.base + memsize;
179 n = (a->size * sizeof(u32int)) - offsetof(Atag, cmdline[0]);
180 if(a->cmdline + n < BOOTARGS + BOOTARGSLEN)
183 BOOTARGS[BOOTARGSLEN-1] = 0;
184 plan9iniinit(a->cmdline, 1);
187 a = (Atag*)((u32int*)a + a->size);
195 machaddr[m->machno] = m;
211 strecpy(oargb, oargb+sizeof(oargb), s);
213 oargblen = strlen(oargb);
214 oargc = tokenize(oargb, oargv, nelem(oargv)-1);
222 memset(&seg, 0, sizeof seg);
223 seg.attr = SG_PHYSICAL;
225 seg.pa = (VIRTIO+0x200000);
234 extern char edata[], end[];
239 memset(edata, 0, end - edata); /* clear bss */
243 optionsinit("/boot/boot boot");
246 ataginit((Atag*)BOOTARGS);
247 confinit(); /* figures out amount of memory */
252 print("\nPlan 9 from Bell Labs\n");
254 print("firmware: rev %d\n", rev);
255 if(rev < Minfirmrev){
256 print("Sorry, firmware (start.elf) must be at least rev %d (%s)\n",
257 Minfirmrev, Minfirmdate);
271 chandevreset(); /* most devices are discovered here */
276 assert(0); /* shouldn't have returned */
280 * starting place for first process
286 char buf[2*KNAMELEN];
293 * These are o.k. because rootinit is null.
294 * Then early kproc's will have a root and dot.
296 up->slash = namec("#/", Atodir, 0, 0);
297 pathclose(up->slash->path);
298 up->slash->path = newpath("/");
299 up->dot = cclone(up->slash);
304 snprint(buf, sizeof(buf), "%s %s", "ARM", conffile);
305 ksetenv("terminal", buf, 0);
306 ksetenv("cputype", "arm", 0);
308 ksetenv("service", "cpu", 0);
310 ksetenv("service", "terminal", 0);
311 snprint(buf, sizeof(buf), "-a %s", getethermac());
312 ksetenv("etherargs", buf, 0);
314 /* convert plan9.ini variables to #e and #ec */
315 for(i = 0; i < nconf; i++) {
316 ksetenv(confname[i], confval[i], 0);
317 ksetenv(confname[i], confval[i], 1);
321 kproc("alarm", alarmkproc, 0);
323 assert(0); /* shouldn't have returned */
327 bootargs(uintptr base)
334 * Push the boot args onto the stack.
335 * The initial value of the user stack must be such
336 * that the total used is larger than the maximum size
337 * of the argument list checked in syscall.
340 p = UINT2PTR(STACKALIGN(base + BY2PG - sizeof(Tos) - i));
341 memmove(p, oargb, i);
344 * Now push the argv pointers.
345 * The code jumped to by touser in lproc.s expects arguments
346 * main(char* argv0, ...)
348 * startboot("/boot/boot", &argv0)
349 * not the usual (int argc, char* argv[])
351 av = (char**)(p - (oargc+1)*sizeof(char*));
352 ssize = base + BY2PG - PTR2UINT(av);
353 for(i = 0; i < oargc; i++)
354 *av++ = (oargv[i] - oargb) + (p - base) + (USTKTOP - BY2PG);
356 sp = USTKTOP - ssize;
360 * create the first process
370 /* no processes yet */
375 p->egrp = smalloc(sizeof(Egrp));
377 p->fgrp = dupfgrp(nil);
382 kstrdup(&p->text, "*init*");
383 kstrdup(&p->user, eve);
388 p->sched.pc = PTR2UINT(init0);
389 p->sched.sp = PTR2UINT(p->kstack+KSTACK-sizeof(up->s.args)-sizeof(uintptr));
390 p->sched.sp = STACKALIGN(p->sched.sp);
395 * Technically, newpage can't be called here because it
396 * should only be called when in a user context as it may
397 * try to sleep if there are no pages available, but that
398 * shouldn't be the case here.
400 s = newseg(SG_STACK, USTKTOP-USTKSIZE, USTKSIZE/BY2PG);
403 pg = newpage(1, 0, USTKTOP-BY2PG);
412 s = newseg(SG_TEXT, UTZERO, 1);
414 pg = newpage(1, 0, UTZERO);
417 k = kmap(s->map[0]->pages[0]);
418 memmove(UINT2PTR(VA(k)), initcode, sizeof initcode);
432 if(p = getconf("service")){
433 if(strcmp(p, "cpu") == 0)
435 else if(strcmp(p,"terminal") == 0)
439 if(p = getconf("*kernelpercent"))
440 userpcnt = 100 - strtol(p, 0, 0);
444 if((p = getconf("*maxmem")) != nil){
445 memsize = strtoul(p, 0, 0) - PHYSDRAM;
446 if (memsize < 16*MB) /* sanity */
450 getramsize(&conf.mem[0]);
451 if(conf.mem[0].limit == 0){
452 conf.mem[0].base = PHYSDRAM;
453 conf.mem[0].limit = PHYSDRAM + memsize;
455 conf.mem[0].limit = conf.mem[0].base + memsize;
458 pa = PADDR(PGROUND(PTR2UINT(end)));
461 * we assume that the kernel is at the beginning of one of the
462 * contiguous chunks of memory and fits therein.
464 for(i=0; i<nelem(conf.mem); i++){
465 /* take kernel out of allocatable space */
466 if(pa > conf.mem[i].base && pa < conf.mem[i].limit)
467 conf.mem[i].base = pa;
469 conf.mem[i].npage = (conf.mem[i].limit - conf.mem[i].base)/BY2PG;
470 conf.npage += conf.mem[i].npage;
474 userpcnt = 60 + cpuserver*10;
475 kpages = conf.npage - (conf.npage*userpcnt)/100;
478 * can't go past the end of virtual memory
479 * (ulong)-KZERO is 2^32 - KZERO
481 if(kpages > ((ulong)-KZERO)/BY2PG)
482 kpages = ((ulong)-KZERO)/BY2PG;
484 conf.upages = conf.npage - kpages;
485 conf.ialloc = (kpages/2)*BY2PG;
487 /* only one processor */
490 /* set up other configuration parameters */
491 conf.nproc = 100 + ((conf.npage*BY2PG)/MB)*5;
494 if(conf.nproc > 2000)
496 conf.nswap = conf.npage*3;
500 conf.copymode = 0; /* copy on write */
503 * Guess how much is taken by the large permanent
504 * datastructures. Mntcache and Mntrpc are not accounted for.
506 kpages = conf.npage - conf.upages;
508 kpages -= conf.upages*sizeof(Page)
509 + conf.nproc*sizeof(Proc)
510 + conf.nimage*sizeof(Image)
512 + conf.nswppo*sizeof(Page*);
513 mainmem->maxsize = kpages;
516 * give terminals lots of image memory, too; the dynamic
517 * allocation will balance the load properly, hopefully.
518 * be careful with 32-bit overflow.
520 imagmem->maxsize = kpages;
525 * exit kernel either on a panic or user request
536 * stub for ../omap/devether.c
539 isaconfig(char *class, int ctlrno, ISAConf *isa)
543 return strcmp(class, "ether") == 0;
547 * the new kernel is already loaded at address `code'
548 * of size `size' and entry point `entry'.
551 reboot(void *entry, void *code, ulong size)
553 void (*f)(ulong, ulong, ulong);
558 /* turn off buffered serial console */
563 /* shutdown devices */
566 /* stop the clock (and watchdog if any) */
572 /* setup reboot trampoline function */
573 f = (void*)REBOOTADDR;
574 memmove(f, rebootcode, sizeof(rebootcode));
577 /* off we go - never to return */
578 (*f)(PADDR(entry), PADDR(code), size);
582 cmpswap(long *addr, long old, long new)
584 return cas32(addr, old, new);
588 setupwatchpts(Proc *, Watchpt *, int n)
591 error("no watchpoints");