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/topology.h> 17 #include <linux/capability.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 32 static const char *memory_uevent_name(struct kset *kset, struct kobject *kobj) 33 { 34 return MEMORY_CLASS_NAME; 35 } 36 37 static int memory_uevent(struct kset *kset, struct kobject *kobj, char **envp, 38 int num_envp, char *buffer, int buffer_size) 39 { 40 int retval = 0; 41 42 return retval; 43 } 44 45 static struct kset_uevent_ops memory_uevent_ops = { 46 .name = memory_uevent_name, 47 .uevent = memory_uevent, 48 }; 49 50 static BLOCKING_NOTIFIER_HEAD(memory_chain); 51 52 int register_memory_notifier(struct notifier_block *nb) 53 { 54 return blocking_notifier_chain_register(&memory_chain, nb); 55 } 56 57 void unregister_memory_notifier(struct notifier_block *nb) 58 { 59 blocking_notifier_chain_unregister(&memory_chain, nb); 60 } 61 62 /* 63 * register_memory - Setup a sysfs device for a memory block 64 */ 65 int register_memory(struct memory_block *memory, struct mem_section *section, 66 struct node *root) 67 { 68 int error; 69 70 memory->sysdev.cls = &memory_sysdev_class; 71 memory->sysdev.id = __section_nr(section); 72 73 error = sysdev_register(&memory->sysdev); 74 75 if (root && !error) 76 error = sysfs_create_link(&root->sysdev.kobj, 77 &memory->sysdev.kobj, 78 kobject_name(&memory->sysdev.kobj)); 79 80 return error; 81 } 82 83 static void 84 unregister_memory(struct memory_block *memory, struct mem_section *section, 85 struct node *root) 86 { 87 BUG_ON(memory->sysdev.cls != &memory_sysdev_class); 88 BUG_ON(memory->sysdev.id != __section_nr(section)); 89 90 sysdev_unregister(&memory->sysdev); 91 if (root) 92 sysfs_remove_link(&root->sysdev.kobj, 93 kobject_name(&memory->sysdev.kobj)); 94 } 95 96 /* 97 * use this as the physical section index that this memsection 98 * uses. 99 */ 100 101 static ssize_t show_mem_phys_index(struct sys_device *dev, char *buf) 102 { 103 struct memory_block *mem = 104 container_of(dev, struct memory_block, sysdev); 105 return sprintf(buf, "%08lx\n", mem->phys_index); 106 } 107 108 /* 109 * online, offline, going offline, etc. 110 */ 111 static ssize_t show_mem_state(struct sys_device *dev, char *buf) 112 { 113 struct memory_block *mem = 114 container_of(dev, struct memory_block, sysdev); 115 ssize_t len = 0; 116 117 /* 118 * We can probably put these states in a nice little array 119 * so that they're not open-coded 120 */ 121 switch (mem->state) { 122 case MEM_ONLINE: 123 len = sprintf(buf, "online\n"); 124 break; 125 case MEM_OFFLINE: 126 len = sprintf(buf, "offline\n"); 127 break; 128 case MEM_GOING_OFFLINE: 129 len = sprintf(buf, "going-offline\n"); 130 break; 131 default: 132 len = sprintf(buf, "ERROR-UNKNOWN-%ld\n", 133 mem->state); 134 WARN_ON(1); 135 break; 136 } 137 138 return len; 139 } 140 141 static inline int memory_notify(unsigned long val, void *v) 142 { 143 return blocking_notifier_call_chain(&memory_chain, val, v); 144 } 145 146 /* 147 * MEMORY_HOTPLUG depends on SPARSEMEM in mm/Kconfig, so it is 148 * OK to have direct references to sparsemem variables in here. 149 */ 150 static int 151 memory_block_action(struct memory_block *mem, unsigned long action) 152 { 153 int i; 154 unsigned long psection; 155 unsigned long start_pfn, start_paddr; 156 struct page *first_page; 157 int ret; 158 int old_state = mem->state; 159 160 psection = mem->phys_index; 161 first_page = pfn_to_page(psection << PFN_SECTION_SHIFT); 162 163 /* 164 * The probe routines leave the pages reserved, just 165 * as the bootmem code does. Make sure they're still 166 * that way. 167 */ 168 if (action == MEM_ONLINE) { 169 for (i = 0; i < PAGES_PER_SECTION; i++) { 170 if (PageReserved(first_page+i)) 171 continue; 172 173 printk(KERN_WARNING "section number %ld page number %d " 174 "not reserved, was it already online? \n", 175 psection, i); 176 return -EBUSY; 177 } 178 } 179 180 switch (action) { 181 case MEM_ONLINE: 182 start_pfn = page_to_pfn(first_page); 183 ret = online_pages(start_pfn, PAGES_PER_SECTION); 184 break; 185 case MEM_OFFLINE: 186 mem->state = MEM_GOING_OFFLINE; 187 memory_notify(MEM_GOING_OFFLINE, NULL); 188 start_paddr = page_to_pfn(first_page) << PAGE_SHIFT; 189 ret = remove_memory(start_paddr, 190 PAGES_PER_SECTION << PAGE_SHIFT); 191 if (ret) { 192 mem->state = old_state; 193 break; 194 } 195 memory_notify(MEM_MAPPING_INVALID, NULL); 196 break; 197 default: 198 printk(KERN_WARNING "%s(%p, %ld) unknown action: %ld\n", 199 __FUNCTION__, mem, action, action); 200 WARN_ON(1); 201 ret = -EINVAL; 202 } 203 /* 204 * For now, only notify on successful memory operations 205 */ 206 if (!ret) 207 memory_notify(action, NULL); 208 209 return ret; 210 } 211 212 static int memory_block_change_state(struct memory_block *mem, 213 unsigned long to_state, unsigned long from_state_req) 214 { 215 int ret = 0; 216 down(&mem->state_sem); 217 218 if (mem->state != from_state_req) { 219 ret = -EINVAL; 220 goto out; 221 } 222 223 ret = memory_block_action(mem, to_state); 224 if (!ret) 225 mem->state = to_state; 226 227 out: 228 up(&mem->state_sem); 229 return ret; 230 } 231 232 static ssize_t 233 store_mem_state(struct sys_device *dev, const char *buf, size_t count) 234 { 235 struct memory_block *mem; 236 unsigned int phys_section_nr; 237 int ret = -EINVAL; 238 239 mem = container_of(dev, struct memory_block, sysdev); 240 phys_section_nr = mem->phys_index; 241 242 if (!valid_section_nr(phys_section_nr)) 243 goto out; 244 245 if (!strncmp(buf, "online", min((int)count, 6))) 246 ret = memory_block_change_state(mem, MEM_ONLINE, MEM_OFFLINE); 247 else if(!strncmp(buf, "offline", min((int)count, 7))) 248 ret = memory_block_change_state(mem, MEM_OFFLINE, MEM_ONLINE); 249 out: 250 if (ret) 251 return ret; 252 return count; 253 } 254 255 /* 256 * phys_device is a bad name for this. What I really want 257 * is a way to differentiate between memory ranges that 258 * are part of physical devices that constitute 259 * a complete removable unit or fru. 260 * i.e. do these ranges belong to the same physical device, 261 * s.t. if I offline all of these sections I can then 262 * remove the physical device? 263 */ 264 static ssize_t show_phys_device(struct sys_device *dev, char *buf) 265 { 266 struct memory_block *mem = 267 container_of(dev, struct memory_block, sysdev); 268 return sprintf(buf, "%d\n", mem->phys_device); 269 } 270 271 static SYSDEV_ATTR(phys_index, 0444, show_mem_phys_index, NULL); 272 static SYSDEV_ATTR(state, 0644, show_mem_state, store_mem_state); 273 static SYSDEV_ATTR(phys_device, 0444, show_phys_device, NULL); 274 275 #define mem_create_simple_file(mem, attr_name) \ 276 sysdev_create_file(&mem->sysdev, &attr_##attr_name) 277 #define mem_remove_simple_file(mem, attr_name) \ 278 sysdev_remove_file(&mem->sysdev, &attr_##attr_name) 279 280 /* 281 * Block size attribute stuff 282 */ 283 static ssize_t 284 print_block_size(struct class *class, char *buf) 285 { 286 return sprintf(buf, "%lx\n", (unsigned long)PAGES_PER_SECTION * PAGE_SIZE); 287 } 288 289 static CLASS_ATTR(block_size_bytes, 0444, print_block_size, NULL); 290 291 static int block_size_init(void) 292 { 293 sysfs_create_file(&memory_sysdev_class.kset.kobj, 294 &class_attr_block_size_bytes.attr); 295 return 0; 296 } 297 298 /* 299 * Some architectures will have custom drivers to do this, and 300 * will not need to do it from userspace. The fake hot-add code 301 * as well as ppc64 will do all of their discovery in userspace 302 * and will require this interface. 303 */ 304 #ifdef CONFIG_ARCH_MEMORY_PROBE 305 static ssize_t 306 memory_probe_store(struct class *class, const char *buf, size_t count) 307 { 308 u64 phys_addr; 309 int nid; 310 int ret; 311 312 phys_addr = simple_strtoull(buf, NULL, 0); 313 314 nid = memory_add_physaddr_to_nid(phys_addr); 315 ret = add_memory(nid, 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.uevent_ops = &memory_uevent_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