lprocfs_status.h

lustre 1.6.5 source code

/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
 * vim:expandtab:shiftwidth=8:tabstop=8:
 *
 *  Copyright (C) 2002 Cluster File Systems, Inc.
 *
 *   This file is part of Lustre, http://www.lustre.org.
 *
 *   Lustre is free software; you can redistribute it and/or
 *   modify it under the terms of version 2 of the GNU General Public
 *   License as published by the Free Software Foundation.
 *
 *   Lustre is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with Lustre; if not, write to the Free Software
 *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *   Top level header file for LProc SNMP
 *   Author: Hariharan Thantry [e-mail]
 */
#ifndef _LPROCFS_SNMP_H
#define _LPROCFS_SNMP_H

#include <lustre/lustre_idl.h>
#if defined(__linux__)
#include <linux/lprocfs_status.h>
#elif defined(__APPLE__)
#include <darwin/lprocfs_status.h>
#elif defined(__WINNT__)
#include <winnt/lprocfs_status.h>
#else
#error Unsupported operating system.
#endif

#undef LPROCFS
#if (defined(__KERNEL__) && defined(CONFIG_PROC_FS))
# define LPROCFS
#endif

struct lprocfs_vars {
        const char   *name;
        cfs_read_proc_t *read_fptr;
        cfs_write_proc_t *write_fptr;
        void *data;
        struct file_operations *fops;
};

struct lprocfs_static_vars {
        struct lprocfs_vars *module_vars;
        struct lprocfs_vars *obd_vars;
};

/* if we find more consumers this could be generalized */
#define OBD_HIST_MAX 32
struct obd_histogram {
        spinlock_t      oh_lock;
        unsigned long   oh_buckets[OBD_HIST_MAX];
};

enum {
        BRW_R_PAGES = 0,
        BRW_W_PAGES,
        BRW_R_RPC_HIST,
        BRW_W_RPC_HIST,
        BRW_R_IO_TIME,
        BRW_W_IO_TIME,
        BRW_R_DISCONT_PAGES,
        BRW_W_DISCONT_PAGES,
        BRW_R_DISCONT_BLOCKS,
        BRW_W_DISCONT_BLOCKS,
        BRW_R_DISK_IOSIZE,
        BRW_W_DISK_IOSIZE,
        BRW_R_DIO_FRAGS,
        BRW_W_DIO_FRAGS,
        BRW_LAST,
};

struct brw_stats {
        struct obd_histogram hist[BRW_LAST];
};


/* An lprocfs counter can be configured using the enum bit masks below.
 *
 * LPROCFS_CNTR_EXTERNALLOCK indicates that an external lock already
 * protects this counter from concurrent updates. If not specified,
 * lprocfs an internal per-counter lock variable. External locks are
 * not used to protect counter increments, but are used to protect
 * counter readout and resets.
 *
 * LPROCFS_CNTR_AVGMINMAX indicates a multi-valued counter samples,
 * (i.e. counter can be incremented by more than "1"). When specified,
 * the counter maintains min, max and sum in addition to a simple
 * invocation count. This allows averages to be be computed.
 * If not specified, the counter is an increment-by-1 counter.
 * min, max, sum, etc. are not maintained.
 *
 * LPROCFS_CNTR_STDDEV indicates that the counter should track sum of
 * squares (for multi-valued counter samples only). This allows
 * external computation of standard deviation, but involves a 64-bit
 * multiply per counter increment.
 */

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

        /* counter data type */
        LPROCFS_TYPE_REGS         = 0x0100,
        LPROCFS_TYPE_BYTES        = 0x0200,
        LPROCFS_TYPE_PAGES        = 0x0400,
        LPROCFS_TYPE_CYCLE        = 0x0800,
};

struct lprocfs_atomic {
        atomic_t               la_entry;
        atomic_t               la_exit;
};

#define LC_MIN_INIT ((~(__u64)0) >> 1)

struct lprocfs_counter {
        struct lprocfs_atomic  lc_cntl;  /* may need to move to per set */
        unsigned int           lc_config;
        __s64                  lc_count;
        __s64                  lc_sum;
        __s64                  lc_min;
        __s64                  lc_max;
        __s64                  lc_sumsquare;
        const char            *lc_name;   /* must be static */
        const char            *lc_units;  /* must be static */
};

struct lprocfs_percpu {
        struct lprocfs_counter lp_cntr[0];
};

#define LPROCFS_GET_NUM_CPU 0x0001
#define LPROCFS_GET_SMP_ID  0x0002

enum lprocfs_stats_flags {
        LPROCFS_STATS_FLAG_PERCPU   = 0x0000, /* per cpu counter */
        LPROCFS_STATS_FLAG_NOPERCPU = 0x0001, /* stats have no percpu
                                               * area and need locking */
};

enum lprocfs_fields_flags {
        LPROCFS_FIELDS_FLAGS_CONFIG = 0x0001,
        LPROCFS_FIELDS_FLAGS_SUM    = 0x0002,
        LPROCFS_FIELDS_FLAGS_MIN    = 0x0003,
        LPROCFS_FIELDS_FLAGS_MAX    = 0x0004,
        LPROCFS_FIELDS_FLAGS_AVG    = 0x0005,
        LPROCFS_FIELDS_FLAGS_SUMSQUARE = 0x0006,
        LPROCFS_FIELDS_FLAGS_COUNT  = 0x0007,
};

struct lprocfs_stats {
        unsigned int           ls_num;     /* # of counters */
        unsigned int           ls_percpu_size;
        int                    ls_flags; /* See LPROCFS_STATS_FLAG_* */
        spinlock_t             ls_lock;  /* Lock used only when there are
                                          * no percpu stats areas */
        struct lprocfs_percpu *ls_percpu[0];
};

static inline int opcode_offset(__u32 opc) {
        if (opc < OST_LAST_OPC) {
                 /* OST opcode */
                return (opc - OST_FIRST_OPC);
        } else if (opc < MDS_LAST_OPC) {
                /* MDS opcode */
                return (opc - MDS_FIRST_OPC +
                        (OST_LAST_OPC - OST_FIRST_OPC));
        } else if (opc < LDLM_LAST_OPC) {
                /* LDLM Opcode */
                return (opc - LDLM_FIRST_OPC +
                        (MDS_LAST_OPC - MDS_FIRST_OPC) +
                        (OST_LAST_OPC - OST_FIRST_OPC));
        } else if (opc < MGS_LAST_OPC) {
                /* MGS Opcode */
                return (opc - MGS_FIRST_OPC +
                        (LDLM_LAST_OPC - LDLM_FIRST_OPC) +
                        (MDS_LAST_OPC - MDS_FIRST_OPC) +
                        (OST_LAST_OPC - OST_FIRST_OPC));
        } else if (opc < OBD_LAST_OPC) {
                /* OBD Ping */
                return (opc - OBD_FIRST_OPC +
                        (MGS_LAST_OPC - MGS_FIRST_OPC) +
                        (LDLM_LAST_OPC - LDLM_FIRST_OPC) +
                        (MDS_LAST_OPC - MDS_FIRST_OPC) +
                        (OST_LAST_OPC - OST_FIRST_OPC));
        } else if (opc < LLOG_LAST_OPC) {
                /* LLOG Opcode */
                return (opc - LLOG_FIRST_OPC +
                        (OBD_LAST_OPC - OBD_FIRST_OPC) +
                        (MGS_LAST_OPC - MGS_FIRST_OPC) +
                        (LDLM_LAST_OPC - LDLM_FIRST_OPC) +
                        (MDS_LAST_OPC - MDS_FIRST_OPC) +
                        (OST_LAST_OPC - OST_FIRST_OPC));
        } else {
                /* Unknown Opcode */
                return -1;
        }
}

#define LUSTRE_MAX_OPCODES ((OST_LAST_OPC - OST_FIRST_OPC)     + \
                            (MDS_LAST_OPC - MDS_FIRST_OPC)     + \
                            (LDLM_LAST_OPC - LDLM_FIRST_OPC)   + \
                            (MGS_LAST_OPC - MGS_FIRST_OPC)     + \
                            (OBD_LAST_OPC - OBD_FIRST_OPC)     + \
                            (LLOG_LAST_OPC - LLOG_FIRST_OPC))

#define EXTRA_MAX_OPCODES ((PTLRPC_LAST_CNTR - PTLRPC_FIRST_CNTR)  + \
                           (EXTRA_LAST_OPC - EXTRA_FIRST_OPC))

enum {
        PTLRPC_REQWAIT_CNTR = 0,
        PTLRPC_REQQDEPTH_CNTR,
        PTLRPC_REQACTIVE_CNTR,
        PTLRPC_TIMEOUT,
        PTLRPC_REQBUF_AVAIL_CNTR,
        PTLRPC_LAST_CNTR
};

#define PTLRPC_FIRST_CNTR PTLRPC_REQWAIT_CNTR

enum {
        LDLM_GLIMPSE_ENQUEUE = 0,
        LDLM_PLAIN_ENQUEUE,
        LDLM_EXTENT_ENQUEUE,
        LDLM_FLOCK_ENQUEUE,
        LDLM_IBITS_ENQUEUE,
        MDS_REINT_CREATE,
        MDS_REINT_LINK,
        MDS_REINT_OPEN,
        MDS_REINT_SETATTR,
        MDS_REINT_RENAME,
        MDS_REINT_UNLINK,
        EXTRA_LAST_OPC
};

#define EXTRA_FIRST_OPC LDLM_GLIMPSE_ENQUEUE
/* class_obd.c */
extern cfs_proc_dir_entry_t *proc_lustre_root;

struct obd_device;
struct file;
struct obd_histogram;

/* Days / hours / mins / seconds format */
struct dhms {
        int d,h,m,s;
};
static inline void s2dhms(struct dhms *ts, time_t secs)
{
        ts->d = secs / 86400;
        secs = secs % 86400;
        ts->h = secs / 3600;
        secs = secs % 3600;
        ts->m = secs / 60;
        ts->s = secs % 60;
}
#define DHMS_FMT "%dd%dh%02dm%02ds"
#define DHMS_VARS(x) (x)->d, (x)->h, (x)->m, (x)->s


#ifdef LPROCFS

static inline int lprocfs_stats_lock(struct lprocfs_stats *stats, int type)
{
        int rc = 0;

        if (stats->ls_flags & LPROCFS_STATS_FLAG_NOPERCPU) {
                if (type & LPROCFS_GET_NUM_CPU)
                        rc = 1;
                if (type & LPROCFS_GET_SMP_ID)
                        rc = 0;
                spin_lock(&stats->ls_lock);
        } else {
                if (type & LPROCFS_GET_NUM_CPU)
                        rc = num_possible_cpus();
                if (type & LPROCFS_GET_SMP_ID)
                        rc = smp_processor_id();
        }
        return rc;
}

static inline void lprocfs_stats_unlock(struct lprocfs_stats *stats)
{
        if (stats->ls_flags & LPROCFS_STATS_FLAG_NOPERCPU)
                spin_unlock(&stats->ls_lock);
}

/* Two optimized LPROCFS counter increment functions are provided:
 *     lprocfs_counter_incr(cntr, value) - optimized for by-one counters
 *     lprocfs_counter_add(cntr) - use for multi-valued counters
 * Counter data layout allows config flag, counter lock and the
 * count itself to reside within a single cache line.
 */

extern void lprocfs_counter_add(struct lprocfs_stats *stats, int idx,
                                long amount);
extern void lprocfs_counter_sub(struct lprocfs_stats *stats, int idx,
                                long amount);

#define lprocfs_counter_incr(stats, idx) \
        lprocfs_counter_add(stats, idx, 1)
#define lprocfs_counter_decr(stats, idx) \
        lprocfs_counter_sub(stats, idx, 1)

extern __s64 lprocfs_read_helper(struct lprocfs_counter *lc, 
                                 enum lprocfs_fields_flags field);

static inline __u64 lprocfs_stats_collector(struct lprocfs_stats *stats, 
                                            int idx, 
                                            enum lprocfs_fields_flags field)
{
        __u64 ret = 0;
        int i;

        LASSERT(stats != NULL);
        for (i = 0; i < num_possible_cpus(); i++)
                ret += lprocfs_read_helper(&(stats->ls_percpu[i]->lp_cntr[idx]),
                                           field);
        return ret;
}

extern struct lprocfs_stats *lprocfs_alloc_stats(unsigned int num, 
                                                 enum lprocfs_stats_flags flags);
extern void lprocfs_clear_stats(struct lprocfs_stats *stats);
extern void lprocfs_free_stats(struct lprocfs_stats **stats);
extern void lprocfs_init_ops_stats(int num_private_stats, 
                                   struct lprocfs_stats *stats);
extern int lprocfs_alloc_obd_stats(struct obd_device *obddev,
                                   unsigned int num_private_stats);
extern void lprocfs_counter_init(struct lprocfs_stats *stats, int index,
                                 unsigned conf, const char *name,
                                 const char *units);
extern void lprocfs_free_obd_stats(struct obd_device *obddev);
struct obd_export;
extern int lprocfs_add_clear_entry(struct obd_device * obd,
                                   cfs_proc_dir_entry_t *entry);
extern int lprocfs_exp_setup(struct obd_export *exp,
                             lnet_nid_t peer_nid, int *newnid);
extern int lprocfs_exp_cleanup(struct obd_export *exp);
extern int lprocfs_add_simple(struct proc_dir_entry *root,
                              char *name, read_proc_t *read_proc,
                              write_proc_t *write_proc, void *data);
extern int lprocfs_register_stats(cfs_proc_dir_entry_t *root, const char *name,
                                  struct lprocfs_stats *stats);

/* lprocfs_status.c */
extern int lprocfs_add_vars(cfs_proc_dir_entry_t *root,
                            struct lprocfs_vars *var,
                            void *data);