4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
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.
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).
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
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
27 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
28 * Use is subject to license terms.
30 * Copyright (c) 2011, Whamcloud, Inc.
33 * This file is part of Lustre, http://www.lustre.org/
34 * Lustre is a trademark of Sun Microsystems, Inc.
36 * lustre/mgs/mgs_llog.c
38 * Lustre Management Server (mgs) config llog creation
40 * Author: Nathan Rutman <nathan@clusterfs.com>
46 #define DEBUG_SUBSYSTEM S_MGS
47 #define D_MGS D_CONFIG
50 #include <linux/module.h>
51 #include <linux/pagemap.h>
57 #include <obd_class.h>
58 #include <lustre_log.h>
60 #include <libcfs/list.h>
61 #include <linux/lvfs.h>
62 #include <lustre_fsfilt.h>
63 #include <lustre_disk.h>
64 #include <lustre_param.h>
65 #include <lustre_sec.h>
66 #include "mgs_internal.h"
68 /********************** Class functions ********************/
70 /* Caller must list_del and OBD_FREE each dentry from the list */
71 int class_dentry_readdir(struct obd_device *obd, struct dentry *dir,
72 struct vfsmount *inmnt,
73 cfs_list_t *dentry_list){
74 /* see mds_cleanup_pending */
75 struct lvfs_run_ctxt saved;
77 struct dentry *dentry;
82 push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
85 GOTO(out_pop, rc = PTR_ERR(dentry));
89 GOTO(out_pop, rc = PTR_ERR(mnt));
92 file = ll_dentry_open(dentry, mnt, O_RDONLY, current_cred());
94 /* dentry_open_it() drops the dentry, mnt refs */
95 GOTO(out_pop, rc = PTR_ERR(file));
97 CFS_INIT_LIST_HEAD(dentry_list);
98 rc = l_readdir(file, dentry_list);
100 /* filp_close->fput() drops the dentry, mnt refs */
103 pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
107 /******************** DB functions *********************/
109 static inline int name_create(char **newname, char *prefix, char *suffix)
112 OBD_ALLOC(*newname, strlen(prefix) + strlen(suffix) + 1);
115 sprintf(*newname, "%s%s", prefix, suffix);
119 static inline void name_destroy(char **name)
122 OBD_FREE(*name, strlen(*name) + 1);
126 struct mgs_fsdb_handler_data
132 /* from the (client) config log, figure out:
133 1. which ost's/mdt's are configured (by index)
134 2. what the last config step is
135 3. COMPAT_146 lov name
136 4. COMPAT_146 mdt lov name
137 5. COMPAT_146 mdc name
138 6. COMPAT_18 osc name
140 /* It might be better to have a separate db file, instead of parsing the info
141 out of the client log. This is slow and potentially error-prone. */
142 static int mgs_fsdb_handler(struct llog_handle *llh, struct llog_rec_hdr *rec,
145 struct mgs_fsdb_handler_data *d = (struct mgs_fsdb_handler_data *) data;
146 struct fs_db *fsdb = d->fsdb;
147 int cfg_len = rec->lrh_len;
148 char *cfg_buf = (char*) (rec + 1);
149 struct lustre_cfg *lcfg;
154 if (rec->lrh_type != OBD_CFG_REC) {
155 CERROR("unhandled lrh_type: %#x\n", rec->lrh_type);
159 rc = lustre_cfg_sanity_check(cfg_buf, cfg_len);
161 CERROR("Insane cfg\n");
165 lcfg = (struct lustre_cfg *)cfg_buf;
167 CDEBUG(D_INFO, "cmd %x %s %s\n", lcfg->lcfg_command,
168 lustre_cfg_string(lcfg, 0), lustre_cfg_string(lcfg, 1));
170 /* Figure out ost indicies */
171 /* lov_modify_tgts add 0:lov1 1:ost1_UUID 2(index):0 3(gen):1 */
172 if (lcfg->lcfg_command == LCFG_LOV_ADD_OBD ||
173 lcfg->lcfg_command == LCFG_LOV_DEL_OBD) {
174 index = simple_strtoul(lustre_cfg_string(lcfg, 2),
176 CDEBUG(D_MGS, "OST index for %s is %u (%s)\n",
177 lustre_cfg_string(lcfg, 1), index,
178 lustre_cfg_string(lcfg, 2));
179 cfs_set_bit(index, fsdb->fsdb_ost_index_map);
182 /* Figure out mdt indicies */
183 /* attach 0:MDC_uml1_mdsA_MNT_client 1:mdc 2:1d834_MNT_client_03f */
184 if ((lcfg->lcfg_command == LCFG_ATTACH) &&
185 (strcmp(lustre_cfg_string(lcfg, 1), LUSTRE_MDC_NAME) == 0)) {
186 rc = server_name2index(lustre_cfg_string(lcfg, 0),
188 if (rc != LDD_F_SV_TYPE_MDT) {
189 CWARN("Unparsable MDC name %s, assuming index 0\n",
190 lustre_cfg_string(lcfg, 0));
194 CDEBUG(D_MGS, "MDT index is %u\n", index);
195 cfs_set_bit(index, fsdb->fsdb_mdt_index_map);
196 fsdb->fsdb_mdt_count ++;
200 /* figure out the old LOV name. fsdb_gen = 0 means old log */
201 /* #01 L attach 0:lov_mdsA 1:lov 2:cdbe9_lov_mdsA_dc8cf7f3bb */
202 if ((fsdb->fsdb_gen == 0) && (lcfg->lcfg_command == LCFG_ATTACH) &&
203 (strcmp(lustre_cfg_string(lcfg, 1), LUSTRE_LOV_NAME) == 0)) {
204 cfs_set_bit(FSDB_OLDLOG14, &fsdb->fsdb_flags);
205 name_destroy(&fsdb->fsdb_clilov);
206 rc = name_create(&fsdb->fsdb_clilov,
207 lustre_cfg_string(lcfg, 0), "");
210 CDEBUG(D_MGS, "client lov name is %s\n", fsdb->fsdb_clilov);
213 /* figure out the old MDT lov name from the MDT uuid */
214 if ((fsdb->fsdb_gen == 0) && (lcfg->lcfg_command == LCFG_SETUP) &&
215 (strncmp(lustre_cfg_string(lcfg, 0), "MDC_", 4) == 0)) {
217 cfs_set_bit(FSDB_OLDLOG14, &fsdb->fsdb_flags);
218 ptr = strstr(lustre_cfg_string(lcfg, 1), "_UUID");
220 CERROR("Can't parse MDT uuid %s\n",
221 lustre_cfg_string(lcfg, 1));
225 name_destroy(&fsdb->fsdb_mdtlov);
226 rc = name_create(&fsdb->fsdb_mdtlov,
227 "lov_", lustre_cfg_string(lcfg, 1));
230 name_destroy(&fsdb->fsdb_mdc);
231 rc = name_create(&fsdb->fsdb_mdc,
232 lustre_cfg_string(lcfg, 0), "");
235 CDEBUG(D_MGS, "MDT lov name is %s\n", fsdb->fsdb_mdtlov);
240 * compat to 1.8, check osc name used by MDT0 to OSTs, bz18548.
242 if (!cfs_test_bit(FSDB_OSCNAME18, &fsdb->fsdb_flags) &&
243 lcfg->lcfg_command == LCFG_ATTACH &&
244 strcmp(lustre_cfg_string(lcfg, 1), LUSTRE_OSC_NAME) == 0) {
245 if (OBD_OCD_VERSION_MAJOR(d->ver) == 1 &&
246 OBD_OCD_VERSION_MINOR(d->ver) <= 8) {
247 CWARN("MDT using 1.8 OSC name scheme\n");
248 cfs_set_bit(FSDB_OSCNAME18, &fsdb->fsdb_flags);
252 if (lcfg->lcfg_command == LCFG_MARKER) {
253 struct cfg_marker *marker;
254 marker = lustre_cfg_buf(lcfg, 1);
256 d->ver = marker->cm_vers;
258 /* Keep track of the latest marker step */
259 fsdb->fsdb_gen = max(fsdb->fsdb_gen, marker->cm_step);
265 /* fsdb->fsdb_mutex is already held in mgs_find_or_make_fsdb*/
266 static int mgs_get_fsdb_from_llog(struct obd_device *obd, struct fs_db *fsdb)
269 struct llog_handle *loghandle;
270 struct lvfs_run_ctxt saved;
271 struct llog_ctxt *ctxt;
272 struct mgs_fsdb_handler_data d = { fsdb, 0 };
276 ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT);
277 LASSERT(ctxt != NULL);
278 name_create(&logname, fsdb->fsdb_name, "-client");
279 cfs_mutex_lock(&fsdb->fsdb_mutex);
280 push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
281 rc = llog_create(ctxt, &loghandle, NULL, logname);
285 rc = llog_init_handle(loghandle, LLOG_F_IS_PLAIN, NULL);
289 if (llog_get_size(loghandle) <= 1)
290 cfs_set_bit(FSDB_LOG_EMPTY, &fsdb->fsdb_flags);
292 rc = llog_process(loghandle, mgs_fsdb_handler, (void *) &d, NULL);
293 CDEBUG(D_INFO, "get_db = %d\n", rc);
295 rc2 = llog_close(loghandle);
299 pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
300 cfs_mutex_unlock(&fsdb->fsdb_mutex);
301 name_destroy(&logname);
307 static void mgs_free_fsdb_srpc(struct fs_db *fsdb)
309 struct mgs_tgt_srpc_conf *tgtconf;
311 /* free target-specific rules */
312 while (fsdb->fsdb_srpc_tgt) {
313 tgtconf = fsdb->fsdb_srpc_tgt;
314 fsdb->fsdb_srpc_tgt = tgtconf->mtsc_next;
316 LASSERT(tgtconf->mtsc_tgt);
318 sptlrpc_rule_set_free(&tgtconf->mtsc_rset);
319 OBD_FREE(tgtconf->mtsc_tgt, strlen(tgtconf->mtsc_tgt) + 1);
320 OBD_FREE_PTR(tgtconf);
323 /* free general rules */
324 sptlrpc_rule_set_free(&fsdb->fsdb_srpc_gen);
327 struct fs_db *mgs_find_fsdb(struct obd_device *obd, char *fsname)
329 struct mgs_obd *mgs = &obd->u.mgs;
333 cfs_list_for_each(tmp, &mgs->mgs_fs_db_list) {
334 fsdb = cfs_list_entry(tmp, struct fs_db, fsdb_list);
335 if (strcmp(fsdb->fsdb_name, fsname) == 0)
341 /* caller must hold the mgs->mgs_fs_db_lock */
342 static struct fs_db *mgs_new_fsdb(struct obd_device *obd, char *fsname)
344 struct mgs_obd *mgs = &obd->u.mgs;
349 if (strlen(fsname) >= sizeof(fsdb->fsdb_name)) {
350 CERROR("fsname %s is too long\n", fsname);
358 strcpy(fsdb->fsdb_name, fsname);
359 cfs_mutex_init(&fsdb->fsdb_mutex);
360 cfs_set_bit(FSDB_UDESC, &fsdb->fsdb_flags);
362 if (strcmp(fsname, MGSSELF_NAME) == 0) {
363 cfs_set_bit(FSDB_MGS_SELF, &fsdb->fsdb_flags);
365 OBD_ALLOC(fsdb->fsdb_ost_index_map, INDEX_MAP_SIZE);
366 OBD_ALLOC(fsdb->fsdb_mdt_index_map, INDEX_MAP_SIZE);
367 if (!fsdb->fsdb_ost_index_map || !fsdb->fsdb_mdt_index_map) {
368 CERROR("No memory for index maps\n");
372 rc = name_create(&fsdb->fsdb_mdtlov, fsname, "-mdtlov");
375 rc = name_create(&fsdb->fsdb_mdtlmv, fsname, "-mdtlmv");
378 rc = name_create(&fsdb->fsdb_clilov, fsname, "-clilov");
381 rc = name_create(&fsdb->fsdb_clilmv, fsname, "-clilmv");
385 /* initialise data for NID table */
386 mgs_ir_init_fs(obd, fsdb);
388 lproc_mgs_add_live(obd, fsdb);
391 cfs_list_add(&fsdb->fsdb_list, &mgs->mgs_fs_db_list);
395 if (fsdb->fsdb_ost_index_map)
396 OBD_FREE(fsdb->fsdb_ost_index_map, INDEX_MAP_SIZE);
397 if (fsdb->fsdb_mdt_index_map)
398 OBD_FREE(fsdb->fsdb_mdt_index_map, INDEX_MAP_SIZE);
399 name_destroy(&fsdb->fsdb_clilov);
400 name_destroy(&fsdb->fsdb_clilmv);
401 name_destroy(&fsdb->fsdb_mdtlov);
402 name_destroy(&fsdb->fsdb_mdtlmv);
407 static void mgs_free_fsdb(struct obd_device *obd, struct fs_db *fsdb)
409 /* wait for anyone with the sem */
410 cfs_mutex_lock(&fsdb->fsdb_mutex);
411 lproc_mgs_del_live(obd, fsdb);
412 cfs_list_del(&fsdb->fsdb_list);
414 /* deinitialize fsr */
415 mgs_ir_fini_fs(obd, fsdb);
417 if (fsdb->fsdb_ost_index_map)
418 OBD_FREE(fsdb->fsdb_ost_index_map, INDEX_MAP_SIZE);
419 if (fsdb->fsdb_mdt_index_map)
420 OBD_FREE(fsdb->fsdb_mdt_index_map, INDEX_MAP_SIZE);
421 name_destroy(&fsdb->fsdb_clilov);
422 name_destroy(&fsdb->fsdb_clilmv);
423 name_destroy(&fsdb->fsdb_mdtlov);
424 name_destroy(&fsdb->fsdb_mdtlmv);
425 name_destroy(&fsdb->fsdb_mdc);
426 mgs_free_fsdb_srpc(fsdb);
427 cfs_mutex_unlock(&fsdb->fsdb_mutex);
431 int mgs_init_fsdb_list(struct obd_device *obd)
433 struct mgs_obd *mgs = &obd->u.mgs;
434 CFS_INIT_LIST_HEAD(&mgs->mgs_fs_db_list);
438 int mgs_cleanup_fsdb_list(struct obd_device *obd)
440 struct mgs_obd *mgs = &obd->u.mgs;
442 cfs_list_t *tmp, *tmp2;
443 cfs_mutex_lock(&mgs->mgs_mutex);
444 cfs_list_for_each_safe(tmp, tmp2, &mgs->mgs_fs_db_list) {
445 fsdb = cfs_list_entry(tmp, struct fs_db, fsdb_list);
446 mgs_free_fsdb(obd, fsdb);
448 cfs_mutex_unlock(&mgs->mgs_mutex);
452 int mgs_find_or_make_fsdb(struct obd_device *obd, char *name,
455 struct mgs_obd *mgs = &obd->u.mgs;
459 cfs_mutex_lock(&mgs->mgs_mutex);
460 fsdb = mgs_find_fsdb(obd, name);
462 cfs_mutex_unlock(&mgs->mgs_mutex);
467 CDEBUG(D_MGS, "Creating new db\n");
468 fsdb = mgs_new_fsdb(obd, name);
469 cfs_mutex_unlock(&mgs->mgs_mutex);
473 if (!cfs_test_bit(FSDB_MGS_SELF, &fsdb->fsdb_flags)) {
474 /* populate the db from the client llog */
475 rc = mgs_get_fsdb_from_llog(obd, fsdb);
477 CERROR("Can't get db from client log %d\n", rc);
478 mgs_free_fsdb(obd, fsdb);
483 /* populate srpc rules from params llog */
484 rc = mgs_get_fsdb_srpc_from_llog(obd, fsdb);
486 CERROR("Can't get db from params log %d\n", rc);
487 mgs_free_fsdb(obd, fsdb);
498 -1= empty client log */
499 int mgs_check_index(struct obd_device *obd, struct mgs_target_info *mti)
506 LASSERT(!(mti->mti_flags & LDD_F_NEED_INDEX));
508 rc = mgs_find_or_make_fsdb(obd, mti->mti_fsname, &fsdb);
510 CERROR("Can't get db for %s\n", mti->mti_fsname);
514 if (cfs_test_bit(FSDB_LOG_EMPTY, &fsdb->fsdb_flags))
517 if (mti->mti_flags & LDD_F_SV_TYPE_OST)
518 imap = fsdb->fsdb_ost_index_map;
519 else if (mti->mti_flags & LDD_F_SV_TYPE_MDT)
520 imap = fsdb->fsdb_mdt_index_map;
524 if (cfs_test_bit(mti->mti_stripe_index, imap))
529 static __inline__ int next_index(void *index_map, int map_len)
532 for (i = 0; i < map_len * 8; i++)
533 if (!cfs_test_bit(i, index_map)) {
536 CERROR("max index %d exceeded.\n", i);
541 0 newly marked as in use
543 +EALREADY for update of an old index */
544 static int mgs_set_index(struct obd_device *obd, struct mgs_target_info *mti)
551 rc = mgs_find_or_make_fsdb(obd, mti->mti_fsname, &fsdb);
553 CERROR("Can't get db for %s\n", mti->mti_fsname);
557 if (mti->mti_flags & LDD_F_SV_TYPE_OST) {
558 imap = fsdb->fsdb_ost_index_map;
559 } else if (mti->mti_flags & LDD_F_SV_TYPE_MDT) {
560 imap = fsdb->fsdb_mdt_index_map;
561 if (fsdb->fsdb_mdt_count >= MAX_MDT_COUNT) {
562 LCONSOLE_ERROR_MSG(0x13f, "The max mdt count"
563 "is %d\n", (int)MAX_MDT_COUNT);
570 if (mti->mti_flags & LDD_F_NEED_INDEX) {
571 rc = next_index(imap, INDEX_MAP_SIZE);
574 mti->mti_stripe_index = rc;
575 if (mti->mti_flags & LDD_F_SV_TYPE_MDT)
576 fsdb->fsdb_mdt_count ++;
579 if (mti->mti_stripe_index >= INDEX_MAP_SIZE * 8) {
580 LCONSOLE_ERROR_MSG(0x13f, "Server %s requested index %d, "
581 "but the max index is %d.\n",
582 mti->mti_svname, mti->mti_stripe_index,
587 if (cfs_test_bit(mti->mti_stripe_index, imap)) {
588 if ((mti->mti_flags & LDD_F_VIRGIN) &&
589 !(mti->mti_flags & LDD_F_WRITECONF)) {
590 LCONSOLE_ERROR_MSG(0x140, "Server %s requested index "
591 "%d, but that index is already in "
592 "use. Use --writeconf to force\n",
594 mti->mti_stripe_index);
597 CDEBUG(D_MGS, "Server %s updating index %d\n",
598 mti->mti_svname, mti->mti_stripe_index);
603 cfs_set_bit(mti->mti_stripe_index, imap);
604 cfs_clear_bit(FSDB_LOG_EMPTY, &fsdb->fsdb_flags);
605 server_make_name(mti->mti_flags, mti->mti_stripe_index,
606 mti->mti_fsname, mti->mti_svname);
608 CDEBUG(D_MGS, "Set index for %s to %d\n", mti->mti_svname,
609 mti->mti_stripe_index);
614 struct mgs_modify_lookup {
615 struct cfg_marker mml_marker;
619 static int mgs_modify_handler(struct llog_handle *llh, struct llog_rec_hdr *rec,
622 struct mgs_modify_lookup *mml = (struct mgs_modify_lookup *)data;
623 struct cfg_marker *marker;
624 struct lustre_cfg *lcfg = (struct lustre_cfg *)(rec + 1);
625 int cfg_len = rec->lrh_len - sizeof(struct llog_rec_hdr) -
626 sizeof(struct llog_rec_tail);
630 if (rec->lrh_type != OBD_CFG_REC) {
631 CERROR("unhandled lrh_type: %#x\n", rec->lrh_type);
635 rc = lustre_cfg_sanity_check(lcfg, cfg_len);
637 CERROR("Insane cfg\n");
641 /* We only care about markers */
642 if (lcfg->lcfg_command != LCFG_MARKER)
645 marker = lustre_cfg_buf(lcfg, 1);
646 if ((strcmp(mml->mml_marker.cm_comment, marker->cm_comment) == 0) &&
647 (strcmp(mml->mml_marker.cm_tgtname, marker->cm_tgtname) == 0) &&
648 !(marker->cm_flags & CM_SKIP)) {
649 /* Found a non-skipped marker match */
650 CDEBUG(D_MGS, "Changing rec %u marker %d %x->%x: %s %s\n",
651 rec->lrh_index, marker->cm_step,
652 marker->cm_flags, mml->mml_marker.cm_flags,
653 marker->cm_tgtname, marker->cm_comment);
654 /* Overwrite the old marker llog entry */
655 marker->cm_flags &= ~CM_EXCLUDE; /* in case we're unexcluding */
656 marker->cm_flags |= mml->mml_marker.cm_flags;
657 marker->cm_canceltime = mml->mml_marker.cm_canceltime;
658 /* Header and tail are added back to lrh_len in
659 llog_lvfs_write_rec */
660 rec->lrh_len = cfg_len;
661 rc = llog_write_rec(llh, rec, NULL, 0, (void *)lcfg,
670 /* Modify an existing config log record (for CM_SKIP or CM_EXCLUDE) */
671 static int mgs_modify(struct obd_device *obd, struct fs_db *fsdb,
672 struct mgs_target_info *mti, char *logname,
673 char *devname, char *comment, int flags)
675 struct llog_handle *loghandle;
676 struct lvfs_run_ctxt saved;
677 struct llog_ctxt *ctxt;
678 struct mgs_modify_lookup *mml;
682 CDEBUG(D_MGS, "modify %s/%s/%s fl=%x\n", logname, devname, comment,
685 push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
687 ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT);
688 LASSERT(ctxt != NULL);
689 rc = llog_create(ctxt, &loghandle, NULL, logname);
693 rc = llog_init_handle(loghandle, LLOG_F_IS_PLAIN, NULL);
697 if (llog_get_size(loghandle) <= 1)
698 GOTO(out_close, rc = 0);
702 GOTO(out_close, rc = -ENOMEM);
703 strcpy(mml->mml_marker.cm_comment, comment);
704 strcpy(mml->mml_marker.cm_tgtname, devname);
705 /* Modify mostly means cancel */
706 mml->mml_marker.cm_flags = flags;
707 mml->mml_marker.cm_canceltime = flags ? cfs_time_current_sec() : 0;
708 mml->mml_modified = 0;
709 rc = llog_process(loghandle, mgs_modify_handler, (void *)mml, NULL);
710 if (!rc && !mml->mml_modified)
715 rc2 = llog_close(loghandle);
719 pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
720 if (rc && rc != -ENODEV)
721 CERROR("modify %s/%s failed %d\n",
722 mti->mti_svname, comment, rc);
727 /******************** config log recording functions *********************/
729 static int record_lcfg(struct obd_device *obd, struct llog_handle *llh,
730 struct lustre_cfg *lcfg)
732 struct lvfs_run_ctxt saved;
733 struct llog_rec_hdr rec;
739 LASSERT(llh->lgh_ctxt);
741 buflen = lustre_cfg_len(lcfg->lcfg_bufcount,
743 rec.lrh_len = llog_data_len(buflen);
744 rec.lrh_type = OBD_CFG_REC;
746 push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
747 /* idx = -1 means append */
748 rc = llog_write_rec(llh, &rec, NULL, 0, (void *)lcfg, -1);
749 pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
751 CERROR("failed %d\n", rc);
755 static int record_base(struct obd_device *obd, struct llog_handle *llh,
756 char *cfgname, lnet_nid_t nid, int cmd,
757 char *s1, char *s2, char *s3, char *s4)
759 struct lustre_cfg_bufs bufs;
760 struct lustre_cfg *lcfg;
763 CDEBUG(D_MGS, "lcfg %s %#x %s %s %s %s\n", cfgname,
764 cmd, s1, s2, s3, s4);
766 lustre_cfg_bufs_reset(&bufs, cfgname);
768 lustre_cfg_bufs_set_string(&bufs, 1, s1);
770 lustre_cfg_bufs_set_string(&bufs, 2, s2);
772 lustre_cfg_bufs_set_string(&bufs, 3, s3);
774 lustre_cfg_bufs_set_string(&bufs, 4, s4);
776 lcfg = lustre_cfg_new(cmd, &bufs);
779 lcfg->lcfg_nid = nid;
781 rc = record_lcfg(obd, llh, lcfg);
783 lustre_cfg_free(lcfg);
786 CERROR("error %d: lcfg %s %#x %s %s %s %s\n", rc, cfgname,
787 cmd, s1, s2, s3, s4);
793 static inline int record_add_uuid(struct obd_device *obd,
794 struct llog_handle *llh,
795 uint64_t nid, char *uuid)
797 return record_base(obd,llh,NULL,nid,LCFG_ADD_UUID,uuid,0,0,0);
801 static inline int record_add_conn(struct obd_device *obd,
802 struct llog_handle *llh,
806 return record_base(obd,llh,devname,0,LCFG_ADD_CONN,uuid,0,0,0);
809 static inline int record_attach(struct obd_device *obd, struct llog_handle *llh,
810 char *devname, char *type, char *uuid)
812 return record_base(obd,llh,devname,0,LCFG_ATTACH,type,uuid,0,0);
815 static inline int record_setup(struct obd_device *obd, struct llog_handle *llh,
817 char *s1, char *s2, char *s3, char *s4)
819 return record_base(obd,llh,devname,0,LCFG_SETUP,s1,s2,s3,s4);
822 static int record_lov_setup(struct obd_device *obd, struct llog_handle *llh,
823 char *devname, struct lov_desc *desc)
825 struct lustre_cfg_bufs bufs;
826 struct lustre_cfg *lcfg;
829 lustre_cfg_bufs_reset(&bufs, devname);
830 lustre_cfg_bufs_set(&bufs, 1, desc, sizeof(*desc));
831 lcfg = lustre_cfg_new(LCFG_SETUP, &bufs);
834 rc = record_lcfg(obd, llh, lcfg);
836 lustre_cfg_free(lcfg);
840 static int record_lmv_setup(struct obd_device *obd, struct llog_handle *llh,
841 char *devname, struct lmv_desc *desc)
843 struct lustre_cfg_bufs bufs;
844 struct lustre_cfg *lcfg;
847 lustre_cfg_bufs_reset(&bufs, devname);
848 lustre_cfg_bufs_set(&bufs, 1, desc, sizeof(*desc));
849 lcfg = lustre_cfg_new(LCFG_SETUP, &bufs);
851 rc = record_lcfg(obd, llh, lcfg);
853 lustre_cfg_free(lcfg);
857 static inline int record_mdc_add(struct obd_device *obd,
858 struct llog_handle *llh,
859 char *logname, char *mdcuuid,
860 char *mdtuuid, char *index,
863 return record_base(obd,llh,logname,0,LCFG_ADD_MDC,
864 mdtuuid,index,gen,mdcuuid);
867 static inline int record_lov_add(struct obd_device *obd,
868 struct llog_handle *llh,
869 char *lov_name, char *ost_uuid,
870 char *index, char *gen)
872 return record_base(obd,llh,lov_name,0,LCFG_LOV_ADD_OBD,
873 ost_uuid,index,gen,0);
876 static inline int record_mount_opt(struct obd_device *obd,
877 struct llog_handle *llh,
878 char *profile, char *lov_name,
881 return record_base(obd,llh,NULL,0,LCFG_MOUNTOPT,
882 profile,lov_name,mdc_name,0);
885 static int record_marker(struct obd_device *obd, struct llog_handle *llh,
886 struct fs_db *fsdb, __u32 flags,
887 char *tgtname, char *comment)
889 struct cfg_marker marker;
890 struct lustre_cfg_bufs bufs;
891 struct lustre_cfg *lcfg;
894 if (flags & CM_START)
896 marker.cm_step = fsdb->fsdb_gen;
897 marker.cm_flags = flags;
898 marker.cm_vers = LUSTRE_VERSION_CODE;
899 strncpy(marker.cm_tgtname, tgtname, sizeof(marker.cm_tgtname));
900 strncpy(marker.cm_comment, comment, sizeof(marker.cm_comment));
901 marker.cm_createtime = cfs_time_current_sec();
902 marker.cm_canceltime = 0;
903 lustre_cfg_bufs_reset(&bufs, NULL);
904 lustre_cfg_bufs_set(&bufs, 1, &marker, sizeof(marker));
905 lcfg = lustre_cfg_new(LCFG_MARKER, &bufs);
908 rc = record_lcfg(obd, llh, lcfg);
910 lustre_cfg_free(lcfg);
914 static int record_start_log(struct obd_device *obd,
915 struct llog_handle **llh, char *name)
917 static struct obd_uuid cfg_uuid = { .uuid = "config_uuid" };
918 struct lvfs_run_ctxt saved;
919 struct llog_ctxt *ctxt;
923 GOTO(out, rc = -EBUSY);
925 ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT);
927 GOTO(out, rc = -ENODEV);
929 push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
930 rc = llog_create(ctxt, llh, NULL, name);
932 llog_init_handle(*llh, LLOG_F_IS_PLAIN, &cfg_uuid);
936 pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
941 CERROR("Can't start log %s: %d\n", name, rc);
946 static int record_end_log(struct obd_device *obd, struct llog_handle **llh)
948 struct lvfs_run_ctxt saved;
951 push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
953 rc = llog_close(*llh);
956 pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
960 static int mgs_log_is_empty(struct obd_device *obd, char *name)
962 struct lvfs_run_ctxt saved;
963 struct llog_handle *llh;
964 struct llog_ctxt *ctxt;
967 ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT);
968 LASSERT(ctxt != NULL);
969 push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
970 rc = llog_create(ctxt, &llh, NULL, name);
972 llog_init_handle(llh, LLOG_F_IS_PLAIN, NULL);
973 rc = llog_get_size(llh);
976 pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
978 /* header is record 1 */
982 /******************** config "macros" *********************/
984 /* write an lcfg directly into a log (with markers) */
985 static int mgs_write_log_direct(struct obd_device *obd, struct fs_db *fsdb,
986 char *logname, struct lustre_cfg *lcfg,
987 char *devname, char *comment)
989 struct llog_handle *llh = NULL;
996 rc = record_start_log(obd, &llh, logname);
1000 /* FIXME These should be a single journal transaction */
1001 rc = record_marker(obd, llh, fsdb, CM_START, devname, comment);
1003 rc = record_lcfg(obd, llh, lcfg);
1005 rc = record_marker(obd, llh, fsdb, CM_END, devname, comment);
1006 rc = record_end_log(obd, &llh);
1011 /* write the lcfg in all logs for the given fs */
1012 int mgs_write_log_direct_all(struct obd_device *obd, struct fs_db *fsdb,
1013 struct mgs_target_info *mti,
1014 struct lustre_cfg *lcfg,
1015 char *devname, char *comment)
1017 struct mgs_obd *mgs = &obd->u.mgs;
1018 cfs_list_t dentry_list;
1019 struct l_linux_dirent *dirent, *n;
1020 char *fsname = mti->mti_fsname;
1022 int rc = 0, len = strlen(fsname);
1025 /* We need to set params for any future logs
1026 as well. FIXME Append this file to every new log.
1027 Actually, we should store as params (text), not llogs. Or
1029 name_create(&logname, fsname, "-params");
1030 if (mgs_log_is_empty(obd, logname)) {
1031 struct llog_handle *llh = NULL;
1032 rc = record_start_log(obd, &llh, logname);
1033 record_end_log(obd, &llh);
1035 name_destroy(&logname);
1039 /* Find all the logs in the CONFIGS directory */
1040 rc = class_dentry_readdir(obd, mgs->mgs_configs_dir,
1041 mgs->mgs_vfsmnt, &dentry_list);
1043 CERROR("Can't read %s dir\n", MOUNT_CONFIGS_DIR);
1047 /* Could use fsdb index maps instead of directory listing */
1048 cfs_list_for_each_entry_safe(dirent, n, &dentry_list, lld_list) {
1049 cfs_list_del(&dirent->lld_list);
1050 /* don't write to sptlrpc rule log */
1051 if (strncmp(fsname, dirent->lld_name, len) == 0 &&
1052 strstr(dirent->lld_name, "-sptlrpc") == NULL) {
1053 CDEBUG(D_MGS, "Changing log %s\n", dirent->lld_name);
1054 /* Erase any old settings of this same parameter */
1055 mgs_modify(obd, fsdb, mti, dirent->lld_name, devname,
1057 /* Write the new one */
1059 rc = mgs_write_log_direct(obd, fsdb,
1064 CERROR("err %d writing log %s\n", rc,
1068 OBD_FREE(dirent, sizeof(*dirent));
1076 struct mgs_target_info *comp_tmti;
1077 struct mgs_target_info *comp_mti;
1078 struct fs_db *comp_fsdb;
1079 struct obd_device *comp_obd;
1082 static int mgs_write_log_mdc_to_mdt(struct obd_device *, struct fs_db *,
1083 struct mgs_target_info *, char *);
1084 static int mgs_write_log_osc_to_lov(struct obd_device *obd, struct fs_db *fsdb,
1085 struct mgs_target_info *mti,
1086 char *logname, char *suffix, char *lovname,
1087 enum lustre_sec_part sec_part, int flags);
1088 static void name_create_mdt_and_lov(char **logname, char **lovname,
1089 struct fs_db *fsdb, int i);
1091 static int mgs_steal_llog_handler(struct llog_handle *llh,
1092 struct llog_rec_hdr *rec,
1095 struct obd_device * obd;
1096 struct mgs_target_info *mti, *tmti;
1098 int cfg_len = rec->lrh_len;
1099 char *cfg_buf = (char*) (rec + 1);
1100 struct lustre_cfg *lcfg;
1102 struct llog_handle *mdt_llh = NULL;
1103 static int got_an_osc_or_mdc = 0;
1104 /* 0: not found any osc/mdc;
1108 static int last_step = -1;
1112 mti = ((struct temp_comp*)data)->comp_mti;
1113 tmti = ((struct temp_comp*)data)->comp_tmti;
1114 fsdb = ((struct temp_comp*)data)->comp_fsdb;
1115 obd = ((struct temp_comp*)data)->comp_obd;
1117 if (rec->lrh_type != OBD_CFG_REC) {
1118 CERROR("unhandled lrh_type: %#x\n", rec->lrh_type);
1122 rc = lustre_cfg_sanity_check(cfg_buf, cfg_len);
1124 CERROR("Insane cfg\n");
1128 lcfg = (struct lustre_cfg *)cfg_buf;
1130 if (lcfg->lcfg_command == LCFG_MARKER) {
1131 struct cfg_marker *marker;
1132 marker = lustre_cfg_buf(lcfg, 1);
1133 if (!strncmp(marker->cm_comment,"add osc",7) &&
1134 (marker->cm_flags & CM_START)){
1135 got_an_osc_or_mdc = 1;
1136 strncpy(tmti->mti_svname, marker->cm_tgtname,
1137 sizeof(tmti->mti_svname));
1138 rc = record_start_log(obd, &mdt_llh, mti->mti_svname);
1139 rc = record_marker(obd, mdt_llh, fsdb, CM_START,
1140 mti->mti_svname,"add osc(copied)");
1141 rc = record_end_log(obd, &mdt_llh);
1142 last_step = marker->cm_step;
1145 if (!strncmp(marker->cm_comment,"add osc",7) &&
1146 (marker->cm_flags & CM_END)){
1147 LASSERT(last_step == marker->cm_step);
1149 got_an_osc_or_mdc = 0;
1150 rc = record_start_log(obd, &mdt_llh, mti->mti_svname);
1151 rc = record_marker(obd, mdt_llh, fsdb, CM_END,
1152 mti->mti_svname,"add osc(copied)");
1153 rc = record_end_log(obd, &mdt_llh);
1156 if (!strncmp(marker->cm_comment,"add mdc",7) &&
1157 (marker->cm_flags & CM_START)){
1158 got_an_osc_or_mdc = 2;
1159 last_step = marker->cm_step;
1160 memcpy(tmti->mti_svname, marker->cm_tgtname,
1161 strlen(marker->cm_tgtname));
1165 if (!strncmp(marker->cm_comment,"add mdc",7) &&
1166 (marker->cm_flags & CM_END)){
1167 LASSERT(last_step == marker->cm_step);
1169 got_an_osc_or_mdc = 0;
1174 if (got_an_osc_or_mdc == 0 || last_step < 0)
1177 if (lcfg->lcfg_command == LCFG_ADD_UUID) {
1179 nodenid = lcfg->lcfg_nid;
1181 tmti->mti_nids[tmti->mti_nid_count] = nodenid;
1182 tmti->mti_nid_count++;
1187 if (lcfg->lcfg_command == LCFG_SETUP) {
1190 target = lustre_cfg_string(lcfg, 1);
1191 memcpy(tmti->mti_uuid, target, strlen(target));
1195 /* ignore client side sptlrpc_conf_log */
1196 if (lcfg->lcfg_command == LCFG_SPTLRPC_CONF)
1199 if (lcfg->lcfg_command == LCFG_ADD_MDC) {
1202 if (sscanf(lustre_cfg_buf(lcfg, 2), "%d", &index) != 1)
1205 memcpy(tmti->mti_fsname, mti->mti_fsname,
1206 strlen(mti->mti_fsname));
1207 tmti->mti_stripe_index = index;
1209 mgs_write_log_mdc_to_mdt(obd, fsdb, tmti, mti->mti_svname);
1210 memset(tmti, 0, sizeof(*tmti));
1214 if (lcfg->lcfg_command == LCFG_LOV_ADD_OBD) {
1217 char *logname, *lovname;
1219 name_create_mdt_and_lov(&logname, &lovname, fsdb,
1220 mti->mti_stripe_index);
1221 sprintf(mdt_index, "-MDT%04x", mti->mti_stripe_index);
1223 if (sscanf(lustre_cfg_buf(lcfg, 2), "%d", &index) != 1) {
1224 name_destroy(&logname);
1225 name_destroy(&lovname);
1229 tmti->mti_stripe_index = index;
1230 mgs_write_log_osc_to_lov(obd, fsdb, tmti, logname,
1233 name_destroy(&logname);
1234 name_destroy(&lovname);
1240 /* fsdb->fsdb_mutex is already held in mgs_write_log_target*/
1241 /* stealed from mgs_get_fsdb_from_llog*/
1242 static int mgs_steal_llog_for_mdt_from_client(struct obd_device *obd,
1244 struct temp_comp* comp)
1246 struct llog_handle *loghandle;
1247 struct lvfs_run_ctxt saved;
1248 struct mgs_target_info *tmti;
1249 struct llog_ctxt *ctxt;
1253 ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT);
1254 LASSERT(ctxt != NULL);
1256 OBD_ALLOC_PTR(tmti);
1260 comp->comp_tmti = tmti;
1261 comp->comp_obd = obd;
1263 push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
1265 rc = llog_create(ctxt, &loghandle, NULL, client_name);
1269 rc = llog_init_handle(loghandle, LLOG_F_IS_PLAIN, NULL);
1271 GOTO(out_close, rc);
1273 rc = llog_process(loghandle, mgs_steal_llog_handler, (void *)comp, NULL);
1274 CDEBUG(D_MGS, "steal llog re = %d\n", rc);
1276 rc2 = llog_close(loghandle);
1280 pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
1282 llog_ctxt_put(ctxt);
1286 /* lmv is the second thing for client logs */
1287 /* copied from mgs_write_log_lov. Please refer to that. */
1288 static int mgs_write_log_lmv(struct obd_device *obd, struct fs_db *fsdb,
1289 struct mgs_target_info *mti,
1290 char *logname, char *lmvname)
1292 struct llog_handle *llh = NULL;
1293 struct lmv_desc *lmvdesc;
1298 CDEBUG(D_MGS, "Writing lmv(%s) log for %s\n", lmvname,logname);
1300 OBD_ALLOC_PTR(lmvdesc);
1301 if (lmvdesc == NULL)
1303 lmvdesc->ld_active_tgt_count = 0;
1304 lmvdesc->ld_tgt_count = 0;
1305 sprintf((char*)lmvdesc->ld_uuid.uuid, "%s_UUID", lmvname);
1306 uuid = (char *)lmvdesc->ld_uuid.uuid;
1308 rc = record_start_log(obd, &llh, logname);
1309 rc = record_marker(obd, llh, fsdb, CM_START, lmvname, "lmv setup");
1310 rc = record_attach(obd, llh, lmvname, "lmv", uuid);
1311 rc = record_lmv_setup(obd, llh, lmvname, lmvdesc);
1312 rc = record_marker(obd, llh, fsdb, CM_END, lmvname, "lmv setup");
1313 rc = record_end_log(obd, &llh);
1315 OBD_FREE_PTR(lmvdesc);
1319 /* lov is the first thing in the mdt and client logs */
1320 static int mgs_write_log_lov(struct obd_device *obd, struct fs_db *fsdb,
1321 struct mgs_target_info *mti,
1322 char *logname, char *lovname)
1324 struct llog_handle *llh = NULL;
1325 struct lov_desc *lovdesc;
1330 CDEBUG(D_MGS, "Writing lov(%s) log for %s\n", lovname, logname);
1333 #01 L attach 0:lov_mdsA 1:lov 2:71ccb_lov_mdsA_19f961a9e1
1334 #02 L lov_setup 0:lov_mdsA 1:(struct lov_desc)
1335 uuid=lov1_UUID, stripe count=1, size=1048576, offset=0, pattern=0
1338 /* FIXME just make lov_setup accept empty desc (put uuid in buf 2) */
1339 OBD_ALLOC_PTR(lovdesc);
1340 if (lovdesc == NULL)
1342 lovdesc->ld_magic = LOV_DESC_MAGIC;
1343 lovdesc->ld_tgt_count = 0;
1344 /* Defaults. Can be changed later by lcfg config_param */
1345 lovdesc->ld_default_stripe_count = 1;
1346 lovdesc->ld_pattern = LOV_PATTERN_RAID0;
1347 lovdesc->ld_default_stripe_size = 1024 * 1024;
1348 lovdesc->ld_default_stripe_offset = -1;
1349 lovdesc->ld_qos_maxage = QOS_DEFAULT_MAXAGE;
1350 sprintf((char*)lovdesc->ld_uuid.uuid, "%s_UUID", lovname);
1351 /* can these be the same? */
1352 uuid = (char *)lovdesc->ld_uuid.uuid;
1354 /* This should always be the first entry in a log.
1355 rc = mgs_clear_log(obd, logname); */
1356 rc = record_start_log(obd, &llh, logname);
1359 /* FIXME these should be a single journal transaction */
1360 rc = record_marker(obd, llh, fsdb, CM_START, lovname, "lov setup");
1361 rc = record_attach(obd, llh, lovname, "lov", uuid);
1362 rc = record_lov_setup(obd, llh, lovname, lovdesc);
1363 rc = record_marker(obd, llh, fsdb, CM_END, lovname, "lov setup");
1364 rc = record_end_log(obd, &llh);
1368 OBD_FREE_PTR(lovdesc);
1372 /* add failnids to open log */
1373 static int mgs_write_log_failnids(struct obd_device *obd,
1374 struct mgs_target_info *mti,
1375 struct llog_handle *llh,
1378 char *failnodeuuid = NULL;
1379 char *ptr = mti->mti_params;
1384 #03 L add_uuid nid=uml1@tcp(0x20000c0a80201) nal=90 0: 1:uml1_UUID
1385 #04 L add_uuid nid=1@elan(0x1000000000001) nal=90 0: 1:uml1_UUID
1386 #05 L setup 0:OSC_uml1_ost1_mdsA 1:ost1_UUID 2:uml1_UUID
1387 #06 L add_uuid nid=uml2@tcp(0x20000c0a80202) nal=90 0: 1:uml2_UUID
1388 #0x L add_uuid nid=2@elan(0x1000000000002) nal=90 0: 1:uml2_UUID
1389 #07 L add_conn 0:OSC_uml1_ost1_mdsA 1:uml2_UUID
1392 /* Pull failnid info out of params string */
1393 while (class_find_param(ptr, PARAM_FAILNODE, &ptr) == 0) {
1394 while (class_parse_nid(ptr, &nid, &ptr) == 0) {
1395 if (failnodeuuid == NULL) {
1396 /* We don't know the failover node name,
1397 so just use the first nid as the uuid */
1398 rc = name_create(&failnodeuuid,
1399 libcfs_nid2str(nid), "");
1403 CDEBUG(D_MGS, "add nid %s for failover uuid %s, "
1404 "client %s\n", libcfs_nid2str(nid),
1405 failnodeuuid, cliname);
1406 rc = record_add_uuid(obd, llh, nid, failnodeuuid);
1409 rc = record_add_conn(obd, llh, cliname, failnodeuuid);
1410 name_destroy(&failnodeuuid);
1411 failnodeuuid = NULL;
1418 static int mgs_write_log_mdc_to_lmv(struct obd_device *obd, struct fs_db *fsdb,
1419 struct mgs_target_info *mti,
1420 char *logname, char *lmvname)
1422 struct llog_handle *llh = NULL;
1423 char *mdcname, *nodeuuid, *mdcuuid, *lmvuuid;
1428 if (mgs_log_is_empty(obd, logname)) {
1429 CERROR("log is empty! Logical error\n");
1433 CDEBUG(D_MGS, "adding mdc for %s to log %s:lmv(%s)\n",
1434 mti->mti_svname, logname, lmvname);
1436 name_create(&nodeuuid, libcfs_nid2str(mti->mti_nids[0]), "");
1437 name_create(&mdcname, mti->mti_svname, "-mdc");
1438 name_create(&mdcuuid, mdcname, "_UUID");
1439 name_create(&lmvuuid, lmvname, "_UUID");
1441 rc = record_start_log(obd, &llh, logname);
1442 rc = record_marker(obd, llh, fsdb, CM_START, mti->mti_svname,
1445 for (i = 0; i < mti->mti_nid_count; i++) {
1446 CDEBUG(D_MGS, "add nid %s for mdt\n",
1447 libcfs_nid2str(mti->mti_nids[i]));
1449 rc = record_add_uuid(obd, llh, mti->mti_nids[i], nodeuuid);
1452 rc = record_attach(obd, llh, mdcname, LUSTRE_MDC_NAME, lmvuuid);
1453 rc = record_setup(obd, llh, mdcname, mti->mti_uuid, nodeuuid, 0, 0);
1454 rc = mgs_write_log_failnids(obd, mti, llh, mdcname);
1455 snprintf(index, sizeof(index), "%d", mti->mti_stripe_index);
1456 rc = record_mdc_add(obd, llh, lmvname, mdcuuid, mti->mti_uuid,
1458 rc = record_marker(obd, llh, fsdb, CM_END, mti->mti_svname,
1460 rc = record_end_log(obd, &llh);
1462 name_destroy(&lmvuuid);
1463 name_destroy(&mdcuuid);
1464 name_destroy(&mdcname);
1465 name_destroy(&nodeuuid);
1469 /* add new mdc to already existent MDS */
1470 static int mgs_write_log_mdc_to_mdt(struct obd_device *obd, struct fs_db *fsdb,
1471 struct mgs_target_info *mti, char *logname)
1473 struct llog_handle *llh = NULL;
1474 char *nodeuuid, *mdcname, *mdcuuid, *mdtuuid;
1475 int idx = mti->mti_stripe_index;
1480 if (mgs_log_is_empty(obd, logname)) {
1481 CERROR("log is empty! Logical error\n");
1485 CDEBUG(D_MGS, "adding mdc index %d to %s\n", idx, logname);
1487 name_create(&nodeuuid, libcfs_nid2str(mti->mti_nids[0]), "");
1488 snprintf(index, sizeof(index), "-mdc%04x", idx);
1489 name_create(&mdcname, logname, index);
1490 name_create(&mdcuuid, mdcname, "_UUID");
1491 name_create(&mdtuuid, logname, "_UUID");
1493 rc = record_start_log(obd, &llh, logname);
1494 rc = record_marker(obd, llh, fsdb, CM_START, mti->mti_svname, "add mdc");
1495 for (i = 0; i < mti->mti_nid_count; i++) {
1496 CDEBUG(D_MGS, "add nid %s for mdt\n",
1497 libcfs_nid2str(mti->mti_nids[i]));
1498 rc = record_add_uuid(obd, llh, mti->mti_nids[i], nodeuuid);
1500 rc = record_attach(obd, llh, mdcname, LUSTRE_MDC_NAME, mdcuuid);
1501 rc = record_setup(obd, llh, mdcname, mti->mti_uuid, nodeuuid, 0, 0);
1502 rc = mgs_write_log_failnids(obd, mti, llh, mdcname);
1503 snprintf(index, sizeof(index), "%d", idx);
1505 rc = record_mdc_add(obd, llh, logname, mdcuuid, mti->mti_uuid,
1507 rc = record_marker(obd, llh, fsdb, CM_END, mti->mti_svname, "add mdc");
1508 rc = record_end_log(obd, &llh);
1510 name_destroy(&mdcuuid);
1511 name_destroy(&mdcname);
1512 name_destroy(&nodeuuid);
1513 name_destroy(&mdtuuid);
1517 static int mgs_write_log_mdt0(struct obd_device *obd, struct fs_db *fsdb,
1518 struct mgs_target_info *mti)
1520 char *log = mti->mti_svname;
1521 struct llog_handle *llh = NULL;
1522 char *uuid, *lovname;
1524 char *ptr = mti->mti_params;
1525 int rc = 0, failout = 0;
1528 OBD_ALLOC(uuid, sizeof(struct obd_uuid));
1532 if (class_find_param(ptr, PARAM_FAILMODE, &ptr) == 0)
1533 failout = (strncmp(ptr, "failout", 7) == 0);
1535 name_create(&lovname, log, "-mdtlov");
1536 if (mgs_log_is_empty(obd, log))
1537 rc = mgs_write_log_lov(obd, fsdb, mti, log, lovname);
1539 sprintf(uuid, "%s_UUID", log);
1540 sprintf(mdt_index, "%d", mti->mti_stripe_index);
1542 /* add MDT itself */
1543 rc = record_start_log(obd, &llh, log);
1547 /* FIXME this whole fn should be a single journal transaction */
1548 rc = record_marker(obd, llh, fsdb, CM_START, log, "add mdt");
1549 rc = record_attach(obd, llh, log, LUSTRE_MDT_NAME, uuid);
1550 rc = record_mount_opt(obd, llh, log, lovname, NULL);
1551 rc = record_setup(obd, llh, log, uuid, mdt_index, lovname,
1552 failout ? "n" : "f");
1553 rc = record_marker(obd, llh, fsdb, CM_END, log, "add mdt");
1554 rc = record_end_log(obd, &llh);
1556 name_destroy(&lovname);
1557 OBD_FREE(uuid, sizeof(struct obd_uuid));
1561 static inline void name_create_mdt(char **logname, char *fsname, int i)
1565 sprintf(mdt_index, "-MDT%04x", i);
1566 name_create(logname, fsname, mdt_index);
1569 static void name_create_mdt_and_lov(char **logname, char **lovname,
1570 struct fs_db *fsdb, int i)
1572 name_create_mdt(logname, fsdb->fsdb_name, i);
1574 if (i == 0 && cfs_test_bit(FSDB_OSCNAME18, &fsdb->fsdb_flags))
1575 name_create(lovname, fsdb->fsdb_name, "-mdtlov");
1577 name_create(lovname, *logname, "-mdtlov");
1580 static inline void name_create_mdt_osc(char **oscname, char *ostname,
1581 struct fs_db *fsdb, int i)
1585 if (i == 0 && cfs_test_bit(FSDB_OSCNAME18, &fsdb->fsdb_flags))
1586 sprintf(suffix, "-osc");
1588 sprintf(suffix, "-osc-MDT%04x", i);
1589 name_create(oscname, ostname, suffix);
1592 /* envelope method for all layers log */
1593 static int mgs_write_log_mdt(struct obd_device *obd, struct fs_db *fsdb,
1594 struct mgs_target_info *mti)
1596 struct llog_handle *llh = NULL;
1598 struct temp_comp comp = { 0 };
1602 CDEBUG(D_MGS, "writing new mdt %s\n", mti->mti_svname);
1606 if (mti->mti_flags & LDD_F_UPGRADE14) {
1607 /* We're starting with an old uuid. Assume old name for lov
1608 as well since the lov entry already exists in the log. */
1609 CDEBUG(D_MGS, "old mds uuid %s\n", mti->mti_uuid);
1610 if (strncmp(mti->mti_uuid, fsdb->fsdb_mdtlov + 4,
1611 strlen(fsdb->fsdb_mdtlov) - 4) != 0) {
1612 CERROR("old mds uuid %s doesn't match log %s (%s)\n",
1613 mti->mti_uuid, fsdb->fsdb_mdtlov,
1614 fsdb->fsdb_mdtlov + 4);
1618 /* end COMPAT_146 */
1620 if (mti->mti_uuid[0] == '\0') {
1621 /* Make up our own uuid */
1622 snprintf(mti->mti_uuid, sizeof(mti->mti_uuid),
1623 "%s_UUID", mti->mti_svname);
1627 rc = mgs_write_log_mdt0(obd, fsdb, mti);
1629 /* Append the mdt info to the client log */
1630 name_create(&cliname, mti->mti_fsname, "-client");
1632 if (mgs_log_is_empty(obd, cliname)) {
1633 /* Start client log */
1634 rc = mgs_write_log_lov(obd, fsdb, mti, cliname,
1636 rc = mgs_write_log_lmv(obd, fsdb, mti, cliname,
1641 #09 L add_uuid nid=uml1@tcp(0x20000c0a80201) 0: 1:uml1_UUID
1642 #10 L attach 0:MDC_uml1_mdsA_MNT_client 1:mdc 2:1d834_MNT_client_03f
1643 #11 L setup 0:MDC_uml1_mdsA_MNT_client 1:mdsA_UUID 2:uml1_UUID
1644 #12 L add_uuid nid=uml2@tcp(0x20000c0a80202) 0: 1:uml2_UUID
1645 #13 L add_conn 0:MDC_uml1_mdsA_MNT_client 1:uml2_UUID
1646 #14 L mount_option 0: 1:client 2:lov1 3:MDC_uml1_mdsA_MNT_client
1651 if (mti->mti_flags & LDD_F_UPGRADE14) {
1652 rc = record_start_log(obd, &llh, cliname);
1656 rc = record_marker(obd, llh, fsdb, CM_START,
1657 mti->mti_svname,"add mdc");
1659 /* Old client log already has MDC entry, but needs mount opt
1660 for new client name (lustre-client) */
1661 /* FIXME Old MDT log already has an old mount opt
1662 which we should remove (currently handled by
1663 class_del_profiles()) */
1664 rc = record_mount_opt(obd, llh, cliname, fsdb->fsdb_clilov,
1666 /* end COMPAT_146 */
1668 rc = record_marker(obd, llh, fsdb, CM_END,
1669 mti->mti_svname, "add mdc");
1673 /* copy client info about lov/lmv */
1674 comp.comp_mti = mti;
1675 comp.comp_fsdb = fsdb;
1677 rc = mgs_steal_llog_for_mdt_from_client(obd, cliname,
1680 rc = mgs_write_log_mdc_to_lmv(obd, fsdb, mti, cliname,
1683 rc = record_start_log(obd, &llh, cliname);
1687 rc = record_marker(obd, llh, fsdb, CM_START, cliname,
1689 rc = record_mount_opt(obd, llh, cliname, fsdb->fsdb_clilov,
1691 rc = record_marker(obd, llh, fsdb, CM_END, cliname,
1695 rc = record_end_log(obd, &llh);
1697 name_destroy(&cliname);
1699 // for_all_existing_mdt except current one
1700 for (i = 0; i < INDEX_MAP_SIZE * 8; i++){
1702 if (i != mti->mti_stripe_index &&
1703 cfs_test_bit(i, fsdb->fsdb_mdt_index_map)) {
1704 name_create_mdt(&mdtname, mti->mti_fsname, i);
1705 rc = mgs_write_log_mdc_to_mdt(obd, fsdb, mti, mdtname);
1706 name_destroy(&mdtname);
1713 /* Add the ost info to the client/mdt lov */
1714 static int mgs_write_log_osc_to_lov(struct obd_device *obd, struct fs_db *fsdb,
1715 struct mgs_target_info *mti,
1716 char *logname, char *suffix, char *lovname,
1717 enum lustre_sec_part sec_part, int flags)
1719 struct llog_handle *llh = NULL;
1720 char *nodeuuid, *oscname, *oscuuid, *lovuuid, *svname;
1725 CDEBUG(D_INFO, "adding osc for %s to log %s\n",
1726 mti->mti_svname, logname);
1728 if (mgs_log_is_empty(obd, logname)) {
1729 CERROR("log is empty! Logical error\n");
1733 name_create(&nodeuuid, libcfs_nid2str(mti->mti_nids[0]), "");
1734 name_create(&svname, mti->mti_svname, "-osc");
1735 name_create(&oscname, svname, suffix);
1736 name_create(&oscuuid, oscname, "_UUID");
1737 name_create(&lovuuid, lovname, "_UUID");
1740 #03 L add_uuid nid=uml1@tcp(0x20000c0a80201) 0: 1:uml1_UUID
1742 #04 L add_uuid nid=1@elan(0x1000000000001) nal=90 0: 1:uml1_UUID
1743 #04 L attach 0:OSC_uml1_ost1_MNT_client 1:osc 2:89070_lov1_a41dff51a
1744 #05 L setup 0:OSC_uml1_ost1_MNT_client 1:ost1_UUID 2:uml1_UUID
1746 #06 L add_uuid nid=uml2@tcp(0x20000c0a80202) 0: 1:uml2_UUID
1747 #07 L add_conn 0:OSC_uml1_ost1_MNT_client 1:uml2_UUID
1748 #08 L lov_modify_tgts add 0:lov1 1:ost1_UUID 2(index):0 3(gen):1
1751 rc = record_start_log(obd, &llh, logname);
1754 /* FIXME these should be a single journal transaction */
1755 rc = record_marker(obd, llh, fsdb, CM_START | flags, mti->mti_svname,
1757 for (i = 0; i < mti->mti_nid_count; i++) {
1758 CDEBUG(D_MGS, "add nid %s\n", libcfs_nid2str(mti->mti_nids[i]));
1759 rc = record_add_uuid(obd, llh, mti->mti_nids[i], nodeuuid);
1761 rc = record_attach(obd, llh, oscname, LUSTRE_OSC_NAME, lovuuid);
1762 rc = record_setup(obd, llh, oscname, mti->mti_uuid, nodeuuid, 0, 0);
1763 rc = mgs_write_log_failnids(obd, mti, llh, oscname);
1764 snprintf(index, sizeof(index), "%d", mti->mti_stripe_index);
1765 rc = record_lov_add(obd, llh, lovname, mti->mti_uuid, index, "1");
1766 rc = record_marker(obd, llh, fsdb, CM_END | flags, mti->mti_svname,
1768 rc = record_end_log(obd, &llh);
1770 name_destroy(&lovuuid);
1771 name_destroy(&oscuuid);
1772 name_destroy(&oscname);
1773 name_destroy(&svname);
1774 name_destroy(&nodeuuid);
1778 static int mgs_write_log_ost(struct obd_device *obd, struct fs_db *fsdb,
1779 struct mgs_target_info *mti)
1781 struct llog_handle *llh = NULL;
1782 char *logname, *lovname;
1783 char *ptr = mti->mti_params;
1784 int rc, flags = 0, failout = 0, i;
1787 CDEBUG(D_MGS, "writing new ost %s\n", mti->mti_svname);
1789 /* The ost startup log */
1791 /* If the ost log already exists, that means that someone reformatted
1792 the ost and it called target_add again. */
1793 if (!mgs_log_is_empty(obd, mti->mti_svname)) {
1794 LCONSOLE_ERROR_MSG(0x141, "The config log for %s already "
1795 "exists, yet the server claims it never "
1796 "registered. It may have been reformatted, "
1797 "or the index changed. writeconf the MDT to "
1798 "regenerate all logs.\n", mti->mti_svname);
1803 attach obdfilter ost1 ost1_UUID
1804 setup /dev/loop2 ldiskfs f|n errors=remount-ro,user_xattr
1806 if (class_find_param(ptr, PARAM_FAILMODE, &ptr) == 0)
1807 failout = (strncmp(ptr, "failout", 7) == 0);
1808 rc = record_start_log(obd, &llh, mti->mti_svname);
1811 /* FIXME these should be a single journal transaction */
1812 rc = record_marker(obd, llh, fsdb, CM_START, mti->mti_svname,"add ost");
1813 if (*mti->mti_uuid == '\0')
1814 snprintf(mti->mti_uuid, sizeof(mti->mti_uuid),
1815 "%s_UUID", mti->mti_svname);
1816 rc = record_attach(obd, llh, mti->mti_svname,
1817 "obdfilter"/*LUSTRE_OST_NAME*/, mti->mti_uuid);
1818 rc = record_setup(obd, llh, mti->mti_svname,
1819 "dev"/*ignored*/, "type"/*ignored*/,
1820 failout ? "n" : "f", 0/*options*/);
1821 rc = record_marker(obd, llh, fsdb, CM_END, mti->mti_svname, "add ost");
1822 rc = record_end_log(obd, &llh);
1824 /* We also have to update the other logs where this osc is part of
1827 if (cfs_test_bit(FSDB_OLDLOG14, &fsdb->fsdb_flags)) {
1828 /* If we're upgrading, the old mdt log already has our
1829 entry. Let's do a fake one for fun. */
1830 /* Note that we can't add any new failnids, since we don't
1831 know the old osc names. */
1832 flags = CM_SKIP | CM_UPGRADE146;
1834 } else if ((mti->mti_flags & LDD_F_UPDATE) != LDD_F_UPDATE) {
1835 /* If the update flag isn't set, don't update client/mdt
1838 LCONSOLE_WARN("Client log for %s was not updated; writeconf "
1839 "the MDT first to regenerate it.\n",
1843 /* Add ost to all MDT lov defs */
1844 for (i = 0; i < INDEX_MAP_SIZE * 8; i++){
1845 if (cfs_test_bit(i, fsdb->fsdb_mdt_index_map)) {
1848 name_create_mdt_and_lov(&logname, &lovname, fsdb, i);
1849 sprintf(mdt_index, "-MDT%04x", i);
1850 mgs_write_log_osc_to_lov(obd, fsdb, mti, logname,
1852 LUSTRE_SP_MDT, flags);
1853 name_destroy(&logname);
1854 name_destroy(&lovname);
1858 /* Append ost info to the client log */
1859 name_create(&logname, mti->mti_fsname, "-client");
1860 if (mgs_log_is_empty(obd, logname)) {
1861 /* Start client log */
1862 rc = mgs_write_log_lov(obd, fsdb, mti, logname,
1864 rc = mgs_write_log_lmv(obd, fsdb, mti, logname,
1867 mgs_write_log_osc_to_lov(obd, fsdb, mti, logname, "",
1868 fsdb->fsdb_clilov, LUSTRE_SP_CLI, flags);
1869 name_destroy(&logname);
1873 static __inline__ int mgs_param_empty(char *ptr)
1877 if ((tmp = strchr(ptr, '=')) && (*(++tmp) == '\0'))
1882 static int mgs_write_log_failnid_internal(struct obd_device *obd,
1884 struct mgs_target_info *mti,
1885 char *logname, char *cliname)
1888 struct llog_handle *llh = NULL;
1890 if (mgs_param_empty(mti->mti_params)) {
1891 /* Remove _all_ failnids */
1892 rc = mgs_modify(obd, fsdb, mti, logname,
1893 mti->mti_svname, "add failnid", CM_SKIP);
1897 /* Otherwise failover nids are additive */
1898 rc = record_start_log(obd, &llh, logname);
1900 /* FIXME this should be a single journal transaction */
1901 rc = record_marker(obd, llh, fsdb, CM_START,
1902 mti->mti_svname, "add failnid");
1903 rc = mgs_write_log_failnids(obd, mti, llh, cliname);
1904 rc = record_marker(obd, llh, fsdb, CM_END,
1905 mti->mti_svname, "add failnid");
1906 rc = record_end_log(obd, &llh);
1913 /* Add additional failnids to an existing log.
1914 The mdc/osc must have been added to logs first */
1915 /* tcp nids must be in dotted-quad ascii -
1916 we can't resolve hostnames from the kernel. */
1917 static int mgs_write_log_add_failnid(struct obd_device *obd, struct fs_db *fsdb,
1918 struct mgs_target_info *mti)
1920 char *logname, *cliname;
1924 /* FIXME we currently can't erase the failnids
1925 * given when a target first registers, since they aren't part of
1926 * an "add uuid" stanza */
1928 /* Verify that we know about this target */
1929 if (mgs_log_is_empty(obd, mti->mti_svname)) {
1930 LCONSOLE_ERROR_MSG(0x142, "The target %s has not registered "
1931 "yet. It must be started before failnids "
1932 "can be added.\n", mti->mti_svname);
1936 /* Create mdc/osc client name (e.g. lustre-OST0001-osc) */
1937 if (mti->mti_flags & LDD_F_SV_TYPE_MDT) {
1938 name_create(&cliname, mti->mti_svname, "-mdc");
1939 } else if (mti->mti_flags & LDD_F_SV_TYPE_OST) {
1940 name_create(&cliname, mti->mti_svname, "-osc");
1945 /* Add failover nids to the client log */
1946 name_create(&logname, mti->mti_fsname, "-client");
1947 rc = mgs_write_log_failnid_internal(obd, fsdb, mti, logname, cliname);
1948 name_destroy(&logname);
1949 name_destroy(&cliname);
1951 if (mti->mti_flags & LDD_F_SV_TYPE_OST) {
1952 /* Add OST failover nids to the MDT logs as well */
1955 for (i = 0; i < INDEX_MAP_SIZE * 8; i++) {
1956 if (!cfs_test_bit(i, fsdb->fsdb_mdt_index_map))
1958 name_create_mdt(&logname, mti->mti_fsname, i);
1959 name_create_mdt_osc(&cliname, mti->mti_svname, fsdb, i);
1960 rc = mgs_write_log_failnid_internal(obd, fsdb, mti,
1962 name_destroy(&cliname);
1963 name_destroy(&logname);
1970 static int mgs_wlp_lcfg(struct obd_device *obd, struct fs_db *fsdb,
1971 struct mgs_target_info *mti,
1972 char *logname, struct lustre_cfg_bufs *bufs,
1973 char *tgtname, char *ptr)
1975 char comment[MTI_NAME_MAXLEN];
1977 struct lustre_cfg *lcfg;
1980 /* Erase any old settings of this same parameter */
1981 memcpy(comment, ptr, MTI_NAME_MAXLEN);
1982 comment[MTI_NAME_MAXLEN - 1] = 0;
1983 /* But don't try to match the value. */
1984 if ((tmp = strchr(comment, '=')))
1986 /* FIXME we should skip settings that are the same as old values */
1987 rc = mgs_modify(obd, fsdb, mti, logname, tgtname, comment, CM_SKIP);
1988 del = mgs_param_empty(ptr);
1990 LCONSOLE_INFO("%sing parameter %s.%s in log %s\n", del ? "Disabl" : rc ?
1991 "Sett" : "Modify", tgtname, comment, logname);
1995 lustre_cfg_bufs_reset(bufs, tgtname);
1996 lustre_cfg_bufs_set_string(bufs, 1, ptr);
1997 lcfg = lustre_cfg_new(LCFG_PARAM, bufs);
2000 rc = mgs_write_log_direct(obd, fsdb, logname, lcfg, tgtname, comment);
2001 lustre_cfg_free(lcfg);
2005 /* write global variable settings into log */
2006 static int mgs_write_log_sys(struct obd_device *obd, struct fs_db *fsdb,
2007 struct mgs_target_info *mti, char *sys, char *ptr)
2009 struct lustre_cfg_bufs bufs;
2010 struct lustre_cfg *lcfg;
2012 int rc, cmd, convert = 1;
2014 if (class_match_param(ptr, PARAM_TIMEOUT, &tmp) == 0) {
2015 cmd = LCFG_SET_TIMEOUT;
2016 } else if (class_match_param(ptr, PARAM_LDLM_TIMEOUT, &tmp) == 0) {
2017 cmd = LCFG_SET_LDLM_TIMEOUT;
2018 /* Check for known params here so we can return error to lctl */
2019 } else if ((class_match_param(ptr, PARAM_AT_MIN, &tmp) == 0) ||
2020 (class_match_param(ptr, PARAM_AT_MAX, &tmp) == 0) ||
2021 (class_match_param(ptr, PARAM_AT_EXTRA, &tmp) == 0) ||
2022 (class_match_param(ptr, PARAM_AT_EARLY_MARGIN, &tmp) == 0) ||
2023 (class_match_param(ptr, PARAM_AT_HISTORY, &tmp) == 0)) {
2025 } else if (class_match_param(ptr, PARAM_JOBID_VAR, &tmp) == 0) {
2026 convert = 0; /* Don't convert string value to integer */
2032 if (mgs_param_empty(ptr))
2033 CDEBUG(D_MGS, "global '%s' removed\n", sys);
2035 CDEBUG(D_MGS, "global '%s' val=%s\n", sys, tmp);
2037 lustre_cfg_bufs_reset(&bufs, NULL);
2038 lustre_cfg_bufs_set_string(&bufs, 1, sys);
2039 if (!convert && *tmp != '\0')
2040 lustre_cfg_bufs_set_string(&bufs, 2, tmp);
2041 lcfg = lustre_cfg_new(cmd, &bufs);
2042 lcfg->lcfg_num = convert ? simple_strtoul(tmp, NULL, 0) : 0;
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);