Dans quel espace s'exécute le pilote Linux ?

Le mappage fixe entre l'espace du noyau et les cadres de page physiques mentionné ici est essentiellement une "réservation" des pages du noyau aux cadres de page physiques. Cela ne signifie pas que ces pages "occupent" ces cadres de page physiques. Autrement dit, la page virtuelle est liée au cadre de page physique uniquement lorsque la page virtuelle a réellement besoin d'accéder au cadre de page physique. Normalement, lorsqu'un cadre de page physique n'est pas utilisé par sa page virtuelle correspondante, le cadre de page peut être utilisé par l'espace utilisateur et la zone d'allocation kmalloc du noyau introduite plus tard.

ZONE_DMA et ZONE_NORMAL

Pour tout l'espace du noyau de 1 Go, les gens appellent également les 16 Mo en tête de l'espace la zone DMA, c'est-à-dire la zone ZONE_DMA, car dans le passé, le matériel correction de l'espace DMA dans la mémoire physique. L'espace inférieur de 16 Mo et les zones restantes sont appelées zones normales, c'est-à-dire ZONE_NORMAL.

Mémoire haut de gamme de l'espace du noyau

Avec le développement de la technologie informatique, la mémoire physique réelle de l'ordinateur devient de plus en plus grande, ce qui agrandit la zone de cartographie fixe du noyau (zone linéaire) et plus grand. Évidemment, si aucune restriction n'est imposée, la zone d'allocation vmalloc (zone non linéaire) cessera d'exister lorsque la mémoire physique réelle atteindra 1 Go. Par conséquent, le code du noyau précédemment développé qui appelait vmalloc() n'est plus disponible. Évidemment, afin d'être compatible avec le code du noyau antérieur, cela n'est pas autorisé.

La raison du problème ci-dessus est qu'il n'était pas prévu que la mémoire physique réelle puisse dépasser 1 Go, donc la limite du noyau a été fixée la zone de mappage n'a pas été définie. Définissez une limite et laissez-la augmenter à mesure que la mémoire physique réelle augmente.

Limiter la limite supérieure de la zone de mappage fixe de l'espace du noyau afin qu'elle ne puisse pas augmenter arbitrairement avec l'augmentation de la mémoire physique. Linux stipule que la valeur limite supérieure de la zone de mappage du noyau ne peut pas être supérieure à une valeur high_menory constante inférieure à 1 Go. Lorsque la mémoire physique réelle est grande, 3G + high_memory est utilisé comme limite pour déterminer la zone de mémoire physique.

En d'autres termes, l'idée la plus basique de la mémoire haut de gamme : emprunter une section d'espace d'adressage, établir un mappage d'adresses temporaire et le libérer après utilisation. Cet espace d'adressage peut être recyclé pour accéder à toute la mémoire physique. Lorsque l'ordinateur dispose d'une grande mémoire physique, le schéma schématique de l'espace noyau est le suivant :

• ZONE_DMA : Espace noyau à partir de 16 Mo
• ZONE_NORMAL : Espace noyau 16 Mo ~ 896 Mo (cartographie fixe)
• ZONE_HIGHMEM : Espace noyau 896 Mo ~ Fin (1G) Selon la cible d'application Différent, haut de gamme La mémoire est divisée en zone vmalloc, zone de mappage persistant et zone de mappage temporaire.
La disposition de la mémoire haut de gamme dans l'espace du noyau est illustrée dans la figure ci-dessous :

Zone de mappage vmalloc

La zone de mappage vmalloc est la partie principale de la mémoire haut de gamme. espace entre la tête de cet intervalle et l'espace de mappage linéaire du noyau. Une zone d'isolement de 8 Mo et une zone d'isolement de 4 Ko à la fin et la zone de mappage persistante suivante.

Zone de mappage du noyau persistant

Si la page correspondant à la mémoire haut de gamme est obtenue via alloc_page(), comment lui trouver un espace linéaire ? Le noyau réserve spécialement un espace linéaire à cet effet, à partir de PKMAP_BASE, qui est utilisé pour mapper la mémoire haut de gamme, qui est la zone de mappage persistante du noyau.

Zone de cartographie temporaire

La zone de cartographie temporaire est également appelée zone de cartographie fixe et zone réservée. Cette zone est principalement utilisée dans les systèmes multiprocesseurs. L'espace mémoire obtenu dans cette zone n'étant pas protégé, la mémoire obtenue doit être utilisée à temps, sinon, dès qu'il y aura une nouvelle demande, le contenu du cadre de page sera écrasé ; , cette zone est donc appelée zone de cartographie temporaire. Un très bon article sur la zone de mémoire haut de gamme :

.

Modificateur d'allocation de mémoire du noyau gfp

Afin de fournir les explications nécessaires pour les requêtes dans la fonction de demande de mémoire du noyau, Linux définit une variété de modificateurs d'allocation de mémoire gfp. Ce sont des modificateurs de comportement, des modificateurs de zone et des modificateurs de type.

Modificateurs de comportement

Les modificateurs de comportement dans les fonctions d'allocation de mémoire décrivent comment le noyau doit allouer la mémoire. Les principaux modificateurs de comportement sont les suivants :

Le modificateur de région indique à partir de quelle région de l'espace mémoire du noyau doit être allouée. Par défaut, l'allocateur de mémoire commence à partir de ZONE_NORMAL dans l'espace du noyau et alloue progressivement des zones de mémoire au demandeur de mémoire. Si l'utilisateur a spécifiquement besoin d'obtenir de la mémoire à partir de ZONE_DMA ou de ZONE_HOGNMEM, alors le demandeur de mémoire doit utiliser les deux zones suivantes dans la mémoire. fonction de requête. Description du modificateur :

Modificateur de zone d'allocation de mémoire du noyau principal de Linux

类型修饰符

类型修饰符实质上是上述所述修饰符的联合应用。也就是：将上述的某些行为修饰符和区修饰符，用“|”进行连接并另外取名的修饰符。这里就不多介绍了。

内核常用内存分配及地址映射函数

函数vmalloc()

函数vmalloc()在vmalloc分配区分配内存，可获得虚拟地址连续，但并不保证其物理页框连续的较大内存。与物理空间的内存分配函数malloc()有所区别，vmalloc()分配的物理页不会被交换出去。函数vmalloc()的原型如下：

void *vmalloc(unsigned long size)
{
       return __vmalloc(size, GFP_KERNEL | __GFP_HIGHMEM, PAGE_KERNEL);
}

void *__vmalloc(unsigned long size, gfp_t gfp_mask, pgprot_t prot)
{
	return kmalloc(size, (gfp_mask | __GFP_COMP) & ~__GFP_HIGHMEM);
}

其中，参数size为所请求内存的大小，返回值为所获得内存虚拟地址指针。

与vmalloc()配套的释放函数如下：

void vfree(const void *addr)
{
	kfree(addr);
}

其中，参数addr为待释放内存指针。

函数kmalloc()

kmalloc()是内核另一个常用的内核分配函数，它可以分配一段未清零的连续物理内存页，返回值为直接映射地址。由kmalloc()可分配的内存最大不能超过32页。其优点是分配速度快，缺点是不能分配大于128KB的内存页（出于跨平台考虑）。

在linux/slab.h文件中，该函数的原型声明如下：

static __always_inline void *kmalloc(size_t size, gfp_t flags)
{
	struct kmem_cache *cachep;
	void *ret;

	if (__builtin_constant_p(size)) {
		int i = 0;

		if (!size)
			return ZERO_SIZE_PTR;

#define CACHE(x) \
		if (size <= x) \
			goto found; \
		else \
			i++;
#include <linux/kmalloc_sizes.h>
#undef CACHE
		return NULL;
found:
#ifdef CONFIG_ZONE_DMA
		if (flags & GFP_DMA)
			cachep = malloc_sizes[i].cs_dmacachep;
		else
#endif
			cachep = malloc_sizes[i].cs_cachep;

		ret = kmem_cache_alloc_notrace(cachep, flags);

		trace_kmalloc(_THIS_IP_, ret,
			      size, slab_buffer_size(cachep), flags);

		return ret;
	}
	return __kmalloc(size, flags);
}

其中，参数size为以字节为单位表示的所申请空间的大小；参数flags决定了所分配的内存适合什么场合。

与函数kmalloc()对应的释放函数如下：

void kfree(const void *objp)
{
	struct kmem_cache *c;
	unsigned long flags;

	trace_kfree(_RET_IP_, objp);

	if (unlikely(ZERO_OR_NULL_PTR(objp)))
		return;
	local_irq_save(flags);
	kfree_debugcheck(objp);
	c = virt_to_cache(objp);
	debug_check_no_locks_freed(objp, obj_size(c));
	debug_check_no_obj_freed(objp, obj_size(c));
	__cache_free(c, (void *)objp);
	local_irq_restore(flags);
}

小结一下，kmalloc、vmalloc、malloc的区别：

• kmalloc和vmalloc是分配的是内核的内存，malloc分配的是用户的内存；
• kmalloc保证分配的内存在物理上是连续的，vmalloc保证的是在虚拟地址空间上的连续，malloc不保证任何东西；
• kmalloc能分配的大小有限，vmalloc和malloc能分配的大小相对较大；
• vmalloc比kmalloc要慢。

也就是说：kmalloc、vmalloc这两个函数所分配的内存都处于内核空间，即从3GB～4GB；但位置不同，kmalloc()分配的内存处于3GB～high_memory（ZONE_DMA、ZONE_NORMAL）之间，而vmalloc()分配的内存在VMALLOC_START～4GB（ZONE_HIGHMEM）之间，也就是非连续内存区。一般情况下在驱动程序中都是调用kmalloc()来给数据结构分配内存，而vmalloc()用在为活动的交换区分配数据结构，为某些I/O驱动程序分配缓冲区，或为模块分配空间。

可参考文章：Kmalloc和Vmalloc的区别。

函数alloc_pages()

与上述在虚拟空间分配内存的函数不同，alloc_pages()是在物理内存空间分配物理页框的函数，其原型如下：

static inline struct page * alloc_pages(gfp_t gfp_mask, unsigned int order)
{
	if (unlikely(order >= MAX_ORDER))
		return NULL;

	return alloc_pages_current(gfp_mask, order);
}

其中，参数order表示所分配页框的数目，该数目为2^order。order的最大值由include/Linux/Mmzone.h文件中的宏MAX_ORDER决定。参数gfp_mask为说明内存页框分配方式及使用场合。

函数返回值为页框块的第一个页框page结构的地址。

调用下列函数可以获得页框的虚拟地址：

void *page_address(struct page *page)
{
	unsigned long flags;
	void *ret;
	struct page_address_slot *pas;
 
	if (!PageHighMem(page))
		return lowmem_page_address(page);
 
	pas = page_slot(page);
	ret = NULL;
	spin_lock_irqsave(&pas->lock, flags);
	if (!list_empty(&pas->lh)) {
		struct page_address_map *pam;
 
		list_for_each_entry(pam, &pas->lh, list) {
			if (pam->page == page) {
				ret = pam->virtual;
				goto done;
			}
		}
	}
done:
	spin_unlock_irqrestore(&pas->lock, flags);
	return ret;
}

使用函数alloc_pages()获得的内存应该使用下面的函数释放：

void __free_pages(struct page *page, unsigned int order)
{
	if (put_page_testzero(page)) {
		if (order == 0)
			free_hot_page(page);
		else
			__free_pages_ok(page, order);
	}
}

函数kmap()

kmap()是一个映射函数，它可以将一个物理页框映射到内核空间的可持久映射区。这种映射类似于内核ZONE_NORMAL的固定映射，但虚拟地址与物理地址的偏移不一定是PAGE_OFFSET。由于内核可持久映射区的容量有限（总共只有4MB），因此当内存使用完毕后，应该立即释放。

函数kmap()的函数原型如下：

void *kmap(struct page *page)
{
	might_sleep();
	if (!PageHighMem(page))
		return page_address(page);
	return kmap_high(page);
}

小结

由于CPU的地址总线只有32位， 32的地址总线无论是从逻辑上还是从物理上都只能描述4G的地址空间（232=4Gbit），在物理上理论上最多拥有4G内存（除了IO地址空间，实际内存容量小于4G），逻辑空间也只能描述4G的线性地址空间。

为了合理的利用逻辑4G空间，Linux采用了3：1的策略，即内核占用1G的线性地址空间，用户占用3G的线性地址空间。所以用户进程的地址范围从0~3G，内核地址范围从3G~4G，也就是说，内核空间只有1G的逻辑线性地址空间。

Si la mémoire physique Linux est inférieure à 1 Go d'espace, le noyau mappe généralement linéairement la mémoire physique sur son espace d'adressage, c'est-à-dire un mappage un à un, ce qui peut améliorer la vitesse d'accès. Cependant, lorsque la mémoire physique Linux dépasse 1 Go, le mécanisme d'accès linéaire ne suffit pas, car seul 1 Go de mémoire peut être mappé et la mémoire physique restante ne peut pas être gérée par le noyau. Par conséquent, afin de résoudre ce problème, Linux L'adresse. est divisée en deux parties, la zone linéaire et la zone non linéaire. La zone linéaire doit être d'un maximum de 896 M, et les 128 M restants sont la zone non linéaire. Par conséquent, la mémoire physique mappée par la zone linéaire devient une mémoire bas de gamme et la mémoire physique restante est appelée mémoire haut de gamme. Contrairement aux régions linéaires, les régions non linéaires ne sont pas mappées en mémoire à l'avance, mais mappées dynamiquement lorsqu'elles sont utilisées.

La mémoire bas de gamme est divisée en deux parties : ZONE_DMA : 16 Mo au début de l'espace noyau, ZONE_NORMAL : 16 Mo ~ 896 Mo de l'espace noyau (mappage fixe). Le reste est de la mémoire haut de gamme : ZONE_HIGHMEM : espace noyau 896 Mo ~ fin (1G).

Selon les différents objectifs de l'application, la mémoire haut de gamme est divisée en trois parties : la zone vmalloc, la zone de mappage persistant et la zone de mappage temporaire. La zone vmalloc est allouée à l'aide de la fonction vmalloc() ; la zone de mappage persistante utilise allc_pages() pour obtenir la page correspondante, et est directement mappée à l'aide de la fonction kmap() ; la zone de mappage temporaire est généralement utilisée pour des besoins particuliers. "Espace utilisateur et espace noyau" Oui Zone de cartographie persistante

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!