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

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Ptrace test for GPR/FPR registers
   4  *
   5  * Copyright (C) 2015 Anshuman Khandual, IBM Corporation.
   6  */
   7 #include "ptrace.h"
   8 #include "ptrace-gpr.h"
   9 #include "reg.h"
  10 #include <time.h>
  11
  12 /* Tracer and Tracee Shared Data */
  13 int shm_id;
  14 int *cptr, *pptr;
  15
  16 extern void gpr_child_loop(int *read_flag, int *write_flag,
  17                            unsigned long *gpr_buf, double *fpr_buf);
  18
  19 unsigned long child_gpr_val, parent_gpr_val;
  20 double child_fpr_val, parent_fpr_val;
  21
  22 static int child(void)
  23 {
  24         unsigned long gpr_buf[32];
  25         double fpr_buf[32];
  26         int i;
  27
  28         cptr = (int *)shmat(shm_id, NULL, 0);
  29         memset(gpr_buf, 0, sizeof(gpr_buf));
  30         memset(fpr_buf, 0, sizeof(fpr_buf));
  31
  32         for (i = 0; i < 32; i++) {
  33                 gpr_buf[i] = child_gpr_val;
  34                 fpr_buf[i] = child_fpr_val;
  35         }
  36
  37         gpr_child_loop(&cptr[0], &cptr[1], gpr_buf, fpr_buf);
  38
  39         shmdt((void *)cptr);
  40
  41         FAIL_IF(validate_gpr(gpr_buf, parent_gpr_val));
  42         FAIL_IF(validate_fpr_double(fpr_buf, parent_fpr_val));
  43
  44         return 0;
  45 }
  46
  47 int trace_gpr(pid_t child)
  48 {
  49         unsigned long gpr[18];
  50         __u64 tmp, fpr[32];
  51
  52         FAIL_IF(start_trace(child));
  53         FAIL_IF(show_gpr(child, gpr));
  54         FAIL_IF(validate_gpr(gpr, child_gpr_val));
  55         FAIL_IF(show_fpr(child, fpr));
  56
  57         memcpy(&tmp, &child_fpr_val, sizeof(tmp));
  58         FAIL_IF(validate_fpr(fpr, tmp));
  59
  60         FAIL_IF(write_gpr(child, parent_gpr_val));
  61
  62         memcpy(&tmp, &parent_fpr_val, sizeof(tmp));
  63         FAIL_IF(write_fpr(child, tmp));
  64
  65         FAIL_IF(stop_trace(child));
  66
  67         return TEST_PASS;
  68 }
  69
  70 #ifndef __LONG_WIDTH__
  71 #define __LONG_WIDTH__ (sizeof(long) * 8)
  72 #endif
  73
  74 static uint64_t rand_reg(void)
  75 {
  76         uint64_t result;
  77         long r;
  78
  79         r = random();
  80
  81         // Small values are typical
  82         result = r & 0xffff;
  83         if (r & 0x10000)
  84                 return result;
  85
  86         // Pointers tend to have high bits set
  87         result |= random() << (__LONG_WIDTH__ - 31);
  88         if (r & 0x100000)
  89                 return result;
  90
  91         // And sometimes we want a full 64-bit value
  92         result ^= random() << 16;
  93
  94         return result;
  95 }
  96
  97 int ptrace_gpr(void)
  98 {
  99         unsigned long seed;
 100         int ret, status;
 101         pid_t pid;
 102
 103         seed = getpid() ^ time(NULL);
 104         printf("srand(%lu)\n", seed);
 105         srand(seed);
 106
 107         child_gpr_val = rand_reg();
 108         child_fpr_val = rand_reg();
 109         parent_gpr_val = rand_reg();
 110         parent_fpr_val = rand_reg();
 111
 112         shm_id = shmget(IPC_PRIVATE, sizeof(int) * 2, 0777|IPC_CREAT);
 113         pid = fork();
 114         if (pid < 0) {
 115                 perror("fork() failed");
 116                 return TEST_FAIL;
 117         }
 118         if (pid == 0)
 119                 exit(child());
 120
 121         if (pid) {
 122                 pptr = (int *)shmat(shm_id, NULL, 0);
 123                 while (!pptr[1])
 124                         asm volatile("" : : : "memory");
 125
 126                 ret = trace_gpr(pid);
 127                 if (ret) {
 128                         kill(pid, SIGTERM);
 129                         shmdt((void *)pptr);
 130                         shmctl(shm_id, IPC_RMID, NULL);
 131                         return TEST_FAIL;
 132                 }
 133
 134                 pptr[0] = 1;
 135                 shmdt((void *)pptr);
 136
 137                 ret = wait(&status);
 138                 shmctl(shm_id, IPC_RMID, NULL);
 139                 if (ret != pid) {
 140                         printf("Child's exit status not captured\n");
 141                         return TEST_FAIL;
 142                 }
 143
 144                 return (WIFEXITED(status) && WEXITSTATUS(status)) ? TEST_FAIL :
 145                         TEST_PASS;
 146         }
 147
 148         return TEST_PASS;
 149 }
 150
 151 int main(int argc, char *argv[])
 152 {
 153         return test_harness(ptrace_gpr, "ptrace_gpr");
 154 }