You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

main.c 10KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474
  1. /**************************************************************************
  2. Etherboot - Network Bootstrap Program
  3. Literature dealing with the network protocols:
  4. ARP - RFC826
  5. RARP - RFC903
  6. UDP - RFC768
  7. BOOTP - RFC951, RFC2132 (vendor extensions)
  8. DHCP - RFC2131, RFC2132 (options)
  9. TFTP - RFC1350, RFC2347 (options), RFC2348 (blocksize), RFC2349 (tsize)
  10. RPC - RFC1831, RFC1832 (XDR), RFC1833 (rpcbind/portmapper)
  11. NFS - RFC1094, RFC1813 (v3, useful for clarifications, not implemented)
  12. IGMP - RFC1112
  13. **************************************************************************/
  14. /* #define MDEBUG */
  15. #include "etherboot.h"
  16. #include "dev.h"
  17. #include "nic.h"
  18. #include "disk.h"
  19. #include "http.h"
  20. #include "timer.h"
  21. #include "cpu.h"
  22. #include "console.h"
  23. #include "init.h"
  24. #include <stdarg.h>
  25. #ifdef CONFIG_FILO
  26. #include <lib.h>
  27. #endif
  28. jmp_buf restart_etherboot;
  29. int url_port;
  30. char as_main_program = 1;
  31. #ifdef IMAGE_FREEBSD
  32. int freebsd_howto = 0;
  33. char freebsd_kernel_env[FREEBSD_KERNEL_ENV_SIZE];
  34. #endif
  35. #if 0
  36. static inline unsigned long ask_boot(unsigned *index)
  37. {
  38. unsigned long order = DEFAULT_BOOT_ORDER;
  39. *index = DEFAULT_BOOT_INDEX;
  40. #ifdef LINUXBIOS
  41. order = get_boot_order(order, index);
  42. #endif
  43. #if defined(ASK_BOOT)
  44. #if ASK_BOOT >= 0
  45. while(1) {
  46. int c = 0;
  47. printf(ASK_PROMPT);
  48. #if ASK_BOOT > 0
  49. {
  50. unsigned long time;
  51. for ( time = currticks() + ASK_BOOT*TICKS_PER_SEC;
  52. !c && !iskey(); ) {
  53. if (currticks() > time) c = ANS_DEFAULT;
  54. }
  55. }
  56. #endif /* ASK_BOOT > 0 */
  57. if ( !c ) c = getchar();
  58. if ((c >= 'a') && (c <= 'z')) c &= 0x5F;
  59. if ((c >= ' ') && (c <= '~')) putchar(c);
  60. putchar('\n');
  61. switch(c) {
  62. default:
  63. /* Nothing useful try again */
  64. continue;
  65. case ANS_QUIT:
  66. order = BOOT_NOTHING;
  67. *index = 0;
  68. break;
  69. case ANS_DEFAULT:
  70. /* Preserve the default boot order */
  71. break;
  72. case ANS_NETWORK:
  73. order = (BOOT_NIC << (0*BOOT_BITS)) |
  74. (BOOT_NOTHING << (1*BOOT_BITS));
  75. *index = 0;
  76. break;
  77. case ANS_DISK:
  78. order = (BOOT_DISK << (0*BOOT_BITS)) |
  79. (BOOT_NOTHING << (1*BOOT_BITS));
  80. *index = 0;
  81. break;
  82. case ANS_FLOPPY:
  83. order = (BOOT_FLOPPY << (0*BOOT_BITS)) |
  84. (BOOT_NOTHING << (1*BOOT_BITS));
  85. *index = 0;
  86. break;
  87. }
  88. break;
  89. }
  90. putchar('\n');
  91. #endif /* ASK_BOOT >= 0 */
  92. #endif /* defined(ASK_BOOT) */
  93. return order;
  94. }
  95. static inline void try_floppy_first(void)
  96. {
  97. #if (TRY_FLOPPY_FIRST > 0)
  98. int i;
  99. printf("Trying floppy");
  100. disk_init();
  101. for (i = TRY_FLOPPY_FIRST; i-- > 0; ) {
  102. putchar('.');
  103. if (pcbios_disk_read(0, 0, 0, 0, ((char *)FLOPPY_BOOT_LOCATION)) != 0x8000) {
  104. printf("using floppy\n");
  105. exit(0);
  106. }
  107. }
  108. printf("no floppy\n");
  109. #endif /* TRY_FLOPPY_FIRST */
  110. }
  111. static struct class_operations {
  112. struct dev *dev;
  113. int (*probe)(struct dev *dev);
  114. int (*load_configuration)(struct dev *dev);
  115. int (*load)(struct dev *dev);
  116. }
  117. operations[] = {
  118. { &nic.dev, eth_probe, eth_load_configuration, eth_load },
  119. { &disk.dev, disk_probe, disk_load_configuration, disk_load },
  120. { &disk.dev, disk_probe, disk_load_configuration, disk_load },
  121. };
  122. #endif
  123. static int main_loop(int state);
  124. static int exit_ok;
  125. static int exit_status;
  126. static int initialized;
  127. /* Global instance of the current boot device */
  128. DEV_BUS(struct bus_device, dev_bus);
  129. struct dev dev = {
  130. .bus = &dev_bus,
  131. };
  132. /**************************************************************************
  133. * initialise() - perform any C-level initialisation
  134. *
  135. * This does not include initialising the NIC, but it does include
  136. * e.g. getting the memory map, relocating to high memory,
  137. * initialising the console, etc.
  138. **************************************************************************
  139. */
  140. void initialise ( void ) {
  141. /* Zero the BSS */
  142. memset ( _bss, 0, _ebss - _bss );
  143. /* Call all registered initialisation functions */
  144. call_init_fns ();
  145. }
  146. /**************************************************************************
  147. MAIN - Kick off routine
  148. **************************************************************************/
  149. int main ( void ) {
  150. /* Print out configuration */
  151. print_config();
  152. /*
  153. * Trivial main loop: we need to think about how we want to
  154. * prompt the user etc.
  155. *
  156. */
  157. for ( ; ; disable ( &dev ), call_reset_fns() ) {
  158. /* Get next boot device */
  159. if ( ! find_boot_device ( &dev ) ) {
  160. /* Reached end of device list */
  161. printf ( "No more boot devices\n" );
  162. continue;
  163. }
  164. /* Probe boot device */
  165. if ( ! probe ( &dev ) ) {
  166. /* Device found on bus, but probe failed */
  167. printf ( "Probe failed on %s, trying next device\n",
  168. dev.name );
  169. continue;
  170. }
  171. /* Print device info */
  172. print_info ( &dev );
  173. /* Load configuration (e.g. DHCP) */
  174. if ( ! load_configuration ( &dev ) ) {
  175. /* DHCP failed */
  176. printf ( "Could not configure device %s\n", dev.name );
  177. continue;
  178. }
  179. /* Load image */
  180. if ( ! load ( &dev ) )
  181. /* Load failed */
  182. printf ( "Could not boot from device %s\n", dev.name );
  183. continue;
  184. }
  185. /* Call registered per-object exit functions */
  186. call_exit_fns ();
  187. return exit_status;
  188. }
  189. void exit(int status)
  190. {
  191. while(!exit_ok)
  192. ;
  193. exit_status = status;
  194. longjmp(restart_etherboot, 255);
  195. }
  196. #if 0
  197. static int main_loop(int state)
  198. {
  199. /* Splitting main into 2 pieces makes the semantics of
  200. * which variables are preserved across a longjmp clean
  201. * and predictable.
  202. */
  203. static unsigned long order;
  204. static unsigned boot_index;
  205. static struct dev * dev = 0;
  206. static struct class_operations *ops;
  207. static int type;
  208. static int i;
  209. if (!initialized) {
  210. initialized = 1;
  211. if (dev && (state >= 1) && (state <= 2)) {
  212. dev->how_probe = PROBE_AWAKE;
  213. dev->how_probe = ops->probe(dev);
  214. if (dev->how_probe == PROBE_FAILED) {
  215. state = -1;
  216. }
  217. }
  218. }
  219. switch(state) {
  220. case 0:
  221. {
  222. static int firsttime = 1;
  223. /* First time through */
  224. if (firsttime) {
  225. cleanup();
  226. firsttime = 0;
  227. }
  228. #ifdef EXIT_IF_NO_OFFER
  229. else {
  230. cleanup();
  231. exit(0);
  232. }
  233. #endif
  234. i = -1;
  235. state = 4;
  236. dev = 0;
  237. /* We just called setjmp ... */
  238. order = ask_boot(&boot_index);
  239. try_floppy_first();
  240. break;
  241. }
  242. case 4:
  243. cleanup();
  244. call_reset_fns();
  245. /* Find a dev entry to probe with */
  246. if (!dev) {
  247. int boot;
  248. int failsafe;
  249. /* Advance to the next device type */
  250. i++;
  251. boot = (order >> (i * BOOT_BITS)) & BOOT_MASK;
  252. type = boot & BOOT_TYPE_MASK;
  253. failsafe = (boot & BOOT_FAILSAFE) != 0;
  254. if (i >= MAX_BOOT_ENTRIES) {
  255. type = BOOT_NOTHING;
  256. }
  257. if ((i == 0) && (type == BOOT_NOTHING)) {
  258. /* Return to caller */
  259. exit(0);
  260. }
  261. if (type >= BOOT_NOTHING) {
  262. interruptible_sleep(2);
  263. state = 0;
  264. break;
  265. }
  266. ops = &operations[type];
  267. dev = ops->dev;
  268. dev->how_probe = PROBE_FIRST;
  269. dev->type = type;
  270. dev->failsafe = failsafe;
  271. dev->type_index = 0;
  272. } else {
  273. /* Advance to the next device of the same type */
  274. dev->how_probe = PROBE_NEXT;
  275. }
  276. state = 3;
  277. break;
  278. case 3:
  279. state = -1;
  280. /* Removed the following line because it was causing
  281. * heap.o to be dragged in unnecessarily. It's also
  282. * slightly puzzling: by resetting heap_base, doesn't
  283. * this mean that we permanently leak memory?
  284. */
  285. /* heap_base = allot(0); */
  286. dev->how_probe = ops->probe(dev);
  287. if (dev->how_probe == PROBE_FAILED) {
  288. dev = 0;
  289. state = 4;
  290. } else if (boot_index && (i == 0) && (boot_index != (unsigned)dev->type_index)) {
  291. printf("Wrong index\n");
  292. state = 4;
  293. }
  294. else {
  295. state = 2;
  296. }
  297. break;
  298. case 2:
  299. state = -1;
  300. if (ops->load_configuration(dev) >= 0) {
  301. state = 1;
  302. }
  303. break;
  304. case 1:
  305. /* Any return from load is a failure */
  306. ops->load(dev);
  307. state = -1;
  308. break;
  309. case 256:
  310. state = 0;
  311. break;
  312. case -3:
  313. i = MAX_BOOT_ENTRIES;
  314. type = BOOT_NOTHING;
  315. /* fall through */
  316. default:
  317. printf("<abort>\n");
  318. state = 4;
  319. /* At the end goto state 0 */
  320. if ((type >= BOOT_NOTHING) || (i >= MAX_BOOT_ENTRIES)) {
  321. state = 0;
  322. }
  323. break;
  324. }
  325. return state;
  326. }
  327. #endif
  328. /**************************************************************************
  329. LOADKERNEL - Try to load kernel image
  330. **************************************************************************/
  331. struct proto {
  332. char *name;
  333. int (*load)(const char *name,
  334. int (*fnc)(unsigned char *, unsigned int, unsigned int, int));
  335. };
  336. static const struct proto protos[] = {
  337. #ifdef DOWNLOAD_PROTO_TFTM
  338. { "x-tftm", url_tftm },
  339. #endif
  340. #ifdef DOWNLOAD_PROTO_SLAM
  341. { "x-slam", url_slam },
  342. #endif
  343. #ifdef DOWNLOAD_PROTO_NFS
  344. { "nfs", nfs },
  345. #endif
  346. #ifdef DOWNLOAD_PROTO_DISK
  347. { "file", url_file },
  348. #endif
  349. #ifdef DOWNLOAD_PROTO_TFTP
  350. { "tftp", tftp },
  351. #endif
  352. #ifdef DOWNLOAD_PROTO_HTTP
  353. { "http", http },
  354. #endif
  355. };
  356. int loadkernel(const char *fname)
  357. {
  358. static const struct proto * const last_proto =
  359. &protos[sizeof(protos)/sizeof(protos[0])];
  360. const struct proto *proto;
  361. in_addr ip;
  362. int len;
  363. const char *name;
  364. #ifdef DNS_RESOLVER
  365. const char *resolvt;
  366. #endif
  367. ip.s_addr = arptable[ARP_SERVER].ipaddr.s_addr;
  368. name = fname;
  369. url_port = -1;
  370. len = 0;
  371. while(fname[len] && fname[len] != ':') {
  372. len++;
  373. }
  374. for(proto = &protos[0]; proto < last_proto; proto++) {
  375. if (memcmp(name, proto->name, len) == 0) {
  376. break;
  377. }
  378. }
  379. if ((proto < last_proto) && (memcmp(fname + len, "://", 3) == 0)) {
  380. name += len + 3;
  381. if (name[0] != '/') {
  382. #ifdef DNS_RESOLVER
  383. resolvt = dns_resolver ( name );
  384. if ( NULL != resolvt ) {
  385. //printf ("Resolved host name [%s] to [%s]\n",
  386. // name, resolvt );
  387. inet_aton(resolvt, &ip);
  388. while ( ( '/' != name[0] ) && ( 0 != name[0]))
  389. ++name;
  390. } else
  391. #endif /* DNS_RESOLVER */
  392. name += inet_aton(name, &ip);
  393. if (name[0] == ':') {
  394. name++;
  395. url_port = strtoul(name, &name, 10);
  396. }
  397. }
  398. if (name[0] == '/') {
  399. arptable[ARP_SERVER].ipaddr.s_addr = ip.s_addr;
  400. printf( "Loading %s ", fname );
  401. return proto->load(name + 1, load_block);
  402. }
  403. }
  404. printf("Loading %@:%s ", arptable[ARP_SERVER].ipaddr, fname);
  405. #ifdef DEFAULT_PROTO_NFS
  406. return nfs(fname, load_block);
  407. #else
  408. return tftp(fname, load_block);
  409. #endif
  410. }
  411. /**************************************************************************
  412. CLEANUP - shut down networking and console so that the OS may be called
  413. **************************************************************************/
  414. void cleanup(void)
  415. {
  416. #ifdef DOWNLOAD_PROTO_NFS
  417. nfs_umountall(ARP_SERVER);
  418. #endif
  419. /* Stop receiving packets */
  420. eth_disable();
  421. disk_disable();
  422. initialized = 0;
  423. }
  424. /*
  425. * Local variables:
  426. * c-basic-offset: 8
  427. * End:
  428. */