Whamcloud - gitweb
LU-8130 lov: convert lo[v|d]_pool to use rhashtable
[fs/lustre-release.git] / lustre / lov / lov_obd.c
index 2a8c855..a66b697 100644 (file)
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -27,7 +23,7 @@
  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  *
- * Copyright (c) 2011, 2013, Intel Corporation.
+ * Copyright (c) 2011, 2017, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
 #define DEBUG_SUBSYSTEM S_LOV
 #include <libcfs/libcfs.h>
 
-#include <obd_support.h>
-#include <lustre_ioctl.h>
-#include <lustre_lib.h>
-#include <lustre_net.h>
-#include <lustre/lustre_idl.h>
+#include <cl_object.h>
 #include <lustre_dlm.h>
+#include <lustre_fid.h>
+#include <uapi/linux/lustre/lustre_ioctl.h>
+#include <lustre_lib.h>
 #include <lustre_mds.h>
-#include <obd_class.h>
+#include <lustre_net.h>
+#include <uapi/linux/lustre/lustre_param.h>
+#include <lustre_swab.h>
 #include <lprocfs_status.h>
-#include <lustre_param.h>
-#include <cl_object.h>
-#include <lustre/ll_fiemap.h>
-#include <lustre_fid.h>
+#include <obd_class.h>
+#include <obd_support.h>
 
 #include "lov_internal.h"
 
 /* Keep a refcount of lov->tgt usage to prevent racing with addition/deletion.
    Any function that expects lov_tgts to remain stationary must take a ref. */
-static void lov_getref(struct obd_device *obd)
+void lov_tgts_getref(struct obd_device *obd)
 {
        struct lov_obd *lov = &obd->u.lov;
 
@@ -70,19 +65,18 @@ static void lov_getref(struct obd_device *obd)
        mutex_lock(&lov->lov_lock);
        atomic_inc(&lov->lov_refcount);
        mutex_unlock(&lov->lov_lock);
-       return;
 }
 
 static void __lov_del_obd(struct obd_device *obd, struct lov_tgt_desc *tgt);
 
-static void lov_putref(struct obd_device *obd)
+void lov_tgts_putref(struct obd_device *obd)
 {
        struct lov_obd *lov = &obd->u.lov;
 
        mutex_lock(&lov->lov_lock);
        /* ok to dec to 0 more than once -- ltd_exp's will be null */
        if (atomic_dec_and_test(&lov->lov_refcount) && lov->lov_death_row) {
-               struct list_head kill = LIST_HEAD_INIT(kill);
+               LIST_HEAD(kill);
                struct lov_tgt_desc *tgt, *n;
                int i;
 
@@ -105,21 +99,21 @@ static void lov_putref(struct obd_device *obd)
 
                list_for_each_entry_safe(tgt, n, &kill, ltd_kill) {
                        list_del(&tgt->ltd_kill);
-                        /* Disconnect */
-                        __lov_del_obd(obd, tgt);
-                }
-        } else {
+                       /* Disconnect */
+                       __lov_del_obd(obd, tgt);
+               }
+       } else {
                mutex_unlock(&lov->lov_lock);
-        }
+       }
 }
 
 static int lov_set_osc_active(struct obd_device *obd, struct obd_uuid *uuid,
-                              enum obd_notify_event ev);
+                             enum obd_notify_event ev);
 static int lov_notify(struct obd_device *obd, struct obd_device *watched,
-                      enum obd_notify_event ev, void *data);
+                     enum obd_notify_event ev);
 
-int lov_connect_obd(struct obd_device *obd, __u32 index, int activate,
-                    struct obd_connect_data *data)
+int lov_connect_osc(struct obd_device *obd, u32 index, int activate,
+                   struct obd_connect_data *data)
 {
        struct lov_obd *lov = &obd->u.lov;
        struct obd_uuid *tgt_uuid;
@@ -151,12 +145,12 @@ int lov_connect_obd(struct obd_device *obd, __u32 index, int activate,
          */
         imp = tgt_obd->u.cli.cl_import;
 
-        if (activate) {
-                tgt_obd->obd_no_recov = 0;
-                /* FIXME this is probably supposed to be
-                   ptlrpc_set_import_active.  Horrible naming. */
-                ptlrpc_activate_import(imp);
-        }
+       if (activate) {
+               tgt_obd->obd_no_recov = 0;
+               /* FIXME this is probably supposed to be
+                  ptlrpc_set_import_active.  Horrible naming. */
+               ptlrpc_activate_import(imp, false);
+       }
 
         rc = obd_register_observer(tgt_obd, obd);
         if (rc) {
@@ -165,15 +159,14 @@ int lov_connect_obd(struct obd_device *obd, __u32 index, int activate,
                 RETURN(rc);
         }
 
+       if (imp->imp_invalid) {
+               CDEBUG(D_CONFIG, "%s: not connecting - administratively disabled\n",
+                      obd_uuid2str(tgt_uuid));
+               RETURN(0);
+       }
 
-        if (imp->imp_invalid) {
-                CDEBUG(D_CONFIG, "not connecting OSC %s; administratively "
-                       "disabled\n", obd_uuid2str(tgt_uuid));
-                RETURN(0);
-        }
-
-        rc = obd_connect(NULL, &lov->lov_tgts[index]->ltd_exp, tgt_obd,
-                         &lov_osc_uuid, data, NULL);
+       rc = obd_connect(NULL, &lov->lov_tgts[index]->ltd_exp, tgt_obd,
+                        &lov_osc_uuid, data, lov->lov_cache);
         if (rc || !lov->lov_tgts[index]->ltd_exp) {
                 CERROR("Target %s connect error %d\n",
                        obd_uuid2str(tgt_uuid), rc);
@@ -185,26 +178,17 @@ int lov_connect_obd(struct obd_device *obd, __u32 index, int activate,
         CDEBUG(D_CONFIG, "Connected tgt idx %d %s (%s) %sactive\n", index,
                obd_uuid2str(tgt_uuid), tgt_obd->obd_name, activate ? "":"in");
 
-       if (lov->targets_proc_entry != NULL) {
-               struct proc_dir_entry *osc_symlink;
-               struct obd_device *osc_obd;
-
-               osc_obd = lov->lov_tgts[index]->ltd_exp->exp_obd;
-
-               LASSERT(osc_obd != NULL);
-               LASSERT(osc_obd->obd_magic == OBD_DEVICE_MAGIC);
-               LASSERT(osc_obd->obd_type->typ_name != NULL);
-
-               osc_symlink = lprocfs_add_symlink(osc_obd->obd_name,
-                                                 lov->targets_proc_entry,
-                                                 "../../../%s/%s",
-                                                 osc_obd->obd_type->typ_name,
-                                                 osc_obd->obd_name);
-               if (osc_symlink == NULL) {
-                       CERROR("cannot register LOV target "
-                              "/proc/fs/lustre/%s/%s/target_obds/%s\n",
-                              obd->obd_type->typ_name, obd->obd_name,
-                              osc_obd->obd_name);
+       if (lov->lov_tgts_kobj) {
+               /* Even if we failed, that's ok */
+               rc = sysfs_create_link(lov->lov_tgts_kobj,
+                                      &tgt_obd->obd_kset.kobj,
+                                      tgt_obd->obd_name);
+               if (rc) {
+                       CERROR("%s: can't register LOV target /sys/fs/lustre/%s/%s/target_obds/%s : rc = %d\n",
+                              obd->obd_name, obd->obd_type->typ_name,
+                              obd->obd_name,
+                              lov->lov_tgts[index]->ltd_exp->exp_obd->obd_name,
+                              rc);
                }
        }
        RETURN(0);
@@ -237,23 +221,19 @@ static int lov_connect(const struct lu_env *env,
         if (data)
                 lov->lov_ocd = *data;
 
-       lov->targets_proc_entry = lprocfs_seq_register("target_obds",
-                                                      obd->obd_proc_entry,
-                                                      NULL, NULL);
-       if (IS_ERR(lov->targets_proc_entry)) {
-               CERROR("%s: cannot register "
-                      "/proc/fs/lustre/%s/%s/target_obds\n",
-                      obd->obd_name, obd->obd_type->typ_name, obd->obd_name);
-               lov->targets_proc_entry = NULL;
+       lov_tgts_getref(obd);
+
+       if (localdata) {
+               lov->lov_cache = localdata;
+               cl_cache_incref(lov->lov_cache);
        }
 
-        obd_getref(obd);
-        for (i = 0; i < lov->desc.ld_tgt_count; i++) {
-                tgt = lov->lov_tgts[i];
-                if (!tgt || obd_uuid_empty(&tgt->ltd_uuid))
-                        continue;
-                /* Flags will be lowest common denominator */
-                rc = lov_connect_obd(obd, i, tgt->ltd_activate, &lov->lov_ocd);
+       for (i = 0; i < lov->desc.ld_tgt_count; i++) {
+               tgt = lov->lov_tgts[i];
+               if (!tgt || obd_uuid_empty(&tgt->ltd_uuid))
+                       continue;
+               /* Flags will be lowest common denominator */
+               rc = lov_connect_osc(obd, i, tgt->ltd_activate, &lov->lov_ocd);
                 if (rc) {
                         CERROR("%s: lov connect tgt %d failed: %d\n",
                                obd->obd_name, i, rc);
@@ -263,16 +243,17 @@ static int lov_connect(const struct lu_env *env,
                 if (!lov->lov_tgts[i]->ltd_exp)
                         continue;
 
-                rc = lov_notify(obd, lov->lov_tgts[i]->ltd_exp->exp_obd,
-                                OBD_NOTIFY_CONNECT, (void *)&i);
+               rc = lov_notify(obd, lov->lov_tgts[i]->ltd_exp->exp_obd,
+                               OBD_NOTIFY_CONNECT);
                 if (rc) {
                         CERROR("%s error sending notify %d\n",
                                obd->obd_name, rc);
                 }
         }
-        obd_putref(obd);
 
-        RETURN(0);
+       lov_tgts_putref(obd);
+
+       RETURN(0);
 }
 
 static int lov_disconnect_obd(struct obd_device *obd, struct lov_tgt_desc *tgt)
@@ -293,6 +274,10 @@ static int lov_disconnect_obd(struct obd_device *obd, struct lov_tgt_desc *tgt)
         }
 
        if (osc_obd) {
+               if (lov->lov_tgts_kobj)
+                       sysfs_remove_link(lov->lov_tgts_kobj,
+                                         osc_obd->obd_name);
+
                /* Pass it on to our clients.
                 * XXX This should be an argument to disconnect,
                 * XXX not a back-door flag on the OBD.  Ah well.
@@ -321,40 +306,39 @@ static int lov_disconnect_obd(struct obd_device *obd, struct lov_tgt_desc *tgt)
 
 static int lov_disconnect(struct obd_export *exp)
 {
-        struct obd_device *obd = class_exp2obd(exp);
-        struct lov_obd *lov = &obd->u.lov;
-        int i, rc;
-        ENTRY;
-
-        if (!lov->lov_tgts)
-                goto out;
-
-        /* Only disconnect the underlying layers on the final disconnect. */
-        lov->lov_connects--;
-        if (lov->lov_connects != 0) {
-                /* why should there be more than 1 connect? */
-                CERROR("disconnect #%d\n", lov->lov_connects);
-                goto out;
-        }
+       struct obd_device *obd = class_exp2obd(exp);
+       struct lov_obd *lov = &obd->u.lov;
+       u32 index;
+       int rc;
 
-        /* Let's hold another reference so lov_del_obd doesn't spin through
-           putref every time */
-        obd_getref(obd);
+       ENTRY;
+       if (!lov->lov_tgts)
+               goto out;
+
+       /* Only disconnect the underlying layers on the final disconnect. */
+       lov->lov_connects--;
+       if (lov->lov_connects != 0) {
+               /* why should there be more than 1 connect? */
+               CWARN("%s: unexpected disconnect #%d\n",
+                     obd->obd_name, lov->lov_connects);
+               goto out;
+       }
 
-        for (i = 0; i < lov->desc.ld_tgt_count; i++) {
-                if (lov->lov_tgts[i] && lov->lov_tgts[i]->ltd_exp) {
-                        /* Disconnection is the last we know about an obd */
-                        lov_del_target(obd, i, 0, lov->lov_tgts[i]->ltd_gen);
-                }
-        }
-        obd_putref(obd);
+       /* hold another ref so lov_del_obd() doesn't spin in putref each time */
+       lov_tgts_getref(obd);
 
-       if (lov->targets_proc_entry != NULL)
-               lprocfs_remove(&lov->targets_proc_entry);
+       for (index = 0; index < lov->desc.ld_tgt_count; index++) {
+               if (lov->lov_tgts[index] && lov->lov_tgts[index]->ltd_exp) {
+                       /* Disconnection is the last we know about an OBD */
+                       lov_del_target(obd, index, NULL,
+                                      lov->lov_tgts[index]->ltd_gen);
+               }
+       }
+       lov_tgts_putref(obd);
 
 out:
-        rc = class_disconnect(exp); /* bz 9811 */
-        RETURN(rc);
+       rc = class_disconnect(exp); /* bz 9811 */
+       RETURN(rc);
 }
 
 /* Error codes:
@@ -375,30 +359,13 @@ static int lov_set_osc_active(struct obd_device *obd, struct obd_uuid *uuid,
         CDEBUG(D_INFO, "Searching in lov %p for uuid %s event(%d)\n",
                lov, uuid->uuid, ev);
 
-       obd_getref(obd);
+       lov_tgts_getref(obd);
        for (index = 0; index < lov->desc.ld_tgt_count; index++) {
                tgt = lov->lov_tgts[index];
                if (!tgt)
                        continue;
-               /*
-                * LU-642, initially inactive OSC could miss the obd_connect,
-                * we make up for it here.
-                */
-               if (ev == OBD_NOTIFY_ACTIVATE && tgt->ltd_exp == NULL &&
-                   obd_uuid_equals(uuid, &tgt->ltd_uuid)) {
-                       struct obd_uuid lov_osc_uuid = {"LOV_OSC_UUID"};
-
-                       obd_connect(NULL, &tgt->ltd_exp, tgt->ltd_obd,
-                                   &lov_osc_uuid, &lov->lov_ocd, NULL);
-               }
-               if (!tgt->ltd_exp)
-                       continue;
-
-                CDEBUG(D_INFO, "lov idx %d is %s conn "LPX64"\n",
-                       index, obd_uuid2str(&tgt->ltd_uuid),
-                       tgt->ltd_exp->exp_handle.h_cookie);
-                if (obd_uuid_equals(uuid, &tgt->ltd_uuid))
-                        break;
+               if (obd_uuid_equals(uuid, &tgt->ltd_uuid))
+                       break;
         }
 
         if (index == lov->desc.ld_tgt_count)
@@ -407,6 +374,21 @@ static int lov_set_osc_active(struct obd_device *obd, struct obd_uuid *uuid,
         if (ev == OBD_NOTIFY_DEACTIVATE || ev == OBD_NOTIFY_ACTIVATE) {
                 activate = (ev == OBD_NOTIFY_ACTIVATE) ? 1 : 0;
 
+               /*
+                * LU-642, initially inactive OSC could miss the obd_connect,
+                * we make up for it here.
+                */
+               if (activate && !tgt->ltd_exp) {
+                       int rc;
+                       struct obd_uuid lov_osc_uuid = {"LOV_OSC_UUID"};
+
+                       rc = obd_connect(NULL, &tgt->ltd_exp, tgt->ltd_obd,
+                                        &lov_osc_uuid, &lov->lov_ocd,
+                                        lov->lov_cache);
+                       if (rc || tgt->ltd_exp == NULL)
+                               GOTO(out, index = rc);
+               }
+
                 if (lov->lov_tgts[index]->ltd_activate == activate) {
                         CDEBUG(D_INFO, "OSC %s already %sactivate!\n",
                                uuid->uuid, activate ? "" : "de");
@@ -441,125 +423,92 @@ static int lov_set_osc_active(struct obd_device *obd, struct obd_uuid *uuid,
                       ev, uuid->uuid);
        }
 
+       if (tgt->ltd_exp)
+               CDEBUG(D_INFO, "%s: lov idx %d conn %llx\n", obd_uuid2str(uuid),
+                      index, tgt->ltd_exp->exp_handle.h_cookie);
+
  out:
-       obd_putref(obd);
+       lov_tgts_putref(obd);
        RETURN(index);
 }
 
 static int lov_notify(struct obd_device *obd, struct obd_device *watched,
-                      enum obd_notify_event ev, void *data)
+                     enum obd_notify_event ev)
 {
-        int rc = 0;
+       int rc = 0;
        struct lov_obd *lov = &obd->u.lov;
-        ENTRY;
+       ENTRY;
 
        down_read(&lov->lov_notify_lock);
-       if (!lov->lov_connects) {
-               up_read(&lov->lov_notify_lock);
-               RETURN(rc);
-       }
-
-        if (ev == OBD_NOTIFY_ACTIVE || ev == OBD_NOTIFY_INACTIVE ||
-            ev == OBD_NOTIFY_ACTIVATE || ev == OBD_NOTIFY_DEACTIVATE) {
-                struct obd_uuid *uuid;
-
-                LASSERT(watched);
+       if (!lov->lov_connects)
+               GOTO(out_notify_lock, rc = 0);
 
-                if (strcmp(watched->obd_type->typ_name, LUSTRE_OSC_NAME)) {
-                       up_read(&lov->lov_notify_lock);
-                        CERROR("unexpected notification of %s %s!\n",
-                               watched->obd_type->typ_name,
-                               watched->obd_name);
-                        RETURN(-EINVAL);
-                }
-                uuid = &watched->u.cli.cl_target_uuid;
-
-                /* Set OSC as active before notifying the observer, so the
-                 * observer can use the OSC normally.
-                 */
-                rc = lov_set_osc_active(obd, uuid, ev);
-                if (rc < 0) {
-                       up_read(&lov->lov_notify_lock);
-                        CERROR("event(%d) of %s failed: %d\n", ev,
-                               obd_uuid2str(uuid), rc);
-                        RETURN(rc);
-                }
-                /* active event should be pass lov target index as data */
-                data = &rc;
-        }
+       if (ev == OBD_NOTIFY_ACTIVE || ev == OBD_NOTIFY_INACTIVE ||
+           ev == OBD_NOTIFY_ACTIVATE || ev == OBD_NOTIFY_DEACTIVATE) {
+               struct obd_uuid *uuid;
 
-        /* Pass the notification up the chain. */
-        if (watched) {
-                rc = obd_notify_observer(obd, watched, ev, data);
-        } else {
-                /* NULL watched means all osc's in the lov (only for syncs) */
-                /* sync event should be send lov idx as data */
-                struct lov_obd *lov = &obd->u.lov;
-                int i, is_sync;
+               LASSERT(watched);
 
-                data = &i;
-                is_sync = (ev == OBD_NOTIFY_SYNC) ||
-                          (ev == OBD_NOTIFY_SYNC_NONBLOCK);
+               if (strcmp(watched->obd_type->typ_name, LUSTRE_OSC_NAME)) {
+                       CERROR("unexpected notification of %s %s\n",
+                              watched->obd_type->typ_name, watched->obd_name);
+                       GOTO(out_notify_lock, rc = -EINVAL);
+               }
 
-                obd_getref(obd);
-                for (i = 0; i < lov->desc.ld_tgt_count; i++) {
-                        if (!lov->lov_tgts[i])
-                                continue;
+               uuid = &watched->u.cli.cl_target_uuid;
 
-                        /* don't send sync event if target not
-                         * connected/activated */
-                        if (is_sync &&  !lov->lov_tgts[i]->ltd_active)
-                                continue;
+               /* Set OSC as active before notifying the observer, so the
+                * observer can use the OSC normally.
+                */
+               rc = lov_set_osc_active(obd, uuid, ev);
+               if (rc < 0) {
+                       CERROR("%s: event %d failed: rc = %d\n", obd->obd_name,
+                              ev, rc);
+                       GOTO(out_notify_lock, rc);
+               }
+       }
 
-                        rc = obd_notify_observer(obd, lov->lov_tgts[i]->ltd_obd,
-                                                 ev, data);
-                        if (rc) {
-                                CERROR("%s: notify %s of %s failed %d\n",
-                                       obd->obd_name,
-                                       obd->obd_observer->obd_name,
-                                       lov->lov_tgts[i]->ltd_obd->obd_name,
-                                       rc);
-                        }
-                }
-                obd_putref(obd);
-        }
+       /* Pass the notification up the chain. */
+       rc = obd_notify_observer(obd, watched, ev);
 
+out_notify_lock:
        up_read(&lov->lov_notify_lock);
-        RETURN(rc);
+
+       RETURN(rc);
 }
 
 static int lov_add_target(struct obd_device *obd, struct obd_uuid *uuidp,
-                          __u32 index, int gen, int active)
+                         u32 index, int gen, int active)
 {
-        struct lov_obd *lov = &obd->u.lov;
-        struct lov_tgt_desc *tgt;
-        struct obd_device *tgt_obd;
-        int rc;
-        ENTRY;
+       struct lov_obd *lov = &obd->u.lov;
+       struct lov_tgt_desc *tgt;
+       struct obd_device *tgt_obd;
+       int rc;
 
-        CDEBUG(D_CONFIG, "uuid:%s idx:%d gen:%d active:%d\n",
-               uuidp->uuid, index, gen, active);
+       ENTRY;
+       CDEBUG(D_CONFIG, "uuid:%s idx:%u gen:%d active:%d\n",
+              uuidp->uuid, index, gen, active);
 
-        if (gen <= 0) {
-                CERROR("request to add OBD %s with invalid generation: %d\n",
-                       uuidp->uuid, gen);
-                RETURN(-EINVAL);
-        }
+       if (gen <= 0) {
+               CERROR("%s: request to add '%s' with invalid generation: %d\n",
+                      obd->obd_name, uuidp->uuid, gen);
+               RETURN(-EINVAL);
+       }
 
-        tgt_obd = class_find_client_obd(uuidp, LUSTRE_OSC_NAME,
-                                        &obd->obd_uuid);
-        if (tgt_obd == NULL)
-                RETURN(-EINVAL);
+       tgt_obd = class_find_client_obd(uuidp, LUSTRE_OSC_NAME, &obd->obd_uuid);
+       if (tgt_obd == NULL)
+               RETURN(-EINVAL);
 
        mutex_lock(&lov->lov_lock);
 
-        if ((index < lov->lov_tgt_size) && (lov->lov_tgts[index] != NULL)) {
-                tgt = lov->lov_tgts[index];
-                CERROR("UUID %s already assigned at LOV target index %d\n",
-                       obd_uuid2str(&tgt->ltd_uuid), index);
+       if ((index < lov->lov_tgt_size) && (lov->lov_tgts[index] != NULL)) {
+               tgt = lov->lov_tgts[index];
+               rc = -EEXIST;
+               CERROR("%s: UUID %s already assigned at index %d: rc = %d\n",
+                      obd->obd_name, obd_uuid2str(&tgt->ltd_uuid), index, rc);
                mutex_unlock(&lov->lov_lock);
-                RETURN(-EEXIST);
-        }
+               RETURN(rc);
+       }
 
         if (index >= lov->lov_tgt_size) {
                 /* We need to reallocate the lov target array. */
@@ -620,18 +569,16 @@ static int lov_add_target(struct obd_device *obd, struct obd_uuid *uuidp,
         CDEBUG(D_CONFIG, "idx=%d ltd_gen=%d ld_tgt_count=%d\n",
                 index, tgt->ltd_gen, lov->desc.ld_tgt_count);
 
-        rc = obd_notify(obd, tgt_obd, OBD_NOTIFY_CREATE, &index);
-
-        if (lov->lov_connects == 0) {
-                /* lov_connect hasn't been called yet. We'll do the
-                   lov_connect_obd on this target when that fn first runs,
-                   because we don't know the connect flags yet. */
-                RETURN(0);
-        }
+       if (lov->lov_connects == 0) {
+               /* lov_connect hasn't been called yet. We'll do the
+                  lov_connect_osc on this target when that fn first runs,
+                  because we don't know the connect flags yet. */
+               RETURN(0);
+       }
 
-        obd_getref(obd);
+       lov_tgts_getref(obd);
 
-        rc = lov_connect_obd(obd, index, active, &lov->lov_ocd);
+       rc = lov_connect_osc(obd, index, active, &lov->lov_ocd);
         if (rc)
                 GOTO(out, rc);
 
@@ -639,31 +586,21 @@ static int lov_add_target(struct obd_device *obd, struct obd_uuid *uuidp,
         if (!tgt->ltd_exp)
                 GOTO(out, rc = 0);
 
-       if (lov->lov_cache != NULL) {
-               rc = obd_set_info_async(NULL, tgt->ltd_exp,
-                               sizeof(KEY_CACHE_SET), KEY_CACHE_SET,
-                               sizeof(struct cl_client_cache), lov->lov_cache,
-                               NULL);
-               if (rc < 0)
-                       GOTO(out, rc);
-       }
-
-        rc = lov_notify(obd, tgt->ltd_exp->exp_obd,
-                        active ? OBD_NOTIFY_CONNECT : OBD_NOTIFY_INACTIVE,
-                        (void *)&index);
+       rc = lov_notify(obd, tgt->ltd_exp->exp_obd,
+                       active ? OBD_NOTIFY_CONNECT : OBD_NOTIFY_INACTIVE);
 
 out:
-        if (rc) {
-                CERROR("add failed (%d), deleting %s\n", rc,
-                       obd_uuid2str(&tgt->ltd_uuid));
-                lov_del_target(obd, index, 0, 0);
-        }
-        obd_putref(obd);
-        RETURN(rc);
+       if (rc) {
+               CERROR("%s: add failed, deleting %s: rc = %d\n",
+                      obd->obd_name, obd_uuid2str(&tgt->ltd_uuid), rc);
+               lov_del_target(obd, index, NULL, 0);
+       }
+       lov_tgts_putref(obd);
+       RETURN(rc);
 }
 
 /* Schedule a target for deletion */
-int lov_del_target(struct obd_device *obd, __u32 index,
+int lov_del_target(struct obd_device *obd, u32 index,
                    struct obd_uuid *uuidp, int gen)
 {
         struct lov_obd *lov = &obd->u.lov;
@@ -679,7 +616,7 @@ int lov_del_target(struct obd_device *obd, __u32 index,
 
        /* to make sure there's no ongoing lov_notify() now */
        down_write(&lov->lov_notify_lock);
-        obd_getref(obd);
+       lov_tgts_getref(obd);
 
         if (!lov->lov_tgts[index]) {
                 CERROR("LOV target at index %d is not setup.\n", index);
@@ -700,12 +637,12 @@ int lov_del_target(struct obd_device *obd, __u32 index,
 
         lov->lov_tgts[index]->ltd_reap = 1;
         lov->lov_death_row++;
-        /* we really delete it from obd_putref */
+       /* we really delete it from lov_tgts_putref() */
 out:
-        obd_putref(obd);
+       lov_tgts_putref(obd);
        up_write(&lov->lov_notify_lock);
 
-        RETURN(rc);
+       RETURN(rc);
 }
 
 static void __lov_del_obd(struct obd_device *obd, struct lov_tgt_desc *tgt)
@@ -743,7 +680,7 @@ void lov_fix_desc_stripe_size(__u64 *val)
                *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 "
+               LCONSOLE_WARN("Changing default stripe size to %llu (a "
                              "multiple of %u)\n",
                              *val, LOV_MIN_STRIPE_SIZE);
        }
@@ -758,10 +695,10 @@ void lov_fix_desc_stripe_count(__u32 *val)
 void lov_fix_desc_pattern(__u32 *val)
 {
         /* from lov_setstripe */
-        if ((*val != 0) && (*val != LOV_PATTERN_RAID0)) {
-                LCONSOLE_WARN("Unknown stripe pattern: %#x\n", *val);
-                *val = 0;
-        }
+       if ((*val != 0) && !lov_pattern_supported_normal_comp(*val)) {
+               LCONSOLE_WARN("lov: Unknown stripe pattern: %#x\n", *val);
+               *val = 0;
+       }
 }
 
 void lov_fix_desc_qos_maxage(__u32 *val)
@@ -772,19 +709,16 @@ void lov_fix_desc_qos_maxage(__u32 *val)
 
 void lov_fix_desc(struct lov_desc *desc)
 {
-        lov_fix_desc_stripe_size(&desc->ld_default_stripe_size);
-        lov_fix_desc_stripe_count(&desc->ld_default_stripe_count);
-        lov_fix_desc_pattern(&desc->ld_pattern);
-        lov_fix_desc_qos_maxage(&desc->ld_qos_maxage);
+       lov_fix_desc_stripe_size(&desc->ld_default_stripe_size);
+       lov_fix_desc_stripe_count(&desc->ld_default_stripe_count);
+       lov_fix_desc_pattern(&desc->ld_pattern);
+       lov_fix_desc_qos_maxage(&desc->ld_qos_maxage);
 }
 
 int lov_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
 {
        struct lov_desc *desc;
        struct lov_obd *lov = &obd->u.lov;
-#ifdef LPROCFS
-       struct obd_type *type;
-#endif
        int rc;
        ENTRY;
 
@@ -825,88 +759,27 @@ int lov_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
 
        init_rwsem(&lov->lov_notify_lock);
 
-        lov->lov_pools_hash_body = cfs_hash_create("POOLS", HASH_POOLS_CUR_BITS,
-                                                   HASH_POOLS_MAX_BITS,
-                                                   HASH_POOLS_BKT_BITS, 0,
-                                                   CFS_HASH_MIN_THETA,
-                                                   CFS_HASH_MAX_THETA,
-                                                   &pool_hash_operations,
-                                                   CFS_HASH_DEFAULT);
        INIT_LIST_HEAD(&lov->lov_pool_list);
         lov->lov_pool_count = 0;
+       rc = lov_pool_hash_init(&lov->lov_pools_hash_body);
+       if (rc)
+               GOTO(out, rc);
+
         rc = lov_ost_pool_init(&lov->lov_packed, 0);
         if (rc)
                GOTO(out, rc);
 
-#ifdef LPROCFS
-       obd->obd_vars = lprocfs_lov_obd_vars;
-       /* If this is true then both client (lov) and server
-        * (lod) are on the same node. The lod layer if loaded
-        * first will register the lov proc directory. In that
-        * case obd->obd_type->typ_procroot will be not set.
-        * Instead we use type->typ_procsym as the parent. */
-       type = class_search_type(LUSTRE_LOD_NAME);
-       if (type != NULL && type->typ_procsym != NULL) {
-               obd->obd_proc_entry = lprocfs_seq_register(obd->obd_name,
-                                                          type->typ_procsym,
-                                                          obd->obd_vars, obd);
-               if (IS_ERR(obd->obd_proc_entry)) {
-                       rc = PTR_ERR(obd->obd_proc_entry);
-                       CERROR("error %d setting up lprocfs for %s\n", rc,
-                              obd->obd_name);
-                       obd->obd_proc_entry = NULL;
-               }
-       } else {
-               rc = lprocfs_obd_setup(obd);
-       }
+       rc = lov_tunables_init(obd);
+       if (rc)
+               GOTO(out, rc);
 
-       if (rc == 0) {
-               rc = lprocfs_seq_create(obd->obd_proc_entry, "target_obd",
-                                       0444, &lov_proc_target_fops, obd);
-               if (rc)
-                       CWARN("Error adding the target_obd file\n");
-
-               lov->lov_pool_proc_entry = lprocfs_seq_register("pools",
-                                                       obd->obd_proc_entry,
-                                                       NULL, NULL);
-               if (IS_ERR(lov->lov_pool_proc_entry)) {
-                       rc = PTR_ERR(lov->lov_pool_proc_entry);
-                       CERROR("error %d setting up lprocfs for pools\n", rc);
-                       lov->lov_pool_proc_entry = NULL;
-               }
-       }
-#endif
-       RETURN(0);
+       lov->lov_tgts_kobj = kobject_create_and_add("target_obds",
+                                                   &obd->obd_kset.kobj);
 
 out:
        return rc;
 }
 
-static int lov_precleanup(struct obd_device *obd, enum obd_cleanup_stage stage)
-{
-        int rc = 0;
-        struct lov_obd *lov = &obd->u.lov;
-
-        ENTRY;
-
-        switch (stage) {
-        case OBD_CLEANUP_EARLY: {
-                int i;
-                for (i = 0; i < lov->desc.ld_tgt_count; i++) {
-                        if (!lov->lov_tgts[i] || !lov->lov_tgts[i]->ltd_active)
-                                continue;
-                        obd_precleanup(class_exp2obd(lov->lov_tgts[i]->ltd_exp),
-                                       OBD_CLEANUP_EARLY);
-                }
-                break;
-       }
-       default:
-               break;
-       }
-
-       RETURN(rc);
-}
-
 static int lov_cleanup(struct obd_device *obd)
 {
         struct lov_obd *lov = &obd->u.lov;
@@ -914,6 +787,11 @@ static int lov_cleanup(struct obd_device *obd)
         struct pool_desc *pool;
         ENTRY;
 
+       if (lov->lov_tgts_kobj) {
+               kobject_put(lov->lov_tgts_kobj);
+               lov->lov_tgts_kobj = NULL;
+       }
+
        list_for_each_safe(pos, tmp, &lov->lov_pool_list) {
                pool = list_entry(pos, struct pool_desc, pool_list);
                 /* free pool structs */
@@ -923,13 +801,13 @@ static int lov_cleanup(struct obd_device *obd)
                /* coverity[overrun-buffer-val] */
                 lov_pool_del(obd, pool->pool_name);
         }
-        cfs_hash_putref(lov->lov_pools_hash_body);
+       lov_pool_hash_destroy(&lov->lov_pools_hash_body);
         lov_ost_pool_free(&lov->lov_packed);
 
        lprocfs_obd_cleanup(obd);
         if (lov->lov_tgts) {
                 int i;
-                obd_getref(obd);
+               lov_tgts_getref(obd);
                 for (i = 0; i < lov->desc.ld_tgt_count; i++) {
                        if (!lov->lov_tgts[i])
                                continue;
@@ -944,61 +822,73 @@ static int lov_cleanup(struct obd_device *obd)
                                       "deathrow=%d, lovrc=%d\n",
                                       obd->obd_name, i, lov->lov_death_row,
                                       atomic_read(&lov->lov_refcount));
-                       lov_del_target(obd, i, 0, 0);
+                       lov_del_target(obd, i, NULL, 0);
                }
-                obd_putref(obd);
+               lov_tgts_putref(obd);
                 OBD_FREE(lov->lov_tgts, sizeof(*lov->lov_tgts) *
                          lov->lov_tgt_size);
                 lov->lov_tgt_size = 0;
         }
+
+       if (lov->lov_cache != NULL) {
+               cl_cache_decref(lov->lov_cache);
+               lov->lov_cache = NULL;
+       }
+
         RETURN(0);
 }
 
 int lov_process_config_base(struct obd_device *obd, struct lustre_cfg *lcfg,
-                            __u32 *indexp, int *genp)
+                           u32 *indexp, int *genp)
 {
-        struct obd_uuid obd_uuid;
-        int cmd;
-        int rc = 0;
-        ENTRY;
+       struct obd_uuid obd_uuid;
+       int cmd;
+       int rc = 0;
 
-        switch(cmd = lcfg->lcfg_command) {
-        case LCFG_LOV_ADD_OBD:
-        case LCFG_LOV_ADD_INA:
-        case LCFG_LOV_DEL_OBD: {
-                __u32 index;
-                int gen;
-                /* lov_modify_tgts add  0:lov_mdsA  1:ost1_UUID  2:0  3:1 */
-                if (LUSTRE_CFG_BUFLEN(lcfg, 1) > sizeof(obd_uuid.uuid))
-                        GOTO(out, rc = -EINVAL);
-
-                obd_str2uuid(&obd_uuid,  lustre_cfg_buf(lcfg, 1));
-
-               if (sscanf(lustre_cfg_buf(lcfg, 2), "%u", indexp) != 1)
-                        GOTO(out, rc = -EINVAL);
-                if (sscanf(lustre_cfg_buf(lcfg, 3), "%d", genp) != 1)
-                        GOTO(out, rc = -EINVAL);
-                index = *indexp;
-                gen = *genp;
-                if (cmd == LCFG_LOV_ADD_OBD)
-                        rc = lov_add_target(obd, &obd_uuid, index, gen, 1);
-                else if (cmd == LCFG_LOV_ADD_INA)
-                        rc = lov_add_target(obd, &obd_uuid, index, gen, 0);
-                else
-                        rc = lov_del_target(obd, index, &obd_uuid, gen);
-                GOTO(out, rc);
-        }
-        case LCFG_PARAM: {
+       ENTRY;
+       switch (cmd = lcfg->lcfg_command) {
+       case LCFG_ADD_MDC:
+       case LCFG_DEL_MDC:
+               break;
+       case LCFG_LOV_ADD_OBD:
+       case LCFG_LOV_ADD_INA:
+       case LCFG_LOV_DEL_OBD: {
+               u32 index;
+               int gen;
+
+               /* lov_modify_tgts add  0:lov_mdsA  1:ost1_UUID  2:0  3:1 */
+               if (LUSTRE_CFG_BUFLEN(lcfg, 1) > sizeof(obd_uuid.uuid))
+                       GOTO(out, rc = -EINVAL);
+
+               obd_str2uuid(&obd_uuid,  lustre_cfg_buf(lcfg, 1));
+
+               rc = kstrtou32(lustre_cfg_buf(lcfg, 2), 10, indexp);
+               if (rc)
+                       GOTO(out, rc);
+               rc = kstrtoint(lustre_cfg_buf(lcfg, 3), 10, genp);
+               if (rc)
+                       GOTO(out, rc);
+               index = *indexp;
+               gen = *genp;
+               if (cmd == LCFG_LOV_ADD_OBD)
+                       rc = lov_add_target(obd, &obd_uuid, index, gen, 1);
+               else if (cmd == LCFG_LOV_ADD_INA)
+                       rc = lov_add_target(obd, &obd_uuid, index, gen, 0);
+               else
+                       rc = lov_del_target(obd, index, &obd_uuid, gen);
+
+               GOTO(out, rc);
+       }
+       case LCFG_PARAM: {
                struct lov_desc *desc = &(obd->u.lov.desc);
+               ssize_t count;
 
                if (!desc)
                        GOTO(out, rc = -EINVAL);
 
-               rc = class_process_proc_param(PARAM_LOV, obd->obd_vars,
-                                             lcfg, obd);
-               if (rc > 0)
-                       rc = 0;
-                GOTO(out, rc);
+               count = class_modify_config(lcfg, PARAM_LOV,
+                                           &obd->obd_kset.kobj);
+               GOTO(out, rc = count < 0 ? count : 0);
         }
         case LCFG_POOL_NEW:
         case LCFG_POOL_ADD:
@@ -1016,373 +906,109 @@ out:
         RETURN(rc);
 }
 
-#define ASSERT_LSM_MAGIC(lsmp)                                                  \
-do {                                                                            \
-        LASSERT((lsmp) != NULL);                                                \
-        LASSERTF(((lsmp)->lsm_magic == LOV_MAGIC_V1 ||                          \
-                 (lsmp)->lsm_magic == LOV_MAGIC_V3),                            \
-                 "%p->lsm_magic=%x\n", (lsmp), (lsmp)->lsm_magic);              \
-} while (0)
-
-static int lov_getattr_interpret(struct ptlrpc_request_set *rqset,
-                                void *data, int rc)
-{
-       struct lov_request_set *lovset = (struct lov_request_set *)data;
-       int err;
-       ENTRY;
-
-       /* don't do attribute merge if this aysnc op failed */
-       if (rc)
-               atomic_set(&lovset->set_completes, 0);
-       err = lov_fini_getattr_set(lovset);
-       RETURN(rc ? rc : err);
-}
-
-static int lov_getattr_async(struct obd_export *exp, struct obd_info *oinfo,
-                              struct ptlrpc_request_set *rqset)
+static int lov_statfs(const struct lu_env *env, struct obd_export *exp,
+                     struct obd_statfs *osfs, time64_t max_age, __u32 flags)
 {
-        struct lov_request_set *lovset;
-        struct lov_obd *lov;
-       struct list_head *pos;
-        struct lov_request *req;
-        int rc = 0, err;
-        ENTRY;
-
-        LASSERT(oinfo);
-        ASSERT_LSM_MAGIC(oinfo->oi_md);
-
-        if (!exp || !exp->exp_obd)
-                RETURN(-ENODEV);
-
-        lov = &exp->exp_obd->u.lov;
-
-        rc = lov_prep_getattr_set(exp, oinfo, &lovset);
-        if (rc)
-                RETURN(rc);
-
-       CDEBUG(D_INFO, "objid "DOSTID": %ux%u byte stripes\n",
-              POSTID(&oinfo->oi_md->lsm_oi), oinfo->oi_md->lsm_stripe_count,
-              oinfo->oi_md->lsm_stripe_size);
-
-       list_for_each(pos, &lovset->set_list) {
-               req = list_entry(pos, struct lov_request, rq_link);
-
-               CDEBUG(D_INFO, "objid "DOSTID"[%d] has subobj "DOSTID" at idx"
-                      "%u\n", POSTID(&oinfo->oi_oa->o_oi), req->rq_stripe,
-                      POSTID(&req->rq_oi.oi_oa->o_oi), req->rq_idx);
-               rc = obd_getattr_async(lov->lov_tgts[req->rq_idx]->ltd_exp,
-                                      &req->rq_oi, rqset);
-               if (rc) {
-                       CERROR("%s: getattr objid "DOSTID" subobj"
-                              DOSTID" on OST idx %d: rc = %d\n",
-                              exp->exp_obd->obd_name,
-                              POSTID(&oinfo->oi_oa->o_oi),
-                              POSTID(&req->rq_oi.oi_oa->o_oi),
-                              req->rq_idx, rc);
-                       GOTO(out, rc);
-               }
-       }
-
-       if (!list_empty(&rqset->set_requests)) {
-                LASSERT(rc == 0);
-                LASSERT (rqset->set_interpret == NULL);
-                rqset->set_interpret = lov_getattr_interpret;
-                rqset->set_arg = (void *)lovset;
-                RETURN(rc);
-        }
-out:
-       if (rc)
-               atomic_set(&lovset->set_completes, 0);
-       err = lov_fini_getattr_set(lovset);
-       RETURN(rc ? rc : err);
-}
+       struct obd_device *obd = class_exp2obd(exp);
+       struct lov_obd *lov = &obd->u.lov;
+       struct obd_info oinfo = {
+               .oi_osfs = osfs,
+               .oi_flags = flags,
+       };
+       struct ptlrpc_request_set *rqset;
+       struct lov_request_set *set = NULL;
+       struct lov_request *req;
+       int rc = 0;
+       int rc2;
 
-static int lov_setattr_interpret(struct ptlrpc_request_set *rqset,
-                                void *data, int rc)
-{
-       struct lov_request_set *lovset = (struct lov_request_set *)data;
-       int err;
        ENTRY;
 
-       if (rc)
-               atomic_set(&lovset->set_completes, 0);
-       err = lov_fini_setattr_set(lovset);
-       RETURN(rc ? rc : err);
-}
-
-/* If @oti is given, the request goes from MDS and responses from OSTs are not
-   needed. Otherwise, a client is waiting for responses. */
-static int lov_setattr_async(struct obd_export *exp, struct obd_info *oinfo,
-                             struct obd_trans_info *oti,
-                             struct ptlrpc_request_set *rqset)
-{
-        struct lov_request_set *set;
-        struct lov_request *req;
-       struct list_head *pos;
-        struct lov_obd *lov;
-        int rc = 0;
-        ENTRY;
-
-        LASSERT(oinfo);
-        ASSERT_LSM_MAGIC(oinfo->oi_md);
-        if (oinfo->oi_oa->o_valid & OBD_MD_FLCOOKIE) {
-                LASSERT(oti);
-                LASSERT(oti->oti_logcookies);
-        }
-
-        if (!exp || !exp->exp_obd)
-                RETURN(-ENODEV);
-
-        lov = &exp->exp_obd->u.lov;
-        rc = lov_prep_setattr_set(exp, oinfo, oti, &set);
-        if (rc)
-                RETURN(rc);
-
-       CDEBUG(D_INFO, "objid "DOSTID": %ux%u byte stripes\n",
-              POSTID(&oinfo->oi_md->lsm_oi),
-              oinfo->oi_md->lsm_stripe_count,
-              oinfo->oi_md->lsm_stripe_size);
-
-       list_for_each(pos, &set->set_list) {
-               req = list_entry(pos, struct lov_request, rq_link);
-
-               if (oinfo->oi_oa->o_valid & OBD_MD_FLCOOKIE)
-                       oti->oti_logcookies = set->set_cookies + req->rq_stripe;
+       rqset = ptlrpc_prep_set();
+       if (rqset == NULL)
+               RETURN(-ENOMEM);
 
-               CDEBUG(D_INFO, "objid "DOSTID"[%d] has subobj "DOSTID" at idx"
-                      "%u\n", POSTID(&oinfo->oi_oa->o_oi), req->rq_stripe,
-                      POSTID(&req->rq_oi.oi_oa->o_oi), req->rq_idx);
+       rc = lov_prep_statfs_set(obd, &oinfo, &set);
+       if (rc < 0)
+               GOTO(out_rqset, rc);
 
-               rc = obd_setattr_async(lov->lov_tgts[req->rq_idx]->ltd_exp,
-                                      &req->rq_oi, oti, rqset);
-               if (rc) {
-                       CERROR("error: setattr objid "DOSTID" subobj"
-                              DOSTID" on OST idx %d: rc = %d\n",
-                              POSTID(&set->set_oi->oi_oa->o_oi),
-                              POSTID(&req->rq_oi.oi_oa->o_oi),
-                              req->rq_idx, rc);
-                       break;
-               }
-       }
-
-       /* If we are not waiting for responses on async requests, return. */
-       if (rc || !rqset || list_empty(&rqset->set_requests)) {
-               int err;
-               if (rc)
-                       atomic_set(&set->set_completes, 0);
-               err = lov_fini_setattr_set(set);
-               RETURN(rc ? rc : err);
+       list_for_each_entry(req, &set->set_list, rq_link) {
+               rc = obd_statfs_async(lov->lov_tgts[req->rq_idx]->ltd_exp,
+                                     &req->rq_oi, max_age, rqset);
+               if (rc < 0)
+                       GOTO(out_set, rc);
        }
 
-       LASSERT(rqset->set_interpret == NULL);
-       rqset->set_interpret = lov_setattr_interpret;
-       rqset->set_arg = (void *)set;
+       rc = ptlrpc_set_wait(env, rqset);
 
-       RETURN(0);
-}
+out_set:
+       if (rc < 0)
+               atomic_set(&set->set_completes, 0);
 
-static int lov_change_cbdata(struct obd_export *exp,
-                             struct lov_stripe_md *lsm, ldlm_iterator_t it,
-                             void *data)
-{
-        struct lov_obd *lov;
-        int rc = 0, i;
-        ENTRY;
+       rc2 = lov_fini_statfs_set(set);
+       if (rc == 0)
+               rc = rc2;
 
-        ASSERT_LSM_MAGIC(lsm);
+out_rqset:
+       ptlrpc_set_destroy(rqset);
 
-        if (!exp || !exp->exp_obd)
-                RETURN(-ENODEV);
-
-        lov = &exp->exp_obd->u.lov;
-        for (i = 0; i < lsm->lsm_stripe_count; i++) {
-                struct lov_stripe_md submd;
-                struct lov_oinfo *loi = lsm->lsm_oinfo[i];
-
-               if (lov_oinfo_is_dummy(loi))
-                       continue;
-
-               if (!lov->lov_tgts[loi->loi_ost_idx]) {
-                       CDEBUG(D_HA, "lov idx %d NULL\n", loi->loi_ost_idx);
-                       continue;
-               }
-
-               submd.lsm_oi = loi->loi_oi;
-               submd.lsm_stripe_count = 0;
-               rc = obd_change_cbdata(lov->lov_tgts[loi->loi_ost_idx]->ltd_exp,
-                                      &submd, it, data);
-       }
        RETURN(rc);
 }
 
-/* find any ldlm lock of the inode in lov
- * return 0    not find
- *        1    find one
- *      < 0    error */
-static int lov_find_cbdata(struct obd_export *exp,
-                           struct lov_stripe_md *lsm, ldlm_iterator_t it,
-                           void *data)
+static int lov_iocontrol(unsigned int cmd, struct obd_export *exp, int len,
+                        void *karg, void __user *uarg)
 {
-        struct lov_obd *lov;
-        int rc = 0, i;
-        ENTRY;
-
-        ASSERT_LSM_MAGIC(lsm);
-
-        if (!exp || !exp->exp_obd)
-                RETURN(-ENODEV);
-
-        lov = &exp->exp_obd->u.lov;
-        for (i = 0; i < lsm->lsm_stripe_count; i++) {
-                struct lov_stripe_md submd;
-                struct lov_oinfo *loi = lsm->lsm_oinfo[i];
-
-               if (lov_oinfo_is_dummy(loi))
-                       continue;
-
-               if (!lov->lov_tgts[loi->loi_ost_idx]) {
-                       CDEBUG(D_HA, "lov idx %d NULL\n", loi->loi_ost_idx);
-                       continue;
-               }
-
-               submd.lsm_oi = loi->loi_oi;
-               submd.lsm_stripe_count = 0;
-               rc = obd_find_cbdata(lov->lov_tgts[loi->loi_ost_idx]->ltd_exp,
-                                    &submd, it, data);
-               if (rc != 0)
-                       RETURN(rc);
-       }
-       RETURN(rc);
-}
+       struct obd_device *obd = class_exp2obd(exp);
+       struct lov_obd *lov = &obd->u.lov;
+       int i = 0, rc = 0, count = lov->desc.ld_tgt_count;
+       struct obd_uuid *uuidp;
 
-int lov_statfs_interpret(struct ptlrpc_request_set *rqset, void *data, int rc)
-{
-       struct lov_request_set *lovset = (struct lov_request_set *)data;
-       int err;
        ENTRY;
+       switch (cmd) {
+       case IOC_OBD_STATFS: {
+               struct obd_ioctl_data *data = karg;
+               struct obd_device *osc_obd;
+               struct obd_statfs stat_buf = {0};
+               struct obd_import *imp;
+               __u32 index;
+               __u32 flags;
 
-       if (rc)
-               atomic_set(&lovset->set_completes, 0);
+               memcpy(&index, data->ioc_inlbuf2, sizeof(index));
+               if (index >= count)
+                       RETURN(-ENODEV);
 
-       err = lov_fini_statfs_set(lovset);
-       RETURN(rc ? rc : err);
-}
+               if (!lov->lov_tgts[index])
+                       /* Try again with the next index */
+                       RETURN(-EAGAIN);
 
-static int lov_statfs_async(struct obd_export *exp, struct obd_info *oinfo,
-                            __u64 max_age, struct ptlrpc_request_set *rqset)
-{
-        struct obd_device      *obd = class_exp2obd(exp);
-        struct lov_request_set *set;
-        struct lov_request *req;
-       struct list_head *pos;
-        struct lov_obd *lov;
-        int rc = 0;
-        ENTRY;
+               osc_obd = class_exp2obd(lov->lov_tgts[index]->ltd_exp);
+               if (!osc_obd)
+                       RETURN(-EINVAL);
 
-        LASSERT(oinfo != NULL);
-        LASSERT(oinfo->oi_osfs != NULL);
+               imp = osc_obd->u.cli.cl_import;
+               if (!lov->lov_tgts[index]->ltd_active &&
+                   imp->imp_state != LUSTRE_IMP_IDLE)
+                       RETURN(-ENODATA);
 
-        lov = &obd->u.lov;
-        rc = lov_prep_statfs_set(obd, oinfo, &set);
-        if (rc)
-                RETURN(rc);
+               /* copy UUID */
+               if (copy_to_user(data->ioc_pbuf2, obd2cli_tgt(osc_obd),
+                                min_t(unsigned long, data->ioc_plen2,
+                                      sizeof(struct obd_uuid))))
+                       RETURN(-EFAULT);
 
-       list_for_each(pos, &set->set_list) {
-               req = list_entry(pos, struct lov_request, rq_link);
-                rc = obd_statfs_async(lov->lov_tgts[req->rq_idx]->ltd_exp,
-                                      &req->rq_oi, max_age, rqset);
-                if (rc)
-                        break;
-        }
+               memcpy(&flags, data->ioc_inlbuf1, sizeof(flags));
+               flags = flags & LL_STATFS_NODELAY ? OBD_STATFS_NODELAY : 0;
 
-       if (rc || list_empty(&rqset->set_requests)) {
-               int err;
+               /* got statfs data */
+               rc = obd_statfs(NULL, lov->lov_tgts[index]->ltd_exp, &stat_buf,
+                               ktime_get_seconds() - OBD_STATFS_CACHE_SECONDS,
+                               flags);
                if (rc)
-                       atomic_set(&set->set_completes, 0);
-               err = lov_fini_statfs_set(set);
-               RETURN(rc ? rc : err);
-       }
-
-       LASSERT(rqset->set_interpret == NULL);
-       rqset->set_interpret = lov_statfs_interpret;
-       rqset->set_arg = (void *)set;
-       RETURN(0);
-}
-
-static int lov_statfs(const struct lu_env *env, struct obd_export *exp,
-                      struct obd_statfs *osfs, __u64 max_age, __u32 flags)
-{
-        struct ptlrpc_request_set *set = NULL;
-        struct obd_info oinfo = { { { 0 } } };
-        int rc = 0;
-        ENTRY;
-
-
-        /* for obdclass we forbid using obd_statfs_rqset, but prefer using async
-         * statfs requests */
-        set = ptlrpc_prep_set();
-        if (set == NULL)
-                RETURN(-ENOMEM);
-
-        oinfo.oi_osfs = osfs;
-        oinfo.oi_flags = flags;
-        rc = lov_statfs_async(exp, &oinfo, max_age, set);
-        if (rc == 0)
-                rc = ptlrpc_set_wait(set);
-        ptlrpc_set_destroy(set);
-
-        RETURN(rc);
-}
-
-static int lov_iocontrol(unsigned int cmd, struct obd_export *exp, int len,
-                        void *karg, void __user *uarg)
-{
-        struct obd_device *obddev = class_exp2obd(exp);
-        struct lov_obd *lov = &obddev->u.lov;
-        int i = 0, rc = 0, count = lov->desc.ld_tgt_count;
-        struct obd_uuid *uuidp;
-        ENTRY;
-
-        switch (cmd) {
-        case IOC_OBD_STATFS: {
-                struct obd_ioctl_data *data = karg;
-                struct obd_device *osc_obd;
-                struct obd_statfs stat_buf = {0};
-                __u32 index;
-               __u32 flags;
-
-                memcpy(&index, data->ioc_inlbuf2, sizeof(__u32));
-                if ((index >= count))
-                        RETURN(-ENODEV);
-
-                if (!lov->lov_tgts[index])
-                        /* Try again with the next index */
-                        RETURN(-EAGAIN);
-                if (!lov->lov_tgts[index]->ltd_active)
-                        RETURN(-ENODATA);
-
-                osc_obd = class_exp2obd(lov->lov_tgts[index]->ltd_exp);
-                if (!osc_obd)
-                        RETURN(-EINVAL);
-
-                /* copy UUID */
-               if (copy_to_user(data->ioc_pbuf2, obd2cli_tgt(osc_obd),
-                                min((int)data->ioc_plen2,
-                                    (int)sizeof(struct obd_uuid))))
-                        RETURN(-EFAULT);
-
-               flags = uarg ? *(__u32 __user *)uarg : 0;
-                /* got statfs data */
-                rc = obd_statfs(NULL, lov->lov_tgts[index]->ltd_exp, &stat_buf,
-                                cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
-                                flags);
-                if (rc)
-                        RETURN(rc);
+                       RETURN(rc);
                if (copy_to_user(data->ioc_pbuf1, &stat_buf,
-                                     min((int) data->ioc_plen1,
-                                         (int) sizeof(stat_buf))))
-                        RETURN(-EFAULT);
-                break;
+                                min_t(unsigned long, data->ioc_plen1,
+                                      sizeof(struct obd_statfs))))
+                       RETURN(-EFAULT);
+               break;
         }
         case OBD_IOC_LOV_GET_CONFIG: {
                 struct obd_ioctl_data *data;
@@ -1397,17 +1023,17 @@ static int lov_iocontrol(unsigned int cmd, struct obd_export *exp, int len,
                 data = (struct obd_ioctl_data *)buf;
 
                 if (sizeof(*desc) > data->ioc_inllen1) {
-                        obd_ioctl_freedata(buf, len);
+                       OBD_FREE_LARGE(buf, len);
                         RETURN(-EINVAL);
                 }
 
                 if (sizeof(uuidp->uuid) * count > data->ioc_inllen2) {
-                        obd_ioctl_freedata(buf, len);
+                       OBD_FREE_LARGE(buf, len);
                         RETURN(-EINVAL);
                 }
 
                 if (sizeof(__u32) * count > data->ioc_inllen3) {
-                        obd_ioctl_freedata(buf, len);
+                       OBD_FREE_LARGE(buf, len);
                         RETURN(-EINVAL);
                 }
 
@@ -1426,7 +1052,7 @@ static int lov_iocontrol(unsigned int cmd, struct obd_export *exp, int len,
 
                if (copy_to_user(uarg, buf, len))
                         rc = -EFAULT;
-                obd_ioctl_freedata(buf, len);
+               OBD_FREE_LARGE(buf, len);
                 break;
         }
         case OBD_IOC_QUOTACTL: {
@@ -1490,15 +1116,12 @@ static int lov_iocontrol(unsigned int cmd, struct obd_export *exp, int len,
                         if (!lov->lov_tgts[i] || !lov->lov_tgts[i]->ltd_exp)
                                 continue;
 
-                        /* ll_umount_begin() sets force flag but for lov, not
-                         * osc. Let's pass it through */
-                        osc_obd = class_exp2obd(lov->lov_tgts[i]->ltd_exp);
-                        osc_obd->obd_force = obddev->obd_force;
-                        err = obd_iocontrol(cmd, lov->lov_tgts[i]->ltd_exp,
-                                            len, karg, uarg);
-                        if (err == -ENODATA && cmd == OBD_IOC_POLL_QUOTACHECK) {
-                                RETURN(err);
-                        } else if (err) {
+                       /* ll_umount_begin() sets force on lov, pass to osc */
+                       osc_obd = class_exp2obd(lov->lov_tgts[i]->ltd_exp);
+                       osc_obd->obd_force = obd->obd_force;
+                       err = obd_iocontrol(cmd, lov->lov_tgts[i]->ltd_exp,
+                                           len, karg, uarg);
+                       if (err) {
                                 if (lov->lov_tgts[i]->ltd_active) {
                                         CDEBUG(err == -ENOTTY ?
                                                D_IOCTL : D_WARNING,
@@ -1521,493 +1144,105 @@ static int lov_iocontrol(unsigned int cmd, struct obd_export *exp, int len,
         RETURN(rc);
 }
 
-#define FIEMAP_BUFFER_SIZE 4096
-
-/**
- * Non-zero fe_logical indicates that this is a continuation FIEMAP
- * call. The local end offset and the device are sent in the first
- * fm_extent. This function calculates the stripe number from the index.
- * This function returns a stripe_no on which mapping is to be restarted.
- *
- * This function returns fm_end_offset which is the in-OST offset at which
- * mapping should be restarted. If fm_end_offset=0 is returned then caller
- * will re-calculate proper offset in next stripe.
- * Note that the first extent is passed to lov_get_info via the value field.
- *
- * \param fiemap fiemap request header
- * \param lsm striping information for the file
- * \param fm_start logical start of mapping
- * \param fm_end logical end of mapping
- * \param start_stripe starting stripe will be returned in this
- */
-static obd_size fiemap_calc_fm_end_offset(struct ll_user_fiemap *fiemap,
-                                         struct lov_stripe_md *lsm,
-                                         obd_size fm_start,
-                                         obd_size fm_end, int *start_stripe)
-{
-        obd_size local_end = fiemap->fm_extents[0].fe_logical;
-        obd_off lun_start, lun_end;
-        obd_size fm_end_offset;
-        int stripe_no = -1, i;
-
-        if (fiemap->fm_extent_count == 0 ||
-            fiemap->fm_extents[0].fe_logical == 0)
-                return 0;
-
-       /* Find out stripe_no from ost_index saved in the fe_device */
-       for (i = 0; i < lsm->lsm_stripe_count; i++) {
-               struct lov_oinfo *oinfo = lsm->lsm_oinfo[i];
-
-               if (lov_oinfo_is_dummy(oinfo))
-                       continue;
-
-               if (oinfo->loi_ost_idx == fiemap->fm_extents[0].fe_device) {
-                       stripe_no = i;
-                       break;
-               }
-       }
-
-       if (stripe_no == -1)
-               return -EINVAL;
-
-        /* If we have finished mapping on previous device, shift logical
-         * offset to start of next device */
-        if ((lov_stripe_intersects(lsm, stripe_no, fm_start, fm_end,
-                                   &lun_start, &lun_end)) != 0 &&
-                                   local_end < lun_end) {
-                fm_end_offset = local_end;
-                *start_stripe = stripe_no;
-        } else {
-                /* This is a special value to indicate that caller should
-                 * calculate offset in next stripe. */
-                fm_end_offset = 0;
-                *start_stripe = (stripe_no + 1) % lsm->lsm_stripe_count;
-        }
-
-        return fm_end_offset;
-}
-
-/**
- * We calculate on which OST the mapping will end. If the length of mapping
- * is greater than (stripe_size * stripe_count) then the last_stripe will
- * will be one just before start_stripe. Else we check if the mapping
- * intersects each OST and find last_stripe.
- * This function returns the last_stripe and also sets the stripe_count
- * over which the mapping is spread
- *
- * \param lsm striping information for the file
- * \param fm_start logical start of mapping
- * \param fm_end logical end of mapping
- * \param start_stripe starting stripe of the mapping
- * \param stripe_count the number of stripes across which to map is returned
- *
- * \retval last_stripe return the last stripe of the mapping
- */
-static int fiemap_calc_last_stripe(struct lov_stripe_md *lsm, obd_size fm_start,
-                                  obd_size fm_end, int start_stripe,
-                                  int *stripe_count)
-{
-        int last_stripe;
-        obd_off obd_start, obd_end;
-        int i, j;
-
-        if (fm_end - fm_start > lsm->lsm_stripe_size * lsm->lsm_stripe_count) {
-                last_stripe = (start_stripe < 1 ? lsm->lsm_stripe_count - 1 :
-                                                              start_stripe - 1);
-                *stripe_count = lsm->lsm_stripe_count;
-        } else {
-                for (j = 0, i = start_stripe; j < lsm->lsm_stripe_count;
-                     i = (i + 1) % lsm->lsm_stripe_count, j++) {
-                        if ((lov_stripe_intersects(lsm, i, fm_start, fm_end,
-                                                   &obd_start, &obd_end)) == 0)
-                                break;
-                }
-                *stripe_count = j;
-                last_stripe = (start_stripe + j - 1) %lsm->lsm_stripe_count;
-        }
-
-        return last_stripe;
-}
-
-/**
- * Set fe_device and copy extents from local buffer into main return buffer.
- *
- * \param fiemap fiemap request header
- * \param lcl_fm_ext array of local fiemap extents to be copied
- * \param ost_index OST index to be written into the fm_device field for each
-                    extent
- * \param ext_count number of extents to be copied
- * \param current_extent where to start copying in main extent array
- */
-static void fiemap_prepare_and_copy_exts(struct ll_user_fiemap *fiemap,
-                                        struct ll_fiemap_extent *lcl_fm_ext,
-                                        int ost_index, unsigned int ext_count,
-                                        int current_extent)
+static int lov_get_info(const struct lu_env *env, struct obd_export *exp,
+                       __u32 keylen, void *key, __u32 *vallen, void *val)
 {
-        char *to;
-        int ext;
+       struct obd_device *obddev = class_exp2obd(exp);
+       struct lov_obd *lov = &obddev->u.lov;
+       struct lov_desc *ld = &lov->desc;
+       int rc = 0;
+       ENTRY;
 
-        for (ext = 0; ext < ext_count; ext++) {
-                lcl_fm_ext[ext].fe_device = ost_index;
-                lcl_fm_ext[ext].fe_flags |= FIEMAP_EXTENT_NET;
-        }
+       if (vallen == NULL || val == NULL)
+               RETURN(-EFAULT);
 
-        /* Copy fm_extent's from fm_local to return buffer */
-        to = (char *)fiemap + fiemap_count_to_size(current_extent);
-        memcpy(to, lcl_fm_ext, ext_count * sizeof(struct ll_fiemap_extent));
-}
+       lov_tgts_getref(obddev);
 
-/**
- * Break down the FIEMAP request and send appropriate calls to individual OSTs.
- * This also handles the restarting of FIEMAP calls in case mapping overflows
- * the available number of extents in single call.
- */
-static int lov_fiemap(struct lov_obd *lov, __u32 keylen, void *key,
-                      __u32 *vallen, void *val, struct lov_stripe_md *lsm)
-{
-        struct ll_fiemap_info_key *fm_key = key;
-        struct ll_user_fiemap *fiemap = val;
-        struct ll_user_fiemap *fm_local = NULL;
-        struct ll_fiemap_extent *lcl_fm_ext;
-        int count_local;
-        unsigned int get_num_extents = 0;
-        int ost_index = 0, actual_start_stripe, start_stripe;
-       obd_size fm_start, fm_end, fm_length, fm_end_offset;
-        obd_size curr_loc;
-        int current_extent = 0, rc = 0, i;
-       /* Whether have we collected enough extents */
-       bool enough = false;
-        int ost_eof = 0; /* EOF for object */
-        int ost_done = 0; /* done with required mapping for this OST? */
-        int last_stripe;
-        int cur_stripe = 0, cur_stripe_wrap = 0, stripe_count;
-        unsigned int buffer_size = FIEMAP_BUFFER_SIZE;
-
-       if (!lsm_has_objects(lsm)) {
-               if (lsm && lsm_is_released(lsm) && (fm_key->fiemap.fm_start <
-                   fm_key->oa.o_size)) {
-                       /* released file, return a minimal FIEMAP if
-                        * request fits in file-size.
-                        */
-                       fiemap->fm_mapped_extents = 1;
-                       fiemap->fm_extents[0].fe_logical =
-                                               fm_key->fiemap.fm_start;
-                       if (fm_key->fiemap.fm_start + fm_key->fiemap.fm_length <
-                           fm_key->oa.o_size)
-                               fiemap->fm_extents[0].fe_length =
-                                               fm_key->fiemap.fm_length;
-                       else
-                               fiemap->fm_extents[0].fe_length =
-                                               fm_key->oa.o_size -
-                                               fm_key->fiemap.fm_start;
-                       fiemap->fm_extents[0].fe_flags |=
-                                               (FIEMAP_EXTENT_UNKNOWN |
-                                                FIEMAP_EXTENT_LAST);
-               }
-               GOTO(out, rc = 0);
-       }
+       if (KEY_IS(KEY_MAX_EASIZE)) {
+               *((u32 *)val) = exp->exp_connect_data.ocd_max_easize;
+       } else if (KEY_IS(KEY_DEFAULT_EASIZE)) {
+               u32 def_stripe_count = min_t(u32, ld->ld_default_stripe_count,
+                                            LOV_MAX_STRIPE_COUNT);
 
-        if (fiemap_count_to_size(fm_key->fiemap.fm_extent_count) < buffer_size)
-                buffer_size = fiemap_count_to_size(fm_key->fiemap.fm_extent_count);
-
-        OBD_ALLOC_LARGE(fm_local, buffer_size);
-        if (fm_local == NULL)
-                GOTO(out, rc = -ENOMEM);
-        lcl_fm_ext = &fm_local->fm_extents[0];
-
-        count_local = fiemap_size_to_count(buffer_size);
-
-        memcpy(fiemap, &fm_key->fiemap, sizeof(*fiemap));
-        fm_start = fiemap->fm_start;
-        fm_length = fiemap->fm_length;
-        /* Calculate start stripe, last stripe and length of mapping */
-        actual_start_stripe = start_stripe = lov_stripe_number(lsm, fm_start);
-        fm_end = (fm_length == ~0ULL ? fm_key->oa.o_size :
-                                                fm_start + fm_length - 1);
-        /* If fm_length != ~0ULL but fm_start+fm_length-1 exceeds file size */
-        if (fm_end > fm_key->oa.o_size)
-                fm_end = fm_key->oa.o_size;
-
-        last_stripe = fiemap_calc_last_stripe(lsm, fm_start, fm_end,
-                                            actual_start_stripe, &stripe_count);
-
-       fm_end_offset = fiemap_calc_fm_end_offset(fiemap, lsm, fm_start,
-                                                 fm_end, &start_stripe);
-       if (fm_end_offset == -EINVAL)
-               GOTO(out, rc = -EINVAL);
-
-       if (fiemap_count_to_size(fiemap->fm_extent_count) > *vallen)
-               fiemap->fm_extent_count = fiemap_size_to_count(*vallen);
-       if (fiemap->fm_extent_count == 0) {
-               get_num_extents = 1;
-               count_local = 0;
+               *((u32 *)val) = lov_mds_md_size(def_stripe_count, LOV_MAGIC_V3);
+       } else if (KEY_IS(KEY_TGT_COUNT)) {
+               *((int *)val) = lov->desc.ld_tgt_count;
+       } else {
+               rc = -EINVAL;
        }
-        /* Check each stripe */
-        for (cur_stripe = start_stripe, i = 0; i < stripe_count;
-             i++, cur_stripe = (cur_stripe + 1) % lsm->lsm_stripe_count) {
-                obd_size req_fm_len; /* Stores length of required mapping */
-                obd_size len_mapped_single_call;
-                obd_off lun_start, lun_end, obd_object_end;
-                unsigned int ext_count;
-
-                cur_stripe_wrap = cur_stripe;
-
-                /* Find out range of mapping on this stripe */
-                if ((lov_stripe_intersects(lsm, cur_stripe, fm_start, fm_end,
-                                           &lun_start, &obd_object_end)) == 0)
-                        continue;
-
-               if (lov_oinfo_is_dummy(lsm->lsm_oinfo[cur_stripe]))
-                       GOTO(out, rc = -EIO);
-
-                /* If this is a continuation FIEMAP call and we are on
-                 * starting stripe then lun_start needs to be set to
-                 * fm_end_offset */
-                if (fm_end_offset != 0 && cur_stripe == start_stripe)
-                        lun_start = fm_end_offset;
-
-                if (fm_length != ~0ULL) {
-                        /* Handle fm_start + fm_length overflow */
-                        if (fm_start + fm_length < fm_start)
-                                fm_length = ~0ULL - fm_start;
-                        lun_end = lov_size_to_stripe(lsm, fm_start + fm_length,
-                                                     cur_stripe);
-                } else {
-                        lun_end = ~0ULL;
-                }
-
-                if (lun_start == lun_end)
-                        continue;
-
-                req_fm_len = obd_object_end - lun_start;
-                fm_local->fm_length = 0;
-                len_mapped_single_call = 0;
-
-                /* If the output buffer is very large and the objects have many
-                 * extents we may need to loop on a single OST repeatedly */
-                ost_eof = 0;
-                ost_done = 0;
-                do {
-                        if (get_num_extents == 0) {
-                                /* Don't get too many extents. */
-                                if (current_extent + count_local >
-                                    fiemap->fm_extent_count)
-                                        count_local = fiemap->fm_extent_count -
-                                                                 current_extent;
-                        }
-
-                        lun_start += len_mapped_single_call;
-                        fm_local->fm_length = req_fm_len - len_mapped_single_call;
-                        req_fm_len = fm_local->fm_length;
-                       fm_local->fm_extent_count = enough ? 1 : count_local;
-                       fm_local->fm_mapped_extents = 0;
-                       fm_local->fm_flags = fiemap->fm_flags;
-
-                       fm_key->oa.o_oi = lsm->lsm_oinfo[cur_stripe]->loi_oi;
-                        ost_index = lsm->lsm_oinfo[cur_stripe]->loi_ost_idx;
-
-                        if (ost_index < 0 || ost_index >=lov->desc.ld_tgt_count)
-                                GOTO(out, rc = -EINVAL);
-
-                        /* If OST is inactive, return extent with UNKNOWN flag */
-                        if (!lov->lov_tgts[ost_index]->ltd_active) {
-                                fm_local->fm_flags |= FIEMAP_EXTENT_LAST;
-                                fm_local->fm_mapped_extents = 1;
-
-                                lcl_fm_ext[0].fe_logical = lun_start;
-                                lcl_fm_ext[0].fe_length = obd_object_end -
-                                                                      lun_start;
-                                lcl_fm_ext[0].fe_flags |= FIEMAP_EXTENT_UNKNOWN;
-
-                                goto inactive_tgt;
-                        }
 
-                        fm_local->fm_start = lun_start;
-                        fm_local->fm_flags &= ~FIEMAP_FLAG_DEVICE_ORDER;
-                        memcpy(&fm_key->fiemap, fm_local, sizeof(*fm_local));
-                        *vallen=fiemap_count_to_size(fm_local->fm_extent_count);
-                        rc = obd_get_info(NULL,
-                                          lov->lov_tgts[ost_index]->ltd_exp,
-                                          keylen, key, vallen, fm_local, lsm);
-                        if (rc != 0)
-                                GOTO(out, rc);
-
-inactive_tgt:
-                        ext_count = fm_local->fm_mapped_extents;
-                        if (ext_count == 0) {
-                                ost_done = 1;
-                                /* If last stripe has hole at the end,
-                                 * then we need to return */
-                                if (cur_stripe_wrap == last_stripe) {
-                                        fiemap->fm_mapped_extents = 0;
-                                        goto finish;
-                                }
-                                break;
-                       } else if (enough) {
-                               /*
-                                * We've collected enough extents and there are
-                                * more extents after it.
-                                */
-                               goto finish;
-                       }
-
-                        /* If we just need num of extents then go to next device */
-                        if (get_num_extents) {
-                                current_extent += ext_count;
-                                break;
-                        }
-
-                        len_mapped_single_call = lcl_fm_ext[ext_count-1].fe_logical -
-                                  lun_start + lcl_fm_ext[ext_count - 1].fe_length;
-
-                        /* Have we finished mapping on this device? */
-                        if (req_fm_len <= len_mapped_single_call)
-                                ost_done = 1;
-
-                        /* Clear the EXTENT_LAST flag which can be present on
-                         * last extent */
-                        if (lcl_fm_ext[ext_count-1].fe_flags & FIEMAP_EXTENT_LAST)
-                                lcl_fm_ext[ext_count - 1].fe_flags &=
-                                                            ~FIEMAP_EXTENT_LAST;
-
-                        curr_loc = lov_stripe_size(lsm,
-                                           lcl_fm_ext[ext_count - 1].fe_logical+
-                                           lcl_fm_ext[ext_count - 1].fe_length,
-                                           cur_stripe);
-                        if (curr_loc >= fm_key->oa.o_size)
-                                ost_eof = 1;
-
-                        fiemap_prepare_and_copy_exts(fiemap, lcl_fm_ext,
-                                                     ost_index, ext_count,
-                                                     current_extent);
-
-                        current_extent += ext_count;
-
-                       /* Ran out of available extents? */
-                       if (current_extent >= fiemap->fm_extent_count)
-                               enough = true;
-                } while (ost_done == 0 && ost_eof == 0);
-
-                if (cur_stripe_wrap == last_stripe)
-                        goto finish;
-        }
-
-finish:
-        /* Indicate that we are returning device offsets unless file just has
-         * single stripe */
-        if (lsm->lsm_stripe_count > 1)
-                fiemap->fm_flags |= FIEMAP_FLAG_DEVICE_ORDER;
-
-        if (get_num_extents)
-                goto skip_last_device_calc;
-
-        /* Check if we have reached the last stripe and whether mapping for that
-         * stripe is done. */
-        if (cur_stripe_wrap == last_stripe) {
-                if (ost_done || ost_eof)
-                        fiemap->fm_extents[current_extent - 1].fe_flags |=
-                                                             FIEMAP_EXTENT_LAST;
-        }
+       lov_tgts_putref(obddev);
 
-skip_last_device_calc:
-        fiemap->fm_mapped_extents = current_extent;
-
-out:
-       if (fm_local)
-               OBD_FREE_LARGE(fm_local, buffer_size);
-        return rc;
+       RETURN(rc);
 }
 
-static int lov_get_info(const struct lu_env *env, struct obd_export *exp,
-                       __u32 keylen, void *key, __u32 *vallen, void *val,
-                       struct lov_stripe_md *lsm)
+static int lov_set_info_async(const struct lu_env *env, struct obd_export *exp,
+                             __u32 keylen, void *key,
+                             __u32 vallen, void *val,
+                             struct ptlrpc_request_set *set)
 {
        struct obd_device *obddev = class_exp2obd(exp);
        struct lov_obd *lov = &obddev->u.lov;
-       int rc;
-        ENTRY;
+       struct lov_tgt_desc *tgt;
+       bool do_inactive = false, no_set = false;
+       u32 i;
+       int rc = 0;
+       int err;
 
-        if (!vallen || !val)
-                RETURN(-EFAULT);
+       ENTRY;
 
-        obd_getref(obddev);
+       if (set == NULL) {
+               no_set = true;
+               set = ptlrpc_prep_set();
+               if (!set)
+                       RETURN(-ENOMEM);
+       }
 
-       if (KEY_IS(KEY_LOVDESC)) {
-                struct lov_desc *desc_ret = val;
-                *desc_ret = lov->desc;
+       lov_tgts_getref(obddev);
 
-                GOTO(out, rc = 0);
-        } else if (KEY_IS(KEY_FIEMAP)) {
-                rc = lov_fiemap(lov, keylen, key, vallen, val, lsm);
-                GOTO(out, rc);
-        } else if (KEY_IS(KEY_TGT_COUNT)) {
-                *((int *)val) = lov->desc.ld_tgt_count;
-                GOTO(out, rc = 0);
-        }
+       if (KEY_IS(KEY_CHECKSUM))
+               do_inactive = true;
 
-        rc = -EINVAL;
-
-out:
-        obd_putref(obddev);
-        RETURN(rc);
-}
+       for (i = 0; i < lov->desc.ld_tgt_count; i++) {
+               tgt = lov->lov_tgts[i];
 
-static int lov_set_info_async(const struct lu_env *env, struct obd_export *exp,
-                              obd_count keylen, void *key, obd_count vallen,
-                              void *val, struct ptlrpc_request_set *set)
-{
-        struct obd_device *obddev = class_exp2obd(exp);
-        struct lov_obd *lov = &obddev->u.lov;
-        obd_count count;
-        int i, rc = 0, err;
-        struct lov_tgt_desc *tgt;
-       int do_inactive = 0;
-       int no_set = 0;
-        ENTRY;
+               /* OST was disconnected */
+               if (tgt == NULL || tgt->ltd_exp == NULL)
+                       continue;
 
-        if (set == NULL) {
-                no_set = 1;
-                set = ptlrpc_prep_set();
-                if (!set)
-                        RETURN(-ENOMEM);
-        }
+               /* OST is inactive and we don't want inactive OSCs */
+               if (!tgt->ltd_active && !do_inactive)
+                       continue;
 
-        obd_getref(obddev);
-        count = lov->desc.ld_tgt_count;
+               err = obd_set_info_async(env, tgt->ltd_exp, keylen, key,
+                                        vallen, val, set);
 
-       if (KEY_IS(KEY_CHECKSUM)) {
-                do_inactive = 1;
-       } else if (KEY_IS(KEY_CACHE_SET)) {
-               LASSERT(lov->lov_cache == NULL);
-               lov->lov_cache = val;
-               do_inactive = 1;
+               if (rc == 0)
+                       rc = err;
        }
 
-       for (i = 0; i < count; i++) {
-               tgt = lov->lov_tgts[i];
-
-                /* OST was disconnected */
-                if (!tgt || !tgt->ltd_exp)
-                        continue;
+       /* cycle through MDC target for Data-on-MDT */
+       for (i = 0; i < LOV_MDC_TGT_MAX; i++) {
+               struct obd_device *mdc;
 
-                /* OST is inactive and we don't want inactive OSCs */
-                if (!tgt->ltd_active && !do_inactive)
-                        continue;
+               mdc = lov->lov_mdc_tgts[i].lmtd_mdc;
+               if (mdc == NULL)
+                       continue;
 
-               err = obd_set_info_async(env, tgt->ltd_exp, keylen, key,
-                                        vallen, val, set);
-                if (!rc)
-                        rc = err;
-        }
+               err = obd_set_info_async(env, mdc->obd_self_export,
+                                        keylen, key, vallen, val, set);
+               if (rc == 0)
+                       rc = err;
+       }
 
-        obd_putref(obddev);
-        if (no_set) {
-                err = ptlrpc_set_wait(set);
-                if (!rc)
-                        rc = err;
-                ptlrpc_set_destroy(set);
-        }
-        RETURN(rc);
+       lov_tgts_putref(obddev);
+       if (no_set) {
+               err = ptlrpc_set_wait(env, set);
+               if (rc == 0)
+                       rc = err;
+               ptlrpc_set_destroy(set);
+       }
+       RETURN(rc);
 }
 
 void lov_stripe_lock(struct lov_stripe_md *md)
@@ -2037,19 +1272,15 @@ static int lov_quotactl(struct obd_device *obd, struct obd_export *exp,
         int                  i, rc = 0;
         ENTRY;
 
-        if (oqctl->qc_cmd != LUSTRE_Q_QUOTAON &&
-            oqctl->qc_cmd != LUSTRE_Q_QUOTAOFF &&
-            oqctl->qc_cmd != Q_GETOQUOTA &&
-            oqctl->qc_cmd != Q_INITQUOTA &&
-            oqctl->qc_cmd != LUSTRE_Q_SETQUOTA &&
-            oqctl->qc_cmd != Q_FINVALIDATE) {
+       if (oqctl->qc_cmd != Q_GETOQUOTA &&
+           oqctl->qc_cmd != LUSTRE_Q_SETQUOTA) {
                CERROR("%s: bad quota opc %x for lov obd\n",
                       obd->obd_name, oqctl->qc_cmd);
                RETURN(-EFAULT);
        }
 
         /* for lov tgt */
-        obd_getref(obd);
+       lov_tgts_getref(obd);
         for (i = 0; i < lov->desc.ld_tgt_count; i++) {
                 int err;
 
@@ -2081,7 +1312,7 @@ static int lov_quotactl(struct obd_device *obd, struct obd_export *exp,
                         bhardlimit += oqctl->qc_dqblk.dqb_bhardlimit;
                 }
         }
-        obd_putref(obd);
+       lov_tgts_putref(obd);
 
         if (oqctl->qc_cmd == Q_GETOQUOTA) {
                 oqctl->qc_dqblk.dqb_curspace = curspace;
@@ -2090,65 +1321,13 @@ static int lov_quotactl(struct obd_device *obd, struct obd_export *exp,
         RETURN(rc);
 }
 
-static int lov_quotacheck(struct obd_device *obd, struct obd_export *exp,
-                          struct obd_quotactl *oqctl)
-{
-        struct lov_obd *lov = &obd->u.lov;
-        int             i, rc = 0;
-        ENTRY;
-
-        obd_getref(obd);
-
-        for (i = 0; i < lov->desc.ld_tgt_count; i++) {
-                if (!lov->lov_tgts[i])
-                        continue;
-
-                /* Skip quota check on the administratively disabled OSTs. */
-                if (!lov->lov_tgts[i]->ltd_activate) {
-                        CWARN("lov idx %d was administratively disabled, "
-                              "skip quotacheck on it.\n", i);
-                        continue;
-                }
-
-                if (!lov->lov_tgts[i]->ltd_active) {
-                        CERROR("lov idx %d inactive\n", i);
-                        rc = -EIO;
-                        goto out;
-                }
-        }
-
-        for (i = 0; i < lov->desc.ld_tgt_count; i++) {
-                int err;
-
-                if (!lov->lov_tgts[i] || !lov->lov_tgts[i]->ltd_activate)
-                        continue;
-
-                err = obd_quotacheck(lov->lov_tgts[i]->ltd_exp, oqctl);
-                if (err && !rc)
-                        rc = err;
-        }
-
-out:
-        obd_putref(obd);
-
-        RETURN(rc);
-}
-
-static struct obd_ops lov_obd_ops = {
+static const struct obd_ops lov_obd_ops = {
        .o_owner                = THIS_MODULE,
        .o_setup                = lov_setup,
-       .o_precleanup           = lov_precleanup,
        .o_cleanup              = lov_cleanup,
        .o_connect              = lov_connect,
        .o_disconnect           = lov_disconnect,
        .o_statfs               = lov_statfs,
-       .o_statfs_async         = lov_statfs_async,
-       .o_packmd               = lov_packmd,
-       .o_unpackmd             = lov_unpackmd,
-       .o_getattr_async        = lov_getattr_async,
-       .o_setattr_async        = lov_setattr_async,
-       .o_change_cbdata        = lov_change_cbdata,
-       .o_find_cbdata          = lov_find_cbdata,
        .o_iocontrol            = lov_iocontrol,
        .o_get_info             = lov_get_info,
        .o_set_info_async       = lov_set_info_async,
@@ -2157,18 +1336,13 @@ static struct obd_ops lov_obd_ops = {
        .o_pool_rem             = lov_pool_remove,
        .o_pool_add             = lov_pool_add,
        .o_pool_del             = lov_pool_del,
-       .o_getref               = lov_getref,
-       .o_putref               = lov_putref,
        .o_quotactl             = lov_quotactl,
-       .o_quotacheck           = lov_quotacheck,
 };
 
 struct kmem_cache *lov_oinfo_slab;
 
 static int __init lov_init(void)
 {
-       bool enable_proc = true;
-       struct obd_type *type;
        int rc;
        ENTRY;
 
@@ -2189,13 +1363,8 @@ static int __init lov_init(void)
                 return -ENOMEM;
         }
 
-       type = class_search_type(LUSTRE_LOD_NAME);
-       if (type != NULL && type->typ_procsym != NULL)
-               enable_proc = false;
-
-       rc = class_register_type(&lov_obd_ops, NULL, enable_proc, NULL,
+       rc = class_register_type(&lov_obd_ops, NULL, true, NULL,
                                 LUSTRE_LOV_NAME, &lov_device_type);
-
         if (rc) {
                kmem_cache_destroy(lov_oinfo_slab);
                 lu_kmem_fini(lov_caches);
@@ -2204,15 +1373,17 @@ static int __init lov_init(void)
         RETURN(rc);
 }
 
-static void /*__exit*/ lov_exit(void)
+static void __exit lov_exit(void)
 {
        class_unregister_type(LUSTRE_LOV_NAME);
        kmem_cache_destroy(lov_oinfo_slab);
        lu_kmem_fini(lov_caches);
 }
 
-MODULE_AUTHOR("Sun Microsystems, Inc. <http://www.lustre.org/>");
-MODULE_DESCRIPTION("Lustre Logical Object Volume OBD driver");
+MODULE_AUTHOR("OpenSFS, Inc. <http://www.lustre.org/>");
+MODULE_DESCRIPTION("Lustre Logical Object Volume");
+MODULE_VERSION(LUSTRE_VERSION_STRING);
 MODULE_LICENSE("GPL");
 
-cfs_module(lov, LUSTRE_VERSION_STRING, lov_init, lov_exit);
+module_init(lov_init);
+module_exit(lov_exit);