staging/mei: don't check if list is empty before looping

1. No need to check if a list is empty before list_for_each_ looping as
this is already checked by loop stopping conditional.

The side effect is reduced indentation depth
from:
	if (!list_empty)
		list_for_each()
to:
	list_for_each()

2. drop cb_ prefix from cl_pos, cl_next variables used in list_for_each
loops. The code is more compact and readable

Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

diff --git a/drivers/staging/mei/init.c b/drivers/staging/mei/init.c
index 4cc184e617210cba773759429de576da5c73cbd6..32cf05ee5feca8a4dd8c754956d9d48f76e4f5af 100644 (file)
--- a/drivers/staging/mei/init.c
+++ b/drivers/staging/mei/init.c
@@ -48,20 +48,15 @@ void mei_io_list_init(struct mei_io_list *list)
  */
 void mei_io_list_flush(struct mei_io_list *list, struct mei_cl *cl)
 {
-       struct mei_cl_cb *cb_pos = NULL;
-       struct mei_cl_cb *cb_next = NULL;
-
-
-       if (list_empty(&list->mei_cb.cb_list))
-               return;
+       struct mei_cl_cb *pos = NULL;
+       struct mei_cl_cb *next = NULL;
 
-       list_for_each_entry_safe(cb_pos, cb_next,
-                                &list->mei_cb.cb_list, cb_list) {
-               if (cb_pos) {
+       list_for_each_entry_safe(pos, next, &list->mei_cb.cb_list, cb_list) {
+               if (pos) {
                        struct mei_cl *cl_tmp;
-                       cl_tmp = (struct mei_cl *)cb_pos->file_private;
+                       cl_tmp = (struct mei_cl *)pos->file_private;
                        if (mei_cl_cmp_id(cl, cl_tmp))
-                               list_del(&cb_pos->cb_list);
+                               list_del(&pos->cb_list);
                }
        }
 }
@@ -335,14 +330,12 @@ void mei_reset(struct mei_device *dev, int interrupts_enabled)
                }
        }
        /* remove all waiting requests */
-       if (!list_empty(&dev->write_list.mei_cb.cb_list)) {
-               list_for_each_entry_safe(cb_pos, cb_next,
-                               &dev->write_list.mei_cb.cb_list, cb_list) {
-                       if (cb_pos) {
-                               list_del(&cb_pos->cb_list);
-                               mei_free_cb_private(cb_pos);
-                               cb_pos = NULL;
-                       }
+       list_for_each_entry_safe(cb_pos, cb_next,
+                       &dev->write_list.mei_cb.cb_list, cb_list) {
+               if (cb_pos) {
+                       list_del(&cb_pos->cb_list);
+                       mei_free_cb_private(cb_pos);
+                       cb_pos = NULL;
                }
        }
 }

diff --git a/drivers/staging/mei/interrupt.c b/drivers/staging/mei/interrupt.c
index ab9c4c0af098cb84e89bd10b24f333adf53a7a96..38e0197475e2d062dd6013db39593604f41ed199 100644 (file)
--- a/drivers/staging/mei/interrupt.c
+++ b/drivers/staging/mei/interrupt.c
@@ -412,21 +412,20 @@ static void mei_client_connect_response(struct mei_device *dev,
                dev->iamthif_state = MEI_IAMTHIF_IDLE;
                return;
        }
-       if (!list_empty(&dev->ctrl_rd_list.mei_cb.cb_list)) {
-               list_for_each_entry_safe(cb_pos, cb_next,
-                       &dev->ctrl_rd_list.mei_cb.cb_list, cb_list) {
-                       cl = (struct mei_cl *)cb_pos->file_private;
-                       if (!cl) {
+       list_for_each_entry_safe(cb_pos, cb_next,
+                               &dev->ctrl_rd_list.mei_cb.cb_list, cb_list) {
+
+               cl = (struct mei_cl *)cb_pos->file_private;
+               if (!cl) {
+                       list_del(&cb_pos->cb_list);
+                       return;
+               }
+               if (MEI_IOCTL == cb_pos->major_file_operations) {
+                       if (is_treat_specially_client(cl, rs)) {
                                list_del(&cb_pos->cb_list);
-                               return;
-                       }
-                       if (MEI_IOCTL == cb_pos->major_file_operations) {
-                               if (is_treat_specially_client(cl, rs)) {
-                                       list_del(&cb_pos->cb_list);
-                                       cl->status = 0;
-                                       cl->timer_count = 0;
-                                       break;
-                               }
+                               cl->status = 0;
+                               cl->timer_count = 0;
+                               break;
                        }
                }
        }
@@ -453,28 +452,26 @@ static void mei_client_disconnect_response(struct mei_device *dev,
                        rs->host_addr,
                        rs->status);
 
-       if (!list_empty(&dev->ctrl_rd_list.mei_cb.cb_list)) {
-               list_for_each_entry_safe(cb_pos, cb_next,
-                               &dev->ctrl_rd_list.mei_cb.cb_list, cb_list) {
-                       cl = (struct mei_cl *)cb_pos->file_private;
+       list_for_each_entry_safe(cb_pos, cb_next,
+                       &dev->ctrl_rd_list.mei_cb.cb_list, cb_list) {
+               cl = (struct mei_cl *)cb_pos->file_private;
 
-                       if (!cl) {
-                               list_del(&cb_pos->cb_list);
-                               return;
-                       }
+               if (!cl) {
+                       list_del(&cb_pos->cb_list);
+                       return;
+               }
 
-                       dev_dbg(&dev->pdev->dev, "list_for_each_entry_safe in ctrl_rd_list.\n");
-                       if (cl->host_client_id == rs->host_addr &&
-                           cl->me_client_id == rs->me_addr) {
+               dev_dbg(&dev->pdev->dev, "list_for_each_entry_safe in ctrl_rd_list.\n");
+               if (cl->host_client_id == rs->host_addr &&
+                   cl->me_client_id == rs->me_addr) {
 
-                               list_del(&cb_pos->cb_list);
-                               if (!rs->status)
-                                       cl->state = MEI_FILE_DISCONNECTED;
+                       list_del(&cb_pos->cb_list);
+                       if (!rs->status)
+                               cl->state = MEI_FILE_DISCONNECTED;
 
-                               cl->status = 0;
-                               cl->timer_count = 0;
-                               break;
-                       }
+                       cl->status = 0;
+                       cl->timer_count = 0;
+                       break;
                }
        }
 }
@@ -1222,7 +1219,7 @@ static int mei_irq_thread_write_handler(struct mei_io_list *cmpl_list,
 {
 
        struct mei_cl *cl;
-       struct mei_cl_cb *cb_pos = NULL, *cb_next = NULL;
+       struct mei_cl_cb *pos = NULL, *next = NULL;
        struct mei_io_list *list;
        int ret;
 
@@ -1235,36 +1232,31 @@ static int mei_irq_thread_write_handler(struct mei_io_list *cmpl_list,
        dev_dbg(&dev->pdev->dev, "complete all waiting for write cb.\n");
 
        list = &dev->write_waiting_list;
-       if (!list_empty(&list->mei_cb.cb_list)) {
-               list_for_each_entry_safe(cb_pos, cb_next,
-                               &list->mei_cb.cb_list, cb_list) {
-                       cl = (struct mei_cl *)cb_pos->file_private;
-                       if (cl) {
-                               cl->status = 0;
-                               list_del(&cb_pos->cb_list);
-                               if (MEI_WRITING == cl->writing_state &&
-                                  (cb_pos->major_file_operations ==
-                                               MEI_WRITE) &&
-                                  (cl != &dev->iamthif_cl)) {
-                                       dev_dbg(&dev->pdev->dev,
-                                               "MEI WRITE COMPLETE\n");
-                                       cl->writing_state =
-                                                       MEI_WRITE_COMPLETE;
-                                       list_add_tail(&cb_pos->cb_list,
-                                               &cmpl_list->mei_cb.cb_list);
-                               }
-                               if (cl == &dev->iamthif_cl) {
-                                       dev_dbg(&dev->pdev->dev, "check iamthif flow control.\n");
-                                       if (dev->iamthif_flow_control_pending) {
-                                               ret =
-                                               _mei_irq_thread_iamthif_read(
-                                                               dev, slots);
-                                               if (ret)
-                                                       return ret;
-                                       }
-                               }
+       list_for_each_entry_safe(pos, next,
+                       &list->mei_cb.cb_list, cb_list) {
+               cl = (struct mei_cl *)pos->file_private;
+               if (cl == NULL)
+                       continue;
+
+               cl->status = 0;
+               list_del(&pos->cb_list);
+               if (MEI_WRITING == cl->writing_state &&
+                  (pos->major_file_operations == MEI_WRITE) &&
+                  (cl != &dev->iamthif_cl)) {
+                       dev_dbg(&dev->pdev->dev,
+                               "MEI WRITE COMPLETE\n");
+                       cl->writing_state = MEI_WRITE_COMPLETE;
+                       list_add_tail(&pos->cb_list,
+                               &cmpl_list->mei_cb.cb_list);
+               }
+               if (cl == &dev->iamthif_cl) {
+                       dev_dbg(&dev->pdev->dev, "check iamthif flow control.\n");
+                       if (dev->iamthif_flow_control_pending) {
+                               ret = _mei_irq_thread_iamthif_read(
+                                               dev, slots);
+                               if (ret)
+                                       return ret;
                        }
-
                }
        }
 
@@ -1312,24 +1304,24 @@ static int mei_irq_thread_write_handler(struct mei_io_list *cmpl_list,
 
        /* complete control write list CB */
        dev_dbg(&dev->pdev->dev, "complete control write list cb.\n");
-       list_for_each_entry_safe(cb_pos, cb_next,
+       list_for_each_entry_safe(pos, next,
                                &dev->ctrl_wr_list.mei_cb.cb_list, cb_list) {
-               cl = (struct mei_cl *) cb_pos->file_private;
+               cl = (struct mei_cl *) pos->file_private;
                if (!cl) {
-                       list_del(&cb_pos->cb_list);
+                       list_del(&pos->cb_list);
                        return -ENODEV;
                }
-               switch (cb_pos->major_file_operations) {
+               switch (pos->major_file_operations) {
                case MEI_CLOSE:
                        /* send disconnect message */
-                       ret = _mei_irq_thread_close(dev, slots, cb_pos, cl, cmpl_list);
+                       ret = _mei_irq_thread_close(dev, slots, pos, cl, cmpl_list);
                        if (ret)
                                return ret;
 
                        break;
                case MEI_READ:
                        /* send flow control message */
-                       ret = _mei_irq_thread_read(dev, slots, cb_pos, cl, cmpl_list);
+                       ret = _mei_irq_thread_read(dev, slots, pos, cl, cmpl_list);
                        if (ret)
                                return ret;
 
@@ -1338,7 +1330,7 @@ static int mei_irq_thread_write_handler(struct mei_io_list *cmpl_list,
                        /* connect message */
                        if (!mei_other_client_is_connecting(dev, cl))
                                continue;
-                       ret = _mei_irq_thread_ioctl(dev, slots, cb_pos, cl, cmpl_list);
+                       ret = _mei_irq_thread_ioctl(dev, slots, pos, cl, cmpl_list);
                        if (ret)
                                return ret;
 
@@ -1350,53 +1342,49 @@ static int mei_irq_thread_write_handler(struct mei_io_list *cmpl_list,
 
        }
        /* complete  write list CB */
-       if (!list_empty(&dev->write_list.mei_cb.cb_list)) {
-               dev_dbg(&dev->pdev->dev, "complete write list cb.\n");
-               list_for_each_entry_safe(cb_pos, cb_next,
-                               &dev->write_list.mei_cb.cb_list, cb_list) {
-                       cl = (struct mei_cl *)cb_pos->file_private;
-
-                       if (cl) {
-                               if (cl != &dev->iamthif_cl) {
-                                       if (!mei_flow_ctrl_creds(dev,
-                                               cl)) {
-                                               dev_dbg(&dev->pdev->dev,
-                                                       "No flow control"
-                                                   " credentials for client"
-                                                   " %d, not sending.\n",
-                                                   cl->host_client_id);
-                                               continue;
-                                       }
-                                       ret = _mei_irq_thread_cmpl(dev, slots,
-                                                           cb_pos,
-                                                           cl, cmpl_list);
-                                       if (ret)
-                                               return ret;
-
-                               } else if (cl == &dev->iamthif_cl) {
-                                       /* IAMTHIF IOCTL */
-                                       dev_dbg(&dev->pdev->dev, "complete amthi write cb.\n");
-                                       if (!mei_flow_ctrl_creds(dev,
-                                                       cl)) {
-                                               dev_dbg(&dev->pdev->dev,
-                                                       "No flow control"
-                                                   " credentials for amthi"
-                                                   " client %d.\n",
-                                                   cl->host_client_id);
-                                               continue;
-                                       }
-                                       ret = _mei_irq_thread_cmpl_iamthif(dev,
-                                                               slots,
-                                                               cb_pos,
-                                                               cl,
-                                                               cmpl_list);
-                                       if (ret)
-                                               return ret;
+       dev_dbg(&dev->pdev->dev, "complete write list cb.\n");
+       list_for_each_entry_safe(pos, next,
+                       &dev->write_list.mei_cb.cb_list, cb_list) {
+               cl = (struct mei_cl *)pos->file_private;
+               if (cl == NULL)
+                       continue;
+
+               if (cl != &dev->iamthif_cl) {
+                       if (!mei_flow_ctrl_creds(dev, cl)) {
+                               dev_dbg(&dev->pdev->dev,
+                                       "No flow control"
+                                   " credentials for client"
+                                   " %d, not sending.\n",
+                                   cl->host_client_id);
+                               continue;
+                       }
+                       ret = _mei_irq_thread_cmpl(dev, slots,
+                                           pos,
+                                           cl, cmpl_list);
+                       if (ret)
+                               return ret;
 
-                               }
+               } else if (cl == &dev->iamthif_cl) {
+                       /* IAMTHIF IOCTL */
+                       dev_dbg(&dev->pdev->dev, "complete amthi write cb.\n");
+                       if (!mei_flow_ctrl_creds(dev, cl)) {
+                               dev_dbg(&dev->pdev->dev,
+                                       "No flow control"
+                                   " credentials for amthi"
+                                   " client %d.\n",
+                                   cl->host_client_id);
+                               continue;
                        }
+                       ret = _mei_irq_thread_cmpl_iamthif(dev,
+                                               slots,
+                                               pos,
+                                               cl,
+                                               cmpl_list);
+                       if (ret)
+                               return ret;
 
                }
+
        }
        return 0;
 }
@@ -1487,18 +1475,13 @@ void mei_timer(struct work_struct *work)
                        amthi_complete_list = &dev->amthi_read_complete_list.
                                        mei_cb.cb_list;
 
-                       if (!list_empty(amthi_complete_list)) {
+                       list_for_each_entry_safe(cb_pos, cb_next, amthi_complete_list, cb_list) {
 
-                               list_for_each_entry_safe(cb_pos, cb_next,
-                                                       amthi_complete_list,
-                                                       cb_list) {
+                               cl_pos = cb_pos->file_object->private_data;
 
-                                       cl_pos = cb_pos->file_object->private_data;
-
-                                       /* Finding the AMTHI entry. */
-                                       if (cl_pos ==   &dev->iamthif_cl)
-                                               list_del(&cb_pos->cb_list);
-                               }
+                               /* Finding the AMTHI entry. */
+                               if (cl_pos == &dev->iamthif_cl)
+                                       list_del(&cb_pos->cb_list);
                        }
                        if (dev->iamthif_current_cb)
                                mei_free_cb_private(dev->iamthif_current_cb);

diff --git a/drivers/staging/mei/iorw.c b/drivers/staging/mei/iorw.c
index 36d0465cd39726ccb0cd7de8968b0bac4dc8aaee..841092b13ca12a72c4b19394b6aff39cfa837143 100644 (file)
--- a/drivers/staging/mei/iorw.c
+++ b/drivers/staging/mei/iorw.c
@@ -228,17 +228,15 @@ struct mei_cl_cb *find_amthi_read_list_entry(
                struct file *file)
 {
        struct mei_cl *cl_temp;
-       struct mei_cl_cb *cb_pos = NULL;
-       struct mei_cl_cb *cb_next = NULL;
-
-       if (!list_empty(&dev->amthi_read_complete_list.mei_cb.cb_list)) {
-               list_for_each_entry_safe(cb_pos, cb_next,
-                   &dev->amthi_read_complete_list.mei_cb.cb_list, cb_list) {
-                       cl_temp = (struct mei_cl *)cb_pos->file_private;
-                       if (cl_temp && cl_temp == &dev->iamthif_cl &&
-                               cb_pos->file_object == file)
-                               return cb_pos;
-               }
+       struct mei_cl_cb *pos = NULL;
+       struct mei_cl_cb *next = NULL;
+
+       list_for_each_entry_safe(pos, next,
+           &dev->amthi_read_complete_list.mei_cb.cb_list, cb_list) {
+               cl_temp = (struct mei_cl *)pos->file_private;
+               if (cl_temp && cl_temp == &dev->iamthif_cl &&
+                       pos->file_object == file)
+                       return pos;
        }
        return NULL;
 }
@@ -549,8 +547,8 @@ int amthi_write(struct mei_device *dev, struct mei_cl_cb *cb)
 void mei_run_next_iamthif_cmd(struct mei_device *dev)
 {
        struct mei_cl *cl_tmp;
-       struct mei_cl_cb *cb_pos = NULL;
-       struct mei_cl_cb *cb_next = NULL;
+       struct mei_cl_cb *pos = NULL;
+       struct mei_cl_cb *next = NULL;
        int status;
 
        if (!dev)
@@ -564,24 +562,22 @@ void mei_run_next_iamthif_cmd(struct mei_device *dev)
        dev->iamthif_timer = 0;
        dev->iamthif_file_object = NULL;
 
-       if (!list_empty(&dev->amthi_cmd_list.mei_cb.cb_list)) {
-               dev_dbg(&dev->pdev->dev, "complete amthi cmd_list cb.\n");
-
-               list_for_each_entry_safe(cb_pos, cb_next,
-                   &dev->amthi_cmd_list.mei_cb.cb_list, cb_list) {
-                       list_del(&cb_pos->cb_list);
-                       cl_tmp = (struct mei_cl *)cb_pos->file_private;
-
-                       if (cl_tmp && cl_tmp == &dev->iamthif_cl) {
-                               status = amthi_write(dev, cb_pos);
-                               if (status) {
-                                       dev_dbg(&dev->pdev->dev,
-                                               "amthi write failed status = %d\n",
-                                                       status);
-                                       return;
-                               }
-                               break;
+       dev_dbg(&dev->pdev->dev, "complete amthi cmd_list cb.\n");
+
+       list_for_each_entry_safe(pos, next,
+                       &dev->amthi_cmd_list.mei_cb.cb_list, cb_list) {
+               list_del(&pos->cb_list);
+               cl_tmp = (struct mei_cl *)pos->file_private;
+
+               if (cl_tmp && cl_tmp == &dev->iamthif_cl) {
+                       status = amthi_write(dev, pos);
+                       if (status) {
+                               dev_dbg(&dev->pdev->dev,
+                                       "amthi write failed status = %d\n",
+                                               status);
+                               return;
                        }
+                       break;
                }
        }
 }

diff --git a/drivers/staging/mei/main.c b/drivers/staging/mei/main.c
index b470bb0c1037145fcede073547406040363eaefc..cb216af63bb6457fadbce7f02e07e52cc1640522 100644 (file)
--- a/drivers/staging/mei/main.c
+++ b/drivers/staging/mei/main.c
@@ -198,20 +198,17 @@ static struct mei_cl_cb *find_read_list_entry(
                struct mei_device *dev,
                struct mei_cl *cl)
 {
-       struct mei_cl_cb *cb_pos = NULL;
-       struct mei_cl_cb *cb_next = NULL;
+       struct mei_cl_cb *pos = NULL;
+       struct mei_cl_cb *next = NULL;
 
-       if (!list_empty(&dev->read_list.mei_cb.cb_list)) {
+       dev_dbg(&dev->pdev->dev, "remove read_list CB\n");
+       list_for_each_entry_safe(pos, next,
+                       &dev->read_list.mei_cb.cb_list, cb_list) {
+               struct mei_cl *cl_temp;
+               cl_temp = (struct mei_cl *)pos->file_private;
 
-               dev_dbg(&dev->pdev->dev, "remove read_list CB\n");
-               list_for_each_entry_safe(cb_pos, cb_next,
-                               &dev->read_list.mei_cb.cb_list, cb_list) {
-                       struct mei_cl *cl_temp;
-                       cl_temp = (struct mei_cl *)cb_pos->file_private;
-
-                       if (mei_cl_cmp_id(cl, cl_temp))
-                               return cb_pos;
-               }
+               if (mei_cl_cmp_id(cl, cl_temp))
+                       return pos;
        }
        return NULL;
 }