Speicher ist eine der wichtigsten Ressourcen in einem Linux-System. Er kann zum Speichern von Daten, Code, Stapeln usw. verwendet werden. Die Speicheranwendung und -freigabe ist einer der grundlegendsten Vorgänge bei der Entwicklung von Linux-Treibern. Sie umfasst Konzepte wie Kernel-Speicherplatz und Benutzerspeicherplatz, statische Zuweisung und dynamische Zuweisung, kontinuierlichen Speicher und nicht zusammenhängenden Speicher. In diesem Artikel stellen wir die Speicheranwendungstechnologie in Linux-Treibern vor, einschließlich kmalloc, vmalloc, get_free_pages, dma_alloc_coherent und anderen Funktionen, und geben Beispiele, um deren Verwendung und Vorsichtsmaßnahmen zu veranschaulichen.
Beginnen wir mit den Grundlagen. Das Bild unten zeigt das Speicherzuordnungsmodell von Linux
“Dynamische Speicheranwendung
“
. Die unterste Ebene von kmalloc muss **__get_free_pages aufrufen. Die gtp_t-Flags, die den Speichertyp im Parameter angeben, sind die Abkürzung dieser Funktion: GFP_USER, GFP_KERNEL, GFP_ATOMIC**.
/** * kmalloc - allocate memory * @size: how many bytes of memory are required. * @flags: the type of memory to allocate. * The @flags argument may be one of: * %GFP_USER - Allocate memory on behalf of user. May sleep. * %GFP_KERNEL - Allocate normal kernel ram. May sleep. * %GFP_ATOMIC - Allocation will not sleep. May use emergency pools. * * For example, use this inside interrupt handlers. */ void *kmalloc(size_t size, gfp_t flags); /** * kfree - free previously allocated memory * @objp: pointer returned by kmalloc. * If @objp is NULL, no operation is performed. */ void kfree(const void *objp);
void *kzalloc(size_t size, gfp_t flags)
__get_free_pages – free_pages
unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order) void free_pages(unsigned long addr, unsigned int order)
Die gleiche Reihe von APIs ist ebenfalls verfügbar
vmalloc在虚拟内存空间给出一块连续的内存区，实质上，这片连续的虚拟内存在物理内存中并不一定连续，所以vmalloc申请的虚拟内存和物理内存之间也就没有简单的换算关系，正因如此，vmalloc()通常用于分配远大于__get_free_pages()的内存空间，它的实现需要建立新的页表，此外还会调用使用GFP_KERN的kmalloc，so，一定不要在中断处理函数，tasklet和内核定时器等非进程上下文中使用vmalloc！ 同系列的API还有 我们知道，页是内存映射的基本单位，但内核中很多频繁创建的对象所需内存都不到一页，此时如果仍然按照页映射的方式，频繁的进行分配和释放就会造成资源的浪费，同时也会降低系统性能。为了解决的这样的问题，内核引入了slab机制，使对象在前后两次被使用时被分配在同一块内存或同一类内存空间，且保留了基本的数据结构，就可以大大提高效率。kmalloc的底层即是使用slab算法管理分配的内存的。注意，slab依然是以页为单位进行映射，只是映射之后分割这些页为相同的更小的单元，从而节省了内存。slab分配的单元不能小于32B或大于128K。 除了slab机制，内核还提供了传统的内存池机制来管理小块内存的分配。内存池主要是用来解决可能出现的内存不足的情况，因为一个内存池在创建的时候就已经分配好了一内存，当我们用mempool_alloc向一个已经创建好的内存池申请申请内存时，该函数首先会尝试回调内存池创建时的分配内存函数，如果已经没有内存可以分配，他就会使用内存池创建时预先分配的内存，这样就可以避免因为无内存分配而陷入休眠，当然，如果预分配的内存也已经使用完毕，还是会陷入休眠。slab机制的目的是提高内存使用率以及内存管理效率，内存池的目的是避免内存的分配失败。下面是内核中提供的关于内存池的API 通过本文，我们了解了Linux驱动中的内存申请技术，它们各有优缺点和适用场景。我们应该根据实际需求选择合适的函数，并遵循一些基本原则，如匹配申请和释放函数，检查返回值是否为空，避免内存泄漏等。内存申请技术是Linux驱动开发中不可或缺的一部分，它可以保证驱动程序的正常运行和数据交换，也可以提升驱动程序的性能和稳定性。希望本文能够对你有所帮助和启发。 Das obige ist der detaillierte Inhalt vonSpeicheranwendungstechnologie in Linux-Treibern: Prinzipien und Methoden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!unsigned long __get_free_page(gfp_t gfp)
unsigned long get_zeroed_page(gfp_t gfp_mask)
struct page *alloc_pages(gfp_t gfp_mask, unsigned int order)
void free_page(unsigned long addr)
Nach dem Login kopierenvmalloc – vfree
/**
* vmalloc - allocate virtually contiguous memory
* @size: allocation size
* Allocate enough pages to cover @size from the page level allocator
and map them into contiguous kernel virtual space.
*/
void *vmalloc(unsigned long size)
/**
* vfree - release memory allocated by vmalloc()
* @addr: memory base address
*/
void vfree(const void *addr)
Nach dem Login kopieren/**
* vmalloc_32 - allocate virtually contiguous memory (32bit addressable)
* @size: allocation size
* Allocate enough 32bit PA addressable pages to cover @size from the
page level allocator and map them into contiguous kernel virtual space.
*/
void *vmalloc_32(unsigned long size)
Nach dem Login kopierenslab缓存
/**
* kmem_cache_create - 创建slab缓存对象
* @name:slab缓存区名字，
* @size:slab分配的缓存区的每一个单元的大小
* @align:缓存区内存的对齐方式，一般给0
* @flags:控制分配的位掩码，
* %SLAB_POISON - Poison the slab with a known test pattern (a5a5a5a5) to catch references
to uninitialised memory.
* %SLAB_RED_ZONE - Insert `Red' zones around the allocated memory to check for buffer
overruns.
* %SLAB_HWCACHE_ALIGN - Align the objects in this cache to a hardware cacheline.
This can be beneficial if you're counting cycles as closely as davem.
* %SLAB_CACHE_DMA - Use GFP_DMA memory
* %SLAB_STORE_USER - Store the last owner for bug hunting
*define SLAB_PANIC - Panic if kmem_cache_create() fails
*/
struct kmem_cache *kmem_cache_create(const char *name, size_t size,
size_t align,unsigned long flags, void (*ctor)(void *))
/**
* kmem_cache_alloc - Allocate an object from this cache.
* @cachep: The cache to allocate from.
* @flags: See kmalloc().
* The flags are only relevant if the cache has no available objects.
*/
void *kmem_cache_alloc(struct kmem_cache *cachep, gfp_t flags)
/**
* kmem_cache_free - Deallocate an object
* @cachep: The cache the allocation was from.
* @objp: The previously allocated object.
* Free an object which was previously allocated from this cache.
*/
void kmem_cache_free(struct kmem_cache *cachep, void *objp)
void kmem_cache_destroy(struct kmem_cache *s)
Nach dem Login kopieren范例
//创建slab对象
struct kmem_cache_t *xj_sbcache;
xj_sbcache = kmem_cache_create("xjslab",sizeof(struct xj_unit_t),0,SLAB_CACHE_DMA|SLAB_PANIC，NULL,NULL);
//分配slab缓存
struct xj_unit_t *xj_unit;
xj_unit = kmem_cache_alloc(xj_sbcache,GFP_KERNEL);
/* 使用slab缓存 */
/* 释放slab缓存 */
kmem_cache_free(xj_sbcache, xj_unit);
/* 销毁slab缓存 */
kmem_cache_destroy(xj_sbcache);
Nach dem Login kopieren内存池
/**
* mempool_create - create a memory pool
* @min_nr: the minimum number of elements guaranteed to be allocated for this pool.
* @alloc_fn: user-defined element-allocation function.
* @free_fn: user-defined element-freeing function.
* @pool_data: optional private data available to the user-defined functions.
*
* this function creates and allocates a guaranteed size, preallocated memory pool.
The pool can be used from the mempool_alloc() and mempool_free() functions.
* This function might sleep. Both the alloc_fn() and the free_fn() functions
might sleep - as long as the mempool_alloc() function is not called from IRQ contexts.
*/
mempool_t *mempool_create(int min_nr, mempool_alloc_t *alloc_fn, mempool_free_t
*free_fn, void *pool_data)
/**
* mempool_alloc - allocate an element from a specific memory pool
* @pool: pointer to the memory pool which was allocated via mempool_create().
* @gfp_mask: the usual allocation bitmask.
* this function only sleeps if the alloc_fn() function sleeps or returns NULL.
Note that due to preallocation, this function never* fails when called from process
contexts. (it might fail if called from an IRQ context.)
*/
void * mempool_alloc(mempool_t *pool, gfp_t gfp_mask)
/**
* mempool_free - return an element to the pool.
* @element: pool element pointer.
* @pool: pointer to the memory pool which was allocated via mempool_create().
*
* this function only sleeps if the free_fn() function sleeps.
*/
void mempool_free(void *element, mempool_t *pool)
/**
* mempool_destroy - deallocate a memory pool
* @pool: pointer to the memory pool which was allocated via mempool_create().
*
* Free all reserved elements in @pool and @pool itself.
This function only sleeps if the free_fn() function sleeps.
*/
void mempool_destroy(mempool_t *pool)
Nach dem Login kopieren
