X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;ds=sidebyside;f=lustre%2Fmdd%2Fmdd_device.c;h=80ff70eb4ad0fbf38cef336d9a0305a4c7256994;hb=76f0977b7ea5d46836cb459deb7b9ad9e781d585;hp=f87fa4275adaf5ad13380412fa1f12a11c004cae;hpb=c961228f1c30254c454ed1432ba83af3aa7c39b4;p=fs%2Flustre-release.git

diff --git a/lustre/mdd/mdd_device.c b/lustre/mdd/mdd_device.c
index f87fa42..80ff70e 100644
--- a/lustre/mdd/mdd_device.c
+++ b/lustre/mdd/mdd_device.c
@@ -27,7 +27,7 @@
  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  *
- * Copyright (c) 2011, 2012, Intel Corporation.
+ * Copyright (c) 2011, 2013, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -57,9 +57,10 @@ static struct lu_device_type mdd_device_type;
 
 static const char mdd_root_dir_name[] = "ROOT";
 static const char mdd_obf_dir_name[] = "fid";
+static const char mdd_lpf_dir_name[] = "lost+found";
 
 /* Slab for MDD object allocation */
-cfs_mem_cache_t *mdd_object_kmem;
+struct kmem_cache *mdd_object_kmem;
 
 static struct lu_kmem_descr mdd_caches[] = {
 	{
@@ -160,49 +161,23 @@ static struct lu_device *mdd_device_fini(const struct lu_env *env,
 	return NULL;
 }
 
-static void mdd_changelog_fini(const struct lu_env *env,
-                               struct mdd_device *mdd);
-
-static void mdd_device_shutdown(const struct lu_env *env,
-                                struct mdd_device *m, struct lustre_cfg *cfg)
-{
-        ENTRY;
-        if (m->mdd_dot_lustre_objs.mdd_obf)
-                mdd_object_put(env, m->mdd_dot_lustre_objs.mdd_obf);
-        if (m->mdd_dot_lustre)
-                mdd_object_put(env, m->mdd_dot_lustre);
-        orph_index_fini(env, m);
-        if (m->mdd_capa != NULL) {
-                lu_object_put(env, &m->mdd_capa->do_lu);
-                m->mdd_capa = NULL;
-        }
-	lu_site_purge(env, m->mdd_md_dev.md_lu_dev.ld_site, -1);
-        /* remove upcall device*/
-        md_upcall_fini(&m->mdd_md_dev);
-
-	if (m->mdd_child_exp)
-		obd_disconnect(m->mdd_child_exp);
-
-        EXIT;
-}
-
 static int changelog_init_cb(const struct lu_env *env, struct llog_handle *llh,
 			     struct llog_rec_hdr *hdr, void *data)
 {
-        struct mdd_device *mdd = (struct mdd_device *)data;
-        struct llog_changelog_rec *rec = (struct llog_changelog_rec *)hdr;
+	struct mdd_device *mdd = (struct mdd_device *)data;
+	struct llog_changelog_rec *rec = (struct llog_changelog_rec *)hdr;
 
-        LASSERT(llh->lgh_hdr->llh_flags & LLOG_F_IS_PLAIN);
-        LASSERT(rec->cr_hdr.lrh_type == CHANGELOG_REC);
+	LASSERT(llh->lgh_hdr->llh_flags & LLOG_F_IS_PLAIN);
+	LASSERT(rec->cr_hdr.lrh_type == CHANGELOG_REC);
 
-        CDEBUG(D_INFO,
-               "seeing record at index %d/%d/"LPU64" t=%x %.*s in log "LPX64"\n",
-               hdr->lrh_index, rec->cr_hdr.lrh_index, rec->cr.cr_index,
-               rec->cr.cr_type, rec->cr.cr_namelen, rec->cr.cr_name,
-               llh->lgh_id.lgl_oid);
+	CDEBUG(D_INFO,
+	       "seeing record at index %d/%d/"LPU64" t=%x %.*s in log"
+	       DOSTID"\n", hdr->lrh_index, rec->cr_hdr.lrh_index,
+	       rec->cr.cr_index, rec->cr.cr_type, rec->cr.cr_namelen,
+	       rec->cr.cr_name, POSTID(&llh->lgh_id.lgl_oi));
 
-        mdd->mdd_cl.mc_index = rec->cr.cr_index;
-        return LLOG_PROC_BREAK;
+	mdd->mdd_cl.mc_index = rec->cr.cr_index;
+	return LLOG_PROC_BREAK;
 }
 
 static int changelog_user_init_cb(const struct lu_env *env,
@@ -217,11 +192,13 @@ static int changelog_user_init_cb(const struct lu_env *env,
         LASSERT(rec->cur_hdr.lrh_type == CHANGELOG_USER_REC);
 
         CDEBUG(D_INFO, "seeing user at index %d/%d id=%d endrec="LPU64
-               " in log "LPX64"\n", hdr->lrh_index, rec->cur_hdr.lrh_index,
-               rec->cur_id, rec->cur_endrec, llh->lgh_id.lgl_oid);
+               " in log "DOSTID"\n", hdr->lrh_index, rec->cur_hdr.lrh_index,
+               rec->cur_id, rec->cur_endrec, POSTID(&llh->lgh_id.lgl_oi));
 
 	spin_lock(&mdd->mdd_cl.mc_user_lock);
 	mdd->mdd_cl.mc_lastuser = rec->cur_id;
+	if (rec->cur_endrec > mdd->mdd_cl.mc_index)
+		mdd->mdd_cl.mc_index = rec->cur_endrec;
 	spin_unlock(&mdd->mdd_cl.mc_user_lock);
 
 	return LLOG_PROC_BREAK;
@@ -275,9 +252,9 @@ static int llog_changelog_cancel(const struct lu_env *env,
 		/* 0 or 1 means we're done */
 		rc = 0;
 	else
-		CERROR("%s: cancel idx %u of catalog "LPX64" rc=%d\n",
+		CERROR("%s: cancel idx %u of catalog "DOSTID" rc=%d\n",
 		       ctxt->loc_obd->obd_name, cathandle->lgh_last_idx,
-		       cathandle->lgh_id.lgl_oid, rc);
+		       POSTID(&cathandle->lgh_id.lgl_oi), rc);
 
 	RETURN(rc);
 }
@@ -293,6 +270,12 @@ static int mdd_changelog_llog_init(const struct lu_env *env,
 	struct llog_ctxt	*ctxt = NULL, *uctxt = NULL;
 	int			 rc;
 
+	ENTRY;
+
+	/* LU-2844 mdd setup failure should not cause umount oops */
+	if (OBD_FAIL_CHECK(OBD_FAIL_MDS_CHANGELOG_INIT))
+		RETURN(-EIO);
+
 	OBD_SET_CTXT_MAGIC(&obd->obd_lvfs_ctxt);
 	obd->obd_lvfs_ctxt.dt = mdd->mdd_bottom;
 	rc = llog_setup(env, obd, &obd->obd_olg, LLOG_CHANGELOG_ORIG_CTXT,
@@ -527,7 +510,7 @@ int mdd_changelog_write_header(const struct lu_env *env,
 	}
 
 	reclen = llog_data_len(sizeof(*rec) + len);
-	buf = mdd_buf_alloc(env, reclen);
+	buf = lu_buf_check_and_alloc(&mdd_env_info(env)->mti_big_buf, reclen);
 	if (buf->lb_buf == NULL)
 		RETURN(-ENOMEM);
 	rec = buf->lb_buf;
@@ -559,547 +542,334 @@ int mdd_changelog_write_header(const struct lu_env *env,
 }
 
 /**
- * Create ".lustre" directory.
+ * Lookup method for "fid" object. Only filenames with correct SEQ:OID format
+ * are valid. We also check if object with passed fid exists or not.
  */
-static int create_dot_lustre_dir(const struct lu_env *env, struct mdd_device *m)
+static int obf_lookup(const struct lu_env *env, struct md_object *p,
+                      const struct lu_name *lname, struct lu_fid *f,
+                      struct md_op_spec *spec)
 {
-        struct lu_fid *fid = &mdd_env_info(env)->mti_fid;
-        struct md_object *mdo;
-        int rc;
-
-        memcpy(fid, &LU_DOT_LUSTRE_FID, sizeof(struct lu_fid));
-        mdo = llo_store_create_index(env, &m->mdd_md_dev, m->mdd_child,
-                                     mdd_root_dir_name, dot_lustre_name,
-                                     fid, &dt_directory_features);
-        /* .lustre dir may be already present */
-        if (IS_ERR(mdo) && PTR_ERR(mdo) != -EEXIST) {
-                rc = PTR_ERR(mdo);
-                CERROR("creating obj [%s] fid = "DFID" rc = %d\n",
-                        dot_lustre_name, PFID(fid), rc);
-		return rc;
-        }
-
-        if (!IS_ERR(mdo))
-                lu_object_put(env, &mdo->mo_lu);
+        char *name = (char *)lname->ln_name;
+        struct mdd_device *mdd = mdo2mdd(p);
+        struct mdd_object *child;
+        int rc = 0;
 
-        return 0;
-}
+        while (*name == '[')
+                name++;
 
+        sscanf(name, SFID, RFID(f));
+        if (!fid_is_sane(f)) {
+		CWARN("%s: bad FID format [%s], should be "DFID"\n",
+		      mdd2obd_dev(mdd)->obd_name, lname->ln_name,
+		      (__u64)FID_SEQ_NORMAL, 1, 0);
+                GOTO(out, rc = -EINVAL);
+        }
 
-static int dot_lustre_mdd_permission(const struct lu_env *env,
-                                     struct md_object *pobj,
-                                     struct md_object *cobj,
-                                     struct md_attr *attr, int mask)
-{
-        if (mask & ~(MAY_READ | MAY_EXEC))
-                return -EPERM;
-        else
-                return 0;
-}
+	if (!fid_is_norm(f) && !fid_is_igif(f) && !fid_is_root(f) &&
+	    !fid_seq_is_dot(f->f_seq)) {
+		CWARN("%s: "DFID" is invalid, sequence should be "
+		      ">= "LPX64" or within ["LPX64","LPX64"].\n",
+		      mdd2obd_dev(mdd)->obd_name, PFID(f),
+		      (__u64)FID_SEQ_NORMAL, (__u64)FID_SEQ_IGIF,
+		      (__u64)FID_SEQ_IGIF_MAX);
+		GOTO(out, rc = -EINVAL);
+	}
 
-static int dot_lustre_mdd_xattr_get(const struct lu_env *env,
-                                    struct md_object *obj, struct lu_buf *buf,
-                                    const char *name)
-{
-        return 0;
-}
+        /* Check if object with this fid exists */
+        child = mdd_object_find(env, mdd, f);
+        if (child == NULL)
+                GOTO(out, rc = 0);
+        if (IS_ERR(child))
+                GOTO(out, rc = PTR_ERR(child));
 
-static int dot_lustre_mdd_xattr_list(const struct lu_env *env,
-                                     struct md_object *obj, struct lu_buf *buf)
-{
-        return 0;
-}
+        if (mdd_object_exists(child) == 0)
+                rc = -ENOENT;
 
-static int dot_lustre_mdd_xattr_set(const struct lu_env *env,
-                                    struct md_object *obj,
-                                    const struct lu_buf *buf, const char *name,
-                                    int fl)
-{
-        return -EPERM;
-}
+        mdd_object_put(env, child);
 
-static int dot_lustre_mdd_xattr_del(const struct lu_env *env,
-                                    struct md_object *obj,
-                                    const char *name)
-{
-        return -EPERM;
+out:
+        return rc;
 }
 
-static int dot_lustre_mdd_swap_layouts(const struct lu_env *env,
-				       struct md_object *obj1,
-				       struct md_object *obj2,
-				       __u64 flags)
+static int mdd_dummy_create(const struct lu_env *env,
+			    struct md_object *pobj,
+			    const struct lu_name *lname,
+			    struct md_object *child,
+			    struct md_op_spec *spec,
+			    struct md_attr* ma)
 {
 	return -EPERM;
 }
 
-static int dot_lustre_mdd_readlink(const struct lu_env *env,
-                                   struct md_object *obj, struct lu_buf *buf)
+static int mdd_dummy_rename(const struct lu_env *env,
+			    struct md_object *src_pobj,
+			    struct md_object *tgt_pobj,
+			    const struct lu_fid *lf,
+			    const struct lu_name *lsname,
+			    struct md_object *tobj,
+			    const struct lu_name *ltname,
+			    struct md_attr *ma)
 {
-        return 0;
-}
-
-static int dot_lustre_mdd_object_create(const struct lu_env *env,
-                                        struct md_object *obj,
-                                        const struct md_op_spec *spec,
-                                        struct md_attr *ma)
-{
-        return -EPERM;
-}
-
-static int dot_lustre_mdd_ref_add(const struct lu_env *env,
-                                  struct md_object *obj,
-                                  const struct md_attr *ma)
-{
-        return -EPERM;
-}
-
-static int dot_lustre_mdd_ref_del(const struct lu_env *env,
-                                  struct md_object *obj,
-                                  struct md_attr *ma)
-{
-        return -EPERM;
-}
-
-static int dot_lustre_mdd_open(const struct lu_env *env, struct md_object *obj,
-                               int flags)
-{
-        struct mdd_object *mdd_obj = md2mdd_obj(obj);
-
-        mdd_write_lock(env, mdd_obj, MOR_TGT_CHILD);
-        mdd_obj->mod_count++;
-        mdd_write_unlock(env, mdd_obj);
-
-        return 0;
-}
-
-static int dot_lustre_mdd_close(const struct lu_env *env, struct md_object *obj,
-                                struct md_attr *ma, int mode)
-{
-        struct mdd_object *mdd_obj = md2mdd_obj(obj);
-
-        mdd_write_lock(env, mdd_obj, MOR_TGT_CHILD);
-        mdd_obj->mod_count--;
-        mdd_write_unlock(env, mdd_obj);
-
-        return 0;
-}
-
-static int dot_lustre_mdd_object_sync(const struct lu_env *env,
-                                      struct md_object *obj)
-{
-        return -ENOSYS;
-}
-
-static int dot_lustre_mdd_path(const struct lu_env *env, struct md_object *obj,
-                           char *path, int pathlen, __u64 *recno, int *linkno)
-{
-        return -ENOSYS;
+	return -EPERM;
 }
 
-static int dot_file_lock(const struct lu_env *env, struct md_object *obj,
-                         struct lov_mds_md *lmm, struct ldlm_extent *extent,
-                         struct lustre_handle *lockh)
+static int mdd_dummy_link(const struct lu_env *env,
+			  struct md_object *tgt_obj,
+			  struct md_object *src_obj,
+			  const struct lu_name *lname,
+			  struct md_attr *ma)
 {
-        return -ENOSYS;
+	return -EPERM;
 }
 
-static int dot_file_unlock(const struct lu_env *env, struct md_object *obj,
-                           struct lov_mds_md *lmm, struct lustre_handle *lockh)
+static int mdd_dummy_unlink(const struct lu_env *env,
+			    struct md_object *pobj,
+			    struct md_object *cobj,
+			    const struct lu_name *lname,
+			    struct md_attr *ma,
+			    int no_name)
 {
-        return -ENOSYS;
+	return -EPERM;
 }
 
-static struct md_object_operations mdd_dot_lustre_obj_ops = {
-	.moo_permission		= dot_lustre_mdd_permission,
-	.moo_attr_get		= mdd_attr_get,
-	.moo_attr_set		= mdd_attr_set,
-	.moo_xattr_get		= dot_lustre_mdd_xattr_get,
-	.moo_xattr_list		= dot_lustre_mdd_xattr_list,
-	.moo_xattr_set		= dot_lustre_mdd_xattr_set,
-	.moo_xattr_del		= dot_lustre_mdd_xattr_del,
-	.moo_swap_layouts	= dot_lustre_mdd_swap_layouts,
-	.moo_readpage		= mdd_readpage,
-	.moo_readlink		= dot_lustre_mdd_readlink,
-	.moo_object_create	= dot_lustre_mdd_object_create,
-	.moo_ref_add		= dot_lustre_mdd_ref_add,
-	.moo_ref_del		= dot_lustre_mdd_ref_del,
-	.moo_open		= dot_lustre_mdd_open,
-	.moo_close		= dot_lustre_mdd_close,
-	.moo_capa_get		= mdd_capa_get,
-	.moo_object_sync	= dot_lustre_mdd_object_sync,
-	.moo_path		= dot_lustre_mdd_path,
-	.moo_file_lock		= dot_file_lock,
-	.moo_file_unlock	= dot_file_unlock,
+static struct md_dir_operations mdd_obf_dir_ops = {
+	.mdo_lookup = obf_lookup,
+	.mdo_create = mdd_dummy_create,
+	.mdo_rename = mdd_dummy_rename,
+	.mdo_link   = mdd_dummy_link,
+	.mdo_unlink = mdd_dummy_unlink
 };
 
+static struct md_dir_operations mdd_lpf_dir_ops = {
+	.mdo_lookup = mdd_lookup,
+	.mdo_create = mdd_dummy_create,
+	.mdo_rename = mdd_dummy_rename,
+	.mdo_link   = mdd_dummy_link,
+	.mdo_unlink = mdd_dummy_unlink
+};
 
-static int dot_lustre_mdd_lookup(const struct lu_env *env, struct md_object *p,
-                                 const struct lu_name *lname, struct lu_fid *f,
-                                 struct md_op_spec *spec)
+static struct md_object *mdo_locate(const struct lu_env *env,
+				    struct md_device *md,
+				    const struct lu_fid *fid)
 {
-	if (strcmp(lname->ln_name, mdd_obf_dir_name) == 0) {
-		*f = LU_OBF_FID;
-		return 0;
-	}
+	struct lu_object *obj;
+	struct md_object *mdo;
 
-	return -ENOENT;
+	obj = lu_object_find(env, &md->md_lu_dev, fid, NULL);
+	if (!IS_ERR(obj)) {
+		obj = lu_object_locate(obj->lo_header, md->md_lu_dev.ld_type);
+		LASSERT(obj != NULL);
+		mdo = lu2md(obj);
+	} else {
+		mdo = ERR_PTR(PTR_ERR(obj));
+	}
+	return mdo;
 }
 
-static mdl_mode_t dot_lustre_mdd_lock_mode(const struct lu_env *env,
-                                           struct md_object *obj,
-                                           mdl_mode_t mode)
+static int mdd_lpf_setup(const struct lu_env *env, struct mdd_device *m)
 {
-        return MDL_MINMODE;
-}
+	struct md_object	*mdo;
+	struct mdd_object	*mdd_lpf;
+	struct lu_fid		 fid	= LU_LPF_FID;
+	int			 rc;
+	ENTRY;
 
-static int dot_lustre_mdd_create(const struct lu_env *env,
-                                 struct md_object *pobj,
-                                 const struct lu_name *lname,
-                                 struct md_object *child,
-                                 struct md_op_spec *spec,
-                                 struct md_attr* ma)
-{
-        return -EPERM;
-}
+	rc = mdd_local_file_create(env, m, mdd_object_fid(m->mdd_dot_lustre),
+				   mdd_lpf_dir_name, S_IFDIR | S_IRUSR | S_IXUSR,
+				   &fid);
+	if (rc != 0)
+		RETURN(rc);
 
-static int dot_lustre_mdd_create_data(const struct lu_env *env,
-                                      struct md_object *p,
-                                      struct md_object *o,
-                                      const struct md_op_spec *spec,
-                                      struct md_attr *ma)
-{
-        return -EPERM;
-}
+	mdo = mdo_locate(env, &m->mdd_md_dev, &fid);
+	if (IS_ERR(mdo))
+		RETURN(PTR_ERR(mdo));
 
-static int dot_lustre_mdd_rename(const struct lu_env *env,
-                                 struct md_object *src_pobj,
-                                 struct md_object *tgt_pobj,
-                                 const struct lu_fid *lf,
-                                 const struct lu_name *lsname,
-                                 struct md_object *tobj,
-                                 const struct lu_name *ltname,
-                                 struct md_attr *ma)
-{
-        return -EPERM;
-}
+	LASSERT(lu_object_exists(&mdo->mo_lu));
 
-static int dot_lustre_mdd_link(const struct lu_env *env,
-                               struct md_object *tgt_obj,
-                               struct md_object *src_obj,
-                               const struct lu_name *lname,
-                               struct md_attr *ma)
-{
-        return -EPERM;
-}
+	mdd_lpf = md2mdd_obj(mdo);
+	mdd_lpf->mod_obj.mo_dir_ops = &mdd_lpf_dir_ops;
+	m->mdd_dot_lustre_objs.mdd_lpf = mdd_lpf;
 
-static int dot_lustre_mdd_unlink(const struct lu_env *env,
-                                 struct md_object *pobj,
-                                 struct md_object *cobj,
-                                 const struct lu_name *lname,
-                                 struct md_attr *ma)
-{
-        return -EPERM;
-}
-
-static int dot_lustre_mdd_name_insert(const struct lu_env *env,
-                                      struct md_object *obj,
-                                      const struct lu_name *lname,
-                                      const struct lu_fid *fid,
-                                      const struct md_attr *ma)
-{
-        return -EPERM;
-}
-
-static int dot_lustre_mdd_name_remove(const struct lu_env *env,
-                                      struct md_object *obj,
-                                      const struct lu_name *lname,
-                                      const struct md_attr *ma)
-{
-        return -EPERM;
+	RETURN(0);
 }
 
-static int dot_lustre_mdd_rename_tgt(const struct lu_env *env,
-                                     struct md_object *pobj,
-                                     struct md_object *tobj,
-                                     const struct lu_fid *fid,
-                                     const struct lu_name *lname,
-                                     struct md_attr *ma)
+/**
+ * Create special in-memory "fid" object for open-by-fid.
+ */
+static int mdd_obf_setup(const struct lu_env *env, struct mdd_device *m)
 {
-        return -EPERM;
-}
+	struct md_object	*mdo;
+	struct mdd_object	*mdd_obf;
+	struct lu_fid		 fid = LU_OBF_FID;
+	int			 rc;
 
+	rc = mdd_local_file_create(env, m, mdd_object_fid(m->mdd_dot_lustre),
+				   mdd_obf_dir_name, S_IFDIR | S_IXUSR, &fid);
+	if (rc < 0)
+		RETURN(rc);
 
-static struct md_dir_operations mdd_dot_lustre_dir_ops = {
-        .mdo_is_subdir   = mdd_is_subdir,
-        .mdo_lookup      = dot_lustre_mdd_lookup,
-        .mdo_lock_mode   = dot_lustre_mdd_lock_mode,
-        .mdo_create      = dot_lustre_mdd_create,
-        .mdo_create_data = dot_lustre_mdd_create_data,
-        .mdo_rename      = dot_lustre_mdd_rename,
-        .mdo_link        = dot_lustre_mdd_link,
-        .mdo_unlink      = dot_lustre_mdd_unlink,
-        .mdo_name_insert = dot_lustre_mdd_name_insert,
-        .mdo_name_remove = dot_lustre_mdd_name_remove,
-        .mdo_rename_tgt  = dot_lustre_mdd_rename_tgt,
-};
+	mdo = mdo_locate(env, &m->mdd_md_dev, &fid);
+	if (IS_ERR(mdo))
+		RETURN(PTR_ERR(mdo));
 
-static int obf_attr_get(const struct lu_env *env, struct md_object *obj,
-                        struct md_attr *ma)
-{
-	struct mdd_device *mdd = mdo2mdd(obj);
+	LASSERT(lu_object_exists(&mdo->mo_lu));
 
-	/* "fid" is a virtual object and hence does not have any "real"
-	 * attributes. So we reuse attributes of .lustre for "fid" dir */
-	return mdd_attr_get(env, &mdd->mdd_dot_lustre->mod_obj, ma);
-}
+	mdd_obf = md2mdd_obj(mdo);
+	mdd_obf->mod_obj.mo_dir_ops = &mdd_obf_dir_ops;
+	m->mdd_dot_lustre_objs.mdd_obf = mdd_obf;
 
-static int obf_attr_set(const struct lu_env *env, struct md_object *obj,
-                        const struct md_attr *ma)
-{
-        return -EPERM;
-}
-
-static int obf_xattr_list(const struct lu_env *env,
-			  struct md_object *obj, struct lu_buf *buf)
-{
 	return 0;
 }
 
-static int obf_xattr_get(const struct lu_env *env,
-                         struct md_object *obj, struct lu_buf *buf,
-                         const char *name)
+static void mdd_dot_lustre_cleanup(const struct lu_env *env,
+				   struct mdd_device *m)
 {
-	struct mdd_device *mdd = mdo2mdd(obj);
-	struct mdd_object *root;
-	int rc = 0;
-
-	/*
-	 * .lustre returns default striping which is 'stored'
-	 * in the root
-	 */
-	if (strcmp(name, XATTR_NAME_LOV) == 0) {
-		root = mdd_object_find(env, mdd, &mdd->mdd_local_root_fid);
-		if (IS_ERR(root))
-			return PTR_ERR(root);
-		rc = mdo_xattr_get(env, root, buf, name,
-				   mdd_object_capa(env, md2mdd_obj(obj)));
-		mdd_object_put(env, root);
+	if (m->mdd_dot_lustre_objs.mdd_lpf != NULL) {
+		mdd_object_put(env, m->mdd_dot_lustre_objs.mdd_lpf);
+		m->mdd_dot_lustre_objs.mdd_lpf = NULL;
+	}
+	if (m->mdd_dot_lustre_objs.mdd_obf != NULL) {
+		mdd_object_put(env, m->mdd_dot_lustre_objs.mdd_obf);
+		m->mdd_dot_lustre_objs.mdd_obf = NULL;
+	}
+	if (m->mdd_dot_lustre != NULL) {
+		mdd_object_put(env, m->mdd_dot_lustre);
+		m->mdd_dot_lustre = NULL;
 	}
-
-	return rc;
-}
-
-static int obf_xattr_set(const struct lu_env *env,
-			 struct md_object *obj,
-			 const struct lu_buf *buf, const char *name,
-			 int fl)
-{
-	return -EPERM;
 }
 
-static int obf_xattr_del(const struct lu_env *env,
-			 struct md_object *obj,
-			 const char *name)
+/** Setup ".lustre" directory object */
+static int mdd_dot_lustre_setup(const struct lu_env *env, struct mdd_device *m)
 {
-	return -EPERM;
-}
+	struct md_object	*mdo;
+	struct lu_fid		 fid;
+	int			 rc;
 
-static int obf_mdd_open(const struct lu_env *env, struct md_object *obj,
-                        int flags)
-{
-        struct mdd_object *mdd_obj = md2mdd_obj(obj);
+	ENTRY;
+	/* Create ".lustre" directory in ROOT. */
+	fid = LU_DOT_LUSTRE_FID;
+	rc = mdd_local_file_create(env, m, &m->mdd_root_fid,
+				   dot_lustre_name,
+				   S_IFDIR | S_IRUGO | S_IWUSR | S_IXUGO,
+				   &fid);
+	if (rc < 0)
+		RETURN(rc);
+	mdo = mdo_locate(env, &m->mdd_md_dev, &fid);
+	if (IS_ERR(mdo))
+		RETURN(PTR_ERR(mdo));
+	LASSERT(lu_object_exists(&mdo->mo_lu));
 
-        mdd_write_lock(env, mdd_obj, MOR_TGT_CHILD);
-        mdd_obj->mod_count++;
-        mdd_write_unlock(env, mdd_obj);
+	m->mdd_dot_lustre = md2mdd_obj(mdo);
 
-        return 0;
-}
+	rc = mdd_obf_setup(env, m);
+	if (rc) {
+		CERROR("%s: error initializing \"fid\" object: rc = %d.\n",
+		       mdd2obd_dev(m)->obd_name, rc);
+		GOTO(out, rc);
+	}
 
-static int obf_mdd_close(const struct lu_env *env, struct md_object *obj,
-                         struct md_attr *ma, int mode)
-{
-        struct mdd_object *mdd_obj = md2mdd_obj(obj);
+	rc = mdd_lpf_setup(env, m);
+	if (rc != 0) {
+		CERROR("%s: error initializing \"lost+found\": rc = %d.\n",
+		       mdd2obd_dev(m)->obd_name, rc);
+		GOTO(out, rc);
+	}
 
-        mdd_write_lock(env, mdd_obj, MOR_TGT_CHILD);
-        mdd_obj->mod_count--;
-        mdd_write_unlock(env, mdd_obj);
+	RETURN(0);
 
-        return 0;
-}
+out:
+	mdd_dot_lustre_cleanup(env, m);
 
-/** Nothing to list in "fid" directory */
-static int obf_mdd_readpage(const struct lu_env *env, struct md_object *obj,
-                            const struct lu_rdpg *rdpg)
-{
-        return -EPERM;
+	return rc;
 }
 
-static int obf_path(const struct lu_env *env, struct md_object *obj,
-                    char *path, int pathlen, __u64 *recno, int *linkno)
-{
-        return -ENOSYS;
-}
 
-static struct md_object_operations mdd_obf_obj_ops = {
-	.moo_attr_get    = obf_attr_get,
-	.moo_attr_set    = obf_attr_set,
-	.moo_xattr_list  = obf_xattr_list,
-	.moo_xattr_get   = obf_xattr_get,
-	.moo_xattr_set   = obf_xattr_set,
-	.moo_xattr_del   = obf_xattr_del,
-	.moo_open        = obf_mdd_open,
-	.moo_close       = obf_mdd_close,
-	.moo_readpage    = obf_mdd_readpage,
-	.moo_path        = obf_path
-};
+static struct llog_operations hsm_actions_logops;
 
 /**
- * Lookup method for "fid" object. Only filenames with correct SEQ:OID format
- * are valid. We also check if object with passed fid exists or not.
+ * set llog methods and create LLOG_AGENT_ORIG_CTXT llog
+ * object in obd_device
  */
-static int obf_lookup(const struct lu_env *env, struct md_object *p,
-                      const struct lu_name *lname, struct lu_fid *f,
-                      struct md_op_spec *spec)
+static int mdd_hsm_actions_llog_init(const struct lu_env *env,
+				     struct mdd_device *m)
 {
-        char *name = (char *)lname->ln_name;
-        struct mdd_device *mdd = mdo2mdd(p);
-        struct mdd_object *child;
-        int rc = 0;
-
-        while (*name == '[')
-                name++;
+	struct obd_device	*obd = mdd2obd_dev(m);
+	struct llog_ctxt	*ctxt = NULL;
+	int			 rc;
+	ENTRY;
 
-        sscanf(name, SFID, RFID(f));
-        if (!fid_is_sane(f)) {
-		CWARN("%s: bad FID format [%s], should be "DFID"\n",
-		      mdd2obd_dev(mdd)->obd_name, lname->ln_name,
-		      (__u64)FID_SEQ_NORMAL, 1, 0);
-                GOTO(out, rc = -EINVAL);
-        }
+	OBD_SET_CTXT_MAGIC(&obd->obd_lvfs_ctxt);
+	obd->obd_lvfs_ctxt.dt = m->mdd_bottom;
 
-	if (!fid_is_norm(f)) {
-		CWARN("%s: "DFID" is invalid, sequence should be "
-		      ">= "LPX64"\n", mdd2obd_dev(mdd)->obd_name, PFID(f),
-		      (__u64)FID_SEQ_NORMAL);
-		GOTO(out, rc = -EINVAL);
+	rc = llog_setup(env, obd, &obd->obd_olg, LLOG_AGENT_ORIG_CTXT,
+			obd, &hsm_actions_logops);
+	if (rc) {
+		CERROR("%s: hsm actions llog setup failed: rc = %d\n",
+			obd->obd_name, rc);
+		RETURN(rc);
 	}
 
-        /* Check if object with this fid exists */
-        child = mdd_object_find(env, mdd, f);
-        if (child == NULL)
-                GOTO(out, rc = 0);
-        if (IS_ERR(child))
-                GOTO(out, rc = PTR_ERR(child));
-
-        if (mdd_object_exists(child) == 0)
-                rc = -ENOENT;
-
-        mdd_object_put(env, child);
+	ctxt = llog_get_context(obd, LLOG_AGENT_ORIG_CTXT);
+	LASSERT(ctxt);
 
-out:
-        return rc;
-}
+	rc = llog_open_create(env, ctxt, &ctxt->loc_handle, NULL,
+			      HSM_ACTIONS);
+	if (rc) {
+		CERROR("%s: hsm actions llog open_create failed: rc = %d\n",
+			obd->obd_name, rc);
+		GOTO(out_cleanup, rc);
+	}
 
-static int obf_create(const struct lu_env *env, struct md_object *pobj,
-                      const struct lu_name *lname, struct md_object *child,
-                      struct md_op_spec *spec, struct md_attr* ma)
-{
-        return -EPERM;
-}
+	rc = llog_cat_init_and_process(env, ctxt->loc_handle);
+	if (rc)
+		GOTO(out_close, rc);
 
-static int obf_rename(const struct lu_env *env,
-                      struct md_object *src_pobj, struct md_object *tgt_pobj,
-                      const struct lu_fid *lf, const struct lu_name *lsname,
-                      struct md_object *tobj, const struct lu_name *ltname,
-                      struct md_attr *ma)
-{
-        return -EPERM;
-}
+	llog_ctxt_put(ctxt);
+	RETURN(0);
 
-static int obf_link(const struct lu_env *env, struct md_object *tgt_obj,
-                    struct md_object *src_obj, const struct lu_name *lname,
-                    struct md_attr *ma)
-{
-        return -EPERM;
-}
+out_close:
+	llog_cat_close(env, ctxt->loc_handle);
+	ctxt->loc_handle = NULL;
+out_cleanup:
+	llog_cleanup(env, ctxt);
 
-static int obf_unlink(const struct lu_env *env, struct md_object *pobj,
-                      struct md_object *cobj, const struct lu_name *lname,
-                      struct md_attr *ma)
-{
-        return -EPERM;
+	return rc;
 }
 
-static struct md_dir_operations mdd_obf_dir_ops = {
-        .mdo_lookup = obf_lookup,
-        .mdo_create = obf_create,
-        .mdo_rename = obf_rename,
-        .mdo_link   = obf_link,
-        .mdo_unlink = obf_unlink
-};
-
 /**
- * Create special in-memory "fid" object for open-by-fid.
+ * cleanup the context created by llog_setup_named()
  */
-static int mdd_obf_setup(const struct lu_env *env, struct mdd_device *m)
+static int mdd_hsm_actions_llog_fini(const struct lu_env *env,
+				     struct mdd_device *m)
 {
-        struct mdd_object *mdd_obf;
-        struct lu_object *obf_lu_obj;
-        int rc = 0;
-
-        m->mdd_dot_lustre_objs.mdd_obf = mdd_object_find(env, m,
-                                                         &LU_OBF_FID);
-        if (m->mdd_dot_lustre_objs.mdd_obf == NULL ||
-            IS_ERR(m->mdd_dot_lustre_objs.mdd_obf))
-                GOTO(out, rc = -ENOENT);
-
-        mdd_obf = m->mdd_dot_lustre_objs.mdd_obf;
-        mdd_obf->mod_obj.mo_dir_ops = &mdd_obf_dir_ops;
-        mdd_obf->mod_obj.mo_ops = &mdd_obf_obj_ops;
-        /* Don't allow objects to be created in "fid" dir */
-        mdd_obf->mod_flags |= IMMUTE_OBJ;
+	struct obd_device	*obd = mdd2obd_dev(m);
+	struct llog_ctxt	*lctxt;
+	ENTRY;
 
-        obf_lu_obj = mdd2lu_obj(mdd_obf);
-        obf_lu_obj->lo_header->loh_attr |= (LOHA_EXISTS | S_IFDIR);
+	lctxt = llog_get_context(obd, LLOG_AGENT_ORIG_CTXT);
+	if (lctxt) {
+		llog_cat_close(env, lctxt->loc_handle);
+		lctxt->loc_handle = NULL;
+		llog_cleanup(env, lctxt);
+	}
 
-out:
-        return rc;
+	RETURN(0);
 }
 
-/** Setup ".lustre" directory object */
-static int mdd_dot_lustre_setup(const struct lu_env *env, struct mdd_device *m)
+static void mdd_device_shutdown(const struct lu_env *env, struct mdd_device *m,
+				struct lustre_cfg *cfg)
 {
-        struct dt_object *dt_dot_lustre;
-        struct lu_fid *fid = &mdd_env_info(env)->mti_fid;
-        int rc;
-	ENTRY;
-
-        rc = create_dot_lustre_dir(env, m);
-        if (rc)
-                return rc;
+	lfsck_degister(env, m->mdd_bottom);
+	mdd_hsm_actions_llog_fini(env, m);
+	mdd_changelog_fini(env, m);
+	orph_index_fini(env, m);
+	mdd_dot_lustre_cleanup(env, m);
+	if (m->mdd_los != NULL)
+		local_oid_storage_fini(env, m->mdd_los);
+	lu_site_purge(env, mdd2lu_dev(m)->ld_site, ~0);
 
-        dt_dot_lustre = dt_store_open(env, m->mdd_child, mdd_root_dir_name,
-                                      dot_lustre_name, fid);
-        if (IS_ERR(dt_dot_lustre)) {
-                rc = PTR_ERR(dt_dot_lustre);
-                GOTO(out, rc);
-        }
-
-        /* references are released in mdd_device_shutdown() */
-        m->mdd_dot_lustre = lu2mdd_obj(lu_object_locate(dt_dot_lustre->do_lu.lo_header,
-                                                        &mdd_device_type));
-
-        m->mdd_dot_lustre->mod_obj.mo_dir_ops = &mdd_dot_lustre_dir_ops;
-        m->mdd_dot_lustre->mod_obj.mo_ops = &mdd_dot_lustre_obj_ops;
-
-        rc = mdd_obf_setup(env, m);
-        if (rc)
-                CERROR("Error initializing \"fid\" object - %d.\n", rc);
-
-out:
-        RETURN(rc);
+	if (m->mdd_child_exp)
+		obd_disconnect(m->mdd_child_exp);
 }
 
 static int mdd_process_config(const struct lu_env *env,
@@ -1126,14 +896,12 @@ static int mdd_process_config(const struct lu_env *env,
                 rc = next->ld_ops->ldo_process_config(env, next, cfg);
                 if (rc)
                         GOTO(out, rc);
-                dt->dd_ops->dt_conf_get(env, dt, &m->mdd_dt_conf);
+		dt_conf_get(env, dt, &m->mdd_dt_conf);
                 break;
         case LCFG_CLEANUP:
-		mdd_lfsck_cleanup(env, m);
-		mdd_changelog_fini(env, m);
 		rc = next->ld_ops->ldo_process_config(env, next, cfg);
 		lu_dev_del_linkage(d->ld_site, d);
-                mdd_device_shutdown(env, m, cfg);
+		mdd_device_shutdown(env, m, cfg);
 		break;
         default:
                 rc = next->ld_ops->ldo_process_config(env, next, cfg);
@@ -1161,63 +929,139 @@ static int mdd_recovery_complete(const struct lu_env *env,
         RETURN(rc);
 }
 
+int mdd_local_file_create(const struct lu_env *env, struct mdd_device *mdd,
+			  const struct lu_fid *pfid, const char *name, __u32 mode,
+			  struct lu_fid *fid)
+{
+	struct dt_object	*parent, *dto;
+	int			 rc;
+
+	ENTRY;
+
+	LASSERT(!fid_is_zero(pfid));
+	parent = dt_locate(env, mdd->mdd_bottom, pfid);
+	if (unlikely(IS_ERR(parent)))
+		RETURN(PTR_ERR(parent));
+
+	/* create local file/dir, if @fid is passed then try to use it */
+	if (fid_is_zero(fid))
+		dto = local_file_find_or_create(env, mdd->mdd_los, parent,
+						name, mode);
+	else
+		dto = local_file_find_or_create_with_fid(env, mdd->mdd_bottom,
+							 fid, parent, name,
+							 mode);
+	if (IS_ERR(dto))
+		GOTO(out_put, rc = PTR_ERR(dto));
+	*fid = *lu_object_fid(&dto->do_lu);
+	/* since stack is not fully set up the local_storage uses own stack
+	 * and we should drop its object from cache */
+	lu_object_put_nocache(env, &dto->do_lu);
+	EXIT;
+out_put:
+	lu_object_put(env, &parent->do_lu);
+	return 0;
+}
+
+static int mdd_lfsck_out_notify(const struct lu_env *env, void *data,
+				enum lfsck_events event)
+{
+	return 0;
+}
+
 static int mdd_prepare(const struct lu_env *env,
                        struct lu_device *pdev,
                        struct lu_device *cdev)
 {
-        struct mdd_device *mdd = lu2mdd_dev(cdev);
-        struct lu_device *next = &mdd->mdd_child->dd_lu_dev;
-        struct dt_object *root;
-        struct lu_fid     fid;
-        int rc;
+	struct mdd_device	*mdd = lu2mdd_dev(cdev);
+	struct lu_device	*next = &mdd->mdd_child->dd_lu_dev;
+	struct lu_fid		 fid;
+	int			 rc;
 
-        ENTRY;
-        rc = next->ld_ops->ldo_prepare(env, cdev, next);
-        if (rc)
-                GOTO(out, rc);
+	ENTRY;
+
+	rc = next->ld_ops->ldo_prepare(env, cdev, next);
+	if (rc)
+		RETURN(rc);
+
+	/* Setup local dirs */
+	fid.f_seq = FID_SEQ_LOCAL_NAME;
+	fid.f_oid = 1;
+	fid.f_ver = 0;
+	rc = local_oid_storage_init(env, mdd->mdd_bottom, &fid,
+				    &mdd->mdd_los);
+	if (rc)
+		RETURN(rc);
 
 	rc = dt_root_get(env, mdd->mdd_child, &mdd->mdd_local_root_fid);
-	if (rc != 0)
-		GOTO(out, rc);
+	if (rc < 0)
+		GOTO(out_los, rc);
 
-        root = dt_store_open(env, mdd->mdd_child, "", mdd_root_dir_name,
-                             &mdd->mdd_root_fid);
-        if (!IS_ERR(root)) {
-                LASSERT(root != NULL);
-                lu_object_put(env, &root->do_lu);
-                rc = orph_index_init(env, mdd);
-        } else {
-                rc = PTR_ERR(root);
-        }
-        if (rc)
-                GOTO(out, rc);
+	lu_root_fid(&fid);
+	if (mdd_seq_site(mdd)->ss_node_id == 0) {
+		rc = mdd_local_file_create(env, mdd, &mdd->mdd_local_root_fid,
+					   mdd_root_dir_name, S_IFDIR |
+					   S_IRUGO | S_IWUSR | S_IXUGO, &fid);
+		if (rc != 0) {
+			CERROR("%s: create root fid failed: rc = %d\n",
+			       mdd2obd_dev(mdd)->obd_name, rc);
+			GOTO(out_los, rc);
+		}
 
-        rc = mdd_dot_lustre_setup(env, mdd);
-        if (rc) {
-                CERROR("Error(%d) initializing .lustre objects\n", rc);
-                GOTO(out, rc);
-        }
+		mdd->mdd_root_fid = fid;
+		rc = mdd_dot_lustre_setup(env, mdd);
+		if (rc != 0) {
+			CERROR("%s: initializing .lustre failed: rc = %d\n",
+			       mdd2obd_dev(mdd)->obd_name, rc);
+			GOTO(out_los, rc);
+		}
 
-        /* we use capa file to declare llog changes,
-         * will be fixed with new llog in 2.3 */
-        root = dt_store_open(env, mdd->mdd_child, "", CAPA_KEYS, &fid);
-	if (IS_ERR(root))
-		GOTO(out, rc = PTR_ERR(root));
+		rc = mdd_compat_fixes(env, mdd);
+		if (rc != 0)
+			GOTO(out_dot, rc);
+	} else {
+		/* Normal client usually send root access to MDT0 directly,
+		 * the root FID on non-MDT0 will only be used by echo client. */
+		mdd->mdd_root_fid = fid;
+	}
 
-	mdd->mdd_capa = root;
+	rc = orph_index_init(env, mdd);
+	if (rc < 0)
+		GOTO(out_dot, rc);
 
 	rc = mdd_changelog_init(env, mdd);
-	if (rc != 0)
-		GOTO(out, rc);
+	if (rc != 0) {
+		CERROR("%s: failed to initialize changelog: rc = %d\n",
+		       mdd2obd_dev(mdd)->obd_name, rc);
+		GOTO(out_orph, rc);
+	}
 
-	rc = mdd_lfsck_setup(env, mdd);
+	rc = mdd_hsm_actions_llog_init(env, mdd);
 	if (rc != 0)
+		GOTO(out_changelog, rc);
+
+	rc = lfsck_register(env, mdd->mdd_bottom, mdd->mdd_child,
+			    mdd2obd_dev(mdd), mdd_lfsck_out_notify,
+			    mdd, true);
+	if (rc != 0) {
 		CERROR("%s: failed to initialize lfsck: rc = %d\n",
 		       mdd2obd_dev(mdd)->obd_name, rc);
+		GOTO(out_hsm, rc);
+	}
+	RETURN(0);
+out_hsm:
+	mdd_hsm_actions_llog_fini(env, mdd);
+out_changelog:
+	mdd_changelog_fini(env, mdd);
+out_orph:
+	orph_index_fini(env, mdd);
+out_dot:
+	if (mdd_seq_site(mdd)->ss_node_id == 0)
+		mdd_dot_lustre_cleanup(env, mdd);
+out_los:
+	local_oid_storage_fini(env, mdd->mdd_los);
+	mdd->mdd_los = NULL;
 
-	GOTO(out, rc);
-
-out:
 	return rc;
 }
 
@@ -1228,33 +1072,32 @@ const struct lu_device_operations mdd_lu_ops = {
         .ldo_prepare           = mdd_prepare,
 };
 
-/*
- * No permission check is needed.
- */
 static int mdd_root_get(const struct lu_env *env,
-                        struct md_device *m, struct lu_fid *f)
+			struct md_device *m, struct lu_fid *f)
 {
-        struct mdd_device *mdd = lu2mdd_dev(&m->md_lu_dev);
+	struct mdd_device *mdd = lu2mdd_dev(&m->md_lu_dev);
 
-        ENTRY;
-        *f = mdd->mdd_root_fid;
-        RETURN(0);
+	ENTRY;
+	*f = mdd->mdd_root_fid;
+	RETURN(0);
 }
 
 /*
  * No permission check is needed.
  */
 static int mdd_statfs(const struct lu_env *env, struct md_device *m,
-                      struct obd_statfs *sfs)
+		      struct obd_statfs *sfs)
 {
-        struct mdd_device *mdd = lu2mdd_dev(&m->md_lu_dev);
-        int rc;
+	struct mdd_device *mdd = lu2mdd_dev(&m->md_lu_dev);
+	int rc;
 
-        ENTRY;
+	ENTRY;
 
-        rc = mdd_child_ops(mdd)->dt_statfs(env, mdd->mdd_child, sfs);
+	rc = mdd_child_ops(mdd)->dt_statfs(env, mdd->mdd_child, sfs);
 
-        RETURN(rc);
+	sfs->os_namelen = min_t(__u32, sfs->os_namelen, NAME_MAX);
+
+	RETURN(rc);
 }
 
 /*
@@ -1275,6 +1118,17 @@ static int mdd_init_capa_ctxt(const struct lu_env *env, struct md_device *m,
         RETURN(rc);
 }
 
+static int mdd_maxeasize_get(const struct lu_env *env, struct md_device *m,
+				int *easize)
+{
+	struct mdd_device *mdd = lu2mdd_dev(&m->md_lu_dev);
+	ENTRY;
+
+	*easize = mdd->mdd_dt_conf.ddp_max_ea_size;
+
+	RETURN(0);
+}
+
 static int mdd_update_capa_key(const struct lu_env *env,
                                struct md_device *m,
                                struct lustre_capa_key *key)
@@ -1298,7 +1152,7 @@ static struct lu_device *mdd_device_free(const struct lu_env *env,
 	struct mdd_device *m = lu2mdd_dev(lu);
 	ENTRY;
 
-	LASSERT(cfs_atomic_read(&lu->ld_ref) == 0);
+	LASSERT(atomic_read(&lu->ld_ref) == 0);
 	md_device_fini(&m->mdd_md_dev);
 	OBD_FREE_PTR(m);
 	RETURN(NULL);
@@ -1378,15 +1232,26 @@ static int mdd_obd_disconnect(struct obd_export *exp)
 	RETURN(rc);
 }
 
-static int mdd_obd_health_check(const struct lu_env *env,
-				struct obd_device *obd)
+static int mdd_obd_get_info(const struct lu_env *env, struct obd_export *exp,
+			    __u32 keylen, void *key, __u32 *vallen, void *val,
+			    struct lov_stripe_md *lsm)
 {
-	struct mdd_device *mdd = lu2mdd_dev(obd->obd_lu_dev);
-	int		   rc;
-	ENTRY;
+	int rc = -EINVAL;
+
+	if (KEY_IS(KEY_OSP_CONNECTED)) {
+		struct obd_device	*obd = exp->exp_obd;
+		struct mdd_device	*mdd;
+
+		if (!obd->obd_set_up || obd->obd_stopping)
+			RETURN(-EAGAIN);
+
+		mdd = lu2mdd_dev(obd->obd_lu_dev);
+		LASSERT(mdd);
+		rc = obd_get_info(env, mdd->mdd_child_exp, keylen, key, vallen,
+				  val, lsm);
+		RETURN(rc);
+	}
 
-	LASSERT(mdd);
-	rc = obd_health_check(env, mdd->mdd_child_exp->exp_obd);
 	RETURN(rc);
 }
 
@@ -1394,30 +1259,9 @@ static struct obd_ops mdd_obd_device_ops = {
 	.o_owner	= THIS_MODULE,
 	.o_connect	= mdd_obd_connect,
 	.o_disconnect	= mdd_obd_disconnect,
-	.o_health_check	= mdd_obd_health_check
+	.o_get_info     = mdd_obd_get_info,
 };
 
-/*
- * context key constructor/destructor:
- * mdd_capainfo_key_init, mdd_capainfo_key_fini
- */
-LU_KEY_INIT_FINI(mdd_capainfo, struct md_capainfo);
-
-struct lu_context_key mdd_capainfo_key = {
-        .lct_tags = LCT_SESSION,
-        .lct_init = mdd_capainfo_key_init,
-        .lct_fini = mdd_capainfo_key_fini
-};
-
-struct md_capainfo *md_capainfo(const struct lu_env *env)
-{
-        /* NB, in mdt_init0 */
-        if (env->le_ses == NULL)
-                return NULL;
-        return lu_context_key_get(env->le_ses, &mdd_capainfo_key);
-}
-EXPORT_SYMBOL(md_capainfo);
-
 static int mdd_changelog_user_register(const struct lu_env *env,
 				       struct mdd_device *mdd, int *id)
 {
@@ -1469,7 +1313,7 @@ struct mdd_changelog_user_data {
         __u32 mcud_id;
         __u32 mcud_minid;  /**< user id with lowest rec reference */
         __u32 mcud_usercount;
-        int   mcud_found:1;
+	unsigned int mcud_found:1;
 };
 #define MCUD_UNREGISTER -1LL
 
@@ -1629,16 +1473,13 @@ static int mdd_iocontrol(const struct lu_env *env, struct md_device *m,
                 RETURN(0);
         }
 	case OBD_IOC_START_LFSCK: {
-		rc = mdd_lfsck_start(env, &mdd->mdd_lfsck,
-				     (struct lfsck_start *)karg);
+		rc = lfsck_start(env, mdd->mdd_bottom,
+				 (struct lfsck_start_param *)karg);
 		RETURN(rc);
 	}
 	case OBD_IOC_STOP_LFSCK: {
-		rc = mdd_lfsck_stop(env, &mdd->mdd_lfsck, false);
-		RETURN(rc);
-	}
-	case OBD_IOC_PAUSE_LFSCK: {
-		rc = mdd_lfsck_stop(env, &mdd->mdd_lfsck, true);
+		rc = lfsck_stop(env, mdd->mdd_bottom,
+				(struct lfsck_stop *)karg);
 		RETURN(rc);
 	}
         }
@@ -1670,15 +1511,16 @@ static int mdd_iocontrol(const struct lu_env *env, struct md_device *m,
 }
 
 /* type constructor/destructor: mdd_type_init, mdd_type_fini */
-LU_TYPE_INIT_FINI(mdd, &mdd_thread_key, &mdd_capainfo_key);
+LU_TYPE_INIT_FINI(mdd, &mdd_thread_key);
 
 const struct md_device_operations mdd_ops = {
-        .mdo_statfs         = mdd_statfs,
-        .mdo_root_get       = mdd_root_get,
-        .mdo_init_capa_ctxt = mdd_init_capa_ctxt,
-        .mdo_update_capa_key= mdd_update_capa_key,
-        .mdo_llog_ctxt_get  = mdd_llog_ctxt_get,
-        .mdo_iocontrol      = mdd_iocontrol,
+	.mdo_statfs         = mdd_statfs,
+	.mdo_root_get	    = mdd_root_get,
+	.mdo_init_capa_ctxt = mdd_init_capa_ctxt,
+	.mdo_update_capa_key= mdd_update_capa_key,
+	.mdo_llog_ctxt_get  = mdd_llog_ctxt_get,
+	.mdo_iocontrol      = mdd_iocontrol,
+	.mdo_maxeasize_get  = mdd_maxeasize_get,
 };
 
 static struct lu_device_type_operations mdd_device_type_ops = {
@@ -1708,11 +1550,9 @@ static void mdd_key_fini(const struct lu_context *ctx,
                          struct lu_context_key *key, void *data)
 {
         struct mdd_thread_info *info = data;
-        if (info->mti_max_lmm != NULL)
-                OBD_FREE(info->mti_max_lmm, info->mti_max_lmm_size);
-        if (info->mti_max_cookie != NULL)
-                OBD_FREE(info->mti_max_cookie, info->mti_max_cookie_size);
-        mdd_buf_put(&info->mti_big_buf);
+
+	lu_buf_free(&info->mti_big_buf);
+	lu_buf_free(&info->mti_link_buf);
 
         OBD_FREE_PTR(info);
 }
@@ -1720,32 +1560,6 @@ static void mdd_key_fini(const struct lu_context *ctx,
 /* context key: mdd_thread_key */
 LU_CONTEXT_KEY_DEFINE(mdd, LCT_MD_THREAD);
 
-static struct lu_local_obj_desc llod_capa_key = {
-        .llod_name      = CAPA_KEYS,
-        .llod_oid       = MDD_CAPA_KEYS_OID,
-        .llod_is_index  = 0,
-};
-
-static struct lu_local_obj_desc llod_mdd_orphan = {
-        .llod_name      = orph_index_name,
-        .llod_oid       = MDD_ORPHAN_OID,
-        .llod_is_index  = 1,
-        .llod_feat      = &dt_directory_features,
-};
-
-static struct lu_local_obj_desc llod_mdd_root = {
-        .llod_name      = mdd_root_dir_name,
-        .llod_oid       = MDD_ROOT_INDEX_OID,
-        .llod_is_index  = 1,
-        .llod_feat      = &dt_directory_features,
-};
-
-static struct lu_local_obj_desc llod_lfsck_bookmark = {
-	.llod_name      = lfsck_bookmark_name,
-	.llod_oid       = LFSCK_BOOKMARK_OID,
-	.llod_is_index  = 0,
-};
-
 static int __init mdd_mod_init(void)
 {
 	struct lprocfs_static_vars lvars;
@@ -1762,13 +1576,15 @@ static int __init mdd_mod_init(void)
 	changelog_orig_logops.lop_add = llog_cat_add_rec;
 	changelog_orig_logops.lop_declare_add = llog_cat_declare_add_rec;
 
-	llo_local_obj_register(&llod_capa_key);
-	llo_local_obj_register(&llod_mdd_orphan);
-	llo_local_obj_register(&llod_mdd_root);
-	llo_local_obj_register(&llod_lfsck_bookmark);
+	hsm_actions_logops = llog_osd_ops;
+	hsm_actions_logops.lop_add = llog_cat_add_rec;
+	hsm_actions_logops.lop_declare_add = llog_cat_declare_add_rec;
 
-	rc = class_register_type(&mdd_obd_device_ops, NULL, lvars.module_vars,
-				 LUSTRE_MDD_NAME, &mdd_device_type);
+	rc = class_register_type(&mdd_obd_device_ops, NULL, NULL,
+#ifndef HAVE_ONLY_PROCFS_SEQ
+				lvars.module_vars,
+#endif
+				LUSTRE_MDD_NAME, &mdd_device_type);
 	if (rc)
 		lu_kmem_fini(mdd_caches);
 	return rc;
@@ -1776,11 +1592,6 @@ static int __init mdd_mod_init(void)
 
 static void __exit mdd_mod_exit(void)
 {
-	llo_local_obj_unregister(&llod_capa_key);
-	llo_local_obj_unregister(&llod_mdd_orphan);
-	llo_local_obj_unregister(&llod_mdd_root);
-	llo_local_obj_unregister(&llod_lfsck_bookmark);
-
 	class_unregister_type(LUSTRE_MDD_NAME);
 	lu_kmem_fini(mdd_caches);
 }