Staging: lustre: Iterate list using list_for_each_entry

Code using doubly linked list is iterated generally  using list_empty and
list_entry functions, but it can be better written using list_for_each_entry
macro.

This patch replaces the while loop containing list_empty and list_entry with
list_for_each_entry and list_for_each_entry_safe. list_for_each_entry is a
macro which is used to iterate over a list of given type. So while loop used to
iterate over a list can be replaced with list_for_each_entry macro. However, if
list_del is used in the loop, then list_for_each_entry_safe is a better choice.
This transformation is done by using the following coccinelle script.

@ rule1 @
expression E1;
identifier I1, I2;
type T;
iterator name list_for_each_entry;
@@

- while (list_empty(&E1) == 0)
+ list_for_each_entry (I1, &E1, I2)
 {
	...when != T *I1;
- 	I1 = list_entry(E1.next, T, I2);
    ...when != list_del(...);
       when != list_del_init(...);
 }

@ rule2  @
expression E1;
identifier I1, I2;
type T;
iterator name list_for_each_entry_safe;
@@
   T *I1;
+  T *tmp;
  ...
- while (list_empty(&E1) == 0)
+ list_for_each_entry_safe (I1, tmp, &E1, I2)
 {
	...when != T *I1;
- 	I1 = list_entry(E1.next, T, I2);
    ...
 }

Signed-off-by: Somya Anand <somyaanand214@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd.c b/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd.c
index 2f2f71c4c052bda675a0b635068c0f891d7e01e7..1422d5668bf88c4046d231f88def911933529556 100644 (file)
--- a/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd.c
+++ b/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd.c
@@ -1893,13 +1893,11 @@ kiblnd_destroy_pmr_pool(kib_pool_t *pool)
 {
        kib_pmr_pool_t *ppo = container_of(pool, kib_pmr_pool_t, ppo_pool);
        kib_phys_mr_t  *pmr;
+       kib_phys_mr_t *tmp;
 
        LASSERT(pool->po_allocated == 0);
 
-       while (!list_empty(&pool->po_free_list)) {
-               pmr = list_entry(pool->po_free_list.next,
-                                    kib_phys_mr_t, pmr_list);
-
+       list_for_each_entry_safe(pmr, tmp, &pool->po_free_list, pmr_list) {
                LASSERT(pmr->pmr_mr == NULL);
                list_del(&pmr->pmr_list);
 

diff --git a/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd_cb.c b/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd_cb.c
index c762dbe106936c5fff5531d6e6dd9571ec5f7203..2e156a995e55589d36000cf3ffb9f024f05fe494 100644 (file)
--- a/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd_cb.c
+++ b/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd_cb.c
@@ -1936,14 +1936,13 @@ kiblnd_handle_early_rxs(kib_conn_t *conn)
 {
        unsigned long    flags;
        kib_rx_t        *rx;
+       kib_rx_t *tmp;
 
        LASSERT(!in_interrupt());
        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,
-                                   kib_rx_t, rx_list);
+       list_for_each_entry_safe(rx, tmp, &conn->ibc_early_rxs, rx_list) {
                list_del(&rx->rx_list);
                write_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
 
@@ -2074,6 +2073,7 @@ kiblnd_connreq_done(kib_conn_t *conn, int status)
 {
        kib_peer_t      *peer = conn->ibc_peer;
        kib_tx_t          *tx;
+       kib_tx_t *tmp;
        struct list_head         txs;
        unsigned long      flags;
        int             active;
@@ -2150,8 +2150,7 @@ kiblnd_connreq_done(kib_conn_t *conn, int status)
 
        /* Schedule blocked txs */
        spin_lock(&conn->ibc_lock);
-       while (!list_empty(&txs)) {
-               tx = list_entry(txs.next, kib_tx_t, tx_list);
+       list_for_each_entry_safe(tx, tmp, &txs, tx_list) {
                list_del(&tx->tx_list);
 
                kiblnd_queue_tx_locked(tx, conn);
@@ -3027,6 +3026,7 @@ kiblnd_check_conns(int idx)
        struct list_head    *ptmp;
        kib_peer_t    *peer;
        kib_conn_t    *conn;
+       kib_conn_t *tmp;
        struct list_head    *ctmp;
        unsigned long  flags;
 
@@ -3080,9 +3080,7 @@ kiblnd_check_conns(int idx)
        /* Handle timeout by closing the whole
         * 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,
-                                     kib_conn_t, ibc_connd_list);
+       list_for_each_entry_safe(conn, tmp, &closes, ibc_connd_list) {
                list_del(&conn->ibc_connd_list);
                kiblnd_close_conn(conn, -ETIMEDOUT);
                kiblnd_conn_decref(conn);