*  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.

 *  of all the /etc/mnttab entries and walk through the cache instead of

--- net-snmp-5.4.1.orig/agent/mibgroup/host/hr_filesys.c	2007-05-18 11:08:01.000000000 -0700

+++ net-snmp-5.4.1/agent/mibgroup/host/hr_filesys.c	2013-01-17 03:36:28.181493003 -0800

@@ -31,6 +31,10 @@

@@ -85,7 +89,11 @@

+static time_t last_access = -1;

@@ -167,6 +175,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 **);

+static int      load_mnttab_cache_solaris(void);

         /*********************

 	 *

@@ -606,8 +617,14 @@

+    if(!load_mnttab_cache_solaris())

+        return;

+#else    

     fp = fopen(ETC_MNTTAB, "r");

 #endif

+

+#endif

 }

 const char     *HRFS_ignores[] = {

@@ -663,6 +680,117 @@

     0

 };

+#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;

+}

 int

 Get_Next_HR_FileSys(void)

 {

@@ -699,17 +827,18 @@

+    if (HRFS_index >= fscount)

         return -1;

+    HRFS_entry = &HRFS_list[HRFS_index];

+        return ++HRFS_index;

+    if (fp == NULL)

+        return -1;

@@ -728,6 +857,8 @@

@@ -791,9 +922,24 @@

+    int i = 0;

+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

+