#
# This patch fixes the performance issue observed while retrieving the
# hrStorage parameters in systems with large number of mountpoints
# parameters using snmpwalk.
#
# This issue is happening due to the overhead of large number of
# ioctl() system calls in getmntent() function called by the
# Get_Next_HR_FileSys() function.
#
# We see that in the Get_Next_HR_FileSys() function, inorder to access
# the last mountpoint, the /etc/mnttab is opened and we walk through
# all the mnttab entries for all filesystems till the end. This is the
# reason we find a large number of the MNTIOC_GETMNTENT ioctl() calls.
#
# To reduce the overhead of the getmntent() calls, we maintain a cache
# of all the /etc/mnttab entries and walk through the cache instead of
# opening /etc/mnttab and walking all the entries for each mountpoint.
# This functionality is provided by the load_mnttab_cache_solaris()
# function called from the Init_HR_FileSys() function.
#
# Developed in-house. Bug submitted upstream
#
--- a/agent/mibgroup/host/hr_filesys.c Wed Feb 19 18:36:42 2014
+++ b/agent/mibgroup/host/hr_filesys.c Wed Nov 26 07:21:17 2014
@@ -46,6 +46,10 @@
#include <sys/mount.h>
#endif
+#ifdef solaris2
+#include <sys/stat.h>
+#endif
+
#include <ctype.h>
#if HAVE_STRING_H
#include <string.h>
@@ -108,7 +112,11 @@
#ifdef solaris2
struct mnttab HRFS_entry_struct;
-struct mnttab *HRFS_entry = &HRFS_entry_struct;
+struct mnttab *HRFS_entry;
+struct mnttab *HRFS_list;
+static int fscount;
+static time_t last_access = -1;
+
#define HRFS_name mnt_special
#define HRFS_mount mnt_mountp
#define HRFS_type mnt_fstype
@@ -207,6 +215,9 @@
static u_char *when_dumped(char *filesys, int level, size_t * length);
int header_hrfilesys(struct variable *, oid *, size_t *, int,
size_t *, WriteMethod **);
+#ifdef solaris2
+static int load_mnttab_cache_solaris(void);
+#endif
/*********************
*
@@ -662,11 +673,14 @@
HRFS_index = 1;
if (fp != NULL)
fclose(fp);
+#ifdef solaris2
+ if(!load_mnttab_cache_solaris())
+ return;
+#else
fp = fopen(ETC_MNTTAB, "r");
- if (!fp) {
- netsnmp_config_error("Can't open mnttab %s\n", ETC_MNTTAB);
- }
#endif
+
+#endif
}
const char *HRFS_ignores[] = {
@@ -722,6 +736,117 @@
NULL
};
+#ifdef solaris2
+
+/*
+ * This function has been introduced to reduce the overhead
+ * of the getmntent() calls used to fetch the details of
+ * the /etc/mnttab entries in Init_HR_FileSys().
+ *
+ * We maintain a cache of all the /etc/mnttab entries and
+ * walk through the cache instead of opening /etc/mnttab and
+ * walking all the entries for each mountpoint.
+ */
+
+static int
+load_mnttab_cache_solaris()
+{
+ char buf[512] = {NULL};
+ int i = 0;
+ struct stat file_stat;
+ const char **cpp;
+ char *ch;
+ int token_flag = 0;
+ int skip_flag = 0;
+ int ignore_flag = 0;
+ int j = 0;
+ int lines = 0;
+ int ret = 0;
+ HRFS_index = 0;
+
+ stat(ETC_MNTTAB, &file_stat);
+ if (last_access == -1 || last_access != file_stat.st_mtime) {
+ fp = fopen(ETC_MNTTAB, "r");
+ if(fp == NULL)
+ {
+ DEBUGMSGTL(("host/hr_filesys", "fopen failed for mnttab.\n"));
+ return -1;
+ }
+
+ /* find the number of valid entries in mnttab. */
+
+ while ((fgets((char *) &buf, sizeof(buf), fp)) != NULL) {
+ j = 0;
+ skip_flag = 0;
+ token_flag = 0;
+
+ /* tokenize the mnttab entries to fetch the fstype
+ * which determines the valid entries.
+ */
+
+ ch = strtok(buf, " \t");
+ while (ch != NULL) {
+ j++;
+ if(j == 3) {
+ for (cpp = HRFS_ignores; *cpp != NULL; ++cpp) {
+ if(!strncmp(ch, *cpp, strlen(ch))) {
+ skip_flag = 1;
+ break;
+ }
+ }
+ token_flag = 1;
+ }
+ if(token_flag)
+ break;
+ ch = strtok(NULL, " \t");
+ }
+ if(!skip_flag)
+ lines++;
+ }
+ fclose(fp);
+
+ fscount = lines;
+ HRFS_list = (struct mnttab *) malloc (sizeof(struct mnttab) * fscount);
+ if(HRFS_list == NULL) {
+ DEBUGMSGTL(("host/hr_filesys", "Memory allocation for mnttab cache failed.\n"));
+ return -1;
+ }
+
+ fp = fopen(ETC_MNTTAB, "r");
+ if(fp == NULL) {
+ DEBUGMSGTL(("host/hr_filesys", "fopen failed for mnttab.\n"));
+ free(HRFS_list);
+ return -1;
+ }
+
+ while (i < fscount) {
+ if (getmntent(fp, &HRFS_entry_struct) == 0) {
+ for (cpp = HRFS_ignores; *cpp != NULL; ++cpp) {
+ if (!strcmp(HRFS_entry_struct.HRFS_type, *cpp)) {
+ ignore_flag = 1;
+ break;
+ }
+ }
+
+ if(!ignore_flag) {
+ HRFS_list[i].mnt_special = strdup(HRFS_entry_struct.mnt_special);
+ HRFS_list[i].mnt_mountp = strdup(HRFS_entry_struct.mnt_mountp);
+ HRFS_list[i].mnt_fstype = strdup(HRFS_entry_struct.mnt_fstype);
+ HRFS_list[i].mnt_mntopts = strdup(HRFS_entry_struct.mnt_mntopts);
+ i++;
+ }
+
+ ignore_flag = 0;
+ }
+ }
+
+ HRFS_entry = HRFS_list;
+ last_access = file_stat.st_mtime;
+ }
+ return ret;
+}
+#endif
+
int
Get_Next_HR_FileSys(void)
{
@@ -758,17 +883,18 @@
#else
const char **cpp;
- if (fp == NULL)
- return -1;
#ifdef solaris2
- if (getmntent(fp, HRFS_entry) != 0)
+ if (HRFS_index >= fscount)
return -1;
+ HRFS_entry = &HRFS_list[HRFS_index];
+ return ++HRFS_index;
#else
+ if (fp == NULL)
+ return -1;
HRFS_entry = getmntent(fp);
if (HRFS_entry == NULL)
return -1;
-#endif /* solaris2 */
for (cpp = HRFS_ignores; *cpp != NULL; ++cpp)
if (!strcmp(HRFS_entry->HRFS_type, *cpp))
@@ -787,6 +913,8 @@
}
return HRFS_index++;
+#endif
+
#endif /* HAVE_GETFSSTAT */
}
@@ -854,10 +982,25 @@
HRFS_entry = NULL;
}
#else
+ int i = 0;
if (fp != NULL)
fclose(fp);
fp = NULL;
+
+#ifdef solaris2
+while (i < fscount) {
+ free(HRFS_list[i].mnt_special);
+ free(HRFS_list[i].mnt_mountp);
+ free(HRFS_list[i].mnt_fstype);
+ free(HRFS_list[i].mnt_mntopts);
+ i++;
+}
+ if (HRFS_list != NULL)
+ free(HRFS_list);
+ last_access = -1;
#endif
+
+#endif
}