![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
diff --git a/plugins/check_disk.c b/plugins/check_disk.c
index b8bbdbda3acf04568194284cb4fe03605c1f4167..f88976473de16b8ea15b6146f13bd20f2bf4ec49 100644 (file)
--- a/plugins/check_disk.c
+++ b/plugins/check_disk.c
-/******************************************************************************
-*
+/*****************************************************************************
+*
* Nagios check_disk plugin
-*
+*
* License: GPL
-* Copyright (c) 1999-2006 nagios-plugins team
-*
-* Last Modified: $Date$
-*
+* Copyright (c) 1999-2008 Nagios Plugins Development Team
+*
* Description:
-*
+*
* This file contains the check_disk plugin
-*
-* License Information:
-*
-* This program is free software; you can redistribute it and/or modify
+*
+*
+* 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
+* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
-*
+*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
-*
+*
* You should have received a copy of the GNU General Public License
-* along with this program; if not, write to the Free Software
-* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-*
-* $Id$
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*
*
*****************************************************************************/
const char *progname = "check_disk";
const char *program_name = "check_disk"; /* Required for coreutils libs */
-const char *revision = "$Revision$";
-const char *copyright = "1999-2006";
+const char *copyright = "1999-2008";
const char *email = "nagiosplug-devel@lists.sourceforge.net";
#pragma alloca
#endif
-/* Linked list of mounted filesystems. */
-static struct mount_entry *mount_list;
-
int process_arguments (int, char **);
void print_path (const char *mypath);
void set_all_thresholds (struct parameter_list *path);
void print_usage (void);
double calculate_percent(uintmax_t, uintmax_t);
void stat_path (struct parameter_list *p);
+void get_stats (struct parameter_list *p, struct fs_usage *fsp);
+void get_path_stats (struct parameter_list *p, struct fs_usage *fsp);
double w_dfp = -1.0;
double c_dfp = -1.0;
int path_selected = FALSE;
char *group = NULL;
struct stat *stat_buf;
+struct name_list *seen = NULL;
int
char *perf;
char *preamble;
double inode_space_pct;
- uintmax_t total, available, available_to_root, used;
- double dfree_pct = -1, dused_pct = -1;
- double dused_units, dfree_units, dtotal_units;
- double dused_inodes_percent, dfree_inodes_percent;
double warning_high_tide;
double critical_high_tide;
int temp_result;
struct mount_entry *me;
struct fs_usage fsp, tmpfsp;
struct parameter_list *temp_list, *path;
- struct name_list *seen = NULL;
preamble = strdup (" - free space:");
output = strdup ("");
mount_list = read_file_system_list (0);
+ /* Parse extra opts if any */
+ argv = np_extra_opts (&argc, argv, progname);
+
if (process_arguments (argc, argv) == ERROR)
usage4 (_("Could not parse arguments"));
/* If a list of paths has not been selected, find entire
mount list and create list of paths
*/
- if (path_selected == FALSE) {
+ if (path_selected == FALSE) {
for (me = mount_list; me; me = me->me_next) {
if (! (path = np_find_parameter(path_select_list, me->me_mountdir))) {
path = np_add_parameter(&path_select_list, me->me_mountdir);
temp_list = temp_list->name_next;
}
-
+
/* Process for every path in list */
for (path = path_select_list; path; path=path->name_next) {
- if (verbose > 3 && path->freespace_percent->warning != NULL && path->freespace_percent->critical != NULL)
+ if (verbose >= 3 && path->freespace_percent->warning != NULL && path->freespace_percent->critical != NULL)
printf("Thresholds(pct) for %s warn: %f crit %f\n",path->name, path->freespace_percent->warning->end,
path->freespace_percent->critical->end);
- if (verbose > 3 && path->group != NULL)
+ if (verbose >= 3 && path->group != NULL)
printf("Group of %s: %s\n",path->name,path->group);
/* reset disk result */
/* Remove filesystems already seen */
if (np_seen_name(seen, me->me_mountdir)) {
continue;
- } else {
- if (path->group != NULL) {
- /* find all group members */
- fsp.fsu_blocksize = 0;
- fsp.fsu_blocks = 0;
- fsp.fsu_bfree = 0;
- fsp.fsu_bavail = 0;
- fsp.fsu_files = 0;
- fsp.fsu_ffree = 0;
-
-
- for (temp_list = path_select_list; temp_list; temp_list=temp_list->name_next) {
- if (temp_list->group && ! (strcmp(temp_list->group, path->group))) {
-
- stat_path(path);
- get_fs_usage (temp_list->best_match->me_mountdir, temp_list->best_match->me_devname, &tmpfsp);
-
- /* possibly differing blocksizes if disks are grouped. Calculating average */
- fsp.fsu_blocksize = (fsp.fsu_blocksize * fsp.fsu_blocks + tmpfsp.fsu_blocksize * tmpfsp.fsu_blocks) / \
- (fsp.fsu_blocks + tmpfsp.fsu_blocks); /* Size of a block. */
- fsp.fsu_blocks += tmpfsp.fsu_blocks; /* Total blocks. */
- fsp.fsu_bfree += tmpfsp.fsu_bfree; /* Free blocks available to superuser. */
- fsp.fsu_bavail += tmpfsp.fsu_bavail; /* Free blocks available to non-superuser. */
- fsp.fsu_files += tmpfsp.fsu_files; /* Total file nodes. */
- fsp.fsu_ffree += tmpfsp.fsu_ffree; /* Free file nodes. */
-
- if (verbose > 3)
- printf("Group %s: add %llu blocks (%s) \n", path->group, tmpfsp.fsu_bavail, temp_list->name);
- /* printf("Group %s: add %u blocks (%s)\n", temp_list->name); *//* path->group, tmpfsp.fsu_bavail, temp_list->name); */
-
- np_add_name(&seen, temp_list->best_match->me_mountdir);
- }
- }
- /* modify devname and mountdir for output */
- me->me_mountdir = me->me_devname = path->group;
- } else
- np_add_name(&seen, me->me_mountdir);
- }
+ }
+ np_add_name(&seen, me->me_mountdir);
if (path->group == NULL) {
/* Skip remote filesystems if we're not interested in them */
/* Skip excluded fstypes */
} else if (fs_exclude_list && np_find_name (fs_exclude_list, me->me_type)) {
continue;
- /* Skip excluded fs's */
- } else if (dp_exclude_list &&
+ /* Skip excluded fs's */
+ } else if (dp_exclude_list &&
(np_find_name (dp_exclude_list, me->me_devname) ||
np_find_name (dp_exclude_list, me->me_mountdir))) {
continue;
}
if (fsp.fsu_blocks && strcmp ("none", me->me_mountdir)) {
- total = fsp.fsu_blocks;
- /* 2007-12-08 - Workaround for Gnulib reporting insanely high available
- * space on BSD (the actual value should be negative but fsp.fsu_bavail
- * is unsigned) */
- available = fsp.fsu_bavail > fsp.fsu_bfree ? 0 : fsp.fsu_bavail;
- available_to_root = fsp.fsu_bfree;
- used = total - available_to_root;
-
- if (verbose >= 3)
- printf ("For %s, total=%llu, available=%llu, available_to_root=%llu, used=%llu, fsp.fsu_files=%llu, fsp.fsu_ffree=%llu\n",
- me->me_mountdir, total, available, available_to_root, used, fsp.fsu_files, fsp.fsu_ffree);
-
- dused_pct = calculate_percent( used, used + available ); /* used + available can never be > uintmax */
-
- dfree_pct = 100 - dused_pct;
- dused_units = used*fsp.fsu_blocksize/mult;
- dfree_units = available*fsp.fsu_blocksize/mult;
- dtotal_units = total*fsp.fsu_blocksize/mult;
- dused_inodes_percent = calculate_percent(fsp.fsu_files - fsp.fsu_ffree, fsp.fsu_files);
- dfree_inodes_percent = 100 - dused_inodes_percent;
+ get_stats (path, &fsp);
if (verbose >= 3) {
- printf ("For %s, used_pct=%g free_pct=%g used_units=%g free_units=%g total_units=%g used_inodes_pct=%g free_inodes_pct=%g fsp.fsu_blocksize=%llu mult=%llu\n",
- me->me_mountdir, dused_pct, dfree_pct, dused_units, dfree_units, dtotal_units, dused_inodes_percent, dfree_inodes_percent, fsp.fsu_blocksize, mult);
+ printf ("For %s, used_pct=%g free_pct=%g used_units=%g free_units=%g total_units=%g used_inodes_pct=%g free_inodes_pct=%g fsp.fsu_blocksize=%llu mult=%llu\n",
+ me->me_mountdir, path->dused_pct, path->dfree_pct, path->dused_units, path->dfree_units, path->dtotal_units, path->dused_inodes_percent, path->dfree_inodes_percent, fsp.fsu_blocksize, mult);
}
/* Threshold comparisons */
- temp_result = get_status(dfree_units, path->freespace_units);
+ temp_result = get_status(path->dfree_units, path->freespace_units);
if (verbose >=3) printf("Freespace_units result=%d\n", temp_result);
disk_result = max_state( disk_result, temp_result );
- temp_result = get_status(dfree_pct, path->freespace_percent);
+ temp_result = get_status(path->dfree_pct, path->freespace_percent);
if (verbose >=3) printf("Freespace%% result=%d\n", temp_result);
disk_result = max_state( disk_result, temp_result );
- temp_result = get_status(dused_units, path->usedspace_units);
+ temp_result = get_status(path->dused_units, path->usedspace_units);
if (verbose >=3) printf("Usedspace_units result=%d\n", temp_result);
disk_result = max_state( disk_result, temp_result );
- temp_result = get_status(dused_pct, path->usedspace_percent);
+ temp_result = get_status(path->dused_pct, path->usedspace_percent);
if (verbose >=3) printf("Usedspace_percent result=%d\n", temp_result);
disk_result = max_state( disk_result, temp_result );
- temp_result = get_status(dused_inodes_percent, path->usedinodes_percent);
+ temp_result = get_status(path->dused_inodes_percent, path->usedinodes_percent);
if (verbose >=3) printf("Usedinodes_percent result=%d\n", temp_result);
disk_result = max_state( disk_result, temp_result );
- temp_result = get_status(dfree_inodes_percent, path->freeinodes_percent);
+ temp_result = get_status(path->dfree_inodes_percent, path->freeinodes_percent);
if (verbose >=3) printf("Freeinodes_percent result=%d\n", temp_result);
disk_result = max_state( disk_result, temp_result );
critical_high_tide = UINT_MAX;
if (path->freespace_units->warning != NULL) {
- warning_high_tide = dtotal_units - path->freespace_units->warning->end;
+ warning_high_tide = path->dtotal_units - path->freespace_units->warning->end;
}
if (path->freespace_percent->warning != NULL) {
- warning_high_tide = abs( min( (double) warning_high_tide, (double) (1.0 - path->freespace_percent->warning->end/100)*dtotal_units ));
+ warning_high_tide = abs( min( (double) warning_high_tide, (double) (1.0 - path->freespace_percent->warning->end/100)*path->dtotal_units ));
}
if (path->freespace_units->critical != NULL) {
- critical_high_tide = dtotal_units - path->freespace_units->critical->end;
+ critical_high_tide = path->dtotal_units - path->freespace_units->critical->end;
}
if (path->freespace_percent->critical != NULL) {
- critical_high_tide = abs( min( (double) critical_high_tide, (double) (1.0 - path->freespace_percent->critical->end/100)*dtotal_units ));
+ critical_high_tide = abs( min( (double) critical_high_tide, (double) (1.0 - path->freespace_percent->critical->end/100)*path->dtotal_units ));
}
/* Nb: *_high_tide are unset when == UINT_MAX */
asprintf (&perf, "%s %s", perf,
perfdata ((!strcmp(me->me_mountdir, "none") || display_mntp) ? me->me_devname : me->me_mountdir,
- dused_units, units,
- (warning_high_tide != UINT_MAX ? TRUE : FALSE), warning_high_tide,
- (critical_high_tide != UINT_MAX ? TRUE : FALSE), critical_high_tide,
- TRUE, 0,
- TRUE, dtotal_units));
+ path->dused_units, units,
+ (warning_high_tide != UINT_MAX ? TRUE : FALSE), warning_high_tide,
+ (critical_high_tide != UINT_MAX ? TRUE : FALSE), critical_high_tide,
+ TRUE, 0,
+ TRUE, path->dtotal_units));
if (disk_result==STATE_OK && erronly && !verbose)
continue;
asprintf (&output, "%s %s %.0f %s (%.0f%%",
output,
(!strcmp(me->me_mountdir, "none") || display_mntp) ? me->me_devname : me->me_mountdir,
- dfree_units,
+ path->dfree_units,
units,
- dfree_pct);
- if (dused_inodes_percent < 0) {
+ path->dfree_pct);
+ if (path->dused_inodes_percent < 0) {
asprintf(&output, "%s inode=-);", output);
} else {
- asprintf(&output, "%s inode=%.0f%%);", output, dfree_inodes_percent );
+ asprintf(&output, "%s inode=%.0f%%);", output, path->dfree_inodes_percent );
}
/* TODO: Need to do a similar debug line
}
- if (verbose > 2)
+ if (verbose >= 2)
asprintf (&output, "%s%s", output, details);
double pct = -1;
/* I don't understand the below, but it is taken from coreutils' df */
/* Seems to be calculating pct, in the best possible way */
- if (value <= TYPE_MAXIMUM(uintmax_t) / 100
+ if (value <= TYPE_MAXIMUM(uintmax_t) / 100
&& total != 0) {
uintmax_t u100 = value * 100;
pct = u100 / total + (u100 % total != 0);
{"iwarning", required_argument, 0, 'W'},
/* Dang, -C is taken. We might want to reshuffle this. */
{"icritical", required_argument, 0, 'K'},
- {"local", required_argument, 0, 'l'},
- {"stat-remote-fs", required_argument, 0, 'L'},
- {"kilobytes", required_argument, 0, 'k'},
- {"megabytes", required_argument, 0, 'm'},
+ {"kilobytes", no_argument, 0, 'k'},
+ {"megabytes", no_argument, 0, 'm'},
{"units", required_argument, 0, 'u'},
{"path", required_argument, 0, 'p'},
{"partition", required_argument, 0, 'p'},
{"ignore-ereg-partition", required_argument, 0, 'i'},
{"ignore-eregi-path", required_argument, 0, 'I'},
{"ignore-eregi-partition", required_argument, 0, 'I'},
+ {"local", no_argument, 0, 'l'},
+ {"stat-remote-fs", no_argument, 0, 'L'},
{"mountpoint", no_argument, 0, 'M'},
{"errors-only", no_argument, 0, 'e'},
{"exact-match", no_argument, 0, 'E'},
}
} else {
if (*optarg == '@') {
- warn_freespace_units = optarg;
+ warn_freespace_units = optarg;
} else {
asprintf(&warn_freespace_units, "@%s", optarg);
}
}
break;
- /* Awful mistake where the range values do not make sense. Normally,
+ /* Awful mistake where the range values do not make sense. Normally,
you alert if the value is within the range, but since we are using
freespace, we have to alert if outside the range. Thus we artifically
force @ at the beginning of the range, so that it is backwards compatible
case 'L':
stat_remote_fs = 1;
case 'l':
- show_local_fs = 1;
+ show_local_fs = 1;
break;
case 'p': /* select path */
- if (! (warn_freespace_units || crit_freespace_units || warn_freespace_percent ||
+ if (! (warn_freespace_units || crit_freespace_units || warn_freespace_percent ||
crit_freespace_percent || warn_usedspace_units || crit_usedspace_units ||
warn_usedspace_percent || crit_usedspace_percent || warn_usedinodes_percent ||
crit_usedinodes_percent || warn_freeinodes_percent || crit_freeinodes_percent )) {
}
se->group = group;
set_all_thresholds(se);
- np_set_best_match(se, mount_list, exact_match);
+
+ /* With autofs, it is required to stat() the path before re-populating the mount_list */
stat_path(se);
+ /* NB: We can't free the old mount_list "just like that": both list pointers and struct
+ * pointers are copied around. One of the reason it wasn't done yet is that other parts
+ * of check_disk need the same kind of cleanup so it'd better be done as a whole */
+ mount_list = read_file_system_list (0);
+ np_set_best_match(se, mount_list, exact_match);
+
path_selected = TRUE;
break;
case 'x': /* exclude path or partition */
break;
case 'E':
if (path_selected)
- die (STATE_UNKNOWN, "DISK %s: %s", _("UNKNOWN"), _("Must set -E before selecting pathes\n"));
+ die (STATE_UNKNOWN, "DISK %s: %s", _("UNKNOWN"), _("Must set -E before selecting paths\n"));
exact_match = TRUE;
break;
case 'g':
if (path_selected)
- die (STATE_UNKNOWN, "DISK %s: %s", _("UNKNOWN"), _("Must set group value before selecting pathes \n"));
+ die (STATE_UNKNOWN, "DISK %s: %s", _("UNKNOWN"), _("Must set group value before selecting paths\n"));
group = optarg;
break;
case 'I':
cflags |= REG_ICASE;
case 'i':
if (!path_selected)
- die (STATE_UNKNOWN, "DISK %s: %s\n", _("UNKNOWN"), _("Pathes need to be selected before using -i/-I. Use -A to select all pathes explicitly"));
+ die (STATE_UNKNOWN, "DISK %s: %s\n", _("UNKNOWN"), _("Paths need to be selected before using -i/-I. Use -A to select all paths explicitly"));
err = regcomp(&re, optarg, cflags);
if (err != 0) {
regerror (err, &re, errbuf, MAX_INPUT_BUFFER);
while (temp_list) {
if (temp_list->best_match) {
if (np_regex_match_mount_entry(temp_list->best_match, &re)) {
-
+
if (verbose >=3)
- printf("ignoring %s matching regex\n", temp_list->name);
+ printf("ignoring %s matching regex\n", temp_list->name);
temp_list = np_del_parameter(temp_list, previous);
- /* pointer to first element needs to be uüdated if first item gets deleted */
+ /* pointer to first element needs to be updated if first item gets deleted */
if (previous == NULL)
path_select_list = temp_list;
} else {
case 'R':
cflags |= REG_ICASE;
case 'r':
- if (! (warn_freespace_units || crit_freespace_units || warn_freespace_percent ||
+ if (! (warn_freespace_units || crit_freespace_units || warn_freespace_percent ||
crit_freespace_percent || warn_usedspace_units || crit_usedspace_units ||
warn_usedspace_percent || crit_usedspace_percent || warn_usedinodes_percent ||
crit_usedinodes_percent || warn_freeinodes_percent || crit_freeinodes_percent )) {
regerror (err, &re, errbuf, MAX_INPUT_BUFFER);
die (STATE_UNKNOWN, "DISK %s: %s - %s\n",_("UNKNOWN"), _("Could not compile regular expression"), errbuf);
}
-
+
for (me = mount_list; me; me = me->me_next) {
if (np_regex_match_mount_entry(me, &re)) {
fnd = TRUE;
- if (verbose > 3)
+ if (verbose >= 3)
printf("%s %s matching expression %s\n", me->me_devname, me->me_mountdir, optarg);
/* add parameter if not found. overwrite thresholds if path has already been added */
case 'C':
/* add all mount entries to path_select list if no partitions have been explicitly defined using -p */
if (path_selected == FALSE) {
- struct mount_entry *me;
struct parameter_list *path;
for (me = mount_list; me; me = me->me_next) {
- if (! (path = np_find_parameter(path_select_list, me->me_mountdir)))
+ if (! (path = np_find_parameter(path_select_list, me->me_mountdir)))
path = np_add_parameter(&path_select_list, me->me_mountdir);
path->best_match = me;
path->group = group;
crit_usedinodes_percent = NULL;
warn_freeinodes_percent = NULL;
crit_freeinodes_percent = NULL;
-
+
path_selected = FALSE;
group = NULL;
break;
case 'V': /* version */
- print_revision (progname, revision);
+ print_revision (progname, NP_VERSION);
exit (STATE_OK);
case 'h': /* help */
print_help ();
void
-print_path (const char *mypath)
+print_path (const char *mypath)
{
if (mypath == NULL)
printf ("\n");
void
-set_all_thresholds (struct parameter_list *path)
+set_all_thresholds (struct parameter_list *path)
{
+ if (path->freespace_units != NULL) free(path->freespace_units);
set_thresholds(&path->freespace_units, warn_freespace_units, crit_freespace_units);
+ if (path->freespace_percent != NULL) free (path->freespace_percent);
set_thresholds(&path->freespace_percent, warn_freespace_percent, crit_freespace_percent);
+ if (path->usedspace_units != NULL) free (path->usedspace_units);
set_thresholds(&path->usedspace_units, warn_usedspace_units, crit_usedspace_units);
+ if (path->usedspace_percent != NULL) free (path->usedspace_percent);
set_thresholds(&path->usedspace_percent, warn_usedspace_percent, crit_usedspace_percent);
+ if (path->usedinodes_percent != NULL) free (path->usedinodes_percent);
set_thresholds(&path->usedinodes_percent, warn_usedinodes_percent, crit_usedinodes_percent);
+ if (path->freeinodes_percent != NULL) free (path->freeinodes_percent);
set_thresholds(&path->freeinodes_percent, warn_freeinodes_percent, crit_freeinodes_percent);
}
@@ -870,7 +819,7 @@ INPUT ERROR: C_DF (%lu) should be less than W_DF (%lu) and both should be greate
print_path (mypath);
return ERROR;
}
-
+
return OK;
}
@@ -885,7 +834,7 @@ INPUT ERROR: C_DF (%lu) should be less than W_DF (%lu) and both should be greate
void
print_help (void)
{
- print_revision (progname, revision);
+ print_revision (progname, NP_VERSION);
printf ("Copyright (c) 1999 Ethan Galstad <nagios@nagios.org>\n");
printf (COPYRIGHT, copyright, email);
print_usage ();
- printf (_(UT_HELP_VRSN));
+ printf (UT_HELP_VRSN);
+ printf (UT_EXTRA_OPTS);
printf (" %s\n", "-w, --warning=INTEGER");
printf (" %s\n", _("Exit with WARNING status if less than INTEGER units of disk are free"));
printf (" %s\n", "-e, --errors-only");
printf (" %s\n", _("Display only devices/mountpoints with errors"));
printf (" %s\n", "-g, --group=NAME");
- printf (" %s\n", _("Group pathes. Thresholds apply to (free-)space of all partitions together"));
+ printf (" %s\n", _("Group paths. Thresholds apply to (free-)space of all partitions together"));
printf (" %s\n", "-k, --kilobytes");
printf (" %s\n", _("Same as '--units kB'"));
printf (" %s\n", "-l, --local");
printf (" %s\n", "-m, --megabytes");
printf (" %s\n", _("Same as '--units MB'"));
printf (" %s\n", "-A, --all");
- printf (" %s\n", _("Explicitly select all pathes. This is equivalent to -R '.*'"));
+ printf (" %s\n", _("Explicitly select all paths. This is equivalent to -R '.*'"));
printf (" %s\n", "-R, --eregi-path=PATH, --eregi-partition=PARTITION");
printf (" %s\n", _("Case insensitive regular expression for path/partition (may be repeated)"));
printf (" %s\n", "-r, --ereg-path=PATH, --ereg-partition=PARTITION");
printf (" %s\n", _("Regular expression to ignore selected path/partition (case insensitive) (may be repeated)"));
printf (" %s\n", "-i, --ignore-ereg-path=PATH, --ignore-ereg-partition=PARTITION");
printf (" %s\n", _("Regular expression to ignore selected path or partition (may be repeated)"));
- printf (_(UT_TIMEOUT), DEFAULT_SOCKET_TIMEOUT);
+ printf (UT_TIMEOUT, DEFAULT_SOCKET_TIMEOUT);
printf (" %s\n", "-u, --units=STRING");
printf (" %s\n", _("Choose bytes, kB, MB, GB, TB (default: MB)"));
- printf (_(UT_VERBOSE));
+ printf (UT_VERBOSE);
printf (" %s\n", "-X, --exclude-type=TYPE");
printf (" %s\n", _("Ignore all filesystems of indicated type (may be repeated)"));
+
printf ("\n");
printf ("%s\n", _("Examples:"));
printf (" %s\n", "check_disk -w 10% -c 5% -p /tmp -p /var -C -w 100000 -c 50000 -p /");
printf (" %s\n", _("Checks /tmp and /var at 10% and 5%, and / at 100MB and 50MB"));
- printf (" %s\n", "check_disk -w 100M -c 50M -C -w 1000M -c 500M -g sidDATA -r '^/oracle/SID/data.*$'");
+ printf (" %s\n", "check_disk -w 100 -c 50 -C -w 1000 -c 500 -g sidDATA -r '^/oracle/SID/data.*$'");
printf (" %s\n", _("Checks all filesystems not matching -r at 100M and 50M. The fs matching the -r regex"));
printf (" %s\n", _("are grouped which means the freespace thresholds are applied to all disks together"));
- printf (" %s\n", "check_disk -w 100M -c 50M -C -w 1000M -c 500M -p /foo -C -w 5% -c 3% -p /bar");
+ printf (" %s\n", "check_disk -w 100 -c 50 -C -w 1000 -c 500 -p /foo -C -w 5% -c 3% -p /bar");
printf (" %s\n", _("Checks /foo for 1000M/500M and /bar for 5/3%. All remaining volumes use 100M/50M"));
- printf (_(UT_SUPPORT));
+
+ printf (UT_SUPPORT);
}
void
print_usage (void)
{
- printf (_("Usage:"));
+ printf ("%s\n", _("Usage:"));
printf (" %s -w limit -c limit [-W limit] [-K limit] {-p path | -x device}\n", progname);
printf ("[-C] [-E] [-e] [-g group ] [-k] [-l] [-M] [-m] [-R path ] [-r path ]\n");
printf ("[-t timeout] [-u unit] [-v] [-X type]\n");
stat_path (struct parameter_list *p)
{
/* Stat entry to check that dir exists and is accessible */
- if (verbose > 3)
+ if (verbose >= 3)
printf("calling stat on %s\n", p->name);
if (stat (p->name, &stat_buf[0])) {
- if (verbose > 3)
+ if (verbose >= 3)
printf("stat failed on %s\n", p->name);
printf("DISK %s - ", _("CRITICAL"));
die (STATE_CRITICAL, _("%s %s: %s\n"), p->name, _("is not accessible"), strerror(errno));
}
}
+
+
+void
+get_stats (struct parameter_list *p, struct fs_usage *fsp) {
+ struct parameter_list *p_list;
+ struct fs_usage tmpfsp;
+ int first = 1;
+
+ if (p->group == NULL) {
+ get_path_stats(p,fsp);
+ } else {
+ /* find all group members */
+ for (p_list = path_select_list; p_list; p_list=p_list->name_next) {
+ if (p_list->group && ! (strcmp(p_list->group, p->group))) {
+ stat_path(p_list);
+ get_fs_usage (p_list->best_match->me_mountdir, p_list->best_match->me_devname, &tmpfsp);
+ get_path_stats(p_list, &tmpfsp);
+ if (verbose >= 3)
+ printf("Group %s: adding %llu blocks sized %llu, (%s) used_units=%g free_units=%g total_units=%g fsu_blocksize=%llu mult=%llu\n",
+ p_list->group, tmpfsp.fsu_bavail, tmpfsp.fsu_blocksize, p_list->best_match->me_mountdir, p_list->dused_units, p_list->dfree_units,
+ p_list->dtotal_units, mult);
+
+ /* prevent counting the first FS of a group twice since its parameter_list entry
+ * is used to carry the information of all file systems of the entire group */
+ if (! first) {
+ p->total += p_list->total;
+ p->available += p_list->available;
+ p->available_to_root += p_list->available_to_root;
+ p->used += p_list->used;
+
+ p->dused_units += p_list->dused_units;
+ p->dfree_units += p_list->dfree_units;
+ p->dtotal_units += p_list->dtotal_units;
+ p->inodes_total += p_list->inodes_total;
+ p->inodes_free += p_list->inodes_free;
+ }
+ first = 0;
+ }
+ if (verbose >= 3)
+ printf("Group %s now has: used_units=%g free_units=%g total_units=%g fsu_blocksize=%llu mult=%llu\n",
+ p->group, tmpfsp.fsu_bavail, tmpfsp.fsu_blocksize, p->best_match->me_mountdir, p->dused_units,
+ p->dfree_units, p->dtotal_units, mult);
+ }
+ /* modify devname and mountdir for output */
+ p->best_match->me_mountdir = p->best_match->me_devname = p->group;
+ }
+ /* finally calculate percentages for either plain FS or summed up group */
+ p->dused_pct = calculate_percent( p->used, p->used + p->available ); /* used + available can never be > uintmax */
+ p->dfree_pct = 100 - p->dused_pct;
+ p->dused_inodes_percent = calculate_percent(p->inodes_total - p->inodes_free, p->inodes_total);
+ p->dfree_inodes_percent = 100 - p->dused_inodes_percent;
+
+}
+
+void
+get_path_stats (struct parameter_list *p, struct fs_usage *fsp) {
+ p->total = fsp->fsu_blocks;
+ /* 2007-12-08 - Workaround for Gnulib reporting insanely high available
+ * space on BSD (the actual value should be negative but fsp->fsu_bavail
+ * is unsigned) */
+ p->available = fsp->fsu_bavail > fsp->fsu_bfree ? 0 : fsp->fsu_bavail;
+ p->available_to_root = fsp->fsu_bfree;
+ p->used = p->total - p->available_to_root;
+
+ p->dused_units = p->used*fsp->fsu_blocksize/mult;
+ p->dfree_units = p->available*fsp->fsu_blocksize/mult;
+ p->dtotal_units = p->total*fsp->fsu_blocksize/mult;
+ p->inodes_total = fsp->fsu_files; /* Total file nodes. */
+ p->inodes_free = fsp->fsu_ffree; /* Free file nodes. */
+ np_add_name(&seen, p->best_match->me_mountdir);
+}