X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=diskutil.c;h=7be4c022431e1a0b823332f233d0159f07876ba4;hp=ac2f006e08597913417d293dbd3a67181fb4c223;hb=d22e2fc8834280e5ee789e2a1e2b23ebbbeabb7e;hpb=f03f8e473b7c8a5c4ed2de0b99717cf75521bf69 diff --git a/diskutil.c b/diskutil.c index ac2f006e..7be4c022 100644 --- a/diskutil.c +++ b/diskutil.c @@ -1,20 +1,25 @@ #include #include -#include #include #include +#include #include #include -#include +#ifdef CONFIG_VALGRIND_DEV +#include +#else +#define DRD_IGNORE_VAR(x) do { } while (0) +#endif #include "fio.h" #include "smalloc.h" #include "diskutil.h" +#include "helper_thread.h" static int last_majdev, last_mindev; static struct disk_util *last_du; -static struct flist_head disk_list = FLIST_HEAD_INIT(disk_list); +static struct fio_sem *disk_util_sem; static struct disk_util *__init_per_file_disk_util(struct thread_data *td, int majdev, int mindev, char *path); @@ -24,14 +29,23 @@ static void disk_util_free(struct disk_util *du) if (du == last_du) last_du = NULL; - fio_mutex_remove(du->lock); - sfree(du->name); + while (!flist_empty(&du->slaves)) { + struct disk_util *slave; + + slave = flist_first_entry(&du->slaves, struct disk_util, slavelist); + flist_del(&slave->slavelist); + slave->users--; + } + + fio_sem_remove(du->lock); + free(du->sysfs_root); sfree(du); } static int get_io_ticks(struct disk_util *du, struct disk_util_stat *dus) { unsigned in_flight; + unsigned long long sectors[2]; char line[256]; FILE *f; char *p; @@ -51,58 +65,75 @@ static int get_io_ticks(struct disk_util *du, struct disk_util_stat *dus) dprint(FD_DISKUTIL, "%s: %s", du->path, p); - ret = sscanf(p, "%u %u %llu %u %u %u %llu %u %u %u %u\n", &dus->ios[0], - &dus->merges[0], &dus->sectors[0], - &dus->ticks[0], &dus->ios[1], - &dus->merges[1], &dus->sectors[1], - &dus->ticks[1], &in_flight, - &dus->io_ticks, &dus->time_in_queue); + ret = sscanf(p, "%llu %llu %llu %llu %llu %llu %llu %llu %u %llu %llu\n", + (unsigned long long *) &dus->s.ios[0], + (unsigned long long *) &dus->s.merges[0], + §ors[0], + (unsigned long long *) &dus->s.ticks[0], + (unsigned long long *) &dus->s.ios[1], + (unsigned long long *) &dus->s.merges[1], + §ors[1], + (unsigned long long *) &dus->s.ticks[1], + &in_flight, + (unsigned long long *) &dus->s.io_ticks, + (unsigned long long *) &dus->s.time_in_queue); fclose(f); dprint(FD_DISKUTIL, "%s: stat read ok? %d\n", du->path, ret == 1); + dus->s.sectors[0] = sectors[0]; + dus->s.sectors[1] = sectors[1]; return ret != 11; } static void update_io_tick_disk(struct disk_util *du) { struct disk_util_stat __dus, *dus, *ldus; - struct timeval t; + struct timespec t; - if (get_io_ticks(du, &__dus)) - return; if (!du->users) return; + if (get_io_ticks(du, &__dus)) + return; dus = &du->dus; ldus = &du->last_dus; - dus->sectors[0] += (__dus.sectors[0] - ldus->sectors[0]); - dus->sectors[1] += (__dus.sectors[1] - ldus->sectors[1]); - dus->ios[0] += (__dus.ios[0] - ldus->ios[0]); - dus->ios[1] += (__dus.ios[1] - ldus->ios[1]); - dus->merges[0] += (__dus.merges[0] - ldus->merges[0]); - dus->merges[1] += (__dus.merges[1] - ldus->merges[1]); - dus->ticks[0] += (__dus.ticks[0] - ldus->ticks[0]); - dus->ticks[1] += (__dus.ticks[1] - ldus->ticks[1]); - dus->io_ticks += (__dus.io_ticks - ldus->io_ticks); - dus->time_in_queue += (__dus.time_in_queue - ldus->time_in_queue); + dus->s.sectors[0] += (__dus.s.sectors[0] - ldus->s.sectors[0]); + dus->s.sectors[1] += (__dus.s.sectors[1] - ldus->s.sectors[1]); + dus->s.ios[0] += (__dus.s.ios[0] - ldus->s.ios[0]); + dus->s.ios[1] += (__dus.s.ios[1] - ldus->s.ios[1]); + dus->s.merges[0] += (__dus.s.merges[0] - ldus->s.merges[0]); + dus->s.merges[1] += (__dus.s.merges[1] - ldus->s.merges[1]); + dus->s.ticks[0] += (__dus.s.ticks[0] - ldus->s.ticks[0]); + dus->s.ticks[1] += (__dus.s.ticks[1] - ldus->s.ticks[1]); + dus->s.io_ticks += (__dus.s.io_ticks - ldus->s.io_ticks); + dus->s.time_in_queue += (__dus.s.time_in_queue - ldus->s.time_in_queue); fio_gettime(&t, NULL); - du->msec += mtime_since(&du->time, &t); + dus->s.msec += mtime_since(&du->time, &t); memcpy(&du->time, &t, sizeof(t)); - memcpy(ldus, &__dus, sizeof(__dus)); + memcpy(&ldus->s, &__dus.s, sizeof(__dus.s)); } -void update_io_ticks(void) +int update_io_ticks(void) { struct flist_head *entry; struct disk_util *du; + int ret = 0; dprint(FD_DISKUTIL, "update io ticks\n"); - flist_for_each(entry, &disk_list) { - du = flist_entry(entry, struct disk_util, list); - update_io_tick_disk(du); - } + fio_sem_down(disk_util_sem); + + if (!helper_should_exit()) { + flist_for_each(entry, &disk_list) { + du = flist_entry(entry, struct disk_util, list); + update_io_tick_disk(du); + } + } else + ret = 1; + + fio_sem_up(disk_util_sem); + return ret; } static struct disk_util *disk_util_exists(int major, int minor) @@ -110,13 +141,18 @@ static struct disk_util *disk_util_exists(int major, int minor) struct flist_head *entry; struct disk_util *du; + fio_sem_down(disk_util_sem); + flist_for_each(entry, &disk_list) { du = flist_entry(entry, struct disk_util, list); - if (major == du->major && minor == du->minor) + if (major == du->major && minor == du->minor) { + fio_sem_up(disk_util_sem); return du; + } } + fio_sem_up(disk_util_sem); return NULL; } @@ -145,6 +181,7 @@ static int get_device_numbers(char *file_name, int *maj, int *min) /* * must be a file, open "." in that path */ + tempname[PATH_MAX - 1] = '\0'; strncpy(tempname, file_name, PATH_MAX - 1); p = dirname(tempname); if (stat(p, &st)) { @@ -205,21 +242,29 @@ static void find_add_disk_slaves(struct thread_data *td, char *path, !strcmp(dirent->d_name, "..")) continue; - sprintf(temppath, "%s/%s", slavesdir, dirent->d_name); + nowarn_snprintf(temppath, sizeof(temppath), "%s/%s", slavesdir, + dirent->d_name); /* Can we always assume that the slaves device entries * are links to the real directories for the slave * devices? */ - linklen = readlink(temppath, slavepath, PATH_MAX - 0); - if (linklen < 0) { + linklen = readlink(temppath, slavepath, PATH_MAX - 1); + if (linklen < 0) { perror("readlink() for slave device."); + closedir(dirhandle); return; } slavepath[linklen] = '\0'; - sprintf(temppath, "%s/%s/dev", slavesdir, slavepath); + nowarn_snprintf(temppath, sizeof(temppath), "%s/%s/dev", + slavesdir, slavepath); + if (access(temppath, F_OK) != 0) + nowarn_snprintf(temppath, sizeof(temppath), + "%s/%s/device/dev", slavesdir, + slavepath); if (read_block_dev_entry(temppath, &majdev, &mindev)) { - perror("Error getting slave device numbers."); + perror("Error getting slave device numbers"); + closedir(dirhandle); return; } @@ -230,7 +275,8 @@ static void find_add_disk_slaves(struct thread_data *td, char *path, if (slavedu) continue; - sprintf(temppath, "%s/%s", slavesdir, slavepath); + nowarn_snprintf(temppath, sizeof(temppath), "%s/%s", slavesdir, + slavepath); __init_per_file_disk_util(td, majdev, mindev, temppath); slavedu = disk_util_exists(majdev, mindev); @@ -245,44 +291,60 @@ static void find_add_disk_slaves(struct thread_data *td, char *path, closedir(dirhandle); } -static struct disk_util *disk_util_add(struct thread_data * td, int majdev, +static struct disk_util *disk_util_add(struct thread_data *td, int majdev, int mindev, char *path) { struct disk_util *du, *__du; struct flist_head *entry; + int l; dprint(FD_DISKUTIL, "add maj/min %d/%d: %s\n", majdev, mindev, path); du = smalloc(sizeof(*du)); + if (!du) + return NULL; + + DRD_IGNORE_VAR(du->users); memset(du, 0, sizeof(*du)); INIT_FLIST_HEAD(&du->list); - sprintf(du->path, "%s/stat", path); - du->name = smalloc_strdup(basename(path)); - du->sysfs_root = path; + l = snprintf(du->path, sizeof(du->path), "%s/stat", path); + if (l < 0 || l >= sizeof(du->path)) { + log_err("constructed path \"%.100s[...]/stat\" larger than buffer (%zu bytes)\n", + path, sizeof(du->path) - 1); + sfree(du); + return NULL; + } + strncpy((char *) du->dus.name, basename(path), FIO_DU_NAME_SZ - 1); + du->sysfs_root = strdup(path); du->major = majdev; du->minor = mindev; INIT_FLIST_HEAD(&du->slavelist); INIT_FLIST_HEAD(&du->slaves); - du->lock = fio_mutex_init(1); + du->lock = fio_sem_init(FIO_SEM_UNLOCKED); du->users = 0; + fio_sem_down(disk_util_sem); + flist_for_each(entry, &disk_list) { __du = flist_entry(entry, struct disk_util, list); - dprint(FD_DISKUTIL, "found %s in list\n", __du->name); + dprint(FD_DISKUTIL, "found %s in list\n", __du->dus.name); - if (!strcmp(du->name, __du->name)) { + if (!strcmp((char *) du->dus.name, (char *) __du->dus.name)) { disk_util_free(du); + fio_sem_up(disk_util_sem); return __du; } } - dprint(FD_DISKUTIL, "add %s to list\n", du->name); + dprint(FD_DISKUTIL, "add %s to list\n", du->dus.name); fio_gettime(&du->time, NULL); get_io_ticks(du, &du->last_dus); flist_add_tail(&du->list, &disk_list); + fio_sem_up(disk_util_sem); + find_add_disk_slaves(td, path, du); return du; } @@ -312,7 +374,7 @@ static int find_block_dir(int majdev, int mindev, char *path, int link_ok) return 0; while ((dir = readdir(D)) != NULL) { - char full_path[256]; + char full_path[257]; if (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, "..")) continue; @@ -373,13 +435,11 @@ static struct disk_util *__init_per_file_disk_util(struct thread_data *td, log_err("unknown sysfs layout\n"); return NULL; } + tmp[PATH_MAX - 1] = '\0'; strncpy(tmp, p, PATH_MAX - 1); sprintf(path, "%s", tmp); } - if (td->o.ioscheduler && !td->sysfs_root) - td->sysfs_root = strdup(path); - return disk_util_add(td, majdev, mindev, path); } @@ -398,12 +458,8 @@ static struct disk_util *init_per_file_disk_util(struct thread_data *td, mindev); du = disk_util_exists(majdev, mindev); - if (du) { - if (td->o.ioscheduler && !td->sysfs_root) - td->sysfs_root = strdup(du->sysfs_root); - + if (du) return du; - } /* * for an fs without a device, we will repeatedly stat through @@ -436,116 +492,248 @@ void init_disk_util(struct thread_data *td) unsigned int i; if (!td->o.do_disk_util || - (td->io_ops->flags & (FIO_DISKLESSIO | FIO_NODISKUTIL))) + td_ioengine_flagged(td, FIO_DISKLESSIO | FIO_NODISKUTIL)) return; for_each_file(td, f, i) f->du = __init_disk_util(td, f); } +static void show_agg_stats(struct disk_util_agg *agg, int terse, + struct buf_output *out) +{ + if (!agg->slavecount) + return; + + if (!terse) { + log_buf(out, ", aggrios=%llu/%llu, aggrmerge=%llu/%llu, " + "aggrticks=%llu/%llu, aggrin_queue=%llu, " + "aggrutil=%3.2f%%", + (unsigned long long) agg->ios[0] / agg->slavecount, + (unsigned long long) agg->ios[1] / agg->slavecount, + (unsigned long long) agg->merges[0] / agg->slavecount, + (unsigned long long) agg->merges[1] / agg->slavecount, + (unsigned long long) agg->ticks[0] / agg->slavecount, + (unsigned long long) agg->ticks[1] / agg->slavecount, + (unsigned long long) agg->time_in_queue / agg->slavecount, + agg->max_util.u.f); + } else { + log_buf(out, ";slaves;%llu;%llu;%llu;%llu;%llu;%llu;%llu;%3.2f%%", + (unsigned long long) agg->ios[0] / agg->slavecount, + (unsigned long long) agg->ios[1] / agg->slavecount, + (unsigned long long) agg->merges[0] / agg->slavecount, + (unsigned long long) agg->merges[1] / agg->slavecount, + (unsigned long long) agg->ticks[0] / agg->slavecount, + (unsigned long long) agg->ticks[1] / agg->slavecount, + (unsigned long long) agg->time_in_queue / agg->slavecount, + agg->max_util.u.f); + } +} + static void aggregate_slaves_stats(struct disk_util *masterdu) { + struct disk_util_agg *agg = &masterdu->agg; struct disk_util_stat *dus; struct flist_head *entry; struct disk_util *slavedu; - double util, max_util = 0; - int slavecount = 0; - - unsigned merges[2] = { 0, }; - unsigned ticks[2] = { 0, }; - unsigned time_in_queue = { 0, }; - unsigned long long sectors[2] = { 0, }; - unsigned ios[2] = { 0, }; + double util; flist_for_each(entry, &masterdu->slaves) { slavedu = flist_entry(entry, struct disk_util, slavelist); dus = &slavedu->dus; - ios[0] += dus->ios[0]; - ios[1] += dus->ios[1]; - merges[0] += dus->merges[0]; - merges[1] += dus->merges[1]; - sectors[0] += dus->sectors[0]; - sectors[1] += dus->sectors[1]; - ticks[0] += dus->ticks[0]; - ticks[1] += dus->ticks[1]; - time_in_queue += dus->time_in_queue; - ++slavecount; - - util = (double) (100 * dus->io_ticks / (double) slavedu->msec); + agg->ios[0] += dus->s.ios[0]; + agg->ios[1] += dus->s.ios[1]; + agg->merges[0] += dus->s.merges[0]; + agg->merges[1] += dus->s.merges[1]; + agg->sectors[0] += dus->s.sectors[0]; + agg->sectors[1] += dus->s.sectors[1]; + agg->ticks[0] += dus->s.ticks[0]; + agg->ticks[1] += dus->s.ticks[1]; + agg->time_in_queue += dus->s.time_in_queue; + agg->slavecount++; + + util = (double) (100 * dus->s.io_ticks / (double) slavedu->dus.s.msec); /* System utilization is the utilization of the * component with the highest utilization. */ - if (util > max_util) - max_util = util; + if (util > agg->max_util.u.f) + agg->max_util.u.f = util; } - if (max_util > 100.0) - max_util = 100.0; + if (agg->max_util.u.f > 100.0) + agg->max_util.u.f = 100.0; +} + +void disk_util_prune_entries(void) +{ + fio_sem_down(disk_util_sem); - log_info(", aggrios=%u/%u, aggrmerge=%u/%u, aggrticks=%u/%u," - " aggrin_queue=%u, aggrutil=%3.2f%%", - ios[0]/slavecount, ios[1]/slavecount, - merges[0]/slavecount, merges[1]/slavecount, - ticks[0]/slavecount, ticks[1]/slavecount, - time_in_queue/slavecount, max_util); + while (!flist_empty(&disk_list)) { + struct disk_util *du; + + du = flist_first_entry(&disk_list, struct disk_util, list); + flist_del(&du->list); + disk_util_free(du); + } + last_majdev = last_mindev = -1; + fio_sem_up(disk_util_sem); + fio_sem_remove(disk_util_sem); } -void show_disk_util(void) +void print_disk_util(struct disk_util_stat *dus, struct disk_util_agg *agg, + int terse, struct buf_output *out) { - struct disk_util_stat *dus; - struct flist_head *entry, *next; - struct disk_util *du; - double util; + double util = 0; + + if (dus->s.msec) + util = (double) 100 * dus->s.io_ticks / (double) dus->s.msec; + if (util > 100.0) + util = 100.0; + + if (!terse) { + if (agg->slavecount) + log_buf(out, " "); + + log_buf(out, " %s: ios=%llu/%llu, merge=%llu/%llu, " + "ticks=%llu/%llu, in_queue=%llu, util=%3.2f%%", + dus->name, + (unsigned long long) dus->s.ios[0], + (unsigned long long) dus->s.ios[1], + (unsigned long long) dus->s.merges[0], + (unsigned long long) dus->s.merges[1], + (unsigned long long) dus->s.ticks[0], + (unsigned long long) dus->s.ticks[1], + (unsigned long long) dus->s.time_in_queue, + util); + } else { + log_buf(out, ";%s;%llu;%llu;%llu;%llu;%llu;%llu;%llu;%3.2f%%", + dus->name, + (unsigned long long) dus->s.ios[0], + (unsigned long long) dus->s.ios[1], + (unsigned long long) dus->s.merges[0], + (unsigned long long) dus->s.merges[1], + (unsigned long long) dus->s.ticks[0], + (unsigned long long) dus->s.ticks[1], + (unsigned long long) dus->s.time_in_queue, + util); + } + + /* + * If the device has slaves, aggregate the stats for + * those slave devices also. + */ + show_agg_stats(agg, terse, out); + + if (!terse) + log_buf(out, "\n"); +} - if (flist_empty(&disk_list)) +void json_array_add_disk_util(struct disk_util_stat *dus, + struct disk_util_agg *agg, struct json_array *array) +{ + struct json_object *obj; + double util = 0; + + if (dus->s.msec) + util = (double) 100 * dus->s.io_ticks / (double) dus->s.msec; + if (util > 100.0) + util = 100.0; + + obj = json_create_object(); + json_array_add_value_object(array, obj); + + json_object_add_value_string(obj, "name", dus->name); + json_object_add_value_int(obj, "read_ios", dus->s.ios[0]); + json_object_add_value_int(obj, "write_ios", dus->s.ios[1]); + json_object_add_value_int(obj, "read_merges", dus->s.merges[0]); + json_object_add_value_int(obj, "write_merges", dus->s.merges[1]); + json_object_add_value_int(obj, "read_ticks", dus->s.ticks[0]); + json_object_add_value_int(obj, "write_ticks", dus->s.ticks[1]); + json_object_add_value_int(obj, "in_queue", dus->s.time_in_queue); + json_object_add_value_float(obj, "util", util); + + /* + * If the device has slaves, aggregate the stats for + * those slave devices also. + */ + if (!agg->slavecount) return; + json_object_add_value_int(obj, "aggr_read_ios", + agg->ios[0] / agg->slavecount); + json_object_add_value_int(obj, "aggr_write_ios", + agg->ios[1] / agg->slavecount); + json_object_add_value_int(obj, "aggr_read_merges", + agg->merges[0] / agg->slavecount); + json_object_add_value_int(obj, "aggr_write_merge", + agg->merges[1] / agg->slavecount); + json_object_add_value_int(obj, "aggr_read_ticks", + agg->ticks[0] / agg->slavecount); + json_object_add_value_int(obj, "aggr_write_ticks", + agg->ticks[1] / agg->slavecount); + json_object_add_value_int(obj, "aggr_in_queue", + agg->time_in_queue / agg->slavecount); + json_object_add_value_float(obj, "aggr_util", agg->max_util.u.f); +} - log_info("\nDisk stats (read/write):\n"); +static void json_object_add_disk_utils(struct json_object *obj, + struct flist_head *head) +{ + struct json_array *array = json_create_array(); + struct flist_head *entry; + struct disk_util *du; - flist_for_each(entry, &disk_list) { + json_object_add_value_array(obj, "disk_util", array); + + flist_for_each(entry, head) { du = flist_entry(entry, struct disk_util, list); - dus = &du->dus; - - util = (double) 100 * du->dus.io_ticks / (double) du->msec; - if (util > 100.0) - util = 100.0; - - /* If this node is the slave of a master device, as - * happens in case of software RAIDs, inward-indent - * this stats line to reflect a master-slave - * relationship. Because the master device gets added - * before the slave devices, we can safely assume that - * the master's stats line has been displayed in a - * previous iteration of this loop. - */ - if (!flist_empty(&du->slavelist)) - log_info(" "); - - log_info(" %s: ios=%u/%u, merge=%u/%u, ticks=%u/%u, " - "in_queue=%u, util=%3.2f%%", du->name, - dus->ios[0], dus->ios[1], - dus->merges[0], dus->merges[1], - dus->ticks[0], dus->ticks[1], - dus->time_in_queue, util); - - /* If the device has slaves, aggregate the stats for - * those slave devices also. - */ - if (!flist_empty(&du->slaves)) - aggregate_slaves_stats(du); - log_info("\n"); + aggregate_slaves_stats(du); + json_array_add_disk_util(&du->dus, &du->agg, array); } +} - /* - * now free the list - */ - flist_for_each_safe(entry, next, &disk_list) { - flist_del(entry); - du = flist_entry(entry, struct disk_util, list); - du->users--; - disk_util_free(du); +void show_disk_util(int terse, struct json_object *parent, + struct buf_output *out) +{ + struct flist_head *entry; + struct disk_util *du; + bool do_json; + + if (!is_running_backend()) + return; + + fio_sem_down(disk_util_sem); + + if (flist_empty(&disk_list)) { + fio_sem_up(disk_util_sem); + return; } + + if ((output_format & FIO_OUTPUT_JSON) && parent) + do_json = true; + else + do_json = false; + + if (!terse && !do_json) + log_buf(out, "\nDisk stats (read/write):\n"); + + if (do_json) + json_object_add_disk_utils(parent, &disk_list); + else if (output_format & ~(FIO_OUTPUT_JSON | FIO_OUTPUT_JSON_PLUS)) { + flist_for_each(entry, &disk_list) { + du = flist_entry(entry, struct disk_util, list); + + aggregate_slaves_stats(du); + print_disk_util(&du->dus, &du->agg, terse, out); + } + } + + fio_sem_up(disk_util_sem); +} + +void setup_disk_util(void) +{ + disk_util_sem = fio_sem_init(FIO_SEM_UNLOCKED); }