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