src/nfs.c

   1 /**
   2  * collectd - src/nfs.c
   3  * Copyright (C) 2005,2006  Jason Pepas
   4  * Copyright (C) 2012,2013  Florian Forster
   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; only version 2 of the License is applicable.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  18  *
  19  * Authors:
  20  *   Jason Pepas <cell at ices.utexas.edu>
  21  *   Florian octo Forster <octo at collectd.org>
  22  *   Cosmin Ioiart <cioiart at gmail.com>
  23  **/
  24
  25 #include "collectd.h"
  26 #include "common.h"
  27 #include "plugin.h"
  28
  29 #if HAVE_KSTAT_H
  30 #include <kstat.h>
  31 #endif
  32
  33 /*
  34 see /proc/net/rpc/nfs
  35 see http://www.missioncriticallinux.com/orph/NFS-Statistics
  36
  37 net x x x x
  38 rpc_stat.netcnt         Not used; always zero.
  39 rpc_stat.netudpcnt      Not used; always zero.
  40 rpc_stat.nettcpcnt      Not used; always zero.
  41 rpc_stat.nettcpconn     Not used; always zero.
  42
  43 rpc x x x
  44 rpc_stat.rpccnt             The number of RPC calls.
  45 rpc_stat.rpcretrans         The number of retransmitted RPC calls.
  46 rpc_stat.rpcauthrefresh     The number of credential refreshes.
  47
  48 proc2 x x x...
  49 proc3 x x x...
  50
  51 Procedure   NFS Version NFS Version 3
  52 Number      Procedures  Procedures
  53
  54 0           null        null
  55 1           getattr     getattr
  56 2           setattr     setattr
  57 3           root        lookup
  58 4           lookup      access
  59 5           readlink    readlink
  60 6           read        read
  61 7           wrcache     write
  62 8           write       create
  63 9           create      mkdir
  64 10          remove      symlink
  65 11          rename      mknod
  66 12          link        remove
  67 13          symlink     rmdir
  68 14          mkdir       rename
  69 15          rmdir       link
  70 16          readdir     readdir
  71 17          fsstat      readdirplus
  72 18                      fsstat
  73 19                      fsinfo
  74 20                      pathconf
  75 21                      commit
  76 */
  77
  78 static const char *nfs2_procedures_names[] =
  79 {
  80         "null",
  81         "getattr",
  82         "setattr",
  83         "root",
  84         "lookup",
  85         "readlink",
  86         "read",
  87         "wrcache",
  88         "write",
  89         "create",
  90         "remove",
  91         "rename",
  92         "link",
  93         "symlink",
  94         "mkdir",
  95         "rmdir",
  96         "readdir",
  97         "fsstat"
  98 };
  99 static size_t nfs2_procedures_names_num = STATIC_ARRAY_SIZE (nfs2_procedures_names);
 100
 101 static const char *nfs3_procedures_names[] =
 102 {
 103         "null",
 104         "getattr",
 105         "setattr",
 106         "lookup",
 107         "access",
 108         "readlink",
 109         "read",
 110         "write",
 111         "create",
 112         "mkdir",
 113         "symlink",
 114         "mknod",
 115         "remove",
 116         "rmdir",
 117         "rename",
 118         "link",
 119         "readdir",
 120         "readdirplus",
 121         "fsstat",
 122         "fsinfo",
 123         "pathconf",
 124         "commit"
 125 };
 126 static size_t nfs3_procedures_names_num = STATIC_ARRAY_SIZE (nfs3_procedures_names);
 127
 128 #if HAVE_LIBKSTAT
 129 static const char *nfs4_procedures_names[] =
 130 {
 131         "null",
 132         "compound",
 133         "reserved",
 134         "access",
 135         "close",
 136         "commit",
 137         "create",
 138         "delegpurge",
 139         "delegreturn",
 140         "getattr",
 141         "getfh",
 142         "link",
 143         "lock",
 144         "lockt",
 145         "locku",
 146         "lookup",
 147         "lookupp",
 148         "nverify",
 149         "open",
 150         "openattr",
 151         "open_confirm",
 152         "open_downgrade",
 153         "putfh",
 154         "putpubfh",
 155         "putrootfh",
 156         "read",
 157         "readdir",
 158         "readlink",
 159         "remove",
 160         "rename",
 161         "renew",
 162         "restorefh",
 163         "savefh",
 164         "secinfo",
 165         "setattr",
 166         "setclientid",
 167         "setclientid_confirm",
 168         "verify",
 169         "write"
 170 };
 171 static size_t nfs4_procedures_names_num = STATIC_ARRAY_SIZE (nfs4_procedures_names);
 172 #endif
 173
 174 #if KERNEL_LINUX
 175 static const char *nfs4_server40_procedures_names[] =
 176 {
 177         "null",
 178         "compound",
 179         "reserved",
 180         "access",
 181         "close",
 182         "commit",
 183         "create",
 184         "delegpurge",
 185         "delegreturn",
 186         "getattr",
 187         "getfh",
 188         "link",
 189         "lock",
 190         "lockt",
 191         "locku",
 192         "lookup",
 193         "lookupp",
 194         "nverify",
 195         "open",
 196         "openattr",
 197         "open_confirm",
 198         "open_downgrade",
 199         "putfh",
 200         "putpubfh",
 201         "putrootfh",
 202         "read",
 203         "readdir",
 204         "readlink",
 205         "remove",
 206         "rename",
 207         "renew",
 208         "restorefh",
 209         "savefh",
 210         "secinfo",
 211         "setattr",
 212         "setclientid",
 213         "setcltid_confirm",
 214         "verify",
 215         "write",
 216         "release_lockowner"
 217 };
 218
 219 static size_t nfs4_server40_procedures_names_num = STATIC_ARRAY_SIZE (nfs4_server40_procedures_names);
 220
 221 static const char *nfs4_server41_procedures_names[] =
 222 {
 223         "backchannel_ctl",
 224         "bind_conn_to_session",
 225         "exchange_id",
 226         "create_session",
 227         "destroy_session",
 228         "free_stateid",
 229         "get_dir_delegation",
 230         "getdeviceinfo",
 231         "getdevicelist",
 232         "layoutcommit",
 233         "layoutget",
 234         "layoutreturn",
 235         "secinfo_no_name",
 236         "sequence",
 237         "set_ssv",
 238         "test_stateid",
 239         "want_delegation",
 240         "destroy_clientid",
 241         "reclaim_complete",
 242 };
 243
 244 static size_t nfs4_server41_procedures_names_num = STATIC_ARRAY_SIZE (nfs4_server41_procedures_names);
 245
 246 #define NFS4_SERVER40_NUM_PROC ( \
 247         STATIC_ARRAY_SIZE (nfs4_server40_procedures_names) )
 248
 249 #define NFS4_SERVER41_NUM_PROC ( \
 250         STATIC_ARRAY_SIZE (nfs4_server40_procedures_names) + \
 251         STATIC_ARRAY_SIZE (nfs4_server41_procedures_names) )
 252
 253 #define NFS4_SERVER_MAX_PROC (NFS4_SERVER41_NUM_PROC)
 254
 255 static const char *nfs4_client40_procedures_names[] =
 256 {
 257         "null",
 258         "read",
 259         "write",
 260         "commit",
 261         "open",
 262         "open_confirm",
 263         "open_noattr",
 264         "open_downgrade",
 265         "close",
 266         "setattr",
 267         "fsinfo",
 268         "renew",
 269         "setclientid",
 270         "setclientid_confirm",
 271         "lock",
 272         "lockt",
 273         "locku",
 274         "access",
 275         "getattr",
 276         "lookup",
 277         "lookupp",
 278         "remove",
 279         "rename",
 280         "link",
 281         "symlink",
 282         "create",
 283         "pathconf",
 284         "statfs",
 285         "readlink",
 286         "readdir",
 287         "server_caps",
 288         "delegreturn",
 289         "getacl",
 290         "setacl",
 291         "fs_locations",         /* |35| 2.6.18 */
 292         "release_lockowner",    /* |42| 2.6.36 */
 293         "secinfo",              /* |46| 2.6.39 */
 294         "fsid_present"          /* |54| 3.13 */
 295 };
 296
 297 static const char *nfs4_client41_procedures_names[] =
 298 {
 299         "exchange_id",          /* |40| 2.6.30 */
 300         "create_session",       /* |40| 2.6.30 */
 301         "destroy_session",      /* |40| 2.6.30 */
 302         "sequence",             /* |40| 2.6.30 */
 303         "get_lease_time",       /* |40| 2.6.30 */
 304         "reclaim_complete",     /* |41| 2.6.33 */
 305         "layoutget",            /* |44| 2.6.37 */
 306         "getdeviceinfo",        /* |44| 2.6.37 */
 307         "layoutcommit",         /* |46| 2.6.39 */
 308         "layoutreturn",         /* |47| 3.0 */
 309         "secinfo_no_name",      /* |51| 3.1 */
 310         "test_stateid",         /* |51| 3.1 */
 311         "free_stateid",         /* |51| 3.1 */
 312         "getdevicelist",        /* |51| 3.1 */
 313         "bind_conn_to_session", /* |53| 3.5 */
 314         "destroy_clientid"      /* |53| 3.5 */
 315 };
 316
 317 #define NFS4_CLIENT40_NUM_PROC ( \
 318         STATIC_ARRAY_SIZE (nfs4_client40_procedures_names) )
 319
 320 #define NFS4_CLIENT41_NUM_PROC ( \
 321         STATIC_ARRAY_SIZE (nfs4_client40_procedures_names) + \
 322         STATIC_ARRAY_SIZE (nfs4_client41_procedures_names) )
 323
 324 #define NFS4_CLIENT_MAX_PROC (NFS4_CLIENT41_NUM_PROC)
 325
 326 #endif
 327
 328 #if HAVE_LIBKSTAT
 329 extern kstat_ctl_t *kc;
 330 static kstat_t *nfs2_ksp_client;
 331 static kstat_t *nfs2_ksp_server;
 332 static kstat_t *nfs3_ksp_client;
 333 static kstat_t *nfs3_ksp_server;
 334 static kstat_t *nfs4_ksp_client;
 335 static kstat_t *nfs4_ksp_server;
 336 #endif
 337
 338 #if KERNEL_LINUX
 339 static int nfs_init (void)
 340 {
 341         return (0);
 342 }
 343 /* #endif KERNEL_LINUX */
 344
 345 #elif HAVE_LIBKSTAT
 346 static int nfs_init (void)
 347 {
 348         kstat_t *ksp_chain = NULL;
 349
 350         nfs2_ksp_client = NULL;
 351         nfs2_ksp_server = NULL;
 352         nfs3_ksp_client = NULL;
 353         nfs3_ksp_server = NULL;
 354         nfs4_ksp_client = NULL;
 355         nfs4_ksp_server = NULL;
 356
 357         if (kc == NULL)
 358                 return (-1);
 359
 360         for (ksp_chain = kc->kc_chain; ksp_chain != NULL;
 361                         ksp_chain = ksp_chain->ks_next)
 362         {
 363                 if (strncmp (ksp_chain->ks_module, "nfs", 3) != 0)
 364                         continue;
 365                 else if (strncmp (ksp_chain->ks_name, "rfsproccnt_v2", 13) == 0)
 366                         nfs2_ksp_server = ksp_chain;
 367                 else if (strncmp (ksp_chain->ks_name, "rfsproccnt_v3", 13) == 0)
 368                         nfs3_ksp_server = ksp_chain;
 369                 else if (strncmp (ksp_chain->ks_name, "rfsproccnt_v4", 13) == 0)
 370                         nfs4_ksp_server = ksp_chain;
 371                 else if (strncmp (ksp_chain->ks_name, "rfsreqcnt_v2", 12) == 0)
 372                         nfs2_ksp_client = ksp_chain;
 373                 else if (strncmp (ksp_chain->ks_name, "rfsreqcnt_v3", 12) == 0)
 374                         nfs3_ksp_client = ksp_chain;
 375                 else if (strncmp (ksp_chain->ks_name, "rfsreqcnt_v4", 12) == 0)
 376                         nfs4_ksp_client = ksp_chain;
 377         }
 378
 379         return (0);
 380 } /* int nfs_init */
 381 #endif
 382
 383 static void nfs_procedures_submit (const char *plugin_instance,
 384                 const char **type_instances,
 385                 value_t *values, size_t values_num)
 386 {
 387         value_list_t vl = VALUE_LIST_INIT;
 388         size_t i;
 389
 390         vl.values_len = 1;
 391         sstrncpy (vl.host, hostname_g, sizeof (vl.host));
 392         sstrncpy (vl.plugin, "nfs", sizeof (vl.plugin));
 393         sstrncpy (vl.plugin_instance, plugin_instance,
 394                         sizeof (vl.plugin_instance));
 395         sstrncpy (vl.type, "nfs_procedure", sizeof (vl.type));
 396
 397         for (i = 0; i < values_num; i++)
 398         {
 399                 vl.values = values + i;
 400                 sstrncpy (vl.type_instance, type_instances[i],
 401                                 sizeof (vl.type_instance));
 402                 plugin_dispatch_values (&vl);
 403         }
 404 } /* void nfs_procedures_submit */
 405
 406 #if KERNEL_LINUX
 407 static void nfs_submit_fields (int nfs_version, const char *instance,
 408                 char **fields, size_t fields_num, const char **proc_names)
 409 {
 410         char plugin_instance[DATA_MAX_NAME_LEN];
 411         value_t values[fields_num];
 412         size_t i;
 413
 414         ssnprintf (plugin_instance, sizeof (plugin_instance), "v%i%s",
 415                         nfs_version, instance);
 416
 417         for (i = 0; i < fields_num; i++)
 418                 (void) parse_value (fields[i], &values[i], DS_TYPE_DERIVE);
 419
 420         nfs_procedures_submit (plugin_instance, proc_names, values,
 421                         fields_num);
 422 }
 423
 424 static int nfs_submit_fields_safe (int nfs_version, const char *instance,
 425                 char **fields, size_t fields_num,
 426                 const char **proc_names, size_t proc_names_num)
 427 {
 428         if (fields_num != proc_names_num)
 429         {
 430                 WARNING ("nfs plugin: Wrong number of fields for "
 431                                 "NFSv%i %s statistics. Expected %zu, got %zu.",
 432                                 nfs_version, instance,
 433                                 proc_names_num, fields_num);
 434                 return (EINVAL);
 435         }
 436
 437         nfs_submit_fields (nfs_version, instance, fields, fields_num,
 438                         proc_names);
 439
 440         return (0);
 441 }
 442
 443 static int nfs_submit_nfs4_server (const char *instance, char **fields,
 444                 size_t fields_num)
 445 {
 446         static int suppress_warning = 0;
 447
 448         if (fields_num != NFS4_SERVER40_NUM_PROC &&
 449                 fields_num != NFS4_SERVER41_NUM_PROC)
 450         {
 451                 if (!suppress_warning)
 452                 {
 453                         WARNING ("nfs plugin: Unexpected number of fields for "
 454                                         "NFSv4 %s statistics: %zu. ",
 455                                         instance, fields_num);
 456                 }
 457
 458                 if (fields_num > NFS4_SERVER_MAX_PROC)
 459                 {
 460                         fields_num = NFS4_SERVER_MAX_PROC;
 461                         suppress_warning = 1;
 462                 }
 463                 else
 464                 {
 465                         return (EINVAL);
 466                 }
 467         }
 468
 469         nfs_submit_fields (4, instance, fields,
 470                         nfs4_server40_procedures_names_num,
 471                         nfs4_server40_procedures_names);
 472
 473         if (fields_num >= NFS4_SERVER41_NUM_PROC)
 474         {
 475                 fields += nfs4_server40_procedures_names_num;
 476
 477                 nfs_submit_fields (4, instance, fields,
 478                                 nfs4_server41_procedures_names_num,
 479                                 nfs4_server41_procedures_names);
 480         }
 481
 482         return (0);
 483 }
 484
 485 static int nfs_submit_nfs4_client (const char *instance, char **fields,
 486                 size_t fields_num)
 487 {
 488         size_t proc40_names_num, proc41_names_num;
 489
 490         static int suppress_warning = 0;
 491
 492         switch (fields_num)
 493         {
 494                 case 34:
 495                 case 35:
 496                 case 36:
 497                 case 37:
 498                 case 38:
 499                         /* 4.0-only configuration */
 500                         proc40_names_num = fields_num;
 501                         break;
 502                 case 40:
 503                 case 41:
 504                         proc40_names_num = 35;
 505                         break;
 506                 case 42:
 507                 case 44:
 508                         proc40_names_num = 36;
 509                         break;
 510                 case 46:
 511                 case 47:
 512                 case 51:
 513                 case 53:
 514                         proc40_names_num = 37;
 515                         break;
 516                 case 54:
 517                         proc40_names_num = 38;
 518                         break;
 519                 default:
 520                         if (!suppress_warning)
 521                         {
 522                                 WARNING ("nfs plugin: Unexpected number of "
 523                                                 "fields for NFSv4 %s "
 524                                                 "statistics: %zu. ",
 525                                                 instance, fields_num);
 526                         }
 527
 528                         if (fields_num > 34)
 529                         {
 530                                 /* safe fallback to basic nfs40 procedures */
 531                                 fields_num = 34;
 532                                 proc40_names_num = 34;
 533
 534                                 suppress_warning = 1;
 535                         }
 536                         else
 537                         {
 538                                 return (EINVAL);
 539                         }
 540         }
 541
 542         nfs_submit_fields (4, instance, fields, proc40_names_num,
 543                         nfs4_client40_procedures_names);
 544
 545         if (fields_num > proc40_names_num)
 546         {
 547                 proc41_names_num = fields_num - proc40_names_num;
 548                 fields += proc40_names_num;
 549
 550                 nfs_submit_fields (4, instance, fields,proc41_names_num,
 551                                  nfs4_client41_procedures_names);
 552         }
 553
 554         return (0);
 555 }
 556
 557 static void nfs_read_linux (FILE *fh, const char *inst)
 558 {
 559         char buffer[1024];
 560
 561         char *fields[64];
 562         int fields_num = 0;
 563
 564         if (fh == NULL)
 565                 return;
 566
 567         while (fgets (buffer, sizeof (buffer), fh) != NULL)
 568         {
 569                 fields_num = strsplit (buffer,
 570                                 fields, STATIC_ARRAY_SIZE (fields));
 571
 572                 if (fields_num < 3)
 573                         continue;
 574
 575                 if (strcmp (fields[0], "proc2") == 0)
 576                 {
 577                         nfs_submit_fields_safe (/* version = */ 2, inst,
 578                                         fields + 2, (size_t) (fields_num - 2),
 579                                         nfs2_procedures_names,
 580                                         nfs2_procedures_names_num);
 581                 }
 582                 else if (strncmp (fields[0], "proc3", 5) == 0)
 583                 {
 584                         nfs_submit_fields_safe (/* version = */ 3, inst,
 585                                         fields + 2, (size_t) (fields_num - 2),
 586                                         nfs3_procedures_names,
 587                                         nfs3_procedures_names_num);
 588                 }
 589                 else if (strcmp (fields[0], "proc4ops") == 0)
 590                 {
 591                         if (inst[0] == 's')
 592                                 nfs_submit_nfs4_server (inst, fields + 2,
 593                                                 (size_t) (fields_num - 2));
 594                 }
 595                 else if (strcmp (fields[0], "proc4") == 0)
 596                 {
 597                         if (inst[0] == 'c')
 598                                 nfs_submit_nfs4_client (inst, fields + 2,
 599                                                 (size_t) (fields_num - 2));
 600                 }
 601         } /* while (fgets) */
 602 } /* void nfs_read_linux */
 603 #endif /* KERNEL_LINUX */
 604
 605 #if HAVE_LIBKSTAT
 606 static int nfs_read_kstat (kstat_t *ksp, int nfs_version, const char *inst,
 607                 char const **proc_names, size_t proc_names_num)
 608 {
 609         char plugin_instance[DATA_MAX_NAME_LEN];
 610         value_t values[proc_names_num];
 611         size_t i;
 612
 613         if (ksp == NULL)
 614                 return (EINVAL);
 615
 616         ssnprintf (plugin_instance, sizeof (plugin_instance), "v%i%s",
 617                         nfs_version, inst);
 618
 619         kstat_read(kc, ksp, NULL);
 620         for (i = 0; i < proc_names_num; i++)
 621         {
 622                 /* The name passed to kstat_data_lookup() doesn't have the
 623                  * "const" modifier, so we need to copy the name here. */
 624                 char name[32];
 625                 sstrncpy (name, proc_names[i], sizeof (name));
 626
 627                 values[i].counter = (derive_t) get_kstat_value (ksp, name);
 628         }
 629
 630         nfs_procedures_submit (plugin_instance, proc_names, values,
 631                         proc_names_num);
 632         return (0);
 633 }
 634 #endif
 635
 636 #if KERNEL_LINUX
 637 static int nfs_read (void)
 638 {
 639         FILE *fh;
 640
 641         if ((fh = fopen ("/proc/net/rpc/nfs", "r")) != NULL)
 642         {
 643                 nfs_read_linux (fh, "client");
 644                 fclose (fh);
 645         }
 646
 647         if ((fh = fopen ("/proc/net/rpc/nfsd", "r")) != NULL)
 648         {
 649                 nfs_read_linux (fh, "server");
 650                 fclose (fh);
 651         }
 652
 653         return (0);
 654 }
 655 /* #endif KERNEL_LINUX */
 656
 657 #elif HAVE_LIBKSTAT
 658 static int nfs_read (void)
 659 {
 660         nfs_read_kstat (nfs2_ksp_client, /* version = */ 2, "client",
 661                         nfs2_procedures_names, nfs2_procedures_names_num);
 662         nfs_read_kstat (nfs2_ksp_server, /* version = */ 2, "server",
 663                         nfs2_procedures_names, nfs2_procedures_names_num);
 664         nfs_read_kstat (nfs3_ksp_client, /* version = */ 3, "client",
 665                         nfs3_procedures_names, nfs3_procedures_names_num);
 666         nfs_read_kstat (nfs3_ksp_server, /* version = */ 3, "server",
 667                         nfs3_procedures_names, nfs3_procedures_names_num);
 668         nfs_read_kstat (nfs4_ksp_client, /* version = */ 4, "client",
 669                         nfs4_procedures_names, nfs4_procedures_names_num);
 670         nfs_read_kstat (nfs4_ksp_server, /* version = */ 4, "server",
 671                         nfs4_procedures_names, nfs4_procedures_names_num);
 672
 673         return (0);
 674 }
 675 #endif /* HAVE_LIBKSTAT */
 676
 677 void module_register (void)
 678 {
 679         plugin_register_init ("nfs", nfs_init);
 680         plugin_register_read ("nfs", nfs_read);
 681 } /* void module_register */