* [PATCH] ALSA: memalloc: Workaround for Xen PV
@ 2023-01-25 15:31 Takashi Iwai
2023-01-26 12:53 ` Marek Marczykowski-Górecki
0 siblings, 1 reply; 2+ messages in thread
From: Takashi Iwai @ 2023-01-25 15:31 UTC (permalink / raw)
To: alsa-devel; +Cc: Marek Marczykowski-Górecki
We change recently the memalloc helper to use
dma_alloc_noncontiguous() and the fallback to get_pages(). Although
lots of issues with IOMMU (or non-IOMMU) have been addressed, but
there seems still a regression on Xen PV. Interestingly, the only
proper way to work is use dma_alloc_coherent(). The use of
dma_alloc_coherent() for SG buffer was dropped as it's problematic on
IOMMU systems. OTOH, Xen PV has a different way, and it's fine to use
the dma_alloc_coherent().
This patch is a workaround for Xen PV. It consists of the following
changes:
- For Xen PV, use only the fallback allocation without
dma_alloc_noncontiguous()
- In the fallback allocation, use dma_alloc_coherent();
the DMA address from dma_alloc_coherent() is returned in get_addr
ops
- The DMA addresses are stored in an array; the first entry stores the
number of allocated pages in lower bits, which are referred at
releasing pages again
Reported-by: Marek Marczykowski-Górecki <marmarek@invisiblethingslab.com>
Fixes: a8d302a0b770 ("ALSA: memalloc: Revive x86-specific WC page allocations again")
Fixes: 9736a325137b ("ALSA: memalloc: Don't fall back for SG-buffer with IOMMU")
Link: https://lore.kernel.org/r/87tu256lqs.wl-tiwai@suse.de
Signed-off-by: Takashi Iwai <tiwai@suse.de>
---
Marek, this is another respin of the fix.
Please check this one and report back. Thanks!
sound/core/memalloc.c | 87 ++++++++++++++++++++++++++++++++++---------
1 file changed, 69 insertions(+), 18 deletions(-)
diff --git a/sound/core/memalloc.c b/sound/core/memalloc.c
index 81025f50a542..f901504b5afc 100644
--- a/sound/core/memalloc.c
+++ b/sound/core/memalloc.c
@@ -541,16 +541,15 @@ static void *snd_dma_noncontig_alloc(struct snd_dma_buffer *dmab, size_t size)
struct sg_table *sgt;
void *p;
+#ifdef CONFIG_SND_DMA_SGBUF
+ if (cpu_feature_enabled(X86_FEATURE_XENPV))
+ return snd_dma_sg_fallback_alloc(dmab, size);
+#endif
sgt = dma_alloc_noncontiguous(dmab->dev.dev, size, dmab->dev.dir,
DEFAULT_GFP, 0);
#ifdef CONFIG_SND_DMA_SGBUF
- if (!sgt && !get_dma_ops(dmab->dev.dev)) {
- if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC_SG)
- dmab->dev.type = SNDRV_DMA_TYPE_DEV_WC_SG_FALLBACK;
- else
- dmab->dev.type = SNDRV_DMA_TYPE_DEV_SG_FALLBACK;
+ if (!sgt && !get_dma_ops(dmab->dev.dev))
return snd_dma_sg_fallback_alloc(dmab, size);
- }
#endif
if (!sgt)
return NULL;
@@ -717,19 +716,38 @@ static const struct snd_malloc_ops snd_dma_sg_wc_ops = {
/* Fallback SG-buffer allocations for x86 */
struct snd_dma_sg_fallback {
+ bool use_dma_alloc_coherent;
size_t count;
struct page **pages;
+ /* DMA address array; the first page contains #pages in ~PAGE_MASK */
+ dma_addr_t *addrs;
};
static void __snd_dma_sg_fallback_free(struct snd_dma_buffer *dmab,
struct snd_dma_sg_fallback *sgbuf)
{
- bool wc = dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC_SG_FALLBACK;
- size_t i;
-
- for (i = 0; i < sgbuf->count && sgbuf->pages[i]; i++)
- do_free_pages(page_address(sgbuf->pages[i]), PAGE_SIZE, wc);
+ size_t i, size;
+
+ if (sgbuf->pages && sgbuf->addrs) {
+ i = 0;
+ while (i < sgbuf->count) {
+ if (!sgbuf->pages[i] || !sgbuf->addrs[i])
+ break;
+ size = sgbuf->addrs[i] & ~PAGE_MASK;
+ if (WARN_ON(!size))
+ break;
+ if (sgbuf->use_dma_alloc_coherent)
+ dma_free_coherent(dmab->dev.dev, size << PAGE_SHIFT,
+ page_address(sgbuf->pages[i]),
+ sgbuf->addrs[i] & PAGE_MASK);
+ else
+ do_free_pages(page_address(sgbuf->pages[i]),
+ size << PAGE_SHIFT, false);
+ i += size;
+ }
+ }
kvfree(sgbuf->pages);
+ kvfree(sgbuf->addrs);
kfree(sgbuf);
}
@@ -738,24 +756,36 @@ static void *snd_dma_sg_fallback_alloc(struct snd_dma_buffer *dmab, size_t size)
struct snd_dma_sg_fallback *sgbuf;
struct page **pagep, *curp;
size_t chunk, npages;
+ dma_addr_t *addrp;
dma_addr_t addr;
void *p;
- bool wc = dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC_SG_FALLBACK;
+
+ /* correct the type */
+ if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_SG)
+ dmab->dev.type = SNDRV_DMA_TYPE_DEV_SG_FALLBACK;
+ else if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC_SG)
+ dmab->dev.type = SNDRV_DMA_TYPE_DEV_WC_SG_FALLBACK;
sgbuf = kzalloc(sizeof(*sgbuf), GFP_KERNEL);
if (!sgbuf)
return NULL;
+ sgbuf->use_dma_alloc_coherent = cpu_feature_enabled(X86_FEATURE_XENPV);
size = PAGE_ALIGN(size);
sgbuf->count = size >> PAGE_SHIFT;
sgbuf->pages = kvcalloc(sgbuf->count, sizeof(*sgbuf->pages), GFP_KERNEL);
- if (!sgbuf->pages)
+ sgbuf->addrs = kvcalloc(sgbuf->count, sizeof(*sgbuf->addrs), GFP_KERNEL);
+ if (!sgbuf->pages || !sgbuf->addrs)
goto error;
pagep = sgbuf->pages;
- chunk = size;
+ addrp = sgbuf->addrs;
+ chunk = (PAGE_SIZE - 1) << PAGE_SHIFT; /* to fit in low bits in addrs */
while (size > 0) {
chunk = min(size, chunk);
- p = do_alloc_pages(dmab->dev.dev, chunk, &addr, wc);
+ if (sgbuf->use_dma_alloc_coherent)
+ p = dma_alloc_coherent(dmab->dev.dev, chunk, &addr, DEFAULT_GFP);
+ else
+ p = do_alloc_pages(dmab->dev.dev, chunk, &addr, false);
if (!p) {
if (chunk <= PAGE_SIZE)
goto error;
@@ -767,17 +797,25 @@ static void *snd_dma_sg_fallback_alloc(struct snd_dma_buffer *dmab, size_t size)
size -= chunk;
/* fill pages */
npages = chunk >> PAGE_SHIFT;
+ *addrp = npages; /* store in lower bits */
curp = virt_to_page(p);
- while (npages--)
+ while (npages--) {
*pagep++ = curp++;
+ *addrp++ |= addr;
+ addr += PAGE_SIZE;
+ }
}
p = vmap(sgbuf->pages, sgbuf->count, VM_MAP, PAGE_KERNEL);
if (!p)
goto error;
+
+ if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC_SG_FALLBACK)
+ set_pages_array_wc(sgbuf->pages, sgbuf->count);
+
dmab->private_data = sgbuf;
/* store the first page address for convenience */
- dmab->addr = snd_sgbuf_get_addr(dmab, 0);
+ dmab->addr = sgbuf->addrs[0] & PAGE_MASK;
return p;
error:
@@ -787,10 +825,23 @@ static void *snd_dma_sg_fallback_alloc(struct snd_dma_buffer *dmab, size_t size)
static void snd_dma_sg_fallback_free(struct snd_dma_buffer *dmab)
{
+ struct snd_dma_sg_fallback *sgbuf = dmab->private_data;
+
+ if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC_SG_FALLBACK)
+ set_pages_array_wb(sgbuf->pages, sgbuf->count);
vunmap(dmab->area);
__snd_dma_sg_fallback_free(dmab, dmab->private_data);
}
+static dma_addr_t snd_dma_sg_fallback_get_addr(struct snd_dma_buffer *dmab,
+ size_t offset)
+{
+ struct snd_dma_sg_fallback *sgbuf = dmab->private_data;
+ size_t index = offset >> PAGE_SHIFT;
+
+ return (sgbuf->addrs[index] & PAGE_MASK) | (offset & ~PAGE_MASK);
+}
+
static int snd_dma_sg_fallback_mmap(struct snd_dma_buffer *dmab,
struct vm_area_struct *area)
{
@@ -805,8 +856,8 @@ static const struct snd_malloc_ops snd_dma_sg_fallback_ops = {
.alloc = snd_dma_sg_fallback_alloc,
.free = snd_dma_sg_fallback_free,
.mmap = snd_dma_sg_fallback_mmap,
+ .get_addr = snd_dma_sg_fallback_get_addr,
/* reuse vmalloc helpers */
- .get_addr = snd_dma_vmalloc_get_addr,
.get_page = snd_dma_vmalloc_get_page,
.get_chunk_size = snd_dma_vmalloc_get_chunk_size,
};
--
2.35.3
^ permalink raw reply related [flat|nested] 2+ messages in thread
* Re: [PATCH] ALSA: memalloc: Workaround for Xen PV
2023-01-25 15:31 [PATCH] ALSA: memalloc: Workaround for Xen PV Takashi Iwai
@ 2023-01-26 12:53 ` Marek Marczykowski-Górecki
0 siblings, 0 replies; 2+ messages in thread
From: Marek Marczykowski-Górecki @ 2023-01-26 12:53 UTC (permalink / raw)
To: Takashi Iwai; +Cc: alsa-devel
[-- Attachment #1: Type: text/plain, Size: 7973 bytes --]
On Wed, Jan 25, 2023 at 04:31:04PM +0100, Takashi Iwai wrote:
> We change recently the memalloc helper to use
> dma_alloc_noncontiguous() and the fallback to get_pages(). Although
> lots of issues with IOMMU (or non-IOMMU) have been addressed, but
> there seems still a regression on Xen PV. Interestingly, the only
> proper way to work is use dma_alloc_coherent(). The use of
> dma_alloc_coherent() for SG buffer was dropped as it's problematic on
> IOMMU systems. OTOH, Xen PV has a different way, and it's fine to use
> the dma_alloc_coherent().
>
> This patch is a workaround for Xen PV. It consists of the following
> changes:
> - For Xen PV, use only the fallback allocation without
> dma_alloc_noncontiguous()
> - In the fallback allocation, use dma_alloc_coherent();
> the DMA address from dma_alloc_coherent() is returned in get_addr
> ops
> - The DMA addresses are stored in an array; the first entry stores the
> number of allocated pages in lower bits, which are referred at
> releasing pages again
>
> Reported-by: Marek Marczykowski-Górecki <marmarek@invisiblethingslab.com>
> Fixes: a8d302a0b770 ("ALSA: memalloc: Revive x86-specific WC page allocations again")
> Fixes: 9736a325137b ("ALSA: memalloc: Don't fall back for SG-buffer with IOMMU")
> Link: https://lore.kernel.org/r/87tu256lqs.wl-tiwai@suse.de
> Signed-off-by: Takashi Iwai <tiwai@suse.de>
Uptime ~20h and it still works, so
Tested-by: Marek Marczykowski-Górecki <marmarek@invisiblethingslab.com>
> ---
>
> Marek, this is another respin of the fix.
> Please check this one and report back. Thanks!
>
> sound/core/memalloc.c | 87 ++++++++++++++++++++++++++++++++++---------
> 1 file changed, 69 insertions(+), 18 deletions(-)
>
> diff --git a/sound/core/memalloc.c b/sound/core/memalloc.c
> index 81025f50a542..f901504b5afc 100644
> --- a/sound/core/memalloc.c
> +++ b/sound/core/memalloc.c
> @@ -541,16 +541,15 @@ static void *snd_dma_noncontig_alloc(struct snd_dma_buffer *dmab, size_t size)
> struct sg_table *sgt;
> void *p;
>
> +#ifdef CONFIG_SND_DMA_SGBUF
> + if (cpu_feature_enabled(X86_FEATURE_XENPV))
> + return snd_dma_sg_fallback_alloc(dmab, size);
> +#endif
> sgt = dma_alloc_noncontiguous(dmab->dev.dev, size, dmab->dev.dir,
> DEFAULT_GFP, 0);
> #ifdef CONFIG_SND_DMA_SGBUF
> - if (!sgt && !get_dma_ops(dmab->dev.dev)) {
> - if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC_SG)
> - dmab->dev.type = SNDRV_DMA_TYPE_DEV_WC_SG_FALLBACK;
> - else
> - dmab->dev.type = SNDRV_DMA_TYPE_DEV_SG_FALLBACK;
> + if (!sgt && !get_dma_ops(dmab->dev.dev))
> return snd_dma_sg_fallback_alloc(dmab, size);
> - }
> #endif
> if (!sgt)
> return NULL;
> @@ -717,19 +716,38 @@ static const struct snd_malloc_ops snd_dma_sg_wc_ops = {
>
> /* Fallback SG-buffer allocations for x86 */
> struct snd_dma_sg_fallback {
> + bool use_dma_alloc_coherent;
> size_t count;
> struct page **pages;
> + /* DMA address array; the first page contains #pages in ~PAGE_MASK */
> + dma_addr_t *addrs;
> };
>
> static void __snd_dma_sg_fallback_free(struct snd_dma_buffer *dmab,
> struct snd_dma_sg_fallback *sgbuf)
> {
> - bool wc = dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC_SG_FALLBACK;
> - size_t i;
> -
> - for (i = 0; i < sgbuf->count && sgbuf->pages[i]; i++)
> - do_free_pages(page_address(sgbuf->pages[i]), PAGE_SIZE, wc);
> + size_t i, size;
> +
> + if (sgbuf->pages && sgbuf->addrs) {
> + i = 0;
> + while (i < sgbuf->count) {
> + if (!sgbuf->pages[i] || !sgbuf->addrs[i])
> + break;
> + size = sgbuf->addrs[i] & ~PAGE_MASK;
> + if (WARN_ON(!size))
> + break;
> + if (sgbuf->use_dma_alloc_coherent)
> + dma_free_coherent(dmab->dev.dev, size << PAGE_SHIFT,
> + page_address(sgbuf->pages[i]),
> + sgbuf->addrs[i] & PAGE_MASK);
> + else
> + do_free_pages(page_address(sgbuf->pages[i]),
> + size << PAGE_SHIFT, false);
> + i += size;
> + }
> + }
> kvfree(sgbuf->pages);
> + kvfree(sgbuf->addrs);
> kfree(sgbuf);
> }
>
> @@ -738,24 +756,36 @@ static void *snd_dma_sg_fallback_alloc(struct snd_dma_buffer *dmab, size_t size)
> struct snd_dma_sg_fallback *sgbuf;
> struct page **pagep, *curp;
> size_t chunk, npages;
> + dma_addr_t *addrp;
> dma_addr_t addr;
> void *p;
> - bool wc = dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC_SG_FALLBACK;
> +
> + /* correct the type */
> + if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_SG)
> + dmab->dev.type = SNDRV_DMA_TYPE_DEV_SG_FALLBACK;
> + else if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC_SG)
> + dmab->dev.type = SNDRV_DMA_TYPE_DEV_WC_SG_FALLBACK;
>
> sgbuf = kzalloc(sizeof(*sgbuf), GFP_KERNEL);
> if (!sgbuf)
> return NULL;
> + sgbuf->use_dma_alloc_coherent = cpu_feature_enabled(X86_FEATURE_XENPV);
> size = PAGE_ALIGN(size);
> sgbuf->count = size >> PAGE_SHIFT;
> sgbuf->pages = kvcalloc(sgbuf->count, sizeof(*sgbuf->pages), GFP_KERNEL);
> - if (!sgbuf->pages)
> + sgbuf->addrs = kvcalloc(sgbuf->count, sizeof(*sgbuf->addrs), GFP_KERNEL);
> + if (!sgbuf->pages || !sgbuf->addrs)
> goto error;
>
> pagep = sgbuf->pages;
> - chunk = size;
> + addrp = sgbuf->addrs;
> + chunk = (PAGE_SIZE - 1) << PAGE_SHIFT; /* to fit in low bits in addrs */
> while (size > 0) {
> chunk = min(size, chunk);
> - p = do_alloc_pages(dmab->dev.dev, chunk, &addr, wc);
> + if (sgbuf->use_dma_alloc_coherent)
> + p = dma_alloc_coherent(dmab->dev.dev, chunk, &addr, DEFAULT_GFP);
> + else
> + p = do_alloc_pages(dmab->dev.dev, chunk, &addr, false);
> if (!p) {
> if (chunk <= PAGE_SIZE)
> goto error;
> @@ -767,17 +797,25 @@ static void *snd_dma_sg_fallback_alloc(struct snd_dma_buffer *dmab, size_t size)
> size -= chunk;
> /* fill pages */
> npages = chunk >> PAGE_SHIFT;
> + *addrp = npages; /* store in lower bits */
> curp = virt_to_page(p);
> - while (npages--)
> + while (npages--) {
> *pagep++ = curp++;
> + *addrp++ |= addr;
> + addr += PAGE_SIZE;
> + }
> }
>
> p = vmap(sgbuf->pages, sgbuf->count, VM_MAP, PAGE_KERNEL);
> if (!p)
> goto error;
> +
> + if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC_SG_FALLBACK)
> + set_pages_array_wc(sgbuf->pages, sgbuf->count);
> +
> dmab->private_data = sgbuf;
> /* store the first page address for convenience */
> - dmab->addr = snd_sgbuf_get_addr(dmab, 0);
> + dmab->addr = sgbuf->addrs[0] & PAGE_MASK;
> return p;
>
> error:
> @@ -787,10 +825,23 @@ static void *snd_dma_sg_fallback_alloc(struct snd_dma_buffer *dmab, size_t size)
>
> static void snd_dma_sg_fallback_free(struct snd_dma_buffer *dmab)
> {
> + struct snd_dma_sg_fallback *sgbuf = dmab->private_data;
> +
> + if (dmab->dev.type == SNDRV_DMA_TYPE_DEV_WC_SG_FALLBACK)
> + set_pages_array_wb(sgbuf->pages, sgbuf->count);
> vunmap(dmab->area);
> __snd_dma_sg_fallback_free(dmab, dmab->private_data);
> }
>
> +static dma_addr_t snd_dma_sg_fallback_get_addr(struct snd_dma_buffer *dmab,
> + size_t offset)
> +{
> + struct snd_dma_sg_fallback *sgbuf = dmab->private_data;
> + size_t index = offset >> PAGE_SHIFT;
> +
> + return (sgbuf->addrs[index] & PAGE_MASK) | (offset & ~PAGE_MASK);
> +}
> +
> static int snd_dma_sg_fallback_mmap(struct snd_dma_buffer *dmab,
> struct vm_area_struct *area)
> {
> @@ -805,8 +856,8 @@ static const struct snd_malloc_ops snd_dma_sg_fallback_ops = {
> .alloc = snd_dma_sg_fallback_alloc,
> .free = snd_dma_sg_fallback_free,
> .mmap = snd_dma_sg_fallback_mmap,
> + .get_addr = snd_dma_sg_fallback_get_addr,
> /* reuse vmalloc helpers */
> - .get_addr = snd_dma_vmalloc_get_addr,
> .get_page = snd_dma_vmalloc_get_page,
> .get_chunk_size = snd_dma_vmalloc_get_chunk_size,
> };
> --
> 2.35.3
>
--
Best Regards,
Marek Marczykowski-Górecki
Invisible Things Lab
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2023-01-26 12:55 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2023-01-25 15:31 [PATCH] ALSA: memalloc: Workaround for Xen PV Takashi Iwai
2023-01-26 12:53 ` Marek Marczykowski-Górecki
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.