X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fdf.c;h=a6fa526a9654135a6fa6fab42df101f56ba10a87;hb=df46cd0137364e4785e96653257392f0d1ea003f;hp=51dff31ff07e9e08172708bd7d0192d593e09d7b;hpb=872a6c0d1404d59261e864bfcdce499b5bcc27a1;p=collectd.git diff --git a/src/df.c b/src/df.c index 51dff31f..a6fa526a 100644 --- a/src/df.c +++ b/src/df.c @@ -1,11 +1,11 @@ /** * collectd - src/df.c - * Copyright (C) 2005 Florian octo Forster + * Copyright (C) 2005-2009 Florian octo Forster + * Copyright (C) 2009 Paul Sadauskas * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the - * Free Software Foundation; either version 2 of the License, or (at your - * option) any later version. + * Free Software Foundation; only version 2 of the License is applicable. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of @@ -17,82 +17,172 @@ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * * Authors: - * Florian octo Forster + * Florian octo Forster + * Paul Sadauskas **/ #include "collectd.h" #include "common.h" #include "plugin.h" +#include "configfile.h" #include "utils_mount.h" - -#define MODULE_NAME "df" - -#if HAVE_STATFS || HAVE_STATVFS -# define DF_HAVE_READ 1 -#else -# define DF_HAVE_READ 0 -#endif +#include "utils_ignorelist.h" #if HAVE_STATVFS # if HAVE_SYS_STATVFS_H # include # endif # define STATANYFS statvfs +# define STATANYFS_STR "statvfs" # define BLOCKSIZE(s) ((s).f_frsize ? (s).f_frsize : (s).f_bsize) #elif HAVE_STATFS # if HAVE_SYS_STATFS_H # include # endif # define STATANYFS statfs +# define STATANYFS_STR "statfs" # define BLOCKSIZE(s) (s).f_bsize +#else +# error "No applicable input method." #endif -static char *filename_template = "df-%s.rrd"; - -static char *ds_def[] = +static const char *config_keys[] = { - "DS:used:GAUGE:"COLLECTD_HEARTBEAT":0:U", - "DS:free:GAUGE:"COLLECTD_HEARTBEAT":0:U", - NULL + "Device", + "MountPoint", + "FSType", + "IgnoreSelected", + "ReportByDevice", + "ReportReserved", + "ReportInodes", + "ValuesAbsolute", + "ValuesPercentage" }; -static int ds_num = 2; +static int config_keys_num = STATIC_ARRAY_SIZE (config_keys); + +static ignorelist_t *il_device = NULL; +static ignorelist_t *il_mountpoint = NULL; +static ignorelist_t *il_fstype = NULL; -#define BUFSIZE 512 +static _Bool by_device = 0; +static _Bool report_inodes = 0; +static _Bool values_absolute = 1; +static _Bool values_percentage = 0; -static void df_init (void) +static int df_init (void) { - return; + if (il_device == NULL) + il_device = ignorelist_create (1); + if (il_mountpoint == NULL) + il_mountpoint = ignorelist_create (1); + if (il_fstype == NULL) + il_fstype = ignorelist_create (1); + + return (0); } -static void df_write (char *host, char *inst, char *val) +static int df_config (const char *key, const char *value) { - char file[BUFSIZE]; - int status; + df_init (); + + if (strcasecmp (key, "Device") == 0) + { + if (ignorelist_add (il_device, value)) + return (1); + return (0); + } + else if (strcasecmp (key, "MountPoint") == 0) + { + if (ignorelist_add (il_mountpoint, value)) + return (1); + return (0); + } + else if (strcasecmp (key, "FSType") == 0) + { + if (ignorelist_add (il_fstype, value)) + return (1); + return (0); + } + else if (strcasecmp (key, "IgnoreSelected") == 0) + { + if (IS_TRUE (value)) + { + ignorelist_set_invert (il_device, 0); + ignorelist_set_invert (il_mountpoint, 0); + ignorelist_set_invert (il_fstype, 0); + } + else + { + ignorelist_set_invert (il_device, 1); + ignorelist_set_invert (il_mountpoint, 1); + ignorelist_set_invert (il_fstype, 1); + } + return (0); + } + else if (strcasecmp (key, "ReportByDevice") == 0) + { + if (IS_TRUE (value)) + by_device = 1; + + return (0); + } + else if (strcasecmp (key, "ReportInodes") == 0) + { + if (IS_TRUE (value)) + report_inodes = 1; + else + report_inodes = 0; - status = snprintf (file, BUFSIZE, filename_template, inst); - if (status < 1) - return; - else if (status >= BUFSIZE) - return; + return (0); + } + else if (strcasecmp (key, "ValuesAbsolute") == 0) + { + if (IS_TRUE (value)) + values_absolute = 1; + else + values_absolute = 0; + + return (0); + } + else if (strcasecmp (key, "ValuesPercentage") == 0) + { + if (IS_TRUE (value)) + values_percentage = 1; + else + values_percentage = 0; + + return (0); + } - rrd_update_file (host, file, val, ds_def, ds_num); + return (-1); } -#if DF_HAVE_READ -static void df_submit (char *df_name, - unsigned long long df_used, - unsigned long long df_free) +__attribute__ ((nonnull(2))) +static void df_submit_one (char *plugin_instance, + const char *type, const char *type_instance, + gauge_t value) { - char buf[BUFSIZE]; + value_t values[1]; + value_list_t vl = VALUE_LIST_INIT; - if (snprintf (buf, BUFSIZE, "%u:%llu:%llu", (unsigned int) curtime, - df_used, df_free) >= BUFSIZE) - return; + values[0].gauge = value; - plugin_submit (MODULE_NAME, df_name, buf); -} + vl.values = values; + vl.values_len = 1; + sstrncpy (vl.host, hostname_g, sizeof (vl.host)); + sstrncpy (vl.plugin, "df", sizeof (vl.plugin)); + if (plugin_instance != NULL) + sstrncpy (vl.plugin_instance, plugin_instance, + sizeof (vl.plugin_instance)); + sstrncpy (vl.type, type, sizeof (vl.type)); + if (type_instance != NULL) + sstrncpy (vl.type_instance, type_instance, + sizeof (vl.type_instance)); + + plugin_dispatch_values (&vl); +} /* void df_submit_one */ -static void df_read (void) +static int df_read (void) { #if HAVE_STATVFS struct statvfs statbuf; @@ -103,59 +193,183 @@ static void df_read (void) cu_mount_t *mnt_list; cu_mount_t *mnt_ptr; - unsigned long long blocksize; - unsigned long long df_free; - unsigned long long df_used; - char mnt_name[BUFSIZE]; - mnt_list = NULL; if (cu_mount_getlist (&mnt_list) == NULL) - return; + { + ERROR ("df plugin: cu_mount_getlist failed."); + return (-1); + } for (mnt_ptr = mnt_list; mnt_ptr != NULL; mnt_ptr = mnt_ptr->next) { + unsigned long long blocksize; + char disk_name[256]; + uint64_t blk_free; + uint64_t blk_reserved; + uint64_t blk_used; + + if (ignorelist_match (il_device, + (mnt_ptr->spec_device != NULL) + ? mnt_ptr->spec_device + : mnt_ptr->device)) + continue; + if (ignorelist_match (il_mountpoint, mnt_ptr->dir)) + continue; + if (ignorelist_match (il_fstype, mnt_ptr->type)) + continue; + if (STATANYFS (mnt_ptr->dir, &statbuf) < 0) { - syslog (LOG_ERR, "statv?fs failed: %s", strerror (errno)); + char errbuf[1024]; + ERROR (STATANYFS_STR"(%s) failed: %s", + mnt_ptr->dir, + sstrerror (errno, errbuf, + sizeof (errbuf))); continue; } if (!statbuf.f_blocks) continue; - blocksize = BLOCKSIZE(statbuf); - df_free = statbuf.f_bfree * blocksize; - df_used = (statbuf.f_blocks - statbuf.f_bfree) * blocksize; - - if (strcmp (mnt_ptr->dir, "/") == 0) + if (by_device) { - strncpy (mnt_name, "root", BUFSIZE); + /* eg, /dev/hda1 -- strip off the "/dev/" */ + if (strncmp (mnt_ptr->spec_device, "/dev/", strlen ("/dev/")) == 0) + sstrncpy (disk_name, mnt_ptr->spec_device + strlen ("/dev/"), sizeof (disk_name)); + else + sstrncpy (disk_name, mnt_ptr->spec_device, sizeof (disk_name)); + + if (strlen(disk_name) < 1) + { + DEBUG("df: no device name for mountpoint %s, skipping", mnt_ptr->dir); + continue; + } } else { - int i, len; + if (strcmp (mnt_ptr->dir, "/") == 0) + { + if (strcmp (mnt_ptr->type, "rootfs") == 0) + continue; + sstrncpy (disk_name, "root", sizeof (disk_name)); + } + else + { + int i, len; - strncpy (mnt_name, mnt_ptr->dir + 1, BUFSIZE); - len = strlen (mnt_name); + sstrncpy (disk_name, mnt_ptr->dir + 1, sizeof (disk_name)); + len = strlen (disk_name); - for (i = 0; i < len; i++) - if (mnt_name[i] == '/') - mnt_name[i] = '-'; + for (i = 0; i < len; i++) + if (disk_name[i] == '/') + disk_name[i] = '-'; + } } - df_submit (mnt_name, df_used, df_free); + blocksize = BLOCKSIZE(statbuf); + + /* + * Sanity-check for the values in the struct + */ + /* Check for negative "available" byes. For example UFS can + * report negative free space for user. Notice. blk_reserved + * will start to diminish after this. */ +#if HAVE_STATVFS + /* Cast and temporary variable are needed to avoid + * compiler warnings. + * ((struct statvfs).f_bavail is unsigned (POSIX)) */ + int64_t signed_bavail = (int64_t) statbuf.f_bavail; + if (signed_bavail < 0) + statbuf.f_bavail = 0; +#elif HAVE_STATFS + if (statbuf.f_bavail < 0) + statbuf.f_bavail = 0; +#endif + /* Make sure that f_blocks >= f_bfree >= f_bavail */ + if (statbuf.f_bfree < statbuf.f_bavail) + statbuf.f_bfree = statbuf.f_bavail; + if (statbuf.f_blocks < statbuf.f_bfree) + statbuf.f_blocks = statbuf.f_bfree; + + blk_free = (uint64_t) statbuf.f_bavail; + blk_reserved = (uint64_t) (statbuf.f_bfree - statbuf.f_bavail); + blk_used = (uint64_t) (statbuf.f_blocks - statbuf.f_bfree); + + if (values_absolute) + { + df_submit_one (disk_name, "df_complex", "free", + (gauge_t) (blk_free * blocksize)); + df_submit_one (disk_name, "df_complex", "reserved", + (gauge_t) (blk_reserved * blocksize)); + df_submit_one (disk_name, "df_complex", "used", + (gauge_t) (blk_used * blocksize)); + } + + if (values_percentage) + { + if (statbuf.f_blocks > 0) + { + df_submit_one (disk_name, "percent_bytes", "free", + (gauge_t) ((float_t)(blk_free) / statbuf.f_blocks * 100)); + df_submit_one (disk_name, "percent_bytes", "reserved", + (gauge_t) ((float_t)(blk_reserved) / statbuf.f_blocks * 100)); + df_submit_one (disk_name, "percent_bytes", "used", + (gauge_t) ((float_t)(blk_used) / statbuf.f_blocks * 100)); + } + else return (-1); + } + + /* inode handling */ + if (report_inodes) + { + uint64_t inode_free; + uint64_t inode_reserved; + uint64_t inode_used; + + /* Sanity-check for the values in the struct */ + if (statbuf.f_ffree < statbuf.f_favail) + statbuf.f_ffree = statbuf.f_favail; + if (statbuf.f_files < statbuf.f_ffree) + statbuf.f_files = statbuf.f_ffree; + + inode_free = (uint64_t) statbuf.f_favail; + inode_reserved = (uint64_t) (statbuf.f_ffree - statbuf.f_favail); + inode_used = (uint64_t) (statbuf.f_files - statbuf.f_ffree); + + if (values_percentage) + { + if (statbuf.f_files > 0) + { + df_submit_one (disk_name, "percent_inodes", "free", + (gauge_t) ((float_t)(inode_free) / statbuf.f_files * 100)); + df_submit_one (disk_name, "percent_inodes", "reserved", + (gauge_t) ((float_t)(inode_reserved) / statbuf.f_files * 100)); + df_submit_one (disk_name, "percent_inodes", "used", + (gauge_t) ((float_t)(inode_used) / statbuf.f_files * 100)); + } + else return (-1); + } + if (values_absolute) + { + df_submit_one (disk_name, "df_inodes", "free", + (gauge_t) inode_free); + df_submit_one (disk_name, "df_inodes", "reserved", + (gauge_t) inode_reserved); + df_submit_one (disk_name, "df_inodes", "used", + (gauge_t) inode_used); + } + } } cu_mount_freelist (mnt_list); -} /* static void df_read (void) */ -#else -# define df_read NULL -#endif /* DF_HAVE_READ */ + + return (0); +} /* int df_read */ void module_register (void) { - plugin_register (MODULE_NAME, df_init, df_read, df_write); -} - -#undef BUFSIZE -#undef MODULE_NAME + plugin_register_config ("df", df_config, + config_keys, config_keys_num); + plugin_register_init ("df", df_init); + plugin_register_read ("df", df_read); +} /* void module_register */