1 /************************************************************************** 2 * 3 * Copyright (C) 2016 Steven Toth <stoth (at) kernellabs.com> 4 * Copyright (C) 2016 Zodiac Inflight Innovations 5 * All Rights Reserved. 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the 9 * "Software"), to deal in the Software without restriction, including 10 * without limitation the rights to use, copy, modify, merge, publish, 11 * distribute, sub license, and/or sell copies of the Software, and to 12 * permit persons to whom the Software is furnished to do so, subject to 13 * the following conditions: 14 * 15 * The above copyright notice and this permission notice (including the 16 * next paragraph) shall be included in all copies or substantial portions 17 * of the Software. 18 * 19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 21 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. 22 * IN NO EVENT SHALL THE AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR 23 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 24 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 25 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 26 * 27 **************************************************************************/ 28 29 #if HAVE_GALLIUM_EXTRA_HUD 30 31 /* Purpose: Reading /sys/block/<*>/stat MB/s read/write throughput per second, 32 * displaying on the HUD. 33 */ 34 35 #include "hud/hud_private.h" 36 #include "util/list.h" 37 #include "os/os_time.h" 38 #include "os/os_thread.h" 39 #include "util/u_memory.h" 40 #include <stdio.h> 41 #include <unistd.h> 42 #include <dirent.h> 43 #include <stdlib.h> 44 #include <unistd.h> 45 #include <inttypes.h> 46 #include <sys/types.h> 47 #include <sys/stat.h> 48 #include <unistd.h> 49 50 struct stat_s 51 { 52 /* Read */ 53 uint64_t r_ios; 54 uint64_t r_merges; 55 uint64_t r_sectors; 56 uint64_t r_ticks; 57 /* Write */ 58 uint64_t w_ios; 59 uint64_t w_merges; 60 uint64_t w_sectors; 61 uint64_t w_ticks; 62 /* Misc */ 63 uint64_t in_flight; 64 uint64_t io_ticks; 65 uint64_t time_in_queue; 66 }; 67 68 struct diskstat_info 69 { 70 struct list_head list; 71 int mode; /* DISKSTAT_RD, DISKSTAT_WR */ 72 char name[64]; /* EG. sda5 */ 73 74 char sysfs_filename[128]; 75 uint64_t last_time; 76 struct stat_s last_stat; 77 }; 78 79 /* TODO: We don't handle dynamic block device / partition 80 * arrival or removal. 81 * Static globals specific to this HUD category. 82 */ 83 static int gdiskstat_count = 0; 84 static struct list_head gdiskstat_list; 85 pipe_static_mutex(gdiskstat_mutex); 86 87 static struct diskstat_info * 88 find_dsi_by_name(const char *n, int mode) 89 { 90 list_for_each_entry(struct diskstat_info, dsi, &gdiskstat_list, list) { 91 if (dsi->mode != mode) 92 continue; 93 if (strcasecmp(dsi->name, n) == 0) 94 return dsi; 95 } 96 return 0; 97 } 98 99 static int 100 get_file_values(const char *fn, struct stat_s *s) 101 { 102 int ret = 0; 103 FILE *fh = fopen(fn, "r"); 104 if (!fh) 105 return -1; 106 107 ret = fscanf(fh, 108 "%" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 109 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 "", 110 &s->r_ios, &s->r_merges, &s->r_sectors, &s->r_ticks, &s->w_ios, 111 &s->w_merges, &s->w_sectors, &s->w_ticks, &s->in_flight, &s->io_ticks, 112 &s->time_in_queue); 113 114 fclose(fh); 115 116 return ret; 117 } 118 119 static void 120 query_dsi_load(struct hud_graph *gr) 121 { 122 /* The framework calls us periodically, compensate for the 123 * calling interval accordingly when reporting per second. 124 */ 125 struct diskstat_info *dsi = gr->query_data; 126 uint64_t now = os_time_get(); 127 128 if (dsi->last_time) { 129 if (dsi->last_time + gr->pane->period <= now) { 130 struct stat_s stat; 131 if (get_file_values(dsi->sysfs_filename, &stat) < 0) 132 return; 133 float val = 0; 134 135 switch (dsi->mode) { 136 case DISKSTAT_RD: 137 val = 138 ((stat.r_sectors - 139 dsi->last_stat.r_sectors) * 512) / 140 (((float) gr->pane->period / 1000) / 1000); 141 break; 142 case DISKSTAT_WR: 143 val = 144 ((stat.w_sectors - 145 dsi->last_stat.w_sectors) * 512) / 146 (((float) gr->pane->period / 1000) / 1000); 147 break; 148 } 149 150 hud_graph_add_value(gr, (uint64_t) val); 151 dsi->last_stat = stat; 152 dsi->last_time = now; 153 } 154 } 155 else { 156 /* initialize */ 157 switch (dsi->mode) { 158 case DISKSTAT_RD: 159 case DISKSTAT_WR: 160 get_file_values(dsi->sysfs_filename, &dsi->last_stat); 161 break; 162 } 163 dsi->last_time = now; 164 } 165 } 166 167 /** 168 * Create and initialize a new object for a specific block I/O device. 169 * \param pane parent context. 170 * \param dev_name logical block device name, EG. sda5. 171 * \param mode query read or write (DISKSTAT_RD/DISKSTAT_WR) statistics. 172 */ 173 void 174 hud_diskstat_graph_install(struct hud_pane *pane, const char *dev_name, 175 unsigned int mode) 176 { 177 struct hud_graph *gr; 178 struct diskstat_info *dsi; 179 180 int num_devs = hud_get_num_disks(0); 181 if (num_devs <= 0) 182 return; 183 184 dsi = find_dsi_by_name(dev_name, mode); 185 if (!dsi) 186 return; 187 188 gr = CALLOC_STRUCT(hud_graph); 189 if (!gr) 190 return; 191 192 dsi->mode = mode; 193 if (dsi->mode == DISKSTAT_RD) { 194 snprintf(gr->name, sizeof(gr->name), "%s-Read-MB/s", dsi->name); 195 } 196 else if (dsi->mode == DISKSTAT_WR) { 197 snprintf(gr->name, sizeof(gr->name), "%s-Write-MB/s", dsi->name); 198 } 199 else 200 return; 201 202 gr->query_data = dsi; 203 gr->query_new_value = query_dsi_load; 204 205 hud_pane_add_graph(pane, gr); 206 hud_pane_set_max_value(pane, 100); 207 } 208 209 static void 210 add_object_part(const char *basename, const char *name, int objmode) 211 { 212 struct diskstat_info *dsi = CALLOC_STRUCT(diskstat_info); 213 214 strcpy(dsi->name, name); 215 snprintf(dsi->sysfs_filename, sizeof(dsi->sysfs_filename), "%s/%s/stat", 216 basename, name); 217 dsi->mode = objmode; 218 list_addtail(&dsi->list, &gdiskstat_list); 219 gdiskstat_count++; 220 } 221 222 static void 223 add_object(const char *basename, const char *name, int objmode) 224 { 225 struct diskstat_info *dsi = CALLOC_STRUCT(diskstat_info); 226 227 strcpy(dsi->name, name); 228 snprintf(dsi->sysfs_filename, sizeof(dsi->sysfs_filename), "%s/stat", 229 basename); 230 dsi->mode = objmode; 231 list_addtail(&dsi->list, &gdiskstat_list); 232 gdiskstat_count++; 233 } 234 235 /** 236 * Initialize internal object arrays and display block I/O HUD help. 237 * \param displayhelp true if the list of detected devices should be 238 displayed on the console. 239 * \return number of detected block I/O devices. 240 */ 241 int 242 hud_get_num_disks(bool displayhelp) 243 { 244 struct dirent *dp; 245 struct stat stat_buf; 246 char name[64]; 247 248 /* Return the number of block devices and partitions. */ 249 pipe_mutex_lock(gdiskstat_mutex); 250 if (gdiskstat_count) { 251 pipe_mutex_unlock(gdiskstat_mutex); 252 return gdiskstat_count; 253 } 254 255 /* Scan /sys/block, for every object type we support, create and 256 * persist an object to represent its different statistics. 257 */ 258 list_inithead(&gdiskstat_list); 259 DIR *dir = opendir("/sys/block/"); 260 if (!dir) { 261 pipe_mutex_unlock(gdiskstat_mutex); 262 return 0; 263 } 264 265 while ((dp = readdir(dir)) != NULL) { 266 267 /* Avoid 'lo' and '..' and '.' */ 268 if (strlen(dp->d_name) <= 2) 269 continue; 270 271 char basename[256]; 272 snprintf(basename, sizeof(basename), "/sys/block/%s", dp->d_name); 273 snprintf(name, sizeof(name), "%s/stat", basename); 274 if (stat(name, &stat_buf) < 0) 275 continue; 276 277 if (!S_ISREG(stat_buf.st_mode)) 278 continue; /* Not a regular file */ 279 280 /* Add a physical block device with R/W stats */ 281 add_object(basename, dp->d_name, DISKSTAT_RD); 282 add_object(basename, dp->d_name, DISKSTAT_WR); 283 284 /* Add any partitions */ 285 struct dirent *dpart; 286 DIR *pdir = opendir(basename); 287 if (!pdir) { 288 pipe_mutex_unlock(gdiskstat_mutex); 289 closedir(dir); 290 return 0; 291 } 292 293 while ((dpart = readdir(pdir)) != NULL) { 294 /* Avoid 'lo' and '..' and '.' */ 295 if (strlen(dpart->d_name) <= 2) 296 continue; 297 298 char p[64]; 299 snprintf(p, sizeof(p), "%s/%s/stat", basename, dpart->d_name); 300 if (stat(p, &stat_buf) < 0) 301 continue; 302 303 if (!S_ISREG(stat_buf.st_mode)) 304 continue; /* Not a regular file */ 305 306 /* Add a partition with R/W stats */ 307 add_object_part(basename, dpart->d_name, DISKSTAT_RD); 308 add_object_part(basename, dpart->d_name, DISKSTAT_WR); 309 } 310 } 311 closedir(dir); 312 313 if (displayhelp) { 314 list_for_each_entry(struct diskstat_info, dsi, &gdiskstat_list, list) { 315 char line[32]; 316 snprintf(line, sizeof(line), " diskstat-%s-%s", 317 dsi->mode == DISKSTAT_RD ? "rd" : 318 dsi->mode == DISKSTAT_WR ? "wr" : "undefined", dsi->name); 319 320 puts(line); 321 } 322 } 323 pipe_mutex_unlock(gdiskstat_mutex); 324 325 return gdiskstat_count; 326 } 327 328 #endif /* HAVE_GALLIUM_EXTRA_HUD */ 329