/*
***************************************************************************
* Write basic stats, read from /proc/diskstats or from sysfs.
*
* IN:
* @curr Index in array for current sample statistics.
* @itv Interval of time.
* @fctr Conversion factor.
* @shi Structures describing the devices and partitions.
* @ioi Current sample statistics.
* @ioj Previous sample statistics.
***************************************************************************
*/
void write_basic_stat(int curr, unsigned long long itv, int fctr,
struct io_hdr_stats *shi, struct io_stats *ioi,
struct io_stats *ioj)
{
char *devname = NULL;
unsigned long long rd_sec, wr_sec;
/* Print device name */
if (DISPLAY_PERSIST_NAME_I(flags)) {
devname = get_persistent_name_from_pretty(shi->name);
}
if (!devname) {
devname = shi->name;
}
if (DISPLAY_HUMAN_READ(flags)) {
cprintf_in(IS_STR, "%s\n", devname, 0);
printf("%13s", "");
}
else {
cprintf_in(IS_STR, "%-13s", devname, 0);
}
/* Print stats coming from /sys or /proc/diskstats */
rd_sec = ioi->rd_sectors - ioj->rd_sectors;
if ((ioi->rd_sectors < ioj->rd_sectors) && (ioj->rd_sectors <= 0xffffffff)) {
rd_sec &= 0xffffffff;
}
wr_sec = ioi->wr_sectors - ioj->wr_sectors;
if ((ioi->wr_sectors < ioj->wr_sectors) && (ioj->wr_sectors <= 0xffffffff)) {
wr_sec &= 0xffffffff;
}
cprintf_f(1, 8, 2,
S_VALUE(ioj->rd_ios + ioj->wr_ios, ioi->rd_ios + ioi->wr_ios, itv));
cprintf_f(2, 12, 2,
S_VALUE(ioj->rd_sectors, ioi->rd_sectors, itv) / fctr,
S_VALUE(ioj->wr_sectors, ioi->wr_sectors, itv) / fctr);
cprintf_u64(2, 10,
(unsigned long long) rd_sec / fctr,
(unsigned long long) wr_sec / fctr);
printf("\n");
}
/*
***************************************************************************
* Write basic stats, read from /proc/diskstats or from sysfs.
*
* IN:
* @curr Index in array for current sample statistics.
* @itv Interval of time.
* @fctr Conversion factor.
* @shi Structures describing the devices and partitions.
* @ioi Current sample statistics.
* @ioj Previous sample statistics.
***************************************************************************
*/
void write_basic_stat(int curr, unsigned long long itv, int fctr,
struct io_hdr_stats *shi, struct io_stats *ioi,
struct io_stats *ioj)
{
char *devname = NULL;
unsigned long long rd_sec, wr_sec;
/* Print device name */
if (DISPLAY_PERSIST_NAME_I(flags)) {
devname = get_persistent_name_from_pretty(shi->name);
}
if (!devname) {
devname = shi->name;
}
if (DISPLAY_HUMAN_READ(flags)) {
printf("%s\n%13s", devname, "");
}
else {
printf("%-13s", devname);
}
/* Print stats coming from /sys or /proc/diskstats */
rd_sec = ioi->rd_sectors - ioj->rd_sectors;
if ((ioi->rd_sectors < ioj->rd_sectors) && (ioj->rd_sectors <= 0xffffffff)) {
rd_sec &= 0xffffffff;
}
wr_sec = ioi->wr_sectors - ioj->wr_sectors;
if ((ioi->wr_sectors < ioj->wr_sectors) && (ioj->wr_sectors <= 0xffffffff)) {
wr_sec &= 0xffffffff;
}
printf(" %8.2f %12.2f %12.2f %10llu %10llu\n",
S_VALUE(ioj->rd_ios + ioj->wr_ios, ioi->rd_ios + ioi->wr_ios, itv),
ll_s_value(ioj->rd_sectors, ioi->rd_sectors, itv) / fctr,
ll_s_value(ioj->wr_sectors, ioi->wr_sectors, itv) / fctr,
(unsigned long long) rd_sec / fctr,
(unsigned long long) wr_sec / fctr);
}
/*
***************************************************************************
* Display extended stats, read from /proc/{diskstats,partitions} or /sys.
*
* IN:
* @curr Index in array for current sample statistics.
* @itv Interval of time.
* @fctr Conversion factor.
* @shi Structures describing the devices and partitions.
* @ioi Current sample statistics.
* @ioj Previous sample statistics.
***************************************************************************
*/
void write_ext_stat(int curr, unsigned long long itv, int fctr,
struct io_hdr_stats *shi, struct io_stats *ioi,
struct io_stats *ioj)
{
char *devname = NULL;
struct stats_disk sdc, sdp;
struct ext_disk_stats xds;
double r_await, w_await;
/*
* Counters overflows are possible, but don't need to be handled in
* a special way: The difference is still properly calculated if the
* result is of the same type as the two values.
* Exception is field rq_ticks which is incremented by the number of
* I/O in progress times the number of milliseconds spent doing I/O.
* But the number of I/O in progress (field ios_pgr) happens to be
* sometimes negative...
*/
sdc.nr_ios = ioi->rd_ios + ioi->wr_ios;
sdp.nr_ios = ioj->rd_ios + ioj->wr_ios;
sdc.tot_ticks = ioi->tot_ticks;
sdp.tot_ticks = ioj->tot_ticks;
sdc.rd_ticks = ioi->rd_ticks;
sdp.rd_ticks = ioj->rd_ticks;
sdc.wr_ticks = ioi->wr_ticks;
sdp.wr_ticks = ioj->wr_ticks;
sdc.rd_sect = ioi->rd_sectors;
sdp.rd_sect = ioj->rd_sectors;
sdc.wr_sect = ioi->wr_sectors;
sdp.wr_sect = ioj->wr_sectors;
compute_ext_disk_stats(&sdc, &sdp, itv, &xds);
r_await = (ioi->rd_ios - ioj->rd_ios) ?
(ioi->rd_ticks - ioj->rd_ticks) /
((double) (ioi->rd_ios - ioj->rd_ios)) : 0.0;
w_await = (ioi->wr_ios - ioj->wr_ios) ?
(ioi->wr_ticks - ioj->wr_ticks) /
((double) (ioi->wr_ios - ioj->wr_ios)) : 0.0;
/* Print device name */
if (DISPLAY_PERSIST_NAME_I(flags)) {
devname = get_persistent_name_from_pretty(shi->name);
}
if (!devname) {
devname = shi->name;
}
if (DISPLAY_HUMAN_READ(flags)) {
printf("%s\n%13s", devname, "");
}
else {
printf("%-13s", devname);
}
/* rrq/s wrq/s r/s w/s rsec wsec rqsz qusz await r_await w_await svctm %util */
printf(" %8.2f %8.2f %7.2f %7.2f %8.2f %8.2f %8.2f %8.2f %7.2f %7.2f %7.2f %6.2f %6.2f\n",
S_VALUE(ioj->rd_merges, ioi->rd_merges, itv),
S_VALUE(ioj->wr_merges, ioi->wr_merges, itv),
S_VALUE(ioj->rd_ios, ioi->rd_ios, itv),
S_VALUE(ioj->wr_ios, ioi->wr_ios, itv),
S_VALUE(ioj->rd_sectors, ioi->rd_sectors, itv) / fctr,
S_VALUE(ioj->wr_sectors, ioi->wr_sectors, itv) / fctr,
xds.arqsz,
S_VALUE(ioj->rq_ticks, ioi->rq_ticks, itv) / 1000.0,
xds.await,
r_await,
w_await,
/* The ticks output is biased to output 1000 ticks per second */
xds.svctm,
/*
* Again: Ticks in milliseconds.
* In the case of a device group (option -g), shi->used is the number of
* devices in the group. Else shi->used equals 1.
*/
shi->used ? xds.util / 10.0 / (double) shi->used
: xds.util / 10.0); /* shi->used should never be null here */
}
/*
***************************************************************************
* Main entry to the iostat program.
***************************************************************************
*/
int main(int argc, char **argv)
{
int it = 0;
int opt = 1;
int i, report_set = FALSE;
long count = 1;
struct utsname header;
struct io_dlist *st_dev_list_i;
struct tm rectime;
char *t, *persist_devname, *devname;
#ifdef USE_NLS
/* Init National Language Support */
init_nls();
#endif
/* Get HZ */
get_HZ();
/* Allocate structures for device list */
if (argc > 1) {
salloc_dev_list(argc - 1 + count_csvalues(argc, argv));
}
/* Process args... */
while (opt < argc) {
/* -p option used individually. See below for grouped use */
if (!strcmp(argv[opt], "-p")) {
flags |= I_D_PARTITIONS;
if (argv[++opt] &&
(strspn(argv[opt], DIGITS) != strlen(argv[opt])) &&
(strncmp(argv[opt], "-", 1))) {
flags |= I_D_UNFILTERED;
for (t = strtok(argv[opt], ","); t; t = strtok(NULL, ",")) {
if (!strcmp(t, K_ALL)) {
flags |= I_D_PART_ALL;
}
else {
devname = device_name(t);
if (DISPLAY_PERSIST_NAME_I(flags)) {
/* Get device persistent name */
persist_devname = get_pretty_name_from_persistent(devname);
if (persist_devname != NULL) {
devname = persist_devname;
}
}
/* Store device name */
i = update_dev_list(&dlist_idx, devname);
st_dev_list_i = st_dev_list + i;
st_dev_list_i->disp_part = TRUE;
}
}
opt++;
}
else {
flags |= I_D_PART_ALL;
}
}
else if (!strcmp(argv[opt], "-g")) {
/*
* Option -g: Stats for a group of devices.
* group_name contains the last group name entered on
* the command line. If we define an additional one, save
* the previous one in the list. We do that this way because we
* want the group name to appear in the list _after_ all
* the devices included in that group. The last group name
* will be saved in the list later, in presave_device_list() function.
*/
if (group_nr > 0) {
update_dev_list(&dlist_idx, group_name);
}
if (argv[++opt]) {
/*
* MAX_NAME_LEN - 2: one char for the heading space,
* and one for the trailing '\0'.
*/
snprintf(group_name, MAX_NAME_LEN, " %-.*s", MAX_NAME_LEN - 2, argv[opt++]);
}
else {
usage(argv[0]);
}
group_nr++;
}
else if (!strcmp(argv[opt], "-j")) {
if (argv[++opt]) {
if (strnlen(argv[opt], MAX_FILE_LEN) >= MAX_FILE_LEN - 1) {
usage(argv[0]);
}
strncpy(persistent_name_type, argv[opt], MAX_FILE_LEN - 1);
persistent_name_type[MAX_FILE_LEN - 1] = '\0';
strtolower(persistent_name_type);
/* Check that this is a valid type of persistent device name */
if (!get_persistent_type_dir(persistent_name_type)) {
fprintf(stderr, _("Invalid type of persistent device name\n"));
exit(1);
}
/*
* Persistent names are usually long: Display
* them as human readable by default.
*/
flags |= I_D_PERSIST_NAME + I_D_HUMAN_READ;
opt++;
}
else {
usage(argv[0]);
}
}
#ifdef DEBUG
else if (!strcmp(argv[opt], "--debuginfo")) {
flags |= I_D_DEBUG;
opt++;
}
#endif
else if (!strncmp(argv[opt], "-", 1)) {
for (i = 1; *(argv[opt] + i); i++) {
switch (*(argv[opt] + i)) {
case 'c':
/* Display cpu usage */
flags |= I_D_CPU;
report_set = TRUE;
break;
case 'd':
/* Display disk utilization */
flags |= I_D_DISK;
report_set = TRUE;
break;
case 'h':
/*
* Display device utilization report
* in a human readable format.
*/
flags |= I_D_HUMAN_READ;
break;
case 'k':
if (DISPLAY_MEGABYTES(flags)) {
usage(argv[0]);
}
/* Display stats in kB/s */
flags |= I_D_KILOBYTES;
break;
case 'm':
if (DISPLAY_KILOBYTES(flags)) {
usage(argv[0]);
}
/* Display stats in MB/s */
flags |= I_D_MEGABYTES;
break;
case 'N':
/* Display device mapper logical name */
flags |= I_D_DEVMAP_NAME;
break;
case 'p':
/* If option -p is grouped then it cannot take an arg */
flags |= I_D_PARTITIONS + I_D_PART_ALL;
break;
case 'T':
/* Display stats only for the groups */
flags |= I_D_GROUP_TOTAL_ONLY;
break;
case 't':
/* Display timestamp */
flags |= I_D_TIMESTAMP;
break;
case 'x':
/* Display extended stats */
flags |= I_D_EXTENDED;
break;
case 'y':
/* Don't display stats since system restart */
flags |= I_D_OMIT_SINCE_BOOT;
break;
case 'z':
/* Omit output for devices with no activity */
flags |= I_D_ZERO_OMIT;
break;
case 'V':
/* Print version number and exit */
print_version();
break;
default:
usage(argv[0]);
}
}
opt++;
}
else if (!isdigit(argv[opt][0])) {
/*
* By default iostat doesn't display unused devices.
* If some devices are explictly entered on the command line
* then don't apply this rule any more.
*/
flags |= I_D_UNFILTERED;
if (strcmp(argv[opt], K_ALL)) {
/* Store device name entered on the command line */
devname = device_name(argv[opt++]);
if (DISPLAY_PERSIST_NAME_I(flags)) {
persist_devname = get_pretty_name_from_persistent(devname);
if (persist_devname != NULL) {
devname = persist_devname;
}
}
update_dev_list(&dlist_idx, devname);
}
else {
opt++;
}
}
else if (!it) {
interval = atol(argv[opt++]);
if (interval < 0) {
usage(argv[0]);
}
count = -1;
it = 1;
}
else if (it > 0) {
count = atol(argv[opt++]);
if ((count < 1) || !interval) {
usage(argv[0]);
}
it = -1;
}
else {
usage(argv[0]);
}
}
if (!interval) {
count = 1;
}
/* Default: Display CPU and DISK reports */
if (!report_set) {
flags |= I_D_CPU + I_D_DISK;
}
/*
* Also display DISK reports if options -p, -x or a device has been entered
* on the command line.
*/
if (DISPLAY_PARTITIONS(flags) || DISPLAY_EXTENDED(flags) ||
DISPLAY_UNFILTERED(flags)) {
flags |= I_D_DISK;
}
/* Option -T can only be used with option -g */
if (DISPLAY_GROUP_TOTAL_ONLY(flags) && !group_nr) {
usage(argv[0]);
}
/* Select disk output unit (kB/s or blocks/s) */
set_disk_output_unit();
/* Ignore device list if '-p ALL' entered on the command line */
if (DISPLAY_PART_ALL(flags)) {
dlist_idx = 0;
}
if (DISPLAY_DEVMAP_NAME(flags)) {
dm_major = get_devmap_major();
}
/* Init structures according to machine architecture */
io_sys_init();
if (group_nr > 0) {
/*
* If groups of devices have been defined
* then save devices and groups in the list.
*/
presave_device_list();
}
get_localtime(&rectime, 0);
/* Get system name, release number and hostname */
uname(&header);
if (print_gal_header(&rectime, header.sysname, header.release,
header.nodename, header.machine, cpu_nr)) {
flags |= I_D_ISO;
}
printf("\n");
/* Set a handler for SIGALRM */
memset(&alrm_act, 0, sizeof(alrm_act));
alrm_act.sa_handler = alarm_handler;
sigaction(SIGALRM, &alrm_act, NULL);
alarm(interval);
/* Main loop */
rw_io_stat_loop(count, &rectime);
/* Free structures */
io_sys_free();
sfree_dev_list();
return 0;
}
