[内核内存] 伙伴系统4---alloc_pages(内存块分配)

最新推荐文章于 2024-08-24 17:07:34 发布
最新推荐文章于 2024-08-24 17:07:34 发布
阅读量3k 收藏 22
点赞数 3
分类专栏： linux内存 文章标签： 伙伴系统 linux内核内存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010923083/article/details/115873669
版权

文章目录

alloc_pages源码流程分析

alloc_pages开始了真正的页面申请,函数作用是:用于申请一块2^order的连续物理内存块

alloc_pages函数实现流程

在这里插入图片描述

代码细节分析

参数准备

//include/linux/gfp.h
/*numa_node_id()返回当前所在节点编号*/
#define alloc_pages(gfp_mask, order) \
		alloc_pages_node(numa_node_id(), gfp_mask, order)
		
static inline struct page *alloc_pages_node(int nid, gfp_t gfp_mask,
						unsigned int order)
{
	//nid最好是传递过来的参数，若参数无效，则会选择一个目前距离cup最近的一个在线节点
	if (nid == NUMA_NO_NODE)
		nid = numa_mem_id();

	return __alloc_pages_node(nid, gfp_mask, order);
}

static inline struct page *
__alloc_pages_node(int nid, gfp_t gfp_mask, unsigned int order)
{
	VM_BUG_ON(nid < 0 || nid >= MAX_NUMNODES);
	VM_WARN_ON(!node_online(nid));
	//node_zonelist(nid, gfp_mask)是用于获取node节点的zone管理区列表,按优先级顺序存储
	return __alloc_pages(gfp_mask, order, node_zonelist(nid, gfp_mask));
}

static inline struct page *
__alloc_pages(gfp_t gfp_mask, unsigned int order,
		struct zonelist *zonelist)
{
	return __alloc_pages_nodemask(gfp_mask, order, zonelist, NULL);
}

核心函数__alloc_pages_nodemask

_alloc_pages_nodemask是伙伴系统的心脏，处理实质的内存分配工作。

  • （1）先进行参数初始化:alloc_mask, alloc_flags和struct alloc_context ac，用于决定内存块的分配配条件。
  • （2） get_page_from_freelist:内核内存环境良好，直接进行快速分配，若成功返回获取free内存块
  • （3）__alloc_pages_slowpath:当前内存环境恶劣时，进入慢分配流程，若成功返回free内存块
  • （4）获取空间内存块后对内存块和系统环境做检查，满足预定要求则返回申请的内存给内核使用
//mm/page_alloc.c
struct page *
__alloc_pages_nodemask(gfp_t gfp_mask, unsigned int order,
			struct zonelist *zonelist, nodemask_t *nodemask)
{
	struct page *page;
	//分配标志，仅在低水位water mark及以上限制页面分配
	unsigned int alloc_flags = ALLOC_WMARK_LOW;
	gfp_t alloc_mask = gfp_mask; /* The gfp_t that was actually used for allocation */
	//用于存储函数间传递的参数
	struct alloc_context ac = {
		//gfp对应的zone,参考文档'如何根据gfp_flag找到对应的zone',内存分配的zoneidx一定小于等于该idx
		.high_zoneidx = gfp_zone(gfp_mask),
		//zone优先级搜索列表
		.zonelist = zonelist,
		.nodemask = nodemask,
		//根据gfp找到迁移类型,gfp_flags的bit3-bit4表示migrate类型
		.migratetype = gfpflags_to_migratetype(gfp_mask),
	};

	if (cpusets_enabled()) {
		alloc_mask |= __GFP_HARDWALL;
		alloc_flags |= ALLOC_CPUSET;
		if (!ac.nodemask)
			ac.nodemask = &cpuset_current_mems_allowed;
	}

	gfp_mask &= gfp_allowed_mask;
    //需要CONFIG_TRACE_IRQFLAGS和CONFIG_PROVE_LOCKING同时定义的时候，才起作用，否则为空函数
	lockdep_trace_alloc(gfp_mask);
    /*如果申请页面传入的gfp_mask掩码携带__GFP_WAIT标识，表示允许页面申请时休眠，
	 *则会进入might_sleep_if()检查是否需要休眠等待以及重新调度
	 */
	might_sleep_if(gfp_mask & __GFP_DIRECT_RECLAIM);
    //由于未设置CONFIG_FAIL_PAGE_ALLOC，则should_fail_alloc_page()恒定返回false
	if (should_fail_alloc_page(gfp_mask, order))
		return NULL;

	/*
	 * Check the zones suitable for the gfp_mask contain at least one
	 * valid zone. It's possible to have an empty zonelist as a result
	 * of __GFP_THISNODE and a memoryless node
	 */
	 //用于检查当前申请页面的内存管理区zone是否为空
	if (unlikely(!zonelist->_zonerefs->zone))
		return NULL;

	if (IS_ENABLED(CONFIG_CMA) && ac.migratetype == MIGRATE_MOVABLE)
		alloc_flags |= ALLOC_CMA;

	/* Dirty zone balancing only done in the fast path */
	ac.spread_dirty_pages = (gfp_mask & __GFP_WRITE);

	/*
	 * The preferred zone is used for statistics but crucially it is
	 * also used as the starting point for the zonelist iterator. It
	 * may get reset for allocations that ignore memory policies.
	 */
	//用于根据nodemask，找到合适的不大于high_zoneidx的内存管理区preferred_zone
	ac.preferred_zoneref = first_zones_zonelist(ac.zonelist,
					ac.high_zoneidx, ac.nodemask);
	//选择出的zone为NULL，进入慢分配
	if (!ac.preferred_zoneref->zone) {
		page = NULL;
		/*
		 * This might be due to race with cpuset_current_mems_allowed
		 * update, so make sure we retry with original nodemask in the
		 * slow path.
		 */
		goto no_zone;
	}
    
	/* First allocation attempt(快速路径分配) */
	page = get_page_from_freelist(alloc_mask, order, alloc_flags, &ac);
	if (likely(page))
		goto out;

no_zone:
	/*
	 * Runtime PM, block IO and its error handling path can deadlock
	 * because I/O on the device might not complete.
	 */
	alloc_mask = memalloc_noio_flags(gfp_mask);
	ac.spread_dirty_pages = false;

	/*
	 * Restore the original nodemask if it was potentially replaced with
	 * &cpuset_current_mems_allowed to optimize the fast-path attempt.
	 */
	if (unlikely(ac.nodemask != nodemask))
		ac.nodemask = nodemask;

	page = __alloc_pages_slowpath(alloc_mask, order, &ac);

out:
    /*返回的page检查和系统当前环境检查*/
    //memcg_kmem_newpage_charge()与控制组群Cgroup相关
	if (memcg_kmem_enabled() && (gfp_mask & __GFP_ACCOUNT) && page &&
	    unlikely(memcg_kmem_charge(page, gfp_mask, order) != 0)) {
		__free_pages(page, order);
		page = NULL;
	}

	if (kmemcheck_enabled && page)
		kmemcheck_pagealloc_alloc(page, order, gfp_mask);

	trace_mm_page_alloc(page, order, alloc_mask, ac.migratetype);

	return page;
}
EXPORT_SYMBOL(__alloc_pages_nodemask);

__alloc_pages_nodemask()分配内存页面的关键函数是：get_page_from_freelist()和__alloc_pages_slowpath()，其中所谓的快速分配就是直接从现有的内存中去分配，如果不成功，再去尝试慢速分配。慢速分配会进行内存压缩，回收，然后再去尝试分配内存。

快速内存分配（get_page_from_freelist)

get_page_from_freelist()最先用于尝试页面分配，它通过标志集和分配阶（order）来判断是否能进行请求的内存分配操作，如果分配失败的情况下，则会进一步调用__alloc_pages_slowpath()。下面先展示该函数代码流程图，然后再具体分析代码实现细节

get_page_from_freelist流程图

在这里插入图片描述
图片参考LoyenWang博主的内存分配器

get_page_from_freelist代码实现细节
//mm/page_alloc.c
static struct page *
get_page_from_freelist(gfp_t gfp_mask, unsigned int order, int alloc_flags,
						const struct alloc_context *ac)
{
	struct zoneref *z = ac->preferred_zoneref;
	struct zone *zone;
	struct pglist_data *last_pgdat_dirty_limit = NULL;
	 /*
	  *该for循环遍历备用列表所有的内存区域，查找到一个合适的空闲内存块
	  *即是遍历ac->zonelist中不大于ac->high_zoneidx的所有zone
	  */
	for_next_zone_zonelist_nodemask(zone, z, ac->zonelist, ac->high_zoneidx,
								ac->nodemask) {
		struct page *page;
		unsigned long mark;
        /*
		 *（1）__cpuset_zone_allowed_softwall是一个辅助函数,用于检查给定内存域是否属于该进程允许运行的      
		 *    CPU
		 *（2）如果使能cpuset而且设置了ALLOC_CPUSET标志就检查看当前CPU是否允许在内存域zone所在结点中分配
		 *     内存
		 */
		if (cpusets_enabled() &&
			(alloc_flags & ALLOC_CPUSET) &&
			!__cpuset_zone_allowed(zone, gfp_mask))
				continue;
		
        // ac->spread_dirty_pages不为零标识本次内存分配用于写，可能增加脏页数
		if (ac->spread_dirty_pages) {
			
            //如果当前zone所在节点被标记为脏页超标就跳过
			if (last_pgdat_dirty_limit == zone->zone_pgdat)
				continue;
            //检查zone所在节点脏页数是否超过限制
			if (!node_dirty_ok(zone->zone_pgdat)) {
				last_pgdat_dirty_limit = zone->zone_pgdat;
				continue;
			}
		}
        /*
		 *接下来检查所遍历到的内存域是否有足够的空闲页，空闲内存页中是否具有大小为2^order大小的连续内存块。
		 *如果没有足够的空闲页或者没有连续内存块可满足分配请求(两者出现任意一个)，则将循环进行到备用列表中
		 *的下一个内存域，作同样的检查. 直到找到一个合适的空闲且连续的内存页块, 才会进行try_this_node进行
		 *内存分配
		 */
		//获取分配所用水印
		mark = zone->watermark[alloc_flags & ALLOC_WMARK_MASK];
		//检查zone中空闲内存是否在水印之上
		if (!zone_watermark_fast(zone, order, mark,
				       ac_classzone_idx(ac), alloc_flags)) {
			int ret;

			/* Checked here to keep the fast path fast */
			BUILD_BUG_ON(ALLOC_NO_WATERMARKS < NR_WMARK);
			//如果设置无忽略水印标志就尝试从当前选定zone中分配内存
			if (alloc_flags & ALLOC_NO_WATERMARKS)
				goto try_this_zone;
            
            /*程序运行到此处说明空闲页在水印之下，接下来需要做内存回收，但有两种特殊情况:
			 *1. 如果系统不允许内存回收；
			 *2. 如果目标zone和当前zone的distance不小于RECLAIM_DISTANCE
			 */
			if (node_reclaim_mode == 0 ||
			    !zone_allows_reclaim(ac->preferred_zoneref->zone, zone))
				continue;
            //node_reclaim内存回收函数
			ret = node_reclaim(zone->zone_pgdat, gfp_mask, order);
			switch (ret) {
            //设置了禁止扫描的标志
			case NODE_RECLAIM_NOSCAN:
				/* did not scan */
				continue;
            //没有可回收的页
			case NODE_RECLAIM_FULL:
				/* scanned but unreclaimable */
				continue;
			default:				
				//回收了部分页再次检查看是否满足水印限制
				if (zone_watermark_ok(zone, order, mark,
						ac_classzone_idx(ac), alloc_flags))
					goto try_this_zone;

				continue;
			}
		}
//执行到此处代表选定的zone的有满足要求的空闲内存块
try_this_zone:
        //内存分配
		page = buffered_rmqueue(ac->preferred_zoneref->zone, zone, order,
				gfp_mask, alloc_flags, ac->migratetype);
		if (page) {
            //清除相关标志或者设置联合页
			prep_new_page(page, order, gfp_mask, alloc_flags);

			/*
			 * If this is a high-order atomic allocation then check
			 * if the pageblock should be reserved for the future
			 */
            /*
             *在申请page的时候，会通过判定该page申请时的一些flags配置,若alloc_flags的ALLOC_HARDER被设置，且
             *order != 0,则认为该page是从高阶内存块分配下来的.通过reserve_highatomic_pageblock尝试将该页加入到
             *highatomic_pageblock中(highatomic_pageblock页面数量不能超过zone里面page的1/100).
             */
			if (unlikely(order && (alloc_flags & ALLOC_HARDER)))
				reserve_highatomic_pageblock(page, zone, order);

			return page;
		}
	}

	return NULL;
}
慢速内存分配(__alloc_pages_slowpath())

__alloc_pages_slowpath()是用于慢速页面分配，允许等待,内存压缩和内存回收等.需要注意的是慢速分配仍然要调用到get_page_from_freelist函数来进行内存的获取，慢速分配的大致过程概况如下：

  1. 降低水印ALLOC_WMARK_MIN，如果设置了GFP_KSWAPD_RECLAIM就唤醒交换线程
  2. 调用get_page_from_freelist尝试重新分配
  3. 如果分配的页阶大于0尝试内存规整操作，通过内存迁移合并出较大的内存块，然后尝试内存分配
  4. 如果设置了GFP_KSWAPD_RECLAIM再次唤醒交换线程，确保交换线程不会意外睡去
  5. 直接进行内存回收之后尝试分配
  6. 如果内存回收没有分配到所需内存，就再次进行内存规整之后尝试分配内存
  7. 如果当前内存获取仍然失败就尝试杀死一些进程后再尝试分配内存
  8. （内存获取还未成功）检查分配标志是否存在一些潜在可调的空间，然后再次调用get_page_from_freelist尝试份分配
  9. 最后若获取到需要的内存空间返回空闲内存，若系统尽了最大努力仍然无法提供需要的空闲内存则返回NULL
__alloc_pages_slowpath函数流程图

在这里插入图片描述
图片参考LoyenWang博主的内存分配器

__alloc_pages_slowpath代码实现细节
//mm/page_alloc.c
static inline struct page *
__alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,
						struct alloc_context *ac)
{
....
....
....
retry_cpuset:
	compaction_retries = 0;
	no_progress_loops = 0;
	compact_priority = DEF_COMPACT_PRIORITY;
	cpuset_mems_cookie = read_mems_allowed_begin();

	//重置nodemask和zonelist，因为可能在fast path中对值进行了更新
	ac->preferred_zoneref = first_zones_zonelist(ac->zonelist,
					ac->high_zoneidx, ac->nodemask);
	if (!ac->preferred_zoneref->zone)
		goto nopage;


    //降低水印ALLOC_WMARK_MIN重新构建分配标志（保守内存分配转向为激进内存分配）
	alloc_flags = gfp_to_alloc_flags(gfp_mask);
    //如果设置了__GFP_KSWAPD_RECLAIM,当内存太低或零散则唤醒交换线程
	if (gfp_mask & __GFP_KSWAPD_RECLAIM)
		wake_all_kswapds(order, ac);


	//调整后重新利用get_page_from_freelist进行内存分配
	page = get_page_from_freelist(gfp_mask, order, alloc_flags, ac);
	if (page)
		goto got_pg;


	/*
	 *前面没有分配到内存可能由于内存碎片的缘故，调用函数__alloc_pages_direct_compact
	 *尝试内存规整操作，进行页的迁移，然后再尝试分配执行该操作需要同时满足如下条件:
	 *(1)分配请求允许直接回收（gfp_mask & __GFP_DIRECT_RECLAI为真）
	 *(2)内存分配的阶要大于3（PAGE_ALLOC_COSTLY_ORDER）：因为低阶内存块受内存碎片化影响较小，内存规整不能解决问
	 *   题
	 *(3)本次内存分配不能是无水线限制的内存分配，函数gfp_pfmemalloc_allowed(gfp_mask)返回false
	 */
	if (can_direct_reclaim && order > PAGE_ALLOC_COSTLY_ORDER &&
		!gfp_pfmemalloc_allowed(gfp_mask)) {
		page = __alloc_pages_direct_compact(gfp_mask, order,
						alloc_flags, ac,
						INIT_COMPACT_PRIORITY,
						&compact_result);
		if (page)
			goto got_pg;

		/*
		 * Checks for costly allocations with __GFP_NORETRY, which
		 * includes THP page fault allocations
		 */
		if (gfp_mask & __GFP_NORETRY) {

			if (compact_result == COMPACT_DEFERRED)
				goto nopage;
            
			compact_priority = INIT_COMPACT_PRIORITY;
		}
	}

retry:
	/* Ensure kswapd doesn't accidentally go to sleep as long as we loop */
	//确保交换线程没有意外睡去
	if (gfp_mask & __GFP_KSWAPD_RECLAIM)
		wake_all_kswapds(order, ac);
    
    //对gfp_mask进行分析看是否可以不受水线限制进行内存分配
	if (gfp_pfmemalloc_allowed(gfp_mask))
		alloc_flags = ALLOC_NO_WATERMARKS;

	 //调整nodemask和zonelist
	if (!(alloc_flags & ALLOC_CPUSET) || (alloc_flags & ALLOC_NO_WATERMARKS)) {
		ac->preferred_zoneref = first_zones_zonelist(ac->zonelist,
					ac->high_zoneidx, ac->nodemask);
	}

	/* Attempt with potentially adjusted zonelist and alloc_flags */
	page = get_page_from_freelist(gfp_mask, order, alloc_flags, ac);
	if (page)
		goto got_pg;

	/* Caller is not willing to reclaim, we can't balance anything */
	if (!can_direct_reclaim) {
		WARN_ON_ONCE(gfp_mask & __GFP_NOFAIL);
		goto nopage;
	}
	/* Avoid recursion of direct reclaim */
    //如果当前进程不能使用紧急内存，内存回收很可能会失败，容易造成递归调用
	if (current->flags & PF_MEMALLOC) {
		if (WARN_ON_ONCE(gfp_mask & __GFP_NOFAIL)) {
			cond_resched();
			goto retry;
		}
		goto nopage;
	}

	/* Avoid allocations with no watermarks from looping endlessly */
	if (test_thread_flag(TIF_MEMDIE) && !(gfp_mask & __GFP_NOFAIL))
		goto nopage;


	/* Try direct reclaim and then allocating */
    //防止非__GFP_NOFAIL内存分配多次retry
	page = __alloc_pages_direct_reclaim(gfp_mask, order, alloc_flags, ac,
							&did_some_progress);
	if (page)
		goto got_pg;

	/* Try direct compaction and then allocating */
    //进行直接内存回收，回收完后再次尝试内存分配
	page = __alloc_pages_direct_compact(gfp_mask, order, alloc_flags, ac,
					compact_priority, &compact_result);
	if (page)
		goto got_pg;

	/* Do not loop if specifically requested */
	if (gfp_mask & __GFP_NORETRY)
		goto nopage;

	/*
	 * 除非gfp_mask设置了__GFP_REPEAT标志，否则退出高阶的空闲内存的循环申请（costly）
	 */
	if (order > PAGE_ALLOC_COSTLY_ORDER && !(gfp_mask & __GFP_REPEAT))
		goto nopage;

	/* 告知该空闲内存申请时间已经过长 */
	if (time_after(jiffies, alloc_start + stall_timeout)) {
		warn_alloc(gfp_mask,
			"page allocation stalls for %ums, order:%u",
			jiffies_to_msecs(jiffies-alloc_start), order);
		stall_timeout += 10 * HZ;
	}
    /*检查是否有必要重新做内存回收*/
	if (should_reclaim_retry(gfp_mask, order, ac, alloc_flags,
				 did_some_progress > 0, &no_progress_loops))
		goto retry;

	/*检查是否有必要重新进行内存规整*/
	if (did_some_progress > 0 &&
			should_compact_retry(ac, order, alloc_flags,
				compact_result, &compact_priority,
				&compaction_retries))
		goto retry;

	 /*在开始进行OOM KILL前先检查cpuset是否更新若更新，则跳转到retry_cpuset*/
	if (read_mems_allowed_retry(cpuset_mems_cookie))
		goto retry_cpuset;

	/*前面的一系列工作，都没有成功分配到需要的空闲内存，开启oom杀死一些进
	 *程，并从新获取的页面中直接进行空闲内存分配 
	 */
	page = __alloc_pages_may_oom(gfp_mask, order, ac, &did_some_progress);
	if (page)
		goto got_pg;

	/* Retry as long as the OOM killer is making progress */
	/*当直接从oom获取到的页面分配内存失败，且oom已经杀死了一些优先级低的进程,
	 *此时将no_progress_loops赋值为0，并跳转到retry再一次进行内存分配操作
	 */
	if (did_some_progress) {
		no_progress_loops = 0;
		goto retry;
	}

nopage:
	 /*
	  *如果检查到cpuset更新，并检测到竞争情况则，跳转到retry_cpuset，重新按流程分配内存
	  */
	if (read_mems_allowed_retry(cpuset_mems_cookie))
		goto retry_cpuset;

	warn_alloc(gfp_mask,
			"page allocation failure: order:%u", order);
got_pg:
	return page;
}
早起的虫儿有鹰吃
关注
专栏目录
linux内核那些事之buddy(慢速申请内存__alloc_pages_slowpath)(5)
weixin_42730667的博客
03-22 1233
内核提供__alloc_pages_nodemask接口申请物理内存主要分为两个部分：快速申请物理内存get_page_from_freelist（inux内核那些事之buddy(快速分配get_page_from_freelist()）(3)）和慢速申请__alloc_pages_slowpath慢速申请内存部分两个部分如下图： 首先尝试快速申请内存get_page_from_freelist，在快速内存中如果当前水位wmark_pages满足要求则调用get_page_from_free_are.
linux内核分配物理页面alloc_pages
软工电子行
08-20 186
linux内核分配物理页空间
Buddy system之alloc_pages
liuhangtiant的博客
07-15 718
申请pages的基础知识在“Buddy system基础 ”这篇文章中已经讲过了，这里主要分析申请pages的代码。 代码框架 alloc_pages //alloc_pages_node(numa_node_id(), gfp_mask, order) |-----&gt;return __alloc_pages_node(nid, gfp_mask, order); |...
Linux内存子系统——分配物理页面（alloc_pages）
深海
08-22 4893
Linux内存子系统——分配物理页面（alloc_pages）分配页面   内核中常用的分配物理内存页面的接口函数是alloc_pages()，用于分配一个或多个连续的物理页面，分配的页面个数只能是2的整数次幂。   诸如vmalloc、get_user_pages、以及缺页中断中分配页面，都是通过该接口分配的物理页面。 分配页面   alloc_pages函数有两个参数，一个是分配掩码gfp_mask，另一个是分配阶数order。 [include/linux/gfp.h] #define alloc_p
内存管理篇-07页分配器接口-alloc_page
最新发布
LuckyDog0623的博客
08-24 308
----终于到了编码实战阶段了，前面都是在将思想和实现机制，即使看了源代码还是模模糊糊，不够清晰。本节通过内核接口从伙伴系统进行申请和释放内存。其实很多缓存机制最终都是通过伙伴系统申请一大片内存，然后内部再进行对这些页处理优化。伙伴系统提供了free_page和alloc_pages两个函数进行申请和释放内存，至于函数内部的实现机制，这里还没开始讲，主要讲了如何使用。
内存管理-alloc_pages()函数分配内存
qq_43084535的博客
01-12 1723
前言 Linux对页面分配分快速和慢速两种方法。在__alloc_pages_nodemask函数中，首先会使用快速方法进行内存分配，当分配失败时会进入慢速路径，函数最终会返回申请到的内存第一个页面page。本文主要对内存分配中的快速方法所涉及到的重要函数进行分析。 alloc_pages() 这个函数是内存分配的入口函数，最终会调用__alloc_pages_nodemask函数，关于内存分配的所以内容都会在这个函数中实现。它在mm/page_alloc.c中实现如下： struct page * __a
Linux内存管理内核API函数alloc_pages( )
Tim的嵌入式之旅
06-24 4473
http://blog.163.com/chujb_chen/blog/static/10571112013392331217/函数功能描述：       alloc_pages( )函数以gfp_mask分配方式分配2的order次方（1&lt;&lt;order）个连续的物理页。 输入参数说明：       gfp_mask： 是分配标志，内核分配内存有多种方式，该参数告诉内核如何分配以及在哪...
Linux内存管理(六): 分配物理内存alloc_pages
热门推荐
Hober
02-21 1万+
分配物理内存alloc_pages
linux内存管理（四）源码解析之伙伴系统alloc_pages/free_pages
jkzzxQQQ的博客
12-27 963
本文kernel代码分析基于以下 1.linux-4.14.159 2.64bit代码处理逻辑 3.UMA架构 上一节伙伴系统详细介绍了伙伴系统的原理以及描述了页申请和释放的过程，另外对伙伴系统及涉及的一些概念进行了介绍，理解这些后我们来看代码中具体的申请流程和释放流程。 alloc_pages linux内核伙伴系统中分配物理内存常用的接口是alloc_pages(),其它接口最终都会归到alloc_pages()，特点是分配页面的个数是2的整数幂，因此函数无需提供分配的size，只需指明两个参数 第一个
linux-char-driver-by-mmap.zip_linux mmap_mmap
09-24
6. **异常处理**: 在mmap过程中，可能遇到各种错误，例如内存分配失败、地址冲突等。驱动程序需要适当地处理这些异常，通过返回错误码通知用户进程。 通过这种方式，Linux的mmap功能为字符驱动提供了一种高效、灵活...
alloc_page分配内存
m0_74282605的博客
01-14 673
_get_free_pages调用alloc_pages完成内存分配, 而alloc_pages又借助于alloc_pages_node，__get_free_pages函数的定义在mm/page_alloc.c。alloc_flags和gfp_mask之间的区别，gfp_mask是使用alloc_pages申请内存时所传递的申请标记，而alloc_flags是在内存管理子系统内部使用的另一个标记。函数直接将自己的所有信息传递给__alloc_pages_nodemask来完成内存的分配。
alloc_page函数浅析
m0_74282605的博客
02-03 203
147 if (unlikely(order >= MAX_ORDER)) /如果要求分配的页数大于MAX_ORDER就以失败告终，这里的MAX_ORDER指的是最大页面号，这里要注意的是对于伙伴算法，所分配的 页面的最大值为2^10，即1024个页面，这一点在伙伴算法中经常会使用到，所以这里的MAX_ORDER的值为11，也就是说如果order的值大于了10，即超出了最大值，那么就会以失败告终，直接以失败返回。//分配页面函数，这个函数比较复杂，所牵涉到的内容也比较多，尤其是进程方面的内容。
alloc_pages的实现浅析
m0_74282605的博客
01-02 500
假设我们请求分配一个order=2，大小为4的页块，order的最大值是5。我们从order=5的area得到一个大小为32的页块。所以我们order5的页块分配到order=3和order=4的页块。这时，order2 order3 order4分别得到了大小为4,8和16的页块。get_page_from_freelist() 遍历整个 zonelist, 如果找到一个watermark满足要求的zone, 就在这个zone上调用 buffered_rmqueue.原文作者：dennis-wong。
深入alloc_pages
Tonyluzhigang的专栏
11-30 1471
内核所有的内存分配都是通过alloc_pages来实现的。 alloc_pages->     __alloc_pages_nodemask->         get_page_from_freelist (__alloc_pages_slowpath) 如果get_page_from_freelist失败，则调用__alloc_pages_slowpath更深程度的回收内存再分配。
伙伴系统分配器 - __alloc_pages
kickxxx的专栏
07-10 6807
kernel可以通过几个分配函数从伙伴系统分配页面： alloc_pages get_zeroed_page get_dma_pages 这几个函数都是通过alloc_pages来实现页面分配的，而alloc_pages的核心实现就是__alloc_pages。 alloc_pages 在gfp.h中定义 #define alloc_pages(gfp_mask, ord
alloc_pages与page_address
yiyeguzhou100的专栏
11-26 2218
alloc_pages分配2^order个物理页，返回指向第一页结构的指针 eg, page_address返回给定page的线性地址，如果给定的page还没有映射则返回NULL（linux-2.6.11.12\mm\highmem.c） 其中： 内核用数据结构page描述一个页框的状态信息，所有的页描述符存放在全局mem_map
alloc_pages函数分析
qq_34160238的博客
04-05 182
所以分析的实现需要分析这个函数.
alloc_pages()用法
乐于分享
11-05 616
#include <linux/module.h> #include <linux/init.h> #include <asm/atomic.h> #include <linux/gfp.h> #include <linux/mm.h> #include <linux/string.h> #define err(msg) printk(KERN_ALERT "%s\n", msg) static int main_init(void)
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值