page - Linux内存管理（4）

最新推荐文章于 2024-05-11 16:11:57 发布
最新推荐文章于 2024-05-11 16:11:57 发布
阅读量1.6k 收藏 3
点赞数
分类专栏： linux内存管理 文章标签： Linux内存管理



日期 内核版本 架构 作者 GitHub CSDN
2017-07-04 Linux-4.12 X86 lwhuq LinuxMemoryStudy Linux内存管理


  页帧是系统内存的最小单位。对内存中的每个页都会创建struct page实例。内核需要注意保持该结构尽可能小。因为即便在中等程度内存配置下，系统的内存同样会分解为大量的页。例如当页长度为4KB，主内存384MB时大约需要100000页。

1 page结构

  页的广泛使用，增加了保持结构长度的难度。不同的页有不同的用途。某些部分内核需要的页面信息对于另一部分内核可能完全无用。C语言的联合Union很适合解决这个问题。因此在page结构中我们将会看到有很多union。

/*
 * Each physical page in the system has a struct page associated with
 * it to keep track of whatever it is we are using the page for at the
 * moment. Note that we have no way to track which tasks are using
 * a page, though if it is a pagecache page, rmap structures can tell us
 * who is mapping it.
 *
 * The objects in struct page are organized in double word blocks in
 * order to allows us to use atomic double word operations on portions
 * of struct page. That is currently only used by slub but the arrangement
 * allows the use of atomic double word operations on the flags/mapping
 * and lru list pointers also.
 */
struct page {
	/* First double word block */
	/* 用于页描述符，一组标志(如PG_locked、PG_error)，也对页框所在的内存域和node进行编号 */
	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 */
	};

	/* Second double word */
	union {
		/* 在映射的虚拟空间（vma_area）内的偏移；
		 * 一个文件可能只映射一部分，假设映射了1M的空间，
		 * index指的是在1M空间内的偏移，而不是在整个文件内的偏移。 
		 */
		pgoff_t index;		/* Our offset within mapping. */
		/* 用于SLAB描述符，指向第一个空闲对象地址 */
		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.
				 * 页映射计数器, 被页表映射的次数，也就是说该page同时被多少个进程共享。
				 * 初始值为-1，如果只被一个进程的页表映射了，该值为0. 
				 * 如果该page处于伙伴系统中，该值为PAGE_BUDDY_MAPCOUNT_VALUE（-128），
				 * 内核通过判断该值是否为PAGE_BUDDY_MAPCOUNT_VALUE来确定该page是否属于伙伴系统
				 */
				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
			 * 引用计数，表示内核中引用该page的次数, 如果要操作该page, 引用计数会+1, 操作完成-1. 
			 * 当该值为0时, 表示没有引用该page的位置，所以该page可以被解除映射，这往往在内存回收时是有用的
			 */
			atomic_t _refcount;
		};
	};

	/*
	 * Third double word block
	 *
	 * 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 {
		/* 包含到页的最近最少使用(LRU)双向链表的指针，用于插入伙伴系统的空闲链表中，只有块中头页框要被插入 */
		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
	};

	/* Remainder is not double word aligned */
	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
}
};

2 page->mapping

  page->mapping指定了页帧所在的地址空间。page->mapping不仅能够保存一个指针, 而且还能包含一些额外的信息, 用于判断页是否属于未关联到地址空间的某个匿名内存区。
 page->mapping本身是一个指针，指针地址的低几个bit因为对齐的原因都是无用的bit，内核就根据这个特性利用这几个bit来让page->mapping实现更多的含义。一个指针多个用途，这个也是内核为了减少page结构大小的办法之一。 目前用到最低2个bit位。定义在include/linux/page-flags.h#L390。 
/*
 * On an anonymous page mapped into a user virtual memory area,
 * page->mapping points to its anon_vma, not to a struct address_space;
 * with the PAGE_MAPPING_ANON bit set to distinguish it.  See rmap.h.
 *
 * On an anonymous page in a VM_MERGEABLE area, if CONFIG_KSM is enabled,
 * the PAGE_MAPPING_MOVABLE bit may be set along with the PAGE_MAPPING_ANON
 * bit; and then page->mapping points, not to an anon_vma, but to a private
 * structure which KSM associates with that merged page.  See ksm.h.
 *
 * PAGE_MAPPING_KSM without PAGE_MAPPING_ANON is used for non-lru movable
 * page and then page->mapping points a struct address_space.
 *
 * Please note that, confusingly, "page_mapping" refers to the inode
 * address_space which maps the page from disk; whereas "page_mapped"
 * refers to user virtual address space into which the page is mapped.
 */
#define PAGE_MAPPING_ANON	0x1
#define PAGE_MAPPING_MOVABLE	0x2
#define PAGE_MAPPING_KSM	(PAGE_MAPPING_ANON | PAGE_MAPPING_MOVABLE)
#define PAGE_MAPPING_FLAGS	(PAGE_MAPPING_ANON | PAGE_MAPPING_MOVABLE)
  • 当page->mapping == NULL，该page属于交换高速缓存页（swap cache），当需要使用地址空间时会指定交换分区的地址空间swapper_space。
  • 当page->mapping != NULL，并且bit[0] == 0，该page属于页缓存或文件映射，mapping指向文件的地址空间address_space。
  • 当page->mapping != NULL，并且bit[0] ！= 0，该page属于匿名映射，page->mapping指向struct anon_vma对象。通过page->mapping恢复anon_vma的方法如下 
    anon_vma = (struct anon_vma *) (anon_mapping - PAGE_MAPPING_ANON);
  • 当page->mapping != NULL，并且bit[1] ！= 0，当一个匿名映射处于VM_MERGEABLE区域，并且CONFIG_KSM功能打开时，bit[1]可能和bit[0]一起被置起。此时page->mapping不是指向anon_vma，而是指向KSM的一个私有结构。
  内核定义了一些API来取得page->mapping指针的状态，定义在include/linux/page-flags.h#L395。 
static __always_inline int PageMappingFlags(struct page *page)
{
	return ((unsigned long)page->mapping & PAGE_MAPPING_FLAGS) != 0;
}

static __always_inline int PageAnon(struct page *page)
{
	page = compound_head(page);
	return ((unsigned long)page->mapping & PAGE_MAPPING_ANON) != 0;
}

static __always_inline int __PageMovable(struct page *page)
{
	return ((unsigned long)page->mapping & PAGE_MAPPING_FLAGS) ==
				PAGE_MAPPING_MOVABLE;
}

#ifdef CONFIG_KSM
/*
 * A KSM page is one of those write-protected "shared pages" or "merged pages"
 * which KSM maps into multiple mms, wherever identical anonymous page content
 * is found in VM_MERGEABLE vmas.  It's a PageAnon page, pointing not to any
 * anon_vma, but to that page's node of the stable tree.
 */
static __always_inline int PageKsm(struct page *page)
{
	page = compound_head(page);
	return ((unsigned long)page->mapping & PAGE_MAPPING_FLAGS) ==
				PAGE_MAPPING_KSM;点击打开链接
}
#else
TESTPAGEFLAG_FALSE(Ksm)
#endif

3 page->flags

  page的flags标识主要分为5部分，其中标志位flag向高位增长, 其余位字段向低位增长，中间存在空闲位。我们又一次看到一个flags参数被用作多种用途。

3.1 flag
  flag的各个bit位描述了一系列页标志。这些flag是CPU架构独立的，因此通过flag是无法获得特定CPU的信息的。
  page-flages各bit位的具体意义定义在include/linux/page-flags.h#L74
 
/*
 * Various page->flags bits:
 *
 * PG_reserved is set for special pages, which can never be swapped out. Some
 * of them might not even exist (eg empty_bad_page)...
 *
 * The PG_private bitflag is set on pagecache pages if they contain filesystem
 * specific data (which is normally at page->private). It can be used by
 * private allocations for its own usage.
 *
 * During initiation of disk I/O, PG_locked is set. This bit is set before I/O
 * and cleared when writeback _starts_ or when read _completes_. PG_writeback
 * is set before writeback starts and cleared when it finishes.
 *
 * PG_locked also pins a page in pagecache, and blocks truncation of the file
 * while it is held.
 *
 * page_waitqueue(page) is a wait queue of all tasks waiting for the page
 * to become unlocked.
 *
 * PG_uptodate tells whether the page's contents is valid.  When a read
 * completes, the page becomes uptodate, unless a disk I/O error happened.
 *
 * PG_referenced, PG_reclaim are used for page reclaim for anonymous and
 * file-backed pagecache (see mm/vmscan.c).
 *
 * PG_error is set to indicate that an I/O error occurred on this page.
 *
 * PG_arch_1 is an architecture specific page state bit.  The generic code
 * guarantees that this bit is cleared for a page when it first is entered into
 * the page cache.
 *
 * PG_highmem pages are not permanently mapped into the kernel virtual address
 * space, they need to be kmapped separately for doing IO on the pages.  The
 * struct page (these bits with information) are always mapped into kernel
 * address space...
 *
 * PG_hwpoison indicates that a page got corrupted in hardware and contains
 * data with incorrect ECC bits that triggered a machine check. Accessing is
 * not safe since it may cause another machine check. Don't touch!
 */

/*
 * Don't use the *_dontuse flags.  Use the macros.  Otherwise you'll break
 * locked- and dirty-page accounting.
 *
 * The page flags field is split into two parts, the main flags area
 * which extends from the low bits upwards, and the fields area which
 * extends from the high bits downwards.
 *
 *  | FIELD | ... | FLAGS |
 *  N-1           ^       0
 *               (NR_PAGEFLAGS)
 *
 * The fields area is reserved for fields mapping zone, node (for NUMA) and
 * SPARSEMEM section (for variants of SPARSEMEM that require section ids like
 * SPARSEMEM_EXTREME with !SPARSEMEM_VMEMMAP).
 */
enum pageflags {
	PG_locked,		/* Page is locked. Don't touch. 页被锁住时，内核其他部分不允许访问该页*/
	PG_error,		/* 例如设计该页的IO操作期间发生错误，需置起本bit位*/
	PG_referenced,		/* 页被引用标志*/
	PG_uptodate,		/* 该页的数据已经从块设备读取*/
	PG_dirty,		/* 和硬盘数据相比，页的内容已经改变，需置起本bit位，稍后需回写页内容到硬盘*/
	PG_lru,			/* 内核使用两个lru链表来标识活动页和不活动页。如果页在链表中，需置起本bit位*/
	PG_active,		/* 和PG_referenced一起表示页的活跃程度*/
	PG_waiters,		/* Page has waiters, check its waitqueue. Must be bit #7 and in the same byte as "PG_locked" */
	PG_slab,		/* 属于slab分配器的页*/
	PG_owner_priv_1,	/* Owner use. If pagecache, fs may use*/
	PG_arch_1,
	PG_reserved,
	PG_private,		/* If pagecache, has fs-private data */
	PG_private_2,		/* If pagecache, has fs aux data */
	PG_writeback,		/* Page is under writeback 页正在执行写回硬盘操作*/
	PG_head,		/* A head page */
	PG_mappedtodisk,	/* Has blocks allocated on-disk */
	PG_reclaim,		/* To be reclaimed asap 页需要执行回收操作*/
	PG_swapbacked,		/* Page is backed by RAM/swap */
	PG_unevictable,		/* Page is "unevictable"  */
#ifdef CONFIG_MMU
	PG_mlocked,		/* Page is vma mlocked */
#endif
#ifdef CONFIG_ARCH_USES_PG_UNCACHED
	PG_uncached,		/* Page has been mapped as uncached */
#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,

	/* SwapBacked */
	PG_swapcache = PG_owner_priv_1,	/* Swap page: swp_entry_t in private */

	/* 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,
};
  内核定义了一系列操作page-flags的宏，定义在 include/linux/page-flags.h#L198 
/*
 * 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)

3.2 width

  当各个部分的总宽度大于BITS_PER_LONG时，flags可能放不下所有部分。这样flags的最终layout会有5种可能性
  •  No sparsemem or sparsemem vmemmap: |       NODE     | ZONE |             ... | FLAGS |
  •       " plus space for last_cpupid:                   |       NODE     | ZONE | LAST_CPUPID ... | FLAGS |
  •  classic sparse with space for node:             | SECTION | NODE | ZONE |             ... | FLAGS |
  •       " plus space for last_cpupid:                  | SECTION | NODE | ZONE | LAST_CPUPID ... | FLAGS |
  •  classic sparse no space for node:               | SECTION |     ZONE    | ... | FLAGS |
  __NR_PAGEFLAGS为enum pageflags的最大值。
  SECTIONS_WIDTH定义在 include/linux/page-flags-layout.h#L50 
#if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP)
#define SECTIONS_WIDTH		SECTIONS_SHIFT
#else
#define SECTIONS_WIDTH		0
#endif
  ZONES_WIDTH定义在 include/linux/page-flags-layout.h#L55 
#define ZONES_WIDTH		ZONES_SHIFT
  NODES_WIDTH定义在 include/linux/page-flags-layout.h#L58 
#if SECTIONS_WIDTH+ZONES_WIDTH+NODES_SHIFT <= BITS_PER_LONG - NR_PAGEFLAGS
#define NODES_WIDTH		NODES_SHIFT
#else
#ifdef CONFIG_SPARSEMEM_VMEMMAP
#error "Vmemmap: No space for nodes field in page flags"
#endif
#define NODES_WIDTH		0
#endif
  LAST_CPUID_WIDTH定义在 include/linux/page-flags-layout.h#L79 
#if SECTIONS_WIDTH+ZONES_WIDTH+NODES_SHIFT+LAST_CPUPID_SHIFT <= BITS_PER_LONG - NR_PAGEFLAGS
#define LAST_CPUPID_WIDTH LAST_CPUPID_SHIFT
#else
#define LAST_CPUPID_WIDTH 0
#endif

3.3 offset

  flag的offset是0。
  其余部分的offset定义在 include/linux/mm.h#L743 
#define SECTIONS_PGOFF		((sizeof(unsigned long)*8) - SECTIONS_WIDTH)
#define NODES_PGOFF		(SECTIONS_PGOFF - NODES_WIDTH)
#define ZONES_PGOFF		(NODES_PGOFF - ZONES_WIDTH)
#define LAST_CPUPID_PGOFF	(ZONES_PGOFF - LAST_CPUPID_WIDTH)

3.4 mask

  mask定义在include/linux/mm.h#L775

#define ZONES_MASK		((1UL << ZONES_WIDTH) - 1)
#define NODES_MASK		((1UL << NODES_WIDTH) - 1)
#define SECTIONS_MASK		((1UL << SECTIONS_WIDTH) - 1)
#define LAST_CPUPID_MASK	((1UL << LAST_CPUPID_SHIFT) - 1)
#define ZONEID_MASK		((1UL << ZONEID_SHIFT) - 1)

3.5 shift

  shift定义在 include/linux/mm.h#L753 

#define SECTIONS_PGSHIFT	(SECTIONS_PGOFF * (SECTIONS_WIDTH != 0))
#define NODES_PGSHIFT		(NODES_PGOFF * (NODES_WIDTH != 0))
#define ZONES_PGSHIFT		(ZONES_PGOFF * (ZONES_WIDTH != 0))
#define LAST_CPUPID_PGSHIFT	(LAST_CPUPID_PGOFF * (LAST_CPUPID_WIDTH != 0))

/* NODE:ZONE or SECTION:ZONE is used to ID a zone for the buddy allocator */
#ifdef NODE_NOT_IN_PAGE_FLAGS
#define ZONEID_SHIFT		(SECTIONS_SHIFT + ZONES_SHIFT)
#define ZONEID_PGOFF		((SECTIONS_PGOFF < ZONES_PGOFF)? \
						SECTIONS_PGOFF : ZONES_PGOFF)
#else
#define ZONEID_SHIFT		(NODES_SHIFT + ZONES_SHIFT)
#define ZONEID_PGOFF		((NODES_PGOFF < ZONES_PGOFF)? \
						NODES_PGOFF : ZONES_PGOFF)
#endif

#define ZONEID_PGSHIFT		(ZONEID_PGOFF * (ZONEID_SHIFT != 0))
  ZONE_SHIFT定义在 include/linux/page-flags-layout.h#L15 
#if MAX_NR_ZONES < 2
#define ZONES_SHIFT 0
#elif MAX_NR_ZONES <= 2
#define ZONES_SHIFT 1
#elif MAX_NR_ZONES <= 4
#define ZONES_SHIFT 2
#elif MAX_NR_ZONES <= 8
#define ZONES_SHIFT 3
#else
#error ZONES_SHIFT -- too many zones configured adjust calculation
#endif
  SECTION_SHIFT定义在 include/linux/page-flags-layout.h#L15 
/* SECTION_SHIFT	#bits space required to store a section # */
#define SECTIONS_SHIFT	(MAX_PHYSMEM_BITS - SECTION_SIZE_BITS)

3.4 定位api

  page_zonenum从page->flags得到zone number，定义在include/linux/mm.h#L781 
static inline enum zone_type page_zonenum(const struct page *page)
{
	return (page->flags >> ZONES_PGSHIFT) & ZONES_MASK;
}
  page_zone_id从page->flags得到zone id，定义在 include/linux/mm.h#L829，zone id包括了zone number和node id，或者 zone number和section id。 
/*
 * The identification function is mainly used by the buddy allocator for
 * determining if two pages could be buddies. We are not really identifying
 * the zone since we could be using the section number id if we do not have
 * node id available in page flags.
 * We only guarantee that it will return the same value for two combinable
 * pages in a zone.
 */
static inline int page_zone_id(struct page *page)
{
	return (page->flags >> ZONEID_PGSHIFT) & ZONEID_MASK;
}
  page_to_nid从page->flags得到node id，定义在 include/linux/mm.h#L844 
#ifdef NODE_NOT_IN_PAGE_FLAGS
extern int page_to_nid(const struct page *page);
#else
static inline int page_to_nid(const struct page *page)
{
	return (page->flags >> NODES_PGSHIFT) & NODES_MASK;
}
#endif
  page_cpupid_last从page->flags得到last cpuid，定义在 include/linux/mm.h#L904 
#ifdef LAST_CPUPID_NOT_IN_PAGE_FLAGS
static inline int page_cpupid_xchg_last(struct page *page, int cpupid)
{
	return xchg(&page->_last_cpupid, cpupid & LAST_CPUPID_MASK);
}

static inline int page_cpupid_last(struct page *page)
{
	return page->_last_cpupid;
}
static inline void page_cpupid_reset_last(struct page *page)
{
	page->_last_cpupid = -1 & LAST_CPUPID_MASK;
}
#else
static inline int page_cpupid_last(struct page *page)
{
	return (page->flags >> LAST_CPUPID_PGSHIFT) & LAST_CPUPID_MASK;
}

extern int page_cpupid_xchg_last(struct page *page, int cpupid);

static inline void page_cpupid_reset_last(struct page *page)
{
	page->flags |= LAST_CPUPID_MASK << LAST_CPUPID_PGSHIFT;
}
#endif /* LAST_CPUPID_NOT_IN_PAGE_FLAGS */
  page_to_section从page->flags得到section，定义在 include/linux/mm.h#L979 
#ifdef SECTION_IN_PAGE_FLAGS
static inline void set_page_section(struct page *page, unsigned long section)
{
	page->flags &= ~(SECTIONS_MASK << SECTIONS_PGSHIFT);
	page->flags |= (section & SECTIONS_MASK) << SECTIONS_PGSHIFT;
}

static inline unsigned long page_to_section(const struct page *page)
{
	return (page->flags >> SECTIONS_PGSHIFT) & SECTIONS_MASK;
}
#endif

3.5 修改api

  set_page_zone修改page->flags内的zone number，定义在 include/linux/mm.h#L985 
static inline void set_page_zone(struct page *page, enum zone_type zone)
{
	page->flags &= ~(ZONES_MASK << ZONES_PGSHIFT);
	page->flags |= (zone & ZONES_MASK) << ZONES_PGSHIFT;
}
  set_page_node修改page->flags内的node id，定义在 include/linux/mm.h#L991 
static inline void set_page_node(struct page *page, unsigned long node)
{
	page->flags &= ~(NODES_MASK << NODES_PGSHIFT);
	page->flags |= (node & NODES_MASK) << NODES_PGSHIFT;
}
  set_page_section修改page->flags内的section， 定义在 include/linux/mm.h#L973 
static inline void set_page_section(struct page *page, unsigned long section)
{
	page->flags &= ~(SECTIONS_MASK << SECTIONS_PGSHIFT);
	page->flags |= (section & SECTIONS_MASK) << SECTIONS_PGSHIFT;
}
  set_page_links同时修改page->flags内的zone，node和section，定义在 include/linux/mm.h#L997 
static inline void set_page_links(struct page *page, enum zone_type zone,
	unsigned long node, unsigned long pfn)
{
	set_page_zone(page, zone);
	set_page_node(page, node);
#ifdef SECTION_IN_PAGE_FLAGS
	set_page_section(page, pfn_to_section_nr(pfn));
#endif
}

4 mem_map, node_mem_map and section_mem_map

  mem_map是一个全局的 指针，指向struct page的数组，它管理着系统中所有的物理内存页面。
  mem_map定义在 mm/memory.c#L91 
#ifndef CONFIG_NEED_MULTIPLE_NODES
/* use the per-pgdat data instead for discontigmem - mbligh */
unsigned long max_mapnr;
EXPORT_SYMBOL(max_mapnr);

struct page *mem_map;
EXPORT_SYMBOL(mem_map);
#endif
  在flat内存模式下，所有的页框结构都在mem_map指针指向的连续空间。
  在contiguous模式下，mem_map指向到第一个内存结点的node_mem_map。 每个结点的node_mem_map指向该结点管理的所有页框结构。
  在sparse模式下，mem_map和node_mem_map无效。取而代之的是每个section结构内有section_mem_map参数指向该section 管理的所有页框结构。mem_section全局结构数组指针或者全局结构数组包含了所有的section，定义在 mm/sparse.c#L25。 
/*
 * Permanent SPARSEMEM data:
 *
 * 1) mem_section	- memory sections, mem_map's for valid memory
 */
#ifdef CONFIG_SPARSEMEM_EXTREME
struct mem_section *mem_section[NR_SECTION_ROOTS]
	____cacheline_internodealigned_in_smp;
#else
struct mem_section mem_section[NR_SECTION_ROOTS][SECTIONS_PER_ROOT]
	____cacheline_internodealigned_in_smp;
#endif
EXPORT_SYMBOL(mem_section);

5 页框号PFN和page的mapping

  页框号PFN到页结构的mapping通过宏__pfn_to_page(pfn)实现。页结构到页框号PFN的mapping通过宏__page_to_pfn实现。

5.1 Flat Memory Model

  定义在include/asm-generic/memory_model.h#L32

#define __pfn_to_page(pfn)	(mem_map + ((pfn) - ARCH_PFN_OFFSET))
#define __page_to_pfn(page)	((unsigned long)((page) - mem_map) + \
				 ARCH_PFN_OFFSET)
  页框号和page结构之间只有一个固定偏移ARCH_PFN_OFFSET，定义在 include/asm-generic/page.h#L72 

#ifndef ARCH_PFN_OFFSET
#define ARCH_PFN_OFFSET		(PAGE_OFFSET >> PAGE_SHIFT)
#endif
  PAGE_OFFSET定义在 include/asm-generic/page.h#L66 
#ifdef CONFIG_KERNEL_RAM_BASE_ADDRESS
#define PAGE_OFFSET		(CONFIG_KERNEL_RAM_BASE_ADDRESS)
#else
#define PAGE_OFFSET		(0)
#endif

5.2 Discontiguous Memory Model

  __pfn_to_page定义在 include/asm-generic/memory_model.h#L37 
#define __pfn_to_page(pfn)			\
({	unsigned long __pfn = (pfn);		\
	unsigned long __nid = arch_pfn_to_nid(__pfn);  \
	NODE_DATA(__nid)->node_mem_map + arch_local_page_offset(__pfn, __nid);\
})
  • arch_pfn_to_nid从pfn得到node id
  • NODE_DATA(__nid)->node_mem_map得到本结点的node data结构，取得node_mem_map指针
  • arch_local_page_offset得到pfn相对于结点第一个pfn的偏移
  __page_to_pfn定义在 include/asm-generic/memory_model.h#L43 
#define __page_to_pfn(pg)						\
({	const struct page *__pg = (pg);					\
	struct pglist_data *__pgdat = NODE_DATA(page_to_nid(__pg));	\
	(unsigned long)(__pg - __pgdat->node_mem_map) +			\
	 __pgdat->node_start_pfn;					\
})
  • page_to_nid从page结构得到node id。以后我们会知道这个是从page->flags参数的某些bit位得到
  • __pgdat->node_start_pfn是本结点的第一个物理页框号
  • (unsigned long)(__pg - __pgdat->node_mem_map)得到页表结构的偏移

5.3 Sparse Memory Model

  Sparse模式下设计到pfn number，page结构，section nunmber和section结构。互相之间的转换关系如下。


  __pfn_to_page定义在 include/asm-generic/memory_model.h#L67 
#define __pfn_to_page(pfn)				\
({	unsigned long __pfn = (pfn);			\
	struct mem_section *__sec = __pfn_to_section(__pfn);	\
	__section_mem_map_addr(__sec) + __pfn;		\
})
  __page_to_pfn定义在 include/asm-generic/memory_model.h#L61 
#define __page_to_pfn(pg)					\
({	const struct page *__pg = (pg);				\
	int __sec = page_to_section(__pg);			\
	(unsigned long)(__pg - __section_mem_map_addr(__nr_to_section(__sec)));	\
})

5.4 Sparse Vmemmap Memory Model 

  因为sparse vmemmap模式下所有页框结构在虚拟地址空间是连续的，并且首地址保存在vmemmap全局指针中，因此它的转换非常简单。定义在include/asm-generic/memory_model.h#L52

/* memmap is virtually contiguous.  */
#define __pfn_to_page(pfn)	(vmemmap + (pfn))
#define __page_to_pfn(page)	(unsigned long)((page) - vmemmap)
lwhuq
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux page笔记
06-30
自己的笔记。 just backup
Linux内存描述之内存页面page--Linux内存管理(四)
热门推荐
OSKernelLAB(gatieme)
08-31 2万+
日期 内核版本 架构 作者 GitHub CSDN 2016-08-31 Linux-4.7 X86 & arm gatieme LinuxDeviceDrivers Linux内存管理 1 前景回顾1.1 UMA和NUMA两种模型共享存储型多处理机有两种模型 均匀存储器存取（Uniform-Memory-Access，简称UMA）模型 非均匀存储器
Linux-页(page)和页表
最新发布
bananawolf的博客
05-11 968
页page的概念，页帧，页框和页表的详细介绍，虚拟地址空间vm_area_struct的资源细粒度划分介绍
Linux中main page和info page
niutingbaby的博客
06-08 670
1、DATE（1）后的数字： main中类似（1）的数字有1-9，表示不同的含义；重要的有1，5，8. 1表示用户在shell环境中可以操作的指令或可执行文件；5表示配置文件或者是某些档案的格式；8表示系统管理员可用的管理指令； 空格键 向下翻一页 [Page Down] 向下翻一页 [Page Up] 向上翻一页 [Ho...
linux 磁盘page,[Linux] 简单了解Linux的Page Cache
weixin_36433147的博客
05-06 207
在Linux下，Page Cache可以加速访问磁盘上的文件，这是因为，当它第一次读或写数据到类似硬盘一样的存储介质时，Linux会存储这些数据到闲置的内存区域，它充当于一个缓存的角色，如果以后读取数据，他就可以迅速的在缓存中读取，这篇文章将会简单的让你了解有关Page Cache的一些信息。内存使用在Linux下，有多少内存被Page Cache使用，可以用free -m查看Cached那一列，...
linux内存管理-FAQs.pdf
07-24
与内存管理系统相关的各种flags汇总如下:  每个物理page有自己的flags, 定义在struct page -> unsigned long flags; 详情见2.2.2节的《page》  每个内存块（多个page组成一个内存块）有自己的pageblock_flags, ...
linux内存管理(上篇-物理内存组织）
01-16
Linux 内存管理（上篇-物理内存组织） Linux 内存管理是一个非常复杂的主题，本篇文章将着重介绍物理内存组织的概念和实现细节。 物理寻址和虚拟寻址 在 Linux 中， CPU 直接操作物理地址，读取 4 字节数据字。在...
Linux_mem.rar_Linux内核源代码解读--内存管理
09-23
在Linux操作系统中，内存管理是内核的核心组成部分之一，它负责高效、安全地分配和管理系统的内存资源。本文将深入探讨Linux内核源代码中的内存管理机制，主要基于"Linux_mem.rar"压缩包中的"Linux物理内存管理.pdf...
Linux内存管理编程技术.doc
03-29
Linux内存管理是操作系统的核心组成部分，它负责有效地分配、管理和回收内存资源。在Linux环境中，程序员通常通过系统调用和库函数来与内存管理接口交互。本实验主要关注两个方面：一是使用malloc()函数进行内存分配...
论文研究-Linux2.6内存管理研究.pdf
07-22
Linux 2.6内核作为Linux操作系统的一个重要版本，它在内存管理方面做出了显著的改进和创新。Linux操作系统自1991年由Linus Torvalds发布第一个版本以来，经过多年的演变，Linux 2.6版是一个重要的里程碑。它不仅优化...
Linux pagecache与内存占用
01-09
实验环境 CentOS Linux release 7.3.1611 (Core)  3.10.0-514.6.1.el7.x86_64 　　一、概念介绍 　　linux系统中通常使用free命令来查看内存使用情况，free命令主要是从/proc/meminfo文件中读取的内存数据然后进行简单处理进行展示，根据查看free命令的手册了解到各个字段的含义。 　　total：系统总内存大小（分物理内存mem、交换分区swap） 　　used：已使用的内存（total – free – buffers – cache） 　　free：未使用的内存 　　shared：通常情况下是t
linux 的 page 结构体的一点笔记
larryliuqing的专栏-xxx
02-08 4624
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结构定义,linux 的 page 结构体的一点笔记
weixin_39626298的博客
05-14 522
Linux的内核在内存管理中处理的最小单位是physical pages然而处理器的的最小的可寻址的单位是byte 或者是 word很多32位系统构架都是4k的页，64位则是8k的页所以对于4k的页，1G的内存就有262144个不同的页内核通过struct page 结构体来表示每一个页，定义在中程序代码： /** Each physical page in the system has a st...
linux内核之page数据结构
m0_74282605的博客
02-07 841
Linux内核的内存管理以page页面为核心，struct page数据结构提供了很多字段，其中_refcount和_mapcount是两个非常重要的引用计数，正确理解它们是理解Linux内核内存管理的基石。对于文件映射页面，mapping指向该文件所属的address_space结构，它包含文件所属的介质相关信息，如inode节点，节点对应操作方法等；对于PG_private页面，主要在块设备的buffer_head中使用，如buffer_migrate_page()会增加_refcount；
Linux 内存管理窥探（5）：page 数据结构
StephenZhou
02-12 1万+
本文参考：https://blog.csdn.net/gatieme/article/details/52384636 感谢作者无私的奉献   前面聊过内存的表示由 node -&gt; zone -&gt; page ，聊聊 page 结构。 内核把物理页作为内存管理的基本单位. 尽管处理器的最小可寻址单位通常是字, 但是, 内存管理单元MMU通常以页为单位进行处理. 因此，从虚拟内存的上...
linux PAGE_POISONING用法
u014089131的博客
11-16 2569
page poison，内存毒药，page free时给page填充特定字节0xaa，在page alloc时check page内容是否有非0xaa的字节， 有的话，代表当前分配的page被其他page盖到，或者说这个page周边的page有发生内存溢出； 代码实现在debug_pagealloc.c中的kernel_map_pages： kernel/mm/Makefile:obj-$(
Linux内存page,Linux虚拟内存管理 - Page Table的作用
weixin_39549110的博客
05-08 318
虚拟内存的作用：1.扩展实际有限的物理内存，当然这种扩展是虚拟的，比如物理内存512M，对于一个需要1G空间的进程来说，照样可以运行。这增加了操作系统是应用范围。2.使得进程中的数据空间增大，增大到多少与硬件有关，对于一个32位的芯片，进程中的数据空间可以为4G[2^32]，对于64位的芯片则支持2^64大小的空间。这一点使得进程自身可操作的空间大大增加。通俗来讲，虚拟内存的管理的核心是解决如何在...
linux 1page是多大空间,Linux内存管理 一个进程究竟占用多少空间？-VSS/RSS/PSS/USS
weixin_31198993的博客
05-06 1075
关键词：VSS、RSS、PSS、USS、_mapcount、pte_present、mem_size_stats。在Linux里面，一个进程占用的内存有不同种说法，可以是VSS/RSS/PSS/USS四种形式，这四种形式首字母分别是Virtual/Resident/Proportional/Unique的意思。VSS是单个进程全部可访问的地址空间，其大小可能包括还尚未在内存中驻留的部分。对于确定单...
linux获取page大小,Unix_Linux
weixin_28911533的博客
05-03 429
Unix_Linux 的 getpagesizegetpagesize -获取内存页面大小内容简介#include int getpagesize(void);描述The functiongetpagesize() returns the number of bytes in a page, where a "page" is the thing used where it says in the...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值