X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fobdclass%2Fobd_config.c;h=325c2c1ecd047bf3343f1ef372c5b5f0931c4e09;hb=191061ee668400324f4505cf498f1ee2d57e4962;hp=931d5d33aaf7431d3df63353f2ceb373dde06037;hpb=342797139fe89f9efd184227cfbd7d654533685c;p=fs%2Flustre-release.git

diff --git a/lustre/obdclass/obd_config.c b/lustre/obdclass/obd_config.c
index 931d5d3..325c2c1 100644
--- a/lustre/obdclass/obd_config.c
+++ b/lustre/obdclass/obd_config.c
@@ -30,7 +30,7 @@
 #include <linux/random.h>
 #include <linux/slab.h>
 #include <linux/pagemap.h>
-#else 
+#else
 #include <liblustre.h>
 #include <linux/obd_class.h>
 #include <linux/obd.h>
@@ -43,51 +43,46 @@
 /* Create a new device and set the type, name and uuid.  If
  * successful, the new device can be accessed by either name or uuid.
  */
-int class_attach(struct lustre_cfg *lcfg)
+static int class_attach(struct lustre_cfg *lcfg)
 {
-        int minor;
         struct obd_type *type;
-        int err = 0;
-        int len;
-	char *typename;
-	char *name;
-	char *uuid;
-	struct obd_device *obd;
-	int dev;
-                 
-	if (!lcfg->lcfg_inllen1 || !lcfg->lcfg_inlbuf1) {
-		CERROR("No type passed!\n");
-		RETURN(-EINVAL);
-	}
-	if (lcfg->lcfg_inlbuf1[lcfg->lcfg_inllen1 - 1] != 0) {
-		CERROR("Type not nul terminated!\n");
-		RETURN(-EINVAL);
-	}
-	typename = lcfg->lcfg_inlbuf1;
-
-	if (!lcfg->lcfg_dev_namelen || !lcfg->lcfg_dev_name) {
-		CERROR("No name passed!\n");
-		RETURN(-EINVAL);
-	}
-	if (lcfg->lcfg_dev_name[lcfg->lcfg_dev_namelen - 1] != 0) {
-		CERROR("Name not nul terminated!\n");
-		RETURN(-EINVAL);
-	}
-	name = lcfg->lcfg_dev_name;
-
-	if (!lcfg->lcfg_inllen2 || !lcfg->lcfg_inlbuf2) {
-		CERROR("No UUID passed!\n");
-		RETURN(-EINVAL);
-	}
-	if (lcfg->lcfg_inlbuf2[lcfg->lcfg_inllen2 - 1] != 0) {
-		CERROR("UUID not nul terminated!\n");
-		RETURN(-EINVAL);
-	}
-	uuid = lcfg->lcfg_inlbuf2;
-
-	CDEBUG(D_IOCTL, "attach type %s name: %s uuid: %s\n",
-	       MKSTR(lcfg->lcfg_inlbuf1),
-	       MKSTR(lcfg->lcfg_dev_name), MKSTR(lcfg->lcfg_inlbuf2));
+        struct obd_device *obd;
+        char *typename, *name, *uuid;
+        int rc, len, cleanup_phase = 0;
+
+        if (!lcfg->lcfg_inllen1 || !lcfg->lcfg_inlbuf1) {
+                CERROR("No type passed!\n");
+                RETURN(-EINVAL);
+        }
+        if (lcfg->lcfg_inlbuf1[lcfg->lcfg_inllen1 - 1] != 0) {
+                CERROR("Type not nul terminated!\n");
+                RETURN(-EINVAL);
+        }
+        typename = lcfg->lcfg_inlbuf1;
+
+        if (!lcfg->lcfg_dev_namelen || !lcfg->lcfg_dev_name) {
+                CERROR("No name passed!\n");
+                RETURN(-EINVAL);
+        }
+        if (lcfg->lcfg_dev_name[lcfg->lcfg_dev_namelen - 1] != 0) {
+                CERROR("Name not nul terminated!\n");
+                RETURN(-EINVAL);
+        }
+        name = lcfg->lcfg_dev_name;
+
+        if (!lcfg->lcfg_inllen2 || !lcfg->lcfg_inlbuf2) {
+                CERROR("No UUID passed!\n");
+                RETURN(-EINVAL);
+        }
+        if (lcfg->lcfg_inlbuf2[lcfg->lcfg_inllen2 - 1] != 0) {
+                CERROR("UUID not nul terminated!\n");
+                RETURN(-EINVAL);
+        }
+        uuid = lcfg->lcfg_inlbuf2;
+
+        CDEBUG(D_IOCTL, "attach type %s name: %s uuid: %s\n",
+               MKSTR(lcfg->lcfg_inlbuf1),
+               MKSTR(lcfg->lcfg_dev_name), MKSTR(lcfg->lcfg_inlbuf2));
 
         /* find the type */
         type = class_get_type(typename);
@@ -95,82 +90,80 @@ int class_attach(struct lustre_cfg *lcfg)
                 CERROR("OBD: unknown type: %s\n", typename);
                 RETURN(-EINVAL);
         }
-        
+        cleanup_phase = 1;  /* class_put_type */
+
         obd = class_name2obd(name);
         if (obd != NULL) {
                 CERROR("obd %s already attached\n", name);
-                RETURN(-EEXIST);
+                GOTO(out, rc = -EEXIST);
         }
 
-	obd = class_newdev(&dev);
-	if (obd == NULL)
-		RETURN(-EINVAL);
-
-	/* have we attached a type to this device */
-	if (obd->obd_attached || obd->obd_type) {
-		CERROR("OBD: Device %d already typed as %s.\n",
-		       obd->obd_minor, MKSTR(obd->obd_type->typ_name));
-		RETURN(-EBUSY);
-	}
-
-        LASSERT(obd == (obd_dev + obd->obd_minor));
+        obd = class_newdev(type);
+        if (obd == NULL)
+                GOTO(out, rc = -EINVAL);
 
-        minor = obd->obd_minor;
-        memset(obd, 0, sizeof(*obd));
-        obd->obd_minor = minor;
-        obd->obd_type = type;
+        cleanup_phase = 2;  /* class_release_dev */
+        
         INIT_LIST_HEAD(&obd->obd_exports);
         obd->obd_num_exports = 0;
         spin_lock_init(&obd->obd_dev_lock);
+        spin_lock_init(&obd->obd_osfs_lock);
+        obd->obd_osfs_age = jiffies - 1000 * HZ;
         init_waitqueue_head(&obd->obd_refcount_waitq);
-        
+
         /* XXX belongs in setup not attach  */
         /* recovery data */
+        init_timer(&obd->obd_recovery_timer);
         spin_lock_init(&obd->obd_processing_task_lock);
         init_waitqueue_head(&obd->obd_next_transno_waitq);
         INIT_LIST_HEAD(&obd->obd_recovery_queue);
         INIT_LIST_HEAD(&obd->obd_delayed_reply_queue);
-        
-        init_waitqueue_head(&obd->obd_commit_waitq);
-        
+
+        spin_lock_init(&obd->obd_uncommitted_replies_lock);
+        INIT_LIST_HEAD(&obd->obd_uncommitted_replies);
+
         len = strlen(name) + 1;
         OBD_ALLOC(obd->obd_name, len);
-        if (!obd->obd_name) {
-                class_put_type(obd->obd_type);
-                obd->obd_type = NULL;
-                RETURN(-ENOMEM);
-        }
+        if (!obd->obd_name)
+                GOTO(out, rc = -ENOMEM);
         memcpy(obd->obd_name, name, len);
         
+        cleanup_phase = 3; /* free obd_name */
+
         len = strlen(uuid);
         if (len >= sizeof(obd->obd_uuid)) {
                 CERROR("uuid must be < "LPSZ" bytes long\n",
                        sizeof(obd->obd_uuid));
-                OBD_FREE(obd->obd_name, strlen(obd->obd_name) + 1);
-                class_put_type(obd->obd_type);
-                obd->obd_type = NULL;
-                RETURN(-EINVAL);
+                GOTO(out, rc = -EINVAL);
         }
         memcpy(obd->obd_uuid.uuid, uuid, len);
 
         /* do the attach */
-        if (OBP(obd, attach))
-                err = OBP(obd,attach)(obd, sizeof *lcfg, lcfg);
-
-        if (err) {
+        if (OBP(obd, attach)) {
+                rc = OBP(obd,attach)(obd, sizeof *lcfg, lcfg);
+                if (rc)
+                        GOTO(out, rc = -EINVAL);
+        }
+
+        obd->obd_attached = 1;
+        type->typ_refcnt++;
+        CDEBUG(D_IOCTL, "OBD: dev %d attached type %s\n",
+               obd->obd_minor, typename);
+        RETURN(0);
+ out:
+        switch (cleanup_phase) {
+        case 3:
                 OBD_FREE(obd->obd_name, strlen(obd->obd_name) + 1);
-                class_put_type(obd->obd_type);
+        case 2:
+                class_release_dev(obd);
+        case 1:
+                class_put_type(type);
                 obd->obd_type = NULL;
-        } else {
-                obd->obd_attached = 1;
-                type->typ_refcnt++;
-                CDEBUG(D_IOCTL, "OBD: dev %d attached type %s\n",
-                       obd->obd_minor, typename);
         }
-        RETURN(err);
+        return rc;
 }
 
-int class_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
+static int class_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
 {
         int err = 0;
         struct obd_export *exp;
@@ -193,45 +186,31 @@ int class_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
 
         atomic_set(&obd->obd_refcount, 0);
 
-        err = obd_setup(obd, sizeof(*lcfg), lcfg);
-        if (err) {
-                RETURN(err);
-        }
-        
-        obd->obd_type->typ_refcnt++;
-        obd->obd_set_up = 1;
-
         exp = class_new_export(obd);
-        if (exp == NULL) {
-                GOTO(err_cleanup, err = -ENOMEM);
-        }
-        memcpy(&exp->exp_client_uuid, &obd->obd_uuid, 
+        if (exp == NULL)
+                RETURN(err);
+        memcpy(&exp->exp_client_uuid, &obd->obd_uuid,
                sizeof(exp->exp_client_uuid));
         obd->obd_self_export = exp;
         class_export_put(exp);
 
-        if (OBT(obd) && OBP(obd, postsetup)) {
-                err = obd_postsetup(obd);
-                if (err) 
-                        GOTO(err_exp, err);
-        } 
+        err = obd_setup(obd, sizeof(*lcfg), lcfg);
+        if (err)
+                GOTO(err_exp, err);
+
+        obd->obd_type->typ_refcnt++;
+        obd->obd_set_up = 1;
 
         RETURN(err);
 
 err_exp:
         class_unlink_export(obd->obd_self_export);
         obd->obd_self_export = NULL;
-err_cleanup:
-        obd->obd_stopping = 1;
-        obd_cleanup(obd, 0);
-        obd->obd_set_up = obd->obd_stopping = 0;
-        obd->obd_type->typ_refcnt--;
         RETURN(err);
 }
 
-int class_detach(struct obd_device *obd, struct lustre_cfg *lcfg)
+static int class_detach(struct obd_device *obd, struct lustre_cfg *lcfg)
 {
-        int minor;
         int err = 0;
 
         ENTRY;
@@ -249,16 +228,14 @@ int class_detach(struct obd_device *obd, struct lustre_cfg *lcfg)
         if (obd->obd_name) {
                 OBD_FREE(obd->obd_name, strlen(obd->obd_name)+1);
                 obd->obd_name = NULL;
-        } else 
+        } else {
                 CERROR("device %d: no name at detach\n", obd->obd_minor);
+        }
 
         obd->obd_attached = 0;
         obd->obd_type->typ_refcnt--;
         class_put_type(obd->obd_type);
-        obd->obd_type = NULL;
-        minor = obd->obd_minor;
-        memset(obd, 0, sizeof(*obd));
-        obd->obd_minor = minor;
+        class_release_dev(obd);
         RETURN(err);
 }
 
@@ -267,19 +244,31 @@ static void dump_exports(struct obd_device *obd)
         struct obd_export *exp, *n;
 
         list_for_each_entry_safe(exp, n, &obd->obd_exports, exp_obd_chain) {
-                CERROR("%s: %p %s %d %d %p\n",
+                struct ptlrpc_reply_state *rs;
+                struct ptlrpc_reply_state *first_reply = NULL;
+                int                        nreplies = 0;
+
+                list_for_each_entry (rs, &exp->exp_outstanding_replies,
+                                     rs_exp_list) {
+                        if (nreplies == 0)
+                                first_reply = rs;
+                        nreplies++;
+                }
+
+                CERROR("%s: %p %s %d %d %d: %p %s\n",
                        obd->obd_name, exp, exp->exp_client_uuid.uuid,
                        atomic_read(&exp->exp_refcount),
-                       exp->exp_failed, exp->exp_outstanding_reply );
+                       exp->exp_failed, nreplies, first_reply,
+                       nreplies > 3 ? "..." : "");
         }
 }
 
-int class_cleanup(struct obd_device *obd, struct lustre_cfg *lcfg)
+static int class_cleanup(struct obd_device *obd, struct lustre_cfg *lcfg)
 {
         int flags = 0;
-	int err = 0;
+        int err = 0;
         char *flag;
-        
+
         ENTRY;
         if (!obd->obd_set_up) {
                 CERROR("Device %d not setup\n", obd->obd_minor);
@@ -316,8 +305,8 @@ int class_cleanup(struct obd_device *obd, struct lustre_cfg *lcfg)
                 int rc;
 
                 if (!(flags & OBD_OPT_FORCE)) {
-                        CERROR("OBD device %d (%p) has refcount %d\n",
-                               obd->obd_minor, obd,
+                        CERROR("OBD device %d (%p,%s) has refcount %d\n",
+                               obd->obd_minor, obd, obd->obd_name,
                                atomic_read(&obd->obd_refcount));
                         dump_exports(obd);
                         GOTO(out, err = -EBUSY);
@@ -343,7 +332,7 @@ int class_cleanup(struct obd_device *obd, struct lustre_cfg *lcfg)
 
         if (obd->obd_self_export) {
                 err = obd_precleanup(obd, flags);
-                if (err) 
+                if (err)
                         GOTO(out, err);
                 class_unlink_export(obd->obd_self_export);
                 obd->obd_self_export = NULL;
@@ -355,14 +344,79 @@ out:
                 obd->obd_set_up = obd->obd_stopping = 0;
                 obd->obd_type->typ_refcnt--;
                 /* XXX this should be an LASSERT */
-                if (atomic_read(&obd->obd_refcount) > 0) 
-                        CERROR("%s still has refcount %d after "
-                               "cleanup.\n", obd->obd_name,
+                if (atomic_read(&obd->obd_refcount) > 0) {
+                        CERROR("%s (%p) still has refcount %d after "
+                               "cleanup.\n", obd->obd_name, obd,
                                atomic_read(&obd->obd_refcount));
-        } 
+                        dump_exports(obd);
+                }
+        }
 
         RETURN(err);
+}
+
+int class_add_conn(struct obd_device *obd, struct lustre_cfg *lcfg)
+{
+        struct obd_import *imp;
+        struct obd_uuid uuid;
+        int priority, rc;
+        ENTRY;
 
+        if (lcfg->lcfg_inllen1 <= 0 ||
+            lcfg->lcfg_inllen1 > sizeof(struct obd_uuid)) {
+                CERROR("invalid conn_uuid\n");
+                RETURN(-EINVAL);
+        }
+        if (lcfg->lcfg_inllen2 != sizeof(int)) {
+                CERROR("invalid priority\n");
+                RETURN(-EINVAL);
+        }
+        if (strcmp(obd->obd_type->typ_name, "mdc") &&
+            strcmp(obd->obd_type->typ_name, "osc")) {
+                CERROR("can't add connection on non-client dev\n");
+                RETURN(-EINVAL);
+        }
+
+        imp = obd->u.cli.cl_import;
+        if (!imp) {
+                CERROR("try to add conn on immature client dev\n");
+                RETURN(-EINVAL);
+        }
+
+        obd_str2uuid(&uuid, lcfg->lcfg_inlbuf1);
+        priority = *((int*) lcfg->lcfg_inlbuf2);
+        rc = obd_add_conn(imp, &uuid, priority);
+
+        RETURN(rc);
+}
+int class_del_conn(struct obd_device *obd, struct lustre_cfg *lcfg)
+{
+        struct obd_import *imp;
+        struct obd_uuid uuid;
+        int rc;
+        ENTRY;
+
+        if (lcfg->lcfg_inllen1 <= 0 ||
+            lcfg->lcfg_inllen1 > sizeof(struct obd_uuid)) {
+                CERROR("invalid conn_uuid\n");
+                RETURN(-EINVAL);
+        }
+        if (strcmp(obd->obd_type->typ_name, "mdc") &&
+            strcmp(obd->obd_type->typ_name, "osc")) {
+                CERROR("can't add connection on non-client dev\n");
+                RETURN(-EINVAL);
+        }
+
+        imp = obd->u.cli.cl_import;
+        if (!imp) {
+                CERROR("try to del conn on immature client dev\n");
+                RETURN(-EINVAL);
+        }
+
+        obd_str2uuid(&uuid, lcfg->lcfg_inlbuf1);
+        rc = obd_del_conn(imp, &uuid);
+
+        RETURN(rc);
 }
 
 LIST_HEAD(lustre_profile_list);
@@ -370,7 +424,7 @@ LIST_HEAD(lustre_profile_list);
 struct lustre_profile *class_get_profile(char * prof)
 {
         struct lustre_profile *lprof;
-        
+
         list_for_each_entry(lprof, &lustre_profile_list, lp_list) {
                 if (!strcmp(lprof->lp_profile, prof)) {
                         RETURN(lprof);
@@ -379,8 +433,7 @@ struct lustre_profile *class_get_profile(char * prof)
         RETURN(NULL);
 }
 
-int class_add_profile(int proflen, char *prof, 
-                      int osclen, char *osc, 
+int class_add_profile(int proflen, char *prof, int osclen, char *osc,
                       int mdclen, char *mdc)
 {
         struct lustre_profile *lprof;
@@ -396,7 +449,7 @@ int class_add_profile(int proflen, char *prof,
         if (lprof->lp_profile == NULL)
                 GOTO(out, err = -ENOMEM);
         memcpy(lprof->lp_profile, prof, proflen);
-        
+
         LASSERT(osclen == (strlen(osc) + 1));
         OBD_ALLOC(lprof->lp_osc, osclen);
         if (lprof->lp_profile == NULL)
@@ -420,7 +473,7 @@ out:
 void class_del_profile(char *prof)
 {
         struct lustre_profile *lprof;
-        
+
         lprof = class_get_profile(prof);
         if (lprof) {
                 list_del(&lprof->lp_list);
@@ -434,16 +487,17 @@ void class_del_profile(char *prof)
 
 int class_process_config(struct lustre_cfg *lcfg)
 {
-	struct obd_device *obd;
+        struct obd_device *obd;
         char str[PTL_NALFMT_SIZE];
         int err;
+        ENTRY;
 
         LASSERT(lcfg && !IS_ERR(lcfg));
 
         CDEBUG(D_IOCTL, "processing cmd: %x\n", lcfg->lcfg_command);
 
         /* Commands that don't need a device */
-	switch(lcfg->lcfg_command) {
+        switch(lcfg->lcfg_command) {
         case LCFG_ATTACH: {
                 err = class_attach(lcfg);
                 GOTO(out, err);
@@ -467,12 +521,13 @@ int class_process_config(struct lustre_cfg *lcfg)
                 GOTO(out, err);
         }
         case LCFG_MOUNTOPT: {
-                CDEBUG(D_IOCTL, "mountopt: profile %s osc %s mdc %s\n", 
-                       lcfg->lcfg_inlbuf1, lcfg->lcfg_inlbuf2, lcfg->lcfg_inlbuf3);
+                CDEBUG(D_IOCTL, "mountopt: profile %s osc %s mdc %s\n",
+                       lcfg->lcfg_inlbuf1, lcfg->lcfg_inlbuf2,
+                       lcfg->lcfg_inlbuf3);
                 /* set these mount options somewhere, so ll_fill_super
                  * can find them. */
-                err = class_add_profile(lcfg->lcfg_inllen1, lcfg->lcfg_inlbuf1, 
-                                        lcfg->lcfg_inllen2, lcfg->lcfg_inlbuf2, 
+                err = class_add_profile(lcfg->lcfg_inllen1, lcfg->lcfg_inlbuf1,
+                                        lcfg->lcfg_inllen2, lcfg->lcfg_inlbuf2,
                                         lcfg->lcfg_inllen3, lcfg->lcfg_inlbuf3);
                 GOTO(out, err);
         }
@@ -484,35 +539,34 @@ int class_process_config(struct lustre_cfg *lcfg)
                 GOTO(out, err = 0);
         }
         case LCFG_SET_TIMEOUT: {
-                CDEBUG(D_IOCTL, "changing lustre timeout from %d to %d\n", 
+                CDEBUG(D_IOCTL, "changing lustre timeout from %d to %d\n",
                        obd_timeout,
                        lcfg->lcfg_num);
                 obd_timeout = lcfg->lcfg_num;
                 GOTO(out, err = 0);
         }
         case LCFG_SET_UPCALL: {
-                CDEBUG(D_IOCTL, "setting lustre ucpall to: %s\n", 
+                CDEBUG(D_IOCTL, "setting lustre ucpall to: %s\n",
                        lcfg->lcfg_inlbuf1);
                 if (lcfg->lcfg_inllen1 > sizeof obd_lustre_upcall)
                         GOTO(out, err = -EINVAL);
-                memcpy(obd_lustre_upcall, lcfg->lcfg_inlbuf1, 
+                memcpy(obd_lustre_upcall, lcfg->lcfg_inlbuf1,
                        lcfg->lcfg_inllen1);
                 GOTO(out, err = 0);
         }
-	}
-	
+        }
 
-	/* Commands that require a device */
+        /* Commands that require a device */
         obd = class_name2obd(lcfg->lcfg_dev_name);
         if (obd == NULL) {
-                if (lcfg->lcfg_dev_name == NULL) {
+                if (lcfg->lcfg_dev_name == NULL)
                         CERROR("this lcfg command requires a device name\n");
-                } else {
+                else
                         CERROR("no device for: %s\n", lcfg->lcfg_dev_name);
-                }
+
                 GOTO(out, err = -EINVAL);
-	}
-	    
+        }
+
         switch(lcfg->lcfg_command) {
         case LCFG_SETUP: {
                 err = class_setup(obd, lcfg);
@@ -526,23 +580,32 @@ int class_process_config(struct lustre_cfg *lcfg)
                 err = class_cleanup(obd, lcfg);
                 GOTO(out, err = 0);
         }
-        default: { 
-                CERROR("Unknown command: %d\n", lcfg->lcfg_command);
-                GOTO(out, err = -EINVAL);
+        case LCFG_ADD_CONN: {
+                err = class_add_conn(obd, lcfg);
+                GOTO(out, err = 0);
+        }
+        case LCFG_DEL_CONN: {
+                err = class_del_conn(obd, lcfg);
+                GOTO(out, err = 0);
+        }
+        default: {
+                err = obd_process_config(obd, sizeof(*lcfg), lcfg);
+                GOTO(out, err);
 
         }
-	}
+        }
 out:
         RETURN(err);
 }
-	    
-static int class_config_llog_handler(struct llog_handle * handle,
-                                     struct llog_rec_hdr *rec, void *data)
+
+static int class_config_parse_handler(struct llog_handle * handle,
+                                      struct llog_rec_hdr *rec, void *data)
 {
         struct config_llog_instance *cfg = data;
         int cfg_len = rec->lrh_len;
         char *cfg_buf = (char*) (rec + 1);
         int rc = 0;
+        ENTRY;
 
         if (rec->lrh_type == OBD_CFG_REC) {
                 char *buf;
@@ -555,24 +618,24 @@ static int class_config_llog_handler(struct llog_handle * handle,
                 int inst_len = 0;
 
                 rc = lustre_cfg_getdata(&buf, cfg_len, cfg_buf, 1);
-                if (rc) 
+                if (rc)
                         GOTO(out, rc);
                 lcfg = (struct lustre_cfg* ) buf;
 
                 if (cfg && cfg->cfg_instance && lcfg->lcfg_dev_name) {
-                        inst_len = strlen(lcfg->lcfg_dev_name) + 
+                        inst_len = strlen(lcfg->lcfg_dev_name) +
                                 strlen(cfg->cfg_instance) + 2;
                         OBD_ALLOC(inst_name, inst_len);
-                        if (inst_name == NULL) 
+                        if (inst_name == NULL)
                                 GOTO(out, rc = -ENOMEM);
-                        sprintf(inst_name, "%s-%s", lcfg->lcfg_dev_name, 
+                        sprintf(inst_name, "%s-%s", lcfg->lcfg_dev_name,
                                 cfg->cfg_instance);
                         old_name = lcfg->lcfg_dev_name;
                         old_len = lcfg->lcfg_dev_namelen;
                         lcfg->lcfg_dev_name = inst_name;
                         lcfg->lcfg_dev_namelen = strlen(inst_name) + 1;
                 }
-                
+
                 if (cfg && lcfg->lcfg_command == LCFG_ATTACH) {
                         old_uuid = lcfg->lcfg_inlbuf2;
                         old_uuid_len = lcfg->lcfg_inllen2;
@@ -588,49 +651,48 @@ static int class_config_llog_handler(struct llog_handle * handle,
                         lcfg->lcfg_dev_namelen = old_len;
                         OBD_FREE(inst_name, inst_len);
                 }
-              
+
                 if (old_uuid) {
                         lcfg->lcfg_inlbuf2 = old_uuid;
                         lcfg->lcfg_inllen2 = old_uuid_len;
                 }
-                
+
                 lustre_cfg_freedata(buf, cfg_len);
         } else if (rec->lrh_type == PTL_CFG_REC) {
                 struct portals_cfg *pcfg = (struct portals_cfg *)cfg_buf;
-                if (pcfg->pcfg_command ==NAL_CMD_REGISTER_MYNID &&
+                if (pcfg->pcfg_command == NAL_CMD_REGISTER_MYNID &&
                     cfg->cfg_local_nid != PTL_NID_ANY) {
                         pcfg->pcfg_nid = cfg->cfg_local_nid;
                 }
 
-                rc = kportal_nal_cmd(pcfg);
+                rc = libcfs_nal_cmd(pcfg);
+        } else {
+                CERROR("unrecognized record type: 0x%x\n", rec->lrh_type);
         }
 out:
         RETURN(rc);
 }
 
-int class_config_parse_llog(struct llog_ctxt *ctxt, char *name, 
-                          struct config_llog_instance *cfg)
+int class_config_process_llog(struct llog_ctxt *ctxt, char *name,
+                              struct config_llog_instance *cfg)
 {
         struct llog_handle *llh;
         int rc, rc2;
         ENTRY;
 
-        rc = llog_create(ctxt, &llh, NULL, name);
-        if (rc) 
+        rc = llog_open(ctxt, &llh, NULL, name, 0);
+        if (rc)
                 RETURN(rc);
 
         rc = llog_init_handle(llh, LLOG_F_IS_PLAIN, NULL);
-        if (rc) 
-                GOTO(parse_out, rc);
+        if (rc == 0)
+                rc = llog_process(llh, class_config_parse_handler, cfg, NULL);
 
-        rc = llog_process(llh, class_config_llog_handler, cfg, NULL);
-parse_out:
         rc2 = llog_close(llh);
         if (rc == 0)
                 rc = rc2;
 
         RETURN(rc);
-
 }
 
 static int class_config_dump_handler(struct llog_handle * handle,
@@ -639,22 +701,23 @@ static int class_config_dump_handler(struct llog_handle * handle,
         int cfg_len = rec->lrh_len;
         char *cfg_buf = (char*) (rec + 1);
         int rc = 0;
+        ENTRY;
 
         if (rec->lrh_type == OBD_CFG_REC) {
                 char *buf;
                 struct lustre_cfg *lcfg;
 
                 rc = lustre_cfg_getdata(&buf, cfg_len, cfg_buf, 1);
-                if (rc) 
+                if (rc)
                         GOTO(out, rc);
                 lcfg = (struct lustre_cfg* ) buf;
-                
-                CDEBUG(D_INFO, "lcfg command: %x\n", lcfg->lcfg_command);
+
+                CDEBUG(D_INFO, "lcfg command: 0x%x\n", lcfg->lcfg_command);
                 if (lcfg->lcfg_dev_name)
                         CDEBUG(D_INFO, "     devname: %s\n",
                                lcfg->lcfg_dev_name);
                 if (lcfg->lcfg_flags)
-                        CDEBUG(D_INFO, "       flags: %x\n", lcfg->lcfg_flags);
+                        CDEBUG(D_INFO, "       flags: 0x%x\n", lcfg->lcfg_flags);
                 if (lcfg->lcfg_nid)
                         CDEBUG(D_INFO, "         nid: "LPX64"\n",
                                lcfg->lcfg_nid);
@@ -665,17 +728,21 @@ static int class_config_dump_handler(struct llog_handle * handle,
                 if (lcfg->lcfg_inlbuf1)
                         CDEBUG(D_INFO, "     inlbuf1: %s\n",lcfg->lcfg_inlbuf1);
                 if (lcfg->lcfg_inlbuf2)
-                        CDEBUG(D_INFO, "     inlbuf1: %s\n",lcfg->lcfg_inlbuf2);
+                        CDEBUG(D_INFO, "     inlbuf2: %s\n",lcfg->lcfg_inlbuf2);
                 if (lcfg->lcfg_inlbuf3)
-                        CDEBUG(D_INFO, "     inlbuf1: %s\n",lcfg->lcfg_inlbuf3);
+                        CDEBUG(D_INFO, "     inlbuf3: %s\n",lcfg->lcfg_inlbuf3);
                 if (lcfg->lcfg_inlbuf4)
-                        CDEBUG(D_INFO, "     inlbuf1: %s\n",lcfg->lcfg_inlbuf4);
+                        CDEBUG(D_INFO, "     inlbuf4: %s\n",lcfg->lcfg_inlbuf4);
+                if (lcfg->lcfg_inlbuf5)
+                        CDEBUG(D_INFO, "     inlbuf5: %s\n",lcfg->lcfg_inlbuf5);
+                if (lcfg->lcfg_inlbuf6)
+                        CDEBUG(D_INFO, "     inlbuf6: %s\n",lcfg->lcfg_inlbuf6);
 
                 lustre_cfg_freedata(buf, cfg_len);
         } else if (rec->lrh_type == PTL_CFG_REC) {
                 struct portals_cfg *pcfg = (struct portals_cfg *)cfg_buf;
 
-                CDEBUG(D_INFO, "pcfg command: %d\n", pcfg->pcfg_command);
+                CDEBUG(D_INFO, "pcfg command: 0x%x\n", pcfg->pcfg_command);
                 if (pcfg->pcfg_nal)
                         CDEBUG(D_INFO, "         nal: %d\n",
                                pcfg->pcfg_nal);
@@ -686,47 +753,46 @@ static int class_config_dump_handler(struct llog_handle * handle,
                         CDEBUG(D_INFO, "         nid: "LPX64"\n",
                                pcfg->pcfg_nid);
                 if (pcfg->pcfg_nid2)
-                        CDEBUG(D_INFO, "         nid: "LPX64"\n",
+                        CDEBUG(D_INFO, "        nid2: "LPX64"\n",
                                pcfg->pcfg_nid2);
                 if (pcfg->pcfg_nid3)
-                        CDEBUG(D_INFO, "         nid: "LPX64"\n",
+                        CDEBUG(D_INFO, "        nid3: "LPX64"\n",
                                pcfg->pcfg_nid3);
                 if (pcfg->pcfg_misc)
-                        CDEBUG(D_INFO, "         nid: %d\n",
+                        CDEBUG(D_INFO, "        misc: %d\n",
                                pcfg->pcfg_misc);
                 if (pcfg->pcfg_id)
-                        CDEBUG(D_INFO, "          id: %x\n",
+                        CDEBUG(D_INFO, "          id: 0x%x\n",
                                pcfg->pcfg_id);
                 if (pcfg->pcfg_flags)
-                        CDEBUG(D_INFO, "       flags: %x\n",
+                        CDEBUG(D_INFO, "       flags: 0x%x\n",
                                pcfg->pcfg_flags);
+        } else {
+                CERROR("unhandled lrh_type: %#x\n", rec->lrh_type);
+                rc = -EINVAL;
         }
 out:
         RETURN(rc);
 }
 
-int class_config_dump_llog(struct llog_ctxt *ctxt, char *name, 
-                          struct config_llog_instance *cfg)
+int class_config_dump_llog(struct llog_ctxt *ctxt, char *name,
+                           struct config_llog_instance *cfg)
 {
         struct llog_handle *llh;
         int rc, rc2;
         ENTRY;
 
-        rc = llog_create(ctxt, &llh, NULL, name);
-        if (rc) 
+        rc = llog_open(ctxt, &llh, NULL, name, 0);
+        if (rc)
                 RETURN(rc);
 
         rc = llog_init_handle(llh, LLOG_F_IS_PLAIN, NULL);
-        if (rc) 
-                GOTO(parse_out, rc);
+        if (rc == 0)
+                rc = llog_process(llh, class_config_dump_handler, cfg, NULL);
 
-        rc = llog_process(llh, class_config_dump_handler, cfg, NULL);
-parse_out:
         rc2 = llog_close(llh);
         if (rc == 0)
                 rc = rc2;
 
         RETURN(rc);
-
 }
-