LU-8836 lprocfs: move lprocfs_stats_[un]lock to a source file

There is no reason to export lprocfs_stats_alloc_one.
The reason is due to the functions lprocfs_stats_[un]lock
being inline functions in a header file. Lets untangle
this mess and turn those inline functions into real
functions in a source file.

Change-Id: I8e33f36226c54baa93c50beb716705d20a55fa58
Signed-off-by: James Simmons <uja.ornl@yahoo.com>
Reviewed-on: https://review.whamcloud.com/23773
Tested-by: Jenkins
Reviewed-by: Andreas Dilger <andreas.dilger@intel.com>
Tested-by: Maloo <hpdd-maloo@intel.com>
Reviewed-by: Dmitry Eremin <dmitry.eremin@intel.com>
Reviewed-by: John L. Hammond <john.hammond@intel.com>

diff --git a/lustre/include/lprocfs_status.h b/lustre/include/lprocfs_status.h
index e4b2d9a..25e0319 100644 (file)
--- a/lustre/include/lprocfs_status.h
+++ b/lustre/include/lprocfs_status.h
@@ -395,94 +395,14 @@ struct obd_job_stats {
 
 #ifdef CONFIG_PROC_FS
 
 
 #ifdef CONFIG_PROC_FS
 

-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)
-{
-       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 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();
-       }
-}
+int lprocfs_stats_alloc_one(struct lprocfs_stats *stats,
+                           unsigned int cpuid);
+int lprocfs_stats_lock(struct lprocfs_stats *stats,
+                      enum lprocfs_stats_lock_ops opc,
+                      unsigned long *flags);
+void lprocfs_stats_unlock(struct lprocfs_stats *stats,
+                         enum lprocfs_stats_lock_ops opc,
+                         unsigned long *flags);

 
 static inline unsigned int
 lprocfs_stats_counter_size(struct lprocfs_stats *stats)
 
 static inline unsigned int
 lprocfs_stats_counter_size(struct lprocfs_stats *stats)


@@ -536,29 +456,8 @@ extern __s64 lprocfs_read_helper(struct lprocfs_counter *lc,
                                 struct lprocfs_counter_header *header,
                                 enum lprocfs_stats_flags flags,
                                 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)
-{
-       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;
-}
+u64 lprocfs_stats_collector(struct lprocfs_stats *stats, int idx,
+                           enum lprocfs_fields_flags field);

 
 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);


@@ -1040,8 +939,8 @@ void lprocfs_stats_collect(struct lprocfs_stats *stats, int idx,
                            struct lprocfs_counter *cnt)
 { return; }
 static inline
                            struct lprocfs_counter *cnt)
 { return; }
 static inline

-__u64 lprocfs_stats_collector(struct lprocfs_stats *stats, int idx,
-                               enum lprocfs_fields_flags field)
+u64 lprocfs_stats_collector(struct lprocfs_stats *stats, int idx,
+                           enum lprocfs_fields_flags field)

 { return (__u64)0; }
 
 #define LPROC_SEQ_FOPS_RO(name)
 { return (__u64)0; }
 
 #define LPROC_SEQ_FOPS_RO(name)

diff --git a/lustre/obdclass/lprocfs_status.c b/lustre/obdclass/lprocfs_status.c
index 08db676..53e46a6 100644 (file)
--- a/lustre/obdclass/lprocfs_status.c
+++ b/lustre/obdclass/lprocfs_status.c
@@ -532,6 +532,95 @@ int lprocfs_conn_uuid_seq_show(struct seq_file *m, void *data)
 EXPORT_SYMBOL(lprocfs_conn_uuid_seq_show);
 
 /** add up per-cpu counters */
 EXPORT_SYMBOL(lprocfs_conn_uuid_seq_show);
 
 /** add up per-cpu counters */

+
+/**
+ * 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)
+ */
+int lprocfs_stats_lock(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_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])) {
+                       int rc = lprocfs_stats_alloc_one(stats, cpuid);
+
+                       if (rc < 0) {
+                               put_cpu();
+                               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
+ */
+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();
+       }
+}
+
+/** add up per-cpu counters */

 void lprocfs_stats_collect(struct lprocfs_stats *stats, int idx,
                           struct lprocfs_counter *cnt)
 {
 void lprocfs_stats_collect(struct lprocfs_stats *stats, int idx,
                           struct lprocfs_counter *cnt)
 {


@@ -1123,7 +1212,6 @@ int lprocfs_stats_alloc_one(struct lprocfs_stats *stats, unsigned int cpuid)
        }
        return rc;
 }
        }
        return rc;
 }

-EXPORT_SYMBOL(lprocfs_stats_alloc_one);

 
 struct lprocfs_stats *lprocfs_alloc_stats(unsigned int num,
                                           enum lprocfs_stats_flags flags)
 
 struct lprocfs_stats *lprocfs_alloc_stats(unsigned int num,
                                           enum lprocfs_stats_flags flags)


@@ -1208,6 +1296,32 @@ void lprocfs_free_stats(struct lprocfs_stats **statsh)
 }
 EXPORT_SYMBOL(lprocfs_free_stats);
 
 }
 EXPORT_SYMBOL(lprocfs_free_stats);
 

+u64 lprocfs_stats_collector(struct lprocfs_stats *stats, int idx,
+                           enum lprocfs_fields_flags field)
+{
+       unsigned long flags = 0;
+       unsigned int num_cpu;
+       unsigned int i;
+       u64 ret = 0;
+
+       LASSERT(stats);
+
+       num_cpu = lprocfs_stats_lock(stats, LPROCFS_GET_NUM_CPU, &flags);
+       for (i = 0; i < num_cpu; i++) {
+               struct lprocfs_counter *cntr;
+
+               if (!stats->ls_percpu[i])
+                       continue;
+
+               cntr = lprocfs_stats_counter_get(stats, i, idx);
+               ret += lprocfs_read_helper(cntr, &stats->ls_cnt_header[idx],
+                                          stats->ls_flags, field);
+       }
+       lprocfs_stats_unlock(stats, LPROCFS_GET_NUM_CPU, &flags);
+       return ret;
+}
+EXPORT_SYMBOL(lprocfs_stats_collector);
+

 void lprocfs_clear_stats(struct lprocfs_stats *stats)
 {
        struct lprocfs_counter          *percpu_cntr;
 void lprocfs_clear_stats(struct lprocfs_stats *stats)
 {
        struct lprocfs_counter          *percpu_cntr;