line6_buffer_release() frees the stream buffer after line6_wait_clear_audio_urbs() gave up waiting for the URBs that are still active. The buffer is still referenced by those URBs, and the completion callback of such an URB resubmits it from submit_audio_out_urb() with line6pcm->out.buffer already set to NULL, which ends up in a NULL pointer dereference in the memset() in submit_audio_out_urb(). While the URBs remain queued, the host controller can also write the received isochronous data into the freed buffer. Such a write does not go through the KASAN checks, so it silently corrupts the freed slab object; the corruption was observed as a bogus KASAN quarantine entry that later led to a general protection fault in qlist_free_all(). The active_urbs bitmap cannot prove that the URBs are gone: line6_unlink_audio_urbs() is called outside the stream lock and only marks the URBs that are active at that moment, so an URB resubmitted by a completion callback right after the scan is never unlinked and keeps being resubmitted after the stream was stopped. Stop the URBs synchronously instead of polling for them: mark all currently active URBs for unlinking under the stream lock, so that the completion callbacks cannot resubmit them, and kill them with usb_kill_urb(), which waits for the giveback. Expose this through the sync_stop PCM op, which ALSA core invokes before hw_free(), hw_params() and prepare() once the stream was stopped, so the buffer is guaranteed to be unused when it is released. Replace line6_wait_clear_audio_urbs() with this helper accordingly, and drop its now redundant calls from snd_line6_prepare() and line6_pcm_acquire(). line6_pcm_disconnect() keeps stopping the URBs synchronously, since the device may be gone already. The monitor and impulse streams are started via line6_pcm_acquire() and released via line6_pcm_release() without going through the PCM ops, so line6_buffer_release() still stops the URBs before it frees the buffer. Fixes: 63e20df1e5b2 ("ALSA: line6: Reorganize PCM stream handling") Cc: stable@vger.kernel.org Co-developed-by: Bin Yu Signed-off-by: Bin Yu Co-developed-by: Cheng Wen Signed-off-by: Cheng Wen Signed-off-by: YuanZhe Liu <25031212351@stu.xidian.edu.cn> --- v4: - Add the sync_stop PCM op and drop the waits from snd_line6_prepare() and line6_pcm_acquire(), as suggested by Takashi Iwai. v3: - Kill the URBs unconditionally instead of rechecking active_urbs outside the stream lock, and clear the unlink marks after the kills. v2: - Rebased on sound/for-next. v1 was generated against v7.3.1 and no longer applied, because line6_buffer_release() gained the prev_fbuf clearing block in the meantime. No code change. --- sound/usb/line6/capture.c | 1 + sound/usb/line6/pcm.c | 66 +++++++++++++++++++++----------------- sound/usb/line6/pcm.h | 1 + sound/usb/line6/playback.c | 1 + 4 files changed, 40 insertions(+), 29 deletions(-) diff --git a/sound/usb/line6/capture.c b/sound/usb/line6/capture.c index 626274e503c7..fa98c26cf77d 100644 --- a/sound/usb/line6/capture.c +++ b/sound/usb/line6/capture.c @@ -284,6 +284,7 @@ const struct snd_pcm_ops snd_line6_capture_ops = { .hw_free = snd_line6_hw_free, .prepare = snd_line6_prepare, .trigger = snd_line6_trigger, + .sync_stop = snd_line6_sync_stop, .pointer = snd_line6_pointer, }; diff --git a/sound/usb/line6/pcm.c b/sound/usb/line6/pcm.c index d17baf7761c6..dc850aa2ebd0 100644 --- a/sound/usb/line6/pcm.c +++ b/sound/usb/line6/pcm.c @@ -109,29 +109,33 @@ static void line6_unlink_audio_urbs(struct snd_line6_pcm *line6pcm, } /* - Wait until unlinking of all currently active URBs has been finished. -*/ -static void line6_wait_clear_audio_urbs(struct snd_line6_pcm *line6pcm, - struct line6_pcm_stream *pcms) + * Mark all currently active URBs for unlinking and kill them. + * + * The unlink bit is set under the stream lock, so the completion + * callbacks cannot resubmit these URBs any longer. usb_kill_urb() then + * waits for the giveback of every URB, hence the stream buffer is no + * longer referenced by the host controller. The unlink marks are + * cleared afterwards, so that a later stream start can submit the URBs + * again. This function must be called from a sleepable context. + */ +static void line6_kill_audio_urbs(struct snd_line6_pcm *line6pcm, + struct line6_pcm_stream *pcms) { - int timeout = HZ; int i; - int alive; - do { - alive = 0; - for (i = 0; i < line6pcm->line6->iso_buffers; i++) { + scoped_guard(spinlock_irqsave, &pcms->lock) { + for (i = 0; i < line6pcm->line6->iso_buffers; i++) if (test_bit(i, &pcms->active_urbs)) - alive++; - } - if (!alive) - break; - set_current_state(TASK_UNINTERRUPTIBLE); - schedule_timeout(1); - } while (--timeout > 0); - if (alive) - dev_err(line6pcm->line6->ifcdev, - "timeout: still %d active urbs..\n", alive); + set_bit(i, &pcms->unlink_urbs); + } + + for (i = 0; i < line6pcm->line6->iso_buffers; i++) + if (pcms->urbs[i]) + usb_kill_urb(pcms->urbs[i]); + + scoped_guard(spinlock_irqsave, &pcms->lock) { + pcms->unlink_urbs = 0; + } } static inline struct line6_pcm_stream * @@ -172,7 +176,7 @@ static void line6_buffer_release(struct snd_line6_pcm *line6pcm, { clear_bit(type, &pstr->opened); if (!pstr->opened) { - line6_wait_clear_audio_urbs(line6pcm, pstr); + line6_kill_audio_urbs(line6pcm, pstr); if (pstr == &line6pcm->in) { /* prev_fbuf points into the capture buffer we are about * to free; drop it while no capture URB is in flight. @@ -337,8 +341,6 @@ int line6_pcm_acquire(struct snd_line6_pcm *line6pcm, int type, bool start) ret = line6_buffer_acquire(line6pcm, pstr, dir, type); if (ret < 0) goto error; - if (!pstr->running) - line6_wait_clear_audio_urbs(line6pcm, pstr); } if (start) { for (dir = 0; dir < 2; dir++) { @@ -510,10 +512,8 @@ static int snd_line6_new_pcm(struct usb_line6 *line6, struct snd_pcm **pcm_ret) */ void line6_pcm_disconnect(struct snd_line6_pcm *line6pcm) { - line6_unlink_audio_urbs(line6pcm, &line6pcm->out); - line6_unlink_audio_urbs(line6pcm, &line6pcm->in); - line6_wait_clear_audio_urbs(line6pcm, &line6pcm->out); - line6_wait_clear_audio_urbs(line6pcm, &line6pcm->in); + line6_kill_audio_urbs(line6pcm, &line6pcm->out); + line6_kill_audio_urbs(line6pcm, &line6pcm->in); } /* @@ -592,15 +592,23 @@ int line6_init_pcm(struct usb_line6 *line6, } EXPORT_SYMBOL_GPL(line6_init_pcm); +/* common PCM sync_stop callback */ +int snd_line6_sync_stop(struct snd_pcm_substream *substream) +{ + struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream); + struct line6_pcm_stream *pstr = get_stream(line6pcm, substream->stream); + + guard(mutex)(&line6pcm->state_mutex); + line6_kill_audio_urbs(line6pcm, pstr); + return 0; +} + /* prepare pcm callback */ int snd_line6_prepare(struct snd_pcm_substream *substream) { struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream); - struct line6_pcm_stream *pstr = get_stream(line6pcm, substream->stream); guard(mutex)(&line6pcm->state_mutex); - if (!pstr->running) - line6_wait_clear_audio_urbs(line6pcm, pstr); if (!test_and_set_bit(LINE6_FLAG_PREPARED, &line6pcm->flags)) { line6pcm->out.count = 0; diff --git a/sound/usb/line6/pcm.h b/sound/usb/line6/pcm.h index a15913bf2a7a..21e550948cd8 100644 --- a/sound/usb/line6/pcm.h +++ b/sound/usb/line6/pcm.h @@ -183,6 +183,7 @@ extern int line6_init_pcm(struct usb_line6 *line6, struct line6_pcm_properties *properties); extern int snd_line6_trigger(struct snd_pcm_substream *substream, int cmd); extern int snd_line6_prepare(struct snd_pcm_substream *substream); +extern int snd_line6_sync_stop(struct snd_pcm_substream *substream); extern int snd_line6_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *hw_params); extern int snd_line6_hw_free(struct snd_pcm_substream *substream); diff --git a/sound/usb/line6/playback.c b/sound/usb/line6/playback.c index e93a16f6958e..10e273f4b77a 100644 --- a/sound/usb/line6/playback.c +++ b/sound/usb/line6/playback.c @@ -414,6 +414,7 @@ const struct snd_pcm_ops snd_line6_playback_ops = { .hw_free = snd_line6_hw_free, .prepare = snd_line6_prepare, .trigger = snd_line6_trigger, + .sync_stop = snd_line6_sync_stop, .pointer = snd_line6_pointer, }; -- 2.34.1