Updating class_obd.c for first delivery of lprocfs

diff --git a/lustre/obdclass/class_obd.c b/lustre/obdclass/class_obd.c
index bfc8ca2..f918c57 100644 (file)
--- a/lustre/obdclass/class_obd.c
+++ b/lustre/obdclass/class_obd.c
@@ -42,6 +42,7 @@
 #include <linux/obd_class.h>
 #include <linux/lustre_debug.h>
 #include <linux/smp_lock.h>
+#include <linux/lprocfs.h>
 
 struct semaphore obd_conf_sem;   /* serialize configuration commands */
 struct obd_device obd_dev[MAX_OBD_DEVICES];
@@ -54,6 +55,284 @@ unsigned long obd_timeout = 100;
 char obd_recovery_upcall[128] = "/usr/lib/lustre/ha_assist";
 
 extern struct obd_type *class_nm_to_type(char *nm);
+/*
+ * LProcFS specific data structures. These define the namespace for
+ * the various device classes. We will need to distribute these
+ * later, to individual modules (e.g. MDS, MDC etc)
+ */
+
+#ifdef LPROCFS_EXISTS
+
+/*
+ * Common OBD namespace for lprocFS (these are used very often)
+ */
+
+char* obd_dir_nm_1[]= {
+        "mgmt%",
+        "mgmt/setup",
+        "mgmt/cleanup",
+        "mgmt/connect",
+        "mgmt/disconnect",
+        0
+};
+
+lprocfs_vars_t obd_var_nm_1[]= {
+        
+        {"num_ops", lprocfs_ll_rd, lprocfs_ll_wr},
+        {"min_time", lprocfs_ll_rd, lprocfs_ll_wr},
+        {"max_time", lprocfs_ll_rd, lprocfs_ll_wr},
+        {"sum_time", lprocfs_ll_rd, lprocfs_ll_wr},
+        {"0", 0, 0}
+};
+
+
+/* 
+ *  MDC Spcific namespace for lprocFS 
+ */
+
+char* mdc_dir_nm_1[]= {
+        "reint",
+        "getstatus",
+        "getattr",
+        "setattr",
+        "open",
+        "readpage",
+        "create",
+        "unlink",
+        "link",
+        "rename",
+        0
+        
+};
+
+/*
+ * Create the MDC groupings
+ */
+
+lprocfs_group_t lprocfs_mdc_nm[]= {
+
+        {obd_dir_nm_1, obd_var_nm_1, e_generic},
+        {mdc_dir_nm_1, obd_var_nm_1, e_generic},
+        {0, 0, 0}
+};
+
+/*
+ * MDS Device Groupings
+ */
+
+char* mds_dir_nm_1[]={
+        "getstatus",
+        "connect",
+        "disconnect_callback",
+        "getattr",
+        "readpage",
+        "open",
+        "close",
+        "create",
+        "unlink",
+        "link",
+        "rename",
+        "reint%",
+        "reint/summary",
+        "reint/setattr",
+        "reint/create",
+        "reint/unlink",
+        "reint/link",
+        "reint/rename",
+        "reint/recreate",
+        0
+};
+
+char* mds_dir_nm_2[]={
+        "mstatfs",
+        0
+        
+};
+
+
+lprocfs_vars_t mds_var_nm_2[]={
+        {"f_type", rd_other, wr_other},
+        {"f_bsize",rd_other, wr_other},
+        {"f_blocks",rd_other, wr_other},
+        {"f_bfree",rd_other, wr_other},
+        {"f_bavail",rd_other, wr_other},
+        {"uuid",rd_string, wr_string},
+        {"0", 0, 0}
+};
+
+
+lprocfs_group_t lprocfs_mds_nm[]={
+         {obd_dir_nm_1, obd_var_nm_1, e_generic},
+         {mds_dir_nm_1, obd_var_nm_1, e_generic},
+         {mds_dir_nm_2, mds_var_nm_2, e_specific}, 
+         {0, 0, 0}
+};
+
+/* 
+ * OSC Namespace
+ */
+
+char* osc_dir_nm_1[]={
+        "create",
+        "destroy",
+        "getattr",
+        "setattr",
+        "open",
+        "close",
+        "brw",
+        "punch",
+        "summary",
+        "cancel",
+        0
+};
+
+lprocfs_group_t lprocfs_osc_nm[]={
+         {obd_dir_nm_1, obd_var_nm_1, e_generic},
+         {osc_dir_nm_1, obd_var_nm_1, e_generic}, 
+         {0, 0, 0}
+};
+
+
+/*
+ * OST, LOV, OBD_FILTER namespace
+ * Note: These namespaces are exactly similar to the osc_dir_namespace
+ * Hence, I use the osc namespace as the base class and add only
+ * those attributes that are missing in osc_dir_namespace.
+ */
+
+char* ost_lov_obdfilter_dir_nm_1[]={
+        "getinfo",
+        0
+
+};
+char* ost_lov_obdfilter_dir_nm_2[]={
+        "ostatfs",
+        0
+}; 
+
+lprocfs_vars_t ost_lov_obdfilter_var_nm_2[]={
+        {"f_type", rd_other, wr_other},
+        {"f_bsize",rd_other, wr_other},
+        {"f_blocks",rd_other, wr_other},
+        {"f_bfree",rd_other, wr_other},
+        {"f_bavail",rd_other, wr_other},
+        {"f_objects", rd_other, wr_other},
+        {"f_ofree", rd_other, wr_other},
+        {"f_objectgroups", rd_other, wr_other},
+        {"f_uuid", rd_string, wr_string},
+        {"0", 0, 0}
+};
+
+
+lprocfs_group_t lprocfs_ost_lov_obdf_nm[]={
+         {obd_dir_nm_1, obd_var_nm_1, e_generic},
+         {osc_dir_nm_1, obd_var_nm_1, e_generic},
+         {ost_lov_obdfilter_dir_nm_1, obd_var_nm_1, e_generic},
+         {ost_lov_obdfilter_dir_nm_2, ost_lov_obdfilter_var_nm_2, e_specific},
+         {0, 0, 0}
+};
+
+/*
+ * LDLM Device namespace
+ */
+
+
+char* ldlm_dir_nm_1[]={
+        "locks%",
+        "locks/enqueus",
+        "locks/cancels",
+        "locks/converts",
+        "locks/matches",
+        0
+};
+ 
+
+lprocfs_vars_t ldlm_var_nm_1[]= {
+        
+        {"num_total", lprocfs_ll_rd, lprocfs_ll_wr},
+        {"num_zerolatency", lprocfs_ll_rd, lprocfs_ll_wr},
+        {"num_zerolatency_inflight", lprocfs_ll_rd, lprocfs_ll_wr},
+        {"num_zerolatency_done", lprocfs_ll_rd, lprocfs_ll_wr},
+        {"nonzero_mintime", lprocfs_ll_rd, lprocfs_ll_wr},
+        {"nonzero_maxtime", lprocfs_ll_rd, lprocfs_ll_wr},
+        {"nonzero_sumtime", lprocfs_ll_rd, lprocfs_ll_wr},
+        {"0", 0, 0}
+
+};
+
+lprocfs_group_t lprocfs_ldlm_nm[]={
+         {obd_dir_nm_1, obd_var_nm_1, e_generic},
+         {ldlm_dir_nm_1, ldlm_var_nm_1, e_generic}, 
+         {0, 0, 0}
+};
+
+/*
+ * Note: Need to add namespace for breaking out locks by device class
+ */
+
+/*
+ * PTLRPC Namespace
+ */
+char* ptlrpc_dir_nm_1[]={
+        "counters",
+        0
+};
+
+lprocfs_vars_t ptlrpc_var_nm_1[]={
+        {"msgs_alloc", lprocfs_ll_rd, lprocfs_ll_wr},
+        {"msgs_max", lprocfs_ll_rd, lprocfs_ll_wr},
+        {"recv_count", lprocfs_ll_rd, lprocfs_ll_wr},
+        {"recv_length", lprocfs_ll_rd, lprocfs_ll_wr},
+        {"send_count", lprocfs_ll_rd, lprocfs_ll_wr},
+        {"send_length", lprocfs_ll_rd, lprocfs_ll_wr},
+        {"portal_kmemory", lprocfs_ll_rd, lprocfs_ll_wr},
+        {"0", 0, 0}
+};
+char* ptlrpc_dir_nm_2[] = {
+        "network",
+        0
+};
+ 
+lprocfs_vars_t ptlrpc_var_nm_2[] = {
+        {"type", rd_string, wr_string},
+        {"mtu", lprocfs_ll_rd, lprocfs_ll_wr},
+        {"rxpackets", lprocfs_ll_rd, lprocfs_ll_wr},
+        {"txpackets", lprocfs_ll_rd, lprocfs_ll_wr},
+        {"txbytes", lprocfs_ll_rd, lprocfs_ll_wr},
+        {"0", 0, 0}
+};
+
+lprocfs_group_t lprocfs_ptlrpc_nm[]={
+         {obd_dir_nm_1, obd_var_nm_1, e_generic},
+         {ptlrpc_dir_nm_1, ptlrpc_var_nm_1, e_generic},
+         {ptlrpc_dir_nm_2, ptlrpc_var_nm_2, e_specific}, 
+         {0, 0, 0}
+};
+
+
+/*
+ * Building the entire device namespace. This will be used during attach and
+ * detach to associate the namespace with the class of the device
+ */
+
+lprocfs_obd_nm_t obd_nm[]={
+        {"mdc", lprocfs_mdc_nm, sizeof(struct lprofiler_gen)},
+        {"mds", lprocfs_mds_nm, sizeof(struct lprofiler_gen)},
+        {"osc", lprocfs_osc_nm, sizeof(struct lprofiler_gen)},
+        {"ost", lprocfs_ost_lov_obdf_nm, sizeof(struct lprofiler_gen)},
+        {"lov", lprocfs_ost_lov_obdf_nm, sizeof(struct lprofiler_gen)},
+        {"obdfilter", lprocfs_ost_lov_obdf_nm, sizeof(struct lprofiler_gen)},
+        {"ldlm", lprocfs_ldlm_nm, sizeof(struct lprofiler_ldlm)},
+        {"ptlrpc", lprocfs_ptlrpc_nm, sizeof(struct lprofiler_ptlrpc)},
+        {"0", 0, 0}
+        
+};
+
+#else
+
+lprocfs_obd_nm_t* obd_nm=0;
+
+#endif
 
 /*  opening /dev/obd */
 static int obd_class_open(struct inode * inode, struct file * file)
@@ -105,6 +384,7 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp,
         int rw = OBD_BRW_READ;
         int err = 0;
         int serialised = 0;
+        int l_idx = 0;
         ENTRY;
 
         switch (cmd)
@@ -326,8 +606,9 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp,
                                         LBUG();
                                 }
                                 memcpy(obd->obd_name, data->ioc_inlbuf2, len);
-                                obd->obd_proc_entry =
+                                /* obd->obd_proc_entry =
                                         proc_lustre_register_obd_device(obd);
+                                */
                         } else {
                                 CERROR("WARNING: unnamed obd device\n");
                                 obd->obd_proc_entry = NULL;
@@ -345,6 +626,23 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp,
                                 }
                                 memcpy(obd->obd_uuid, data->ioc_inlbuf3, len);
                         }
+                          /*
+                         * Get the LprocFS namespace for this device class
+                         */
+                        
+                        l_idx=lprocfs_get_nm(data->ioc_inlbuf1, \
+                                             obd_nm);
+                       
+                        if(l_idx<0){
+                                CERROR("Non-existent device class"
+                                       "or proc/lustre not compiled \n");
+                                
+                        } else {
+                                lprocfs_reg_dev(obd,\
+                                                obd_nm[l_idx].obd_names,\
+                                                obd_nm[l_idx].cntr_blk_sz); 
+                        }
+                        
                         MOD_INC_USE_COUNT;
                 }
 
@@ -368,13 +666,19 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp,
                         GOTO(out, err=-EBUSY);
                 }
 
+                if(lprocfs_dereg_dev(obd)!=LPROCFS_SUCCESS){
+                        CERROR("Could not remove Proc Entry\n");
+                        GOTO(out, err=-ENODEV);
+                        
+                }
                 if (obd->obd_name) {
                         OBD_FREE(obd->obd_name, strlen(obd->obd_name)+1);
                         obd->obd_name = NULL;
                 }
-
+                /* 
                 if (obd->obd_proc_entry)
                         proc_lustre_release_obd_device(obd);
+                */
 
                 obd->obd_flags &= ~OBD_ATTACHED;
                 obd->obd_type->typ_refcnt--;