1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2 * vim:expandtab:shiftwidth=8:tabstop=8:
4 * lustre/mgs/mgs_handler.c
5 * Lustre Management Server (mgs) request handler
7 * Copyright (C) 2001-2005 Cluster File Systems, Inc.
8 * Author Nathan <nathan@clusterfs.com>
9 * Author LinSongTao <lincent@clusterfs.com>
11 * This file is part of Lustre, http://www.lustre.org.
13 * Lustre is free software; you can redistribute it and/or
14 * modify it under the terms of version 2 of the GNU General Public
15 * License as published by the Free Software Foundation.
17 * Lustre is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with Lustre; if not, write to the Free Software
24 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28 # define EXPORT_SYMTAB
30 #define DEBUG_SUBSYSTEM S_MGS
31 #define D_MGS D_INFO|D_ERROR
34 # include <linux/module.h>
35 # include <linux/pagemap.h>
36 # include <linux/miscdevice.h>
37 # include <linux/init.h>
39 # include <liblustre.h>
42 #include <linux/obd_class.h>
43 #include <linux/lustre_dlm.h>
44 #include <linux/lprocfs_status.h>
45 #include <linux/lustre_fsfilt.h>
46 #include <linux/lustre_commit_confd.h>
47 #include <linux/lustre_disk.h>
48 #include "mgs_internal.h"
50 static int mgs_cleanup(struct obd_device *obd);
52 /* Establish a connection to the MGS.*/
53 static int mgs_connect(struct lustre_handle *conn, struct obd_device *obd,
54 struct obd_uuid *cluuid, struct obd_connect_data *data)
56 struct obd_export *exp;
60 if (!conn || !obd || !cluuid)
63 rc = class_connect(conn, obd, cluuid);
66 exp = class_conn2export(conn);
70 data->ocd_connect_flags &= MGMT_CONNECT_SUPPORTED;
71 exp->exp_connect_flags = data->ocd_connect_flags;
75 class_disconnect(exp);
77 class_export_put(exp);
83 static int mgs_disconnect(struct obd_export *exp)
85 unsigned long irqflags;
90 class_export_get(exp);
92 /* Disconnect early so that clients can't keep using export */
93 rc = class_disconnect(exp);
94 ldlm_cancel_locks_for_export(exp);
96 /* complete all outstanding replies */
97 spin_lock_irqsave(&exp->exp_lock, irqflags);
98 while (!list_empty(&exp->exp_outstanding_replies)) {
99 struct ptlrpc_reply_state *rs =
100 list_entry(exp->exp_outstanding_replies.next,
101 struct ptlrpc_reply_state, rs_exp_list);
102 struct ptlrpc_service *svc = rs->rs_service;
104 spin_lock(&svc->srv_lock);
105 list_del_init(&rs->rs_exp_list);
106 ptlrpc_schedule_difficult_reply(rs);
107 spin_unlock(&svc->srv_lock);
109 spin_unlock_irqrestore(&exp->exp_lock, irqflags);
111 class_export_put(exp);
115 /* Start the MGS obd */
116 static int mgs_setup(struct obd_device *obd, obd_count len, void *buf)
118 struct lprocfs_static_vars lvars;
119 char *ns_name = "MGS";
120 struct mgs_obd *mgs = &obd->u.mgs;
121 struct lustre_mount_info *lmi;
122 struct lustre_sb_info *lsi;
123 struct vfsmount *mnt;
127 CDEBUG(D_CONFIG, "Starting MGS\n");
129 lmi = server_get_mount(obd->obd_name);
131 RETURN(rc = -EINVAL);
134 lsi = s2lsi(lmi->lmi_sb);
135 obd->obd_fsops = fsfilt_get_ops(MT_STR(lsi->lsi_ldd));
136 if (IS_ERR(obd->obd_fsops))
137 GOTO(err_put, rc = PTR_ERR(obd->obd_fsops));
139 /* namespace for mgs llog */
140 obd->obd_namespace = ldlm_namespace_new(ns_name, LDLM_NAMESPACE_SERVER);
141 if (obd->obd_namespace == NULL) {
143 GOTO(err_ops, rc = -ENOMEM);
146 LASSERT(!lvfs_check_rdonly(lvfs_sbdev(mnt->mnt_sb)));
148 rc = mgs_fs_setup(obd, mnt);
150 CERROR("%s: MGS filesystem method init failed: rc = %d\n",
155 rc = llog_start_commit_thread();
159 rc = llog_setup(obd, LLOG_CONFIG_ORIG_CTXT, obd, 0, NULL,
164 mgs_init_db_list(obd);
166 lprocfs_init_vars(mgs, &lvars);
167 lprocfs_obd_setup(obd, lvars.obd_vars);
169 LCONSOLE_INFO("MGS %s started\n", obd->obd_name);
172 ping_evictor_start();
177 /* No extra cleanup needed for llog_init_commit_thread() */
180 ldlm_namespace_free(obd->obd_namespace, 0);
181 obd->obd_namespace = NULL;
183 fsfilt_put_ops(obd->obd_fsops);
185 server_put_mount(obd->obd_name, mgs->mgs_vfsmnt);
190 static int mgs_precleanup(struct obd_device *obd, int stage)
195 CDEBUG(D_MGS, "precleanup %d\n", stage);
198 case OBD_CLEANUP_SELF_EXP:
199 mgs_cleanup_db_list(obd);
200 llog_cleanup(llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT));
201 rc = obd_llog_finish(obd, 0);
206 static int mgs_cleanup(struct obd_device *obd)
208 struct mgs_obd *mgs = &obd->u.mgs;
209 lvfs_sbdev_type save_dev;
214 if (mgs->mgs_sb == NULL)
216 save_dev = lvfs_sbdev(mgs->mgs_sb);
218 // lprocfs_obd_cleanup(obd);
220 // mgs_update_server_data(obd, 1);
224 server_put_mount(obd->obd_name, mgs->mgs_vfsmnt);
227 ldlm_namespace_free(obd->obd_namespace, obd->obd_force);
229 spin_lock_bh(&obd->obd_processing_task_lock);
230 if (obd->obd_recovering) {
231 target_cancel_recovery_timer(obd);
232 obd->obd_recovering = 0;
234 spin_unlock_bh(&obd->obd_processing_task_lock);
236 lvfs_clear_rdonly(save_dev);
238 fsfilt_put_ops(obd->obd_fsops);
240 LCONSOLE_INFO("MGS %s has stopped.\n", obd->obd_name);
245 static int mgs_handle_target_add(struct ptlrpc_request *req)
247 struct obd_device *obd = req->rq_export->exp_obd;
248 struct mgmt_target_info *req_mti, *mti, *rep_mti;
249 int rep_size = sizeof(*mti);
253 OBD_ALLOC(mti, sizeof(*mti));
255 GOTO(out, rc = -ENOMEM);
256 req_mti = lustre_swab_reqbuf(req, 0, sizeof(*mti),
257 lustre_swab_mgmt_target_info);
258 memcpy(mti, req_mti, sizeof(*mti));
260 CDEBUG(D_MGS, "adding %s, index=%d\n", mti->mti_svname,
261 mti->mti_stripe_index);
263 /* set the new target index if needed */
264 if (mti->mti_flags & LDD_F_NEED_INDEX) {
265 rc = mgs_set_next_index(obd, mti);
267 CERROR("Can't get index (%d)\n", rc);
272 /* create the log for the new target
273 and update the client/mdt logs */
274 rc = mgs_write_log_target(obd, mti);
276 CERROR("Failed to write %s log (%d)\n",
277 mti->mti_svname, rc);
282 lustre_pack_reply(req, 1, &rep_size, NULL);
283 /* send back the whole mti in the reply */
284 rep_mti = lustre_msg_buf(req->rq_repmsg, 0, sizeof(*rep_mti));
285 memcpy(rep_mti, mti, sizeof(*rep_mti));
286 rep_mti->mti_rc = rc;
290 int mgs_handle(struct ptlrpc_request *req)
292 int fail = OBD_FAIL_MGMT_ALL_REPLY_NET;
296 CDEBUG(D_MGS, "MGS handle\n");
298 OBD_FAIL_RETURN(OBD_FAIL_MGMT_ALL_REQUEST_NET | OBD_FAIL_ONCE, 0);
300 LASSERT(current->journal_info == NULL);
301 if (req->rq_reqmsg->opc != MGMT_CONNECT) {
302 if (req->rq_export == NULL) {
303 CERROR("lustre_mgs: operation %d on unconnected MGS\n",
304 req->rq_reqmsg->opc);
305 req->rq_status = -ENOTCONN;
306 GOTO(out, rc = -ENOTCONN);
310 switch (req->rq_reqmsg->opc) {
312 DEBUG_REQ(D_MGS, req, "connect");
313 OBD_FAIL_RETURN(OBD_FAIL_MGMT_CONNECT_NET, 0);
314 rc = target_handle_connect(req, mgs_handle);
316 case MGMT_DISCONNECT:
317 DEBUG_REQ(D_MGS, req, "disconnect");
318 OBD_FAIL_RETURN(OBD_FAIL_MGMT_DISCONNECT_NET, 0);
319 rc = target_handle_disconnect(req);
320 req->rq_status = rc; /* superfluous? */
323 case MGMT_TARGET_ADD:
324 CDEBUG(D_MGS, "target add\n");
325 rc = mgs_handle_target_add(req);
327 case MGMT_TARGET_DEL:
328 CDEBUG(D_MGS, "target del\n");
329 //rc = mgs_handle_target_del(req);
333 DEBUG_REQ(D_MGS, req, "enqueue");
334 OBD_FAIL_RETURN(OBD_FAIL_LDLM_ENQUEUE, 0);
335 rc = ldlm_handle_enqueue(req, ldlm_server_completion_ast,
336 ldlm_server_blocking_ast, NULL);
337 fail = OBD_FAIL_LDLM_REPLY;
339 case LDLM_BL_CALLBACK:
340 case LDLM_CP_CALLBACK:
341 DEBUG_REQ(D_MGS, req, "callback");
342 CERROR("callbacks should not happen on MDS\n");
344 OBD_FAIL_RETURN(OBD_FAIL_LDLM_BL_CALLBACK, 0);
348 DEBUG_REQ(D_MGS, req, "ping");
349 rc = target_handle_ping(req);
353 CDEBUG(D_MGS, "log cancel\n");
354 OBD_FAIL_RETURN(OBD_FAIL_OBD_LOG_CANCEL_NET, 0);
355 rc = -ENOTSUPP; /* la la la */
358 case LLOG_ORIGIN_HANDLE_CREATE:
359 DEBUG_REQ(D_MGS, req, "llog_init");
360 OBD_FAIL_RETURN(OBD_FAIL_OBD_LOGD_NET, 0);
361 rc = llog_origin_handle_create(req);
363 case LLOG_ORIGIN_HANDLE_NEXT_BLOCK:
364 DEBUG_REQ(D_MGS, req, "llog next block");
365 OBD_FAIL_RETURN(OBD_FAIL_OBD_LOGD_NET, 0);
366 rc = llog_origin_handle_next_block(req);
368 case LLOG_ORIGIN_HANDLE_READ_HEADER:
369 DEBUG_REQ(D_MGS, req, "llog read header");
370 OBD_FAIL_RETURN(OBD_FAIL_OBD_LOGD_NET, 0);
371 rc = llog_origin_handle_read_header(req);
373 case LLOG_ORIGIN_HANDLE_CLOSE:
374 DEBUG_REQ(D_MGS, req, "llog close");
375 OBD_FAIL_RETURN(OBD_FAIL_OBD_LOGD_NET, 0);
376 rc = llog_origin_handle_close(req);
379 DEBUG_REQ(D_MGS, req, "llog catinfo");
380 OBD_FAIL_RETURN(OBD_FAIL_OBD_LOGD_NET, 0);
381 rc = llog_catinfo(req);
384 req->rq_status = -ENOTSUPP;
385 rc = ptlrpc_error(req);
389 LASSERT(current->journal_info == NULL);
392 target_send_reply(req, rc, fail);
396 static int mgt_setup(struct obd_device *obd, obd_count len, void *buf)
398 struct mgs_obd *mgs = &obd->u.mgs;
399 struct lprocfs_static_vars lvars;
403 lprocfs_init_vars(mgt, &lvars);
404 lprocfs_obd_setup(obd, lvars.obd_vars);
407 ptlrpc_init_svc(MGS_NBUFS, MGS_BUFSIZE, MGS_MAXREQSIZE,
408 MGS_MAXREPSIZE, MGS_REQUEST_PORTAL,
409 MGC_REPLY_PORTAL, MGS_SERVICE_WATCHDOG_TIMEOUT,
410 mgs_handle, "mgs", obd->obd_proc_entry, NULL,
413 if (!mgs->mgs_service) {
414 CERROR("failed to start service\n");
415 GOTO(err_lprocfs, rc = -ENOMEM);
418 rc = ptlrpc_start_threads(obd, mgs->mgs_service, "ll_mgt");
420 GOTO(err_thread, rc);
425 ptlrpc_unregister_service(mgs->mgs_service);
427 lprocfs_obd_cleanup(obd);
432 static int mgt_cleanup(struct obd_device *obd)
434 struct mgs_obd *mgs = &obd->u.mgs;
437 ptlrpc_unregister_service(mgs->mgs_service);
439 lprocfs_obd_cleanup(obd);
444 struct lvfs_callback_ops mgs_lvfs_ops = {
445 // l_fid2dentry: mgs_lvfs_fid2dentry,
446 // l_open_llog: mgs_lvfs_open_llog,
449 /* use obd ops to offer management infrastructure */
450 static struct obd_ops mgs_obd_ops = {
451 .o_owner = THIS_MODULE,
452 .o_connect = mgs_connect,
453 .o_disconnect = mgs_disconnect,
454 .o_setup = mgs_setup,
455 .o_precleanup = mgs_precleanup,
456 .o_cleanup = mgs_cleanup,
457 .o_iocontrol = mgs_iocontrol,
460 static struct obd_ops mgt_obd_ops = {
461 .o_owner = THIS_MODULE,
462 .o_setup = mgt_setup,
463 .o_cleanup = mgt_cleanup,
466 static int __init mgs_init(void)
468 struct lprocfs_static_vars lvars;
470 lprocfs_init_vars(mgs, &lvars);
471 class_register_type(&mgs_obd_ops, lvars.module_vars, LUSTRE_MGS_NAME);
472 lprocfs_init_vars(mgt, &lvars);
473 class_register_type(&mgt_obd_ops, lvars.module_vars, LUSTRE_MGT_NAME);
478 static void /*__exit*/ mgs_exit(void)
480 class_unregister_type(LUSTRE_MGS_NAME);
481 class_unregister_type(LUSTRE_MGT_NAME);
484 MODULE_AUTHOR("Cluster File Systems, Inc. <info@clusterfs.com>");
485 MODULE_DESCRIPTION("Lustre Management Server (MGS)");
486 MODULE_LICENSE("GPL");
488 module_init(mgs_init);
489 module_exit(mgs_exit);