wm.c 30 KB

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