Re: DMA-API attr - DMA_ATTR_NO_KERNEL_MAPPING

[Pankaj Suryawanshi <pankajssuryawanshi@xxxxxxxxx>]

On Mon, Jul 1, 2019 at 7:39 PM Robin Murphy <robin.murphy@xxxxxxx> wrote:

On 28/06/2019 17:29, Pankaj Suryawanshi wrote:
> On Wed, Jun 26, 2019 at 11:21 PM Christoph Hellwig <hch@xxxxxxxxxxxxx> wrote:
>>
>> On Wed, Jun 26, 2019 at 10:12:45PM +0530, Pankaj Suryawanshi wrote:
>>> [CC: linux kernel and Vlastimil Babka]
>>
>> The right list is the list for the DMA mapping subsystem, which is
>> iommu@xxxxxxxxxxxxxxxxxxxxxxxxxx.  I've also added that.
>>
>>>> I am writing driver in which I used DMA_ATTR_NO_KERNEL_MAPPING attribute
>>>> for cma allocation using dma_alloc_attr(), as per kernel docs
>>>> https://www.kernel.org/doc/Documentation/DMA-attributes.txt  buffers
>>>> allocated with this attribute can be only passed to user space by calling
>>>> dma_mmap_attrs().
>>>>
>>>> how can I mapped in kernel space (after dma_alloc_attr with
>>>> DMA_ATTR_NO_KERNEL_MAPPING ) ?
>>
>> You can't.  And that is the whole point of that API.
>
> 1. We can again mapped in kernel space using dma_remap() api , because
> when we are using  DMA_ATTR_NO_KERNEL_MAPPING for dma_alloc_attr it
> returns the page as virtual address(in case of CMA) so we can mapped
> it again using dma_remap().

No, you really can't. A caller of dma_alloc_attrs(...,
DMA_ATTR_NO_KERNEL_MAPPING) cannot make any assumptions about the void*
it returns, other than that it must be handed back to dma_free_attrs()
later. The implementation is free to ignore the flag and give back a
virtual mapping anyway. Any driver which depends on how one particular
implementation on one particular platform happens to behave today is,
essentially, wrong.

Here is the example that i have tried in my driver.

///////////////code snippet/////////////////////////////////////////////////////////////////////////

For CMA allocation using DMA API with DMA_ATTR_NO_KERNEL_MAPPING  :-

if(strcmp("video",info->name) == 0)
        {
        printk("Testing CMA Alloc %s\n", info->name);
        info->dma_virt = dma_alloc_attrs(pmap_device, info->size, &phys, GFP_KERNEL,
                        DMA_ATTR_WRITE_COMBINE | DMA_ATTR_FORCE_CONTIGUOUS | DMA_ATTR_NO_KERNEL_MAPPING);
        if (!info->dma_virt) {
                pr_err("\x1b[31m" "pmap: cma: failed to alloc %s" "\x1b[0m\n",
                                info->name);
                return 0;
        }
                __dma_remap(info->dma_virt, info->size, PAGE_KERNEL); // pgprot we will take from attr
                virt = page_address(info->dma_virt);
        }

For CMA free using DMA api with DMA_ATTR_NO_KERNEL_MAPPING:-

if(strcmp("video",info->name) == 0)
        {
        printk("Testing CMA Release\n");

        __dma_remap(info->dma_virt, info->size, PAGE_KERNEL);
        dma_free_attrs(pmap_device, info->size, info->dma_virt, phys,
                        DMA_ATTR_WRITE_COMBINE | DMA_ATTR_FORCE_CONTIGUOUS | DMA_ATTR_NO_KERNEL_MAPPING);
        }

Flow of Function calls :-

1. static void *__dma_alloc() // .want_vaddr = ((attrs & DMA_ATTR_NO_KERNEL_MAPPING) == 0)

2.cma_allocator :-

                            i.  static void *cma_allocator_alloc ()

                            ii. static void *__alloc_from_contiguous()  // file name :- ./arch/arm/mm/dma-mapping.c

                                                                     if (!want_vaddr)
                                                                                    goto out; // condition true for DMA_ATTR_NO_KERNEL_MAPPING

                                                                     if (PageHighMem(page)) {
                                                                     ptr = __dma_alloc_remap(page, size, GFP_KERNEL, prot, caller);
                                                                     if (!ptr) {
                                                                                dma_release_from_contiguous(dev, page, count);
                                                                                return NULL;
                                                                      }
                                                                     } else {
                                                                     __dma_remap(page, size, prot);
                                                                    ptr = page_address(page);
                                                                     }

                                                                   out:                            
                                                                  *ret_page = page; // return  page
                                                                   return ptr;  // nothing in ptr
                                                                  }

                            iii. struct page *dma_alloc_from_contiguous()

                            iv. cma_alloc()

3. dma_alloc () // returns

return args.want_vaddr ? addr : page; // returns page which is return by alloc_from_contiguous().

What wrong with this if we already know page is returning dma_alloc_attr().

we can use dma_remap in our driver and free as freed in static void __free_from_contiguous ().

Please let me know if i missing anything.

> 2. We can mapped in kernel space using vmap() as used for ion-cma
> https://github.com/torvalds/linux/tree/master/drivers/staging/android/ion
>   as used in function ion_heap_map_kernel().
>
> Please let me know if i am missing anything.

If you want a kernel mapping, *don't* explicitly request not to have a
kernel mapping in the first place. It's that simple.

Do you mean do not use dma-api ? because if i used dma-api it will give you mapped virtual address.

or i have to use directly cma_alloc() in my driver. // if i used this approach i need to reserved more vmalloc area.

Any help would be appreciated.

Robin.