Whamcloud - gitweb
LU-5223 lmv: build master LMV EA dynamically build via readdir
[fs/lustre-release.git] / lustre / lod / lod_lov.c
index 5763ef4..80e96cd 100644 (file)
 /*
  * Copyright  2009 Sun Microsystems, Inc. All rights reserved
  * Use is subject to license terms.
+ *
+ * Copyright (c) 2012, 2013, Intel Corporation.
  */
 /*
  * lustre/lod/lod_lov.c
  *
- * Author: Alex Zhuravlev <alexey.zhuravlev@intel.com> 
+ * Author: Alex Zhuravlev <alexey.zhuravlev@intel.com>
  */
 
-#ifndef EXPORT_SYMTAB
-# define EXPORT_SYMTAB
-#endif
 #define DEBUG_SUBSYSTEM S_MDS
 
 #include <obd_class.h>
-#include <obd_lov.h>
+#include <lustre_lfsck.h>
+#include <lustre_lmv.h>
 
 #include "lod_internal.h"
 
 /*
- * Keep a refcount of lod->lod_osts usage to prevent racing with
+ * Keep a refcount of lod->ltd_tgts usage to prevent racing with
  * addition/deletion. Any function that expects lov_tgts to remain stationary
  * must take a ref.
  *
  * \param lod - is the lod device from which we want to grab a reference
  */
-void lod_getref(struct lod_device *lod)
+void lod_getref(struct lod_tgt_descs *ltd)
 {
-       cfs_down_read(&lod->lod_rw_sem);
-       cfs_mutex_lock(&lod->lod_mutex);
-       lod->lod_refcount++;
-       cfs_mutex_unlock(&lod->lod_mutex);
+       down_read(&ltd->ltd_rw_sem);
+       mutex_lock(&ltd->ltd_mutex);
+       ltd->ltd_refcount++;
+       mutex_unlock(&ltd->ltd_mutex);
 }
 
 /*
@@ -61,57 +61,67 @@ void lod_getref(struct lod_device *lod)
  *
  * \param lod - is the lod device from which we release a reference
  */
-void lod_putref(struct lod_device *lod)
+void lod_putref(struct lod_device *lod, struct lod_tgt_descs *ltd)
 {
-       cfs_mutex_lock(&lod->lod_mutex);
-       lod->lod_refcount--;
-       if (lod->lod_refcount == 0 && lod->lod_death_row) {
-               struct lod_ost_desc *ost_desc, *tmp;
+       mutex_lock(&ltd->ltd_mutex);
+       ltd->ltd_refcount--;
+       if (ltd->ltd_refcount == 0 && ltd->ltd_death_row) {
+               struct lod_tgt_desc *tgt_desc, *tmp;
                int                  idx;
                CFS_LIST_HEAD(kill);
 
-               CDEBUG(D_CONFIG, "destroying %d lod desc\n",
-                      lod->lod_death_row);
+               CDEBUG(D_CONFIG, "destroying %d ltd desc\n",
+                      ltd->ltd_death_row);
 
-               cfs_foreach_bit(lod->lod_ost_bitmap, idx) {
-                       ost_desc = OST_TGT(lod, idx);
-                       LASSERT(ost_desc);
+               cfs_foreach_bit(ltd->ltd_tgt_bitmap, idx) {
+                       tgt_desc = LTD_TGT(ltd, idx);
+                       LASSERT(tgt_desc);
 
-                       if (!ost_desc->ltd_reap)
+                       if (!tgt_desc->ltd_reap)
                                continue;
 
-                       cfs_list_add(&ost_desc->ltd_kill, &kill);
-
-                       lod_ost_pool_remove(&lod->lod_pool_info, idx);
-                       OST_TGT(lod, idx) = NULL;
-                       lod->lod_ostnr--;
-                       cfs_bitmap_clear(lod->lod_ost_bitmap, idx);
-                       if (ost_desc->ltd_active)
-                               lod->lod_desc.ld_active_tgt_count--;
-                       lod->lod_death_row--;
+                       cfs_list_add(&tgt_desc->ltd_kill, &kill);
+                       LTD_TGT(ltd, idx) = NULL;
+                       /*FIXME: only support ost pool for now */
+                       if (ltd == &lod->lod_ost_descs) {
+                               lod_ost_pool_remove(&lod->lod_pool_info, idx);
+                               if (tgt_desc->ltd_active)
+                                       lod->lod_desc.ld_active_tgt_count--;
+                       }
+                       ltd->ltd_tgtnr--;
+                       cfs_bitmap_clear(ltd->ltd_tgt_bitmap, idx);
+                       ltd->ltd_death_row--;
                }
-               cfs_mutex_unlock(&lod->lod_mutex);
-               cfs_up_read(&lod->lod_rw_sem);
+               mutex_unlock(&ltd->ltd_mutex);
+               up_read(&ltd->ltd_rw_sem);
 
-               cfs_list_for_each_entry_safe(ost_desc, tmp, &kill, ltd_kill) {
+               cfs_list_for_each_entry_safe(tgt_desc, tmp, &kill, ltd_kill) {
                        int rc;
-                       cfs_list_del(&ost_desc->ltd_kill);
-                       /* XXX: remove from QoS structures */
-                       /* disconnect from OSP */
-                       rc = obd_disconnect(ost_desc->ltd_exp);
+                       cfs_list_del(&tgt_desc->ltd_kill);
+                       if (ltd == &lod->lod_ost_descs) {
+                               /* remove from QoS structures */
+                               rc = qos_del_tgt(lod, tgt_desc);
+                               if (rc)
+                                       CERROR("%s: qos_del_tgt(%s) failed:"
+                                              "rc = %d\n",
+                                              lod2obd(lod)->obd_name,
+                                             obd_uuid2str(&tgt_desc->ltd_uuid),
+                                              rc);
+                       }
+                       rc = obd_disconnect(tgt_desc->ltd_exp);
                        if (rc)
-                               CERROR("%s: failed to disconnect %s (%d)\n",
+                               CERROR("%s: failed to disconnect %s: rc = %d\n",
                                       lod2obd(lod)->obd_name,
-                                      obd_uuid2str(&ost_desc->ltd_uuid), rc);
-                       OBD_FREE_PTR(ost_desc);
+                                      obd_uuid2str(&tgt_desc->ltd_uuid), rc);
+                       OBD_FREE_PTR(tgt_desc);
                }
        } else {
-               cfs_mutex_unlock(&lod->lod_mutex);
-               cfs_up_read(&lod->lod_rw_sem);
+               mutex_unlock(&ltd->ltd_mutex);
+               up_read(&ltd->ltd_rw_sem);
        }
 }
 
-static int lod_bitmap_resize(struct lod_device *lod, __u32 newsize)
+static int ltd_bitmap_resize(struct lod_tgt_descs *ltd, __u32 newsize)
 {
        cfs_bitmap_t *new_bitmap, *old_bitmap = NULL;
        int           rc = 0;
@@ -119,9 +129,9 @@ static int lod_bitmap_resize(struct lod_device *lod, __u32 newsize)
 
        /* grab write reference on the lod. Relocating the array requires
         * exclusive access */
-       cfs_down_write(&lod->lod_rw_sem);
 
-       if (newsize <= lod->lod_osts_size)
+       down_write(&ltd->ltd_rw_sem);
+       if (newsize <= ltd->ltd_tgts_size)
                /* someone else has already resize the array */
                GOTO(out, rc = 0);
 
@@ -130,24 +140,24 @@ static int lod_bitmap_resize(struct lod_device *lod, __u32 newsize)
        if (!new_bitmap)
                GOTO(out, rc = -ENOMEM);
 
-       if (lod->lod_osts_size > 0) {
+       if (ltd->ltd_tgts_size > 0) {
                /* the bitmap already exists, we need
                 * to copy data from old one */
-               cfs_bitmap_copy(new_bitmap, lod->lod_ost_bitmap);
-               old_bitmap = lod->lod_ost_bitmap;
+               cfs_bitmap_copy(new_bitmap, ltd->ltd_tgt_bitmap);
+               old_bitmap = ltd->ltd_tgt_bitmap;
        }
 
-       lod->lod_osts_size  = newsize;
-       lod->lod_ost_bitmap = new_bitmap;
+       ltd->ltd_tgts_size  = newsize;
+       ltd->ltd_tgt_bitmap = new_bitmap;
 
        if (old_bitmap)
                CFS_FREE_BITMAP(old_bitmap);
 
-       CDEBUG(D_CONFIG, "ost size: %d\n", lod->lod_osts_size);
+       CDEBUG(D_CONFIG, "tgt size: %d\n", ltd->ltd_tgts_size);
 
        EXIT;
 out:
-       cfs_up_write(&lod->lod_rw_sem);
+       up_write(&ltd->ltd_rw_sem);
        return rc;
 }
 
@@ -159,9 +169,12 @@ out:
  * \param osp - is the name of OSP device name about to be added
  * \param index - is the OSP index
  * \param gen - is the generation number
+ * \param tgt_index - is the group of the OSP.
+ * \param type - is the type of device (mdc or osc)
  */
 int lod_add_device(const struct lu_env *env, struct lod_device *lod,
-                  char *osp, unsigned index, unsigned gen, int active)
+                  char *osp, unsigned index, unsigned gen, int tgt_index,
+                  char *type, int active)
 {
        struct obd_connect_data *data = NULL;
        struct obd_export       *exp = NULL;
@@ -169,9 +182,10 @@ int lod_add_device(const struct lu_env *env, struct lod_device *lod,
        struct lu_device        *ldev;
        struct dt_device        *d;
        int                      rc;
-       struct lod_ost_desc     *ost_desc;
-       struct obd_uuid          obd_uuid;
-
+       struct lod_tgt_desc     *tgt_desc;
+       struct lod_tgt_descs    *ltd;
+       struct obd_uuid         obd_uuid;
+       bool                    for_ost;
        ENTRY;
 
        CDEBUG(D_CONFIG, "osp:%s idx:%d gen:%d\n", osp, index, gen);
@@ -199,6 +213,52 @@ int lod_add_device(const struct lu_env *env, struct lod_device *lod,
        data->ocd_version = LUSTRE_VERSION_CODE;
        data->ocd_index = index;
 
+       if (strcmp(LUSTRE_OSC_NAME, type) == 0) {
+               for_ost = true;
+               data->ocd_connect_flags |= OBD_CONNECT_AT |
+                                          OBD_CONNECT_FULL20 |
+                                          OBD_CONNECT_INDEX |
+#ifdef HAVE_LRU_RESIZE_SUPPORT
+                                          OBD_CONNECT_LRU_RESIZE |
+#endif
+                                          OBD_CONNECT_MDS |
+                                          OBD_CONNECT_OSS_CAPA |
+                                          OBD_CONNECT_REQPORTAL |
+                                          OBD_CONNECT_SKIP_ORPHAN |
+                                          OBD_CONNECT_FID |
+                                          OBD_CONNECT_LVB_TYPE |
+                                          OBD_CONNECT_VERSION |
+                                          OBD_CONNECT_PINGLESS |
+                                          OBD_CONNECT_LFSCK;
+
+               data->ocd_group = tgt_index;
+               ltd = &lod->lod_ost_descs;
+       } else {
+               struct obd_import *imp = obd->u.cli.cl_import;
+
+               for_ost = false;
+               data->ocd_ibits_known = MDS_INODELOCK_UPDATE;
+               data->ocd_connect_flags |= OBD_CONNECT_ACL |
+                                          OBD_CONNECT_MDS_CAPA |
+                                          OBD_CONNECT_OSS_CAPA |
+                                          OBD_CONNECT_IBITS |
+                                          OBD_CONNECT_MDS_MDS |
+                                          OBD_CONNECT_FID |
+                                          OBD_CONNECT_AT |
+                                          OBD_CONNECT_FULL20 |
+                                          OBD_CONNECT_LFSCK;
+               /* XXX set MDS-MDS flags, remove this when running this
+                * on client*/
+               data->ocd_connect_flags |= OBD_CONNECT_MDS_MDS;
+               spin_lock(&imp->imp_lock);
+               imp->imp_server_timeout = 1;
+               spin_unlock(&imp->imp_lock);
+               imp->imp_client->cli_request_portal = OUT_PORTAL;
+               CDEBUG(D_OTHER, "%s: Set 'mds' portal and timeout\n",
+                     obd->obd_name);
+               ltd = &lod->lod_mdt_descs;
+       }
+
        rc = obd_connect(env, &exp, obd, &obd->obd_uuid, data, NULL);
        OBD_FREE_PTR(data);
        if (rc) {
@@ -208,88 +268,105 @@ int lod_add_device(const struct lu_env *env, struct lod_device *lod,
        }
 
        LASSERT(obd->obd_lu_dev);
-       LASSERT(obd->obd_lu_dev->ld_site = lod->lod_dt_dev.dd_lu_dev.ld_site);
+       LASSERT(obd->obd_lu_dev->ld_site == lod->lod_dt_dev.dd_lu_dev.ld_site);
 
        ldev = obd->obd_lu_dev;
        d = lu2dt_dev(ldev);
 
        /* Allocate ost descriptor and fill it */
-       OBD_ALLOC_PTR(ost_desc);
-       if (!ost_desc)
+       OBD_ALLOC_PTR(tgt_desc);
+       if (!tgt_desc)
                GOTO(out_conn, rc = -ENOMEM);
 
-       ost_desc->ltd_ost    = d;
-       ost_desc->ltd_exp    = exp;
-       ost_desc->ltd_uuid   = obd->u.cli.cl_target_uuid;
-       ost_desc->ltd_gen    = gen;
-       ost_desc->ltd_index  = index;
-       ost_desc->ltd_active = active;
+       tgt_desc->ltd_tgt    = d;
+       tgt_desc->ltd_exp    = exp;
+       tgt_desc->ltd_uuid   = obd->u.cli.cl_target_uuid;
+       tgt_desc->ltd_gen    = gen;
+       tgt_desc->ltd_index  = index;
+       tgt_desc->ltd_active = active;
 
-       lod_getref(lod);
-       if (index >= lod->lod_osts_size) {
+       lod_getref(ltd);
+       if (index >= ltd->ltd_tgts_size) {
                /* we have to increase the size of the lod_osts array */
                __u32  newsize;
 
-               newsize = max(lod->lod_osts_size, (__u32)2);
+               newsize = max(ltd->ltd_tgts_size, (__u32)2);
                while (newsize < index + 1)
                        newsize = newsize << 1;
 
                /* lod_bitmap_resize() needs lod_rw_sem
                 * which we hold with th reference */
-               lod_putref(lod);
+               lod_putref(lod, ltd);
 
-               rc = lod_bitmap_resize(lod, newsize);
+               rc = ltd_bitmap_resize(ltd, newsize);
                if (rc)
                        GOTO(out_desc, rc);
 
-               lod_getref(lod);
+               lod_getref(ltd);
        }
 
-       cfs_mutex_lock(&lod->lod_mutex);
-       if (cfs_bitmap_check(lod->lod_ost_bitmap, index)) {
+       mutex_lock(&ltd->ltd_mutex);
+       if (cfs_bitmap_check(ltd->ltd_tgt_bitmap, index)) {
                CERROR("%s: device %d is registered already\n", obd->obd_name,
                       index);
                GOTO(out_mutex, rc = -EEXIST);
        }
 
-       if (lod->lod_ost_idx[index / OST_PTRS_PER_BLOCK] == NULL) {
-               OBD_ALLOC_PTR(lod->lod_ost_idx[index / OST_PTRS_PER_BLOCK]);
-               if (lod->lod_ost_idx[index / OST_PTRS_PER_BLOCK] == NULL) {
+       if (ltd->ltd_tgt_idx[index / TGT_PTRS_PER_BLOCK] == NULL) {
+               OBD_ALLOC_PTR(ltd->ltd_tgt_idx[index / TGT_PTRS_PER_BLOCK]);
+               if (ltd->ltd_tgt_idx[index / TGT_PTRS_PER_BLOCK] == NULL) {
                        CERROR("can't allocate index to add %s\n",
                               obd->obd_name);
                        GOTO(out_mutex, rc = -ENOMEM);
                }
        }
 
-       rc = lod_ost_pool_add(&lod->lod_pool_info, index, lod->lod_osts_size);
-       if (rc) {
-               CERROR("%s: can't set up pool, failed with %d\n",
-                      obd->obd_name, rc);
-               GOTO(out_mutex, rc);
-       }
-
-       /* The new OST is now a full citizen */
-       if (index >= lod->lod_desc.ld_tgt_count)
-               lod->lod_desc.ld_tgt_count = index + 1;
-       if (active)
-               lod->lod_desc.ld_active_tgt_count++;
-       OST_TGT(lod, index) = ost_desc;
-       cfs_bitmap_set(lod->lod_ost_bitmap, index);
-       lod->lod_ostnr++;
-       cfs_mutex_unlock(&lod->lod_mutex);
-       lod_putref(lod);
+       if (!strcmp(LUSTRE_OSC_NAME, type)) {
+               /* pool and qos are not supported for MDS stack yet */
+               rc = lod_ost_pool_add(&lod->lod_pool_info, index,
+                                     lod->lod_osts_size);
+               if (rc) {
+                       CERROR("%s: can't set up pool, failed with %d\n",
+                              obd->obd_name, rc);
+                       GOTO(out_mutex, rc);
+               }
 
+               rc = qos_add_tgt(lod, tgt_desc);
+               if (rc) {
+                       CERROR("%s: qos_add_tgt failed with %d\n",
+                               obd->obd_name, rc);
+                       GOTO(out_pool, rc);
+               }
+
+               /* The new OST is now a full citizen */
+               if (index >= lod->lod_desc.ld_tgt_count)
+                       lod->lod_desc.ld_tgt_count = index + 1;
+               if (active)
+                       lod->lod_desc.ld_active_tgt_count++;
+       }
+
+       LTD_TGT(ltd, index) = tgt_desc;
+       cfs_bitmap_set(ltd->ltd_tgt_bitmap, index);
+       ltd->ltd_tgtnr++;
+       mutex_unlock(&ltd->ltd_mutex);
+       lod_putref(lod, ltd);
        if (lod->lod_recovery_completed)
                ldev->ld_ops->ldo_recovery_complete(env, ldev);
 
-       RETURN(0);
+       rc = lfsck_add_target(env, lod->lod_child, d, exp, index, for_ost);
+       if (rc != 0)
+               CERROR("Fail to add LFSCK target: name = %s, type = %s, "
+                      "index = %u, rc = %d\n", osp, type, index, rc);
+
+       RETURN(rc);
 
+out_pool:
        lod_ost_pool_remove(&lod->lod_pool_info, index);
 out_mutex:
-       cfs_mutex_unlock(&lod->lod_mutex);
-       lod_putref(lod);
+       mutex_unlock(&ltd->ltd_mutex);
+       lod_putref(lod, ltd);
 out_desc:
-       OBD_FREE_PTR(ost_desc);
+       OBD_FREE_PTR(tgt_desc);
 out_conn:
        obd_disconnect(exp);
 out_free:
@@ -299,13 +376,41 @@ out_free:
 /*
  * helper function to schedule OST removal from the device table
  */
-static void __lod_del_device(struct lod_device *lod, unsigned idx)
+static void __lod_del_device(const struct lu_env *env, struct lod_device *lod,
+                            struct lod_tgt_descs *ltd, unsigned idx,
+                            bool for_ost)
+{
+       LASSERT(LTD_TGT(ltd, idx));
+
+       lfsck_del_target(env, lod->lod_child, LTD_TGT(ltd, idx)->ltd_tgt,
+                        idx, for_ost);
+
+       if (LTD_TGT(ltd, idx)->ltd_reap == 0) {
+               LTD_TGT(ltd, idx)->ltd_reap = 1;
+               ltd->ltd_death_row++;
+       }
+}
+
+int lod_fini_tgt(const struct lu_env *env, struct lod_device *lod,
+                struct lod_tgt_descs *ltd, bool for_ost)
 {
-       LASSERT(OST_TGT(lod,idx));
-       if (OST_TGT(lod,idx)->ltd_reap == 0) {
-               OST_TGT(lod,idx)->ltd_reap = 1;
-               lod->lod_death_row++;
+       int idx;
+
+       if (ltd->ltd_tgts_size <= 0)
+               return 0;
+       lod_getref(ltd);
+       mutex_lock(&ltd->ltd_mutex);
+       cfs_foreach_bit(ltd->ltd_tgt_bitmap, idx)
+               __lod_del_device(env, lod, ltd, idx, for_ost);
+       mutex_unlock(&ltd->ltd_mutex);
+       lod_putref(lod, ltd);
+       CFS_FREE_BITMAP(ltd->ltd_tgt_bitmap);
+       for (idx = 0; idx < TGT_PTRS; idx++) {
+               if (ltd->ltd_tgt_idx[idx])
+                       OBD_FREE_PTR(ltd->ltd_tgt_idx[idx]);
        }
+       ltd->ltd_tgts_size = 0;
+       return 0;
 }
 
 /*
@@ -322,7 +427,8 @@ static void __lod_del_device(struct lod_device *lod, unsigned idx)
  * \param gen - is the generation number, not used currently
  */
 int lod_del_device(const struct lu_env *env, struct lod_device *lod,
-                  char *osp, unsigned idx, unsigned gen)
+                  struct lod_tgt_descs *ltd, char *osp, unsigned idx,
+                  unsigned gen, bool for_ost)
 {
        struct obd_device *obd;
        int                rc = 0;
@@ -331,7 +437,10 @@ int lod_del_device(const struct lu_env *env, struct lod_device *lod,
 
        CDEBUG(D_CONFIG, "osp:%s idx:%d gen:%d\n", osp, idx, gen);
 
-       obd = class_name2obd(osp);
+       obd_str2uuid(&uuid, osp);
+
+       obd = class_find_client_obd(&uuid, LUSTRE_OSP_NAME,
+                                  &lod->lod_dt_dev.dd_lu_dev.ld_obd->obd_uuid);
        if (obd == NULL) {
                CERROR("can't find %s device\n", osp);
                RETURN(-EINVAL);
@@ -345,36 +454,603 @@ int lod_del_device(const struct lu_env *env, struct lod_device *lod,
 
        obd_str2uuid(&uuid,  osp);
 
-       lod_getref(lod);
-       cfs_mutex_lock(&lod->lod_mutex);
+       lod_getref(ltd);
+       mutex_lock(&ltd->ltd_mutex);
        /* check that the index is allocated in the bitmap */
-       if (!cfs_bitmap_check(lod->lod_ost_bitmap, idx) || !OST_TGT(lod,idx)) {
+       if (!cfs_bitmap_check(ltd->ltd_tgt_bitmap, idx) ||
+           !LTD_TGT(ltd, idx)) {
                CERROR("%s: device %d is not set up\n", obd->obd_name, idx);
                GOTO(out, rc = -EINVAL);
        }
 
        /* check that the UUID matches */
-       if (!obd_uuid_equals(&uuid, &OST_TGT(lod,idx)->ltd_uuid)) {
+       if (!obd_uuid_equals(&uuid, &LTD_TGT(ltd, idx)->ltd_uuid)) {
                CERROR("%s: LOD target UUID %s at index %d does not match %s\n",
-                      obd->obd_name, obd_uuid2str(&OST_TGT(lod,idx)->ltd_uuid),
+                      obd->obd_name, obd_uuid2str(&LTD_TGT(ltd,idx)->ltd_uuid),
                       idx, osp);
                GOTO(out, rc = -EINVAL);
        }
 
-       __lod_del_device(lod, idx);
+       __lod_del_device(env, lod, ltd, idx, for_ost);
        EXIT;
 out:
-       cfs_mutex_unlock(&lod->lod_mutex);
-       lod_putref(lod);
+       mutex_unlock(&ltd->ltd_mutex);
+       lod_putref(lod, ltd);
        return(rc);
 }
 
+int lod_ea_store_resize(struct lod_thread_info *info, int size)
+{
+       int round = size_roundup_power2(size);
+
+       LASSERT(round <=
+               lov_mds_md_size(LOV_MAX_STRIPE_COUNT, LOV_MAGIC_V3));
+       if (info->lti_ea_store) {
+               LASSERT(info->lti_ea_store_size);
+               LASSERT(info->lti_ea_store_size < round);
+               CDEBUG(D_INFO, "EA store size %d is not enough, need %d\n",
+                      info->lti_ea_store_size, round);
+               OBD_FREE_LARGE(info->lti_ea_store, info->lti_ea_store_size);
+               info->lti_ea_store = NULL;
+               info->lti_ea_store_size = 0;
+       }
+
+       OBD_ALLOC_LARGE(info->lti_ea_store, round);
+       if (info->lti_ea_store == NULL)
+               RETURN(-ENOMEM);
+       info->lti_ea_store_size = round;
+       RETURN(0);
+}
+
+/*
+ * generate and write LOV EA for given striped object
+ */
+int lod_generate_and_set_lovea(const struct lu_env *env,
+                              struct lod_object *lo, struct thandle *th)
+{
+       struct lod_thread_info  *info = lod_env_info(env);
+       struct dt_object        *next = dt_object_child(&lo->ldo_obj);
+       const struct lu_fid     *fid  = lu_object_fid(&lo->ldo_obj.do_lu);
+       struct lov_mds_md_v1    *lmm;
+       struct lov_ost_data_v1  *objs;
+       __u32                    magic;
+       int                      i, rc, lmm_size;
+       int                      cplen = 0;
+       ENTRY;
+
+       LASSERT(lo);
+
+       magic = lo->ldo_pool != NULL ? LOV_MAGIC_V3 : LOV_MAGIC_V1;
+       lmm_size = lov_mds_md_size(lo->ldo_stripenr, magic);
+       if (info->lti_ea_store_size < lmm_size) {
+               rc = lod_ea_store_resize(info, lmm_size);
+               if (rc)
+                       RETURN(rc);
+       }
+
+       if (lo->ldo_pattern == 0) /* default striping */
+               lo->ldo_pattern = LOV_PATTERN_RAID0;
+
+       lmm = info->lti_ea_store;
+
+       lmm->lmm_magic = cpu_to_le32(magic);
+       lmm->lmm_pattern = cpu_to_le32(lo->ldo_pattern);
+       fid_to_lmm_oi(fid, &lmm->lmm_oi);
+       if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_BAD_LMMOI))
+               lmm->lmm_oi.oi.oi_id++;
+       lmm_oi_cpu_to_le(&lmm->lmm_oi, &lmm->lmm_oi);
+       lmm->lmm_stripe_size = cpu_to_le32(lo->ldo_stripe_size);
+       lmm->lmm_stripe_count = cpu_to_le16(lo->ldo_stripenr);
+       if (lo->ldo_pattern & LOV_PATTERN_F_RELEASED)
+               lmm->lmm_stripe_count = cpu_to_le16(lo->ldo_released_stripenr);
+       lmm->lmm_layout_gen = 0;
+       if (magic == LOV_MAGIC_V1) {
+               objs = &lmm->lmm_objects[0];
+       } else {
+               struct lov_mds_md_v3 *v3 = (struct lov_mds_md_v3 *) lmm;
+               cplen = strlcpy(v3->lmm_pool_name, lo->ldo_pool,
+                               sizeof(v3->lmm_pool_name));
+               if (cplen >= sizeof(v3->lmm_pool_name))
+                       RETURN(-E2BIG);
+               objs = &v3->lmm_objects[0];
+       }
+
+       for (i = 0; i < lo->ldo_stripenr; i++) {
+               struct lu_fid           *fid    = &info->lti_fid;
+               struct lod_device       *lod;
+               __u32                   index;
+               int                     type    = LU_SEQ_RANGE_OST;
+
+               lod = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
+               LASSERT(lo->ldo_stripe[i]);
+
+               *fid = *lu_object_fid(&lo->ldo_stripe[i]->do_lu);
+               if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_MULTIPLE_REF)) {
+                       if (cfs_fail_val == 0)
+                               cfs_fail_val = fid->f_oid;
+                       else
+                               fid->f_oid = cfs_fail_val;
+               }
+
+               rc = fid_to_ostid(fid, &info->lti_ostid);
+               LASSERT(rc == 0);
+
+               ostid_cpu_to_le(&info->lti_ostid, &objs[i].l_ost_oi);
+               objs[i].l_ost_gen    = cpu_to_le32(0);
+               rc = lod_fld_lookup(env, lod, fid, &index, &type);
+               if (rc < 0) {
+                       CERROR("%s: Can not locate "DFID": rc = %d\n",
+                              lod2obd(lod)->obd_name, PFID(fid), rc);
+                       lod_object_free_striping(env, lo);
+                       RETURN(rc);
+               }
+               objs[i].l_ost_idx = cpu_to_le32(index);
+       }
+
+       info->lti_buf.lb_buf = lmm;
+       info->lti_buf.lb_len = lmm_size;
+       rc = dt_xattr_set(env, next, &info->lti_buf, XATTR_NAME_LOV, 0,
+                         th, BYPASS_CAPA);
+       if (rc < 0)
+               lod_object_free_striping(env, lo);
+
+       RETURN(rc);
+}
+
+int lod_get_ea(const struct lu_env *env, struct lod_object *lo,
+              const char *name)
+{
+       struct lod_thread_info  *info = lod_env_info(env);
+       struct dt_object        *next = dt_object_child(&lo->ldo_obj);
+       int                     rc;
+       ENTRY;
+
+       LASSERT(info);
+
+       if (unlikely(info->lti_ea_store == NULL)) {
+               /* just to enter in allocation block below */
+               rc = -ERANGE;
+       } else {
+repeat:
+               info->lti_buf.lb_buf = info->lti_ea_store;
+               info->lti_buf.lb_len = info->lti_ea_store_size;
+               rc = dt_xattr_get(env, next, &info->lti_buf, name, BYPASS_CAPA);
+       }
+
+       /* if object is not striped or inaccessible */
+       if (rc == -ENODATA || rc == -ENOENT)
+               RETURN(0);
+
+       if (rc == -ERANGE) {
+               /* EA doesn't fit, reallocate new buffer */
+               rc = dt_xattr_get(env, next, &LU_BUF_NULL, name,
+                                 BYPASS_CAPA);
+               if (rc == -ENODATA || rc == -ENOENT)
+                       RETURN(0);
+               else if (rc < 0)
+                       RETURN(rc);
+
+               LASSERT(rc > 0);
+               rc = lod_ea_store_resize(info, rc);
+               if (rc)
+                       RETURN(rc);
+               goto repeat;
+       }
+
+       RETURN(rc);
+}
+
+int lod_store_def_striping(const struct lu_env *env, struct dt_object *dt,
+                          struct thandle *th)
+{
+       struct lod_thread_info  *info = lod_env_info(env);
+       struct lod_object       *lo = lod_dt_obj(dt);
+       struct dt_object        *next = dt_object_child(dt);
+       struct lov_user_md_v3   *v3;
+       int                      rc;
+       ENTRY;
+
+       if (S_ISDIR(dt->do_lu.lo_header->loh_attr))
+               RETURN(-ENOTDIR);
+       /*
+        * store striping defaults into new directory
+        * used to implement defaults inheritance
+        */
+
+       /* probably nothing to inherite */
+       if (lo->ldo_striping_cached == 0)
+               RETURN(0);
+
+       if (LOVEA_DELETE_VALUES(lo->ldo_def_stripe_size, lo->ldo_def_stripenr,
+                               lo->ldo_def_stripe_offset))
+               RETURN(0);
+
+       v3 = info->lti_ea_store;
+       if (info->lti_ea_store_size < sizeof(*v3)) {
+               rc = lod_ea_store_resize(info, sizeof(*v3));
+               if (rc != 0)
+                       RETURN(rc);
+               v3 = info->lti_ea_store;
+       }
+       memset(v3, 0, sizeof(*v3));
+       v3->lmm_magic = cpu_to_le32(LOV_USER_MAGIC_V3);
+       v3->lmm_stripe_count = cpu_to_le16(lo->ldo_def_stripenr);
+       v3->lmm_stripe_offset = cpu_to_le16(lo->ldo_def_stripe_offset);
+       v3->lmm_stripe_size = cpu_to_le32(lo->ldo_def_stripe_size);
+       if (lo->ldo_pool != NULL)
+               strlcpy(v3->lmm_pool_name, lo->ldo_pool,
+                       sizeof(v3->lmm_pool_name));
+       info->lti_buf.lb_buf = v3;
+       info->lti_buf.lb_len = sizeof(*v3);
+       rc = dt_xattr_set(env, next, &info->lti_buf, XATTR_NAME_LOV, 0, th,
+                       BYPASS_CAPA);
+
+       RETURN(rc);
+}
+
+static int validate_lod_and_idx(struct lod_device *md, int idx)
+{
+       if (unlikely(idx >= md->lod_ost_descs.ltd_tgts_size ||
+                    !cfs_bitmap_check(md->lod_ost_bitmap, idx))) {
+               CERROR("%s: bad idx: %d of %d\n", lod2obd(md)->obd_name, idx,
+                      md->lod_ost_descs.ltd_tgts_size);
+               return -EINVAL;
+       }
+
+       if (unlikely(OST_TGT(md, idx) == NULL)) {
+               CERROR("%s: bad lod_tgt_desc for idx: %d\n",
+                      lod2obd(md)->obd_name, idx);
+               return -EINVAL;
+       }
+
+       if (unlikely(OST_TGT(md, idx)->ltd_ost == NULL)) {
+               CERROR("%s: invalid lod device, for idx: %d\n",
+                      lod2obd(md)->obd_name , idx);
+               return -EINVAL;
+       }
+
+       return 0;
+}
+
+/*
+ * allocate array of objects pointers, find/create objects
+ * stripenr and other fields should be initialized by this moment
+ */
+int lod_initialize_objects(const struct lu_env *env, struct lod_object *lo,
+                          struct lov_ost_data_v1 *objs)
+{
+       struct lod_thread_info  *info = lod_env_info(env);
+       struct lod_device       *md;
+       struct lu_object        *o, *n;
+       struct lu_device        *nd;
+       struct dt_object       **stripe;
+       int                      stripe_len;
+       int                      i, idx, rc = 0;
+       ENTRY;
+
+       LASSERT(lo != NULL);
+       md = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
+       LASSERT(lo->ldo_stripe == NULL);
+       LASSERT(lo->ldo_stripenr > 0);
+       LASSERT(lo->ldo_stripe_size > 0);
+
+       stripe_len = lo->ldo_stripenr;
+       OBD_ALLOC(stripe, sizeof(stripe[0]) * stripe_len);
+       if (stripe == NULL)
+               RETURN(-ENOMEM);
+
+       for (i = 0; i < lo->ldo_stripenr; i++) {
+               if (unlikely(lovea_slot_is_dummy(&objs[i])))
+                       continue;
+
+               ostid_le_to_cpu(&objs[i].l_ost_oi, &info->lti_ostid);
+               idx = le32_to_cpu(objs[i].l_ost_idx);
+               rc = ostid_to_fid(&info->lti_fid, &info->lti_ostid, idx);
+               if (rc != 0)
+                       GOTO(out, rc);
+               LASSERTF(fid_is_sane(&info->lti_fid), ""DFID" insane!\n",
+                        PFID(&info->lti_fid));
+               lod_getref(&md->lod_ost_descs);
+
+               rc = validate_lod_and_idx(md, idx);
+               if (unlikely(rc != 0)) {
+                       lod_putref(md, &md->lod_ost_descs);
+                       GOTO(out, rc);
+               }
+
+               nd = &OST_TGT(md,idx)->ltd_ost->dd_lu_dev;
+               lod_putref(md, &md->lod_ost_descs);
+
+               /* In the function below, .hs_keycmp resolves to
+                * u_obj_hop_keycmp() */
+               /* coverity[overrun-buffer-val] */
+               o = lu_object_find_at(env, nd, &info->lti_fid, NULL);
+               if (IS_ERR(o))
+                       GOTO(out, rc = PTR_ERR(o));
+
+               n = lu_object_locate(o->lo_header, nd->ld_type);
+               LASSERT(n);
+
+               stripe[i] = container_of(n, struct dt_object, do_lu);
+       }
+
+out:
+       if (rc != 0) {
+               for (i = 0; i < stripe_len; i++)
+                       if (stripe[i] != NULL)
+                               lu_object_put(env, &stripe[i]->do_lu);
+
+               OBD_FREE(stripe, sizeof(stripe[0]) * stripe_len);
+               lo->ldo_stripenr = 0;
+       } else {
+               lo->ldo_stripe = stripe;
+               lo->ldo_stripes_allocated = stripe_len;
+       }
+
+       RETURN(rc);
+}
+
+/*
+ * Parse striping information stored in lti_ea_store
+ */
+int lod_parse_striping(const struct lu_env *env, struct lod_object *lo,
+                      const struct lu_buf *buf)
+{
+       struct lov_mds_md_v1    *lmm;
+       struct lov_ost_data_v1  *objs;
+       __u32                    magic;
+       __u32                    pattern;
+       int                      rc = 0;
+       ENTRY;
+
+       LASSERT(buf);
+       LASSERT(buf->lb_buf);
+       LASSERT(buf->lb_len);
+
+       lmm = (struct lov_mds_md_v1 *) buf->lb_buf;
+       magic = le32_to_cpu(lmm->lmm_magic);
+       pattern = le32_to_cpu(lmm->lmm_pattern);
+
+       if (magic != LOV_MAGIC_V1 && magic != LOV_MAGIC_V3)
+               GOTO(out, rc = -EINVAL);
+       if (lov_pattern(pattern) != LOV_PATTERN_RAID0)
+               GOTO(out, rc = -EINVAL);
+
+       lo->ldo_pattern = pattern;
+       lo->ldo_stripe_size = le32_to_cpu(lmm->lmm_stripe_size);
+       lo->ldo_layout_gen = le16_to_cpu(lmm->lmm_layout_gen);
+       lo->ldo_stripenr = le16_to_cpu(lmm->lmm_stripe_count);
+       /* released file stripenr fixup. */
+       if (pattern & LOV_PATTERN_F_RELEASED)
+               lo->ldo_stripenr = 0;
+
+       LASSERT(buf->lb_len >= lov_mds_md_size(lo->ldo_stripenr, magic));
+
+       if (magic == LOV_MAGIC_V3) {
+               struct lov_mds_md_v3 *v3 = (struct lov_mds_md_v3 *) lmm;
+               objs = &v3->lmm_objects[0];
+               lod_object_set_pool(lo, v3->lmm_pool_name);
+       } else {
+               objs = &lmm->lmm_objects[0];
+       }
+
+       if (lo->ldo_stripenr > 0)
+               rc = lod_initialize_objects(env, lo, objs);
+
+out:
+       RETURN(rc);
+}
+
+int lod_load_striping_locked(const struct lu_env *env, struct lod_object *lo)
+{
+       struct lod_thread_info  *info = lod_env_info(env);
+       struct lu_buf           *buf  = &info->lti_buf;
+       struct dt_object        *next = dt_object_child(&lo->ldo_obj);
+       int                      rc = 0;
+       ENTRY;
+
+       /* already initialized? */
+       if (lo->ldo_stripe != NULL)
+               GOTO(out, rc = 0);
+
+       if (!dt_object_exists(next))
+               GOTO(out, rc = 0);
+
+       /* Do not load stripe for slaves of striped dir */
+       if (lo->ldo_dir_slave_stripe)
+               GOTO(out, rc = 0);
+
+       if (S_ISREG(lu_object_attr(lod2lu_obj(lo)))) {
+               rc = lod_get_lov_ea(env, lo);
+               if (rc <= 0)
+                       GOTO(out, rc);
+               /*
+                * there is LOV EA (striping information) in this object
+                * let's parse it and create in-core objects for the stripes
+                */
+               buf->lb_buf = info->lti_ea_store;
+               buf->lb_len = info->lti_ea_store_size;
+               rc = lod_parse_striping(env, lo, buf);
+       } else if (S_ISDIR(lu_object_attr(lod2lu_obj(lo)))) {
+               rc = lod_get_lmv_ea(env, lo);
+               if (rc < sizeof(struct lmv_mds_md_v1))
+                       GOTO(out, rc = rc > 0 ? -EINVAL : rc);
+
+               buf->lb_buf = info->lti_ea_store;
+               buf->lb_len = info->lti_ea_store_size;
+               if (rc == sizeof(struct lmv_mds_md_v1)) {
+                       rc = lod_load_lmv_shards(env, lo, buf, true);
+                       if (buf->lb_buf != info->lti_ea_store) {
+                               OBD_FREE_LARGE(info->lti_ea_store,
+                                              info->lti_ea_store_size);
+                               info->lti_ea_store = buf->lb_buf;
+                               info->lti_ea_store_size = buf->lb_len;
+                       }
+
+                       if (rc < 0)
+                               GOTO(out, rc);
+               }
+
+               /*
+                * there is LOV EA (striping information) in this object
+                * let's parse it and create in-core objects for the stripes
+                */
+               rc = lod_parse_dir_striping(env, lo, buf);
+       }
+out:
+       RETURN(rc);
+}
+
+/**
+ * Load and parse striping information, create in-core representation for the
+ * stripes
+ **/
+int lod_load_striping(const struct lu_env *env, struct lod_object *lo)
+{
+       struct dt_object        *next = dt_object_child(&lo->ldo_obj);
+       int                     rc = 0;
+
+       /* currently this code is supposed to be called from declaration
+        * phase only, thus the object is not expected to be locked by caller */
+       dt_write_lock(env, next, 0);
+       rc = lod_load_striping_locked(env, lo);
+       dt_write_unlock(env, next);
+       return rc;
+}
+
+/* verify the striping information for directory */
+int lod_verify_striping(struct lod_device *d, const struct lu_buf *buf,
+                       bool is_from_disk)
+{
+       struct lov_user_md_v1   *lum;
+       struct lov_user_md_v3   *lum3;
+       struct pool_desc        *pool = NULL;
+       __u32                    magic;
+       __u32                    stripe_size;
+       __u16                    stripe_count;
+       __u16                    stripe_offset;
+       size_t                   lum_size;
+       int                      rc = 0;
+       ENTRY;
+
+       lum = buf->lb_buf;
+
+       LASSERT(sizeof(*lum) < sizeof(*lum3));
+
+       if (buf->lb_len < sizeof(*lum)) {
+               CDEBUG(D_IOCTL, "buf len %zd too small for lov_user_md\n",
+                      buf->lb_len);
+               GOTO(out, rc = -EINVAL);
+       }
+
+       magic = le32_to_cpu(lum->lmm_magic);
+       if (magic != LOV_USER_MAGIC_V1 &&
+           magic != LOV_USER_MAGIC_V3 &&
+           magic != LOV_MAGIC_V1_DEF &&
+           magic != LOV_MAGIC_V3_DEF) {
+               CDEBUG(D_IOCTL, "bad userland LOV MAGIC: %#x\n", magic);
+               GOTO(out, rc = -EINVAL);
+       }
+
+       /* the user uses "0" for default stripe pattern normally. */
+       if (!is_from_disk && lum->lmm_pattern == 0)
+               lum->lmm_pattern = cpu_to_le32(LOV_PATTERN_RAID0);
+
+       if (le32_to_cpu(lum->lmm_pattern) != LOV_PATTERN_RAID0) {
+               CDEBUG(D_IOCTL, "bad userland stripe pattern: %#x\n",
+                      le32_to_cpu(lum->lmm_pattern));
+               GOTO(out, rc = -EINVAL);
+       }
+
+       /* 64kB is the largest common page size we see (ia64), and matches the
+        * check in lfs */
+       stripe_size = le32_to_cpu(lum->lmm_stripe_size);
+       if (stripe_size & (LOV_MIN_STRIPE_SIZE - 1)) {
+               CDEBUG(D_IOCTL, "stripe size %u not a multiple of %u\n",
+                      stripe_size, LOV_MIN_STRIPE_SIZE);
+               GOTO(out, rc = -EINVAL);
+       }
+
+       /* an offset of -1 is treated as a "special" valid offset */
+       stripe_offset = le16_to_cpu(lum->lmm_stripe_offset);
+       if (stripe_offset != (typeof(stripe_offset))-1) {
+               /* if offset is not within valid range [0, osts_size) */
+               if (stripe_offset >= d->lod_osts_size) {
+                       CDEBUG(D_IOCTL, "stripe offset %u >= bitmap size %u\n",
+                              stripe_offset, d->lod_osts_size);
+                       GOTO(out, rc = -EINVAL);
+               }
+
+               /* if lmm_stripe_offset is *not* in bitmap */
+               if (!cfs_bitmap_check(d->lod_ost_bitmap, stripe_offset)) {
+                       CDEBUG(D_IOCTL, "stripe offset %u not in bitmap\n",
+                              stripe_offset);
+                       GOTO(out, rc = -EINVAL);
+               }
+       }
+
+       if (magic == LOV_USER_MAGIC_V1 || magic == LOV_MAGIC_V1_DEF)
+               lum_size = offsetof(struct lov_user_md_v1,
+                                   lmm_objects[0]);
+       else if (magic == LOV_USER_MAGIC_V3 || magic == LOV_MAGIC_V3_DEF)
+               lum_size = offsetof(struct lov_user_md_v3,
+                                   lmm_objects[0]);
+       else
+               GOTO(out, rc = -EINVAL);
+
+       stripe_count = le16_to_cpu(lum->lmm_stripe_count);
+       if (buf->lb_len != lum_size) {
+               CDEBUG(D_IOCTL, "invalid buf len %zd for lov_user_md with "
+                      "magic %#x and stripe_count %u\n",
+                      buf->lb_len, magic, stripe_count);
+               GOTO(out, rc = -EINVAL);
+       }
+
+       if (!(magic == LOV_USER_MAGIC_V3 || magic == LOV_MAGIC_V3_DEF))
+               goto out;
+
+       lum3 = buf->lb_buf;
+       if (buf->lb_len < sizeof(*lum3)) {
+               CDEBUG(D_IOCTL, "buf len %zd too small for lov_user_md_v3\n",
+                      buf->lb_len);
+               GOTO(out, rc = -EINVAL);
+       }
+
+       /* In the function below, .hs_keycmp resolves to
+        * pool_hashkey_keycmp() */
+       /* coverity[overrun-buffer-val] */
+       pool = lod_find_pool(d, lum3->lmm_pool_name);
+       if (pool == NULL)
+               goto out;
+
+       if (stripe_offset != (typeof(stripe_offset))-1) {
+               rc = lod_check_index_in_pool(stripe_offset, pool);
+               if (rc < 0)
+                       GOTO(out, rc = -EINVAL);
+       }
+
+       if (is_from_disk && stripe_count > pool_tgt_count(pool)) {
+               CDEBUG(D_IOCTL,
+                      "stripe count %u > # OSTs %u in the pool\n",
+                      stripe_count, pool_tgt_count(pool));
+               GOTO(out, rc = -EINVAL);
+       }
+
+out:
+       if (pool != NULL)
+               lod_pool_putref(pool);
+
+       RETURN(rc);
+}
+
 void lod_fix_desc_stripe_size(__u64 *val)
 {
-       if (*val < PTLRPC_MAX_BRW_SIZE) {
-               LCONSOLE_WARN("Increasing default stripe size to min %u\n",
-                             PTLRPC_MAX_BRW_SIZE);
-               *val = PTLRPC_MAX_BRW_SIZE;
+       if (*val < LOV_MIN_STRIPE_SIZE) {
+               if (*val != 0)
+                       LCONSOLE_INFO("Increasing default stripe size to "
+                                     "minimum value %u\n",
+                                     LOV_DESC_STRIPE_SIZE_DEFAULT);
+               *val = LOV_DESC_STRIPE_SIZE_DEFAULT;
        } else if (*val & (LOV_MIN_STRIPE_SIZE - 1)) {
                *val &= ~(LOV_MIN_STRIPE_SIZE - 1);
                LCONSOLE_WARN("Changing default stripe size to "LPU64" (a "
@@ -402,7 +1078,7 @@ void lod_fix_desc_qos_maxage(__u32 *val)
 {
        /* fix qos_maxage */
        if (*val == 0)
-               *val = QOS_DEFAULT_MAXAGE;
+               *val = LOV_DESC_QOS_MAXAGE_DEFAULT;
 }
 
 void lod_fix_desc(struct lov_desc *desc)
@@ -415,7 +1091,6 @@ void lod_fix_desc(struct lov_desc *desc)
 
 int lod_pools_init(struct lod_device *lod, struct lustre_cfg *lcfg)
 {
-       struct lprocfs_static_vars  lvars = { 0 };
        struct obd_device          *obd;
        struct lov_desc            *desc;
        int                         rc;
@@ -459,7 +1134,7 @@ int lod_pools_init(struct lod_device *lod, struct lustre_cfg *lcfg)
 
        /* Set up allocation policy (QoS and RR) */
        CFS_INIT_LIST_HEAD(&lod->lod_qos.lq_oss_list);
-       cfs_init_rwsem(&lod->lod_qos.lq_rw_sem);
+       init_rwsem(&lod->lod_qos.lq_rw_sem);
        lod->lod_qos.lq_dirty = 1;
        lod->lod_qos.lq_rr.lqr_dirty = 1;
        lod->lod_qos.lq_reset = 1;
@@ -467,11 +1142,6 @@ int lod_pools_init(struct lod_device *lod, struct lustre_cfg *lcfg)
        lod->lod_qos.lq_prio_free = 232;
        /* Default threshold for rr (roughly 17%) */
        lod->lod_qos.lq_threshold_rr = 43;
-       /* Init statfs fields */
-       OBD_ALLOC_PTR(lod->lod_qos.lq_statfs_data);
-       if (NULL == lod->lod_qos.lq_statfs_data)
-               RETURN(-ENOMEM);
-       cfs_waitq_init(&lod->lod_qos.lq_statfs_waitq);
 
        /* Set up OST pool environment */
        lod->lod_pools_hash_body = cfs_hash_create("POOLS", HASH_POOLS_CUR_BITS,
@@ -481,8 +1151,9 @@ int lod_pools_init(struct lod_device *lod, struct lustre_cfg *lcfg)
                                                   CFS_HASH_MAX_THETA,
                                                   &pool_hash_operations,
                                                   CFS_HASH_DEFAULT);
-       if (!lod->lod_pools_hash_body)
-               GOTO(out_statfs, rc = -ENOMEM);
+       if (lod->lod_pools_hash_body == NULL)
+               RETURN(-ENOMEM);
+
        CFS_INIT_LIST_HEAD(&lod->lod_pool_list);
        lod->lod_pool_count = 0;
        rc = lod_ost_pool_init(&lod->lod_pool_info, 0);
@@ -492,50 +1163,13 @@ int lod_pools_init(struct lod_device *lod, struct lustre_cfg *lcfg)
        if (rc)
                GOTO(out_pool_info, rc);
 
-       /* the OST array and bitmap are allocated/grown dynamically as OSTs are
-        * added to the LOD, see lod_add_device() */
-       lod->lod_ost_bitmap = NULL;
-       lod->lod_osts_size  = 0;
-       lod->lod_ostnr      = 0;
-
-       lod->lod_death_row = 0;
-       lod->lod_refcount  = 0;
-
-       lprocfs_lod_init_vars(&lvars);
-       lprocfs_obd_setup(obd, lvars.obd_vars);
-
-#ifdef LPROCFS
-       rc = lprocfs_seq_create(obd->obd_proc_entry, "target_obd",
-                               0444, &lod_proc_target_fops, obd);
-       if (rc) {
-               CWARN("%s: Error adding the target_obd file %d\n",
-                     obd->obd_name, rc);
-               GOTO(out_lproc, rc);
-       }
-       lod->lod_pool_proc_entry = lprocfs_register("pools",
-                                                   obd->obd_proc_entry,
-                                                   NULL, NULL);
-       if (IS_ERR(lod->lod_pool_proc_entry)) {
-               int ret = PTR_ERR(lod->lod_pool_proc_entry);
-               lod->lod_pool_proc_entry = NULL;
-               CWARN("%s: Failed to create pool proc file %d\n",
-                     obd->obd_name, ret);
-               rc = lod_pools_fini(lod);
-               RETURN(ret);
-       }
-#endif
-
        RETURN(0);
 
-out_lproc:
-       lprocfs_obd_cleanup(obd);
-       lod_ost_pool_free(&lod->lod_qos.lq_rr.lqr_pool);
 out_pool_info:
        lod_ost_pool_free(&lod->lod_pool_info);
 out_hash:
        cfs_hash_putref(lod->lod_pools_hash_body);
-out_statfs:
-       OBD_FREE_PTR(lod->lod_qos.lq_statfs_data);
+
        return rc;
 }
 
@@ -550,38 +1184,16 @@ int lod_pools_fini(struct lod_device *lod)
                pool = cfs_list_entry(pos, struct pool_desc, pool_list);
                /* free pool structs */
                CDEBUG(D_INFO, "delete pool %p\n", pool);
+               /* In the function below, .hs_keycmp resolves to
+                * pool_hashkey_keycmp() */
+               /* coverity[overrun-buffer-val] */
                lod_pool_del(obd, pool->pool_name);
        }
 
-       if (lod->lod_osts_size > 0) {
-               int idx;
-               lod_getref(lod);
-               cfs_mutex_lock(&lod->lod_mutex);
-               cfs_foreach_bit(lod->lod_ost_bitmap, idx)
-                       __lod_del_device(lod, idx);
-               cfs_mutex_unlock(&lod->lod_mutex);
-               lod_putref(lod);
-               CFS_FREE_BITMAP(lod->lod_ost_bitmap);
-               for (idx = 0; idx < OST_PTRS; idx++) {
-                       if (lod->lod_ost_idx[idx])
-                               OBD_FREE_PTR(lod->lod_ost_idx[idx]);
-               }
-               lod->lod_osts_size = 0;
-       }
-
        cfs_hash_putref(lod->lod_pools_hash_body);
        lod_ost_pool_free(&(lod->lod_qos.lq_rr.lqr_pool));
        lod_ost_pool_free(&lod->lod_pool_info);
 
-       /* clear pools parent proc entry only after all pools are killed */
-       if (lod->lod_pool_proc_entry) {
-               lprocfs_remove(&lod->lod_pool_proc_entry);
-               lod->lod_pool_proc_entry = NULL;
-       }
-
-       lprocfs_obd_cleanup(obd);
-
-       OBD_FREE_PTR(lod->lod_qos.lq_statfs_data);
        RETURN(0);
 }