1#ifndef __LINUX_MEMORY_HOTPLUG_H
2#define __LINUX_MEMORY_HOTPLUG_H
3
4#include <linux/mmzone.h>
5#include <linux/spinlock.h>
6#include <linux/notifier.h>
7#include <linux/bug.h>
8
9struct page;
10struct zone;
11struct pglist_data;
12struct mem_section;
13struct memory_block;
14struct resource;
15
16#ifdef CONFIG_MEMORY_HOTPLUG
17
18/*
19 * Types for free bootmem stored in page->lru.next. These have to be in
20 * some random range in unsigned long space for debugging purposes.
21 */
22enum {
23	MEMORY_HOTPLUG_MIN_BOOTMEM_TYPE = 12,
24	SECTION_INFO = MEMORY_HOTPLUG_MIN_BOOTMEM_TYPE,
25	MIX_SECTION_INFO,
26	NODE_INFO,
27	MEMORY_HOTPLUG_MAX_BOOTMEM_TYPE = NODE_INFO,
28};
29
30/* Types for control the zone type of onlined and offlined memory */
31enum {
32	MMOP_OFFLINE = -1,
33	MMOP_ONLINE_KEEP,
34	MMOP_ONLINE_KERNEL,
35	MMOP_ONLINE_MOVABLE,
36};
37
38/*
39 * pgdat resizing functions
40 */
41static inline
42void pgdat_resize_lock(struct pglist_data *pgdat, unsigned long *flags)
43{
44	spin_lock_irqsave(&pgdat->node_size_lock, *flags);
45}
46static inline
47void pgdat_resize_unlock(struct pglist_data *pgdat, unsigned long *flags)
48{
49	spin_unlock_irqrestore(&pgdat->node_size_lock, *flags);
50}
51static inline
52void pgdat_resize_init(struct pglist_data *pgdat)
53{
54	spin_lock_init(&pgdat->node_size_lock);
55}
56/*
57 * Zone resizing functions
58 *
59 * Note: any attempt to resize a zone should has pgdat_resize_lock()
60 * zone_span_writelock() both held. This ensure the size of a zone
61 * can't be changed while pgdat_resize_lock() held.
62 */
63static inline unsigned zone_span_seqbegin(struct zone *zone)
64{
65	return read_seqbegin(&zone->span_seqlock);
66}
67static inline int zone_span_seqretry(struct zone *zone, unsigned iv)
68{
69	return read_seqretry(&zone->span_seqlock, iv);
70}
71static inline void zone_span_writelock(struct zone *zone)
72{
73	write_seqlock(&zone->span_seqlock);
74}
75static inline void zone_span_writeunlock(struct zone *zone)
76{
77	write_sequnlock(&zone->span_seqlock);
78}
79static inline void zone_seqlock_init(struct zone *zone)
80{
81	seqlock_init(&zone->span_seqlock);
82}
83extern int zone_grow_free_lists(struct zone *zone, unsigned long new_nr_pages);
84extern int zone_grow_waitqueues(struct zone *zone, unsigned long nr_pages);
85extern int add_one_highpage(struct page *page, int pfn, int bad_ppro);
86/* VM interface that may be used by firmware interface */
87extern int online_pages(unsigned long, unsigned long, int);
88extern int test_pages_in_a_zone(unsigned long, unsigned long);
89extern void __offline_isolated_pages(unsigned long, unsigned long);
90
91typedef void (*online_page_callback_t)(struct page *page);
92
93extern int set_online_page_callback(online_page_callback_t callback);
94extern int restore_online_page_callback(online_page_callback_t callback);
95
96extern void __online_page_set_limits(struct page *page);
97extern void __online_page_increment_counters(struct page *page);
98extern void __online_page_free(struct page *page);
99
100extern int try_online_node(int nid);
101
102#ifdef CONFIG_MEMORY_HOTREMOVE
103extern bool is_pageblock_removable_nolock(struct page *page);
104extern int arch_remove_memory(u64 start, u64 size);
105extern int __remove_pages(struct zone *zone, unsigned long start_pfn,
106	unsigned long nr_pages);
107#endif /* CONFIG_MEMORY_HOTREMOVE */
108
109/* reasonably generic interface to expand the physical pages in a zone  */
110extern int __add_pages(int nid, struct zone *zone, unsigned long start_pfn,
111	unsigned long nr_pages);
112
113#ifdef CONFIG_NUMA
114extern int memory_add_physaddr_to_nid(u64 start);
115#else
116static inline int memory_add_physaddr_to_nid(u64 start)
117{
118	return 0;
119}
120#endif
121
122#ifdef CONFIG_HAVE_ARCH_NODEDATA_EXTENSION
123/*
124 * For supporting node-hotadd, we have to allocate a new pgdat.
125 *
126 * If an arch has generic style NODE_DATA(),
127 * node_data[nid] = kzalloc() works well. But it depends on the architecture.
128 *
129 * In general, generic_alloc_nodedata() is used.
130 * Now, arch_free_nodedata() is just defined for error path of node_hot_add.
131 *
132 */
133extern pg_data_t *arch_alloc_nodedata(int nid);
134extern void arch_free_nodedata(pg_data_t *pgdat);
135extern void arch_refresh_nodedata(int nid, pg_data_t *pgdat);
136
137#else /* CONFIG_HAVE_ARCH_NODEDATA_EXTENSION */
138
139#define arch_alloc_nodedata(nid)	generic_alloc_nodedata(nid)
140#define arch_free_nodedata(pgdat)	generic_free_nodedata(pgdat)
141
142#ifdef CONFIG_NUMA
143/*
144 * If ARCH_HAS_NODEDATA_EXTENSION=n, this func is used to allocate pgdat.
145 * XXX: kmalloc_node() can't work well to get new node's memory at this time.
146 *	Because, pgdat for the new node is not allocated/initialized yet itself.
147 *	To use new node's memory, more consideration will be necessary.
148 */
149#define generic_alloc_nodedata(nid)				\
150({								\
151	kzalloc(sizeof(pg_data_t), GFP_KERNEL);			\
152})
153/*
154 * This definition is just for error path in node hotadd.
155 * For node hotremove, we have to replace this.
156 */
157#define generic_free_nodedata(pgdat)	kfree(pgdat)
158
159extern pg_data_t *node_data[];
160static inline void arch_refresh_nodedata(int nid, pg_data_t *pgdat)
161{
162	node_data[nid] = pgdat;
163}
164
165#else /* !CONFIG_NUMA */
166
167/* never called */
168static inline pg_data_t *generic_alloc_nodedata(int nid)
169{
170	BUG();
171	return NULL;
172}
173static inline void generic_free_nodedata(pg_data_t *pgdat)
174{
175}
176static inline void arch_refresh_nodedata(int nid, pg_data_t *pgdat)
177{
178}
179#endif /* CONFIG_NUMA */
180#endif /* CONFIG_HAVE_ARCH_NODEDATA_EXTENSION */
181
182#ifdef CONFIG_HAVE_BOOTMEM_INFO_NODE
183extern void register_page_bootmem_info_node(struct pglist_data *pgdat);
184#else
185static inline void register_page_bootmem_info_node(struct pglist_data *pgdat)
186{
187}
188#endif
189extern void put_page_bootmem(struct page *page);
190extern void get_page_bootmem(unsigned long ingo, struct page *page,
191			     unsigned long type);
192
193void get_online_mems(void);
194void put_online_mems(void);
195
196void mem_hotplug_begin(void);
197void mem_hotplug_done(void);
198
199#else /* ! CONFIG_MEMORY_HOTPLUG */
200/*
201 * Stub functions for when hotplug is off
202 */
203static inline void pgdat_resize_lock(struct pglist_data *p, unsigned long *f) {}
204static inline void pgdat_resize_unlock(struct pglist_data *p, unsigned long *f) {}
205static inline void pgdat_resize_init(struct pglist_data *pgdat) {}
206
207static inline unsigned zone_span_seqbegin(struct zone *zone)
208{
209	return 0;
210}
211static inline int zone_span_seqretry(struct zone *zone, unsigned iv)
212{
213	return 0;
214}
215static inline void zone_span_writelock(struct zone *zone) {}
216static inline void zone_span_writeunlock(struct zone *zone) {}
217static inline void zone_seqlock_init(struct zone *zone) {}
218
219static inline int mhp_notimplemented(const char *func)
220{
221	printk(KERN_WARNING "%s() called, with CONFIG_MEMORY_HOTPLUG disabled\n", func);
222	dump_stack();
223	return -ENOSYS;
224}
225
226static inline void register_page_bootmem_info_node(struct pglist_data *pgdat)
227{
228}
229
230static inline int try_online_node(int nid)
231{
232	return 0;
233}
234
235static inline void get_online_mems(void) {}
236static inline void put_online_mems(void) {}
237
238static inline void mem_hotplug_begin(void) {}
239static inline void mem_hotplug_done(void) {}
240
241#endif /* ! CONFIG_MEMORY_HOTPLUG */
242
243#ifdef CONFIG_MEMORY_HOTREMOVE
244
245extern int is_mem_section_removable(unsigned long pfn, unsigned long nr_pages);
246extern void try_offline_node(int nid);
247extern int offline_pages(unsigned long start_pfn, unsigned long nr_pages);
248extern void remove_memory(int nid, u64 start, u64 size);
249
250#else
251static inline int is_mem_section_removable(unsigned long pfn,
252					unsigned long nr_pages)
253{
254	return 0;
255}
256
257static inline void try_offline_node(int nid) {}
258
259static inline int offline_pages(unsigned long start_pfn, unsigned long nr_pages)
260{
261	return -EINVAL;
262}
263
264static inline void remove_memory(int nid, u64 start, u64 size) {}
265#endif /* CONFIG_MEMORY_HOTREMOVE */
266
267extern int walk_memory_range(unsigned long start_pfn, unsigned long end_pfn,
268		void *arg, int (*func)(struct memory_block *, void *));
269extern int add_memory(int nid, u64 start, u64 size);
270extern int add_memory_resource(int nid, struct resource *resource);
271extern int zone_for_memory(int nid, u64 start, u64 size, int zone_default,
272		bool for_device);
273extern int arch_add_memory(int nid, u64 start, u64 size, bool for_device);
274extern int offline_pages(unsigned long start_pfn, unsigned long nr_pages);
275extern bool is_memblock_offlined(struct memory_block *mem);
276extern void remove_memory(int nid, u64 start, u64 size);
277extern int sparse_add_one_section(struct zone *zone, unsigned long start_pfn);
278extern void sparse_remove_one_section(struct zone *zone, struct mem_section *ms);
279extern struct page *sparse_decode_mem_map(unsigned long coded_mem_map,
280					  unsigned long pnum);
281
282#endif /* __LINUX_MEMORY_HOTPLUG_H */
283