DMA / Microblaze считывает неверные данные после прямого доступа к физическим адресам страниц пользовательского пространства (разброс / сбор ядра)

Я пытаюсь сделать блок памяти в пользовательском пространстве напрямую доступным для ядра DMA на плате FPGA через PCIe (без какого-либо вмешательства со стороны ядра).

Для этого я использую posix_memalign () в пользовательском пространстве, чтобы выделить блок памяти (4M) в пользовательском пространстве, а затем передать его виртуальный адрес ядру с помощью операции записи.

В ядре я использую приведенный ниже код, чтобы получить все страницы блока памяти пользовательского пространства, чтобы создать список Scatter / Gather и получить все физические адреса для каждой страницы:

static ssize_t  posix_memory_write(struct file *file, const char __user *buffer, size_t count, loff_t *off)
{

    int repeat;
    int temporary_point;

    int buffer_mapped_pages;
    int sg_table_value;

    int buffer_dma_buffers = 0;

    u32 *u32_posix_buffer = NULL;

    int buffer_entries = count / PAGE_SIZE;

    struct page **buffer_page_array;

    dma_addr_t *dma_address_list_pointer;
    int *dma_length_list_pointer;

    struct sg_table *dma_sg_table;
    struct scatterlist *scatterlist_pointer;

    if(posix_buffer != NULL)
    {
        printk(KERN_ALERT "%s [DEBUG MESSAGE-POSIX MEMORY WRITE] Buffer's Virtual Address is 0x%016lX\n", driver_name, (unsigned long)posix_buffer);


        u32_posix_buffer = (u32 *)posix_buffer;


        for(repeat = 0; repeat < 16; repeat++)
        {
            printk(KERN_ALERT "%s [DEBUG MESSAGE-POSIX MEMORY WRITE] Buffer Data: %d\n", driver_name, u32_posix_buffer[repeat]);
        }

        buffer_page_array = kmalloc(sizeof(struct page *) * buffer_entries, GFP_KERNEL);

        down_read(&current->mm->mmap_sem);

        buffer_mapped_pages = get_user_pages(current, current->mm, (unsigned long)(posix_buffer), buffer_entries, 1, 0, buffer_page_array, NULL);


        printk(KERN_ALERT "%s [DEBUG MESSAGE-POSIX MEMORY WRITE] Buffer Mapped Pages %d\n", driver_name, buffer_mapped_pages);


        for(repeat = 0; repeat < buffer_mapped_pages; repeat++) 
        {
            if (!PageReserved(buffer_page_array[repeat]))
            {
                SetPageDirty(buffer_page_array[repeat]);
            }
            page_cache_release(buffer_page_array[repeat]);

        }

        up_read(&current->mm->mmap_sem);

        dma_sg_table = kmalloc(sizeof(struct sg_table), GFP_KERNEL);


        sg_table_value = sg_alloc_table(dma_sg_table, buffer_mapped_pages, GFP_KERNEL);


        printk(KERN_ALERT "%s [DEBUG MESSAGE-POSIX MEMORY WRITE] Scatter/Gather Table Return Value %d\n", driver_name, sg_table_value);

        scatterlist_pointer = dma_sg_table->sgl;    

        for(repeat = 0; repeat < buffer_mapped_pages; repeat++)
        {
            sg_set_page(scatterlist_pointer, buffer_page_array[repeat], PAGE_SIZE, 0);
            scatterlist_pointer = sg_next(scatterlist_pointer);
        }


        scatterlist_pointer = dma_sg_table->sgl;

        buffer_dma_buffers = dma_map_sg(&dev->dev, scatterlist_pointer, buffer_mapped_pages, DMA_BIDIRECTIONAL);


        printk(KERN_ALERT "%s [DEBUG MESSAGE-POSIX MEMORY WRITE] DMA Buffers are: %d\n", driver_name, buffer_dma_buffers);

        dma_address_list_pointer = (dma_addr_t *)kmalloc(sizeof(dma_addr_t) * buffer_dma_buffers, GFP_KERNEL);
        dma_length_list_pointer = (int *)kmalloc(sizeof(int) * buffer_dma_buffers, GFP_KERNEL);


        for(repeat = 0; repeat < buffer_dma_buffers; repeat++)
        {
            dma_address_list_pointer[repeat] = sg_dma_address(scatterlist_pointer);
            dma_length_list_pointer[repeat] = sg_dma_len(scatterlist_pointer);


            scatterlist_pointer = sg_next(scatterlist_pointer);

            printk(KERN_ALERT "%s [DEBUG MESSAGE-POSIX MEMORY WRITE] Buffer Page %d DMA Physical Address is: 0x%016lX [SIZE %d Bytes]\n", driver_name, repeat, (unsigned long)dma_address_list_pointer[repeat], dma_length_list_pointer[repeat]);

        }   


        scatterlist_pointer = dma_sg_table->sgl;

        //pci_dma_sync_sg_for_device(dev, scatterlist_pointer, buffer_dma_buffers, DMA_TO_DEVICE);


        for(repeat = 0; repeat < buffer_mapped_pages; repeat++) 
        {
            writel(dma_address_list_pointer[repeat], (u32 *)bar1_address_virtual + repeat);
        }

        temporary_point = repeat;

        for(repeat = 0; repeat < buffer_mapped_pages; repeat++) 
        {
            writel(dma_length_list_pointer[repeat], (u32 *)bar1_address_virtual + repeat + temporary_point);
        }       

        write_remote_register(bar0_address_virtual, BAR0_OFFSET_GPIO_NOTIFIER + ZERO_OFFSET, (u32) (OPERATION_SET_DMA_ADDRESS_LENGTH_ARRAY_SIZE | buffer_dma_buffers));

}

С блоком памяти пользовательского пространства 4M кажется, что я правильно получаю все физические адреса для каждой из 1024 страниц (размер страницы 4096 байт).

Затем я записываю эти адреса в память BRAM в моей FPGA.

И ядро ​​DMA, и процессор Microblaze используют эти адреса для чтения через PCIe данных, которые уже записаны приложением пользовательского пространства, которое выделяет предыдущий блок памяти.

Однако по какой-то причине операции чтения DMA / Microblaze некорректны.

Данные, которые хранятся в блоке памяти пользовательского пространства, представляют собой непрерывные возрастающие значения (11, 12, 13, 14, 15, 16 ..., 234, 235 и т. Д.).

Каждый раз, когда я читаю физический адрес страницы, мне кажется, что я получаю кусок таких смежных значений, который заставляет меня думать, что я получаю правильные данные.

Проблема в том, что я получаю одни и те же непрерывные возрастающие значения для всех страниц, к которым я обращаюсь.

Что могло быть не так в моем случае? Может ли это быть проблемой согласованности кеша?