LU-12678 lnet: use list_first_entry() in lnet/klnds subdirectory.

[fs/lustre-release.git] / lnet / klnds / o2iblnd / o2iblnd_cb.c

diff --git a/lnet/klnds/o2iblnd/o2iblnd_cb.c b/lnet/klnds/o2iblnd/o2iblnd_cb.c
index 5e04b72..4e79dfd 100644 (file)
--- a/lnet/klnds/o2iblnd/o2iblnd_cb.c
+++ b/lnet/klnds/o2iblnd/o2iblnd_cb.c
@@ -99,9 +99,9 @@ kiblnd_txlist_done(struct list_head *txlist, int status,
 {
        struct kib_tx *tx;
 
-       while (!list_empty(txlist)) {
-               tx = list_entry(txlist->next, struct kib_tx, tx_list);
-
+       while ((tx = list_first_entry_or_null(txlist,
+                                             struct kib_tx,
+                                             tx_list)) != NULL) {
                list_del(&tx->tx_list);
                /* complete now */
                tx->tx_waiting = 0;
@@ -989,9 +989,8 @@ kiblnd_check_sends_locked(struct kib_conn *conn)
         LASSERT (conn->ibc_reserved_credits >= 0);
 
         while (conn->ibc_reserved_credits > 0 &&
-              !list_empty(&conn->ibc_tx_queue_rsrvd)) {
-               tx = list_entry(conn->ibc_tx_queue_rsrvd.next,
-                               struct kib_tx, tx_list);
+              (tx = list_first_entry_or_null(&conn->ibc_tx_queue_rsrvd,
+                                             struct kib_tx, tx_list)) != NULL) {
                list_move_tail(&tx->tx_list, &conn->ibc_tx_queue);
                 conn->ibc_reserved_credits--;
         }
@@ -1013,17 +1012,17 @@ kiblnd_check_sends_locked(struct kib_conn *conn)
 
                if (!list_empty(&conn->ibc_tx_queue_nocred)) {
                         credit = 0;
-                       tx = list_entry(conn->ibc_tx_queue_nocred.next,
-                                       struct kib_tx, tx_list);
+                       tx = list_first_entry(&conn->ibc_tx_queue_nocred,
+                                             struct kib_tx, tx_list);
                } else if (!list_empty(&conn->ibc_tx_noops)) {
                         LASSERT (!IBLND_OOB_CAPABLE(ver));
                         credit = 1;
-                       tx = list_entry(conn->ibc_tx_noops.next,
-                                       struct kib_tx, tx_list);
+                       tx = list_first_entry(&conn->ibc_tx_noops,
+                                             struct kib_tx, tx_list);
                } else if (!list_empty(&conn->ibc_tx_queue)) {
                         credit = 1;
-                       tx = list_entry(conn->ibc_tx_queue.next,
-                                       struct kib_tx, tx_list);
+                       tx = list_first_entry(&conn->ibc_tx_queue,
+                                             struct kib_tx, tx_list);
                 } else
                         break;
 
@@ -2075,9 +2074,9 @@ kiblnd_handle_early_rxs(struct kib_conn *conn)
        LASSERT(conn->ibc_state >= IBLND_CONN_ESTABLISHED);
 
        write_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
-       while (!list_empty(&conn->ibc_early_rxs)) {
-               rx = list_entry(conn->ibc_early_rxs.next,
-                               struct kib_rx, rx_list);
+       while ((rx = list_first_entry_or_null(&conn->ibc_early_rxs,
+                                             struct kib_rx,
+                                             rx_list)) != NULL) {
                list_del(&rx->rx_list);
                write_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
 
@@ -2361,8 +2360,8 @@ kiblnd_connreq_done(struct kib_conn *conn, int status)
         * scheduled.  We won't be using round robin on this first batch.
         */
        spin_lock(&conn->ibc_lock);
-       while (!list_empty(&txs)) {
-               tx = list_entry(txs.next, struct kib_tx, tx_list);
+       while ((tx = list_first_entry_or_null(&txs, struct kib_tx,
+                                             tx_list)) != NULL) {
                list_del(&tx->tx_list);
 
                kiblnd_queue_tx_locked(tx, conn);
@@ -3422,9 +3421,9 @@ kiblnd_check_conns (int idx)
         * connection. We can only be sure RDMA activity
         * has ceased once the QP has been modified.
         */
-       while (!list_empty(&closes)) {
-               conn = list_entry(closes.next,
-                                 struct kib_conn, ibc_connd_list);
+       while ((conn = list_first_entry_or_null(&closes,
+                                               struct kib_conn,
+                                               ibc_connd_list)) != NULL) {
                list_del(&conn->ibc_connd_list);
                kiblnd_close_conn(conn, -ETIMEDOUT);
                kiblnd_conn_decref(conn);
@@ -3434,9 +3433,9 @@ kiblnd_check_conns (int idx)
         * NOOP, but there were no non-blocking tx descs
         * free to do it last time...
         */
-       while (!list_empty(&checksends)) {
-               conn = list_entry(checksends.next,
-                                 struct kib_conn, ibc_connd_list);
+       while ((conn = list_first_entry_or_null(&checksends,
+                                               struct kib_conn,
+                                               ibc_connd_list)) != NULL) {
                list_del(&conn->ibc_connd_list);
 
                spin_lock(&conn->ibc_lock);
@@ -3494,11 +3493,11 @@ kiblnd_connd (void *arg)
 
                dropped_lock = false;
 
-               if (!list_empty(&kiblnd_data.kib_connd_zombies)) {
+               conn = list_first_entry_or_null(&kiblnd_data.kib_connd_zombies,
+                                               struct kib_conn, ibc_list);
+               if (conn) {
                        struct kib_peer_ni *peer_ni = NULL;
 
-                       conn = list_entry(kiblnd_data.kib_connd_zombies.next,
-                                         struct kib_conn, ibc_list);
                        list_del(&conn->ibc_list);
                        if (conn->ibc_reconnect) {
                                peer_ni = conn->ibc_peer;
@@ -3525,10 +3524,11 @@ kiblnd_connd (void *arg)
                                              &kiblnd_data.kib_reconn_wait);
                }
 
-               if (!list_empty(&kiblnd_data.kib_connd_conns)) {
+               conn = list_first_entry_or_null(&kiblnd_data.kib_connd_conns,
+                                               struct kib_conn, ibc_list);
+               if (conn) {
                        int wait;
-                       conn = list_entry(kiblnd_data.kib_connd_conns.next,
-                                         struct kib_conn, ibc_list);
+
                        list_del(&conn->ibc_list);
 
                        spin_unlock_irqrestore(lock, flags);
@@ -3554,11 +3554,11 @@ kiblnd_connd (void *arg)
                                                 &kiblnd_data.kib_reconn_list);
                        }
 
-                       if (list_empty(&kiblnd_data.kib_reconn_list))
+                       conn = list_first_entry_or_null(&kiblnd_data.kib_reconn_list,
+                                                       struct kib_conn, ibc_list);
+                       if (!conn)
                                break;
 
-                       conn = list_entry(kiblnd_data.kib_reconn_list.next,
-                                         struct kib_conn, ibc_list);
                        list_del(&conn->ibc_list);
 
                        spin_unlock_irqrestore(lock, flags);
@@ -3571,9 +3571,10 @@ kiblnd_connd (void *arg)
                        spin_lock_irqsave(lock, flags);
                }
 
-               if (!list_empty(&kiblnd_data.kib_connd_waits)) {
-                       conn = list_entry(kiblnd_data.kib_connd_waits.next,
-                                         struct kib_conn, ibc_list);
+               conn = list_first_entry_or_null(&kiblnd_data.kib_connd_waits,
+                                               struct kib_conn,
+                                               ibc_sched_list);
+               if (conn) {
                        list_del(&conn->ibc_list);
                        spin_unlock_irqrestore(lock, flags);
 
@@ -3788,9 +3789,10 @@ kiblnd_scheduler(void *arg)
 
                did_something = false;
 
-               if (!list_empty(&sched->ibs_conns)) {
-                       conn = list_entry(sched->ibs_conns.next,
-                                         struct kib_conn, ibc_sched_list);
+               conn = list_first_entry_or_null(&sched->ibs_conns,
+                                               struct kib_conn,
+                                               ibc_sched_list);
+               if (conn) {
                        /* take over kib_sched_conns' ref on conn... */
                        LASSERT(conn->ibc_scheduled);
                        list_del(&conn->ibc_sched_list);