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

   1 /*
   2  * pcp_def_metrics.c: Funtions used by sadf to define PCP metrics
   3  * (C) 2019-2021 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 "common.h"
  23 #include "sa.h"
  24 #include "pcp_def_metrics.h"
  25
  26 #ifdef HAVE_PCP
  27 #include <pcp/pmapi.h>
  28 #include <pcp/import.h>
  29 #ifdef HAVE_PCP_IMPL_H
  30 #include <pcp/impl.h>
  31 #endif
  32 #endif /* HAVE_PCP */
  33
  34 /*
  35  ***************************************************************************
  36  * Define PCP metrics for CPU related statistics.
  37  *
  38  * IN:
  39  * @a           Activity structure with statistics.
  40  ***************************************************************************
  41  */
  42 void pcp_def_cpu_metrics(struct activity *a)
  43 {
  44 #ifdef HAVE_PCP
  45         int i, first = TRUE, create = FALSE;
  46         char buf[64];
  47         static pmInDom indom = PM_INDOM_NULL;
  48
  49         for (i = 0; (i < a->nr_ini) && (i < a->bitmap->b_size + 1); i++) {
  50
  51                 /*
  52                  * Should current CPU (including CPU "all") be displayed?
  53                  * NB: Offline not tested (they may be turned off and on within
  54                  * the same file.
  55                  */
  56                 if (!(a->bitmap->b_array[i >> 3] & (1 << (i & 0x07))))
  57                         /* CPU not selected */
  58                         continue;
  59
  60                 if (!i) {
  61                         if (a->id == A_CPU) {
  62                                 /* This is CPU "all" */
  63                                 pmiAddMetric("kernel.all.cpu.user",
  64                                              pmiID(60, 0, 20), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
  65                                              pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
  66
  67                                 pmiAddMetric("kernel.all.cpu.nice",
  68                                              pmiID(60, 0, 21), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
  69                                              pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
  70
  71                                 pmiAddMetric("kernel.all.cpu.sys",
  72                                              pmiID(60, 0, 22), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
  73                                              pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
  74
  75                                 pmiAddMetric("kernel.all.cpu.idle",
  76                                              pmiID(60, 0, 23), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
  77                                              pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
  78
  79                                 pmiAddMetric("kernel.all.cpu.wait.total",
  80                                              pmiID(60, 0, 25), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
  81                                              pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
  82
  83                                 pmiAddMetric("kernel.all.cpu.intr",
  84                                              pmiID(60, 0, 34), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
  85                                              pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
  86
  87                                 pmiAddMetric("kernel.all.cpu.steal",
  88                                              pmiID(60, 0, 55), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
  89                                              pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
  90
  91                                 pmiAddMetric("kernel.all.cpu.irq.hard",
  92                                              pmiID(60, 0, 54), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
  93                                              pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
  94
  95                                 pmiAddMetric("kernel.all.cpu.irq.soft",
  96                                              pmiID(60, 0, 53), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
  97                                              pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
  98
  99                                 pmiAddMetric("kernel.all.cpu.guest",
 100                                              pmiID(60, 0, 60), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 101                                              pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
 102
 103                                 pmiAddMetric("kernel.all.cpu.guest_nice",
 104                                              pmiID(60, 0, 81), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 105                                              pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
 106                         }
 107
 108                         else if (a->id == A_NET_SOFT) {
 109                                 /* Create metrics for a_NET_SOFT */
 110                                 pmiAddMetric("network.softnet.processed",
 111                                              pmiID(60, 57, 0), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 112                                              pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 113
 114                                 pmiAddMetric("network.softnet.dropped",
 115                                              pmiID(60, 57, 1), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 116                                              pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 117
 118                                 pmiAddMetric("network.softnet.time_squeeze",
 119                                              pmiID(60, 57, 2), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 120                                              pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 121
 122                                 pmiAddMetric("network.softnet.received_rps",
 123                                              pmiID(60, 57, 4), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 124                                              pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 125
 126                                 pmiAddMetric("network.softnet.flow_limit_count",
 127                                              pmiID(60, 57, 5), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 128                                              pmiUnits(0, -1, 1, 0, PM_TIME_SEC, PM_COUNT_ONE));
 129                         }
 130                 }
 131                 else {
 132                         /* This is not CPU "all" */
 133                         if (indom == PM_INDOM_NULL) {
 134                                 /* Create domain */
 135                                 indom = pmInDom_build(60, 0);
 136                                 create = TRUE;
 137                         }
 138                         if (create) {
 139                                 /* Create instance for current CPU */
 140                                 sprintf(buf, "cpu%d", i - 1);
 141                                 pmiAddInstance(indom, buf, i - 1);
 142                         }
 143
 144                         if (first) {
 145                                 if (a->id == A_CPU) {
 146                                         /* Create metrics for A_CPU */
 147                                         pmiAddMetric("kernel.percpu.cpu.user",
 148                                                      pmiID(60, 0, 0), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 149                                                      pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
 150
 151                                         pmiAddMetric("kernel.percpu.cpu.nice",
 152                                                      pmiID(60, 0, 1), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 153                                                      pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
 154
 155                                         pmiAddMetric("kernel.percpu.cpu.sys",
 156                                                      pmiID(60, 0, 2), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 157                                                      pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
 158
 159                                         pmiAddMetric("kernel.percpu.cpu.idle",
 160                                                      pmiID(60, 0, 3), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 161                                                      pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
 162
 163                                         pmiAddMetric("kernel.percpu.cpu.wait.total",
 164                                                      pmiID(60, 0, 30), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 165                                                      pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
 166
 167                                         pmiAddMetric("kernel.percpu.cpu.steal",
 168                                                      pmiID(60, 0, 58), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 169                                                      pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
 170
 171                                         pmiAddMetric("kernel.percpu.cpu.irq.hard",
 172                                                      pmiID(60, 0, 57), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 173                                                      pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
 174
 175                                         pmiAddMetric("kernel.percpu.cpu.irq.soft",
 176                                                      pmiID(60, 0, 56), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 177                                                      pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
 178
 179                                         pmiAddMetric("kernel.percpu.cpu.guest",
 180                                                      pmiID(60, 0, 61), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 181                                                      pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
 182
 183                                         pmiAddMetric("kernel.percpu.cpu.guest_nice",
 184                                                      pmiID(60, 0, 83), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 185                                                      pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
 186                                 }
 187
 188                                 else if (a->id == A_PWR_CPU) {
 189                                         /* Create metric for A_PWR_CPU */
 190                                         pmiAddMetric("hinv.cpu.clock",
 191                                                      pmiID(60, 18, 0), PM_TYPE_FLOAT, indom, PM_SEM_DISCRETE,
 192                                                      pmiUnits(0, -1, 0, 0, PM_TIME_USEC, 0));
 193                                 }
 194
 195                                 else if (a->id == A_NET_SOFT) {
 196                                         /* Create metrics for a_NET_SOFT */
 197                                         pmiAddMetric("network.softnet.percpu.processed",
 198                                                      pmiID(60, 57, 6), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 199                                                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 200
 201                                         pmiAddMetric("network.softnet.percpu.dropped",
 202                                                      pmiID(60, 57, 7), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 203                                                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 204
 205                                         pmiAddMetric("network.softnet.percpu.time_squeeze",
 206                                                      pmiID(60, 57, 8), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 207                                                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 208
 209                                         pmiAddMetric("network.softnet.percpu.received_rps",
 210                                                      pmiID(60, 57, 10), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 211                                                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 212
 213                                         pmiAddMetric("network.softnet.percpu.flow_limit_count",
 214                                                      pmiID(60, 57, 11), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 215                                                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 216                                 }
 217                                 first = FALSE;
 218                         }
 219                 }
 220         }
 221 #endif /* HAVE_PCP */
 222 }
 223
 224 /*
 225  ***************************************************************************
 226  * Define PCP metrics for task creation and context switch statistics.
 227  ***************************************************************************
 228  */
 229 void pcp_def_pcsw_metrics(void)
 230 {
 231 #ifdef HAVE_PCP
 232         pmiAddMetric("kernel.all.pswitch",
 233                      pmiID(60, 0, 13), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 234                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 235
 236         pmiAddMetric("kernel.all.sysfork",
 237                      pmiID(60, 0, 14), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 238                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 239 #endif /* HAVE_PCP */
 240 }
 241
 242 /*
 243  ***************************************************************************
 244  * Define PCP metrics for interrupts statistics.
 245  *
 246  * IN:
 247  * @a           Activity structure with statistics.
 248  ***************************************************************************
 249  */
 250 void pcp_def_irq_metrics(struct activity *a)
 251 {
 252 #ifdef HAVE_PCP
 253         int i, first = TRUE;
 254         char buf[64];
 255         pmInDom indom = pmiInDom(60, 4);
 256
 257         for (i = 0; (i < a->nr_ini) && (i < a->bitmap->b_size + 1); i++) {
 258
 259                 /* Should current interrupt (including int "sum") be displayed? */
 260                 if (a->bitmap->b_array[i >> 3] & (1 << (i & 0x07))) {
 261
 262                         if (!i) {
 263                                 /* Interrupt "sum" */
 264                                 pmiAddMetric("kernel.all.intr",
 265                                              pmiID(60, 0, 12), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 266                                              pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 267                         }
 268                         else {
 269                                 if (first) {
 270                                         pmiAddMetric("kernel.all.interrupts.total",
 271                                                      pmiID(60, 4, 0), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 272                                                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 273                                         first = FALSE;
 274                                 }
 275                                 sprintf(buf, "%d", i - 1);
 276                                 pmiAddInstance(indom, buf, i - 1);
 277                         }
 278                 }
 279         }
 280 #endif /* HAVE_PCP */
 281 }
 282
 283 /*
 284  ***************************************************************************
 285  * Define PCP metrics for swapping statistics.
 286  ***************************************************************************
 287  */
 288 void pcp_def_swap_metrics(void)
 289 {
 290 #ifdef HAVE_PCP
 291         pmiAddMetric("swap.pagesin",
 292                      pmiID(60, 0, 8), PM_TYPE_U32, PM_INDOM_NULL, PM_SEM_COUNTER,
 293                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 294
 295         pmiAddMetric("swap.pagesout",
 296                      pmiID(60, 0, 9), PM_TYPE_U32, PM_INDOM_NULL, PM_SEM_COUNTER,
 297                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 298 #endif /* HAVE_PCP */
 299 }
 300
 301 /*
 302  ***************************************************************************
 303  * Define PCP metrics for paging statistics.
 304  ***************************************************************************
 305  */
 306 void pcp_def_paging_metrics(void)
 307 {
 308 #ifdef HAVE_PCP
 309         pmiAddMetric("mem.vmstat.pgpgin",
 310                      pmiID(60, 28, 6), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 311                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 312
 313         pmiAddMetric("mem.vmstat.pgpgout",
 314                      pmiID(60, 28, 7), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 315                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 316
 317         pmiAddMetric("mem.vmstat.pgfault",
 318                      pmiID(60, 28, 16), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 319                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 320
 321         pmiAddMetric("mem.vmstat.pgmajfault",
 322                      pmiID(60, 28, 17), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 323                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 324
 325         pmiAddMetric("mem.vmstat.pgfree",
 326                      pmiID(60, 28, 13), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 327                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 328
 329         pmiAddMetric("mem.vmstat.pgscan_kswapd_total",
 330                      pmiID(60, 28, 177), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 331                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 332
 333         pmiAddMetric("mem.vmstat.pgscan_direct_total",
 334                      pmiID(60, 28, 176), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 335                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 336
 337         pmiAddMetric("mem.vmstat.pgsteal_total",
 338                      pmiID(60, 28, 178), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 339                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 340 #endif /* HAVE_PCP */
 341 }
 342
 343 /*
 344  ***************************************************************************
 345  * Define PCP metrics for I/O and transfer rate statistics.
 346  ***************************************************************************
 347  */
 348 void pcp_def_io_metrics(void)
 349 {
 350 #ifdef HAVE_PCP
 351         pmiAddMetric("disk.all.total",
 352                      pmiID(60, 0, 29), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 353                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 354
 355         pmiAddMetric("disk.all.read",
 356                      pmiID(60, 0, 24), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 357                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 358
 359         pmiAddMetric("disk.all.write",
 360                      pmiID(60, 0, 25), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 361                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 362
 363         pmiAddMetric("disk.all.discard",
 364                      pmiID(60, 0, 96), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 365                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 366
 367         pmiAddMetric("disk.all.read_bytes",
 368                      pmiID(60, 0, 41), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 369                      pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
 370
 371         pmiAddMetric("disk.all.write_bytes",
 372                      pmiID(60, 0, 42), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 373                      pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
 374
 375         pmiAddMetric("disk.all.discard_bytes",
 376                      pmiID(60, 0, 98), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 377                      pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
 378 #endif /* HAVE_PCP */
 379 }
 380
 381 /*
 382  ***************************************************************************
 383  * Define PCP metrics for memory statistics.
 384  *
 385  * IN:
 386  * @a           Activity structure with statistics.
 387  ***************************************************************************
 388  */
 389 void pcp_def_memory_metrics(struct activity *a)
 390 {
 391 #ifdef HAVE_PCP
 392         if (DISPLAY_MEMORY(a->opt_flags)) {
 393
 394                 pmiAddMetric("hinv.physmem",
 395                              pmiID(60, 1, 9), PM_TYPE_U32, PM_INDOM_NULL, PM_SEM_DISCRETE,
 396                              pmiUnits(1, 0, 0, PM_SPACE_MBYTE, 0, 0));
 397
 398                 pmiAddMetric("mem.physmem",
 399                              pmiID(60, 1, 0), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_DISCRETE,
 400                              pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
 401
 402                 pmiAddMetric("mem.util.free",
 403                              pmiID(60, 1, 2), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 404                              pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
 405
 406                 pmiAddMetric("mem.util.available",
 407                              pmiID(60, 1, 58), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 408                              pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
 409
 410                 pmiAddMetric("mem.util.used",
 411                              pmiID(60, 1, 1), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 412                              pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
 413
 414                 pmiAddMetric("mem.util.bufmem",
 415                              pmiID(60, 1, 4), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 416                              pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
 417
 418                 pmiAddMetric("mem.util.cached",
 419                              pmiID(60, 1, 5), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 420                              pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
 421
 422                 pmiAddMetric("mem.util.committed_AS",
 423                              pmiID(60, 1, 26), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 424                              pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
 425
 426                 pmiAddMetric("mem.util.active",
 427                              pmiID(60, 1, 14), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 428                              pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
 429
 430                 pmiAddMetric("mem.util.inactive",
 431                              pmiID(60, 1, 15), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 432                              pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
 433
 434                 pmiAddMetric("mem.util.dirty",
 435                              pmiID(60, 1, 22), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 436                              pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
 437
 438                 if (DISPLAY_MEM_ALL(a->opt_flags)) {
 439
 440                         pmiAddMetric("mem.util.anonpages",
 441                                      pmiID(60, 1, 30), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 442                                      pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
 443
 444                         pmiAddMetric("mem.util.slab",
 445                                      pmiID(60, 1, 25), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 446                                      pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
 447
 448                         pmiAddMetric("mem.util.kernelStack",
 449                                      pmiID(60, 1, 43), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 450                                      pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
 451
 452                         pmiAddMetric("mem.util.pageTables",
 453                                      pmiID(60, 1, 27), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 454                                      pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
 455
 456                         pmiAddMetric("mem.util.vmallocUsed",
 457                                      pmiID(60, 1, 51), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 458                                      pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
 459                 }
 460         }
 461
 462         if (DISPLAY_SWAP(a->opt_flags)) {
 463
 464                 pmiAddMetric("mem.util.swapFree",
 465                              pmiID(60, 1, 21), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 466                              pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
 467
 468                 pmiAddMetric("mem.util.swapTotal",
 469                              pmiID(60, 1, 20), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 470                              pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
 471
 472                 pmiAddMetric("mem.util.swapCached",
 473                              pmiID(60, 1, 13), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 474                              pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
 475         }
 476 #endif /* HAVE_PCP */
 477 }
 478
 479 /*
 480  ***************************************************************************
 481  * Define PCP metrics for kernel tables statistics.
 482  ***************************************************************************
 483  */
 484 void pcp_def_ktables_metrics(void)
 485 {
 486 #ifdef HAVE_PCP
 487         pmiAddMetric("vfs.dentry.count",
 488                      pmiID(60, 27, 5), PM_TYPE_32, PM_INDOM_NULL, PM_SEM_INSTANT,
 489                      pmiUnits(0, 0, 0, 0, 0, 0));
 490
 491         pmiAddMetric("vfs.files.count",
 492                      pmiID(60, 27, 0), PM_TYPE_32, PM_INDOM_NULL, PM_SEM_INSTANT,
 493                      pmiUnits(0, 0, 0, 0, 0, 0));
 494
 495         pmiAddMetric("vfs.inodes.count",
 496                      pmiID(60, 27, 3), PM_TYPE_32, PM_INDOM_NULL, PM_SEM_INSTANT,
 497                      pmiUnits(0, 0, 0, 0, 0, 0));
 498
 499         pmiAddMetric("kernel.all.nptys",
 500                      pmiID(60, 72, 3), PM_TYPE_U32, PM_INDOM_NULL, PM_SEM_INSTANT,
 501                      pmiUnits(0, 0, 0, 0, 0, 0));
 502 #endif /* HAVE_PCP */
 503 }
 504
 505 /*
 506  ***************************************************************************
 507  * Define PCP metrics for queue and load statistics.
 508  ***************************************************************************
 509  */
 510 void pcp_def_queue_metrics(void)
 511 {
 512 #ifdef HAVE_PCP
 513         pmInDom indom;
 514
 515         pmiAddMetric("kernel.all.runnable",
 516                      pmiID(60, 2, 2), PM_TYPE_U32, PM_INDOM_NULL, PM_SEM_INSTANT,
 517                      pmiUnits(0, 0, 0, 0, 0, 0));
 518
 519         pmiAddMetric("kernel.all.nprocs",
 520                      pmiID(60, 2, 3), PM_TYPE_U32, PM_INDOM_NULL, PM_SEM_INSTANT,
 521                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 522
 523         pmiAddMetric("kernel.all.blocked",
 524                      pmiID(60, 0, 16), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
 525                      pmiUnits(0, 0, 0, 0, 0, 0));
 526
 527         indom = pmiInDom(60, 2);
 528         pmiAddMetric("kernel.all.load",
 529                      pmiID(60, 2, 0), PM_TYPE_FLOAT, indom, PM_SEM_INSTANT,
 530                      pmiUnits(0, 0, 0, 0, 0, 0));
 531         pmiAddInstance(indom, "1 minute", 1);
 532         pmiAddInstance(indom, "5 minute", 5);
 533         pmiAddInstance(indom, "15 minute", 15);
 534 #endif /* HAVE_PCP */
 535 }
 536
 537 /*
 538  ***************************************************************************
 539  * Define PCP metrics for disks statistics.
 540  *
 541  * IN:
 542  * @a           Activity structure with statistics.
 543  ***************************************************************************
 544  */
 545 void pcp_def_disk_metrics(struct activity *a)
 546 {
 547 #ifdef HAVE_PCP
 548         int inst = 0;
 549         static pmInDom indom = PM_INDOM_NULL;
 550         struct sa_item *list = a->item_list;
 551
 552         if (indom == PM_INDOM_NULL) {
 553                 /* Create domain */
 554                 indom = pmInDom_build(60, 1);
 555
 556                 /* Create instances */
 557                 while (list != NULL) {
 558                         pmiAddInstance(indom, list->item_name, inst++);
 559                         list = list->next;
 560                 }
 561         }
 562
 563         pmiAddMetric("disk.dev.read",
 564                      pmiID(60, 0, 4), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 565                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 566
 567         pmiAddMetric("disk.dev.write",
 568                      pmiID(60, 0, 5), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 569                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 570
 571         pmiAddMetric("disk.dev.total",
 572                      pmiID(60, 0, 28), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 573                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 574
 575         pmiAddMetric("disk.dev.read_bytes",
 576                      pmiID(60, 0, 38), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 577                      pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
 578
 579         pmiAddMetric("disk.dev.write_bytes",
 580                      pmiID(60, 0, 39), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 581                      pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
 582
 583         pmiAddMetric("disk.dev.discard_bytes",
 584                      pmiID(60, 0, 90), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 585                      pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
 586
 587         pmiAddMetric("disk.dev.read_rawactive",
 588                      pmiID(60, 0, 72), PM_TYPE_U32, indom, PM_SEM_COUNTER,
 589                      pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
 590
 591         pmiAddMetric("disk.dev.write_rawactive",
 592                      pmiID(60, 0, 73), PM_TYPE_U32, indom, PM_SEM_COUNTER,
 593                      pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
 594
 595         pmiAddMetric("disk.dev.total_rawactive",
 596                      pmiID(60, 0, 79), PM_TYPE_U32, indom, PM_SEM_COUNTER,
 597                      pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
 598
 599         pmiAddMetric("disk.dev.discard_rawactive",
 600                      pmiID(60, 0, 92), PM_TYPE_U32, indom, PM_SEM_COUNTER,
 601                      pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
 602
 603         pmiAddMetric("disk.dev.avactive",
 604                      pmiID(60, 0, 46), PM_TYPE_U32, indom, PM_SEM_COUNTER,
 605                      pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
 606
 607         pmiAddMetric("disk.dev.aveq",
 608                      pmiID(60, 0, 47), PM_TYPE_U32, indom, PM_SEM_COUNTER,
 609                      pmiUnits(0, 1, 0, 0, PM_TIME_MSEC, 0));
 610 #endif /* HAVE_PCP */
 611 }
 612
 613 /*
 614  ***************************************************************************
 615  * Define PCP metrics for network interfaces (errors) statistics.
 616  *
 617  * IN:
 618  * @a           Activity structure with statistics.
 619  ***************************************************************************
 620  */
 621 void pcp_def_net_dev_metrics(struct activity *a)
 622 {
 623 #ifdef HAVE_PCP
 624         int inst = 0;
 625         static pmInDom indom = PM_INDOM_NULL;
 626         struct sa_item *list = a->item_list;
 627
 628         if (indom == PM_INDOM_NULL) {
 629                 /* Create domain */
 630                 indom = pmInDom_build(60, 3);
 631
 632                 /* Create instances */
 633                 while (list != NULL) {
 634                         pmiAddInstance(indom, list->item_name, inst++);
 635                         list = list->next;
 636                 }
 637         }
 638
 639         if (a->id == A_NET_DEV) {
 640                 /* Create metrics for A_NET_DEV */
 641                 pmiAddMetric("network.interface.in.packets",
 642                              pmiID(60, 3, 1), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 643                              pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 644
 645                 pmiAddMetric("network.interface.out.packets",
 646                              pmiID(60, 3, 9), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 647                              pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 648
 649                 pmiAddMetric("network.interface.in.bytes",
 650                              pmiID(60, 3, 0), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 651                              pmiUnits(1, 0, 0, PM_SPACE_BYTE, 0, 0));
 652
 653                 pmiAddMetric("network.interface.out.bytes",
 654                              pmiID(60, 3, 8), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 655                              pmiUnits(1, 0, 0, PM_SPACE_BYTE, 0, 0));
 656
 657                 pmiAddMetric("network.interface.in.compressed",
 658                              pmiID(60, 3, 6), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 659                              pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 660
 661                 pmiAddMetric("network.interface.out.compressed",
 662                              pmiID(60, 3, 15), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 663                              pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 664
 665                 pmiAddMetric("network.interface.in.mcasts",
 666                              pmiID(60, 3, 7), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 667                              pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 668         }
 669         else {
 670                 /* Create metrics for A_NET_EDEV */
 671                 pmiAddMetric("network.interface.in.errors",
 672                              pmiID(60, 3, 2), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 673                              pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 674
 675                 pmiAddMetric("network.interface.out.errors",
 676                              pmiID(60, 3, 10), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 677                              pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 678
 679                 pmiAddMetric("network.interface.collisions",
 680                              pmiID(60, 3, 13), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 681                              pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 682
 683                 pmiAddMetric("network.interface.in.drops",
 684                              pmiID(60, 3, 3), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 685                              pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 686
 687                 pmiAddMetric("network.interface.out.drops",
 688                              pmiID(60, 3, 11), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 689                              pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 690
 691                 pmiAddMetric("network.interface.out.carrier",
 692                              pmiID(60, 3, 14), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 693                              pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 694
 695                 pmiAddMetric("network.interface.in.frame",
 696                              pmiID(60, 3, 5), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 697                              pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 698
 699                 pmiAddMetric("network.interface.in.fifo",
 700                              pmiID(60, 3, 4), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 701                              pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 702
 703                 pmiAddMetric("network.interface.out.fifo",
 704                              pmiID(60, 3, 12), PM_TYPE_U64, indom, PM_SEM_COUNTER,
 705                              pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 706         }
 707 #endif /* HAVE_PCP */
 708 }
 709
 710 /*
 711  ***************************************************************************
 712  * Define PCP metrics for serial lines statistics.
 713  *
 714  * IN:
 715  * @a           Activity structure with statistics.
 716  ***************************************************************************
 717  */
 718 void pcp_def_serial_metrics(struct activity *a)
 719 {
 720 #ifdef HAVE_PCP
 721         int i;
 722         pmInDom indom;
 723         char buf[64];
 724
 725         /* Create domain */
 726         indom = pmInDom_build(60, 35);
 727
 728         /* Create metrics */
 729         pmiAddMetric("tty.serial.rx",
 730                      pmiID(60, 74, 0), PM_TYPE_U32, indom, PM_SEM_COUNTER,
 731                      pmiUnits(0, 0, 0, 0, 0, 0));
 732
 733         pmiAddMetric("tty.serial.tx",
 734                      pmiID(60, 74, 1), PM_TYPE_U32, indom, PM_SEM_COUNTER,
 735                      pmiUnits(0, 0, 0, 0, 0, 0));
 736
 737         pmiAddMetric("tty.serial.frame",
 738                      pmiID(60, 74, 2), PM_TYPE_U32, indom, PM_SEM_COUNTER,
 739                      pmiUnits(0, 0, 0, 0, 0, 0));
 740
 741         pmiAddMetric("tty.serial.parity",
 742                      pmiID(60, 74, 3), PM_TYPE_U32, indom, PM_SEM_COUNTER,
 743                      pmiUnits(0, 0, 0, 0, 0, 0));
 744
 745         pmiAddMetric("tty.serial.brk",
 746                      pmiID(60, 74, 4), PM_TYPE_U32, indom, PM_SEM_COUNTER,
 747                      pmiUnits(0, 0, 0, 0, 0, 0));
 748
 749         pmiAddMetric("tty.serial.overrun",
 750                      pmiID(60, 74, 5), PM_TYPE_U32, indom, PM_SEM_COUNTER,
 751                      pmiUnits(0, 0, 0, 0, 0, 0));
 752
 753         for (i = 0; i < a->nr_ini; i++) {
 754                 /* Create instances */
 755                 sprintf(buf, "serial%d", i);
 756                 pmiAddInstance(indom, buf, i);
 757         }
 758 #endif /* HAVE_PCP */
 759 }
 760
 761 /*
 762  ***************************************************************************
 763  * Define PCP metrics for NFS client statistics.
 764  ***************************************************************************
 765  */
 766 void pcp_def_net_nfs_metrics(void)
 767 {
 768 #ifdef HAVE_PCP
 769         pmInDom indom;
 770
 771         pmiAddMetric("rpc.client.rpccnt",
 772                      pmiID(60, 7, 20), PM_TYPE_U32, PM_INDOM_NULL, PM_SEM_COUNTER,
 773                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 774
 775         pmiAddMetric("rpc.client.rpcretrans",
 776                      pmiID(60, 7, 21), PM_TYPE_U32, PM_INDOM_NULL, PM_SEM_COUNTER,
 777                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 778
 779         indom = pmiInDom(60, 7);
 780         pmiAddInstance(indom, "read", 6);
 781         pmiAddInstance(indom, "write", 8);
 782         pmiAddInstance(indom, "access", 18);
 783         pmiAddInstance(indom, "lookup", 4);
 784
 785         pmiAddMetric("nfs.client.reqs",
 786                      pmiID(60, 7, 4), PM_TYPE_U32, indom, PM_SEM_COUNTER,
 787                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 788 #endif /* HAVE_PCP */
 789 }
 790
 791 /*
 792  ***************************************************************************
 793  * Define PCP metrics for NFS server statistics.
 794  ***************************************************************************
 795  */
 796 void pcp_def_net_nfsd_metrics(void)
 797 {
 798 #ifdef HAVE_PCP
 799         pmInDom indom;
 800
 801         pmiAddMetric("rpc.server.rpccnt",
 802                      pmiID(60, 7, 30), PM_TYPE_U32, PM_INDOM_NULL, PM_SEM_COUNTER,
 803                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 804
 805         pmiAddMetric("rpc.server.rpcbadclnt",
 806                      pmiID(60, 7, 34), PM_TYPE_U32, PM_INDOM_NULL, PM_SEM_COUNTER,
 807                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 808
 809         pmiAddMetric("rpc.server.netcnt",
 810                      pmiID(60, 7, 44), PM_TYPE_U32, PM_INDOM_NULL, PM_SEM_COUNTER,
 811                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 812
 813         pmiAddMetric("rpc.server.netudpcnt",
 814                      pmiID(60, 7, 45), PM_TYPE_U32, PM_INDOM_NULL, PM_SEM_COUNTER,
 815                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 816
 817         pmiAddMetric("rpc.server.nettcpcnt",
 818                      pmiID(60, 7, 46), PM_TYPE_U32, PM_INDOM_NULL, PM_SEM_COUNTER,
 819                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 820
 821         pmiAddMetric("rpc.server.rchits",
 822                      pmiID(60, 7, 35), PM_TYPE_U32, PM_INDOM_NULL, PM_SEM_COUNTER,
 823                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 824
 825         pmiAddMetric("rpc.server.rcmisses",
 826                      pmiID(60, 7, 36), PM_TYPE_U32, PM_INDOM_NULL, PM_SEM_COUNTER,
 827                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 828
 829         indom = pmiInDom(60, 7);
 830         pmiAddInstance(indom, "read", 6);
 831         pmiAddInstance(indom, "write", 8);
 832         pmiAddInstance(indom, "access", 18);
 833         pmiAddInstance(indom, "lookup", 4);
 834
 835         pmiAddMetric("nfs.server.reqs",
 836                      pmiID(60, 7, 12), PM_TYPE_U32, indom, PM_SEM_COUNTER,
 837                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 838 #endif /* HAVE_PCP */
 839 }
 840
 841 /*
 842  ***************************************************************************
 843  * Define PCP metrics for network sockets statistics.
 844  ***************************************************************************
 845  */
 846 void pcp_def_net_sock_metrics(void)
 847 {
 848 #ifdef HAVE_PCP
 849         pmiAddMetric("network.sockstat.total",
 850                      pmiID(60, 11, 9), PM_TYPE_32, PM_INDOM_NULL, PM_SEM_INSTANT,
 851                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 852
 853         pmiAddMetric("network.sockstat.tcp.inuse",
 854                      pmiID(60, 11, 0), PM_TYPE_32, PM_INDOM_NULL, PM_SEM_INSTANT,
 855                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 856
 857         pmiAddMetric("network.sockstat.udp.inuse",
 858                      pmiID(60, 11, 3), PM_TYPE_32, PM_INDOM_NULL, PM_SEM_INSTANT,
 859                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 860
 861         pmiAddMetric("network.sockstat.raw.inuse",
 862                      pmiID(60, 11, 6), PM_TYPE_32, PM_INDOM_NULL, PM_SEM_INSTANT,
 863                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 864
 865         pmiAddMetric("network.sockstat.frag.inuse",
 866                      pmiID(60, 11, 15), PM_TYPE_32, PM_INDOM_NULL, PM_SEM_INSTANT,
 867                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 868
 869         pmiAddMetric("network.sockstat.tcp.tw",
 870                      pmiID(60, 11, 11), PM_TYPE_32, PM_INDOM_NULL, PM_SEM_INSTANT,
 871                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 872 #endif /* HAVE_PCP */
 873 }
 874
 875 /*
 876  ***************************************************************************
 877  * Define PCP metrics for IP network statistics.
 878  ***************************************************************************
 879  */
 880 void pcp_def_net_ip_metrics(void)
 881 {
 882 #ifdef HAVE_PCP
 883         pmiAddMetric("network.ip.inreceives",
 884                      pmiID(60, 14, 2), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 885                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 886
 887         pmiAddMetric("network.ip.forwdatagrams",
 888                      pmiID(60, 14, 5), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 889                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 890
 891         pmiAddMetric("network.ip.indelivers",
 892                      pmiID(60, 14, 8), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 893                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 894
 895         pmiAddMetric("network.ip.ipoutrequests",
 896                      pmiID(60, 14, 9), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 897                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 898
 899         pmiAddMetric("network.ip.ipreasmreqds",
 900                      pmiID(60, 14, 13), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 901                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 902
 903         pmiAddMetric("network.ip.ipreasmoks",
 904                      pmiID(60, 14, 14), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 905                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 906
 907         pmiAddMetric("network.ip.fragoks",
 908                      pmiID(60, 14, 16), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 909                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 910
 911         pmiAddMetric("network.ip.fragcreates",
 912                      pmiID(60, 14, 18), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 913                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 914 #endif /* HAVE_PCP */
 915 }
 916
 917 /*
 918  ***************************************************************************
 919  * Define PCP metrics for IP network errors statistics.
 920  ***************************************************************************
 921  */
 922 void pcp_def_net_eip_metrics(void)
 923 {
 924 #ifdef HAVE_PCP
 925         pmiAddMetric("network.ip.inhdrerrors",
 926                      pmiID(60, 14, 3), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 927                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 928
 929         pmiAddMetric("network.ip.inaddrerrors",
 930                      pmiID(60, 14, 4), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 931                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 932
 933         pmiAddMetric("network.ip.inunknownprotos",
 934                      pmiID(60, 14, 6), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 935                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 936
 937         pmiAddMetric("network.ip.indiscards",
 938                      pmiID(60, 14, 7), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 939                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 940
 941         pmiAddMetric("network.ip.outdiscards",
 942                      pmiID(60, 14, 10), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 943                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 944
 945         pmiAddMetric("network.ip.outnoroutes",
 946                      pmiID(60, 14, 11), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 947                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 948
 949         pmiAddMetric("network.ip.reasmfails",
 950                      pmiID(60, 14, 15), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 951                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 952
 953         pmiAddMetric("network.ip.fragfails",
 954                      pmiID(60, 14, 17), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 955                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 956 #endif /* HAVE_PCP */
 957 }
 958
 959 /*
 960  ***************************************************************************
 961  * Define PCP metrics for ICMP network statistics.
 962  ***************************************************************************
 963  */
 964 void pcp_def_net_icmp_metrics(void)
 965 {
 966 #ifdef HAVE_PCP
 967         pmiAddMetric("network.icmp.inmsgs",
 968                      pmiID(60, 14, 20), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 969                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 970
 971         pmiAddMetric("network.icmp.outmsgs",
 972                      pmiID(60, 14, 33), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 973                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 974
 975         pmiAddMetric("network.icmp.inechos",
 976                      pmiID(60, 14, 27), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 977                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 978
 979         pmiAddMetric("network.icmp.inechoreps",
 980                      pmiID(60, 14, 28), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 981                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 982
 983         pmiAddMetric("network.icmp.outechos",
 984                      pmiID(60, 14, 40), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 985                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 986
 987         pmiAddMetric("network.icmp.outechoreps",
 988                      pmiID(60, 14, 41), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 989                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 990
 991         pmiAddMetric("network.icmp.intimestamps",
 992                      pmiID(60, 14, 29), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 993                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 994
 995         pmiAddMetric("network.icmp.intimestampreps",
 996                      pmiID(60, 14, 30), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
 997                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
 998
 999         pmiAddMetric("network.icmp.outtimestamps",
1000                      pmiID(60, 14, 42), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1001                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1002
1003         pmiAddMetric("network.icmp.outtimestampreps",
1004                      pmiID(60, 14, 43), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1005                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1006
1007         pmiAddMetric("network.icmp.inaddrmasks",
1008                      pmiID(60, 14, 31), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1009                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1010
1011         pmiAddMetric("network.icmp.inaddrmaskreps",
1012                      pmiID(60, 14, 32), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1013                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1014
1015         pmiAddMetric("network.icmp.outaddrmasks",
1016                      pmiID(60, 14, 44), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1017                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1018
1019         pmiAddMetric("network.icmp.outaddrmaskreps",
1020                      pmiID(60, 14, 45), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1021                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1022 #endif /* HAVE_PCP */
1023 }
1024
1025 /*
1026  ***************************************************************************
1027  * Define PCP metrics for ICMP network errors statistics.
1028  ***************************************************************************
1029  */
1030 void pcp_def_net_eicmp_metrics(void)
1031 {
1032 #ifdef HAVE_PCP
1033         pmiAddMetric("network.icmp.inerrors",
1034                      pmiID(60, 14, 21), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1035                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1036
1037         pmiAddMetric("network.icmp.outerrors",
1038                      pmiID(60, 14, 34), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1039                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1040
1041         pmiAddMetric("network.icmp.indestunreachs",
1042                      pmiID(60, 14, 22), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1043                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1044
1045         pmiAddMetric("network.icmp.outdestunreachs",
1046                      pmiID(60, 14, 35), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1047                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1048
1049         pmiAddMetric("network.icmp.intimeexcds",
1050                      pmiID(60, 14, 23), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1051                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1052
1053         pmiAddMetric("network.icmp.outtimeexcds",
1054                      pmiID(60, 14, 36), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1055                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1056
1057         pmiAddMetric("network.icmp.inparmprobs",
1058                      pmiID(60, 14, 24), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1059                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1060
1061         pmiAddMetric("network.icmp.outparmprobs",
1062                      pmiID(60, 14, 37), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1063                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1064
1065         pmiAddMetric("network.icmp.insrcquenchs",
1066                      pmiID(60, 14, 25), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1067                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1068
1069         pmiAddMetric("network.icmp.outsrcquenchs",
1070                      pmiID(60, 14, 38), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1071                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1072
1073         pmiAddMetric("network.icmp.inredirects",
1074                      pmiID(60, 14, 27), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1075                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1076
1077         pmiAddMetric("network.icmp.outredirects",
1078                      pmiID(60, 14, 39), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1079                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1080 #endif /* HAVE_PCP */
1081 }
1082
1083 /*
1084  ***************************************************************************
1085  * Define PCP metrics for TCP network statistics.
1086  ***************************************************************************
1087  */
1088 void pcp_def_net_tcp_metrics(void)
1089 {
1090 #ifdef HAVE_PCP
1091         pmiAddMetric("network.tcp.activeopens",
1092                      pmiID(60, 14, 54), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1093                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1094
1095         pmiAddMetric("network.tcp.passiveopens",
1096                      pmiID(60, 14, 55), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1097                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1098
1099         pmiAddMetric("network.tcp.insegs",
1100                      pmiID(60, 14, 59), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1101                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1102
1103         pmiAddMetric("network.tcp.outsegs",
1104                      pmiID(60, 14, 60), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1105                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1106 #endif /* HAVE_PCP */
1107 }
1108
1109 /*
1110  ***************************************************************************
1111  * Define PCP metrics for TCP network errors statistics.
1112  ***************************************************************************
1113  */
1114 void pcp_def_net_etcp_metrics(void)
1115 {
1116 #ifdef HAVE_PCP
1117         pmiAddMetric("network.tcp.attemptfails",
1118                      pmiID(60, 14, 56), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1119                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1120
1121         pmiAddMetric("network.tcp.estabresets",
1122                      pmiID(60, 14, 57), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1123                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1124
1125         pmiAddMetric("network.tcp.retranssegs",
1126                      pmiID(60, 14, 61), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1127                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1128
1129         pmiAddMetric("network.tcp.inerrs",
1130                      pmiID(60, 14, 62), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1131                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1132
1133         pmiAddMetric("network.tcp.outrsts",
1134                      pmiID(60, 14, 63), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1135                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1136 #endif /* HAVE_PCP */
1137 }
1138
1139 /*
1140  ***************************************************************************
1141  * Define PCP metrics for UDP network statistics.
1142  ***************************************************************************
1143  */
1144 void pcp_def_net_udp_metrics(void)
1145 {
1146 #ifdef HAVE_PCP
1147         pmiAddMetric("network.udp.indatagrams",
1148                      pmiID(60, 14, 70), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1149                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1150
1151         pmiAddMetric("network.udp.outdatagrams",
1152                      pmiID(60, 14, 74), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1153                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1154
1155         pmiAddMetric("network.udp.noports",
1156                      pmiID(60, 14, 71), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1157                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1158
1159         pmiAddMetric("network.udp.inerrors",
1160                      pmiID(60, 14, 72), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1161                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1162 #endif /* HAVE_PCP */
1163 }
1164
1165 /*
1166  ***************************************************************************
1167  * Define PCP metrics for IPv6 network sockets statistics.
1168  ***************************************************************************
1169  */
1170 void pcp_def_net_sock6_metrics(void)
1171 {
1172 #ifdef HAVE_PCP
1173         pmiAddMetric("network.sockstat.tcp6.inuse",
1174                      pmiID(60, 73, 0), PM_TYPE_32, PM_INDOM_NULL, PM_SEM_INSTANT,
1175                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1176
1177         pmiAddMetric("network.sockstat.udp6.inuse",
1178                      pmiID(60, 73, 1), PM_TYPE_32, PM_INDOM_NULL, PM_SEM_INSTANT,
1179                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1180
1181         pmiAddMetric("network.sockstat.raw6.inuse",
1182                      pmiID(60, 73, 3), PM_TYPE_32, PM_INDOM_NULL, PM_SEM_INSTANT,
1183                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1184
1185         pmiAddMetric("network.sockstat.frag6.inuse",
1186                      pmiID(60, 73, 4), PM_TYPE_32, PM_INDOM_NULL, PM_SEM_INSTANT,
1187                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1188 #endif /* HAVE_PCP */
1189 }
1190
1191 /*
1192  ***************************************************************************
1193  * Define PCP metrics for IPv6 network statistics.
1194  ***************************************************************************
1195  */
1196 void pcp_def_net_ip6_metrics(void)
1197 {
1198 #ifdef HAVE_PCP
1199         pmiAddMetric("network.ip6.inreceives",
1200                      pmiID(60, 58, 0), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1201                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1202
1203         pmiAddMetric("network.ip6.outforwdatagrams",
1204                      pmiID(60, 58, 9), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1205                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1206
1207         pmiAddMetric("network.ip6.indelivers",
1208                      pmiID(60, 58, 8), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1209                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1210
1211         pmiAddMetric("network.ip6.outrequests",
1212                      pmiID(60, 58, 10), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1213                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1214
1215         pmiAddMetric("network.ip6.reasmreqds",
1216                      pmiID(60, 58, 14), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1217                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1218
1219         pmiAddMetric("network.ip6.reasmoks",
1220                      pmiID(60, 58, 15), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1221                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1222
1223         pmiAddMetric("network.ip6.inmcastpkts",
1224                      pmiID(60, 58, 20), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1225                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1226
1227         pmiAddMetric("network.ip6.outmcastpkts",
1228                      pmiID(60, 58, 21), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1229                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1230
1231         pmiAddMetric("network.ip6.fragoks",
1232                      pmiID(60, 58, 17), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1233                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1234
1235         pmiAddMetric("network.ip6.fragcreates",
1236                      pmiID(60, 58, 19), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1237                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1238 #endif /* HAVE_PCP */
1239 }
1240
1241 /*
1242  ***************************************************************************
1243  * Define PCP metrics for IPv6 network errors statistics.
1244  ***************************************************************************
1245  */
1246 void pcp_def_net_eip6_metrics(void)
1247 {
1248 #ifdef HAVE_PCP
1249         pmiAddMetric("network.ip6.inhdrerrors",
1250                      pmiID(60, 58, 1), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1251                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1252
1253         pmiAddMetric("network.ip6.inaddrerrors",
1254                      pmiID(60, 58, 4), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1255                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1256
1257         pmiAddMetric("network.ip6.inunknownprotos",
1258                      pmiID(60, 58, 5), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1259                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1260
1261         pmiAddMetric("network.ip6.intoobigerrors",
1262                      pmiID(60, 58, 2), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1263                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1264
1265         pmiAddMetric("network.ip6.indiscards",
1266                      pmiID(60, 58, 7), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1267                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1268
1269         pmiAddMetric("network.ip6.outdiscards",
1270                      pmiID(60, 58, 11), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1271                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1272
1273         pmiAddMetric("network.ip6.innoroutes",
1274                      pmiID(60, 58, 3), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1275                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1276
1277         pmiAddMetric("network.ip6.outnoroutes",
1278                      pmiID(60, 58, 12), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1279                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1280
1281         pmiAddMetric("network.ip6.reasmfails",
1282                      pmiID(60, 58, 16), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1283                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1284
1285         pmiAddMetric("network.ip6.fragfails",
1286                      pmiID(60, 58, 18), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1287                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1288
1289         pmiAddMetric("network.ip6.intruncatedpkts",
1290                      pmiID(60, 58, 6), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1291                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1292 #endif /* HAVE_PCP */
1293 }
1294
1295 /*
1296  ***************************************************************************
1297  * Define PCP metrics for ICMPv6 network statistics.
1298  ***************************************************************************
1299  */
1300 void pcp_def_net_icmp6_metrics(void)
1301 {
1302 #ifdef HAVE_PCP
1303         pmiAddMetric("network.icmp6.inmsgs",
1304                      pmiID(60, 58, 32), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1305                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1306
1307         pmiAddMetric("network.icmp6.outmsgs",
1308                      pmiID(60, 58, 34), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1309                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1310
1311         pmiAddMetric("network.icmp6.inechos",
1312                      pmiID(60, 58, 41), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1313                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1314
1315         pmiAddMetric("network.icmp6.inechoreplies",
1316                      pmiID(60, 58, 42), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1317                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1318
1319         pmiAddMetric("network.icmp6.outechoreplies",
1320                      pmiID(60, 58, 57), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1321                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1322
1323         pmiAddMetric("network.icmp6.ingroupmembqueries",
1324                      pmiID(60, 58, 43), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1325                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1326
1327         pmiAddMetric("network.icmp6.ingroupmembresponses",
1328                      pmiID(60, 58, 44), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1329                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1330
1331         pmiAddMetric("network.icmp6.outgroupmembresponses",
1332                      pmiID(60, 58, 59), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1333                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1334
1335         pmiAddMetric("network.icmp6.ingroupmembreductions",
1336                      pmiID(60, 58, 45), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1337                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1338
1339         pmiAddMetric("network.icmp6.outgroupmembreductions",
1340                      pmiID(60, 58, 60), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1341                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1342
1343         pmiAddMetric("network.icmp6.inroutersolicits",
1344                      pmiID(60, 58, 46), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1345                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1346
1347         pmiAddMetric("network.icmp6.outroutersolicits",
1348                      pmiID(60, 58, 61), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1349                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1350
1351         pmiAddMetric("network.icmp6.inrouteradvertisements",
1352                      pmiID(60, 58, 47), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1353                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1354
1355         pmiAddMetric("network.icmp6.inneighborsolicits",
1356                      pmiID(60, 58, 48), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1357                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1358
1359         pmiAddMetric("network.icmp6.outneighborsolicits",
1360                      pmiID(60, 58, 63), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1361                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1362
1363         pmiAddMetric("network.icmp6.inneighboradvertisements",
1364                      pmiID(60, 58, 49), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1365                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1366
1367         pmiAddMetric("network.icmp6.outneighboradvertisements",
1368                      pmiID(60, 58, 64), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1369                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1370 #endif /* HAVE_PCP */
1371 }
1372
1373 /*
1374  ***************************************************************************
1375  * Define PCP metrics for ICMPv6 network errors statistics.
1376  ***************************************************************************
1377  */
1378 void pcp_def_net_eicmp6_metrics(void)
1379 {
1380 #ifdef HAVE_PCP
1381         pmiAddMetric("network.icmp6.inerrors",
1382                      pmiID(60, 58, 33), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1383                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1384
1385         pmiAddMetric("network.icmp6.indestunreachs",
1386                      pmiID(60, 58, 37), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1387                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1388
1389         pmiAddMetric("network.icmp6.outdestunreachs",
1390                      pmiID(60, 58, 52), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1391                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1392
1393         pmiAddMetric("network.icmp6.intimeexcds",
1394                      pmiID(60, 58, 39), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1395                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1396
1397         pmiAddMetric("network.icmp6.outtimeexcds",
1398                      pmiID(60, 58, 54), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1399                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1400
1401         pmiAddMetric("network.icmp6.inparmproblems",
1402                      pmiID(60, 58, 40), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1403                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1404
1405         pmiAddMetric("network.icmp6.outparmproblems",
1406                      pmiID(60, 58, 55), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1407                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1408
1409         pmiAddMetric("network.icmp6.inredirects",
1410                      pmiID(60, 58, 50), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1411                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1412
1413         pmiAddMetric("network.icmp6.outredirects",
1414                      pmiID(60, 58, 65), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1415                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1416
1417         pmiAddMetric("network.icmp6.inpkttoobigs",
1418                      pmiID(60, 58, 38), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1419                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1420
1421         pmiAddMetric("network.icmp6.outpkttoobigs",
1422                      pmiID(60, 58, 53), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1423                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1424 #endif /* HAVE_PCP */
1425 }
1426
1427 /*
1428  ***************************************************************************
1429  * Define PCP metrics for UDPv6 network statistics.
1430  ***************************************************************************
1431  */
1432 void pcp_def_net_udp6_metrics(void)
1433 {
1434 #ifdef HAVE_PCP
1435         pmiAddMetric("network.udp6.indatagrams",
1436                      pmiID(60, 58, 67), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1437                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1438
1439         pmiAddMetric("network.udp6.outdatagrams",
1440                      pmiID(60, 58, 70), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1441                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1442
1443         pmiAddMetric("network.udp6.noports",
1444                      pmiID(60, 58, 68), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1445                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1446
1447         pmiAddMetric("network.udp6.inerrors",
1448                      pmiID(60, 58, 69), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_COUNTER,
1449                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1450 #endif /* HAVE_PCP */
1451 }
1452
1453 /*
1454  ***************************************************************************
1455  * Define PCP metrics for huge pages statistics.
1456  ***************************************************************************
1457  */
1458 void pcp_def_huge_metrics()
1459 {
1460 #ifdef HAVE_PCP
1461         pmiAddMetric("mem.util.hugepagesTotalBytes",
1462                      pmiID(60, 1, 60), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
1463                      pmiUnits(1, 0, 0, PM_SPACE_BYTE, 0, 0));
1464
1465         pmiAddMetric("mem.util.hugepagesFreeBytes",
1466                      pmiID(60, 1, 61), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
1467                      pmiUnits(1, 0, 0, PM_SPACE_BYTE, 0, 0));
1468
1469         pmiAddMetric("mem.util.hugepagesRsvdBytes",
1470                      pmiID(60, 1, 62), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
1471                      pmiUnits(1, 0, 0, PM_SPACE_BYTE, 0, 0));
1472
1473         pmiAddMetric("mem.util.hugepagesSurpBytes",
1474                      pmiID(60, 1, 63), PM_TYPE_U64, PM_INDOM_NULL, PM_SEM_INSTANT,
1475                      pmiUnits(1, 0, 0, PM_SPACE_BYTE, 0, 0));
1476 #endif /* HAVE_PCP */
1477 }
1478
1479 /*
1480  ***************************************************************************
1481  * Define PCP metrics for fan statistics.
1482  *
1483  * IN:
1484  * @a           Activity structure with statistics.
1485  ***************************************************************************
1486  */
1487 void pcp_def_pwr_fan_metrics(struct activity *a)
1488 {
1489 #ifdef HAVE_PCP
1490         int inst = 0;
1491         static pmInDom indom = PM_INDOM_NULL;
1492         char buf[16];
1493
1494         if (indom == PM_INDOM_NULL) {
1495                 /* Create domain */
1496                 indom = pmInDom_build(34, 0);
1497
1498                 for (inst = 0; inst < a->item_list_sz; inst++) {
1499                         sprintf(buf, "fan%d", inst + 1);
1500                         pmiAddInstance(indom, buf, inst);
1501                 }
1502         }
1503
1504         pmiAddMetric("power.fan.rpm",
1505                      pmiID(34, 0, 0), PM_TYPE_U64, indom, PM_SEM_INSTANT,
1506                      pmiUnits(0, 0, 0, 0, 0, 0));
1507
1508         pmiAddMetric("power.fan.drpm",
1509                      pmiID(34, 0, 1), PM_TYPE_U64, indom, PM_SEM_INSTANT,
1510                      pmiUnits(0, 0, 0, 0, 0, 0));
1511
1512         pmiAddMetric("power.fan.device",
1513                      pmiID(34, 0, 2), PM_TYPE_STRING, indom, PM_SEM_DISCRETE,
1514                      pmiUnits(0, 0, 0, 0, 0, 0));
1515 #endif /* HAVE_PCP */
1516 }
1517
1518 /*
1519  ***************************************************************************
1520  * Define PCP metrics for temperature statistics.
1521  *
1522  * IN:
1523  * @a           Activity structure with statistics.
1524  ***************************************************************************
1525  */
1526 void pcp_def_pwr_temp_metrics(struct activity *a)
1527 {
1528 #ifdef HAVE_PCP
1529         int inst = 0;
1530         static pmInDom indom = PM_INDOM_NULL;
1531         char buf[16];
1532
1533         if (indom == PM_INDOM_NULL) {
1534                 /* Create domain */
1535                 indom = pmInDom_build(34, 1);
1536
1537                 for (inst = 0; inst < a->item_list_sz; inst++) {
1538                         sprintf(buf, "temp%d", inst + 1);
1539                         pmiAddInstance(indom, buf, inst);
1540                 }
1541         }
1542
1543         pmiAddMetric("power.temp.celsius",
1544                      pmiID(34, 1, 0), PM_TYPE_FLOAT, indom, PM_SEM_INSTANT,
1545                      pmiUnits(0, 0, 0, 0, 0, 0));
1546
1547         pmiAddMetric("power.temp.percent",
1548                      pmiID(34, 1, 1), PM_TYPE_FLOAT, indom, PM_SEM_INSTANT,
1549                      pmiUnits(0, 0, 0, 0, 0, 0));
1550
1551         pmiAddMetric("power.temp.device",
1552                      pmiID(34, 1, 2), PM_TYPE_STRING, indom, PM_SEM_DISCRETE,
1553                      pmiUnits(0, 0, 0, 0, 0, 0));
1554 #endif /* HAVE_PCP */
1555 }
1556
1557 /*
1558  ***************************************************************************
1559  * Define PCP metrics for voltage inputs statistics.
1560  *
1561  * IN:
1562  * @a           Activity structure with statistics.
1563  ***************************************************************************
1564  */
1565 void pcp_def_pwr_in_metrics(struct activity *a)
1566 {
1567 #ifdef HAVE_PCP
1568         int inst = 0;
1569         static pmInDom indom = PM_INDOM_NULL;
1570         char buf[16];
1571
1572         if (indom == PM_INDOM_NULL) {
1573                 /* Create domain */
1574                 indom = pmInDom_build(34, 2);
1575
1576                 for (inst = 0; inst < a->item_list_sz; inst++) {
1577                         sprintf(buf, "in%d", inst);
1578                         pmiAddInstance(indom, buf, inst);
1579                 }
1580         }
1581
1582         pmiAddMetric("power.in.voltage",
1583                      pmiID(34, 2, 0), PM_TYPE_FLOAT, indom, PM_SEM_INSTANT,
1584                      pmiUnits(0, 0, 0, 0, 0, 0));
1585
1586         pmiAddMetric("power.in.percent",
1587                      pmiID(34, 2, 1), PM_TYPE_FLOAT, indom, PM_SEM_INSTANT,
1588                      pmiUnits(0, 0, 0, 0, 0, 0));
1589
1590         pmiAddMetric("power.in.device",
1591                      pmiID(34, 2, 2), PM_TYPE_STRING, indom, PM_SEM_DISCRETE,
1592                      pmiUnits(0, 0, 0, 0, 0, 0));
1593 #endif /* HAVE_PCP */
1594 }
1595
1596 /*
1597  ***************************************************************************
1598  * Define PCP metrics for USB devices statistics.
1599  *
1600  * IN:
1601  * @a           Activity structure with statistics.
1602  ***************************************************************************
1603  */
1604 void pcp_def_pwr_usb_metrics(struct activity *a)
1605 {
1606 #ifdef HAVE_PCP
1607         int inst = 0;
1608         static pmInDom indom = PM_INDOM_NULL;
1609         char buf[16];
1610
1611         if (indom == PM_INDOM_NULL) {
1612                 /* Create domain */
1613                 indom = pmInDom_build(34, 3);
1614
1615                 for (inst = 0; inst < a->item_list_sz; inst++) {
1616                         sprintf(buf, "usb%d", inst);
1617                         pmiAddInstance(indom, buf, inst);
1618                 }
1619         }
1620
1621         pmiAddMetric("power.usb.bus",
1622                      pmiID(34, 3, 0), PM_TYPE_U32, indom, PM_SEM_DISCRETE,
1623                      pmiUnits(0, 0, 0, 0, 0, 0));
1624
1625         pmiAddMetric("power.usb.vendorId",
1626                      pmiID(34, 3, 1), PM_TYPE_STRING, indom, PM_SEM_DISCRETE,
1627                      pmiUnits(0, 0, 0, 0, 0, 0));
1628
1629         pmiAddMetric("power.usb.productId",
1630                      pmiID(34, 3, 2), PM_TYPE_STRING, indom, PM_SEM_DISCRETE,
1631                      pmiUnits(0, 0, 0, 0, 0, 0));
1632
1633         pmiAddMetric("power.usb.maxpower",
1634                      pmiID(34, 3, 3), PM_TYPE_U32, indom, PM_SEM_DISCRETE,
1635                      pmiUnits(0, 0, 0, 0, 0, 0));
1636
1637         pmiAddMetric("power.usb.manufacturer",
1638                      pmiID(34, 3, 3), PM_TYPE_STRING, indom, PM_SEM_DISCRETE,
1639                      pmiUnits(0, 0, 0, 0, 0, 0));
1640
1641         pmiAddMetric("power.usb.productName",
1642                      pmiID(34, 3, 3), PM_TYPE_STRING, indom, PM_SEM_DISCRETE,
1643                      pmiUnits(0, 0, 0, 0, 0, 0));
1644 #endif /* HAVE_PCP */
1645 }
1646
1647 /*
1648  ***************************************************************************
1649  * Define PCP metrics for filesystem statistics.
1650  *
1651  * IN:
1652  * @a           Activity structure with statistics.
1653  ***************************************************************************
1654  */
1655 void pcp_def_filesystem_metrics(struct activity *a)
1656 {
1657 #ifdef HAVE_PCP
1658         int inst = 0;
1659         static pmInDom indom = PM_INDOM_NULL;
1660         struct sa_item *list = a->item_list;
1661
1662         if (indom == PM_INDOM_NULL) {
1663                 /* Create domain */
1664                 indom = pmInDom_build(60, 5);
1665
1666                 /* Create instances */
1667                 while (list != NULL) {
1668                         pmiAddInstance(indom, list->item_name, inst++);
1669                         list = list->next;
1670                 }
1671         }
1672
1673         pmiAddMetric("filesys.capacity",
1674                      pmiID(60, 5, 1), PM_TYPE_U64, indom, PM_SEM_INSTANT,
1675                      pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
1676
1677         pmiAddMetric("filesys.free",
1678                      pmiID(60, 5, 3), PM_TYPE_U64, indom, PM_SEM_INSTANT,
1679                      pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
1680
1681         pmiAddMetric("filesys.used",
1682                      pmiID(60, 5, 2), PM_TYPE_U64, indom, PM_SEM_INSTANT,
1683                      pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
1684
1685         pmiAddMetric("filesys.full",
1686                      pmiID(60, 5, 8), PM_TYPE_DOUBLE, indom, PM_SEM_INSTANT,
1687                      pmiUnits(0, 0, 0, 0, 0, 0));
1688
1689         pmiAddMetric("filesys.maxfiles",
1690                      pmiID(60, 5, 4), PM_TYPE_U64, indom, PM_SEM_INSTANT,
1691                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1692
1693         pmiAddMetric("filesys.freefiles",
1694                      pmiID(60, 5, 6), PM_TYPE_U64, indom, PM_SEM_INSTANT,
1695                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1696
1697         pmiAddMetric("filesys.usedfiles",
1698                      pmiID(60, 5, 5), PM_TYPE_U64, indom, PM_SEM_INSTANT,
1699                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1700
1701         pmiAddMetric("filesys.avail",
1702                      pmiID(60, 5, 10), PM_TYPE_U64, indom, PM_SEM_INSTANT,
1703                      pmiUnits(1, 0, 0, PM_SPACE_KBYTE, 0, 0));
1704 #endif /* HAVE_PCP */
1705 }
1706
1707 /*
1708  ***************************************************************************
1709  * Define PCP metrics for Fibre Channel HBA statistics.
1710  *
1711  * IN:
1712  * @a           Activity structure with statistics.
1713  ***************************************************************************
1714  */
1715 void pcp_def_fchost_metrics(struct activity *a)
1716 {
1717 #ifdef HAVE_PCP
1718         int inst = 0;
1719         static pmInDom indom = PM_INDOM_NULL;
1720         struct sa_item *list = a->item_list;
1721
1722         if (indom == PM_INDOM_NULL) {
1723                 /* Create domain */
1724                 indom = pmInDom_build(60, 39);
1725
1726                 /* Create instances */
1727                 while (list != NULL) {
1728                         pmiAddInstance(indom, list->item_name, inst++);
1729                         list = list->next;
1730                 }
1731         }
1732
1733         pmiAddMetric("fchost.in.frames",
1734                      pmiID(60, 91, 0), PM_TYPE_U64, indom, PM_SEM_COUNTER,
1735                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1736
1737         pmiAddMetric("fchost.out.frames",
1738                      pmiID(60, 91, 1), PM_TYPE_U64, indom, PM_SEM_COUNTER,
1739                      pmiUnits(0, 0, 1, 0, 0, PM_COUNT_ONE));
1740
1741         pmiAddMetric("fchost.in.bytes",
1742                      pmiID(60, 91, 2), PM_TYPE_U64, indom, PM_SEM_COUNTER,
1743                      pmiUnits(1, 0, 0, PM_SPACE_BYTE, 0, 0));
1744
1745         pmiAddMetric("fchost.out.bytes",
1746                      pmiID(60, 91, 3), PM_TYPE_U64, indom, PM_SEM_COUNTER,
1747                      pmiUnits(1, 0, 0, PM_SPACE_BYTE, 0, 0));
1748 #endif /* HAVE_PCP */
1749 }
1750
1751 /*
1752  ***************************************************************************
1753  * Define PCP metrics for pressure-stall statistics.
1754  *
1755  * IN:
1756  * @a   Activity structure with statistics.
1757  ***************************************************************************
1758  */
1759 void pcp_def_psi_metrics(struct activity *a)
1760 {
1761 #ifdef HAVE_PCP
1762         static pmInDom indom = PM_INDOM_NULL;
1763
1764         if (indom == PM_INDOM_NULL) {
1765                 /* Create domain */
1766                 indom = pmInDom_build(60, 37);
1767
1768                 pmiAddInstance(indom, "10 second", 10);
1769                 pmiAddInstance(indom, "1 minute", 60);
1770                 pmiAddInstance(indom, "5 minute", 300);
1771         }
1772
1773         if (a->id == A_PSI_CPU) {
1774                 /* Create metrics for A_PSI_CPU */
1775                 pmiAddMetric("kernel.all.pressure.cpu.some.total",
1776                              pmiID(60, 83, 1), PM_TYPE_U64, indom, PM_SEM_COUNTER,
1777                              pmiUnits(0, 1, 0, 0, PM_TIME_USEC, 0));
1778
1779                 pmiAddMetric("kernel.all.pressure.cpu.some.avg",
1780                              pmiID(60, 83, 0), PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
1781                              pmiUnits(0, 0, 0, 0, 0, 0));
1782         }
1783         else if (a->id == A_PSI_IO) {
1784                 /* Create metrics for A_PSI_IO */
1785                 pmiAddMetric("kernel.all.pressure.io.some.total",
1786                              pmiID(60, 85, 1), PM_TYPE_U64, indom, PM_SEM_COUNTER,
1787                              pmiUnits(0, 1, 0, 0, PM_TIME_USEC, 0));
1788
1789                 pmiAddMetric("kernel.all.pressure.io.some.avg",
1790                              pmiID(60, 85, 0), PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
1791                              pmiUnits(0, 0, 0, 0, 0, 0));
1792
1793                 pmiAddMetric("kernel.all.pressure.io.full.total",
1794                              pmiID(60, 85, 3), PM_TYPE_U64, indom, PM_SEM_COUNTER,
1795                              pmiUnits(0, 1, 0, 0, PM_TIME_USEC, 0));
1796
1797                 pmiAddMetric("kernel.all.pressure.io.full.avg",
1798                              pmiID(60, 85, 2), PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
1799                              pmiUnits(0, 0, 0, 0, 0, 0));
1800         }
1801         else {
1802                 /* Create metrics for A_PSI_MEM */
1803                 pmiAddMetric("kernel.all.pressure.memory.some.total",
1804                              pmiID(60, 84, 1), PM_TYPE_U64, indom, PM_SEM_COUNTER,
1805                              pmiUnits(0, 1, 0, 0, PM_TIME_USEC, 0));
1806
1807                 pmiAddMetric("kernel.all.pressure.memory.some.avg",
1808                              pmiID(60, 84, 0), PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
1809                              pmiUnits(0, 0, 0, 0, 0, 0));
1810
1811                 pmiAddMetric("kernel.all.pressure.memory.full.total",
1812                              pmiID(60, 84, 3), PM_TYPE_U64, indom, PM_SEM_COUNTER,
1813                              pmiUnits(0, 1, 0, 0, PM_TIME_USEC, 0));
1814
1815                 pmiAddMetric("kernel.all.pressure.memory.full.avg",
1816                              pmiID(60, 84, 2), PM_TYPE_FLOAT, PM_INDOM_NULL, PM_SEM_INSTANT,
1817                              pmiUnits(0, 0, 0, 0, 0, 0));
1818         }
1819 #endif /* HAVE_PCP */
1820 }