X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fofd%2Fofd_lvb.c;h=0397f0beeb98d976169fbd8818b31ba3d283e18b;hb=HEAD;hp=9f0c4031db11513a084291bf0eb328d6ebfbbc05;hpb=9c6ebfd11be1cc11629a2960c8c818492e1f0980;p=fs%2Flustre-release.git

diff --git a/lustre/ofd/ofd_lvb.c b/lustre/ofd/ofd_lvb.c
index 9f0c403..f220ded 100644
--- a/lustre/ofd/ofd_lvb.c
+++ b/lustre/ofd/ofd_lvb.c
@@ -15,11 +15,7 @@
  *
  * 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,22 +23,41 @@
  * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  *
- * Copyright (c) 2012, 2013, Intel Corporation.
+ * Copyright (c) 2012, 2017, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
- * Lustre is a trademark of Sun Microsystems, Inc.
  *
  * lustre/ofd/ofd_lvb.c
  *
- * Author: Mikhail Pershin <tappro@whamcloud.com>
- * Author: Alexey Zhuravlev <bzzz@whamcloud.com>
+ * This file contains methods for OBD Filter Device (OFD)
+ * Lock Value Block (LVB) operations.
+ *
+ * LVB is special opaque (to LDLM) data that is associated with an LDLM lock
+ * and transferred from client to server and back. OFD LVBs are used to
+ * maintain current object size/times.
+ *
+ * Author: Andreas Dilger <andreas.dilger@intel.com>
+ * Author: Mikhail Pershin <mike.pershin@intel.com>
+ * Author: Alexey Zhuravlev <alexey.zhuravlev@intel.com>
  */
 
 #define DEBUG_SUBSYSTEM S_FILTER
 
+#include <lustre_swab.h>
 #include "ofd_internal.h"
 
+/**
+ * Implementation of ldlm_valblock_ops::lvbo_free for OFD.
+ *
+ * This function frees allocated LVB data if it associated with the given
+ * LDLM resource.
+ *
+ * \param[in] res	LDLM resource
+ *
+ * \retval		0 on successful setup
+ * \retval		negative value on error
+ */
 static int ofd_lvbo_free(struct ldlm_resource *res)
 {
 	if (res->lr_lvb_data)
@@ -51,16 +66,43 @@ static int ofd_lvbo_free(struct ldlm_resource *res)
 	return 0;
 }
 
-/* Called with res->lr_lvb_sem held */
+static bool ofd_resync_allowed(struct ofd_device *ofd)
+{
+	struct obd_device *obd = ofd_obd(ofd);
+
+	if (obd->obd_recovery_start == 0)
+		return false;
+
+	if (obd->obd_recovery_start + obd->obd_recovery_time_hard <
+	    ktime_get_seconds())
+		return false;
+
+	return true;
+}
+
+/**
+ * Implementation of ldlm_valblock_ops::lvbo_init for OFD.
+ *
+ * This function allocates and initializes new LVB data for the given
+ * LDLM resource if it is not allocated yet. New LVB is filled with attributes
+ * of the object associated with that resource. Function does nothing if LVB
+ * for the given LDLM resource is allocated already.
+ *
+ * Called with res->lr_lvb_sem held.
+ *
+ * \param[in] lock	LDLM lock on resource
+ *
+ * \retval		0 on successful setup
+ * \retval		negative value on error
+ */
 static int ofd_lvbo_init(struct ldlm_resource *res)
 {
 	struct ost_lvb		*lvb;
 	struct ofd_device	*ofd;
 	struct ofd_object	*fo;
 	struct ofd_thread_info	*info;
-	struct lu_env		 env;
-	int			 rc = 0;
-
+	struct lu_env *env;
+	int rc = 0;
 	ENTRY;
 
 	LASSERT(res);
@@ -72,29 +114,46 @@ static int ofd_lvbo_init(struct ldlm_resource *res)
 	ofd = ldlm_res_to_ns(res)->ns_lvbp;
 	LASSERT(ofd != NULL);
 
-	if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_OST_LVB))
+	if (CFS_FAIL_CHECK(OBD_FAIL_LDLM_OST_LVB))
 		RETURN(-ENOMEM);
 
-	rc = lu_env_init(&env, LCT_DT_THREAD);
-	if (rc)
-		RETURN(rc);
+	env = lu_env_find();
+	LASSERT(env);
 
 	OBD_ALLOC_PTR(lvb);
 	if (lvb == NULL)
-		GOTO(out_env, rc = -ENOMEM);
+		GOTO(out, rc = -ENOMEM);
 
+	info = ofd_info(env);
 	res->lr_lvb_data = lvb;
 	res->lr_lvb_len = sizeof(*lvb);
 
-	info = ofd_info_init(&env, NULL);
-	ost_fid_from_resid(&info->fti_fid, &res->lr_name);
-	fo = ofd_object_find(&env, ofd, &info->fti_fid);
+	ost_fid_from_resid(&info->fti_fid, &res->lr_name,
+			   ofd->ofd_lut.lut_lsd.lsd_osd_index);
+	fo = ofd_object_find(env, ofd, &info->fti_fid);
 	if (IS_ERR(fo))
 		GOTO(out_lvb, rc = PTR_ERR(fo));
 
-	rc = ofd_attr_get(&env, fo, &info->fti_attr);
-	if (rc)
+	rc = ofd_attr_get(env, fo, &info->fti_attr);
+	if (rc) {
+		struct ofd_seq		*oseq;
+		__u64			 seq;
+
+		/* Object could be recreated during the first
+		 * CLEANUP_ORPHAN request. */
+		if (rc == -ENOENT) {
+			seq = fid_seq(&info->fti_fid);
+			oseq = ofd_seq_load(env, ofd, fid_seq_is_idif(seq) ?
+					    FID_SEQ_OST_MDT0 : seq);
+			if (!IS_ERR_OR_NULL(oseq)) {
+				if (!oseq->os_last_id_synced &&
+				    ofd_resync_allowed(ofd))
+					rc = -EINPROGRESS;
+				ofd_seq_put(env, oseq);
+			}
+		}
 		GOTO(out_obj, rc);
+	}
 
 	lvb->lvb_size = info->fti_attr.la_size;
 	lvb->lvb_blocks = info->fti_attr.la_blocks;
@@ -102,59 +161,83 @@ static int ofd_lvbo_init(struct ldlm_resource *res)
 	lvb->lvb_atime = info->fti_attr.la_atime;
 	lvb->lvb_ctime = info->fti_attr.la_ctime;
 
-	CDEBUG(D_DLMTRACE, "res: "DFID" initial lvb size: "LPU64", "
-	       "mtime: "LPX64", blocks: "LPX64"\n",
-	       PFID(&info->fti_fid), lvb->lvb_size,
-	       lvb->lvb_mtime, lvb->lvb_blocks);
+	if (fo->ofo_atime_ondisk == 0)
+		fo->ofo_atime_ondisk = info->fti_attr.la_atime;
+
+	CDEBUG(D_DLMTRACE,
+	       "res: "DFID" initial LVB size: %llu, mtime: %#llx, atime: %#llx, ctime: %#llx, blocks: %#llx\n",
+	       PFID(&info->fti_fid), lvb->lvb_size, lvb->lvb_mtime,
+	       lvb->lvb_atime, lvb->lvb_ctime, lvb->lvb_blocks);
+
+	info->fti_attr.la_valid = 0;
 
 	EXIT;
 out_obj:
-	ofd_object_put(&env, fo);
+	ofd_object_put(env, fo);
 out_lvb:
 	if (rc != 0)
 		OST_LVB_SET_ERR(lvb->lvb_blocks, rc);
-out_env:
-	lu_env_fini(&env);
+out:
 	/* Don't free lvb data on lookup error */
 	return rc;
 }
 
-/* This will be called in two ways:
+/**
+ * Implementation of ldlm_valblock_ops::lvbo_update for OFD.
+ *
+ * When a client generates a glimpse enqueue, it wants to get the current
+ * file size and updated attributes for a stat() type operation, but these
+ * attributes may be writeback cached on another client. The client with
+ * the DLM extent lock at the highest offset is asked for its current
+ * attributes via a glimpse callback on its extent lock, on the assumption
+ * that it has the highest file size and the newest timestamps. The timestamps
+ * are guaranteed to be correct if there is only a single writer on the file,
+ * but may be slightly inaccurate if there are multiple concurrent writers on
+ * the same object. In order to avoid race conditions between the glimpse AST
+ * and the client cancelling the lock, ofd_lvbo_update() also updates
+ * the attributes from the local object. If the last client hasn't done any
+ * writes yet, or has already written its data and cancelled its lock before
+ * it processed the glimpse, then the local inode will have more uptodate
+ * information.
  *
- *   r != NULL : called by the DLM itself after a glimpse callback
- *   r == NULL : called by the ofd after a disk write
+ * This is called in two ways:
+ *  \a req != NULL : called by the DLM itself after a glimpse callback
+ *  \a req == NULL : called by the OFD after a disk write
  *
- *   If 'increase_only' is true, don't allow values to move backwards.
+ * \param[in] lock		LDLM lock
+ * \param[in] req		PTLRPC request
+ * \param[in] increase_only	don't allow LVB values to decrease
+ *
+ * \retval		0 on successful setup
+ * \retval		negative value on error
  */
-static int ofd_lvbo_update(struct ldlm_resource *res,
+static int ofd_lvbo_update(struct ldlm_resource *res, struct ldlm_lock *lock,
 			   struct ptlrpc_request *req, int increase_only)
 {
-	struct ofd_device	*ofd;
-	struct ofd_object	*fo;
-	struct ofd_thread_info	*info;
-	struct ost_lvb		*lvb;
-	struct lu_env		 env;
-	int			 rc = 0;
+	struct ofd_thread_info *info;
+	struct ofd_device *ofd;
+	struct ofd_object *fo;
+	struct ost_lvb	*lvb;
+	const struct lu_env *env;
+	int rc = 0;
 
 	ENTRY;
 
+	env = lu_env_find();
+	LASSERT(env);
+	info = ofd_info(env);
 	LASSERT(res != NULL);
 
 	ofd = ldlm_res_to_ns(res)->ns_lvbp;
 	LASSERT(ofd != NULL);
 
-	rc = lu_env_init(&env, LCT_DT_THREAD);
-	if (rc)
-		RETURN(rc);
-
-	info = ofd_info_init(&env, NULL);
 	fid_extract_from_res_name(&info->fti_fid, &res->lr_name);
 
 	lvb = res->lr_lvb_data;
 	if (lvb == NULL) {
 		CERROR("%s: no LVB data for "DFID"\n",
-		       ofd_obd(ofd)->obd_name, PFID(&info->fti_fid));
-		GOTO(out_env, rc = 0);
+		       ofd_name(ofd), PFID(&info->fti_fid));
+		GOTO(out, rc = 0);
 	}
 
 	/* Update the LVB from the network message */
@@ -191,31 +274,31 @@ static int ofd_lvbo_update(struct ldlm_resource *res,
 		lock_res(res);
 		if (rpc_lvb->lvb_size > lvb->lvb_size || !increase_only) {
 			CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb size: "
-			       LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
+			       "%llu -> %llu\n", PFID(&info->fti_fid),
 			       lvb->lvb_size, rpc_lvb->lvb_size);
 			lvb->lvb_size = rpc_lvb->lvb_size;
 		}
 		if (rpc_lvb->lvb_mtime > lvb->lvb_mtime || !increase_only) {
 			CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb mtime: "
-			       LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
+			       "%llu -> %llu\n", PFID(&info->fti_fid),
 			       lvb->lvb_mtime, rpc_lvb->lvb_mtime);
 			lvb->lvb_mtime = rpc_lvb->lvb_mtime;
 		}
 		if (rpc_lvb->lvb_atime > lvb->lvb_atime || !increase_only) {
 			CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb atime: "
-			       LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
+			       "%llu -> %llu\n", PFID(&info->fti_fid),
 			       lvb->lvb_atime, rpc_lvb->lvb_atime);
 			lvb->lvb_atime = rpc_lvb->lvb_atime;
 		}
 		if (rpc_lvb->lvb_ctime > lvb->lvb_ctime || !increase_only) {
 			CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb ctime: "
-			       LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
+			       "%llu -> %llu\n", PFID(&info->fti_fid),
 			       lvb->lvb_ctime, rpc_lvb->lvb_ctime);
 			lvb->lvb_ctime = rpc_lvb->lvb_ctime;
 		}
 		if (rpc_lvb->lvb_blocks > lvb->lvb_blocks || !increase_only) {
 			CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb blocks: "
-			       LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
+			       "%llu -> %llu\n", PFID(&info->fti_fid),
 			       lvb->lvb_blocks, rpc_lvb->lvb_blocks);
 			lvb->lvb_blocks = rpc_lvb->lvb_blocks;
 		}
@@ -224,56 +307,68 @@ static int ofd_lvbo_update(struct ldlm_resource *res,
 
 disk_update:
 	/* Update the LVB from the disk inode */
-	ost_fid_from_resid(&info->fti_fid, &res->lr_name);
-	fo = ofd_object_find(&env, ofd, &info->fti_fid);
+	ost_fid_from_resid(&info->fti_fid, &res->lr_name,
+			   ofd->ofd_lut.lut_lsd.lsd_osd_index);
+	fo = ofd_object_find(env, ofd, &info->fti_fid);
 	if (IS_ERR(fo))
-		GOTO(out_env, rc = PTR_ERR(fo));
+		GOTO(out, rc = PTR_ERR(fo));
 
-	rc = ofd_attr_get(&env, fo, &info->fti_attr);
+	rc = ofd_attr_get(env, fo, &info->fti_attr);
 	if (rc)
 		GOTO(out_obj, rc);
 
 	lock_res(res);
 	if (info->fti_attr.la_size > lvb->lvb_size || !increase_only) {
 		CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb size from disk: "
-		       LPU64" -> %llu\n", PFID(&info->fti_fid),
+		       "%llu -> %llu\n", PFID(&info->fti_fid),
 		       lvb->lvb_size, info->fti_attr.la_size);
 		lvb->lvb_size = info->fti_attr.la_size;
 	}
 
 	if (info->fti_attr.la_mtime >lvb->lvb_mtime || !increase_only) {
 		CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb mtime from disk: "
-		       LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
+		       "%llu -> %llu\n", PFID(&info->fti_fid),
 		       lvb->lvb_mtime, info->fti_attr.la_mtime);
 		lvb->lvb_mtime = info->fti_attr.la_mtime;
 	}
 	if (info->fti_attr.la_atime >lvb->lvb_atime || !increase_only) {
 		CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb atime from disk: "
-		       LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
+		       "%llu -> %llu\n", PFID(&info->fti_fid),
 		       lvb->lvb_atime, info->fti_attr.la_atime);
 		lvb->lvb_atime = info->fti_attr.la_atime;
 	}
 	if (info->fti_attr.la_ctime >lvb->lvb_ctime || !increase_only) {
 		CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb ctime from disk: "
-		       LPU64" -> "LPU64"\n", PFID(&info->fti_fid),
+		       "%llu -> %llu\n", PFID(&info->fti_fid),
 		       lvb->lvb_ctime, info->fti_attr.la_ctime);
 		lvb->lvb_ctime = info->fti_attr.la_ctime;
 	}
 	if (info->fti_attr.la_blocks > lvb->lvb_blocks || !increase_only) {
 		CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb blocks from disk: "
-		       LPU64" -> %llu\n", PFID(&info->fti_fid), lvb->lvb_blocks,
+		       "%llu -> %llu\n", PFID(&info->fti_fid), lvb->lvb_blocks,
 		       (unsigned long long)info->fti_attr.la_blocks);
 		lvb->lvb_blocks = info->fti_attr.la_blocks;
 	}
 	unlock_res(res);
 
+	info->fti_attr.la_valid = 0;
 out_obj:
-	ofd_object_put(&env, fo);
-out_env:
-	lu_env_fini(&env);
+	ofd_object_put(env, fo);
+out:
 	return rc;
 }
 
+/**
+ * Implementation of ldlm_valblock_ops::lvbo_size for OFD.
+ *
+ * This function returns size of LVB data so appropriate RPC size will be
+ * reserved. This is used for compatibility needs between server and client
+ * of different Lustre versions.
+ *
+ * \param[in] lock	LDLM lock
+ *
+ * \retval		size of LVB data
+ */
 static int ofd_lvbo_size(struct ldlm_lock *lock)
 {
 	if (lock->l_export != NULL && exp_connect_lvb_type(lock->l_export))
@@ -282,7 +377,19 @@ static int ofd_lvbo_size(struct ldlm_lock *lock)
 		return sizeof(struct ost_lvb_v1);
 }
 
-static int ofd_lvbo_fill(struct ldlm_lock *lock, void *buf, int buflen)
+/**
+ * Implementation of ldlm_valblock_ops::lvbo_fill for OFD.
+ *
+ * This function is called to fill the given RPC buffer \a buf with LVB data
+ *
+ * \param[in] env	execution environment
+ * \param[in] lock	LDLM lock
+ * \param[in] buf	RPC buffer to fill
+ * \param[in] buflen	buffer length
+ *
+ * \retval		size of LVB data written into \a buf buffer
+ */
+static int ofd_lvbo_fill(struct ldlm_lock *lock, void *buf, int *buflen)
 {
 	struct ldlm_resource *res = lock->l_resource;
 	int lvb_len;
@@ -294,8 +401,8 @@ static int ofd_lvbo_fill(struct ldlm_lock *lock, void *buf, int buflen)
 	lvb_len = ofd_lvbo_size(lock);
 	LASSERT(lvb_len <= res->lr_lvb_len);
 
-	if (lvb_len > buflen)
-		lvb_len = buflen;
+	if (lvb_len > *buflen)
+		lvb_len = *buflen;
 
 	lock_res(res);
 	memcpy(buf, res->lr_lvb_data, lvb_len);