struct page的flags成员和常用函数说明

最新推荐文章于 2024-07-28 18:06:21 发布
最新推荐文章于 2024-07-28 18:06:21 发布
阅读量2.2k 收藏 5
点赞数 4
分类专栏： linux 内存管理 文章标签： linux 内核 数据结构 内存管理
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/lunhui2016/article/details/104444842
版权

1.概述

本文主要解析struct page的flags成员中相关bit的含义以及其重要的标志位说明，简单说明一下Linux内核常见的PageXXX()/SetPageXXX()/ClearPageXXX()函数的作用和实现。

内核版本：linux-4.9

2.struct page结构

struct page {
	/* 第一个双字大小的区块 */
	unsigned long flags;		/* Atomic flags, some possibly
					 * updated asynchronously */
	union {
		struct address_space *mapping;	/* If low bit clear, points to
						 * inode address_space, or NULL.
						 * If page mapped as anonymous
						 * memory, low bit is set, and
						 * it points to anon_vma object:
						 * see PAGE_MAPPING_ANON below.
						 */
		void *s_mem;			/* slab first object */
		atomic_t compound_mapcount;	/* first tail page */
		/* page_deferred_list().next	 -- second tail page */
	};

	/* 第二个双字大小的区块 */
	union {
		pgoff_t index;		/* Our offset within mapping. */
		void *freelist;		/* sl[aou]b first free object */
		/* page_deferred_list().prev	-- second tail page */
	};

	union {
#if defined(CONFIG_HAVE_CMPXCHG_DOUBLE) && \
	defined(CONFIG_HAVE_ALIGNED_STRUCT_PAGE)
		/* Used for cmpxchg_double in slub */
		unsigned long counters;
#else
		/*
		 * Keep _refcount separate from slub cmpxchg_double data.
		 * As the rest of the double word is protected by slab_lock
		 * but _refcount is not.
		 */
		unsigned counters;
#endif
		struct {

			union {
				/*
				 * Count of ptes mapped in mms, to show when
				 * page is mapped & limit reverse map searches.
				 *
				 * Extra information about page type may be
				 * stored here for pages that are never mapped,
				 * in which case the value MUST BE <= -2.
				 * See page-flags.h for more details.
				 */
				atomic_t _mapcount;

				unsigned int active;		/* SLAB */
				struct {			/* SLUB */
					unsigned inuse:16;
					unsigned objects:15;
					unsigned frozen:1;
				};
				int units;			/* SLOB */
			};
			/*
			 * Usage count, *USE WRAPPER FUNCTION* when manual
			 * accounting. See page_ref.h
			 */
			atomic_t _refcount;
		};
	};

	/*
	 * 第三个双字大小的区块
	 *
	 * WARNING: bit 0 of the first word encode PageTail(). That means
	 * the rest users of the storage space MUST NOT use the bit to
	 * avoid collision and false-positive PageTail().
	 */
	union {
		struct list_head lru;	/* Pageout list, eg. active_list
					 * protected by zone_lru_lock !
					 * Can be used as a generic list
					 * by the page owner.
					 */
		struct dev_pagemap *pgmap; /* ZONE_DEVICE pages are never on an
					    * lru or handled by a slab
					    * allocator, this points to the
					    * hosting device page map.
					    */
		struct {		/* slub per cpu partial pages */
			struct page *next;	/* Next partial slab */
#ifdef CONFIG_64BIT
			int pages;	/* Nr of partial slabs left */
			int pobjects;	/* Approximate # of objects */
#else
			short int pages;
			short int pobjects;
#endif
		};

		struct rcu_head rcu_head;	/* Used by SLAB
						 * when destroying via RCU
						 */
		/* Tail pages of compound page */
		struct {
			unsigned long compound_head; /* If bit zero is set */

			/* First tail page only */
#ifdef CONFIG_64BIT
			/*
			 * On 64 bit system we have enough space in struct page
			 * to encode compound_dtor and compound_order with
			 * unsigned int. It can help compiler generate better or
			 * smaller code on some archtectures.
			 */
			unsigned int compound_dtor;
			unsigned int compound_order;
#else
			unsigned short int compound_dtor;
			unsigned short int compound_order;
#endif
		};

#if defined(CONFIG_TRANSPARENT_HUGEPAGE) && USE_SPLIT_PMD_PTLOCKS
		struct {
			unsigned long __pad;	/* do not overlay pmd_huge_pte
						 * with compound_head to avoid
						 * possible bit 0 collision.
						 */
			pgtable_t pmd_huge_pte; /* protected by page->ptl */
		};
#endif
	};

	/* 剩余字节非双字对齐 */
	union {
		unsigned long private;		/* Mapping-private opaque data:
					 	 * usually used for buffer_heads
						 * if PagePrivate set; used for
						 * swp_entry_t if PageSwapCache;
						 * indicates order in the buddy
						 * system if PG_buddy is set.
						 */
#if USE_SPLIT_PTE_PTLOCKS
#if ALLOC_SPLIT_PTLOCKS
		spinlock_t *ptl;
#else
		spinlock_t ptl;
#endif
#endif
		struct kmem_cache *slab_cache;	/* SL[AU]B: Pointer to slab */
	};

#ifdef CONFIG_MEMCG
	struct mem_cgroup *mem_cgroup;
#endif

	/*
	 * On machines where all RAM is mapped into kernel address space,
	 * we can simply calculate the virtual address. On machines with
	 * highmem some memory is mapped into kernel virtual memory
	 * dynamically, so we need a place to store that address.
	 * Note that this field could be 16 bits on x86 ... ;)
	 *
	 * Architectures with slow multiplication can define
	 * WANT_PAGE_VIRTUAL in asm/page.h
	 */
#if defined(WANT_PAGE_VIRTUAL)
	void *virtual;			/* Kernel virtual address (NULL if
					   not kmapped, ie. highmem) */
#endif /* WANT_PAGE_VIRTUAL */

#ifdef CONFIG_KMEMCHECK
	/*
	 * kmemcheck wants to track the status of each byte in a page; this
	 * is a pointer to such a status block. NULL if not tracked.
	 */
	void *shadow;
#endif

#ifdef LAST_CPUPID_NOT_IN_PAGE_FLAGS
	int _last_cpupid;
#endif
}

linux内核内存管理的核心数据结构是struct page，其他所有内存管理设施都是以它为中心展开的，如vma管理、缺页中断、页面分配与回收等，该数据结构定义在include/linux/mm_types.h头文件中，大量使用了c语言的union来优化其数据结构大小，因为每个物理页面(页帧)都需要一个struct page数据结构，因此会占用较多的空间。

3.flags成员介绍

struct page中的flags成员是页面的标志位集合，这些标志位是内存管理中非常重要的部分，具体定义在include/linux/page-flags.h文件中，其中重要的标志位如下：

enum pageflags {
	PG_locked,		/* 表示页面已上锁，不要访问 */
	PG_error,     /* 表示页面发生IO错误 */
	PG_referenced, /* 用于RCU算法 */
	PG_uptodate,   /* 表示页面内容有效，当该页面上读操作完成后，设置该标志位 */
	PG_dirty,      /* 表示页面是脏页，内容被修改过 */
	PG_lru,        /* 表示该页面在lrc链表中 */
	PG_active,     /* 表示该页面在活跃lru链表中 */
	PG_slab,       /* 表示该页面是属于slab分配器创建的slab */
	PG_owner_priv_1,	/* 页面的所有者使用，如果是pagecache页面，文件系统可能使用*/
	PG_arch_1,       /* 与体系架构相关的页面状态位 */
	PG_reserved,     /* 表示该页面不可被换出，防止该page被交换到swap */
	PG_private,		/* 如果page中的private成员非空，则需要设置该标志，如果是pagecache, 包含fs-private data */
	PG_private_2,		/* 如果是pagecache, 包含fs aux data */
	PG_writeback,		/* 页面正在回写 */
	PG_head,		/* A head page */
	PG_swapcache,		/* 表示该page处于swap cache中 */
	PG_mappedtodisk,	/* 表示page中的数据在后备存储器中有对应 */
	PG_reclaim,		/* 表示该page要被回收，决定要回收某个page后，需要设置该标志 */
	PG_swapbacked,		/* 该page的后备存储器是swap/ram，一般匿名页才可以回写swap分区 */
	PG_unevictable,		/* 该page被锁住，不能回收，并会出现在LRU_UNEVICTABLE链表中，它包括的几种page：ramdisk或ramfs使用的页、shm_locked、mlock锁定的页 */
#ifdef CONFIG_MMU
	PG_mlocked,		/* 该page在vma中被锁定，一般是通过系统调用mlock()锁定了一段内存 */
#endif
#ifdef CONFIG_ARCH_USES_PG_UNCACHED
	PG_uncached,		/* 该page是uncache的 */
#endif
#ifdef CONFIG_MEMORY_FAILURE
	PG_hwpoison,		/* hardware poisoned page. Don't touch */
#endif
#if defined(CONFIG_IDLE_PAGE_TRACKING) && defined(CONFIG_64BIT)
	PG_young,
	PG_idle,
#endif
	__NR_PAGEFLAGS,

	/* Filesystems */
	PG_checked = PG_owner_priv_1,

	/* Two page bits are conscripted by FS-Cache to maintain local caching
	 * state.  These bits are set on pages belonging to the netfs's inodes
	 * when those inodes are being locally cached.
	 */
	PG_fscache = PG_private_2,	/* page backed by cache */

	/* XEN */
	/* Pinned in Xen as a read-only pagetable page. */
	PG_pinned = PG_owner_priv_1,
	/* Pinned as part of domain save (see xen_mm_pin_all()). */
	PG_savepinned = PG_dirty,
	/* Has a grant mapping of another (foreign) domain's page. */
	PG_foreign = PG_owner_priv_1,

	/* SLOB */
	PG_slob_free = PG_private,

	/* Compound pages. Stored in first tail page's flags */
	PG_double_map = PG_private_2,

	/* non-lru isolated movable page */
	PG_isolated = PG_reclaim,
};

内核定义了一些标准宏，用于检查页面是否设置了某个特定的标志位或者用于操作某些特定的标志位，这些宏的名称都有一定的规律，具体如下：

PageXXX()：用于检查页面是否设置了PG_XXX标志位。如PageLRU(page)检查PG_lru标志位是否置位，PageSlab(page)检查PG_slab是否置位。

SetPageXXX():用于设置页中PG_XXX标志位，如SetPageDirty(page)设置页中PG_dirty标志位。

ClearPageXXX():用于无条件清除某个特定的标志位。

这些宏的实现都在include/linux/page-flags.h文件中定义。如下所示：

/*
 * Macros to create function definitions for page flags
 */
#define TESTPAGEFLAG(uname, lname, policy)				\
static __always_inline int Page##uname(struct page *page)		\
	{ return test_bit(PG_##lname, &policy(page, 0)->flags); }

#define SETPAGEFLAG(uname, lname, policy)				\
static __always_inline void SetPage##uname(struct page *page)		\
	{ set_bit(PG_##lname, &policy(page, 1)->flags); }

#define CLEARPAGEFLAG(uname, lname, policy)				\
static __always_inline void ClearPage##uname(struct page *page)		\
	{ clear_bit(PG_##lname, &policy(page, 1)->flags); }

#define __SETPAGEFLAG(uname, lname, policy)				\
static __always_inline void __SetPage##uname(struct page *page)		\
	{ __set_bit(PG_##lname, &policy(page, 1)->flags); }

#define __CLEARPAGEFLAG(uname, lname, policy)				\
static __always_inline void __ClearPage##uname(struct page *page)	\
	{ __clear_bit(PG_##lname, &policy(page, 1)->flags); }

#define TESTSETFLAG(uname, lname, policy)				\
static __always_inline int TestSetPage##uname(struct page *page)	\
	{ return test_and_set_bit(PG_##lname, &policy(page, 1)->flags); }

#define TESTCLEARFLAG(uname, lname, policy)				\
static __always_inline int TestClearPage##uname(struct page *page)	\
	{ return test_and_clear_bit(PG_##lname, &policy(page, 1)->flags); }

#define PAGEFLAG(uname, lname, policy)					\
	TESTPAGEFLAG(uname, lname, policy)				\
	SETPAGEFLAG(uname, lname, policy)				\
	CLEARPAGEFLAG(uname, lname, policy)

#define __PAGEFLAG(uname, lname, policy)				\
	TESTPAGEFLAG(uname, lname, policy)				\
	__SETPAGEFLAG(uname, lname, policy)				\
	__CLEARPAGEFLAG(uname, lname, policy)

#define TESTSCFLAG(uname, lname, policy)				\
	TESTSETFLAG(uname, lname, policy)				\
	TESTCLEARFLAG(uname, lname, policy)

#define TESTPAGEFLAG_FALSE(uname)					\
static inline int Page##uname(const struct page *page) { return 0; }

#define SETPAGEFLAG_NOOP(uname)						\
static inline void SetPage##uname(struct page *page) {  }

#define CLEARPAGEFLAG_NOOP(uname)					\
static inline void ClearPage##uname(struct page *page) {  }

#define __CLEARPAGEFLAG_NOOP(uname)					\
static inline void __ClearPage##uname(struct page *page) {  }

#define TESTSETFLAG_FALSE(uname)					\
static inline int TestSetPage##uname(struct page *page) { return 0; }

#define TESTCLEARFLAG_FALSE(uname)					\
static inline int TestClearPage##uname(struct page *page) { return 0; }

#define PAGEFLAG_FALSE(uname) TESTPAGEFLAG_FALSE(uname)			\
	SETPAGEFLAG_NOOP(uname) CLEARPAGEFLAG_NOOP(uname)

#define TESTSCFLAG_FALSE(uname)						\
	TESTSETFLAG_FALSE(uname) TESTCLEARFLAG_FALSE(uname)

__PAGEFLAG(Locked, locked, PF_NO_TAIL)
PAGEFLAG(Error, error, PF_NO_COMPOUND) TESTCLEARFLAG(Error, error, PF_NO_COMPOUND)
PAGEFLAG(Referenced, referenced, PF_HEAD)
	TESTCLEARFLAG(Referenced, referenced, PF_HEAD)
	__SETPAGEFLAG(Referenced, referenced, PF_HEAD)
PAGEFLAG(Dirty, dirty, PF_HEAD) TESTSCFLAG(Dirty, dirty, PF_HEAD)
	__CLEARPAGEFLAG(Dirty, dirty, PF_HEAD)
PAGEFLAG(LRU, lru, PF_HEAD) __CLEARPAGEFLAG(LRU, lru, PF_HEAD)
PAGEFLAG(Active, active, PF_HEAD) __CLEARPAGEFLAG(Active, active, PF_HEAD)
	TESTCLEARFLAG(Active, active, PF_HEAD)
__PAGEFLAG(Slab, slab, PF_NO_TAIL)
__PAGEFLAG(SlobFree, slob_free, PF_NO_TAIL)
PAGEFLAG(Checked, checked, PF_NO_COMPOUND)	   /* Used by some filesystems */

/* Xen */
PAGEFLAG(Pinned, pinned, PF_NO_COMPOUND)
	TESTSCFLAG(Pinned, pinned, PF_NO_COMPOUND)
PAGEFLAG(SavePinned, savepinned, PF_NO_COMPOUND);
PAGEFLAG(Foreign, foreign, PF_NO_COMPOUND);

PAGEFLAG(Reserved, reserved, PF_NO_COMPOUND)
	__CLEARPAGEFLAG(Reserved, reserved, PF_NO_COMPOUND)
PAGEFLAG(SwapBacked, swapbacked, PF_NO_TAIL)
	__CLEARPAGEFLAG(SwapBacked, swapbacked, PF_NO_TAIL)
	__SETPAGEFLAG(SwapBacked, swapbacked, PF_NO_TAIL)

/*
 * Private page markings that may be used by the filesystem that owns the page
 * for its own purposes.
 * - PG_private and PG_private_2 cause releasepage() and co to be invoked
 */
PAGEFLAG(Private, private, PF_ANY) __SETPAGEFLAG(Private, private, PF_ANY)
	__CLEARPAGEFLAG(Private, private, PF_ANY)
PAGEFLAG(Private2, private_2, PF_ANY) TESTSCFLAG(Private2, private_2, PF_ANY)
PAGEFLAG(OwnerPriv1, owner_priv_1, PF_ANY)
	TESTCLEARFLAG(OwnerPriv1, owner_priv_1, PF_ANY)

/*
 * Only test-and-set exist for PG_writeback.  The unconditional operators are
 * risky: they bypass page accounting.
 */
TESTPAGEFLAG(Writeback, writeback, PF_NO_COMPOUND)
	TESTSCFLAG(Writeback, writeback, PF_NO_COMPOUND)
PAGEFLAG(MappedToDisk, mappedtodisk, PF_NO_TAIL)

/* PG_readahead is only used for reads; PG_reclaim is only for writes */
PAGEFLAG(Reclaim, reclaim, PF_NO_TAIL)
	TESTCLEARFLAG(Reclaim, reclaim, PF_NO_TAIL)
PAGEFLAG(Readahead, reclaim, PF_NO_COMPOUND)
	TESTCLEARFLAG(Readahead, reclaim, PF_NO_COMPOUND)

#ifdef CONFIG_HIGHMEM
/*
 * Must use a macro here due to header dependency issues. page_zone() is not
 * available at this point.
 */
#define PageHighMem(__p) is_highmem_idx(page_zonenum(__p))
#else
PAGEFLAG_FALSE(HighMem)
#endif

#ifdef CONFIG_SWAP
PAGEFLAG(SwapCache, swapcache, PF_NO_COMPOUND)
#else
PAGEFLAG_FALSE(SwapCache)
#endif

PAGEFLAG(Unevictable, unevictable, PF_HEAD)
	__CLEARPAGEFLAG(Unevictable, unevictable, PF_HEAD)
	TESTCLEARFLAG(Unevictable, unevictable, PF_HEAD)

#ifdef CONFIG_MMU
PAGEFLAG(Mlocked, mlocked, PF_NO_TAIL)
	__CLEARPAGEFLAG(Mlocked, mlocked, PF_NO_TAIL)
	TESTSCFLAG(Mlocked, mlocked, PF_NO_TAIL)
#else
PAGEFLAG_FALSE(Mlocked) __CLEARPAGEFLAG_NOOP(Mlocked)
	TESTSCFLAG_FALSE(Mlocked)
#endif

#ifdef CONFIG_ARCH_USES_PG_UNCACHED
PAGEFLAG(Uncached, uncached, PF_NO_COMPOUND)
#else
PAGEFLAG_FALSE(Uncached)
#endif

#ifdef CONFIG_MEMORY_FAILURE
PAGEFLAG(HWPoison, hwpoison, PF_ANY)
TESTSCFLAG(HWPoison, hwpoison, PF_ANY)
#define __PG_HWPOISON (1UL << PG_hwpoison)
#else
PAGEFLAG_FALSE(HWPoison)
#define __PG_HWPOISON 0
#endif

#if defined(CONFIG_IDLE_PAGE_TRACKING) && defined(CONFIG_64BIT)
TESTPAGEFLAG(Young, young, PF_ANY)
SETPAGEFLAG(Young, young, PF_ANY)
TESTCLEARFLAG(Young, young, PF_ANY)
PAGEFLAG(Idle, idle, PF_ANY)
#endif
lunhui2016
关注
专栏目录
A.1#【内存管理】——1.1.3 page: struct page
SeventhD7
07-11 526
struct page
struct page的flags布局
choumin的专栏
10-08 558
page->flags 只占 8 个字节，64 个 bit 位里存了较多的信息，且受若干配置选项的影响，比如内存模型、zone 数量、node 数量等，有必要简单梳理一下。从下面内核源码的注释可以看到，page->flags 的布局一共分为 5 种情况，第2、4种格式只是多了一个 LAST_CPUID 域，可以暂且不看，同时 FLAGS 域相对比较固定，也可以暂且不看，这里需要分析 SECTION、NODE、ZONE 域的去留问题。 内核中对 page->flags 布局的描述： /
page的几个比较中重要的flag
laughing_zou的专栏
09-11 682
_count:表示内核引用该页面的次数，当_count为0时表示该页面为空闲或者即将被释放，当count大于0时表示该页面正在被使用，暂时不会被释放。 _mapcount:表示该页面被进程映射的个数，即已经映射了多少个pte页表。_mapcount为-1表示没有pte映射页面中去，_mapcount为0表示只有父进程映射了该页面。 PG_active：表示该页面为活跃页面，PG_referen...
Linux6.1.79 页描述符（struct page）
最新发布
weixin_44996644的博客
07-28 872
内存管理、物理页面
PageFlag-crx插件
04-04
语言:English (United States) mark你上次停止在页面上！ 您是否重新访问了一个长ish页面，只是忘记您上次停止阅读的地方？ :face_with_steam_from_nose: PageFlag是一个Chrome扩展，允许您在页面上标记特定段落或标头。 永远不要失去再次阅读阅读！ :smiling_face_with_hearts: ******* PageFlag不会收集任何个人信息，也没有跟踪您访问过哪些网站或多长时间的任何信息。 它也不会将任何数据传输关闭您自己的计算机。
信息量爆表的struct page->flags
ytfy339784578的专栏
02-28 592
先把kernel4.15的一段注释截图送上： 很明显我关注的是之前crash中0x1ffff0000000000与0x5ffff0000000000的含义，然后再来一个神级大图： 上面这个图很不错，但是对于不同的平台通过配置了.config中的参数如CONFIG_NODES_SHIFT、CONFIG_NR_CPUS等，flags中各段占据的字节数和bit分段点是不一样的，不过安排的顺序...
page flags
11-17 573
//@kernel/include/linux/page-flags.h enum pageflags { PG_locked, /* Page is locked. Don't touch. */ PG_error, PG_referenced, PG_uptodate, PG_dirty
新学期立的flag
include_645829461的博客
09-06 380
这几天太丧了，觉得自己太菜了，新学期到了，立以下flag，希望自己能实现： 1.自学前端，每学一部分更新博客，开启前端新坑。 2.继续更python学习博客。 希望自己这个学期结束后，能自信的说我不再像现在那么菜了！ ...
测试和修改page->flags的操作函数位于哪里？
sabolasi
06-17 235
用Source Insight阅读Linux源码的朋友一定注意到过，类似于PageReserved() PageDirty() PageWriteback()之类的函数，都是白色的，找不到它们的定义在哪里。如图所示： 在kernel/include/linux/page-flags.h 中我们找到了答案： 这些函数都是通过宏展开在编译期生成的。 下面以Page...
page-flags-layout.rar_page
09-23
`page-flags-layout.c`这个文件很可能包含了对页标志布局的具体实现，包括定义各个标志的位，以及设置、检查和清除这些标志的函数。通过分析这个源代码，我们可以深入了解Linux内核如何使用页标志来管理内存，以及在...
注释此函数，static void ali_destroy_page(struct page *page, int flags) { if (page) { if (flags & AGP_PAGE_DESTROY_UNMAP) { agp_generic_destroy_page(page, flags); } else agp_generic_destroy_page(page, flags); } }
06-10
static void ali_destroy_page(struct page *page, int flags) { if (page) { if (flags & AGP_PAGE_DESTROY_UNMAP) { agp_generic_destroy_page(page, flags); } else agp_generic_destroy_page(page, ...
Page Flag和mprotect，DEP和NX(EDB)
小气球归来的博客
11-19 696
Page Flag Bit #define _PAGE_BIT_PRESENT 0 /* is present */ #define _PAGE_BIT_RW 1 /* writeable */ #define _PAGE_BIT_USER 2 /* userspace addressable */ #define _PAGE_BIT_PWT 3 /* page write through */ #define _PAGE_BIT_PCD 4 /* page cache disabled */
PageDirty、PageWriteback、PageReclaim、PageReferenced、PageUptodate等page的各个状态源码讲解
dongzhiyan_hjp
08-29 2796
在看内核文件系统read/write、pagecache、内存回收相关代码时，多多少少应该看过if(PageDirty(page))、if(PageWriteback(page))、if(PageReclaim(page))、if (PageReferenced(page))、if (PageUptodate(page))、trylock_page这样内核代码，依次判断page是否有” Dirty”、”writeback”、” Reclaim”、” Referenced”、” Uptodate”、”loc.
linux 的 page 结构体的一点笔记
larryliuqing的专栏-xxx
02-08 4630
http://bbs.bccn.net/thread-374463-1-1.html Linux的内核在内存管理中处理的最小单位是physical pages 然而处理器的的最小的可寻址的单位是byte 或者是 word 很多32位系统构架都是4k的页，64位则是8k的页 所以对于4k的页，1G的内存就有262144个不同的页 内核通过struct page 结构体来表示
【Linux内核学习笔记三】内存管理-页面（page）
wyy4045的专栏
08-29 5449
1.页面     系统的内存划分成大小确定的许多块，这些块也称为页面帧，页帧是系统内存的最小单位。内核需要保持该结构尽可能小，因为对于现代计算机，物理内存包含大量的页帧，即便是增加page一点点空间，都会导致保存所有页帧page结构多占用大量物理内存。例如当页长度为4KB，主内存384MB时大约需要100000页。      每个物理页面帧由一个 struct page 描述。它在&lt;ke...
struct page 理解
鲲的博客
08-26 1807
struct page结构体 为了减少占用的空间，使用联合体，不同的场景下表示不同的意思。 struct page { /* First double word block */ /* 标志位，每个bit代表不同的含义 */ unsigned long flags; /* Atomic flags, some possibly updated asynchronously */ union { /* * 如果mapping = 0，说明该page属于交换缓存（swap cache）
struct page
热门推荐
farmwang的专栏
03-27 1万+
struct page是内存管理中第三个重要的数据结构，它代表系统内存的最小单位。     其数据结构如下所示：struct page { /* First double word block */ unsigned long flags; /* Atomic flags, some possibly * updated a
linux内存中的page,pte,alloc_page的flag
faxiang1230的专栏
05-17 2919
内核中关于内存的这几个flag容易混淆,他们的功能相互关联,下面简要总结一下他们的区别,其中的重要flag的用途 页表项的flag:使用页表项的有两个:CPU和MMU,MMU的功能有两个,将虚拟地址转换为物理地址,检查访问权限是否合法,它是arch完全相关的 page的flag:page是物理地址空间管理的元数据,它是纯粹的软件概念,基本是通用的 alloc_page的flag:根据物理内存的稀有程序,它受到区别对待分成了ZONE_DMA,ZONE_DMA32,ZONE_NORMAL,ZONE_HIGH;而
linux内存子系统源码,linux 3.4.10 内核内存管理源代码分析2：伙伴系统
weixin_42347763的博客
05-04 195
法律声明：《linux 3.4.10 内核内存管理源代码分析》系列文章由机器人()发表于GPL协议。欢迎转载，转载请注明作者和此条款2 伙伴系统Linux采用NUMA模型，所谓NUMA即非一致访问分布共享存储技术。NUMA 系统的结点通常是由一组 CPU(如，SGI Altix 3000 是 2 个Itanium2 CPU)和本地内存组成，有的结点可能还有I/O子系统。由于每个结点都有自己的本地内...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值