kernel.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632
  1. /* Kernel: entry point at 0x7E00, timer (PIT 1 kHz), process init, terminal. */
  2. #include "acpi.h"
  3. #include "asix.h"
  4. #include "bootcon.h"
  5. #include "bootinfo.h"
  6. #include "cpu.h"
  7. #include "cros_ec.h"
  8. #include "idle.h"
  9. #include "io.h"
  10. #include "lapic.h"
  11. #include "panic.h"
  12. #include "kmalloc.h"
  13. #include "mm.h"
  14. #include "mouse.h"
  15. #include "netdev.h"
  16. #include "net.h"
  17. #include "dhcp.h"
  18. #include "netlog.h"
  19. #include "paging.h"
  20. #include "power.h"
  21. #include "process.h"
  22. #include "ramfs.h"
  23. #include "rndis.h"
  24. #include "sched.h"
  25. #include "thermal.h"
  26. #include "timer.h"
  27. #include "tpec.h"
  28. #include "tss.h"
  29. #include "usbhid.h"
  30. #include "usbmsc.h"
  31. #include "wm.h"
  32. #include "serial.h"
  33. #include "smp.h"
  34. #include "version.h"
  35. #include "vga.h"
  36. #include "vfs.h"
  37. #include "wifi_cfg.h"
  38. static inline void outb(unsigned short port, unsigned char v)
  39. {
  40. __asm__ volatile ("outb %0, %1" : : "a"(v), "Nd"(port));
  41. }
  42. volatile unsigned int ticks;
  43. static unsigned int timer_hz;
  44. static unsigned int tick_ms = 1;
  45. struct idt_entry {
  46. unsigned short offset_lo;
  47. unsigned short selector;
  48. unsigned char zero;
  49. unsigned char type;
  50. unsigned short offset_hi;
  51. } __attribute__((packed));
  52. struct idtr_desc {
  53. unsigned short limit;
  54. unsigned int base;
  55. } __attribute__((packed));
  56. static struct idt_entry idt[256];
  57. static struct idtr_desc idtr;
  58. extern void pit_irq_stub(void);
  59. extern void kbd_irq_stub(void);
  60. extern void mouse_irq_stub(void);
  61. extern void fdc_irq_stub(void);
  62. extern void default_irq_stub(void);
  63. extern void resched_stub(void);
  64. extern void lapic_timer_stub(void);
  65. extern void lapic_resched_stub(void);
  66. extern void lapic_spurious_stub(void);
  67. extern void syscall_stub(void);
  68. extern unsigned int exc_stub_table[];
  69. unsigned int get_ticks_ms(void)
  70. {
  71. return ticks;
  72. }
  73. unsigned int timer_tick_ms(void)
  74. {
  75. return tick_ms;
  76. }
  77. void timer_tick_advance(void)
  78. {
  79. ticks += tick_ms;
  80. }
  81. void timer_set_hz(unsigned int hz)
  82. {
  83. unsigned int flags, divisor;
  84. if (hz < 100 || hz > 1000)
  85. hz = 1000;
  86. if (hz == timer_hz)
  87. return;
  88. __asm__ volatile ("pushfl; popl %0" : "=r"(flags));
  89. __asm__ volatile ("cli" ::: "memory");
  90. timer_hz = hz;
  91. tick_ms = 1000 / hz;
  92. divisor = 1193182u / hz;
  93. outb(0x43, 0x36);
  94. outb(0x40, (unsigned char)(divisor & 0xFF));
  95. outb(0x40, (unsigned char)((divisor >> 8) & 0xFF));
  96. if (flags & (1u << 9))
  97. __asm__ volatile ("sti" ::: "memory");
  98. }
  99. void exc_handler(struct exc_state *st);
  100. void exc_handler(struct exc_state *st)
  101. {
  102. unsigned int vector = st->vector;
  103. unsigned int cr2 = 0;
  104. static const char * const names[] = {
  105. "#DE Divide Error", "#DB Debug", "NMI", "#BP Breakpoint",
  106. "#OF Overflow", "#BR Bound Range", "#UD Invalid Opcode",
  107. "#NM No FPU", "#DF Double Fault", "Coprocessor Overrun",
  108. "#TS Invalid TSS", "#NP Seg Not Present", "#SS Stack Fault",
  109. "#GP General Protection", "#PF Page Fault", "Reserved",
  110. "#MF FPU Error", "#AC Alignment Check", "#MC Machine Check",
  111. "#XM SIMD Error",
  112. };
  113. __asm__ volatile ("mov %%cr2, %0" : "=r"(cr2));
  114. /* A fault from ring 3 is a bug in a user command (or its ELF): kill that
  115. * process and keep the kernel running. Kernel faults still halt. */
  116. if ((st->cs & 3) == 3) {
  117. struct process *p = current_proc();
  118. serial_puts(SERIAL_COM1, "\n*** user fault vec ");
  119. serial_puthex(SERIAL_COM1, vector);
  120. serial_puts(SERIAL_COM1, " eip=");
  121. serial_puthex(SERIAL_COM1, st->eip);
  122. serial_puts(SERIAL_COM1, " cr2=");
  123. serial_puthex(SERIAL_COM1, cr2);
  124. if (p) {
  125. serial_puts(SERIAL_COM1, " pid=");
  126. serial_putdec(SERIAL_COM1, p->pid);
  127. serial_puts(SERIAL_COM1, " ");
  128. serial_puts(SERIAL_COM1, p->name);
  129. }
  130. serial_puts(SERIAL_COM1, " -- process killed\n");
  131. io_putstr("\n*** fault: ");
  132. io_putstr(vector < 20 ? names[vector] : "unknown vector");
  133. io_putstr(" -- command killed\n");
  134. process_exit(); /* marks us dead and waits to be switched out */
  135. }
  136. /* Fatal kernel fault: the banner goes straight into the LFB (no serial
  137. * console needed) and the full state is mirrored to COM1. */
  138. panic_report(st, vector < 20 ? names[vector] : "unknown vector");
  139. for (;;)
  140. __asm__ volatile ("cli; hlt");
  141. }
  142. static void set_idt_gate(int vec, unsigned int handler)
  143. {
  144. idt[vec].offset_lo = (unsigned short)(handler & 0xFFFF);
  145. idt[vec].selector = 0x08;
  146. idt[vec].zero = 0;
  147. idt[vec].type = 0x8E;
  148. idt[vec].offset_hi = (unsigned short)((handler >> 16) & 0xFFFF);
  149. }
  150. /* Trap gate (DPL=3) so ring-3 can `int` into it; a trap gate does NOT clear
  151. * IF, so a blocking syscall (e.g. sleep) can still be preempted by the timer. */
  152. static void set_idt_gate_user(int vec, unsigned int handler)
  153. {
  154. idt[vec].offset_lo = (unsigned short)(handler & 0xFFFF);
  155. idt[vec].selector = 0x08;
  156. idt[vec].zero = 0;
  157. idt[vec].type = 0xEF;
  158. idt[vec].offset_hi = (unsigned short)((handler >> 16) & 0xFFFF);
  159. }
  160. static void timer_init(void)
  161. {
  162. int i;
  163. /* Remap PICs: master at 0x20, slave at 0x28. */
  164. outb(0x20, 0x11);
  165. outb(0xA0, 0x11);
  166. outb(0x21, 0x20);
  167. outb(0xA1, 0x28);
  168. outb(0x21, 0x04);
  169. outb(0xA1, 0x02);
  170. outb(0x21, 0x01);
  171. outb(0xA1, 0x01);
  172. outb(0x21, 0xFC);
  173. outb(0xA1, 0xFF);
  174. /* Default handler for all 256 vectors: absorbs any unexpected
  175. interrupt (including spurious IRQ 7) with an EOI + iret. */
  176. for (i = 0; i < 256; i++)
  177. set_idt_gate(i, (unsigned int)default_irq_stub);
  178. /* Exception handlers 0-31: ring-3 faults kill the process, kernel
  179. faults print the panic banner and halt (see exc_handler). */
  180. for (i = 0; i < 32; i++)
  181. set_idt_gate(i, exc_stub_table[i]);
  182. /* Hardware IRQ handlers. */
  183. set_idt_gate(0x20, (unsigned int)pit_irq_stub);
  184. set_idt_gate(0x21, (unsigned int)kbd_irq_stub);
  185. set_idt_gate(0x2c, (unsigned int)mouse_irq_stub);
  186. set_idt_gate(0x26, (unsigned int)fdc_irq_stub);
  187. /* Local-APIC vectors: the AP timer and reschedule IPI, plus the
  188. * spurious vector the LAPIC can deliver at any time. */
  189. set_idt_gate(LAPIC_TIMER_VECTOR, (unsigned int)lapic_timer_stub);
  190. set_idt_gate(LAPIC_RESCHED_VECTOR, (unsigned int)lapic_resched_stub);
  191. set_idt_gate(LAPIC_SPURIOUS_VECTOR, (unsigned int)lapic_spurious_stub);
  192. /* Syscall gate (ring-3 can int 0x80). */
  193. set_idt_gate_user(0x80, (unsigned int)syscall_stub);
  194. /* Kernel-only voluntary reschedule gate (int 0x81). */
  195. set_idt_gate(0x81, (unsigned int)resched_stub);
  196. idtr.limit = (unsigned short)(sizeof(idt) - 1);
  197. idtr.base = (unsigned int)idt;
  198. __asm__ volatile ("lidt %0" : : "m"(idtr));
  199. /* Start the PIT at 1 kHz; schedule() drops it to 100 Hz while the BSP
  200. * is idle (see timer_set_hz). */
  201. timer_set_hz(1000);
  202. __asm__ volatile ("sti");
  203. }
  204. /* The BSP built the IDT once; APs only need to load the same pointer. */
  205. void idt_load_ap(void)
  206. {
  207. __asm__ volatile ("lidt %0" : : "m"(idtr));
  208. }
  209. extern unsigned char __bss_start[], __bss_end[];
  210. static int kworker_pid = -1;
  211. /* Parts of the system that must keep running independently of the WM:
  212. * input routing, cursor blink, kexec recovery, netlog flushing, gfx-session
  213. * cleanup and the shadow-buffer flush. */
  214. static void system_housekeeping(void)
  215. {
  216. process_reap_dead();
  217. mouse_poll_update();
  218. #ifndef NOWM
  219. wm_pump_keyboard();
  220. #endif
  221. netlog_flush();
  222. #ifndef NOWM
  223. wm_handle_kexec();
  224. wm_server_supervise();
  225. if (!wm_server_frame_active())
  226. vga_fb_flush_budget(VGA_FLUSH_BUDGET_BYTES);
  227. #else
  228. /* Diagnostic build: keep the direct-LFB boot console visible and do
  229. * not let the WM shadow flush overwrite it. */
  230. #endif
  231. }
  232. static void kworker_main(void)
  233. {
  234. for (;;) {
  235. system_housekeeping();
  236. process_sleep_ms(2);
  237. }
  238. }
  239. /* Idle is not a normal runnable task: schedule() selects it only when no
  240. * READY process exists. The kworker does the housekeeping; if it dies (or
  241. * could not be created), idle takes over as a degraded fallback. */
  242. static void kernel_idle_loop(void)
  243. {
  244. for (;;) {
  245. if (kworker_pid <= 0 ||
  246. !process_is_alive((unsigned int)kworker_pid)) {
  247. /* Idle must never sleep on the BKL: if a user process on
  248. * another CPU owns it, just keep idling and retry. */
  249. if (bkl_trylock()) {
  250. system_housekeeping();
  251. bkl_unlock();
  252. }
  253. }
  254. cpu_idle();
  255. }
  256. }
  257. /* Boot-stage tracing: COM1 (netlog mirrors it) plus the direct-LFB boot
  258. * console, so a machine without serial still shows where the boot stops. */
  259. static unsigned int boot_t0;
  260. static void boot_trace(const char *what)
  261. {
  262. unsigned int ms = get_ticks_ms() - boot_t0;
  263. bootcon_puts("[");
  264. bootcon_puts(what);
  265. bootcon_puts("] +");
  266. bootcon_dec(ms);
  267. bootcon_puts(" ms\n");
  268. serial_puts(SERIAL_COM1, "[boot] ");
  269. serial_puts(SERIAL_COM1, what);
  270. serial_puts(SERIAL_COM1, " +");
  271. serial_putdec(SERIAL_COM1, ms);
  272. serial_puts(SERIAL_COM1, " ms\n");
  273. }
  274. static void boot_val(const char *name, unsigned int v)
  275. {
  276. bootcon_puts(name);
  277. bootcon_puts(": ");
  278. bootcon_dec(v);
  279. bootcon_puts("\n");
  280. serial_puts(SERIAL_COM1, name);
  281. serial_puts(SERIAL_COM1, ": ");
  282. serial_putdec(SERIAL_COM1, v);
  283. serial_puts(SERIAL_COM1, "\n");
  284. }
  285. /* Bounded PIT self-test. If the 8259 does not deliver IRQ0, every later
  286. * delay/timeout would spin on a frozen tick counter; say so and stop. */
  287. static int pit_ticking(void)
  288. {
  289. unsigned int t0 = get_ticks_ms();
  290. unsigned int n;
  291. for (n = 0; n < 5000000u; n++) {
  292. if (get_ticks_ms() != t0)
  293. return 1;
  294. __asm__ volatile ("pause");
  295. }
  296. return 0;
  297. }
  298. /* A kexec/net-dev reload starts a fresh kernel with zeroed BSS, so the
  299. * leased address and resolver would otherwise fall back to the static
  300. * default until someone types dhcp. The previous kernel stashed them in
  301. * the boot-info reserved words; apply them before the boot DHCP attempt. */
  302. static int net_restore_boot_config(void)
  303. {
  304. const volatile unsigned int *p;
  305. unsigned char ip[4], mask[4], gw[4], dns[4];
  306. unsigned int i;
  307. if (!bootinfo_valid() || !(bootinfo_flags() & BOOTINFO_FLAG_NET))
  308. return 0;
  309. p = bootinfo_words();
  310. for (i = 0; i < 4; i++) {
  311. ip[i] = (unsigned char)(p[7] >> (8 * i));
  312. mask[i] = (unsigned char)(p[8] >> (8 * i));
  313. gw[i] = (unsigned char)(p[9] >> (8 * i));
  314. dns[i] = (unsigned char)(p[10] >> (8 * i));
  315. }
  316. if (!(ip[0] || ip[1] || ip[2] || ip[3]))
  317. return 0;
  318. net_configure(ip, mask, gw);
  319. if (dns[0] || dns[1] || dns[2] || dns[3])
  320. net_set_dns(dns);
  321. boot_trace("net retained");
  322. /* A resolver is what net-dev users notice missing; without one, let
  323. * the boot DHCP attempt learn it. */
  324. return dns[0] || dns[1] || dns[2] || dns[3];
  325. }
  326. void kernel_main(void);
  327. void kernel_main(void)
  328. {
  329. unsigned char *p = __bss_start;
  330. int net_kept;
  331. while (p < __bss_end)
  332. *p++ = 0;
  333. /* Earliest possible output: straight into the boot framebuffer, before
  334. * paging, drivers, the heap or the serial port. Everything below logs
  335. * here as well as to COM1, so a machine without serial (the X201) can
  336. * show where the boot stops. */
  337. bootcon_init();
  338. bootcon_puts(OS_NAME " v" OS_VERSION "\n");
  339. serial_init(SERIAL_COM1);
  340. serial_ring_init();
  341. /* Network console mirror from the very first line on; the ring holds the
  342. * early boot output until the WM loop starts flushing it. */
  343. netlog_init();
  344. serial_puts(SERIAL_COM1, "\n" OS_NAME " v" OS_VERSION " booted\n");
  345. boot_trace("start");
  346. /* GDT/TSS and the per-CPU GS base must exist before anything that can
  347. * use current_proc()/this_cpu(). The BSS is already cleared and the
  348. * GDT/TSS live at identity-mapped addresses. */
  349. gdt_tss_init(0);
  350. boot_trace("gdt");
  351. mm_init();
  352. mm_dump();
  353. boot_trace("mm");
  354. boot_val("mm free KB", mm_free_pages() * 4);
  355. kmalloc_init();
  356. /* Report the VBE geometry before paging, so a boot that dies in the
  357. * translation switch still says which mode the BIOS picked. */
  358. bootcon_fb_info();
  359. paging_init();
  360. boot_trace("paging");
  361. /* Keep a RAM copy of the boot console text; the WM hides the
  362. * framebuffer console later and this is what `bootlog` prints. */
  363. bootcon_log_init();
  364. /* paging_init only ORs in PSE; make sure the BSP's SSE state is on
  365. * before any drawing path can select an SSE2 helper. */
  366. cpu_enable_sse();
  367. /* ACPI needs paging for table access; a missing or unusable MADT simply
  368. * leaves the machine at one CPU. */
  369. acpi_init();
  370. acpi_dump();
  371. boot_trace("acpi");
  372. boot_val("acpi cpus", acpi_cpu_count());
  373. io_init();
  374. boot_trace("io");
  375. /* P-states/deep C-states first: idle_init() picks its default from
  376. * the power module (deep MWAIT on Nehalem, HLT elsewhere). */
  377. power_init();
  378. idle_init();
  379. boot_trace("power");
  380. thermal_init();
  381. boot_trace("thermal");
  382. /* Board sensors: the ThinkPad EC probe is gated on SMBIOS identifying a
  383. * Lenovo/IBM machine, so it is a no-op everywhere else. The Chrome EC
  384. * probe is skipped when the ThinkPad EC was found. */
  385. tpec_init();
  386. cros_ec_init();
  387. boot_trace("ec");
  388. /* process_init must run before timer_init: once the PIT is started (sti
  389. * in timer_init) the context-switch stub runs on every tick and reads
  390. * the current process, its CR3 and the TSS, so those must be valid. */
  391. process_init();
  392. boot_trace("process");
  393. timer_init();
  394. boot_t0 = get_ticks_ms();
  395. boot_trace("timer");
  396. if (!pit_ticking()) {
  397. bootcon_puts("*** PIT NOT TICKING ***\n");
  398. serial_puts(SERIAL_COM1, "*** PIT NOT TICKING ***\n");
  399. for (;;)
  400. __asm__ volatile ("cli; hlt");
  401. }
  402. boot_val("timer ticks", get_ticks_ms());
  403. /* The PIT (and its sti) is live, so the AP bring-up can use it as a
  404. * timeout clock. APs idle until smp_enable_sched() after boot. */
  405. smp_init();
  406. boot_trace("smp");
  407. boot_val("smp cpus", cpu_count);
  408. mouse_init();
  409. boot_trace("ps2");
  410. /* USB HID backend (mouse + keyboard): controller bring-up + first
  411. * scan; devices plugged in later are picked up by the hotplug
  412. * watcher in the WM loop. */
  413. asix_register();
  414. usbmsc_register();
  415. rndis_register();
  416. usbhid_init();
  417. boot_trace("usb");
  418. vga_shadow_init();
  419. vga_fb_flush();
  420. boot_trace("vga");
  421. /* The command pack: read-only, mounted at /ramfs (see ramfs.c). The
  422. * boot path copied it into RAM (the legacy stage's low gap, the UEFI
  423. * loader or kexec); ramfs_init takes its own copy so the boot region
  424. * can be released. The mount is created even without a pack, so a running
  425. * board can be recovered with `make cmds-dev`/`make net-cmds`. */
  426. {
  427. unsigned int pack_addr = bootinfo_pack_addr();
  428. unsigned int pack_len = bootinfo_pack_size();
  429. int ok = 0, gz = 0;
  430. if (!pack_addr || !pack_len)
  431. serial_puts(SERIAL_COM1, "ramfs: no boot pack\n");
  432. else {
  433. const unsigned char *p = (const unsigned char *)pack_addr;
  434. gz = pack_len >= 2 && p[0] == 0x1F && p[1] == 0x8B;
  435. serial_puts(SERIAL_COM1, "ramfs: boot pack at ");
  436. serial_puthex(SERIAL_COM1, pack_addr);
  437. serial_puts(SERIAL_COM1, ", ");
  438. serial_putdec(SERIAL_COM1, pack_len);
  439. serial_puts(SERIAL_COM1, gz ? " bytes (gzip)\n" :
  440. " bytes\n");
  441. if (gz)
  442. ramfs_set_boot_image((const void *)pack_addr,
  443. pack_len, 1);
  444. ok = ramfs_init((const void *)pack_addr, pack_len) == 0;
  445. if (!ok) {
  446. serial_puts(SERIAL_COM1, "ramfs: bad boot pack\n");
  447. ramfs_set_boot_image(0, 0, 0);
  448. mm_free_range(pack_addr, pack_len);
  449. } else {
  450. serial_puts(SERIAL_COM1, "ramfs: pack ok, ");
  451. serial_putdec(SERIAL_COM1, ramfs_count());
  452. serial_puts(SERIAL_COM1, " files, ");
  453. serial_putdec(SERIAL_COM1, ramfs_pack_size());
  454. serial_puts(SERIAL_COM1, " bytes\n");
  455. if (!gz) {
  456. /* ramfs has its own copy now; keep that
  457. * as the self-update image. */
  458. ramfs_set_boot_image(ramfs_pack_base(),
  459. ramfs_pack_size(), 0);
  460. mm_free_range(pack_addr, pack_len);
  461. }
  462. /* A gzip boot image stays reserved so
  463. * `install self` can write it to P2. */
  464. }
  465. }
  466. (void)ok;
  467. vfs_mount_ramfs();
  468. }
  469. boot_trace("ramfs");
  470. boot_val("ramfs files", ramfs_count());
  471. #ifndef NOWM
  472. /* Start the WM before touching disks: the first frame can be painted
  473. * while storage and the network are still being probed. */
  474. wm_server_init();
  475. boot_trace("wm init");
  476. wm_server_start();
  477. boot_trace("wm");
  478. #else
  479. /* Diagnostic build: boot to the console, no WM, no terminal. */
  480. bootcon_puts("WM disabled (diagnostic build)\n");
  481. serial_puts(SERIAL_COM1, "nowm: window manager disabled\n");
  482. boot_trace("wm off");
  483. #endif
  484. /* Probe the NIC (link negotiation is asynchronous now) before the
  485. * kworker starts, so its netlog flushes have a device to use. */
  486. netdev_active();
  487. net_kept = net_restore_boot_config();
  488. boot_trace("net");
  489. /* The idle process is the kernel_main context; housekeeping runs in
  490. * its own process so it cannot be starved by a busy system. */
  491. kworker_pid = process_create("kworker", kworker_main);
  492. if (kworker_pid < 0) {
  493. serial_puts(SERIAL_COM1, "kworker: cannot create, using idle fallback\n");
  494. kworker_pid = -1;
  495. } else {
  496. process_set_weight((unsigned int)kworker_pid, 4);
  497. process_set_affinity((unsigned int)kworker_pid, 1);
  498. }
  499. boot_trace("kworker");
  500. /* Slow storage bring-up happens behind the usable desktop now. */
  501. boot_trace("storage begin");
  502. vfs_mount_all();
  503. boot_trace("storage");
  504. /* The WM spawns the first terminal once it sees boot_ready: while the
  505. * boot scan was rebuilding the mount table, no user command could touch
  506. * the disks. The desktop itself was already painted from /ramfs. */
  507. #ifndef NOWM
  508. wm_server_boot_ready();
  509. boot_trace("terminal ready");
  510. #else
  511. boot_trace("terminal off");
  512. #endif
  513. /* With a linked NIC present, try DHCP; on failure the static default
  514. * stays. A wired NIC without a cable is skipped so the WiFi fallback
  515. * below does not have to wait out the 4 s timeout first. Deliberately
  516. * after the WM: a missing cable or DHCP server must not delay the first
  517. * frame. */
  518. {
  519. const struct netdev *nd = netdev_active();
  520. int linked = nd && netdev_link(nd);
  521. if (linked && !net_kept)
  522. dhcp_run(4000);
  523. boot_trace(net_kept ? "dhcp skipped" :
  524. (linked ? "dhcp" : "dhcp no link"));
  525. }
  526. /* If the writable /data volume has saved WiFi credentials, let the
  527. * normal supplicant reconnect in the background. It leaves a wired
  528. * link that is physically up alone, and a missing /data or wifi
  529. * helper is harmless. */
  530. {
  531. unsigned int sz = 0;
  532. int is_dir = 0;
  533. if (vfs_stat(WIFI_CRED_PATH, &sz, &is_dir) == 0 &&
  534. !is_dir && sz > 0) {
  535. struct vfs_file f;
  536. struct vfs_mount *m = 0;
  537. if (vfs_load_file("/ramfs/bin/wifi", &f, &m) == 0) {
  538. if (process_create_user("wifi", f.data, f.size,
  539. "autoconnect", "/") > 0)
  540. serial_puts(SERIAL_COM1,
  541. "wifi: autoconnect started\n");
  542. vfs_release_file(m, &f);
  543. }
  544. }
  545. }
  546. boot_trace("wifi auto");
  547. /* Dump the active NIC's counters after the boot DHCP attempt. With
  548. * the ASIX as the management link this appears in netmon even when
  549. * the active e1000e cannot pass traffic. */
  550. {
  551. const struct netdev *nd = netdev_active();
  552. if (nd && (nd->dump_brief || nd->dump_regs)) {
  553. io_putstr("\n[boot netregs: ");
  554. io_putstr(nd->name);
  555. io_putstr("]\n");
  556. if (nd->dump_brief)
  557. nd->dump_brief();
  558. else
  559. nd->dump_regs();
  560. }
  561. }
  562. /* Boot-time device/FS setup is complete; APs may now take user work.
  563. * Kernel threads stay pinned to the BSP and serialize on the BKL. */
  564. smp_enable_sched();
  565. boot_trace("sched");
  566. kernel_idle_loop();
  567. }