lisa/android_kernel_xiaomi_sm8350
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ALSA: pcm: Set per-card upper limit of PCM buffer allocations

Browse Source 
[ Upstream commit d4cfb30fce03093ad944e0b44bd8f40bdad5330e ]

Currently, the available buffer allocation size for a PCM stream
depends on the preallocated size; when a buffer has been preallocated,
the max buffer size is set to that size, so that application won't
re-allocate too much memory.  OTOH, when no preallocation is done,
each substream may allocate arbitrary size of buffers as long as
snd_pcm_hardware.buffer_bytes_max allows -- which can be quite high,
HD-audio sets 1GB there.

It means that the system may consume a high amount of pages for PCM
buffers, and they are pinned and never swapped out.  This can lead to
OOM easily.

For avoiding such a situation, this patch adds the upper limit per
card.  Each snd_pcm_lib_malloc_pages() and _free_pages() calls are
tracked and it will return an error if the total amount of buffers
goes over the defined upper limit.  The default value is set to 32MB,
which should be really large enough for usual operations.

If larger buffers are needed for any specific usage, it can be
adjusted (also dynamically) via snd_pcm.max_alloc_per_card option.
Setting zero there means no chceck is performed, and again, unlimited
amount of buffers are allowed.

Link: https://lore.kernel.org/r/20200120124423.11862-1-tiwai@suse.de
Signed-off-by: Takashi Iwai <tiwai@suse.de>
Stable-dep-of: bd55842ed998 ("ALSA: pcm: Fix potential data race at PCM memory allocation helpers")
Signed-off-by: Sasha Levin <sashal@kernel.org>
This commit is contained in:
Takashi Iwai 2020-01-20 13:44:22 +01:00 committed by Greg Kroah-Hartman
parent d0ef103e19
commit 95b30a4312
3 changed files with 55 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
include/sound/core.h
View File

@ -119,6 +119,9 @@ struct snd_card {
bool registered; /* card_dev is registered? */ bool registered; /* card_dev is registered? */
wait_queue_head_t remove_sleep; wait_queue_head_t remove_sleep;
size_t total_pcm_alloc_bytes; /* total amount of allocated buffers */
struct mutex memory_mutex; /* protection for the above */
#ifdef CONFIG_PM #ifdef CONFIG_PM
unsigned int power_state; /* power state */ unsigned int power_state; /* power state */
wait_queue_head_t power_sleep; wait_queue_head_t power_sleep;

1
sound/core/init.c
View File

@ -211,6 +211,7 @@ int snd_card_new(struct device *parent, int idx, const char *xid,
INIT_LIST_HEAD(&card->ctl_files); INIT_LIST_HEAD(&card->ctl_files);
spin_lock_init(&card->files_lock); spin_lock_init(&card->files_lock);
INIT_LIST_HEAD(&card->files_list); INIT_LIST_HEAD(&card->files_list);
mutex_init(&card->memory_mutex);
#ifdef CONFIG_PM #ifdef CONFIG_PM
init_waitqueue_head(&card->power_sleep); init_waitqueue_head(&card->power_sleep);
#endif #endif

69
sound/core/pcm_memory.c
View File

@ -26,6 +26,38 @@ MODULE_PARM_DESC(maximum_substreams, "Maximum substreams with preallocated DMA m
static const size_t snd_minimum_buffer = 16384; static const size_t snd_minimum_buffer = 16384;
static unsigned long max_alloc_per_card = 32UL * 1024UL * 1024UL;
module_param(max_alloc_per_card, ulong, 0644);
MODULE_PARM_DESC(max_alloc_per_card, "Max total allocation bytes per card.");
static int do_alloc_pages(struct snd_card *card, int type, struct device *dev,
size_t size, struct snd_dma_buffer *dmab)
{
int err;
if (max_alloc_per_card &&
card->total_pcm_alloc_bytes + size > max_alloc_per_card)
return -ENOMEM;
err = snd_dma_alloc_pages(type, dev, size, dmab);
if (!err) {
mutex_lock(&card->memory_mutex);
card->total_pcm_alloc_bytes += dmab->bytes;
mutex_unlock(&card->memory_mutex);
}
return err;
}
static void do_free_pages(struct snd_card *card, struct snd_dma_buffer *dmab)
{
if (!dmab->area)
return;
mutex_lock(&card->memory_mutex);
WARN_ON(card->total_pcm_alloc_bytes < dmab->bytes);
card->total_pcm_alloc_bytes -= dmab->bytes;
mutex_unlock(&card->memory_mutex);
snd_dma_free_pages(dmab);
dmab->area = NULL;
}
/* /*
* try to allocate as the large pages as possible. * try to allocate as the large pages as possible.
@ -36,16 +68,15 @@ static const size_t snd_minimum_buffer = 16384;
static int preallocate_pcm_pages(struct snd_pcm_substream *substream, size_t size) static int preallocate_pcm_pages(struct snd_pcm_substream *substream, size_t size)
{ {
struct snd_dma_buffer *dmab = &substream->dma_buffer; struct snd_dma_buffer *dmab = &substream->dma_buffer;
struct snd_card *card = substream->pcm->card;
size_t orig_size = size; size_t orig_size = size;
int err; int err;
do { do {
if ((err = snd_dma_alloc_pages(dmab->dev.type, dmab->dev.dev, err = do_alloc_pages(card, dmab->dev.type, dmab->dev.dev,
size, dmab)) < 0) { size, dmab);
if (err != -ENOMEM) if (err != -ENOMEM)
return err; /* fatal error */ return err;
} else
return 0;
size >>= 1; size >>= 1;
} while (size >= snd_minimum_buffer); } while (size >= snd_minimum_buffer);
dmab->bytes = 0; /* tell error */ dmab->bytes = 0; /* tell error */
@ -61,10 +92,7 @@ static int preallocate_pcm_pages(struct snd_pcm_substream *substream, size_t siz
*/ */
static void snd_pcm_lib_preallocate_dma_free(struct snd_pcm_substream *substream) static void snd_pcm_lib_preallocate_dma_free(struct snd_pcm_substream *substream)
{ {
if (substream->dma_buffer.area == NULL) do_free_pages(substream->pcm->card, &substream->dma_buffer);
return;
snd_dma_free_pages(&substream->dma_buffer);
substream->dma_buffer.area = NULL;
} }
/** /**
@ -129,6 +157,7 @@ static void snd_pcm_lib_preallocate_proc_write(struct snd_info_entry *entry,
struct snd_info_buffer *buffer) struct snd_info_buffer *buffer)
{ {
struct snd_pcm_substream *substream = entry->private_data; struct snd_pcm_substream *substream = entry->private_data;
struct snd_card *card = substream->pcm->card;
char line[64], str[64]; char line[64], str[64];
size_t size; size_t size;
struct snd_dma_buffer new_dmab; struct snd_dma_buffer new_dmab;
@ -150,9 +179,10 @@ static void snd_pcm_lib_preallocate_proc_write(struct snd_info_entry *entry,
memset(&new_dmab, 0, sizeof(new_dmab)); memset(&new_dmab, 0, sizeof(new_dmab));
new_dmab.dev = substream->dma_buffer.dev; new_dmab.dev = substream->dma_buffer.dev;
if (size > 0) { if (size > 0) {
if (snd_dma_alloc_pages(substream->dma_buffer.dev.type, if (do_alloc_pages(card,
substream->dma_buffer.dev.dev, substream->dma_buffer.dev.type,
size, &new_dmab) < 0) { substream->dma_buffer.dev.dev,
size, &new_dmab) < 0) {
buffer->error = -ENOMEM; buffer->error = -ENOMEM;
goto unlock; goto unlock;
} }
@ -161,7 +191,7 @@ static void snd_pcm_lib_preallocate_proc_write(struct snd_info_entry *entry,
substream->buffer_bytes_max = UINT_MAX; substream->buffer_bytes_max = UINT_MAX;
} }
if (substream->dma_buffer.area) if (substream->dma_buffer.area)
snd_dma_free_pages(&substream->dma_buffer); do_free_pages(card, &substream->dma_buffer);
substream->dma_buffer = new_dmab; substream->dma_buffer = new_dmab;
} else { } else {
buffer->error = -EINVAL; buffer->error = -EINVAL;
@ -289,6 +319,7 @@ EXPORT_SYMBOL(snd_pcm_sgbuf_ops_page);
*/ */
int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size) int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size)
{ {
struct snd_card *card = substream->pcm->card;
struct snd_pcm_runtime *runtime; struct snd_pcm_runtime *runtime;
struct snd_dma_buffer *dmab = NULL; struct snd_dma_buffer *dmab = NULL;
@ -317,9 +348,10 @@ int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size)
if (! dmab) if (! dmab)
return -ENOMEM; return -ENOMEM;
dmab->dev = substream->dma_buffer.dev; dmab->dev = substream->dma_buffer.dev;
if (snd_dma_alloc_pages(substream->dma_buffer.dev.type, if (do_alloc_pages(card,
substream->dma_buffer.dev.dev, substream->dma_buffer.dev.type,
size, dmab) < 0) { substream->dma_buffer.dev.dev,
size, dmab) < 0) {
kfree(dmab); kfree(dmab);
return -ENOMEM; return -ENOMEM;
} }
@ -340,6 +372,7 @@ EXPORT_SYMBOL(snd_pcm_lib_malloc_pages);
*/ */
int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream) int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream)
{ {
struct snd_card *card = substream->pcm->card;
struct snd_pcm_runtime *runtime; struct snd_pcm_runtime *runtime;
if (PCM_RUNTIME_CHECK(substream)) if (PCM_RUNTIME_CHECK(substream))
@ -349,7 +382,7 @@ int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream)
return 0; return 0;
if (runtime->dma_buffer_p != &substream->dma_buffer) { if (runtime->dma_buffer_p != &substream->dma_buffer) {
/* it's a newly allocated buffer. release it now. */ /* it's a newly allocated buffer. release it now. */
snd_dma_free_pages(runtime->dma_buffer_p); do_free_pages(card, runtime->dma_buffer_p);
kfree(runtime->dma_buffer_p); kfree(runtime->dma_buffer_p);
} }
snd_pcm_set_runtime_buffer(substream, NULL); snd_pcm_set_runtime_buffer(substream, NULL);