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