lustre/cmm/mdc_device.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  lustre/cmm/cmm_mdc.c
   5  *  Lustre Metadata Client (mdc)
   6  *
   7  *  Copyright (c) 2006 Cluster File Systems, Inc.
   8  *   Author: Mike Pershin <tappro@clusterfs.com>
   9  *
  10  *   This file is part of the Lustre file system, http://www.lustre.org
  11  *   Lustre is a trademark of Cluster File Systems, Inc.
  12  *
  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.
  17  *
  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.
  22  *
  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.
  27  */
  28
  29 #ifndef EXPORT_SYMTAB
  30 # define EXPORT_SYMTAB
  31 #endif
  32 #define DEBUG_SUBSYSTEM S_MDS
  33
  34 #include <obd.h>
  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"
  40
  41 static struct lu_device_operations mdc_lu_ops;
  42
  43 static inline int lu_device_is_mdc(struct lu_device *ld)
  44 {
  45         return ergo(ld != NULL && ld->ld_ops != NULL,
  46                     ld->ld_ops == &mdc_lu_ops);
  47 }
  48
  49 static struct md_device_operations mdc_md_ops = { 0 };
  50
  51 static int mdc_obd_update(struct obd_device *host,
  52                           struct obd_device *watched,
  53                           enum obd_notify_event ev, void *owner)
  54 {
  55         struct mdc_device *mc = owner;
  56         int rc = 0;
  57         ENTRY;
  58
  59         LASSERT(mc != NULL);
  60         CDEBUG(D_CONFIG, "notify %s ev=%d\n", watched->obd_name, ev);
  61         RETURN(rc);
  62 }
  63 /* MDC OBD is set up already and connected to the proper MDS
  64  * mdc_add_obd() find that obd by uuid and connects to it.
  65  * Local MDT uuid is used for connection
  66  * */
  67 static int mdc_add_obd(const struct lu_env *env,
  68                        struct mdc_device *mc, struct lustre_cfg *cfg)
  69 {
  70         struct mdc_cli_desc *desc = &mc->mc_desc;
  71         struct obd_device *mdc;
  72         const char *uuid_str = lustre_cfg_string(cfg, 1);
  73         const char *index = lustre_cfg_string(cfg, 2);
  74         const char *mdc_uuid_str = lustre_cfg_string(cfg, 4);
  75         char *p;
  76         int rc = 0;
  77
  78         ENTRY;
  79         LASSERT(uuid_str);
  80         LASSERT(index);
  81
  82         mc->mc_num = simple_strtol(index, &p, 10);
  83         if (*p) {
  84                 CERROR("Invalid index in lustre_cgf, offset 2\n");
  85                 RETURN(-EINVAL);
  86         }
  87
  88         obd_str2uuid(&desc->cl_srv_uuid, uuid_str);
  89         obd_str2uuid(&desc->cl_cli_uuid, mdc_uuid_str);
  90         /* try to find MDC OBD connected to the needed MDT */
  91         mdc = class_find_client_obd(&desc->cl_srv_uuid, LUSTRE_MDC_NAME,
  92                                     &desc->cl_cli_uuid);
  93         if (!mdc) {
  94                 CERROR("Cannot find MDC OBD connected to %s\n", uuid_str);
  95                 rc = -ENOENT;
  96         } else if (!mdc->obd_set_up) {
  97                 CERROR("target %s not set up\n", mdc->obd_name);
  98                 rc = -EINVAL;
  99         } else {
 100                 struct lustre_handle *conn = &desc->cl_conn;
 101                 struct obd_connect_data *ocd;
 102
 103                 CDEBUG(D_CONFIG, "connect to %s(%s)\n",
 104                        mdc->obd_name, mdc->obd_uuid.uuid);
 105
 106                 OBD_ALLOC_PTR(ocd);
 107                 if (!ocd)
 108                         RETURN(-ENOMEM);
 109                 /* The connection between MDS must be local */
 110                 ocd->ocd_connect_flags |= OBD_CONNECT_LCL_CLIENT;
 111                 rc = obd_connect(env, conn, mdc, &mdc->obd_uuid, ocd);
 112                 OBD_FREE_PTR(ocd);
 113                 if (rc) {
 114                         CERROR("target %s connect error %d\n",
 115                                mdc->obd_name, rc);
 116                 } else {
 117                         desc->cl_exp = class_conn2export(conn);
 118
 119                         rc = obd_fid_init(desc->cl_exp);
 120                         if (rc)
 121                                 CERROR("fid init error %d \n", rc);
 122                         else {
 123                                 /* obd notify mechanism */
 124                                 mdc->obd_upcall.onu_owner = mc;
 125                                 mdc->obd_upcall.onu_upcall = mdc_obd_update;
 126                         }
 127                 }
 128                 if (rc) {
 129                         obd_disconnect(desc->cl_exp);
 130                         desc->cl_exp = NULL;
 131                 }
 132         }
 133
 134         RETURN(rc);
 135 }
 136
 137 static int mdc_del_obd(struct mdc_device *mc)
 138 {
 139         struct mdc_cli_desc *desc = &mc->mc_desc;
 140         struct obd_device *mdc_obd = class_exp2obd(desc->cl_exp);
 141         int rc;
 142
 143         ENTRY;
 144
 145         CDEBUG(D_CONFIG, "disconnect from %s\n",
 146                mdc_obd->obd_name);
 147
 148         rc = obd_fid_fini(desc->cl_exp);
 149         if (rc)
 150                 CERROR("fid init error %d \n", rc);
 151
 152         obd_register_observer(mdc_obd, NULL);
 153
 154         /*TODO: Give the same shutdown flags as we have */
 155         /*
 156         desc->cl_exp->exp_obd->obd_force = mdt_obd->obd_force;
 157         desc->cl_exp->exp_obd->obd_fail = mdt_obd->obd_fail;
 158         */
 159         rc = obd_disconnect(desc->cl_exp);
 160         if (rc) {
 161                 CERROR("target %s disconnect error %d\n",
 162                        mdc_obd->obd_name, rc);
 163         }
 164         class_manual_cleanup(mdc_obd);
 165         desc->cl_exp = NULL;
 166
 167         RETURN(rc);
 168 }
 169
 170 static int mdc_process_config(const struct lu_env *env,
 171                               struct lu_device *ld, struct lustre_cfg *cfg)
 172 {
 173         struct mdc_device *mc = lu2mdc_dev(ld);
 174         int rc;
 175
 176         ENTRY;
 177         switch (cfg->lcfg_command) {
 178         case LCFG_ADD_MDC:
 179                 rc = mdc_add_obd(env, mc, cfg);
 180                 break;
 181         default:
 182                 rc = -EOPNOTSUPP;
 183         }
 184         RETURN(rc);
 185 }
 186
 187 static struct lu_device_operations mdc_lu_ops = {
 188         .ldo_object_alloc   = mdc_object_alloc,
 189         .ldo_process_config = mdc_process_config
 190 };
 191
 192 static int mdc_device_init(const struct lu_env *env,
 193                            struct lu_device *ld, struct lu_device *next)
 194 {
 195         return 0;
 196 }
 197
 198 static struct lu_device *mdc_device_fini(const struct lu_env *env,
 199                                          struct lu_device *ld)
 200 {
 201         struct mdc_device *mc = lu2mdc_dev(ld);
 202
 203         ENTRY;
 204
 205         mdc_del_obd(mc);
 206
 207         RETURN (NULL);
 208 }
 209
 210 struct lu_device *mdc_device_alloc(const struct lu_env *env,
 211                                    struct lu_device_type *ldt,
 212                                    struct lustre_cfg *cfg)
 213 {
 214         struct lu_device  *ld;
 215         struct mdc_device *mc;
 216
 217         ENTRY;
 218
 219         OBD_ALLOC_PTR(mc);
 220         if (mc == NULL) {
 221                 ld = ERR_PTR(-ENOMEM);
 222         } else {
 223                 md_device_init(&mc->mc_md_dev, ldt);
 224                 mc->mc_md_dev.md_ops =  &mdc_md_ops;
 225                 ld = mdc2lu_dev(mc);
 226                 ld->ld_ops = &mdc_lu_ops;
 227         }
 228
 229         RETURN (ld);
 230 }
 231 void mdc_device_free(const struct lu_env *env, struct lu_device *ld)
 232 {
 233         struct mdc_device *mc = lu2mdc_dev(ld);
 234
 235         LASSERT(atomic_read(&ld->ld_ref) == 0);
 236         LASSERT(list_empty(&mc->mc_linkage));
 237         md_device_fini(&mc->mc_md_dev);
 238         OBD_FREE_PTR(mc);
 239 }
 240
 241 /* context key constructor/destructor */
 242
 243 static void *mdc_key_init(const struct lu_context *ctx,
 244                           struct lu_context_key *key)
 245 {
 246         struct mdc_thread_info *info;
 247
 248         CLASSERT(CFS_PAGE_SIZE >= sizeof *info);
 249         OBD_ALLOC_PTR(info);
 250         if (info == NULL)
 251                 info = ERR_PTR(-ENOMEM);
 252         return info;
 253 }
 254
 255 static void mdc_key_fini(const struct lu_context *ctx,
 256                          struct lu_context_key *key, void *data)
 257 {
 258         struct mdc_thread_info *info = data;
 259         OBD_FREE_PTR(info);
 260 }
 261
 262 struct lu_context_key mdc_thread_key = {
 263         .lct_tags = LCT_MD_THREAD|LCT_CL_THREAD,
 264         .lct_init = mdc_key_init,
 265         .lct_fini = mdc_key_fini
 266 };
 267
 268 int mdc_type_init(struct lu_device_type *ldt)
 269 {
 270         return lu_context_key_register(&mdc_thread_key);
 271 }
 272
 273 void mdc_type_fini(struct lu_device_type *ldt)
 274 {
 275         lu_context_key_degister(&mdc_thread_key);
 276 }
 277
 278 static struct lu_device_type_operations mdc_device_type_ops = {
 279         .ldto_init = mdc_type_init,
 280         .ldto_fini = mdc_type_fini,
 281
 282         .ldto_device_alloc = mdc_device_alloc,
 283         .ldto_device_free  = mdc_device_free,
 284
 285         .ldto_device_init = mdc_device_init,
 286         .ldto_device_fini = mdc_device_fini
 287 };
 288
 289 struct lu_device_type mdc_device_type = {
 290         .ldt_tags     = LU_DEVICE_MD,
 291         .ldt_name     = LUSTRE_CMM_MDC_NAME,
 292         .ldt_ops      = &mdc_device_type_ops,
 293         .ldt_ctx_tags = LCT_MD_THREAD|LCT_CL_THREAD
 294 };
 295