X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lnet%2Flnet%2Fpeer.c;h=363d27093ce703f8ffb642f33ce16ed75ca01b13;hb=2bcfce77a2712960fadac2f034c1df4826780608;hp=325be18e18721df325c33fa4b8d863e04aa430ef;hpb=3ba222d5230cd89713aaf11cf0d8a8bc7ca62107;p=fs%2Flustre-release.git

diff --git a/lnet/lnet/peer.c b/lnet/lnet/peer.c
index 325be18..363d270 100644
--- a/lnet/lnet/peer.c
+++ b/lnet/lnet/peer.c
@@ -26,6 +26,8 @@
 /*
  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
+ *
+ * Copyright (c) 2012, 2014, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -37,12 +39,13 @@
 #define DEBUG_SUBSYSTEM S_LNET
 
 #include <lnet/lib-lnet.h>
+#include <lnet/lib-dlc.h>
 
 int
 lnet_peer_tables_create(void)
 {
 	struct lnet_peer_table	*ptable;
-	cfs_list_t		*hash;
+	struct list_head	*hash;
 	int			i;
 	int			j;
 
@@ -54,7 +57,7 @@ lnet_peer_tables_create(void)
 	}
 
 	cfs_percpt_for_each(ptable, i, the_lnet.ln_peer_tables) {
-		CFS_INIT_LIST_HEAD(&ptable->pt_deathrow);
+		INIT_LIST_HEAD(&ptable->pt_deathrow);
 
 		LIBCFS_CPT_ALLOC(hash, lnet_cpt_table(), i,
 				 LNET_PEER_HASH_SIZE * sizeof(*hash));
@@ -65,7 +68,7 @@ lnet_peer_tables_create(void)
 		}
 
 		for (j = 0; j < LNET_PEER_HASH_SIZE; j++)
-			CFS_INIT_LIST_HEAD(&hash[j]);
+			INIT_LIST_HEAD(&hash[j]);
 		ptable->pt_hash = hash; /* sign of initialization */
 	}
 
@@ -76,7 +79,7 @@ void
 lnet_peer_tables_destroy(void)
 {
 	struct lnet_peer_table	*ptable;
-	cfs_list_t		*hash;
+	struct list_head	*hash;
 	int			i;
 	int			j;
 
@@ -88,11 +91,11 @@ lnet_peer_tables_destroy(void)
 		if (hash == NULL) /* not intialized */
 			break;
 
-		LASSERT(cfs_list_empty(&ptable->pt_deathrow));
+		LASSERT(list_empty(&ptable->pt_deathrow));
 
 		ptable->pt_hash = NULL;
 		for (j = 0; j < LNET_PEER_HASH_SIZE; j++)
-			LASSERT(cfs_list_empty(&hash[j]));
+			LASSERT(list_empty(&hash[j]));
 
 		LIBCFS_FREE(hash, LNET_PEER_HASH_SIZE * sizeof(*hash));
 	}
@@ -101,61 +104,111 @@ lnet_peer_tables_destroy(void)
 	the_lnet.ln_peer_tables = NULL;
 }
 
+static void
+lnet_peer_table_cleanup_locked(lnet_ni_t *ni, struct lnet_peer_table *ptable)
+{
+	int		 i;
+	lnet_peer_t	*lp;
+	lnet_peer_t	*tmp;
+
+	for (i = 0; i < LNET_PEER_HASH_SIZE; i++) {
+		list_for_each_entry_safe(lp, tmp, &ptable->pt_hash[i],
+					 lp_hashlist) {
+			if (ni != NULL && ni != lp->lp_ni)
+				continue;
+			list_del_init(&lp->lp_hashlist);
+			/* Lose hash table's ref */
+			ptable->pt_zombies++;
+			lnet_peer_decref_locked(lp);
+		}
+	}
+}
+
+static void
+lnet_peer_table_deathrow_wait_locked(struct lnet_peer_table *ptable,
+				     int cpt_locked)
+{
+	int	i;
+
+	for (i = 3; ptable->pt_zombies != 0; i++) {
+		lnet_net_unlock(cpt_locked);
+
+		if (IS_PO2(i)) {
+			CDEBUG(D_WARNING,
+			       "Waiting for %d zombies on peer table\n",
+			       ptable->pt_zombies);
+		}
+		cfs_pause(cfs_time_seconds(1) >> 1);
+		lnet_net_lock(cpt_locked);
+	}
+}
+
+static void
+lnet_peer_table_del_rtrs_locked(lnet_ni_t *ni, struct lnet_peer_table *ptable,
+				int cpt_locked)
+{
+	lnet_peer_t	*lp;
+	lnet_peer_t	*tmp;
+	lnet_nid_t	 lp_nid;
+	int		 i;
+
+	for (i = 0; i < LNET_PEER_HASH_SIZE; i++) {
+		list_for_each_entry_safe(lp, tmp, &ptable->pt_hash[i],
+					 lp_hashlist) {
+			if (ni != lp->lp_ni)
+				continue;
+
+			if (lp->lp_rtr_refcount == 0)
+				continue;
+
+			lp_nid = lp->lp_nid;
+
+			lnet_net_unlock(cpt_locked);
+			lnet_del_route(LNET_NIDNET(LNET_NID_ANY), lp_nid);
+			lnet_net_lock(cpt_locked);
+		}
+	}
+}
+
 void
-lnet_peer_tables_cleanup(void)
+lnet_peer_tables_cleanup(lnet_ni_t *ni)
 {
-	struct lnet_peer_table	*ptable;
 	int			i;
-	int			j;
+	struct lnet_peer_table	*ptable;
+	lnet_peer_t		*lp;
+	struct list_head	deathrow;
 
-	LASSERT(the_lnet.ln_shutdown);	/* i.e. no new peers */
+	INIT_LIST_HEAD(&deathrow);
 
+	LASSERT(the_lnet.ln_shutdown || ni != NULL);
+	/* If just deleting the peers for a NI, get rid of any routes these
+	 * peers are gateways for. */
 	cfs_percpt_for_each(ptable, i, the_lnet.ln_peer_tables) {
 		lnet_net_lock(i);
-
-		for (j = 0; j < LNET_PEER_HASH_SIZE; j++) {
-			cfs_list_t *peers = &ptable->pt_hash[j];
-
-			while (!cfs_list_empty(peers)) {
-				lnet_peer_t *lp = cfs_list_entry(peers->next,
-								 lnet_peer_t,
-								 lp_hashlist);
-				cfs_list_del_init(&lp->lp_hashlist);
-				/* lose hash table's ref */
-				lnet_peer_decref_locked(lp);
-			}
-		}
-
+		lnet_peer_table_del_rtrs_locked(ni, ptable, i);
 		lnet_net_unlock(i);
 	}
 
+	/* Start the process of moving the applicable peers to
+	 * deathrow. */
 	cfs_percpt_for_each(ptable, i, the_lnet.ln_peer_tables) {
-		CFS_LIST_HEAD	(deathrow);
-		lnet_peer_t	*lp;
-
 		lnet_net_lock(i);
+		lnet_peer_table_cleanup_locked(ni, ptable);
+		lnet_net_unlock(i);
+	}
 
-		for (j = 3; ptable->pt_number != 0; j++) {
-			lnet_net_unlock(i);
-
-			if ((j & (j - 1)) == 0) {
-				CDEBUG(D_WARNING,
-				       "Waiting for %d peers on peer table\n",
-				       ptable->pt_number);
-			}
-			cfs_pause(cfs_time_seconds(1) / 2);
-			lnet_net_lock(i);
-		}
-		cfs_list_splice_init(&ptable->pt_deathrow, &deathrow);
-
+	/* Cleanup all entries on deathrow. */
+	cfs_percpt_for_each(ptable, i, the_lnet.ln_peer_tables) {
+		lnet_net_lock(i);
+		lnet_peer_table_deathrow_wait_locked(ptable, i);
+		list_splice_init(&ptable->pt_deathrow, &deathrow);
 		lnet_net_unlock(i);
+	}
 
-		while (!cfs_list_empty(&deathrow)) {
-			lp = cfs_list_entry(deathrow.next,
-					    lnet_peer_t, lp_hashlist);
-			cfs_list_del(&lp->lp_hashlist);
-			LIBCFS_FREE(lp, sizeof(*lp));
-		}
+	while (!list_empty(&deathrow)) {
+		lp = list_entry(deathrow.next, lnet_peer_t, lp_hashlist);
+		list_del(&lp->lp_hashlist);
+		LIBCFS_FREE(lp, sizeof(*lp));
 	}
 }
 
@@ -166,8 +219,8 @@ lnet_destroy_peer_locked(lnet_peer_t *lp)
 
 	LASSERT(lp->lp_refcount == 0);
 	LASSERT(lp->lp_rtr_refcount == 0);
-	LASSERT(cfs_list_empty(&lp->lp_txq));
-	LASSERT(cfs_list_empty(&lp->lp_hashlist));
+	LASSERT(list_empty(&lp->lp_txq));
+	LASSERT(list_empty(&lp->lp_hashlist));
 	LASSERT(lp->lp_txqnob == 0);
 
 	ptable = the_lnet.ln_peer_tables[lp->lp_cpt];
@@ -177,19 +230,21 @@ lnet_destroy_peer_locked(lnet_peer_t *lp)
 	lnet_ni_decref_locked(lp->lp_ni, lp->lp_cpt);
 	lp->lp_ni = NULL;
 
-	cfs_list_add(&lp->lp_hashlist, &ptable->pt_deathrow);
+	list_add(&lp->lp_hashlist, &ptable->pt_deathrow);
+	LASSERT(ptable->pt_zombies > 0);
+	ptable->pt_zombies--;
 }
 
 lnet_peer_t *
 lnet_find_peer_locked(struct lnet_peer_table *ptable, lnet_nid_t nid)
 {
-	cfs_list_t	*peers;
-	lnet_peer_t	*lp;
+	struct list_head *peers;
+	lnet_peer_t	 *lp;
 
 	LASSERT(!the_lnet.ln_shutdown);
 
 	peers = &ptable->pt_hash[lnet_nid2peerhash(nid)];
-	cfs_list_for_each_entry(lp, peers, lp_hashlist) {
+	list_for_each_entry(lp, peers, lp_hashlist) {
 		if (lp->lp_nid == nid) {
 			lnet_peer_addref_locked(lp);
 			return lp;
@@ -222,10 +277,10 @@ lnet_nid2peer_locked(lnet_peer_t **lpp, lnet_nid_t nid, int cpt)
 		return 0;
 	}
 
-	if (!cfs_list_empty(&ptable->pt_deathrow)) {
-		lp = cfs_list_entry(ptable->pt_deathrow.next,
-				    lnet_peer_t, lp_hashlist);
-		cfs_list_del(&lp->lp_hashlist);
+	if (!list_empty(&ptable->pt_deathrow)) {
+		lp = list_entry(ptable->pt_deathrow.next,
+				lnet_peer_t, lp_hashlist);
+		list_del(&lp->lp_hashlist);
 	}
 
 	/*
@@ -246,9 +301,9 @@ lnet_nid2peer_locked(lnet_peer_t **lpp, lnet_nid_t nid, int cpt)
 		goto out;
 	}
 
-	CFS_INIT_LIST_HEAD(&lp->lp_txq);
-	CFS_INIT_LIST_HEAD(&lp->lp_rtrq);
-	CFS_INIT_LIST_HEAD(&lp->lp_routes);
+	INIT_LIST_HEAD(&lp->lp_txq);
+	INIT_LIST_HEAD(&lp->lp_rtrq);
+	INIT_LIST_HEAD(&lp->lp_routes);
 
         lp->lp_notify = 0;
         lp->lp_notifylnd = 0;
@@ -289,15 +344,15 @@ lnet_nid2peer_locked(lnet_peer_t **lpp, lnet_nid_t nid, int cpt)
 	lp->lp_rtrcredits    =
 	lp->lp_minrtrcredits = lnet_peer_buffer_credits(lp->lp_ni);
 
-	cfs_list_add_tail(&lp->lp_hashlist,
-			  &ptable->pt_hash[lnet_nid2peerhash(nid)]);
+	list_add_tail(&lp->lp_hashlist,
+		      &ptable->pt_hash[lnet_nid2peerhash(nid)]);
 	ptable->pt_version++;
 	*lpp = lp;
 
 	return 0;
 out:
 	if (lp != NULL)
-		cfs_list_add(&lp->lp_hashlist, &ptable->pt_deathrow);
+		list_add(&lp->lp_hashlist, &ptable->pt_deathrow);
 	ptable->pt_number--;
 	return rc;
 }
@@ -320,7 +375,7 @@ lnet_debug_peer(lnet_nid_t nid)
                 return;
         }
 
-        if (lnet_isrouter(lp) || lnet_peer_aliveness_enabled(lp))
+	if (lnet_peer_aliveness_enabled(lp))
                 aliveness = lp->lp_alive ? "up" : "down";
 
         CDEBUG(D_WARNING, "%-24s %4d %5s %5d %5d %5d %5d %5d %ld\n",
@@ -333,3 +388,64 @@ lnet_debug_peer(lnet_nid_t nid)
 
 	lnet_net_unlock(cpt);
 }
+
+int lnet_get_peer_info(__u32 peer_index, __u64 *nid,
+		       char aliveness[LNET_MAX_STR_LEN],
+		       __u32 *cpt_iter, __u32 *refcount,
+		       __u32 *ni_peer_tx_credits, __u32 *peer_tx_credits,
+		       __u32 *peer_rtr_credits, __u32 *peer_min_rtr_credits,
+		       __u32 *peer_tx_qnob)
+{
+	struct lnet_peer_table	*peer_table;
+	lnet_peer_t		*lp;
+	int			j;
+	int			lncpt;
+	bool			found = false;
+
+	/* get the number of CPTs */
+	lncpt = cfs_percpt_number(the_lnet.ln_peer_tables);
+
+	/* if the cpt number to be examined is >= the number of cpts in
+	 * the system then indicate that there are no more cpts to examin
+	 */
+	if (*cpt_iter > lncpt)
+		return -ENOENT;
+
+	/* get the current table */
+	peer_table = the_lnet.ln_peer_tables[*cpt_iter];
+	/* if the ptable is NULL then there are no more cpts to examine */
+	if (peer_table == NULL)
+		return -ENOENT;
+
+	lnet_net_lock(*cpt_iter);
+
+	for (j = 0; j < LNET_PEER_HASH_SIZE && !found; j++) {
+		struct list_head *peers = &peer_table->pt_hash[j];
+
+		list_for_each_entry(lp, peers, lp_hashlist) {
+			if (peer_index-- > 0)
+				continue;
+
+			snprintf(aliveness, LNET_MAX_STR_LEN, "NA");
+			if (lnet_peer_aliveness_enabled(lp))
+				snprintf(aliveness, LNET_MAX_STR_LEN,
+					 lp->lp_alive ? "up" : "down");
+
+			*nid = lp->lp_nid;
+			*refcount = lp->lp_refcount;
+			*ni_peer_tx_credits = lp->lp_ni->ni_peertxcredits;
+			*peer_tx_credits = lp->lp_txcredits;
+			*peer_rtr_credits = lp->lp_rtrcredits;
+			*peer_min_rtr_credits = lp->lp_mintxcredits;
+			*peer_tx_qnob = lp->lp_txqnob;
+
+			found = true;
+		}
+
+	}
+	lnet_net_unlock(*cpt_iter);
+
+	*cpt_iter = lncpt;
+
+	return found ? 0 : -ENOENT;
+}