memory.h 4.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156
  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. #include <linux/node.h>
  18. #include <linux/compiler.h>
  19. #include <linux/mutex.h>
  20. #define MIN_MEMORY_BLOCK_SIZE (1UL << SECTION_SIZE_BITS)
  21. struct memory_block {
  22. unsigned long start_section_nr;
  23. unsigned long end_section_nr;
  24. unsigned long state;
  25. int section_count;
  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 device dev;
  37. };
  38. int arch_get_memory_phys_device(unsigned long start_pfn);
  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. 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. * During pageblock isolation, count the number of pages within the
  55. * range [start_pfn, start_pfn + nr_pages) which are owned by code
  56. * in the notifier chain.
  57. */
  58. #define MEM_ISOLATE_COUNT (1<<0)
  59. struct memory_isolate_notify {
  60. unsigned long start_pfn; /* Start of range to check */
  61. unsigned int nr_pages; /* # pages in range to check */
  62. unsigned int pages_found; /* # pages owned found by callbacks */
  63. };
  64. struct notifier_block;
  65. struct mem_section;
  66. /*
  67. * Priorities for the hotplug memory callback routines (stored in decreasing
  68. * order in the callback chain)
  69. */
  70. #define SLAB_CALLBACK_PRI 1
  71. #define IPC_CALLBACK_PRI 10
  72. #ifndef CONFIG_MEMORY_HOTPLUG_SPARSE
  73. static inline int memory_dev_init(void)
  74. {
  75. return 0;
  76. }
  77. static inline int register_memory_notifier(struct notifier_block *nb)
  78. {
  79. return 0;
  80. }
  81. static inline void unregister_memory_notifier(struct notifier_block *nb)
  82. {
  83. }
  84. static inline int memory_notify(unsigned long val, void *v)
  85. {
  86. return 0;
  87. }
  88. static inline int register_memory_isolate_notifier(struct notifier_block *nb)
  89. {
  90. return 0;
  91. }
  92. static inline void unregister_memory_isolate_notifier(struct notifier_block *nb)
  93. {
  94. }
  95. static inline int memory_isolate_notify(unsigned long val, void *v)
  96. {
  97. return 0;
  98. }
  99. #else
  100. extern int register_memory_notifier(struct notifier_block *nb);
  101. extern void unregister_memory_notifier(struct notifier_block *nb);
  102. extern int register_memory_isolate_notifier(struct notifier_block *nb);
  103. extern void unregister_memory_isolate_notifier(struct notifier_block *nb);
  104. extern int register_new_memory(int, struct mem_section *);
  105. extern int unregister_memory_section(struct mem_section *);
  106. extern int memory_dev_init(void);
  107. extern int remove_memory_block(unsigned long, struct mem_section *, int);
  108. extern int memory_notify(unsigned long val, void *v);
  109. extern int memory_isolate_notify(unsigned long val, void *v);
  110. extern struct memory_block *find_memory_block_hinted(struct mem_section *,
  111. struct memory_block *);
  112. extern struct memory_block *find_memory_block(struct mem_section *);
  113. #define CONFIG_MEM_BLOCK_SIZE (PAGES_PER_SECTION<<PAGE_SHIFT)
  114. enum mem_add_context { BOOT, HOTPLUG };
  115. #endif /* CONFIG_MEMORY_HOTPLUG_SPARSE */
  116. #ifdef CONFIG_MEMORY_HOTPLUG
  117. #define hotplug_memory_notifier(fn, pri) { \
  118. static __meminitdata struct notifier_block fn##_mem_nb =\
  119. { .notifier_call = fn, .priority = pri }; \
  120. register_memory_notifier(&fn##_mem_nb); \
  121. }
  122. #else
  123. #define hotplug_memory_notifier(fn, pri) do { } while (0)
  124. #endif
  125. /*
  126. * 'struct memory_accessor' is a generic interface to provide
  127. * in-kernel access to persistent memory such as i2c or SPI EEPROMs
  128. */
  129. struct memory_accessor {
  130. ssize_t (*read)(struct memory_accessor *, char *buf, off_t offset,
  131. size_t count);
  132. ssize_t (*write)(struct memory_accessor *, const char *buf,
  133. off_t offset, size_t count);
  134. };
  135. /*
  136. * Kernel text modification mutex, used for code patching. Users of this lock
  137. * can sleep.
  138. */
  139. extern struct mutex text_mutex;
  140. #endif /* _LINUX_MEMORY_H_ */