1 /*

     2  * include/linux/memory.h - generic memory definition

     3  *

     4  * This is mainly for topological representation. We define the

     5  * basic "struct memory_block" here, which can be embedded in per-arch

     6  * definitions or NUMA information.

     7  *

     8  * Basic handling of the devices is done in drivers/base/memory.c

     9  * and system devices are handled in drivers/base/sys.c.

    10  *

    11  * Memory block are exported via sysfs in the class/memory/devices/

    12  * directory.

    13  *

    14  */

    15 #ifndef _LINUX_MEMORY_H_

    16 #define _LINUX_MEMORY_H_

    17 

    18 #include <linux/sysdev.h>

    19 #include <linux/node.h>

    20 #include <linux/compiler.h>

    21 #include <linux/mutex.h>

    22 

    23 struct memory_block {

    24 	unsigned long phys_index;

    25 	unsigned long state;

    26 	/*

    27 	 * This serializes all state change requests.  It isn't

    28 	 * held during creation because the control files are

    29 	 * created long after the critical areas during

    30 	 * initialization.

    31 	 */

    32 	struct mutex state_mutex;

    33 	int phys_device;		/* to which fru does this belong? */

    34 	void *hw;			/* optional pointer to fw/hw data */

    35 	int (*phys_callback)(struct memory_block *);

    36 	struct sys_device sysdev;

    37 };

    38 

    39 /* These states are exposed to userspace as text strings in sysfs */

    40 #define	MEM_ONLINE		(1<<0) /* exposed to userspace */

    41 #define	MEM_GOING_OFFLINE	(1<<1) /* exposed to userspace */

    42 #define	MEM_OFFLINE		(1<<2) /* exposed to userspace */

    43 #define	MEM_GOING_ONLINE	(1<<3)

    44 #define	MEM_CANCEL_ONLINE	(1<<4)

    45 #define	MEM_CANCEL_OFFLINE	(1<<5)

    46 

    47 struct memory_notify {

    48 	unsigned long start_pfn;

    49 	unsigned long nr_pages;

    50 	int status_change_nid;

    51 };

    52 

    53 struct notifier_block;

    54 struct mem_section;

    55 

    56 /*

    57  * Priorities for the hotplug memory callback routines (stored in decreasing

    58  * order in the callback chain)

    59  */

    60 #define SLAB_CALLBACK_PRI       1

    61 #define IPC_CALLBACK_PRI        10

    62 

    63 #ifndef CONFIG_MEMORY_HOTPLUG_SPARSE

    64 static inline int memory_dev_init(void)

    65 {

    66 	return 0;

    67 }

    68 static inline int register_memory_notifier(struct notifier_block *nb)

    69 {

    70 	return 0;

    71 }

    72 static inline void unregister_memory_notifier(struct notifier_block *nb)

    73 {

    74 }

    75 static inline int memory_notify(unsigned long val, void *v)

    76 {

    77 	return 0;

    78 }

    79 #else

    80 extern int register_memory_notifier(struct notifier_block *nb);

    81 extern void unregister_memory_notifier(struct notifier_block *nb);

    82 extern int register_new_memory(struct mem_section *);

    83 extern int unregister_memory_section(struct mem_section *);

    84 extern int memory_dev_init(void);

    85 extern int remove_memory_block(unsigned long, struct mem_section *, int);

    86 extern int memory_notify(unsigned long val, void *v);

    87 #define CONFIG_MEM_BLOCK_SIZE	(PAGES_PER_SECTION<<PAGE_SHIFT)

    88 

    89 

    90 #endif /* CONFIG_MEMORY_HOTPLUG_SPARSE */

    91 

    92 #ifdef CONFIG_MEMORY_HOTPLUG

    93 #define hotplug_memory_notifier(fn, pri) {			\

    94 	static __meminitdata struct notifier_block fn##_mem_nb =\

    95 		{ .notifier_call = fn, .priority = pri };	\

    96 	register_memory_notifier(&fn##_mem_nb);			\

    97 }

    98 #else

    99 #define hotplug_memory_notifier(fn, pri) do { } while (0)

   100 #endif

   101 

   102 #endif /* _LINUX_MEMORY_H_ */