tools/testing/selftests/breakpoints/breakpoint_test.c

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