wm.c 32 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272
  1. /* Kernel window server for the ring-3 WM: window bookkeeping, canvas
  2. * mapping/presentation and input routing. There is no in-kernel WM. */
  3. #include "wm.h"
  4. #include "bootcon.h"
  5. #include "io.h"
  6. #include "kexec.h"
  7. #include "mm.h"
  8. #include "mouse.h"
  9. #include "netkexec.h"
  10. #include "netlog.h"
  11. #include "paging.h"
  12. #include "payload.h"
  13. #include "process.h"
  14. #include "serial.h"
  15. #include "timer.h"
  16. #include "vga.h"
  17. #include "vfs.h"
  18. static struct window windows[MAX_WINDOWS];
  19. static int wm_full_redraw;
  20. /* Content pointer routing for canvas windows. wm_server_poll() is
  21. * called by the ring-3 WM every loop, so it is the cheapest place to turn the
  22. * sampled mouse state into press/release edges. */
  23. static unsigned int wm_ptr_buttons;
  24. static int wm_ptr_capture = -1;
  25. /* Ring-3 WM lifecycle. The kernel only admits the process it spawned; a
  26. * stale pid cannot keep drawing after a restart. */
  27. static unsigned int wm_expected_pid;
  28. static unsigned int wm_pid;
  29. static unsigned int wm_cr3;
  30. static int wm_attached;
  31. static int wm_frame_active;
  32. static int wm_first_frame;
  33. static int wm_boot_ready;
  34. static int wm_boot_logged;
  35. static unsigned int wm_last_start;
  36. static unsigned int wm_last_seen;
  37. static inline unsigned int irq_save_disable(void)
  38. {
  39. unsigned int flags;
  40. __asm__ volatile ("pushfl; popl %0; cli" : "=r"(flags));
  41. return flags;
  42. }
  43. static inline void irq_restore(unsigned int flags)
  44. {
  45. __asm__ volatile ("pushl %0; popfl" :: "r"(flags));
  46. }
  47. static inline void invlpg_va(unsigned int va)
  48. {
  49. __asm__ volatile ("invlpg (%0)" : : "r"(va) : "memory");
  50. }
  51. static void wm_focus_index(unsigned int idx);
  52. static void wm_focus_top(void);
  53. static void wm_close_window(unsigned int idx);
  54. static void wm_clamp_window(struct window *w, int nx, int ny);
  55. static void wm_server_unmap_index(unsigned int idx);
  56. static int wm_window_at(int px, int py);
  57. void wm_request_redraw(void)
  58. {
  59. wm_full_redraw = 1;
  60. }
  61. struct window *wm_focused_window(void)
  62. {
  63. unsigned int i;
  64. for (i = 0; i < MAX_WINDOWS; i++)
  65. if (windows[i].used && windows[i].focused)
  66. return &windows[i];
  67. return (void *)0;
  68. }
  69. int wm_is_focused(const struct window *w)
  70. {
  71. return w->focused;
  72. }
  73. /* ---- Ring-3 WM ABI ---------------------------------------------------- */
  74. int wm_server_is_wm(void)
  75. {
  76. return wm_attached && current_proc()->pid == wm_pid;
  77. }
  78. int wm_server_frame_active(void)
  79. {
  80. return wm_frame_active;
  81. }
  82. /* Safe point for freeing another window's canvas: the WM is not between
  83. * SYS_WM_INFO/MAP and PRESENT. A ring-3 WM sleeps at the end of every loop;
  84. * the kernel fallback has no cached mappings. */
  85. int wm_server_can_reap(void)
  86. {
  87. if (wm_frame_active)
  88. return 0;
  89. return !wm_attached || process_is_sleeping(wm_pid);
  90. }
  91. static void wm_server_unmap_index(unsigned int idx)
  92. {
  93. struct window *w = &windows[idx];
  94. unsigned int va, i;
  95. if (!wm_cr3 || idx >= MAX_WINDOWS || !w->mapped_pages)
  96. return;
  97. va = WM_CONTENT_VA_BASE + idx * WM_CONTENT_SLOT;
  98. paging_release_user_range(wm_cr3, va, WM_CONTENT_SLOT, 0);
  99. for (i = 0; i < w->mapped_pages; i++)
  100. invlpg_va(va + i * PAGE_SIZE);
  101. w->mapped_kind = WM_KIND_NONE;
  102. w->mapped_gen = 0;
  103. w->mapped_pages = 0;
  104. w->mapped_src = 0;
  105. }
  106. /* A dead gfx session can coexist with a newer session on the same screen (the
  107. * old canvas is freed later). Only drop the WM mapping when it still points
  108. * at *this* canvas, so collecting the old session cannot unmap the new one. */
  109. static int wm_window_for_pid(unsigned int pid)
  110. {
  111. unsigned int i;
  112. for (i = 0; i < MAX_WINDOWS; i++)
  113. if (windows[i].used && windows[i].pid == pid)
  114. return (int)i;
  115. return -1;
  116. }
  117. static void wm_unmap_back(struct window *w, unsigned int pages)
  118. {
  119. unsigned int i;
  120. if (w->owner_cr3 && pages) {
  121. paging_release_user_range(w->owner_cr3, USER_WIN_BASE,
  122. pages * PAGE_SIZE, 0);
  123. for (i = 0; i < pages; i++)
  124. invlpg_va(USER_WIN_BASE + i * PAGE_SIZE);
  125. }
  126. w->owner_cr3 = 0;
  127. }
  128. static void wm_free_canvas_window(unsigned int idx)
  129. {
  130. struct window *w = &windows[idx];
  131. unsigned int i;
  132. if (!w->canvas_window)
  133. return;
  134. wm_unmap_back(w, w->back_pages);
  135. if (w->back) {
  136. for (i = 0; i < w->back_pages; i++)
  137. mm_free_page((unsigned int)w->back + i * PAGE_SIZE);
  138. w->back = 0;
  139. }
  140. w->back_pages = 0;
  141. if (w->pending_back) {
  142. for (i = 0; i < w->pending_pages; i++)
  143. mm_free_page((unsigned int)w->pending_back + i * PAGE_SIZE);
  144. w->pending_back = 0;
  145. }
  146. w->pending_pages = 0;
  147. w->resize_pending = 0;
  148. w->canvas_dmg_w = w->canvas_dmg_h = 0;
  149. gfx_free(&w->canvas);
  150. w->canvas_window = 0;
  151. }
  152. int wm_server_win_create(const struct win_create *in, struct win_info *out)
  153. {
  154. struct window *w;
  155. struct gfx_canvas *c;
  156. unsigned short *back;
  157. unsigned int i, j, pages, cw, ch, base;
  158. unsigned int flags;
  159. if (!in || !out)
  160. return -1;
  161. if (current_proc()->pid == 0 ||
  162. wm_window_for_pid(current_proc()->pid) >= 0)
  163. return -1;
  164. cw = in->w;
  165. ch = in->h;
  166. if (cw == 0 || ch == 0 || cw > WM_WIN_MAX_W || ch > WM_WIN_MAX_H)
  167. return -1;
  168. if (cw * ch * 2 > WM_CONTENT_SLOT || cw * ch * 2 > USER_WIN_RANGE)
  169. return -1;
  170. if (cw + 2 > vga_fb_width() || ch + WM_TITLE_H + 2 > vga_fb_height())
  171. return -1;
  172. for (i = 0; i < MAX_WINDOWS; i++)
  173. if (!windows[i].used)
  174. break;
  175. if (i == MAX_WINDOWS) {
  176. serial_puts(SERIAL_COM1, "wm: win_create no window slot\n");
  177. return -1;
  178. }
  179. w = &windows[i];
  180. c = &w->canvas;
  181. if (gfx_alloc(c, cw, ch) != 0)
  182. return -1;
  183. pages = (cw * ch * 2 + PAGE_SIZE - 1) / PAGE_SIZE;
  184. back = (unsigned short *)mm_alloc_pages(pages);
  185. if (!back) {
  186. gfx_free(c);
  187. return -1;
  188. }
  189. for (j = 0; j < cw * ch; j++)
  190. back[j] = 0;
  191. flags = irq_save_disable();
  192. base = current_proc()->cr3;
  193. for (j = 0; j < pages; j++) {
  194. if (!paging_map_page(base, USER_WIN_BASE + j * PAGE_SIZE,
  195. (unsigned int)back + j * PAGE_SIZE,
  196. PTE_USER | PTE_WRITABLE | PTE_PRESENT)) {
  197. irq_restore(flags);
  198. paging_release_user_range(base, USER_WIN_BASE,
  199. (j ? j : 1) * PAGE_SIZE, 0);
  200. for (i = 0; i < pages; i++)
  201. mm_free_page((unsigned int)back + i * PAGE_SIZE);
  202. gfx_free(c);
  203. return -1;
  204. }
  205. invlpg_va(USER_WIN_BASE + j * PAGE_SIZE);
  206. }
  207. irq_restore(flags);
  208. w->used = 1;
  209. w->canvas_window = 1;
  210. w->pid = current_proc()->pid;
  211. w->owner_cr3 = base;
  212. w->back = back;
  213. w->back_pages = pages;
  214. w->canvas.seq = 1;
  215. w->canvas.drawn = 0;
  216. w->pending_back = 0;
  217. w->pending_pages = 0;
  218. w->resize_pending = 0;
  219. w->canvas_dmg_x = w->canvas_dmg_y = 0;
  220. w->canvas_dmg_w = w->canvas_dmg_h = 0;
  221. w->pw = cw + 2;
  222. w->ph = ch + WM_TITLE_H + 2;
  223. w->x = 24 + (int)i * 32;
  224. w->y = WM_BAR_H + 12 + (int)i * 28;
  225. if (w->x + (int)w->pw > (int)vga_fb_width())
  226. w->x = ((int)vga_fb_width() > (int)w->pw) ?
  227. (int)vga_fb_width() - (int)w->pw : 0;
  228. if (w->y + (int)w->ph > (int)vga_fb_height())
  229. w->y = WM_BAR_H + 4;
  230. wm_clamp_window(w, w->x, w->y);
  231. w->focused = 0;
  232. w->content_gen = 1;
  233. w->mapped_kind = WM_KIND_NONE;
  234. w->mapped_gen = 0;
  235. w->mapped_pages = 0;
  236. w->mapped_src = 0;
  237. w->key_head = w->key_tail = 0;
  238. wait_queue_init(&w->key_wq);
  239. w->ptr_head = w->ptr_tail = 0;
  240. for (j = 0; j < sizeof(w->title) - 1 && in->title[j]; j++)
  241. w->title[j] = in->title[j];
  242. w->title[j] = '\0';
  243. wm_focus_index(i);
  244. out->fb = (void *)USER_WIN_BASE;
  245. out->width = cw;
  246. out->height = ch;
  247. out->id = i;
  248. return 0;
  249. }
  250. int wm_server_win_present(const struct wm_win_present *in)
  251. {
  252. int idx = wm_window_for_pid(current_proc()->pid);
  253. struct window *w;
  254. const unsigned short *src;
  255. unsigned int x = 0, y = 0, rw, rh, row;
  256. if (idx < 0)
  257. return -1;
  258. w = &windows[idx];
  259. if (!w->canvas_window || !w->back || !w->canvas.px ||
  260. w->resize_pending)
  261. return -1;
  262. rw = w->canvas.w;
  263. rh = w->canvas.h;
  264. if (in && in->w && in->h) {
  265. x = in->x;
  266. y = in->y;
  267. rw = in->w;
  268. rh = in->h;
  269. if (x >= w->canvas.w || y >= w->canvas.h)
  270. return -1;
  271. if (rw > w->canvas.w - x)
  272. rw = w->canvas.w - x;
  273. if (rh > w->canvas.h - y)
  274. rh = w->canvas.h - y;
  275. }
  276. src = (const unsigned short *)USER_WIN_BASE;
  277. for (row = 0; row < rh; row++) {
  278. const unsigned short *s = src + (unsigned long)(y + row) *
  279. w->canvas.w + x;
  280. unsigned short *d = w->canvas.px +
  281. (unsigned long)(y + row) * w->canvas.w + x;
  282. unsigned int n = rw;
  283. __asm__ volatile ("cld; rep movsw"
  284. : "+D"(d), "+c"(n), "+S"(s)
  285. :
  286. : "memory");
  287. }
  288. if (!w->canvas_dmg_w || !w->canvas_dmg_h) {
  289. w->canvas_dmg_x = x;
  290. w->canvas_dmg_y = y;
  291. w->canvas_dmg_w = rw;
  292. w->canvas_dmg_h = rh;
  293. } else {
  294. unsigned int x1 = w->canvas_dmg_x + w->canvas_dmg_w;
  295. unsigned int y1 = w->canvas_dmg_y + w->canvas_dmg_h;
  296. if (x < w->canvas_dmg_x)
  297. w->canvas_dmg_x = x;
  298. if (y < w->canvas_dmg_y)
  299. w->canvas_dmg_y = y;
  300. if (x + rw > x1)
  301. x1 = x + rw;
  302. if (y + rh > y1)
  303. y1 = y + rh;
  304. w->canvas_dmg_w = x1 - w->canvas_dmg_x;
  305. w->canvas_dmg_h = y1 - w->canvas_dmg_y;
  306. }
  307. w->canvas.seq++;
  308. return 0;
  309. }
  310. int wm_server_win_close(void)
  311. {
  312. int idx = wm_window_for_pid(current_proc()->pid);
  313. if (idx < 0 || !wm_server_can_reap())
  314. return -1;
  315. wm_server_unmap_index((unsigned int)idx);
  316. wm_free_canvas_window((unsigned int)idx);
  317. windows[idx].used = 0;
  318. windows[idx].pid = 0;
  319. windows[idx].focused = 0;
  320. windows[idx].content_gen++;
  321. wm_focus_top();
  322. wm_request_redraw();
  323. return 0;
  324. }
  325. int wm_server_win_info(struct win_info *out)
  326. {
  327. int idx = wm_window_for_pid(current_proc()->pid);
  328. struct window *w;
  329. if (!out || idx < 0)
  330. return -1;
  331. w = &windows[idx];
  332. if (!w->canvas_window)
  333. return -1;
  334. out->fb = (void *)USER_WIN_BASE;
  335. out->width = w->canvas.w;
  336. out->height = w->canvas.h;
  337. out->id = (unsigned int)idx;
  338. return 0;
  339. }
  340. int wm_server_win_ack_resize(void)
  341. {
  342. int idx = wm_window_for_pid(current_proc()->pid);
  343. struct window *w;
  344. unsigned int i, old_pages;
  345. if (idx < 0)
  346. return -1;
  347. w = &windows[idx];
  348. if (!w->canvas_window || !w->resize_pending || !w->pending_back)
  349. return -1;
  350. old_pages = w->back_pages;
  351. if (w->owner_cr3)
  352. paging_release_user_range(w->owner_cr3, USER_WIN_BASE,
  353. old_pages * PAGE_SIZE, 0);
  354. for (i = 0; i < w->pending_pages; i++) {
  355. if (!paging_map_page(current_proc()->cr3,
  356. USER_WIN_BASE + i * PAGE_SIZE,
  357. (unsigned int)w->pending_back + i * PAGE_SIZE,
  358. PTE_USER | PTE_WRITABLE | PTE_PRESENT)) {
  359. /* Put the old mapping back; this is a last-resort path. */
  360. paging_release_user_range(current_proc()->cr3,
  361. USER_WIN_BASE,
  362. i * PAGE_SIZE, 0);
  363. for (i = 0; i < old_pages; i++)
  364. paging_map_page(current_proc()->cr3,
  365. USER_WIN_BASE + i * PAGE_SIZE,
  366. (unsigned int)w->back + i * PAGE_SIZE,
  367. PTE_USER | PTE_WRITABLE | PTE_PRESENT);
  368. for (i = 0; i < w->pending_pages; i++)
  369. mm_free_page((unsigned int)w->pending_back +
  370. i * PAGE_SIZE);
  371. w->pending_back = 0;
  372. w->pending_pages = 0;
  373. w->resize_pending = 0;
  374. return -1;
  375. }
  376. invlpg_va(USER_WIN_BASE + i * PAGE_SIZE);
  377. }
  378. for (i = 0; i < old_pages; i++)
  379. mm_free_page((unsigned int)w->back + i * PAGE_SIZE);
  380. w->back = w->pending_back;
  381. w->back_pages = w->pending_pages;
  382. w->pending_back = 0;
  383. w->pending_pages = 0;
  384. w->resize_pending = 0;
  385. w->canvas_dmg_w = w->canvas_dmg_h = 0;
  386. return 0;
  387. }
  388. int wm_server_win_pointer(struct win_pointer *out)
  389. {
  390. int idx = wm_window_for_pid(current_proc()->pid);
  391. struct window *w;
  392. unsigned int mx, my;
  393. int cx, cy;
  394. if (!out || idx < 0 || !windows[idx].canvas_window)
  395. return -1;
  396. w = &windows[idx];
  397. mx = mouse_get_x();
  398. my = mouse_get_y();
  399. cx = (int)mx - (int)w->x - 1;
  400. cy = (int)my - (int)w->y - 1 - WM_TITLE_H;
  401. out->x = cx;
  402. out->y = cy;
  403. out->buttons = mouse_buttons_state();
  404. out->inside = (cx >= 0 && cy >= 0 &&
  405. cx < (int)w->canvas.w && cy < (int)w->canvas.h &&
  406. (w->focused || wm_window_at((int)mx, (int)my) == idx)) ?
  407. 1 : 0;
  408. out->focused = w->focused ? 1 : 0;
  409. return 0;
  410. }
  411. int wm_server_win_event(struct win_event *out)
  412. {
  413. int idx = wm_window_for_pid(current_proc()->pid);
  414. struct window *w;
  415. if (!out || idx < 0 || !windows[idx].canvas_window)
  416. return -1;
  417. w = &windows[idx];
  418. if (w->ptr_tail == w->ptr_head)
  419. return 0;
  420. *out = w->ptr_events[w->ptr_tail];
  421. w->ptr_tail = (w->ptr_tail + 1) % 8;
  422. return 1;
  423. }
  424. int wm_server_resize(unsigned int index, unsigned int cw, unsigned int ch)
  425. {
  426. struct window *w;
  427. struct gfx_canvas nf;
  428. unsigned short *nb;
  429. unsigned int i, pages;
  430. if (!wm_server_is_wm() || index >= MAX_WINDOWS || !windows[index].used)
  431. return -1;
  432. w = &windows[index];
  433. if (!w->canvas_window || !process_is_alive(w->pid))
  434. return -1;
  435. if (cw < 160 || ch < 80 || cw > WM_WIN_MAX_W || ch > WM_WIN_MAX_H)
  436. return -1;
  437. if (cw * ch * 2 > WM_CONTENT_SLOT || cw * ch * 2 > USER_WIN_RANGE)
  438. return -1;
  439. if (cw + 2 > vga_fb_width() || ch + WM_TITLE_H + 2 > vga_fb_height())
  440. return -1;
  441. if (gfx_alloc(&nf, cw, ch) != 0)
  442. return -1;
  443. pages = (cw * ch * 2 + PAGE_SIZE - 1) / PAGE_SIZE;
  444. nb = (unsigned short *)mm_alloc_pages(pages);
  445. if (!nb) {
  446. gfx_free(&nf);
  447. return -1;
  448. }
  449. for (i = 0; i < cw * ch; i++)
  450. nb[i] = 0;
  451. wm_server_unmap_index(index);
  452. gfx_free(&w->canvas);
  453. if (w->pending_back) {
  454. for (i = 0; i < w->pending_pages; i++)
  455. mm_free_page((unsigned int)w->pending_back + i * PAGE_SIZE);
  456. }
  457. w->canvas = nf;
  458. w->canvas.seq = 1;
  459. w->canvas.drawn = 0;
  460. w->canvas_dmg_x = w->canvas_dmg_y = 0;
  461. w->canvas_dmg_w = w->canvas_dmg_h = 0;
  462. w->pending_back = nb;
  463. w->pending_pages = pages;
  464. w->resize_pending = 1;
  465. w->pw = cw + 2;
  466. w->ph = ch + WM_TITLE_H + 2;
  467. w->content_gen++;
  468. /* The owner is probably parked in SYS_WIN_KEY_WAIT; wake it so it
  469. * acknowledges the resize (and reflows its content) immediately. */
  470. wait_wake_one(&w->key_wq);
  471. return 0;
  472. }
  473. int wm_server_key_poll(void)
  474. {
  475. int idx = wm_window_for_pid(current_proc()->pid);
  476. struct window *w;
  477. int k;
  478. if (idx < 0)
  479. return 0;
  480. w = &windows[idx];
  481. if (w->key_tail == w->key_head)
  482. return 0;
  483. k = w->keys[w->key_tail];
  484. w->key_tail = (w->key_tail + 1) % 16;
  485. return k;
  486. }
  487. /* Block until a key arrives for the caller's window, or `timeout_ms` passes
  488. * (0 = wait forever). Returns the key, 0 on timeout/no key, -1 if the caller
  489. * has no window. */
  490. int wm_server_key_wait(unsigned int timeout_ms)
  491. {
  492. int idx = wm_window_for_pid(current_proc()->pid);
  493. struct window *w;
  494. int k;
  495. if (idx < 0)
  496. return -1;
  497. w = &windows[idx];
  498. k = wm_server_key_poll();
  499. if (k)
  500. return k;
  501. if (timeout_ms)
  502. sched_block_timeout(&w->key_wq, timeout_ms);
  503. else
  504. sched_block_on(&w->key_wq);
  505. return wm_server_key_poll();
  506. }
  507. int wm_server_attach(struct wm_screen_info *out)
  508. {
  509. struct surface *s;
  510. unsigned int pages, i, bytes;
  511. if (!out || !wm_expected_pid ||
  512. current_proc()->pid != wm_expected_pid || wm_attached) {
  513. serial_puts(SERIAL_COM1, "wm: attach rejected (expected ");
  514. serial_puthex(SERIAL_COM1, wm_expected_pid);
  515. serial_puts(SERIAL_COM1, " current ");
  516. serial_puthex(SERIAL_COM1, current_proc()->pid);
  517. serial_puts(SERIAL_COM1, ")\n");
  518. return -1;
  519. }
  520. if (!vga_shadow_is_active()) {
  521. serial_puts(SERIAL_COM1, "wm: attach: no shadow buffer\n");
  522. return -1;
  523. }
  524. s = vga_screen_surface();
  525. if (!s || !s->px)
  526. return -1;
  527. bytes = s->pitch * s->h;
  528. pages = (bytes + PAGE_SIZE - 1) / PAGE_SIZE;
  529. wm_cr3 = current_proc()->cr3;
  530. for (i = 0; i < pages; i++) {
  531. unsigned int va = WM_SHADOW_VA + i * PAGE_SIZE;
  532. if (!paging_map_page(wm_cr3, va,
  533. (unsigned int)s->px + i * PAGE_SIZE,
  534. PTE_USER | PTE_WRITABLE | PTE_PRESENT)) {
  535. paging_release_user_range(wm_cr3, WM_SHADOW_VA,
  536. i * PAGE_SIZE, 0);
  537. wm_cr3 = 0;
  538. return -1;
  539. }
  540. invlpg_va(va);
  541. }
  542. for (i = 0; i < MAX_WINDOWS; i++) {
  543. windows[i].mapped_kind = WM_KIND_NONE;
  544. windows[i].mapped_gen = 0;
  545. windows[i].mapped_pages = 0;
  546. windows[i].mapped_src = 0;
  547. }
  548. wm_pid = current_proc()->pid;
  549. wm_attached = 1;
  550. wm_frame_active = 0;
  551. wm_boot_logged = 0;
  552. wm_last_seen = get_ticks_ms();
  553. mouse_set_auto_draw(1);
  554. wm_full_redraw = 1;
  555. /* The WM owns the display from its first frame on; stop the boot
  556. * console before a later boot line can draw over the desktop. */
  557. bootcon_set_enabled(0);
  558. out->width = s->w;
  559. out->height = s->h;
  560. out->pitch = s->pitch;
  561. out->bpp = s->bpp;
  562. out->bytes = bytes;
  563. out->fb = (void *)WM_SHADOW_VA;
  564. serial_puts(SERIAL_COM1, "wm: ring-3 WM attached\n");
  565. return 0;
  566. }
  567. int wm_server_info(unsigned int index, struct wm_window_info *out)
  568. {
  569. struct window *w;
  570. struct gfx_canvas *g;
  571. unsigned int i;
  572. if (!wm_server_is_wm() || !out || index >= MAX_WINDOWS)
  573. return -1;
  574. w = &windows[index];
  575. if (!w->used)
  576. return 0;
  577. out->used = 1;
  578. out->focused = w->focused ? 1 : 0;
  579. out->pid = w->pid;
  580. out->x = (int)w->x;
  581. out->y = (int)w->y;
  582. out->w = w->pw;
  583. out->h = w->ph;
  584. out->dirty = 0;
  585. out->dirty_seq = 0;
  586. out->dmg_x = out->dmg_y = out->dmg_w = out->dmg_h = 0;
  587. out->content_gen = w->content_gen;
  588. for (i = 0; i < sizeof(out->title) - 1 && w->title[i]; i++)
  589. out->title[i] = w->title[i];
  590. out->title[i] = '\0';
  591. if (!w->canvas_window)
  592. return 1;
  593. g = &w->canvas;
  594. out->content_w = g->w;
  595. out->content_h = g->h;
  596. out->dirty = (g->seq != g->drawn);
  597. out->dirty_seq = g->seq;
  598. if (out->dirty && w->canvas_dmg_w && w->canvas_dmg_h) {
  599. out->dmg_x = w->canvas_dmg_x;
  600. out->dmg_y = w->canvas_dmg_y;
  601. out->dmg_w = w->canvas_dmg_w;
  602. out->dmg_h = w->canvas_dmg_h;
  603. } else if (out->dirty) {
  604. out->dmg_w = g->w;
  605. out->dmg_h = g->h;
  606. }
  607. return 1;
  608. }
  609. int wm_server_map(unsigned int index, struct wm_map_info *out)
  610. {
  611. struct window *w;
  612. struct gfx_canvas *g = 0;
  613. const void *src;
  614. unsigned int pages, i, va, stride;
  615. if (!wm_server_is_wm() || !out || index >= MAX_WINDOWS || !wm_cr3)
  616. return -1;
  617. w = &windows[index];
  618. if (!w->used || !w->canvas_window)
  619. return -1;
  620. g = &w->canvas;
  621. src = (const void *)g->px;
  622. if (!src)
  623. return -1;
  624. stride = g->w * 2;
  625. if (w->mapped_kind == WM_KIND_GFX && w->mapped_gen == w->content_gen &&
  626. w->mapped_src == src) {
  627. out->va = (void *)(WM_CONTENT_VA_BASE + index * WM_CONTENT_SLOT);
  628. out->kind = WM_KIND_GFX;
  629. out->generation = w->content_gen;
  630. out->w = g->w;
  631. out->h = g->h;
  632. out->stride = stride;
  633. return 0;
  634. }
  635. wm_server_unmap_index(index);
  636. pages = (g->w * g->h * 2 + PAGE_SIZE - 1) / PAGE_SIZE;
  637. if (pages * PAGE_SIZE > WM_CONTENT_SLOT)
  638. return -1;
  639. va = WM_CONTENT_VA_BASE + index * WM_CONTENT_SLOT;
  640. for (i = 0; i < pages; i++) {
  641. if (!paging_map_page(wm_cr3, va + i * PAGE_SIZE,
  642. (unsigned int)src + i * PAGE_SIZE,
  643. PTE_USER | PTE_PRESENT)) {
  644. paging_release_user_range(wm_cr3, va,
  645. (i ? i : 1) * PAGE_SIZE, 0);
  646. return -1;
  647. }
  648. invlpg_va(va + i * PAGE_SIZE);
  649. }
  650. w->mapped_kind = WM_KIND_GFX;
  651. w->mapped_gen = w->content_gen;
  652. w->mapped_pages = pages;
  653. w->mapped_src = src;
  654. out->va = (void *)va;
  655. out->kind = WM_KIND_GFX;
  656. out->w = g->w;
  657. out->h = g->h;
  658. out->stride = stride;
  659. out->generation = w->content_gen;
  660. return 0;
  661. }
  662. int wm_server_ack(unsigned int index, unsigned int seq)
  663. {
  664. struct window *w;
  665. if (!wm_server_is_wm() || index >= MAX_WINDOWS)
  666. return -1;
  667. w = &windows[index];
  668. if (!w->used || !w->canvas_window)
  669. return -1;
  670. if (seq == w->canvas.seq) {
  671. w->canvas.drawn = seq;
  672. w->canvas_dmg_w = w->canvas_dmg_h = 0;
  673. }
  674. return 0;
  675. }
  676. int wm_server_focus(unsigned int index)
  677. {
  678. if (!wm_server_is_wm() || index >= MAX_WINDOWS ||
  679. !windows[index].used)
  680. return -1;
  681. wm_focus_index(index);
  682. return 0;
  683. }
  684. int wm_server_set_geom(unsigned int index, int x, int y)
  685. {
  686. if (!wm_server_is_wm() || index >= MAX_WINDOWS ||
  687. !windows[index].used)
  688. return -1;
  689. wm_clamp_window(&windows[index], x, y);
  690. return 0;
  691. }
  692. int wm_spawn_terminal(void)
  693. {
  694. struct vfs_file f;
  695. struct vfs_mount *m = 0;
  696. unsigned int flags;
  697. int pid;
  698. if (vfs_load_file("/ramfs/bin/term", &f, &m) != 0) {
  699. serial_puts(SERIAL_COM1, "wm: /ramfs/bin/term not found\n");
  700. return -1;
  701. }
  702. flags = irq_save_disable();
  703. pid = process_create_user_tty("term", f.data, f.size, "", "/", 0);
  704. irq_restore(flags);
  705. vfs_release_file(m, &f);
  706. if (pid <= 0) {
  707. serial_puts(SERIAL_COM1, "wm: cannot start ring-3 term\n");
  708. return -1;
  709. }
  710. process_set_weight((unsigned int)pid, 12);
  711. wm_request_redraw();
  712. return 0;
  713. }
  714. int wm_server_create_term(void)
  715. {
  716. if (!wm_server_is_wm())
  717. return -1;
  718. return wm_spawn_terminal();
  719. }
  720. int wm_server_close(unsigned int index)
  721. {
  722. if (!wm_server_is_wm() || wm_frame_active ||
  723. index >= MAX_WINDOWS || !windows[index].used)
  724. return -1;
  725. wm_close_window(index);
  726. return 0;
  727. }
  728. static void wm_queue_ptr_event(struct window *w, unsigned int type,
  729. int x, int y, unsigned int buttons)
  730. {
  731. unsigned int next = (w->ptr_head + 1) % 8;
  732. if (next == w->ptr_tail)
  733. return; /* full: drop the event, not the app */
  734. w->ptr_events[w->ptr_head].type = type;
  735. w->ptr_events[w->ptr_head].x = x;
  736. w->ptr_events[w->ptr_head].y = y;
  737. w->ptr_events[w->ptr_head].buttons = buttons;
  738. w->ptr_head = next;
  739. /* Wake a window blocked in SYS_WIN_KEY_WAIT so a click (e.g. on the
  740. * terminal's scrollbar) is handled now, not on the next poll timeout. */
  741. wait_wake_one(&w->key_wq);
  742. }
  743. /* Turn the sampled button state into content-relative press/release events for
  744. * the topmost canvas window. The kernel WM still owns focus, drag and resize;
  745. * only clicks that land in the content area are forwarded. */
  746. static void wm_route_pointer(unsigned int mx, unsigned int my,
  747. unsigned int buttons)
  748. {
  749. unsigned int press = buttons & ~wm_ptr_buttons;
  750. unsigned int release = wm_ptr_buttons & ~buttons;
  751. if (press & 1) {
  752. int idx = wm_window_at((int)mx, (int)my);
  753. if (idx >= 0) {
  754. struct window *w = &windows[idx];
  755. int cx = (int)mx - w->x - 1;
  756. int cy = (int)my - w->y - 1 - WM_TITLE_H;
  757. if (w->canvas_window && cx >= 0 && cy >= 0 &&
  758. cx < (int)w->canvas.w && cy < (int)w->canvas.h &&
  759. !((int)mx >= w->x + (int)w->pw - 16 &&
  760. (int)my >= w->y + (int)w->ph - 16)) {
  761. wm_queue_ptr_event(w, WIN_EV_POINTER_DOWN,
  762. cx, cy, buttons);
  763. wm_ptr_capture = idx;
  764. }
  765. }
  766. }
  767. if ((release & 1) && wm_ptr_capture >= 0) {
  768. struct window *w = &windows[wm_ptr_capture];
  769. if (w->used && w->canvas_window) {
  770. int cx = (int)mx - (int)w->x - 1;
  771. int cy = (int)my - (int)w->y - 1 - WM_TITLE_H;
  772. wm_queue_ptr_event(w, WIN_EV_POINTER_UP,
  773. cx, cy, buttons);
  774. }
  775. wm_ptr_capture = -1;
  776. }
  777. wm_ptr_buttons = buttons;
  778. }
  779. int wm_server_poll(struct wm_status *out)
  780. {
  781. if (!wm_server_is_wm() || !out)
  782. return -1;
  783. wm_last_seen = get_ticks_ms();
  784. out->mouse.x = mouse_get_x();
  785. out->mouse.y = mouse_get_y();
  786. out->mouse.buttons = mouse_buttons_state();
  787. wm_route_pointer(out->mouse.x, out->mouse.y, out->mouse.buttons);
  788. out->full_redraw = wm_full_redraw ? 1 : 0;
  789. out->boot_ready = wm_boot_ready ? 1 : 0;
  790. out->kexec_busy = kexec_busy ? 1 : 0;
  791. out->kexec_progress = kexec_progress;
  792. out->kexec_total = kexec_total;
  793. wm_full_redraw = 0;
  794. return 0;
  795. }
  796. void wm_server_boot_ready(void)
  797. {
  798. wm_boot_ready = 1;
  799. }
  800. int wm_server_begin(void)
  801. {
  802. if (!wm_server_is_wm() || wm_frame_active)
  803. return -1;
  804. mouse_cursor_erase();
  805. mouse_set_auto_draw(0);
  806. wm_frame_active = 1;
  807. return 0;
  808. }
  809. int wm_server_present(const struct wm_present_info *in)
  810. {
  811. unsigned int i;
  812. if (!wm_server_is_wm() || !wm_frame_active || !in)
  813. return -1;
  814. for (i = 0; i < in->count && i < 4; i++) {
  815. int x0 = in->rect[i].x;
  816. int y0 = in->rect[i].y;
  817. int x1 = x0 + (int)in->rect[i].w;
  818. int y1 = y0 + (int)in->rect[i].h;
  819. if (x0 < 0) x0 = 0;
  820. if (y0 < 0) y0 = 0;
  821. if (x1 < 0) x1 = 0;
  822. if (y1 < 0) y1 = 0;
  823. if (x1 > (int)vga_fb_width()) x1 = (int)vga_fb_width();
  824. if (y1 > (int)vga_fb_height()) y1 = (int)vga_fb_height();
  825. if (x1 > x0 && y1 > y0)
  826. vga_fb_mark_dirty_rect_xy((unsigned int)y0,
  827. (unsigned int)(y1 - y0),
  828. (unsigned int)x0, (unsigned int)x1);
  829. }
  830. mouse_redraw_cursor();
  831. mouse_set_auto_draw(1);
  832. wm_frame_active = 0;
  833. /* The copy can be long; let IRQs run. vga_present_shadow() keeps the
  834. * scheduler from switching away while it owns the damage list. */
  835. __asm__ volatile ("sti" ::: "memory");
  836. if (in->immediate)
  837. vga_fb_flush();
  838. else
  839. vga_fb_flush_budget(VGA_FLUSH_BUDGET_BYTES);
  840. if (!wm_first_frame) {
  841. wm_first_frame = 1;
  842. serial_puts(SERIAL_COM1, "wm: first frame\n");
  843. }
  844. return 0;
  845. }
  846. int wm_server_sync(void)
  847. {
  848. if (wm_frame_active)
  849. return -1;
  850. return 0;
  851. }
  852. static void wm_server_wm_died(void)
  853. {
  854. unsigned int i;
  855. if (wm_frame_active) {
  856. mouse_set_auto_draw(1);
  857. mouse_redraw_cursor();
  858. }
  859. wm_frame_active = 0;
  860. wm_attached = 0;
  861. wm_pid = 0;
  862. wm_cr3 = 0;
  863. wm_ptr_buttons = 0;
  864. wm_ptr_capture = -1;
  865. for (i = 0; i < MAX_WINDOWS; i++) {
  866. windows[i].mapped_kind = WM_KIND_NONE;
  867. windows[i].mapped_gen = 0;
  868. windows[i].mapped_pages = 0;
  869. windows[i].mapped_src = 0;
  870. }
  871. wm_full_redraw = 1;
  872. serial_puts(SERIAL_COM1, "wm: ring-3 WM stopped; restarting\n");
  873. }
  874. void wm_server_start(void)
  875. {
  876. struct vfs_file f;
  877. struct vfs_mount *m = 0;
  878. unsigned int flags;
  879. int pid;
  880. if (wm_expected_pid && process_is_alive(wm_expected_pid))
  881. return;
  882. if (wm_last_start && get_ticks_ms() - wm_last_start < 1000)
  883. return;
  884. wm_last_start = get_ticks_ms();
  885. if (vfs_load_file("/ramfs/bin/wm", &f, &m) != 0) {
  886. if (!wm_boot_logged) {
  887. wm_boot_logged = 1;
  888. serial_puts(SERIAL_COM1, "wm: /ramfs/bin/wm not found\n");
  889. bootcon_puts("wm: /ramfs/bin/wm not found\n");
  890. }
  891. return;
  892. }
  893. flags = irq_save_disable();
  894. pid = process_create_user("wm", f.data, f.size, "", "/");
  895. if (pid > 0)
  896. wm_expected_pid = (unsigned int)pid;
  897. irq_restore(flags);
  898. vfs_release_file(m, &f);
  899. if (pid <= 0) {
  900. if (!wm_boot_logged) {
  901. wm_boot_logged = 1;
  902. serial_puts(SERIAL_COM1, "wm: cannot load /ramfs/bin/wm\n");
  903. bootcon_puts("wm: cannot load /ramfs/bin/wm\n");
  904. }
  905. return;
  906. }
  907. process_set_weight((unsigned int)pid, 16);
  908. wm_boot_logged = 0;
  909. serial_puts(SERIAL_COM1, "wm: ring-3 WM started\n");
  910. }
  911. void wm_server_supervise(void)
  912. {
  913. unsigned int i, now = get_ticks_ms();
  914. /* Watchdog: a WM that never attaches, or stops polling for several
  915. * seconds, is treated like a crash so a wedged UI can recover. */
  916. if (wm_expected_pid && process_is_alive(wm_expected_pid) &&
  917. !process_is_sleeping(wm_expected_pid)) {
  918. /* A sleeping WM is usually blocked on the BKL or its normal
  919. * 10 ms poll sleep; do not treat a long disk scan as a hang. */
  920. if ((wm_attached && now - wm_last_seen > 15000) ||
  921. (!wm_attached && now - wm_last_start > 10000)) {
  922. serial_puts(SERIAL_COM1, "wm: watchdog, killing WM\n");
  923. process_kill(wm_expected_pid);
  924. }
  925. }
  926. if (wm_expected_pid && !process_is_alive(wm_expected_pid)) {
  927. wm_server_wm_died();
  928. wm_expected_pid = 0;
  929. }
  930. /* Owner processes that exited close their windows. Only at a safe
  931. * point: the WM may still be between INFO/MAP and PRESENT. */
  932. if (wm_server_can_reap()) {
  933. for (i = 0; i < MAX_WINDOWS; i++) {
  934. struct window *w = &windows[i];
  935. if (!w->used || !w->pid || process_is_alive(w->pid))
  936. continue;
  937. if (w->canvas_window)
  938. w->owner_cr3 = 0; /* cr3 is gone/reaped */
  939. wm_close_window(i);
  940. }
  941. }
  942. if (wm_expected_pid && process_is_alive(wm_expected_pid))
  943. return;
  944. wm_server_start();
  945. }
  946. void wm_server_init(void)
  947. {
  948. unsigned int i;
  949. for (i = 0; i < MAX_WINDOWS; i++) {
  950. windows[i].used = 0;
  951. windows[i].mapped_kind = WM_KIND_NONE;
  952. windows[i].mapped_gen = 0;
  953. windows[i].mapped_pages = 0;
  954. windows[i].mapped_src = 0;
  955. }
  956. wm_full_redraw = 1;
  957. wm_boot_ready = 0;
  958. wm_boot_logged = 0;
  959. wm_ptr_buttons = 0;
  960. wm_ptr_capture = -1;
  961. wm_expected_pid = 0;
  962. wm_pid = 0;
  963. wm_cr3 = 0;
  964. wm_attached = 0;
  965. wm_frame_active = 0;
  966. wm_first_frame = 0;
  967. /* The ring-3 WM spawns the first terminal once wm_server_boot_ready()
  968. * says the storage scan is done. */
  969. }
  970. static int wm_point_in_rect(int px, int py,
  971. int rx, int ry, unsigned int rw, unsigned int rh)
  972. {
  973. return px >= rx && px < rx + (int)rw &&
  974. py >= ry && py < ry + (int)rh;
  975. }
  976. static void wm_focus_index(unsigned int idx)
  977. {
  978. unsigned int i;
  979. if (windows[idx].used && windows[idx].focused)
  980. return;
  981. for (i = 0; i < MAX_WINDOWS; i++) {
  982. int now = windows[i].used && (i == idx);
  983. if (!windows[i].used || windows[i].focused == now)
  984. continue;
  985. windows[i].focused = now;
  986. }
  987. wm_request_redraw();
  988. }
  989. static void wm_focus_top(void)
  990. {
  991. unsigned int i;
  992. /* With no explicit z-order the highest used slot is painted last, so
  993. * it is the topmost window left after a close. */
  994. for (i = MAX_WINDOWS; i-- > 0; )
  995. if (windows[i].used) {
  996. wm_focus_index(i);
  997. return;
  998. }
  999. }
  1000. static void wm_close_window(unsigned int idx)
  1001. {
  1002. struct window *w = &windows[idx];
  1003. if (wm_ptr_capture == (int)idx)
  1004. wm_ptr_capture = -1;
  1005. wait_wake_all(&w->key_wq);
  1006. if (w->canvas_window) {
  1007. if (w->pid)
  1008. process_kill(w->pid);
  1009. wm_server_unmap_index(idx);
  1010. wm_free_canvas_window(idx);
  1011. } else if (w->pid) {
  1012. process_kill(w->pid);
  1013. }
  1014. wm_server_unmap_index(idx);
  1015. w->used = 0;
  1016. w->pid = 0;
  1017. w->focused = 0;
  1018. w->content_gen++;
  1019. w->mapped_kind = WM_KIND_NONE;
  1020. w->mapped_gen = 0;
  1021. w->mapped_pages = 0;
  1022. w->mapped_src = 0;
  1023. wm_focus_top();
  1024. wm_request_redraw();
  1025. }
  1026. /* Topmost window containing (px,py), or -1. */
  1027. static int wm_window_at(int px, int py)
  1028. {
  1029. unsigned int i;
  1030. for (i = 0; i < MAX_WINDOWS; i++)
  1031. if (windows[i].used && windows[i].focused &&
  1032. wm_point_in_rect(px, py, windows[i].x, windows[i].y,
  1033. windows[i].pw, windows[i].ph))
  1034. return (int)i;
  1035. /* Inactive windows are painted in slot order, so the highest slot is
  1036. * the topmost one under the cursor. */
  1037. for (i = MAX_WINDOWS; i-- > 0; )
  1038. if (windows[i].used && !windows[i].focused &&
  1039. wm_point_in_rect(px, py, windows[i].x, windows[i].y,
  1040. windows[i].pw, windows[i].ph))
  1041. return (int)i;
  1042. return -1;
  1043. }
  1044. static void wm_clamp_window(struct window *w, int nx, int ny)
  1045. {
  1046. int fbw = (int)vga_fb_width();
  1047. int fbh = (int)vga_fb_height();
  1048. /* Allow a window to hang off the left, right and bottom edges, but
  1049. * keep a strip of the title bar reachable and never let it overlap the
  1050. * system bar at the top. */
  1051. int minx = WM_DRAG_VISIBLE - (int)w->pw;
  1052. int maxx = fbw - WM_DRAG_VISIBLE;
  1053. int miny = WM_BAR_H;
  1054. int maxy = fbh - WM_TITLE_H;
  1055. if (minx > maxx)
  1056. minx = maxx = 0;
  1057. if (miny > maxy)
  1058. miny = maxy = WM_BAR_H;
  1059. if (nx < minx)
  1060. nx = minx;
  1061. else if (nx > maxx)
  1062. nx = maxx;
  1063. if (ny < miny)
  1064. ny = miny;
  1065. else if (ny > maxy)
  1066. ny = maxy;
  1067. w->x = nx;
  1068. w->y = ny;
  1069. }
  1070. /* Fill the intersection of rect (rx,ry,rw,rh) with clip rect (cx,cy,cw,ch). */
  1071. /* Repaint the desktop rectangle (x, y, w, h): background, then every
  1072. intersecting window back-to-front (focused last), then mark it dirty. The
  1073. caller handles the mouse cursor. The rect must lie below the system bar
  1074. (windows are clamped to y >= WM_BAR_H, so the bar is never overlapped and
  1075. needs no clip variant). */
  1076. /* Move a window in the shadow buffer: copy its rect, redraw the exposed
  1077. sliver, keep the cursor on top, and flush the swept band immediately so a
  1078. drag step is always one consistent frame (a budgeted flush would copy only
  1079. the top rows of the band per iteration and the window would appear to
  1080. stretch while the mouse keeps moving). */
  1081. void wm_pump_keyboard(void)
  1082. {
  1083. struct window *fw = wm_focused_window();
  1084. static unsigned int last_hw_poll;
  1085. unsigned int now = get_ticks_ms();
  1086. int n;
  1087. if (io_keyboard_raw())
  1088. return; /* an inline command is polling for keys itself */
  1089. if (!fw)
  1090. return;
  1091. for (n = 0; n < 8; n++) {
  1092. int k = io_poll_key();
  1093. if (!k && (now - last_hw_poll) >= (io_keyboard_irq_masked() ? 5 : 50)) {
  1094. /* Fallback paths: IRQ1 was storm-masked, or no IRQ is
  1095. * delivering; sample the controller directly (faster
  1096. * when masked, so fast typing isn't dropped). */
  1097. k = io_poll_key_with_hw();
  1098. last_hw_poll = now;
  1099. }
  1100. if (!k)
  1101. break;
  1102. if (fw->canvas_window) {
  1103. unsigned int next = (fw->key_head + 1) % 16;
  1104. if (next != fw->key_tail) {
  1105. fw->keys[fw->key_head] = k;
  1106. fw->key_head = next;
  1107. }
  1108. wait_wake_one(&fw->key_wq);
  1109. }
  1110. }
  1111. }
  1112. void wm_handle_kexec(void)
  1113. {
  1114. if (kexec_busy)
  1115. return;
  1116. /* A command pack for /ramfs (checked before kexec: both start with
  1117. * 'K', and the kexec detector drops anything that is not KXE2). */
  1118. if (payload_pending()) {
  1119. kexec_busy = 1;
  1120. if (process_create("payload", program_payload_main) < 0)
  1121. kexec_busy = 0;
  1122. return;
  1123. }
  1124. if (kexec_pending()) {
  1125. kexec_busy = 1;
  1126. if (process_create("kexec", program_kexec_main) < 0)
  1127. kexec_busy = 0;
  1128. return;
  1129. }
  1130. /* Same over UDP: the host's `make net-dev` is picked up from here. */
  1131. if (netkexec_pending()) {
  1132. kexec_busy = 1;
  1133. if (process_create("netkexec", program_netkexec_main) < 0)
  1134. kexec_busy = 0;
  1135. }
  1136. }