1 files changed, 149 insertions, 36 deletions

diff --git a/sound/core/oss/pcm_oss.c b/sound/core/oss/pcm_oss.c
index 441405081195..481ab0e94ffa 100644
--- a/sound/core/oss/pcm_oss.c
+++ b/sound/core/oss/pcm_oss.c
@@ -823,8 +823,25 @@ static int choose_rate(struct snd_pcm_substream *substream,
         return snd_pcm_hw_param_near(substream, params, SNDRV_PCM_HW_PARAM_RATE, best_rate, NULL);
 }
 
-static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream,
-                                     bool trylock)
+/* parameter locking: returns immediately if tried during streaming */
+static int lock_params(struct snd_pcm_runtime *runtime)
+{
+        if (mutex_lock_interruptible(&runtime->oss.params_lock))
+                return -ERESTARTSYS;
+        if (atomic_read(&runtime->oss.rw_ref)) {
+                mutex_unlock(&runtime->oss.params_lock);
+                return -EBUSY;
+        }
+        return 0;
+}
+
+static void unlock_params(struct snd_pcm_runtime *runtime)
+{
+        mutex_unlock(&runtime->oss.params_lock);
+}
+
+/* call with params_lock held */
+static int snd_pcm_oss_change_params_locked(struct snd_pcm_substream *substream)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct snd_pcm_hw_params *params, *sparams;
@@ -838,11 +855,8 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream,
         const struct snd_mask *sformat_mask;
         struct snd_mask mask;
 
-        if (trylock) {
-                if (!(mutex_trylock(&runtime->oss.params_lock)))
-                        return -EAGAIN;
-        } else if (mutex_lock_interruptible(&runtime->oss.params_lock))
-                return -ERESTARTSYS;
+        if (!runtime->oss.params)
+                return 0;
         sw_params = kzalloc(sizeof(*sw_params), GFP_KERNEL);
         params = kmalloc(sizeof(*params), GFP_KERNEL);
         sparams = kmalloc(sizeof(*sparams), GFP_KERNEL);
@@ -1068,6 +1082,23 @@ failure:
         kfree(sw_params);
         kfree(params);
         kfree(sparams);
+        return err;
+}
+
+/* this one takes the lock by itself */
+static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream,
+                                     bool trylock)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        int err;
+
+        if (trylock) {
+                if (!(mutex_trylock(&runtime->oss.params_lock)))
+                        return -EAGAIN;
+        } else if (mutex_lock_interruptible(&runtime->oss.params_lock))
+                return -ERESTARTSYS;
+
+        err = snd_pcm_oss_change_params_locked(substream);
         mutex_unlock(&runtime->oss.params_lock);
         return err;
 }
@@ -1096,11 +1127,14 @@ static int snd_pcm_oss_get_active_substream(struct snd_pcm_oss_file *pcm_oss_fil
         return 0;
 }
 
+/* call with params_lock held */
 static int snd_pcm_oss_prepare(struct snd_pcm_substream *substream)
 {
         int err;
         struct snd_pcm_runtime *runtime = substream->runtime;
 
+        if (!runtime->oss.prepare)
+                return 0;
         err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_PREPARE, NULL);
         if (err < 0) {
                 pcm_dbg(substream->pcm,
@@ -1120,8 +1154,6 @@ static int snd_pcm_oss_make_ready(struct snd_pcm_substream *substream)
         struct snd_pcm_runtime *runtime;
         int err;
 
-        if (substream == NULL)
-                return 0;
         runtime = substream->runtime;
         if (runtime->oss.params) {
                 err = snd_pcm_oss_change_params(substream, false);
@@ -1129,6 +1161,29 @@ static int snd_pcm_oss_make_ready(struct snd_pcm_substream *substream)
                         return err;
         }
         if (runtime->oss.prepare) {
+                if (mutex_lock_interruptible(&runtime->oss.params_lock))
+                        return -ERESTARTSYS;
+                err = snd_pcm_oss_prepare(substream);
+                mutex_unlock(&runtime->oss.params_lock);
+                if (err < 0)
+                        return err;
+        }
+        return 0;
+}
+
+/* call with params_lock held */
+static int snd_pcm_oss_make_ready_locked(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime;
+        int err;
+
+        runtime = substream->runtime;
+        if (runtime->oss.params) {
+                err = snd_pcm_oss_change_params_locked(substream);
+                if (err < 0)
+                        return err;
+        }
+        if (runtime->oss.prepare) {
                 err = snd_pcm_oss_prepare(substream);
                 if (err < 0)
                         return err;
@@ -1332,13 +1387,15 @@ static ssize_t snd_pcm_oss_write1(struct snd_pcm_substream *substream, const cha
         if (atomic_read(&substream->mmap_count))
                 return -ENXIO;
 
-        if ((tmp = snd_pcm_oss_make_ready(substream)) < 0)
-                return tmp;
+        atomic_inc(&runtime->oss.rw_ref);
         while (bytes > 0) {
                 if (mutex_lock_interruptible(&runtime->oss.params_lock)) {
                         tmp = -ERESTARTSYS;
                         break;
                 }
+                tmp = snd_pcm_oss_make_ready_locked(substream);
+                if (tmp < 0)
+                        goto err;
                 if (bytes < runtime->oss.period_bytes || runtime->oss.buffer_used > 0) {
                         tmp = bytes;
                         if (tmp + runtime->oss.buffer_used > runtime->oss.period_bytes)
@@ -1394,6 +1451,7 @@ static ssize_t snd_pcm_oss_write1(struct snd_pcm_substream *substream, const cha
                 }
                 tmp = 0;
         }
+        atomic_dec(&runtime->oss.rw_ref);
         return xfer > 0 ? (snd_pcm_sframes_t)xfer : tmp;
 }
 
@@ -1439,13 +1497,15 @@ static ssize_t snd_pcm_oss_read1(struct snd_pcm_substream *substream, char __use
         if (atomic_read(&substream->mmap_count))
                 return -ENXIO;
 
-        if ((tmp = snd_pcm_oss_make_ready(substream)) < 0)
-                return tmp;
+        atomic_inc(&runtime->oss.rw_ref);
         while (bytes > 0) {
                 if (mutex_lock_interruptible(&runtime->oss.params_lock)) {
                         tmp = -ERESTARTSYS;
                         break;
                 }
+                tmp = snd_pcm_oss_make_ready_locked(substream);
+                if (tmp < 0)
+                        goto err;
                 if (bytes < runtime->oss.period_bytes || runtime->oss.buffer_used > 0) {
                         if (runtime->oss.buffer_used == 0) {
                                 tmp = snd_pcm_oss_read2(substream, runtime->oss.buffer, runtime->oss.period_bytes, 1);
@@ -1486,6 +1546,7 @@ static ssize_t snd_pcm_oss_read1(struct snd_pcm_substream *substream, char __use
                 }
                 tmp = 0;
         }
+        atomic_dec(&runtime->oss.rw_ref);
         return xfer > 0 ? (snd_pcm_sframes_t)xfer : tmp;
 }
 
@@ -1501,10 +1562,12 @@ static int snd_pcm_oss_reset(struct snd_pcm_oss_file *pcm_oss_file)
                         continue;
                 runtime = substream->runtime;
                 snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL);
+                mutex_lock(&runtime->oss.params_lock);
                 runtime->oss.prepare = 1;
                 runtime->oss.buffer_used = 0;
                 runtime->oss.prev_hw_ptr_period = 0;
                 runtime->oss.period_ptr = 0;
+                mutex_unlock(&runtime->oss.params_lock);
         }
         return 0;
 }
@@ -1590,9 +1653,13 @@ static int snd_pcm_oss_sync(struct snd_pcm_oss_file *pcm_oss_file)
                         goto __direct;
                 if ((err = snd_pcm_oss_make_ready(substream)) < 0)
                         return err;
+                atomic_inc(&runtime->oss.rw_ref);
+                if (mutex_lock_interruptible(&runtime->oss.params_lock)) {
+                        atomic_dec(&runtime->oss.rw_ref);
+                        return -ERESTARTSYS;
+                }
                 format = snd_pcm_oss_format_from(runtime->oss.format);
                 width = snd_pcm_format_physical_width(format);
-                mutex_lock(&runtime->oss.params_lock);
                 if (runtime->oss.buffer_used > 0) {
 #ifdef OSS_DEBUG
                         pcm_dbg(substream->pcm, "sync: buffer_used\n");
@@ -1602,10 +1669,8 @@ static int snd_pcm_oss_sync(struct snd_pcm_oss_file *pcm_oss_file)
                                                    runtime->oss.buffer + runtime->oss.buffer_used,
                                                    size);
                         err = snd_pcm_oss_sync1(substream, runtime->oss.period_bytes);
-                        if (err < 0) {
-                                mutex_unlock(&runtime->oss.params_lock);
-                                return err;
-                        }
+                        if (err < 0)
+                                goto unlock;
                 } else if (runtime->oss.period_ptr > 0) {
 #ifdef OSS_DEBUG
                         pcm_dbg(substream->pcm, "sync: period_ptr\n");
@@ -1615,10 +1680,8 @@ static int snd_pcm_oss_sync(struct snd_pcm_oss_file *pcm_oss_file)
                                                    runtime->oss.buffer,
                                                    size * 8 / width);
                         err = snd_pcm_oss_sync1(substream, size);
-                        if (err < 0) {
-                                mutex_unlock(&runtime->oss.params_lock);
-                                return err;
-                        }
+                        if (err < 0)
+                                goto unlock;
                 }
                 /*
                  * The ALSA's period might be a bit large than OSS one.
@@ -1632,7 +1695,11 @@ static int snd_pcm_oss_sync(struct snd_pcm_oss_file *pcm_oss_file)
                         else if (runtime->access == SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
                                 snd_pcm_lib_writev(substream, NULL, size);
                 }
+unlock:
                 mutex_unlock(&runtime->oss.params_lock);
+                atomic_dec(&runtime->oss.rw_ref);
+                if (err < 0)
+                        return err;
                 /*
                  * finish sync: drain the buffer
                  */
@@ -1643,7 +1710,9 @@ static int snd_pcm_oss_sync(struct snd_pcm_oss_file *pcm_oss_file)
                 substream->f_flags = saved_f_flags;
                 if (err < 0)
                         return err;
+                mutex_lock(&runtime->oss.params_lock);
                 runtime->oss.prepare = 1;
+                mutex_unlock(&runtime->oss.params_lock);
         }
 
         substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE];
@@ -1654,8 +1723,10 @@ static int snd_pcm_oss_sync(struct snd_pcm_oss_file *pcm_oss_file)
                 err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL);
                 if (err < 0)
                         return err;
+                mutex_lock(&runtime->oss.params_lock);
                 runtime->oss.buffer_used = 0;
                 runtime->oss.prepare = 1;
+                mutex_unlock(&runtime->oss.params_lock);
         }
         return 0;
 }
@@ -1667,6 +1738,8 @@ static int snd_pcm_oss_set_rate(struct snd_pcm_oss_file *pcm_oss_file, int rate)
         for (idx = 1; idx >= 0; --idx) {
                 struct snd_pcm_substream *substream = pcm_oss_file->streams[idx];
                 struct snd_pcm_runtime *runtime;
+                int err;
+
                 if (substream == NULL)
                         continue;
                 runtime = substream->runtime;
@@ -1674,10 +1747,14 @@ static int snd_pcm_oss_set_rate(struct snd_pcm_oss_file *pcm_oss_file, int rate)
                         rate = 1000;
                 else if (rate > 192000)
                         rate = 192000;
+                err = lock_params(runtime);
+                if (err < 0)
+                        return err;
                 if (runtime->oss.rate != rate) {
                         runtime->oss.params = 1;
                         runtime->oss.rate = rate;
                 }
+                unlock_params(runtime);
         }
         return snd_pcm_oss_get_rate(pcm_oss_file);
 }
@@ -1702,13 +1779,19 @@ static int snd_pcm_oss_set_channels(struct snd_pcm_oss_file *pcm_oss_file, unsig
         for (idx = 1; idx >= 0; --idx) {
                 struct snd_pcm_substream *substream = pcm_oss_file->streams[idx];
                 struct snd_pcm_runtime *runtime;
+                int err;
+
                 if (substream == NULL)
                         continue;
                 runtime = substream->runtime;
+                err = lock_params(runtime);
+                if (err < 0)
+                        return err;
                 if (runtime->oss.channels != channels) {
                         runtime->oss.params = 1;
                         runtime->oss.channels = channels;
                 }
+                unlock_params(runtime);
         }
         return snd_pcm_oss_get_channels(pcm_oss_file);
 }
@@ -1781,6 +1864,7 @@ static int snd_pcm_oss_get_formats(struct snd_pcm_oss_file *pcm_oss_file)
 static int snd_pcm_oss_set_format(struct snd_pcm_oss_file *pcm_oss_file, int format)
 {
         int formats, idx;
+        int err;
         
         if (format != AFMT_QUERY) {
                 formats = snd_pcm_oss_get_formats(pcm_oss_file);
@@ -1794,10 +1878,14 @@ static int snd_pcm_oss_set_format(struct snd_pcm_oss_file *pcm_oss_file, int for
                         if (substream == NULL)
                                 continue;
                         runtime = substream->runtime;
+                        err = lock_params(runtime);
+                        if (err < 0)
+                                return err;
                         if (runtime->oss.format != format) {
                                 runtime->oss.params = 1;
                                 runtime->oss.format = format;
                         }
+                        unlock_params(runtime);
                 }
         }
         return snd_pcm_oss_get_format(pcm_oss_file);
@@ -1817,8 +1905,6 @@ static int snd_pcm_oss_set_subdivide1(struct snd_pcm_substream *substream, int s
 {
         struct snd_pcm_runtime *runtime;
 
-        if (substream == NULL)
-                return 0;
         runtime = substream->runtime;
         if (subdivide == 0) {
                 subdivide = runtime->oss.subdivision;
@@ -1842,9 +1928,17 @@ static int snd_pcm_oss_set_subdivide(struct snd_pcm_oss_file *pcm_oss_file, int
 
         for (idx = 1; idx >= 0; --idx) {
                 struct snd_pcm_substream *substream = pcm_oss_file->streams[idx];
+                struct snd_pcm_runtime *runtime;
+
                 if (substream == NULL)
                         continue;
-                if ((err = snd_pcm_oss_set_subdivide1(substream, subdivide)) < 0)
+                runtime = substream->runtime;
+                err = lock_params(runtime);
+                if (err < 0)
+                        return err;
+                err = snd_pcm_oss_set_subdivide1(substream, subdivide);
+                unlock_params(runtime);
+                if (err < 0)
                         return err;
         }
         return err;
@@ -1854,8 +1948,6 @@ static int snd_pcm_oss_set_fragment1(struct snd_pcm_substream *substream, unsign
 {
         struct snd_pcm_runtime *runtime;
 
-        if (substream == NULL)
-                return 0;
         runtime = substream->runtime;
         if (runtime->oss.subdivision || runtime->oss.fragshift)
                 return -EINVAL;
@@ -1875,9 +1967,17 @@ static int snd_pcm_oss_set_fragment(struct snd_pcm_oss_file *pcm_oss_file, unsig
 
         for (idx = 1; idx >= 0; --idx) {
                 struct snd_pcm_substream *substream = pcm_oss_file->streams[idx];
+                struct snd_pcm_runtime *runtime;
+
                 if (substream == NULL)
                         continue;
-                if ((err = snd_pcm_oss_set_fragment1(substream, val)) < 0)
+                runtime = substream->runtime;
+                err = lock_params(runtime);
+                if (err < 0)
+                        return err;
+                err = snd_pcm_oss_set_fragment1(substream, val);
+                unlock_params(runtime);
+                if (err < 0)
                         return err;
         }
         return err;
@@ -1961,6 +2061,9 @@ static int snd_pcm_oss_set_trigger(struct snd_pcm_oss_file *pcm_oss_file, int tr
         }
         if (psubstream) {
                 runtime = psubstream->runtime;
+                cmd = 0;
+                if (mutex_lock_interruptible(&runtime->oss.params_lock))
+                        return -ERESTARTSYS;
                 if (trigger & PCM_ENABLE_OUTPUT) {
                         if (runtime->oss.trigger)
                                 goto _skip1;
@@ -1978,13 +2081,19 @@ static int snd_pcm_oss_set_trigger(struct snd_pcm_oss_file *pcm_oss_file, int tr
                         cmd = SNDRV_PCM_IOCTL_DROP;
                         runtime->oss.prepare = 1;
                 }
-                err = snd_pcm_kernel_ioctl(psubstream, cmd, NULL);
-                if (err < 0)
-                        return err;
-        }
  _skip1:
+                mutex_unlock(&runtime->oss.params_lock);
+                if (cmd) {
+                        err = snd_pcm_kernel_ioctl(psubstream, cmd, NULL);
+                        if (err < 0)
+                                return err;
+                }
+        }
         if (csubstream) {
                 runtime = csubstream->runtime;
+                cmd = 0;
+                if (mutex_lock_interruptible(&runtime->oss.params_lock))
+                        return -ERESTARTSYS;
                 if (trigger & PCM_ENABLE_INPUT) {
                         if (runtime->oss.trigger)
                                 goto _skip2;
@@ -1999,11 +2108,14 @@ static int snd_pcm_oss_set_trigger(struct snd_pcm_oss_file *pcm_oss_file, int tr
                         cmd = SNDRV_PCM_IOCTL_DROP;
                         runtime->oss.prepare = 1;
                 }
-                err = snd_pcm_kernel_ioctl(csubstream, cmd, NULL);
-                if (err < 0)
-                        return err;
-        }
  _skip2:
+                mutex_unlock(&runtime->oss.params_lock);
+                if (cmd) {
+                        err = snd_pcm_kernel_ioctl(csubstream, cmd, NULL);
+                        if (err < 0)
+                                return err;
+                }
+        }
         return 0;
 }
 
@@ -2255,6 +2367,7 @@ static void snd_pcm_oss_init_substream(struct snd_pcm_substream *substream,
         runtime->oss.maxfrags = 0;
         runtime->oss.subdivision = 0;
         substream->pcm_release = snd_pcm_oss_release_substream;
+        atomic_set(&runtime->oss.rw_ref, 0);
 }
 
 static int snd_pcm_oss_release_file(struct snd_pcm_oss_file *pcm_oss_file)