2005-04-17 05:20:36 +07:00
|
|
|
#ifndef _LINUX_MMZONE_H
|
|
|
|
#define _LINUX_MMZONE_H
|
|
|
|
|
|
|
|
#ifdef __KERNEL__
|
|
|
|
#ifndef __ASSEMBLY__
|
|
|
|
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/wait.h>
|
|
|
|
#include <linux/cache.h>
|
|
|
|
#include <linux/threads.h>
|
|
|
|
#include <linux/numa.h>
|
|
|
|
#include <linux/init.h>
|
2005-10-30 08:16:53 +07:00
|
|
|
#include <linux/seqlock.h>
|
2006-03-27 16:15:57 +07:00
|
|
|
#include <linux/nodemask.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <asm/atomic.h>
|
[PATCH] Sparsemem build fix
From: Ralf Baechle <ralf@linux-mips.org>
<linux/mmzone.h> uses PAGE_SIZE, PAGE_SHIFT from <asm/page.h> without
including that header itself. For some sparsemem configurations this may
result in build errors like:
CC init/initramfs.o
In file included from include/linux/gfp.h:4,
from include/linux/slab.h:15,
from include/linux/percpu.h:4,
from include/linux/rcupdate.h:41,
from include/linux/dcache.h:10,
from include/linux/fs.h:226,
from init/initramfs.c:2:
include/linux/mmzone.h:498:22: warning: "PAGE_SHIFT" is not defined
In file included from include/linux/gfp.h:4,
from include/linux/slab.h:15,
from include/linux/percpu.h:4,
from include/linux/rcupdate.h:41,
from include/linux/dcache.h:10,
from include/linux/fs.h:226,
from init/initramfs.c:2:
include/linux/mmzone.h:526: error: `PAGE_SIZE' undeclared here (not in a function)
include/linux/mmzone.h: In function `__pfn_to_section':
include/linux/mmzone.h:573: error: `PAGE_SHIFT' undeclared (first use in this function)
include/linux/mmzone.h:573: error: (Each undeclared identifier is reported only once
include/linux/mmzone.h:573: error: for each function it appears in.)
include/linux/mmzone.h: In function `pfn_valid':
include/linux/mmzone.h:578: error: `PAGE_SHIFT' undeclared (first use in this function)
make[1]: *** [init/initramfs.o] Error 1
make: *** [init] Error 2
Signed-off-by: Ralf Baechle <ralf@linux-mips.org>
Seems-reasonable-to: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-04 16:51:29 +07:00
|
|
|
#include <asm/page.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Free memory management - zoned buddy allocator. */
|
|
|
|
#ifndef CONFIG_FORCE_MAX_ZONEORDER
|
|
|
|
#define MAX_ORDER 11
|
|
|
|
#else
|
|
|
|
#define MAX_ORDER CONFIG_FORCE_MAX_ZONEORDER
|
|
|
|
#endif
|
2006-05-21 05:00:31 +07:00
|
|
|
#define MAX_ORDER_NR_PAGES (1 << (MAX_ORDER - 1))
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
struct free_area {
|
|
|
|
struct list_head free_list;
|
|
|
|
unsigned long nr_free;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct pglist_data;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* zone->lock and zone->lru_lock are two of the hottest locks in the kernel.
|
|
|
|
* So add a wild amount of padding here to ensure that they fall into separate
|
|
|
|
* cachelines. There are very few zone structures in the machine, so space
|
|
|
|
* consumption is not a concern here.
|
|
|
|
*/
|
|
|
|
#if defined(CONFIG_SMP)
|
|
|
|
struct zone_padding {
|
|
|
|
char x[0];
|
2006-01-08 16:01:27 +07:00
|
|
|
} ____cacheline_internodealigned_in_smp;
|
2005-04-17 05:20:36 +07:00
|
|
|
#define ZONE_PADDING(name) struct zone_padding name;
|
|
|
|
#else
|
|
|
|
#define ZONE_PADDING(name)
|
|
|
|
#endif
|
|
|
|
|
2006-06-30 15:55:33 +07:00
|
|
|
enum zone_stat_item {
|
2006-06-30 15:55:36 +07:00
|
|
|
NR_ANON_PAGES, /* Mapped anonymous pages */
|
|
|
|
NR_FILE_MAPPED, /* pagecache pages mapped into pagetables.
|
2006-06-30 15:55:34 +07:00
|
|
|
only modified from process context */
|
2006-06-30 15:55:35 +07:00
|
|
|
NR_FILE_PAGES,
|
2006-09-26 13:31:51 +07:00
|
|
|
NR_SLAB_RECLAIMABLE,
|
|
|
|
NR_SLAB_UNRECLAIMABLE,
|
2006-06-30 15:55:38 +07:00
|
|
|
NR_PAGETABLE, /* used for pagetables */
|
2006-06-30 15:55:39 +07:00
|
|
|
NR_FILE_DIRTY,
|
2006-06-30 15:55:40 +07:00
|
|
|
NR_WRITEBACK,
|
2006-06-30 15:55:40 +07:00
|
|
|
NR_UNSTABLE_NFS, /* NFS unstable pages */
|
2006-06-30 15:55:41 +07:00
|
|
|
NR_BOUNCE,
|
2006-09-27 15:50:00 +07:00
|
|
|
NR_VMSCAN_WRITE,
|
2006-06-30 15:55:44 +07:00
|
|
|
#ifdef CONFIG_NUMA
|
|
|
|
NUMA_HIT, /* allocated in intended node */
|
|
|
|
NUMA_MISS, /* allocated in non intended node */
|
|
|
|
NUMA_FOREIGN, /* was intended here, hit elsewhere */
|
|
|
|
NUMA_INTERLEAVE_HIT, /* interleaver preferred this zone */
|
|
|
|
NUMA_LOCAL, /* allocation from local node */
|
|
|
|
NUMA_OTHER, /* allocation from other node */
|
|
|
|
#endif
|
2006-06-30 15:55:33 +07:00
|
|
|
NR_VM_ZONE_STAT_ITEMS };
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
struct per_cpu_pages {
|
|
|
|
int count; /* number of pages in the list */
|
|
|
|
int high; /* high watermark, emptying needed */
|
|
|
|
int batch; /* chunk size for buddy add/remove */
|
|
|
|
struct list_head list; /* the list of pages */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct per_cpu_pageset {
|
|
|
|
struct per_cpu_pages pcp[2]; /* 0: hot. 1: cold */
|
2006-06-30 15:55:33 +07:00
|
|
|
#ifdef CONFIG_SMP
|
2006-09-01 11:27:35 +07:00
|
|
|
s8 stat_threshold;
|
2006-06-30 15:55:33 +07:00
|
|
|
s8 vm_stat_diff[NR_VM_ZONE_STAT_ITEMS];
|
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
} ____cacheline_aligned_in_smp;
|
|
|
|
|
2005-06-22 07:14:47 +07:00
|
|
|
#ifdef CONFIG_NUMA
|
|
|
|
#define zone_pcp(__z, __cpu) ((__z)->pageset[(__cpu)])
|
|
|
|
#else
|
|
|
|
#define zone_pcp(__z, __cpu) (&(__z)->pageset[(__cpu)])
|
|
|
|
#endif
|
|
|
|
|
2006-09-26 13:31:13 +07:00
|
|
|
enum zone_type {
|
|
|
|
/*
|
|
|
|
* ZONE_DMA is used when there are devices that are not able
|
|
|
|
* to do DMA to all of addressable memory (ZONE_NORMAL). Then we
|
|
|
|
* carve out the portion of memory that is needed for these devices.
|
|
|
|
* The range is arch specific.
|
|
|
|
*
|
|
|
|
* Some examples
|
|
|
|
*
|
|
|
|
* Architecture Limit
|
|
|
|
* ---------------------------
|
|
|
|
* parisc, ia64, sparc <4G
|
|
|
|
* s390 <2G
|
|
|
|
* arm26 <48M
|
|
|
|
* arm Various
|
|
|
|
* alpha Unlimited or 0-16MB.
|
|
|
|
*
|
|
|
|
* i386, x86_64 and multiple other arches
|
|
|
|
* <16M.
|
|
|
|
*/
|
|
|
|
ZONE_DMA,
|
2006-09-26 13:31:13 +07:00
|
|
|
#ifdef CONFIG_ZONE_DMA32
|
2006-09-26 13:31:13 +07:00
|
|
|
/*
|
|
|
|
* x86_64 needs two ZONE_DMAs because it supports devices that are
|
|
|
|
* only able to do DMA to the lower 16M but also 32 bit devices that
|
|
|
|
* can only do DMA areas below 4G.
|
|
|
|
*/
|
|
|
|
ZONE_DMA32,
|
2006-09-26 13:31:13 +07:00
|
|
|
#endif
|
2006-09-26 13:31:13 +07:00
|
|
|
/*
|
|
|
|
* Normal addressable memory is in ZONE_NORMAL. DMA operations can be
|
|
|
|
* performed on pages in ZONE_NORMAL if the DMA devices support
|
|
|
|
* transfers to all addressable memory.
|
|
|
|
*/
|
|
|
|
ZONE_NORMAL,
|
2006-09-26 13:31:14 +07:00
|
|
|
#ifdef CONFIG_HIGHMEM
|
2006-09-26 13:31:13 +07:00
|
|
|
/*
|
|
|
|
* A memory area that is only addressable by the kernel through
|
|
|
|
* mapping portions into its own address space. This is for example
|
|
|
|
* used by i386 to allow the kernel to address the memory beyond
|
|
|
|
* 900MB. The kernel will set up special mappings (page
|
|
|
|
* table entries on i386) for each page that the kernel needs to
|
|
|
|
* access.
|
|
|
|
*/
|
|
|
|
ZONE_HIGHMEM,
|
2006-09-26 13:31:14 +07:00
|
|
|
#endif
|
2006-09-26 13:31:13 +07:00
|
|
|
MAX_NR_ZONES
|
|
|
|
};
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* When a memory allocation must conform to specific limitations (such
|
|
|
|
* as being suitable for DMA) the caller will pass in hints to the
|
|
|
|
* allocator in the gfp_mask, in the zone modifier bits. These bits
|
|
|
|
* are used to select a priority ordered list of memory zones which
|
2006-09-26 13:31:19 +07:00
|
|
|
* match the requested limits. See gfp_zone() in include/linux/gfp.h
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2006-09-26 13:31:13 +07:00
|
|
|
|
2006-09-26 13:31:19 +07:00
|
|
|
#if !defined(CONFIG_ZONE_DMA32) && !defined(CONFIG_HIGHMEM)
|
|
|
|
#define ZONES_SHIFT 1
|
2006-09-26 13:31:14 +07:00
|
|
|
#else
|
2006-09-26 13:31:19 +07:00
|
|
|
#define ZONES_SHIFT 2
|
2006-09-26 13:31:13 +07:00
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
struct zone {
|
|
|
|
/* Fields commonly accessed by the page allocator */
|
|
|
|
unsigned long free_pages;
|
|
|
|
unsigned long pages_min, pages_low, pages_high;
|
|
|
|
/*
|
|
|
|
* We don't know if the memory that we're going to allocate will be freeable
|
|
|
|
* or/and it will be released eventually, so to avoid totally wasting several
|
|
|
|
* GB of ram we must reserve some of the lower zone memory (otherwise we risk
|
|
|
|
* to run OOM on the lower zones despite there's tons of freeable ram
|
|
|
|
* on the higher zones). This array is recalculated at runtime if the
|
|
|
|
* sysctl_lowmem_reserve_ratio sysctl changes.
|
|
|
|
*/
|
|
|
|
unsigned long lowmem_reserve[MAX_NR_ZONES];
|
|
|
|
|
2005-06-22 07:14:47 +07:00
|
|
|
#ifdef CONFIG_NUMA
|
2006-09-27 15:50:08 +07:00
|
|
|
int node;
|
2006-07-03 14:24:13 +07:00
|
|
|
/*
|
|
|
|
* zone reclaim becomes active if more unmapped pages exist.
|
|
|
|
*/
|
2006-09-26 13:31:51 +07:00
|
|
|
unsigned long min_unmapped_pages;
|
2006-09-26 13:31:52 +07:00
|
|
|
unsigned long min_slab_pages;
|
2005-06-22 07:14:47 +07:00
|
|
|
struct per_cpu_pageset *pageset[NR_CPUS];
|
|
|
|
#else
|
2005-04-17 05:20:36 +07:00
|
|
|
struct per_cpu_pageset pageset[NR_CPUS];
|
2005-06-22 07:14:47 +07:00
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* free areas of different sizes
|
|
|
|
*/
|
|
|
|
spinlock_t lock;
|
2005-10-30 08:16:53 +07:00
|
|
|
#ifdef CONFIG_MEMORY_HOTPLUG
|
|
|
|
/* see spanned/present_pages for more description */
|
|
|
|
seqlock_t span_seqlock;
|
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
struct free_area free_area[MAX_ORDER];
|
|
|
|
|
|
|
|
|
|
|
|
ZONE_PADDING(_pad1_)
|
|
|
|
|
|
|
|
/* Fields commonly accessed by the page reclaim scanner */
|
|
|
|
spinlock_t lru_lock;
|
|
|
|
struct list_head active_list;
|
|
|
|
struct list_head inactive_list;
|
|
|
|
unsigned long nr_scan_active;
|
|
|
|
unsigned long nr_scan_inactive;
|
|
|
|
unsigned long nr_active;
|
|
|
|
unsigned long nr_inactive;
|
|
|
|
unsigned long pages_scanned; /* since last reclaim */
|
|
|
|
int all_unreclaimable; /* All pages pinned */
|
|
|
|
|
2005-06-22 07:14:43 +07:00
|
|
|
/* A count of how many reclaimers are scanning this zone */
|
|
|
|
atomic_t reclaim_in_progress;
|
2005-06-22 07:14:41 +07:00
|
|
|
|
2006-06-30 15:55:33 +07:00
|
|
|
/* Zone statistics */
|
|
|
|
atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS];
|
2006-01-19 08:42:31 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* prev_priority holds the scanning priority for this zone. It is
|
|
|
|
* defined as the scanning priority at which we achieved our reclaim
|
|
|
|
* target at the previous try_to_free_pages() or balance_pgdat()
|
|
|
|
* invokation.
|
|
|
|
*
|
|
|
|
* We use prev_priority as a measure of how much stress page reclaim is
|
|
|
|
* under - it drives the swappiness decision: whether to unmap mapped
|
|
|
|
* pages.
|
|
|
|
*
|
|
|
|
* temp_priority is used to remember the scanning priority at which
|
|
|
|
* this zone was successfully refilled to free_pages == pages_high.
|
|
|
|
*
|
|
|
|
* Access to both these fields is quite racy even on uniprocessor. But
|
|
|
|
* it is expected to average out OK.
|
|
|
|
*/
|
|
|
|
int temp_priority;
|
|
|
|
int prev_priority;
|
|
|
|
|
|
|
|
|
|
|
|
ZONE_PADDING(_pad2_)
|
|
|
|
/* Rarely used or read-mostly fields */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* wait_table -- the array holding the hash table
|
2006-06-23 16:03:08 +07:00
|
|
|
* wait_table_hash_nr_entries -- the size of the hash table array
|
2005-04-17 05:20:36 +07:00
|
|
|
* wait_table_bits -- wait_table_size == (1 << wait_table_bits)
|
|
|
|
*
|
|
|
|
* The purpose of all these is to keep track of the people
|
|
|
|
* waiting for a page to become available and make them
|
|
|
|
* runnable again when possible. The trouble is that this
|
|
|
|
* consumes a lot of space, especially when so few things
|
|
|
|
* wait on pages at a given time. So instead of using
|
|
|
|
* per-page waitqueues, we use a waitqueue hash table.
|
|
|
|
*
|
|
|
|
* The bucket discipline is to sleep on the same queue when
|
|
|
|
* colliding and wake all in that wait queue when removing.
|
|
|
|
* When something wakes, it must check to be sure its page is
|
|
|
|
* truly available, a la thundering herd. The cost of a
|
|
|
|
* collision is great, but given the expected load of the
|
|
|
|
* table, they should be so rare as to be outweighed by the
|
|
|
|
* benefits from the saved space.
|
|
|
|
*
|
|
|
|
* __wait_on_page_locked() and unlock_page() in mm/filemap.c, are the
|
|
|
|
* primary users of these fields, and in mm/page_alloc.c
|
|
|
|
* free_area_init_core() performs the initialization of them.
|
|
|
|
*/
|
|
|
|
wait_queue_head_t * wait_table;
|
2006-06-23 16:03:08 +07:00
|
|
|
unsigned long wait_table_hash_nr_entries;
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long wait_table_bits;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Discontig memory support fields.
|
|
|
|
*/
|
|
|
|
struct pglist_data *zone_pgdat;
|
|
|
|
/* zone_start_pfn == zone_start_paddr >> PAGE_SHIFT */
|
|
|
|
unsigned long zone_start_pfn;
|
|
|
|
|
2005-10-30 08:16:53 +07:00
|
|
|
/*
|
|
|
|
* zone_start_pfn, spanned_pages and present_pages are all
|
|
|
|
* protected by span_seqlock. It is a seqlock because it has
|
|
|
|
* to be read outside of zone->lock, and it is done in the main
|
|
|
|
* allocator path. But, it is written quite infrequently.
|
|
|
|
*
|
|
|
|
* The lock is declared along with zone->lock because it is
|
|
|
|
* frequently read in proximity to zone->lock. It's good to
|
|
|
|
* give them a chance of being in the same cacheline.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long spanned_pages; /* total size, including holes */
|
|
|
|
unsigned long present_pages; /* amount of memory (excluding holes) */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* rarely used fields:
|
|
|
|
*/
|
|
|
|
char *name;
|
2006-01-08 16:01:27 +07:00
|
|
|
} ____cacheline_internodealigned_in_smp;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The "priority" of VM scanning is how much of the queues we will scan in one
|
|
|
|
* go. A value of 12 for DEF_PRIORITY implies that we will scan 1/4096th of the
|
|
|
|
* queues ("queue_length >> 12") during an aging round.
|
|
|
|
*/
|
|
|
|
#define DEF_PRIORITY 12
|
|
|
|
|
|
|
|
/*
|
|
|
|
* One allocation request operates on a zonelist. A zonelist
|
|
|
|
* is a list of zones, the first one is the 'goal' of the
|
|
|
|
* allocation, the other zones are fallback zones, in decreasing
|
|
|
|
* priority.
|
|
|
|
*
|
|
|
|
* Right now a zonelist takes up less than a cacheline. We never
|
|
|
|
* modify it apart from boot-up, and only a few indices are used,
|
|
|
|
* so despite the zonelist table being relatively big, the cache
|
|
|
|
* footprint of this construct is very small.
|
|
|
|
*/
|
|
|
|
struct zonelist {
|
|
|
|
struct zone *zones[MAX_NUMNODES * MAX_NR_ZONES + 1]; // NULL delimited
|
|
|
|
};
|
|
|
|
|
[PATCH] Introduce mechanism for registering active regions of memory
At a basic level, architectures define structures to record where active
ranges of page frames are located. Once located, the code to calculate zone
sizes and holes in each architecture is very similar. Some of this zone and
hole sizing code is difficult to read for no good reason. This set of patches
eliminates the similar-looking architecture-specific code.
The patches introduce a mechanism where architectures register where the
active ranges of page frames are with add_active_range(). When all areas have
been discovered, free_area_init_nodes() is called to initialise the pgdat and
zones. The zone sizes and holes are then calculated in an architecture
independent manner.
Patch 1 introduces the mechanism for registering and initialising PFN ranges
Patch 2 changes ppc to use the mechanism - 139 arch-specific LOC removed
Patch 3 changes x86 to use the mechanism - 136 arch-specific LOC removed
Patch 4 changes x86_64 to use the mechanism - 74 arch-specific LOC removed
Patch 5 changes ia64 to use the mechanism - 52 arch-specific LOC removed
Patch 6 accounts for mem_map as a memory hole as the pages are not reclaimable.
It adjusts the watermarks slightly
Tony Luck has successfully tested for ia64 on Itanium with tiger_defconfig,
gensparse_defconfig and defconfig. Bob Picco has also tested and debugged on
IA64. Jack Steiner successfully boot tested on a mammoth SGI IA64-based
machine. These were on patches against 2.6.17-rc1 and release 3 of these
patches but there have been no ia64-changes since release 3.
There are differences in the zone sizes for x86_64 as the arch-specific code
for x86_64 accounts the kernel image and the starting mem_maps as memory holes
but the architecture-independent code accounts the memory as present.
The big benefit of this set of patches is a sizable reduction of
architecture-specific code, some of which is very hairy. There should be a
greater reduction when other architectures use the same mechanisms for zone
and hole sizing but I lack the hardware to test on.
Additional credit;
Dave Hansen for the initial suggestion and comments on early patches
Andy Whitcroft for reviewing early versions and catching numerous
errors
Tony Luck for testing and debugging on IA64
Bob Picco for fixing bugs related to pfn registration, reviewing a
number of patch revisions, providing a number of suggestions
on future direction and testing heavily
Jack Steiner and Robin Holt for testing on IA64 and clarifying
issues related to memory holes
Yasunori for testing on IA64
Andi Kleen for reviewing and feeding back about x86_64
Christian Kujau for providing valuable information related to ACPI
problems on x86_64 and testing potential fixes
This patch:
Define the structure to represent an active range of page frames within a node
in an architecture independent manner. Architectures are expected to register
active ranges of PFNs using add_active_range(nid, start_pfn, end_pfn) and call
free_area_init_nodes() passing the PFNs of the end of each zone.
Signed-off-by: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Cc: Dave Hansen <haveblue@us.ibm.com>
Cc: Andy Whitcroft <apw@shadowen.org>
Cc: Andi Kleen <ak@muc.de>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: "Keith Mannthey" <kmannth@gmail.com>
Cc: "Luck, Tony" <tony.luck@intel.com>
Cc: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Cc: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-09-27 15:49:43 +07:00
|
|
|
#ifdef CONFIG_ARCH_POPULATES_NODE_MAP
|
|
|
|
struct node_active_region {
|
|
|
|
unsigned long start_pfn;
|
|
|
|
unsigned long end_pfn;
|
|
|
|
int nid;
|
|
|
|
};
|
|
|
|
#endif /* CONFIG_ARCH_POPULATES_NODE_MAP */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-09-27 15:50:01 +07:00
|
|
|
#ifndef CONFIG_DISCONTIGMEM
|
|
|
|
/* The array of struct pages - for discontigmem use pgdat->lmem_map */
|
|
|
|
extern struct page *mem_map;
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* The pg_data_t structure is used in machines with CONFIG_DISCONTIGMEM
|
|
|
|
* (mostly NUMA machines?) to denote a higher-level memory zone than the
|
|
|
|
* zone denotes.
|
|
|
|
*
|
|
|
|
* On NUMA machines, each NUMA node would have a pg_data_t to describe
|
|
|
|
* it's memory layout.
|
|
|
|
*
|
|
|
|
* Memory statistics and page replacement data structures are maintained on a
|
|
|
|
* per-zone basis.
|
|
|
|
*/
|
|
|
|
struct bootmem_data;
|
|
|
|
typedef struct pglist_data {
|
|
|
|
struct zone node_zones[MAX_NR_ZONES];
|
2006-09-26 13:31:19 +07:00
|
|
|
struct zonelist node_zonelists[MAX_NR_ZONES];
|
2005-04-17 05:20:36 +07:00
|
|
|
int nr_zones;
|
[PATCH] sparsemem memory model
Sparsemem abstracts the use of discontiguous mem_maps[]. This kind of
mem_map[] is needed by discontiguous memory machines (like in the old
CONFIG_DISCONTIGMEM case) as well as memory hotplug systems. Sparsemem
replaces DISCONTIGMEM when enabled, and it is hoped that it can eventually
become a complete replacement.
A significant advantage over DISCONTIGMEM is that it's completely separated
from CONFIG_NUMA. When producing this patch, it became apparent in that NUMA
and DISCONTIG are often confused.
Another advantage is that sparse doesn't require each NUMA node's ranges to be
contiguous. It can handle overlapping ranges between nodes with no problems,
where DISCONTIGMEM currently throws away that memory.
Sparsemem uses an array to provide different pfn_to_page() translations for
each SECTION_SIZE area of physical memory. This is what allows the mem_map[]
to be chopped up.
In order to do quick pfn_to_page() operations, the section number of the page
is encoded in page->flags. Part of the sparsemem infrastructure enables
sharing of these bits more dynamically (at compile-time) between the
page_zone() and sparsemem operations. However, on 32-bit architectures, the
number of bits is quite limited, and may require growing the size of the
page->flags type in certain conditions. Several things might force this to
occur: a decrease in the SECTION_SIZE (if you want to hotplug smaller areas of
memory), an increase in the physical address space, or an increase in the
number of used page->flags.
One thing to note is that, once sparsemem is present, the NUMA node
information no longer needs to be stored in the page->flags. It might provide
speed increases on certain platforms and will be stored there if there is
room. But, if out of room, an alternate (theoretically slower) mechanism is
used.
This patch introduces CONFIG_FLATMEM. It is used in almost all cases where
there used to be an #ifndef DISCONTIG, because SPARSEMEM and DISCONTIGMEM
often have to compile out the same areas of code.
Signed-off-by: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin Bligh <mbligh@aracnet.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 14:07:54 +07:00
|
|
|
#ifdef CONFIG_FLAT_NODE_MEM_MAP
|
2005-04-17 05:20:36 +07:00
|
|
|
struct page *node_mem_map;
|
[PATCH] sparsemem memory model
Sparsemem abstracts the use of discontiguous mem_maps[]. This kind of
mem_map[] is needed by discontiguous memory machines (like in the old
CONFIG_DISCONTIGMEM case) as well as memory hotplug systems. Sparsemem
replaces DISCONTIGMEM when enabled, and it is hoped that it can eventually
become a complete replacement.
A significant advantage over DISCONTIGMEM is that it's completely separated
from CONFIG_NUMA. When producing this patch, it became apparent in that NUMA
and DISCONTIG are often confused.
Another advantage is that sparse doesn't require each NUMA node's ranges to be
contiguous. It can handle overlapping ranges between nodes with no problems,
where DISCONTIGMEM currently throws away that memory.
Sparsemem uses an array to provide different pfn_to_page() translations for
each SECTION_SIZE area of physical memory. This is what allows the mem_map[]
to be chopped up.
In order to do quick pfn_to_page() operations, the section number of the page
is encoded in page->flags. Part of the sparsemem infrastructure enables
sharing of these bits more dynamically (at compile-time) between the
page_zone() and sparsemem operations. However, on 32-bit architectures, the
number of bits is quite limited, and may require growing the size of the
page->flags type in certain conditions. Several things might force this to
occur: a decrease in the SECTION_SIZE (if you want to hotplug smaller areas of
memory), an increase in the physical address space, or an increase in the
number of used page->flags.
One thing to note is that, once sparsemem is present, the NUMA node
information no longer needs to be stored in the page->flags. It might provide
speed increases on certain platforms and will be stored there if there is
room. But, if out of room, an alternate (theoretically slower) mechanism is
used.
This patch introduces CONFIG_FLATMEM. It is used in almost all cases where
there used to be an #ifndef DISCONTIG, because SPARSEMEM and DISCONTIGMEM
often have to compile out the same areas of code.
Signed-off-by: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin Bligh <mbligh@aracnet.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 14:07:54 +07:00
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
struct bootmem_data *bdata;
|
2005-10-30 08:16:52 +07:00
|
|
|
#ifdef CONFIG_MEMORY_HOTPLUG
|
|
|
|
/*
|
|
|
|
* Must be held any time you expect node_start_pfn, node_present_pages
|
|
|
|
* or node_spanned_pages stay constant. Holding this will also
|
|
|
|
* guarantee that any pfn_valid() stays that way.
|
|
|
|
*
|
|
|
|
* Nests above zone->lock and zone->size_seqlock.
|
|
|
|
*/
|
|
|
|
spinlock_t node_size_lock;
|
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long node_start_pfn;
|
|
|
|
unsigned long node_present_pages; /* total number of physical pages */
|
|
|
|
unsigned long node_spanned_pages; /* total size of physical page
|
|
|
|
range, including holes */
|
|
|
|
int node_id;
|
|
|
|
wait_queue_head_t kswapd_wait;
|
|
|
|
struct task_struct *kswapd;
|
|
|
|
int kswapd_max_order;
|
|
|
|
} pg_data_t;
|
|
|
|
|
|
|
|
#define node_present_pages(nid) (NODE_DATA(nid)->node_present_pages)
|
|
|
|
#define node_spanned_pages(nid) (NODE_DATA(nid)->node_spanned_pages)
|
[PATCH] sparsemem memory model
Sparsemem abstracts the use of discontiguous mem_maps[]. This kind of
mem_map[] is needed by discontiguous memory machines (like in the old
CONFIG_DISCONTIGMEM case) as well as memory hotplug systems. Sparsemem
replaces DISCONTIGMEM when enabled, and it is hoped that it can eventually
become a complete replacement.
A significant advantage over DISCONTIGMEM is that it's completely separated
from CONFIG_NUMA. When producing this patch, it became apparent in that NUMA
and DISCONTIG are often confused.
Another advantage is that sparse doesn't require each NUMA node's ranges to be
contiguous. It can handle overlapping ranges between nodes with no problems,
where DISCONTIGMEM currently throws away that memory.
Sparsemem uses an array to provide different pfn_to_page() translations for
each SECTION_SIZE area of physical memory. This is what allows the mem_map[]
to be chopped up.
In order to do quick pfn_to_page() operations, the section number of the page
is encoded in page->flags. Part of the sparsemem infrastructure enables
sharing of these bits more dynamically (at compile-time) between the
page_zone() and sparsemem operations. However, on 32-bit architectures, the
number of bits is quite limited, and may require growing the size of the
page->flags type in certain conditions. Several things might force this to
occur: a decrease in the SECTION_SIZE (if you want to hotplug smaller areas of
memory), an increase in the physical address space, or an increase in the
number of used page->flags.
One thing to note is that, once sparsemem is present, the NUMA node
information no longer needs to be stored in the page->flags. It might provide
speed increases on certain platforms and will be stored there if there is
room. But, if out of room, an alternate (theoretically slower) mechanism is
used.
This patch introduces CONFIG_FLATMEM. It is used in almost all cases where
there used to be an #ifndef DISCONTIG, because SPARSEMEM and DISCONTIGMEM
often have to compile out the same areas of code.
Signed-off-by: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin Bligh <mbligh@aracnet.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 14:07:54 +07:00
|
|
|
#ifdef CONFIG_FLAT_NODE_MEM_MAP
|
[PATCH] remove non-DISCONTIG use of pgdat->node_mem_map
This patch effectively eliminates direct use of pgdat->node_mem_map outside
of the DISCONTIG code. On a flat memory system, these fields aren't
currently used, neither are they on a sparsemem system.
There was also a node_mem_map(nid) macro on many architectures. Its use
along with the use of ->node_mem_map itself was not consistent. It has
been removed in favor of two new, more explicit, arch-independent macros:
pgdat_page_nr(pgdat, pagenr)
nid_page_nr(nid, pagenr)
I called them "pgdat" and "nid" because we overload the term "node" to mean
"NUMA node", "DISCONTIG node" or "pg_data_t" in very confusing ways. I
believe the newer names are much clearer.
These macros can be overridden in the sparsemem case with a theoretically
slower operation using node_start_pfn and pfn_to_page(), instead. We could
make this the only behavior if people want, but I don't want to change too
much at once. One thing at a time.
This patch removes more code than it adds.
Compile tested on alpha, alpha discontig, arm, arm-discontig, i386, i386
generic, NUMAQ, Summit, ppc64, ppc64 discontig, and x86_64. Full list
here: http://sr71.net/patches/2.6.12/2.6.12-rc1-mhp2/configs/
Boot tested on NUMAQ, x86 SMP and ppc64 power4/5 LPARs.
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin J. Bligh <mbligh@aracnet.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 14:07:37 +07:00
|
|
|
#define pgdat_page_nr(pgdat, pagenr) ((pgdat)->node_mem_map + (pagenr))
|
[PATCH] sparsemem memory model
Sparsemem abstracts the use of discontiguous mem_maps[]. This kind of
mem_map[] is needed by discontiguous memory machines (like in the old
CONFIG_DISCONTIGMEM case) as well as memory hotplug systems. Sparsemem
replaces DISCONTIGMEM when enabled, and it is hoped that it can eventually
become a complete replacement.
A significant advantage over DISCONTIGMEM is that it's completely separated
from CONFIG_NUMA. When producing this patch, it became apparent in that NUMA
and DISCONTIG are often confused.
Another advantage is that sparse doesn't require each NUMA node's ranges to be
contiguous. It can handle overlapping ranges between nodes with no problems,
where DISCONTIGMEM currently throws away that memory.
Sparsemem uses an array to provide different pfn_to_page() translations for
each SECTION_SIZE area of physical memory. This is what allows the mem_map[]
to be chopped up.
In order to do quick pfn_to_page() operations, the section number of the page
is encoded in page->flags. Part of the sparsemem infrastructure enables
sharing of these bits more dynamically (at compile-time) between the
page_zone() and sparsemem operations. However, on 32-bit architectures, the
number of bits is quite limited, and may require growing the size of the
page->flags type in certain conditions. Several things might force this to
occur: a decrease in the SECTION_SIZE (if you want to hotplug smaller areas of
memory), an increase in the physical address space, or an increase in the
number of used page->flags.
One thing to note is that, once sparsemem is present, the NUMA node
information no longer needs to be stored in the page->flags. It might provide
speed increases on certain platforms and will be stored there if there is
room. But, if out of room, an alternate (theoretically slower) mechanism is
used.
This patch introduces CONFIG_FLATMEM. It is used in almost all cases where
there used to be an #ifndef DISCONTIG, because SPARSEMEM and DISCONTIGMEM
often have to compile out the same areas of code.
Signed-off-by: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin Bligh <mbligh@aracnet.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 14:07:54 +07:00
|
|
|
#else
|
|
|
|
#define pgdat_page_nr(pgdat, pagenr) pfn_to_page((pgdat)->node_start_pfn + (pagenr))
|
|
|
|
#endif
|
[PATCH] remove non-DISCONTIG use of pgdat->node_mem_map
This patch effectively eliminates direct use of pgdat->node_mem_map outside
of the DISCONTIG code. On a flat memory system, these fields aren't
currently used, neither are they on a sparsemem system.
There was also a node_mem_map(nid) macro on many architectures. Its use
along with the use of ->node_mem_map itself was not consistent. It has
been removed in favor of two new, more explicit, arch-independent macros:
pgdat_page_nr(pgdat, pagenr)
nid_page_nr(nid, pagenr)
I called them "pgdat" and "nid" because we overload the term "node" to mean
"NUMA node", "DISCONTIG node" or "pg_data_t" in very confusing ways. I
believe the newer names are much clearer.
These macros can be overridden in the sparsemem case with a theoretically
slower operation using node_start_pfn and pfn_to_page(), instead. We could
make this the only behavior if people want, but I don't want to change too
much at once. One thing at a time.
This patch removes more code than it adds.
Compile tested on alpha, alpha discontig, arm, arm-discontig, i386, i386
generic, NUMAQ, Summit, ppc64, ppc64 discontig, and x86_64. Full list
here: http://sr71.net/patches/2.6.12/2.6.12-rc1-mhp2/configs/
Boot tested on NUMAQ, x86 SMP and ppc64 power4/5 LPARs.
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin J. Bligh <mbligh@aracnet.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 14:07:37 +07:00
|
|
|
#define nid_page_nr(nid, pagenr) pgdat_page_nr(NODE_DATA(nid),(pagenr))
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-10-30 08:16:52 +07:00
|
|
|
#include <linux/memory_hotplug.h>
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
void __get_zone_counts(unsigned long *active, unsigned long *inactive,
|
|
|
|
unsigned long *free, struct pglist_data *pgdat);
|
|
|
|
void get_zone_counts(unsigned long *active, unsigned long *inactive,
|
|
|
|
unsigned long *free);
|
|
|
|
void build_all_zonelists(void);
|
|
|
|
void wakeup_kswapd(struct zone *zone, int order);
|
|
|
|
int zone_watermark_ok(struct zone *z, int order, unsigned long mark,
|
2005-11-14 07:06:43 +07:00
|
|
|
int classzone_idx, int alloc_flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-06-23 16:03:10 +07:00
|
|
|
extern int init_currently_empty_zone(struct zone *zone, unsigned long start_pfn,
|
|
|
|
unsigned long size);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef CONFIG_HAVE_MEMORY_PRESENT
|
|
|
|
void memory_present(int nid, unsigned long start, unsigned long end);
|
|
|
|
#else
|
|
|
|
static inline void memory_present(int nid, unsigned long start, unsigned long end) {}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_NEED_NODE_MEMMAP_SIZE
|
|
|
|
unsigned long __init node_memmap_size_bytes(int, unsigned long, unsigned long);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* zone_idx() returns 0 for the ZONE_DMA zone, 1 for the ZONE_NORMAL zone, etc.
|
|
|
|
*/
|
|
|
|
#define zone_idx(zone) ((zone) - (zone)->zone_pgdat->node_zones)
|
|
|
|
|
2006-01-06 15:11:15 +07:00
|
|
|
static inline int populated_zone(struct zone *zone)
|
|
|
|
{
|
|
|
|
return (!!zone->present_pages);
|
|
|
|
}
|
|
|
|
|
2006-09-26 13:31:13 +07:00
|
|
|
static inline int is_highmem_idx(enum zone_type idx)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-09-26 13:31:14 +07:00
|
|
|
#ifdef CONFIG_HIGHMEM
|
2005-04-17 05:20:36 +07:00
|
|
|
return (idx == ZONE_HIGHMEM);
|
2006-09-26 13:31:14 +07:00
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2006-09-26 13:31:13 +07:00
|
|
|
static inline int is_normal_idx(enum zone_type idx)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
return (idx == ZONE_NORMAL);
|
|
|
|
}
|
2006-01-06 15:11:10 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/**
|
|
|
|
* is_highmem - helper function to quickly check if a struct zone is a
|
|
|
|
* highmem zone or not. This is an attempt to keep references
|
|
|
|
* to ZONE_{DMA/NORMAL/HIGHMEM/etc} in general code to a minimum.
|
|
|
|
* @zone - pointer to struct zone variable
|
|
|
|
*/
|
|
|
|
static inline int is_highmem(struct zone *zone)
|
|
|
|
{
|
2006-09-26 13:31:14 +07:00
|
|
|
#ifdef CONFIG_HIGHMEM
|
2005-04-17 05:20:36 +07:00
|
|
|
return zone == zone->zone_pgdat->node_zones + ZONE_HIGHMEM;
|
2006-09-26 13:31:14 +07:00
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int is_normal(struct zone *zone)
|
|
|
|
{
|
|
|
|
return zone == zone->zone_pgdat->node_zones + ZONE_NORMAL;
|
|
|
|
}
|
|
|
|
|
2006-01-06 15:11:10 +07:00
|
|
|
static inline int is_dma32(struct zone *zone)
|
|
|
|
{
|
2006-09-26 13:31:13 +07:00
|
|
|
#ifdef CONFIG_ZONE_DMA32
|
2006-01-06 15:11:10 +07:00
|
|
|
return zone == zone->zone_pgdat->node_zones + ZONE_DMA32;
|
2006-09-26 13:31:13 +07:00
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
2006-01-06 15:11:10 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int is_dma(struct zone *zone)
|
|
|
|
{
|
|
|
|
return zone == zone->zone_pgdat->node_zones + ZONE_DMA;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* These two functions are used to setup the per zone pages min values */
|
|
|
|
struct ctl_table;
|
|
|
|
struct file;
|
|
|
|
int min_free_kbytes_sysctl_handler(struct ctl_table *, int, struct file *,
|
|
|
|
void __user *, size_t *, loff_t *);
|
|
|
|
extern int sysctl_lowmem_reserve_ratio[MAX_NR_ZONES-1];
|
|
|
|
int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *, int, struct file *,
|
|
|
|
void __user *, size_t *, loff_t *);
|
2006-01-08 16:00:40 +07:00
|
|
|
int percpu_pagelist_fraction_sysctl_handler(struct ctl_table *, int, struct file *,
|
|
|
|
void __user *, size_t *, loff_t *);
|
2006-07-03 14:24:13 +07:00
|
|
|
int sysctl_min_unmapped_ratio_sysctl_handler(struct ctl_table *, int,
|
|
|
|
struct file *, void __user *, size_t *, loff_t *);
|
2006-09-26 13:31:52 +07:00
|
|
|
int sysctl_min_slab_ratio_sysctl_handler(struct ctl_table *, int,
|
|
|
|
struct file *, void __user *, size_t *, loff_t *);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#include <linux/topology.h>
|
|
|
|
/* Returns the number of the current Node. */
|
2005-11-05 23:25:53 +07:00
|
|
|
#ifndef numa_node_id
|
2005-06-22 07:14:34 +07:00
|
|
|
#define numa_node_id() (cpu_to_node(raw_smp_processor_id()))
|
2005-11-05 23:25:53 +07:00
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-06-23 14:07:47 +07:00
|
|
|
#ifndef CONFIG_NEED_MULTIPLE_NODES
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
extern struct pglist_data contig_page_data;
|
|
|
|
#define NODE_DATA(nid) (&contig_page_data)
|
|
|
|
#define NODE_MEM_MAP(nid) mem_map
|
|
|
|
#define MAX_NODES_SHIFT 1
|
|
|
|
|
2005-06-23 14:07:47 +07:00
|
|
|
#else /* CONFIG_NEED_MULTIPLE_NODES */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#include <asm/mmzone.h>
|
|
|
|
|
2005-06-23 14:07:47 +07:00
|
|
|
#endif /* !CONFIG_NEED_MULTIPLE_NODES */
|
2005-06-23 14:07:40 +07:00
|
|
|
|
2006-03-27 16:16:02 +07:00
|
|
|
extern struct pglist_data *first_online_pgdat(void);
|
|
|
|
extern struct pglist_data *next_online_pgdat(struct pglist_data *pgdat);
|
|
|
|
extern struct zone *next_zone(struct zone *zone);
|
2006-03-27 16:15:57 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* for_each_pgdat - helper macro to iterate over all nodes
|
|
|
|
* @pgdat - pointer to a pg_data_t variable
|
|
|
|
*/
|
|
|
|
#define for_each_online_pgdat(pgdat) \
|
|
|
|
for (pgdat = first_online_pgdat(); \
|
|
|
|
pgdat; \
|
|
|
|
pgdat = next_online_pgdat(pgdat))
|
|
|
|
/**
|
|
|
|
* for_each_zone - helper macro to iterate over all memory zones
|
|
|
|
* @zone - pointer to struct zone variable
|
|
|
|
*
|
|
|
|
* The user only needs to declare the zone variable, for_each_zone
|
|
|
|
* fills it in.
|
|
|
|
*/
|
|
|
|
#define for_each_zone(zone) \
|
|
|
|
for (zone = (first_online_pgdat())->node_zones; \
|
|
|
|
zone; \
|
|
|
|
zone = next_zone(zone))
|
|
|
|
|
[PATCH] sparsemem memory model
Sparsemem abstracts the use of discontiguous mem_maps[]. This kind of
mem_map[] is needed by discontiguous memory machines (like in the old
CONFIG_DISCONTIGMEM case) as well as memory hotplug systems. Sparsemem
replaces DISCONTIGMEM when enabled, and it is hoped that it can eventually
become a complete replacement.
A significant advantage over DISCONTIGMEM is that it's completely separated
from CONFIG_NUMA. When producing this patch, it became apparent in that NUMA
and DISCONTIG are often confused.
Another advantage is that sparse doesn't require each NUMA node's ranges to be
contiguous. It can handle overlapping ranges between nodes with no problems,
where DISCONTIGMEM currently throws away that memory.
Sparsemem uses an array to provide different pfn_to_page() translations for
each SECTION_SIZE area of physical memory. This is what allows the mem_map[]
to be chopped up.
In order to do quick pfn_to_page() operations, the section number of the page
is encoded in page->flags. Part of the sparsemem infrastructure enables
sharing of these bits more dynamically (at compile-time) between the
page_zone() and sparsemem operations. However, on 32-bit architectures, the
number of bits is quite limited, and may require growing the size of the
page->flags type in certain conditions. Several things might force this to
occur: a decrease in the SECTION_SIZE (if you want to hotplug smaller areas of
memory), an increase in the physical address space, or an increase in the
number of used page->flags.
One thing to note is that, once sparsemem is present, the NUMA node
information no longer needs to be stored in the page->flags. It might provide
speed increases on certain platforms and will be stored there if there is
room. But, if out of room, an alternate (theoretically slower) mechanism is
used.
This patch introduces CONFIG_FLATMEM. It is used in almost all cases where
there used to be an #ifndef DISCONTIG, because SPARSEMEM and DISCONTIGMEM
often have to compile out the same areas of code.
Signed-off-by: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin Bligh <mbligh@aracnet.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 14:07:54 +07:00
|
|
|
#ifdef CONFIG_SPARSEMEM
|
|
|
|
#include <asm/sparsemem.h>
|
|
|
|
#endif
|
|
|
|
|
2005-11-05 23:25:53 +07:00
|
|
|
#if BITS_PER_LONG == 32
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
2005-11-05 23:25:53 +07:00
|
|
|
* with 32 bit page->flags field, we reserve 9 bits for node/zone info.
|
|
|
|
* there are 4 zones (3 bits) and this leaves 9-3=6 bits for nodes.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2005-11-05 23:25:53 +07:00
|
|
|
#define FLAGS_RESERVED 9
|
2005-06-23 14:07:40 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#elif BITS_PER_LONG == 64
|
|
|
|
/*
|
|
|
|
* with 64 bit flags field, there's plenty of room.
|
|
|
|
*/
|
2005-06-23 14:07:40 +07:00
|
|
|
#define FLAGS_RESERVED 32
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-06-23 14:07:40 +07:00
|
|
|
#else
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-06-23 14:07:40 +07:00
|
|
|
#error BITS_PER_LONG not defined
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#endif
|
|
|
|
|
[PATCH] Introduce mechanism for registering active regions of memory
At a basic level, architectures define structures to record where active
ranges of page frames are located. Once located, the code to calculate zone
sizes and holes in each architecture is very similar. Some of this zone and
hole sizing code is difficult to read for no good reason. This set of patches
eliminates the similar-looking architecture-specific code.
The patches introduce a mechanism where architectures register where the
active ranges of page frames are with add_active_range(). When all areas have
been discovered, free_area_init_nodes() is called to initialise the pgdat and
zones. The zone sizes and holes are then calculated in an architecture
independent manner.
Patch 1 introduces the mechanism for registering and initialising PFN ranges
Patch 2 changes ppc to use the mechanism - 139 arch-specific LOC removed
Patch 3 changes x86 to use the mechanism - 136 arch-specific LOC removed
Patch 4 changes x86_64 to use the mechanism - 74 arch-specific LOC removed
Patch 5 changes ia64 to use the mechanism - 52 arch-specific LOC removed
Patch 6 accounts for mem_map as a memory hole as the pages are not reclaimable.
It adjusts the watermarks slightly
Tony Luck has successfully tested for ia64 on Itanium with tiger_defconfig,
gensparse_defconfig and defconfig. Bob Picco has also tested and debugged on
IA64. Jack Steiner successfully boot tested on a mammoth SGI IA64-based
machine. These were on patches against 2.6.17-rc1 and release 3 of these
patches but there have been no ia64-changes since release 3.
There are differences in the zone sizes for x86_64 as the arch-specific code
for x86_64 accounts the kernel image and the starting mem_maps as memory holes
but the architecture-independent code accounts the memory as present.
The big benefit of this set of patches is a sizable reduction of
architecture-specific code, some of which is very hairy. There should be a
greater reduction when other architectures use the same mechanisms for zone
and hole sizing but I lack the hardware to test on.
Additional credit;
Dave Hansen for the initial suggestion and comments on early patches
Andy Whitcroft for reviewing early versions and catching numerous
errors
Tony Luck for testing and debugging on IA64
Bob Picco for fixing bugs related to pfn registration, reviewing a
number of patch revisions, providing a number of suggestions
on future direction and testing heavily
Jack Steiner and Robin Holt for testing on IA64 and clarifying
issues related to memory holes
Yasunori for testing on IA64
Andi Kleen for reviewing and feeding back about x86_64
Christian Kujau for providing valuable information related to ACPI
problems on x86_64 and testing potential fixes
This patch:
Define the structure to represent an active range of page frames within a node
in an architecture independent manner. Architectures are expected to register
active ranges of PFNs using add_active_range(nid, start_pfn, end_pfn) and call
free_area_init_nodes() passing the PFNs of the end of each zone.
Signed-off-by: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Cc: Dave Hansen <haveblue@us.ibm.com>
Cc: Andy Whitcroft <apw@shadowen.org>
Cc: Andi Kleen <ak@muc.de>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: "Keith Mannthey" <kmannth@gmail.com>
Cc: "Luck, Tony" <tony.luck@intel.com>
Cc: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Cc: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-09-27 15:49:43 +07:00
|
|
|
#if !defined(CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID) && \
|
|
|
|
!defined(CONFIG_ARCH_POPULATES_NODE_MAP)
|
2005-06-23 14:07:52 +07:00
|
|
|
#define early_pfn_to_nid(nid) (0UL)
|
|
|
|
#endif
|
|
|
|
|
2006-01-06 15:10:53 +07:00
|
|
|
#ifdef CONFIG_FLATMEM
|
|
|
|
#define pfn_to_nid(pfn) (0)
|
|
|
|
#endif
|
|
|
|
|
[PATCH] sparsemem memory model
Sparsemem abstracts the use of discontiguous mem_maps[]. This kind of
mem_map[] is needed by discontiguous memory machines (like in the old
CONFIG_DISCONTIGMEM case) as well as memory hotplug systems. Sparsemem
replaces DISCONTIGMEM when enabled, and it is hoped that it can eventually
become a complete replacement.
A significant advantage over DISCONTIGMEM is that it's completely separated
from CONFIG_NUMA. When producing this patch, it became apparent in that NUMA
and DISCONTIG are often confused.
Another advantage is that sparse doesn't require each NUMA node's ranges to be
contiguous. It can handle overlapping ranges between nodes with no problems,
where DISCONTIGMEM currently throws away that memory.
Sparsemem uses an array to provide different pfn_to_page() translations for
each SECTION_SIZE area of physical memory. This is what allows the mem_map[]
to be chopped up.
In order to do quick pfn_to_page() operations, the section number of the page
is encoded in page->flags. Part of the sparsemem infrastructure enables
sharing of these bits more dynamically (at compile-time) between the
page_zone() and sparsemem operations. However, on 32-bit architectures, the
number of bits is quite limited, and may require growing the size of the
page->flags type in certain conditions. Several things might force this to
occur: a decrease in the SECTION_SIZE (if you want to hotplug smaller areas of
memory), an increase in the physical address space, or an increase in the
number of used page->flags.
One thing to note is that, once sparsemem is present, the NUMA node
information no longer needs to be stored in the page->flags. It might provide
speed increases on certain platforms and will be stored there if there is
room. But, if out of room, an alternate (theoretically slower) mechanism is
used.
This patch introduces CONFIG_FLATMEM. It is used in almost all cases where
there used to be an #ifndef DISCONTIG, because SPARSEMEM and DISCONTIGMEM
often have to compile out the same areas of code.
Signed-off-by: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin Bligh <mbligh@aracnet.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 14:07:54 +07:00
|
|
|
#define pfn_to_section_nr(pfn) ((pfn) >> PFN_SECTION_SHIFT)
|
|
|
|
#define section_nr_to_pfn(sec) ((sec) << PFN_SECTION_SHIFT)
|
|
|
|
|
|
|
|
#ifdef CONFIG_SPARSEMEM
|
|
|
|
|
|
|
|
/*
|
|
|
|
* SECTION_SHIFT #bits space required to store a section #
|
|
|
|
*
|
|
|
|
* PA_SECTION_SHIFT physical address to/from section number
|
|
|
|
* PFN_SECTION_SHIFT pfn to/from section number
|
|
|
|
*/
|
|
|
|
#define SECTIONS_SHIFT (MAX_PHYSMEM_BITS - SECTION_SIZE_BITS)
|
|
|
|
|
|
|
|
#define PA_SECTION_SHIFT (SECTION_SIZE_BITS)
|
|
|
|
#define PFN_SECTION_SHIFT (SECTION_SIZE_BITS - PAGE_SHIFT)
|
|
|
|
|
|
|
|
#define NR_MEM_SECTIONS (1UL << SECTIONS_SHIFT)
|
|
|
|
|
|
|
|
#define PAGES_PER_SECTION (1UL << PFN_SECTION_SHIFT)
|
|
|
|
#define PAGE_SECTION_MASK (~(PAGES_PER_SECTION-1))
|
|
|
|
|
|
|
|
#if (MAX_ORDER - 1 + PAGE_SHIFT) > SECTION_SIZE_BITS
|
|
|
|
#error Allocator MAX_ORDER exceeds SECTION_SIZE
|
|
|
|
#endif
|
|
|
|
|
|
|
|
struct page;
|
|
|
|
struct mem_section {
|
2005-06-23 14:08:00 +07:00
|
|
|
/*
|
|
|
|
* This is, logically, a pointer to an array of struct
|
|
|
|
* pages. However, it is stored with some other magic.
|
|
|
|
* (see sparse.c::sparse_init_one_section())
|
|
|
|
*
|
2006-06-23 16:03:41 +07:00
|
|
|
* Additionally during early boot we encode node id of
|
|
|
|
* the location of the section here to guide allocation.
|
|
|
|
* (see sparse.c::memory_present())
|
|
|
|
*
|
2005-06-23 14:08:00 +07:00
|
|
|
* Making it a UL at least makes someone do a cast
|
|
|
|
* before using it wrong.
|
|
|
|
*/
|
|
|
|
unsigned long section_mem_map;
|
[PATCH] sparsemem memory model
Sparsemem abstracts the use of discontiguous mem_maps[]. This kind of
mem_map[] is needed by discontiguous memory machines (like in the old
CONFIG_DISCONTIGMEM case) as well as memory hotplug systems. Sparsemem
replaces DISCONTIGMEM when enabled, and it is hoped that it can eventually
become a complete replacement.
A significant advantage over DISCONTIGMEM is that it's completely separated
from CONFIG_NUMA. When producing this patch, it became apparent in that NUMA
and DISCONTIG are often confused.
Another advantage is that sparse doesn't require each NUMA node's ranges to be
contiguous. It can handle overlapping ranges between nodes with no problems,
where DISCONTIGMEM currently throws away that memory.
Sparsemem uses an array to provide different pfn_to_page() translations for
each SECTION_SIZE area of physical memory. This is what allows the mem_map[]
to be chopped up.
In order to do quick pfn_to_page() operations, the section number of the page
is encoded in page->flags. Part of the sparsemem infrastructure enables
sharing of these bits more dynamically (at compile-time) between the
page_zone() and sparsemem operations. However, on 32-bit architectures, the
number of bits is quite limited, and may require growing the size of the
page->flags type in certain conditions. Several things might force this to
occur: a decrease in the SECTION_SIZE (if you want to hotplug smaller areas of
memory), an increase in the physical address space, or an increase in the
number of used page->flags.
One thing to note is that, once sparsemem is present, the NUMA node
information no longer needs to be stored in the page->flags. It might provide
speed increases on certain platforms and will be stored there if there is
room. But, if out of room, an alternate (theoretically slower) mechanism is
used.
This patch introduces CONFIG_FLATMEM. It is used in almost all cases where
there used to be an #ifndef DISCONTIG, because SPARSEMEM and DISCONTIGMEM
often have to compile out the same areas of code.
Signed-off-by: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin Bligh <mbligh@aracnet.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 14:07:54 +07:00
|
|
|
};
|
|
|
|
|
2005-09-04 05:54:28 +07:00
|
|
|
#ifdef CONFIG_SPARSEMEM_EXTREME
|
|
|
|
#define SECTIONS_PER_ROOT (PAGE_SIZE / sizeof (struct mem_section))
|
|
|
|
#else
|
|
|
|
#define SECTIONS_PER_ROOT 1
|
|
|
|
#endif
|
2005-09-04 05:54:26 +07:00
|
|
|
|
2005-09-04 05:54:28 +07:00
|
|
|
#define SECTION_NR_TO_ROOT(sec) ((sec) / SECTIONS_PER_ROOT)
|
|
|
|
#define NR_SECTION_ROOTS (NR_MEM_SECTIONS / SECTIONS_PER_ROOT)
|
|
|
|
#define SECTION_ROOT_MASK (SECTIONS_PER_ROOT - 1)
|
2005-09-04 05:54:26 +07:00
|
|
|
|
2005-09-04 05:54:28 +07:00
|
|
|
#ifdef CONFIG_SPARSEMEM_EXTREME
|
|
|
|
extern struct mem_section *mem_section[NR_SECTION_ROOTS];
|
2005-09-04 05:54:26 +07:00
|
|
|
#else
|
2005-09-04 05:54:28 +07:00
|
|
|
extern struct mem_section mem_section[NR_SECTION_ROOTS][SECTIONS_PER_ROOT];
|
|
|
|
#endif
|
[PATCH] sparsemem memory model
Sparsemem abstracts the use of discontiguous mem_maps[]. This kind of
mem_map[] is needed by discontiguous memory machines (like in the old
CONFIG_DISCONTIGMEM case) as well as memory hotplug systems. Sparsemem
replaces DISCONTIGMEM when enabled, and it is hoped that it can eventually
become a complete replacement.
A significant advantage over DISCONTIGMEM is that it's completely separated
from CONFIG_NUMA. When producing this patch, it became apparent in that NUMA
and DISCONTIG are often confused.
Another advantage is that sparse doesn't require each NUMA node's ranges to be
contiguous. It can handle overlapping ranges between nodes with no problems,
where DISCONTIGMEM currently throws away that memory.
Sparsemem uses an array to provide different pfn_to_page() translations for
each SECTION_SIZE area of physical memory. This is what allows the mem_map[]
to be chopped up.
In order to do quick pfn_to_page() operations, the section number of the page
is encoded in page->flags. Part of the sparsemem infrastructure enables
sharing of these bits more dynamically (at compile-time) between the
page_zone() and sparsemem operations. However, on 32-bit architectures, the
number of bits is quite limited, and may require growing the size of the
page->flags type in certain conditions. Several things might force this to
occur: a decrease in the SECTION_SIZE (if you want to hotplug smaller areas of
memory), an increase in the physical address space, or an increase in the
number of used page->flags.
One thing to note is that, once sparsemem is present, the NUMA node
information no longer needs to be stored in the page->flags. It might provide
speed increases on certain platforms and will be stored there if there is
room. But, if out of room, an alternate (theoretically slower) mechanism is
used.
This patch introduces CONFIG_FLATMEM. It is used in almost all cases where
there used to be an #ifndef DISCONTIG, because SPARSEMEM and DISCONTIGMEM
often have to compile out the same areas of code.
Signed-off-by: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin Bligh <mbligh@aracnet.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 14:07:54 +07:00
|
|
|
|
2005-06-23 14:08:00 +07:00
|
|
|
static inline struct mem_section *__nr_to_section(unsigned long nr)
|
|
|
|
{
|
2005-09-04 05:54:28 +07:00
|
|
|
if (!mem_section[SECTION_NR_TO_ROOT(nr)])
|
|
|
|
return NULL;
|
|
|
|
return &mem_section[SECTION_NR_TO_ROOT(nr)][nr & SECTION_ROOT_MASK];
|
2005-06-23 14:08:00 +07:00
|
|
|
}
|
2005-10-30 08:16:51 +07:00
|
|
|
extern int __section_nr(struct mem_section* ms);
|
2005-06-23 14:08:00 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We use the lower bits of the mem_map pointer to store
|
|
|
|
* a little bit of information. There should be at least
|
|
|
|
* 3 bits here due to 32-bit alignment.
|
|
|
|
*/
|
|
|
|
#define SECTION_MARKED_PRESENT (1UL<<0)
|
|
|
|
#define SECTION_HAS_MEM_MAP (1UL<<1)
|
|
|
|
#define SECTION_MAP_LAST_BIT (1UL<<2)
|
|
|
|
#define SECTION_MAP_MASK (~(SECTION_MAP_LAST_BIT-1))
|
2006-06-23 16:03:41 +07:00
|
|
|
#define SECTION_NID_SHIFT 2
|
2005-06-23 14:08:00 +07:00
|
|
|
|
|
|
|
static inline struct page *__section_mem_map_addr(struct mem_section *section)
|
|
|
|
{
|
|
|
|
unsigned long map = section->section_mem_map;
|
|
|
|
map &= SECTION_MAP_MASK;
|
|
|
|
return (struct page *)map;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int valid_section(struct mem_section *section)
|
|
|
|
{
|
2005-09-04 05:54:26 +07:00
|
|
|
return (section && (section->section_mem_map & SECTION_MARKED_PRESENT));
|
2005-06-23 14:08:00 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int section_has_mem_map(struct mem_section *section)
|
|
|
|
{
|
2005-09-04 05:54:26 +07:00
|
|
|
return (section && (section->section_mem_map & SECTION_HAS_MEM_MAP));
|
2005-06-23 14:08:00 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int valid_section_nr(unsigned long nr)
|
|
|
|
{
|
|
|
|
return valid_section(__nr_to_section(nr));
|
|
|
|
}
|
|
|
|
|
[PATCH] sparsemem memory model
Sparsemem abstracts the use of discontiguous mem_maps[]. This kind of
mem_map[] is needed by discontiguous memory machines (like in the old
CONFIG_DISCONTIGMEM case) as well as memory hotplug systems. Sparsemem
replaces DISCONTIGMEM when enabled, and it is hoped that it can eventually
become a complete replacement.
A significant advantage over DISCONTIGMEM is that it's completely separated
from CONFIG_NUMA. When producing this patch, it became apparent in that NUMA
and DISCONTIG are often confused.
Another advantage is that sparse doesn't require each NUMA node's ranges to be
contiguous. It can handle overlapping ranges between nodes with no problems,
where DISCONTIGMEM currently throws away that memory.
Sparsemem uses an array to provide different pfn_to_page() translations for
each SECTION_SIZE area of physical memory. This is what allows the mem_map[]
to be chopped up.
In order to do quick pfn_to_page() operations, the section number of the page
is encoded in page->flags. Part of the sparsemem infrastructure enables
sharing of these bits more dynamically (at compile-time) between the
page_zone() and sparsemem operations. However, on 32-bit architectures, the
number of bits is quite limited, and may require growing the size of the
page->flags type in certain conditions. Several things might force this to
occur: a decrease in the SECTION_SIZE (if you want to hotplug smaller areas of
memory), an increase in the physical address space, or an increase in the
number of used page->flags.
One thing to note is that, once sparsemem is present, the NUMA node
information no longer needs to be stored in the page->flags. It might provide
speed increases on certain platforms and will be stored there if there is
room. But, if out of room, an alternate (theoretically slower) mechanism is
used.
This patch introduces CONFIG_FLATMEM. It is used in almost all cases where
there used to be an #ifndef DISCONTIG, because SPARSEMEM and DISCONTIGMEM
often have to compile out the same areas of code.
Signed-off-by: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin Bligh <mbligh@aracnet.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 14:07:54 +07:00
|
|
|
static inline struct mem_section *__pfn_to_section(unsigned long pfn)
|
|
|
|
{
|
2005-06-23 14:08:00 +07:00
|
|
|
return __nr_to_section(pfn_to_section_nr(pfn));
|
[PATCH] sparsemem memory model
Sparsemem abstracts the use of discontiguous mem_maps[]. This kind of
mem_map[] is needed by discontiguous memory machines (like in the old
CONFIG_DISCONTIGMEM case) as well as memory hotplug systems. Sparsemem
replaces DISCONTIGMEM when enabled, and it is hoped that it can eventually
become a complete replacement.
A significant advantage over DISCONTIGMEM is that it's completely separated
from CONFIG_NUMA. When producing this patch, it became apparent in that NUMA
and DISCONTIG are often confused.
Another advantage is that sparse doesn't require each NUMA node's ranges to be
contiguous. It can handle overlapping ranges between nodes with no problems,
where DISCONTIGMEM currently throws away that memory.
Sparsemem uses an array to provide different pfn_to_page() translations for
each SECTION_SIZE area of physical memory. This is what allows the mem_map[]
to be chopped up.
In order to do quick pfn_to_page() operations, the section number of the page
is encoded in page->flags. Part of the sparsemem infrastructure enables
sharing of these bits more dynamically (at compile-time) between the
page_zone() and sparsemem operations. However, on 32-bit architectures, the
number of bits is quite limited, and may require growing the size of the
page->flags type in certain conditions. Several things might force this to
occur: a decrease in the SECTION_SIZE (if you want to hotplug smaller areas of
memory), an increase in the physical address space, or an increase in the
number of used page->flags.
One thing to note is that, once sparsemem is present, the NUMA node
information no longer needs to be stored in the page->flags. It might provide
speed increases on certain platforms and will be stored there if there is
room. But, if out of room, an alternate (theoretically slower) mechanism is
used.
This patch introduces CONFIG_FLATMEM. It is used in almost all cases where
there used to be an #ifndef DISCONTIG, because SPARSEMEM and DISCONTIGMEM
often have to compile out the same areas of code.
Signed-off-by: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin Bligh <mbligh@aracnet.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 14:07:54 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int pfn_valid(unsigned long pfn)
|
|
|
|
{
|
|
|
|
if (pfn_to_section_nr(pfn) >= NR_MEM_SECTIONS)
|
|
|
|
return 0;
|
2005-06-23 14:08:00 +07:00
|
|
|
return valid_section(__nr_to_section(pfn_to_section_nr(pfn)));
|
[PATCH] sparsemem memory model
Sparsemem abstracts the use of discontiguous mem_maps[]. This kind of
mem_map[] is needed by discontiguous memory machines (like in the old
CONFIG_DISCONTIGMEM case) as well as memory hotplug systems. Sparsemem
replaces DISCONTIGMEM when enabled, and it is hoped that it can eventually
become a complete replacement.
A significant advantage over DISCONTIGMEM is that it's completely separated
from CONFIG_NUMA. When producing this patch, it became apparent in that NUMA
and DISCONTIG are often confused.
Another advantage is that sparse doesn't require each NUMA node's ranges to be
contiguous. It can handle overlapping ranges between nodes with no problems,
where DISCONTIGMEM currently throws away that memory.
Sparsemem uses an array to provide different pfn_to_page() translations for
each SECTION_SIZE area of physical memory. This is what allows the mem_map[]
to be chopped up.
In order to do quick pfn_to_page() operations, the section number of the page
is encoded in page->flags. Part of the sparsemem infrastructure enables
sharing of these bits more dynamically (at compile-time) between the
page_zone() and sparsemem operations. However, on 32-bit architectures, the
number of bits is quite limited, and may require growing the size of the
page->flags type in certain conditions. Several things might force this to
occur: a decrease in the SECTION_SIZE (if you want to hotplug smaller areas of
memory), an increase in the physical address space, or an increase in the
number of used page->flags.
One thing to note is that, once sparsemem is present, the NUMA node
information no longer needs to be stored in the page->flags. It might provide
speed increases on certain platforms and will be stored there if there is
room. But, if out of room, an alternate (theoretically slower) mechanism is
used.
This patch introduces CONFIG_FLATMEM. It is used in almost all cases where
there used to be an #ifndef DISCONTIG, because SPARSEMEM and DISCONTIGMEM
often have to compile out the same areas of code.
Signed-off-by: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin Bligh <mbligh@aracnet.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 14:07:54 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* These are _only_ used during initialisation, therefore they
|
|
|
|
* can use __initdata ... They could have names to indicate
|
|
|
|
* this restriction.
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_NUMA
|
2006-01-06 15:10:54 +07:00
|
|
|
#define pfn_to_nid(pfn) \
|
|
|
|
({ \
|
|
|
|
unsigned long __pfn_to_nid_pfn = (pfn); \
|
|
|
|
page_to_nid(pfn_to_page(__pfn_to_nid_pfn)); \
|
|
|
|
})
|
2006-01-06 15:10:53 +07:00
|
|
|
#else
|
|
|
|
#define pfn_to_nid(pfn) (0)
|
[PATCH] sparsemem memory model
Sparsemem abstracts the use of discontiguous mem_maps[]. This kind of
mem_map[] is needed by discontiguous memory machines (like in the old
CONFIG_DISCONTIGMEM case) as well as memory hotplug systems. Sparsemem
replaces DISCONTIGMEM when enabled, and it is hoped that it can eventually
become a complete replacement.
A significant advantage over DISCONTIGMEM is that it's completely separated
from CONFIG_NUMA. When producing this patch, it became apparent in that NUMA
and DISCONTIG are often confused.
Another advantage is that sparse doesn't require each NUMA node's ranges to be
contiguous. It can handle overlapping ranges between nodes with no problems,
where DISCONTIGMEM currently throws away that memory.
Sparsemem uses an array to provide different pfn_to_page() translations for
each SECTION_SIZE area of physical memory. This is what allows the mem_map[]
to be chopped up.
In order to do quick pfn_to_page() operations, the section number of the page
is encoded in page->flags. Part of the sparsemem infrastructure enables
sharing of these bits more dynamically (at compile-time) between the
page_zone() and sparsemem operations. However, on 32-bit architectures, the
number of bits is quite limited, and may require growing the size of the
page->flags type in certain conditions. Several things might force this to
occur: a decrease in the SECTION_SIZE (if you want to hotplug smaller areas of
memory), an increase in the physical address space, or an increase in the
number of used page->flags.
One thing to note is that, once sparsemem is present, the NUMA node
information no longer needs to be stored in the page->flags. It might provide
speed increases on certain platforms and will be stored there if there is
room. But, if out of room, an alternate (theoretically slower) mechanism is
used.
This patch introduces CONFIG_FLATMEM. It is used in almost all cases where
there used to be an #ifndef DISCONTIG, because SPARSEMEM and DISCONTIGMEM
often have to compile out the same areas of code.
Signed-off-by: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin Bligh <mbligh@aracnet.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 14:07:54 +07:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#define early_pfn_valid(pfn) pfn_valid(pfn)
|
|
|
|
void sparse_init(void);
|
|
|
|
#else
|
|
|
|
#define sparse_init() do {} while (0)
|
2005-09-04 05:54:29 +07:00
|
|
|
#define sparse_index_init(_sec, _nid) do {} while (0)
|
[PATCH] sparsemem memory model
Sparsemem abstracts the use of discontiguous mem_maps[]. This kind of
mem_map[] is needed by discontiguous memory machines (like in the old
CONFIG_DISCONTIGMEM case) as well as memory hotplug systems. Sparsemem
replaces DISCONTIGMEM when enabled, and it is hoped that it can eventually
become a complete replacement.
A significant advantage over DISCONTIGMEM is that it's completely separated
from CONFIG_NUMA. When producing this patch, it became apparent in that NUMA
and DISCONTIG are often confused.
Another advantage is that sparse doesn't require each NUMA node's ranges to be
contiguous. It can handle overlapping ranges between nodes with no problems,
where DISCONTIGMEM currently throws away that memory.
Sparsemem uses an array to provide different pfn_to_page() translations for
each SECTION_SIZE area of physical memory. This is what allows the mem_map[]
to be chopped up.
In order to do quick pfn_to_page() operations, the section number of the page
is encoded in page->flags. Part of the sparsemem infrastructure enables
sharing of these bits more dynamically (at compile-time) between the
page_zone() and sparsemem operations. However, on 32-bit architectures, the
number of bits is quite limited, and may require growing the size of the
page->flags type in certain conditions. Several things might force this to
occur: a decrease in the SECTION_SIZE (if you want to hotplug smaller areas of
memory), an increase in the physical address space, or an increase in the
number of used page->flags.
One thing to note is that, once sparsemem is present, the NUMA node
information no longer needs to be stored in the page->flags. It might provide
speed increases on certain platforms and will be stored there if there is
room. But, if out of room, an alternate (theoretically slower) mechanism is
used.
This patch introduces CONFIG_FLATMEM. It is used in almost all cases where
there used to be an #ifndef DISCONTIG, because SPARSEMEM and DISCONTIGMEM
often have to compile out the same areas of code.
Signed-off-by: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin Bligh <mbligh@aracnet.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 14:07:54 +07:00
|
|
|
#endif /* CONFIG_SPARSEMEM */
|
|
|
|
|
|
|
|
#ifndef early_pfn_valid
|
|
|
|
#define early_pfn_valid(pfn) (1)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
void memory_present(int nid, unsigned long start, unsigned long end);
|
|
|
|
unsigned long __init node_memmap_size_bytes(int, unsigned long, unsigned long);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif /* !__ASSEMBLY__ */
|
|
|
|
#endif /* __KERNEL__ */
|
|
|
|
#endif /* _LINUX_MMZONE_H */
|