load.c 9.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583
  1. #include "u.h"
  2. #include "lib.h"
  3. #include "mem.h"
  4. #include "dat.h"
  5. #include "fns.h"
  6. #include "io.h"
  7. #include "fs.h"
  8. /*
  9. * "cache" must be in this list so that 9load will pass the definition of
  10. * the cache partition into the kernel so that the disk named by the `cfs'
  11. * variable in plan9.ini can be seen in all circumstances before termrc
  12. * sets up all the disk partitions. In particular, if it's on an odd-ball
  13. * disk like sd10 rather than sdC0, this is needed.
  14. */
  15. static char *diskparts[] = {
  16. "dos", "9fat", "fs", "data", "cdboot", "cache", 0
  17. };
  18. static char *etherparts[] = { "*", 0 };
  19. static char *diskinis[] = {
  20. "plan9/plan9.ini",
  21. "plan9.ini",
  22. 0
  23. };
  24. static char *etherinis[] = {
  25. "/cfg/pxe/%E",
  26. 0
  27. };
  28. Type types[] = {
  29. { Tfloppy,
  30. Fini|Ffs,
  31. floppyinit, floppyinitdev,
  32. floppygetfspart, 0, floppyboot,
  33. floppyprintdevs,
  34. diskparts,
  35. diskinis,
  36. },
  37. { Tcd,
  38. Fini|Ffs,
  39. cdinit, sdinitdev,
  40. sdgetfspart, sdaddconf, sdboot,
  41. sdprintdevs,
  42. diskparts,
  43. diskinis,
  44. },
  45. { Tether,
  46. Fini|Fbootp,
  47. etherinit, etherinitdev,
  48. pxegetfspart, 0, bootpboot,
  49. etherprintdevs,
  50. etherparts,
  51. etherinis,
  52. },
  53. { Tsd,
  54. Fini|Ffs,
  55. sdinit, sdinitdev,
  56. sdgetfspart, sdaddconf, sdboot,
  57. sdprintdevs,
  58. diskparts,
  59. diskinis,
  60. },
  61. { Tnil,
  62. 0,
  63. nil, nil, nil, nil, nil, nil,
  64. nil,
  65. nil,
  66. 0,
  67. nil,
  68. },
  69. };
  70. #include "sd.h"
  71. extern SDifc sdataifc;
  72. extern SDifc sd63xxesbifc;
  73. #ifdef NOSCSI
  74. SDifc* sdifc[] = {
  75. &sdataifc,
  76. &sd63xxesbifc,
  77. nil,
  78. };
  79. #else
  80. extern SDifc sdmylexifc;
  81. extern SDifc sd53c8xxifc;
  82. SDifc* sdifc[] = {
  83. &sdataifc,
  84. &sdmylexifc,
  85. &sd53c8xxifc,
  86. &sd63xxesbifc,
  87. nil,
  88. };
  89. #endif NOSCSI
  90. typedef struct Mode Mode;
  91. enum {
  92. Maxdev = 7,
  93. Dany = -1,
  94. Nmedia = 16,
  95. Nini = 10,
  96. };
  97. enum { /* mode */
  98. Mauto = 0x00,
  99. Mlocal = 0x01,
  100. Manual = 0x02,
  101. NMode = 0x03,
  102. };
  103. typedef struct Medium Medium;
  104. struct Medium {
  105. Type* type;
  106. int flag;
  107. int dev;
  108. char name[NAMELEN];
  109. Fs *inifs;
  110. char *part;
  111. char *ini;
  112. Medium* next;
  113. };
  114. typedef struct Mode {
  115. char* name;
  116. int mode;
  117. } Mode;
  118. static Medium media[Nmedia];
  119. static Medium *curmedium = media;
  120. static Mode modes[NMode+1] = {
  121. [Mauto] { "auto", Mauto, },
  122. [Mlocal] { "local", Mlocal, },
  123. [Manual] { "manual", Manual, },
  124. };
  125. char **ini;
  126. int scsi0port;
  127. char *defaultpartition;
  128. int iniread;
  129. static Medium*
  130. parse(char *line, char **file)
  131. {
  132. char *p;
  133. Type *tp;
  134. Medium *mp;
  135. if(p = strchr(line, '!')) {
  136. *p++ = 0;
  137. *file = p;
  138. } else
  139. *file = "";
  140. for(tp = types; tp->type != Tnil; tp++)
  141. for(mp = tp->media; mp; mp = mp->next)
  142. if(strcmp(mp->name, line) == 0)
  143. return mp;
  144. if(p)
  145. *--p = '!';
  146. return nil;
  147. }
  148. static int
  149. boot(Medium *mp, char *file)
  150. {
  151. Type *tp;
  152. Medium *xmp;
  153. static int didaddconf;
  154. Boot b;
  155. memset(&b, 0, sizeof b);
  156. b.state = INITKERNEL;
  157. if(didaddconf == 0) {
  158. didaddconf = 1;
  159. for(tp = types; tp->type != Tnil; tp++)
  160. if(tp->addconf)
  161. for(xmp = tp->media; xmp; xmp = xmp->next)
  162. (*tp->addconf)(xmp->dev);
  163. }
  164. sprint(BOOTLINE, "%s!%s", mp->name, file);
  165. return (*mp->type->boot)(mp->dev, file, &b);
  166. }
  167. static Medium*
  168. allocm(Type *tp)
  169. {
  170. Medium **l;
  171. if(curmedium >= &media[Nmedia])
  172. return 0;
  173. for(l = &tp->media; *l; l = &(*l)->next)
  174. ;
  175. *l = curmedium++;
  176. return *l;
  177. }
  178. Medium*
  179. probe(int type, int flag, int dev)
  180. {
  181. Type *tp;
  182. int i;
  183. Medium *mp;
  184. File f;
  185. Fs *fs;
  186. char **partp;
  187. for(tp = types; tp->type != Tnil; tp++){
  188. if(type != Tany && type != tp->type)
  189. continue;
  190. if(flag != Fnone){
  191. for(mp = tp->media; mp; mp = mp->next){
  192. if((flag & mp->flag) && (dev == Dany || dev == mp->dev))
  193. return mp;
  194. }
  195. }
  196. if((tp->flag & Fprobe) == 0){
  197. tp->flag |= Fprobe;
  198. tp->mask = (*tp->init)();
  199. }
  200. for(i = 0; tp->mask; i++){
  201. if((tp->mask & (1<<i)) == 0)
  202. continue;
  203. tp->mask &= ~(1<<i);
  204. if((mp = allocm(tp)) == 0)
  205. continue;
  206. mp->dev = i;
  207. mp->flag = tp->flag;
  208. mp->type = tp;
  209. (*tp->initdev)(i, mp->name);
  210. if(mp->flag & Fini){
  211. mp->flag &= ~Fini;
  212. for(partp = tp->parts; *partp; partp++){
  213. if((fs = (*tp->getfspart)(i, *partp, 0)) == nil)
  214. continue;
  215. for(ini = tp->inis; *ini; ini++){
  216. if(fswalk(fs, *ini, &f) > 0){
  217. mp->inifs = fs;
  218. mp->part = *partp;
  219. mp->ini = f.path;
  220. mp->flag |= Fini;
  221. goto Break2;
  222. }
  223. }
  224. }
  225. }
  226. Break2:
  227. if((flag & mp->flag) && (dev == Dany || dev == i))
  228. return mp;
  229. }
  230. }
  231. return 0;
  232. }
  233. static char *typenm[] = {
  234. [Tnil] "nil",
  235. [Tfloppy] "Tfloppy",
  236. [Tsd] "Tsd",
  237. [Tether] "Tether",
  238. [Tcd] "Tcd",
  239. };
  240. void
  241. main(void)
  242. {
  243. Medium *mp;
  244. int flag, i, mode, tried;
  245. char def[2*NAMELEN], line[80], *p, *file;
  246. Type *tp;
  247. i8042a20();
  248. memset(m, 0, sizeof(Mach));
  249. trapinit();
  250. clockinit();
  251. alarminit();
  252. meminit(0);
  253. spllo();
  254. kbdinit();
  255. if((ulong)&end > (KZERO|(640*1024)))
  256. panic("i'm too big\n");
  257. readlsconf();
  258. for(tp = types; tp->type != Tnil; tp++){
  259. if(!pxe && tp->type == Tether)
  260. continue;
  261. if((mp = probe(tp->type, Fini, Dany)) && (mp->flag & Fini)){
  262. print("using %s!%s!%s\n", mp->name, mp->part, mp->ini);
  263. iniread = !dotini(mp->inifs);
  264. break;
  265. }
  266. }
  267. apminit();
  268. if((p = getconf("console")) != nil)
  269. consinit(p, getconf("baud"));
  270. devpccardlink();
  271. devi82365link();
  272. /*
  273. * Even after we find the ini file, we keep probing disks,
  274. * because we have to collect the partition tables and
  275. * have boot devices for parse.
  276. */
  277. probe(Tany, Fnone, Dany);
  278. tried = 0;
  279. mode = Mauto;
  280. p = getconf("bootfile");
  281. if(p != 0) {
  282. mode = Manual;
  283. for(i = 0; i < NMode; i++){
  284. if(strcmp(p, modes[i].name) == 0){
  285. mode = modes[i].mode;
  286. goto done;
  287. }
  288. }
  289. if((mp = parse(p, &file)) == nil) {
  290. print("Unknown boot device: %s\n", p);
  291. goto done;
  292. }
  293. tried = boot(mp, file);
  294. }
  295. done:
  296. if(tried == 0 && mode != Manual){
  297. flag = Fany;
  298. if(mode == Mlocal)
  299. flag &= ~Fbootp;
  300. if((mp = probe(Tany, flag, Dany)) && mp->type->type != Tfloppy)
  301. boot(mp, "");
  302. }
  303. def[0] = 0;
  304. probe(Tany, Fnone, Dany);
  305. if(p = getconf("bootdef"))
  306. strcpy(def, p);
  307. flag = 0;
  308. for(tp = types; tp->type != Tnil; tp++){
  309. for(mp = tp->media; mp; mp = mp->next){
  310. if(flag == 0){
  311. flag = 1;
  312. print("Boot devices:");
  313. }
  314. (*tp->printdevs)(mp->dev);
  315. }
  316. }
  317. if(flag)
  318. print("\n");
  319. for(;;){
  320. if(getstr("boot from", line, sizeof(line), def, (mode != Manual)*15) >= 0)
  321. if(mp = parse(line, &file))
  322. boot(mp, file);
  323. def[0] = 0;
  324. }
  325. }
  326. int
  327. getfields(char *lp, char **fields, int n, char sep)
  328. {
  329. int i;
  330. for(i = 0; lp && *lp && i < n; i++){
  331. while(*lp == sep)
  332. *lp++ = 0;
  333. if(*lp == 0)
  334. break;
  335. fields[i] = lp;
  336. while(*lp && *lp != sep){
  337. if(*lp == '\\' && *(lp+1) == '\n')
  338. *lp++ = ' ';
  339. lp++;
  340. }
  341. }
  342. return i;
  343. }
  344. int
  345. cistrcmp(char *a, char *b)
  346. {
  347. int ac, bc;
  348. for(;;){
  349. ac = *a++;
  350. bc = *b++;
  351. if(ac >= 'A' && ac <= 'Z')
  352. ac = 'a' + (ac - 'A');
  353. if(bc >= 'A' && bc <= 'Z')
  354. bc = 'a' + (bc - 'A');
  355. ac -= bc;
  356. if(ac)
  357. return ac;
  358. if(bc == 0)
  359. break;
  360. }
  361. return 0;
  362. }
  363. int
  364. cistrncmp(char *a, char *b, int n)
  365. {
  366. unsigned ac, bc;
  367. while(n > 0){
  368. ac = *a++;
  369. bc = *b++;
  370. n--;
  371. if(ac >= 'A' && ac <= 'Z')
  372. ac = 'a' + (ac - 'A');
  373. if(bc >= 'A' && bc <= 'Z')
  374. bc = 'a' + (bc - 'A');
  375. ac -= bc;
  376. if(ac)
  377. return ac;
  378. if(bc == 0)
  379. break;
  380. }
  381. return 0;
  382. }
  383. #define PSTART ( 8*1024*1024)
  384. #define PEND (16*1024*1024)
  385. ulong palloc = PSTART;
  386. void*
  387. ialloc(ulong n, int align)
  388. {
  389. ulong p;
  390. int a;
  391. p = palloc;
  392. if(align <= 0)
  393. align = 4;
  394. if(a = n % align)
  395. n += align - a;
  396. if(a = p % align)
  397. p += align - a;
  398. palloc = p+n;
  399. if(palloc > PEND)
  400. panic("ialloc(%lud, %d) called from %#p\n",
  401. n, align, getcallerpc(&n));
  402. return memset((void*)(p|KZERO), 0, n);
  403. }
  404. void*
  405. xspanalloc(ulong size, int align, ulong span)
  406. {
  407. ulong a, v;
  408. if((palloc + (size+align+span)) > PEND)
  409. panic("xspanalloc(%lud, %d, 0x%lux) called from %#p\n",
  410. size, align, span, getcallerpc(&size));
  411. a = (ulong)ialloc(size+align+span, 0);
  412. if(span > 2)
  413. v = (a + span) & ~(span-1);
  414. else
  415. v = a;
  416. if(align > 1)
  417. v = (v + align) & ~(align-1);
  418. return (void*)v;
  419. }
  420. static Block *allocbp;
  421. Block*
  422. allocb(int size)
  423. {
  424. Block *bp, **lbp;
  425. ulong addr;
  426. lbp = &allocbp;
  427. for(bp = *lbp; bp; bp = bp->next){
  428. if((bp->lim - bp->base) >= size){
  429. *lbp = bp->next;
  430. break;
  431. }
  432. lbp = &bp->next;
  433. }
  434. if(bp == 0){
  435. if((palloc + (sizeof(Block)+size+64)) > PEND)
  436. panic("allocb(%d) called from %#p\n",
  437. size, getcallerpc(&size));
  438. bp = ialloc(sizeof(Block)+size+64, 0);
  439. addr = (ulong)bp;
  440. addr = ROUNDUP(addr + sizeof(Block), 8);
  441. bp->base = (uchar*)addr;
  442. bp->lim = ((uchar*)bp) + sizeof(Block)+size+64;
  443. }
  444. if(bp->flag)
  445. panic("allocb reuse\n");
  446. bp->rp = bp->base;
  447. bp->wp = bp->rp;
  448. bp->next = 0;
  449. bp->flag = 1;
  450. return bp;
  451. }
  452. void
  453. freeb(Block* bp)
  454. {
  455. bp->next = allocbp;
  456. allocbp = bp;
  457. bp->flag = 0;
  458. }
  459. enum {
  460. Paddr= 0x70, /* address port */
  461. Pdata= 0x71, /* data port */
  462. };
  463. uchar
  464. nvramread(int offset)
  465. {
  466. outb(Paddr, offset);
  467. return inb(Pdata);
  468. }
  469. void (*etherdetach)(void);
  470. void (*floppydetach)(void);
  471. void (*sddetach)(void);
  472. void
  473. warp9(ulong entry)
  474. {
  475. if(etherdetach)
  476. etherdetach();
  477. if(floppydetach)
  478. floppydetach();
  479. if(sddetach)
  480. sddetach();
  481. consdrain();
  482. splhi();
  483. trapdisable();
  484. /*
  485. * This is where to push things on the stack to
  486. * boot *BSD systems, e.g.
  487. (*(void(*)(void*, void*, void*, void*, ulong, ulong))(PADDR(entry)))(0, 0, 0, 0, 8196, 640);
  488. * will enable NetBSD boot (the real memory size needs to
  489. * go in the 5th argument).
  490. */
  491. (*(void(*)(void))(PADDR(entry)))();
  492. }