Skip to contentSkip to conversation

bus: mhi: core: Add support for data transfer

bug report Dan Carpenter 3 participants 12 messages Apr 7, 2020 – Apr 21, 2020

Subsystems (3)
lore
Share & tools
lore
#0 lore raw

Hello Manivannan Sadhasivam,

The patch 189ff97cca53: "bus: mhi: core: Add support for data transfer" from Feb 20, 2020, leads to the following static checker warning:

	drivers/bus/mhi/core/main.c:1153 mhi_queue_buf()
	error: double locked 'mhi_chan->lock' (orig line 1110)

drivers/bus/mhi/core/main.c
1142 }
1143
1144 /* Toggle wake to exit out of M2 */
1145 mhi_cntrl->wake_toggle(mhi_cntrl);
1146
1147 if (mhi_chan->dir = DMA_TO_DEVICE)
1148 atomic_inc(&mhi_cntrl->pending_pkts);
1149
1150 if (likely(MHI_DB_ACCESS_VALID(mhi_cntrl))) {
1151 unsigned long flags;
1152

  1153                  read_lock_irqsave(&mhi_chan->lock, flags);
                                          ^^^^^^^^^^^^^^^

The caller is already holding this lock.

  1154                  mhi_ring_chan_db(mhi_cntrl, mhi_chan);
  1155                  read_unlock_irqrestore(&mhi_chan->lock, flags);
  1156          }
  1157  
  1158          read_unlock_irqrestore(&mhi_cntrl->pm_lock, flags);
  1159  
  1160          return 0;
  1161  }
  1162  EXPORT_SYMBOL_GPL(mhi_queue_buf);

regards,
dan carpenter

#1 lore raw

Hello Manivannan Sadhasivam,

The patch 189ff97cca53: "bus: mhi: core: Add support for data transfer" from Feb 20, 2020, leads to the following static checker warning:

	drivers/bus/mhi/core/main.c:1093 mhi_gen_tre()
	warn: bitwise AND condition is false here

drivers/bus/mhi/core/main.c
1088
1089 ret = mhi_cntrl->map_single(mhi_cntrl, buf_info);
1090 if (ret)
1091 return ret;
1092

  1093          eob = !!(flags & MHI_EOB);
                                 ^^^^^^^

This is zero. Was BIT(0) intended?

  1094          eot = !!(flags & MHI_EOT);
  1095          chain = !!(flags & MHI_CHAIN);
  1096          bei = !!(mhi_chan->intmod);

1097
1098 mhi_tre = tre_ring->wp;
1099 mhi_tre->ptr = MHI_TRE_DATA_PTR(buf_info->p_addr);

regards,
dan carpenter

#2 lore raw

Hi Dan,

Quoted 15 lines · Dan Carpenter

Hello Manivannan Sadhasivam,

The patch 189ff97cca53: "bus: mhi: core: Add support for data transfer" from Feb 20, 2020, leads to the following static checker warning:

	drivers/bus/mhi/core/main.c:1093 mhi_gen_tre()
	warn: bitwise AND condition is false here

drivers/bus/mhi/core/main.c
1088
1089 ret = mhi_cntrl->map_single(mhi_cntrl, buf_info);
1090 if (ret)
1091 return ret;
1092

Quoted 4 lines
  1093          eob = !!(flags & MHI_EOB);
                                 ^^^^^^^

This is zero. Was BIT(0) intended?

Darn. The enum mhi_flags is supposed to start with 1. I'll fix it with your Reported-by tag.

Btw, which static checker you are using? I did try sparse and W=2.

Thanks,
Mani

Quoted 9 lines
  1094          eot = !!(flags & MHI_EOT);
  1095          chain = !!(flags & MHI_CHAIN);
  1096          bei = !!(mhi_chan->intmod);

1097
1098 mhi_tre = tre_ring->wp;
1099 mhi_tre->ptr = MHI_TRE_DATA_PTR(buf_info->p_addr);

regards,
dan carpenter

#3 lore raw
In reply to Dan Carpenter

Hi Dan,

Quoted 21 lines · Dan Carpenter

Hello Manivannan Sadhasivam,

The patch 189ff97cca53: "bus: mhi: core: Add support for data transfer" from Feb 20, 2020, leads to the following static checker warning:

	drivers/bus/mhi/core/main.c:1153 mhi_queue_buf()
	error: double locked 'mhi_chan->lock' (orig line 1110)

drivers/bus/mhi/core/main.c
1142 }
1143
1144 /* Toggle wake to exit out of M2 */
1145 mhi_cntrl->wake_toggle(mhi_cntrl);
1146
1147 if (mhi_chan->dir == DMA_TO_DEVICE)
1148 atomic_inc(&mhi_cntrl->pending_pkts);
1149
1150 if (likely(MHI_DB_ACCESS_VALID(mhi_cntrl))) {
1151 unsigned long flags;
1152

Quoted 4 lines
  1153                  read_lock_irqsave(&mhi_chan->lock, flags);
                                          ^^^^^^^^^^^^^^^

The caller is already holding this lock.

Hmm. We have one internal user of this function and that's where the locking has gone wrong. Will fix it.

Thanks for reporting!

Regards,
Mani

Quoted 12 lines
  1154                  mhi_ring_chan_db(mhi_cntrl, mhi_chan);
  1155                  read_unlock_irqrestore(&mhi_chan->lock, flags);
  1156          }
  1157  
  1158          read_unlock_irqrestore(&mhi_cntrl->pm_lock, flags);
  1159  
  1160          return 0;
  1161  }
  1162  EXPORT_SYMBOL_GPL(mhi_queue_buf);

regards,
dan carpenter

#4 lore raw
Quoted 25 lines · Manivannan Sadhasivam

Hi Dan,

Quoted 22 lines · Dan Carpenter

Hello Manivannan Sadhasivam,

The patch 189ff97cca53: "bus: mhi: core: Add support for data transfer" from Feb 20, 2020, leads to the following static checker warning:

	drivers/bus/mhi/core/main.c:1153 mhi_queue_buf()
	error: double locked 'mhi_chan->lock' (orig line 1110)

drivers/bus/mhi/core/main.c
1142 }
1143
1144 /* Toggle wake to exit out of M2 */

   1145          mhi_cntrl->wake_toggle(mhi_cntrl);
   1146
   1147          if (mhi_chan->dir = DMA_TO_DEVICE)
   1148                  atomic_inc(&mhi_cntrl->pending_pkts);
   1149
   1150          if (likely(MHI_DB_ACCESS_VALID(mhi_cntrl))) {
   1151                  unsigned long flags;
   1152
   1153                  read_lock_irqsave(&mhi_chan->lock, flags);

parse_xfer_event is taking read lock : read_lock_bh(&mhi_chan->lock); first and later

mhi_queue_buf takes read lock: read_lock_irqsave(&mhi_chan->lock, flags);

Both are read locks which are recursive, is this problematic ?

Quoted 23 lines
Quoted 3 lines
                                           ^^^^^^^^^^^^^^^

The caller is already holding this lock.

Hmm. We have one internal user of this function and that's where the locking has gone wrong. Will fix it.

Thanks for reporting!

Regards,
Mani

Quoted 12 lines
   1154                  mhi_ring_chan_db(mhi_cntrl, mhi_chan);
   1155                  read_unlock_irqrestore(&mhi_chan->lock, flags);
   1156          }
   1157
   1158          read_unlock_irqrestore(&mhi_cntrl->pm_lock, flags);
   1159
   1160          return 0;
   1161  }
   1162  EXPORT_SYMBOL_GPL(mhi_queue_buf);

regards,
dan carpenter

Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
a Linux Foundation Collaborative Project
#5 lore raw

Hi Hemant,

Quoted 28 lines · Hemant Kumar
Quoted 25 lines · Manivannan Sadhasivam

Hi Dan,

Quoted 22 lines · Dan Carpenter

Hello Manivannan Sadhasivam,

The patch 189ff97cca53: "bus: mhi: core: Add support for data transfer" from Feb 20, 2020, leads to the following static checker warning:

	drivers/bus/mhi/core/main.c:1153 mhi_queue_buf()
	error: double locked 'mhi_chan->lock' (orig line 1110)

drivers/bus/mhi/core/main.c
1142 }
1143
1144 /* Toggle wake to exit out of M2 */

   1145          mhi_cntrl->wake_toggle(mhi_cntrl);
   1146
   1147          if (mhi_chan->dir == DMA_TO_DEVICE)
   1148                  atomic_inc(&mhi_cntrl->pending_pkts);
   1149
   1150          if (likely(MHI_DB_ACCESS_VALID(mhi_cntrl))) {
   1151                  unsigned long flags;
   1152
   1153                  read_lock_irqsave(&mhi_chan->lock, flags);
Quoted 7 lines

parse_xfer_event is taking read lock : read_lock_bh(&mhi_chan->lock); first and later

mhi_queue_buf takes read lock: read_lock_irqsave(&mhi_chan->lock, flags);

Both are read locks which are recursive, is this problematic ?

read_locks are recursive but I wanted to make the static checker happy. But looking into it further (and after having a chat with Arnd), we might need to refactor the locking here.

Since 'chan->lock' only prevents 'mhi_chan->ch_state', how about doing something like below?

drivers/bus/mhi/core/main.c +8 -19
index 3e9aa3b2da77..904f9be7a142 100644
@@ -474,19 +474,12 @@ static int parse_xfer_event(struct mhi_controller *mhi_cntrl,
        result.transaction_status = (ev_code == MHI_EV_CC_OVERFLOW) ?
                -EOVERFLOW : 0;
 
-       /*
-        * If it's a DB Event then we need to grab the lock
-        * with preemption disabled and as a write because we
-        * have to update db register and there are chances that
-        * another thread could be doing the same.
-        */
-       if (ev_code >= MHI_EV_CC_OOB)
-               write_lock_irqsave(&mhi_chan->lock, flags);
-       else
-               read_lock_bh(&mhi_chan->lock);
-
-       if (mhi_chan->ch_state != MHI_CH_STATE_ENABLED)
-               goto end_process_tx_event;
+       read_lock_bh(&mhi_chan->lock);
+       if (mhi_chan->ch_state != MHI_CH_STATE_ENABLED) {
+               read_unlock_bh(&mhi_chan->lock);
+               return 0;
+       }
+       read_unlock_bh(&mhi_chan->lock);
 
        switch (ev_code) {
        case MHI_EV_CC_OVERFLOW:
@@ -559,10 +552,12 @@ static int parse_xfer_event(struct mhi_controller *mhi_cntrl,
 
                mhi_chan->db_cfg.db_mode = 1;
                read_lock_irqsave(&mhi_cntrl->pm_lock, flags);
+               write_lock_irqsave(&mhi_chan->lock, flags);
                if (tre_ring->wp != tre_ring->rp &&
                    MHI_DB_ACCESS_VALID(mhi_cntrl)) {
                        mhi_ring_chan_db(mhi_cntrl, mhi_chan);
                }
+               write_unlock_irqrestore(&mhi_chan->lock, flags);
                read_unlock_irqrestore(&mhi_cntrl->pm_lock, flags);
                break;
        }
@@ -572,12 +567,6 @@ static int parse_xfer_event(struct mhi_controller *mhi_cntrl,
                break;
        } /* switch(MHI_EV_READ_CODE(EV_TRB_CODE,event)) */
 
-end_process_tx_event:
-       if (ev_code >= MHI_EV_CC_OOB)
-               write_unlock_irqrestore(&mhi_chan->lock, flags);
-       else
-               read_unlock_bh(&mhi_chan->lock);
-
        return 0;
 }
 

Moreover, I do have couple of concerns:

1. 'mhi_chan->db_cfg.db_mode = 1' needs to be added to the critical section above.

2. Why we have {write/read}_lock_irq variants for chan->lock? I don't see where the db or ch_state got shared with hardirq handler. Maybe we should only have *_bh (softirq) variants all over the place?

Thanks,
Mani

Quoted 27 lines
Quoted 23 lines
Quoted 3 lines
                                           ^^^^^^^^^^^^^^^

The caller is already holding this lock.

Hmm. We have one internal user of this function and that's where the locking has gone wrong. Will fix it.

Thanks for reporting!

Regards,
Mani

Quoted 12 lines
   1154                  mhi_ring_chan_db(mhi_cntrl, mhi_chan);
   1155                  read_unlock_irqrestore(&mhi_chan->lock, flags);
   1156          }
   1157
   1158          read_unlock_irqrestore(&mhi_cntrl->pm_lock, flags);
   1159
   1160          return 0;
   1161  }
   1162  EXPORT_SYMBOL_GPL(mhi_queue_buf);

regards,
dan carpenter

Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
a Linux Foundation Collaborative Project
#6 lore raw
Quoted 34 lines · Manivannan Sadhasivam

Hi Hemant,

Quoted 31 lines · Hemant Kumar
Quoted 25 lines · Manivannan Sadhasivam

Hi Dan,

Quoted 22 lines · Dan Carpenter

Hello Manivannan Sadhasivam,

The patch 189ff97cca53: "bus: mhi: core: Add support for data transfer" from Feb 20, 2020, leads to the following static checker warning:

	drivers/bus/mhi/core/main.c:1153 mhi_queue_buf()
	error: double locked 'mhi_chan->lock' (orig line 1110)

drivers/bus/mhi/core/main.c
1142 }
1143
1144 /* Toggle wake to exit out of M2 */

   1145          mhi_cntrl->wake_toggle(mhi_cntrl);
   1146
   1147          if (mhi_chan->dir = DMA_TO_DEVICE)
   1148                  atomic_inc(&mhi_cntrl->pending_pkts);
   1149
   1150          if (likely(MHI_DB_ACCESS_VALID(mhi_cntrl))) {
   1151                  unsigned long flags;
   1152
   1153                  read_lock_irqsave(&mhi_chan->lock, flags);

parse_xfer_event is taking read lock : read_lock_bh(&mhi_chan->lock); first and later

Quoted 6 lines
Quoted 4 lines

mhi_queue_buf takes read lock: read_lock_irqsave(&mhi_chan->lock, flags);

Both are read locks which are recursive, is this problematic ?

read_locks are recursive but I wanted to make the static checker happy.

Don't do things just to make the static checker happy.

regards,
dan carpenter

#7 lore raw
In reply to Manivannan Sadhasivam

Hi Mani,

Quoted 34 lines · Manivannan Sadhasivam

Hi Hemant,

Quoted 31 lines · Hemant Kumar
Quoted 25 lines · Manivannan Sadhasivam

Hi Dan,

Quoted 22 lines · Dan Carpenter

Hello Manivannan Sadhasivam,

The patch 189ff97cca53: "bus: mhi: core: Add support for data transfer" from Feb 20, 2020, leads to the following static checker warning:

	drivers/bus/mhi/core/main.c:1153 mhi_queue_buf()
	error: double locked 'mhi_chan->lock' (orig line 1110)

drivers/bus/mhi/core/main.c

    1142          }
    1143
    1144          /* Toggle wake to exit out of M2 */
    1145          mhi_cntrl->wake_toggle(mhi_cntrl);
    1146
    1147          if (mhi_chan->dir = DMA_TO_DEVICE)
    1148                  atomic_inc(&mhi_cntrl->pending_pkts);
    1149
    1150          if (likely(MHI_DB_ACCESS_VALID(mhi_cntrl))) {
    1151                  unsigned long flags;
    1152
    1153                  read_lock_irqsave(&mhi_chan->lock, flags);

parse_xfer_event is taking read lock : read_lock_bh(&mhi_chan->lock); first and later

mhi_queue_buf takes read lock: read_lock_irqsave(&mhi_chan->lock, flags);

Quoted 8 lines
Quoted 2 lines

Both are read locks which are recursive, is this problematic ?

read_locks are recursive but I wanted to make the static checker happy. But looking into it further (and after having a chat with Arnd), we might need to refactor the locking here.

Since 'chan->lock' only prevents 'mhi_chan->ch_state', how about doing something like below?

As comment mentioned for OOB (to enter  DB mode) write lock is acquired

with preemption disabled (irqsave ver). In case of OOB event control does not go to mhi_queue_buf

path. For transfer completion events read_lock_bh is acquired and channel state is checked.

This lock is held for entire handling of the transfer completion so that in case

__mhi_unprepare_channel() is called from power down context write lock is acquired

for channel lock to change channel state, which would wait until parse_xfer_event for

data transfer is done (reader is in critical section).  In case if __mhi_unprepare_channel() wins then

parse_xfer_event is skipped otherwise parse_xfer_event is done and then channel state is changed.

Quoted 95 lines
drivers/bus/mhi/core/main.c +8 -19
index 3e9aa3b2da77..904f9be7a142 100644
@@ -474,19 +474,12 @@ static int parse_xfer_event(struct mhi_controller *mhi_cntrl,
         result.transaction_status = (ev_code = MHI_EV_CC_OVERFLOW) ?
                 -EOVERFLOW : 0;
 
-       /*
-        * If it's a DB Event then we need to grab the lock
-        * with preemption disabled and as a write because we
-        * have to update db register and there are chances that
-        * another thread could be doing the same.
-        */
-       if (ev_code >= MHI_EV_CC_OOB)
-               write_lock_irqsave(&mhi_chan->lock, flags);
-       else
-               read_lock_bh(&mhi_chan->lock);
-
-       if (mhi_chan->ch_state != MHI_CH_STATE_ENABLED)
-               goto end_process_tx_event;
+       read_lock_bh(&mhi_chan->lock);
+       if (mhi_chan->ch_state != MHI_CH_STATE_ENABLED) {
+               read_unlock_bh(&mhi_chan->lock);
+               return 0;
+       }
+       read_unlock_bh(&mhi_chan->lock);
 
         switch (ev_code) {
         case MHI_EV_CC_OVERFLOW:
@@ -559,10 +552,12 @@ static int parse_xfer_event(struct mhi_controller *mhi_cntrl,
 
                 mhi_chan->db_cfg.db_mode = 1;
                 read_lock_irqsave(&mhi_cntrl->pm_lock, flags);
+               write_lock_irqsave(&mhi_chan->lock, flags);
                 if (tre_ring->wp != tre_ring->rp &&
                     MHI_DB_ACCESS_VALID(mhi_cntrl)) {
                         mhi_ring_chan_db(mhi_cntrl, mhi_chan);
                 }
+               write_unlock_irqrestore(&mhi_chan->lock, flags);
                 read_unlock_irqrestore(&mhi_cntrl->pm_lock, flags);
                 break;
         }
@@ -572,12 +567,6 @@ static int parse_xfer_event(struct mhi_controller *mhi_cntrl,
                 break;
         } /* switch(MHI_EV_READ_CODE(EV_TRB_CODE,event)) */
 
-end_process_tx_event:
-       if (ev_code >= MHI_EV_CC_OOB)
-               write_unlock_irqrestore(&mhi_chan->lock, flags);
-       else
-               read_unlock_bh(&mhi_chan->lock);
-
         return 0;
  }
 

Moreover, I do have couple of concerns:

1. 'mhi_chan->db_cfg.db_mode = 1' needs to be added to the critical section above.

2. Why we have {write/read}_lock_irq variants for chan->lock? I don't see where the db or ch_state got shared with hardirq handler. Maybe we should only have *_bh (softirq) variants all over the place?

Thanks,
Mani

Quoted 26 lines
Quoted 23 lines
Quoted 3 lines
                                            ^^^^^^^^^^^^^^^

The caller is already holding this lock.

Hmm. We have one internal user of this function and that's where the locking has gone wrong. Will fix it.

Thanks for reporting!

Regards,
Mani

Quoted 12 lines
    1154                  mhi_ring_chan_db(mhi_cntrl, mhi_chan);
    1155                  read_unlock_irqrestore(&mhi_chan->lock, flags);
    1156          }
    1157
    1158          read_unlock_irqrestore(&mhi_cntrl->pm_lock, flags);
    1159
    1160          return 0;
    1161  }
    1162  EXPORT_SYMBOL_GPL(mhi_queue_buf);

regards,
dan carpenter

Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
a Linux Foundation Collaborative Project
Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
a Linux Foundation Collaborative Project
#8 lore raw

Hi Hemant,

Please try to use an email client supporting plain text mode like mutt. Your reply looks mangled.

Quoted 50 lines · Hemant Kumar

Hi Mani,

Quoted 29 lines · Manivannan Sadhasivam

Hi Hemant,

Quoted 26 lines · Hemant Kumar
Quoted 25 lines · Manivannan Sadhasivam

Hi Dan,

Quoted 22 lines · Dan Carpenter

Hello Manivannan Sadhasivam,

The patch 189ff97cca53: "bus: mhi: core: Add support for data transfer" from Feb 20, 2020, leads to the following static checker warning:

	drivers/bus/mhi/core/main.c:1153 mhi_queue_buf()
	error: double locked 'mhi_chan->lock' (orig line 1110)

drivers/bus/mhi/core/main.c

    1142          }
    1143
    1144          /* Toggle wake to exit out of M2 */
    1145          mhi_cntrl->wake_toggle(mhi_cntrl);
    1146
    1147          if (mhi_chan->dir == DMA_TO_DEVICE)
    1148                  atomic_inc(&mhi_cntrl->pending_pkts);
    1149
    1150          if (likely(MHI_DB_ACCESS_VALID(mhi_cntrl))) {
    1151                  unsigned long flags;
    1152
    1153                  read_lock_irqsave(&mhi_chan->lock,

flags);

Quoted 1 line
Quoted 1 line

parse_xfer_event is taking read lock :

read_lock_bh(&mhi_chan->lock); first

Quoted 3 lines
Quoted 3 lines

and later

mhi_queue_buf takes read lock: read_lock_irqsave(&mhi_chan->lock,

flags);

Quoted 4 lines
Quoted 3 lines

Both are read locks which are recursive, is this problematic ?

read_locks are recursive but I wanted to make the static checker

happy. But

Quoted 1 line

looking into it further (and after having a chat with Arnd), we might

need to

Quoted 3 lines

refactor the locking here.

Since 'chan->lock' only prevents 'mhi_chan->ch_state', how about

doing something

Quoted 8 lines
Quoted 1 line

like below?

As comment mentioned for OOB (to enter  DB mode) write lock is acquired

with preemption disabled (irqsave ver). In case of OOB event control does not go to mhi_queue_buf

path.

Again, why do we need irq version of write lock. It should only be used if the data is shared with hardirq handlers which I don't see. Otherwise, write_lock_bh() looks sufficient to me as this itself is an exclusive lock.

Quoted 13 lines

For transfer completion events >read_lock_bh is acquired and channel state is checked.

This lock is held for entire handling of the transfer completion so that
in case

__mhi_unprepare_channel() is called from power down context write lock is acquired

for channel lock to change channel state, which would wait until parse_xfer_event for

Quoted 7 lines

data transfer is done (reader is in critical section).  In case if __mhi_unprepare_channel() wins then

parse_xfer_event is skipped otherwise parse_xfer_event is done and then

channel state is changed.

So if we get unprepare_channel() after checking the channel state in parse_xfer_event(), what could go wrong?
Also, grabbing the lock for the entire function doesn't look good to me. The purpose of the chan->lock is just to protect 'chan_state'/DB and not the whole function.

Thanks,
Mani

Quoted 107 lines

Review

Quoted 2 lines
(quoted diff) +0 -0

b/drivers/bus/mhi/core/main.c

drivers/bus/mhi/core/main.c static int parse_xfer_event(struct

Quoted 4 lines

index 3e9aa3b2da77..904f9be7a142 100644

drivers/bus/mhi/core/main.c +0 -0
@@ -474,19 +474,12 @@ static int parse_xfer_event(struct

mhi_controller *mhi_cntrl,

drivers/bus/mhi/core/main.c static int parse_xfer_event(struct · line 474

Quoted 1 line
drivers/bus/mhi/core/main.c +0 -0
         result.transaction_status = (ev_code == MHI_EV_CC_OVERFLOW)

?

drivers/bus/mhi/core/main.c static int parse_xfer_event(struct

Quoted 25 lines
drivers/bus/mhi/core/main.c +6 -13
                 -EOVERFLOW : 0;
 
-       /*
-        * If it's a DB Event then we need to grab the lock
-        * with preemption disabled and as a write because we
-        * have to update db register and there are chances that
-        * another thread could be doing the same.
-        */
-       if (ev_code >= MHI_EV_CC_OOB)
-               write_lock_irqsave(&mhi_chan->lock, flags);
-       else
-               read_lock_bh(&mhi_chan->lock);
-
-       if (mhi_chan->ch_state != MHI_CH_STATE_ENABLED)
-               goto end_process_tx_event;
+       read_lock_bh(&mhi_chan->lock);
+       if (mhi_chan->ch_state != MHI_CH_STATE_ENABLED) {
+               read_unlock_bh(&mhi_chan->lock);
+               return 0;
+       }
+       read_unlock_bh(&mhi_chan->lock);
 
         switch (ev_code) {
         case MHI_EV_CC_OVERFLOW:
@@ -559,10 +552,12 @@ static int parse_xfer_event(struct

mhi_controller *mhi_cntrl,

drivers/bus/mhi/core/main.c static int parse_xfer_event(struct

Quoted 13 lines
drivers/bus/mhi/core/main.c +2 -0
                 mhi_chan->db_cfg.db_mode = 1;
                 read_lock_irqsave(&mhi_cntrl->pm_lock, flags);
+               write_lock_irqsave(&mhi_chan->lock, flags);
                 if (tre_ring->wp != tre_ring->rp &&
                     MHI_DB_ACCESS_VALID(mhi_cntrl)) {
                         mhi_ring_chan_db(mhi_cntrl, mhi_chan);
                 }
+               write_unlock_irqrestore(&mhi_chan->lock, flags);
                 read_unlock_irqrestore(&mhi_cntrl->pm_lock, flags);
                 break;
         }
@@ -572,12 +567,6 @@ static int parse_xfer_event(struct

mhi_controller *mhi_cntrl,

Quoted 14 lines
drivers/bus/mhi/core/main.c +0 -6
                 break;
         } /* switch(MHI_EV_READ_CODE(EV_TRB_CODE,event)) */
 
-end_process_tx_event:
-       if (ev_code >= MHI_EV_CC_OOB)
-               write_unlock_irqrestore(&mhi_chan->lock, flags);
-       else
-               read_unlock_bh(&mhi_chan->lock);
-
         return 0;
  }
 

Moreover, I do have couple of concerns:

Quoted 1 line

1. 'mhi_chan->db_cfg.db_mode = 1' needs to be added to the critical

section

Quoted 3 lines

above.

2. Why we have {write/read}_lock_irq variants for chan->lock? I don't

see where

Quoted 1 line

the db or ch_state got shared with hardirq handler. Maybe we should

only have

Quoted 9 lines

*_bh (softirq) variants all over the place?

Thanks,
Mani

Quoted 4 lines
Quoted 4 lines
Quoted 3 lines
                                            ^^^^^^^^^^^^^^^

The caller is already holding this lock.

Hmm. We have one internal user of this function and that's where

the locking

Quoted 9 lines
Quoted 9 lines
Quoted 9 lines

has gone wrong. Will fix it.

Thanks for reporting!

Regards,
Mani

Quoted 2 lines
    1154                  mhi_ring_chan_db(mhi_cntrl, mhi_chan);
    1155                  read_unlock_irqrestore(&mhi_chan->lock,

flags);

Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
    1156          }
    1157
    1158          read_unlock_irqrestore(&mhi_cntrl->pm_lock,

flags);

Quoted 9 lines
Quoted 9 lines
Quoted 7 lines
Quoted 7 lines
    1159
    1160          return 0;
    1161  }
    1162  EXPORT_SYMBOL_GPL(mhi_queue_buf);

regards,
dan carpenter

Signature · 1 line
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora

Forum,

Quoted 1 line
Quoted 1 line

a Linux Foundation Collaborative Project

Signature · 1 line
Sent from my Android device with K-9 Mail. Please excuse my brevity.
#9 lore raw

Hi Mani,

Quoted 57 lines · Manivannan Sadhasivam

Hi Hemant,

Please try to use an email client supporting plain text mode like mutt. Your reply looks mangled.

Quoted 52 lines · Hemant Kumar

Hi Mani,

Quoted 29 lines · Manivannan Sadhasivam

Hi Hemant,

Quoted 26 lines · Hemant Kumar
Quoted 25 lines · Manivannan Sadhasivam

Hi Dan,

Quoted 22 lines · Dan Carpenter

Hello Manivannan Sadhasivam,

The patch 189ff97cca53: "bus: mhi: core: Add support for data transfer" from Feb 20, 2020, leads to the following static checker warning:

	drivers/bus/mhi/core/main.c:1153 mhi_queue_buf()
	error: double locked 'mhi_chan->lock' (orig line 1110)

drivers/bus/mhi/core/main.c

     1142          }
     1143
     1144          /* Toggle wake to exit out of M2 */
     1145          mhi_cntrl->wake_toggle(mhi_cntrl);
     1146
     1147          if (mhi_chan->dir = DMA_TO_DEVICE)
     1148                  atomic_inc(&mhi_cntrl->pending_pkts);
     1149
     1150          if (likely(MHI_DB_ACCESS_VALID(mhi_cntrl))) {
     1151                  unsigned long flags;
     1152
     1153                  read_lock_irqsave(&mhi_chan->lock,

flags);

Quoted 1 line
Quoted 1 line

parse_xfer_event is taking read lock :

read_lock_bh(&mhi_chan->lock); first

Quoted 3 lines
Quoted 3 lines

and later

mhi_queue_buf takes read lock: read_lock_irqsave(&mhi_chan->lock,

flags);

Quoted 4 lines
Quoted 3 lines

Both are read locks which are recursive, is this problematic ?

read_locks are recursive but I wanted to make the static checker

happy. But

Quoted 1 line

looking into it further (and after having a chat with Arnd), we might

need to

Quoted 3 lines

refactor the locking here.

Since 'chan->lock' only prevents 'mhi_chan->ch_state', how about

doing something

Quoted 1 line

like below?

Quoted 8 lines
Quoted 6 lines

As comment mentioned for OOB (to enter  DB mode) write lock is acquired

with preemption disabled (irqsave ver). In case of OOB event control does not go to mhi_queue_buf

path.

Again, why do we need irq version of write lock. It should only be used if the data is shared with hardirq handlers which I don't see. Otherwise, write_lock_bh() looks sufficient to me as this itself is an exclusive lock.

irq ver disables preemption where as bh ver does not. In case of OOB event, idea is not get preempted and this is for short duration of ringing the channel doorbell.

Quoted 17 lines
Quoted 17 lines

For transfer completion events >read_lock_bh is acquired and channel state is checked.

This lock is held for entire handling of the transfer completion so that
in case

__mhi_unprepare_channel() is called from power down context write lock is acquired

for channel lock to change channel state, which would wait until parse_xfer_event for

data transfer is done (reader is in critical section).  In case if __mhi_unprepare_channel() wins then

Quoted 8 lines
Quoted 4 lines

parse_xfer_event is skipped otherwise parse_xfer_event is done and then

channel state is changed.

So if we get unprepare_channel() after checking the channel state in parse_xfer_event(), what could go wrong?
Also, grabbing the lock for the entire function doesn't look good to me. The purpose of the chan->lock is just to protect 'chan_state'/DB and not the whole function.

main problem unprepare_channel and parse_xfer_event have lot in common due to that we can not let them run in parallel. For example -parse_xfer_event is working on transfer ring (rp and wp updates) -parse_xfer_event calling dma_unmap_single on buffer -__mhi_unprepare_channel() calling mhi_reset_chan() and mhi_deinit_chan_ctxt().

Quoted 111 lines

Thanks,
Mani

Quoted 107 lines

Review

Quoted 2 lines
(quoted diff) +0 -0

b/drivers/bus/mhi/core/main.c

drivers/bus/mhi/core/main.c static int parse_xfer_event(struct

Quoted 4 lines

index 3e9aa3b2da77..904f9be7a142 100644

drivers/bus/mhi/core/main.c +0 -0
@@ -474,19 +474,12 @@ static int parse_xfer_event(struct

mhi_controller *mhi_cntrl,

drivers/bus/mhi/core/main.c static int parse_xfer_event(struct · line 474

Quoted 1 line
drivers/bus/mhi/core/main.c +0 -0
          result.transaction_status = (ev_code = MHI_EV_CC_OVERFLOW)

?

drivers/bus/mhi/core/main.c static int parse_xfer_event(struct

Quoted 25 lines
drivers/bus/mhi/core/main.c +6 -13
                  -EOVERFLOW : 0;
 
-       /*
-        * If it's a DB Event then we need to grab the lock
-        * with preemption disabled and as a write because we
-        * have to update db register and there are chances that
-        * another thread could be doing the same.
-        */
-       if (ev_code >= MHI_EV_CC_OOB)
-               write_lock_irqsave(&mhi_chan->lock, flags);
-       else
-               read_lock_bh(&mhi_chan->lock);
-
-       if (mhi_chan->ch_state != MHI_CH_STATE_ENABLED)
-               goto end_process_tx_event;
+       read_lock_bh(&mhi_chan->lock);
+       if (mhi_chan->ch_state != MHI_CH_STATE_ENABLED) {
+               read_unlock_bh(&mhi_chan->lock);
+               return 0;
+       }
+       read_unlock_bh(&mhi_chan->lock);
 
          switch (ev_code) {
          case MHI_EV_CC_OVERFLOW:
@@ -559,10 +552,12 @@ static int parse_xfer_event(struct

mhi_controller *mhi_cntrl,

drivers/bus/mhi/core/main.c static int parse_xfer_event(struct

Quoted 13 lines
drivers/bus/mhi/core/main.c +2 -0
                  mhi_chan->db_cfg.db_mode = 1;
                  read_lock_irqsave(&mhi_cntrl->pm_lock, flags);
+               write_lock_irqsave(&mhi_chan->lock, flags);
                  if (tre_ring->wp != tre_ring->rp &&
                      MHI_DB_ACCESS_VALID(mhi_cntrl)) {
                          mhi_ring_chan_db(mhi_cntrl, mhi_chan);
                  }
+               write_unlock_irqrestore(&mhi_chan->lock, flags);
                  read_unlock_irqrestore(&mhi_cntrl->pm_lock, flags);
                  break;
          }
@@ -572,12 +567,6 @@ static int parse_xfer_event(struct

mhi_controller *mhi_cntrl,

Quoted 14 lines
drivers/bus/mhi/core/main.c +0 -6
                  break;
          } /* switch(MHI_EV_READ_CODE(EV_TRB_CODE,event)) */
 
-end_process_tx_event:
-       if (ev_code >= MHI_EV_CC_OOB)
-               write_unlock_irqrestore(&mhi_chan->lock, flags);
-       else
-               read_unlock_bh(&mhi_chan->lock);
-
          return 0;
   }
 

Moreover, I do have couple of concerns:

Quoted 1 line

1. 'mhi_chan->db_cfg.db_mode = 1' needs to be added to the critical

section

Quoted 3 lines

above.

2. Why we have {write/read}_lock_irq variants for chan->lock? I don't

see where

Quoted 1 line

the db or ch_state got shared with hardirq handler. Maybe we should

only have

Quoted 9 lines

*_bh (softirq) variants all over the place?

Thanks,
Mani

Quoted 4 lines
Quoted 4 lines
Quoted 3 lines
                                             ^^^^^^^^^^^^^^^

The caller is already holding this lock.

Hmm. We have one internal user of this function and that's where

the locking

Quoted 9 lines
Quoted 9 lines
Quoted 9 lines

has gone wrong. Will fix it.

Thanks for reporting!

Regards,
Mani

Quoted 2 lines
     1154                  mhi_ring_chan_db(mhi_cntrl, mhi_chan);
     1155                  read_unlock_irqrestore(&mhi_chan->lock,

flags);

Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
     1156          }
     1157
     1158          read_unlock_irqrestore(&mhi_cntrl->pm_lock,

flags);

Quoted 9 lines
Quoted 9 lines
Quoted 7 lines
Quoted 7 lines
     1159
     1160          return 0;
     1161  }
     1162  EXPORT_SYMBOL_GPL(mhi_queue_buf);

regards,
dan carpenter

Signature · 1 line
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora

Forum,

Quoted 1 line
Quoted 1 line

a Linux Foundation Collaborative Project

Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
a Linux Foundation Collaborative Project
#10 lore raw
Quoted 65 lines · Hemant Kumar

Hi Mani,

Quoted 62 lines · Manivannan Sadhasivam

Hi Hemant,

Please try to use an email client supporting plain text mode like mutt. Your reply looks mangled.

Quoted 57 lines · Hemant Kumar

Hi Mani,

Quoted 29 lines · Manivannan Sadhasivam

Hi Hemant,

Quoted 26 lines · Hemant Kumar
Quoted 25 lines · Manivannan Sadhasivam

Hi Dan,

Quoted 22 lines · Dan Carpenter

Hello Manivannan Sadhasivam,

The patch 189ff97cca53: "bus: mhi: core: Add support for data transfer" from Feb 20, 2020, leads to the following static checker warning:

	drivers/bus/mhi/core/main.c:1153 mhi_queue_buf()
	error: double locked 'mhi_chan->lock' (orig line 1110)

drivers/bus/mhi/core/main.c

     1142          }
     1143
     1144          /* Toggle wake to exit out of M2 */
     1145          mhi_cntrl->wake_toggle(mhi_cntrl);
     1146
     1147          if (mhi_chan->dir == DMA_TO_DEVICE)
     1148                  atomic_inc(&mhi_cntrl->pending_pkts);
     1149
     1150          if (likely(MHI_DB_ACCESS_VALID(mhi_cntrl))) {
     1151                  unsigned long flags;
     1152
     1153                  read_lock_irqsave(&mhi_chan->lock,

flags);

Quoted 1 line
Quoted 1 line

parse_xfer_event is taking read lock :

read_lock_bh(&mhi_chan->lock); first

Quoted 3 lines
Quoted 3 lines

and later

mhi_queue_buf takes read lock: read_lock_irqsave(&mhi_chan->lock,

flags);

Quoted 4 lines
Quoted 3 lines

Both are read locks which are recursive, is this problematic ?

read_locks are recursive but I wanted to make the static checker

happy. But

Quoted 1 line

looking into it further (and after having a chat with Arnd), we might

need to

Quoted 3 lines

refactor the locking here.

Since 'chan->lock' only prevents 'mhi_chan->ch_state', how about

doing something

Quoted 1 line

like below?

As comment mentioned for OOB (to enter  DB mode) write lock is acquired

with preemption disabled (irqsave ver). In case of OOB event control does not go to mhi_queue_buf

Quoted 6 lines
Quoted 3 lines
Quoted 1 line

path.

Again, why do we need irq version of write lock. It should only be used if the data is shared with hardirq handlers which I don't see. Otherwise, write_lock_bh() looks sufficient to me as this itself is an exclusive lock.

irq ver disables preemption where as bh ver does not. In case of OOB event, idea is not get preempted and this is for short duration of ringing the channel doorbell.

This is a clear abuse of write_lock_irq() API. write_lock_irq() should _only_ be used when the data is shared with a hardirq handler. The original comment says,

"If it's a DB Event then we need to grab the lock with preemption disabled and as a write because we have to update db register and there are chances that another thread could be doing the same."

If the 'another' thread has the lock for this piece of code then we don't need to disable the irq, isn't it? The irq needs to be disabled only if the 'another' thread is a hardirq handler. I think the problem here is you are caution of not getting preempted while mhi_ring_chan_db() which I don't see why. Is this function non reentrant? I don't think so.

Furthermore, there are _lot_ of places the *_irq and *_bh versions of locks are mixed. One such instance is mhi_queue_buf() where the read_lock_irq() is used for mhi_ring_chan_db() while mhi_queue_skb() uses read_lock_bh().

Quoted 30 lines
Quoted 17 lines
Quoted 17 lines

For transfer completion events >read_lock_bh is acquired and channel state is checked.

This lock is held for entire handling of the transfer completion so that
in case

__mhi_unprepare_channel() is called from power down context write lock is acquired

for channel lock to change channel state, which would wait until parse_xfer_event for

data transfer is done (reader is in critical section).  In case if __mhi_unprepare_channel() wins then

Quoted 8 lines
Quoted 4 lines

parse_xfer_event is skipped otherwise parse_xfer_event is done and then

channel state is changed.

So if we get unprepare_channel() after checking the channel state in parse_xfer_event(), what could go wrong?
Also, grabbing the lock for the entire function doesn't look good to me. The purpose of the chan->lock is just to protect 'chan_state'/DB and not the whole function.

main problem unprepare_channel and parse_xfer_event have lot in common due to that we can not let them run in parallel. For example -parse_xfer_event is working on transfer ring (rp and wp updates)

(quoted diff) +0 -2
-parse_xfer_event calling dma_unmap_single on buffer
-__mhi_unprepare_channel() calling mhi_reset_chan() and
Quoted 1 line

mhi_deinit_chan_ctxt().

Hmm. So the issue will be when __mhi_unprepare_channel() gets called after parse_xfer_event() checked the 'mhi_chan->ch_state'. So if we have the read_lock for the whole case then it is guarenteed to run before __mhi_unprepare_channel() does its part.

Let's keep it as it is. But please look into the irq vs bh part above.

Thanks,
Mani

Quoted 111 lines
Quoted 107 lines

Thanks,
Mani

Quoted 103 lines

Review

Quoted 2 lines
(quoted diff) +0 -0

b/drivers/bus/mhi/core/main.c

drivers/bus/mhi/core/main.c static int parse_xfer_event(struct

Quoted 4 lines

index 3e9aa3b2da77..904f9be7a142 100644

drivers/bus/mhi/core/main.c +0 -0
@@ -474,19 +474,12 @@ static int parse_xfer_event(struct

mhi_controller *mhi_cntrl,

drivers/bus/mhi/core/main.c static int parse_xfer_event(struct · line 474

Quoted 1 line
drivers/bus/mhi/core/main.c +0 -0
          result.transaction_status = (ev_code == MHI_EV_CC_OVERFLOW)

?

drivers/bus/mhi/core/main.c static int parse_xfer_event(struct

Quoted 23 lines
drivers/bus/mhi/core/main.c +6 -13
                  -EOVERFLOW : 0;
-       /*
-        * If it's a DB Event then we need to grab the lock
-        * with preemption disabled and as a write because we
-        * have to update db register and there are chances that
-        * another thread could be doing the same.
-        */
-       if (ev_code >= MHI_EV_CC_OOB)
-               write_lock_irqsave(&mhi_chan->lock, flags);
-       else
-               read_lock_bh(&mhi_chan->lock);
-
-       if (mhi_chan->ch_state != MHI_CH_STATE_ENABLED)
-               goto end_process_tx_event;
+       read_lock_bh(&mhi_chan->lock);
+       if (mhi_chan->ch_state != MHI_CH_STATE_ENABLED) {
+               read_unlock_bh(&mhi_chan->lock);
+               return 0;
+       }
+       read_unlock_bh(&mhi_chan->lock);
          switch (ev_code) {
          case MHI_EV_CC_OVERFLOW:
@@ -559,10 +552,12 @@ static int parse_xfer_event(struct

mhi_controller *mhi_cntrl,

drivers/bus/mhi/core/main.c static int parse_xfer_event(struct

Quoted 12 lines
drivers/bus/mhi/core/main.c +2 -0
                  mhi_chan->db_cfg.db_mode = 1;
                  read_lock_irqsave(&mhi_cntrl->pm_lock, flags);
+               write_lock_irqsave(&mhi_chan->lock, flags);
                  if (tre_ring->wp != tre_ring->rp &&
                      MHI_DB_ACCESS_VALID(mhi_cntrl)) {
                          mhi_ring_chan_db(mhi_cntrl, mhi_chan);
                  }
+               write_unlock_irqrestore(&mhi_chan->lock, flags);
                  read_unlock_irqrestore(&mhi_cntrl->pm_lock, flags);
                  break;
          }
@@ -572,12 +567,6 @@ static int parse_xfer_event(struct

mhi_controller *mhi_cntrl,

Quoted 13 lines
drivers/bus/mhi/core/main.c +0 -6
                  break;
          } /* switch(MHI_EV_READ_CODE(EV_TRB_CODE,event)) */
-end_process_tx_event:
-       if (ev_code >= MHI_EV_CC_OOB)
-               write_unlock_irqrestore(&mhi_chan->lock, flags);
-       else
-               read_unlock_bh(&mhi_chan->lock);
-
          return 0;
   }
 

Moreover, I do have couple of concerns:

Quoted 1 line

1. 'mhi_chan->db_cfg.db_mode = 1' needs to be added to the critical

section

Quoted 3 lines

above.

2. Why we have {write/read}_lock_irq variants for chan->lock? I don't

see where

Quoted 1 line

the db or ch_state got shared with hardirq handler. Maybe we should

only have

Quoted 9 lines

*_bh (softirq) variants all over the place?

Thanks,
Mani

Quoted 4 lines
Quoted 4 lines
Quoted 3 lines
                                             ^^^^^^^^^^^^^^^

The caller is already holding this lock.

Hmm. We have one internal user of this function and that's where

the locking

Quoted 9 lines
Quoted 9 lines
Quoted 9 lines

has gone wrong. Will fix it.

Thanks for reporting!

Regards,
Mani

Quoted 2 lines
     1154                  mhi_ring_chan_db(mhi_cntrl, mhi_chan);
     1155                  read_unlock_irqrestore(&mhi_chan->lock,

flags);

Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines
     1156          }
     1157
     1158          read_unlock_irqrestore(&mhi_cntrl->pm_lock,

flags);

Quoted 9 lines
Quoted 9 lines
Quoted 7 lines
Quoted 7 lines
     1159
     1160          return 0;
     1161  }
     1162  EXPORT_SYMBOL_GPL(mhi_queue_buf);

regards,
dan carpenter

Signature · 1 line
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora

Forum,

Quoted 1 line
Quoted 1 line

a Linux Foundation Collaborative Project

Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
a Linux Foundation Collaborative Project
#11 lore raw
In reply to Dan Carpenter

Hi Dan,

Quoted 21 lines · Dan Carpenter

Hello Manivannan Sadhasivam,

The patch 189ff97cca53: "bus: mhi: core: Add support for data transfer" from Feb 20, 2020, leads to the following static checker warning:

	drivers/bus/mhi/core/main.c:1153 mhi_queue_buf()
	error: double locked 'mhi_chan->lock' (orig line 1110)

drivers/bus/mhi/core/main.c
1142 }
1143
1144 /* Toggle wake to exit out of M2 */
1145 mhi_cntrl->wake_toggle(mhi_cntrl);
1146
1147 if (mhi_chan->dir == DMA_TO_DEVICE)
1148 atomic_inc(&mhi_cntrl->pending_pkts);
1149
1150 if (likely(MHI_DB_ACCESS_VALID(mhi_cntrl))) {
1151 unsigned long flags;
1152

Quoted 4 lines
  1153                  read_lock_irqsave(&mhi_chan->lock, flags);
                                          ^^^^^^^^^^^^^^^

The caller is already holding this lock.

This function will be called from multiple places. It needs to have the chan->lock on its own. I thought about dropping the lock in parse_xfer_event() before calling this function but that won't really solve any issue since read_locks are recursive and by doing so we are only making the static checkers happy.

So I'd consider this bug report as false positive.

Thanks,
Mani

Quoted 12 lines
  1154                  mhi_ring_chan_db(mhi_cntrl, mhi_chan);
  1155                  read_unlock_irqrestore(&mhi_chan->lock, flags);
  1156          }
  1157  
  1158          read_unlock_irqrestore(&mhi_cntrl->pm_lock, flags);
  1159  
  1160          return 0;
  1161  }
  1162  EXPORT_SYMBOL_GPL(mhi_queue_buf);

regards,
dan carpenter