1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include <stdio.h> 18 #include <sys/time.h> 19 #include <sys/types.h> 20 #include <unistd.h> 21 #include <stdlib.h> 22 #include <signal.h> 23 #include <string.h> 24 #include <sys/stat.h> 25 #include <sys/errno.h> 26 #include <fcntl.h> 27 #include <ctype.h> 28 #include "ioshark.h" 29 #include "compile_ioshark.h" 30 31 char *progname; 32 33 char in_buf[2048]; 34 35 struct flags_map_s { 36 char *flag_str; 37 int flag; 38 }; 39 40 #define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) 41 42 struct flags_map_s open_flags_map[] = { 43 { "O_RDONLY", O_RDONLY }, 44 { "O_WRONLY", O_WRONLY }, 45 { "O_RDWR", O_RDWR }, 46 { "O_CREAT", O_CREAT }, 47 { "O_SYNC", O_SYNC }, 48 { "O_TRUNC", O_TRUNC }, 49 { "O_EXCL", O_EXCL }, 50 { "O_APPEND", O_APPEND }, 51 { "O_NOATIME", O_NOATIME }, 52 { "O_ASYNC", O_ASYNC }, 53 { "O_CLOEXEC", O_CLOEXEC }, 54 { "O_DIRECT", O_DIRECT }, 55 { "O_DIRECTORY", O_DIRECTORY }, 56 { "O_LARGEFILE", O_LARGEFILE }, 57 { "O_NOCTTY", O_NOCTTY }, 58 { "O_NOFOLLOW", O_NOFOLLOW }, 59 { "O_NONBLOCK", O_NONBLOCK }, 60 { "O_NDELAY", O_NDELAY }, 61 { "O_PATH", O_PATH } 62 }; 63 64 struct flags_map_s lseek_action_map[] = { 65 { "SEEK_SET", SEEK_SET }, 66 { "SEEK_CUR", SEEK_CUR }, 67 { "SEEK_END", SEEK_END } 68 }; 69 70 struct flags_map_s fileop_map[] = { 71 { "lseek", IOSHARK_LSEEK }, 72 { "_llseek", IOSHARK_LLSEEK }, 73 { "pread64", IOSHARK_PREAD64 }, 74 { "pwrite64", IOSHARK_PWRITE64 }, 75 { "read", IOSHARK_READ }, 76 { "write", IOSHARK_WRITE }, 77 { "mmap", IOSHARK_MMAP }, 78 { "mmap2", IOSHARK_MMAP2 }, 79 { "openat", IOSHARK_OPEN }, 80 { "fsync", IOSHARK_FSYNC }, 81 { "fdatasync", IOSHARK_FDATASYNC }, 82 { "close", IOSHARK_CLOSE }, 83 { "ftrace", IOSHARK_MAPPED_PREAD } 84 }; 85 86 struct in_mem_file_op { 87 struct ioshark_file_operation disk_file_op; 88 struct in_mem_file_op *next; 89 }; 90 91 struct in_mem_file_op *in_mem_file_op_head = NULL, *in_mem_file_op_tail = NULL; 92 93 void usage(void) 94 { 95 fprintf(stderr, "%s in_file out_file\n", progname); 96 } 97 98 void 99 init_prev_time(struct timeval *tv) 100 { 101 tv->tv_sec = tv->tv_usec = 0; 102 } 103 104 /* 105 * delta ts is the time delta from the previous IO in this tracefile. 106 */ 107 static u_int64_t 108 get_delta_ts(char *buf, struct timeval *prev) 109 { 110 struct timeval op_tv, tv_res; 111 112 sscanf(buf, "%lu.%lu", &op_tv.tv_sec, &op_tv.tv_usec); 113 /* First item */ 114 if (prev->tv_sec == 0 && prev->tv_usec == 0) 115 tv_res.tv_sec = tv_res.tv_usec = 0; 116 else 117 timersub(&op_tv, prev, &tv_res); 118 *prev = op_tv; 119 return (tv_res.tv_usec + (tv_res.tv_sec * 1000000)); 120 } 121 122 void 123 get_tracetype(char *buf, char *trace_type) 124 { 125 char *s, *s2; 126 127 *trace_type = '\0'; 128 s = strchr(buf, ' '); 129 if (s == NULL) { 130 fprintf(stderr, 131 "%s Malformed Trace Type ? %s\n", 132 progname, __func__); 133 exit(EXIT_FAILURE); 134 } 135 while (*s == ' ') 136 s++; 137 if (sscanf(s, "%s", trace_type) != 1) { 138 fprintf(stderr, 139 "%s Malformed Trace Type ? %s\n", 140 progname, __func__); 141 exit(EXIT_FAILURE); 142 } 143 if (strcmp(trace_type, "strace") != 0 && 144 strcmp(trace_type, "ftrace") != 0) { 145 fprintf(stderr, 146 "%s Unknown/Missing Trace Type (has to be strace|ftrace) %s\n", 147 progname, __func__); 148 exit(EXIT_FAILURE); 149 } 150 /* 151 * Remove the keyword "strace"/"ftrace" from the buffer 152 */ 153 s2 = strchr(s, ' '); 154 if (s2 == NULL) { 155 fprintf(stderr, 156 "%s Malformed Trace Type ? %s\n", 157 progname, __func__); 158 exit(EXIT_FAILURE); 159 } 160 while (*s2 == ' ') 161 s2++; 162 if (*s2 == '\0') { 163 /* 164 * Premature end of input record 165 */ 166 fprintf(stderr, 167 "%s Mal-formed strace/ftrace record %s:%s\n", 168 progname, __func__, buf); 169 exit(EXIT_FAILURE); 170 } 171 /* strcpy() expects non-overlapping buffers, but bcopy doesn't */ 172 bcopy(s2, s, strlen(s2) + 1); 173 } 174 175 void 176 get_pathname(char *buf, char *pathname, enum file_op file_op) 177 { 178 char *s, *s2, save; 179 180 if (file_op == IOSHARK_MAPPED_PREAD) { 181 s = strchr(buf, '/'); 182 if (s == NULL) { 183 fprintf(stderr, "%s: Malformed line: %s\n", 184 __func__, buf); 185 exit(EXIT_FAILURE); 186 } 187 s2 = strchr(s, ' '); 188 if (s2 == NULL) { 189 fprintf(stderr, "%s: Malformed line: %s\n", 190 __func__, buf); 191 exit(EXIT_FAILURE); 192 } 193 } else { 194 if (file_op == IOSHARK_OPEN) 195 s = strchr(buf, '"'); 196 else 197 s = strchr(buf, '<'); 198 if (s == NULL) { 199 fprintf(stderr, "%s: Malformed line: %s\n", 200 __func__, buf); 201 exit(EXIT_FAILURE); 202 } 203 s += 1; 204 if (file_op == IOSHARK_OPEN) 205 s2 = strchr(s, '"'); 206 else 207 s2 = strchr(s, '>'); 208 if (s2 == NULL) { 209 fprintf(stderr, "%s: Malformed line: %s\n", 210 __func__, buf); 211 exit(EXIT_FAILURE); 212 } 213 } 214 save = *s2; 215 *s2 = '\0'; 216 strcpy(pathname, s); 217 *s2 = save; 218 } 219 220 void 221 get_syscall(char *buf, char *syscall) 222 { 223 char *s, *s2; 224 225 s = strchr(buf, ' '); 226 if (s == NULL) { 227 fprintf(stderr, "%s: Malformed line: %s\n", 228 __func__, buf); 229 exit(EXIT_FAILURE); 230 } 231 s += 1; 232 s2 = strchr(s, '('); 233 if (s2 == NULL) { 234 fprintf(stderr, "%s: Malformed line: %s\n", 235 __func__, buf); 236 exit(EXIT_FAILURE); 237 } 238 *s2 = '\0'; 239 strcpy(syscall, s); 240 *s2 = '('; 241 } 242 243 void 244 get_mmap_offset_len_prot(char *buf, int *prot, off_t *offset, u_int64_t *len) 245 { 246 char *s, *s1; 247 int i; 248 char protstr[128]; 249 250 s = strchr(buf, ','); 251 if (s == NULL) { 252 fprintf(stderr, "%s: Malformed line: %s\n", 253 __func__, buf); 254 exit(EXIT_FAILURE); 255 } 256 s += 2; 257 sscanf(s, "%ju", len); 258 s1 = strchr(s, ','); 259 if (s1 == NULL) { 260 fprintf(stderr, "%s: Malformed line: %s\n", 261 __func__, buf); 262 exit(EXIT_FAILURE); 263 } 264 s1 += 2; 265 s = strchr(s1, ','); 266 if (s == NULL) { 267 fprintf(stderr, "%s: Malformed line: %s\n", 268 __func__, buf); 269 exit(EXIT_FAILURE); 270 } 271 *s = '\0'; 272 strcpy(protstr, s1); 273 *prot = 0; 274 if (strstr(protstr, "PROT_READ")) 275 *prot |= IOSHARK_PROT_READ; 276 if (strstr(protstr, "PROT_WRITE")) 277 *prot |= IOSHARK_PROT_WRITE; 278 *s = ','; 279 s += 2; 280 for (i = 0 ; i < 2 ; i++) { 281 s = strchr(s, ','); 282 if (s == NULL) { 283 fprintf(stderr, "%s: Malformed line: %s\n", 284 __func__, buf); 285 exit(EXIT_FAILURE); 286 } 287 s += 2; 288 } 289 sscanf(s, "%jx", offset); 290 } 291 292 void 293 get_lseek_offset_action(char *buf, enum file_op op, 294 off_t *offset, char *action) 295 { 296 char *s, *s2; 297 298 s = strchr(buf, ','); 299 if (s == NULL) { 300 fprintf(stderr, "%s: Malformed line: %s\n", 301 __func__, buf); 302 exit(EXIT_FAILURE); 303 } 304 s += 2; 305 sscanf(s, "%ju", offset); 306 s = strchr(s, ','); 307 if (s == NULL) { 308 fprintf(stderr, "%s: Malformed line: %s\n", 309 __func__, buf); 310 exit(EXIT_FAILURE); 311 } 312 s += 2; 313 if (op == IOSHARK_LLSEEK) { 314 s = strchr(s, ','); 315 if (s == NULL) { 316 fprintf(stderr, "%s: Malformed line: %s\n", 317 __func__, buf); 318 exit(EXIT_FAILURE); 319 } 320 s += 2; 321 } 322 s2 = strchr(s, ')'); 323 if (s2 == NULL) { 324 fprintf(stderr, "%s: Malformed line: %s\n", 325 __func__, buf); 326 exit(EXIT_FAILURE); 327 } 328 *s2 = '\0'; 329 strcpy(action, s); 330 *s2 = ')'; 331 } 332 333 void 334 get_rw_len(char *buf, 335 u_int64_t *len) 336 { 337 char *s_len; 338 339 s_len = strrchr(buf, ','); 340 if (s_len == NULL) { 341 fprintf(stderr, "%s: Malformed line: %s\n", 342 __func__, buf); 343 exit(EXIT_FAILURE); 344 } 345 sscanf(s_len + 2, "%ju", len); 346 } 347 348 void 349 get_prw64_offset_len(char *buf, 350 off_t *offset, 351 u_int64_t *len) 352 { 353 char *s_offset, *s_len; 354 355 s_offset = strrchr(buf, ','); 356 if (s_offset == NULL) { 357 fprintf(stderr, "%s: Malformed line 1: %s\n", 358 __func__, buf); 359 exit(EXIT_FAILURE); 360 } 361 *s_offset = '\0'; 362 s_len = strrchr(buf, ','); 363 if (s_len == NULL) { 364 fprintf(stderr, "%s: Malformed line 2: %s\n", 365 __func__, buf); 366 exit(EXIT_FAILURE); 367 } 368 *s_offset = ','; 369 sscanf(s_len + 2, "%ju", len); 370 sscanf(s_offset + 2, "%ju", offset); 371 } 372 373 374 void 375 get_ftrace_offset_len(char *buf, 376 off_t *offset, 377 u_int64_t *len) 378 { 379 char *s_offset; 380 381 s_offset = strchr(buf, '/'); 382 if (s_offset == NULL) { 383 fprintf(stderr, "%s: Malformed line 1: %s\n", 384 __func__, buf); 385 exit(EXIT_FAILURE); 386 } 387 s_offset = strchr(s_offset, ' '); 388 if (s_offset == NULL) { 389 fprintf(stderr, "%s: Malformed line 2: %s\n", 390 __func__, buf); 391 exit(EXIT_FAILURE); 392 } 393 while (*s_offset == ' ') 394 s_offset++; 395 if (sscanf(s_offset, "%ju %ju", offset, len) != 2) { 396 fprintf(stderr, "%s: Malformed line 3: %s\n", 397 __func__, buf); 398 exit(EXIT_FAILURE); 399 } 400 } 401 402 void 403 get_openat_flags_mode(char *buf, char *flags, mode_t *mode) 404 { 405 char *s, *s2, lookfor; 406 407 s = strchr(buf, ','); 408 if (s == NULL) { 409 fprintf(stderr, "%s: Malformed line: %s\n", 410 __func__, buf); 411 exit(EXIT_FAILURE); 412 } 413 s += 2; 414 s = strchr(s, ','); 415 if (s == NULL) { 416 fprintf(stderr, "%s: Malformed line: %s\n", 417 __func__, buf); 418 exit(EXIT_FAILURE); 419 } 420 s += 2; 421 if (strstr(s, "O_CREAT") == NULL) 422 lookfor = ')'; 423 else 424 lookfor = ','; 425 s2 = strchr(s, lookfor); 426 if (s2 == NULL) { 427 fprintf(stderr, "%s: Malformed line: %s\n", 428 __func__, buf); 429 exit(EXIT_FAILURE); 430 } 431 *s2 = '\0'; 432 strcpy(flags, s); 433 *s2 = lookfor; 434 if (strstr(s, "O_CREAT") != NULL) { 435 s = s2 + 2; 436 s2 = strchr(s, ')'); 437 if (s2 == NULL) { 438 fprintf(stderr, "%s: Malformed line: %s\n", 439 __func__, buf); 440 exit(EXIT_FAILURE); 441 } 442 *s2 = '\0'; 443 sscanf(s, "%o", mode); 444 *s2 = ')'; 445 } 446 } 447 448 int 449 lookup_map(char *s, struct flags_map_s *flags_map, int maplen) 450 { 451 int found = 0, flag = 0; 452 int i; 453 454 while (isspace(*s)) 455 s++; 456 for (i = 0 ; i < maplen ; i++) { 457 if (strcmp(flags_map[i].flag_str, s) == 0) { 458 flag = flags_map[i].flag; 459 found = 1; 460 break; 461 } 462 } 463 if (found == 0) { 464 fprintf(stderr, "%s: Unknown syscall %s\n", 465 __func__, s); 466 exit(1); 467 } 468 return flag; 469 } 470 471 int 472 map_open_flags(char *s) 473 { 474 int flags = 0; 475 char *s1; 476 477 while ((s1 = strchr(s, '|'))) { 478 *s1 = '\0'; 479 flags |= lookup_map(s, open_flags_map, 480 ARRAY_SIZE(open_flags_map)); 481 *s1 = '|'; 482 s = s1 + 1; 483 } 484 /* Last option */ 485 flags |= lookup_map(s, open_flags_map, 486 ARRAY_SIZE(open_flags_map)); 487 return flags; 488 } 489 490 int 491 map_lseek_action(char *s) 492 { 493 int flags = 0; 494 char *s1; 495 496 while ((s1 = strchr(s, '|'))) { 497 *s1 = '\0'; 498 flags |= lookup_map(s, lseek_action_map, 499 ARRAY_SIZE(lseek_action_map)); 500 *s1 = '|'; 501 s = s1 + 1; 502 } 503 /* Last option */ 504 flags |= lookup_map(s, lseek_action_map, 505 ARRAY_SIZE(lseek_action_map)); 506 return flags; 507 } 508 509 enum file_op 510 map_syscall(char *syscall) 511 { 512 return lookup_map(syscall, fileop_map, 513 ARRAY_SIZE(fileop_map)); 514 } 515 516 /* 517 * For each tracefile, we first create in-memory structures, then once 518 * we've processed each tracefile completely, we write out the in-memory 519 * structures and free them. 520 */ 521 int main(int argc, char **argv) 522 { 523 FILE *fp; 524 char path[512]; 525 char syscall[512]; 526 char lseek_action_str[512]; 527 char *s; 528 char open_flags_str[64]; 529 void *db_node; 530 int num_io_operations = 0; 531 struct ioshark_header header; 532 struct ioshark_file_operation *disk_file_op; 533 struct in_mem_file_op *in_mem_fop; 534 struct stat st; 535 char *infile, *outfile; 536 struct timeval prev_time; 537 char trace_type[64]; 538 539 progname = argv[0]; 540 if (argc != 3) { 541 usage(); 542 exit(EXIT_FAILURE); 543 } 544 infile = argv[1]; 545 outfile = argv[2]; 546 if (stat(infile, &st) < 0) { 547 fprintf(stderr, "%s Can't stat %s\n", 548 progname, infile); 549 exit(EXIT_FAILURE); 550 } 551 if (st.st_size == 0) { 552 fprintf(stderr, "%s Empty file %s\n", 553 progname, infile); 554 exit(EXIT_FAILURE); 555 } 556 init_prev_time(&prev_time); 557 init_filename_cache(); 558 fp = fopen(infile, "r"); 559 if (fp == NULL) { 560 fprintf(stderr, "%s Can't open %s\n", 561 progname, infile); 562 exit(EXIT_FAILURE); 563 } 564 while (fgets(in_buf, 2048, fp)) { 565 s = in_buf; 566 while (isspace(*s)) 567 s++; 568 in_mem_fop = malloc(sizeof(struct in_mem_file_op)); 569 disk_file_op = &in_mem_fop->disk_file_op; 570 disk_file_op->delta_us = get_delta_ts(s, &prev_time); 571 get_tracetype(s, trace_type); 572 if (strcmp(trace_type, "strace") == 0) { 573 get_syscall(s, syscall); 574 disk_file_op->file_op = map_syscall(syscall); 575 } else 576 disk_file_op->file_op = map_syscall("ftrace"); 577 get_pathname(s, path, disk_file_op->file_op); 578 db_node = files_db_add(path); 579 disk_file_op->fileno = files_db_get_fileno(db_node); 580 switch (disk_file_op->file_op) { 581 case IOSHARK_LLSEEK: 582 case IOSHARK_LSEEK: 583 get_lseek_offset_action(s, 584 disk_file_op->file_op, 585 &disk_file_op->lseek_offset, 586 lseek_action_str); 587 disk_file_op->lseek_action = 588 map_lseek_action(lseek_action_str); 589 if (disk_file_op->lseek_action == SEEK_SET) 590 files_db_update_size(db_node, 591 disk_file_op->lseek_offset); 592 break; 593 case IOSHARK_PREAD64: 594 case IOSHARK_PWRITE64: 595 get_prw64_offset_len(s, 596 &disk_file_op->prw_offset, 597 (u_int64_t *)&disk_file_op->prw_len); 598 files_db_update_size(db_node, 599 disk_file_op->prw_offset + 600 disk_file_op->prw_len); 601 break; 602 case IOSHARK_READ: 603 case IOSHARK_WRITE: 604 get_rw_len(s, (u_int64_t *)&disk_file_op->rw_len); 605 files_db_add_to_size(db_node, 606 disk_file_op->rw_len); 607 break; 608 case IOSHARK_MMAP: 609 case IOSHARK_MMAP2: 610 get_mmap_offset_len_prot(s, 611 &disk_file_op->mmap_prot, 612 &disk_file_op->mmap_offset, 613 (u_int64_t *)&disk_file_op->mmap_len); 614 files_db_update_size(db_node, 615 disk_file_op->mmap_offset + 616 disk_file_op->mmap_len); 617 break; 618 case IOSHARK_OPEN: 619 disk_file_op->open_mode = 0; 620 get_openat_flags_mode(s, open_flags_str, 621 &disk_file_op->open_mode); 622 disk_file_op->open_flags = 623 map_open_flags(open_flags_str); 624 break; 625 case IOSHARK_FSYNC: 626 case IOSHARK_FDATASYNC: 627 break; 628 case IOSHARK_CLOSE: 629 break; 630 case IOSHARK_MAPPED_PREAD: 631 /* Convert a mmap'ed read into a PREAD64 */ 632 disk_file_op->file_op = IOSHARK_PREAD64; 633 get_ftrace_offset_len(s, 634 &disk_file_op->prw_offset, 635 (u_int64_t *)&disk_file_op->prw_len); 636 files_db_update_size(db_node, 637 disk_file_op->prw_offset + 638 disk_file_op->prw_len); 639 break; 640 default: 641 break; 642 } 643 /* Chain at the end */ 644 num_io_operations++; 645 in_mem_fop->next = NULL; 646 if (in_mem_file_op_head == NULL) { 647 in_mem_file_op_tail = in_mem_fop; 648 in_mem_file_op_head = in_mem_fop; 649 } else { 650 in_mem_file_op_tail->next = in_mem_fop; 651 in_mem_file_op_tail = in_mem_fop; 652 } 653 } 654 fclose(fp); 655 /* 656 * Now we can write everything out to the output tracefile. 657 */ 658 fp = fopen(outfile, "w+"); 659 if (fp == NULL) { 660 fprintf(stderr, "%s Can't open trace.outfile\n", 661 progname); 662 exit(EXIT_FAILURE); 663 } 664 header.num_io_operations = num_io_operations; 665 header.num_files = files_db_get_total_obj(); 666 if (fwrite(&header, sizeof(struct ioshark_header), 1, fp) != 1) { 667 fprintf(stderr, "%s Write error trace.outfile\n", 668 progname); 669 exit(EXIT_FAILURE); 670 } 671 files_db_write_objects(fp); 672 while (in_mem_file_op_head != NULL) { 673 struct in_mem_file_op *temp; 674 675 disk_file_op = &in_mem_file_op_head->disk_file_op; 676 if (fwrite(disk_file_op, 677 sizeof(struct ioshark_file_operation), 1, fp) != 1) { 678 fprintf(stderr, "%s Write error trace.outfile\n", 679 progname); 680 exit(EXIT_FAILURE); 681 } 682 temp = in_mem_file_op_head; 683 in_mem_file_op_head = in_mem_file_op_head->next; 684 free(temp); 685 } 686 store_filename_cache(); 687 } 688
