X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fofd%2Fofd_obd.c;h=cd9f673d985fc8d8cae05d8465cc22d5ff374a58;hp=da99fb00d16d89a29546c16f7f63efc61593cbb0;hb=e9389613eb29297f7b5a6b6cd896bafc7a5551f8;hpb=83ae3e2e5b9713822ea4889d832915e791801d90

diff --git a/lustre/ofd/ofd_obd.c b/lustre/ofd/ofd_obd.c
index da99fb0..cd9f673 100644
--- a/lustre/ofd/ofd_obd.c
+++ b/lustre/ofd/ofd_obd.c
@@ -23,7 +23,7 @@
  * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  *
- * Copyright (c) 2012, 2014 Intel Corporation.
+ * Copyright (c) 2012, 2016, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -122,6 +122,10 @@ out:
  * connect flags from the obd_connect_data::ocd_connect_flags field of the
  * reply. \see tgt_connect().
  *
+ * Before 2.7.50 clients will send a struct obd_connect_data_v1 rather than a
+ * full struct obd_connect_data. So care must be taken when accessing fields
+ * that are not present in struct obd_connect_data_v1. See LU-16.
+ *
  * \param[in] env		execution environment
  * \param[in] exp		the obd_export associated with this
  *				client/target pair
@@ -145,7 +149,7 @@ static int ofd_parse_connect_data(const struct lu_env *env,
 	if (!data)
 		RETURN(0);
 
-	CDEBUG(D_RPCTRACE, "%s: cli %s/%p ocd_connect_flags: "LPX64
+	CDEBUG(D_RPCTRACE, "%s: cli %s/%p ocd_connect_flags: %#llx"
 	       " ocd_version: %x ocd_grant: %d ocd_index: %u"
 	       " ocd_group %u\n",
 	       exp->exp_obd->obd_name, exp->exp_client_uuid.uuid, exp,
@@ -164,6 +168,10 @@ static int ofd_parse_connect_data(const struct lu_env *env,
 	fed->fed_group = data->ocd_group;
 
 	data->ocd_connect_flags &= OST_CONNECT_SUPPORTED;
+
+	if (data->ocd_connect_flags & OBD_CONNECT_FLAGS2)
+		data->ocd_connect_flags2 &= OST_CONNECT_SUPPORTED2;
+
 	data->ocd_version = LUSTRE_VERSION_CODE;
 
 	/* Kindly make sure the SKIP_ORPHAN flag is from MDS. */
@@ -173,18 +181,46 @@ static int ofd_parse_connect_data(const struct lu_env *env,
 	else if (data->ocd_connect_flags & OBD_CONNECT_SKIP_ORPHAN)
 		RETURN(-EPROTO);
 
-	if (ofd_grant_param_supp(exp)) {
-		exp->exp_filter_data.fed_pagesize = data->ocd_blocksize;
-		/* ocd_{blocksize,inodespace} are log2 values */
-		data->ocd_blocksize  = ofd->ofd_blockbits;
-		data->ocd_inodespace = ofd->ofd_dt_conf.ddp_inodespace;
-		/* ocd_grant_extent is in 1K blocks */
-		data->ocd_grant_extent = ofd->ofd_dt_conf.ddp_grant_frag >> 10;
+	/* Determine optimal brw size before calculating grant */
+	if (OBD_FAIL_CHECK(OBD_FAIL_OST_BRW_SIZE)) {
+		data->ocd_brw_size = 65536;
+	} else if (OCD_HAS_FLAG(data, BRW_SIZE)) {
+		if (data->ocd_brw_size > ofd->ofd_brw_size)
+			data->ocd_brw_size = ofd->ofd_brw_size;
+		if (data->ocd_brw_size == 0) {
+			CERROR("%s: cli %s/%p ocd_connect_flags: %#llx"
+			       " ocd_version: %x ocd_grant: %d ocd_index: %u "
+			       "ocd_brw_size is unexpectedly zero, "
+			       "network data corruption?"
+			       "Refusing connection of this client\n",
+			       exp->exp_obd->obd_name,
+			       exp->exp_client_uuid.uuid,
+			       exp, data->ocd_connect_flags, data->ocd_version,
+			       data->ocd_grant, data->ocd_index);
+			RETURN(-EPROTO);
+		}
+	}
+
+	if (OCD_HAS_FLAG(data, GRANT_PARAM)) {
+		struct dt_device_param *ddp = &ofd->ofd_lut.lut_dt_conf;
+
+		/* client is reporting its page size, for future use */
+		exp->exp_target_data.ted_pagebits = data->ocd_grant_blkbits;
+		data->ocd_grant_blkbits  = ofd->ofd_lut.lut_tgd.tgd_blockbits;
+		/* ddp_inodespace may not be power-of-two value, eg. for ldiskfs
+		 * it's LDISKFS_DIR_REC_LEN(20) = 28. */
+		data->ocd_grant_inobits = fls(ddp->ddp_inodespace - 1);
+		/* ocd_grant_tax_kb is in 1K byte blocks */
+		data->ocd_grant_tax_kb = ddp->ddp_extent_tax >> 10;
+		data->ocd_grant_max_blks = ddp->ddp_max_extent_blks;
 	}
 
-	if (data->ocd_connect_flags & OBD_CONNECT_GRANT)
-		data->ocd_grant = ofd_grant_connect(env, exp, data->ocd_grant,
-						    new_connection);
+	if (OCD_HAS_FLAG(data, GRANT)) {
+		/* Save connect_data we have so far because tgt_grant_connect()
+		 * uses it to calculate grant. */
+		exp->exp_connect_data = *data;
+		tgt_grant_connect(env, exp, data, new_connection);
+	}
 
 	if (data->ocd_connect_flags & OBD_CONNECT_INDEX) {
 		struct lr_server_data *lsd = &ofd->ofd_lut.lut_lsd;
@@ -202,29 +238,11 @@ static int ofd_parse_connect_data(const struct lu_env *env,
 		if (!(lsd->lsd_feature_compat & OBD_COMPAT_OST)) {
 			/* this will only happen on the first connect */
 			lsd->lsd_feature_compat |= OBD_COMPAT_OST;
-			/* sync is not needed here as lut_client_add will
+			/* sync is not needed here as tgt_client_new will
 			 * set exp_need_sync flag */
 			tgt_server_data_update(env, &ofd->ofd_lut, 0);
 		}
 	}
-	if (OBD_FAIL_CHECK(OBD_FAIL_OST_BRW_SIZE)) {
-		data->ocd_brw_size = 65536;
-	} else if (data->ocd_connect_flags & OBD_CONNECT_BRW_SIZE) {
-		data->ocd_brw_size = min(data->ocd_brw_size,
-					 (__u32)DT_MAX_BRW_SIZE);
-		if (data->ocd_brw_size == 0) {
-			CERROR("%s: cli %s/%p ocd_connect_flags: "LPX64
-			       " ocd_version: %x ocd_grant: %d ocd_index: %u "
-			       "ocd_brw_size is unexpectedly zero, "
-			       "network data corruption?"
-			       "Refusing connection of this client\n",
-			       exp->exp_obd->obd_name,
-			       exp->exp_client_uuid.uuid,
-			       exp, data->ocd_connect_flags, data->ocd_version,
-			       data->ocd_grant, data->ocd_index);
-			RETURN(-EPROTO);
-		}
-	}
 
 	if (data->ocd_connect_flags & OBD_CONNECT_CKSUM) {
 		__u32 cksum_types = data->ocd_cksum_types;
@@ -232,7 +250,7 @@ static int ofd_parse_connect_data(const struct lu_env *env,
 		/* The client set in ocd_cksum_types the checksum types it
 		 * supports. We have to mask off the algorithms that we don't
 		 * support */
-		data->ocd_cksum_types &= cksum_types_supported_server();
+		data->ocd_cksum_types &= ofd->ofd_cksum_types_supported;
 
 		if (unlikely(data->ocd_cksum_types == 0)) {
 			CERROR("%s: Connect with checksum support but no "
@@ -245,15 +263,15 @@ static int ofd_parse_connect_data(const struct lu_env *env,
 		       "%x\n", exp->exp_obd->obd_name, obd_export_nid2str(exp),
 		       cksum_types, data->ocd_cksum_types);
 	} else {
-		/* This client does not support OBD_CONNECT_CKSUM
-		 * fall back to CRC32 */
+		/* This client does not support OBD_CONNECT_CKSUM.
+		 * Report failure to negotiate checksum at connect */
 		CDEBUG(D_RPCTRACE, "%s: cli %s does not support "
-		       "OBD_CONNECT_CKSUM, CRC32 will be used\n",
+		       "OBD_CONNECT_CKSUM\n",
 		       exp->exp_obd->obd_name, obd_export_nid2str(exp));
 	}
 
 	if (data->ocd_connect_flags & OBD_CONNECT_MAXBYTES)
-		data->ocd_maxbytes = ofd->ofd_dt_conf.ddp_maxbytes;
+		data->ocd_maxbytes = ofd->ofd_lut.lut_dt_conf.ddp_maxbytes;
 
 	if (OCD_HAS_FLAG(data, PINGLESS)) {
 		if (ptlrpc_pinger_suppress_pings()) {
@@ -297,13 +315,17 @@ static int ofd_obd_reconnect(const struct lu_env *env, struct obd_export *exp,
 	if (exp == NULL || obd == NULL || cluuid == NULL)
 		RETURN(-EINVAL);
 
+	rc = nodemap_add_member(*(lnet_nid_t *)client_nid, exp);
+	if (rc != 0 && rc != -EEXIST)
+		RETURN(rc);
+
 	ofd = ofd_dev(obd->obd_lu_dev);
 
 	rc = ofd_parse_connect_data(env, exp, data, false);
 	if (rc == 0)
 		ofd_export_stats_init(ofd, exp, client_nid);
-
-	nodemap_add_member(*(lnet_nid_t *)client_nid, exp);
+	else
+		nodemap_del_member(exp);
 
 	RETURN(rc);
 }
@@ -333,7 +355,6 @@ static int ofd_obd_connect(const struct lu_env *env, struct obd_export **_exp,
 	struct ofd_device	*ofd;
 	struct lustre_handle	 conn = { 0 };
 	int			 rc;
-	lnet_nid_t		*client_nid;
 	ENTRY;
 
 	if (_exp == NULL || obd == NULL || cluuid == NULL)
@@ -348,15 +369,19 @@ static int ofd_obd_connect(const struct lu_env *env, struct obd_export **_exp,
 	exp = class_conn2export(&conn);
 	LASSERT(exp != NULL);
 
+	if (localdata != NULL) {
+		rc = nodemap_add_member(*(lnet_nid_t *)localdata, exp);
+		if (rc != 0 && rc != -EEXIST)
+			GOTO(out, rc);
+	} else {
+		CDEBUG(D_HA, "%s: cannot find nodemap for client %s: "
+		       "nid is null\n", obd->obd_name, cluuid->uuid);
+	}
+
 	rc = ofd_parse_connect_data(env, exp, data, true);
 	if (rc)
 		GOTO(out, rc);
 
-	if (localdata != NULL) {
-		client_nid = localdata;
-		nodemap_add_member(*client_nid, exp);
-	}
-
 	if (obd->obd_replayable) {
 		struct tg_export_data *ted = &exp->exp_target_data;
 
@@ -373,8 +398,8 @@ static int ofd_obd_connect(const struct lu_env *env, struct obd_export **_exp,
 
 out:
 	if (rc != 0) {
-		nodemap_del_member(exp);
 		class_disconnect(exp);
+		nodemap_del_member(exp);
 		*_exp = NULL;
 	} else {
 		*_exp = exp;
@@ -405,12 +430,11 @@ int ofd_obd_disconnect(struct obd_export *exp)
 	class_export_get(exp);
 
 	if (!(exp->exp_flags & OBD_OPT_FORCE))
-		ofd_grant_sanity_check(ofd_obd(ofd), __FUNCTION__);
+		tgt_grant_sanity_check(ofd_obd(ofd), __func__);
 
-	nodemap_del_member(exp);
 	rc = server_disconnect_export(exp);
 
-	ofd_grant_discard(exp);
+	tgt_grant_discard(exp);
 
 	/* Do not erase record for recoverable client. */
 	if (exp->exp_obd->obd_replayable &&
@@ -423,6 +447,7 @@ int ofd_obd_disconnect(struct obd_export *exp)
 		lu_env_fini(&env);
 	}
 out:
+	nodemap_del_member(exp);
 	class_export_put(exp);
 	RETURN(rc);
 }
@@ -478,10 +503,10 @@ static int ofd_destroy_export(struct obd_export *exp)
 {
 	struct ofd_device *ofd = ofd_exp(exp);
 
-	if (exp->exp_filter_data.fed_pending)
+	if (exp->exp_target_data.ted_pending)
 		CERROR("%s: cli %s/%p has %lu pending on destroyed export"
 		       "\n", exp->exp_obd->obd_name, exp->exp_client_uuid.uuid,
-		       exp, exp->exp_filter_data.fed_pending);
+		       exp, exp->exp_target_data.ted_pending);
 
 	target_destroy_export(exp);
 
@@ -498,16 +523,14 @@ static int ofd_destroy_export(struct obd_export *exp)
 	 * discard grants once we're sure no more
 	 * interaction with the client is possible
 	 */
-	ofd_grant_discard(exp);
+	tgt_grant_discard(exp);
 	ofd_fmd_cleanup(exp);
 
-	if (exp_connect_flags(exp) & OBD_CONNECT_GRANT_SHRINK) {
-		if (ofd->ofd_tot_granted_clients > 0)
-			ofd->ofd_tot_granted_clients --;
-	}
+	if (exp_connect_flags(exp) & OBD_CONNECT_GRANT)
+		ofd->ofd_lut.lut_tgd.tgd_tot_granted_clients--;
 
 	if (!(exp->exp_flags & OBD_OPT_FORCE))
-		ofd_grant_sanity_check(exp->exp_obd, __FUNCTION__);
+		tgt_grant_sanity_check(exp->exp_obd, __func__);
 
 	LASSERT(list_empty(&exp->exp_filter_data.fed_mod_list));
 	return 0;
@@ -528,17 +551,20 @@ static int ofd_destroy_export(struct obd_export *exp)
 int ofd_postrecov(const struct lu_env *env, struct ofd_device *ofd)
 {
 	struct lu_device *ldev = &ofd->ofd_dt_dev.dd_lu_dev;
-	struct lfsck_start_param lsp;
 	int rc;
 
 	CDEBUG(D_HA, "%s: recovery is over\n", ofd_name(ofd));
 
-	lsp.lsp_start = NULL;
-	lsp.lsp_index_valid = 0;
-	rc = lfsck_start(env, ofd->ofd_osd, &lsp);
-	if (rc != 0 && rc != -EALREADY)
-		CWARN("%s: auto trigger paused LFSCK failed: rc = %d\n",
-		      ofd_name(ofd), rc);
+	if (!ofd->ofd_skip_lfsck && !ofd->ofd_osd->dd_rdonly) {
+		struct lfsck_start_param lsp;
+
+		lsp.lsp_start = NULL;
+		lsp.lsp_index_valid = 0;
+		rc = lfsck_start(env, ofd->ofd_osd, &lsp);
+		if (rc != 0 && rc != -EALREADY)
+			CWARN("%s: auto trigger paused LFSCK failed: rc = %d\n",
+			      ofd_name(ofd), rc);
+	}
 
 	return ldev->ld_ops->ldo_recovery_complete(env, ldev);
 }
@@ -605,7 +631,7 @@ static int ofd_set_info_async(const struct lu_env *env, struct obd_export *exp,
 	}
 
 	if (KEY_IS(KEY_SPTLRPC_CONF)) {
-		rc = tgt_adapt_sptlrpc_conf(class_exp2tgt(exp), 0);
+		rc = tgt_adapt_sptlrpc_conf(class_exp2tgt(exp));
 	} else {
 		CERROR("%s: Unsupported key %s\n",
 		       exp->exp_obd->obd_name, (char*)key);
@@ -668,115 +694,6 @@ static int ofd_get_info(const struct lu_env *env, struct obd_export *exp,
 }
 
 /**
- * Get file system statistics of OST server.
- *
- * Helper function for ofd_statfs(), also used by grant code.
- * Implements caching for statistics to avoid calling OSD device each time.
- *
- * \param[in]  env	  execution environment
- * \param[in]  ofd	  OFD device
- * \param[out] osfs	  statistic data to return
- * \param[in]  max_age	  maximum age for cached data
- * \param[in]  from_cache show that data was get from cache or not
- *
- * \retval		0 if successful
- * \retval		negative value on error
- */
-int ofd_statfs_internal(const struct lu_env *env, struct ofd_device *ofd,
-                        struct obd_statfs *osfs, __u64 max_age, int *from_cache)
-{
-	int rc = 0;
-	ENTRY;
-
-	down_read(&ofd->ofd_lastid_rwsem);
-	/* Currently, for safe, we do not distinguish which LAST_ID is broken,
-	 * we may do that in the future.
-	 * Return -ENOSPC until the LAST_ID rebuilt. */
-	if (unlikely(ofd->ofd_lastid_rebuilding))
-		GOTO(out, rc = -ENOSPC);
-
-	spin_lock(&ofd->ofd_osfs_lock);
-	if (cfs_time_before_64(ofd->ofd_osfs_age, max_age) || max_age == 0) {
-		u64 unstable;
-
-		/* statfs data are too old, get up-to-date one.
-		 * we must be cautious here since multiple threads might be
-		 * willing to update statfs data concurrently and we must
-		 * grant that cached statfs data are always consistent */
-
-		if (ofd->ofd_statfs_inflight == 0)
-			/* clear inflight counter if no users, although it would
-			 * take a while to overflow this 64-bit counter ... */
-			ofd->ofd_osfs_inflight = 0;
-		/* notify ofd_grant_commit() that we want to track writes
-		 * completed as of now */
-		ofd->ofd_statfs_inflight++;
-		/* record value of inflight counter before running statfs to
-		 * compute the diff once statfs is completed */
-		unstable = ofd->ofd_osfs_inflight;
-		spin_unlock(&ofd->ofd_osfs_lock);
-
-		/* statfs can sleep ... hopefully not for too long since we can
-		 * call it fairly often as space fills up */
-		rc = dt_statfs(env, ofd->ofd_osd, osfs);
-		if (unlikely(rc))
-			GOTO(out, rc);
-
-		spin_lock(&ofd->ofd_grant_lock);
-		spin_lock(&ofd->ofd_osfs_lock);
-		/* calculate how much space was written while we released the
-		 * ofd_osfs_lock */
-		unstable = ofd->ofd_osfs_inflight - unstable;
-		ofd->ofd_osfs_unstable = 0;
-		if (unstable) {
-			/* some writes completed while we were running statfs
-			 * w/o the ofd_osfs_lock. Those ones got added to
-			 * the cached statfs data that we are about to crunch.
-			 * Take them into account in the new statfs data */
-			osfs->os_bavail -= min_t(u64, osfs->os_bavail,
-					       unstable >> ofd->ofd_blockbits);
-			/* However, we don't really know if those writes got
-			 * accounted in the statfs call, so tell
-			 * ofd_grant_space_left() there is some uncertainty
-			 * on the accounting of those writes.
-			 * The purpose is to prevent spurious error messages in
-			 * ofd_grant_space_left() since those writes might be
-			 * accounted twice. */
-			ofd->ofd_osfs_unstable += unstable;
-		}
-		/* similarly, there is some uncertainty on write requests
-		 * between prepare & commit */
-		ofd->ofd_osfs_unstable += ofd->ofd_tot_pending;
-		spin_unlock(&ofd->ofd_grant_lock);
-
-		/* finally udpate cached statfs data */
-		ofd->ofd_osfs = *osfs;
-		ofd->ofd_osfs_age = cfs_time_current_64();
-
-		ofd->ofd_statfs_inflight--; /* stop tracking */
-		if (ofd->ofd_statfs_inflight == 0)
-			ofd->ofd_osfs_inflight = 0;
-		spin_unlock(&ofd->ofd_osfs_lock);
-
-		if (from_cache)
-			*from_cache = 0;
-	} else {
-		/* use cached statfs data */
-		*osfs = ofd->ofd_osfs;
-		spin_unlock(&ofd->ofd_osfs_lock);
-		if (from_cache)
-			*from_cache = 1;
-	}
-
-	GOTO(out, rc);
-
-out:
-	up_read(&ofd->ofd_lastid_rwsem);
-
-	return rc;
-}
-
-/**
  * Implementation of obd_ops::o_statfs.
  *
  * This function returns information about a storage file system.
@@ -802,11 +719,12 @@ int ofd_statfs(const struct lu_env *env,  struct obd_export *exp,
 {
         struct obd_device	*obd = class_exp2obd(exp);
 	struct ofd_device	*ofd = ofd_exp(exp);
+	struct tg_grants_data	*tgd = &ofd->ofd_lut.lut_tgd;
 	int			 rc;
 
 	ENTRY;
 
-	rc = ofd_statfs_internal(env, ofd, osfs, max_age, NULL);
+	rc = tgt_statfs_internal(env, &ofd->ofd_lut, osfs, max_age, NULL);
 	if (unlikely(rc))
 		GOTO(out, rc);
 
@@ -814,55 +732,64 @@ int ofd_statfs(const struct lu_env *env,  struct obd_export *exp,
 	 * might be under-reporting if clients haven't announced their
 	 * caches with brw recently */
 
-	CDEBUG(D_SUPER | D_CACHE, "blocks cached "LPU64" granted "LPU64
-	       " pending "LPU64" free "LPU64" avail "LPU64"\n",
-	       ofd->ofd_tot_dirty, ofd->ofd_tot_granted, ofd->ofd_tot_pending,
-	       osfs->os_bfree << ofd->ofd_blockbits,
-	       osfs->os_bavail << ofd->ofd_blockbits);
+	CDEBUG(D_SUPER | D_CACHE, "blocks cached %llu granted %llu"
+	       " pending %llu free %llu avail %llu\n",
+	       tgd->tgd_tot_dirty, tgd->tgd_tot_granted,
+	       tgd->tgd_tot_pending,
+	       osfs->os_bfree << tgd->tgd_blockbits,
+	       osfs->os_bavail << tgd->tgd_blockbits);
 
 	osfs->os_bavail -= min_t(u64, osfs->os_bavail,
-				 ((ofd->ofd_tot_dirty + ofd->ofd_tot_pending +
-				   osfs->os_bsize - 1) >> ofd->ofd_blockbits));
+				 ((tgd->tgd_tot_dirty + tgd->tgd_tot_pending +
+				   osfs->os_bsize - 1) >> tgd->tgd_blockbits));
 
 	/* The QoS code on the MDS does not care about space reserved for
 	 * precreate, so take it out. */
 	if (exp_connect_flags(exp) & OBD_CONNECT_MDS) {
-		struct filter_export_data *fed;
+		struct tg_export_data *ted;
 
-		fed = &obd->obd_self_export->exp_filter_data;
+		ted = &obd->obd_self_export->exp_target_data;
 		osfs->os_bavail -= min_t(u64, osfs->os_bavail,
-					 fed->fed_grant >> ofd->ofd_blockbits);
+					 ted->ted_grant >> tgd->tgd_blockbits);
 	}
 
-	ofd_grant_sanity_check(obd, __FUNCTION__);
-	CDEBUG(D_CACHE, LPU64" blocks: "LPU64" free, "LPU64" avail; "
-	       LPU64" objects: "LPU64" free; state %x\n",
+	tgt_grant_sanity_check(obd, __func__);
+	CDEBUG(D_CACHE, "%llu blocks: %llu free, %llu avail; "
+	       "%llu objects: %llu free; state %x\n",
 	       osfs->os_blocks, osfs->os_bfree, osfs->os_bavail,
 	       osfs->os_files, osfs->os_ffree, osfs->os_state);
 
 	if (OBD_FAIL_CHECK_VALUE(OBD_FAIL_OST_ENOINO,
-				 ofd->ofd_lut.lut_lsd.lsd_osd_index))
-		osfs->os_ffree = 0;
+				 ofd->ofd_lut.lut_lsd.lsd_osd_index)) {
+		/* Reduce free inode count to zero, but keep "used" intact */
+		osfs->os_files -= osfs->os_ffree;
+		osfs->os_ffree -= osfs->os_ffree;
+	}
 
 	/* OS_STATE_READONLY can be set by OSD already */
 	if (ofd->ofd_raid_degraded)
 		osfs->os_state |= OS_STATE_DEGRADED;
 
-	if (obd->obd_self_export != exp && ofd_grant_compat(exp, ofd)) {
+	if (obd->obd_self_export != exp && !exp_grant_param_supp(exp) &&
+	    tgd->tgd_blockbits > COMPAT_BSIZE_SHIFT) {
 		/* clients which don't support OBD_CONNECT_GRANT_PARAM
 		 * should not see a block size > page size, otherwise
 		 * cl_lost_grant goes mad. Therefore, we emulate a 4KB (=2^12)
 		 * block size which is the biggest block size known to work
 		 * with all client's page size. */
-		osfs->os_blocks <<= ofd->ofd_blockbits - COMPAT_BSIZE_SHIFT;
-		osfs->os_bfree  <<= ofd->ofd_blockbits - COMPAT_BSIZE_SHIFT;
-		osfs->os_bavail <<= ofd->ofd_blockbits - COMPAT_BSIZE_SHIFT;
+		osfs->os_blocks <<= tgd->tgd_blockbits - COMPAT_BSIZE_SHIFT;
+		osfs->os_bfree  <<= tgd->tgd_blockbits - COMPAT_BSIZE_SHIFT;
+		osfs->os_bavail <<= tgd->tgd_blockbits - COMPAT_BSIZE_SHIFT;
 		osfs->os_bsize    = 1 << COMPAT_BSIZE_SHIFT;
 	}
 
 	if (OBD_FAIL_CHECK_VALUE(OBD_FAIL_OST_ENOSPC,
-				 ofd->ofd_lut.lut_lsd.lsd_osd_index))
-		osfs->os_bfree = osfs->os_bavail = 2;
+				 ofd->ofd_lut.lut_lsd.lsd_osd_index)) {
+		/* Reduce free blocks count near zero, but keep "used" intact */
+		osfs->os_bavail -= osfs->os_bavail - 2;
+		osfs->os_blocks -= osfs->os_bfree - 2;
+		osfs->os_bfree -= osfs->os_bfree - 2;
+	}
 
 	EXIT;
 out:
@@ -977,14 +904,12 @@ out:
 int ofd_destroy_by_fid(const struct lu_env *env, struct ofd_device *ofd,
 		       const struct lu_fid *fid, int orphan)
 {
-	struct ofd_thread_info	*info = ofd_info(env);
-	struct lustre_handle	 lockh;
-	__u64			 flags = LDLM_FL_AST_DISCARD_DATA;
-	__u64			 rc = 0;
-	ldlm_policy_data_t	 policy = {
-					.l_extent = { 0, OBD_OBJECT_EOF }
-				 };
-	struct ofd_object	*fo;
+	struct ofd_thread_info *info = ofd_info(env);
+	struct lustre_handle lockh;
+	union ldlm_policy_data policy = { .l_extent = { 0, OBD_OBJECT_EOF } };
+	struct ofd_object *fo;
+	__u64 flags = LDLM_FL_AST_DISCARD_DATA;
+	__u64 rc = 0;
 
 	ENTRY;
 
@@ -1041,6 +966,10 @@ static int ofd_echo_destroy(const struct lu_env *env, struct obd_export *exp,
 
 	ofd_info_init(env, exp);
 
+	rc = ofd_validate_seq(exp, ostid_seq(&oa->o_oi));
+	if (rc != 0)
+		RETURN(rc);
+
 	CDEBUG(D_HA, "%s: Destroy object "DFID"\n", ofd_name(ofd), PFID(fid));
 
 	rc = ofd_destroy_by_fid(env, ofd, fid, 0);
@@ -1080,16 +1009,16 @@ static int ofd_echo_create(const struct lu_env *env, struct obd_export *exp,
 			   struct obdo *oa)
 {
 	struct ofd_device	*ofd = ofd_exp(exp);
-	struct ofd_thread_info	*info;
 	u64			 seq = ostid_seq(&oa->o_oi);
 	struct ofd_seq		*oseq;
 	int			 rc = 0, diff = 1;
+	long			 granted;
 	u64			 next_id;
 	int			 count;
 
 	ENTRY;
 
-	info = ofd_info_init(env, exp);
+	ofd_info_init(env, exp);
 
 	LASSERT(seq == FID_SEQ_ECHO);
 	LASSERT(oa->o_valid & OBD_MD_FLGROUP);
@@ -1103,16 +1032,22 @@ static int ofd_echo_create(const struct lu_env *env, struct obd_export *exp,
 	if (unlikely(ofd->ofd_lastid_rebuilding))
 		GOTO(out_sem, rc = -ENOSPC);
 
+	rc = ofd_validate_seq(exp, seq);
+	if (rc != 0)
+		RETURN(rc);
+
 	oseq = ofd_seq_load(env, ofd, seq);
 	if (IS_ERR(oseq)) {
-		CERROR("%s: Can't find FID Sequence "LPX64": rc = %ld\n",
+		CERROR("%s: Can't find FID Sequence %#llx: rc = %ld\n",
 		       ofd_name(ofd), seq, PTR_ERR(oseq));
 		GOTO(out_sem, rc = -EINVAL);
 	}
 
 	mutex_lock(&oseq->os_create_lock);
-	rc = ofd_grant_create(env, ofd_obd(ofd)->obd_self_export, &diff);
-	if (rc < 0) {
+	granted = tgt_grant_create(env, ofd_obd(ofd)->obd_self_export, &diff);
+	if (granted < 0) {
+		rc = granted;
+		granted = 0;
 		CDEBUG(D_HA, "%s: failed to acquire grant space for "
 		       "precreate (%d): rc = %d\n", ofd_name(ofd), diff, rc);
 		diff = 0;
@@ -1132,7 +1067,7 @@ static int ofd_echo_create(const struct lu_env *env, struct obd_export *exp,
 		rc = 0;
 	}
 
-	ofd_grant_commit(env, ofd_obd(ofd)->obd_self_export, rc);
+	tgt_grant_commit(ofd_obd(ofd)->obd_self_export, granted, rc);
 out:
 	mutex_unlock(&oseq->os_create_lock);
 	ofd_seq_put(env, oseq);
@@ -1181,7 +1116,7 @@ static int ofd_echo_getattr(const struct lu_env *env, struct obd_export *exp,
 		__u64 curr_version;
 
 		obdo_from_la(oa, &info->fti_attr,
-			     OFD_VALID_FLAGS | LA_UID | LA_GID);
+			     OFD_VALID_FLAGS | LA_UID | LA_GID | LA_PROJID);
 
 		/* Store object version in reply */
 		curr_version = dt_version_get(env, ofd_object_child(fo));
@@ -1283,7 +1218,7 @@ out:
  * \retval		negative value on error
  */
 static int ofd_iocontrol(unsigned int cmd, struct obd_export *exp, int len,
-			 void *karg, void *uarg)
+			 void *karg, void __user *uarg)
 {
 	struct lu_env		 env;
 	struct ofd_device	*ofd = ofd_exp(exp);
@@ -1300,6 +1235,7 @@ static int ofd_iocontrol(unsigned int cmd, struct obd_export *exp, int len,
 	switch (cmd) {
 	case OBD_IOC_ABORT_RECOVERY:
 		CERROR("%s: aborting recovery\n", obd->obd_name);
+		obd->obd_abort_recovery = 1;
 		target_stop_recovery_thread(obd);
 		break;
 	case OBD_IOC_SYNC:
@@ -1360,24 +1296,14 @@ static int ofd_iocontrol(unsigned int cmd, struct obd_export *exp, int len,
  * special actions, it just invokes target_recovery_cleanup().
  *
  * \param[in] obd	OBD device of OFD
- * \param[in] stage	cleanup stage
  *
  * \retval		0
  */
-static int ofd_precleanup(struct obd_device *obd, enum obd_cleanup_stage stage)
+static int ofd_precleanup(struct obd_device *obd)
 {
-	int rc = 0;
-
 	ENTRY;
-
-	switch(stage) {
-	case OBD_CLEANUP_EARLY:
-		break;
-	case OBD_CLEANUP_EXPORTS:
-		target_cleanup_recovery(obd);
-		break;
-	}
-	RETURN(rc);
+	target_cleanup_recovery(obd);
+	RETURN(0);
 }
 
 /**
@@ -1438,15 +1364,15 @@ static int ofd_health_check(const struct lu_env *nul, struct obd_device *obd)
 	if (unlikely(rc))
 		GOTO(out, rc);
 
-	if (info->fti_u.osfs.os_state == OS_STATE_READONLY)
+	if (info->fti_u.osfs.os_state & OS_STATE_READONLY)
 		GOTO(out, rc = -EROFS);
 
 #ifdef USE_HEALTH_CHECK_WRITE
-	OBD_ALLOC(info->fti_buf.lb_buf, PAGE_CACHE_SIZE);
+	OBD_ALLOC(info->fti_buf.lb_buf, PAGE_SIZE);
 	if (info->fti_buf.lb_buf == NULL)
 		GOTO(out, rc = -ENOMEM);
 
-	info->fti_buf.lb_len = PAGE_CACHE_SIZE;
+	info->fti_buf.lb_len = PAGE_SIZE;
 	info->fti_off = 0;
 
 	th = dt_trans_create(&env, ofd->ofd_osd);
@@ -1465,7 +1391,7 @@ static int ofd_health_check(const struct lu_env *nul, struct obd_device *obd)
 	}
 	dt_trans_stop(&env, ofd->ofd_osd, th);
 
-	OBD_FREE(info->fti_buf.lb_buf, PAGE_CACHE_SIZE);
+	OBD_FREE(info->fti_buf.lb_buf, PAGE_SIZE);
 
 	CDEBUG(D_INFO, "write 1 page synchronously for checking io rc %d\n",rc);
 #endif