Whamcloud - gitweb
LU-8130 obd: convert obd uuid hash to rhashtable
[fs/lustre-release.git] / 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) + 16 + 4;
1770                         OBD_ALLOC(inst_name, inst_len);
1771                         if (!inst_name)
1772                                 GOTO(out, rc = -ENOMEM);
1773                         snprintf(inst_name, inst_len, "%s-%016lx",
1774                                 lustre_cfg_string(lcfg, 0),
1775                                 cfg->cfg_instance);
1776                         lustre_cfg_bufs_set_string(&bufs, 0, inst_name);
1777                         CDEBUG(D_CONFIG, "cmd %x, instance name: %s\n",
1778                                lcfg->lcfg_command, inst_name);
1779                 }
1780
1781                 /* override llog UUID for clients, to insure they are unique */
1782                 if (cfg->cfg_instance && lcfg->lcfg_command == LCFG_ATTACH)
1783                         lustre_cfg_bufs_set_string(&bufs, 2,
1784                                                    cfg->cfg_uuid.uuid);
1785                 /*
1786                  * sptlrpc config record, we expect 2 data segments:
1787                  *  [0]: fs_name/target_name,
1788                  *  [1]: rule string
1789                  * moving them to index [1] and [2], and insert MGC's
1790                  * obdname at index [0].
1791                  */
1792                 if (cfg->cfg_instance &&
1793                     lcfg->lcfg_command == LCFG_SPTLRPC_CONF) {
1794                         /* After ASLR changes cfg_instance this needs fixing */
1795                         /* "obd" is set in config_log_find_or_add() */
1796                         struct obd_device *obd = (void *)cfg->cfg_instance;
1797
1798                         lustre_cfg_bufs_set(&bufs, 2, bufs.lcfg_buf[1],
1799                                             bufs.lcfg_buflen[1]);
1800                         lustre_cfg_bufs_set(&bufs, 1, bufs.lcfg_buf[0],
1801                                             bufs.lcfg_buflen[0]);
1802                         lustre_cfg_bufs_set_string(&bufs, 0,
1803                                                    obd->obd_name);
1804                 }
1805
1806                 /*
1807                  * Add net info to setup command
1808                  * if given on command line.
1809                  * So config log will be:
1810                  * [0]: client name
1811                  * [1]: client UUID
1812                  * [2]: server UUID
1813                  * [3]: inactive-on-startup
1814                  * [4]: restrictive net
1815                  */
1816                 if (cfg && cfg->cfg_sb && s2lsi(cfg->cfg_sb) &&
1817                     !IS_SERVER(s2lsi(cfg->cfg_sb))) {
1818                         struct lustre_sb_info *lsi = s2lsi(cfg->cfg_sb);
1819                         char *nidnet = lsi->lsi_lmd->lmd_nidnet;
1820
1821                         if (lcfg->lcfg_command == LCFG_SETUP &&
1822                             lcfg->lcfg_bufcount != 2 && nidnet) {
1823                                 CDEBUG(D_CONFIG, "Adding net %s info to setup "
1824                                        "command for client %s\n", nidnet,
1825                                        lustre_cfg_string(lcfg, 0));
1826                                 lustre_cfg_bufs_set_string(&bufs, 4, nidnet);
1827                         }
1828                 }
1829
1830                 /*
1831                  * Skip add_conn command if uuid is
1832                  * not on restricted net
1833                  */
1834                 if (cfg && cfg->cfg_sb && s2lsi(cfg->cfg_sb) &&
1835                     !IS_SERVER(s2lsi(cfg->cfg_sb))) {
1836                         struct lustre_sb_info *lsi = s2lsi(cfg->cfg_sb);
1837                         char *uuid_str = lustre_cfg_string(lcfg, 1);
1838
1839                         if (lcfg->lcfg_command == LCFG_ADD_CONN &&
1840                             lsi->lsi_lmd->lmd_nidnet &&
1841                             LNET_NIDNET(libcfs_str2nid(uuid_str)) !=
1842                             libcfs_str2net(lsi->lsi_lmd->lmd_nidnet)) {
1843                                 CDEBUG(D_CONFIG, "skipping add_conn for %s\n",
1844                                        uuid_str);
1845                                 rc = 0;
1846                                 /* No processing! */
1847                                 break;
1848                         }
1849                 }
1850
1851                 OBD_ALLOC(lcfg_new, lustre_cfg_len(bufs.lcfg_bufcount,
1852                                                    bufs.lcfg_buflen));
1853                 if (!lcfg_new)
1854                         GOTO(out, rc = -ENOMEM);
1855
1856                 lustre_cfg_init(lcfg_new, lcfg->lcfg_command, &bufs);
1857                 lcfg_new->lcfg_num   = lcfg->lcfg_num;
1858                 lcfg_new->lcfg_flags = lcfg->lcfg_flags;
1859
1860                 /*
1861                  * XXX Hack to try to remain binary compatible with
1862                  * pre-newconfig logs
1863                  */
1864                 if (lcfg->lcfg_nal != 0 &&      /* pre-newconfig log? */
1865                     (lcfg->lcfg_nid >> 32) == 0) {
1866                         __u32 addr = (__u32)(lcfg->lcfg_nid & 0xffffffff);
1867
1868                         lcfg_new->lcfg_nid =
1869                                 LNET_MKNID(LNET_MKNET(lcfg->lcfg_nal, 0), addr);
1870                         CWARN("Converted pre-newconfig NAL %d NID %x to %s\n",
1871                               lcfg->lcfg_nal, addr,
1872                               libcfs_nid2str(lcfg_new->lcfg_nid));
1873                 } else {
1874                         lcfg_new->lcfg_nid = lcfg->lcfg_nid;
1875                 }
1876
1877                 lcfg_new->lcfg_nal = 0; /* illegal value for obsolete field */
1878
1879                 rc = class_process_config(lcfg_new);
1880                 OBD_FREE(lcfg_new, lustre_cfg_len(lcfg_new->lcfg_bufcount,
1881                                                   lcfg_new->lcfg_buflens));
1882                 if (inst_name)
1883                         OBD_FREE(inst_name, inst_len);
1884                 break;
1885         }
1886         default:
1887                 CERROR("Unknown llog record type %#x encountered\n",
1888                        rec->lrh_type);
1889                 break;
1890         }
1891 out:
1892         if (rc) {
1893                 CERROR("%s: cfg command failed: rc = %d\n",
1894                         handle->lgh_ctxt->loc_obd->obd_name, rc);
1895                 class_config_dump_handler(NULL, handle, rec, data);
1896         }
1897         RETURN(rc);
1898 }
1899 EXPORT_SYMBOL(class_config_llog_handler);
1900
1901 int class_config_parse_llog(const struct lu_env *env, struct llog_ctxt *ctxt,
1902                             char *name, struct config_llog_instance *cfg)
1903 {
1904         struct llog_process_cat_data cd = {
1905                 .lpcd_first_idx = 0,
1906         };
1907         struct llog_handle *llh;
1908         llog_cb_t callback;
1909         int rc;
1910         ENTRY;
1911
1912         CDEBUG(D_INFO, "looking up llog %s\n", name);
1913         rc = llog_open(env, ctxt, &llh, NULL, name, LLOG_OPEN_EXISTS);
1914         if (rc)
1915                 RETURN(rc);
1916
1917         rc = llog_init_handle(env, llh, LLOG_F_IS_PLAIN, NULL);
1918         if (rc)
1919                 GOTO(parse_out, rc);
1920
1921         /* continue processing from where we last stopped to end-of-log */
1922         if (cfg) {
1923                 cd.lpcd_first_idx = cfg->cfg_last_idx;
1924                 callback = cfg->cfg_callback;
1925                 LASSERT(callback != NULL);
1926         } else {
1927                 callback = class_config_llog_handler;
1928         }
1929
1930         cd.lpcd_last_idx = 0;
1931
1932         rc = llog_process(env, llh, callback, cfg, &cd);
1933
1934         CDEBUG(D_CONFIG, "Processed log %s gen %d-%d (rc=%d)\n", name,
1935                cd.lpcd_first_idx + 1, cd.lpcd_last_idx, rc);
1936         if (cfg)
1937                 cfg->cfg_last_idx = cd.lpcd_last_idx;
1938
1939 parse_out:
1940         llog_close(env, llh);
1941         RETURN(rc);
1942 }
1943 EXPORT_SYMBOL(class_config_parse_llog);
1944
1945 /**
1946  * Parse config record and output dump in supplied buffer.
1947  *
1948  * This is separated from class_config_dump_handler() to use
1949  * for ioctl needs as well
1950  *
1951  * Sample Output:
1952  * - { index: 4, event: attach, device: lustrewt-clilov, type: lov,
1953  *     UUID: lustrewt-clilov_UUID }
1954  */
1955 int class_config_yaml_output(struct llog_rec_hdr *rec, char *buf, int size)
1956 {
1957         struct lustre_cfg *lcfg = (struct lustre_cfg *)(rec + 1);
1958         char *ptr = buf;
1959         char *end = buf + size;
1960         int rc = 0, i;
1961         struct lcfg_type_data *ldata;
1962
1963         LASSERT(rec->lrh_type == OBD_CFG_REC);
1964         rc = lustre_cfg_sanity_check(lcfg, rec->lrh_len);
1965         if (rc < 0)
1966                 return rc;
1967
1968         ldata = lcfg_cmd2data(lcfg->lcfg_command);
1969         if (!ldata)
1970                 return -ENOTTY;
1971
1972         if (lcfg->lcfg_command == LCFG_MARKER)
1973                 return 0;
1974
1975         /* form YAML entity */
1976         ptr += snprintf(ptr, end - ptr, "- { index: %u, event: %s",
1977                         rec->lrh_index, ldata->ltd_name);
1978         if (end - ptr <= 0)
1979                 goto out_overflow;
1980
1981         if (lcfg->lcfg_flags) {
1982                 ptr += snprintf(ptr, end - ptr, ", flags: %#08x",
1983                                 lcfg->lcfg_flags);
1984                 if (end - ptr <= 0)
1985                         goto out_overflow;
1986         }
1987         if (lcfg->lcfg_num) {
1988                 ptr += snprintf(ptr, end - ptr, ", num: %#08x",
1989                                 lcfg->lcfg_num);
1990                 if (end - ptr <= 0)
1991                         goto out_overflow;
1992         }
1993         if (lcfg->lcfg_nid) {
1994                 char nidstr[LNET_NIDSTR_SIZE];
1995
1996                 libcfs_nid2str_r(lcfg->lcfg_nid, nidstr, sizeof(nidstr));
1997                 ptr += snprintf(ptr, end - ptr, ", nid: %s(%#llx)",
1998                                 nidstr, lcfg->lcfg_nid);
1999                 if (end - ptr <= 0)
2000                         goto out_overflow;
2001         }
2002
2003         if (LUSTRE_CFG_BUFLEN(lcfg, 0) > 0) {
2004                 ptr += snprintf(ptr, end - ptr, ", device: %s",
2005                                 lustre_cfg_string(lcfg, 0));
2006                 if (end - ptr <= 0)
2007                         goto out_overflow;
2008         }
2009
2010         if (lcfg->lcfg_command == LCFG_SET_PARAM) {
2011                 /*
2012                  * set_param -P parameters have param=val here, separate
2013                  * them through pointer magic and print them out in
2014                  * native yamlese
2015                  */
2016                 char *cfg_str = lustre_cfg_string(lcfg, 1);
2017                 char *tmp = strchr(cfg_str, '=');
2018                 size_t len;
2019
2020                 if (!tmp)
2021                         goto out_done;
2022
2023                 ptr += snprintf(ptr, end - ptr, ", %s: ", ldata->ltd_bufs[0]);
2024                 len = tmp - cfg_str + 1;
2025                 snprintf(ptr, len, "%s", cfg_str);
2026                 ptr += len - 1;
2027
2028                 ptr += snprintf(ptr, end - ptr, ", %s: ", ldata->ltd_bufs[1]);
2029                 ptr += snprintf(ptr, end - ptr, "%s", tmp + 1);
2030
2031                 goto out_done;
2032         }
2033
2034         for (i = 1; i < lcfg->lcfg_bufcount; i++) {
2035                 if (LUSTRE_CFG_BUFLEN(lcfg, i) > 0) {
2036                         ptr += snprintf(ptr, end - ptr, ", %s: %s",
2037                                         ldata->ltd_bufs[i - 1],
2038                                         lustre_cfg_string(lcfg, i));
2039                         if (end - ptr <= 0)
2040                                 goto out_overflow;
2041                 }
2042         }
2043
2044 out_done:
2045         ptr += snprintf(ptr, end - ptr, " }\n");
2046 out_overflow:
2047         /* Return consumed bytes.  If the buffer overflowed, zero last byte */
2048         rc = ptr - buf;
2049         if (rc > size) {
2050                 rc = -EOVERFLOW;
2051                 *(end - 1) = '\0';
2052         }
2053
2054         return rc;
2055 }
2056
2057 /**
2058  * parse config record and output dump in supplied buffer.
2059  * This is separated from class_config_dump_handler() to use
2060  * for ioctl needs as well
2061  */
2062 static int class_config_parse_rec(struct llog_rec_hdr *rec, char *buf, int size)
2063 {
2064         struct lustre_cfg       *lcfg = (struct lustre_cfg *)(rec + 1);
2065         char                    *ptr = buf;
2066         char                    *end = buf + size;
2067         int                      rc = 0;
2068
2069         ENTRY;
2070
2071         LASSERT(rec->lrh_type == OBD_CFG_REC);
2072         rc = lustre_cfg_sanity_check(lcfg, rec->lrh_len);
2073         if (rc < 0)
2074                 RETURN(rc);
2075
2076         ptr += snprintf(ptr, end-ptr, "cmd=%05x ", lcfg->lcfg_command);
2077         if (lcfg->lcfg_flags)
2078                 ptr += snprintf(ptr, end-ptr, "flags=%#08x ",
2079                                 lcfg->lcfg_flags);
2080
2081         if (lcfg->lcfg_num)
2082                 ptr += snprintf(ptr, end-ptr, "num=%#08x ", lcfg->lcfg_num);
2083
2084         if (lcfg->lcfg_nid) {
2085                 char nidstr[LNET_NIDSTR_SIZE];
2086
2087                 libcfs_nid2str_r(lcfg->lcfg_nid, nidstr, sizeof(nidstr));
2088                 ptr += snprintf(ptr, end-ptr, "nid=%s(%#llx)    ",
2089                                 nidstr, lcfg->lcfg_nid);
2090         }
2091
2092         if (lcfg->lcfg_command == LCFG_MARKER) {
2093                 struct cfg_marker *marker = lustre_cfg_buf(lcfg, 1);
2094
2095                 ptr += snprintf(ptr, end-ptr, "marker=%d(%#x)%s '%s'",
2096                                 marker->cm_step, marker->cm_flags,
2097                                 marker->cm_tgtname, marker->cm_comment);
2098         } else {
2099                 int i;
2100
2101                 for (i = 0; i <  lcfg->lcfg_bufcount; i++) {
2102                         ptr += snprintf(ptr, end-ptr, "%d:%s  ", i,
2103                                         lustre_cfg_string(lcfg, i));
2104                 }
2105         }
2106         ptr += snprintf(ptr, end - ptr, "\n");
2107         /* return consumed bytes */
2108         rc = ptr - buf;
2109         RETURN(rc);
2110 }
2111
2112 int class_config_dump_handler(const struct lu_env *env,
2113                               struct llog_handle *handle,
2114                               struct llog_rec_hdr *rec, void *data)
2115 {
2116         char *outstr;
2117         int rc = 0;
2118
2119         ENTRY;
2120
2121         OBD_ALLOC(outstr, 256);
2122         if (!outstr)
2123                 RETURN(-ENOMEM);
2124
2125         if (rec->lrh_type == OBD_CFG_REC) {
2126                 class_config_parse_rec(rec, outstr, 256);
2127                 LCONSOLE(D_WARNING, "   %s\n", outstr);
2128         } else {
2129                 LCONSOLE(D_WARNING, "unhandled lrh_type: %#x\n", rec->lrh_type);
2130                 rc = -EINVAL;
2131         }
2132
2133         OBD_FREE(outstr, 256);
2134         RETURN(rc);
2135 }
2136
2137 /**
2138  * Call class_cleanup and class_detach.
2139  * "Manual" only in the sense that we're faking lcfg commands.
2140  */
2141 int class_manual_cleanup(struct obd_device *obd)
2142 {
2143         char flags[3] = "";
2144         struct lustre_cfg *lcfg;
2145         struct lustre_cfg_bufs bufs;
2146         int rc;
2147
2148         ENTRY;
2149
2150         if (!obd) {
2151                 CERROR("empty cleanup\n");
2152                 RETURN(-EALREADY);
2153         }
2154
2155         if (obd->obd_force)
2156                 strlcat(flags, "F", sizeof(flags));
2157         if (obd->obd_fail)
2158                 strlcat(flags, "A", sizeof(flags));
2159
2160         CDEBUG(D_CONFIG, "Manual cleanup of %s (flags='%s')\n",
2161                obd->obd_name, flags);
2162
2163         lustre_cfg_bufs_reset(&bufs, obd->obd_name);
2164         lustre_cfg_bufs_set_string(&bufs, 1, flags);
2165         OBD_ALLOC(lcfg, lustre_cfg_len(bufs.lcfg_bufcount, bufs.lcfg_buflen));
2166         if (!lcfg)
2167                 RETURN(-ENOMEM);
2168         lustre_cfg_init(lcfg, LCFG_CLEANUP, &bufs);
2169
2170         rc = class_process_config(lcfg);
2171         if (rc) {
2172                 CERROR("cleanup failed %d: %s\n", rc, obd->obd_name);
2173                 GOTO(out, rc);
2174         }
2175
2176         /* the lcfg is almost the same for both ops */
2177         lcfg->lcfg_command = LCFG_DETACH;
2178         rc = class_process_config(lcfg);
2179         if (rc)
2180                 CERROR("detach failed %d: %s\n", rc, obd->obd_name);
2181 out:
2182         OBD_FREE(lcfg, lustre_cfg_len(lcfg->lcfg_bufcount, lcfg->lcfg_buflens));
2183         RETURN(rc);
2184 }
2185 EXPORT_SYMBOL(class_manual_cleanup);
2186
2187 /*
2188  * nid<->export hash operations
2189  */
2190 static unsigned
2191 nid_hash(struct cfs_hash *hs, const void *key, unsigned mask)
2192 {
2193         return cfs_hash_djb2_hash(key, sizeof(lnet_nid_t), mask);
2194 }
2195
2196 static void *
2197 nid_key(struct hlist_node *hnode)
2198 {
2199         struct obd_export *exp;
2200
2201         exp = hlist_entry(hnode, struct obd_export, exp_nid_hash);
2202
2203         RETURN(&exp->exp_connection->c_peer.nid);
2204 }
2205
2206 /*
2207  * NOTE: It is impossible to find an export that is in failed
2208  *       state with this function
2209  */
2210 static int
2211 nid_kepcmp(const void *key, struct hlist_node *hnode)
2212 {
2213         struct obd_export *exp;
2214
2215         LASSERT(key);
2216         exp = hlist_entry(hnode, struct obd_export, exp_nid_hash);
2217
2218         RETURN(exp->exp_connection->c_peer.nid == *(lnet_nid_t *)key &&
2219                !exp->exp_failed);
2220 }
2221
2222 static void *
2223 nid_export_object(struct hlist_node *hnode)
2224 {
2225         return hlist_entry(hnode, struct obd_export, exp_nid_hash);
2226 }
2227
2228 static void
2229 nid_export_get(struct cfs_hash *hs, struct hlist_node *hnode)
2230 {
2231         struct obd_export *exp;
2232
2233         exp = hlist_entry(hnode, struct obd_export, exp_nid_hash);
2234         class_export_get(exp);
2235 }
2236
2237 static void
2238 nid_export_put_locked(struct cfs_hash *hs, struct hlist_node *hnode)
2239 {
2240         struct obd_export *exp;
2241
2242         exp = hlist_entry(hnode, struct obd_export, exp_nid_hash);
2243         class_export_put(exp);
2244 }
2245
2246 static struct cfs_hash_ops nid_hash_ops = {
2247         .hs_hash        = nid_hash,
2248         .hs_key         = nid_key,
2249         .hs_keycmp      = nid_kepcmp,
2250         .hs_object      = nid_export_object,
2251         .hs_get         = nid_export_get,
2252         .hs_put_locked  = nid_export_put_locked,
2253 };
2254
2255
2256 /*
2257  * nid<->nidstats hash operations
2258  */
2259
2260 static void *
2261 nidstats_key(struct hlist_node *hnode)
2262 {
2263         struct nid_stat *ns;
2264
2265         ns = hlist_entry(hnode, struct nid_stat, nid_hash);
2266
2267         return &ns->nid;
2268 }
2269
2270 static int
2271 nidstats_keycmp(const void *key, struct hlist_node *hnode)
2272 {
2273         return *(lnet_nid_t *)nidstats_key(hnode) == *(lnet_nid_t *)key;
2274 }
2275
2276 static void *
2277 nidstats_object(struct hlist_node *hnode)
2278 {
2279         return hlist_entry(hnode, struct nid_stat, nid_hash);
2280 }
2281
2282 static void
2283 nidstats_get(struct cfs_hash *hs, struct hlist_node *hnode)
2284 {
2285         struct nid_stat *ns;
2286
2287         ns = hlist_entry(hnode, struct nid_stat, nid_hash);
2288         nidstat_getref(ns);
2289 }
2290
2291 static void
2292 nidstats_put_locked(struct cfs_hash *hs, struct hlist_node *hnode)
2293 {
2294         struct nid_stat *ns;
2295
2296         ns = hlist_entry(hnode, struct nid_stat, nid_hash);
2297         nidstat_putref(ns);
2298 }
2299
2300 static struct cfs_hash_ops nid_stat_hash_ops = {
2301         .hs_hash        = nid_hash,
2302         .hs_key         = nidstats_key,
2303         .hs_keycmp      = nidstats_keycmp,
2304         .hs_object      = nidstats_object,
2305         .hs_get         = nidstats_get,
2306         .hs_put_locked  = nidstats_put_locked,
2307 };
2308
2309
2310 /*
2311  * client_generation<->export hash operations
2312  */
2313
2314 static unsigned
2315 gen_hash(struct cfs_hash *hs, const void *key, unsigned mask)
2316 {
2317         return cfs_hash_djb2_hash(key, sizeof(__u32), mask);
2318 }
2319
2320 static void *
2321 gen_key(struct hlist_node *hnode)
2322 {
2323         struct obd_export *exp;
2324
2325         exp = hlist_entry(hnode, struct obd_export, exp_gen_hash);
2326
2327         RETURN(&exp->exp_target_data.ted_lcd->lcd_generation);
2328 }
2329
2330 /*
2331  * NOTE: It is impossible to find an export that is in failed
2332  *       state with this function
2333  */
2334 static int
2335 gen_kepcmp(const void *key, struct hlist_node *hnode)
2336 {
2337         struct obd_export *exp;
2338
2339         LASSERT(key);
2340         exp = hlist_entry(hnode, struct obd_export, exp_gen_hash);
2341
2342         RETURN(exp->exp_target_data.ted_lcd->lcd_generation == *(__u32 *)key &&
2343                !exp->exp_failed);
2344 }
2345
2346 static void *
2347 gen_export_object(struct hlist_node *hnode)
2348 {
2349         return hlist_entry(hnode, struct obd_export, exp_gen_hash);
2350 }
2351
2352 static void
2353 gen_export_get(struct cfs_hash *hs, struct hlist_node *hnode)
2354 {
2355         struct obd_export *exp;
2356
2357         exp = hlist_entry(hnode, struct obd_export, exp_gen_hash);
2358         class_export_get(exp);
2359 }
2360
2361 static void
2362 gen_export_put_locked(struct cfs_hash *hs, struct hlist_node *hnode)
2363 {
2364         struct obd_export *exp;
2365
2366         exp = hlist_entry(hnode, struct obd_export, exp_gen_hash);
2367         class_export_put(exp);
2368 }
2369
2370 static struct cfs_hash_ops gen_hash_ops = {
2371         .hs_hash        = gen_hash,
2372         .hs_key         = gen_key,
2373         .hs_keycmp      = gen_kepcmp,
2374         .hs_object      = gen_export_object,
2375         .hs_get         = gen_export_get,
2376         .hs_put_locked  = gen_export_put_locked,
2377 };