1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2 * vim:expandtab:shiftwidth=8:tabstop=8:
4 * lustre/mgc/mgc_request.c
5 * Lustre Management Client config llog handling
7 * Copyright (C) 2006 Cluster File Systems, Inc.
8 * Author Nathan Rutman <nathan@clusterfs.com>
10 * This file is part of Lustre, http://www.lustre.org
12 * Lustre is free software; you can redistribute it and/or
13 * modify it under the terms of version 2 of the GNU General Public
14 * License as published by the Free Software Foundation.
16 * Lustre is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with Lustre; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 * For testing and management it is treated as an obd_device,
26 * although * it does not export a full OBD method table (the
27 * requests are coming * in over the wire, so object target modules
28 * do not have a full * method table.)
32 # define EXPORT_SYMTAB
34 #define DEBUG_SUBSYSTEM S_MGC
35 #define D_MGC D_CONFIG|D_WARNING
38 # include <linux/module.h>
39 # include <linux/pagemap.h>
40 # include <linux/miscdevice.h>
41 # include <linux/init.h>
43 # include <liblustre.h>
46 #include <linux/obd_class.h>
47 #include <linux/lustre_dlm.h>
48 #include <linux/lustre_log.h>
49 #include <linux/lustre_fsfilt.h>
50 #include <linux/lustre_disk.h>
51 #include <linux/lustre_mgs.h>
54 int mgc_logname2resid(char *logname, struct ldlm_res_id *res_id)
60 /* fsname is at most 8 chars long at the beginning of the logname
61 e.g. "lustre-MDT0001" or "lustre" */
62 name_end = strchr(logname, '-');
64 len = name_end - logname;
66 len = strlen(logname);
68 memcpy(&resname, logname, len);
70 memset(res_id, 0, sizeof(*res_id));
71 /* FIXME are resid names swabbed across the wire? */
72 res_id->name[0] = cpu_to_le64(resname);
73 CDEBUG(D_MGC, "log %s to resid "LPX64"/"LPX64" (%.8s)\n", logname,
74 res_id->name[0], res_id->name[1], (char *)&res_id->name[0]);
77 EXPORT_SYMBOL(mgc_logname2resid);
79 /********************** config llog list **********************/
80 DECLARE_MUTEX(config_llog_lock);
81 struct list_head config_llog_list = LIST_HEAD_INIT(config_llog_list);
83 /* Find log and take the global log sem. I don't want mutliple processes
84 running process_log at once -- sounds like badness. It actually might be
85 fine, as long as we're not trying to update from the same log
86 simultaneously (in which case we should use a per-log sem.) */
87 static struct config_llog_data *config_log_get(char *logname,
88 struct config_llog_instance *cfg)
90 struct list_head *tmp;
91 struct config_llog_data *cld;
92 int match_instance = 0;
95 CDEBUG(D_MGC, "get log %s:%s\n", logname ? logname : "-",
96 cfg->cfg_instance ? cfg->cfg_instance : "-");
97 if (cfg->cfg_instance)
101 down(&config_llog_lock);
102 list_for_each(tmp, &config_llog_list) {
103 cld = list_entry(tmp, struct config_llog_data, cld_list_chain);
104 if (match_instance &&
105 strcmp(cfg->cfg_instance, cld->cld_cfg.cfg_instance) == 0)
108 if (!match_instance &&
109 strcmp(logname, cld->cld_logname) == 0)
112 up(&config_llog_lock);
113 CERROR("can't get log %s\n", logname);
114 return(ERR_PTR(-ENOENT));
117 static void config_log_put(void)
119 up(&config_llog_lock);
122 /* Add this log to our list of active logs.
123 We have one active log per "mount" - client instance or servername.
124 Each instance may be at a different point in the log. */
125 static int config_log_add(char *logname, struct config_llog_instance *cfg,
126 struct super_block *sb)
128 struct config_llog_data *cld;
132 CDEBUG(D_MGC, "adding config log %s:%s\n", logname, cfg->cfg_instance);
134 down(&config_llog_lock);
135 OBD_ALLOC(cld, sizeof(*cld));
137 GOTO(out, rc = -ENOMEM);
138 OBD_ALLOC(cld->cld_logname, strlen(logname) + 1);
139 if (!cld->cld_logname) {
140 OBD_FREE(cld, sizeof(*cld));
141 GOTO(out, rc = -ENOMEM);
143 strcpy(cld->cld_logname, logname);
145 cld->cld_cfg.cfg_last_idx = 0;
146 cld->cld_cfg.cfg_flags = 0;
147 cld->cld_cfg.cfg_sb = sb;
148 if (cfg->cfg_instance != NULL) {
149 OBD_ALLOC(cld->cld_cfg.cfg_instance,
150 strlen(cfg->cfg_instance) + 1);
151 strcpy(cld->cld_cfg.cfg_instance, cfg->cfg_instance);
153 mgc_logname2resid(logname, &cld->cld_resid);
154 list_add(&cld->cld_list_chain, &config_llog_list);
156 up(&config_llog_lock);
160 /* Stop watching for updates on this log. 2 clients on the same node
161 may be at different gens, so we need different log info (eg.
162 already mounted client is at gen 10, but must start a new client
164 static int config_log_end(char *logname, struct config_llog_instance *cfg)
166 struct config_llog_data *cld;
170 cld = config_log_get(logname, cfg);
172 RETURN(PTR_ERR(cld));
174 OBD_FREE(cld->cld_logname, strlen(cld->cld_logname) + 1);
175 if (cld->cld_cfg.cfg_instance != NULL)
176 OBD_FREE(cld->cld_cfg.cfg_instance,
177 strlen(cfg->cfg_instance) + 1);
179 list_del(&cld->cld_list_chain);
180 OBD_FREE(cld, sizeof(*cld));
182 CDEBUG(D_MGC, "dropped config log %s (%d)\n", logname, rc);
186 static void config_log_end_all(void)
188 struct list_head *tmp, *n;
189 struct config_llog_data *cld;
192 down(&config_llog_lock);
193 list_for_each_safe(tmp, n, &config_llog_list) {
194 cld = list_entry(tmp, struct config_llog_data, cld_list_chain);
195 CERROR("conflog failsafe %s\n", cld->cld_logname);
196 OBD_FREE(cld->cld_logname, strlen(cld->cld_logname) + 1);
197 if (cld->cld_cfg.cfg_instance != NULL)
198 OBD_FREE(cld->cld_cfg.cfg_instance,
199 strlen(cld->cld_cfg.cfg_instance) + 1);
200 list_del(&cld->cld_list_chain);
201 OBD_FREE(cld, sizeof(*cld));
203 up(&config_llog_lock);
208 /********************** class fns **********************/
210 static int mgc_fs_setup(struct obd_device *obd, struct super_block *sb,
211 struct vfsmount *mnt)
213 struct lvfs_run_ctxt saved;
214 struct lustre_sb_info *lsi = s2lsi(sb);
215 struct client_obd *cli = &obd->u.cli;
216 struct dentry *dentry;
221 LASSERT(lsi->lsi_srv_mnt == mnt);
223 /* The mgc fs exclusion sem. Only one fs can be setup at a time.
224 Maybe just overload the cl_sem? */
225 down(&cli->cl_mgc_sem);
227 obd->obd_fsops = fsfilt_get_ops(MT_STR(lsi->lsi_ldd));
228 if (IS_ERR(obd->obd_fsops)) {
229 up(&cli->cl_mgc_sem);
230 CERROR("No fstype %s rc=%ld\n", MT_STR(lsi->lsi_ldd),
231 PTR_ERR(obd->obd_fsops));
232 RETURN(PTR_ERR(obd->obd_fsops));
235 cli->cl_mgc_vfsmnt = mnt;
236 // FIXME which is the right SB? - filter_common_setup also
237 CDEBUG(D_MGC, "SB's: fill=%p mnt=%p root=%p\n", sb, mnt->mnt_sb,
238 mnt->mnt_root->d_inode->i_sb);
239 fsfilt_setup(obd, mnt->mnt_sb);
241 OBD_SET_CTXT_MAGIC(&obd->obd_lvfs_ctxt);
242 obd->obd_lvfs_ctxt.pwdmnt = mnt;
243 obd->obd_lvfs_ctxt.pwd = mnt->mnt_root;
244 obd->obd_lvfs_ctxt.fs = get_ds();
246 push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
247 dentry = lookup_one_len(MOUNT_CONFIGS_DIR, current->fs->pwd,
248 strlen(MOUNT_CONFIGS_DIR));
249 pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
250 if (IS_ERR(dentry)) {
251 err = PTR_ERR(dentry);
252 CERROR("cannot lookup %s directory: rc = %d\n",
253 MOUNT_CONFIGS_DIR, err);
256 cli->cl_mgc_configs_dir = dentry;
258 /* We keep the cl_mgc_sem until mgc_fs_cleanup */
262 fsfilt_put_ops(obd->obd_fsops);
263 obd->obd_fsops = NULL;
264 cli->cl_mgc_vfsmnt = NULL;
265 up(&cli->cl_mgc_sem);
269 static int mgc_fs_cleanup(struct obd_device *obd)
271 struct client_obd *cli = &obd->u.cli;
275 LASSERT(cli->cl_mgc_vfsmnt != NULL);
277 if (cli->cl_mgc_configs_dir != NULL) {
278 struct lvfs_run_ctxt saved;
279 push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
280 l_dput(cli->cl_mgc_configs_dir);
281 cli->cl_mgc_configs_dir = NULL;
282 pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
285 cli->cl_mgc_vfsmnt = NULL;
287 fsfilt_put_ops(obd->obd_fsops);
289 up(&cli->cl_mgc_sem);
293 static int mgc_cleanup(struct obd_device *obd)
295 struct client_obd *cli = &obd->u.cli;
298 /* FIXME calls to mgc_fs_setup must take an obd ref to insure there's
299 no fs by the time we get here. */
300 LASSERT(cli->cl_mgc_vfsmnt == NULL);
302 rc = obd_llog_finish(obd, 0);
304 CERROR("failed to cleanup llogging subsystems\n");
308 config_log_end_all();
310 return client_obd_cleanup(obd);
313 static struct obd_device *the_mgc;
315 static int mgc_setup(struct obd_device *obd, obd_count len, void *buf)
322 rc = client_obd_setup(obd, len, buf);
324 GOTO(err_decref, rc);
326 rc = obd_llog_init(obd, obd, 0, NULL);
328 CERROR("failed to setup llogging subsystems\n");
329 GOTO(err_cleanup, rc);
336 client_obd_cleanup(obd);
342 static int mgc_process_log(struct obd_device *mgc,
343 struct config_llog_data *cld);
345 /* FIXME I don't want a thread for every cld; make a list of cld's to requeue
346 and use only 1 thread. */
347 /* reenqueue the lock, reparse the log */
348 static int mgc_async_requeue(void *data)
350 struct config_llog_data *cld = (struct config_llog_data *)data;
360 SIGNAL_MASK_LOCK(current, flags);
361 sigfillset(¤t->blocked);
363 SIGNAL_MASK_UNLOCK(current, flags);
364 THREAD_NAME(current->comm, sizeof(current->comm) - 1, "reQ %s",
368 CDEBUG(D_MGC, "requeue "LPX64" %s:%s\n",
369 cld->cld_resid.name[0], cld->cld_logname,
370 cld->cld_cfg.cfg_instance);
373 class_export_get(the_mgc->obd_self_export);
374 /* FIXME sleep a few seconds here to allow the server who caused
375 the lock revocation to finish its setup */
378 /* Re-send server info every time, in case MGS needs to regen its
379 logs (for write_conf). Do we need this? It's extra RPCs for
380 every server at every update. */
381 server_register_target(cld->cld_cfg.cfg_sb);
384 rc = mgc_process_log(the_mgc, cld);
386 class_export_put(the_mgc->obd_self_export);
390 /* based on ll_mdc_blocking_ast */
391 static int mgc_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
392 void *data, int flag)
394 struct lustre_handle lockh;
399 case LDLM_CB_BLOCKING:
400 /* mgs wants the lock, give it up... */
401 LDLM_DEBUG(lock, "MGC blocking CB");
402 ldlm_lock2handle(lock, &lockh);
403 rc = ldlm_cli_cancel(&lockh);
405 case LDLM_CB_CANCELING: {
406 /* We've given up the lock, prepare ourselves to update. */
407 LDLM_DEBUG(lock, "MGC cancel CB");
409 CDEBUG(D_MGC, "Lock res "LPX64" (%.8s)\n",
410 lock->l_resource->lr_name.name[0],
411 (char *)&lock->l_resource->lr_name.name[0]);
413 /* Make sure not to re-enqueue when the mgc is stopping
414 (we get called from client_disconnect_export) */
415 if (!lock->l_conn_export ||
416 !lock->l_conn_export->exp_obd->u.cli.cl_conn_count) {
417 CDEBUG(D_MGC, "Disconnecting, don't requeue\n");
420 if (lock->l_req_mode != lock->l_granted_mode) {
421 CERROR("original grant failed, won't requeue\n");
425 CERROR("missing data, won't requeue\n");
429 /* Re-enqueue the lock in a separate thread, because we must
430 return from this fn before that lock can be taken. */
431 rc = kernel_thread(mgc_async_requeue, data,
432 CLONE_VM | CLONE_FS);
434 CERROR("Cannot re-enqueue thread: %d\n", rc);
444 CERROR("%s CB failed %d:\n", flag == LDLM_CB_BLOCKING ?
445 "blocking" : "cancel", rc);
446 LDLM_ERROR(lock, "MGC ast");
451 /* Take a config lock so we can get cancel notifications */
452 static int mgc_enqueue(struct obd_export *exp, struct lov_stripe_md *lsm,
453 __u32 type, ldlm_policy_data_t *policy, __u32 mode,
454 int *flags, void *bl_cb, void *cp_cb, void *gl_cb,
455 void *data, __u32 lvb_len, void *lvb_swabber,
456 struct lustre_handle *lockh)
458 struct config_llog_data *cld = (struct config_llog_data *)data;
459 struct obd_device *obd = class_exp2obd(exp);
463 CDEBUG(D_MGC, "Enqueue for %s (res "LPX64")\n", cld->cld_logname,
464 cld->cld_resid.name[0]);
466 /* We need a callback for every lockholder, so don't try to
467 ldlm_lock_match (see rev 1.1.2.11.2.47) */
469 rc = ldlm_cli_enqueue(exp, NULL, obd->obd_namespace, cld->cld_resid,
470 type, NULL, mode, flags,
471 mgc_blocking_ast, ldlm_completion_ast, NULL,
472 data, NULL, 0, NULL, lockh);
477 static int mgc_cancel(struct obd_export *exp, struct lov_stripe_md *md,
478 __u32 mode, struct lustre_handle *lockh)
482 ldlm_lock_decref(lockh, mode);
488 static int mgc_iocontrol(unsigned int cmd, struct obd_export *exp, int len,
489 void *karg, void *uarg)
491 struct obd_device *obd = exp->exp_obd;
492 struct obd_ioctl_data *data = karg;
493 struct llog_ctxt *ctxt;
494 struct lvfs_run_ctxt saved;
498 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
501 if (!try_module_get(THIS_MODULE)) {
502 CERROR("Can't get module. Is it alive?");
507 /* REPLicator context */
508 case OBD_IOC_PARSE: {
509 CERROR("MGC parsing llog %s\n", data->ioc_inlbuf1);
510 ctxt = llog_get_context(exp->exp_obd, LLOG_CONFIG_REPL_CTXT);
511 rc = class_config_parse_llog(ctxt, data->ioc_inlbuf1, NULL);
515 case OBD_IOC_LLOG_INFO:
516 case OBD_IOC_LLOG_PRINT: {
517 ctxt = llog_get_context(obd, LLOG_CONFIG_REPL_CTXT);
518 rc = llog_ioctl(ctxt, cmd, data);
523 /* ORIGinator context */
524 case OBD_IOC_DUMP_LOG: {
525 ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT);
526 push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
527 rc = class_config_dump_llog(ctxt, data->ioc_inlbuf1, NULL);
528 pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
535 CERROR("mgc_ioctl(): unrecognised ioctl %#x\n", cmd);
536 GOTO(out, rc = -ENOTTY);
539 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
542 module_put(THIS_MODULE);
549 /* Send target_reg message to MGS */
550 static int mgc_target_register(struct obd_export *exp,
551 struct mgs_target_info *mti)
553 struct ptlrpc_request *req;
554 struct mgs_target_info *req_mti, *rep_mti;
555 int size = sizeof(*req_mti);
556 int rep_size = sizeof(*mti);
560 req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MGS_VERSION,
561 MGS_TARGET_REG, 1, &size, NULL);
563 RETURN(rc = -ENOMEM);
565 req_mti = lustre_msg_buf(req->rq_reqmsg, 0, sizeof(*req_mti));
566 memcpy(req_mti, mti, sizeof(*req_mti));
568 req->rq_replen = lustre_msg_size(1, &rep_size);
570 CDEBUG(D_MGC, "register %s\n", mti->mti_svname);
572 rc = ptlrpc_queue_wait(req);
574 rep_mti = lustre_swab_repbuf(req, 0, sizeof(*rep_mti),
575 lustre_swab_mgs_target_info);
576 memcpy(mti, rep_mti, sizeof(*rep_mti));
577 CDEBUG(D_MGC, "register %s got index = %d\n",
578 mti->mti_svname, mti->mti_stripe_index);
580 CERROR("register failed. rc=%d\n", rc);
582 ptlrpc_req_finished(req);
587 int mgc_set_info(struct obd_export *exp, obd_count keylen,
588 void *key, obd_count vallen, void *val)
590 struct obd_import *imp = class_exp2cliimp(exp);
594 /* Try to "recover" the initial connection; i.e. retry */
595 if (KEY_IS(KEY_INIT_RECOV)) {
596 if (vallen != sizeof(int))
598 imp->imp_initial_recov = *(int *)val;
599 CDEBUG(D_HA, "%s: set imp_initial_recov = %d\n",
600 exp->exp_obd->obd_name, imp->imp_initial_recov);
603 /* Turn off initial_recov after we try all backup servers once */
604 if (KEY_IS(KEY_INIT_RECOV_BACKUP)) {
605 if (vallen != sizeof(int))
607 imp->imp_initial_recov_bk = *(int *)val;
608 CDEBUG(D_HA, "%s: set imp_initial_recov_bk = %d\n",
609 exp->exp_obd->obd_name, imp->imp_initial_recov_bk);
610 if (imp->imp_invalid) {
611 /* Resurrect if we previously died */
612 CDEBUG(D_MGC, "Reactivate %s %d:%d:%d\n",
613 imp->imp_obd->obd_name,
614 imp->imp_deactive, imp->imp_invalid,
616 /* can't put this in obdclass, module loop with ptlrpc*/
617 /* remove 'invalid' flag */
618 ptlrpc_activate_import(imp);
620 ptlrpc_set_import_active(imp, 1);
621 //ptlrpc_recover_import(imp);
626 if (KEY_IS("register_target")) {
627 struct mgs_target_info *mti;
628 if (vallen != sizeof(struct mgs_target_info))
630 mti = (struct mgs_target_info *)val;
631 CDEBUG(D_MGC, "register_target %s %#x\n",
632 mti->mti_svname, mti->mti_flags);
633 rc = mgc_target_register(exp, mti);
636 if (KEY_IS("set_fs")) {
637 struct super_block *sb = (struct super_block *)val;
638 struct lustre_sb_info *lsi;
639 if (vallen != sizeof(struct super_block))
642 rc = mgc_fs_setup(exp->exp_obd, sb, lsi->lsi_srv_mnt);
644 CERROR("set_fs got %d\n", rc);
648 if (KEY_IS("clear_fs")) {
651 rc = mgc_fs_cleanup(exp->exp_obd);
653 CERROR("clear_fs got %d\n", rc);
661 static int mgc_import_event(struct obd_device *obd,
662 struct obd_import *imp,
663 enum obd_import_event event)
667 LASSERT(imp->imp_obd == obd);
670 case IMP_EVENT_INVALIDATE: {
671 struct ldlm_namespace *ns = obd->obd_namespace;
673 ldlm_namespace_cleanup(ns, LDLM_FL_LOCAL_ONLY);
677 case IMP_EVENT_DISCON:
678 case IMP_EVENT_INACTIVE:
679 case IMP_EVENT_ACTIVE:
683 CERROR("Unknown import event %#x\n", event);
689 static int mgc_llog_init(struct obd_device *obd, struct obd_device *tgt,
690 int count, struct llog_catid *logid)
692 struct llog_ctxt *ctxt;
696 rc = llog_setup(obd, LLOG_CONFIG_ORIG_CTXT, tgt, 0, NULL,
701 rc = llog_setup(obd, LLOG_CONFIG_REPL_CTXT, tgt, 0, NULL,
704 ctxt = llog_get_context(obd, LLOG_CONFIG_REPL_CTXT);
705 ctxt->loc_imp = obd->u.cli.cl_import;
711 static int mgc_llog_finish(struct obd_device *obd, int count)
716 rc = llog_cleanup(llog_get_context(obd, LLOG_CONFIG_REPL_CTXT));
717 rc = llog_cleanup(llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT));
722 /* identical to mgs_log_is_empty */
723 static int mgc_llog_is_empty(struct obd_device *obd, struct llog_ctxt *ctxt,
726 struct lvfs_run_ctxt saved;
727 struct llog_handle *llh;
730 push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
731 rc = llog_create(ctxt, &llh, NULL, name);
733 llog_init_handle(llh, LLOG_F_IS_PLAIN, NULL);
734 rc = llog_get_size(llh);
737 pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
738 /* header is record 1 */
742 static int mgc_copy_handler(struct llog_handle *llh, struct llog_rec_hdr *rec,
745 struct llog_rec_hdr local_rec = *rec;
746 struct llog_handle *local_llh = (struct llog_handle *)data;
747 char *cfg_buf = (char*) (rec + 1);
748 struct lustre_cfg *lcfg;
752 lcfg = (struct lustre_cfg *)cfg_buf;
754 /* FIXME we should always write to an empty log, so remove this check.*/
755 /* append new records */
756 if (rec->lrh_index >= llog_get_size(local_llh)) {
757 rc = llog_write_rec(local_llh, &local_rec, NULL, 0,
758 (void *)cfg_buf, -1);
760 CDEBUG(D_INFO, "idx=%d, rc=%d, len=%d, cmd %x %s %s\n",
761 rec->lrh_index, rc, rec->lrh_len, lcfg->lcfg_command,
762 lustre_cfg_string(lcfg, 0), lustre_cfg_string(lcfg, 1));
764 CDEBUG(D_INFO, "skip idx=%d\n", rec->lrh_index);
770 static int mgc_copy_llog(struct obd_device *obd, struct llog_ctxt *rctxt,
771 struct llog_ctxt *lctxt, char *logname)
773 struct llog_handle *local_llh, *remote_llh;
774 struct obd_uuid *uuid;
779 rc = llog_create(lctxt, &local_llh, NULL, logname);
782 /* set the log header uuid for fun */
784 obd_str2uuid(uuid, logname);
785 rc = llog_init_handle(local_llh, LLOG_F_IS_PLAIN, uuid);
788 GOTO(out_closel, rc);
790 /* FIXME write new log to a temp name, then vfs_rename over logname
791 upon successful completion. */
793 /* open remote log */
794 rc = llog_create(rctxt, &remote_llh, NULL, logname);
796 GOTO(out_closel, rc);
797 rc = llog_init_handle(remote_llh, LLOG_F_IS_PLAIN, NULL);
799 GOTO(out_closer, rc);
801 rc = llog_process(remote_llh, mgc_copy_handler,(void *)local_llh, NULL);
804 rc2 = llog_close(remote_llh);
808 rc2 = llog_close(local_llh);
812 CDEBUG(D_MGC, "Copied remote log %s (%d)\n", logname, rc);
816 /* Get a config log from the MGS and process it.
817 This func is called for both clients and servers. */
818 static int mgc_process_log(struct obd_device *mgc,
819 struct config_llog_data *cld)
821 struct llog_ctxt *ctxt, *lctxt;
822 struct lustre_handle lockh;
823 struct client_obd *cli = &mgc->u.cli;
824 struct lvfs_run_ctxt saved;
825 struct lustre_sb_info *lsi = s2lsi(cld->cld_cfg.cfg_sb);
826 int rc, rcl, flags = 0, must_pop = 0;
829 CDEBUG(D_MGC, "Process log %s:%s from %d\n", cld->cld_logname,
830 cld->cld_cfg.cfg_instance, cld->cld_cfg.cfg_last_idx + 1);
832 ctxt = llog_get_context(mgc, LLOG_CONFIG_REPL_CTXT);
834 CERROR("missing llog context\n");
838 /* Get the cfg lock on the llog */
839 rcl = mgc_enqueue(mgc->u.cli.cl_mgc_mgsexp, NULL, LDLM_PLAIN, NULL,
840 LCK_CR, &flags, NULL, NULL, NULL,
841 cld, 0, NULL, &lockh);
843 CERROR("Can't get cfg lock: %d\n", rcl);
845 lctxt = llog_get_context(mgc, LLOG_CONFIG_ORIG_CTXT);
847 /* Copy the setup log locally if we can. Don't mess around if we're
848 running an MGS though (logs are already local). */
849 if (lctxt && lsi && (lsi->lsi_flags & LSI_SERVER) &&
850 (lsi->lsi_srv_mnt == cli->cl_mgc_vfsmnt) &&
851 !IS_MGS(lsi->lsi_ldd)) {
852 push_ctxt(&saved, &mgc->obd_lvfs_ctxt, NULL);
855 /* Only try to copy log if we have the lock. */
856 rc = mgc_copy_llog(mgc, ctxt, lctxt, cld->cld_logname);
858 if (mgc_llog_is_empty(mgc, lctxt, cld->cld_logname)) {
859 LCONSOLE_ERROR("Failed to get MGS log %s "
860 "and no local copy.\n",
862 GOTO(out_pop, rc = -ENOTCONN);
864 LCONSOLE_WARN("Failed to get MGS log %s, using "
865 "local copy.\n", cld->cld_logname);
867 /* Now, whether we copied or not, start using the local llog.
868 If we failed to copy, we'll start using whatever the old
873 /* logname and instance info should be the same, so use our
874 copy of the instance for the update. The cfg_last_idx will
876 rc = class_config_parse_llog(ctxt, cld->cld_logname, &cld->cld_cfg);
880 pop_ctxt(&saved, &mgc->obd_lvfs_ctxt, NULL);
882 /* Now drop the lock so MGS can revoke it */
884 rcl = mgc_cancel(mgc->u.cli.cl_mgc_mgsexp, NULL,
887 CERROR("Can't drop cfg lock: %d\n", rcl);
891 CERROR("%s: the configuration '%s' could not be read "
892 "(%d) from the MGS.\n",
893 mgc->obd_name, cld->cld_logname, rc);
899 static int mgc_process_config(struct obd_device *obd, obd_count len, void *buf)
901 struct lustre_cfg *lcfg = buf;
906 switch(cmd = lcfg->lcfg_command) {
907 case LCFG_LOV_ADD_OBD: {
908 struct mgs_target_info *mti;
910 if (LUSTRE_CFG_BUFLEN(lcfg, 1) !=
911 sizeof(struct mgs_target_info))
912 GOTO(out, rc = -EINVAL);
914 mti = (struct mgs_target_info *)lustre_cfg_buf(lcfg, 1);
915 CDEBUG(D_MGC, "add_target %s %#x\n",
916 mti->mti_svname, mti->mti_flags);
917 rc = mgc_target_register(obd->u.cli.cl_mgc_mgsexp, mti);
920 case LCFG_LOV_DEL_OBD:
922 CERROR("lov_del_obd unimplemented\n");
925 case LCFG_LOG_START: {
926 struct config_llog_data *cld;
927 struct config_llog_instance *cfg;
928 struct super_block *sb;
929 char *logname = lustre_cfg_string(lcfg, 1);
930 cfg = (struct config_llog_instance *)lustre_cfg_buf(lcfg, 2);
931 sb = *(struct super_block **)lustre_cfg_buf(lcfg, 3);
933 CDEBUG(D_MGC, "parse_log %s from %d\n", logname,
936 /* We're only called through here on the initial mount */
937 config_log_add(logname, cfg, sb);
939 cld = config_log_get(logname, cfg);
944 /* For old logs, there was no start marker. */
945 /* FIXME only set this for old logs! */
946 cld->cld_cfg.cfg_flags |= CFG_F_MARKER;
948 rc = mgc_process_log(obd, cld);
954 struct config_llog_instance *cfg = NULL;
955 char *logname = lustre_cfg_string(lcfg, 1);
956 if (lcfg->lcfg_bufcount >= 2)
957 cfg = (struct config_llog_instance *)lustre_cfg_buf(
959 rc = config_log_end(logname, cfg);
963 CERROR("Unknown command: %d\n", lcfg->lcfg_command);
964 GOTO(out, rc = -EINVAL);
972 struct obd_ops mgc_obd_ops = {
973 .o_owner = THIS_MODULE,
974 .o_setup = mgc_setup,
975 .o_cleanup = mgc_cleanup,
976 .o_add_conn = client_import_add_conn,
977 .o_del_conn = client_import_del_conn,
978 .o_connect = client_connect_import,
979 .o_disconnect = client_disconnect_export,
980 //.o_enqueue = mgc_enqueue,
981 .o_cancel = mgc_cancel,
982 //.o_iocontrol = mgc_iocontrol,
983 .o_set_info = mgc_set_info,
984 .o_import_event = mgc_import_event,
985 .o_llog_init = mgc_llog_init,
986 .o_llog_finish = mgc_llog_finish,
987 .o_process_config = mgc_process_config,
990 int __init mgc_init(void)
992 return class_register_type(&mgc_obd_ops, NULL, LUSTRE_MGC_NAME);
996 static void /*__exit*/ mgc_exit(void)
998 class_unregister_type(LUSTRE_MGC_NAME);
1001 MODULE_AUTHOR("Cluster File Systems, Inc. <info@clusterfs.com>");
1002 MODULE_DESCRIPTION("Lustre Management Client");
1003 MODULE_LICENSE("GPL");
1005 module_init(mgc_init);
1006 module_exit(mgc_exit);