X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fptlrpc%2Fnrs_crr.c;h=680cefb52d472627a4daeeca177820ebfbc5e013;hp=f03319a99d46cd70bed7ec453a16f4547801816b;hb=f07508d17b49574c7ea47a855c6e8af2b23c3add;hpb=500f334631c6ebec72f5791472f21603da3e0ef9

diff --git a/lustre/ptlrpc/nrs_crr.c b/lustre/ptlrpc/nrs_crr.c
index f03319a..680cefb 100644
--- a/lustre/ptlrpc/nrs_crr.c
+++ b/lustre/ptlrpc/nrs_crr.c
@@ -20,7 +20,7 @@
  * GPL HEADER END
  */
 /*
- * Copyright (c) 2011, 2014, Intel Corporation.
+ * Copyright (c) 2013, 2017, Intel Corporation.
  *
  * Copyright 2012 Xyratex Technology Limited
  */
@@ -96,63 +96,39 @@ static struct cfs_binheap_ops nrs_crrn_heap_ops = {
 };
 
 /**
- * libcfs_hash operations for nrs_crrn_net::cn_cli_hash
+ * rhashtable operations for nrs_crrn_net::cn_cli_hash
  *
  * This uses ptlrpc_request::rq_peer.nid as its key, in order to hash
  * nrs_crrn_client objects.
  */
-#define NRS_NID_BKT_BITS	8
-#define NRS_NID_BITS		16
-
-static unsigned nrs_crrn_hop_hash(struct cfs_hash *hs, const void *key,
-				  unsigned mask)
+static u32 nrs_crrn_hashfn(const void *data, u32 len, u32 seed)
 {
-	return cfs_hash_djb2_hash(key, sizeof(lnet_nid_t), mask);
-}
+	const lnet_nid_t *nid = data;
 
-static int nrs_crrn_hop_keycmp(const void *key, struct hlist_node *hnode)
-{
-	lnet_nid_t		*nid = (lnet_nid_t *)key;
-	struct nrs_crrn_client	*cli = hlist_entry(hnode,
-						       struct nrs_crrn_client,
-						       cc_hnode);
-	return *nid == cli->cc_nid;
+	seed ^= cfs_hash_64((u64)nid, 32);
+	return seed;
 }
 
-static void *nrs_crrn_hop_key(struct hlist_node *hnode)
+static int nrs_crrn_cmpfn(struct rhashtable_compare_arg *arg, const void *obj)
 {
-	struct nrs_crrn_client	*cli = hlist_entry(hnode,
-						       struct nrs_crrn_client,
-						       cc_hnode);
-	return &cli->cc_nid;
-}
+	const struct nrs_crrn_client *cli = obj;
+	const lnet_nid_t *nid = arg->key;
 
-static void *nrs_crrn_hop_object(struct hlist_node *hnode)
-{
-	return hlist_entry(hnode, struct nrs_crrn_client, cc_hnode);
+	return *nid != cli->cc_nid;
 }
 
-static void nrs_crrn_hop_get(struct cfs_hash *hs, struct hlist_node *hnode)
-{
-	struct nrs_crrn_client *cli = hlist_entry(hnode,
-						      struct nrs_crrn_client,
-						      cc_hnode);
-	atomic_inc(&cli->cc_ref);
-}
+static const struct rhashtable_params nrs_crrn_hash_params = {
+	.key_len        = sizeof(lnet_nid_t),
+	.key_offset	= offsetof(struct nrs_crrn_client, cc_nid),
+	.head_offset	= offsetof(struct nrs_crrn_client, cc_rhead),
+	.hashfn		= nrs_crrn_hashfn,
+	.obj_cmpfn	= nrs_crrn_cmpfn,
+};
 
-static void nrs_crrn_hop_put(struct cfs_hash *hs, struct hlist_node *hnode)
+static void nrs_crrn_exit(void *vcli, void *data)
 {
-	struct nrs_crrn_client	*cli = hlist_entry(hnode,
-						       struct nrs_crrn_client,
-						       cc_hnode);
-	atomic_dec(&cli->cc_ref);
-}
+	struct nrs_crrn_client *cli = vcli;
 
-static void nrs_crrn_hop_exit(struct cfs_hash *hs, struct hlist_node *hnode)
-{
-	struct nrs_crrn_client	*cli = hlist_entry(hnode,
-						       struct nrs_crrn_client,
-						       cc_hnode);
 	LASSERTF(atomic_read(&cli->cc_ref) == 0,
 		 "Busy CRR-N object from client with NID %s, with %d refs\n",
 		 libcfs_nid2str(cli->cc_nid), atomic_read(&cli->cc_ref));
@@ -160,17 +136,6 @@ static void nrs_crrn_hop_exit(struct cfs_hash *hs, struct hlist_node *hnode)
 	OBD_FREE_PTR(cli);
 }
 
-static struct cfs_hash_ops nrs_crrn_hash_ops = {
-	.hs_hash	= nrs_crrn_hop_hash,
-	.hs_keycmp	= nrs_crrn_hop_keycmp,
-	.hs_key		= nrs_crrn_hop_key,
-	.hs_object	= nrs_crrn_hop_object,
-	.hs_get		= nrs_crrn_hop_get,
-	.hs_put		= nrs_crrn_hop_put,
-	.hs_put_locked	= nrs_crrn_hop_put,
-	.hs_exit	= nrs_crrn_hop_exit,
-};
-
 /**
  * Called when a CRR-N policy instance is started.
  *
@@ -194,17 +159,11 @@ static int nrs_crrn_start(struct ptlrpc_nrs_policy *policy, char *arg)
 					     nrs_pol2cptab(policy),
 					     nrs_pol2cptid(policy));
 	if (net->cn_binheap == NULL)
-		GOTO(failed, rc = -ENOMEM);
-
-	net->cn_cli_hash = cfs_hash_create("nrs_crrn_nid_hash",
-					   NRS_NID_BITS, NRS_NID_BITS,
-					   NRS_NID_BKT_BITS, 0,
-					   CFS_HASH_MIN_THETA,
-					   CFS_HASH_MAX_THETA,
-					   &nrs_crrn_hash_ops,
-					   CFS_HASH_RW_BKTLOCK);
-	if (net->cn_cli_hash == NULL)
-		GOTO(failed, rc = -ENOMEM);
+		GOTO(out_net, rc = -ENOMEM);
+
+	rc = rhashtable_init(&net->cn_cli_hash, &nrs_crrn_hash_params);
+	if (rc)
+		GOTO(out_binheap, rc);
 
 	/**
 	 * Set default quantum value to max_rpcs_in_flight for non-MDS OSCs;
@@ -223,10 +182,9 @@ static int nrs_crrn_start(struct ptlrpc_nrs_policy *policy, char *arg)
 
 	RETURN(rc);
 
-failed:
-	if (net->cn_binheap != NULL)
-		cfs_binheap_destroy(net->cn_binheap);
-
+out_binheap:
+	cfs_binheap_destroy(net->cn_binheap);
+out_net:
 	OBD_FREE_PTR(net);
 
 	RETURN(rc);
@@ -248,11 +206,10 @@ static void nrs_crrn_stop(struct ptlrpc_nrs_policy *policy)
 
 	LASSERT(net != NULL);
 	LASSERT(net->cn_binheap != NULL);
-	LASSERT(net->cn_cli_hash != NULL);
 	LASSERT(cfs_binheap_is_empty(net->cn_binheap));
 
+	rhashtable_free_and_destroy(&net->cn_cli_hash, nrs_crrn_exit, NULL);
 	cfs_binheap_destroy(net->cn_binheap);
-	cfs_hash_putref(net->cn_cli_hash);
 
 	OBD_FREE_PTR(net);
 }
@@ -346,8 +303,9 @@ static int nrs_crrn_res_get(struct ptlrpc_nrs_policy *policy,
 	net = container_of(parent, struct nrs_crrn_net, cn_res);
 	req = container_of(nrq, struct ptlrpc_request, rq_nrq);
 
-	cli = cfs_hash_lookup(net->cn_cli_hash, &req->rq_peer.nid);
-	if (cli != NULL)
+	cli = rhashtable_lookup_fast(&net->cn_cli_hash, &req->rq_peer.nid,
+				     nrs_crrn_hash_params);
+	if (cli)
 		goto out;
 
 	OBD_CPT_ALLOC_GFP(cli, nrs_pol2cptab(policy), nrs_pol2cptid(policy),
@@ -357,14 +315,20 @@ static int nrs_crrn_res_get(struct ptlrpc_nrs_policy *policy,
 
 	cli->cc_nid = req->rq_peer.nid;
 
-	atomic_set(&cli->cc_ref, 1);
-	tmp = cfs_hash_findadd_unique(net->cn_cli_hash, &cli->cc_nid,
-				      &cli->cc_hnode);
-	if (tmp != cli) {
+	atomic_set(&cli->cc_ref, 0);
+
+	tmp = rhashtable_lookup_get_insert_fast(&net->cn_cli_hash,
+						&cli->cc_rhead,
+						nrs_crrn_hash_params);
+	if (tmp) {
+		/* insertion failed */
 		OBD_FREE_PTR(cli);
+		if (IS_ERR(tmp))
+			return PTR_ERR(tmp);
 		cli = tmp;
 	}
 out:
+	atomic_inc(&cli->cc_ref);
 	*resp = &cli->cc_res;
 
 	return 1;
@@ -380,8 +344,7 @@ out:
 static void nrs_crrn_res_put(struct ptlrpc_nrs_policy *policy,
 			     const struct ptlrpc_nrs_resource *res)
 {
-	struct nrs_crrn_net	*net;
-	struct nrs_crrn_client	*cli;
+	struct nrs_crrn_client *cli;
 
 	/**
 	 * Do nothing for freeing parent, nrs_crrn_net resources
@@ -390,9 +353,8 @@ static void nrs_crrn_res_put(struct ptlrpc_nrs_policy *policy,
 		return;
 
 	cli = container_of(res, struct nrs_crrn_client, cc_res);
-	net = container_of(res->res_parent, struct nrs_crrn_net, cn_res);
 
-	cfs_hash_put(net->cn_cli_hash, &cli->cc_hnode);
+	atomic_dec(&cli->cc_ref);
 }
 
 /**
@@ -611,10 +573,8 @@ static void nrs_crrn_req_stop(struct ptlrpc_nrs_policy *policy,
 	       libcfs_id2str(req->rq_peer), nrq->nr_u.crr.cr_round);
 }
 
-#ifdef CONFIG_PROC_FS
-
 /**
- * lprocfs interface
+ * debugfs interface
  */
 
 /**
@@ -705,7 +665,8 @@ ptlrpc_lprocfs_nrs_crrn_quantum_seq_write(struct file *file,
 					  size_t count,
 					  loff_t *off)
 {
-	struct ptlrpc_service	    *svc = ((struct seq_file *)file->private_data)->private;
+	struct seq_file		    *m = file->private_data;
+	struct ptlrpc_service	    *svc = m->private;
 	enum ptlrpc_nrs_queue_type   queue = 0;
 	char			     kernbuf[LPROCFS_NRS_WR_QUANTUM_MAX_CMD];
 	char			    *val;
@@ -732,7 +693,9 @@ ptlrpc_lprocfs_nrs_crrn_quantum_seq_write(struct file *file,
 	val = lprocfs_find_named_value(kernbuf, NRS_LPROCFS_QUANTUM_NAME_REG,
 				       &count_copy);
 	if (val != kernbuf) {
-		quantum_reg = simple_strtol(val, NULL, 10);
+		rc = kstrtol(val, 10, &quantum_reg);
+		if (rc)
+			return rc;
 
 		queue |= PTLRPC_NRS_QUEUE_REG;
 	}
@@ -748,7 +711,9 @@ ptlrpc_lprocfs_nrs_crrn_quantum_seq_write(struct file *file,
 		if (!nrs_svc_has_hp(svc))
 			return -ENODEV;
 
-		quantum_hp = simple_strtol(val, NULL, 10);
+		rc = kstrtol(val, 10, &quantum_hp);
+		if (rc)
+			return rc;
 
 		queue |= PTLRPC_NRS_QUEUE_HP;
 	}
@@ -758,10 +723,9 @@ ptlrpc_lprocfs_nrs_crrn_quantum_seq_write(struct file *file,
 	 * value
 	 */
 	if (queue == 0) {
-		if (!isdigit(kernbuf[0]))
-			return -EINVAL;
-
-		quantum_reg = simple_strtol(kernbuf, NULL, 10);
+		rc = kstrtol(kernbuf, 10, &quantum_reg);
+		if (rc)
+			return rc;
 
 		queue = PTLRPC_NRS_QUEUE_REG;
 
@@ -809,7 +773,8 @@ ptlrpc_lprocfs_nrs_crrn_quantum_seq_write(struct file *file,
 
 	return rc == -ENODEV && rc2 == -ENODEV ? -ENODEV : count;
 }
-LPROC_SEQ_FOPS(ptlrpc_lprocfs_nrs_crrn_quantum);
+
+LDEBUGFS_SEQ_FOPS(ptlrpc_lprocfs_nrs_crrn_quantum);
 
 /**
  * Initializes a CRR-N policy's lprocfs interface for service \a svc
@@ -828,28 +793,13 @@ static int nrs_crrn_lprocfs_init(struct ptlrpc_service *svc)
 		{ NULL }
 	};
 
-	if (svc->srv_procroot == NULL)
+	if (!svc->srv_debugfs_entry)
 		return 0;
 
-	return lprocfs_add_vars(svc->srv_procroot, nrs_crrn_lprocfs_vars, NULL);
+	return ldebugfs_add_vars(svc->srv_debugfs_entry, nrs_crrn_lprocfs_vars, NULL);
 }
 
 /**
- * Cleans up a CRR-N policy's lprocfs interface for service \a svc
- *
- * \param[in] svc the service
- */
-static void nrs_crrn_lprocfs_fini(struct ptlrpc_service *svc)
-{
-	if (svc->srv_procroot == NULL)
-		return;
-
-	lprocfs_remove_proc_entry("nrs_crrn_quantum", svc->srv_procroot);
-}
-
-#endif /* CONFIG_PROC_FS */
-
-/**
  * CRR-N policy operations
  */
 static const struct ptlrpc_nrs_pol_ops nrs_crrn_ops = {
@@ -862,10 +812,7 @@ static const struct ptlrpc_nrs_pol_ops nrs_crrn_ops = {
 	.op_req_enqueue		= nrs_crrn_req_add,
 	.op_req_dequeue		= nrs_crrn_req_del,
 	.op_req_stop		= nrs_crrn_req_stop,
-#ifdef CONFIG_PROC_FS
 	.op_lprocfs_init	= nrs_crrn_lprocfs_init,
-	.op_lprocfs_fini	= nrs_crrn_lprocfs_fini,
-#endif
 };
 
 /**