From b515c6ec2ab84598c77c65eb78f1afd5e67b1ede Mon Sep 17 00:00:00 2001 From: Andreas Dilger Date: Tue, 15 Mar 2022 22:51:55 -0600 Subject: [PATCH] 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 Change-Id: I25f31478f238072ddbf9a3918cd43bb08c3ebbe5 Reviewed-on: https://review.whamcloud.com/46833 Tested-by: jenkins Tested-by: Maloo Reviewed-by: Jian Yu Reviewed-by: Ben Evans Reviewed-by: Oleg Drokin --- lustre/include/lprocfs_status.h | 49 ++++++++++++++---------- lustre/ldlm/ldlm_pool.c | 34 +++++++++++------ lustre/ldlm/ldlm_resource.c | 3 +- lustre/llite/lproc_llite.c | 33 ++++++---------- lustre/mdt/mdt_lproc.c | 7 ++-- lustre/mgs/lproc_mgs.c | 24 ++++++------ lustre/obdclass/class_obd.c | 4 +- lustre/obdclass/lprocfs_status.c | 82 ++++++++++++++++++++++++++++------------ lustre/obdclass/lu_object.c | 27 ++++++------- lustre/obdecho/echo.c | 8 ++-- lustre/ofd/lproc_ofd.c | 30 +++++++-------- lustre/osd-ldiskfs/osd_lproc.c | 47 +++++++++++------------ lustre/osd-zfs/osd_lproc.c | 44 ++++++++++----------- lustre/ptlrpc/lproc_ptlrpc.c | 32 +++++++--------- 14 files changed, 227 insertions(+), 197 deletions(-) diff --git a/lustre/include/lprocfs_status.h b/lustre/include/lprocfs_status.h index 64c56e2..7103ffa 100644 --- a/lustre/include/lprocfs_status.h +++ b/lustre/include/lprocfs_status.h @@ -128,18 +128,22 @@ struct obd_hist_pcpu { * 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 | @@ -149,9 +153,9 @@ enum { #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 { @@ -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, - 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; @@ -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, - 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 */ diff --git a/lustre/ldlm/ldlm_pool.c b/lustre/ldlm/ldlm_pool.c index c424aac..dac8f11 100644 --- 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, - 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); diff --git a/lustre/ldlm/ldlm_resource.c b/lustre/ldlm/ldlm_resource.c index b00579e..d73ef51 100644 --- 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_CNTR_AVGMINMAX, "locks", "locks"); + LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_LOCKS, + "locks"); return err; } diff --git a/lustre/llite/lproc_llite.c b/lustre/llite/lproc_llite.c index 50fd29d..b121b89 100644 --- a/lustre/llite/lproc_llite.c +++ b/lustre/llite/lproc_llite.c @@ -39,6 +39,7 @@ #include #include "llite_internal.h" +#include "lprocfs_status.h" #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 { - __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" }, @@ -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_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 */ @@ -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_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" }, @@ -1929,20 +1929,11 @@ int ll_debugfs_register_super(struct super_block *sb, const char *name) 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); @@ -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++) - 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); diff --git a/lustre/mdt/mdt_lproc.c b/lustre/mdt/mdt_lproc.c index 6dfc117..a43fe90 100644 --- 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, - 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]); } } diff --git a/lustre/mgs/lproc_mgs.c b/lustre/mgs/lproc_mgs.c index 4cb65fb..7e8c3f1 100644 --- 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; } - 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 diff --git a/lustre/obdclass/class_obd.c b/lustre/obdclass/class_obd.c index 135d188..5b7efd2 100644 --- 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_CNTR_AVGMINMAX, - "memused", "bytes"); + LPROCFS_CNTR_AVGMINMAX | LPROCFS_TYPE_BYTES, + "memused"); #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 --- 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); -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; @@ -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); - 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) { @@ -1496,6 +1522,15 @@ void lprocfs_counter_init(struct lprocfs_stats *stats, int index, } 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[] = { @@ -1541,7 +1576,8 @@ int lprocfs_alloc_md_stats(struct obd_device *obd, 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); @@ -1573,24 +1609,18 @@ EXPORT_SYMBOL(lprocfs_free_md_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); @@ -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 - 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; diff --git a/lustre/obdclass/lu_object.c b/lustre/obdclass/lu_object.c index 3a07035..773e7f2 100644 --- 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; } - 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); diff --git a/lustre/obdecho/echo.c b/lustre/obdecho/echo.c index b65d01a..5de02d8 100644 --- 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, - 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, diff --git a/lustre/ofd/lproc_ofd.c b/lustre/ofd/lproc_ofd.c index db81351..f6cec470 100644 --- 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, - 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); diff --git a/lustre/osd-ldiskfs/osd_lproc.c b/lustre/osd-ldiskfs/osd_lproc.c index b93881b..6f67f0f 100644 --- 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) { - 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; } diff --git a/lustre/osd-zfs/osd_lproc.c b/lustre/osd-zfs/osd_lproc.c index c199717..01f792d 100644 --- 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, - 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; } diff --git a/lustre/ptlrpc/lproc_ptlrpc.c b/lustre/ptlrpc/lproc_ptlrpc.c index bfb48d6..7ef662e 100644 --- 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; + 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); @@ -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_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, -- 1.8.3.1