1 /**
2 * collectd - src/md.c
3 * Copyright (C) 2010,2011 Michael Hanselmann
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License as published by the
7 * Free Software Foundation; only version 2 of the License is applicable.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 *
18 * Author:
19 * Michael Hanselmann
20 **/
22 #include "collectd.h"
24 #include "common.h"
25 #include "plugin.h"
26 #include "utils_ignorelist.h"
28 #include <sys/ioctl.h>
30 #include <linux/major.h>
31 #include <linux/raid/md_u.h>
33 #ifdef HAVE_SYS_SYSMACROS_H
34 #include <sys/sysmacros.h>
35 #endif
37 #define PROC_DISKSTATS "/proc/diskstats"
38 #define DEV_DIR "/dev"
40 static const char *config_keys[] = {"Device", "IgnoreSelected"};
41 static int config_keys_num = STATIC_ARRAY_SIZE(config_keys);
43 static ignorelist_t *ignorelist = NULL;
45 static int md_config(const char *key, const char *value) {
46 if (ignorelist == NULL)
47 ignorelist = ignorelist_create(/* invert = */ 1);
48 if (ignorelist == NULL)
49 return (1);
51 if (strcasecmp(key, "Device") == 0) {
52 ignorelist_add(ignorelist, value);
53 } else if (strcasecmp(key, "IgnoreSelected") == 0) {
54 ignorelist_set_invert(ignorelist, IS_TRUE(value) ? 0 : 1);
55 } else {
56 return (-1);
57 }
59 return (0);
60 }
62 static void md_submit(const int minor, const char *type_instance,
63 gauge_t value) {
64 value_t values[1];
65 value_list_t vl = VALUE_LIST_INIT;
67 values[0].gauge = value;
69 vl.values = values;
70 vl.values_len = 1;
71 sstrncpy(vl.host, hostname_g, sizeof(vl.host));
72 sstrncpy(vl.plugin, "md", sizeof(vl.plugin));
73 ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%i", minor);
74 sstrncpy(vl.type, "md_disks", sizeof(vl.type));
75 sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
77 plugin_dispatch_values(&vl);
78 } /* void md_submit */
80 static void md_process(const int minor, const char *path) {
81 char errbuf[1024];
82 int fd;
83 struct stat st;
84 mdu_array_info_t array;
85 gauge_t disks_missing;
87 fd = open(path, O_RDONLY);
88 if (fd < 0) {
89 WARNING("md: open(%s): %s", path, sstrerror(errno, errbuf, sizeof(errbuf)));
90 return;
91 }
93 if (fstat(fd, &st) < 0) {
94 WARNING("md: Unable to fstat file descriptor for %s: %s", path,
95 sstrerror(errno, errbuf, sizeof(errbuf)));
96 close(fd);
97 return;
98 }
100 if (!S_ISBLK(st.st_mode)) {
101 WARNING("md: %s is no block device", path);
102 close(fd);
103 return;
104 }
106 if (st.st_rdev != makedev(MD_MAJOR, minor)) {
107 WARNING("md: Major/minor of %s are %i:%i, should be %i:%i", path,
108 (int)major(st.st_rdev), (int)minor(st.st_rdev), (int)MD_MAJOR,
109 minor);
110 close(fd);
111 return;
112 }
114 /* Retrieve md information */
115 if (ioctl(fd, GET_ARRAY_INFO, &array) < 0) {
116 WARNING("md: Unable to retrieve array info from %s: %s", path,
117 sstrerror(errno, errbuf, sizeof(errbuf)));
118 close(fd);
119 return;
120 }
122 close(fd);
124 /*
125 * The mdu_array_info_t structure contains numbers of disks in the array.
126 * However, disks are accounted for more than once:
127 *
128 * active: Number of active (in sync) disks.
129 * spare: Number of stand-by disks.
130 * working: Number of working disks. (active + sync)
131 * failed: Number of failed disks.
132 * nr: Number of physically present disks. (working + failed)
133 * raid: Number of disks in the RAID. This may be larger than "nr" if
134 * disks are missing and smaller than "nr" when spare disks are
135 * around.
136 */
137 md_submit(minor, "active", (gauge_t)array.active_disks);
138 md_submit(minor, "failed", (gauge_t)array.failed_disks);
139 md_submit(minor, "spare", (gauge_t)array.spare_disks);
141 disks_missing = 0.0;
142 if (array.raid_disks > array.nr_disks)
143 disks_missing = (gauge_t)(array.raid_disks - array.nr_disks);
144 md_submit(minor, "missing", disks_missing);
145 } /* void md_process */
147 static int md_read(void) {
148 FILE *fh;
149 char buffer[1024];
151 fh = fopen(PROC_DISKSTATS, "r");
152 if (fh == NULL) {
153 char errbuf[1024];
154 WARNING("md: Unable to open %s: %s", PROC_DISKSTATS,
155 sstrerror(errno, errbuf, sizeof(errbuf)));
156 return (-1);
157 }
159 /* Iterate md devices */
160 while (fgets(buffer, sizeof(buffer), fh) != NULL) {
161 char path[PATH_MAX];
162 char *fields[4];
163 char *name;
164 int major, minor;
166 /* Extract interesting fields */
167 if (strsplit(buffer, fields, STATIC_ARRAY_SIZE(fields)) < 3)
168 continue;
170 major = atoi(fields[0]);
172 if (major != MD_MAJOR)
173 continue;
175 minor = atoi(fields[1]);
176 name = fields[2];
178 if (ignorelist_match(ignorelist, name))
179 continue;
181 /* FIXME: Don't hardcode path. Walk /dev collecting major,
182 * minor and name, then use lookup table to find device.
183 * Alternatively create a temporary device file with correct
184 * major/minor, but that again can be tricky if the filesystem
185 * with the device file is mounted using the "nodev" option.
186 */
187 ssnprintf(path, sizeof(path), "%s/%s", DEV_DIR, name);
189 md_process(minor, path);
190 }
192 fclose(fh);
194 return (0);
195 } /* int md_read */
197 void module_register(void) {
198 plugin_register_config("md", md_config, config_keys, config_keys_num);
199 plugin_register_read("md", md_read);
200 } /* void module_register */