X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fdisk.c;h=36d0a0c3450cc46b46d8a5d3725dedbaad9c2231;hb=f7e81e5920d6e51cd6d616aee1123a02b7dc183f;hp=ca3531eb5a14748327570bdd76d19618a90fa13b;hpb=99274702d4e4b42139244b549df1a01f19288b4f;p=collectd.git diff --git a/src/disk.c b/src/disk.c index ca3531eb..36d0a0c3 100644 --- a/src/disk.c +++ b/src/disk.c @@ -1,11 +1,11 @@ /** * collectd - src/disk.c - * Copyright (C) 2005,2006 Florian octo Forster + * Copyright (C) 2005-2012 Florian octo Forster + * Copyright (C) 2009 Manuel Sanmartin * * 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,15 +17,14 @@ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * * Authors: - * Florian octo Forster + * Florian octo Forster + * Manuel Sanmartin **/ #include "collectd.h" #include "common.h" #include "plugin.h" -#include "utils_debug.h" - -#define MODULE_NAME "disk" +#include "utils_ignorelist.h" #if HAVE_MACH_MACH_TYPES_H # include @@ -55,42 +54,30 @@ # include #endif -#if HAVE_IOKIT_IOKITLIB_H || KERNEL_LINUX || HAVE_LIBKSTAT -# define DISK_HAVE_READ 1 -#else -# define DISK_HAVE_READ 0 +#if HAVE_LIMITS_H +# include +#endif +#ifndef UINT_MAX +# define UINT_MAX 4294967295U #endif -static char *disk_filename_template = "disk-%s.rrd"; -static char *part_filename_template = "partition-%s.rrd"; - -/* 104857600 == 100 MB */ -static char *disk_ds_def[] = -{ - "DS:rcount:COUNTER:"COLLECTD_HEARTBEAT":0:U", - "DS:rmerged:COUNTER:"COLLECTD_HEARTBEAT":0:U", - "DS:rbytes:COUNTER:"COLLECTD_HEARTBEAT":0:104857600", - "DS:rtime:COUNTER:"COLLECTD_HEARTBEAT":0:U", - "DS:wcount:COUNTER:"COLLECTD_HEARTBEAT":0:U", - "DS:wmerged:COUNTER:"COLLECTD_HEARTBEAT":0:U", - "DS:wbytes:COUNTER:"COLLECTD_HEARTBEAT":0:104857600", - "DS:wtime:COUNTER:"COLLECTD_HEARTBEAT":0:U", - NULL -}; -static int disk_ds_num = 8; +#if HAVE_STATGRAB_H +# include +#endif -static char *part_ds_def[] = -{ - "DS:rcount:COUNTER:"COLLECTD_HEARTBEAT":0:U", - "DS:rbytes:COUNTER:"COLLECTD_HEARTBEAT":0:104857600", - "DS:wcount:COUNTER:"COLLECTD_HEARTBEAT":0:U", - "DS:wbytes:COUNTER:"COLLECTD_HEARTBEAT":0:104857600", - NULL -}; -static int part_ds_num = 4; +#if HAVE_PERFSTAT +# ifndef _AIXVERSION_610 +# include +# endif +# include +# include +#endif #if HAVE_IOKIT_IOKITLIB_H static mach_port_t io_master_port = MACH_PORT_NULL; +/* This defaults to false for backwards compatibility. Please fix in the next + * major version. */ +static _Bool use_bsd_name = 0; /* #endif HAVE_IOKIT_IOKITLIB_H */ #elif KERNEL_LINUX @@ -98,34 +85,99 @@ typedef struct diskstats { char *name; - /* This overflows in roughly 1361 year */ + /* This overflows in roughly 1361 years */ unsigned int poll_count; - unsigned long long read_sectors; - unsigned long long write_sectors; + derive_t read_sectors; + derive_t write_sectors; + + derive_t read_bytes; + derive_t write_bytes; + + derive_t read_ops; + derive_t write_ops; + derive_t read_time; + derive_t write_time; - unsigned long long read_bytes; - unsigned long long write_bytes; + derive_t avg_read_time; + derive_t avg_write_time; struct diskstats *next; } diskstats_t; static diskstats_t *disklist; -static int min_poll_count; /* #endif KERNEL_LINUX */ #elif HAVE_LIBKSTAT -#define MAX_NUMDISK 256 +#define MAX_NUMDISK 1024 extern kstat_ctl_t *kc; static kstat_t *ksp[MAX_NUMDISK]; static int numdisk = 0; -#endif /* HAVE_LIBKSTAT */ +/* #endif HAVE_LIBKSTAT */ + +#elif defined(HAVE_LIBSTATGRAB) +/* #endif HAVE_LIBKSTATGRAB */ + +#elif HAVE_PERFSTAT +static perfstat_disk_t * stat_disk; +static int numdisk; +static int pnumdisk; +/* #endif HAVE_PERFSTAT */ -static void disk_init (void) +#else +# error "No applicable input method." +#endif + +static const char *config_keys[] = +{ + "Disk", + "UseBSDName", + "IgnoreSelected" +}; +static int config_keys_num = STATIC_ARRAY_SIZE (config_keys); + +static ignorelist_t *ignorelist = NULL; + +static int disk_config (const char *key, const char *value) +{ + if (ignorelist == NULL) + ignorelist = ignorelist_create (/* invert = */ 1); + if (ignorelist == NULL) + return (1); + + if (strcasecmp ("Disk", key) == 0) + { + ignorelist_add (ignorelist, value); + } + else if (strcasecmp ("IgnoreSelected", key) == 0) + { + int invert = 1; + if (IS_TRUE (value)) + invert = 0; + ignorelist_set_invert (ignorelist, invert); + } + else if (strcasecmp ("UseBSDName", key) == 0) + { +#if HAVE_IOKIT_IOKITLIB_H + use_bsd_name = IS_TRUE (value) ? 1 : 0; +#else + WARNING ("disk plugin: The \"UseBSDName\" option is only supported " + "on Mach / Mac OS X and will be ignored."); +#endif + } + else + { + return (-1); + } + + return (0); +} /* int disk_config */ + +static int disk_init (void) { #if HAVE_IOKIT_IOKITLIB_H kern_return_t status; - + if (io_master_port != MACH_PORT_NULL) { mach_port_deallocate (mach_task_self (), @@ -136,25 +188,15 @@ static void disk_init (void) status = IOMasterPort (MACH_PORT_NULL, &io_master_port); if (status != kIOReturnSuccess) { - syslog (LOG_ERR, "IOMasterPort failed: %s", + ERROR ("IOMasterPort failed: %s", mach_error_string (status)); io_master_port = MACH_PORT_NULL; - return; + return (-1); } /* #endif HAVE_IOKIT_IOKITLIB_H */ #elif KERNEL_LINUX - int step; - int heartbeat; - - step = atoi (COLLECTD_STEP); - heartbeat = atoi (COLLECTD_HEARTBEAT); - - assert (step > 0); - assert (heartbeat >= step); - - min_poll_count = 1 + (heartbeat / step); - DBG ("min_poll_count = %i;", min_poll_count); + /* do nothing */ /* #endif KERNEL_LINUX */ #elif HAVE_LIBKSTAT @@ -163,7 +205,7 @@ static void disk_init (void) numdisk = 0; if (kc == NULL) - return; + return (-1); for (numdisk = 0, ksp_chain = kc->kc_chain; (numdisk < MAX_NUMDISK) && (ksp_chain != NULL); @@ -178,83 +220,44 @@ static void disk_init (void) } #endif /* HAVE_LIBKSTAT */ - return; -} + return (0); +} /* int disk_init */ -static void disk_write (char *host, char *inst, char *val) +static void disk_submit (const char *plugin_instance, + const char *type, + derive_t read, derive_t write) { - char file[512]; - int status; + value_t values[2]; + value_list_t vl = VALUE_LIST_INIT; - status = snprintf (file, 512, disk_filename_template, inst); - if (status < 1) - return; - else if (status >= 512) - return; + /* Both `ignorelist' and `plugin_instance' may be NULL. */ + if (ignorelist_match (ignorelist, plugin_instance) != 0) + return; - rrd_update_file (host, file, val, disk_ds_def, disk_ds_num); -} - -static void partition_write (char *host, char *inst, char *val) -{ - char file[512]; - int status; + values[0].derive = read; + values[1].derive = write; - status = snprintf (file, 512, part_filename_template, inst); - if (status < 1) - return; - else if (status >= 512) - return; + vl.values = values; + vl.values_len = 2; + sstrncpy (vl.host, hostname_g, sizeof (vl.host)); + sstrncpy (vl.plugin, "disk", sizeof (vl.plugin)); + sstrncpy (vl.plugin_instance, plugin_instance, + sizeof (vl.plugin_instance)); + sstrncpy (vl.type, type, sizeof (vl.type)); - rrd_update_file (host, file, val, part_ds_def, part_ds_num); -} + plugin_dispatch_values (&vl); +} /* void disk_submit */ -#if DISK_HAVE_READ -#define BUFSIZE 512 -static void disk_submit (char *disk_name, - unsigned long long read_count, - unsigned long long read_merged, - unsigned long long read_bytes, - unsigned long long read_time, - unsigned long long write_count, - unsigned long long write_merged, - unsigned long long write_bytes, - unsigned long long write_time) +#if KERNEL_LINUX +static counter_t disk_calc_time_incr (counter_t delta_time, counter_t delta_ops) { - char buf[BUFSIZE]; - - if (snprintf (buf, BUFSIZE, "%u:%llu:%llu:%llu:%llu:%llu:%llu:%llu:%llu", - (unsigned int) curtime, - read_count, read_merged, read_bytes, read_time, - write_count, write_merged, write_bytes, - write_time) >= BUFSIZE) - return; - - DBG ("disk_name = %s; buf = %s;", - disk_name, buf); - - plugin_submit (MODULE_NAME, disk_name, buf); -} - -#if KERNEL_LINUX || HAVE_LIBKSTAT -static void partition_submit (char *part_name, - unsigned long long read_count, - unsigned long long read_bytes, - unsigned long long write_count, - unsigned long long write_bytes) -{ - char buf[BUFSIZE]; - - if (snprintf (buf, BUFSIZE, "%u:%llu:%llu:%llu:%llu", - (unsigned int) curtime, - read_count, read_bytes, write_count, - write_bytes) >= BUFSIZE) - return; + double interval = CDTIME_T_TO_DOUBLE (plugin_get_interval ()); + double avg_time = ((double) delta_time) / ((double) delta_ops); + double avg_time_incr = interval * avg_time; - plugin_submit ("partition", part_name, buf); + return ((counter_t) (avg_time_incr + .5)); } -#endif /* KERNEL_LINUX || HAVE_LIBKSTAT */ -#undef BUFSIZE +#endif #if HAVE_IOKIT_IOKITLIB_H static signed long long dict_get_value (CFDictionaryRef dict, const char *key) @@ -268,7 +271,7 @@ static signed long long dict_get_value (CFDictionaryRef dict, const char *key) kCFStringEncodingASCII); if (key_obj == NULL) { - DBG ("CFStringCreateWithCString (%s) failed.", key); + DEBUG ("CFStringCreateWithCString (%s) failed.", key); return (-1LL); } @@ -279,13 +282,13 @@ static signed long long dict_get_value (CFDictionaryRef dict, const char *key) if (val_obj == NULL) { - DBG ("CFDictionaryGetValue (%s) failed.", key); + DEBUG ("CFDictionaryGetValue (%s) failed.", key); return (-1LL); } if (!CFNumberGetValue (val_obj, kCFNumberSInt64Type, &val_int)) { - DBG ("CFNumberGetValue (%s) failed.", key); + DEBUG ("CFNumberGetValue (%s) failed.", key); return (-1LL); } @@ -293,7 +296,7 @@ static signed long long dict_get_value (CFDictionaryRef dict, const char *key) } #endif /* HAVE_IOKIT_IOKITLIB_H */ -static void disk_read (void) +static int disk_read (void) { #if HAVE_IOKIT_IOKITLIB_H io_registry_entry_t disk; @@ -302,7 +305,8 @@ static void disk_read (void) CFDictionaryRef props_dict; CFDictionaryRef stats_dict; CFDictionaryRef child_dict; - kern_return_t status; + CFStringRef tmp_cf_string_ref; + kern_return_t status; signed long long read_ops; signed long long read_byt; @@ -313,15 +317,16 @@ static void disk_read (void) int disk_major; int disk_minor; - char disk_name[64]; + char disk_name[DATA_MAX_NAME_LEN]; + char disk_name_bsd[DATA_MAX_NAME_LEN]; /* Get the list of all disk objects. */ if (IOServiceGetMatchingServices (io_master_port, IOServiceMatching (kIOBlockStorageDriverClass), &disk_list) != kIOReturnSuccess) { - syslog (LOG_ERR, "disk-plugin: IOServiceGetMatchingServices failed."); - return; + ERROR ("disk plugin: IOServiceGetMatchingServices failed."); + return (-1); } while ((disk = IOIteratorNext (disk_list)) != 0) @@ -335,7 +340,7 @@ static void disk_read (void) != kIOReturnSuccess) { /* This fails for example for DVD/CD drives.. */ - DBG ("IORegistryEntryGetChildEntry (disk) failed: 0x%08x", status); + DEBUG ("IORegistryEntryGetChildEntry (disk) failed: 0x%08x", status); IOObjectRelease (disk); continue; } @@ -347,7 +352,7 @@ static void disk_read (void) kNilOptions) != kIOReturnSuccess) { - syslog (LOG_ERR, "disk-plugin: IORegistryEntryCreateCFProperties failed."); + ERROR ("disk-plugin: IORegistryEntryCreateCFProperties failed."); IOObjectRelease (disk_child); IOObjectRelease (disk); continue; @@ -355,18 +360,47 @@ static void disk_read (void) if (props_dict == NULL) { - DBG ("IORegistryEntryCreateCFProperties (disk) failed."); + DEBUG ("IORegistryEntryCreateCFProperties (disk) failed."); + IOObjectRelease (disk_child); + IOObjectRelease (disk); + continue; + } + + /* tmp_cf_string_ref doesn't need to be released. */ + tmp_cf_string_ref = (CFStringRef) CFDictionaryGetValue (props_dict, + CFSTR(kIOBSDNameKey)); + if (!tmp_cf_string_ref) + { + DEBUG ("disk plugin: CFDictionaryGetValue(" + "kIOBSDNameKey) failed."); + CFRelease (props_dict); IOObjectRelease (disk_child); IOObjectRelease (disk); continue; } + assert (CFGetTypeID (tmp_cf_string_ref) == CFStringGetTypeID ()); + + memset (disk_name_bsd, 0, sizeof (disk_name_bsd)); + CFStringGetCString (tmp_cf_string_ref, + disk_name_bsd, sizeof (disk_name_bsd), + kCFStringEncodingUTF8); + if (disk_name_bsd[0] == 0) + { + ERROR ("disk plugin: CFStringGetCString() failed."); + CFRelease (props_dict); + IOObjectRelease (disk_child); + IOObjectRelease (disk); + continue; + } + DEBUG ("disk plugin: disk_name_bsd = \"%s\"", disk_name_bsd); stats_dict = (CFDictionaryRef) CFDictionaryGetValue (props_dict, CFSTR (kIOBlockStorageDriverStatisticsKey)); if (stats_dict == NULL) { - DBG ("CFDictionaryGetValue (%s) failed.", + DEBUG ("disk plugin: CFDictionaryGetValue (" + "%s) failed.", kIOBlockStorageDriverStatisticsKey); CFRelease (props_dict); IOObjectRelease (disk_child); @@ -380,13 +414,15 @@ static void disk_read (void) kNilOptions) != kIOReturnSuccess) { - DBG ("IORegistryEntryCreateCFProperties (disk_child) failed."); + DEBUG ("disk plugin: IORegistryEntryCreateCFProperties (" + "disk_child) failed."); IOObjectRelease (disk_child); CFRelease (props_dict); IOObjectRelease (disk); continue; } + /* kIOBSDNameKey */ disk_major = (int) dict_get_value (child_dict, kIOBSDMajorKey); disk_minor = (int) dict_get_value (child_dict, @@ -401,29 +437,29 @@ static void disk_read (void) kIOBlockStorageDriverStatisticsWritesKey); write_byt = dict_get_value (stats_dict, kIOBlockStorageDriverStatisticsBytesWrittenKey); + /* This property describes the number of nanoseconds spent + * performing writes since the block storage driver was + * instantiated. It is one of the statistic entries listed + * under the top-level kIOBlockStorageDriverStatisticsKey + * property table. It has an OSNumber value. */ write_tme = dict_get_value (stats_dict, kIOBlockStorageDriverStatisticsTotalWriteTimeKey); - if (snprintf (disk_name, 64, "%i-%i", disk_major, disk_minor) >= 64) - { - DBG ("snprintf (major, minor) failed."); - CFRelease (child_dict); - IOObjectRelease (disk_child); - CFRelease (props_dict); - IOObjectRelease (disk); - continue; - } - DBG ("disk_name = %s", disk_name); - - if ((read_ops != -1LL) - || (read_byt != -1LL) - || (read_tme != -1LL) - || (write_ops != -1LL) - || (write_byt != -1LL) - || (write_tme != -1LL)) - disk_submit (disk_name, - read_ops, 0ULL, read_byt, read_tme, - write_ops, 0ULL, write_byt, write_tme); + if (use_bsd_name) + sstrncpy (disk_name, disk_name_bsd, sizeof (disk_name)); + else + ssnprintf (disk_name, sizeof (disk_name), "%i-%i", + disk_major, disk_minor); + DEBUG ("disk plugin: disk_name = \"%s\"", disk_name); + + if ((read_byt != -1LL) || (write_byt != -1LL)) + disk_submit (disk_name, "disk_octets", read_byt, write_byt); + if ((read_ops != -1LL) || (write_ops != -1LL)) + disk_submit (disk_name, "disk_ops", read_ops, write_ops); + if ((read_tme != -1LL) || (write_tme != -1LL)) + disk_submit (disk_name, "disk_time", + read_tme / 1000, + write_tme / 1000); CFRelease (child_dict); IOObjectRelease (disk_child); @@ -436,52 +472,51 @@ static void disk_read (void) #elif KERNEL_LINUX FILE *fh; char buffer[1024]; - char disk_name[128]; char *fields[32]; int numfields; int fieldshift = 0; - int major = 0; int minor = 0; - unsigned long long read_sectors = 0ULL; - unsigned long long write_sectors = 0ULL; - - unsigned long long read_count = 0ULL; - unsigned long long read_merged = 0ULL; - unsigned long long read_bytes = 0ULL; - unsigned long long read_time = 0ULL; - unsigned long long write_count = 0ULL; - unsigned long long write_merged = 0ULL; - unsigned long long write_bytes = 0ULL; - unsigned long long write_time = 0ULL; + derive_t read_sectors = 0; + derive_t write_sectors = 0; + + derive_t read_ops = 0; + derive_t read_merged = 0; + derive_t read_time = 0; + derive_t write_ops = 0; + derive_t write_merged = 0; + derive_t write_time = 0; int is_disk = 0; diskstats_t *ds, *pre_ds; if ((fh = fopen ("/proc/diskstats", "r")) == NULL) { - if ((fh = fopen ("/proc/partitions", "r")) == NULL) - return; + fh = fopen ("/proc/partitions", "r"); + if (fh == NULL) + { + ERROR ("disk plugin: fopen (/proc/{diskstats,partitions}) failed."); + return (-1); + } /* Kernel is 2.4.* */ fieldshift = 1; } - while (fgets (buffer, 1024, fh) != NULL) + while (fgets (buffer, sizeof (buffer), fh) != NULL) { + char *disk_name; + numfields = strsplit (buffer, fields, 32); if ((numfields != (14 + fieldshift)) && (numfields != 7)) continue; - major = atoll (fields[0]); minor = atoll (fields[1]); - if (snprintf (disk_name, 128, "%i-%i", major, minor) < 1) - continue; - disk_name[127] = '\0'; + disk_name = fields[2 + fieldshift]; for (ds = disklist, pre_ds = disklist; ds != NULL; pre_ds = ds, ds = ds->next) if (strcmp (disk_name, ds->name) == 0) @@ -508,15 +543,15 @@ static void disk_read (void) if (numfields == 7) { /* Kernel 2.6, Partition */ - read_count = atoll (fields[3]); + read_ops = atoll (fields[3]); read_sectors = atoll (fields[4]); - write_count = atoll (fields[5]); + write_ops = atoll (fields[5]); write_sectors = atoll (fields[6]); } else if (numfields == (14 + fieldshift)) { - read_count = atoll (fields[3 + fieldshift]); - write_count = atoll (fields[7 + fieldshift]); + read_ops = atoll (fields[3 + fieldshift]); + write_ops = atoll (fields[7 + fieldshift]); read_sectors = atoll (fields[5 + fieldshift]); write_sectors = atoll (fields[9 + fieldshift]); @@ -532,57 +567,143 @@ static void disk_read (void) } else { - DBG ("numfields = %i; => unknown file format.", numfields); + DEBUG ("numfields = %i; => unknown file format.", numfields); continue; } + { + derive_t diff_read_sectors; + derive_t diff_write_sectors; + /* If the counter wraps around, it's only 32 bits.. */ - if (read_sectors < ds->read_sectors) - ds->read_bytes += 512 * ((0xFFFFFFFF - ds->read_sectors) + read_sectors); - else - ds->read_bytes += 512 * (read_sectors - ds->read_sectors); + if (read_sectors < ds->read_sectors) + diff_read_sectors = 1 + read_sectors + + (UINT_MAX - ds->read_sectors); + else + diff_read_sectors = read_sectors - ds->read_sectors; + if (write_sectors < ds->write_sectors) + diff_write_sectors = 1 + write_sectors + + (UINT_MAX - ds->write_sectors); + else + diff_write_sectors = write_sectors - ds->write_sectors; - if (write_sectors < ds->write_sectors) - ds->write_bytes += 512 * ((0xFFFFFFFF - ds->write_sectors) + write_sectors); - else - ds->write_bytes += 512 * (write_sectors - ds->write_sectors); + ds->read_bytes += 512 * diff_read_sectors; + ds->write_bytes += 512 * diff_write_sectors; + ds->read_sectors = read_sectors; + ds->write_sectors = write_sectors; + } + + /* Calculate the average time an io-op needs to complete */ + if (is_disk) + { + derive_t diff_read_ops; + derive_t diff_write_ops; + derive_t diff_read_time; + derive_t diff_write_time; + + if (read_ops < ds->read_ops) + diff_read_ops = 1 + read_ops + + (UINT_MAX - ds->read_ops); + else + diff_read_ops = read_ops - ds->read_ops; + DEBUG ("disk plugin: disk_name = %s; read_ops = %"PRIi64"; " + "ds->read_ops = %"PRIi64"; diff_read_ops = %"PRIi64";", + disk_name, + read_ops, ds->read_ops, diff_read_ops); + + if (write_ops < ds->write_ops) + diff_write_ops = 1 + write_ops + + (UINT_MAX - ds->write_ops); + else + diff_write_ops = write_ops - ds->write_ops; + + if (read_time < ds->read_time) + diff_read_time = 1 + read_time + + (UINT_MAX - ds->read_time); + else + diff_read_time = read_time - ds->read_time; + + if (write_time < ds->write_time) + diff_write_time = 1 + write_time + + (UINT_MAX - ds->write_time); + else + diff_write_time = write_time - ds->write_time; - ds->read_sectors = read_sectors; - ds->write_sectors = write_sectors; - read_bytes = ds->read_bytes; - write_bytes = ds->write_bytes; + if (diff_read_ops != 0) + ds->avg_read_time += disk_calc_time_incr ( + diff_read_time, diff_read_ops); + if (diff_write_ops != 0) + ds->avg_write_time += disk_calc_time_incr ( + diff_write_time, diff_write_ops); + + ds->read_ops = read_ops; + ds->read_time = read_time; + ds->write_ops = write_ops; + ds->write_time = write_time; + } /* if (is_disk) */ /* Don't write to the RRDs if we've just started.. */ ds->poll_count++; - if (ds->poll_count <= min_poll_count) + if (ds->poll_count <= 2) { - DBG ("(ds->poll_count = %i) <= (min_poll_count = %i); => Not writing.", - ds->poll_count, min_poll_count); + DEBUG ("disk plugin: (ds->poll_count = %i) <= " + "(min_poll_count = 2); => Not writing.", + ds->poll_count); continue; } - if ((read_count == 0) && (write_count == 0)) + if ((read_ops == 0) && (write_ops == 0)) { - DBG ("((read_count == 0) && (write_count == 0)); => Not writing."); + DEBUG ("disk plugin: ((read_ops == 0) && " + "(write_ops == 0)); => Not writing."); continue; } + if ((ds->read_bytes != 0) || (ds->write_bytes != 0)) + disk_submit (disk_name, "disk_octets", + ds->read_bytes, ds->write_bytes); + + if ((ds->read_ops != 0) || (ds->write_ops != 0)) + disk_submit (disk_name, "disk_ops", + read_ops, write_ops); + + if ((ds->avg_read_time != 0) || (ds->avg_write_time != 0)) + disk_submit (disk_name, "disk_time", + ds->avg_read_time, ds->avg_write_time); + if (is_disk) - disk_submit (disk_name, read_count, read_merged, read_bytes, read_time, - write_count, write_merged, write_bytes, write_time); - else - partition_submit (disk_name, read_count, read_bytes, write_count, write_bytes); - } + { + disk_submit (disk_name, "disk_merged", + read_merged, write_merged); + } /* if (is_disk) */ + } /* while (fgets (buffer, sizeof (buffer), fh) != NULL) */ fclose (fh); /* #endif defined(KERNEL_LINUX) */ #elif HAVE_LIBKSTAT +# if HAVE_KSTAT_IO_T_WRITES && HAVE_KSTAT_IO_T_NWRITES && HAVE_KSTAT_IO_T_WTIME +# define KIO_ROCTETS reads +# define KIO_WOCTETS writes +# define KIO_ROPS nreads +# define KIO_WOPS nwrites +# define KIO_RTIME rtime +# define KIO_WTIME wtime +# elif HAVE_KSTAT_IO_T_NWRITTEN && HAVE_KSTAT_IO_T_WRITES && HAVE_KSTAT_IO_T_WTIME +# define KIO_ROCTETS nread +# define KIO_WOCTETS nwritten +# define KIO_ROPS reads +# define KIO_WOPS writes +# define KIO_RTIME rtime +# define KIO_WTIME wtime +# else +# error "kstat_io_t does not have the required members" +# endif static kstat_io_t kio; int i; if (kc == NULL) - return; + return (-1); for (i = 0; i < numdisk; i++) { @@ -590,24 +711,101 @@ static void disk_read (void) continue; if (strncmp (ksp[i]->ks_class, "disk", 4) == 0) - disk_submit (ksp[i]->ks_name, - kio.reads, 0LL, kio.nread, kio.rtime, - kio.writes, 0LL, kio.nwritten, kio.wtime); + { + disk_submit (ksp[i]->ks_name, "disk_octets", + kio.KIO_ROCTETS, kio.KIO_WOCTETS); + disk_submit (ksp[i]->ks_name, "disk_ops", + kio.KIO_ROPS, kio.KIO_WOPS); + /* FIXME: Convert this to microseconds if necessary */ + disk_submit (ksp[i]->ks_name, "disk_time", + kio.KIO_RTIME, kio.KIO_WTIME); + } else if (strncmp (ksp[i]->ks_class, "partition", 9) == 0) - partition_submit (ksp[i]->ks_name, - kio.reads, kio.nread, - kio.writes,kio.nwritten); + { + disk_submit (ksp[i]->ks_name, "disk_octets", + kio.KIO_ROCTETS, kio.KIO_WOCTETS); + disk_submit (ksp[i]->ks_name, "disk_ops", + kio.KIO_ROPS, kio.KIO_WOPS); + } } -#endif /* defined(HAVE_LIBKSTAT) */ -} /* static void disk_read (void) */ -#else -# define disk_read NULL -#endif /* DISK_HAVE_READ */ +/* #endif defined(HAVE_LIBKSTAT) */ + +#elif defined(HAVE_LIBSTATGRAB) + sg_disk_io_stats *ds; + int disks, counter; + char name[DATA_MAX_NAME_LEN]; + + if ((ds = sg_get_disk_io_stats(&disks)) == NULL) + return (0); + + for (counter=0; counter < disks; counter++) { + strncpy(name, ds->disk_name, sizeof(name)); + name[sizeof(name)-1] = '\0'; /* strncpy doesn't terminate longer strings */ + disk_submit (name, "disk_octets", ds->read_bytes, ds->write_bytes); + ds++; + } +/* #endif defined(HAVE_LIBSTATGRAB) */ + +#elif defined(HAVE_PERFSTAT) + derive_t read_sectors; + derive_t write_sectors; + derive_t read_time; + derive_t write_time; + derive_t read_ops; + derive_t write_ops; + perfstat_id_t firstpath; + int rnumdisk; + int i; + + if ((numdisk = perfstat_disk(NULL, NULL, sizeof(perfstat_disk_t), 0)) < 0) + { + char errbuf[1024]; + WARNING ("disk plugin: perfstat_disk: %s", + sstrerror (errno, errbuf, sizeof (errbuf))); + return (-1); + } + + if (numdisk != pnumdisk || stat_disk==NULL) { + if (stat_disk!=NULL) + free(stat_disk); + stat_disk = (perfstat_disk_t *)calloc(numdisk, sizeof(perfstat_disk_t)); + } + pnumdisk = numdisk; + + firstpath.name[0]='\0'; + if ((rnumdisk = perfstat_disk(&firstpath, stat_disk, sizeof(perfstat_disk_t), numdisk)) < 0) + { + char errbuf[1024]; + WARNING ("disk plugin: perfstat_disk : %s", + sstrerror (errno, errbuf, sizeof (errbuf))); + return (-1); + } + + for (i = 0; i < rnumdisk; i++) + { + read_sectors = stat_disk[i].rblks*stat_disk[i].bsize; + write_sectors = stat_disk[i].wblks*stat_disk[i].bsize; + disk_submit (stat_disk[i].name, "disk_octets", read_sectors, write_sectors); + + read_ops = stat_disk[i].xrate; + write_ops = stat_disk[i].xfers - stat_disk[i].xrate; + disk_submit (stat_disk[i].name, "disk_ops", read_ops, write_ops); + + read_time = stat_disk[i].rserv; + read_time *= ((double)(_system_configuration.Xint)/(double)(_system_configuration.Xfrac)) / 1000000.0; + write_time = stat_disk[i].wserv; + write_time *= ((double)(_system_configuration.Xint)/(double)(_system_configuration.Xfrac)) / 1000000.0; + disk_submit (stat_disk[i].name, "disk_time", read_time, write_time); + } +#endif /* defined(HAVE_PERFSTAT) */ + + return (0); +} /* int disk_read */ void module_register (void) { - plugin_register ("partition", NULL, NULL, partition_write); - plugin_register (MODULE_NAME, disk_init, disk_read, disk_write); -} - -#undef MODULE_NAME + plugin_register_config ("disk", disk_config, + config_keys, config_keys_num); + plugin_register_init ("disk", disk_init); + plugin_register_read ("disk", disk_read); +} /* void module_register */