wm.c 39 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565
  1. /* Window manager: fixed-size draggable terminal windows + a system bar.
  2. * wm_run() is a normal kernel process; the idle loop keeps input routing,
  3. * cursor blinking, kexec detection and gfx session cleanup running even when
  4. * the WM process is not scheduled. */
  5. #include "wm.h"
  6. #include "blit.h"
  7. #include "fbtext.h"
  8. #include "idle.h"
  9. #include "io.h"
  10. #include "kexec.h"
  11. #include "mm.h"
  12. #include "mouse.h"
  13. #include "netkexec.h"
  14. #include "netlog.h"
  15. #include "paging.h"
  16. #include "payload.h"
  17. #include "process.h"
  18. #include "rtc.h"
  19. #include "serial.h"
  20. #include "sys_gfx.h"
  21. #include "timer.h"
  22. #include "version.h"
  23. #include "vga.h"
  24. #include "vfs.h"
  25. static struct window windows[MAX_WINDOWS];
  26. /* The terminal state is large and only needed for live windows. Allocate it
  27. * from the frame allocator (page-aligned) instead of carrying it in BSS: the
  28. * cell grid is exactly one page, so a ring-3 WM can map just that page. */
  29. #define TERM_STRIDE (2 * PAGE_SIZE)
  30. static struct term *terms[MAX_WINDOWS];
  31. static unsigned int term_counter;
  32. static int wm_full_redraw;
  33. _Static_assert(sizeof(struct term) <= TERM_STRIDE,
  34. "struct term no longer fits two pages");
  35. _Static_assert(__builtin_offsetof(struct term, screen) == 0,
  36. "term->screen must be the first field");
  37. _Static_assert(__builtin_offsetof(struct text_screen, cells) == 0,
  38. "text_screen.cells must be the first field");
  39. _Static_assert(sizeof(((struct text_screen *)0)->cells) == PAGE_SIZE,
  40. "the cell grid must be exactly one page");
  41. static int wm_terms_init(void)
  42. {
  43. unsigned int base = mm_alloc_pages(MAX_WINDOWS * (TERM_STRIDE / PAGE_SIZE));
  44. unsigned char *p;
  45. unsigned int i;
  46. if (!base)
  47. return -1;
  48. p = (unsigned char *)base;
  49. for (i = 0; i < MAX_WINDOWS * TERM_STRIDE; i++)
  50. p[i] = 0;
  51. for (i = 0; i < MAX_WINDOWS; i++)
  52. terms[i] = (struct term *)(base + i * TERM_STRIDE);
  53. return 0;
  54. }
  55. /* Mouse drag state. */
  56. static int drag_active;
  57. static int drag_window; /* index into windows[] */
  58. static int drag_dx, drag_dy; /* mouse offset from window origin */
  59. static unsigned int prev_buttons;
  60. /* Ring-3 WM lifecycle. The kernel only admits the process it spawned; a
  61. * stale pid cannot keep drawing after a restart. */
  62. static unsigned int wm_expected_pid;
  63. static unsigned int wm_pid;
  64. static unsigned int wm_cr3;
  65. static int wm_attached;
  66. static int wm_frame_active;
  67. static unsigned int wm_last_start;
  68. static unsigned int wm_last_seen;
  69. static inline unsigned int irq_save_disable(void)
  70. {
  71. unsigned int flags;
  72. __asm__ volatile ("pushfl; popl %0; cli" : "=r"(flags));
  73. return flags;
  74. }
  75. static inline void irq_restore(unsigned int flags)
  76. {
  77. __asm__ volatile ("pushl %0; popfl" :: "r"(flags));
  78. }
  79. static inline void invlpg_va(unsigned int va)
  80. {
  81. __asm__ volatile ("invlpg (%0)" : : "r"(va) : "memory");
  82. }
  83. static void wm_focus_index(unsigned int idx);
  84. static void wm_focus_top(void);
  85. static void wm_close_window(unsigned int idx);
  86. static void wm_clamp_window(struct window *w, int nx, int ny);
  87. static void wm_server_unmap_index(unsigned int idx);
  88. void wm_request_redraw(void)
  89. {
  90. wm_full_redraw = 1;
  91. }
  92. struct window *wm_focused_window(void)
  93. {
  94. unsigned int i;
  95. for (i = 0; i < MAX_WINDOWS; i++)
  96. if (windows[i].used && windows[i].focused)
  97. return &windows[i];
  98. return (void *)0;
  99. }
  100. int wm_is_focused(const struct window *w)
  101. {
  102. return w->focused;
  103. }
  104. /* The terminal whose screen is `screen`, or NULL: a spawned ring-3 command
  105. * inherits its terminal's screen pointer, so this maps it back to the window
  106. * (used by the sys_gfx window-canvas service). */
  107. struct term *wm_term_for_screen(struct text_screen *screen)
  108. {
  109. unsigned int i;
  110. for (i = 0; i < MAX_WINDOWS; i++)
  111. if (windows[i].used && windows[i].term &&
  112. &windows[i].term->screen == screen)
  113. return windows[i].term;
  114. return 0;
  115. }
  116. /* Pixel size of a window's content area (the size of its gfx canvas). */
  117. int wm_content_size(struct term *t, unsigned int *w, unsigned int *h)
  118. {
  119. unsigned int i;
  120. for (i = 0; i < MAX_WINDOWS; i++)
  121. if (windows[i].used && windows[i].term == t) {
  122. *w = windows[i].pw - 2;
  123. *h = SCREEN_ROWS * 10;
  124. return 0;
  125. }
  126. return -1;
  127. }
  128. /* ---- Ring-3 WM ABI ---------------------------------------------------- */
  129. int wm_server_is_wm(void)
  130. {
  131. return wm_attached && current_proc()->pid == wm_pid;
  132. }
  133. int wm_server_frame_active(void)
  134. {
  135. return wm_frame_active;
  136. }
  137. /* Safe point for freeing another window's canvas: the WM is not between
  138. * SYS_WM_INFO/MAP and PRESENT. A ring-3 WM sleeps at the end of every loop;
  139. * the kernel fallback has no cached mappings. */
  140. int wm_server_can_reap(void)
  141. {
  142. if (wm_frame_active)
  143. return 0;
  144. return !wm_attached || process_is_sleeping(wm_pid);
  145. }
  146. static void wm_server_unmap_index(unsigned int idx)
  147. {
  148. struct window *w = &windows[idx];
  149. unsigned int va, i;
  150. if (!wm_cr3 || idx >= MAX_WINDOWS || !w->mapped_pages)
  151. return;
  152. va = WM_CONTENT_VA_BASE + idx * WM_CONTENT_SLOT;
  153. paging_release_user_range(wm_cr3, va, WM_CONTENT_SLOT, 0);
  154. for (i = 0; i < w->mapped_pages; i++)
  155. invlpg_va(va + i * PAGE_SIZE);
  156. w->mapped_kind = WM_KIND_NONE;
  157. w->mapped_gen = 0;
  158. w->mapped_pages = 0;
  159. w->mapped_src = 0;
  160. }
  161. void wm_server_unmap_screen(struct text_screen *screen)
  162. {
  163. unsigned int i;
  164. for (i = 0; i < MAX_WINDOWS; i++)
  165. if (windows[i].used && windows[i].term &&
  166. &windows[i].term->screen == screen)
  167. wm_server_unmap_index(i);
  168. }
  169. /* A dead gfx session can coexist with a newer session on the same screen (the
  170. * old canvas is freed later). Only drop the WM mapping when it still points
  171. * at *this* canvas, so collecting the old session cannot unmap the new one. */
  172. void wm_server_unmap_canvas(struct text_screen *screen, const void *canvas)
  173. {
  174. unsigned int i;
  175. for (i = 0; i < MAX_WINDOWS; i++)
  176. if (windows[i].used && windows[i].term &&
  177. &windows[i].term->screen == screen &&
  178. windows[i].mapped_kind == WM_KIND_GFX &&
  179. windows[i].mapped_src == canvas)
  180. wm_server_unmap_index(i);
  181. }
  182. static int wm_window_for_pid(unsigned int pid)
  183. {
  184. unsigned int i;
  185. for (i = 0; i < MAX_WINDOWS; i++)
  186. if (windows[i].used && windows[i].pid == pid)
  187. return (int)i;
  188. return -1;
  189. }
  190. static void wm_unmap_back(struct window *w, unsigned int pages)
  191. {
  192. unsigned int i;
  193. if (w->owner_cr3 && pages) {
  194. paging_release_user_range(w->owner_cr3, USER_GFX_BASE,
  195. pages * PAGE_SIZE, 0);
  196. for (i = 0; i < pages; i++)
  197. invlpg_va(USER_GFX_BASE + i * PAGE_SIZE);
  198. }
  199. w->owner_cr3 = 0;
  200. }
  201. static void wm_free_canvas_window(unsigned int idx)
  202. {
  203. struct window *w = &windows[idx];
  204. unsigned int i;
  205. if (!w->canvas_window)
  206. return;
  207. wm_unmap_back(w, w->back_pages);
  208. if (w->back) {
  209. for (i = 0; i < w->back_pages; i++)
  210. mm_free_page((unsigned int)w->back + i * PAGE_SIZE);
  211. w->back = 0;
  212. }
  213. w->back_pages = 0;
  214. gfx_free(&w->canvas);
  215. w->canvas_window = 0;
  216. }
  217. int wm_server_win_create(const struct win_create *in, struct win_info *out)
  218. {
  219. struct window *w;
  220. struct gfx_canvas *c;
  221. unsigned short *back;
  222. unsigned int i, j, pages, cw, ch, base;
  223. unsigned int flags;
  224. if (!in || !out)
  225. return -1;
  226. if (current_proc()->pid == 0 ||
  227. wm_window_for_pid(current_proc()->pid) >= 0)
  228. return -1;
  229. cw = in->w;
  230. ch = in->h;
  231. if (cw == 0 || ch == 0 || cw > 1024 || ch > 1024)
  232. return -1;
  233. if (cw + 2 > vga_fb_width() || ch + WM_TITLE_H + 2 > vga_fb_height())
  234. return -1;
  235. for (i = 0; i < MAX_WINDOWS; i++)
  236. if (!windows[i].used)
  237. break;
  238. if (i == MAX_WINDOWS)
  239. return -1;
  240. w = &windows[i];
  241. c = &w->canvas;
  242. if (gfx_alloc(c, cw, ch) != 0)
  243. return -1;
  244. pages = (cw * ch * 2 + PAGE_SIZE - 1) / PAGE_SIZE;
  245. back = (unsigned short *)mm_alloc_pages(pages);
  246. if (!back) {
  247. gfx_free(c);
  248. return -1;
  249. }
  250. for (j = 0; j < cw * ch; j++)
  251. back[j] = 0;
  252. flags = irq_save_disable();
  253. base = current_proc()->cr3;
  254. for (j = 0; j < pages; j++) {
  255. if (!paging_map_page(base, USER_GFX_BASE + j * PAGE_SIZE,
  256. (unsigned int)back + j * PAGE_SIZE,
  257. PTE_USER | PTE_WRITABLE | PTE_PRESENT)) {
  258. irq_restore(flags);
  259. paging_release_user_range(base, USER_GFX_BASE,
  260. (j ? j : 1) * PAGE_SIZE, 0);
  261. for (i = 0; i < pages; i++)
  262. mm_free_page((unsigned int)back + i * PAGE_SIZE);
  263. gfx_free(c);
  264. return -1;
  265. }
  266. invlpg_va(USER_GFX_BASE + j * PAGE_SIZE);
  267. }
  268. irq_restore(flags);
  269. w->used = 1;
  270. w->canvas_window = 1;
  271. w->term = 0;
  272. w->pid = current_proc()->pid;
  273. w->owner_cr3 = base;
  274. w->back = back;
  275. w->back_pages = pages;
  276. w->canvas.seq = 1;
  277. w->canvas.drawn = 0;
  278. w->pw = cw + 2;
  279. w->ph = ch + WM_TITLE_H + 2;
  280. w->x = 24 + i * 32;
  281. w->y = WM_BAR_H + 12 + i * 28;
  282. if (w->x + w->pw > vga_fb_width())
  283. w->x = (vga_fb_width() > w->pw) ? vga_fb_width() - w->pw : 0;
  284. if (w->y + w->ph > vga_fb_height())
  285. w->y = WM_BAR_H + 4;
  286. w->focused = 0;
  287. w->content_gen = 1;
  288. w->mapped_kind = WM_KIND_NONE;
  289. w->mapped_gen = 0;
  290. w->mapped_pages = 0;
  291. w->mapped_src = 0;
  292. w->key_head = w->key_tail = 0;
  293. wait_queue_init(&w->key_wq);
  294. for (j = 0; j < sizeof(w->title) - 1 && in->title[j]; j++)
  295. w->title[j] = in->title[j];
  296. w->title[j] = '\0';
  297. for (j = 0; j < MAX_WINDOWS; j++)
  298. if (windows[j].used)
  299. windows[j].focused = (j == i);
  300. wm_request_redraw();
  301. out->fb = (void *)USER_GFX_BASE;
  302. out->width = cw;
  303. out->height = ch;
  304. out->id = i;
  305. return 0;
  306. }
  307. int wm_server_win_present(void)
  308. {
  309. int idx = wm_window_for_pid(current_proc()->pid);
  310. struct window *w;
  311. const unsigned short *src;
  312. unsigned int n, i;
  313. if (idx < 0)
  314. return -1;
  315. w = &windows[idx];
  316. if (!w->canvas_window || !w->back || !w->canvas.px)
  317. return -1;
  318. src = (const unsigned short *)USER_GFX_BASE;
  319. n = w->canvas.w * w->canvas.h;
  320. for (i = 0; i + 1 < n; i += 2)
  321. ((unsigned int *)w->canvas.px)[i / 2] = ((const unsigned int *)src)[i / 2];
  322. if (n & 1)
  323. w->canvas.px[n - 1] = src[n - 1];
  324. w->canvas.seq++;
  325. return 0;
  326. }
  327. int wm_server_win_close(void)
  328. {
  329. int idx = wm_window_for_pid(current_proc()->pid);
  330. if (idx < 0 || !wm_server_can_reap())
  331. return -1;
  332. wm_server_unmap_index((unsigned int)idx);
  333. wm_free_canvas_window((unsigned int)idx);
  334. windows[idx].used = 0;
  335. windows[idx].pid = 0;
  336. windows[idx].focused = 0;
  337. windows[idx].content_gen++;
  338. wm_focus_top();
  339. wm_request_redraw();
  340. return 0;
  341. }
  342. int wm_server_key_poll(void)
  343. {
  344. int idx = wm_window_for_pid(current_proc()->pid);
  345. struct window *w;
  346. int k;
  347. if (idx < 0)
  348. return 0;
  349. w = &windows[idx];
  350. if (w->key_tail == w->key_head)
  351. return 0;
  352. k = w->keys[w->key_tail];
  353. w->key_tail = (w->key_tail + 1) % 16;
  354. return k;
  355. }
  356. /* Block until a key arrives for the caller's window, or `timeout_ms` passes
  357. * (0 = wait forever). Returns the key, 0 on timeout/no key, -1 if the caller
  358. * has no window. */
  359. int wm_server_key_wait(unsigned int timeout_ms)
  360. {
  361. int idx = wm_window_for_pid(current_proc()->pid);
  362. struct window *w;
  363. int k;
  364. if (idx < 0)
  365. return -1;
  366. w = &windows[idx];
  367. k = wm_server_key_poll();
  368. if (k)
  369. return k;
  370. if (timeout_ms)
  371. sched_block_timeout(&w->key_wq, timeout_ms);
  372. else
  373. sched_block_on(&w->key_wq);
  374. return wm_server_key_poll();
  375. }
  376. void wm_content_changed(struct text_screen *screen)
  377. {
  378. unsigned int i;
  379. for (i = 0; i < MAX_WINDOWS; i++)
  380. if (windows[i].used && windows[i].term &&
  381. &windows[i].term->screen == screen)
  382. windows[i].content_gen++;
  383. wm_request_redraw();
  384. }
  385. int wm_server_attach(struct wm_screen_info *out)
  386. {
  387. struct surface *s;
  388. unsigned int pages, i, bytes;
  389. if (!out || !wm_expected_pid ||
  390. current_proc()->pid != wm_expected_pid || wm_attached) {
  391. serial_puts(SERIAL_COM1, "wm: attach rejected (expected ");
  392. serial_puthex(SERIAL_COM1, wm_expected_pid);
  393. serial_puts(SERIAL_COM1, " current ");
  394. serial_puthex(SERIAL_COM1, current_proc()->pid);
  395. serial_puts(SERIAL_COM1, ")\n");
  396. return -1;
  397. }
  398. if (!vga_shadow_is_active()) {
  399. serial_puts(SERIAL_COM1, "wm: attach: no shadow buffer\n");
  400. return -1;
  401. }
  402. s = vga_screen_surface();
  403. if (!s || !s->px)
  404. return -1;
  405. bytes = s->pitch * s->h;
  406. pages = (bytes + PAGE_SIZE - 1) / PAGE_SIZE;
  407. wm_cr3 = current_proc()->cr3;
  408. for (i = 0; i < pages; i++) {
  409. unsigned int va = WM_SHADOW_VA + i * PAGE_SIZE;
  410. if (!paging_map_page(wm_cr3, va,
  411. (unsigned int)s->px + i * PAGE_SIZE,
  412. PTE_USER | PTE_WRITABLE | PTE_PRESENT)) {
  413. paging_release_user_range(wm_cr3, WM_SHADOW_VA,
  414. i * PAGE_SIZE, 0);
  415. wm_cr3 = 0;
  416. return -1;
  417. }
  418. invlpg_va(va);
  419. }
  420. for (i = 0; i < MAX_WINDOWS; i++) {
  421. windows[i].mapped_kind = WM_KIND_NONE;
  422. windows[i].mapped_gen = 0;
  423. windows[i].mapped_pages = 0;
  424. windows[i].mapped_src = 0;
  425. }
  426. wm_pid = current_proc()->pid;
  427. wm_attached = 1;
  428. wm_frame_active = 0;
  429. wm_last_seen = get_ticks_ms();
  430. mouse_set_auto_draw(1);
  431. wm_full_redraw = 1;
  432. out->width = s->w;
  433. out->height = s->h;
  434. out->pitch = s->pitch;
  435. out->bpp = s->bpp;
  436. out->bytes = bytes;
  437. out->fb = (void *)WM_SHADOW_VA;
  438. serial_puts(SERIAL_COM1, "wm: ring-3 WM attached\n");
  439. return 0;
  440. }
  441. int wm_server_info(unsigned int index, struct wm_window_info *out)
  442. {
  443. struct window *w;
  444. struct gfx_canvas *g = 0;
  445. struct text_screen *s = 0;
  446. unsigned int i;
  447. if (!wm_server_is_wm() || !out || index >= MAX_WINDOWS)
  448. return -1;
  449. w = &windows[index];
  450. if (!w->used)
  451. return 0;
  452. out->used = 1;
  453. out->kind = WM_KIND_NONE;
  454. out->focused = w->focused ? 1 : 0;
  455. out->pid = w->pid;
  456. out->x = (int)w->x;
  457. out->y = (int)w->y;
  458. out->w = w->pw;
  459. out->h = w->ph;
  460. out->cols = 0;
  461. out->rows = 0;
  462. out->cursor = 0;
  463. out->cursor_visible = 0;
  464. out->dirty = 0;
  465. out->dirty_seq = 0;
  466. out->dmg_col0 = out->dmg_row0 = 0;
  467. out->dmg_cols = out->dmg_rows = 0;
  468. out->content_gen = w->content_gen;
  469. for (i = 0; i < sizeof(out->title) - 1 && w->title[i]; i++)
  470. out->title[i] = w->title[i];
  471. out->title[i] = '\0';
  472. if (w->canvas_window) {
  473. g = &w->canvas;
  474. } else if (w->term) {
  475. s = &w->term->screen;
  476. g = sys_gfx_canvas_for(s);
  477. } else {
  478. return 1;
  479. }
  480. if (g) {
  481. out->kind = WM_KIND_GFX;
  482. out->content_w = g->w;
  483. out->content_h = g->h;
  484. out->dirty = (g->seq != g->drawn);
  485. out->dirty_seq = g->seq;
  486. } else if (s) {
  487. unsigned int c0, r0, nc, nr;
  488. out->kind = WM_KIND_TEXT;
  489. out->content_w = w->pw - 2;
  490. out->content_h = SCREEN_ROWS * 10;
  491. out->cols = s->cols;
  492. out->rows = s->rows;
  493. out->cursor = s->cursor;
  494. out->cursor_visible = s->cursor_visible;
  495. out->dirty_seq = s->damage_seq;
  496. if (screen_damage_block(s, &c0, &r0, &nc, &nr)) {
  497. out->dirty = 1;
  498. out->dmg_col0 = c0;
  499. out->dmg_row0 = r0;
  500. out->dmg_cols = nc;
  501. out->dmg_rows = nr;
  502. }
  503. }
  504. return 1;
  505. }
  506. int wm_server_map(unsigned int index, struct wm_map_info *out)
  507. {
  508. struct window *w;
  509. struct gfx_canvas *g = 0;
  510. struct text_screen *s = 0;
  511. const void *src;
  512. unsigned int kind, pages, i, va;
  513. unsigned int wpx, hpx, stride;
  514. if (!wm_server_is_wm() || !out || index >= MAX_WINDOWS || !wm_cr3)
  515. return -1;
  516. w = &windows[index];
  517. if (!w->used)
  518. return -1;
  519. if (w->canvas_window) {
  520. g = &w->canvas;
  521. } else if (w->term) {
  522. s = &w->term->screen;
  523. g = sys_gfx_canvas_for(s);
  524. } else {
  525. return -1;
  526. }
  527. kind = g ? WM_KIND_GFX : WM_KIND_TEXT;
  528. src = g ? (const void *)g->px : (const void *)w->term;
  529. if (w->mapped_kind == kind && w->mapped_gen == w->content_gen &&
  530. w->mapped_src == src) {
  531. out->va = (void *)(WM_CONTENT_VA_BASE + index * WM_CONTENT_SLOT);
  532. out->kind = kind;
  533. out->generation = w->content_gen;
  534. if (g) {
  535. out->w = g->w;
  536. out->h = g->h;
  537. out->stride = g->w * 2;
  538. } else {
  539. out->w = s->cols;
  540. out->h = s->rows;
  541. out->stride = s->cols * 2;
  542. }
  543. return 0;
  544. }
  545. wm_server_unmap_index(index);
  546. if (g) {
  547. wpx = g->w;
  548. hpx = g->h;
  549. stride = g->w * 2;
  550. pages = (wpx * hpx * 2 + PAGE_SIZE - 1) / PAGE_SIZE;
  551. if (pages * PAGE_SIZE > WM_CONTENT_SLOT)
  552. return -1;
  553. } else {
  554. wpx = s->cols;
  555. hpx = s->rows;
  556. stride = s->cols * 2;
  557. pages = 1;
  558. }
  559. va = WM_CONTENT_VA_BASE + index * WM_CONTENT_SLOT;
  560. for (i = 0; i < pages; i++) {
  561. if (!paging_map_page(wm_cr3, va + i * PAGE_SIZE,
  562. (unsigned int)src + i * PAGE_SIZE,
  563. PTE_USER | PTE_PRESENT)) {
  564. paging_release_user_range(wm_cr3, va,
  565. (i ? i : 1) * PAGE_SIZE, 0);
  566. return -1;
  567. }
  568. invlpg_va(va + i * PAGE_SIZE);
  569. }
  570. w->mapped_kind = kind;
  571. w->mapped_gen = w->content_gen;
  572. w->mapped_pages = pages;
  573. w->mapped_src = src;
  574. out->va = (void *)va;
  575. out->kind = kind;
  576. out->w = wpx;
  577. out->h = hpx;
  578. out->stride = stride;
  579. out->generation = w->content_gen;
  580. return 0;
  581. }
  582. int wm_server_ack(unsigned int index, unsigned int seq)
  583. {
  584. struct window *w;
  585. struct gfx_canvas *g;
  586. if (!wm_server_is_wm() || index >= MAX_WINDOWS)
  587. return -1;
  588. w = &windows[index];
  589. if (!w->used)
  590. return -1;
  591. if (w->canvas_window) {
  592. if (seq == w->canvas.seq)
  593. w->canvas.drawn = seq;
  594. return 0;
  595. }
  596. if (!w->term)
  597. return -1;
  598. g = sys_gfx_canvas_for(&w->term->screen);
  599. if (g) {
  600. if (seq == g->seq)
  601. g->drawn = seq;
  602. } else if (seq == w->term->screen.damage_seq) {
  603. screen_clear_damage(&w->term->screen);
  604. }
  605. return 0;
  606. }
  607. int wm_server_focus(unsigned int index)
  608. {
  609. if (!wm_server_is_wm() || index >= MAX_WINDOWS ||
  610. !windows[index].used)
  611. return -1;
  612. wm_focus_index(index);
  613. return 0;
  614. }
  615. int wm_server_set_geom(unsigned int index, int x, int y)
  616. {
  617. if (!wm_server_is_wm() || index >= MAX_WINDOWS ||
  618. !windows[index].used)
  619. return -1;
  620. wm_clamp_window(&windows[index], x, y);
  621. return 0;
  622. }
  623. int wm_server_create_term(void)
  624. {
  625. int idx;
  626. if (!wm_server_is_wm())
  627. return -1;
  628. idx = wm_spawn_terminal();
  629. return idx;
  630. }
  631. int wm_server_close(unsigned int index)
  632. {
  633. if (!wm_server_is_wm() || wm_frame_active ||
  634. index >= MAX_WINDOWS || !windows[index].used)
  635. return -1;
  636. wm_close_window(index);
  637. return 0;
  638. }
  639. int wm_server_poll(struct wm_status *out)
  640. {
  641. if (!wm_server_is_wm() || !out)
  642. return -1;
  643. wm_last_seen = get_ticks_ms();
  644. out->mouse.x = mouse_get_x();
  645. out->mouse.y = mouse_get_y();
  646. out->mouse.buttons = mouse_buttons_state();
  647. out->full_redraw = wm_full_redraw ? 1 : 0;
  648. out->kexec_busy = kexec_busy ? 1 : 0;
  649. out->kexec_progress = kexec_progress;
  650. out->kexec_total = kexec_total;
  651. wm_full_redraw = 0;
  652. return 0;
  653. }
  654. int wm_server_begin(void)
  655. {
  656. if (!wm_server_is_wm() || wm_frame_active)
  657. return -1;
  658. mouse_cursor_erase();
  659. mouse_set_auto_draw(0);
  660. wm_frame_active = 1;
  661. return 0;
  662. }
  663. int wm_server_present(const struct wm_present_info *in)
  664. {
  665. unsigned int i;
  666. if (!wm_server_is_wm() || !wm_frame_active || !in)
  667. return -1;
  668. for (i = 0; i < in->count && i < 4; i++) {
  669. int x0 = in->rect[i].x;
  670. int y0 = in->rect[i].y;
  671. int x1 = x0 + (int)in->rect[i].w;
  672. int y1 = y0 + (int)in->rect[i].h;
  673. if (x0 < 0) x0 = 0;
  674. if (y0 < 0) y0 = 0;
  675. if (x1 < 0) x1 = 0;
  676. if (y1 < 0) y1 = 0;
  677. if (x1 > (int)vga_fb_width()) x1 = (int)vga_fb_width();
  678. if (y1 > (int)vga_fb_height()) y1 = (int)vga_fb_height();
  679. if (x1 > x0 && y1 > y0)
  680. vga_fb_mark_dirty_rect_xy((unsigned int)y0,
  681. (unsigned int)(y1 - y0),
  682. (unsigned int)x0, (unsigned int)x1);
  683. }
  684. mouse_redraw_cursor();
  685. mouse_set_auto_draw(1);
  686. wm_frame_active = 0;
  687. /* The copy can be long; let IRQs run. vga_present_shadow() keeps the
  688. * scheduler from switching away while it owns the damage list. */
  689. __asm__ volatile ("sti" ::: "memory");
  690. if (in->immediate)
  691. vga_fb_flush();
  692. else
  693. vga_fb_flush_budget(VGA_FLUSH_BUDGET_BYTES);
  694. sys_gfx_collect();
  695. return 0;
  696. }
  697. int wm_server_sync(void)
  698. {
  699. if (wm_frame_active)
  700. return -1;
  701. sys_gfx_collect();
  702. return 0;
  703. }
  704. static void wm_server_wm_died(void)
  705. {
  706. unsigned int i;
  707. if (wm_frame_active) {
  708. mouse_set_auto_draw(1);
  709. mouse_redraw_cursor();
  710. }
  711. wm_frame_active = 0;
  712. wm_attached = 0;
  713. wm_pid = 0;
  714. wm_cr3 = 0;
  715. for (i = 0; i < MAX_WINDOWS; i++) {
  716. windows[i].mapped_kind = WM_KIND_NONE;
  717. windows[i].mapped_gen = 0;
  718. windows[i].mapped_pages = 0;
  719. windows[i].mapped_src = 0;
  720. }
  721. wm_full_redraw = 1;
  722. serial_puts(SERIAL_COM1, "wm: ring-3 WM stopped; restarting\n");
  723. }
  724. void wm_server_start(void)
  725. {
  726. struct vfs_file f;
  727. struct vfs_mount *m = 0;
  728. unsigned int flags;
  729. int pid;
  730. if (wm_expected_pid && process_is_alive(wm_expected_pid))
  731. return;
  732. if (wm_last_start && get_ticks_ms() - wm_last_start < 1000)
  733. return;
  734. wm_last_start = get_ticks_ms();
  735. if (vfs_load_file("/ramfs/bin/wm", &f, &m) == 0) {
  736. flags = irq_save_disable();
  737. pid = process_create_user("wm", f.data, f.size, "", "/");
  738. if (pid > 0)
  739. wm_expected_pid = (unsigned int)pid;
  740. irq_restore(flags);
  741. vfs_release_file(m, &f);
  742. if (pid > 0) {
  743. process_set_weight((unsigned int)pid, 16);
  744. serial_puts(SERIAL_COM1, "wm: ring-3 WM started\n");
  745. return;
  746. }
  747. serial_puts(SERIAL_COM1, "wm: cannot load /ramfs/bin/wm\n");
  748. } else {
  749. serial_puts(SERIAL_COM1, "wm: /ramfs/bin/wm not found\n");
  750. }
  751. /* Temporary fallback during the transition: the old kernel WM. */
  752. flags = irq_save_disable();
  753. pid = process_create("wm", wm_run);
  754. if (pid > 0)
  755. wm_expected_pid = (unsigned int)pid;
  756. irq_restore(flags);
  757. if (pid > 0) {
  758. process_set_weight((unsigned int)pid, 16);
  759. serial_puts(SERIAL_COM1, "wm: kernel WM fallback\n");
  760. }
  761. }
  762. void wm_server_supervise(void)
  763. {
  764. unsigned int i, now = get_ticks_ms();
  765. /* Watchdog: a WM that never attaches, or stops polling for several
  766. * seconds, is treated like a crash so a wedged UI can recover. */
  767. if (wm_expected_pid && process_is_alive(wm_expected_pid)) {
  768. if ((wm_attached && now - wm_last_seen > 5000) ||
  769. (!wm_attached && now - wm_last_start > 3000)) {
  770. serial_puts(SERIAL_COM1, "wm: watchdog, killing WM\n");
  771. process_kill(wm_expected_pid);
  772. }
  773. }
  774. if (wm_expected_pid && !process_is_alive(wm_expected_pid)) {
  775. wm_server_wm_died();
  776. wm_expected_pid = 0;
  777. }
  778. /* Owner processes that exited close their windows. Only at a safe
  779. * point: the WM may still be between INFO/MAP and PRESENT. */
  780. if (wm_server_can_reap()) {
  781. for (i = 0; i < MAX_WINDOWS; i++) {
  782. struct window *w = &windows[i];
  783. if (!w->used || !w->pid || process_is_alive(w->pid))
  784. continue;
  785. if (w->canvas_window)
  786. w->owner_cr3 = 0; /* cr3 is gone/reaped */
  787. wm_close_window(i);
  788. }
  789. }
  790. if (wm_expected_pid && process_is_alive(wm_expected_pid))
  791. return;
  792. wm_server_start();
  793. }
  794. void wm_server_init(void)
  795. {
  796. unsigned int i;
  797. int have_terms = (wm_terms_init() == 0);
  798. if (!have_terms)
  799. serial_puts(SERIAL_COM1, "wm: no memory for terminal state\n");
  800. for (i = 0; i < MAX_WINDOWS; i++) {
  801. windows[i].used = 0;
  802. windows[i].term = terms[i];
  803. windows[i].mapped_kind = WM_KIND_NONE;
  804. windows[i].mapped_gen = 0;
  805. windows[i].mapped_pages = 0;
  806. windows[i].mapped_src = 0;
  807. }
  808. term_counter = 0;
  809. wm_full_redraw = 1;
  810. drag_active = 0;
  811. prev_buttons = 0;
  812. wm_expected_pid = 0;
  813. wm_pid = 0;
  814. wm_cr3 = 0;
  815. wm_attached = 0;
  816. wm_frame_active = 0;
  817. if (have_terms)
  818. wm_spawn_terminal();
  819. }
  820. static int wm_point_in_rect(unsigned int px, unsigned int py,
  821. unsigned int rx, unsigned int ry, unsigned int rw, unsigned int rh)
  822. {
  823. return px >= rx && px < rx + rw && py >= ry && py < ry + rh;
  824. }
  825. static void wm_make_title(struct window *w, unsigned int n)
  826. {
  827. char num[4];
  828. unsigned int i = 0, k = 0;
  829. w->title[k++] = 't'; w->title[k++] = 'e'; w->title[k++] = 'r';
  830. w->title[k++] = 'm'; w->title[k++] = ' ';
  831. do {
  832. num[i++] = (char)('0' + (n % 10));
  833. n /= 10;
  834. } while (n && i < 3);
  835. while (i)
  836. w->title[k++] = num[--i];
  837. w->title[k] = '\0';
  838. }
  839. int wm_spawn_terminal(void)
  840. {
  841. unsigned int i, j, fbw = vga_fb_width();
  842. struct window *w;
  843. struct term *t;
  844. int pid;
  845. unsigned int n;
  846. /* Preferred path: the ring-3 terminal owns a canvas window and creates
  847. * its own tty. The in-kernel cell terminal below is only a fallback for
  848. * a pack without /ramfs/bin/term. */
  849. {
  850. struct vfs_file f;
  851. struct vfs_mount *m = 0;
  852. if (vfs_load_file("/ramfs/bin/term", &f, &m) == 0) {
  853. unsigned int flags = irq_save_disable();
  854. pid = process_create_user_tty("term", f.data, f.size,
  855. "", "/", 0);
  856. irq_restore(flags);
  857. vfs_release_file(m, &f);
  858. if (pid > 0) {
  859. process_set_weight((unsigned int)pid, 12);
  860. wm_request_redraw();
  861. return 0;
  862. }
  863. serial_puts(SERIAL_COM1, "wm: cannot start ring-3 term\n");
  864. }
  865. }
  866. for (i = 0; i < MAX_WINDOWS; i++)
  867. if (!windows[i].used && terms[i])
  868. break;
  869. if (i == MAX_WINDOWS)
  870. return -1;
  871. w = &windows[i];
  872. t = terms[i];
  873. screen_init(&t->screen);
  874. t->screen.cursor_visible = 1;
  875. t->key_head = t->key_tail = 0;
  876. wait_queue_init(&t->key_wq);
  877. t->history_count = 0;
  878. t->history_next = 0;
  879. t->cwd[0] = '/';
  880. t->cwd[1] = '\0';
  881. w->used = 1;
  882. w->term = t;
  883. w->canvas_window = 0;
  884. w->canvas.px = 0;
  885. w->canvas.w = w->canvas.h = 0;
  886. w->canvas.seq = w->canvas.drawn = 0;
  887. w->back = 0;
  888. w->back_pages = 0;
  889. w->owner_cr3 = 0;
  890. w->key_head = w->key_tail = 0;
  891. wait_queue_init(&w->key_wq);
  892. w->pid = 0;
  893. w->focused = 0;
  894. w->pw = SCREEN_COLS * 8 + 2;
  895. w->ph = WM_TITLE_H + SCREEN_ROWS * 10 + 2;
  896. w->content_gen = 1;
  897. w->mapped_kind = WM_KIND_NONE;
  898. w->mapped_gen = 0;
  899. w->mapped_pages = 0;
  900. w->mapped_src = 0;
  901. /* Cascade position, clamped to the desktop area. */
  902. n = term_counter % 5;
  903. w->x = 24 + n * 32;
  904. w->y = WM_BAR_H + 12 + n * 28;
  905. if (w->x + w->pw > fbw)
  906. w->x = (fbw > w->pw) ? fbw - w->pw : 0;
  907. if (w->y + w->ph > vga_fb_height())
  908. w->y = WM_BAR_H + 4;
  909. term_counter++;
  910. wm_make_title(w, term_counter);
  911. pid = process_create_ptr("term", term_entry, t);
  912. if (pid < 0) {
  913. w->used = 0;
  914. return -1;
  915. }
  916. process_set_weight((unsigned int)pid, 12);
  917. w->pid = (unsigned int)pid;
  918. for (j = 0; j < MAX_WINDOWS; j++)
  919. if (windows[j].used)
  920. windows[j].focused = (j == i);
  921. wm_request_redraw();
  922. return (int)i;
  923. }
  924. static void wm_focus_index(unsigned int idx)
  925. {
  926. unsigned int i;
  927. if (windows[idx].used && windows[idx].focused)
  928. return;
  929. for (i = 0; i < MAX_WINDOWS; i++)
  930. if (windows[i].used)
  931. windows[i].focused = (i == idx);
  932. wm_request_redraw();
  933. }
  934. static void wm_focus_top(void)
  935. {
  936. unsigned int i;
  937. for (i = 0; i < MAX_WINDOWS; i++)
  938. if (windows[i].used) {
  939. wm_focus_index(i);
  940. return;
  941. }
  942. }
  943. static void wm_close_window(unsigned int idx)
  944. {
  945. struct window *w = &windows[idx];
  946. /* A terminal/key reader blocked on this window must not sleep through
  947. * the close; process_kill() also removes it from the queue. */
  948. wait_wake_all(&w->key_wq);
  949. if (w->term)
  950. wait_wake_all(&w->term->key_wq);
  951. if (w->term) {
  952. sys_gfx_kill_for_screen(&w->term->screen); /* stop a demo */
  953. if (w->pid)
  954. process_kill(w->pid);
  955. /* Free the dead session before this term/window slot can be
  956. * reused, so a late collect cannot unmap a new window that
  957. * lands on the same screen. */
  958. sys_gfx_collect();
  959. } else if (w->canvas_window) {
  960. if (w->pid)
  961. process_kill(w->pid);
  962. wm_server_unmap_index(idx);
  963. wm_free_canvas_window(idx);
  964. } else if (w->pid) {
  965. process_kill(w->pid);
  966. }
  967. wm_server_unmap_index(idx);
  968. w->used = 0;
  969. w->pid = 0;
  970. w->focused = 0;
  971. w->content_gen++;
  972. w->mapped_kind = WM_KIND_NONE;
  973. w->mapped_gen = 0;
  974. w->mapped_pages = 0;
  975. w->mapped_src = 0;
  976. wm_focus_top();
  977. wm_request_redraw();
  978. }
  979. /* Topmost window containing (px,py), or -1. */
  980. static int wm_window_at(unsigned int px, unsigned int py)
  981. {
  982. unsigned int i;
  983. for (i = 0; i < MAX_WINDOWS; i++)
  984. if (windows[i].used && windows[i].focused &&
  985. wm_point_in_rect(px, py, windows[i].x, windows[i].y,
  986. windows[i].pw, windows[i].ph))
  987. return (int)i;
  988. for (i = 0; i < MAX_WINDOWS; i++)
  989. if (windows[i].used && !windows[i].focused &&
  990. wm_point_in_rect(px, py, windows[i].x, windows[i].y,
  991. windows[i].pw, windows[i].ph))
  992. return (int)i;
  993. return -1;
  994. }
  995. static void wm_clamp_window(struct window *w, int nx, int ny)
  996. {
  997. unsigned int fbw = vga_fb_width();
  998. unsigned int fbh = vga_fb_height();
  999. int maxx = (int)fbw - (int)w->pw;
  1000. int maxy = (int)fbh - (int)w->ph;
  1001. if (maxx < 0)
  1002. maxx = 0;
  1003. if (maxy < (int)WM_BAR_H)
  1004. maxy = (int)WM_BAR_H;
  1005. if (nx < 0)
  1006. nx = 0;
  1007. else if (nx > maxx)
  1008. nx = maxx;
  1009. if (ny < (int)WM_BAR_H)
  1010. ny = (int)WM_BAR_H;
  1011. else if (ny > maxy)
  1012. ny = maxy;
  1013. w->x = (unsigned int)nx;
  1014. w->y = (unsigned int)ny;
  1015. }
  1016. /* Fill the intersection of rect (rx,ry,rw,rh) with clip rect (cx,cy,cw,ch). */
  1017. static void wm_fill_rect_clip(unsigned int rx, unsigned int ry, unsigned int rw, unsigned int rh,
  1018. unsigned int cx, unsigned int cy, unsigned int cw, unsigned int ch,
  1019. unsigned int r, unsigned int g, unsigned int b)
  1020. {
  1021. unsigned int x0 = (rx > cx) ? rx : cx;
  1022. unsigned int y0 = (ry > cy) ? ry : cy;
  1023. unsigned int x1 = (rx + rw < cx + cw) ? rx + rw : cx + cw;
  1024. unsigned int y1 = (ry + rh < cy + ch) ? ry + rh : cy + ch;
  1025. if (x1 > x0 && y1 > y0)
  1026. vga_fill_rect(x0, y0, x1 - x0, y1 - y0, r, g, b);
  1027. }
  1028. static void wm_draw_window_clip(struct window *w, unsigned int cx, unsigned int cy,
  1029. unsigned int cw, unsigned int ch);
  1030. /* Repaint the desktop rectangle (x, y, w, h): background, then every
  1031. intersecting window back-to-front (focused last), then mark it dirty. The
  1032. caller handles the mouse cursor. The rect must lie below the system bar
  1033. (windows are clamped to y >= WM_BAR_H, so the bar is never overlapped and
  1034. needs no clip variant). */
  1035. static void wm_redraw_rect(unsigned int x, unsigned int y,
  1036. unsigned int w, unsigned int h)
  1037. {
  1038. unsigned int i;
  1039. if (w == 0 || h == 0)
  1040. return;
  1041. vga_fill_rect(x, y, w, h, 32, 32, 48);
  1042. for (i = 0; i < MAX_WINDOWS; i++) {
  1043. struct window *w2 = &windows[i];
  1044. if (w2->used && !w2->focused &&
  1045. x < w2->x + w2->pw && x + w > w2->x &&
  1046. y < w2->y + w2->ph && y + h > w2->y)
  1047. wm_draw_window_clip(w2, x, y, w, h);
  1048. }
  1049. for (i = 0; i < MAX_WINDOWS; i++) {
  1050. struct window *w2 = &windows[i];
  1051. if (w2->used && w2->focused &&
  1052. x < w2->x + w2->pw && x + w > w2->x &&
  1053. y < w2->y + w2->ph && y + h > w2->y)
  1054. wm_draw_window_clip(w2, x, y, w, h);
  1055. }
  1056. vga_fb_mark_dirty_rect_xy(y, h, x, x + w);
  1057. }
  1058. /* Move a window in the shadow buffer: copy its rect, redraw the exposed
  1059. sliver, keep the cursor on top, and flush the swept band immediately so a
  1060. drag step is always one consistent frame (a budgeted flush would copy only
  1061. the top rows of the band per iteration and the window would appear to
  1062. stretch while the mouse keeps moving). */
  1063. static void wm_drag_shadow(struct window *w, unsigned int ox, unsigned int oy,
  1064. unsigned int nx, unsigned int ny)
  1065. {
  1066. int dx = (int)nx - (int)ox;
  1067. int dy = (int)ny - (int)oy;
  1068. mouse_cursor_erase();
  1069. blit->copy(nx, ny, ox, oy, w->pw, w->ph);
  1070. if (dy > 0)
  1071. wm_redraw_rect(ox, oy, w->pw, (unsigned int)dy);
  1072. else if (dy < 0)
  1073. wm_redraw_rect(ox, ny + w->ph, w->pw, (unsigned int)(-dy));
  1074. if (dx > 0)
  1075. wm_redraw_rect(ox, oy, (unsigned int)dx, w->ph);
  1076. else if (dx < 0)
  1077. wm_redraw_rect(nx + w->pw, oy, (unsigned int)(-dx), w->ph);
  1078. /* Only the moved window's new rect needs marking: the repaints above
  1079. cover the exposed slivers exactly, and the cursor marks itself. The
  1080. damage list merges these when the step is small (the union is then
  1081. the swept hull anyway) and keeps them apart after a big jump. */
  1082. vga_fb_mark_dirty_rect_xy(w->y, w->ph, w->x, w->x + w->pw);
  1083. mouse_redraw_cursor();
  1084. vga_fb_flush();
  1085. }
  1086. static void wm_handle_mouse(void)
  1087. {
  1088. unsigned int buttons = mouse_buttons_state();
  1089. unsigned int mx = mouse_get_x();
  1090. unsigned int my = mouse_get_y();
  1091. int left_down = (buttons & 1) != 0;
  1092. int left_was_down = (prev_buttons & 1) != 0;
  1093. if (left_down && !left_was_down) {
  1094. /* Press. */
  1095. if (wm_point_in_rect(mx, my, WM_BTN_X, WM_BTN_Y, WM_BTN_W, WM_BTN_H)) {
  1096. wm_spawn_terminal();
  1097. } else {
  1098. int idx = wm_window_at(mx, my);
  1099. if (idx >= 0) {
  1100. struct window *w = &windows[idx];
  1101. wm_focus_index((unsigned int)idx);
  1102. /* Close button? */
  1103. if (wm_point_in_rect(mx, my,
  1104. w->x + w->pw - 1 - WM_CLOSE_W, w->y + 1,
  1105. WM_CLOSE_W, WM_TITLE_H)) {
  1106. wm_close_window((unsigned int)idx);
  1107. } else if (my < w->y + WM_TITLE_H) {
  1108. /* Title bar: start drag. */
  1109. drag_active = 1;
  1110. drag_window = idx;
  1111. drag_dx = (int)mx - (int)w->x;
  1112. drag_dy = (int)my - (int)w->y;
  1113. }
  1114. }
  1115. }
  1116. } else if (left_down && left_was_down && drag_active) {
  1117. struct window *w = &windows[drag_window];
  1118. if (w->used) {
  1119. unsigned int ox = w->x, oy = w->y;
  1120. wm_clamp_window(w, (int)mx - drag_dx, (int)my - drag_dy);
  1121. if (ox != w->x || oy != w->y)
  1122. wm_drag_shadow(w, ox, oy, w->x, w->y);
  1123. } else {
  1124. drag_active = 0;
  1125. }
  1126. } else if (!left_down && left_was_down) {
  1127. drag_active = 0;
  1128. }
  1129. prev_buttons = buttons;
  1130. }
  1131. void wm_pump_keyboard(void)
  1132. {
  1133. struct window *fw = wm_focused_window();
  1134. static unsigned int last_hw_poll;
  1135. unsigned int now = get_ticks_ms();
  1136. int n;
  1137. if (io_keyboard_raw())
  1138. return; /* an inline command is polling for keys itself */
  1139. if (!fw)
  1140. return;
  1141. for (n = 0; n < 8; n++) {
  1142. int k = io_poll_key();
  1143. if (!k && (now - last_hw_poll) >= (io_keyboard_irq_masked() ? 5 : 50)) {
  1144. /* Fallback paths: IRQ1 was storm-masked, or no IRQ is
  1145. * delivering; sample the controller directly (faster
  1146. * when masked, so fast typing isn't dropped). */
  1147. k = io_poll_key_with_hw();
  1148. last_hw_poll = now;
  1149. }
  1150. if (!k)
  1151. break;
  1152. if (fw->term) {
  1153. /* A graphics command owns its window's keys (ESC etc.);
  1154. * Ctrl+C always reaches the terminal so its foreground
  1155. * kill keeps working. */
  1156. if (k == IO_KEY_CTRL_C ||
  1157. !sys_gfx_push_key(&fw->term->screen, k)) {
  1158. term_key_push(fw->term, k);
  1159. term_key_wake(fw->term);
  1160. }
  1161. } else if (fw->canvas_window) {
  1162. unsigned int next = (fw->key_head + 1) % 16;
  1163. if (next != fw->key_tail) {
  1164. fw->keys[fw->key_head] = k;
  1165. fw->key_head = next;
  1166. }
  1167. wait_wake_one(&fw->key_wq);
  1168. }
  1169. }
  1170. }
  1171. static void wm_draw_bar(void)
  1172. {
  1173. unsigned int fbw = vga_fb_width();
  1174. char dt[20];
  1175. /* Banner (light green). */
  1176. fbtext_draw_string_xy(4, 5, OS_NAME " v" OS_VERSION, 85, 255, 85, 0);
  1177. /* "+ New" button: purple box, white text. */
  1178. vga_fill_rect(WM_BTN_X, WM_BTN_Y, WM_BTN_W, WM_BTN_H, 150, 60, 210);
  1179. fbtext_draw_string_xy(WM_BTN_X + 4, WM_BTN_Y + 3, "+ New", 255, 255, 255, 1);
  1180. if (kexec_busy) {
  1181. /* Kexec progress, in place of the clock. */
  1182. static const char msg[] = "loading new kernel over serial";
  1183. char buf[48];
  1184. unsigned int n = 0, dots, i;
  1185. while (msg[n])
  1186. buf[n] = msg[n], n++;
  1187. dots = (kexec_total > 0) ? (kexec_progress * 12 / kexec_total) : 0;
  1188. for (i = 0; i < 12; i++)
  1189. buf[n + i] = (i < dots) ? '.' : ' ';
  1190. n += 12;
  1191. buf[n] = '\0';
  1192. fbtext_draw_string_xy(fbw - n * 8 - 4, 5, buf, 255, 200, 100, 0);
  1193. } else {
  1194. /* Live clock (light green, right-aligned). */
  1195. rtc_read_datetime(dt);
  1196. fbtext_draw_string_xy(fbw - 19 * 8 - 4, 5, dt, 85, 255, 85, 0);
  1197. }
  1198. /* Rainbow separator. */
  1199. fbtext_draw_rainbow_separator();
  1200. }
  1201. /* Draw window w clipped to (cx, cy, cw, ch). Chrome uses wm_fill_rect_clip,
  1202. * content the cells/canvas clip variants, so pixels outside the clip are
  1203. * untouched. */
  1204. static void wm_draw_window_clip(struct window *w, unsigned int cx, unsigned int cy,
  1205. unsigned int cw, unsigned int ch)
  1206. {
  1207. struct text_screen *s;
  1208. struct gfx_canvas *g;
  1209. if (!w->term)
  1210. return; /* generic canvas windows are drawn by the ring-3 WM */
  1211. s = &w->term->screen;
  1212. g = sys_gfx_canvas_for(s);
  1213. unsigned int bx = w->x + w->pw - 1 - WM_CLOSE_W;
  1214. unsigned int cony = w->y + 1 + WM_TITLE_H;
  1215. /* Border. */
  1216. wm_fill_rect_clip(w->x, w->y, w->pw, w->ph, cx, cy, cw, ch, 200, 200, 200);
  1217. /* Title bar. */
  1218. if (w->focused)
  1219. wm_fill_rect_clip(w->x + 1, w->y + 1, w->pw - 2, WM_TITLE_H,
  1220. cx, cy, cw, ch, 70, 90, 150);
  1221. else
  1222. wm_fill_rect_clip(w->x + 1, w->y + 1, w->pw - 2, WM_TITLE_H,
  1223. cx, cy, cw, ch, 100, 100, 100);
  1224. /* Title text. */
  1225. fbtext_draw_string_xy_clip(w->x + 4, w->y + 3, w->title, 255, 255, 255,
  1226. cx, cy, cw, ch);
  1227. /* Close button. */
  1228. wm_fill_rect_clip(bx, w->y + 1, WM_CLOSE_W, WM_TITLE_H,
  1229. cx, cy, cw, ch, 190, 60, 60);
  1230. fbtext_draw_string_xy_clip(bx + 3, w->y + 3, "x", 255, 255, 255,
  1231. cx, cy, cw, ch);
  1232. /* Content: text cells or the gfx canvas. */
  1233. wm_fill_rect_clip(w->x + 1, cony, w->pw - 2, SCREEN_ROWS * 10,
  1234. cx, cy, cw, ch, 0, 0, 0);
  1235. if (g)
  1236. blit->canvas(g, w->x + 1, cony, cx, cy, cw, ch);
  1237. else
  1238. fbtext_draw_cells_clip(s->cells, s->cols, s->rows,
  1239. w->x + 1, cony, cx, cy, cw, ch);
  1240. /* Blinking block cursor (text windows only). */
  1241. if (!g && w->focused && s->cursor_visible) {
  1242. unsigned int col = s->cursor % s->cols;
  1243. unsigned int row = s->cursor / s->cols;
  1244. wm_fill_rect_clip(w->x + 1 + col * 8, cony + row * 10, 2, 10,
  1245. cx, cy, cw, ch, 255, 255, 255);
  1246. }
  1247. }
  1248. static void wm_draw_window(struct window *w)
  1249. {
  1250. wm_draw_window_clip(w, w->x, w->y, w->pw, w->ph);
  1251. }
  1252. static void wm_render_full(void)
  1253. {
  1254. unsigned int fbw = vga_fb_width();
  1255. unsigned int fbh = vga_fb_height();
  1256. unsigned int i;
  1257. /* Erase the mouse cursor so the scene is drawn onto a clean background. */
  1258. mouse_cursor_erase();
  1259. /* Desktop background. */
  1260. vga_fill_rect(0, 0, fbw, fbh, 32, 32, 48);
  1261. /* Windows back-to-front (focused drawn last = on top). */
  1262. for (i = 0; i < MAX_WINDOWS; i++)
  1263. if (windows[i].used && !windows[i].focused)
  1264. wm_draw_window(&windows[i]);
  1265. for (i = 0; i < MAX_WINDOWS; i++)
  1266. if (windows[i].used && windows[i].focused)
  1267. wm_draw_window(&windows[i]);
  1268. /* System bar always on top. */
  1269. wm_draw_bar();
  1270. /* Mouse cursor on top of everything. */
  1271. mouse_redraw_cursor();
  1272. }
  1273. static void wm_render_bar(void)
  1274. {
  1275. unsigned int fbw = vga_fb_width();
  1276. mouse_cursor_erase();
  1277. vga_fill_rect(0, 0, fbw, WM_BAR_H, 32, 32, 48);
  1278. wm_draw_bar();
  1279. mouse_redraw_cursor();
  1280. }
  1281. static void wm_redraw_if_needed(void)
  1282. {
  1283. unsigned int i;
  1284. static unsigned int last_sec = 0xFFFFFFFF;
  1285. static unsigned int last_kexec_tick;
  1286. unsigned int now_ms = get_ticks_ms();
  1287. unsigned int now_sec = now_ms / 1000;
  1288. int kexec_changed = kexec_busy && (now_ms - last_kexec_tick >= 100);
  1289. int bar_changed;
  1290. if (kexec_changed)
  1291. last_kexec_tick = now_ms;
  1292. bar_changed = (now_sec != last_sec) || kexec_changed;
  1293. if (wm_full_redraw) {
  1294. unsigned int seq_before[MAX_WINDOWS];
  1295. for (i = 0; i < MAX_WINDOWS; i++) {
  1296. struct gfx_canvas *g = (windows[i].used && windows[i].term) ?
  1297. sys_gfx_canvas_for(&windows[i].term->screen) : 0;
  1298. seq_before[i] = g ? g->seq : 0;
  1299. }
  1300. wm_render_full();
  1301. for (i = 0; i < MAX_WINDOWS; i++)
  1302. if (windows[i].used && windows[i].term) {
  1303. struct gfx_canvas *g = sys_gfx_canvas_for(&windows[i].term->screen);
  1304. screen_clear_damage(&windows[i].term->screen);
  1305. if (g)
  1306. g->drawn = seq_before[i]; /* keep a frame
  1307. presented during the render */
  1308. }
  1309. wm_full_redraw = 0;
  1310. last_sec = now_sec;
  1311. return;
  1312. }
  1313. if (bar_changed) {
  1314. wm_render_bar();
  1315. last_sec = now_sec;
  1316. }
  1317. /* Any window whose content changed (focused or not): repaint just its
  1318. damaged cell block (a canvas window repaints its whole content)
  1319. through the damage-rect compositor. */
  1320. for (i = 0; i < MAX_WINDOWS; i++) {
  1321. struct text_screen *s;
  1322. struct gfx_canvas *g;
  1323. unsigned int seq, col0, row0, ncols, nrows;
  1324. if (!windows[i].used || !windows[i].term)
  1325. continue;
  1326. s = &windows[i].term->screen;
  1327. g = sys_gfx_canvas_for(s);
  1328. if (!screen_damage_block(s, &col0, &row0, &ncols, &nrows) &&
  1329. !(g && g->seq != g->drawn))
  1330. continue;
  1331. seq = g ? g->seq : 0; /* capture before compositing */
  1332. mouse_cursor_erase();
  1333. if (g)
  1334. wm_redraw_rect(windows[i].x + 1,
  1335. windows[i].y + 1 + WM_TITLE_H,
  1336. windows[i].pw - 2, SCREEN_ROWS * 10);
  1337. else
  1338. wm_redraw_rect(windows[i].x + 1 + col0 * 8,
  1339. windows[i].y + 1 + WM_TITLE_H + row0 * 10,
  1340. ncols * 8, nrows * 10);
  1341. mouse_redraw_cursor();
  1342. screen_clear_damage(s);
  1343. if (g)
  1344. g->drawn = seq;
  1345. }
  1346. }
  1347. void wm_blink_cursor(void)
  1348. {
  1349. static unsigned int last_cursor_tick;
  1350. struct window *fw = wm_focused_window();
  1351. unsigned int now = get_ticks_ms();
  1352. if (!fw || !fw->term)
  1353. return;
  1354. if (sys_gfx_canvas_for(&fw->term->screen))
  1355. return; /* no text cursor over a graphics command */
  1356. if (now - last_cursor_tick >= CURSOR_MS) {
  1357. last_cursor_tick = now;
  1358. fw->term->screen.cursor_visible = !fw->term->screen.cursor_visible;
  1359. screen_damage_cursor(&fw->term->screen);
  1360. }
  1361. }
  1362. void wm_handle_kexec(void)
  1363. {
  1364. if (kexec_busy)
  1365. return;
  1366. /* A command pack for /ramfs (checked before kexec: both start with
  1367. * 'K', and the kexec detector drops anything that is not KXEC). */
  1368. if (payload_pending()) {
  1369. kexec_busy = 1;
  1370. if (process_create("payload", program_payload_main) < 0)
  1371. kexec_busy = 0;
  1372. return;
  1373. }
  1374. if (kexec_pending()) {
  1375. kexec_busy = 1;
  1376. if (process_create("kexec", program_kexec_main) < 0)
  1377. kexec_busy = 0;
  1378. return;
  1379. }
  1380. /* Same over UDP: the host's `make net-dev` is picked up from here. */
  1381. if (netkexec_pending()) {
  1382. kexec_busy = 1;
  1383. if (process_create("netkexec", program_netkexec_main) < 0)
  1384. kexec_busy = 0;
  1385. }
  1386. }
  1387. void wm_run(void)
  1388. {
  1389. for (;;) {
  1390. wm_handle_mouse();
  1391. wm_redraw_if_needed();
  1392. vga_fb_flush_budget(VGA_FLUSH_BUDGET_BYTES);
  1393. cpu_idle();
  1394. }
  1395. }