lustre/lov/lov_obd.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, see
  18  * http://www.gnu.org/licenses/gpl-2.0.html
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * Copyright (c) 2011, 2017, Intel Corporation.
  27  */
  28 /*
  29  * This file is part of Lustre, http://www.lustre.org/
  30  * Lustre is a trademark of Sun Microsystems, Inc.
  31  *
  32  * lustre/lov/lov_obd.c
  33  *
  34  * Author: Phil Schwan <phil@clusterfs.com>
  35  * Author: Peter Braam <braam@clusterfs.com>
  36  * Author: Mike Shaver <shaver@clusterfs.com>
  37  * Author: Nathan Rutman <nathan@clusterfs.com>
  38  */
  39
  40 #define DEBUG_SUBSYSTEM S_LOV
  41 #include <libcfs/libcfs.h>
  42
  43 #include <cl_object.h>
  44 #include <lustre_dlm.h>
  45 #include <lustre_fid.h>
  46 #include <uapi/linux/lustre/lustre_ioctl.h>
  47 #include <lustre_lib.h>
  48 #include <lustre_mds.h>
  49 #include <lustre_net.h>
  50 #include <uapi/linux/lustre/lustre_param.h>
  51 #include <lustre_swab.h>
  52 #include <lprocfs_status.h>
  53 #include <obd_class.h>
  54 #include <obd_support.h>
  55
  56 #include "lov_internal.h"
  57
  58 /* Keep a refcount of lov->tgt usage to prevent racing with addition/deletion.
  59    Any function that expects lov_tgts to remain stationary must take a ref. */
  60 void lov_tgts_getref(struct obd_device *obd)
  61 {
  62         struct lov_obd *lov = &obd->u.lov;
  63
  64         /* nobody gets through here until lov_putref is done */
  65         mutex_lock(&lov->lov_lock);
  66         atomic_inc(&lov->lov_refcount);
  67         mutex_unlock(&lov->lov_lock);
  68 }
  69
  70 static void __lov_del_obd(struct obd_device *obd, struct lov_tgt_desc *tgt);
  71
  72 void lov_tgts_putref(struct obd_device *obd)
  73 {
  74         struct lov_obd *lov = &obd->u.lov;
  75
  76         mutex_lock(&lov->lov_lock);
  77         /* ok to dec to 0 more than once -- ltd_exp's will be null */
  78         if (atomic_dec_and_test(&lov->lov_refcount) && lov->lov_death_row) {
  79                 LIST_HEAD(kill);
  80                 struct lov_tgt_desc *tgt, *n;
  81                 int i;
  82
  83                 CDEBUG(D_CONFIG, "destroying %d lov targets\n",
  84                        lov->lov_death_row);
  85                 for (i = 0; i < lov->desc.ld_tgt_count; i++) {
  86                         tgt = lov->lov_tgts[i];
  87
  88                         if (!tgt || !tgt->ltd_reap)
  89                                 continue;
  90                         list_add(&tgt->ltd_kill, &kill);
  91                         /* XXX - right now there is a dependency on ld_tgt_count
  92                          * being the maximum tgt index for computing the
  93                          * mds_max_easize. So we can't shrink it. */
  94                         tgt_pool_remove(&lov->lov_packed, i);
  95                         lov->lov_tgts[i] = NULL;
  96                         lov->lov_death_row--;
  97                 }
  98                 mutex_unlock(&lov->lov_lock);
  99
 100                 list_for_each_entry_safe(tgt, n, &kill, ltd_kill) {
 101                         list_del(&tgt->ltd_kill);
 102                         /* Disconnect */
 103                         __lov_del_obd(obd, tgt);
 104                 }
 105         } else {
 106                 mutex_unlock(&lov->lov_lock);
 107         }
 108 }
 109
 110 static int lov_notify(struct obd_device *obd, struct obd_device *watched,
 111                       enum obd_notify_event ev);
 112
 113 int lov_connect_osc(struct obd_device *obd, u32 index, int activate,
 114                     struct obd_connect_data *data)
 115 {
 116         struct lov_obd *lov = &obd->u.lov;
 117         struct obd_uuid *tgt_uuid;
 118         struct obd_device *tgt_obd;
 119         static struct obd_uuid lov_osc_uuid = { "LOV_OSC_UUID" };
 120         struct obd_import *imp;
 121         int rc;
 122         ENTRY;
 123
 124         if (lov->lov_tgts[index] == NULL)
 125                 RETURN(-EINVAL);
 126
 127         tgt_uuid = &lov->lov_tgts[index]->ltd_uuid;
 128         tgt_obd = lov->lov_tgts[index]->ltd_obd;
 129
 130         if (!tgt_obd->obd_set_up) {
 131                 CERROR("Target %s not set up\n", obd_uuid2str(tgt_uuid));
 132                 RETURN(-EINVAL);
 133         }
 134
 135         /* override the sp_me from lov */
 136         tgt_obd->u.cli.cl_sp_me = lov->lov_sp_me;
 137
 138         if (data && (data->ocd_connect_flags & OBD_CONNECT_INDEX))
 139                 data->ocd_index = index;
 140
 141         /*
 142          * Divine LOV knows that OBDs under it are OSCs.
 143          */
 144         imp = tgt_obd->u.cli.cl_import;
 145
 146         if (activate) {
 147                 tgt_obd->obd_no_recov = 0;
 148                 /* FIXME this is probably supposed to be
 149                    ptlrpc_set_import_active.  Horrible naming. */
 150                 ptlrpc_activate_import(imp, false);
 151         }
 152
 153         rc = obd_register_observer(tgt_obd, obd);
 154         if (rc) {
 155                 CERROR("Target %s register_observer error %d\n",
 156                        obd_uuid2str(tgt_uuid), rc);
 157                 RETURN(rc);
 158         }
 159
 160         if (imp->imp_invalid) {
 161                 CDEBUG(D_CONFIG, "%s: not connecting - administratively disabled\n",
 162                        obd_uuid2str(tgt_uuid));
 163                 RETURN(0);
 164         }
 165
 166         rc = obd_connect(NULL, &lov->lov_tgts[index]->ltd_exp, tgt_obd,
 167                          &lov_osc_uuid, data, lov->lov_cache);
 168         if (rc || !lov->lov_tgts[index]->ltd_exp) {
 169                 CERROR("Target %s connect error %d\n",
 170                        obd_uuid2str(tgt_uuid), rc);
 171                 RETURN(-ENODEV);
 172         }
 173
 174         lov->lov_tgts[index]->ltd_reap = 0;
 175
 176         CDEBUG(D_CONFIG, "Connected tgt idx %d %s (%s) %sactive\n", index,
 177                obd_uuid2str(tgt_uuid), tgt_obd->obd_name, activate ? "":"in");
 178
 179         if (lov->lov_tgts_kobj) {
 180                 /* Even if we failed, that's ok */
 181                 rc = sysfs_create_link(lov->lov_tgts_kobj,
 182                                        &tgt_obd->obd_kset.kobj,
 183                                        tgt_obd->obd_name);
 184                 if (rc) {
 185                         CERROR("%s: can't register LOV target /sys/fs/lustre/%s/%s/target_obds/%s : rc = %d\n",
 186                                obd->obd_name, obd->obd_type->typ_name,
 187                                obd->obd_name,
 188                                lov->lov_tgts[index]->ltd_exp->exp_obd->obd_name,
 189                                rc);
 190                 }
 191         }
 192         RETURN(0);
 193 }
 194
 195 static int lov_connect(const struct lu_env *env,
 196                        struct obd_export **exp, struct obd_device *obd,
 197                        struct obd_uuid *cluuid, struct obd_connect_data *data,
 198                        void *localdata)
 199 {
 200         struct lov_obd *lov = &obd->u.lov;
 201         struct lov_tgt_desc *tgt;
 202         struct lustre_handle conn;
 203         int i, rc;
 204         ENTRY;
 205
 206         CDEBUG(D_CONFIG, "connect #%d\n", lov->lov_connects);
 207
 208         rc = class_connect(&conn, obd, cluuid);
 209         if (rc)
 210                 RETURN(rc);
 211
 212         *exp = class_conn2export(&conn);
 213
 214         /* Why should there ever be more than 1 connect? */
 215         lov->lov_connects++;
 216         LASSERT(lov->lov_connects == 1);
 217
 218         memset(&lov->lov_ocd, 0, sizeof(lov->lov_ocd));
 219         if (data)
 220                 lov->lov_ocd = *data;
 221
 222         lov_tgts_getref(obd);
 223
 224         if (localdata) {
 225                 lov->lov_cache = localdata;
 226                 cl_cache_incref(lov->lov_cache);
 227         }
 228
 229         for (i = 0; i < lov->desc.ld_tgt_count; i++) {
 230                 tgt = lov->lov_tgts[i];
 231                 if (!tgt || obd_uuid_empty(&tgt->ltd_uuid))
 232                         continue;
 233                 /* Flags will be lowest common denominator */
 234                 rc = lov_connect_osc(obd, i, tgt->ltd_activate, &lov->lov_ocd);
 235                 if (rc) {
 236                         CERROR("%s: lov connect tgt %d failed: %d\n",
 237                                obd->obd_name, i, rc);
 238                         continue;
 239                 }
 240                 /* connect to administrative disabled ost */
 241                 if (!lov->lov_tgts[i]->ltd_exp)
 242                         continue;
 243
 244                 rc = lov_notify(obd, lov->lov_tgts[i]->ltd_exp->exp_obd,
 245                                 OBD_NOTIFY_CONNECT);
 246                 if (rc) {
 247                         CERROR("%s error sending notify %d\n",
 248                                obd->obd_name, rc);
 249                 }
 250         }
 251
 252         lov_tgts_putref(obd);
 253
 254         RETURN(0);
 255 }
 256
 257 static int lov_disconnect_obd(struct obd_device *obd, struct lov_tgt_desc *tgt)
 258 {
 259         struct lov_obd *lov = &obd->u.lov;
 260         struct obd_device *osc_obd;
 261         int rc;
 262         ENTRY;
 263
 264         osc_obd = class_exp2obd(tgt->ltd_exp);
 265         CDEBUG(D_CONFIG, "%s: disconnecting target %s\n", obd->obd_name,
 266                osc_obd ? osc_obd->obd_name : "<no obd>");
 267
 268         if (tgt->ltd_active) {
 269                 tgt->ltd_active = 0;
 270                 lov->desc.ld_active_tgt_count--;
 271                 tgt->ltd_exp->exp_obd->obd_inactive = 1;
 272         }
 273
 274         if (osc_obd) {
 275                 if (lov->lov_tgts_kobj)
 276                         sysfs_remove_link(lov->lov_tgts_kobj,
 277                                           osc_obd->obd_name);
 278
 279                 /* Pass it on to our clients.
 280                  * XXX This should be an argument to disconnect,
 281                  * XXX not a back-door flag on the OBD.  Ah well.
 282                  */
 283                 osc_obd->obd_force = obd->obd_force;
 284                 osc_obd->obd_fail = obd->obd_fail;
 285                 osc_obd->obd_no_recov = obd->obd_no_recov;
 286         }
 287
 288         obd_register_observer(osc_obd, NULL);
 289
 290         rc = obd_disconnect(tgt->ltd_exp);
 291         if (rc) {
 292                 CERROR("Target %s disconnect error %d\n",
 293                        tgt->ltd_uuid.uuid, rc);
 294                 rc = 0;
 295         }
 296
 297         tgt->ltd_exp = NULL;
 298         RETURN(0);
 299 }
 300
 301 static int lov_disconnect(struct obd_export *exp)
 302 {
 303         struct obd_device *obd = class_exp2obd(exp);
 304         struct lov_obd *lov = &obd->u.lov;
 305         u32 index;
 306         int rc;
 307
 308         ENTRY;
 309         if (!lov->lov_tgts)
 310                 goto out;
 311
 312         /* Only disconnect the underlying layers on the final disconnect. */
 313         lov->lov_connects--;
 314         if (lov->lov_connects != 0) {
 315                 /* why should there be more than 1 connect? */
 316                 CWARN("%s: unexpected disconnect #%d\n",
 317                       obd->obd_name, lov->lov_connects);
 318                 goto out;
 319         }
 320
 321         /* hold another ref so lov_del_obd() doesn't spin in putref each time */
 322         lov_tgts_getref(obd);
 323
 324         for (index = 0; index < lov->desc.ld_tgt_count; index++) {
 325                 if (lov->lov_tgts[index] && lov->lov_tgts[index]->ltd_exp) {
 326                         /* Disconnection is the last we know about an OBD */
 327                         lov_del_target(obd, index, NULL,
 328                                        lov->lov_tgts[index]->ltd_gen);
 329                 }
 330         }
 331         lov_tgts_putref(obd);
 332
 333 out:
 334         rc = class_disconnect(exp); /* bz 9811 */
 335         RETURN(rc);
 336 }
 337
 338 /* Error codes:
 339  *
 340  *  -EINVAL  : UUID can't be found in the LOV's target list
 341  *  -ENOTCONN: The UUID is found, but the target connection is bad (!)
 342  *  -EBADF   : The UUID is found, but the OBD is the wrong type (!)
 343  *  any >= 0 : is log target index
 344  */
 345 static int lov_set_osc_active(struct obd_device *obd, struct obd_uuid *uuid,
 346                               enum obd_notify_event ev)
 347 {
 348         struct lov_obd *lov = &obd->u.lov;
 349         struct lov_tgt_desc *tgt;
 350         int index;
 351         bool activate, active;
 352         ENTRY;
 353
 354         CDEBUG(D_INFO, "Searching in lov %p for uuid %s event(%d)\n",
 355                lov, uuid->uuid, ev);
 356
 357         lov_tgts_getref(obd);
 358         for (index = 0; index < lov->desc.ld_tgt_count; index++) {
 359                 tgt = lov->lov_tgts[index];
 360                 if (tgt && obd_uuid_equals(uuid, &tgt->ltd_uuid))
 361                         break;
 362         }
 363
 364         if (index == lov->desc.ld_tgt_count)
 365                 GOTO(out, index = -EINVAL);
 366
 367         if (ev == OBD_NOTIFY_DEACTIVATE || ev == OBD_NOTIFY_ACTIVATE) {
 368                 activate = (ev == OBD_NOTIFY_ACTIVATE);
 369
 370                 /*
 371                  * LU-642, initially inactive OSC could miss the obd_connect,
 372                  * we make up for it here.
 373                  */
 374                 if (activate && !tgt->ltd_exp) {
 375                         int rc;
 376                         struct obd_uuid lov_osc_uuid = {"LOV_OSC_UUID"};
 377
 378                         rc = obd_connect(NULL, &tgt->ltd_exp, tgt->ltd_obd,
 379                                          &lov_osc_uuid, &lov->lov_ocd,
 380                                          lov->lov_cache);
 381                         if (rc || !tgt->ltd_exp)
 382                                 GOTO(out, index = rc);
 383                 }
 384
 385                 if (lov->lov_tgts[index]->ltd_activate == activate) {
 386                         CDEBUG(D_INFO, "OSC %s already %sactivate!\n",
 387                                uuid->uuid, activate ? "" : "de");
 388                 } else {
 389                         lov->lov_tgts[index]->ltd_activate = activate;
 390                         CDEBUG(D_CONFIG, "%sactivate OSC %s\n",
 391                                activate ? "" : "de", obd_uuid2str(uuid));
 392                 }
 393         } else if (ev == OBD_NOTIFY_INACTIVE || ev == OBD_NOTIFY_ACTIVE) {
 394                 active = (ev == OBD_NOTIFY_ACTIVE);
 395
 396                 if (lov->lov_tgts[index]->ltd_active == active) {
 397                         CDEBUG(D_INFO, "OSC %s already %sactive!\n",
 398                                uuid->uuid, active ? "" : "in");
 399                         GOTO(out, index);
 400                 }
 401                 CDEBUG(D_CONFIG, "Marking OSC %s %sactive\n",
 402                        obd_uuid2str(uuid), active ? "" : "in");
 403
 404                 lov->lov_tgts[index]->ltd_active = active;
 405                 if (active) {
 406                         lov->desc.ld_active_tgt_count++;
 407                         lov->lov_tgts[index]->ltd_exp->exp_obd->obd_inactive = 0;
 408                 } else {
 409                         lov->desc.ld_active_tgt_count--;
 410                         lov->lov_tgts[index]->ltd_exp->exp_obd->obd_inactive = 1;
 411                 }
 412         } else {
 413                 CERROR("%s: unknown event %d for uuid %s\n", obd->obd_name,
 414                        ev, uuid->uuid);
 415         }
 416
 417         if (tgt->ltd_exp)
 418                 CDEBUG(D_INFO, "%s: lov idx %d conn %llx\n", obd_uuid2str(uuid),
 419                        index, tgt->ltd_exp->exp_handle.h_cookie);
 420
 421  out:
 422         lov_tgts_putref(obd);
 423         RETURN(index);
 424 }
 425
 426 static int lov_notify(struct obd_device *obd, struct obd_device *watched,
 427                       enum obd_notify_event ev)
 428 {
 429         int rc = 0;
 430         struct lov_obd *lov = &obd->u.lov;
 431         ENTRY;
 432
 433         down_read(&lov->lov_notify_lock);
 434         if (!lov->lov_connects)
 435                 GOTO(out_notify_lock, rc = 0);
 436
 437         if (ev == OBD_NOTIFY_ACTIVE || ev == OBD_NOTIFY_INACTIVE ||
 438             ev == OBD_NOTIFY_ACTIVATE || ev == OBD_NOTIFY_DEACTIVATE) {
 439                 struct obd_uuid *uuid;
 440
 441                 LASSERT(watched);
 442
 443                 if (strcmp(watched->obd_type->typ_name, LUSTRE_OSC_NAME)) {
 444                         CERROR("unexpected notification of %s %s\n",
 445                                watched->obd_type->typ_name, watched->obd_name);
 446                         GOTO(out_notify_lock, rc = -EINVAL);
 447                 }
 448
 449                 uuid = &watched->u.cli.cl_target_uuid;
 450
 451                 /* Set OSC as active before notifying the observer, so the
 452                  * observer can use the OSC normally.
 453                  */
 454                 rc = lov_set_osc_active(obd, uuid, ev);
 455                 if (rc < 0) {
 456                         CERROR("%s: event %d failed: rc = %d\n", obd->obd_name,
 457                                ev, rc);
 458                         GOTO(out_notify_lock, rc);
 459                 }
 460         }
 461
 462         /* Pass the notification up the chain. */
 463         rc = obd_notify_observer(obd, watched, ev);
 464
 465 out_notify_lock:
 466         up_read(&lov->lov_notify_lock);
 467
 468         RETURN(rc);
 469 }
 470
 471 static int lov_add_target(struct obd_device *obd, struct obd_uuid *uuidp,
 472                           u32 index, int gen, int active)
 473 {
 474         struct lov_obd *lov = &obd->u.lov;
 475         struct lov_tgt_desc *tgt;
 476         struct obd_device *tgt_obd;
 477         int rc;
 478
 479         ENTRY;
 480         CDEBUG(D_CONFIG, "uuid:%s idx:%u gen:%d active:%d\n",
 481                uuidp->uuid, index, gen, active);
 482
 483         if (gen <= 0) {
 484                 CERROR("%s: request to add '%s' with invalid generation: %d\n",
 485                        obd->obd_name, uuidp->uuid, gen);
 486                 RETURN(-EINVAL);
 487         }
 488
 489         tgt_obd = class_find_client_obd(uuidp, LUSTRE_OSC_NAME, &obd->obd_uuid);
 490         if (tgt_obd == NULL)
 491                 RETURN(-EINVAL);
 492
 493         mutex_lock(&lov->lov_lock);
 494
 495         if ((index < lov->lov_tgt_size) && (lov->lov_tgts[index] != NULL)) {
 496                 tgt = lov->lov_tgts[index];
 497                 rc = -EEXIST;
 498                 CERROR("%s: UUID %s already assigned at index %d: rc = %d\n",
 499                        obd->obd_name, obd_uuid2str(&tgt->ltd_uuid), index, rc);
 500                 mutex_unlock(&lov->lov_lock);
 501                 RETURN(rc);
 502         }
 503
 504         if (index >= lov->lov_tgt_size) {
 505                 /* We need to reallocate the lov target array. */
 506                 struct lov_tgt_desc **newtgts, **old = NULL;
 507                 __u32 newsize, oldsize = 0;
 508
 509                 newsize = max(lov->lov_tgt_size, 2U);
 510                 while (newsize < index + 1)
 511                         newsize = newsize << 1;
 512                 OBD_ALLOC_PTR_ARRAY(newtgts, newsize);
 513                 if (newtgts == NULL) {
 514                         mutex_unlock(&lov->lov_lock);
 515                         RETURN(-ENOMEM);
 516                 }
 517
 518                 if (lov->lov_tgt_size) {
 519                         memcpy(newtgts, lov->lov_tgts, sizeof(*newtgts) *
 520                                lov->lov_tgt_size);
 521                         old = lov->lov_tgts;
 522                         oldsize = lov->lov_tgt_size;
 523                 }
 524
 525                 lov->lov_tgts = newtgts;
 526                 lov->lov_tgt_size = newsize;
 527                 smp_rmb();
 528                 if (old)
 529                         OBD_FREE_PTR_ARRAY(old, oldsize);
 530
 531                 CDEBUG(D_CONFIG, "tgts: %p size: %d\n",
 532                        lov->lov_tgts, lov->lov_tgt_size);
 533         }
 534
 535         OBD_ALLOC_PTR(tgt);
 536         if (!tgt) {
 537                 mutex_unlock(&lov->lov_lock);
 538                 RETURN(-ENOMEM);
 539         }
 540
 541         rc = tgt_pool_add(&lov->lov_packed, index, lov->lov_tgt_size);
 542         if (rc) {
 543                 mutex_unlock(&lov->lov_lock);
 544                 OBD_FREE_PTR(tgt);
 545                 RETURN(rc);
 546         }
 547
 548         tgt->ltd_uuid = *uuidp;
 549         tgt->ltd_obd = tgt_obd;
 550         /* XXX - add a sanity check on the generation number. */
 551         tgt->ltd_gen = gen;
 552         tgt->ltd_index = index;
 553         tgt->ltd_activate = active;
 554         lov->lov_tgts[index] = tgt;
 555         if (index >= lov->desc.ld_tgt_count)
 556                 lov->desc.ld_tgt_count = index + 1;
 557
 558         mutex_unlock(&lov->lov_lock);
 559
 560         CDEBUG(D_CONFIG, "idx=%d ltd_gen=%d ld_tgt_count=%d\n",
 561                 index, tgt->ltd_gen, lov->desc.ld_tgt_count);
 562
 563         if (lov->lov_connects == 0) {
 564                 /* lov_connect hasn't been called yet. We'll do the
 565                    lov_connect_osc on this target when that fn first runs,
 566                    because we don't know the connect flags yet. */
 567                 RETURN(0);
 568         }
 569
 570         lov_tgts_getref(obd);
 571
 572         rc = lov_connect_osc(obd, index, active, &lov->lov_ocd);
 573         if (rc)
 574                 GOTO(out, rc);
 575
 576         /* connect to administrative disabled ost */
 577         if (!tgt->ltd_exp)
 578                 GOTO(out, rc = 0);
 579
 580         rc = lov_notify(obd, tgt->ltd_exp->exp_obd,
 581                         active ? OBD_NOTIFY_CONNECT : OBD_NOTIFY_INACTIVE);
 582
 583 out:
 584         if (rc) {
 585                 CERROR("%s: add failed, deleting %s: rc = %d\n",
 586                        obd->obd_name, obd_uuid2str(&tgt->ltd_uuid), rc);
 587                 lov_del_target(obd, index, NULL, 0);
 588         }
 589         lov_tgts_putref(obd);
 590         RETURN(rc);
 591 }
 592
 593 /* Schedule a target for deletion */
 594 int lov_del_target(struct obd_device *obd, u32 index,
 595                    struct obd_uuid *uuidp, int gen)
 596 {
 597         struct lov_obd *lov = &obd->u.lov;
 598         int count = lov->desc.ld_tgt_count;
 599         int rc = 0;
 600         ENTRY;
 601
 602         if (index >= count) {
 603                 CERROR("LOV target index %d >= number of LOV OBDs %d.\n",
 604                        index, count);
 605                 RETURN(-EINVAL);
 606         }
 607
 608         /* to make sure there's no ongoing lov_notify() now */
 609         down_write(&lov->lov_notify_lock);
 610         lov_tgts_getref(obd);
 611
 612         if (!lov->lov_tgts[index]) {
 613                 CERROR("LOV target at index %d is not setup.\n", index);
 614                 GOTO(out, rc = -EINVAL);
 615         }
 616
 617         if (uuidp && !obd_uuid_equals(uuidp, &lov->lov_tgts[index]->ltd_uuid)) {
 618                 CERROR("LOV target UUID %s at index %d doesn't match %s.\n",
 619                        lov_uuid2str(lov, index), index,
 620                        obd_uuid2str(uuidp));
 621                 GOTO(out, rc = -EINVAL);
 622         }
 623
 624         CDEBUG(D_CONFIG, "uuid: %s idx: %d gen: %d exp: %p active: %d\n",
 625                lov_uuid2str(lov, index), index,
 626                lov->lov_tgts[index]->ltd_gen, lov->lov_tgts[index]->ltd_exp,
 627                lov->lov_tgts[index]->ltd_active);
 628
 629         lov->lov_tgts[index]->ltd_reap = 1;
 630         lov->lov_death_row++;
 631         /* we really delete it from lov_tgts_putref() */
 632 out:
 633         lov_tgts_putref(obd);
 634         up_write(&lov->lov_notify_lock);
 635
 636         RETURN(rc);
 637 }
 638
 639 static void __lov_del_obd(struct obd_device *obd, struct lov_tgt_desc *tgt)
 640 {
 641         struct obd_device *osc_obd;
 642
 643         LASSERT(tgt);
 644         LASSERT(tgt->ltd_reap);
 645
 646         osc_obd = class_exp2obd(tgt->ltd_exp);
 647
 648         CDEBUG(D_CONFIG, "Removing tgt %s : %s\n",
 649                tgt->ltd_uuid.uuid,
 650                osc_obd ? osc_obd->obd_name : "<no obd>");
 651
 652         if (tgt->ltd_exp)
 653                 lov_disconnect_obd(obd, tgt);
 654
 655         OBD_FREE_PTR(tgt);
 656
 657         /* Manual cleanup - no cleanup logs to clean up the osc's.  We must
 658            do it ourselves. And we can't do it from lov_cleanup,
 659            because we just lost our only reference to it. */
 660         if (osc_obd)
 661                 class_manual_cleanup(osc_obd);
 662 }
 663
 664 void lov_fix_desc_stripe_size(__u64 *val)
 665 {
 666         if (*val < LOV_MIN_STRIPE_SIZE) {
 667                 if (*val != 0)
 668                         LCONSOLE_INFO("Increasing default stripe size to "
 669                                       "minimum %u\n",
 670                                       LOV_DESC_STRIPE_SIZE_DEFAULT);
 671                 *val = LOV_DESC_STRIPE_SIZE_DEFAULT;
 672         } else if (*val & (LOV_MIN_STRIPE_SIZE - 1)) {
 673                 *val &= ~(LOV_MIN_STRIPE_SIZE - 1);
 674                 LCONSOLE_WARN("Changing default stripe size to %llu (a "
 675                               "multiple of %u)\n",
 676                               *val, LOV_MIN_STRIPE_SIZE);
 677         }
 678 }
 679
 680 void lov_fix_desc_stripe_count(__u32 *val)
 681 {
 682         if (*val == 0)
 683                 *val = 1;
 684 }
 685
 686 void lov_fix_desc_pattern(__u32 *val)
 687 {
 688         /* from lov_setstripe */
 689         if ((*val != 0) && !lov_pattern_supported_normal_comp(*val)) {
 690                 LCONSOLE_WARN("lov: Unknown stripe pattern: %#x\n", *val);
 691                 *val = 0;
 692         }
 693 }
 694
 695 void lov_fix_desc_qos_maxage(__u32 *val)
 696 {
 697         if (*val == 0)
 698                 *val = LOV_DESC_QOS_MAXAGE_DEFAULT;
 699 }
 700
 701 void lov_fix_desc(struct lov_desc *desc)
 702 {
 703         lov_fix_desc_stripe_size(&desc->ld_default_stripe_size);
 704         lov_fix_desc_stripe_count(&desc->ld_default_stripe_count);
 705         lov_fix_desc_pattern(&desc->ld_pattern);
 706         lov_fix_desc_qos_maxage(&desc->ld_qos_maxage);
 707 }
 708
 709 int lov_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
 710 {
 711         struct lov_desc *desc;
 712         struct lov_obd *lov = &obd->u.lov;
 713         int rc;
 714         ENTRY;
 715
 716         if (LUSTRE_CFG_BUFLEN(lcfg, 1) < 1) {
 717                 CERROR("LOV setup requires a descriptor\n");
 718                 RETURN(-EINVAL);
 719         }
 720
 721         desc = (struct lov_desc *)lustre_cfg_buf(lcfg, 1);
 722
 723         if (sizeof(*desc) > LUSTRE_CFG_BUFLEN(lcfg, 1)) {
 724                 CERROR("descriptor size wrong: %d > %d\n",
 725                        (int)sizeof(*desc), LUSTRE_CFG_BUFLEN(lcfg, 1));
 726                 RETURN(-EINVAL);
 727         }
 728
 729         if (desc->ld_magic != LOV_DESC_MAGIC) {
 730                 if (desc->ld_magic == __swab32(LOV_DESC_MAGIC)) {
 731                             CDEBUG(D_OTHER, "%s: Swabbing lov desc %p\n",
 732                                    obd->obd_name, desc);
 733                             lustre_swab_lov_desc(desc);
 734                 } else {
 735                         CERROR("%s: Bad lov desc magic: %#x\n",
 736                                obd->obd_name, desc->ld_magic);
 737                         RETURN(-EINVAL);
 738                 }
 739         }
 740
 741         lov_fix_desc(desc);
 742
 743         desc->ld_active_tgt_count = 0;
 744         lov->desc = *desc;
 745         lov->lov_tgt_size = 0;
 746
 747         mutex_init(&lov->lov_lock);
 748         atomic_set(&lov->lov_refcount, 0);
 749         lov->lov_sp_me = LUSTRE_SP_CLI;
 750
 751         init_rwsem(&lov->lov_notify_lock);
 752
 753         INIT_LIST_HEAD(&lov->lov_pool_list);
 754         lov->lov_pool_count = 0;
 755         rc = lov_pool_hash_init(&lov->lov_pools_hash_body);
 756         if (rc)
 757                 GOTO(out, rc);
 758
 759         rc = tgt_pool_init(&lov->lov_packed, 0);
 760         if (rc)
 761                 GOTO(out, rc);
 762
 763         rc = lov_tunables_init(obd);
 764         if (rc)
 765                 GOTO(out, rc);
 766
 767         lov->lov_tgts_kobj = kobject_create_and_add("target_obds",
 768                                                     &obd->obd_kset.kobj);
 769
 770 out:
 771         return rc;
 772 }
 773
 774 static int lov_cleanup(struct obd_device *obd)
 775 {
 776         struct lov_obd *lov = &obd->u.lov;
 777         struct list_head *pos, *tmp;
 778         struct pool_desc *pool;
 779         ENTRY;
 780
 781         if (lov->lov_tgts_kobj) {
 782                 kobject_put(lov->lov_tgts_kobj);
 783                 lov->lov_tgts_kobj = NULL;
 784         }
 785
 786         list_for_each_safe(pos, tmp, &lov->lov_pool_list) {
 787                 pool = list_entry(pos, struct pool_desc, pool_list);
 788                 /* free pool structs */
 789                 CDEBUG(D_INFO, "delete pool %p\n", pool);
 790                 /* In the function below, .hs_keycmp resolves to
 791                  * pool_hashkey_keycmp() */
 792                 /* coverity[overrun-buffer-val] */
 793                 lov_pool_del(obd, pool->pool_name);
 794         }
 795         lov_pool_hash_destroy(&lov->lov_pools_hash_body);
 796         tgt_pool_free(&lov->lov_packed);
 797
 798         lprocfs_obd_cleanup(obd);
 799         if (lov->lov_tgts) {
 800                 int i;
 801                 lov_tgts_getref(obd);
 802                 for (i = 0; i < lov->desc.ld_tgt_count; i++) {
 803                         if (!lov->lov_tgts[i])
 804                                 continue;
 805
 806                         /* Inactive targets may never have connected */
 807                         if (lov->lov_tgts[i]->ltd_active)
 808                                 /* We should never get here - these
 809                                  * should have been removed in the
 810                                  * disconnect. */
 811                                 CERROR("%s: lov tgt %d not cleaned! "
 812                                        "deathrow=%d, lovrc=%d\n",
 813                                        obd->obd_name, i, lov->lov_death_row,
 814                                        atomic_read(&lov->lov_refcount));
 815                         lov_del_target(obd, i, NULL, 0);
 816                 }
 817                 lov_tgts_putref(obd);
 818                 OBD_FREE_PTR_ARRAY(lov->lov_tgts, lov->lov_tgt_size);
 819                 lov->lov_tgt_size = 0;
 820         }
 821
 822         if (lov->lov_cache != NULL) {
 823                 cl_cache_decref(lov->lov_cache);
 824                 lov->lov_cache = NULL;
 825         }
 826
 827         RETURN(0);
 828 }
 829
 830 int lov_process_config_base(struct obd_device *obd, struct lustre_cfg *lcfg,
 831                             u32 *indexp, int *genp)
 832 {
 833         struct obd_uuid obd_uuid;
 834         int cmd;
 835         int rc = 0;
 836
 837         ENTRY;
 838         switch (cmd = lcfg->lcfg_command) {
 839         case LCFG_ADD_MDC:
 840         case LCFG_DEL_MDC:
 841                 break;
 842         case LCFG_LOV_ADD_OBD:
 843         case LCFG_LOV_ADD_INA:
 844         case LCFG_LOV_DEL_OBD: {
 845                 u32 index;
 846                 int gen;
 847
 848                 /* lov_modify_tgts add  0:lov_mdsA  1:ost1_UUID  2:0  3:1 */
 849                 if (LUSTRE_CFG_BUFLEN(lcfg, 1) > sizeof(obd_uuid.uuid))
 850                         GOTO(out, rc = -EINVAL);
 851
 852                 obd_str2uuid(&obd_uuid,  lustre_cfg_buf(lcfg, 1));
 853
 854                 rc = kstrtou32(lustre_cfg_buf(lcfg, 2), 10, indexp);
 855                 if (rc)
 856                         GOTO(out, rc);
 857                 rc = kstrtoint(lustre_cfg_buf(lcfg, 3), 10, genp);
 858                 if (rc)
 859                         GOTO(out, rc);
 860                 index = *indexp;
 861                 gen = *genp;
 862                 if (cmd == LCFG_LOV_ADD_OBD)
 863                         rc = lov_add_target(obd, &obd_uuid, index, gen, 1);
 864                 else if (cmd == LCFG_LOV_ADD_INA)
 865                         rc = lov_add_target(obd, &obd_uuid, index, gen, 0);
 866                 else
 867                         rc = lov_del_target(obd, index, &obd_uuid, gen);
 868
 869                 GOTO(out, rc);
 870         }
 871         case LCFG_PARAM: {
 872                 struct lov_desc *desc = &(obd->u.lov.desc);
 873                 ssize_t count;
 874
 875                 if (!desc)
 876                         GOTO(out, rc = -EINVAL);
 877
 878                 count = class_modify_config(lcfg, PARAM_LOV,
 879                                             &obd->obd_kset.kobj);
 880                 GOTO(out, rc = count < 0 ? count : 0);
 881         }
 882         case LCFG_POOL_NEW:
 883         case LCFG_POOL_ADD:
 884         case LCFG_POOL_DEL:
 885         case LCFG_POOL_REM:
 886                 GOTO(out, rc);
 887
 888         default: {
 889                 CERROR("Unknown command: %d\n", lcfg->lcfg_command);
 890                 GOTO(out, rc = -EINVAL);
 891
 892         }
 893         }
 894 out:
 895         RETURN(rc);
 896 }
 897
 898 static int lov_statfs(const struct lu_env *env, struct obd_export *exp,
 899                       struct obd_statfs *osfs, time64_t max_age, __u32 flags)
 900 {
 901         struct obd_device *obd = class_exp2obd(exp);
 902         struct lov_obd *lov = &obd->u.lov;
 903         struct obd_info oinfo = {
 904                 .oi_osfs = osfs,
 905                 .oi_flags = flags,
 906         };
 907         struct ptlrpc_request_set *rqset;
 908         struct lov_request_set *set = NULL;
 909         struct lov_request *req;
 910         int rc = 0;
 911         int rc2;
 912
 913         ENTRY;
 914
 915         rqset = ptlrpc_prep_set();
 916         if (rqset == NULL)
 917                 RETURN(-ENOMEM);
 918
 919         rc = lov_prep_statfs_set(obd, &oinfo, &set);
 920         if (rc < 0)
 921                 GOTO(out_rqset, rc);
 922
 923         list_for_each_entry(req, &set->set_list, rq_link) {
 924                 rc = obd_statfs_async(lov->lov_tgts[req->rq_idx]->ltd_exp,
 925                                       &req->rq_oi, max_age, rqset);
 926                 if (rc < 0)
 927                         GOTO(out_set, rc);
 928         }
 929
 930         rc = ptlrpc_set_wait(env, rqset);
 931
 932 out_set:
 933         if (rc < 0)
 934                 atomic_set(&set->set_completes, 0);
 935
 936         rc2 = lov_fini_statfs_set(set);
 937         if (rc == 0)
 938                 rc = rc2;
 939
 940 out_rqset:
 941         ptlrpc_set_destroy(rqset);
 942
 943         RETURN(rc);
 944 }
 945
 946 static int lov_iocontrol(unsigned int cmd, struct obd_export *exp, int len,
 947                          void *karg, void __user *uarg)
 948 {
 949         struct obd_device *obd = class_exp2obd(exp);
 950         struct lov_obd *lov = &obd->u.lov;
 951         int i = 0, rc = 0, count = lov->desc.ld_tgt_count;
 952
 953         ENTRY;
 954         switch (cmd) {
 955         case IOC_OBD_STATFS: {
 956                 struct obd_ioctl_data *data = karg;
 957                 struct obd_device *osc_obd;
 958                 struct obd_statfs stat_buf = {0};
 959                 struct obd_import *imp;
 960                 __u32 index;
 961                 __u32 flags;
 962
 963                 memcpy(&index, data->ioc_inlbuf2, sizeof(index));
 964                 if (index >= count)
 965                         RETURN(-ENODEV);
 966
 967                 if (!lov->lov_tgts[index])
 968                         /* Try again with the next index */
 969                         RETURN(-EAGAIN);
 970
 971                 osc_obd = class_exp2obd(lov->lov_tgts[index]->ltd_exp);
 972                 if (!osc_obd)
 973                         RETURN(-EINVAL);
 974
 975                 imp = osc_obd->u.cli.cl_import;
 976                 if (!lov->lov_tgts[index]->ltd_active &&
 977                     imp->imp_state != LUSTRE_IMP_IDLE)
 978                         RETURN(-ENODATA);
 979
 980                 /* copy UUID */
 981                 if (copy_to_user(data->ioc_pbuf2, obd2cli_tgt(osc_obd),
 982                                  min_t(unsigned long, data->ioc_plen2,
 983                                        sizeof(struct obd_uuid))))
 984                         RETURN(-EFAULT);
 985
 986                 memcpy(&flags, data->ioc_inlbuf1, sizeof(flags));
 987                 flags = flags & LL_STATFS_NODELAY ? OBD_STATFS_NODELAY : 0;
 988
 989                 /* got statfs data */
 990                 rc = obd_statfs(NULL, lov->lov_tgts[index]->ltd_exp, &stat_buf,
 991                                 ktime_get_seconds() - OBD_STATFS_CACHE_SECONDS,
 992                                 flags);
 993                 if (rc)
 994                         RETURN(rc);
 995                 if (copy_to_user(data->ioc_pbuf1, &stat_buf,
 996                                  min_t(unsigned long, data->ioc_plen1,
 997                                        sizeof(struct obd_statfs))))
 998                         RETURN(-EFAULT);
 999                 break;
1000         }
1001         case OBD_IOC_QUOTACTL: {
1002                 struct if_quotactl *qctl = karg;
1003                 struct lov_tgt_desc *tgt = NULL;
1004                 struct obd_quotactl *oqctl;
1005
1006                 if (qctl->qc_valid == QC_OSTIDX) {
1007                         if (count <= qctl->qc_idx)
1008                                 RETURN(-EINVAL);
1009
1010                         tgt = lov->lov_tgts[qctl->qc_idx];
1011                         if (!tgt || !tgt->ltd_exp)
1012                                 RETURN(-EINVAL);
1013                 } else if (qctl->qc_valid == QC_UUID) {
1014                         for (i = 0; i < count; i++) {
1015                                 tgt = lov->lov_tgts[i];
1016                                 if (!tgt ||
1017                                     !obd_uuid_equals(&tgt->ltd_uuid,
1018                                                      &qctl->obd_uuid))
1019                                         continue;
1020
1021                                 if (tgt->ltd_exp == NULL)
1022                                         RETURN(-EINVAL);
1023
1024                                 break;
1025                         }
1026                 } else {
1027                         RETURN(-EINVAL);
1028                 }
1029
1030                 if (i >= count)
1031                         RETURN(-EAGAIN);
1032
1033                 LASSERT(tgt && tgt->ltd_exp);
1034                 OBD_ALLOC_PTR(oqctl);
1035                 if (!oqctl)
1036                         RETURN(-ENOMEM);
1037
1038                 QCTL_COPY(oqctl, qctl);
1039                 rc = obd_quotactl(tgt->ltd_exp, oqctl);
1040                 if (rc == 0) {
1041                         QCTL_COPY(qctl, oqctl);
1042                         qctl->qc_valid = QC_OSTIDX;
1043                         qctl->obd_uuid = tgt->ltd_uuid;
1044                 }
1045                 OBD_FREE_PTR(oqctl);
1046                 break;
1047         }
1048         default: {
1049                 int set = 0;
1050
1051                 if (count == 0)
1052                         RETURN(-ENOTTY);
1053
1054                 for (i = 0; i < count; i++) {
1055                         int err;
1056                         struct obd_device *osc_obd;
1057
1058                         /* OST was disconnected */
1059                         if (!lov->lov_tgts[i] || !lov->lov_tgts[i]->ltd_exp)
1060                                 continue;
1061
1062                         /* ll_umount_begin() sets force on lov, pass to osc */
1063                         osc_obd = class_exp2obd(lov->lov_tgts[i]->ltd_exp);
1064                         if (osc_obd)
1065                                 osc_obd->obd_force = obd->obd_force;
1066                         err = obd_iocontrol(cmd, lov->lov_tgts[i]->ltd_exp,
1067                                             len, karg, uarg);
1068                         if (err) {
1069                                 if (lov->lov_tgts[i]->ltd_active) {
1070                                         CDEBUG_LIMIT(err == -ENOTTY ?
1071                                                      D_IOCTL : D_WARNING,
1072                                                      "iocontrol OSC %s on OST idx %d cmd %x: err = %d\n",
1073                                                      lov_uuid2str(lov, i),
1074                                                      i, cmd, err);
1075                                         if (!rc)
1076                                                 rc = err;
1077                                 }
1078                         } else {
1079                                 set = 1;
1080                         }
1081                 }
1082                 if (!set && !rc)
1083                         rc = -EIO;
1084         }
1085         }
1086
1087         RETURN(rc);
1088 }
1089
1090 static int lov_get_info(const struct lu_env *env, struct obd_export *exp,
1091                         __u32 keylen, void *key, __u32 *vallen, void *val)
1092 {
1093         struct obd_device *obd = class_exp2obd(exp);
1094         struct lov_obd *lov = &obd->u.lov;
1095         struct lov_desc *ld = &lov->desc;
1096         int rc = 0;
1097         ENTRY;
1098
1099         if (vallen == NULL || val == NULL)
1100                 RETURN(-EFAULT);
1101
1102         lov_tgts_getref(obd);
1103
1104         if (KEY_IS(KEY_MAX_EASIZE)) {
1105                 *((u32 *)val) = exp->exp_connect_data.ocd_max_easize;
1106         } else if (KEY_IS(KEY_DEFAULT_EASIZE)) {
1107                 u32 def_stripe_count = min_t(u32, ld->ld_default_stripe_count,
1108                                              LOV_MAX_STRIPE_COUNT);
1109
1110                 *((u32 *)val) = lov_mds_md_size(def_stripe_count, LOV_MAGIC_V3);
1111         } else if (KEY_IS(KEY_TGT_COUNT)) {
1112                 *((int *)val) = lov->desc.ld_tgt_count;
1113         } else {
1114                 rc = -EINVAL;
1115         }
1116
1117         lov_tgts_putref(obd);
1118
1119         RETURN(rc);
1120 }
1121
1122 static int lov_set_info_async(const struct lu_env *env, struct obd_export *exp,
1123                               __u32 keylen, void *key,
1124                               __u32 vallen, void *val,
1125                               struct ptlrpc_request_set *set)
1126 {
1127         struct obd_device *obd = class_exp2obd(exp);
1128         struct lov_obd *lov = &obd->u.lov;
1129         struct lov_tgt_desc *tgt;
1130         bool do_inactive = false, no_set = false;
1131         u32 i;
1132         int rc = 0;
1133         int err;
1134
1135         ENTRY;
1136
1137         if (set == NULL) {
1138                 no_set = true;
1139                 set = ptlrpc_prep_set();
1140                 if (!set)
1141                         RETURN(-ENOMEM);
1142         }
1143
1144         lov_tgts_getref(obd);
1145
1146         if (KEY_IS(KEY_CHECKSUM))
1147                 do_inactive = true;
1148
1149         for (i = 0; i < lov->desc.ld_tgt_count; i++) {
1150                 tgt = lov->lov_tgts[i];
1151
1152                 /* OST was disconnected */
1153                 if (tgt == NULL || tgt->ltd_exp == NULL)
1154                         continue;
1155
1156                 /* OST is inactive and we don't want inactive OSCs */
1157                 if (!tgt->ltd_active && !do_inactive)
1158                         continue;
1159
1160                 err = obd_set_info_async(env, tgt->ltd_exp, keylen, key,
1161                                          vallen, val, set);
1162
1163                 if (rc == 0)
1164                         rc = err;
1165         }
1166
1167         /* cycle through MDC target for Data-on-MDT */
1168         for (i = 0; i < LOV_MDC_TGT_MAX; i++) {
1169                 struct obd_device *mdc;
1170
1171                 mdc = lov->lov_mdc_tgts[i].lmtd_mdc;
1172                 if (mdc == NULL)
1173                         continue;
1174
1175                 err = obd_set_info_async(env, mdc->obd_self_export,
1176                                          keylen, key, vallen, val, set);
1177                 if (rc == 0)
1178                         rc = err;
1179         }
1180
1181         lov_tgts_putref(obd);
1182         if (no_set) {
1183                 err = ptlrpc_set_wait(env, set);
1184                 if (rc == 0)
1185                         rc = err;
1186                 ptlrpc_set_destroy(set);
1187         }
1188         RETURN(rc);
1189 }
1190
1191 void lov_stripe_lock(struct lov_stripe_md *md)
1192 __acquires(&md->lsm_lock)
1193 {
1194         LASSERT(md->lsm_lock_owner != current->pid);
1195         spin_lock(&md->lsm_lock);
1196         LASSERT(md->lsm_lock_owner == 0);
1197         md->lsm_lock_owner = current->pid;
1198 }
1199
1200 void lov_stripe_unlock(struct lov_stripe_md *md)
1201 __releases(&md->lsm_lock)
1202 {
1203         LASSERT(md->lsm_lock_owner == current->pid);
1204         md->lsm_lock_owner = 0;
1205         spin_unlock(&md->lsm_lock);
1206 }
1207
1208 static int lov_quotactl(struct obd_device *obd, struct obd_export *exp,
1209                         struct obd_quotactl *oqctl)
1210 {
1211         struct lov_obd *lov = &obd->u.lov;
1212         struct lov_tgt_desc *tgt;
1213         struct pool_desc *pool = NULL;
1214         __u64 curspace = 0;
1215         __u64 bhardlimit = 0;
1216         int i, rc = 0;
1217
1218         ENTRY;
1219         if (oqctl->qc_cmd != Q_GETOQUOTA &&
1220             oqctl->qc_cmd != LUSTRE_Q_SETQUOTA &&
1221             oqctl->qc_cmd != LUSTRE_Q_GETQUOTAPOOL) {
1222                 rc = -EFAULT;
1223                 CERROR("%s: bad quota opc %x for lov obd: rc = %d\n",
1224                        obd->obd_name, oqctl->qc_cmd, rc);
1225                 RETURN(rc);
1226         }
1227
1228         if (oqctl->qc_cmd == LUSTRE_Q_GETQUOTAPOOL) {
1229                 pool = lov_pool_find(obd, oqctl->qc_poolname);
1230                 if (!pool)
1231                         RETURN(-ENOENT);
1232                 /* Set Q_GETOQUOTA back as targets report it's own
1233                  * usage and doesn't care about pools */
1234                 oqctl->qc_cmd = Q_GETOQUOTA;
1235         }
1236
1237         /* for lov tgt */
1238         lov_tgts_getref(obd);
1239         for (i = 0; i < lov->desc.ld_tgt_count; i++) {
1240                 int err;
1241
1242                 tgt = lov->lov_tgts[i];
1243
1244                 if (!tgt)
1245                         continue;
1246
1247                 if (pool &&
1248                     tgt_check_index(tgt->ltd_index, &pool->pool_obds))
1249                         continue;
1250
1251                 if (!tgt->ltd_active || tgt->ltd_reap) {
1252                         if (oqctl->qc_cmd == Q_GETOQUOTA &&
1253                             lov->lov_tgts[i]->ltd_activate) {
1254                                 rc = -ENETDOWN;
1255                                 CERROR("%s: ost %d is inactive: rc = %d\n",
1256                                        obd->obd_name, i, rc);
1257                         } else {
1258                                 CDEBUG(D_HA, "ost %d is inactive\n", i);
1259                         }
1260                         continue;
1261                 }
1262
1263                 err = obd_quotactl(tgt->ltd_exp, oqctl);
1264                 if (err) {
1265                         if (tgt->ltd_active && !rc)
1266                                 rc = err;
1267                         continue;
1268                 }
1269
1270                 if (oqctl->qc_cmd == Q_GETOQUOTA) {
1271                         curspace += oqctl->qc_dqblk.dqb_curspace;
1272                         bhardlimit += oqctl->qc_dqblk.dqb_bhardlimit;
1273                 }
1274         }
1275         lov_tgts_putref(obd);
1276         if (pool)
1277                 lov_pool_putref(pool);
1278
1279         if (oqctl->qc_cmd == Q_GETOQUOTA) {
1280                 oqctl->qc_dqblk.dqb_curspace = curspace;
1281                 oqctl->qc_dqblk.dqb_bhardlimit = bhardlimit;
1282         }
1283         RETURN(rc);
1284 }
1285
1286 static const struct obd_ops lov_obd_ops = {
1287         .o_owner                = THIS_MODULE,
1288         .o_setup                = lov_setup,
1289         .o_cleanup              = lov_cleanup,
1290         .o_connect              = lov_connect,
1291         .o_disconnect           = lov_disconnect,
1292         .o_statfs               = lov_statfs,
1293         .o_iocontrol            = lov_iocontrol,
1294         .o_get_info             = lov_get_info,
1295         .o_set_info_async       = lov_set_info_async,
1296         .o_notify               = lov_notify,
1297         .o_pool_new             = lov_pool_new,
1298         .o_pool_rem             = lov_pool_remove,
1299         .o_pool_add             = lov_pool_add,
1300         .o_pool_del             = lov_pool_del,
1301         .o_quotactl             = lov_quotactl,
1302 };
1303
1304 struct kmem_cache *lov_oinfo_slab;
1305
1306 static int __init lov_init(void)
1307 {
1308         int rc;
1309         ENTRY;
1310
1311         /* print an address of _any_ initialized kernel symbol from this
1312          * module, to allow debugging with gdb that doesn't support data
1313          * symbols from modules.*/
1314         CDEBUG(D_INFO, "Lustre LOV module (%p).\n", &lov_caches);
1315
1316         rc = lu_kmem_init(lov_caches);
1317         if (rc)
1318                 return rc;
1319
1320         lov_oinfo_slab = kmem_cache_create("lov_oinfo",
1321                                            sizeof(struct lov_oinfo), 0,
1322                                            SLAB_HWCACHE_ALIGN, NULL);
1323         if (lov_oinfo_slab == NULL) {
1324                 lu_kmem_fini(lov_caches);
1325                 return -ENOMEM;
1326         }
1327
1328         rc = class_register_type(&lov_obd_ops, NULL, true,
1329                                  LUSTRE_LOV_NAME, &lov_device_type);
1330         if (rc) {
1331                 kmem_cache_destroy(lov_oinfo_slab);
1332                 lu_kmem_fini(lov_caches);
1333         }
1334
1335         RETURN(rc);
1336 }
1337
1338 static void __exit lov_exit(void)
1339 {
1340         class_unregister_type(LUSTRE_LOV_NAME);
1341         kmem_cache_destroy(lov_oinfo_slab);
1342         lu_kmem_fini(lov_caches);
1343 }
1344
1345 MODULE_AUTHOR("OpenSFS, Inc. <http://www.lustre.org/>");
1346 MODULE_DESCRIPTION("Lustre Logical Object Volume");
1347 MODULE_VERSION(LUSTRE_VERSION_STRING);
1348 MODULE_LICENSE("GPL");
1349
1350 module_init(lov_init);
1351 module_exit(lov_exit);