granicus.if.org Git - sysstat/blob - count.c

   1 /*
   2  * count.c: Count items for which statistics will be collected.
   3  * (C) 1999-2016 by Sebastien GODARD (sysstat <at> orange.fr)
   4  *
   5  ***************************************************************************
   6  * This program is free software; you can redistribute it and/or modify it *
   7  * under the terms of the GNU General Public License as published  by  the *
   8  * Free Software Foundation; either version 2 of the License, or (at  your *
   9  * option) any later version.                                              *
  10  *                                                                         *
  11  * This program is distributed in the hope that it  will  be  useful,  but *
  12  * WITHOUT ANY WARRANTY; without the implied warranty  of  MERCHANTABILITY *
  13  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
  14  * for more details.                                                       *
  15  *                                                                         *
  16  * You should have received a copy of the GNU General Public License along *
  17  * with this program; if not, write to the Free Software Foundation, Inc., *
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA              *
  19  ***************************************************************************
  20  */
  21
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <stdlib.h>
  25 #include <errno.h>
  26 #include <dirent.h>
  27 #include <ctype.h>
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30 #include <sys/statvfs.h>
  31 #include <unistd.h>
  32
  33 #include "common.h"
  34 #include "rd_stats.h"
  35
  36 #ifdef USE_NLS
  37 #include <locale.h>
  38 #include <libintl.h>
  39 #define _(string) gettext(string)
  40 #else
  41 #define _(string) (string)
  42 #endif
  43
  44
  45 /*
  46  ***************************************************************************
  47  * Count number of processors in /sys.
  48  *
  49  * IN:
  50  * @highest     If set to TRUE, then look for the highest processor number.
  51  *              This is used when eg. the machine has 4 CPU numbered 0, 1, 4
  52  *              and 5. In this case, this procedure will return 6.
  53  *
  54  * RETURNS:
  55  * Number of processors (online and offline).
  56  * A value of 0 means that /sys was not mounted.
  57  * A value of N (!=0) means N processor(s) (cpu0 .. cpu(N-1)).
  58  ***************************************************************************
  59  */
  60 int get_sys_cpu_nr(int highest)
  61 {
  62         DIR *dir;
  63         struct dirent *drd;
  64         struct stat buf;
  65         char line[MAX_PF_NAME];
  66         int num_proc, proc_nr = -1;
  67
  68         /* Open relevant /sys directory */
  69         if ((dir = opendir(SYSFS_DEVCPU)) == NULL)
  70                 return 0;
  71
  72         /* Get current file entry */
  73         while ((drd = readdir(dir)) != NULL) {
  74
  75                 if (!strncmp(drd->d_name, "cpu", 3) && isdigit(drd->d_name[3])) {
  76                         snprintf(line, MAX_PF_NAME, "%s/%s", SYSFS_DEVCPU, drd->d_name);
  77                         line[MAX_PF_NAME - 1] = '\0';
  78                         if (stat(line, &buf) < 0)
  79                                 continue;
  80                         if (S_ISDIR(buf.st_mode)) {
  81                                 if (highest) {
  82                                         sscanf(drd->d_name + 3, "%d", &num_proc);
  83                                         if (num_proc > proc_nr) {
  84                                                 proc_nr = num_proc;
  85                                         }
  86                                 }
  87                                 else {
  88                                         proc_nr++;
  89                                 }
  90                         }
  91                 }
  92         }
  93
  94         /* Close directory */
  95         closedir(dir);
  96
  97         return (proc_nr + 1);
  98 }
  99
 100 /*
 101  ***************************************************************************
 102  * Count number of processors in /proc/stat.
 103  *
 104  * RETURNS:
 105  * Number of processors. The returned value is greater than or equal to the
 106  * number of online processors.
 107  * A value of 0 means one processor and non SMP kernel.
 108  * A value of N (!=0) means N processor(s) (0 .. N-1) with SMP kernel.
 109  ***************************************************************************
 110  */
 111 int get_proc_cpu_nr(void)
 112 {
 113         FILE *fp;
 114         char line[16];
 115         int num_proc, proc_nr = -1;
 116
 117         if ((fp = fopen(STAT, "r")) == NULL) {
 118                 fprintf(stderr, _("Cannot open %s: %s\n"), STAT, strerror(errno));
 119                 exit(1);
 120         }
 121
 122         while (fgets(line, sizeof(line), fp) != NULL) {
 123
 124                 if (strncmp(line, "cpu ", 4) && !strncmp(line, "cpu", 3)) {
 125                         sscanf(line + 3, "%d", &num_proc);
 126                         if (num_proc > proc_nr) {
 127                                 proc_nr = num_proc;
 128                         }
 129                 }
 130         }
 131
 132         fclose(fp);
 133
 134         proc_nr++;
 135         return proc_nr;
 136 }
 137
 138 /*
 139  ***************************************************************************
 140  * Count the number of processors on the machine, or look for the
 141  * highest processor number.
 142  * Try to use /sys for that, or /proc/stat if /sys doesn't exist.
 143  *
 144  * IN:
 145  * @max_nr_cpus Maximum number of proc that sysstat can handle.
 146  * @highest     If set to TRUE, then look for the highest processor number.
 147  *              This is used when eg. the machine has 4 CPU numbered 0, 1, 4
 148  *              and 5. In this case, this procedure will return 6.
 149  *
 150  * RETURNS:
 151  * Number of processors.
 152  * 0: one proc and non SMP kernel.
 153  * 1: one proc and SMP kernel (NB: On SMP machines where all the CPUs but
 154  *    one have been disabled, we get the total number of proc since we use
 155  *    /sys to count them).
 156  * 2: two proc...
 157  ***************************************************************************
 158  */
 159 int get_cpu_nr(unsigned int max_nr_cpus, int highest)
 160 {
 161         int cpu_nr;
 162
 163         if ((cpu_nr = get_sys_cpu_nr(highest)) == 0) {
 164                 /* /sys may be not mounted. Use /proc/stat instead */
 165                 cpu_nr = get_proc_cpu_nr();
 166         }
 167
 168         if (cpu_nr > max_nr_cpus) {
 169                 fprintf(stderr, _("Cannot handle so many processors!\n"));
 170                 exit(1);
 171         }
 172
 173         return cpu_nr;
 174 }
 175
 176 /*
 177  ***************************************************************************
 178  * Find number of interrupts available per processor (use
 179  * /proc/interrupts file or /proc/softirqs).
 180  *
 181  * IN:
 182  * @file                /proc file to read (interrupts or softirqs).
 183  * @max_nr_irqcpu       Maximum number of interrupts per processor that
 184  *                      sadc can handle.
 185  * @cpu_nr              Number of processors.
 186  *
 187  * RETURNS:
 188  * Number of interrupts per processor.
 189  ***************************************************************************
 190  */
 191 int get_irqcpu_nr(char *file, int max_nr_irqcpu, int cpu_nr)
 192 {
 193         FILE *fp;
 194         char *line = NULL;
 195         unsigned int irq = 0;
 196         int p;
 197
 198         if ((fp = fopen(file, "r")) == NULL)
 199                 return 0;       /* No interrupts file */
 200
 201         SREALLOC(line, char, INTERRUPTS_LINE + 11 * cpu_nr);
 202
 203         while ((fgets(line, INTERRUPTS_LINE + 11 * cpu_nr , fp) != NULL) &&
 204                (irq < max_nr_irqcpu)) {
 205                 p = strcspn(line, ":");
 206                 if ((p > 0) && (p < 16)) {
 207                         irq++;
 208                 }
 209         }
 210
 211         fclose(fp);
 212
 213         free(line);
 214
 215         return irq;
 216 }
 217
 218 /*
 219  ***************************************************************************
 220  * Find number of devices and partitions available in /proc/diskstats.
 221  *
 222  * IN:
 223  * @count_part          Set to TRUE if devices _and_ partitions are to be
 224  *                      counted.
 225  * @only_used_dev       When counting devices, set to TRUE if only devices
 226  *                      with non zero stats must be counted.
 227  *
 228  * RETURNS:
 229  * Number of devices (and partitions).
 230  ***************************************************************************
 231  */
 232 int get_diskstats_dev_nr(int count_part, int only_used_dev)
 233 {
 234         FILE *fp;
 235         char line[256];
 236         char dev_name[MAX_NAME_LEN];
 237         int dev = 0, i;
 238         unsigned long rd_ios, wr_ios;
 239
 240         if ((fp = fopen(DISKSTATS, "r")) == NULL)
 241                 /* File non-existent */
 242                 return 0;
 243
 244         /*
 245          * Counting devices and partitions is simply a matter of counting
 246          * the number of lines...
 247          */
 248         while (fgets(line, sizeof(line), fp) != NULL) {
 249                 if (!count_part) {
 250                         i = sscanf(line, "%*d %*d %s %lu %*u %*u %*u %lu",
 251                                    dev_name, &rd_ios, &wr_ios);
 252                         if ((i == 2) || !is_device(dev_name, ACCEPT_VIRTUAL_DEVICES))
 253                                 /* It was a partition and not a device */
 254                                 continue;
 255                         if (only_used_dev && !rd_ios && !wr_ios)
 256                                 /* Unused device */
 257                                 continue;
 258                 }
 259                 dev++;
 260         }
 261
 262         fclose(fp);
 263
 264         return dev;
 265 }
 266
 267 #ifdef SOURCE_SADC
 268 /*---------------- BEGIN: FUNCTIONS USED BY SADC ONLY ---------------------*/
 269
 270 /*
 271  ***************************************************************************
 272  * Count number of interrupts that are in /proc/stat file.
 273  *
 274  * RETURNS:
 275  * Number of interrupts, including total number of interrupts.
 276  ***************************************************************************
 277  */
 278 int get_irq_nr(void)
 279 {
 280         FILE *fp;
 281         char line[8192];
 282         int in = 0;
 283         int pos = 4;
 284
 285         if ((fp = fopen(STAT, "r")) == NULL)
 286                 return 0;
 287
 288         while (fgets(line, sizeof(line), fp) != NULL) {
 289
 290                 if (!strncmp(line, "intr ", 5)) {
 291
 292                         while (pos < strlen(line)) {
 293                                 in++;
 294                                 pos += strcspn(line + pos + 1, " ") + 1;
 295                         }
 296                 }
 297         }
 298
 299         fclose(fp);
 300
 301         return in;
 302 }
 303
 304 /*
 305  ***************************************************************************
 306  * Find number of serial lines that support tx/rx accounting
 307  * in /proc/tty/driver/serial file.
 308  *
 309  * RETURNS:
 310  * Number of serial lines supporting tx/rx accouting.
 311  ***************************************************************************
 312  */
 313 int get_serial_nr(void)
 314 {
 315         FILE *fp;
 316         char line[256];
 317         int sl = 0;
 318
 319         if ((fp = fopen(SERIAL, "r")) == NULL)
 320                 return 0;       /* No SERIAL file */
 321
 322         while (fgets(line, sizeof(line), fp) != NULL) {
 323                 /*
 324                  * tx/rx statistics are always present,
 325                  * except when serial line is unknown.
 326                  */
 327                 if (strstr(line, "tx:") != NULL) {
 328                         sl++;
 329                 }
 330         }
 331
 332         fclose(fp);
 333
 334         return sl;
 335 }
 336
 337 /*
 338  ***************************************************************************
 339  * Find number of interfaces (network devices) that are in /proc/net/dev
 340  * file.
 341  *
 342  * RETURNS:
 343  * Number of network interfaces.
 344  ***************************************************************************
 345  */
 346 int get_iface_nr(void)
 347 {
 348         FILE *fp;
 349         char line[128];
 350         int iface = 0;
 351
 352         if ((fp = fopen(NET_DEV, "r")) == NULL)
 353                 return 0;       /* No network device file */
 354
 355         while (fgets(line, sizeof(line), fp) != NULL) {
 356                 if (strchr(line, ':')) {
 357                         iface++;
 358                 }
 359         }
 360
 361         fclose(fp);
 362
 363         return iface;
 364 }
 365
 366 /*
 367  ***************************************************************************
 368  * Get number of devices in /proc/diskstats.
 369  *
 370  * IN:
 371  * @f   Non zero (true) if disks *and* partitions should be counted, and
 372  *      zero (false) if only disks must be counted.
 373  *
 374  * RETURNS:
 375  * Number of devices.
 376  ***************************************************************************
 377  */
 378 int get_disk_nr(unsigned int f)
 379 {
 380         int disk_nr;
 381
 382         /*
 383          * Partitions are taken into account by sar -d only with
 384          * kernels 2.6.25 and later.
 385          */
 386         disk_nr = get_diskstats_dev_nr(f, CNT_USED_DEV);
 387
 388         return disk_nr;
 389 }
 390
 391 /*
 392  ***************************************************************************
 393  * Count number of possible frequencies for CPU#0.
 394  *
 395  * RETURNS:
 396  * Number of frequencies.
 397  ***************************************************************************
 398  */
 399 int get_freq_nr(void)
 400 {
 401         FILE *fp;
 402         char filename[MAX_PF_NAME];
 403         char line[128];
 404         int freq = 0;
 405
 406         snprintf(filename, MAX_PF_NAME, "%s/cpu0/%s",
 407                  SYSFS_DEVCPU, SYSFS_TIME_IN_STATE);
 408         if ((fp = fopen(filename, "r")) == NULL)
 409                 return 0;       /* No time_in_state file for CPU#0 */
 410
 411         while (fgets(line, sizeof(line), fp) != NULL) {
 412                 freq++;
 413         }
 414
 415         fclose(fp);
 416
 417         return freq;
 418 }
 419
 420 /*
 421  ***************************************************************************
 422  * Count number of USB devices in /sys/bus/usb/devices.
 423  *
 424  * RETURNS:
 425  * Number of USB devices plugged into the system.
 426  * Don't count USB root hubs.
 427  * Return -1 if directory doesn't exist in sysfs.
 428  ***************************************************************************
 429  */
 430 int get_usb_nr(void)
 431 {
 432         DIR *dir;
 433         struct dirent *drd;
 434         int usb = 0;
 435
 436         /* Open relevant /sys directory */
 437         if ((dir = opendir(SYSFS_USBDEV)) == NULL)
 438                 return -1;
 439
 440         /* Get current file entry */
 441         while ((drd = readdir(dir)) != NULL) {
 442
 443                 if (isdigit(drd->d_name[0]) && !strchr(drd->d_name, ':')) {
 444                         usb++;
 445                 }
 446         }
 447
 448         /* Close directory */
 449         closedir(dir);
 450
 451         return usb;
 452 }
 453
 454 /*
 455  ***************************************************************************
 456  * Find number of filesystems in /etc/mtab. Pseudo-filesystems are ignored.
 457  *
 458  * RETURNS:
 459  * Number of filesystems.
 460  ***************************************************************************
 461  */
 462 int get_filesystem_nr(void)
 463 {
 464         FILE *fp;
 465         char line[512], fs_name[MAX_FS_LEN], mountp[256];
 466         int fs = 0;
 467         struct statvfs buf;
 468
 469         if ((fp = fopen(MTAB, "r")) == NULL)
 470                 /* File non-existent */
 471                 return 0;
 472
 473         /* Get current filesystem */
 474         while (fgets(line, sizeof(line), fp) != NULL) {
 475                 if (line[0] == '/') {
 476
 477                         /* Read filesystem name and mount point */
 478                         sscanf(line, "%127s", fs_name);
 479                         sscanf(strchr(line, ' ') + 1, "%255s", mountp);
 480
 481                         /* Replace octal codes */
 482                         oct2chr(mountp);
 483
 484                         /* Check that total size is not zero */
 485                         if (statvfs(mountp, &buf) < 0)
 486                                 continue;
 487
 488                         if (buf.f_blocks) {
 489                                 fs++;
 490                         }
 491                 }
 492         }
 493
 494         fclose(fp);
 495
 496         return fs;
 497 }
 498
 499 /*
 500  ***************************************************************************
 501  * Find number of fibre channel hosts in /sys/class/fc_host/.
 502  *
 503  * RETURNS:
 504  * Number of FC hosts.
 505  * Return -1 if directory doesn't exist in sysfs.
 506  ***************************************************************************
 507  */
 508 int get_fchost_nr(void)
 509 {
 510         DIR *dir;
 511         struct dirent *drd;
 512         int fc = 0;
 513
 514         if ((dir = opendir(SYSFS_FCHOST)) == NULL) {
 515                 /* Directory non-existent */
 516                 return -1;
 517         }
 518
 519         while ((drd = readdir(dir)) != NULL) {
 520
 521                 if (!strncmp(drd->d_name, "host", 4)) {
 522                         fc++;
 523                 }
 524         }
 525
 526         /* Close directory */
 527         closedir(dir);
 528
 529         return fc;
 530 }
 531
 532 /*------------------ END: FUNCTIONS USED BY SADC ONLY ---------------------*/
 533 #endif /* SOURCE_SADC */