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

   1 /*
   2  * count.c: Count items for which statistics will be collected.
   3  * (C) 1999-2020 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, sizeof(line), "%s/%s", SYSFS_DEVCPU, drd->d_name);
  77                         line[sizeof(line) - 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 __nr_t get_cpu_nr(unsigned int max_nr_cpus, int highest)
 160 {
 161         __nr_t 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 __nr_t get_irqcpu_nr(char *file, int max_nr_irqcpu, int cpu_nr)
 192 {
 193         FILE *fp;
 194         char *line = NULL;
 195         __nr_t 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 __nr_t 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         __nr_t dev = 0;
 238         int i;
 239         unsigned long rd_ios, wr_ios;
 240
 241         if ((fp = fopen(DISKSTATS, "r")) == NULL)
 242                 /* File non-existent */
 243                 return 0;
 244
 245         /*
 246          * Counting devices and partitions is simply a matter of counting
 247          * the number of lines...
 248          */
 249         while (fgets(line, sizeof(line), fp) != NULL) {
 250                 if (!count_part) {
 251                         i = sscanf(line, "%*d %*d %s %lu %*u %*u %*u %lu",
 252                                    dev_name, &rd_ios, &wr_ios);
 253                         if ((i == 2) || !is_device(SLASH_SYS, dev_name, ACCEPT_VIRTUAL_DEVICES))
 254                                 /* It was a partition and not a device */
 255                                 continue;
 256                         if (only_used_dev && !rd_ios && !wr_ios)
 257                                 /* Unused device */
 258                                 continue;
 259                 }
 260                 dev++;
 261         }
 262
 263         fclose(fp);
 264
 265         return dev;
 266 }
 267
 268 #ifdef SOURCE_SADC
 269 /*---------------- BEGIN: FUNCTIONS USED BY SADC ONLY ---------------------*/
 270
 271 /*
 272  ***************************************************************************
 273  * Count number of interrupts that are in /proc/stat file.
 274  *
 275  * RETURNS:
 276  * Number of interrupts, including total number of interrupts.
 277  ***************************************************************************
 278  */
 279 __nr_t get_irq_nr(void)
 280 {
 281         FILE *fp;
 282         char line[8192];
 283         __nr_t in = 0;
 284         int pos = 4;
 285
 286         if ((fp = fopen(STAT, "r")) == NULL)
 287                 return 0;
 288
 289         while (fgets(line, sizeof(line), fp) != NULL) {
 290
 291                 if (!strncmp(line, "intr ", 5)) {
 292
 293                         while (pos < strlen(line)) {
 294                                 in++;
 295                                 pos += strcspn(line + pos + 1, " ") + 1;
 296                         }
 297                 }
 298         }
 299
 300         fclose(fp);
 301
 302         return in;
 303 }
 304
 305 /*
 306  ***************************************************************************
 307  * Find number of serial lines that support tx/rx accounting
 308  * in /proc/tty/driver/serial file.
 309  *
 310  * RETURNS:
 311  * Number of serial lines supporting tx/rx accouting.
 312  ***************************************************************************
 313  */
 314 __nr_t get_serial_nr(void)
 315 {
 316         FILE *fp;
 317         char line[256];
 318         __nr_t sl = 0;
 319
 320         if ((fp = fopen(SERIAL, "r")) == NULL)
 321                 return 0;       /* No SERIAL file */
 322
 323         while (fgets(line, sizeof(line), fp) != NULL) {
 324                 /*
 325                  * tx/rx statistics are always present,
 326                  * except when serial line is unknown.
 327                  */
 328                 if (strstr(line, "tx:") != NULL) {
 329                         sl++;
 330                 }
 331         }
 332
 333         fclose(fp);
 334
 335         return sl;
 336 }
 337
 338 /*
 339  ***************************************************************************
 340  * Find number of interfaces (network devices) that are in /proc/net/dev
 341  * file.
 342  *
 343  * RETURNS:
 344  * Number of network interfaces.
 345  ***************************************************************************
 346  */
 347 __nr_t get_iface_nr(void)
 348 {
 349         FILE *fp;
 350         char line[128];
 351         __nr_t iface = 0;
 352
 353         if ((fp = fopen(NET_DEV, "r")) == NULL)
 354                 return 0;       /* No network device file */
 355
 356         while (fgets(line, sizeof(line), fp) != NULL) {
 357                 if (strchr(line, ':')) {
 358                         iface++;
 359                 }
 360         }
 361
 362         fclose(fp);
 363
 364         return iface;
 365 }
 366
 367 /*
 368  ***************************************************************************
 369  * Get number of devices in /proc/diskstats.
 370  *
 371  * IN:
 372  * @f   Non zero (true) if disks *and* partitions should be counted, and
 373  *      zero (false) if only disks must be counted.
 374  *
 375  * RETURNS:
 376  * Number of devices.
 377  ***************************************************************************
 378  */
 379 __nr_t get_disk_nr(unsigned int f)
 380 {
 381         __nr_t disk_nr;
 382
 383         /*
 384          * Partitions are taken into account by sar -d only with
 385          * kernels 2.6.25 and later.
 386          */
 387         disk_nr = get_diskstats_dev_nr(f, CNT_USED_DEV);
 388
 389         return disk_nr;
 390 }
 391
 392 /*
 393  ***************************************************************************
 394  * Count number of possible frequencies for CPU#0.
 395  *
 396  * RETURNS:
 397  * Number of frequencies.
 398  ***************************************************************************
 399  */
 400 __nr_t get_freq_nr(void)
 401 {
 402         FILE *fp;
 403         char filename[MAX_PF_NAME];
 404         char line[128];
 405         __nr_t freq = 0;
 406
 407         snprintf(filename, MAX_PF_NAME, "%s/cpu0/%s",
 408                  SYSFS_DEVCPU, SYSFS_TIME_IN_STATE);
 409         if ((fp = fopen(filename, "r")) == NULL)
 410                 return 0;       /* No time_in_state file for CPU#0 */
 411
 412         while (fgets(line, sizeof(line), fp) != NULL) {
 413                 freq++;
 414         }
 415
 416         fclose(fp);
 417
 418         return freq;
 419 }
 420
 421 /*
 422  ***************************************************************************
 423  * Count number of USB devices in /sys/bus/usb/devices.
 424  *
 425  * RETURNS:
 426  * Number of USB devices plugged into the system.
 427  * Don't count USB root hubs.
 428  * Return -1 if directory doesn't exist in sysfs.
 429  ***************************************************************************
 430  */
 431 __nr_t get_usb_nr(void)
 432 {
 433         DIR *dir;
 434         struct dirent *drd;
 435         __nr_t usb = 0;
 436
 437         /* Open relevant /sys directory */
 438         if ((dir = opendir(SYSFS_USBDEV)) == NULL)
 439                 return -1;
 440
 441         /* Get current file entry */
 442         while ((drd = readdir(dir)) != NULL) {
 443
 444                 if (isdigit(drd->d_name[0]) && !strchr(drd->d_name, ':')) {
 445                         usb++;
 446                 }
 447         }
 448
 449         /* Close directory */
 450         closedir(dir);
 451
 452         return usb;
 453 }
 454
 455 /*
 456  ***************************************************************************
 457  * Find number of filesystems in /etc/mtab. Pseudo-filesystems are ignored.
 458  *
 459  * RETURNS:
 460  * Number of filesystems.
 461  ***************************************************************************
 462  */
 463 __nr_t get_filesystem_nr(void)
 464 {
 465         FILE *fp;
 466         char line[512], fs_name[MAX_FS_LEN], mountp[256], type[128];
 467         char *pos = 0, *pos2 = 0;
 468         __nr_t fs = 0;
 469         int skip = 0, skip_next = 0;
 470         struct statvfs buf;
 471
 472         if ((fp = fopen(MTAB, "r")) == NULL)
 473                 /* File non-existent */
 474                 return 0;
 475
 476         /* Get current filesystem */
 477         while (fgets(line, sizeof(line), fp) != NULL) {
 478                 /*
 479                  * Ignore line if the preceding line did not contain '\n'.
 480                  * (Some very long lines may be found for instance when
 481                  * overlay2 filesystem with docker is used).
 482                  */
 483                 skip = skip_next;
 484                 skip_next = (strchr(line, '\n') == NULL);
 485                 if (skip)
 486                         continue;
 487
 488                 if (line[0] == '/') {
 489                         /* Find field separator position */
 490                         pos = strchr(line, ' ');
 491                         if (pos == NULL)
 492                                 continue;
 493
 494                         /*
 495                          * Find second field separator position,
 496                          * read filesystem type,
 497                          * if filesystem type is autofs, skip it
 498                         */
 499                         pos2 = strchr(pos + 1, ' ');
 500                         if (pos2 == NULL)
 501                                 continue;
 502
 503                         sscanf(pos2 + 1, "%127s", type);
 504                         if(strcmp(type, "autofs") == 0)
 505                                 continue;
 506
 507                         /* Read filesystem name and mount point */
 508                         sscanf(line, "%127s", fs_name);
 509                         sscanf(pos + 1, "%255s", mountp);
 510
 511                         /* Replace octal codes */
 512                         oct2chr(mountp);
 513
 514                         /* Check that total size is not zero */
 515                         if (__statvfs(mountp, &buf) < 0)
 516                                 continue;
 517
 518                         if (buf.f_blocks) {
 519                                 fs++;
 520                         }
 521                 }
 522         }
 523
 524         fclose(fp);
 525
 526         return fs;
 527 }
 528
 529 /*
 530  ***************************************************************************
 531  * Find number of fibre channel hosts in /sys/class/fc_host/.
 532  *
 533  * RETURNS:
 534  * Number of FC hosts.
 535  * Return -1 if directory doesn't exist in sysfs.
 536  ***************************************************************************
 537  */
 538 __nr_t get_fchost_nr(void)
 539 {
 540         DIR *dir;
 541         struct dirent *drd;
 542         __nr_t fc = 0;
 543
 544         if ((dir = opendir(SYSFS_FCHOST)) == NULL) {
 545                 /* Directory non-existent */
 546                 return -1;
 547         }
 548
 549         while ((drd = readdir(dir)) != NULL) {
 550
 551                 if (!strncmp(drd->d_name, "host", 4)) {
 552                         fc++;
 553                 }
 554         }
 555
 556         /* Close directory */
 557         closedir(dir);
 558
 559         return fc;
 560 }
 561
 562 /*------------------ END: FUNCTIONS USED BY SADC ONLY ---------------------*/
 563 #endif /* SOURCE_SADC */