diskutil.c revision 9f8f2064bcb196c10c9d3a2b64b951d796af22b5
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 10#include "fio.h" 11 12static int last_majdev, last_mindev; 13static struct itimerval itimer; 14 15static struct list_head disk_list = LIST_HEAD_INIT(disk_list); 16 17static int get_io_ticks(struct disk_util *du, struct disk_util_stat *dus) 18{ 19 unsigned in_flight; 20 char line[256]; 21 FILE *f; 22 char *p; 23 24 f = fopen(du->path, "r"); 25 if (!f) 26 return 1; 27 28 p = fgets(line, sizeof(line), f); 29 if (!p) { 30 fclose(f); 31 return 1; 32 } 33 34 if (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) != 11) { 35 fclose(f); 36 return 1; 37 } 38 39 fclose(f); 40 return 0; 41} 42 43static void update_io_tick_disk(struct disk_util *du) 44{ 45 struct disk_util_stat __dus, *dus, *ldus; 46 struct timeval t; 47 48 if (get_io_ticks(du, &__dus)) 49 return; 50 51 dus = &du->dus; 52 ldus = &du->last_dus; 53 54 dus->sectors[0] += (__dus.sectors[0] - ldus->sectors[0]); 55 dus->sectors[1] += (__dus.sectors[1] - ldus->sectors[1]); 56 dus->ios[0] += (__dus.ios[0] - ldus->ios[0]); 57 dus->ios[1] += (__dus.ios[1] - ldus->ios[1]); 58 dus->merges[0] += (__dus.merges[0] - ldus->merges[0]); 59 dus->merges[1] += (__dus.merges[1] - ldus->merges[1]); 60 dus->ticks[0] += (__dus.ticks[0] - ldus->ticks[0]); 61 dus->ticks[1] += (__dus.ticks[1] - ldus->ticks[1]); 62 dus->io_ticks += (__dus.io_ticks - ldus->io_ticks); 63 dus->time_in_queue += (__dus.time_in_queue - ldus->time_in_queue); 64 65 fio_gettime(&t, NULL); 66 du->msec += mtime_since(&du->time, &t); 67 memcpy(&du->time, &t, sizeof(t)); 68 memcpy(ldus, &__dus, sizeof(__dus)); 69} 70 71void update_io_ticks(void) 72{ 73 struct list_head *entry; 74 struct disk_util *du; 75 76 list_for_each(entry, &disk_list) { 77 du = list_entry(entry, struct disk_util, list); 78 update_io_tick_disk(du); 79 } 80} 81 82static int disk_util_exists(int major, int minor) 83{ 84 struct list_head *entry; 85 struct disk_util *du; 86 87 list_for_each(entry, &disk_list) { 88 du = list_entry(entry, struct disk_util, list); 89 90 if (major == du->major && minor == du->minor) 91 return 1; 92 } 93 94 return 0; 95} 96 97static void disk_util_add(int majdev, int mindev, char *path) 98{ 99 struct disk_util *du, *__du; 100 struct list_head *entry; 101 102 du = malloc(sizeof(*du)); 103 memset(du, 0, sizeof(*du)); 104 INIT_LIST_HEAD(&du->list); 105 sprintf(du->path, "%s/stat", path); 106 du->name = strdup(basename(path)); 107 du->major = majdev; 108 du->minor = mindev; 109 110 list_for_each(entry, &disk_list) { 111 __du = list_entry(entry, struct disk_util, list); 112 113 if (!strcmp(du->name, __du->name)) { 114 free(du->name); 115 free(du); 116 return; 117 } 118 } 119 120 fio_gettime(&du->time, NULL); 121 get_io_ticks(du, &du->last_dus); 122 123 list_add_tail(&du->list, &disk_list); 124} 125 126static int check_dev_match(int majdev, int mindev, char *path) 127{ 128 int major, minor; 129 char line[256], *p; 130 FILE *f; 131 132 f = fopen(path, "r"); 133 if (!f) { 134 perror("open path"); 135 return 1; 136 } 137 138 p = fgets(line, sizeof(line), f); 139 if (!p) { 140 fclose(f); 141 return 1; 142 } 143 144 if (sscanf(p, "%u:%u", &major, &minor) != 2) { 145 fclose(f); 146 return 1; 147 } 148 149 if (majdev == major && mindev == minor) { 150 fclose(f); 151 return 0; 152 } 153 154 fclose(f); 155 return 1; 156} 157 158static int find_block_dir(int majdev, int mindev, char *path) 159{ 160 struct dirent *dir; 161 struct stat st; 162 int found = 0; 163 DIR *D; 164 165 D = opendir(path); 166 if (!D) 167 return 0; 168 169 while ((dir = readdir(D)) != NULL) { 170 char full_path[256]; 171 172 if (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, "..")) 173 continue; 174 175 sprintf(full_path, "%s/%s", path, dir->d_name); 176 177 if (!strcmp(dir->d_name, "dev")) { 178 if (!check_dev_match(majdev, mindev, full_path)) { 179 found = 1; 180 break; 181 } 182 } 183 184 if (lstat(full_path, &st) == -1) { 185 perror("stat"); 186 break; 187 } 188 189 if (!S_ISDIR(st.st_mode) || S_ISLNK(st.st_mode)) 190 continue; 191 192 found = find_block_dir(majdev, mindev, full_path); 193 if (found) { 194 strcpy(path, full_path); 195 break; 196 } 197 } 198 199 closedir(D); 200 return found; 201} 202 203static void __init_disk_util(struct thread_data *td, struct fio_file *f) 204{ 205 struct stat st; 206 char foo[PATH_MAX], tmp[PATH_MAX]; 207 int mindev, majdev; 208 char *p; 209 210 if (!stat(f->file_name, &st)) { 211 if (S_ISBLK(st.st_mode)) { 212 majdev = major(st.st_rdev); 213 mindev = minor(st.st_rdev); 214 } else if (S_ISCHR(st.st_mode)) { 215 majdev = major(st.st_rdev); 216 mindev = minor(st.st_rdev); 217 fio_lookup_raw(st.st_rdev, &majdev, &mindev); 218 } else { 219 majdev = major(st.st_dev); 220 mindev = minor(st.st_dev); 221 } 222 } else { 223 /* 224 * must be a file, open "." in that path 225 */ 226 strncpy(foo, f->file_name, PATH_MAX - 1); 227 p = dirname(foo); 228 if (stat(p, &st)) { 229 perror("disk util stat"); 230 return; 231 } 232 233 majdev = major(st.st_dev); 234 mindev = minor(st.st_dev); 235 } 236 237 if (disk_util_exists(majdev, mindev)) 238 return; 239 240 /* 241 * for an fs without a device, we will repeatedly stat through 242 * sysfs which can take oodles of time for thousands of files. so 243 * cache the last lookup and compare with that before going through 244 * everything again. 245 */ 246 if (mindev == last_mindev && majdev == last_majdev) 247 return; 248 249 last_mindev = mindev; 250 last_majdev = majdev; 251 252 sprintf(foo, "/sys/block"); 253 if (!find_block_dir(majdev, mindev, foo)) 254 return; 255 256 /* 257 * If there's a ../queue/ directory there, we are inside a partition. 258 * Check if that is the case and jump back. For loop/md/dm etc we 259 * are already in the right spot. 260 */ 261 sprintf(tmp, "%s/../queue", foo); 262 if (!stat(tmp, &st)) { 263 p = dirname(foo); 264 sprintf(tmp, "%s/queue", p); 265 if (stat(tmp, &st)) { 266 log_err("unknown sysfs layout\n"); 267 return; 268 } 269 strncpy(tmp, p, PATH_MAX - 1); 270 sprintf(foo, "%s", tmp); 271 } 272 273 if (td->o.ioscheduler && !td->sysfs_root) 274 td->sysfs_root = strdup(foo); 275 276 disk_util_add(majdev, mindev, foo); 277} 278 279void init_disk_util(struct thread_data *td) 280{ 281 struct fio_file *f; 282 unsigned int i; 283 284 if (!td->o.do_disk_util || 285 (td->io_ops->flags & (FIO_DISKLESSIO | FIO_NODISKUTIL))) 286 return; 287 288 for_each_file(td, f, i) 289 __init_disk_util(td, f); 290} 291 292void disk_util_timer_arm(void) 293{ 294 itimer.it_value.tv_sec = 0; 295 itimer.it_value.tv_usec = DISK_UTIL_MSEC * 1000; 296 setitimer(ITIMER_REAL, &itimer, NULL); 297} 298 299void show_disk_util(void) 300{ 301 struct disk_util_stat *dus; 302 struct list_head *entry, *next; 303 struct disk_util *du; 304 double util; 305 306 log_info("\nDisk stats (read/write):\n"); 307 308 list_for_each(entry, &disk_list) { 309 du = list_entry(entry, struct disk_util, list); 310 dus = &du->dus; 311 312 util = (double) 100 * du->dus.io_ticks / (double) du->msec; 313 if (util > 100.0) 314 util = 100.0; 315 316 log_info(" %s: ios=%u/%u, merge=%u/%u, ticks=%u/%u, in_queue=%u, util=%3.2f%%\n", 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); 317 } 318 319 /* 320 * now free the list 321 */ 322 list_for_each_safe(entry, next, &disk_list) { 323 list_del(entry); 324 du = list_entry(entry, struct disk_util, list); 325 free(du->name); 326 free(du); 327 } 328} 329