Merge branch 'for-next' into for-linus

Preparation for 4.17 merge.

Signed-off-by: Takashi Iwai <tiwai@suse.de>

6 files changed, 179 insertions, 62 deletions

diff --git a/sound/core/control.c b/sound/core/control.c
index 8a77620a3854..69734b0eafd0 100644
--- a/sound/core/control.c
+++ b/sound/core/control.c
@@ -105,7 +105,7 @@ static void snd_ctl_empty_read_queue(struct snd_ctl_file * ctl)
 {
         unsigned long flags;
         struct snd_kctl_event *cread;
-        
+
         spin_lock_irqsave(&ctl->read_lock, flags);
         while (!list_empty(&ctl->events)) {
                 cread = snd_kctl_event(ctl->events.next);
@@ -159,7 +159,7 @@ void snd_ctl_notify(struct snd_card *card, unsigned int mask,
         unsigned long flags;
         struct snd_ctl_file *ctl;
         struct snd_kctl_event *ev;
-        
+
         if (snd_BUG_ON(!card || !id))
                 return;
         if (card->shutdown)
@@ -213,7 +213,7 @@ static int snd_ctl_new(struct snd_kcontrol **kctl, unsigned int count,
 {
         unsigned int size;
         unsigned int idx;
-        
+
         if (count == 0 || count > MAX_CONTROL_COUNT)
                 return -EINVAL;
 
@@ -238,7 +238,7 @@ static int snd_ctl_new(struct snd_kcontrol **kctl, unsigned int count,
  * @ncontrol: the initialization record
  * @private_data: the private data to set
  *
- * Allocates a new struct snd_kcontrol instance and initialize from the given 
+ * Allocates a new struct snd_kcontrol instance and initialize from the given
  * template.  When the access field of ncontrol is 0, it's assumed as
  * READWRITE access. When the count field is 0, it's assumes as one.
  *
@@ -251,7 +251,7 @@ struct snd_kcontrol *snd_ctl_new1(const struct snd_kcontrol_new *ncontrol,
         unsigned int count;
         unsigned int access;
         int err;
-        
+
         if (snd_BUG_ON(!ncontrol || !ncontrol->info))
                 return NULL;
 
@@ -753,7 +753,7 @@ static int snd_ctl_elem_list(struct snd_card *card,
         struct snd_ctl_elem_id id;
         unsigned int offset, space, jidx;
         int err = 0;
-        
+
         if (copy_from_user(&list, _list, sizeof(list)))
                 return -EFAULT;
         offset = list.offset;
@@ -827,7 +827,7 @@ static int snd_ctl_elem_info(struct snd_ctl_file *ctl,
         struct snd_kcontrol_volatile *vd;
         unsigned int index_offset;
         int result;
-        
+
         down_read(&card->controls_rwsem);
         kctl = snd_ctl_find_id(card, &info->id);
         if (kctl == NULL) {
@@ -992,7 +992,7 @@ static int snd_ctl_elem_lock(struct snd_ctl_file *file,
         struct snd_kcontrol *kctl;
         struct snd_kcontrol_volatile *vd;
         int result;
-        
+
         if (copy_from_user(&id, _id, sizeof(id)))
                 return -EFAULT;
         down_write(&card->controls_rwsem);
@@ -1020,7 +1020,7 @@ static int snd_ctl_elem_unlock(struct snd_ctl_file *file,
         struct snd_kcontrol *kctl;
         struct snd_kcontrol_volatile *vd;
         int result;
-        
+
         if (copy_from_user(&id, _id, sizeof(id)))
                 return -EFAULT;
         down_write(&card->controls_rwsem);
diff --git a/sound/core/init.c b/sound/core/init.c
index 4fa5dd955740..79b4df1c1dc7 100644
--- a/sound/core/init.c
+++ b/sound/core/init.c
@@ -670,7 +670,7 @@ card_id_show_attr(struct device *dev,
                   struct device_attribute *attr, char *buf)
 {
         struct snd_card *card = container_of(dev, struct snd_card, card_dev);
-        return snprintf(buf, PAGE_SIZE, "%s\n", card->id);
+        return scnprintf(buf, PAGE_SIZE, "%s\n", card->id);
 }
 
 static ssize_t
@@ -710,7 +710,7 @@ card_number_show_attr(struct device *dev,
                      struct device_attribute *attr, char *buf)
 {
         struct snd_card *card = container_of(dev, struct snd_card, card_dev);
-        return snprintf(buf, PAGE_SIZE, "%i\n", card->number);
+        return scnprintf(buf, PAGE_SIZE, "%i\n", card->number);
 }
 
 static DEVICE_ATTR(number, S_IRUGO, card_number_show_attr, NULL);
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)
diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c
index a83152e7d387..f4a19509cccf 100644
--- a/sound/core/pcm_lib.c
+++ b/sound/core/pcm_lib.c
@@ -1129,16 +1129,12 @@ int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond,
         if (constrs->rules_num >= constrs->rules_all) {
                 struct snd_pcm_hw_rule *new;
                 unsigned int new_rules = constrs->rules_all + 16;
-                new = kcalloc(new_rules, sizeof(*c), GFP_KERNEL);
+                new = krealloc(constrs->rules, new_rules * sizeof(*c),
+                               GFP_KERNEL);
                 if (!new) {
                         va_end(args);
                         return -ENOMEM;
                 }
-                if (constrs->rules) {
-                        memcpy(new, constrs->rules,
-                               constrs->rules_num * sizeof(*c));
-                        kfree(constrs->rules);
-                }
                 constrs->rules = new;
                 constrs->rules_all = new_rules;
         }
diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c
index d18b3982548b..b84554893fab 100644
--- a/sound/core/pcm_native.c
+++ b/sound/core/pcm_native.c
@@ -323,7 +323,7 @@ static int constrain_params_by_rules(struct snd_pcm_substream *substream,
         struct snd_pcm_hw_constraints *constrs =
                                         &substream->runtime->hw_constraints;
         unsigned int k;
-        unsigned int rstamps[constrs->rules_num];
+        unsigned int *rstamps;
         unsigned int vstamps[SNDRV_PCM_HW_PARAM_LAST_INTERVAL + 1];
         unsigned int stamp;
         struct snd_pcm_hw_rule *r;
@@ -331,7 +331,7 @@ static int constrain_params_by_rules(struct snd_pcm_substream *substream,
         struct snd_mask old_mask;
         struct snd_interval old_interval;
         bool again;
-        int changed;
+        int changed, err = 0;
 
         /*
          * Each application of rule has own sequence number.
@@ -339,8 +339,9 @@ static int constrain_params_by_rules(struct snd_pcm_substream *substream,
          * Each member of 'rstamps' array represents the sequence number of
          * recent application of corresponding rule.
          */
-        for (k = 0; k < constrs->rules_num; k++)
-                rstamps[k] = 0;
+        rstamps = kcalloc(constrs->rules_num, sizeof(unsigned int), GFP_KERNEL);
+        if (!rstamps)
+                return -ENOMEM;
 
         /*
          * Each member of 'vstamps' array represents the sequence number of
@@ -398,8 +399,10 @@ retry:
                 }
 
                 changed = r->func(params, r);
-                if (changed < 0)
-                        return changed;
+                if (changed < 0) {
+                        err = changed;
+                        goto out;
+                }
 
                 /*
                  * When the parameter is changed, notify it to the caller
@@ -430,7 +433,9 @@ retry:
         if (again)
                 goto retry;
 
-        return 0;
+ out:
+        kfree(rstamps);
+        return err;
 }
 
 static int fixup_unreferenced_params(struct snd_pcm_substream *substream,
diff --git a/sound/core/vmaster.c b/sound/core/vmaster.c
index 8632301489fa..9e96186742d0 100644
--- a/sound/core/vmaster.c
+++ b/sound/core/vmaster.c
@@ -63,15 +63,18 @@ static int slave_update(struct link_slave *slave)
         struct snd_ctl_elem_value *uctl;
         int err, ch;
 
-        uctl = kmalloc(sizeof(*uctl), GFP_KERNEL);
+        uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
         if (!uctl)
                 return -ENOMEM;
         uctl->id = slave->slave.id;
         err = slave->slave.get(&slave->slave, uctl);
+        if (err < 0)
+                goto error;
         for (ch = 0; ch < slave->info.count; ch++)
                 slave->vals[ch] = uctl->value.integer.value[ch];
+ error:
         kfree(uctl);
-        return 0;
+        return err < 0 ? err : 0;
 }
 
 /* get the slave ctl info and save the initial values */