sys_wm.c 5.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279
  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 "paging.h"
  6. #include "process.h"
  7. #include "wm.h"
  8. #include "serial.h"
  9. #include "timer.h"
  10. static int user_ok(const void *p, unsigned int size, int write)
  11. {
  12. return paging_user_range_ok(current_proc()->cr3,
  13. (unsigned int)p, size, write);
  14. }
  15. static void copy_to_user(void *dst, const void *src, unsigned int n)
  16. {
  17. unsigned char *d = (unsigned char *)dst;
  18. const unsigned char *s = (const unsigned char *)src;
  19. while (n--)
  20. *d++ = *s++;
  21. }
  22. static void copy_from_user(void *dst, const void *src, unsigned int n)
  23. {
  24. unsigned char *d = (unsigned char *)dst;
  25. const unsigned char *s = (const unsigned char *)src;
  26. while (n--)
  27. *d++ = *s++;
  28. }
  29. static void zero_struct(void *p, unsigned int n)
  30. {
  31. unsigned char *d = (unsigned char *)p;
  32. while (n--)
  33. *d++ = 0;
  34. }
  35. int sys_wm_attach(struct wm_screen_info *out)
  36. {
  37. struct wm_screen_info info;
  38. int r;
  39. if (!user_ok(out, sizeof(info), 1))
  40. return -1;
  41. zero_struct(&info, sizeof(info));
  42. r = wm_server_attach(&info);
  43. if (r == 0)
  44. copy_to_user(out, &info, sizeof(info));
  45. return r;
  46. }
  47. int sys_wm_info(unsigned int index, struct wm_window_info *out)
  48. {
  49. struct wm_window_info info;
  50. int r;
  51. if (!user_ok(out, sizeof(info), 1))
  52. return -1;
  53. zero_struct(&info, sizeof(info));
  54. r = wm_server_info(index, &info);
  55. if (r >= 0)
  56. copy_to_user(out, &info, sizeof(info));
  57. return r;
  58. }
  59. int sys_wm_map(unsigned int index, struct wm_map_info *out)
  60. {
  61. struct wm_map_info info;
  62. int r;
  63. if (!user_ok(out, sizeof(info), 1))
  64. return -1;
  65. zero_struct(&info, sizeof(info));
  66. r = wm_server_map(index, &info);
  67. if (r == 0)
  68. copy_to_user(out, &info, sizeof(info));
  69. return r;
  70. }
  71. int sys_wm_ack(unsigned int index, unsigned int seq)
  72. {
  73. return wm_server_ack(index, seq);
  74. }
  75. int sys_wm_focus(unsigned int index)
  76. {
  77. return wm_server_focus(index);
  78. }
  79. int sys_wm_set_geom(unsigned int index, const struct wm_geom *in)
  80. {
  81. struct wm_geom g;
  82. if (!user_ok(in, sizeof(g), 0))
  83. return -1;
  84. copy_from_user(&g, in, sizeof(g));
  85. return wm_server_set_geom(index, g.x, g.y);
  86. }
  87. int sys_wm_create_term(void)
  88. {
  89. return wm_server_create_term();
  90. }
  91. int sys_wm_close(unsigned int index)
  92. {
  93. return wm_server_close(index);
  94. }
  95. int sys_wm_poll(struct wm_status *out)
  96. {
  97. struct wm_status st;
  98. int r;
  99. if (!user_ok(out, sizeof(st), 1))
  100. return -1;
  101. zero_struct(&st, sizeof(st));
  102. r = wm_server_poll(&st);
  103. if (r == 0)
  104. copy_to_user(out, &st, sizeof(st));
  105. return r;
  106. }
  107. int sys_wm_begin(void)
  108. {
  109. return wm_server_begin();
  110. }
  111. int sys_wm_present(const struct wm_present_info *in)
  112. {
  113. struct wm_present_info p;
  114. if (!user_ok(in, sizeof(p), 0))
  115. return -1;
  116. copy_from_user(&p, in, sizeof(p));
  117. return wm_server_present(&p);
  118. }
  119. int sys_wm_key_poll(void)
  120. {
  121. return wm_server_key_poll();
  122. }
  123. int sys_wm_sync(void)
  124. {
  125. return wm_server_sync();
  126. }
  127. int sys_win_create(const struct win_create *in, struct win_info *out)
  128. {
  129. struct win_create create;
  130. struct win_info info;
  131. int r;
  132. if (!user_ok(in, sizeof(create), 0) ||
  133. !user_ok(out, sizeof(info), 1))
  134. return -1;
  135. copy_from_user(&create, in, sizeof(create));
  136. zero_struct(&info, sizeof(info));
  137. r = wm_server_win_create(&create, &info);
  138. if (r == 0)
  139. copy_to_user(out, &info, sizeof(info));
  140. return r;
  141. }
  142. /* One serial line when the first application window (normally the boot
  143. * terminal) presents a frame: the end point of the boot-time measurement
  144. * ("[boot] ..." lines are relative to the PIT start, this is uptime). */
  145. static void boot_first_present(void)
  146. {
  147. static int done;
  148. if (done)
  149. return;
  150. done = 1;
  151. serial_puts(SERIAL_COM1, "wm: first window frame (");
  152. serial_puts(SERIAL_COM1, current_proc()->name);
  153. serial_puts(SERIAL_COM1, ") at ");
  154. serial_putdec(SERIAL_COM1, get_ticks_ms());
  155. serial_puts(SERIAL_COM1, " ms\n");
  156. }
  157. int sys_win_present(const struct wm_win_present *in)
  158. {
  159. struct wm_win_present p;
  160. boot_first_present();
  161. if (!in)
  162. return wm_server_win_present(0);
  163. if (!user_ok(in, sizeof(p), 0))
  164. return -1;
  165. copy_from_user(&p, in, sizeof(p));
  166. return wm_server_win_present(&p);
  167. }
  168. int sys_win_close(void)
  169. {
  170. return wm_server_win_close();
  171. }
  172. int sys_win_info(struct win_info *out)
  173. {
  174. struct win_info info;
  175. int r;
  176. if (!user_ok(out, sizeof(info), 1))
  177. return -1;
  178. zero_struct(&info, sizeof(info));
  179. r = wm_server_win_info(&info);
  180. if (r == 0)
  181. copy_to_user(out, &info, sizeof(info));
  182. return r;
  183. }
  184. int sys_win_ack_resize(void)
  185. {
  186. return wm_server_win_ack_resize();
  187. }
  188. int sys_win_pointer(struct win_pointer *out)
  189. {
  190. struct win_pointer p;
  191. int r;
  192. if (!user_ok(out, sizeof(p), 1))
  193. return -1;
  194. zero_struct(&p, sizeof(p));
  195. r = wm_server_win_pointer(&p);
  196. if (r == 0)
  197. copy_to_user(out, &p, sizeof(p));
  198. return r;
  199. }
  200. int sys_win_event(struct win_event *out)
  201. {
  202. struct win_event e;
  203. int r;
  204. if (!user_ok(out, sizeof(e), 1))
  205. return -1;
  206. zero_struct(&e, sizeof(e));
  207. r = wm_server_win_event(&e);
  208. if (r == 1)
  209. copy_to_user(out, &e, sizeof(e));
  210. return r;
  211. }
  212. int sys_win_scroll(struct win_scroll *out)
  213. {
  214. struct win_scroll s;
  215. int r;
  216. if (!user_ok(out, sizeof(s), 1))
  217. return -1;
  218. zero_struct(&s, sizeof(s));
  219. r = wm_server_win_scroll(&s);
  220. if (r >= 0)
  221. copy_to_user(out, &s, sizeof(s));
  222. return r;
  223. }
  224. int sys_wm_resize(unsigned int index, const struct wm_size *in)
  225. {
  226. struct wm_size s;
  227. if (!user_ok(in, sizeof(s), 0))
  228. return -1;
  229. copy_from_user(&s, in, sizeof(s));
  230. return wm_server_resize(index, s.w, s.h);
  231. }
  232. int sys_win_key_wait(unsigned int timeout_ms)
  233. {
  234. return wm_server_key_wait(timeout_ms);
  235. }