diff mbox series

ALSA: usb-audio: Fix recursive locking on XRUN

Message ID 20230317195128.3911155-1-john@metanate.com
State New
Headers show
Series ALSA: usb-audio: Fix recursive locking on XRUN | expand

Commit Message

John Keeping March 17, 2023, 7:51 p.m. UTC
snd_usb_queue_pending_output_urbs() may be called from
snd_pcm_ops::ack() which means the PCM stream is locked.

For the normal case where the call back into the PCM core is via
prepare_output_urb() the "_under_stream_lock" variant of
snd_pcm_period_elapsed() is called, but when an error occurs and the
stream is stopped as XRUN then snd_pcm_xrun() tries to recursively lock
the stream which results in deadlock.

Follow the example of snd_pcm_period_elapsed() by adding
snd_pcm_xrun_under_stream_lock() and use this when the PCM substream
lock is already held.

Signed-off-by: John Keeping <john@metanate.com>
---
 include/sound/pcm.h     |  1 +
 sound/core/pcm_native.c | 28 ++++++++++++++++++++++++----
 sound/usb/endpoint.c    | 18 +++++++++++-------
 3 files changed, 36 insertions(+), 11 deletions(-)

Comments

Takashi Iwai March 20, 2023, 2:28 p.m. UTC | #1
On Mon, 20 Mar 2023 13:04:22 +0100,
John Keeping wrote:
> 
> On Sun, Mar 19, 2023 at 10:15:55AM +0100, Takashi Iwai wrote:
> > On Sun, 19 Mar 2023 08:57:03 +0100,
> > Takashi Iwai wrote:
> > > 
> > > On Sun, 19 Mar 2023 04:28:53 +0100,
> > > Takashi Sakamoto wrote:
> > > > 
> > > > Hi,
> > > > 
> > > > On Sat, Mar 18, 2023 at 09:20:05AM +0900, Takashi Sakamoto wrote:
> > > > > On Fri, Mar 17, 2023 at 07:51:27PM +0000, John Keeping wrote:
> > > > > > snd_usb_queue_pending_output_urbs() may be called from
> > > > > > snd_pcm_ops::ack() which means the PCM stream is locked.
> > > > > > 
> > > > > > For the normal case where the call back into the PCM core is via
> > > > > > prepare_output_urb() the "_under_stream_lock" variant of
> > > > > > snd_pcm_period_elapsed() is called, but when an error occurs and the
> > > > > > stream is stopped as XRUN then snd_pcm_xrun() tries to recursively lock
> > > > > > the stream which results in deadlock.
> > > > > > 
> > > > > > Follow the example of snd_pcm_period_elapsed() by adding
> > > > > > snd_pcm_xrun_under_stream_lock() and use this when the PCM substream
> > > > > > lock is already held.
> > > > > > 
> > > > > > Signed-off-by: John Keeping <john@metanate.com>
> > > > > > ---
> > > > > >  include/sound/pcm.h     |  1 +
> > > > > >  sound/core/pcm_native.c | 28 ++++++++++++++++++++++++----
> > > > > >  sound/usb/endpoint.c    | 18 +++++++++++-------
> > > > > >  3 files changed, 36 insertions(+), 11 deletions(-)
> > > > >  
> > > > > The name of added kernel API implies me that you refer to existent
> > > > > 'snd_pcm_period_elapsed_under_stream_lock()' which I added to Linux
> > > > > v5.14.
> > > > > 
> > > > > In my opinion, unlike the version of period elapsed API, the version of
> > > > > XRUN API seems not to be necessarily required to ALSA PCM core, since PCM
> > > > > device drivers can implement .pointer callback in the part of PCM operation.
> > > > > When the callback returns SNDRV_PCM_POS_XRUN, ALSA PCM application get
> > > > > occurence of XRUN as a result of any operation relevant to hwptr movement
> > > > > (e.g. SNDRV_PCM_IOCTL_HWSYNC).
> > > > > 
> > > > > Therefore I think it possible to fix the issue without the proposed
> > > > > kernel API. I can assume some scenario:
> > > > > 
> > > > > 1. Failure at tasklet for URB completion
> > > > > 
> > > > > It is softIRQ context. The stream lock is not acquired. It doesn't
> > > > > matter to call current XRUN API.
> > > > > 
> > > > > 2. Failure at PCM operation called by ALSA PCM application
> > > > > 
> > > > > It is process context. The stream lock is acquired before calling driver
> > > > > code. When detecting any type of failure, driver code stores the state.
> > > > > Then .pointer callback should return SNDRV_PCM_POS_XRUNrefering to
> > > > > the state.
> > > > 
> > > > Although being inexperienced to hack driver for USB audio device class,
> > > > I attempt to post the patch to fix the issue of recursive stream lock.
> > > > I apologies in advance since the patch is not tested yet...
> > > > 
> > > > The 'in_xrun' member is newly added to 'struct snd_usb_substream'. When
> > > > detecting any failure, false is assigned to the member. The assignment
> > > > is expected to be done in both softIRQ context, and process context with
> > > > stream lock, thus no need to take care of cocurrent access (e.g. by usage
> > > > of WRITE_ONCE/READ_ONCE).
> > > > 
> > > > Typical ALSA PCM application periodically calls PCM operation which calls
> > > > .pointer in driver code. As I described, returning SNDRV_PCM_POS_XRUN
> > > > takes ALSA PCM core to handle XRUN state of PCM substream in the timing.
> > > > 
> > > > The negative point of the patch is the delay of XRUN notification to user
> > > > space application. In the point, I think the new kernel API introduced by
> > > > your patch has advantage.
> > > > 
> > > > The in_xrun member can be replaced with a kind of EP_STATE_
> > > > enumerations; i.e. EP_STATE_XRUN. In the case, we need some care so that
> > > > the state should be referred from pcm.c.
> > > 
> > > Thanks for the patch.  That would work, but the shortcoming side of
> > > this implementation is that it misses stopping / reporting the error
> > > immediately but waiting for the next pointer update.
> > > 
> > > It might be simpler if we perform the xrun handling in the caller
> > > side, i.e. a change like below:
> > > 
> > > --- a/sound/core/pcm_lib.c
> > > +++ b/sound/core/pcm_lib.c
> > > @@ -2155,6 +2155,8 @@ int pcm_lib_apply_appl_ptr(struct snd_pcm_substream *substream,
> > >  		ret = substream->ops->ack(substream);
> > >  		if (ret < 0) {
> > >  			runtime->control->appl_ptr = old_appl_ptr;
> > > +			if (ret == -EPIPE)
> > > +				__snd_pcm_xrun(substream);
> > >  			return ret;
> > >  		}
> > >  	}
> > > 
> > > ... and let the caller returning -EPIPE for XRUN:
> > 
> > and that misses the XRUN in the case of non-stream-lock.
> > A revised version is below.
> 
> Yes, it looks like this also solves the problem.  If you roll this into
> a proper patch feel free to add:
> 
> Tested-by: John Keeping <john@metanate.com>

Thanks, then I'll submit a proper patch.


Takashi
diff mbox series

Patch

diff --git a/include/sound/pcm.h b/include/sound/pcm.h
index 27040b472a4f..98551907453a 100644
--- a/include/sound/pcm.h
+++ b/include/sound/pcm.h
@@ -571,6 +571,7 @@  int snd_pcm_status64(struct snd_pcm_substream *substream,
 int snd_pcm_start(struct snd_pcm_substream *substream);
 int snd_pcm_stop(struct snd_pcm_substream *substream, snd_pcm_state_t status);
 int snd_pcm_drain_done(struct snd_pcm_substream *substream);
+int snd_pcm_stop_xrun_under_stream_lock(struct snd_pcm_substream *substream);
 int snd_pcm_stop_xrun(struct snd_pcm_substream *substream);
 #ifdef CONFIG_PM
 int snd_pcm_suspend_all(struct snd_pcm *pcm);
diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c
index 331380c2438b..617f5dc74df0 100644
--- a/sound/core/pcm_native.c
+++ b/sound/core/pcm_native.c
@@ -1559,24 +1559,44 @@  int snd_pcm_drain_done(struct snd_pcm_substream *substream)
 				     SNDRV_PCM_STATE_SETUP);
 }
 
+/**
+ * snd_pcm_stop_xrun_under_stream_lock - stop the running stream as XRUN under the lock of
+ * 					 the PCM substream.
+ * @substream: the PCM substream instance
+ *
+ * This stops the given running substream (and all linked substreams) as XRUN.
+ * This function assumes that the substream lock is already held.
+ *
+ * Return: Zero if successful, or a negative error core.
+ */
+int snd_pcm_stop_xrun_under_stream_lock(struct snd_pcm_substream *substream)
+{
+	if (substream->runtime && snd_pcm_running(substream))
+		__snd_pcm_xrun(substream);
+
+	return 0;
+}
+
 /**
  * snd_pcm_stop_xrun - stop the running streams as XRUN
  * @substream: the PCM substream instance
  *
+ * This function is similar to ``snd_pcm_stop_xrun_under_stream_lock()`` except that it
+ * acquires the substream lock itself.
+ *
  * This stops the given running substream (and all linked substreams) as XRUN.
- * Unlike snd_pcm_stop(), this function takes the substream lock by itself.
  *
  * Return: Zero if successful, or a negative error code.
  */
 int snd_pcm_stop_xrun(struct snd_pcm_substream *substream)
 {
 	unsigned long flags;
+	int ret;
 
 	snd_pcm_stream_lock_irqsave(substream, flags);
-	if (substream->runtime && snd_pcm_running(substream))
-		__snd_pcm_xrun(substream);
+	ret = snd_pcm_stop_xrun_under_stream_lock(substream);
 	snd_pcm_stream_unlock_irqrestore(substream, flags);
-	return 0;
+	return ret;
 }
 EXPORT_SYMBOL_GPL(snd_pcm_stop_xrun);
 
diff --git a/sound/usb/endpoint.c b/sound/usb/endpoint.c
index 1e0af1179ca8..83a6b6d41374 100644
--- a/sound/usb/endpoint.c
+++ b/sound/usb/endpoint.c
@@ -400,13 +400,17 @@  static int prepare_inbound_urb(struct snd_usb_endpoint *ep,
 }
 
 /* notify an error as XRUN to the assigned PCM data substream */
-static void notify_xrun(struct snd_usb_endpoint *ep)
+static void notify_xrun(struct snd_usb_endpoint *ep, bool in_stream_lock)
 {
 	struct snd_usb_substream *data_subs;
 
 	data_subs = READ_ONCE(ep->data_subs);
-	if (data_subs && data_subs->pcm_substream)
-		snd_pcm_stop_xrun(data_subs->pcm_substream);
+	if (data_subs && data_subs->pcm_substream) {
+		if (in_stream_lock)
+			snd_pcm_stop_xrun_under_stream_lock(data_subs->pcm_substream);
+		else
+			snd_pcm_stop_xrun(data_subs->pcm_substream);
+	}
 }
 
 static struct snd_usb_packet_info *
@@ -498,7 +502,7 @@  void snd_usb_queue_pending_output_urbs(struct snd_usb_endpoint *ep,
 			if (err == -EAGAIN)
 				push_back_to_ready_list(ep, ctx);
 			else
-				notify_xrun(ep);
+				notify_xrun(ep, in_stream_lock);
 			return;
 		}
 
@@ -507,7 +511,7 @@  void snd_usb_queue_pending_output_urbs(struct snd_usb_endpoint *ep,
 			usb_audio_err(ep->chip,
 				      "Unable to submit urb #%d: %d at %s\n",
 				      ctx->index, err, __func__);
-			notify_xrun(ep);
+			notify_xrun(ep, in_stream_lock);
 			return;
 		}
 
@@ -574,7 +578,7 @@  static void snd_complete_urb(struct urb *urb)
 		return;
 
 	usb_audio_err(ep->chip, "cannot submit urb (err = %d)\n", err);
-	notify_xrun(ep);
+	notify_xrun(ep, false);
 
 exit_clear:
 	clear_bit(ctx->index, &ep->active_mask);
@@ -1762,7 +1766,7 @@  static void snd_usb_handle_sync_urb(struct snd_usb_endpoint *ep,
 			usb_audio_err(ep->chip,
 				      "next package FIFO overflow EP 0x%x\n",
 				      ep->ep_num);
-			notify_xrun(ep);
+			notify_xrun(ep, false);
 			return;
 		}