Nelze vybrat více než 25 témat Téma musí začínat písmenem nebo číslem, může obsahovat pomlčky („-“) a může být dlouhé až 35 znaků.

main.c 9.7KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457
  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. struct dev dev;
  129. /**************************************************************************
  130. * initialise() - perform any C-level initialisation
  131. *
  132. * This does not include initialising the NIC, but it does include
  133. * e.g. getting the memory map, relocating to high memory,
  134. * initialising the console, etc.
  135. **************************************************************************
  136. */
  137. void initialise ( void ) {
  138. /* Zero the BSS */
  139. memset ( _bss, 0, _ebss - _bss );
  140. /* Call all registered initialisation functions */
  141. call_init_fns ();
  142. }
  143. /**************************************************************************
  144. MAIN - Kick off routine
  145. **************************************************************************/
  146. int main ( void ) {
  147. /* Print out configuration */
  148. print_config();
  149. /*
  150. * Trivial main loop: we need to think about how we want to
  151. * prompt the user etc.
  152. *
  153. */
  154. for ( ; ; disable ( &dev ), call_reset_fns() ) {
  155. /* Get next boot device */
  156. if ( ! probe ( &dev ) ) {
  157. /* Reached end of device list */
  158. continue;
  159. }
  160. /* Load configuration (e.g. DHCP) */
  161. if ( ! load_configuration ( &dev ) ) {
  162. /* DHCP failed */
  163. continue;
  164. }
  165. /* Load image */
  166. if ( ! load ( &dev ) )
  167. /* Load failed */
  168. continue;
  169. }
  170. /* Call registered per-object exit functions */
  171. call_exit_fns ();
  172. return exit_status;
  173. }
  174. void exit(int status)
  175. {
  176. while(!exit_ok)
  177. ;
  178. exit_status = status;
  179. longjmp(restart_etherboot, 255);
  180. }
  181. #if 0
  182. static int main_loop(int state)
  183. {
  184. /* Splitting main into 2 pieces makes the semantics of
  185. * which variables are preserved across a longjmp clean
  186. * and predictable.
  187. */
  188. static unsigned long order;
  189. static unsigned boot_index;
  190. static struct dev * dev = 0;
  191. static struct class_operations *ops;
  192. static int type;
  193. static int i;
  194. if (!initialized) {
  195. initialized = 1;
  196. if (dev && (state >= 1) && (state <= 2)) {
  197. dev->how_probe = PROBE_AWAKE;
  198. dev->how_probe = ops->probe(dev);
  199. if (dev->how_probe == PROBE_FAILED) {
  200. state = -1;
  201. }
  202. }
  203. }
  204. switch(state) {
  205. case 0:
  206. {
  207. static int firsttime = 1;
  208. /* First time through */
  209. if (firsttime) {
  210. cleanup();
  211. firsttime = 0;
  212. }
  213. #ifdef EXIT_IF_NO_OFFER
  214. else {
  215. cleanup();
  216. exit(0);
  217. }
  218. #endif
  219. i = -1;
  220. state = 4;
  221. dev = 0;
  222. /* We just called setjmp ... */
  223. order = ask_boot(&boot_index);
  224. try_floppy_first();
  225. break;
  226. }
  227. case 4:
  228. cleanup();
  229. call_reset_fns();
  230. /* Find a dev entry to probe with */
  231. if (!dev) {
  232. int boot;
  233. int failsafe;
  234. /* Advance to the next device type */
  235. i++;
  236. boot = (order >> (i * BOOT_BITS)) & BOOT_MASK;
  237. type = boot & BOOT_TYPE_MASK;
  238. failsafe = (boot & BOOT_FAILSAFE) != 0;
  239. if (i >= MAX_BOOT_ENTRIES) {
  240. type = BOOT_NOTHING;
  241. }
  242. if ((i == 0) && (type == BOOT_NOTHING)) {
  243. /* Return to caller */
  244. exit(0);
  245. }
  246. if (type >= BOOT_NOTHING) {
  247. interruptible_sleep(2);
  248. state = 0;
  249. break;
  250. }
  251. ops = &operations[type];
  252. dev = ops->dev;
  253. dev->how_probe = PROBE_FIRST;
  254. dev->type = type;
  255. dev->failsafe = failsafe;
  256. dev->type_index = 0;
  257. } else {
  258. /* Advance to the next device of the same type */
  259. dev->how_probe = PROBE_NEXT;
  260. }
  261. state = 3;
  262. break;
  263. case 3:
  264. state = -1;
  265. /* Removed the following line because it was causing
  266. * heap.o to be dragged in unnecessarily. It's also
  267. * slightly puzzling: by resetting heap_base, doesn't
  268. * this mean that we permanently leak memory?
  269. */
  270. /* heap_base = allot(0); */
  271. dev->how_probe = ops->probe(dev);
  272. if (dev->how_probe == PROBE_FAILED) {
  273. dev = 0;
  274. state = 4;
  275. } else if (boot_index && (i == 0) && (boot_index != (unsigned)dev->type_index)) {
  276. printf("Wrong index\n");
  277. state = 4;
  278. }
  279. else {
  280. state = 2;
  281. }
  282. break;
  283. case 2:
  284. state = -1;
  285. if (ops->load_configuration(dev) >= 0) {
  286. state = 1;
  287. }
  288. break;
  289. case 1:
  290. /* Any return from load is a failure */
  291. ops->load(dev);
  292. state = -1;
  293. break;
  294. case 256:
  295. state = 0;
  296. break;
  297. case -3:
  298. i = MAX_BOOT_ENTRIES;
  299. type = BOOT_NOTHING;
  300. /* fall through */
  301. default:
  302. printf("<abort>\n");
  303. state = 4;
  304. /* At the end goto state 0 */
  305. if ((type >= BOOT_NOTHING) || (i >= MAX_BOOT_ENTRIES)) {
  306. state = 0;
  307. }
  308. break;
  309. }
  310. return state;
  311. }
  312. #endif
  313. /**************************************************************************
  314. LOADKERNEL - Try to load kernel image
  315. **************************************************************************/
  316. struct proto {
  317. char *name;
  318. int (*load)(const char *name,
  319. int (*fnc)(unsigned char *, unsigned int, unsigned int, int));
  320. };
  321. static const struct proto protos[] = {
  322. #ifdef DOWNLOAD_PROTO_TFTM
  323. { "x-tftm", url_tftm },
  324. #endif
  325. #ifdef DOWNLOAD_PROTO_SLAM
  326. { "x-slam", url_slam },
  327. #endif
  328. #ifdef DOWNLOAD_PROTO_NFS
  329. { "nfs", nfs },
  330. #endif
  331. #ifdef DOWNLOAD_PROTO_DISK
  332. { "file", url_file },
  333. #endif
  334. #ifdef DOWNLOAD_PROTO_TFTP
  335. { "tftp", tftp },
  336. #endif
  337. #ifdef DOWNLOAD_PROTO_HTTP
  338. { "http", http },
  339. #endif
  340. };
  341. int loadkernel(const char *fname)
  342. {
  343. static const struct proto * const last_proto =
  344. &protos[sizeof(protos)/sizeof(protos[0])];
  345. const struct proto *proto;
  346. in_addr ip;
  347. int len;
  348. const char *name;
  349. #ifdef DNS_RESOLVER
  350. const char *resolvt;
  351. #endif
  352. ip.s_addr = arptable[ARP_SERVER].ipaddr.s_addr;
  353. name = fname;
  354. url_port = -1;
  355. len = 0;
  356. while(fname[len] && fname[len] != ':') {
  357. len++;
  358. }
  359. for(proto = &protos[0]; proto < last_proto; proto++) {
  360. if (memcmp(name, proto->name, len) == 0) {
  361. break;
  362. }
  363. }
  364. if ((proto < last_proto) && (memcmp(fname + len, "://", 3) == 0)) {
  365. name += len + 3;
  366. if (name[0] != '/') {
  367. #ifdef DNS_RESOLVER
  368. resolvt = dns_resolver ( name );
  369. if ( NULL != resolvt ) {
  370. //printf ("Resolved host name [%s] to [%s]\n",
  371. // name, resolvt );
  372. inet_aton(resolvt, &ip);
  373. while ( ( '/' != name[0] ) && ( 0 != name[0]))
  374. ++name;
  375. } else
  376. #endif /* DNS_RESOLVER */
  377. name += inet_aton(name, &ip);
  378. if (name[0] == ':') {
  379. name++;
  380. url_port = strtoul(name, &name, 10);
  381. }
  382. }
  383. if (name[0] == '/') {
  384. arptable[ARP_SERVER].ipaddr.s_addr = ip.s_addr;
  385. printf( "Loading %s ", fname );
  386. return proto->load(name + 1, load_block);
  387. }
  388. }
  389. printf("Loading %@:%s ", arptable[ARP_SERVER].ipaddr, fname);
  390. #ifdef DEFAULT_PROTO_NFS
  391. return nfs(fname, load_block);
  392. #else
  393. return tftp(fname, load_block);
  394. #endif
  395. }
  396. /**************************************************************************
  397. CLEANUP - shut down networking and console so that the OS may be called
  398. **************************************************************************/
  399. void cleanup(void)
  400. {
  401. #ifdef DOWNLOAD_PROTO_NFS
  402. nfs_umountall(ARP_SERVER);
  403. #endif
  404. /* Stop receiving packets */
  405. eth_disable();
  406. disk_disable();
  407. initialized = 0;
  408. }
  409. /*
  410. * Local variables:
  411. * c-basic-offset: 8
  412. * End:
  413. */