Mass conversion of all copyright messages to Oracle.

[fs/lustre-release.git] / lnet / lnet / peer.c

diff --git a/lnet/lnet/peer.c b/lnet/lnet/peer.c
index 7d68e6d..c2d51fe 100644 (file)
--- a/lnet/lnet/peer.c
+++ b/lnet/lnet/peer.c
@@ -26,7 +26,7 @@
  * GPL HEADER END
  */
 /*
- * Copyright  2008 Sun Microsystems, Inc. All rights reserved
+ * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  */
 /*
@@ -43,11 +43,11 @@
 int
 lnet_create_peer_table(void)
 {
-       struct list_head *hash;
-       int               i;
+       cfs_list_t  *hash;
+       int          i;
 
        LASSERT (the_lnet.ln_peer_hash == NULL);
-       LIBCFS_ALLOC(hash, LNET_PEER_HASHSIZE * sizeof(struct list_head));
+       LIBCFS_ALLOC(hash, LNET_PEER_HASHSIZE * sizeof(cfs_list_t));
        
        if (hash == NULL) {
                CERROR("Can't allocate peer hash table\n");
@@ -70,10 +70,10 @@ lnet_destroy_peer_table(void)
                 return;
 
        for (i = 0; i < LNET_PEER_HASHSIZE; i++)
-               LASSERT (list_empty(&the_lnet.ln_peer_hash[i]));
-       
+               LASSERT (cfs_list_empty(&the_lnet.ln_peer_hash[i]));
+
        LIBCFS_FREE(the_lnet.ln_peer_hash,
-                   LNET_PEER_HASHSIZE * sizeof (struct list_head));
+                   LNET_PEER_HASHSIZE * sizeof (cfs_list_t));
         the_lnet.ln_peer_hash = NULL;
 }
 
@@ -83,16 +83,17 @@ lnet_clear_peer_table(void)
        int         i;
 
         LASSERT (the_lnet.ln_shutdown);         /* i.e. no new peers */
-       
+
        for (i = 0; i < LNET_PEER_HASHSIZE; i++) {
-               struct list_head *peers = &the_lnet.ln_peer_hash[i];
+               cfs_list_t *peers = &the_lnet.ln_peer_hash[i];
 
                LNET_LOCK();
-               while (!list_empty(peers)) {
-                       lnet_peer_t *lp = list_entry(peers->next,
-                                                    lnet_peer_t, lp_hashlist);
-                       
-                       list_del(&lp->lp_hashlist);
+               while (!cfs_list_empty(peers)) {
+                       lnet_peer_t *lp = cfs_list_entry(peers->next,
+                                                         lnet_peer_t,
+                                                         lp_hashlist);
+
+                       cfs_list_del(&lp->lp_hashlist);
                         lnet_peer_decref_locked(lp);   /* lose hash table's ref */
                }
                LNET_UNLOCK();
@@ -120,8 +121,9 @@ lnet_destroy_peer_locked (lnet_peer_t *lp)
 
         LASSERT (lp->lp_refcount == 0);
         LASSERT (lp->lp_rtr_refcount == 0);
-       LASSERT (list_empty(&lp->lp_txq));
+       LASSERT (cfs_list_empty(&lp->lp_txq));
         LASSERT (lp->lp_txqnob == 0);
+        LASSERT (lp->lp_rcd == NULL);
 
        LIBCFS_FREE(lp, sizeof(*lp));
 
@@ -135,22 +137,22 @@ lnet_peer_t *
 lnet_find_peer_locked (lnet_nid_t nid)
 {
        unsigned int      idx = LNET_NIDADDR(nid) % LNET_PEER_HASHSIZE;
-       struct list_head *peers = &the_lnet.ln_peer_hash[idx];
-       struct list_head *tmp;
+       cfs_list_t       *peers = &the_lnet.ln_peer_hash[idx];
+       cfs_list_t       *tmp;
         lnet_peer_t      *lp;
 
        if (the_lnet.ln_shutdown)
                 return NULL;
 
-       list_for_each (tmp, peers) {
-               lp = list_entry(tmp, lnet_peer_t, lp_hashlist);
-               
+       cfs_list_for_each (tmp, peers) {
+               lp = cfs_list_entry(tmp, lnet_peer_t, lp_hashlist);
+
                if (lp->lp_nid == nid) {
                         lnet_peer_addref_locked(lp);
                        return lp;
                 }
        }
-        
+
        return NULL;
 }
 
@@ -184,11 +186,12 @@ lnet_nid2peer_locked(lnet_peer_t **lpp, lnet_nid_t nid)
         lp->lp_notifylnd = 0;
         lp->lp_notifying = 0;
         lp->lp_alive_count = 0;
-       lp->lp_timestamp = 0;
-       lp->lp_alive = !lnet_peers_start_down(); /* 1 bit!! */
-        lp->lp_last_alive = cfs_time_current_sec(); /* assumes alive */
+        lp->lp_timestamp = 0;
+        lp->lp_alive = !lnet_peers_start_down(); /* 1 bit!! */
+        lp->lp_last_alive = cfs_time_current(); /* assumes alive */
+        lp->lp_last_query = 0; /* haven't asked NI yet */
         lp->lp_ping_timestamp = 0;
-       lp->lp_nid = nid;
+        lp->lp_nid = nid;
         lp->lp_refcount = 2;                    /* 1 for caller; 1 for hash */
         lp->lp_rtr_refcount = 0;
 
@@ -220,17 +223,15 @@ lnet_nid2peer_locked(lnet_peer_t **lpp, lnet_nid_t nid)
                 return the_lnet.ln_shutdown ? -ESHUTDOWN : -EHOSTUNREACH;
         }
 
-       lp->lp_txcredits = 
-                lp->lp_mintxcredits = lp->lp_ni->ni_peertxcredits;
-
-        /* As a first approximation; allow this peer the same number of router
-         * buffers as it is allowed outstanding sends */
-        lp->lp_rtrcredits = lp->lp_minrtrcredits = lp->lp_txcredits;
+        lp->lp_txcredits    =
+        lp->lp_mintxcredits = lp->lp_ni->ni_peertxcredits;
+        lp->lp_rtrcredits    =
+        lp->lp_minrtrcredits = lnet_peer_buffer_credits(lp->lp_ni);
 
-        LASSERT (!the_lnet.ln_shutdown);
         /* can't add peers after shutdown starts */
+        LASSERT (!the_lnet.ln_shutdown);
 
-        list_add_tail(&lp->lp_hashlist, lnet_nid2peerhash(nid));
+        cfs_list_add_tail(&lp->lp_hashlist, lnet_nid2peerhash(nid));
         the_lnet.ln_npeers++;
         the_lnet.ln_peertable_version++;
         *lpp = lp;
@@ -253,7 +254,7 @@ lnet_debug_peer(lnet_nid_t nid)
                 return;
         }
 
-        if (lnet_isrouter(lp) || lp->lp_ni->ni_peertimeout > 0)
+        if (lnet_isrouter(lp) || lnet_peer_aliveness_enabled(lp))
                 aliveness = lp->lp_alive ? "up" : "down";
 
         CDEBUG(D_WARNING, "%-24s %4d %5s %5d %5d %5d %5d %5d %ld\n",