X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Finclude%2Flprocfs_status.h;h=beb0413a64793a223056bd468dc2eb439e6083a8;hp=e7e3e8b95f03d57f1539cbbd591dead56f6cf186;hb=f9920b4924edce1bd341622eee4281fdcd41845a;hpb=c25118c5eac2946f44f69eac394185c7ca035545 diff --git a/lustre/include/lprocfs_status.h b/lustre/include/lprocfs_status.h index e7e3e8b..beb0413 100644 --- a/lustre/include/lprocfs_status.h +++ b/lustre/include/lprocfs_status.h @@ -1,6 +1,4 @@ -/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- - * vim:expandtab:shiftwidth=8:tabstop=8: - * +/* * GPL HEADER START * * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. @@ -26,8 +24,10 @@ * GPL HEADER END */ /* - * Copyright 2008 Sun Microsystems, Inc. All rights reserved + * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. + * + * Copyright (c) 2011, 2014, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -43,43 +43,43 @@ #define _LPROCFS_SNMP_H #include -#if defined(__linux__) -#include -#elif defined(__APPLE__) -#include -#elif defined(__WINNT__) -#include -#else -#error Unsupported operating system. -#endif - -#undef LPROCFS -#if (defined(__KERNEL__) && defined(CONFIG_PROC_FS)) -# define LPROCFS -#endif +#include +#ifndef HAVE_ONLY_PROCFS_SEQ struct lprocfs_vars { - const char *name; - cfs_read_proc_t *read_fptr; - cfs_write_proc_t *write_fptr; - void *data; - struct file_operations *fops; - /** - * /proc file mode. - */ - mode_t proc_mode; + const char *name; + read_proc_t *read_fptr; + write_proc_t *write_fptr; + void *data; + const struct file_operations *fops; + /** + * /proc file mode. + */ + mode_t proc_mode; }; struct lprocfs_static_vars { - struct lprocfs_vars *module_vars; - struct lprocfs_vars *obd_vars; + struct lprocfs_vars *module_vars; + struct lprocfs_vars *obd_vars; +}; + +#endif + +struct lprocfs_seq_vars { + const char *name; + const struct file_operations *fops; + void *data; + /** + * /proc file mode. + */ + mode_t proc_mode; }; /* 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]; + spinlock_t oh_lock; + unsigned long oh_buckets[OBD_HIST_MAX]; }; enum { @@ -104,6 +104,16 @@ struct brw_stats { struct obd_histogram hist[BRW_LAST]; }; +enum { + RENAME_SAMEDIR_SIZE = 0, + RENAME_CROSSDIR_SRC_SIZE, + RENAME_CROSSDIR_TGT_SIZE, + RENAME_LAST, +}; + +struct rename_stats { + struct obd_histogram hist[RENAME_LAST]; +}; /* An lprocfs counter can be configured using the enum bit masks below. * @@ -138,58 +148,74 @@ enum { 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_header { + unsigned int lc_config; + const char *lc_name; /* must be static */ + const char *lc_units; /* must be static */ +}; + 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 */ + __s64 lc_count; + __s64 lc_min; + __s64 lc_max; + __s64 lc_sumsquare; + /* + * Every counter has lc_array_sum[0], while lc_array_sum[1] is only + * for irq context counter, i.e. stats with + * LPROCFS_STATS_FLAG_IRQ_SAFE flag, its counter need + * lc_array_sum[1] + */ + __s64 lc_array_sum[1]; }; +#define lc_sum lc_array_sum[0] +#define lc_sum_irq lc_array_sum[1] struct lprocfs_percpu { - struct lprocfs_counter lp_cntr[0]; + struct lprocfs_counter lp_cntr[0]; }; -#define LPROCFS_GET_NUM_CPU 0x0001 -#define LPROCFS_GET_SMP_ID 0x0002 +enum lprocfs_stats_lock_ops { + LPROCFS_GET_NUM_CPU = 0x0001, /* number allocated per-CPU stats */ + LPROCFS_GET_SMP_ID = 0x0002, /* current stat to be updated */ +}; enum lprocfs_stats_flags { - LPROCFS_STATS_FLAG_NONE = 0x0000, /* per cpu counter */ - LPROCFS_STATS_FLAG_NOPERCPU = 0x0001, /* stats have no percpu - * area and need locking */ - LPROCFS_STATS_GET_SMP_ID = 0x0002, /* just record locking with - * LPROCFS_GET_SMP_ID flag */ + LPROCFS_STATS_FLAG_NONE = 0x0000, /* per cpu counter */ + LPROCFS_STATS_FLAG_NOPERCPU = 0x0001, /* stats have no percpu + * area and need locking */ + LPROCFS_STATS_FLAG_IRQ_SAFE = 0x0002, /* alloc need irq safe */ }; 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, + 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 */ - 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]; + /* # of counters */ + unsigned short ls_num; + /* 1 + the biggest cpu # whose ls_percpu slot has been allocated */ + unsigned short ls_biggest_alloc_num; + enum lprocfs_stats_flags ls_flags; + /* Lock used when there are no percpu stats areas; For percpu stats, + * it is used to protect ls_biggest_alloc_num change */ + spinlock_t ls_lock; + + /* has ls_num of counter headers */ + struct lprocfs_counter_header *ls_cnt_header; + struct lprocfs_percpu *ls_percpu[0]; }; +#define OPC_RANGE(seg) (seg ## _LAST_OPC - seg ## _FIRST_OPC) + +/* Pack all opcodes down into a single monotonically increasing index */ static inline int opcode_offset(__u32 opc) { if (opc < OST_LAST_OPC) { /* OST opcode */ @@ -197,95 +223,124 @@ static inline int opcode_offset(__u32 opc) { } else if (opc < MDS_LAST_OPC) { /* MDS opcode */ return (opc - MDS_FIRST_OPC + - (OST_LAST_OPC - OST_FIRST_OPC)); + OPC_RANGE(OST)); } 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)); + OPC_RANGE(MDS) + + OPC_RANGE(OST)); } 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)); + OPC_RANGE(LDLM) + + OPC_RANGE(MDS) + + OPC_RANGE(OST)); } 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)); + OPC_RANGE(MGS) + + OPC_RANGE(LDLM) + + OPC_RANGE(MDS) + + OPC_RANGE(OST)); } 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)); + OPC_RANGE(OBD) + + OPC_RANGE(MGS) + + OPC_RANGE(LDLM) + + OPC_RANGE(MDS) + + OPC_RANGE(OST)); } else if (opc < QUOTA_LAST_OPC) { /* LQUOTA Opcode */ return (opc - QUOTA_FIRST_OPC + - (LLOG_LAST_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)); + OPC_RANGE(LLOG) + + OPC_RANGE(OBD) + + OPC_RANGE(MGS) + + OPC_RANGE(LDLM) + + OPC_RANGE(MDS) + + OPC_RANGE(OST)); } else if (opc < SEQ_LAST_OPC) { /* SEQ opcode */ return (opc - SEQ_FIRST_OPC + - (QUOTA_LAST_OPC- QUOTA_FIRST_OPC) + - (LLOG_LAST_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)); + OPC_RANGE(QUOTA) + + OPC_RANGE(LLOG) + + OPC_RANGE(OBD) + + OPC_RANGE(MGS) + + OPC_RANGE(LDLM) + + OPC_RANGE(MDS) + + OPC_RANGE(OST)); } else if (opc < SEC_LAST_OPC) { /* SEC opcode */ return (opc - SEC_FIRST_OPC + - (SEQ_LAST_OPC - SEQ_FIRST_OPC) + - (QUOTA_LAST_OPC- QUOTA_FIRST_OPC) + - (LLOG_LAST_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)); + OPC_RANGE(SEQ) + + OPC_RANGE(QUOTA) + + OPC_RANGE(LLOG) + + OPC_RANGE(OBD) + + OPC_RANGE(MGS) + + OPC_RANGE(LDLM) + + OPC_RANGE(MDS) + + OPC_RANGE(OST)); } else if (opc < FLD_LAST_OPC) { /* FLD opcode */ return (opc - FLD_FIRST_OPC + - (SEC_LAST_OPC - SEC_FIRST_OPC) + - (SEQ_LAST_OPC - SEQ_FIRST_OPC) + - (QUOTA_LAST_OPC- QUOTA_FIRST_OPC) + - (LLOG_LAST_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; - } + OPC_RANGE(SEC) + + OPC_RANGE(SEQ) + + OPC_RANGE(QUOTA) + + OPC_RANGE(LLOG) + + OPC_RANGE(OBD) + + OPC_RANGE(MGS) + + OPC_RANGE(LDLM) + + OPC_RANGE(MDS) + + OPC_RANGE(OST)); + } else if (opc < OUT_UPDATE_LAST_OPC) { + /* update opcode */ + return (opc - OUT_UPDATE_FIRST_OPC + + OPC_RANGE(FLD) + + OPC_RANGE(SEC) + + OPC_RANGE(SEQ) + + OPC_RANGE(QUOTA) + + OPC_RANGE(LLOG) + + OPC_RANGE(OBD) + + OPC_RANGE(MGS) + + OPC_RANGE(LDLM) + + OPC_RANGE(MDS) + + OPC_RANGE(OST)); + } else if (opc < LFSCK_LAST_OPC) { + /* LFSCK opcode */ + return (opc - LFSCK_FIRST_OPC + + OPC_RANGE(OUT_UPDATE) + + OPC_RANGE(FLD) + + OPC_RANGE(SEC) + + OPC_RANGE(SEQ) + + OPC_RANGE(QUOTA) + + OPC_RANGE(LLOG) + + OPC_RANGE(OBD) + + OPC_RANGE(MGS) + + OPC_RANGE(LDLM) + + OPC_RANGE(MDS) + + OPC_RANGE(OST)); + } 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) + \ - (QUOTA_LAST_OPC - QUOTA_FIRST_OPC) + \ - (SEQ_LAST_OPC - SEQ_FIRST_OPC) + \ - (SEC_LAST_OPC - SEC_FIRST_OPC) + \ - (FLD_LAST_OPC - FLD_FIRST_OPC)) +#define LUSTRE_MAX_OPCODES (OPC_RANGE(OST) + \ + OPC_RANGE(MDS) + \ + OPC_RANGE(LDLM) + \ + OPC_RANGE(MGS) + \ + OPC_RANGE(OBD) + \ + OPC_RANGE(LLOG) + \ + OPC_RANGE(SEC) + \ + OPC_RANGE(SEQ) + \ + OPC_RANGE(SEC) + \ + OPC_RANGE(FLD) + \ + OPC_RANGE(OUT_UPDATE) + \ + OPC_RANGE(LFSCK)) #define EXTRA_MAX_OPCODES ((PTLRPC_LAST_CNTR - PTLRPC_FIRST_CNTR) + \ - (EXTRA_LAST_OPC - EXTRA_FIRST_OPC)) + OPC_RANGE(EXTRA)) enum { PTLRPC_REQWAIT_CNTR = 0, @@ -298,7 +353,7 @@ enum { #define PTLRPC_FIRST_CNTR PTLRPC_REQWAIT_CNTR -enum { +enum lprocfs_extra_opc { LDLM_GLIMPSE_ENQUEUE = 0, LDLM_PLAIN_ENQUEUE, LDLM_EXTENT_ENQUEUE, @@ -318,10 +373,9 @@ enum { #define EXTRA_FIRST_OPC LDLM_GLIMPSE_ENQUEUE /* class_obd.c */ -extern cfs_proc_dir_entry_t *proc_lustre_root; +extern struct proc_dir_entry *proc_lustre_root; struct obd_device; -struct file; struct obd_histogram; /* Days / hours / mins / seconds format */ @@ -340,36 +394,142 @@ static inline void s2dhms(struct dhms *ts, time_t secs) #define DHMS_FMT "%dd%dh%02dm%02ds" #define DHMS_VARS(x) (x)->d, (x)->h, (x)->m, (x)->s +#define JOBSTATS_JOBID_VAR_MAX_LEN 20 +#define JOBSTATS_DISABLE "disable" +#define JOBSTATS_PROCNAME_UID "procname_uid" + +typedef void (*cntr_init_callback)(struct lprocfs_stats *stats); + +struct obd_job_stats { + cfs_hash_t *ojs_hash; + struct list_head ojs_list; + rwlock_t ojs_lock; /* protect the obj_list */ + cntr_init_callback ojs_cntr_init_fn; + int ojs_cntr_num; + int ojs_cleanup_interval; + time_t ojs_last_cleanup; +}; #ifdef LPROCFS -static inline int lprocfs_stats_lock(struct lprocfs_stats *stats, int type) +extern int lprocfs_stats_alloc_one(struct lprocfs_stats *stats, + unsigned int cpuid); + +/** + * Lock statistics structure for access, possibly only on this CPU. + * + * The statistics struct may be allocated with per-CPU structures for + * efficient concurrent update (usually only on server-wide stats), or + * as a single global struct (e.g. for per-client or per-job statistics), + * so the required locking depends on the type of structure allocated. + * + * For per-CPU statistics, pin the thread to the current cpuid so that + * will only access the statistics for that CPU. If the stats structure + * for the current CPU has not been allocated (or previously freed), + * allocate it now. The per-CPU statistics do not need locking since + * the thread is pinned to the CPU during update. + * + * For global statistics, lock the stats structure to prevent concurrent update. + * + * \param[in] stats statistics structure to lock + * \param[in] opc type of operation: + * LPROCFS_GET_SMP_ID: "lock" and return current CPU index + * for incrementing statistics for that CPU + * LPROCFS_GET_NUM_CPU: "lock" and return number of used + * CPU indices to iterate over all indices + * \param[out] flags CPU interrupt saved state for IRQ-safe locking + * + * \retval cpuid of current thread or number of allocated structs + * \retval negative on error (only for opc LPROCFS_GET_SMP_ID + per-CPU stats) + */ +static inline int lprocfs_stats_lock(struct lprocfs_stats *stats, + enum lprocfs_stats_lock_ops opc, + unsigned long *flags) { - 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) { - stats->ls_flags &= LPROCFS_STATS_GET_SMP_ID; - rc = cfs_get_cpu(); + if (stats->ls_flags & LPROCFS_STATS_FLAG_NOPERCPU) { + if (stats->ls_flags & LPROCFS_STATS_FLAG_IRQ_SAFE) + spin_lock_irqsave(&stats->ls_lock, *flags); + else + spin_lock(&stats->ls_lock); + return opc == LPROCFS_GET_NUM_CPU ? 1 : 0; + } + + switch (opc) { + case LPROCFS_GET_SMP_ID: { + unsigned int cpuid = get_cpu(); + + if (unlikely(stats->ls_percpu[cpuid] == NULL)) { + int rc = lprocfs_stats_alloc_one(stats, cpuid); + if (rc < 0) { + put_cpu(); + return rc; + } } - } - return rc; + return cpuid; + } + case LPROCFS_GET_NUM_CPU: + return stats->ls_biggest_alloc_num; + default: + LBUG(); + } +} + +/** + * Unlock statistics structure after access. + * + * Unlock the lock acquired via lprocfs_stats_lock() for global statistics, + * or unpin this thread from the current cpuid for per-CPU statistics. + * + * This function must be called using the same arguments as used when calling + * lprocfs_stats_lock() so that the correct operation can be performed. + * + * \param[in] stats statistics structure to unlock + * \param[in] opc type of operation (current cpuid or number of structs) + * \param[in] flags CPU interrupt saved state for IRQ-safe locking + */ +static inline void lprocfs_stats_unlock(struct lprocfs_stats *stats, + enum lprocfs_stats_lock_ops opc, + unsigned long *flags) +{ + if (stats->ls_flags & LPROCFS_STATS_FLAG_NOPERCPU) { + if (stats->ls_flags & LPROCFS_STATS_FLAG_IRQ_SAFE) + spin_unlock_irqrestore(&stats->ls_lock, *flags); + else + spin_unlock(&stats->ls_lock); + } else if (opc == LPROCFS_GET_SMP_ID) { + put_cpu(); + } } -static inline void lprocfs_stats_unlock(struct lprocfs_stats *stats) +static inline unsigned int +lprocfs_stats_counter_size(struct lprocfs_stats *stats) { - if (stats->ls_flags & LPROCFS_STATS_FLAG_NOPERCPU) - spin_unlock(&stats->ls_lock); - else if (stats->ls_flags & LPROCFS_STATS_GET_SMP_ID) - cfs_put_cpu(); + unsigned int percpusize; + + percpusize = offsetof(struct lprocfs_percpu, lp_cntr[stats->ls_num]); + + /* irq safe stats need lc_array_sum[1] */ + if ((stats->ls_flags & LPROCFS_STATS_FLAG_IRQ_SAFE) != 0) + percpusize += stats->ls_num * sizeof(__s64); + + if ((stats->ls_flags & LPROCFS_STATS_FLAG_NOPERCPU) == 0) + percpusize = L1_CACHE_ALIGN(percpusize); + + return percpusize; +} + +static inline struct lprocfs_counter * +lprocfs_stats_counter_get(struct lprocfs_stats *stats, unsigned int cpuid, + int index) +{ + struct lprocfs_counter *cntr; + + cntr = &stats->ls_percpu[cpuid]->lp_cntr[index]; + + if ((stats->ls_flags & LPROCFS_STATS_FLAG_IRQ_SAFE) != 0) + cntr = (void *)cntr + index * sizeof(__s64); + + return cntr; } /* Two optimized LPROCFS counter increment functions are provided: @@ -390,27 +550,41 @@ extern void lprocfs_counter_sub(struct lprocfs_stats *stats, int idx, lprocfs_counter_sub(stats, idx, 1) extern __s64 lprocfs_read_helper(struct lprocfs_counter *lc, - enum lprocfs_fields_flags field); + struct lprocfs_counter_header *header, + enum lprocfs_stats_flags flags, + 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; + unsigned int i; + unsigned int num_cpu; + unsigned long flags = 0; + __u64 ret = 0; + + LASSERT(stats != NULL); + + num_cpu = lprocfs_stats_lock(stats, LPROCFS_GET_NUM_CPU, &flags); + for (i = 0; i < num_cpu; i++) { + if (stats->ls_percpu[i] == NULL) + continue; + ret += lprocfs_read_helper( + lprocfs_stats_counter_get(stats, i, idx), + &stats->ls_cnt_header[idx], stats->ls_flags, + field); + } + lprocfs_stats_unlock(stats, LPROCFS_GET_NUM_CPU, &flags); + return ret; } -extern struct lprocfs_stats *lprocfs_alloc_stats(unsigned int num, - enum lprocfs_stats_flags flags); +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 void lprocfs_init_mps_stats(int num_private_stats, + struct lprocfs_stats *stats); extern void lprocfs_init_ldlm_stats(struct lprocfs_stats *ldlm_stats); extern int lprocfs_alloc_obd_stats(struct obd_device *obddev, unsigned int num_private_stats); @@ -420,239 +594,308 @@ 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); +extern void lprocfs_free_md_stats(struct obd_device *obddev); struct obd_export; struct nid_stat; 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); + struct proc_dir_entry *entry); +#ifdef HAVE_SERVER_SUPPORT +extern int lprocfs_exp_setup(struct obd_export *exp, lnet_nid_t *peer_nid); extern int lprocfs_exp_cleanup(struct obd_export *exp); -extern cfs_proc_dir_entry_t *lprocfs_add_simple(struct proc_dir_entry *root, - char *name, - cfs_read_proc_t *read_proc, - cfs_write_proc_t *write_proc, - void *data, - struct file_operations *fops); -extern struct proc_dir_entry *lprocfs_add_symlink(const char *name, - struct proc_dir_entry *parent, const char *dest); +#else +static inline int lprocfs_exp_cleanup(struct obd_export *exp) +{ return 0; } +#endif +extern struct proc_dir_entry * +lprocfs_add_simple(struct proc_dir_entry *root, char *name, + void *data, const struct file_operations *fops); +extern struct proc_dir_entry * +lprocfs_add_symlink(const char *name, struct proc_dir_entry *parent, + const char *format, ...); extern void lprocfs_free_per_client_stats(struct obd_device *obd); -extern int lprocfs_nid_stats_clear_write(struct file *file, const char *buffer, - unsigned long count, void *data); -extern int lprocfs_nid_stats_clear_read(char *page, char **start, off_t off, - int count, int *eof, void *data); - -extern int lprocfs_register_stats(cfs_proc_dir_entry_t *root, const char *name, +#ifdef HAVE_SERVER_SUPPORT +extern ssize_t +lprocfs_nid_stats_clear_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off); +extern int lprocfs_nid_stats_clear_seq_show(struct seq_file *file, void *data); +#endif +extern int lprocfs_register_stats(struct proc_dir_entry *root, const char *name, struct lprocfs_stats *stats); /* lprocfs_status.c */ -extern int lprocfs_add_vars(cfs_proc_dir_entry_t *root, +#ifndef HAVE_ONLY_PROCFS_SEQ +extern int lprocfs_add_vars(struct proc_dir_entry *root, struct lprocfs_vars *var, void *data); -extern cfs_proc_dir_entry_t *lprocfs_register(const char *name, - cfs_proc_dir_entry_t *parent, - struct lprocfs_vars *list, - void *data); - -extern void lprocfs_remove(cfs_proc_dir_entry_t **root); +extern struct proc_dir_entry *lprocfs_register(const char *name, + struct proc_dir_entry *parent, + struct lprocfs_vars *list, + void *data); +#endif +extern int lprocfs_seq_add_vars(struct proc_dir_entry *root, + struct lprocfs_seq_vars *var, + void *data); + +extern struct proc_dir_entry * +lprocfs_seq_register(const char *name, struct proc_dir_entry *parent, + struct lprocfs_seq_vars *list, void *data); +extern void lprocfs_remove(struct proc_dir_entry **root); extern void lprocfs_remove_proc_entry(const char *name, struct proc_dir_entry *parent); +#ifndef HAVE_ONLY_PROCFS_SEQ +extern void lprocfs_try_remove_proc_entry(const char *name, + struct proc_dir_entry *parent); -extern cfs_proc_dir_entry_t *lprocfs_srch(cfs_proc_dir_entry_t *root, - const char *name); - -extern int lprocfs_obd_setup(struct obd_device *obd, struct lprocfs_vars *list); +extern struct proc_dir_entry *lprocfs_srch(struct proc_dir_entry *root, + const char *name); +#endif +extern int lprocfs_obd_setup(struct obd_device *dev); extern int lprocfs_obd_cleanup(struct obd_device *obd); -extern void lprocfs_free_per_client_stats(struct obd_device *obd); -extern struct file_operations lprocfs_evict_client_fops; - -extern int lprocfs_seq_create(cfs_proc_dir_entry_t *parent, char *name, - mode_t mode, struct file_operations *seq_fops, - void *data); -extern int lprocfs_obd_seq_create(struct obd_device *dev, char *name, - mode_t mode, struct file_operations *seq_fops, - void *data); +#ifdef HAVE_SERVER_SUPPORT +extern const struct file_operations lprocfs_evict_client_fops; +#endif +extern int lprocfs_seq_create(struct proc_dir_entry *parent, const char *name, + mode_t mode, + const struct file_operations *seq_fops, + void *data); +extern int lprocfs_obd_seq_create(struct obd_device *dev, const char *name, + mode_t mode, + const struct file_operations *seq_fops, + void *data); /* Generic callbacks */ - -extern int lprocfs_rd_u64(char *page, char **start, off_t off, - int count, int *eof, void *data); -extern int lprocfs_rd_atomic(char *page, char **start, off_t off, - int count, int *eof, void *data); -extern int lprocfs_wr_atomic(struct file *file, const char *buffer, - unsigned long count, void *data); -extern int lprocfs_rd_uint(char *page, char **start, off_t off, - int count, int *eof, void *data); -extern int lprocfs_wr_uint(struct file *file, const char *buffer, - unsigned long count, void *data); -extern int lprocfs_rd_uuid(char *page, char **start, off_t off, - int count, int *eof, void *data); -extern int lprocfs_rd_name(char *page, char **start, off_t off, - int count, int *eof, void *data); -extern int lprocfs_rd_fstype(char *page, char **start, off_t off, - int count, int *eof, void *data); -extern int lprocfs_rd_server_uuid(char *page, char **start, off_t off, - int count, int *eof, void *data); -extern int lprocfs_rd_conn_uuid(char *page, char **start, off_t off, - int count, int *eof, void *data); -extern int lprocfs_rd_import(char *page, char **start, off_t off, int count, - int *eof, void *data); -extern int lprocfs_rd_connect_flags(char *page, char **start, off_t off, - int count, int *eof, void *data); -extern int lprocfs_rd_num_exports(char *page, char **start, off_t off, - int count, int *eof, void *data); -extern int lprocfs_rd_numrefs(char *page, char **start, off_t off, - int count, int *eof, void *data); +extern int lprocfs_u64_seq_show(struct seq_file *m, void *data); +extern int lprocfs_atomic_seq_show(struct seq_file *m, void *data); +extern ssize_t lprocfs_atomic_seq_write(struct file *file, + const char __user *buffer, + size_t count, loff_t *off); +extern int lprocfs_uint_seq_show(struct seq_file *m, void *data); +extern ssize_t lprocfs_uint_seq_write(struct file *file, + const char __user *buffer, + size_t count, loff_t *off); +extern int lprocfs_wr_uint(struct file *file, const char __user *buffer, + unsigned long count, void *data); +extern int lprocfs_uuid_seq_show(struct seq_file *m, void *data); +extern int lprocfs_name_seq_show(struct seq_file *m, void *data); +extern int lprocfs_server_uuid_seq_show(struct seq_file *m, void *data); +extern int lprocfs_conn_uuid_seq_show(struct seq_file *m, void *data); +extern int lprocfs_import_seq_show(struct seq_file *m, void *data); +extern int lprocfs_state_seq_show(struct seq_file *m, void *data); +extern int lprocfs_connect_flags_seq_show(struct seq_file *m, void *data); +#ifdef HAVE_SERVER_SUPPORT +extern int lprocfs_num_exports_seq_show(struct seq_file *m, void *data); +#endif struct adaptive_timeout; -extern int lprocfs_at_hist_helper(char *page, int count, int rc, - struct adaptive_timeout *at); -extern int lprocfs_rd_timeouts(char *page, char **start, off_t off, - int count, int *eof, void *data); -extern int lprocfs_wr_timeouts(struct file *file, const char *buffer, - unsigned long count, void *data); -extern int lprocfs_wr_evict_client(struct file *file, const char *buffer, - unsigned long count, void *data); -extern int lprocfs_wr_ping(struct file *file, const char *buffer, - unsigned long count, void *data); +extern int lprocfs_seq_at_hist_helper(struct seq_file *m, + struct adaptive_timeout *at); +extern int lprocfs_timeouts_seq_show(struct seq_file *m, void *data); +extern ssize_t +lprocfs_timeouts_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off); +#ifdef HAVE_SERVER_SUPPORT +#ifndef HAVE_ONLY_PROCFS_SEQ +extern ssize_t lprocfs_fops_read(struct file *f, char __user *buf, + size_t size, loff_t *ppos); +extern ssize_t lprocfs_fops_write(struct file *f, const char __user *buf, + size_t size, loff_t *ppos); +#endif +extern ssize_t +lprocfs_evict_client_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off); +#endif +extern ssize_t +lprocfs_ping_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off); +extern ssize_t +lprocfs_import_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off); +extern int lprocfs_pinger_recov_seq_show(struct seq_file *m, void *data); +extern ssize_t +lprocfs_pinger_recov_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off); /* Statfs helpers */ -extern int lprocfs_rd_blksize(char *page, char **start, off_t off, - int count, int *eof, void *data); -extern int lprocfs_rd_kbytestotal(char *page, char **start, off_t off, - int count, int *eof, void *data); -extern int lprocfs_rd_kbytesfree(char *page, char **start, off_t off, - int count, int *eof, void *data); -extern int lprocfs_rd_kbytesavail(char *page, char **start, off_t off, - int count, int *eof, void *data); -extern int lprocfs_rd_filestotal(char *page, char **start, off_t off, - int count, int *eof, void *data); -extern int lprocfs_rd_filesfree(char *page, char **start, off_t off, - int count, int *eof, void *data); -extern int lprocfs_rd_filegroups(char *page, char **start, off_t off, - int count, int *eof, void *data); - -extern int lprocfs_write_helper(const char *buffer, unsigned long count, +extern int lprocfs_blksize_seq_show(struct seq_file *m, void *data); +extern int lprocfs_kbytestotal_seq_show(struct seq_file *m, void *data); +extern int lprocfs_kbytesfree_seq_show(struct seq_file *m, void *data); +extern int lprocfs_kbytesavail_seq_show(struct seq_file *m, void *data); +extern int lprocfs_filestotal_seq_show(struct seq_file *m, void *data); +extern int lprocfs_filesfree_seq_show(struct seq_file *m, void *data); + +extern int lprocfs_write_helper(const char __user *buffer, unsigned long count, int *val); -extern int lprocfs_write_frac_helper(const char *buffer, unsigned long count, - int *val, int mult); +extern int lprocfs_write_frac_helper(const char __user *buffer, + unsigned long count, + int *val, int mult); +extern int lprocfs_seq_read_frac_helper(struct seq_file *m, long val, int mult); extern int lprocfs_read_frac_helper(char *buffer, unsigned long count, long val, int mult); -extern int lprocfs_write_u64_helper(const char *buffer, unsigned long count, - __u64 *val); -extern int lprocfs_write_frac_u64_helper(const char *buffer, unsigned long count, +extern int lprocfs_write_u64_helper(const char __user *buffer, + unsigned long count, __u64 *val); +extern int lprocfs_write_frac_u64_helper(const char __user *buffer, + unsigned long count, __u64 *val, int mult); +char *lprocfs_find_named_value(const char *buffer, const char *name, + size_t *count); void lprocfs_oh_tally(struct obd_histogram *oh, unsigned int value); void lprocfs_oh_tally_log2(struct obd_histogram *oh, unsigned int value); void lprocfs_oh_clear(struct obd_histogram *oh); unsigned long lprocfs_oh_sum(struct obd_histogram *oh); -/* lprocfs_status.c: counter read/write functions */ -extern int lprocfs_counter_read(char *page, char **start, off_t off, - int count, int *eof, void *data); -extern int lprocfs_counter_write(struct file *file, const char *buffer, - unsigned long count, void *data); +void lprocfs_stats_collect(struct lprocfs_stats *stats, int idx, + struct lprocfs_counter *cnt); +#ifdef HAVE_SERVER_SUPPORT /* lprocfs_status.c: recovery status */ -int lprocfs_obd_rd_recovery_status(char *page, char **start, off_t off, - int count, int *eof, void *data); +int lprocfs_recovery_status_seq_show(struct seq_file *m, void *data); -/* lprocfs_statuc.c: hash statistics */ -int lprocfs_obd_rd_hash(char *page, char **start, off_t off, - int count, int *eof, void *data); +/* lprocfs_status.c: hash statistics */ +int lprocfs_hash_seq_show(struct seq_file *m, void *data); +/* lprocfs_status.c: IR factor */ +int lprocfs_ir_factor_seq_show(struct seq_file *m, void *data); +ssize_t +lprocfs_ir_factor_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off); +#endif +extern int lprocfs_single_release(struct inode *, struct file *); extern int lprocfs_seq_release(struct inode *, struct file *); -/* in lprocfs_stat.c, to protect the private data for proc entries */ -extern struct rw_semaphore _lprocfs_lock; -#define LPROCFS_ENTRY() do { \ - down_read(&_lprocfs_lock); \ -} while(0) -#define LPROCFS_EXIT() do { \ - up_read(&_lprocfs_lock); \ -} while(0) -#define LPROCFS_ENTRY_AND_CHECK(dp) do { \ - typecheck(struct proc_dir_entry *, dp); \ - LPROCFS_ENTRY(); \ - if ((dp)->deleted) { \ - LPROCFS_EXIT(); \ - return -ENODEV; \ - } \ -} while(0) -#define LPROCFS_WRITE_ENTRY() do { \ - down_write(&_lprocfs_lock); \ -} while(0) -#define LPROCFS_WRITE_EXIT() do { \ - up_write(&_lprocfs_lock); \ -} while(0) - /* You must use these macros when you want to refer to * the import in a client obd_device for a lprocfs entry */ #define LPROCFS_CLIMP_CHECK(obd) do { \ typecheck(struct obd_device *, obd); \ - down_read(&(obd)->u.cli.cl_sem); \ + down_read(&(obd)->u.cli.cl_sem); \ if ((obd)->u.cli.cl_import == NULL) { \ - up_read(&(obd)->u.cli.cl_sem); \ + up_read(&(obd)->u.cli.cl_sem); \ return -ENODEV; \ } \ } while(0) #define LPROCFS_CLIMP_EXIT(obd) \ - up_read(&(obd)->u.cli.cl_sem); - + up_read(&(obd)->u.cli.cl_sem); /* write the name##_seq_show function, call LPROC_SEQ_FOPS_RO for read-only proc entries; otherwise, you will define name##_seq_write function also for a read-write proc entry, and then call LPROC_SEQ_SEQ instead. Finally, call lprocfs_obd_seq_create(obd, filename, 0444, &name#_fops, data); */ -#define __LPROC_SEQ_FOPS(name, custom_seq_write) \ -static int name##_seq_open(struct inode *inode, struct file *file) { \ - struct proc_dir_entry *dp = PDE(inode); \ - int rc; \ - LPROCFS_ENTRY_AND_CHECK(dp); \ - rc = single_open(file, name##_seq_show, dp->data); \ - if (rc) { \ - LPROCFS_EXIT(); \ - return rc; \ - } \ - return 0; \ -} \ -struct file_operations name##_fops = { \ - .owner = THIS_MODULE, \ - .open = name##_seq_open, \ - .read = seq_read, \ - .write = custom_seq_write, \ - .llseek = seq_lseek, \ - .release = lprocfs_seq_release, \ +#define __LPROC_SEQ_FOPS(name, custom_seq_write) \ +static int name##_single_open(struct inode *inode, struct file *file) \ +{ \ + int rc; \ + \ + rc = LPROCFS_ENTRY_CHECK(inode); \ + if (rc < 0) \ + return rc; \ + \ + return single_open(file, name##_seq_show, PDE_DATA(inode)); \ +} \ +static const struct file_operations name##_fops = { \ + .owner = THIS_MODULE, \ + .open = name##_single_open, \ + .read = seq_read, \ + .write = custom_seq_write, \ + .llseek = seq_lseek, \ + .release = lprocfs_single_release, \ } -#define LPROC_SEQ_FOPS_RO(name) __LPROC_SEQ_FOPS(name, NULL) -#define LPROC_SEQ_FOPS(name) __LPROC_SEQ_FOPS(name, name##_seq_write) +#define LPROC_SEQ_FOPS_RO(name) __LPROC_SEQ_FOPS(name, NULL) +#define LPROC_SEQ_FOPS(name) __LPROC_SEQ_FOPS(name, name##_seq_write) + +#define LPROC_SEQ_FOPS_RO_TYPE(name, type) \ + static int name##_##type##_seq_show(struct seq_file *m, void *v)\ + { \ + return lprocfs_##type##_seq_show(m, m->private); \ + } \ + LPROC_SEQ_FOPS_RO(name##_##type) + +#define LPROC_SEQ_FOPS_RW_TYPE(name, type) \ + static int name##_##type##_seq_show(struct seq_file *m, void *v)\ + { \ + return lprocfs_##type##_seq_show(m, m->private); \ + } \ + static ssize_t name##_##type##_seq_write(struct file *file, \ + const char __user *buffer, size_t count, \ + loff_t *off) \ + { \ + struct seq_file *seq = file->private_data; \ + return lprocfs_##type##_seq_write(file, buffer, \ + count, seq->private); \ + } \ + LPROC_SEQ_FOPS(name##_##type); + +#define LPROC_SEQ_FOPS_WO_TYPE(name, type) \ + static ssize_t name##_##type##_write(struct file *file, \ + const char __user *buffer, size_t count, \ + loff_t *off) \ + { \ + return lprocfs_##type##_seq_write(file, buffer, count, off);\ + } \ + static int name##_##type##_open(struct inode *inode, struct file *file)\ + { \ + return single_open(file, NULL, PDE_DATA(inode)); \ + } \ + static const struct file_operations name##_##type##_fops = { \ + .open = name##_##type##_open, \ + .write = name##_##type##_write, \ + .release = lprocfs_single_release, \ + }; /* lproc_ptlrpc.c */ struct ptlrpc_request; extern void target_print_req(void *seq_file, struct ptlrpc_request *req); -/* lprocfs_status.c: read recovery max time bz13079 */ -int lprocfs_obd_rd_recovery_maxtime(char *page, char **start, off_t off, - int count, int *eof, void *data); +#ifdef HAVE_SERVER_SUPPORT +/* lprocfs_jobstats.c */ +int lprocfs_job_stats_log(struct obd_device *obd, char *jobid, + int event, long amount); +void lprocfs_job_stats_fini(struct obd_device *obd); +int lprocfs_job_stats_init(struct obd_device *obd, int cntr_num, + cntr_init_callback fn); +int lprocfs_job_interval_seq_show(struct seq_file *m, void *data); +ssize_t +lprocfs_job_interval_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off); +/* lproc_status.c */ +int lprocfs_recovery_time_soft_seq_show(struct seq_file *m, void *data); +ssize_t lprocfs_recovery_time_soft_seq_write(struct file *file, + const char *buffer, + size_t count, loff_t *off); +int lprocfs_recovery_time_hard_seq_show(struct seq_file *m, void *data); +ssize_t +lprocfs_recovery_time_hard_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off); +int lprocfs_target_instance_seq_show(struct seq_file *m, void *data); +#endif +int lprocfs_obd_max_pages_per_rpc_seq_show(struct seq_file *m, void *data); +ssize_t +lprocfs_obd_max_pages_per_rpc_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off); -/* lprocfs_status.c: write recovery max time bz13079 */ -int lprocfs_obd_wr_recovery_maxtime(struct file *file, const char *buffer, - unsigned long count, void *data); +struct root_squash_info; +int lprocfs_wr_root_squash(const char __user *buffer, unsigned long count, + struct root_squash_info *squash, char *name); +int lprocfs_wr_nosquash_nids(const char __user *buffer, unsigned long count, + struct root_squash_info *squash, char *name); /* all quota proc functions */ -extern int lprocfs_quota_rd_bunit(char *page, char **start, off_t off, int count, +extern int lprocfs_quota_rd_bunit(char *page, char **start, + off_t off, int count, int *eof, void *data); extern int lprocfs_quota_wr_bunit(struct file *file, const char *buffer, unsigned long count, void *data); -extern int lprocfs_quota_rd_btune(char *page, char **start, off_t off, int count, +extern int lprocfs_quota_rd_btune(char *page, char **start, + off_t off, int count, int *eof, void *data); extern int lprocfs_quota_wr_btune(struct file *file, const char *buffer, unsigned long count, void *data); -extern int lprocfs_quota_rd_iunit(char *page, char **start, off_t off, int count, +extern int lprocfs_quota_rd_iunit(char *page, char **start, + off_t off, int count, int *eof, void *data); extern int lprocfs_quota_wr_iunit(struct file *file, const char *buffer, unsigned long count, void *data); -extern int lprocfs_quota_rd_itune(char *page, char **start, off_t off, int count, +extern int lprocfs_quota_rd_itune(char *page, char **start, + off_t off, int count, int *eof, void *data); extern int lprocfs_quota_wr_itune(struct file *file, const char *buffer, unsigned long count, void *data); @@ -662,7 +905,8 @@ extern int lprocfs_quota_wr_type(struct file *file, const char *buffer, unsigned long count, void *data); extern int lprocfs_quota_rd_switch_seconds(char *page, char **start, off_t off, int count, int *eof, void *data); -extern int lprocfs_quota_wr_switch_seconds(struct file *file, const char *buffer, +extern int lprocfs_quota_wr_switch_seconds(struct file *file, + const char *buffer, unsigned long count, void *data); extern int lprocfs_quota_rd_sync_blk(char *page, char **start, off_t off, int count, int *eof, void *data); @@ -670,57 +914,46 @@ extern int lprocfs_quota_wr_sync_blk(struct file *file, const char *buffer, unsigned long count, void *data); extern int lprocfs_quota_rd_switch_qs(char *page, char **start, off_t off, int count, int *eof, void *data); -extern int lprocfs_quota_wr_switch_qs(struct file *file, const char *buffer, +extern int lprocfs_quota_wr_switch_qs(struct file *file, + const char *buffer, unsigned long count, void *data); extern int lprocfs_quota_rd_boundary_factor(char *page, char **start, off_t off, int count, int *eof, void *data); -extern int lprocfs_quota_wr_boundary_factor(struct file *file, const char *buffer, +extern int lprocfs_quota_wr_boundary_factor(struct file *file, + const char *buffer, unsigned long count, void *data); extern int lprocfs_quota_rd_least_bunit(char *page, char **start, off_t off, int count, int *eof, void *data); -extern int lprocfs_quota_wr_least_bunit(struct file *file, const char *buffer, +extern int lprocfs_quota_wr_least_bunit(struct file *file, + const char *buffer, unsigned long count, void *data); extern int lprocfs_quota_rd_least_iunit(char *page, char **start, off_t off, int count, int *eof, void *data); -extern int lprocfs_quota_wr_least_iunit(struct file *file, const char *buffer, +extern int lprocfs_quota_wr_least_iunit(struct file *file, + const char *buffer, unsigned long count, void *data); extern int lprocfs_quota_rd_qs_factor(char *page, char **start, off_t off, int count, int *eof, void *data); -extern int lprocfs_quota_wr_qs_factor(struct file *file, const char *buffer, +extern int lprocfs_quota_wr_qs_factor(struct file *file, + const char *buffer, unsigned long count, void *data); - -/** struct for holding changelog data for seq_file processing */ -struct changelog_seq_iter { - void *csi_dev; - struct llog_ctxt *csi_ctxt; - struct llog_handle *csi_llh; - __u64 csi_startrec; - __u64 csi_endrec; - loff_t csi_pos; - int csi_wrote; - int csi_startcat; - int csi_startidx; - int csi_fill:1; - int csi_done:1; -}; -int changelog_seq_open(struct inode *inode, struct file *file, - struct changelog_seq_iter **csih); -int changelog_seq_release(struct inode *inode, struct file *file); -loff_t changelog_seq_lseek(struct file *file, loff_t offset, int origin); - - - #else /* LPROCFS is not defined */ - +#define proc_lustre_root NULL static inline void lprocfs_counter_add(struct lprocfs_stats *stats, - int index, long amount) { return; } + int index, long amount) +{ return; } static inline void lprocfs_counter_incr(struct lprocfs_stats *stats, - int index) { return; } + int index) +{ return; } static inline void lprocfs_counter_sub(struct lprocfs_stats *stats, - int index, long amount) { return; } + int index, long amount) +{ return; } +static inline void lprocfs_counter_decr(struct lprocfs_stats *stats, + int index) +{ return; } static inline void lprocfs_counter_init(struct lprocfs_stats *stats, int index, unsigned conf, const char *name, const char *units) @@ -730,20 +963,24 @@ static inline __u64 lc_read_helper(struct lprocfs_counter *lc, enum lprocfs_fields_flags field) { return 0; } -static inline struct lprocfs_stats* lprocfs_alloc_stats(unsigned int num, - enum lprocfs_stats_flags flags) -{ return NULL; } +/* NB: we return !NULL to satisfy error checker */ +static inline struct lprocfs_stats * +lprocfs_alloc_stats(unsigned int num, enum lprocfs_stats_flags flags) +{ return (struct lprocfs_stats *)1; } static inline void lprocfs_clear_stats(struct lprocfs_stats *stats) { return; } static inline void lprocfs_free_stats(struct lprocfs_stats **stats) { return; } -static inline int lprocfs_register_stats(cfs_proc_dir_entry_t *root, - const char *name, - struct lprocfs_stats *stats) +static inline int lprocfs_register_stats(struct proc_dir_entry *root, + const char *name, + struct lprocfs_stats *stats) { return 0; } static inline void lprocfs_init_ops_stats(int num_private_stats, struct lprocfs_stats *stats) { return; } +static inline void lprocfs_init_mps_stats(int num_private_stats, + struct lprocfs_stats *stats) +{ return; } static inline void lprocfs_init_ldlm_stats(struct lprocfs_stats *ldlm_stats) { return; } static inline int lprocfs_alloc_obd_stats(struct obd_device *obddev, @@ -754,138 +991,179 @@ static inline int lprocfs_alloc_md_stats(struct obd_device *obddev, { return 0; } static inline void lprocfs_free_obd_stats(struct obd_device *obddev) { return; } +static inline void lprocfs_free_md_stats(struct obd_device *obddev) +{ return; } struct obd_export; static inline int lprocfs_add_clear_entry(struct obd_export *exp) { return 0; } -static inline int lprocfs_exp_setup(struct obd_export *exp, - lnet_nid_t *peer_nid, int *newnid) +static inline void lprocfs_free_per_client_stats(struct obd_device *obd) +{ return; } +#ifdef HAVE_SERVER_SUPPORT +static inline +ssize_t lprocfs_nid_stats_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off) +{return 0;} +static inline +int lprocfs_nid_stats_clear_seq_show(struct seq_file *m, void *data) +{return 0;} +static inline int lprocfs_exp_setup(struct obd_export *exp,lnet_nid_t *peer_nid) { return 0; } +#endif static inline int lprocfs_exp_cleanup(struct obd_export *exp) { return 0; } -static inline cfs_proc_dir_entry_t *lprocfs_add_simple(struct proc_dir_entry *root, - char *name, - cfs_read_proc_t *read_proc, - cfs_write_proc_t *write_proc, - void *data, - struct file_operations *fops) +static inline struct proc_dir_entry * +lprocfs_add_simple(struct proc_dir_entry *root, char *name, + void *data, const struct file_operations *fops) {return 0; } -static inline struct proc_dir_entry *lprocfs_add_symlink(const char *name, - struct proc_dir_entry *parent, const char *dest) +static inline struct proc_dir_entry * +lprocfs_add_symlink(const char *name, struct proc_dir_entry *parent, + const char *format, ...) {return NULL; } -static inline void lprocfs_free_per_client_stats(struct obd_device *obd) -{} -static inline -int lprocfs_nid_stats_clear_write(struct file *file, const char *buffer, - unsigned long count, void *data) -{return count;} -static inline -int lprocfs_nid_stats_clear_read(char *page, char **start, off_t off, - int count, int *eof, void *data) -{return count;} - -static inline cfs_proc_dir_entry_t * -lprocfs_register(const char *name, cfs_proc_dir_entry_t *parent, - struct lprocfs_vars *list, void *data) { return NULL; } -static inline int lprocfs_add_vars(cfs_proc_dir_entry_t *root, +#ifndef HAVE_ONLY_PROCFS_SEQ +static inline struct proc_dir_entry * +lprocfs_register(const char *name, struct proc_dir_entry *parent, + struct lprocfs_vars *list, void *data) +{ return NULL; } +static inline int lprocfs_add_vars(struct proc_dir_entry *root, struct lprocfs_vars *var, - void *data) { return 0; } -static inline void lprocfs_remove(cfs_proc_dir_entry_t **root) {}; + void *data) +{ return 0; } +#endif +static inline int lprocfs_seq_add_vars(struct proc_dir_entry *root, + struct lprocfs_seq_vars *var, + void *data) +{ return 0; } +static inline struct proc_dir_entry * +lprocfs_seq_register(const char *name, struct proc_dir_entry *parent, + struct lprocfs_seq_vars *list, void *data) +{ return NULL; } +static inline void lprocfs_remove(struct proc_dir_entry **root) +{ return; } static inline void lprocfs_remove_proc_entry(const char *name, - struct proc_dir_entry *parent) {}; -static inline cfs_proc_dir_entry_t *lprocfs_srch(cfs_proc_dir_entry_t *head, - const char *name) {return 0;} -static inline int lprocfs_obd_setup(struct obd_device *dev, - struct lprocfs_vars *list) { return 0; } -static inline int lprocfs_obd_cleanup(struct obd_device *dev) { return 0; } -static inline int lprocfs_rd_u64(char *page, char **start, off_t off, - int count, int *eof, void *data) { return 0; } -static inline int lprocfs_rd_uuid(char *page, char **start, off_t off, - int count, int *eof, void *data) { return 0; } -static inline int lprocfs_rd_name(char *page, char **start, off_t off, - int count, int *eof, void *data) { return 0; } -static inline int lprocfs_rd_server_uuid(char *page, char **start, off_t off, - int count, int *eof, void *data) -{ return 0; } -static inline int lprocfs_rd_conn_uuid(char *page, char **start, off_t off, - int count, int *eof, void *data) -{ return 0; } -static inline int lprocfs_rd_import(char *page, char **start, off_t off, int count, - int *eof, void *data) { return 0; } -static inline int lprocfs_rd_connect_flags(char *page, char **start, off_t off, - int count, int *eof, void *data) -{ return 0; } -static inline int lprocfs_rd_num_exports(char *page, char **start, off_t off, - int count, int *eof, void *data) -{ return 0; } -static inline int lprocfs_rd_numrefs(char *page, char **start, off_t off, - int count, int *eof, void *data) + struct proc_dir_entry *parent) +{ return; } +#ifndef HAVE_ONLY_PROCFS_SEQ +static inline void lprocfs_try_remove_proc_entry(const char *name, + struct proc_dir_entry *parent) +{ return; } +static inline struct proc_dir_entry *lprocfs_srch(struct proc_dir_entry *head, + const char *name) +{ return 0; } +#endif +static inline int lprocfs_obd_setup(struct obd_device *dev) +{ return 0; } +static inline int lprocfs_obd_cleanup(struct obd_device *dev) { return 0; } +static inline int lprocfs_uuid_seq_show(struct seq_file *m, void *data) +{ return 0; } +static inline int lprocfs_name_seq_show(struct seq_file *m, void *data) +{ return 0; } +static inline int lprocfs_server_seq_show(struct seq_file *m, void *data) +{ return 0; } +static inline int lprocfs_conn_uuid_seq_show(struct seq_file *m, void *data) +{ return 0; } +static inline int lprocfs_import_seq_show(struct seq_file *m, void *data) +{ return 0; } +static inline int lprocfs_state_seq_show(struct seq_file *m, void *data) +{ return 0; } +static inline int lprocfs_connect_flags_seq_show(struct seq_file *m, void *data) +{ return 0; } +#ifdef HAVE_SERVER_SUPPORT +static inline int lprocfs_num_exports_seq_show(struct seq_file *m, void *data) +{ return 0; } +#endif struct adaptive_timeout; -static inline int lprocfs_at_hist_helper(char *page, int count, int rc, - struct adaptive_timeout *at) +static inline int lprocfs_seq_at_hist_helper(struct seq_file *m, + struct adaptive_timeout *at) { return 0; } -static inline int lprocfs_rd_timeouts(char *page, char **start, off_t off, - int count, int *eof, void *data) +static inline int lprocfs_timeouts_seq_show(struct seq_file *m, void *data) { return 0; } -static inline int lprocfs_wr_timeouts(struct file *file, const char *buffer, - unsigned long count, void *data) +static inline ssize_t +lprocfs_timeouts_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off) { return 0; } -static inline int lprocfs_wr_evict_client(struct file *file, const char *buffer, - unsigned long count, void *data) +#ifdef HAVE_SERVER_SUPPORT +static inline ssize_t +lprocfs_evict_client_seq_write(struct file *file, const char *buffer, + size_t count, loff_t *off) { return 0; } -static inline int lprocfs_wr_ping(struct file *file, const char *buffer, - unsigned long count, void *data) +#endif +static inline ssize_t +lprocfs_ping_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off) +{ return 0; } +static inline ssize_t +lprocfs_import_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off) +{ return 0; } +static inline int +lprocfs_pinger_recov_seq_show(struct seq_file *m, void *data) +{ return 0; } +static inline ssize_t +lprocfs_pinger_recov_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off) { return 0; } - /* Statfs helpers */ static inline -int lprocfs_rd_blksize(char *page, char **start, off_t off, - int count, int *eof, void *data) { return 0; } -static inline -int lprocfs_rd_kbytestotal(char *page, char **start, off_t off, - int count, int *eof, void *data) { return 0; } -static inline -int lprocfs_rd_kbytesfree(char *page, char **start, off_t off, - int count, int *eof, void *data) { return 0; } +int lprocfs_blksize_seq_show(struct seq_file *m, void *data) +{ return 0; } static inline -int lprocfs_rd_kbytesavail(char *page, char **start, off_t off, - int count, int *eof, void *data) { return 0; } +int lprocfs_kbytestotal_seq_show(struct seq_file *m, void *data) +{ return 0; } static inline -int lprocfs_rd_filestotal(char *page, char **start, off_t off, - int count, int *eof, void *data) { return 0; } +int lprocfs_kbytesfree_seq_show(struct seq_file *m, void *data) +{ return 0; } static inline -int lprocfs_rd_filesfree(char *page, char **start, off_t off, - int count, int *eof, void *data) { return 0; } +int lprocfs_kbytesavail_seq_show(struct seq_file *m, void *data) +{ return 0; } static inline -int lprocfs_rd_filegroups(char *page, char **start, off_t off, - int count, int *eof, void *data) { return 0; } +int lprocfs_filestotal_seq_show(struct seq_file *m, void *data) +{ return 0; } static inline -void lprocfs_oh_tally(struct obd_histogram *oh, unsigned int value) {} +int lprocfs_filesfree_seq_show(struct seq_file *m, void *data) +{ return 0; } static inline -void lprocfs_oh_tally_log2(struct obd_histogram *oh, unsigned int value) {} +void lprocfs_oh_tally(struct obd_histogram *oh, unsigned int value) +{ return; } static inline -void lprocfs_oh_clear(struct obd_histogram *oh) {} +void lprocfs_oh_tally_log2(struct obd_histogram *oh, unsigned int value) +{ return; } static inline -unsigned long lprocfs_oh_sum(struct obd_histogram *oh) { return 0; } +void lprocfs_oh_clear(struct obd_histogram *oh) +{ return; } static inline -int lprocfs_counter_read(char *page, char **start, off_t off, - int count, int *eof, void *data) { return 0; } +unsigned long lprocfs_oh_sum(struct obd_histogram *oh) +{ return 0; } static inline -int lprocfs_counter_write(struct file *file, const char *buffer, - unsigned long count, void *data) { return 0; } - +void lprocfs_stats_collect(struct lprocfs_stats *stats, int idx, + struct lprocfs_counter *cnt) +{ return; } static inline __u64 lprocfs_stats_collector(struct lprocfs_stats *stats, int idx, enum lprocfs_fields_flags field) { return (__u64)0; } -#define LPROCFS_ENTRY() -#define LPROCFS_EXIT() -#define LPROCFS_ENTRY_AND_CHECK(dp) #define LPROC_SEQ_FOPS_RO(name) #define LPROC_SEQ_FOPS(name) +#define LPROC_SEQ_FOPS_RO_TYPE(name, type) +#define LPROC_SEQ_FOPS_RW_TYPE(name, type) +#define LPROC_SEQ_FOPS_WO_TYPE(name, type) + +/* lprocfs_jobstats.c */ +static inline +int lprocfs_job_stats_log(struct obd_device *obd, char *jobid, int event, + long amount) +{ return 0; } +static inline +void lprocfs_job_stats_fini(struct obd_device *obd) +{ return; } +static inline +int lprocfs_job_stats_init(struct obd_device *obd, int cntr_num, + cntr_init_callback fn) +{ return 0; } + /* lproc_ptlrpc.c */ #define target_print_req NULL