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