tools/testing/selftests/powerpc/ptrace/ptrace-hwbreak.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2
   3 /*
   4  * Ptrace test for hw breakpoints
   5  *
   6  * Based on tools/testing/selftests/breakpoints/breakpoint_test.c
   7  *
   8  * This test forks and the parent then traces the child doing various
   9  * types of ptrace enabled breakpoints
  10  *
  11  * Copyright (C) 2018 Michael Neuling, IBM Corporation.
  12  */
  13
  14 #include <sys/ptrace.h>
  15 #include <unistd.h>
  16 #include <stddef.h>
  17 #include <sys/user.h>
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <signal.h>
  21 #include <sys/types.h>
  22 #include <sys/wait.h>
  23 #include <sys/syscall.h>
  24 #include <linux/limits.h>
  25 #include "ptrace.h"
  26 #include "reg.h"
  27
  28 #define SPRN_PVR        0x11F
  29 #define PVR_8xx         0x00500000
  30
  31 bool is_8xx;
  32
  33 /*
  34  * Use volatile on all global var so that compiler doesn't
  35  * optimise their load/stores. Otherwise selftest can fail.
  36  */
  37 static volatile __u64 glvar;
  38
  39 #define DAWR_MAX_LEN 512
  40 static volatile __u8 big_var[DAWR_MAX_LEN] __attribute__((aligned(512)));
  41
  42 #define A_LEN 6
  43 #define B_LEN 6
  44 struct gstruct {
  45         __u8 a[A_LEN]; /* double word aligned */
  46         __u8 b[B_LEN]; /* double word unaligned */
  47 };
  48 static volatile struct gstruct gstruct __attribute__((aligned(512)));
  49
  50 static volatile char cwd[PATH_MAX] __attribute__((aligned(8)));
  51
  52 static void get_dbginfo(pid_t child_pid, struct ppc_debug_info *dbginfo)
  53 {
  54         if (ptrace(PPC_PTRACE_GETHWDBGINFO, child_pid, NULL, dbginfo)) {
  55                 perror("Can't get breakpoint info");
  56                 exit(-1);
  57         }
  58 }
  59
  60 static bool dawr_present(struct ppc_debug_info *dbginfo)
  61 {
  62         return !!(dbginfo->features & PPC_DEBUG_FEATURE_DATA_BP_DAWR);
  63 }
  64
  65 static void write_var(int len)
  66 {
  67         volatile __u8 *pcvar;
  68         volatile __u16 *psvar;
  69         volatile __u32 *pivar;
  70         volatile __u64 *plvar;
  71
  72         switch (len) {
  73         case 1:
  74                 pcvar = (volatile __u8 *)&glvar;
  75                 *pcvar = 0xff;
  76                 break;
  77         case 2:
  78                 psvar = (volatile __u16 *)&glvar;
  79                 *psvar = 0xffff;
  80                 break;
  81         case 4:
  82                 pivar = (volatile __u32 *)&glvar;
  83                 *pivar = 0xffffffff;
  84                 break;
  85         case 8:
  86                 plvar = (volatile __u64 *)&glvar;
  87                 *plvar = 0xffffffffffffffffLL;
  88                 break;
  89         }
  90 }
  91
  92 static void read_var(int len)
  93 {
  94         __u8 cvar __attribute__((unused));
  95         __u16 svar __attribute__((unused));
  96         __u32 ivar __attribute__((unused));
  97         __u64 lvar __attribute__((unused));
  98
  99         switch (len) {
 100         case 1:
 101                 cvar = (volatile __u8)glvar;
 102                 break;
 103         case 2:
 104                 svar = (volatile __u16)glvar;
 105                 break;
 106         case 4:
 107                 ivar = (volatile __u32)glvar;
 108                 break;
 109         case 8:
 110                 lvar = (volatile __u64)glvar;
 111                 break;
 112         }
 113 }
 114
 115 static void test_workload(void)
 116 {
 117         __u8 cvar __attribute__((unused));
 118         __u32 ivar __attribute__((unused));
 119         int len = 0;
 120
 121         if (ptrace(PTRACE_TRACEME, 0, NULL, 0)) {
 122                 perror("Child can't be traced?");
 123                 exit(-1);
 124         }
 125
 126         /* Wake up father so that it sets up the first test */
 127         kill(getpid(), SIGUSR1);
 128
 129         /* PTRACE_SET_DEBUGREG, WO test */
 130         for (len = 1; len <= sizeof(glvar); len <<= 1)
 131                 write_var(len);
 132
 133         /* PTRACE_SET_DEBUGREG, RO test */
 134         for (len = 1; len <= sizeof(glvar); len <<= 1)
 135                 read_var(len);
 136
 137         /* PTRACE_SET_DEBUGREG, RW test */
 138         for (len = 1; len <= sizeof(glvar); len <<= 1) {
 139                 if (rand() % 2)
 140                         read_var(len);
 141                 else
 142                         write_var(len);
 143         }
 144
 145         /* PTRACE_SET_DEBUGREG, Kernel Access Userspace test */
 146         syscall(__NR_getcwd, &cwd, PATH_MAX);
 147
 148         /* PPC_PTRACE_SETHWDEBUG, MODE_EXACT, WO test */
 149         write_var(1);
 150
 151         /* PPC_PTRACE_SETHWDEBUG, MODE_EXACT, RO test */
 152         read_var(1);
 153
 154         /* PPC_PTRACE_SETHWDEBUG, MODE_EXACT, RW test */
 155         if (rand() % 2)
 156                 write_var(1);
 157         else
 158                 read_var(1);
 159
 160         /* PPC_PTRACE_SETHWDEBUG, MODE_EXACT, Kernel Access Userspace test */
 161         syscall(__NR_getcwd, &cwd, PATH_MAX);
 162
 163         /* PPC_PTRACE_SETHWDEBUG, MODE_RANGE, DW ALIGNED, WO test */
 164         gstruct.a[rand() % A_LEN] = 'a';
 165
 166         /* PPC_PTRACE_SETHWDEBUG, MODE_RANGE, DW ALIGNED, RO test */
 167         cvar = gstruct.a[rand() % A_LEN];
 168
 169         /* PPC_PTRACE_SETHWDEBUG, MODE_RANGE, DW ALIGNED, RW test */
 170         if (rand() % 2)
 171                 gstruct.a[rand() % A_LEN] = 'a';
 172         else
 173                 cvar = gstruct.a[rand() % A_LEN];
 174
 175         /* PPC_PTRACE_SETHWDEBUG, MODE_RANGE, DW UNALIGNED, WO test */
 176         gstruct.b[rand() % B_LEN] = 'b';
 177
 178         /* PPC_PTRACE_SETHWDEBUG, MODE_RANGE, DW UNALIGNED, RO test */
 179         cvar = gstruct.b[rand() % B_LEN];
 180
 181         /* PPC_PTRACE_SETHWDEBUG, MODE_RANGE, DW UNALIGNED, RW test */
 182         if (rand() % 2)
 183                 gstruct.b[rand() % B_LEN] = 'b';
 184         else
 185                 cvar = gstruct.b[rand() % B_LEN];
 186
 187         /* PPC_PTRACE_SETHWDEBUG, MODE_RANGE, DW UNALIGNED, DAR OUTSIDE, RW test */
 188         if (rand() % 2)
 189                 *((int *)(gstruct.a + 4)) = 10;
 190         else
 191                 ivar = *((int *)(gstruct.a + 4));
 192
 193         /* PPC_PTRACE_SETHWDEBUG. DAWR_MAX_LEN. RW test */
 194         if (rand() % 2)
 195                 big_var[rand() % DAWR_MAX_LEN] = 'a';
 196         else
 197                 cvar = big_var[rand() % DAWR_MAX_LEN];
 198
 199         /* PPC_PTRACE_SETHWDEBUG 2, MODE_RANGE, DW ALIGNED, WO test */
 200         gstruct.a[rand() % A_LEN] = 'a';
 201
 202         /* PPC_PTRACE_SETHWDEBUG 2, MODE_RANGE, DW UNALIGNED, RO test */
 203         cvar = gstruct.b[rand() % B_LEN];
 204
 205         /* PPC_PTRACE_SETHWDEBUG 2, MODE_RANGE, DAWR Overlap, WO test */
 206         gstruct.a[rand() % A_LEN] = 'a';
 207
 208         /* PPC_PTRACE_SETHWDEBUG 2, MODE_RANGE, DAWR Overlap, RO test */
 209         cvar = gstruct.a[rand() % A_LEN];
 210 }
 211
 212 static void check_success(pid_t child_pid, const char *name, const char *type,
 213                           unsigned long saddr, int len)
 214 {
 215         int status;
 216         siginfo_t siginfo;
 217         unsigned long eaddr = (saddr + len - 1) | 0x7;
 218
 219         saddr &= ~0x7;
 220
 221         /* Wait for the child to SIGTRAP */
 222         wait(&status);
 223
 224         ptrace(PTRACE_GETSIGINFO, child_pid, NULL, &siginfo);
 225
 226         if (!WIFSTOPPED(status) || WSTOPSIG(status) != SIGTRAP ||
 227             (unsigned long)siginfo.si_addr < saddr ||
 228             (unsigned long)siginfo.si_addr > eaddr) {
 229                 printf("%s, %s, len: %d: Fail\n", name, type, len);
 230                 exit(-1);
 231         }
 232
 233         printf("%s, %s, len: %d: Ok\n", name, type, len);
 234
 235         if (!is_8xx) {
 236                 /*
 237                  * For ptrace registered watchpoint, signal is generated
 238                  * before executing load/store. Singlestep the instruction
 239                  * and then continue the test.
 240                  */
 241                 ptrace(PTRACE_SINGLESTEP, child_pid, NULL, 0);
 242                 wait(NULL);
 243         }
 244 }
 245
 246 static void ptrace_set_debugreg(pid_t child_pid, unsigned long wp_addr)
 247 {
 248         if (ptrace(PTRACE_SET_DEBUGREG, child_pid, 0, wp_addr)) {
 249                 perror("PTRACE_SET_DEBUGREG failed");
 250                 exit(-1);
 251         }
 252 }
 253
 254 static int ptrace_sethwdebug(pid_t child_pid, struct ppc_hw_breakpoint *info)
 255 {
 256         int wh = ptrace(PPC_PTRACE_SETHWDEBUG, child_pid, 0, info);
 257
 258         if (wh <= 0) {
 259                 perror("PPC_PTRACE_SETHWDEBUG failed");
 260                 exit(-1);
 261         }
 262         return wh;
 263 }
 264
 265 static void ptrace_delhwdebug(pid_t child_pid, int wh)
 266 {
 267         if (ptrace(PPC_PTRACE_DELHWDEBUG, child_pid, 0, wh) < 0) {
 268                 perror("PPC_PTRACE_DELHWDEBUG failed");
 269                 exit(-1);
 270         }
 271 }
 272
 273 #define DABR_READ_SHIFT         0
 274 #define DABR_WRITE_SHIFT        1
 275 #define DABR_TRANSLATION_SHIFT  2
 276
 277 static int test_set_debugreg(pid_t child_pid)
 278 {
 279         unsigned long wp_addr = (unsigned long)&glvar;
 280         char *name = "PTRACE_SET_DEBUGREG";
 281         int len;
 282
 283         /* PTRACE_SET_DEBUGREG, WO test*/
 284         wp_addr &= ~0x7UL;
 285         wp_addr |= (1UL << DABR_WRITE_SHIFT);
 286         wp_addr |= (1UL << DABR_TRANSLATION_SHIFT);
 287         for (len = 1; len <= sizeof(glvar); len <<= 1) {
 288                 ptrace_set_debugreg(child_pid, wp_addr);
 289                 ptrace(PTRACE_CONT, child_pid, NULL, 0);
 290                 check_success(child_pid, name, "WO", wp_addr, len);
 291         }
 292
 293         /* PTRACE_SET_DEBUGREG, RO test */
 294         wp_addr &= ~0x7UL;
 295         wp_addr |= (1UL << DABR_READ_SHIFT);
 296         wp_addr |= (1UL << DABR_TRANSLATION_SHIFT);
 297         for (len = 1; len <= sizeof(glvar); len <<= 1) {
 298                 ptrace_set_debugreg(child_pid, wp_addr);
 299                 ptrace(PTRACE_CONT, child_pid, NULL, 0);
 300                 check_success(child_pid, name, "RO", wp_addr, len);
 301         }
 302
 303         /* PTRACE_SET_DEBUGREG, RW test */
 304         wp_addr &= ~0x7UL;
 305         wp_addr |= (1Ul << DABR_READ_SHIFT);
 306         wp_addr |= (1UL << DABR_WRITE_SHIFT);
 307         wp_addr |= (1UL << DABR_TRANSLATION_SHIFT);
 308         for (len = 1; len <= sizeof(glvar); len <<= 1) {
 309                 ptrace_set_debugreg(child_pid, wp_addr);
 310                 ptrace(PTRACE_CONT, child_pid, NULL, 0);
 311                 check_success(child_pid, name, "RW", wp_addr, len);
 312         }
 313
 314         ptrace_set_debugreg(child_pid, 0);
 315         return 0;
 316 }
 317
 318 static int test_set_debugreg_kernel_userspace(pid_t child_pid)
 319 {
 320         unsigned long wp_addr = (unsigned long)cwd;
 321         char *name = "PTRACE_SET_DEBUGREG";
 322
 323         /* PTRACE_SET_DEBUGREG, Kernel Access Userspace test */
 324         wp_addr &= ~0x7UL;
 325         wp_addr |= (1Ul << DABR_READ_SHIFT);
 326         wp_addr |= (1UL << DABR_WRITE_SHIFT);
 327         wp_addr |= (1UL << DABR_TRANSLATION_SHIFT);
 328         ptrace_set_debugreg(child_pid, wp_addr);
 329         ptrace(PTRACE_CONT, child_pid, NULL, 0);
 330         check_success(child_pid, name, "Kernel Access Userspace", wp_addr, 8);
 331
 332         ptrace_set_debugreg(child_pid, 0);
 333         return 0;
 334 }
 335
 336 static void get_ppc_hw_breakpoint(struct ppc_hw_breakpoint *info, int type,
 337                                   unsigned long addr, int len)
 338 {
 339         info->version = 1;
 340         info->trigger_type = type;
 341         info->condition_mode = PPC_BREAKPOINT_CONDITION_NONE;
 342         info->addr = (__u64)addr;
 343         info->addr2 = (__u64)addr + len;
 344         info->condition_value = 0;
 345         if (!len)
 346                 info->addr_mode = PPC_BREAKPOINT_MODE_EXACT;
 347         else
 348                 info->addr_mode = PPC_BREAKPOINT_MODE_RANGE_INCLUSIVE;
 349 }
 350
 351 static void test_sethwdebug_exact(pid_t child_pid)
 352 {
 353         struct ppc_hw_breakpoint info;
 354         unsigned long wp_addr = (unsigned long)&glvar;
 355         char *name = "PPC_PTRACE_SETHWDEBUG, MODE_EXACT";
 356         int len = 1; /* hardcoded in kernel */
 357         int wh;
 358
 359         /* PPC_PTRACE_SETHWDEBUG, MODE_EXACT, WO test */
 360         get_ppc_hw_breakpoint(&info, PPC_BREAKPOINT_TRIGGER_WRITE, wp_addr, 0);
 361         wh = ptrace_sethwdebug(child_pid, &info);
 362         ptrace(PTRACE_CONT, child_pid, NULL, 0);
 363         check_success(child_pid, name, "WO", wp_addr, len);
 364         ptrace_delhwdebug(child_pid, wh);
 365
 366         /* PPC_PTRACE_SETHWDEBUG, MODE_EXACT, RO test */
 367         get_ppc_hw_breakpoint(&info, PPC_BREAKPOINT_TRIGGER_READ, wp_addr, 0);
 368         wh = ptrace_sethwdebug(child_pid, &info);
 369         ptrace(PTRACE_CONT, child_pid, NULL, 0);
 370         check_success(child_pid, name, "RO", wp_addr, len);
 371         ptrace_delhwdebug(child_pid, wh);
 372
 373         /* PPC_PTRACE_SETHWDEBUG, MODE_EXACT, RW test */
 374         get_ppc_hw_breakpoint(&info, PPC_BREAKPOINT_TRIGGER_RW, wp_addr, 0);
 375         wh = ptrace_sethwdebug(child_pid, &info);
 376         ptrace(PTRACE_CONT, child_pid, NULL, 0);
 377         check_success(child_pid, name, "RW", wp_addr, len);
 378         ptrace_delhwdebug(child_pid, wh);
 379 }
 380
 381 static void test_sethwdebug_exact_kernel_userspace(pid_t child_pid)
 382 {
 383         struct ppc_hw_breakpoint info;
 384         unsigned long wp_addr = (unsigned long)&cwd;
 385         char *name = "PPC_PTRACE_SETHWDEBUG, MODE_EXACT";
 386         int len = 1; /* hardcoded in kernel */
 387         int wh;
 388
 389         /* PPC_PTRACE_SETHWDEBUG, MODE_EXACT, Kernel Access Userspace test */
 390         get_ppc_hw_breakpoint(&info, PPC_BREAKPOINT_TRIGGER_WRITE, wp_addr, 0);
 391         wh = ptrace_sethwdebug(child_pid, &info);
 392         ptrace(PTRACE_CONT, child_pid, NULL, 0);
 393         check_success(child_pid, name, "Kernel Access Userspace", wp_addr, len);
 394         ptrace_delhwdebug(child_pid, wh);
 395 }
 396
 397 static void test_sethwdebug_range_aligned(pid_t child_pid)
 398 {
 399         struct ppc_hw_breakpoint info;
 400         unsigned long wp_addr;
 401         char *name = "PPC_PTRACE_SETHWDEBUG, MODE_RANGE, DW ALIGNED";
 402         int len;
 403         int wh;
 404
 405         /* PPC_PTRACE_SETHWDEBUG, MODE_RANGE, DW ALIGNED, WO test */
 406         wp_addr = (unsigned long)&gstruct.a;
 407         len = A_LEN;
 408         get_ppc_hw_breakpoint(&info, PPC_BREAKPOINT_TRIGGER_WRITE, wp_addr, len);
 409         wh = ptrace_sethwdebug(child_pid, &info);
 410         ptrace(PTRACE_CONT, child_pid, NULL, 0);
 411         check_success(child_pid, name, "WO", wp_addr, len);
 412         ptrace_delhwdebug(child_pid, wh);
 413
 414         /* PPC_PTRACE_SETHWDEBUG, MODE_RANGE, DW ALIGNED, RO test */
 415         wp_addr = (unsigned long)&gstruct.a;
 416         len = A_LEN;
 417         get_ppc_hw_breakpoint(&info, PPC_BREAKPOINT_TRIGGER_READ, wp_addr, len);
 418         wh = ptrace_sethwdebug(child_pid, &info);
 419         ptrace(PTRACE_CONT, child_pid, NULL, 0);
 420         check_success(child_pid, name, "RO", wp_addr, len);
 421         ptrace_delhwdebug(child_pid, wh);
 422
 423         /* PPC_PTRACE_SETHWDEBUG, MODE_RANGE, DW ALIGNED, RW test */
 424         wp_addr = (unsigned long)&gstruct.a;
 425         len = A_LEN;
 426         get_ppc_hw_breakpoint(&info, PPC_BREAKPOINT_TRIGGER_RW, wp_addr, len);
 427         wh = ptrace_sethwdebug(child_pid, &info);
 428         ptrace(PTRACE_CONT, child_pid, NULL, 0);
 429         check_success(child_pid, name, "RW", wp_addr, len);
 430         ptrace_delhwdebug(child_pid, wh);
 431 }
 432
 433 static void test_multi_sethwdebug_range(pid_t child_pid)
 434 {
 435         struct ppc_hw_breakpoint info1, info2;
 436         unsigned long wp_addr1, wp_addr2;
 437         char *name1 = "PPC_PTRACE_SETHWDEBUG 2, MODE_RANGE, DW ALIGNED";
 438         char *name2 = "PPC_PTRACE_SETHWDEBUG 2, MODE_RANGE, DW UNALIGNED";
 439         int len1, len2;
 440         int wh1, wh2;
 441
 442         wp_addr1 = (unsigned long)&gstruct.a;
 443         wp_addr2 = (unsigned long)&gstruct.b;
 444         len1 = A_LEN;
 445         len2 = B_LEN;
 446         get_ppc_hw_breakpoint(&info1, PPC_BREAKPOINT_TRIGGER_WRITE, wp_addr1, len1);
 447         get_ppc_hw_breakpoint(&info2, PPC_BREAKPOINT_TRIGGER_READ, wp_addr2, len2);
 448
 449         /* PPC_PTRACE_SETHWDEBUG 2, MODE_RANGE, DW ALIGNED, WO test */
 450         wh1 = ptrace_sethwdebug(child_pid, &info1);
 451
 452         /* PPC_PTRACE_SETHWDEBUG 2, MODE_RANGE, DW UNALIGNED, RO test */
 453         wh2 = ptrace_sethwdebug(child_pid, &info2);
 454
 455         ptrace(PTRACE_CONT, child_pid, NULL, 0);
 456         check_success(child_pid, name1, "WO", wp_addr1, len1);
 457
 458         ptrace(PTRACE_CONT, child_pid, NULL, 0);
 459         check_success(child_pid, name2, "RO", wp_addr2, len2);
 460
 461         ptrace_delhwdebug(child_pid, wh1);
 462         ptrace_delhwdebug(child_pid, wh2);
 463 }
 464
 465 static void test_multi_sethwdebug_range_dawr_overlap(pid_t child_pid)
 466 {
 467         struct ppc_hw_breakpoint info1, info2;
 468         unsigned long wp_addr1, wp_addr2;
 469         char *name = "PPC_PTRACE_SETHWDEBUG 2, MODE_RANGE, DAWR Overlap";
 470         int len1, len2;
 471         int wh1, wh2;
 472
 473         wp_addr1 = (unsigned long)&gstruct.a;
 474         wp_addr2 = (unsigned long)&gstruct.a;
 475         len1 = A_LEN;
 476         len2 = A_LEN;
 477         get_ppc_hw_breakpoint(&info1, PPC_BREAKPOINT_TRIGGER_WRITE, wp_addr1, len1);
 478         get_ppc_hw_breakpoint(&info2, PPC_BREAKPOINT_TRIGGER_READ, wp_addr2, len2);
 479
 480         /* PPC_PTRACE_SETHWDEBUG 2, MODE_RANGE, DAWR Overlap, WO test */
 481         wh1 = ptrace_sethwdebug(child_pid, &info1);
 482
 483         /* PPC_PTRACE_SETHWDEBUG 2, MODE_RANGE, DAWR Overlap, RO test */
 484         wh2 = ptrace_sethwdebug(child_pid, &info2);
 485
 486         ptrace(PTRACE_CONT, child_pid, NULL, 0);
 487         check_success(child_pid, name, "WO", wp_addr1, len1);
 488
 489         ptrace(PTRACE_CONT, child_pid, NULL, 0);
 490         check_success(child_pid, name, "RO", wp_addr2, len2);
 491
 492         ptrace_delhwdebug(child_pid, wh1);
 493         ptrace_delhwdebug(child_pid, wh2);
 494 }
 495
 496 static void test_sethwdebug_range_unaligned(pid_t child_pid)
 497 {
 498         struct ppc_hw_breakpoint info;
 499         unsigned long wp_addr;
 500         char *name = "PPC_PTRACE_SETHWDEBUG, MODE_RANGE, DW UNALIGNED";
 501         int len;
 502         int wh;
 503
 504         /* PPC_PTRACE_SETHWDEBUG, MODE_RANGE, DW UNALIGNED, WO test */
 505         wp_addr = (unsigned long)&gstruct.b;
 506         len = B_LEN;
 507         get_ppc_hw_breakpoint(&info, PPC_BREAKPOINT_TRIGGER_WRITE, wp_addr, len);
 508         wh = ptrace_sethwdebug(child_pid, &info);
 509         ptrace(PTRACE_CONT, child_pid, NULL, 0);
 510         check_success(child_pid, name, "WO", wp_addr, len);
 511         ptrace_delhwdebug(child_pid, wh);
 512
 513         /* PPC_PTRACE_SETHWDEBUG, MODE_RANGE, DW UNALIGNED, RO test */
 514         wp_addr = (unsigned long)&gstruct.b;
 515         len = B_LEN;
 516         get_ppc_hw_breakpoint(&info, PPC_BREAKPOINT_TRIGGER_READ, wp_addr, len);
 517         wh = ptrace_sethwdebug(child_pid, &info);
 518         ptrace(PTRACE_CONT, child_pid, NULL, 0);
 519         check_success(child_pid, name, "RO", wp_addr, len);
 520         ptrace_delhwdebug(child_pid, wh);
 521
 522         /* PPC_PTRACE_SETHWDEBUG, MODE_RANGE, DW UNALIGNED, RW test */
 523         wp_addr = (unsigned long)&gstruct.b;
 524         len = B_LEN;
 525         get_ppc_hw_breakpoint(&info, PPC_BREAKPOINT_TRIGGER_RW, wp_addr, len);
 526         wh = ptrace_sethwdebug(child_pid, &info);
 527         ptrace(PTRACE_CONT, child_pid, NULL, 0);
 528         check_success(child_pid, name, "RW", wp_addr, len);
 529         ptrace_delhwdebug(child_pid, wh);
 530
 531 }
 532
 533 static void test_sethwdebug_range_unaligned_dar(pid_t child_pid)
 534 {
 535         struct ppc_hw_breakpoint info;
 536         unsigned long wp_addr;
 537         char *name = "PPC_PTRACE_SETHWDEBUG, MODE_RANGE, DW UNALIGNED, DAR OUTSIDE";
 538         int len;
 539         int wh;
 540
 541         /* PPC_PTRACE_SETHWDEBUG, MODE_RANGE, DW UNALIGNED, DAR OUTSIDE, RW test */
 542         wp_addr = (unsigned long)&gstruct.b;
 543         len = B_LEN;
 544         get_ppc_hw_breakpoint(&info, PPC_BREAKPOINT_TRIGGER_WRITE, wp_addr, len);
 545         wh = ptrace_sethwdebug(child_pid, &info);
 546         ptrace(PTRACE_CONT, child_pid, NULL, 0);
 547         check_success(child_pid, name, "RW", wp_addr, len);
 548         ptrace_delhwdebug(child_pid, wh);
 549 }
 550
 551 static void test_sethwdebug_dawr_max_range(pid_t child_pid)
 552 {
 553         struct ppc_hw_breakpoint info;
 554         unsigned long wp_addr;
 555         char *name = "PPC_PTRACE_SETHWDEBUG, DAWR_MAX_LEN";
 556         int len;
 557         int wh;
 558
 559         /* PPC_PTRACE_SETHWDEBUG, DAWR_MAX_LEN, RW test */
 560         wp_addr = (unsigned long)big_var;
 561         len = DAWR_MAX_LEN;
 562         get_ppc_hw_breakpoint(&info, PPC_BREAKPOINT_TRIGGER_RW, wp_addr, len);
 563         wh = ptrace_sethwdebug(child_pid, &info);
 564         ptrace(PTRACE_CONT, child_pid, NULL, 0);
 565         check_success(child_pid, name, "RW", wp_addr, len);
 566         ptrace_delhwdebug(child_pid, wh);
 567 }
 568
 569 /* Set the breakpoints and check the child successfully trigger them */
 570 static void
 571 run_tests(pid_t child_pid, struct ppc_debug_info *dbginfo, bool dawr)
 572 {
 573         test_set_debugreg(child_pid);
 574         test_set_debugreg_kernel_userspace(child_pid);
 575         test_sethwdebug_exact(child_pid);
 576         test_sethwdebug_exact_kernel_userspace(child_pid);
 577         if (dbginfo->features & PPC_DEBUG_FEATURE_DATA_BP_RANGE) {
 578                 test_sethwdebug_range_aligned(child_pid);
 579                 if (dawr || is_8xx) {
 580                         test_sethwdebug_range_unaligned(child_pid);
 581                         test_sethwdebug_range_unaligned_dar(child_pid);
 582                         test_sethwdebug_dawr_max_range(child_pid);
 583                         if (dbginfo->num_data_bps > 1) {
 584                                 test_multi_sethwdebug_range(child_pid);
 585                                 test_multi_sethwdebug_range_dawr_overlap(child_pid);
 586                         }
 587                 }
 588         }
 589 }
 590
 591 static int ptrace_hwbreak(void)
 592 {
 593         pid_t child_pid;
 594         struct ppc_debug_info dbginfo;
 595         bool dawr;
 596
 597         child_pid = fork();
 598         if (!child_pid) {
 599                 test_workload();
 600                 return 0;
 601         }
 602
 603         wait(NULL);
 604
 605         get_dbginfo(child_pid, &dbginfo);
 606         SKIP_IF_MSG(dbginfo.num_data_bps == 0, "No data breakpoints present");
 607
 608         dawr = dawr_present(&dbginfo);
 609         run_tests(child_pid, &dbginfo, dawr);
 610
 611         /* Let the child exit first. */
 612         ptrace(PTRACE_CONT, child_pid, NULL, 0);
 613         wait(NULL);
 614
 615         /*
 616          * Testcases exits immediately with -1 on any failure. If
 617          * it has reached here, it means all tests were successful.
 618          */
 619         return TEST_PASS;
 620 }
 621
 622 int main(int argc, char **argv, char **envp)
 623 {
 624         is_8xx = mfspr(SPRN_PVR) == PVR_8xx;
 625
 626         return test_harness(ptrace_hwbreak, "ptrace-hwbreak");
 627 }