1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2 * vim:expandtab:shiftwidth=8:tabstop=8:
5 * Lustre Metadata Client (mdc)
7 * Copyright (c) 2006 Cluster File Systems, Inc.
8 * Author: Mike Pershin <tappro@clusterfs.com>
10 * This file is part of the Lustre file system, http://www.lustre.org
11 * Lustre is a trademark of Cluster File Systems, Inc.
13 * You may have signed or agreed to another license before downloading
14 * this software. If so, you are bound by the terms and conditions
15 * of that agreement, and the following does not apply to you. See the
16 * LICENSE file included with this distribution for more information.
18 * If you did not agree to a different license, then this copy of Lustre
19 * is open source software; you can redistribute it and/or modify it
20 * under the terms of version 2 of the GNU General Public License as
21 * published by the Free Software Foundation.
23 * In either case, Lustre is distributed in the hope that it will be
24 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
25 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 * license text for more details.
30 # define EXPORT_SYMTAB
32 #define DEBUG_SUBSYSTEM S_MDS
35 #include <obd_class.h>
36 #include <lprocfs_status.h>
37 #include <lustre_ver.h>
38 #include "cmm_internal.h"
39 #include "mdc_internal.h"
41 static struct lu_device_operations mdc_lu_ops;
43 static inline int lu_device_is_mdc(struct lu_device *ld)
45 return ergo(ld != NULL && ld->ld_ops != NULL,
46 ld->ld_ops == &mdc_lu_ops);
49 static struct md_device_operations mdc_md_ops = { 0 };
51 static int mdc_obd_update(struct obd_device *host,
52 struct obd_device *watched,
53 enum obd_notify_event ev, void *owner)
55 struct mdc_device *mc = owner;
60 CDEBUG(D_CONFIG, "notify %s ev=%d\n", watched->obd_name, ev);
61 if (ev == OBD_NOTIFY_ACTIVE) {
62 CDEBUG(D_INFO|D_WARNING, "Device %s is active now\n",
64 } else if (ev == OBD_NOTIFY_INACTIVE) {
65 CDEBUG(D_INFO|D_WARNING, "Device %s is inactive now\n",
67 } else if (ev == OBD_NOTIFY_OCD) {
68 struct obd_connect_data *conn_data =
69 &watched->u.cli.cl_import->imp_connect_data;
71 * Update exp_connect_flags.
73 mc->mc_desc.cl_exp->exp_connect_flags =
74 conn_data->ocd_connect_flags;
75 CDEBUG(D_INFO, "Update connect_flags: "LPX64"\n",
76 conn_data->ocd_connect_flags);
81 /* MDC OBD is set up already and connected to the proper MDS
82 * mdc_add_obd() find that obd by uuid and connects to it.
83 * Local MDT uuid is used for connection
85 static int mdc_obd_add(const struct lu_env *env,
86 struct mdc_device *mc, struct lustre_cfg *cfg)
88 struct mdc_cli_desc *desc = &mc->mc_desc;
89 struct obd_device *mdc;
90 const char *uuid_str = lustre_cfg_string(cfg, 1);
91 const char *index = lustre_cfg_string(cfg, 2);
92 const char *mdc_uuid_str = lustre_cfg_string(cfg, 4);
93 struct lu_site *ls = mdc2lu_dev(mc)->ld_site;
101 mc->mc_num = simple_strtol(index, &p, 10);
103 CERROR("Invalid index in lustre_cgf, offset 2\n");
107 obd_str2uuid(&desc->cl_srv_uuid, uuid_str);
108 obd_str2uuid(&desc->cl_cli_uuid, mdc_uuid_str);
109 /* try to find MDC OBD connected to the needed MDT */
110 mdc = class_find_client_obd(&desc->cl_srv_uuid, LUSTRE_MDC_NAME,
113 CERROR("Cannot find MDC OBD connected to %s\n", uuid_str);
115 } else if (!mdc->obd_set_up) {
116 CERROR("target %s not set up\n", mdc->obd_name);
119 struct lustre_handle *conn = &desc->cl_conn;
120 struct obd_connect_data *ocd;
122 CDEBUG(D_CONFIG, "connect to %s(%s)\n",
123 mdc->obd_name, mdc->obd_uuid.uuid);
129 * The connection between MDS must be local,
130 * IBITS are needed for rename_lock (INODELOCK_UPDATE)
132 ocd->ocd_ibits_known = MDS_INODELOCK_UPDATE;
133 ocd->ocd_connect_flags = OBD_CONNECT_VERSION |
135 OBD_CONNECT_LCL_CLIENT |
136 OBD_CONNECT_MDS_CAPA |
137 OBD_CONNECT_OSS_CAPA |
140 rc = obd_connect(env, conn, mdc, &mdc->obd_uuid, ocd);
143 CERROR("target %s connect error %d\n",
146 desc->cl_exp = class_conn2export(conn);
147 /* set seq controller export for MDC0 if exists */
150 class_export_get(desc->cl_exp);
151 rc = obd_fid_init(desc->cl_exp);
153 CERROR("fid init error %d \n", rc);
155 /* obd notify mechanism */
156 mdc->obd_upcall.onu_owner = mc;
157 mdc->obd_upcall.onu_upcall = mdc_obd_update;
162 obd_disconnect(desc->cl_exp);
170 static int mdc_obd_del(const struct lu_env *env, struct mdc_device *mc,
171 struct lustre_cfg *cfg)
173 struct mdc_cli_desc *desc = &mc->mc_desc;
174 const char *dev = lustre_cfg_string(cfg, 0);
175 struct obd_device *mdc_obd = class_exp2obd(desc->cl_exp);
176 struct obd_device *mdt_obd;
181 CDEBUG(D_CONFIG, "Disconnect from %s\n",
184 /* Set mdt_obd flags in shutdown. */
185 mdt_obd = class_name2obd(dev);
186 LASSERT(mdt_obd != NULL);
188 mdc_obd->obd_no_recov = mdt_obd->obd_no_recov;
189 mdc_obd->obd_force = mdt_obd->obd_force;
190 mdc_obd->obd_fail = 0;
193 rc = obd_fid_fini(desc->cl_exp);
195 CERROR("Fid fini error %d\n", rc);
197 obd_register_observer(mdc_obd, NULL);
198 mdc_obd->obd_upcall.onu_owner = NULL;
199 mdc_obd->obd_upcall.onu_upcall = NULL;
200 rc = obd_disconnect(desc->cl_exp);
202 CERROR("Target %s disconnect error %d\n",
203 mdc_obd->obd_name, rc);
205 class_manual_cleanup(mdc_obd);
211 static int mdc_process_config(const struct lu_env *env,
212 struct lu_device *ld,
213 struct lustre_cfg *cfg)
215 struct mdc_device *mc = lu2mdc_dev(ld);
219 switch (cfg->lcfg_command) {
221 rc = mdc_obd_add(env, mc, cfg);
224 rc = mdc_obd_del(env, mc, cfg);
232 static struct lu_device_operations mdc_lu_ops = {
233 .ldo_object_alloc = mdc_object_alloc,
234 .ldo_process_config = mdc_process_config
237 void mdc_init_ea_size(const struct lu_env *env, struct mdc_device *mc,
238 int max_mdsize, int max_cookiesize)
240 struct obd_device *obd = class_exp2obd(mc->mc_desc.cl_exp);
242 obd->u.cli.cl_max_mds_easize = max_mdsize;
243 obd->u.cli.cl_max_mds_cookiesize = max_cookiesize;
246 static int mdc_device_init(const struct lu_env *env, struct lu_device *ld,
247 const char *name, struct lu_device *next)
252 static struct lu_device *mdc_device_fini(const struct lu_env *env,
253 struct lu_device *ld)
259 struct lu_device *mdc_device_alloc(const struct lu_env *env,
260 struct lu_device_type *ldt,
261 struct lustre_cfg *cfg)
263 struct lu_device *ld;
264 struct mdc_device *mc;
269 ld = ERR_PTR(-ENOMEM);
271 md_device_init(&mc->mc_md_dev, ldt);
272 mc->mc_md_dev.md_ops = &mdc_md_ops;
274 ld->ld_ops = &mdc_lu_ops;
275 sema_init(&mc->mc_fid_sem, 1);
281 void mdc_device_free(const struct lu_env *env, struct lu_device *ld)
283 struct mdc_device *mc = lu2mdc_dev(ld);
285 LASSERTF(atomic_read(&ld->ld_ref) == 0,
286 "Refcount = %i\n", atomic_read(&ld->ld_ref));
287 LASSERT(list_empty(&mc->mc_linkage));
288 md_device_fini(&mc->mc_md_dev);
292 /* context key constructor/destructor */
294 static void *mdc_key_init(const struct lu_context *ctx,
295 struct lu_context_key *key)
297 struct mdc_thread_info *info;
299 CLASSERT(CFS_PAGE_SIZE >= sizeof *info);
302 info = ERR_PTR(-ENOMEM);
306 static void mdc_key_fini(const struct lu_context *ctx,
307 struct lu_context_key *key, void *data)
309 struct mdc_thread_info *info = data;
313 struct lu_context_key mdc_thread_key = {
314 .lct_tags = LCT_MD_THREAD|LCT_CL_THREAD,
315 .lct_init = mdc_key_init,
316 .lct_fini = mdc_key_fini
319 int mdc_type_init(struct lu_device_type *ldt)
321 LU_CONTEXT_KEY_INIT(&mdc_thread_key);
322 return lu_context_key_register(&mdc_thread_key);
325 void mdc_type_fini(struct lu_device_type *ldt)
327 lu_context_key_degister(&mdc_thread_key);
330 static struct lu_device_type_operations mdc_device_type_ops = {
331 .ldto_init = mdc_type_init,
332 .ldto_fini = mdc_type_fini,
334 .ldto_device_alloc = mdc_device_alloc,
335 .ldto_device_free = mdc_device_free,
337 .ldto_device_init = mdc_device_init,
338 .ldto_device_fini = mdc_device_fini
341 struct lu_device_type mdc_device_type = {
342 .ldt_tags = LU_DEVICE_MD,
343 .ldt_name = LUSTRE_CMM_MDC_NAME,
344 .ldt_ops = &mdc_device_type_ops,
345 .ldt_ctx_tags = LCT_MD_THREAD|LCT_CL_THREAD