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 }