}
static void
-print_affinitylist(struct tcb *const tcp, const kernel_ureg_t addr,
+print_affinitylist(struct tcb *const tcp, const kernel_ulong_t addr,
const unsigned int len)
{
const unsigned int max_size = get_cpuset_size();
static bool
print_iocbp(struct tcb *tcp, void *elem_buf, size_t elem_size, void *data)
{
- kernel_ureg_t addr;
+ kernel_ulong_t addr;
struct iocb cb;
- if (elem_size < sizeof(kernel_ureg_t)) {
+ if (elem_size < sizeof(kernel_ulong_t)) {
addr = * (unsigned int *) elem_buf;
} else {
- addr = * (kernel_ureg_t *) elem_buf;
+ addr = * (kernel_ulong_t *) elem_buf;
}
tprints("{");
SYS_FUNC(io_submit)
{
const long nr = widen_to_long(tcp->u_arg[1]);
- const kernel_ureg_t addr = tcp->u_arg[2];
- kernel_ureg_t iocbp;
+ const kernel_ulong_t addr = tcp->u_arg[2];
+ kernel_ulong_t iocbp;
printaddr(tcp->u_arg[0]);
tprintf(", %ld, ", nr);
}
MPERS_PRINTER_DECL(int, block_ioctl, struct tcb *const tcp,
- const unsigned int code, const kernel_ureg_t arg)
+ const unsigned int code, const kernel_ulong_t arg)
{
switch (code) {
/* take arg as a value, not as a pointer */
#include "xlat/bpf_map_update_elem_flags.h"
static int
-bpf_map_create(struct tcb *const tcp, const kernel_ureg_t addr,
+bpf_map_create(struct tcb *const tcp, const kernel_ulong_t addr,
unsigned int size)
{
struct {
}
static void
-bpf_map_update_elem(struct tcb *const tcp, const kernel_ureg_t addr,
+bpf_map_update_elem(struct tcb *const tcp, const kernel_ulong_t addr,
unsigned int size)
{
struct {
}
static void
-bpf_map_delete_elem(struct tcb *const tcp, const kernel_ureg_t addr,
+bpf_map_delete_elem(struct tcb *const tcp, const kernel_ulong_t addr,
unsigned int size)
{
struct {
}
static int
-bpf_map_io(struct tcb *const tcp, const kernel_ureg_t addr, unsigned int size,
+bpf_map_io(struct tcb *const tcp, const kernel_ulong_t addr, unsigned int size,
const char *const text)
{
struct bpf_io_elem_struct {
}
static int
-bpf_prog_load(struct tcb *const tcp, const kernel_ureg_t addr,
+bpf_prog_load(struct tcb *const tcp, const kernel_ulong_t addr,
unsigned int size)
{
struct {
SYS_FUNC(bpf)
{
const unsigned int cmd = tcp->u_arg[0];
- const kernel_ureg_t addr = tcp->u_arg[1];
+ const kernel_ulong_t addr = tcp->u_arg[1];
const unsigned int size = tcp->u_arg[2];
int rc = RVAL_DECODED;
}
static void
-btrfs_print_balance(struct tcb *const tcp, const kernel_ureg_t arg, bool out)
+btrfs_print_balance(struct tcb *const tcp, const kernel_ulong_t arg, bool out)
{
struct btrfs_ioctl_balance_args balance_args;
}
static void
-btrfs_print_qgroup_inherit(struct tcb *const tcp, const kernel_ureg_t qgi_addr)
+btrfs_print_qgroup_inherit(struct tcb *const tcp, const kernel_ulong_t qgi_addr)
{
struct btrfs_qgroup_inherit inherit;
MPERS_PRINTER_DECL(int, btrfs_ioctl,
struct tcb *const tcp, const unsigned int code,
- const kernel_ureg_t arg)
+ const kernel_ulong_t arg)
{
switch (code) {
/* Take no arguments; command only. */
} *cap_user_data_t;
static cap_user_header_t
-get_cap_header(struct tcb *const tcp, const kernel_ureg_t addr)
+get_cap_header(struct tcb *const tcp, const kernel_ulong_t addr)
{
static struct user_cap_header_struct header;
}
static void
-print_cap_header(struct tcb *const tcp, const kernel_ureg_t addr,
+print_cap_header(struct tcb *const tcp, const kernel_ulong_t addr,
const cap_user_header_t const h)
{
if (!addr || !h) {
}
static void
-print_cap_data(struct tcb *const tcp, const kernel_ureg_t addr,
+print_cap_data(struct tcb *const tcp, const kernel_ulong_t addr,
const cap_user_header_t const h)
{
struct user_cap_data_struct data[2];
#endif
static void
-print_tls_arg(struct tcb *const tcp, const kernel_ureg_t addr)
+print_tls_arg(struct tcb *const tcp, const kernel_ulong_t addr)
{
#ifdef HAVE_STRUCT_USER_DESC
# if SUPPORTED_PERSONALITIES > 1
{
if (exiting(tcp)) {
const char *sep = "|";
- kernel_ureg_t flags = tcp->u_arg[ARG_FLAGS];
+ kernel_ulong_t flags = tcp->u_arg[ARG_FLAGS];
tprints("child_stack=");
printaddr(tcp->u_arg[ARG_STACK]);
tprints(", ");
int pid; /* If 0, this tcb is free */
int qual_flg; /* qual_flags[scno] or DEFAULT_QUAL_FLAGS + RAW */
unsigned long u_error; /* Error code */
- kernel_scno_t scno; /* System call number */
- kernel_ureg_t u_arg[MAX_ARGS]; /* System call arguments */
+ kernel_ulong_t scno; /* System call number */
+ kernel_ulong_t u_arg[MAX_ARGS]; /* System call arguments */
#if HAVE_STRUCT_TCB_EXT_ARG
unsigned long long ext_arg[MAX_ARGS];
long long u_lrval; /* long long return value */
* @return String literal corresponding to the syscall number in case latter
* is valid; NULL otherwise.
*/
-extern const char *syscall_name(kernel_scno_t scno);
+extern const char *syscall_name(kernel_ulong_t scno);
extern const char *err_name(unsigned long err);
extern bool is_erestart(struct tcb *);
}
extern int
-umoven(struct tcb *tcp, kernel_ureg_t addr, unsigned int len, void *laddr);
+umoven(struct tcb *tcp, kernel_ulong_t addr, unsigned int len, void *laddr);
#define umove(pid, addr, objp) \
umoven((pid), (addr), sizeof(*(objp)), (void *) (objp))
extern int
-umoven_or_printaddr(struct tcb *tcp, kernel_ureg_t addr,
+umoven_or_printaddr(struct tcb *tcp, kernel_ulong_t addr,
unsigned int len, void *laddr);
#define umove_or_printaddr(pid, addr, objp) \
umoven_or_printaddr((pid), (addr), sizeof(*(objp)), (void *) (objp))
extern int
-umoven_or_printaddr_ignore_syserror(struct tcb *tcp, kernel_ureg_t addr,
+umoven_or_printaddr_ignore_syserror(struct tcb *tcp, kernel_ulong_t addr,
unsigned int len, void *laddr);
extern int
-umovestr(struct tcb *tcp, kernel_ureg_t addr, unsigned int len, char *laddr);
+umovestr(struct tcb *tcp, kernel_ulong_t addr, unsigned int len, char *laddr);
-extern int upeek(int pid, unsigned long, kernel_ureg_t *);
-extern int upoke(int pid, unsigned long, kernel_ureg_t);
+extern int upeek(int pid, unsigned long, kernel_ulong_t *);
+extern int upoke(int pid, unsigned long, kernel_ulong_t);
extern bool
print_array(struct tcb *tcp,
- kernel_ureg_t start_addr,
+ kernel_ulong_t start_addr,
size_t nmemb,
void *elem_buf,
size_t elem_size,
int (*umoven_func)(struct tcb *,
- kernel_ureg_t,
+ kernel_ulong_t,
unsigned int,
void *),
bool (*print_func)(struct tcb *,
extern void print_numeric_long_umask(unsigned long);
extern void
-dumpiov_in_msghdr(struct tcb *, kernel_ureg_t addr, kernel_ureg_t data_size);
+dumpiov_in_msghdr(struct tcb *, kernel_ulong_t addr, kernel_ulong_t data_size);
extern void
-dumpiov_in_mmsghdr(struct tcb *, kernel_ureg_t addr);
+dumpiov_in_mmsghdr(struct tcb *, kernel_ulong_t addr);
extern void
-dumpiov_upto(struct tcb *, int len, kernel_ureg_t addr, kernel_ureg_t data_size);
+dumpiov_upto(struct tcb *, int len, kernel_ulong_t addr, kernel_ulong_t data_size);
extern void
-dumpstr(struct tcb *, kernel_ureg_t addr, int len);
+dumpstr(struct tcb *, kernel_ulong_t addr, int len);
extern void
-printstr_ex(struct tcb *, kernel_ureg_t addr, kernel_ureg_t len,
+printstr_ex(struct tcb *, kernel_ulong_t addr, kernel_ulong_t len,
unsigned int user_style);
#define DECL_PRINTNUM(name) \
extern bool \
-printnum_ ## name(struct tcb *, kernel_ureg_t addr, const char *fmt) \
+printnum_ ## name(struct tcb *, kernel_ulong_t addr, const char *fmt) \
ATTRIBUTE_FORMAT((printf, 3, 0))
DECL_PRINTNUM(short);
DECL_PRINTNUM(int);
#if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
extern bool
-printnum_long_int(struct tcb *, kernel_ureg_t addr,
+printnum_long_int(struct tcb *, kernel_ulong_t addr,
const char *fmt_long, const char *fmt_int)
ATTRIBUTE_FORMAT((printf, 3, 0))
ATTRIBUTE_FORMAT((printf, 4, 0));
#define DECL_PRINTPAIR(name) \
extern bool \
-printpair_ ## name(struct tcb *, kernel_ureg_t addr, const char *fmt) \
+printpair_ ## name(struct tcb *, kernel_ulong_t addr, const char *fmt) \
ATTRIBUTE_FORMAT((printf, 3, 0))
DECL_PRINTPAIR(int);
DECL_PRINTPAIR(int64);
#undef DECL_PRINTPAIR
extern void
-printpathn(struct tcb *, kernel_ureg_t addr, unsigned int n);
+printpathn(struct tcb *, kernel_ulong_t addr, unsigned int n);
extern void
-printpath(struct tcb *, kernel_ureg_t addr);
+printpath(struct tcb *, kernel_ulong_t addr);
#define TIMESPEC_TEXT_BUFSIZE \
(sizeof(intmax_t)*3 * 2 + sizeof("{tv_sec=%jd, tv_nsec=%jd}"))
extern void print_dirfd(struct tcb *, int);
extern int
-decode_sockaddr(struct tcb *, kernel_ureg_t addr, int addrlen);
+decode_sockaddr(struct tcb *, kernel_ulong_t addr, int addrlen);
extern void printuid(const char *, const unsigned int);
extern void
-print_sigset_addr_len(struct tcb *, kernel_ureg_t addr, kernel_ureg_t len);
+print_sigset_addr_len(struct tcb *, kernel_ulong_t addr, kernel_ulong_t len);
extern const char *sprintsigmask_n(const char *, const void *, unsigned int);
#define tprintsigmask_addr(prefix, mask) \
extern void printsignal(int);
extern void
-tprint_iov_upto(struct tcb *, kernel_ureg_t len, kernel_ureg_t addr,
- enum iov_decode, kernel_ureg_t data_size);
+tprint_iov_upto(struct tcb *, kernel_ulong_t len, kernel_ulong_t addr,
+ enum iov_decode, kernel_ulong_t data_size);
extern void
-decode_netlink(struct tcb *, kernel_ureg_t addr, kernel_ureg_t len);
+decode_netlink(struct tcb *, kernel_ulong_t addr, kernel_ulong_t len);
extern void tprint_open_modes(unsigned int);
extern const char *sprint_open_modes(unsigned int);
extern void
-print_seccomp_filter(struct tcb *, kernel_ureg_t addr);
+print_seccomp_filter(struct tcb *, kernel_ulong_t addr);
extern void
-print_seccomp_fprog(struct tcb *, kernel_ureg_t addr, unsigned short len);
+print_seccomp_fprog(struct tcb *, kernel_ulong_t addr, unsigned short len);
struct strace_stat;
extern void print_struct_stat(struct tcb *tcp, const struct strace_stat *const st);
struct strace_statfs;
extern void
-print_struct_statfs(struct tcb *, kernel_ureg_t addr);
+print_struct_statfs(struct tcb *, kernel_ulong_t addr);
extern void
-print_struct_statfs64(struct tcb *, kernel_ureg_t addr, kernel_ureg_t size);
+print_struct_statfs64(struct tcb *, kernel_ulong_t addr, kernel_ulong_t size);
extern void print_ifindex(unsigned int);
#define DECL_IOCTL(name) \
extern int \
-name ## _ioctl(struct tcb *, unsigned int request, kernel_ureg_t arg)
+name ## _ioctl(struct tcb *, unsigned int request, kernel_ulong_t arg)
DECL_IOCTL(dm);
DECL_IOCTL(file);
DECL_IOCTL(fs_x);
#endif
static inline void
-printaddr(kernel_ureg_t addr)
+printaddr(kernel_ulong_t addr)
{
printaddr_klu(addr);
}
static inline void
-printstrn(struct tcb *tcp, kernel_ureg_t addr, kernel_ureg_t len)
+printstrn(struct tcb *tcp, kernel_ulong_t addr, kernel_ulong_t len)
{
printstr_ex(tcp, addr, len, 0);
}
static inline void
-printstr(struct tcb *tcp, kernel_ureg_t addr)
+printstr(struct tcb *tcp, kernel_ulong_t addr)
{
printstr_ex(tcp, addr, -1, QUOTE_0_TERMINATED);
}
}
static inline void
-tprint_iov(struct tcb *tcp, kernel_ureg_t len, kernel_ureg_t addr,
+tprint_iov(struct tcb *tcp, kernel_ulong_t len, kernel_ulong_t addr,
enum iov_decode decode_iov)
{
tprint_iov_upto(tcp, len, addr, decode_iov, -1);
} timeval32_t;
extern void print_timeval32_t(const timeval32_t *);
-extern void printrusage32(struct tcb *, kernel_ureg_t);
-extern const char *sprint_timeval32(struct tcb *tcp, kernel_ureg_t);
-extern void print_timeval32(struct tcb *tcp, kernel_ureg_t);
-extern void print_timeval32_pair(struct tcb *tcp, kernel_ureg_t);
-extern void print_itimerval32(struct tcb *tcp, kernel_ureg_t);
+extern void printrusage32(struct tcb *, kernel_ulong_t);
+extern const char *sprint_timeval32(struct tcb *tcp, kernel_ulong_t);
+extern void print_timeval32(struct tcb *tcp, kernel_ulong_t);
+extern void print_timeval32_pair(struct tcb *tcp, kernel_ulong_t);
+extern void print_itimerval32(struct tcb *tcp, kernel_ulong_t);
#endif
#ifdef HAVE_STRUCT_USER_DESC
-extern void print_user_desc(struct tcb *, kernel_ureg_t addr);
+extern void print_user_desc(struct tcb *, kernel_ulong_t addr);
#endif
/* Strace log generation machinery.
#endif
/*
- * Cast a pointer or a pointer-sized integer to kernel_ureg_t.
+ * Cast a pointer or a pointer-sized integer to kernel_ulong_t.
*/
-#define ptr_to_kulong(v) ((kernel_ureg_t) (unsigned long) (v))
+#define ptr_to_kulong(v) ((kernel_ulong_t) (unsigned long) (v))
/*
* Zero-extend a signed integer type to unsigned long long.
/* Checks that sysent[scno] is not out of range. */
static inline bool
-scno_in_range(kernel_scno_t scno)
+scno_in_range(kernel_ulong_t scno)
{
return scno < nsyscalls;
}
* and its sysent[scno].sys_flags has no TRACE_INDIRECT_SUBCALL flag set.
*/
static inline bool
-scno_is_valid(kernel_scno_t scno)
+scno_is_valid(kernel_ulong_t scno)
{
return scno_in_range(scno)
&& sysent[scno].sys_func
}
static int
-decode_select(struct tcb *const tcp, const kernel_ureg_t *const args,
- void (*const print_tv_ts) (struct tcb *, kernel_ureg_t),
- const char * (*const sprint_tv_ts) (struct tcb *, kernel_ureg_t))
+decode_select(struct tcb *const tcp, const kernel_ulong_t *const args,
+ void (*const print_tv_ts) (struct tcb *, kernel_ulong_t),
+ const char * (*const sprint_tv_ts) (struct tcb *, kernel_ulong_t))
{
int i, j;
int nfds, fdsize;
fd_set *fds = NULL;
const char *sep;
- kernel_ureg_t addr;
+ kernel_ulong_t addr;
/* Kernel truncates args[0] to int, we do the same. */
nfds = (int) args[0];
SYS_FUNC(oldselect)
{
- kernel_ureg_t select_args[5];
+ kernel_ulong_t select_args[5];
unsigned int oldselect_args[5];
if (sizeof(*select_args) == sizeof(*oldselect_args)) {
}
static int
-umove_kulong_array_or_printaddr(struct tcb *const tcp, const kernel_ureg_t addr,
+umove_kulong_array_or_printaddr(struct tcb *const tcp, const kernel_ulong_t addr,
kernel_ulong_t *const ptr, const size_t n)
{
#ifndef current_klongsize
#define D_NAME_LEN_MAX 256
static void
-print_old_dirent(struct tcb *const tcp, const kernel_ureg_t addr)
+print_old_dirent(struct tcb *const tcp, const kernel_ulong_t addr)
{
kernel_dirent d;
}
static void
-dm_decode_dm_target_spec(struct tcb *const tcp, const kernel_ureg_t addr,
+dm_decode_dm_target_spec(struct tcb *const tcp, const kernel_ulong_t addr,
const struct dm_ioctl *const ioc)
{
static const uint32_t target_spec_size =
}
static void
-dm_decode_dm_target_deps(struct tcb *const tcp, const kernel_ureg_t addr,
+dm_decode_dm_target_deps(struct tcb *const tcp, const kernel_ulong_t addr,
const struct dm_ioctl *const ioc)
{
static const uint32_t target_deps_dev_offs =
}
static void
-dm_decode_dm_name_list(struct tcb *const tcp, const kernel_ureg_t addr,
+dm_decode_dm_name_list(struct tcb *const tcp, const kernel_ulong_t addr,
const struct dm_ioctl *const ioc)
{
static const uint32_t name_list_name_offs =
}
static void
-dm_decode_dm_target_versions(struct tcb *const tcp, const kernel_ureg_t addr,
+dm_decode_dm_target_versions(struct tcb *const tcp, const kernel_ulong_t addr,
const struct dm_ioctl *const ioc)
{
static const uint32_t target_vers_name_offs =
}
static void
-dm_decode_dm_target_msg(struct tcb *const tcp, const kernel_ureg_t addr,
+dm_decode_dm_target_msg(struct tcb *const tcp, const kernel_ulong_t addr,
const struct dm_ioctl *const ioc)
{
static const uint32_t target_msg_message_offs =
}
static void
-dm_decode_string(struct tcb *const tcp, const kernel_ureg_t addr,
+dm_decode_string(struct tcb *const tcp, const kernel_ulong_t addr,
const struct dm_ioctl *const ioc)
{
uint32_t offset = ioc->data_start;
static int
dm_known_ioctl(struct tcb *const tcp, const unsigned int code,
- const kernel_ureg_t arg)
+ const kernel_ulong_t arg)
{
struct dm_ioctl *ioc = NULL;
struct dm_ioctl *entering_ioc = NULL;
}
int
-dm_ioctl(struct tcb *const tcp, const unsigned int code, const kernel_ureg_t arg)
+dm_ioctl(struct tcb *const tcp, const unsigned int code, const kernel_ulong_t arg)
{
switch (code) {
case DM_VERSION:
# else /* !(DM_VERSION_MAJOR == 4) */
int
-dm_ioctl(struct tcb *const tcp, const unsigned int code, const kernel_ureg_t arg)
+dm_ioctl(struct tcb *const tcp, const unsigned int code, const kernel_ulong_t arg)
{
return 0;
}
}
static int
-ff_effect_ioctl(struct tcb *const tcp, const kernel_ureg_t arg)
+ff_effect_ioctl(struct tcb *const tcp, const kernel_ulong_t arg)
{
tprints(", ");
}
static int
-abs_ioctl(struct tcb *const tcp, const kernel_ureg_t arg)
+abs_ioctl(struct tcb *const tcp, const kernel_ulong_t arg)
{
tprints(", ");
}
static int
-keycode_ioctl(struct tcb *const tcp, const kernel_ureg_t arg)
+keycode_ioctl(struct tcb *const tcp, const kernel_ulong_t arg)
{
tprints(", ");
# ifdef EVIOCGKEYCODE_V2
static int
-keycode_V2_ioctl(struct tcb *const tcp, const kernel_ureg_t arg)
+keycode_V2_ioctl(struct tcb *const tcp, const kernel_ulong_t arg)
{
tprints(", ");
# endif /* EVIOCGKEYCODE_V2 */
static int
-getid_ioctl(struct tcb *const tcp, const kernel_ureg_t arg)
+getid_ioctl(struct tcb *const tcp, const kernel_ulong_t arg)
{
tprints(", ");
}
static int
-decode_bitset(struct tcb *const tcp, const kernel_ureg_t arg,
+decode_bitset(struct tcb *const tcp, const kernel_ulong_t arg,
const struct xlat decode_nr[], const unsigned int max_nr,
const char *const dflt)
{
tprints(", ");
unsigned int size;
- if ((kernel_ureg_t) tcp->u_rval > max_nr)
+ if ((kernel_ulong_t) tcp->u_rval > max_nr)
size = max_nr;
else
size = tcp->u_rval;
# ifdef EVIOCGMTSLOTS
static int
mtslots_ioctl(struct tcb *const tcp, const unsigned int code,
- const kernel_ureg_t arg)
+ const kernel_ulong_t arg)
{
tprints(", ");
# if defined EVIOCGREP || defined EVIOCSREP
static int
-repeat_ioctl(struct tcb *const tcp, const kernel_ureg_t arg)
+repeat_ioctl(struct tcb *const tcp, const kernel_ulong_t arg)
{
tprints(", ");
printpair_int(tcp, arg, "%u");
static int
bit_ioctl(struct tcb *const tcp, const unsigned int ev_nr,
- const kernel_ureg_t arg)
+ const kernel_ulong_t arg)
{
switch (ev_nr) {
case EV_SYN:
static int
evdev_read_ioctl(struct tcb *const tcp, const unsigned int code,
- const kernel_ureg_t arg)
+ const kernel_ulong_t arg)
{
/* fixed-number fixed-length commands */
switch (code) {
static int
evdev_write_ioctl(struct tcb *const tcp, const unsigned int code,
- const kernel_ureg_t arg)
+ const kernel_ulong_t arg)
{
/* fixed-number fixed-length commands */
switch (code) {
}
MPERS_PRINTER_DECL(int, evdev_ioctl, struct tcb *const tcp,
- const unsigned int code, const kernel_ureg_t arg)
+ const unsigned int code, const kernel_ulong_t arg)
{
switch(_IOC_DIR(code)) {
case _IOC_READ:
#include "defs.h"
static void
-printargv(struct tcb *const tcp, kernel_ureg_t addr)
+printargv(struct tcb *const tcp, kernel_ulong_t addr)
{
if (!addr || !verbose(tcp)) {
printaddr(addr);
}
static void
-printargc(struct tcb *const tcp, kernel_ureg_t addr)
+printargc(struct tcb *const tcp, kernel_ulong_t addr)
{
if (!addr || !verbose(tcp)) {
printaddr(addr);
}
static void
-printflock64(struct tcb *const tcp, const kernel_ureg_t addr, const int getlk)
+printflock64(struct tcb *const tcp, const kernel_ulong_t addr, const int getlk)
{
struct_kernel_flock64 fl;
}
static void
-printflock(struct tcb *const tcp, const kernel_ureg_t addr, const int getlk)
+printflock(struct tcb *const tcp, const kernel_ulong_t addr, const int getlk)
{
struct_kernel_flock64 fl;
}
static void
-print_f_owner_ex(struct tcb *const tcp, const kernel_ureg_t addr)
+print_f_owner_ex(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct { int type, pid; } owner;
if (entering(tcp) || syserror(tcp) || tcp->u_rval == 0)
return 0;
tcp->auxstr = sprintflags("flags ", fdflags,
- (kernel_ureg_t) tcp->u_rval);
+ (kernel_ulong_t) tcp->u_rval);
return RVAL_HEX | RVAL_STR;
case F_GETFL:
if (entering(tcp) || syserror(tcp))
case F_GETLEASE:
if (entering(tcp) || syserror(tcp))
return 0;
- tcp->auxstr = xlookup(lockfcmds, (kernel_ureg_t) tcp->u_rval);
+ tcp->auxstr = xlookup(lockfcmds, (kernel_ulong_t) tcp->u_rval);
return RVAL_HEX | RVAL_STR;
case F_GET_SEALS:
if (entering(tcp) || syserror(tcp) || tcp->u_rval == 0)
return 0;
tcp->auxstr = sprintflags("seals ", f_seals,
- (kernel_ureg_t) tcp->u_rval);
+ (kernel_ulong_t) tcp->u_rval);
return RVAL_HEX | RVAL_STR;
case F_GETSIG:
if (entering(tcp) || syserror(tcp) || tcp->u_rval == 0)
#include MPERS_DEFS
MPERS_PRINTER_DECL(bool, fetch_seccomp_fprog, struct tcb *const tcp,
- const kernel_ureg_t addr, void *const p)
+ const kernel_ulong_t addr, void *const p)
{
struct seccomp_fprog *pfp = p;
seccomp_fprog_t mfp;
&& FLOCK_MEMBERS_EQ(type, l_pid))
MPERS_PRINTER_DECL(bool, fetch_struct_flock, struct tcb *const tcp,
- const kernel_ureg_t addr, void *const p)
+ const kernel_ulong_t addr, void *const p)
{
struct_kernel_flock64 *pfl = p;
struct_flock mfl;
}
MPERS_PRINTER_DECL(bool, fetch_struct_flock64, struct tcb *const tcp,
- const kernel_ureg_t addr, void *const p)
+ const kernel_ulong_t addr, void *const p)
{
struct_kernel_flock64 *pfl = p;
struct_flock64 mfl;
*/
MPERS_PRINTER_DECL(int, fetch_struct_mmsghdr,
- struct tcb *const tcp, const kernel_ureg_t addr,
+ struct tcb *const tcp, const kernel_ulong_t addr,
void *const p)
{
struct mmsghdr *p_native = p;
*/
MPERS_PRINTER_DECL(int, fetch_struct_msghdr,
- struct tcb *const tcp, const kernel_ureg_t addr,
+ struct tcb *const tcp, const kernel_ulong_t addr,
void *const p)
{
struct msghdr *const p_native = p;
#endif
MPERS_PRINTER_DECL(bool, fetch_struct_stat,
- struct tcb *const tcp, const kernel_ureg_t addr,
+ struct tcb *const tcp, const kernel_ulong_t addr,
struct strace_stat *const dst)
{
#ifdef HAVE_STRUCT_STAT
#endif
MPERS_PRINTER_DECL(bool, fetch_struct_stat64,
- struct tcb *const tcp, const kernel_ureg_t addr,
+ struct tcb *const tcp, const kernel_ulong_t addr,
struct strace_stat *const dst)
{
#ifdef HAVE_STRUCT_STAT64
#include "statfs.h"
MPERS_PRINTER_DECL(bool, fetch_struct_statfs,
- struct tcb *const tcp, const kernel_ureg_t addr,
+ struct tcb *const tcp, const kernel_ulong_t addr,
struct strace_statfs *const p)
{
struct_statfs b;
#endif
MPERS_PRINTER_DECL(bool, fetch_struct_statfs64,
- struct tcb *const tcp, const kernel_ureg_t addr,
- const kernel_ureg_t size, struct strace_statfs *const p)
+ struct tcb *const tcp, const kernel_ulong_t addr,
+ const kernel_ulong_t size, struct strace_statfs *const p)
{
struct_statfs64 b;
SYS_FUNC(name_to_handle_at)
{
file_handle_header h;
- const kernel_ureg_t addr = tcp->u_arg[2];
+ const kernel_ulong_t addr = tcp->u_arg[2];
if (entering(tcp)) {
/* dirfd */
SYS_FUNC(open_by_handle_at)
{
file_handle_header h;
- const kernel_ureg_t addr = tcp->u_arg[1];
+ const kernel_ulong_t addr = tcp->u_arg[1];
/* mount_fd */
printfd(tcp, tcp->u_arg[0]);
int
file_ioctl(struct tcb *const tcp, const unsigned int code,
- const kernel_ureg_t arg)
+ const kernel_ulong_t arg)
{
switch (code) {
case FICLONE: /* W */
int
fs_x_ioctl(struct tcb *const tcp, const unsigned int code,
- const kernel_ureg_t arg)
+ const kernel_ulong_t arg)
{
switch (code) {
#ifdef FITRIM
SYS_FUNC(futex)
{
- const kernel_ureg_t uaddr = tcp->u_arg[0];
+ const kernel_ulong_t uaddr = tcp->u_arg[0];
const int op = tcp->u_arg[1];
const int cmd = op & 127;
- const kernel_ureg_t timeout = tcp->u_arg[3];
- const kernel_ureg_t uaddr2 = tcp->u_arg[4];
+ const kernel_ulong_t timeout = tcp->u_arg[3];
+ const kernel_ulong_t uaddr2 = tcp->u_arg[4];
const unsigned int val = tcp->u_arg[2];
const unsigned int val2 = tcp->u_arg[3];
const unsigned int val3 = tcp->u_arg[5];
#include MPERS_DEFS
MPERS_PRINTER_DECL(int, hdio_ioctl, struct tcb *const tcp,
- const unsigned int code, const kernel_ureg_t arg)
+ const unsigned int code, const kernel_ulong_t arg)
{
switch (code) {
case HDIO_GETGEO:
struct print_iovec_config {
enum iov_decode decode_iov;
- kernel_ureg_t data_size;
+ kernel_ulong_t data_size;
};
static bool
print_iovec(struct tcb *tcp, void *elem_buf, size_t elem_size, void *data)
{
- const kernel_ureg_t *iov;
- kernel_ureg_t iov_buf[2], len;
+ const kernel_ulong_t *iov;
+ kernel_ulong_t iov_buf[2], len;
struct print_iovec_config *c = data;
if (elem_size < sizeof(iov_buf)) {
case IOV_DECODE_STR:
if (len > c->data_size)
len = c->data_size;
- if (c->data_size != (kernel_ureg_t) -1)
+ if (c->data_size != (kernel_ulong_t) -1)
c->data_size -= len;
printstrn(tcp, iov[0], len);
break;
case IOV_DECODE_NETLINK:
if (len > c->data_size)
len = c->data_size;
- if (c->data_size != (kernel_ureg_t) -1)
+ if (c->data_size != (kernel_ulong_t) -1)
c->data_size -= len;
decode_netlink(tcp, iov[0], iov[1]);
break;
* Example: recvmsg returing a short read.
*/
void
-tprint_iov_upto(struct tcb *const tcp, const kernel_ureg_t len,
- const kernel_ureg_t addr, const enum iov_decode decode_iov,
- const kernel_ureg_t data_size)
+tprint_iov_upto(struct tcb *const tcp, const kernel_ulong_t len,
+ const kernel_ulong_t addr, const enum iov_decode decode_iov,
+ const kernel_ulong_t data_size)
{
- kernel_ureg_t iov[2];
+ kernel_ulong_t iov[2];
struct print_iovec_config config =
{ .decode_iov = decode_iov, .data_size = data_size };
ioctl_decode(struct tcb *tcp)
{
const unsigned int code = tcp->u_arg[1];
- const kernel_ureg_t arg = tcp->u_arg[2];
+ const kernel_ulong_t arg = tcp->u_arg[2];
switch (_IOC_TYPE(code)) {
#if defined(ALPHA) || defined(POWERPC)
}
static void
-tprint_msgsnd(struct tcb *const tcp, const kernel_ureg_t addr,
- const kernel_ureg_t count, const unsigned int flags)
+tprint_msgsnd(struct tcb *const tcp, const kernel_ulong_t addr,
+ const kernel_ulong_t count, const unsigned int flags)
{
tprint_msgbuf(tcp, addr, count);
printflags(ipc_msg_flags, flags, "MSG_???");
}
static void
-tprint_msgrcv(struct tcb *const tcp, const kernel_ureg_t addr,
- const kernel_ureg_t count, const kernel_ureg_t msgtyp)
+tprint_msgrcv(struct tcb *const tcp, const kernel_ulong_t addr,
+ const kernel_ulong_t count, const kernel_ulong_t msgtyp)
{
tprint_msgbuf(tcp, addr, count);
tprintf("%" PRI_krd ", ", msgtyp);
}
static int
-fetch_msgrcv_args(struct tcb *const tcp, const kernel_ureg_t addr,
- kernel_ureg_t *const pair)
+fetch_msgrcv_args(struct tcb *const tcp, const kernel_ulong_t addr,
+ kernel_ulong_t *const pair)
{
if (current_wordsize == sizeof(*pair)) {
if (umoven_or_printaddr(tcp, addr, 2 * sizeof(*pair), pair))
tprint_msgrcv(tcp, tcp->u_arg[3],
tcp->u_arg[1], tcp->u_arg[4]);
} else {
- kernel_ureg_t pair[2];
+ kernel_ulong_t pair[2];
if (fetch_msgrcv_args(tcp, tcp->u_arg[3], pair))
tprintf(", %" PRI_kru ", ", tcp->u_arg[1]);
#include "xlat/msgctl_flags.h"
static void
-print_msqid_ds(struct tcb *const tcp, const kernel_ureg_t addr, int cmd)
+print_msqid_ds(struct tcb *const tcp, const kernel_ulong_t addr, int cmd)
{
/* TODO: We don't properly decode old compat ipc calls. */
if (cmd & IPC_64)
PRINTCTL(msgctl_flags, tcp->u_arg[1], "MSG_???");
tprints(", ");
} else {
- const kernel_ureg_t addr = tcp->u_arg[indirect_ipccall(tcp) ? 3 : 2];
+ const kernel_ulong_t addr = tcp->u_arg[indirect_ipccall(tcp) ? 3 : 2];
print_msqid_ds(tcp, addr, tcp->u_arg[1]);
}
return 0;
#endif
static void
-tprint_sembuf_array(struct tcb *const tcp, const kernel_ureg_t addr,
+tprint_sembuf_array(struct tcb *const tcp, const kernel_ulong_t addr,
const unsigned int count)
{
#if defined HAVE_SYS_SEM_H || defined HAVE_LINUX_SEM_H
#include "xlat/shmctl_flags.h"
static void
-print_shmid_ds(struct tcb *const tcp, const kernel_ureg_t addr, int cmd)
+print_shmid_ds(struct tcb *const tcp, const kernel_ulong_t addr, int cmd)
{
/* TODO: We don't properly decode old compat ipc calls. */
if (cmd & IPC_64)
PRINTCTL(shmctl_flags, tcp->u_arg[1], "SHM_???");
tprints(", ");
} else {
- const kernel_ureg_t addr = tcp->u_arg[indirect_ipccall(tcp) ? 3 : 2];
+ const kernel_ulong_t addr = tcp->u_arg[indirect_ipccall(tcp) ? 3 : 2];
print_shmid_ds(tcp, addr, tcp->u_arg[1]);
}
return 0;
# endif
-typedef kernel_ulong_t kernel_scno_t;
-typedef kernel_ulong_t kernel_ureg_t;
-
typedef struct {
kernel_ulong_t d_ino;
kernel_ulong_t d_off;
static bool
print_seg(struct tcb *tcp, void *elem_buf, size_t elem_size, void *data)
{
- const kernel_ureg_t *seg;
- kernel_ureg_t seg_buf[4];
+ const kernel_ulong_t *seg;
+ kernel_ulong_t seg_buf[4];
if (elem_size < sizeof(seg_buf)) {
unsigned int i;
}
static void
-print_kexec_segments(struct tcb *const tcp, const kernel_ureg_t addr,
- const kernel_ureg_t len)
+print_kexec_segments(struct tcb *const tcp, const kernel_ulong_t addr,
+ const kernel_ulong_t len)
{
if (len > KEXEC_SEGMENT_MAX) {
printaddr(addr);
return;
}
- kernel_ureg_t seg[4];
+ kernel_ulong_t seg[4];
const size_t sizeof_seg = ARRAY_SIZE(seg) * current_wordsize;
print_array(tcp, addr, len, seg, sizeof_seg,
tprints(", ");
/* flags */
- kernel_ureg_t n = tcp->u_arg[3];
+ kernel_ulong_t n = tcp->u_arg[3];
printxval64(kexec_arch_values, n & KEXEC_ARCH_MASK, "KEXEC_ARCH_???");
- n &= ~(kernel_ureg_t) KEXEC_ARCH_MASK;
+ n &= ~(kernel_ulong_t) KEXEC_ARCH_MASK;
if (n) {
tprints("|");
printflags64(kexec_load_flags, n, "KEXEC_???");
# include <asm/ldt.h>
void
-print_user_desc(struct tcb *const tcp, const kernel_ureg_t addr)
+print_user_desc(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct user_desc desc;
static int
arch_get_scno(struct tcb *tcp)
{
- kernel_scno_t scno = 0;
+ kernel_ulong_t scno = 0;
switch (aarch64_io.iov_len) {
case sizeof(aarch64_regs):
*/
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
unsigned int n = (uint16_t) scno;
const struct iovec io = {
static int
arch_get_scno(struct tcb *tcp)
{
- kernel_scno_t scno = 0;
+ kernel_ulong_t scno = 0;
if (upeek(tcp->pid, REG_A3, &alpha_a3) < 0)
return -1;
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
return upoke(tcp->pid, REG_R0, scno);
}
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
arc_regs.scratch.r8 = scno;
return set_regs(tcp->pid);
static int
arch_get_scno(struct tcb *tcp)
{
- kernel_scno_t scno = 0;
+ kernel_ulong_t scno = 0;
/* Note: we support only 32-bit CPUs, not 26-bit */
*/
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
unsigned int n = (uint16_t) scno;
int rc = ptrace(PTRACE_SET_SYSCALL, tcp->pid, NULL, (unsigned long) n);
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
avr32_regs.r8 = scno;
return set_regs(tcp->pid);
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
return upoke(tcp->pid, PT_ORIG_P0, scno);
}
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
return upoke(tcp->pid, 4 * PT_R9, scno);
}
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
return upoke(tcp->pid, PT_GR20, scno);
}
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
#ifdef HAVE_GETREGS_OLD
return upoke(tcp->pid, 4 * ORIG_EAX, scno);
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
if (ia64_ia32mode)
ia64_regs.gr[0] = scno;
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
m68k_regs.orig_d0 = scno;
return set_regs(tcp->pid);
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
metag_regs.dx[0][1] = scno;
return set_regs(tcp->pid);
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
return upoke(tcp->pid, 0, scno);
}
* offsetof(struct sigframe, sf_mask) ==
* sizeof(sf_ass) + sizeof(sf_pad) + sizeof(struct sigcontext)
*/
- const kernel_ureg_t addr = mips_REG_SP + 6 * 4 +
+ const kernel_ulong_t addr = mips_REG_SP + 6 * 4 +
sizeof(struct sigcontext);
#else
/*
* offsetof(struct rt_sigframe, rs_uc) ==
* sizeof(sf_ass) + sizeof(sf_pad) + sizeof(struct siginfo)
*/
- const kernel_ureg_t addr = mips_REG_SP + 6 * 4 + 128 +
+ const kernel_ulong_t addr = mips_REG_SP + 6 * 4 + 128 +
offsetof(struct ucontext, uc_sigmask);
#endif
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
mips_REG_V0 = scno;
return set_regs(tcp->pid);
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
nios2_regs.regs[2] = scno;
return set_regs(tcp->pid);
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
or1k_regs.gpr[11] = scno;
return set_regs(tcp->pid);
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
#ifdef HAVE_GETREGS_OLD
return upoke(tcp->pid, sizeof(long) * PT_R0, scno);
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
riscv_regs.a7 = scno;
return set_regs(tcp->pid);
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
s390_regset.gprs[2] = scno;
return set_regs(tcp->pid);
static int
arch_get_scno(struct tcb *tcp)
{
- kernel_scno_t scno = 0;
+ kernel_ulong_t scno = 0;
/*
* In the new syscall ABI, the system call number is in R3.
/* Odd as it may seem, a glibc bug has been known to cause
glibc to issue bogus negative syscall numbers. So for
our purposes, make strace print what it *should* have been */
- kernel_scno_t correct_scno = (scno & 0xff);
+ kernel_ulong_t correct_scno = (scno & 0xff);
if (debug_flag)
error_msg("Detected glibc bug: bogus system call"
" number = %ld, correcting to %ld",
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
return upoke(tcp->pid, 4 * (REG_REG0 + 3), scno);
}
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
return upoke(tcp->pid, REG_SYSCALL, scno);
}
*/
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
sparc_regs.u_regs[U_REG_G1] = scno;
return set_regs(tcp->pid);
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
tile_regs.regs[10] = scno;
return set_regs(tcp->pid);
#define X86_64_SIGMASK_OFFSET offsetof(struct ucontext, uc_sigmask)
#define X32_SIGMASK_OFFSET sizeof(ucontext_x32_header)
- const kernel_ureg_t offset =
+ const kernel_ulong_t offset =
#ifdef X32
X32_SIGMASK_OFFSET;
#else
current_personality == 2 ? X32_SIGMASK_OFFSET :
X86_64_SIGMASK_OFFSET;
#endif
- const kernel_ureg_t addr = (kernel_ureg_t) *x86_64_rsp_ptr + offset;
+ const kernel_ulong_t addr = (kernel_ulong_t) *x86_64_rsp_ptr + offset;
tprints("{mask=");
print_sigset_addr_len(tcp, addr, NSIG / 8);
tprints("}");
static int
arch_get_scno(struct tcb *tcp)
{
- kernel_scno_t scno = 0;
+ kernel_ulong_t scno = 0;
unsigned int currpers;
#ifndef __X32_SYSCALL_BIT
#endif /* !HAVE_GETREGS_OLD */
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
#ifdef HAVE_GETREGS_OLD
return upoke(tcp->pid, 8 * ORIG_RAX, scno);
static int
-arch_set_scno(struct tcb *tcp, kernel_scno_t scno)
+arch_set_scno(struct tcb *tcp, kernel_ulong_t scno)
{
return upoke(tcp->pid, SYSCALL_NR, scno);
}
#include "xlat/loop_crypt_type_options.h"
static void
-decode_loop_info(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_loop_info(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct loop_info info;
}
static void
-decode_loop_info64(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_loop_info64(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct loop_info64 info64;
int
loop_ioctl(struct tcb *const tcp, const unsigned int code,
- const kernel_ureg_t arg)
+ const kernel_ulong_t arg)
{
if (!verbose(tcp))
return RVAL_DECODED;
#include "xlat/mmap_flags.h"
static void
-print_mmap(struct tcb *tcp, kernel_ureg_t *u_arg, unsigned long long offset)
+print_mmap(struct tcb *tcp, kernel_ulong_t *u_arg, unsigned long long offset)
{
- const kernel_ureg_t addr = u_arg[0];
- const kernel_ureg_t len = u_arg[1];
- const kernel_ureg_t prot = u_arg[2];
- const kernel_ureg_t flags = u_arg[3];
+ const kernel_ulong_t addr = u_arg[0];
+ const kernel_ulong_t len = u_arg[1];
+ const kernel_ulong_t prot = u_arg[2];
+ const kernel_ulong_t flags = u_arg[3];
const int fd = u_arg[4];
printaddr(addr);
/* Params are pointed to by u_arg[0], offset is in bytes */
SYS_FUNC(old_mmap)
{
- kernel_ureg_t u_arg[6];
+ kernel_ulong_t u_arg[6];
# ifndef current_klongsize
/* We are here only in a 32-bit personality. */
unsigned int narrow_arg[6];
/* Params are pointed to by u_arg[0], offset is in pages */
SYS_FUNC(old_mmap_pgoff)
{
- kernel_ureg_t u_arg[5];
+ kernel_ulong_t u_arg[5];
int i;
unsigned int narrow_arg[6];
unsigned long long offset;
SYS_FUNC(remap_file_pages)
{
- const kernel_ureg_t addr = tcp->u_arg[0];
- const kernel_ureg_t size = tcp->u_arg[1];
- const kernel_ureg_t prot = tcp->u_arg[2];
- const kernel_ureg_t pgoff = tcp->u_arg[3];
- const kernel_ureg_t flags = tcp->u_arg[4];
+ const kernel_ulong_t addr = tcp->u_arg[0];
+ const kernel_ulong_t size = tcp->u_arg[1];
+ const kernel_ulong_t prot = tcp->u_arg[2];
+ const kernel_ulong_t pgoff = tcp->u_arg[3];
+ const kernel_ulong_t flags = tcp->u_arg[4];
printaddr(addr);
tprintf(", %" PRI_kru ", ", size);
SYS_FUNC(subpage_prot)
{
- kernel_ureg_t addr = tcp->u_arg[0];
- kernel_ureg_t len = tcp->u_arg[1];
- kernel_ureg_t nmemb = len >> 16;
- kernel_ureg_t map = tcp->u_arg[2];
+ kernel_ulong_t addr = tcp->u_arg[0];
+ kernel_ulong_t len = tcp->u_arg[1];
+ kernel_ulong_t nmemb = len >> 16;
+ kernel_ulong_t map = tcp->u_arg[2];
printaddr(addr);
tprintf(", %" PRI_kru ", ", len);
return 0;
tcp->auxstr = sprintflags("", membarrier_cmds,
- (kernel_ureg_t) tcp->u_rval);
+ (kernel_ulong_t) tcp->u_rval);
return RVAL_HEX | RVAL_STR;
}
static int
fetch_struct_mmsghdr_or_printaddr(struct tcb *const tcp,
- const kernel_ureg_t addr,
+ const kernel_ulong_t addr,
const unsigned int len, void *const mh)
{
if ((entering(tcp) || !syserror(tcp))
tprints("{msg_hdr=");
print_struct_msghdr(tcp, &mmsg->msg_hdr, c->p_user_msg_namelen,
- c->use_msg_len ? mmsg->msg_len : (kernel_ureg_t) -1);
+ c->use_msg_len ? mmsg->msg_len : (kernel_ulong_t) -1);
if (c->msg_len_vlen) {
tprintf(", msg_len=%u", mmsg->msg_len);
--c->msg_len_vlen;
};
static void
-save_mmsgvec_namelen(struct tcb *const tcp, kernel_ureg_t addr,
+save_mmsgvec_namelen(struct tcb *const tcp, kernel_ulong_t addr,
unsigned int len, const char *const timeout)
{
if (len > IOV_MAX)
}
static void
-decode_mmsgvec(struct tcb *const tcp, const kernel_ureg_t addr,
+decode_mmsgvec(struct tcb *const tcp, const kernel_ulong_t addr,
const unsigned int vlen, const unsigned int msg_len_vlen,
const bool use_msg_len)
{
}
void
-dumpiov_in_mmsghdr(struct tcb *const tcp, kernel_ureg_t addr)
+dumpiov_in_mmsghdr(struct tcb *const tcp, kernel_ulong_t addr)
{
unsigned int len = tcp->u_rval;
unsigned int i, fetched;
if (!fetched)
break;
tprintf(" = %" PRI_kru " buffers in vector %u\n",
- (kernel_ureg_t) mmsg.msg_hdr.msg_iovlen, i);
+ (kernel_ulong_t) mmsg.msg_hdr.msg_iovlen, i);
dumpiov_upto(tcp, mmsg.msg_hdr.msg_iovlen,
ptr_to_kulong(mmsg.msg_hdr.msg_iov),
mmsg.msg_len);
bool ignore_type = false;
bool ignore_data = false;
bool old_magic = false;
- kernel_ureg_t flags = tcp->u_arg[3];
+ kernel_ulong_t flags = tcp->u_arg[3];
/* Discard magic */
if ((flags & MS_MGC_MSK) == MS_MGC_VAL) {
}
static void
-decode_msg_control(struct tcb *const tcp, const kernel_ureg_t addr,
- const kernel_ureg_t in_control_len)
+decode_msg_control(struct tcb *const tcp, const kernel_ulong_t addr,
+ const kernel_ulong_t in_control_len)
{
if (!in_control_len)
return;
tprints("[");
while (buf_len >= cmsg_size) {
- const kernel_ureg_t cmsg_len =
+ const kernel_ulong_t cmsg_len =
#if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
(current_wordsize < sizeof(long)) ? u.cmsg32->cmsg_len :
#endif
printxval(socketlayers, cmsg_level, "SOL_???");
tprints(", cmsg_type=");
- kernel_ureg_t len = cmsg_len > buf_len ? buf_len : cmsg_len;
+ kernel_ulong_t len = cmsg_len > buf_len ? buf_len : cmsg_len;
print_cmsg_type_data(tcp, cmsg_level, cmsg_type,
(const void *) (u.ptr + cmsg_size),
break;
}
len = (cmsg_len + current_wordsize - 1) &
- ~((kernel_ureg_t) current_wordsize - 1);
+ ~((kernel_ulong_t) current_wordsize - 1);
if (len >= buf_len) {
buf_len = 0;
break;
void
print_struct_msghdr(struct tcb *tcp, const struct msghdr *msg,
const int *const p_user_msg_namelen,
- const kernel_ureg_t data_size)
+ const kernel_ulong_t data_size)
{
const int msg_namelen =
p_user_msg_namelen && (int) msg->msg_namelen > *p_user_msg_namelen
tprint_iov_upto(tcp, msg->msg_iovlen,
ptr_to_kulong(msg->msg_iov), decode, data_size);
- tprintf(", msg_iovlen=%" PRI_kru, (kernel_ureg_t) msg->msg_iovlen);
+ tprintf(", msg_iovlen=%" PRI_kru, (kernel_ulong_t) msg->msg_iovlen);
decode_msg_control(tcp, ptr_to_kulong(msg->msg_control),
msg->msg_controllen);
- tprintf(", msg_controllen=%" PRI_kru, (kernel_ureg_t) msg->msg_controllen);
+ tprintf(", msg_controllen=%" PRI_kru, (kernel_ulong_t) msg->msg_controllen);
tprints(", msg_flags=");
printflags(msg_flags, msg->msg_flags, "MSG_???");
}
static bool
-fetch_msghdr_namelen(struct tcb *const tcp, const kernel_ureg_t addr,
+fetch_msghdr_namelen(struct tcb *const tcp, const kernel_ulong_t addr,
int *const p_msg_namelen)
{
struct msghdr msg;
static void
decode_msghdr(struct tcb *const tcp, const int *const p_user_msg_namelen,
- const kernel_ureg_t addr, const kernel_ureg_t data_size)
+ const kernel_ulong_t addr, const kernel_ulong_t data_size)
{
struct msghdr msg;
}
void
-dumpiov_in_msghdr(struct tcb *const tcp, const kernel_ureg_t addr,
- const kernel_ureg_t data_size)
+dumpiov_in_msghdr(struct tcb *const tcp, const kernel_ulong_t addr,
+ const kernel_ulong_t data_size)
{
struct msghdr msg;
extern void
print_struct_msghdr(struct tcb *, const struct msghdr *,
- const int *p_user_msg_namelen, kernel_ureg_t data_size);
+ const int *p_user_msg_namelen, kernel_ulong_t data_size);
#endif /* !STRACE_MSGHDR_H */
#include "xlat/mtd_nandecc_options.h"
static void
-decode_erase_info_user(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_erase_info_user(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct erase_info_user einfo;
}
static void
-decode_erase_info_user64(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_erase_info_user64(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct erase_info_user64 einfo64;
}
static void
-decode_mtd_oob_buf(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_mtd_oob_buf(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct_mtd_oob_buf mbuf;
}
static void
-decode_mtd_oob_buf64(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_mtd_oob_buf64(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct mtd_oob_buf64 mbuf64;
}
static void
-decode_otp_info(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_otp_info(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct otp_info oinfo;
}
static void
-decode_otp_select(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_otp_select(struct tcb *const tcp, const kernel_ulong_t addr)
{
unsigned int i;
}
static void
-decode_mtd_write_req(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_mtd_write_req(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct mtd_write_req mreq;
}
static void
-decode_mtd_info_user(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_mtd_info_user(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct mtd_info_user minfo;
}
static void
-decode_nand_oobinfo(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_nand_oobinfo(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct nand_oobinfo ninfo;
unsigned int i, j;
}
static void
-decode_nand_ecclayout_user(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_nand_ecclayout_user(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct nand_ecclayout_user nlay;
unsigned int i;
}
static void
-decode_mtd_ecc_stats(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_mtd_ecc_stats(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct mtd_ecc_stats es;
}
MPERS_PRINTER_DECL(int, mtd_ioctl, struct tcb *const tcp,
- const unsigned int code, const kernel_ureg_t arg)
+ const unsigned int code, const kernel_ulong_t arg)
{
switch (code) {
case MEMERASE:
}
static void
-decode_sockbuf(struct tcb *const tcp, const int fd, const kernel_ureg_t addr,
- const kernel_ureg_t addrlen)
+decode_sockbuf(struct tcb *const tcp, const int fd, const kernel_ulong_t addr,
+ const kernel_ulong_t addrlen)
{
switch (verbose(tcp) ? getfdproto(tcp, fd) : SOCK_PROTO_UNKNOWN) {
static bool
fetch_socklen(struct tcb *const tcp, int *const plen,
- const kernel_ureg_t sockaddr, const kernel_ureg_t socklen)
+ const kernel_ulong_t sockaddr, const kernel_ulong_t socklen)
{
return verbose(tcp) && sockaddr && socklen
&& umove(tcp, socklen, plen) == 0;
}
static void
-decode_pair_fd(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_pair_fd(struct tcb *const tcp, const kernel_ulong_t addr)
{
int pair[2];
}
static void
-print_linger(struct tcb *const tcp, const kernel_ureg_t addr, const int len)
+print_linger(struct tcb *const tcp, const kernel_ulong_t addr, const int len)
{
struct linger linger;
#ifdef SO_PEERCRED
static void
-print_ucred(struct tcb *const tcp, const kernel_ureg_t addr, const int len)
+print_ucred(struct tcb *const tcp, const kernel_ulong_t addr, const int len)
{
struct ucred uc;
#ifdef PACKET_STATISTICS
static void
-print_tpacket_stats(struct tcb *const tcp, const kernel_ureg_t addr,
+print_tpacket_stats(struct tcb *const tcp, const kernel_ulong_t addr,
const int len)
{
struct tpacket_stats stats;
#include "xlat/icmpfilterflags.h"
static void
-print_icmp_filter(struct tcb *const tcp, const kernel_ureg_t addr, int len)
+print_icmp_filter(struct tcb *const tcp, const kernel_ulong_t addr, int len)
{
struct icmp_filter filter = {};
static void
print_getsockopt(struct tcb *const tcp, const unsigned int level,
- const unsigned int name, const kernel_ureg_t addr,
+ const unsigned int name, const kernel_ulong_t addr,
const int len)
{
if (addr && verbose(tcp))
#ifdef IP_ADD_MEMBERSHIP
static void
-print_mreq(struct tcb *const tcp, const kernel_ureg_t addr,
+print_mreq(struct tcb *const tcp, const kernel_ulong_t addr,
const unsigned int len)
{
struct ip_mreq mreq;
#ifdef IPV6_ADD_MEMBERSHIP
static void
-print_mreq6(struct tcb *const tcp, const kernel_ureg_t addr,
+print_mreq6(struct tcb *const tcp, const kernel_ulong_t addr,
const unsigned int len)
{
struct ipv6_mreq mreq;
#ifdef MCAST_JOIN_GROUP
static void
-print_group_req(struct tcb *const tcp, const kernel_ureg_t addr, const int len)
+print_group_req(struct tcb *const tcp, const kernel_ulong_t addr, const int len)
{
struct group_req greq;
#ifdef PACKET_RX_RING
static void
-print_tpacket_req(struct tcb *const tcp, const kernel_ureg_t addr, const int len)
+print_tpacket_req(struct tcb *const tcp, const kernel_ulong_t addr, const int len)
{
struct tpacket_req req;
# include "xlat/packet_mreq_type.h"
static void
-print_packet_mreq(struct tcb *const tcp, const kernel_ureg_t addr, const int len)
+print_packet_mreq(struct tcb *const tcp, const kernel_ulong_t addr, const int len)
{
struct packet_mreq mreq;
static void
print_setsockopt(struct tcb *const tcp, const unsigned int level,
- const unsigned int name, const kernel_ureg_t addr,
+ const unsigned int name, const kernel_ulong_t addr,
const int len)
{
if (addr && verbose(tcp))
*/
static bool
fetch_nlmsghdr(struct tcb *const tcp, struct nlmsghdr *const nlmsghdr,
- const kernel_ureg_t addr, const kernel_ureg_t len)
+ const kernel_ulong_t addr, const kernel_ulong_t len)
{
if (len < sizeof(struct nlmsghdr)) {
printstrn(tcp, addr, len);
static void
decode_nlmsghdr_with_payload(struct tcb *const tcp,
const struct nlmsghdr *const nlmsghdr,
- const kernel_ureg_t addr,
- const kernel_ureg_t len)
+ const kernel_ulong_t addr,
+ const kernel_ulong_t len)
{
tprints("{");
}
void
-decode_netlink(struct tcb *const tcp, kernel_ureg_t addr, kernel_ureg_t len)
+decode_netlink(struct tcb *const tcp, kernel_ulong_t addr, kernel_ulong_t len)
{
struct nlmsghdr nlmsghdr;
bool print_array = false;
}
unsigned int nlmsg_len = NLMSG_ALIGN(nlmsghdr.nlmsg_len);
- kernel_ureg_t next_addr = 0;
- kernel_ureg_t next_len = 0;
+ kernel_ulong_t next_addr = 0;
+ kernel_ulong_t next_len = 0;
if (nlmsghdr.nlmsg_len >= sizeof(struct nlmsghdr)) {
next_len = (len >= nlmsg_len) ? len - nlmsg_len : 0;
static bool
print_node(struct tcb *tcp, void *elem_buf, size_t elem_size, void *data)
{
- if (elem_size < sizeof(kernel_ureg_t)) {
+ if (elem_size < sizeof(kernel_ulong_t)) {
tprintf("%#0*x", (int) elem_size * 2 + 2,
* (unsigned int *) elem_buf);
} else {
tprintf("%#0*" PRI_krx, (int) elem_size * 2 + 2,
- * (kernel_ureg_t *) elem_buf);
+ * (kernel_ulong_t *) elem_buf);
}
return true;
}
static void
-print_nodemask(struct tcb *const tcp, const kernel_ureg_t addr,
- const kernel_ureg_t maxnodes)
+print_nodemask(struct tcb *const tcp, const kernel_ulong_t addr,
+ const kernel_ulong_t maxnodes)
{
const unsigned int bits_per_long = 8 * current_wordsize;
- const kernel_ureg_t nmemb =
+ const kernel_ulong_t nmemb =
(maxnodes + bits_per_long - 2) / bits_per_long;
if (nmemb < maxnodes / bits_per_long ||
return;
}
- kernel_ureg_t buf;
+ kernel_ulong_t buf;
print_array(tcp, addr, nmemb, &buf, current_wordsize,
umoven_or_printaddr, print_node, 0);
}
static bool
print_addr(struct tcb *tcp, void *elem_buf, size_t elem_size, void *data)
{
- kernel_ureg_t addr;
+ kernel_ulong_t addr;
if (elem_size < sizeof(addr)) {
addr = * (unsigned int *) elem_buf;
} else {
- addr = * (kernel_ureg_t *) elem_buf;
+ addr = * (kernel_ulong_t *) elem_buf;
}
printaddr(addr);
SYS_FUNC(move_pages)
{
- const kernel_ureg_t npages = tcp->u_arg[1];
- kernel_ureg_t buf;
+ const kernel_ulong_t npages = tcp->u_arg[1];
+ kernel_ulong_t buf;
if (entering(tcp)) {
tprintf("%d, %" PRI_kru ", ", (int) tcp->u_arg[0], npages);
#ifdef HAVE_STRUCT___OLD_KERNEL_STAT
static void
-print_old_kernel_stat(struct tcb *const tcp, const kernel_ureg_t addr)
+print_old_kernel_stat(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct __old_kernel_stat buf;
if (umove_or_printaddr(tcp, addr, &buf))
* Return true if specified path (in user-space) matches.
*/
static int
-upathmatch(struct tcb *const tcp, const kernel_ureg_t upath)
+upathmatch(struct tcb *const tcp, const kernel_ulong_t upath)
{
char path[PATH_MAX + 1];
{
int i, j;
int nfds;
- kernel_ureg_t *args;
- kernel_ureg_t select_args[5];
+ kernel_ulong_t *args;
+ kernel_ulong_t select_args[5];
unsigned int oldselect_args[5];
unsigned int fdsize;
fd_set *fds;
{
struct pollfd fds;
unsigned nfds;
- kernel_ureg_t start, cur, end;
+ kernel_ulong_t start, cur, end;
start = tcp->u_arg[0];
nfds = tcp->u_arg[1];
}
static int
-fetch_perf_event_attr(struct tcb *const tcp, const kernel_ureg_t addr)
+fetch_perf_event_attr(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct pea_desc *desc;
struct perf_event_attr *attr;
} while (0)
static void
-print_perf_event_attr(struct tcb *const tcp, const kernel_ureg_t addr)
+print_perf_event_attr(struct tcb *const tcp, const kernel_ulong_t addr)
{
static const char *precise_ip_desc[] = {
"arbitrary skid",
static void
decode_poll_entering(struct tcb *tcp)
{
- const kernel_ureg_t addr = tcp->u_arg[0];
+ const kernel_ulong_t addr = tcp->u_arg[0];
const unsigned int nfds = tcp->u_arg[1];
struct pollfd fds;
}
static int
-decode_poll_exiting(struct tcb *const tcp, const kernel_ureg_t pts)
+decode_poll_exiting(struct tcb *const tcp, const kernel_ulong_t pts)
{
struct pollfd fds;
const unsigned int nfds = tcp->u_arg[1];
const unsigned long size = sizeof(fds) * nfds;
- const kernel_ureg_t start = tcp->u_arg[0];
- const kernel_ureg_t end = start + size;
- kernel_ureg_t cur;
+ const kernel_ulong_t start = tcp->u_arg[0];
+ const kernel_ulong_t end = start + size;
+ kernel_ulong_t cur;
const unsigned int max_printed =
abbrev(tcp) ? max_strlen : -1U;
unsigned int printed;
break;
if (syserror(tcp))
return 0;
- tcp->auxstr = xlookup(pr_dumpable, (kernel_ureg_t) tcp->u_rval);
+ tcp->auxstr = xlookup(pr_dumpable, (kernel_ulong_t) tcp->u_rval);
return RVAL_STR;
case PR_GET_NAME:
if (syserror(tcp) || tcp->u_rval == 0)
return 0;
tcp->auxstr = sprintflags("", secbits,
- (kernel_ureg_t) tcp->u_rval);
+ (kernel_ulong_t) tcp->u_rval);
return RVAL_STR;
case PR_GET_TID_ADDRESS:
if (syserror(tcp) || tcp->u_rval == 0)
return 0;
tcp->auxstr = sprintflags("", pr_fp_mode,
- (kernel_ureg_t) tcp->u_rval);
+ (kernel_ulong_t) tcp->u_rval);
return RVAL_STR;
/* PR_TASK_PERF_EVENTS_* take no arguments. */
if (syserror(tcp))
return 0;
tcp->auxstr = xlookup(pr_mce_kill_policy,
- (kernel_ureg_t) tcp->u_rval);
+ (kernel_ulong_t) tcp->u_rval);
return tcp->auxstr ? RVAL_STR : RVAL_UDECIMAL;
case PR_SET_FP_MODE:
#include MPERS_DEFS
MPERS_PRINTER_DECL(void, printmqattr, struct tcb *const tcp,
- const kernel_ureg_t addr, const bool decode_flags)
+ const kernel_ulong_t addr, const bool decode_flags)
{
#if defined HAVE_MQUEUE_H || defined HAVE_LINUX_MQUEUE_H
mq_attr_t attr;
#include MPERS_DEFS
MPERS_PRINTER_DECL(void, tprint_msgbuf, struct tcb *const tcp,
- const kernel_ureg_t addr, const kernel_ureg_t count)
+ const kernel_ulong_t addr, const kernel_ulong_t count)
{
msgbuf_t msg;
#include "xlat/sigev_value.h"
MPERS_PRINTER_DECL(void, print_sigevent,
- struct tcb *const tcp, const kernel_ureg_t addr)
+ struct tcb *const tcp, const kernel_ulong_t addr)
{
struct_sigevent sev;
}
void
-print_struct_statfs(struct tcb *const tcp, const kernel_ureg_t addr)
+print_struct_statfs(struct tcb *const tcp, const kernel_ulong_t addr)
{
#ifdef HAVE_STRUCT_STATFS
struct strace_statfs b;
}
void
-print_struct_statfs64(struct tcb *const tcp, const kernel_ureg_t addr,
- const kernel_ureg_t size)
+print_struct_statfs64(struct tcb *const tcp, const kernel_ulong_t addr,
+ const kernel_ulong_t size)
{
#ifdef HAVE_STRUCT_STATFS64
struct strace_statfs b;
}
MPERS_PRINTER_DECL(void, print_timespec,
- struct tcb *const tcp, const kernel_ureg_t addr)
+ struct tcb *const tcp, const kernel_ulong_t addr)
{
timespec_t t;
}
MPERS_PRINTER_DECL(const char *, sprint_timespec,
- struct tcb *const tcp, const kernel_ureg_t addr)
+ struct tcb *const tcp, const kernel_ulong_t addr)
{
timespec_t t;
static char buf[sizeof(timespec_fmt) + 3 * sizeof(t)];
}
MPERS_PRINTER_DECL(void, print_timespec_utime_pair,
- struct tcb *const tcp, const kernel_ureg_t addr)
+ struct tcb *const tcp, const kernel_ulong_t addr)
{
timespec_t t[2];
}
MPERS_PRINTER_DECL(void, print_itimerspec,
- struct tcb *const tcp, const kernel_ureg_t addr)
+ struct tcb *const tcp, const kernel_ulong_t addr)
{
timespec_t t[2];
}
MPERS_PRINTER_DECL(void, print_timeval,
- struct tcb *const tcp, const kernel_ureg_t addr)
+ struct tcb *const tcp, const kernel_ulong_t addr)
{
timeval_t t;
}
MPERS_PRINTER_DECL(void, print_timeval_pair,
- struct tcb *const tcp, const kernel_ureg_t addr)
+ struct tcb *const tcp, const kernel_ulong_t addr)
{
timeval_t t;
}
MPERS_PRINTER_DECL(const char *, sprint_timeval,
- struct tcb *const tcp, const kernel_ureg_t addr)
+ struct tcb *const tcp, const kernel_ulong_t addr)
{
timeval_t t;
static char buf[sizeof(timeval_fmt) + 3 * sizeof(t)];
}
MPERS_PRINTER_DECL(void, print_itimerval,
- struct tcb *const tcp, const kernel_ureg_t addr)
+ struct tcb *const tcp, const kernel_ulong_t addr)
{
timeval_t t[2];
}
void
-print_timeval32(struct tcb *const tcp, const kernel_ureg_t addr)
+print_timeval32(struct tcb *const tcp, const kernel_ulong_t addr)
{
timeval32_t t;
}
void
-print_timeval32_pair(struct tcb *const tcp, const kernel_ureg_t addr)
+print_timeval32_pair(struct tcb *const tcp, const kernel_ulong_t addr)
{
timeval32_t t[2];
}
void
-print_itimerval32(struct tcb *const tcp, const kernel_ureg_t addr)
+print_itimerval32(struct tcb *const tcp, const kernel_ulong_t addr)
{
timeval32_t t[2];
}
const char *
-sprint_timeval32(struct tcb *const tcp, const kernel_ureg_t addr)
+sprint_timeval32(struct tcb *const tcp, const kernel_ulong_t addr)
{
timeval32_t t;
static char buf[sizeof(timeval_fmt) + 3 * sizeof(t)];
#include "xlat/adjtimex_status.h"
MPERS_PRINTER_DECL(int, print_timex,
- struct tcb *const tcp, const kernel_ureg_t addr)
+ struct tcb *const tcp, const kernel_ulong_t addr)
{
struct_timex tx;
#include MPERS_DEFS
MPERS_PRINTER_DECL(void, printrusage,
- struct tcb *const tcp, const kernel_ureg_t addr)
+ struct tcb *const tcp, const kernel_ulong_t addr)
{
rusage_t ru;
#ifdef ALPHA
void
-printrusage32(struct tcb *const tcp, const kernel_ureg_t addr)
+printrusage32(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct rusage32 {
timeval32_t ru_utime; /* user time used */
}
MPERS_PRINTER_DECL(void, printsiginfo_at,
- struct tcb *const tcp, const kernel_ureg_t addr)
+ struct tcb *const tcp, const kernel_ulong_t addr)
{
siginfo_t si;
}
MPERS_PRINTER_DECL(void, print_siginfo_array, struct tcb *const tcp,
- const kernel_ureg_t addr, const kernel_ureg_t len)
+ const kernel_ulong_t addr, const kernel_ulong_t len)
{
siginfo_t si;
};
static void
-print_user_offset_addr(const kernel_ureg_t addr)
+print_user_offset_addr(const kernel_ulong_t addr)
{
const struct xlat *x;
} else {
--x;
tprintf("%s + %" PRI_kru,
- x->str, addr - (kernel_ureg_t) x->val);
+ x->str, addr - (kernel_ulong_t) x->val);
}
} else {
tprints(x->str);
SYS_FUNC(ptrace)
{
- const kernel_ureg_t request = tcp->u_arg[0];
+ const kernel_ulong_t request = tcp->u_arg[0];
const int pid = tcp->u_arg[1];
- const kernel_ureg_t addr = tcp->u_arg[2];
- const kernel_ureg_t data = tcp->u_arg[3];
+ const kernel_ulong_t addr = tcp->u_arg[2];
+ const kernel_ulong_t data = tcp->u_arg[3];
if (entering(tcp)) {
/* request */
/* arg 1: pid */
tprintf("%d, ", (int) tcp->u_arg[0]);
} else {
- kernel_ureg_t local_iovcnt = tcp->u_arg[2];
- kernel_ureg_t remote_iovcnt = tcp->u_arg[4];
- kernel_ureg_t flags = tcp->u_arg[5];
+ kernel_ulong_t local_iovcnt = tcp->u_arg[2];
+ kernel_ulong_t remote_iovcnt = tcp->u_arg[4];
+ kernel_ulong_t flags = tcp->u_arg[5];
/* arg 2: local iov */
tprint_iov_upto(tcp, local_iovcnt, tcp->u_arg[1],
SYS_FUNC(process_vm_writev)
{
- kernel_ureg_t local_iovcnt = tcp->u_arg[2];
- kernel_ureg_t remote_iovcnt = tcp->u_arg[4];
- kernel_ureg_t flags = tcp->u_arg[5];
+ kernel_ulong_t local_iovcnt = tcp->u_arg[2];
+ kernel_ulong_t remote_iovcnt = tcp->u_arg[4];
+ kernel_ulong_t flags = tcp->u_arg[5];
/* arg 1: pid */
tprintf("%d, ", (int) tcp->u_arg[0]);
int
ptp_ioctl(struct tcb *const tcp, const unsigned int code,
- const kernel_ureg_t arg)
+ const kernel_ulong_t arg)
{
if (!verbose(tcp))
return RVAL_DECODED;
zero_extend_signed_to_ull((where).field))
static int
-decode_cmd_data(struct tcb *tcp, uint32_t id, uint32_t cmd, kernel_ureg_t data)
+decode_cmd_data(struct tcb *tcp, uint32_t id, uint32_t cmd, kernel_ulong_t data)
{
switch (cmd) {
case Q_QUOTAOFF:
}
static void
-print_rlimit64(struct tcb *const tcp, const kernel_ureg_t addr)
+print_rlimit64(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct rlimit_64 {
uint64_t rlim_cur;
}
static void
-print_rlimit32(struct tcb *const tcp, const kernel_ureg_t addr)
+print_rlimit32(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct rlimit_32 {
uint32_t rlim_cur;
}
static void
-decode_rlimit(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_rlimit(struct tcb *const tcp, const kernel_ulong_t addr)
{
/*
* i386 is the only personality on X86_64 and X32
}
static void
-decode_rtc_time(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_rtc_time(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct rtc_time rt;
}
static void
-decode_rtc_wkalrm(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_rtc_wkalrm(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct rtc_wkalrm wk;
}
static void
-decode_rtc_pll_info(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_rtc_pll_info(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct_rtc_pll_info pll;
}
MPERS_PRINTER_DECL(int, rtc_ioctl, struct tcb *const tcp,
- const unsigned int code, const kernel_ureg_t arg)
+ const unsigned int code, const kernel_ulong_t arg)
{
switch (code) {
case RTC_ALM_READ:
if (entering(tcp)) {
tprintf("%d", (int) tcp->u_arg[0]);
} else if (!syserror(tcp)) {
- tcp->auxstr = xlookup(schedulers, (kernel_ureg_t) tcp->u_rval);
+ tcp->auxstr = xlookup(schedulers, (kernel_ulong_t) tcp->u_rval);
if (tcp->auxstr != NULL)
return RVAL_STR;
}
}
static void
-print_sched_attr(struct tcb *const tcp, const kernel_ureg_t addr,
+print_sched_attr(struct tcb *const tcp, const kernel_ulong_t addr,
unsigned int size)
{
struct {
}
static void
-print_sg_io_buffer(struct tcb *const tcp, const kernel_ureg_t addr,
+print_sg_io_buffer(struct tcb *const tcp, const kernel_ulong_t addr,
const unsigned int len)
{
unsigned char buf;
}
static int
-print_sg_io_v3_req(struct tcb *const tcp, const kernel_ureg_t arg)
+print_sg_io_v3_req(struct tcb *const tcp, const kernel_ulong_t arg)
{
struct sg_io_hdr sg_io;
}
static void
-print_sg_io_v3_res(struct tcb *const tcp, const kernel_ureg_t arg)
+print_sg_io_v3_res(struct tcb *const tcp, const kernel_ulong_t arg)
{
struct sg_io_hdr sg_io;
#ifdef HAVE_LINUX_BSG_H
static int
-print_sg_io_v4_req(struct tcb *const tcp, const kernel_ureg_t arg)
+print_sg_io_v4_req(struct tcb *const tcp, const kernel_ulong_t arg)
{
struct sg_io_v4 sg_io;
}
static void
-print_sg_io_v4_res(struct tcb *const tcp, const kernel_ureg_t arg)
+print_sg_io_v4_res(struct tcb *const tcp, const kernel_ulong_t arg)
{
struct sg_io_v4 sg_io;
uint32_t din_len;
#else /* !HAVE_LINUX_BSG_H */
static int
-print_sg_io_v4_req(struct tcb *const tcp, const kernel_ureg_t arg)
+print_sg_io_v4_req(struct tcb *const tcp, const kernel_ulong_t arg)
{
tprints("...}");
return RVAL_DECODED | 1;
}
static void
-print_sg_io_v4_res(struct tcb *const tcp, const kernel_ureg_t arg)
+print_sg_io_v4_res(struct tcb *const tcp, const kernel_ulong_t arg)
{
}
static int
print_sg_io_req(struct tcb *const tcp, const uint32_t iid,
- const kernel_ureg_t arg)
+ const kernel_ulong_t arg)
{
tprintf("{'%c', ", iid);
static void
print_sg_io_res(struct tcb *const tcp, const uint32_t iid,
- const kernel_ureg_t arg)
+ const kernel_ulong_t arg)
{
switch (iid) {
case 'S':
int
scsi_ioctl(struct tcb *const tcp, const unsigned int code,
- const kernel_ureg_t arg)
+ const kernel_ulong_t arg)
{
uint32_t iid;
}
void
-print_seccomp_fprog(struct tcb *const tcp, const kernel_ureg_t addr,
+print_seccomp_fprog(struct tcb *const tcp, const kernel_ulong_t addr,
const unsigned short len)
{
if (abbrev(tcp)) {
#include "seccomp_fprog.h"
void
-print_seccomp_filter(struct tcb *const tcp, const kernel_ureg_t addr)
+print_seccomp_filter(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct seccomp_fprog fprog;
static void
decode_seccomp_set_mode_strict(const unsigned int flags,
- const kernel_ureg_t addr)
+ const kernel_ulong_t addr)
{
tprintf("%u, ", flags);
printaddr(addr);
#include "xlat/sigaltstack_flags.h"
static void
-print_stack_t(struct tcb *const tcp, const kernel_ureg_t addr)
+print_stack_t(struct tcb *const tcp, const kernel_ulong_t addr)
{
stack_t ss;
printaddr(ptr_to_kulong(ss.ss_sp));
tprints(", ss_flags=");
printflags(sigaltstack_flags, ss.ss_flags, "SS_???");
- tprintf(", ss_size=%" PRI_kru "}", (kernel_ureg_t) ss.ss_size);
+ tprintf(", ss_size=%" PRI_kru "}", (kernel_ulong_t) ss.ss_size);
}
SYS_FUNC(sigaltstack)
*/
static const char *
-get_sa_handler_str(kernel_ureg_t handler)
+get_sa_handler_str(kernel_ulong_t handler)
{
return xlookup(sa_handler_values, handler);
}
static void
-print_sa_handler(kernel_ureg_t handler)
+print_sa_handler(kernel_ulong_t handler)
{
const char *sa_handler_str = get_sa_handler_str(handler);
}
static void
-print_sigset_addr_len_limit(struct tcb *const tcp, const kernel_ureg_t addr,
- const kernel_ureg_t len, const unsigned int min_len)
+print_sigset_addr_len_limit(struct tcb *const tcp, const kernel_ulong_t addr,
+ const kernel_ulong_t len, const unsigned int min_len)
{
/*
* Here len is usually equal to NSIG / 8 or current_wordsize.
}
void
-print_sigset_addr_len(struct tcb *const tcp, const kernel_ureg_t addr,
- const kernel_ureg_t len)
+print_sigset_addr_len(struct tcb *const tcp, const kernel_ulong_t addr,
+ const kernel_ulong_t len)
{
print_sigset_addr_len_limit(tcp, addr, len, current_wordsize);
}
};
static void
-decode_old_sigaction(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_old_sigaction(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct old_sigaction sa;
};
static void
-decode_new_sigaction(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_new_sigaction(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct new_sigaction sa;
static void
print_sigqueueinfo(struct tcb *const tcp, const int sig,
- const kernel_ureg_t addr)
+ const kernel_ulong_t addr)
{
printsignal(sig);
tprints(", ");
static void
print_ifreq(struct tcb *const tcp, const unsigned int code,
- const kernel_ureg_t arg, const struct ifreq *const ifr)
+ const kernel_ulong_t arg, const struct ifreq *const ifr)
{
switch (code) {
case SIOCSIFADDR:
}
static int
-decode_ifconf(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_ifconf(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct ifconf ifc;
}
int
-sock_ioctl(struct tcb *const tcp, const unsigned int code, const kernel_ureg_t arg)
+sock_ioctl(struct tcb *const tcp, const unsigned int code, const kernel_ulong_t arg)
{
struct ifreq ifr;
}
int
-decode_sockaddr(struct tcb *const tcp, const kernel_ureg_t addr, int addrlen)
+decode_sockaddr(struct tcb *const tcp, const kernel_ulong_t addr, int addrlen)
{
if (addrlen < 2) {
printaddr(addr);
#include "stat.h"
static void
-decode_struct_stat(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_struct_stat(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct strace_stat st;
#include "stat.h"
static void
-decode_struct_stat64(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_struct_stat64(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct strace_stat st;
if (call < 1 || call >= SYS_socket_nsubcalls)
return;
- const kernel_scno_t scno = SYS_socket_subcall + call;
+ const kernel_ulong_t scno = SYS_socket_subcall + call;
const unsigned int nargs = sysent[scno].nargs;
uint64_t buf[nargs];
* Shuffle syscall numbers so that we don't have huge gaps in syscall table.
* The shuffling should be an involution: shuffle_scno(shuffle_scno(n)) == n.
*/
-static kernel_scno_t
-shuffle_scno(kernel_scno_t scno)
+static kernel_ulong_t
+shuffle_scno(kernel_ulong_t scno)
{
#if defined(ARM) || defined(AARCH64) /* So far only 32-bit ARM needs this */
if (scno < ARM_FIRST_SHUFFLED_SYSCALL)
static int get_syscall_args(struct tcb *);
static int get_syscall_result(struct tcb *);
static int arch_get_scno(struct tcb *tcp);
-static int arch_set_scno(struct tcb *, kernel_scno_t);
+static int arch_set_scno(struct tcb *, kernel_ulong_t);
static void get_error(struct tcb *, const bool);
static int arch_set_error(struct tcb *);
#if defined ARCH_PC_REG
# define ARCH_GET_PC 0
#elif defined ARCH_PC_PEEK_ADDR
- kernel_ureg_t pc;
+ kernel_ulong_t pc;
# define ARCH_PC_REG pc
# define ARCH_GET_PC upeek(tcp->pid, ARCH_PC_PEEK_ADDR, &pc)
#else
else
tprintf(current_wordsize == 4
? "[%08" PRI_krx "] " : "[%016" PRI_krx "] ",
- (kernel_ureg_t) ARCH_PC_REG);
+ (kernel_ulong_t) ARCH_PC_REG);
}
#include "getregs_old.h"
struct sysent_buf {
struct tcb *tcp;
struct_sysent ent;
- char buf[sizeof("syscall_%lu") + sizeof(kernel_scno_t) * 3];
+ char buf[sizeof("syscall_%lu") + sizeof(kernel_ulong_t) * 3];
};
static void
#endif
const char *
-syscall_name(kernel_scno_t scno)
+syscall_name(kernel_ulong_t scno)
{
#if defined X32_PERSONALITY_NUMBER && defined __X32_SYSCALL_BIT
if (current_personality == X32_PERSONALITY_NUMBER)
#include "xlat/modem_flags.h"
static void
-decode_termios(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_termios(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct termios tios;
int i;
}
static void
-decode_termio(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_termio(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct termio tio;
int i;
}
static void
-decode_winsize(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_winsize(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct winsize ws;
#ifdef TIOCGSIZE
static void
-decode_ttysize(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_ttysize(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct ttysize ts;
#endif
static void
-decode_modem_flags(struct tcb *const tcp, const kernel_ureg_t addr)
+decode_modem_flags(struct tcb *const tcp, const kernel_ulong_t addr)
{
int i;
int
term_ioctl(struct tcb *const tcp, const unsigned int code,
- const kernel_ureg_t arg)
+ const kernel_ulong_t arg)
{
switch (code) {
/* struct termios */
#include <sys/timex.h>
static void
-print_timezone(struct tcb *const tcp, const kernel_ureg_t addr)
+print_timezone(struct tcb *const tcp, const kernel_ulong_t addr)
{
struct timezone tz;
#include "xlat/adjtimex_state.h"
static int
-do_adjtimex(struct tcb *const tcp, const kernel_ureg_t addr)
+do_adjtimex(struct tcb *const tcp, const kernel_ulong_t addr)
{
if (print_timex(tcp, addr))
return 0;
- tcp->auxstr = xlookup(adjtimex_state, (kernel_ureg_t) tcp->u_rval);
+ tcp->auxstr = xlookup(adjtimex_state, (kernel_ulong_t) tcp->u_rval);
if (tcp->auxstr)
return RVAL_STR;
return 0;
int
ubi_ioctl(struct tcb *const tcp, const unsigned int code,
- const kernel_ureg_t arg)
+ const kernel_ulong_t arg)
{
if (!verbose(tcp))
return RVAL_DECODED;
static void
get_print_uid(struct tcb *const tcp, const char *const prefix,
- const kernel_ureg_t addr)
+ const kernel_ulong_t addr)
{
uid_t uid;
static void
print_groups(struct tcb *const tcp, const unsigned int len,
- const kernel_ureg_t addr)
+ const kernel_ulong_t addr)
{
static unsigned long ngroups_max;
if (!ngroups_max)
#include "ptrace.h"
int
-upeek(int pid, unsigned long off, kernel_ureg_t *res)
+upeek(int pid, unsigned long off, kernel_ulong_t *res)
{
long val;
#include "ptrace.h"
int
-upoke(int pid, unsigned long off, kernel_ureg_t val)
+upoke(int pid, unsigned long off, kernel_ulong_t val)
{
if (ptrace(PTRACE_POKEUSER, pid, off, val)) {
if (errno != ESRCH)
int
uffdio_ioctl(struct tcb *const tcp, const unsigned int code,
- const kernel_ureg_t arg)
+ const kernel_ulong_t arg)
{
switch (code) {
case UFFDIO_API: {
#define DEF_PRINTNUM(name, type) \
bool \
-printnum_ ## name(struct tcb *const tcp, const kernel_ureg_t addr, \
+printnum_ ## name(struct tcb *const tcp, const kernel_ulong_t addr, \
const char *const fmt) \
{ \
type num; \
#define DEF_PRINTPAIR(name, type) \
bool \
-printpair_ ## name(struct tcb *const tcp, const kernel_ureg_t addr, \
+printpair_ ## name(struct tcb *const tcp, const kernel_ulong_t addr, \
const char *const fmt) \
{ \
type pair[2]; \
#if SUPPORTED_PERSONALITIES > 1 && SIZEOF_LONG > 4
bool
-printnum_long_int(struct tcb *const tcp, const kernel_ureg_t addr,
+printnum_long_int(struct tcb *const tcp, const kernel_ulong_t addr,
const char *const fmt_long, const char *const fmt_int)
{
if (current_wordsize > sizeof(int)) {
* If path length exceeds `n', append `...' to the output.
*/
void
-printpathn(struct tcb *const tcp, const kernel_ureg_t addr, unsigned int n)
+printpathn(struct tcb *const tcp, const kernel_ulong_t addr, unsigned int n)
{
char path[PATH_MAX + 1];
int nul_seen;
}
void
-printpath(struct tcb *const tcp, const kernel_ureg_t addr)
+printpath(struct tcb *const tcp, const kernel_ulong_t addr)
{
/* Size must correspond to char path[] size in printpathn */
printpathn(tcp, addr, PATH_MAX);
* or QUOTE_0_TERMINATED bit is set and the string length exceeds `len'.
*/
void
-printstr_ex(struct tcb *const tcp, const kernel_ureg_t addr,
- const kernel_ureg_t len, const unsigned int user_style)
+printstr_ex(struct tcb *const tcp, const kernel_ulong_t addr,
+ const kernel_ulong_t len, const unsigned int user_style)
{
static char *str = NULL;
static char *outstr;
}
void
-dumpiov_upto(struct tcb *const tcp, const int len, const kernel_ureg_t addr,
- kernel_ureg_t data_size)
+dumpiov_upto(struct tcb *const tcp, const int len, const kernel_ulong_t addr,
+ kernel_ulong_t data_size)
{
#if SUPPORTED_PERSONALITIES > 1
union {
}
if (umoven(tcp, addr, size, iov) >= 0) {
for (i = 0; i < len; i++) {
- kernel_ureg_t iov_len = iov_iov_len(i);
+ kernel_ulong_t iov_len = iov_iov_len(i);
if (iov_len > data_size)
iov_len = data_size;
if (!iov_len)
}
void
-dumpstr(struct tcb *const tcp, const kernel_ureg_t addr, const int len)
+dumpstr(struct tcb *const tcp, const kernel_ulong_t addr, const int len)
{
static int strsize = -1;
static unsigned char *str;
static ssize_t
vm_read_mem(const pid_t pid, void *const laddr,
- const kernel_ureg_t raddr, const size_t len)
+ const kernel_ulong_t raddr, const size_t len)
{
const unsigned long truncated_raddr = raddr;
- if (raddr != (kernel_ureg_t) truncated_raddr) {
+ if (raddr != (kernel_ulong_t) truncated_raddr) {
errno = EIO;
return -1;
}
* at address `addr' to our space at `our_addr'
*/
int
-umoven(struct tcb *const tcp, kernel_ureg_t addr, unsigned int len,
+umoven(struct tcb *const tcp, kernel_ulong_t addr, unsigned int len,
void *const our_addr)
{
char *laddr = our_addr;
}
int
-umoven_or_printaddr(struct tcb *const tcp, const kernel_ureg_t addr,
+umoven_or_printaddr(struct tcb *const tcp, const kernel_ulong_t addr,
const unsigned int len, void *const our_addr)
{
if (!addr || !verbose(tcp) || (exiting(tcp) && syserror(tcp)) ||
int
umoven_or_printaddr_ignore_syserror(struct tcb *const tcp,
- const kernel_ureg_t addr,
+ const kernel_ulong_t addr,
const unsigned int len,
void *const our_addr)
{
* we never write past laddr[len-1]).
*/
int
-umovestr(struct tcb *const tcp, kernel_ureg_t addr, unsigned int len, char *laddr)
+umovestr(struct tcb *const tcp, kernel_ulong_t addr, unsigned int len, char *laddr)
{
const unsigned long x01010101 = (unsigned long) 0x0101010101010101ULL;
const unsigned long x80808080 = (unsigned long) 0x8080808080808080ULL;
*/
bool
print_array(struct tcb *const tcp,
- const kernel_ureg_t start_addr,
+ const kernel_ulong_t start_addr,
const size_t nmemb,
void *const elem_buf,
const size_t elem_size,
int (*const umoven_func)(struct tcb *,
- kernel_ureg_t,
+ kernel_ulong_t,
unsigned int,
void *),
bool (*const print_func)(struct tcb *,
}
const size_t size = nmemb * elem_size;
- const kernel_ureg_t end_addr = start_addr + size;
+ const kernel_ulong_t end_addr = start_addr + size;
if (end_addr <= start_addr || size / elem_size != nmemb) {
printaddr(start_addr);
return false;
}
- const kernel_ureg_t abbrev_end =
+ const kernel_ulong_t abbrev_end =
(abbrev(tcp) && max_strlen < nmemb) ?
start_addr + elem_size * max_strlen : end_addr;
- kernel_ureg_t cur;
+ kernel_ulong_t cur;
for (cur = start_addr; cur < end_addr; cur += elem_size) {
if (cur != start_addr)
#include "xlat/v4l2_device_capabilities_flags.h"
static int
-print_v4l2_capability(struct tcb *const tcp, const kernel_ureg_t arg)
+print_v4l2_capability(struct tcb *const tcp, const kernel_ulong_t arg)
{
struct v4l2_capability caps;
#include "xlat/v4l2_format_description_flags.h"
static int
-print_v4l2_fmtdesc(struct tcb *const tcp, const kernel_ureg_t arg)
+print_v4l2_fmtdesc(struct tcb *const tcp, const kernel_ulong_t arg)
{
struct v4l2_fmtdesc f;
}
static int
-print_v4l2_format(struct tcb *const tcp, const kernel_ureg_t arg,
+print_v4l2_format(struct tcb *const tcp, const kernel_ulong_t arg,
const bool is_get)
{
struct_v4l2_format f;
#include "xlat/v4l2_memories.h"
static int
-print_v4l2_requestbuffers(struct tcb *const tcp, const kernel_ureg_t arg)
+print_v4l2_requestbuffers(struct tcb *const tcp, const kernel_ulong_t arg)
{
struct v4l2_requestbuffers reqbufs;
static int
print_v4l2_buffer(struct tcb *const tcp, const unsigned int code,
- const kernel_ureg_t arg)
+ const kernel_ulong_t arg)
{
struct_v4l2_buffer b;
}
static int
-print_v4l2_framebuffer(struct tcb *const tcp, const kernel_ureg_t arg)
+print_v4l2_framebuffer(struct tcb *const tcp, const kernel_ulong_t arg)
{
struct_v4l2_framebuffer b;
}
static int
-print_v4l2_buf_type(struct tcb *const tcp, const kernel_ureg_t arg)
+print_v4l2_buf_type(struct tcb *const tcp, const kernel_ulong_t arg)
{
int type;
#include "xlat/v4l2_capture_modes.h"
static int
-print_v4l2_streamparm(struct tcb *const tcp, const kernel_ureg_t arg,
+print_v4l2_streamparm(struct tcb *const tcp, const kernel_ulong_t arg,
const bool is_get)
{
struct v4l2_streamparm s;
}
static int
-print_v4l2_standard(struct tcb *const tcp, const kernel_ureg_t arg)
+print_v4l2_standard(struct tcb *const tcp, const kernel_ulong_t arg)
{
struct_v4l2_standard s;
#include "xlat/v4l2_input_types.h"
static int
-print_v4l2_input(struct tcb *const tcp, const kernel_ureg_t arg)
+print_v4l2_input(struct tcb *const tcp, const kernel_ulong_t arg)
{
struct_v4l2_input i;
#include "xlat/v4l2_control_ids.h"
static int
-print_v4l2_control(struct tcb *const tcp, const kernel_ureg_t arg,
+print_v4l2_control(struct tcb *const tcp, const kernel_ulong_t arg,
const bool is_get)
{
struct v4l2_control c;
#include "xlat/v4l2_control_flags.h"
static int
-print_v4l2_queryctrl(struct tcb *const tcp, const kernel_ureg_t arg)
+print_v4l2_queryctrl(struct tcb *const tcp, const kernel_ulong_t arg)
{
struct v4l2_queryctrl c;
}
static int
-print_v4l2_cropcap(struct tcb *const tcp, const kernel_ureg_t arg)
+print_v4l2_cropcap(struct tcb *const tcp, const kernel_ulong_t arg)
{
struct v4l2_cropcap c;
}
static int
-print_v4l2_crop(struct tcb *const tcp, const kernel_ureg_t arg,
+print_v4l2_crop(struct tcb *const tcp, const kernel_ulong_t arg,
const bool is_get)
{
struct v4l2_crop c;
#include "xlat/v4l2_control_classes.h"
static int
-print_v4l2_ext_controls(struct tcb *const tcp, const kernel_ureg_t arg,
+print_v4l2_ext_controls(struct tcb *const tcp, const kernel_ulong_t arg,
const bool is_get)
{
struct_v4l2_ext_controls c;
# include "xlat/v4l2_framesize_types.h"
static int
-print_v4l2_frmsizeenum(struct tcb *const tcp, const kernel_ureg_t arg)
+print_v4l2_frmsizeenum(struct tcb *const tcp, const kernel_ulong_t arg)
{
struct v4l2_frmsizeenum s;
# include "xlat/v4l2_frameinterval_types.h"
static int
-print_v4l2_frmivalenum(struct tcb *const tcp, const kernel_ureg_t arg)
+print_v4l2_frmivalenum(struct tcb *const tcp, const kernel_ulong_t arg)
{
struct v4l2_frmivalenum f;
#ifdef VIDIOC_CREATE_BUFS
static int
-print_v4l2_create_buffers(struct tcb *const tcp, const kernel_ureg_t arg)
+print_v4l2_create_buffers(struct tcb *const tcp, const kernel_ulong_t arg)
{
struct_v4l2_create_buffers b;
#endif /* VIDIOC_CREATE_BUFS */
MPERS_PRINTER_DECL(int, v4l2_ioctl, struct tcb *const tcp,
- const unsigned int code, const kernel_ureg_t arg)
+ const unsigned int code, const kernel_ulong_t arg)
{
if (!verbose(tcp))
return RVAL_DECODED;
static int
printwaitn(struct tcb *const tcp,
- void (*const print_rusage)(struct tcb *, kernel_ureg_t))
+ void (*const print_rusage)(struct tcb *, kernel_ulong_t))
{
if (entering(tcp)) {
/* On Linux, kernel-side pid_t is typedef'ed to int
static void
print_xattr_val(struct tcb *const tcp,
- const kernel_ureg_t addr,
- const kernel_ureg_t insize,
- const kernel_ureg_t size)
+ const kernel_ulong_t addr,
+ const kernel_ulong_t insize,
+ const kernel_ulong_t size)
{
tprints(", ");
}
static void
-print_xattr_list(struct tcb *const tcp, const kernel_ureg_t addr,
- const kernel_ureg_t size)
+print_xattr_list(struct tcb *const tcp, const kernel_ulong_t addr,
+ const kernel_ulong_t size)
{
if (!size || syserror(tcp)) {
printaddr(addr);
projects / strace / commitdiff