diskutil.c

   1 #include <inttypes.h>
   2 #include <stdio.h>
   3 #include <string.h>
   4 #include <sys/types.h>
   5 #include <sys/stat.h>
   6 #include <sys/sysmacros.h>
   7 #include <dirent.h>
   8 #include <libgen.h>
   9 #ifdef CONFIG_VALGRIND_DEV
  10 #include <valgrind/drd.h>
  11 #else
  12 #define DRD_IGNORE_VAR(x) do { } while (0)
  13 #endif
  14
  15 #include "fio.h"
  16 #include "smalloc.h"
  17 #include "diskutil.h"
  18 #include "helper_thread.h"
  19
  20 static int last_majdev, last_mindev;
  21 static struct disk_util *last_du;
  22
  23 static struct fio_sem *disk_util_sem;
  24
  25 static struct disk_util *__init_per_file_disk_util(struct thread_data *td,
  26                 int majdev, int mindev, char *path);
  27
  28 static void disk_util_free(struct disk_util *du)
  29 {
  30         if (du == last_du)
  31                 last_du = NULL;
  32
  33         while (!flist_empty(&du->slaves)) {
  34                 struct disk_util *slave;
  35
  36                 slave = flist_first_entry(&du->slaves, struct disk_util, slavelist);
  37                 flist_del(&slave->slavelist);
  38                 slave->users--;
  39         }
  40
  41         fio_sem_remove(du->lock);
  42         free(du->sysfs_root);
  43         sfree(du);
  44 }
  45
  46 static int get_io_ticks(struct disk_util *du, struct disk_util_stat *dus)
  47 {
  48         char line[256];
  49         FILE *f;
  50         char *p;
  51         int ret;
  52
  53         dprint(FD_DISKUTIL, "open stat file: %s\n", du->path);
  54
  55         f = fopen(du->path, "r");
  56         if (!f)
  57                 return 1;
  58
  59         p = fgets(line, sizeof(line), f);
  60         if (!p) {
  61                 fclose(f);
  62                 return 1;
  63         }
  64
  65         dprint(FD_DISKUTIL, "%s: %s", du->path, p);
  66
  67         ret = sscanf(p, "%"SCNu64" %"SCNu64" %"SCNu64" %"SCNu64" "
  68                      "%"SCNu64" %"SCNu64" %"SCNu64" %"SCNu64" "
  69                      "%*u %"SCNu64" %"SCNu64"\n",
  70                      &dus->s.ios[0], &dus->s.merges[0], &dus->s.sectors[0],
  71                      &dus->s.ticks[0],
  72                      &dus->s.ios[1], &dus->s.merges[1], &dus->s.sectors[1],
  73                      &dus->s.ticks[1],
  74                      &dus->s.io_ticks, &dus->s.time_in_queue);
  75         fclose(f);
  76         dprint(FD_DISKUTIL, "%s: stat read ok? %d\n", du->path, ret == 10);
  77         return ret != 10;
  78 }
  79
  80 static uint64_t safe_32bit_diff(uint64_t nval, uint64_t oval)
  81 {
  82         /* Linux kernel prints some of the stat fields as 32-bit integers. It is
  83          * possible that the value overflows, but since fio uses unsigned 64-bit
  84          * arithmetic in update_io_tick_disk(), it instead results in a huge
  85          * bogus value being added to the respective accumulating field. Just
  86          * in case Linux starts reporting these metrics as 64-bit values in the
  87          * future, check that overflow actually happens around the 32-bit
  88          * unsigned boundary; assume overflow only happens once between
  89          * successive polls.
  90          */
  91         if (oval <= nval || oval >= (1ull << 32))
  92                 return nval - oval;
  93         else
  94                 return (1ull << 32) + nval - oval;
  95 }
  96
  97 static void update_io_tick_disk(struct disk_util *du)
  98 {
  99         struct disk_util_stat __dus, *dus, *ldus;
 100         struct timespec t;
 101
 102         if (!du->users)
 103                 return;
 104         if (get_io_ticks(du, &__dus))
 105                 return;
 106
 107         dus = &du->dus;
 108         ldus = &du->last_dus;
 109
 110         dus->s.sectors[0] += (__dus.s.sectors[0] - ldus->s.sectors[0]);
 111         dus->s.sectors[1] += (__dus.s.sectors[1] - ldus->s.sectors[1]);
 112         dus->s.ios[0] += (__dus.s.ios[0] - ldus->s.ios[0]);
 113         dus->s.ios[1] += (__dus.s.ios[1] - ldus->s.ios[1]);
 114         dus->s.merges[0] += (__dus.s.merges[0] - ldus->s.merges[0]);
 115         dus->s.merges[1] += (__dus.s.merges[1] - ldus->s.merges[1]);
 116         dus->s.ticks[0] += safe_32bit_diff(__dus.s.ticks[0], ldus->s.ticks[0]);
 117         dus->s.ticks[1] += safe_32bit_diff(__dus.s.ticks[1], ldus->s.ticks[1]);
 118         dus->s.io_ticks += safe_32bit_diff(__dus.s.io_ticks, ldus->s.io_ticks);
 119         dus->s.time_in_queue +=
 120                         safe_32bit_diff(__dus.s.time_in_queue, ldus->s.time_in_queue);
 121
 122         fio_gettime(&t, NULL);
 123         dus->s.msec += mtime_since(&du->time, &t);
 124         du->time = t;
 125         ldus->s = __dus.s;
 126 }
 127
 128 int update_io_ticks(void)
 129 {
 130         struct flist_head *entry;
 131         struct disk_util *du;
 132         int ret = 0;
 133
 134         dprint(FD_DISKUTIL, "update io ticks\n");
 135
 136         fio_sem_down(disk_util_sem);
 137
 138         if (!helper_should_exit()) {
 139                 flist_for_each(entry, &disk_list) {
 140                         du = flist_entry(entry, struct disk_util, list);
 141                         update_io_tick_disk(du);
 142                 }
 143         } else
 144                 ret = 1;
 145
 146         fio_sem_up(disk_util_sem);
 147         return ret;
 148 }
 149
 150 static struct disk_util *disk_util_exists(int major, int minor)
 151 {
 152         struct flist_head *entry;
 153         struct disk_util *du;
 154
 155         fio_sem_down(disk_util_sem);
 156
 157         flist_for_each(entry, &disk_list) {
 158                 du = flist_entry(entry, struct disk_util, list);
 159
 160                 if (major == du->major && minor == du->minor) {
 161                         fio_sem_up(disk_util_sem);
 162                         return du;
 163                 }
 164         }
 165
 166         fio_sem_up(disk_util_sem);
 167         return NULL;
 168 }
 169
 170 static int get_device_numbers(char *file_name, int *maj, int *min)
 171 {
 172         struct stat st;
 173         int majdev, mindev;
 174         char tempname[PATH_MAX], *p;
 175
 176         if (!lstat(file_name, &st)) {
 177                 if (S_ISBLK(st.st_mode)) {
 178                         majdev = major(st.st_rdev);
 179                         mindev = minor(st.st_rdev);
 180                 } else if (S_ISCHR(st.st_mode) ||
 181                            S_ISFIFO(st.st_mode)) {
 182                         return -1;
 183                 } else {
 184                         majdev = major(st.st_dev);
 185                         mindev = minor(st.st_dev);
 186                 }
 187         } else {
 188                 /*
 189                  * must be a file, open "." in that path
 190                  */
 191                 snprintf(tempname, FIO_ARRAY_SIZE(tempname), "%s", file_name);
 192                 p = dirname(tempname);
 193                 if (stat(p, &st)) {
 194                         perror("disk util stat");
 195                         return -1;
 196                 }
 197
 198                 majdev = major(st.st_dev);
 199                 mindev = minor(st.st_dev);
 200         }
 201
 202         *min = mindev;
 203         *maj = majdev;
 204
 205         return 0;
 206 }
 207
 208 static int read_block_dev_entry(char *path, int *maj, int *min)
 209 {
 210         char line[256], *p;
 211         FILE *f;
 212
 213         f = fopen(path, "r");
 214         if (!f) {
 215                 perror("open path");
 216                 return 1;
 217         }
 218
 219         p = fgets(line, sizeof(line), f);
 220         fclose(f);
 221
 222         if (!p)
 223                 return 1;
 224
 225         if (sscanf(p, "%u:%u", maj, min) != 2)
 226                 return 1;
 227
 228         return 0;
 229 }
 230
 231 static void find_add_disk_slaves(struct thread_data *td, char *path,
 232                                  struct disk_util *masterdu)
 233 {
 234         DIR *dirhandle = NULL;
 235         struct dirent *dirent = NULL;
 236         char slavesdir[PATH_MAX], temppath[PATH_MAX], slavepath[PATH_MAX];
 237         struct disk_util *slavedu = NULL;
 238         int majdev, mindev;
 239         ssize_t linklen;
 240
 241         sprintf(slavesdir, "%s/%s", path, "slaves");
 242         dirhandle = opendir(slavesdir);
 243         if (!dirhandle)
 244                 return;
 245
 246         while ((dirent = readdir(dirhandle)) != NULL) {
 247                 if (!strcmp(dirent->d_name, ".") ||
 248                     !strcmp(dirent->d_name, ".."))
 249                         continue;
 250
 251                 nowarn_snprintf(temppath, sizeof(temppath), "%s/%s", slavesdir,
 252                                 dirent->d_name);
 253                 /* Can we always assume that the slaves device entries
 254                  * are links to the real directories for the slave
 255                  * devices?
 256                  */
 257                 linklen = readlink(temppath, slavepath, PATH_MAX - 1);
 258                 if (linklen < 0) {
 259                         perror("readlink() for slave device.");
 260                         closedir(dirhandle);
 261                         return;
 262                 }
 263                 slavepath[linklen] = '\0';
 264
 265                 nowarn_snprintf(temppath, sizeof(temppath), "%s/%s/dev",
 266                                 slavesdir, slavepath);
 267                 if (access(temppath, F_OK) != 0)
 268                         nowarn_snprintf(temppath, sizeof(temppath),
 269                                         "%s/%s/device/dev", slavesdir,
 270                                         slavepath);
 271                 if (read_block_dev_entry(temppath, &majdev, &mindev)) {
 272                         perror("Error getting slave device numbers");
 273                         closedir(dirhandle);
 274                         return;
 275                 }
 276
 277                 /*
 278                  * See if this maj,min already exists
 279                  */
 280                 slavedu = disk_util_exists(majdev, mindev);
 281                 if (slavedu)
 282                         continue;
 283
 284                 nowarn_snprintf(temppath, sizeof(temppath), "%s/%s", slavesdir,
 285                                 slavepath);
 286                 __init_per_file_disk_util(td, majdev, mindev, temppath);
 287                 slavedu = disk_util_exists(majdev, mindev);
 288
 289                 /* Should probably use an assert here. slavedu should
 290                  * always be present at this point. */
 291                 if (slavedu) {
 292                         slavedu->users++;
 293                         flist_add_tail(&slavedu->slavelist, &masterdu->slaves);
 294                 }
 295         }
 296
 297         closedir(dirhandle);
 298 }
 299
 300 static struct disk_util *disk_util_add(struct thread_data *td, int majdev,
 301                                        int mindev, char *path)
 302 {
 303         struct disk_util *du, *__du;
 304         struct flist_head *entry;
 305         int l;
 306
 307         dprint(FD_DISKUTIL, "add maj/min %d/%d: %s\n", majdev, mindev, path);
 308
 309         du = smalloc(sizeof(*du));
 310         if (!du)
 311                 return NULL;
 312
 313         DRD_IGNORE_VAR(du->users);
 314         memset(du, 0, sizeof(*du));
 315         INIT_FLIST_HEAD(&du->list);
 316         l = snprintf(du->path, sizeof(du->path), "%s/stat", path);
 317         if (l < 0 || l >= sizeof(du->path)) {
 318                 log_err("constructed path \"%.100s[...]/stat\" larger than buffer (%zu bytes)\n",
 319                         path, sizeof(du->path) - 1);
 320                 sfree(du);
 321                 return NULL;
 322         }
 323         snprintf((char *) du->dus.name, FIO_ARRAY_SIZE(du->dus.name), "%s",
 324                  basename(path));
 325         du->sysfs_root = strdup(path);
 326         du->major = majdev;
 327         du->minor = mindev;
 328         INIT_FLIST_HEAD(&du->slavelist);
 329         INIT_FLIST_HEAD(&du->slaves);
 330         du->lock = fio_sem_init(FIO_SEM_UNLOCKED);
 331         du->users = 0;
 332
 333         fio_sem_down(disk_util_sem);
 334
 335         flist_for_each(entry, &disk_list) {
 336                 __du = flist_entry(entry, struct disk_util, list);
 337
 338                 dprint(FD_DISKUTIL, "found %s in list\n", __du->dus.name);
 339
 340                 if (!strcmp((char *) du->dus.name, (char *) __du->dus.name)) {
 341                         disk_util_free(du);
 342                         fio_sem_up(disk_util_sem);
 343                         return __du;
 344                 }
 345         }
 346
 347         dprint(FD_DISKUTIL, "add %s to list\n", du->dus.name);
 348
 349         fio_gettime(&du->time, NULL);
 350         get_io_ticks(du, &du->last_dus);
 351
 352         flist_add_tail(&du->list, &disk_list);
 353         fio_sem_up(disk_util_sem);
 354
 355         find_add_disk_slaves(td, path, du);
 356         return du;
 357 }
 358
 359 static int check_dev_match(int majdev, int mindev, char *path)
 360 {
 361         int major, minor;
 362
 363         if (read_block_dev_entry(path, &major, &minor))
 364                 return 1;
 365
 366         if (majdev == major && mindev == minor)
 367                 return 0;
 368
 369         return 1;
 370 }
 371
 372 static int find_block_dir(int majdev, int mindev, char *path, int link_ok)
 373 {
 374         struct dirent *dir;
 375         struct stat st;
 376         int found = 0;
 377         DIR *D;
 378
 379         D = opendir(path);
 380         if (!D)
 381                 return 0;
 382
 383         while ((dir = readdir(D)) != NULL) {
 384                 char full_path[257];
 385
 386                 if (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, ".."))
 387                         continue;
 388
 389                 sprintf(full_path, "%s/%s", path, dir->d_name);
 390
 391                 if (!strcmp(dir->d_name, "dev")) {
 392                         if (!check_dev_match(majdev, mindev, full_path)) {
 393                                 found = 1;
 394                                 break;
 395                         }
 396                 }
 397
 398                 if (link_ok) {
 399                         if (stat(full_path, &st) == -1) {
 400                                 perror("stat");
 401                                 break;
 402                         }
 403                 } else {
 404                         if (lstat(full_path, &st) == -1) {
 405                                 perror("stat");
 406                                 break;
 407                         }
 408                 }
 409
 410                 if (!S_ISDIR(st.st_mode) || S_ISLNK(st.st_mode))
 411                         continue;
 412
 413                 found = find_block_dir(majdev, mindev, full_path, 0);
 414                 if (found) {
 415                         strcpy(path, full_path);
 416                         break;
 417                 }
 418         }
 419
 420         closedir(D);
 421         return found;
 422 }
 423
 424 static struct disk_util *__init_per_file_disk_util(struct thread_data *td,
 425                                                    int majdev, int mindev,
 426                                                    char *path)
 427 {
 428         struct stat st;
 429         char tmp[PATH_MAX];
 430         char *p;
 431
 432         /*
 433          * If there's a ../queue/ directory there, we are inside a partition.
 434          * Check if that is the case and jump back. For loop/md/dm etc we
 435          * are already in the right spot.
 436          */
 437         sprintf(tmp, "%s/../queue", path);
 438         if (!stat(tmp, &st)) {
 439                 p = dirname(path);
 440                 sprintf(tmp, "%s/queue", p);
 441                 if (stat(tmp, &st)) {
 442                         log_err("unknown sysfs layout\n");
 443                         return NULL;
 444                 }
 445                 snprintf(tmp, FIO_ARRAY_SIZE(tmp), "%s", p);
 446                 sprintf(path, "%s", tmp);
 447         }
 448
 449         return disk_util_add(td, majdev, mindev, path);
 450 }
 451
 452 static struct disk_util *init_per_file_disk_util(struct thread_data *td,
 453                                                  char *filename)
 454 {
 455
 456         char foo[PATH_MAX];
 457         struct disk_util *du;
 458         int mindev, majdev;
 459
 460         if (get_device_numbers(filename, &majdev, &mindev))
 461                 return NULL;
 462
 463         dprint(FD_DISKUTIL, "%s belongs to maj/min %d/%d\n", filename, majdev,
 464                         mindev);
 465
 466         du = disk_util_exists(majdev, mindev);
 467         if (du)
 468                 return du;
 469
 470         /*
 471          * for an fs without a device, we will repeatedly stat through
 472          * sysfs which can take oodles of time for thousands of files. so
 473          * cache the last lookup and compare with that before going through
 474          * everything again.
 475          */
 476         if (mindev == last_mindev && majdev == last_majdev)
 477                 return last_du;
 478
 479         last_mindev = mindev;
 480         last_majdev = majdev;
 481
 482         sprintf(foo, "/sys/block");
 483         if (!find_block_dir(majdev, mindev, foo, 1))
 484                 return NULL;
 485
 486         return __init_per_file_disk_util(td, majdev, mindev, foo);
 487 }
 488
 489 static struct disk_util *__init_disk_util(struct thread_data *td,
 490                                           struct fio_file *f)
 491 {
 492         return init_per_file_disk_util(td, f->file_name);
 493 }
 494
 495 void init_disk_util(struct thread_data *td)
 496 {
 497         struct fio_file *f;
 498         unsigned int i;
 499
 500         if (!td->o.do_disk_util ||
 501             td_ioengine_flagged(td, FIO_DISKLESSIO | FIO_NODISKUTIL))
 502                 return;
 503
 504         for_each_file(td, f, i)
 505                 f->du = __init_disk_util(td, f);
 506 }
 507
 508 void disk_util_prune_entries(void)
 509 {
 510         fio_sem_down(disk_util_sem);
 511
 512         while (!flist_empty(&disk_list)) {
 513                 struct disk_util *du;
 514
 515                 du = flist_first_entry(&disk_list, struct disk_util, list);
 516                 flist_del(&du->list);
 517                 disk_util_free(du);
 518         }
 519
 520         last_majdev = last_mindev = -1;
 521         fio_sem_up(disk_util_sem);
 522         fio_sem_remove(disk_util_sem);
 523 }
 524
 525 void setup_disk_util(void)
 526 {
 527         disk_util_sem = fio_sem_init(FIO_SEM_UNLOCKED);
 528 }