CoCalc -- exec

GitHub Repository: sudo-project/sudo
Path: blob/main/src/exec_ptrace.h
¹⁵³² views
1
/*
2
 * Copyright (c) 2022 Todd C. Miller <[email protected]>
3
 *
4
 * Permission to use, copy, modify, and distribute this software for any
5
 * purpose with or without fee is hereby granted, provided that the above
6
 * copyright notice and this permission notice appear in all copies.
7
 *
8
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15
 */
16

17
#ifndef SUDO_EXEC_PTRACE_H
18
#define SUDO_EXEC_PTRACE_H
19

20
#include <sys/prctl.h>
21
#include <sys/ptrace.h>
22
#include <sys/user.h>
23
#include <asm/unistd.h>
24
#include <linux/audit.h>
25
#include <linux/ptrace.h>
26
#include <linux/seccomp.h>
27
#include <linux/filter.h>
28

29
/* Older kernel headers may be missing some EM_* defines in linux/elf.h. */
30
#include <elf.h>
31

32
/* Older systems may not support execveat(2). */
33
#ifndef __NR_execveat
34
# define __NR_execveat	-1
35
#endif
36

37
/* In case userland elf.h doesn't define NT_ARM_SYSTEM_CALL. */
38
#if defined(__aarch64__) && !defined(NT_ARM_SYSTEM_CALL)
39
# define NT_ARM_SYSTEM_CALL 0x404
40
#endif
41

42
/* In case userland doesn't define __X32_SYSCALL_BIT. */
43
#if defined(__x86_64__) && !defined(__X32_SYSCALL_BIT)
44
# define __X32_SYSCALL_BIT 0x40000000
45
#endif
46

47
#ifdef __mips__
48
# ifndef __NR_O32_Linux
49
#  define __NR_O32_Linux 4000
50
# endif
51
# ifndef __NR_N32_Linux
52
#  define __NR_N32_Linux 6000
53
# endif
54
#endif
55

56
/* Align address to a (compat) word boundary. */
57
#define WORDALIGN(_a, _r)	\
58
	(((_a) + ((unsigned long)(_r).wordsize - 1UL)) & ~((unsigned long)(_r).wordsize - 1UL))
59

60
/* Align pointer to a native word boundary. */
61
#define LONGALIGN(_p)	\
62
	(((unsigned long)(_p) + (sizeof(unsigned long) - 1UL)) & ~(sizeof(unsigned long) - 1UL))
63

64
/*
65
 * See syscall(2) for a list of registers used in system calls.
66
 * For example code, see tools/testing/selftests/seccomp/seccomp_bpf.c
67
 *
68
 * The structs and registers vary among the different platforms.
69
 * We define user_regs_struct as the struct to use for getting
70
 * and setting the general registers and define accessor
71
 * macros to get/set the individual struct members.
72
 *
73
 * The value of SECCOMP_AUDIT_ARCH is used when matching the architecture
74
 * in the seccomp(2) filter.
75
 */
76
#if defined(__x86_64__)
77
# define SECCOMP_AUDIT_ARCH	AUDIT_ARCH_X86_64
78
# ifndef __ILP32__
79
#  define X32_execve		__X32_SYSCALL_BIT + 520
80
#  define X32_execveat		__X32_SYSCALL_BIT + 545
81
# endif
82
# define sudo_pt_regs		struct user_regs_struct
83
# define reg_syscall(x)		(x).orig_rax
84
# define reg_retval(x)		(x).rax
85
# define reg_sp(x)		(x).rsp
86
# define reg_arg1(x)		(x).rdi
87
# define reg_arg2(x)		(x).rsi
88
# define reg_arg3(x)		(x).rdx
89
# define reg_arg4(x)		(x).r10
90
#elif defined(__aarch64__)
91
# define SECCOMP_AUDIT_ARCH	AUDIT_ARCH_AARCH64
92
# define sudo_pt_regs		struct user_pt_regs
93
# define reg_syscall(x)		(x).regs[8]	/* w8 */
94
# define reg_retval(x)		(x).regs[0]	/* x0 */
95
# define reg_sp(x)		(x).sp		/* sp */
96
# define reg_arg1(x)		(x).regs[0]	/* x0 */
97
# define reg_arg2(x)		(x).regs[1]	/* x1 */
98
# define reg_arg3(x)		(x).regs[2]	/* x2 */
99
# define reg_arg4(x)		(x).regs[3]	/* x3 */
100
# define reg_set_syscall(_r, _nr) do {					\
101
    struct iovec _iov;							\
102
    long _syscallno = (_nr);						\
103
    _iov.iov_base = &_syscallno;					\
104
    _iov.iov_len = sizeof(_syscallno);					\
105
    ptrace(PTRACE_SETREGSET, pid, NT_ARM_SYSTEM_CALL, &_iov);		\
106
} while (0)
107
#elif defined(__arm__)
108
/* Note: assumes arm EABI, not OABI */
109
# define SECCOMP_AUDIT_ARCH	AUDIT_ARCH_ARM
110
# define sudo_pt_regs		struct pt_regs
111
# define reg_syscall(x)		(x).ARM_r7
112
# define reg_retval(x)		(x).ARM_r0
113
# define reg_sp(x)		(x).ARM_sp
114
# define reg_arg1(x)		(x).ARM_r0
115
# define reg_arg2(x)		(x).ARM_r1
116
# define reg_arg3(x)		(x).ARM_r2
117
# define reg_arg4(x)		(x).ARM_r3
118
# define reg_set_syscall(_r, _nr) do {					\
119
    ptrace(PTRACE_SET_SYSCALL, pid, NULL, _nr);				\
120
} while (0)
121
#elif defined (__hppa__)
122
/* Untested (should also support hppa64) */
123
# define SECCOMP_AUDIT_ARCH	AUDIT_ARCH_PARISC
124
# define sudo_pt_regs		struct user_regs_struct
125
# define reg_syscall(x)		(x).gr[20]	/* r20 */
126
# define reg_retval(x)		(x).gr[28]	/* r28 */
127
# define reg_sp(x)		(x).gr[30]	/* r30 */
128
# define reg_arg1(x)		(x).gr[26]	/* r26 */
129
# define reg_arg2(x)		(x).gr[25]	/* r25 */
130
# define reg_arg3(x)		(x).gr[24]	/* r24 */
131
# define reg_arg4(x)		(x).gr[23]	/* r23 */
132
#elif defined(__i386__)
133
# define SECCOMP_AUDIT_ARCH	AUDIT_ARCH_I386
134
# define sudo_pt_regs		struct user_regs_struct
135
# define reg_syscall(x)		(x).orig_eax
136
# define reg_retval(x)		(x).eax
137
# define reg_sp(x)		(x).esp
138
# define reg_arg1(x)		(x).ebx
139
# define reg_arg2(x)		(x).ecx
140
# define reg_arg3(x)		(x).edx
141
# define reg_arg4(x)		(x).esi
142
#elif defined(__mips__)
143
# if _MIPS_SIM == _MIPS_SIM_ABI32
144
#  /* Linux o32 style syscalls, 4000-4999. */
145
#  if BYTE_ORDER == LITTLE_ENDIAN
146
#   define SECCOMP_AUDIT_ARCH	AUDIT_ARCH_MIPSEL
147
#  else
148
#   define SECCOMP_AUDIT_ARCH	AUDIT_ARCH_MIPS
149
#  endif
150
# elif _MIPS_SIM == _MIPS_SIM_ABI64
151
#  /* Linux 64-bit syscalls, 5000-5999. */
152
#  if BYTE_ORDER == LITTLE_ENDIAN
153
#   define SECCOMP_AUDIT_ARCH	AUDIT_ARCH_MIPSEL64
154
#  else
155
#   define SECCOMP_AUDIT_ARCH	AUDIT_ARCH_MIPS64
156
#  endif
157
# elif _MIPS_SIM == _MIPS_SIM_NABI32
158
# /* Linux N32 syscalls, 6000-6999. */
159
#  if BYTE_ORDER == LITTLE_ENDIAN
160
#   define SECCOMP_AUDIT_ARCH	AUDIT_ARCH_MIPSEL64N32
161
#  else
162
#   define SECCOMP_AUDIT_ARCH	AUDIT_ARCH_MIPS64N32
163
#  endif
164
#  else
165
#   error "Unsupported MIPS ABI"
166
# endif
167
/*
168
 * If called via syscall(__NR_###), v0 holds __NR_O32_Linux and the real
169
 * syscall is in the first arg (a0).  The actual args are shifted by one.
170
 * MIPS does not support setting the syscall return value via ptrace.
171
 */
172
# define sudo_pt_regs		struct pt_regs
173
# define reg_syscall(_r) ({						\
174
    __u64 _nr;								\
175
    if ((_r).regs[2] == __NR_O32_Linux)					\
176
	_nr = (_r).regs[4]; /* a0 */					\
177
    else								\
178
	_nr = (_r).regs[2]; /* v0 */					\
179
    _nr;								\
180
})
181
# define reg_retval(x)		(x).regs[2]	/* v0 */
182
# define reg_sp(x)		(x).regs[29]	/* sp */
183
# define reg_arg1(x)		\
184
    ((x).regs[2] == __NR_O32_Linux ? (x).regs[5] : (x).regs[4])
185
# define reg_set_arg1(_r, _v) do {					\
186
    if ((_r).regs[2] == __NR_O32_Linux)					\
187
	(_r).regs[5] = _v; /* a1 */					\
188
    else								\
189
	(_r).regs[4] = _v; /* a0 */					\
190
} while (0)
191
# define reg_arg2(x)							\
192
    ((x).regs[2] == __NR_O32_Linux ? (x).regs[6] : (x).regs[5])
193
# define reg_set_arg2(_r, _v) do {					\
194
    if ((_r).regs[2] == __NR_O32_Linux)					\
195
	(_r).regs[6] = _v; /* a2 */					\
196
    else								\
197
	(_r).regs[5] = _v; /* a1 */					\
198
} while (0)
199
# define reg_arg3(x)							\
200
    ((x).regs[2] == __NR_O32_Linux ? (x).regs[7] : (x).regs[6])
201
# define reg_set_arg3(_r, _v) do {					\
202
    if ((_r).regs[2] == __NR_O32_Linux)					\
203
	(_r).regs[7] = _v; /* a3 */					\
204
    else								\
205
	(_r).regs[6] = _v; /* a2 */					\
206
} while (0)
207
/* XXX - reg_arg4 probably wrong for syscall() type calls on 032. */
208
# define reg_arg4(x)		\
209
    ((x).regs[2] == __NR_O32_Linux ? (x).regs[8] : (x).regs[7])
210
# define reg_set_arg4(_r, _v) do {					\
211
    if ((_r).regs[2] == __NR_O32_Linux)					\
212
	(_r).regs[8] = _v; /* a4 */					\
213
    else								\
214
	(_r).regs[7] = _v; /* a3 */					\
215
} while (0)
216
# define reg_set_syscall(_r, _nr) do {					\
217
    if ((_r).regs[2] == __NR_O32_Linux)					\
218
	(_r).regs[4] = _nr; /* a0 */					\
219
    else								\
220
	(_r).regs[2] = _nr; /* v0 */					\
221
} while (0)
222
#elif defined(__powerpc__)
223
# if defined(__powerpc64__)
224
#  if BYTE_ORDER == LITTLE_ENDIAN
225
#   define SECCOMP_AUDIT_ARCH	AUDIT_ARCH_PPC64LE
226
#  else
227
#   define SECCOMP_AUDIT_ARCH	AUDIT_ARCH_PPC64
228
#  endif
229
# else
230
#  define SECCOMP_AUDIT_ARCH	AUDIT_ARCH_PPC
231
# endif
232
# define sudo_pt_regs		struct pt_regs
233
# define reg_syscall(x)		(x).gpr[0]	/* r0 */
234
# define reg_retval(x)		(x).gpr[3]	/* r3 */
235
# define reg_sp(x)		(x).gpr[1]	/* r1 */
236
# define reg_arg1(x)		(x).orig_gpr3	/* r3 */
237
# define reg_arg2(x)		(x).gpr[4]	/* r4 */
238
# define reg_arg3(x)		(x).gpr[5]	/* r5 */
239
# define reg_arg4(x)		(x).gpr[6]	/* r6 */
240
# define reg_set_retval(_r, _v) do {					\
241
    if (((_r).trap & 0xfff0) == 0x3000) {				\
242
	/* scv 0 system call, uses negative error code for result. */	\
243
	reg_retval(_r) = (_v);						\
244
    } else {								\
245
	/*								\
246
	 * Set CR0 SO bit to indicate a syscall error, which is stored	\
247
	 * as a positive error code.					\
248
	 */								\
249
	reg_retval(_r) = -(_v);						\
250
	(_r).ccr |= 0x10000000;						\
251
    }									\
252
} while (0)
253
#elif defined(__riscv) && __riscv_xlen == 64
254
# define SECCOMP_AUDIT_ARCH	AUDIT_ARCH_RISCV64
255
# define sudo_pt_regs		struct user_regs_struct
256
# define reg_syscall(x)		(x).a7
257
# define reg_retval(x)		(x).a0
258
# define reg_sp(x)		(x).sp
259
# define reg_arg1(x)		(x).a0
260
# define reg_arg2(x)		(x).a1
261
# define reg_arg3(x)		(x).a2
262
# define reg_arg4(x)		(x).a3
263
#elif defined(__s390__)
264
/*
265
 * Both the syscall number and return value are stored in r2 for
266
 * the s390 ptrace API.  The first argument is stored in orig_gpr2.
267
 */
268
# if defined(__s390x__)
269
#  define SECCOMP_AUDIT_ARCH	AUDIT_ARCH_S390X
270
# else
271
#  define SECCOMP_AUDIT_ARCH	AUDIT_ARCH_S390
272
# endif
273
# define sudo_pt_regs		s390_regs
274
# define reg_syscall(x)		(x).gprs[2]	/* r2 */
275
# define reg_retval(x)		(x).gprs[2]	/* r2 */
276
# define reg_sp(x)		(x).gprs[15]	/* r15 */
277
# define reg_arg1(x)		(x).orig_gpr2	/* r2 */
278
# define reg_arg2(x)		(x).gprs[3]	/* r3 */
279
# define reg_arg3(x)		(x).gprs[4]	/* r4 */
280
# define reg_arg4(x)		(x).gprs[5]	/* r6 */
281
#else
282
# error "Do not know how to find your architecture's registers"
283
#endif
284

285
/*
286
 * Compat definitions for running 32-bit binaries on 64-bit platforms.
287
 * We must define the register struct too since there is no way to
288
 * get it directly from the system headers.
289
 *
290
 * The value of SECCOMP_AUDIT_ARCH_COMPAT is used when matching the
291
 * architecture in the seccomp(2) filter.  We can tell when the compat
292
 * arch matched by inspecting the message returned by PTRACE_GETEVENTMSG.
293
 */
294
#if defined(__x86_64__)
295
struct i386_user_regs_struct {
296
    unsigned int ebx;
297
    unsigned int ecx;
298
    unsigned int edx;
299
    unsigned int esi;
300
    unsigned int edi;
301
    unsigned int ebp;
302
    unsigned int eax;
303
    unsigned int xds;
304
    unsigned int xes;
305
    unsigned int xfs;
306
    unsigned int xgs;
307
    unsigned int orig_eax;
308
    unsigned int eip;
309
    unsigned int xcs;
310
    unsigned int eflags;
311
    unsigned int esp;
312
    unsigned int xss;
313
};
314
# define SECCOMP_AUDIT_ARCH_COMPAT	AUDIT_ARCH_I386
315
# define COMPAT_execve			11
316
# define COMPAT_execveat		358
317
# define compat_sudo_pt_regs		struct i386_user_regs_struct
318
# define compat_reg_syscall(x)		(x).orig_eax
319
# define compat_reg_retval(x)		(x).eax
320
# define compat_reg_sp(x)		(x).esp
321
# define compat_reg_arg1(x)		(x).ebx
322
# define compat_reg_arg2(x)		(x).ecx
323
# define compat_reg_arg3(x)		(x).edx
324
# define compat_reg_arg4(x)		(x).esi
325
#elif defined(__aarch64__)
326
struct arm_pt_regs {
327
  unsigned int uregs[18];
328
};
329
# define SECCOMP_AUDIT_ARCH_COMPAT	AUDIT_ARCH_ARM
330
# define COMPAT_execve			11
331
# define COMPAT_execveat		387
332
# define compat_sudo_pt_regs		struct arm_pt_regs
333
# define compat_reg_syscall(x)		(x).uregs[7]	/* r7 */
334
# define compat_reg_retval(x)		(x).uregs[0]	/* r0 */
335
# define compat_reg_sp(x)		(x).uregs[13]	/* r13 */
336
# define compat_reg_arg1(x)		(x).uregs[0]	/* r0 */
337
# define compat_reg_arg2(x)		(x).uregs[1]	/* r1 */
338
# define compat_reg_arg3(x)		(x).uregs[2]	/* r2 */
339
# define compat_reg_arg4(x)		(x).uregs[3]	/* r3 */
340
# define compat_reg_set_syscall(_r, _nr) reg_set_syscall(_r, _nr)
341
#elif defined(__mips__)
342
# if _MIPS_SIM == _MIPS_SIM_ABI64
343
/* MIPS o32/n32 binary compatibility on a mips64 system. */
344
#  if BYTE_ORDER == LITTLE_ENDIAN
345
#   define SECCOMP_AUDIT_ARCH_COMPAT	AUDIT_ARCH_MIPSEL
346
#   define SECCOMP_AUDIT_ARCH_COMPAT2	AUDIT_ARCH_MIPSEL64N32
347
#  else
348
#   define SECCOMP_AUDIT_ARCH_COMPAT	AUDIT_ARCH_MIPS
349
#   define SECCOMP_AUDIT_ARCH_COMPAT2	AUDIT_ARCH_MIPS64N32
350
#  endif
351
#  define COMPAT_execve			__NR_O32_Linux + 11
352
#  define COMPAT_execveat		__NR_O32_Linux + 356
353
#  define COMPAT2_execve		__NR_N32_Linux + 57
354
#  define COMPAT2_execveat		__NR_N32_Linux + 320
355
# elif _MIPS_SIM == _MIPS_SIM_NABI32
356
#  if BYTE_ORDER == LITTLE_ENDIAN
357
#   define SECCOMP_AUDIT_ARCH_COMPAT	AUDIT_ARCH_MIPSEL
358
#  else
359
#   define SECCOMP_AUDIT_ARCH_COMPAT	AUDIT_ARCH_MIPS
360
#  endif
361
#  define COMPAT_execve			__NR_O32_Linux + 11
362
#  define COMPAT_execveat		__NR_O32_Linux + 356
363
# endif /* _MIPS_SIM_ABI64 */
364
/* MIPS ABIs use a common ptrace interface. */
365
# define compat_sudo_pt_regs		struct pt_regs
366
# define compat_reg_syscall(x)		reg_syscall(x)
367
# define compat_reg_retval(x)		reg_retval(x)
368
# define compat_reg_sp(x)		reg_sp(x)
369
# define compat_reg_arg1(x)		reg_arg1(x)
370
# define compat_reg_set_arg1(_r, _v)	reg_set_arg1(_r, _v)
371
# define compat_reg_arg2(x)		reg_arg2(x)
372
# define compat_reg_set_arg2(_r, _v)	reg_set_arg2(_r, _v)
373
# define compat_reg_arg3(x)		reg_arg3(x)
374
# define compat_reg_set_arg3(_r, _v)	reg_set_arg3(_r, _v)
375
# define compat_reg_arg4(x)		reg_arg4(x)
376
# define compat_reg_set_arg4(_r, _v)	reg_set_arg4(_r, _v)
377
# define compat_reg_set_syscall(_r, _nr) reg_set_syscall(_r, _nr)
378
#elif defined(__powerpc64__)
379
struct ppc_pt_regs {
380
    unsigned int gpr[32];
381
    unsigned int nip;
382
    unsigned int msr;
383
    unsigned int orig_gpr3;
384
    unsigned int ctr;
385
    unsigned int link;
386
    unsigned int xer;
387
    unsigned int ccr;
388
    unsigned int mq;
389
    unsigned int trap;
390
    unsigned int dar;
391
    unsigned int dsisr;
392
    unsigned int result;
393
};
394
#  if BYTE_ORDER == LITTLE_ENDIAN
395
/* There is no AUDIT_ARCH_PPCLE define. */
396
#   define SECCOMP_AUDIT_ARCH_COMPAT	(AUDIT_ARCH_PPC|__AUDIT_ARCH_LE)
397
#  else
398
#   define SECCOMP_AUDIT_ARCH_COMPAT	AUDIT_ARCH_PPC
399
#  endif
400
# define COMPAT_execve			__NR_execve
401
# define COMPAT_execveat		__NR_execveat
402
# define compat_sudo_pt_regs		struct ppc_pt_regs
403
# define compat_reg_syscall(x)		(x).gpr[0]	/* r0 */
404
# define compat_reg_retval(x)		(x).gpr[3]	/* r3 */
405
# define compat_reg_sp(x)		(x).gpr[1]	/* r1 */
406
# define compat_reg_arg1(x)		(x).orig_gpr3	/* r3 */
407
# define compat_reg_arg2(x)		(x).gpr[4]	/* r4 */
408
# define compat_reg_arg3(x)		(x).gpr[5]	/* r5 */
409
# define compat_reg_arg4(x)		(x).gpr[6]	/* r6 */
410
# define compat_reg_set_retval(_r, _v)	reg_set_retval(_r, _v)
411
#endif
412

413
/* Set the syscall number the "normal" way by default. */
414
#ifndef reg_set_syscall
415
# define reg_set_syscall(_r, _nr) do {					\
416
    reg_syscall(_r) = (_nr);						\
417
} while (0)
418
#endif
419
#ifndef compat_reg_set_syscall
420
# define compat_reg_set_syscall(_r, _nr) do {				\
421
    compat_reg_syscall(_r) = (_nr);					\
422
} while (0)
423
#endif
424

425
/* Set the syscall return value the "normal" way by default. */
426
#ifndef reg_set_retval
427
# define reg_set_retval(_r, _v) do {					\
428
    reg_retval(_r) = (_v);						\
429
} while (0)
430
#endif
431
#ifndef compat_reg_set_retval
432
# define compat_reg_set_retval(_r, _v) do {				\
433
    compat_reg_retval(_r) = (_v);					\
434
} while (0)
435
#endif
436

437
/* Set the syscall arguments the "normal" way by default. */
438
#ifndef reg_set_arg1
439
# define reg_set_arg1(_r, _v) do {					\
440
    reg_arg1(_r) = (_v);						\
441
} while (0)
442
#endif
443
#ifndef compat_reg_set_arg1
444
# define compat_reg_set_arg1(_r, _v) do {				\
445
    compat_reg_arg1(_r) = (_v);						\
446
} while (0)
447
#endif
448
#ifndef reg_set_arg2
449
# define reg_set_arg2(_r, _v) do {					\
450
    reg_arg2(_r) = (_v);						\
451
} while (0)
452
#endif
453
#ifndef compat_reg_set_arg2
454
# define compat_reg_set_arg2(_r, _v) do {				\
455
    compat_reg_arg2(_r) = (_v);						\
456
} while (0)
457
#endif
458
#ifndef reg_set_arg3
459
# define reg_set_arg3(_r, _v) do {					\
460
    reg_arg3(_r) = (_v);						\
461
} while (0)
462
#endif
463
#ifndef compat_reg_set_arg3
464
# define compat_reg_set_arg3(_r, _v) do {				\
465
    compat_reg_arg3(_r) = (_v);						\
466
} while (0)
467
#endif
468
#ifndef reg_set_arg4
469
# define reg_set_arg4(_r, _v) do {					\
470
    reg_arg4(_r) = (_v);						\
471
} while (0)
472
#endif
473
#ifndef compat_reg_set_arg4
474
# define compat_reg_set_arg4(_r, _v) do {				\
475
    compat_reg_arg4(_r) = (_v);						\
476
} while (0)
477
#endif
478

479
/* Set the syscall arguments the "normal" way by default. */
480
#ifndef reg_set_arg1
481
# define reg_set_arg1(_r, _v) do {					\
482
    reg_arg1(_r) = (_v);						\
483
} while (0)
484
#endif
485
#ifndef compat_reg_set_arg1
486
# define compat_reg_set_arg1(_r, _v) do {				\
487
    compat_reg_arg1(_r) = (_v);						\
488
} while (0)
489
#endif
490
#ifndef reg_set_arg2
491
# define reg_set_arg2(_r, _v) do {					\
492
    reg_arg2(_r) = (_v);						\
493
} while (0)
494
#endif
495
#ifndef compat_reg_set_arg2
496
# define compat_reg_set_arg2(_r, _v) do {				\
497
    compat_reg_arg2(_r) = (_v);						\
498
} while (0)
499
#endif
500
#ifndef reg_set_arg3
501
# define reg_set_arg3(_r, _v) do {					\
502
    reg_arg3(_r) = (_v);						\
503
} while (0)
504
#endif
505
#ifndef compat_reg_set_arg3
506
# define compat_reg_set_arg3(_r, _v) do {				\
507
    compat_reg_arg3(_r) = (_v);						\
508
} while (0)
509
#endif
510
#ifndef reg_set_arg4
511
# define reg_set_arg4(_r, _v) do {					\
512
    reg_arg4(_r) = (_v);						\
513
} while (0)
514
#endif
515
#ifndef compat_reg_set_arg4
516
# define compat_reg_set_arg4(_r, _v) do {				\
517
    compat_reg_arg4(_r) = (_v);						\
518
} while (0)
519
#endif
520

521
struct sudo_ptrace_regs {
522
    union {
523
	sudo_pt_regs native;
524
#ifdef SECCOMP_AUDIT_ARCH_COMPAT
525
	compat_sudo_pt_regs compat;
526
#endif
527
    } u;
528
    unsigned int wordsize;
529
    bool compat;
530
};
531

532
#endif /* SUDO_EXEC_PTRACE_H */
533

534
Product

Resources

Company
