breakpoint_test.c 7.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401
  1. /*
  2. * Copyright (C) 2011 Red Hat, Inc., Frederic Weisbecker <fweisbec@redhat.com>
  3. *
  4. * Licensed under the terms of the GNU GPL License version 2
  5. *
  6. * Selftests for breakpoints (and more generally the do_debug() path) in x86.
  7. */
  8. #include <sys/ptrace.h>
  9. #include <unistd.h>
  10. #include <stddef.h>
  11. #include <sys/user.h>
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <signal.h>
  15. #include <sys/types.h>
  16. #include <sys/wait.h>
  17. #include <errno.h>
  18. #include <string.h>
  19. #include "../kselftest.h"
  20. /* Breakpoint access modes */
  21. enum {
  22. BP_X = 1,
  23. BP_RW = 2,
  24. BP_W = 4,
  25. };
  26. static pid_t child_pid;
  27. /*
  28. * Ensures the child and parent are always "talking" about
  29. * the same test sequence. (ie: that we haven't forgotten
  30. * to call check_trapped() somewhere).
  31. */
  32. static int nr_tests;
  33. static void set_breakpoint_addr(void *addr, int n)
  34. {
  35. int ret;
  36. ret = ptrace(PTRACE_POKEUSER, child_pid,
  37. offsetof(struct user, u_debugreg[n]), addr);
  38. if (ret)
  39. ksft_exit_fail_msg("Can't set breakpoint addr: %s\n",
  40. strerror(errno));
  41. }
  42. static void toggle_breakpoint(int n, int type, int len,
  43. int local, int global, int set)
  44. {
  45. int ret;
  46. int xtype, xlen;
  47. unsigned long vdr7, dr7;
  48. switch (type) {
  49. case BP_X:
  50. xtype = 0;
  51. break;
  52. case BP_W:
  53. xtype = 1;
  54. break;
  55. case BP_RW:
  56. xtype = 3;
  57. break;
  58. }
  59. switch (len) {
  60. case 1:
  61. xlen = 0;
  62. break;
  63. case 2:
  64. xlen = 4;
  65. break;
  66. case 4:
  67. xlen = 0xc;
  68. break;
  69. case 8:
  70. xlen = 8;
  71. break;
  72. }
  73. dr7 = ptrace(PTRACE_PEEKUSER, child_pid,
  74. offsetof(struct user, u_debugreg[7]), 0);
  75. vdr7 = (xlen | xtype) << 16;
  76. vdr7 <<= 4 * n;
  77. if (local) {
  78. vdr7 |= 1 << (2 * n);
  79. vdr7 |= 1 << 8;
  80. }
  81. if (global) {
  82. vdr7 |= 2 << (2 * n);
  83. vdr7 |= 1 << 9;
  84. }
  85. if (set)
  86. dr7 |= vdr7;
  87. else
  88. dr7 &= ~vdr7;
  89. ret = ptrace(PTRACE_POKEUSER, child_pid,
  90. offsetof(struct user, u_debugreg[7]), dr7);
  91. if (ret) {
  92. ksft_print_msg("Can't set dr7: %s\n", strerror(errno));
  93. exit(-1);
  94. }
  95. }
  96. /* Dummy variables to test read/write accesses */
  97. static unsigned long long dummy_var[4];
  98. /* Dummy functions to test execution accesses */
  99. static void dummy_func(void) { }
  100. static void dummy_func1(void) { }
  101. static void dummy_func2(void) { }
  102. static void dummy_func3(void) { }
  103. static void (*dummy_funcs[])(void) = {
  104. dummy_func,
  105. dummy_func1,
  106. dummy_func2,
  107. dummy_func3,
  108. };
  109. static int trapped;
  110. static void check_trapped(void)
  111. {
  112. /*
  113. * If we haven't trapped, wake up the parent
  114. * so that it notices the failure.
  115. */
  116. if (!trapped)
  117. kill(getpid(), SIGUSR1);
  118. trapped = 0;
  119. nr_tests++;
  120. }
  121. static void write_var(int len)
  122. {
  123. char *pcval; short *psval; int *pival; long long *plval;
  124. int i;
  125. for (i = 0; i < 4; i++) {
  126. switch (len) {
  127. case 1:
  128. pcval = (char *)&dummy_var[i];
  129. *pcval = 0xff;
  130. break;
  131. case 2:
  132. psval = (short *)&dummy_var[i];
  133. *psval = 0xffff;
  134. break;
  135. case 4:
  136. pival = (int *)&dummy_var[i];
  137. *pival = 0xffffffff;
  138. break;
  139. case 8:
  140. plval = (long long *)&dummy_var[i];
  141. *plval = 0xffffffffffffffffLL;
  142. break;
  143. }
  144. check_trapped();
  145. }
  146. }
  147. static void read_var(int len)
  148. {
  149. char cval; short sval; int ival; long long lval;
  150. int i;
  151. for (i = 0; i < 4; i++) {
  152. switch (len) {
  153. case 1:
  154. cval = *(char *)&dummy_var[i];
  155. break;
  156. case 2:
  157. sval = *(short *)&dummy_var[i];
  158. break;
  159. case 4:
  160. ival = *(int *)&dummy_var[i];
  161. break;
  162. case 8:
  163. lval = *(long long *)&dummy_var[i];
  164. break;
  165. }
  166. check_trapped();
  167. }
  168. }
  169. /*
  170. * Do the r/w/x accesses to trigger the breakpoints. And run
  171. * the usual traps.
  172. */
  173. static void trigger_tests(void)
  174. {
  175. int len, local, global, i;
  176. char val;
  177. int ret;
  178. ret = ptrace(PTRACE_TRACEME, 0, NULL, 0);
  179. if (ret) {
  180. ksft_print_msg("Can't be traced? %s\n", strerror(errno));
  181. return;
  182. }
  183. /* Wake up father so that it sets up the first test */
  184. kill(getpid(), SIGUSR1);
  185. /* Test instruction breakpoints */
  186. for (local = 0; local < 2; local++) {
  187. for (global = 0; global < 2; global++) {
  188. if (!local && !global)
  189. continue;
  190. for (i = 0; i < 4; i++) {
  191. dummy_funcs[i]();
  192. check_trapped();
  193. }
  194. }
  195. }
  196. /* Test write watchpoints */
  197. for (len = 1; len <= sizeof(long); len <<= 1) {
  198. for (local = 0; local < 2; local++) {
  199. for (global = 0; global < 2; global++) {
  200. if (!local && !global)
  201. continue;
  202. write_var(len);
  203. }
  204. }
  205. }
  206. /* Test read/write watchpoints (on read accesses) */
  207. for (len = 1; len <= sizeof(long); len <<= 1) {
  208. for (local = 0; local < 2; local++) {
  209. for (global = 0; global < 2; global++) {
  210. if (!local && !global)
  211. continue;
  212. read_var(len);
  213. }
  214. }
  215. }
  216. /* Icebp trap */
  217. asm(".byte 0xf1\n");
  218. check_trapped();
  219. /* Int 3 trap */
  220. asm("int $3\n");
  221. check_trapped();
  222. kill(getpid(), SIGUSR1);
  223. }
  224. static void check_success(const char *msg)
  225. {
  226. int child_nr_tests;
  227. int status;
  228. int ret;
  229. /* Wait for the child to SIGTRAP */
  230. wait(&status);
  231. ret = 0;
  232. if (WSTOPSIG(status) == SIGTRAP) {
  233. child_nr_tests = ptrace(PTRACE_PEEKDATA, child_pid,
  234. &nr_tests, 0);
  235. if (child_nr_tests == nr_tests)
  236. ret = 1;
  237. if (ptrace(PTRACE_POKEDATA, child_pid, &trapped, 1))
  238. ksft_exit_fail_msg("Can't poke: %s\n", strerror(errno));
  239. }
  240. nr_tests++;
  241. if (ret)
  242. ksft_test_result_pass(msg);
  243. else
  244. ksft_test_result_fail(msg);
  245. }
  246. static void launch_instruction_breakpoints(char *buf, int local, int global)
  247. {
  248. int i;
  249. for (i = 0; i < 4; i++) {
  250. set_breakpoint_addr(dummy_funcs[i], i);
  251. toggle_breakpoint(i, BP_X, 1, local, global, 1);
  252. ptrace(PTRACE_CONT, child_pid, NULL, 0);
  253. sprintf(buf, "Test breakpoint %d with local: %d global: %d\n",
  254. i, local, global);
  255. check_success(buf);
  256. toggle_breakpoint(i, BP_X, 1, local, global, 0);
  257. }
  258. }
  259. static void launch_watchpoints(char *buf, int mode, int len,
  260. int local, int global)
  261. {
  262. const char *mode_str;
  263. int i;
  264. if (mode == BP_W)
  265. mode_str = "write";
  266. else
  267. mode_str = "read";
  268. for (i = 0; i < 4; i++) {
  269. set_breakpoint_addr(&dummy_var[i], i);
  270. toggle_breakpoint(i, mode, len, local, global, 1);
  271. ptrace(PTRACE_CONT, child_pid, NULL, 0);
  272. sprintf(buf,
  273. "Test %s watchpoint %d with len: %d local: %d global: %d\n",
  274. mode_str, i, len, local, global);
  275. check_success(buf);
  276. toggle_breakpoint(i, mode, len, local, global, 0);
  277. }
  278. }
  279. /* Set the breakpoints and check the child successfully trigger them */
  280. static void launch_tests(void)
  281. {
  282. char buf[1024];
  283. int len, local, global, i;
  284. /* Instruction breakpoints */
  285. for (local = 0; local < 2; local++) {
  286. for (global = 0; global < 2; global++) {
  287. if (!local && !global)
  288. continue;
  289. launch_instruction_breakpoints(buf, local, global);
  290. }
  291. }
  292. /* Write watchpoint */
  293. for (len = 1; len <= sizeof(long); len <<= 1) {
  294. for (local = 0; local < 2; local++) {
  295. for (global = 0; global < 2; global++) {
  296. if (!local && !global)
  297. continue;
  298. launch_watchpoints(buf, BP_W, len,
  299. local, global);
  300. }
  301. }
  302. }
  303. /* Read-Write watchpoint */
  304. for (len = 1; len <= sizeof(long); len <<= 1) {
  305. for (local = 0; local < 2; local++) {
  306. for (global = 0; global < 2; global++) {
  307. if (!local && !global)
  308. continue;
  309. launch_watchpoints(buf, BP_RW, len,
  310. local, global);
  311. }
  312. }
  313. }
  314. /* Icebp traps */
  315. ptrace(PTRACE_CONT, child_pid, NULL, 0);
  316. check_success("Test icebp\n");
  317. /* Int 3 traps */
  318. ptrace(PTRACE_CONT, child_pid, NULL, 0);
  319. check_success("Test int 3 trap\n");
  320. ptrace(PTRACE_CONT, child_pid, NULL, 0);
  321. }
  322. int main(int argc, char **argv)
  323. {
  324. pid_t pid;
  325. int ret;
  326. ksft_print_header();
  327. pid = fork();
  328. if (!pid) {
  329. trigger_tests();
  330. exit(0);
  331. }
  332. child_pid = pid;
  333. wait(NULL);
  334. launch_tests();
  335. wait(NULL);
  336. ksft_exit_pass();
  337. }