sys_wm.c 6.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348
  1. /* Syscall wrappers for the ring-3 window manager. User pointers are checked
  2. * against the caller's page tables and copied before the kernel touches them;
  3. * a buggy WM returns -1 instead of faulting in ring 0. */
  4. #include "sys_wm.h"
  5. #include "syscall.h"
  6. #include "paging.h"
  7. #include "process.h"
  8. #include "wm.h"
  9. #include "serial.h"
  10. #include "timer.h"
  11. static int user_ok(const void *p, unsigned int size, int write)
  12. {
  13. return paging_user_range_ok(current_proc()->cr3,
  14. (unsigned int)p, size, write);
  15. }
  16. static void copy_to_user(void *dst, const void *src, unsigned int n)
  17. {
  18. unsigned char *d = (unsigned char *)dst;
  19. const unsigned char *s = (const unsigned char *)src;
  20. while (n--)
  21. *d++ = *s++;
  22. }
  23. static void copy_from_user(void *dst, const void *src, unsigned int n)
  24. {
  25. unsigned char *d = (unsigned char *)dst;
  26. const unsigned char *s = (const unsigned char *)src;
  27. while (n--)
  28. *d++ = *s++;
  29. }
  30. static void zero_struct(void *p, unsigned int n)
  31. {
  32. unsigned char *d = (unsigned char *)p;
  33. while (n--)
  34. *d++ = 0;
  35. }
  36. int sys_wm_attach(struct wm_screen_info *out)
  37. {
  38. struct wm_screen_info info;
  39. int r;
  40. if (!user_ok(out, sizeof(info), 1))
  41. return -1;
  42. zero_struct(&info, sizeof(info));
  43. r = wm_server_attach(&info);
  44. if (r == 0)
  45. copy_to_user(out, &info, sizeof(info));
  46. return r;
  47. }
  48. int sys_wm_info(unsigned int index, struct wm_window_info *out)
  49. {
  50. struct wm_window_info info;
  51. int r;
  52. if (!user_ok(out, sizeof(info), 1))
  53. return -1;
  54. zero_struct(&info, sizeof(info));
  55. r = wm_server_info(index, &info);
  56. if (r >= 0)
  57. copy_to_user(out, &info, sizeof(info));
  58. return r;
  59. }
  60. int sys_wm_map(unsigned int index, struct wm_map_info *out)
  61. {
  62. struct wm_map_info info;
  63. int r;
  64. if (!user_ok(out, sizeof(info), 1))
  65. return -1;
  66. zero_struct(&info, sizeof(info));
  67. r = wm_server_map(index, &info);
  68. if (r == 0)
  69. copy_to_user(out, &info, sizeof(info));
  70. return r;
  71. }
  72. int sys_wm_ack(unsigned int index, unsigned int seq)
  73. {
  74. return wm_server_ack(index, seq);
  75. }
  76. int sys_wm_focus(unsigned int index)
  77. {
  78. return wm_server_focus(index);
  79. }
  80. int sys_wm_set_geom(unsigned int index, const struct wm_geom *in)
  81. {
  82. struct wm_geom g;
  83. if (!user_ok(in, sizeof(g), 0))
  84. return -1;
  85. copy_from_user(&g, in, sizeof(g));
  86. return wm_server_set_geom(index, g.x, g.y);
  87. }
  88. int sys_wm_create_term(void)
  89. {
  90. return wm_server_create_term();
  91. }
  92. int sys_wm_close(unsigned int index)
  93. {
  94. return wm_server_close(index);
  95. }
  96. int sys_wm_poll(struct wm_status *out)
  97. {
  98. struct wm_status st;
  99. int r;
  100. if (!user_ok(out, sizeof(st), 1))
  101. return -1;
  102. zero_struct(&st, sizeof(st));
  103. r = wm_server_poll(&st);
  104. if (r == 0)
  105. copy_to_user(out, &st, sizeof(st));
  106. return r;
  107. }
  108. int sys_wm_begin(void)
  109. {
  110. return wm_server_begin();
  111. }
  112. int sys_wm_present(const struct wm_present_info *in)
  113. {
  114. struct wm_present_info p;
  115. if (!user_ok(in, sizeof(p), 0))
  116. return -1;
  117. copy_from_user(&p, in, sizeof(p));
  118. return wm_server_present(&p);
  119. }
  120. int sys_wm_key_poll(void)
  121. {
  122. return wm_server_key_poll();
  123. }
  124. int sys_wm_sync(void)
  125. {
  126. return wm_server_sync();
  127. }
  128. int sys_win_create(const struct win_create *in, struct win_info *out)
  129. {
  130. struct win_create create;
  131. struct win_info info;
  132. int r;
  133. if (!user_ok(in, sizeof(create), 0) ||
  134. !user_ok(out, sizeof(info), 1))
  135. return -1;
  136. copy_from_user(&create, in, sizeof(create));
  137. zero_struct(&info, sizeof(info));
  138. r = wm_server_win_create(&create, &info);
  139. if (r == 0)
  140. copy_to_user(out, &info, sizeof(info));
  141. return r;
  142. }
  143. /* One serial line when the first terminal presents a frame: the end point of
  144. * the boot-time measurement ("[boot] ..." lines are relative to the PIT
  145. * start, this is uptime). The bootscan log window presents before it and is
  146. * deliberately not counted here. */
  147. volatile int wm_first_window_presented;
  148. static int is_term_proc(void)
  149. {
  150. const char *n = current_proc() ? current_proc()->name : "";
  151. return n[0] == 't' && n[1] == 'e' && n[2] == 'r' && n[3] == 'm' &&
  152. n[4] == '\0';
  153. }
  154. static void boot_first_present(void)
  155. {
  156. static int done;
  157. if (done || !is_term_proc())
  158. return;
  159. done = 1;
  160. wm_first_window_presented = 1;
  161. serial_puts(SERIAL_COM1, "wm: first window frame (");
  162. serial_puts(SERIAL_COM1, current_proc()->name);
  163. serial_puts(SERIAL_COM1, ") at ");
  164. serial_putdec(SERIAL_COM1, get_ticks_ms());
  165. serial_puts(SERIAL_COM1, " ms\n");
  166. }
  167. int sys_win_present(const struct wm_win_present *in)
  168. {
  169. struct wm_win_present p;
  170. boot_first_present();
  171. if (!in)
  172. return wm_server_win_present(0);
  173. if (!user_ok(in, sizeof(p), 0))
  174. return -1;
  175. copy_from_user(&p, in, sizeof(p));
  176. return wm_server_win_present(&p);
  177. }
  178. int sys_win_close(void)
  179. {
  180. return wm_server_win_close();
  181. }
  182. int sys_win_info(struct win_info *out)
  183. {
  184. struct win_info info;
  185. int r;
  186. if (!user_ok(out, sizeof(info), 1))
  187. return -1;
  188. zero_struct(&info, sizeof(info));
  189. r = wm_server_win_info(&info);
  190. if (r == 0)
  191. copy_to_user(out, &info, sizeof(info));
  192. return r;
  193. }
  194. int sys_win_ack_resize(void)
  195. {
  196. return wm_server_win_ack_resize();
  197. }
  198. int sys_win_pointer(struct win_pointer *out)
  199. {
  200. struct win_pointer p;
  201. int r;
  202. if (!user_ok(out, sizeof(p), 1))
  203. return -1;
  204. zero_struct(&p, sizeof(p));
  205. r = wm_server_win_pointer(&p);
  206. if (r == 0)
  207. copy_to_user(out, &p, sizeof(p));
  208. return r;
  209. }
  210. int sys_win_event(struct win_event *out)
  211. {
  212. struct win_event e;
  213. int r;
  214. if (!user_ok(out, sizeof(e), 1))
  215. return -1;
  216. zero_struct(&e, sizeof(e));
  217. r = wm_server_win_event(&e);
  218. if (r == 1)
  219. copy_to_user(out, &e, sizeof(e));
  220. return r;
  221. }
  222. int sys_win_scroll(struct win_scroll *out)
  223. {
  224. struct win_scroll s;
  225. int r;
  226. if (!user_ok(out, sizeof(s), 1))
  227. return -1;
  228. zero_struct(&s, sizeof(s));
  229. r = wm_server_win_scroll(&s);
  230. if (r >= 0)
  231. copy_to_user(out, &s, sizeof(s));
  232. return r;
  233. }
  234. int sys_wm_resize(unsigned int index, const struct wm_size *in)
  235. {
  236. struct wm_size s;
  237. if (!user_ok(in, sizeof(s), 0))
  238. return -1;
  239. copy_from_user(&s, in, sizeof(s));
  240. return wm_server_resize(index, s.w, s.h, s.dx, s.dy);
  241. }
  242. int sys_win_key_wait(unsigned int timeout_ms)
  243. {
  244. return wm_server_key_wait(timeout_ms);
  245. }
  246. int sys_win_resize_self(unsigned int w, unsigned int h)
  247. {
  248. return wm_server_win_resize_self(w, h);
  249. }
  250. int sys_win_set_cursor(int shape)
  251. {
  252. return wm_server_win_set_cursor(shape);
  253. }
  254. int sys_wm_set_cursor(int shape)
  255. {
  256. return wm_server_set_cursor(shape);
  257. }
  258. int sys_wm_mouse_capture(int on)
  259. {
  260. return wm_server_set_pointer_capture(on);
  261. }
  262. int sys_wm_wallpaper(int op)
  263. {
  264. if (op != 1)
  265. return -1;
  266. wm_server_wallpaper_changed();
  267. return 0;
  268. }
  269. int sys_wm_prefs(int op, void *arg)
  270. {
  271. struct wm_prefs p;
  272. if (op == SYS_WM_PREFS_GET) {
  273. if (!user_ok(arg, sizeof(p), 1))
  274. return -1;
  275. if (wm_server_prefs_get(&p) != 0)
  276. return -1;
  277. copy_to_user(arg, &p, sizeof(p));
  278. return 0;
  279. }
  280. if (op == SYS_WM_PREFS_SET) {
  281. if (!user_ok(arg, sizeof(p), 0))
  282. return -1;
  283. copy_from_user(&p, arg, sizeof(p));
  284. return wm_server_prefs_set(&p);
  285. }
  286. return -1;
  287. }
  288. int sys_wm_open_settings(int section)
  289. {
  290. if (section < 0 || section >= WM_SETTINGS_COUNT)
  291. return -1;
  292. return wm_server_open_settings((unsigned int)section);
  293. }