LU-15642 obdclass: use consistent stats units

Use consistent stats units, since some were "usec" and others "usecs".
Most stats already use LPROCFS_TYPE_* to encode type stats type, so
use this to provide units for those stats, and only explicitly provide
strings for the few stats that don't match the commonly-used units.
This also reduces the number of repeat static strings in the modules.

Signed-off-by: Andreas Dilger <adilger@whamcloud.com>
Change-Id: I25f31478f238072ddbf9a3918cd43bb08c3ebbe5
Reviewed-on: https://review.whamcloud.com/46833
Tested-by: jenkins <devops@whamcloud.com>
Tested-by: Maloo <maloo@whamcloud.com>
Reviewed-by: Jian Yu <yujian@whamcloud.com>
Reviewed-by: Ben Evans <beevans@whamcloud.com>
Reviewed-by: Oleg Drokin <green@whamcloud.com>

diff --git a/lustre/include/lprocfs_status.h b/lustre/include/lprocfs_status.h
index 64c56e2..7103ffa 100644 (file)
--- a/lustre/include/lprocfs_status.h
+++ b/lustre/include/lprocfs_status.h
@@ -128,18 +128,22 @@ struct obd_hist_pcpu {
  * multiply per counter increment.
  */
 
  * multiply per counter increment.
  */
 

-enum {
+enum lprocfs_counter_config {

        LPROCFS_CNTR_EXTERNALLOCK       = 0x0001,
        LPROCFS_CNTR_AVGMINMAX          = 0x0002,
        LPROCFS_CNTR_STDDEV             = 0x0004,
 
        LPROCFS_CNTR_EXTERNALLOCK       = 0x0001,
        LPROCFS_CNTR_AVGMINMAX          = 0x0002,
        LPROCFS_CNTR_STDDEV             = 0x0004,
 

-       /* counter data type */
-       LPROCFS_TYPE_REQS               = 0x0100,
+       /* counter unit type */
+       LPROCFS_TYPE_REQS               = 0x0000, /* default if config = 0 */

        LPROCFS_TYPE_BYTES              = 0x0200,
        LPROCFS_TYPE_PAGES              = 0x0400,
        LPROCFS_TYPE_BYTES              = 0x0200,
        LPROCFS_TYPE_PAGES              = 0x0400,

-       LPROCFS_TYPE_USEC               = 0x0800,
+       LPROCFS_TYPE_LOCKS              = 0x0500,
+       LPROCFS_TYPE_LOCKSPS            = 0x0600,
+       LPROCFS_TYPE_SECS               = 0x0700,
+       LPROCFS_TYPE_USECS              = 0x0800,
+       LPROCFS_TYPE_MASK               = 0x0f00,

 
 

-       LPROCFS_TYPE_LATENCY            = LPROCFS_TYPE_USEC |
+       LPROCFS_TYPE_LATENCY            = LPROCFS_TYPE_USECS |

                                          LPROCFS_CNTR_AVGMINMAX |
                                          LPROCFS_CNTR_STDDEV,
        LPROCFS_TYPE_BYTES_FULL         = LPROCFS_TYPE_BYTES |
                                          LPROCFS_CNTR_AVGMINMAX |
                                          LPROCFS_CNTR_STDDEV,
        LPROCFS_TYPE_BYTES_FULL         = LPROCFS_TYPE_BYTES |


@@ -149,9 +153,9 @@ enum {
 #define LC_MIN_INIT ((~(__u64)0) >> 1)
 
 struct lprocfs_counter_header {
 #define LC_MIN_INIT ((~(__u64)0) >> 1)
 
 struct lprocfs_counter_header {

-       unsigned int            lc_config;
-       const char              *lc_name;   /* must be static */
-       const char              *lc_units;  /* must be static */
+       enum lprocfs_counter_config     lc_config;
+       const char                      *lc_name;   /* must be static */
+       const char                      *lc_units;  /* must be static */

 };
 
 struct lprocfs_counter {
 };
 
 struct lprocfs_counter {


@@ -521,8 +525,11 @@ extern int lprocfs_alloc_obd_stats(struct obd_device *obd,
 extern int lprocfs_alloc_md_stats(struct obd_device *obd,
                                  unsigned int num_private_stats);
 extern void lprocfs_counter_init(struct lprocfs_stats *stats, int index,
 extern int lprocfs_alloc_md_stats(struct obd_device *obd,
                                  unsigned int num_private_stats);
 extern void lprocfs_counter_init(struct lprocfs_stats *stats, int index,

-                                unsigned conf, const char *name,
-                                const char *units);
+                                enum lprocfs_counter_config config,
+                                const char *name);
+extern void lprocfs_counter_init_units(struct lprocfs_stats *stats, int index,
+                                      enum lprocfs_counter_config config,
+                                      const char *name, const char *units);

 extern void lprocfs_free_obd_stats(struct obd_device *obd);
 extern void lprocfs_free_md_stats(struct obd_device *obd);
 struct obd_export;
 extern void lprocfs_free_obd_stats(struct obd_device *obd);
 extern void lprocfs_free_md_stats(struct obd_device *obd);
 struct obd_export;


@@ -906,24 +913,26 @@ int lprocfs_wr_nosquash_nids(const char __user *buffer, unsigned long count,
 #define proc_lustre_root NULL
 
 static inline void lprocfs_counter_add(struct lprocfs_stats *stats,
 #define proc_lustre_root NULL
 
 static inline void lprocfs_counter_add(struct lprocfs_stats *stats,

-                                       int index, long amount)
+                                      int index, long amount)

 { return; }
 { return; }

-static inline void lprocfs_counter_incr(struct lprocfs_stats *stats,
-                                        int index)
+static inline void lprocfs_counter_incr(struct lprocfs_stats *stats, int index)

 { return; }
 static inline void lprocfs_counter_sub(struct lprocfs_stats *stats,
 { return; }
 static inline void lprocfs_counter_sub(struct lprocfs_stats *stats,

-                                       int index, long amount)
+                                      int index, long amount)
+{ return; }
+static inline void lprocfs_counter_decr(struct lprocfs_stats *stats, int index)

 { return; }
 { return; }

-static inline void lprocfs_counter_decr(struct lprocfs_stats *stats,
-                                        int index)
+static inline void lprocfs_counter_init(struct lprocfs_stats *stats, int index,
+                                       enum lprocfs_counter_config config,
+                                       const char *name)

 { return; }
 { return; }

-static inline void lprocfs_counter_init(struct lprocfs_stats *stats,
-                                        int index, unsigned conf,
-                                        const char *name, const char *units)
+static inline void lprocfs_counter_init_units(struct lprocfs_stats *stats,
+                               int index, enum lprocfs_counter_config config,
+                               const char *name, const char *units)

 { return; }
 
 static inline __u64 lc_read_helper(struct lprocfs_counter *lc,
 { return; }
 
 static inline __u64 lc_read_helper(struct lprocfs_counter *lc,

-                                   enum lprocfs_fields_flags field)
+                                  enum lprocfs_fields_flags field)

 { return 0; }
 
 /* NB: we return !NULL to satisfy error checker */
 { return 0; }
 
 /* NB: we return !NULL to satisfy error checker */

diff --git a/lustre/ldlm/ldlm_pool.c b/lustre/ldlm/ldlm_pool.c
index c424aac..dac8f11 100644 (file)
--- a/lustre/ldlm/ldlm_pool.c
+++ b/lustre/ldlm/ldlm_pool.c
@@ -845,27 +845,37 @@ static int ldlm_pool_debugfs_init(struct ldlm_pool *pl)
                GOTO(out, rc = -ENOMEM);
 
        lprocfs_counter_init(pl->pl_stats, LDLM_POOL_GRANTED_STAT,
                GOTO(out, rc = -ENOMEM);
 
        lprocfs_counter_init(pl->pl_stats, LDLM_POOL_GRANTED_STAT,

-                            LPROCFS_CNTR_AVGMINMAX, "granted", "locks");
+                            LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_LOCKS,
+                            "granted");

        lprocfs_counter_init(pl->pl_stats, LDLM_POOL_GRANT_STAT,
        lprocfs_counter_init(pl->pl_stats, LDLM_POOL_GRANT_STAT,

-                            LPROCFS_CNTR_AVGMINMAX, "grant", "locks");
+                            LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_LOCKS,
+                            "grant");

        lprocfs_counter_init(pl->pl_stats, LDLM_POOL_CANCEL_STAT,
        lprocfs_counter_init(pl->pl_stats, LDLM_POOL_CANCEL_STAT,

-                            LPROCFS_CNTR_AVGMINMAX, "cancel", "locks");
+                            LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_LOCKS,
+                            "cancel");

        lprocfs_counter_init(pl->pl_stats, LDLM_POOL_GRANT_RATE_STAT,
        lprocfs_counter_init(pl->pl_stats, LDLM_POOL_GRANT_RATE_STAT,

-                            LPROCFS_CNTR_AVGMINMAX, "grant_rate", "locks/s");
+                            LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_LOCKSPS,
+                            "grant_rate");

        lprocfs_counter_init(pl->pl_stats, LDLM_POOL_CANCEL_RATE_STAT,
        lprocfs_counter_init(pl->pl_stats, LDLM_POOL_CANCEL_RATE_STAT,

-                            LPROCFS_CNTR_AVGMINMAX, "cancel_rate", "locks/s");
+                            LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_LOCKSPS,
+                            "cancel_rate");

        lprocfs_counter_init(pl->pl_stats, LDLM_POOL_GRANT_PLAN_STAT,
        lprocfs_counter_init(pl->pl_stats, LDLM_POOL_GRANT_PLAN_STAT,

-                            LPROCFS_CNTR_AVGMINMAX, "grant_plan", "locks/s");
-       lprocfs_counter_init(pl->pl_stats, LDLM_POOL_SLV_STAT,
-                            LPROCFS_CNTR_AVGMINMAX, "slv", "slv");
+                            LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_LOCKSPS,
+                            "grant_plan");
+       lprocfs_counter_init_units(pl->pl_stats, LDLM_POOL_SLV_STAT,
+                            LPROCFS_CNTR_AVGMINMAX, "slv", "lock.secs");

        lprocfs_counter_init(pl->pl_stats, LDLM_POOL_SHRINK_REQTD_STAT,
        lprocfs_counter_init(pl->pl_stats, LDLM_POOL_SHRINK_REQTD_STAT,

-                            LPROCFS_CNTR_AVGMINMAX, "shrink_request", "locks");
+                            LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_LOCKS,
+                            "shrink_request");

        lprocfs_counter_init(pl->pl_stats, LDLM_POOL_SHRINK_FREED_STAT,
        lprocfs_counter_init(pl->pl_stats, LDLM_POOL_SHRINK_FREED_STAT,

-                            LPROCFS_CNTR_AVGMINMAX, "shrink_freed", "locks");
+                            LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_LOCKS,
+                            "shrink_freed");

        lprocfs_counter_init(pl->pl_stats, LDLM_POOL_RECALC_STAT,
        lprocfs_counter_init(pl->pl_stats, LDLM_POOL_RECALC_STAT,

-                            LPROCFS_CNTR_AVGMINMAX, "recalc_freed", "locks");
+                            LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_LOCKS,
+                            "recalc_freed");

        lprocfs_counter_init(pl->pl_stats, LDLM_POOL_TIMING_STAT,
        lprocfs_counter_init(pl->pl_stats, LDLM_POOL_TIMING_STAT,

-                            LPROCFS_CNTR_AVGMINMAX, "recalc_timing", "sec");
+                            LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_SECS,
+                            "recalc_timing");

        debugfs_create_file("stats", 0644, pl->pl_debugfs_entry,
                            pl->pl_stats, &ldebugfs_stats_seq_fops);
 
        debugfs_create_file("stats", 0644, pl->pl_debugfs_entry,
                            pl->pl_stats, &ldebugfs_stats_seq_fops);
 

diff --git a/lustre/ldlm/ldlm_resource.c b/lustre/ldlm/ldlm_resource.c
index b00579e..d73ef51 100644 (file)
--- a/lustre/ldlm/ldlm_resource.c
+++ b/lustre/ldlm/ldlm_resource.c
@@ -742,7 +742,8 @@ int ldlm_namespace_sysfs_register(struct ldlm_namespace *ns)
        }
 
        lprocfs_counter_init(ns->ns_stats, LDLM_NSS_LOCKS,
        }
 
        lprocfs_counter_init(ns->ns_stats, LDLM_NSS_LOCKS,

-                            LPROCFS_CNTR_AVGMINMAX, "locks", "locks");
+                            LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_LOCKS,
+                            "locks");

 
        return err;
 }
 
        return err;
 }

diff --git a/lustre/llite/lproc_llite.c b/lustre/llite/lproc_llite.c
index 50fd29d..b121b89 100644 (file)
--- a/lustre/llite/lproc_llite.c
+++ b/lustre/llite/lproc_llite.c
@@ -39,6 +39,7 @@
 #include <obd_support.h>
 
 #include "llite_internal.h"
 #include <obd_support.h>
 
 #include "llite_internal.h"

+#include "lprocfs_status.h"

 #include "vvp_internal.h"
 
 static struct kobject *llite_kobj;
 #include "vvp_internal.h"
 
 static struct kobject *llite_kobj;


@@ -1808,9 +1809,9 @@ static struct kobj_type sbi_ktype = {
 };
 
 static const struct llite_file_opcode {
 };
 
 static const struct llite_file_opcode {

-       __u32           opcode;
-       __u32           type;
-       const char      *opname;
+       __u32                           lfo_opcode;
+       enum lprocfs_counter_config     lfo_config;
+       const char                      *lfo_opname;

 } llite_opcode_table[LPROC_LL_FILE_OPCODES] = {
        /* file operation */
        { LPROC_LL_READ_BYTES,  LPROCFS_TYPE_BYTES_FULL, "read_bytes" },
 } llite_opcode_table[LPROC_LL_FILE_OPCODES] = {
        /* file operation */
        { LPROC_LL_READ_BYTES,  LPROCFS_TYPE_BYTES_FULL, "read_bytes" },


@@ -1826,8 +1827,7 @@ static const struct llite_file_opcode {
        { LPROC_LL_LLSEEK,      LPROCFS_TYPE_LATENCY,   "seek" },
        { LPROC_LL_FSYNC,       LPROCFS_TYPE_LATENCY,   "fsync" },
        { LPROC_LL_READDIR,     LPROCFS_TYPE_LATENCY,   "readdir" },
        { LPROC_LL_LLSEEK,      LPROCFS_TYPE_LATENCY,   "seek" },
        { LPROC_LL_FSYNC,       LPROCFS_TYPE_LATENCY,   "fsync" },
        { LPROC_LL_READDIR,     LPROCFS_TYPE_LATENCY,   "readdir" },

-       { LPROC_LL_INODE_OCOUNT,LPROCFS_TYPE_REQS |
-                               LPROCFS_CNTR_AVGMINMAX |
+       { LPROC_LL_INODE_OCOUNT, LPROCFS_TYPE_REQS | LPROCFS_CNTR_AVGMINMAX |

                                LPROCFS_CNTR_STDDEV,    "opencount" },
        { LPROC_LL_INODE_OPCLTM,LPROCFS_TYPE_LATENCY,   "openclosetime" },
        /* inode operation */
                                LPROCFS_CNTR_STDDEV,    "opencount" },
        { LPROC_LL_INODE_OPCLTM,LPROCFS_TYPE_LATENCY,   "openclosetime" },
        /* inode operation */


@@ -1835,7 +1835,7 @@ static const struct llite_file_opcode {
        { LPROC_LL_TRUNC,       LPROCFS_TYPE_LATENCY,   "truncate" },
        { LPROC_LL_FLOCK,       LPROCFS_TYPE_LATENCY,   "flock" },
        { LPROC_LL_GETATTR,     LPROCFS_TYPE_LATENCY,   "getattr" },
        { LPROC_LL_TRUNC,       LPROCFS_TYPE_LATENCY,   "truncate" },
        { LPROC_LL_FLOCK,       LPROCFS_TYPE_LATENCY,   "flock" },
        { LPROC_LL_GETATTR,     LPROCFS_TYPE_LATENCY,   "getattr" },

-       { LPROC_LL_FALLOCATE,   LPROCFS_TYPE_LATENCY, "fallocate"},
+       { LPROC_LL_FALLOCATE,   LPROCFS_TYPE_LATENCY,   "fallocate"},

        /* dir inode operation */
        { LPROC_LL_CREATE,      LPROCFS_TYPE_LATENCY,   "create" },
        { LPROC_LL_LINK,        LPROCFS_TYPE_LATENCY,   "link" },
        /* dir inode operation */
        { LPROC_LL_CREATE,      LPROCFS_TYPE_LATENCY,   "create" },
        { LPROC_LL_LINK,        LPROCFS_TYPE_LATENCY,   "link" },


@@ -1929,20 +1929,11 @@ int ll_debugfs_register_super(struct super_block *sb, const char *name)
                GOTO(out_debugfs, err = -ENOMEM);
 
        /* do counter init */
                GOTO(out_debugfs, err = -ENOMEM);
 
        /* do counter init */

-       for (id = 0; id < LPROC_LL_FILE_OPCODES; id++) {
-               u32 type = llite_opcode_table[id].type;
-               void *ptr = "unknown";
-
-               if (type & LPROCFS_TYPE_REQS)
-                       ptr = "reqs";
-               else if (type & LPROCFS_TYPE_BYTES)
-                       ptr = "bytes";
-               else if (type & LPROCFS_TYPE_USEC)
-                       ptr = "usec";
+       for (id = 0; id < LPROC_LL_FILE_OPCODES; id++)

                lprocfs_counter_init(sbi->ll_stats,
                lprocfs_counter_init(sbi->ll_stats,

-                                    llite_opcode_table[id].opcode, type,
-                                    llite_opcode_table[id].opname, ptr);
-       }
+                                    llite_opcode_table[id].lfo_opcode,
+                                    llite_opcode_table[id].lfo_config,
+                                    llite_opcode_table[id].lfo_opname);

 
        debugfs_create_file("stats", 0644, sbi->ll_debugfs_entry,
                            sbi->ll_stats, &ldebugfs_stats_seq_fops);
 
        debugfs_create_file("stats", 0644, sbi->ll_debugfs_entry,
                            sbi->ll_stats, &ldebugfs_stats_seq_fops);


@@ -1953,8 +1944,8 @@ int ll_debugfs_register_super(struct super_block *sb, const char *name)
                GOTO(out_stats, err = -ENOMEM);
 
        for (id = 0; id < ARRAY_SIZE(ra_stat_string); id++)
                GOTO(out_stats, err = -ENOMEM);
 
        for (id = 0; id < ARRAY_SIZE(ra_stat_string); id++)

-               lprocfs_counter_init(sbi->ll_ra_stats, id, 0,
-                                    ra_stat_string[id], "pages");
+               lprocfs_counter_init(sbi->ll_ra_stats, id, LPROCFS_TYPE_PAGES,
+                                    ra_stat_string[id]);

 
        debugfs_create_file("read_ahead_stats", 0644, sbi->ll_debugfs_entry,
                            sbi->ll_ra_stats, &ldebugfs_stats_seq_fops);
 
        debugfs_create_file("read_ahead_stats", 0644, sbi->ll_debugfs_entry,
                            sbi->ll_ra_stats, &ldebugfs_stats_seq_fops);

diff --git a/lustre/mdt/mdt_lproc.c b/lustre/mdt/mdt_lproc.c
index 6dfc117..a43fe90 100644 (file)
--- a/lustre/mdt/mdt_lproc.c
+++ b/lustre/mdt/mdt_lproc.c
@@ -1674,11 +1674,10 @@ void mdt_stats_counter_init(struct lprocfs_stats *stats, unsigned int offset)
                    midx == LPROC_MDT_IO_WRITE_BYTES)
                        lprocfs_counter_init(stats, oidx,
                                             LPROCFS_TYPE_BYTES_FULL,
                    midx == LPROC_MDT_IO_WRITE_BYTES)
                        lprocfs_counter_init(stats, oidx,
                                             LPROCFS_TYPE_BYTES_FULL,

-                                            mdt_stats[midx], "bytes");
+                                            mdt_stats[midx]);

                else
                else

-                       lprocfs_counter_init(stats, oidx,
-                                            LPROCFS_TYPE_LATENCY,
-                                            mdt_stats[midx], "usecs");
+                       lprocfs_counter_init(stats, oidx, LPROCFS_TYPE_LATENCY,
+                                            mdt_stats[midx]);

        }
 }
 
        }
 }
 

diff --git a/lustre/mgs/lproc_mgs.c b/lustre/mgs/lproc_mgs.c
index 4cb65fb..7e8c3f1 100644 (file)
--- a/lustre/mgs/lproc_mgs.c
+++ b/lustre/mgs/lproc_mgs.c
@@ -353,27 +353,25 @@ void lproc_mgs_cleanup(struct mgs_device *mgs)
                mgs->mgs_proc_live = NULL;
        }
 
                mgs->mgs_proc_live = NULL;
        }
 

-        lprocfs_free_per_client_stats(obd);
+       lprocfs_free_per_client_stats(obd);

        lprocfs_obd_cleanup(obd);
        lprocfs_obd_cleanup(obd);

-        lprocfs_free_obd_stats(obd);
-        lprocfs_free_md_stats(obd);
+       lprocfs_free_obd_stats(obd);
+       lprocfs_free_md_stats(obd);

 }
 
 void mgs_counter_incr(struct obd_export *exp, int opcode)
 {
 }
 
 void mgs_counter_incr(struct obd_export *exp, int opcode)
 {

-        lprocfs_counter_incr(exp->exp_obd->obd_stats, opcode);
-        if (exp->exp_nid_stats && exp->exp_nid_stats->nid_stats != NULL)
-                lprocfs_counter_incr(exp->exp_nid_stats->nid_stats, opcode);
+       lprocfs_counter_incr(exp->exp_obd->obd_stats, opcode);
+       if (exp->exp_nid_stats && exp->exp_nid_stats->nid_stats != NULL)
+               lprocfs_counter_incr(exp->exp_nid_stats->nid_stats, opcode);

 }
 
 void mgs_stats_counter_init(struct lprocfs_stats *stats)
 {
 }
 
 void mgs_stats_counter_init(struct lprocfs_stats *stats)
 {

-        lprocfs_counter_init(stats, LPROC_MGS_CONNECT, 0, "connect", "reqs");
-        lprocfs_counter_init(stats, LPROC_MGS_DISCONNECT, 0, "disconnect",
-                             "reqs");
-        lprocfs_counter_init(stats, LPROC_MGS_EXCEPTION, 0, "exception",
-                             "reqs");
-        lprocfs_counter_init(stats, LPROC_MGS_TARGET_REG, 0, "tgtreg", "reqs");
-        lprocfs_counter_init(stats, LPROC_MGS_TARGET_DEL, 0, "tgtdel", "reqs");
+       lprocfs_counter_init(stats, LPROC_MGS_CONNECT, 0, "connect");
+       lprocfs_counter_init(stats, LPROC_MGS_DISCONNECT, 0, "disconnect");
+       lprocfs_counter_init(stats, LPROC_MGS_EXCEPTION, 0, "exception");
+       lprocfs_counter_init(stats, LPROC_MGS_TARGET_REG, 0, "tgtreg");
+       lprocfs_counter_init(stats, LPROC_MGS_TARGET_DEL, 0, "tgtdel");

 }
 #endif
 }
 #endif

diff --git a/lustre/obdclass/class_obd.c b/lustre/obdclass/class_obd.c
index 135d188..5b7efd2 100644 (file)
--- a/lustre/obdclass/class_obd.c
+++ b/lustre/obdclass/class_obd.c
@@ -694,8 +694,8 @@ static int __init obdclass_init(void)
        }
 
        lprocfs_counter_init(obd_memory, OBD_MEMORY_STAT,
        }
 
        lprocfs_counter_init(obd_memory, OBD_MEMORY_STAT,

-                            LPROCFS_CNTR_AVGMINMAX,
-                            "memused", "bytes");
+                            LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_BYTES,
+                            "memused");

 #endif
        err = obd_zombie_impexp_init();
        if (err)
 #endif
        err = obd_zombie_impexp_init();
        if (err)

diff --git a/lustre/obdclass/lprocfs_status.c b/lustre/obdclass/lprocfs_status.c
index ca0234d..5b11a27 100644 (file)
--- a/lustre/obdclass/lprocfs_status.c
+++ b/lustre/obdclass/lprocfs_status.c
@@ -1462,8 +1462,34 @@ int lprocfs_register_stats(struct proc_dir_entry *root, const char *name,
 }
 EXPORT_SYMBOL(lprocfs_register_stats);
 
 }
 EXPORT_SYMBOL(lprocfs_register_stats);
 

-void lprocfs_counter_init(struct lprocfs_stats *stats, int index,
-                         unsigned conf, const char *name, const char *units)
+static const char *lprocfs_counter_config_units(const char *name,
+                                        enum lprocfs_counter_config config)
+{
+       const char *units;
+
+       switch (config & LPROCFS_TYPE_MASK) {
+       default:
+               units = "reqs"; break;
+       case LPROCFS_TYPE_BYTES:
+               units = "bytes"; break;
+       case LPROCFS_TYPE_PAGES:
+               units = "pages"; break;
+       case LPROCFS_TYPE_LOCKS:
+               units = "locks"; break;
+       case LPROCFS_TYPE_LOCKSPS:
+               units = "locks/s"; break;
+       case LPROCFS_TYPE_SECS:
+               units = "secs"; break;
+       case LPROCFS_TYPE_USECS:
+               units = "usecs"; break;
+       }
+
+       return units;
+}
+
+void lprocfs_counter_init_units(struct lprocfs_stats *stats, int index,
+                               enum lprocfs_counter_config config,
+                               const char *name, const char *units)

 {
        struct lprocfs_counter_header *header;
        struct lprocfs_counter *percpu_cntr;
 {
        struct lprocfs_counter_header *header;
        struct lprocfs_counter *percpu_cntr;


@@ -1477,9 +1503,9 @@ void lprocfs_counter_init(struct lprocfs_stats *stats, int index,
        LASSERTF(header != NULL, "Failed to allocate stats header:[%d]%s/%s\n",
                 index, name, units);
 
        LASSERTF(header != NULL, "Failed to allocate stats header:[%d]%s/%s\n",
                 index, name, units);
 

-       header->lc_config = conf;
-       header->lc_name   = name;
-       header->lc_units  = units;
+       header->lc_config = config;
+       header->lc_name = name;
+       header->lc_units = units;

 
        num_cpu = lprocfs_stats_lock(stats, LPROCFS_GET_NUM_CPU, &flags);
        for (i = 0; i < num_cpu; ++i) {
 
        num_cpu = lprocfs_stats_lock(stats, LPROCFS_GET_NUM_CPU, &flags);
        for (i = 0; i < num_cpu; ++i) {


@@ -1496,6 +1522,15 @@ void lprocfs_counter_init(struct lprocfs_stats *stats, int index,
        }
        lprocfs_stats_unlock(stats, LPROCFS_GET_NUM_CPU, &flags);
 }
        }
        lprocfs_stats_unlock(stats, LPROCFS_GET_NUM_CPU, &flags);
 }

+EXPORT_SYMBOL(lprocfs_counter_init_units);
+
+void lprocfs_counter_init(struct lprocfs_stats *stats, int index,
+                         enum lprocfs_counter_config config,
+                         const char *name)
+{
+       lprocfs_counter_init_units(stats, index, config, name,
+                                  lprocfs_counter_config_units(name, config));
+}

 EXPORT_SYMBOL(lprocfs_counter_init);
 
 static const char * const mps_stats[] = {
 EXPORT_SYMBOL(lprocfs_counter_init);
 
 static const char * const mps_stats[] = {


@@ -1541,7 +1576,8 @@ int lprocfs_alloc_md_stats(struct obd_device *obd,
                return -ENOMEM;
 
        for (i = 0; i < ARRAY_SIZE(mps_stats); i++) {
                return -ENOMEM;
 
        for (i = 0; i < ARRAY_SIZE(mps_stats); i++) {

-               lprocfs_counter_init(stats, i, 0, mps_stats[i], "reqs");
+               lprocfs_counter_init(stats, i, LPROCFS_TYPE_REQS,
+                                    mps_stats[i]);

                if (!stats->ls_cnt_header[i].lc_name) {
                        CERROR("Missing md_stat initializer md_op operation at offset %d. Aborting.\n",
                               i);
                if (!stats->ls_cnt_header[i].lc_name) {
                        CERROR("Missing md_stat initializer md_op operation at offset %d. Aborting.\n",
                               i);


@@ -1573,24 +1609,18 @@ EXPORT_SYMBOL(lprocfs_free_md_stats);
 
 void lprocfs_init_ldlm_stats(struct lprocfs_stats *ldlm_stats)
 {
 
 void lprocfs_init_ldlm_stats(struct lprocfs_stats *ldlm_stats)
 {

-       lprocfs_counter_init(ldlm_stats,
-                            LDLM_ENQUEUE - LDLM_FIRST_OPC,
-                            0, "ldlm_enqueue", "reqs");
-       lprocfs_counter_init(ldlm_stats,
-                            LDLM_CONVERT - LDLM_FIRST_OPC,
-                            0, "ldlm_convert", "reqs");
-       lprocfs_counter_init(ldlm_stats,
-                            LDLM_CANCEL - LDLM_FIRST_OPC,
-                            0, "ldlm_cancel", "reqs");
-       lprocfs_counter_init(ldlm_stats,
-                            LDLM_BL_CALLBACK - LDLM_FIRST_OPC,
-                            0, "ldlm_bl_callback", "reqs");
-       lprocfs_counter_init(ldlm_stats,
-                            LDLM_CP_CALLBACK - LDLM_FIRST_OPC,
-                            0, "ldlm_cp_callback", "reqs");
-       lprocfs_counter_init(ldlm_stats,
-                            LDLM_GL_CALLBACK - LDLM_FIRST_OPC,
-                            0, "ldlm_gl_callback", "reqs");
+       lprocfs_counter_init(ldlm_stats, LDLM_ENQUEUE - LDLM_FIRST_OPC,
+                            LPROCFS_TYPE_REQS, "ldlm_enqueue");
+       lprocfs_counter_init(ldlm_stats, LDLM_CONVERT - LDLM_FIRST_OPC,
+                            LPROCFS_TYPE_REQS, "ldlm_convert");
+       lprocfs_counter_init(ldlm_stats, LDLM_CANCEL - LDLM_FIRST_OPC,
+                            LPROCFS_TYPE_REQS, "ldlm_cancel");
+       lprocfs_counter_init(ldlm_stats, LDLM_BL_CALLBACK - LDLM_FIRST_OPC,
+                            LPROCFS_TYPE_REQS, "ldlm_bl_callback");
+       lprocfs_counter_init(ldlm_stats, LDLM_CP_CALLBACK - LDLM_FIRST_OPC,
+                            LPROCFS_TYPE_REQS, "ldlm_cp_callback");
+       lprocfs_counter_init(ldlm_stats, LDLM_GL_CALLBACK - LDLM_FIRST_OPC,
+                            LPROCFS_TYPE_REQS, "ldlm_gl_callback");

 }
 EXPORT_SYMBOL(lprocfs_init_ldlm_stats);
 
 }
 EXPORT_SYMBOL(lprocfs_init_ldlm_stats);
 


@@ -1620,7 +1650,9 @@ __s64 lprocfs_read_helper(struct lprocfs_counter *lc,
                        ret = lc->lc_max;
                        break;
                case LPROCFS_FIELDS_FLAGS_AVG:
                        ret = lc->lc_max;
                        break;
                case LPROCFS_FIELDS_FLAGS_AVG:

-                       ret = (lc->lc_max - lc->lc_min) / 2;
+                       ret = div64_u64((flags & LPROCFS_STATS_FLAG_IRQ_SAFE ?
+                                        lc->lc_sum_irq : 0) + lc->lc_sum,
+                                       lc->lc_count);

                        break;
                case LPROCFS_FIELDS_FLAGS_SUMSQUARE:
                        ret = lc->lc_sumsquare;
                        break;
                case LPROCFS_FIELDS_FLAGS_SUMSQUARE:
                        ret = lc->lc_sumsquare;

diff --git a/lustre/obdclass/lu_object.c b/lustre/obdclass/lu_object.c
index 3a07035..773e7f2 100644 (file)
--- a/lustre/obdclass/lu_object.c
+++ b/lustre/obdclass/lu_object.c
@@ -1160,24 +1160,19 @@ int lu_site_init(struct lu_site *s, struct lu_device *top)
                return -ENOMEM;
        }
 
                return -ENOMEM;
        }
 

-        lprocfs_counter_init(s->ls_stats, LU_SS_CREATED,
-                             0, "created", "created");
-        lprocfs_counter_init(s->ls_stats, LU_SS_CACHE_HIT,
-                             0, "cache_hit", "cache_hit");
-        lprocfs_counter_init(s->ls_stats, LU_SS_CACHE_MISS,
-                             0, "cache_miss", "cache_miss");
-        lprocfs_counter_init(s->ls_stats, LU_SS_CACHE_RACE,
-                             0, "cache_race", "cache_race");
-        lprocfs_counter_init(s->ls_stats, LU_SS_CACHE_DEATH_RACE,
-                             0, "cache_death_race", "cache_death_race");
-        lprocfs_counter_init(s->ls_stats, LU_SS_LRU_PURGED,
-                             0, "lru_purged", "lru_purged");
+       lprocfs_counter_init(s->ls_stats, LU_SS_CREATED, 0, "created");
+       lprocfs_counter_init(s->ls_stats, LU_SS_CACHE_HIT, 0, "cache_hit");
+       lprocfs_counter_init(s->ls_stats, LU_SS_CACHE_MISS, 0, "cache_miss");
+       lprocfs_counter_init(s->ls_stats, LU_SS_CACHE_RACE, 0, "cache_race");
+       lprocfs_counter_init(s->ls_stats, LU_SS_CACHE_DEATH_RACE,
+                            0, "cache_death_race");
+       lprocfs_counter_init(s->ls_stats, LU_SS_LRU_PURGED, 0, "lru_purged");

 
        INIT_LIST_HEAD(&s->ls_linkage);
 
        INIT_LIST_HEAD(&s->ls_linkage);

-        s->ls_top_dev = top;
-        top->ld_site = s;
-        lu_device_get(top);
-        lu_ref_add(&top->ld_reference, "site-top", s);
+       s->ls_top_dev = top;
+       top->ld_site = s;
+       lu_device_get(top);
+       lu_ref_add(&top->ld_reference, "site-top", s);

 
        INIT_LIST_HEAD(&s->ls_ld_linkage);
        spin_lock_init(&s->ls_ld_lock);
 
        INIT_LIST_HEAD(&s->ls_ld_linkage);
        spin_lock_init(&s->ls_ld_lock);

diff --git a/lustre/obdecho/echo.c b/lustre/obdecho/echo.c
index b65d01a..5de02d8 100644 (file)
--- a/lustre/obdecho/echo.c
+++ b/lustre/obdecho/echo.c
@@ -779,11 +779,11 @@ static int echo_srv_init0(const struct lu_env *env,
        if (!lprocfs_obd_setup(obd, true) &&
            lprocfs_alloc_obd_stats(obd, LPROC_ECHO_LAST) == 0) {
                lprocfs_counter_init(obd->obd_stats, LPROC_ECHO_READ_BYTES,
        if (!lprocfs_obd_setup(obd, true) &&
            lprocfs_alloc_obd_stats(obd, LPROC_ECHO_LAST) == 0) {
                lprocfs_counter_init(obd->obd_stats, LPROC_ECHO_READ_BYTES,

-                                    LPROCFS_CNTR_AVGMINMAX,
-                                    "read_bytes", "bytes");
+                                    LPROCFS_CNTR_AVGMINMAX|LPROCFS_TYPE_BYTES,
+                                    "read_bytes");

                lprocfs_counter_init(obd->obd_stats, LPROC_ECHO_WRITE_BYTES,
                lprocfs_counter_init(obd->obd_stats, LPROC_ECHO_WRITE_BYTES,

-                                    LPROCFS_CNTR_AVGMINMAX,
-                                    "write_bytes", "bytes");
+                                    LPROCFS_CNTR_AVGMINMAX|LPROCFS_TYPE_BYTES,
+                                    "write_bytes");

        }
 
        ptlrpc_init_client(LDLM_CB_REQUEST_PORTAL, LDLM_CB_REPLY_PORTAL,
        }
 
        ptlrpc_init_client(LDLM_CB_REQUEST_PORTAL, LDLM_CB_REPLY_PORTAL,

diff --git a/lustre/ofd/lproc_ofd.c b/lustre/ofd/lproc_ofd.c
index db81351..f6cec47 100644 (file)
--- a/lustre/ofd/lproc_ofd.c
+++ b/lustre/ofd/lproc_ofd.c
@@ -1058,35 +1058,35 @@ void ofd_stats_counter_init(struct lprocfs_stats *stats, unsigned int offset)
        LASSERT(stats && stats->ls_num >= LPROC_OFD_STATS_LAST);
 
        lprocfs_counter_init(stats, LPROC_OFD_STATS_READ_BYTES,
        LASSERT(stats && stats->ls_num >= LPROC_OFD_STATS_LAST);
 
        lprocfs_counter_init(stats, LPROC_OFD_STATS_READ_BYTES,

-                            LPROCFS_TYPE_BYTES_FULL, "read_bytes", "bytes");
+                            LPROCFS_TYPE_BYTES_FULL, "read_bytes");

        lprocfs_counter_init(stats, LPROC_OFD_STATS_WRITE_BYTES,
        lprocfs_counter_init(stats, LPROC_OFD_STATS_WRITE_BYTES,

-                            LPROCFS_TYPE_BYTES_FULL, "write_bytes", "bytes");
+                            LPROCFS_TYPE_BYTES_FULL, "write_bytes");

        lprocfs_counter_init(stats, LPROC_OFD_STATS_READ,
        lprocfs_counter_init(stats, LPROC_OFD_STATS_READ,

-                            LPROCFS_TYPE_LATENCY, "read", "usecs");
+                            LPROCFS_TYPE_LATENCY, "read");

        lprocfs_counter_init(stats, LPROC_OFD_STATS_WRITE,
        lprocfs_counter_init(stats, LPROC_OFD_STATS_WRITE,

-                            LPROCFS_TYPE_LATENCY, "write", "usecs");
+                            LPROCFS_TYPE_LATENCY, "write");

        lprocfs_counter_init(stats, LPROC_OFD_STATS_GETATTR,
        lprocfs_counter_init(stats, LPROC_OFD_STATS_GETATTR,

-                            LPROCFS_TYPE_LATENCY, "getattr", "usecs");
+                            LPROCFS_TYPE_LATENCY, "getattr");

        lprocfs_counter_init(stats, LPROC_OFD_STATS_SETATTR,
        lprocfs_counter_init(stats, LPROC_OFD_STATS_SETATTR,

-                            LPROCFS_TYPE_LATENCY, "setattr", "usecs");
+                            LPROCFS_TYPE_LATENCY, "setattr");

        lprocfs_counter_init(stats, LPROC_OFD_STATS_PUNCH,
        lprocfs_counter_init(stats, LPROC_OFD_STATS_PUNCH,

-                            LPROCFS_TYPE_LATENCY, "punch", "usecs");
+                            LPROCFS_TYPE_LATENCY, "punch");

        lprocfs_counter_init(stats, LPROC_OFD_STATS_SYNC,
        lprocfs_counter_init(stats, LPROC_OFD_STATS_SYNC,

-                            LPROCFS_TYPE_LATENCY, "sync", "usecs");
+                            LPROCFS_TYPE_LATENCY, "sync");

        lprocfs_counter_init(stats, LPROC_OFD_STATS_DESTROY,
        lprocfs_counter_init(stats, LPROC_OFD_STATS_DESTROY,

-                            LPROCFS_TYPE_LATENCY, "destroy", "usecs");
+                            LPROCFS_TYPE_LATENCY, "destroy");

        lprocfs_counter_init(stats, LPROC_OFD_STATS_CREATE,
        lprocfs_counter_init(stats, LPROC_OFD_STATS_CREATE,

-                            LPROCFS_TYPE_LATENCY, "create", "usecs");
+                            LPROCFS_TYPE_LATENCY, "create");

        lprocfs_counter_init(stats, LPROC_OFD_STATS_STATFS,
        lprocfs_counter_init(stats, LPROC_OFD_STATS_STATFS,

-                            LPROCFS_TYPE_LATENCY, "statfs", "usecs");
+                            LPROCFS_TYPE_LATENCY, "statfs");

        lprocfs_counter_init(stats, LPROC_OFD_STATS_GET_INFO,
        lprocfs_counter_init(stats, LPROC_OFD_STATS_GET_INFO,

-                            LPROCFS_TYPE_LATENCY, "get_info", "usecs");
+                            LPROCFS_TYPE_LATENCY, "get_info");

        lprocfs_counter_init(stats, LPROC_OFD_STATS_SET_INFO,
        lprocfs_counter_init(stats, LPROC_OFD_STATS_SET_INFO,

-                            LPROCFS_TYPE_LATENCY, "set_info", "usecs");
+                            LPROCFS_TYPE_LATENCY, "set_info");

        lprocfs_counter_init(stats, LPROC_OFD_STATS_QUOTACTL,
        lprocfs_counter_init(stats, LPROC_OFD_STATS_QUOTACTL,

-                            LPROCFS_TYPE_LATENCY, "quotactl", "usecs");
+                            LPROCFS_TYPE_LATENCY, "quotactl");

        lprocfs_counter_init(stats, LPROC_OFD_STATS_PREALLOC,
        lprocfs_counter_init(stats, LPROC_OFD_STATS_PREALLOC,

-                            LPROCFS_TYPE_LATENCY, "prealloc", "usecs");
+                            LPROCFS_TYPE_LATENCY, "prealloc");

 }
 
 LPROC_SEQ_FOPS(lprocfs_nid_stats_clear);
 }
 
 LPROC_SEQ_FOPS(lprocfs_nid_stats_clear);

diff --git a/lustre/osd-ldiskfs/osd_lproc.c b/lustre/osd-ldiskfs/osd_lproc.c
index b93881b..6f67f0f 100644 (file)
--- a/lustre/osd-ldiskfs/osd_lproc.c
+++ b/lustre/osd-ldiskfs/osd_lproc.c
@@ -84,31 +84,30 @@ static int osd_stats_init(struct osd_device *osd)
        ENTRY;
         osd->od_stats = lprocfs_alloc_stats(LPROC_OSD_LAST, 0);
        if (osd->od_stats) {
        ENTRY;
         osd->od_stats = lprocfs_alloc_stats(LPROC_OSD_LAST, 0);
        if (osd->od_stats) {

-                lprocfs_counter_init(osd->od_stats, LPROC_OSD_GET_PAGE,
-                                     LPROCFS_CNTR_AVGMINMAX|LPROCFS_CNTR_STDDEV,
-                                     "get_page", "usec");
-                lprocfs_counter_init(osd->od_stats, LPROC_OSD_NO_PAGE,
-                                     LPROCFS_CNTR_AVGMINMAX,
-                                     "get_page_failures", "num");
-                lprocfs_counter_init(osd->od_stats, LPROC_OSD_CACHE_ACCESS,
-                                     LPROCFS_CNTR_AVGMINMAX,
-                                     "cache_access", "pages");
-                lprocfs_counter_init(osd->od_stats, LPROC_OSD_CACHE_HIT,
-                                     LPROCFS_CNTR_AVGMINMAX,
-                                     "cache_hit", "pages");
-                lprocfs_counter_init(osd->od_stats, LPROC_OSD_CACHE_MISS,
-                                     LPROCFS_CNTR_AVGMINMAX,
-                                     "cache_miss", "pages");
+               lprocfs_counter_init(osd->od_stats, LPROC_OSD_GET_PAGE,
+                                    LPROCFS_TYPE_LATENCY, "get_page");
+               lprocfs_counter_init(osd->od_stats, LPROC_OSD_NO_PAGE,
+                                    LPROCFS_CNTR_AVGMINMAX|LPROCFS_TYPE_REQS,
+                                    "get_page_failures");
+               lprocfs_counter_init(osd->od_stats, LPROC_OSD_CACHE_ACCESS,
+                                    LPROCFS_CNTR_AVGMINMAX|LPROCFS_TYPE_PAGES,
+                                    "cache_access");
+               lprocfs_counter_init(osd->od_stats, LPROC_OSD_CACHE_HIT,
+                                    LPROCFS_CNTR_AVGMINMAX|LPROCFS_TYPE_PAGES,
+                                    "cache_hit");
+               lprocfs_counter_init(osd->od_stats, LPROC_OSD_CACHE_MISS,
+                                    LPROCFS_CNTR_AVGMINMAX|LPROCFS_TYPE_PAGES,
+                                    "cache_miss");

 #if OSD_THANDLE_STATS
 #if OSD_THANDLE_STATS

-                lprocfs_counter_init(osd->od_stats, LPROC_OSD_THANDLE_STARTING,
-                                     LPROCFS_CNTR_AVGMINMAX,
-                                     "thandle starting", "usec");
-                lprocfs_counter_init(osd->od_stats, LPROC_OSD_THANDLE_OPEN,
-                                     LPROCFS_CNTR_AVGMINMAX,
-                                     "thandle open", "usec");
-                lprocfs_counter_init(osd->od_stats, LPROC_OSD_THANDLE_CLOSING,
-                                     LPROCFS_CNTR_AVGMINMAX,
-                                     "thandle closing", "usec");
+               lprocfs_counter_init(osd->od_stats, LPROC_OSD_THANDLE_STARTING,
+                                    LPROCFS_CNTR_AVGMINMAX|LPROCFS_TYPE_USECS,
+                                    "thandle starting");
+               lprocfs_counter_init(osd->od_stats, LPROC_OSD_THANDLE_OPEN,
+                                    LPROCFS_CNTR_AVGMINMAX|LPROCFS_TYPE_USECS,
+                                    "thandle open");
+               lprocfs_counter_init(osd->od_stats, LPROC_OSD_THANDLE_CLOSING,
+                                    LPROCFS_CNTR_AVGMINMAX|LPROCFS_TYPE_USECS,
+                                    "thandle closing");

 #endif
                result = 0;
        }
 #endif
                result = 0;
        }

diff --git a/lustre/osd-zfs/osd_lproc.c b/lustre/osd-zfs/osd_lproc.c
index c199717..01f792d 100644 (file)
--- a/lustre/osd-zfs/osd_lproc.c
+++ b/lustre/osd-zfs/osd_lproc.c
@@ -51,39 +51,39 @@ static int osd_stats_init(struct osd_device *osd)
        osd->od_stats = lprocfs_alloc_stats(LPROC_OSD_LAST, 0);
        if (osd->od_stats) {
                lprocfs_counter_init(osd->od_stats, LPROC_OSD_GET_PAGE,
        osd->od_stats = lprocfs_alloc_stats(LPROC_OSD_LAST, 0);
        if (osd->od_stats) {
                lprocfs_counter_init(osd->od_stats, LPROC_OSD_GET_PAGE,

-                               LPROCFS_CNTR_AVGMINMAX|LPROCFS_CNTR_STDDEV,
-                               "get_page", "usec");
+                               LPROCFS_CNTR_AVGMINMAX | LPROCFS_CNTR_STDDEV |
+                               LPROCFS_TYPE_USECS, "get_page");

                lprocfs_counter_init(osd->od_stats, LPROC_OSD_NO_PAGE,
                lprocfs_counter_init(osd->od_stats, LPROC_OSD_NO_PAGE,

-                               LPROCFS_CNTR_AVGMINMAX,
-                               "get_page_failures", "num");
+                               LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_REQS,
+                               "get_page_failures");

                lprocfs_counter_init(osd->od_stats, LPROC_OSD_CACHE_ACCESS,
                lprocfs_counter_init(osd->od_stats, LPROC_OSD_CACHE_ACCESS,

-                               LPROCFS_CNTR_AVGMINMAX,
-                               "cache_access", "pages");
+                               LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_PAGES,
+                               "cache_access");

                lprocfs_counter_init(osd->od_stats, LPROC_OSD_CACHE_HIT,
                lprocfs_counter_init(osd->od_stats, LPROC_OSD_CACHE_HIT,

-                               LPROCFS_CNTR_AVGMINMAX,
-                               "cache_hit", "pages");
+                               LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_PAGES,
+                               "cache_hit");

                lprocfs_counter_init(osd->od_stats, LPROC_OSD_CACHE_MISS,
                lprocfs_counter_init(osd->od_stats, LPROC_OSD_CACHE_MISS,

-                               LPROCFS_CNTR_AVGMINMAX,
-                               "cache_miss", "pages");
+                               LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_PAGES,
+                               "cache_miss");

                lprocfs_counter_init(osd->od_stats, LPROC_OSD_COPY_IO,
                lprocfs_counter_init(osd->od_stats, LPROC_OSD_COPY_IO,

-                               LPROCFS_CNTR_AVGMINMAX,
-                               "copy", "pages");
+                               LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_PAGES,
+                               "copy");

                lprocfs_counter_init(osd->od_stats, LPROC_OSD_ZEROCOPY_IO,
                lprocfs_counter_init(osd->od_stats, LPROC_OSD_ZEROCOPY_IO,

-                               LPROCFS_CNTR_AVGMINMAX,
-                               "zerocopy", "pages");
+                               LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_PAGES,
+                               "zerocopy");

                lprocfs_counter_init(osd->od_stats, LPROC_OSD_TAIL_IO,
                lprocfs_counter_init(osd->od_stats, LPROC_OSD_TAIL_IO,

-                               LPROCFS_CNTR_AVGMINMAX,
-                               "tail", "pages");
+                               LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_PAGES,
+                               "tail");

 #ifdef OSD_THANDLE_STATS
                lprocfs_counter_init(osd->od_stats, LPROC_OSD_THANDLE_STARTING,
 #ifdef OSD_THANDLE_STATS
                lprocfs_counter_init(osd->od_stats, LPROC_OSD_THANDLE_STARTING,

-                               LPROCFS_CNTR_AVGMINMAX,
-                               "thandle_starting", "usec");
+                               LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_USECS,
+                               "thandle_starting");

                lprocfs_counter_init(osd->od_stats, LPROC_OSD_THANDLE_OPEN,
                lprocfs_counter_init(osd->od_stats, LPROC_OSD_THANDLE_OPEN,

-                               LPROCFS_CNTR_AVGMINMAX,
-                               "thandle_open", "usec");
+                               LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_USECS,
+                               "thandle_open");

                lprocfs_counter_init(osd->od_stats, LPROC_OSD_THANDLE_CLOSING,
                lprocfs_counter_init(osd->od_stats, LPROC_OSD_THANDLE_CLOSING,

-                               LPROCFS_CNTR_AVGMINMAX,
-                               "thandle_closing", "usec");
+                               LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_USECS,
+                               "thandle_closing");

 #endif
                result = 0;
        }
 #endif
                result = 0;
        }

diff --git a/lustre/ptlrpc/lproc_ptlrpc.c b/lustre/ptlrpc/lproc_ptlrpc.c
index bfb48d6..7ef662e 100644 (file)
--- a/lustre/ptlrpc/lproc_ptlrpc.c
+++ b/lustre/ptlrpc/lproc_ptlrpc.c
@@ -207,9 +207,9 @@ ptlrpc_ldebugfs_register(struct dentry *root, char *dir, char *name,
 {
        struct dentry *svc_debugfs_entry;
        struct lprocfs_stats *svc_stats;
 {
        struct dentry *svc_debugfs_entry;
        struct lprocfs_stats *svc_stats;

+       enum lprocfs_counter_config config = LPROCFS_CNTR_AVGMINMAX |
+                                            LPROCFS_CNTR_STDDEV;

        int i;
        int i;

-       unsigned int svc_counter_config = LPROCFS_CNTR_AVGMINMAX |
-                                         LPROCFS_CNTR_STDDEV;

 
        LASSERT(!*debugfs_root_ret);
        LASSERT(!*stats_ret);
 
        LASSERT(!*debugfs_root_ret);
        LASSERT(!*stats_ret);


@@ -225,37 +225,33 @@ ptlrpc_ldebugfs_register(struct dentry *root, char *dir, char *name,
                svc_debugfs_entry = root;
 
        lprocfs_counter_init(svc_stats, PTLRPC_REQWAIT_CNTR,
                svc_debugfs_entry = root;
 
        lprocfs_counter_init(svc_stats, PTLRPC_REQWAIT_CNTR,

-                            svc_counter_config, "req_waittime", "usec");
+                            config | LPROCFS_TYPE_USECS, "req_waittime");

        lprocfs_counter_init(svc_stats, PTLRPC_REQQDEPTH_CNTR,
        lprocfs_counter_init(svc_stats, PTLRPC_REQQDEPTH_CNTR,

-                            svc_counter_config, "req_qdepth", "reqs");
+                            config | LPROCFS_TYPE_REQS, "req_qdepth");

        lprocfs_counter_init(svc_stats, PTLRPC_REQACTIVE_CNTR,
        lprocfs_counter_init(svc_stats, PTLRPC_REQACTIVE_CNTR,

-                            svc_counter_config, "req_active", "reqs");
+                            config | LPROCFS_TYPE_REQS, "req_active");

        lprocfs_counter_init(svc_stats, PTLRPC_TIMEOUT,
        lprocfs_counter_init(svc_stats, PTLRPC_TIMEOUT,

-                            svc_counter_config, "req_timeout", "sec");
-       lprocfs_counter_init(svc_stats, PTLRPC_REQBUF_AVAIL_CNTR,
-                            svc_counter_config, "reqbuf_avail", "bufs");
+                            config | LPROCFS_TYPE_SECS, "req_timeout");
+       lprocfs_counter_init_units(svc_stats, PTLRPC_REQBUF_AVAIL_CNTR,
+                            config, "reqbuf_avail", "bufs");

        for (i = 0; i < EXTRA_LAST_OPC; i++) {
        for (i = 0; i < EXTRA_LAST_OPC; i++) {

-               char *units;
+               enum lprocfs_counter_config extra_type = LPROCFS_TYPE_REQS;

 
                switch (i) {
                case BRW_WRITE_BYTES:
                case BRW_READ_BYTES:
 
                switch (i) {
                case BRW_WRITE_BYTES:
                case BRW_READ_BYTES:

-                       units = "bytes";
-                       break;
-               default:
-                       units = "reqs";
+                       extra_type = LPROCFS_TYPE_BYTES;

                        break;
                }
                lprocfs_counter_init(svc_stats, PTLRPC_LAST_CNTR + i,
                        break;
                }
                lprocfs_counter_init(svc_stats, PTLRPC_LAST_CNTR + i,

-                                    svc_counter_config,
-                                    ll_eopcode2str(i), units);
+                                    config | extra_type, ll_eopcode2str(i));

        }
        for (i = 0; i < LUSTRE_MAX_OPCODES; i++) {
                __u32 opcode = ll_rpc_opcode_table[i].opcode;
 
        }
        for (i = 0; i < LUSTRE_MAX_OPCODES; i++) {
                __u32 opcode = ll_rpc_opcode_table[i].opcode;
 

-               lprocfs_counter_init(svc_stats,
-                                    EXTRA_MAX_OPCODES + i, svc_counter_config,
-                                    ll_opcode2str(opcode), "usec");
+               lprocfs_counter_init(svc_stats, EXTRA_MAX_OPCODES + i,
+                                    config | LPROCFS_TYPE_USECS,
+                                    ll_opcode2str(opcode));

        }
 
        debugfs_create_file(name, 0644, svc_debugfs_entry, svc_stats,
        }
 
        debugfs_create_file(name, 0644, svc_debugfs_entry, svc_stats,