1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
/* See LICENSE file for copyright and license details. */
#include "common.h"
#include <stdalign.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#if defined(__GNUC__)
# pragma GCC diagnostic ignored "-Winline"
#endif
#define LOWEST_BIT(X) ((X) & ~((X) - 1))
#define POST_HIGHEST_OF_CONSECUTIVELY_BITS(X) ((X) + LOWEST_BIT(X))
static inline signed char
trailing_zeroes(unsigned long long int x) { /* TODO use builtin function if available */
int r = 0;
if (x == 0)
return -1;
for (; (x & 1) == 0; x >>= 1)
r += 1;
return (signed char)r;
}
static int
signed_named_number_cmp(const void *a_, const void *b_)
{
const struct libsyscalls_named_number *a = a_, *b = b_;
return a->number.s < b->number.s ? -1 : a->number.s > b->number.s;
}
static int
unsigned_named_number_cmp(const void *a_, const void *b_)
{
const struct libsyscalls_named_number *a = a_, *b = b_;
return a->number.u < b->number.u ? -1 : a->number.u > b->number.u;
}
static const char *
extract_signal(enum libsyscalls_os os, enum libsyscalls_arch arch,
unsigned long long int *valuep, char *fallback_out, int is_signed)
{
const struct libsyscalls_named_number *signals, *found;
size_t nsignals;
struct libsyscalls_named_number key = {.number.u = *valuep};
if (libsyscalls_get_signals(os, arch, &signals, &nsignals))
return NULL;
found = bsearch(&key, signals, nsignals, sizeof(key), /* TODO interpolation search may be better */
is_signed ? &signed_named_number_cmp : &unsigned_named_number_cmp);
if (!found)
return NULL;
(void)fallback_out;
*valuep = 0;
return found->name;
}
#if defined(__clang__)
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
#endif
static struct libsyscalls_syscall_display_info *
build_syscall_display_info(void *data, size_t data_size, size_t data_align,
libsyscalls_symbol_printer_function **funcs,
const struct libsyscalls_syscall_abi *syscall, int nargs, int nsyms)
{
struct libsyscalls_syscall_display_info *ret;
size_t size, dataoff, paramoff;
int i;
size = sizeof(*ret);
if (size & (data_align - 1)) {
size |= data_align - 1;
size += 1;
}
dataoff = size;
size += (size_t)nsyms * data_size;
if (size & (alignof(struct libsyscalls_syscall_type_info) - 1)) {
size |= alignof(struct libsyscalls_syscall_type_info) - 1;
size += 1;
}
paramoff = size;
size += (size_t)(nargs + 1) * sizeof(*ret->params);
ret = calloc(1, size);
if (!ret)
return NULL;
ret->size = sizeof(*ret);
ret->params = (void *)&((char *)ret)[paramoff];
ret->retvalue = &ret->params[nargs];
nsyms = 0;
for (i = 0; i < nargs; i++) {
ret->params[i].type = syscall->parameters_types[i];
if (funcs[i]) {
ret->params[i].function = funcs[i];
ret->params[i].data = (void *)&((char *)ret)[dataoff + (size_t)nsyms * data_size];
memcpy(ret->params[i].data, &((char *)data)[(size_t)i * data_size], data_size);
nsyms++;
}
}
ret->retvalue->type = syscall->return_type;
ret->retvalue->expect_zero = syscall->expect_zero;
if (funcs[i]) {
ret->retvalue->function = funcs[i];
ret->retvalue->data = (void *)&((char *)ret)[dataoff + (size_t)nsyms * data_size];
memcpy(ret->retvalue->data, &((char *)data)[(size_t)i * data_size], data_size);
}
return ret;
}
#if defined(__clang__)
# pragma clang diagnostic pop
#endif
#include "generated/symbols.c"
#if defined(__GNUC__) && !defined(__clang__)
# pragma GCC diagnostic ignored "-Wnonnull-compare" /* Why should I trust that the user is using the same compiler? */
#endif
enum libsyscalls_error
libsyscalls_get_syscall_display_info(enum libsyscalls_os os, enum libsyscalls_arch arch,
const struct libsyscalls_syscall_abi *syscall,
long long int syscall_number,
unsigned long long int *syscall_arguments,
struct libsyscalls_syscall_display_info **info_out)
{
struct libsyscalls_syscall_display_info *info;
if (!syscall || !syscall_arguments || !info_out)
return LIBSYSCALLS_E_INVAL;
#define CASE(UPPERCASE, LOWERCASE)\
case LIBSYSCALLS_OS_##UPPERCASE:\
info = get_##LOWERCASE##_syscall_display_info(arch, syscall, syscall_number, syscall_arguments);\
break
switch ((int)os) {
LIST_OSES(CASE, ;);
default:
return LIBSYSCALLS_E_OSNOSUP;
}
#undef CASE
if (!info)
return LIBSYSCALLS_E_NOMEM;
*info_out = info;
return LIBSYSCALLS_E_OK;
}
|
