src/gallium/auxiliary/hud/hud_diskstat.c - third_party/mesa - Git at Google

 /**************************************************************************
  *
  * Copyright (C) 2016 Steven Toth <stoth@kernellabs.com>
  * Copyright (C) 2016 Zodiac Inflight Innovations
  * All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the
  * "Software"), to deal in the Software without restriction, including
  * without limitation the rights to use, copy, modify, merge, publish,
  * distribute, sub license, and/or sell copies of the Software, and to
  * permit persons to whom the Software is furnished to do so, subject to
  * the following conditions:
  *
  * The above copyright notice and this permission notice (including the
  * next paragraph) shall be included in all copies or substantial portions
  * of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  * IN NO EVENT SHALL THE AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR
  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  *
  **************************************************************************/

 #ifdef HAVE_GALLIUM_EXTRA_HUD

 /* Purpose: Reading /sys/block/<*>/stat MB/s read/write throughput per second,
  * displaying on the HUD.
  */

 #include "hud/hud_private.h"
 #include "util/list.h"
 #include "util/os_time.h"
 #include "os/os_thread.h"
 #include "util/u_memory.h"
 #include "util/u_string.h"
 #include <stdio.h>
 #include <unistd.h>
 #include <dirent.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <inttypes.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>

 struct stat_s
 {
    /* Read */
    uint64_t r_ios;
    uint64_t r_merges;
    uint64_t r_sectors;
    uint64_t r_ticks;
    /* Write */
    uint64_t w_ios;
    uint64_t w_merges;
    uint64_t w_sectors;
    uint64_t w_ticks;
    /* Misc */
    uint64_t in_flight;
    uint64_t io_ticks;
    uint64_t time_in_queue;
 };

 struct diskstat_info
 {
    struct list_head list;
    int mode; /* DISKSTAT_RD, DISKSTAT_WR */
    char name[64]; /* EG. sda5 */

    char sysfs_filename[128];
    uint64_t last_time;
    struct stat_s last_stat;
 };

 /* TODO: We don't handle dynamic block device / partition
  * arrival or removal.
  * Static globals specific to this HUD category.
  */
 static int gdiskstat_count = 0;
 static struct list_head gdiskstat_list;
 static mtx_t gdiskstat_mutex = _MTX_INITIALIZER_NP;

 static struct diskstat_info *
 find_dsi_by_name(const char *n, int mode)
 {
    list_for_each_entry(struct diskstat_info, dsi, &gdiskstat_list, list) {
       if (dsi->mode != mode)
          continue;
       if (strcasecmp(dsi->name, n) == 0)
          return dsi;
    }
    return 0;
 }

 static int
 get_file_values(const char *fn, struct stat_s *s)
 {
    int ret = 0;
    FILE *fh = fopen(fn, "r");
    if (!fh)
       return -1;

    ret = fscanf(fh,
         "%" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64
         " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 "",
         &s->r_ios, &s->r_merges, &s->r_sectors, &s->r_ticks, &s->w_ios,
         &s->w_merges, &s->w_sectors, &s->w_ticks, &s->in_flight, &s->io_ticks,
         &s->time_in_queue);

    fclose(fh);

    return ret;
 }

 static void
 query_dsi_load(struct hud_graph *gr, struct pipe_context *pipe)
 {
    /* The framework calls us periodically, compensate for the
     * calling interval accordingly when reporting per second.
     */
    struct diskstat_info *dsi = gr->query_data;
    uint64_t now = os_time_get();

    if (dsi->last_time) {
       if (dsi->last_time + gr->pane->period <= now) {
          struct stat_s stat;
          if (get_file_values(dsi->sysfs_filename, &stat) < 0)
             return;
          float val = 0;

          switch (dsi->mode) {
          case DISKSTAT_RD:
             val =
                ((stat.r_sectors -
                  dsi->last_stat.r_sectors) * 512) /
                (((float) gr->pane->period / 1000) / 1000);
             break;
          case DISKSTAT_WR:
             val =
                ((stat.w_sectors -
                  dsi->last_stat.w_sectors) * 512) /
                (((float) gr->pane->period / 1000) / 1000);
             break;
          }

          hud_graph_add_value(gr, (uint64_t) val);
          dsi->last_stat = stat;
          dsi->last_time = now;
       }
    }
    else {
       /* initialize */
       switch (dsi->mode) {
       case DISKSTAT_RD:
       case DISKSTAT_WR:
          get_file_values(dsi->sysfs_filename, &dsi->last_stat);
          break;
       }
       dsi->last_time = now;
    }
 }

 /**
   * Create and initialize a new object for a specific block I/O device.
   * \param  pane  parent context.
   * \param  dev_name  logical block device name, EG. sda5.
   * \param  mode  query read or write (DISKSTAT_RD/DISKSTAT_WR) statistics.
   */
 void
 hud_diskstat_graph_install(struct hud_pane *pane, const char *dev_name,
                            unsigned int mode)
 {
    struct hud_graph *gr;
    struct diskstat_info *dsi;

    int num_devs = hud_get_num_disks(0);
    if (num_devs <= 0)
       return;

    dsi = find_dsi_by_name(dev_name, mode);
    if (!dsi)
       return;

    gr = CALLOC_STRUCT(hud_graph);
    if (!gr)
       return;

    dsi->mode = mode;
    if (dsi->mode == DISKSTAT_RD) {
       snprintf(gr->name, sizeof(gr->name), "%s-Read-MB/s", dsi->name);
    }
    else if (dsi->mode == DISKSTAT_WR) {
       snprintf(gr->name, sizeof(gr->name), "%s-Write-MB/s", dsi->name);
    }
    else {
       free(gr);
       return;
    }

    gr->query_data = dsi;
    gr->query_new_value = query_dsi_load;

    hud_pane_add_graph(pane, gr);
    hud_pane_set_max_value(pane, 100);
 }

 static void
 add_object_part(const char *basename, const char *name, int objmode)
 {
    struct diskstat_info *dsi = CALLOC_STRUCT(diskstat_info);

    snprintf(dsi->name, sizeof(dsi->name), "%s", name);
    snprintf(dsi->sysfs_filename, sizeof(dsi->sysfs_filename), "%s/%s/stat",
       basename, name);
    dsi->mode = objmode;
    list_addtail(&dsi->list, &gdiskstat_list);
    gdiskstat_count++;
 }

 static void
 add_object(const char *basename, const char *name, int objmode)
 {
    struct diskstat_info *dsi = CALLOC_STRUCT(diskstat_info);

    snprintf(dsi->name, sizeof(dsi->name), "%s", name);
    snprintf(dsi->sysfs_filename, sizeof(dsi->sysfs_filename), "%s/stat",
       basename);
    dsi->mode = objmode;
    list_addtail(&dsi->list, &gdiskstat_list);
    gdiskstat_count++;
 }

 /**
   * Initialize internal object arrays and display block I/O HUD help.
   * \param  displayhelp  true if the list of detected devices should be
                          displayed on the console.
   * \return  number of detected block I/O devices.
   */
 int
 hud_get_num_disks(bool displayhelp)
 {
    struct dirent *dp;
    struct stat stat_buf;
    char name[64];

    /* Return the number of block devices and partitions. */
    mtx_lock(&gdiskstat_mutex);
    if (gdiskstat_count) {
       mtx_unlock(&gdiskstat_mutex);
       return gdiskstat_count;
    }

    /* Scan /sys/block, for every object type we support, create and
     * persist an object to represent its different statistics.
     */
    list_inithead(&gdiskstat_list);
    DIR *dir = opendir("/sys/block/");
    if (!dir) {
       mtx_unlock(&gdiskstat_mutex);
       return 0;
    }

    while ((dp = readdir(dir)) != NULL) {

       /* Avoid 'lo' and '..' and '.' */
       if (strlen(dp->d_name) <= 2)
          continue;

       char basename[256];
       snprintf(basename, sizeof(basename), "/sys/block/%s", dp->d_name);
       snprintf(name, sizeof(name), "%s/stat", basename);
       if (stat(name, &stat_buf) < 0)
          continue;

       if (!S_ISREG(stat_buf.st_mode))
          continue;              /* Not a regular file */

       /* Add a physical block device with R/W stats */
       add_object(basename, dp->d_name, DISKSTAT_RD);
       add_object(basename, dp->d_name, DISKSTAT_WR);

       /* Add any partitions */
       struct dirent *dpart;
       DIR *pdir = opendir(basename);
       if (!pdir) {
          mtx_unlock(&gdiskstat_mutex);
          closedir(dir);
          return 0;
       }

       while ((dpart = readdir(pdir)) != NULL) {
          /* Avoid 'lo' and '..' and '.' */
          if (strlen(dpart->d_name) <= 2)
             continue;

          char p[64];
          snprintf(p, sizeof(p), "%s/%s/stat", basename, dpart->d_name);
          if (stat(p, &stat_buf) < 0)
             continue;

          if (!S_ISREG(stat_buf.st_mode))
             continue;           /* Not a regular file */

          /* Add a partition with R/W stats */
          add_object_part(basename, dpart->d_name, DISKSTAT_RD);
          add_object_part(basename, dpart->d_name, DISKSTAT_WR);
       }
    }
    closedir(dir);

    if (displayhelp) {
       list_for_each_entry(struct diskstat_info, dsi, &gdiskstat_list, list) {
          char line[32];
          snprintf(line, sizeof(line), "    diskstat-%s-%s",
                  dsi->mode == DISKSTAT_RD ? "rd" :
                  dsi->mode == DISKSTAT_WR ? "wr" : "undefined", dsi->name);

          puts(line);
       }
    }
    mtx_unlock(&gdiskstat_mutex);

    return gdiskstat_count;
 }

 #endif /* HAVE_GALLIUM_EXTRA_HUD */
	/**************************************************************************
	*
	* Copyright (C) 2016 Steven Toth <stoth@kernellabs.com>
	* Copyright (C) 2016 Zodiac Inflight Innovations
	* All Rights Reserved.
	*
	* Permission is hereby granted, free of charge, to any person obtaining a
	* copy of this software and associated documentation files (the
	* "Software"), to deal in the Software without restriction, including
	* without limitation the rights to use, copy, modify, merge, publish,
	* distribute, sub license, and/or sell copies of the Software, and to
	* permit persons to whom the Software is furnished to do so, subject to
	* the following conditions:
	*
	* The above copyright notice and this permission notice (including the
	* next paragraph) shall be included in all copies or substantial portions
	* of the Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
	* IN NO EVENT SHALL THE AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR
	* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
	* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
	* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	*
	**************************************************************************/

	#ifdef HAVE_GALLIUM_EXTRA_HUD

	/* Purpose: Reading /sys/block/<*>/stat MB/s read/write throughput per second,
	* displaying on the HUD.
	*/

	#include "hud/hud_private.h"
	#include "util/list.h"
	#include "util/os_time.h"
	#include "os/os_thread.h"
	#include "util/u_memory.h"
	#include "util/u_string.h"
	#include <stdio.h>
	#include <unistd.h>
	#include <dirent.h>
	#include <stdlib.h>
	#include <unistd.h>
	#include <inttypes.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <unistd.h>

	struct stat_s
	{
	/* Read */
	uint64_t r_ios;
	uint64_t r_merges;
	uint64_t r_sectors;
	uint64_t r_ticks;
	/* Write */
	uint64_t w_ios;
	uint64_t w_merges;
	uint64_t w_sectors;
	uint64_t w_ticks;
	/* Misc */
	uint64_t in_flight;
	uint64_t io_ticks;
	uint64_t time_in_queue;
	};

	struct diskstat_info
	{
	struct list_head list;
	int mode; /* DISKSTAT_RD, DISKSTAT_WR */
	char name[64]; /* EG. sda5 */

	char sysfs_filename[128];
	uint64_t last_time;
	struct stat_s last_stat;
	};

	/* TODO: We don't handle dynamic block device / partition
	* arrival or removal.
	* Static globals specific to this HUD category.
	*/
	static int gdiskstat_count = 0;
	static struct list_head gdiskstat_list;
	static mtx_t gdiskstat_mutex = _MTX_INITIALIZER_NP;

	static struct diskstat_info *
	find_dsi_by_name(const char *n, int mode)
	{
	list_for_each_entry(struct diskstat_info, dsi, &gdiskstat_list, list) {
	if (dsi->mode != mode)
	continue;
	if (strcasecmp(dsi->name, n) == 0)
	return dsi;
	}
	return 0;
	}

	static int
	get_file_values(const char fn, struct stat_s s)
	{
	int ret = 0;
	FILE *fh = fopen(fn, "r");
	if (!fh)
	return -1;

	ret = fscanf(fh,
	"%" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64
	" %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 "",
	&s->r_ios, &s->r_merges, &s->r_sectors, &s->r_ticks, &s->w_ios,
	&s->w_merges, &s->w_sectors, &s->w_ticks, &s->in_flight, &s->io_ticks,
	&s->time_in_queue);

	fclose(fh);

	return ret;
	}

	static void
	query_dsi_load(struct hud_graph gr, struct pipe_context pipe)
	{
	/* The framework calls us periodically, compensate for the
	* calling interval accordingly when reporting per second.
	*/
	struct diskstat_info *dsi = gr->query_data;
	uint64_t now = os_time_get();

	if (dsi->last_time) {
	if (dsi->last_time + gr->pane->period <= now) {
	struct stat_s stat;
	if (get_file_values(dsi->sysfs_filename, &stat) < 0)
	return;
	float val = 0;

	switch (dsi->mode) {
	case DISKSTAT_RD:
	val =
	((stat.r_sectors -
	dsi->last_stat.r_sectors) * 512) /
	(((float) gr->pane->period / 1000) / 1000);
	break;
	case DISKSTAT_WR:
	val =
	((stat.w_sectors -
	dsi->last_stat.w_sectors) * 512) /
	(((float) gr->pane->period / 1000) / 1000);
	break;
	}

	hud_graph_add_value(gr, (uint64_t) val);
	dsi->last_stat = stat;
	dsi->last_time = now;
	}
	}
	else {
	/* initialize */
	switch (dsi->mode) {
	case DISKSTAT_RD:
	case DISKSTAT_WR:
	get_file_values(dsi->sysfs_filename, &dsi->last_stat);
	break;
	}
	dsi->last_time = now;
	}
	}

	/**
	* Create and initialize a new object for a specific block I/O device.
	* \param pane parent context.
	* \param dev_name logical block device name, EG. sda5.
	* \param mode query read or write (DISKSTAT_RD/DISKSTAT_WR) statistics.
	*/
	void
	hud_diskstat_graph_install(struct hud_pane pane, const char dev_name,
	unsigned int mode)
	{
	struct hud_graph *gr;
	struct diskstat_info *dsi;

	int num_devs = hud_get_num_disks(0);
	if (num_devs <= 0)
	return;

	dsi = find_dsi_by_name(dev_name, mode);
	if (!dsi)
	return;

	gr = CALLOC_STRUCT(hud_graph);
	if (!gr)
	return;

	dsi->mode = mode;
	if (dsi->mode == DISKSTAT_RD) {
	snprintf(gr->name, sizeof(gr->name), "%s-Read-MB/s", dsi->name);
	}
	else if (dsi->mode == DISKSTAT_WR) {
	snprintf(gr->name, sizeof(gr->name), "%s-Write-MB/s", dsi->name);
	}
	else {
	free(gr);
	return;
	}

	gr->query_data = dsi;
	gr->query_new_value = query_dsi_load;

	hud_pane_add_graph(pane, gr);
	hud_pane_set_max_value(pane, 100);
	}

	static void
	add_object_part(const char basename, const char name, int objmode)
	{
	struct diskstat_info *dsi = CALLOC_STRUCT(diskstat_info);

	snprintf(dsi->name, sizeof(dsi->name), "%s", name);
	snprintf(dsi->sysfs_filename, sizeof(dsi->sysfs_filename), "%s/%s/stat",
	basename, name);
	dsi->mode = objmode;
	list_addtail(&dsi->list, &gdiskstat_list);
	gdiskstat_count++;
	}

	static void
	add_object(const char basename, const char name, int objmode)
	{
	struct diskstat_info *dsi = CALLOC_STRUCT(diskstat_info);

	snprintf(dsi->name, sizeof(dsi->name), "%s", name);
	snprintf(dsi->sysfs_filename, sizeof(dsi->sysfs_filename), "%s/stat",
	basename);
	dsi->mode = objmode;
	list_addtail(&dsi->list, &gdiskstat_list);
	gdiskstat_count++;
	}

	/**
	* Initialize internal object arrays and display block I/O HUD help.
	* \param displayhelp true if the list of detected devices should be
	displayed on the console.
	* \return number of detected block I/O devices.
	*/
	int
	hud_get_num_disks(bool displayhelp)
	{
	struct dirent *dp;
	struct stat stat_buf;
	char name[64];

	/* Return the number of block devices and partitions. */
	mtx_lock(&gdiskstat_mutex);
	if (gdiskstat_count) {
	mtx_unlock(&gdiskstat_mutex);
	return gdiskstat_count;
	}

	/* Scan /sys/block, for every object type we support, create and
	* persist an object to represent its different statistics.
	*/
	list_inithead(&gdiskstat_list);
	DIR *dir = opendir("/sys/block/");
	if (!dir) {
	mtx_unlock(&gdiskstat_mutex);
	return 0;
	}

	while ((dp = readdir(dir)) != NULL) {

	/* Avoid 'lo' and '..' and '.' */
	if (strlen(dp->d_name) <= 2)
	continue;

	char basename[256];
	snprintf(basename, sizeof(basename), "/sys/block/%s", dp->d_name);
	snprintf(name, sizeof(name), "%s/stat", basename);
	if (stat(name, &stat_buf) < 0)
	continue;

	if (!S_ISREG(stat_buf.st_mode))
	continue; /* Not a regular file */

	/* Add a physical block device with R/W stats */
	add_object(basename, dp->d_name, DISKSTAT_RD);
	add_object(basename, dp->d_name, DISKSTAT_WR);

	/* Add any partitions */
	struct dirent *dpart;
	DIR *pdir = opendir(basename);
	if (!pdir) {
	mtx_unlock(&gdiskstat_mutex);
	closedir(dir);
	return 0;
	}

	while ((dpart = readdir(pdir)) != NULL) {
	/* Avoid 'lo' and '..' and '.' */
	if (strlen(dpart->d_name) <= 2)
	continue;

	char p[64];
	snprintf(p, sizeof(p), "%s/%s/stat", basename, dpart->d_name);
	if (stat(p, &stat_buf) < 0)
	continue;

	if (!S_ISREG(stat_buf.st_mode))
	continue; /* Not a regular file */

	/* Add a partition with R/W stats */
	add_object_part(basename, dpart->d_name, DISKSTAT_RD);
	add_object_part(basename, dpart->d_name, DISKSTAT_WR);
	}
	}
	closedir(dir);

	if (displayhelp) {
	list_for_each_entry(struct diskstat_info, dsi, &gdiskstat_list, list) {
	char line[32];
	snprintf(line, sizeof(line), " diskstat-%s-%s",
	dsi->mode == DISKSTAT_RD ? "rd" :
	dsi->mode == DISKSTAT_WR ? "wr" : "undefined", dsi->name);

	puts(line);
	}
	}
	mtx_unlock(&gdiskstat_mutex);

	return gdiskstat_count;
	}

	#endif /* HAVE_GALLIUM_EXTRA_HUD */