kernel - Add many sysctl definitions, sysv, vfs, nfs, etc.

* Also take the opportunity to remove some dead (no longer referenced
  sysctl's), these are:
  vfs.cache.dothits
  vfs.cache.dotdothits
  vfs.cache.nummiss
  vfs.cache.nummisszap
  vfs.cache.numposzaps
  vfs.cache.numposhits
  vfs.cache.numnegzaps
  vfs.cache.numneghits
  vfs.reassignbufloops
  vfs.reassignbufsortgood
  vfs.reassignbufsortbad
  vfs.reassignbufmethod
  vfs.nfs.defect
  vfs.cache.numfullpathfail4
  vfs.cache.numfullpathfail3
  vfs.cache.numfullpathfail2
  vfs.cache.numfullpathfail1
  vfs.cache.numcwdfail4
  vfs.cache.numcwdfail3
  vfs.cache.numcwdfail2
  vfs.cache.numcwdfail1

* Add back a couple of vfs.cache sysctl's with improved names
  vfs.cache.numcwdfailnf
  vfs.cache.numcwdfailsz
  vfs.cache.numfullpathfailnf
  vfs.cache.numfullpathfailsz

Submitted-by: Taras Klaskovsky
Sponsored-by: Google Code-In

diff --git a/sys/kern/sysv_msg.c b/sys/kern/sysv_msg.c
index a53974b..c34c0cc 100644 (file)
--- a/sys/kern/sysv_msg.c
+++ b/sys/kern/sysv_msg.c
@@ -1121,11 +1121,17 @@ TUNABLE_INT("kern.ipc.msgseg", &msginfo.msgseg);
 TUNABLE_INT("kern.ipc.msgssz", &msginfo.msgssz);
 TUNABLE_INT("kern.ipc.msgmni", &msginfo.msgmni);
 
-SYSCTL_INT(_kern_ipc, OID_AUTO, msgmax, CTLFLAG_RD, &msginfo.msgmax, 0, "");
-SYSCTL_INT(_kern_ipc, OID_AUTO, msgmni, CTLFLAG_RD, &msginfo.msgmni, 0, "");
-SYSCTL_INT(_kern_ipc, OID_AUTO, msgmnb, CTLFLAG_RD, &msginfo.msgmnb, 0, "");
-SYSCTL_INT(_kern_ipc, OID_AUTO, msgtql, CTLFLAG_RD, &msginfo.msgtql, 0, "");
-SYSCTL_INT(_kern_ipc, OID_AUTO, msgssz, CTLFLAG_RD, &msginfo.msgssz, 0, "");
-SYSCTL_INT(_kern_ipc, OID_AUTO, msgseg, CTLFLAG_RD, &msginfo.msgseg, 0, "");
+SYSCTL_INT(_kern_ipc, OID_AUTO, msgmax, CTLFLAG_RD, &msginfo.msgmax, 0,
+    "Max characters in message");
+SYSCTL_INT(_kern_ipc, OID_AUTO, msgmni, CTLFLAG_RD, &msginfo.msgmni, 0,
+    "Max message queue identifiers");
+SYSCTL_INT(_kern_ipc, OID_AUTO, msgmnb, CTLFLAG_RD, &msginfo.msgmnb, 0,
+    "Max characters in message queue");
+SYSCTL_INT(_kern_ipc, OID_AUTO, msgtql, CTLFLAG_RD, &msginfo.msgtql, 0,
+    "Max SVID messages in system");
+SYSCTL_INT(_kern_ipc, OID_AUTO, msgssz, CTLFLAG_RD, &msginfo.msgssz, 0,
+    "Power-of-two size of a message segment");
+SYSCTL_INT(_kern_ipc, OID_AUTO, msgseg, CTLFLAG_RD, &msginfo.msgseg, 0,
+    "Number of message segments");
 SYSCTL_PROC(_kern_ipc, OID_AUTO, msqids, CTLFLAG_RD,
     NULL, 0, sysctl_msqids, "", "Message queue IDs");

diff --git a/sys/kern/sysv_sem.c b/sys/kern/sysv_sem.c
index ca0017b..92d4013 100644 (file)
--- a/sys/kern/sysv_sem.c
+++ b/sys/kern/sysv_sem.c
@@ -138,16 +138,26 @@ TUNABLE_INT("kern.ipc.semusz", &seminfo.semusz);
 TUNABLE_INT("kern.ipc.semvmx", &seminfo.semvmx);
 TUNABLE_INT("kern.ipc.semaem", &seminfo.semaem);
 
-SYSCTL_INT(_kern_ipc, OID_AUTO, semmap, CTLFLAG_RW, &seminfo.semmap, 0, "");
-SYSCTL_INT(_kern_ipc, OID_AUTO, semmni, CTLFLAG_RD, &seminfo.semmni, 0, "");
-SYSCTL_INT(_kern_ipc, OID_AUTO, semmns, CTLFLAG_RD, &seminfo.semmns, 0, "");
-SYSCTL_INT(_kern_ipc, OID_AUTO, semmnu, CTLFLAG_RD, &seminfo.semmnu, 0, "");
-SYSCTL_INT(_kern_ipc, OID_AUTO, semmsl, CTLFLAG_RW, &seminfo.semmsl, 0, "");
-SYSCTL_INT(_kern_ipc, OID_AUTO, semopm, CTLFLAG_RD, &seminfo.semopm, 0, "");
-SYSCTL_INT(_kern_ipc, OID_AUTO, semume, CTLFLAG_RD, &seminfo.semume, 0, "");
-SYSCTL_INT(_kern_ipc, OID_AUTO, semusz, CTLFLAG_RD, &seminfo.semusz, 0, "");
-SYSCTL_INT(_kern_ipc, OID_AUTO, semvmx, CTLFLAG_RW, &seminfo.semvmx, 0, "");
-SYSCTL_INT(_kern_ipc, OID_AUTO, semaem, CTLFLAG_RW, &seminfo.semaem, 0, "");
+SYSCTL_INT(_kern_ipc, OID_AUTO, semmap, CTLFLAG_RW, &seminfo.semmap, 0,
+    "Number of entries in semaphore map");
+SYSCTL_INT(_kern_ipc, OID_AUTO, semmni, CTLFLAG_RD, &seminfo.semmni, 0,
+    "Number of semaphore identifiers");
+SYSCTL_INT(_kern_ipc, OID_AUTO, semmns, CTLFLAG_RD, &seminfo.semmns, 0,
+    "Total number of semaphores");
+SYSCTL_INT(_kern_ipc, OID_AUTO, semmnu, CTLFLAG_RD, &seminfo.semmnu, 0,
+    "Total number of undo structures");
+SYSCTL_INT(_kern_ipc, OID_AUTO, semmsl, CTLFLAG_RW, &seminfo.semmsl, 0,
+    "Max number of semaphores per id");
+SYSCTL_INT(_kern_ipc, OID_AUTO, semopm, CTLFLAG_RD, &seminfo.semopm, 0,
+    "Max number of operations per semop call");
+SYSCTL_INT(_kern_ipc, OID_AUTO, semume, CTLFLAG_RD, &seminfo.semume, 0,
+    "Max number of undo entries per process");
+SYSCTL_INT(_kern_ipc, OID_AUTO, semusz, CTLFLAG_RD, &seminfo.semusz, 0,
+    "Size in bytes of undo structure");
+SYSCTL_INT(_kern_ipc, OID_AUTO, semvmx, CTLFLAG_RW, &seminfo.semvmx, 0,
+    "Semaphore maximum value");
+SYSCTL_INT(_kern_ipc, OID_AUTO, semaem, CTLFLAG_RW, &seminfo.semaem, 0,
+    "Adjust on exit max value");
 
 #if 0
 RO seminfo.semmap      /* SEMMAP unused */

diff --git a/sys/kern/sysv_shm.c b/sys/kern/sysv_shm.c
index 026d457..676a3dd 100644 (file)
--- a/sys/kern/sysv_shm.c
+++ b/sys/kern/sysv_shm.c
@@ -138,12 +138,18 @@ TUNABLE_INT("kern.ipc.shmseg", &shminfo.shmseg);
 TUNABLE_INT("kern.ipc.shmmaxpgs", &shminfo.shmall);
 TUNABLE_INT("kern.ipc.shm_use_phys", &shm_use_phys);
 
-SYSCTL_INT(_kern_ipc, OID_AUTO, shmmax, CTLFLAG_RW, &shminfo.shmmax, 0, "");
-SYSCTL_INT(_kern_ipc, OID_AUTO, shmmin, CTLFLAG_RW, &shminfo.shmmin, 0, "");
-SYSCTL_INT(_kern_ipc, OID_AUTO, shmmni, CTLFLAG_RD, &shminfo.shmmni, 0, "");
-SYSCTL_INT(_kern_ipc, OID_AUTO, shmseg, CTLFLAG_RW, &shminfo.shmseg, 0, "");
-SYSCTL_INT(_kern_ipc, OID_AUTO, shmall, CTLFLAG_RW, &shminfo.shmall, 0, "");
-SYSCTL_INT(_kern_ipc, OID_AUTO, shm_use_phys, CTLFLAG_RW, &shm_use_phys, 0, "");
+SYSCTL_INT(_kern_ipc, OID_AUTO, shmmax, CTLFLAG_RW, &shminfo.shmmax, 0,
+    "Max shared memory segment size");
+SYSCTL_INT(_kern_ipc, OID_AUTO, shmmin, CTLFLAG_RW, &shminfo.shmmin, 0,
+    "Min shared memory segment size");
+SYSCTL_INT(_kern_ipc, OID_AUTO, shmmni, CTLFLAG_RD, &shminfo.shmmni, 0,
+    "Max number of shared memory identifiers");
+SYSCTL_INT(_kern_ipc, OID_AUTO, shmseg, CTLFLAG_RW, &shminfo.shmseg, 0,
+    "Max shared memory segments per process");
+SYSCTL_INT(_kern_ipc, OID_AUTO, shmall, CTLFLAG_RW, &shminfo.shmall, 0,
+    "Max pages of shared memory");
+SYSCTL_INT(_kern_ipc, OID_AUTO, shm_use_phys, CTLFLAG_RW, &shm_use_phys, 0,
+    "Use phys pager allocation instead of swap pager allocation");
 
 static int
 shm_find_segment_by_key(key_t key)

diff --git a/sys/kern/uipc_mbuf.c b/sys/kern/uipc_mbuf.c
index 394e664..415c578 100644 (file)
--- a/sys/kern/uipc_mbuf.c
+++ b/sys/kern/uipc_mbuf.c
@@ -260,18 +260,19 @@ int       nmbclusters;
 int    nmbufs;
 
 SYSCTL_INT(_kern_ipc, KIPC_MAX_LINKHDR, max_linkhdr, CTLFLAG_RW,
-          &max_linkhdr, 0, "");
+       &max_linkhdr, 0, "Max size of a link-level header");
 SYSCTL_INT(_kern_ipc, KIPC_MAX_PROTOHDR, max_protohdr, CTLFLAG_RW,
-          &max_protohdr, 0, "");
-SYSCTL_INT(_kern_ipc, KIPC_MAX_HDR, max_hdr, CTLFLAG_RW, &max_hdr, 0, "");
+       &max_protohdr, 0, "Max size of a protocol header");
+SYSCTL_INT(_kern_ipc, KIPC_MAX_HDR, max_hdr, CTLFLAG_RW, &max_hdr, 0,
+       "Max size of link+protocol headers");
 SYSCTL_INT(_kern_ipc, KIPC_MAX_DATALEN, max_datalen, CTLFLAG_RW,
-          &max_datalen, 0, "");
+       &max_datalen, 0, "Max data payload size without headers");
 SYSCTL_INT(_kern_ipc, OID_AUTO, mbuf_wait, CTLFLAG_RW,
-          &mbuf_wait, 0, "");
+       &mbuf_wait, 0, "Time in ticks to sleep after failed mbuf allocations");
 static int do_mbstat(SYSCTL_HANDLER_ARGS);
 
 SYSCTL_PROC(_kern_ipc, KIPC_MBSTAT, mbstat, CTLTYPE_STRUCT|CTLFLAG_RD,
-       0, 0, do_mbstat, "S,mbstat", "");
+       0, 0, do_mbstat, "S,mbstat", "mbuf usage statistics");
 
 static int do_mbtypes(SYSCTL_HANDLER_ARGS);
 
@@ -343,13 +344,13 @@ SYSCTL_INT(_kern_ipc, OID_AUTO, nmbufs, CTLFLAG_RD, &nmbufs, 0,
           "Maximum number of mbufs available"); 
 
 SYSCTL_INT(_kern_ipc, OID_AUTO, m_defragpackets, CTLFLAG_RD,
-          &m_defragpackets, 0, "");
+          &m_defragpackets, 0, "Number of defragment packets");
 SYSCTL_INT(_kern_ipc, OID_AUTO, m_defragbytes, CTLFLAG_RD,
-          &m_defragbytes, 0, "");
+          &m_defragbytes, 0, "Number of defragment bytes");
 SYSCTL_INT(_kern_ipc, OID_AUTO, m_defraguseless, CTLFLAG_RD,
-          &m_defraguseless, 0, "");
+          &m_defraguseless, 0, "Number of useless defragment mbuf chain operations");
 SYSCTL_INT(_kern_ipc, OID_AUTO, m_defragfailure, CTLFLAG_RD,
-          &m_defragfailure, 0, "");
+          &m_defragfailure, 0, "Number of failed defragment mbuf chain operations");
 #ifdef MBUF_STRESS_TEST
 SYSCTL_INT(_kern_ipc, OID_AUTO, m_defragrandomfailures, CTLFLAG_RW,
           &m_defragrandomfailures, 0, "");

diff --git a/sys/kern/uipc_socket2.c b/sys/kern/uipc_socket2.c
index 757e0e0..4df36b1 100644 (file)
--- a/sys/kern/uipc_socket2.c
+++ b/sys/kern/uipc_socket2.c
@@ -761,7 +761,8 @@ SYSCTL_OID(_kern_ipc, KIPC_MAXSOCKBUF, maxsockbuf, CTLTYPE_INT|CTLFLAG_RW,
 SYSCTL_INT(_kern_ipc, OID_AUTO, maxsockets, CTLFLAG_RD, 
     &maxsockets, 0, "Maximum number of sockets available");
 SYSCTL_INT(_kern_ipc, KIPC_SOCKBUF_WASTE, sockbuf_waste_factor, CTLFLAG_RW,
-    &sb_efficiency, 0, "");
+    &sb_efficiency, 0,
+    "Socket buffer limit scaler");
 
 /*
  * Initialize maxsockets 

diff --git a/sys/kern/vfs_cache.c b/sys/kern/vfs_cache.c
index f7a8866..98e80a3 100644 (file)
--- a/sys/kern/vfs_cache.c
+++ b/sys/kern/vfs_cache.c
@@ -191,22 +191,18 @@ static void _cache_cleandefered(void);
  * The new name cache statistics
  */
 SYSCTL_NODE(_vfs, OID_AUTO, cache, CTLFLAG_RW, 0, "Name cache statistics");
-#define STATNODE(mode, name, var) \
-       SYSCTL_ULONG(_vfs_cache, OID_AUTO, name, mode, var, 0, "");
-#define STATNODE_INT(mode, name, var) \
-       SYSCTL_UINT(_vfs_cache, OID_AUTO, name, mode, var, 0, "");
-static int numneg; STATNODE_INT(CTLFLAG_RD, numneg, &numneg);
-static int numcache; STATNODE_INT(CTLFLAG_RD, numcache, &numcache);
-static u_long numcalls; STATNODE(CTLFLAG_RD, numcalls, &numcalls);
-static u_long dothits; STATNODE(CTLFLAG_RD, dothits, &dothits);
-static u_long dotdothits; STATNODE(CTLFLAG_RD, dotdothits, &dotdothits);
-static u_long numchecks; STATNODE(CTLFLAG_RD, numchecks, &numchecks);
-static u_long nummiss; STATNODE(CTLFLAG_RD, nummiss, &nummiss);
-static u_long nummisszap; STATNODE(CTLFLAG_RD, nummisszap, &nummisszap);
-static u_long numposzaps; STATNODE(CTLFLAG_RD, numposzaps, &numposzaps);
-static u_long numposhits; STATNODE(CTLFLAG_RD, numposhits, &numposhits);
-static u_long numnegzaps; STATNODE(CTLFLAG_RD, numnegzaps, &numnegzaps);
-static u_long numneghits; STATNODE(CTLFLAG_RD, numneghits, &numneghits);
+static int numneg;
+SYSCTL_ULONG(_vfs_cache, OID_AUTO, numneg, CTLFLAG_RD, &numneg, 0,
+    "Number of negative namecache entries");
+static int numcache;
+SYSCTL_ULONG(_vfs_cache, OID_AUTO, numcache, CTLFLAG_RD, &numcache, 0,
+    "Number of namecaches entries");
+static u_long numcalls;
+SYSCTL_ULONG(_vfs_cache, OID_AUTO, numcalls, CTLFLAG_RD, &numcalls, 0,
+    "Number of namecache lookups");
+static u_long numchecks;
+SYSCTL_ULONG(_vfs_cache, OID_AUTO, numchecks, CTLFLAG_RD, &numchecks, 0,
+    "Number of checked entries in namecache lookups");
 
 struct nchstats nchstats[SMP_MAXCPU];
 /*
@@ -3011,12 +3007,18 @@ static int disablecwd;
 SYSCTL_INT(_debug, OID_AUTO, disablecwd, CTLFLAG_RW, &disablecwd, 0,
     "Disable getcwd");
 
-static u_long numcwdcalls; STATNODE(CTLFLAG_RD, numcwdcalls, &numcwdcalls);
-static u_long numcwdfail1; STATNODE(CTLFLAG_RD, numcwdfail1, &numcwdfail1);
-static u_long numcwdfail2; STATNODE(CTLFLAG_RD, numcwdfail2, &numcwdfail2);
-static u_long numcwdfail3; STATNODE(CTLFLAG_RD, numcwdfail3, &numcwdfail3);
-static u_long numcwdfail4; STATNODE(CTLFLAG_RD, numcwdfail4, &numcwdfail4);
-static u_long numcwdfound; STATNODE(CTLFLAG_RD, numcwdfound, &numcwdfound);
+static u_long numcwdcalls;
+SYSCTL_ULONG(_vfs_cache, OID_AUTO, numcwdcalls, CTLFLAG_RD, &numcwdcalls, 0,
+    "Number of current directory resolution calls");
+static u_long numcwdfailnf;
+SYSCTL_ULONG(_vfs_cache, OID_AUTO, numcwdfailnf, CTLFLAG_RD, &numcwdfailnf, 0,
+    "Number of current directory failures due to lack of file");
+static u_long numcwdfailsz;
+SYSCTL_ULONG(_vfs_cache, OID_AUTO, numcwdfailsz, CTLFLAG_RD, &numcwdfailsz, 0,
+    "Number of current directory failures due to large result");
+static u_long numcwdfound;
+SYSCTL_ULONG(_vfs_cache, OID_AUTO, numcwdfound, CTLFLAG_RD, &numcwdfound, 0,
+    "Number of current directory resolution successes");
 
 /*
  * MPALMOSTSAFE
@@ -3092,7 +3094,7 @@ kern_getcwd(char *buf, size_t buflen, int *error)
                 */
                for (i = ncp->nc_nlen - 1; i >= 0; i--) {
                        if (bp == buf) {
-                               numcwdfail4++;
+                               numcwdfailsz++;
                                *error = ERANGE;
                                bp = NULL;
                                goto done;
@@ -3100,7 +3102,7 @@ kern_getcwd(char *buf, size_t buflen, int *error)
                        *--bp = ncp->nc_name[i];
                }
                if (bp == buf) {
-                       numcwdfail4++;
+                       numcwdfailsz++;
                        *error = ERANGE;
                        bp = NULL;
                        goto done;
@@ -3126,14 +3128,14 @@ kern_getcwd(char *buf, size_t buflen, int *error)
                ncp = nch.ncp;
        }
        if (ncp == NULL) {
-               numcwdfail2++;
+               numcwdfailnf++;
                *error = ENOENT;
                bp = NULL;
                goto done;
        }
        if (!slash_prefixed) {
                if (bp == buf) {
-                       numcwdfail4++;
+                       numcwdfailsz++;
                        *error = ERANGE;
                        bp = NULL;
                        goto done;
@@ -3153,22 +3155,27 @@ done:
  *
  * The passed nchp is referenced but not locked.
  */
-#undef STATNODE
-#define STATNODE(name)                                                 \
-       static u_int name;                                              \
-       SYSCTL_UINT(_vfs_cache, OID_AUTO, name, CTLFLAG_RD, &name, 0, "")
-
 static int disablefullpath;
 SYSCTL_INT(_debug, OID_AUTO, disablefullpath, CTLFLAG_RW,
     &disablefullpath, 0,
     "Disable fullpath lookups");
 
-STATNODE(numfullpathcalls);
-STATNODE(numfullpathfail1);
-STATNODE(numfullpathfail2);
-STATNODE(numfullpathfail3);
-STATNODE(numfullpathfail4);
-STATNODE(numfullpathfound);
+static u_int numfullpathcalls;
+SYSCTL_UINT(_vfs_cache, OID_AUTO, numfullpathcalls, CTLFLAG_RD,
+    &numfullpathcalls, 0,
+    "Number of full path resolutions in progress");
+static u_int numfullpathfailnf;
+SYSCTL_UINT(_vfs_cache, OID_AUTO, numfullpathfailnf, CTLFLAG_RD,
+    &numfullpathfailnf, 0,
+    "Number of full path resolution failures due to lack of file");
+static u_int numfullpathfailsz;
+SYSCTL_UINT(_vfs_cache, OID_AUTO, numfullpathfailsz, CTLFLAG_RD,
+    &numfullpathfailsz, 0,
+    "Number of full path resolution failures due to insufficient memory");
+static u_int numfullpathfound;
+SYSCTL_UINT(_vfs_cache, OID_AUTO, numfullpathfound, CTLFLAG_RD,
+    &numfullpathfound, 0,
+    "Number of full path resolution successes");
 
 int
 cache_fullpath(struct proc *p, struct nchandle *nchp,
@@ -3235,7 +3242,7 @@ cache_fullpath(struct proc *p, struct nchandle *nchp,
                 */
                for (i = ncp->nc_nlen - 1; i >= 0; i--) {
                        if (bp == buf) {
-                               numfullpathfail4++;
+                               numfullpathfailsz++;
                                kfree(buf, M_TEMP);
                                error = ENOMEM;
                                goto done;
@@ -3243,7 +3250,7 @@ cache_fullpath(struct proc *p, struct nchandle *nchp,
                        *--bp = ncp->nc_name[i];
                }
                if (bp == buf) {
-                       numfullpathfail4++;
+                       numfullpathfailsz++;
                        kfree(buf, M_TEMP);
                        error = ENOMEM;
                        goto done;
@@ -3271,7 +3278,7 @@ cache_fullpath(struct proc *p, struct nchandle *nchp,
                ncp = nch.ncp;
        }
        if (ncp == NULL) {
-               numfullpathfail2++;
+               numfullpathfailnf++;
                kfree(buf, M_TEMP);
                error = ENOENT;
                goto done;
@@ -3279,7 +3286,7 @@ cache_fullpath(struct proc *p, struct nchandle *nchp,
 
        if (!slash_prefixed) {
                if (bp == buf) {
-                       numfullpathfail4++;
+                       numfullpathfailsz++;
                        kfree(buf, M_TEMP);
                        error = ENOMEM;
                        goto done;

diff --git a/sys/kern/vfs_cluster.c b/sys/kern/vfs_cluster.c
index 4c6dc3e..80388b9 100644 (file)
--- a/sys/kern/vfs_cluster.c
+++ b/sys/kern/vfs_cluster.c
@@ -77,9 +77,11 @@ static void cluster_callback (struct bio *);
 static void cluster_setram (struct buf *);
 
 static int write_behind = 1;
-SYSCTL_INT(_vfs, OID_AUTO, write_behind, CTLFLAG_RW, &write_behind, 0, "");
+SYSCTL_INT(_vfs, OID_AUTO, write_behind, CTLFLAG_RW, &write_behind, 0,
+    "Cluster write-behind setting");
 static int max_readahead = 2 * 1024 * 1024;
-SYSCTL_INT(_vfs, OID_AUTO, max_readahead, CTLFLAG_RW, &max_readahead, 0, "");
+SYSCTL_INT(_vfs, OID_AUTO, max_readahead, CTLFLAG_RW, &max_readahead, 0,
+    "Limit in bytes for desired cluster read-ahead");
 
 extern vm_page_t       bogus_page;
 

diff --git a/sys/kern/vfs_subr.c b/sys/kern/vfs_subr.c
index 52a8f3a..cdad58b 100644 (file)
--- a/sys/kern/vfs_subr.c
+++ b/sys/kern/vfs_subr.c
@@ -104,23 +104,12 @@ int vttoif_tab[9] = {
 };
 
 static int reassignbufcalls;
-SYSCTL_INT(_vfs, OID_AUTO, reassignbufcalls, CTLFLAG_RW,
-               &reassignbufcalls, 0, "");
-static int reassignbufloops;
-SYSCTL_INT(_vfs, OID_AUTO, reassignbufloops, CTLFLAG_RW,
-               &reassignbufloops, 0, "");
-static int reassignbufsortgood;
-SYSCTL_INT(_vfs, OID_AUTO, reassignbufsortgood, CTLFLAG_RW,
-               &reassignbufsortgood, 0, "");
-static int reassignbufsortbad;
-SYSCTL_INT(_vfs, OID_AUTO, reassignbufsortbad, CTLFLAG_RW,
-               &reassignbufsortbad, 0, "");
-static int reassignbufmethod = 1;
-SYSCTL_INT(_vfs, OID_AUTO, reassignbufmethod, CTLFLAG_RW,
-               &reassignbufmethod, 0, "");
+SYSCTL_INT(_vfs, OID_AUTO, reassignbufcalls, CTLFLAG_RW, &reassignbufcalls,
+    0, "Number of times buffers have been reassigned to the proper list");
+
 static int check_buf_overlap = 2;      /* invasive check */
-SYSCTL_INT(_vfs, OID_AUTO, check_buf_overlap, CTLFLAG_RW,
-               &check_buf_overlap, 0, "");
+SYSCTL_INT(_vfs, OID_AUTO, check_buf_overlap, CTLFLAG_RW, &check_buf_overlap,
+    0, "Enable overlapping buffer checks");
 
 int    nfs_mount_type = -1;
 static struct lwkt_token spechash_token;
@@ -217,7 +206,7 @@ enum { TSP_SEC, TSP_HZ, TSP_USEC, TSP_NSEC };
 
 static int timestamp_precision = TSP_SEC;
 SYSCTL_INT(_vfs, OID_AUTO, timestamp_precision, CTLFLAG_RW,
-               &timestamp_precision, 0, "");
+               &timestamp_precision, 0, "Precision of file timestamps");
 
 /*
  * Get a current timestamp.

diff --git a/sys/kern/vfs_syscalls.c b/sys/kern/vfs_syscalls.c
index aaa85bc..bf9e1db 100644 (file)
--- a/sys/kern/vfs_syscalls.c
+++ b/sys/kern/vfs_syscalls.c
@@ -99,7 +99,8 @@ static int    usermount = 0;  /* if 1, non-root can mount fs. */
 
 int (*union_dircheckp) (struct thread *, struct vnode **, struct file *);
 
-SYSCTL_INT(_vfs, OID_AUTO, usermount, CTLFLAG_RW, &usermount, 0, "");
+SYSCTL_INT(_vfs, OID_AUTO, usermount, CTLFLAG_RW, &usermount, 0,
+    "Allow non-root users to mount filesystems");
 
 /*
  * Virtual File System System Calls

diff --git a/sys/vfs/nfs/nfs_serv.c b/sys/vfs/nfs/nfs_serv.c
index 35646ed..b2775dd 100644 (file)
--- a/sys/vfs/nfs/nfs_serv.c
+++ b/sys/vfs/nfs/nfs_serv.c
@@ -131,11 +131,14 @@ static struct timespec    nfsver;
 SYSCTL_DECL(_vfs_nfs);
 
 int nfs_async;
-SYSCTL_INT(_vfs_nfs, OID_AUTO, async, CTLFLAG_RW, &nfs_async, 0, "");
+SYSCTL_INT(_vfs_nfs, OID_AUTO, async, CTLFLAG_RW, &nfs_async, 0,
+    "Enable unstable and fast writes");
 static int nfs_commit_blks;
 static int nfs_commit_miss;
-SYSCTL_INT(_vfs_nfs, OID_AUTO, commit_blks, CTLFLAG_RW, &nfs_commit_blks, 0, "");
-SYSCTL_INT(_vfs_nfs, OID_AUTO, commit_miss, CTLFLAG_RW, &nfs_commit_miss, 0, "");
+SYSCTL_INT(_vfs_nfs, OID_AUTO, commit_blks, CTLFLAG_RW, &nfs_commit_blks, 0,
+    "Number of commited blocks");
+SYSCTL_INT(_vfs_nfs, OID_AUTO, commit_miss, CTLFLAG_RW, &nfs_commit_miss, 0,
+    "Number of nfs blocks committed from dirty buffers");
 
 static int nfsrv_access (struct mount *, struct vnode *, int,
                        struct ucred *, int, struct thread *, int);
@@ -3586,7 +3589,8 @@ nfsrv_commit(struct nfsrv_descript *nfsd, struct nfssvc_sock *slp,
 
                if (vp->v_object &&
                   (vp->v_object->flags & OBJ_MIGHTBEDIRTY)) {
-                       vm_object_page_clean(vp->v_object, off / PAGE_SIZE, (cnt + PAGE_MASK) / PAGE_SIZE, OBJPC_SYNC);
+                       vm_object_page_clean(vp->v_object, off / PAGE_SIZE,
+                           (cnt + PAGE_MASK) / PAGE_SIZE, OBJPC_SYNC);
                }
 
                crit_enter();

diff --git a/sys/vfs/nfs/nfs_socket.c b/sys/vfs/nfs/nfs_socket.c
index c879c8b..0a6ed9d 100644 (file)
--- a/sys/vfs/nfs/nfs_socket.c
+++ b/sys/vfs/nfs/nfs_socket.c
@@ -120,11 +120,16 @@ int nfs_maxasyncbio = NFS_MAXASYNCBIO;
 
 SYSCTL_DECL(_vfs_nfs);
 
-SYSCTL_INT(_vfs_nfs, OID_AUTO, realign_test, CTLFLAG_RW, &nfs_realign_test, 0, "");
-SYSCTL_INT(_vfs_nfs, OID_AUTO, realign_count, CTLFLAG_RW, &nfs_realign_count, 0, "");
-SYSCTL_INT(_vfs_nfs, OID_AUTO, showrtt, CTLFLAG_RW, &nfs_showrtt, 0, "");
-SYSCTL_INT(_vfs_nfs, OID_AUTO, showrexmit, CTLFLAG_RW, &nfs_showrexmit, 0, "");
-SYSCTL_INT(_vfs_nfs, OID_AUTO, maxasyncbio, CTLFLAG_RW, &nfs_maxasyncbio, 0, "");
+SYSCTL_INT(_vfs_nfs, OID_AUTO, realign_test, CTLFLAG_RW, &nfs_realign_test, 0,
+    "Number of times mbufs have been tested for bad alignment");
+SYSCTL_INT(_vfs_nfs, OID_AUTO, realign_count, CTLFLAG_RW, &nfs_realign_count, 0,
+    "Number of realignments for badly aligned mbuf data");
+SYSCTL_INT(_vfs_nfs, OID_AUTO, showrtt, CTLFLAG_RW, &nfs_showrtt, 0,
+    "Show round trip time output");
+SYSCTL_INT(_vfs_nfs, OID_AUTO, showrexmit, CTLFLAG_RW, &nfs_showrexmit, 0,
+    "Show retransmits info");
+SYSCTL_INT(_vfs_nfs, OID_AUTO, maxasyncbio, CTLFLAG_RW, &nfs_maxasyncbio, 0,
+    "Max number of asynchronous bio's");
 
 static int nfs_request_setup(nfsm_info_t info);
 static int nfs_request_auth(struct nfsreq *rep);

diff --git a/sys/vfs/nfs/nfs_syscalls.c b/sys/vfs/nfs/nfs_syscalls.c
index df7a669..2198bd3 100644 (file)
--- a/sys/vfs/nfs/nfs_syscalls.c
+++ b/sys/vfs/nfs/nfs_syscalls.c
@@ -101,11 +101,15 @@ static int        nfssvc_addsock (struct file *, struct sockaddr *,
 static int     nfssvc_nfsd (struct nfsd_srvargs *,caddr_t,struct thread *);
 
 static int nfs_privport = 0;
-SYSCTL_INT(_vfs_nfs, NFS_NFSPRIVPORT, nfs_privport, CTLFLAG_RW, &nfs_privport, 0, "");
-SYSCTL_INT(_vfs_nfs, OID_AUTO, gatherdelay, CTLFLAG_RW, &nfsrvw_procrastinate, 0, "");
-SYSCTL_INT(_vfs_nfs, OID_AUTO, gatherdelay_v3, CTLFLAG_RW, &nfsrvw_procrastinate_v3, 0, "");
+SYSCTL_INT(_vfs_nfs, NFS_NFSPRIVPORT, nfs_privport, CTLFLAG_RW, &nfs_privport,
+    0, "Enable privileged source port checks");
+SYSCTL_INT(_vfs_nfs, OID_AUTO, gatherdelay, CTLFLAG_RW, &nfsrvw_procrastinate, 0,
+    "Enable NFS request procrastination");
+SYSCTL_INT(_vfs_nfs, OID_AUTO, gatherdelay_v3, CTLFLAG_RW, &nfsrvw_procrastinate_v3, 0,
+    "Enable NFSv3 request procrastination");
 int    nfs_soreserve = NFS_MAXPACKET * NFS_MAXASYNCBIO;
-SYSCTL_INT(_vfs_nfs, OID_AUTO, soreserve, CTLFLAG_RW, &nfs_soreserve, 0, "");
+SYSCTL_INT(_vfs_nfs, OID_AUTO, soreserve, CTLFLAG_RW, &nfs_soreserve, 0,
+    "Minimum NFS socket buffer size reservation");
 
 /*
  * NFS server system calls
@@ -988,9 +992,6 @@ nfsd_rt(int sotype, struct nfsrv_descript *nd, int cacherep)
 }
 #endif /* NFS_NOSERVER */
 
-static int nfs_defect = 0;
-SYSCTL_INT(_vfs_nfs, OID_AUTO, defect, CTLFLAG_RW, &nfs_defect, 0, "");
-
 /*
  * Get an authorization string for the uid by having the mount_nfs sitting
  * on this mount point porpous out of the kernel and do it.

diff --git a/sys/vfs/nfs/nfs_vfsops.c b/sys/vfs/nfs/nfs_vfsops.c
index cdc8de7..f3299ed 100644 (file)
--- a/sys/vfs/nfs/nfs_vfsops.c
+++ b/sys/vfs/nfs/nfs_vfsops.c
@@ -1,4 +1,4 @@
-/*
+    /*
  * Copyright (c) 1989, 1993, 1995
  *     The Regents of the University of California.  All rights reserved.
  *
@@ -95,11 +95,11 @@ vm_zone_t nfsmount_zone;
 
 struct nfsstats        nfsstats;
 SYSCTL_NODE(_vfs, OID_AUTO, nfs, CTLFLAG_RW, 0, "NFS filesystem");
-SYSCTL_STRUCT(_vfs_nfs, NFS_NFSSTATS, nfsstats, CTLFLAG_RD,
-       &nfsstats, nfsstats, "");
+SYSCTL_STRUCT(_vfs_nfs, NFS_NFSSTATS, nfsstats, CTLFLAG_RD, &nfsstats, nfsstats,
+    "Nfs stats structure");
 static int nfs_ip_paranoia = 1;
-SYSCTL_INT(_vfs_nfs, OID_AUTO, nfs_ip_paranoia, CTLFLAG_RW,
-       &nfs_ip_paranoia, 0, "");
+SYSCTL_INT(_vfs_nfs, OID_AUTO, nfs_ip_paranoia, CTLFLAG_RW, &nfs_ip_paranoia, 0,
+    "Enable no-connection mode for protocols that support no-connection mode");
 #ifdef NFS_DEBUG
 int nfs_debug;
 SYSCTL_INT(_vfs_nfs, OID_AUTO, debug, CTLFLAG_RW, &nfs_debug, 0, "");
@@ -152,21 +152,24 @@ struct nfsv3_diskless nfsv3_diskless = { { { 0 } } };
 int nfs_diskless_valid = 0;
 
 SYSCTL_INT(_vfs_nfs, OID_AUTO, diskless_valid, CTLFLAG_RD,
-       &nfs_diskless_valid, 0, "");
+       &nfs_diskless_valid, 0,
+       "NFS diskless params were obtained");
 
 SYSCTL_STRING(_vfs_nfs, OID_AUTO, diskless_rootpath, CTLFLAG_RD,
-       nfsv3_diskless.root_hostnam, 0, "");
+       nfsv3_diskless.root_hostnam, 0,
+       "Host name for mount point");
 
 SYSCTL_OPAQUE(_vfs_nfs, OID_AUTO, diskless_rootaddr, CTLFLAG_RD,
        &nfsv3_diskless.root_saddr, sizeof nfsv3_diskless.root_saddr,
-       "%Ssockaddr_in", "");
+       "%Ssockaddr_in", "Address of root server");
 
 SYSCTL_STRING(_vfs_nfs, OID_AUTO, diskless_swappath, CTLFLAG_RD,
-       nfsv3_diskless.swap_hostnam, 0, "");
+       nfsv3_diskless.swap_hostnam, 0,
+       "Host name for mount ppoint");
 
 SYSCTL_OPAQUE(_vfs_nfs, OID_AUTO, diskless_swapaddr, CTLFLAG_RD,
        &nfsv3_diskless.swap_saddr, sizeof nfsv3_diskless.swap_saddr,
-       "%Ssockaddr_in","");
+       "%Ssockaddr_in", "Address of swap server");
 
 
 void nfsargs_ntoh (struct nfs_args *);

diff --git a/sys/vm/vm_pager.c b/sys/vm/vm_pager.c
index 468fee3..f0ec534 100644 (file)
--- a/sys/vm/vm_pager.c
+++ b/sys/vm/vm_pager.c
@@ -195,8 +195,10 @@ static struct spinlock bswspin = SPINLOCK_INITIALIZER(&bswspin);
 static int pbuf_raw_count;
 static int pbuf_kva_count;
 
-SYSCTL_INT(_vfs, OID_AUTO, pbuf_raw_count, CTLFLAG_RD, &pbuf_raw_count, 0, "");
-SYSCTL_INT(_vfs, OID_AUTO, pbuf_kva_count, CTLFLAG_RD, &pbuf_kva_count, 0, "");
+SYSCTL_INT(_vfs, OID_AUTO, pbuf_raw_count, CTLFLAG_RD, &pbuf_raw_count, 0,
+    "Kernel virtual address space reservations");
+SYSCTL_INT(_vfs, OID_AUTO, pbuf_kva_count, CTLFLAG_RD, &pbuf_kva_count, 0,
+    "Kernel raw address space reservations");
 
 /*
  * Initialize the swap buffer list.