1#include <stdio.h> 2#include <string.h> 3#include <sys/time.h> 4#include <sys/types.h> 5#include <sys/stat.h> 6#include <dirent.h> 7#include <libgen.h> 8#include <math.h> 9#include <assert.h> 10 11#include "fio.h" 12#include "smalloc.h" 13#include "diskutil.h" 14 15static int last_majdev, last_mindev; 16static struct disk_util *last_du; 17 18static struct fio_mutex *disk_util_mutex; 19 20FLIST_HEAD(disk_list); 21 22static struct disk_util *__init_per_file_disk_util(struct thread_data *td, 23 int majdev, int mindev, char *path); 24 25static void disk_util_free(struct disk_util *du) 26{ 27 if (du == last_du) 28 last_du = NULL; 29 30 while (!flist_empty(&du->slaves)) { 31 struct disk_util *slave; 32 33 slave = flist_entry(du->slaves.next, struct disk_util, slavelist); 34 flist_del(&slave->slavelist); 35 slave->users--; 36 } 37 38 fio_mutex_remove(du->lock); 39 sfree(du); 40} 41 42static int get_io_ticks(struct disk_util *du, struct disk_util_stat *dus) 43{ 44 unsigned in_flight; 45 unsigned long long sectors[2]; 46 char line[256]; 47 FILE *f; 48 char *p; 49 int ret; 50 51 dprint(FD_DISKUTIL, "open stat file: %s\n", du->path); 52 53 f = fopen(du->path, "r"); 54 if (!f) 55 return 1; 56 57 p = fgets(line, sizeof(line), f); 58 if (!p) { 59 fclose(f); 60 return 1; 61 } 62 63 dprint(FD_DISKUTIL, "%s: %s", du->path, p); 64 65 ret = sscanf(p, "%u %u %llu %u %u %u %llu %u %u %u %u\n", 66 &dus->s.ios[0], 67 &dus->s.merges[0], §ors[0], 68 &dus->s.ticks[0], &dus->s.ios[1], 69 &dus->s.merges[1], §ors[1], 70 &dus->s.ticks[1], &in_flight, 71 &dus->s.io_ticks, 72 &dus->s.time_in_queue); 73 fclose(f); 74 dprint(FD_DISKUTIL, "%s: stat read ok? %d\n", du->path, ret == 1); 75 dus->s.sectors[0] = sectors[0]; 76 dus->s.sectors[1] = sectors[1]; 77 return ret != 11; 78} 79 80static void update_io_tick_disk(struct disk_util *du) 81{ 82 struct disk_util_stat __dus, *dus, *ldus; 83 struct timeval t; 84 85 if (!du->users) 86 return; 87 if (get_io_ticks(du, &__dus)) 88 return; 89 90 dus = &du->dus; 91 ldus = &du->last_dus; 92 93 dus->s.sectors[0] += (__dus.s.sectors[0] - ldus->s.sectors[0]); 94 dus->s.sectors[1] += (__dus.s.sectors[1] - ldus->s.sectors[1]); 95 dus->s.ios[0] += (__dus.s.ios[0] - ldus->s.ios[0]); 96 dus->s.ios[1] += (__dus.s.ios[1] - ldus->s.ios[1]); 97 dus->s.merges[0] += (__dus.s.merges[0] - ldus->s.merges[0]); 98 dus->s.merges[1] += (__dus.s.merges[1] - ldus->s.merges[1]); 99 dus->s.ticks[0] += (__dus.s.ticks[0] - ldus->s.ticks[0]); 100 dus->s.ticks[1] += (__dus.s.ticks[1] - ldus->s.ticks[1]); 101 dus->s.io_ticks += (__dus.s.io_ticks - ldus->s.io_ticks); 102 dus->s.time_in_queue += (__dus.s.time_in_queue - ldus->s.time_in_queue); 103 104 fio_gettime(&t, NULL); 105 dus->s.msec += mtime_since(&du->time, &t); 106 memcpy(&du->time, &t, sizeof(t)); 107 memcpy(&ldus->s, &__dus.s, sizeof(__dus.s)); 108} 109 110int update_io_ticks(void) 111{ 112 struct flist_head *entry; 113 struct disk_util *du; 114 int ret = 0; 115 116 dprint(FD_DISKUTIL, "update io ticks\n"); 117 118 fio_mutex_down(disk_util_mutex); 119 120 if (!disk_util_exit) { 121 flist_for_each(entry, &disk_list) { 122 du = flist_entry(entry, struct disk_util, list); 123 update_io_tick_disk(du); 124 } 125 } else 126 ret = 1; 127 128 fio_mutex_up(disk_util_mutex); 129 return ret; 130} 131 132static struct disk_util *disk_util_exists(int major, int minor) 133{ 134 struct flist_head *entry; 135 struct disk_util *du; 136 137 fio_mutex_down(disk_util_mutex); 138 139 flist_for_each(entry, &disk_list) { 140 du = flist_entry(entry, struct disk_util, list); 141 142 if (major == du->major && minor == du->minor) { 143 fio_mutex_up(disk_util_mutex); 144 return du; 145 } 146 } 147 148 fio_mutex_up(disk_util_mutex); 149 return NULL; 150} 151 152static int get_device_numbers(char *file_name, int *maj, int *min) 153{ 154 struct stat st; 155 int majdev, mindev; 156 char tempname[PATH_MAX], *p; 157 158 if (!lstat(file_name, &st)) { 159 if (S_ISBLK(st.st_mode)) { 160 majdev = major(st.st_rdev); 161 mindev = minor(st.st_rdev); 162 } else if (S_ISCHR(st.st_mode)) { 163 majdev = major(st.st_rdev); 164 mindev = minor(st.st_rdev); 165 if (fio_lookup_raw(st.st_rdev, &majdev, &mindev)) 166 return -1; 167 } else if (S_ISFIFO(st.st_mode)) 168 return -1; 169 else { 170 majdev = major(st.st_dev); 171 mindev = minor(st.st_dev); 172 } 173 } else { 174 /* 175 * must be a file, open "." in that path 176 */ 177 strncpy(tempname, file_name, PATH_MAX - 1); 178 p = dirname(tempname); 179 if (stat(p, &st)) { 180 perror("disk util stat"); 181 return -1; 182 } 183 184 majdev = major(st.st_dev); 185 mindev = minor(st.st_dev); 186 } 187 188 *min = mindev; 189 *maj = majdev; 190 191 return 0; 192} 193 194static int read_block_dev_entry(char *path, int *maj, int *min) 195{ 196 char line[256], *p; 197 FILE *f; 198 199 f = fopen(path, "r"); 200 if (!f) { 201 perror("open path"); 202 return 1; 203 } 204 205 p = fgets(line, sizeof(line), f); 206 fclose(f); 207 208 if (!p) 209 return 1; 210 211 if (sscanf(p, "%u:%u", maj, min) != 2) 212 return 1; 213 214 return 0; 215} 216 217static void find_add_disk_slaves(struct thread_data *td, char *path, 218 struct disk_util *masterdu) 219{ 220 DIR *dirhandle = NULL; 221 struct dirent *dirent = NULL; 222 char slavesdir[PATH_MAX], temppath[PATH_MAX], slavepath[PATH_MAX]; 223 struct disk_util *slavedu = NULL; 224 int majdev, mindev; 225 ssize_t linklen; 226 227 sprintf(slavesdir, "%s/%s", path, "slaves"); 228 dirhandle = opendir(slavesdir); 229 if (!dirhandle) 230 return; 231 232 while ((dirent = readdir(dirhandle)) != NULL) { 233 if (!strcmp(dirent->d_name, ".") || 234 !strcmp(dirent->d_name, "..")) 235 continue; 236 237 sprintf(temppath, "%s%s%s", slavesdir, FIO_OS_PATH_SEPARATOR, dirent->d_name); 238 /* Can we always assume that the slaves device entries 239 * are links to the real directories for the slave 240 * devices? 241 */ 242 linklen = readlink(temppath, slavepath, PATH_MAX - 1); 243 if (linklen < 0) { 244 perror("readlink() for slave device."); 245 closedir(dirhandle); 246 return; 247 } 248 slavepath[linklen] = '\0'; 249 250 sprintf(temppath, "%s/%s/dev", slavesdir, slavepath); 251 if (read_block_dev_entry(temppath, &majdev, &mindev)) { 252 perror("Error getting slave device numbers."); 253 closedir(dirhandle); 254 return; 255 } 256 257 /* 258 * See if this maj,min already exists 259 */ 260 slavedu = disk_util_exists(majdev, mindev); 261 if (slavedu) 262 continue; 263 264 sprintf(temppath, "%s%s%s", slavesdir, FIO_OS_PATH_SEPARATOR, slavepath); 265 __init_per_file_disk_util(td, majdev, mindev, temppath); 266 slavedu = disk_util_exists(majdev, mindev); 267 268 /* Should probably use an assert here. slavedu should 269 * always be present at this point. */ 270 if (slavedu) { 271 slavedu->users++; 272 flist_add_tail(&slavedu->slavelist, &masterdu->slaves); 273 } 274 } 275 276 closedir(dirhandle); 277} 278 279static struct disk_util *disk_util_add(struct thread_data *td, int majdev, 280 int mindev, char *path) 281{ 282 struct disk_util *du, *__du; 283 struct flist_head *entry; 284 int l; 285 286 dprint(FD_DISKUTIL, "add maj/min %d/%d: %s\n", majdev, mindev, path); 287 288 du = smalloc(sizeof(*du)); 289 if (!du) { 290 log_err("fio: smalloc() pool exhausted\n"); 291 return NULL; 292 } 293 294 memset(du, 0, sizeof(*du)); 295 INIT_FLIST_HEAD(&du->list); 296 l = snprintf(du->path, sizeof(du->path), "%s/stat", path); 297 if (l < 0 || l >= sizeof(du->path)) { 298 log_err("constructed path \"%.100s[...]/stat\" larger than buffer (%zu bytes)\n", 299 path, sizeof(du->path) - 1); 300 sfree(du); 301 return NULL; 302 } 303 strncpy((char *) du->dus.name, basename(path), FIO_DU_NAME_SZ - 1); 304 du->sysfs_root = path; 305 du->major = majdev; 306 du->minor = mindev; 307 INIT_FLIST_HEAD(&du->slavelist); 308 INIT_FLIST_HEAD(&du->slaves); 309 du->lock = fio_mutex_init(FIO_MUTEX_UNLOCKED); 310 du->users = 0; 311 312 fio_mutex_down(disk_util_mutex); 313 314 flist_for_each(entry, &disk_list) { 315 __du = flist_entry(entry, struct disk_util, list); 316 317 dprint(FD_DISKUTIL, "found %s in list\n", __du->dus.name); 318 319 if (!strcmp((char *) du->dus.name, (char *) __du->dus.name)) { 320 disk_util_free(du); 321 fio_mutex_up(disk_util_mutex); 322 return __du; 323 } 324 } 325 326 dprint(FD_DISKUTIL, "add %s to list\n", du->dus.name); 327 328 fio_gettime(&du->time, NULL); 329 get_io_ticks(du, &du->last_dus); 330 331 flist_add_tail(&du->list, &disk_list); 332 fio_mutex_up(disk_util_mutex); 333 334 find_add_disk_slaves(td, path, du); 335 return du; 336} 337 338static int check_dev_match(int majdev, int mindev, char *path) 339{ 340 int major, minor; 341 342 if (read_block_dev_entry(path, &major, &minor)) 343 return 1; 344 345 if (majdev == major && mindev == minor) 346 return 0; 347 348 return 1; 349} 350 351static int find_block_dir(int majdev, int mindev, char *path, int link_ok) 352{ 353 struct dirent *dir; 354 struct stat st; 355 int found = 0; 356 DIR *D; 357 358 D = opendir(path); 359 if (!D) 360 return 0; 361 362 while ((dir = readdir(D)) != NULL) { 363 char full_path[256]; 364 365 if (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, "..")) 366 continue; 367 368 sprintf(full_path, "%s%s%s", path, FIO_OS_PATH_SEPARATOR, dir->d_name); 369 370 if (!strcmp(dir->d_name, "dev")) { 371 if (!check_dev_match(majdev, mindev, full_path)) { 372 found = 1; 373 break; 374 } 375 } 376 377 if (link_ok) { 378 if (stat(full_path, &st) == -1) { 379 perror("stat"); 380 break; 381 } 382 } else { 383 if (lstat(full_path, &st) == -1) { 384 perror("stat"); 385 break; 386 } 387 } 388 389 if (!S_ISDIR(st.st_mode) || S_ISLNK(st.st_mode)) 390 continue; 391 392 found = find_block_dir(majdev, mindev, full_path, 0); 393 if (found) { 394 strcpy(path, full_path); 395 break; 396 } 397 } 398 399 closedir(D); 400 return found; 401} 402 403static struct disk_util *__init_per_file_disk_util(struct thread_data *td, 404 int majdev, int mindev, 405 char *path) 406{ 407 struct stat st; 408 char tmp[PATH_MAX]; 409 char *p; 410 411 /* 412 * If there's a ../queue/ directory there, we are inside a partition. 413 * Check if that is the case and jump back. For loop/md/dm etc we 414 * are already in the right spot. 415 */ 416 sprintf(tmp, "%s/../queue", path); 417 if (!stat(tmp, &st)) { 418 p = dirname(path); 419 sprintf(tmp, "%s/queue", p); 420 if (stat(tmp, &st)) { 421 log_err("unknown sysfs layout\n"); 422 return NULL; 423 } 424 strncpy(tmp, p, PATH_MAX - 1); 425 sprintf(path, "%s", tmp); 426 } 427 428 if (td->o.ioscheduler && !td->sysfs_root) 429 td->sysfs_root = strdup(path); 430 431 return disk_util_add(td, majdev, mindev, path); 432} 433 434static struct disk_util *init_per_file_disk_util(struct thread_data *td, 435 char *filename) 436{ 437 438 char foo[PATH_MAX]; 439 struct disk_util *du; 440 int mindev, majdev; 441 442 if (get_device_numbers(filename, &majdev, &mindev)) 443 return NULL; 444 445 dprint(FD_DISKUTIL, "%s belongs to maj/min %d/%d\n", filename, majdev, 446 mindev); 447 448 du = disk_util_exists(majdev, mindev); 449 if (du) { 450 if (td->o.ioscheduler && !td->sysfs_root) 451 td->sysfs_root = strdup(du->sysfs_root); 452 453 return du; 454 } 455 456 /* 457 * for an fs without a device, we will repeatedly stat through 458 * sysfs which can take oodles of time for thousands of files. so 459 * cache the last lookup and compare with that before going through 460 * everything again. 461 */ 462 if (mindev == last_mindev && majdev == last_majdev) 463 return last_du; 464 465 last_mindev = mindev; 466 last_majdev = majdev; 467 468 sprintf(foo, "/sys/block"); 469 if (!find_block_dir(majdev, mindev, foo, 1)) 470 return NULL; 471 472 return __init_per_file_disk_util(td, majdev, mindev, foo); 473} 474 475static struct disk_util *__init_disk_util(struct thread_data *td, 476 struct fio_file *f) 477{ 478 return init_per_file_disk_util(td, f->file_name); 479} 480 481void init_disk_util(struct thread_data *td) 482{ 483 struct fio_file *f; 484 unsigned int i; 485 486 if (!td->o.do_disk_util || 487 (td->io_ops->flags & (FIO_DISKLESSIO | FIO_NODISKUTIL))) 488 return; 489 490 for_each_file(td, f, i) 491 f->du = __init_disk_util(td, f); 492} 493 494static void show_agg_stats(struct disk_util_agg *agg, int terse) 495{ 496 if (!agg->slavecount) 497 return; 498 499 if (!terse) { 500 log_info(", aggrios=%u/%u, aggrmerge=%u/%u, aggrticks=%u/%u," 501 " aggrin_queue=%u, aggrutil=%3.2f%%", 502 agg->ios[0] / agg->slavecount, 503 agg->ios[1] / agg->slavecount, 504 agg->merges[0] / agg->slavecount, 505 agg->merges[1] / agg->slavecount, 506 agg->ticks[0] / agg->slavecount, 507 agg->ticks[1] / agg->slavecount, 508 agg->time_in_queue / agg->slavecount, 509 agg->max_util.u.f); 510 } else { 511 log_info(";slaves;%u;%u;%u;%u;%u;%u;%u;%3.2f%%", 512 agg->ios[0] / agg->slavecount, 513 agg->ios[1] / agg->slavecount, 514 agg->merges[0] / agg->slavecount, 515 agg->merges[1] / agg->slavecount, 516 agg->ticks[0] / agg->slavecount, 517 agg->ticks[1] / agg->slavecount, 518 agg->time_in_queue / agg->slavecount, 519 agg->max_util.u.f); 520 } 521} 522 523static void aggregate_slaves_stats(struct disk_util *masterdu) 524{ 525 struct disk_util_agg *agg = &masterdu->agg; 526 struct disk_util_stat *dus; 527 struct flist_head *entry; 528 struct disk_util *slavedu; 529 double util; 530 531 flist_for_each(entry, &masterdu->slaves) { 532 slavedu = flist_entry(entry, struct disk_util, slavelist); 533 dus = &slavedu->dus; 534 agg->ios[0] += dus->s.ios[0]; 535 agg->ios[1] += dus->s.ios[1]; 536 agg->merges[0] += dus->s.merges[0]; 537 agg->merges[1] += dus->s.merges[1]; 538 agg->sectors[0] += dus->s.sectors[0]; 539 agg->sectors[1] += dus->s.sectors[1]; 540 agg->ticks[0] += dus->s.ticks[0]; 541 agg->ticks[1] += dus->s.ticks[1]; 542 agg->time_in_queue += dus->s.time_in_queue; 543 agg->slavecount++; 544 545 util = (double) (100 * dus->s.io_ticks / (double) slavedu->dus.s.msec); 546 /* System utilization is the utilization of the 547 * component with the highest utilization. 548 */ 549 if (util > agg->max_util.u.f) 550 agg->max_util.u.f = util; 551 552 } 553 554 if (agg->max_util.u.f > 100.0) 555 agg->max_util.u.f = 100.0; 556} 557 558void disk_util_prune_entries(void) 559{ 560 fio_mutex_down(disk_util_mutex); 561 562 while (!flist_empty(&disk_list)) { 563 struct disk_util *du; 564 565 du = flist_entry(disk_list.next, struct disk_util, list); 566 flist_del(&du->list); 567 disk_util_free(du); 568 } 569 570 last_majdev = last_mindev = -1; 571 fio_mutex_up(disk_util_mutex); 572 fio_mutex_remove(disk_util_mutex); 573} 574 575void print_disk_util(struct disk_util_stat *dus, struct disk_util_agg *agg, 576 int terse) 577{ 578 double util = 0; 579 580 if (dus->s.msec) 581 util = (double) 100 * dus->s.io_ticks / (double) dus->s.msec; 582 if (util > 100.0) 583 util = 100.0; 584 585 if (!terse) { 586 if (agg->slavecount) 587 log_info(" "); 588 589 log_info(" %s: ios=%u/%u, merge=%u/%u, ticks=%u/%u, " 590 "in_queue=%u, util=%3.2f%%", dus->name, 591 dus->s.ios[0], dus->s.ios[1], 592 dus->s.merges[0], dus->s.merges[1], 593 dus->s.ticks[0], dus->s.ticks[1], 594 dus->s.time_in_queue, util); 595 } else { 596 log_info(";%s;%u;%u;%u;%u;%u;%u;%u;%3.2f%%", 597 dus->name, dus->s.ios[0], 598 dus->s.ios[1], dus->s.merges[0], 599 dus->s.merges[1], dus->s.ticks[0], 600 dus->s.ticks[1], 601 dus->s.time_in_queue, util); 602 } 603 604 /* 605 * If the device has slaves, aggregate the stats for 606 * those slave devices also. 607 */ 608 show_agg_stats(agg, terse); 609 610 if (!terse) 611 log_info("\n"); 612} 613 614void json_array_add_disk_util(struct disk_util_stat *dus, 615 struct disk_util_agg *agg, struct json_array *array) 616{ 617 struct json_object *obj; 618 double util = 0; 619 620 if (dus->s.msec) 621 util = (double) 100 * dus->s.io_ticks / (double) dus->s.msec; 622 if (util > 100.0) 623 util = 100.0; 624 625 obj = json_create_object(); 626 json_array_add_value_object(array, obj); 627 628 json_object_add_value_string(obj, "name", dus->name); 629 json_object_add_value_int(obj, "read_ios", dus->s.ios[0]); 630 json_object_add_value_int(obj, "write_ios", dus->s.ios[1]); 631 json_object_add_value_int(obj, "read_merges", dus->s.merges[0]); 632 json_object_add_value_int(obj, "write_merges", dus->s.merges[1]); 633 json_object_add_value_int(obj, "read_ticks", dus->s.ticks[0]); 634 json_object_add_value_int(obj, "write_ticks", dus->s.ticks[1]); 635 json_object_add_value_int(obj, "in_queue", dus->s.time_in_queue); 636 json_object_add_value_float(obj, "util", util); 637 638 /* 639 * If the device has slaves, aggregate the stats for 640 * those slave devices also. 641 */ 642 if (!agg->slavecount) 643 return; 644 json_object_add_value_int(obj, "aggr_read_ios", 645 agg->ios[0] / agg->slavecount); 646 json_object_add_value_int(obj, "aggr_write_ios", 647 agg->ios[1] / agg->slavecount); 648 json_object_add_value_int(obj, "aggr_read_merges", 649 agg->merges[0] / agg->slavecount); 650 json_object_add_value_int(obj, "aggr_write_merge", 651 agg->merges[1] / agg->slavecount); 652 json_object_add_value_int(obj, "aggr_read_ticks", 653 agg->ticks[0] / agg->slavecount); 654 json_object_add_value_int(obj, "aggr_write_ticks", 655 agg->ticks[1] / agg->slavecount); 656 json_object_add_value_int(obj, "aggr_in_queue", 657 agg->time_in_queue / agg->slavecount); 658 json_object_add_value_float(obj, "aggr_util", agg->max_util.u.f); 659} 660 661static void json_object_add_disk_utils(struct json_object *obj, 662 struct flist_head *head) 663{ 664 struct json_array *array = json_create_array(); 665 struct flist_head *entry; 666 struct disk_util *du; 667 668 json_object_add_value_array(obj, "disk_util", array); 669 670 flist_for_each(entry, head) { 671 du = flist_entry(entry, struct disk_util, list); 672 673 aggregate_slaves_stats(du); 674 json_array_add_disk_util(&du->dus, &du->agg, array); 675 } 676} 677 678void show_disk_util(int terse, struct json_object *parent) 679{ 680 struct flist_head *entry; 681 struct disk_util *du; 682 683 fio_mutex_down(disk_util_mutex); 684 685 if (flist_empty(&disk_list)) { 686 fio_mutex_up(disk_util_mutex); 687 return; 688 } 689 690 if (output_format == FIO_OUTPUT_JSON) 691 assert(parent); 692 693 if (!terse && output_format != FIO_OUTPUT_JSON) 694 log_info("\nDisk stats (read/write):\n"); 695 696 if (output_format == FIO_OUTPUT_JSON) 697 json_object_add_disk_utils(parent, &disk_list); 698 else 699 flist_for_each(entry, &disk_list) { 700 du = flist_entry(entry, struct disk_util, list); 701 702 aggregate_slaves_stats(du); 703 print_disk_util(&du->dus, &du->agg, terse); 704 } 705 706 fio_mutex_up(disk_util_mutex); 707} 708 709void setup_disk_util(void) 710{ 711 disk_util_mutex = fio_mutex_init(FIO_MUTEX_UNLOCKED); 712} 713