staging/lustre/obd: final removal of procfs stuff
authorDmitry Eremin <dmiter4ever@gmail.com>
Sun, 31 May 2015 03:27:05 +0000 (23:27 -0400)
committerGreg Kroah-Hartman <gregkh@linuxfoundation.org>
Sun, 31 May 2015 06:26:38 +0000 (15:26 +0900)
Signed-off-by: Dmitry Eremin <dmiter4ever@gmail.com>
Signed-off-by: Oleg Drokin <oleg.drokin@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
43 files changed:
drivers/staging/lustre/include/linux/libcfs/linux/libcfs.h
drivers/staging/lustre/lustre/fid/Makefile
drivers/staging/lustre/lustre/fld/Makefile
drivers/staging/lustre/lustre/include/dt_object.h
drivers/staging/lustre/lustre/include/linux/lustre_lite.h
drivers/staging/lustre/lustre/include/linux/obd.h
drivers/staging/lustre/lustre/include/lprocfs_status.h
drivers/staging/lustre/lustre/include/lustre_fid.h
drivers/staging/lustre/lustre/include/lustre_fld.h
drivers/staging/lustre/lustre/include/lustre_net.h
drivers/staging/lustre/lustre/include/lustre_quota.h [deleted file]
drivers/staging/lustre/lustre/include/obd_class.h
drivers/staging/lustre/lustre/include/obd_support.h
drivers/staging/lustre/lustre/ldlm/ldlm_resource.c
drivers/staging/lustre/lustre/libcfs/module.c
drivers/staging/lustre/lustre/llite/Makefile
drivers/staging/lustre/lustre/llite/llite_internal.h
drivers/staging/lustre/lustre/llite/vvp_dev.c
drivers/staging/lustre/lustre/lmv/Makefile
drivers/staging/lustre/lustre/lmv/lmv_internal.h
drivers/staging/lustre/lustre/lov/Makefile
drivers/staging/lustre/lustre/lov/lov_internal.h
drivers/staging/lustre/lustre/lov/lov_pool.c
drivers/staging/lustre/lustre/mdc/Makefile
drivers/staging/lustre/lustre/mdc/lproc_mdc.c
drivers/staging/lustre/lustre/mdc/mdc_internal.h
drivers/staging/lustre/lustre/mgc/Makefile
drivers/staging/lustre/lustre/mgc/mgc_internal.h
drivers/staging/lustre/lustre/mgc/mgc_request.c
drivers/staging/lustre/lustre/obdclass/Makefile
drivers/staging/lustre/lustre/obdclass/class_obd.c
drivers/staging/lustre/lustre/obdclass/dt_object.c
drivers/staging/lustre/lustre/obdclass/linux/linux-module.c
drivers/staging/lustre/lustre/obdclass/linux/linux-sysctl.c
drivers/staging/lustre/lustre/obdclass/lprocfs_status.c
drivers/staging/lustre/lustre/obdclass/lu_object.c
drivers/staging/lustre/lustre/osc/Makefile
drivers/staging/lustre/lustre/osc/lproc_osc.c
drivers/staging/lustre/lustre/osc/osc_internal.h
drivers/staging/lustre/lustre/ptlrpc/Makefile
drivers/staging/lustre/lustre/ptlrpc/lproc_ptlrpc.c
drivers/staging/lustre/lustre/ptlrpc/ptlrpc_internal.h
drivers/staging/lustre/lustre/ptlrpc/sec_lproc.c

index 4fe50841e8e3c3546d9f62eb4176a5fe1ef159a0..3e2502a69bbd16cb7ef36727c5051d9f76db5e28 100644 (file)
@@ -61,7 +61,6 @@
 #include <linux/moduleparam.h>
 #include <linux/mutex.h>
 #include <linux/notifier.h>
-#include <linux/proc_fs.h>
 #include <linux/random.h>
 #include <linux/rbtree.h>
 #include <linux/rwsem.h>
index 5513ce416a35e5576046dab3d14f82671e09cd1a..b7ef314b4b848f5858aaed356ec803e169b4b2ef 100644 (file)
@@ -1,3 +1,2 @@
 obj-$(CONFIG_LUSTRE_FS) += fid.o
-fid-y := fid_request.o fid_lib.o
-fid-$(CONFIG_PROC_FS) += lproc_fid.o
+fid-y := fid_request.o fid_lib.o lproc_fid.o
index 2bbf08433dcaae9a5a3a6cb636739c3c13ccc9fd..646e315d1aa8994f2c94378844426450b4426d48 100644 (file)
@@ -1,3 +1,2 @@
 obj-$(CONFIG_LUSTRE_FS) += fld.o
-fld-y := fld_request.o fld_cache.o
-fld-$(CONFIG_PROC_FS) += lproc_fld.o
+fld-y := fld_request.o fld_cache.o lproc_fld.o
index 866d04b2814bfd6cde4815fb71ff4effd8e6bb0e..abae31b41e744fde4c4782b9cd2530e0731a1f25 100644 (file)
@@ -1480,7 +1480,6 @@ static inline struct dt_thread_info *dt_info(const struct lu_env *env)
 int dt_global_init(void);
 void dt_global_fini(void);
 
-#if defined (CONFIG_PROC_FS)
 int lprocfs_dt_rd_blksize(char *page, char **start, off_t off,
                          int count, int *eof, void *data);
 int lprocfs_dt_rd_kbytestotal(char *page, char **start, off_t off,
@@ -1493,6 +1492,5 @@ int lprocfs_dt_rd_filestotal(char *page, char **start, off_t off,
                             int count, int *eof, void *data);
 int lprocfs_dt_rd_filesfree(char *page, char **start, off_t off,
                            int count, int *eof, void *data);
-#endif /* CONFIG_PROC_FS */
 
 #endif /* __LUSTRE_DT_OBJECT_H */
index a7658a99a08d878fa1316e21bd08b20206c1c1af..45651caf42ccf6b8df084bbd0e8985308d76f389 100644 (file)
@@ -44,7 +44,6 @@
 
 #include <linux/fs.h>
 #include <linux/dcache.h>
-#include <linux/proc_fs.h>
 
 #include "../obd_class.h"
 #include "../lustre_net.h"
index 9cd8683573ce6128914d909407adfc15b9c124b2..2817e88e014a45826a9dc421f8ea67083604c4cd 100644 (file)
 
 #include "../obd_support.h"
 
-# include <linux/fs.h>
-# include <linux/list.h>
-# include <linux/sched.h>  /* for struct task_struct, for current.h */
-# include <linux/proc_fs.h>
-# include <linux/mount.h>
+#include <linux/fs.h>
+#include <linux/list.h>
+#include <linux/sched.h>  /* for struct task_struct, for current.h */
+#include <linux/mount.h>
+
 #include "../lustre_intent.h"
 
 struct ll_iattr {
index 6a77ea8ec62e769a3237271bdea15dd9a6d2a360..3292fd3c588a5620c20359bf17c740cf85aaaf2e 100644 (file)
@@ -42,7 +42,6 @@
 #ifndef _LPROCFS_SNMP_H
 #define _LPROCFS_SNMP_H
 
-#include <linux/proc_fs.h>
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
 #include <linux/spinlock.h>
@@ -380,8 +379,6 @@ extern int lprocfs_write_frac_helper(const char __user *buffer,
                                     unsigned long count, int *val, int mult);
 extern int lprocfs_read_frac_helper(char *buffer, unsigned long count,
                                    long val, int mult);
-#if defined (CONFIG_PROC_FS)
-
 extern int lprocfs_stats_alloc_one(struct lprocfs_stats *stats,
                                   unsigned int cpuid);
 /*
@@ -558,17 +555,11 @@ extern void lprocfs_counter_init(struct lprocfs_stats *stats, int index,
 extern void lprocfs_free_obd_stats(struct obd_device *obddev);
 extern void lprocfs_free_md_stats(struct obd_device *obddev);
 struct obd_export;
-extern int lprocfs_add_clear_entry(struct obd_device *obd,
-                                  struct proc_dir_entry *entry);
 extern int lprocfs_exp_cleanup(struct obd_export *exp);
 extern struct dentry *ldebugfs_add_simple(struct dentry *root,
                                          char *name,
                                          void *data,
                                          struct file_operations *fops);
-extern struct proc_dir_entry *lprocfs_add_simple(struct proc_dir_entry *root,
-                                               char *name,
-                                               void *data,
-                                               struct file_operations *fops);
 extern struct dentry *
 ldebugfs_add_symlink(const char *name, struct dentry *parent,
                    const char *format, ...);
@@ -576,30 +567,18 @@ ldebugfs_add_symlink(const char *name, struct dentry *parent,
 extern int ldebugfs_register_stats(struct dentry *parent,
                                   const char *name,
                                   struct lprocfs_stats *stats);
-extern int lprocfs_register_stats(struct proc_dir_entry *root, const char *name,
-                                 struct lprocfs_stats *stats);
 
 /* lprocfs_status.c */
 extern int ldebugfs_add_vars(struct dentry *parent,
                             struct lprocfs_vars *var,
                             void *data);
-extern int lprocfs_add_vars(struct proc_dir_entry *root,
-                           struct lprocfs_vars *var,
-                           void *data);
 
 extern struct dentry *ldebugfs_register(const char *name,
                                        struct dentry *parent,
                                        struct lprocfs_vars *list,
                                        void *data);
-extern struct proc_dir_entry *lprocfs_register(const char *name,
-                                             struct proc_dir_entry *parent,
-                                             struct lprocfs_vars *list,
-                                             void *data);
 
 extern void ldebugfs_remove(struct dentry **entryp);
-extern void lprocfs_remove(struct proc_dir_entry **root);
-extern void lprocfs_remove_proc_entry(const char *name,
-                                     struct proc_dir_entry *parent);
 
 extern int lprocfs_obd_setup(struct obd_device *obd, struct lprocfs_vars *list,
                             struct attribute_group *attrs);
@@ -610,14 +589,11 @@ extern int ldebugfs_seq_create(struct dentry *parent,
                               umode_t mode,
                               const struct file_operations *seq_fops,
                               void *data);
-extern int lprocfs_seq_create(struct proc_dir_entry *parent, const char *name,
-                             umode_t mode,
-                             const struct file_operations *seq_fops,
-                             void *data);
-extern int lprocfs_obd_seq_create(struct obd_device *dev, const char *name,
-                                 umode_t mode,
-                                 const struct file_operations *seq_fops,
-                                 void *data);
+extern int ldebugfs_obd_seq_create(struct obd_device *dev,
+                                  const char *name,
+                                  umode_t mode,
+                                  const struct file_operations *seq_fops,
+                                  void *data);
 
 /* Generic callbacks */
 
@@ -691,12 +667,11 @@ extern int lprocfs_seq_release(struct inode *, struct file *);
 /* 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); */
+  call ldebugfs_obd_seq_create(obd, filename, 0444, &name#_fops, data); */
 #define __LPROC_SEQ_FOPS(name, custom_seq_write)                       \
 static int name##_single_open(struct inode *inode, struct file *file)  \
 {                                                                      \
-       return single_open(file, name##_seq_show,                       \
-                          inode->i_private ?: PDE_DATA(inode));        \
+       return single_open(file, name##_seq_show, inode->i_private);    \
 }                                                                      \
 static struct file_operations name##_fops = {                          \
        .owner   = THIS_MODULE,                                     \
@@ -741,8 +716,7 @@ static struct file_operations name##_fops = {                               \
        }                                                               \
        static int name##_##type##_open(struct inode *inode, struct file *file) \
        {                                                               \
-               return single_open(file, NULL,                          \
-                                  inode->i_private ?: PDE_DATA(inode));\
+               return single_open(file, NULL, inode->i_private);       \
        }                                                               \
        static struct file_operations name##_##type##_fops = {  \
                .open   = name##_##type##_open,                         \
@@ -839,187 +813,4 @@ extern int lprocfs_quota_rd_qs_factor(char *page, char **start, loff_t off,
 extern int lprocfs_quota_wr_qs_factor(struct file *file,
                                      const char *buffer,
                                      unsigned long count, void *data);
-#else
-/* CONFIG_PROC_FS is not defined */
-
-static inline void lprocfs_counter_add(struct lprocfs_stats *stats,
-                                      int index, long amount)
-{ return; }
-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)
-{ 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)
-{ return; }
-
-static inline __u64 lc_read_helper(struct lprocfs_counter *lc,
-                                  enum lprocfs_fields_flags field)
-{ return 0; }
-
-/* 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(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,
-                                         unsigned int num_private_stats)
-{ return 0; }
-static inline int lprocfs_alloc_md_stats(struct obd_device *obddev,
-                                        unsigned int num_private_stats)
-{ 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_cleanup(struct obd_export *exp)
-{ return 0; }
-static inline struct proc_dir_entry *
-lprocfs_add_simple(struct proc_dir_entry *root, char *name,
-                  void *data, struct file_operations *fops)
-{return 0; }
-
-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(struct proc_dir_entry **root)
-{ return; }
-static inline void lprocfs_remove_proc_entry(const char *name,
-                                            struct proc_dir_entry *parent)
-{ return; }
-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(struct seq_file *m, void *data)
-{ return 0; }
-static inline int lprocfs_rd_uuid(struct seq_file *m, void *data)
-{ return 0; }
-static inline int lprocfs_rd_name(struct seq_file *m, void *data)
-{ return 0; }
-static inline int lprocfs_rd_server_uuid(struct seq_file *m, void *data)
-{ return 0; }
-static inline int lprocfs_rd_conn_uuid(struct seq_file *m, void *data)
-{ return 0; }
-static inline int lprocfs_rd_import(struct seq_file *m, void *data)
-{ return 0; }
-static inline int lprocfs_rd_pinger_recov(struct seq_file *m, void *n)
-{ return 0; }
-static inline int lprocfs_rd_state(struct seq_file *m, void *data)
-{ return 0; }
-static inline int lprocfs_rd_connect_flags(struct seq_file *m, void *data)
-{ return 0; }
-static inline int lprocfs_rd_num_exports(struct seq_file *m, void *data)
-{ return 0; }
-extern inline int lprocfs_rd_numrefs(struct seq_file *m, void *data)
-{ return 0; }
-struct adaptive_timeout;
-static inline int lprocfs_at_hist_helper(struct seq_file *m,
-                                        struct adaptive_timeout *at)
-{ return 0; }
-static inline int lprocfs_rd_timeouts(struct seq_file *m, void *data)
-{ return 0; }
-static inline int lprocfs_wr_timeouts(struct file *file,
-                               const char __user *buffer,
-                               unsigned long count, void *data)
-{ return 0; }
-static inline int lprocfs_wr_evict_client(struct file *file,
-                               const char __user *buffer,
-                               size_t count, loff_t *off)
-{ return 0; }
-static inline int lprocfs_wr_ping(struct file *file,
-                               const char __user *buffer,
-                               size_t count, loff_t *off)
-{ return 0; }
-static inline int lprocfs_wr_import(struct file *file,
-                               const char __user *buffer,
-                               size_t count, loff_t *off)
-{ return 0; }
-static inline int lprocfs_wr_pinger_recov(struct file *file,
-                               const char __user *buffer,
-                               size_t count, loff_t *off)
-{ return 0; }
-
-/* Statfs helpers */
-static inline
-int lprocfs_rd_blksize(struct seq_file *m, void *data)
-{ return 0; }
-static inline
-int lprocfs_rd_kbytestotal(struct seq_file *m, void *data)
-{ return 0; }
-static inline
-int lprocfs_rd_kbytesfree(struct seq_file *m, void *data)
-{ return 0; }
-static inline
-int lprocfs_rd_kbytesavail(struct seq_file *m, void *data)
-{ return 0; }
-static inline
-int lprocfs_rd_filestotal(struct seq_file *m, void *data)
-{ return 0; }
-static inline
-int lprocfs_rd_filesfree(struct seq_file *m, void *data)
-{ return 0; }
-static inline
-void lprocfs_oh_tally(struct obd_histogram *oh, unsigned int value)
-{ return; }
-static inline
-void lprocfs_oh_tally_log2(struct obd_histogram *oh, unsigned int value)
-{ return; }
-static inline
-void lprocfs_oh_clear(struct obd_histogram *oh)
-{ return; }
-static inline
-unsigned long lprocfs_oh_sum(struct obd_histogram *oh)
-{ return 0; }
-static inline
-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 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_WR_ONLY(name, type)
-
-/* lproc_ptlrpc.c */
-#define target_print_req NULL
-
-#endif /* CONFIG_PROC_FS */
-
 #endif /* LPROCFS_SNMP_H */
index 0592f2bca0084d0294ca8791eac3129a76e63234..c7c8fe4cdbcc6a0d252c8b6874f7b0cb131e5d13 100644 (file)
@@ -392,9 +392,6 @@ struct lu_server_seq {
        /* /seq file object device */
        struct dt_object       *lss_obj;
 
-       /* Seq related proc */
-       struct proc_dir_entry   *lss_proc_dir;
-
        /* LUSTRE_SEQ_SERVER or LUSTRE_SEQ_CONTROLLER */
        enum lu_mgr_type       lss_type;
 
index 588cdd5a291c3ae65991b65cce2b1c42da7360ca..c1f08dee3bd6616d704953c69bc664d19a227339 100644 (file)
@@ -70,10 +70,6 @@ struct lu_fld_target {
 };
 
 struct lu_server_fld {
-       /**
-        * Fld dir proc entry. */
-       struct proc_dir_entry    *lsf_proc_dir;
-
        /**
         * /fld file object device */
        struct dt_object        *lsf_obj;
index e65e7d8af666a8afb81ba0e51c833942665af930..998dcd94c1b20d34ba123a5134ac373802d2a1df 100644 (file)
@@ -2952,15 +2952,9 @@ void ptlrpcd_decref(void);
  * @{
  */
 const char *ll_opcode2str(__u32 opcode);
-#if defined (CONFIG_PROC_FS)
 void ptlrpc_lprocfs_register_obd(struct obd_device *obd);
 void ptlrpc_lprocfs_unregister_obd(struct obd_device *obd);
 void ptlrpc_lprocfs_brw(struct ptlrpc_request *req, int bytes);
-#else
-static inline void ptlrpc_lprocfs_register_obd(struct obd_device *obd) {}
-static inline void ptlrpc_lprocfs_unregister_obd(struct obd_device *obd) {}
-static inline void ptlrpc_lprocfs_brw(struct ptlrpc_request *req, int bytes) {}
-#endif
 /** @} */
 
 /* ptlrpc/llog_client.c */
diff --git a/drivers/staging/lustre/lustre/include/lustre_quota.h b/drivers/staging/lustre/lustre/include/lustre_quota.h
deleted file mode 100644 (file)
index 2643f28..0000000
+++ /dev/null
@@ -1,241 +0,0 @@
-/*
- * GPL HEADER START
- *
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 only,
- * as published by the Free Software Foundation.
- *
- * This program 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 version 2 for more details (a copy is included
- * in the LICENSE file that accompanied this code).
- *
- * You should have received a copy of the GNU General Public License
- * version 2 along with this program; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 021110-1307, USA
- *
- * GPL HEADER END
- */
-/*
- * Copyright (c) 2011, 2012, Intel Corporation.
- * Use is subject to license terms.
- */
-
-#ifndef _LUSTRE_QUOTA_H
-#define _LUSTRE_QUOTA_H
-
-/** \defgroup quota quota
- *
- */
-
-#include <linux/fs.h>
-#include <linux/quota.h>
-#include <linux/quotaops.h>
-
-#include "dt_object.h"
-#include "lustre_fid.h"
-#include "lustre_dlm.h"
-
-#ifndef MAX_IQ_TIME
-#define MAX_IQ_TIME  604800     /* (7*24*60*60) 1 week */
-#endif
-
-#ifndef MAX_DQ_TIME
-#define MAX_DQ_TIME  604800     /* (7*24*60*60) 1 week */
-#endif
-
-struct lquota_id_info;
-struct lquota_trans;
-
-/* Gather all quota record type in an union that can be used to read any records
- * from disk. All fields of these records must be 64-bit aligned, otherwise the
- * OSD layer may swab them incorrectly. */
-union lquota_rec {
-       struct lquota_glb_rec   lqr_glb_rec;
-       struct lquota_slv_rec   lqr_slv_rec;
-       struct lquota_acct_rec  lqr_acct_rec;
-};
-
-/* Index features supported by the global index objects
- * Only used for migration purpose and should be removed once on-disk migration
- * is no longer needed */
-extern struct dt_index_features dt_quota_iusr_features;
-extern struct dt_index_features dt_quota_busr_features;
-extern struct dt_index_features dt_quota_igrp_features;
-extern struct dt_index_features dt_quota_bgrp_features;
-
-/* Name used in the configuration logs to identify the default metadata pool
- * (composed of all the MDTs, with pool ID 0) and the default data pool (all
- * the OSTs, with pool ID 0 too). */
-#define QUOTA_METAPOOL_NAME   "mdt="
-#define QUOTA_DATAPOOL_NAME   "ost="
-
-/*
- * Quota Master Target support
- */
-
-/* Request handlers for quota master operations.
- * This is used by the MDT to pass quota/lock requests to the quota master
- * target. This won't be needed any more once the QMT is a real target and
- * does not rely any more on the MDT service threads and namespace. */
-struct qmt_handlers {
-       /* Handle quotactl request from client. */
-       int (*qmth_quotactl)(const struct lu_env *, struct lu_device *,
-                            struct obd_quotactl *);
-
-       /* Handle dqacq/dqrel request from slave. */
-       int (*qmth_dqacq)(const struct lu_env *, struct lu_device *,
-                         struct ptlrpc_request *);
-
-       /* LDLM intent policy associated with quota locks */
-       int (*qmth_intent_policy)(const struct lu_env *, struct lu_device *,
-                                 struct ptlrpc_request *, struct ldlm_lock **,
-                                 int);
-
-       /* Initialize LVB of ldlm resource associated with quota objects */
-       int (*qmth_lvbo_init)(struct lu_device *, struct ldlm_resource *);
-
-       /* Update LVB of ldlm resource associated with quota objects */
-       int (*qmth_lvbo_update)(struct lu_device *, struct ldlm_resource *,
-                               struct ptlrpc_request *, int);
-
-       /* Return size of LVB to be packed in ldlm message */
-       int (*qmth_lvbo_size)(struct lu_device *, struct ldlm_lock *);
-
-       /* Fill request buffer with lvb */
-       int (*qmth_lvbo_fill)(struct lu_device *, struct ldlm_lock *, void *,
-                             int);
-
-       /* Free lvb associated with ldlm resource */
-       int (*qmth_lvbo_free)(struct lu_device *, struct ldlm_resource *);
-};
-
-/* actual handlers are defined in lustre/quota/qmt_handler.c */
-extern struct qmt_handlers qmt_hdls;
-
-/*
- * Quota enforcement support on slaves
- */
-
-struct qsd_instance;
-
-/* The quota slave feature is implemented under the form of a library.
- * The API is the following:
- *
- * - qsd_init(): the user (mostly the OSD layer) should first allocate a qsd
- *            instance via qsd_init(). This creates all required structures
- *            to manage quota enforcement for this target and performs all
- *            low-level initialization which does not involve any lustre
- *            object. qsd_init() should typically be called when the OSD
- *            is being set up.
- *
- * - qsd_prepare(): This sets up on-disk objects associated with the quota slave
- *               feature and initiates the quota reintegration procedure if
- *               needed. qsd_prepare() should typically be called when
- *               ->ldo_prepare is invoked.
- *
- * - qsd_start(): a qsd instance should be started once recovery is completed
- *             (i.e. when ->ldo_recovery_complete is called). This is used
- *             to notify the qsd layer that quota should now be enforced
- *             again via the qsd_op_begin/end functions. The last step of the
- *             reintegration procedure (namely usage reconciliation) will be
- *             completed during start.
- *
- * - qsd_fini(): is used to release a qsd_instance structure allocated with
- *            qsd_init(). This releases all quota slave objects and frees the
- *            structures associated with the qsd_instance.
- *
- * - qsd_op_begin(): is used to enforce quota, it must be called in the
- *                declaration of each operation. qsd_op_end() should then be
- *                invoked later once all operations have been completed in
- *                order to release/adjust the quota space.
- *                Running qsd_op_begin() before qsd_start() isn't fatal and
- *                will return success.
- *                Once qsd_start() has been run, qsd_op_begin() will block
- *                until the reintegration procedure is completed.
- *
- * - qsd_op_end(): performs the post operation quota processing. This must be
- *              called after the operation transaction stopped.
- *              While qsd_op_begin() must be invoked each time a new
- *              operation is declared, qsd_op_end() should be called only
- *              once for the whole transaction.
- *
- * - qsd_op_adjust(): triggers pre-acquire/release if necessary.
- *
- * Below are the function prototypes to be used by OSD layer to manage quota
- * enforcement. Arguments are documented where each function is defined.  */
-
-struct qsd_instance *qsd_init(const struct lu_env *, char *, struct dt_device *,
-                             struct proc_dir_entry *);
-int qsd_prepare(const struct lu_env *, struct qsd_instance *);
-int qsd_start(const struct lu_env *, struct qsd_instance *);
-void qsd_fini(const struct lu_env *, struct qsd_instance *);
-int qsd_op_begin(const struct lu_env *, struct qsd_instance *,
-                struct lquota_trans *, struct lquota_id_info *, int *);
-void qsd_op_end(const struct lu_env *, struct qsd_instance *,
-               struct lquota_trans *);
-void qsd_op_adjust(const struct lu_env *, struct qsd_instance *,
-                  union lquota_id *, int);
-/* This is exported for the ldiskfs quota migration only,
- * see convert_quota_file() */
-int lquota_disk_write_glb(const struct lu_env *, struct dt_object *,
-                         __u64, struct lquota_glb_rec *);
-
-/*
- * Quota information attached to a transaction
- */
-
-struct lquota_entry;
-
-struct lquota_id_info {
-       /* quota identifier */
-       union lquota_id          lqi_id;
-
-       /* USRQUOTA or GRPQUOTA for now, could be expanded for
-        * directory quota or other types later.  */
-       int                      lqi_type;
-
-       /* inodes or kbytes to be consumed or released, it could
-        * be negative when releasing space.  */
-       long long                lqi_space;
-
-       /* quota slave entry structure associated with this ID */
-       struct lquota_entry     *lqi_qentry;
-
-       /* whether we are reporting blocks or inodes */
-       bool                     lqi_is_blk;
-};
-
-/* Since we enforce only inode quota in meta pool (MDTs), and block quota in
- * data pool (OSTs), there are at most 4 quota ids being enforced in a single
- * transaction, which is chown transaction:
- * original uid and gid, new uid and gid.
- *
- * This value might need to be revised when directory quota is added.  */
-#define QUOTA_MAX_TRANSIDS    4
-
-/* all qids involved in a single transaction */
-struct lquota_trans {
-       unsigned short          lqt_id_cnt;
-       struct lquota_id_info   lqt_ids[QUOTA_MAX_TRANSIDS];
-};
-
-/* flags for quota local enforcement */
-#define QUOTA_FL_OVER_USRQUOTA  0x01
-#define QUOTA_FL_OVER_GRPQUOTA  0x02
-#define QUOTA_FL_SYNC     0x04
-
-#define IS_LQUOTA_RES(res)                                             \
-       (res->lr_name.name[LUSTRE_RES_ID_SEQ_OFF] == FID_SEQ_QUOTA ||   \
-        res->lr_name.name[LUSTRE_RES_ID_SEQ_OFF] == FID_SEQ_QUOTA_GLB)
-
-/* helper function used by MDT & OFD to retrieve quota accounting information
- * on slave */
-int lquotactl_slv(const struct lu_env *, struct dt_device *,
-                 struct obd_quotactl *);
-/** @} quota */
-#endif /* _LUSTRE_QUOTA_H */
index 63f5224ecb97d6d410a4b3ca0e3f94a0b02ee76a..36ed78127830b001d574baad59f9da04e5d12b28 100644 (file)
@@ -139,14 +139,7 @@ int class_add_conn(struct obd_device *obd, struct lustre_cfg *lcfg);
 int class_add_uuid(const char *uuid, __u64 nid);
 
 /*obdecho*/
-#if defined (CONFIG_PROC_FS)
 extern void lprocfs_echo_init_vars(struct lprocfs_static_vars *lvars);
-#else
-static inline void lprocfs_echo_init_vars(struct lprocfs_static_vars *lvars)
-{
-       memset(lvars, 0, sizeof(*lvars));
-}
-#endif
 
 #define CFG_F_START     0x01   /* Set when we start updating from a log */
 #define CFG_F_MARKER    0x02   /* We are within a maker */
@@ -356,7 +349,6 @@ static inline int obd_check_dev_active(struct obd_device *obd)
        return rc;
 }
 
-#if defined (CONFIG_PROC_FS)
 #define OBD_COUNTER_OFFSET(op)                           \
        ((offsetof(struct obd_ops, o_ ## op) -            \
          offsetof(struct obd_ops, o_iocontrol))                \
@@ -406,13 +398,6 @@ static inline int obd_check_dev_active(struct obd_device *obd)
                                (export)->exp_md_stats, coffset);           \
        }
 
-#else
-#define OBD_COUNTER_OFFSET(op)
-#define OBD_COUNTER_INCREMENT(obd, op)
-#define EXP_COUNTER_INCREMENT(exp, op)
-#define MD_COUNTER_INCREMENT(obd, op)
-#define EXP_MD_COUNTER_INCREMENT(exp, op)
-#endif
 
 #define OBD_CHECK_MD_OP(obd, op, err)                     \
 do {                                                       \
index c0136ee778e32e478b08f9a9089afe98956cc343..73e2d4880b9b392c924b7f1e6e8e0fb7bd8648f3 100644 (file)
@@ -509,7 +509,6 @@ extern atomic_t libcfs_kmemory;
 
 extern void obd_update_maxusage(void);
 
-#if defined (CONFIG_PROC_FS)
 #define obd_memory_add(size)                                             \
        lprocfs_counter_add(obd_memory, OBD_MEMORY_STAT, (long)(size))
 #define obd_memory_sub(size)                                             \
@@ -530,46 +529,6 @@ extern void obd_update_maxusage(void);
 extern __u64 obd_memory_max(void);
 extern __u64 obd_pages_max(void);
 
-#else
-
-extern __u64 obd_alloc;
-extern __u64 obd_pages;
-
-extern __u64 obd_max_alloc;
-extern __u64 obd_max_pages;
-
-static inline void obd_memory_add(long size)
-{
-       obd_alloc += size;
-       if (obd_alloc > obd_max_alloc)
-               obd_max_alloc = obd_alloc;
-}
-
-static inline void obd_memory_sub(long size)
-{
-       obd_alloc -= size;
-}
-
-static inline void obd_pages_add(int order)
-{
-       obd_pages += 1<< order;
-       if (obd_pages > obd_max_pages)
-               obd_max_pages = obd_pages;
-}
-
-static inline void obd_pages_sub(int order)
-{
-       obd_pages -= 1<< order;
-}
-
-#define obd_memory_sum() (obd_alloc)
-#define obd_pages_sum()  (obd_pages)
-
-#define obd_memory_max() (obd_max_alloc)
-#define obd_pages_max() (obd_max_pages)
-
-#endif
-
 #define OBD_DEBUG_MEMUSAGE (1)
 
 #if OBD_DEBUG_MEMUSAGE
index 50e049b01a62ace9acd3d06235950ad8e5081c54..cdb63665a11389ba685dc6e7b05462f0158cee17 100644 (file)
@@ -955,7 +955,7 @@ void ldlm_namespace_free_post(struct ldlm_namespace *ns)
  * proc1: destroy import
  *     class_disconnect_export(grab cl_sem) ->
  *           -> ldlm_namespace_free ->
- *           -> lprocfs_remove(grab _lprocfs_lock).
+ *           -> ldebugfs_remove(grab _lprocfs_lock).
  * proc2: read proc info
  *     lprocfs_fops_read(grab _lprocfs_lock) ->
  *           -> osc_rd_active, etc(grab cl_sem).
index f0ee76abfd5a4ad8d2d34096688fbafb5c7e3f90..83b1a708b1e3d6f470ae8c9ab8840fa0cf0ae2c9 100644 (file)
@@ -49,7 +49,6 @@
 #include <linux/file.h>
 #include <linux/list.h>
 
-#include <linux/proc_fs.h>
 #include <linux/sysctl.h>
 
 # define DEBUG_SUBSYSTEM S_LNET
index 7d70115d5bc783dbcd37c497a6378ced22220ea8..2cbc46838fdd83b0861ac8b98f654eb470dbf56b 100644 (file)
@@ -5,7 +5,6 @@ lustre-y := dcache.o dir.o file.o llite_close.o llite_lib.o llite_nfs.o \
            xattr.o xattr_cache.o remote_perm.o llite_rmtacl.o llite_capa.o \
            rw26.o super25.o statahead.o \
            ../lclient/glimpse.o ../lclient/lcommon_cl.o ../lclient/lcommon_misc.o \
-           vvp_dev.o vvp_page.o vvp_lock.o vvp_io.o vvp_object.o
+           vvp_dev.o vvp_page.o vvp_lock.o vvp_io.o vvp_object.o lproc_llite.o
 
-lustre-$(CONFIG_PROC_FS) += lproc_llite.o
 llite_lloop-y := lloop.o
index b30eb85a53c958b9f6c2074c2552f2a29e8c455f..f097d4d167d525c2054858fa59345d5f8ad94ed6 100644 (file)
@@ -663,7 +663,6 @@ void ll_ra_read_ex(struct file *f, struct ll_ra_read *rar);
 struct ll_ra_read *ll_ra_read_get(struct file *f);
 
 /* llite/lproc_llite.c */
-#if defined (CONFIG_PROC_FS)
 int ldebugfs_register_mountpoint(struct dentry *parent,
                                 struct super_block *sb, char *osc, char *mdc);
 void ldebugfs_unregister_mountpoint(struct ll_sb_info *sbi);
@@ -672,26 +671,6 @@ void lprocfs_llite_init_vars(struct lprocfs_static_vars *lvars);
 void ll_rw_stats_tally(struct ll_sb_info *sbi, pid_t pid,
                       struct ll_file_data *file, loff_t pos,
                       size_t count, int rw);
-#else /* CONFIG_PROC_FS */
-static inline
-int ldebugfs_register_mountpoint(struct dentry *parent,
-                                struct super_block *sb, char *osc, char *mdc)
-{ return 0; }
-static inline
-void ldebugfs_unregister_mountpoint(struct ll_sb_info *sbi)
-{}
-static inline
-void ll_stats_ops_tally(struct ll_sb_info *sbi, int op, int count)
-{}
-static inline void lprocfs_llite_init_vars(struct lprocfs_static_vars *lvars)
-{
-       memset(lvars, 0, sizeof(*lvars));
-}
-static inline void ll_rw_stats_tally(struct ll_sb_info *sbi, pid_t pid,
-                                    struct ll_file_data *file, loff_t pos,
-                                    size_t count, int rw) {}
-#endif /* CONFIG_PROC_FS */
-
 
 /* llite/dir.c */
 void ll_release_page(struct page *page, int remove);
index 6d9622acb44fda0cad9232eca81f4cfbb2a3ef2e..2aae5f5fa8ea7aacb346557084f5be3e65a32f0c 100644 (file)
@@ -534,7 +534,7 @@ static int vvp_dump_pgcache_seq_open(struct inode *inode, struct file *filp)
                return rc;
 
        seq = filp->private_data;
-       seq->private = inode->i_private ?: PDE_DATA(inode);
+       seq->private = inode->i_private;
 
        return 0;
 }
index a7a15369af15982b220719b4f2ac73e9b624d720..1a24299791d79ae9a84eff2adedff04e20452e69 100644 (file)
@@ -1,3 +1,2 @@
 obj-$(CONFIG_LUSTRE_FS) += lmv.o
-lmv-y := lmv_obd.o lmv_intent.o lmv_fld.o
-lmv-$(CONFIG_PROC_FS) += lproc_lmv.o
+lmv-y := lmv_obd.o lmv_intent.o lmv_fld.o lproc_lmv.o
index 852d78721ca9c5a4fa93e714163ff05792a40a2e..b808728daee7ad32fa681883c7af6d654525b044 100644 (file)
@@ -144,14 +144,8 @@ struct lmv_tgt_desc
 *lmv_locate_mds(struct lmv_obd *lmv, struct md_op_data *op_data,
                struct lu_fid *fid);
 /* lproc_lmv.c */
-#if defined(CONFIG_PROC_FS)
 void lprocfs_lmv_init_vars(struct lprocfs_static_vars *lvars);
-#else
-static inline void lprocfs_lmv_init_vars(struct lprocfs_static_vars *lvars)
-{
-       memset(lvars, 0, sizeof(*lvars));
-}
-#endif
+
 extern struct file_operations lmv_proc_target_fops;
 
 #endif
index 6fe56a24b1657041282b1841d0085416ae1cb055..e4cc0db21014fadaff158ffd47b9e884cc29dc39 100644 (file)
@@ -2,5 +2,4 @@ obj-$(CONFIG_LUSTRE_FS) += lov.o
 lov-y := lov_obd.o lov_pack.o lov_offset.o lov_merge.o \
         lov_request.o lov_ea.o lov_dev.o lov_object.o lov_page.o  \
         lov_lock.o lov_io.o lovsub_dev.o lovsub_object.o lovsub_page.o      \
-        lovsub_lock.o lovsub_io.o lov_pool.o
-lov-$(CONFIG_PROC_FS) += lproc_lov.o
+        lovsub_lock.o lovsub_io.o lov_pool.o lproc_lov.o
index b644acc9b034c0c36cf726aecfbd65e33f8d995e..5e8bcc6ba01a3fe709e1858eaccc234e886255d3 100644 (file)
@@ -265,15 +265,8 @@ void lsm_free_plain(struct lov_stripe_md *lsm);
 void dump_lsm(unsigned int level, const struct lov_stripe_md *lsm);
 
 /* lproc_lov.c */
-#if defined (CONFIG_PROC_FS)
 extern const struct file_operations lov_proc_target_fops;
 void lprocfs_lov_init_vars(struct lprocfs_static_vars *lvars);
-#else
-static inline void lprocfs_lov_init_vars(struct lprocfs_static_vars *lvars)
-{
-       memset(lvars, 0, sizeof(*lvars));
-}
-#endif
 
 /* lov_cl.c */
 extern struct lu_device_type lov_device_type;
index 30a29fd86e8ead26214eda8c8c55b66c15a412c4..3c46c368cf134fbfae8ccb4292482072019ecf4e 100644 (file)
@@ -152,7 +152,6 @@ cfs_hash_ops_t pool_hash_operations = {
 
 };
 
-#if defined (CONFIG_PROC_FS)
 /* ifdef needed for liblustre support */
 /*
  * pool /proc seq_file methods
@@ -294,7 +293,6 @@ static struct file_operations pool_proc_operations = {
        .llseek  = seq_lseek,
        .release        = seq_release,
 };
-#endif /* CONFIG_PROC_FS */
 
 void lov_dump_pool(int level, struct pool_desc *pool)
 {
index 2516551a6dc35dcb45bd89a539a27b4f2aedaf7e..99ba9ff0d83a72a428fae561a4f36946a077b07e 100644 (file)
@@ -1,3 +1,2 @@
 obj-$(CONFIG_LUSTRE_FS) += mdc.o
-mdc-y := mdc_request.o mdc_reint.o mdc_lib.o mdc_locks.o
-mdc-$(CONFIG_PROC_FS) += lproc_mdc.o
+mdc-y := mdc_request.o mdc_reint.o mdc_lib.o mdc_locks.o lproc_mdc.o
index 858d568a896fe5193fd84e7b8c57a3527676a233..1c95f87a0e2ae62aaeb03683ef41b03fa13a15b6 100644 (file)
@@ -84,7 +84,7 @@ LUSTRE_RW_ATTR(max_rpcs_in_flight);
 
 static int mdc_kuc_open(struct inode *inode, struct file *file)
 {
-       return single_open(file, NULL, inode->i_private ?: PDE_DATA(inode));
+       return single_open(file, NULL, inode->i_private);
 }
 
 /* temporary for testing */
index 81780c943a08aadb484c82f16fb8598eb63f101e..4d149435e949acaf34d6a35212f3ff54ffd0d731 100644 (file)
 #include "../include/lustre_mdc.h"
 #include "../include/lustre_mds.h"
 
-#if defined CONFIG_PROC_FS
 void lprocfs_mdc_init_vars(struct lprocfs_static_vars *lvars);
-#else
-static inline void lprocfs_mdc_init_vars(struct lprocfs_static_vars *lvars)
-{
-       memset(lvars, 0, sizeof(*lvars));
-}
-#endif
 
 void mdc_pack_body(struct ptlrpc_request *req, const struct lu_fid *fid,
                   struct obd_capa *oc, __u64 valid, int ea_size,
index cc6e9f51a8e889ab060a114a8cc071af8cf50db4..8ea29a89cf508eb2d6641f65dd88e12eaae69fa6 100644 (file)
@@ -1,3 +1,2 @@
 obj-$(CONFIG_LUSTRE_FS) += mgc.o
-mgc-y := mgc_request.o
-mgc-$(CONFIG_PROC_FS) += lproc_mgc.o
+mgc-y := mgc_request.o lproc_mgc.o
index a6f8b3ced2e7d9fdd41c977ad7bfb5c9221f3d67..82fb8f46e037d6260c63fb75f928630f0a5bff6a 100644 (file)
 #include "../include/lustre_log.h"
 #include "../include/lustre_export.h"
 
-#if defined (CONFIG_PROC_FS)
 void lprocfs_mgc_init_vars(struct lprocfs_static_vars *lvars);
 int lprocfs_mgc_rd_ir_state(struct seq_file *m, void *data);
-#else
-static inline void lprocfs_mgc_init_vars(struct lprocfs_static_vars *lvars)
-{
-       memset(lvars, 0, sizeof(*lvars));
-}
-static inline int lprocfs_mgc_rd_ir_state(struct seq_file *m, void *data)
-{
-       return 0;
-}
-#endif  /* CONFIG_PROC_FS */
 
 int mgc_process_log(struct obd_device *mgc, struct config_llog_data *cld);
 
index 517b8ce1a44ab45755b9cfb9c965248ef8464ef1..174dfc32876b5860b5131b31a1b36f330e0ddbba 100644 (file)
@@ -448,7 +448,6 @@ static int config_log_end(char *logname, struct config_llog_instance *cfg)
        return rc;
 }
 
-#if defined (CONFIG_PROC_FS)
 int lprocfs_mgc_rd_ir_state(struct seq_file *m, void *data)
 {
        struct obd_device       *obd = data;
@@ -477,7 +476,6 @@ int lprocfs_mgc_rd_ir_state(struct seq_file *m, void *data)
        LPROCFS_CLIMP_EXIT(obd);
        return 0;
 }
-#endif
 
 /* reenqueue any lost locks */
 #define RQ_RUNNING 0x1
index e894681797c238a340c4b84d26de8d0d2e22ab4b..d0f70b41acf6f050f37d4f3372dc943db37ed469 100644 (file)
@@ -6,6 +6,4 @@ obdclass-y := linux/linux-module.o linux/linux-obdo.o linux/linux-sysctl.o \
              lustre_handles.o lustre_peer.o \
              statfs_pack.o obdo.o obd_config.o obd_mount.o \
              lu_object.o dt_object.o capa.o cl_object.o   \
-             cl_page.o cl_lock.o cl_io.o lu_ref.o acl.o
-
-obdclass-$(CONFIG_PROC_FS) += lprocfs_counters.o
+             cl_page.o cl_lock.o cl_io.o lu_ref.o acl.o lprocfs_counters.o
index 6e967af2f6b4145dc4c479f2f69f1f78d3c33142..1bc37566b3a50a3dbe106b26a7eb1793346aa9f1 100644 (file)
@@ -506,15 +506,8 @@ int obd_init_checks(void)
        return ret;
 }
 
-#if defined (CONFIG_PROC_FS)
 extern int class_procfs_init(void);
 extern int class_procfs_clean(void);
-#else
-static inline int class_procfs_init(void)
-{ return 0; }
-static inline int class_procfs_clean(void)
-{ return 0; }
-#endif
 
 static int __init init_obdclass(void)
 {
@@ -529,24 +522,22 @@ static int __init init_obdclass(void)
        spin_lock_init(&obd_types_lock);
        obd_zombie_impexp_init();
 
-       if (IS_ENABLED(CONFIG_PROC_FS)) {
-               obd_memory = lprocfs_alloc_stats(OBD_STATS_NUM,
-                                                LPROCFS_STATS_FLAG_NONE |
-                                                LPROCFS_STATS_FLAG_IRQ_SAFE);
+       obd_memory = lprocfs_alloc_stats(OBD_STATS_NUM,
+                                        LPROCFS_STATS_FLAG_NONE |
+                                        LPROCFS_STATS_FLAG_IRQ_SAFE);
 
-               if (obd_memory == NULL) {
-                       CERROR("kmalloc of 'obd_memory' failed\n");
-                       return -ENOMEM;
-               }
-
-               lprocfs_counter_init(obd_memory, OBD_MEMORY_STAT,
-                                    LPROCFS_CNTR_AVGMINMAX,
-                                    "memused", "bytes");
-               lprocfs_counter_init(obd_memory, OBD_MEMORY_PAGES_STAT,
-                                    LPROCFS_CNTR_AVGMINMAX,
-                                    "pagesused", "pages");
+       if (obd_memory == NULL) {
+               CERROR("kmalloc of 'obd_memory' failed\n");
+               return -ENOMEM;
        }
 
+       lprocfs_counter_init(obd_memory, OBD_MEMORY_STAT,
+                            LPROCFS_CNTR_AVGMINMAX,
+                            "memused", "bytes");
+       lprocfs_counter_init(obd_memory, OBD_MEMORY_PAGES_STAT,
+                            LPROCFS_CNTR_AVGMINMAX,
+                            "pagesused", "pages");
+
        err = obd_init_checks();
        if (err == -EOVERFLOW)
                return err;
@@ -620,7 +611,6 @@ void obd_update_maxusage(void)
 }
 EXPORT_SYMBOL(obd_update_maxusage);
 
-#if defined (CONFIG_PROC_FS)
 __u64 obd_memory_max(void)
 {
        __u64 ret;
@@ -644,7 +634,6 @@ __u64 obd_pages_max(void)
        return ret;
 }
 EXPORT_SYMBOL(obd_pages_max);
-#endif
 
 /* liblustre doesn't call cleanup_obdclass, apparently.  we carry on in this
  * ifdef to the end of the file to cover module and versioning goo.*/
index b1eee0a6dc9a1effdae32918133e46d16834321a..6ce407ff8318c10b72f4b04321426b376f9f0e41 100644 (file)
@@ -49,8 +49,6 @@
 /* fid_be_to_cpu() */
 #include "../include/lustre_fid.h"
 
-#include "../include/lustre_quota.h"
-
 /* context key constructor/destructor: dt_global_key_init, dt_global_key_fini */
 LU_KEY_INIT(dt_global, struct dt_thread_info);
 LU_KEY_FINI(dt_global, struct dt_thread_info);
@@ -939,8 +937,6 @@ out:
 }
 EXPORT_SYMBOL(dt_index_read);
 
-#if defined (CONFIG_PROC_FS)
-
 int lprocfs_dt_rd_blksize(char *page, char **start, off_t off,
                          int count, int *eof, void *data)
 {
@@ -1055,5 +1051,3 @@ int lprocfs_dt_rd_filesfree(char *page, char **start, off_t off,
        return rc;
 }
 EXPORT_SYMBOL(lprocfs_dt_rd_filesfree);
-
-#endif /* CONFIG_PROC_FS */
index 50c3d1de24cb12146f91381b69b6a230fb14bfac..e3c6dcb42cffb35d59dc04e8b900c7e69ba53c3b 100644 (file)
@@ -53,7 +53,6 @@
 #include <linux/fcntl.h>
 #include <linux/delay.h>
 #include <linux/skbuff.h>
-#include <linux/proc_fs.h>
 #include <linux/fs.h>
 #include <linux/poll.h>
 #include <linux/list.h>
index 8927e24a599f7bc19ece60cab459cd8a1a9ff6a0..54f0a81f7b518dfa7b2d20a5dab8d70002578bbc 100644 (file)
@@ -38,7 +38,6 @@
 #include <linux/sysctl.h>
 #include <linux/sched.h>
 #include <linux/mm.h>
-#include <linux/proc_fs.h>
 #include <linux/slab.h>
 #include <linux/stat.h>
 #include <linux/ctype.h>
index f44c74611d3b0d736091aa8df87678913eacaa44..17e7c18078639d946f2a3ad7eb45d862358f5d81 100644 (file)
@@ -221,8 +221,6 @@ int lprocfs_write_frac_helper(const char __user *buffer, unsigned long count,
 }
 EXPORT_SYMBOL(lprocfs_write_frac_helper);
 
-#if defined (CONFIG_PROC_FS)
-
 static int lprocfs_no_percpu_stats;
 module_param(lprocfs_no_percpu_stats, int, 0644);
 MODULE_PARM_DESC(lprocfs_no_percpu_stats, "Do not alloc percpu data for lprocfs stats");
@@ -266,29 +264,6 @@ struct dentry *ldebugfs_add_simple(struct dentry *root,
 }
 EXPORT_SYMBOL(ldebugfs_add_simple);
 
-struct proc_dir_entry *lprocfs_add_simple(struct proc_dir_entry *root,
-                                    char *name, void *data,
-                                    struct file_operations *fops)
-{
-       struct proc_dir_entry *proc;
-       umode_t mode = 0;
-
-       if (root == NULL || name == NULL || fops == NULL)
-               return ERR_PTR(-EINVAL);
-
-       if (fops->read)
-               mode = 0444;
-       if (fops->write)
-               mode |= 0200;
-       proc = proc_create_data(name, mode, root, fops, data);
-       if (!proc) {
-               CERROR("LprocFS: No memory to create /proc entry %s", name);
-               return ERR_PTR(-ENOMEM);
-       }
-       return proc;
-}
-EXPORT_SYMBOL(lprocfs_add_simple);
-
 struct dentry *ldebugfs_add_symlink(const char *name, struct dentry *parent,
                                    const char *format, ...)
 {
@@ -352,46 +327,6 @@ int ldebugfs_add_vars(struct dentry *parent,
 }
 EXPORT_SYMBOL(ldebugfs_add_vars);
 
-/**
- * Add /proc entries.
- *
- * \param root [in]  The parent proc entry on which new entry will be added.
- * \param list [in]  Array of proc entries to be added.
- * \param data [in]  The argument to be passed when entries read/write routines
- *                are called through /proc file.
- *
- * \retval 0   on success
- *      < 0 on error
- */
-int lprocfs_add_vars(struct proc_dir_entry *root, struct lprocfs_vars *list,
-                    void *data)
-{
-       if (root == NULL || list == NULL)
-               return -EINVAL;
-
-       while (list->name != NULL) {
-               struct proc_dir_entry *proc;
-               umode_t mode = 0;
-
-               if (list->proc_mode != 0000) {
-                       mode = list->proc_mode;
-               } else if (list->fops) {
-                       if (list->fops->read)
-                               mode = 0444;
-                       if (list->fops->write)
-                               mode |= 0200;
-               }
-               proc = proc_create_data(list->name, mode, root,
-                                       list->fops ?: &lprocfs_generic_fops,
-                                       list->data ?: data);
-               if (proc == NULL)
-                       return -ENOMEM;
-               list++;
-       }
-       return 0;
-}
-EXPORT_SYMBOL(lprocfs_add_vars);
-
 void ldebugfs_remove(struct dentry **entryp)
 {
        debugfs_remove(*entryp);
@@ -399,20 +334,6 @@ void ldebugfs_remove(struct dentry **entryp)
 }
 EXPORT_SYMBOL(ldebugfs_remove);
 
-void lprocfs_remove(struct proc_dir_entry **rooth)
-{
-       proc_remove(*rooth);
-       *rooth = NULL;
-}
-EXPORT_SYMBOL(lprocfs_remove);
-
-void lprocfs_remove_proc_entry(const char *name, struct proc_dir_entry *parent)
-{
-       LASSERT(parent != NULL);
-       remove_proc_entry(name, parent);
-}
-EXPORT_SYMBOL(lprocfs_remove_proc_entry);
-
 struct dentry *ldebugfs_register(const char *name,
                                 struct dentry *parent,
                                 struct lprocfs_vars *list, void *data)
@@ -439,30 +360,6 @@ out:
 }
 EXPORT_SYMBOL(ldebugfs_register);
 
-struct proc_dir_entry *lprocfs_register(const char *name,
-                                       struct proc_dir_entry *parent,
-                                       struct lprocfs_vars *list, void *data)
-{
-       struct proc_dir_entry *entry;
-
-       entry = proc_mkdir(name, parent);
-       if (entry == NULL) {
-               entry = ERR_PTR(-ENOMEM);
-               goto out;
-       }
-
-       if (list != NULL) {
-               int rc = lprocfs_add_vars(entry, list, data);
-               if (rc != 0) {
-                       lprocfs_remove(&entry);
-                       entry = ERR_PTR(rc);
-               }
-       }
-out:
-       return entry;
-}
-EXPORT_SYMBOL(lprocfs_register);
-
 /* Generic callbacks */
 int lprocfs_rd_uint(struct seq_file *m, void *data)
 {
@@ -1337,7 +1234,7 @@ static int lprocfs_stats_seq_open(struct inode *inode, struct file *file)
                return rc;
 
        seq = file->private_data;
-       seq->private = inode->i_private ?: PDE_DATA(inode);
+       seq->private = inode->i_private;
 
        return 0;
 }
@@ -1367,21 +1264,6 @@ int ldebugfs_register_stats(struct dentry *parent, const char *name,
 }
 EXPORT_SYMBOL(ldebugfs_register_stats);
 
-int lprocfs_register_stats(struct proc_dir_entry *root, const char *name,
-                          struct lprocfs_stats *stats)
-{
-       struct proc_dir_entry *entry;
-       LASSERT(root != NULL);
-
-       entry = proc_create_data(name, 0644, root,
-                                &lprocfs_stats_seq_fops, stats);
-       if (entry == NULL)
-               return -ENOMEM;
-
-       return 0;
-}
-EXPORT_SYMBOL(lprocfs_register_stats);
-
 void lprocfs_counter_init(struct lprocfs_stats *stats, int index,
                          unsigned conf, const char *name, const char *units)
 {
@@ -1854,35 +1736,16 @@ int ldebugfs_seq_create(struct dentry *parent,
 }
 EXPORT_SYMBOL(ldebugfs_seq_create);
 
-int lprocfs_seq_create(struct proc_dir_entry *parent,
-                      const char *name,
-                      umode_t mode,
-                      const struct file_operations *seq_fops,
-                      void *data)
-{
-       struct proc_dir_entry *entry;
-
-       /* Disallow secretly (un)writable entries. */
-       LASSERT((seq_fops->write == NULL) == ((mode & 0222) == 0));
-       entry = proc_create_data(name, mode, parent, seq_fops, data);
-
-       if (entry == NULL)
-               return -ENOMEM;
-
-       return 0;
-}
-EXPORT_SYMBOL(lprocfs_seq_create);
-
-int lprocfs_obd_seq_create(struct obd_device *dev,
-                          const char *name,
-                          umode_t mode,
-                          const struct file_operations *seq_fops,
-                          void *data)
+int ldebugfs_obd_seq_create(struct obd_device *dev,
+                           const char *name,
+                           umode_t mode,
+                           const struct file_operations *seq_fops,
+                           void *data)
 {
        return ldebugfs_seq_create(dev->obd_debugfs_entry, name,
                                   mode, seq_fops, data);
 }
-EXPORT_SYMBOL(lprocfs_obd_seq_create);
+EXPORT_SYMBOL(ldebugfs_obd_seq_create);
 
 void lprocfs_oh_tally(struct obd_histogram *oh, unsigned int value)
 {
@@ -1938,8 +1801,6 @@ int lprocfs_obd_rd_max_pages_per_rpc(struct seq_file *m, void *data)
 }
 EXPORT_SYMBOL(lprocfs_obd_rd_max_pages_per_rpc);
 
-#endif
-
 ssize_t lustre_attr_show(struct kobject *kobj,
                         struct attribute *attr, char *buf)
 {
index 4458faad1b1a7042f372d1ba3f58f0d3511f74dd..eae66066035890f9c4ecdc5ecda085fe5851f622 100644 (file)
@@ -1989,14 +1989,10 @@ void lu_global_fini(void)
 
 static __u32 ls_stats_read(struct lprocfs_stats *stats, int idx)
 {
-#if defined (CONFIG_PROC_FS)
        struct lprocfs_counter ret;
 
        lprocfs_stats_collect(stats, idx, &ret);
        return (__u32)ret.lc_count;
-#else
-       return 0;
-#endif
 }
 
 /**
index 54927fba4eb463a914c0f266d20598f37b8c0edb..37cdeea9ac496464216dff9832272d4f8bdcf142 100644 (file)
@@ -1,4 +1,3 @@
 obj-$(CONFIG_LUSTRE_FS) += osc.o
 osc-y := osc_request.o osc_dev.o osc_object.o \
-        osc_page.o osc_lock.o osc_io.o osc_quota.o osc_cache.o
-osc-$(CONFIG_PROC_FS) += lproc_osc.o
+        osc_page.o osc_lock.o osc_io.o osc_quota.o osc_cache.o lproc_osc.o
index 0ba2c36ace442b04aa51875d6e147f93c36e1d40..9dc84ba7aa55026e346ffec3e1e4325f9ad0aa1d 100644 (file)
@@ -741,8 +741,8 @@ int lproc_osc_attach_seqstat(struct obd_device *dev)
        rc = ldebugfs_seq_create(dev->obd_debugfs_entry, "osc_stats", 0644,
                                 &osc_stats_fops, dev);
        if (rc == 0)
-               rc = lprocfs_obd_seq_create(dev, "rpc_stats", 0644,
-                                           &osc_rpc_stats_fops, dev);
+               rc = ldebugfs_obd_seq_create(dev, "rpc_stats", 0644,
+                                            &osc_rpc_stats_fops, dev);
 
        return rc;
 }
index af96c7bc7764d763791f03de2b4c48d148d17110..470698b0dd75280ca8f085dddc5e2b9836a356dd 100644 (file)
@@ -136,16 +136,8 @@ extern spinlock_t osc_ast_guard;
 int osc_cleanup(struct obd_device *obd);
 int osc_setup(struct obd_device *obd, struct lustre_cfg *lcfg);
 
-#if defined (CONFIG_PROC_FS)
 int lproc_osc_attach_seqstat(struct obd_device *dev);
 void lprocfs_osc_init_vars(struct lprocfs_static_vars *lvars);
-#else
-static inline int lproc_osc_attach_seqstat(struct obd_device *dev) {return 0;}
-static inline void lprocfs_osc_init_vars(struct lprocfs_static_vars *lvars)
-{
-       memset(lvars, 0, sizeof(*lvars));
-}
-#endif
 
 extern struct lu_device_type osc_device_type;
 
index fb50cd4c65b6536aaeed8e9802d81836f9fa0217..24bbac19ddd1bdc3bc78c2e534a7d1b17751beda 100644 (file)
@@ -15,6 +15,5 @@ ptlrpc_objs += pers.o lproc_ptlrpc.o wiretest.o layout.o
 ptlrpc_objs += sec.o sec_bulk.o sec_gc.o sec_config.o
 ptlrpc_objs += sec_null.o sec_plain.o nrs.o nrs_fifo.o
 
-ptlrpc-y := $(ldlm_objs) $(ptlrpc_objs)
-ptlrpc-$(CONFIG_PROC_FS) += sec_lproc.o
+ptlrpc-y := $(ldlm_objs) $(ptlrpc_objs) sec_lproc.o
 ptlrpc-$(CONFIG_LUSTRE_TRANSLATE_ERRNOS) += errno.o
index cf5196a25fd876c74ce72224c8ade4ee2b534288..1362160983a9e32d1a6833c6d36b7ac9eebcd2c5 100644 (file)
@@ -256,7 +256,6 @@ ptlrpc_ldebugfs_register(struct dentry *root, char *dir,
        }
 }
 
-#if defined(CONFIG_PROC_FS)
 static int
 ptlrpc_lprocfs_req_history_len_seq_show(struct seq_file *m, void *v)
 {
@@ -1237,7 +1236,7 @@ int lprocfs_wr_evict_client(struct file *file, const char __user *buffer,
        /* Kludge code(deadlock situation): the lprocfs lock has been held
         * since the client is evicted by writing client's
         * uuid/nid to procfs "evict_client" entry. However,
-        * obd_export_evict_by_uuid() will call lprocfs_remove() to destroy
+        * obd_export_evict_by_uuid() will call ldebugfs_remove() to destroy
         * the proc entries under the being destroyed export{}, so I have
         * to drop the lock at first here.
         * - jay, jxiong@clusterfs.com */
@@ -1390,5 +1389,3 @@ int lprocfs_wr_pinger_recov(struct file *file, const char __user *buffer,
 
 }
 EXPORT_SYMBOL(lprocfs_wr_pinger_recov);
-
-#endif /* CONFIG_PROC_FS */
index 9f9ef9a24b63b070524edbbd00d33cfc48d5653e..6dc3998dcd248cf3b78f524b77bc4ef6f67ed790 100644 (file)
@@ -82,16 +82,10 @@ void ptlrpc_sysfs_unregister_service(struct ptlrpc_service *svc);
 
 void ptlrpc_ldebugfs_register_service(struct dentry *debugfs_entry,
                                      struct ptlrpc_service *svc);
-#if defined(CONFIG_PROC_FS)
 void ptlrpc_lprocfs_unregister_service(struct ptlrpc_service *svc);
 void ptlrpc_lprocfs_rpc_sent(struct ptlrpc_request *req, long amount);
 void ptlrpc_lprocfs_do_request_stat(struct ptlrpc_request *req,
                                     long q_usec, long work_usec);
-#else
-#define ptlrpc_lprocfs_unregister_service(params...) do {} while (0)
-#define ptlrpc_lprocfs_rpc_sent(params...) do {} while (0)
-#define ptlrpc_lprocfs_do_request_stat(params...) do {} while (0)
-#endif /* CONFIG_PROC_FS */
 
 /* NRS */
 
@@ -266,14 +260,8 @@ void sptlrpc_enc_pool_fini(void);
 int sptlrpc_proc_enc_pool_seq_show(struct seq_file *m, void *v);
 
 /* sec_lproc.c */
-#if defined(CONFIG_PROC_FS)
 int  sptlrpc_lproc_init(void);
 void sptlrpc_lproc_fini(void);
-#else
-static inline int sptlrpc_lproc_init(void)
-{ return 0; }
-static inline void sptlrpc_lproc_fini(void) {}
-#endif
 
 /* sec_gc.c */
 int sptlrpc_gc_init(void);
index 549515dd165e49703a101bd541431101bbaef4af..982512febf05fc8cc91fe392ce279342673903f3 100644 (file)
@@ -144,16 +144,16 @@ int sptlrpc_lprocfs_cliobd_attach(struct obd_device *dev)
                return -EINVAL;
        }
 
-       rc = lprocfs_obd_seq_create(dev, "srpc_info", 0444,
-                                   &sptlrpc_info_lprocfs_fops, dev);
+       rc = ldebugfs_obd_seq_create(dev, "srpc_info", 0444,
+                                    &sptlrpc_info_lprocfs_fops, dev);
        if (rc) {
                CERROR("create proc entry srpc_info for %s: %d\n",
                       dev->obd_name, rc);
                return rc;
        }
 
-       rc = lprocfs_obd_seq_create(dev, "srpc_contexts", 0444,
-                                   &sptlrpc_ctxs_lprocfs_fops, dev);
+       rc = ldebugfs_obd_seq_create(dev, "srpc_contexts", 0444,
+                                    &sptlrpc_ctxs_lprocfs_fops, dev);
        if (rc) {
                CERROR("create proc entry srpc_contexts for %s: %d\n",
                       dev->obd_name, rc);