lustre/osp/lwp_dev.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   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.
   9  *
  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).
  15  *
  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
  20  *
  21  * GPL HEADER END
  22  */
  23 /*
  24  * Copyright (c) 2013, 2017, Intel Corporation.
  25  * Use is subject to license terms.
  26  *
  27  * lustre/osp/lwp_dev.c
  28  *
  29  * This file provides code related to the Light Weight Proxy (LWP) managing
  30  * the connections established from OST to MDT, and MDT to MDT0.
  31  *
  32  * A LWP connection is used to send quota and FLD query requests. It's not
  33  * recoverable, which means target server doesn't have an on-disk record in
  34  * the last_rcvd file to remember the connection. Once LWP reconnect after
  35  * server reboot, server will always regard it as a new connection.
  36  *
  37  * Author: <di.wang@intel.com>
  38  * Author: <yawei.niu@intel.com>
  39  */
  40 #define DEBUG_SUBSYSTEM S_OST
  41
  42 #include <obd_class.h>
  43 #include <uapi/linux/lustre/lustre_param.h>
  44 #include <lustre_log.h>
  45 #include <linux/kthread.h>
  46
  47 #include "osp_internal.h"
  48
  49 struct lwp_device {
  50         struct lu_device        lpd_dev;
  51         struct obd_device      *lpd_obd;   /* corresponding OBD device */
  52         struct obd_export      *lpd_exp;   /* export of LWP */
  53         struct task_struct     *lpd_notify_task; /* notify thread */
  54         int                     lpd_connects; /* use count, 0 or 1 */
  55 };
  56
  57 static inline struct lwp_device *lu2lwp_dev(struct lu_device *d)
  58 {
  59         return container_of_safe(d, struct lwp_device, lpd_dev);
  60 }
  61
  62 static inline struct lu_device *lwp2lu_dev(struct lwp_device *d)
  63 {
  64         return &d->lpd_dev;
  65 }
  66
  67 /**
  68  * Setup LWP device.
  69  *
  70  * \param[in] env       environment passed by caller
  71  * \param[in] lwp       LWP device to be setup
  72  * \param[in] nidstring remote target NID
  73  *
  74  * \retval              0 on success
  75  * \retval              negative number on error
  76  */
  77 static int lwp_setup(const struct lu_env *env, struct lwp_device *lwp,
  78                      char *nidstring)
  79 {
  80         struct lustre_cfg_bufs  *bufs = NULL;
  81         struct lustre_cfg       *lcfg = NULL;
  82         char                    *lwp_name = lwp->lpd_obd->obd_name;
  83         char                    *server_uuid = NULL;
  84         char                    *ptr;
  85         int                      uuid_len = -1;
  86         struct obd_import       *imp;
  87         int                      len = strlen(lwp_name) + 1;
  88         int                      rc;
  89         const char              *lwp_marker = "-" LUSTRE_LWP_NAME "-";
  90         ENTRY;
  91
  92         lwp->lpd_notify_task = NULL;
  93
  94         OBD_ALLOC_PTR(bufs);
  95         if (bufs == NULL)
  96                 RETURN(-ENOMEM);
  97
  98         OBD_ALLOC(server_uuid, len);
  99         if (server_uuid == NULL)
 100                 GOTO(out, rc = -ENOMEM);
 101
 102         ptr = lwp_name;
 103         while (ptr && (ptr = strstr(ptr+1, lwp_marker)) != NULL)
 104                 uuid_len = ptr - lwp_name;
 105
 106         if (uuid_len < 0) {
 107                 CERROR("%s: failed to get server_uuid from lwp_name: rc = %d\n",
 108                        lwp_name, -EINVAL);
 109                 GOTO(out, rc = -EINVAL);
 110         }
 111
 112         strncpy(server_uuid, lwp_name, uuid_len);
 113         strlcat(server_uuid, "_UUID", len);
 114         lustre_cfg_bufs_reset(bufs, lwp_name);
 115         lustre_cfg_bufs_set_string(bufs, 1, server_uuid);
 116         lustre_cfg_bufs_set_string(bufs, 2, nidstring);
 117         OBD_ALLOC(lcfg, lustre_cfg_len(bufs->lcfg_bufcount, bufs->lcfg_buflen));
 118         if (!lcfg)
 119                 GOTO(out, rc = -ENOMEM);
 120         lustre_cfg_init(lcfg, LCFG_SETUP, bufs);
 121
 122         rc = client_obd_setup(lwp->lpd_obd, lcfg);
 123         if (rc != 0) {
 124                 CERROR("%s: client obd setup error: rc = %d\n",
 125                        lwp->lpd_obd->obd_name, rc);
 126                 GOTO(out, rc);
 127         }
 128
 129         imp = lwp->lpd_obd->u.cli.cl_import;
 130         rc = ptlrpc_init_import(imp);
 131 out:
 132         if (bufs != NULL)
 133                 OBD_FREE_PTR(bufs);
 134         if (server_uuid != NULL)
 135                 OBD_FREE(server_uuid, len);
 136         if (lcfg)
 137                 OBD_FREE(lcfg, lustre_cfg_len(lcfg->lcfg_bufcount,
 138                                               lcfg->lcfg_buflens));
 139         if (rc)
 140                 client_obd_cleanup(lwp->lpd_obd);
 141
 142         RETURN(rc);
 143 }
 144
 145 /**
 146  * Disconnect the import from LWP.
 147  *
 148  * \param[in] d         LWP device to be disconnected
 149  *
 150  * \retval              0 on success
 151  * \retval              negative number on error
 152  */
 153 static int lwp_disconnect(struct lwp_device *d)
 154 {
 155         struct obd_import *imp;
 156         int rc = 0;
 157
 158         imp = d->lpd_obd->u.cli.cl_import;
 159
 160         /*
 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 because that would cause all requests
 164          * to be dropped.
 165          */
 166         LASSERT(imp != NULL);
 167         spin_lock(&imp->imp_lock);
 168         imp->imp_deactive = 1;
 169         spin_unlock(&imp->imp_lock);
 170
 171         ptlrpc_deactivate_import(imp);
 172
 173         /*
 174          * Some non-replayable imports (MDS's OSCs) are pinged, so just
 175          * delete it regardless.  (It's safe to delete an import that was
 176          * never added.)
 177          */
 178         ptlrpc_pinger_del_import(imp);
 179         rc = ptlrpc_disconnect_import(imp, 0);
 180         ptlrpc_invalidate_import(imp);
 181
 182         RETURN(rc);
 183 }
 184
 185 /**
 186  * Implementation of lu_device_operations::ldo_process_config.
 187  *
 188  * Process a Lustre configuration request.
 189  *
 190  * \param[in] env       environment passed by caller
 191  * \param[in] dev       device to be processed
 192  * \param[in] lcfg      lustre_cfg, LCFG_PRE_CLEANUP or LCFG_CLEANUP
 193  *
 194  * \retval              0 on success
 195  * \retval              negative number on error
 196  */
 197 static int lwp_process_config(const struct lu_env *env,
 198                               struct lu_device *dev, struct lustre_cfg *lcfg)
 199 {
 200         struct lwp_device               *d = lu2lwp_dev(dev);
 201         int                              rc;
 202         ENTRY;
 203
 204         switch (lcfg->lcfg_command) {
 205         case LCFG_PRE_CLEANUP:
 206         case LCFG_CLEANUP:
 207                 rc = lwp_disconnect(d);
 208                 break;
 209         case LCFG_PARAM:
 210                 rc = -ENOSYS;
 211                 break;
 212         default:
 213                 CERROR("%s: unknown command %u\n",
 214                        (char *)lustre_cfg_string(lcfg, 0), lcfg->lcfg_command);
 215                 rc = 0;
 216                 break;
 217         }
 218
 219         RETURN(rc);
 220 }
 221
 222 static const struct lu_device_operations lwp_lu_ops = {
 223         .ldo_process_config     = lwp_process_config,
 224 };
 225
 226 /**
 227  * Initialize LWP device.
 228  *
 229  * \param[in] env       environment passed by caller
 230  * \param[in] lwp       device to be initialized
 231  * \param[in] ldt       not used
 232  * \param[in] cfg       lustre_cfg contains remote target uuid
 233  *
 234  * \retval              0 on success
 235  * \retval              -ENODEV if the device name cannot be found
 236  * \retval              negative numbers on other errors
 237  */
 238 static int lwp_init0(const struct lu_env *env, struct lwp_device *lwp,
 239                      struct lu_device_type *ldt, struct lustre_cfg *cfg)
 240 {
 241         int                        rc;
 242         ENTRY;
 243
 244         lwp->lpd_obd = class_name2obd(lustre_cfg_string(cfg, 0));
 245         if (lwp->lpd_obd == NULL) {
 246                 CERROR("Cannot find obd with name %s\n",
 247                        lustre_cfg_string(cfg, 0));
 248                 RETURN(-ENODEV);
 249         }
 250
 251         lwp->lpd_dev.ld_ops = &lwp_lu_ops;
 252         lwp->lpd_obd->obd_lu_dev = &lwp->lpd_dev;
 253
 254         rc = ptlrpcd_addref();
 255         if (rc) {
 256                 CERROR("%s: ptlrpcd addref error: rc =%d\n",
 257                        lwp->lpd_obd->obd_name, rc);
 258                 RETURN(rc);
 259         }
 260
 261         rc = lprocfs_obd_setup(lwp->lpd_obd, true);
 262         if (rc) {
 263                 CERROR("%s: lprocfs_obd_setup failed. %d\n",
 264                        lwp->lpd_obd->obd_name, rc);
 265                 ptlrpcd_decref();
 266                 RETURN(rc);
 267         }
 268
 269         rc = lwp_setup(env, lwp, lustre_cfg_string(cfg, 1));
 270         if (rc) {
 271                 CERROR("%s: setup lwp failed. %d\n",
 272                        lwp->lpd_obd->obd_name, rc);
 273                 lprocfs_obd_cleanup(lwp->lpd_obd);
 274                 ptlrpcd_decref();
 275                 RETURN(rc);
 276         }
 277
 278         rc = sptlrpc_lprocfs_cliobd_attach(lwp->lpd_obd);
 279         if (rc) {
 280                 CERROR("%s: sptlrpc_lprocfs_cliobd_attached failed. %d\n",
 281                        lwp->lpd_obd->obd_name, rc);
 282                 ptlrpcd_decref();
 283                 RETURN(rc);
 284         }
 285
 286         ptlrpc_lprocfs_register_obd(lwp->lpd_obd);
 287
 288         RETURN(0);
 289 }
 290
 291 /**
 292  * Implementation of lu_device_type_operations::ldto_device_free.
 293  *
 294  * Free a LWP device.
 295  *
 296  * \param[in] env       environment passed by caller
 297  * \param[in] lu        device to be freed
 298  *
 299  * \retval              NULL to indicate that this is the bottom device
 300  *                      of the stack and there are no more devices
 301  *                      below this one to be cleaned up.
 302  */
 303 static struct lu_device *lwp_device_free(const struct lu_env *env,
 304                                          struct lu_device *lu)
 305 {
 306         struct lwp_device *m = lu2lwp_dev(lu);
 307         ENTRY;
 308
 309         lu_site_print(env, lu->ld_site, &lu->ld_ref, D_ERROR,
 310                       lu_cdebug_printer);
 311         lu_device_fini(&m->lpd_dev);
 312         OBD_FREE_PTR(m);
 313         RETURN(NULL);
 314 }
 315
 316 /**
 317  * Implementation of lu_device_type_operations::ldto_device_alloc.
 318  *
 319  * Allocate a LWP device.
 320  *
 321  * \param[in] env       environment passed by caller
 322  * \param[in] ldt       device type whose name is LUSTRE_LWP_NAME
 323  * \param[in] lcfg      lustre_cfg contains remote target UUID
 324  *
 325  * \retval              pointer of allocated LWP device on success
 326  * \retval              ERR_PTR(errno) on error
 327  */
 328 static struct lu_device *lwp_device_alloc(const struct lu_env *env,
 329                                           struct lu_device_type *ldt,
 330                                           struct lustre_cfg *lcfg)
 331 {
 332         struct lwp_device *lwp;
 333         struct lu_device  *ludev;
 334
 335         OBD_ALLOC_PTR(lwp);
 336         if (lwp == NULL) {
 337                 ludev = ERR_PTR(-ENOMEM);
 338         } else {
 339                 int rc;
 340
 341                 ludev = lwp2lu_dev(lwp);
 342                 lu_device_init(&lwp->lpd_dev, ldt);
 343                 rc = lwp_init0(env, lwp, ldt, lcfg);
 344                 if (rc != 0) {
 345                         lwp_device_free(env, ludev);
 346                         ludev = ERR_PTR(rc);
 347                 }
 348         }
 349         return ludev;
 350 }
 351
 352
 353 /**
 354  * Implementation of lu_device_type_operations::ltdo_device_fini.
 355  *
 356  * Finalize LWP device.
 357  *
 358  * \param[in] env       environment passed by caller
 359  * \param[in] ludev     device to be finalized
 360  *
 361  * \retval              NULL on success
 362  */
 363 static struct lu_device *lwp_device_fini(const struct lu_env *env,
 364                                          struct lu_device *ludev)
 365 {
 366         struct lwp_device       *m = lu2lwp_dev(ludev);
 367         struct task_struct      *task = NULL;
 368         int                      rc;
 369         ENTRY;
 370
 371         task = xchg(&m->lpd_notify_task, NULL);
 372         if (task) {
 373                 kthread_stop(task);
 374                 class_export_put(m->lpd_exp);
 375         }
 376
 377         if (m->lpd_exp != NULL)
 378                 class_disconnect(m->lpd_exp);
 379
 380         LASSERT(m->lpd_obd);
 381         rc = client_obd_cleanup(m->lpd_obd);
 382         LASSERTF(rc == 0, "error %d\n", rc);
 383
 384         ptlrpc_lprocfs_unregister_obd(m->lpd_obd);
 385
 386         ptlrpcd_decref();
 387
 388         RETURN(NULL);
 389 }
 390
 391 static const struct lu_device_type_operations lwp_device_type_ops = {
 392         .ldto_device_alloc      = lwp_device_alloc,
 393         .ldto_device_free       = lwp_device_free,
 394         .ldto_device_fini       = lwp_device_fini
 395 };
 396
 397 struct lu_device_type lwp_device_type = {
 398         .ldt_tags     = LU_DEVICE_DT,
 399         .ldt_name     = LUSTRE_LWP_NAME,
 400         .ldt_ops      = &lwp_device_type_ops,
 401         .ldt_ctx_tags = LCT_MD_THREAD
 402 };
 403
 404 static int lwp_notify_main(void *args)
 405 {
 406         struct obd_export       *exp = (struct obd_export *)args;
 407         struct lwp_device       *lwp;
 408
 409         LASSERT(exp != NULL);
 410
 411         lwp = lu2lwp_dev(exp->exp_obd->obd_lu_dev);
 412
 413         lustre_notify_lwp_list(exp);
 414
 415         if (xchg(&lwp->lpd_notify_task, NULL) == NULL)
 416                 /* lwp_device_fini() is waiting for me
 417                  * Note that the wakeup comes direct from
 418                  * kthread_stop, not from wake_up_var().
 419                  * lwp_device_fini() will call class_export_put().
 420                  */
 421                 wait_var_event(lwp, kthread_should_stop());
 422         else
 423                 class_export_put(exp);
 424
 425         return 0;
 426 }
 427
 428 /*
 429  * Some notify callbacks may cause deadlock in failover
 430  * scenario, so we have to start thread to run callbacks
 431  * asynchronously. See LU-6273.
 432  */
 433 static void lwp_notify_users(struct obd_export *exp)
 434 {
 435         struct lwp_device       *lwp;
 436         struct task_struct      *task;
 437         char                     name[MTI_NAME_MAXLEN];
 438
 439         LASSERT(exp != NULL);
 440         lwp = lu2lwp_dev(exp->exp_obd->obd_lu_dev);
 441
 442         snprintf(name, MTI_NAME_MAXLEN, "lwp_notify_%s",
 443                  exp->exp_obd->obd_name);
 444
 445         /* Notify happens only on LWP setup, so there shouldn't
 446          * be notify thread running */
 447         if (lwp->lpd_notify_task) {
 448                 CERROR("LWP notify thread: %s wasn't stopped\n", name);
 449                 return;
 450         }
 451
 452         task = kthread_create(lwp_notify_main, exp, "%s", name);
 453         if (IS_ERR(task)) {
 454                 CERROR("Failed to start LWP notify thread:%s. %lu\n",
 455                        name, PTR_ERR(task));
 456         } else {
 457                 lwp->lpd_notify_task = task;
 458                 class_export_get(exp);
 459                 wake_up_process(task);
 460         }
 461 }
 462
 463 /**
 464  * Implementation of OBD device operations obd_ops::o_connect.
 465  *
 466  * Create export for LWP, and connect to target server.
 467  *
 468  * \param[in] env       the environment passed by caller
 469  * \param[out] exp      export for the connection to be established
 470  * \param[in] obd       OBD device to perform the connect on
 471  * \param[in] cluuid    UUID of the OBD device
 472  * \param[in] data      connect data containing compatibility flags
 473  * \param[in] localdata not used
 474  *
 475  * \retval              0 on success
 476  * \retval              negative number on error
 477  */
 478 static int lwp_obd_connect(const struct lu_env *env, struct obd_export **exp,
 479                            struct obd_device *obd, struct obd_uuid *cluuid,
 480                            struct obd_connect_data *data, void *localdata)
 481 {
 482         struct lwp_device       *lwp = lu2lwp_dev(obd->obd_lu_dev);
 483         struct client_obd       *cli = &lwp->lpd_obd->u.cli;
 484         struct obd_import       *imp = cli->cl_import;
 485         struct obd_connect_data *ocd;
 486         struct lustre_handle     conn;
 487         int                      rc;
 488
 489         ENTRY;
 490
 491         CDEBUG(D_CONFIG, "connect #%d\n", lwp->lpd_connects);
 492
 493         *exp = NULL;
 494         down_write(&cli->cl_sem);
 495         rc = class_connect(&conn, obd, cluuid);
 496         if (rc != 0)
 497                 GOTO(out_sem, rc);
 498
 499         *exp = class_conn2export(&conn);
 500         lwp->lpd_exp = *exp;
 501
 502         lwp->lpd_connects++;
 503         LASSERT(lwp->lpd_connects == 1);
 504
 505         imp->imp_dlm_handle = conn;
 506         rc = ptlrpc_init_import(imp);
 507         if (rc != 0)
 508                 GOTO(out_dis, rc);
 509
 510         LASSERT(data != NULL);
 511         ocd = &imp->imp_connect_data;
 512         *ocd = *data;
 513
 514         LASSERT(ocd->ocd_connect_flags & OBD_CONNECT_LIGHTWEIGHT);
 515
 516         ocd->ocd_version = LUSTRE_VERSION_CODE;
 517         imp->imp_connect_flags_orig = ocd->ocd_connect_flags;
 518         imp->imp_connect_flags2_orig = ocd->ocd_connect_flags2;
 519
 520         rc = ptlrpc_connect_import(imp);
 521         if (rc != 0) {
 522                 CERROR("%s: can't connect obd: rc = %d\n", obd->obd_name, rc);
 523                 GOTO(out_dis, rc);
 524         }
 525
 526         ptlrpc_pinger_add_import(imp);
 527
 528         GOTO(out_dis, rc = 0);
 529
 530 out_dis:
 531         if (rc != 0) {
 532                 class_disconnect(*exp);
 533                 *exp = NULL;
 534                 lwp->lpd_exp = NULL;
 535         }
 536
 537 out_sem:
 538         up_write(&cli->cl_sem);
 539
 540         if (rc == 0)
 541                 lwp_notify_users(*exp);
 542
 543         return rc;
 544 }
 545
 546 /**
 547  * Implementation of OBD device operations obd_ops::o_disconnect.
 548  *
 549  * Release export for the LWP. Only disconnect the underlying layers
 550  * on the final disconnect.
 551  *
 552  * \param[in] exp       the export to perform disconnect on
 553  *
 554  * \retval              0 on success
 555  * \retval              negative number on error
 556  */
 557 static int lwp_obd_disconnect(struct obd_export *exp)
 558 {
 559         struct obd_device *obd = exp->exp_obd;
 560         struct lwp_device *lwp = lu2lwp_dev(obd->obd_lu_dev);
 561         int                rc;
 562         ENTRY;
 563
 564         LASSERT(lwp->lpd_connects == 1);
 565         lwp->lpd_connects--;
 566
 567         rc = class_disconnect(exp);
 568         if (rc)
 569                 CERROR("%s: class disconnect error: rc = %d\n",
 570                        obd->obd_name, rc);
 571
 572         RETURN(rc);
 573 }
 574
 575 /**
 576  * Handle import events for the LWP device.
 577  *
 578  * \param[in] obd       OBD device associated with the import
 579  * \param[in] imp       the import which event happened on
 580  * \param[in] event     event type
 581  *
 582  * \retval              0 on success
 583  * \retval              negative number on error
 584  */
 585 static int lwp_import_event(struct obd_device *obd, struct obd_import *imp,
 586                             enum obd_import_event event)
 587 {
 588         switch (event) {
 589         case IMP_EVENT_DISCON:
 590         case IMP_EVENT_INACTIVE:
 591         case IMP_EVENT_ACTIVE:
 592                 break;
 593         case IMP_EVENT_INVALIDATE:
 594                 if (obd->obd_namespace == NULL)
 595                         break;
 596                 ldlm_namespace_cleanup(obd->obd_namespace, LDLM_FL_LOCAL_ONLY);
 597                 break;
 598         case IMP_EVENT_OCD:
 599                 break;
 600         default:
 601                 CERROR("%s: unsupported import event: %#x\n",
 602                        obd->obd_name, event);
 603         }
 604         return 0;
 605 }
 606
 607 static int lwp_set_info_async(const struct lu_env *env,
 608                               struct obd_export *exp,
 609                               u32 keylen, void *key,
 610                               u32 vallen, void *val,
 611                               struct ptlrpc_request_set *set)
 612 {
 613         ENTRY;
 614
 615         if (KEY_IS(KEY_SPTLRPC_CONF)) {
 616                 sptlrpc_conf_client_adapt(exp->exp_obd);
 617                 RETURN(0);
 618         }
 619
 620         CERROR("Unknown key %s\n", (char *)key);
 621         RETURN(-EINVAL);
 622 }
 623
 624 const struct obd_ops lwp_obd_device_ops = {
 625         .o_owner        = THIS_MODULE,
 626         .o_add_conn     = client_import_add_conn,
 627         .o_del_conn     = client_import_del_conn,
 628         .o_connect      = lwp_obd_connect,
 629         .o_disconnect   = lwp_obd_disconnect,
 630         .o_import_event = lwp_import_event,
 631         .o_set_info_async   = lwp_set_info_async,
 632 };