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 <string.h> 28 #include <assert.h> 29 #include <sys/vfs.h> 30 #include <sys/statvfs.h> 31 #include <sys/mman.h> 32 #include "ioshark.h" 33 #include "ioshark_bench.h" 34 35 extern char *progname; 36 extern int verbose, summary_mode; 37 38 void * 39 files_db_create_handle(void) 40 { 41 struct files_db_handle *h; 42 int i; 43 44 h = malloc(sizeof(struct files_db_handle)); 45 for (i = 0 ; i < FILE_DB_HASHSIZE ; i++) 46 h->files_db_buckets[i] = NULL; 47 return h; 48 } 49 50 void *files_db_lookup_byfileno(void *handle, int fileno) 51 { 52 u_int32_t hash; 53 struct files_db_handle *h = (struct files_db_handle *)handle; 54 struct files_db_s *db_node; 55 56 hash = fileno % FILE_DB_HASHSIZE; 57 db_node = h->files_db_buckets[hash]; 58 while (db_node != NULL) { 59 if (db_node->fileno == fileno) 60 break; 61 db_node = db_node->next; 62 } 63 return db_node; 64 } 65 66 void *files_db_add_byfileno(void *handle, int fileno, int readonly) 67 { 68 u_int32_t hash = fileno % FILE_DB_HASHSIZE; 69 struct files_db_handle *h = (struct files_db_handle *)handle; 70 struct files_db_s *db_node; 71 72 db_node = (struct files_db_s *) 73 files_db_lookup_byfileno(handle, fileno); 74 if (db_node == NULL) { 75 db_node = malloc(sizeof(struct files_db_s)); 76 db_node->fileno = fileno; 77 db_node->filename = NULL; 78 db_node->readonly = readonly; 79 db_node->size = 0; 80 db_node->fd = -1; 81 db_node->next = h->files_db_buckets[hash]; 82 h->files_db_buckets[hash] = db_node; 83 } else { 84 fprintf(stderr, 85 "%s: Node to be added already exists fileno = %d\n\n", 86 __func__, fileno); 87 exit(EXIT_FAILURE); 88 } 89 return db_node; 90 } 91 92 void 93 files_db_fsync_discard_files(void *handle) 94 { 95 struct files_db_handle *h = (struct files_db_handle *)handle; 96 struct files_db_s *db_node; 97 int i; 98 99 for (i = 0 ; i < FILE_DB_HASHSIZE ; i++) { 100 db_node = h->files_db_buckets[i]; 101 while (db_node != NULL) { 102 int do_close = 0; 103 104 if (db_node->fd == -1) { 105 int fd; 106 int openflags; 107 108 /*n 109 * File was closed, let's open it so we can 110 * fsync and fadvise(DONTNEED) it. 111 */ 112 do_close = 1; 113 if (files_db_readonly(db_node)) 114 openflags = O_RDONLY; 115 else 116 openflags = O_RDWR; 117 fd = open(files_db_get_filename(db_node), 118 openflags); 119 if (fd < 0) { 120 fprintf(stderr, 121 "%s: open(%s %x) error %d\n", 122 progname, db_node->filename, 123 openflags, 124 errno); 125 exit(EXIT_FAILURE); 126 } 127 db_node->fd = fd; 128 } 129 if (!db_node->readonly && fsync(db_node->fd) < 0) { 130 fprintf(stderr, "%s: Cannot fsync %s\n", 131 __func__, db_node->filename); 132 exit(1); 133 } 134 if (posix_fadvise(db_node->fd, 0, 0, 135 POSIX_FADV_DONTNEED) < 0) { 136 fprintf(stderr, 137 "%s: Cannot fadvise(DONTNEED) %s\n", 138 __func__, db_node->filename); 139 exit(1); 140 } 141 if (do_close) { 142 close(db_node->fd); 143 db_node->fd = -1; 144 } 145 db_node = db_node->next; 146 } 147 } 148 } 149 150 void 151 files_db_update_fd(void *node, int fd) 152 { 153 struct files_db_s *db_node = (struct files_db_s *)node; 154 155 db_node->fd = fd; 156 } 157 158 void 159 files_db_close_fd(void *node) 160 { 161 struct files_db_s *db_node = (struct files_db_s *)node; 162 163 if (db_node->fd != -1) 164 close(db_node->fd); 165 db_node->fd = -1; 166 } 167 168 void 169 files_db_close_files(void *handle) 170 { 171 struct files_db_handle *h = (struct files_db_handle *)handle; 172 struct files_db_s *db_node; 173 int i; 174 175 for (i = 0 ; i < FILE_DB_HASHSIZE ; i++) { 176 db_node = h->files_db_buckets[i]; 177 while (db_node != NULL) { 178 if ((db_node->fd != -1) && close(db_node->fd) < 0) { 179 fprintf(stderr, "%s: Cannot close %s\n", 180 __func__, db_node->filename); 181 exit(1); 182 } 183 db_node->fd = -1; 184 db_node = db_node->next; 185 } 186 } 187 } 188 189 void 190 files_db_unlink_files(void *handle) 191 { 192 struct files_db_handle *h = (struct files_db_handle *)handle; 193 struct files_db_s *db_node; 194 int i; 195 196 for (i = 0 ; i < FILE_DB_HASHSIZE ; i++) { 197 db_node = h->files_db_buckets[i]; 198 while (db_node != NULL) { 199 if ((db_node->fd != -1) && close(db_node->fd) < 0) { 200 fprintf(stderr, "%s: Cannot close %s\n", 201 __func__, db_node->filename); 202 exit(1); 203 } 204 db_node->fd = -1; 205 if (is_readonly_mount(db_node->filename, db_node->size) == 0) { 206 if (unlink(db_node->filename) < 0) { 207 fprintf(stderr, "%s: Cannot unlink %s:%s\n", 208 __func__, db_node->filename, 209 strerror(errno)); 210 exit(EXIT_FAILURE); 211 } 212 } 213 db_node = db_node->next; 214 } 215 } 216 } 217 218 void 219 files_db_free_memory(void *handle) 220 { 221 struct files_db_handle *h = (struct files_db_handle *)handle; 222 struct files_db_s *db_node, *tmp; 223 int i; 224 225 for (i = 0 ; i < FILE_DB_HASHSIZE ; i++) { 226 db_node = h->files_db_buckets[i]; 227 while (db_node != NULL) { 228 tmp = db_node; 229 db_node = db_node->next; 230 free(tmp->filename); 231 free(tmp); 232 } 233 } 234 free(h); 235 } 236 237 char * 238 get_buf(char **buf, int *buflen, int len, int do_fill __attribute__((unused))) 239 { 240 if (len == 0 && *buf == NULL) { 241 /* 242 * If we ever get a zero len 243 * request, start with MINBUFLEN 244 */ 245 if (*buf == NULL) 246 len = MINBUFLEN / 2; 247 } 248 if (*buflen < len) { 249 *buflen = MAX(MINBUFLEN, len * 2); 250 if (*buf) 251 free(*buf); 252 *buf = malloc(*buflen); 253 if (do_fill) { 254 u_int32_t *s; 255 int count; 256 257 s = (u_int32_t *)*buf; 258 count = *buflen / sizeof(u_int32_t); 259 while (count > 0) { 260 *s++ = rand(); 261 count--; 262 } 263 } 264 } 265 assert(*buf != NULL); 266 return *buf; 267 } 268 269 void 270 create_file(char *path, size_t size, struct rw_bytes_s *rw_bytes) 271 { 272 int fd, n; 273 char *buf = NULL; 274 int buflen = 0; 275 276 fd = open(path, O_WRONLY|O_CREAT|O_TRUNC, 0644); 277 if (fd < 0) { 278 fprintf(stderr, "%s Cannot create file %s, error = %d\n", 279 progname, path, errno); 280 exit(EXIT_FAILURE); 281 } 282 while (size > 0) { 283 n = MIN(size, MINBUFLEN); 284 buf = get_buf(&buf, &buflen, n, 1); 285 if (write(fd, buf, n) < n) { 286 fprintf(stderr, 287 "%s Cannot write file %s, error = %d\n", 288 progname, path, errno); 289 exit(EXIT_FAILURE); 290 } 291 rw_bytes->bytes_written += n; 292 size -= n; 293 } 294 if (fsync(fd) < 0) { 295 fprintf(stderr, "%s Cannot fsync file %s, error = %d\n", 296 progname, path, errno); 297 exit(EXIT_FAILURE); 298 } 299 if (posix_fadvise(fd, 0, 0, POSIX_FADV_DONTNEED) < 0) { 300 fprintf(stderr, 301 "%s Cannot fadvise(DONTNEED) file %s, error = %d\n", 302 progname, path, errno); 303 exit(EXIT_FAILURE); 304 } 305 close(fd); 306 } 307 308 void 309 print_op_stats(u_int64_t *op_counts) 310 { 311 int i; 312 extern char *IO_op[]; 313 314 printf("IO Operation counts :\n"); 315 for (i = IOSHARK_LSEEK ; i < IOSHARK_MAX_FILE_OP ; i++) { 316 printf("%s: %ju\n", 317 IO_op[i], op_counts[i]); 318 } 319 } 320 321 void 322 print_bytes(char *desc, struct rw_bytes_s *rw_bytes) 323 { 324 if (!summary_mode) 325 printf("%s: Reads = %dMB, Writes = %dMB\n", 326 desc, 327 (int)(rw_bytes->bytes_read / (1024 * 1024)), 328 (int)(rw_bytes->bytes_written / (1024 * 1024))); 329 else 330 printf("%d %d ", 331 (int)(rw_bytes->bytes_read / (1024 * 1024)), 332 (int)(rw_bytes->bytes_written / (1024 * 1024))); 333 } 334 335 struct cpu_disk_util_stats { 336 /* CPU util */ 337 u_int64_t user_cpu_ticks; 338 u_int64_t nice_cpu_ticks; 339 u_int64_t system_cpu_ticks; 340 u_int64_t idle_cpu_ticks; 341 u_int64_t iowait_cpu_ticks; 342 u_int64_t hardirq_cpu_ticks; 343 u_int64_t softirq_cpu_ticks; 344 /* disk util */ 345 unsigned long long uptime; 346 unsigned int tot_ticks; 347 unsigned long rd_ios; 348 unsigned long wr_ios; 349 unsigned long rd_sec; 350 unsigned long wr_sec; 351 }; 352 353 static struct cpu_disk_util_stats before; 354 static struct cpu_disk_util_stats after; 355 356 #define BUFSIZE 8192 357 358 static int hz; 359 360 static void 361 get_HZ(void) 362 { 363 if ((hz = sysconf(_SC_CLK_TCK)) == -1) 364 exit(1); 365 } 366 367 #if 0 368 static int num_cores; 369 370 static void 371 get_cores(void) 372 { 373 if ((num_cores = sysconf(_SC_NPROCESSORS_ONLN)) == -1) 374 exit(1); 375 } 376 #endif 377 378 static void 379 get_blockdev_name(char *bdev) 380 { 381 char dev_name[BUFSIZE]; 382 FILE *cmd; 383 384 cmd = popen("getprop ro.product.name", "r"); 385 if (cmd == NULL) { 386 fprintf(stderr, "%s: Cannot popen getprop\n", 387 progname); 388 exit(1); 389 } 390 if (fgets(dev_name, BUFSIZE, cmd) == NULL) { 391 fprintf(stderr, 392 "%s: Bad output from getprop ro.product.name\n", 393 progname); 394 exit(1); 395 } 396 pclose(cmd); 397 /* strncmp needed because of the trailing '\n' */ 398 if (strncmp(dev_name, "bullhead", strlen("bullhead")) == 0 || 399 strncmp(dev_name, "angler", strlen("angler")) == 0 || 400 strncmp(dev_name, "shamu", strlen("shamu")) == 0) { 401 strcpy(bdev, "mmcblk0"); 402 } else if (strncmp(dev_name, "marlin", strlen("marlin")) == 0 || 403 strncmp(dev_name, "sailfish", strlen("sailfish")) == 0) { 404 strcpy(bdev, "sda"); 405 } else { 406 fprintf(stderr, 407 "%s: Unknown device %s\n", 408 progname, dev_name); 409 exit(1); 410 } 411 } 412 413 static void 414 read_disk_util_state(struct cpu_disk_util_stats *state) 415 { 416 FILE *fp; 417 char line[BUFSIZE], dev_name[BUFSIZE]; 418 unsigned int major, minor; 419 unsigned int ios_pgr; 420 unsigned int rq_ticks; 421 unsigned int wr_ticks; 422 unsigned long rd_ticks; 423 unsigned long rd_merges; 424 unsigned long wr_merges; 425 unsigned long up_sec, up_cent; 426 char blockdev_name[BUFSIZE]; 427 428 /* Read and parse /proc/uptime */ 429 fp = fopen("/proc/uptime", "r"); 430 if (fgets(line, sizeof(line), fp) == NULL) { 431 fprintf(stderr, "%s: Cannot read /proc/uptime\n", 432 progname); 433 exit(1); 434 } 435 fclose(fp); 436 sscanf(line, "%lu.%lu", &up_sec, &up_cent); 437 state->uptime = (unsigned long long) up_sec * hz + 438 (unsigned long long) up_cent * hz / 100; 439 440 /* Read and parse /proc/diskstats */ 441 get_blockdev_name(blockdev_name); 442 fp = fopen("/proc/diskstats", "r"); 443 while (fgets(line, sizeof(line), fp)) { 444 sscanf(line, 445 "%u %u %s %lu %lu %lu %lu %lu %lu %lu %u %u %u %u", 446 &major, &minor, dev_name, 447 &state->rd_ios, &rd_merges, &state->rd_sec, 448 &rd_ticks, &state->wr_ios, &wr_merges, 449 &state->wr_sec, &wr_ticks, 450 &ios_pgr, &state->tot_ticks, &rq_ticks); 451 if (strcmp(dev_name, blockdev_name) == 0) { 452 /* 453 * tot_ticks is "number of milliseconds spent 454 * doing I/Os". Look at Documentation/iostats.txt. 455 * Or at genhd.c:diskstats_show(), which calls 456 * jiffies_to_msecs() on this field before printing 457 * it. Convert this to hz, so we can do all our math 458 * in ticks. 459 */ 460 state->tot_ticks /= 1000; /* to seconds */ 461 state->tot_ticks *= hz; /* to hz */ 462 fclose(fp); 463 return; 464 } 465 } 466 fprintf(stderr, "%s: Did not find device sda in /proc/diskstats\n", 467 progname); 468 exit(1); 469 } 470 471 static void 472 read_cpu_util_state(struct cpu_disk_util_stats *state) 473 { 474 FILE *fp; 475 char line[BUFSIZE], cpu[BUFSIZE]; 476 477 /* Read and parse /proc/stat */ 478 fp = fopen("/proc/stat", "r"); 479 if (fgets(line, sizeof(line), fp) == NULL) { 480 fprintf(stderr, "%s: Cannot read /proc/stat\n", 481 progname); 482 exit(1); 483 } 484 fclose(fp); 485 sscanf(line, "%s %ju %ju %ju %ju %ju %ju %ju", 486 cpu, 487 &state->user_cpu_ticks, 488 &state->nice_cpu_ticks, 489 &state->system_cpu_ticks, 490 &state->idle_cpu_ticks, 491 &state->iowait_cpu_ticks, 492 &state->hardirq_cpu_ticks, 493 &state->softirq_cpu_ticks); 494 } 495 496 void 497 capture_util_state_before(void) 498 { 499 get_HZ(); 500 read_disk_util_state(&before); 501 read_cpu_util_state(&before); 502 } 503 504 void 505 report_cpu_disk_util(void) 506 { 507 double disk_util, cpu_util; 508 u_int64_t tot1, tot2, delta1, delta2; 509 510 read_disk_util_state(&after); 511 read_cpu_util_state(&after); 512 /* CPU Util */ 513 tot2 = after.user_cpu_ticks + after.nice_cpu_ticks + 514 after.system_cpu_ticks + after.hardirq_cpu_ticks + 515 after.softirq_cpu_ticks; 516 tot1 = before.user_cpu_ticks + before.nice_cpu_ticks + 517 before.system_cpu_ticks + before.hardirq_cpu_ticks + 518 before.softirq_cpu_ticks; 519 delta1 = tot2 - tot1; 520 tot2 += after.iowait_cpu_ticks + after.idle_cpu_ticks; 521 tot1 += before.iowait_cpu_ticks + before.idle_cpu_ticks; 522 delta2 = tot2 - tot1; 523 cpu_util = delta1 * 100.0 / delta2; 524 if (!summary_mode) 525 printf("CPU util = %.2f%%\n", cpu_util); 526 else 527 printf("%.2f ", cpu_util); 528 /* Next compute system (incl irq/softirq) and user cpu util */ 529 delta1 = (after.user_cpu_ticks + after.nice_cpu_ticks) - 530 (before.user_cpu_ticks + before.nice_cpu_ticks); 531 cpu_util = delta1 * 100.0 / delta2; 532 if (!summary_mode) 533 printf("User CPU util = %.2f%%\n", cpu_util); 534 else 535 printf("%.2f ", cpu_util); 536 delta1 = (after.system_cpu_ticks + after.hardirq_cpu_ticks + 537 after.softirq_cpu_ticks) - 538 (before.system_cpu_ticks + before.hardirq_cpu_ticks + 539 before.softirq_cpu_ticks); 540 cpu_util = delta1 * 100.0 / delta2; 541 if (!summary_mode) 542 printf("System CPU util = %.2f%%\n", cpu_util); 543 else 544 printf("%.2f ", cpu_util); 545 /* Disk Util */ 546 disk_util = (after.tot_ticks - before.tot_ticks) * 100.0 / 547 (after.uptime - before.uptime); 548 if (verbose) { 549 printf("Reads : nr_ios %lu, MB read %lu\n", 550 (after.rd_ios - before.rd_ios), 551 (after.rd_sec - before.rd_sec) / 2048); 552 printf("Writes : nr_ios %lu, MB written %lu\n", 553 (after.wr_ios - before.wr_ios), 554 (after.wr_sec - before.wr_sec) / 2048); 555 } 556 if (!summary_mode) 557 printf("Disk util = %.2f%%\n", disk_util); 558 else 559 printf("%.2f", disk_util); 560 } 561 562 563 static struct ioshark_filename_struct *filename_cache; 564 static int filename_cache_num_entries; 565 566 char * 567 get_ro_filename(int ix) 568 { 569 if (ix >= filename_cache_num_entries) 570 return NULL; 571 return filename_cache[ix].path; 572 } 573 574 void 575 init_filename_cache(void) 576 { 577 int fd; 578 struct stat st; 579 580 fd = open("ioshark_filenames", O_RDONLY); 581 if (fd < 0) { 582 fprintf(stderr, "%s Can't open ioshark_filenames file\n", 583 progname); 584 exit(EXIT_FAILURE); 585 } 586 if (fstat(fd, &st) < 0) { 587 fprintf(stderr, "%s Can't fstat ioshark_filenames file\n", 588 progname); 589 exit(EXIT_FAILURE); 590 } 591 filename_cache_num_entries = st.st_size / 592 sizeof(struct ioshark_filename_struct); 593 filename_cache = mmap(NULL, st.st_size, PROT_READ, 594 MAP_SHARED | MAP_LOCKED | MAP_POPULATE, 595 fd, 0); 596 if (filename_cache == MAP_FAILED) { 597 fprintf(stderr, "%s Can't fstat ioshark_filenames file: %s\n", 598 progname, strerror(errno)); 599 exit(EXIT_FAILURE); 600 } 601 close(fd); 602 } 603 604 void 605 free_filename_cache(void) 606 { 607 size_t mmap_size; 608 609 mmap_size = filename_cache_num_entries * 610 sizeof(struct ioshark_filename_struct); 611 munmap(filename_cache, mmap_size); 612 } 613 614 /* 615 * Is the passed in filename a regular file ? (eg. not a directory). 616 * Second, is it in a read-only partition ? 617 */ 618 int 619 is_readonly_mount(char *filename, size_t size) 620 { 621 struct statfs statfsbuf; 622 struct stat statbuf; 623 624 if (stat(filename, &statbuf) < 0) { 625 /* File possibly deleted */ 626 return 0; 627 } 628 if (!S_ISREG(statbuf.st_mode)) { 629 /* Is it a regular file ? */ 630 return 0; 631 } 632 if ((size_t)statbuf.st_size < size) { 633 /* Size of existing file is smaller than we expect */ 634 return 0; 635 } 636 if (statfs(filename, &statfsbuf) < 0) { 637 /* This shouldn't happen */ 638 return 0; 639 } 640 if ((statfsbuf.f_flags & ST_RDONLY) == 0) 641 return 0; 642 else 643 return 1; 644 } 645
