Shulou(Shulou.com)06/01 Report--

Editor to share with you the Linux kernel device driver memory management example analysis, I believe that most people do not know much about it, so share this article for your reference, I hope you will learn a lot after reading this article, let's learn about it!

/ * memory management of linux * * /

Memory management is by far the most complex activity in the unix kernel. Let's give a brief introduction to memory management and illustrate how to obtain memory in kernel state through an example.

(1) various addresses

For x86 processors, you need to distinguish between the following three addresses:

* logical address (logical address)

Only x86 supports it. Each logical address consists of a segment (segment) and an offset (offset), which indicates the distance from the beginning of the segment to the actual address.

The logical address consists of 48 bits, segment selector 16 bits, and offset 32 bits. Linux's support for logical addresses is limited.

* Linear address (linear address)

Also known as virtual address (virtual address).

32-bit unsigned integer, from 0x00000000 to 0xfffffffufffffffff, a total of 4GB address range. Whether it is an application or a driver, the address we use in the program is a virtual address.

* physical address (physical address)

A 32-bit unsigned integer corresponding to an electrical signal sent from the address pin of the CPU to the memory bus. Used for memory addressing.

Find a program, such as scanf.c, run two, 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 actual RAM in the system, such as a 256 megabyte RAM that we often talk about. The connection between the x86 processor and physical memory is through the actual physical line.

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

For processors, most peripherals are accessed in the same way as RAM, and the program sends out physical addresses to access the actual physical devices.

Peripherals and RAM share a 4G physical memory space.

b. Virtual memory

MMU converts the virtual memory used by the application into a physical address according to a predefined page table, and then accesses the actual peripheral or RAM through the physical address.

Virtual memory has many uses and advantages:

* several processes can be executed concurrently

* it can also be run when the memory required by the application is larger than the physical memory

* the process can execute a program when only part of the code is loaded into memory

* allow each process to access a subset of available physical memory

* A process can share a library function or a separate memory image of a program

* the program is relocatable, that is, it can be placed anywhere in physical memory

* programmers can write machine-independent code without having to worry about the organization of physical memory

(3) the use of RAM

Linux divides the actual physical RAM into two parts, of which a few megabytes are dedicated to storing kernel images (that is, kernel code and kernel static data structures), and the rest of the RAM is usually handled by the virtual memory system and used in the following three possible aspects:

* 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

* better performance from disks and other buffering devices with the help of cache

One of the main problems that virtual memory must address is memory fragmentation, because the kernel usually uses continuous 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 freed in the kernel, but with more limitations than user space.

(1) memory management in kernel

The kernel uses physical pages as the basic unit of memory management. This is mainly because the memory management unit (MMU) translates virtual addresses and physical addresses on a page-by-page basis, which is the smallest unit from a virtual memory point of view. Most 32-bit architectures support 4KB pages.

a. Page

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

Including, you can use page, which is actually defined in

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 state of the page, defined in the state, including whether the page is dirty, whether it is locked in memory, and so on. _ count holds 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 the pages in the system according to the page structure, and the kernel can know whether a page is free (that is, whether the page is allocated or not) through page.

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

The owner may be a user space process, dynamically allocated kernel data, static kernel code, or page caching, etc.

Each physical page in the system is assigned such a structure. If the size of the structure is 40 bytes, 128MB physical memory (4K pages) needs to be allocated for 1MB mostly for page structures.

b. Zone

Due to hardware limitations, the kernel cannot treat all pages equally. The kernel usage zone (zone) groups pages with similar features. These features include:

* some hardware can only use certain memory addresses to execute DMA

* some architectures have a much larger physical addressing range of memory than a virtual addressing range, so that some memory cannot be permanently mapped to kernel space

In response to these limitations, linux adopts three zones ():

ZONE_DMA: this area contains pages that can perform DMA operations

ZONE_NORMAL: this area contains pages that can be mapped properly

ZONE_HIGHMEM: this section contains high-end memory (larger than 896m), in which pages cannot be permanently mapped to the kernel address space

For x86, the physical memory for these three regions is:

ZONE_DMA: 896MB

See struct zone in.

There are only three 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 on a page-by-page basis in the kernel. Of course, page-by-page allocation can lead to memory waste, so we call them only when we are sure we need full-page memory.

a. Distribution

# include 1. Struct page * alloc_pages (unsigned int gfp_mask, unsigned int order); / / assign 2 to the order power of 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 Fla

This flag determines how the kernel behaves when allocating memory and where to allocate memory.

# include # define GFP_ATOMIC// atomic allocation, does not sleep, can be used to interrupt processing. # define GFP_KERNEL / / preferred, the kernel may sleep and be 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)

Be careful! You can only release pages that belong to you. Incorrect parameters can cause the kernel to crash.

(3) obtain memory through kmalloc

Kmalloc, much like malloc, is the most commonly used memory allocation function in the kernel.

Kmalloc does not clear 0 of the allocated memory areas, which are contiguous in physical memory.

a. Distribution

# include void * kmalloc (size_t size, int flags)

Size is the amount of memory required to be allocated

The parameter flags of kmalloc controls the behavior of kmalloc allocation. It is the same as the flag used in alloc_page. Note that kmalloc cannot allocate high-end memory

b. Release

# include void kfree (const void * ptr)

If the memory to be freed has been released, or if the memory that belongs to other parts of the kernel is freed, there will be serious consequences. It is safe to call kfree (NULL).

Pay attention! The kernel can only allocate predefined, fixed-size byte arrays. The smallest block of memory that kmalloc can handle is 32 or 64. Because the memory allocated by kmalloc is physically continuous, there is an upper limit for allocation, which usually does not exceed 128KB.

(4) obtain memory through vmalloc

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

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

Vmalloc is the same as malloc () in declaration, definition and usage.

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

Vmalloc can cause sleep.

(5) obtain memory through slab mechanism

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

A common approach is to build a free linked list that contains blocks of data structures that are available and have been allocated.

Each time you want to allocate a data structure, you no longer have to apply for memory, but allocate data blocks directly from the free linked list, and return the memory to the linked list when the structure is freed.

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

Linux provides a slab allocator to do this for this requirement.

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. In order to avoid this phenomenon, the cache in the idle linked 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 based on slab.

a. Create a new cache

# include struct kmem_cache * kmem_cache_create (const char * name, size_t size, size_t align, unsigned long flags, void (* ctor) (...))

Name: name of the cache. Appear in / proc/slabinfo

Size: the size of each element in the cache

Align: offset of the first object in the cache, usually 0

Flags: allocation flag. SLAB_HWCACHE_ALIGH is commonly used, indicating that it is aligned by cache line, see slab.h

b. Destroy cache

# include void kmem_cache_destroy (struct kmem_cache * cachep)

Cannot be called until all objects in the cache have been released.

c. Get an 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-end memory cannot be permanently mapped to the kernel address space, so pages obtained with the _ _ GFP_HIGHMEM flag through the alloc_pages () function cannot have virtual addresses. It needs to be allocated dynamically through a function.

a. Mapping

To map a given page structure to the kernel address space, you can use:

Void * kmap (struct page * page)

Function can sleep

b. De-mapping

Void kunmap (struct page* page); the above is all the contents of the article "sample Analysis of memory Management for Linux Kernel device drivers". Thank you for reading! I believe we all have a certain understanding, hope to share the content to help you, if you want to learn more knowledge, welcome to follow the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.