Add thread-safety to PCM API
cover Add thread-safety to PCM API
Hi,
here is an experimental patchset to add multi thread safety to PCM functions. Basically ALSA PCM functions are thread-unsafe, and applications are supposed to do the proper protection against racy accesses. The reality is, however, that application developers don't care such, as alsa-lib works in most cases. Of course, users still get occasionally mysterious crashes.
As a workaround, this patchset adds the pthread mutex protection to most of exported PCM functions. This is slightly an overkill, but the biggest merit is that it's easy to implement; I just wrapped the functions and replaced the internal ones with unlocked versions.
To be noted, there is an optimization for the direct hw PCM access. Performance-sensitive applications like JACK should work like before without any overhead.
Another bonus by this addition is that we can finally get rid of home brew (and deadly smelling) atomic macros from the tree, since it's now more widely protected.
I lightly tested on my local machines and it seems working well, so far.
Comments and suggestions welcome.
thanks,
Takashi
===
Takashi Iwai (5):
pcm: Add thread-safety to PCM API
test: Add pcm-multi-thread program
Add pcm-multi-thread to .gitignore
pcm: Remove superfluous rmb() from PCM meter plugin
pcm: Remove home brew atomic operations
.gitignore | 1 + configure.ac | 15 ++ include/Makefile.am | 2 +- include/iatomic.h | 170 ------------------ src/pcm/Makefile.am | 2 +- src/pcm/atomic.c | 43 ----- src/pcm/pcm.c | 468 +++++++++++++++++++++++++++++++++++++++++------- src/pcm/pcm_direct.c | 4 +- src/pcm/pcm_dmix.c | 13 +- src/pcm/pcm_dshare.c | 13 +- src/pcm/pcm_dsnoop.c | 15 +- src/pcm/pcm_file.c | 21 ++- src/pcm/pcm_generic.c | 10 +- src/pcm/pcm_hw.c | 3 + src/pcm/pcm_ioplug.c | 11 +- src/pcm/pcm_local.h | 62 ++++++- src/pcm/pcm_meter.c | 1 - src/pcm/pcm_mmap.c | 16 +- src/pcm/pcm_params.c | 2 +- src/pcm/pcm_plugin.c | 72 ++------ src/pcm/pcm_plugin.h | 2 - src/pcm/pcm_rate.c | 41 ++--- src/pcm/pcm_route.c | 2 +- test/Makefile.am | 3 +- test/pcm-multi-thread.c | 263 +++++++++++++++++++++++++++ 25 files changed, 851 insertions(+), 404 deletions(-) delete mode 100644 include/iatomic.h delete mode 100644 src/pcm/atomic.c create mode 100644 test/pcm-multi-thread.c
Signature · 1 line
2.9.0
RFC PATCH 1/5 pcm: Add thread-safety to PCM API
Traditionally, many of ALSA library functions are supposed to be thread-unsafe, and applications are required to take care of thread safety by themselves. However, people never be careful enough, and almost all applications fail in this regard.
This patch is an attempt to harden the thread safety in exported PCM functions in a simplistic way: namely, just wrap the exported functions with the pthread mutex of each PCM object. Some functions are split to both unlocked and locked versions for avoiding deadlocks.
Two new fields are added snd_pcm_t when the option is enabled:thread_safe and lock. The former indicates that the plugin is thread-safe that doesn't need this workaround and the latter is the pthread mutex. Currently only hw plugin has thread_safe=1. So, the most of real-time sensitive apps won't be influenced by this change at all.
Although the patch covers most of PCM ops, a few snd_pcm_fast_ops are left without the extra mutex locking: namely, the ones that may have blocking behavior, i.e. resume, drain, readi, writei, readn and writen. These are supposed to handle own locking in the callbacks.
If anyone wants to disable this new thread-safe API feature, it can be still turned off via --disable-thread-safety configure option.
--- configure.ac | 15 ++ src/pcm/pcm.c | 468 +++++++++++++++++++++++++++++++++++++++++++------- src/pcm/pcm_direct.c | 4 +- src/pcm/pcm_dmix.c | 13 +- src/pcm/pcm_dshare.c | 13 +- src/pcm/pcm_dsnoop.c | 15 +- src/pcm/pcm_file.c | 21 ++- src/pcm/pcm_generic.c | 10 +- src/pcm/pcm_hw.c | 3 + src/pcm/pcm_ioplug.c | 11 +- src/pcm/pcm_local.h | 62 ++++++- src/pcm/pcm_mmap.c | 16 +- src/pcm/pcm_params.c | 2 +- src/pcm/pcm_rate.c | 7 +- src/pcm/pcm_route.c | 2 +- 15 files changed, 565 insertions(+), 97 deletions(-)
configure.ac +15 -0
@@ -632,6 +632,21 @@ elif test "$max_cards" -gt 256; then fi AC_DEFINE_UNQUOTED(SND_MAX_CARDS, $max_cards, [Max number of cards]) +dnl Check for thread-safe API functions +if test "$HAVE_LIBPTHREAD" = "yes"; then +AC_MSG_CHECKING(for thread-safe API functions) +AC_ARG_ENABLE(thread-safety, + AS_HELP_STRING([--disable-thread-safety], + [disable thread-safe API functions]), + threadsafe="$enableval", threadsafe="yes") +if test "$threadsafe" = "yes"; then + AC_MSG_RESULT(yes) + AC_DEFINE([THREAD_SAFE_API], "1", [Build thread-safe API functions]) +else + AC_MSG_RESULT(no) +fi +fi + dnl Make a symlink for inclusion of alsa/xxx.h if test ! -L "$srcdir"/include/alsa ; then echo "Making a symlink include/alsa"
src/pcm/pcm.c +404 -64
1,161 lines not on this page · raw message
src/pcm/pcm_direct.c +2 -2
@@ -559,7 +559,7 @@ int snd_pcm_direct_poll_revents(snd_pcm_t *pcm, struct pollfd *pfds, unsigned in events = pfds[0 ].revents;if (events &POLLIN ) {snd_pcm_uframes_t avail; -snd_pcm_avail_update (pcm); +__snd_pcm_avail_update (pcm);if (pcm->stream ==SND_PCM_STREAM_PLAYBACK ) { events |=POLLOUT ; events &= ~POLLIN ;
@@ -580,7 +580,7 @@ int snd_pcm_direct_poll_revents(snd_pcm_t *pcm, struct pollfd *pfds, unsigned insnd_pcm_direct_clear_timer_queue (dmix); events &= ~(POLLOUT |POLLIN );/* additional check */ -switch (snd_pcm_state (pcm)) { +switch (__snd_pcm_state (pcm)) {case SND_PCM_STATE_XRUN :case SND_PCM_STATE_SUSPENDED :case SND_PCM_STATE_SETUP :
src/pcm/pcm_dmix.c +12 -1
@@ -601,7 +601,8 @@ static int snd_pcm_dmix_drop(snd_pcm_t *pcm)return 0 ; } -static int snd_pcm_dmix_drain (snd_pcm_t *pcm) +/* locked version */ +static int __snd_pcm_dmix_drain (snd_pcm_t *pcm) {snd_pcm_direct_t *dmix = pcm->private_data;snd_pcm_uframes_t stop_threshold;
@@ -659,6 +660,16 @@ static int snd_pcm_dmix_drain(snd_pcm_t *pcm)return 0 ; } +static int snd_pcm_dmix_drain (snd_pcm_t *pcm) +{ +int err; + +snd_pcm_lock (pcm); + err =__snd_pcm_dmix_drain (pcm); +snd_pcm_unlock (pcm); +return err; +} + static int snd_pcm_dmix_pause(snd_pcm_t *pcm ATTRIBUTE_UNUSED, int enable ATTRIBUTE_UNUSED) {return -EIO ;
src/pcm/pcm_dshare.c +12 -1
@@ -354,7 +354,8 @@ static int snd_pcm_dshare_drop(snd_pcm_t *pcm)return 0 ; } -static int snd_pcm_dshare_drain (snd_pcm_t *pcm) +/* locked version */ +static int __snd_pcm_dshare_drain (snd_pcm_t *pcm) {snd_pcm_direct_t *dshare = pcm->private_data;snd_pcm_uframes_t stop_threshold;
@@ -412,6 +413,16 @@ static int snd_pcm_dshare_drain(snd_pcm_t *pcm)return 0 ; } +static int snd_pcm_dshare_drain (snd_pcm_t *pcm) +{ +int err; + +snd_pcm_lock (pcm); + err =__snd_pcm_dshare_drain (pcm); +snd_pcm_unlock (pcm); +return err; +} + static int snd_pcm_dshare_pause(snd_pcm_t *pcm ATTRIBUTE_UNUSED, int enable ATTRIBUTE_UNUSED) {return -EIO ;
src/pcm/pcm_dsnoop.c +13 -2
@@ -297,7 +297,8 @@ static int snd_pcm_dsnoop_drop(snd_pcm_t *pcm)return 0 ; } -static int snd_pcm_dsnoop_drain (snd_pcm_t *pcm) +/* locked version */ +static int __snd_pcm_dsnoop_drain (snd_pcm_t *pcm) {snd_pcm_direct_t *dsnoop = pcm->private_data;snd_pcm_uframes_t stop_threshold;
@@ -314,12 +315,22 @@ static int snd_pcm_dsnoop_drain(snd_pcm_t *pcm)break ;if (pcm->mode &SND_PCM_NONBLOCK )return -EAGAIN ; -snd_pcm_wait (pcm,-1 ); +__snd_pcm_wait_in_lock (pcm,-1 ); } pcm->stop_threshold = stop_threshold;return snd_pcm_dsnoop_drop (pcm); } +static int snd_pcm_dsnoop_drain (snd_pcm_t *pcm) +{ +int err; + +snd_pcm_lock (pcm); + err =__snd_pcm_dsnoop_drain (pcm); +snd_pcm_unlock (pcm); +return err; +} + static int snd_pcm_dsnoop_pause(snd_pcm_t *pcm ATTRIBUTE_UNUSED, int enable ATTRIBUTE_UNUSED) {return -EIO ;
src/pcm/pcm_file.c +17 -4
@@ -440,13 +440,16 @@ static int snd_pcm_file_drop(snd_pcm_t *pcm)return err; } +/* locking */ static int snd_pcm_file_drain (snd_pcm_t *pcm) {snd_pcm_file_t *file = pcm->private_data;int err =snd_pcm_drain (file->gen.slave);if (err >=0 ) { +snd_pcm_lock (pcm);snd_pcm_file_write_bytes (pcm, file->wbuf_used_bytes);assert (file->wbuf_used_bytes ==0 ); +snd_pcm_unlock (pcm); }return err; }
@@ -507,40 +510,49 @@ static snd_pcm_sframes_t snd_pcm_file_forward(snd_pcm_t *pcm, snd_pcm_uframes_treturn err; } +/* locking */ static snd_pcm_sframes_t snd_pcm_file_writei (snd_pcm_t *pcm,const void *buffer,snd_pcm_uframes_t size) {snd_pcm_file_t *file = pcm->private_data;snd_pcm_channel_area_t areas[pcm->channels]; -snd_pcm_sframes_t n =snd_pcm_writei (file->gen.slave, buffer, size); +snd_pcm_sframes_t n =_snd_pcm_writei (file->gen.slave, buffer, size);if (n >0 ) {snd_pcm_areas_from_buf (pcm, areas, (void *) buffer); +snd_pcm_lock (pcm);snd_pcm_file_add_frames (pcm, areas,0 , n); +snd_pcm_unlock (pcm); }return n; } +/* locking */ static snd_pcm_sframes_t snd_pcm_file_writen (snd_pcm_t *pcm,void **bufs,snd_pcm_uframes_t size) {snd_pcm_file_t *file = pcm->private_data;snd_pcm_channel_area_t areas[pcm->channels]; -snd_pcm_sframes_t n =snd_pcm_writen (file->gen.slave, bufs, size); +snd_pcm_sframes_t n =_snd_pcm_writen (file->gen.slave, bufs, size);if (n >0 ) {snd_pcm_areas_from_bufs (pcm, areas, bufs); +snd_pcm_lock (pcm);snd_pcm_file_add_frames (pcm, areas,0 , n); +snd_pcm_unlock (pcm); }return n; } +/* locking */ static snd_pcm_sframes_t snd_pcm_file_readi (snd_pcm_t *pcm,void *buffer,snd_pcm_uframes_t size) {snd_pcm_file_t *file = pcm->private_data;snd_pcm_sframes_t n; - n =snd_pcm_readi (file->gen.slave, buffer, size); + n =_snd_pcm_readi (file->gen.slave, buffer, size);if (n <=0 )return n;if (file->ifd >=0 ) { +snd_pcm_lock (pcm); n =read (file->ifd, buffer, n * pcm->frame_bits /8 ); +snd_pcm_unlock (pcm);if (n <0 )return n;return n *8 / pcm->frame_bits;
@@ -548,6 +560,7 @@ static snd_pcm_sframes_t snd_pcm_file_readi(snd_pcm_t *pcm, void *buffer, snd_pcreturn n; } +/* locking */ static snd_pcm_sframes_t snd_pcm_file_readn (snd_pcm_t *pcm,void **bufs,snd_pcm_uframes_t size) {snd_pcm_file_t *file = pcm->private_data;
@@ -558,7 +571,7 @@ static snd_pcm_sframes_t snd_pcm_file_readn(snd_pcm_t *pcm, void **bufs, snd_pcmreturn 0 ;/* TODO: Noninterleaved read */ } - n =snd_pcm_readn (file->gen.slave, bufs, size); + n =_snd_pcm_readn (file->gen.slave, bufs, size);return n; }
src/pcm/pcm_generic.c +5 -5
@@ -235,25 +235,25 @@ int snd_pcm_generic_unlink(snd_pcm_t *pcm)snd_pcm_sframes_t snd_pcm_generic_writei (snd_pcm_t *pcm,const void *buffer,snd_pcm_uframes_t size) {snd_pcm_generic_t *generic = pcm->private_data; -return snd_pcm_writei (generic->slave, buffer, size); +return _snd_pcm_writei (generic->slave, buffer, size); }snd_pcm_sframes_t snd_pcm_generic_writen (snd_pcm_t *pcm,void **bufs,snd_pcm_uframes_t size) {snd_pcm_generic_t *generic = pcm->private_data; -return snd_pcm_writen (generic->slave, bufs, size); +return _snd_pcm_writen (generic->slave, bufs, size); }snd_pcm_sframes_t snd_pcm_generic_readi (snd_pcm_t *pcm,void *buffer,snd_pcm_uframes_t size) {snd_pcm_generic_t *generic = pcm->private_data; -return snd_pcm_readi (generic->slave, buffer, size); +return _snd_pcm_readi (generic->slave, buffer, size); }snd_pcm_sframes_t snd_pcm_generic_readn (snd_pcm_t *pcm,void **bufs,snd_pcm_uframes_t size) {snd_pcm_generic_t *generic = pcm->private_data; -return snd_pcm_readn (generic->slave, bufs, size); +return _snd_pcm_readn (generic->slave, bufs, size); } snd_pcm_sframes_t snd_pcm_generic_mmap_commit(snd_pcm_t *pcm,
@@ -287,7 +287,7 @@ int snd_pcm_generic_real_htimestamp(snd_pcm_t *pcm, snd_pcm_uframes_t *avail,int ok =0 ;while (1 ) { - avail1 =snd_pcm_avail_update (pcm); + avail1 =__snd_pcm_avail_update (pcm);if (avail1 <0 )return avail1;if (ok && (snd_pcm_uframes_t )avail1 == *avail)
src/pcm/pcm_hw.c +3 -0
@@ -1505,6 +1505,9 @@ int snd_pcm_hw_open_fd(snd_pcm_t **pcmp, const char *name, pcm->poll_fd = fd; pcm->poll_events = info.stream ==SND_PCM_STREAM_PLAYBACK ?POLLOUT :POLLIN ; pcm->tstamp_type = tstamp_type; +#ifdef THREAD_SAFE_API + pcm->thread_safe =1 ; +#endif ret =snd_pcm_hw_mmap_status (pcm);if (ret <0 ) {
src/pcm/pcm_ioplug.c +8 -3
@@ -469,15 +469,20 @@ static int snd_pcm_ioplug_drop(snd_pcm_t *pcm)return 0 ; } +/* need locking */ static int snd_pcm_ioplug_drain (snd_pcm_t *pcm) {ioplug_priv_t *io = pcm->private_data; +int err;if (io->data->state ==SND_PCM_STATE_OPEN )return -EBADFD ;if (io->data->callback->drain) io->data->callback->drain (io->data); -return snd_pcm_ioplug_drop (pcm); +snd_pcm_lock (pcm); + err =snd_pcm_ioplug_drop (pcm); +snd_pcm_unlock (pcm); +return err; }static int snd_pcm_ioplug_pause (snd_pcm_t *pcm,int enable)
@@ -609,7 +614,7 @@ static snd_pcm_sframes_t snd_pcm_ioplug_mmap_commit(snd_pcm_t *pcm,const snd_pcm_channel_area_t *areas;snd_pcm_uframes_t ofs, frames = size; -snd_pcm_mmap_begin (pcm, &areas, &ofs, &frames); +__snd_pcm_mmap_begin (pcm, &areas, &ofs, &frames);if (ofs != offset)return -EIO ;return ioplug_priv_transfer_areas (pcm, areas, offset, frames);
@@ -635,7 +640,7 @@ static snd_pcm_sframes_t snd_pcm_ioplug_avail_update(snd_pcm_t *pcm)snd_pcm_uframes_t offset, size =UINT_MAX ;snd_pcm_sframes_t result; -snd_pcm_mmap_begin (pcm, &areas, &offset, &size); +__snd_pcm_mmap_begin (pcm, &areas, &offset, &size); result = io->data->callback->transfer (io->data, areas, offset, size);if (result <0 )return result;
src/pcm/pcm_local.h +54 -8
136 lines not on this page · raw message
src/pcm/pcm_mmap.c +12 -4
@@ -82,12 +82,12 @@ static snd_pcm_sframes_t snd_pcm_mmap_write_areas(snd_pcm_t *pcm,snd_pcm_uframes_t frames = size;snd_pcm_sframes_t result; -snd_pcm_mmap_begin (pcm, &pcm_areas, &pcm_offset, &frames); +__snd_pcm_mmap_begin (pcm, &pcm_areas, &pcm_offset, &frames);snd_pcm_areas_copy (pcm_areas, pcm_offset, areas, offset, pcm->channels, frames, pcm->format); - result =snd_pcm_mmap_commit (pcm, pcm_offset, frames); + result =__snd_pcm_mmap_commit (pcm, pcm_offset, frames);if (result <0 )return xfer >0 ? (snd_pcm_sframes_t )xfer : result; offset += result;
@@ -114,12 +114,12 @@ static snd_pcm_sframes_t snd_pcm_mmap_read_areas(snd_pcm_t *pcm,snd_pcm_uframes_t frames = size;snd_pcm_sframes_t result; -snd_pcm_mmap_begin (pcm, &pcm_areas, &pcm_offset, &frames); +__snd_pcm_mmap_begin (pcm, &pcm_areas, &pcm_offset, &frames);snd_pcm_areas_copy (areas, offset, pcm_areas, pcm_offset, pcm->channels, frames, pcm->format); - result =snd_pcm_mmap_commit (pcm, pcm_offset, frames); + result =__snd_pcm_mmap_commit (pcm, pcm_offset, frames);if (result <0 )return xfer >0 ? (snd_pcm_sframes_t )xfer : result; offset += result;
@@ -256,6 +256,7 @@ int snd_pcm_channel_info_shm(snd_pcm_t *pcm, snd_pcm_channel_info_t *info, int sreturn 0 ; } +/* called in pcm lock */ int snd_pcm_mmap (snd_pcm_t *pcm) {int err;
@@ -435,6 +436,7 @@ int snd_pcm_mmap(snd_pcm_t *pcm)return 0 ; } +/* called in pcm lock */ int snd_pcm_munmap (snd_pcm_t *pcm) {int err;
@@ -513,6 +515,7 @@ int snd_pcm_munmap(snd_pcm_t *pcm)return 0 ; } +/* called in pcm lock */ snd_pcm_sframes_t snd_pcm_write_mmap (snd_pcm_t *pcm,snd_pcm_uframes_t offset,snd_pcm_uframes_t size) {
@@ -545,7 +548,9 @@ snd_pcm_sframes_t snd_pcm_write_mmap(snd_pcm_t *pcm, snd_pcm_uframes_t offset,const snd_pcm_channel_area_t *a = &areas[c]; bufs[c] =snd_pcm_channel_area_addr (a, offset); } +snd_pcm_unlock (pcm); err =_snd_pcm_writen (pcm, bufs, frames); +snd_pcm_lock (pcm);if (err >=0 ) frames = err;break ;
@@ -564,6 +569,7 @@ snd_pcm_sframes_t snd_pcm_write_mmap(snd_pcm_t *pcm, snd_pcm_uframes_t offset,return err; } +/* called in pcm lock */ snd_pcm_sframes_t snd_pcm_read_mmap (snd_pcm_t *pcm,snd_pcm_uframes_t offset,snd_pcm_uframes_t size) {
@@ -596,7 +602,9 @@ snd_pcm_sframes_t snd_pcm_read_mmap(snd_pcm_t *pcm, snd_pcm_uframes_t offset,const snd_pcm_channel_area_t *a = &areas[c]; bufs[c] =snd_pcm_channel_area_addr (a, offset); } +snd_pcm_unlock (pcm); err =_snd_pcm_readn (pcm->fast_op_arg, bufs, frames); +snd_pcm_lock (pcm);if (err >=0 ) frames = err;break ;
src/pcm/pcm_params.c +1 -1
@@ -2360,7 +2360,7 @@ int _snd_pcm_hw_params_internal(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)/* Default sw params */ memset (&sw,0 ,sizeof (sw));snd_pcm_sw_params_default (pcm, &sw); - err =snd_pcm_sw_params (pcm, &sw); + err =__snd_pcm_sw_params (pcm, &sw);if (err <0 )return err;
src/pcm/pcm_rate.c +6 -1
@@ -1004,6 +1004,7 @@ static int snd_pcm_rate_poll_revents(snd_pcm_t *pcm, struct pollfd *pfds, unsignreturn snd_pcm_poll_descriptors_revents (rate->gen.slave, pfds, nfds, revents); } +/* locking */ static int snd_pcm_rate_drain (snd_pcm_t *pcm) {snd_pcm_rate_t *rate = pcm->private_data;
@@ -1013,6 +1014,7 @@ static int snd_pcm_rate_drain(snd_pcm_t *pcm)snd_pcm_uframes_t size, ofs, saved_avail_min;snd_pcm_sw_params_t sw_params; +snd_pcm_lock (pcm);/* temporarily set avail_min to one */ sw_params = rate->sw_params; saved_avail_min = sw_params.avail_min;
@@ -1023,8 +1025,10 @@ static int snd_pcm_rate_drain(snd_pcm_t *pcm) ofs = rate->last_commit_ptr % pcm->buffer_size;while (size >0 ) {snd_pcm_uframes_t psize, spsize; +int err; -if (snd_pcm_wait (rate->gen.slave,-1 ) <0 ) + err =__snd_pcm_wait_in_lock (rate->gen.slave,-1 ); +if (err <0 )break ;if (size > pcm->period_size) { psize = pcm->period_size;
@@ -1042,6 +1046,7 @@ static int snd_pcm_rate_drain(snd_pcm_t *pcm) } sw_params.avail_min = saved_avail_min;snd_pcm_sw_params (rate->gen.slave, &sw_params); +snd_pcm_unlock (pcm); }return snd_pcm_drain (rate->gen.slave); }
src/pcm/pcm_route.c +1 -1
@@ -877,7 +877,7 @@ static int route_chmap_init(snd_pcm_t *pcm)snd_pcm_route_t *route = pcm->private_data;if (!route->chmap)return 0 ; -if (snd_pcm_state (pcm) !=SND_PCM_STATE_PREPARED ) +if (__snd_pcm_state (pcm) !=SND_PCM_STATE_PREPARED )return 0 ;/* Check if we really need to set the chmap or not.
Signature · 1 line
2.9.0
Re: [PATCH RFC alsa-lib 1/5] pcm: Add thread-safety to PCM API
Quoted 20 lines · Takashi Iwai
src/pcm/pcm.c +3
-0@@ -686,6 +686,8 @@ snd_pcm_stream_t snd_pcm_stream(snd_pcm_t *pcm)* * Closes the specified PCM handle and frees all associated * resources. +* +* The function is thread-safe when built with the proper option. */ int snd_pcm_close (snd_pcm_t *pcm) {@@ -697,6 +699,7 @@ int snd_pcm_close(snd_pcm_t *pcm)if (err <0 ) res = err; } +snd_pcm_lock (pcm);if (pcm->mmap_channels)snd_pcm_munmap (pcm);while (!list_empty (&pcm->async_handlers)) {
src/pcm/pcm.c int snd_pcm_close(snd_pcm_t *pcm) · line 713
Quoted 7 lines
src/pcm/pcm.c +1
-0@@ -704,6 +707,7 @@ int snd_pcm_close(snd_pcm_t *pcm)snd_async_del_handler (h); } err = pcm->ops->close (pcm->op_arg); +snd_pcm_unlock (pcm);if (err <0 ) res = err; err =snd_pcm_free (pcm);
Thread safety does not really make sense for a destructor like snd_pcm_close(). If any other code is accessing the device at the same time, the freeing will make it crash anyway.
What would make sense would be to output a debug warning if the device is locked, and/or to poison the device (maybe ->ops = NULL).
Regards,
Clemens
Re: [PATCH RFC alsa-lib 1/5] pcm: Add thread-safety to PCM API
Quoted 25 lines · Clemens Ladisch
Quoted 23 lines · Takashi Iwai
src/pcm/pcm.c +3
-0@@ -686,6 +686,8 @@ snd_pcm_stream_t snd_pcm_stream(snd_pcm_t *pcm)* * Closes the specified PCM handle and frees all associated * resources. +* +* The function is thread-safe when built with the proper option. */ int snd_pcm_close (snd_pcm_t *pcm) {@@ -697,6 +699,7 @@ int snd_pcm_close(snd_pcm_t *pcm)if (err <0 ) res = err; } +snd_pcm_lock (pcm);if (pcm->mmap_channels)snd_pcm_munmap (pcm);while (!list_empty (&pcm->async_handlers)) {@@ -704,6 +707,7 @@ int snd_pcm_close(snd_pcm_t *pcm)snd_async_del_handler (h); } err = pcm->ops->close (pcm->op_arg);
Quoted 8 lines
src/pcm/pcm.c int snd_pcm_close(snd_pcm_t *pcm) · line 713
Quoted 4 lines
src/pcm/pcm.c +1
-0+snd_pcm_unlock (pcm);if (err <0 ) res = err; err =snd_pcm_free (pcm);Thread safety does not really make sense for a destructor like
snd_pcm_close(). If any other code is accessing the device at the same time, the freeing will make it crash anyway.
That's true. OTOH, snd_pcm_close() does sync before closing, so I thought it might be not too bad to be prepared for bad programmers. But I'm fine to get rid of it.
Quoted 2 lines
What would make sense would be to output a debug warning if the device is locked, and/or to poison the device (maybe ->ops = NULL).
Yes, more debugging option would be nicer. We can add it later.
thanks,
Takashi
RFC PATCH 2/5 test: Add pcm-multi-thread program
In reply to Takashi IwaiA simple multi-thread stress test for PCM is added to test subdirectory. It can perform various PCM update function in the worker threads while reading/writing the data in the main thread. It can help catching the unexpected error or blockage. For example, running the capture test without thread-safety option will lead to the assert due to the races.
--- test/Makefile.am | 3 +- test/pcm-multi-thread.c | 263 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 265 insertions(+), 1 deletion(-) create mode 100644 test/pcm-multi-thread.c
test/Makefile.am +2 -1
@@ -3,7 +3,7 @@ SUBDIRS=. lsb check_PROGRAMS=control pcm pcm_min latency seq \ playmidi1 timer rawmidi midiloop \ oldapi queue_timer namehint client_event_filter \ - chmap audio_time user-ctl-element-set + chmap audio_time user-ctl-element-set pcm-multi-thread control_LDADD=../src/libasound.la pcm_LDADD=../src/libasound.la
@@ -23,6 +23,7 @@ client_event_filter_LDADD=../src/libasound.la code_CFLAGS=-Wall -pipe -g -O2 chmap_LDADD=../src/libasound.la audio_time_LDADD=../src/libasound.la +pcm_multi_thread_LDADD=../src/libasound.la user_ctl_element_set_LDADD=../src/libasound.la user_ctl_element_set_CFLAGS=-Wall -g
test/pcm-multi-thread.c new file +263 -0
263 lines not on this page · raw message
Signature · 1 line
2.9.0
RFC PATCH 3/5 Add pcm-multi-thread to .gitignore
In reply to Takashi Iwai--- .gitignore | 1 + 1 file changed, 1 insertion(+)
.gitignore +1 -0
@@ -58,6 +58,7 @@ test/oldapi test/chmap test/pcm test/pcm_min +test/pcm-multi-thread test/playmidi1 test/queue_timer test/rawmidi
Signature · 1 line
2.9.0
RFC PATCH 4/5 pcm: Remove superfluous rmb() from PCM meter plugin
In reply to Takashi Iwairmb() is still left in the code without any actual meaning there just before the atomic operation. Let's clean it up.
--- src/pcm/pcm_meter.c | 1 - 1 file changed, 1 deletion(-)
src/pcm/pcm_meter.c +0 -1
@@ -136,7 +136,6 @@ static int snd_pcm_meter_update_scope(snd_pcm_t *pcm) _again: rptr = *pcm->hw.ptr; old_rptr = meter->rptr; -rmb ();if (atomic_read (&meter->reset)) { reset =1 ;atomic_dec (&meter->reset);
Signature · 1 line
2.9.0
RFC PATCH 5/5 pcm: Remove home brew atomic operations
In reply to Takashi IwaiWe've had a few home brew atomic operations in a couple of places in the PCM code. This was for supporting the concurrent accesses, but in practice, it couldn't cover the race properly by itself alone.
Since we have a wider concurrency protection via mutex now, we can get rid of these atomic codes, which worsens the portability significantly.
--- include/Makefile.am | 2 +- include/iatomic.h | 170 --------------------------------------------------- src/pcm/Makefile.am | 2 +- src/pcm/atomic.c | 43 ------------- src/pcm/pcm_plugin.c | 72 +++++----------------- src/pcm/pcm_plugin.h | 2 - src/pcm/pcm_rate.c | 34 ++--------- 7 files changed, 20 insertions(+), 305 deletions(-) delete mode 100644 include/iatomic.h delete mode 100644 src/pcm/atomic.c
include/Makefile.am +1 -1
@@ -5,7 +5,7 @@ alsaincludedir = ${includedir}/alsa alsainclude_HEADERS = asoundlib.h asoundef.h \ version.h global.h input.h output.h error.h \ - conf.h control.h iatomic.h + conf.h control.h if BUILD_CTL_PLUGIN_EXT alsainclude_HEADERS += control_external.h
include/iatomic.h deleted +0 -170
170 lines not on this page · raw message
src/pcm/Makefile.am +1 -1
@@ -3,7 +3,7 @@ DIST_SUBDIRS = scopes EXTRA_LTLIBRARIES = libpcm.la -libpcm_la_SOURCES = atomic.c mask.c interval.c \ +libpcm_la_SOURCES = mask.c interval.c \ pcm.c pcm_params.c pcm_simple.c \ pcm_hw.c pcm_misc.c pcm_mmap.c pcm_symbols.c
src/pcm/atomic.c deleted +0 -43
43 lines not on this page · raw message
src/pcm/pcm_plugin.c +14 -58
236 lines not on this page · raw message
src/pcm/pcm_plugin.h +0 -2
@@ -19,7 +19,6 @@* */ -#include "iatomic.h" #include "pcm_generic.h" typedef snd_pcm_uframes_t (*snd_pcm_slave_xfer_areas_func_t )
@@ -46,7 +45,6 @@ typedef struct {snd_pcm_slave_xfer_areas_undo_func_t undo_write;int (*init)(snd_pcm_t *pcm);snd_pcm_uframes_t appl_ptr, hw_ptr; -snd_atomic_write_t watom; } snd_pcm_plugin_t;/* make local functions really local */
src/pcm/pcm_rate.c +4 -30
@@ -32,7 +32,6 @@#include "pcm_local.h" #include "pcm_plugin.h" #include "pcm_rate.h" -#include "iatomic.h" #include "plugin_ops.h"
@@ -51,7 +50,6 @@ typedef struct _snd_pcm_rate snd_pcm_rate_t;struct _snd_pcm_rate {snd_pcm_generic_t gen; -snd_atomic_write_t watom;snd_pcm_uframes_t appl_ptr, hw_ptr;snd_pcm_uframes_t last_commit_ptr;snd_pcm_uframes_t orig_avail_min;
@@ -584,9 +582,7 @@ static int snd_pcm_rate_hwsync(snd_pcm_t *pcm)int err =snd_pcm_hwsync (rate->gen.slave);if (err <0 )return err; -snd_atomic_write_begin (&rate->watom);snd_pcm_rate_sync_hwptr (pcm); -snd_atomic_write_end (&rate->watom);return 0 ; }
@@ -602,15 +598,11 @@ static int snd_pcm_rate_prepare(snd_pcm_t *pcm)snd_pcm_rate_t *rate = pcm->private_data;int err; -snd_atomic_write_begin (&rate->watom); err =snd_pcm_prepare (rate->gen.slave); -if (err <0 ) { -snd_atomic_write_end (&rate->watom); +if (err <0 )return err; - } *pcm->hw.ptr =0 ; *pcm->appl.ptr =0 ; -snd_atomic_write_end (&rate->watom); err =snd_pcm_rate_init (pcm);if (err <0 )return err;
@@ -621,15 +613,11 @@ static int snd_pcm_rate_reset(snd_pcm_t *pcm) {snd_pcm_rate_t *rate = pcm->private_data;int err; -snd_atomic_write_begin (&rate->watom); err =snd_pcm_reset (rate->gen.slave); -if (err <0 ) { -snd_atomic_write_end (&rate->watom); +if (err <0 )return err; - } *pcm->hw.ptr =0 ; *pcm->appl.ptr =0 ; -snd_atomic_write_end (&rate->watom); err =snd_pcm_rate_init (pcm);if (err <0 )return err;
@@ -923,9 +911,7 @@ static snd_pcm_sframes_t snd_pcm_rate_mmap_commit(snd_pcm_t *pcm,if (err <0 )return err; } -snd_atomic_write_begin (&rate->watom);snd_pcm_mmap_appl_forward (pcm, size); -snd_atomic_write_end (&rate->watom);return size; }
@@ -938,9 +924,7 @@ static snd_pcm_sframes_t snd_pcm_rate_avail_update(snd_pcm_t *pcm) slave_size =snd_pcm_avail_update (slave);if (pcm->stream ==SND_PCM_STREAM_CAPTURE ) goto _capture; -snd_atomic_write_begin (&rate->watom);snd_pcm_rate_sync_hwptr (pcm); -snd_atomic_write_end (&rate->watom);snd_pcm_rate_sync_playback_area (pcm, rate->appl_ptr);return snd_pcm_mmap_avail (pcm); _capture: {
@@ -1090,15 +1074,10 @@ static int snd_pcm_rate_status(snd_pcm_t *pcm, snd_pcm_status_t * status) {snd_pcm_rate_t *rate = pcm->private_data;snd_pcm_sframes_t err; -snd_atomic_read_t ratom; -snd_atomic_read_init (&ratom, &rate->watom); - _again: -snd_atomic_read_begin (&ratom); + err =snd_pcm_status (rate->gen.slave, status); -if (err <0 ) { -snd_atomic_read_ok (&ratom); +if (err <0 )return err; - }if (pcm->stream ==SND_PCM_STREAM_PLAYBACK ) {if (rate->start_pending) status->state =SND_PCM_STATE_RUNNING ;
@@ -1116,10 +1095,6 @@ static int snd_pcm_rate_status(snd_pcm_t *pcm, snd_pcm_status_t * status) status->avail =snd_pcm_mmap_capture_avail (pcm); status->avail_max = rate->ops.output_frames (rate->obj, status->avail_max); } -if (!snd_atomic_read_ok (&ratom)) { -snd_atomic_read_wait (&ratom); - goto _again; - }return 0 ; }
@@ -1309,7 +1284,6 @@ int snd_pcm_rate_open(snd_pcm_t **pcmp, const char *name, rate->gen.close_slave = close_slave; rate->srate = srate; rate->sformat = sformat; -snd_atomic_write_init (&rate->watom); err =snd_pcm_new (&pcm,SND_PCM_TYPE_RATE , name, slave->stream, slave->mode);if (err <0 ) {
Signature · 1 line
2.9.0