drivers/base/memory.c

   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 <linux/mutex.h>
  24 #include <linux/stat.h>
  25 #include <linux/slab.h>
  26
  27 #include <asm/atomic.h>
  28 #include <asm/uaccess.h>
  29
  30 #define MEMORY_CLASS_NAME       "memory"
  31
  32 static struct sysdev_class memory_sysdev_class = {
  33         .name = MEMORY_CLASS_NAME,
  34 };
  35
  36 static const char *memory_uevent_name(struct kset *kset, struct kobject *kobj)
  37 {
  38         return MEMORY_CLASS_NAME;
  39 }
  40
  41 static int memory_uevent(struct kset *kset, struct kobject *obj, struct kobj_uevent_env *env)
  42 {
  43         int retval = 0;
  44
  45         return retval;
  46 }
  47
  48 static const struct kset_uevent_ops memory_uevent_ops = {
  49         .name           = memory_uevent_name,
  50         .uevent         = memory_uevent,
  51 };
  52
  53 static BLOCKING_NOTIFIER_HEAD(memory_chain);
  54
  55 int register_memory_notifier(struct notifier_block *nb)
  56 {
  57         return blocking_notifier_chain_register(&memory_chain, nb);
  58 }
  59 EXPORT_SYMBOL(register_memory_notifier);
  60
  61 void unregister_memory_notifier(struct notifier_block *nb)
  62 {
  63         blocking_notifier_chain_unregister(&memory_chain, nb);
  64 }
  65 EXPORT_SYMBOL(unregister_memory_notifier);
  66
  67 static ATOMIC_NOTIFIER_HEAD(memory_isolate_chain);
  68
  69 int register_memory_isolate_notifier(struct notifier_block *nb)
  70 {
  71         return atomic_notifier_chain_register(&memory_isolate_chain, nb);
  72 }
  73 EXPORT_SYMBOL(register_memory_isolate_notifier);
  74
  75 void unregister_memory_isolate_notifier(struct notifier_block *nb)
  76 {
  77         atomic_notifier_chain_unregister(&memory_isolate_chain, nb);
  78 }
  79 EXPORT_SYMBOL(unregister_memory_isolate_notifier);
  80
  81 /*
  82  * register_memory - Setup a sysfs device for a memory block
  83  */
  84 static
  85 int register_memory(struct memory_block *memory, struct mem_section *section)
  86 {
  87         int error;
  88
  89         memory->sysdev.cls = &memory_sysdev_class;
  90         memory->sysdev.id = __section_nr(section);
  91
  92         error = sysdev_register(&memory->sysdev);
  93         return error;
  94 }
  95
  96 static void
  97 unregister_memory(struct memory_block *memory, struct mem_section *section)
  98 {
  99         BUG_ON(memory->sysdev.cls != &memory_sysdev_class);
 100         BUG_ON(memory->sysdev.id != __section_nr(section));
 101
 102         /* drop the ref. we got in remove_memory_block() */
 103         kobject_put(&memory->sysdev.kobj);
 104         sysdev_unregister(&memory->sysdev);
 105 }
 106
 107 /*
 108  * use this as the physical section index that this memsection
 109  * uses.
 110  */
 111
 112 static ssize_t show_mem_phys_index(struct sys_device *dev,
 113                         struct sysdev_attribute *attr, char *buf)
 114 {
 115         struct memory_block *mem =
 116                 container_of(dev, struct memory_block, sysdev);
 117         return sprintf(buf, "%08lx\n", mem->phys_index);
 118 }
 119
 120 /*
 121  * Show whether the section of memory is likely to be hot-removable
 122  */
 123 static ssize_t show_mem_removable(struct sys_device *dev,
 124                         struct sysdev_attribute *attr, char *buf)
 125 {
 126         unsigned long start_pfn;
 127         int ret;
 128         struct memory_block *mem =
 129                 container_of(dev, struct memory_block, sysdev);
 130
 131         start_pfn = section_nr_to_pfn(mem->phys_index);
 132         ret = is_mem_section_removable(start_pfn, PAGES_PER_SECTION);
 133         return sprintf(buf, "%d\n", ret);
 134 }
 135
 136 /*
 137  * online, offline, going offline, etc.
 138  */
 139 static ssize_t show_mem_state(struct sys_device *dev,
 140                         struct sysdev_attribute *attr, char *buf)
 141 {
 142         struct memory_block *mem =
 143                 container_of(dev, struct memory_block, sysdev);
 144         ssize_t len = 0;
 145
 146         /*
 147          * We can probably put these states in a nice little array
 148          * so that they're not open-coded
 149          */
 150         switch (mem->state) {
 151                 case MEM_ONLINE:
 152                         len = sprintf(buf, "online\n");
 153                         break;
 154                 case MEM_OFFLINE:
 155                         len = sprintf(buf, "offline\n");
 156                         break;
 157                 case MEM_GOING_OFFLINE:
 158                         len = sprintf(buf, "going-offline\n");
 159                         break;
 160                 default:
 161                         len = sprintf(buf, "ERROR-UNKNOWN-%ld\n",
 162                                         mem->state);
 163                         WARN_ON(1);
 164                         break;
 165         }
 166
 167         return len;
 168 }
 169
 170 int memory_notify(unsigned long val, void *v)
 171 {
 172         return blocking_notifier_call_chain(&memory_chain, val, v);
 173 }
 174
 175 int memory_isolate_notify(unsigned long val, void *v)
 176 {
 177         return atomic_notifier_call_chain(&memory_isolate_chain, val, v);
 178 }
 179
 180 /*
 181  * MEMORY_HOTPLUG depends on SPARSEMEM in mm/Kconfig, so it is
 182  * OK to have direct references to sparsemem variables in here.
 183  */
 184 static int
 185 memory_block_action(struct memory_block *mem, unsigned long action)
 186 {
 187         int i;
 188         unsigned long psection;
 189         unsigned long start_pfn, start_paddr;
 190         struct page *first_page;
 191         int ret;
 192         int old_state = mem->state;
 193
 194         psection = mem->phys_index;
 195         first_page = pfn_to_page(psection << PFN_SECTION_SHIFT);
 196
 197         /*
 198          * The probe routines leave the pages reserved, just
 199          * as the bootmem code does.  Make sure they're still
 200          * that way.
 201          */
 202         if (action == MEM_ONLINE) {
 203                 for (i = 0; i < PAGES_PER_SECTION; i++) {
 204                         if (PageReserved(first_page+i))
 205                                 continue;
 206
 207                         printk(KERN_WARNING "section number %ld page number %d "
 208                                 "not reserved, was it already online? \n",
 209                                 psection, i);
 210                         return -EBUSY;
 211                 }
 212         }
 213
 214         switch (action) {
 215                 case MEM_ONLINE:
 216                         start_pfn = page_to_pfn(first_page);
 217                         ret = online_pages(start_pfn, PAGES_PER_SECTION);
 218                         break;
 219                 case MEM_OFFLINE:
 220                         mem->state = MEM_GOING_OFFLINE;
 221                         start_paddr = page_to_pfn(first_page) << PAGE_SHIFT;
 222                         ret = remove_memory(start_paddr,
 223                                             PAGES_PER_SECTION << PAGE_SHIFT);
 224                         if (ret) {
 225                                 mem->state = old_state;
 226                                 break;
 227                         }
 228                         break;
 229                 default:
 230                         WARN(1, KERN_WARNING "%s(%p, %ld) unknown action: %ld\n",
 231                                         __func__, mem, action, action);
 232                         ret = -EINVAL;
 233         }
 234
 235         return ret;
 236 }
 237
 238 static int memory_block_change_state(struct memory_block *mem,
 239                 unsigned long to_state, unsigned long from_state_req)
 240 {
 241         int ret = 0;
 242         mutex_lock(&mem->state_mutex);
 243
 244         if (mem->state != from_state_req) {
 245                 ret = -EINVAL;
 246                 goto out;
 247         }
 248
 249         ret = memory_block_action(mem, to_state);
 250         if (!ret)
 251                 mem->state = to_state;
 252
 253 out:
 254         mutex_unlock(&mem->state_mutex);
 255         return ret;
 256 }
 257
 258 static ssize_t
 259 store_mem_state(struct sys_device *dev,
 260                 struct sysdev_attribute *attr, const char *buf, size_t count)
 261 {
 262         struct memory_block *mem;
 263         unsigned int phys_section_nr;
 264         int ret = -EINVAL;
 265
 266         mem = container_of(dev, struct memory_block, sysdev);
 267         phys_section_nr = mem->phys_index;
 268
 269         if (!present_section_nr(phys_section_nr))
 270                 goto out;
 271
 272         if (!strncmp(buf, "online", min((int)count, 6)))
 273                 ret = memory_block_change_state(mem, MEM_ONLINE, MEM_OFFLINE);
 274         else if(!strncmp(buf, "offline", min((int)count, 7)))
 275                 ret = memory_block_change_state(mem, MEM_OFFLINE, MEM_ONLINE);
 276 out:
 277         if (ret)
 278                 return ret;
 279         return count;
 280 }
 281
 282 /*
 283  * phys_device is a bad name for this.  What I really want
 284  * is a way to differentiate between memory ranges that
 285  * are part of physical devices that constitute
 286  * a complete removable unit or fru.
 287  * i.e. do these ranges belong to the same physical device,
 288  * s.t. if I offline all of these sections I can then
 289  * remove the physical device?
 290  */
 291 static ssize_t show_phys_device(struct sys_device *dev,
 292                                 struct sysdev_attribute *attr, char *buf)
 293 {
 294         struct memory_block *mem =
 295                 container_of(dev, struct memory_block, sysdev);
 296         return sprintf(buf, "%d\n", mem->phys_device);
 297 }
 298
 299 static SYSDEV_ATTR(phys_index, 0444, show_mem_phys_index, NULL);
 300 static SYSDEV_ATTR(state, 0644, show_mem_state, store_mem_state);
 301 static SYSDEV_ATTR(phys_device, 0444, show_phys_device, NULL);
 302 static SYSDEV_ATTR(removable, 0444, show_mem_removable, NULL);
 303
 304 #define mem_create_simple_file(mem, attr_name)  \
 305         sysdev_create_file(&mem->sysdev, &attr_##attr_name)
 306 #define mem_remove_simple_file(mem, attr_name)  \
 307         sysdev_remove_file(&mem->sysdev, &attr_##attr_name)
 308
 309 /*
 310  * Block size attribute stuff
 311  */
 312 static ssize_t
 313 print_block_size(struct sysdev_class *class, struct sysdev_class_attribute *attr,
 314                  char *buf)
 315 {
 316         return sprintf(buf, "%#lx\n", (unsigned long)PAGES_PER_SECTION * PAGE_SIZE);
 317 }
 318
 319 static SYSDEV_CLASS_ATTR(block_size_bytes, 0444, print_block_size, NULL);
 320
 321 static int block_size_init(void)
 322 {
 323         return sysfs_create_file(&memory_sysdev_class.kset.kobj,
 324                                 &attr_block_size_bytes.attr);
 325 }
 326
 327 /*
 328  * Some architectures will have custom drivers to do this, and
 329  * will not need to do it from userspace.  The fake hot-add code
 330  * as well as ppc64 will do all of their discovery in userspace
 331  * and will require this interface.
 332  */
 333 #ifdef CONFIG_ARCH_MEMORY_PROBE
 334 static ssize_t
 335 memory_probe_store(struct class *class, struct class_attribute *attr,
 336                    const char *buf, size_t count)
 337 {
 338         u64 phys_addr;
 339         int nid;
 340         int ret;
 341
 342         phys_addr = simple_strtoull(buf, NULL, 0);
 343
 344         nid = memory_add_physaddr_to_nid(phys_addr);
 345         ret = add_memory(nid, phys_addr, PAGES_PER_SECTION << PAGE_SHIFT);
 346
 347         if (ret)
 348                 count = ret;
 349
 350         return count;
 351 }
 352 static CLASS_ATTR(probe, S_IWUSR, NULL, memory_probe_store);
 353
 354 static int memory_probe_init(void)
 355 {
 356         return sysfs_create_file(&memory_sysdev_class.kset.kobj,
 357                                 &class_attr_probe.attr);
 358 }
 359 #else
 360 static inline int memory_probe_init(void)
 361 {
 362         return 0;
 363 }
 364 #endif
 365
 366 #ifdef CONFIG_MEMORY_FAILURE
 367 /*
 368  * Support for offlining pages of memory
 369  */
 370
 371 /* Soft offline a page */
 372 static ssize_t
 373 store_soft_offline_page(struct class *class,
 374                         struct class_attribute *attr,
 375                         const char *buf, size_t count)
 376 {
 377         int ret;
 378         u64 pfn;
 379         if (!capable(CAP_SYS_ADMIN))
 380                 return -EPERM;
 381         if (strict_strtoull(buf, 0, &pfn) < 0)
 382                 return -EINVAL;
 383         pfn >>= PAGE_SHIFT;
 384         if (!pfn_valid(pfn))
 385                 return -ENXIO;
 386         ret = soft_offline_page(pfn_to_page(pfn), 0);
 387         return ret == 0 ? count : ret;
 388 }
 389
 390 /* Forcibly offline a page, including killing processes. */
 391 static ssize_t
 392 store_hard_offline_page(struct class *class,
 393                         struct class_attribute *attr,
 394                         const char *buf, size_t count)
 395 {
 396         int ret;
 397         u64 pfn;
 398         if (!capable(CAP_SYS_ADMIN))
 399                 return -EPERM;
 400         if (strict_strtoull(buf, 0, &pfn) < 0)
 401                 return -EINVAL;
 402         pfn >>= PAGE_SHIFT;
 403         ret = __memory_failure(pfn, 0, 0);
 404         return ret ? ret : count;
 405 }
 406
 407 static CLASS_ATTR(soft_offline_page, 0644, NULL, store_soft_offline_page);
 408 static CLASS_ATTR(hard_offline_page, 0644, NULL, store_hard_offline_page);
 409
 410 static __init int memory_fail_init(void)
 411 {
 412         int err;
 413
 414         err = sysfs_create_file(&memory_sysdev_class.kset.kobj,
 415                                 &class_attr_soft_offline_page.attr);
 416         if (!err)
 417                 err = sysfs_create_file(&memory_sysdev_class.kset.kobj,
 418                                 &class_attr_hard_offline_page.attr);
 419         return err;
 420 }
 421 #else
 422 static inline int memory_fail_init(void)
 423 {
 424         return 0;
 425 }
 426 #endif
 427
 428 /*
 429  * Note that phys_device is optional.  It is here to allow for
 430  * differentiation between which *physical* devices each
 431  * section belongs to...
 432  */
 433 int __weak arch_get_memory_phys_device(unsigned long start_pfn)
 434 {
 435         return 0;
 436 }
 437
 438 static int add_memory_block(int nid, struct mem_section *section,
 439                         unsigned long state, enum mem_add_context context)
 440 {
 441         struct memory_block *mem = kzalloc(sizeof(*mem), GFP_KERNEL);
 442         unsigned long start_pfn;
 443         int ret = 0;
 444
 445         if (!mem)
 446                 return -ENOMEM;
 447
 448         mem->phys_index = __section_nr(section);
 449         mem->state = state;
 450         mutex_init(&mem->state_mutex);
 451         start_pfn = section_nr_to_pfn(mem->phys_index);
 452         mem->phys_device = arch_get_memory_phys_device(start_pfn);
 453
 454         ret = register_memory(mem, section);
 455         if (!ret)
 456                 ret = mem_create_simple_file(mem, phys_index);
 457         if (!ret)
 458                 ret = mem_create_simple_file(mem, state);
 459         if (!ret)
 460                 ret = mem_create_simple_file(mem, phys_device);
 461         if (!ret)
 462                 ret = mem_create_simple_file(mem, removable);
 463         if (!ret) {
 464                 if (context == HOTPLUG)
 465                         ret = register_mem_sect_under_node(mem, nid);
 466         }
 467
 468         return ret;
 469 }
 470
 471 /*
 472  * For now, we have a linear search to go find the appropriate
 473  * memory_block corresponding to a particular phys_index. If
 474  * this gets to be a real problem, we can always use a radix
 475  * tree or something here.
 476  *
 477  * This could be made generic for all sysdev classes.
 478  */
 479 struct memory_block *find_memory_block(struct mem_section *section)
 480 {
 481         struct kobject *kobj;
 482         struct sys_device *sysdev;
 483         struct memory_block *mem;
 484         char name[sizeof(MEMORY_CLASS_NAME) + 9 + 1];
 485
 486         /*
 487          * This only works because we know that section == sysdev->id
 488          * slightly redundant with sysdev_register()
 489          */
 490         sprintf(&name[0], "%s%d", MEMORY_CLASS_NAME, __section_nr(section));
 491
 492         kobj = kset_find_obj(&memory_sysdev_class.kset, name);
 493         if (!kobj)
 494                 return NULL;
 495
 496         sysdev = container_of(kobj, struct sys_device, kobj);
 497         mem = container_of(sysdev, struct memory_block, sysdev);
 498
 499         return mem;
 500 }
 501
 502 int remove_memory_block(unsigned long node_id, struct mem_section *section,
 503                 int phys_device)
 504 {
 505         struct memory_block *mem;
 506
 507         mem = find_memory_block(section);
 508         unregister_mem_sect_under_nodes(mem);
 509         mem_remove_simple_file(mem, phys_index);
 510         mem_remove_simple_file(mem, state);
 511         mem_remove_simple_file(mem, phys_device);
 512         mem_remove_simple_file(mem, removable);
 513         unregister_memory(mem, section);
 514
 515         return 0;
 516 }
 517
 518 /*
 519  * need an interface for the VM to add new memory regions,
 520  * but without onlining it.
 521  */
 522 int register_new_memory(int nid, struct mem_section *section)
 523 {
 524         return add_memory_block(nid, section, MEM_OFFLINE, HOTPLUG);
 525 }
 526
 527 int unregister_memory_section(struct mem_section *section)
 528 {
 529         if (!present_section(section))
 530                 return -EINVAL;
 531
 532         return remove_memory_block(0, section, 0);
 533 }
 534
 535 /*
 536  * Initialize the sysfs support for memory devices...
 537  */
 538 int __init memory_dev_init(void)
 539 {
 540         unsigned int i;
 541         int ret;
 542         int err;
 543
 544         memory_sysdev_class.kset.uevent_ops = &memory_uevent_ops;
 545         ret = sysdev_class_register(&memory_sysdev_class);
 546         if (ret)
 547                 goto out;
 548
 549         /*
 550          * Create entries for memory sections that were found
 551          * during boot and have been initialized
 552          */
 553         for (i = 0; i < NR_MEM_SECTIONS; i++) {
 554                 if (!present_section_nr(i))
 555                         continue;
 556                 err = add_memory_block(0, __nr_to_section(i), MEM_ONLINE,
 557                                        BOOT);
 558                 if (!ret)
 559                         ret = err;
 560         }
 561
 562         err = memory_probe_init();
 563         if (!ret)
 564                 ret = err;
 565         err = memory_fail_init();
 566         if (!ret)
 567                 ret = err;
 568         err = block_size_init();
 569         if (!ret)
 570                 ret = err;
 571 out:
 572         if (ret)
 573                 printk(KERN_ERR "%s() failed: %d\n", __func__, ret);
 574         return ret;
 575 }