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
 11/* Tracer and Tracee Shared Data */
 12int shm_id;
 13int *cptr, *pptr;
 14
 15float a = FPR_1;
 16float b = FPR_2;
 17float c = FPR_3;
 18
 19void gpr(void)
 
 
 
 20{
 21	unsigned long gpr_buf[18];
 22	float fpr_buf[32];
 
 23
 24	cptr = (int *)shmat(shm_id, NULL, 0);
 
 
 25
 26	asm __volatile__(
 27		ASM_LOAD_GPR_IMMED(gpr_1)
 28		ASM_LOAD_FPR_SINGLE_PRECISION(flt_1)
 29		:
 30		: [gpr_1]"i"(GPR_1), [flt_1] "b" (&a)
 31		: "memory", "r6", "r7", "r8", "r9", "r10",
 32		"r11", "r12", "r13", "r14", "r15", "r16", "r17",
 33		"r18", "r19", "r20", "r21", "r22", "r23", "r24",
 34		"r25", "r26", "r27", "r28", "r29", "r30", "r31"
 35		);
 36
 37	cptr[1] = 1;
 38
 39	while (!cptr[0])
 40		asm volatile("" : : : "memory");
 41
 42	shmdt((void *)cptr);
 43	store_gpr(gpr_buf);
 44	store_fpr_single_precision(fpr_buf);
 45
 46	if (validate_gpr(gpr_buf, GPR_3))
 47		exit(1);
 48
 49	if (validate_fpr_float(fpr_buf, c))
 50		exit(1);
 51
 52	exit(0);
 53}
 54
 55int trace_gpr(pid_t child)
 56{
 
 57	unsigned long gpr[18];
 58	unsigned long fpr[32];
 59
 60	FAIL_IF(start_trace(child));
 
 
 61	FAIL_IF(show_gpr(child, gpr));
 62	FAIL_IF(validate_gpr(gpr, GPR_1));
 
 
 63	FAIL_IF(show_fpr(child, fpr));
 64	FAIL_IF(validate_fpr(fpr, FPR_1_REP));
 65	FAIL_IF(write_gpr(child, GPR_3));
 66	FAIL_IF(write_fpr(child, FPR_3_REP));
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 67	FAIL_IF(stop_trace(child));
 68
 69	return TEST_PASS;
 70}
 71
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 72int ptrace_gpr(void)
 73{
 74	pid_t pid;
 75	int ret, status;
 
 
 
 
 
 
 
 
 
 
 76
 77	shm_id = shmget(IPC_PRIVATE, sizeof(int) * 2, 0777|IPC_CREAT);
 78	pid = fork();
 79	if (pid < 0) {
 80		perror("fork() failed");
 81		return TEST_FAIL;
 82	}
 83	if (pid == 0)
 84		gpr();
 85
 86	if (pid) {
 87		pptr = (int *)shmat(shm_id, NULL, 0);
 88		while (!pptr[1])
 89			asm volatile("" : : : "memory");
 90
 91		ret = trace_gpr(pid);
 92		if (ret) {
 93			kill(pid, SIGTERM);
 94			shmdt((void *)pptr);
 95			shmctl(shm_id, IPC_RMID, NULL);
 96			return TEST_FAIL;
 97		}
 98
 99		pptr[0] = 1;
100		shmdt((void *)pptr);
101
102		ret = wait(&status);
103		shmctl(shm_id, IPC_RMID, NULL);
104		if (ret != pid) {
105			printf("Child's exit status not captured\n");
106			return TEST_FAIL;
107		}
108
109		return (WIFEXITED(status) && WEXITSTATUS(status)) ? TEST_FAIL :
110			TEST_PASS;
111	}
112
113	return TEST_PASS;
114}
115
116int main(int argc, char *argv[])
117{
118	return test_harness(ptrace_gpr, "ptrace_gpr");
119}

  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 */
 13int shm_id;
 14int *cptr, *pptr;
 15
 16extern void gpr_child_loop(int *read_flag, int *write_flag,
 17			   unsigned long *gpr_buf, double *fpr_buf);
 
 18
 19unsigned long child_gpr_val, parent_gpr_val;
 20double child_fpr_val, parent_fpr_val;
 21
 22static 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
 47int trace_gpr(pid_t child)
 48{
 49	__u64 tmp, fpr[32], *peeked_fprs;
 50	unsigned long gpr[18];
 
 51
 52	FAIL_IF(start_trace(child));
 53
 54	// Check child GPRs match what we expect using GETREGS
 55	FAIL_IF(show_gpr(child, gpr));
 56	FAIL_IF(validate_gpr(gpr, child_gpr_val));
 57
 58	// Check child FPRs match what we expect using GETFPREGS
 59	FAIL_IF(show_fpr(child, fpr));
 60	memcpy(&tmp, &child_fpr_val, sizeof(tmp));
 61	FAIL_IF(validate_fpr(fpr, tmp));
 62
 63	// Check child FPRs match what we expect using PEEKUSR
 64	peeked_fprs = peek_fprs(child);
 65	FAIL_IF(!peeked_fprs);
 66	FAIL_IF(validate_fpr(peeked_fprs, tmp));
 67	free(peeked_fprs);
 68
 69	// Write child GPRs using SETREGS
 70	FAIL_IF(write_gpr(child, parent_gpr_val));
 71
 72	// Write child FPRs using SETFPREGS
 73	memcpy(&tmp, &parent_fpr_val, sizeof(tmp));
 74	FAIL_IF(write_fpr(child, tmp));
 75
 76	// Check child FPRs match what we just set, using PEEKUSR
 77	peeked_fprs = peek_fprs(child);
 78	FAIL_IF(!peeked_fprs);
 79	FAIL_IF(validate_fpr(peeked_fprs, tmp));
 80
 81	// Write child FPRs using POKEUSR
 82	FAIL_IF(poke_fprs(child, (unsigned long *)peeked_fprs));
 83
 84	// Child will check its FPRs match before exiting
 85	FAIL_IF(stop_trace(child));
 86
 87	return TEST_PASS;
 88}
 89
 90#ifndef __LONG_WIDTH__
 91#define __LONG_WIDTH__ (sizeof(long) * 8)
 92#endif
 93
 94static uint64_t rand_reg(void)
 95{
 96	uint64_t result;
 97	long r;
 98
 99	r = random();
100
101	// Small values are typical
102	result = r & 0xffff;
103	if (r & 0x10000)
104		return result;
105
106	// Pointers tend to have high bits set
107	result |= random() << (__LONG_WIDTH__ - 31);
108	if (r & 0x100000)
109		return result;
110
111	// And sometimes we want a full 64-bit value
112	result ^= random() << 16;
113
114	return result;
115}
116
117int ptrace_gpr(void)
118{
119	unsigned long seed;
120	int ret, status;
121	pid_t pid;
122
123	seed = getpid() ^ time(NULL);
124	printf("srand(%lu)\n", seed);
125	srand(seed);
126
127	child_gpr_val = rand_reg();
128	child_fpr_val = rand_reg();
129	parent_gpr_val = rand_reg();
130	parent_fpr_val = rand_reg();
131
132	shm_id = shmget(IPC_PRIVATE, sizeof(int) * 2, 0777|IPC_CREAT);
133	pid = fork();
134	if (pid < 0) {
135		perror("fork() failed");
136		return TEST_FAIL;
137	}
138	if (pid == 0)
139		exit(child());
140
141	if (pid) {
142		pptr = (int *)shmat(shm_id, NULL, 0);
143		while (!pptr[1])
144			asm volatile("" : : : "memory");
145
146		ret = trace_gpr(pid);
147		if (ret) {
148			kill(pid, SIGTERM);
149			shmdt((void *)pptr);
150			shmctl(shm_id, IPC_RMID, NULL);
151			return TEST_FAIL;
152		}
153
154		pptr[0] = 1;
155		shmdt((void *)pptr);
156
157		ret = wait(&status);
158		shmctl(shm_id, IPC_RMID, NULL);
159		if (ret != pid) {
160			printf("Child's exit status not captured\n");
161			return TEST_FAIL;
162		}
163
164		return (WIFEXITED(status) && WEXITSTATUS(status)) ? TEST_FAIL :
165			TEST_PASS;
166	}
167
168	return TEST_PASS;
169}
170
171int main(int argc, char *argv[])
172{
173	return test_harness(ptrace_gpr, "ptrace_gpr");
174}