Fix: new syscall names in textdump
[lttngtop.git] / src / iostreamtop.c
1 /*
2 * Copyright (C) 2011-2012 Mathieu Bain <mathieu.bain@polymtl.ca>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License Version 2 as
6 * published by the Free Software Foundation;
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License along
14 * with this program; if not, write to the Free Software Foundation, Inc.,
15 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
16 */
17
18 #include <stdlib.h>
19 #include <unistd.h>
20 #include <sys/types.h>
21 #include <sys/stat.h>
22 #include <string.h>
23 #include <babeltrace/babeltrace.h>
24
25 #include "lttngtoptypes.h"
26 #include "common.h"
27 #include "iostreamtop.h"
28
29 void add_file(struct processtop *proc, struct files *file, int fd)
30 {
31 struct files *tmp_file;
32 struct processtop *parent;
33 int size;
34 int i;
35
36 size = proc->process_files_table->len;
37 parent = proc->threadparent;
38 if (parent)
39 insert_file(parent, fd);
40 if (size <= fd) {
41 /* Add NULL file structures for undefined FDs */
42 for (i = size; i < fd; i++) {
43 g_ptr_array_add(proc->process_files_table, NULL);
44 }
45 g_ptr_array_add(proc->process_files_table, file);
46 } else {
47 tmp_file = g_ptr_array_index(proc->process_files_table, fd);
48 if (tmp_file == NULL)
49 g_ptr_array_index(proc->process_files_table, fd) = file;
50 else {
51 if (!tmp_file->name ||
52 strcmp(tmp_file->name, file->name) != 0) {
53 size = proc->process_files_table->len;
54 g_ptr_array_set_size(proc->process_files_table,
55 size+1);
56 g_ptr_array_index(proc->process_files_table,
57 size) = tmp_file;
58 g_ptr_array_index(proc->process_files_table,
59 fd) = file;
60 } else
61 tmp_file->flag = __NR_open;
62 }
63 }
64 /*
65 * The file may have be created in the parent
66 */
67 if (file->flag == -1) {
68 file->fd = fd;
69 file->flag = __NR_open;
70 lttngtop.nbfiles++;
71 lttngtop.nbnewfiles++;
72 }
73 }
74
75 /*
76 * Edit the file
77 * Called by handled_statedump_filename
78 */
79 void edit_file(struct processtop *proc, struct files *file, int fd)
80 {
81 int size = proc->process_files_table->len;
82 struct files *tmpfile;
83
84 if (fd >= size) {
85 add_file(proc, file, fd);
86 } else {
87 tmpfile = g_ptr_array_index(proc->process_files_table, fd);
88 if (tmpfile) {
89 tmpfile->name = strdup(file->name);
90 free(file);
91 } else
92 add_file(proc, file, fd);
93 }
94 }
95
96 void insert_file(struct processtop *proc, int fd)
97 {
98 struct files *tmp;
99 struct files *tmp_parent;
100 struct processtop *parent;
101
102 if (fd < 0)
103 return;
104 if (fd >= proc->process_files_table->len) {
105 tmp = g_new0(struct files, 1);
106 tmp->name = NULL;
107 tmp->read = 0;
108 tmp->write = 0;
109 tmp->fd = fd;
110 tmp->flag = -1;
111 add_file(proc, tmp, fd);
112 } else {
113 tmp = g_ptr_array_index(proc->process_files_table, fd);
114 if (tmp == NULL) {
115 tmp = g_new0(struct files, 1);
116 tmp->name = NULL;
117 tmp->read = 0;
118 tmp->write = 0;
119 tmp->fd = fd;
120 tmp->flag = -1;
121 add_file(proc, tmp, fd);
122 } else {
123 parent = proc->threadparent;
124 if (parent) {
125 tmp_parent = g_ptr_array_index(
126 parent->process_files_table, fd);
127 if (tmp_parent && tmp->name && tmp_parent->name &&
128 (strcmp(tmp->name, tmp_parent->name)) != 0)
129 tmp->name = strdup(tmp_parent->name);
130 }
131 }
132 }
133 }
134
135 void close_file(struct processtop *proc, int fd)
136 {
137 struct files *file;
138
139 file = get_file(proc, fd);
140 if (file != NULL) {
141 file->flag = __NR_close;
142 lttngtop.nbfiles--;
143 if (file->name) {
144 free(file->name);
145 file->name = NULL;
146 }
147 }
148 lttngtop.nbclosedfiles++;
149 }
150
151 struct files *get_file(struct processtop *proc, int fd)
152 {
153 int len;
154 struct files *tmp = NULL;
155
156 len = proc->process_files_table->len;
157
158 /*
159 * It is possible that a file was open before taking the trace
160 * and its fd could be greater than all of the others fd
161 * used by the process
162 */
163 if (fd < len && fd >= 0)
164 tmp = g_ptr_array_index(proc->process_files_table, fd);
165
166 return tmp;
167 }
168
169 void show_table(GPtrArray *tab)
170 {
171 int i;
172 struct files *file;
173
174 for (i = 0 ; i < tab->len; i++) {
175 file = g_ptr_array_index(tab, i);
176 if (file == NULL)
177 fprintf(stderr, "NULL, ");
178 else
179 fprintf(stderr, "%s, ", file->name);
180 }
181 fprintf(stderr, "]\n\n");
182 }
183
184 void show_history(struct file_history *history)
185 {
186 struct file_history *tmp = history;
187
188 while (tmp != NULL) {
189 fprintf(stderr, "fd = %d, name = %s\n", tmp->file->fd,
190 tmp->file->name);
191 tmp = tmp->next;
192 }
193
194 }
195
196 int update_iostream_ret(struct lttngtop *ctx, int tid, char *comm,
197 unsigned long timestamp, uint64_t cpu_id, int ret,
198 char *hostname)
199 {
200 struct processtop *tmp;
201 struct files *tmpfile;
202 int err = 0;
203
204 tmp = get_proc(ctx, tid, comm, timestamp, hostname);
205
206 if (!tmp) {
207 err = -1;
208 goto end;
209 }
210 if (tmp->syscall_info != NULL) {
211 if (tmp->syscall_info->type == __NR_read
212 && ret > 0) {
213 tmp->totalfileread += ret;
214 tmp->fileread += ret;
215 tmpfile = get_file(tmp, tmp->syscall_info->fd);
216 if (tmpfile)
217 tmpfile->read += ret;
218 } else if (tmp->syscall_info->type == __NR_write
219 && ret > 0) {
220 tmp->totalfilewrite += ret;
221 tmp->filewrite += ret;
222 tmpfile = get_file(tmp, tmp->syscall_info->fd);
223 if (tmpfile)
224 tmpfile->write += ret;
225 } else if (tmp->syscall_info->type == __NR_open
226 && ret > 0) {
227 tmpfile = tmp->files_history->file;
228 add_file(tmp, tmpfile, ret);
229 tmpfile->fd = ret;
230 } else {
231 err = -1;
232 }
233 g_free(tmp->syscall_info);
234 tmp->syscall_info = NULL;
235 }
236
237 end:
238 return err;
239 }
240
241 struct syscalls *create_syscall_info(unsigned int type, uint64_t cpu_id,
242 unsigned int tid, int fd)
243 {
244 struct syscalls *syscall_info;
245
246 syscall_info = g_new0(struct syscalls, 1);
247 syscall_info->type = type;
248 syscall_info->cpu_id = cpu_id;
249 syscall_info->tid = tid;
250 syscall_info->fd = fd;
251
252 return syscall_info;
253 }
254
255 struct file_history *create_file(struct file_history *history, char *file_name)
256 {
257 struct files *new_file;
258 struct file_history *new_history;
259
260 new_file = g_new0(struct files, 1);
261 new_history = g_new0(struct file_history, 1);
262 new_file->name = strdup(file_name);
263 new_file->read = 0;
264 new_file->write = 0;
265 new_file->flag = -1;
266 new_history->file = new_file;
267 new_history->next = history;
268
269 return new_history;
270 }
271
272 enum bt_cb_ret handle_exit_syscall(struct bt_ctf_event *call_data,
273 void *private_data)
274 {
275 const struct bt_definition *scope;
276 unsigned long timestamp;
277 char *comm;
278 uint64_t ret, tid;
279 uint64_t cpu_id;
280 char *hostname;
281
282 timestamp = bt_ctf_get_timestamp(call_data);
283 if (timestamp == -1ULL)
284 goto error;
285
286 comm = get_context_comm(call_data);
287 tid = get_context_tid(call_data);
288
289 scope = bt_ctf_get_top_level_scope(call_data,
290 BT_EVENT_FIELDS);
291 ret = bt_ctf_get_int64(bt_ctf_get_field(call_data,
292 scope, "_ret"));
293 if (bt_ctf_field_get_error()) {
294 fprintf(stderr, "Missing ret context info\n");
295 goto error;
296 }
297
298 cpu_id = get_cpu_id(call_data);
299 hostname = get_context_hostname(call_data);
300
301 /*
302 * if we encounter an exit_syscall and
303 * it is not for a syscall read or write
304 * we just abort the execution of this callback
305 */
306 if ((update_iostream_ret(&lttngtop, tid, comm, timestamp, cpu_id,
307 ret, hostname)) < 0)
308 return BT_CB_ERROR_CONTINUE;
309
310 return BT_CB_OK;
311
312 error:
313 return BT_CB_ERROR_STOP;
314 }
315
316
317 enum bt_cb_ret handle_sys_write(struct bt_ctf_event *call_data,
318 void *private_data)
319 {
320 const struct bt_definition *scope;
321 struct processtop *tmp;
322 unsigned long timestamp;
323 uint64_t cpu_id;
324 int64_t tid;
325 char *procname, *hostname;
326 int fd;
327
328 timestamp = bt_ctf_get_timestamp(call_data);
329 if (timestamp == -1ULL)
330 goto error;
331
332 tid = get_context_tid(call_data);
333 cpu_id = get_cpu_id(call_data);
334
335 procname = get_context_comm(call_data);
336 hostname = get_context_hostname(call_data);
337
338 scope = bt_ctf_get_top_level_scope(call_data,
339 BT_EVENT_FIELDS);
340 fd = bt_ctf_get_uint64(bt_ctf_get_field(call_data,
341 scope, "_fd"));
342 if (bt_ctf_field_get_error()) {
343 fprintf(stderr, "Missing fd context info\n");
344 goto error;
345 }
346
347 tmp = get_proc(&lttngtop, tid, procname, timestamp, hostname);
348 if (!tmp)
349 goto end;
350
351 tmp->syscall_info = create_syscall_info(__NR_write, cpu_id, tid, fd);
352
353 insert_file(tmp, fd);
354
355 end:
356 return BT_CB_OK;
357
358 error:
359 return BT_CB_ERROR_STOP;
360 }
361
362 enum bt_cb_ret handle_sys_read(struct bt_ctf_event *call_data,
363 void *private_data)
364 {
365 struct processtop *tmp;
366 const struct bt_definition *scope;
367 unsigned long timestamp;
368 uint64_t cpu_id;
369 int64_t tid;
370 char *procname;
371 int fd;
372 char *hostname;
373
374 timestamp = bt_ctf_get_timestamp(call_data);
375 if (timestamp == -1ULL)
376 goto error;
377
378 tid = get_context_tid(call_data);
379 cpu_id = get_cpu_id(call_data);
380
381 procname = get_context_comm(call_data);
382 hostname = get_context_hostname(call_data);
383
384 scope = bt_ctf_get_top_level_scope(call_data,
385 BT_EVENT_FIELDS);
386 fd = bt_ctf_get_uint64(bt_ctf_get_field(call_data,
387 scope, "_fd"));
388 if (bt_ctf_field_get_error()) {
389 fprintf(stderr, "Missing fd context info\n");
390 goto error;
391 }
392
393 tmp = get_proc(&lttngtop, tid, procname, timestamp, hostname);
394 if (!tmp)
395 goto end;
396
397 tmp->syscall_info = create_syscall_info(__NR_read, cpu_id, tid, fd);
398
399 insert_file(tmp, fd);
400
401 end:
402 return BT_CB_OK;
403
404 error:
405 return BT_CB_ERROR_STOP;
406 }
407
408 enum bt_cb_ret handle_sys_open(struct bt_ctf_event *call_data,
409 void *private_data)
410 {
411
412 struct processtop *tmp;
413 const struct bt_definition *scope;
414 unsigned long timestamp;
415 uint64_t cpu_id;
416 int64_t tid;
417 char *procname, *hostname;
418 char *file;
419
420 timestamp = bt_ctf_get_timestamp(call_data);
421 if (timestamp == -1ULL)
422 goto error;
423
424 tid = get_context_tid(call_data);
425 cpu_id = get_cpu_id(call_data);
426
427 procname = get_context_comm(call_data);
428 hostname = get_context_hostname(call_data);
429
430 scope = bt_ctf_get_top_level_scope(call_data,
431 BT_EVENT_FIELDS);
432 file = bt_ctf_get_string(bt_ctf_get_field(call_data,
433 scope, "_filename"));
434 if (bt_ctf_field_get_error()) {
435 fprintf(stderr, "Missing file name context info\n");
436 goto error;
437 }
438
439 tmp = get_proc(&lttngtop, tid, procname, timestamp, hostname);
440 if (!tmp)
441 goto end;
442
443 tmp->syscall_info = create_syscall_info(__NR_open, cpu_id, tid, -1);
444
445 tmp->files_history = create_file(tmp->files_history, file);
446
447 end:
448 return BT_CB_OK;
449
450 error:
451 return BT_CB_ERROR_STOP;
452 }
453
454 enum bt_cb_ret handle_sys_socket(struct bt_ctf_event *call_data,
455 void *private_data)
456 {
457
458 struct processtop *tmp;
459 unsigned long timestamp;
460 uint64_t cpu_id;
461 int64_t tid;
462 char *procname, *hostname;
463 char *file;
464
465 timestamp = bt_ctf_get_timestamp(call_data);
466 if (timestamp == -1ULL)
467 goto error;
468
469 tid = get_context_tid(call_data);
470 cpu_id = get_cpu_id(call_data);
471
472 procname = get_context_comm(call_data);
473 hostname = get_context_hostname(call_data);
474
475 file = strdup("socket");
476
477 tmp = get_proc(&lttngtop, tid, procname, timestamp, hostname);
478 if (!tmp)
479 goto end;
480
481 tmp->syscall_info = create_syscall_info(__NR_open, cpu_id, tid, -1);
482
483 tmp->files_history = create_file(tmp->files_history, file);
484
485 end:
486 return BT_CB_OK;
487
488 error:
489 return BT_CB_ERROR_STOP;
490 }
491
492 enum bt_cb_ret handle_sys_close(struct bt_ctf_event *call_data,
493 void *private_data)
494 {
495 const struct bt_definition *scope;
496 struct processtop *tmp;
497 unsigned long timestamp;
498 int64_t tid;
499 char *procname;
500 int fd;
501 char *hostname;
502
503 timestamp = bt_ctf_get_timestamp(call_data);
504 if (timestamp == -1ULL)
505 goto error;
506
507 tid = get_context_tid(call_data);
508
509 procname = get_context_comm(call_data);
510 hostname = get_context_hostname(call_data);
511
512 scope = bt_ctf_get_top_level_scope(call_data,
513 BT_EVENT_FIELDS);
514 fd = bt_ctf_get_uint64(bt_ctf_get_field(call_data,
515 scope, "_fd"));
516 if (bt_ctf_field_get_error()) {
517 fprintf(stderr, "Missing fd context info\n");
518 goto error;
519 }
520
521 tmp = get_proc(&lttngtop, tid, procname, timestamp, hostname);
522 if (!tmp)
523 goto end;
524
525 close_file(tmp, fd);
526
527 end:
528 return BT_CB_OK;
529
530 error:
531 return BT_CB_ERROR_STOP;
532 }
533
534 enum bt_cb_ret handle_statedump_file_descriptor(struct bt_ctf_event *call_data,
535 void *private_data)
536 {
537 const struct bt_definition *scope;
538 struct processtop *parent;
539 struct files *file;
540 unsigned long timestamp;
541 int64_t pid;
542 char *file_name, *hostname;
543 int fd;
544
545 timestamp = bt_ctf_get_timestamp(call_data);
546 if (timestamp == -1ULL)
547 goto error;
548
549 scope = bt_ctf_get_top_level_scope(call_data,
550 BT_EVENT_FIELDS);
551 pid = bt_ctf_get_int64(bt_ctf_get_field(call_data,
552 scope, "_pid"));
553 if (bt_ctf_field_get_error()) {
554 fprintf(stderr, "Missing tid context info\n");
555 goto error;
556 }
557
558 scope = bt_ctf_get_top_level_scope(call_data,
559 BT_EVENT_FIELDS);
560 fd = bt_ctf_get_int64(bt_ctf_get_field(call_data,
561 scope, "_fd"));
562 if (bt_ctf_field_get_error()) {
563 fprintf(stderr, "Missing fd context info\n");
564 goto error;
565 }
566
567 scope = bt_ctf_get_top_level_scope(call_data,
568 BT_EVENT_FIELDS);
569 file_name = bt_ctf_get_string(bt_ctf_get_field(call_data,
570 scope, "_filename"));
571 if (bt_ctf_field_get_error()) {
572 fprintf(stderr, "Missing file name context info\n");
573 goto error;
574 }
575 hostname = get_context_hostname(call_data);
576
577 parent = get_proc_pid(&lttngtop, pid, pid, timestamp, hostname);
578 if (!parent)
579 goto end;
580
581 parent->files_history = create_file(parent->files_history, file_name);
582 file = parent->files_history->file;
583 edit_file(parent, file, fd);
584
585 end:
586 return BT_CB_OK;
587
588 error:
589 return BT_CB_ERROR_STOP;
590 }
This page took 0.042267 seconds and 4 git commands to generate.