diff options
Diffstat (limited to 'plugins/check_ide-smart.c')
-rw-r--r-- | plugins/check_ide-smart.c | 448 |
1 files changed, 448 insertions, 0 deletions
diff --git a/plugins/check_ide-smart.c b/plugins/check_ide-smart.c new file mode 100644 index 00000000..869f7dc0 --- /dev/null +++ b/plugins/check_ide-smart.c | |||
@@ -0,0 +1,448 @@ | |||
1 | /* | ||
2 | * check_ide-smart v.1 - hacked version of ide-smart for Nagios | ||
3 | * Copyright (C) 2000 Robert Dale <rdale@digital-mission.com> | ||
4 | * | ||
5 | * Net Saint - http://www.nagios.org | ||
6 | * | ||
7 | * Notes: | ||
8 | * ide-smart has the same functionality as before. Some return | ||
9 | * values were changed, otherwise the --net-saint option was added. | ||
10 | * | ||
11 | * Run with: check_ide-smart --net-saint [-d] <DRIVE> | ||
12 | * Where DRIVE is an IDE drive, ie. /dev/hda, /dev/hdb, /dev/hdc | ||
13 | * | ||
14 | * - Returns 0 on no errors | ||
15 | * - Returns 1 on advisories | ||
16 | * - Returns 2 on prefailure | ||
17 | * - Returns -1 not too often | ||
18 | * | ||
19 | * ide-smart 1.3 - IDE S.M.A.R.T. cheking tool | ||
20 | * Copyright (C) 1998-1999 Ragnar Hojland Espinosa <ragnar@lightside.dhis.org> | ||
21 | * 1998 Gadi Oxman <gadio@netvision.net.il> | ||
22 | * | ||
23 | * This program is free software; you can redistribute it and/or modify | ||
24 | * it under the terms of the GNU General Public License as published by | ||
25 | * the Free Software Foundation; either version 2 of the License, or | ||
26 | * (at your option) any later version. | ||
27 | * | ||
28 | * This program is distributed in the hope that it will be useful, | ||
29 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
30 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
31 | * GNU General Public License for more details. | ||
32 | * | ||
33 | * You should have received a copy of the GNU General Public License | ||
34 | * along with this program; if not, write to the Free Software | ||
35 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | ||
36 | */ | ||
37 | |||
38 | #include <stdio.h> | ||
39 | #include <sys/types.h> | ||
40 | #include <sys/stat.h> | ||
41 | #include <sys/ioctl.h> | ||
42 | #include <fcntl.h> | ||
43 | #include <string.h> | ||
44 | #include <unistd.h> | ||
45 | #include <linux/hdreg.h> | ||
46 | #include <linux/types.h> | ||
47 | #include <getopt.h> | ||
48 | #include <errno.h> | ||
49 | |||
50 | #define NR_ATTRIBUTES 30 | ||
51 | |||
52 | #ifndef TRUE | ||
53 | #define TRUE 1 | ||
54 | #endif /* */ | ||
55 | |||
56 | #define PREFAILURE 2 | ||
57 | #define ADVISORY 1 | ||
58 | #define OPERATIONAL 0 | ||
59 | #define UNKNOWN -1 | ||
60 | typedef struct threshold_s | ||
61 | { | ||
62 | __u8 id; | ||
63 | __u8 threshold; | ||
64 | __u8 reserved[10]; | ||
65 | } | ||
66 | __attribute__ ((packed)) threshold_t; | ||
67 | typedef struct thresholds_s | ||
68 | { | ||
69 | __u16 revision; | ||
70 | threshold_t thresholds[NR_ATTRIBUTES]; | ||
71 | __u8 reserved[18]; | ||
72 | __u8 vendor[131]; | ||
73 | __u8 checksum; | ||
74 | } | ||
75 | __attribute__ ((packed)) thresholds_t; | ||
76 | typedef struct value_s | ||
77 | { | ||
78 | __u8 id; | ||
79 | __u16 status; | ||
80 | __u8 value; | ||
81 | __u8 vendor[8]; | ||
82 | } | ||
83 | __attribute__ ((packed)) value_t; | ||
84 | typedef struct values_s | ||
85 | { | ||
86 | __u16 revision; | ||
87 | value_t values[NR_ATTRIBUTES]; | ||
88 | __u8 offline_status; | ||
89 | __u8 vendor1; | ||
90 | __u16 offline_timeout; | ||
91 | __u8 vendor2; | ||
92 | __u8 offline_capability; | ||
93 | __u16 smart_capability; | ||
94 | __u8 reserved[16]; | ||
95 | __u8 vendor[125]; | ||
96 | __u8 checksum; | ||
97 | } | ||
98 | __attribute__ ((packed)) values_t; | ||
99 | struct | ||
100 | { | ||
101 | __u8 value; | ||
102 | char *text; | ||
103 | } | ||
104 | offline_status_text[] = | ||
105 | { | ||
106 | { | ||
107 | 0x00, "NeverStarted"} | ||
108 | , { | ||
109 | 0x02, "Completed"} | ||
110 | , { | ||
111 | 0x04, "Suspended"} | ||
112 | , { | ||
113 | 0x05, "Aborted"} | ||
114 | , { | ||
115 | 0x06, "Failed"} | ||
116 | , { | ||
117 | 0, 0} | ||
118 | }; | ||
119 | struct | ||
120 | { | ||
121 | __u8 value; | ||
122 | char *text; | ||
123 | } | ||
124 | smart_command[] = | ||
125 | { | ||
126 | { | ||
127 | SMART_ENABLE, "SMART_ENABLE"} | ||
128 | , { | ||
129 | SMART_DISABLE, "SMART_DISABLE"} | ||
130 | , { | ||
131 | SMART_IMMEDIATE_OFFLINE, "SMART_IMMEDIATE_OFFLINE"} | ||
132 | , { | ||
133 | SMART_AUTO_OFFLINE, "SMART_AUTO_OFFLINE"} | ||
134 | , }; | ||
135 | |||
136 | |||
137 | /* Index to smart_command table, keep in order */ | ||
138 | enum SmartCommand | ||
139 | { SMART_CMD_ENABLE, SMART_CMD_DISABLE, SMART_CMD_IMMEDIATE_OFFLINE, | ||
140 | SMART_CMD_AUTO_OFFLINE | ||
141 | }; | ||
142 | char * | ||
143 | get_offline_text (int status) | ||
144 | { | ||
145 | int i; | ||
146 | for (i = 0; offline_status_text[i].text; i++) { | ||
147 | if (offline_status_text[i].value == status) { | ||
148 | return offline_status_text[i].text; | ||
149 | } | ||
150 | } | ||
151 | return "unknown"; | ||
152 | } | ||
153 | int | ||
154 | smart_read_values (int fd, values_t * values) | ||
155 | { | ||
156 | __u8 args[4 + 512] = { | ||
157 | WIN_SMART, 0, SMART_READ_VALUES, 1,}; | ||
158 | if (ioctl (fd, HDIO_DRIVE_CMD, &args)) { | ||
159 | int e = errno; | ||
160 | printf ("Critical: SMART_READ_VALUES: %s\n", strerror (errno)); | ||
161 | return e; | ||
162 | } | ||
163 | memcpy (values, args + 4, 512); | ||
164 | return 0; | ||
165 | } | ||
166 | int | ||
167 | values_not_passed (values_t * p, thresholds_t * t) | ||
168 | { | ||
169 | value_t * value = p->values; | ||
170 | threshold_t * threshold = t->thresholds; | ||
171 | int failed = 0; | ||
172 | int passed = 0; | ||
173 | int i; | ||
174 | for (i = 0; i < NR_ATTRIBUTES; i++) { | ||
175 | if (value->id && threshold->id && value->id == threshold->id) { | ||
176 | if (value->value <= threshold->threshold) { | ||
177 | ++failed; | ||
178 | } | ||
179 | else { | ||
180 | ++passed; | ||
181 | } | ||
182 | } | ||
183 | ++value; | ||
184 | ++threshold; | ||
185 | } | ||
186 | return (passed ? -failed : 2); | ||
187 | } | ||
188 | int | ||
189 | net_saint (values_t * p, thresholds_t * t) | ||
190 | { | ||
191 | value_t * value = p->values; | ||
192 | threshold_t * threshold = t->thresholds; | ||
193 | int status = OPERATIONAL; | ||
194 | int prefailure = 0; | ||
195 | int advisory = 0; | ||
196 | int failed = 0; | ||
197 | int passed = 0; | ||
198 | int total = 0; | ||
199 | int i; | ||
200 | for (i = 0; i < NR_ATTRIBUTES; i++) { | ||
201 | if (value->id && threshold->id && value->id == threshold->id) { | ||
202 | if (value->value <= threshold->threshold) { | ||
203 | ++failed; | ||
204 | if (value->status & 1) { | ||
205 | status = PREFAILURE; | ||
206 | ++prefailure; | ||
207 | } | ||
208 | else { | ||
209 | status = ADVISORY; | ||
210 | ++advisory; | ||
211 | } | ||
212 | } | ||
213 | else { | ||
214 | ++passed; | ||
215 | } | ||
216 | ++total; | ||
217 | } | ||
218 | ++value; | ||
219 | ++threshold; | ||
220 | } | ||
221 | switch (status) { | ||
222 | case PREFAILURE: | ||
223 | printf ("Critical: %d Harddrive PreFailure%cDetected! " | ||
224 | "%d/%d tests failed.\n", prefailure, prefailure > 1 ? 's' : ' ', | ||
225 | failed, total); | ||
226 | break; | ||
227 | case ADVISORY: | ||
228 | printf ("Warning: %d Harddrive Advisor%s Detected. " | ||
229 | "%d/%d tests failed.\n", advisory, advisory > 1 ? "ies" : "y", | ||
230 | failed, total); | ||
231 | break; | ||
232 | case OPERATIONAL: | ||
233 | printf ("Status: Operational (%d/%d tests passed)\n", passed, total); | ||
234 | break; | ||
235 | default: | ||
236 | printf ("Error: Status '%d' uknown. %d/%d tests passed\n", status, | ||
237 | passed, total); | ||
238 | status = -1; | ||
239 | break; | ||
240 | } | ||
241 | return status; | ||
242 | } | ||
243 | void | ||
244 | print_value (value_t * p, threshold_t * t) | ||
245 | { | ||
246 | printf ("Id=%3d, Status=%2d {%s , %s}, Value=%3d, Threshold=%3d, %s\n", | ||
247 | p->id, p->status, p->status & 1 ? "PreFailure" : "Advisory ", | ||
248 | p->status & 2 ? "OnLine " : "OffLine", p->value, t->threshold, | ||
249 | p->value > t->threshold ? "Passed" : "Failed"); | ||
250 | } | ||
251 | void | ||
252 | print_values (values_t * p, thresholds_t * t) | ||
253 | { | ||
254 | value_t * value = p->values; | ||
255 | threshold_t * threshold = t->thresholds; | ||
256 | int i; | ||
257 | for (i = 0; i < NR_ATTRIBUTES; i++) { | ||
258 | if (value->id && threshold->id && value->id == threshold->id) { | ||
259 | print_value (value++, threshold++); | ||
260 | } | ||
261 | } | ||
262 | printf | ||
263 | ("OffLineStatus=%d {%s}, AutoOffLine=%s, OffLineTimeout=%d minutes\n", | ||
264 | p->offline_status, get_offline_text (p->offline_status & 0x7f), | ||
265 | (p->offline_status & 0x80 ? "Yes" : "No"), p->offline_timeout / 60); | ||
266 | printf ("OffLineCapability=%d {%s %s %s}\n", p->offline_capability, | ||
267 | p->offline_capability & 1 ? "Immediate" : "", | ||
268 | p->offline_capability & 2 ? "Auto" : "", | ||
269 | p->offline_capability & 4 ? "AbortOnCmd" : "SuspendOnCmd"); | ||
270 | printf ("SmartRevision=%d, CheckSum=%d, SmartCapability=%d {%s %s}\n", | ||
271 | p->revision, p->checksum, p->smart_capability, | ||
272 | p->smart_capability & 1 ? "SaveOnStandBy" : "", | ||
273 | p->smart_capability & 2 ? "AutoSave" : ""); | ||
274 | } | ||
275 | void | ||
276 | print_thresholds (thresholds_t * p) | ||
277 | { | ||
278 | threshold_t * threshold = p->thresholds; | ||
279 | int i; | ||
280 | printf ("\n"); | ||
281 | printf ("SmartRevision=%d\n", p->revision); | ||
282 | for (i = 0; i < NR_ATTRIBUTES; i++) { | ||
283 | if (threshold->id) { | ||
284 | printf ("Id=%3d, Threshold=%3d\n", threshold->id, | ||
285 | threshold->threshold); } | ||
286 | ++threshold; | ||
287 | } | ||
288 | printf ("CheckSum=%d\n", p->checksum); | ||
289 | } | ||
290 | int | ||
291 | smart_cmd_simple (int fd, enum SmartCommand command, __u8 val0, | ||
292 | char show_error) | ||
293 | { | ||
294 | __u8 args[4] = { | ||
295 | WIN_SMART, val0, smart_command[command].value, 0}; | ||
296 | int e = 0; | ||
297 | if (ioctl (fd, HDIO_DRIVE_CMD, &args)) { | ||
298 | e = errno; | ||
299 | if (show_error) { | ||
300 | printf ("Critical: %s: %s\n", smart_command[command].text, | ||
301 | strerror (errno)); } | ||
302 | } | ||
303 | return e; | ||
304 | } | ||
305 | int | ||
306 | smart_read_thresholds (int fd, thresholds_t * thresholds) | ||
307 | { | ||
308 | __u8 args[4 + 512] = { | ||
309 | WIN_SMART, 0, SMART_READ_THRESHOLDS, 1,}; | ||
310 | if (ioctl (fd, HDIO_DRIVE_CMD, &args)) { | ||
311 | int e = errno; | ||
312 | printf ("Critical: SMART_READ_THRESHOLDS: %s\n", strerror (errno)); | ||
313 | return e; | ||
314 | } | ||
315 | memcpy (thresholds, args + 4, 512); | ||
316 | return 0; | ||
317 | } | ||
318 | void | ||
319 | show_version () | ||
320 | { | ||
321 | printf ("check_ide-smart v.1 - FREE Software with NO WARRANTY\n"); | ||
322 | printf ("Nagios feature - Robert Dale <rdale@digital-mission.com>\n"); | ||
323 | printf ("(C) 1999 Ragnar Hojland Espinosa <ragnar@lightside.dhis.org>\n"); | ||
324 | } | ||
325 | void | ||
326 | show_help () | ||
327 | { | ||
328 | printf ("Usage: check_ide-smart [DEVICE] [OPTION]\n" | ||
329 | " -d, --device=DEVICE Select device DEVICE\n" | ||
330 | " -i, --immediate Perform immediately offline tests\n" | ||
331 | " -q, --quiet-check Returns the number of failed tests\n" | ||
332 | " -1, --auto-on Turn on automatic offline tests\n" | ||
333 | " -0, --auto-off Turn off automatic offline tests\n" | ||
334 | " -n, --net-saint Output suitable for Net Saint\n" | ||
335 | " -h, --help\n" " -V, --version\n"); | ||
336 | } | ||
337 | int | ||
338 | main (int argc, char *argv[]) | ||
339 | { | ||
340 | char *device = NULL; | ||
341 | int command = -1; | ||
342 | int o, longindex; | ||
343 | int retval = 0; | ||
344 | |||
345 | #ifdef HAVE_GETOPT_H | ||
346 | const struct option longopts[] = { | ||
347 | {"device", required_argument, 0, 'd'}, | ||
348 | {"immediate", no_argument, 0, 'i'}, | ||
349 | {"quiet-check", no_argument, 0, 'q'}, | ||
350 | {"auto-on", no_argument, 0, '1'}, | ||
351 | {"auto-off", no_argument, 0, '0'}, | ||
352 | {"net-saint", no_argument, 0, 'n'}, | ||
353 | {"help", no_argument, 0, 'h'}, | ||
354 | {"version", no_argument, 0, 'V'}, {0, 0, 0, 0} | ||
355 | }; | ||
356 | |||
357 | #endif /* */ | ||
358 | while (1) { | ||
359 | |||
360 | #ifdef HAVE_GETOPT_H | ||
361 | o = getopt_long (argc, argv, "+d:iq10nhV", longopts, &longindex); | ||
362 | |||
363 | #else /* */ | ||
364 | o = getopt (argc, argv, "+d:iq10nhV"); | ||
365 | |||
366 | #endif /* */ | ||
367 | if (o == -1 || o == EOF) | ||
368 | break; | ||
369 | switch (o) { | ||
370 | case 'd': | ||
371 | device = optarg; | ||
372 | break; | ||
373 | case 'q': | ||
374 | command = 3; | ||
375 | break; | ||
376 | case 'i': | ||
377 | command = 2; | ||
378 | break; | ||
379 | case '1': | ||
380 | command = 1; | ||
381 | break; | ||
382 | case '0': | ||
383 | command = 0; | ||
384 | break; | ||
385 | case 'n': | ||
386 | command = 4; | ||
387 | break; | ||
388 | case 'h': | ||
389 | show_help (); | ||
390 | return 0; | ||
391 | case 'V': | ||
392 | show_version (); | ||
393 | return 0; | ||
394 | default: | ||
395 | printf ("Try `%s --help' for more information.\n", argv[0]); | ||
396 | return 1; | ||
397 | } | ||
398 | if (optind < argc) { | ||
399 | device = argv[optind]; | ||
400 | } | ||
401 | if (!device) { | ||
402 | show_help (); | ||
403 | show_version (); | ||
404 | return -1; | ||
405 | } | ||
406 | if (1) { | ||
407 | thresholds_t thresholds; | ||
408 | values_t values; | ||
409 | int fd = open (device, O_RDONLY); | ||
410 | if (fd < 0) { | ||
411 | printf ("Critical: Couldn't open device: %s\n", strerror (errno)); | ||
412 | return 2; | ||
413 | } | ||
414 | if (smart_cmd_simple (fd, SMART_CMD_ENABLE, 0, TRUE)) { | ||
415 | printf ("Critical: SMART_CMD_ENABLE\n"); | ||
416 | return 2; | ||
417 | } | ||
418 | switch (command) { | ||
419 | case 0: | ||
420 | retval = smart_cmd_simple (fd, SMART_CMD_AUTO_OFFLINE, 0, TRUE); | ||
421 | break; | ||
422 | case 1: | ||
423 | retval = smart_cmd_simple (fd, SMART_CMD_AUTO_OFFLINE, 0xF8, TRUE); | ||
424 | break; | ||
425 | case 2: | ||
426 | retval = smart_cmd_simple (fd, SMART_CMD_IMMEDIATE_OFFLINE, 0, TRUE); | ||
427 | break; | ||
428 | case 3: | ||
429 | smart_read_values (fd, &values); | ||
430 | smart_read_thresholds (fd, &thresholds); | ||
431 | retval = values_not_passed (&values, &thresholds); | ||
432 | break; | ||
433 | case 4: | ||
434 | smart_read_values (fd, &values); | ||
435 | smart_read_thresholds (fd, &thresholds); | ||
436 | retval = net_saint (&values, &thresholds); | ||
437 | break; | ||
438 | default: | ||
439 | smart_read_values (fd, &values); | ||
440 | smart_read_thresholds (fd, &thresholds); | ||
441 | print_values (&values, &thresholds); | ||
442 | break; | ||
443 | } | ||
444 | close (fd); | ||
445 | } | ||
446 | return retval; | ||
447 | } | ||
448 | |||