Line data    Source code

       1             : /* SPDX-License-Identifier: GPL-2.0 */
       2             : /*
       3             :  * include/linux/memory.h - generic memory definition
       4             :  *
       5             :  * This is mainly for topological representation. We define the
       6             :  * basic "struct memory_block" here, which can be embedded in per-arch
       7             :  * definitions or NUMA information.
       8             :  *
       9             :  * Basic handling of the devices is done in drivers/base/memory.c
      10             :  * and system devices are handled in drivers/base/sys.c.
      11             :  *
      12             :  * Memory block are exported via sysfs in the class/memory/devices/
      13             :  * directory.
      14             :  *
      15             :  */
      16             : #ifndef _LINUX_MEMORY_H_
      17             : #define _LINUX_MEMORY_H_
      18             : 
      19             : #include <linux/node.h>
      20             : #include <linux/compiler.h>
      21             : #include <linux/mutex.h>
      22             : #include <linux/notifier.h>
      23             : 
      24             : #define MIN_MEMORY_BLOCK_SIZE     (1UL << SECTION_SIZE_BITS)
      25             : 
      26             : struct memory_block {
      27             :         unsigned long start_section_nr;
      28             :         unsigned long state;            /* serialized by the dev->lock */
      29             :         int online_type;                /* for passing data to online routine */
      30             :         int nid;                        /* NID for this memory block */
      31             :         struct device dev;
      32             : };
      33             : 
      34             : int arch_get_memory_phys_device(unsigned long start_pfn);
      35             : unsigned long memory_block_size_bytes(void);
      36             : int set_memory_block_size_order(unsigned int order);
      37             : 
      38             : /* These states are exposed to userspace as text strings in sysfs */
      39             : #define MEM_ONLINE              (1<<0) /* exposed to userspace */
      40             : #define MEM_GOING_OFFLINE       (1<<1) /* exposed to userspace */
      41             : #define MEM_OFFLINE             (1<<2) /* exposed to userspace */
      42             : #define MEM_GOING_ONLINE        (1<<3)
      43             : #define MEM_CANCEL_ONLINE       (1<<4)
      44             : #define MEM_CANCEL_OFFLINE      (1<<5)
      45             : 
      46             : struct memory_notify {
      47             :         unsigned long start_pfn;
      48             :         unsigned long nr_pages;
      49             :         int status_change_nid_normal;
      50             :         int status_change_nid_high;
      51             :         int status_change_nid;
      52             : };
      53             : 
      54             : struct notifier_block;
      55             : struct mem_section;
      56             : 
      57             : /*
      58             :  * Priorities for the hotplug memory callback routines (stored in decreasing
      59             :  * order in the callback chain)
      60             :  */
      61             : #define SLAB_CALLBACK_PRI       1
      62             : #define IPC_CALLBACK_PRI        10
      63             : 
      64             : #ifndef CONFIG_MEMORY_HOTPLUG_SPARSE
      65           1 : static inline void memory_dev_init(void)
      66             : {
      67           1 :         return;
      68             : }
      69             : static inline int register_memory_notifier(struct notifier_block *nb)
      70             : {
      71             :         return 0;
      72             : }
      73             : static inline void unregister_memory_notifier(struct notifier_block *nb)
      74             : {
      75             : }
      76             : static inline int memory_notify(unsigned long val, void *v)
      77             : {
      78             :         return 0;
      79             : }
      80             : #else
      81             : extern int register_memory_notifier(struct notifier_block *nb);
      82             : extern void unregister_memory_notifier(struct notifier_block *nb);
      83             : int create_memory_block_devices(unsigned long start, unsigned long size);
      84             : void remove_memory_block_devices(unsigned long start, unsigned long size);
      85             : extern void memory_dev_init(void);
      86             : extern int memory_notify(unsigned long val, void *v);
      87             : extern struct memory_block *find_memory_block(struct mem_section *);
      88             : typedef int (*walk_memory_blocks_func_t)(struct memory_block *, void *);
      89             : extern int walk_memory_blocks(unsigned long start, unsigned long size,
      90             :                               void *arg, walk_memory_blocks_func_t func);
      91             : extern int for_each_memory_block(void *arg, walk_memory_blocks_func_t func);
      92             : #define CONFIG_MEM_BLOCK_SIZE   (PAGES_PER_SECTION<<PAGE_SHIFT)
      93             : #endif /* CONFIG_MEMORY_HOTPLUG_SPARSE */
      94             : 
      95             : #ifdef CONFIG_MEMORY_HOTPLUG
      96             : #define hotplug_memory_notifier(fn, pri) ({             \
      97             :         static __meminitdata struct notifier_block fn##_mem_nb =\
      98             :                 { .notifier_call = fn, .priority = pri };\
      99             :         register_memory_notifier(&fn##_mem_nb);                     \
     100             : })
     101             : #define register_hotmemory_notifier(nb)         register_memory_notifier(nb)
     102             : #define unregister_hotmemory_notifier(nb)       unregister_memory_notifier(nb)
     103             : #else
     104             : #define hotplug_memory_notifier(fn, pri)        ({ 0; })
     105             : /* These aren't inline functions due to a GCC bug. */
     106             : #define register_hotmemory_notifier(nb)    ({ (void)(nb); 0; })
     107             : #define unregister_hotmemory_notifier(nb)  ({ (void)(nb); })
     108             : #endif
     109             : 
     110             : /*
     111             :  * Kernel text modification mutex, used for code patching. Users of this lock
     112             :  * can sleep.
     113             :  */
     114             : extern struct mutex text_mutex;
     115             : 
     116             : #endif /* _LINUX_MEMORY_H_ */