Subject: [PATCH] resources: Add probe_resource() It is changed from busn_res only version, because Bjorn found that version was not holding resource_lock. Even it may be ok for busn_res not holding resource_lock. It would be better to have it to be generic and use lock and we would use it for other resources. probe_resource() will try to find specified size or more in parent bus. If can not find current parent resource, and it will try to expand parents top. If still can not find that specified on top, it will try to reduce target size until find one. It will return 0, if it find any resource that it could use. Returned resource already register in the tree. So caller may still need call replace_resource to put real resource in the tree. Signed-off-by: Yinghai Lu Cc: Andrew Morton --- include/linux/ioport.h | 7 ++ kernel/resource.c | 157 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 164 insertions(+) Index: linux-2.6/include/linux/ioport.h =================================================================== --- linux-2.6.orig/include/linux/ioport.h +++ linux-2.6/include/linux/ioport.h @@ -158,6 +158,13 @@ extern int allocate_resource(struct reso resource_size_t, resource_size_t), void *alignf_data); +void resource_shrink_parents_top(struct resource *b_res, + long size, struct resource *parent_res); +struct device; +int probe_resource(struct resource *b_res, + struct device *dev, struct resource *busn_res, + resource_size_t needed_size, struct resource **p, + int skip_nr, int limit, char *name); struct resource *lookup_resource(struct resource *root, resource_size_t start); int adjust_resource(struct resource *res, resource_size_t start, resource_size_t size); Index: linux-2.6/kernel/resource.c =================================================================== --- linux-2.6.orig/kernel/resource.c +++ linux-2.6/kernel/resource.c @@ -1024,6 +1024,163 @@ void __release_region(struct resource *p } EXPORT_SYMBOL(__release_region); +static void __resource_update_parents_top(struct resource *b_res, + long size, struct resource *parent_res) +{ + struct resource *res = b_res; + + if (!size) + return; + + while (res) { + if (res == parent_res) + break; + res->end += size; + res = res->parent; + } +} + +static void __resource_extend_parents_top(struct resource *b_res, + long size, struct resource *parent_res) +{ + __resource_update_parents_top(b_res, size, parent_res); +} + +void resource_shrink_parents_top(struct resource *b_res, + long size, struct resource *parent_res) +{ + write_lock(&resource_lock); + __resource_update_parents_top(b_res, -size, parent_res); + write_unlock(&resource_lock); +} + +static resource_size_t __find_res_top_free_size(struct resource *res, + int skip_nr) +{ + resource_size_t n_size; + struct resource tmp_res; + + /* + * find out free number below res->end that we can use. + * res->start to res->start + skip_nr - 1 can not be used. + */ + n_size = resource_size(res); + if (n_size <= skip_nr) + return 0; + + n_size -= skip_nr; + memset(&tmp_res, 0, sizeof(struct resource)); + while (n_size > 0) { + int ret; + + ret = __allocate_resource(res, &tmp_res, n_size, + res->end - n_size + skip_nr, res->end, + 1, NULL, NULL, false); + if (ret == 0) { + __release_resource(&tmp_res); + break; + } + n_size--; + } + + return n_size; +} + +/** + * probe_resource - Probe resource in parent resource. + * @b_res: parent resource descriptor + * @dev: debug purpose + * @busn_res: return probed resource + * @needed_size: target size + * @p: pointer to farest parent that we extend the top + * @skip_nr: number in b_res start that we need to skip. + * @limit: local boundary + * @name: debug purpose + * + * will try to allocate resource in b_res, if can not find the range + * will try to extend parent resources' top. + * if still can not make it, will reduce needed_size. + */ +int probe_resource(struct resource *b_res, + struct device *dev, struct resource *busn_res, + resource_size_t needed_size, struct resource **p, + int skip_nr, int limit, char *name) +{ + int ret = -ENOMEM; + resource_size_t n_size; + struct resource *parent_res = NULL; + resource_size_t tmp = b_res->end + 1; + +again: + /* + * We first try to allocate biggest range in b_res that + * we can use in b_res directly. + * we can not use skip_nr from start of b_res. + */ + n_size = resource_size(b_res); + if (n_size > skip_nr) + n_size -= skip_nr; + else + n_size = 0; + memset(busn_res, 0, sizeof(struct resource)); + dev_printk(KERN_DEBUG, dev, "find free %s in res: %pR\n", name, b_res); + while (n_size >= needed_size) { + ret = allocate_resource(b_res, busn_res, n_size, + b_res->start + skip_nr, b_res->end, + 1, NULL, NULL); + if (!ret) + return ret; + n_size--; + } + + /* We need to extend the top of parent resources to meet needed_size */ + + /* find out free range under top at first */ + write_lock(&resource_lock); + n_size = __find_res_top_free_size(b_res, skip_nr); + dev_printk(KERN_DEBUG, dev, "found free %s %ld in res: %pR top\n", + name, (unsigned long)n_size, b_res); + /* can not extend cross local boundary */ + if ((limit - b_res->end) < (needed_size - n_size)) + goto reduce_needed_size; + + /* Probe extended range above top */ + memset(busn_res, 0, sizeof(struct resource)); + parent_res = b_res->parent; + while (parent_res) { + ret = __allocate_resource(parent_res, busn_res, + needed_size - n_size, + tmp, tmp + needed_size - n_size - 1, + 1, NULL, NULL, false); + if (!ret) { + /* save parent_res, we need it as stopper later */ + *p = parent_res; + + /* prepare busn_res for return */ + __release_resource(busn_res); + busn_res->start -= n_size; + + /* extend parent resources top*/ + __resource_extend_parents_top(b_res, + needed_size - n_size, parent_res); + __request_resource(b_res, busn_res); + + write_unlock(&resource_lock); + return ret; + } + parent_res = parent_res->parent; + } + +reduce_needed_size: + write_unlock(&resource_lock); + /* ret must not be 0 here */ + needed_size--; + if (needed_size) + goto again; + + return ret; +} + /* * Managed region resource */