This patchset attempts to fix some errors in udmabuf and remove the upin_list structure. Some of this fix just gather the patches which I upload before. Patch1 === Try to remove page fault mmap and direct map it. Due to current udmabuf has already obtained and pinned the folio upon completion of the creation.This means that the physical memory has already been acquired, rather than being accessed dynamically. The current page fault method only saves some page table memory. As a result, the page fault mechanism has lost its purpose as a demanding page. Due to the fact that page fault requires trapping into kernel mode and filling in when accessing the corresponding virtual address in mmap, this means that user mode access to virtual addresses needs to trap into kernel mode. Therefore, when creating a large size udmabuf, this represents a considerable overhead. Therefore, the current patch removes the page fault method of mmap and instead fills it directly when mmap is triggered. This is achieved by using the scatter-gather table to establish a linear relationship for the page. Calling remap_pfn_range does not cause the previously set VMA flags to become invalid. Patch2 === This is the same to patch: https://lore.kernel.org/all/20240725021349.580574-1-link@xxxxxxxx/ I just gather it to this patchset. Patch3 === The current implementation of udmabuf's vmap has issues. It does not correctly set each page of the folio to the page structure, so that when vmap is called, all pages are the head page of the folio. This implementation is not the same as this patch: https://lore.kernel.org/all/20240731090233.1343559-1-link@xxxxxxxx/ This reuse sgt table to map all page into vmalloc area. Patch4 === Wrap the repeated calls to get_sg_table, add a helper function to do it. Set to udmabuf->sg use cmpxchg, It should be able to prevent concurrent access situations. (I see mmap do not use lock) Patch5 === Attempt to remove unpin_list and other related data structures. In order to adapt to Folio, we established the unpin_list data structure to unpin all folios and maintain the page mapping relationship. However, this data structure requires 24 bytes for each page and has low traversal performance for the list. And maintaining the offset structure also consumes a portion of memory. This patch attempts to remove these data structures and modify the semantics of some existing data structures. udmabuf: folios -> folios array, which only contain's the folio, org contains duplicate. add item_offset -> base on create item count, record it's start offset in every memfd. add item_size -> base on create item count, record it's size in every memfd. add nr_folios -> folios array number So, when building the sg table, it is necessary to iterate in this way: if size cross item->size, take care of it's start offset in folio. if got folio, set each page into sgl until reach into folio size. This patch also remove single folios' create on each create item, use it be the ubuf->folios arrays' pointer, slide to fill the corresponding folio under the item into the array. After the modification, the various data structures in udmabuf have the following corresponding relationships: pagecount * PAGESIZE = sum(folios_size(folios[i])) i=0->nr_folios pagecount * PAGESIZE = sum(item_size[i]) i=0, item_count (do not record) item_offset use to record each memfd offset if exist, else 0. Huan Yang (5): udmabuf: cancel mmap page fault, direct map it udmabuf: change folios array from kmalloc to kvmalloc udmabuf: fix vmap_udmabuf error page set udmabuf: add get_sg_table helper function udmabuf: remove folio pin list drivers/dma-buf/udmabuf.c | 270 +++++++++++++++++++++----------------- 1 file changed, 148 insertions(+), 122 deletions(-) base-commit: cd19ac2f903276b820f5d0d89de0c896c27036ed -- 2.45.2
