1 files changed, 84 insertions, 44 deletions

diff --git a/kernel/resource.c b/kernel/resource.c
index e3080fcc66a3..9db38a1a7520 100644
--- a/kernel/resource.c
+++ b/kernel/resource.c
@@ -7,7 +7,6 @@
  * Arbitrary resource management.
  */
 
-#include <linux/config.h>
 #include <linux/module.h>
 #include <linux/sched.h>
 #include <linux/errno.h>
@@ -23,20 +22,18 @@
 
 struct resource ioport_resource = {
         .name   = "PCI IO",
-        .start  = 0x0000,
+        .start  = 0,
         .end    = IO_SPACE_LIMIT,
         .flags  = IORESOURCE_IO,
 };
-
 EXPORT_SYMBOL(ioport_resource);
 
 struct resource iomem_resource = {
         .name   = "PCI mem",
-        .start  = 0UL,
-        .end    = ~0UL,
+        .start  = 0,
+        .end    = -1,
         .flags  = IORESOURCE_MEM,
 };
-
 EXPORT_SYMBOL(iomem_resource);
 
 static DEFINE_RWLOCK(resource_lock);
@@ -83,10 +80,10 @@ static int r_show(struct seq_file *m, void *v)
         for (depth = 0, p = r; depth < MAX_IORES_LEVEL; depth++, p = p->parent)
                 if (p->parent == root)
                         break;
-        seq_printf(m, "%*s%0*lx-%0*lx : %s\n",
+        seq_printf(m, "%*s%0*llx-%0*llx : %s\n",
                         depth * 2, "",
-                        width, r->start,
-                        width, r->end,
+                        width, (unsigned long long) r->start,
+                        width, (unsigned long long) r->end,
                         r->name ? r->name : "<BAD>");
         return 0;
 }
@@ -151,8 +148,8 @@ __initcall(ioresources_init);
 /* Return the conflict entry if you can't request it */
 static struct resource * __request_resource(struct resource *root, struct resource *new)
 {
-        unsigned long start = new->start;
-        unsigned long end = new->end;
+        resource_size_t start = new->start;
+        resource_size_t end = new->end;
         struct resource *tmp, **p;
 
         if (end < start)
@@ -232,15 +229,55 @@ int release_resource(struct resource *old)
 
 EXPORT_SYMBOL(release_resource);
 
+#ifdef CONFIG_MEMORY_HOTPLUG
+/*
+ * Finds the lowest memory reosurce exists within [res->start.res->end)
+ * the caller must specify res->start, res->end, res->flags.
+ * If found, returns 0, res is overwritten, if not found, returns -1.
+ */
+int find_next_system_ram(struct resource *res)
+{
+        resource_size_t start, end;
+        struct resource *p;
+
+        BUG_ON(!res);
+
+        start = res->start;
+        end = res->end;
+        BUG_ON(start >= end);
+
+        read_lock(&resource_lock);
+        for (p = iomem_resource.child; p ; p = p->sibling) {
+                /* system ram is just marked as IORESOURCE_MEM */
+                if (p->flags != res->flags)
+                        continue;
+                if (p->start > end) {
+                        p = NULL;
+                        break;
+                }
+                if ((p->end >= start) && (p->start < end))
+                        break;
+        }
+        read_unlock(&resource_lock);
+        if (!p)
+                return -1;
+        /* copy data */
+        if (res->start < p->start)
+                res->start = p->start;
+        if (res->end > p->end)
+                res->end = p->end;
+        return 0;
+}
+#endif
+
 /*
  * Find empty slot in the resource tree given range and alignment.
  */
 static int find_resource(struct resource *root, struct resource *new,
-                         unsigned long size,
-                         unsigned long min, unsigned long max,
-                         unsigned long align,
+                         resource_size_t size, resource_size_t min,
+                         resource_size_t max, resource_size_t align,
                          void (*alignf)(void *, struct resource *,
-                                        unsigned long, unsigned long),
+                                        resource_size_t, resource_size_t),
                          void *alignf_data)
 {
         struct resource *this = root->child;
@@ -282,11 +319,10 @@ static int find_resource(struct resource *root, struct resource *new,
  * Allocate empty slot in the resource tree given range and alignment.
  */
 int allocate_resource(struct resource *root, struct resource *new,
-                      unsigned long size,
-                      unsigned long min, unsigned long max,
-                      unsigned long align,
+                      resource_size_t size, resource_size_t min,
+                      resource_size_t max, resource_size_t align,
                       void (*alignf)(void *, struct resource *,
-                                     unsigned long, unsigned long),
+                                     resource_size_t, resource_size_t),
                       void *alignf_data)
 {
         int err;
@@ -308,12 +344,11 @@ EXPORT_SYMBOL(allocate_resource);
  *
  * Returns 0 on success, -EBUSY if the resource can't be inserted.
  *
- * This function is equivalent of request_resource when no conflict
+ * This function is equivalent to request_resource when no conflict
  * happens. If a conflict happens, and the conflicting resources
  * entirely fit within the range of the new resource, then the new
- * resource is inserted and the conflicting resources become childs of
- * the new resource.  Otherwise the new resource becomes the child of
- * the conflicting resource
+ * resource is inserted and the conflicting resources become children of
+ * the new resource.
  */
 int insert_resource(struct resource *parent, struct resource *new)
 {
@@ -321,20 +356,21 @@ int insert_resource(struct resource *parent, struct resource *new)
         struct resource *first, *next;
 
         write_lock(&resource_lock);
- begin:
-        result = 0;
-        first = __request_resource(parent, new);
-        if (!first)
-                goto out;
 
-        result = -EBUSY;
-        if (first == parent)
-                goto out;
+        for (;; parent = first) {
+                result = 0;
+                first = __request_resource(parent, new);
+                if (!first)
+                        goto out;
+
+                result = -EBUSY;
+                if (first == parent)
+                        goto out;
 
-        /* Resource fully contained by the clashing resource? Recurse into it */
-        if (first->start <= new->start && first->end >= new->end) {
-                parent = first;
-                goto begin;
+                if ((first->start > new->start) || (first->end < new->end))
+                        break;
+                if ((first->start == new->start) && (first->end == new->end))
+                        break;
         }
 
         for (next = first; ; next = next->sibling) {
@@ -371,17 +407,15 @@ int insert_resource(struct resource *parent, struct resource *new)
         return result;
 }
 
-EXPORT_SYMBOL(insert_resource);
-
 /*
  * Given an existing resource, change its start and size to match the
  * arguments.  Returns -EBUSY if it can't fit.  Existing children of
  * the resource are assumed to be immutable.
  */
-int adjust_resource(struct resource *res, unsigned long start, unsigned long size)
+int adjust_resource(struct resource *res, resource_size_t start, resource_size_t size)
 {
         struct resource *tmp, *parent = res->parent;
-        unsigned long end = start + size - 1;
+        resource_size_t end = start + size - 1;
         int result = -EBUSY;
 
         write_lock(&resource_lock);
@@ -428,7 +462,9 @@ EXPORT_SYMBOL(adjust_resource);
  *
  * Release-region releases a matching busy region.
  */
-struct resource * __request_region(struct resource *parent, unsigned long start, unsigned long n, const char *name)
+struct resource * __request_region(struct resource *parent,
+                                   resource_size_t start, resource_size_t n,
+                                   const char *name)
 {
         struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL);
 
@@ -464,7 +500,8 @@ struct resource * __request_region(struct resource *parent, unsigned long start,
 
 EXPORT_SYMBOL(__request_region);
 
-int __check_region(struct resource *parent, unsigned long start, unsigned long n)
+int __check_region(struct resource *parent, resource_size_t start,
+                        resource_size_t n)
 {
         struct resource * res;
 
@@ -479,10 +516,11 @@ int __check_region(struct resource *parent, unsigned long start, unsigned long n
 
 EXPORT_SYMBOL(__check_region);
 
-void __release_region(struct resource *parent, unsigned long start, unsigned long n)
+void __release_region(struct resource *parent, resource_size_t start,
+                        resource_size_t n)
 {
         struct resource **p;
-        unsigned long end;
+        resource_size_t end;
 
         p = &parent->child;
         end = start + n - 1;
@@ -511,7 +549,9 @@ void __release_region(struct resource *parent, unsigned long start, unsigned lon
 
         write_unlock(&resource_lock);
 
-        printk(KERN_WARNING "Trying to free nonexistent resource <%08lx-%08lx>\n", start, end);
+        printk(KERN_WARNING "Trying to free nonexistent resource "
+                "<%016llx-%016llx>\n", (unsigned long long)start,
+                (unsigned long long)end);
 }
 
 EXPORT_SYMBOL(__release_region);