Fix: illegal memory access in syscall_init_table
[lttng-tools.git] / src / bin / lttng-sessiond / syscall.c
1 /*
2 * Copyright (C) 2014 - David Goulet <dgoulet@efficios.com>
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License, version 2 only, as
6 * published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
11 * more details.
12 *
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc., 51
15 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
16 */
17
18 #define _LGPL_SOURCE
19 #include <common/bitfield.h>
20 #include <common/common.h>
21 #include <common/kernel-ctl/kernel-ctl.h>
22
23 #include "lttng-sessiond.h"
24 #include "kernel.h"
25 #include "syscall.h"
26 #include "utils.h"
27
28 /* Global syscall table. */
29 struct syscall *syscall_table;
30
31 /* Number of entry in the syscall table. */
32 static size_t syscall_table_nb_entry;
33
34 /*
35 * Populate the system call table using the kernel tracer.
36 *
37 * Return 0 on success and the syscall table is allocated. On error, a negative
38 * value is returned.
39 */
40 int syscall_init_table(void)
41 {
42 int ret, fd, err;
43 size_t nbmem;
44 FILE *fp;
45 /* Syscall data from the kernel. */
46 size_t index;
47 uint32_t bitness;
48 char name[SYSCALL_NAME_LEN];
49
50 DBG3("Syscall init system call table");
51
52 fd = kernctl_syscall_list(kernel_tracer_fd);
53 if (fd < 0) {
54 ret = -errno;
55 PERROR("kernelctl syscall list");
56 goto error_ioctl;
57 }
58
59 fp = fdopen(fd, "r");
60 if (!fp) {
61 ret = -errno;
62 PERROR("syscall list fdopen");
63 goto error_fp;
64 }
65
66 nbmem = SYSCALL_TABLE_INIT_SIZE;
67 syscall_table = zmalloc(sizeof(struct syscall) * nbmem);
68 if (!syscall_table) {
69 ret = -errno;
70 PERROR("syscall list zmalloc");
71 goto error;
72 }
73
74 while (fscanf(fp,
75 "syscall { index = %zu; \
76 name = %" XSTR(SYSCALL_NAME_LEN) "[^;]; \
77 bitness = %u; };\n",
78 &index, name, &bitness) == 3) {
79 if (index >= nbmem ) {
80 struct syscall *new_list;
81 size_t new_nbmem;
82
83 /* Double memory size. */
84 new_nbmem = max(index, nbmem << 1);
85 if (new_nbmem < nbmem) {
86 /* Overflow, stop everything, something went really wrong. */
87 ERR("Syscall listing memory size overflow. Stopping");
88 free(syscall_table);
89 syscall_table = NULL;
90 ret = -EINVAL;
91 goto error;
92 }
93
94 DBG("Reallocating syscall table from %zu to %zu entries", nbmem,
95 new_nbmem);
96 new_list = realloc(syscall_table, new_nbmem * sizeof(*new_list));
97 if (!new_list) {
98 ret = -errno;
99 PERROR("syscall list realloc");
100 goto error;
101 }
102
103 /* Zero out the new memory. */
104 memset(new_list + nbmem, 0,
105 (new_nbmem - nbmem) * sizeof(*new_list));
106 nbmem = new_nbmem;
107 syscall_table = new_list;
108 }
109 syscall_table[index].index = index;
110 syscall_table[index].bitness = bitness;
111 if (lttng_strncpy(syscall_table[index].name, name,
112 sizeof(syscall_table[index].name))) {
113 ret = -EINVAL;
114 free(syscall_table);
115 syscall_table = NULL;
116 goto error;
117 }
118 /*
119 DBG("Syscall name '%s' at index %" PRIu32 " of bitness %u",
120 syscall_table[index].name,
121 syscall_table[index].index,
122 syscall_table[index].bitness);
123 */
124 }
125
126 syscall_table_nb_entry = index;
127
128 ret = 0;
129
130 error:
131 err = fclose(fp);
132 if (err) {
133 PERROR("syscall list fclose");
134 }
135 return ret;
136
137 error_fp:
138 err = close(fd);
139 if (err) {
140 PERROR("syscall list close");
141 }
142
143 error_ioctl:
144 return ret;
145 }
146
147 /*
148 * Helper function for the list syscalls command that empty the temporary
149 * syscall hashtable used to track duplicate between 32 and 64 bit arch.
150 *
151 * This empty the hash table and destroys it after. After this, the pointer is
152 * unsuable. RCU read side lock MUST be acquired before calling this.
153 */
154 static void destroy_syscall_ht(struct lttng_ht *ht)
155 {
156 struct lttng_ht_iter iter;
157 struct syscall *ksyscall;
158
159 DBG3("Destroying syscall hash table.");
160
161 if (!ht) {
162 return;
163 }
164
165 cds_lfht_for_each_entry(ht->ht, &iter.iter, ksyscall, node.node) {
166 int ret;
167
168 ret = lttng_ht_del(ht, &iter);
169 assert(!ret);
170 free(ksyscall);
171 }
172 ht_cleanup_push(ht);
173 }
174
175 /*
176 * Allocate the given hashtable pointer.
177 *
178 * Return 0 on success else a negative LTTNG error value.
179 */
180 static int init_syscall_ht(struct lttng_ht **ht)
181 {
182 int ret;
183
184 *ht = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
185 if (!*ht) {
186 ret = -LTTNG_ERR_NOMEM;
187 } else {
188 ret = 0;
189 }
190
191 return ret;
192 }
193
194 /*
195 * Lookup a syscall in the given hash table by name.
196 *
197 * Return syscall object if found or else NULL.
198 */
199 static struct syscall *lookup_syscall(struct lttng_ht *ht, const char *name)
200 {
201 struct lttng_ht_node_str *node;
202 struct lttng_ht_iter iter;
203 struct syscall *ksyscall = NULL;
204
205 assert(ht);
206 assert(name);
207
208 lttng_ht_lookup(ht, (void *) name, &iter);
209 node = lttng_ht_iter_get_node_str(&iter);
210 if (node) {
211 ksyscall = caa_container_of(node, struct syscall, node);
212 }
213
214 return ksyscall;
215 }
216
217 /*
218 * Using the given syscall object in the events array with the bitness of the
219 * syscall at index in the syscall table.
220 */
221 static void update_event_syscall_bitness(struct lttng_event *events,
222 unsigned int index, unsigned int syscall_index)
223 {
224 assert(events);
225
226 if (syscall_table[index].bitness == 32) {
227 events[syscall_index].flags |= LTTNG_EVENT_FLAG_SYSCALL_32;
228 } else {
229 events[syscall_index].flags |= LTTNG_EVENT_FLAG_SYSCALL_64;
230 }
231 }
232
233 /*
234 * Allocate and initialize syscall object and add it to the given hashtable.
235 *
236 * Return 0 on success else -LTTNG_ERR_NOMEM.
237 */
238 static int add_syscall_to_ht(struct lttng_ht *ht, unsigned int index,
239 unsigned int syscall_index)
240 {
241 int ret;
242 struct syscall *ksyscall;
243
244 assert(ht);
245
246 ksyscall = zmalloc(sizeof(*ksyscall));
247 if (!ksyscall) {
248 ret = -LTTNG_ERR_NOMEM;
249 goto error;
250 }
251
252 strncpy(ksyscall->name, syscall_table[index].name,
253 sizeof(ksyscall->name));
254 ksyscall->bitness = syscall_table[index].bitness;
255 ksyscall->index = syscall_index;
256 lttng_ht_node_init_str(&ksyscall->node, ksyscall->name);
257 lttng_ht_add_unique_str(ht, &ksyscall->node);
258 ret = 0;
259
260 error:
261 return ret;
262 }
263
264 /*
265 * List syscalls present in the kernel syscall global array, allocate and
266 * populate the events structure with them. Skip the empty syscall name.
267 *
268 * Return the number of entries in the array else a negative value.
269 */
270 ssize_t syscall_table_list(struct lttng_event **_events)
271 {
272 int i, index = 0;
273 ssize_t ret;
274 struct lttng_event *events;
275 /* Hash table used to filter duplicate out. */
276 struct lttng_ht *syscalls_ht = NULL;
277
278 assert(_events);
279
280 DBG("Syscall table listing.");
281
282 rcu_read_lock();
283
284 /*
285 * Allocate at least the number of total syscall we have even if some of
286 * them might not be valid. The count below will make sure to return the
287 * right size of the events array.
288 */
289 events = zmalloc(syscall_table_nb_entry * sizeof(*events));
290 if (!events) {
291 PERROR("syscall table list zmalloc");
292 ret = -LTTNG_ERR_NOMEM;
293 goto error;
294 }
295
296 ret = init_syscall_ht(&syscalls_ht);
297 if (ret < 0) {
298 goto error;
299 }
300
301 for (i = 0; i < syscall_table_nb_entry; i++) {
302 struct syscall *ksyscall;
303
304 /* Skip empty syscalls. */
305 if (*syscall_table[i].name == '\0') {
306 continue;
307 }
308
309 ksyscall = lookup_syscall(syscalls_ht, syscall_table[i].name);
310 if (ksyscall) {
311 update_event_syscall_bitness(events, i, ksyscall->index);
312 continue;
313 }
314
315 ret = add_syscall_to_ht(syscalls_ht, i, index);
316 if (ret < 0) {
317 goto error;
318 }
319
320 /* Copy the event information in the event's array. */
321 strncpy(events[index].name, syscall_table[i].name,
322 sizeof(events[index].name));
323 update_event_syscall_bitness(events, i, index);
324 events[index].type = LTTNG_EVENT_SYSCALL;
325 /* This makes the command line not print the enabled/disabled field. */
326 events[index].enabled = -1;
327 index++;
328 }
329
330 destroy_syscall_ht(syscalls_ht);
331 *_events = events;
332 rcu_read_unlock();
333 return index;
334
335 error:
336 destroy_syscall_ht(syscalls_ht);
337 free(events);
338 rcu_read_unlock();
339 return ret;
340 }
This page took 0.058405 seconds and 4 git commands to generate.