Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c0f5ac54 authored by Bjorn Helgaas's avatar Bjorn Helgaas Committed by Jesse Barnes
Browse files

Revert "resources: support allocating space within a region from the top down" 



This reverts commit e7f8567d.

Acked-by: default avatarH. Peter Anvin <hpa@zytor.com>
Signed-off-by: default avatarBjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: default avatarJesse Barnes <jbarnes@virtuousgeek.org>
parent 6db45b76

Documentation/kernel-parameters.txt

+0 −5
Original line number Diff line number Diff line
@@ -2175,11 +2175,6 @@ and is between 256 and 4096 characters. It is defined in the file 
	reset_devices	[KNL] Force drivers to reset the underlying device

			during initialization.



	resource_alloc_from_bottom

			Allocate new resources from the beginning of available

			space, not the end.  If you need to use this, please

			report a bug.



	resume=		[SWSUSP]

			Specify the partition device for software suspend

include/linux/ioport.h

+0 −1
Original line number Diff line number Diff line
@@ -112,7 +112,6 @@ struct resource_list { 
/* PC/ISA/whatever - the normal PC address spaces: IO and memory */

extern struct resource ioport_resource;

extern struct resource iomem_resource;

extern int resource_alloc_from_bottom;



extern struct resource *request_resource_conflict(struct resource *root, struct resource *new);

extern int request_resource(struct resource *root, struct resource *new);

kernel/resource.c

+4 −94
Original line number Diff line number Diff line
@@ -40,23 +40,6 @@ EXPORT_SYMBOL(iomem_resource); 


static DEFINE_RWLOCK(resource_lock);



/*

 * By default, we allocate free space bottom-up.  The architecture can request

 * top-down by clearing this flag.  The user can override the architecture's

 * choice with the "resource_alloc_from_bottom" kernel boot option, but that

 * should only be a debugging tool.

 */

int resource_alloc_from_bottom = 1;



static __init int setup_alloc_from_bottom(char *s)

{

	printk(KERN_INFO

	       "resource: allocating from bottom-up; please report a bug\n");

	resource_alloc_from_bottom = 1;

	return 0;

}

early_param("resource_alloc_from_bottom", setup_alloc_from_bottom);



static void *r_next(struct seq_file *m, void *v, loff_t *pos)

{

	struct resource *p = v;
@@ -396,75 +379,8 @@ static bool resource_contains(struct resource *res1, struct resource *res2) 
	return res1->start <= res2->start && res1->end >= res2->end;

}



/*

 * Find the resource before "child" in the sibling list of "root" children.

 */

static struct resource *find_sibling_prev(struct resource *root, struct resource *child)

{

	struct resource *this;



	for (this = root->child; this; this = this->sibling)

		if (this->sibling == child)

			return this;



	return NULL;

}



/*

 * Find empty slot in the resource tree given range and alignment.

 * This version allocates from the end of the root resource first.

 */

static int find_resource_from_top(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)

{

	struct resource *this;

	struct resource tmp, avail, alloc;



	tmp.start = root->end;

	tmp.end = root->end;



	this = find_sibling_prev(root, NULL);

	for (;;) {

		if (this) {

			if (this->end < root->end)

				tmp.start = this->end + 1;

		} else

			tmp.start = root->start;



		resource_clip(&tmp, min, max);



		/* Check for overflow after ALIGN() */

		avail = *new;

		avail.start = ALIGN(tmp.start, align);

		avail.end = tmp.end;

		if (avail.start >= tmp.start) {

			alloc.start = alignf(alignf_data, &avail, size, align);

			alloc.end = alloc.start + size - 1;

			if (resource_contains(&avail, &alloc)) {

				new->start = alloc.start;

				new->end = alloc.end;

				return 0;

			}

		}



		if (!this || this->start == root->start)

			break;



		tmp.end = this->start - 1;

		this = find_sibling_prev(root, this);

	}

	return -EBUSY;

}



/*

 * Find empty slot in the resource tree given range and alignment.

 * This version allocates from the beginning of the root resource first.

 */

static int find_resource(struct resource *root, struct resource *new,

			 resource_size_t size, resource_size_t min,
@@ -480,9 +396,8 @@ static int find_resource(struct resource *root, struct resource *new, 


	tmp.start = root->start;

	/*

	 * Skip past an allocated resource that starts at 0, since the

	 * assignment of this->start - 1 to tmp->end below would cause an

	 * underflow.

	 * Skip past an allocated resource that starts at 0, since the assignment

	 * of this->start - 1 to tmp->end below would cause an underflow.

	 */

	if (this && this->start == 0) {

		tmp.start = this->end + 1;
@@ -509,10 +424,8 @@ static int find_resource(struct resource *root, struct resource *new, 
				return 0;

			}

		}



		if (!this)

			break;



		tmp.start = this->end + 1;

		this = this->sibling;

	}
@@ -545,10 +458,7 @@ int allocate_resource(struct resource *root, struct resource *new, 
		alignf = simple_align_resource;



	write_lock(&resource_lock);

	if (resource_alloc_from_bottom)

	err = find_resource(root, new, size, min, max, align, alignf, alignf_data);

	else

		err = find_resource_from_top(root, new, size, min, max, align, alignf, alignf_data);

	if (err >= 0 && __request_resource(root, new))

		err = -EBUSY;

	write_unlock(&resource_lock);