lustre/obdclass/obd_config.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  Copyright (c) 2001-2003 Cluster File Systems, Inc.
   5  *
   6  *   This file is part of Lustre, http://www.lustre.org.
   7  *
   8  *   Lustre is free software; you can redistribute it and/or
   9  *   modify it under the terms of version 2 of the GNU General Public
  10  *   License as published by the Free Software Foundation.
  11  *
  12  *   Lustre is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *   GNU General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU General Public License
  18  *   along with Lustre; if not, write to the Free Software
  19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  *
  21  * Config API
  22  *
  23  */
  24
  25 #define DEBUG_SUBSYSTEM S_CLASS
  26 #ifdef __KERNEL__
  27 #include <linux/kmod.h>   /* for request_module() */
  28 #include <linux/module.h>
  29 #include <linux/obd_class.h>
  30 #include <linux/random.h>
  31 #include <linux/slab.h>
  32 #include <linux/pagemap.h>
  33 #else
  34 #include <liblustre.h>
  35 #include <linux/obd_class.h>
  36 #include <linux/obd.h>
  37 #endif
  38 #include <linux/lustre_log.h>
  39 #include <linux/lprocfs_status.h>
  40 #include <libcfs/list.h>
  41
  42
  43 /* Create a new device and set the type, name and uuid.  If
  44  * successful, the new device can be accessed by either name or uuid.
  45  */
  46 static int class_attach(struct lustre_cfg *lcfg)
  47 {
  48         struct obd_type *type;
  49         struct obd_device *obd;
  50         char *typename, *name, *uuid;
  51         int rc, len, cleanup_phase = 0;
  52
  53         if (!LUSTRE_CFG_BUFLEN(lcfg, 1)) {
  54                 CERROR("No type passed!\n");
  55                 RETURN(-EINVAL);
  56         }
  57         typename = lustre_cfg_string(lcfg, 1);
  58
  59         if (!LUSTRE_CFG_BUFLEN(lcfg, 0)) {
  60                 CERROR("No name passed!\n");
  61                 RETURN(-EINVAL);
  62         }
  63         name = lustre_cfg_string(lcfg, 0);
  64
  65         if (!LUSTRE_CFG_BUFLEN(lcfg, 2)) {
  66                 CERROR("No UUID passed!\n");
  67                 RETURN(-EINVAL);
  68         }
  69         uuid = lustre_cfg_string(lcfg, 2);
  70
  71         CDEBUG(D_IOCTL, "attach type %s name: %s uuid: %s\n",
  72                MKSTR(typename), MKSTR(name), MKSTR(uuid));
  73
  74         /* find the type */
  75         type = class_get_type(typename);
  76         if (!type) {
  77                 CERROR("OBD: unknown type: %s\n", typename);
  78                 RETURN(-EINVAL);
  79         }
  80         cleanup_phase = 1;  /* class_put_type */
  81
  82         obd = class_name2obd(name);
  83         if (obd != NULL) {
  84                 CERROR("obd %s already attached\n", name);
  85                 GOTO(out, rc = -EEXIST);
  86         }
  87
  88         obd = class_newdev(type);
  89         if (obd == NULL)
  90                 GOTO(out, rc = -EINVAL);
  91
  92         cleanup_phase = 2;  /* class_release_dev */
  93
  94         INIT_LIST_HEAD(&obd->obd_exports);
  95         obd->obd_num_exports = 0;
  96         spin_lock_init(&obd->obd_dev_lock);
  97         spin_lock_init(&obd->obd_osfs_lock);
  98         obd->obd_osfs_age = jiffies - 1000 * HZ;
  99         init_waitqueue_head(&obd->obd_refcount_waitq);
 100
 101         /* XXX belongs in setup not attach  */
 102         /* recovery data */
 103         init_timer(&obd->obd_recovery_timer);
 104         spin_lock_init(&obd->obd_processing_task_lock);
 105         init_waitqueue_head(&obd->obd_next_transno_waitq);
 106         INIT_LIST_HEAD(&obd->obd_req_replay_queue);
 107         INIT_LIST_HEAD(&obd->obd_lock_replay_queue);
 108         INIT_LIST_HEAD(&obd->obd_final_req_queue);
 109
 110         spin_lock_init(&obd->obd_uncommitted_replies_lock);
 111         INIT_LIST_HEAD(&obd->obd_uncommitted_replies);
 112
 113         len = strlen(name) + 1;
 114         OBD_ALLOC(obd->obd_name, len);
 115         if (!obd->obd_name)
 116                 GOTO(out, rc = -ENOMEM);
 117         memcpy(obd->obd_name, name, len);
 118
 119         cleanup_phase = 3; /* free obd_name */
 120
 121         len = strlen(uuid);
 122         if (len >= sizeof(obd->obd_uuid)) {
 123                 CERROR("uuid must be < "LPSZ" bytes long\n",
 124                        sizeof(obd->obd_uuid));
 125                 GOTO(out, rc = -EINVAL);
 126         }
 127         memcpy(obd->obd_uuid.uuid, uuid, len);
 128
 129         /* do the attach */
 130         if (OBP(obd, attach)) {
 131                 rc = OBP(obd,attach)(obd, sizeof *lcfg, lcfg);
 132                 if (rc)
 133                         GOTO(out, rc = -EINVAL);
 134         }
 135
 136         obd->obd_attached = 1;
 137         type->typ_refcnt++;
 138         CDEBUG(D_IOCTL, "OBD: dev %d attached type %s\n",
 139                obd->obd_minor, typename);
 140         RETURN(0);
 141  out:
 142         switch (cleanup_phase) {
 143         case 3:
 144                 OBD_FREE(obd->obd_name, strlen(obd->obd_name) + 1);
 145         case 2:
 146                 class_release_dev(obd);
 147         case 1:
 148                 class_put_type(type);
 149         }
 150         return rc;
 151 }
 152
 153 static int class_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
 154 {
 155         int err = 0;
 156         struct obd_export *exp;
 157         ENTRY;
 158
 159         LASSERT(obd == (obd_dev + obd->obd_minor));
 160
 161         /* have we attached a type to this device? */
 162         if (!obd->obd_attached) {
 163                 CERROR("Device %d not attached\n", obd->obd_minor);
 164                 RETURN(-ENODEV);
 165         }
 166
 167         /* has this been done already? */
 168         if (obd->obd_set_up) {
 169                 CERROR("Device %d already setup (type %s)\n",
 170                        obd->obd_minor, obd->obd_type->typ_name);
 171                 RETURN(-EBUSY);
 172         }
 173
 174         atomic_set(&obd->obd_refcount, 0);
 175
 176         exp = class_new_export(obd);
 177         if (exp == NULL)
 178                 RETURN(err);
 179         memcpy(&exp->exp_client_uuid, &obd->obd_uuid,
 180                sizeof(exp->exp_client_uuid));
 181         obd->obd_self_export = exp;
 182         class_export_put(exp);
 183
 184         err = obd_setup(obd, sizeof(*lcfg), lcfg);
 185         if (err)
 186                 GOTO(err_exp, err);
 187
 188         obd->obd_type->typ_refcnt++;
 189         obd->obd_set_up = 1;
 190
 191         RETURN(err);
 192
 193 err_exp:
 194         class_unlink_export(obd->obd_self_export);
 195         obd->obd_self_export = NULL;
 196         RETURN(err);
 197 }
 198
 199 static int class_detach(struct obd_device *obd, struct lustre_cfg *lcfg)
 200 {
 201         int err = 0;
 202
 203         ENTRY;
 204         if (obd->obd_set_up) {
 205                 CERROR("OBD device %d still set up\n", obd->obd_minor);
 206                 RETURN(-EBUSY);
 207         }
 208         if (!obd->obd_attached) {
 209                 CERROR("OBD device %d not attached\n", obd->obd_minor);
 210                 RETURN(-ENODEV);
 211         }
 212         if (OBP(obd, detach))
 213                 err = OBP(obd,detach)(obd);
 214
 215         if (obd->obd_name) {
 216                 OBD_FREE(obd->obd_name, strlen(obd->obd_name)+1);
 217                 obd->obd_name = NULL;
 218         } else {
 219                 CERROR("device %d: no name at detach\n", obd->obd_minor);
 220         }
 221
 222         obd->obd_attached = 0;
 223         obd->obd_type->typ_refcnt--;
 224         class_put_type(obd->obd_type);
 225         class_release_dev(obd);
 226         RETURN(err);
 227 }
 228
 229 static void dump_exports(struct obd_device *obd)
 230 {
 231         struct obd_export *exp, *n;
 232
 233         list_for_each_entry_safe(exp, n, &obd->obd_exports, exp_obd_chain) {
 234                 struct ptlrpc_reply_state *rs;
 235                 struct ptlrpc_reply_state *first_reply = NULL;
 236                 int                        nreplies = 0;
 237
 238                 list_for_each_entry (rs, &exp->exp_outstanding_replies,
 239                                      rs_exp_list) {
 240                         if (nreplies == 0)
 241                                 first_reply = rs;
 242                         nreplies++;
 243                 }
 244
 245                 CERROR("%s: %p %s %d %d %d: %p %s\n",
 246                        obd->obd_name, exp, exp->exp_client_uuid.uuid,
 247                        atomic_read(&exp->exp_refcount),
 248                        exp->exp_failed, nreplies, first_reply,
 249                        nreplies > 3 ? "..." : "");
 250         }
 251 }
 252
 253 static int class_cleanup(struct obd_device *obd, struct lustre_cfg *lcfg)
 254 {
 255         int flags = 0;
 256         int err = 0;
 257         char *flag;
 258
 259         ENTRY;
 260         if (!obd->obd_set_up) {
 261                 CERROR("Device %d not setup\n", obd->obd_minor);
 262                 RETURN(-ENODEV);
 263         }
 264         if (LUSTRE_CFG_BUFLEN(lcfg, 1) > 0) {
 265                  for (flag = lustre_cfg_string(lcfg, 1); *flag != 0; flag++)
 266                         switch (*flag) {
 267                         case 'F':
 268                                 flags |= OBD_OPT_FORCE;
 269                                 break;
 270                         case 'A':
 271                                 flags |= OBD_OPT_FAILOVER;
 272                                 break;
 273                         default:
 274                                 CERROR("unrecognised flag '%c'\n",
 275                                        *flag);
 276                         }
 277         }
 278
 279         /* The one reference that should be remaining is the
 280          * obd_self_export */
 281         if (atomic_read(&obd->obd_refcount) <= 1 ||
 282             flags & OBD_OPT_FORCE) {
 283                 /* this will stop new connections, and need to
 284                    do it before class_disconnect_exports() */
 285                 obd->obd_stopping = 1;
 286         }
 287
 288         if (atomic_read(&obd->obd_refcount) > 1) {
 289                 struct l_wait_info lwi = LWI_TIMEOUT_INTR(1 * HZ, NULL,
 290                                                           NULL, NULL);
 291                 int rc;
 292
 293                 if (!(flags & OBD_OPT_FORCE)) {
 294                         CERROR("OBD device %d (%p,%s) has refcount %d\n",
 295                                obd->obd_minor, obd, obd->obd_name,
 296                                atomic_read(&obd->obd_refcount));
 297                         portals_debug_dumplog();
 298                         dump_exports(obd);
 299                         GOTO(out, err = -EBUSY);
 300                 }
 301                 class_disconnect_exports(obd, flags);
 302                 CDEBUG(D_IOCTL,
 303                        "%s: waiting for obd refs to go away: %d\n",
 304                        obd->obd_name, atomic_read(&obd->obd_refcount));
 305
 306                 rc = l_wait_event(obd->obd_refcount_waitq,
 307                                   atomic_read(&obd->obd_refcount) < 2, &lwi);
 308                 if (rc == 0) {
 309                         LASSERT(atomic_read(&obd->obd_refcount) == 1);
 310                 } else {
 311                         CERROR("wait cancelled cleaning anyway. "
 312                                "refcount: %d\n",
 313                                atomic_read(&obd->obd_refcount));
 314                         dump_exports(obd);
 315                 }
 316                 CDEBUG(D_IOCTL, "%s: awake, now finishing cleanup\n",
 317                        obd->obd_name);
 318         }
 319
 320         if (obd->obd_self_export) {
 321                 err = obd_precleanup(obd, flags);
 322                 if (err)
 323                         GOTO(out, err);
 324                 class_unlink_export(obd->obd_self_export);
 325                 obd->obd_self_export = NULL;
 326         }
 327
 328         err = obd_cleanup(obd, flags);
 329 out:
 330         if (!err) {
 331                 obd->obd_set_up = obd->obd_stopping = 0;
 332                 obd->obd_type->typ_refcnt--;
 333                 /* XXX this should be an LASSERT */
 334                 if (atomic_read(&obd->obd_refcount) > 0) {
 335                         CERROR("%s (%p) still has refcount %d after "
 336                                "cleanup.\n", obd->obd_name, obd,
 337                                atomic_read(&obd->obd_refcount));
 338                         dump_exports(obd);
 339                 }
 340         }
 341
 342         RETURN(err);
 343 }
 344
 345 int class_add_conn(struct obd_device *obd, struct lustre_cfg *lcfg)
 346 {
 347         struct obd_import *imp;
 348         struct obd_uuid uuid;
 349         int rc;
 350         ENTRY;
 351
 352         if (LUSTRE_CFG_BUFLEN(lcfg, 1) < 1 ||
 353             LUSTRE_CFG_BUFLEN(lcfg, 1) > sizeof(struct obd_uuid)) {
 354                 CERROR("invalid conn_uuid\n");
 355                 RETURN(-EINVAL);
 356         }
 357
 358         if (LUSTRE_CFG_BUFLEN(lcfg, 2) != sizeof(int)) {
 359                 CERROR("invalid priority\n");
 360                 RETURN(-EINVAL);
 361         }
 362         if (strcmp(obd->obd_type->typ_name, OBD_MDC_DEVICENAME) &&
 363             strcmp(obd->obd_type->typ_name, OBD_OSC_DEVICENAME)) {
 364                 CERROR("can't add connection on non-client dev\n");
 365                 RETURN(-EINVAL);
 366         }
 367
 368         imp = obd->u.cli.cl_import;
 369         if (!imp) {
 370                 CERROR("try to add conn on immature client dev\n");
 371                 RETURN(-EINVAL);
 372         }
 373
 374         obd_str2uuid(&uuid, lustre_cfg_string(lcfg, 1));
 375         rc = obd_add_conn(imp, &uuid, lcfg->lcfg_num);
 376
 377         RETURN(rc);
 378 }
 379
 380 int class_del_conn(struct obd_device *obd, struct lustre_cfg *lcfg)
 381 {
 382         struct obd_import *imp;
 383         struct obd_uuid uuid;
 384         int rc;
 385         ENTRY;
 386
 387         if (LUSTRE_CFG_BUFLEN(lcfg, 1) < 1 ||
 388             LUSTRE_CFG_BUFLEN(lcfg, 1) > sizeof(struct obd_uuid)) {
 389                 CERROR("invalid conn_uuid\n");
 390                 RETURN(-EINVAL);
 391         }
 392
 393         if (strcmp(obd->obd_type->typ_name, OBD_MDC_DEVICENAME) &&
 394             strcmp(obd->obd_type->typ_name, OBD_OSC_DEVICENAME)) {
 395                 CERROR("can't add connection on non-client dev\n");
 396                 RETURN(-EINVAL);
 397         }
 398
 399         imp = obd->u.cli.cl_import;
 400         if (!imp) {
 401                 CERROR("try to del conn on immature client dev\n");
 402                 RETURN(-EINVAL);
 403         }
 404
 405         obd_str2uuid(&uuid, lustre_cfg_string(lcfg, 1));
 406         rc = obd_del_conn(imp, &uuid);
 407
 408         RETURN(rc);
 409 }
 410
 411 LIST_HEAD(lustre_profile_list);
 412
 413 struct lustre_profile *class_get_profile(char * prof)
 414 {
 415         struct lustre_profile *lprof;
 416
 417         list_for_each_entry(lprof, &lustre_profile_list, lp_list) {
 418                 if (!strcmp(lprof->lp_profile, prof)) {
 419                         RETURN(lprof);
 420                 }
 421         }
 422         RETURN(NULL);
 423 }
 424
 425 int class_add_profile(int proflen, char *prof,
 426                       int lovlen, char *lov,
 427                       int lmvlen, char *lmv,
 428                       int gkclen, char *gkc)
 429 {
 430         struct lustre_profile *lprof;
 431         int err = 0;
 432
 433         OBD_ALLOC(lprof, sizeof(*lprof));
 434         if (lprof == NULL)
 435                 GOTO(out, err = -ENOMEM);
 436         INIT_LIST_HEAD(&lprof->lp_list);
 437
 438         LASSERT(proflen == (strlen(prof) + 1));
 439         OBD_ALLOC(lprof->lp_profile, proflen);
 440         if (lprof->lp_profile == NULL)
 441                 GOTO(out, err = -ENOMEM);
 442         memcpy(lprof->lp_profile, prof, proflen);
 443
 444         LASSERT(lovlen == (strlen(lov) + 1));
 445         OBD_ALLOC(lprof->lp_lov, lovlen);
 446         if (lprof->lp_profile == NULL)
 447                 GOTO(out, err = -ENOMEM);
 448         memcpy(lprof->lp_lov, lov, lovlen);
 449
 450         if (lmvlen > 0) {
 451                 LASSERT(lmvlen == (strlen(lmv) + 1));
 452                 OBD_ALLOC(lprof->lp_lmv, lmvlen);
 453                 if (lprof->lp_lmv == NULL)
 454                         GOTO(out, err = -ENOMEM);
 455                 memcpy(lprof->lp_lmv, lmv, lmvlen);
 456         }
 457         if (gkclen > 0 ) {
 458                 LASSERT(gkclen == (strlen(gkc) + 1));
 459                 OBD_ALLOC(lprof->lp_gkc, gkclen);
 460                 if (lprof->lp_gkc == NULL)
 461                         GOTO(out, err = -ENOMEM);
 462                 memcpy(lprof->lp_gkc, gkc, gkclen);
 463         }
 464
 465         list_add(&lprof->lp_list, &lustre_profile_list);
 466 out:
 467         RETURN(err);
 468 }
 469
 470 void class_del_profile(char *prof)
 471 {
 472         struct lustre_profile *lprof;
 473
 474         lprof = class_get_profile(prof);
 475         if (lprof) {
 476                 list_del(&lprof->lp_list);
 477                 OBD_FREE(lprof->lp_profile, strlen(lprof->lp_profile) + 1);
 478                 OBD_FREE(lprof->lp_lov, strlen(lprof->lp_lov) + 1);
 479                 if (lprof->lp_lmv)
 480                         OBD_FREE(lprof->lp_lmv, strlen(lprof->lp_lmv) + 1);
 481                 OBD_FREE(lprof, sizeof *lprof);
 482         }
 483 }
 484
 485 int class_process_config(struct lustre_cfg *lcfg)
 486 {
 487         struct obd_device *obd;
 488         char str[PTL_NALFMT_SIZE];
 489         int err;
 490         ENTRY;
 491
 492         LASSERT(lcfg && !IS_ERR(lcfg));
 493
 494         CDEBUG(D_IOCTL, "processing cmd: %x\n", lcfg->lcfg_command);
 495
 496         /* Commands that don't need a device */
 497         switch(lcfg->lcfg_command) {
 498         case LCFG_ATTACH: {
 499                 err = class_attach(lcfg);
 500                 GOTO(out, err);
 501         }
 502         case LCFG_ADD_UUID: {
 503                 CDEBUG(D_IOCTL, "adding mapping from uuid %s to nid "LPX64
 504                        " (%s), nal %x\n", lustre_cfg_string(lcfg, 1), lcfg->lcfg_nid,
 505                        portals_nid2str(lcfg->lcfg_nal, lcfg->lcfg_nid, str),
 506                        lcfg->lcfg_nal);
 507
 508                err = class_add_uuid(lustre_cfg_string(lcfg, 1), lcfg->lcfg_nid,
 509                                     lcfg->lcfg_nal);
 510                GOTO(out, err);
 511         }
 512         case LCFG_DEL_UUID: {
 513                 CDEBUG(D_IOCTL, "removing mappings for uuid %s\n",
 514                        (lcfg->lcfg_bufcount < 2 || LUSTRE_CFG_BUFLEN(lcfg, 1) == 0)
 515                        ? "<all uuids>" : lustre_cfg_string(lcfg, 1));
 516
 517                 err = class_del_uuid(lustre_cfg_string(lcfg, 1));
 518                 GOTO(out, err);
 519         }
 520         case LCFG_MOUNTOPT: {
 521                 CDEBUG(D_IOCTL, "mountopt: profile %s osc %s mdc %s gkc %s \n",
 522                        lustre_cfg_string(lcfg, 1),
 523                        lustre_cfg_string(lcfg, 2),
 524                        lustre_cfg_string(lcfg, 3),
 525                        lustre_cfg_string(lcfg, 4));
 526                 /* set these mount options somewhere, so ll_fill_super
 527                  * can find them. */
 528                 err = class_add_profile(LUSTRE_CFG_BUFLEN(lcfg, 1),
 529                                         lustre_cfg_string(lcfg, 1),
 530                                         LUSTRE_CFG_BUFLEN(lcfg, 2),
 531                                         lustre_cfg_string(lcfg, 2),
 532                                         LUSTRE_CFG_BUFLEN(lcfg, 3),
 533                                         lustre_cfg_string(lcfg, 3),
 534                                         LUSTRE_CFG_BUFLEN(lcfg, 4),
 535                                         lustre_cfg_string(lcfg, 4));
 536                 GOTO(out, err);
 537         }
 538         case LCFG_DEL_MOUNTOPT: {
 539                 CDEBUG(D_IOCTL, "mountopt: profile %s\n",
 540                        lustre_cfg_string(lcfg, 1));
 541                 /* set these mount options somewhere, so ll_fill_super
 542                  * can find them. */
 543                 class_del_profile(lustre_cfg_string(lcfg, 1));
 544                 GOTO(out, err = 0);
 545         }
 546         case LCFG_SET_TIMEOUT: {
 547                 CDEBUG(D_IOCTL, "changing lustre timeout from %d to %d\n",
 548                        obd_timeout,
 549                        lcfg->lcfg_num);
 550                 obd_timeout = lcfg->lcfg_num;
 551                 GOTO(out, err = 0);
 552         }
 553         case LCFG_SET_UPCALL: {
 554                 CDEBUG(D_IOCTL, "setting lustre ucpall to: %s\n",
 555                        lustre_cfg_string(lcfg, 1));
 556                 if (LUSTRE_CFG_BUFLEN(lcfg, 1) > sizeof obd_lustre_upcall)
 557                         GOTO(out, err = -EINVAL);
 558                 strncpy(obd_lustre_upcall, lustre_cfg_string(lcfg, 1),
 559                         sizeof (obd_lustre_upcall));
 560                 GOTO(out, err = 0);
 561         }
 562         }
 563
 564         /* Commands that require a device */
 565         obd = class_name2obd(lustre_cfg_string(lcfg, 0));
 566         if (obd == NULL) {
 567                 if (!LUSTRE_CFG_BUFLEN(lcfg, 0))
 568                         CERROR("this lcfg command %d requires a device name\n",
 569                                lcfg->lcfg_command);
 570                 else
 571                         CERROR("no device for: %s\n",
 572                                lustre_cfg_string(lcfg, 0));
 573
 574                 GOTO(out, err = -EINVAL);
 575         }
 576
 577         switch(lcfg->lcfg_command) {
 578         case LCFG_SETUP: {
 579                 err = class_setup(obd, lcfg);
 580                 GOTO(out, err);
 581         }
 582         case LCFG_DETACH: {
 583                 err = class_detach(obd, lcfg);
 584                 GOTO(out, err = 0);
 585         }
 586         case LCFG_CLEANUP: {
 587                 err = class_cleanup(obd, lcfg);
 588                 GOTO(out, err = 0);
 589         }
 590         case LCFG_ADD_CONN: {
 591                 err = class_add_conn(obd, lcfg);
 592                 GOTO(out, err = 0);
 593         }
 594         case LCFG_DEL_CONN: {
 595                 err = class_del_conn(obd, lcfg);
 596                 GOTO(out, err = 0);
 597         }
 598         default: {
 599                 err = obd_process_config(obd, sizeof(*lcfg), lcfg);
 600                 GOTO(out, err);
 601
 602         }
 603         }
 604 out:
 605         return err;
 606 }
 607
 608 static int class_config_parse_handler(struct llog_handle * handle,
 609                                       struct llog_rec_hdr *rec, void *data)
 610 {
 611         struct config_llog_instance *cfg = data;
 612         int cfg_len = rec->lrh_len;
 613         char *cfg_buf = (char*) (rec + 1);
 614         int rc = 0;
 615         ENTRY;
 616
 617         if (rec->lrh_type == OBD_CFG_REC) {
 618                 struct lustre_cfg *lcfg, *lcfg_new;
 619                 struct lustre_cfg_bufs bufs;
 620
 621                 char *inst_name = NULL;
 622                 int inst_len = 0;
 623                 int inst = 0;
 624
 625                 lcfg = (struct lustre_cfg *)cfg_buf;
 626                 if (lcfg->lcfg_version == __swab32(LUSTRE_CFG_VERSION))
 627                         lustre_swab_lustre_cfg(lcfg);
 628
 629                 rc = lustre_cfg_sanity_check(cfg_buf, cfg_len);
 630                 if (rc)
 631                         GOTO(out, rc);
 632
 633                 lustre_cfg_bufs_init(&bufs, lcfg);
 634                 if (cfg && cfg->cfg_instance && LUSTRE_CFG_BUFLEN(lcfg, 0) > 0) {
 635                         inst = 1;
 636                         inst_len = LUSTRE_CFG_BUFLEN(lcfg, 0) +
 637                                 strlen(cfg->cfg_instance) + 1;
 638                         OBD_ALLOC(inst_name, inst_len);
 639                         if (inst_name == NULL)
 640                                 GOTO(out, rc = -ENOMEM);
 641                         sprintf(inst_name, "%s-%s",
 642                                 lustre_cfg_string(lcfg, 0),
 643                                 cfg->cfg_instance);
 644                         lustre_cfg_bufs_set_string(&bufs, 0, inst_name);
 645
 646                 }
 647                 if (cfg && lcfg->lcfg_command == LCFG_ATTACH)
 648                         lustre_cfg_bufs_set_string(&bufs, 2,
 649                                                    (char *)cfg->cfg_uuid.uuid);
 650
 651                 if (cfg && cfg->cfg_instance &&
 652                     lcfg->lcfg_command == LCFG_SETUP) {
 653                         /*add cfg_instance to the end of lcfg buffers*/
 654                         lustre_cfg_bufs_set_string(&bufs, bufs.lcfg_bufcount,
 655                                                    cfg->cfg_instance);
 656                 }
 657                 lcfg_new = lustre_cfg_new(lcfg->lcfg_command, &bufs);
 658
 659                 lcfg_new->lcfg_num   = lcfg->lcfg_num;
 660                 lcfg_new->lcfg_flags = lcfg->lcfg_flags;
 661                 lcfg_new->lcfg_nid   = lcfg->lcfg_nid;
 662                 lcfg_new->lcfg_nal   = lcfg->lcfg_nal;
 663
 664                 rc = class_process_config(lcfg_new);
 665                 lustre_cfg_free(lcfg_new);
 666
 667                 if (inst)
 668                         OBD_FREE(inst_name, inst_len);
 669         } else if (rec->lrh_type == PTL_CFG_REC) {
 670                 struct portals_cfg *pcfg = (struct portals_cfg *)cfg_buf;
 671                 if (pcfg->pcfg_command == NAL_CMD_REGISTER_MYNID &&
 672                     cfg->cfg_local_nid != PTL_NID_ANY) {
 673                         pcfg->pcfg_nid = cfg->cfg_local_nid;
 674                 }
 675
 676                 rc = libcfs_nal_cmd(pcfg);
 677         } else {
 678                 CERROR("unrecognized record type: 0x%x\n", rec->lrh_type);
 679         }
 680 out:
 681         RETURN(rc);
 682 }
 683
 684 int class_config_process_llog(struct llog_ctxt *ctxt, char *name,
 685                               struct config_llog_instance *cfg)
 686 {
 687         struct llog_handle *llh;
 688         int rc, rc2;
 689         ENTRY;
 690
 691         rc = llog_open(ctxt, &llh, NULL, name, 0);
 692         if (rc)
 693                 RETURN(rc);
 694
 695         rc = llog_init_handle(llh, LLOG_F_IS_PLAIN, NULL);
 696         if (rc == 0)
 697                 rc = llog_process(llh, class_config_parse_handler, cfg, NULL);
 698
 699         rc2 = llog_close(llh);
 700         if (rc == 0)
 701                 rc = rc2;
 702
 703         RETURN(rc);
 704 }
 705
 706 int class_config_dump_handler(struct llog_handle * handle,
 707                               struct llog_rec_hdr *rec, void *data)
 708 {
 709         int cfg_len = rec->lrh_len;
 710         char *cfg_buf = (char*) (rec + 1);
 711         int rc = 0;
 712         ENTRY;
 713         if (rec->lrh_type == OBD_CFG_REC) {
 714                 struct lustre_cfg *lcfg;
 715                 int i;
 716
 717                 rc = lustre_cfg_sanity_check(cfg_buf, cfg_len);
 718                 if (rc)
 719                         GOTO(out, rc);
 720                 lcfg = (struct lustre_cfg *)cfg_buf;
 721
 722                 CDEBUG(D_INFO, "lcfg command: %x\n", lcfg->lcfg_command);
 723                 if (LUSTRE_CFG_BUFLEN(lcfg, 0) > 0)
 724                         CDEBUG(D_INFO, "     devname: %s\n",
 725                                lustre_cfg_string(lcfg, 0));
 726                 if (lcfg->lcfg_flags)
 727                         CDEBUG(D_INFO, "       flags: %x\n", lcfg->lcfg_flags);
 728                 if (lcfg->lcfg_nid)
 729                         CDEBUG(D_INFO, "         nid: "LPX64"\n",
 730                                lcfg->lcfg_nid);
 731                 if (lcfg->lcfg_nal)
 732                         CDEBUG(D_INFO, "         nal: %x\n", lcfg->lcfg_nal);
 733                 if (lcfg->lcfg_num)
 734                         CDEBUG(D_INFO, "         nal: %x\n", lcfg->lcfg_num);
 735                 for (i = 1; i < lcfg->lcfg_bufcount; i++)
 736                         if (LUSTRE_CFG_BUFLEN(lcfg, i) > 0)
 737                                 CDEBUG(D_INFO, "     inlbuf%d: %s\n", i,
 738                                        lustre_cfg_string(lcfg, i));
 739         } else if (rec->lrh_type == PTL_CFG_REC) {
 740                 struct portals_cfg *pcfg = (struct portals_cfg *)cfg_buf;
 741                 CDEBUG(D_INFO, "pcfg command: %d\n", pcfg->pcfg_command);
 742                 if (pcfg->pcfg_nal)
 743                         CDEBUG(D_INFO, "         nal: %x\n",
 744                                pcfg->pcfg_nal);
 745                 if (pcfg->pcfg_gw_nal)
 746                         CDEBUG(D_INFO, "      gw_nal: %x\n",
 747                                pcfg->pcfg_gw_nal);
 748                 if (pcfg->pcfg_nid)
 749                         CDEBUG(D_INFO, "         nid: "LPX64"\n",
 750                                pcfg->pcfg_nid);
 751                 if (pcfg->pcfg_nid2)
 752                         CDEBUG(D_INFO, "         nid: "LPX64"\n",
 753                                pcfg->pcfg_nid2);
 754                 if (pcfg->pcfg_nid3)
 755                         CDEBUG(D_INFO, "         nid: "LPX64"\n",
 756                                pcfg->pcfg_nid3);
 757                 if (pcfg->pcfg_misc)
 758                         CDEBUG(D_INFO, "         nid: %d\n",
 759                                pcfg->pcfg_misc);
 760                 if (pcfg->pcfg_id)
 761                         CDEBUG(D_INFO, "          id: %x\n",
 762                                pcfg->pcfg_id);
 763                 if (pcfg->pcfg_flags)
 764                         CDEBUG(D_INFO, "       flags: %x\n",
 765                                pcfg->pcfg_flags);
 766         } else {
 767                 CERROR("unhandled lrh_type: %#x\n", rec->lrh_type);
 768                 rc = -EINVAL;
 769         }
 770 out:
 771         RETURN(rc);
 772 }
 773
 774 int class_config_dump_llog(struct llog_ctxt *ctxt, char *name,
 775                            struct config_llog_instance *cfg)
 776 {
 777         struct llog_handle *llh;
 778         int rc, rc2;
 779         ENTRY;
 780
 781         rc = llog_open(ctxt, &llh, NULL, name, 0);
 782         if (rc)
 783                 RETURN(rc);
 784
 785         rc = llog_init_handle(llh, LLOG_F_IS_PLAIN, NULL);
 786         if (rc == 0)
 787                 rc = llog_process(llh, class_config_dump_handler, cfg, NULL);
 788
 789         rc2 = llog_close(llh);
 790         if (rc == 0)
 791                 rc = rc2;
 792
 793         RETURN(rc);
 794 }