X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Ffld%2Ffld_handler.c;h=c234179760aec0e9a293cc5a14fce8cbccee9136;hb=a68e117a54af82f209aed46a822f8346a3e0703f;hp=9d6d1380aaee642c3697c2740dc81226e5b22072;hpb=c50a9e2ae39df781598696dae4f33d60199a84dd;p=fs%2Flustre-release.git

diff --git a/lustre/fld/fld_handler.c b/lustre/fld/fld_handler.c
index 9d6d138..c234179 100644
--- a/lustre/fld/fld_handler.c
+++ b/lustre/fld/fld_handler.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, 2013, Intel Corporation.
+ * Copyright (c) 2011, 2015, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -51,7 +51,6 @@
 #include <obd_support.h>
 #include <lustre_fid.h>
 #include <lustre_fld.h>
-#include <lustre_mdt.h> /* err_serious() */
 #include <lustre_req_layout.h>
 #include <lprocfs_status.h>
 #include "fld_internal.h"
@@ -60,6 +59,7 @@
 LU_KEY_INIT_FINI(fld, struct fld_thread_info);
 
 /* context key: fld_thread_key */
+/* MGS thread may create llog file causing FLD lookup */
 LU_CONTEXT_KEY_DEFINE(fld, LCT_MD_THREAD | LCT_DT_THREAD | LCT_MG_THREAD);
 
 int fld_server_mod_init(void)
@@ -105,14 +105,105 @@ int fld_server_create(const struct lu_env *env, struct lu_server_fld *fld,
 EXPORT_SYMBOL(fld_server_create);
 
 /**
- *  Lookup mds by seq, returns a range for given seq.
- *
- *  If that entry is not cached in fld cache, request is sent to super
- *  sequence controller node (MDT0). All other MDT[1...N] and client
- *  cache fld entries, but this cache is not persistent.
- */
-int fld_server_lookup(const struct lu_env *env, struct lu_server_fld *fld,
-		      seqno_t seq, struct lu_seq_range *range)
+ * Extract index information from fld name like srv-fsname-MDT0000
+ **/
+int fld_name_to_index(const char *name, __u32 *index)
+{
+	char *dash;
+	int rc;
+	ENTRY;
+
+	CDEBUG(D_INFO, "get index from %s\n", name);
+	dash = strrchr(name, '-');
+	if (dash == NULL)
+		RETURN(-EINVAL);
+	dash++;
+	rc = target_name2index(dash, index, NULL);
+	RETURN(rc);
+}
+
+/**
+ * Retrieve fldb entry from MDT0 and add to local FLDB and cache.
+ **/
+int fld_update_from_controller(const struct lu_env *env,
+			       struct lu_server_fld *fld)
+{
+	struct fld_thread_info	  *info;
+	struct lu_seq_range	  *range;
+	struct lu_seq_range_array *lsra;
+	__u32			  index;
+	struct ptlrpc_request	  *req;
+	int			  rc;
+	int			  i;
+	ENTRY;
+
+	/* Update only happens during initalization, i.e. local FLDB
+	 * does not exist yet */
+	if (!fld->lsf_new)
+		RETURN(0);
+
+	rc = fld_name_to_index(fld->lsf_name, &index);
+	if (rc < 0)
+		RETURN(rc);
+
+	/* No need update fldb for MDT0 */
+	if (index == 0)
+		RETURN(0);
+
+	info = lu_context_key_get(&env->le_ctx, &fld_thread_key);
+	LASSERT(info != NULL);
+	range = &info->fti_lrange;
+	memset(range, 0, sizeof(*range));
+	range->lsr_index = index;
+	fld_range_set_mdt(range);
+
+	do {
+		rc = fld_client_rpc(fld->lsf_control_exp, range, FLD_READ,
+				    &req);
+		if (rc != 0 && rc != -EAGAIN)
+			GOTO(out, rc);
+
+		LASSERT(req != NULL);
+		lsra = (struct lu_seq_range_array *)req_capsule_server_get(
+					  &req->rq_pill, &RMF_GENERIC_DATA);
+		if (lsra == NULL)
+			GOTO(out, rc = -EPROTO);
+
+		range_array_le_to_cpu(lsra, lsra);
+		for (i = 0; i < lsra->lsra_count; i++) {
+			int rc1;
+
+			if (lsra->lsra_lsr[i].lsr_flags != LU_SEQ_RANGE_MDT)
+				GOTO(out, rc = -EINVAL);
+
+			if (lsra->lsra_lsr[i].lsr_index != index)
+				GOTO(out, rc = -EINVAL);
+
+			mutex_lock(&fld->lsf_lock);
+			rc1 = fld_insert_entry(env, fld, &lsra->lsra_lsr[i]);
+			mutex_unlock(&fld->lsf_lock);
+
+			if (rc1 != 0)
+				GOTO(out, rc = rc1);
+		}
+		if (rc == -EAGAIN)
+			*range = lsra->lsra_lsr[lsra->lsra_count - 1];
+	} while (rc == -EAGAIN);
+
+	fld->lsf_new = 1;
+out:
+	if (req != NULL)
+		ptlrpc_req_finished(req);
+
+	RETURN(rc);
+}
+EXPORT_SYMBOL(fld_update_from_controller);
+
+/**
+ * Lookup sequece in local cache/fldb.
+ **/
+int fld_local_lookup(const struct lu_env *env, struct lu_server_fld *fld,
+		     u64 seq, struct lu_seq_range *range)
 {
 	struct lu_seq_range *erange;
 	struct fld_thread_info *info;
@@ -136,22 +227,51 @@ int fld_server_lookup(const struct lu_env *env, struct lu_server_fld *fld,
 		*range = *erange;
 		RETURN(0);
 	}
+	RETURN(rc);
+}
+EXPORT_SYMBOL(fld_local_lookup);
 
-	if (fld->lsf_obj) {
+/**
+ *  Lookup MDT/OST by seq, returns a range for given seq.
+ *
+ *  If that entry is not cached in fld cache, request is sent to super
+ *  sequence controller node (MDT0). All other MDT[1...N] and client
+ *  cache fld entries, but this cache is not persistent.
+ */
+int fld_server_lookup(const struct lu_env *env, struct lu_server_fld *fld,
+		      u64 seq, struct lu_seq_range *range)
+{
+	__u32 index;
+	int rc;
+	ENTRY;
+
+	rc = fld_local_lookup(env, fld, seq, range);
+	if (likely(rc == 0))
+		RETURN(rc);
+
+	rc = fld_name_to_index(fld->lsf_name, &index);
+	if (rc < 0)
+		RETURN(rc);
+
+	if (index == 0 && rc == LDD_F_SV_TYPE_MDT) {
 		/* On server side, all entries should be in cache.
 		 * If we can not find it in cache, just return error */
 		CERROR("%s: Cannot find sequence "LPX64": rc = %d\n",
-		       fld->lsf_name, seq, -EIO);
-		RETURN(-EIO);
+		       fld->lsf_name, seq, -ENOENT);
+		RETURN(-ENOENT);
 	} else {
-		LASSERT(fld->lsf_control_exp);
+		if (fld->lsf_control_exp == NULL) {
+			CERROR("%s: lookup "LPX64", but not connects to MDT0"
+			       "yet: rc = %d.\n", fld->lsf_name, seq, -EIO);
+			RETURN(-EIO);
+		}
 		/* send request to mdt0 i.e. super seq. controller.
 		 * This is temporary solution, long term solution is fld
 		 * replication on all mdt servers.
 		 */
 		range->lsr_start = seq;
 		rc = fld_client_rpc(fld->lsf_control_exp,
-				    range, FLD_LOOKUP);
+				    range, FLD_QUERY, NULL);
 		if (rc == 0)
 			fld_cache_insert(fld->lsf_cache, range);
 	}
@@ -163,115 +283,82 @@ EXPORT_SYMBOL(fld_server_lookup);
  * All MDT server handle fld lookup operation. But only MDT0 has fld index.
  * if entry is not found in cache we need to forward lookup request to MDT0
  */
-
-static int fld_server_handle(struct lu_server_fld *fld,
-                             const struct lu_env *env,
-                             __u32 opc, struct lu_seq_range *range,
-                             struct fld_thread_info *info)
+static int fld_handle_lookup(struct tgt_session_info *tsi)
 {
-        int rc;
-        ENTRY;
+	struct obd_export	*exp = tsi->tsi_exp;
+	struct lu_site		*site = exp->exp_obd->obd_lu_dev->ld_site;
+	struct lu_server_fld	*fld;
+	struct lu_seq_range	*in;
+	struct lu_seq_range	*out;
+	int			rc;
 
-        switch (opc) {
-        case FLD_LOOKUP:
-		rc = fld_server_lookup(env, fld, range->lsr_start, range);
-                break;
-        default:
-                rc = -EINVAL;
-                break;
-        }
+	ENTRY;
 
-        CDEBUG(D_INFO, "%s: FLD req handle: error %d (opc: %d, range: "
-               DRANGE"\n", fld->lsf_name, rc, opc, PRANGE(range));
+	in = req_capsule_client_get(tsi->tsi_pill, &RMF_FLD_MDFLD);
+	if (in == NULL)
+		RETURN(err_serious(-EPROTO));
 
-        RETURN(rc);
+	rc = req_capsule_server_pack(tsi->tsi_pill);
+	if (unlikely(rc != 0))
+		RETURN(err_serious(rc));
 
-}
+	out = req_capsule_server_get(tsi->tsi_pill, &RMF_FLD_MDFLD);
+	if (out == NULL)
+		RETURN(err_serious(-EPROTO));
+	*out = *in;
 
-static int fld_req_handle(struct ptlrpc_request *req,
-                          struct fld_thread_info *info)
-{
-        struct obd_export *exp = req->rq_export;
-        struct lu_site *site = exp->exp_obd->obd_lu_dev->ld_site;
-        struct lu_seq_range *in;
-        struct lu_seq_range *out;
-        int rc;
-        __u32 *opc;
-        ENTRY;
+	fld = lu_site2seq(site)->ss_server_fld;
 
-        rc = req_capsule_server_pack(info->fti_pill);
-        if (rc)
-                RETURN(err_serious(rc));
-
-        opc = req_capsule_client_get(info->fti_pill, &RMF_FLD_OPC);
-        if (opc != NULL) {
-                in = req_capsule_client_get(info->fti_pill, &RMF_FLD_MDFLD);
-                if (in == NULL)
-                        RETURN(err_serious(-EPROTO));
-                out = req_capsule_server_get(info->fti_pill, &RMF_FLD_MDFLD);
-                if (out == NULL)
-                        RETURN(err_serious(-EPROTO));
-                *out = *in;
-
-		/* For old 2.0 client, the 'lsr_flags' is uninitialized.
-		 * Set it as 'LU_SEQ_RANGE_MDT' by default. */
-		if (!(exp_connect_flags(exp) & OBD_CONNECT_64BITHASH) &&
-		    !(exp_connect_flags(exp) & OBD_CONNECT_MDS_MDS) &&
-		    !(exp_connect_flags(exp) & OBD_CONNECT_LIGHTWEIGHT) &&
-		    !exp->exp_libclient)
-			fld_range_set_mdt(out);
-
-		rc = fld_server_handle(lu_site2seq(site)->ss_server_fld,
-				       req->rq_svc_thread->t_env,
-				       *opc, out, info);
-	} else {
-                rc = err_serious(-EPROTO);
-	}
+	rc = fld_server_lookup(tsi->tsi_env, fld, in->lsr_start, out);
+
+	CDEBUG(D_INFO, "%s: FLD req handle: error %d (range: "DRANGE")\n",
+	       fld->lsf_name, rc, PRANGE(out));
 
 	RETURN(rc);
 }
 
-static void fld_thread_info_init(struct ptlrpc_request *req,
-                                 struct fld_thread_info *info)
+static int fld_handle_read(struct tgt_session_info *tsi)
 {
-        info->fti_pill = &req->rq_pill;
-        /* Init request capsule. */
-        req_capsule_init(info->fti_pill, req, RCL_SERVER);
-        req_capsule_set(info->fti_pill, &RQF_FLD_QUERY);
-}
+	struct obd_export	*exp = tsi->tsi_exp;
+	struct lu_site		*site = exp->exp_obd->obd_lu_dev->ld_site;
+	struct lu_seq_range	*in;
+	void			*data;
+	int			rc;
 
-static void fld_thread_info_fini(struct fld_thread_info *info)
-{
-        req_capsule_fini(info->fti_pill);
-}
+	ENTRY;
 
-static int fld_handle(struct ptlrpc_request *req)
-{
-        struct fld_thread_info *info;
-        const struct lu_env *env;
-        int rc;
+	req_capsule_set(tsi->tsi_pill, &RQF_FLD_READ);
+
+	in = req_capsule_client_get(tsi->tsi_pill, &RMF_FLD_MDFLD);
+	if (in == NULL)
+		RETURN(err_serious(-EPROTO));
 
-        env = req->rq_svc_thread->t_env;
-        LASSERT(env != NULL);
+	req_capsule_set_size(tsi->tsi_pill, &RMF_GENERIC_DATA, RCL_SERVER,
+			     PAGE_CACHE_SIZE);
 
-        info = lu_context_key_get(&env->le_ctx, &fld_thread_key);
-        LASSERT(info != NULL);
+	rc = req_capsule_server_pack(tsi->tsi_pill);
+	if (unlikely(rc != 0))
+		RETURN(err_serious(rc));
 
-        fld_thread_info_init(req, info);
-        rc = fld_req_handle(req, info);
-        fld_thread_info_fini(info);
+	data = req_capsule_server_get(tsi->tsi_pill, &RMF_GENERIC_DATA);
 
-        return rc;
+	rc = fld_server_read(tsi->tsi_env, lu_site2seq(site)->ss_server_fld,
+			     in, data, PAGE_CACHE_SIZE);
+	RETURN(rc);
 }
 
-/*
- * Entry point for handling FLD RPCs called from MDT.
- */
-int fld_query(struct com_thread_info *info)
+static int fld_handle_query(struct tgt_session_info *tsi)
 {
-        return fld_handle(info->cti_pill->rc_req);
+	int	rc;
+
+	ENTRY;
+
+	req_capsule_set(tsi->tsi_pill, &RQF_FLD_QUERY);
+
+	rc = fld_handle_lookup(tsi);
+
+	RETURN(rc);
 }
-EXPORT_SYMBOL(fld_query);
 
 /*
  * Returns true, if fid is local to this server node.
@@ -305,23 +392,21 @@ int fid_is_local(const struct lu_env *env,
 	}
 	return result;
 }
-EXPORT_SYMBOL(fid_is_local);
 
 static void fld_server_proc_fini(struct lu_server_fld *fld);
 
-#ifdef LPROCFS
+#ifdef CONFIG_PROC_FS
 static int fld_server_proc_init(struct lu_server_fld *fld)
 {
         int rc = 0;
         ENTRY;
 
-        fld->lsf_proc_dir = lprocfs_register(fld->lsf_name,
-                                             fld_type_proc_dir,
-                                             fld_server_proc_list, fld);
-        if (IS_ERR(fld->lsf_proc_dir)) {
-                rc = PTR_ERR(fld->lsf_proc_dir);
-                RETURN(rc);
-        }
+	fld->lsf_proc_dir = lprocfs_register(fld->lsf_name, fld_type_proc_dir,
+					     fld_server_proc_list, fld);
+	if (IS_ERR(fld->lsf_proc_dir)) {
+		rc = PTR_ERR(fld->lsf_proc_dir);
+		RETURN(rc);
+	}
 
 	rc = lprocfs_seq_create(fld->lsf_proc_dir, "fldb", 0444,
 				&fld_proc_seq_fops, fld);
@@ -356,50 +441,45 @@ static void fld_server_proc_fini(struct lu_server_fld *fld)
 #endif
 
 int fld_server_init(const struct lu_env *env, struct lu_server_fld *fld,
-		    struct dt_device *dt, const char *prefix, int mds_node_id,
-		    int type)
+		    struct dt_device *dt, const char *prefix, int type)
 {
 	int cache_size, cache_threshold;
 	int rc;
+
 	ENTRY;
 
-        snprintf(fld->lsf_name, sizeof(fld->lsf_name),
-                 "srv-%s", prefix);
+	snprintf(fld->lsf_name, sizeof(fld->lsf_name), "srv-%s", prefix);
 
-        cache_size = FLD_SERVER_CACHE_SIZE /
-                sizeof(struct fld_cache_entry);
+	cache_size = FLD_SERVER_CACHE_SIZE / sizeof(struct fld_cache_entry);
 
-        cache_threshold = cache_size *
-                FLD_SERVER_CACHE_THRESHOLD / 100;
+	cache_threshold = cache_size * FLD_SERVER_CACHE_THRESHOLD / 100;
 
 	mutex_init(&fld->lsf_lock);
-        fld->lsf_cache = fld_cache_init(fld->lsf_name,
-                                        cache_size, cache_threshold);
-        if (IS_ERR(fld->lsf_cache)) {
-                rc = PTR_ERR(fld->lsf_cache);
-                fld->lsf_cache = NULL;
-                GOTO(out, rc);
-        }
-
-	if (!mds_node_id && type == LU_SEQ_RANGE_MDT) {
-		rc = fld_index_init(env, fld, dt);
-                if (rc)
-                        GOTO(out, rc);
-        } else {
-                fld->lsf_obj = NULL;
+	fld->lsf_cache = fld_cache_init(fld->lsf_name, cache_size,
+					cache_threshold);
+	if (IS_ERR(fld->lsf_cache)) {
+		rc = PTR_ERR(fld->lsf_cache);
+		fld->lsf_cache = NULL;
+		RETURN(rc);
 	}
 
-        rc = fld_server_proc_init(fld);
-        if (rc)
-                GOTO(out, rc);
+	rc = fld_index_init(env, fld, dt, type);
+	if (rc)
+		GOTO(out_cache, rc);
 
-        fld->lsf_control_exp = NULL;
+	rc = fld_server_proc_init(fld);
+	if (rc)
+		GOTO(out_index, rc);
 
-	GOTO(out, rc);
+	fld->lsf_control_exp = NULL;
+	fld->lsf_seq_lookup = fld_server_lookup;
 
-out:
-	if (rc)
-		fld_server_fini(env, fld);
+	fld->lsf_seq_lookup = fld_server_lookup;
+	RETURN(0);
+out_index:
+	fld_index_fini(env, fld);
+out_cache:
+	fld_cache_fini(fld->lsf_cache);
 	return rc;
 }
 EXPORT_SYMBOL(fld_server_init);
@@ -420,3 +500,9 @@ void fld_server_fini(const struct lu_env *env, struct lu_server_fld *fld)
 	EXIT;
 }
 EXPORT_SYMBOL(fld_server_fini);
+
+struct tgt_handler fld_handlers[] = {
+TGT_FLD_HDL_VAR(0,	FLD_QUERY,	fld_handle_query),
+TGT_FLD_HDL_VAR(0,	FLD_READ,	fld_handle_read),
+};
+EXPORT_SYMBOL(fld_handlers);