wm.c 42 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607
  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 "cursor_abi.h"
  5. #include "backlight.h"
  6. #include "bootcon.h"
  7. #include "init.h"
  8. #include "io.h"
  9. #include "kexec.h"
  10. #include "mm.h"
  11. #include "mouse.h"
  12. #include "netkexec.h"
  13. #include "netlog.h"
  14. #include "paging.h"
  15. #include "payload.h"
  16. #include "process.h"
  17. #include "serial.h"
  18. #include "timer.h"
  19. #include "vga.h"
  20. #include "vfs.h"
  21. static struct window windows[MAX_WINDOWS];
  22. static int wm_full_redraw;
  23. static unsigned int wm_content_seq;
  24. static unsigned int wm_next_content_gen(void)
  25. {
  26. if (++wm_content_seq == 0)
  27. wm_content_seq++;
  28. return wm_content_seq;
  29. }
  30. /* Content pointer routing for canvas windows. wm_server_poll() is
  31. * called by the ring-3 WM every loop, so it is the cheapest place to turn the
  32. * sampled mouse state into press/release edges. */
  33. static unsigned int wm_ptr_buttons;
  34. /* SYS_WM_SET_CURSOR: the WM's shape for its own chrome (resize border,
  35. * title-bar drag, launchers), or CURSOR_NO_OVERRIDE. */
  36. static int wm_cursor_override = CURSOR_NO_OVERRIDE;
  37. /* The WM owns the pointer while it drags or resizes a window: no pointer
  38. * events reach canvas clients and SYS_WIN_POINTER reports no buttons. */
  39. static int wm_pointer_owned;
  40. static int wm_ptr_capture = -1;
  41. /* Ring-3 WM lifecycle. Init is the only creator: the attach auth below
  42. * admits an init child named "wm"; the kernel never starts a WM itself. */
  43. static unsigned int wm_pid;
  44. static unsigned int wm_cr3;
  45. static int wm_attached;
  46. static int wm_frame_active;
  47. static int wm_first_frame;
  48. static int wm_boot_ready;
  49. static unsigned int wm_wallpaper_seq;
  50. static unsigned int wm_last_seen;
  51. static inline unsigned int irq_save_disable(void)
  52. {
  53. unsigned int flags;
  54. __asm__ volatile ("pushfl; popl %0; cli" : "=r"(flags));
  55. return flags;
  56. }
  57. static inline void irq_restore(unsigned int flags)
  58. {
  59. __asm__ volatile ("pushl %0; popfl" :: "r"(flags));
  60. }
  61. static inline void invlpg_va(unsigned int va)
  62. {
  63. __asm__ volatile ("invlpg (%0)" : : "r"(va) : "memory");
  64. }
  65. static void wm_server_wm_died(void);
  66. static void wm_focus_index(unsigned int idx);
  67. static void wm_focus_top(void);
  68. static void wm_close_window(unsigned int idx);
  69. static void wm_clamp_window(struct window *w, int nx, int ny);
  70. static void wm_server_unmap_index(unsigned int idx);
  71. static int wm_window_at(int px, int py);
  72. static int wm_resize_target(int px, int py, int *edges);
  73. /* Content origin: a normal window has no visible frame, so its content
  74. * starts one title bar below the window origin; a popover is a flat
  75. * chromeless panel whose canvas fills the window. */
  76. static int win_content_x(const struct window *w)
  77. {
  78. return w->x + (w->popover ? 0 : WM_BORDER_W);
  79. }
  80. static int win_content_y(const struct window *w)
  81. {
  82. return w->y + (w->popover ? 0 : WM_BORDER_W + WM_TITLE_H);
  83. }
  84. void wm_request_redraw(void)
  85. {
  86. wm_full_redraw = 1;
  87. }
  88. struct window *wm_focused_window(void)
  89. {
  90. unsigned int i;
  91. for (i = 0; i < MAX_WINDOWS; i++)
  92. if (windows[i].used && windows[i].focused)
  93. return &windows[i];
  94. return (void *)0;
  95. }
  96. int wm_is_focused(const struct window *w)
  97. {
  98. return w->focused;
  99. }
  100. /* ---- Ring-3 WM ABI ---------------------------------------------------- */
  101. int wm_server_is_wm(void)
  102. {
  103. return wm_attached && current_proc()->pid == wm_pid;
  104. }
  105. int wm_server_frame_active(void)
  106. {
  107. return wm_frame_active;
  108. }
  109. /* Safe point for freeing another window's canvas: the WM is not between
  110. * SYS_WM_INFO/MAP and PRESENT. A ring-3 WM sleeps at the end of every loop;
  111. * the kernel fallback has no cached mappings. */
  112. int wm_server_can_reap(void)
  113. {
  114. if (wm_frame_active)
  115. return 0;
  116. return !wm_attached || process_is_sleeping(wm_pid);
  117. }
  118. static void wm_server_unmap_index(unsigned int idx)
  119. {
  120. struct window *w = &windows[idx];
  121. unsigned int va, i;
  122. if (!wm_cr3 || idx >= MAX_WINDOWS || !w->mapped_pages)
  123. return;
  124. va = WM_CONTENT_VA_BASE + idx * WM_CONTENT_SLOT;
  125. paging_release_user_range(wm_cr3, va, WM_CONTENT_SLOT, 0);
  126. for (i = 0; i < w->mapped_pages; i++)
  127. invlpg_va(va + i * PAGE_SIZE);
  128. w->mapped_kind = WM_KIND_NONE;
  129. w->mapped_gen = 0;
  130. w->mapped_pages = 0;
  131. w->mapped_src = 0;
  132. }
  133. /* A dead gfx session can coexist with a newer session on the same screen (the
  134. * old canvas is freed later). Only drop the WM mapping when it still points
  135. * at *this* canvas, so collecting the old session cannot unmap the new one. */
  136. static int wm_window_for_pid(unsigned int pid)
  137. {
  138. unsigned int i;
  139. for (i = 0; i < MAX_WINDOWS; i++)
  140. if (windows[i].used && windows[i].pid == pid)
  141. return (int)i;
  142. return -1;
  143. }
  144. static void wm_unmap_back(struct window *w, unsigned int pages)
  145. {
  146. unsigned int i;
  147. if (w->owner_cr3 && pages) {
  148. paging_release_user_range(w->owner_cr3, USER_WIN_BASE,
  149. pages * PAGE_SIZE, 0);
  150. for (i = 0; i < pages; i++)
  151. invlpg_va(USER_WIN_BASE + i * PAGE_SIZE);
  152. }
  153. w->owner_cr3 = 0;
  154. }
  155. static void wm_free_canvas_window(unsigned int idx)
  156. {
  157. struct window *w = &windows[idx];
  158. unsigned int i;
  159. if (!w->canvas_window)
  160. return;
  161. wm_unmap_back(w, w->back_pages);
  162. if (w->back) {
  163. for (i = 0; i < w->back_pages; i++)
  164. mm_free_page((unsigned int)w->back + i * PAGE_SIZE);
  165. w->back = 0;
  166. }
  167. w->back_pages = 0;
  168. if (w->pending_back) {
  169. for (i = 0; i < w->pending_pages; i++)
  170. mm_free_page((unsigned int)w->pending_back + i * PAGE_SIZE);
  171. w->pending_back = 0;
  172. }
  173. w->pending_pages = 0;
  174. w->resize_pending = 0;
  175. w->canvas_dmg_w = w->canvas_dmg_h = 0;
  176. gfx_free(&w->canvas);
  177. w->canvas_window = 0;
  178. }
  179. int wm_server_win_create(const struct win_create *in, struct win_info *out)
  180. {
  181. struct window *w;
  182. struct gfx_canvas *c;
  183. unsigned short *back;
  184. unsigned int i, j, pages, cw, ch, base;
  185. unsigned int flags;
  186. int popover = (in && (in->flags & WIN_F_POPOVER)) ? 1 : 0;
  187. unsigned int pad = popover ? 0 : WM_BORDER_W;
  188. unsigned int top = popover ? 0 : WM_TITLE_H + WM_BORDER_W;
  189. if (!in || !out)
  190. return -1;
  191. if (current_proc()->pid == 0 ||
  192. wm_window_for_pid(current_proc()->pid) >= 0)
  193. return -1;
  194. cw = in->w;
  195. ch = in->h;
  196. if (cw == 0 || ch == 0 || cw > WM_WIN_MAX_W || ch > WM_WIN_MAX_H)
  197. return -1;
  198. if (cw * ch * 2 > WM_CONTENT_SLOT || cw * ch * 2 > USER_WIN_RANGE)
  199. return -1;
  200. if (cw + pad * 2 > vga_fb_width() ||
  201. ch + top + pad > vga_fb_height())
  202. return -1;
  203. for (i = 0; i < MAX_WINDOWS; i++)
  204. if (!windows[i].used)
  205. break;
  206. if (i == MAX_WINDOWS) {
  207. serial_puts(SERIAL_COM1, "wm: win_create no window slot\n");
  208. return -1;
  209. }
  210. w = &windows[i];
  211. c = &w->canvas;
  212. if (gfx_alloc(c, cw, ch) != 0)
  213. return -1;
  214. pages = (cw * ch * 2 + PAGE_SIZE - 1) / PAGE_SIZE;
  215. back = (unsigned short *)mm_alloc_pages(pages);
  216. if (!back) {
  217. gfx_free(c);
  218. return -1;
  219. }
  220. for (j = 0; j < cw * ch; j++)
  221. back[j] = 0;
  222. flags = irq_save_disable();
  223. base = current_proc()->cr3;
  224. for (j = 0; j < pages; j++) {
  225. if (!paging_map_page(base, USER_WIN_BASE + j * PAGE_SIZE,
  226. (unsigned int)back + j * PAGE_SIZE,
  227. PTE_USER | PTE_WRITABLE | PTE_PRESENT)) {
  228. irq_restore(flags);
  229. paging_release_user_range(base, USER_WIN_BASE,
  230. (j ? j : 1) * PAGE_SIZE, 0);
  231. for (i = 0; i < pages; i++)
  232. mm_free_page((unsigned int)back + i * PAGE_SIZE);
  233. gfx_free(c);
  234. return -1;
  235. }
  236. invlpg_va(USER_WIN_BASE + j * PAGE_SIZE);
  237. }
  238. irq_restore(flags);
  239. w->used = 1;
  240. w->popover = popover;
  241. w->canvas_window = 1;
  242. w->pid = current_proc()->pid;
  243. w->owner_cr3 = base;
  244. w->back = back;
  245. w->back_pages = pages;
  246. w->canvas.seq = 1;
  247. w->canvas.drawn = 0;
  248. w->pending_back = 0;
  249. w->pending_pages = 0;
  250. w->resize_pending = 0;
  251. w->scroll_x = w->scroll_y = 0;
  252. w->cursor = CURSOR_DEFAULT;
  253. w->canvas_dmg_x = w->canvas_dmg_y = 0;
  254. w->canvas_dmg_w = w->canvas_dmg_h = 0;
  255. w->pw = cw + pad * 2;
  256. w->ph = ch + top + pad;
  257. if (popover) {
  258. w->x = (int)vga_fb_width() - (int)w->pw;
  259. w->y = WM_BAR_H;
  260. } else {
  261. w->x = 24 + (int)i * 32;
  262. w->y = WM_BAR_H + 12 + (int)i * 28;
  263. if (w->x + (int)w->pw > (int)vga_fb_width())
  264. w->x = ((int)vga_fb_width() > (int)w->pw) ?
  265. (int)vga_fb_width() - (int)w->pw : 0;
  266. if (w->y + (int)w->ph > (int)vga_fb_height())
  267. w->y = WM_BAR_H + 4;
  268. }
  269. wm_clamp_window(w, w->x, w->y);
  270. w->focused = 0;
  271. w->content_gen = wm_next_content_gen();
  272. w->mapped_kind = WM_KIND_NONE;
  273. w->mapped_gen = 0;
  274. w->mapped_pages = 0;
  275. w->mapped_src = 0;
  276. w->key_head = w->key_tail = 0;
  277. wait_queue_init(&w->key_wq);
  278. w->ptr_head = w->ptr_tail = 0;
  279. for (j = 0; j < sizeof(w->title) - 1 && in->title[j]; j++)
  280. w->title[j] = in->title[j];
  281. w->title[j] = '\0';
  282. wm_focus_index(i);
  283. out->fb = (void *)USER_WIN_BASE;
  284. out->width = cw;
  285. out->height = ch;
  286. out->id = i;
  287. return 0;
  288. }
  289. int wm_server_win_present(const struct wm_win_present *in)
  290. {
  291. int idx = wm_window_for_pid(current_proc()->pid);
  292. struct window *w;
  293. const unsigned short *src;
  294. unsigned int x = 0, y = 0, rw, rh, row;
  295. if (idx < 0)
  296. return -1;
  297. w = &windows[idx];
  298. if (!w->canvas_window || !w->back || !w->canvas.px ||
  299. w->resize_pending)
  300. return -1;
  301. rw = w->canvas.w;
  302. rh = w->canvas.h;
  303. if (in && in->w && in->h) {
  304. x = in->x;
  305. y = in->y;
  306. rw = in->w;
  307. rh = in->h;
  308. if (x >= w->canvas.w || y >= w->canvas.h)
  309. return -1;
  310. if (rw > w->canvas.w - x)
  311. rw = w->canvas.w - x;
  312. if (rh > w->canvas.h - y)
  313. rh = w->canvas.h - y;
  314. }
  315. src = (const unsigned short *)USER_WIN_BASE;
  316. for (row = 0; row < rh; row++) {
  317. const unsigned short *s = src + (unsigned long)(y + row) *
  318. w->canvas.w + x;
  319. unsigned short *d = w->canvas.px +
  320. (unsigned long)(y + row) * w->canvas.w + x;
  321. unsigned int n = rw;
  322. __asm__ volatile ("cld; rep movsw"
  323. : "+D"(d), "+c"(n), "+S"(s)
  324. :
  325. : "memory");
  326. }
  327. if (!w->canvas_dmg_w || !w->canvas_dmg_h) {
  328. w->canvas_dmg_x = x;
  329. w->canvas_dmg_y = y;
  330. w->canvas_dmg_w = rw;
  331. w->canvas_dmg_h = rh;
  332. } else {
  333. unsigned int x1 = w->canvas_dmg_x + w->canvas_dmg_w;
  334. unsigned int y1 = w->canvas_dmg_y + w->canvas_dmg_h;
  335. if (x < w->canvas_dmg_x)
  336. w->canvas_dmg_x = x;
  337. if (y < w->canvas_dmg_y)
  338. w->canvas_dmg_y = y;
  339. if (x + rw > x1)
  340. x1 = x + rw;
  341. if (y + rh > y1)
  342. y1 = y + rh;
  343. w->canvas_dmg_w = x1 - w->canvas_dmg_x;
  344. w->canvas_dmg_h = y1 - w->canvas_dmg_y;
  345. }
  346. w->canvas.seq++;
  347. return 0;
  348. }
  349. int wm_server_win_close(void)
  350. {
  351. int idx = wm_window_for_pid(current_proc()->pid);
  352. int was_focused;
  353. if (idx < 0 || !wm_server_can_reap())
  354. return -1;
  355. was_focused = windows[idx].focused;
  356. wm_server_unmap_index((unsigned int)idx);
  357. wm_free_canvas_window((unsigned int)idx);
  358. windows[idx].used = 0;
  359. windows[idx].pid = 0;
  360. windows[idx].focused = 0;
  361. windows[idx].content_gen++;
  362. if (was_focused)
  363. wm_focus_top();
  364. wm_request_redraw();
  365. return 0;
  366. }
  367. int wm_server_win_info(struct win_info *out)
  368. {
  369. int idx = wm_window_for_pid(current_proc()->pid);
  370. struct window *w;
  371. if (!out || idx < 0)
  372. return -1;
  373. w = &windows[idx];
  374. if (!w->canvas_window)
  375. return -1;
  376. out->fb = (void *)USER_WIN_BASE;
  377. out->width = w->canvas.w;
  378. out->height = w->canvas.h;
  379. out->id = (unsigned int)idx;
  380. return 0;
  381. }
  382. int wm_server_win_ack_resize(void)
  383. {
  384. int idx = wm_window_for_pid(current_proc()->pid);
  385. struct window *w;
  386. unsigned int i, old_pages;
  387. if (idx < 0)
  388. return -1;
  389. w = &windows[idx];
  390. if (!w->canvas_window || !w->resize_pending || !w->pending_back)
  391. return -1;
  392. old_pages = w->back_pages;
  393. if (w->owner_cr3)
  394. paging_release_user_range(w->owner_cr3, USER_WIN_BASE,
  395. old_pages * PAGE_SIZE, 0);
  396. for (i = 0; i < w->pending_pages; i++) {
  397. if (!paging_map_page(current_proc()->cr3,
  398. USER_WIN_BASE + i * PAGE_SIZE,
  399. (unsigned int)w->pending_back + i * PAGE_SIZE,
  400. PTE_USER | PTE_WRITABLE | PTE_PRESENT)) {
  401. /* Put the old mapping back; this is a last-resort path. */
  402. paging_release_user_range(current_proc()->cr3,
  403. USER_WIN_BASE,
  404. i * PAGE_SIZE, 0);
  405. for (i = 0; i < old_pages; i++)
  406. paging_map_page(current_proc()->cr3,
  407. USER_WIN_BASE + i * PAGE_SIZE,
  408. (unsigned int)w->back + i * PAGE_SIZE,
  409. PTE_USER | PTE_WRITABLE | PTE_PRESENT);
  410. for (i = 0; i < w->pending_pages; i++)
  411. mm_free_page((unsigned int)w->pending_back +
  412. i * PAGE_SIZE);
  413. w->pending_back = 0;
  414. w->pending_pages = 0;
  415. w->resize_pending = 0;
  416. return -1;
  417. }
  418. invlpg_va(USER_WIN_BASE + i * PAGE_SIZE);
  419. }
  420. for (i = 0; i < old_pages; i++)
  421. mm_free_page((unsigned int)w->back + i * PAGE_SIZE);
  422. w->back = w->pending_back;
  423. w->back_pages = w->pending_pages;
  424. w->pending_back = 0;
  425. w->pending_pages = 0;
  426. w->resize_pending = 0;
  427. w->canvas_dmg_w = w->canvas_dmg_h = 0;
  428. return 0;
  429. }
  430. int wm_server_win_pointer(struct win_pointer *out)
  431. {
  432. int idx = wm_window_for_pid(current_proc()->pid);
  433. struct window *w;
  434. unsigned int mx, my;
  435. int cx, cy;
  436. if (!out || idx < 0 || !windows[idx].canvas_window)
  437. return -1;
  438. w = &windows[idx];
  439. mx = mouse_get_x();
  440. my = mouse_get_y();
  441. cx = (int)mx - win_content_x(w);
  442. cy = (int)my - win_content_y(w);
  443. out->x = cx;
  444. out->y = cy;
  445. if (wm_pointer_owned) {
  446. out->buttons = 0;
  447. out->inside = 0;
  448. } else {
  449. out->buttons = mouse_buttons_state();
  450. out->inside = (cx >= 0 && cy >= 0 &&
  451. cx < (int)w->canvas.w && cy < (int)w->canvas.h &&
  452. (w->focused ||
  453. wm_window_at((int)mx, (int)my) == idx)) ?
  454. 1 : 0;
  455. }
  456. out->focused = w->focused ? 1 : 0;
  457. return 0;
  458. }
  459. int wm_server_win_event(struct win_event *out)
  460. {
  461. int idx = wm_window_for_pid(current_proc()->pid);
  462. struct window *w;
  463. if (!out || idx < 0 || !windows[idx].canvas_window)
  464. return -1;
  465. w = &windows[idx];
  466. if (w->ptr_tail == w->ptr_head)
  467. return 0;
  468. *out = w->ptr_events[w->ptr_tail];
  469. w->ptr_tail = (w->ptr_tail + 1) % 8;
  470. return 1;
  471. }
  472. int wm_server_win_scroll(struct win_scroll *out)
  473. {
  474. int idx = wm_window_for_pid(current_proc()->pid);
  475. struct window *w;
  476. if (!out || idx < 0 || !windows[idx].canvas_window)
  477. return -1;
  478. w = &windows[idx];
  479. out->dx = w->scroll_x;
  480. out->dy = w->scroll_y;
  481. w->scroll_x = w->scroll_y = 0;
  482. return (out->dx || out->dy) ? 1 : 0;
  483. }
  484. /* Keep the previous frame visible across a resize: copy the overlap of the old
  485. * front canvas into the new one, shifted by the window's origin delta
  486. * (dx,dy = new origin - old origin), so the pixels stay put on screen. The
  487. * newly exposed area starts black, and the client's back buffer stays blank on
  488. * purpose: it presents a full frame right after SYS_WIN_ACK_RESIZE. Without
  489. * this the WM composited a zeroed canvas and the content blinked black on
  490. * every resize step until the owner repainted. */
  491. static void wm_carry_canvas(const struct gfx_canvas *old,
  492. const struct gfx_canvas *fresh, int dx, int dy)
  493. {
  494. int x0 = 0, y0 = 0, x1, y1, y;
  495. if (!old->px || !fresh->px)
  496. return;
  497. /* New pixel (x,y) shows old pixel (x+dx, y+dy). */
  498. x1 = (int)fresh->w;
  499. if (x0 < -dx)
  500. x0 = -dx;
  501. if (x1 > (int)old->w - dx)
  502. x1 = (int)old->w - dx;
  503. y1 = (int)fresh->h;
  504. if (y0 < -dy)
  505. y0 = -dy;
  506. if (y1 > (int)old->h - dy)
  507. y1 = (int)old->h - dy;
  508. if (x0 >= x1 || y0 >= y1)
  509. return;
  510. for (y = y0; y < y1; y++) {
  511. const unsigned short *s = old->px +
  512. (unsigned long)(y + dy) * old->w + (x0 + dx);
  513. unsigned short *d = fresh->px +
  514. (unsigned long)y * fresh->w + x0;
  515. unsigned int n = (unsigned int)(x1 - x0);
  516. __asm__ volatile ("cld; rep movsw"
  517. : "+D"(d), "+c"(n), "+S"(s)
  518. :
  519. : "memory");
  520. }
  521. }
  522. static int wm_resize_window(unsigned int index, unsigned int cw,
  523. unsigned int ch, int dx, int dy)
  524. {
  525. struct window *w;
  526. struct gfx_canvas nf;
  527. unsigned short *nb;
  528. unsigned int i, pages, pad, top;
  529. if (index >= MAX_WINDOWS || !windows[index].used)
  530. return -1;
  531. w = &windows[index];
  532. if (!w->canvas_window || !process_is_alive(w->pid))
  533. return -1;
  534. pad = w->popover ? 0 : WM_BORDER_W;
  535. top = w->popover ? 0 : WM_TITLE_H + WM_BORDER_W;
  536. if (cw < 160 || ch < 80 || cw > WM_WIN_MAX_W || ch > WM_WIN_MAX_H)
  537. return -1;
  538. if (cw * ch * 2 > WM_CONTENT_SLOT || cw * ch * 2 > USER_WIN_RANGE)
  539. return -1;
  540. if (cw + pad * 2 > vga_fb_width() || ch + top + pad > vga_fb_height())
  541. return -1;
  542. if (gfx_alloc(&nf, cw, ch) != 0)
  543. return -1;
  544. pages = (cw * ch * 2 + PAGE_SIZE - 1) / PAGE_SIZE;
  545. nb = (unsigned short *)mm_alloc_pages(pages);
  546. if (!nb) {
  547. gfx_free(&nf);
  548. return -1;
  549. }
  550. for (i = 0; i < cw * ch; i++)
  551. nb[i] = 0;
  552. wm_carry_canvas(&w->canvas, &nf, dx, dy);
  553. wm_server_unmap_index(index);
  554. gfx_free(&w->canvas);
  555. if (w->pending_back) {
  556. for (i = 0; i < w->pending_pages; i++)
  557. mm_free_page((unsigned int)w->pending_back + i * PAGE_SIZE);
  558. }
  559. w->canvas = nf;
  560. w->canvas.seq = 1;
  561. w->canvas.drawn = 0;
  562. w->canvas_dmg_x = w->canvas_dmg_y = 0;
  563. w->canvas_dmg_w = w->canvas_dmg_h = 0;
  564. w->pending_back = nb;
  565. w->pending_pages = pages;
  566. w->resize_pending = 1;
  567. w->pw = cw + pad * 2;
  568. w->ph = ch + top + pad;
  569. w->content_gen = wm_next_content_gen();
  570. /* The owner is probably parked in SYS_WIN_KEY_WAIT; wake it so it
  571. * acknowledges the resize (and reflows its content) immediately. */
  572. wait_wake_one(&w->key_wq);
  573. return 0;
  574. }
  575. int wm_server_resize(unsigned int index, unsigned int cw, unsigned int ch,
  576. int dx, int dy)
  577. {
  578. if (!wm_server_is_wm())
  579. return -1;
  580. return wm_resize_window(index, cw, ch, dx, dy);
  581. }
  582. /* A canvas app resizes its own popover when it expands or collapses a
  583. * section. Refuse while the WM owns a frame: it may still be reading the
  584. * old front canvas. The app retries on its next loop. */
  585. int wm_server_win_resize_self(unsigned int cw, unsigned int ch)
  586. {
  587. int idx = wm_window_for_pid(current_proc()->pid);
  588. if (idx < 0 || wm_frame_active)
  589. return -1;
  590. return wm_resize_window((unsigned int)idx, cw, ch, 0, 0);
  591. }
  592. int wm_server_win_set_cursor(int shape)
  593. {
  594. int idx = wm_window_for_pid(current_proc()->pid);
  595. if (idx < 0 || shape < 0 || shape >= CURSOR_COUNT)
  596. return -1;
  597. windows[idx].cursor = shape;
  598. return 0;
  599. }
  600. int wm_server_set_cursor(int shape)
  601. {
  602. if (!wm_server_is_wm())
  603. return -1;
  604. if (shape != CURSOR_NO_OVERRIDE && (shape < 0 || shape >= CURSOR_COUNT))
  605. return -1;
  606. wm_cursor_override = shape;
  607. return 0;
  608. }
  609. /* Take/release the pointer for a WM drag or resize. While owned, a held
  610. * button is invisible to the canvas clients, so a press that started on a
  611. * window edge cannot also drag a scrollbar inside the window. */
  612. int wm_server_set_pointer_capture(int on)
  613. {
  614. if (!wm_server_is_wm())
  615. return -1;
  616. wm_pointer_owned = on ? 1 : 0;
  617. if (on) {
  618. wm_ptr_capture = -1;
  619. wm_ptr_buttons = mouse_buttons_state();
  620. }
  621. return 0;
  622. }
  623. /* Invisible resize border inside a normal window's outer edge. Presses here
  624. * belong to the ring-3 WM's resize path, not to the content client. Only the
  625. * WM_RESIZE_IN part of the band lies inside the window; the rest is outside
  626. * the rectangle and never reaches the content anyway. */
  627. static int win_in_resize_border(const struct window *w, unsigned int mx,
  628. unsigned int my)
  629. {
  630. if (w->popover)
  631. return 0;
  632. return (int)mx < w->x + WM_RESIZE_IN ||
  633. (int)mx >= w->x + (int)w->pw - WM_RESIZE_IN ||
  634. (int)my < w->y + WM_RESIZE_IN ||
  635. (int)my >= w->y + (int)w->ph - WM_RESIZE_IN;
  636. }
  637. /* The shape for the pointer at (mx,my): the WM's override, else the
  638. * content cursor of the window that holds the pointer capture (a drag that
  639. * started in the content keeps its cursor), else of the window whose
  640. * content is under the pointer (not on a normal window's resize border),
  641. * else the default arrow (title bars, the desktop, the top bar). */
  642. static int wm_cursor_at(unsigned int mx, unsigned int my)
  643. {
  644. int idx;
  645. struct window *w;
  646. int cx, cy;
  647. int edges = 0;
  648. if (wm_cursor_override != CURSOR_NO_OVERRIDE)
  649. return wm_cursor_override;
  650. if (wm_ptr_capture >= 0 && windows[wm_ptr_capture].used &&
  651. windows[wm_ptr_capture].canvas_window)
  652. return windows[wm_ptr_capture].cursor;
  653. idx = wm_resize_target((int)mx, (int)my, &edges);
  654. if (idx < 0 || edges)
  655. return CURSOR_DEFAULT;
  656. w = &windows[idx];
  657. if (!w->canvas_window)
  658. return CURSOR_DEFAULT;
  659. cx = (int)mx - win_content_x(w);
  660. cy = (int)my - win_content_y(w);
  661. if (cx < 0 || cy < 0 || cx >= (int)w->canvas.w ||
  662. cy >= (int)w->canvas.h)
  663. return CURSOR_DEFAULT;
  664. if (win_in_resize_border(w, mx, my))
  665. return CURSOR_DEFAULT;
  666. return w->cursor;
  667. }
  668. int wm_server_key_poll(void)
  669. {
  670. int idx = wm_window_for_pid(current_proc()->pid);
  671. struct window *w;
  672. int k;
  673. if (idx < 0)
  674. return 0;
  675. w = &windows[idx];
  676. if (w->key_tail == w->key_head)
  677. return 0;
  678. k = w->keys[w->key_tail];
  679. w->key_tail = (w->key_tail + 1) % 16;
  680. return k;
  681. }
  682. /* Block until a key arrives for the caller's window, or `timeout_ms` passes
  683. * (0 = wait forever). Returns the key, 0 on timeout/no key, -1 if the caller
  684. * has no window. */
  685. int wm_server_key_wait(unsigned int timeout_ms)
  686. {
  687. int idx = wm_window_for_pid(current_proc()->pid);
  688. struct window *w;
  689. int k;
  690. if (idx < 0)
  691. return -1;
  692. w = &windows[idx];
  693. k = wm_server_key_poll();
  694. if (k)
  695. return k;
  696. if (timeout_ms)
  697. sched_block_timeout(&w->key_wq, timeout_ms);
  698. else
  699. sched_block_on(&w->key_wq);
  700. return wm_server_key_poll();
  701. }
  702. int wm_server_attach(struct wm_screen_info *out)
  703. {
  704. struct process *cur = current_proc();
  705. struct surface *s;
  706. unsigned int pages, i, bytes;
  707. if (!out || !cur)
  708. return -1;
  709. /* A WM that died but was not reaped yet must not block its replacement. */
  710. if (wm_pid && !process_is_alive(wm_pid)) {
  711. wm_server_wm_died();
  712. wm_pid = 0;
  713. }
  714. if (wm_attached ||
  715. !init_server_pid() ||
  716. cur->parent_pid != init_server_pid() ||
  717. cur->name[0] != 'w' || cur->name[1] != 'm' ||
  718. cur->name[2] != '\0') {
  719. serial_puts(SERIAL_COM1, "wm: attach rejected (pid ");
  720. serial_puthex(SERIAL_COM1, cur->pid);
  721. serial_puts(SERIAL_COM1, " parent ");
  722. serial_puthex(SERIAL_COM1, cur->parent_pid);
  723. serial_puts(SERIAL_COM1, " init ");
  724. serial_puthex(SERIAL_COM1, init_server_pid());
  725. serial_puts(SERIAL_COM1, ")\n");
  726. return -1;
  727. }
  728. if (!vga_shadow_is_active()) {
  729. serial_puts(SERIAL_COM1, "wm: attach: no shadow buffer\n");
  730. return -1;
  731. }
  732. s = vga_screen_surface();
  733. if (!s || !s->px)
  734. return -1;
  735. bytes = s->pitch * s->h;
  736. pages = (bytes + PAGE_SIZE - 1) / PAGE_SIZE;
  737. wm_cr3 = current_proc()->cr3;
  738. for (i = 0; i < pages; i++) {
  739. unsigned int va = WM_SHADOW_VA + i * PAGE_SIZE;
  740. if (!paging_map_page(wm_cr3, va,
  741. (unsigned int)s->px + i * PAGE_SIZE,
  742. PTE_USER | PTE_WRITABLE | PTE_PRESENT)) {
  743. paging_release_user_range(wm_cr3, WM_SHADOW_VA,
  744. i * PAGE_SIZE, 0);
  745. wm_cr3 = 0;
  746. return -1;
  747. }
  748. invlpg_va(va);
  749. }
  750. for (i = 0; i < MAX_WINDOWS; i++) {
  751. windows[i].mapped_kind = WM_KIND_NONE;
  752. windows[i].mapped_gen = 0;
  753. windows[i].mapped_pages = 0;
  754. windows[i].mapped_src = 0;
  755. }
  756. wm_pid = current_proc()->pid;
  757. wm_attached = 1;
  758. wm_frame_active = 0;
  759. wm_last_seen = get_ticks_ms();
  760. mouse_set_auto_draw(1);
  761. wm_full_redraw = 1;
  762. /* The WM owns the display from its first frame on; stop the boot
  763. * console before a later boot line can draw over the desktop. */
  764. bootcon_set_enabled(0);
  765. out->width = s->w;
  766. out->height = s->h;
  767. out->pitch = s->pitch;
  768. out->bpp = s->bpp;
  769. out->bytes = bytes;
  770. out->fb = (void *)WM_SHADOW_VA;
  771. serial_puts(SERIAL_COM1, "wm: ring-3 WM attached\n");
  772. return 0;
  773. }
  774. int wm_server_info(unsigned int index, struct wm_window_info *out)
  775. {
  776. struct window *w;
  777. struct gfx_canvas *g;
  778. unsigned int i;
  779. if (!wm_server_is_wm() || !out || index >= MAX_WINDOWS)
  780. return -1;
  781. w = &windows[index];
  782. if (!w->used)
  783. return 0;
  784. out->used = 1;
  785. out->focused = w->focused ? 1 : 0;
  786. out->pid = w->pid;
  787. out->popover = w->popover ? 1 : 0;
  788. out->x = (int)w->x;
  789. out->y = (int)w->y;
  790. out->w = w->pw;
  791. out->h = w->ph;
  792. out->dirty = 0;
  793. out->dirty_seq = 0;
  794. out->dmg_x = out->dmg_y = out->dmg_w = out->dmg_h = 0;
  795. out->content_gen = w->content_gen;
  796. for (i = 0; i < sizeof(out->title) - 1 && w->title[i]; i++)
  797. out->title[i] = w->title[i];
  798. out->title[i] = '\0';
  799. if (!w->canvas_window)
  800. return 1;
  801. g = &w->canvas;
  802. out->content_w = g->w;
  803. out->content_h = g->h;
  804. out->dirty = (g->seq != g->drawn);
  805. out->dirty_seq = g->seq;
  806. if (out->dirty && w->canvas_dmg_w && w->canvas_dmg_h) {
  807. out->dmg_x = w->canvas_dmg_x;
  808. out->dmg_y = w->canvas_dmg_y;
  809. out->dmg_w = w->canvas_dmg_w;
  810. out->dmg_h = w->canvas_dmg_h;
  811. } else if (out->dirty) {
  812. out->dmg_w = g->w;
  813. out->dmg_h = g->h;
  814. }
  815. return 1;
  816. }
  817. int wm_server_map(unsigned int index, struct wm_map_info *out)
  818. {
  819. struct window *w;
  820. struct gfx_canvas *g = 0;
  821. const void *src;
  822. unsigned int pages, i, va, stride;
  823. if (!wm_server_is_wm() || !out || index >= MAX_WINDOWS || !wm_cr3)
  824. return -1;
  825. w = &windows[index];
  826. if (!w->used || !w->canvas_window)
  827. return -1;
  828. g = &w->canvas;
  829. src = (const void *)g->px;
  830. if (!src)
  831. return -1;
  832. stride = g->w * 2;
  833. if (w->mapped_kind == WM_KIND_GFX && w->mapped_gen == w->content_gen &&
  834. w->mapped_src == src) {
  835. out->va = (void *)(WM_CONTENT_VA_BASE + index * WM_CONTENT_SLOT);
  836. out->kind = WM_KIND_GFX;
  837. out->generation = w->content_gen;
  838. out->w = g->w;
  839. out->h = g->h;
  840. out->stride = stride;
  841. return 0;
  842. }
  843. wm_server_unmap_index(index);
  844. pages = (g->w * g->h * 2 + PAGE_SIZE - 1) / PAGE_SIZE;
  845. if (pages * PAGE_SIZE > WM_CONTENT_SLOT)
  846. return -1;
  847. va = WM_CONTENT_VA_BASE + index * WM_CONTENT_SLOT;
  848. for (i = 0; i < pages; i++) {
  849. if (!paging_map_page(wm_cr3, va + i * PAGE_SIZE,
  850. (unsigned int)src + i * PAGE_SIZE,
  851. PTE_USER | PTE_PRESENT)) {
  852. paging_release_user_range(wm_cr3, va,
  853. (i ? i : 1) * PAGE_SIZE, 0);
  854. return -1;
  855. }
  856. invlpg_va(va + i * PAGE_SIZE);
  857. }
  858. w->mapped_kind = WM_KIND_GFX;
  859. w->mapped_gen = w->content_gen;
  860. w->mapped_pages = pages;
  861. w->mapped_src = src;
  862. out->va = (void *)va;
  863. out->kind = WM_KIND_GFX;
  864. out->w = g->w;
  865. out->h = g->h;
  866. out->stride = stride;
  867. out->generation = w->content_gen;
  868. return 0;
  869. }
  870. int wm_server_ack(unsigned int index, unsigned int seq)
  871. {
  872. struct window *w;
  873. if (!wm_server_is_wm() || index >= MAX_WINDOWS)
  874. return -1;
  875. w = &windows[index];
  876. if (!w->used || !w->canvas_window)
  877. return -1;
  878. if (seq == w->canvas.seq) {
  879. w->canvas.drawn = seq;
  880. w->canvas_dmg_w = w->canvas_dmg_h = 0;
  881. }
  882. return 0;
  883. }
  884. int wm_server_focus(unsigned int index)
  885. {
  886. if (!wm_server_is_wm() || index >= MAX_WINDOWS ||
  887. !windows[index].used)
  888. return -1;
  889. wm_focus_index(index);
  890. return 0;
  891. }
  892. int wm_server_set_geom(unsigned int index, int x, int y)
  893. {
  894. if (!wm_server_is_wm() || index >= MAX_WINDOWS ||
  895. !windows[index].used)
  896. return -1;
  897. wm_clamp_window(&windows[index], x, y);
  898. return 0;
  899. }
  900. int wm_spawn_terminal(void)
  901. {
  902. struct vfs_file f;
  903. struct vfs_mount *m = 0;
  904. unsigned int flags;
  905. int pid;
  906. if (vfs_load_file("/ramfs/bin/term", &f, &m) != 0) {
  907. serial_puts(SERIAL_COM1, "wm: /ramfs/bin/term not found\n");
  908. return -1;
  909. }
  910. flags = irq_save_disable();
  911. pid = process_create_user_tty("term", f.data, f.size, "", "/", 0);
  912. irq_restore(flags);
  913. vfs_release_file(m, &f);
  914. if (pid <= 0) {
  915. serial_puts(SERIAL_COM1, "wm: cannot start ring-3 term\n");
  916. return -1;
  917. }
  918. process_set_weight((unsigned int)pid, 12);
  919. wm_request_redraw();
  920. return 0;
  921. }
  922. int wm_server_create_term(void)
  923. {
  924. if (!wm_server_is_wm())
  925. return -1;
  926. return wm_spawn_terminal();
  927. }
  928. int wm_server_close(unsigned int index)
  929. {
  930. if (!wm_server_is_wm() || wm_frame_active ||
  931. index >= MAX_WINDOWS || !windows[index].used)
  932. return -1;
  933. wm_close_window(index);
  934. return 0;
  935. }
  936. static void wm_queue_ptr_event(struct window *w, unsigned int type,
  937. int x, int y, unsigned int buttons,
  938. unsigned int button)
  939. {
  940. unsigned int next = (w->ptr_head + 1) % 8;
  941. if (next == w->ptr_tail)
  942. return; /* full: drop the event, not the app */
  943. w->ptr_events[w->ptr_head].type = type;
  944. w->ptr_events[w->ptr_head].x = x;
  945. w->ptr_events[w->ptr_head].y = y;
  946. w->ptr_events[w->ptr_head].buttons = buttons;
  947. w->ptr_events[w->ptr_head].button = button;
  948. w->ptr_head = next;
  949. /* Wake a window blocked in SYS_WIN_KEY_WAIT so a click (e.g. on the
  950. * terminal's scrollbar) is handled now, not on the next poll timeout. */
  951. wait_wake_one(&w->key_wq);
  952. }
  953. /* Turn the sampled button state into content-relative press/release events for
  954. * the topmost canvas window. The kernel WM still owns focus, drag and resize;
  955. * only clicks that land in the content area are forwarded. */
  956. static void wm_route_pointer(unsigned int mx, unsigned int my,
  957. unsigned int buttons)
  958. {
  959. unsigned int press = buttons & ~wm_ptr_buttons;
  960. unsigned int release = wm_ptr_buttons & ~buttons;
  961. if (wm_pointer_owned) {
  962. wm_ptr_buttons = buttons;
  963. return;
  964. }
  965. if (press & 3) {
  966. int idx = wm_ptr_capture;
  967. if (idx < 0) {
  968. int edges = 0;
  969. idx = wm_resize_target((int)mx, (int)my, &edges);
  970. if (edges)
  971. idx = -1;
  972. }
  973. if (idx >= 0 && idx < (int)MAX_WINDOWS) {
  974. struct window *w = &windows[idx];
  975. int cx = (int)mx - win_content_x(w);
  976. int cy = (int)my - win_content_y(w);
  977. /* A second button pressed after a capture may leave the
  978. * content, but still belongs to the window that owns the
  979. * pointer. */
  980. if (w->used && w->canvas_window &&
  981. (wm_ptr_capture == idx ||
  982. (cx >= 0 && cy >= 0 && cx < (int)w->canvas.w &&
  983. cy < (int)w->canvas.h &&
  984. (w->popover || !win_in_resize_border(w, mx, my))))) {
  985. wm_queue_ptr_event(w, WIN_EV_POINTER_DOWN,
  986. cx, cy, buttons, press & 3);
  987. wm_ptr_capture = idx;
  988. }
  989. }
  990. }
  991. if ((release & 3) && wm_ptr_capture >= 0) {
  992. struct window *w = &windows[wm_ptr_capture];
  993. if (w->used && w->canvas_window) {
  994. int cx = (int)mx - win_content_x(w);
  995. int cy = (int)my - win_content_y(w);
  996. wm_queue_ptr_event(w, WIN_EV_POINTER_UP,
  997. cx, cy, buttons, release & 3);
  998. }
  999. if (!(buttons & 3))
  1000. wm_ptr_capture = -1;
  1001. }
  1002. wm_ptr_buttons = buttons;
  1003. }
  1004. /* Route wheel/touchpad scroll to the canvas window under the pointer. The
  1005. * accumulator is drained by SYS_WIN_SCROLL, so a slow client can catch up. */
  1006. static void wm_route_scroll(unsigned int mx, unsigned int my)
  1007. {
  1008. int sdx, sdy;
  1009. int edges = 0;
  1010. int idx = wm_resize_target((int)mx, (int)my, &edges);
  1011. struct window *w;
  1012. int cx, cy;
  1013. mouse_scroll_take(&sdx, &sdy);
  1014. if (wm_pointer_owned)
  1015. return;
  1016. if (edges || (!sdx && !sdy) || idx < 0)
  1017. return;
  1018. w = &windows[idx];
  1019. if (!w->canvas_window)
  1020. return;
  1021. cx = (int)mx - win_content_x(w);
  1022. cy = (int)my - win_content_y(w);
  1023. if (cx < 0 || cy < 0 || cx >= (int)w->canvas.w ||
  1024. cy >= (int)w->canvas.h)
  1025. return;
  1026. w->scroll_x += sdx;
  1027. w->scroll_y += sdy;
  1028. if (w->scroll_x > 100000)
  1029. w->scroll_x = 100000;
  1030. else if (w->scroll_x < -100000)
  1031. w->scroll_x = -100000;
  1032. if (w->scroll_y > 100000)
  1033. w->scroll_y = 100000;
  1034. else if (w->scroll_y < -100000)
  1035. w->scroll_y = -100000;
  1036. /* Wake clients blocked in SYS_WIN_KEY_WAIT so they drain the scroll. */
  1037. wait_wake_one(&w->key_wq);
  1038. }
  1039. int wm_server_poll(struct wm_status *out)
  1040. {
  1041. if (!wm_server_is_wm() || !out)
  1042. return -1;
  1043. wm_last_seen = get_ticks_ms();
  1044. out->mouse.x = mouse_get_x();
  1045. out->mouse.y = mouse_get_y();
  1046. out->mouse.buttons = mouse_buttons_state();
  1047. wm_route_pointer(out->mouse.x, out->mouse.y, out->mouse.buttons);
  1048. wm_route_scroll(out->mouse.x, out->mouse.y);
  1049. mouse_set_shape(wm_cursor_at(out->mouse.x, out->mouse.y));
  1050. out->full_redraw = wm_full_redraw ? 1 : 0;
  1051. out->boot_ready = wm_boot_ready ? 1 : 0;
  1052. out->kexec_busy = kexec_busy ? 1 : 0;
  1053. out->kexec_progress = kexec_progress;
  1054. out->kexec_total = kexec_total;
  1055. {
  1056. int level = backlight_percent();
  1057. out->backlight_present = level >= 0 ? 1 : 0;
  1058. out->backlight_level = level > 0 ? (unsigned int)level : 0;
  1059. out->backlight_seq = backlight_seq();
  1060. }
  1061. out->wallpaper_seq = wm_wallpaper_seq;
  1062. wm_full_redraw = 0;
  1063. return 0;
  1064. }
  1065. void wm_server_boot_ready(void)
  1066. {
  1067. wm_boot_ready = 1;
  1068. }
  1069. /* SYS_WM_WALLPAPER: a client (the image viewer) wrote a new wallpaper file.
  1070. * Bumping the sequence makes the WM reload it and repaint the desktop. */
  1071. void wm_server_wallpaper_changed(void)
  1072. {
  1073. wm_wallpaper_seq++;
  1074. }
  1075. int wm_server_begin(void)
  1076. {
  1077. if (!wm_server_is_wm() || wm_frame_active)
  1078. return -1;
  1079. mouse_cursor_erase();
  1080. mouse_set_auto_draw(0);
  1081. wm_frame_active = 1;
  1082. return 0;
  1083. }
  1084. int wm_server_present(const struct wm_present_info *in)
  1085. {
  1086. unsigned int i;
  1087. if (!wm_server_is_wm() || !wm_frame_active || !in)
  1088. return -1;
  1089. for (i = 0; i < in->count && i < 4; i++) {
  1090. int x0 = in->rect[i].x;
  1091. int y0 = in->rect[i].y;
  1092. int x1 = x0 + (int)in->rect[i].w;
  1093. int y1 = y0 + (int)in->rect[i].h;
  1094. if (x0 < 0) x0 = 0;
  1095. if (y0 < 0) y0 = 0;
  1096. if (x1 < 0) x1 = 0;
  1097. if (y1 < 0) y1 = 0;
  1098. if (x1 > (int)vga_fb_width()) x1 = (int)vga_fb_width();
  1099. if (y1 > (int)vga_fb_height()) y1 = (int)vga_fb_height();
  1100. if (x1 > x0 && y1 > y0)
  1101. vga_fb_mark_dirty_rect_xy((unsigned int)y0,
  1102. (unsigned int)(y1 - y0),
  1103. (unsigned int)x0, (unsigned int)x1);
  1104. }
  1105. mouse_redraw_cursor();
  1106. mouse_set_auto_draw(1);
  1107. wm_frame_active = 0;
  1108. /* The copy can be long; let IRQs run. vga_present_shadow() keeps the
  1109. * scheduler from switching away while it owns the damage list. */
  1110. __asm__ volatile ("sti" ::: "memory");
  1111. if (in->immediate)
  1112. vga_fb_flush();
  1113. else
  1114. vga_fb_flush_budget(VGA_FLUSH_BUDGET_BYTES);
  1115. if (!wm_first_frame) {
  1116. wm_first_frame = 1;
  1117. serial_puts(SERIAL_COM1, "wm: first frame\n");
  1118. }
  1119. return 0;
  1120. }
  1121. int wm_server_sync(void)
  1122. {
  1123. if (wm_frame_active)
  1124. return -1;
  1125. return 0;
  1126. }
  1127. static void wm_server_wm_died(void)
  1128. {
  1129. unsigned int i;
  1130. if (wm_frame_active) {
  1131. mouse_set_auto_draw(1);
  1132. mouse_redraw_cursor();
  1133. }
  1134. wm_frame_active = 0;
  1135. wm_attached = 0;
  1136. wm_pid = 0;
  1137. wm_cr3 = 0;
  1138. wm_ptr_buttons = 0;
  1139. wm_ptr_capture = -1;
  1140. wm_cursor_override = CURSOR_NO_OVERRIDE;
  1141. wm_pointer_owned = 0;
  1142. mouse_set_shape(CURSOR_DEFAULT);
  1143. for (i = 0; i < MAX_WINDOWS; i++) {
  1144. windows[i].mapped_kind = WM_KIND_NONE;
  1145. windows[i].mapped_gen = 0;
  1146. windows[i].mapped_pages = 0;
  1147. windows[i].mapped_src = 0;
  1148. }
  1149. wm_full_redraw = 1;
  1150. serial_puts(SERIAL_COM1, "wm: ring-3 WM stopped\n");
  1151. }
  1152. void wm_server_supervise(void)
  1153. {
  1154. unsigned int i, now = get_ticks_ms();
  1155. /* Watchdog: a WM that stops polling for several seconds is treated
  1156. * like a crash so init can replace it. Sleeping is not a hang: it is
  1157. * usually the BKL or the normal 10 ms poll sleep. */
  1158. if (wm_pid && process_is_alive(wm_pid) &&
  1159. !process_is_sleeping(wm_pid) && wm_attached &&
  1160. now - wm_last_seen > 15000) {
  1161. serial_puts(SERIAL_COM1, "wm: watchdog, killing WM\n");
  1162. process_kill(wm_pid);
  1163. }
  1164. if (wm_pid && !process_is_alive(wm_pid))
  1165. wm_server_wm_died();
  1166. /* Owner processes that exited close their windows. Only at a safe
  1167. * point: the WM may still be between INFO/MAP and PRESENT. */
  1168. if (wm_server_can_reap()) {
  1169. for (i = 0; i < MAX_WINDOWS; i++) {
  1170. struct window *w = &windows[i];
  1171. if (!w->used || !w->pid || process_is_alive(w->pid))
  1172. continue;
  1173. if (w->canvas_window)
  1174. w->owner_cr3 = 0; /* cr3 is gone/reaped */
  1175. wm_close_window(i);
  1176. }
  1177. }
  1178. }
  1179. void wm_server_init(void)
  1180. {
  1181. unsigned int i;
  1182. for (i = 0; i < MAX_WINDOWS; i++) {
  1183. windows[i].used = 0;
  1184. windows[i].mapped_kind = WM_KIND_NONE;
  1185. windows[i].mapped_gen = 0;
  1186. windows[i].mapped_pages = 0;
  1187. windows[i].mapped_src = 0;
  1188. }
  1189. wm_full_redraw = 1;
  1190. wm_boot_ready = 0;
  1191. wm_ptr_buttons = 0;
  1192. wm_ptr_capture = -1;
  1193. wm_pid = 0;
  1194. wm_cr3 = 0;
  1195. wm_attached = 0;
  1196. wm_frame_active = 0;
  1197. wm_first_frame = 0;
  1198. /* The ring-3 WM spawns the first terminal once wm_server_boot_ready()
  1199. * says the storage scan is done. */
  1200. }
  1201. static int wm_point_in_rect(int px, int py,
  1202. int rx, int ry, unsigned int rw, unsigned int rh)
  1203. {
  1204. return px >= rx && px < rx + (int)rw &&
  1205. py >= ry && py < ry + (int)rh;
  1206. }
  1207. static void wm_focus_index(unsigned int idx)
  1208. {
  1209. unsigned int i;
  1210. if (windows[idx].used && windows[idx].focused)
  1211. return;
  1212. for (i = 0; i < MAX_WINDOWS; i++) {
  1213. int now = windows[i].used && (i == idx);
  1214. if (!windows[i].used || windows[i].focused == now)
  1215. continue;
  1216. windows[i].focused = now;
  1217. }
  1218. wm_request_redraw();
  1219. }
  1220. static void wm_focus_top(void)
  1221. {
  1222. unsigned int i;
  1223. /* With no explicit z-order the highest used slot is painted last, so
  1224. * it is the topmost window left after a close. */
  1225. for (i = MAX_WINDOWS; i-- > 0; )
  1226. if (windows[i].used) {
  1227. wm_focus_index(i);
  1228. return;
  1229. }
  1230. }
  1231. static void wm_close_window(unsigned int idx)
  1232. {
  1233. struct window *w = &windows[idx];
  1234. int was_focused = w->focused;
  1235. if (wm_ptr_capture == (int)idx)
  1236. wm_ptr_capture = -1;
  1237. wait_wake_all(&w->key_wq);
  1238. if (w->canvas_window) {
  1239. if (w->pid)
  1240. process_kill(w->pid);
  1241. wm_server_unmap_index(idx);
  1242. wm_free_canvas_window(idx);
  1243. } else if (w->pid) {
  1244. process_kill(w->pid);
  1245. }
  1246. wm_server_unmap_index(idx);
  1247. w->used = 0;
  1248. w->pid = 0;
  1249. w->focused = 0;
  1250. w->content_gen++;
  1251. w->mapped_kind = WM_KIND_NONE;
  1252. w->mapped_gen = 0;
  1253. w->mapped_pages = 0;
  1254. w->mapped_src = 0;
  1255. if (was_focused)
  1256. wm_focus_top();
  1257. wm_request_redraw();
  1258. }
  1259. /* Topmost window containing (px,py), or -1. A popover overrides the normal
  1260. * focus/slot order: it is an overlay panel and always receives the click. */
  1261. static int wm_window_at(int px, int py)
  1262. {
  1263. unsigned int i;
  1264. for (i = 0; i < MAX_WINDOWS; i++)
  1265. if (windows[i].used && windows[i].popover &&
  1266. wm_point_in_rect(px, py, windows[i].x, windows[i].y,
  1267. windows[i].pw, windows[i].ph))
  1268. return (int)i;
  1269. for (i = 0; i < MAX_WINDOWS; i++)
  1270. if (windows[i].used && windows[i].focused &&
  1271. wm_point_in_rect(px, py, windows[i].x, windows[i].y,
  1272. windows[i].pw, windows[i].ph))
  1273. return (int)i;
  1274. /* Inactive windows are painted in slot order, so the highest slot is
  1275. * the topmost one under the cursor. */
  1276. for (i = MAX_WINDOWS; i-- > 0; )
  1277. if (windows[i].used && !windows[i].focused &&
  1278. wm_point_in_rect(px, py, windows[i].x, windows[i].y,
  1279. windows[i].pw, windows[i].ph))
  1280. return (int)i;
  1281. return -1;
  1282. }
  1283. /* Resize band of a normal window: WM_RESIZE_IN px inside and WM_RESIZE_OUT
  1284. * px outside every edge. Mirrors the ring-3 WM's resize_edges_at(). */
  1285. static int wm_in_resize_band(const struct window *w, int mx, int my)
  1286. {
  1287. int l = w->x, t = w->y;
  1288. int r = l + (int)w->pw, b = t + (int)w->ph;
  1289. int near_x, near_y;
  1290. if (w->popover || my < WM_BAR_H)
  1291. return 0;
  1292. near_x = mx >= l - WM_RESIZE_OUT && mx < r + WM_RESIZE_OUT;
  1293. near_y = my >= t - WM_RESIZE_OUT && my < b + WM_RESIZE_OUT;
  1294. return (near_y && mx >= l - WM_RESIZE_OUT && mx < l + WM_RESIZE_IN) ||
  1295. (near_y && mx >= r - WM_RESIZE_IN && mx < r + WM_RESIZE_OUT) ||
  1296. (near_x && my >= t - WM_RESIZE_OUT && my < t + WM_RESIZE_IN) ||
  1297. (near_x && my >= b - WM_RESIZE_IN && my < b + WM_RESIZE_OUT);
  1298. }
  1299. static int wm_hit_one(struct window *w, int mx, int my, int *edges)
  1300. {
  1301. *edges = 0;
  1302. if (!w->used)
  1303. return 0;
  1304. if (wm_in_resize_band(w, mx, my)) {
  1305. *edges = 1;
  1306. return 1;
  1307. }
  1308. return wm_point_in_rect(mx, my, w->x, w->y, w->pw, w->ph);
  1309. }
  1310. /* Topmost window for a pointer position, in the WM's painting order. A
  1311. * resize band wins over a plain rectangle hit, so a front window's outside
  1312. * band is not stolen by a window behind it. *edges is 1 for a band hit. */
  1313. static int wm_resize_target(int px, int py, int *edges)
  1314. {
  1315. unsigned int i;
  1316. *edges = 0;
  1317. for (i = 0; i < MAX_WINDOWS; i++)
  1318. if (windows[i].popover &&
  1319. wm_hit_one(&windows[i], px, py, edges))
  1320. return (int)i;
  1321. for (i = 0; i < MAX_WINDOWS; i++)
  1322. if (windows[i].focused && !windows[i].popover &&
  1323. wm_hit_one(&windows[i], px, py, edges))
  1324. return (int)i;
  1325. for (i = MAX_WINDOWS; i-- > 0;)
  1326. if (!windows[i].focused && !windows[i].popover &&
  1327. wm_hit_one(&windows[i], px, py, edges))
  1328. return (int)i;
  1329. return -1;
  1330. }
  1331. static void wm_clamp_window(struct window *w, int nx, int ny)
  1332. {
  1333. int fbw = (int)vga_fb_width();
  1334. int fbh = (int)vga_fb_height();
  1335. /* Allow a window to hang off the left, right and bottom edges, but
  1336. * keep a strip of the title bar reachable and never let it overlap the
  1337. * system bar at the top. */
  1338. int minx = WM_DRAG_VISIBLE - (int)w->pw;
  1339. int maxx = fbw - WM_DRAG_VISIBLE;
  1340. int miny = WM_BAR_H;
  1341. int maxy = fbh - WM_BORDER_W - WM_TITLE_H;
  1342. if (w->popover) {
  1343. /* A popover is an overlay panel: keep all of it on screen,
  1344. * flush under the bar and against the right edge. */
  1345. minx = 0;
  1346. maxx = fbw - (int)w->pw;
  1347. miny = WM_BAR_H;
  1348. maxy = fbh - (int)w->ph;
  1349. if (minx > maxx)
  1350. minx = maxx = 0;
  1351. if (miny > maxy)
  1352. miny = maxy = WM_BAR_H + 2;
  1353. if (nx < minx)
  1354. nx = minx;
  1355. else if (nx > maxx)
  1356. nx = maxx;
  1357. if (ny < miny)
  1358. ny = miny;
  1359. else if (ny > maxy)
  1360. ny = maxy;
  1361. w->x = nx;
  1362. w->y = ny;
  1363. return;
  1364. }
  1365. if (minx > maxx)
  1366. minx = maxx = 0;
  1367. if (miny > maxy)
  1368. miny = maxy = WM_BAR_H;
  1369. if (nx < minx)
  1370. nx = minx;
  1371. else if (nx > maxx)
  1372. nx = maxx;
  1373. if (ny < miny)
  1374. ny = miny;
  1375. else if (ny > maxy)
  1376. ny = maxy;
  1377. w->x = nx;
  1378. w->y = ny;
  1379. }
  1380. /* Fill the intersection of rect (rx,ry,rw,rh) with clip rect (cx,cy,cw,ch). */
  1381. /* Repaint the desktop rectangle (x, y, w, h): background, then every
  1382. intersecting window back-to-front (focused last), then mark it dirty. The
  1383. caller handles the mouse cursor. The rect must lie below the system bar
  1384. (windows are clamped to y >= WM_BAR_H, so the bar is never overlapped and
  1385. needs no clip variant). */
  1386. /* Move a window in the shadow buffer: copy its rect, redraw the exposed
  1387. sliver, keep the cursor on top, and flush the swept band immediately so a
  1388. drag step is always one consistent frame (a budgeted flush would copy only
  1389. the top rows of the band per iteration and the window would appear to
  1390. stretch while the mouse keeps moving). */
  1391. void wm_pump_keyboard(void)
  1392. {
  1393. struct window *fw = wm_focused_window();
  1394. static unsigned int last_hw_poll;
  1395. unsigned int now = get_ticks_ms();
  1396. int n;
  1397. if (io_keyboard_raw())
  1398. return; /* an inline command is polling for keys itself */
  1399. if (!fw)
  1400. return;
  1401. for (n = 0; n < 8; n++) {
  1402. int k = io_poll_key();
  1403. if (!k && (now - last_hw_poll) >= (io_keyboard_irq_masked() ? 5 : 50)) {
  1404. /* Fallback paths: IRQ1 was storm-masked, or no IRQ is
  1405. * delivering; sample the controller directly (faster
  1406. * when masked, so fast typing isn't dropped). */
  1407. k = io_poll_key_with_hw();
  1408. last_hw_poll = now;
  1409. }
  1410. if (!k)
  1411. break;
  1412. if (fw->canvas_window) {
  1413. unsigned int next = (fw->key_head + 1) % 16;
  1414. if (next != fw->key_tail) {
  1415. fw->keys[fw->key_head] = k;
  1416. fw->key_head = next;
  1417. }
  1418. wait_wake_one(&fw->key_wq);
  1419. }
  1420. }
  1421. }
  1422. void wm_handle_kexec(void)
  1423. {
  1424. if (kexec_busy)
  1425. return;
  1426. /* A command pack for /ramfs (checked before kexec: both start with
  1427. * 'K', and the kexec detector drops anything that is not KXE2). */
  1428. if (payload_pending()) {
  1429. kexec_busy = 1;
  1430. if (process_create("payload", program_payload_main) < 0)
  1431. kexec_busy = 0;
  1432. return;
  1433. }
  1434. if (kexec_pending()) {
  1435. kexec_busy = 1;
  1436. if (process_create("kexec", program_kexec_main) < 0)
  1437. kexec_busy = 0;
  1438. return;
  1439. }
  1440. /* Same over UDP: the host's `make net-dev` is picked up from here. */
  1441. if (netkexec_pending()) {
  1442. kexec_busy = 1;
  1443. if (process_create("netkexec", program_netkexec_main) < 0)
  1444. kexec_busy = 0;
  1445. }
  1446. }