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 (strcmp(tmp_file->name, file->name) != 0) {
  52                                 size = proc->process_files_table->len;
  53                                 g_ptr_array_set_size(proc->process_files_table,
  54                                                                 size+1);
  55                                 g_ptr_array_index(proc->process_files_table,
  56                                                         size) = tmp_file;
  57                                 g_ptr_array_index(proc->process_files_table,
  58                                                         fd) = file;
  59                         } else
  60                                 tmp_file->flag = __NR_open;
  61                 }
  62         }
  63         /*
  64          * The file may have be created in the parent
  65          */
  66         if (file->flag == -1) {
  67                 file->fd = fd;
  68                 file->flag = __NR_open;
  69                 lttngtop.nbfiles++;
  70                 lttngtop.nbnewfiles++;
  71         }
  72 }
  73
  74 /*
  75  * Edit the file
  76  * Called by handled_statedump_filename
  77  */
  78 void edit_file(struct processtop *proc, struct files *file, int fd)
  79 {
  80         int size = proc->process_files_table->len;
  81         struct files *tmpfile;
  82
  83         if (fd >= size) {
  84                 add_file(proc, file, fd);
  85         } else {
  86                 tmpfile = g_ptr_array_index(proc->process_files_table, fd);
  87                 if (tmpfile) {
  88                         tmpfile->name = strdup(file->name);
  89                         free(file);
  90                 } else
  91                         add_file(proc, file, fd);
  92         }
  93 }
  94
  95 void insert_file(struct processtop *proc, int fd)
  96 {
  97         struct files *tmp;
  98         struct files *tmp_parent;
  99         struct processtop *parent;
 100
 101         if (fd < 0)
 102                 return;
 103         if (fd >= proc->process_files_table->len) {
 104                 tmp = g_new0(struct files, 1);
 105                 tmp->name = "Unknown";
 106                 tmp->read = 0;
 107                 tmp->write = 0;
 108                 tmp->fd = fd;
 109                 tmp->flag = -1;
 110                 add_file(proc, tmp, fd);
 111         } else {
 112                 tmp = g_ptr_array_index(proc->process_files_table, fd);
 113                 if (tmp == NULL) {
 114                         tmp = g_new0(struct files, 1);
 115                         tmp->name = "Unknown";
 116                         tmp->read = 0;
 117                         tmp->write = 0;
 118                         tmp->fd = fd;
 119                         tmp->flag = -1;
 120                         add_file(proc, tmp, fd);
 121                 } else {
 122                         parent = proc->threadparent;
 123                         if (parent) {
 124                                 tmp_parent = g_ptr_array_index(
 125                                         parent->process_files_table, fd);
 126                                 if (tmp_parent &&
 127                                    (strcmp(tmp->name, tmp_parent->name)) != 0)
 128                                         tmp->name = strdup(tmp_parent->name);
 129                         }
 130                 }
 131         }
 132 }
 133
 134 void close_file(struct processtop *proc, int fd)
 135 {
 136         struct files *file;
 137
 138         file = get_file(proc, fd);
 139         if (file != NULL) {
 140                 file->flag = __NR_close;
 141                 lttngtop.nbfiles--;
 142         }
 143         lttngtop.nbclosedfiles++;
 144 }
 145
 146 struct files *get_file(struct processtop *proc, int fd)
 147 {
 148         int len;
 149         struct files *tmp = NULL;
 150
 151         len = proc->process_files_table->len;
 152
 153         /*
 154          * It is possible that a file was open before taking the trace
 155          * and its fd could be greater than all of the others fd
 156          * used by the process
 157          */
 158         if (fd < len && fd >= 0)
 159                 tmp = g_ptr_array_index(proc->process_files_table, fd);
 160
 161         return tmp;
 162 }
 163
 164 void show_table(GPtrArray *tab)
 165 {
 166         int i;
 167         struct files *file;
 168
 169         for (i = 0 ; i < tab->len; i++) {
 170                 file = g_ptr_array_index(tab, i);
 171                 if (file == NULL)
 172                         fprintf(stderr, "NULL, ");
 173                 else
 174                         fprintf(stderr, "%s, ", file->name);
 175         }
 176         fprintf(stderr, "]\n\n");
 177 }
 178
 179 void show_history(struct file_history *history)
 180 {
 181         struct file_history *tmp = history;
 182
 183         while (tmp != NULL) {
 184                 fprintf(stderr, "fd = %d, name = %s\n", tmp->file->fd,
 185                                         tmp->file->name);
 186                 tmp = tmp->next;
 187         }
 188
 189 }
 190
 191 int update_iostream_ret(struct lttngtop *ctx, int tid, char *comm,
 192                 unsigned long timestamp, uint64_t cpu_id, int ret,
 193                 char *hostname)
 194 {
 195         struct processtop *tmp;
 196         struct files *tmpfile;
 197         int err = 0;
 198
 199         tmp = get_proc(ctx, tid, comm, timestamp, hostname);
 200
 201         if (!tmp) {
 202                 err = -1;
 203                 goto end;
 204         }
 205         if (tmp->syscall_info != NULL) {
 206                 if (tmp->syscall_info->type == __NR_read
 207                         && ret > 0) {
 208                         tmp->totalfileread += ret;
 209                         tmp->fileread += ret;
 210                         tmpfile = get_file(tmp, tmp->syscall_info->fd);
 211                         if (tmpfile)
 212                                 tmpfile->read += ret;
 213                 } else if (tmp->syscall_info->type == __NR_write
 214                         && ret > 0) {
 215                         tmp->totalfilewrite += ret;
 216                         tmp->filewrite += ret;
 217                         tmpfile = get_file(tmp, tmp->syscall_info->fd);
 218                         if (tmpfile)
 219                                 tmpfile->write += ret;
 220                 } else if (tmp->syscall_info->type == __NR_open
 221                         && ret > 0) {
 222                         tmpfile = tmp->files_history->file;
 223                         add_file(tmp, tmpfile, ret);
 224                         tmpfile->fd = ret;
 225                 } else {
 226                         err = -1;
 227                 }
 228                 g_free(tmp->syscall_info);
 229                 tmp->syscall_info = NULL;
 230         }
 231
 232 end:
 233         return err;
 234 }
 235
 236 struct syscalls *create_syscall_info(unsigned int type, uint64_t cpu_id,
 237                 unsigned int tid, int fd)
 238 {
 239         struct syscalls *syscall_info;
 240
 241         syscall_info = g_new0(struct syscalls, 1);
 242         syscall_info->type = type;
 243         syscall_info->cpu_id = cpu_id;
 244         syscall_info->tid = tid;
 245         syscall_info->fd = fd;
 246
 247         return syscall_info;
 248 }
 249
 250 struct file_history *create_file(struct file_history *history, char *file_name)
 251 {
 252         struct files *new_file;
 253         struct file_history *new_history;
 254
 255         new_file = g_new0(struct files, 1);
 256         new_history = g_new0(struct file_history, 1);
 257         new_file->name = strdup(file_name);
 258         new_file->read = 0;
 259         new_file->write = 0;
 260         new_file->flag = -1;
 261         new_history->file = new_file;
 262         new_history->next = history;
 263
 264         return new_history;
 265 }
 266
 267 enum bt_cb_ret handle_exit_syscall(struct bt_ctf_event *call_data,
 268                 void *private_data)
 269 {
 270         const struct bt_definition *scope;
 271         unsigned long timestamp;
 272         char *comm;
 273         uint64_t ret, tid;
 274         uint64_t cpu_id;
 275         char *hostname;
 276
 277         timestamp = bt_ctf_get_timestamp(call_data);
 278         if (timestamp == -1ULL)
 279                 goto error;
 280
 281         comm = get_context_comm(call_data);
 282         tid = get_context_tid(call_data);
 283
 284         scope = bt_ctf_get_top_level_scope(call_data,
 285                         BT_EVENT_FIELDS);
 286         ret = bt_ctf_get_int64(bt_ctf_get_field(call_data,
 287                                 scope, "_ret"));
 288         if (bt_ctf_field_get_error()) {
 289                 fprintf(stderr, "Missing ret context info\n");
 290                 goto error;
 291         }
 292
 293         cpu_id = get_cpu_id(call_data);
 294         hostname = get_context_hostname(call_data);
 295
 296         /*
 297          * if we encounter an exit_syscall and
 298          * it is not for a syscall read or write
 299          * we just abort the execution of this callback
 300          */
 301         if ((update_iostream_ret(&lttngtop, tid, comm, timestamp, cpu_id,
 302                                         ret, hostname)) < 0)
 303                 return BT_CB_ERROR_CONTINUE;
 304
 305         return BT_CB_OK;
 306
 307 error:
 308         return BT_CB_ERROR_STOP;
 309 }
 310
 311
 312 enum bt_cb_ret handle_sys_write(struct bt_ctf_event *call_data,
 313                 void *private_data)
 314 {
 315         const struct bt_definition *scope;
 316         struct processtop *tmp;
 317         unsigned long timestamp;
 318         uint64_t cpu_id;
 319         int64_t tid;
 320         char *procname, *hostname;
 321         int fd;
 322
 323         timestamp = bt_ctf_get_timestamp(call_data);
 324         if (timestamp == -1ULL)
 325                 goto error;
 326
 327         tid = get_context_tid(call_data);
 328         cpu_id = get_cpu_id(call_data);
 329
 330         procname = get_context_comm(call_data);
 331         hostname = get_context_hostname(call_data);
 332
 333         scope = bt_ctf_get_top_level_scope(call_data,
 334                         BT_EVENT_FIELDS);
 335         fd = bt_ctf_get_uint64(bt_ctf_get_field(call_data,
 336                                 scope, "_fd"));
 337         if (bt_ctf_field_get_error()) {
 338                 fprintf(stderr, "Missing fd context info\n");
 339                 goto error;
 340         }
 341
 342         tmp = get_proc(&lttngtop, tid, procname, timestamp, hostname);
 343         if (!tmp)
 344                 goto end;
 345
 346         tmp->syscall_info = create_syscall_info(__NR_write, cpu_id, tid, fd);
 347
 348         insert_file(tmp, fd);
 349
 350 end:
 351         return BT_CB_OK;
 352
 353 error:
 354         return BT_CB_ERROR_STOP;
 355 }
 356
 357 enum bt_cb_ret handle_sys_read(struct bt_ctf_event *call_data,
 358                 void *private_data)
 359 {
 360         struct processtop *tmp;
 361         const struct bt_definition *scope;
 362         unsigned long timestamp;
 363         uint64_t cpu_id;
 364         int64_t tid;
 365         char *procname;
 366         int fd;
 367         char *hostname;
 368
 369         timestamp = bt_ctf_get_timestamp(call_data);
 370         if (timestamp == -1ULL)
 371                 goto error;
 372
 373         tid = get_context_tid(call_data);
 374         cpu_id = get_cpu_id(call_data);
 375
 376         procname = get_context_comm(call_data);
 377         hostname = get_context_hostname(call_data);
 378
 379         scope = bt_ctf_get_top_level_scope(call_data,
 380                         BT_EVENT_FIELDS);
 381         fd = bt_ctf_get_uint64(bt_ctf_get_field(call_data,
 382                                 scope, "_fd"));
 383         if (bt_ctf_field_get_error()) {
 384                 fprintf(stderr, "Missing fd context info\n");
 385                 goto error;
 386         }
 387
 388         tmp = get_proc(&lttngtop, tid, procname, timestamp, hostname);
 389         if (!tmp)
 390                 goto end;
 391
 392         tmp->syscall_info = create_syscall_info(__NR_read, cpu_id, tid, fd);
 393
 394         insert_file(tmp, fd);
 395
 396 end:
 397         return BT_CB_OK;
 398
 399 error:
 400         return BT_CB_ERROR_STOP;
 401 }
 402
 403
 404 enum bt_cb_ret handle_sys_open(struct bt_ctf_event *call_data,
 405                 void *private_data)
 406 {
 407
 408         struct processtop *tmp;
 409         const struct bt_definition *scope;
 410         unsigned long timestamp;
 411         uint64_t cpu_id;
 412         int64_t tid;
 413         char *procname, *hostname;
 414         char *file;
 415
 416         timestamp = bt_ctf_get_timestamp(call_data);
 417         if (timestamp == -1ULL)
 418                 goto error;
 419
 420         tid = get_context_tid(call_data);
 421         cpu_id = get_cpu_id(call_data);
 422
 423         procname = get_context_comm(call_data);
 424         hostname = get_context_hostname(call_data);
 425
 426         scope = bt_ctf_get_top_level_scope(call_data,
 427                         BT_EVENT_FIELDS);
 428         file = bt_ctf_get_string(bt_ctf_get_field(call_data,
 429                                 scope, "_filename"));
 430         if (bt_ctf_field_get_error()) {
 431                 fprintf(stderr, "Missing file name context info\n");
 432                 goto error;
 433         }
 434
 435         tmp = get_proc(&lttngtop, tid, procname, timestamp, hostname);
 436         if (!tmp)
 437                 goto end;
 438
 439         tmp->syscall_info = create_syscall_info(__NR_open, cpu_id, tid, -1);
 440
 441         tmp->files_history = create_file(tmp->files_history, file);
 442
 443 end:
 444         return BT_CB_OK;
 445
 446 error:
 447         return BT_CB_ERROR_STOP;
 448 }
 449
 450
 451 enum bt_cb_ret handle_sys_close(struct bt_ctf_event *call_data,
 452                 void *private_data)
 453 {
 454         const struct bt_definition *scope;
 455         struct processtop *tmp;
 456         unsigned long timestamp;
 457         int64_t tid;
 458         char *procname;
 459         int fd;
 460         char *hostname;
 461
 462         timestamp = bt_ctf_get_timestamp(call_data);
 463         if (timestamp == -1ULL)
 464                 goto error;
 465
 466         tid = get_context_tid(call_data);
 467
 468         procname = get_context_comm(call_data);
 469         hostname = get_context_hostname(call_data);
 470
 471         scope = bt_ctf_get_top_level_scope(call_data,
 472                         BT_EVENT_FIELDS);
 473         fd = bt_ctf_get_uint64(bt_ctf_get_field(call_data,
 474                                 scope, "_fd"));
 475         if (bt_ctf_field_get_error()) {
 476                 fprintf(stderr, "Missing fd context info\n");
 477                 goto error;
 478         }
 479
 480         tmp = get_proc(&lttngtop, tid, procname, timestamp, hostname);
 481         if (!tmp)
 482                 goto end;
 483
 484         close_file(tmp, fd);
 485
 486 end:
 487         return BT_CB_OK;
 488
 489 error:
 490         return BT_CB_ERROR_STOP;
 491 }
 492
 493 enum bt_cb_ret handle_statedump_file_descriptor(struct bt_ctf_event *call_data,
 494                 void *private_data)
 495 {
 496         const struct bt_definition *scope;
 497         struct processtop *parent;
 498         struct files *file;
 499         unsigned long timestamp;
 500         int64_t pid;
 501         char *file_name, *hostname;
 502         int fd;
 503
 504         timestamp = bt_ctf_get_timestamp(call_data);
 505         if (timestamp == -1ULL)
 506                 goto error;
 507
 508         scope = bt_ctf_get_top_level_scope(call_data,
 509                          BT_EVENT_FIELDS);
 510         pid = bt_ctf_get_int64(bt_ctf_get_field(call_data,
 511                              scope, "_pid"));
 512         if (bt_ctf_field_get_error()) {
 513                 fprintf(stderr, "Missing tid context info\n");
 514                 goto error;
 515         }
 516
 517         scope = bt_ctf_get_top_level_scope(call_data,
 518                         BT_EVENT_FIELDS);
 519         fd = bt_ctf_get_int64(bt_ctf_get_field(call_data,
 520                                 scope, "_fd"));
 521         if (bt_ctf_field_get_error()) {
 522                 fprintf(stderr, "Missing fd context info\n");
 523                 goto error;
 524         }
 525
 526         scope = bt_ctf_get_top_level_scope(call_data,
 527                         BT_EVENT_FIELDS);
 528         file_name = bt_ctf_get_string(bt_ctf_get_field(call_data,
 529                                 scope, "_filename"));
 530         if (bt_ctf_field_get_error()) {
 531                 fprintf(stderr, "Missing file name context info\n");
 532                 goto error;
 533         }
 534         hostname = get_context_hostname(call_data);
 535
 536         parent = get_proc_pid(&lttngtop, pid, pid, timestamp, hostname);
 537         if (!parent)
 538                 goto end;
 539
 540         parent->files_history = create_file(parent->files_history, file_name);
 541         file = parent->files_history->file;
 542         edit_file(parent, file, fd);
 543
 544 end:
 545         return BT_CB_OK;
 546
 547 error:
 548         return BT_CB_ERROR_STOP;
 549 }