/* *************************************************************************** * Display disk stats header. * * OUT: * @fctr Conversion factor. *************************************************************************** */ void write_disk_stat_header(int *fctr) { if (DISPLAY_EXTENDED(flags)) { /* Extended stats */ printf("Device: rrqm/s wrqm/s r/s w/s"); if (DISPLAY_MEGABYTES(flags)) { printf(" rMB/s wMB/s"); *fctr = 2048; } else if (DISPLAY_KILOBYTES(flags)) { printf(" rkB/s wkB/s"); *fctr = 2; } else { printf(" rsec/s wsec/s"); } printf(" avgrq-sz avgqu-sz await r_await w_await svctm %%util\n"); } else { /* Basic stats */ printf("Device: tps"); if (DISPLAY_KILOBYTES(flags)) { printf(" kB_read/s kB_wrtn/s kB_read kB_wrtn\n"); *fctr = 2; } else if (DISPLAY_MEGABYTES(flags)) { printf(" MB_read/s MB_wrtn/s MB_read MB_wrtn\n"); *fctr = 2048; } else { printf(" Blk_read/s Blk_wrtn/s Blk_read Blk_wrtn\n"); } } }
/* *************************************************************************** * Set disk output unit. Unit will be kB/s unless POSIXLY_CORRECT * environment variable has been set, in which case the output will be * expressed in blocks/s. *************************************************************************** */ void set_disk_output_unit(void) { if (DISPLAY_KILOBYTES(flags) || DISPLAY_MEGABYTES(flags)) return; /* Check POSIXLY_CORRECT environment variable */ if (getenv(ENV_POSIXLY_CORRECT) == NULL) { /* Variable not set: Unit is kB/s and not blocks/s */ flags |= I_D_KILOBYTES; } }
/* *************************************************************************** * Display CIFS stats header. * * OUT: * @fctr Conversion factor. *************************************************************************** */ void write_cifs_stat_header(int *fctr) { printf("Filesystem: "); if (DISPLAY_KILOBYTES(flags)) { printf(" rkB/s wkB/s"); *fctr = 1024; } else if (DISPLAY_MEGABYTES(flags)) { printf(" rMB/s wMB/s"); *fctr = 1024 * 1024; } else { printf(" rB/s wB/s"); *fctr = 1; } printf(" rops/s wops/s fo/s fc/s fd/s\n"); }
void write_vm_header(int flag, unsigned long long* unit) { if (DISPLAY_ACTIVE(flag)) printf("group procs ----------memory---------" " ---io--- --------cpu--------\n" "name r b swpd free inact active" " pi po us sy id wa st\n"); else printf("group procs ----------memory---------" " ---io--- --------cpu--------\n" "name r b swpd free buff cache" " pi po us sy id wa st\n"); if (DISPLAY_KILOBYTES(flag)) *unit = 1024; else if (DISPLAY_MEGABYTES(flag)) *unit = 1024 * 1024; else if (DISPLAY_GIGABYTES(flag)) *unit = 1024 * 1024 * 1024; }
/* *************************************************************************** * Display NFS stats header. * * OUT: * @fctr Conversion factor. *************************************************************************** */ void write_nfs_stat_header(int *fctr) { printf("Filesystem: "); if (DISPLAY_KILOBYTES(flags)) { printf(" rkB_nor/s wkB_nor/s rkB_dir/s wkB_dir/s" " rkB_svr/s wkB_svr/s"); *fctr = 1024; } else if (DISPLAY_MEGABYTES(flags)) { printf(" rMB_nor/s wMB_nor/s rMB_dir/s wMB_dir/s" " rMB_svr/s wMB_svr/s"); *fctr = 1024 * 1024; } else { printf(" rBlk_nor/s wBlk_nor/s rBlk_dir/s wBlk_dir/s" " rBlk_svr/s wBlk_svr/s"); *fctr = 512; } printf(" ops/s rops/s wops/s\n"); }
/* * Write the memory statistic information. * * IN: * @mem_stats: The memory statistics information. * @flag: The display flag. */ void write_mem_stats(cg_mem_stats* mem_stats, int flag) { unsigned long long unit = 1024; unsigned long long temp = 0; printf( " total used free shared buffers cached\n"); if (DISPLAY_BYTES(flag)) unit = 1; else if (DISPLAY_MEGABYTES(flag)) unit = 1024 * 1024; else if (DISPLAY_GIGABYTES(flag)) unit = 1024 * 1024 * 1024; printf("Mem: %12.0f %12.0f %12.0f %12.0f %12.0f %12.0f\n", ((double) mem_stats->limit) / unit, ((double) mem_stats->usage) / unit, ((double) (mem_stats->limit - mem_stats->usage)) / unit, (double) 0, (double) 0, ((double) mem_stats->stats->cache) / unit); if (!DISPLAY_OLD(flag)) printf("-/+ buffers/cache: %12.0f %12.0f\n", ((double) (mem_stats->usage - mem_stats->stats->cache - mem_stats->stats->inactive_anon - mem_stats->stats->inactive_file)) / unit, ((double) (mem_stats->limit - mem_stats->usage + mem_stats->stats->cache)) / unit); temp = mem_stats->mem_swap_limit - mem_stats->limit; printf("Swap: %12.0f %12.0f %12.0f\n", ((double) (temp)) / unit, ((double) (mem_stats->mem_swap_usage - mem_stats->usage)) / unit, temp ? ((double) (temp - mem_stats->mem_swap_usage + mem_stats->usage) / unit) : 0); if (DISPLAY_TOTAL(flag)) printf("Total: %12.0f %12.0f %12.0f\n", ((double) mem_stats->mem_swap_limit) / unit, ((double) mem_stats->mem_swap_usage) / unit, ((double) (mem_stats->mem_swap_limit - mem_stats->mem_swap_usage)) / unit); }
/* *************************************************************************** * 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; }
/* *************************************************************************** * Main entry to the cifsiostat program. *************************************************************************** */ int main(int argc, char **argv) { int it = 0; int opt = 1; int i; long count = 1; struct utsname header; struct tm rectime; #ifdef USE_NLS /* Init National Language Support */ init_nls(); #endif /* Get HZ */ get_HZ(); /* Process args... */ while (opt < argc) { #ifdef DEBUG if (!strcmp(argv[opt], "--debuginfo")) { flags |= I_D_DEBUG; opt++; } else #endif if (!strncmp(argv[opt], "-", 1)) { for (i = 1; *(argv[opt] + i); i++) { switch (*(argv[opt] + i)) { case 'h': /* Display an easy-to-read CIFS report */ 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 't': /* Display timestamp */ flags |= I_D_TIMESTAMP; break; case 'V': /* Print version number and exit */ print_version(); break; default: usage(argv[0]); } } 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; } /* Init structures according to machine architecture */ io_sys_init(); get_localtime(&rectime); /* 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 */ alarm_handler(0); /* Main loop */ rw_io_stat_loop(count, &rectime); /* Free structures */ io_sys_free(); return 0; }