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                 /*
 144                 if (file->name) {
 145                         free(file->name);
 146                         file->name = NULL;
 147                 }
 148                 */
 149         }
 150         lttngtop.nbclosedfiles++;
 151 }
 152
 153 struct files *get_file(struct processtop *proc, int fd)
 154 {
 155         int len;
 156         struct files *tmp = NULL;
 157
 158         len = proc->process_files_table->len;
 159
 160         /*
 161          * It is possible that a file was open before taking the trace
 162          * and its fd could be greater than all of the others fd
 163          * used by the process
 164          */
 165         if (fd < len && fd >= 0)
 166                 tmp = g_ptr_array_index(proc->process_files_table, fd);
 167
 168         return tmp;
 169 }
 170
 171 void show_table(GPtrArray *tab)
 172 {
 173         int i;
 174         struct files *file;
 175
 176         for (i = 0 ; i < tab->len; i++) {
 177                 file = g_ptr_array_index(tab, i);
 178                 if (file == NULL)
 179                         fprintf(stderr, "NULL, ");
 180                 else
 181                         fprintf(stderr, "%s, ", file->name);
 182         }
 183         fprintf(stderr, "]\n\n");
 184 }
 185
 186 void show_history(struct file_history *history)
 187 {
 188         struct file_history *tmp = history;
 189
 190         while (tmp != NULL) {
 191                 fprintf(stderr, "fd = %d, name = %s\n", tmp->file->fd,
 192                                         tmp->file->name);
 193                 tmp = tmp->next;
 194         }
 195
 196 }
 197
 198 int update_iostream_ret(struct lttngtop *ctx, int tid, char *comm,
 199                 unsigned long timestamp, uint64_t cpu_id, int ret,
 200                 char *hostname)
 201 {
 202         struct processtop *tmp;
 203         struct files *tmpfile;
 204         int err = 0;
 205
 206         tmp = get_proc(ctx, tid, comm, timestamp, hostname);
 207
 208         if (!tmp) {
 209                 err = -1;
 210                 goto end;
 211         }
 212         if (tmp->syscall_info != NULL) {
 213                 if (tmp->syscall_info->type == __NR_read
 214                         && ret > 0) {
 215                         tmp->totalfileread += ret;
 216                         tmp->fileread += ret;
 217                         tmpfile = get_file(tmp, tmp->syscall_info->fd);
 218                         if (tmpfile)
 219                                 tmpfile->read += ret;
 220                 } else if (tmp->syscall_info->type == __NR_write
 221                         && ret > 0) {
 222                         tmp->totalfilewrite += ret;
 223                         tmp->filewrite += ret;
 224                         tmpfile = get_file(tmp, tmp->syscall_info->fd);
 225                         if (tmpfile)
 226                                 tmpfile->write += ret;
 227                 } else if (tmp->syscall_info->type == __NR_open
 228                         && ret > 0) {
 229                         tmpfile = tmp->files_history->file;
 230                         add_file(tmp, tmpfile, ret);
 231                         tmpfile->fd = ret;
 232                 } else {
 233                         err = -1;
 234                 }
 235                 g_free(tmp->syscall_info);
 236                 tmp->syscall_info = NULL;
 237         }
 238
 239 end:
 240         return err;
 241 }
 242
 243 struct syscalls *create_syscall_info(unsigned int type, uint64_t cpu_id,
 244                 unsigned int tid, int fd)
 245 {
 246         struct syscalls *syscall_info;
 247
 248         syscall_info = g_new0(struct syscalls, 1);
 249         syscall_info->type = type;
 250         syscall_info->cpu_id = cpu_id;
 251         syscall_info->tid = tid;
 252         syscall_info->fd = fd;
 253
 254         return syscall_info;
 255 }
 256
 257 struct file_history *create_file(struct file_history *history, char *file_name)
 258 {
 259         struct files *new_file;
 260         struct file_history *new_history;
 261
 262         new_file = g_new0(struct files, 1);
 263         new_history = g_new0(struct file_history, 1);
 264         new_file->name = strdup(file_name);
 265         new_file->read = 0;
 266         new_file->write = 0;
 267         new_file->flag = -1;
 268         new_history->file = new_file;
 269         new_history->next = history;
 270
 271         return new_history;
 272 }
 273
 274 enum bt_cb_ret handle_exit_syscall(struct bt_ctf_event *call_data,
 275                 void *private_data)
 276 {
 277         const struct bt_definition *scope;
 278         unsigned long timestamp;
 279         char *comm;
 280         uint64_t ret, tid;
 281         uint64_t cpu_id;
 282         char *hostname;
 283
 284         timestamp = bt_ctf_get_timestamp(call_data);
 285         if (timestamp == -1ULL)
 286                 goto error;
 287
 288         comm = get_context_comm(call_data);
 289         tid = get_context_tid(call_data);
 290
 291         scope = bt_ctf_get_top_level_scope(call_data,
 292                         BT_EVENT_FIELDS);
 293         ret = bt_ctf_get_int64(bt_ctf_get_field(call_data,
 294                                 scope, "_ret"));
 295         if (bt_ctf_field_get_error()) {
 296                 fprintf(stderr, "Missing ret context info\n");
 297                 goto error;
 298         }
 299
 300         cpu_id = get_cpu_id(call_data);
 301         hostname = get_context_hostname(call_data);
 302
 303         /*
 304          * if we encounter an exit_syscall and
 305          * it is not for a syscall read or write
 306          * we just abort the execution of this callback
 307          */
 308         if ((update_iostream_ret(&lttngtop, tid, comm, timestamp, cpu_id,
 309                                         ret, hostname)) < 0)
 310                 return BT_CB_ERROR_CONTINUE;
 311
 312         return BT_CB_OK;
 313
 314 error:
 315         return BT_CB_ERROR_STOP;
 316 }
 317
 318
 319 enum bt_cb_ret handle_sys_write(struct bt_ctf_event *call_data,
 320                 void *private_data)
 321 {
 322         const struct bt_definition *scope;
 323         struct processtop *tmp;
 324         unsigned long timestamp;
 325         uint64_t cpu_id;
 326         int64_t tid;
 327         char *procname, *hostname;
 328         int fd;
 329
 330         timestamp = bt_ctf_get_timestamp(call_data);
 331         if (timestamp == -1ULL)
 332                 goto error;
 333
 334         tid = get_context_tid(call_data);
 335         cpu_id = get_cpu_id(call_data);
 336
 337         procname = get_context_comm(call_data);
 338         hostname = get_context_hostname(call_data);
 339
 340         scope = bt_ctf_get_top_level_scope(call_data,
 341                         BT_EVENT_FIELDS);
 342         fd = bt_ctf_get_uint64(bt_ctf_get_field(call_data,
 343                                 scope, "_fd"));
 344         if (bt_ctf_field_get_error()) {
 345                 fprintf(stderr, "Missing fd context info\n");
 346                 goto error;
 347         }
 348
 349         tmp = get_proc(&lttngtop, tid, procname, timestamp, hostname);
 350         if (!tmp)
 351                 goto end;
 352
 353         tmp->syscall_info = create_syscall_info(__NR_write, cpu_id, tid, fd);
 354
 355         insert_file(tmp, fd);
 356
 357 end:
 358         return BT_CB_OK;
 359
 360 error:
 361         return BT_CB_ERROR_STOP;
 362 }
 363
 364 enum bt_cb_ret handle_sys_read(struct bt_ctf_event *call_data,
 365                 void *private_data)
 366 {
 367         struct processtop *tmp;
 368         const struct bt_definition *scope;
 369         unsigned long timestamp;
 370         uint64_t cpu_id;
 371         int64_t tid;
 372         char *procname;
 373         int fd;
 374         char *hostname;
 375
 376         timestamp = bt_ctf_get_timestamp(call_data);
 377         if (timestamp == -1ULL)
 378                 goto error;
 379
 380         tid = get_context_tid(call_data);
 381         cpu_id = get_cpu_id(call_data);
 382
 383         procname = get_context_comm(call_data);
 384         hostname = get_context_hostname(call_data);
 385
 386         scope = bt_ctf_get_top_level_scope(call_data,
 387                         BT_EVENT_FIELDS);
 388         fd = bt_ctf_get_uint64(bt_ctf_get_field(call_data,
 389                                 scope, "_fd"));
 390         if (bt_ctf_field_get_error()) {
 391                 fprintf(stderr, "Missing fd context info\n");
 392                 goto error;
 393         }
 394
 395         tmp = get_proc(&lttngtop, tid, procname, timestamp, hostname);
 396         if (!tmp)
 397                 goto end;
 398
 399         tmp->syscall_info = create_syscall_info(__NR_read, cpu_id, tid, fd);
 400
 401         insert_file(tmp, fd);
 402
 403 end:
 404         return BT_CB_OK;
 405
 406 error:
 407         return BT_CB_ERROR_STOP;
 408 }
 409
 410 enum bt_cb_ret handle_sys_open(struct bt_ctf_event *call_data,
 411                 void *private_data)
 412 {
 413
 414         struct processtop *tmp;
 415         const struct bt_definition *scope;
 416         unsigned long timestamp;
 417         uint64_t cpu_id;
 418         int64_t tid;
 419         char *procname, *hostname;
 420         char *file;
 421
 422         timestamp = bt_ctf_get_timestamp(call_data);
 423         if (timestamp == -1ULL)
 424                 goto error;
 425
 426         tid = get_context_tid(call_data);
 427         cpu_id = get_cpu_id(call_data);
 428
 429         procname = get_context_comm(call_data);
 430         hostname = get_context_hostname(call_data);
 431
 432         scope = bt_ctf_get_top_level_scope(call_data,
 433                         BT_EVENT_FIELDS);
 434         file = bt_ctf_get_string(bt_ctf_get_field(call_data,
 435                                 scope, "_filename"));
 436         if (bt_ctf_field_get_error()) {
 437                 fprintf(stderr, "Missing file name context info\n");
 438                 goto error;
 439         }
 440
 441         tmp = get_proc(&lttngtop, tid, procname, timestamp, hostname);
 442         if (!tmp)
 443                 goto end;
 444
 445         tmp->syscall_info = create_syscall_info(__NR_open, cpu_id, tid, -1);
 446
 447         tmp->files_history = create_file(tmp->files_history, file);
 448
 449 end:
 450         return BT_CB_OK;
 451
 452 error:
 453         return BT_CB_ERROR_STOP;
 454 }
 455
 456 enum bt_cb_ret handle_sys_socket(struct bt_ctf_event *call_data,
 457                 void *private_data)
 458 {
 459
 460         struct processtop *tmp;
 461         unsigned long timestamp;
 462         uint64_t cpu_id;
 463         int64_t tid;
 464         char *procname, *hostname;
 465         char *file;
 466
 467         timestamp = bt_ctf_get_timestamp(call_data);
 468         if (timestamp == -1ULL)
 469                 goto error;
 470
 471         tid = get_context_tid(call_data);
 472         cpu_id = get_cpu_id(call_data);
 473
 474         procname = get_context_comm(call_data);
 475         hostname = get_context_hostname(call_data);
 476
 477         file = strdup("socket");
 478
 479         tmp = get_proc(&lttngtop, tid, procname, timestamp, hostname);
 480         if (!tmp)
 481                 goto end;
 482
 483         tmp->syscall_info = create_syscall_info(__NR_open, cpu_id, tid, -1);
 484
 485         tmp->files_history = create_file(tmp->files_history, file);
 486
 487 end:
 488         return BT_CB_OK;
 489
 490 error:
 491         return BT_CB_ERROR_STOP;
 492 }
 493
 494 enum bt_cb_ret handle_sys_close(struct bt_ctf_event *call_data,
 495                 void *private_data)
 496 {
 497         const struct bt_definition *scope;
 498         struct processtop *tmp;
 499         unsigned long timestamp;
 500         int64_t tid;
 501         char *procname;
 502         int fd;
 503         char *hostname;
 504
 505         timestamp = bt_ctf_get_timestamp(call_data);
 506         if (timestamp == -1ULL)
 507                 goto error;
 508
 509         tid = get_context_tid(call_data);
 510
 511         procname = get_context_comm(call_data);
 512         hostname = get_context_hostname(call_data);
 513
 514         scope = bt_ctf_get_top_level_scope(call_data,
 515                         BT_EVENT_FIELDS);
 516         fd = bt_ctf_get_uint64(bt_ctf_get_field(call_data,
 517                                 scope, "_fd"));
 518         if (bt_ctf_field_get_error()) {
 519                 fprintf(stderr, "Missing fd context info\n");
 520                 goto error;
 521         }
 522
 523         tmp = get_proc(&lttngtop, tid, procname, timestamp, hostname);
 524         if (!tmp)
 525                 goto end;
 526
 527         close_file(tmp, fd);
 528
 529 end:
 530         return BT_CB_OK;
 531
 532 error:
 533         return BT_CB_ERROR_STOP;
 534 }
 535
 536 enum bt_cb_ret handle_statedump_file_descriptor(struct bt_ctf_event *call_data,
 537                 void *private_data)
 538 {
 539         const struct bt_definition *scope;
 540         struct processtop *parent;
 541         struct files *file;
 542         unsigned long timestamp;
 543         int64_t pid;
 544         char *file_name, *hostname;
 545         int fd;
 546
 547         timestamp = bt_ctf_get_timestamp(call_data);
 548         if (timestamp == -1ULL)
 549                 goto error;
 550
 551         scope = bt_ctf_get_top_level_scope(call_data,
 552                          BT_EVENT_FIELDS);
 553         pid = bt_ctf_get_int64(bt_ctf_get_field(call_data,
 554                              scope, "_pid"));
 555         if (bt_ctf_field_get_error()) {
 556                 fprintf(stderr, "Missing tid context info\n");
 557                 goto error;
 558         }
 559
 560         scope = bt_ctf_get_top_level_scope(call_data,
 561                         BT_EVENT_FIELDS);
 562         fd = bt_ctf_get_int64(bt_ctf_get_field(call_data,
 563                                 scope, "_fd"));
 564         if (bt_ctf_field_get_error()) {
 565                 fprintf(stderr, "Missing fd context info\n");
 566                 goto error;
 567         }
 568
 569         scope = bt_ctf_get_top_level_scope(call_data,
 570                         BT_EVENT_FIELDS);
 571         file_name = bt_ctf_get_string(bt_ctf_get_field(call_data,
 572                                 scope, "_filename"));
 573         if (bt_ctf_field_get_error()) {
 574                 fprintf(stderr, "Missing file name context info\n");
 575                 goto error;
 576         }
 577         hostname = get_context_hostname(call_data);
 578
 579         parent = get_proc_pid(&lttngtop, pid, pid, timestamp, hostname);
 580         if (!parent)
 581                 goto end;
 582
 583         parent->files_history = create_file(parent->files_history, file_name);
 584         file = parent->files_history->file;
 585         edit_file(parent, file, fd);
 586
 587 end:
 588         return BT_CB_OK;
 589
 590 error:
 591         return BT_CB_ERROR_STOP;
 592 }