LU-3963 libcfs: convert LNET layer to linux list api

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

diff --git a/lnet/lnet/peer.c b/lnet/lnet/peer.c
index 27be863..182f44d 100644 (file)
--- a/lnet/lnet/peer.c
+++ b/lnet/lnet/peer.c
@@ -44,7 +44,7 @@ int
 lnet_peer_tables_create(void)
 {
        struct lnet_peer_table  *ptable;
-       cfs_list_t              *hash;
+       struct list_head        *hash;
        int                     i;
        int                     j;
 
@@ -56,7 +56,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));
@@ -67,7 +67,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 */
        }
 
@@ -78,7 +78,7 @@ void
 lnet_peer_tables_destroy(void)
 {
        struct lnet_peer_table  *ptable;
-       cfs_list_t              *hash;
+       struct list_head        *hash;
        int                     i;
        int                     j;
 
@@ -90,11 +90,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));
        }
@@ -116,13 +116,13 @@ lnet_peer_tables_cleanup(void)
                lnet_net_lock(i);
 
                for (j = 0; j < LNET_PEER_HASH_SIZE; j++) {
-                       cfs_list_t *peers = &ptable->pt_hash[j];
+                       struct list_head *peers = &ptable->pt_hash[j];
 
-                       while (!cfs_list_empty(peers)) {
-                               lnet_peer_t *lp = cfs_list_entry(peers->next,
+                       while (!list_empty(peers)) {
+                               lnet_peer_t *lp = list_entry(peers->next,
                                                                 lnet_peer_t,
                                                                 lp_hashlist);
-                               cfs_list_del_init(&lp->lp_hashlist);
+                               list_del_init(&lp->lp_hashlist);
                                /* lose hash table's ref */
                                lnet_peer_decref_locked(lp);
                        }
@@ -132,7 +132,7 @@ lnet_peer_tables_cleanup(void)
        }
 
        cfs_percpt_for_each(ptable, i, the_lnet.ln_peer_tables) {
-               CFS_LIST_HEAD   (deathrow);
+               struct list_head deathrow = LIST_HEAD_INIT(deathrow);
                lnet_peer_t     *lp;
 
                lnet_net_lock(i);
@@ -148,14 +148,14 @@ lnet_peer_tables_cleanup(void)
                        cfs_pause(cfs_time_seconds(1) / 2);
                        lnet_net_lock(i);
                }
-               cfs_list_splice_init(&ptable->pt_deathrow, &deathrow);
+               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);
+               while (!list_empty(&deathrow)) {
+                       lp = list_entry(deathrow.next,
+                                       lnet_peer_t, lp_hashlist);
+                       list_del(&lp->lp_hashlist);
                        LIBCFS_FREE(lp, sizeof(*lp));
                }
        }
@@ -168,8 +168,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];
@@ -179,19 +179,19 @@ 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);
 }
 
 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;
@@ -224,10 +224,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);
        }
 
        /*
@@ -248,9 +248,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;
@@ -291,15 +291,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;
 }