xref: /openbmc/linux/drivers/base/memory.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
1 /*
2  * drivers/base/memory.c - basic Memory class support
3  *
4  * Written by Matt Tolentino <matthew.e.tolentino@intel.com>
5  *            Dave Hansen <haveblue@us.ibm.com>
6  *
7  * This file provides the necessary infrastructure to represent
8  * a SPARSEMEM-memory-model system's physical memory in /sysfs.
9  * All arch-independent code that assumes MEMORY_HOTPLUG requires
10  * SPARSEMEM should be contained here, or in mm/memory_hotplug.c.
11  */
12 
13 #include <linux/sysdev.h>
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/sched.h>	/* capable() */
17 #include <linux/topology.h>
18 #include <linux/device.h>
19 #include <linux/memory.h>
20 #include <linux/kobject.h>
21 #include <linux/memory_hotplug.h>
22 #include <linux/mm.h>
23 #include <asm/atomic.h>
24 #include <asm/uaccess.h>
25 
26 #define MEMORY_CLASS_NAME	"memory"
27 
28 static struct sysdev_class memory_sysdev_class = {
29 	set_kset_name(MEMORY_CLASS_NAME),
30 };
31 EXPORT_SYMBOL(memory_sysdev_class);
32 
33 static char *memory_hotplug_name(struct kset *kset, struct kobject *kobj)
34 {
35 	return MEMORY_CLASS_NAME;
36 }
37 
38 static int memory_hotplug(struct kset *kset, struct kobject *kobj, char **envp,
39 			int num_envp, char *buffer, int buffer_size)
40 {
41 	int retval = 0;
42 
43 	return retval;
44 }
45 
46 static struct kset_hotplug_ops memory_hotplug_ops = {
47 	.name		= memory_hotplug_name,
48 	.hotplug	= memory_hotplug,
49 };
50 
51 static struct notifier_block *memory_chain;
52 
53 static int register_memory_notifier(struct notifier_block *nb)
54 {
55         return notifier_chain_register(&memory_chain, nb);
56 }
57 
58 static void unregister_memory_notifier(struct notifier_block *nb)
59 {
60         notifier_chain_unregister(&memory_chain, nb);
61 }
62 
63 /*
64  * register_memory - Setup a sysfs device for a memory block
65  */
66 static int
67 register_memory(struct memory_block *memory, struct mem_section *section,
68 		struct node *root)
69 {
70 	int error;
71 
72 	memory->sysdev.cls = &memory_sysdev_class;
73 	memory->sysdev.id = __section_nr(section);
74 
75 	error = sysdev_register(&memory->sysdev);
76 
77 	if (root && !error)
78 		error = sysfs_create_link(&root->sysdev.kobj,
79 					  &memory->sysdev.kobj,
80 					  kobject_name(&memory->sysdev.kobj));
81 
82 	return error;
83 }
84 
85 static void
86 unregister_memory(struct memory_block *memory, struct mem_section *section,
87 		struct node *root)
88 {
89 	BUG_ON(memory->sysdev.cls != &memory_sysdev_class);
90 	BUG_ON(memory->sysdev.id != __section_nr(section));
91 
92 	sysdev_unregister(&memory->sysdev);
93 	if (root)
94 		sysfs_remove_link(&root->sysdev.kobj,
95 				  kobject_name(&memory->sysdev.kobj));
96 }
97 
98 /*
99  * use this as the physical section index that this memsection
100  * uses.
101  */
102 
103 static ssize_t show_mem_phys_index(struct sys_device *dev, char *buf)
104 {
105 	struct memory_block *mem =
106 		container_of(dev, struct memory_block, sysdev);
107 	return sprintf(buf, "%08lx\n", mem->phys_index);
108 }
109 
110 /*
111  * online, offline, going offline, etc.
112  */
113 static ssize_t show_mem_state(struct sys_device *dev, char *buf)
114 {
115 	struct memory_block *mem =
116 		container_of(dev, struct memory_block, sysdev);
117 	ssize_t len = 0;
118 
119 	/*
120 	 * We can probably put these states in a nice little array
121 	 * so that they're not open-coded
122 	 */
123 	switch (mem->state) {
124 		case MEM_ONLINE:
125 			len = sprintf(buf, "online\n");
126 			break;
127 		case MEM_OFFLINE:
128 			len = sprintf(buf, "offline\n");
129 			break;
130 		case MEM_GOING_OFFLINE:
131 			len = sprintf(buf, "going-offline\n");
132 			break;
133 		default:
134 			len = sprintf(buf, "ERROR-UNKNOWN-%ld\n",
135 					mem->state);
136 			WARN_ON(1);
137 			break;
138 	}
139 
140 	return len;
141 }
142 
143 static inline int memory_notify(unsigned long val, void *v)
144 {
145 	return notifier_call_chain(&memory_chain, val, v);
146 }
147 
148 /*
149  * MEMORY_HOTPLUG depends on SPARSEMEM in mm/Kconfig, so it is
150  * OK to have direct references to sparsemem variables in here.
151  */
152 static int
153 memory_block_action(struct memory_block *mem, unsigned long action)
154 {
155 	int i;
156 	unsigned long psection;
157 	unsigned long start_pfn, start_paddr;
158 	struct page *first_page;
159 	int ret;
160 	int old_state = mem->state;
161 
162 	psection = mem->phys_index;
163 	first_page = pfn_to_page(psection << PFN_SECTION_SHIFT);
164 
165 	/*
166 	 * The probe routines leave the pages reserved, just
167 	 * as the bootmem code does.  Make sure they're still
168 	 * that way.
169 	 */
170 	if (action == MEM_ONLINE) {
171 		for (i = 0; i < PAGES_PER_SECTION; i++) {
172 			if (PageReserved(first_page+i))
173 				continue;
174 
175 			printk(KERN_WARNING "section number %ld page number %d "
176 				"not reserved, was it already online? \n",
177 				psection, i);
178 			return -EBUSY;
179 		}
180 	}
181 
182 	switch (action) {
183 		case MEM_ONLINE:
184 			start_pfn = page_to_pfn(first_page);
185 			ret = online_pages(start_pfn, PAGES_PER_SECTION);
186 			break;
187 		case MEM_OFFLINE:
188 			mem->state = MEM_GOING_OFFLINE;
189 			memory_notify(MEM_GOING_OFFLINE, NULL);
190 			start_paddr = page_to_pfn(first_page) << PAGE_SHIFT;
191 			ret = remove_memory(start_paddr,
192 					    PAGES_PER_SECTION << PAGE_SHIFT);
193 			if (ret) {
194 				mem->state = old_state;
195 				break;
196 			}
197 			memory_notify(MEM_MAPPING_INVALID, NULL);
198 			break;
199 		default:
200 			printk(KERN_WARNING "%s(%p, %ld) unknown action: %ld\n",
201 					__FUNCTION__, mem, action, action);
202 			WARN_ON(1);
203 			ret = -EINVAL;
204 	}
205 	/*
206 	 * For now, only notify on successful memory operations
207 	 */
208 	if (!ret)
209 		memory_notify(action, NULL);
210 
211 	return ret;
212 }
213 
214 static int memory_block_change_state(struct memory_block *mem,
215 		unsigned long to_state, unsigned long from_state_req)
216 {
217 	int ret = 0;
218 	down(&mem->state_sem);
219 
220 	if (mem->state != from_state_req) {
221 		ret = -EINVAL;
222 		goto out;
223 	}
224 
225 	ret = memory_block_action(mem, to_state);
226 	if (!ret)
227 		mem->state = to_state;
228 
229 out:
230 	up(&mem->state_sem);
231 	return ret;
232 }
233 
234 static ssize_t
235 store_mem_state(struct sys_device *dev, const char *buf, size_t count)
236 {
237 	struct memory_block *mem;
238 	unsigned int phys_section_nr;
239 	int ret = -EINVAL;
240 
241 	mem = container_of(dev, struct memory_block, sysdev);
242 	phys_section_nr = mem->phys_index;
243 
244 	if (!valid_section_nr(phys_section_nr))
245 		goto out;
246 
247 	if (!strncmp(buf, "online", min((int)count, 6)))
248 		ret = memory_block_change_state(mem, MEM_ONLINE, MEM_OFFLINE);
249 	else if(!strncmp(buf, "offline", min((int)count, 7)))
250 		ret = memory_block_change_state(mem, MEM_OFFLINE, MEM_ONLINE);
251 out:
252 	if (ret)
253 		return ret;
254 	return count;
255 }
256 
257 /*
258  * phys_device is a bad name for this.  What I really want
259  * is a way to differentiate between memory ranges that
260  * are part of physical devices that constitute
261  * a complete removable unit or fru.
262  * i.e. do these ranges belong to the same physical device,
263  * s.t. if I offline all of these sections I can then
264  * remove the physical device?
265  */
266 static ssize_t show_phys_device(struct sys_device *dev, char *buf)
267 {
268 	struct memory_block *mem =
269 		container_of(dev, struct memory_block, sysdev);
270 	return sprintf(buf, "%d\n", mem->phys_device);
271 }
272 
273 static SYSDEV_ATTR(phys_index, 0444, show_mem_phys_index, NULL);
274 static SYSDEV_ATTR(state, 0644, show_mem_state, store_mem_state);
275 static SYSDEV_ATTR(phys_device, 0444, show_phys_device, NULL);
276 
277 #define mem_create_simple_file(mem, attr_name)	\
278 	sysdev_create_file(&mem->sysdev, &attr_##attr_name)
279 #define mem_remove_simple_file(mem, attr_name)	\
280 	sysdev_remove_file(&mem->sysdev, &attr_##attr_name)
281 
282 /*
283  * Block size attribute stuff
284  */
285 static ssize_t
286 print_block_size(struct class *class, char *buf)
287 {
288 	return sprintf(buf, "%lx\n", (unsigned long)PAGES_PER_SECTION * PAGE_SIZE);
289 }
290 
291 static CLASS_ATTR(block_size_bytes, 0444, print_block_size, NULL);
292 
293 static int block_size_init(void)
294 {
295 	sysfs_create_file(&memory_sysdev_class.kset.kobj,
296 		&class_attr_block_size_bytes.attr);
297 	return 0;
298 }
299 
300 /*
301  * Some architectures will have custom drivers to do this, and
302  * will not need to do it from userspace.  The fake hot-add code
303  * as well as ppc64 will do all of their discovery in userspace
304  * and will require this interface.
305  */
306 #ifdef CONFIG_ARCH_MEMORY_PROBE
307 static ssize_t
308 memory_probe_store(struct class *class, const char __user *buf, size_t count)
309 {
310 	u64 phys_addr;
311 	int ret;
312 
313 	phys_addr = simple_strtoull(buf, NULL, 0);
314 
315 	ret = add_memory(phys_addr, PAGES_PER_SECTION << PAGE_SHIFT);
316 
317 	if (ret)
318 		count = ret;
319 
320 	return count;
321 }
322 static CLASS_ATTR(probe, 0700, NULL, memory_probe_store);
323 
324 static int memory_probe_init(void)
325 {
326 	sysfs_create_file(&memory_sysdev_class.kset.kobj,
327 		&class_attr_probe.attr);
328 	return 0;
329 }
330 #else
331 #define memory_probe_init(...)	do {} while (0)
332 #endif
333 
334 /*
335  * Note that phys_device is optional.  It is here to allow for
336  * differentiation between which *physical* devices each
337  * section belongs to...
338  */
339 
340 static int add_memory_block(unsigned long node_id, struct mem_section *section,
341 		     unsigned long state, int phys_device)
342 {
343 	struct memory_block *mem = kzalloc(sizeof(*mem), GFP_KERNEL);
344 	int ret = 0;
345 
346 	if (!mem)
347 		return -ENOMEM;
348 
349 	mem->phys_index = __section_nr(section);
350 	mem->state = state;
351 	init_MUTEX(&mem->state_sem);
352 	mem->phys_device = phys_device;
353 
354 	ret = register_memory(mem, section, NULL);
355 	if (!ret)
356 		ret = mem_create_simple_file(mem, phys_index);
357 	if (!ret)
358 		ret = mem_create_simple_file(mem, state);
359 	if (!ret)
360 		ret = mem_create_simple_file(mem, phys_device);
361 
362 	return ret;
363 }
364 
365 /*
366  * For now, we have a linear search to go find the appropriate
367  * memory_block corresponding to a particular phys_index. If
368  * this gets to be a real problem, we can always use a radix
369  * tree or something here.
370  *
371  * This could be made generic for all sysdev classes.
372  */
373 static struct memory_block *find_memory_block(struct mem_section *section)
374 {
375 	struct kobject *kobj;
376 	struct sys_device *sysdev;
377 	struct memory_block *mem;
378 	char name[sizeof(MEMORY_CLASS_NAME) + 9 + 1];
379 
380 	/*
381 	 * This only works because we know that section == sysdev->id
382 	 * slightly redundant with sysdev_register()
383 	 */
384 	sprintf(&name[0], "%s%d", MEMORY_CLASS_NAME, __section_nr(section));
385 
386 	kobj = kset_find_obj(&memory_sysdev_class.kset, name);
387 	if (!kobj)
388 		return NULL;
389 
390 	sysdev = container_of(kobj, struct sys_device, kobj);
391 	mem = container_of(sysdev, struct memory_block, sysdev);
392 
393 	return mem;
394 }
395 
396 int remove_memory_block(unsigned long node_id, struct mem_section *section,
397 		int phys_device)
398 {
399 	struct memory_block *mem;
400 
401 	mem = find_memory_block(section);
402 	mem_remove_simple_file(mem, phys_index);
403 	mem_remove_simple_file(mem, state);
404 	mem_remove_simple_file(mem, phys_device);
405 	unregister_memory(mem, section, NULL);
406 
407 	return 0;
408 }
409 
410 /*
411  * need an interface for the VM to add new memory regions,
412  * but without onlining it.
413  */
414 int register_new_memory(struct mem_section *section)
415 {
416 	return add_memory_block(0, section, MEM_OFFLINE, 0);
417 }
418 
419 int unregister_memory_section(struct mem_section *section)
420 {
421 	if (!valid_section(section))
422 		return -EINVAL;
423 
424 	return remove_memory_block(0, section, 0);
425 }
426 
427 /*
428  * Initialize the sysfs support for memory devices...
429  */
430 int __init memory_dev_init(void)
431 {
432 	unsigned int i;
433 	int ret;
434 
435 	memory_sysdev_class.kset.hotplug_ops = &memory_hotplug_ops;
436 	ret = sysdev_class_register(&memory_sysdev_class);
437 
438 	/*
439 	 * Create entries for memory sections that were found
440 	 * during boot and have been initialized
441 	 */
442 	for (i = 0; i < NR_MEM_SECTIONS; i++) {
443 		if (!valid_section_nr(i))
444 			continue;
445 		add_memory_block(0, __nr_to_section(i), MEM_ONLINE, 0);
446 	}
447 
448 	memory_probe_init();
449 	block_size_init();
450 
451 	return ret;
452 }
453