]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/staging/lustre/lustre/obdclass/obd_config.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:


f7b6e1657fc99ba17b4a25aac7cfb35c623f6dff
[mirror_ubuntu-artful-kernel.git] / drivers / staging / lustre / 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.sun.com/software/products/lustre/docs/GPLv2.pdf
19 *
20 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21 * CA 95054 USA or visit www.sun.com if you need additional information or
22 * have any questions.
23 *
24 * GPL HEADER END
25 */
26 /*
27 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
28 * Use is subject to license terms.
29 *
30 * Copyright (c) 2011, 2012, Intel Corporation.
31 */
32 /*
33 * This file is part of Lustre, http://www.lustre.org/
34 * Lustre is a trademark of Sun Microsystems, Inc.
35 *
36 * lustre/obdclass/obd_config.c
37 *
38 * Config API
39 */
40
41 #define DEBUG_SUBSYSTEM S_CLASS
42 #include "../include/obd_class.h"
43 #include <linux/string.h>
44 #include "../include/lustre_log.h"
45 #include "../include/lprocfs_status.h"
46 #include "../include/lustre_param.h"
47
48 #include "llog_internal.h"
49
50 static cfs_hash_ops_t uuid_hash_ops;
51 static cfs_hash_ops_t nid_hash_ops;
52 static cfs_hash_ops_t nid_stat_hash_ops;
53
54 /*********** string parsing utils *********/
55
56 /* returns 0 if we find this key in the buffer, else 1 */
57 int class_find_param(char *buf, char *key, char **valp)
58 {
59 char *ptr;
60
61 if (!buf)
62 return 1;
63
64 ptr = strstr(buf, key);
65 if (ptr == NULL)
66 return 1;
67
68 if (valp)
69 *valp = ptr + strlen(key);
70
71 return 0;
72 }
73 EXPORT_SYMBOL(class_find_param);
74
75 /**
76 * Check whether the proc parameter \a param is an old parameter or not from
77 * the array \a ptr which contains the mapping from old parameters to new ones.
78 * If it's an old one, then return the pointer to the cfg_interop_param struc-
79 * ture which contains both the old and new parameters.
80 *
81 * \param param proc parameter
82 * \param ptr an array which contains the mapping from
83 * old parameters to new ones
84 *
85 * \retval valid-pointer pointer to the cfg_interop_param structure
86 * which contains the old and new parameters
87 * \retval NULL \a param or \a ptr is NULL,
88 * or \a param is not an old parameter
89 */
90 struct cfg_interop_param *class_find_old_param(const char *param,
91 struct cfg_interop_param *ptr)
92 {
93 char *value = NULL;
94 int name_len = 0;
95
96 if (param == NULL || ptr == NULL)
97 return NULL;
98
99 value = strchr(param, '=');
100 if (value == NULL)
101 name_len = strlen(param);
102 else
103 name_len = value - param;
104
105 while (ptr->old_param != NULL) {
106 if (strncmp(param, ptr->old_param, name_len) == 0 &&
107 name_len == strlen(ptr->old_param))
108 return ptr;
109 ptr++;
110 }
111
112 return NULL;
113 }
114 EXPORT_SYMBOL(class_find_old_param);
115
116 /**
117 * Finds a parameter in \a params and copies it to \a copy.
118 *
119 * Leading spaces are skipped. Next space or end of string is the
120 * parameter terminator with the exception that spaces inside single or double
121 * quotes get included into a parameter. The parameter is copied into \a copy
122 * which has to be allocated big enough by a caller, quotes are stripped in
123 * the copy and the copy is terminated by 0.
124 *
125 * On return \a params is set to next parameter or to NULL if last
126 * parameter is returned.
127 *
128 * \retval 0 if parameter is returned in \a copy
129 * \retval 1 otherwise
130 * \retval -EINVAL if unbalanced quota is found
131 */
132 int class_get_next_param(char **params, char *copy)
133 {
134 char *q1, *q2, *str;
135 int len;
136
137 str = *params;
138 while (*str == ' ')
139 str++;
140
141 if (*str == '\0') {
142 *params = NULL;
143 return 1;
144 }
145
146 while (1) {
147 q1 = strpbrk(str, " '\"");
148 if (q1 == NULL) {
149 len = strlen(str);
150 memcpy(copy, str, len);
151 copy[len] = '\0';
152 *params = NULL;
153 return 0;
154 }
155 len = q1 - str;
156 if (*q1 == ' ') {
157 memcpy(copy, str, len);
158 copy[len] = '\0';
159 *params = str + len;
160 return 0;
161 }
162
163 memcpy(copy, str, len);
164 copy += len;
165
166 /* search for the matching closing quote */
167 str = q1 + 1;
168 q2 = strchr(str, *q1);
169 if (q2 == NULL) {
170 CERROR("Unbalanced quota in parameters: \"%s\"\n",
171 *params);
172 return -EINVAL;
173 }
174 len = q2 - str;
175 memcpy(copy, str, len);
176 copy += len;
177 str = q2 + 1;
178 }
179 return 1;
180 }
181 EXPORT_SYMBOL(class_get_next_param);
182
183 /* returns 0 if this is the first key in the buffer, else 1.
184 valp points to first char after key. */
185 int class_match_param(char *buf, char *key, char **valp)
186 {
187 if (!buf)
188 return 1;
189
190 if (memcmp(buf, key, strlen(key)) != 0)
191 return 1;
192
193 if (valp)
194 *valp = buf + strlen(key);
195
196 return 0;
197 }
198 EXPORT_SYMBOL(class_match_param);
199
200 static int parse_nid(char *buf, void *value, int quiet)
201 {
202 lnet_nid_t *nid = (lnet_nid_t *)value;
203
204 *nid = libcfs_str2nid(buf);
205 if (*nid != LNET_NID_ANY)
206 return 0;
207
208 if (!quiet)
209 LCONSOLE_ERROR_MSG(0x159, "Can't parse NID '%s'\n", buf);
210 return -EINVAL;
211 }
212
213 static int parse_net(char *buf, void *value)
214 {
215 __u32 *net = (__u32 *)value;
216
217 *net = libcfs_str2net(buf);
218 CDEBUG(D_INFO, "Net %s\n", libcfs_net2str(*net));
219 return 0;
220 }
221
222 enum {
223 CLASS_PARSE_NID = 1,
224 CLASS_PARSE_NET,
225 };
226
227 /* 0 is good nid,
228 1 not found
229 < 0 error
230 endh is set to next separator */
231 static int class_parse_value(char *buf, int opc, void *value, char **endh,
232 int quiet)
233 {
234 char *endp;
235 char tmp;
236 int rc = 0;
237
238 if (!buf)
239 return 1;
240 while (*buf == ',' || *buf == ':')
241 buf++;
242 if (*buf == ' ' || *buf == '/' || *buf == '\0')
243 return 1;
244
245 /* nid separators or end of nids */
246 endp = strpbrk(buf, ",: /");
247 if (endp == NULL)
248 endp = buf + strlen(buf);
249
250 tmp = *endp;
251 *endp = '\0';
252 switch (opc) {
253 default:
254 LBUG();
255 case CLASS_PARSE_NID:
256 rc = parse_nid(buf, value, quiet);
257 break;
258 case CLASS_PARSE_NET:
259 rc = parse_net(buf, value);
260 break;
261 }
262 *endp = tmp;
263 if (rc != 0)
264 return rc;
265 if (endh)
266 *endh = endp;
267 return 0;
268 }
269
270 int class_parse_nid(char *buf, lnet_nid_t *nid, char **endh)
271 {
272 return class_parse_value(buf, CLASS_PARSE_NID, (void *)nid, endh, 0);
273 }
274 EXPORT_SYMBOL(class_parse_nid);
275
276 int class_parse_nid_quiet(char *buf, lnet_nid_t *nid, char **endh)
277 {
278 return class_parse_value(buf, CLASS_PARSE_NID, (void *)nid, endh, 1);
279 }
280 EXPORT_SYMBOL(class_parse_nid_quiet);
281
282 int class_parse_net(char *buf, __u32 *net, char **endh)
283 {
284 return class_parse_value(buf, CLASS_PARSE_NET, (void *)net, endh, 0);
285 }
286 EXPORT_SYMBOL(class_parse_net);
287
288 /* 1 param contains key and match
289 * 0 param contains key and not match
290 * -1 param does not contain key
291 */
292 int class_match_nid(char *buf, char *key, lnet_nid_t nid)
293 {
294 lnet_nid_t tmp;
295 int rc = -1;
296
297 while (class_find_param(buf, key, &buf) == 0) {
298 /* please restrict to the nids pertaining to
299 * the specified nids */
300 while (class_parse_nid(buf, &tmp, &buf) == 0) {
301 if (tmp == nid)
302 return 1;
303 }
304 rc = 0;
305 }
306 return rc;
307 }
308 EXPORT_SYMBOL(class_match_nid);
309
310 int class_match_net(char *buf, char *key, __u32 net)
311 {
312 __u32 tmp;
313 int rc = -1;
314
315 while (class_find_param(buf, key, &buf) == 0) {
316 /* please restrict to the nids pertaining to
317 * the specified networks */
318 while (class_parse_net(buf, &tmp, &buf) == 0) {
319 if (tmp == net)
320 return 1;
321 }
322 rc = 0;
323 }
324 return rc;
325 }
326 EXPORT_SYMBOL(class_match_net);
327
328 /********************** class fns **********************/
329
330 /**
331 * Create a new obd device and set the type, name and uuid. If successful,
332 * the new device can be accessed by either name or uuid.
333 */
334 int class_attach(struct lustre_cfg *lcfg)
335 {
336 struct obd_device *obd = NULL;
337 char *typename, *name, *uuid;
338 int rc, len;
339
340 if (!LUSTRE_CFG_BUFLEN(lcfg, 1)) {
341 CERROR("No type passed!\n");
342 return -EINVAL;
343 }
344 typename = lustre_cfg_string(lcfg, 1);
345
346 if (!LUSTRE_CFG_BUFLEN(lcfg, 0)) {
347 CERROR("No name passed!\n");
348 return -EINVAL;
349 }
350 name = lustre_cfg_string(lcfg, 0);
351
352 if (!LUSTRE_CFG_BUFLEN(lcfg, 2)) {
353 CERROR("No UUID passed!\n");
354 return -EINVAL;
355 }
356 uuid = lustre_cfg_string(lcfg, 2);
357
358 CDEBUG(D_IOCTL, "attach type %s name: %s uuid: %s\n",
359 MKSTR(typename), MKSTR(name), MKSTR(uuid));
360
361 obd = class_newdev(typename, name);
362 if (IS_ERR(obd)) {
363 /* Already exists or out of obds */
364 rc = PTR_ERR(obd);
365 obd = NULL;
366 CERROR("Cannot create device %s of type %s : %d\n",
367 name, typename, rc);
368 GOTO(out, rc);
369 }
370 LASSERTF(obd != NULL, "Cannot get obd device %s of type %s\n",
371 name, typename);
372 LASSERTF(obd->obd_magic == OBD_DEVICE_MAGIC,
373 "obd %p obd_magic %08X != %08X\n",
374 obd, obd->obd_magic, OBD_DEVICE_MAGIC);
375 LASSERTF(strncmp(obd->obd_name, name, strlen(name)) == 0,
376 "%p obd_name %s != %s\n", obd, obd->obd_name, name);
377
378 rwlock_init(&obd->obd_pool_lock);
379 obd->obd_pool_limit = 0;
380 obd->obd_pool_slv = 0;
381
382 INIT_LIST_HEAD(&obd->obd_exports);
383 INIT_LIST_HEAD(&obd->obd_unlinked_exports);
384 INIT_LIST_HEAD(&obd->obd_delayed_exports);
385 INIT_LIST_HEAD(&obd->obd_exports_timed);
386 INIT_LIST_HEAD(&obd->obd_nid_stats);
387 spin_lock_init(&obd->obd_nid_lock);
388 spin_lock_init(&obd->obd_dev_lock);
389 mutex_init(&obd->obd_dev_mutex);
390 spin_lock_init(&obd->obd_osfs_lock);
391 /* obd->obd_osfs_age must be set to a value in the distant
392 * past to guarantee a fresh statfs is fetched on mount. */
393 obd->obd_osfs_age = cfs_time_shift_64(-1000);
394
395 /* XXX belongs in setup not attach */
396 init_rwsem(&obd->obd_observer_link_sem);
397 /* recovery data */
398 cfs_init_timer(&obd->obd_recovery_timer);
399 spin_lock_init(&obd->obd_recovery_task_lock);
400 init_waitqueue_head(&obd->obd_next_transno_waitq);
401 init_waitqueue_head(&obd->obd_evict_inprogress_waitq);
402 INIT_LIST_HEAD(&obd->obd_req_replay_queue);
403 INIT_LIST_HEAD(&obd->obd_lock_replay_queue);
404 INIT_LIST_HEAD(&obd->obd_final_req_queue);
405 INIT_LIST_HEAD(&obd->obd_evict_list);
406
407 llog_group_init(&obd->obd_olg, FID_SEQ_LLOG);
408
409 obd->obd_conn_inprogress = 0;
410
411 len = strlen(uuid);
412 if (len >= sizeof(obd->obd_uuid)) {
413 CERROR("uuid must be < %d bytes long\n",
414 (int)sizeof(obd->obd_uuid));
415 GOTO(out, rc = -EINVAL);
416 }
417 memcpy(obd->obd_uuid.uuid, uuid, len);
418
419 /* do the attach */
420 if (OBP(obd, attach)) {
421 rc = OBP(obd, attach)(obd, sizeof(*lcfg), lcfg);
422 if (rc)
423 GOTO(out, rc = -EINVAL);
424 }
425
426 /* Detach drops this */
427 spin_lock(&obd->obd_dev_lock);
428 atomic_set(&obd->obd_refcount, 1);
429 spin_unlock(&obd->obd_dev_lock);
430 lu_ref_init(&obd->obd_reference);
431 lu_ref_add(&obd->obd_reference, "attach", obd);
432
433 obd->obd_attached = 1;
434 CDEBUG(D_IOCTL, "OBD: dev %d attached type %s with refcount %d\n",
435 obd->obd_minor, typename, atomic_read(&obd->obd_refcount));
436 return 0;
437 out:
438 if (obd != NULL) {
439 class_release_dev(obd);
440 }
441 return rc;
442 }
443 EXPORT_SYMBOL(class_attach);
444
445 /** Create hashes, self-export, and call type-specific setup.
446 * Setup is effectively the "start this obd" call.
447 */
448 int class_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
449 {
450 int err = 0;
451 struct obd_export *exp;
452
453 LASSERT(obd != NULL);
454 LASSERTF(obd == class_num2obd(obd->obd_minor),
455 "obd %p != obd_devs[%d] %p\n",
456 obd, obd->obd_minor, class_num2obd(obd->obd_minor));
457 LASSERTF(obd->obd_magic == OBD_DEVICE_MAGIC,
458 "obd %p obd_magic %08x != %08x\n",
459 obd, obd->obd_magic, OBD_DEVICE_MAGIC);
460
461 /* have we attached a type to this device? */
462 if (!obd->obd_attached) {
463 CERROR("Device %d not attached\n", obd->obd_minor);
464 return -ENODEV;
465 }
466
467 if (obd->obd_set_up) {
468 CERROR("Device %d already setup (type %s)\n",
469 obd->obd_minor, obd->obd_type->typ_name);
470 return -EEXIST;
471 }
472
473 /* is someone else setting us up right now? (attach inits spinlock) */
474 spin_lock(&obd->obd_dev_lock);
475 if (obd->obd_starting) {
476 spin_unlock(&obd->obd_dev_lock);
477 CERROR("Device %d setup in progress (type %s)\n",
478 obd->obd_minor, obd->obd_type->typ_name);
479 return -EEXIST;
480 }
481 /* just leave this on forever. I can't use obd_set_up here because
482 other fns check that status, and we're not actually set up yet. */
483 obd->obd_starting = 1;
484 obd->obd_uuid_hash = NULL;
485 obd->obd_nid_hash = NULL;
486 obd->obd_nid_stats_hash = NULL;
487 spin_unlock(&obd->obd_dev_lock);
488
489 /* create an uuid-export lustre hash */
490 obd->obd_uuid_hash = cfs_hash_create("UUID_HASH",
491 HASH_UUID_CUR_BITS,
492 HASH_UUID_MAX_BITS,
493 HASH_UUID_BKT_BITS, 0,
494 CFS_HASH_MIN_THETA,
495 CFS_HASH_MAX_THETA,
496 &uuid_hash_ops, CFS_HASH_DEFAULT);
497 if (!obd->obd_uuid_hash)
498 GOTO(err_hash, err = -ENOMEM);
499
500 /* create a nid-export lustre hash */
501 obd->obd_nid_hash = cfs_hash_create("NID_HASH",
502 HASH_NID_CUR_BITS,
503 HASH_NID_MAX_BITS,
504 HASH_NID_BKT_BITS, 0,
505 CFS_HASH_MIN_THETA,
506 CFS_HASH_MAX_THETA,
507 &nid_hash_ops, CFS_HASH_DEFAULT);
508 if (!obd->obd_nid_hash)
509 GOTO(err_hash, err = -ENOMEM);
510
511 /* create a nid-stats lustre hash */
512 obd->obd_nid_stats_hash = cfs_hash_create("NID_STATS",
513 HASH_NID_STATS_CUR_BITS,
514 HASH_NID_STATS_MAX_BITS,
515 HASH_NID_STATS_BKT_BITS, 0,
516 CFS_HASH_MIN_THETA,
517 CFS_HASH_MAX_THETA,
518 &nid_stat_hash_ops, CFS_HASH_DEFAULT);
519 if (!obd->obd_nid_stats_hash)
520 GOTO(err_hash, err = -ENOMEM);
521
522 exp = class_new_export(obd, &obd->obd_uuid);
523 if (IS_ERR(exp))
524 GOTO(err_hash, err = PTR_ERR(exp));
525
526 obd->obd_self_export = exp;
527 list_del_init(&exp->exp_obd_chain_timed);
528 class_export_put(exp);
529
530 err = obd_setup(obd, lcfg);
531 if (err)
532 GOTO(err_exp, err);
533
534 obd->obd_set_up = 1;
535
536 spin_lock(&obd->obd_dev_lock);
537 /* cleanup drops this */
538 class_incref(obd, "setup", obd);
539 spin_unlock(&obd->obd_dev_lock);
540
541 CDEBUG(D_IOCTL, "finished setup of obd %s (uuid %s)\n",
542 obd->obd_name, obd->obd_uuid.uuid);
543
544 return 0;
545 err_exp:
546 if (obd->obd_self_export) {
547 class_unlink_export(obd->obd_self_export);
548 obd->obd_self_export = NULL;
549 }
550 err_hash:
551 if (obd->obd_uuid_hash) {
552 cfs_hash_putref(obd->obd_uuid_hash);
553 obd->obd_uuid_hash = NULL;
554 }
555 if (obd->obd_nid_hash) {
556 cfs_hash_putref(obd->obd_nid_hash);
557 obd->obd_nid_hash = NULL;
558 }
559 if (obd->obd_nid_stats_hash) {
560 cfs_hash_putref(obd->obd_nid_stats_hash);
561 obd->obd_nid_stats_hash = NULL;
562 }
563 obd->obd_starting = 0;
564 CERROR("setup %s failed (%d)\n", obd->obd_name, err);
565 return err;
566 }
567 EXPORT_SYMBOL(class_setup);
568
569 /** We have finished using this obd and are ready to destroy it.
570 * There can be no more references to this obd.
571 */
572 int class_detach(struct obd_device *obd, struct lustre_cfg *lcfg)
573 {
574 if (obd->obd_set_up) {
575 CERROR("OBD device %d still set up\n", obd->obd_minor);
576 return -EBUSY;
577 }
578
579 spin_lock(&obd->obd_dev_lock);
580 if (!obd->obd_attached) {
581 spin_unlock(&obd->obd_dev_lock);
582 CERROR("OBD device %d not attached\n", obd->obd_minor);
583 return -ENODEV;
584 }
585 obd->obd_attached = 0;
586 spin_unlock(&obd->obd_dev_lock);
587
588 CDEBUG(D_IOCTL, "detach on obd %s (uuid %s)\n",
589 obd->obd_name, obd->obd_uuid.uuid);
590
591 class_decref(obd, "attach", obd);
592 return 0;
593 }
594 EXPORT_SYMBOL(class_detach);
595
596 /** Start shutting down the obd. There may be in-progress ops when
597 * this is called. We tell them to start shutting down with a call
598 * to class_disconnect_exports().
599 */
600 int class_cleanup(struct obd_device *obd, struct lustre_cfg *lcfg)
601 {
602 int err = 0;
603 char *flag;
604
605 OBD_RACE(OBD_FAIL_LDLM_RECOV_CLIENTS);
606
607 if (!obd->obd_set_up) {
608 CERROR("Device %d not setup\n", obd->obd_minor);
609 return -ENODEV;
610 }
611
612 spin_lock(&obd->obd_dev_lock);
613 if (obd->obd_stopping) {
614 spin_unlock(&obd->obd_dev_lock);
615 CERROR("OBD %d already stopping\n", obd->obd_minor);
616 return -ENODEV;
617 }
618 /* Leave this on forever */
619 obd->obd_stopping = 1;
620
621 /* wait for already-arrived-connections to finish. */
622 while (obd->obd_conn_inprogress > 0) {
623 spin_unlock(&obd->obd_dev_lock);
624
625 cond_resched();
626
627 spin_lock(&obd->obd_dev_lock);
628 }
629 spin_unlock(&obd->obd_dev_lock);
630
631 if (lcfg->lcfg_bufcount >= 2 && LUSTRE_CFG_BUFLEN(lcfg, 1) > 0) {
632 for (flag = lustre_cfg_string(lcfg, 1); *flag != 0; flag++)
633 switch (*flag) {
634 case 'F':
635 obd->obd_force = 1;
636 break;
637 case 'A':
638 LCONSOLE_WARN("Failing over %s\n",
639 obd->obd_name);
640 obd->obd_fail = 1;
641 obd->obd_no_transno = 1;
642 obd->obd_no_recov = 1;
643 if (OBP(obd, iocontrol)) {
644 obd_iocontrol(OBD_IOC_SYNC,
645 obd->obd_self_export,
646 0, NULL, NULL);
647 }
648 break;
649 default:
650 CERROR("Unrecognised flag '%c'\n", *flag);
651 }
652 }
653
654 LASSERT(obd->obd_self_export);
655
656 /* The three references that should be remaining are the
657 * obd_self_export and the attach and setup references. */
658 if (atomic_read(&obd->obd_refcount) > 3) {
659 /* refcount - 3 might be the number of real exports
660 (excluding self export). But class_incref is called
661 by other things as well, so don't count on it. */
662 CDEBUG(D_IOCTL, "%s: forcing exports to disconnect: %d\n",
663 obd->obd_name, atomic_read(&obd->obd_refcount) - 3);
664 dump_exports(obd, 0);
665 class_disconnect_exports(obd);
666 }
667
668 /* Precleanup, we must make sure all exports get destroyed. */
669 err = obd_precleanup(obd, OBD_CLEANUP_EXPORTS);
670 if (err)
671 CERROR("Precleanup %s returned %d\n",
672 obd->obd_name, err);
673
674 /* destroy an uuid-export hash body */
675 if (obd->obd_uuid_hash) {
676 cfs_hash_putref(obd->obd_uuid_hash);
677 obd->obd_uuid_hash = NULL;
678 }
679
680 /* destroy a nid-export hash body */
681 if (obd->obd_nid_hash) {
682 cfs_hash_putref(obd->obd_nid_hash);
683 obd->obd_nid_hash = NULL;
684 }
685
686 /* destroy a nid-stats hash body */
687 if (obd->obd_nid_stats_hash) {
688 cfs_hash_putref(obd->obd_nid_stats_hash);
689 obd->obd_nid_stats_hash = NULL;
690 }
691
692 class_decref(obd, "setup", obd);
693 obd->obd_set_up = 0;
694
695 return 0;
696 }
697 EXPORT_SYMBOL(class_cleanup);
698
699 struct obd_device *class_incref(struct obd_device *obd,
700 const char *scope, const void *source)
701 {
702 lu_ref_add_atomic(&obd->obd_reference, scope, source);
703 atomic_inc(&obd->obd_refcount);
704 CDEBUG(D_INFO, "incref %s (%p) now %d\n", obd->obd_name, obd,
705 atomic_read(&obd->obd_refcount));
706
707 return obd;
708 }
709 EXPORT_SYMBOL(class_incref);
710
711 void class_decref(struct obd_device *obd, const char *scope, const void *source)
712 {
713 int err;
714 int refs;
715
716 spin_lock(&obd->obd_dev_lock);
717 atomic_dec(&obd->obd_refcount);
718 refs = atomic_read(&obd->obd_refcount);
719 spin_unlock(&obd->obd_dev_lock);
720 lu_ref_del(&obd->obd_reference, scope, source);
721
722 CDEBUG(D_INFO, "Decref %s (%p) now %d\n", obd->obd_name, obd, refs);
723
724 if ((refs == 1) && obd->obd_stopping) {
725 /* All exports have been destroyed; there should
726 be no more in-progress ops by this point.*/
727
728 spin_lock(&obd->obd_self_export->exp_lock);
729 obd->obd_self_export->exp_flags |= exp_flags_from_obd(obd);
730 spin_unlock(&obd->obd_self_export->exp_lock);
731
732 /* note that we'll recurse into class_decref again */
733 class_unlink_export(obd->obd_self_export);
734 return;
735 }
736
737 if (refs == 0) {
738 CDEBUG(D_CONFIG, "finishing cleanup of obd %s (%s)\n",
739 obd->obd_name, obd->obd_uuid.uuid);
740 LASSERT(!obd->obd_attached);
741 if (obd->obd_stopping) {
742 /* If we're not stopping, we were never set up */
743 err = obd_cleanup(obd);
744 if (err)
745 CERROR("Cleanup %s returned %d\n",
746 obd->obd_name, err);
747 }
748 if (OBP(obd, detach)) {
749 err = OBP(obd, detach)(obd);
750 if (err)
751 CERROR("Detach returned %d\n", err);
752 }
753 class_release_dev(obd);
754 }
755 }
756 EXPORT_SYMBOL(class_decref);
757
758 /** Add a failover nid location.
759 * Client obd types contact server obd types using this nid list.
760 */
761 int class_add_conn(struct obd_device *obd, struct lustre_cfg *lcfg)
762 {
763 struct obd_import *imp;
764 struct obd_uuid uuid;
765 int rc;
766
767 if (LUSTRE_CFG_BUFLEN(lcfg, 1) < 1 ||
768 LUSTRE_CFG_BUFLEN(lcfg, 1) > sizeof(struct obd_uuid)) {
769 CERROR("invalid conn_uuid\n");
770 return -EINVAL;
771 }
772 if (strcmp(obd->obd_type->typ_name, LUSTRE_MDC_NAME) &&
773 strcmp(obd->obd_type->typ_name, LUSTRE_OSC_NAME) &&
774 strcmp(obd->obd_type->typ_name, LUSTRE_OSP_NAME) &&
775 strcmp(obd->obd_type->typ_name, LUSTRE_LWP_NAME) &&
776 strcmp(obd->obd_type->typ_name, LUSTRE_MGC_NAME)) {
777 CERROR("can't add connection on non-client dev\n");
778 return -EINVAL;
779 }
780
781 imp = obd->u.cli.cl_import;
782 if (!imp) {
783 CERROR("try to add conn on immature client dev\n");
784 return -EINVAL;
785 }
786
787 obd_str2uuid(&uuid, lustre_cfg_string(lcfg, 1));
788 rc = obd_add_conn(imp, &uuid, lcfg->lcfg_num);
789
790 return rc;
791 }
792 EXPORT_SYMBOL(class_add_conn);
793
794 /** Remove a failover nid location.
795 */
796 int class_del_conn(struct obd_device *obd, struct lustre_cfg *lcfg)
797 {
798 struct obd_import *imp;
799 struct obd_uuid uuid;
800 int rc;
801
802 if (LUSTRE_CFG_BUFLEN(lcfg, 1) < 1 ||
803 LUSTRE_CFG_BUFLEN(lcfg, 1) > sizeof(struct obd_uuid)) {
804 CERROR("invalid conn_uuid\n");
805 return -EINVAL;
806 }
807 if (strcmp(obd->obd_type->typ_name, LUSTRE_MDC_NAME) &&
808 strcmp(obd->obd_type->typ_name, LUSTRE_OSC_NAME)) {
809 CERROR("can't del connection on non-client dev\n");
810 return -EINVAL;
811 }
812
813 imp = obd->u.cli.cl_import;
814 if (!imp) {
815 CERROR("try to del conn on immature client dev\n");
816 return -EINVAL;
817 }
818
819 obd_str2uuid(&uuid, lustre_cfg_string(lcfg, 1));
820 rc = obd_del_conn(imp, &uuid);
821
822 return rc;
823 }
824
825 LIST_HEAD(lustre_profile_list);
826
827 struct lustre_profile *class_get_profile(const char * prof)
828 {
829 struct lustre_profile *lprof;
830
831 list_for_each_entry(lprof, &lustre_profile_list, lp_list) {
832 if (!strcmp(lprof->lp_profile, prof)) {
833 return lprof;
834 }
835 }
836 return NULL;
837 }
838 EXPORT_SYMBOL(class_get_profile);
839
840 /** Create a named "profile".
841 * This defines the mdc and osc names to use for a client.
842 * This also is used to define the lov to be used by a mdt.
843 */
844 int class_add_profile(int proflen, char *prof, int osclen, char *osc,
845 int mdclen, char *mdc)
846 {
847 struct lustre_profile *lprof;
848 int err = 0;
849
850 CDEBUG(D_CONFIG, "Add profile %s\n", prof);
851
852 OBD_ALLOC(lprof, sizeof(*lprof));
853 if (lprof == NULL)
854 return -ENOMEM;
855 INIT_LIST_HEAD(&lprof->lp_list);
856
857 LASSERT(proflen == (strlen(prof) + 1));
858 OBD_ALLOC(lprof->lp_profile, proflen);
859 if (lprof->lp_profile == NULL)
860 GOTO(out, err = -ENOMEM);
861 memcpy(lprof->lp_profile, prof, proflen);
862
863 LASSERT(osclen == (strlen(osc) + 1));
864 OBD_ALLOC(lprof->lp_dt, osclen);
865 if (lprof->lp_dt == NULL)
866 GOTO(out, err = -ENOMEM);
867 memcpy(lprof->lp_dt, osc, osclen);
868
869 if (mdclen > 0) {
870 LASSERT(mdclen == (strlen(mdc) + 1));
871 OBD_ALLOC(lprof->lp_md, mdclen);
872 if (lprof->lp_md == NULL)
873 GOTO(out, err = -ENOMEM);
874 memcpy(lprof->lp_md, mdc, mdclen);
875 }
876
877 list_add(&lprof->lp_list, &lustre_profile_list);
878 return err;
879
880 out:
881 if (lprof->lp_md)
882 OBD_FREE(lprof->lp_md, mdclen);
883 if (lprof->lp_dt)
884 OBD_FREE(lprof->lp_dt, osclen);
885 if (lprof->lp_profile)
886 OBD_FREE(lprof->lp_profile, proflen);
887 OBD_FREE(lprof, sizeof(*lprof));
888 return err;
889 }
890
891 void class_del_profile(const char *prof)
892 {
893 struct lustre_profile *lprof;
894
895 CDEBUG(D_CONFIG, "Del profile %s\n", prof);
896
897 lprof = class_get_profile(prof);
898 if (lprof) {
899 list_del(&lprof->lp_list);
900 OBD_FREE(lprof->lp_profile, strlen(lprof->lp_profile) + 1);
901 OBD_FREE(lprof->lp_dt, strlen(lprof->lp_dt) + 1);
902 if (lprof->lp_md)
903 OBD_FREE(lprof->lp_md, strlen(lprof->lp_md) + 1);
904 OBD_FREE(lprof, sizeof(*lprof));
905 }
906 }
907 EXPORT_SYMBOL(class_del_profile);
908
909 /* COMPAT_146 */
910 void class_del_profiles(void)
911 {
912 struct lustre_profile *lprof, *n;
913
914 list_for_each_entry_safe(lprof, n, &lustre_profile_list, lp_list) {
915 list_del(&lprof->lp_list);
916 OBD_FREE(lprof->lp_profile, strlen(lprof->lp_profile) + 1);
917 OBD_FREE(lprof->lp_dt, strlen(lprof->lp_dt) + 1);
918 if (lprof->lp_md)
919 OBD_FREE(lprof->lp_md, strlen(lprof->lp_md) + 1);
920 OBD_FREE(lprof, sizeof(*lprof));
921 }
922 }
923 EXPORT_SYMBOL(class_del_profiles);
924
925 static int class_set_global(char *ptr, int val, struct lustre_cfg *lcfg)
926 {
927 if (class_match_param(ptr, PARAM_AT_MIN, NULL) == 0)
928 at_min = val;
929 else if (class_match_param(ptr, PARAM_AT_MAX, NULL) == 0)
930 at_max = val;
931 else if (class_match_param(ptr, PARAM_AT_EXTRA, NULL) == 0)
932 at_extra = val;
933 else if (class_match_param(ptr, PARAM_AT_EARLY_MARGIN, NULL) == 0)
934 at_early_margin = val;
935 else if (class_match_param(ptr, PARAM_AT_HISTORY, NULL) == 0)
936 at_history = val;
937 else if (class_match_param(ptr, PARAM_JOBID_VAR, NULL) == 0)
938 strlcpy(obd_jobid_var, lustre_cfg_string(lcfg, 2),
939 JOBSTATS_JOBID_VAR_MAX_LEN + 1);
940 else
941 return -EINVAL;
942
943 CDEBUG(D_IOCTL, "global %s = %d\n", ptr, val);
944 return 0;
945 }
946
947
948 /* We can't call ll_process_config or lquota_process_config directly because
949 * it lives in a module that must be loaded after this one. */
950 static int (*client_process_config)(struct lustre_cfg *lcfg) = NULL;
951 static int (*quota_process_config)(struct lustre_cfg *lcfg) = NULL;
952
953 void lustre_register_client_process_config(int (*cpc)(struct lustre_cfg *lcfg))
954 {
955 client_process_config = cpc;
956 }
957 EXPORT_SYMBOL(lustre_register_client_process_config);
958
959 /**
960 * Rename the proc parameter in \a cfg with a new name \a new_name.
961 *
962 * \param cfg config structure which contains the proc parameter
963 * \param new_name new name of the proc parameter
964 *
965 * \retval valid-pointer pointer to the newly-allocated config structure
966 * which contains the renamed proc parameter
967 * \retval ERR_PTR(-EINVAL) if \a cfg or \a new_name is NULL, or \a cfg does
968 * not contain a proc parameter
969 * \retval ERR_PTR(-ENOMEM) if memory allocation failure occurs
970 */
971 struct lustre_cfg *lustre_cfg_rename(struct lustre_cfg *cfg,
972 const char *new_name)
973 {
974 struct lustre_cfg_bufs *bufs = NULL;
975 struct lustre_cfg *new_cfg = NULL;
976 char *param = NULL;
977 char *new_param = NULL;
978 char *value = NULL;
979 int name_len = 0;
980 int new_len = 0;
981
982 if (cfg == NULL || new_name == NULL)
983 return ERR_PTR(-EINVAL);
984
985 param = lustre_cfg_string(cfg, 1);
986 if (param == NULL)
987 return ERR_PTR(-EINVAL);
988
989 value = strchr(param, '=');
990 if (value == NULL)
991 name_len = strlen(param);
992 else
993 name_len = value - param;
994
995 new_len = LUSTRE_CFG_BUFLEN(cfg, 1) + strlen(new_name) - name_len;
996
997 OBD_ALLOC(new_param, new_len);
998 if (new_param == NULL)
999 return ERR_PTR(-ENOMEM);
1000
1001 strcpy(new_param, new_name);
1002 if (value != NULL)
1003 strcat(new_param, value);
1004
1005 OBD_ALLOC_PTR(bufs);
1006 if (bufs == NULL) {
1007 OBD_FREE(new_param, new_len);
1008 return ERR_PTR(-ENOMEM);
1009 }
1010
1011 lustre_cfg_bufs_reset(bufs, NULL);
1012 lustre_cfg_bufs_init(bufs, cfg);
1013 lustre_cfg_bufs_set_string(bufs, 1, new_param);
1014
1015 new_cfg = lustre_cfg_new(cfg->lcfg_command, bufs);
1016
1017 OBD_FREE(new_param, new_len);
1018 OBD_FREE_PTR(bufs);
1019 if (new_cfg == NULL)
1020 return ERR_PTR(-ENOMEM);
1021
1022 new_cfg->lcfg_num = cfg->lcfg_num;
1023 new_cfg->lcfg_flags = cfg->lcfg_flags;
1024 new_cfg->lcfg_nid = cfg->lcfg_nid;
1025 new_cfg->lcfg_nal = cfg->lcfg_nal;
1026
1027 return new_cfg;
1028 }
1029 EXPORT_SYMBOL(lustre_cfg_rename);
1030
1031 static int process_param2_config(struct lustre_cfg *lcfg)
1032 {
1033 char *param = lustre_cfg_string(lcfg, 1);
1034 char *upcall = lustre_cfg_string(lcfg, 2);
1035 char *argv[] = {
1036 [0] = "/usr/sbin/lctl",
1037 [1] = "set_param",
1038 [2] = param,
1039 [3] = NULL
1040 };
1041 struct timeval start;
1042 struct timeval end;
1043 int rc;
1044
1045
1046 /* Add upcall processing here. Now only lctl is supported */
1047 if (strcmp(upcall, LCTL_UPCALL) != 0) {
1048 CERROR("Unsupported upcall %s\n", upcall);
1049 return -EINVAL;
1050 }
1051
1052 do_gettimeofday(&start);
1053 rc = USERMODEHELPER(argv[0], argv, NULL);
1054 do_gettimeofday(&end);
1055
1056 if (rc < 0) {
1057 CERROR(
1058 "lctl: error invoking upcall %s %s %s: rc = %d; time %ldus\n",
1059 argv[0], argv[1], argv[2], rc,
1060 cfs_timeval_sub(&end, &start, NULL));
1061 } else {
1062 CDEBUG(D_HA, "lctl: invoked upcall %s %s %s, time %ldus\n",
1063 argv[0], argv[1], argv[2],
1064 cfs_timeval_sub(&end, &start, NULL));
1065 rc = 0;
1066 }
1067
1068 return rc;
1069 }
1070
1071 void lustre_register_quota_process_config(int (*qpc)(struct lustre_cfg *lcfg))
1072 {
1073 quota_process_config = qpc;
1074 }
1075 EXPORT_SYMBOL(lustre_register_quota_process_config);
1076
1077 /** Process configuration commands given in lustre_cfg form.
1078 * These may come from direct calls (e.g. class_manual_cleanup)
1079 * or processing the config llog, or ioctl from lctl.
1080 */
1081 int class_process_config(struct lustre_cfg *lcfg)
1082 {
1083 struct obd_device *obd;
1084 int err;
1085
1086 LASSERT(lcfg && !IS_ERR(lcfg));
1087 CDEBUG(D_IOCTL, "processing cmd: %x\n", lcfg->lcfg_command);
1088
1089 /* Commands that don't need a device */
1090 switch(lcfg->lcfg_command) {
1091 case LCFG_ATTACH: {
1092 err = class_attach(lcfg);
1093 GOTO(out, err);
1094 }
1095 case LCFG_ADD_UUID: {
1096 CDEBUG(D_IOCTL, "adding mapping from uuid %s to nid "LPX64
1097 " (%s)\n", lustre_cfg_string(lcfg, 1),
1098 lcfg->lcfg_nid, libcfs_nid2str(lcfg->lcfg_nid));
1099
1100 err = class_add_uuid(lustre_cfg_string(lcfg, 1), lcfg->lcfg_nid);
1101 GOTO(out, err);
1102 }
1103 case LCFG_DEL_UUID: {
1104 CDEBUG(D_IOCTL, "removing mappings for uuid %s\n",
1105 (lcfg->lcfg_bufcount < 2 || LUSTRE_CFG_BUFLEN(lcfg, 1) == 0)
1106 ? "<all uuids>" : lustre_cfg_string(lcfg, 1));
1107
1108 err = class_del_uuid(lustre_cfg_string(lcfg, 1));
1109 GOTO(out, err);
1110 }
1111 case LCFG_MOUNTOPT: {
1112 CDEBUG(D_IOCTL, "mountopt: profile %s osc %s mdc %s\n",
1113 lustre_cfg_string(lcfg, 1),
1114 lustre_cfg_string(lcfg, 2),
1115 lustre_cfg_string(lcfg, 3));
1116 /* set these mount options somewhere, so ll_fill_super
1117 * can find them. */
1118 err = class_add_profile(LUSTRE_CFG_BUFLEN(lcfg, 1),
1119 lustre_cfg_string(lcfg, 1),
1120 LUSTRE_CFG_BUFLEN(lcfg, 2),
1121 lustre_cfg_string(lcfg, 2),
1122 LUSTRE_CFG_BUFLEN(lcfg, 3),
1123 lustre_cfg_string(lcfg, 3));
1124 GOTO(out, err);
1125 }
1126 case LCFG_DEL_MOUNTOPT: {
1127 CDEBUG(D_IOCTL, "mountopt: profile %s\n",
1128 lustre_cfg_string(lcfg, 1));
1129 class_del_profile(lustre_cfg_string(lcfg, 1));
1130 GOTO(out, err = 0);
1131 }
1132 case LCFG_SET_TIMEOUT: {
1133 CDEBUG(D_IOCTL, "changing lustre timeout from %d to %d\n",
1134 obd_timeout, lcfg->lcfg_num);
1135 obd_timeout = max(lcfg->lcfg_num, 1U);
1136 obd_timeout_set = 1;
1137 GOTO(out, err = 0);
1138 }
1139 case LCFG_SET_LDLM_TIMEOUT: {
1140 CDEBUG(D_IOCTL, "changing lustre ldlm_timeout from %d to %d\n",
1141 ldlm_timeout, lcfg->lcfg_num);
1142 ldlm_timeout = max(lcfg->lcfg_num, 1U);
1143 if (ldlm_timeout >= obd_timeout)
1144 ldlm_timeout = max(obd_timeout / 3, 1U);
1145 ldlm_timeout_set = 1;
1146 GOTO(out, err = 0);
1147 }
1148 case LCFG_SET_UPCALL: {
1149 LCONSOLE_ERROR_MSG(0x15a, "recovery upcall is deprecated\n");
1150 /* COMPAT_146 Don't fail on old configs */
1151 GOTO(out, err = 0);
1152 }
1153 case LCFG_MARKER: {
1154 struct cfg_marker *marker;
1155 marker = lustre_cfg_buf(lcfg, 1);
1156 CDEBUG(D_IOCTL, "marker %d (%#x) %.16s %s\n", marker->cm_step,
1157 marker->cm_flags, marker->cm_tgtname, marker->cm_comment);
1158 GOTO(out, err = 0);
1159 }
1160 case LCFG_PARAM: {
1161 char *tmp;
1162 /* llite has no obd */
1163 if ((class_match_param(lustre_cfg_string(lcfg, 1),
1164 PARAM_LLITE, 0) == 0) &&
1165 client_process_config) {
1166 err = (*client_process_config)(lcfg);
1167 GOTO(out, err);
1168 } else if ((class_match_param(lustre_cfg_string(lcfg, 1),
1169 PARAM_SYS, &tmp) == 0)) {
1170 /* Global param settings */
1171 err = class_set_global(tmp, lcfg->lcfg_num, lcfg);
1172 /*
1173 * Client or server should not fail to mount if
1174 * it hits an unknown configuration parameter.
1175 */
1176 if (err != 0)
1177 CWARN("Ignoring unknown param %s\n", tmp);
1178
1179 GOTO(out, err = 0);
1180 } else if ((class_match_param(lustre_cfg_string(lcfg, 1),
1181 PARAM_QUOTA, &tmp) == 0) &&
1182 quota_process_config) {
1183 err = (*quota_process_config)(lcfg);
1184 GOTO(out, err);
1185 }
1186
1187 break;
1188 }
1189 case LCFG_SET_PARAM: {
1190 err = process_param2_config(lcfg);
1191 GOTO(out, 0);
1192 }
1193 }
1194 /* Commands that require a device */
1195 obd = class_name2obd(lustre_cfg_string(lcfg, 0));
1196 if (obd == NULL) {
1197 if (!LUSTRE_CFG_BUFLEN(lcfg, 0))
1198 CERROR("this lcfg command requires a device name\n");
1199 else
1200 CERROR("no device for: %s\n",
1201 lustre_cfg_string(lcfg, 0));
1202
1203 GOTO(out, err = -EINVAL);
1204 }
1205
1206 switch(lcfg->lcfg_command) {
1207 case LCFG_SETUP: {
1208 err = class_setup(obd, lcfg);
1209 GOTO(out, err);
1210 }
1211 case LCFG_DETACH: {
1212 err = class_detach(obd, lcfg);
1213 GOTO(out, err = 0);
1214 }
1215 case LCFG_CLEANUP: {
1216 err = class_cleanup(obd, lcfg);
1217 GOTO(out, err = 0);
1218 }
1219 case LCFG_ADD_CONN: {
1220 err = class_add_conn(obd, lcfg);
1221 GOTO(out, err = 0);
1222 }
1223 case LCFG_DEL_CONN: {
1224 err = class_del_conn(obd, lcfg);
1225 GOTO(out, err = 0);
1226 }
1227 case LCFG_POOL_NEW: {
1228 err = obd_pool_new(obd, lustre_cfg_string(lcfg, 2));
1229 GOTO(out, err = 0);
1230 break;
1231 }
1232 case LCFG_POOL_ADD: {
1233 err = obd_pool_add(obd, lustre_cfg_string(lcfg, 2),
1234 lustre_cfg_string(lcfg, 3));
1235 GOTO(out, err = 0);
1236 break;
1237 }
1238 case LCFG_POOL_REM: {
1239 err = obd_pool_rem(obd, lustre_cfg_string(lcfg, 2),
1240 lustre_cfg_string(lcfg, 3));
1241 GOTO(out, err = 0);
1242 break;
1243 }
1244 case LCFG_POOL_DEL: {
1245 err = obd_pool_del(obd, lustre_cfg_string(lcfg, 2));
1246 GOTO(out, err = 0);
1247 break;
1248 }
1249 default: {
1250 err = obd_process_config(obd, sizeof(*lcfg), lcfg);
1251 GOTO(out, err);
1252
1253 }
1254 }
1255 out:
1256 if ((err < 0) && !(lcfg->lcfg_command & LCFG_REQUIRED)) {
1257 CWARN("Ignoring error %d on optional command %#x\n", err,
1258 lcfg->lcfg_command);
1259 err = 0;
1260 }
1261 return err;
1262 }
1263 EXPORT_SYMBOL(class_process_config);
1264
1265 int class_process_proc_param(char *prefix, struct lprocfs_vars *lvars,
1266 struct lustre_cfg *lcfg, void *data)
1267 {
1268 struct lprocfs_vars *var;
1269 struct file fakefile;
1270 struct seq_file fake_seqfile;
1271 char *key, *sval;
1272 int i, keylen, vallen;
1273 int matched = 0, j = 0;
1274 int rc = 0;
1275 int skip = 0;
1276
1277 if (lcfg->lcfg_command != LCFG_PARAM) {
1278 CERROR("Unknown command: %d\n", lcfg->lcfg_command);
1279 return -EINVAL;
1280 }
1281
1282 /* fake a seq file so that var->fops->write can work... */
1283 fakefile.private_data = &fake_seqfile;
1284 fake_seqfile.private = data;
1285 /* e.g. tunefs.lustre --param mdt.group_upcall=foo /r/tmp/lustre-mdt
1286 or lctl conf_param lustre-MDT0000.mdt.group_upcall=bar
1287 or lctl conf_param lustre-OST0000.osc.max_dirty_mb=36 */
1288 for (i = 1; i < lcfg->lcfg_bufcount; i++) {
1289 key = lustre_cfg_buf(lcfg, i);
1290 /* Strip off prefix */
1291 class_match_param(key, prefix, &key);
1292 sval = strchr(key, '=');
1293 if (!sval || (*(sval + 1) == 0)) {
1294 CERROR("Can't parse param %s (missing '=')\n", key);
1295 /* rc = -EINVAL; continue parsing other params */
1296 continue;
1297 }
1298 keylen = sval - key;
1299 sval++;
1300 vallen = strlen(sval);
1301 matched = 0;
1302 j = 0;
1303 /* Search proc entries */
1304 while (lvars[j].name) {
1305 var = &lvars[j];
1306 if (class_match_param(key, (char *)var->name, 0) == 0 &&
1307 keylen == strlen(var->name)) {
1308 matched++;
1309 rc = -EROFS;
1310 if (var->fops && var->fops->write) {
1311 mm_segment_t oldfs;
1312 oldfs = get_fs();
1313 set_fs(KERNEL_DS);
1314 rc = (var->fops->write)(&fakefile, sval,
1315 vallen, NULL);
1316 set_fs(oldfs);
1317 }
1318 break;
1319 }
1320 j++;
1321 }
1322 if (!matched) {
1323 /* If the prefix doesn't match, return error so we
1324 can pass it down the stack */
1325 if (strnchr(key, keylen, '.'))
1326 return -ENOSYS;
1327 CERROR("%s: unknown param %s\n",
1328 (char *)lustre_cfg_string(lcfg, 0), key);
1329 /* rc = -EINVAL; continue parsing other params */
1330 skip++;
1331 } else if (rc < 0) {
1332 CERROR("writing proc entry %s err %d\n",
1333 var->name, rc);
1334 rc = 0;
1335 } else {
1336 CDEBUG(D_CONFIG, "%s.%.*s: Set parameter %.*s=%s\n",
1337 lustre_cfg_string(lcfg, 0),
1338 (int)strlen(prefix) - 1, prefix,
1339 (int)(sval - key - 1), key, sval);
1340 }
1341 }
1342
1343 if (rc > 0)
1344 rc = 0;
1345 if (!rc && skip)
1346 rc = skip;
1347 return rc;
1348 }
1349 EXPORT_SYMBOL(class_process_proc_param);
1350
1351 extern int lustre_check_exclusion(struct super_block *sb, char *svname);
1352
1353 /** Parse a configuration llog, doing various manipulations on them
1354 * for various reasons, (modifications for compatibility, skip obsolete
1355 * records, change uuids, etc), then class_process_config() resulting
1356 * net records.
1357 */
1358 int class_config_llog_handler(const struct lu_env *env,
1359 struct llog_handle *handle,
1360 struct llog_rec_hdr *rec, void *data)
1361 {
1362 struct config_llog_instance *clli = data;
1363 int cfg_len = rec->lrh_len;
1364 char *cfg_buf = (char*) (rec + 1);
1365 int rc = 0;
1366
1367 //class_config_dump_handler(handle, rec, data);
1368
1369 switch (rec->lrh_type) {
1370 case OBD_CFG_REC: {
1371 struct lustre_cfg *lcfg, *lcfg_new;
1372 struct lustre_cfg_bufs bufs;
1373 char *inst_name = NULL;
1374 int inst_len = 0;
1375 int inst = 0, swab = 0;
1376
1377 lcfg = (struct lustre_cfg *)cfg_buf;
1378 if (lcfg->lcfg_version == __swab32(LUSTRE_CFG_VERSION)) {
1379 lustre_swab_lustre_cfg(lcfg);
1380 swab = 1;
1381 }
1382
1383 rc = lustre_cfg_sanity_check(cfg_buf, cfg_len);
1384 if (rc)
1385 GOTO(out, rc);
1386
1387 /* Figure out config state info */
1388 if (lcfg->lcfg_command == LCFG_MARKER) {
1389 struct cfg_marker *marker = lustre_cfg_buf(lcfg, 1);
1390 lustre_swab_cfg_marker(marker, swab,
1391 LUSTRE_CFG_BUFLEN(lcfg, 1));
1392 CDEBUG(D_CONFIG, "Marker, inst_flg=%#x mark_flg=%#x\n",
1393 clli->cfg_flags, marker->cm_flags);
1394 if (marker->cm_flags & CM_START) {
1395 /* all previous flags off */
1396 clli->cfg_flags = CFG_F_MARKER;
1397 if (marker->cm_flags & CM_SKIP) {
1398 clli->cfg_flags |= CFG_F_SKIP;
1399 CDEBUG(D_CONFIG, "SKIP #%d\n",
1400 marker->cm_step);
1401 } else if ((marker->cm_flags & CM_EXCLUDE) ||
1402 (clli->cfg_sb &&
1403 lustre_check_exclusion(clli->cfg_sb,
1404 marker->cm_tgtname))) {
1405 clli->cfg_flags |= CFG_F_EXCLUDE;
1406 CDEBUG(D_CONFIG, "EXCLUDE %d\n",
1407 marker->cm_step);
1408 }
1409 } else if (marker->cm_flags & CM_END) {
1410 clli->cfg_flags = 0;
1411 }
1412 }
1413 /* A config command without a start marker before it is
1414 illegal (post 146) */
1415 if (!(clli->cfg_flags & CFG_F_COMPAT146) &&
1416 !(clli->cfg_flags & CFG_F_MARKER) &&
1417 (lcfg->lcfg_command != LCFG_MARKER)) {
1418 CWARN("Config not inside markers, ignoring! "
1419 "(inst: %p, uuid: %s, flags: %#x)\n",
1420 clli->cfg_instance,
1421 clli->cfg_uuid.uuid, clli->cfg_flags);
1422 clli->cfg_flags |= CFG_F_SKIP;
1423 }
1424 if (clli->cfg_flags & CFG_F_SKIP) {
1425 CDEBUG(D_CONFIG, "skipping %#x\n",
1426 clli->cfg_flags);
1427 rc = 0;
1428 /* No processing! */
1429 break;
1430 }
1431
1432 /*
1433 * For interoperability between 1.8 and 2.0,
1434 * rename "mds" obd device type to "mdt".
1435 */
1436 {
1437 char *typename = lustre_cfg_string(lcfg, 1);
1438 char *index = lustre_cfg_string(lcfg, 2);
1439
1440 if ((lcfg->lcfg_command == LCFG_ATTACH && typename &&
1441 strcmp(typename, "mds") == 0)) {
1442 CWARN("For 1.8 interoperability, rename obd "
1443 "type from mds to mdt\n");
1444 typename[2] = 't';
1445 }
1446 if ((lcfg->lcfg_command == LCFG_SETUP && index &&
1447 strcmp(index, "type") == 0)) {
1448 CDEBUG(D_INFO, "For 1.8 interoperability, "
1449 "set this index to '0'\n");
1450 index[0] = '0';
1451 index[1] = 0;
1452 }
1453 }
1454
1455
1456 if (clli->cfg_flags & CFG_F_EXCLUDE) {
1457 CDEBUG(D_CONFIG, "cmd: %x marked EXCLUDED\n",
1458 lcfg->lcfg_command);
1459 if (lcfg->lcfg_command == LCFG_LOV_ADD_OBD)
1460 /* Add inactive instead */
1461 lcfg->lcfg_command = LCFG_LOV_ADD_INA;
1462 }
1463
1464 lustre_cfg_bufs_init(&bufs, lcfg);
1465
1466 if (clli && clli->cfg_instance &&
1467 LUSTRE_CFG_BUFLEN(lcfg, 0) > 0){
1468 inst = 1;
1469 inst_len = LUSTRE_CFG_BUFLEN(lcfg, 0) +
1470 sizeof(clli->cfg_instance) * 2 + 4;
1471 OBD_ALLOC(inst_name, inst_len);
1472 if (inst_name == NULL)
1473 GOTO(out, rc = -ENOMEM);
1474 sprintf(inst_name, "%s-%p",
1475 lustre_cfg_string(lcfg, 0),
1476 clli->cfg_instance);
1477 lustre_cfg_bufs_set_string(&bufs, 0, inst_name);
1478 CDEBUG(D_CONFIG, "cmd %x, instance name: %s\n",
1479 lcfg->lcfg_command, inst_name);
1480 }
1481
1482 /* we override the llog's uuid for clients, to insure they
1483 are unique */
1484 if (clli && clli->cfg_instance != NULL &&
1485 lcfg->lcfg_command == LCFG_ATTACH) {
1486 lustre_cfg_bufs_set_string(&bufs, 2,
1487 clli->cfg_uuid.uuid);
1488 }
1489 /*
1490 * sptlrpc config record, we expect 2 data segments:
1491 * [0]: fs_name/target_name,
1492 * [1]: rule string
1493 * moving them to index [1] and [2], and insert MGC's
1494 * obdname at index [0].
1495 */
1496 if (clli && clli->cfg_instance == NULL &&
1497 lcfg->lcfg_command == LCFG_SPTLRPC_CONF) {
1498 lustre_cfg_bufs_set(&bufs, 2, bufs.lcfg_buf[1],
1499 bufs.lcfg_buflen[1]);
1500 lustre_cfg_bufs_set(&bufs, 1, bufs.lcfg_buf[0],
1501 bufs.lcfg_buflen[0]);
1502 lustre_cfg_bufs_set_string(&bufs, 0,
1503 clli->cfg_obdname);
1504 }
1505
1506 lcfg_new = lustre_cfg_new(lcfg->lcfg_command, &bufs);
1507
1508 lcfg_new->lcfg_num = lcfg->lcfg_num;
1509 lcfg_new->lcfg_flags = lcfg->lcfg_flags;
1510
1511 /* XXX Hack to try to remain binary compatible with
1512 * pre-newconfig logs */
1513 if (lcfg->lcfg_nal != 0 && /* pre-newconfig log? */
1514 (lcfg->lcfg_nid >> 32) == 0) {
1515 __u32 addr = (__u32)(lcfg->lcfg_nid & 0xffffffff);
1516
1517 lcfg_new->lcfg_nid =
1518 LNET_MKNID(LNET_MKNET(lcfg->lcfg_nal, 0), addr);
1519 CWARN("Converted pre-newconfig NAL %d NID %x to %s\n",
1520 lcfg->lcfg_nal, addr,
1521 libcfs_nid2str(lcfg_new->lcfg_nid));
1522 } else {
1523 lcfg_new->lcfg_nid = lcfg->lcfg_nid;
1524 }
1525
1526 lcfg_new->lcfg_nal = 0; /* illegal value for obsolete field */
1527
1528 rc = class_process_config(lcfg_new);
1529 lustre_cfg_free(lcfg_new);
1530
1531 if (inst)
1532 OBD_FREE(inst_name, inst_len);
1533 break;
1534 }
1535 default:
1536 CERROR("Unknown llog record type %#x encountered\n",
1537 rec->lrh_type);
1538 break;
1539 }
1540 out:
1541 if (rc) {
1542 CERROR("%s: cfg command failed: rc = %d\n",
1543 handle->lgh_ctxt->loc_obd->obd_name, rc);
1544 class_config_dump_handler(NULL, handle, rec, data);
1545 }
1546 return rc;
1547 }
1548 EXPORT_SYMBOL(class_config_llog_handler);
1549
1550 int class_config_parse_llog(const struct lu_env *env, struct llog_ctxt *ctxt,
1551 char *name, struct config_llog_instance *cfg)
1552 {
1553 struct llog_process_cat_data cd = {0, 0};
1554 struct llog_handle *llh;
1555 llog_cb_t callback;
1556 int rc;
1557
1558 CDEBUG(D_INFO, "looking up llog %s\n", name);
1559 rc = llog_open(env, ctxt, &llh, NULL, name, LLOG_OPEN_EXISTS);
1560 if (rc)
1561 return rc;
1562
1563 rc = llog_init_handle(env, llh, LLOG_F_IS_PLAIN, NULL);
1564 if (rc)
1565 GOTO(parse_out, rc);
1566
1567 /* continue processing from where we last stopped to end-of-log */
1568 if (cfg) {
1569 cd.lpcd_first_idx = cfg->cfg_last_idx;
1570 callback = cfg->cfg_callback;
1571 LASSERT(callback != NULL);
1572 } else {
1573 callback = class_config_llog_handler;
1574 }
1575
1576 cd.lpcd_last_idx = 0;
1577
1578 rc = llog_process(env, llh, callback, cfg, &cd);
1579
1580 CDEBUG(D_CONFIG, "Processed log %s gen %d-%d (rc=%d)\n", name,
1581 cd.lpcd_first_idx + 1, cd.lpcd_last_idx, rc);
1582 if (cfg)
1583 cfg->cfg_last_idx = cd.lpcd_last_idx;
1584
1585 parse_out:
1586 llog_close(env, llh);
1587 return rc;
1588 }
1589 EXPORT_SYMBOL(class_config_parse_llog);
1590
1591 /**
1592 * parse config record and output dump in supplied buffer.
1593 * This is separated from class_config_dump_handler() to use
1594 * for ioctl needs as well
1595 */
1596 int class_config_parse_rec(struct llog_rec_hdr *rec, char *buf, int size)
1597 {
1598 struct lustre_cfg *lcfg = (struct lustre_cfg *)(rec + 1);
1599 char *ptr = buf;
1600 char *end = buf + size;
1601 int rc = 0;
1602
1603 LASSERT(rec->lrh_type == OBD_CFG_REC);
1604 rc = lustre_cfg_sanity_check(lcfg, rec->lrh_len);
1605 if (rc < 0)
1606 return rc;
1607
1608 ptr += snprintf(ptr, end-ptr, "cmd=%05x ", lcfg->lcfg_command);
1609 if (lcfg->lcfg_flags)
1610 ptr += snprintf(ptr, end-ptr, "flags=%#08x ",
1611 lcfg->lcfg_flags);
1612
1613 if (lcfg->lcfg_num)
1614 ptr += snprintf(ptr, end-ptr, "num=%#08x ", lcfg->lcfg_num);
1615
1616 if (lcfg->lcfg_nid)
1617 ptr += snprintf(ptr, end-ptr, "nid=%s("LPX64")\n ",
1618 libcfs_nid2str(lcfg->lcfg_nid),
1619 lcfg->lcfg_nid);
1620
1621 if (lcfg->lcfg_command == LCFG_MARKER) {
1622 struct cfg_marker *marker = lustre_cfg_buf(lcfg, 1);
1623
1624 ptr += snprintf(ptr, end-ptr, "marker=%d(%#x)%s '%s'",
1625 marker->cm_step, marker->cm_flags,
1626 marker->cm_tgtname, marker->cm_comment);
1627 } else {
1628 int i;
1629
1630 for (i = 0; i < lcfg->lcfg_bufcount; i++) {
1631 ptr += snprintf(ptr, end-ptr, "%d:%s ", i,
1632 lustre_cfg_string(lcfg, i));
1633 }
1634 }
1635 /* return consumed bytes */
1636 rc = ptr - buf;
1637 return rc;
1638 }
1639
1640 int class_config_dump_handler(const struct lu_env *env,
1641 struct llog_handle *handle,
1642 struct llog_rec_hdr *rec, void *data)
1643 {
1644 char *outstr;
1645 int rc = 0;
1646
1647 OBD_ALLOC(outstr, 256);
1648 if (outstr == NULL)
1649 return -ENOMEM;
1650
1651 if (rec->lrh_type == OBD_CFG_REC) {
1652 class_config_parse_rec(rec, outstr, 256);
1653 LCONSOLE(D_WARNING, " %s\n", outstr);
1654 } else {
1655 LCONSOLE(D_WARNING, "unhandled lrh_type: %#x\n", rec->lrh_type);
1656 rc = -EINVAL;
1657 }
1658
1659 OBD_FREE(outstr, 256);
1660 return rc;
1661 }
1662
1663 int class_config_dump_llog(const struct lu_env *env, struct llog_ctxt *ctxt,
1664 char *name, struct config_llog_instance *cfg)
1665 {
1666 struct llog_handle *llh;
1667 int rc;
1668
1669 LCONSOLE_INFO("Dumping config log %s\n", name);
1670
1671 rc = llog_open(env, ctxt, &llh, NULL, name, LLOG_OPEN_EXISTS);
1672 if (rc)
1673 return rc;
1674
1675 rc = llog_init_handle(env, llh, LLOG_F_IS_PLAIN, NULL);
1676 if (rc)
1677 GOTO(parse_out, rc);
1678
1679 rc = llog_process(env, llh, class_config_dump_handler, cfg, NULL);
1680 parse_out:
1681 llog_close(env, llh);
1682
1683 LCONSOLE_INFO("End config log %s\n", name);
1684 return rc;
1685 }
1686 EXPORT_SYMBOL(class_config_dump_llog);
1687
1688 /** Call class_cleanup and class_detach.
1689 * "Manual" only in the sense that we're faking lcfg commands.
1690 */
1691 int class_manual_cleanup(struct obd_device *obd)
1692 {
1693 char flags[3] = "";
1694 struct lustre_cfg *lcfg;
1695 struct lustre_cfg_bufs bufs;
1696 int rc;
1697
1698 if (!obd) {
1699 CERROR("empty cleanup\n");
1700 return -EALREADY;
1701 }
1702
1703 if (obd->obd_force)
1704 strcat(flags, "F");
1705 if (obd->obd_fail)
1706 strcat(flags, "A");
1707
1708 CDEBUG(D_CONFIG, "Manual cleanup of %s (flags='%s')\n",
1709 obd->obd_name, flags);
1710
1711 lustre_cfg_bufs_reset(&bufs, obd->obd_name);
1712 lustre_cfg_bufs_set_string(&bufs, 1, flags);
1713 lcfg = lustre_cfg_new(LCFG_CLEANUP, &bufs);
1714 if (!lcfg)
1715 return -ENOMEM;
1716
1717 rc = class_process_config(lcfg);
1718 if (rc) {
1719 CERROR("cleanup failed %d: %s\n", rc, obd->obd_name);
1720 GOTO(out, rc);
1721 }
1722
1723 /* the lcfg is almost the same for both ops */
1724 lcfg->lcfg_command = LCFG_DETACH;
1725 rc = class_process_config(lcfg);
1726 if (rc)
1727 CERROR("detach failed %d: %s\n", rc, obd->obd_name);
1728 out:
1729 lustre_cfg_free(lcfg);
1730 return rc;
1731 }
1732 EXPORT_SYMBOL(class_manual_cleanup);
1733
1734 /*
1735 * uuid<->export lustre hash operations
1736 */
1737
1738 static unsigned
1739 uuid_hash(struct cfs_hash *hs, const void *key, unsigned mask)
1740 {
1741 return cfs_hash_djb2_hash(((struct obd_uuid *)key)->uuid,
1742 sizeof(((struct obd_uuid *)key)->uuid), mask);
1743 }
1744
1745 static void *
1746 uuid_key(struct hlist_node *hnode)
1747 {
1748 struct obd_export *exp;
1749
1750 exp = hlist_entry(hnode, struct obd_export, exp_uuid_hash);
1751
1752 return &exp->exp_client_uuid;
1753 }
1754
1755 /*
1756 * NOTE: It is impossible to find an export that is in failed
1757 * state with this function
1758 */
1759 static int
1760 uuid_keycmp(const void *key, struct hlist_node *hnode)
1761 {
1762 struct obd_export *exp;
1763
1764 LASSERT(key);
1765 exp = hlist_entry(hnode, struct obd_export, exp_uuid_hash);
1766
1767 return obd_uuid_equals(key, &exp->exp_client_uuid) &&
1768 !exp->exp_failed;
1769 }
1770
1771 static void *
1772 uuid_export_object(struct hlist_node *hnode)
1773 {
1774 return hlist_entry(hnode, struct obd_export, exp_uuid_hash);
1775 }
1776
1777 static void
1778 uuid_export_get(struct cfs_hash *hs, struct hlist_node *hnode)
1779 {
1780 struct obd_export *exp;
1781
1782 exp = hlist_entry(hnode, struct obd_export, exp_uuid_hash);
1783 class_export_get(exp);
1784 }
1785
1786 static void
1787 uuid_export_put_locked(struct cfs_hash *hs, struct hlist_node *hnode)
1788 {
1789 struct obd_export *exp;
1790
1791 exp = hlist_entry(hnode, struct obd_export, exp_uuid_hash);
1792 class_export_put(exp);
1793 }
1794
1795 static cfs_hash_ops_t uuid_hash_ops = {
1796 .hs_hash = uuid_hash,
1797 .hs_key = uuid_key,
1798 .hs_keycmp = uuid_keycmp,
1799 .hs_object = uuid_export_object,
1800 .hs_get = uuid_export_get,
1801 .hs_put_locked = uuid_export_put_locked,
1802 };
1803
1804
1805 /*
1806 * nid<->export hash operations
1807 */
1808
1809 static unsigned
1810 nid_hash(struct cfs_hash *hs, const void *key, unsigned mask)
1811 {
1812 return cfs_hash_djb2_hash(key, sizeof(lnet_nid_t), mask);
1813 }
1814
1815 static void *
1816 nid_key(struct hlist_node *hnode)
1817 {
1818 struct obd_export *exp;
1819
1820 exp = hlist_entry(hnode, struct obd_export, exp_nid_hash);
1821
1822 return &exp->exp_connection->c_peer.nid;
1823 }
1824
1825 /*
1826 * NOTE: It is impossible to find an export that is in failed
1827 * state with this function
1828 */
1829 static int
1830 nid_kepcmp(const void *key, struct hlist_node *hnode)
1831 {
1832 struct obd_export *exp;
1833
1834 LASSERT(key);
1835 exp = hlist_entry(hnode, struct obd_export, exp_nid_hash);
1836
1837 return exp->exp_connection->c_peer.nid == *(lnet_nid_t *)key &&
1838 !exp->exp_failed;
1839 }
1840
1841 static void *
1842 nid_export_object(struct hlist_node *hnode)
1843 {
1844 return hlist_entry(hnode, struct obd_export, exp_nid_hash);
1845 }
1846
1847 static void
1848 nid_export_get(struct cfs_hash *hs, struct hlist_node *hnode)
1849 {
1850 struct obd_export *exp;
1851
1852 exp = hlist_entry(hnode, struct obd_export, exp_nid_hash);
1853 class_export_get(exp);
1854 }
1855
1856 static void
1857 nid_export_put_locked(struct cfs_hash *hs, struct hlist_node *hnode)
1858 {
1859 struct obd_export *exp;
1860
1861 exp = hlist_entry(hnode, struct obd_export, exp_nid_hash);
1862 class_export_put(exp);
1863 }
1864
1865 static cfs_hash_ops_t nid_hash_ops = {
1866 .hs_hash = nid_hash,
1867 .hs_key = nid_key,
1868 .hs_keycmp = nid_kepcmp,
1869 .hs_object = nid_export_object,
1870 .hs_get = nid_export_get,
1871 .hs_put_locked = nid_export_put_locked,
1872 };
1873
1874
1875 /*
1876 * nid<->nidstats hash operations
1877 */
1878
1879 static void *
1880 nidstats_key(struct hlist_node *hnode)
1881 {
1882 struct nid_stat *ns;
1883
1884 ns = hlist_entry(hnode, struct nid_stat, nid_hash);
1885
1886 return &ns->nid;
1887 }
1888
1889 static int
1890 nidstats_keycmp(const void *key, struct hlist_node *hnode)
1891 {
1892 return *(lnet_nid_t *)nidstats_key(hnode) == *(lnet_nid_t *)key;
1893 }
1894
1895 static void *
1896 nidstats_object(struct hlist_node *hnode)
1897 {
1898 return hlist_entry(hnode, struct nid_stat, nid_hash);
1899 }
1900
1901 static void
1902 nidstats_get(struct cfs_hash *hs, struct hlist_node *hnode)
1903 {
1904 struct nid_stat *ns;
1905
1906 ns = hlist_entry(hnode, struct nid_stat, nid_hash);
1907 nidstat_getref(ns);
1908 }
1909
1910 static void
1911 nidstats_put_locked(struct cfs_hash *hs, struct hlist_node *hnode)
1912 {
1913 struct nid_stat *ns;
1914
1915 ns = hlist_entry(hnode, struct nid_stat, nid_hash);
1916 nidstat_putref(ns);
1917 }
1918
1919 static cfs_hash_ops_t nid_stat_hash_ops = {
1920 .hs_hash = nid_hash,
1921 .hs_key = nidstats_key,
1922 .hs_keycmp = nidstats_keycmp,
1923 .hs_object = nidstats_object,
1924 .hs_get = nidstats_get,
1925 .hs_put_locked = nidstats_put_locked,
1926 };
Ubuntu Artful kernel mirror