kernel/resource.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *      linux/kernel/resource.c
   4  *
   5  * Copyright (C) 1999   Linus Torvalds
   6  * Copyright (C) 1999   Martin Mares <mj@ucw.cz>
   7  *
   8  * Arbitrary resource management.
   9  */
  10
  11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  12
  13 #include <linux/export.h>
  14 #include <linux/errno.h>
  15 #include <linux/ioport.h>
  16 #include <linux/init.h>
  17 #include <linux/slab.h>
  18 #include <linux/spinlock.h>
  19 #include <linux/fs.h>
  20 #include <linux/proc_fs.h>
  21 #include <linux/pseudo_fs.h>
  22 #include <linux/sched.h>
  23 #include <linux/seq_file.h>
  24 #include <linux/device.h>
  25 #include <linux/pfn.h>
  26 #include <linux/mm.h>
  27 #include <linux/mount.h>
  28 #include <linux/resource_ext.h>
  29 #include <uapi/linux/magic.h>
  30 #include <asm/io.h>
  31
  32
  33 struct resource ioport_resource = {
  34         .name   = "PCI IO",
  35         .start  = 0,
  36         .end    = IO_SPACE_LIMIT,
  37         .flags  = IORESOURCE_IO,
  38 };
  39 EXPORT_SYMBOL(ioport_resource);
  40
  41 struct resource iomem_resource = {
  42         .name   = "PCI mem",
  43         .start  = 0,
  44         .end    = -1,
  45         .flags  = IORESOURCE_MEM,
  46 };
  47 EXPORT_SYMBOL(iomem_resource);
  48
  49 /* constraints to be met while allocating resources */
  50 struct resource_constraint {
  51         resource_size_t min, max, align;
  52         resource_size_t (*alignf)(void *, const struct resource *,
  53                         resource_size_t, resource_size_t);
  54         void *alignf_data;
  55 };
  56
  57 static DEFINE_RWLOCK(resource_lock);
  58
  59 /*
  60  * For memory hotplug, there is no way to free resource entries allocated
  61  * by boot mem after the system is up. So for reusing the resource entry
  62  * we need to remember the resource.
  63  */
  64 static struct resource *bootmem_resource_free;
  65 static DEFINE_SPINLOCK(bootmem_resource_lock);
  66
  67 static struct resource *next_resource(struct resource *p, bool sibling_only)
  68 {
  69         /* Caller wants to traverse through siblings only */
  70         if (sibling_only)
  71                 return p->sibling;
  72
  73         if (p->child)
  74                 return p->child;
  75         while (!p->sibling && p->parent)
  76                 p = p->parent;
  77         return p->sibling;
  78 }
  79
  80 static void *r_next(struct seq_file *m, void *v, loff_t *pos)
  81 {
  82         struct resource *p = v;
  83         (*pos)++;
  84         return (void *)next_resource(p, false);
  85 }
  86
  87 #ifdef CONFIG_PROC_FS
  88
  89 enum { MAX_IORES_LEVEL = 5 };
  90
  91 static void *r_start(struct seq_file *m, loff_t *pos)
  92         __acquires(resource_lock)
  93 {
  94         struct resource *p = PDE_DATA(file_inode(m->file));
  95         loff_t l = 0;
  96         read_lock(&resource_lock);
  97         for (p = p->child; p && l < *pos; p = r_next(m, p, &l))
  98                 ;
  99         return p;
 100 }
 101
 102 static void r_stop(struct seq_file *m, void *v)
 103         __releases(resource_lock)
 104 {
 105         read_unlock(&resource_lock);
 106 }
 107
 108 static int r_show(struct seq_file *m, void *v)
 109 {
 110         struct resource *root = PDE_DATA(file_inode(m->file));
 111         struct resource *r = v, *p;
 112         unsigned long long start, end;
 113         int width = root->end < 0x10000 ? 4 : 8;
 114         int depth;
 115
 116         for (depth = 0, p = r; depth < MAX_IORES_LEVEL; depth++, p = p->parent)
 117                 if (p->parent == root)
 118                         break;
 119
 120         if (file_ns_capable(m->file, &init_user_ns, CAP_SYS_ADMIN)) {
 121                 start = r->start;
 122                 end = r->end;
 123         } else {
 124                 start = end = 0;
 125         }
 126
 127         seq_printf(m, "%*s%0*llx-%0*llx : %s\n",
 128                         depth * 2, "",
 129                         width, start,
 130                         width, end,
 131                         r->name ? r->name : "<BAD>");
 132         return 0;
 133 }
 134
 135 static const struct seq_operations resource_op = {
 136         .start  = r_start,
 137         .next   = r_next,
 138         .stop   = r_stop,
 139         .show   = r_show,
 140 };
 141
 142 static int __init ioresources_init(void)
 143 {
 144         proc_create_seq_data("ioports", 0, NULL, &resource_op,
 145                         &ioport_resource);
 146         proc_create_seq_data("iomem", 0, NULL, &resource_op, &iomem_resource);
 147         return 0;
 148 }
 149 __initcall(ioresources_init);
 150
 151 #endif /* CONFIG_PROC_FS */
 152
 153 static void free_resource(struct resource *res)
 154 {
 155         if (!res)
 156                 return;
 157
 158         if (!PageSlab(virt_to_head_page(res))) {
 159                 spin_lock(&bootmem_resource_lock);
 160                 res->sibling = bootmem_resource_free;
 161                 bootmem_resource_free = res;
 162                 spin_unlock(&bootmem_resource_lock);
 163         } else {
 164                 kfree(res);
 165         }
 166 }
 167
 168 static struct resource *alloc_resource(gfp_t flags)
 169 {
 170         struct resource *res = NULL;
 171
 172         spin_lock(&bootmem_resource_lock);
 173         if (bootmem_resource_free) {
 174                 res = bootmem_resource_free;
 175                 bootmem_resource_free = res->sibling;
 176         }
 177         spin_unlock(&bootmem_resource_lock);
 178
 179         if (res)
 180                 memset(res, 0, sizeof(struct resource));
 181         else
 182                 res = kzalloc(sizeof(struct resource), flags);
 183
 184         return res;
 185 }
 186
 187 /* Return the conflict entry if you can't request it */
 188 static struct resource * __request_resource(struct resource *root, struct resource *new)
 189 {
 190         resource_size_t start = new->start;
 191         resource_size_t end = new->end;
 192         struct resource *tmp, **p;
 193
 194         if (end < start)
 195                 return root;
 196         if (start < root->start)
 197                 return root;
 198         if (end > root->end)
 199                 return root;
 200         p = &root->child;
 201         for (;;) {
 202                 tmp = *p;
 203                 if (!tmp || tmp->start > end) {
 204                         new->sibling = tmp;
 205                         *p = new;
 206                         new->parent = root;
 207                         return NULL;
 208                 }
 209                 p = &tmp->sibling;
 210                 if (tmp->end < start)
 211                         continue;
 212                 return tmp;
 213         }
 214 }
 215
 216 static int __release_resource(struct resource *old, bool release_child)
 217 {
 218         struct resource *tmp, **p, *chd;
 219
 220         p = &old->parent->child;
 221         for (;;) {
 222                 tmp = *p;
 223                 if (!tmp)
 224                         break;
 225                 if (tmp == old) {
 226                         if (release_child || !(tmp->child)) {
 227                                 *p = tmp->sibling;
 228                         } else {
 229                                 for (chd = tmp->child;; chd = chd->sibling) {
 230                                         chd->parent = tmp->parent;
 231                                         if (!(chd->sibling))
 232                                                 break;
 233                                 }
 234                                 *p = tmp->child;
 235                                 chd->sibling = tmp->sibling;
 236                         }
 237                         old->parent = NULL;
 238                         return 0;
 239                 }
 240                 p = &tmp->sibling;
 241         }
 242         return -EINVAL;
 243 }
 244
 245 static void __release_child_resources(struct resource *r)
 246 {
 247         struct resource *tmp, *p;
 248         resource_size_t size;
 249
 250         p = r->child;
 251         r->child = NULL;
 252         while (p) {
 253                 tmp = p;
 254                 p = p->sibling;
 255
 256                 tmp->parent = NULL;
 257                 tmp->sibling = NULL;
 258                 __release_child_resources(tmp);
 259
 260                 printk(KERN_DEBUG "release child resource %pR\n", tmp);
 261                 /* need to restore size, and keep flags */
 262                 size = resource_size(tmp);
 263                 tmp->start = 0;
 264                 tmp->end = size - 1;
 265         }
 266 }
 267
 268 void release_child_resources(struct resource *r)
 269 {
 270         write_lock(&resource_lock);
 271         __release_child_resources(r);
 272         write_unlock(&resource_lock);
 273 }
 274
 275 /**
 276  * request_resource_conflict - request and reserve an I/O or memory resource
 277  * @root: root resource descriptor
 278  * @new: resource descriptor desired by caller
 279  *
 280  * Returns 0 for success, conflict resource on error.
 281  */
 282 struct resource *request_resource_conflict(struct resource *root, struct resource *new)
 283 {
 284         struct resource *conflict;
 285
 286         write_lock(&resource_lock);
 287         conflict = __request_resource(root, new);
 288         write_unlock(&resource_lock);
 289         return conflict;
 290 }
 291
 292 /**
 293  * request_resource - request and reserve an I/O or memory resource
 294  * @root: root resource descriptor
 295  * @new: resource descriptor desired by caller
 296  *
 297  * Returns 0 for success, negative error code on error.
 298  */
 299 int request_resource(struct resource *root, struct resource *new)
 300 {
 301         struct resource *conflict;
 302
 303         conflict = request_resource_conflict(root, new);
 304         return conflict ? -EBUSY : 0;
 305 }
 306
 307 EXPORT_SYMBOL(request_resource);
 308
 309 /**
 310  * release_resource - release a previously reserved resource
 311  * @old: resource pointer
 312  */
 313 int release_resource(struct resource *old)
 314 {
 315         int retval;
 316
 317         write_lock(&resource_lock);
 318         retval = __release_resource(old, true);
 319         write_unlock(&resource_lock);
 320         return retval;
 321 }
 322
 323 EXPORT_SYMBOL(release_resource);
 324
 325 /**
 326  * find_next_iomem_res - Finds the lowest iomem resource that covers part of
 327  *                       [@start..@end].
 328  *
 329  * If a resource is found, returns 0 and @*res is overwritten with the part
 330  * of the resource that's within [@start..@end]; if none is found, returns
 331  * -ENODEV.  Returns -EINVAL for invalid parameters.
 332  *
 333  * This function walks the whole tree and not just first level children
 334  * unless @first_lvl is true.
 335  *
 336  * @start:      start address of the resource searched for
 337  * @end:        end address of same resource
 338  * @flags:      flags which the resource must have
 339  * @desc:       descriptor the resource must have
 340  * @first_lvl:  walk only the first level children, if set
 341  * @res:        return ptr, if resource found
 342  *
 343  * The caller must specify @start, @end, @flags, and @desc
 344  * (which may be IORES_DESC_NONE).
 345  */
 346 static int find_next_iomem_res(resource_size_t start, resource_size_t end,
 347                                unsigned long flags, unsigned long desc,
 348                                bool first_lvl, struct resource *res)
 349 {
 350         bool siblings_only = true;
 351         struct resource *p;
 352
 353         if (!res)
 354                 return -EINVAL;
 355
 356         if (start >= end)
 357                 return -EINVAL;
 358
 359         read_lock(&resource_lock);
 360
 361         for (p = iomem_resource.child; p; p = next_resource(p, siblings_only)) {
 362                 /* If we passed the resource we are looking for, stop */
 363                 if (p->start > end) {
 364                         p = NULL;
 365                         break;
 366                 }
 367
 368                 /* Skip until we find a range that matches what we look for */
 369                 if (p->end < start)
 370                         continue;
 371
 372                 /*
 373                  * Now that we found a range that matches what we look for,
 374                  * check the flags and the descriptor. If we were not asked to
 375                  * use only the first level, start looking at children as well.
 376                  */
 377                 siblings_only = first_lvl;
 378
 379                 if ((p->flags & flags) != flags)
 380                         continue;
 381                 if ((desc != IORES_DESC_NONE) && (desc != p->desc))
 382                         continue;
 383
 384                 /* Found a match, break */
 385                 break;
 386         }
 387
 388         if (p) {
 389                 /* copy data */
 390                 *res = (struct resource) {
 391                         .start = max(start, p->start),
 392                         .end = min(end, p->end),
 393                         .flags = p->flags,
 394                         .desc = p->desc,
 395                         .parent = p->parent,
 396                 };
 397         }
 398
 399         read_unlock(&resource_lock);
 400         return p ? 0 : -ENODEV;
 401 }
 402
 403 static int __walk_iomem_res_desc(resource_size_t start, resource_size_t end,
 404                                  unsigned long flags, unsigned long desc,
 405                                  bool first_lvl, void *arg,
 406                                  int (*func)(struct resource *, void *))
 407 {
 408         struct resource res;
 409         int ret = -EINVAL;
 410
 411         while (start < end &&
 412                !find_next_iomem_res(start, end, flags, desc, first_lvl, &res)) {
 413                 ret = (*func)(&res, arg);
 414                 if (ret)
 415                         break;
 416
 417                 start = res.end + 1;
 418         }
 419
 420         return ret;
 421 }
 422
 423 /**
 424  * walk_iomem_res_desc - Walks through iomem resources and calls func()
 425  *                       with matching resource ranges.
 426  * *
 427  * @desc: I/O resource descriptor. Use IORES_DESC_NONE to skip @desc check.
 428  * @flags: I/O resource flags
 429  * @start: start addr
 430  * @end: end addr
 431  * @arg: function argument for the callback @func
 432  * @func: callback function that is called for each qualifying resource area
 433  *
 434  * This walks through whole tree and not just first level children.
 435  * All the memory ranges which overlap start,end and also match flags and
 436  * desc are valid candidates.
 437  *
 438  * NOTE: For a new descriptor search, define a new IORES_DESC in
 439  * <linux/ioport.h> and set it in 'desc' of a target resource entry.
 440  */
 441 int walk_iomem_res_desc(unsigned long desc, unsigned long flags, u64 start,
 442                 u64 end, void *arg, int (*func)(struct resource *, void *))
 443 {
 444         return __walk_iomem_res_desc(start, end, flags, desc, false, arg, func);
 445 }
 446 EXPORT_SYMBOL_GPL(walk_iomem_res_desc);
 447
 448 /*
 449  * This function calls the @func callback against all memory ranges of type
 450  * System RAM which are marked as IORESOURCE_SYSTEM_RAM and IORESOUCE_BUSY.
 451  * Now, this function is only for System RAM, it deals with full ranges and
 452  * not PFNs. If resources are not PFN-aligned, dealing with PFNs can truncate
 453  * ranges.
 454  */
 455 int walk_system_ram_res(u64 start, u64 end, void *arg,
 456                         int (*func)(struct resource *, void *))
 457 {
 458         unsigned long flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY;
 459
 460         return __walk_iomem_res_desc(start, end, flags, IORES_DESC_NONE, true,
 461                                      arg, func);
 462 }
 463
 464 /*
 465  * This function calls the @func callback against all memory ranges, which
 466  * are ranges marked as IORESOURCE_MEM and IORESOUCE_BUSY.
 467  */
 468 int walk_mem_res(u64 start, u64 end, void *arg,
 469                  int (*func)(struct resource *, void *))
 470 {
 471         unsigned long flags = IORESOURCE_MEM | IORESOURCE_BUSY;
 472
 473         return __walk_iomem_res_desc(start, end, flags, IORES_DESC_NONE, true,
 474                                      arg, func);
 475 }
 476
 477 /*
 478  * This function calls the @func callback against all memory ranges of type
 479  * System RAM which are marked as IORESOURCE_SYSTEM_RAM and IORESOUCE_BUSY.
 480  * It is to be used only for System RAM.
 481  *
 482  * This will find System RAM ranges that are children of top-level resources
 483  * in addition to top-level System RAM resources.
 484  */
 485 int walk_system_ram_range(unsigned long start_pfn, unsigned long nr_pages,
 486                           void *arg, int (*func)(unsigned long, unsigned long, void *))
 487 {
 488         resource_size_t start, end;
 489         unsigned long flags;
 490         struct resource res;
 491         unsigned long pfn, end_pfn;
 492         int ret = -EINVAL;
 493
 494         start = (u64) start_pfn << PAGE_SHIFT;
 495         end = ((u64)(start_pfn + nr_pages) << PAGE_SHIFT) - 1;
 496         flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY;
 497         while (start < end &&
 498                !find_next_iomem_res(start, end, flags, IORES_DESC_NONE,
 499                                     false, &res)) {
 500                 pfn = PFN_UP(res.start);
 501                 end_pfn = PFN_DOWN(res.end + 1);
 502                 if (end_pfn > pfn)
 503                         ret = (*func)(pfn, end_pfn - pfn, arg);
 504                 if (ret)
 505                         break;
 506                 start = res.end + 1;
 507         }
 508         return ret;
 509 }
 510
 511 static int __is_ram(unsigned long pfn, unsigned long nr_pages, void *arg)
 512 {
 513         return 1;
 514 }
 515
 516 /*
 517  * This generic page_is_ram() returns true if specified address is
 518  * registered as System RAM in iomem_resource list.
 519  */
 520 int __weak page_is_ram(unsigned long pfn)
 521 {
 522         return walk_system_ram_range(pfn, 1, NULL, __is_ram) == 1;
 523 }
 524 EXPORT_SYMBOL_GPL(page_is_ram);
 525
 526 /**
 527  * region_intersects() - determine intersection of region with known resources
 528  * @start: region start address
 529  * @size: size of region
 530  * @flags: flags of resource (in iomem_resource)
 531  * @desc: descriptor of resource (in iomem_resource) or IORES_DESC_NONE
 532  *
 533  * Check if the specified region partially overlaps or fully eclipses a
 534  * resource identified by @flags and @desc (optional with IORES_DESC_NONE).
 535  * Return REGION_DISJOINT if the region does not overlap @flags/@desc,
 536  * return REGION_MIXED if the region overlaps @flags/@desc and another
 537  * resource, and return REGION_INTERSECTS if the region overlaps @flags/@desc
 538  * and no other defined resource. Note that REGION_INTERSECTS is also
 539  * returned in the case when the specified region overlaps RAM and undefined
 540  * memory holes.
 541  *
 542  * region_intersect() is used by memory remapping functions to ensure
 543  * the user is not remapping RAM and is a vast speed up over walking
 544  * through the resource table page by page.
 545  */
 546 int region_intersects(resource_size_t start, size_t size, unsigned long flags,
 547                       unsigned long desc)
 548 {
 549         struct resource res;
 550         int type = 0; int other = 0;
 551         struct resource *p;
 552
 553         res.start = start;
 554         res.end = start + size - 1;
 555
 556         read_lock(&resource_lock);
 557         for (p = iomem_resource.child; p ; p = p->sibling) {
 558                 bool is_type = (((p->flags & flags) == flags) &&
 559                                 ((desc == IORES_DESC_NONE) ||
 560                                  (desc == p->desc)));
 561
 562                 if (resource_overlaps(p, &res))
 563                         is_type ? type++ : other++;
 564         }
 565         read_unlock(&resource_lock);
 566
 567         if (type == 0)
 568                 return REGION_DISJOINT;
 569
 570         if (other == 0)
 571                 return REGION_INTERSECTS;
 572
 573         return REGION_MIXED;
 574 }
 575 EXPORT_SYMBOL_GPL(region_intersects);
 576
 577 void __weak arch_remove_reservations(struct resource *avail)
 578 {
 579 }
 580
 581 static resource_size_t simple_align_resource(void *data,
 582                                              const struct resource *avail,
 583                                              resource_size_t size,
 584                                              resource_size_t align)
 585 {
 586         return avail->start;
 587 }
 588
 589 static void resource_clip(struct resource *res, resource_size_t min,
 590                           resource_size_t max)
 591 {
 592         if (res->start < min)
 593                 res->start = min;
 594         if (res->end > max)
 595                 res->end = max;
 596 }
 597
 598 /*
 599  * Find empty slot in the resource tree with the given range and
 600  * alignment constraints
 601  */
 602 static int __find_resource(struct resource *root, struct resource *old,
 603                          struct resource *new,
 604                          resource_size_t  size,
 605                          struct resource_constraint *constraint)
 606 {
 607         struct resource *this = root->child;
 608         struct resource tmp = *new, avail, alloc;
 609
 610         tmp.start = root->start;
 611         /*
 612          * Skip past an allocated resource that starts at 0, since the assignment
 613          * of this->start - 1 to tmp->end below would cause an underflow.
 614          */
 615         if (this && this->start == root->start) {
 616                 tmp.start = (this == old) ? old->start : this->end + 1;
 617                 this = this->sibling;
 618         }
 619         for(;;) {
 620                 if (this)
 621                         tmp.end = (this == old) ?  this->end : this->start - 1;
 622                 else
 623                         tmp.end = root->end;
 624
 625                 if (tmp.end < tmp.start)
 626                         goto next;
 627
 628                 resource_clip(&tmp, constraint->min, constraint->max);
 629                 arch_remove_reservations(&tmp);
 630
 631                 /* Check for overflow after ALIGN() */
 632                 avail.start = ALIGN(tmp.start, constraint->align);
 633                 avail.end = tmp.end;
 634                 avail.flags = new->flags & ~IORESOURCE_UNSET;
 635                 if (avail.start >= tmp.start) {
 636                         alloc.flags = avail.flags;
 637                         alloc.start = constraint->alignf(constraint->alignf_data, &avail,
 638                                         size, constraint->align);
 639                         alloc.end = alloc.start + size - 1;
 640                         if (alloc.start <= alloc.end &&
 641                             resource_contains(&avail, &alloc)) {
 642                                 new->start = alloc.start;
 643                                 new->end = alloc.end;
 644                                 return 0;
 645                         }
 646                 }
 647
 648 next:           if (!this || this->end == root->end)
 649                         break;
 650
 651                 if (this != old)
 652                         tmp.start = this->end + 1;
 653                 this = this->sibling;
 654         }
 655         return -EBUSY;
 656 }
 657
 658 /*
 659  * Find empty slot in the resource tree given range and alignment.
 660  */
 661 static int find_resource(struct resource *root, struct resource *new,
 662                         resource_size_t size,
 663                         struct resource_constraint  *constraint)
 664 {
 665         return  __find_resource(root, NULL, new, size, constraint);
 666 }
 667
 668 /**
 669  * reallocate_resource - allocate a slot in the resource tree given range & alignment.
 670  *      The resource will be relocated if the new size cannot be reallocated in the
 671  *      current location.
 672  *
 673  * @root: root resource descriptor
 674  * @old:  resource descriptor desired by caller
 675  * @newsize: new size of the resource descriptor
 676  * @constraint: the size and alignment constraints to be met.
 677  */
 678 static int reallocate_resource(struct resource *root, struct resource *old,
 679                                resource_size_t newsize,
 680                                struct resource_constraint *constraint)
 681 {
 682         int err=0;
 683         struct resource new = *old;
 684         struct resource *conflict;
 685
 686         write_lock(&resource_lock);
 687
 688         if ((err = __find_resource(root, old, &new, newsize, constraint)))
 689                 goto out;
 690
 691         if (resource_contains(&new, old)) {
 692                 old->start = new.start;
 693                 old->end = new.end;
 694                 goto out;
 695         }
 696
 697         if (old->child) {
 698                 err = -EBUSY;
 699                 goto out;
 700         }
 701
 702         if (resource_contains(old, &new)) {
 703                 old->start = new.start;
 704                 old->end = new.end;
 705         } else {
 706                 __release_resource(old, true);
 707                 *old = new;
 708                 conflict = __request_resource(root, old);
 709                 BUG_ON(conflict);
 710         }
 711 out:
 712         write_unlock(&resource_lock);
 713         return err;
 714 }
 715
 716
 717 /**
 718  * allocate_resource - allocate empty slot in the resource tree given range & alignment.
 719  *      The resource will be reallocated with a new size if it was already allocated
 720  * @root: root resource descriptor
 721  * @new: resource descriptor desired by caller
 722  * @size: requested resource region size
 723  * @min: minimum boundary to allocate
 724  * @max: maximum boundary to allocate
 725  * @align: alignment requested, in bytes
 726  * @alignf: alignment function, optional, called if not NULL
 727  * @alignf_data: arbitrary data to pass to the @alignf function
 728  */
 729 int allocate_resource(struct resource *root, struct resource *new,
 730                       resource_size_t size, resource_size_t min,
 731                       resource_size_t max, resource_size_t align,
 732                       resource_size_t (*alignf)(void *,
 733                                                 const struct resource *,
 734                                                 resource_size_t,
 735                                                 resource_size_t),
 736                       void *alignf_data)
 737 {
 738         int err;
 739         struct resource_constraint constraint;
 740
 741         if (!alignf)
 742                 alignf = simple_align_resource;
 743
 744         constraint.min = min;
 745         constraint.max = max;
 746         constraint.align = align;
 747         constraint.alignf = alignf;
 748         constraint.alignf_data = alignf_data;
 749
 750         if ( new->parent ) {
 751                 /* resource is already allocated, try reallocating with
 752                    the new constraints */
 753                 return reallocate_resource(root, new, size, &constraint);
 754         }
 755
 756         write_lock(&resource_lock);
 757         err = find_resource(root, new, size, &constraint);
 758         if (err >= 0 && __request_resource(root, new))
 759                 err = -EBUSY;
 760         write_unlock(&resource_lock);
 761         return err;
 762 }
 763
 764 EXPORT_SYMBOL(allocate_resource);
 765
 766 /**
 767  * lookup_resource - find an existing resource by a resource start address
 768  * @root: root resource descriptor
 769  * @start: resource start address
 770  *
 771  * Returns a pointer to the resource if found, NULL otherwise
 772  */
 773 struct resource *lookup_resource(struct resource *root, resource_size_t start)
 774 {
 775         struct resource *res;
 776
 777         read_lock(&resource_lock);
 778         for (res = root->child; res; res = res->sibling) {
 779                 if (res->start == start)
 780                         break;
 781         }
 782         read_unlock(&resource_lock);
 783
 784         return res;
 785 }
 786
 787 /*
 788  * Insert a resource into the resource tree. If successful, return NULL,
 789  * otherwise return the conflicting resource (compare to __request_resource())
 790  */
 791 static struct resource * __insert_resource(struct resource *parent, struct resource *new)
 792 {
 793         struct resource *first, *next;
 794
 795         for (;; parent = first) {
 796                 first = __request_resource(parent, new);
 797                 if (!first)
 798                         return first;
 799
 800                 if (first == parent)
 801                         return first;
 802                 if (WARN_ON(first == new))      /* duplicated insertion */
 803                         return first;
 804
 805                 if ((first->start > new->start) || (first->end < new->end))
 806                         break;
 807                 if ((first->start == new->start) && (first->end == new->end))
 808                         break;
 809         }
 810
 811         for (next = first; ; next = next->sibling) {
 812                 /* Partial overlap? Bad, and unfixable */
 813                 if (next->start < new->start || next->end > new->end)
 814                         return next;
 815                 if (!next->sibling)
 816                         break;
 817                 if (next->sibling->start > new->end)
 818                         break;
 819         }
 820
 821         new->parent = parent;
 822         new->sibling = next->sibling;
 823         new->child = first;
 824
 825         next->sibling = NULL;
 826         for (next = first; next; next = next->sibling)
 827                 next->parent = new;
 828
 829         if (parent->child == first) {
 830                 parent->child = new;
 831         } else {
 832                 next = parent->child;
 833                 while (next->sibling != first)
 834                         next = next->sibling;
 835                 next->sibling = new;
 836         }
 837         return NULL;
 838 }
 839
 840 /**
 841  * insert_resource_conflict - Inserts resource in the resource tree
 842  * @parent: parent of the new resource
 843  * @new: new resource to insert
 844  *
 845  * Returns 0 on success, conflict resource if the resource can't be inserted.
 846  *
 847  * This function is equivalent to request_resource_conflict when no conflict
 848  * happens. If a conflict happens, and the conflicting resources
 849  * entirely fit within the range of the new resource, then the new
 850  * resource is inserted and the conflicting resources become children of
 851  * the new resource.
 852  *
 853  * This function is intended for producers of resources, such as FW modules
 854  * and bus drivers.
 855  */
 856 struct resource *insert_resource_conflict(struct resource *parent, struct resource *new)
 857 {
 858         struct resource *conflict;
 859
 860         write_lock(&resource_lock);
 861         conflict = __insert_resource(parent, new);
 862         write_unlock(&resource_lock);
 863         return conflict;
 864 }
 865
 866 /**
 867  * insert_resource - Inserts a resource in the resource tree
 868  * @parent: parent of the new resource
 869  * @new: new resource to insert
 870  *
 871  * Returns 0 on success, -EBUSY if the resource can't be inserted.
 872  *
 873  * This function is intended for producers of resources, such as FW modules
 874  * and bus drivers.
 875  */
 876 int insert_resource(struct resource *parent, struct resource *new)
 877 {
 878         struct resource *conflict;
 879
 880         conflict = insert_resource_conflict(parent, new);
 881         return conflict ? -EBUSY : 0;
 882 }
 883 EXPORT_SYMBOL_GPL(insert_resource);
 884
 885 /**
 886  * insert_resource_expand_to_fit - Insert a resource into the resource tree
 887  * @root: root resource descriptor
 888  * @new: new resource to insert
 889  *
 890  * Insert a resource into the resource tree, possibly expanding it in order
 891  * to make it encompass any conflicting resources.
 892  */
 893 void insert_resource_expand_to_fit(struct resource *root, struct resource *new)
 894 {
 895         if (new->parent)
 896                 return;
 897
 898         write_lock(&resource_lock);
 899         for (;;) {
 900                 struct resource *conflict;
 901
 902                 conflict = __insert_resource(root, new);
 903                 if (!conflict)
 904                         break;
 905                 if (conflict == root)
 906                         break;
 907
 908                 /* Ok, expand resource to cover the conflict, then try again .. */
 909                 if (conflict->start < new->start)
 910                         new->start = conflict->start;
 911                 if (conflict->end > new->end)
 912                         new->end = conflict->end;
 913
 914                 printk("Expanded resource %s due to conflict with %s\n", new->name, conflict->name);
 915         }
 916         write_unlock(&resource_lock);
 917 }
 918
 919 /**
 920  * remove_resource - Remove a resource in the resource tree
 921  * @old: resource to remove
 922  *
 923  * Returns 0 on success, -EINVAL if the resource is not valid.
 924  *
 925  * This function removes a resource previously inserted by insert_resource()
 926  * or insert_resource_conflict(), and moves the children (if any) up to
 927  * where they were before.  insert_resource() and insert_resource_conflict()
 928  * insert a new resource, and move any conflicting resources down to the
 929  * children of the new resource.
 930  *
 931  * insert_resource(), insert_resource_conflict() and remove_resource() are
 932  * intended for producers of resources, such as FW modules and bus drivers.
 933  */
 934 int remove_resource(struct resource *old)
 935 {
 936         int retval;
 937
 938         write_lock(&resource_lock);
 939         retval = __release_resource(old, false);
 940         write_unlock(&resource_lock);
 941         return retval;
 942 }
 943 EXPORT_SYMBOL_GPL(remove_resource);
 944
 945 static int __adjust_resource(struct resource *res, resource_size_t start,
 946                                 resource_size_t size)
 947 {
 948         struct resource *tmp, *parent = res->parent;
 949         resource_size_t end = start + size - 1;
 950         int result = -EBUSY;
 951
 952         if (!parent)
 953                 goto skip;
 954
 955         if ((start < parent->start) || (end > parent->end))
 956                 goto out;
 957
 958         if (res->sibling && (res->sibling->start <= end))
 959                 goto out;
 960
 961         tmp = parent->child;
 962         if (tmp != res) {
 963                 while (tmp->sibling != res)
 964                         tmp = tmp->sibling;
 965                 if (start <= tmp->end)
 966                         goto out;
 967         }
 968
 969 skip:
 970         for (tmp = res->child; tmp; tmp = tmp->sibling)
 971                 if ((tmp->start < start) || (tmp->end > end))
 972                         goto out;
 973
 974         res->start = start;
 975         res->end = end;
 976         result = 0;
 977
 978  out:
 979         return result;
 980 }
 981
 982 /**
 983  * adjust_resource - modify a resource's start and size
 984  * @res: resource to modify
 985  * @start: new start value
 986  * @size: new size
 987  *
 988  * Given an existing resource, change its start and size to match the
 989  * arguments.  Returns 0 on success, -EBUSY if it can't fit.
 990  * Existing children of the resource are assumed to be immutable.
 991  */
 992 int adjust_resource(struct resource *res, resource_size_t start,
 993                     resource_size_t size)
 994 {
 995         int result;
 996
 997         write_lock(&resource_lock);
 998         result = __adjust_resource(res, start, size);
 999         write_unlock(&resource_lock);
1000         return result;
1001 }
1002 EXPORT_SYMBOL(adjust_resource);
1003
1004 static void __init
1005 __reserve_region_with_split(struct resource *root, resource_size_t start,
1006                             resource_size_t end, const char *name)
1007 {
1008         struct resource *parent = root;
1009         struct resource *conflict;
1010         struct resource *res = alloc_resource(GFP_ATOMIC);
1011         struct resource *next_res = NULL;
1012         int type = resource_type(root);
1013
1014         if (!res)
1015                 return;
1016
1017         res->name = name;
1018         res->start = start;
1019         res->end = end;
1020         res->flags = type | IORESOURCE_BUSY;
1021         res->desc = IORES_DESC_NONE;
1022
1023         while (1) {
1024
1025                 conflict = __request_resource(parent, res);
1026                 if (!conflict) {
1027                         if (!next_res)
1028                                 break;
1029                         res = next_res;
1030                         next_res = NULL;
1031                         continue;
1032                 }
1033
1034                 /* conflict covered whole area */
1035                 if (conflict->start <= res->start &&
1036                                 conflict->end >= res->end) {
1037                         free_resource(res);
1038                         WARN_ON(next_res);
1039                         break;
1040                 }
1041
1042                 /* failed, split and try again */
1043                 if (conflict->start > res->start) {
1044                         end = res->end;
1045                         res->end = conflict->start - 1;
1046                         if (conflict->end < end) {
1047                                 next_res = alloc_resource(GFP_ATOMIC);
1048                                 if (!next_res) {
1049                                         free_resource(res);
1050                                         break;
1051                                 }
1052                                 next_res->name = name;
1053                                 next_res->start = conflict->end + 1;
1054                                 next_res->end = end;
1055                                 next_res->flags = type | IORESOURCE_BUSY;
1056                                 next_res->desc = IORES_DESC_NONE;
1057                         }
1058                 } else {
1059                         res->start = conflict->end + 1;
1060                 }
1061         }
1062
1063 }
1064
1065 void __init
1066 reserve_region_with_split(struct resource *root, resource_size_t start,
1067                           resource_size_t end, const char *name)
1068 {
1069         int abort = 0;
1070
1071         write_lock(&resource_lock);
1072         if (root->start > start || root->end < end) {
1073                 pr_err("requested range [0x%llx-0x%llx] not in root %pr\n",
1074                        (unsigned long long)start, (unsigned long long)end,
1075                        root);
1076                 if (start > root->end || end < root->start)
1077                         abort = 1;
1078                 else {
1079                         if (end > root->end)
1080                                 end = root->end;
1081                         if (start < root->start)
1082                                 start = root->start;
1083                         pr_err("fixing request to [0x%llx-0x%llx]\n",
1084                                (unsigned long long)start,
1085                                (unsigned long long)end);
1086                 }
1087                 dump_stack();
1088         }
1089         if (!abort)
1090                 __reserve_region_with_split(root, start, end, name);
1091         write_unlock(&resource_lock);
1092 }
1093
1094 /**
1095  * resource_alignment - calculate resource's alignment
1096  * @res: resource pointer
1097  *
1098  * Returns alignment on success, 0 (invalid alignment) on failure.
1099  */
1100 resource_size_t resource_alignment(struct resource *res)
1101 {
1102         switch (res->flags & (IORESOURCE_SIZEALIGN | IORESOURCE_STARTALIGN)) {
1103         case IORESOURCE_SIZEALIGN:
1104                 return resource_size(res);
1105         case IORESOURCE_STARTALIGN:
1106                 return res->start;
1107         default:
1108                 return 0;
1109         }
1110 }
1111
1112 /*
1113  * This is compatibility stuff for IO resources.
1114  *
1115  * Note how this, unlike the above, knows about
1116  * the IO flag meanings (busy etc).
1117  *
1118  * request_region creates a new busy region.
1119  *
1120  * release_region releases a matching busy region.
1121  */
1122
1123 static DECLARE_WAIT_QUEUE_HEAD(muxed_resource_wait);
1124
1125 static struct inode *iomem_inode;
1126
1127 #ifdef CONFIG_IO_STRICT_DEVMEM
1128 static void revoke_iomem(struct resource *res)
1129 {
1130         /* pairs with smp_store_release() in iomem_init_inode() */
1131         struct inode *inode = smp_load_acquire(&iomem_inode);
1132
1133         /*
1134          * Check that the initialization has completed. Losing the race
1135          * is ok because it means drivers are claiming resources before
1136          * the fs_initcall level of init and prevent iomem_get_mapping users
1137          * from establishing mappings.
1138          */
1139         if (!inode)
1140                 return;
1141
1142         /*
1143          * The expectation is that the driver has successfully marked
1144          * the resource busy by this point, so devmem_is_allowed()
1145          * should start returning false, however for performance this
1146          * does not iterate the entire resource range.
1147          */
1148         if (devmem_is_allowed(PHYS_PFN(res->start)) &&
1149             devmem_is_allowed(PHYS_PFN(res->end))) {
1150                 /*
1151                  * *cringe* iomem=relaxed says "go ahead, what's the
1152                  * worst that can happen?"
1153                  */
1154                 return;
1155         }
1156
1157         unmap_mapping_range(inode->i_mapping, res->start, resource_size(res), 1);
1158 }
1159 #else
1160 static void revoke_iomem(struct resource *res) {}
1161 #endif
1162
1163 struct address_space *iomem_get_mapping(void)
1164 {
1165         /*
1166          * This function is only called from file open paths, hence guaranteed
1167          * that fs_initcalls have completed and no need to check for NULL. But
1168          * since revoke_iomem can be called before the initcall we still need
1169          * the barrier to appease checkers.
1170          */
1171         return smp_load_acquire(&iomem_inode)->i_mapping;
1172 }
1173
1174 /**
1175  * __request_region - create a new busy resource region
1176  * @parent: parent resource descriptor
1177  * @start: resource start address
1178  * @n: resource region size
1179  * @name: reserving caller's ID string
1180  * @flags: IO resource flags
1181  */
1182 struct resource * __request_region(struct resource *parent,
1183                                    resource_size_t start, resource_size_t n,
1184                                    const char *name, int flags)
1185 {
1186         DECLARE_WAITQUEUE(wait, current);
1187         struct resource *res = alloc_resource(GFP_KERNEL);
1188         struct resource *orig_parent = parent;
1189
1190         if (!res)
1191                 return NULL;
1192
1193         res->name = name;
1194         res->start = start;
1195         res->end = start + n - 1;
1196
1197         write_lock(&resource_lock);
1198
1199         for (;;) {
1200                 struct resource *conflict;
1201
1202                 res->flags = resource_type(parent) | resource_ext_type(parent);
1203                 res->flags |= IORESOURCE_BUSY | flags;
1204                 res->desc = parent->desc;
1205
1206                 conflict = __request_resource(parent, res);
1207                 if (!conflict)
1208                         break;
1209                 /*
1210                  * mm/hmm.c reserves physical addresses which then
1211                  * become unavailable to other users.  Conflicts are
1212                  * not expected.  Warn to aid debugging if encountered.
1213                  */
1214                 if (conflict->desc == IORES_DESC_DEVICE_PRIVATE_MEMORY) {
1215                         pr_warn("Unaddressable device %s %pR conflicts with %pR",
1216                                 conflict->name, conflict, res);
1217                 }
1218                 if (conflict != parent) {
1219                         if (!(conflict->flags & IORESOURCE_BUSY)) {
1220                                 parent = conflict;
1221                                 continue;
1222                         }
1223                 }
1224                 if (conflict->flags & flags & IORESOURCE_MUXED) {
1225                         add_wait_queue(&muxed_resource_wait, &wait);
1226                         write_unlock(&resource_lock);
1227                         set_current_state(TASK_UNINTERRUPTIBLE);
1228                         schedule();
1229                         remove_wait_queue(&muxed_resource_wait, &wait);
1230                         write_lock(&resource_lock);
1231                         continue;
1232                 }
1233                 /* Uhhuh, that didn't work out.. */
1234                 free_resource(res);
1235                 res = NULL;
1236                 break;
1237         }
1238         write_unlock(&resource_lock);
1239
1240         if (res && orig_parent == &iomem_resource)
1241                 revoke_iomem(res);
1242
1243         return res;
1244 }
1245 EXPORT_SYMBOL(__request_region);
1246
1247 /**
1248  * __release_region - release a previously reserved resource region
1249  * @parent: parent resource descriptor
1250  * @start: resource start address
1251  * @n: resource region size
1252  *
1253  * The described resource region must match a currently busy region.
1254  */
1255 void __release_region(struct resource *parent, resource_size_t start,
1256                       resource_size_t n)
1257 {
1258         struct resource **p;
1259         resource_size_t end;
1260
1261         p = &parent->child;
1262         end = start + n - 1;
1263
1264         write_lock(&resource_lock);
1265
1266         for (;;) {
1267                 struct resource *res = *p;
1268
1269                 if (!res)
1270                         break;
1271                 if (res->start <= start && res->end >= end) {
1272                         if (!(res->flags & IORESOURCE_BUSY)) {
1273                                 p = &res->child;
1274                                 continue;
1275                         }
1276                         if (res->start != start || res->end != end)
1277                                 break;
1278                         *p = res->sibling;
1279                         write_unlock(&resource_lock);
1280                         if (res->flags & IORESOURCE_MUXED)
1281                                 wake_up(&muxed_resource_wait);
1282                         free_resource(res);
1283                         return;
1284                 }
1285                 p = &res->sibling;
1286         }
1287
1288         write_unlock(&resource_lock);
1289
1290         printk(KERN_WARNING "Trying to free nonexistent resource "
1291                 "<%016llx-%016llx>\n", (unsigned long long)start,
1292                 (unsigned long long)end);
1293 }
1294 EXPORT_SYMBOL(__release_region);
1295
1296 #ifdef CONFIG_MEMORY_HOTREMOVE
1297 /**
1298  * release_mem_region_adjustable - release a previously reserved memory region
1299  * @start: resource start address
1300  * @size: resource region size
1301  *
1302  * This interface is intended for memory hot-delete.  The requested region
1303  * is released from a currently busy memory resource.  The requested region
1304  * must either match exactly or fit into a single busy resource entry.  In
1305  * the latter case, the remaining resource is adjusted accordingly.
1306  * Existing children of the busy memory resource must be immutable in the
1307  * request.
1308  *
1309  * Note:
1310  * - Additional release conditions, such as overlapping region, can be
1311  *   supported after they are confirmed as valid cases.
1312  * - When a busy memory resource gets split into two entries, the code
1313  *   assumes that all children remain in the lower address entry for
1314  *   simplicity.  Enhance this logic when necessary.
1315  */
1316 void release_mem_region_adjustable(resource_size_t start, resource_size_t size)
1317 {
1318         struct resource *parent = &iomem_resource;
1319         struct resource *new_res = NULL;
1320         bool alloc_nofail = false;
1321         struct resource **p;
1322         struct resource *res;
1323         resource_size_t end;
1324
1325         end = start + size - 1;
1326         if (WARN_ON_ONCE((start < parent->start) || (end > parent->end)))
1327                 return;
1328
1329         /*
1330          * We free up quite a lot of memory on memory hotunplug (esp., memap),
1331          * just before releasing the region. This is highly unlikely to
1332          * fail - let's play save and make it never fail as the caller cannot
1333          * perform any error handling (e.g., trying to re-add memory will fail
1334          * similarly).
1335          */
1336 retry:
1337         new_res = alloc_resource(GFP_KERNEL | (alloc_nofail ? __GFP_NOFAIL : 0));
1338
1339         p = &parent->child;
1340         write_lock(&resource_lock);
1341
1342         while ((res = *p)) {
1343                 if (res->start >= end)
1344                         break;
1345
1346                 /* look for the next resource if it does not fit into */
1347                 if (res->start > start || res->end < end) {
1348                         p = &res->sibling;
1349                         continue;
1350                 }
1351
1352                 /*
1353                  * All memory regions added from memory-hotplug path have the
1354                  * flag IORESOURCE_SYSTEM_RAM. If the resource does not have
1355                  * this flag, we know that we are dealing with a resource coming
1356                  * from HMM/devm. HMM/devm use another mechanism to add/release
1357                  * a resource. This goes via devm_request_mem_region and
1358                  * devm_release_mem_region.
1359                  * HMM/devm take care to release their resources when they want,
1360                  * so if we are dealing with them, let us just back off here.
1361                  */
1362                 if (!(res->flags & IORESOURCE_SYSRAM)) {
1363                         break;
1364                 }
1365
1366                 if (!(res->flags & IORESOURCE_MEM))
1367                         break;
1368
1369                 if (!(res->flags & IORESOURCE_BUSY)) {
1370                         p = &res->child;
1371                         continue;
1372                 }
1373
1374                 /* found the target resource; let's adjust accordingly */
1375                 if (res->start == start && res->end == end) {
1376                         /* free the whole entry */
1377                         *p = res->sibling;
1378                         free_resource(res);
1379                 } else if (res->start == start && res->end != end) {
1380                         /* adjust the start */
1381                         WARN_ON_ONCE(__adjust_resource(res, end + 1,
1382                                                        res->end - end));
1383                 } else if (res->start != start && res->end == end) {
1384                         /* adjust the end */
1385                         WARN_ON_ONCE(__adjust_resource(res, res->start,
1386                                                        start - res->start));
1387                 } else {
1388                         /* split into two entries - we need a new resource */
1389                         if (!new_res) {
1390                                 new_res = alloc_resource(GFP_ATOMIC);
1391                                 if (!new_res) {
1392                                         alloc_nofail = true;
1393                                         write_unlock(&resource_lock);
1394                                         goto retry;
1395                                 }
1396                         }
1397                         new_res->name = res->name;
1398                         new_res->start = end + 1;
1399                         new_res->end = res->end;
1400                         new_res->flags = res->flags;
1401                         new_res->desc = res->desc;
1402                         new_res->parent = res->parent;
1403                         new_res->sibling = res->sibling;
1404                         new_res->child = NULL;
1405
1406                         if (WARN_ON_ONCE(__adjust_resource(res, res->start,
1407                                                            start - res->start)))
1408                                 break;
1409                         res->sibling = new_res;
1410                         new_res = NULL;
1411                 }
1412
1413                 break;
1414         }
1415
1416         write_unlock(&resource_lock);
1417         free_resource(new_res);
1418 }
1419 #endif  /* CONFIG_MEMORY_HOTREMOVE */
1420
1421 #ifdef CONFIG_MEMORY_HOTPLUG
1422 static bool system_ram_resources_mergeable(struct resource *r1,
1423                                            struct resource *r2)
1424 {
1425         /* We assume either r1 or r2 is IORESOURCE_SYSRAM_MERGEABLE. */
1426         return r1->flags == r2->flags && r1->end + 1 == r2->start &&
1427                r1->name == r2->name && r1->desc == r2->desc &&
1428                !r1->child && !r2->child;
1429 }
1430
1431 /**
1432  * merge_system_ram_resource - mark the System RAM resource mergeable and try to
1433  *      merge it with adjacent, mergeable resources
1434  * @res: resource descriptor
1435  *
1436  * This interface is intended for memory hotplug, whereby lots of contiguous
1437  * system ram resources are added (e.g., via add_memory*()) by a driver, and
1438  * the actual resource boundaries are not of interest (e.g., it might be
1439  * relevant for DIMMs). Only resources that are marked mergeable, that have the
1440  * same parent, and that don't have any children are considered. All mergeable
1441  * resources must be immutable during the request.
1442  *
1443  * Note:
1444  * - The caller has to make sure that no pointers to resources that are
1445  *   marked mergeable are used anymore after this call - the resource might
1446  *   be freed and the pointer might be stale!
1447  * - release_mem_region_adjustable() will split on demand on memory hotunplug
1448  */
1449 void merge_system_ram_resource(struct resource *res)
1450 {
1451         const unsigned long flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY;
1452         struct resource *cur;
1453
1454         if (WARN_ON_ONCE((res->flags & flags) != flags))
1455                 return;
1456
1457         write_lock(&resource_lock);
1458         res->flags |= IORESOURCE_SYSRAM_MERGEABLE;
1459
1460         /* Try to merge with next item in the list. */
1461         cur = res->sibling;
1462         if (cur && system_ram_resources_mergeable(res, cur)) {
1463                 res->end = cur->end;
1464                 res->sibling = cur->sibling;
1465                 free_resource(cur);
1466         }
1467
1468         /* Try to merge with previous item in the list. */
1469         cur = res->parent->child;
1470         while (cur && cur->sibling != res)
1471                 cur = cur->sibling;
1472         if (cur && system_ram_resources_mergeable(cur, res)) {
1473                 cur->end = res->end;
1474                 cur->sibling = res->sibling;
1475                 free_resource(res);
1476         }
1477         write_unlock(&resource_lock);
1478 }
1479 #endif  /* CONFIG_MEMORY_HOTPLUG */
1480
1481 /*
1482  * Managed region resource
1483  */
1484 static void devm_resource_release(struct device *dev, void *ptr)
1485 {
1486         struct resource **r = ptr;
1487
1488         release_resource(*r);
1489 }
1490
1491 /**
1492  * devm_request_resource() - request and reserve an I/O or memory resource
1493  * @dev: device for which to request the resource
1494  * @root: root of the resource tree from which to request the resource
1495  * @new: descriptor of the resource to request
1496  *
1497  * This is a device-managed version of request_resource(). There is usually
1498  * no need to release resources requested by this function explicitly since
1499  * that will be taken care of when the device is unbound from its driver.
1500  * If for some reason the resource needs to be released explicitly, because
1501  * of ordering issues for example, drivers must call devm_release_resource()
1502  * rather than the regular release_resource().
1503  *
1504  * When a conflict is detected between any existing resources and the newly
1505  * requested resource, an error message will be printed.
1506  *
1507  * Returns 0 on success or a negative error code on failure.
1508  */
1509 int devm_request_resource(struct device *dev, struct resource *root,
1510                           struct resource *new)
1511 {
1512         struct resource *conflict, **ptr;
1513
1514         ptr = devres_alloc(devm_resource_release, sizeof(*ptr), GFP_KERNEL);
1515         if (!ptr)
1516                 return -ENOMEM;
1517
1518         *ptr = new;
1519
1520         conflict = request_resource_conflict(root, new);
1521         if (conflict) {
1522                 dev_err(dev, "resource collision: %pR conflicts with %s %pR\n",
1523                         new, conflict->name, conflict);
1524                 devres_free(ptr);
1525                 return -EBUSY;
1526         }
1527
1528         devres_add(dev, ptr);
1529         return 0;
1530 }
1531 EXPORT_SYMBOL(devm_request_resource);
1532
1533 static int devm_resource_match(struct device *dev, void *res, void *data)
1534 {
1535         struct resource **ptr = res;
1536
1537         return *ptr == data;
1538 }
1539
1540 /**
1541  * devm_release_resource() - release a previously requested resource
1542  * @dev: device for which to release the resource
1543  * @new: descriptor of the resource to release
1544  *
1545  * Releases a resource previously requested using devm_request_resource().
1546  */
1547 void devm_release_resource(struct device *dev, struct resource *new)
1548 {
1549         WARN_ON(devres_release(dev, devm_resource_release, devm_resource_match,
1550                                new));
1551 }
1552 EXPORT_SYMBOL(devm_release_resource);
1553
1554 struct region_devres {
1555         struct resource *parent;
1556         resource_size_t start;
1557         resource_size_t n;
1558 };
1559
1560 static void devm_region_release(struct device *dev, void *res)
1561 {
1562         struct region_devres *this = res;
1563
1564         __release_region(this->parent, this->start, this->n);
1565 }
1566
1567 static int devm_region_match(struct device *dev, void *res, void *match_data)
1568 {
1569         struct region_devres *this = res, *match = match_data;
1570
1571         return this->parent == match->parent &&
1572                 this->start == match->start && this->n == match->n;
1573 }
1574
1575 struct resource *
1576 __devm_request_region(struct device *dev, struct resource *parent,
1577                       resource_size_t start, resource_size_t n, const char *name)
1578 {
1579         struct region_devres *dr = NULL;
1580         struct resource *res;
1581
1582         dr = devres_alloc(devm_region_release, sizeof(struct region_devres),
1583                           GFP_KERNEL);
1584         if (!dr)
1585                 return NULL;
1586
1587         dr->parent = parent;
1588         dr->start = start;
1589         dr->n = n;
1590
1591         res = __request_region(parent, start, n, name, 0);
1592         if (res)
1593                 devres_add(dev, dr);
1594         else
1595                 devres_free(dr);
1596
1597         return res;
1598 }
1599 EXPORT_SYMBOL(__devm_request_region);
1600
1601 void __devm_release_region(struct device *dev, struct resource *parent,
1602                            resource_size_t start, resource_size_t n)
1603 {
1604         struct region_devres match_data = { parent, start, n };
1605
1606         __release_region(parent, start, n);
1607         WARN_ON(devres_destroy(dev, devm_region_release, devm_region_match,
1608                                &match_data));
1609 }
1610 EXPORT_SYMBOL(__devm_release_region);
1611
1612 /*
1613  * Reserve I/O ports or memory based on "reserve=" kernel parameter.
1614  */
1615 #define MAXRESERVE 4
1616 static int __init reserve_setup(char *str)
1617 {
1618         static int reserved;
1619         static struct resource reserve[MAXRESERVE];
1620
1621         for (;;) {
1622                 unsigned int io_start, io_num;
1623                 int x = reserved;
1624                 struct resource *parent;
1625
1626                 if (get_option(&str, &io_start) != 2)
1627                         break;
1628                 if (get_option(&str, &io_num) == 0)
1629                         break;
1630                 if (x < MAXRESERVE) {
1631                         struct resource *res = reserve + x;
1632
1633                         /*
1634                          * If the region starts below 0x10000, we assume it's
1635                          * I/O port space; otherwise assume it's memory.
1636                          */
1637                         if (io_start < 0x10000) {
1638                                 res->flags = IORESOURCE_IO;
1639                                 parent = &ioport_resource;
1640                         } else {
1641                                 res->flags = IORESOURCE_MEM;
1642                                 parent = &iomem_resource;
1643                         }
1644                         res->name = "reserved";
1645                         res->start = io_start;
1646                         res->end = io_start + io_num - 1;
1647                         res->flags |= IORESOURCE_BUSY;
1648                         res->desc = IORES_DESC_NONE;
1649                         res->child = NULL;
1650                         if (request_resource(parent, res) == 0)
1651                                 reserved = x+1;
1652                 }
1653         }
1654         return 1;
1655 }
1656 __setup("reserve=", reserve_setup);
1657
1658 /*
1659  * Check if the requested addr and size spans more than any slot in the
1660  * iomem resource tree.
1661  */
1662 int iomem_map_sanity_check(resource_size_t addr, unsigned long size)
1663 {
1664         struct resource *p = &iomem_resource;
1665         int err = 0;
1666         loff_t l;
1667
1668         read_lock(&resource_lock);
1669         for (p = p->child; p ; p = r_next(NULL, p, &l)) {
1670                 /*
1671                  * We can probably skip the resources without
1672                  * IORESOURCE_IO attribute?
1673                  */
1674                 if (p->start >= addr + size)
1675                         continue;
1676                 if (p->end < addr)
1677                         continue;
1678                 if (PFN_DOWN(p->start) <= PFN_DOWN(addr) &&
1679                     PFN_DOWN(p->end) >= PFN_DOWN(addr + size - 1))
1680                         continue;
1681                 /*
1682                  * if a resource is "BUSY", it's not a hardware resource
1683                  * but a driver mapping of such a resource; we don't want
1684                  * to warn for those; some drivers legitimately map only
1685                  * partial hardware resources. (example: vesafb)
1686                  */
1687                 if (p->flags & IORESOURCE_BUSY)
1688                         continue;
1689
1690                 printk(KERN_WARNING "resource sanity check: requesting [mem %#010llx-%#010llx], which spans more than %s %pR\n",
1691                        (unsigned long long)addr,
1692                        (unsigned long long)(addr + size - 1),
1693                        p->name, p);
1694                 err = -1;
1695                 break;
1696         }
1697         read_unlock(&resource_lock);
1698
1699         return err;
1700 }
1701
1702 #ifdef CONFIG_STRICT_DEVMEM
1703 static int strict_iomem_checks = 1;
1704 #else
1705 static int strict_iomem_checks;
1706 #endif
1707
1708 /*
1709  * check if an address is reserved in the iomem resource tree
1710  * returns true if reserved, false if not reserved.
1711  */
1712 bool iomem_is_exclusive(u64 addr)
1713 {
1714         struct resource *p = &iomem_resource;
1715         bool err = false;
1716         loff_t l;
1717         int size = PAGE_SIZE;
1718
1719         if (!strict_iomem_checks)
1720                 return false;
1721
1722         addr = addr & PAGE_MASK;
1723
1724         read_lock(&resource_lock);
1725         for (p = p->child; p ; p = r_next(NULL, p, &l)) {
1726                 /*
1727                  * We can probably skip the resources without
1728                  * IORESOURCE_IO attribute?
1729                  */
1730                 if (p->start >= addr + size)
1731                         break;
1732                 if (p->end < addr)
1733                         continue;
1734                 /*
1735                  * A resource is exclusive if IORESOURCE_EXCLUSIVE is set
1736                  * or CONFIG_IO_STRICT_DEVMEM is enabled and the
1737                  * resource is busy.
1738                  */
1739                 if ((p->flags & IORESOURCE_BUSY) == 0)
1740                         continue;
1741                 if (IS_ENABLED(CONFIG_IO_STRICT_DEVMEM)
1742                                 || p->flags & IORESOURCE_EXCLUSIVE) {
1743                         err = true;
1744                         break;
1745                 }
1746         }
1747         read_unlock(&resource_lock);
1748
1749         return err;
1750 }
1751
1752 struct resource_entry *resource_list_create_entry(struct resource *res,
1753                                                   size_t extra_size)
1754 {
1755         struct resource_entry *entry;
1756
1757         entry = kzalloc(sizeof(*entry) + extra_size, GFP_KERNEL);
1758         if (entry) {
1759                 INIT_LIST_HEAD(&entry->node);
1760                 entry->res = res ? res : &entry->__res;
1761         }
1762
1763         return entry;
1764 }
1765 EXPORT_SYMBOL(resource_list_create_entry);
1766
1767 void resource_list_free(struct list_head *head)
1768 {
1769         struct resource_entry *entry, *tmp;
1770
1771         list_for_each_entry_safe(entry, tmp, head, node)
1772                 resource_list_destroy_entry(entry);
1773 }
1774 EXPORT_SYMBOL(resource_list_free);
1775
1776 #ifdef CONFIG_DEVICE_PRIVATE
1777 static struct resource *__request_free_mem_region(struct device *dev,
1778                 struct resource *base, unsigned long size, const char *name)
1779 {
1780         resource_size_t end, addr;
1781         struct resource *res;
1782
1783         size = ALIGN(size, 1UL << PA_SECTION_SHIFT);
1784         end = min_t(unsigned long, base->end, (1UL << MAX_PHYSMEM_BITS) - 1);
1785         addr = end - size + 1UL;
1786
1787         for (; addr > size && addr >= base->start; addr -= size) {
1788                 if (region_intersects(addr, size, 0, IORES_DESC_NONE) !=
1789                                 REGION_DISJOINT)
1790                         continue;
1791
1792                 if (dev)
1793                         res = devm_request_mem_region(dev, addr, size, name);
1794                 else
1795                         res = request_mem_region(addr, size, name);
1796                 if (!res)
1797                         return ERR_PTR(-ENOMEM);
1798                 res->desc = IORES_DESC_DEVICE_PRIVATE_MEMORY;
1799                 return res;
1800         }
1801
1802         return ERR_PTR(-ERANGE);
1803 }
1804
1805 /**
1806  * devm_request_free_mem_region - find free region for device private memory
1807  *
1808  * @dev: device struct to bind the resource to
1809  * @size: size in bytes of the device memory to add
1810  * @base: resource tree to look in
1811  *
1812  * This function tries to find an empty range of physical address big enough to
1813  * contain the new resource, so that it can later be hotplugged as ZONE_DEVICE
1814  * memory, which in turn allocates struct pages.
1815  */
1816 struct resource *devm_request_free_mem_region(struct device *dev,
1817                 struct resource *base, unsigned long size)
1818 {
1819         return __request_free_mem_region(dev, base, size, dev_name(dev));
1820 }
1821 EXPORT_SYMBOL_GPL(devm_request_free_mem_region);
1822
1823 struct resource *request_free_mem_region(struct resource *base,
1824                 unsigned long size, const char *name)
1825 {
1826         return __request_free_mem_region(NULL, base, size, name);
1827 }
1828 EXPORT_SYMBOL_GPL(request_free_mem_region);
1829
1830 #endif /* CONFIG_DEVICE_PRIVATE */
1831
1832 static int __init strict_iomem(char *str)
1833 {
1834         if (strstr(str, "relaxed"))
1835                 strict_iomem_checks = 0;
1836         if (strstr(str, "strict"))
1837                 strict_iomem_checks = 1;
1838         return 1;
1839 }
1840
1841 static int iomem_fs_init_fs_context(struct fs_context *fc)
1842 {
1843         return init_pseudo(fc, DEVMEM_MAGIC) ? 0 : -ENOMEM;
1844 }
1845
1846 static struct file_system_type iomem_fs_type = {
1847         .name           = "iomem",
1848         .owner          = THIS_MODULE,
1849         .init_fs_context = iomem_fs_init_fs_context,
1850         .kill_sb        = kill_anon_super,
1851 };
1852
1853 static int __init iomem_init_inode(void)
1854 {
1855         static struct vfsmount *iomem_vfs_mount;
1856         static int iomem_fs_cnt;
1857         struct inode *inode;
1858         int rc;
1859
1860         rc = simple_pin_fs(&iomem_fs_type, &iomem_vfs_mount, &iomem_fs_cnt);
1861         if (rc < 0) {
1862                 pr_err("Cannot mount iomem pseudo filesystem: %d\n", rc);
1863                 return rc;
1864         }
1865
1866         inode = alloc_anon_inode(iomem_vfs_mount->mnt_sb);
1867         if (IS_ERR(inode)) {
1868                 rc = PTR_ERR(inode);
1869                 pr_err("Cannot allocate inode for iomem: %d\n", rc);
1870                 simple_release_fs(&iomem_vfs_mount, &iomem_fs_cnt);
1871                 return rc;
1872         }
1873
1874         /*
1875          * Publish iomem revocation inode initialized.
1876          * Pairs with smp_load_acquire() in revoke_iomem().
1877          */
1878         smp_store_release(&iomem_inode, inode);
1879
1880         return 0;
1881 }
1882
1883 fs_initcall(iomem_init_inode);
1884
1885 __setup("iomem=", strict_iomem);