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>
* multiply per counter increment.
*/
-enum {
+enum lprocfs_counter_config {
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_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 |
#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 {
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;
#define proc_lustre_root NULL
static inline void lprocfs_counter_add(struct lprocfs_stats *stats,
- int index, long amount)
+ int index, long amount)
{ 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,
- int index, long amount)
+ int index, long amount)
+{ return; }
+static inline void lprocfs_counter_decr(struct lprocfs_stats *stats, int index)
{ 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; }
-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,
- enum lprocfs_fields_flags field)
+ enum lprocfs_fields_flags field)
{ return 0; }
/* NB: we return !NULL to satisfy error checker */
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_CNTR_AVGMINMAX, "grant", "locks");
+ LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_LOCKS,
+ "grant");
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_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_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_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_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_CNTR_AVGMINMAX, "shrink_freed", "locks");
+ LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_LOCKS,
+ "shrink_freed");
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_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);
}
lprocfs_counter_init(ns->ns_stats, LDLM_NSS_LOCKS,
- LPROCFS_CNTR_AVGMINMAX, "locks", "locks");
+ LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_LOCKS,
+ "locks");
return err;
}
#include <obd_support.h>
#include "llite_internal.h"
+#include "lprocfs_status.h"
#include "vvp_internal.h"
static struct kobject *llite_kobj;
};
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" },
{ 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 */
{ 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" },
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,
- 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);
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);
midx == LPROC_MDT_IO_WRITE_BYTES)
lprocfs_counter_init(stats, oidx,
LPROCFS_TYPE_BYTES_FULL,
- mdt_stats[midx], "bytes");
+ mdt_stats[midx]);
else
- lprocfs_counter_init(stats, oidx,
- LPROCFS_TYPE_LATENCY,
- mdt_stats[midx], "usecs");
+ lprocfs_counter_init(stats, oidx, LPROCFS_TYPE_LATENCY,
+ mdt_stats[midx]);
}
}
mgs->mgs_proc_live = NULL;
}
- lprocfs_free_per_client_stats(obd);
+ lprocfs_free_per_client_stats(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)
{
- 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)
{
- 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
}
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)
}
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;
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) {
}
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[] = {
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);
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);
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;
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);
- 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);
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_CNTR_AVGMINMAX,
- "write_bytes", "bytes");
+ LPROCFS_CNTR_AVGMINMAX|LPROCFS_TYPE_BYTES,
+ "write_bytes");
}
ptlrpc_init_client(LDLM_CB_REQUEST_PORTAL, LDLM_CB_REPLY_PORTAL,
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_TYPE_BYTES_FULL, "write_bytes", "bytes");
+ LPROCFS_TYPE_BYTES_FULL, "write_bytes");
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_TYPE_LATENCY, "write", "usecs");
+ LPROCFS_TYPE_LATENCY, "write");
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_TYPE_LATENCY, "setattr", "usecs");
+ LPROCFS_TYPE_LATENCY, "setattr");
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_TYPE_LATENCY, "sync", "usecs");
+ LPROCFS_TYPE_LATENCY, "sync");
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_TYPE_LATENCY, "create", "usecs");
+ LPROCFS_TYPE_LATENCY, "create");
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_TYPE_LATENCY, "get_info", "usecs");
+ LPROCFS_TYPE_LATENCY, "get_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_TYPE_LATENCY, "quotactl", "usecs");
+ LPROCFS_TYPE_LATENCY, "quotactl");
lprocfs_counter_init(stats, LPROC_OFD_STATS_PREALLOC,
- LPROCFS_TYPE_LATENCY, "prealloc", "usecs");
+ LPROCFS_TYPE_LATENCY, "prealloc");
}
LPROC_SEQ_FOPS(lprocfs_nid_stats_clear);
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
- 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;
}
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_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_CNTR_AVGMINMAX,
- "cache_access", "pages");
+ LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_PAGES,
+ "cache_access");
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_CNTR_AVGMINMAX,
- "cache_miss", "pages");
+ LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_PAGES,
+ "cache_miss");
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_CNTR_AVGMINMAX,
- "zerocopy", "pages");
+ LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_PAGES,
+ "zerocopy");
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,
- 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_CNTR_AVGMINMAX,
- "thandle_open", "usec");
+ LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_USECS,
+ "thandle_open");
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;
}
{
struct dentry *svc_debugfs_entry;
struct lprocfs_stats *svc_stats;
+ enum lprocfs_counter_config config = LPROCFS_CNTR_AVGMINMAX |
+ LPROCFS_CNTR_STDDEV;
int i;
- unsigned int svc_counter_config = LPROCFS_CNTR_AVGMINMAX |
- LPROCFS_CNTR_STDDEV;
LASSERT(!*debugfs_root_ret);
LASSERT(!*stats_ret);
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,
- svc_counter_config, "req_qdepth", "reqs");
+ config | LPROCFS_TYPE_REQS, "req_qdepth");
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,
- 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++) {
- char *units;
+ enum lprocfs_counter_config extra_type = LPROCFS_TYPE_REQS;
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,
- 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;
- 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,