1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2 * vim:expandtab:shiftwidth=8:tabstop=8:
6 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 only,
10 * as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License version 2 for more details (a copy is included
16 * in the LICENSE file that accompanied this code).
18 * You should have received a copy of the GNU General Public License
19 * version 2 along with this program; If not, see
20 * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
22 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
23 * CA 95054 USA or visit www.sun.com if you need additional information or
29 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
30 * Use is subject to license terms.
32 * Copyright (c) 2011, Whamcloud, Inc.
35 * This file is part of Lustre, http://www.lustre.org/
36 * Lustre is a trademark of Sun Microsystems, Inc.
38 * lustre/mgs/mgs_llog.c
40 * Lustre Management Server (mgs) config llog creation
42 * Author: Nathan Rutman <nathan@clusterfs.com>
48 #define DEBUG_SUBSYSTEM S_MGS
49 #define D_MGS D_CONFIG
52 #include <linux/module.h>
53 #include <linux/pagemap.h>
59 #include <obd_class.h>
60 #include <lustre_log.h>
62 #include <libcfs/list.h>
63 #include <linux/lvfs.h>
64 #include <lustre_fsfilt.h>
65 #include <lustre_disk.h>
66 #include <lustre_param.h>
67 #include <lustre_sec.h>
68 #include "mgs_internal.h"
70 /********************** Class functions ********************/
72 /* Caller must list_del and OBD_FREE each dentry from the list */
73 int class_dentry_readdir(struct obd_device *obd, struct dentry *dir,
74 struct vfsmount *inmnt,
75 cfs_list_t *dentry_list){
76 /* see mds_cleanup_pending */
77 struct lvfs_run_ctxt saved;
79 struct dentry *dentry;
84 push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
87 GOTO(out_pop, rc = PTR_ERR(dentry));
91 GOTO(out_pop, rc = PTR_ERR(mnt));
94 file = ll_dentry_open(dentry, mnt, O_RDONLY, current_cred());
96 /* dentry_open_it() drops the dentry, mnt refs */
97 GOTO(out_pop, rc = PTR_ERR(file));
99 CFS_INIT_LIST_HEAD(dentry_list);
100 rc = l_readdir(file, dentry_list);
102 /* filp_close->fput() drops the dentry, mnt refs */
105 pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
109 /******************** DB functions *********************/
111 static inline int name_create(char **newname, char *prefix, char *suffix)
114 OBD_ALLOC(*newname, strlen(prefix) + strlen(suffix) + 1);
117 sprintf(*newname, "%s%s", prefix, suffix);
121 static inline void name_destroy(char **name)
124 OBD_FREE(*name, strlen(*name) + 1);
128 struct mgs_fsdb_handler_data
134 /* from the (client) config log, figure out:
135 1. which ost's/mdt's are configured (by index)
136 2. what the last config step is
137 3. COMPAT_146 lov name
138 4. COMPAT_146 mdt lov name
139 5. COMPAT_146 mdc name
140 6. COMPAT_18 osc name
142 /* It might be better to have a separate db file, instead of parsing the info
143 out of the client log. This is slow and potentially error-prone. */
144 static int mgs_fsdb_handler(struct llog_handle *llh, struct llog_rec_hdr *rec,
147 struct mgs_fsdb_handler_data *d = (struct mgs_fsdb_handler_data *) data;
148 struct fs_db *fsdb = d->fsdb;
149 int cfg_len = rec->lrh_len;
150 char *cfg_buf = (char*) (rec + 1);
151 struct lustre_cfg *lcfg;
156 if (rec->lrh_type != OBD_CFG_REC) {
157 CERROR("unhandled lrh_type: %#x\n", rec->lrh_type);
161 rc = lustre_cfg_sanity_check(cfg_buf, cfg_len);
163 CERROR("Insane cfg\n");
167 lcfg = (struct lustre_cfg *)cfg_buf;
169 CDEBUG(D_INFO, "cmd %x %s %s\n", lcfg->lcfg_command,
170 lustre_cfg_string(lcfg, 0), lustre_cfg_string(lcfg, 1));
172 /* Figure out ost indicies */
173 /* lov_modify_tgts add 0:lov1 1:ost1_UUID 2(index):0 3(gen):1 */
174 if (lcfg->lcfg_command == LCFG_LOV_ADD_OBD ||
175 lcfg->lcfg_command == LCFG_LOV_DEL_OBD) {
176 index = simple_strtoul(lustre_cfg_string(lcfg, 2),
178 CDEBUG(D_MGS, "OST index for %s is %u (%s)\n",
179 lustre_cfg_string(lcfg, 1), index,
180 lustre_cfg_string(lcfg, 2));
181 cfs_set_bit(index, fsdb->fsdb_ost_index_map);
184 /* Figure out mdt indicies */
185 /* attach 0:MDC_uml1_mdsA_MNT_client 1:mdc 2:1d834_MNT_client_03f */
186 if ((lcfg->lcfg_command == LCFG_ATTACH) &&
187 (strcmp(lustre_cfg_string(lcfg, 1), LUSTRE_MDC_NAME) == 0)) {
188 rc = server_name2index(lustre_cfg_string(lcfg, 0),
190 if (rc != LDD_F_SV_TYPE_MDT) {
191 CWARN("Unparsable MDC name %s, assuming index 0\n",
192 lustre_cfg_string(lcfg, 0));
196 CDEBUG(D_MGS, "MDT index is %u\n", index);
197 cfs_set_bit(index, fsdb->fsdb_mdt_index_map);
198 fsdb->fsdb_mdt_count ++;
202 /* figure out the old LOV name. fsdb_gen = 0 means old log */
203 /* #01 L attach 0:lov_mdsA 1:lov 2:cdbe9_lov_mdsA_dc8cf7f3bb */
204 if ((fsdb->fsdb_gen == 0) && (lcfg->lcfg_command == LCFG_ATTACH) &&
205 (strcmp(lustre_cfg_string(lcfg, 1), LUSTRE_LOV_NAME) == 0)) {
206 cfs_set_bit(FSDB_OLDLOG14, &fsdb->fsdb_flags);
207 name_destroy(&fsdb->fsdb_clilov);
208 rc = name_create(&fsdb->fsdb_clilov,
209 lustre_cfg_string(lcfg, 0), "");
212 CDEBUG(D_MGS, "client lov name is %s\n", fsdb->fsdb_clilov);
215 /* figure out the old MDT lov name from the MDT uuid */
216 if ((fsdb->fsdb_gen == 0) && (lcfg->lcfg_command == LCFG_SETUP) &&
217 (strncmp(lustre_cfg_string(lcfg, 0), "MDC_", 4) == 0)) {
219 cfs_set_bit(FSDB_OLDLOG14, &fsdb->fsdb_flags);
220 ptr = strstr(lustre_cfg_string(lcfg, 1), "_UUID");
222 CERROR("Can't parse MDT uuid %s\n",
223 lustre_cfg_string(lcfg, 1));
227 name_destroy(&fsdb->fsdb_mdtlov);
228 rc = name_create(&fsdb->fsdb_mdtlov,
229 "lov_", lustre_cfg_string(lcfg, 1));
232 name_destroy(&fsdb->fsdb_mdc);
233 rc = name_create(&fsdb->fsdb_mdc,
234 lustre_cfg_string(lcfg, 0), "");
237 CDEBUG(D_MGS, "MDT lov name is %s\n", fsdb->fsdb_mdtlov);
242 * compat to 1.8, check osc name used by MDT0 to OSTs, bz18548.
244 if (!cfs_test_bit(FSDB_OSCNAME18, &fsdb->fsdb_flags) &&
245 lcfg->lcfg_command == LCFG_ATTACH &&
246 strcmp(lustre_cfg_string(lcfg, 1), LUSTRE_OSC_NAME) == 0) {
247 if (OBD_OCD_VERSION_MAJOR(d->ver) == 1 &&
248 OBD_OCD_VERSION_MINOR(d->ver) <= 8) {
249 CWARN("MDT using 1.8 OSC name scheme\n");
250 cfs_set_bit(FSDB_OSCNAME18, &fsdb->fsdb_flags);
254 if (lcfg->lcfg_command == LCFG_MARKER) {
255 struct cfg_marker *marker;
256 marker = lustre_cfg_buf(lcfg, 1);
258 d->ver = marker->cm_vers;
260 /* Keep track of the latest marker step */
261 fsdb->fsdb_gen = max(fsdb->fsdb_gen, marker->cm_step);
267 /* fsdb->fsdb_mutex is already held in mgs_find_or_make_fsdb*/
268 static int mgs_get_fsdb_from_llog(struct obd_device *obd, struct fs_db *fsdb)
271 struct llog_handle *loghandle;
272 struct lvfs_run_ctxt saved;
273 struct llog_ctxt *ctxt;
274 struct mgs_fsdb_handler_data d = { fsdb, 0 };
278 ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT);
279 LASSERT(ctxt != NULL);
280 name_create(&logname, fsdb->fsdb_name, "-client");
281 cfs_mutex_lock(&fsdb->fsdb_mutex);
282 push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
283 rc = llog_create(ctxt, &loghandle, NULL, logname);
287 rc = llog_init_handle(loghandle, LLOG_F_IS_PLAIN, NULL);
291 if (llog_get_size(loghandle) <= 1)
292 cfs_set_bit(FSDB_LOG_EMPTY, &fsdb->fsdb_flags);
294 rc = llog_process(loghandle, mgs_fsdb_handler, (void *) &d, NULL);
295 CDEBUG(D_INFO, "get_db = %d\n", rc);
297 rc2 = llog_close(loghandle);
301 pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
302 cfs_mutex_unlock(&fsdb->fsdb_mutex);
303 name_destroy(&logname);
309 static void mgs_free_fsdb_srpc(struct fs_db *fsdb)
311 struct mgs_tgt_srpc_conf *tgtconf;
313 /* free target-specific rules */
314 while (fsdb->fsdb_srpc_tgt) {
315 tgtconf = fsdb->fsdb_srpc_tgt;
316 fsdb->fsdb_srpc_tgt = tgtconf->mtsc_next;
318 LASSERT(tgtconf->mtsc_tgt);
320 sptlrpc_rule_set_free(&tgtconf->mtsc_rset);
321 OBD_FREE(tgtconf->mtsc_tgt, strlen(tgtconf->mtsc_tgt) + 1);
322 OBD_FREE_PTR(tgtconf);
325 /* free general rules */
326 sptlrpc_rule_set_free(&fsdb->fsdb_srpc_gen);
329 struct fs_db *mgs_find_fsdb(struct obd_device *obd, char *fsname)
331 struct mgs_obd *mgs = &obd->u.mgs;
335 cfs_list_for_each(tmp, &mgs->mgs_fs_db_list) {
336 fsdb = cfs_list_entry(tmp, struct fs_db, fsdb_list);
337 if (strcmp(fsdb->fsdb_name, fsname) == 0)
343 /* caller must hold the mgs->mgs_fs_db_lock */
344 static struct fs_db *mgs_new_fsdb(struct obd_device *obd, char *fsname)
346 struct mgs_obd *mgs = &obd->u.mgs;
351 if (strlen(fsname) >= sizeof(fsdb->fsdb_name)) {
352 CERROR("fsname %s is too long\n", fsname);
360 strcpy(fsdb->fsdb_name, fsname);
361 cfs_mutex_init(&fsdb->fsdb_mutex);
362 cfs_set_bit(FSDB_UDESC, &fsdb->fsdb_flags);
364 if (strcmp(fsname, MGSSELF_NAME) == 0) {
365 cfs_set_bit(FSDB_MGS_SELF, &fsdb->fsdb_flags);
367 OBD_ALLOC(fsdb->fsdb_ost_index_map, INDEX_MAP_SIZE);
368 OBD_ALLOC(fsdb->fsdb_mdt_index_map, INDEX_MAP_SIZE);
369 if (!fsdb->fsdb_ost_index_map || !fsdb->fsdb_mdt_index_map) {
370 CERROR("No memory for index maps\n");
374 rc = name_create(&fsdb->fsdb_mdtlov, fsname, "-mdtlov");
377 rc = name_create(&fsdb->fsdb_mdtlmv, fsname, "-mdtlmv");
380 rc = name_create(&fsdb->fsdb_clilov, fsname, "-clilov");
383 rc = name_create(&fsdb->fsdb_clilmv, fsname, "-clilmv");
387 /* initialise data for NID table */
388 mgs_ir_init_fs(obd, fsdb);
390 lproc_mgs_add_live(obd, fsdb);
393 cfs_list_add(&fsdb->fsdb_list, &mgs->mgs_fs_db_list);
397 if (fsdb->fsdb_ost_index_map)
398 OBD_FREE(fsdb->fsdb_ost_index_map, INDEX_MAP_SIZE);
399 if (fsdb->fsdb_mdt_index_map)
400 OBD_FREE(fsdb->fsdb_mdt_index_map, INDEX_MAP_SIZE);
401 name_destroy(&fsdb->fsdb_clilov);
402 name_destroy(&fsdb->fsdb_clilmv);
403 name_destroy(&fsdb->fsdb_mdtlov);
404 name_destroy(&fsdb->fsdb_mdtlmv);
409 static void mgs_free_fsdb(struct obd_device *obd, struct fs_db *fsdb)
411 /* wait for anyone with the sem */
412 cfs_mutex_lock(&fsdb->fsdb_mutex);
413 lproc_mgs_del_live(obd, fsdb);
414 cfs_list_del(&fsdb->fsdb_list);
416 /* deinitialize fsr */
417 mgs_ir_fini_fs(obd, fsdb);
419 if (fsdb->fsdb_ost_index_map)
420 OBD_FREE(fsdb->fsdb_ost_index_map, INDEX_MAP_SIZE);
421 if (fsdb->fsdb_mdt_index_map)
422 OBD_FREE(fsdb->fsdb_mdt_index_map, INDEX_MAP_SIZE);
423 name_destroy(&fsdb->fsdb_clilov);
424 name_destroy(&fsdb->fsdb_clilmv);
425 name_destroy(&fsdb->fsdb_mdtlov);
426 name_destroy(&fsdb->fsdb_mdtlmv);
427 name_destroy(&fsdb->fsdb_mdc);
428 mgs_free_fsdb_srpc(fsdb);
429 cfs_mutex_unlock(&fsdb->fsdb_mutex);
433 int mgs_init_fsdb_list(struct obd_device *obd)
435 struct mgs_obd *mgs = &obd->u.mgs;
436 CFS_INIT_LIST_HEAD(&mgs->mgs_fs_db_list);
440 int mgs_cleanup_fsdb_list(struct obd_device *obd)
442 struct mgs_obd *mgs = &obd->u.mgs;
444 cfs_list_t *tmp, *tmp2;
445 cfs_mutex_lock(&mgs->mgs_mutex);
446 cfs_list_for_each_safe(tmp, tmp2, &mgs->mgs_fs_db_list) {
447 fsdb = cfs_list_entry(tmp, struct fs_db, fsdb_list);
448 mgs_free_fsdb(obd, fsdb);
450 cfs_mutex_unlock(&mgs->mgs_mutex);
454 int mgs_find_or_make_fsdb(struct obd_device *obd, char *name,
457 struct mgs_obd *mgs = &obd->u.mgs;
461 cfs_mutex_lock(&mgs->mgs_mutex);
462 fsdb = mgs_find_fsdb(obd, name);
464 cfs_mutex_unlock(&mgs->mgs_mutex);
469 CDEBUG(D_MGS, "Creating new db\n");
470 fsdb = mgs_new_fsdb(obd, name);
471 cfs_mutex_unlock(&mgs->mgs_mutex);
475 if (!cfs_test_bit(FSDB_MGS_SELF, &fsdb->fsdb_flags)) {
476 /* populate the db from the client llog */
477 rc = mgs_get_fsdb_from_llog(obd, fsdb);
479 CERROR("Can't get db from client log %d\n", rc);
480 mgs_free_fsdb(obd, fsdb);
485 /* populate srpc rules from params llog */
486 rc = mgs_get_fsdb_srpc_from_llog(obd, fsdb);
488 CERROR("Can't get db from params log %d\n", rc);
489 mgs_free_fsdb(obd, fsdb);
500 -1= empty client log */
501 int mgs_check_index(struct obd_device *obd, struct mgs_target_info *mti)
508 LASSERT(!(mti->mti_flags & LDD_F_NEED_INDEX));
510 rc = mgs_find_or_make_fsdb(obd, mti->mti_fsname, &fsdb);
512 CERROR("Can't get db for %s\n", mti->mti_fsname);
516 if (cfs_test_bit(FSDB_LOG_EMPTY, &fsdb->fsdb_flags))
519 if (mti->mti_flags & LDD_F_SV_TYPE_OST)
520 imap = fsdb->fsdb_ost_index_map;
521 else if (mti->mti_flags & LDD_F_SV_TYPE_MDT)
522 imap = fsdb->fsdb_mdt_index_map;
526 if (cfs_test_bit(mti->mti_stripe_index, imap))
531 static __inline__ int next_index(void *index_map, int map_len)
534 for (i = 0; i < map_len * 8; i++)
535 if (!cfs_test_bit(i, index_map)) {
538 CERROR("max index %d exceeded.\n", i);
543 0 newly marked as in use
545 +EALREADY for update of an old index */
546 static int mgs_set_index(struct obd_device *obd, struct mgs_target_info *mti)
553 rc = mgs_find_or_make_fsdb(obd, mti->mti_fsname, &fsdb);
555 CERROR("Can't get db for %s\n", mti->mti_fsname);
559 if (mti->mti_flags & LDD_F_SV_TYPE_OST) {
560 imap = fsdb->fsdb_ost_index_map;
561 } else if (mti->mti_flags & LDD_F_SV_TYPE_MDT) {
562 imap = fsdb->fsdb_mdt_index_map;
563 if (fsdb->fsdb_mdt_count >= MAX_MDT_COUNT) {
564 LCONSOLE_ERROR_MSG(0x13f, "The max mdt count"
565 "is %d\n", (int)MAX_MDT_COUNT);
572 if (mti->mti_flags & LDD_F_NEED_INDEX) {
573 rc = next_index(imap, INDEX_MAP_SIZE);
576 mti->mti_stripe_index = rc;
577 if (mti->mti_flags & LDD_F_SV_TYPE_MDT)
578 fsdb->fsdb_mdt_count ++;
581 if (mti->mti_stripe_index >= INDEX_MAP_SIZE * 8) {
582 LCONSOLE_ERROR_MSG(0x13f, "Server %s requested index %d, "
583 "but the max index is %d.\n",
584 mti->mti_svname, mti->mti_stripe_index,
589 if (cfs_test_bit(mti->mti_stripe_index, imap)) {
590 if ((mti->mti_flags & LDD_F_VIRGIN) &&
591 !(mti->mti_flags & LDD_F_WRITECONF)) {
592 LCONSOLE_ERROR_MSG(0x140, "Server %s requested index "
593 "%d, but that index is already in "
594 "use. Use --writeconf to force\n",
596 mti->mti_stripe_index);
599 CDEBUG(D_MGS, "Server %s updating index %d\n",
600 mti->mti_svname, mti->mti_stripe_index);
605 cfs_set_bit(mti->mti_stripe_index, imap);
606 cfs_clear_bit(FSDB_LOG_EMPTY, &fsdb->fsdb_flags);
607 server_make_name(mti->mti_flags, mti->mti_stripe_index,
608 mti->mti_fsname, mti->mti_svname);
610 CDEBUG(D_MGS, "Set index for %s to %d\n", mti->mti_svname,
611 mti->mti_stripe_index);
616 struct mgs_modify_lookup {
617 struct cfg_marker mml_marker;
621 static int mgs_modify_handler(struct llog_handle *llh, struct llog_rec_hdr *rec,
624 struct mgs_modify_lookup *mml = (struct mgs_modify_lookup *)data;
625 struct cfg_marker *marker;
626 struct lustre_cfg *lcfg = (struct lustre_cfg *)(rec + 1);
627 int cfg_len = rec->lrh_len - sizeof(struct llog_rec_hdr) -
628 sizeof(struct llog_rec_tail);
632 if (rec->lrh_type != OBD_CFG_REC) {
633 CERROR("unhandled lrh_type: %#x\n", rec->lrh_type);
637 rc = lustre_cfg_sanity_check(lcfg, cfg_len);
639 CERROR("Insane cfg\n");
643 /* We only care about markers */
644 if (lcfg->lcfg_command != LCFG_MARKER)
647 marker = lustre_cfg_buf(lcfg, 1);
648 if ((strcmp(mml->mml_marker.cm_comment, marker->cm_comment) == 0) &&
649 (strcmp(mml->mml_marker.cm_tgtname, marker->cm_tgtname) == 0) &&
650 !(marker->cm_flags & CM_SKIP)) {
651 /* Found a non-skipped marker match */
652 CDEBUG(D_MGS, "Changing rec %u marker %d %x->%x: %s %s\n",
653 rec->lrh_index, marker->cm_step,
654 marker->cm_flags, mml->mml_marker.cm_flags,
655 marker->cm_tgtname, marker->cm_comment);
656 /* Overwrite the old marker llog entry */
657 marker->cm_flags &= ~CM_EXCLUDE; /* in case we're unexcluding */
658 marker->cm_flags |= mml->mml_marker.cm_flags;
659 marker->cm_canceltime = mml->mml_marker.cm_canceltime;
660 /* Header and tail are added back to lrh_len in
661 llog_lvfs_write_rec */
662 rec->lrh_len = cfg_len;
663 rc = llog_write_rec(llh, rec, NULL, 0, (void *)lcfg,
672 /* Modify an existing config log record (for CM_SKIP or CM_EXCLUDE) */
673 static int mgs_modify(struct obd_device *obd, struct fs_db *fsdb,
674 struct mgs_target_info *mti, char *logname,
675 char *devname, char *comment, int flags)
677 struct llog_handle *loghandle;
678 struct lvfs_run_ctxt saved;
679 struct llog_ctxt *ctxt;
680 struct mgs_modify_lookup *mml;
684 CDEBUG(D_MGS, "modify %s/%s/%s fl=%x\n", logname, devname, comment,
687 push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
689 ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT);
690 LASSERT(ctxt != NULL);
691 rc = llog_create(ctxt, &loghandle, NULL, logname);
695 rc = llog_init_handle(loghandle, LLOG_F_IS_PLAIN, NULL);
699 if (llog_get_size(loghandle) <= 1)
700 GOTO(out_close, rc = 0);
704 GOTO(out_close, rc = -ENOMEM);
705 strcpy(mml->mml_marker.cm_comment, comment);
706 strcpy(mml->mml_marker.cm_tgtname, devname);
707 /* Modify mostly means cancel */
708 mml->mml_marker.cm_flags = flags;
709 mml->mml_marker.cm_canceltime = flags ? cfs_time_current_sec() : 0;
710 mml->mml_modified = 0;
711 rc = llog_process(loghandle, mgs_modify_handler, (void *)mml, NULL);
712 if (!rc && !mml->mml_modified)
717 rc2 = llog_close(loghandle);
721 pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
722 if (rc && rc != -ENODEV)
723 CERROR("modify %s/%s failed %d\n",
724 mti->mti_svname, comment, rc);
729 /******************** config log recording functions *********************/
731 static int record_lcfg(struct obd_device *obd, struct llog_handle *llh,
732 struct lustre_cfg *lcfg)
734 struct lvfs_run_ctxt saved;
735 struct llog_rec_hdr rec;
741 LASSERT(llh->lgh_ctxt);
743 buflen = lustre_cfg_len(lcfg->lcfg_bufcount,
745 rec.lrh_len = llog_data_len(buflen);
746 rec.lrh_type = OBD_CFG_REC;
748 push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
749 /* idx = -1 means append */
750 rc = llog_write_rec(llh, &rec, NULL, 0, (void *)lcfg, -1);
751 pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
753 CERROR("failed %d\n", rc);
757 static int record_base(struct obd_device *obd, struct llog_handle *llh,
758 char *cfgname, lnet_nid_t nid, int cmd,
759 char *s1, char *s2, char *s3, char *s4)
761 struct lustre_cfg_bufs bufs;
762 struct lustre_cfg *lcfg;
765 CDEBUG(D_MGS, "lcfg %s %#x %s %s %s %s\n", cfgname,
766 cmd, s1, s2, s3, s4);
768 lustre_cfg_bufs_reset(&bufs, cfgname);
770 lustre_cfg_bufs_set_string(&bufs, 1, s1);
772 lustre_cfg_bufs_set_string(&bufs, 2, s2);
774 lustre_cfg_bufs_set_string(&bufs, 3, s3);
776 lustre_cfg_bufs_set_string(&bufs, 4, s4);
778 lcfg = lustre_cfg_new(cmd, &bufs);
781 lcfg->lcfg_nid = nid;
783 rc = record_lcfg(obd, llh, lcfg);
785 lustre_cfg_free(lcfg);
788 CERROR("error %d: lcfg %s %#x %s %s %s %s\n", rc, cfgname,
789 cmd, s1, s2, s3, s4);
795 static inline int record_add_uuid(struct obd_device *obd,
796 struct llog_handle *llh,
797 uint64_t nid, char *uuid)
799 return record_base(obd,llh,NULL,nid,LCFG_ADD_UUID,uuid,0,0,0);
803 static inline int record_add_conn(struct obd_device *obd,
804 struct llog_handle *llh,
808 return record_base(obd,llh,devname,0,LCFG_ADD_CONN,uuid,0,0,0);
811 static inline int record_attach(struct obd_device *obd, struct llog_handle *llh,
812 char *devname, char *type, char *uuid)
814 return record_base(obd,llh,devname,0,LCFG_ATTACH,type,uuid,0,0);
817 static inline int record_setup(struct obd_device *obd, struct llog_handle *llh,
819 char *s1, char *s2, char *s3, char *s4)
821 return record_base(obd,llh,devname,0,LCFG_SETUP,s1,s2,s3,s4);
824 static int record_lov_setup(struct obd_device *obd, struct llog_handle *llh,
825 char *devname, struct lov_desc *desc)
827 struct lustre_cfg_bufs bufs;
828 struct lustre_cfg *lcfg;
831 lustre_cfg_bufs_reset(&bufs, devname);
832 lustre_cfg_bufs_set(&bufs, 1, desc, sizeof(*desc));
833 lcfg = lustre_cfg_new(LCFG_SETUP, &bufs);
836 rc = record_lcfg(obd, llh, lcfg);
838 lustre_cfg_free(lcfg);
842 static int record_lmv_setup(struct obd_device *obd, struct llog_handle *llh,
843 char *devname, struct lmv_desc *desc)
845 struct lustre_cfg_bufs bufs;
846 struct lustre_cfg *lcfg;
849 lustre_cfg_bufs_reset(&bufs, devname);
850 lustre_cfg_bufs_set(&bufs, 1, desc, sizeof(*desc));
851 lcfg = lustre_cfg_new(LCFG_SETUP, &bufs);
853 rc = record_lcfg(obd, llh, lcfg);
855 lustre_cfg_free(lcfg);
859 static inline int record_mdc_add(struct obd_device *obd,
860 struct llog_handle *llh,
861 char *logname, char *mdcuuid,
862 char *mdtuuid, char *index,
865 return record_base(obd,llh,logname,0,LCFG_ADD_MDC,
866 mdtuuid,index,gen,mdcuuid);
869 static inline int record_lov_add(struct obd_device *obd,
870 struct llog_handle *llh,
871 char *lov_name, char *ost_uuid,
872 char *index, char *gen)
874 return record_base(obd,llh,lov_name,0,LCFG_LOV_ADD_OBD,
875 ost_uuid,index,gen,0);
878 static inline int record_mount_opt(struct obd_device *obd,
879 struct llog_handle *llh,
880 char *profile, char *lov_name,
883 return record_base(obd,llh,NULL,0,LCFG_MOUNTOPT,
884 profile,lov_name,mdc_name,0);
887 static int record_marker(struct obd_device *obd, struct llog_handle *llh,
888 struct fs_db *fsdb, __u32 flags,
889 char *tgtname, char *comment)
891 struct cfg_marker marker;
892 struct lustre_cfg_bufs bufs;
893 struct lustre_cfg *lcfg;
896 if (flags & CM_START)
898 marker.cm_step = fsdb->fsdb_gen;
899 marker.cm_flags = flags;
900 marker.cm_vers = LUSTRE_VERSION_CODE;
901 strncpy(marker.cm_tgtname, tgtname, sizeof(marker.cm_tgtname));
902 strncpy(marker.cm_comment, comment, sizeof(marker.cm_comment));
903 marker.cm_createtime = cfs_time_current_sec();
904 marker.cm_canceltime = 0;
905 lustre_cfg_bufs_reset(&bufs, NULL);
906 lustre_cfg_bufs_set(&bufs, 1, &marker, sizeof(marker));
907 lcfg = lustre_cfg_new(LCFG_MARKER, &bufs);
910 rc = record_lcfg(obd, llh, lcfg);
912 lustre_cfg_free(lcfg);
916 static int record_start_log(struct obd_device *obd,
917 struct llog_handle **llh, char *name)
919 static struct obd_uuid cfg_uuid = { .uuid = "config_uuid" };
920 struct lvfs_run_ctxt saved;
921 struct llog_ctxt *ctxt;
925 GOTO(out, rc = -EBUSY);
927 ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT);
929 GOTO(out, rc = -ENODEV);
931 push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
932 rc = llog_create(ctxt, llh, NULL, name);
934 llog_init_handle(*llh, LLOG_F_IS_PLAIN, &cfg_uuid);
938 pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
943 CERROR("Can't start log %s: %d\n", name, rc);
948 static int record_end_log(struct obd_device *obd, struct llog_handle **llh)
950 struct lvfs_run_ctxt saved;
953 push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
955 rc = llog_close(*llh);
958 pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
962 static int mgs_log_is_empty(struct obd_device *obd, char *name)
964 struct lvfs_run_ctxt saved;
965 struct llog_handle *llh;
966 struct llog_ctxt *ctxt;
969 ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT);
970 LASSERT(ctxt != NULL);
971 push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
972 rc = llog_create(ctxt, &llh, NULL, name);
974 llog_init_handle(llh, LLOG_F_IS_PLAIN, NULL);
975 rc = llog_get_size(llh);
978 pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
980 /* header is record 1 */
984 /******************** config "macros" *********************/
986 /* write an lcfg directly into a log (with markers) */
987 static int mgs_write_log_direct(struct obd_device *obd, struct fs_db *fsdb,
988 char *logname, struct lustre_cfg *lcfg,
989 char *devname, char *comment)
991 struct llog_handle *llh = NULL;
998 rc = record_start_log(obd, &llh, logname);
1002 /* FIXME These should be a single journal transaction */
1003 rc = record_marker(obd, llh, fsdb, CM_START, devname, comment);
1005 rc = record_lcfg(obd, llh, lcfg);
1007 rc = record_marker(obd, llh, fsdb, CM_END, devname, comment);
1008 rc = record_end_log(obd, &llh);
1013 /* write the lcfg in all logs for the given fs */
1014 int mgs_write_log_direct_all(struct obd_device *obd, struct fs_db *fsdb,
1015 struct mgs_target_info *mti,
1016 struct lustre_cfg *lcfg,
1017 char *devname, char *comment)
1019 struct mgs_obd *mgs = &obd->u.mgs;
1020 cfs_list_t dentry_list;
1021 struct l_linux_dirent *dirent, *n;
1022 char *fsname = mti->mti_fsname;
1024 int rc = 0, len = strlen(fsname);
1027 /* We need to set params for any future logs
1028 as well. FIXME Append this file to every new log.
1029 Actually, we should store as params (text), not llogs. Or
1031 name_create(&logname, fsname, "-params");
1032 if (mgs_log_is_empty(obd, logname)) {
1033 struct llog_handle *llh = NULL;
1034 rc = record_start_log(obd, &llh, logname);
1035 record_end_log(obd, &llh);
1037 name_destroy(&logname);
1041 /* Find all the logs in the CONFIGS directory */
1042 rc = class_dentry_readdir(obd, mgs->mgs_configs_dir,
1043 mgs->mgs_vfsmnt, &dentry_list);
1045 CERROR("Can't read %s dir\n", MOUNT_CONFIGS_DIR);
1049 /* Could use fsdb index maps instead of directory listing */
1050 cfs_list_for_each_entry_safe(dirent, n, &dentry_list, lld_list) {
1051 cfs_list_del(&dirent->lld_list);
1052 /* don't write to sptlrpc rule log */
1053 if (strncmp(fsname, dirent->lld_name, len) == 0 &&
1054 strstr(dirent->lld_name, "-sptlrpc") == NULL) {
1055 CDEBUG(D_MGS, "Changing log %s\n", dirent->lld_name);
1056 /* Erase any old settings of this same parameter */
1057 mgs_modify(obd, fsdb, mti, dirent->lld_name, devname,
1059 /* Write the new one */
1061 rc = mgs_write_log_direct(obd, fsdb,
1066 CERROR("err %d writing log %s\n", rc,
1070 OBD_FREE(dirent, sizeof(*dirent));
1078 struct mgs_target_info *comp_tmti;
1079 struct mgs_target_info *comp_mti;
1080 struct fs_db *comp_fsdb;
1081 struct obd_device *comp_obd;
1084 static int mgs_write_log_mdc_to_mdt(struct obd_device *, struct fs_db *,
1085 struct mgs_target_info *, char *);
1086 static int mgs_write_log_osc_to_lov(struct obd_device *obd, struct fs_db *fsdb,
1087 struct mgs_target_info *mti,
1088 char *logname, char *suffix, char *lovname,
1089 enum lustre_sec_part sec_part, int flags);
1090 static void name_create_mdt_and_lov(char **logname, char **lovname,
1091 struct fs_db *fsdb, int i);
1093 static int mgs_steal_llog_handler(struct llog_handle *llh,
1094 struct llog_rec_hdr *rec,
1097 struct obd_device * obd;
1098 struct mgs_target_info *mti, *tmti;
1100 int cfg_len = rec->lrh_len;
1101 char *cfg_buf = (char*) (rec + 1);
1102 struct lustre_cfg *lcfg;
1104 struct llog_handle *mdt_llh = NULL;
1105 static int got_an_osc_or_mdc = 0;
1106 /* 0: not found any osc/mdc;
1110 static int last_step = -1;
1114 mti = ((struct temp_comp*)data)->comp_mti;
1115 tmti = ((struct temp_comp*)data)->comp_tmti;
1116 fsdb = ((struct temp_comp*)data)->comp_fsdb;
1117 obd = ((struct temp_comp*)data)->comp_obd;
1119 if (rec->lrh_type != OBD_CFG_REC) {
1120 CERROR("unhandled lrh_type: %#x\n", rec->lrh_type);
1124 rc = lustre_cfg_sanity_check(cfg_buf, cfg_len);
1126 CERROR("Insane cfg\n");
1130 lcfg = (struct lustre_cfg *)cfg_buf;
1132 if (lcfg->lcfg_command == LCFG_MARKER) {
1133 struct cfg_marker *marker;
1134 marker = lustre_cfg_buf(lcfg, 1);
1135 if (!strncmp(marker->cm_comment,"add osc",7) &&
1136 (marker->cm_flags & CM_START)){
1137 got_an_osc_or_mdc = 1;
1138 strncpy(tmti->mti_svname, marker->cm_tgtname,
1139 sizeof(tmti->mti_svname));
1140 rc = record_start_log(obd, &mdt_llh, mti->mti_svname);
1141 rc = record_marker(obd, mdt_llh, fsdb, CM_START,
1142 mti->mti_svname,"add osc(copied)");
1143 rc = record_end_log(obd, &mdt_llh);
1144 last_step = marker->cm_step;
1147 if (!strncmp(marker->cm_comment,"add osc",7) &&
1148 (marker->cm_flags & CM_END)){
1149 LASSERT(last_step == marker->cm_step);
1151 got_an_osc_or_mdc = 0;
1152 rc = record_start_log(obd, &mdt_llh, mti->mti_svname);
1153 rc = record_marker(obd, mdt_llh, fsdb, CM_END,
1154 mti->mti_svname,"add osc(copied)");
1155 rc = record_end_log(obd, &mdt_llh);
1158 if (!strncmp(marker->cm_comment,"add mdc",7) &&
1159 (marker->cm_flags & CM_START)){
1160 got_an_osc_or_mdc = 2;
1161 last_step = marker->cm_step;
1162 memcpy(tmti->mti_svname, marker->cm_tgtname,
1163 strlen(marker->cm_tgtname));
1167 if (!strncmp(marker->cm_comment,"add mdc",7) &&
1168 (marker->cm_flags & CM_END)){
1169 LASSERT(last_step == marker->cm_step);
1171 got_an_osc_or_mdc = 0;
1176 if (got_an_osc_or_mdc == 0 || last_step < 0)
1179 if (lcfg->lcfg_command == LCFG_ADD_UUID) {
1181 nodenid = lcfg->lcfg_nid;
1183 tmti->mti_nids[tmti->mti_nid_count] = nodenid;
1184 tmti->mti_nid_count++;
1189 if (lcfg->lcfg_command == LCFG_SETUP) {
1192 target = lustre_cfg_string(lcfg, 1);
1193 memcpy(tmti->mti_uuid, target, strlen(target));
1197 /* ignore client side sptlrpc_conf_log */
1198 if (lcfg->lcfg_command == LCFG_SPTLRPC_CONF)
1201 if (lcfg->lcfg_command == LCFG_ADD_MDC) {
1204 if (sscanf(lustre_cfg_buf(lcfg, 2), "%d", &index) != 1)
1207 memcpy(tmti->mti_fsname, mti->mti_fsname,
1208 strlen(mti->mti_fsname));
1209 tmti->mti_stripe_index = index;
1211 mgs_write_log_mdc_to_mdt(obd, fsdb, tmti, mti->mti_svname);
1212 memset(tmti, 0, sizeof(*tmti));
1216 if (lcfg->lcfg_command == LCFG_LOV_ADD_OBD) {
1219 char *logname, *lovname;
1221 name_create_mdt_and_lov(&logname, &lovname, fsdb,
1222 mti->mti_stripe_index);
1223 sprintf(mdt_index, "-MDT%04x", mti->mti_stripe_index);
1225 if (sscanf(lustre_cfg_buf(lcfg, 2), "%d", &index) != 1) {
1226 name_destroy(&logname);
1227 name_destroy(&lovname);
1231 tmti->mti_stripe_index = index;
1232 mgs_write_log_osc_to_lov(obd, fsdb, tmti, logname,
1235 name_destroy(&logname);
1236 name_destroy(&lovname);
1242 /* fsdb->fsdb_mutex is already held in mgs_write_log_target*/
1243 /* stealed from mgs_get_fsdb_from_llog*/
1244 static int mgs_steal_llog_for_mdt_from_client(struct obd_device *obd,
1246 struct temp_comp* comp)
1248 struct llog_handle *loghandle;
1249 struct lvfs_run_ctxt saved;
1250 struct mgs_target_info *tmti;
1251 struct llog_ctxt *ctxt;
1255 ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT);
1256 LASSERT(ctxt != NULL);
1258 OBD_ALLOC_PTR(tmti);
1262 comp->comp_tmti = tmti;
1263 comp->comp_obd = obd;
1265 push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
1267 rc = llog_create(ctxt, &loghandle, NULL, client_name);
1271 rc = llog_init_handle(loghandle, LLOG_F_IS_PLAIN, NULL);
1273 GOTO(out_close, rc);
1275 rc = llog_process(loghandle, mgs_steal_llog_handler, (void *)comp, NULL);
1276 CDEBUG(D_MGS, "steal llog re = %d\n", rc);
1278 rc2 = llog_close(loghandle);
1282 pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
1284 llog_ctxt_put(ctxt);
1288 /* lmv is the second thing for client logs */
1289 /* copied from mgs_write_log_lov. Please refer to that. */
1290 static int mgs_write_log_lmv(struct obd_device *obd, struct fs_db *fsdb,
1291 struct mgs_target_info *mti,
1292 char *logname, char *lmvname)
1294 struct llog_handle *llh = NULL;
1295 struct lmv_desc *lmvdesc;
1300 CDEBUG(D_MGS, "Writing lmv(%s) log for %s\n", lmvname,logname);
1302 OBD_ALLOC_PTR(lmvdesc);
1303 if (lmvdesc == NULL)
1305 lmvdesc->ld_active_tgt_count = 0;
1306 lmvdesc->ld_tgt_count = 0;
1307 sprintf((char*)lmvdesc->ld_uuid.uuid, "%s_UUID", lmvname);
1308 uuid = (char *)lmvdesc->ld_uuid.uuid;
1310 rc = record_start_log(obd, &llh, logname);
1311 rc = record_marker(obd, llh, fsdb, CM_START, lmvname, "lmv setup");
1312 rc = record_attach(obd, llh, lmvname, "lmv", uuid);
1313 rc = record_lmv_setup(obd, llh, lmvname, lmvdesc);
1314 rc = record_marker(obd, llh, fsdb, CM_END, lmvname, "lmv setup");
1315 rc = record_end_log(obd, &llh);
1317 OBD_FREE_PTR(lmvdesc);
1321 /* lov is the first thing in the mdt and client logs */
1322 static int mgs_write_log_lov(struct obd_device *obd, struct fs_db *fsdb,
1323 struct mgs_target_info *mti,
1324 char *logname, char *lovname)
1326 struct llog_handle *llh = NULL;
1327 struct lov_desc *lovdesc;
1332 CDEBUG(D_MGS, "Writing lov(%s) log for %s\n", lovname, logname);
1335 #01 L attach 0:lov_mdsA 1:lov 2:71ccb_lov_mdsA_19f961a9e1
1336 #02 L lov_setup 0:lov_mdsA 1:(struct lov_desc)
1337 uuid=lov1_UUID, stripe count=1, size=1048576, offset=0, pattern=0
1340 /* FIXME just make lov_setup accept empty desc (put uuid in buf 2) */
1341 OBD_ALLOC_PTR(lovdesc);
1342 if (lovdesc == NULL)
1344 lovdesc->ld_magic = LOV_DESC_MAGIC;
1345 lovdesc->ld_tgt_count = 0;
1346 /* Defaults. Can be changed later by lcfg config_param */
1347 lovdesc->ld_default_stripe_count = 1;
1348 lovdesc->ld_pattern = LOV_PATTERN_RAID0;
1349 lovdesc->ld_default_stripe_size = 1024 * 1024;
1350 lovdesc->ld_default_stripe_offset = -1;
1351 lovdesc->ld_qos_maxage = QOS_DEFAULT_MAXAGE;
1352 sprintf((char*)lovdesc->ld_uuid.uuid, "%s_UUID", lovname);
1353 /* can these be the same? */
1354 uuid = (char *)lovdesc->ld_uuid.uuid;
1356 /* This should always be the first entry in a log.
1357 rc = mgs_clear_log(obd, logname); */
1358 rc = record_start_log(obd, &llh, logname);
1361 /* FIXME these should be a single journal transaction */
1362 rc = record_marker(obd, llh, fsdb, CM_START, lovname, "lov setup");
1363 rc = record_attach(obd, llh, lovname, "lov", uuid);
1364 rc = record_lov_setup(obd, llh, lovname, lovdesc);
1365 rc = record_marker(obd, llh, fsdb, CM_END, lovname, "lov setup");
1366 rc = record_end_log(obd, &llh);
1370 OBD_FREE_PTR(lovdesc);
1374 /* add failnids to open log */
1375 static int mgs_write_log_failnids(struct obd_device *obd,
1376 struct mgs_target_info *mti,
1377 struct llog_handle *llh,
1380 char *failnodeuuid = NULL;
1381 char *ptr = mti->mti_params;
1386 #03 L add_uuid nid=uml1@tcp(0x20000c0a80201) nal=90 0: 1:uml1_UUID
1387 #04 L add_uuid nid=1@elan(0x1000000000001) nal=90 0: 1:uml1_UUID
1388 #05 L setup 0:OSC_uml1_ost1_mdsA 1:ost1_UUID 2:uml1_UUID
1389 #06 L add_uuid nid=uml2@tcp(0x20000c0a80202) nal=90 0: 1:uml2_UUID
1390 #0x L add_uuid nid=2@elan(0x1000000000002) nal=90 0: 1:uml2_UUID
1391 #07 L add_conn 0:OSC_uml1_ost1_mdsA 1:uml2_UUID
1394 /* Pull failnid info out of params string */
1395 while (class_find_param(ptr, PARAM_FAILNODE, &ptr) == 0) {
1396 while (class_parse_nid(ptr, &nid, &ptr) == 0) {
1397 if (failnodeuuid == NULL) {
1398 /* We don't know the failover node name,
1399 so just use the first nid as the uuid */
1400 rc = name_create(&failnodeuuid,
1401 libcfs_nid2str(nid), "");
1405 CDEBUG(D_MGS, "add nid %s for failover uuid %s, "
1406 "client %s\n", libcfs_nid2str(nid),
1407 failnodeuuid, cliname);
1408 rc = record_add_uuid(obd, llh, nid, failnodeuuid);
1411 rc = record_add_conn(obd, llh, cliname, failnodeuuid);
1412 name_destroy(&failnodeuuid);
1413 failnodeuuid = NULL;
1420 static int mgs_write_log_mdc_to_lmv(struct obd_device *obd, struct fs_db *fsdb,
1421 struct mgs_target_info *mti,
1422 char *logname, char *lmvname)
1424 struct llog_handle *llh = NULL;
1425 char *mdcname, *nodeuuid, *mdcuuid, *lmvuuid;
1430 if (mgs_log_is_empty(obd, logname)) {
1431 CERROR("log is empty! Logical error\n");
1435 CDEBUG(D_MGS, "adding mdc for %s to log %s:lmv(%s)\n",
1436 mti->mti_svname, logname, lmvname);
1438 name_create(&nodeuuid, libcfs_nid2str(mti->mti_nids[0]), "");
1439 name_create(&mdcname, mti->mti_svname, "-mdc");
1440 name_create(&mdcuuid, mdcname, "_UUID");
1441 name_create(&lmvuuid, lmvname, "_UUID");
1443 rc = record_start_log(obd, &llh, logname);
1444 rc = record_marker(obd, llh, fsdb, CM_START, mti->mti_svname,
1447 for (i = 0; i < mti->mti_nid_count; i++) {
1448 CDEBUG(D_MGS, "add nid %s for mdt\n",
1449 libcfs_nid2str(mti->mti_nids[i]));
1451 rc = record_add_uuid(obd, llh, mti->mti_nids[i], nodeuuid);
1454 rc = record_attach(obd, llh, mdcname, LUSTRE_MDC_NAME, lmvuuid);
1455 rc = record_setup(obd, llh, mdcname, mti->mti_uuid, nodeuuid, 0, 0);
1456 rc = mgs_write_log_failnids(obd, mti, llh, mdcname);
1457 snprintf(index, sizeof(index), "%d", mti->mti_stripe_index);
1458 rc = record_mdc_add(obd, llh, lmvname, mdcuuid, mti->mti_uuid,
1460 rc = record_marker(obd, llh, fsdb, CM_END, mti->mti_svname,
1462 rc = record_end_log(obd, &llh);
1464 name_destroy(&lmvuuid);
1465 name_destroy(&mdcuuid);
1466 name_destroy(&mdcname);
1467 name_destroy(&nodeuuid);
1471 /* add new mdc to already existent MDS */
1472 static int mgs_write_log_mdc_to_mdt(struct obd_device *obd, struct fs_db *fsdb,
1473 struct mgs_target_info *mti, char *logname)
1475 struct llog_handle *llh = NULL;
1476 char *nodeuuid, *mdcname, *mdcuuid, *mdtuuid;
1477 int idx = mti->mti_stripe_index;
1482 if (mgs_log_is_empty(obd, logname)) {
1483 CERROR("log is empty! Logical error\n");
1487 CDEBUG(D_MGS, "adding mdc index %d to %s\n", idx, logname);
1489 name_create(&nodeuuid, libcfs_nid2str(mti->mti_nids[0]), "");
1490 snprintf(index, sizeof(index), "-mdc%04x", idx);
1491 name_create(&mdcname, logname, index);
1492 name_create(&mdcuuid, mdcname, "_UUID");
1493 name_create(&mdtuuid, logname, "_UUID");
1495 rc = record_start_log(obd, &llh, logname);
1496 rc = record_marker(obd, llh, fsdb, CM_START, mti->mti_svname, "add mdc");
1497 for (i = 0; i < mti->mti_nid_count; i++) {
1498 CDEBUG(D_MGS, "add nid %s for mdt\n",
1499 libcfs_nid2str(mti->mti_nids[i]));
1500 rc = record_add_uuid(obd, llh, mti->mti_nids[i], nodeuuid);
1502 rc = record_attach(obd, llh, mdcname, LUSTRE_MDC_NAME, mdcuuid);
1503 rc = record_setup(obd, llh, mdcname, mti->mti_uuid, nodeuuid, 0, 0);
1504 rc = mgs_write_log_failnids(obd, mti, llh, mdcname);
1505 snprintf(index, sizeof(index), "%d", idx);
1507 rc = record_mdc_add(obd, llh, logname, mdcuuid, mti->mti_uuid,
1509 rc = record_marker(obd, llh, fsdb, CM_END, mti->mti_svname, "add mdc");
1510 rc = record_end_log(obd, &llh);
1512 name_destroy(&mdcuuid);
1513 name_destroy(&mdcname);
1514 name_destroy(&nodeuuid);
1515 name_destroy(&mdtuuid);
1519 static int mgs_write_log_mdt0(struct obd_device *obd, struct fs_db *fsdb,
1520 struct mgs_target_info *mti)
1522 char *log = mti->mti_svname;
1523 struct llog_handle *llh = NULL;
1524 char *uuid, *lovname;
1526 char *ptr = mti->mti_params;
1527 int rc = 0, failout = 0;
1530 OBD_ALLOC(uuid, sizeof(struct obd_uuid));
1534 if (class_find_param(ptr, PARAM_FAILMODE, &ptr) == 0)
1535 failout = (strncmp(ptr, "failout", 7) == 0);
1537 name_create(&lovname, log, "-mdtlov");
1538 if (mgs_log_is_empty(obd, log))
1539 rc = mgs_write_log_lov(obd, fsdb, mti, log, lovname);
1541 sprintf(uuid, "%s_UUID", log);
1542 sprintf(mdt_index, "%d", mti->mti_stripe_index);
1544 /* add MDT itself */
1545 rc = record_start_log(obd, &llh, log);
1549 /* FIXME this whole fn should be a single journal transaction */
1550 rc = record_marker(obd, llh, fsdb, CM_START, log, "add mdt");
1551 rc = record_attach(obd, llh, log, LUSTRE_MDT_NAME, uuid);
1552 rc = record_mount_opt(obd, llh, log, lovname, NULL);
1553 rc = record_setup(obd, llh, log, uuid, mdt_index, lovname,
1554 failout ? "n" : "f");
1555 rc = record_marker(obd, llh, fsdb, CM_END, log, "add mdt");
1556 rc = record_end_log(obd, &llh);
1558 name_destroy(&lovname);
1559 OBD_FREE(uuid, sizeof(struct obd_uuid));
1563 static inline void name_create_mdt(char **logname, char *fsname, int i)
1567 sprintf(mdt_index, "-MDT%04x", i);
1568 name_create(logname, fsname, mdt_index);
1571 static void name_create_mdt_and_lov(char **logname, char **lovname,
1572 struct fs_db *fsdb, int i)
1574 name_create_mdt(logname, fsdb->fsdb_name, i);
1576 if (i == 0 && cfs_test_bit(FSDB_OSCNAME18, &fsdb->fsdb_flags))
1577 name_create(lovname, fsdb->fsdb_name, "-mdtlov");
1579 name_create(lovname, *logname, "-mdtlov");
1582 static inline void name_create_mdt_osc(char **oscname, char *ostname,
1583 struct fs_db *fsdb, int i)
1587 if (i == 0 && cfs_test_bit(FSDB_OSCNAME18, &fsdb->fsdb_flags))
1588 sprintf(suffix, "-osc");
1590 sprintf(suffix, "-osc-MDT%04x", i);
1591 name_create(oscname, ostname, suffix);
1594 /* envelope method for all layers log */
1595 static int mgs_write_log_mdt(struct obd_device *obd, struct fs_db *fsdb,
1596 struct mgs_target_info *mti)
1598 struct llog_handle *llh = NULL;
1600 struct temp_comp comp = { 0 };
1604 CDEBUG(D_MGS, "writing new mdt %s\n", mti->mti_svname);
1608 if (mti->mti_flags & LDD_F_UPGRADE14) {
1609 /* We're starting with an old uuid. Assume old name for lov
1610 as well since the lov entry already exists in the log. */
1611 CDEBUG(D_MGS, "old mds uuid %s\n", mti->mti_uuid);
1612 if (strncmp(mti->mti_uuid, fsdb->fsdb_mdtlov + 4,
1613 strlen(fsdb->fsdb_mdtlov) - 4) != 0) {
1614 CERROR("old mds uuid %s doesn't match log %s (%s)\n",
1615 mti->mti_uuid, fsdb->fsdb_mdtlov,
1616 fsdb->fsdb_mdtlov + 4);
1620 /* end COMPAT_146 */
1622 if (mti->mti_uuid[0] == '\0') {
1623 /* Make up our own uuid */
1624 snprintf(mti->mti_uuid, sizeof(mti->mti_uuid),
1625 "%s_UUID", mti->mti_svname);
1629 rc = mgs_write_log_mdt0(obd, fsdb, mti);
1631 /* Append the mdt info to the client log */
1632 name_create(&cliname, mti->mti_fsname, "-client");
1634 if (mgs_log_is_empty(obd, cliname)) {
1635 /* Start client log */
1636 rc = mgs_write_log_lov(obd, fsdb, mti, cliname,
1638 rc = mgs_write_log_lmv(obd, fsdb, mti, cliname,
1643 #09 L add_uuid nid=uml1@tcp(0x20000c0a80201) 0: 1:uml1_UUID
1644 #10 L attach 0:MDC_uml1_mdsA_MNT_client 1:mdc 2:1d834_MNT_client_03f
1645 #11 L setup 0:MDC_uml1_mdsA_MNT_client 1:mdsA_UUID 2:uml1_UUID
1646 #12 L add_uuid nid=uml2@tcp(0x20000c0a80202) 0: 1:uml2_UUID
1647 #13 L add_conn 0:MDC_uml1_mdsA_MNT_client 1:uml2_UUID
1648 #14 L mount_option 0: 1:client 2:lov1 3:MDC_uml1_mdsA_MNT_client
1653 if (mti->mti_flags & LDD_F_UPGRADE14) {
1654 rc = record_start_log(obd, &llh, cliname);
1658 rc = record_marker(obd, llh, fsdb, CM_START,
1659 mti->mti_svname,"add mdc");
1661 /* Old client log already has MDC entry, but needs mount opt
1662 for new client name (lustre-client) */
1663 /* FIXME Old MDT log already has an old mount opt
1664 which we should remove (currently handled by
1665 class_del_profiles()) */
1666 rc = record_mount_opt(obd, llh, cliname, fsdb->fsdb_clilov,
1668 /* end COMPAT_146 */
1670 rc = record_marker(obd, llh, fsdb, CM_END,
1671 mti->mti_svname, "add mdc");
1675 /* copy client info about lov/lmv */
1676 comp.comp_mti = mti;
1677 comp.comp_fsdb = fsdb;
1679 rc = mgs_steal_llog_for_mdt_from_client(obd, cliname,
1682 rc = mgs_write_log_mdc_to_lmv(obd, fsdb, mti, cliname,
1685 rc = record_start_log(obd, &llh, cliname);
1689 rc = record_marker(obd, llh, fsdb, CM_START, cliname,
1691 rc = record_mount_opt(obd, llh, cliname, fsdb->fsdb_clilov,
1693 rc = record_marker(obd, llh, fsdb, CM_END, cliname,
1697 rc = record_end_log(obd, &llh);
1699 name_destroy(&cliname);
1701 // for_all_existing_mdt except current one
1702 for (i = 0; i < INDEX_MAP_SIZE * 8; i++){
1704 if (i != mti->mti_stripe_index &&
1705 cfs_test_bit(i, fsdb->fsdb_mdt_index_map)) {
1706 name_create_mdt(&mdtname, mti->mti_fsname, i);
1707 rc = mgs_write_log_mdc_to_mdt(obd, fsdb, mti, mdtname);
1708 name_destroy(&mdtname);
1715 /* Add the ost info to the client/mdt lov */
1716 static int mgs_write_log_osc_to_lov(struct obd_device *obd, struct fs_db *fsdb,
1717 struct mgs_target_info *mti,
1718 char *logname, char *suffix, char *lovname,
1719 enum lustre_sec_part sec_part, int flags)
1721 struct llog_handle *llh = NULL;
1722 char *nodeuuid, *oscname, *oscuuid, *lovuuid, *svname;
1727 CDEBUG(D_INFO, "adding osc for %s to log %s\n",
1728 mti->mti_svname, logname);
1730 if (mgs_log_is_empty(obd, logname)) {
1731 CERROR("log is empty! Logical error\n");
1735 name_create(&nodeuuid, libcfs_nid2str(mti->mti_nids[0]), "");
1736 name_create(&svname, mti->mti_svname, "-osc");
1737 name_create(&oscname, svname, suffix);
1738 name_create(&oscuuid, oscname, "_UUID");
1739 name_create(&lovuuid, lovname, "_UUID");
1742 #03 L add_uuid nid=uml1@tcp(0x20000c0a80201) 0: 1:uml1_UUID
1744 #04 L add_uuid nid=1@elan(0x1000000000001) nal=90 0: 1:uml1_UUID
1745 #04 L attach 0:OSC_uml1_ost1_MNT_client 1:osc 2:89070_lov1_a41dff51a
1746 #05 L setup 0:OSC_uml1_ost1_MNT_client 1:ost1_UUID 2:uml1_UUID
1748 #06 L add_uuid nid=uml2@tcp(0x20000c0a80202) 0: 1:uml2_UUID
1749 #07 L add_conn 0:OSC_uml1_ost1_MNT_client 1:uml2_UUID
1750 #08 L lov_modify_tgts add 0:lov1 1:ost1_UUID 2(index):0 3(gen):1
1753 rc = record_start_log(obd, &llh, logname);
1756 /* FIXME these should be a single journal transaction */
1757 rc = record_marker(obd, llh, fsdb, CM_START | flags, mti->mti_svname,
1759 for (i = 0; i < mti->mti_nid_count; i++) {
1760 CDEBUG(D_MGS, "add nid %s\n", libcfs_nid2str(mti->mti_nids[i]));
1761 rc = record_add_uuid(obd, llh, mti->mti_nids[i], nodeuuid);
1763 rc = record_attach(obd, llh, oscname, LUSTRE_OSC_NAME, lovuuid);
1764 rc = record_setup(obd, llh, oscname, mti->mti_uuid, nodeuuid, 0, 0);
1765 rc = mgs_write_log_failnids(obd, mti, llh, oscname);
1766 snprintf(index, sizeof(index), "%d", mti->mti_stripe_index);
1767 rc = record_lov_add(obd, llh, lovname, mti->mti_uuid, index, "1");
1768 rc = record_marker(obd, llh, fsdb, CM_END | flags, mti->mti_svname,
1770 rc = record_end_log(obd, &llh);
1772 name_destroy(&lovuuid);
1773 name_destroy(&oscuuid);
1774 name_destroy(&oscname);
1775 name_destroy(&svname);
1776 name_destroy(&nodeuuid);
1780 static int mgs_write_log_ost(struct obd_device *obd, struct fs_db *fsdb,
1781 struct mgs_target_info *mti)
1783 struct llog_handle *llh = NULL;
1784 char *logname, *lovname;
1785 char *ptr = mti->mti_params;
1786 int rc, flags = 0, failout = 0, i;
1789 CDEBUG(D_MGS, "writing new ost %s\n", mti->mti_svname);
1791 /* The ost startup log */
1793 /* If the ost log already exists, that means that someone reformatted
1794 the ost and it called target_add again. */
1795 if (!mgs_log_is_empty(obd, mti->mti_svname)) {
1796 LCONSOLE_ERROR_MSG(0x141, "The config log for %s already "
1797 "exists, yet the server claims it never "
1798 "registered. It may have been reformatted, "
1799 "or the index changed. writeconf the MDT to "
1800 "regenerate all logs.\n", mti->mti_svname);
1805 attach obdfilter ost1 ost1_UUID
1806 setup /dev/loop2 ldiskfs f|n errors=remount-ro,user_xattr
1808 if (class_find_param(ptr, PARAM_FAILMODE, &ptr) == 0)
1809 failout = (strncmp(ptr, "failout", 7) == 0);
1810 rc = record_start_log(obd, &llh, mti->mti_svname);
1813 /* FIXME these should be a single journal transaction */
1814 rc = record_marker(obd, llh, fsdb, CM_START, mti->mti_svname,"add ost");
1815 if (*mti->mti_uuid == '\0')
1816 snprintf(mti->mti_uuid, sizeof(mti->mti_uuid),
1817 "%s_UUID", mti->mti_svname);
1818 rc = record_attach(obd, llh, mti->mti_svname,
1819 "obdfilter"/*LUSTRE_OST_NAME*/, mti->mti_uuid);
1820 rc = record_setup(obd, llh, mti->mti_svname,
1821 "dev"/*ignored*/, "type"/*ignored*/,
1822 failout ? "n" : "f", 0/*options*/);
1823 rc = record_marker(obd, llh, fsdb, CM_END, mti->mti_svname, "add ost");
1824 rc = record_end_log(obd, &llh);
1826 /* We also have to update the other logs where this osc is part of
1829 if (cfs_test_bit(FSDB_OLDLOG14, &fsdb->fsdb_flags)) {
1830 /* If we're upgrading, the old mdt log already has our
1831 entry. Let's do a fake one for fun. */
1832 /* Note that we can't add any new failnids, since we don't
1833 know the old osc names. */
1834 flags = CM_SKIP | CM_UPGRADE146;
1836 } else if ((mti->mti_flags & LDD_F_UPDATE) != LDD_F_UPDATE) {
1837 /* If the update flag isn't set, don't update client/mdt
1840 LCONSOLE_WARN("Client log for %s was not updated; writeconf "
1841 "the MDT first to regenerate it.\n",
1845 /* Add ost to all MDT lov defs */
1846 for (i = 0; i < INDEX_MAP_SIZE * 8; i++){
1847 if (cfs_test_bit(i, fsdb->fsdb_mdt_index_map)) {
1850 name_create_mdt_and_lov(&logname, &lovname, fsdb, i);
1851 sprintf(mdt_index, "-MDT%04x", i);
1852 mgs_write_log_osc_to_lov(obd, fsdb, mti, logname,
1854 LUSTRE_SP_MDT, flags);
1855 name_destroy(&logname);
1856 name_destroy(&lovname);
1860 /* Append ost info to the client log */
1861 name_create(&logname, mti->mti_fsname, "-client");
1862 if (mgs_log_is_empty(obd, logname)) {
1863 /* Start client log */
1864 rc = mgs_write_log_lov(obd, fsdb, mti, logname,
1866 rc = mgs_write_log_lmv(obd, fsdb, mti, logname,
1869 mgs_write_log_osc_to_lov(obd, fsdb, mti, logname, "",
1870 fsdb->fsdb_clilov, LUSTRE_SP_CLI, flags);
1871 name_destroy(&logname);
1875 static __inline__ int mgs_param_empty(char *ptr)
1879 if ((tmp = strchr(ptr, '=')) && (*(++tmp) == '\0'))
1884 static int mgs_write_log_failnid_internal(struct obd_device *obd,
1886 struct mgs_target_info *mti,
1887 char *logname, char *cliname)
1890 struct llog_handle *llh = NULL;
1892 if (mgs_param_empty(mti->mti_params)) {
1893 /* Remove _all_ failnids */
1894 rc = mgs_modify(obd, fsdb, mti, logname,
1895 mti->mti_svname, "add failnid", CM_SKIP);
1899 /* Otherwise failover nids are additive */
1900 rc = record_start_log(obd, &llh, logname);
1902 /* FIXME this should be a single journal transaction */
1903 rc = record_marker(obd, llh, fsdb, CM_START,
1904 mti->mti_svname, "add failnid");
1905 rc = mgs_write_log_failnids(obd, mti, llh, cliname);
1906 rc = record_marker(obd, llh, fsdb, CM_END,
1907 mti->mti_svname, "add failnid");
1908 rc = record_end_log(obd, &llh);
1915 /* Add additional failnids to an existing log.
1916 The mdc/osc must have been added to logs first */
1917 /* tcp nids must be in dotted-quad ascii -
1918 we can't resolve hostnames from the kernel. */
1919 static int mgs_write_log_add_failnid(struct obd_device *obd, struct fs_db *fsdb,
1920 struct mgs_target_info *mti)
1922 char *logname, *cliname;
1926 /* FIXME we currently can't erase the failnids
1927 * given when a target first registers, since they aren't part of
1928 * an "add uuid" stanza */
1930 /* Verify that we know about this target */
1931 if (mgs_log_is_empty(obd, mti->mti_svname)) {
1932 LCONSOLE_ERROR_MSG(0x142, "The target %s has not registered "
1933 "yet. It must be started before failnids "
1934 "can be added.\n", mti->mti_svname);
1938 /* Create mdc/osc client name (e.g. lustre-OST0001-osc) */
1939 if (mti->mti_flags & LDD_F_SV_TYPE_MDT) {
1940 name_create(&cliname, mti->mti_svname, "-mdc");
1941 } else if (mti->mti_flags & LDD_F_SV_TYPE_OST) {
1942 name_create(&cliname, mti->mti_svname, "-osc");
1947 /* Add failover nids to the client log */
1948 name_create(&logname, mti->mti_fsname, "-client");
1949 rc = mgs_write_log_failnid_internal(obd, fsdb, mti, logname, cliname);
1950 name_destroy(&logname);
1951 name_destroy(&cliname);
1953 if (mti->mti_flags & LDD_F_SV_TYPE_OST) {
1954 /* Add OST failover nids to the MDT logs as well */
1957 for (i = 0; i < INDEX_MAP_SIZE * 8; i++) {
1958 if (!cfs_test_bit(i, fsdb->fsdb_mdt_index_map))
1960 name_create_mdt(&logname, mti->mti_fsname, i);
1961 name_create_mdt_osc(&cliname, mti->mti_svname, fsdb, i);
1962 rc = mgs_write_log_failnid_internal(obd, fsdb, mti,
1964 name_destroy(&cliname);
1965 name_destroy(&logname);
1972 static int mgs_wlp_lcfg(struct obd_device *obd, struct fs_db *fsdb,
1973 struct mgs_target_info *mti,
1974 char *logname, struct lustre_cfg_bufs *bufs,
1975 char *tgtname, char *ptr)
1977 char comment[MTI_NAME_MAXLEN];
1979 struct lustre_cfg *lcfg;
1982 /* Erase any old settings of this same parameter */
1983 memcpy(comment, ptr, MTI_NAME_MAXLEN);
1984 comment[MTI_NAME_MAXLEN - 1] = 0;
1985 /* But don't try to match the value. */
1986 if ((tmp = strchr(comment, '=')))
1988 /* FIXME we should skip settings that are the same as old values */
1989 rc = mgs_modify(obd, fsdb, mti, logname, tgtname, comment, CM_SKIP);
1990 del = mgs_param_empty(ptr);
1992 LCONSOLE_INFO("%sing parameter %s.%s in log %s\n", del ? "Disabl" : rc ?
1993 "Sett" : "Modify", tgtname, comment, logname);
1997 lustre_cfg_bufs_reset(bufs, tgtname);
1998 lustre_cfg_bufs_set_string(bufs, 1, ptr);
1999 lcfg = lustre_cfg_new(LCFG_PARAM, bufs);
2002 rc = mgs_write_log_direct(obd, fsdb, logname, lcfg, tgtname, comment);
2003 lustre_cfg_free(lcfg);
2007 /* write global variable settings into log */
2008 static int mgs_write_log_sys(struct obd_device *obd, struct fs_db *fsdb,
2009 struct mgs_target_info *mti, char *sys, char *ptr)
2011 struct lustre_cfg_bufs bufs;
2012 struct lustre_cfg *lcfg;
2018 if (class_match_param(ptr, PARAM_TIMEOUT, &tmp) == 0)
2019 cmd = LCFG_SET_TIMEOUT;
2020 else if (class_match_param(ptr, PARAM_LDLM_TIMEOUT, &tmp) == 0)
2021 cmd = LCFG_SET_LDLM_TIMEOUT;
2022 /* Check for known params here so we can return error to lctl */
2023 else if ((class_match_param(ptr, PARAM_AT_MIN, &tmp) == 0)
2024 || (class_match_param(ptr, PARAM_AT_MAX, &tmp) == 0)
2025 || (class_match_param(ptr, PARAM_AT_EXTRA, &tmp) == 0)
2026 || (class_match_param(ptr, PARAM_AT_EARLY_MARGIN, &tmp) == 0)
2027 || (class_match_param(ptr, PARAM_AT_HISTORY, &tmp) == 0))
2032 /* separate the value */
2033 val = simple_strtoul(tmp, NULL, 0);
2035 CDEBUG(D_MGS, "global '%s' removed\n", sys);
2037 CDEBUG(D_MGS, "global '%s' val=%d\n", sys, val);
2039 lustre_cfg_bufs_reset(&bufs, NULL);
2040 lustre_cfg_bufs_set_string(&bufs, 1, sys);
2041 lcfg = lustre_cfg_new(cmd, &bufs);
2042 lcfg->lcfg_num = val;
2043 /* truncate the comment to the parameter name */
2047 /* modify all servers and clients */
2048 rc = mgs_write_log_direct_all(obd, fsdb, mti,
2049 *tmp == '\0' ? NULL : lcfg,
2050 mti->mti_fsname, sys);
2052 lustre_cfg_free(lcfg);
2056 static int mgs_srpc_set_param_disk(struct obd_device *obd,
2058 struct mgs_target_info *mti,
2061 struct llog_handle *llh = NULL;
2063 char *comment, *ptr;
2064 struct lustre_cfg_bufs bufs;
2065 struct lustre_cfg *lcfg;
2070 ptr = strchr(param, '=');
2074 OBD_ALLOC(comment, len + 1);
2075 if (comment == NULL)
2077 strncpy(comment, param, len);
2078 comment[len] = '\0';
2081 lustre_cfg_bufs_reset(&bufs, mti->mti_svname);
2082 lustre_cfg_bufs_set_string(&bufs, 1, param);
2083 lcfg = lustre_cfg_new(LCFG_SPTLRPC_CONF, &bufs);
2085 GOTO(out_comment, rc = -ENOMEM);
2087 /* construct log name */
2088 rc = name_create(&logname, mti->mti_fsname, "-sptlrpc");
2092 if (mgs_log_is_empty(obd, logname)) {
2093 rc = record_start_log(obd, &llh, logname);
2094 record_end_log(obd, &llh);
2099 /* obsolete old one */
2100 mgs_modify(obd, fsdb, mti, logname, mti->mti_svname, comment, CM_SKIP);
2102 /* write the new one */
2103 rc = mgs_write_log_direct(obd, fsdb, logname, lcfg,
2104 mti->mti_svname, comment);
2106 CERROR("err %d writing log %s\n", rc, logname);
2109 name_destroy(&logname);
2111 lustre_cfg_free(lcfg);
2113 OBD_FREE(comment, len + 1);
2117 static int mgs_srpc_set_param_udesc_mem(struct fs_db *fsdb,
2122 /* disable the adjustable udesc parameter for now, i.e. use default
2123 * setting that client always ship udesc to MDT if possible. to enable
2124 * it simply remove the following line */
2127 ptr = strchr(param, '=');
2132 if (strcmp(param, PARAM_SRPC_UDESC))
2135 if (strcmp(ptr, "yes") == 0) {
2136 cfs_set_bit(FSDB_UDESC, &fsdb->fsdb_flags);
2137 CWARN("Enable user descriptor shipping from client to MDT\n");
2138 } else if (strcmp(ptr, "no") == 0) {
2139 cfs_clear_bit(FSDB_UDESC, &fsdb->fsdb_flags);
2140 CWARN("Disable user descriptor shipping from client to MDT\n");
2148 CERROR("Invalid param: %s\n", param);
2152 static int mgs_srpc_set_param_mem(struct fs_db *fsdb,
2156 struct sptlrpc_rule rule;
2157 struct sptlrpc_rule_set *rset;
2161 if (strncmp(param, PARAM_SRPC, sizeof(PARAM_SRPC) - 1) != 0) {
2162 CERROR("Invalid sptlrpc parameter: %s\n", param);
2166 if (strncmp(param, PARAM_SRPC_UDESC,
2167 sizeof(PARAM_SRPC_UDESC) - 1) == 0) {
2168 RETURN(mgs_srpc_set_param_udesc_mem(fsdb, param));
2171 if (strncmp(param, PARAM_SRPC_FLVR, sizeof(PARAM_SRPC_FLVR) - 1) != 0) {
2172 CERROR("Invalid sptlrpc flavor parameter: %s\n", param);
2176 param += sizeof(PARAM_SRPC_FLVR) - 1;
2178 rc = sptlrpc_parse_rule(param, &rule);
2182 /* mgs rules implies must be mgc->mgs */
2183 if (cfs_test_bit(FSDB_MGS_SELF, &fsdb->fsdb_flags)) {
2184 if ((rule.sr_from != LUSTRE_SP_MGC &&
2185 rule.sr_from != LUSTRE_SP_ANY) ||
2186 (rule.sr_to != LUSTRE_SP_MGS &&
2187 rule.sr_to != LUSTRE_SP_ANY))
2191 /* preapre room for this coming rule. svcname format should be:
2192 * - fsname: general rule
2193 * - fsname-tgtname: target-specific rule
2195 if (strchr(svname, '-')) {
2196 struct mgs_tgt_srpc_conf *tgtconf;
2199 for (tgtconf = fsdb->fsdb_srpc_tgt; tgtconf != NULL;
2200 tgtconf = tgtconf->mtsc_next) {
2201 if (!strcmp(tgtconf->mtsc_tgt, svname)) {
2210 OBD_ALLOC_PTR(tgtconf);
2211 if (tgtconf == NULL)
2214 name_len = strlen(svname);
2216 OBD_ALLOC(tgtconf->mtsc_tgt, name_len + 1);
2217 if (tgtconf->mtsc_tgt == NULL) {
2218 OBD_FREE_PTR(tgtconf);
2221 memcpy(tgtconf->mtsc_tgt, svname, name_len);
2223 tgtconf->mtsc_next = fsdb->fsdb_srpc_tgt;
2224 fsdb->fsdb_srpc_tgt = tgtconf;
2227 rset = &tgtconf->mtsc_rset;
2229 rset = &fsdb->fsdb_srpc_gen;
2232 rc = sptlrpc_rule_set_merge(rset, &rule);
2237 static int mgs_srpc_set_param(struct obd_device *obd,
2239 struct mgs_target_info *mti,
2249 /* keep a copy of original param, which could be destroied
2251 copy_size = strlen(param) + 1;
2252 OBD_ALLOC(copy, copy_size);
2255 memcpy(copy, param, copy_size);
2257 rc = mgs_srpc_set_param_mem(fsdb, mti->mti_svname, param);
2261 /* previous steps guaranteed the syntax is correct */
2262 rc = mgs_srpc_set_param_disk(obd, fsdb, mti, copy);
2266 if (cfs_test_bit(FSDB_MGS_SELF, &fsdb->fsdb_flags)) {
2268 * for mgs rules, make them effective immediately.
2270 LASSERT(fsdb->fsdb_srpc_tgt == NULL);
2271 sptlrpc_target_update_exp_flavor(obd, &fsdb->fsdb_srpc_gen);
2275 OBD_FREE(copy, copy_size);
2279 struct mgs_srpc_read_data {
2280 struct fs_db *msrd_fsdb;
2284 static int mgs_srpc_read_handler(struct llog_handle *llh,
2285 struct llog_rec_hdr *rec,
2288 struct mgs_srpc_read_data *msrd = (struct mgs_srpc_read_data *) data;
2289 struct cfg_marker *marker;
2290 struct lustre_cfg *lcfg = (struct lustre_cfg *)(rec + 1);
2291 char *svname, *param;
2295 if (rec->lrh_type != OBD_CFG_REC) {
2296 CERROR("unhandled lrh_type: %#x\n", rec->lrh_type);
2300 cfg_len = rec->lrh_len - sizeof(struct llog_rec_hdr) -
2301 sizeof(struct llog_rec_tail);
2303 rc = lustre_cfg_sanity_check(lcfg, cfg_len);
2305 CERROR("Insane cfg\n");
2309 if (lcfg->lcfg_command == LCFG_MARKER) {
2310 marker = lustre_cfg_buf(lcfg, 1);
2312 if (marker->cm_flags & CM_START &&
2313 marker->cm_flags & CM_SKIP)
2314 msrd->msrd_skip = 1;
2315 if (marker->cm_flags & CM_END)
2316 msrd->msrd_skip = 0;
2321 if (msrd->msrd_skip)
2324 if (lcfg->lcfg_command != LCFG_SPTLRPC_CONF) {
2325 CERROR("invalid command (%x)\n", lcfg->lcfg_command);
2329 svname = lustre_cfg_string(lcfg, 0);
2330 if (svname == NULL) {
2331 CERROR("svname is empty\n");
2335 param = lustre_cfg_string(lcfg, 1);
2336 if (param == NULL) {
2337 CERROR("param is empty\n");
2341 rc = mgs_srpc_set_param_mem(msrd->msrd_fsdb, svname, param);
2343 CERROR("read sptlrpc record error (%d): %s\n", rc, param);
2348 int mgs_get_fsdb_srpc_from_llog(struct obd_device *obd,
2351 struct llog_handle *llh = NULL;
2352 struct lvfs_run_ctxt saved;
2353 struct llog_ctxt *ctxt;
2355 struct mgs_srpc_read_data msrd;
2359 /* construct log name */
2360 rc = name_create(&logname, fsdb->fsdb_name, "-sptlrpc");
2364 ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT);
2365 LASSERT(ctxt != NULL);
2367 if (mgs_log_is_empty(obd, logname))
2370 push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
2372 rc = llog_create(ctxt, &llh, NULL, logname);
2376 rc = llog_init_handle(llh, LLOG_F_IS_PLAIN, NULL);
2378 GOTO(out_close, rc);
2380 if (llog_get_size(llh) <= 1)
2381 GOTO(out_close, rc = 0);
2383 msrd.msrd_fsdb = fsdb;
2386 rc = llog_process(llh, mgs_srpc_read_handler, (void *) &msrd, NULL);
2391 pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
2393 llog_ctxt_put(ctxt);
2394 name_destroy(&logname);
2397 CERROR("failed to read sptlrpc config database: %d\n", rc);
2401 /* Permanent settings of all parameters by writing into the appropriate
2402 * configuration logs.
2403 * A parameter with null value ("<param>='\0'") means to erase it out of
2406 static int mgs_write_log_param(struct obd_device *obd, struct fs_db *fsdb,
2407 struct mgs_target_info *mti, char *ptr)
2409 struct lustre_cfg_bufs bufs;
2412 int rc = 0, rc2 = 0;
2415 /* For various parameter settings, we have to figure out which logs
2416 care about them (e.g. both mdt and client for lov settings) */
2417 CDEBUG(D_MGS, "next param '%s'\n", ptr);
2419 /* The params are stored in MOUNT_DATA_FILE and modified via
2420 tunefs.lustre, or set using lctl conf_param */
2422 /* Processed in lustre_start_mgc */
2423 if (class_match_param(ptr, PARAM_MGSNODE, NULL) == 0)
2426 /* Processed in ost/mdt */
2427 if (class_match_param(ptr, PARAM_NETWORK, NULL) == 0)
2430 /* Processed in mgs_write_log_ost */
2431 if (class_match_param(ptr, PARAM_FAILMODE, NULL) == 0) {
2432 if (mti->mti_flags & LDD_F_PARAM) {
2433 LCONSOLE_ERROR_MSG(0x169, "%s can only be "
2434 "changed with tunefs.lustre"
2435 "and --writeconf\n", ptr);
2441 if (class_match_param(ptr, PARAM_SRPC, NULL) == 0) {
2442 rc = mgs_srpc_set_param(obd, fsdb, mti, ptr);
2446 if (class_match_param(ptr, PARAM_FAILNODE, NULL) == 0) {
2447 /* Add a failover nidlist */
2449 /* We already processed failovers params for new
2450 targets in mgs_write_log_target */
2451 if (mti->mti_flags & LDD_F_PARAM) {
2452 CDEBUG(D_MGS, "Adding failnode\n");
2453 rc = mgs_write_log_add_failnid(obd, fsdb, mti);
2458 if (class_match_param(ptr, PARAM_SYS, &tmp) == 0) {
2459 rc = mgs_write_log_sys(obd, fsdb, mti, ptr, tmp);
2463 if (class_match_param(ptr, PARAM_OSC""PARAM_ACTIVE, &tmp) == 0) {
2464 /* active=0 means off, anything else means on */
2465 int flag = (*tmp == '0') ? CM_EXCLUDE : 0;
2468 if (!(mti->mti_flags & LDD_F_SV_TYPE_OST)) {
2469 LCONSOLE_ERROR_MSG(0x144, "%s: Only OSCs can "
2470 "be (de)activated.\n",
2472 GOTO(end, rc = -EINVAL);
2474 LCONSOLE_WARN("Permanently %sactivating %s\n",
2475 flag ? "de": "re", mti->mti_svname);
2477 name_create(&logname, mti->mti_fsname, "-client");
2478 rc = mgs_modify(obd, fsdb, mti, logname,
2479 mti->mti_svname, "add osc", flag);
2480 name_destroy(&logname);
2484 /* Add to all MDT logs for CMD */
2485 for (i = 0; i < INDEX_MAP_SIZE * 8; i++) {
2486 if (!cfs_test_bit(i, fsdb->fsdb_mdt_index_map))
2488 name_create_mdt(&logname, mti->mti_fsname, i);
2489 rc = mgs_modify(obd, fsdb, mti, logname,
2490 mti->mti_svname, "add osc", flag);
2491 name_destroy(&logname);
2497 LCONSOLE_ERROR_MSG(0x145, "Couldn't find %s in"
2498 "log (%d). No permanent "
2499 "changes were made to the "
2501 mti->mti_svname, rc);
2502 if (cfs_test_bit(FSDB_OLDLOG14, &fsdb->fsdb_flags))
2503 LCONSOLE_ERROR_MSG(0x146, "This may be"
2508 "update the logs.\n");
2511 /* Fall through to osc proc for deactivating live OSC
2512 on running MDT / clients. */
2514 /* Below here, let obd's XXX_process_config methods handle it */
2516 /* All lov. in proc */
2517 if (class_match_param(ptr, PARAM_LOV, NULL) == 0) {
2520 CDEBUG(D_MGS, "lov param %s\n", ptr);
2521 if (!(mti->mti_flags & LDD_F_SV_TYPE_MDT)) {
2522 LCONSOLE_ERROR_MSG(0x147, "LOV params must be "
2523 "set on the MDT, not %s. "
2530 if (mgs_log_is_empty(obd, mti->mti_svname))
2531 GOTO(end, rc = -ENODEV);
2533 name_create_mdt_and_lov(&logname, &mdtlovname, fsdb,
2534 mti->mti_stripe_index);
2535 rc = mgs_wlp_lcfg(obd, fsdb, mti, mti->mti_svname,
2536 &bufs, mdtlovname, ptr);
2537 name_destroy(&logname);
2538 name_destroy(&mdtlovname);
2543 name_create(&logname, mti->mti_fsname, "-client");
2544 rc = mgs_wlp_lcfg(obd, fsdb, mti, logname, &bufs,
2545 fsdb->fsdb_clilov, ptr);
2546 name_destroy(&logname);
2550 /* All osc., mdc., llite. params in proc */
2551 if ((class_match_param(ptr, PARAM_OSC, NULL) == 0) ||
2552 (class_match_param(ptr, PARAM_MDC, NULL) == 0) ||
2553 (class_match_param(ptr, PARAM_LLITE, NULL) == 0)) {
2555 if (memcmp(ptr, PARAM_LLITE, strlen(PARAM_LLITE)) == 0) {
2556 name_create(&cname, mti->mti_fsname, "-client");
2557 /* Add the client type to match the obdname in
2558 class_config_llog_handler */
2559 } else if (mti->mti_flags & LDD_F_SV_TYPE_MDT) {
2562 name_create(&cname, fsdb->fsdb_mdc, "");
2564 name_create(&cname, mti->mti_svname,
2566 } else if (mti->mti_flags & LDD_F_SV_TYPE_OST) {
2568 if (cfs_test_bit(FSDB_OLDLOG14, &fsdb->fsdb_flags)) {
2569 LCONSOLE_ERROR_MSG(0x148, "Upgraded "
2570 "client logs for %s"
2572 "modified. Consider"
2574 "configuration with"
2577 /* We don't know the names of all the
2579 GOTO(end, rc = -EINVAL);
2581 name_create(&cname, mti->mti_svname, "-osc");
2583 GOTO(end, rc = -EINVAL);
2586 CDEBUG(D_MGS, "%.3s param %s\n", ptr, ptr + 4);
2589 name_create(&logname, mti->mti_fsname, "-client");
2590 rc = mgs_wlp_lcfg(obd, fsdb, mti, logname, &bufs,
2593 /* osc params affect the MDT as well */
2594 if (!rc && (mti->mti_flags & LDD_F_SV_TYPE_OST)) {
2597 for (i = 0; i < INDEX_MAP_SIZE * 8; i++){
2598 if (!cfs_test_bit(i, fsdb->fsdb_mdt_index_map))
2600 name_destroy(&cname);
2601 name_create_mdt_osc(&cname, mti->mti_svname,
2603 name_destroy(&logname);
2604 name_create_mdt(&logname, mti->mti_fsname, i);
2605 if (!mgs_log_is_empty(obd, logname))
2606 rc = mgs_wlp_lcfg(obd, fsdb,mti,logname,
2612 name_destroy(&logname);
2613 name_destroy(&cname);
2617 /* All mdt. params in proc */
2618 if (class_match_param(ptr, PARAM_MDT, NULL) == 0) {
2622 CDEBUG(D_MGS, "%.3s param %s\n", ptr, ptr + 4);
2623 if (strncmp(mti->mti_svname, mti->mti_fsname,
2624 MTI_NAME_MAXLEN) == 0)
2625 /* device is unspecified completely? */
2626 rc = LDD_F_SV_TYPE_MDT | LDD_F_SV_ALL;
2628 rc = server_name2index(mti->mti_svname, &idx, NULL);
2631 if ((rc & LDD_F_SV_TYPE_MDT) == 0)
2633 if (rc & LDD_F_SV_ALL) {
2634 for (i = 0; i < INDEX_MAP_SIZE * 8; i++) {
2635 if (!cfs_test_bit(i,
2636 fsdb->fsdb_mdt_index_map))
2638 name_create_mdt(&logname, mti->mti_fsname, i);
2639 rc = mgs_wlp_lcfg(obd, fsdb, mti,
2642 name_destroy(&logname);
2647 rc = mgs_wlp_lcfg(obd, fsdb, mti,
2648 mti->mti_svname, &bufs,
2649 mti->mti_svname, ptr);
2656 /* All mdd., ost. params in proc */
2657 if ((class_match_param(ptr, PARAM_MDD, NULL) == 0) ||
2658 (class_match_param(ptr, PARAM_OST, NULL) == 0)) {
2659 CDEBUG(D_MGS, "%.3s param %s\n", ptr, ptr + 4);
2660 if (mgs_log_is_empty(obd, mti->mti_svname))
2661 GOTO(end, rc = -ENODEV);
2663 rc = mgs_wlp_lcfg(obd, fsdb, mti, mti->mti_svname,
2664 &bufs, mti->mti_svname, ptr);
2668 LCONSOLE_WARN("Ignoring unrecognized param '%s'\n", ptr);
2673 CERROR("err %d on param '%s'\n", rc, ptr);
2678 /* Not implementing automatic failover nid addition at this time. */
2679 int mgs_check_failnid(struct obd_device *obd, struct mgs_target_info *mti)
2686 rc = mgs_find_or_make_fsdb(obd, fsname, &fsdb);
2690 if (mgs_log_is_empty(obd, mti->mti_svname))
2691 /* should never happen */
2694 CDEBUG(D_MGS, "Checking for new failnids for %s\n", mti->mti_svname);
2696 /* FIXME We can just check mti->params to see if we're already in
2697 the failover list. Modify mti->params for rewriting back at
2698 server_register_target(). */
2700 cfs_mutex_lock(&fsdb->fsdb_mutex);
2701 rc = mgs_write_log_add_failnid(obd, fsdb, mti);
2702 cfs_mutex_unlock(&fsdb->fsdb_mutex);
2709 int mgs_write_log_target(struct obd_device *obd,
2710 struct mgs_target_info *mti,
2717 /* set/check the new target index */
2718 rc = mgs_set_index(obd, mti);
2720 CERROR("Can't get index (%d)\n", rc);
2725 if (mti->mti_flags & LDD_F_UPGRADE14) {
2726 if (rc == EALREADY) {
2727 LCONSOLE_INFO("Found index %d for %s 1.4 log, "
2728 "upgrading\n", mti->mti_stripe_index,
2731 LCONSOLE_ERROR_MSG(0x149, "Failed to find %s in the old"
2732 " client log. Apparently it is not "
2733 "part of this filesystem, or the old"
2734 " log is wrong.\nUse 'writeconf' on "
2735 "the MDT to force log regeneration."
2736 "\n", mti->mti_svname);
2737 /* Not in client log? Upgrade anyhow...*/
2738 /* Argument against upgrading: reformat MDT,
2739 upgrade OST, then OST will start but will be SKIPped
2740 in client logs. Maybe error now is better. */
2741 /* RETURN(-EINVAL); */
2743 /* end COMPAT_146 */
2745 if (rc == EALREADY) {
2746 LCONSOLE_WARN("Found index %d for %s, updating log\n",
2747 mti->mti_stripe_index, mti->mti_svname);
2748 /* We would like to mark old log sections as invalid
2749 and add new log sections in the client and mdt logs.
2750 But if we add new sections, then live clients will
2751 get repeat setup instructions for already running
2752 osc's. So don't update the client/mdt logs. */
2753 mti->mti_flags &= ~LDD_F_UPDATE;
2757 cfs_mutex_lock(&fsdb->fsdb_mutex);
2759 if (mti->mti_flags &
2760 (LDD_F_VIRGIN | LDD_F_UPGRADE14 | LDD_F_WRITECONF)) {
2761 /* Generate a log from scratch */
2762 if (mti->mti_flags & LDD_F_SV_TYPE_MDT) {
2763 rc = mgs_write_log_mdt(obd, fsdb, mti);
2764 } else if (mti->mti_flags & LDD_F_SV_TYPE_OST) {
2765 rc = mgs_write_log_ost(obd, fsdb, mti);
2767 CERROR("Unknown target type %#x, can't create log for "
2768 "%s\n", mti->mti_flags, mti->mti_svname);
2771 CERROR("Can't write logs for %s (%d)\n",
2772 mti->mti_svname, rc);
2776 /* Just update the params from tunefs in mgs_write_log_params */
2777 CDEBUG(D_MGS, "Update params for %s\n", mti->mti_svname);
2778 mti->mti_flags |= LDD_F_PARAM;
2781 /* allocate temporary buffer, where class_get_next_param will
2782 make copy of a current parameter */
2783 OBD_ALLOC(buf, strlen(mti->mti_params) + 1);
2785 GOTO(out_up, rc = -ENOMEM);
2786 params = mti->mti_params;
2787 while (params != NULL) {
2788 rc = class_get_next_param(¶ms, buf);
2791 /* there is no next parameter, that is
2796 CDEBUG(D_MGS, "remaining string: '%s', param: '%s'\n",
2798 rc = mgs_write_log_param(obd, fsdb, mti, buf);
2803 OBD_FREE(buf, strlen(mti->mti_params) + 1);
2806 cfs_mutex_unlock(&fsdb->fsdb_mutex);
2811 /* verify that we can handle the old config logs */
2812 int mgs_upgrade_sv_14(struct obd_device *obd, struct mgs_target_info *mti,
2818 /* Create ost log normally, as servers register. Servers
2819 register with their old uuids (from last_rcvd), so old
2820 (MDT and client) logs should work.
2821 - new MDT won't know about old OSTs, only the ones that have
2822 registered, so we need the old MDT log to get the LOV right
2823 in order for old clients to work.
2824 - Old clients connect to the MDT, not the MGS, for their logs, and
2825 will therefore receive the old client log from the MDT /LOGS dir.
2826 - Old clients can continue to use and connect to old or new OSTs
2827 - New clients will contact the MGS for their log
2830 LCONSOLE_INFO("upgrading server %s from pre-1.6\n", mti->mti_svname);
2831 server_mti_print("upgrade", mti);
2833 if (cfs_test_bit(FSDB_LOG_EMPTY, &fsdb->fsdb_flags)) {
2834 LCONSOLE_ERROR_MSG(0x14a, "The old client log %s-client is "
2835 "missing. Was tunefs.lustre successful?\n",
2840 if (fsdb->fsdb_gen == 0) {
2841 /* There were no markers in the client log, meaning we have
2842 not updated the logs for this fs */
2843 CDEBUG(D_MGS, "found old, unupdated client log\n");
2846 if (mti->mti_flags & LDD_F_SV_TYPE_MDT) {
2847 if (mgs_log_is_empty(obd, mti->mti_svname)) {
2848 LCONSOLE_ERROR_MSG(0x14b, "The old MDT log %s is "
2849 "missing. Was tunefs.lustre "
2854 /* We're starting with an old uuid. Assume old name for lov
2855 as well since the lov entry already exists in the log. */
2856 CDEBUG(D_MGS, "old mds uuid %s\n", mti->mti_uuid);
2857 if (strncmp(mti->mti_uuid, fsdb->fsdb_mdtlov + 4,
2858 strlen(fsdb->fsdb_mdtlov) - 4) != 0) {
2859 CERROR("old mds uuid %s doesn't match log %s (%s)\n",
2860 mti->mti_uuid, fsdb->fsdb_mdtlov,
2861 fsdb->fsdb_mdtlov + 4);
2866 if (!cfs_test_bit(FSDB_OLDLOG14, &fsdb->fsdb_flags)) {
2867 LCONSOLE_ERROR_MSG(0x14c, "%s-client is supposedly an old "
2868 "log, but no old LOV or MDT was found. "
2869 "Consider updating the configuration with"
2870 " --writeconf.\n", mti->mti_fsname);
2875 /* end COMPAT_146 */
2877 int mgs_erase_log(struct obd_device *obd, char *name)
2879 struct lvfs_run_ctxt saved;
2880 struct llog_ctxt *ctxt;
2881 struct llog_handle *llh;
2884 ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT);
2885 LASSERT(ctxt != NULL);
2887 push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
2888 rc = llog_create(ctxt, &llh, NULL, name);
2890 llog_init_handle(llh, LLOG_F_IS_PLAIN, NULL);
2891 rc = llog_destroy(llh);
2892 llog_free_handle(llh);
2894 pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
2895 llog_ctxt_put(ctxt);
2898 CERROR("failed to clear log %s: %d\n", name, rc);
2903 /* erase all logs for the given fs */
2904 int mgs_erase_logs(struct obd_device *obd, char *fsname)
2906 struct mgs_obd *mgs = &obd->u.mgs;
2908 cfs_list_t dentry_list;
2909 struct l_linux_dirent *dirent, *n;
2910 int rc, len = strlen(fsname);
2914 /* Find all the logs in the CONFIGS directory */
2915 rc = class_dentry_readdir(obd, mgs->mgs_configs_dir,
2916 mgs->mgs_vfsmnt, &dentry_list);
2918 CERROR("Can't read %s dir\n", MOUNT_CONFIGS_DIR);
2922 cfs_mutex_lock(&mgs->mgs_mutex);
2924 /* Delete the fs db */
2925 fsdb = mgs_find_fsdb(obd, fsname);
2927 mgs_free_fsdb(obd, fsdb);
2929 cfs_list_for_each_entry_safe(dirent, n, &dentry_list, lld_list) {
2930 cfs_list_del(&dirent->lld_list);
2931 suffix = strrchr(dirent->lld_name, '-');
2932 if (suffix != NULL) {
2933 if ((len == suffix - dirent->lld_name) &&
2934 (strncmp(fsname, dirent->lld_name, len) == 0)) {
2935 CDEBUG(D_MGS, "Removing log %s\n",
2937 mgs_erase_log(obd, dirent->lld_name);
2940 OBD_FREE(dirent, sizeof(*dirent));
2943 cfs_mutex_unlock(&mgs->mgs_mutex);
2948 /* from llog_swab */
2949 static void print_lustre_cfg(struct lustre_cfg *lcfg)
2954 CDEBUG(D_MGS, "lustre_cfg: %p\n", lcfg);
2955 CDEBUG(D_MGS, "\tlcfg->lcfg_version: %#x\n", lcfg->lcfg_version);
2957 CDEBUG(D_MGS, "\tlcfg->lcfg_command: %#x\n", lcfg->lcfg_command);
2958 CDEBUG(D_MGS, "\tlcfg->lcfg_num: %#x\n", lcfg->lcfg_num);
2959 CDEBUG(D_MGS, "\tlcfg->lcfg_flags: %#x\n", lcfg->lcfg_flags);
2960 CDEBUG(D_MGS, "\tlcfg->lcfg_nid: %s\n", libcfs_nid2str(lcfg->lcfg_nid));
2962 CDEBUG(D_MGS, "\tlcfg->lcfg_bufcount: %d\n", lcfg->lcfg_bufcount);
2963 if (lcfg->lcfg_bufcount < LUSTRE_CFG_MAX_BUFCOUNT)
2964 for (i = 0; i < lcfg->lcfg_bufcount; i++) {
2965 CDEBUG(D_MGS, "\tlcfg->lcfg_buflens[%d]: %d %s\n",
2966 i, lcfg->lcfg_buflens[i],
2967 lustre_cfg_string(lcfg, i));
2972 /* Set a permanent (config log) param for a target or fs
2973 * \param lcfg buf0 may contain the device (testfs-MDT0000) name
2974 * buf1 contains the single parameter
2976 int mgs_setparam(struct obd_device *obd, struct lustre_cfg *lcfg, char *fsname)
2979 struct mgs_target_info *mti;
2980 char *devname, *param;
2986 print_lustre_cfg(lcfg);
2988 /* lustre, lustre-mdtlov, lustre-client, lustre-MDT0000 */
2989 devname = lustre_cfg_string(lcfg, 0);
2990 param = lustre_cfg_string(lcfg, 1);
2992 /* Assume device name embedded in param:
2993 lustre-OST0000.osc.max_dirty_mb=32 */
2994 ptr = strchr(param, '.');
3002 LCONSOLE_ERROR_MSG(0x14d, "No target specified: %s\n", param);
3006 /* Extract fsname */
3007 ptr = strrchr(devname, '-');
3008 memset(fsname, 0, MTI_NAME_MAXLEN);
3009 if (ptr && (server_name2index(ptr, &index, NULL) >= 0)) {
3010 /* param related to llite isn't allowed to set by OST or MDT */
3011 if (strncmp(param, PARAM_LLITE, sizeof(PARAM_LLITE)) == 0)
3014 strncpy(fsname, devname, ptr - devname);
3016 /* assume devname is the fsname */
3017 strncpy(fsname, devname, MTI_NAME_MAXLEN);
3019 fsname[MTI_NAME_MAXLEN - 1] = 0;
3020 CDEBUG(D_MGS, "setparam fs='%s' device='%s'\n", fsname, devname);
3022 rc = mgs_find_or_make_fsdb(obd, fsname, &fsdb);
3025 if (!cfs_test_bit(FSDB_MGS_SELF, &fsdb->fsdb_flags) &&
3026 cfs_test_bit(FSDB_LOG_EMPTY, &fsdb->fsdb_flags)) {
3027 CERROR("No filesystem targets for %s. cfg_device from lctl "
3028 "is '%s'\n", fsname, devname);
3029 mgs_free_fsdb(obd, fsdb);
3033 /* Create a fake mti to hold everything */
3036 GOTO(out, rc = -ENOMEM);
3037 strncpy(mti->mti_fsname, fsname, MTI_NAME_MAXLEN);
3038 strncpy(mti->mti_svname, devname, MTI_NAME_MAXLEN);
3039 strncpy(mti->mti_params, param, sizeof(mti->mti_params));
3040 rc = server_name2index(mti->mti_svname, &mti->mti_stripe_index, &tmp);
3042 /* Not a valid server; may be only fsname */
3045 /* Strip -osc or -mdc suffix from svname */
3046 if (server_make_name(rc, mti->mti_stripe_index, mti->mti_fsname,
3048 GOTO(out, rc = -EINVAL);
3050 mti->mti_flags = rc | LDD_F_PARAM;
3052 cfs_mutex_lock(&fsdb->fsdb_mutex);
3053 rc = mgs_write_log_param(obd, fsdb, mti, mti->mti_params);
3054 cfs_mutex_unlock(&fsdb->fsdb_mutex);
3057 * Revoke lock so everyone updates. Should be alright if
3058 * someone was already reading while we were updating the logs,
3059 * so we don't really need to hold the lock while we're
3062 mgs_revoke_lock(obd, fsdb, CONFIG_T_CONFIG);
3068 static int mgs_write_log_pool(struct obd_device *obd, char *logname,
3069 struct fs_db *fsdb, char *lovname,
3070 enum lcfg_command_type cmd,
3071 char *poolname, char *fsname,
3072 char *ostname, char *comment)
3074 struct llog_handle *llh = NULL;
3077 rc = record_start_log(obd, &llh, logname);
3080 rc = record_marker(obd, llh, fsdb, CM_START, lovname, comment);
3081 record_base(obd, llh, lovname, 0, cmd, poolname, fsname, ostname, 0);
3082 rc = record_marker(obd, llh, fsdb, CM_END, lovname, comment);
3083 rc = record_end_log(obd, &llh);
3088 int mgs_pool_cmd(struct obd_device *obd, enum lcfg_command_type cmd,
3089 char *fsname, char *poolname, char *ostname)
3094 char *label = NULL, *canceled_label = NULL;
3096 struct mgs_target_info *mti = NULL;
3100 rc = mgs_find_or_make_fsdb(obd, fsname, &fsdb);
3102 CERROR("Can't get db for %s\n", fsname);
3105 if (cfs_test_bit(FSDB_LOG_EMPTY, &fsdb->fsdb_flags)) {
3106 CERROR("%s is not defined\n", fsname);
3107 mgs_free_fsdb(obd, fsdb);
3111 label_sz = 10 + strlen(fsname) + strlen(poolname);
3113 /* check if ostname match fsname */
3114 if (ostname != NULL) {
3117 ptr = strrchr(ostname, '-');
3118 if ((ptr == NULL) ||
3119 (strncmp(fsname, ostname, ptr-ostname) != 0))
3121 label_sz += strlen(ostname);
3124 OBD_ALLOC(label, label_sz);
3126 GOTO(out, rc = -ENOMEM);
3129 case LCFG_POOL_NEW: {
3131 "new %s.%s", fsname, poolname);
3134 case LCFG_POOL_ADD: {
3136 "add %s.%s.%s", fsname, poolname, ostname);
3139 case LCFG_POOL_REM: {
3140 OBD_ALLOC(canceled_label, label_sz);
3141 if (canceled_label == NULL)
3142 GOTO(out, rc = -ENOMEM);
3144 "rem %s.%s.%s", fsname, poolname, ostname);
3145 sprintf(canceled_label,
3146 "add %s.%s.%s", fsname, poolname, ostname);
3149 case LCFG_POOL_DEL: {
3150 OBD_ALLOC(canceled_label, label_sz);
3151 if (canceled_label == NULL)
3152 GOTO(out, rc = -ENOMEM);
3154 "del %s.%s", fsname, poolname);
3155 sprintf(canceled_label,
3156 "new %s.%s", fsname, poolname);
3164 cfs_mutex_lock(&fsdb->fsdb_mutex);
3166 if (canceled_label != NULL) {
3169 GOTO(out, rc = -ENOMEM);
3172 /* write pool def to all MDT logs */
3173 for (i = 0; i < INDEX_MAP_SIZE * 8; i++) {
3174 if (cfs_test_bit(i, fsdb->fsdb_mdt_index_map)) {
3175 name_create_mdt_and_lov(&logname, &lovname, fsdb, i);
3177 if (canceled_label != NULL) {
3178 strcpy(mti->mti_svname, "lov pool");
3179 mgs_modify(obd, fsdb, mti, logname, lovname,
3180 canceled_label, CM_SKIP);
3183 mgs_write_log_pool(obd, logname, fsdb, lovname,
3184 cmd, fsname, poolname, ostname,
3186 name_destroy(&logname);
3187 name_destroy(&lovname);
3191 name_create(&logname, fsname, "-client");
3192 if (canceled_label != NULL)
3193 mgs_modify(obd, fsdb, mti, logname, fsdb->fsdb_clilov,
3194 canceled_label, CM_SKIP);
3196 mgs_write_log_pool(obd, logname, fsdb, fsdb->fsdb_clilov,
3197 cmd, fsname, poolname, ostname, label);
3198 name_destroy(&logname);
3200 cfs_mutex_unlock(&fsdb->fsdb_mutex);
3201 /* request for update */
3202 mgs_revoke_lock(obd, fsdb, CONFIG_T_CONFIG);
3207 OBD_FREE(label, label_sz);
3209 if (canceled_label != NULL)
3210 OBD_FREE(canceled_label, label_sz);
3219 /******************** unused *********************/
3220 static int mgs_backup_llog(struct obd_device *obd, char* fsname)
3222 struct file *filp, *bak_filp;
3223 struct lvfs_run_ctxt saved;
3224 char *logname, *buf;
3225 loff_t soff = 0 , doff = 0;
3226 int count = 4096, len;
3229 OBD_ALLOC(logname, PATH_MAX);
3230 if (logname == NULL)
3233 OBD_ALLOC(buf, count);
3235 GOTO(out , rc = -ENOMEM);
3237 len = snprintf(logname, PATH_MAX, "%s/%s.bak",
3238 MOUNT_CONFIGS_DIR, fsname);
3240 if (len >= PATH_MAX - 1) {
3241 GOTO(out, -ENAMETOOLONG);
3244 push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
3246 bak_filp = l_filp_open(logname, O_RDWR|O_CREAT|O_TRUNC, 0660);
3247 if (IS_ERR(bak_filp)) {
3248 rc = PTR_ERR(bak_filp);
3249 CERROR("backup logfile open %s: %d\n", logname, rc);
3252 sprintf(logname, "%s/%s", MOUNT_CONFIGS_DIR, fsname);
3253 filp = l_filp_open(logname, O_RDONLY, 0);
3256 CERROR("logfile open %s: %d\n", logname, rc);
3260 while ((rc = lustre_fread(filp, buf, count, &soff)) > 0) {
3261 rc = lustre_fwrite(bak_filp, buf, count, &doff);
3265 filp_close(filp, 0);
3267 filp_close(bak_filp, 0);
3269 pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
3272 OBD_FREE(buf, count);
3273 OBD_FREE(logname, PATH_MAX);