aboutsummaryrefslogtreecommitdiffstats
path: root/sound/core
diff options
context:
space:
mode:
Diffstat (limited to 'sound/core')
-rw-r--r--sound/core/control.c50
-rw-r--r--sound/core/control_compat.c3
-rw-r--r--sound/core/device.c26
-rw-r--r--sound/core/hwdep.c16
-rw-r--r--sound/core/info.c23
-rw-r--r--sound/core/info_oss.c6
-rw-r--r--sound/core/init.c3
-rw-r--r--sound/core/memalloc.c41
-rw-r--r--sound/core/oss/copy.c30
-rw-r--r--sound/core/oss/io.c24
-rw-r--r--sound/core/oss/linear.c29
-rw-r--r--sound/core/oss/mixer_oss.c18
-rw-r--r--sound/core/oss/mulaw.c27
-rw-r--r--sound/core/oss/pcm_oss.c52
-rw-r--r--sound/core/oss/pcm_plugin.c38
-rw-r--r--sound/core/oss/rate.c42
-rw-r--r--sound/core/oss/route.c12
-rw-r--r--sound/core/pcm.c34
-rw-r--r--sound/core/pcm_compat.c3
-rw-r--r--sound/core/pcm_lib.c102
-rw-r--r--sound/core/pcm_memory.c14
-rw-r--r--sound/core/pcm_native.c127
-rw-r--r--sound/core/pcm_timer.c6
-rw-r--r--sound/core/rawmidi.c25
-rw-r--r--sound/core/rtctimer.c6
-rw-r--r--sound/core/seq/oss/seq_oss.c12
-rw-r--r--sound/core/seq/oss/seq_oss_synth.c6
-rw-r--r--sound/core/seq/seq_clientmgr.c30
-rw-r--r--sound/core/seq/seq_compat.c3
-rw-r--r--sound/core/seq/seq_device.c6
-rw-r--r--sound/core/seq/seq_fifo.c15
-rw-r--r--sound/core/seq/seq_memory.c12
-rw-r--r--sound/core/seq/seq_midi.c15
-rw-r--r--sound/core/seq/seq_ports.c13
-rw-r--r--sound/core/seq/seq_prioq.c4
-rw-r--r--sound/core/seq/seq_queue.c6
-rw-r--r--sound/core/seq/seq_timer.c24
-rw-r--r--sound/core/sound.c12
-rw-r--r--sound/core/sound_oss.c12
-rw-r--r--sound/core/timer.c33
-rw-r--r--sound/core/timer_compat.c9
41 files changed, 581 insertions, 388 deletions
diff --git a/sound/core/control.c b/sound/core/control.c
index 281b2e2ef0ea..3c5e746d619b 100644
--- a/sound/core/control.c
+++ b/sound/core/control.c
@@ -139,7 +139,8 @@ void snd_ctl_notify(struct snd_card *card, unsigned int mask,
139 struct snd_ctl_file *ctl; 139 struct snd_ctl_file *ctl;
140 struct snd_kctl_event *ev; 140 struct snd_kctl_event *ev;
141 141
142 snd_assert(card != NULL && id != NULL, return); 142 if (snd_BUG_ON(!card || !id))
143 return;
143 read_lock(&card->ctl_files_rwlock); 144 read_lock(&card->ctl_files_rwlock);
144#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE) 145#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
145 card->mixer_oss_change_count++; 146 card->mixer_oss_change_count++;
@@ -188,8 +189,8 @@ static struct snd_kcontrol *snd_ctl_new(struct snd_kcontrol *control,
188 struct snd_kcontrol *kctl; 189 struct snd_kcontrol *kctl;
189 unsigned int idx; 190 unsigned int idx;
190 191
191 snd_assert(control != NULL, return NULL); 192 if (snd_BUG_ON(!control || !control->count))
192 snd_assert(control->count > 0, return NULL); 193 return NULL;
193 kctl = kzalloc(sizeof(*kctl) + sizeof(struct snd_kcontrol_volatile) * control->count, GFP_KERNEL); 194 kctl = kzalloc(sizeof(*kctl) + sizeof(struct snd_kcontrol_volatile) * control->count, GFP_KERNEL);
194 if (kctl == NULL) { 195 if (kctl == NULL) {
195 snd_printk(KERN_ERR "Cannot allocate control instance\n"); 196 snd_printk(KERN_ERR "Cannot allocate control instance\n");
@@ -218,8 +219,8 @@ struct snd_kcontrol *snd_ctl_new1(const struct snd_kcontrol_new *ncontrol,
218 struct snd_kcontrol kctl; 219 struct snd_kcontrol kctl;
219 unsigned int access; 220 unsigned int access;
220 221
221 snd_assert(ncontrol != NULL, return NULL); 222 if (snd_BUG_ON(!ncontrol || !ncontrol->info))
222 snd_assert(ncontrol->info != NULL, return NULL); 223 return NULL;
223 memset(&kctl, 0, sizeof(kctl)); 224 memset(&kctl, 0, sizeof(kctl));
224 kctl.id.iface = ncontrol->iface; 225 kctl.id.iface = ncontrol->iface;
225 kctl.id.device = ncontrol->device; 226 kctl.id.device = ncontrol->device;
@@ -315,8 +316,8 @@ int snd_ctl_add(struct snd_card *card, struct snd_kcontrol *kcontrol)
315 316
316 if (! kcontrol) 317 if (! kcontrol)
317 return err; 318 return err;
318 snd_assert(card != NULL, goto error); 319 if (snd_BUG_ON(!card || !kcontrol->info))
319 snd_assert(kcontrol->info != NULL, goto error); 320 goto error;
320 id = kcontrol->id; 321 id = kcontrol->id;
321 down_write(&card->controls_rwsem); 322 down_write(&card->controls_rwsem);
322 if (snd_ctl_find_id(card, &id)) { 323 if (snd_ctl_find_id(card, &id)) {
@@ -367,7 +368,8 @@ int snd_ctl_remove(struct snd_card *card, struct snd_kcontrol *kcontrol)
367 struct snd_ctl_elem_id id; 368 struct snd_ctl_elem_id id;
368 unsigned int idx; 369 unsigned int idx;
369 370
370 snd_assert(card != NULL && kcontrol != NULL, return -EINVAL); 371 if (snd_BUG_ON(!card || !kcontrol))
372 return -EINVAL;
371 list_del(&kcontrol->list); 373 list_del(&kcontrol->list);
372 card->controls_count -= kcontrol->count; 374 card->controls_count -= kcontrol->count;
373 id = kcontrol->id; 375 id = kcontrol->id;
@@ -487,7 +489,8 @@ struct snd_kcontrol *snd_ctl_find_numid(struct snd_card *card, unsigned int numi
487{ 489{
488 struct snd_kcontrol *kctl; 490 struct snd_kcontrol *kctl;
489 491
490 snd_assert(card != NULL && numid != 0, return NULL); 492 if (snd_BUG_ON(!card || !numid))
493 return NULL;
491 list_for_each_entry(kctl, &card->controls, list) { 494 list_for_each_entry(kctl, &card->controls, list) {
492 if (kctl->id.numid <= numid && kctl->id.numid + kctl->count > numid) 495 if (kctl->id.numid <= numid && kctl->id.numid + kctl->count > numid)
493 return kctl; 496 return kctl;
@@ -514,7 +517,8 @@ struct snd_kcontrol *snd_ctl_find_id(struct snd_card *card,
514{ 517{
515 struct snd_kcontrol *kctl; 518 struct snd_kcontrol *kctl;
516 519
517 snd_assert(card != NULL && id != NULL, return NULL); 520 if (snd_BUG_ON(!card || !id))
521 return NULL;
518 if (id->numid != 0) 522 if (id->numid != 0)
519 return snd_ctl_find_numid(card, id->numid); 523 return snd_ctl_find_numid(card, id->numid);
520 list_for_each_entry(kctl, &card->controls, list) { 524 list_for_each_entry(kctl, &card->controls, list) {
@@ -647,7 +651,7 @@ static int snd_ctl_elem_info(struct snd_ctl_file *ctl,
647#endif 651#endif
648 result = kctl->info(kctl, info); 652 result = kctl->info(kctl, info);
649 if (result >= 0) { 653 if (result >= 0) {
650 snd_assert(info->access == 0, ); 654 snd_BUG_ON(info->access);
651 index_offset = snd_ctl_get_ioff(kctl, &info->id); 655 index_offset = snd_ctl_get_ioff(kctl, &info->id);
652 vd = &kctl->vd[index_offset]; 656 vd = &kctl->vd[index_offset];
653 snd_ctl_build_ioff(&info->id, kctl, index_offset); 657 snd_ctl_build_ioff(&info->id, kctl, index_offset);
@@ -1160,7 +1164,8 @@ static long snd_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg
1160 1164
1161 ctl = file->private_data; 1165 ctl = file->private_data;
1162 card = ctl->card; 1166 card = ctl->card;
1163 snd_assert(card != NULL, return -ENXIO); 1167 if (snd_BUG_ON(!card))
1168 return -ENXIO;
1164 switch (cmd) { 1169 switch (cmd) {
1165 case SNDRV_CTL_IOCTL_PVERSION: 1170 case SNDRV_CTL_IOCTL_PVERSION:
1166 return put_user(SNDRV_CTL_VERSION, ip) ? -EFAULT : 0; 1171 return put_user(SNDRV_CTL_VERSION, ip) ? -EFAULT : 0;
@@ -1222,7 +1227,8 @@ static ssize_t snd_ctl_read(struct file *file, char __user *buffer,
1222 ssize_t result = 0; 1227 ssize_t result = 0;
1223 1228
1224 ctl = file->private_data; 1229 ctl = file->private_data;
1225 snd_assert(ctl != NULL && ctl->card != NULL, return -ENXIO); 1230 if (snd_BUG_ON(!ctl || !ctl->card))
1231 return -ENXIO;
1226 if (!ctl->subscribed) 1232 if (!ctl->subscribed)
1227 return -EBADFD; 1233 return -EBADFD;
1228 if (count < sizeof(struct snd_ctl_event)) 1234 if (count < sizeof(struct snd_ctl_event))
@@ -1328,7 +1334,8 @@ static int _snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn,
1328{ 1334{
1329 struct snd_kctl_ioctl *p; 1335 struct snd_kctl_ioctl *p;
1330 1336
1331 snd_assert(fcn != NULL, return -EINVAL); 1337 if (snd_BUG_ON(!fcn))
1338 return -EINVAL;
1332 down_write(&snd_ioctl_rwsem); 1339 down_write(&snd_ioctl_rwsem);
1333 list_for_each_entry(p, lists, list) { 1340 list_for_each_entry(p, lists, list) {
1334 if (p->fioctl == fcn) { 1341 if (p->fioctl == fcn) {
@@ -1404,9 +1411,11 @@ static int snd_ctl_dev_register(struct snd_device *device)
1404 int err, cardnum; 1411 int err, cardnum;
1405 char name[16]; 1412 char name[16];
1406 1413
1407 snd_assert(card != NULL, return -ENXIO); 1414 if (snd_BUG_ON(!card))
1415 return -ENXIO;
1408 cardnum = card->number; 1416 cardnum = card->number;
1409 snd_assert(cardnum >= 0 && cardnum < SNDRV_CARDS, return -ENXIO); 1417 if (snd_BUG_ON(cardnum < 0 || cardnum >= SNDRV_CARDS))
1418 return -ENXIO;
1410 sprintf(name, "controlC%i", cardnum); 1419 sprintf(name, "controlC%i", cardnum);
1411 if ((err = snd_register_device(SNDRV_DEVICE_TYPE_CONTROL, card, -1, 1420 if ((err = snd_register_device(SNDRV_DEVICE_TYPE_CONTROL, card, -1,
1412 &snd_ctl_f_ops, card, name)) < 0) 1421 &snd_ctl_f_ops, card, name)) < 0)
@@ -1423,9 +1432,11 @@ static int snd_ctl_dev_disconnect(struct snd_device *device)
1423 struct snd_ctl_file *ctl; 1432 struct snd_ctl_file *ctl;
1424 int err, cardnum; 1433 int err, cardnum;
1425 1434
1426 snd_assert(card != NULL, return -ENXIO); 1435 if (snd_BUG_ON(!card))
1436 return -ENXIO;
1427 cardnum = card->number; 1437 cardnum = card->number;
1428 snd_assert(cardnum >= 0 && cardnum < SNDRV_CARDS, return -ENXIO); 1438 if (snd_BUG_ON(cardnum < 0 || cardnum >= SNDRV_CARDS))
1439 return -ENXIO;
1429 1440
1430 down_read(&card->controls_rwsem); 1441 down_read(&card->controls_rwsem);
1431 list_for_each_entry(ctl, &card->ctl_files, list) { 1442 list_for_each_entry(ctl, &card->ctl_files, list) {
@@ -1469,7 +1480,8 @@ int snd_ctl_create(struct snd_card *card)
1469 .dev_disconnect = snd_ctl_dev_disconnect, 1480 .dev_disconnect = snd_ctl_dev_disconnect,
1470 }; 1481 };
1471 1482
1472 snd_assert(card != NULL, return -ENXIO); 1483 if (snd_BUG_ON(!card))
1484 return -ENXIO;
1473 return snd_device_new(card, SNDRV_DEV_CONTROL, card, &ops); 1485 return snd_device_new(card, SNDRV_DEV_CONTROL, card, &ops);
1474} 1486}
1475 1487
diff --git a/sound/core/control_compat.c b/sound/core/control_compat.c
index 6101259ad860..368dc9c4aef8 100644
--- a/sound/core/control_compat.c
+++ b/sound/core/control_compat.c
@@ -398,7 +398,8 @@ static inline long snd_ctl_ioctl_compat(struct file *file, unsigned int cmd, uns
398 int err; 398 int err;
399 399
400 ctl = file->private_data; 400 ctl = file->private_data;
401 snd_assert(ctl && ctl->card, return -ENXIO); 401 if (snd_BUG_ON(!ctl || !ctl->card))
402 return -ENXIO;
402 403
403 switch (cmd) { 404 switch (cmd) {
404 case SNDRV_CTL_IOCTL_PVERSION: 405 case SNDRV_CTL_IOCTL_PVERSION:
diff --git a/sound/core/device.c b/sound/core/device.c
index 202dac0e4d89..c58d8227254c 100644
--- a/sound/core/device.c
+++ b/sound/core/device.c
@@ -45,9 +45,8 @@ int snd_device_new(struct snd_card *card, snd_device_type_t type,
45{ 45{
46 struct snd_device *dev; 46 struct snd_device *dev;
47 47
48 snd_assert(card != NULL, return -ENXIO); 48 if (snd_BUG_ON(!card || !device_data || !ops))
49 snd_assert(device_data != NULL, return -ENXIO); 49 return -ENXIO;
50 snd_assert(ops != NULL, return -ENXIO);
51 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 50 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
52 if (dev == NULL) { 51 if (dev == NULL) {
53 snd_printk(KERN_ERR "Cannot allocate device\n"); 52 snd_printk(KERN_ERR "Cannot allocate device\n");
@@ -80,8 +79,8 @@ int snd_device_free(struct snd_card *card, void *device_data)
80{ 79{
81 struct snd_device *dev; 80 struct snd_device *dev;
82 81
83 snd_assert(card != NULL, return -ENXIO); 82 if (snd_BUG_ON(!card || !device_data))
84 snd_assert(device_data != NULL, return -ENXIO); 83 return -ENXIO;
85 list_for_each_entry(dev, &card->devices, list) { 84 list_for_each_entry(dev, &card->devices, list) {
86 if (dev->device_data != device_data) 85 if (dev->device_data != device_data)
87 continue; 86 continue;
@@ -123,8 +122,8 @@ int snd_device_disconnect(struct snd_card *card, void *device_data)
123{ 122{
124 struct snd_device *dev; 123 struct snd_device *dev;
125 124
126 snd_assert(card != NULL, return -ENXIO); 125 if (snd_BUG_ON(!card || !device_data))
127 snd_assert(device_data != NULL, return -ENXIO); 126 return -ENXIO;
128 list_for_each_entry(dev, &card->devices, list) { 127 list_for_each_entry(dev, &card->devices, list) {
129 if (dev->device_data != device_data) 128 if (dev->device_data != device_data)
130 continue; 129 continue;
@@ -159,8 +158,8 @@ int snd_device_register(struct snd_card *card, void *device_data)
159 struct snd_device *dev; 158 struct snd_device *dev;
160 int err; 159 int err;
161 160
162 snd_assert(card != NULL, return -ENXIO); 161 if (snd_BUG_ON(!card || !device_data))
163 snd_assert(device_data != NULL, return -ENXIO); 162 return -ENXIO;
164 list_for_each_entry(dev, &card->devices, list) { 163 list_for_each_entry(dev, &card->devices, list) {
165 if (dev->device_data != device_data) 164 if (dev->device_data != device_data)
166 continue; 165 continue;
@@ -188,7 +187,8 @@ int snd_device_register_all(struct snd_card *card)
188 struct snd_device *dev; 187 struct snd_device *dev;
189 int err; 188 int err;
190 189
191 snd_assert(card != NULL, return -ENXIO); 190 if (snd_BUG_ON(!card))
191 return -ENXIO;
192 list_for_each_entry(dev, &card->devices, list) { 192 list_for_each_entry(dev, &card->devices, list) {
193 if (dev->state == SNDRV_DEV_BUILD && dev->ops->dev_register) { 193 if (dev->state == SNDRV_DEV_BUILD && dev->ops->dev_register) {
194 if ((err = dev->ops->dev_register(dev)) < 0) 194 if ((err = dev->ops->dev_register(dev)) < 0)
@@ -208,7 +208,8 @@ int snd_device_disconnect_all(struct snd_card *card)
208 struct snd_device *dev; 208 struct snd_device *dev;
209 int err = 0; 209 int err = 0;
210 210
211 snd_assert(card != NULL, return -ENXIO); 211 if (snd_BUG_ON(!card))
212 return -ENXIO;
212 list_for_each_entry(dev, &card->devices, list) { 213 list_for_each_entry(dev, &card->devices, list) {
213 if (snd_device_disconnect(card, dev->device_data) < 0) 214 if (snd_device_disconnect(card, dev->device_data) < 0)
214 err = -ENXIO; 215 err = -ENXIO;
@@ -226,7 +227,8 @@ int snd_device_free_all(struct snd_card *card, snd_device_cmd_t cmd)
226 int err; 227 int err;
227 unsigned int range_low, range_high; 228 unsigned int range_low, range_high;
228 229
229 snd_assert(card != NULL, return -ENXIO); 230 if (snd_BUG_ON(!card))
231 return -ENXIO;
230 range_low = cmd * SNDRV_DEV_TYPE_RANGE_SIZE; 232 range_low = cmd * SNDRV_DEV_TYPE_RANGE_SIZE;
231 range_high = range_low + SNDRV_DEV_TYPE_RANGE_SIZE - 1; 233 range_high = range_low + SNDRV_DEV_TYPE_RANGE_SIZE - 1;
232 __again: 234 __again:
diff --git a/sound/core/hwdep.c b/sound/core/hwdep.c
index 6d6589f93899..195cafc5a553 100644
--- a/sound/core/hwdep.c
+++ b/sound/core/hwdep.c
@@ -353,9 +353,10 @@ int snd_hwdep_new(struct snd_card *card, char *id, int device,
353 .dev_disconnect = snd_hwdep_dev_disconnect, 353 .dev_disconnect = snd_hwdep_dev_disconnect,
354 }; 354 };
355 355
356 snd_assert(rhwdep != NULL, return -EINVAL); 356 if (snd_BUG_ON(!card))
357 *rhwdep = NULL; 357 return -ENXIO;
358 snd_assert(card != NULL, return -ENXIO); 358 if (rhwdep)
359 *rhwdep = NULL;
359 hwdep = kzalloc(sizeof(*hwdep), GFP_KERNEL); 360 hwdep = kzalloc(sizeof(*hwdep), GFP_KERNEL);
360 if (hwdep == NULL) { 361 if (hwdep == NULL) {
361 snd_printk(KERN_ERR "hwdep: cannot allocate\n"); 362 snd_printk(KERN_ERR "hwdep: cannot allocate\n");
@@ -374,13 +375,15 @@ int snd_hwdep_new(struct snd_card *card, char *id, int device,
374 } 375 }
375 init_waitqueue_head(&hwdep->open_wait); 376 init_waitqueue_head(&hwdep->open_wait);
376 mutex_init(&hwdep->open_mutex); 377 mutex_init(&hwdep->open_mutex);
377 *rhwdep = hwdep; 378 if (rhwdep)
379 *rhwdep = hwdep;
378 return 0; 380 return 0;
379} 381}
380 382
381static int snd_hwdep_free(struct snd_hwdep *hwdep) 383static int snd_hwdep_free(struct snd_hwdep *hwdep)
382{ 384{
383 snd_assert(hwdep != NULL, return -ENXIO); 385 if (!hwdep)
386 return 0;
384 if (hwdep->private_free) 387 if (hwdep->private_free)
385 hwdep->private_free(hwdep); 388 hwdep->private_free(hwdep);
386 kfree(hwdep); 389 kfree(hwdep);
@@ -440,7 +443,8 @@ static int snd_hwdep_dev_disconnect(struct snd_device *device)
440{ 443{
441 struct snd_hwdep *hwdep = device->device_data; 444 struct snd_hwdep *hwdep = device->device_data;
442 445
443 snd_assert(hwdep != NULL, return -ENXIO); 446 if (snd_BUG_ON(!hwdep))
447 return -ENXIO;
444 mutex_lock(&register_mutex); 448 mutex_lock(&register_mutex);
445 if (snd_hwdep_search(hwdep->card, hwdep->device) != hwdep) { 449 if (snd_hwdep_search(hwdep->card, hwdep->device) != hwdep) {
446 mutex_unlock(&register_mutex); 450 mutex_unlock(&register_mutex);
diff --git a/sound/core/info.c b/sound/core/info.c
index c67773ad9298..527b207462b0 100644
--- a/sound/core/info.c
+++ b/sound/core/info.c
@@ -217,7 +217,8 @@ static ssize_t snd_info_entry_read(struct file *file, char __user *buffer,
217 loff_t pos; 217 loff_t pos;
218 218
219 data = file->private_data; 219 data = file->private_data;
220 snd_assert(data != NULL, return -ENXIO); 220 if (snd_BUG_ON(!data))
221 return -ENXIO;
221 pos = *offset; 222 pos = *offset;
222 if (pos < 0 || (long) pos != pos || (ssize_t) count < 0) 223 if (pos < 0 || (long) pos != pos || (ssize_t) count < 0)
223 return -EIO; 224 return -EIO;
@@ -258,7 +259,8 @@ static ssize_t snd_info_entry_write(struct file *file, const char __user *buffer
258 loff_t pos; 259 loff_t pos;
259 260
260 data = file->private_data; 261 data = file->private_data;
261 snd_assert(data != NULL, return -ENXIO); 262 if (snd_BUG_ON(!data))
263 return -ENXIO;
262 entry = data->entry; 264 entry = data->entry;
263 pos = *offset; 265 pos = *offset;
264 if (pos < 0 || (long) pos != pos || (ssize_t) count < 0) 266 if (pos < 0 || (long) pos != pos || (ssize_t) count < 0)
@@ -614,7 +616,8 @@ int snd_info_card_create(struct snd_card *card)
614 char str[8]; 616 char str[8];
615 struct snd_info_entry *entry; 617 struct snd_info_entry *entry;
616 618
617 snd_assert(card != NULL, return -ENXIO); 619 if (snd_BUG_ON(!card))
620 return -ENXIO;
618 621
619 sprintf(str, "card%i", card->number); 622 sprintf(str, "card%i", card->number);
620 if ((entry = snd_info_create_module_entry(card->module, str, NULL)) == NULL) 623 if ((entry = snd_info_create_module_entry(card->module, str, NULL)) == NULL)
@@ -636,7 +639,8 @@ int snd_info_card_register(struct snd_card *card)
636{ 639{
637 struct proc_dir_entry *p; 640 struct proc_dir_entry *p;
638 641
639 snd_assert(card != NULL, return -ENXIO); 642 if (snd_BUG_ON(!card))
643 return -ENXIO;
640 644
641 if (!strcmp(card->id, card->proc_root->name)) 645 if (!strcmp(card->id, card->proc_root->name))
642 return 0; 646 return 0;
@@ -654,7 +658,8 @@ int snd_info_card_register(struct snd_card *card)
654 */ 658 */
655void snd_info_card_disconnect(struct snd_card *card) 659void snd_info_card_disconnect(struct snd_card *card)
656{ 660{
657 snd_assert(card != NULL, return); 661 if (!card)
662 return;
658 mutex_lock(&info_mutex); 663 mutex_lock(&info_mutex);
659 if (card->proc_root_link) { 664 if (card->proc_root_link) {
660 snd_remove_proc_entry(snd_proc_root, card->proc_root_link); 665 snd_remove_proc_entry(snd_proc_root, card->proc_root_link);
@@ -671,7 +676,8 @@ void snd_info_card_disconnect(struct snd_card *card)
671 */ 676 */
672int snd_info_card_free(struct snd_card *card) 677int snd_info_card_free(struct snd_card *card)
673{ 678{
674 snd_assert(card != NULL, return -ENXIO); 679 if (!card)
680 return 0;
675 snd_info_free_entry(card->proc_root); 681 snd_info_free_entry(card->proc_root);
676 card->proc_root = NULL; 682 card->proc_root = NULL;
677 return 0; 683 return 0;
@@ -849,7 +855,7 @@ static void snd_info_disconnect(struct snd_info_entry *entry)
849 return; 855 return;
850 list_del_init(&entry->list); 856 list_del_init(&entry->list);
851 root = entry->parent == NULL ? snd_proc_root : entry->parent->p; 857 root = entry->parent == NULL ? snd_proc_root : entry->parent->p;
852 snd_assert(root, return); 858 snd_BUG_ON(!root);
853 snd_remove_proc_entry(root, entry->p); 859 snd_remove_proc_entry(root, entry->p);
854 entry->p = NULL; 860 entry->p = NULL;
855} 861}
@@ -947,7 +953,8 @@ int snd_info_register(struct snd_info_entry * entry)
947{ 953{
948 struct proc_dir_entry *root, *p = NULL; 954 struct proc_dir_entry *root, *p = NULL;
949 955
950 snd_assert(entry != NULL, return -ENXIO); 956 if (snd_BUG_ON(!entry))
957 return -ENXIO;
951 root = entry->parent == NULL ? snd_proc_root : entry->parent->p; 958 root = entry->parent == NULL ? snd_proc_root : entry->parent->p;
952 mutex_lock(&info_mutex); 959 mutex_lock(&info_mutex);
953 p = snd_create_proc_entry(entry->name, entry->mode, root); 960 p = snd_create_proc_entry(entry->name, entry->mode, root);
diff --git a/sound/core/info_oss.c b/sound/core/info_oss.c
index e35789a92752..e4af138d651a 100644
--- a/sound/core/info_oss.c
+++ b/sound/core/info_oss.c
@@ -43,8 +43,10 @@ int snd_oss_info_register(int dev, int num, char *string)
43{ 43{
44 char *x; 44 char *x;
45 45
46 snd_assert(dev >= 0 && dev < SNDRV_OSS_INFO_DEV_COUNT, return -ENXIO); 46 if (snd_BUG_ON(dev < 0 || dev >= SNDRV_OSS_INFO_DEV_COUNT))
47 snd_assert(num >= 0 && num < SNDRV_CARDS, return -ENXIO); 47 return -ENXIO;
48 if (snd_BUG_ON(num < 0 || num >= SNDRV_CARDS))
49 return -ENXIO;
48 mutex_lock(&strings); 50 mutex_lock(&strings);
49 if (string == NULL) { 51 if (string == NULL) {
50 if ((x = snd_sndstat_strings[num][dev]) != NULL) { 52 if ((x = snd_sndstat_strings[num][dev]) != NULL) {
diff --git a/sound/core/init.c b/sound/core/init.c
index df46bbc25dc2..8af467df9245 100644
--- a/sound/core/init.c
+++ b/sound/core/init.c
@@ -545,7 +545,8 @@ int snd_card_register(struct snd_card *card)
545{ 545{
546 int err; 546 int err;
547 547
548 snd_assert(card != NULL, return -EINVAL); 548 if (snd_BUG_ON(!card))
549 return -EINVAL;
549#ifndef CONFIG_SYSFS_DEPRECATED 550#ifndef CONFIG_SYSFS_DEPRECATED
550 if (!card->card_dev) { 551 if (!card->card_dev) {
551 card->card_dev = device_create_drvdata(sound_class, card->dev, 552 card->card_dev = device_create_drvdata(sound_class, card->dev,
diff --git a/sound/core/memalloc.c b/sound/core/memalloc.c
index f5d6d8d12979..4a649976cc8a 100644
--- a/sound/core/memalloc.c
+++ b/sound/core/memalloc.c
@@ -67,18 +67,6 @@ struct snd_mem_list {
67/* id for pre-allocated buffers */ 67/* id for pre-allocated buffers */
68#define SNDRV_DMA_DEVICE_UNUSED (unsigned int)-1 68#define SNDRV_DMA_DEVICE_UNUSED (unsigned int)-1
69 69
70#ifdef CONFIG_SND_DEBUG
71#define __ASTRING__(x) #x
72#define snd_assert(expr, args...) do {\
73 if (!(expr)) {\
74 printk(KERN_ERR "snd-malloc: BUG? (%s) (called from %p)\n", __ASTRING__(expr), __builtin_return_address(0));\
75 args;\
76 }\
77} while (0)
78#else
79#define snd_assert(expr, args...) /**/
80#endif
81
82/* 70/*
83 * 71 *
84 * Generic memory allocators 72 * Generic memory allocators
@@ -111,8 +99,10 @@ void *snd_malloc_pages(size_t size, gfp_t gfp_flags)
111 int pg; 99 int pg;
112 void *res; 100 void *res;
113 101
114 snd_assert(size > 0, return NULL); 102 if (WARN_ON(!size))
115 snd_assert(gfp_flags != 0, return NULL); 103 return NULL;
104 if (WARN_ON(!gfp_flags))
105 return NULL;
116 gfp_flags |= __GFP_COMP; /* compound page lets parts be mapped */ 106 gfp_flags |= __GFP_COMP; /* compound page lets parts be mapped */
117 pg = get_order(size); 107 pg = get_order(size);
118 if ((res = (void *) __get_free_pages(gfp_flags, pg)) != NULL) 108 if ((res = (void *) __get_free_pages(gfp_flags, pg)) != NULL)
@@ -152,8 +142,8 @@ static void *snd_malloc_dev_pages(struct device *dev, size_t size, dma_addr_t *d
152 void *res; 142 void *res;
153 gfp_t gfp_flags; 143 gfp_t gfp_flags;
154 144
155 snd_assert(size > 0, return NULL); 145 if (WARN_ON(!dma))
156 snd_assert(dma != NULL, return NULL); 146 return NULL;
157 pg = get_order(size); 147 pg = get_order(size);
158 gfp_flags = GFP_KERNEL 148 gfp_flags = GFP_KERNEL
159 | __GFP_COMP /* compound page lets parts be mapped */ 149 | __GFP_COMP /* compound page lets parts be mapped */
@@ -189,8 +179,8 @@ static void *snd_malloc_sbus_pages(struct device *dev, size_t size,
189 int pg; 179 int pg;
190 void *res; 180 void *res;
191 181
192 snd_assert(size > 0, return NULL); 182 if (WARN_ON(!dma_addr))
193 snd_assert(dma_addr != NULL, return NULL); 183 return NULL;
194 pg = get_order(size); 184 pg = get_order(size);
195 res = sbus_alloc_consistent(sdev, PAGE_SIZE * (1 << pg), dma_addr); 185 res = sbus_alloc_consistent(sdev, PAGE_SIZE * (1 << pg), dma_addr);
196 if (res != NULL) 186 if (res != NULL)
@@ -236,8 +226,10 @@ static void snd_free_sbus_pages(struct device *dev, size_t size,
236int snd_dma_alloc_pages(int type, struct device *device, size_t size, 226int snd_dma_alloc_pages(int type, struct device *device, size_t size,
237 struct snd_dma_buffer *dmab) 227 struct snd_dma_buffer *dmab)
238{ 228{
239 snd_assert(size > 0, return -ENXIO); 229 if (WARN_ON(!size))
240 snd_assert(dmab != NULL, return -ENXIO); 230 return -ENXIO;
231 if (WARN_ON(!dmab))
232 return -ENXIO;
241 233
242 dmab->dev.type = type; 234 dmab->dev.type = type;
243 dmab->dev.dev = device; 235 dmab->dev.dev = device;
@@ -292,9 +284,6 @@ int snd_dma_alloc_pages_fallback(int type, struct device *device, size_t size,
292{ 284{
293 int err; 285 int err;
294 286
295 snd_assert(size > 0, return -ENXIO);
296 snd_assert(dmab != NULL, return -ENXIO);
297
298 while ((err = snd_dma_alloc_pages(type, device, size, dmab)) < 0) { 287 while ((err = snd_dma_alloc_pages(type, device, size, dmab)) < 0) {
299 if (err != -ENOMEM) 288 if (err != -ENOMEM)
300 return err; 289 return err;
@@ -353,7 +342,8 @@ size_t snd_dma_get_reserved_buf(struct snd_dma_buffer *dmab, unsigned int id)
353{ 342{
354 struct snd_mem_list *mem; 343 struct snd_mem_list *mem;
355 344
356 snd_assert(dmab, return 0); 345 if (WARN_ON(!dmab))
346 return 0;
357 347
358 mutex_lock(&list_mutex); 348 mutex_lock(&list_mutex);
359 list_for_each_entry(mem, &mem_list_head, list) { 349 list_for_each_entry(mem, &mem_list_head, list) {
@@ -387,7 +377,8 @@ int snd_dma_reserve_buf(struct snd_dma_buffer *dmab, unsigned int id)
387{ 377{
388 struct snd_mem_list *mem; 378 struct snd_mem_list *mem;
389 379
390 snd_assert(dmab, return -EINVAL); 380 if (WARN_ON(!dmab))
381 return -EINVAL;
391 mem = kmalloc(sizeof(*mem), GFP_KERNEL); 382 mem = kmalloc(sizeof(*mem), GFP_KERNEL);
392 if (! mem) 383 if (! mem)
393 return -ENOMEM; 384 return -ENOMEM;
diff --git a/sound/core/oss/copy.c b/sound/core/oss/copy.c
index 9ded30d0e97d..05b58d4fc2b7 100644
--- a/sound/core/oss/copy.c
+++ b/sound/core/oss/copy.c
@@ -32,17 +32,18 @@ static snd_pcm_sframes_t copy_transfer(struct snd_pcm_plugin *plugin,
32 unsigned int channel; 32 unsigned int channel;
33 unsigned int nchannels; 33 unsigned int nchannels;
34 34
35 snd_assert(plugin != NULL && src_channels != NULL && dst_channels != NULL, return -ENXIO); 35 if (snd_BUG_ON(!plugin || !src_channels || !dst_channels))
36 return -ENXIO;
36 if (frames == 0) 37 if (frames == 0)
37 return 0; 38 return 0;
38 nchannels = plugin->src_format.channels; 39 nchannels = plugin->src_format.channels;
39 for (channel = 0; channel < nchannels; channel++) { 40 for (channel = 0; channel < nchannels; channel++) {
40 snd_assert(src_channels->area.first % 8 == 0 && 41 if (snd_BUG_ON(src_channels->area.first % 8 ||
41 src_channels->area.step % 8 == 0, 42 src_channels->area.step % 8))
42 return -ENXIO); 43 return -ENXIO;
43 snd_assert(dst_channels->area.first % 8 == 0 && 44 if (snd_BUG_ON(dst_channels->area.first % 8 ||
44 dst_channels->area.step % 8 == 0, 45 dst_channels->area.step % 8))
45 return -ENXIO); 46 return -ENXIO;
46 if (!src_channels->enabled) { 47 if (!src_channels->enabled) {
47 if (dst_channels->wanted) 48 if (dst_channels->wanted)
48 snd_pcm_area_silence(&dst_channels->area, 0, frames, plugin->dst_format.format); 49 snd_pcm_area_silence(&dst_channels->area, 0, frames, plugin->dst_format.format);
@@ -66,15 +67,20 @@ int snd_pcm_plugin_build_copy(struct snd_pcm_substream *plug,
66 struct snd_pcm_plugin *plugin; 67 struct snd_pcm_plugin *plugin;
67 int width; 68 int width;
68 69
69 snd_assert(r_plugin != NULL, return -ENXIO); 70 if (snd_BUG_ON(!r_plugin))
71 return -ENXIO;
70 *r_plugin = NULL; 72 *r_plugin = NULL;
71 73
72 snd_assert(src_format->format == dst_format->format, return -ENXIO); 74 if (snd_BUG_ON(src_format->format != dst_format->format))
73 snd_assert(src_format->rate == dst_format->rate, return -ENXIO); 75 return -ENXIO;
74 snd_assert(src_format->channels == dst_format->channels, return -ENXIO); 76 if (snd_BUG_ON(src_format->rate != dst_format->rate))
77 return -ENXIO;
78 if (snd_BUG_ON(src_format->channels != dst_format->channels))
79 return -ENXIO;
75 80
76 width = snd_pcm_format_physical_width(src_format->format); 81 width = snd_pcm_format_physical_width(src_format->format);
77 snd_assert(width > 0, return -ENXIO); 82 if (snd_BUG_ON(width <= 0))
83 return -ENXIO;
78 84
79 err = snd_pcm_plugin_build(plug, "copy", src_format, dst_format, 85 err = snd_pcm_plugin_build(plug, "copy", src_format, dst_format,
80 0, &plugin); 86 0, &plugin);
diff --git a/sound/core/oss/io.c b/sound/core/oss/io.c
index f874f6ca3657..6faa1d719206 100644
--- a/sound/core/oss/io.c
+++ b/sound/core/oss/io.c
@@ -39,14 +39,17 @@ static snd_pcm_sframes_t io_playback_transfer(struct snd_pcm_plugin *plugin,
39 struct snd_pcm_plugin_channel *dst_channels, 39 struct snd_pcm_plugin_channel *dst_channels,
40 snd_pcm_uframes_t frames) 40 snd_pcm_uframes_t frames)
41{ 41{
42 snd_assert(plugin != NULL, return -ENXIO); 42 if (snd_BUG_ON(!plugin))
43 snd_assert(src_channels != NULL, return -ENXIO); 43 return -ENXIO;
44 if (snd_BUG_ON(!src_channels))
45 return -ENXIO;
44 if (plugin->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED) { 46 if (plugin->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED) {
45 return pcm_write(plugin->plug, src_channels->area.addr, frames); 47 return pcm_write(plugin->plug, src_channels->area.addr, frames);
46 } else { 48 } else {
47 int channel, channels = plugin->dst_format.channels; 49 int channel, channels = plugin->dst_format.channels;
48 void **bufs = (void**)plugin->extra_data; 50 void **bufs = (void**)plugin->extra_data;
49 snd_assert(bufs != NULL, return -ENXIO); 51 if (snd_BUG_ON(!bufs))
52 return -ENXIO;
50 for (channel = 0; channel < channels; channel++) { 53 for (channel = 0; channel < channels; channel++) {
51 if (src_channels[channel].enabled) 54 if (src_channels[channel].enabled)
52 bufs[channel] = src_channels[channel].area.addr; 55 bufs[channel] = src_channels[channel].area.addr;
@@ -62,14 +65,17 @@ static snd_pcm_sframes_t io_capture_transfer(struct snd_pcm_plugin *plugin,
62 struct snd_pcm_plugin_channel *dst_channels, 65 struct snd_pcm_plugin_channel *dst_channels,
63 snd_pcm_uframes_t frames) 66 snd_pcm_uframes_t frames)
64{ 67{
65 snd_assert(plugin != NULL, return -ENXIO); 68 if (snd_BUG_ON(!plugin))
66 snd_assert(dst_channels != NULL, return -ENXIO); 69 return -ENXIO;
70 if (snd_BUG_ON(!dst_channels))
71 return -ENXIO;
67 if (plugin->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED) { 72 if (plugin->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED) {
68 return pcm_read(plugin->plug, dst_channels->area.addr, frames); 73 return pcm_read(plugin->plug, dst_channels->area.addr, frames);
69 } else { 74 } else {
70 int channel, channels = plugin->dst_format.channels; 75 int channel, channels = plugin->dst_format.channels;
71 void **bufs = (void**)plugin->extra_data; 76 void **bufs = (void**)plugin->extra_data;
72 snd_assert(bufs != NULL, return -ENXIO); 77 if (snd_BUG_ON(!bufs))
78 return -ENXIO;
73 for (channel = 0; channel < channels; channel++) { 79 for (channel = 0; channel < channels; channel++) {
74 if (dst_channels[channel].enabled) 80 if (dst_channels[channel].enabled)
75 bufs[channel] = dst_channels[channel].area.addr; 81 bufs[channel] = dst_channels[channel].area.addr;
@@ -107,9 +113,11 @@ int snd_pcm_plugin_build_io(struct snd_pcm_substream *plug,
107 struct snd_pcm_plugin_format format; 113 struct snd_pcm_plugin_format format;
108 struct snd_pcm_plugin *plugin; 114 struct snd_pcm_plugin *plugin;
109 115
110 snd_assert(r_plugin != NULL, return -ENXIO); 116 if (snd_BUG_ON(!r_plugin))
117 return -ENXIO;
111 *r_plugin = NULL; 118 *r_plugin = NULL;
112 snd_assert(plug != NULL && params != NULL, return -ENXIO); 119 if (snd_BUG_ON(!plug || !params))
120 return -ENXIO;
113 format.format = params_format(params); 121 format.format = params_format(params);
114 format.rate = params_rate(params); 122 format.rate = params_rate(params);
115 format.channels = params_channels(params); 123 format.channels = params_channels(params);
diff --git a/sound/core/oss/linear.c b/sound/core/oss/linear.c
index da3dbd41669e..4c1d16827199 100644
--- a/sound/core/oss/linear.c
+++ b/sound/core/oss/linear.c
@@ -92,7 +92,8 @@ static snd_pcm_sframes_t linear_transfer(struct snd_pcm_plugin *plugin,
92{ 92{
93 struct linear_priv *data; 93 struct linear_priv *data;
94 94
95 snd_assert(plugin != NULL && src_channels != NULL && dst_channels != NULL, return -ENXIO); 95 if (snd_BUG_ON(!plugin || !src_channels || !dst_channels))
96 return -ENXIO;
96 data = (struct linear_priv *)plugin->extra_data; 97 data = (struct linear_priv *)plugin->extra_data;
97 if (frames == 0) 98 if (frames == 0)
98 return 0; 99 return 0;
@@ -100,12 +101,12 @@ static snd_pcm_sframes_t linear_transfer(struct snd_pcm_plugin *plugin,
100 { 101 {
101 unsigned int channel; 102 unsigned int channel;
102 for (channel = 0; channel < plugin->src_format.channels; channel++) { 103 for (channel = 0; channel < plugin->src_format.channels; channel++) {
103 snd_assert(src_channels[channel].area.first % 8 == 0 && 104 if (snd_BUG_ON(src_channels[channel].area.first % 8 ||
104 src_channels[channel].area.step % 8 == 0, 105 src_channels[channel].area.step % 8))
105 return -ENXIO); 106 return -ENXIO;
106 snd_assert(dst_channels[channel].area.first % 8 == 0 && 107 if (snd_BUG_ON(dst_channels[channel].area.first % 8 ||
107 dst_channels[channel].area.step % 8 == 0, 108 dst_channels[channel].area.step % 8))
108 return -ENXIO); 109 return -ENXIO;
109 } 110 }
110 } 111 }
111#endif 112#endif
@@ -154,13 +155,17 @@ int snd_pcm_plugin_build_linear(struct snd_pcm_substream *plug,
154 struct linear_priv *data; 155 struct linear_priv *data;
155 struct snd_pcm_plugin *plugin; 156 struct snd_pcm_plugin *plugin;
156 157
157 snd_assert(r_plugin != NULL, return -ENXIO); 158 if (snd_BUG_ON(!r_plugin))
159 return -ENXIO;
158 *r_plugin = NULL; 160 *r_plugin = NULL;
159 161
160 snd_assert(src_format->rate == dst_format->rate, return -ENXIO); 162 if (snd_BUG_ON(src_format->rate != dst_format->rate))
161 snd_assert(src_format->channels == dst_format->channels, return -ENXIO); 163 return -ENXIO;
162 snd_assert(snd_pcm_format_linear(src_format->format) && 164 if (snd_BUG_ON(src_format->channels != dst_format->channels))
163 snd_pcm_format_linear(dst_format->format), return -ENXIO); 165 return -ENXIO;
166 if (snd_BUG_ON(!snd_pcm_format_linear(src_format->format) ||
167 !snd_pcm_format_linear(dst_format->format)))
168 return -ENXIO;
164 169
165 err = snd_pcm_plugin_build(plug, "linear format conversion", 170 err = snd_pcm_plugin_build(plug, "linear format conversion",
166 src_format, dst_format, 171 src_format, dst_format,
diff --git a/sound/core/oss/mixer_oss.c b/sound/core/oss/mixer_oss.c
index 581aa2c60e65..4690b8b5681f 100644
--- a/sound/core/oss/mixer_oss.c
+++ b/sound/core/oss/mixer_oss.c
@@ -257,8 +257,10 @@ static int snd_mixer_oss_get_volume(struct snd_mixer_oss_file *fmixer, int slot)
257 result = pslot->get_volume(fmixer, pslot, &left, &right); 257 result = pslot->get_volume(fmixer, pslot, &left, &right);
258 if (!pslot->stereo) 258 if (!pslot->stereo)
259 right = left; 259 right = left;
260 snd_assert(left >= 0 && left <= 100, return -EIO); 260 if (snd_BUG_ON(left < 0 || left > 100))
261 snd_assert(right >= 0 && right <= 100, return -EIO); 261 return -EIO;
262 if (snd_BUG_ON(right < 0 || right > 100))
263 return -EIO;
262 if (result >= 0) { 264 if (result >= 0) {
263 pslot->volume[0] = left; 265 pslot->volume[0] = left;
264 pslot->volume[1] = right; 266 pslot->volume[1] = right;
@@ -298,7 +300,8 @@ static int snd_mixer_oss_ioctl1(struct snd_mixer_oss_file *fmixer, unsigned int
298 int __user *p = argp; 300 int __user *p = argp;
299 int tmp; 301 int tmp;
300 302
301 snd_assert(fmixer != NULL, return -ENXIO); 303 if (snd_BUG_ON(!fmixer))
304 return -ENXIO;
302 if (((cmd >> 8) & 0xff) == 'M') { 305 if (((cmd >> 8) & 0xff) == 'M') {
303 switch (cmd) { 306 switch (cmd) {
304 case SOUND_MIXER_INFO: 307 case SOUND_MIXER_INFO:
@@ -368,7 +371,8 @@ int snd_mixer_oss_ioctl_card(struct snd_card *card, unsigned int cmd, unsigned l
368{ 371{
369 struct snd_mixer_oss_file fmixer; 372 struct snd_mixer_oss_file fmixer;
370 373
371 snd_assert(card != NULL, return -ENXIO); 374 if (snd_BUG_ON(!card))
375 return -ENXIO;
372 if (card->mixer_oss == NULL) 376 if (card->mixer_oss == NULL)
373 return -ENXIO; 377 return -ENXIO;
374 memset(&fmixer, 0, sizeof(fmixer)); 378 memset(&fmixer, 0, sizeof(fmixer));
@@ -1284,9 +1288,11 @@ static int snd_mixer_oss_free1(void *private)
1284 struct snd_card *card; 1288 struct snd_card *card;
1285 int idx; 1289 int idx;
1286 1290
1287 snd_assert(mixer != NULL, return -ENXIO); 1291 if (!mixer)
1292 return 0;
1288 card = mixer->card; 1293 card = mixer->card;
1289 snd_assert(mixer == card->mixer_oss, return -ENXIO); 1294 if (snd_BUG_ON(mixer != card->mixer_oss))
1295 return -ENXIO;
1290 card->mixer_oss = NULL; 1296 card->mixer_oss = NULL;
1291 for (idx = 0; idx < SNDRV_OSS_MAX_MIXERS; idx++) { 1297 for (idx = 0; idx < SNDRV_OSS_MAX_MIXERS; idx++) {
1292 struct snd_mixer_oss_slot *chn = &mixer->slots[idx]; 1298 struct snd_mixer_oss_slot *chn = &mixer->slots[idx];
diff --git a/sound/core/oss/mulaw.c b/sound/core/oss/mulaw.c
index 77f96194a0ed..f7649d4d950b 100644
--- a/sound/core/oss/mulaw.c
+++ b/sound/core/oss/mulaw.c
@@ -252,19 +252,20 @@ static snd_pcm_sframes_t mulaw_transfer(struct snd_pcm_plugin *plugin,
252{ 252{
253 struct mulaw_priv *data; 253 struct mulaw_priv *data;
254 254
255 snd_assert(plugin != NULL && src_channels != NULL && dst_channels != NULL, return -ENXIO); 255 if (snd_BUG_ON(!plugin || !src_channels || !dst_channels))
256 return -ENXIO;
256 if (frames == 0) 257 if (frames == 0)
257 return 0; 258 return 0;
258#ifdef CONFIG_SND_DEBUG 259#ifdef CONFIG_SND_DEBUG
259 { 260 {
260 unsigned int channel; 261 unsigned int channel;
261 for (channel = 0; channel < plugin->src_format.channels; channel++) { 262 for (channel = 0; channel < plugin->src_format.channels; channel++) {
262 snd_assert(src_channels[channel].area.first % 8 == 0 && 263 if (snd_BUG_ON(src_channels[channel].area.first % 8 ||
263 src_channels[channel].area.step % 8 == 0, 264 src_channels[channel].area.step % 8))
264 return -ENXIO); 265 return -ENXIO;
265 snd_assert(dst_channels[channel].area.first % 8 == 0 && 266 if (snd_BUG_ON(dst_channels[channel].area.first % 8 ||
266 dst_channels[channel].area.step % 8 == 0, 267 dst_channels[channel].area.step % 8))
267 return -ENXIO); 268 return -ENXIO;
268 } 269 }
269 } 270 }
270#endif 271#endif
@@ -305,11 +306,14 @@ int snd_pcm_plugin_build_mulaw(struct snd_pcm_substream *plug,
305 struct snd_pcm_plugin_format *format; 306 struct snd_pcm_plugin_format *format;
306 mulaw_f func; 307 mulaw_f func;
307 308
308 snd_assert(r_plugin != NULL, return -ENXIO); 309 if (snd_BUG_ON(!r_plugin))
310 return -ENXIO;
309 *r_plugin = NULL; 311 *r_plugin = NULL;
310 312
311 snd_assert(src_format->rate == dst_format->rate, return -ENXIO); 313 if (snd_BUG_ON(src_format->rate != dst_format->rate))
312 snd_assert(src_format->channels == dst_format->channels, return -ENXIO); 314 return -ENXIO;
315 if (snd_BUG_ON(src_format->channels != dst_format->channels))
316 return -ENXIO;
313 317
314 if (dst_format->format == SNDRV_PCM_FORMAT_MU_LAW) { 318 if (dst_format->format == SNDRV_PCM_FORMAT_MU_LAW) {
315 format = src_format; 319 format = src_format;
@@ -323,7 +327,8 @@ int snd_pcm_plugin_build_mulaw(struct snd_pcm_substream *plug,
323 snd_BUG(); 327 snd_BUG();
324 return -EINVAL; 328 return -EINVAL;
325 } 329 }
326 snd_assert(snd_pcm_format_linear(format->format) != 0, return -ENXIO); 330 if (snd_BUG_ON(!snd_pcm_format_linear(format->format)))
331 return -ENXIO;
327 332
328 err = snd_pcm_plugin_build(plug, "Mu-Law<->linear conversion", 333 err = snd_pcm_plugin_build(plug, "Mu-Law<->linear conversion",
329 src_format, dst_format, 334 src_format, dst_format,
diff --git a/sound/core/oss/pcm_oss.c b/sound/core/oss/pcm_oss.c
index 4c601b192ddf..1af62b8b86c6 100644
--- a/sound/core/oss/pcm_oss.c
+++ b/sound/core/oss/pcm_oss.c
@@ -452,7 +452,8 @@ static int snd_pcm_hw_param_near(struct snd_pcm_substream *pcm,
452 } else { 452 } else {
453 *params = *save; 453 *params = *save;
454 max = snd_pcm_hw_param_max(pcm, params, var, max, &maxdir); 454 max = snd_pcm_hw_param_max(pcm, params, var, max, &maxdir);
455 snd_assert(max >= 0, return -EINVAL); 455 if (max < 0)
456 return max;
456 last = 1; 457 last = 1;
457 } 458 }
458 _end: 459 _end:
@@ -461,7 +462,7 @@ static int snd_pcm_hw_param_near(struct snd_pcm_substream *pcm,
461 v = snd_pcm_hw_param_last(pcm, params, var, dir); 462 v = snd_pcm_hw_param_last(pcm, params, var, dir);
462 else 463 else
463 v = snd_pcm_hw_param_first(pcm, params, var, dir); 464 v = snd_pcm_hw_param_first(pcm, params, var, dir);
464 snd_assert(v >= 0, return -EINVAL); 465 snd_BUG_ON(v < 0);
465 return v; 466 return v;
466} 467}
467 468
@@ -778,7 +779,8 @@ static int snd_pcm_oss_period_size(struct snd_pcm_substream *substream,
778 while (oss_period_size * oss_periods > oss_buffer_size) 779 while (oss_period_size * oss_periods > oss_buffer_size)
779 oss_period_size /= 2; 780 oss_period_size /= 2;
780 781
781 snd_assert(oss_period_size >= 16, return -EINVAL); 782 if (oss_period_size < 16)
783 return -EINVAL;
782 runtime->oss.period_bytes = oss_period_size; 784 runtime->oss.period_bytes = oss_period_size;
783 runtime->oss.period_frames = 1; 785 runtime->oss.period_frames = 1;
784 runtime->oss.periods = oss_periods; 786 runtime->oss.periods = oss_periods;
@@ -895,7 +897,8 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
895 } 897 }
896 } 898 }
897 err = _snd_pcm_hw_param_set(sparams, SNDRV_PCM_HW_PARAM_FORMAT, sformat, 0); 899 err = _snd_pcm_hw_param_set(sparams, SNDRV_PCM_HW_PARAM_FORMAT, sformat, 0);
898 snd_assert(err >= 0, goto failure); 900 if (err < 0)
901 goto failure;
899 902
900 if (direct) { 903 if (direct) {
901 memcpy(params, sparams, sizeof(*params)); 904 memcpy(params, sparams, sizeof(*params));
@@ -958,11 +961,13 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
958 961
959 n = snd_pcm_plug_slave_size(substream, runtime->oss.period_bytes / oss_frame_size); 962 n = snd_pcm_plug_slave_size(substream, runtime->oss.period_bytes / oss_frame_size);
960 err = snd_pcm_hw_param_near(substream, sparams, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, n, NULL); 963 err = snd_pcm_hw_param_near(substream, sparams, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, n, NULL);
961 snd_assert(err >= 0, goto failure); 964 if (err < 0)
965 goto failure;
962 966
963 err = snd_pcm_hw_param_near(substream, sparams, SNDRV_PCM_HW_PARAM_PERIODS, 967 err = snd_pcm_hw_param_near(substream, sparams, SNDRV_PCM_HW_PARAM_PERIODS,
964 runtime->oss.periods, NULL); 968 runtime->oss.periods, NULL);
965 snd_assert(err >= 0, goto failure); 969 if (err < 0)
970 goto failure;
966 971
967 snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL); 972 snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL);
968 973
@@ -1006,7 +1011,10 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
1006 1011
1007 runtime->oss.periods = params_periods(sparams); 1012 runtime->oss.periods = params_periods(sparams);
1008 oss_period_size = snd_pcm_plug_client_size(substream, params_period_size(sparams)); 1013 oss_period_size = snd_pcm_plug_client_size(substream, params_period_size(sparams));
1009 snd_assert(oss_period_size >= 0, err = -EINVAL; goto failure); 1014 if (oss_period_size < 0) {
1015 err = -EINVAL;
1016 goto failure;
1017 }
1010#ifdef CONFIG_SND_PCM_OSS_PLUGINS 1018#ifdef CONFIG_SND_PCM_OSS_PLUGINS
1011 if (runtime->oss.plugin_first) { 1019 if (runtime->oss.plugin_first) {
1012 err = snd_pcm_plug_alloc(substream, oss_period_size); 1020 err = snd_pcm_plug_alloc(substream, oss_period_size);
@@ -1017,7 +1025,10 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
1017 oss_period_size *= oss_frame_size; 1025 oss_period_size *= oss_frame_size;
1018 1026
1019 oss_buffer_size = oss_period_size * runtime->oss.periods; 1027 oss_buffer_size = oss_period_size * runtime->oss.periods;
1020 snd_assert(oss_buffer_size >= 0, err = -EINVAL; goto failure); 1028 if (oss_buffer_size < 0) {
1029 err = -EINVAL;
1030 goto failure;
1031 }
1021 1032
1022 runtime->oss.period_bytes = oss_period_size; 1033 runtime->oss.period_bytes = oss_period_size;
1023 runtime->oss.buffer_bytes = oss_buffer_size; 1034 runtime->oss.buffer_bytes = oss_buffer_size;
@@ -1069,7 +1080,8 @@ static int snd_pcm_oss_get_active_substream(struct snd_pcm_oss_file *pcm_oss_fil
1069 return err; 1080 return err;
1070 } 1081 }
1071 } 1082 }
1072 snd_assert(asubstream != NULL, return -EIO); 1083 if (!asubstream)
1084 return -EIO;
1073 if (r_substream) 1085 if (r_substream)
1074 *r_substream = asubstream; 1086 *r_substream = asubstream;
1075 return 0; 1087 return 0;
@@ -1764,7 +1776,8 @@ static int snd_pcm_oss_get_formats(struct snd_pcm_oss_file *pcm_oss_file)
1764 err = snd_pcm_hw_refine(substream, params); 1776 err = snd_pcm_hw_refine(substream, params);
1765 format_mask = *hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); 1777 format_mask = *hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
1766 kfree(params); 1778 kfree(params);
1767 snd_assert(err >= 0, return err); 1779 if (err < 0)
1780 return err;
1768 for (fmt = 0; fmt < 32; ++fmt) { 1781 for (fmt = 0; fmt < 32; ++fmt) {
1769 if (snd_mask_test(&format_mask, fmt)) { 1782 if (snd_mask_test(&format_mask, fmt)) {
1770 int f = snd_pcm_oss_format_to(fmt); 1783 int f = snd_pcm_oss_format_to(fmt);
@@ -2250,7 +2263,8 @@ static void snd_pcm_oss_init_substream(struct snd_pcm_substream *substream,
2250static int snd_pcm_oss_release_file(struct snd_pcm_oss_file *pcm_oss_file) 2263static int snd_pcm_oss_release_file(struct snd_pcm_oss_file *pcm_oss_file)
2251{ 2264{
2252 int cidx; 2265 int cidx;
2253 snd_assert(pcm_oss_file != NULL, return -ENXIO); 2266 if (!pcm_oss_file)
2267 return 0;
2254 for (cidx = 0; cidx < 2; ++cidx) { 2268 for (cidx = 0; cidx < 2; ++cidx) {
2255 struct snd_pcm_substream *substream = pcm_oss_file->streams[cidx]; 2269 struct snd_pcm_substream *substream = pcm_oss_file->streams[cidx];
2256 if (substream) 2270 if (substream)
@@ -2271,8 +2285,8 @@ static int snd_pcm_oss_open_file(struct file *file,
2271 struct snd_pcm_substream *substream; 2285 struct snd_pcm_substream *substream;
2272 unsigned int f_mode = file->f_mode; 2286 unsigned int f_mode = file->f_mode;
2273 2287
2274 snd_assert(rpcm_oss_file != NULL, return -EINVAL); 2288 if (rpcm_oss_file)
2275 *rpcm_oss_file = NULL; 2289 *rpcm_oss_file = NULL;
2276 2290
2277 pcm_oss_file = kzalloc(sizeof(*pcm_oss_file), GFP_KERNEL); 2291 pcm_oss_file = kzalloc(sizeof(*pcm_oss_file), GFP_KERNEL);
2278 if (pcm_oss_file == NULL) 2292 if (pcm_oss_file == NULL)
@@ -2312,7 +2326,8 @@ static int snd_pcm_oss_open_file(struct file *file,
2312 } 2326 }
2313 2327
2314 file->private_data = pcm_oss_file; 2328 file->private_data = pcm_oss_file;
2315 *rpcm_oss_file = pcm_oss_file; 2329 if (rpcm_oss_file)
2330 *rpcm_oss_file = pcm_oss_file;
2316 return 0; 2331 return 0;
2317} 2332}
2318 2333
@@ -2321,7 +2336,8 @@ static int snd_task_name(struct task_struct *task, char *name, size_t size)
2321{ 2336{
2322 unsigned int idx; 2337 unsigned int idx;
2323 2338
2324 snd_assert(task != NULL && name != NULL && size >= 2, return -EINVAL); 2339 if (snd_BUG_ON(!task || !name || size < 2))
2340 return -EINVAL;
2325 for (idx = 0; idx < sizeof(task->comm) && idx + 1 < size; idx++) 2341 for (idx = 0; idx < sizeof(task->comm) && idx + 1 < size; idx++)
2326 name[idx] = task->comm[idx]; 2342 name[idx] = task->comm[idx];
2327 name[idx] = '\0'; 2343 name[idx] = '\0';
@@ -2415,7 +2431,8 @@ static int snd_pcm_oss_release(struct inode *inode, struct file *file)
2415 substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK]; 2431 substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
2416 if (substream == NULL) 2432 if (substream == NULL)
2417 substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE]; 2433 substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE];
2418 snd_assert(substream != NULL, return -ENXIO); 2434 if (snd_BUG_ON(!substream))
2435 return -ENXIO;
2419 pcm = substream->pcm; 2436 pcm = substream->pcm;
2420 if (!pcm->card->shutdown) 2437 if (!pcm->card->shutdown)
2421 snd_pcm_oss_sync(pcm_oss_file); 2438 snd_pcm_oss_sync(pcm_oss_file);
@@ -2448,7 +2465,8 @@ static long snd_pcm_oss_ioctl(struct file *file, unsigned int cmd, unsigned long
2448 if (substream != NULL) 2465 if (substream != NULL)
2449 break; 2466 break;
2450 } 2467 }
2451 snd_assert(substream != NULL, return -ENXIO); 2468 if (snd_BUG_ON(idx >= 2))
2469 return -ENXIO;
2452 return snd_mixer_oss_ioctl_card(substream->pcm->card, cmd, arg); 2470 return snd_mixer_oss_ioctl_card(substream->pcm->card, cmd, arg);
2453 } 2471 }
2454#endif 2472#endif
diff --git a/sound/core/oss/pcm_plugin.c b/sound/core/oss/pcm_plugin.c
index bec94138205e..6751daa3bb50 100644
--- a/sound/core/oss/pcm_plugin.c
+++ b/sound/core/oss/pcm_plugin.c
@@ -62,7 +62,8 @@ static int snd_pcm_plugin_alloc(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t
62 if ((width = snd_pcm_format_physical_width(format->format)) < 0) 62 if ((width = snd_pcm_format_physical_width(format->format)) < 0)
63 return width; 63 return width;
64 size = frames * format->channels * width; 64 size = frames * format->channels * width;
65 snd_assert((size % 8) == 0, return -ENXIO); 65 if (snd_BUG_ON(size % 8))
66 return -ENXIO;
66 size /= 8; 67 size /= 8;
67 if (plugin->buf_frames < frames) { 68 if (plugin->buf_frames < frames) {
68 vfree(plugin->buf); 69 vfree(plugin->buf);
@@ -84,7 +85,8 @@ static int snd_pcm_plugin_alloc(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t
84 c->area.step = format->channels * width; 85 c->area.step = format->channels * width;
85 } 86 }
86 } else if (plugin->access == SNDRV_PCM_ACCESS_RW_NONINTERLEAVED) { 87 } else if (plugin->access == SNDRV_PCM_ACCESS_RW_NONINTERLEAVED) {
87 snd_assert((size % format->channels) == 0,); 88 if (snd_BUG_ON(size % format->channels))
89 return -EINVAL;
88 size /= format->channels; 90 size /= format->channels;
89 for (channel = 0; channel < format->channels; channel++, c++) { 91 for (channel = 0; channel < format->channels; channel++, c++) {
90 c->frames = frames; 92 c->frames = frames;
@@ -102,13 +104,15 @@ static int snd_pcm_plugin_alloc(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t
102int snd_pcm_plug_alloc(struct snd_pcm_substream *plug, snd_pcm_uframes_t frames) 104int snd_pcm_plug_alloc(struct snd_pcm_substream *plug, snd_pcm_uframes_t frames)
103{ 105{
104 int err; 106 int err;
105 snd_assert(snd_pcm_plug_first(plug) != NULL, return -ENXIO); 107 if (snd_BUG_ON(!snd_pcm_plug_first(plug)))
108 return -ENXIO;
106 if (snd_pcm_plug_stream(plug) == SNDRV_PCM_STREAM_PLAYBACK) { 109 if (snd_pcm_plug_stream(plug) == SNDRV_PCM_STREAM_PLAYBACK) {
107 struct snd_pcm_plugin *plugin = snd_pcm_plug_first(plug); 110 struct snd_pcm_plugin *plugin = snd_pcm_plug_first(plug);
108 while (plugin->next) { 111 while (plugin->next) {
109 if (plugin->dst_frames) 112 if (plugin->dst_frames)
110 frames = plugin->dst_frames(plugin, frames); 113 frames = plugin->dst_frames(plugin, frames);
111 snd_assert(frames > 0, return -ENXIO); 114 if (snd_BUG_ON(frames <= 0))
115 return -ENXIO;
112 plugin = plugin->next; 116 plugin = plugin->next;
113 err = snd_pcm_plugin_alloc(plugin, frames); 117 err = snd_pcm_plugin_alloc(plugin, frames);
114 if (err < 0) 118 if (err < 0)
@@ -119,7 +123,8 @@ int snd_pcm_plug_alloc(struct snd_pcm_substream *plug, snd_pcm_uframes_t frames)
119 while (plugin->prev) { 123 while (plugin->prev) {
120 if (plugin->src_frames) 124 if (plugin->src_frames)
121 frames = plugin->src_frames(plugin, frames); 125 frames = plugin->src_frames(plugin, frames);
122 snd_assert(frames > 0, return -ENXIO); 126 if (snd_BUG_ON(frames <= 0))
127 return -ENXIO;
123 plugin = plugin->prev; 128 plugin = plugin->prev;
124 err = snd_pcm_plugin_alloc(plugin, frames); 129 err = snd_pcm_plugin_alloc(plugin, frames);
125 if (err < 0) 130 if (err < 0)
@@ -148,8 +153,10 @@ int snd_pcm_plugin_build(struct snd_pcm_substream *plug,
148 struct snd_pcm_plugin *plugin; 153 struct snd_pcm_plugin *plugin;
149 unsigned int channels; 154 unsigned int channels;
150 155
151 snd_assert(plug != NULL, return -ENXIO); 156 if (snd_BUG_ON(!plug))
152 snd_assert(src_format != NULL && dst_format != NULL, return -ENXIO); 157 return -ENXIO;
158 if (snd_BUG_ON(!src_format || !dst_format))
159 return -ENXIO;
153 plugin = kzalloc(sizeof(*plugin) + extra, GFP_KERNEL); 160 plugin = kzalloc(sizeof(*plugin) + extra, GFP_KERNEL);
154 if (plugin == NULL) 161 if (plugin == NULL)
155 return -ENOMEM; 162 return -ENOMEM;
@@ -159,10 +166,10 @@ int snd_pcm_plugin_build(struct snd_pcm_substream *plug,
159 plugin->access = SNDRV_PCM_ACCESS_RW_INTERLEAVED; 166 plugin->access = SNDRV_PCM_ACCESS_RW_INTERLEAVED;
160 plugin->src_format = *src_format; 167 plugin->src_format = *src_format;
161 plugin->src_width = snd_pcm_format_physical_width(src_format->format); 168 plugin->src_width = snd_pcm_format_physical_width(src_format->format);
162 snd_assert(plugin->src_width > 0, ); 169 snd_BUG_ON(plugin->src_width <= 0);
163 plugin->dst_format = *dst_format; 170 plugin->dst_format = *dst_format;
164 plugin->dst_width = snd_pcm_format_physical_width(dst_format->format); 171 plugin->dst_width = snd_pcm_format_physical_width(dst_format->format);
165 snd_assert(plugin->dst_width > 0, ); 172 snd_BUG_ON(plugin->dst_width <= 0);
166 if (plugin->stream == SNDRV_PCM_STREAM_PLAYBACK) 173 if (plugin->stream == SNDRV_PCM_STREAM_PLAYBACK)
167 channels = src_format->channels; 174 channels = src_format->channels;
168 else 175 else
@@ -194,7 +201,8 @@ snd_pcm_sframes_t snd_pcm_plug_client_size(struct snd_pcm_substream *plug, snd_p
194 struct snd_pcm_plugin *plugin, *plugin_prev, *plugin_next; 201 struct snd_pcm_plugin *plugin, *plugin_prev, *plugin_next;
195 int stream = snd_pcm_plug_stream(plug); 202 int stream = snd_pcm_plug_stream(plug);
196 203
197 snd_assert(plug != NULL, return -ENXIO); 204 if (snd_BUG_ON(!plug))
205 return -ENXIO;
198 if (drv_frames == 0) 206 if (drv_frames == 0)
199 return 0; 207 return 0;
200 if (stream == SNDRV_PCM_STREAM_PLAYBACK) { 208 if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
@@ -224,7 +232,8 @@ snd_pcm_sframes_t snd_pcm_plug_slave_size(struct snd_pcm_substream *plug, snd_pc
224 snd_pcm_sframes_t frames; 232 snd_pcm_sframes_t frames;
225 int stream = snd_pcm_plug_stream(plug); 233 int stream = snd_pcm_plug_stream(plug);
226 234
227 snd_assert(plug != NULL, return -ENXIO); 235 if (snd_BUG_ON(!plug))
236 return -ENXIO;
228 if (clt_frames == 0) 237 if (clt_frames == 0)
229 return 0; 238 return 0;
230 frames = clt_frames; 239 frames = clt_frames;
@@ -540,7 +549,8 @@ snd_pcm_sframes_t snd_pcm_plug_client_channels_buf(struct snd_pcm_substream *plu
540 int width, nchannels, channel; 549 int width, nchannels, channel;
541 int stream = snd_pcm_plug_stream(plug); 550 int stream = snd_pcm_plug_stream(plug);
542 551
543 snd_assert(buf != NULL, return -ENXIO); 552 if (snd_BUG_ON(!buf))
553 return -ENXIO;
544 if (stream == SNDRV_PCM_STREAM_PLAYBACK) { 554 if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
545 plugin = snd_pcm_plug_first(plug); 555 plugin = snd_pcm_plug_first(plug);
546 format = &plugin->src_format; 556 format = &plugin->src_format;
@@ -553,7 +563,9 @@ snd_pcm_sframes_t snd_pcm_plug_client_channels_buf(struct snd_pcm_substream *plu
553 if ((width = snd_pcm_format_physical_width(format->format)) < 0) 563 if ((width = snd_pcm_format_physical_width(format->format)) < 0)
554 return width; 564 return width;
555 nchannels = format->channels; 565 nchannels = format->channels;
556 snd_assert(plugin->access == SNDRV_PCM_ACCESS_RW_INTERLEAVED || format->channels <= 1, return -ENXIO); 566 if (snd_BUG_ON(plugin->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED &&
567 format->channels > 1))
568 return -ENXIO;
557 for (channel = 0; channel < nchannels; channel++, v++) { 569 for (channel = 0; channel < nchannels; channel++, v++) {
558 v->frames = count; 570 v->frames = count;
559 v->enabled = 1; 571 v->enabled = 1;
diff --git a/sound/core/oss/rate.c b/sound/core/oss/rate.c
index 14dfb3175d84..a466443c4a26 100644
--- a/sound/core/oss/rate.c
+++ b/sound/core/oss/rate.c
@@ -185,7 +185,8 @@ static snd_pcm_sframes_t rate_src_frames(struct snd_pcm_plugin *plugin, snd_pcm_
185 struct rate_priv *data; 185 struct rate_priv *data;
186 snd_pcm_sframes_t res; 186 snd_pcm_sframes_t res;
187 187
188 snd_assert(plugin != NULL, return -ENXIO); 188 if (snd_BUG_ON(!plugin))
189 return -ENXIO;
189 if (frames == 0) 190 if (frames == 0)
190 return 0; 191 return 0;
191 data = (struct rate_priv *)plugin->extra_data; 192 data = (struct rate_priv *)plugin->extra_data;
@@ -217,7 +218,8 @@ static snd_pcm_sframes_t rate_dst_frames(struct snd_pcm_plugin *plugin, snd_pcm_
217 struct rate_priv *data; 218 struct rate_priv *data;
218 snd_pcm_sframes_t res; 219 snd_pcm_sframes_t res;
219 220
220 snd_assert(plugin != NULL, return -ENXIO); 221 if (snd_BUG_ON(!plugin))
222 return -ENXIO;
221 if (frames == 0) 223 if (frames == 0)
222 return 0; 224 return 0;
223 data = (struct rate_priv *)plugin->extra_data; 225 data = (struct rate_priv *)plugin->extra_data;
@@ -252,19 +254,20 @@ static snd_pcm_sframes_t rate_transfer(struct snd_pcm_plugin *plugin,
252 snd_pcm_uframes_t dst_frames; 254 snd_pcm_uframes_t dst_frames;
253 struct rate_priv *data; 255 struct rate_priv *data;
254 256
255 snd_assert(plugin != NULL && src_channels != NULL && dst_channels != NULL, return -ENXIO); 257 if (snd_BUG_ON(!plugin || !src_channels || !dst_channels))
258 return -ENXIO;
256 if (frames == 0) 259 if (frames == 0)
257 return 0; 260 return 0;
258#ifdef CONFIG_SND_DEBUG 261#ifdef CONFIG_SND_DEBUG
259 { 262 {
260 unsigned int channel; 263 unsigned int channel;
261 for (channel = 0; channel < plugin->src_format.channels; channel++) { 264 for (channel = 0; channel < plugin->src_format.channels; channel++) {
262 snd_assert(src_channels[channel].area.first % 8 == 0 && 265 if (snd_BUG_ON(src_channels[channel].area.first % 8 ||
263 src_channels[channel].area.step % 8 == 0, 266 src_channels[channel].area.step % 8))
264 return -ENXIO); 267 return -ENXIO;
265 snd_assert(dst_channels[channel].area.first % 8 == 0 && 268 if (snd_BUG_ON(dst_channels[channel].area.first % 8 ||
266 dst_channels[channel].area.step % 8 == 0, 269 dst_channels[channel].area.step % 8))
267 return -ENXIO); 270 return -ENXIO;
268 } 271 }
269 } 272 }
270#endif 273#endif
@@ -281,7 +284,8 @@ static int rate_action(struct snd_pcm_plugin *plugin,
281 enum snd_pcm_plugin_action action, 284 enum snd_pcm_plugin_action action,
282 unsigned long udata) 285 unsigned long udata)
283{ 286{
284 snd_assert(plugin != NULL, return -ENXIO); 287 if (snd_BUG_ON(!plugin))
288 return -ENXIO;
285 switch (action) { 289 switch (action) {
286 case INIT: 290 case INIT:
287 case PREPARE: 291 case PREPARE:
@@ -302,14 +306,20 @@ int snd_pcm_plugin_build_rate(struct snd_pcm_substream *plug,
302 struct rate_priv *data; 306 struct rate_priv *data;
303 struct snd_pcm_plugin *plugin; 307 struct snd_pcm_plugin *plugin;
304 308
305 snd_assert(r_plugin != NULL, return -ENXIO); 309 if (snd_BUG_ON(!r_plugin))
310 return -ENXIO;
306 *r_plugin = NULL; 311 *r_plugin = NULL;
307 312
308 snd_assert(src_format->channels == dst_format->channels, return -ENXIO); 313 if (snd_BUG_ON(src_format->channels != dst_format->channels))
309 snd_assert(src_format->channels > 0, return -ENXIO); 314 return -ENXIO;
310 snd_assert(src_format->format == SNDRV_PCM_FORMAT_S16, return -ENXIO); 315 if (snd_BUG_ON(src_format->channels <= 0))
311 snd_assert(dst_format->format == SNDRV_PCM_FORMAT_S16, return -ENXIO); 316 return -ENXIO;
312 snd_assert(src_format->rate != dst_format->rate, return -ENXIO); 317 if (snd_BUG_ON(src_format->format != SNDRV_PCM_FORMAT_S16))
318 return -ENXIO;
319 if (snd_BUG_ON(dst_format->format != SNDRV_PCM_FORMAT_S16))
320 return -ENXIO;
321 if (snd_BUG_ON(src_format->rate == dst_format->rate))
322 return -ENXIO;
313 323
314 err = snd_pcm_plugin_build(plug, "rate conversion", 324 err = snd_pcm_plugin_build(plug, "rate conversion",
315 src_format, dst_format, 325 src_format, dst_format,
diff --git a/sound/core/oss/route.c b/sound/core/oss/route.c
index da7ab7a3e82c..0dcc2870d537 100644
--- a/sound/core/oss/route.c
+++ b/sound/core/oss/route.c
@@ -54,7 +54,8 @@ static snd_pcm_sframes_t route_transfer(struct snd_pcm_plugin *plugin,
54 struct snd_pcm_plugin_channel *dvp; 54 struct snd_pcm_plugin_channel *dvp;
55 int format; 55 int format;
56 56
57 snd_assert(plugin != NULL && src_channels != NULL && dst_channels != NULL, return -ENXIO); 57 if (snd_BUG_ON(!plugin || !src_channels || !dst_channels))
58 return -ENXIO;
58 if (frames == 0) 59 if (frames == 0)
59 return 0; 60 return 0;
60 61
@@ -90,10 +91,13 @@ int snd_pcm_plugin_build_route(struct snd_pcm_substream *plug,
90 struct snd_pcm_plugin *plugin; 91 struct snd_pcm_plugin *plugin;
91 int err; 92 int err;
92 93
93 snd_assert(r_plugin != NULL, return -ENXIO); 94 if (snd_BUG_ON(!r_plugin))
95 return -ENXIO;
94 *r_plugin = NULL; 96 *r_plugin = NULL;
95 snd_assert(src_format->rate == dst_format->rate, return -ENXIO); 97 if (snd_BUG_ON(src_format->rate != dst_format->rate))
96 snd_assert(src_format->format == dst_format->format, return -ENXIO); 98 return -ENXIO;
99 if (snd_BUG_ON(src_format->format != dst_format->format))
100 return -ENXIO;
97 101
98 err = snd_pcm_plugin_build(plug, "route conversion", 102 err = snd_pcm_plugin_build(plug, "route conversion",
99 src_format, dst_format, 0, &plugin); 103 src_format, dst_format, 0, &plugin);
diff --git a/sound/core/pcm.c b/sound/core/pcm.c
index 517388b2eba9..192a433a2403 100644
--- a/sound/core/pcm.c
+++ b/sound/core/pcm.c
@@ -256,7 +256,6 @@ static char *snd_pcm_tstamp_mode_names[] = {
256 256
257static const char *snd_pcm_stream_name(int stream) 257static const char *snd_pcm_stream_name(int stream)
258{ 258{
259 snd_assert(stream <= SNDRV_PCM_STREAM_LAST, return NULL);
260 return snd_pcm_stream_names[stream]; 259 return snd_pcm_stream_names[stream];
261} 260}
262 261
@@ -272,7 +271,6 @@ static const char *snd_pcm_subformat_name(snd_pcm_subformat_t subformat)
272 271
273static const char *snd_pcm_tstamp_mode_name(int mode) 272static const char *snd_pcm_tstamp_mode_name(int mode)
274{ 273{
275 snd_assert(mode <= SNDRV_PCM_TSTAMP_LAST, return NULL);
276 return snd_pcm_tstamp_mode_names[mode]; 274 return snd_pcm_tstamp_mode_names[mode];
277} 275}
278 276
@@ -706,9 +704,10 @@ int snd_pcm_new(struct snd_card *card, char *id, int device,
706 .dev_disconnect = snd_pcm_dev_disconnect, 704 .dev_disconnect = snd_pcm_dev_disconnect,
707 }; 705 };
708 706
709 snd_assert(rpcm != NULL, return -EINVAL); 707 if (snd_BUG_ON(!card))
710 *rpcm = NULL; 708 return -ENXIO;
711 snd_assert(card != NULL, return -ENXIO); 709 if (rpcm)
710 *rpcm = NULL;
712 pcm = kzalloc(sizeof(*pcm), GFP_KERNEL); 711 pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);
713 if (pcm == NULL) { 712 if (pcm == NULL) {
714 snd_printk(KERN_ERR "Cannot allocate PCM\n"); 713 snd_printk(KERN_ERR "Cannot allocate PCM\n");
@@ -732,7 +731,8 @@ int snd_pcm_new(struct snd_card *card, char *id, int device,
732 snd_pcm_free(pcm); 731 snd_pcm_free(pcm);
733 return err; 732 return err;
734 } 733 }
735 *rpcm = pcm; 734 if (rpcm)
735 *rpcm = pcm;
736 return 0; 736 return 0;
737} 737}
738 738
@@ -766,7 +766,8 @@ static int snd_pcm_free(struct snd_pcm *pcm)
766{ 766{
767 struct snd_pcm_notify *notify; 767 struct snd_pcm_notify *notify;
768 768
769 snd_assert(pcm != NULL, return -ENXIO); 769 if (!pcm)
770 return 0;
770 list_for_each_entry(notify, &snd_pcm_notify_list, list) { 771 list_for_each_entry(notify, &snd_pcm_notify_list, list) {
771 notify->n_unregister(pcm); 772 notify->n_unregister(pcm);
772 } 773 }
@@ -797,9 +798,9 @@ int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream,
797 int prefer_subdevice = -1; 798 int prefer_subdevice = -1;
798 size_t size; 799 size_t size;
799 800
800 snd_assert(rsubstream != NULL, return -EINVAL); 801 if (snd_BUG_ON(!pcm || !rsubstream))
802 return -ENXIO;
801 *rsubstream = NULL; 803 *rsubstream = NULL;
802 snd_assert(pcm != NULL, return -ENXIO);
803 pstr = &pcm->streams[stream]; 804 pstr = &pcm->streams[stream];
804 if (pstr->substream == NULL || pstr->substream_count == 0) 805 if (pstr->substream == NULL || pstr->substream_count == 0)
805 return -ENODEV; 806 return -ENODEV;
@@ -907,8 +908,9 @@ void snd_pcm_detach_substream(struct snd_pcm_substream *substream)
907{ 908{
908 struct snd_pcm_runtime *runtime; 909 struct snd_pcm_runtime *runtime;
909 910
911 if (PCM_RUNTIME_CHECK(substream))
912 return;
910 runtime = substream->runtime; 913 runtime = substream->runtime;
911 snd_assert(runtime != NULL, return);
912 if (runtime->private_free != NULL) 914 if (runtime->private_free != NULL)
913 runtime->private_free(runtime); 915 runtime->private_free(runtime);
914 snd_free_pages((void*)runtime->status, 916 snd_free_pages((void*)runtime->status,
@@ -953,7 +955,8 @@ static int snd_pcm_dev_register(struct snd_device *device)
953 struct snd_pcm *pcm = device->device_data; 955 struct snd_pcm *pcm = device->device_data;
954 struct device *dev; 956 struct device *dev;
955 957
956 snd_assert(pcm != NULL && device != NULL, return -ENXIO); 958 if (snd_BUG_ON(!pcm || !device))
959 return -ENXIO;
957 mutex_lock(&register_mutex); 960 mutex_lock(&register_mutex);
958 err = snd_pcm_add(pcm); 961 err = snd_pcm_add(pcm);
959 if (err) { 962 if (err) {
@@ -1043,10 +1046,11 @@ int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree)
1043{ 1046{
1044 struct snd_pcm *pcm; 1047 struct snd_pcm *pcm;
1045 1048
1046 snd_assert(notify != NULL && 1049 if (snd_BUG_ON(!notify ||
1047 notify->n_register != NULL && 1050 !notify->n_register ||
1048 notify->n_unregister != NULL && 1051 !notify->n_unregister ||
1049 notify->n_disconnect, return -EINVAL); 1052 !notify->n_disconnect))
1053 return -EINVAL;
1050 mutex_lock(&register_mutex); 1054 mutex_lock(&register_mutex);
1051 if (nfree) { 1055 if (nfree) {
1052 list_del(&notify->list); 1056 list_del(&notify->list);
diff --git a/sound/core/pcm_compat.c b/sound/core/pcm_compat.c
index 49aa693fba8a..36d7a5998234 100644
--- a/sound/core/pcm_compat.c
+++ b/sound/core/pcm_compat.c
@@ -397,7 +397,8 @@ static int snd_pcm_ioctl_sync_ptr_compat(struct snd_pcm_substream *substream,
397 snd_pcm_uframes_t boundary; 397 snd_pcm_uframes_t boundary;
398 int err; 398 int err;
399 399
400 snd_assert(runtime, return -EINVAL); 400 if (snd_BUG_ON(!runtime))
401 return -EINVAL;
401 402
402 if (get_user(sflags, &src->flags) || 403 if (get_user(sflags, &src->flags) ||
403 get_user(scontrol.appl_ptr, &src->c.control.appl_ptr) || 404 get_user(scontrol.appl_ptr, &src->c.control.appl_ptr) ||
diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c
index 1533f0379e9d..6ea5cfb83998 100644
--- a/sound/core/pcm_lib.c
+++ b/sound/core/pcm_lib.c
@@ -85,7 +85,8 @@ void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_ufram
85 } 85 }
86 frames = runtime->buffer_size - runtime->silence_filled; 86 frames = runtime->buffer_size - runtime->silence_filled;
87 } 87 }
88 snd_assert(frames <= runtime->buffer_size, return); 88 if (snd_BUG_ON(frames > runtime->buffer_size))
89 return;
89 if (frames == 0) 90 if (frames == 0)
90 return; 91 return;
91 ofs = runtime->silence_start % runtime->buffer_size; 92 ofs = runtime->silence_start % runtime->buffer_size;
@@ -96,7 +97,7 @@ void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_ufram
96 if (substream->ops->silence) { 97 if (substream->ops->silence) {
97 int err; 98 int err;
98 err = substream->ops->silence(substream, -1, ofs, transfer); 99 err = substream->ops->silence(substream, -1, ofs, transfer);
99 snd_assert(err >= 0, ); 100 snd_BUG_ON(err < 0);
100 } else { 101 } else {
101 char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, ofs); 102 char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, ofs);
102 snd_pcm_format_set_silence(runtime->format, hwbuf, transfer * runtime->channels); 103 snd_pcm_format_set_silence(runtime->format, hwbuf, transfer * runtime->channels);
@@ -108,7 +109,7 @@ void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_ufram
108 for (c = 0; c < channels; ++c) { 109 for (c = 0; c < channels; ++c) {
109 int err; 110 int err;
110 err = substream->ops->silence(substream, c, ofs, transfer); 111 err = substream->ops->silence(substream, c, ofs, transfer);
111 snd_assert(err >= 0, ); 112 snd_BUG_ON(err < 0);
112 } 113 }
113 } else { 114 } else {
114 size_t dma_csize = runtime->dma_bytes / channels; 115 size_t dma_csize = runtime->dma_bytes / channels;
@@ -354,7 +355,7 @@ static inline unsigned int muldiv32(unsigned int a, unsigned int b,
354{ 355{
355 u_int64_t n = (u_int64_t) a * b; 356 u_int64_t n = (u_int64_t) a * b;
356 if (c == 0) { 357 if (c == 0) {
357 snd_assert(n > 0, ); 358 snd_BUG_ON(!n);
358 *r = 0; 359 *r = 0;
359 return UINT_MAX; 360 return UINT_MAX;
360 } 361 }
@@ -380,7 +381,8 @@ static inline unsigned int muldiv32(unsigned int a, unsigned int b,
380int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v) 381int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v)
381{ 382{
382 int changed = 0; 383 int changed = 0;
383 snd_assert(!snd_interval_empty(i), return -EINVAL); 384 if (snd_BUG_ON(snd_interval_empty(i)))
385 return -EINVAL;
384 if (i->min < v->min) { 386 if (i->min < v->min) {
385 i->min = v->min; 387 i->min = v->min;
386 i->openmin = v->openmin; 388 i->openmin = v->openmin;
@@ -423,7 +425,8 @@ EXPORT_SYMBOL(snd_interval_refine);
423 425
424static int snd_interval_refine_first(struct snd_interval *i) 426static int snd_interval_refine_first(struct snd_interval *i)
425{ 427{
426 snd_assert(!snd_interval_empty(i), return -EINVAL); 428 if (snd_BUG_ON(snd_interval_empty(i)))
429 return -EINVAL;
427 if (snd_interval_single(i)) 430 if (snd_interval_single(i))
428 return 0; 431 return 0;
429 i->max = i->min; 432 i->max = i->min;
@@ -435,7 +438,8 @@ static int snd_interval_refine_first(struct snd_interval *i)
435 438
436static int snd_interval_refine_last(struct snd_interval *i) 439static int snd_interval_refine_last(struct snd_interval *i)
437{ 440{
438 snd_assert(!snd_interval_empty(i), return -EINVAL); 441 if (snd_BUG_ON(snd_interval_empty(i)))
442 return -EINVAL;
439 if (snd_interval_single(i)) 443 if (snd_interval_single(i))
440 return 0; 444 return 0;
441 i->min = i->max; 445 i->min = i->max;
@@ -889,7 +893,8 @@ int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond,
889 c->private = private; 893 c->private = private;
890 k = 0; 894 k = 0;
891 while (1) { 895 while (1) {
892 snd_assert(k < ARRAY_SIZE(c->deps), return -EINVAL); 896 if (snd_BUG_ON(k >= ARRAY_SIZE(c->deps)))
897 return -EINVAL;
893 c->deps[k++] = dep; 898 c->deps[k++] = dep;
894 if (dep < 0) 899 if (dep < 0)
895 break; 900 break;
@@ -1285,7 +1290,8 @@ int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm,
1285 return changed; 1290 return changed;
1286 if (params->rmask) { 1291 if (params->rmask) {
1287 int err = snd_pcm_hw_refine(pcm, params); 1292 int err = snd_pcm_hw_refine(pcm, params);
1288 snd_assert(err >= 0, return err); 1293 if (snd_BUG_ON(err < 0))
1294 return err;
1289 } 1295 }
1290 return snd_pcm_hw_param_value(params, var, dir); 1296 return snd_pcm_hw_param_value(params, var, dir);
1291} 1297}
@@ -1330,7 +1336,8 @@ int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm,
1330 return changed; 1336 return changed;
1331 if (params->rmask) { 1337 if (params->rmask) {
1332 int err = snd_pcm_hw_refine(pcm, params); 1338 int err = snd_pcm_hw_refine(pcm, params);
1333 snd_assert(err >= 0, return err); 1339 if (snd_BUG_ON(err < 0))
1340 return err;
1334 } 1341 }
1335 return snd_pcm_hw_param_value(params, var, dir); 1342 return snd_pcm_hw_param_value(params, var, dir);
1336} 1343}
@@ -1368,7 +1375,8 @@ int snd_pcm_hw_params_choose(struct snd_pcm_substream *pcm,
1368 err = snd_pcm_hw_param_first(pcm, params, *v, NULL); 1375 err = snd_pcm_hw_param_first(pcm, params, *v, NULL);
1369 else 1376 else
1370 err = snd_pcm_hw_param_last(pcm, params, *v, NULL); 1377 err = snd_pcm_hw_param_last(pcm, params, *v, NULL);
1371 snd_assert(err >= 0, return err); 1378 if (snd_BUG_ON(err < 0))
1379 return err;
1372 } 1380 }
1373 return 0; 1381 return 0;
1374} 1382}
@@ -1466,9 +1474,9 @@ void snd_pcm_period_elapsed(struct snd_pcm_substream *substream)
1466 struct snd_pcm_runtime *runtime; 1474 struct snd_pcm_runtime *runtime;
1467 unsigned long flags; 1475 unsigned long flags;
1468 1476
1469 snd_assert(substream != NULL, return); 1477 if (PCM_RUNTIME_CHECK(substream))
1478 return;
1470 runtime = substream->runtime; 1479 runtime = substream->runtime;
1471 snd_assert(runtime != NULL, return);
1472 1480
1473 if (runtime->transfer_ack_begin) 1481 if (runtime->transfer_ack_begin)
1474 runtime->transfer_ack_begin(substream); 1482 runtime->transfer_ack_begin(substream);
@@ -1567,7 +1575,6 @@ static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream,
1567 return err; 1575 return err;
1568 } else { 1576 } else {
1569 char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff); 1577 char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff);
1570 snd_assert(runtime->dma_area, return -EFAULT);
1571 if (copy_from_user(hwbuf, buf, frames_to_bytes(runtime, frames))) 1578 if (copy_from_user(hwbuf, buf, frames_to_bytes(runtime, frames)))
1572 return -EFAULT; 1579 return -EFAULT;
1573 } 1580 }
@@ -1629,7 +1636,10 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream,
1629 cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size; 1636 cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;
1630 if (frames > cont) 1637 if (frames > cont)
1631 frames = cont; 1638 frames = cont;
1632 snd_assert(frames != 0, snd_pcm_stream_unlock_irq(substream); return -EINVAL); 1639 if (snd_BUG_ON(!frames)) {
1640 snd_pcm_stream_unlock_irq(substream);
1641 return -EINVAL;
1642 }
1633 appl_ptr = runtime->control->appl_ptr; 1643 appl_ptr = runtime->control->appl_ptr;
1634 appl_ofs = appl_ptr % runtime->buffer_size; 1644 appl_ofs = appl_ptr % runtime->buffer_size;
1635 snd_pcm_stream_unlock_irq(substream); 1645 snd_pcm_stream_unlock_irq(substream);
@@ -1669,18 +1679,30 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream,
1669 return xfer > 0 ? (snd_pcm_sframes_t)xfer : err; 1679 return xfer > 0 ? (snd_pcm_sframes_t)xfer : err;
1670} 1680}
1671 1681
1672snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const void __user *buf, snd_pcm_uframes_t size) 1682/* sanity-check for read/write methods */
1683static int pcm_sanity_check(struct snd_pcm_substream *substream)
1673{ 1684{
1674 struct snd_pcm_runtime *runtime; 1685 struct snd_pcm_runtime *runtime;
1675 int nonblock; 1686 if (PCM_RUNTIME_CHECK(substream))
1676 1687 return -ENXIO;
1677 snd_assert(substream != NULL, return -ENXIO);
1678 runtime = substream->runtime; 1688 runtime = substream->runtime;
1679 snd_assert(runtime != NULL, return -ENXIO); 1689 if (snd_BUG_ON(!substream->ops->copy && !runtime->dma_area))
1680 snd_assert(substream->ops->copy != NULL || runtime->dma_area != NULL, return -EINVAL); 1690 return -EINVAL;
1681 if (runtime->status->state == SNDRV_PCM_STATE_OPEN) 1691 if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
1682 return -EBADFD; 1692 return -EBADFD;
1693 return 0;
1694}
1695
1696snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const void __user *buf, snd_pcm_uframes_t size)
1697{
1698 struct snd_pcm_runtime *runtime;
1699 int nonblock;
1700 int err;
1683 1701
1702 err = pcm_sanity_check(substream);
1703 if (err < 0)
1704 return err;
1705 runtime = substream->runtime;
1684 nonblock = !!(substream->f_flags & O_NONBLOCK); 1706 nonblock = !!(substream->f_flags & O_NONBLOCK);
1685 1707
1686 if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED && 1708 if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED &&
@@ -1703,7 +1725,8 @@ static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream,
1703 int channels = runtime->channels; 1725 int channels = runtime->channels;
1704 int c; 1726 int c;
1705 if (substream->ops->copy) { 1727 if (substream->ops->copy) {
1706 snd_assert(substream->ops->silence != NULL, return -EINVAL); 1728 if (snd_BUG_ON(!substream->ops->silence))
1729 return -EINVAL;
1707 for (c = 0; c < channels; ++c, ++bufs) { 1730 for (c = 0; c < channels; ++c, ++bufs) {
1708 if (*bufs == NULL) { 1731 if (*bufs == NULL) {
1709 if ((err = substream->ops->silence(substream, c, hwoff, frames)) < 0) 1732 if ((err = substream->ops->silence(substream, c, hwoff, frames)) < 0)
@@ -1717,7 +1740,6 @@ static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream,
1717 } else { 1740 } else {
1718 /* default transfer behaviour */ 1741 /* default transfer behaviour */
1719 size_t dma_csize = runtime->dma_bytes / channels; 1742 size_t dma_csize = runtime->dma_bytes / channels;
1720 snd_assert(runtime->dma_area, return -EFAULT);
1721 for (c = 0; c < channels; ++c, ++bufs) { 1743 for (c = 0; c < channels; ++c, ++bufs) {
1722 char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff); 1744 char *hwbuf = runtime->dma_area + (c * dma_csize) + samples_to_bytes(runtime, hwoff);
1723 if (*bufs == NULL) { 1745 if (*bufs == NULL) {
@@ -1738,14 +1760,12 @@ snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream,
1738{ 1760{
1739 struct snd_pcm_runtime *runtime; 1761 struct snd_pcm_runtime *runtime;
1740 int nonblock; 1762 int nonblock;
1763 int err;
1741 1764
1742 snd_assert(substream != NULL, return -ENXIO); 1765 err = pcm_sanity_check(substream);
1766 if (err < 0)
1767 return err;
1743 runtime = substream->runtime; 1768 runtime = substream->runtime;
1744 snd_assert(runtime != NULL, return -ENXIO);
1745 snd_assert(substream->ops->copy != NULL || runtime->dma_area != NULL, return -EINVAL);
1746 if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
1747 return -EBADFD;
1748
1749 nonblock = !!(substream->f_flags & O_NONBLOCK); 1769 nonblock = !!(substream->f_flags & O_NONBLOCK);
1750 1770
1751 if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED) 1771 if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
@@ -1769,7 +1789,6 @@ static int snd_pcm_lib_read_transfer(struct snd_pcm_substream *substream,
1769 return err; 1789 return err;
1770 } else { 1790 } else {
1771 char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff); 1791 char *hwbuf = runtime->dma_area + frames_to_bytes(runtime, hwoff);
1772 snd_assert(runtime->dma_area, return -EFAULT);
1773 if (copy_to_user(buf, hwbuf, frames_to_bytes(runtime, frames))) 1792 if (copy_to_user(buf, hwbuf, frames_to_bytes(runtime, frames)))
1774 return -EFAULT; 1793 return -EFAULT;
1775 } 1794 }
@@ -1841,7 +1860,10 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,
1841 cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size; 1860 cont = runtime->buffer_size - runtime->control->appl_ptr % runtime->buffer_size;
1842 if (frames > cont) 1861 if (frames > cont)
1843 frames = cont; 1862 frames = cont;
1844 snd_assert(frames != 0, snd_pcm_stream_unlock_irq(substream); return -EINVAL); 1863 if (snd_BUG_ON(!frames)) {
1864 snd_pcm_stream_unlock_irq(substream);
1865 return -EINVAL;
1866 }
1845 appl_ptr = runtime->control->appl_ptr; 1867 appl_ptr = runtime->control->appl_ptr;
1846 appl_ofs = appl_ptr % runtime->buffer_size; 1868 appl_ofs = appl_ptr % runtime->buffer_size;
1847 snd_pcm_stream_unlock_irq(substream); 1869 snd_pcm_stream_unlock_irq(substream);
@@ -1879,14 +1901,12 @@ snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, void __u
1879{ 1901{
1880 struct snd_pcm_runtime *runtime; 1902 struct snd_pcm_runtime *runtime;
1881 int nonblock; 1903 int nonblock;
1904 int err;
1882 1905
1883 snd_assert(substream != NULL, return -ENXIO); 1906 err = pcm_sanity_check(substream);
1907 if (err < 0)
1908 return err;
1884 runtime = substream->runtime; 1909 runtime = substream->runtime;
1885 snd_assert(runtime != NULL, return -ENXIO);
1886 snd_assert(substream->ops->copy != NULL || runtime->dma_area != NULL, return -EINVAL);
1887 if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
1888 return -EBADFD;
1889
1890 nonblock = !!(substream->f_flags & O_NONBLOCK); 1910 nonblock = !!(substream->f_flags & O_NONBLOCK);
1891 if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED) 1911 if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED)
1892 return -EINVAL; 1912 return -EINVAL;
@@ -1916,7 +1936,6 @@ static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream,
1916 } 1936 }
1917 } else { 1937 } else {
1918 snd_pcm_uframes_t dma_csize = runtime->dma_bytes / channels; 1938 snd_pcm_uframes_t dma_csize = runtime->dma_bytes / channels;
1919 snd_assert(runtime->dma_area, return -EFAULT);
1920 for (c = 0; c < channels; ++c, ++bufs) { 1939 for (c = 0; c < channels; ++c, ++bufs) {
1921 char *hwbuf; 1940 char *hwbuf;
1922 char __user *buf; 1941 char __user *buf;
@@ -1938,11 +1957,12 @@ snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream,
1938{ 1957{
1939 struct snd_pcm_runtime *runtime; 1958 struct snd_pcm_runtime *runtime;
1940 int nonblock; 1959 int nonblock;
1960 int err;
1941 1961
1942 snd_assert(substream != NULL, return -ENXIO); 1962 err = pcm_sanity_check(substream);
1963 if (err < 0)
1964 return err;
1943 runtime = substream->runtime; 1965 runtime = substream->runtime;
1944 snd_assert(runtime != NULL, return -ENXIO);
1945 snd_assert(substream->ops->copy != NULL || runtime->dma_area != NULL, return -EINVAL);
1946 if (runtime->status->state == SNDRV_PCM_STATE_OPEN) 1966 if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
1947 return -EBADFD; 1967 return -EBADFD;
1948 1968
diff --git a/sound/core/pcm_memory.c b/sound/core/pcm_memory.c
index ff07b4a9992e..859b1185e69a 100644
--- a/sound/core/pcm_memory.c
+++ b/sound/core/pcm_memory.c
@@ -50,8 +50,6 @@ static int preallocate_pcm_pages(struct snd_pcm_substream *substream, size_t siz
50 struct snd_dma_buffer *dmab = &substream->dma_buffer; 50 struct snd_dma_buffer *dmab = &substream->dma_buffer;
51 int err; 51 int err;
52 52
53 snd_assert(size > 0, return -EINVAL);
54
55 /* already reserved? */ 53 /* already reserved? */
56 if (snd_dma_get_reserved_buf(dmab, substream->dma_buf_id) > 0) { 54 if (snd_dma_get_reserved_buf(dmab, substream->dma_buf_id) > 0) {
57 if (dmab->bytes >= size) 55 if (dmab->bytes >= size)
@@ -342,10 +340,12 @@ int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size)
342 struct snd_pcm_runtime *runtime; 340 struct snd_pcm_runtime *runtime;
343 struct snd_dma_buffer *dmab = NULL; 341 struct snd_dma_buffer *dmab = NULL;
344 342
345 snd_assert(substream->dma_buffer.dev.type != SNDRV_DMA_TYPE_UNKNOWN, return -EINVAL); 343 if (PCM_RUNTIME_CHECK(substream))
346 snd_assert(substream != NULL, return -EINVAL); 344 return -EINVAL;
345 if (snd_BUG_ON(substream->dma_buffer.dev.type ==
346 SNDRV_DMA_TYPE_UNKNOWN))
347 return -EINVAL;
347 runtime = substream->runtime; 348 runtime = substream->runtime;
348 snd_assert(runtime != NULL, return -EINVAL);
349 349
350 if (runtime->dma_buffer_p) { 350 if (runtime->dma_buffer_p) {
351 /* perphaps, we might free the large DMA memory region 351 /* perphaps, we might free the large DMA memory region
@@ -391,9 +391,9 @@ int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream)
391{ 391{
392 struct snd_pcm_runtime *runtime; 392 struct snd_pcm_runtime *runtime;
393 393
394 snd_assert(substream != NULL, return -EINVAL); 394 if (PCM_RUNTIME_CHECK(substream))
395 return -EINVAL;
395 runtime = substream->runtime; 396 runtime = substream->runtime;
396 snd_assert(runtime != NULL, return -EINVAL);
397 if (runtime->dma_area == NULL) 397 if (runtime->dma_area == NULL)
398 return 0; 398 return 0;
399 if (runtime->dma_buffer_p != &substream->dma_buffer) { 399 if (runtime->dma_buffer_p != &substream->dma_buffer) {
diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c
index c487025d3457..df2299a8cefd 100644
--- a/sound/core/pcm_native.c
+++ b/sound/core/pcm_native.c
@@ -95,7 +95,6 @@ int snd_pcm_info(struct snd_pcm_substream *substream, struct snd_pcm_info *info)
95 struct snd_pcm *pcm = substream->pcm; 95 struct snd_pcm *pcm = substream->pcm;
96 struct snd_pcm_str *pstr = substream->pstr; 96 struct snd_pcm_str *pstr = substream->pstr;
97 97
98 snd_assert(substream != NULL, return -ENXIO);
99 memset(info, 0, sizeof(*info)); 98 memset(info, 0, sizeof(*info));
100 info->card = pcm->card->number; 99 info->card = pcm->card->number;
101 info->device = pcm->device; 100 info->device = pcm->device;
@@ -370,9 +369,9 @@ static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
370 unsigned int bits; 369 unsigned int bits;
371 snd_pcm_uframes_t frames; 370 snd_pcm_uframes_t frames;
372 371
373 snd_assert(substream != NULL, return -ENXIO); 372 if (PCM_RUNTIME_CHECK(substream))
373 return -ENXIO;
374 runtime = substream->runtime; 374 runtime = substream->runtime;
375 snd_assert(runtime != NULL, return -ENXIO);
376 snd_pcm_stream_lock_irq(substream); 375 snd_pcm_stream_lock_irq(substream);
377 switch (runtime->status->state) { 376 switch (runtime->status->state) {
378 case SNDRV_PCM_STATE_OPEN: 377 case SNDRV_PCM_STATE_OPEN:
@@ -490,9 +489,9 @@ static int snd_pcm_hw_free(struct snd_pcm_substream *substream)
490 struct snd_pcm_runtime *runtime; 489 struct snd_pcm_runtime *runtime;
491 int result = 0; 490 int result = 0;
492 491
493 snd_assert(substream != NULL, return -ENXIO); 492 if (PCM_RUNTIME_CHECK(substream))
493 return -ENXIO;
494 runtime = substream->runtime; 494 runtime = substream->runtime;
495 snd_assert(runtime != NULL, return -ENXIO);
496 snd_pcm_stream_lock_irq(substream); 495 snd_pcm_stream_lock_irq(substream);
497 switch (runtime->status->state) { 496 switch (runtime->status->state) {
498 case SNDRV_PCM_STATE_SETUP: 497 case SNDRV_PCM_STATE_SETUP:
@@ -518,9 +517,9 @@ static int snd_pcm_sw_params(struct snd_pcm_substream *substream,
518{ 517{
519 struct snd_pcm_runtime *runtime; 518 struct snd_pcm_runtime *runtime;
520 519
521 snd_assert(substream != NULL, return -ENXIO); 520 if (PCM_RUNTIME_CHECK(substream))
521 return -ENXIO;
522 runtime = substream->runtime; 522 runtime = substream->runtime;
523 snd_assert(runtime != NULL, return -ENXIO);
524 snd_pcm_stream_lock_irq(substream); 523 snd_pcm_stream_lock_irq(substream);
525 if (runtime->status->state == SNDRV_PCM_STATE_OPEN) { 524 if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
526 snd_pcm_stream_unlock_irq(substream); 525 snd_pcm_stream_unlock_irq(substream);
@@ -622,11 +621,8 @@ static int snd_pcm_status_user(struct snd_pcm_substream *substream,
622 struct snd_pcm_status __user * _status) 621 struct snd_pcm_status __user * _status)
623{ 622{
624 struct snd_pcm_status status; 623 struct snd_pcm_status status;
625 struct snd_pcm_runtime *runtime;
626 int res; 624 int res;
627 625
628 snd_assert(substream != NULL, return -ENXIO);
629 runtime = substream->runtime;
630 memset(&status, 0, sizeof(status)); 626 memset(&status, 0, sizeof(status));
631 res = snd_pcm_status(substream, &status); 627 res = snd_pcm_status(substream, &status);
632 if (res < 0) 628 if (res < 0)
@@ -642,7 +638,6 @@ static int snd_pcm_channel_info(struct snd_pcm_substream *substream,
642 struct snd_pcm_runtime *runtime; 638 struct snd_pcm_runtime *runtime;
643 unsigned int channel; 639 unsigned int channel;
644 640
645 snd_assert(substream != NULL, return -ENXIO);
646 channel = info->channel; 641 channel = info->channel;
647 runtime = substream->runtime; 642 runtime = substream->runtime;
648 snd_pcm_stream_lock_irq(substream); 643 snd_pcm_stream_lock_irq(substream);
@@ -1250,7 +1245,6 @@ static int snd_pcm_do_reset(struct snd_pcm_substream *substream, int state)
1250 int err = substream->ops->ioctl(substream, SNDRV_PCM_IOCTL1_RESET, NULL); 1245 int err = substream->ops->ioctl(substream, SNDRV_PCM_IOCTL1_RESET, NULL);
1251 if (err < 0) 1246 if (err < 0)
1252 return err; 1247 return err;
1253 // snd_assert(runtime->status->hw_ptr < runtime->buffer_size, );
1254 runtime->hw_ptr_base = 0; 1248 runtime->hw_ptr_base = 0;
1255 runtime->hw_ptr_interrupt = runtime->status->hw_ptr - 1249 runtime->hw_ptr_interrupt = runtime->status->hw_ptr -
1256 runtime->status->hw_ptr % runtime->period_size; 1250 runtime->status->hw_ptr % runtime->period_size;
@@ -1421,7 +1415,6 @@ static int snd_pcm_drain(struct snd_pcm_substream *substream)
1421 int i, num_drecs; 1415 int i, num_drecs;
1422 struct drain_rec *drec, drec_tmp, *d; 1416 struct drain_rec *drec, drec_tmp, *d;
1423 1417
1424 snd_assert(substream != NULL, return -ENXIO);
1425 card = substream->pcm->card; 1418 card = substream->pcm->card;
1426 runtime = substream->runtime; 1419 runtime = substream->runtime;
1427 1420
@@ -1541,7 +1534,8 @@ static int snd_pcm_drop(struct snd_pcm_substream *substream)
1541 struct snd_card *card; 1534 struct snd_card *card;
1542 int result = 0; 1535 int result = 0;
1543 1536
1544 snd_assert(substream != NULL, return -ENXIO); 1537 if (PCM_RUNTIME_CHECK(substream))
1538 return -ENXIO;
1545 runtime = substream->runtime; 1539 runtime = substream->runtime;
1546 card = substream->pcm->card; 1540 card = substream->pcm->card;
1547 1541
@@ -1934,33 +1928,41 @@ int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream)
1934 mask |= 1 << SNDRV_PCM_ACCESS_MMAP_COMPLEX; 1928 mask |= 1 << SNDRV_PCM_ACCESS_MMAP_COMPLEX;
1935 } 1929 }
1936 err = snd_pcm_hw_constraint_mask(runtime, SNDRV_PCM_HW_PARAM_ACCESS, mask); 1930 err = snd_pcm_hw_constraint_mask(runtime, SNDRV_PCM_HW_PARAM_ACCESS, mask);
1937 snd_assert(err >= 0, return -EINVAL); 1931 if (err < 0)
1932 return err;
1938 1933
1939 err = snd_pcm_hw_constraint_mask64(runtime, SNDRV_PCM_HW_PARAM_FORMAT, hw->formats); 1934 err = snd_pcm_hw_constraint_mask64(runtime, SNDRV_PCM_HW_PARAM_FORMAT, hw->formats);
1940 snd_assert(err >= 0, return -EINVAL); 1935 if (err < 0)
1936 return err;
1941 1937
1942 err = snd_pcm_hw_constraint_mask(runtime, SNDRV_PCM_HW_PARAM_SUBFORMAT, 1 << SNDRV_PCM_SUBFORMAT_STD); 1938 err = snd_pcm_hw_constraint_mask(runtime, SNDRV_PCM_HW_PARAM_SUBFORMAT, 1 << SNDRV_PCM_SUBFORMAT_STD);
1943 snd_assert(err >= 0, return -EINVAL); 1939 if (err < 0)
1940 return err;
1944 1941
1945 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_CHANNELS, 1942 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_CHANNELS,
1946 hw->channels_min, hw->channels_max); 1943 hw->channels_min, hw->channels_max);
1947 snd_assert(err >= 0, return -EINVAL); 1944 if (err < 0)
1945 return err;
1948 1946
1949 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_RATE, 1947 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_RATE,
1950 hw->rate_min, hw->rate_max); 1948 hw->rate_min, hw->rate_max);
1951 snd_assert(err >= 0, return -EINVAL); 1949 if (err < 0)
1950 return err;
1952 1951
1953 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 1952 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
1954 hw->period_bytes_min, hw->period_bytes_max); 1953 hw->period_bytes_min, hw->period_bytes_max);
1955 snd_assert(err >= 0, return -EINVAL); 1954 if (err < 0)
1955 return err;
1956 1956
1957 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIODS, 1957 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIODS,
1958 hw->periods_min, hw->periods_max); 1958 hw->periods_min, hw->periods_max);
1959 snd_assert(err >= 0, return -EINVAL); 1959 if (err < 0)
1960 return err;
1960 1961
1961 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 1962 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
1962 hw->period_bytes_min, hw->buffer_bytes_max); 1963 hw->period_bytes_min, hw->buffer_bytes_max);
1963 snd_assert(err >= 0, return -EINVAL); 1964 if (err < 0)
1965 return err;
1964 1966
1965 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 1967 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
1966 snd_pcm_hw_rule_buffer_bytes_max, substream, 1968 snd_pcm_hw_rule_buffer_bytes_max, substream,
@@ -1971,7 +1973,8 @@ int snd_pcm_hw_constraints_complete(struct snd_pcm_substream *substream)
1971 /* FIXME: remove */ 1973 /* FIXME: remove */
1972 if (runtime->dma_bytes) { 1974 if (runtime->dma_bytes) {
1973 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, runtime->dma_bytes); 1975 err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, runtime->dma_bytes);
1974 snd_assert(err >= 0, return -EINVAL); 1976 if (err < 0)
1977 return -EINVAL;
1975 } 1978 }
1976 1979
1977 if (!(hw->rates & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))) { 1980 if (!(hw->rates & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))) {
@@ -2067,8 +2070,8 @@ static int snd_pcm_open_file(struct file *file,
2067 struct snd_pcm_str *str; 2070 struct snd_pcm_str *str;
2068 int err; 2071 int err;
2069 2072
2070 snd_assert(rpcm_file != NULL, return -EINVAL); 2073 if (rpcm_file)
2071 *rpcm_file = NULL; 2074 *rpcm_file = NULL;
2072 2075
2073 err = snd_pcm_open_substream(pcm, stream, file, &substream); 2076 err = snd_pcm_open_substream(pcm, stream, file, &substream);
2074 if (err < 0) 2077 if (err < 0)
@@ -2086,7 +2089,8 @@ static int snd_pcm_open_file(struct file *file,
2086 substream->pcm_release = pcm_release_private; 2089 substream->pcm_release = pcm_release_private;
2087 } 2090 }
2088 file->private_data = pcm_file; 2091 file->private_data = pcm_file;
2089 *rpcm_file = pcm_file; 2092 if (rpcm_file)
2093 *rpcm_file = pcm_file;
2090 return 0; 2094 return 0;
2091} 2095}
2092 2096
@@ -2170,7 +2174,8 @@ static int snd_pcm_release(struct inode *inode, struct file *file)
2170 2174
2171 pcm_file = file->private_data; 2175 pcm_file = file->private_data;
2172 substream = pcm_file->substream; 2176 substream = pcm_file->substream;
2173 snd_assert(substream != NULL, return -ENXIO); 2177 if (snd_BUG_ON(!substream))
2178 return -ENXIO;
2174 pcm = substream->pcm; 2179 pcm = substream->pcm;
2175 fasync_helper(-1, file, 0, &substream->runtime->fasync); 2180 fasync_helper(-1, file, 0, &substream->runtime->fasync);
2176 mutex_lock(&pcm->open_mutex); 2181 mutex_lock(&pcm->open_mutex);
@@ -2493,8 +2498,6 @@ static int snd_pcm_common_ioctl1(struct file *file,
2493 struct snd_pcm_substream *substream, 2498 struct snd_pcm_substream *substream,
2494 unsigned int cmd, void __user *arg) 2499 unsigned int cmd, void __user *arg)
2495{ 2500{
2496 snd_assert(substream != NULL, return -ENXIO);
2497
2498 switch (cmd) { 2501 switch (cmd) {
2499 case SNDRV_PCM_IOCTL_PVERSION: 2502 case SNDRV_PCM_IOCTL_PVERSION:
2500 return put_user(SNDRV_PCM_VERSION, (int __user *)arg) ? -EFAULT : 0; 2503 return put_user(SNDRV_PCM_VERSION, (int __user *)arg) ? -EFAULT : 0;
@@ -2563,8 +2566,10 @@ static int snd_pcm_playback_ioctl1(struct file *file,
2563 struct snd_pcm_substream *substream, 2566 struct snd_pcm_substream *substream,
2564 unsigned int cmd, void __user *arg) 2567 unsigned int cmd, void __user *arg)
2565{ 2568{
2566 snd_assert(substream != NULL, return -ENXIO); 2569 if (snd_BUG_ON(!substream))
2567 snd_assert(substream->stream == SNDRV_PCM_STREAM_PLAYBACK, return -EINVAL); 2570 return -ENXIO;
2571 if (snd_BUG_ON(substream->stream != SNDRV_PCM_STREAM_PLAYBACK))
2572 return -EINVAL;
2568 switch (cmd) { 2573 switch (cmd) {
2569 case SNDRV_PCM_IOCTL_WRITEI_FRAMES: 2574 case SNDRV_PCM_IOCTL_WRITEI_FRAMES:
2570 { 2575 {
@@ -2643,8 +2648,10 @@ static int snd_pcm_capture_ioctl1(struct file *file,
2643 struct snd_pcm_substream *substream, 2648 struct snd_pcm_substream *substream,
2644 unsigned int cmd, void __user *arg) 2649 unsigned int cmd, void __user *arg)
2645{ 2650{
2646 snd_assert(substream != NULL, return -ENXIO); 2651 if (snd_BUG_ON(!substream))
2647 snd_assert(substream->stream == SNDRV_PCM_STREAM_CAPTURE, return -EINVAL); 2652 return -ENXIO;
2653 if (snd_BUG_ON(substream->stream != SNDRV_PCM_STREAM_CAPTURE))
2654 return -EINVAL;
2648 switch (cmd) { 2655 switch (cmd) {
2649 case SNDRV_PCM_IOCTL_READI_FRAMES: 2656 case SNDRV_PCM_IOCTL_READI_FRAMES:
2650 { 2657 {
@@ -2783,7 +2790,8 @@ static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t count,
2783 2790
2784 pcm_file = file->private_data; 2791 pcm_file = file->private_data;
2785 substream = pcm_file->substream; 2792 substream = pcm_file->substream;
2786 snd_assert(substream != NULL, return -ENXIO); 2793 if (PCM_RUNTIME_CHECK(substream))
2794 return -ENXIO;
2787 runtime = substream->runtime; 2795 runtime = substream->runtime;
2788 if (runtime->status->state == SNDRV_PCM_STATE_OPEN) 2796 if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2789 return -EBADFD; 2797 return -EBADFD;
@@ -2806,21 +2814,17 @@ static ssize_t snd_pcm_write(struct file *file, const char __user *buf,
2806 2814
2807 pcm_file = file->private_data; 2815 pcm_file = file->private_data;
2808 substream = pcm_file->substream; 2816 substream = pcm_file->substream;
2809 snd_assert(substream != NULL, result = -ENXIO; goto end); 2817 if (PCM_RUNTIME_CHECK(substream))
2818 return -ENXIO;
2810 runtime = substream->runtime; 2819 runtime = substream->runtime;
2811 if (runtime->status->state == SNDRV_PCM_STATE_OPEN) { 2820 if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2812 result = -EBADFD; 2821 return -EBADFD;
2813 goto end; 2822 if (!frame_aligned(runtime, count))
2814 } 2823 return -EINVAL;
2815 if (!frame_aligned(runtime, count)) {
2816 result = -EINVAL;
2817 goto end;
2818 }
2819 count = bytes_to_frames(runtime, count); 2824 count = bytes_to_frames(runtime, count);
2820 result = snd_pcm_lib_write(substream, buf, count); 2825 result = snd_pcm_lib_write(substream, buf, count);
2821 if (result > 0) 2826 if (result > 0)
2822 result = frames_to_bytes(runtime, result); 2827 result = frames_to_bytes(runtime, result);
2823 end:
2824 return result; 2828 return result;
2825} 2829}
2826 2830
@@ -2838,7 +2842,8 @@ static ssize_t snd_pcm_aio_read(struct kiocb *iocb, const struct iovec *iov,
2838 2842
2839 pcm_file = iocb->ki_filp->private_data; 2843 pcm_file = iocb->ki_filp->private_data;
2840 substream = pcm_file->substream; 2844 substream = pcm_file->substream;
2841 snd_assert(substream != NULL, return -ENXIO); 2845 if (PCM_RUNTIME_CHECK(substream))
2846 return -ENXIO;
2842 runtime = substream->runtime; 2847 runtime = substream->runtime;
2843 if (runtime->status->state == SNDRV_PCM_STATE_OPEN) 2848 if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2844 return -EBADFD; 2849 return -EBADFD;
@@ -2872,17 +2877,14 @@ static ssize_t snd_pcm_aio_write(struct kiocb *iocb, const struct iovec *iov,
2872 2877
2873 pcm_file = iocb->ki_filp->private_data; 2878 pcm_file = iocb->ki_filp->private_data;
2874 substream = pcm_file->substream; 2879 substream = pcm_file->substream;
2875 snd_assert(substream != NULL, result = -ENXIO; goto end); 2880 if (PCM_RUNTIME_CHECK(substream))
2881 return -ENXIO;
2876 runtime = substream->runtime; 2882 runtime = substream->runtime;
2877 if (runtime->status->state == SNDRV_PCM_STATE_OPEN) { 2883 if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
2878 result = -EBADFD; 2884 return -EBADFD;
2879 goto end;
2880 }
2881 if (nr_segs > 128 || nr_segs != runtime->channels || 2885 if (nr_segs > 128 || nr_segs != runtime->channels ||
2882 !frame_aligned(runtime, iov->iov_len)) { 2886 !frame_aligned(runtime, iov->iov_len))
2883 result = -EINVAL; 2887 return -EINVAL;
2884 goto end;
2885 }
2886 frames = bytes_to_samples(runtime, iov->iov_len); 2888 frames = bytes_to_samples(runtime, iov->iov_len);
2887 bufs = kmalloc(sizeof(void *) * nr_segs, GFP_KERNEL); 2889 bufs = kmalloc(sizeof(void *) * nr_segs, GFP_KERNEL);
2888 if (bufs == NULL) 2890 if (bufs == NULL)
@@ -2893,7 +2895,6 @@ static ssize_t snd_pcm_aio_write(struct kiocb *iocb, const struct iovec *iov,
2893 if (result > 0) 2895 if (result > 0)
2894 result = frames_to_bytes(runtime, result); 2896 result = frames_to_bytes(runtime, result);
2895 kfree(bufs); 2897 kfree(bufs);
2896 end:
2897 return result; 2898 return result;
2898} 2899}
2899 2900
@@ -2908,7 +2909,8 @@ static unsigned int snd_pcm_playback_poll(struct file *file, poll_table * wait)
2908 pcm_file = file->private_data; 2909 pcm_file = file->private_data;
2909 2910
2910 substream = pcm_file->substream; 2911 substream = pcm_file->substream;
2911 snd_assert(substream != NULL, return -ENXIO); 2912 if (PCM_RUNTIME_CHECK(substream))
2913 return -ENXIO;
2912 runtime = substream->runtime; 2914 runtime = substream->runtime;
2913 2915
2914 poll_wait(file, &runtime->sleep, wait); 2916 poll_wait(file, &runtime->sleep, wait);
@@ -2946,7 +2948,8 @@ static unsigned int snd_pcm_capture_poll(struct file *file, poll_table * wait)
2946 pcm_file = file->private_data; 2948 pcm_file = file->private_data;
2947 2949
2948 substream = pcm_file->substream; 2950 substream = pcm_file->substream;
2949 snd_assert(substream != NULL, return -ENXIO); 2951 if (PCM_RUNTIME_CHECK(substream))
2952 return -ENXIO;
2950 runtime = substream->runtime; 2953 runtime = substream->runtime;
2951 2954
2952 poll_wait(file, &runtime->sleep, wait); 2955 poll_wait(file, &runtime->sleep, wait);
@@ -3016,7 +3019,6 @@ static int snd_pcm_mmap_status(struct snd_pcm_substream *substream, struct file
3016 if (!(area->vm_flags & VM_READ)) 3019 if (!(area->vm_flags & VM_READ))
3017 return -EINVAL; 3020 return -EINVAL;
3018 runtime = substream->runtime; 3021 runtime = substream->runtime;
3019 snd_assert(runtime != NULL, return -EAGAIN);
3020 size = area->vm_end - area->vm_start; 3022 size = area->vm_end - area->vm_start;
3021 if (size != PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status))) 3023 if (size != PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)))
3022 return -EINVAL; 3024 return -EINVAL;
@@ -3056,7 +3058,6 @@ static int snd_pcm_mmap_control(struct snd_pcm_substream *substream, struct file
3056 if (!(area->vm_flags & VM_READ)) 3058 if (!(area->vm_flags & VM_READ))
3057 return -EINVAL; 3059 return -EINVAL;
3058 runtime = substream->runtime; 3060 runtime = substream->runtime;
3059 snd_assert(runtime != NULL, return -EAGAIN);
3060 size = area->vm_end - area->vm_start; 3061 size = area->vm_end - area->vm_start;
3061 if (size != PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control))) 3062 if (size != PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control)))
3062 return -EINVAL; 3063 return -EINVAL;
@@ -3188,7 +3189,6 @@ int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file,
3188 return -EINVAL; 3189 return -EINVAL;
3189 } 3190 }
3190 runtime = substream->runtime; 3191 runtime = substream->runtime;
3191 snd_assert(runtime != NULL, return -EAGAIN);
3192 if (runtime->status->state == SNDRV_PCM_STATE_OPEN) 3192 if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
3193 return -EBADFD; 3193 return -EBADFD;
3194 if (!(runtime->info & SNDRV_PCM_INFO_MMAP)) 3194 if (!(runtime->info & SNDRV_PCM_INFO_MMAP))
@@ -3220,7 +3220,8 @@ static int snd_pcm_mmap(struct file *file, struct vm_area_struct *area)
3220 3220
3221 pcm_file = file->private_data; 3221 pcm_file = file->private_data;
3222 substream = pcm_file->substream; 3222 substream = pcm_file->substream;
3223 snd_assert(substream != NULL, return -ENXIO); 3223 if (PCM_RUNTIME_CHECK(substream))
3224 return -ENXIO;
3224 3225
3225 offset = area->vm_pgoff << PAGE_SHIFT; 3226 offset = area->vm_pgoff << PAGE_SHIFT;
3226 switch (offset) { 3227 switch (offset) {
@@ -3248,9 +3249,9 @@ static int snd_pcm_fasync(int fd, struct file * file, int on)
3248 lock_kernel(); 3249 lock_kernel();
3249 pcm_file = file->private_data; 3250 pcm_file = file->private_data;
3250 substream = pcm_file->substream; 3251 substream = pcm_file->substream;
3251 snd_assert(substream != NULL, goto out); 3252 if (PCM_RUNTIME_CHECK(substream))
3253 goto out;
3252 runtime = substream->runtime; 3254 runtime = substream->runtime;
3253
3254 err = fasync_helper(fd, file, on, &runtime->fasync); 3255 err = fasync_helper(fd, file, on, &runtime->fasync);
3255out: 3256out:
3256 unlock_kernel(); 3257 unlock_kernel();
diff --git a/sound/core/pcm_timer.c b/sound/core/pcm_timer.c
index 033a024d153a..2c89c04f2916 100644
--- a/sound/core/pcm_timer.c
+++ b/sound/core/pcm_timer.c
@@ -51,12 +51,14 @@ void snd_pcm_timer_resolution_change(struct snd_pcm_substream *substream)
51 51
52 mult = 1000000000; 52 mult = 1000000000;
53 rate = runtime->rate; 53 rate = runtime->rate;
54 snd_assert(rate != 0, return); 54 if (snd_BUG_ON(!rate))
55 return;
55 l = gcd(mult, rate); 56 l = gcd(mult, rate);
56 mult /= l; 57 mult /= l;
57 rate /= l; 58 rate /= l;
58 fsize = runtime->period_size; 59 fsize = runtime->period_size;
59 snd_assert(fsize != 0, return); 60 if (snd_BUG_ON(!fsize))
61 return;
60 l = gcd(rate, fsize); 62 l = gcd(rate, fsize);
61 rate /= l; 63 rate /= l;
62 fsize /= l; 64 fsize /= l;
diff --git a/sound/core/rawmidi.c b/sound/core/rawmidi.c
index b917a9f981c7..c4995c9f5730 100644
--- a/sound/core/rawmidi.c
+++ b/sound/core/rawmidi.c
@@ -470,8 +470,8 @@ int snd_rawmidi_kernel_release(struct snd_rawmidi_file * rfile)
470 struct snd_rawmidi_substream *substream; 470 struct snd_rawmidi_substream *substream;
471 struct snd_rawmidi_runtime *runtime; 471 struct snd_rawmidi_runtime *runtime;
472 472
473 snd_assert(rfile != NULL, return -ENXIO); 473 if (snd_BUG_ON(!rfile))
474 snd_assert(rfile->input != NULL || rfile->output != NULL, return -ENXIO); 474 return -ENXIO;
475 rmidi = rfile->rmidi; 475 rmidi = rfile->rmidi;
476 mutex_lock(&rmidi->open_mutex); 476 mutex_lock(&rmidi->open_mutex);
477 if (rfile->input != NULL) { 477 if (rfile->input != NULL) {
@@ -1100,7 +1100,7 @@ int snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count)
1100 return -EINVAL; 1100 return -EINVAL;
1101 } 1101 }
1102 spin_lock_irqsave(&runtime->lock, flags); 1102 spin_lock_irqsave(&runtime->lock, flags);
1103 snd_assert(runtime->avail + count <= runtime->buffer_size, ); 1103 snd_BUG_ON(runtime->avail + count > runtime->buffer_size);
1104 runtime->hw_ptr += count; 1104 runtime->hw_ptr += count;
1105 runtime->hw_ptr %= runtime->buffer_size; 1105 runtime->hw_ptr %= runtime->buffer_size;
1106 runtime->avail += count; 1106 runtime->avail += count;
@@ -1141,8 +1141,10 @@ static long snd_rawmidi_kernel_write1(struct snd_rawmidi_substream *substream,
1141 long count1, result; 1141 long count1, result;
1142 struct snd_rawmidi_runtime *runtime = substream->runtime; 1142 struct snd_rawmidi_runtime *runtime = substream->runtime;
1143 1143
1144 snd_assert(kernelbuf != NULL || userbuf != NULL, return -EINVAL); 1144 if (snd_BUG_ON(!kernelbuf && !userbuf))
1145 snd_assert(runtime->buffer != NULL, return -EINVAL); 1145 return -EINVAL;
1146 if (snd_BUG_ON(!runtime->buffer))
1147 return -EINVAL;
1146 1148
1147 result = 0; 1149 result = 0;
1148 spin_lock_irqsave(&runtime->lock, flags); 1150 spin_lock_irqsave(&runtime->lock, flags);
@@ -1420,9 +1422,10 @@ int snd_rawmidi_new(struct snd_card *card, char *id, int device,
1420 .dev_disconnect = snd_rawmidi_dev_disconnect, 1422 .dev_disconnect = snd_rawmidi_dev_disconnect,
1421 }; 1423 };
1422 1424
1423 snd_assert(rrawmidi != NULL, return -EINVAL); 1425 if (snd_BUG_ON(!card))
1424 *rrawmidi = NULL; 1426 return -ENXIO;
1425 snd_assert(card != NULL, return -ENXIO); 1427 if (rrawmidi)
1428 *rrawmidi = NULL;
1426 rmidi = kzalloc(sizeof(*rmidi), GFP_KERNEL); 1429 rmidi = kzalloc(sizeof(*rmidi), GFP_KERNEL);
1427 if (rmidi == NULL) { 1430 if (rmidi == NULL) {
1428 snd_printk(KERN_ERR "rawmidi: cannot allocate\n"); 1431 snd_printk(KERN_ERR "rawmidi: cannot allocate\n");
@@ -1455,7 +1458,8 @@ int snd_rawmidi_new(struct snd_card *card, char *id, int device,
1455 snd_rawmidi_free(rmidi); 1458 snd_rawmidi_free(rmidi);
1456 return err; 1459 return err;
1457 } 1460 }
1458 *rrawmidi = rmidi; 1461 if (rrawmidi)
1462 *rrawmidi = rmidi;
1459 return 0; 1463 return 0;
1460} 1464}
1461 1465
@@ -1472,7 +1476,8 @@ static void snd_rawmidi_free_substreams(struct snd_rawmidi_str *stream)
1472 1476
1473static int snd_rawmidi_free(struct snd_rawmidi *rmidi) 1477static int snd_rawmidi_free(struct snd_rawmidi *rmidi)
1474{ 1478{
1475 snd_assert(rmidi != NULL, return -ENXIO); 1479 if (!rmidi)
1480 return 0;
1476 1481
1477 snd_info_free_entry(rmidi->proc_entry); 1482 snd_info_free_entry(rmidi->proc_entry);
1478 rmidi->proc_entry = NULL; 1483 rmidi->proc_entry = NULL;
diff --git a/sound/core/rtctimer.c b/sound/core/rtctimer.c
index 97b30fb4c361..51e64e30dd3b 100644
--- a/sound/core/rtctimer.c
+++ b/sound/core/rtctimer.c
@@ -91,7 +91,8 @@ static int
91rtctimer_start(struct snd_timer *timer) 91rtctimer_start(struct snd_timer *timer)
92{ 92{
93 rtc_task_t *rtc = timer->private_data; 93 rtc_task_t *rtc = timer->private_data;
94 snd_assert(rtc != NULL, return -EINVAL); 94 if (snd_BUG_ON(!rtc))
95 return -EINVAL;
95 rtc_control(rtc, RTC_IRQP_SET, rtctimer_freq); 96 rtc_control(rtc, RTC_IRQP_SET, rtctimer_freq);
96 rtc_control(rtc, RTC_PIE_ON, 0); 97 rtc_control(rtc, RTC_PIE_ON, 0);
97 return 0; 98 return 0;
@@ -101,7 +102,8 @@ static int
101rtctimer_stop(struct snd_timer *timer) 102rtctimer_stop(struct snd_timer *timer)
102{ 103{
103 rtc_task_t *rtc = timer->private_data; 104 rtc_task_t *rtc = timer->private_data;
104 snd_assert(rtc != NULL, return -EINVAL); 105 if (snd_BUG_ON(!rtc))
106 return -EINVAL;
105 rtc_control(rtc, RTC_PIE_OFF, 0); 107 rtc_control(rtc, RTC_PIE_OFF, 0);
106 return 0; 108 return 0;
107} 109}
diff --git a/sound/core/seq/oss/seq_oss.c b/sound/core/seq/oss/seq_oss.c
index 777796e94490..f25e3cc7ddfa 100644
--- a/sound/core/seq/oss/seq_oss.c
+++ b/sound/core/seq/oss/seq_oss.c
@@ -164,7 +164,8 @@ odev_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
164{ 164{
165 struct seq_oss_devinfo *dp; 165 struct seq_oss_devinfo *dp;
166 dp = file->private_data; 166 dp = file->private_data;
167 snd_assert(dp != NULL, return -EIO); 167 if (snd_BUG_ON(!dp))
168 return -ENXIO;
168 return snd_seq_oss_read(dp, buf, count); 169 return snd_seq_oss_read(dp, buf, count);
169} 170}
170 171
@@ -174,7 +175,8 @@ odev_write(struct file *file, const char __user *buf, size_t count, loff_t *offs
174{ 175{
175 struct seq_oss_devinfo *dp; 176 struct seq_oss_devinfo *dp;
176 dp = file->private_data; 177 dp = file->private_data;
177 snd_assert(dp != NULL, return -EIO); 178 if (snd_BUG_ON(!dp))
179 return -ENXIO;
178 return snd_seq_oss_write(dp, buf, count, file); 180 return snd_seq_oss_write(dp, buf, count, file);
179} 181}
180 182
@@ -183,7 +185,8 @@ odev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
183{ 185{
184 struct seq_oss_devinfo *dp; 186 struct seq_oss_devinfo *dp;
185 dp = file->private_data; 187 dp = file->private_data;
186 snd_assert(dp != NULL, return -EIO); 188 if (snd_BUG_ON(!dp))
189 return -ENXIO;
187 return snd_seq_oss_ioctl(dp, cmd, arg); 190 return snd_seq_oss_ioctl(dp, cmd, arg);
188} 191}
189 192
@@ -198,7 +201,8 @@ odev_poll(struct file *file, poll_table * wait)
198{ 201{
199 struct seq_oss_devinfo *dp; 202 struct seq_oss_devinfo *dp;
200 dp = file->private_data; 203 dp = file->private_data;
201 snd_assert(dp != NULL, return 0); 204 if (snd_BUG_ON(!dp))
205 return -ENXIO;
202 return snd_seq_oss_poll(dp, file, wait); 206 return snd_seq_oss_poll(dp, file, wait);
203} 207}
204 208
diff --git a/sound/core/seq/oss/seq_oss_synth.c b/sound/core/seq/oss/seq_oss_synth.c
index e024e4588b82..945a27c34a9d 100644
--- a/sound/core/seq/oss/seq_oss_synth.c
+++ b/sound/core/seq/oss/seq_oss_synth.c
@@ -308,7 +308,8 @@ snd_seq_oss_synth_cleanup(struct seq_oss_devinfo *dp)
308 struct seq_oss_synth *rec; 308 struct seq_oss_synth *rec;
309 struct seq_oss_synthinfo *info; 309 struct seq_oss_synthinfo *info;
310 310
311 snd_assert(dp->max_synthdev <= SNDRV_SEQ_OSS_MAX_SYNTH_DEVS, return); 311 if (snd_BUG_ON(dp->max_synthdev >= SNDRV_SEQ_OSS_MAX_SYNTH_DEVS))
312 return;
312 for (i = 0; i < dp->max_synthdev; i++) { 313 for (i = 0; i < dp->max_synthdev; i++) {
313 info = &dp->synths[i]; 314 info = &dp->synths[i];
314 if (! info->opened) 315 if (! info->opened)
@@ -402,7 +403,8 @@ snd_seq_oss_synth_reset(struct seq_oss_devinfo *dp, int dev)
402 struct seq_oss_synth *rec; 403 struct seq_oss_synth *rec;
403 struct seq_oss_synthinfo *info; 404 struct seq_oss_synthinfo *info;
404 405
405 snd_assert(dev >= 0 && dev < dp->max_synthdev, return); 406 if (snd_BUG_ON(dev < 0 || dev >= dp->max_synthdev))
407 return;
406 info = &dp->synths[dev]; 408 info = &dp->synths[dev];
407 if (! info->opened) 409 if (! info->opened)
408 return; 410 return;
diff --git a/sound/core/seq/seq_clientmgr.c b/sound/core/seq/seq_clientmgr.c
index 7a1545d2d953..8ca2be339f3b 100644
--- a/sound/core/seq/seq_clientmgr.c
+++ b/sound/core/seq/seq_clientmgr.c
@@ -266,7 +266,8 @@ static int seq_free_client1(struct snd_seq_client *client)
266{ 266{
267 unsigned long flags; 267 unsigned long flags;
268 268
269 snd_assert(client != NULL, return -EINVAL); 269 if (!client)
270 return 0;
270 snd_seq_delete_all_ports(client); 271 snd_seq_delete_all_ports(client);
271 snd_seq_queue_client_leave(client->number); 272 snd_seq_queue_client_leave(client->number);
272 spin_lock_irqsave(&clients_lock, flags); 273 spin_lock_irqsave(&clients_lock, flags);
@@ -403,7 +404,8 @@ static ssize_t snd_seq_read(struct file *file, char __user *buf, size_t count,
403 return -EFAULT; 404 return -EFAULT;
404 405
405 /* check client structures are in place */ 406 /* check client structures are in place */
406 snd_assert(client != NULL, return -ENXIO); 407 if (snd_BUG_ON(!client))
408 return -ENXIO;
407 409
408 if (!client->accept_input || (fifo = client->data.user.fifo) == NULL) 410 if (!client->accept_input || (fifo = client->data.user.fifo) == NULL)
409 return -ENXIO; 411 return -ENXIO;
@@ -825,7 +827,8 @@ int snd_seq_dispatch_event(struct snd_seq_event_cell *cell, int atomic, int hop)
825 struct snd_seq_client *client; 827 struct snd_seq_client *client;
826 int result; 828 int result;
827 829
828 snd_assert(cell != NULL, return -EINVAL); 830 if (snd_BUG_ON(!cell))
831 return -EINVAL;
829 832
830 client = snd_seq_client_use_ptr(cell->event.source.client); 833 client = snd_seq_client_use_ptr(cell->event.source.client);
831 if (client == NULL) { 834 if (client == NULL) {
@@ -994,7 +997,8 @@ static ssize_t snd_seq_write(struct file *file, const char __user *buf,
994 return -ENXIO; 997 return -ENXIO;
995 998
996 /* check client structures are in place */ 999 /* check client structures are in place */
997 snd_assert(client != NULL, return -ENXIO); 1000 if (snd_BUG_ON(!client))
1001 return -ENXIO;
998 1002
999 if (!client->accept_output || client->pool == NULL) 1003 if (!client->accept_output || client->pool == NULL)
1000 return -ENXIO; 1004 return -ENXIO;
@@ -1076,7 +1080,8 @@ static unsigned int snd_seq_poll(struct file *file, poll_table * wait)
1076 unsigned int mask = 0; 1080 unsigned int mask = 0;
1077 1081
1078 /* check client structures are in place */ 1082 /* check client structures are in place */
1079 snd_assert(client != NULL, return -ENXIO); 1083 if (snd_BUG_ON(!client))
1084 return -ENXIO;
1080 1085
1081 if ((snd_seq_file_flags(file) & SNDRV_SEQ_LFLG_INPUT) && 1086 if ((snd_seq_file_flags(file) & SNDRV_SEQ_LFLG_INPUT) &&
1082 client->data.user.fifo) { 1087 client->data.user.fifo) {
@@ -2195,7 +2200,8 @@ static long snd_seq_ioctl(struct file *file, unsigned int cmd, unsigned long arg
2195{ 2200{
2196 struct snd_seq_client *client = file->private_data; 2201 struct snd_seq_client *client = file->private_data;
2197 2202
2198 snd_assert(client != NULL, return -ENXIO); 2203 if (snd_BUG_ON(!client))
2204 return -ENXIO;
2199 2205
2200 return snd_seq_do_ioctl(client, cmd, (void __user *) arg); 2206 return snd_seq_do_ioctl(client, cmd, (void __user *) arg);
2201} 2207}
@@ -2216,7 +2222,8 @@ int snd_seq_create_kernel_client(struct snd_card *card, int client_index,
2216 struct snd_seq_client *client; 2222 struct snd_seq_client *client;
2217 va_list args; 2223 va_list args;
2218 2224
2219 snd_assert(! in_interrupt(), return -EBUSY); 2225 if (snd_BUG_ON(in_interrupt()))
2226 return -EBUSY;
2220 2227
2221 if (card && client_index >= SNDRV_SEQ_CLIENTS_PER_CARD) 2228 if (card && client_index >= SNDRV_SEQ_CLIENTS_PER_CARD)
2222 return -EINVAL; 2229 return -EINVAL;
@@ -2265,7 +2272,8 @@ int snd_seq_delete_kernel_client(int client)
2265{ 2272{
2266 struct snd_seq_client *ptr; 2273 struct snd_seq_client *ptr;
2267 2274
2268 snd_assert(! in_interrupt(), return -EBUSY); 2275 if (snd_BUG_ON(in_interrupt()))
2276 return -EBUSY;
2269 2277
2270 ptr = clientptr(client); 2278 ptr = clientptr(client);
2271 if (ptr == NULL) 2279 if (ptr == NULL)
@@ -2288,7 +2296,8 @@ static int kernel_client_enqueue(int client, struct snd_seq_event *ev,
2288 struct snd_seq_client *cptr; 2296 struct snd_seq_client *cptr;
2289 int result; 2297 int result;
2290 2298
2291 snd_assert(ev != NULL, return -EINVAL); 2299 if (snd_BUG_ON(!ev))
2300 return -EINVAL;
2292 2301
2293 if (ev->type == SNDRV_SEQ_EVENT_NONE) 2302 if (ev->type == SNDRV_SEQ_EVENT_NONE)
2294 return 0; /* ignore this */ 2303 return 0; /* ignore this */
@@ -2354,7 +2363,8 @@ int snd_seq_kernel_client_dispatch(int client, struct snd_seq_event * ev,
2354 struct snd_seq_client *cptr; 2363 struct snd_seq_client *cptr;
2355 int result; 2364 int result;
2356 2365
2357 snd_assert(ev != NULL, return -EINVAL); 2366 if (snd_BUG_ON(!ev))
2367 return -EINVAL;
2358 2368
2359 /* fill in client number */ 2369 /* fill in client number */
2360 ev->queue = SNDRV_SEQ_QUEUE_DIRECT; 2370 ev->queue = SNDRV_SEQ_QUEUE_DIRECT;
diff --git a/sound/core/seq/seq_compat.c b/sound/core/seq/seq_compat.c
index 9628c06e4eab..38693f47c262 100644
--- a/sound/core/seq/seq_compat.c
+++ b/sound/core/seq/seq_compat.c
@@ -92,7 +92,8 @@ static long snd_seq_ioctl_compat(struct file *file, unsigned int cmd, unsigned l
92 struct snd_seq_client *client = file->private_data; 92 struct snd_seq_client *client = file->private_data;
93 void __user *argp = compat_ptr(arg); 93 void __user *argp = compat_ptr(arg);
94 94
95 snd_assert(client != NULL, return -ENXIO); 95 if (snd_BUG_ON(!client))
96 return -ENXIO;
96 97
97 switch (cmd) { 98 switch (cmd) {
98 case SNDRV_SEQ_IOCTL_PVERSION: 99 case SNDRV_SEQ_IOCTL_PVERSION:
diff --git a/sound/core/seq/seq_device.c b/sound/core/seq/seq_device.c
index 05410e536a4f..1f997675c893 100644
--- a/sound/core/seq/seq_device.c
+++ b/sound/core/seq/seq_device.c
@@ -187,7 +187,8 @@ int snd_seq_device_new(struct snd_card *card, int device, char *id, int argsize,
187 if (result) 187 if (result)
188 *result = NULL; 188 *result = NULL;
189 189
190 snd_assert(id != NULL, return -EINVAL); 190 if (snd_BUG_ON(!id))
191 return -EINVAL;
191 192
192 ops = find_driver(id, 1); 193 ops = find_driver(id, 1);
193 if (ops == NULL) 194 if (ops == NULL)
@@ -232,7 +233,8 @@ static int snd_seq_device_free(struct snd_seq_device *dev)
232{ 233{
233 struct ops_list *ops; 234 struct ops_list *ops;
234 235
235 snd_assert(dev != NULL, return -EINVAL); 236 if (snd_BUG_ON(!dev))
237 return -EINVAL;
236 238
237 ops = find_driver(dev->id, 0); 239 ops = find_driver(dev->id, 0);
238 if (ops == NULL) 240 if (ops == NULL)
diff --git a/sound/core/seq/seq_fifo.c b/sound/core/seq/seq_fifo.c
index 3a94ed021bd9..0d75afa786bc 100644
--- a/sound/core/seq/seq_fifo.c
+++ b/sound/core/seq/seq_fifo.c
@@ -65,9 +65,11 @@ void snd_seq_fifo_delete(struct snd_seq_fifo **fifo)
65{ 65{
66 struct snd_seq_fifo *f; 66 struct snd_seq_fifo *f;
67 67
68 snd_assert(fifo != NULL, return); 68 if (snd_BUG_ON(!fifo))
69 return;
69 f = *fifo; 70 f = *fifo;
70 snd_assert(f != NULL, return); 71 if (snd_BUG_ON(!f))
72 return;
71 *fifo = NULL; 73 *fifo = NULL;
72 74
73 snd_seq_fifo_clear(f); 75 snd_seq_fifo_clear(f);
@@ -116,7 +118,8 @@ int snd_seq_fifo_event_in(struct snd_seq_fifo *f,
116 unsigned long flags; 118 unsigned long flags;
117 int err; 119 int err;
118 120
119 snd_assert(f != NULL, return -EINVAL); 121 if (snd_BUG_ON(!f))
122 return -EINVAL;
120 123
121 snd_use_lock_use(&f->use_lock); 124 snd_use_lock_use(&f->use_lock);
122 err = snd_seq_event_dup(f->pool, event, &cell, 1, NULL); /* always non-blocking */ 125 err = snd_seq_event_dup(f->pool, event, &cell, 1, NULL); /* always non-blocking */
@@ -174,7 +177,8 @@ int snd_seq_fifo_cell_out(struct snd_seq_fifo *f,
174 unsigned long flags; 177 unsigned long flags;
175 wait_queue_t wait; 178 wait_queue_t wait;
176 179
177 snd_assert(f != NULL, return -EINVAL); 180 if (snd_BUG_ON(!f))
181 return -EINVAL;
178 182
179 *cellp = NULL; 183 *cellp = NULL;
180 init_waitqueue_entry(&wait, current); 184 init_waitqueue_entry(&wait, current);
@@ -233,7 +237,8 @@ int snd_seq_fifo_resize(struct snd_seq_fifo *f, int poolsize)
233 struct snd_seq_pool *newpool, *oldpool; 237 struct snd_seq_pool *newpool, *oldpool;
234 struct snd_seq_event_cell *cell, *next, *oldhead; 238 struct snd_seq_event_cell *cell, *next, *oldhead;
235 239
236 snd_assert(f != NULL && f->pool != NULL, return -EINVAL); 240 if (snd_BUG_ON(!f || !f->pool))
241 return -EINVAL;
237 242
238 /* allocate new pool */ 243 /* allocate new pool */
239 newpool = snd_seq_pool_new(poolsize); 244 newpool = snd_seq_pool_new(poolsize);
diff --git a/sound/core/seq/seq_memory.c b/sound/core/seq/seq_memory.c
index 0cf6ac477318..7fb55436287f 100644
--- a/sound/core/seq/seq_memory.c
+++ b/sound/core/seq/seq_memory.c
@@ -187,9 +187,11 @@ void snd_seq_cell_free(struct snd_seq_event_cell * cell)
187 unsigned long flags; 187 unsigned long flags;
188 struct snd_seq_pool *pool; 188 struct snd_seq_pool *pool;
189 189
190 snd_assert(cell != NULL, return); 190 if (snd_BUG_ON(!cell))
191 return;
191 pool = cell->pool; 192 pool = cell->pool;
192 snd_assert(pool != NULL, return); 193 if (snd_BUG_ON(!pool))
194 return;
193 195
194 spin_lock_irqsave(&pool->lock, flags); 196 spin_lock_irqsave(&pool->lock, flags);
195 free_cell(pool, cell); 197 free_cell(pool, cell);
@@ -378,7 +380,8 @@ int snd_seq_pool_init(struct snd_seq_pool *pool)
378 struct snd_seq_event_cell *cellptr; 380 struct snd_seq_event_cell *cellptr;
379 unsigned long flags; 381 unsigned long flags;
380 382
381 snd_assert(pool != NULL, return -EINVAL); 383 if (snd_BUG_ON(!pool))
384 return -EINVAL;
382 if (pool->ptr) /* should be atomic? */ 385 if (pool->ptr) /* should be atomic? */
383 return 0; 386 return 0;
384 387
@@ -414,7 +417,8 @@ int snd_seq_pool_done(struct snd_seq_pool *pool)
414 struct snd_seq_event_cell *ptr; 417 struct snd_seq_event_cell *ptr;
415 int max_count = 5 * HZ; 418 int max_count = 5 * HZ;
416 419
417 snd_assert(pool != NULL, return -EINVAL); 420 if (snd_BUG_ON(!pool))
421 return -EINVAL;
418 422
419 /* wait for closing all threads */ 423 /* wait for closing all threads */
420 spin_lock_irqsave(&pool->lock, flags); 424 spin_lock_irqsave(&pool->lock, flags);
diff --git a/sound/core/seq/seq_midi.c b/sound/core/seq/seq_midi.c
index 99b35360c506..4d26146a62cc 100644
--- a/sound/core/seq/seq_midi.c
+++ b/sound/core/seq/seq_midi.c
@@ -116,7 +116,8 @@ static int dump_midi(struct snd_rawmidi_substream *substream, const char *buf, i
116 struct snd_rawmidi_runtime *runtime; 116 struct snd_rawmidi_runtime *runtime;
117 int tmp; 117 int tmp;
118 118
119 snd_assert(substream != NULL || buf != NULL, return -EINVAL); 119 if (snd_BUG_ON(!substream || !buf))
120 return -EINVAL;
120 runtime = substream->runtime; 121 runtime = substream->runtime;
121 if ((tmp = runtime->avail) < count) { 122 if ((tmp = runtime->avail) < count) {
122 snd_printd("warning, output event was lost (count = %i, available = %i)\n", count, tmp); 123 snd_printd("warning, output event was lost (count = %i, available = %i)\n", count, tmp);
@@ -135,7 +136,8 @@ static int event_process_midi(struct snd_seq_event *ev, int direct,
135 struct snd_rawmidi_substream *substream; 136 struct snd_rawmidi_substream *substream;
136 int len; 137 int len;
137 138
138 snd_assert(msynth != NULL, return -EINVAL); 139 if (snd_BUG_ON(!msynth))
140 return -EINVAL;
139 substream = msynth->output_rfile.output; 141 substream = msynth->output_rfile.output;
140 if (substream == NULL) 142 if (substream == NULL)
141 return -ENODEV; 143 return -ENODEV;
@@ -210,7 +212,8 @@ static int midisynth_unsubscribe(void *private_data, struct snd_seq_port_subscri
210 int err; 212 int err;
211 struct seq_midisynth *msynth = private_data; 213 struct seq_midisynth *msynth = private_data;
212 214
213 snd_assert(msynth->input_rfile.input != NULL, return -EINVAL); 215 if (snd_BUG_ON(!msynth->input_rfile.input))
216 return -EINVAL;
214 err = snd_rawmidi_kernel_release(&msynth->input_rfile); 217 err = snd_rawmidi_kernel_release(&msynth->input_rfile);
215 return err; 218 return err;
216} 219}
@@ -247,7 +250,8 @@ static int midisynth_unuse(void *private_data, struct snd_seq_port_subscribe *in
247 struct seq_midisynth *msynth = private_data; 250 struct seq_midisynth *msynth = private_data;
248 unsigned char buf = 0xff; /* MIDI reset */ 251 unsigned char buf = 0xff; /* MIDI reset */
249 252
250 snd_assert(msynth->output_rfile.output != NULL, return -EINVAL); 253 if (snd_BUG_ON(!msynth->output_rfile.output))
254 return -EINVAL;
251 /* sending single MIDI reset message to shut the device up */ 255 /* sending single MIDI reset message to shut the device up */
252 snd_rawmidi_kernel_write(msynth->output_rfile.output, &buf, 1); 256 snd_rawmidi_kernel_write(msynth->output_rfile.output, &buf, 1);
253 snd_rawmidi_drain_output(msynth->output_rfile.output); 257 snd_rawmidi_drain_output(msynth->output_rfile.output);
@@ -285,7 +289,8 @@ snd_seq_midisynth_register_port(struct snd_seq_device *dev)
285 int device = dev->device; 289 int device = dev->device;
286 unsigned int input_count = 0, output_count = 0; 290 unsigned int input_count = 0, output_count = 0;
287 291
288 snd_assert(card != NULL && device >= 0 && device < SNDRV_RAWMIDI_DEVICES, return -EINVAL); 292 if (snd_BUG_ON(!card || device < 0 || device >= SNDRV_RAWMIDI_DEVICES))
293 return -EINVAL;
289 info = kmalloc(sizeof(*info), GFP_KERNEL); 294 info = kmalloc(sizeof(*info), GFP_KERNEL);
290 if (! info) 295 if (! info)
291 return -ENOMEM; 296 return -ENOMEM;
diff --git a/sound/core/seq/seq_ports.c b/sound/core/seq/seq_ports.c
index 1c32a53d6bd8..3bf7d73ac52e 100644
--- a/sound/core/seq/seq_ports.c
+++ b/sound/core/seq/seq_ports.c
@@ -130,7 +130,8 @@ struct snd_seq_client_port *snd_seq_create_port(struct snd_seq_client *client,
130 int num = -1; 130 int num = -1;
131 131
132 /* sanity check */ 132 /* sanity check */
133 snd_assert(client, return NULL); 133 if (snd_BUG_ON(!client))
134 return NULL;
134 135
135 if (client->num_ports >= SNDRV_SEQ_MAX_PORTS - 1) { 136 if (client->num_ports >= SNDRV_SEQ_MAX_PORTS - 1) {
136 snd_printk(KERN_WARNING "too many ports for client %d\n", client->number); 137 snd_printk(KERN_WARNING "too many ports for client %d\n", client->number);
@@ -268,8 +269,8 @@ static int port_delete(struct snd_seq_client *client,
268 if (port->private_free) 269 if (port->private_free)
269 port->private_free(port->private_data); 270 port->private_free(port->private_data);
270 271
271 snd_assert(port->c_src.count == 0,); 272 snd_BUG_ON(port->c_src.count != 0);
272 snd_assert(port->c_dest.count == 0,); 273 snd_BUG_ON(port->c_dest.count != 0);
273 274
274 kfree(port); 275 kfree(port);
275 return 0; 276 return 0;
@@ -336,7 +337,8 @@ int snd_seq_delete_all_ports(struct snd_seq_client *client)
336int snd_seq_set_port_info(struct snd_seq_client_port * port, 337int snd_seq_set_port_info(struct snd_seq_client_port * port,
337 struct snd_seq_port_info * info) 338 struct snd_seq_port_info * info)
338{ 339{
339 snd_assert(port && info, return -EINVAL); 340 if (snd_BUG_ON(!port || !info))
341 return -EINVAL;
340 342
341 /* set port name */ 343 /* set port name */
342 if (info->name[0]) 344 if (info->name[0])
@@ -365,7 +367,8 @@ int snd_seq_set_port_info(struct snd_seq_client_port * port,
365int snd_seq_get_port_info(struct snd_seq_client_port * port, 367int snd_seq_get_port_info(struct snd_seq_client_port * port,
366 struct snd_seq_port_info * info) 368 struct snd_seq_port_info * info)
367{ 369{
368 snd_assert(port && info, return -EINVAL); 370 if (snd_BUG_ON(!port || !info))
371 return -EINVAL;
369 372
370 /* get port name */ 373 /* get port name */
371 strlcpy(info->name, port->name, sizeof(info->name)); 374 strlcpy(info->name, port->name, sizeof(info->name));
diff --git a/sound/core/seq/seq_prioq.c b/sound/core/seq/seq_prioq.c
index 85969db576c9..0101a8b99b73 100644
--- a/sound/core/seq/seq_prioq.c
+++ b/sound/core/seq/seq_prioq.c
@@ -153,8 +153,8 @@ int snd_seq_prioq_cell_in(struct snd_seq_prioq * f,
153 int count; 153 int count;
154 int prior; 154 int prior;
155 155
156 snd_assert(f, return -EINVAL); 156 if (snd_BUG_ON(!f || !cell))
157 snd_assert(cell, return -EINVAL); 157 return -EINVAL;
158 158
159 /* check flags */ 159 /* check flags */
160 prior = (cell->event.flags & SNDRV_SEQ_PRIORITY_MASK); 160 prior = (cell->event.flags & SNDRV_SEQ_PRIORITY_MASK);
diff --git a/sound/core/seq/seq_queue.c b/sound/core/seq/seq_queue.c
index 4a48c6ee8ee8..e7a8e9e4edb2 100644
--- a/sound/core/seq/seq_queue.c
+++ b/sound/core/seq/seq_queue.c
@@ -315,7 +315,8 @@ int snd_seq_enqueue_event(struct snd_seq_event_cell *cell, int atomic, int hop)
315 int dest, err; 315 int dest, err;
316 struct snd_seq_queue *q; 316 struct snd_seq_queue *q;
317 317
318 snd_assert(cell != NULL, return -EINVAL); 318 if (snd_BUG_ON(!cell))
319 return -EINVAL;
319 dest = cell->event.queue; /* destination queue */ 320 dest = cell->event.queue; /* destination queue */
320 q = queueptr(dest); 321 q = queueptr(dest);
321 if (q == NULL) 322 if (q == NULL)
@@ -734,7 +735,8 @@ int snd_seq_control_queue(struct snd_seq_event *ev, int atomic, int hop)
734{ 735{
735 struct snd_seq_queue *q; 736 struct snd_seq_queue *q;
736 737
737 snd_assert(ev != NULL, return -EINVAL); 738 if (snd_BUG_ON(!ev))
739 return -EINVAL;
738 q = queueptr(ev->data.queue.queue); 740 q = queueptr(ev->data.queue.queue);
739 741
740 if (q == NULL) 742 if (q == NULL)
diff --git a/sound/core/seq/seq_timer.c b/sound/core/seq/seq_timer.c
index d8fcd62e400f..f745c317d6af 100644
--- a/sound/core/seq/seq_timer.c
+++ b/sound/core/seq/seq_timer.c
@@ -173,7 +173,8 @@ int snd_seq_timer_set_tempo(struct snd_seq_timer * tmr, int tempo)
173{ 173{
174 unsigned long flags; 174 unsigned long flags;
175 175
176 snd_assert(tmr, return -EINVAL); 176 if (snd_BUG_ON(!tmr))
177 return -EINVAL;
177 if (tempo <= 0) 178 if (tempo <= 0)
178 return -EINVAL; 179 return -EINVAL;
179 spin_lock_irqsave(&tmr->lock, flags); 180 spin_lock_irqsave(&tmr->lock, flags);
@@ -190,7 +191,8 @@ int snd_seq_timer_set_ppq(struct snd_seq_timer * tmr, int ppq)
190{ 191{
191 unsigned long flags; 192 unsigned long flags;
192 193
193 snd_assert(tmr, return -EINVAL); 194 if (snd_BUG_ON(!tmr))
195 return -EINVAL;
194 if (ppq <= 0) 196 if (ppq <= 0)
195 return -EINVAL; 197 return -EINVAL;
196 spin_lock_irqsave(&tmr->lock, flags); 198 spin_lock_irqsave(&tmr->lock, flags);
@@ -214,7 +216,8 @@ int snd_seq_timer_set_position_tick(struct snd_seq_timer *tmr,
214{ 216{
215 unsigned long flags; 217 unsigned long flags;
216 218
217 snd_assert(tmr, return -EINVAL); 219 if (snd_BUG_ON(!tmr))
220 return -EINVAL;
218 221
219 spin_lock_irqsave(&tmr->lock, flags); 222 spin_lock_irqsave(&tmr->lock, flags);
220 tmr->tick.cur_tick = position; 223 tmr->tick.cur_tick = position;
@@ -229,7 +232,8 @@ int snd_seq_timer_set_position_time(struct snd_seq_timer *tmr,
229{ 232{
230 unsigned long flags; 233 unsigned long flags;
231 234
232 snd_assert(tmr, return -EINVAL); 235 if (snd_BUG_ON(!tmr))
236 return -EINVAL;
233 237
234 snd_seq_sanity_real_time(&position); 238 snd_seq_sanity_real_time(&position);
235 spin_lock_irqsave(&tmr->lock, flags); 239 spin_lock_irqsave(&tmr->lock, flags);
@@ -244,7 +248,8 @@ int snd_seq_timer_set_skew(struct snd_seq_timer *tmr, unsigned int skew,
244{ 248{
245 unsigned long flags; 249 unsigned long flags;
246 250
247 snd_assert(tmr, return -EINVAL); 251 if (snd_BUG_ON(!tmr))
252 return -EINVAL;
248 253
249 /* FIXME */ 254 /* FIXME */
250 if (base != SKEW_BASE) { 255 if (base != SKEW_BASE) {
@@ -265,7 +270,8 @@ int snd_seq_timer_open(struct snd_seq_queue *q)
265 int err; 270 int err;
266 271
267 tmr = q->timer; 272 tmr = q->timer;
268 snd_assert(tmr != NULL, return -EINVAL); 273 if (snd_BUG_ON(!tmr))
274 return -EINVAL;
269 if (tmr->timeri) 275 if (tmr->timeri)
270 return -EBUSY; 276 return -EBUSY;
271 sprintf(str, "sequencer queue %i", q->queue); 277 sprintf(str, "sequencer queue %i", q->queue);
@@ -302,7 +308,8 @@ int snd_seq_timer_close(struct snd_seq_queue *q)
302 struct snd_seq_timer *tmr; 308 struct snd_seq_timer *tmr;
303 309
304 tmr = q->timer; 310 tmr = q->timer;
305 snd_assert(tmr != NULL, return -EINVAL); 311 if (snd_BUG_ON(!tmr))
312 return -EINVAL;
306 if (tmr->timeri) { 313 if (tmr->timeri) {
307 snd_timer_stop(tmr->timeri); 314 snd_timer_stop(tmr->timeri);
308 snd_timer_close(tmr->timeri); 315 snd_timer_close(tmr->timeri);
@@ -328,7 +335,8 @@ static int initialize_timer(struct snd_seq_timer *tmr)
328 unsigned long freq; 335 unsigned long freq;
329 336
330 t = tmr->timeri->timer; 337 t = tmr->timeri->timer;
331 snd_assert(t, return -EINVAL); 338 if (snd_BUG_ON(!t))
339 return -EINVAL;
332 340
333 freq = tmr->preferred_resolution; 341 freq = tmr->preferred_resolution;
334 if (!freq) 342 if (!freq)
diff --git a/sound/core/sound.c b/sound/core/sound.c
index 838dd9ee957c..c0685e2f0afa 100644
--- a/sound/core/sound.c
+++ b/sound/core/sound.c
@@ -206,20 +206,23 @@ static int snd_kernel_minor(int type, struct snd_card *card, int dev)
206 minor = type; 206 minor = type;
207 break; 207 break;
208 case SNDRV_DEVICE_TYPE_CONTROL: 208 case SNDRV_DEVICE_TYPE_CONTROL:
209 snd_assert(card != NULL, return -EINVAL); 209 if (snd_BUG_ON(!card))
210 return -EINVAL;
210 minor = SNDRV_MINOR(card->number, type); 211 minor = SNDRV_MINOR(card->number, type);
211 break; 212 break;
212 case SNDRV_DEVICE_TYPE_HWDEP: 213 case SNDRV_DEVICE_TYPE_HWDEP:
213 case SNDRV_DEVICE_TYPE_RAWMIDI: 214 case SNDRV_DEVICE_TYPE_RAWMIDI:
214 case SNDRV_DEVICE_TYPE_PCM_PLAYBACK: 215 case SNDRV_DEVICE_TYPE_PCM_PLAYBACK:
215 case SNDRV_DEVICE_TYPE_PCM_CAPTURE: 216 case SNDRV_DEVICE_TYPE_PCM_CAPTURE:
216 snd_assert(card != NULL, return -EINVAL); 217 if (snd_BUG_ON(!card))
218 return -EINVAL;
217 minor = SNDRV_MINOR(card->number, type + dev); 219 minor = SNDRV_MINOR(card->number, type + dev);
218 break; 220 break;
219 default: 221 default:
220 return -EINVAL; 222 return -EINVAL;
221 } 223 }
222 snd_assert(minor >= 0 && minor < SNDRV_OS_MINORS, return -EINVAL); 224 if (snd_BUG_ON(minor < 0 || minor >= SNDRV_OS_MINORS))
225 return -EINVAL;
223 return minor; 226 return minor;
224} 227}
225#endif 228#endif
@@ -247,7 +250,8 @@ int snd_register_device_for_dev(int type, struct snd_card *card, int dev,
247 int minor; 250 int minor;
248 struct snd_minor *preg; 251 struct snd_minor *preg;
249 252
250 snd_assert(name, return -EINVAL); 253 if (snd_BUG_ON(!name))
254 return -EINVAL;
251 preg = kmalloc(sizeof *preg, GFP_KERNEL); 255 preg = kmalloc(sizeof *preg, GFP_KERNEL);
252 if (preg == NULL) 256 if (preg == NULL)
253 return -ENOMEM; 257 return -ENOMEM;
diff --git a/sound/core/sound_oss.c b/sound/core/sound_oss.c
index 7be51546eb9e..7fe12264ff80 100644
--- a/sound/core/sound_oss.c
+++ b/sound/core/sound_oss.c
@@ -64,7 +64,8 @@ static int snd_oss_kernel_minor(int type, struct snd_card *card, int dev)
64 64
65 switch (type) { 65 switch (type) {
66 case SNDRV_OSS_DEVICE_TYPE_MIXER: 66 case SNDRV_OSS_DEVICE_TYPE_MIXER:
67 snd_assert(card != NULL && dev <= 1, return -EINVAL); 67 if (snd_BUG_ON(!card || dev < 0 || dev > 1))
68 return -EINVAL;
68 minor = SNDRV_MINOR_OSS(card->number, (dev ? SNDRV_MINOR_OSS_MIXER1 : SNDRV_MINOR_OSS_MIXER)); 69 minor = SNDRV_MINOR_OSS(card->number, (dev ? SNDRV_MINOR_OSS_MIXER1 : SNDRV_MINOR_OSS_MIXER));
69 break; 70 break;
70 case SNDRV_OSS_DEVICE_TYPE_SEQUENCER: 71 case SNDRV_OSS_DEVICE_TYPE_SEQUENCER:
@@ -74,11 +75,13 @@ static int snd_oss_kernel_minor(int type, struct snd_card *card, int dev)
74 minor = SNDRV_MINOR_OSS_MUSIC; 75 minor = SNDRV_MINOR_OSS_MUSIC;
75 break; 76 break;
76 case SNDRV_OSS_DEVICE_TYPE_PCM: 77 case SNDRV_OSS_DEVICE_TYPE_PCM:
77 snd_assert(card != NULL && dev <= 1, return -EINVAL); 78 if (snd_BUG_ON(!card || dev < 0 || dev > 1))
79 return -EINVAL;
78 minor = SNDRV_MINOR_OSS(card->number, (dev ? SNDRV_MINOR_OSS_PCM1 : SNDRV_MINOR_OSS_PCM)); 80 minor = SNDRV_MINOR_OSS(card->number, (dev ? SNDRV_MINOR_OSS_PCM1 : SNDRV_MINOR_OSS_PCM));
79 break; 81 break;
80 case SNDRV_OSS_DEVICE_TYPE_MIDI: 82 case SNDRV_OSS_DEVICE_TYPE_MIDI:
81 snd_assert(card != NULL && dev <= 1, return -EINVAL); 83 if (snd_BUG_ON(!card || dev < 0 || dev > 1))
84 return -EINVAL;
82 minor = SNDRV_MINOR_OSS(card->number, (dev ? SNDRV_MINOR_OSS_MIDI1 : SNDRV_MINOR_OSS_MIDI)); 85 minor = SNDRV_MINOR_OSS(card->number, (dev ? SNDRV_MINOR_OSS_MIDI1 : SNDRV_MINOR_OSS_MIDI));
83 break; 86 break;
84 case SNDRV_OSS_DEVICE_TYPE_DMFM: 87 case SNDRV_OSS_DEVICE_TYPE_DMFM:
@@ -90,7 +93,8 @@ static int snd_oss_kernel_minor(int type, struct snd_card *card, int dev)
90 default: 93 default:
91 return -EINVAL; 94 return -EINVAL;
92 } 95 }
93 snd_assert(minor >= 0 && minor < SNDRV_OSS_MINORS, return -EINVAL); 96 if (snd_BUG_ON(minor < 0 || minor >= SNDRV_OSS_MINORS))
97 return -EINVAL;
94 return minor; 98 return minor;
95} 99}
96 100
diff --git a/sound/core/timer.c b/sound/core/timer.c
index 0af337efc64e..b8ee49c1f855 100644
--- a/sound/core/timer.c
+++ b/sound/core/timer.c
@@ -306,7 +306,8 @@ int snd_timer_close(struct snd_timer_instance *timeri)
306 struct snd_timer *timer = NULL; 306 struct snd_timer *timer = NULL;
307 struct snd_timer_instance *slave, *tmp; 307 struct snd_timer_instance *slave, *tmp;
308 308
309 snd_assert(timeri != NULL, return -ENXIO); 309 if (snd_BUG_ON(!timer))
310 return -ENXIO;
310 311
311 /* force to stop the timer */ 312 /* force to stop the timer */
312 snd_timer_stop(timeri); 313 snd_timer_stop(timeri);
@@ -385,8 +386,9 @@ static void snd_timer_notify1(struct snd_timer_instance *ti, int event)
385 do_posix_clock_monotonic_gettime(&tstamp); 386 do_posix_clock_monotonic_gettime(&tstamp);
386 else 387 else
387 getnstimeofday(&tstamp); 388 getnstimeofday(&tstamp);
388 snd_assert(event >= SNDRV_TIMER_EVENT_START && 389 if (snd_BUG_ON(event < SNDRV_TIMER_EVENT_START ||
389 event <= SNDRV_TIMER_EVENT_PAUSE, return); 390 event > SNDRV_TIMER_EVENT_PAUSE))
391 return;
390 if (event == SNDRV_TIMER_EVENT_START || 392 if (event == SNDRV_TIMER_EVENT_START ||
391 event == SNDRV_TIMER_EVENT_CONTINUE) 393 event == SNDRV_TIMER_EVENT_CONTINUE)
392 resolution = snd_timer_resolution(ti); 394 resolution = snd_timer_resolution(ti);
@@ -474,7 +476,8 @@ static int _snd_timer_stop(struct snd_timer_instance * timeri,
474 struct snd_timer *timer; 476 struct snd_timer *timer;
475 unsigned long flags; 477 unsigned long flags;
476 478
477 snd_assert(timeri != NULL, return -ENXIO); 479 if (snd_BUG_ON(!timeri))
480 return -ENXIO;
478 481
479 if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE) { 482 if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE) {
480 if (!keep_flag) { 483 if (!keep_flag) {
@@ -758,9 +761,10 @@ int snd_timer_new(struct snd_card *card, char *id, struct snd_timer_id *tid,
758 .dev_disconnect = snd_timer_dev_disconnect, 761 .dev_disconnect = snd_timer_dev_disconnect,
759 }; 762 };
760 763
761 snd_assert(tid != NULL, return -EINVAL); 764 if (snd_BUG_ON(!tid))
762 snd_assert(rtimer != NULL, return -EINVAL); 765 return -EINVAL;
763 *rtimer = NULL; 766 if (rtimer)
767 *rtimer = NULL;
764 timer = kzalloc(sizeof(*timer), GFP_KERNEL); 768 timer = kzalloc(sizeof(*timer), GFP_KERNEL);
765 if (timer == NULL) { 769 if (timer == NULL) {
766 snd_printk(KERN_ERR "timer: cannot allocate\n"); 770 snd_printk(KERN_ERR "timer: cannot allocate\n");
@@ -788,13 +792,15 @@ int snd_timer_new(struct snd_card *card, char *id, struct snd_timer_id *tid,
788 return err; 792 return err;
789 } 793 }
790 } 794 }
791 *rtimer = timer; 795 if (rtimer)
796 *rtimer = timer;
792 return 0; 797 return 0;
793} 798}
794 799
795static int snd_timer_free(struct snd_timer *timer) 800static int snd_timer_free(struct snd_timer *timer)
796{ 801{
797 snd_assert(timer != NULL, return -ENXIO); 802 if (!timer)
803 return 0;
798 804
799 mutex_lock(&register_mutex); 805 mutex_lock(&register_mutex);
800 if (! list_empty(&timer->open_list_head)) { 806 if (! list_empty(&timer->open_list_head)) {
@@ -827,8 +833,8 @@ static int snd_timer_dev_register(struct snd_device *dev)
827 struct snd_timer *timer = dev->device_data; 833 struct snd_timer *timer = dev->device_data;
828 struct snd_timer *timer1; 834 struct snd_timer *timer1;
829 835
830 snd_assert(timer != NULL && timer->hw.start != NULL && 836 if (snd_BUG_ON(!timer || !timer->hw.start || !timer->hw.stop))
831 timer->hw.stop != NULL, return -ENXIO); 837 return -ENXIO;
832 if (!(timer->hw.flags & SNDRV_TIMER_HW_SLAVE) && 838 if (!(timer->hw.flags & SNDRV_TIMER_HW_SLAVE) &&
833 !timer->hw.resolution && timer->hw.c_resolution == NULL) 839 !timer->hw.resolution && timer->hw.c_resolution == NULL)
834 return -EINVAL; 840 return -EINVAL;
@@ -879,8 +885,9 @@ void snd_timer_notify(struct snd_timer *timer, int event, struct timespec *tstam
879 885
880 if (! (timer->hw.flags & SNDRV_TIMER_HW_SLAVE)) 886 if (! (timer->hw.flags & SNDRV_TIMER_HW_SLAVE))
881 return; 887 return;
882 snd_assert(event >= SNDRV_TIMER_EVENT_MSTART && 888 if (snd_BUG_ON(event < SNDRV_TIMER_EVENT_MSTART ||
883 event <= SNDRV_TIMER_EVENT_MRESUME, return); 889 event > SNDRV_TIMER_EVENT_MRESUME))
890 return;
884 spin_lock_irqsave(&timer->lock, flags); 891 spin_lock_irqsave(&timer->lock, flags);
885 if (event == SNDRV_TIMER_EVENT_MSTART || 892 if (event == SNDRV_TIMER_EVENT_MSTART ||
886 event == SNDRV_TIMER_EVENT_MCONTINUE || 893 event == SNDRV_TIMER_EVENT_MCONTINUE ||
diff --git a/sound/core/timer_compat.c b/sound/core/timer_compat.c
index 5512f5373c52..e05802ae6e1b 100644
--- a/sound/core/timer_compat.c
+++ b/sound/core/timer_compat.c
@@ -40,9 +40,11 @@ static int snd_timer_user_info_compat(struct file *file,
40 struct snd_timer *t; 40 struct snd_timer *t;
41 41
42 tu = file->private_data; 42 tu = file->private_data;
43 snd_assert(tu->timeri != NULL, return -ENXIO); 43 if (snd_BUG_ON(!tu->timeri))
44 return -ENXIO;
44 t = tu->timeri->timer; 45 t = tu->timeri->timer;
45 snd_assert(t != NULL, return -ENXIO); 46 if (snd_BUG_ON(!t))
47 return -ENXIO;
46 memset(&info, 0, sizeof(info)); 48 memset(&info, 0, sizeof(info));
47 info.card = t->card ? t->card->number : -1; 49 info.card = t->card ? t->card->number : -1;
48 if (t->hw.flags & SNDRV_TIMER_HW_SLAVE) 50 if (t->hw.flags & SNDRV_TIMER_HW_SLAVE)
@@ -71,7 +73,8 @@ static int snd_timer_user_status_compat(struct file *file,
71 struct snd_timer_status status; 73 struct snd_timer_status status;
72 74
73 tu = file->private_data; 75 tu = file->private_data;
74 snd_assert(tu->timeri != NULL, return -ENXIO); 76 if (snd_BUG_ON(!tu->timeri))
77 return -ENXIO;
75 memset(&status, 0, sizeof(status)); 78 memset(&status, 0, sizeof(status));
76 status.tstamp = tu->tstamp; 79 status.tstamp = tu->tstamp;
77 status.resolution = snd_timer_resolution(tu->timeri); 80 status.resolution = snd_timer_resolution(tu->timeri);
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-20 03:26:00 -0500