/*
***************************************************************************
* Allocate and init structures, according to system state.
***************************************************************************
*/
void io_sys_init(void)
{
/* Allocate and init stat common counters */
init_stats();
/* How many processors on this machine? */
cpu_nr = get_cpu_nr(~0, FALSE);
/* Get number of block devices and partitions in /proc/diskstats */
if ((iodev_nr = get_diskstats_dev_nr(CNT_PART, CNT_ALL_DEV)) > 0) {
flags |= I_F_HAS_DISKSTATS;
iodev_nr += NR_DEV_PREALLOC;
}
if (!HAS_DISKSTATS(flags) ||
(DISPLAY_PARTITIONS(flags) && !DISPLAY_PART_ALL(flags))) {
/*
* If /proc/diskstats exists but we also want stats for the partitions
* of a particular device, stats will have to be found in /sys. So we
* need to know if /sys is mounted or not, and set flags accordingly.
*/
/* Get number of block devices (and partitions) in sysfs */
if ((iodev_nr = get_sysfs_dev_nr(DISPLAY_PARTITIONS(flags))) > 0) {
flags |= I_F_HAS_SYSFS;
iodev_nr += NR_DEV_PREALLOC;
}
else {
fprintf(stderr, _("Cannot find disk data\n"));
exit(2);
}
}
/* Also allocate stat structures for "group" devices */
iodev_nr += group_nr;
/*
* Allocate structures for number of disks found, but also
* for groups of devices if option -g has been entered on the command line.
* iodev_nr must be <> 0.
*/
salloc_device(iodev_nr);
}
/*
***************************************************************************
* Read stats from the sysfs filesystem for every block devices found.
*
* IN:
* @curr Index in array for current sample statistics.
***************************************************************************
*/
void read_sysfs_stat(int curr)
{
DIR *dir;
struct dirent *drd;
char filename[MAX_PF_NAME];
int ok;
/* Every I/O device entry is potentially unregistered */
set_entries_unregistered(iodev_nr, st_hdr_iodev);
/* Open /sys/block directory */
if ((dir = opendir(SYSFS_BLOCK)) != NULL) {
/* Get current entry */
while ((drd = readdir(dir)) != NULL) {
if (!strcmp(drd->d_name, ".") || !strcmp(drd->d_name, ".."))
continue;
snprintf(filename, MAX_PF_NAME, "%s/%s/%s",
SYSFS_BLOCK, drd->d_name, S_STAT);
filename[MAX_PF_NAME - 1] = '\0';
/* If current entry is a directory, try to read its stat file */
ok = read_sysfs_file_stat(curr, filename, drd->d_name);
/*
* If '-p ALL' was entered on the command line,
* also try to read stats for its partitions
*/
if (ok && DISPLAY_PART_ALL(flags)) {
read_sysfs_dlist_part_stat(curr, drd->d_name);
}
}
/* Close /sys/block directory */
closedir(dir);
}
/* Free structures corresponding to unregistered devices */
free_unregistered_entries(iodev_nr, st_hdr_iodev);
}
/*
***************************************************************************
* 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;
}
/*
***************************************************************************
* Allocate and init structures, according to system state
***************************************************************************
*/
void io_sys_init(int *flags)
{
int i;
/* Init stat common counters */
init_stats();
/* How many processors on this machine ? */
cpu_nr = get_cpu_nr(~0);
/* Get number of block devices and partitions in /proc/diskstats */
if ((iodev_nr = get_diskstats_dev_nr(CNT_PART, CNT_ALL_DEV)) > 0) {
*flags |= I_F_HAS_DISKSTATS;
iodev_nr += NR_DEV_PREALLOC;
}
if (!HAS_DISKSTATS(*flags) ||
(DISPLAY_PARTITIONS(*flags) && !DISPLAY_PART_ALL(*flags))) {
/*
* If /proc/diskstats exists but we also want stats for the partitions
* of a particular device, stats will have to be found in /sys. So we
* need to know if /sys is mounted or not, and set *flags accordingly.
*/
/* Get number of block devices (and partitions) in sysfs */
if ((iodev_nr = get_sysfs_dev_nr(DISPLAY_PARTITIONS(*flags))) > 0) {
*flags |= I_F_HAS_SYSFS;
iodev_nr += NR_DEV_PREALLOC;
}
/*
* Get number of block devices and partitions in /proc/partitions,
* those with statistics...
*/
else if ((iodev_nr = get_ppartitions_dev_nr(CNT_PART)) > 0) {
*flags |= I_F_HAS_PPARTITIONS;
iodev_nr += NR_DEV_PREALLOC;
}
/* Get number of "disk_io:" entries in /proc/stat */
else if ((iodev_nr = get_disk_io_nr()) > 0) {
*flags |= I_F_PLAIN_KERNEL24;
iodev_nr += NR_DISK_PREALLOC;
}
else {
/* Assume we have an old kernel: stats for 4 disks are in /proc/stat */
iodev_nr = 4;
*flags |= I_F_OLD_KERNEL;
}
}
/*
* Allocate structures for number of disks found.
* iodev_nr must be <> 0.
*/
salloc_device(iodev_nr);
if (HAS_OLD_KERNEL(*flags)) {
struct io_hdr_stats *shi = st_hdr_iodev;
/*
* If we have an old kernel with the stats for the first four disks
* in /proc/stat, then set the devices names to hdisk[0..3].
*/
for (i = 0; i < 4; i++, shi++) {
shi->used = TRUE;
sprintf(shi->name, "%s%d", K_HDISK, i);
}
}
}
