lustre/obdclass/obd_config.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.gnu.org/licenses/gpl-2.0.html
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * Copyright (c) 2011, 2017, Intel Corporation.
  27  */
  28 /*
  29  * This file is part of Lustre, http://www.lustre.org/
  30  * Lustre is a trademark of Sun Microsystems, Inc.
  31  *
  32  * lustre/obdclass/obd_config.c
  33  *
  34  * Config API
  35  */
  36
  37 #define DEBUG_SUBSYSTEM S_CLASS
  38
  39 #include <linux/kobject.h>
  40 #include <linux/string.h>
  41
  42 #include <llog_swab.h>
  43 #include <lprocfs_status.h>
  44 #include <lustre_disk.h>
  45 #include <uapi/linux/lustre/lustre_ioctl.h>
  46 #include <lustre_log.h>
  47 #include <uapi/linux/lustre/lustre_param.h>
  48 #include <obd_class.h>
  49
  50 #include "llog_internal.h"
  51
  52 static struct cfs_hash_ops nid_hash_ops;
  53 static struct cfs_hash_ops nid_stat_hash_ops;
  54 static struct cfs_hash_ops gen_hash_ops;
  55
  56 /*
  57  * uuid<->export lustre hash operations
  58  */
  59 /*
  60  * NOTE: It is impossible to find an export that is in failed
  61  *      state with this function
  62  */
  63 static int
  64 uuid_keycmp(struct rhashtable_compare_arg *arg, const void *obj)
  65 {
  66         const struct obd_uuid *uuid = arg->key;
  67         const struct obd_export *exp = obj;
  68
  69         if (obd_uuid_equals(uuid, &exp->exp_client_uuid) &&
  70             !exp->exp_failed)
  71                 return 0;
  72         return -ESRCH;
  73 }
  74
  75 static void
  76 obd_export_exit(void *vexport, void *data)
  77 {
  78         struct obd_export *exp = vexport;
  79
  80         class_export_put(exp);
  81 }
  82
  83 static const struct rhashtable_params uuid_hash_params = {
  84         .key_len        = sizeof(struct obd_uuid),
  85         .key_offset     = offsetof(struct obd_export, exp_client_uuid),
  86         .head_offset    = offsetof(struct obd_export, exp_uuid_hash),
  87         .obj_cmpfn      = uuid_keycmp,
  88         .max_size       = MAX_OBD_DEVICES,
  89         .automatic_shrinking = true,
  90 };
  91
  92 int obd_uuid_add(struct obd_device *obd, struct obd_export *export)
  93 {
  94         int rc;
  95
  96         class_export_get(export);
  97         rcu_read_lock();
  98         rc = rhashtable_lookup_insert_fast(&obd->obd_uuid_hash,
  99                                            &export->exp_uuid_hash,
 100                                            uuid_hash_params);
 101         if (rc) {
 102                 class_export_put(export);
 103                 if (rc != -EEXIST) {
 104                         /* map obscure error codes to -ENOMEM */
 105                         rc = -ENOMEM;
 106                 } else {
 107                         rc = -EALREADY;
 108                 }
 109         }
 110         rcu_read_unlock();
 111
 112         return rc;
 113 }
 114 EXPORT_SYMBOL(obd_uuid_add);
 115
 116 void obd_uuid_del(struct obd_device *obd, struct obd_export *export)
 117 {
 118         int rc;
 119
 120         rcu_read_lock();
 121         rc = rhashtable_remove_fast(&obd->obd_uuid_hash,
 122                                     &export->exp_uuid_hash,
 123                                     uuid_hash_params);
 124         if (!rc)
 125                 class_export_put(export);
 126         rcu_read_unlock();
 127 }
 128 EXPORT_SYMBOL(obd_uuid_del);
 129
 130 #ifdef HAVE_SERVER_SUPPORT
 131 /* obd_uuid_lookup() is used only server side by target_handle_connect(),
 132  * mdt_hsm_agent_send(), and obd_export_evict_by_uuid().
 133  */
 134 struct obd_export *obd_uuid_lookup(struct obd_device *obd,
 135                                    struct obd_uuid *uuid)
 136 {
 137         struct obd_export *export = NULL;
 138
 139         rcu_read_lock();
 140         export = rhashtable_lookup_fast(&obd->obd_uuid_hash, uuid,
 141                                         uuid_hash_params);
 142         if (export && !refcount_inc_not_zero(&export->exp_handle.h_ref))
 143                 export = NULL;
 144         rcu_read_unlock();
 145
 146         return export;
 147 }
 148 EXPORT_SYMBOL(obd_uuid_lookup);
 149 #endif /* HAVE_SERVER_SUPPORT */
 150
 151 /*********** string parsing utils *********/
 152
 153 /* returns 0 if we find this key in the buffer, else 1 */
 154 int class_find_param(char *buf, char *key, char **valp)
 155 {
 156         char *ptr;
 157
 158         if (!buf)
 159                 return 1;
 160
 161         ptr = strstr(buf, key);
 162         if (!ptr)
 163                 return 1;
 164
 165         if (valp)
 166                 *valp = ptr + strlen(key);
 167
 168         return 0;
 169 }
 170 EXPORT_SYMBOL(class_find_param);
 171
 172 /**
 173  * Check whether the proc parameter \a param is an old parameter or not from
 174  * the array \a ptr which contains the mapping from old parameters to new ones.
 175  * If it's an old one, then return the pointer to the cfg_interop_param struc-
 176  * ture which contains both the old and new parameters.
 177  *
 178  * \param param                 proc parameter
 179  * \param ptr                   an array which contains the mapping from
 180  *                              old parameters to new ones
 181  *
 182  * \retval valid-pointer        pointer to the cfg_interop_param structure
 183  *                              which contains the old and new parameters
 184  * \retval NULL                 \a param or \a ptr is NULL,
 185  *                              or \a param is not an old parameter
 186  */
 187 struct cfg_interop_param *class_find_old_param(const char *param,
 188                                                struct cfg_interop_param *ptr)
 189 {
 190         char *value = NULL;
 191         int   name_len = 0;
 192
 193         if (!param || !ptr)
 194                 RETURN(NULL);
 195
 196         value = strchr(param, '=');
 197         if (value)
 198                 name_len = value - param;
 199         else
 200                 name_len = strlen(param);
 201
 202         while (ptr->old_param) {
 203                 if (strncmp(param, ptr->old_param, name_len) == 0 &&
 204                     name_len == strlen(ptr->old_param))
 205                         RETURN(ptr);
 206                 ptr++;
 207         }
 208
 209         RETURN(NULL);
 210 }
 211 EXPORT_SYMBOL(class_find_old_param);
 212
 213 /**
 214  * Finds a parameter in \a params and copies it to \a copy.
 215  *
 216  * Leading spaces are skipped. Next space or end of string is the
 217  * parameter terminator with the exception that spaces inside single or double
 218  * quotes get included into a parameter. The parameter is copied into \a copy
 219  * which has to be allocated big enough by a caller, quotes are stripped in
 220  * the copy and the copy is terminated by 0.
 221  *
 222  * On return \a params is set to next parameter or to NULL if last
 223  * parameter is returned.
 224  *
 225  * \retval 0 if parameter is returned in \a copy
 226  * \retval 1 otherwise
 227  * \retval -EINVAL if unbalanced quota is found
 228  */
 229 int class_get_next_param(char **params, char *copy)
 230 {
 231         char *q1, *q2, *str;
 232         int len;
 233
 234         str = *params;
 235         while (*str == ' ')
 236                 str++;
 237
 238         if (*str == '\0') {
 239                 *params = NULL;
 240                 return 1;
 241         }
 242
 243         while (1) {
 244                 q1 = strpbrk(str, " '\"");
 245                 if (!q1) {
 246                         len = strlen(str);
 247                         memcpy(copy, str, len);
 248                         copy[len] = '\0';
 249                         *params = NULL;
 250                         return 0;
 251                 }
 252                 len = q1 - str;
 253                 if (*q1 == ' ') {
 254                         memcpy(copy, str, len);
 255                         copy[len] = '\0';
 256                         *params = str + len;
 257                         return 0;
 258                 }
 259
 260                 memcpy(copy, str, len);
 261                 copy += len;
 262
 263                 /* search for the matching closing quote */
 264                 str = q1 + 1;
 265                 q2 = strchr(str, *q1);
 266                 if (!q2) {
 267                         CERROR("Unbalanced quota in parameters: \"%s\"\n",
 268                                *params);
 269                         return -EINVAL;
 270                 }
 271                 len = q2 - str;
 272                 memcpy(copy, str, len);
 273                 copy += len;
 274                 str = q2 + 1;
 275         }
 276         return 1;
 277 }
 278 EXPORT_SYMBOL(class_get_next_param);
 279
 280 /*
 281  * returns 0 if this is the first key in the buffer, else 1.
 282  * valp points to first char after key.
 283  */
 284 int class_match_param(char *buf, const char *key, char **valp)
 285 {
 286         if (!buf)
 287                 return 1;
 288
 289         if (memcmp(buf, key, strlen(key)) != 0)
 290                 return 1;
 291
 292         if (valp)
 293                 *valp = buf + strlen(key);
 294
 295         return 0;
 296 }
 297 EXPORT_SYMBOL(class_match_param);
 298
 299 static int parse_nid(char *buf, void *value, int quiet)
 300 {
 301         lnet_nid_t *nid = (lnet_nid_t *)value;
 302
 303         *nid = libcfs_str2nid(buf);
 304         if (*nid != LNET_NID_ANY)
 305                 return 0;
 306
 307         if (!quiet)
 308                 LCONSOLE_ERROR_MSG(0x159, "Can't parse NID '%s'\n", buf);
 309         return -EINVAL;
 310 }
 311
 312 static int parse_net(char *buf, void *value)
 313 {
 314         __u32 *net = (__u32 *)value;
 315
 316         *net = libcfs_str2net(buf);
 317         CDEBUG(D_INFO, "Net %s\n", libcfs_net2str(*net));
 318         return 0;
 319 }
 320
 321 enum {
 322         CLASS_PARSE_NID = 1,
 323         CLASS_PARSE_NET,
 324 };
 325
 326 /*
 327  * 0 is good NID,
 328  * 1 not found
 329  * < 0 error
 330  * endh is set to next separator
 331  */
 332 static int class_parse_value(char *buf, int opc, void *value, char **endh,
 333                              int quiet)
 334 {
 335         char *endp;
 336         char  tmp;
 337         int   rc = 0;
 338
 339         if (!buf)
 340                 return 1;
 341         while (*buf == ',' || *buf == ':')
 342                 buf++;
 343         if (*buf == ' ' || *buf == '/' || *buf == '\0')
 344                 return 1;
 345
 346         /* NID separators or end of NIDs */
 347         endp = strpbrk(buf, ",: /");
 348         if (!endp)
 349                 endp = buf + strlen(buf);
 350
 351         tmp = *endp;
 352         *endp = '\0';
 353         switch (opc) {
 354         default:
 355                 LBUG();
 356         case CLASS_PARSE_NID:
 357                 rc = parse_nid(buf, value, quiet);
 358                 break;
 359         case CLASS_PARSE_NET:
 360                 rc = parse_net(buf, value);
 361                 break;
 362         }
 363         *endp = tmp;
 364         if (rc != 0)
 365                 return rc;
 366         if (endh)
 367                 *endh = endp;
 368         return 0;
 369 }
 370
 371 int class_parse_nid(char *buf, lnet_nid_t *nid, char **endh)
 372 {
 373         return class_parse_value(buf, CLASS_PARSE_NID, (void *)nid, endh, 0);
 374 }
 375 EXPORT_SYMBOL(class_parse_nid);
 376
 377 int class_parse_nid_quiet(char *buf, lnet_nid_t *nid, char **endh)
 378 {
 379         return class_parse_value(buf, CLASS_PARSE_NID, (void *)nid, endh, 1);
 380 }
 381 EXPORT_SYMBOL(class_parse_nid_quiet);
 382
 383 int class_parse_net(char *buf, __u32 *net, char **endh)
 384 {
 385         return class_parse_value(buf, CLASS_PARSE_NET, (void *)net, endh, 0);
 386 }
 387
 388 /*
 389  * 1 param contains key and match
 390  * 0 param contains key and not match
 391  * -1 param does not contain key
 392  */
 393 int class_match_nid(char *buf, char *key, lnet_nid_t nid)
 394 {
 395         lnet_nid_t tmp;
 396         int rc = -1;
 397
 398         while (class_find_param(buf, key, &buf) == 0) {
 399                 /*
 400                  * please restrict to the NIDs pertaining to
 401                  * the specified NIDs
 402                  */
 403                 while (class_parse_nid(buf, &tmp, &buf) == 0) {
 404                         if (tmp == nid)
 405                                 return 1;
 406                 }
 407                 rc = 0;
 408         }
 409         return rc;
 410 }
 411
 412 int class_match_net(char *buf, char *key, __u32 net)
 413 {
 414         __u32 tmp;
 415         int rc = -1;
 416
 417         while (class_find_param(buf, key, &buf) == 0) {
 418                 /*
 419                  * please restrict to the NIDs pertaining to
 420                  * the specified networks
 421                  */
 422                 while (class_parse_net(buf, &tmp, &buf) == 0) {
 423                         if (tmp == net)
 424                                 return 1;
 425                 }
 426                 rc = 0;
 427         }
 428         return rc;
 429 }
 430
 431 char *lustre_cfg_string(struct lustre_cfg *lcfg, u32 index)
 432 {
 433         char *s;
 434
 435         if (!lcfg->lcfg_buflens[index])
 436                 return NULL;
 437
 438         s = lustre_cfg_buf(lcfg, index);
 439         if (!s)
 440                 return NULL;
 441
 442         /*
 443          * make sure it's NULL terminated, even if this kills a char
 444          * of data.  Try to use the padding first though.
 445          */
 446         if (s[lcfg->lcfg_buflens[index] - 1] != '\0') {
 447                 size_t last = ALIGN(lcfg->lcfg_buflens[index], 8) - 1;
 448                 char lost;
 449
 450                 /* Use the smaller value */
 451                 if (last > lcfg->lcfg_buflens[index])
 452                         last = lcfg->lcfg_buflens[index];
 453
 454                 lost = s[last];
 455                 s[last] = '\0';
 456                 if (lost != '\0') {
 457                         CWARN("Truncated buf %d to '%s' (lost '%c'...)\n",
 458                               index, s, lost);
 459                 }
 460         }
 461         return s;
 462 }
 463 EXPORT_SYMBOL(lustre_cfg_string);
 464
 465 /********************** class fns **********************/
 466
 467 /**
 468  * Create a new OBD device and set the type, name and uuid.  If successful,
 469  * the new device can be accessed by either name or uuid.
 470  */
 471 int class_attach(struct lustre_cfg *lcfg)
 472 {
 473         struct obd_export *exp;
 474         struct obd_device *obd = NULL;
 475         char *typename, *name, *uuid;
 476         int rc, len;
 477
 478         ENTRY;
 479
 480         if (!LUSTRE_CFG_BUFLEN(lcfg, 1)) {
 481                 CERROR("No type passed!\n");
 482                 RETURN(-EINVAL);
 483         }
 484         typename = lustre_cfg_string(lcfg, 1);
 485
 486         if (!LUSTRE_CFG_BUFLEN(lcfg, 0)) {
 487                 CERROR("No name passed!\n");
 488                 RETURN(-EINVAL);
 489         }
 490         name = lustre_cfg_string(lcfg, 0);
 491         if (!LUSTRE_CFG_BUFLEN(lcfg, 2)) {
 492                 CERROR("No UUID passed!\n");
 493                 RETURN(-EINVAL);
 494         }
 495
 496         uuid = lustre_cfg_string(lcfg, 2);
 497         len = strlen(uuid);
 498         if (len >= sizeof(obd->obd_uuid)) {
 499                 CERROR("%s: uuid must be < %d bytes long\n",
 500                        name, (int)sizeof(obd->obd_uuid));
 501                 RETURN(-EINVAL);
 502         }
 503
 504         obd = class_newdev(typename, name, uuid);
 505         if (IS_ERR(obd)) { /* Already exists or out of obds */
 506                 rc = PTR_ERR(obd);
 507                 CERROR("Cannot create device %s of type %s : %d\n",
 508                        name, typename, rc);
 509                 RETURN(rc);
 510         }
 511         LASSERTF(obd->obd_magic == OBD_DEVICE_MAGIC,
 512                  "obd %p obd_magic %08X != %08X\n",
 513                  obd, obd->obd_magic, OBD_DEVICE_MAGIC);
 514         LASSERTF(strncmp(obd->obd_name, name, strlen(name)) == 0,
 515                  "%p obd_name %s != %s\n", obd, obd->obd_name, name);
 516
 517         exp = class_new_export_self(obd, &obd->obd_uuid);
 518         if (IS_ERR(exp)) {
 519                 rc = PTR_ERR(exp);
 520                 class_free_dev(obd);
 521                 RETURN(rc);
 522         }
 523
 524         obd->obd_self_export = exp;
 525         list_del_init(&exp->exp_obd_chain_timed);
 526         class_export_put(exp);
 527
 528         rc = class_register_device(obd);
 529         if (rc != 0) {
 530                 class_decref(obd, "newdev", obd);
 531                 RETURN(rc);
 532         }
 533
 534         obd->obd_attached = 1;
 535         CDEBUG(D_IOCTL, "OBD: dev %d attached type %s with refcount %d\n",
 536                obd->obd_minor, typename, atomic_read(&obd->obd_refcount));
 537
 538         RETURN(0);
 539 }
 540 EXPORT_SYMBOL(class_attach);
 541
 542 /**
 543  * Create hashes, self-export, and call type-specific setup.
 544  * Setup is effectively the "start this obd" call.
 545  */
 546 int class_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
 547 {
 548         int err = 0;
 549
 550         ENTRY;
 551
 552         LASSERT(obd != NULL);
 553         LASSERTF(obd == class_num2obd(obd->obd_minor),
 554                  "obd %p != obd_devs[%d] %p\n",
 555                  obd, obd->obd_minor, class_num2obd(obd->obd_minor));
 556         LASSERTF(obd->obd_magic == OBD_DEVICE_MAGIC,
 557                  "obd %p obd_magic %08x != %08x\n",
 558                  obd, obd->obd_magic, OBD_DEVICE_MAGIC);
 559
 560         /* have we attached a type to this device? */
 561         if (!obd->obd_attached) {
 562                 CERROR("Device %d not attached\n", obd->obd_minor);
 563                 RETURN(-ENODEV);
 564         }
 565
 566         if (obd->obd_set_up) {
 567                 CERROR("Device %d already setup (type %s)\n",
 568                        obd->obd_minor, obd->obd_type->typ_name);
 569                 RETURN(-EEXIST);
 570         }
 571
 572         /* is someone else setting us up right now? (attach inits spinlock) */
 573         spin_lock(&obd->obd_dev_lock);
 574         if (obd->obd_starting) {
 575                 spin_unlock(&obd->obd_dev_lock);
 576                 CERROR("Device %d setup in progress (type %s)\n",
 577                        obd->obd_minor, obd->obd_type->typ_name);
 578                 RETURN(-EEXIST);
 579         }
 580         /*
 581          * just leave this on forever.  I can't use obd_set_up here because
 582          * other fns check that status, and we're not actually set up yet.
 583          */
 584         obd->obd_starting = 1;
 585         obd->obd_nid_hash = NULL;
 586         obd->obd_nid_stats_hash = NULL;
 587         obd->obd_gen_hash = NULL;
 588         spin_unlock(&obd->obd_dev_lock);
 589
 590         /* create an uuid-export lustre hash */
 591         err = rhashtable_init(&obd->obd_uuid_hash, &uuid_hash_params);
 592         if (err)
 593                 GOTO(err_starting, err);
 594
 595         /* create a nid-export lustre hash */
 596         obd->obd_nid_hash = cfs_hash_create("NID_HASH",
 597                                             HASH_NID_CUR_BITS,
 598                                             HASH_NID_MAX_BITS,
 599                                             HASH_NID_BKT_BITS, 0,
 600                                             CFS_HASH_MIN_THETA,
 601                                             CFS_HASH_MAX_THETA,
 602                                             &nid_hash_ops, CFS_HASH_DEFAULT);
 603         if (!obd->obd_nid_hash)
 604                 GOTO(err_uuid_hash, err = -ENOMEM);
 605
 606         /* create a nid-stats lustre hash */
 607         obd->obd_nid_stats_hash = cfs_hash_create("NID_STATS",
 608                                                   HASH_NID_STATS_CUR_BITS,
 609                                                   HASH_NID_STATS_MAX_BITS,
 610                                                   HASH_NID_STATS_BKT_BITS, 0,
 611                                                   CFS_HASH_MIN_THETA,
 612                                                   CFS_HASH_MAX_THETA,
 613                                                   &nid_stat_hash_ops,
 614                                                   CFS_HASH_DEFAULT);
 615         if (!obd->obd_nid_stats_hash)
 616                 GOTO(err_nid_hash, err = -ENOMEM);
 617
 618         /* create a client_generation-export lustre hash */
 619         obd->obd_gen_hash = cfs_hash_create("UUID_HASH",
 620                                             HASH_GEN_CUR_BITS,
 621                                             HASH_GEN_MAX_BITS,
 622                                             HASH_GEN_BKT_BITS, 0,
 623                                             CFS_HASH_MIN_THETA,
 624                                             CFS_HASH_MAX_THETA,
 625                                             &gen_hash_ops, CFS_HASH_DEFAULT);
 626         if (!obd->obd_gen_hash)
 627                 GOTO(err_nid_stats_hash, err = -ENOMEM);
 628
 629         err = obd_setup(obd, lcfg);
 630         if (err)
 631                 GOTO(err_gen_hash, err);
 632
 633         obd->obd_set_up = 1;
 634
 635         spin_lock(&obd->obd_dev_lock);
 636         /* cleanup drops this */
 637         class_incref(obd, "setup", obd);
 638         spin_unlock(&obd->obd_dev_lock);
 639
 640         CDEBUG(D_IOCTL, "finished setup of obd %s (uuid %s)\n",
 641                obd->obd_name, obd->obd_uuid.uuid);
 642
 643         RETURN(0);
 644
 645 err_gen_hash:
 646         if (obd->obd_gen_hash) {
 647                 cfs_hash_putref(obd->obd_gen_hash);
 648                 obd->obd_gen_hash = NULL;
 649         }
 650 err_nid_stats_hash:
 651         if (obd->obd_nid_stats_hash) {
 652                 cfs_hash_putref(obd->obd_nid_stats_hash);
 653                 obd->obd_nid_stats_hash = NULL;
 654         }
 655 err_nid_hash:
 656         if (obd->obd_nid_hash) {
 657                 cfs_hash_putref(obd->obd_nid_hash);
 658                 obd->obd_nid_hash = NULL;
 659         }
 660 err_uuid_hash:
 661         rhashtable_destroy(&obd->obd_uuid_hash);
 662 err_starting:
 663         obd->obd_starting = 0;
 664         CERROR("setup %s failed (%d)\n", obd->obd_name, err);
 665         return err;
 666 }
 667 EXPORT_SYMBOL(class_setup);
 668
 669 /**
 670  * We have finished using this OBD and are ready to destroy it.
 671  * There can be no more references to this obd.
 672  */
 673 int class_detach(struct obd_device *obd, struct lustre_cfg *lcfg)
 674 {
 675         ENTRY;
 676
 677         if (obd->obd_set_up) {
 678                 CERROR("OBD device %d still set up\n", obd->obd_minor);
 679                 RETURN(-EBUSY);
 680         }
 681
 682         spin_lock(&obd->obd_dev_lock);
 683         if (!obd->obd_attached) {
 684                 spin_unlock(&obd->obd_dev_lock);
 685                 CERROR("OBD device %d not attached\n", obd->obd_minor);
 686                 RETURN(-ENODEV);
 687         }
 688         obd->obd_attached = 0;
 689         spin_unlock(&obd->obd_dev_lock);
 690
 691         /* cleanup in progress. we don't like to find this device after now */
 692         class_unregister_device(obd);
 693
 694         CDEBUG(D_IOCTL, "detach on obd %s (uuid %s)\n",
 695                obd->obd_name, obd->obd_uuid.uuid);
 696
 697         class_decref(obd, "newdev", obd);
 698
 699         RETURN(0);
 700 }
 701 EXPORT_SYMBOL(class_detach);
 702
 703 /**
 704  * Start shutting down the OBD.  There may be in-progess ops when
 705  * this is called.  We tell them to start shutting down with a call
 706  * to class_disconnect_exports().
 707  */
 708 int class_cleanup(struct obd_device *obd, struct lustre_cfg *lcfg)
 709 {
 710         int err = 0;
 711         char *flag;
 712         ENTRY;
 713
 714         OBD_RACE(OBD_FAIL_LDLM_RECOV_CLIENTS);
 715
 716         if (!obd->obd_set_up) {
 717                 CERROR("Device %d not setup\n", obd->obd_minor);
 718                 RETURN(-ENODEV);
 719         }
 720
 721         spin_lock(&obd->obd_dev_lock);
 722         if (obd->obd_stopping) {
 723                 spin_unlock(&obd->obd_dev_lock);
 724                 CERROR("OBD %d already stopping\n", obd->obd_minor);
 725                 RETURN(-ENODEV);
 726         }
 727         /* Leave this on forever */
 728         obd->obd_stopping = 1;
 729         /*
 730          * function can't return error after that point, so clear setup flag
 731          * as early as possible to avoid finding via obd_devs / hash
 732          */
 733         obd->obd_set_up = 0;
 734         spin_unlock(&obd->obd_dev_lock);
 735
 736         /* wait for already-arrived-connections to finish. */
 737         while (obd->obd_conn_inprogress > 0)
 738                 yield();
 739         smp_rmb();
 740
 741         if (lcfg->lcfg_bufcount >= 2 && LUSTRE_CFG_BUFLEN(lcfg, 1) > 0) {
 742                 for (flag = lustre_cfg_string(lcfg, 1); *flag != 0; flag++)
 743                         switch (*flag) {
 744                         case 'F':
 745                                 obd->obd_force = 1;
 746                                 break;
 747                         case 'A':
 748                                 LCONSOLE_WARN("Failing over %s\n",
 749                                               obd->obd_name);
 750                                 obd->obd_fail = 1;
 751                                 obd->obd_no_transno = 1;
 752                                 obd->obd_no_recov = 1;
 753                                 if (OBP(obd, iocontrol)) {
 754                                         obd_iocontrol(OBD_IOC_SYNC,
 755                                                       obd->obd_self_export,
 756                                                       0, NULL, NULL);
 757                                 }
 758                                 break;
 759                         default:
 760                                 CERROR("Unrecognised flag '%c'\n", *flag);
 761                         }
 762         }
 763
 764         LASSERT(obd->obd_self_export);
 765
 766         CDEBUG(D_IOCTL, "%s: forcing exports to disconnect: %d/%d\n",
 767                obd->obd_name, obd->obd_num_exports,
 768                atomic_read(&obd->obd_refcount) - 2);
 769         dump_exports(obd, 0, D_HA);
 770         class_disconnect_exports(obd);
 771
 772         /* Precleanup, we must make sure all exports get destroyed. */
 773         err = obd_precleanup(obd);
 774         if (err)
 775                 CERROR("Precleanup %s returned %d\n",
 776                        obd->obd_name, err);
 777
 778         /* destroy an uuid-export hash body */
 779         rhashtable_free_and_destroy(&obd->obd_uuid_hash, obd_export_exit,
 780                                     NULL);
 781
 782         /* destroy a nid-export hash body */
 783         if (obd->obd_nid_hash) {
 784                 cfs_hash_putref(obd->obd_nid_hash);
 785                 obd->obd_nid_hash = NULL;
 786         }
 787
 788         /* destroy a nid-stats hash body */
 789         if (obd->obd_nid_stats_hash) {
 790                 cfs_hash_putref(obd->obd_nid_stats_hash);
 791                 obd->obd_nid_stats_hash = NULL;
 792         }
 793
 794         /* destroy a client_generation-export hash body */
 795         if (obd->obd_gen_hash) {
 796                 cfs_hash_putref(obd->obd_gen_hash);
 797                 obd->obd_gen_hash = NULL;
 798         }
 799
 800         class_decref(obd, "setup", obd);
 801         obd->obd_set_up = 0;
 802
 803         RETURN(0);
 804 }
 805
 806 struct obd_device *class_incref(struct obd_device *obd,
 807                                 const char *scope,
 808                                 const void *source)
 809 {
 810         lu_ref_add_atomic(&obd->obd_reference, scope, source);
 811         atomic_inc(&obd->obd_refcount);
 812         CDEBUG(D_INFO, "incref %s (%p) now %d\n", obd->obd_name, obd,
 813                atomic_read(&obd->obd_refcount));
 814
 815         return obd;
 816 }
 817 EXPORT_SYMBOL(class_incref);
 818
 819 void class_decref(struct obd_device *obd, const char *scope, const void *source)
 820 {
 821         int last;
 822
 823         CDEBUG(D_INFO, "Decref %s (%p) now %d - %s\n", obd->obd_name, obd,
 824                atomic_read(&obd->obd_refcount), scope);
 825
 826         LASSERT(obd->obd_num_exports >= 0);
 827         last = atomic_dec_and_test(&obd->obd_refcount);
 828         lu_ref_del(&obd->obd_reference, scope, source);
 829
 830         if (last) {
 831                 struct obd_export *exp;
 832
 833                 LASSERT(!obd->obd_attached);
 834                 /*
 835                  * All exports have been destroyed; there should
 836                  * be no more in-progress ops by this point.
 837                  */
 838                 exp = obd->obd_self_export;
 839
 840                 if (exp) {
 841                         exp->exp_flags |= exp_flags_from_obd(obd);
 842                         class_unlink_export(exp);
 843                 }
 844         }
 845 }
 846 EXPORT_SYMBOL(class_decref);
 847
 848 /**
 849  * Add a failover NID location.
 850  * Client OBD types contact server OBD types using this NID list.
 851  */
 852 int class_add_conn(struct obd_device *obd, struct lustre_cfg *lcfg)
 853 {
 854         struct obd_import *imp;
 855         struct obd_uuid uuid;
 856         int rc;
 857
 858         ENTRY;
 859
 860         if (LUSTRE_CFG_BUFLEN(lcfg, 1) < 1 ||
 861             LUSTRE_CFG_BUFLEN(lcfg, 1) > sizeof(struct obd_uuid)) {
 862                 CERROR("invalid conn_uuid\n");
 863                 RETURN(-EINVAL);
 864         }
 865         if (strcmp(obd->obd_type->typ_name, LUSTRE_MDC_NAME) &&
 866             strcmp(obd->obd_type->typ_name, LUSTRE_OSC_NAME) &&
 867             strcmp(obd->obd_type->typ_name, LUSTRE_OSP_NAME) &&
 868             strcmp(obd->obd_type->typ_name, LUSTRE_LWP_NAME) &&
 869             strcmp(obd->obd_type->typ_name, LUSTRE_MGC_NAME)) {
 870                 CERROR("can't add connection on non-client dev\n");
 871                 RETURN(-EINVAL);
 872         }
 873
 874         imp = obd->u.cli.cl_import;
 875         if (!imp) {
 876                 CERROR("try to add conn on immature client dev\n");
 877                 RETURN(-EINVAL);
 878         }
 879
 880         obd_str2uuid(&uuid, lustre_cfg_string(lcfg, 1));
 881         rc = obd_add_conn(imp, &uuid, lcfg->lcfg_num);
 882
 883         RETURN(rc);
 884 }
 885
 886 /** Remove a failover NID location. */
 887 static int class_del_conn(struct obd_device *obd, struct lustre_cfg *lcfg)
 888 {
 889         struct obd_import *imp;
 890         struct obd_uuid uuid;
 891         int rc;
 892
 893         ENTRY;
 894
 895         if (LUSTRE_CFG_BUFLEN(lcfg, 1) < 1 ||
 896             LUSTRE_CFG_BUFLEN(lcfg, 1) > sizeof(struct obd_uuid)) {
 897                 CERROR("invalid conn_uuid\n");
 898                 RETURN(-EINVAL);
 899         }
 900         if (strcmp(obd->obd_type->typ_name, LUSTRE_MDC_NAME) &&
 901             strcmp(obd->obd_type->typ_name, LUSTRE_OSC_NAME)) {
 902                 CERROR("can't del connection on non-client dev\n");
 903                 RETURN(-EINVAL);
 904         }
 905
 906         imp = obd->u.cli.cl_import;
 907         if (!imp) {
 908                 CERROR("try to del conn on immature client dev\n");
 909                 RETURN(-EINVAL);
 910         }
 911
 912         obd_str2uuid(&uuid, lustre_cfg_string(lcfg, 1));
 913         rc = obd_del_conn(imp, &uuid);
 914
 915         RETURN(rc);
 916 }
 917
 918 static LIST_HEAD(lustre_profile_list);
 919 static DEFINE_SPINLOCK(lustre_profile_list_lock);
 920
 921 struct lustre_profile *class_get_profile(const char *prof)
 922 {
 923         struct lustre_profile *lprof;
 924
 925         ENTRY;
 926         spin_lock(&lustre_profile_list_lock);
 927         list_for_each_entry(lprof, &lustre_profile_list, lp_list) {
 928                 if (!strcmp(lprof->lp_profile, prof)) {
 929                         lprof->lp_refs++;
 930                         spin_unlock(&lustre_profile_list_lock);
 931                         RETURN(lprof);
 932                 }
 933         }
 934         spin_unlock(&lustre_profile_list_lock);
 935         RETURN(NULL);
 936 }
 937 EXPORT_SYMBOL(class_get_profile);
 938
 939 /**
 940  * Create a named "profile".
 941  * This defines the MDC and OSC names to use for a client.
 942  * This also is used to define the LOV to be used by a MDT.
 943  */
 944 static int class_add_profile(int proflen, char *prof, int osclen, char *osc,
 945                              int mdclen, char *mdc)
 946 {
 947         struct lustre_profile *lprof;
 948         int err = 0;
 949
 950         ENTRY;
 951
 952         CDEBUG(D_CONFIG, "Add profile %s\n", prof);
 953
 954         OBD_ALLOC(lprof, sizeof(*lprof));
 955         if (!lprof)
 956                 RETURN(-ENOMEM);
 957         INIT_LIST_HEAD(&lprof->lp_list);
 958
 959         LASSERT(proflen == (strlen(prof) + 1));
 960         OBD_ALLOC(lprof->lp_profile, proflen);
 961         if (!lprof->lp_profile)
 962                 GOTO(out, err = -ENOMEM);
 963         memcpy(lprof->lp_profile, prof, proflen);
 964
 965         LASSERT(osclen == (strlen(osc) + 1));
 966         OBD_ALLOC(lprof->lp_dt, osclen);
 967         if (!lprof->lp_dt)
 968                 GOTO(out, err = -ENOMEM);
 969         memcpy(lprof->lp_dt, osc, osclen);
 970
 971         if (mdclen > 0) {
 972                 LASSERT(mdclen == (strlen(mdc) + 1));
 973                 OBD_ALLOC(lprof->lp_md, mdclen);
 974                 if (!lprof->lp_md)
 975                         GOTO(out, err = -ENOMEM);
 976                 memcpy(lprof->lp_md, mdc, mdclen);
 977         }
 978
 979         spin_lock(&lustre_profile_list_lock);
 980         lprof->lp_refs = 1;
 981         lprof->lp_list_deleted = false;
 982
 983         list_add(&lprof->lp_list, &lustre_profile_list);
 984         spin_unlock(&lustre_profile_list_lock);
 985         RETURN(err);
 986
 987 out:
 988         if (lprof->lp_md)
 989                 OBD_FREE(lprof->lp_md, mdclen);
 990         if (lprof->lp_dt)
 991                 OBD_FREE(lprof->lp_dt, osclen);
 992         if (lprof->lp_profile)
 993                 OBD_FREE(lprof->lp_profile, proflen);
 994         OBD_FREE(lprof, sizeof(*lprof));
 995         RETURN(err);
 996 }
 997
 998 void class_del_profile(const char *prof)
 999 {
1000         struct lustre_profile *lprof;
1001
1002         ENTRY;
1003
1004         CDEBUG(D_CONFIG, "Del profile %s\n", prof);
1005
1006         lprof = class_get_profile(prof);
1007         if (lprof) {
1008                 spin_lock(&lustre_profile_list_lock);
1009                 /* because get profile increments the ref counter */
1010                 lprof->lp_refs--;
1011                 list_del(&lprof->lp_list);
1012                 lprof->lp_list_deleted = true;
1013                 spin_unlock(&lustre_profile_list_lock);
1014
1015                 class_put_profile(lprof);
1016         }
1017         EXIT;
1018 }
1019 EXPORT_SYMBOL(class_del_profile);
1020
1021 void class_put_profile(struct lustre_profile *lprof)
1022 {
1023         spin_lock(&lustre_profile_list_lock);
1024         if ((--lprof->lp_refs) > 0) {
1025                 LASSERT(lprof->lp_refs > 0);
1026                 spin_unlock(&lustre_profile_list_lock);
1027                 return;
1028         }
1029         spin_unlock(&lustre_profile_list_lock);
1030
1031         /* confirm not a negative number */
1032         LASSERT(lprof->lp_refs == 0);
1033
1034         /*
1035          * At least one class_del_profile/profiles must be called
1036          * on the target profile or lustre_profile_list will corrupt
1037          */
1038         LASSERT(lprof->lp_list_deleted);
1039         OBD_FREE(lprof->lp_profile, strlen(lprof->lp_profile) + 1);
1040         OBD_FREE(lprof->lp_dt, strlen(lprof->lp_dt) + 1);
1041         if (lprof->lp_md)
1042                 OBD_FREE(lprof->lp_md, strlen(lprof->lp_md) + 1);
1043         OBD_FREE(lprof, sizeof(*lprof));
1044 }
1045 EXPORT_SYMBOL(class_put_profile);
1046
1047 /* COMPAT_146 */
1048 void class_del_profiles(void)
1049 {
1050         struct lustre_profile *lprof, *n;
1051         ENTRY;
1052
1053         spin_lock(&lustre_profile_list_lock);
1054         list_for_each_entry_safe(lprof, n, &lustre_profile_list, lp_list) {
1055                 list_del(&lprof->lp_list);
1056                 lprof->lp_list_deleted = true;
1057                 spin_unlock(&lustre_profile_list_lock);
1058
1059                 class_put_profile(lprof);
1060
1061                 spin_lock(&lustre_profile_list_lock);
1062         }
1063         spin_unlock(&lustre_profile_list_lock);
1064         EXIT;
1065 }
1066 EXPORT_SYMBOL(class_del_profiles);
1067
1068 /*
1069  * We can't call lquota_process_config directly because
1070  * it lives in a module that must be loaded after this one.
1071  */
1072 #ifdef HAVE_SERVER_SUPPORT
1073 static int (*quota_process_config)(struct lustre_cfg *lcfg) = NULL;
1074 #endif /* HAVE_SERVER_SUPPORT */
1075
1076 /**
1077  * Rename the proc parameter in \a cfg with a new name \a new_name.
1078  *
1079  * \param cfg      config structure which contains the proc parameter
1080  * \param new_name new name of the proc parameter
1081  *
1082  * \retval valid-pointer    pointer to the newly-allocated config structure
1083  *                          which contains the renamed proc parameter
1084  * \retval ERR_PTR(-EINVAL) if \a cfg or \a new_name is NULL, or \a cfg does
1085  *                          not contain a proc parameter
1086  * \retval ERR_PTR(-ENOMEM) if memory allocation failure occurs
1087  */
1088 struct lustre_cfg *lustre_cfg_rename(struct lustre_cfg *cfg,
1089                                      const char *new_name)
1090 {
1091         struct lustre_cfg_bufs *bufs = NULL;
1092         struct lustre_cfg *new_cfg = NULL;
1093         char *param = NULL;
1094         char *new_param = NULL;
1095         char *value = NULL;
1096         int name_len = 0;
1097         int new_len = 0;
1098
1099         ENTRY;
1100
1101         if (!cfg || !new_name)
1102                 GOTO(out_nocfg, new_cfg = ERR_PTR(-EINVAL));
1103
1104         param = lustre_cfg_string(cfg, 1);
1105         if (!param)
1106                 GOTO(out_nocfg, new_cfg = ERR_PTR(-EINVAL));
1107
1108         value = strchr(param, '=');
1109         if (value)
1110                 name_len = value - param;
1111         else
1112                 name_len = strlen(param);
1113
1114         new_len = LUSTRE_CFG_BUFLEN(cfg, 1) + strlen(new_name) - name_len;
1115
1116         OBD_ALLOC(new_param, new_len);
1117         if (!new_param)
1118                 GOTO(out_nocfg, new_cfg = ERR_PTR(-ENOMEM));
1119
1120         strlcpy(new_param, new_name, new_len);
1121         if (value)
1122                 strcat(new_param, value);
1123
1124         OBD_ALLOC_PTR(bufs);
1125         if (!bufs)
1126                 GOTO(out_free_param, new_cfg = ERR_PTR(-ENOMEM));
1127
1128         lustre_cfg_bufs_reset(bufs, NULL);
1129         lustre_cfg_bufs_init(bufs, cfg);
1130         lustre_cfg_bufs_set_string(bufs, 1, new_param);
1131
1132         OBD_ALLOC(new_cfg, lustre_cfg_len(bufs->lcfg_bufcount,
1133                                           bufs->lcfg_buflen));
1134         if (!new_cfg)
1135                 GOTO(out_free_buf, new_cfg = ERR_PTR(-ENOMEM));
1136
1137         lustre_cfg_init(new_cfg, cfg->lcfg_command, bufs);
1138
1139         new_cfg->lcfg_num = cfg->lcfg_num;
1140         new_cfg->lcfg_flags = cfg->lcfg_flags;
1141         new_cfg->lcfg_nid = cfg->lcfg_nid;
1142         new_cfg->lcfg_nal = cfg->lcfg_nal;
1143 out_free_buf:
1144         OBD_FREE_PTR(bufs);
1145 out_free_param:
1146         OBD_FREE(new_param, new_len);
1147 out_nocfg:
1148         RETURN(new_cfg);
1149 }
1150 EXPORT_SYMBOL(lustre_cfg_rename);
1151
1152 static ssize_t process_param2_config(struct lustre_cfg *lcfg)
1153 {
1154         char *param = lustre_cfg_string(lcfg, 1);
1155         char *upcall = lustre_cfg_string(lcfg, 2);
1156         struct kobject *kobj = NULL;
1157         const char *subsys = param;
1158         char *argv[] = {
1159                 [0] = "/usr/sbin/lctl",
1160                 [1] = "set_param",
1161                 [2] = param,
1162                 [3] = NULL
1163         };
1164         ktime_t start;
1165         ktime_t end;
1166         size_t len;
1167         int rc;
1168
1169         ENTRY;
1170         print_lustre_cfg(lcfg);
1171
1172         len = strcspn(param, ".=");
1173         if (!len)
1174                 return -EINVAL;
1175
1176         /* If we find '=' then its the top level sysfs directory */
1177         if (param[len] == '=')
1178                 return class_set_global(param);
1179
1180         subsys = kstrndup(param, len, GFP_KERNEL);
1181         if (!subsys)
1182                 return -ENOMEM;
1183
1184         kobj = kset_find_obj(lustre_kset, subsys);
1185         kfree(subsys);
1186         if (kobj) {
1187                 char *value = param;
1188                 char *envp[4];
1189                 int i;
1190
1191                 param = strsep(&value, "=");
1192                 envp[0] = kasprintf(GFP_KERNEL, "PARAM=%s", param);
1193                 envp[1] = kasprintf(GFP_KERNEL, "SETTING=%s", value);
1194                 envp[2] = kasprintf(GFP_KERNEL, "TIME=%lld",
1195                                     ktime_get_real_seconds());
1196                 envp[3] = NULL;
1197
1198                 rc = kobject_uevent_env(kobj, KOBJ_CHANGE, envp);
1199                 for (i = 0; i < ARRAY_SIZE(envp); i++)
1200                         kfree(envp[i]);
1201
1202                 kobject_put(kobj);
1203
1204                 RETURN(rc);
1205         }
1206
1207         /* Add upcall processing here. Now only lctl is supported */
1208         if (strcmp(upcall, LCTL_UPCALL) != 0) {
1209                 CERROR("Unsupported upcall %s\n", upcall);
1210                 RETURN(-EINVAL);
1211         }
1212
1213         start = ktime_get();
1214         rc = call_usermodehelper(argv[0], argv, NULL, UMH_WAIT_PROC);
1215         end = ktime_get();
1216
1217         if (rc < 0) {
1218                 CERROR("lctl: error invoking upcall %s %s %s: rc = %d; "
1219                        "time %ldus\n", argv[0], argv[1], argv[2], rc,
1220                        (long)ktime_us_delta(end, start));
1221         } else {
1222                 CDEBUG(D_HA, "lctl: invoked upcall %s %s %s, time %ldus\n",
1223                        argv[0], argv[1], argv[2],
1224                        (long)ktime_us_delta(end, start));
1225                        rc = 0;
1226         }
1227
1228         RETURN(rc);
1229 }
1230
1231 #ifdef HAVE_SERVER_SUPPORT
1232 void lustre_register_quota_process_config(int (*qpc)(struct lustre_cfg *lcfg))
1233 {
1234         quota_process_config = qpc;
1235 }
1236 EXPORT_SYMBOL(lustre_register_quota_process_config);
1237 #endif /* HAVE_SERVER_SUPPORT */
1238
1239 /**
1240  * Process configuration commands given in lustre_cfg form.
1241  * These may come from direct calls (e.g. class_manual_cleanup)
1242  * or processing the config llog, or ioctl from lctl.
1243  */
1244 int class_process_config(struct lustre_cfg *lcfg)
1245 {
1246         struct obd_device *obd;
1247         int err;
1248
1249         LASSERT(lcfg && !IS_ERR(lcfg));
1250         CDEBUG(D_IOCTL, "processing cmd: %x\n", lcfg->lcfg_command);
1251
1252         /* Commands that don't need a device */
1253         switch (lcfg->lcfg_command) {
1254         case LCFG_ATTACH: {
1255                 err = class_attach(lcfg);
1256                 GOTO(out, err);
1257         }
1258         case LCFG_ADD_UUID: {
1259                 CDEBUG(D_IOCTL,
1260                        "adding mapping from uuid %s to nid %#llx (%s)\n",
1261                        lustre_cfg_string(lcfg, 1), lcfg->lcfg_nid,
1262                        libcfs_nid2str(lcfg->lcfg_nid));
1263
1264                 err = class_add_uuid(lustre_cfg_string(lcfg, 1),
1265                                      lcfg->lcfg_nid);
1266                 GOTO(out, err);
1267         }
1268         case LCFG_DEL_UUID: {
1269                 CDEBUG(D_IOCTL, "removing mappings for uuid %s\n",
1270                        (lcfg->lcfg_bufcount < 2 || LUSTRE_CFG_BUFLEN(lcfg, 1) ==
1271                         0) ? "<all uuids>" : lustre_cfg_string(lcfg, 1));
1272
1273                 err = class_del_uuid(lustre_cfg_string(lcfg, 1));
1274                 GOTO(out, err);
1275         }
1276         case LCFG_MOUNTOPT: {
1277                 CDEBUG(D_IOCTL, "mountopt: profile %s osc %s mdc %s\n",
1278                        lustre_cfg_string(lcfg, 1),
1279                        lustre_cfg_string(lcfg, 2),
1280                        lustre_cfg_string(lcfg, 3));
1281                 /*
1282                  * set these mount options somewhere, so ll_fill_super
1283                  * can find them.
1284                  */
1285                 err = class_add_profile(LUSTRE_CFG_BUFLEN(lcfg, 1),
1286                                         lustre_cfg_string(lcfg, 1),
1287                                         LUSTRE_CFG_BUFLEN(lcfg, 2),
1288                                         lustre_cfg_string(lcfg, 2),
1289                                         LUSTRE_CFG_BUFLEN(lcfg, 3),
1290                                         lustre_cfg_string(lcfg, 3));
1291                 GOTO(out, err);
1292         }
1293         case LCFG_DEL_MOUNTOPT: {
1294                 CDEBUG(D_IOCTL, "mountopt: profile %s\n",
1295                        lustre_cfg_string(lcfg, 1));
1296                 class_del_profile(lustre_cfg_string(lcfg, 1));
1297                 GOTO(out, err = 0);
1298         }
1299         case LCFG_SET_TIMEOUT: {
1300                 CDEBUG(D_IOCTL, "changing lustre timeout from %d to %d\n",
1301                        obd_timeout, lcfg->lcfg_num);
1302                 obd_timeout = max(lcfg->lcfg_num, 1U);
1303                 obd_timeout_set = 1;
1304                 GOTO(out, err = 0);
1305         }
1306         case LCFG_SET_LDLM_TIMEOUT: {
1307                 CDEBUG(D_IOCTL, "changing lustre ldlm_timeout from %d to %d\n",
1308                        ldlm_timeout, lcfg->lcfg_num);
1309                 ldlm_timeout = max(lcfg->lcfg_num, 1U);
1310                 if (ldlm_timeout >= obd_timeout)
1311                         ldlm_timeout = max(obd_timeout / 3, 1U);
1312                 ldlm_timeout_set = 1;
1313                 GOTO(out, err = 0);
1314         }
1315         case LCFG_SET_UPCALL: {
1316                 LCONSOLE_ERROR_MSG(0x15a, "recovery upcall is deprecated\n");
1317                 /* COMPAT_146 Don't fail on old configs */
1318                 GOTO(out, err = 0);
1319         }
1320         case LCFG_MARKER: {
1321                 struct cfg_marker *marker;
1322
1323                 marker = lustre_cfg_buf(lcfg, 1);
1324                 CDEBUG(D_IOCTL, "marker %d (%#x) %.16s %s\n", marker->cm_step,
1325                        marker->cm_flags, marker->cm_tgtname,
1326                        marker->cm_comment);
1327                 GOTO(out, err = 0);
1328         }
1329         case LCFG_PARAM: {
1330                 char *tmp;
1331
1332                 /* llite has no OBD */
1333                 if (class_match_param(lustre_cfg_string(lcfg, 1),
1334                                       PARAM_LLITE, NULL) == 0) {
1335                         struct lustre_sb_info *lsi;
1336                         unsigned long addr;
1337                         ssize_t count;
1338
1339                         /*
1340                          * The instance name contains the sb:
1341                          * lustre-client-aacfe000
1342                          */
1343                         tmp = strrchr(lustre_cfg_string(lcfg, 0), '-');
1344                         if (!tmp || !*(++tmp))
1345                                 GOTO(out, err = -EINVAL);
1346
1347                         if (sscanf(tmp, "%lx", &addr) != 1)
1348                                 GOTO(out, err = -EINVAL);
1349
1350                         lsi = s2lsi((struct super_block *)addr);
1351                         /* This better be a real Lustre superblock! */
1352                         LASSERT(lsi->lsi_lmd->lmd_magic == LMD_MAGIC);
1353
1354                         count = class_modify_config(lcfg, PARAM_LLITE,
1355                                                     lsi->lsi_kobj);
1356                         err = count < 0 ? count : 0;
1357                         GOTO(out, err);
1358                 } else if ((class_match_param(lustre_cfg_string(lcfg, 1),
1359                                               PARAM_SYS, &tmp) == 0)) {
1360                         /* Global param settings */
1361                         err = class_set_global(tmp);
1362                         /*
1363                          * Client or server should not fail to mount if
1364                          * it hits an unknown configuration parameter.
1365                          */
1366                         if (err < 0)
1367                                 CWARN("Ignoring unknown param %s\n", tmp);
1368
1369                         GOTO(out, err = 0);
1370 #ifdef HAVE_SERVER_SUPPORT
1371                 } else if ((class_match_param(lustre_cfg_string(lcfg, 1),
1372                                               PARAM_QUOTA, &tmp) == 0) &&
1373                            quota_process_config) {
1374                         err = (*quota_process_config)(lcfg);
1375                         GOTO(out, err);
1376 #endif /* HAVE_SERVER_SUPPORT */
1377                 }
1378
1379                 break;
1380         }
1381         case LCFG_SET_PARAM: {
1382                 err = process_param2_config(lcfg);
1383                 GOTO(out, err = 0);
1384         }
1385         }
1386         /* Commands that require a device */
1387         obd = class_name2obd(lustre_cfg_string(lcfg, 0));
1388         if (!obd) {
1389                 if (!LUSTRE_CFG_BUFLEN(lcfg, 0))
1390                         CERROR("this lcfg command requires a device name\n");
1391                 else
1392                         CERROR("no device for: %s\n",
1393                                lustre_cfg_string(lcfg, 0));
1394
1395                 GOTO(out, err = -EINVAL);
1396         }
1397         switch(lcfg->lcfg_command) {
1398         case LCFG_SETUP: {
1399                 err = class_setup(obd, lcfg);
1400                 GOTO(out, err);
1401         }
1402         case LCFG_DETACH: {
1403                 err = class_detach(obd, lcfg);
1404                 GOTO(out, err = 0);
1405         }
1406         case LCFG_CLEANUP: {
1407                 err = class_cleanup(obd, lcfg);
1408                 GOTO(out, err = 0);
1409         }
1410         case LCFG_ADD_CONN: {
1411                 err = class_add_conn(obd, lcfg);
1412                 GOTO(out, err = 0);
1413         }
1414         case LCFG_DEL_CONN: {
1415                 err = class_del_conn(obd, lcfg);
1416                 GOTO(out, err = 0);
1417         }
1418         case LCFG_POOL_NEW: {
1419                 err = obd_pool_new(obd, lustre_cfg_string(lcfg, 2));
1420                 GOTO(out, err = 0);
1421         }
1422         case LCFG_POOL_ADD: {
1423                 err = obd_pool_add(obd, lustre_cfg_string(lcfg, 2),
1424                                    lustre_cfg_string(lcfg, 3));
1425                 GOTO(out, err = 0);
1426         }
1427         case LCFG_POOL_REM: {
1428                 err = obd_pool_rem(obd, lustre_cfg_string(lcfg, 2),
1429                                    lustre_cfg_string(lcfg, 3));
1430                 GOTO(out, err = 0);
1431         }
1432         case LCFG_POOL_DEL: {
1433                 err = obd_pool_del(obd, lustre_cfg_string(lcfg, 2));
1434                 GOTO(out, err = 0);
1435         }
1436         /*
1437          * Process config log ADD_MDC record twice to add MDC also to LOV
1438          * for Data-on-MDT:
1439          *
1440          * add 0:lustre-clilmv 1:lustre-MDT0000_UUID 2:0 3:1
1441          *     4:lustre-MDT0000-mdc_UUID
1442          */
1443         case LCFG_ADD_MDC: {
1444                 struct obd_device *lov_obd;
1445                 char *clilmv;
1446
1447                 err = obd_process_config(obd, sizeof(*lcfg), lcfg);
1448                 if (err)
1449                         GOTO(out, err);
1450
1451                 /* make sure this is client LMV log entry */
1452                 clilmv = strstr(lustre_cfg_string(lcfg, 0), "clilmv");
1453                 if (!clilmv)
1454                         GOTO(out, err);
1455
1456                 /*
1457                  * replace 'lmv' with 'lov' name to address LOV device and
1458                  * process llog record to add MDC there.
1459                  */
1460                 clilmv[4] = 'o';
1461                 lov_obd = class_name2obd(lustre_cfg_string(lcfg, 0));
1462                 if (lov_obd) {
1463                         err = obd_process_config(lov_obd, sizeof(*lcfg), lcfg);
1464                 } else {
1465                         err = -ENOENT;
1466                         CERROR("%s: Cannot find LOV by %s name, rc = %d\n",
1467                                obd->obd_name, lustre_cfg_string(lcfg, 0), err);
1468                 }
1469                 /* restore 'lmv' name */
1470                 clilmv[4] = 'm';
1471                 GOTO(out, err);
1472         }
1473         default: {
1474                 err = obd_process_config(obd, sizeof(*lcfg), lcfg);
1475                 GOTO(out, err);
1476         }
1477         }
1478         EXIT;
1479 out:
1480         if ((err < 0) && !(lcfg->lcfg_command & LCFG_REQUIRED)) {
1481                 CWARN("Ignoring error %d on optional command %#x\n", err,
1482                       lcfg->lcfg_command);
1483                 err = 0;
1484         }
1485         return err;
1486 }
1487 EXPORT_SYMBOL(class_process_config);
1488
1489 ssize_t class_modify_config(struct lustre_cfg *lcfg, const char *prefix,
1490                             struct kobject *kobj)
1491 {
1492         struct kobj_type *typ;
1493         ssize_t count = 0;
1494         int i;
1495
1496         if (lcfg->lcfg_command != LCFG_PARAM) {
1497                 CERROR("Unknown command: %d\n", lcfg->lcfg_command);
1498                 return -EINVAL;
1499         }
1500
1501         typ = get_ktype(kobj);
1502         if (!typ || !typ->default_attrs)
1503                 return -ENODEV;
1504
1505         print_lustre_cfg(lcfg);
1506
1507         /*
1508          * e.g. tunefs.lustre --param mdt.group_upcall=foo /r/tmp/lustre-mdt
1509          * or   lctl conf_param lustre-MDT0000.mdt.group_upcall=bar
1510          * or   lctl conf_param lustre-OST0000.osc.max_dirty_mb=36
1511          */
1512         for (i = 1; i < lcfg->lcfg_bufcount; i++) {
1513                 struct attribute *attr;
1514                 size_t keylen;
1515                 char *value;
1516                 char *key;
1517                 int j;
1518
1519                 key = lustre_cfg_buf(lcfg, i);
1520                 /* Strip off prefix */
1521                 if (class_match_param(key, prefix, &key))
1522                         /*
1523                          * If the prefix doesn't match, return error so we
1524                          * can pass it down the stack
1525                          */
1526                         return -EINVAL;
1527
1528                 value = strchr(key, '=');
1529                 if (!value || *(value + 1) == 0) {
1530                         CERROR("%s: can't parse param '%s' (missing '=')\n",
1531                                lustre_cfg_string(lcfg, 0),
1532                                lustre_cfg_string(lcfg, i));
1533                         /* continue parsing other params */
1534                         continue;
1535                 }
1536                 keylen = value - key;
1537                 value++;
1538
1539                 attr = NULL;
1540                 for (j = 0; typ->default_attrs[j]; j++) {
1541                         if (!strncmp(typ->default_attrs[j]->name, key,
1542                                      keylen)) {
1543                                 attr = typ->default_attrs[j];
1544                                 break;
1545                         }
1546                 }
1547
1548                 if (!attr) {
1549                         char *envp[4], *param, *path;
1550
1551                         path = kobject_get_path(kobj, GFP_KERNEL);
1552                         if (!path)
1553                                 return -EINVAL;
1554
1555                         /* convert sysfs path to uevent format */
1556                         param = path;
1557                         while ((param = strchr(param, '/')) != NULL)
1558                                 *param = '.';
1559
1560                         param = strstr(path, "fs.lustre.") + 10;
1561
1562                         envp[0] = kasprintf(GFP_KERNEL, "PARAM=%s.%.*s",
1563                                             param, (int) keylen, key);
1564                         envp[1] = kasprintf(GFP_KERNEL, "SETTING=%s", value);
1565                         envp[2] = kasprintf(GFP_KERNEL, "TIME=%lld",
1566                                             ktime_get_real_seconds());
1567                         envp[3] = NULL;
1568
1569                         if (kobject_uevent_env(kobj, KOBJ_CHANGE, envp)) {
1570                                 CERROR("%s: failed to send uevent %s\n",
1571                                        kobject_name(kobj), key);
1572                         }
1573
1574                         for (i = 0; i < ARRAY_SIZE(envp); i++)
1575                                 kfree(envp[i]);
1576                         kfree(path);
1577                 } else {
1578                         count += lustre_attr_store(kobj, attr, value,
1579                                                    strlen(value));
1580                 }
1581         }
1582         return count;
1583 }
1584 EXPORT_SYMBOL(class_modify_config);
1585
1586 /*
1587  * Supplemental functions for config logs, it allocates lustre_cfg
1588  * buffers plus initialized llog record header at the beginning.
1589  */
1590 struct llog_cfg_rec *lustre_cfg_rec_new(int cmd, struct lustre_cfg_bufs *bufs)
1591 {
1592         struct llog_cfg_rec *lcr;
1593         int reclen;
1594
1595         ENTRY;
1596
1597         reclen = lustre_cfg_len(bufs->lcfg_bufcount, bufs->lcfg_buflen);
1598         reclen = llog_data_len(reclen) + sizeof(struct llog_rec_hdr) +
1599                  sizeof(struct llog_rec_tail);
1600
1601         OBD_ALLOC(lcr, reclen);
1602         if (!lcr)
1603                 RETURN(NULL);
1604
1605         lustre_cfg_init(&lcr->lcr_cfg, cmd, bufs);
1606
1607         lcr->lcr_hdr.lrh_len = reclen;
1608         lcr->lcr_hdr.lrh_type = OBD_CFG_REC;
1609
1610         RETURN(lcr);
1611 }
1612 EXPORT_SYMBOL(lustre_cfg_rec_new);
1613
1614 void lustre_cfg_rec_free(struct llog_cfg_rec *lcr)
1615 {
1616         ENTRY;
1617         OBD_FREE(lcr, lcr->lcr_hdr.lrh_len);
1618         EXIT;
1619 }
1620 EXPORT_SYMBOL(lustre_cfg_rec_free);
1621
1622 /**
1623  * Parse a configuration llog, doing various manipulations on them
1624  * for various reasons, (modifications for compatibility, skip obsolete
1625  * records, change uuids, etc), then class_process_config() resulting
1626  * net records.
1627  */
1628 int class_config_llog_handler(const struct lu_env *env,
1629                               struct llog_handle *handle,
1630                               struct llog_rec_hdr *rec, void *data)
1631 {
1632         struct config_llog_instance *cfg = data;
1633         int cfg_len = rec->lrh_len;
1634         char *cfg_buf = (char *) (rec + 1);
1635         int rc = 0;
1636         ENTRY;
1637
1638         /* class_config_dump_handler(handle, rec, data); */
1639
1640         switch (rec->lrh_type) {
1641         case OBD_CFG_REC: {
1642                 struct lustre_cfg *lcfg, *lcfg_new;
1643                 struct lustre_cfg_bufs bufs;
1644                 char *inst_name = NULL;
1645                 int inst_len = 0;
1646                 int swab = 0;
1647
1648                 lcfg = (struct lustre_cfg *)cfg_buf;
1649                 if (lcfg->lcfg_version == __swab32(LUSTRE_CFG_VERSION)) {
1650                         lustre_swab_lustre_cfg(lcfg);
1651                         swab = 1;
1652                 }
1653
1654                 rc = lustre_cfg_sanity_check(cfg_buf, cfg_len);
1655                 if (rc)
1656                         GOTO(out, rc);
1657
1658                 /* Figure out config state info */
1659                 if (lcfg->lcfg_command == LCFG_MARKER) {
1660                         struct cfg_marker *marker = lustre_cfg_buf(lcfg, 1);
1661                         lustre_swab_cfg_marker(marker, swab,
1662                                                LUSTRE_CFG_BUFLEN(lcfg, 1));
1663                         CDEBUG(D_CONFIG, "Marker, inst_flg=%#x mark_flg=%#x\n",
1664                                cfg->cfg_flags, marker->cm_flags);
1665                         if (marker->cm_flags & CM_START) {
1666                                 /* all previous flags off */
1667                                 cfg->cfg_flags = CFG_F_MARKER;
1668                                 server_name2index(marker->cm_tgtname,
1669                                                   &cfg->cfg_lwp_idx, NULL);
1670                                 if (marker->cm_flags & CM_SKIP) {
1671                                         cfg->cfg_flags |= CFG_F_SKIP;
1672                                         CDEBUG(D_CONFIG, "SKIP #%d\n",
1673                                                marker->cm_step);
1674                                 } else if ((marker->cm_flags & CM_EXCLUDE) ||
1675                                            (cfg->cfg_sb &&
1676                                            lustre_check_exclusion(cfg->cfg_sb,
1677                                                         marker->cm_tgtname))) {
1678                                         cfg->cfg_flags |= CFG_F_EXCLUDE;
1679                                         CDEBUG(D_CONFIG, "EXCLUDE %d\n",
1680                                                marker->cm_step);
1681                                 }
1682                         } else if (marker->cm_flags & CM_END) {
1683                                 cfg->cfg_flags = 0;
1684                         }
1685                 }
1686                 /*
1687                  * A config command without a start marker before it is
1688                  * illegal
1689                  */
1690                 if (!(cfg->cfg_flags & CFG_F_MARKER) &&
1691                     (lcfg->lcfg_command != LCFG_MARKER)) {
1692                         CWARN("Skip config outside markers, (inst: %016lx, uuid: %s, flags: %#x)\n",
1693                                 cfg->cfg_instance,
1694                                 cfg->cfg_uuid.uuid, cfg->cfg_flags);
1695                         cfg->cfg_flags |= CFG_F_SKIP;
1696                 }
1697                 if (cfg->cfg_flags & CFG_F_SKIP) {
1698                         CDEBUG(D_CONFIG, "skipping %#x\n",
1699                                cfg->cfg_flags);
1700                         rc = 0;
1701                         /* No processing! */
1702                         break;
1703                 }
1704
1705                 /*
1706                  * For interoperability between 1.8 and 2.0,
1707                  * rename "mds" OBD device type to "mdt".
1708                  */
1709                 {
1710                         char *typename = lustre_cfg_string(lcfg, 1);
1711                         char *index = lustre_cfg_string(lcfg, 2);
1712
1713                         if ((lcfg->lcfg_command == LCFG_ATTACH && typename &&
1714                             strcmp(typename, "mds") == 0)) {
1715                                 CWARN("For 1.8 interoperability, rename obd "
1716                                         "type from mds to mdt\n");
1717                                 typename[2] = 't';
1718                         }
1719                         if ((lcfg->lcfg_command == LCFG_SETUP && index &&
1720                             strcmp(index, "type") == 0)) {
1721                                 CDEBUG(D_INFO, "For 1.8 interoperability, "
1722                                        "set this index to '0'\n");
1723                                 index[0] = '0';
1724                                 index[1] = 0;
1725                         }
1726                 }
1727
1728 #ifdef HAVE_SERVER_SUPPORT
1729                 /* newer MDS replaces LOV/OSC with LOD/OSP */
1730                 if ((lcfg->lcfg_command == LCFG_ATTACH ||
1731                      lcfg->lcfg_command == LCFG_SET_PARAM ||
1732                      lcfg->lcfg_command == LCFG_PARAM) &&
1733                     cfg->cfg_sb && IS_MDT(s2lsi(cfg->cfg_sb))) {
1734                         char *typename = lustre_cfg_string(lcfg, 1);
1735
1736                         if (typename &&
1737                             strcmp(typename, LUSTRE_LOV_NAME) == 0) {
1738                                 CDEBUG(D_CONFIG,
1739                                        "For 2.x interoperability, rename obd "
1740                                        "type from lov to lod (%s)\n",
1741                                        s2lsi(cfg->cfg_sb)->lsi_svname);
1742                                 strcpy(typename, LUSTRE_LOD_NAME);
1743                         }
1744                         if (typename &&
1745                             strcmp(typename, LUSTRE_OSC_NAME) == 0) {
1746                                 CDEBUG(D_CONFIG,
1747                                        "For 2.x interoperability, rename obd "
1748                                        "type from osc to osp (%s)\n",
1749                                        s2lsi(cfg->cfg_sb)->lsi_svname);
1750                                 strcpy(typename, LUSTRE_OSP_NAME);
1751                         }
1752                 }
1753 #endif /* HAVE_SERVER_SUPPORT */
1754
1755                 if (cfg->cfg_flags & CFG_F_EXCLUDE) {
1756                         CDEBUG(D_CONFIG, "cmd: %x marked EXCLUDED\n",
1757                                lcfg->lcfg_command);
1758                         if (lcfg->lcfg_command == LCFG_LOV_ADD_OBD)
1759                                 /* Add inactive instead */
1760                                 lcfg->lcfg_command = LCFG_LOV_ADD_INA;
1761                 }
1762
1763                 lustre_cfg_bufs_reset(&bufs, NULL);
1764                 lustre_cfg_bufs_init(&bufs, lcfg);
1765
1766                 if (cfg->cfg_instance &&
1767                     lcfg->lcfg_command != LCFG_SPTLRPC_CONF &&
1768                     LUSTRE_CFG_BUFLEN(lcfg, 0) > 0) {
1769                         inst_len = LUSTRE_CFG_BUFLEN(lcfg, 0) +
1770                                 LUSTRE_MAXINSTANCE + 4;
1771                         OBD_ALLOC(inst_name, inst_len);
1772                         if (!inst_name)
1773                                 GOTO(out, rc = -ENOMEM);
1774                         snprintf(inst_name, inst_len, "%s-%016lx",
1775                                 lustre_cfg_string(lcfg, 0),
1776                                 cfg->cfg_instance);
1777                         lustre_cfg_bufs_set_string(&bufs, 0, inst_name);
1778                         CDEBUG(D_CONFIG, "cmd %x, instance name: %s\n",
1779                                lcfg->lcfg_command, inst_name);
1780                 }
1781
1782                 /* override llog UUID for clients, to insure they are unique */
1783                 if (cfg->cfg_instance && lcfg->lcfg_command == LCFG_ATTACH)
1784                         lustre_cfg_bufs_set_string(&bufs, 2,
1785                                                    cfg->cfg_uuid.uuid);
1786                 /*
1787                  * sptlrpc config record, we expect 2 data segments:
1788                  *  [0]: fs_name/target_name,
1789                  *  [1]: rule string
1790                  * moving them to index [1] and [2], and insert MGC's
1791                  * obdname at index [0].
1792                  */
1793                 if (cfg->cfg_instance &&
1794                     lcfg->lcfg_command == LCFG_SPTLRPC_CONF) {
1795                         /* After ASLR changes cfg_instance this needs fixing */
1796                         /* "obd" is set in config_log_find_or_add() */
1797                         struct obd_device *obd = (void *)cfg->cfg_instance;
1798
1799                         lustre_cfg_bufs_set(&bufs, 2, bufs.lcfg_buf[1],
1800                                             bufs.lcfg_buflen[1]);
1801                         lustre_cfg_bufs_set(&bufs, 1, bufs.lcfg_buf[0],
1802                                             bufs.lcfg_buflen[0]);
1803                         lustre_cfg_bufs_set_string(&bufs, 0,
1804                                                    obd->obd_name);
1805                 }
1806
1807                 /*
1808                  * Add net info to setup command
1809                  * if given on command line.
1810                  * So config log will be:
1811                  * [0]: client name
1812                  * [1]: client UUID
1813                  * [2]: server UUID
1814                  * [3]: inactive-on-startup
1815                  * [4]: restrictive net
1816                  */
1817                 if (cfg && cfg->cfg_sb && s2lsi(cfg->cfg_sb) &&
1818                     !IS_SERVER(s2lsi(cfg->cfg_sb))) {
1819                         struct lustre_sb_info *lsi = s2lsi(cfg->cfg_sb);
1820                         char *nidnet = lsi->lsi_lmd->lmd_nidnet;
1821
1822                         if (lcfg->lcfg_command == LCFG_SETUP &&
1823                             lcfg->lcfg_bufcount != 2 && nidnet) {
1824                                 CDEBUG(D_CONFIG, "Adding net %s info to setup "
1825                                        "command for client %s\n", nidnet,
1826                                        lustre_cfg_string(lcfg, 0));
1827                                 lustre_cfg_bufs_set_string(&bufs, 4, nidnet);
1828                         }
1829                 }
1830
1831                 /*
1832                  * Skip add_conn command if uuid is
1833                  * not on restricted net
1834                  */
1835                 if (cfg && cfg->cfg_sb && s2lsi(cfg->cfg_sb) &&
1836                     !IS_SERVER(s2lsi(cfg->cfg_sb))) {
1837                         struct lustre_sb_info *lsi = s2lsi(cfg->cfg_sb);
1838                         char *uuid_str = lustre_cfg_string(lcfg, 1);
1839
1840                         if (lcfg->lcfg_command == LCFG_ADD_CONN &&
1841                             lsi->lsi_lmd->lmd_nidnet &&
1842                             LNET_NIDNET(libcfs_str2nid(uuid_str)) !=
1843                             libcfs_str2net(lsi->lsi_lmd->lmd_nidnet)) {
1844                                 CDEBUG(D_CONFIG, "skipping add_conn for %s\n",
1845                                        uuid_str);
1846                                 rc = 0;
1847                                 /* No processing! */
1848                                 break;
1849                         }
1850                 }
1851
1852                 OBD_ALLOC(lcfg_new, lustre_cfg_len(bufs.lcfg_bufcount,
1853                                                    bufs.lcfg_buflen));
1854                 if (!lcfg_new)
1855                         GOTO(out, rc = -ENOMEM);
1856
1857                 lustre_cfg_init(lcfg_new, lcfg->lcfg_command, &bufs);
1858                 lcfg_new->lcfg_num   = lcfg->lcfg_num;
1859                 lcfg_new->lcfg_flags = lcfg->lcfg_flags;
1860
1861                 /*
1862                  * XXX Hack to try to remain binary compatible with
1863                  * pre-newconfig logs
1864                  */
1865                 if (lcfg->lcfg_nal != 0 &&      /* pre-newconfig log? */
1866                     (lcfg->lcfg_nid >> 32) == 0) {
1867                         __u32 addr = (__u32)(lcfg->lcfg_nid & 0xffffffff);
1868
1869                         lcfg_new->lcfg_nid =
1870                                 LNET_MKNID(LNET_MKNET(lcfg->lcfg_nal, 0), addr);
1871                         CWARN("Converted pre-newconfig NAL %d NID %x to %s\n",
1872                               lcfg->lcfg_nal, addr,
1873                               libcfs_nid2str(lcfg_new->lcfg_nid));
1874                 } else {
1875                         lcfg_new->lcfg_nid = lcfg->lcfg_nid;
1876                 }
1877
1878                 lcfg_new->lcfg_nal = 0; /* illegal value for obsolete field */
1879
1880                 rc = class_process_config(lcfg_new);
1881                 OBD_FREE(lcfg_new, lustre_cfg_len(lcfg_new->lcfg_bufcount,
1882                                                   lcfg_new->lcfg_buflens));
1883                 if (inst_name)
1884                         OBD_FREE(inst_name, inst_len);
1885                 break;
1886         }
1887         default:
1888                 CERROR("Unknown llog record type %#x encountered\n",
1889                        rec->lrh_type);
1890                 break;
1891         }
1892 out:
1893         if (rc) {
1894                 CERROR("%s: cfg command failed: rc = %d\n",
1895                         handle->lgh_ctxt->loc_obd->obd_name, rc);
1896                 class_config_dump_handler(NULL, handle, rec, data);
1897         }
1898         RETURN(rc);
1899 }
1900 EXPORT_SYMBOL(class_config_llog_handler);
1901
1902 int class_config_parse_llog(const struct lu_env *env, struct llog_ctxt *ctxt,
1903                             char *name, struct config_llog_instance *cfg)
1904 {
1905         struct llog_process_cat_data cd = {
1906                 .lpcd_first_idx = 0,
1907         };
1908         struct llog_handle *llh;
1909         llog_cb_t callback;
1910         int rc;
1911         ENTRY;
1912
1913         CDEBUG(D_INFO, "looking up llog %s\n", name);
1914         rc = llog_open(env, ctxt, &llh, NULL, name, LLOG_OPEN_EXISTS);
1915         if (rc)
1916                 RETURN(rc);
1917
1918         rc = llog_init_handle(env, llh, LLOG_F_IS_PLAIN, NULL);
1919         if (rc)
1920                 GOTO(parse_out, rc);
1921
1922         /* continue processing from where we last stopped to end-of-log */
1923         if (cfg) {
1924                 cd.lpcd_first_idx = cfg->cfg_last_idx;
1925                 callback = cfg->cfg_callback;
1926                 LASSERT(callback != NULL);
1927         } else {
1928                 callback = class_config_llog_handler;
1929         }
1930
1931         cd.lpcd_last_idx = 0;
1932
1933         rc = llog_process(env, llh, callback, cfg, &cd);
1934
1935         CDEBUG(D_CONFIG, "Processed log %s gen %d-%d (rc=%d)\n", name,
1936                cd.lpcd_first_idx + 1, cd.lpcd_last_idx, rc);
1937         if (cfg)
1938                 cfg->cfg_last_idx = cd.lpcd_last_idx;
1939
1940 parse_out:
1941         llog_close(env, llh);
1942         RETURN(rc);
1943 }
1944 EXPORT_SYMBOL(class_config_parse_llog);
1945
1946 /**
1947  * Parse config record and output dump in supplied buffer.
1948  *
1949  * This is separated from class_config_dump_handler() to use
1950  * for ioctl needs as well
1951  *
1952  * Sample Output:
1953  * - { index: 4, event: attach, device: lustrewt-clilov, type: lov,
1954  *     UUID: lustrewt-clilov_UUID }
1955  */
1956 int class_config_yaml_output(struct llog_rec_hdr *rec, char *buf, int size)
1957 {
1958         struct lustre_cfg *lcfg = (struct lustre_cfg *)(rec + 1);
1959         char *ptr = buf;
1960         char *end = buf + size;
1961         int rc = 0, i;
1962         struct lcfg_type_data *ldata;
1963
1964         LASSERT(rec->lrh_type == OBD_CFG_REC);
1965         rc = lustre_cfg_sanity_check(lcfg, rec->lrh_len);
1966         if (rc < 0)
1967                 return rc;
1968
1969         ldata = lcfg_cmd2data(lcfg->lcfg_command);
1970         if (!ldata)
1971                 return -ENOTTY;
1972
1973         if (lcfg->lcfg_command == LCFG_MARKER)
1974                 return 0;
1975
1976         /* form YAML entity */
1977         ptr += snprintf(ptr, end - ptr, "- { index: %u, event: %s",
1978                         rec->lrh_index, ldata->ltd_name);
1979         if (end - ptr <= 0)
1980                 goto out_overflow;
1981
1982         if (lcfg->lcfg_flags) {
1983                 ptr += snprintf(ptr, end - ptr, ", flags: %#08x",
1984                                 lcfg->lcfg_flags);
1985                 if (end - ptr <= 0)
1986                         goto out_overflow;
1987         }
1988         if (lcfg->lcfg_num) {
1989                 ptr += snprintf(ptr, end - ptr, ", num: %#08x",
1990                                 lcfg->lcfg_num);
1991                 if (end - ptr <= 0)
1992                         goto out_overflow;
1993         }
1994         if (lcfg->lcfg_nid) {
1995                 char nidstr[LNET_NIDSTR_SIZE];
1996
1997                 libcfs_nid2str_r(lcfg->lcfg_nid, nidstr, sizeof(nidstr));
1998                 ptr += snprintf(ptr, end - ptr, ", nid: %s(%#llx)",
1999                                 nidstr, lcfg->lcfg_nid);
2000                 if (end - ptr <= 0)
2001                         goto out_overflow;
2002         }
2003
2004         if (LUSTRE_CFG_BUFLEN(lcfg, 0) > 0) {
2005                 ptr += snprintf(ptr, end - ptr, ", device: %s",
2006                                 lustre_cfg_string(lcfg, 0));
2007                 if (end - ptr <= 0)
2008                         goto out_overflow;
2009         }
2010
2011         if (lcfg->lcfg_command == LCFG_SET_PARAM) {
2012                 /*
2013                  * set_param -P parameters have param=val here, separate
2014                  * them through pointer magic and print them out in
2015                  * native yamlese
2016                  */
2017                 char *cfg_str = lustre_cfg_string(lcfg, 1);
2018                 char *tmp = strchr(cfg_str, '=');
2019                 size_t len;
2020
2021                 if (!tmp)
2022                         goto out_done;
2023
2024                 ptr += snprintf(ptr, end - ptr, ", %s: ", ldata->ltd_bufs[0]);
2025                 len = tmp - cfg_str + 1;
2026                 snprintf(ptr, len, "%s", cfg_str);
2027                 ptr += len - 1;
2028
2029                 ptr += snprintf(ptr, end - ptr, ", %s: ", ldata->ltd_bufs[1]);
2030                 ptr += snprintf(ptr, end - ptr, "%s", tmp + 1);
2031
2032                 goto out_done;
2033         }
2034
2035         for (i = 1; i < lcfg->lcfg_bufcount; i++) {
2036                 if (LUSTRE_CFG_BUFLEN(lcfg, i) > 0) {
2037                         ptr += snprintf(ptr, end - ptr, ", %s: %s",
2038                                         ldata->ltd_bufs[i - 1],
2039                                         lustre_cfg_string(lcfg, i));
2040                         if (end - ptr <= 0)
2041                                 goto out_overflow;
2042                 }
2043         }
2044
2045 out_done:
2046         ptr += snprintf(ptr, end - ptr, " }\n");
2047 out_overflow:
2048         /* Return consumed bytes.  If the buffer overflowed, zero last byte */
2049         rc = ptr - buf;
2050         if (rc > size) {
2051                 rc = -EOVERFLOW;
2052                 *(end - 1) = '\0';
2053         }
2054
2055         return rc;
2056 }
2057
2058 /**
2059  * parse config record and output dump in supplied buffer.
2060  * This is separated from class_config_dump_handler() to use
2061  * for ioctl needs as well
2062  */
2063 static int class_config_parse_rec(struct llog_rec_hdr *rec, char *buf, int size)
2064 {
2065         struct lustre_cfg       *lcfg = (struct lustre_cfg *)(rec + 1);
2066         char                    *ptr = buf;
2067         char                    *end = buf + size;
2068         int                      rc = 0;
2069
2070         ENTRY;
2071
2072         LASSERT(rec->lrh_type == OBD_CFG_REC);
2073         rc = lustre_cfg_sanity_check(lcfg, rec->lrh_len);
2074         if (rc < 0)
2075                 RETURN(rc);
2076
2077         ptr += snprintf(ptr, end-ptr, "cmd=%05x ", lcfg->lcfg_command);
2078         if (lcfg->lcfg_flags)
2079                 ptr += snprintf(ptr, end-ptr, "flags=%#08x ",
2080                                 lcfg->lcfg_flags);
2081
2082         if (lcfg->lcfg_num)
2083                 ptr += snprintf(ptr, end-ptr, "num=%#08x ", lcfg->lcfg_num);
2084
2085         if (lcfg->lcfg_nid) {
2086                 char nidstr[LNET_NIDSTR_SIZE];
2087
2088                 libcfs_nid2str_r(lcfg->lcfg_nid, nidstr, sizeof(nidstr));
2089                 ptr += snprintf(ptr, end-ptr, "nid=%s(%#llx)    ",
2090                                 nidstr, lcfg->lcfg_nid);
2091         }
2092
2093         if (lcfg->lcfg_command == LCFG_MARKER) {
2094                 struct cfg_marker *marker = lustre_cfg_buf(lcfg, 1);
2095
2096                 ptr += snprintf(ptr, end-ptr, "marker=%d(%#x)%s '%s'",
2097                                 marker->cm_step, marker->cm_flags,
2098                                 marker->cm_tgtname, marker->cm_comment);
2099         } else {
2100                 int i;
2101
2102                 for (i = 0; i <  lcfg->lcfg_bufcount; i++) {
2103                         ptr += snprintf(ptr, end-ptr, "%d:%s  ", i,
2104                                         lustre_cfg_string(lcfg, i));
2105                 }
2106         }
2107         ptr += snprintf(ptr, end - ptr, "\n");
2108         /* return consumed bytes */
2109         rc = ptr - buf;
2110         RETURN(rc);
2111 }
2112
2113 int class_config_dump_handler(const struct lu_env *env,
2114                               struct llog_handle *handle,
2115                               struct llog_rec_hdr *rec, void *data)
2116 {
2117         char *outstr;
2118         int rc = 0;
2119
2120         ENTRY;
2121
2122         OBD_ALLOC(outstr, 256);
2123         if (!outstr)
2124                 RETURN(-ENOMEM);
2125
2126         if (rec->lrh_type == OBD_CFG_REC) {
2127                 class_config_parse_rec(rec, outstr, 256);
2128                 LCONSOLE(D_WARNING, "   %s\n", outstr);
2129         } else {
2130                 LCONSOLE(D_WARNING, "unhandled lrh_type: %#x\n", rec->lrh_type);
2131                 rc = -EINVAL;
2132         }
2133
2134         OBD_FREE(outstr, 256);
2135         RETURN(rc);
2136 }
2137
2138 /**
2139  * Call class_cleanup and class_detach.
2140  * "Manual" only in the sense that we're faking lcfg commands.
2141  */
2142 int class_manual_cleanup(struct obd_device *obd)
2143 {
2144         char flags[3] = "";
2145         struct lustre_cfg *lcfg;
2146         struct lustre_cfg_bufs bufs;
2147         int rc;
2148
2149         ENTRY;
2150
2151         if (!obd) {
2152                 CERROR("empty cleanup\n");
2153                 RETURN(-EALREADY);
2154         }
2155
2156         if (obd->obd_force)
2157                 strlcat(flags, "F", sizeof(flags));
2158         if (obd->obd_fail)
2159                 strlcat(flags, "A", sizeof(flags));
2160
2161         CDEBUG(D_CONFIG, "Manual cleanup of %s (flags='%s')\n",
2162                obd->obd_name, flags);
2163
2164         lustre_cfg_bufs_reset(&bufs, obd->obd_name);
2165         lustre_cfg_bufs_set_string(&bufs, 1, flags);
2166         OBD_ALLOC(lcfg, lustre_cfg_len(bufs.lcfg_bufcount, bufs.lcfg_buflen));
2167         if (!lcfg)
2168                 RETURN(-ENOMEM);
2169         lustre_cfg_init(lcfg, LCFG_CLEANUP, &bufs);
2170
2171         rc = class_process_config(lcfg);
2172         if (rc) {
2173                 CERROR("cleanup failed %d: %s\n", rc, obd->obd_name);
2174                 GOTO(out, rc);
2175         }
2176
2177         /* the lcfg is almost the same for both ops */
2178         lcfg->lcfg_command = LCFG_DETACH;
2179         rc = class_process_config(lcfg);
2180         if (rc)
2181                 CERROR("detach failed %d: %s\n", rc, obd->obd_name);
2182 out:
2183         OBD_FREE(lcfg, lustre_cfg_len(lcfg->lcfg_bufcount, lcfg->lcfg_buflens));
2184         RETURN(rc);
2185 }
2186 EXPORT_SYMBOL(class_manual_cleanup);
2187
2188 /*
2189  * nid<->export hash operations
2190  */
2191 static unsigned
2192 nid_hash(struct cfs_hash *hs, const void *key, unsigned mask)
2193 {
2194         return cfs_hash_djb2_hash(key, sizeof(lnet_nid_t), mask);
2195 }
2196
2197 static void *
2198 nid_key(struct hlist_node *hnode)
2199 {
2200         struct obd_export *exp;
2201
2202         exp = hlist_entry(hnode, struct obd_export, exp_nid_hash);
2203
2204         RETURN(&exp->exp_connection->c_peer.nid);
2205 }
2206
2207 /*
2208  * NOTE: It is impossible to find an export that is in failed
2209  *       state with this function
2210  */
2211 static int
2212 nid_kepcmp(const void *key, struct hlist_node *hnode)
2213 {
2214         struct obd_export *exp;
2215
2216         LASSERT(key);
2217         exp = hlist_entry(hnode, struct obd_export, exp_nid_hash);
2218
2219         RETURN(exp->exp_connection->c_peer.nid == *(lnet_nid_t *)key &&
2220                !exp->exp_failed);
2221 }
2222
2223 static void *
2224 nid_export_object(struct hlist_node *hnode)
2225 {
2226         return hlist_entry(hnode, struct obd_export, exp_nid_hash);
2227 }
2228
2229 static void
2230 nid_export_get(struct cfs_hash *hs, struct hlist_node *hnode)
2231 {
2232         struct obd_export *exp;
2233
2234         exp = hlist_entry(hnode, struct obd_export, exp_nid_hash);
2235         class_export_get(exp);
2236 }
2237
2238 static void
2239 nid_export_put_locked(struct cfs_hash *hs, struct hlist_node *hnode)
2240 {
2241         struct obd_export *exp;
2242
2243         exp = hlist_entry(hnode, struct obd_export, exp_nid_hash);
2244         class_export_put(exp);
2245 }
2246
2247 static struct cfs_hash_ops nid_hash_ops = {
2248         .hs_hash        = nid_hash,
2249         .hs_key         = nid_key,
2250         .hs_keycmp      = nid_kepcmp,
2251         .hs_object      = nid_export_object,
2252         .hs_get         = nid_export_get,
2253         .hs_put_locked  = nid_export_put_locked,
2254 };
2255
2256
2257 /*
2258  * nid<->nidstats hash operations
2259  */
2260
2261 static void *
2262 nidstats_key(struct hlist_node *hnode)
2263 {
2264         struct nid_stat *ns;
2265
2266         ns = hlist_entry(hnode, struct nid_stat, nid_hash);
2267
2268         return &ns->nid;
2269 }
2270
2271 static int
2272 nidstats_keycmp(const void *key, struct hlist_node *hnode)
2273 {
2274         return *(lnet_nid_t *)nidstats_key(hnode) == *(lnet_nid_t *)key;
2275 }
2276
2277 static void *
2278 nidstats_object(struct hlist_node *hnode)
2279 {
2280         return hlist_entry(hnode, struct nid_stat, nid_hash);
2281 }
2282
2283 static void
2284 nidstats_get(struct cfs_hash *hs, struct hlist_node *hnode)
2285 {
2286         struct nid_stat *ns;
2287
2288         ns = hlist_entry(hnode, struct nid_stat, nid_hash);
2289         nidstat_getref(ns);
2290 }
2291
2292 static void
2293 nidstats_put_locked(struct cfs_hash *hs, struct hlist_node *hnode)
2294 {
2295         struct nid_stat *ns;
2296
2297         ns = hlist_entry(hnode, struct nid_stat, nid_hash);
2298         nidstat_putref(ns);
2299 }
2300
2301 static struct cfs_hash_ops nid_stat_hash_ops = {
2302         .hs_hash        = nid_hash,
2303         .hs_key         = nidstats_key,
2304         .hs_keycmp      = nidstats_keycmp,
2305         .hs_object      = nidstats_object,
2306         .hs_get         = nidstats_get,
2307         .hs_put_locked  = nidstats_put_locked,
2308 };
2309
2310
2311 /*
2312  * client_generation<->export hash operations
2313  */
2314
2315 static unsigned
2316 gen_hash(struct cfs_hash *hs, const void *key, unsigned mask)
2317 {
2318         return cfs_hash_djb2_hash(key, sizeof(__u32), mask);
2319 }
2320
2321 static void *
2322 gen_key(struct hlist_node *hnode)
2323 {
2324         struct obd_export *exp;
2325
2326         exp = hlist_entry(hnode, struct obd_export, exp_gen_hash);
2327
2328         RETURN(&exp->exp_target_data.ted_lcd->lcd_generation);
2329 }
2330
2331 /*
2332  * NOTE: It is impossible to find an export that is in failed
2333  *       state with this function
2334  */
2335 static int
2336 gen_kepcmp(const void *key, struct hlist_node *hnode)
2337 {
2338         struct obd_export *exp;
2339
2340         LASSERT(key);
2341         exp = hlist_entry(hnode, struct obd_export, exp_gen_hash);
2342
2343         RETURN(exp->exp_target_data.ted_lcd->lcd_generation == *(__u32 *)key &&
2344                !exp->exp_failed);
2345 }
2346
2347 static void *
2348 gen_export_object(struct hlist_node *hnode)
2349 {
2350         return hlist_entry(hnode, struct obd_export, exp_gen_hash);
2351 }
2352
2353 static void
2354 gen_export_get(struct cfs_hash *hs, struct hlist_node *hnode)
2355 {
2356         struct obd_export *exp;
2357
2358         exp = hlist_entry(hnode, struct obd_export, exp_gen_hash);
2359         class_export_get(exp);
2360 }
2361
2362 static void
2363 gen_export_put_locked(struct cfs_hash *hs, struct hlist_node *hnode)
2364 {
2365         struct obd_export *exp;
2366
2367         exp = hlist_entry(hnode, struct obd_export, exp_gen_hash);
2368         class_export_put(exp);
2369 }
2370
2371 static struct cfs_hash_ops gen_hash_ops = {
2372         .hs_hash        = gen_hash,
2373         .hs_key         = gen_key,
2374         .hs_keycmp      = gen_kepcmp,
2375         .hs_object      = gen_export_object,
2376         .hs_get         = gen_export_get,
2377         .hs_put_locked  = gen_export_put_locked,
2378 };