LXR linux/include/linux/memory

   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
 102extern bool memhp_auto_online;
 103
 104#ifdef CONFIG_MEMORY_HOTREMOVE
 105extern bool is_pageblock_removable_nolock(struct page *page);
 106extern int arch_remove_memory(u64 start, u64 size);
 107extern int __remove_pages(struct zone *zone, unsigned long start_pfn,
 108        unsigned long nr_pages);
 109#endif /* CONFIG_MEMORY_HOTREMOVE */
 110
 111/* reasonably generic interface to expand the physical pages in a zone  */
 112extern int __add_pages(int nid, struct zone *zone, unsigned long start_pfn,
 113        unsigned long nr_pages);
 114
 115#ifdef CONFIG_NUMA
 116extern int memory_add_physaddr_to_nid(u64 start);
 117#else
 118static inline int memory_add_physaddr_to_nid(u64 start)
 119{
 120        return 0;
 121}
 122#endif
 123
 124#ifdef CONFIG_HAVE_ARCH_NODEDATA_EXTENSION
 125/*
 126 * For supporting node-hotadd, we have to allocate a new pgdat.
 127 *
 128 * If an arch has generic style NODE_DATA(),
 129 * node_data[nid] = kzalloc() works well. But it depends on the architecture.
 130 *
 131 * In general, generic_alloc_nodedata() is used.
 132 * Now, arch_free_nodedata() is just defined for error path of node_hot_add.
 133 *
 134 */
 135extern pg_data_t *arch_alloc_nodedata(int nid);
 136extern void arch_free_nodedata(pg_data_t *pgdat);
 137extern void arch_refresh_nodedata(int nid, pg_data_t *pgdat);
 138
 139#else /* CONFIG_HAVE_ARCH_NODEDATA_EXTENSION */
 140
 141#define arch_alloc_nodedata(nid)        generic_alloc_nodedata(nid)
 142#define arch_free_nodedata(pgdat)       generic_free_nodedata(pgdat)
 143
 144#ifdef CONFIG_NUMA
 145/*
 146 * If ARCH_HAS_NODEDATA_EXTENSION=n, this func is used to allocate pgdat.
 147 * XXX: kmalloc_node() can't work well to get new node's memory at this time.
 148 *      Because, pgdat for the new node is not allocated/initialized yet itself.
 149 *      To use new node's memory, more consideration will be necessary.
 150 */
 151#define generic_alloc_nodedata(nid)                             \
 152({                                                              \
 153        kzalloc(sizeof(pg_data_t), GFP_KERNEL);                 \
 154})
 155/*
 156 * This definition is just for error path in node hotadd.
 157 * For node hotremove, we have to replace this.
 158 */
 159#define generic_free_nodedata(pgdat)    kfree(pgdat)
 160
 161extern pg_data_t *node_data[];
 162static inline void arch_refresh_nodedata(int nid, pg_data_t *pgdat)
 163{
 164        node_data[nid] = pgdat;
 165}
 166
 167#else /* !CONFIG_NUMA */
 168
 169/* never called */
 170static inline pg_data_t *generic_alloc_nodedata(int nid)
 171{
 172        BUG();
 173        return NULL;
 174}
 175static inline void generic_free_nodedata(pg_data_t *pgdat)
 176{
 177}
 178static inline void arch_refresh_nodedata(int nid, pg_data_t *pgdat)
 179{
 180}
 181#endif /* CONFIG_NUMA */
 182#endif /* CONFIG_HAVE_ARCH_NODEDATA_EXTENSION */
 183
 184#ifdef CONFIG_HAVE_BOOTMEM_INFO_NODE
 185extern void register_page_bootmem_info_node(struct pglist_data *pgdat);
 186#else
 187static inline void register_page_bootmem_info_node(struct pglist_data *pgdat)
 188{
 189}
 190#endif
 191extern void put_page_bootmem(struct page *page);
 192extern void get_page_bootmem(unsigned long ingo, struct page *page,
 193                             unsigned long type);
 194
 195void get_online_mems(void);
 196void put_online_mems(void);
 197
 198void mem_hotplug_begin(void);
 199void mem_hotplug_done(void);
 200
 201extern void set_zone_contiguous(struct zone *zone);
 202extern void clear_zone_contiguous(struct zone *zone);
 203
 204#else /* ! CONFIG_MEMORY_HOTPLUG */
 205/*
 206 * Stub functions for when hotplug is off
 207 */
 208static inline void pgdat_resize_lock(struct pglist_data *p, unsigned long *f) {}
 209static inline void pgdat_resize_unlock(struct pglist_data *p, unsigned long *f) {}
 210static inline void pgdat_resize_init(struct pglist_data *pgdat) {}
 211
 212static inline unsigned zone_span_seqbegin(struct zone *zone)
 213{
 214        return 0;
 215}
 216static inline int zone_span_seqretry(struct zone *zone, unsigned iv)
 217{
 218        return 0;
 219}
 220static inline void zone_span_writelock(struct zone *zone) {}
 221static inline void zone_span_writeunlock(struct zone *zone) {}
 222static inline void zone_seqlock_init(struct zone *zone) {}
 223
 224static inline int mhp_notimplemented(const char *func)
 225{
 226        printk(KERN_WARNING "%s() called, with CONFIG_MEMORY_HOTPLUG disabled\n", func);
 227        dump_stack();
 228        return -ENOSYS;
 229}
 230
 231static inline void register_page_bootmem_info_node(struct pglist_data *pgdat)
 232{
 233}
 234
 235static inline int try_online_node(int nid)
 236{
 237        return 0;
 238}
 239
 240static inline void get_online_mems(void) {}
 241static inline void put_online_mems(void) {}
 242
 243static inline void mem_hotplug_begin(void) {}
 244static inline void mem_hotplug_done(void) {}
 245
 246#endif /* ! CONFIG_MEMORY_HOTPLUG */
 247
 248#ifdef CONFIG_MEMORY_HOTREMOVE
 249
 250extern int is_mem_section_removable(unsigned long pfn, unsigned long nr_pages);
 251extern void try_offline_node(int nid);
 252extern int offline_pages(unsigned long start_pfn, unsigned long nr_pages);
 253extern void remove_memory(int nid, u64 start, u64 size);
 254
 255#else
 256static inline int is_mem_section_removable(unsigned long pfn,
 257                                        unsigned long nr_pages)
 258{
 259        return 0;
 260}
 261
 262static inline void try_offline_node(int nid) {}
 263
 264static inline int offline_pages(unsigned long start_pfn, unsigned long nr_pages)
 265{
 266        return -EINVAL;
 267}
 268
 269static inline void remove_memory(int nid, u64 start, u64 size) {}
 270#endif /* CONFIG_MEMORY_HOTREMOVE */
 271
 272extern int walk_memory_range(unsigned long start_pfn, unsigned long end_pfn,
 273                void *arg, int (*func)(struct memory_block *, void *));
 274extern int add_memory(int nid, u64 start, u64 size);
 275extern int add_memory_resource(int nid, struct resource *resource, bool online);
 276extern int zone_for_memory(int nid, u64 start, u64 size, int zone_default,
 277                bool for_device);
 278extern int arch_add_memory(int nid, u64 start, u64 size, bool for_device);
 279extern int offline_pages(unsigned long start_pfn, unsigned long nr_pages);
 280extern bool is_memblock_offlined(struct memory_block *mem);
 281extern void remove_memory(int nid, u64 start, u64 size);
 282extern int sparse_add_one_section(struct zone *zone, unsigned long start_pfn);
 283extern void sparse_remove_one_section(struct zone *zone, struct mem_section *ms,
 284                unsigned long map_offset);
 285extern struct page *sparse_decode_mem_map(unsigned long coded_mem_map,
 286                                          unsigned long pnum);
 287
 288#endif /* __LINUX_MEMORY_HOTPLUG_H */
 289