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