Linux内核内存管理

static inline void *pci_alloc_consistent(struct pci_dev *hwdev, size_t size,
                                         dma_addr_t *dma_handle)
{
    return dma_alloc_coherent(hwdev == NULL ? NULL : &hwdev->dev,
                              size, dma_handle, GFP_ATOMIC);
}

struct dma_coherent_mem {
    void            *virt_base;
    u32             device_base;
    int             size;
    int             flags;
    unsigned long   *bitmap;
};

void *dma_alloc_coherent(struct device *dev, size_t size,
                         dma_addr_t *dma_handle, int gfp)
{
    void *ret;
    // 若是设备，得到设备的dma内存区域
    struct dma_coherent_mem *mem = dev ? dev->dma_mem : NULL;
    int order = get_order(size);        // 将size转换成order
    gfp &= ~(__GFP_DMA | __GFP_HIGHMEM);
    if (mem) {                          // 设备的DMA映射
        int page = bitmap_find_free_region(mem->bitmap, mem->size, order);
        if (page >= 0) {
            *dma_handle = mem->device_base + (page << PAGE_SHIFT);
            ret = mem->virt_base + (page << PAGE_SHIFT);
            memset(ret, 0, size);
            return ret;
        }
        if (mem->flags & DMA_MEMORY_EXCLUSIVE)
            return NULL;
    }
    // 不是设备的DMA映射
    if (dev == NULL || (dev->coherent_dma_mask < 0xffffffff))
        gfp |= GFP_DMA;
    // 分配空闲页
    ret = (void *)__get_free_pages(gfp, order);
    if (ret != NULL) {
        memset(ret, 0, size);
        *dma_handle = virt_to_phys(ret);
    }
    return ret;
}

static inline dma_addr_t pci_map_single(struct pci_dev *hwdev,
                                        void *ptr, size_t size, int direction)
{
    return dma_map_single(hwdev == NULL ? NULL : &hwdev->dev, ptr, size,
                          (enum ma_data_direction) direction);
}

static inline dma_addr_t dma_map_single(struct device *dev, void *ptr,
                                        size_t size,
                                        enum dma_data_direction direction)

{
    BUG_ON(direction == DMA_NONE);
    // 可能有些数据还会保留在处理器的高速缓冲存储器中，因此必须显式刷新
    flush_write_buffers();
    return virt_to_phys(ptr);　// 虚拟地址转化为物理地址
}

struct scatterlist {
    struct page         *page;
    unsigned int        offset;
    dma_addr_t          dma_address;    // 用在分散聚集操作中的缓冲区地址
    unsigned int        length;         // 该缓冲区的长度
};

static inline int pci_map_sg(struct pci_dev *hwdev, struct scatterlist *sg,
                             int nents, int direction)
{
        return dma_map_sg(hwdev == NULL ? NULL : &hwdev->dev, sg, nents,
                          (enum dma_data_direction)direction);
}

static inline int dma_map_sg(struct device *dev, struct scatterlist *sg,
                             int nents, enum dma_data_direction direction)
{
    int i;

    BUG_ON(direction == DMA_NONE);
    for (i = 0; i < nents; i++ ) {
        BUG_ON(!sg[i].page);
        // 将页及页偏移地址转化为物理地址
        sg[i].dma_address = page_to_phys(sg[i].page) + sg[i].offset;
    }
    // 可能有些数据还会保留在处理器的高速缓冲存储器中，因此必须显式刷新
    flush_write_buffers();
    return nents;
}

struct dma_pool {
    struct list_head        page_list;
    spinlock_t              lock;
    size_t                  blocks_per_page;　  // 每页的块数
    size_t                  size;               // DMA池里的一致内存块的大小
    struct device           *dev;               // 将做DMA的设备
    size_t                  allocation;         // 分配的没有跨越边界的块数
                                                // 是size的整数倍
    char                    name [32];　        // 池的名字
    wait_queue_head_t       waitq;              // 等待队列
    struct list_head        pools;
};

struct dma_pool *dma_pool_create (const char *name, struct device *dev,
                                  size_t size, size_t align,
                                  size_t allocation)

struct vm_struct {
    struct vm_struct        *next;      // 链表下一节点
    void                    *addr;      // 内存区起始地址
    unsigned long           size;       // 区域大小
    unsigned long           flags;      // 内存区类型
    struct page             **pages;    // 每个page关联到一个物理页帧
    unsigned int            nr_pages;   // 总page数
    phys_addr_t             phys_addr;  // 通常为0，用于ioremap
    const void              *caller;    // 返回地址
};

void *vmalloc(unsigned long size)
{
    return __vmalloc_node_flags(size, NUMA_NO_NODE,
                                GFP_KERNEL | __GFP_HIGHMEM);
}
static inline void *__vmalloc_node_flags(unsigned long size,
                                         int node, gfp_t flags)
{
    return __vmalloc_node(size, 1, flags, PAGE_KERNEL,
                          node, __builtin_return_address(0));
}
static void *__vmalloc_node(unsigned long size, unsigned long align,
                            gfp_t gfp_mask, pgprot_t prot,
                            int node, const void *caller)
{
    return __vmalloc_node_range(size, align, VMALLOC_START, VMALLOC_END,
                                gfp_mask, prot, 0, node, caller);
}
void *__vmalloc_node_range(unsigned long size, unsigned long align,
                           unsigned long start, unsigned long end,
                           gfp_t gfp_mask, pgprot_t prot,
                           unsigned long vm_flags, int node,
                           const void *caller);

int brk(void *addr);                    // return 0 for ok
void *sbrk(intptr_t increment);         // return (void *)-1 when failed