linux内核空间申请超过2MB连续空间的实现函数。

最新推荐文章于 2024-09-19 08:37:25 发布

原创最新推荐文章于 2024-09-19 08:37:25 发布 · 1.6k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#linux内核 #struct #io #null #user

本文介绍了一个用于内核空间的内存分配函数kmem_alloc，该函数能够为DMA操作分配连续内存，并提供相应的释放函数kmem_free。它支持不同大小的内存分配，并针对高内存区和低内存区进行了区分。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

/*
kmalloc can apply 128KB memory only. This func support any continous memory allocate more than 2MB.
*/
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kallsyms.h>

#define KMEM_PAGES       //apply more than one page
#define KMEM_DEBUG       //debug message switch

/*
// Pure 2^n version of get_order
static __inline__ __attribute_const__ int get_order(unsigned long size)
{
   int order;

   size = (size - 1) >> (PAGE_SHIFT - 1);
   order = -1;
   do {
       size >>= 1;
       order++;
   } while (size);
   return order;
}
*/

/*
alloc memory for DMA using in kernel space.
*/
void *kmem_alloc(size_t size, dma_addr_t *dma_handle, unsigned long flags)
{
    struct page *page;       //start page address
    void *cpu_addr = NULL;       //cpu io address
    struct page *end;       //end of pages
    unsigned int PageOrder=0;

    size = PAGE_ALIGN(size);   //must be times of 4KB
    PageOrder=get_order(size);
#ifdef CONFIG_ISOLATE_HIGHMEM       //allocate in high memory
    page = alloc_pages(GFP_HIGHUSER, PageOrder);
#else                               //allocate from low memory
    page = alloc_pages(GFP_KERNEL, PageOrder);       //get_order(size) means how many 4KB page do you want to apply. 2^n
#endif
    if(!page) {
   err("alloc_pages fail! (requested %#x)", size);
   goto no_page;
    }
#ifdef KMEM_DEBUG
    printk("kmem_alloc 0x%x size 0x%x,order=%d/n",page_to_phys(page),size,PageOrder);
#endif

    *dma_handle = page_to_phys(page);   //transform to physical address

    cpu_addr = __ioremap(*dma_handle, size, flags, 1);       //map to kernal io space

    if(cpu_addr) {
#ifdef KMEM_PAGES
        end = page + (1 << PageOrder);       //count to get the last page
        do {
            set_page_count(page, 1);           //only one user
            SetPageReserved(page);           //set page used flag
            page++;
        } while (size -= PAGE_SIZE);

       /*
       * Free the unused pages. get_order(size) means 2^n to apply, so there must be more pages to alloc than we want.
       */
       while (page < end) {
           set_page_count(page, 1);
            if (!PageReserved(page) && put_page_testzero(page))
                free_cold_page(page);       //only we can use this func to free page
           page++;
       }
#else       //just apply one page
        set_page_count(page, 1);
        SetPageReserved(page);
#endif
    }
    else {
   __free_pages(page, PageOrder);       //free more than one pages
   err("__ioremap fail! (phy %#x)", *dma_handle);
    }
no_page:
    return cpu_addr;
}
EXPORT_SYMBOL(kmem_alloc);

void kmem_free(size_t size, void *cpu_addr, dma_addr_t handle)
{
    struct page *page = pfn_to_page(handle >> PAGE_SHIFT);       //equal to phys_to_pages()
    struct page *pg;
    unsigned int sz;

    pg=page;
    sz=PAGE_ALIGN(size);
#ifdef KMEM_DEBUG
    printk("kmem_free 0x%x size 0x%x/n",page_to_phys(pg),sz);
#endif

    __iounmap(cpu_addr);       //un map from kernel io space

#ifdef KMEM_PAGES
    do {
        ClearPageReserved(page);
        if (!PageReserved(page) && put_page_testzero(page))
            free_cold_page(page);
        page++;
    } while (sz -= PAGE_SIZE);

#else
    ClearPageReserved(page);
    if (!PageReserved(page) && set_page_count(page, 0))
        __free_pages_ok(page,get_order(size));
#endif

}

EXPORT_SYMBOL(kmem_free);