Linux kernel device driver memory management notes

/**********************
 * Linux memory management **************************/

Memory management is by far the most complex activity in the Unix kernel. We briefly introduce memory management and use examples to illustrate how to obtain memory in kernel mode.

(1) Various addresses

For x86 processors, the following three types of addresses need to be distinguished:

*Logical address

Only x86 is supported. Each logical address consists of a segment and an offset, which indicates the distance from the beginning of the segment to the actual address.

The logical address is 48 bits, the segment selector is 16 bits, and the offset is 32 bits. Linux has limited support for logical addresses

*Linear address

Also called a virtual address.

32-bit unsigned integer, from 0x0000,0000 to 0xffff,ffff, a total address range of 4GB. Whether it is an application or a driver, the addresses we use in the program are virtual addresses.

* Physical address

A 32-bit unsigned integer that corresponds to the electrical signals sent from the CPU's address pins onto the memory bus. Used for memory addressing.

Find a program, such as scanf.c, run it twice, and then execute the following instructions to observe:

$>pmap $(pid)
$>cat /proc/$(pid)/maps

(2) Physical memory and virtual memory

a. Physical memory

It is the RAM that actually exists in the system, such as a 256MB RAM that we often talk about. The x86 processor and physical memory are connected through actual physical lines.

In addition, the x86 processor is connected to many peripherals through the motherboard, and these peripherals are also connected to the processor through actual physical lines.

For the processor, the access method for most peripherals and RAM is the same, that is, the program issues a physical address to access the actual physical device.

Peripherals and RAM share a 4G physical memory space.

b. Virtual Memory

It is a logical memory constructed for each process on top of the physical memory, between the application's memory request and the hardware memory management unit (MMU). The MMU converts the virtual memory used by the application into physical addresses according to a predefined page table, and then accesses the actual peripherals or RAM through the physical addresses.

Virtual memory has many uses and advantages:

• *Several processes can be executed concurrently
• * The application can run even when the memory required is greater than the physical memory
• * A process can execute a program when only part of its code is loaded into memory
• * Allow each process to access a subset of available physical memory
• *Processes can share a single memory image of a library function or program
• * The program is relocatable, that is, the program can be placed anywhere in physical memory
• * Programmers can write machine-independent code without having to worry about the organization of physical memory

(3) RAM usage

Linux divides the actual physical RAM into two parts. Several megabytes are used to store the kernel image (that is, the kernel code and kernel static data structures). The rest of the RAM is usually handled by the virtual memory system and used in the following three possible ways:

• * Satisfy kernel requests for caches, descriptors, and other dynamic kernel data structures
• *Satisfy the process's request for general memory area and file memory mapping
• * Get better performance from disks and other buffering devices with the help of cache

One of the main issues that virtual memory must address is memory fragmentation, because normally the kernel uses contiguous physical memory, so too much fragmentation can cause requests to fail.

/**********************
 * Get memory in the kernel************************/

As in user space, memory can be dynamically allocated and released in the kernel, but it is subject to more restrictions than in user space.

(1) Memory management in the kernel

The kernel uses physical pages as the basic unit of memory management. This is mainly because the memory management unit (MMU) converts virtual addresses and physical addresses in pages. From the perspective of virtual memory, a page is the smallest unit. Most 32-bit architectures support 4KB pages.

a. Page

The kernel uses struct page to represent each physical page in the system.

Including <linux/mm.h> allows you to use page, which is actually defined in <linux/mm_types.h>

struct page{
 page_flags_t flags;
 atomic_t _count;
 atomic_t _mapcount;
 unsigned long private;
 struct address_space *mapping;
 pgoff_t index;
 struct list_head lru;
 void *virtual;
};

Flags is used to store the status of the page, which is defined in <linux/page-flags.h>. The status includes whether the page is dirty, whether it is locked in memory, etc. _count stores the reference count of the page.

The page structure is related to physical pages, not virtual pages. The purpose of the structure is to describe the physical memory itself, not the data in it.

The kernel manages all pages in the system based on the page structure. The kernel can know whether a page is free (that is, whether the page has been allocated) through the page.

If the page has been allocated, the kernel also needs to know who owns the page.

The owner may be a userspace process, dynamically allocated kernel data, static kernel code, or the page cache, etc.

Such a structure is allocated for each physical page in the system. If the structure is 40 bytes in size, then 1MB of 128MB of physical memory (4K pages) needs to be allocated for the page structure.

b. Area

Due to hardware limitations, the kernel cannot treat all pages equally. The kernel uses zones to group pages with similar characteristics. These features include:

• *Some hardware can only perform DMA using certain memory addresses
• *Some architectures have a memory address range that is much larger than the virtual address range, so some memory cannot be permanently mapped into kernel space.

To address these limitations, Linux uses three zones (<linux/mmzone.h>):

• ZONE_DMA: This zone contains pages that can perform DMA operations
• ZONE_NORMAL: This zone contains pages that can be mapped normally.
• ZONE_HIGHMEM: This zone contains high-end memory (greater than 896M), pages of which cannot be permanently mapped into the kernel's address space

For x86, the physical memory corresponding to these three areas are:

• ZONE_DMA: <16MB
• ZONE_NORMAL: 16~896MB
• ZONE_HIGHMEM: >896MB

See struct zone in <linux/mmzone.h>.

There are only 3 such zone structures in the system.

(2) Page allocation

The kernel uses pages for memory management, so we can also ask the system to allocate memory to us in pages in the kernel. Of course, allocating in pages may cause memory waste, so we only call them when we are sure that we need a whole page of memory.

a. Allocation

#include <linux/gfp.h>
1. struct page * alloc_pages(
    unsigned int gfp_mask, 
    unsigned int order);
//Allocate 2 consecutive physical pages.
2. void *page_address(
    struct page *page);
//Returns a pointer to the current virtual address of a given physical page 3. unsigned long __get_free_pages(
    unsigned int gfp_mask, 
    unsigned int order);
//Equivalent to the combination of the above two functions 4. struct page * alloc_page(
    unsigned int gfp_mask);
5. unsigned long __get_free_page(
    unsigned int gfp_mask);
6. unsigned long get_zeroed_page(
    unsigned int gfp_mask);
//Allocate only one page

b.gfp_mask flag

This flag determines how the kernel behaves when allocating memory, and from where it allocates the memory.

#include <linux/gfp.h>
#define GFP_ATOMIC
//Atomic allocation, no sleep, can be used for interrupt processing.
#define GFP_KERNEL 
//Preferred, the kernel may sleep, used in the process context

c. Release page

void __free_pages(struct page *page,
    unsigned int order);
void free_pages(unsigned long addr,
    unsigned int order);
void free_page(unsigned long addr);

Notice! You can only release pages that belong to you. Incorrect parameters may cause a kernel panic.

(3) Obtaining memory through kmalloc

kmalloc is very similar to malloc and is the most commonly used memory allocation function in the kernel.

kmalloc will not clear the allocated memory area to 0, and the allocated area is continuous in physical memory.

a. Allocation

#include <linux/slab.h>
void *kmalloc(size_t size, int flags)

size is the size of the memory required to be allocated

The flags parameter of kmalloc can control the behavior of kmalloc during allocation. The flags used are consistent with those used in alloc_page. Note that kmalloc cannot allocate high-end memory.

b. Release

#include <linux/slab.h>
 void kfree(const void *ptr);

This can have serious consequences if the memory being freed has already been freed, or if freeing memory that belongs to other parts of the kernel. It is safe to call kfree(NULL).

Be careful! The kernel can only allocate byte arrays of some predefined, fixed size. The smallest memory block that kmalloc can handle is 32 or 64. Since the memory allocated by kmalloc is physically continuous, there is an allocation upper limit, which usually should not exceed 128KB.

(4) Obtain memory through vmalloc

The virtual addresses of memory allocated by vmalloc() are continuous, but the physical addresses do not need to be continuous. This is also how malloc() allocates. vmalloc allocates non-contiguous memory blocks, then modifies the page table to map the memory into a continuous area in the logical space.

In most cases, only hardware devices need to obtain memory with continuous physical addresses, and the kernel can use the memory obtained through vmalloc. However, kmalloc is mostly used in the kernel, mainly for performance considerations, because vmalloc will cause large TLB jitter, unless vmalloc is used when mapping large blocks of memory. For example, when a module is loaded dynamically, it is loaded into the memory allocated by vmalloc.

vmalloc is declared in <linux/vmalloc.h> and defined in <mm/vmalloc.c>. Its usage is the same as malloc().

 void* vmalloc(unsigned long size);
 void vfree(void *addr);

vmalloc will cause sleep

(5) Obtaining memory through the slab mechanism

Allocating and freeing data structures is one of the most common operations in the kernel.

A common method is to build a free list, which contains the allocated data structure blocks available for use.

Every time you need to allocate a data structure, you don't need to apply for memory again. Instead, you can directly allocate the data block from this free linked list, and return the memory to this linked list when releasing the structure.

This is actually a kind of object cache (caching objects).

Linux provides a slab allocator to accomplish this task.

The slab allocator seeks a balance between several basic principles:

• * Frequently used data structures are frequently allocated and released and need to be cached
• *Frequent allocation and recycling will inevitably lead to memory fragmentation. To avoid this phenomenon, the cache in the free list will be stored continuously to avoid fragmentation.
• * The allocator can be optimized based on object size, page size and total cache size

kmalloc is built on top of slab.

a. Create a new cache

#include <linux/slab.h>
struct kmem_cache *kmem_cache_create(
   const char *name, 
   size_t size,
   size_t align,
   unsigned long flags,
   void(*ctor)(...));

name: The name of the cache. Appears in /proc/slabinfo
size: The size of each element in the cache
align: the offset of the first object in the cache, usually 0
flags: Allocation flags. Commonly used SLAB_HWCACHE_ALIGH, indicating cache line alignment, see slab.h

b. Destroy the cache

#include <linux/slab.h>
void kmem_cache_destroy(struct kmem_cache *cachep);

This method must be called after all objects in the cache have been released.

c. Get the object from the cache

void *kmem_cache_alloc(
   struct kmem_cache *cachep, int flags);
flags:
   GFP_KERNEL

d. Release the object back to the cache

void kmem_cache_free(
   struct kmem_cache *cachep, void *objp);

See kernel/fork.c

(6) Mapping of high-end memory

Pages in high memory cannot be permanently mapped into the kernel address space, therefore, pages obtained by alloc_pages() with the __GFP_HIGHMEM flag cannot have virtual addresses. It needs to be dynamically allocated through a function.

a. Mapping

To map a given page structure into kernel address space, use:

void *kmap(struct page *page);

Functions can sleep

b. Unmap

void kunmap(struct page* page);

Summarize

The above is the full content of this article. I hope that the content of this article will have certain reference learning value for your study or work. Thank you for your support of 123WORDPRESS.COM. If you want to learn more about this, please check out the following links