drivers/firmware/memmap.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * linux/drivers/firmware/memmap.c
   4  *  Copyright (C) 2008 SUSE LINUX Products GmbH
   5  *  by Bernhard Walle <bernhard.walle@gmx.de>
   6  */
   7
   8 #include <linux/string.h>
   9 #include <linux/firmware-map.h>
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/types.h>
  13 #include <linux/memblock.h>
  14 #include <linux/slab.h>
  15 #include <linux/mm.h>
  16
  17 /*
  18  * Data types ------------------------------------------------------------------
  19  */
  20
  21 /*
  22  * Firmware map entry. Because firmware memory maps are flat and not
  23  * hierarchical, it's ok to organise them in a linked list. No parent
  24  * information is necessary as for the resource tree.
  25  */
  26 struct firmware_map_entry {
  27         /*
  28          * start and end must be u64 rather than resource_size_t, because e820
  29          * resources can lie at addresses above 4G.
  30          */
  31         u64                     start;  /* start of the memory range */
  32         u64                     end;    /* end of the memory range (incl.) */
  33         const char              *type;  /* type of the memory range */
  34         struct list_head        list;   /* entry for the linked list */
  35         struct kobject          kobj;   /* kobject for each entry */
  36 };
  37
  38 /*
  39  * Forward declarations --------------------------------------------------------
  40  */
  41 static ssize_t memmap_attr_show(struct kobject *kobj,
  42                                 struct attribute *attr, char *buf);
  43 static ssize_t start_show(struct firmware_map_entry *entry, char *buf);
  44 static ssize_t end_show(struct firmware_map_entry *entry, char *buf);
  45 static ssize_t type_show(struct firmware_map_entry *entry, char *buf);
  46
  47 static struct firmware_map_entry * __meminit
  48 firmware_map_find_entry(u64 start, u64 end, const char *type);
  49
  50 /*
  51  * Static data -----------------------------------------------------------------
  52  */
  53
  54 struct memmap_attribute {
  55         struct attribute attr;
  56         ssize_t (*show)(struct firmware_map_entry *entry, char *buf);
  57 };
  58
  59 static struct memmap_attribute memmap_start_attr = __ATTR_RO(start);
  60 static struct memmap_attribute memmap_end_attr   = __ATTR_RO(end);
  61 static struct memmap_attribute memmap_type_attr  = __ATTR_RO(type);
  62
  63 /*
  64  * These are default attributes that are added for every memmap entry.
  65  */
  66 static struct attribute *def_attrs[] = {
  67         &memmap_start_attr.attr,
  68         &memmap_end_attr.attr,
  69         &memmap_type_attr.attr,
  70         NULL
  71 };
  72 ATTRIBUTE_GROUPS(def);
  73
  74 static const struct sysfs_ops memmap_attr_ops = {
  75         .show = memmap_attr_show,
  76 };
  77
  78 /* Firmware memory map entries. */
  79 static LIST_HEAD(map_entries);
  80 static DEFINE_SPINLOCK(map_entries_lock);
  81
  82 /*
  83  * For memory hotplug, there is no way to free memory map entries allocated
  84  * by boot mem after the system is up. So when we hot-remove memory whose
  85  * map entry is allocated by bootmem, we need to remember the storage and
  86  * reuse it when the memory is hot-added again.
  87  */
  88 static LIST_HEAD(map_entries_bootmem);
  89 static DEFINE_SPINLOCK(map_entries_bootmem_lock);
  90
  91
  92 static inline struct firmware_map_entry *
  93 to_memmap_entry(struct kobject *kobj)
  94 {
  95         return container_of(kobj, struct firmware_map_entry, kobj);
  96 }
  97
  98 static void __meminit release_firmware_map_entry(struct kobject *kobj)
  99 {
 100         struct firmware_map_entry *entry = to_memmap_entry(kobj);
 101
 102         if (PageReserved(virt_to_page(entry))) {
 103                 /*
 104                  * Remember the storage allocated by bootmem, and reuse it when
 105                  * the memory is hot-added again. The entry will be added to
 106                  * map_entries_bootmem here, and deleted from &map_entries in
 107                  * firmware_map_remove_entry().
 108                  */
 109                 spin_lock(&map_entries_bootmem_lock);
 110                 list_add(&entry->list, &map_entries_bootmem);
 111                 spin_unlock(&map_entries_bootmem_lock);
 112
 113                 return;
 114         }
 115
 116         kfree(entry);
 117 }
 118
 119 static struct kobj_type __refdata memmap_ktype = {
 120         .release        = release_firmware_map_entry,
 121         .sysfs_ops      = &memmap_attr_ops,
 122         .default_groups = def_groups,
 123 };
 124
 125 /*
 126  * Registration functions ------------------------------------------------------
 127  */
 128
 129 /**
 130  * firmware_map_add_entry() - Does the real work to add a firmware memmap entry.
 131  * @start: Start of the memory range.
 132  * @end:   End of the memory range (exclusive).
 133  * @type:  Type of the memory range.
 134  * @entry: Pre-allocated (either kmalloc() or bootmem allocator), uninitialised
 135  *         entry.
 136  *
 137  * Common implementation of firmware_map_add() and firmware_map_add_early()
 138  * which expects a pre-allocated struct firmware_map_entry.
 139  *
 140  * Return: 0 always
 141  */
 142 static int firmware_map_add_entry(u64 start, u64 end,
 143                                   const char *type,
 144                                   struct firmware_map_entry *entry)
 145 {
 146         BUG_ON(start > end);
 147
 148         entry->start = start;
 149         entry->end = end - 1;
 150         entry->type = type;
 151         INIT_LIST_HEAD(&entry->list);
 152         kobject_init(&entry->kobj, &memmap_ktype);
 153
 154         spin_lock(&map_entries_lock);
 155         list_add_tail(&entry->list, &map_entries);
 156         spin_unlock(&map_entries_lock);
 157
 158         return 0;
 159 }
 160
 161 /**
 162  * firmware_map_remove_entry() - Does the real work to remove a firmware
 163  * memmap entry.
 164  * @entry: removed entry.
 165  *
 166  * The caller must hold map_entries_lock, and release it properly.
 167  */
 168 static inline void firmware_map_remove_entry(struct firmware_map_entry *entry)
 169 {
 170         list_del(&entry->list);
 171 }
 172
 173 /*
 174  * Add memmap entry on sysfs
 175  */
 176 static int add_sysfs_fw_map_entry(struct firmware_map_entry *entry)
 177 {
 178         static int map_entries_nr;
 179         static struct kset *mmap_kset;
 180
 181         if (entry->kobj.state_in_sysfs)
 182                 return -EEXIST;
 183
 184         if (!mmap_kset) {
 185                 mmap_kset = kset_create_and_add("memmap", NULL, firmware_kobj);
 186                 if (!mmap_kset)
 187                         return -ENOMEM;
 188         }
 189
 190         entry->kobj.kset = mmap_kset;
 191         if (kobject_add(&entry->kobj, NULL, "%d", map_entries_nr++))
 192                 kobject_put(&entry->kobj);
 193
 194         return 0;
 195 }
 196
 197 /*
 198  * Remove memmap entry on sysfs
 199  */
 200 static inline void remove_sysfs_fw_map_entry(struct firmware_map_entry *entry)
 201 {
 202         kobject_put(&entry->kobj);
 203 }
 204
 205 /**
 206  * firmware_map_find_entry_in_list() - Search memmap entry in a given list.
 207  * @start: Start of the memory range.
 208  * @end:   End of the memory range (exclusive).
 209  * @type:  Type of the memory range.
 210  * @list:  In which to find the entry.
 211  *
 212  * This function is to find the memmap entey of a given memory range in a
 213  * given list. The caller must hold map_entries_lock, and must not release
 214  * the lock until the processing of the returned entry has completed.
 215  *
 216  * Return: Pointer to the entry to be found on success, or NULL on failure.
 217  */
 218 static struct firmware_map_entry * __meminit
 219 firmware_map_find_entry_in_list(u64 start, u64 end, const char *type,
 220                                 struct list_head *list)
 221 {
 222         struct firmware_map_entry *entry;
 223
 224         list_for_each_entry(entry, list, list)
 225                 if ((entry->start == start) && (entry->end == end) &&
 226                     (!strcmp(entry->type, type))) {
 227                         return entry;
 228                 }
 229
 230         return NULL;
 231 }
 232
 233 /**
 234  * firmware_map_find_entry() - Search memmap entry in map_entries.
 235  * @start: Start of the memory range.
 236  * @end:   End of the memory range (exclusive).
 237  * @type:  Type of the memory range.
 238  *
 239  * This function is to find the memmap entey of a given memory range.
 240  * The caller must hold map_entries_lock, and must not release the lock
 241  * until the processing of the returned entry has completed.
 242  *
 243  * Return: Pointer to the entry to be found on success, or NULL on failure.
 244  */
 245 static struct firmware_map_entry * __meminit
 246 firmware_map_find_entry(u64 start, u64 end, const char *type)
 247 {
 248         return firmware_map_find_entry_in_list(start, end, type, &map_entries);
 249 }
 250
 251 /**
 252  * firmware_map_find_entry_bootmem() - Search memmap entry in map_entries_bootmem.
 253  * @start: Start of the memory range.
 254  * @end:   End of the memory range (exclusive).
 255  * @type:  Type of the memory range.
 256  *
 257  * This function is similar to firmware_map_find_entry except that it find the
 258  * given entry in map_entries_bootmem.
 259  *
 260  * Return: Pointer to the entry to be found on success, or NULL on failure.
 261  */
 262 static struct firmware_map_entry * __meminit
 263 firmware_map_find_entry_bootmem(u64 start, u64 end, const char *type)
 264 {
 265         return firmware_map_find_entry_in_list(start, end, type,
 266                                                &map_entries_bootmem);
 267 }
 268
 269 /**
 270  * firmware_map_add_hotplug() - Adds a firmware mapping entry when we do
 271  * memory hotplug.
 272  * @start: Start of the memory range.
 273  * @end:   End of the memory range (exclusive)
 274  * @type:  Type of the memory range.
 275  *
 276  * Adds a firmware mapping entry. This function is for memory hotplug, it is
 277  * similar to function firmware_map_add_early(). The only difference is that
 278  * it will create the syfs entry dynamically.
 279  *
 280  * Return: 0 on success, or -ENOMEM if no memory could be allocated.
 281  */
 282 int __meminit firmware_map_add_hotplug(u64 start, u64 end, const char *type)
 283 {
 284         struct firmware_map_entry *entry;
 285
 286         entry = firmware_map_find_entry(start, end - 1, type);
 287         if (entry)
 288                 return 0;
 289
 290         entry = firmware_map_find_entry_bootmem(start, end - 1, type);
 291         if (!entry) {
 292                 entry = kzalloc(sizeof(struct firmware_map_entry), GFP_ATOMIC);
 293                 if (!entry)
 294                         return -ENOMEM;
 295         } else {
 296                 /* Reuse storage allocated by bootmem. */
 297                 spin_lock(&map_entries_bootmem_lock);
 298                 list_del(&entry->list);
 299                 spin_unlock(&map_entries_bootmem_lock);
 300
 301                 memset(entry, 0, sizeof(*entry));
 302         }
 303
 304         firmware_map_add_entry(start, end, type, entry);
 305         /* create the memmap entry */
 306         add_sysfs_fw_map_entry(entry);
 307
 308         return 0;
 309 }
 310
 311 /**
 312  * firmware_map_add_early() - Adds a firmware mapping entry.
 313  * @start: Start of the memory range.
 314  * @end:   End of the memory range.
 315  * @type:  Type of the memory range.
 316  *
 317  * Adds a firmware mapping entry. This function uses the bootmem allocator
 318  * for memory allocation.
 319  *
 320  * That function must be called before late_initcall.
 321  *
 322  * Return: 0 on success, or -ENOMEM if no memory could be allocated.
 323  */
 324 int __init firmware_map_add_early(u64 start, u64 end, const char *type)
 325 {
 326         struct firmware_map_entry *entry;
 327
 328         entry = memblock_alloc(sizeof(struct firmware_map_entry),
 329                                SMP_CACHE_BYTES);
 330         if (WARN_ON(!entry))
 331                 return -ENOMEM;
 332
 333         return firmware_map_add_entry(start, end, type, entry);
 334 }
 335
 336 /**
 337  * firmware_map_remove() - remove a firmware mapping entry
 338  * @start: Start of the memory range.
 339  * @end:   End of the memory range.
 340  * @type:  Type of the memory range.
 341  *
 342  * removes a firmware mapping entry.
 343  *
 344  * Return: 0 on success, or -EINVAL if no entry.
 345  */
 346 int __meminit firmware_map_remove(u64 start, u64 end, const char *type)
 347 {
 348         struct firmware_map_entry *entry;
 349
 350         spin_lock(&map_entries_lock);
 351         entry = firmware_map_find_entry(start, end - 1, type);
 352         if (!entry) {
 353                 spin_unlock(&map_entries_lock);
 354                 return -EINVAL;
 355         }
 356
 357         firmware_map_remove_entry(entry);
 358         spin_unlock(&map_entries_lock);
 359
 360         /* remove the memmap entry */
 361         remove_sysfs_fw_map_entry(entry);
 362
 363         return 0;
 364 }
 365
 366 /*
 367  * Sysfs functions -------------------------------------------------------------
 368  */
 369
 370 static ssize_t start_show(struct firmware_map_entry *entry, char *buf)
 371 {
 372         return snprintf(buf, PAGE_SIZE, "0x%llx\n",
 373                 (unsigned long long)entry->start);
 374 }
 375
 376 static ssize_t end_show(struct firmware_map_entry *entry, char *buf)
 377 {
 378         return snprintf(buf, PAGE_SIZE, "0x%llx\n",
 379                 (unsigned long long)entry->end);
 380 }
 381
 382 static ssize_t type_show(struct firmware_map_entry *entry, char *buf)
 383 {
 384         return snprintf(buf, PAGE_SIZE, "%s\n", entry->type);
 385 }
 386
 387 static inline struct memmap_attribute *to_memmap_attr(struct attribute *attr)
 388 {
 389         return container_of(attr, struct memmap_attribute, attr);
 390 }
 391
 392 static ssize_t memmap_attr_show(struct kobject *kobj,
 393                                 struct attribute *attr, char *buf)
 394 {
 395         struct firmware_map_entry *entry = to_memmap_entry(kobj);
 396         struct memmap_attribute *memmap_attr = to_memmap_attr(attr);
 397
 398         return memmap_attr->show(entry, buf);
 399 }
 400
 401 /*
 402  * Initialises stuff and adds the entries in the map_entries list to
 403  * sysfs. Important is that firmware_map_add() and firmware_map_add_early()
 404  * must be called before late_initcall. That's just because that function
 405  * is called as late_initcall() function, which means that if you call
 406  * firmware_map_add() or firmware_map_add_early() afterwards, the entries
 407  * are not added to sysfs.
 408  */
 409 static int __init firmware_memmap_init(void)
 410 {
 411         struct firmware_map_entry *entry;
 412
 413         list_for_each_entry(entry, &map_entries, list)
 414                 add_sysfs_fw_map_entry(entry);
 415
 416         return 0;
 417 }
 418 late_initcall(firmware_memmap_init);
 419