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, write to the
18 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 * Boston, MA 021110-1307, USA
24 * Copyright (c) 2012 Intel Corporation
25 * Use is subject to license terms.
27 * lustre/osp/lwp_dev.c
29 * Light Weight Proxy, which is just for managing the connection established
30 * from OSTs/MDTs to MDT0.
32 * Author: <di.wang@intel.com>
33 * Author: <yawei.niu@intel.com>
36 # define EXPORT_SYMTAB
38 #define DEBUG_SUBSYSTEM S_OST
40 #include <obd_class.h>
41 #include <lustre_param.h>
42 #include <lustre_log.h>
45 struct lu_device lpd_dev;
46 struct obd_device *lpd_obd;
47 struct obd_uuid lpd_cluuid;
48 struct obd_export *lpd_exp;
52 static inline struct lwp_device *lu2lwp_dev(struct lu_device *d)
54 return container_of0(d, struct lwp_device, lpd_dev);
57 static inline struct lu_device *lwp2lu_dev(struct lwp_device *d)
62 static int lwp_name2fsname(char *lwpname, char *fsname)
66 LASSERT(lwpname != NULL);
67 LASSERT(fsname != NULL);
69 sprintf(fsname, "-%s-", LUSTRE_LWP_NAME);
71 ptr = strstr(lwpname, fsname);
75 while (*(--ptr) != '-') {
80 strncpy(fsname, lwpname, ptr - lwpname);
81 fsname[ptr - lwpname] = '\0';
86 static int lwp_setup(const struct lu_env *env, struct lwp_device *lwp,
89 struct lustre_cfg_bufs *bufs = NULL;
90 struct lustre_cfg *lcfg = NULL;
91 char *lwpname = lwp->lpd_obd->obd_name;
93 char *server_uuid = NULL;
95 struct obd_import *imp;
103 OBD_ALLOC(fsname, strlen(lwpname));
105 GOTO(out, rc = -ENOMEM);
107 rc = lwp_name2fsname(lwpname, fsname);
109 CERROR("%s: failed to get fsname from lwpname. %d\n",
114 OBD_ALLOC(server_uuid, strlen(fsname) + 15);
115 if (server_uuid == NULL)
116 GOTO(out, rc = -ENOMEM);
118 sprintf(server_uuid, "%s-MDT0000_UUID", fsname);
119 lustre_cfg_bufs_reset(bufs, lwpname);
120 lustre_cfg_bufs_set_string(bufs, 1, server_uuid);
121 lustre_cfg_bufs_set_string(bufs, 2, nidstring);
122 lcfg = lustre_cfg_new(LCFG_SETUP, bufs);
124 GOTO(out, rc = -ENOMEM);
126 rc = client_obd_setup(lwp->lpd_obd, lcfg);
128 CERROR("%s: client obd setup error: rc = %d\n",
129 lwp->lpd_obd->obd_name, rc);
133 imp = lwp->lpd_obd->u.cli.cl_import;
134 rc = ptlrpc_init_import(imp);
138 ll_generate_random_uuid(uuid);
139 class_uuid_unparse(uuid, &lwp->lpd_cluuid);
143 if (server_uuid != NULL)
144 OBD_FREE(server_uuid, strlen(fsname) + 15);
146 OBD_FREE(fsname, strlen(lwpname));
148 lustre_cfg_free(lcfg);
150 client_obd_cleanup(lwp->lpd_obd);
154 int lwp_disconnect(struct lwp_device *d)
156 struct obd_import *imp;
159 imp = d->lpd_obd->u.cli.cl_import;
161 /* Mark import deactivated now, so we don't try to reconnect if any
162 * of the cleanup RPCs fails (e.g. ldlm cancel, etc). We don't
163 * fully deactivate the import, or that would drop all requests. */
164 LASSERT(imp != NULL);
165 spin_lock(&imp->imp_lock);
166 imp->imp_deactive = 1;
167 spin_unlock(&imp->imp_lock);
169 ptlrpc_deactivate_import(imp);
171 /* Some non-replayable imports (MDS's OSCs) are pinged, so just
172 * delete it regardless. (It's safe to delete an import that was
174 (void)ptlrpc_pinger_del_import(imp);
176 rc = ptlrpc_disconnect_import(imp, 0);
177 if (rc && rc != -ETIMEDOUT)
178 CERROR("%s: can't disconnect: rc = %d\n",
179 d->lpd_obd->obd_name, rc);
181 ptlrpc_invalidate_import(imp);
186 static int lwp_process_config(const struct lu_env *env,
187 struct lu_device *dev, struct lustre_cfg *lcfg)
189 struct lwp_device *d = lu2lwp_dev(dev);
193 switch (lcfg->lcfg_command) {
194 case LCFG_PRE_CLEANUP:
196 rc = lwp_disconnect(d);
202 CERROR("%s: unknown command %u\n",
203 (char *)lustre_cfg_string(lcfg, 0), lcfg->lcfg_command);
211 const struct lu_device_operations lwp_lu_ops = {
212 .ldo_process_config = lwp_process_config,
215 static struct lprocfs_vars lprocfs_lwp_module_vars[] = {
216 { "num_refs", lprocfs_rd_numrefs, 0, 0 },
220 static struct lprocfs_vars lprocfs_lwp_obd_vars[] = {
224 void lprocfs_lwp_init_vars(struct lprocfs_static_vars *lvars)
226 lvars->module_vars = lprocfs_lwp_module_vars;
227 lvars->obd_vars = lprocfs_lwp_obd_vars;
230 int lwp_init0(const struct lu_env *env, struct lwp_device *lwp,
231 struct lu_device_type *ldt, struct lustre_cfg *cfg)
233 struct lprocfs_static_vars lvars = { 0 };
237 lwp->lpd_obd = class_name2obd(lustre_cfg_string(cfg, 0));
238 if (lwp->lpd_obd == NULL) {
239 CERROR("Cannot find obd with name %s\n",
240 lustre_cfg_string(cfg, 0));
244 lwp->lpd_dev.ld_ops = &lwp_lu_ops;
245 lwp->lpd_obd->obd_lu_dev = &lwp->lpd_dev;
247 rc = ptlrpcd_addref();
249 CERROR("%s: ptlrpcd addref error: rc =%d\n",
250 lwp->lpd_obd->obd_name, rc);
254 rc = lwp_setup(env, lwp, lustre_cfg_string(cfg, 1));
256 CERROR("%s: setup lwp failed. %d\n",
257 lwp->lpd_obd->obd_name, rc);
262 lprocfs_lwp_init_vars(&lvars);
263 if (lprocfs_obd_setup(lwp->lpd_obd, lvars.obd_vars) == 0)
264 ptlrpc_lprocfs_register_obd(lwp->lpd_obd);
269 static struct lu_device *lwp_device_free(const struct lu_env *env,
270 struct lu_device *lu)
272 struct lwp_device *m = lu2lwp_dev(lu);
275 if (cfs_atomic_read(&lu->ld_ref) && lu->ld_site) {
276 LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_ERROR, NULL);
277 lu_site_print(env, lu->ld_site, &msgdata, lu_cdebug_printer);
279 lu_device_fini(&m->lpd_dev);
284 static struct lu_device *lwp_device_alloc(const struct lu_env *env,
285 struct lu_device_type *t,
286 struct lustre_cfg *lcfg)
288 struct lwp_device *lwp;
293 l = ERR_PTR(-ENOMEM);
298 lu_device_init(&lwp->lpd_dev, t);
299 rc = lwp_init0(env, lwp, t, lcfg);
301 lwp_device_free(env, l);
309 static struct lu_device *lwp_device_fini(const struct lu_env *env,
312 struct lwp_device *m = lu2lwp_dev(d);
313 struct obd_import *imp;
317 if (m->lpd_exp != NULL)
318 class_disconnect(m->lpd_exp);
320 imp = m->lpd_obd->u.cli.cl_import;
322 if (imp->imp_rq_pool) {
323 ptlrpc_free_rq_pool(imp->imp_rq_pool);
324 imp->imp_rq_pool = NULL;
327 obd_cleanup_client_import(m->lpd_obd);
330 ptlrpc_lprocfs_unregister_obd(m->lpd_obd);
331 lprocfs_obd_cleanup(m->lpd_obd);
333 rc = client_obd_cleanup(m->lpd_obd);
334 LASSERTF(rc == 0, "error %d\n", rc);
341 static struct lu_device_type_operations lwp_device_type_ops = {
342 .ldto_device_alloc = lwp_device_alloc,
343 .ldto_device_free = lwp_device_free,
344 .ldto_device_fini = lwp_device_fini
347 struct lu_device_type lwp_device_type = {
348 .ldt_tags = LU_DEVICE_DT,
349 .ldt_name = LUSTRE_LWP_NAME,
350 .ldt_ops = &lwp_device_type_ops,
351 .ldt_ctx_tags = LCT_MD_THREAD
354 static int lwp_obd_connect(const struct lu_env *env, struct obd_export **exp,
355 struct obd_device *obd, struct obd_uuid *cluuid,
356 struct obd_connect_data *data, void *localdata)
358 struct lwp_device *lwp = lu2lwp_dev(obd->obd_lu_dev);
359 struct obd_connect_data *ocd;
360 struct obd_import *imp;
361 struct lustre_handle conn;
366 CDEBUG(D_CONFIG, "connect #%d\n", lwp->lpd_connects);
368 rc = class_connect(&conn, obd, cluuid);
372 *exp = class_conn2export(&conn);
375 /* Why should there ever be more than 1 connect? */
377 LASSERT(lwp->lpd_connects == 1);
379 imp = lwp->lpd_obd->u.cli.cl_import;
380 imp->imp_dlm_handle = conn;
382 LASSERT(data != NULL);
383 ocd = &imp->imp_connect_data;
386 LASSERT(ocd->ocd_connect_flags & OBD_CONNECT_LIGHTWEIGHT);
388 ocd->ocd_version = LUSTRE_VERSION_CODE;
389 imp->imp_connect_flags_orig = ocd->ocd_connect_flags;
391 rc = ptlrpc_connect_import(imp);
393 CERROR("%s: can't connect obd: rc = %d\n", obd->obd_name, rc);
397 ptlrpc_pinger_add_import(imp);
403 static int lwp_obd_disconnect(struct obd_export *exp)
405 struct obd_device *obd = exp->exp_obd;
406 struct lwp_device *lwp = lu2lwp_dev(obd->obd_lu_dev);
410 /* Only disconnect the underlying layers on the final disconnect. */
411 LASSERT(lwp->lpd_connects == 1);
414 rc = class_disconnect(exp);
416 CERROR("%s: class disconnect error: rc = %d\n",
422 static int lwp_import_event(struct obd_device *obd, struct obd_import *imp,
423 enum obd_import_event event)
426 case IMP_EVENT_DISCON:
427 case IMP_EVENT_INACTIVE:
428 case IMP_EVENT_ACTIVE:
430 case IMP_EVENT_INVALIDATE:
431 if (obd->obd_namespace == NULL)
433 ldlm_namespace_cleanup(obd->obd_namespace, LDLM_FL_LOCAL_ONLY);
438 CERROR("%s: unsupported import event: %#x\n",
439 obd->obd_name, event);
444 struct obd_ops lwp_obd_device_ops = {
445 .o_owner = THIS_MODULE,
446 .o_add_conn = client_import_add_conn,
447 .o_del_conn = client_import_del_conn,
448 .o_connect = lwp_obd_connect,
449 .o_disconnect = lwp_obd_disconnect,
450 .o_import_event = lwp_import_event,