2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* linux/kernel/resource.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 1999 Linus Torvalds
|
|
|
|
* Copyright (C) 1999 Martin Mares <mj@ucw.cz>
|
|
|
|
*
|
|
|
|
* Arbitrary resource management.
|
|
|
|
*/
|
|
|
|
|
2012-07-30 15:42:58 -06:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2011-05-23 12:51:41 -06:00
|
|
|
#include <linux/export.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/ioport.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/proc_fs.h>
|
2010-03-29 11:38:00 -06:00
|
|
|
#include <linux/sched.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/seq_file.h>
|
devres: device resource management
Implement device resource management, in short, devres. A device
driver can allocate arbirary size of devres data which is associated
with a release function. On driver detach, release function is
invoked on the devres data, then, devres data is freed.
devreses are typed by associated release functions. Some devreses are
better represented by single instance of the type while others need
multiple instances sharing the same release function. Both usages are
supported.
devreses can be grouped using devres group such that a device driver
can easily release acquired resources halfway through initialization
or selectively release resources (e.g. resources for port 1 out of 4
ports).
This patch adds devres core including documentation and the following
managed interfaces.
* alloc/free : devm_kzalloc(), devm_kzfree()
* IO region : devm_request_region(), devm_release_region()
* IRQ : devm_request_irq(), devm_free_irq()
* DMA : dmam_alloc_coherent(), dmam_free_coherent(),
dmam_declare_coherent_memory(), dmam_pool_create(),
dmam_pool_destroy()
* PCI : pcim_enable_device(), pcim_pin_device(), pci_is_managed()
* iomap : devm_ioport_map(), devm_ioport_unmap(), devm_ioremap(),
devm_ioremap_nocache(), devm_iounmap(), pcim_iomap_table(),
pcim_iomap(), pcim_iounmap()
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-01-20 00:00:26 -07:00
|
|
|
#include <linux/device.h>
|
2008-10-28 12:45:42 -06:00
|
|
|
#include <linux/pfn.h>
|
mem hotunplug: fix kfree() of bootmem memory
When hot removing memory presented at boot time, following messages are shown:
kernel BUG at mm/slub.c:3409!
invalid opcode: 0000 [#1] SMP
Modules linked in: ebtable_nat ebtables xt_CHECKSUM iptable_mangle bridge stp llc ipmi_devintf ipmi_msghandler sunrpc ipt_REJECT nf_conntrack_ipv4 nf_defrag_ipv4 iptable_filter ip_tables ip6t_REJECT nf_conntrack_ipv6 nf_defrag_ipv6 xt_state nf_conntrack ip6table_filter ip6_tables binfmt_misc vfat fat dm_mirror dm_region_hash dm_log dm_mod vhost_net macvtap macvlan tun uinput iTCO_wdt iTCO_vendor_support coretemp kvm_intel kvm crc32c_intel ghash_clmulni_intel microcode pcspkr sg i2c_i801 lpc_ich mfd_core igb i2c_algo_bit i2c_core e1000e ptp pps_core tpm_infineon ioatdma dca sr_mod cdrom sd_mod crc_t10dif usb_storage megaraid_sas lpfc scsi_transport_fc scsi_tgt scsi_mod
CPU 0
Pid: 5091, comm: kworker/0:2 Tainted: G W 3.9.0-rc6+ #15
RIP: kfree+0x232/0x240
Process kworker/0:2 (pid: 5091, threadinfo ffff88084678c000, task ffff88083928ca80)
Call Trace:
__release_region+0xd4/0xe0
__remove_pages+0x52/0x110
arch_remove_memory+0x89/0xd0
remove_memory+0xc4/0x100
acpi_memory_device_remove+0x6d/0xb1
acpi_device_remove+0x89/0xab
__device_release_driver+0x7c/0xf0
device_release_driver+0x2f/0x50
acpi_bus_device_detach+0x6c/0x70
acpi_ns_walk_namespace+0x11a/0x250
acpi_walk_namespace+0xee/0x137
acpi_bus_trim+0x33/0x7a
acpi_bus_hot_remove_device+0xc4/0x1a1
acpi_os_execute_deferred+0x27/0x34
process_one_work+0x1f7/0x590
worker_thread+0x11a/0x370
kthread+0xee/0x100
ret_from_fork+0x7c/0xb0
RIP [<ffffffff811c41d2>] kfree+0x232/0x240
RSP <ffff88084678d968>
The reason why the messages are shown is to release a resource
structure, allocated by bootmem, by kfree(). So when we release a
resource structure, we should check whether it is allocated by bootmem
or not.
But even if we know a resource structure is allocated by bootmem, we
cannot release it since SLxB cannot treat it. So for reusing a resource
structure, this patch remembers it by using bootmem_resource as follows:
When releasing a resource structure by free_resource(), free_resource()
checks whether the resource structure is allocated by bootmem or not.
If it is allocated by bootmem, free_resource() adds it to
bootmem_resource. If it is not allocated by bootmem, free_resource()
release it by kfree().
And when getting a new resource structure by get_resource(),
get_resource() checks whether bootmem_resource has released resource
structures or not. If there is a released resource structure,
get_resource() returns it. If there is not a releaed resource
structure, get_resource() returns new resource structure allocated by
kzalloc().
[akpm@linux-foundation.org: s/get_resource/alloc_resource/]
Signed-off-by: Yasuaki Ishimatsu <isimatu.yasuaki@jp.fujitsu.com>
Reviewed-by: Toshi Kani <toshi.kani@hp.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Ram Pai <linuxram@us.ibm.com>
Cc: David Rientjes <rientjes@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-04-29 16:08:56 -06:00
|
|
|
#include <linux/mm.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <asm/io.h>
|
|
|
|
|
|
|
|
|
|
|
|
struct resource ioport_resource = {
|
|
|
|
.name = "PCI IO",
|
2006-06-12 18:11:31 -06:00
|
|
|
.start = 0,
|
2005-04-16 16:20:36 -06:00
|
|
|
.end = IO_SPACE_LIMIT,
|
|
|
|
.flags = IORESOURCE_IO,
|
|
|
|
};
|
|
|
|
EXPORT_SYMBOL(ioport_resource);
|
|
|
|
|
|
|
|
struct resource iomem_resource = {
|
|
|
|
.name = "PCI mem",
|
2006-06-12 18:11:31 -06:00
|
|
|
.start = 0,
|
|
|
|
.end = -1,
|
2005-04-16 16:20:36 -06:00
|
|
|
.flags = IORESOURCE_MEM,
|
|
|
|
};
|
|
|
|
EXPORT_SYMBOL(iomem_resource);
|
|
|
|
|
2011-07-06 00:44:30 -06:00
|
|
|
/* constraints to be met while allocating resources */
|
|
|
|
struct resource_constraint {
|
|
|
|
resource_size_t min, max, align;
|
|
|
|
resource_size_t (*alignf)(void *, const struct resource *,
|
|
|
|
resource_size_t, resource_size_t);
|
|
|
|
void *alignf_data;
|
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static DEFINE_RWLOCK(resource_lock);
|
|
|
|
|
mem hotunplug: fix kfree() of bootmem memory
When hot removing memory presented at boot time, following messages are shown:
kernel BUG at mm/slub.c:3409!
invalid opcode: 0000 [#1] SMP
Modules linked in: ebtable_nat ebtables xt_CHECKSUM iptable_mangle bridge stp llc ipmi_devintf ipmi_msghandler sunrpc ipt_REJECT nf_conntrack_ipv4 nf_defrag_ipv4 iptable_filter ip_tables ip6t_REJECT nf_conntrack_ipv6 nf_defrag_ipv6 xt_state nf_conntrack ip6table_filter ip6_tables binfmt_misc vfat fat dm_mirror dm_region_hash dm_log dm_mod vhost_net macvtap macvlan tun uinput iTCO_wdt iTCO_vendor_support coretemp kvm_intel kvm crc32c_intel ghash_clmulni_intel microcode pcspkr sg i2c_i801 lpc_ich mfd_core igb i2c_algo_bit i2c_core e1000e ptp pps_core tpm_infineon ioatdma dca sr_mod cdrom sd_mod crc_t10dif usb_storage megaraid_sas lpfc scsi_transport_fc scsi_tgt scsi_mod
CPU 0
Pid: 5091, comm: kworker/0:2 Tainted: G W 3.9.0-rc6+ #15
RIP: kfree+0x232/0x240
Process kworker/0:2 (pid: 5091, threadinfo ffff88084678c000, task ffff88083928ca80)
Call Trace:
__release_region+0xd4/0xe0
__remove_pages+0x52/0x110
arch_remove_memory+0x89/0xd0
remove_memory+0xc4/0x100
acpi_memory_device_remove+0x6d/0xb1
acpi_device_remove+0x89/0xab
__device_release_driver+0x7c/0xf0
device_release_driver+0x2f/0x50
acpi_bus_device_detach+0x6c/0x70
acpi_ns_walk_namespace+0x11a/0x250
acpi_walk_namespace+0xee/0x137
acpi_bus_trim+0x33/0x7a
acpi_bus_hot_remove_device+0xc4/0x1a1
acpi_os_execute_deferred+0x27/0x34
process_one_work+0x1f7/0x590
worker_thread+0x11a/0x370
kthread+0xee/0x100
ret_from_fork+0x7c/0xb0
RIP [<ffffffff811c41d2>] kfree+0x232/0x240
RSP <ffff88084678d968>
The reason why the messages are shown is to release a resource
structure, allocated by bootmem, by kfree(). So when we release a
resource structure, we should check whether it is allocated by bootmem
or not.
But even if we know a resource structure is allocated by bootmem, we
cannot release it since SLxB cannot treat it. So for reusing a resource
structure, this patch remembers it by using bootmem_resource as follows:
When releasing a resource structure by free_resource(), free_resource()
checks whether the resource structure is allocated by bootmem or not.
If it is allocated by bootmem, free_resource() adds it to
bootmem_resource. If it is not allocated by bootmem, free_resource()
release it by kfree().
And when getting a new resource structure by get_resource(),
get_resource() checks whether bootmem_resource has released resource
structures or not. If there is a released resource structure,
get_resource() returns it. If there is not a releaed resource
structure, get_resource() returns new resource structure allocated by
kzalloc().
[akpm@linux-foundation.org: s/get_resource/alloc_resource/]
Signed-off-by: Yasuaki Ishimatsu <isimatu.yasuaki@jp.fujitsu.com>
Reviewed-by: Toshi Kani <toshi.kani@hp.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Ram Pai <linuxram@us.ibm.com>
Cc: David Rientjes <rientjes@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-04-29 16:08:56 -06:00
|
|
|
/*
|
|
|
|
* For memory hotplug, there is no way to free resource entries allocated
|
|
|
|
* by boot mem after the system is up. So for reusing the resource entry
|
|
|
|
* we need to remember the resource.
|
|
|
|
*/
|
|
|
|
static struct resource *bootmem_resource_free;
|
|
|
|
static DEFINE_SPINLOCK(bootmem_resource_lock);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static void *r_next(struct seq_file *m, void *v, loff_t *pos)
|
|
|
|
{
|
|
|
|
struct resource *p = v;
|
|
|
|
(*pos)++;
|
|
|
|
if (p->child)
|
|
|
|
return p->child;
|
|
|
|
while (!p->sibling && p->parent)
|
|
|
|
p = p->parent;
|
|
|
|
return p->sibling;
|
|
|
|
}
|
|
|
|
|
2008-09-26 02:10:12 -06:00
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
|
|
|
|
enum { MAX_IORES_LEVEL = 5 };
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static void *r_start(struct seq_file *m, loff_t *pos)
|
|
|
|
__acquires(resource_lock)
|
|
|
|
{
|
|
|
|
struct resource *p = m->private;
|
|
|
|
loff_t l = 0;
|
|
|
|
read_lock(&resource_lock);
|
|
|
|
for (p = p->child; p && l < *pos; p = r_next(m, p, &l))
|
|
|
|
;
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void r_stop(struct seq_file *m, void *v)
|
|
|
|
__releases(resource_lock)
|
|
|
|
{
|
|
|
|
read_unlock(&resource_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int r_show(struct seq_file *m, void *v)
|
|
|
|
{
|
|
|
|
struct resource *root = m->private;
|
|
|
|
struct resource *r = v, *p;
|
|
|
|
int width = root->end < 0x10000 ? 4 : 8;
|
|
|
|
int depth;
|
|
|
|
|
|
|
|
for (depth = 0, p = r; depth < MAX_IORES_LEVEL; depth++, p = p->parent)
|
|
|
|
if (p->parent == root)
|
|
|
|
break;
|
2006-06-12 16:18:31 -06:00
|
|
|
seq_printf(m, "%*s%0*llx-%0*llx : %s\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
depth * 2, "",
|
2006-06-12 16:18:31 -06:00
|
|
|
width, (unsigned long long) r->start,
|
|
|
|
width, (unsigned long long) r->end,
|
2005-04-16 16:20:36 -06:00
|
|
|
r->name ? r->name : "<BAD>");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-12-06 21:40:36 -07:00
|
|
|
static const struct seq_operations resource_op = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.start = r_start,
|
|
|
|
.next = r_next,
|
|
|
|
.stop = r_stop,
|
|
|
|
.show = r_show,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int ioports_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
int res = seq_open(file, &resource_op);
|
|
|
|
if (!res) {
|
|
|
|
struct seq_file *m = file->private_data;
|
|
|
|
m->private = &ioport_resource;
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int iomem_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
int res = seq_open(file, &resource_op);
|
|
|
|
if (!res) {
|
|
|
|
struct seq_file *m = file->private_data;
|
|
|
|
m->private = &iomem_resource;
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2006-12-06 21:40:36 -07:00
|
|
|
static const struct file_operations proc_ioports_operations = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.open = ioports_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = seq_release,
|
|
|
|
};
|
|
|
|
|
2006-12-06 21:40:36 -07:00
|
|
|
static const struct file_operations proc_iomem_operations = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.open = iomem_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = seq_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init ioresources_init(void)
|
|
|
|
{
|
2008-04-29 02:02:31 -06:00
|
|
|
proc_create("ioports", 0, NULL, &proc_ioports_operations);
|
|
|
|
proc_create("iomem", 0, NULL, &proc_iomem_operations);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
__initcall(ioresources_init);
|
|
|
|
|
|
|
|
#endif /* CONFIG_PROC_FS */
|
|
|
|
|
mem hotunplug: fix kfree() of bootmem memory
When hot removing memory presented at boot time, following messages are shown:
kernel BUG at mm/slub.c:3409!
invalid opcode: 0000 [#1] SMP
Modules linked in: ebtable_nat ebtables xt_CHECKSUM iptable_mangle bridge stp llc ipmi_devintf ipmi_msghandler sunrpc ipt_REJECT nf_conntrack_ipv4 nf_defrag_ipv4 iptable_filter ip_tables ip6t_REJECT nf_conntrack_ipv6 nf_defrag_ipv6 xt_state nf_conntrack ip6table_filter ip6_tables binfmt_misc vfat fat dm_mirror dm_region_hash dm_log dm_mod vhost_net macvtap macvlan tun uinput iTCO_wdt iTCO_vendor_support coretemp kvm_intel kvm crc32c_intel ghash_clmulni_intel microcode pcspkr sg i2c_i801 lpc_ich mfd_core igb i2c_algo_bit i2c_core e1000e ptp pps_core tpm_infineon ioatdma dca sr_mod cdrom sd_mod crc_t10dif usb_storage megaraid_sas lpfc scsi_transport_fc scsi_tgt scsi_mod
CPU 0
Pid: 5091, comm: kworker/0:2 Tainted: G W 3.9.0-rc6+ #15
RIP: kfree+0x232/0x240
Process kworker/0:2 (pid: 5091, threadinfo ffff88084678c000, task ffff88083928ca80)
Call Trace:
__release_region+0xd4/0xe0
__remove_pages+0x52/0x110
arch_remove_memory+0x89/0xd0
remove_memory+0xc4/0x100
acpi_memory_device_remove+0x6d/0xb1
acpi_device_remove+0x89/0xab
__device_release_driver+0x7c/0xf0
device_release_driver+0x2f/0x50
acpi_bus_device_detach+0x6c/0x70
acpi_ns_walk_namespace+0x11a/0x250
acpi_walk_namespace+0xee/0x137
acpi_bus_trim+0x33/0x7a
acpi_bus_hot_remove_device+0xc4/0x1a1
acpi_os_execute_deferred+0x27/0x34
process_one_work+0x1f7/0x590
worker_thread+0x11a/0x370
kthread+0xee/0x100
ret_from_fork+0x7c/0xb0
RIP [<ffffffff811c41d2>] kfree+0x232/0x240
RSP <ffff88084678d968>
The reason why the messages are shown is to release a resource
structure, allocated by bootmem, by kfree(). So when we release a
resource structure, we should check whether it is allocated by bootmem
or not.
But even if we know a resource structure is allocated by bootmem, we
cannot release it since SLxB cannot treat it. So for reusing a resource
structure, this patch remembers it by using bootmem_resource as follows:
When releasing a resource structure by free_resource(), free_resource()
checks whether the resource structure is allocated by bootmem or not.
If it is allocated by bootmem, free_resource() adds it to
bootmem_resource. If it is not allocated by bootmem, free_resource()
release it by kfree().
And when getting a new resource structure by get_resource(),
get_resource() checks whether bootmem_resource has released resource
structures or not. If there is a released resource structure,
get_resource() returns it. If there is not a releaed resource
structure, get_resource() returns new resource structure allocated by
kzalloc().
[akpm@linux-foundation.org: s/get_resource/alloc_resource/]
Signed-off-by: Yasuaki Ishimatsu <isimatu.yasuaki@jp.fujitsu.com>
Reviewed-by: Toshi Kani <toshi.kani@hp.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Ram Pai <linuxram@us.ibm.com>
Cc: David Rientjes <rientjes@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-04-29 16:08:56 -06:00
|
|
|
static void free_resource(struct resource *res)
|
|
|
|
{
|
|
|
|
if (!res)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!PageSlab(virt_to_head_page(res))) {
|
|
|
|
spin_lock(&bootmem_resource_lock);
|
|
|
|
res->sibling = bootmem_resource_free;
|
|
|
|
bootmem_resource_free = res;
|
|
|
|
spin_unlock(&bootmem_resource_lock);
|
|
|
|
} else {
|
|
|
|
kfree(res);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct resource *alloc_resource(gfp_t flags)
|
|
|
|
{
|
|
|
|
struct resource *res = NULL;
|
|
|
|
|
|
|
|
spin_lock(&bootmem_resource_lock);
|
|
|
|
if (bootmem_resource_free) {
|
|
|
|
res = bootmem_resource_free;
|
|
|
|
bootmem_resource_free = res->sibling;
|
|
|
|
}
|
|
|
|
spin_unlock(&bootmem_resource_lock);
|
|
|
|
|
|
|
|
if (res)
|
|
|
|
memset(res, 0, sizeof(struct resource));
|
|
|
|
else
|
|
|
|
res = kzalloc(sizeof(struct resource), flags);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Return the conflict entry if you can't request it */
|
|
|
|
static struct resource * __request_resource(struct resource *root, struct resource *new)
|
|
|
|
{
|
2006-06-12 17:09:23 -06:00
|
|
|
resource_size_t start = new->start;
|
|
|
|
resource_size_t end = new->end;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct resource *tmp, **p;
|
|
|
|
|
|
|
|
if (end < start)
|
|
|
|
return root;
|
|
|
|
if (start < root->start)
|
|
|
|
return root;
|
|
|
|
if (end > root->end)
|
|
|
|
return root;
|
|
|
|
p = &root->child;
|
|
|
|
for (;;) {
|
|
|
|
tmp = *p;
|
|
|
|
if (!tmp || tmp->start > end) {
|
|
|
|
new->sibling = tmp;
|
|
|
|
*p = new;
|
|
|
|
new->parent = root;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
p = &tmp->sibling;
|
|
|
|
if (tmp->end < start)
|
|
|
|
continue;
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __release_resource(struct resource *old)
|
|
|
|
{
|
|
|
|
struct resource *tmp, **p;
|
|
|
|
|
|
|
|
p = &old->parent->child;
|
|
|
|
for (;;) {
|
|
|
|
tmp = *p;
|
|
|
|
if (!tmp)
|
|
|
|
break;
|
|
|
|
if (tmp == old) {
|
|
|
|
*p = tmp->sibling;
|
|
|
|
old->parent = NULL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
p = &tmp->sibling;
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-12-22 16:02:22 -07:00
|
|
|
static void __release_child_resources(struct resource *r)
|
|
|
|
{
|
|
|
|
struct resource *tmp, *p;
|
|
|
|
resource_size_t size;
|
|
|
|
|
|
|
|
p = r->child;
|
|
|
|
r->child = NULL;
|
|
|
|
while (p) {
|
|
|
|
tmp = p;
|
|
|
|
p = p->sibling;
|
|
|
|
|
|
|
|
tmp->parent = NULL;
|
|
|
|
tmp->sibling = NULL;
|
|
|
|
__release_child_resources(tmp);
|
|
|
|
|
|
|
|
printk(KERN_DEBUG "release child resource %pR\n", tmp);
|
|
|
|
/* need to restore size, and keep flags */
|
|
|
|
size = resource_size(tmp);
|
|
|
|
tmp->start = 0;
|
|
|
|
tmp->end = size - 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void release_child_resources(struct resource *r)
|
|
|
|
{
|
|
|
|
write_lock(&resource_lock);
|
|
|
|
__release_child_resources(r);
|
|
|
|
write_unlock(&resource_lock);
|
|
|
|
}
|
|
|
|
|
2006-10-03 02:13:51 -06:00
|
|
|
/**
|
2010-03-11 17:01:09 -07:00
|
|
|
* request_resource_conflict - request and reserve an I/O or memory resource
|
2006-10-03 02:13:51 -06:00
|
|
|
* @root: root resource descriptor
|
|
|
|
* @new: resource descriptor desired by caller
|
|
|
|
*
|
2010-03-11 17:01:09 -07:00
|
|
|
* Returns 0 for success, conflict resource on error.
|
2006-10-03 02:13:51 -06:00
|
|
|
*/
|
2010-03-11 17:01:09 -07:00
|
|
|
struct resource *request_resource_conflict(struct resource *root, struct resource *new)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct resource *conflict;
|
|
|
|
|
|
|
|
write_lock(&resource_lock);
|
|
|
|
conflict = __request_resource(root, new);
|
|
|
|
write_unlock(&resource_lock);
|
2010-03-11 17:01:09 -07:00
|
|
|
return conflict;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* request_resource - request and reserve an I/O or memory resource
|
|
|
|
* @root: root resource descriptor
|
|
|
|
* @new: resource descriptor desired by caller
|
|
|
|
*
|
|
|
|
* Returns 0 for success, negative error code on error.
|
|
|
|
*/
|
|
|
|
int request_resource(struct resource *root, struct resource *new)
|
|
|
|
{
|
|
|
|
struct resource *conflict;
|
|
|
|
|
|
|
|
conflict = request_resource_conflict(root, new);
|
2005-04-16 16:20:36 -06:00
|
|
|
return conflict ? -EBUSY : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(request_resource);
|
|
|
|
|
2006-10-03 02:13:51 -06:00
|
|
|
/**
|
|
|
|
* release_resource - release a previously reserved resource
|
|
|
|
* @old: resource pointer
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
int release_resource(struct resource *old)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
write_lock(&resource_lock);
|
|
|
|
retval = __release_resource(old);
|
|
|
|
write_unlock(&resource_lock);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(release_resource);
|
|
|
|
|
2009-09-22 17:45:46 -06:00
|
|
|
#if !defined(CONFIG_ARCH_HAS_WALK_MEMORY)
|
2006-06-27 03:53:36 -06:00
|
|
|
/*
|
|
|
|
* Finds the lowest memory reosurce exists within [res->start.res->end)
|
2009-09-22 17:45:46 -06:00
|
|
|
* the caller must specify res->start, res->end, res->flags and "name".
|
2006-06-27 03:53:36 -06:00
|
|
|
* If found, returns 0, res is overwritten, if not found, returns -1.
|
|
|
|
*/
|
2009-09-22 17:45:46 -06:00
|
|
|
static int find_next_system_ram(struct resource *res, char *name)
|
2006-06-27 03:53:36 -06:00
|
|
|
{
|
|
|
|
resource_size_t start, end;
|
|
|
|
struct resource *p;
|
|
|
|
|
|
|
|
BUG_ON(!res);
|
|
|
|
|
|
|
|
start = res->start;
|
|
|
|
end = res->end;
|
2006-08-05 13:15:01 -06:00
|
|
|
BUG_ON(start >= end);
|
2006-06-27 03:53:36 -06:00
|
|
|
|
|
|
|
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;
|
2009-09-22 17:45:46 -06:00
|
|
|
if (name && strcmp(p->name, name))
|
|
|
|
continue;
|
2006-06-27 03:53:36 -06:00
|
|
|
if (p->start > end) {
|
|
|
|
p = NULL;
|
|
|
|
break;
|
|
|
|
}
|
2006-08-05 13:15:01 -06:00
|
|
|
if ((p->end >= start) && (p->start < end))
|
2006-06-27 03:53:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
read_unlock(&resource_lock);
|
|
|
|
if (!p)
|
|
|
|
return -1;
|
|
|
|
/* copy data */
|
2006-08-05 13:14:59 -06:00
|
|
|
if (res->start < p->start)
|
|
|
|
res->start = p->start;
|
|
|
|
if (res->end > p->end)
|
|
|
|
res->end = p->end;
|
2006-06-27 03:53:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2009-09-22 17:45:46 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This function calls callback against all memory range of "System RAM"
|
|
|
|
* which are marked as IORESOURCE_MEM and IORESOUCE_BUSY.
|
|
|
|
* Now, this function is only for "System RAM".
|
|
|
|
*/
|
|
|
|
int walk_system_ram_range(unsigned long start_pfn, unsigned long nr_pages,
|
|
|
|
void *arg, int (*func)(unsigned long, unsigned long, void *))
|
2007-10-16 02:26:10 -06:00
|
|
|
{
|
|
|
|
struct resource res;
|
2010-03-01 06:55:51 -07:00
|
|
|
unsigned long pfn, end_pfn;
|
2007-10-16 02:26:10 -06:00
|
|
|
u64 orig_end;
|
|
|
|
int ret = -1;
|
2009-09-22 17:45:46 -06:00
|
|
|
|
2007-10-16 02:26:10 -06:00
|
|
|
res.start = (u64) start_pfn << PAGE_SHIFT;
|
|
|
|
res.end = ((u64)(start_pfn + nr_pages) << PAGE_SHIFT) - 1;
|
2007-11-14 17:59:20 -07:00
|
|
|
res.flags = IORESOURCE_MEM | IORESOURCE_BUSY;
|
2007-10-16 02:26:10 -06:00
|
|
|
orig_end = res.end;
|
2009-09-22 17:45:46 -06:00
|
|
|
while ((res.start < res.end) &&
|
|
|
|
(find_next_system_ram(&res, "System RAM") >= 0)) {
|
2010-03-01 06:55:51 -07:00
|
|
|
pfn = (res.start + PAGE_SIZE - 1) >> PAGE_SHIFT;
|
|
|
|
end_pfn = (res.end + 1) >> PAGE_SHIFT;
|
|
|
|
if (end_pfn > pfn)
|
2010-03-02 12:21:09 -07:00
|
|
|
ret = (*func)(pfn, end_pfn - pfn, arg);
|
2007-10-16 02:26:10 -06:00
|
|
|
if (ret)
|
|
|
|
break;
|
|
|
|
res.start = res.end + 1;
|
|
|
|
res.end = orig_end;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2006-06-27 03:53:36 -06:00
|
|
|
#endif
|
|
|
|
|
2010-01-22 01:16:19 -07:00
|
|
|
static int __is_ram(unsigned long pfn, unsigned long nr_pages, void *arg)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* This generic page_is_ram() returns true if specified address is
|
|
|
|
* registered as "System RAM" in iomem_resource list.
|
|
|
|
*/
|
2010-01-26 17:31:19 -07:00
|
|
|
int __weak page_is_ram(unsigned long pfn)
|
2010-01-22 01:16:19 -07:00
|
|
|
{
|
|
|
|
return walk_system_ram_range(pfn, 1, NULL, __is_ram) == 1;
|
|
|
|
}
|
2013-06-06 16:20:51 -06:00
|
|
|
EXPORT_SYMBOL_GPL(page_is_ram);
|
2010-01-22 01:16:19 -07:00
|
|
|
|
2010-12-16 10:38:46 -07:00
|
|
|
void __weak arch_remove_reservations(struct resource *avail)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2010-10-26 15:41:13 -06:00
|
|
|
static resource_size_t simple_align_resource(void *data,
|
|
|
|
const struct resource *avail,
|
|
|
|
resource_size_t size,
|
|
|
|
resource_size_t align)
|
|
|
|
{
|
|
|
|
return avail->start;
|
|
|
|
}
|
|
|
|
|
2010-10-26 15:41:18 -06:00
|
|
|
static void resource_clip(struct resource *res, resource_size_t min,
|
|
|
|
resource_size_t max)
|
|
|
|
{
|
|
|
|
if (res->start < min)
|
|
|
|
res->start = min;
|
|
|
|
if (res->end > max)
|
|
|
|
res->end = max;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2011-07-06 00:44:30 -06:00
|
|
|
* Find empty slot in the resource tree with the given range and
|
|
|
|
* alignment constraints
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2011-07-06 00:44:30 -06:00
|
|
|
static int __find_resource(struct resource *root, struct resource *old,
|
|
|
|
struct resource *new,
|
|
|
|
resource_size_t size,
|
|
|
|
struct resource_constraint *constraint)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct resource *this = root->child;
|
2010-10-26 15:41:28 -06:00
|
|
|
struct resource tmp = *new, avail, alloc;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-12-20 02:50:02 -07:00
|
|
|
tmp.start = root->start;
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2010-12-16 10:38:41 -07:00
|
|
|
* Skip past an allocated resource that starts at 0, since the assignment
|
|
|
|
* of this->start - 1 to tmp->end below would cause an underflow.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2011-07-06 00:44:30 -06:00
|
|
|
if (this && this->start == root->start) {
|
|
|
|
tmp.start = (this == old) ? old->start : this->end + 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
this = this->sibling;
|
|
|
|
}
|
2010-12-16 10:38:41 -07:00
|
|
|
for(;;) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (this)
|
2011-07-06 00:44:30 -06:00
|
|
|
tmp.end = (this == old) ? this->end : this->start - 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
else
|
2009-12-20 02:50:02 -07:00
|
|
|
tmp.end = root->end;
|
2010-10-26 15:41:18 -06:00
|
|
|
|
2011-09-22 01:48:58 -06:00
|
|
|
if (tmp.end < tmp.start)
|
|
|
|
goto next;
|
|
|
|
|
2011-07-06 00:44:30 -06:00
|
|
|
resource_clip(&tmp, constraint->min, constraint->max);
|
2010-12-16 10:38:46 -07:00
|
|
|
arch_remove_reservations(&tmp);
|
2010-10-26 15:41:13 -06:00
|
|
|
|
2010-10-26 15:41:28 -06:00
|
|
|
/* Check for overflow after ALIGN() */
|
2011-07-06 00:44:30 -06:00
|
|
|
avail.start = ALIGN(tmp.start, constraint->align);
|
2010-10-26 15:41:28 -06:00
|
|
|
avail.end = tmp.end;
|
2014-02-04 20:32:28 -07:00
|
|
|
avail.flags = new->flags & ~IORESOURCE_UNSET;
|
2010-10-26 15:41:28 -06:00
|
|
|
if (avail.start >= tmp.start) {
|
2014-02-04 20:32:28 -07:00
|
|
|
alloc.flags = avail.flags;
|
2011-07-06 00:44:30 -06:00
|
|
|
alloc.start = constraint->alignf(constraint->alignf_data, &avail,
|
|
|
|
size, constraint->align);
|
2010-10-26 15:41:28 -06:00
|
|
|
alloc.end = alloc.start + size - 1;
|
|
|
|
if (resource_contains(&avail, &alloc)) {
|
|
|
|
new->start = alloc.start;
|
|
|
|
new->end = alloc.end;
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2011-09-22 01:48:58 -06:00
|
|
|
|
|
|
|
next: if (!this || this->end == root->end)
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
2011-09-22 01:48:58 -06:00
|
|
|
|
2011-07-06 00:44:30 -06:00
|
|
|
if (this != old)
|
|
|
|
tmp.start = this->end + 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
this = this->sibling;
|
|
|
|
}
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
2011-07-06 00:44:30 -06:00
|
|
|
/*
|
|
|
|
* Find empty slot in the resource tree given range and alignment.
|
|
|
|
*/
|
|
|
|
static int find_resource(struct resource *root, struct resource *new,
|
|
|
|
resource_size_t size,
|
|
|
|
struct resource_constraint *constraint)
|
|
|
|
{
|
|
|
|
return __find_resource(root, NULL, new, size, constraint);
|
|
|
|
}
|
|
|
|
|
2006-10-03 02:13:51 -06:00
|
|
|
/**
|
2011-07-06 00:44:30 -06:00
|
|
|
* reallocate_resource - allocate a slot in the resource tree given range & alignment.
|
|
|
|
* The resource will be relocated if the new size cannot be reallocated in the
|
|
|
|
* current location.
|
|
|
|
*
|
|
|
|
* @root: root resource descriptor
|
|
|
|
* @old: resource descriptor desired by caller
|
|
|
|
* @newsize: new size of the resource descriptor
|
|
|
|
* @constraint: the size and alignment constraints to be met.
|
|
|
|
*/
|
2014-04-03 15:48:36 -06:00
|
|
|
static int reallocate_resource(struct resource *root, struct resource *old,
|
2011-07-06 00:44:30 -06:00
|
|
|
resource_size_t newsize,
|
|
|
|
struct resource_constraint *constraint)
|
|
|
|
{
|
|
|
|
int err=0;
|
|
|
|
struct resource new = *old;
|
|
|
|
struct resource *conflict;
|
|
|
|
|
|
|
|
write_lock(&resource_lock);
|
|
|
|
|
|
|
|
if ((err = __find_resource(root, old, &new, newsize, constraint)))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (resource_contains(&new, old)) {
|
|
|
|
old->start = new.start;
|
|
|
|
old->end = new.end;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (old->child) {
|
|
|
|
err = -EBUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (resource_contains(old, &new)) {
|
|
|
|
old->start = new.start;
|
|
|
|
old->end = new.end;
|
|
|
|
} else {
|
|
|
|
__release_resource(old);
|
|
|
|
*old = new;
|
|
|
|
conflict = __request_resource(root, old);
|
|
|
|
BUG_ON(conflict);
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
write_unlock(&resource_lock);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* allocate_resource - allocate empty slot in the resource tree given range & alignment.
|
|
|
|
* The resource will be reallocated with a new size if it was already allocated
|
2006-10-03 02:13:51 -06:00
|
|
|
* @root: root resource descriptor
|
|
|
|
* @new: resource descriptor desired by caller
|
|
|
|
* @size: requested resource region size
|
2012-05-31 17:26:05 -06:00
|
|
|
* @min: minimum boundary to allocate
|
|
|
|
* @max: maximum boundary to allocate
|
2006-10-03 02:13:51 -06:00
|
|
|
* @align: alignment requested, in bytes
|
|
|
|
* @alignf: alignment function, optional, called if not NULL
|
|
|
|
* @alignf_data: arbitrary data to pass to the @alignf function
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
int allocate_resource(struct resource *root, struct resource *new,
|
2006-06-12 17:09:23 -06:00
|
|
|
resource_size_t size, resource_size_t min,
|
|
|
|
resource_size_t max, resource_size_t align,
|
2010-01-01 09:40:49 -07:00
|
|
|
resource_size_t (*alignf)(void *,
|
2010-01-01 09:40:50 -07:00
|
|
|
const struct resource *,
|
2010-01-01 09:40:49 -07:00
|
|
|
resource_size_t,
|
|
|
|
resource_size_t),
|
2005-04-16 16:20:36 -06:00
|
|
|
void *alignf_data)
|
|
|
|
{
|
|
|
|
int err;
|
2011-07-06 00:44:30 -06:00
|
|
|
struct resource_constraint constraint;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-10-26 15:41:13 -06:00
|
|
|
if (!alignf)
|
|
|
|
alignf = simple_align_resource;
|
|
|
|
|
2011-07-06 00:44:30 -06:00
|
|
|
constraint.min = min;
|
|
|
|
constraint.max = max;
|
|
|
|
constraint.align = align;
|
|
|
|
constraint.alignf = alignf;
|
|
|
|
constraint.alignf_data = alignf_data;
|
|
|
|
|
|
|
|
if ( new->parent ) {
|
|
|
|
/* resource is already allocated, try reallocating with
|
|
|
|
the new constraints */
|
|
|
|
return reallocate_resource(root, new, size, &constraint);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
write_lock(&resource_lock);
|
2011-07-06 00:44:30 -06:00
|
|
|
err = find_resource(root, new, size, &constraint);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (err >= 0 && __request_resource(root, new))
|
|
|
|
err = -EBUSY;
|
|
|
|
write_unlock(&resource_lock);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(allocate_resource);
|
|
|
|
|
2011-05-07 12:53:16 -06:00
|
|
|
/**
|
|
|
|
* lookup_resource - find an existing resource by a resource start address
|
|
|
|
* @root: root resource descriptor
|
|
|
|
* @start: resource start address
|
|
|
|
*
|
|
|
|
* Returns a pointer to the resource if found, NULL otherwise
|
|
|
|
*/
|
|
|
|
struct resource *lookup_resource(struct resource *root, resource_size_t start)
|
|
|
|
{
|
|
|
|
struct resource *res;
|
|
|
|
|
|
|
|
read_lock(&resource_lock);
|
|
|
|
for (res = root->child; res; res = res->sibling) {
|
|
|
|
if (res->start == start)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
read_unlock(&resource_lock);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2008-08-29 21:18:31 -06:00
|
|
|
/*
|
|
|
|
* Insert a resource into the resource tree. If successful, return NULL,
|
|
|
|
* otherwise return the conflicting resource (compare to __request_resource())
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2008-08-29 21:18:31 -06:00
|
|
|
static struct resource * __insert_resource(struct resource *parent, struct resource *new)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct resource *first, *next;
|
|
|
|
|
2006-06-30 03:31:24 -06:00
|
|
|
for (;; parent = first) {
|
|
|
|
first = __request_resource(parent, new);
|
|
|
|
if (!first)
|
2008-08-29 21:18:31 -06:00
|
|
|
return first;
|
2006-06-30 03:31:24 -06:00
|
|
|
|
|
|
|
if (first == parent)
|
2008-08-29 21:18:31 -06:00
|
|
|
return first;
|
2010-10-27 16:34:52 -06:00
|
|
|
if (WARN_ON(first == new)) /* duplicated insertion */
|
|
|
|
return first;
|
2006-06-30 03:31:24 -06:00
|
|
|
|
|
|
|
if ((first->start > new->start) || (first->end < new->end))
|
|
|
|
break;
|
|
|
|
if ((first->start == new->start) && (first->end == new->end))
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
for (next = first; ; next = next->sibling) {
|
|
|
|
/* Partial overlap? Bad, and unfixable */
|
|
|
|
if (next->start < new->start || next->end > new->end)
|
2008-08-29 21:18:31 -06:00
|
|
|
return next;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!next->sibling)
|
|
|
|
break;
|
|
|
|
if (next->sibling->start > new->end)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
new->parent = parent;
|
|
|
|
new->sibling = next->sibling;
|
|
|
|
new->child = first;
|
|
|
|
|
|
|
|
next->sibling = NULL;
|
|
|
|
for (next = first; next; next = next->sibling)
|
|
|
|
next->parent = new;
|
|
|
|
|
|
|
|
if (parent->child == first) {
|
|
|
|
parent->child = new;
|
|
|
|
} else {
|
|
|
|
next = parent->child;
|
|
|
|
while (next->sibling != first)
|
|
|
|
next = next->sibling;
|
|
|
|
next->sibling = new;
|
|
|
|
}
|
2008-08-29 21:18:31 -06:00
|
|
|
return NULL;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-08-29 21:18:31 -06:00
|
|
|
/**
|
2010-03-11 17:01:09 -07:00
|
|
|
* insert_resource_conflict - Inserts resource in the resource tree
|
2008-08-29 21:18:31 -06:00
|
|
|
* @parent: parent of the new resource
|
|
|
|
* @new: new resource to insert
|
|
|
|
*
|
2010-03-11 17:01:09 -07:00
|
|
|
* Returns 0 on success, conflict resource if the resource can't be inserted.
|
2008-08-29 21:18:31 -06:00
|
|
|
*
|
2010-03-11 17:01:09 -07:00
|
|
|
* This function is equivalent to request_resource_conflict when no conflict
|
2008-08-29 21:18:31 -06:00
|
|
|
* 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 children of
|
|
|
|
* the new resource.
|
|
|
|
*/
|
2010-03-11 17:01:09 -07:00
|
|
|
struct resource *insert_resource_conflict(struct resource *parent, struct resource *new)
|
2008-08-29 21:18:31 -06:00
|
|
|
{
|
|
|
|
struct resource *conflict;
|
|
|
|
|
|
|
|
write_lock(&resource_lock);
|
|
|
|
conflict = __insert_resource(parent, new);
|
|
|
|
write_unlock(&resource_lock);
|
2010-03-11 17:01:09 -07:00
|
|
|
return conflict;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* insert_resource - Inserts a resource in the resource tree
|
|
|
|
* @parent: parent of the new resource
|
|
|
|
* @new: new resource to insert
|
|
|
|
*
|
|
|
|
* Returns 0 on success, -EBUSY if the resource can't be inserted.
|
|
|
|
*/
|
|
|
|
int insert_resource(struct resource *parent, struct resource *new)
|
|
|
|
{
|
|
|
|
struct resource *conflict;
|
|
|
|
|
|
|
|
conflict = insert_resource_conflict(parent, new);
|
2008-08-29 21:18:31 -06:00
|
|
|
return conflict ? -EBUSY : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* insert_resource_expand_to_fit - Insert a resource into the resource tree
|
2008-08-31 21:31:55 -06:00
|
|
|
* @root: root resource descriptor
|
2008-08-29 21:18:31 -06:00
|
|
|
* @new: new resource to insert
|
|
|
|
*
|
|
|
|
* Insert a resource into the resource tree, possibly expanding it in order
|
|
|
|
* to make it encompass any conflicting resources.
|
|
|
|
*/
|
|
|
|
void insert_resource_expand_to_fit(struct resource *root, struct resource *new)
|
|
|
|
{
|
|
|
|
if (new->parent)
|
|
|
|
return;
|
|
|
|
|
|
|
|
write_lock(&resource_lock);
|
|
|
|
for (;;) {
|
|
|
|
struct resource *conflict;
|
|
|
|
|
|
|
|
conflict = __insert_resource(root, new);
|
|
|
|
if (!conflict)
|
|
|
|
break;
|
|
|
|
if (conflict == root)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Ok, expand resource to cover the conflict, then try again .. */
|
|
|
|
if (conflict->start < new->start)
|
|
|
|
new->start = conflict->start;
|
|
|
|
if (conflict->end > new->end)
|
|
|
|
new->end = conflict->end;
|
|
|
|
|
|
|
|
printk("Expanded resource %s due to conflict with %s\n", new->name, conflict->name);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
write_unlock(&resource_lock);
|
|
|
|
}
|
|
|
|
|
2013-04-29 16:08:17 -06:00
|
|
|
static int __adjust_resource(struct resource *res, resource_size_t start,
|
|
|
|
resource_size_t size)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct resource *tmp, *parent = res->parent;
|
2006-06-12 17:09:23 -06:00
|
|
|
resource_size_t end = start + size - 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
int result = -EBUSY;
|
|
|
|
|
2012-05-17 19:51:11 -06:00
|
|
|
if (!parent)
|
|
|
|
goto skip;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if ((start < parent->start) || (end > parent->end))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (res->sibling && (res->sibling->start <= end))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
tmp = parent->child;
|
|
|
|
if (tmp != res) {
|
|
|
|
while (tmp->sibling != res)
|
|
|
|
tmp = tmp->sibling;
|
|
|
|
if (start <= tmp->end)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2012-05-17 19:51:11 -06:00
|
|
|
skip:
|
|
|
|
for (tmp = res->child; tmp; tmp = tmp->sibling)
|
|
|
|
if ((tmp->start < start) || (tmp->end > end))
|
|
|
|
goto out;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
res->start = start;
|
|
|
|
res->end = end;
|
|
|
|
result = 0;
|
|
|
|
|
|
|
|
out:
|
2013-04-29 16:08:17 -06:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* adjust_resource - modify a resource's start and size
|
|
|
|
* @res: resource to modify
|
|
|
|
* @start: new start value
|
|
|
|
* @size: new size
|
|
|
|
*
|
|
|
|
* Given an existing resource, change its start and size to match the
|
|
|
|
* arguments. Returns 0 on success, -EBUSY if it can't fit.
|
|
|
|
* Existing children of the resource are assumed to be immutable.
|
|
|
|
*/
|
|
|
|
int adjust_resource(struct resource *res, resource_size_t start,
|
|
|
|
resource_size_t size)
|
|
|
|
{
|
|
|
|
int result;
|
|
|
|
|
|
|
|
write_lock(&resource_lock);
|
|
|
|
result = __adjust_resource(res, start, size);
|
2005-04-16 16:20:36 -06:00
|
|
|
write_unlock(&resource_lock);
|
|
|
|
return result;
|
|
|
|
}
|
2012-02-03 06:42:39 -07:00
|
|
|
EXPORT_SYMBOL(adjust_resource);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-09-04 13:02:44 -06:00
|
|
|
static void __init __reserve_region_with_split(struct resource *root,
|
|
|
|
resource_size_t start, resource_size_t end,
|
|
|
|
const char *name)
|
|
|
|
{
|
|
|
|
struct resource *parent = root;
|
|
|
|
struct resource *conflict;
|
mem hotunplug: fix kfree() of bootmem memory
When hot removing memory presented at boot time, following messages are shown:
kernel BUG at mm/slub.c:3409!
invalid opcode: 0000 [#1] SMP
Modules linked in: ebtable_nat ebtables xt_CHECKSUM iptable_mangle bridge stp llc ipmi_devintf ipmi_msghandler sunrpc ipt_REJECT nf_conntrack_ipv4 nf_defrag_ipv4 iptable_filter ip_tables ip6t_REJECT nf_conntrack_ipv6 nf_defrag_ipv6 xt_state nf_conntrack ip6table_filter ip6_tables binfmt_misc vfat fat dm_mirror dm_region_hash dm_log dm_mod vhost_net macvtap macvlan tun uinput iTCO_wdt iTCO_vendor_support coretemp kvm_intel kvm crc32c_intel ghash_clmulni_intel microcode pcspkr sg i2c_i801 lpc_ich mfd_core igb i2c_algo_bit i2c_core e1000e ptp pps_core tpm_infineon ioatdma dca sr_mod cdrom sd_mod crc_t10dif usb_storage megaraid_sas lpfc scsi_transport_fc scsi_tgt scsi_mod
CPU 0
Pid: 5091, comm: kworker/0:2 Tainted: G W 3.9.0-rc6+ #15
RIP: kfree+0x232/0x240
Process kworker/0:2 (pid: 5091, threadinfo ffff88084678c000, task ffff88083928ca80)
Call Trace:
__release_region+0xd4/0xe0
__remove_pages+0x52/0x110
arch_remove_memory+0x89/0xd0
remove_memory+0xc4/0x100
acpi_memory_device_remove+0x6d/0xb1
acpi_device_remove+0x89/0xab
__device_release_driver+0x7c/0xf0
device_release_driver+0x2f/0x50
acpi_bus_device_detach+0x6c/0x70
acpi_ns_walk_namespace+0x11a/0x250
acpi_walk_namespace+0xee/0x137
acpi_bus_trim+0x33/0x7a
acpi_bus_hot_remove_device+0xc4/0x1a1
acpi_os_execute_deferred+0x27/0x34
process_one_work+0x1f7/0x590
worker_thread+0x11a/0x370
kthread+0xee/0x100
ret_from_fork+0x7c/0xb0
RIP [<ffffffff811c41d2>] kfree+0x232/0x240
RSP <ffff88084678d968>
The reason why the messages are shown is to release a resource
structure, allocated by bootmem, by kfree(). So when we release a
resource structure, we should check whether it is allocated by bootmem
or not.
But even if we know a resource structure is allocated by bootmem, we
cannot release it since SLxB cannot treat it. So for reusing a resource
structure, this patch remembers it by using bootmem_resource as follows:
When releasing a resource structure by free_resource(), free_resource()
checks whether the resource structure is allocated by bootmem or not.
If it is allocated by bootmem, free_resource() adds it to
bootmem_resource. If it is not allocated by bootmem, free_resource()
release it by kfree().
And when getting a new resource structure by get_resource(),
get_resource() checks whether bootmem_resource has released resource
structures or not. If there is a released resource structure,
get_resource() returns it. If there is not a releaed resource
structure, get_resource() returns new resource structure allocated by
kzalloc().
[akpm@linux-foundation.org: s/get_resource/alloc_resource/]
Signed-off-by: Yasuaki Ishimatsu <isimatu.yasuaki@jp.fujitsu.com>
Reviewed-by: Toshi Kani <toshi.kani@hp.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Ram Pai <linuxram@us.ibm.com>
Cc: David Rientjes <rientjes@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-04-29 16:08:56 -06:00
|
|
|
struct resource *res = alloc_resource(GFP_ATOMIC);
|
2012-10-04 18:16:55 -06:00
|
|
|
struct resource *next_res = NULL;
|
2008-09-04 13:02:44 -06:00
|
|
|
|
|
|
|
if (!res)
|
|
|
|
return;
|
|
|
|
|
|
|
|
res->name = name;
|
|
|
|
res->start = start;
|
|
|
|
res->end = end;
|
|
|
|
res->flags = IORESOURCE_BUSY;
|
|
|
|
|
2012-10-04 18:16:55 -06:00
|
|
|
while (1) {
|
2008-09-04 13:02:44 -06:00
|
|
|
|
2012-10-04 18:16:55 -06:00
|
|
|
conflict = __request_resource(parent, res);
|
|
|
|
if (!conflict) {
|
|
|
|
if (!next_res)
|
|
|
|
break;
|
|
|
|
res = next_res;
|
|
|
|
next_res = NULL;
|
|
|
|
continue;
|
|
|
|
}
|
2008-09-04 13:02:44 -06:00
|
|
|
|
2012-10-04 18:16:55 -06:00
|
|
|
/* conflict covered whole area */
|
|
|
|
if (conflict->start <= res->start &&
|
|
|
|
conflict->end >= res->end) {
|
mem hotunplug: fix kfree() of bootmem memory
When hot removing memory presented at boot time, following messages are shown:
kernel BUG at mm/slub.c:3409!
invalid opcode: 0000 [#1] SMP
Modules linked in: ebtable_nat ebtables xt_CHECKSUM iptable_mangle bridge stp llc ipmi_devintf ipmi_msghandler sunrpc ipt_REJECT nf_conntrack_ipv4 nf_defrag_ipv4 iptable_filter ip_tables ip6t_REJECT nf_conntrack_ipv6 nf_defrag_ipv6 xt_state nf_conntrack ip6table_filter ip6_tables binfmt_misc vfat fat dm_mirror dm_region_hash dm_log dm_mod vhost_net macvtap macvlan tun uinput iTCO_wdt iTCO_vendor_support coretemp kvm_intel kvm crc32c_intel ghash_clmulni_intel microcode pcspkr sg i2c_i801 lpc_ich mfd_core igb i2c_algo_bit i2c_core e1000e ptp pps_core tpm_infineon ioatdma dca sr_mod cdrom sd_mod crc_t10dif usb_storage megaraid_sas lpfc scsi_transport_fc scsi_tgt scsi_mod
CPU 0
Pid: 5091, comm: kworker/0:2 Tainted: G W 3.9.0-rc6+ #15
RIP: kfree+0x232/0x240
Process kworker/0:2 (pid: 5091, threadinfo ffff88084678c000, task ffff88083928ca80)
Call Trace:
__release_region+0xd4/0xe0
__remove_pages+0x52/0x110
arch_remove_memory+0x89/0xd0
remove_memory+0xc4/0x100
acpi_memory_device_remove+0x6d/0xb1
acpi_device_remove+0x89/0xab
__device_release_driver+0x7c/0xf0
device_release_driver+0x2f/0x50
acpi_bus_device_detach+0x6c/0x70
acpi_ns_walk_namespace+0x11a/0x250
acpi_walk_namespace+0xee/0x137
acpi_bus_trim+0x33/0x7a
acpi_bus_hot_remove_device+0xc4/0x1a1
acpi_os_execute_deferred+0x27/0x34
process_one_work+0x1f7/0x590
worker_thread+0x11a/0x370
kthread+0xee/0x100
ret_from_fork+0x7c/0xb0
RIP [<ffffffff811c41d2>] kfree+0x232/0x240
RSP <ffff88084678d968>
The reason why the messages are shown is to release a resource
structure, allocated by bootmem, by kfree(). So when we release a
resource structure, we should check whether it is allocated by bootmem
or not.
But even if we know a resource structure is allocated by bootmem, we
cannot release it since SLxB cannot treat it. So for reusing a resource
structure, this patch remembers it by using bootmem_resource as follows:
When releasing a resource structure by free_resource(), free_resource()
checks whether the resource structure is allocated by bootmem or not.
If it is allocated by bootmem, free_resource() adds it to
bootmem_resource. If it is not allocated by bootmem, free_resource()
release it by kfree().
And when getting a new resource structure by get_resource(),
get_resource() checks whether bootmem_resource has released resource
structures or not. If there is a released resource structure,
get_resource() returns it. If there is not a releaed resource
structure, get_resource() returns new resource structure allocated by
kzalloc().
[akpm@linux-foundation.org: s/get_resource/alloc_resource/]
Signed-off-by: Yasuaki Ishimatsu <isimatu.yasuaki@jp.fujitsu.com>
Reviewed-by: Toshi Kani <toshi.kani@hp.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Ram Pai <linuxram@us.ibm.com>
Cc: David Rientjes <rientjes@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-04-29 16:08:56 -06:00
|
|
|
free_resource(res);
|
2012-10-04 18:16:55 -06:00
|
|
|
WARN_ON(next_res);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* failed, split and try again */
|
|
|
|
if (conflict->start > res->start) {
|
|
|
|
end = res->end;
|
|
|
|
res->end = conflict->start - 1;
|
|
|
|
if (conflict->end < end) {
|
mem hotunplug: fix kfree() of bootmem memory
When hot removing memory presented at boot time, following messages are shown:
kernel BUG at mm/slub.c:3409!
invalid opcode: 0000 [#1] SMP
Modules linked in: ebtable_nat ebtables xt_CHECKSUM iptable_mangle bridge stp llc ipmi_devintf ipmi_msghandler sunrpc ipt_REJECT nf_conntrack_ipv4 nf_defrag_ipv4 iptable_filter ip_tables ip6t_REJECT nf_conntrack_ipv6 nf_defrag_ipv6 xt_state nf_conntrack ip6table_filter ip6_tables binfmt_misc vfat fat dm_mirror dm_region_hash dm_log dm_mod vhost_net macvtap macvlan tun uinput iTCO_wdt iTCO_vendor_support coretemp kvm_intel kvm crc32c_intel ghash_clmulni_intel microcode pcspkr sg i2c_i801 lpc_ich mfd_core igb i2c_algo_bit i2c_core e1000e ptp pps_core tpm_infineon ioatdma dca sr_mod cdrom sd_mod crc_t10dif usb_storage megaraid_sas lpfc scsi_transport_fc scsi_tgt scsi_mod
CPU 0
Pid: 5091, comm: kworker/0:2 Tainted: G W 3.9.0-rc6+ #15
RIP: kfree+0x232/0x240
Process kworker/0:2 (pid: 5091, threadinfo ffff88084678c000, task ffff88083928ca80)
Call Trace:
__release_region+0xd4/0xe0
__remove_pages+0x52/0x110
arch_remove_memory+0x89/0xd0
remove_memory+0xc4/0x100
acpi_memory_device_remove+0x6d/0xb1
acpi_device_remove+0x89/0xab
__device_release_driver+0x7c/0xf0
device_release_driver+0x2f/0x50
acpi_bus_device_detach+0x6c/0x70
acpi_ns_walk_namespace+0x11a/0x250
acpi_walk_namespace+0xee/0x137
acpi_bus_trim+0x33/0x7a
acpi_bus_hot_remove_device+0xc4/0x1a1
acpi_os_execute_deferred+0x27/0x34
process_one_work+0x1f7/0x590
worker_thread+0x11a/0x370
kthread+0xee/0x100
ret_from_fork+0x7c/0xb0
RIP [<ffffffff811c41d2>] kfree+0x232/0x240
RSP <ffff88084678d968>
The reason why the messages are shown is to release a resource
structure, allocated by bootmem, by kfree(). So when we release a
resource structure, we should check whether it is allocated by bootmem
or not.
But even if we know a resource structure is allocated by bootmem, we
cannot release it since SLxB cannot treat it. So for reusing a resource
structure, this patch remembers it by using bootmem_resource as follows:
When releasing a resource structure by free_resource(), free_resource()
checks whether the resource structure is allocated by bootmem or not.
If it is allocated by bootmem, free_resource() adds it to
bootmem_resource. If it is not allocated by bootmem, free_resource()
release it by kfree().
And when getting a new resource structure by get_resource(),
get_resource() checks whether bootmem_resource has released resource
structures or not. If there is a released resource structure,
get_resource() returns it. If there is not a releaed resource
structure, get_resource() returns new resource structure allocated by
kzalloc().
[akpm@linux-foundation.org: s/get_resource/alloc_resource/]
Signed-off-by: Yasuaki Ishimatsu <isimatu.yasuaki@jp.fujitsu.com>
Reviewed-by: Toshi Kani <toshi.kani@hp.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Ram Pai <linuxram@us.ibm.com>
Cc: David Rientjes <rientjes@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-04-29 16:08:56 -06:00
|
|
|
next_res = alloc_resource(GFP_ATOMIC);
|
2012-10-04 18:16:55 -06:00
|
|
|
if (!next_res) {
|
mem hotunplug: fix kfree() of bootmem memory
When hot removing memory presented at boot time, following messages are shown:
kernel BUG at mm/slub.c:3409!
invalid opcode: 0000 [#1] SMP
Modules linked in: ebtable_nat ebtables xt_CHECKSUM iptable_mangle bridge stp llc ipmi_devintf ipmi_msghandler sunrpc ipt_REJECT nf_conntrack_ipv4 nf_defrag_ipv4 iptable_filter ip_tables ip6t_REJECT nf_conntrack_ipv6 nf_defrag_ipv6 xt_state nf_conntrack ip6table_filter ip6_tables binfmt_misc vfat fat dm_mirror dm_region_hash dm_log dm_mod vhost_net macvtap macvlan tun uinput iTCO_wdt iTCO_vendor_support coretemp kvm_intel kvm crc32c_intel ghash_clmulni_intel microcode pcspkr sg i2c_i801 lpc_ich mfd_core igb i2c_algo_bit i2c_core e1000e ptp pps_core tpm_infineon ioatdma dca sr_mod cdrom sd_mod crc_t10dif usb_storage megaraid_sas lpfc scsi_transport_fc scsi_tgt scsi_mod
CPU 0
Pid: 5091, comm: kworker/0:2 Tainted: G W 3.9.0-rc6+ #15
RIP: kfree+0x232/0x240
Process kworker/0:2 (pid: 5091, threadinfo ffff88084678c000, task ffff88083928ca80)
Call Trace:
__release_region+0xd4/0xe0
__remove_pages+0x52/0x110
arch_remove_memory+0x89/0xd0
remove_memory+0xc4/0x100
acpi_memory_device_remove+0x6d/0xb1
acpi_device_remove+0x89/0xab
__device_release_driver+0x7c/0xf0
device_release_driver+0x2f/0x50
acpi_bus_device_detach+0x6c/0x70
acpi_ns_walk_namespace+0x11a/0x250
acpi_walk_namespace+0xee/0x137
acpi_bus_trim+0x33/0x7a
acpi_bus_hot_remove_device+0xc4/0x1a1
acpi_os_execute_deferred+0x27/0x34
process_one_work+0x1f7/0x590
worker_thread+0x11a/0x370
kthread+0xee/0x100
ret_from_fork+0x7c/0xb0
RIP [<ffffffff811c41d2>] kfree+0x232/0x240
RSP <ffff88084678d968>
The reason why the messages are shown is to release a resource
structure, allocated by bootmem, by kfree(). So when we release a
resource structure, we should check whether it is allocated by bootmem
or not.
But even if we know a resource structure is allocated by bootmem, we
cannot release it since SLxB cannot treat it. So for reusing a resource
structure, this patch remembers it by using bootmem_resource as follows:
When releasing a resource structure by free_resource(), free_resource()
checks whether the resource structure is allocated by bootmem or not.
If it is allocated by bootmem, free_resource() adds it to
bootmem_resource. If it is not allocated by bootmem, free_resource()
release it by kfree().
And when getting a new resource structure by get_resource(),
get_resource() checks whether bootmem_resource has released resource
structures or not. If there is a released resource structure,
get_resource() returns it. If there is not a releaed resource
structure, get_resource() returns new resource structure allocated by
kzalloc().
[akpm@linux-foundation.org: s/get_resource/alloc_resource/]
Signed-off-by: Yasuaki Ishimatsu <isimatu.yasuaki@jp.fujitsu.com>
Reviewed-by: Toshi Kani <toshi.kani@hp.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Ram Pai <linuxram@us.ibm.com>
Cc: David Rientjes <rientjes@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-04-29 16:08:56 -06:00
|
|
|
free_resource(res);
|
2012-10-04 18:16:55 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
next_res->name = name;
|
|
|
|
next_res->start = conflict->end + 1;
|
|
|
|
next_res->end = end;
|
|
|
|
next_res->flags = IORESOURCE_BUSY;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
res->start = conflict->end + 1;
|
|
|
|
}
|
|
|
|
}
|
2008-09-04 13:02:44 -06:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2008-10-22 04:31:11 -06:00
|
|
|
void __init reserve_region_with_split(struct resource *root,
|
2008-09-04 13:02:44 -06:00
|
|
|
resource_size_t start, resource_size_t end,
|
|
|
|
const char *name)
|
|
|
|
{
|
2012-07-30 15:42:58 -06:00
|
|
|
int abort = 0;
|
|
|
|
|
2008-09-04 13:02:44 -06:00
|
|
|
write_lock(&resource_lock);
|
2012-07-30 15:42:58 -06:00
|
|
|
if (root->start > start || root->end < end) {
|
|
|
|
pr_err("requested range [0x%llx-0x%llx] not in root %pr\n",
|
|
|
|
(unsigned long long)start, (unsigned long long)end,
|
|
|
|
root);
|
|
|
|
if (start > root->end || end < root->start)
|
|
|
|
abort = 1;
|
|
|
|
else {
|
|
|
|
if (end > root->end)
|
|
|
|
end = root->end;
|
|
|
|
if (start < root->start)
|
|
|
|
start = root->start;
|
|
|
|
pr_err("fixing request to [0x%llx-0x%llx]\n",
|
|
|
|
(unsigned long long)start,
|
|
|
|
(unsigned long long)end);
|
|
|
|
}
|
|
|
|
dump_stack();
|
|
|
|
}
|
|
|
|
if (!abort)
|
|
|
|
__reserve_region_with_split(root, start, end, name);
|
2008-09-04 13:02:44 -06:00
|
|
|
write_unlock(&resource_lock);
|
|
|
|
}
|
|
|
|
|
PCI: clean up resource alignment management
Done per Linus' request and suggestions. Linus has explained that
better than I'll be able to explain:
On Thu, Mar 27, 2008 at 10:12:10AM -0700, Linus Torvalds wrote:
> Actually, before we go any further, there might be a less intrusive
> alternative: add just a couple of flags to the resource flags field (we
> still have something like 8 unused bits on 32-bit), and use those to
> implement a generic "resource_alignment()" routine.
>
> Two flags would do it:
>
> - IORESOURCE_SIZEALIGN: size indicates alignment (regular PCI device
> resources)
>
> - IORESOURCE_STARTALIGN: start field is alignment (PCI bus resources
> during probing)
>
> and then the case of both flags zero (or both bits set) would actually be
> "invalid", and we would also clear the IORESOURCE_STARTALIGN flag when we
> actually allocate the resource (so that we don't use the "start" field as
> alignment incorrectly when it no longer indicates alignment).
>
> That wouldn't be totally generic, but it would have the nice property of
> automatically at least add sanity checking for that whole "res->start has
> the odd meaning of 'alignment' during probing" and remove the need for a
> new field, and it would allow us to have a generic "resource_alignment()"
> routine that just gets a resource pointer.
Besides, I removed IORESOURCE_BUS_HAS_VGA flag which was unused for ages.
Signed-off-by: Ivan Kokshaysky <ink@jurassic.park.msu.ru>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Gary Hade <garyhade@us.ibm.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2008-03-30 09:50:14 -06:00
|
|
|
/**
|
|
|
|
* resource_alignment - calculate resource's alignment
|
|
|
|
* @res: resource pointer
|
|
|
|
*
|
|
|
|
* Returns alignment on success, 0 (invalid alignment) on failure.
|
|
|
|
*/
|
|
|
|
resource_size_t resource_alignment(struct resource *res)
|
|
|
|
{
|
|
|
|
switch (res->flags & (IORESOURCE_SIZEALIGN | IORESOURCE_STARTALIGN)) {
|
|
|
|
case IORESOURCE_SIZEALIGN:
|
2008-07-29 23:32:57 -06:00
|
|
|
return resource_size(res);
|
PCI: clean up resource alignment management
Done per Linus' request and suggestions. Linus has explained that
better than I'll be able to explain:
On Thu, Mar 27, 2008 at 10:12:10AM -0700, Linus Torvalds wrote:
> Actually, before we go any further, there might be a less intrusive
> alternative: add just a couple of flags to the resource flags field (we
> still have something like 8 unused bits on 32-bit), and use those to
> implement a generic "resource_alignment()" routine.
>
> Two flags would do it:
>
> - IORESOURCE_SIZEALIGN: size indicates alignment (regular PCI device
> resources)
>
> - IORESOURCE_STARTALIGN: start field is alignment (PCI bus resources
> during probing)
>
> and then the case of both flags zero (or both bits set) would actually be
> "invalid", and we would also clear the IORESOURCE_STARTALIGN flag when we
> actually allocate the resource (so that we don't use the "start" field as
> alignment incorrectly when it no longer indicates alignment).
>
> That wouldn't be totally generic, but it would have the nice property of
> automatically at least add sanity checking for that whole "res->start has
> the odd meaning of 'alignment' during probing" and remove the need for a
> new field, and it would allow us to have a generic "resource_alignment()"
> routine that just gets a resource pointer.
Besides, I removed IORESOURCE_BUS_HAS_VGA flag which was unused for ages.
Signed-off-by: Ivan Kokshaysky <ink@jurassic.park.msu.ru>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Gary Hade <garyhade@us.ibm.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2008-03-30 09:50:14 -06:00
|
|
|
case IORESOURCE_STARTALIGN:
|
|
|
|
return res->start;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* This is compatibility stuff for IO resources.
|
|
|
|
*
|
|
|
|
* Note how this, unlike the above, knows about
|
|
|
|
* the IO flag meanings (busy etc).
|
|
|
|
*
|
2006-10-03 02:13:51 -06:00
|
|
|
* request_region creates a new busy region.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2006-10-03 02:13:51 -06:00
|
|
|
* check_region returns non-zero if the area is already busy.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2006-10-03 02:13:51 -06:00
|
|
|
* release_region releases a matching busy region.
|
|
|
|
*/
|
|
|
|
|
2010-03-29 11:38:00 -06:00
|
|
|
static DECLARE_WAIT_QUEUE_HEAD(muxed_resource_wait);
|
|
|
|
|
2006-10-03 02:13:51 -06:00
|
|
|
/**
|
|
|
|
* __request_region - create a new busy resource region
|
|
|
|
* @parent: parent resource descriptor
|
|
|
|
* @start: resource start address
|
|
|
|
* @n: resource region size
|
|
|
|
* @name: reserving caller's ID string
|
2009-01-15 14:51:01 -07:00
|
|
|
* @flags: IO resource flags
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2006-06-12 17:09:23 -06:00
|
|
|
struct resource * __request_region(struct resource *parent,
|
|
|
|
resource_size_t start, resource_size_t n,
|
2008-10-22 20:55:31 -06:00
|
|
|
const char *name, int flags)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-03-29 11:38:00 -06:00
|
|
|
DECLARE_WAITQUEUE(wait, current);
|
mem hotunplug: fix kfree() of bootmem memory
When hot removing memory presented at boot time, following messages are shown:
kernel BUG at mm/slub.c:3409!
invalid opcode: 0000 [#1] SMP
Modules linked in: ebtable_nat ebtables xt_CHECKSUM iptable_mangle bridge stp llc ipmi_devintf ipmi_msghandler sunrpc ipt_REJECT nf_conntrack_ipv4 nf_defrag_ipv4 iptable_filter ip_tables ip6t_REJECT nf_conntrack_ipv6 nf_defrag_ipv6 xt_state nf_conntrack ip6table_filter ip6_tables binfmt_misc vfat fat dm_mirror dm_region_hash dm_log dm_mod vhost_net macvtap macvlan tun uinput iTCO_wdt iTCO_vendor_support coretemp kvm_intel kvm crc32c_intel ghash_clmulni_intel microcode pcspkr sg i2c_i801 lpc_ich mfd_core igb i2c_algo_bit i2c_core e1000e ptp pps_core tpm_infineon ioatdma dca sr_mod cdrom sd_mod crc_t10dif usb_storage megaraid_sas lpfc scsi_transport_fc scsi_tgt scsi_mod
CPU 0
Pid: 5091, comm: kworker/0:2 Tainted: G W 3.9.0-rc6+ #15
RIP: kfree+0x232/0x240
Process kworker/0:2 (pid: 5091, threadinfo ffff88084678c000, task ffff88083928ca80)
Call Trace:
__release_region+0xd4/0xe0
__remove_pages+0x52/0x110
arch_remove_memory+0x89/0xd0
remove_memory+0xc4/0x100
acpi_memory_device_remove+0x6d/0xb1
acpi_device_remove+0x89/0xab
__device_release_driver+0x7c/0xf0
device_release_driver+0x2f/0x50
acpi_bus_device_detach+0x6c/0x70
acpi_ns_walk_namespace+0x11a/0x250
acpi_walk_namespace+0xee/0x137
acpi_bus_trim+0x33/0x7a
acpi_bus_hot_remove_device+0xc4/0x1a1
acpi_os_execute_deferred+0x27/0x34
process_one_work+0x1f7/0x590
worker_thread+0x11a/0x370
kthread+0xee/0x100
ret_from_fork+0x7c/0xb0
RIP [<ffffffff811c41d2>] kfree+0x232/0x240
RSP <ffff88084678d968>
The reason why the messages are shown is to release a resource
structure, allocated by bootmem, by kfree(). So when we release a
resource structure, we should check whether it is allocated by bootmem
or not.
But even if we know a resource structure is allocated by bootmem, we
cannot release it since SLxB cannot treat it. So for reusing a resource
structure, this patch remembers it by using bootmem_resource as follows:
When releasing a resource structure by free_resource(), free_resource()
checks whether the resource structure is allocated by bootmem or not.
If it is allocated by bootmem, free_resource() adds it to
bootmem_resource. If it is not allocated by bootmem, free_resource()
release it by kfree().
And when getting a new resource structure by get_resource(),
get_resource() checks whether bootmem_resource has released resource
structures or not. If there is a released resource structure,
get_resource() returns it. If there is not a releaed resource
structure, get_resource() returns new resource structure allocated by
kzalloc().
[akpm@linux-foundation.org: s/get_resource/alloc_resource/]
Signed-off-by: Yasuaki Ishimatsu <isimatu.yasuaki@jp.fujitsu.com>
Reviewed-by: Toshi Kani <toshi.kani@hp.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Ram Pai <linuxram@us.ibm.com>
Cc: David Rientjes <rientjes@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-04-29 16:08:56 -06:00
|
|
|
struct resource *res = alloc_resource(GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-10-15 23:05:14 -06:00
|
|
|
if (!res)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
res->name = name;
|
|
|
|
res->start = start;
|
|
|
|
res->end = start + n - 1;
|
2014-03-07 09:22:19 -07:00
|
|
|
res->flags = resource_type(parent);
|
|
|
|
res->flags |= IORESOURCE_BUSY | flags;
|
2008-10-15 23:05:14 -06:00
|
|
|
|
|
|
|
write_lock(&resource_lock);
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
struct resource *conflict;
|
|
|
|
|
|
|
|
conflict = __request_resource(parent, res);
|
|
|
|
if (!conflict)
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
2008-10-15 23:05:14 -06:00
|
|
|
if (conflict != parent) {
|
|
|
|
parent = conflict;
|
|
|
|
if (!(conflict->flags & IORESOURCE_BUSY))
|
|
|
|
continue;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2010-03-29 11:38:00 -06:00
|
|
|
if (conflict->flags & flags & IORESOURCE_MUXED) {
|
|
|
|
add_wait_queue(&muxed_resource_wait, &wait);
|
|
|
|
write_unlock(&resource_lock);
|
|
|
|
set_current_state(TASK_UNINTERRUPTIBLE);
|
|
|
|
schedule();
|
|
|
|
remove_wait_queue(&muxed_resource_wait, &wait);
|
|
|
|
write_lock(&resource_lock);
|
|
|
|
continue;
|
|
|
|
}
|
2008-10-15 23:05:14 -06:00
|
|
|
/* Uhhuh, that didn't work out.. */
|
mem hotunplug: fix kfree() of bootmem memory
When hot removing memory presented at boot time, following messages are shown:
kernel BUG at mm/slub.c:3409!
invalid opcode: 0000 [#1] SMP
Modules linked in: ebtable_nat ebtables xt_CHECKSUM iptable_mangle bridge stp llc ipmi_devintf ipmi_msghandler sunrpc ipt_REJECT nf_conntrack_ipv4 nf_defrag_ipv4 iptable_filter ip_tables ip6t_REJECT nf_conntrack_ipv6 nf_defrag_ipv6 xt_state nf_conntrack ip6table_filter ip6_tables binfmt_misc vfat fat dm_mirror dm_region_hash dm_log dm_mod vhost_net macvtap macvlan tun uinput iTCO_wdt iTCO_vendor_support coretemp kvm_intel kvm crc32c_intel ghash_clmulni_intel microcode pcspkr sg i2c_i801 lpc_ich mfd_core igb i2c_algo_bit i2c_core e1000e ptp pps_core tpm_infineon ioatdma dca sr_mod cdrom sd_mod crc_t10dif usb_storage megaraid_sas lpfc scsi_transport_fc scsi_tgt scsi_mod
CPU 0
Pid: 5091, comm: kworker/0:2 Tainted: G W 3.9.0-rc6+ #15
RIP: kfree+0x232/0x240
Process kworker/0:2 (pid: 5091, threadinfo ffff88084678c000, task ffff88083928ca80)
Call Trace:
__release_region+0xd4/0xe0
__remove_pages+0x52/0x110
arch_remove_memory+0x89/0xd0
remove_memory+0xc4/0x100
acpi_memory_device_remove+0x6d/0xb1
acpi_device_remove+0x89/0xab
__device_release_driver+0x7c/0xf0
device_release_driver+0x2f/0x50
acpi_bus_device_detach+0x6c/0x70
acpi_ns_walk_namespace+0x11a/0x250
acpi_walk_namespace+0xee/0x137
acpi_bus_trim+0x33/0x7a
acpi_bus_hot_remove_device+0xc4/0x1a1
acpi_os_execute_deferred+0x27/0x34
process_one_work+0x1f7/0x590
worker_thread+0x11a/0x370
kthread+0xee/0x100
ret_from_fork+0x7c/0xb0
RIP [<ffffffff811c41d2>] kfree+0x232/0x240
RSP <ffff88084678d968>
The reason why the messages are shown is to release a resource
structure, allocated by bootmem, by kfree(). So when we release a
resource structure, we should check whether it is allocated by bootmem
or not.
But even if we know a resource structure is allocated by bootmem, we
cannot release it since SLxB cannot treat it. So for reusing a resource
structure, this patch remembers it by using bootmem_resource as follows:
When releasing a resource structure by free_resource(), free_resource()
checks whether the resource structure is allocated by bootmem or not.
If it is allocated by bootmem, free_resource() adds it to
bootmem_resource. If it is not allocated by bootmem, free_resource()
release it by kfree().
And when getting a new resource structure by get_resource(),
get_resource() checks whether bootmem_resource has released resource
structures or not. If there is a released resource structure,
get_resource() returns it. If there is not a releaed resource
structure, get_resource() returns new resource structure allocated by
kzalloc().
[akpm@linux-foundation.org: s/get_resource/alloc_resource/]
Signed-off-by: Yasuaki Ishimatsu <isimatu.yasuaki@jp.fujitsu.com>
Reviewed-by: Toshi Kani <toshi.kani@hp.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Ram Pai <linuxram@us.ibm.com>
Cc: David Rientjes <rientjes@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-04-29 16:08:56 -06:00
|
|
|
free_resource(res);
|
2008-10-15 23:05:14 -06:00
|
|
|
res = NULL;
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2008-10-15 23:05:14 -06:00
|
|
|
write_unlock(&resource_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(__request_region);
|
|
|
|
|
2006-10-03 02:13:51 -06:00
|
|
|
/**
|
|
|
|
* __check_region - check if a resource region is busy or free
|
|
|
|
* @parent: parent resource descriptor
|
|
|
|
* @start: resource start address
|
|
|
|
* @n: resource region size
|
|
|
|
*
|
|
|
|
* Returns 0 if the region is free at the moment it is checked,
|
|
|
|
* returns %-EBUSY if the region is busy.
|
|
|
|
*
|
|
|
|
* NOTE:
|
|
|
|
* This function is deprecated because its use is racy.
|
|
|
|
* Even if it returns 0, a subsequent call to request_region()
|
|
|
|
* may fail because another driver etc. just allocated the region.
|
|
|
|
* Do NOT use it. It will be removed from the kernel.
|
|
|
|
*/
|
2006-06-12 17:09:23 -06:00
|
|
|
int __check_region(struct resource *parent, resource_size_t start,
|
|
|
|
resource_size_t n)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct resource * res;
|
|
|
|
|
2008-10-22 20:55:31 -06:00
|
|
|
res = __request_region(parent, start, n, "check-region", 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!res)
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
release_resource(res);
|
mem hotunplug: fix kfree() of bootmem memory
When hot removing memory presented at boot time, following messages are shown:
kernel BUG at mm/slub.c:3409!
invalid opcode: 0000 [#1] SMP
Modules linked in: ebtable_nat ebtables xt_CHECKSUM iptable_mangle bridge stp llc ipmi_devintf ipmi_msghandler sunrpc ipt_REJECT nf_conntrack_ipv4 nf_defrag_ipv4 iptable_filter ip_tables ip6t_REJECT nf_conntrack_ipv6 nf_defrag_ipv6 xt_state nf_conntrack ip6table_filter ip6_tables binfmt_misc vfat fat dm_mirror dm_region_hash dm_log dm_mod vhost_net macvtap macvlan tun uinput iTCO_wdt iTCO_vendor_support coretemp kvm_intel kvm crc32c_intel ghash_clmulni_intel microcode pcspkr sg i2c_i801 lpc_ich mfd_core igb i2c_algo_bit i2c_core e1000e ptp pps_core tpm_infineon ioatdma dca sr_mod cdrom sd_mod crc_t10dif usb_storage megaraid_sas lpfc scsi_transport_fc scsi_tgt scsi_mod
CPU 0
Pid: 5091, comm: kworker/0:2 Tainted: G W 3.9.0-rc6+ #15
RIP: kfree+0x232/0x240
Process kworker/0:2 (pid: 5091, threadinfo ffff88084678c000, task ffff88083928ca80)
Call Trace:
__release_region+0xd4/0xe0
__remove_pages+0x52/0x110
arch_remove_memory+0x89/0xd0
remove_memory+0xc4/0x100
acpi_memory_device_remove+0x6d/0xb1
acpi_device_remove+0x89/0xab
__device_release_driver+0x7c/0xf0
device_release_driver+0x2f/0x50
acpi_bus_device_detach+0x6c/0x70
acpi_ns_walk_namespace+0x11a/0x250
acpi_walk_namespace+0xee/0x137
acpi_bus_trim+0x33/0x7a
acpi_bus_hot_remove_device+0xc4/0x1a1
acpi_os_execute_deferred+0x27/0x34
process_one_work+0x1f7/0x590
worker_thread+0x11a/0x370
kthread+0xee/0x100
ret_from_fork+0x7c/0xb0
RIP [<ffffffff811c41d2>] kfree+0x232/0x240
RSP <ffff88084678d968>
The reason why the messages are shown is to release a resource
structure, allocated by bootmem, by kfree(). So when we release a
resource structure, we should check whether it is allocated by bootmem
or not.
But even if we know a resource structure is allocated by bootmem, we
cannot release it since SLxB cannot treat it. So for reusing a resource
structure, this patch remembers it by using bootmem_resource as follows:
When releasing a resource structure by free_resource(), free_resource()
checks whether the resource structure is allocated by bootmem or not.
If it is allocated by bootmem, free_resource() adds it to
bootmem_resource. If it is not allocated by bootmem, free_resource()
release it by kfree().
And when getting a new resource structure by get_resource(),
get_resource() checks whether bootmem_resource has released resource
structures or not. If there is a released resource structure,
get_resource() returns it. If there is not a releaed resource
structure, get_resource() returns new resource structure allocated by
kzalloc().
[akpm@linux-foundation.org: s/get_resource/alloc_resource/]
Signed-off-by: Yasuaki Ishimatsu <isimatu.yasuaki@jp.fujitsu.com>
Reviewed-by: Toshi Kani <toshi.kani@hp.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Ram Pai <linuxram@us.ibm.com>
Cc: David Rientjes <rientjes@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-04-29 16:08:56 -06:00
|
|
|
free_resource(res);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(__check_region);
|
|
|
|
|
2006-10-03 02:13:51 -06:00
|
|
|
/**
|
|
|
|
* __release_region - release a previously reserved resource region
|
|
|
|
* @parent: parent resource descriptor
|
|
|
|
* @start: resource start address
|
|
|
|
* @n: resource region size
|
|
|
|
*
|
|
|
|
* The described resource region must match a currently busy region.
|
|
|
|
*/
|
2006-06-12 17:09:23 -06:00
|
|
|
void __release_region(struct resource *parent, resource_size_t start,
|
|
|
|
resource_size_t n)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct resource **p;
|
2006-06-12 17:09:23 -06:00
|
|
|
resource_size_t end;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
p = &parent->child;
|
|
|
|
end = start + n - 1;
|
|
|
|
|
|
|
|
write_lock(&resource_lock);
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
struct resource *res = *p;
|
|
|
|
|
|
|
|
if (!res)
|
|
|
|
break;
|
|
|
|
if (res->start <= start && res->end >= end) {
|
|
|
|
if (!(res->flags & IORESOURCE_BUSY)) {
|
|
|
|
p = &res->child;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (res->start != start || res->end != end)
|
|
|
|
break;
|
|
|
|
*p = res->sibling;
|
|
|
|
write_unlock(&resource_lock);
|
2010-03-29 11:38:00 -06:00
|
|
|
if (res->flags & IORESOURCE_MUXED)
|
|
|
|
wake_up(&muxed_resource_wait);
|
mem hotunplug: fix kfree() of bootmem memory
When hot removing memory presented at boot time, following messages are shown:
kernel BUG at mm/slub.c:3409!
invalid opcode: 0000 [#1] SMP
Modules linked in: ebtable_nat ebtables xt_CHECKSUM iptable_mangle bridge stp llc ipmi_devintf ipmi_msghandler sunrpc ipt_REJECT nf_conntrack_ipv4 nf_defrag_ipv4 iptable_filter ip_tables ip6t_REJECT nf_conntrack_ipv6 nf_defrag_ipv6 xt_state nf_conntrack ip6table_filter ip6_tables binfmt_misc vfat fat dm_mirror dm_region_hash dm_log dm_mod vhost_net macvtap macvlan tun uinput iTCO_wdt iTCO_vendor_support coretemp kvm_intel kvm crc32c_intel ghash_clmulni_intel microcode pcspkr sg i2c_i801 lpc_ich mfd_core igb i2c_algo_bit i2c_core e1000e ptp pps_core tpm_infineon ioatdma dca sr_mod cdrom sd_mod crc_t10dif usb_storage megaraid_sas lpfc scsi_transport_fc scsi_tgt scsi_mod
CPU 0
Pid: 5091, comm: kworker/0:2 Tainted: G W 3.9.0-rc6+ #15
RIP: kfree+0x232/0x240
Process kworker/0:2 (pid: 5091, threadinfo ffff88084678c000, task ffff88083928ca80)
Call Trace:
__release_region+0xd4/0xe0
__remove_pages+0x52/0x110
arch_remove_memory+0x89/0xd0
remove_memory+0xc4/0x100
acpi_memory_device_remove+0x6d/0xb1
acpi_device_remove+0x89/0xab
__device_release_driver+0x7c/0xf0
device_release_driver+0x2f/0x50
acpi_bus_device_detach+0x6c/0x70
acpi_ns_walk_namespace+0x11a/0x250
acpi_walk_namespace+0xee/0x137
acpi_bus_trim+0x33/0x7a
acpi_bus_hot_remove_device+0xc4/0x1a1
acpi_os_execute_deferred+0x27/0x34
process_one_work+0x1f7/0x590
worker_thread+0x11a/0x370
kthread+0xee/0x100
ret_from_fork+0x7c/0xb0
RIP [<ffffffff811c41d2>] kfree+0x232/0x240
RSP <ffff88084678d968>
The reason why the messages are shown is to release a resource
structure, allocated by bootmem, by kfree(). So when we release a
resource structure, we should check whether it is allocated by bootmem
or not.
But even if we know a resource structure is allocated by bootmem, we
cannot release it since SLxB cannot treat it. So for reusing a resource
structure, this patch remembers it by using bootmem_resource as follows:
When releasing a resource structure by free_resource(), free_resource()
checks whether the resource structure is allocated by bootmem or not.
If it is allocated by bootmem, free_resource() adds it to
bootmem_resource. If it is not allocated by bootmem, free_resource()
release it by kfree().
And when getting a new resource structure by get_resource(),
get_resource() checks whether bootmem_resource has released resource
structures or not. If there is a released resource structure,
get_resource() returns it. If there is not a releaed resource
structure, get_resource() returns new resource structure allocated by
kzalloc().
[akpm@linux-foundation.org: s/get_resource/alloc_resource/]
Signed-off-by: Yasuaki Ishimatsu <isimatu.yasuaki@jp.fujitsu.com>
Reviewed-by: Toshi Kani <toshi.kani@hp.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Ram Pai <linuxram@us.ibm.com>
Cc: David Rientjes <rientjes@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-04-29 16:08:56 -06:00
|
|
|
free_resource(res);
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
p = &res->sibling;
|
|
|
|
}
|
|
|
|
|
|
|
|
write_unlock(&resource_lock);
|
|
|
|
|
2006-06-12 16:18:31 -06:00
|
|
|
printk(KERN_WARNING "Trying to free nonexistent resource "
|
|
|
|
"<%016llx-%016llx>\n", (unsigned long long)start,
|
|
|
|
(unsigned long long)end);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(__release_region);
|
|
|
|
|
resource: add release_mem_region_adjustable()
Add release_mem_region_adjustable(), which releases a requested region
from a currently busy memory resource. This interface adjusts the
matched memory resource accordingly even if the requested region does
not match exactly but still fits into.
This new interface is intended for memory hot-delete. During bootup,
memory resources are inserted from the boot descriptor table, such as
EFI Memory Table and e820. Each memory resource entry usually covers
the whole contigous memory range. Memory hot-delete request, on the
other hand, may target to a particular range of memory resource, and its
size can be much smaller than the whole contiguous memory. Since the
existing release interfaces like __release_region() require a requested
region to be exactly matched to a resource entry, they do not allow a
partial resource to be released.
This new interface is restrictive (i.e. release under certain
conditions), which is consistent with other release interfaces,
__release_region() and __release_resource(). Additional release
conditions, such as an overlapping region to a resource entry, can be
supported after they are confirmed as valid cases.
There is no change to the existing interfaces since their restriction is
valid for I/O resources.
[akpm@linux-foundation.org: use GFP_ATOMIC under write_lock()]
[akpm@linux-foundation.org: switch back to GFP_KERNEL, less buggily]
[akpm@linux-foundation.org: remove unneeded and wrong kfree(), per Toshi]
Signed-off-by: Toshi Kani <toshi.kani@hp.com>
Reviewed-by : Yasuaki Ishimatsu <isimatu.yasuaki@jp.fujitsu.com>
Cc: David Rientjes <rientjes@google.com>
Reviewed-by: Ram Pai <linuxram@us.ibm.com>
Cc: T Makphaibulchoke <tmac@hp.com>
Cc: Wen Congyang <wency@cn.fujitsu.com>
Cc: Tang Chen <tangchen@cn.fujitsu.com>
Cc: Jiang Liu <jiang.liu@huawei.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-04-29 16:08:19 -06:00
|
|
|
#ifdef CONFIG_MEMORY_HOTREMOVE
|
|
|
|
/**
|
|
|
|
* release_mem_region_adjustable - release a previously reserved memory region
|
|
|
|
* @parent: parent resource descriptor
|
|
|
|
* @start: resource start address
|
|
|
|
* @size: resource region size
|
|
|
|
*
|
|
|
|
* This interface is intended for memory hot-delete. The requested region
|
|
|
|
* is released from a currently busy memory resource. The requested region
|
|
|
|
* must either match exactly or fit into a single busy resource entry. In
|
|
|
|
* the latter case, the remaining resource is adjusted accordingly.
|
|
|
|
* Existing children of the busy memory resource must be immutable in the
|
|
|
|
* request.
|
|
|
|
*
|
|
|
|
* Note:
|
|
|
|
* - Additional release conditions, such as overlapping region, can be
|
|
|
|
* supported after they are confirmed as valid cases.
|
|
|
|
* - When a busy memory resource gets split into two entries, the code
|
|
|
|
* assumes that all children remain in the lower address entry for
|
|
|
|
* simplicity. Enhance this logic when necessary.
|
|
|
|
*/
|
|
|
|
int release_mem_region_adjustable(struct resource *parent,
|
|
|
|
resource_size_t start, resource_size_t size)
|
|
|
|
{
|
|
|
|
struct resource **p;
|
|
|
|
struct resource *res;
|
|
|
|
struct resource *new_res;
|
|
|
|
resource_size_t end;
|
|
|
|
int ret = -EINVAL;
|
|
|
|
|
|
|
|
end = start + size - 1;
|
|
|
|
if ((start < parent->start) || (end > parent->end))
|
|
|
|
return ret;
|
|
|
|
|
mem hotunplug: fix kfree() of bootmem memory
When hot removing memory presented at boot time, following messages are shown:
kernel BUG at mm/slub.c:3409!
invalid opcode: 0000 [#1] SMP
Modules linked in: ebtable_nat ebtables xt_CHECKSUM iptable_mangle bridge stp llc ipmi_devintf ipmi_msghandler sunrpc ipt_REJECT nf_conntrack_ipv4 nf_defrag_ipv4 iptable_filter ip_tables ip6t_REJECT nf_conntrack_ipv6 nf_defrag_ipv6 xt_state nf_conntrack ip6table_filter ip6_tables binfmt_misc vfat fat dm_mirror dm_region_hash dm_log dm_mod vhost_net macvtap macvlan tun uinput iTCO_wdt iTCO_vendor_support coretemp kvm_intel kvm crc32c_intel ghash_clmulni_intel microcode pcspkr sg i2c_i801 lpc_ich mfd_core igb i2c_algo_bit i2c_core e1000e ptp pps_core tpm_infineon ioatdma dca sr_mod cdrom sd_mod crc_t10dif usb_storage megaraid_sas lpfc scsi_transport_fc scsi_tgt scsi_mod
CPU 0
Pid: 5091, comm: kworker/0:2 Tainted: G W 3.9.0-rc6+ #15
RIP: kfree+0x232/0x240
Process kworker/0:2 (pid: 5091, threadinfo ffff88084678c000, task ffff88083928ca80)
Call Trace:
__release_region+0xd4/0xe0
__remove_pages+0x52/0x110
arch_remove_memory+0x89/0xd0
remove_memory+0xc4/0x100
acpi_memory_device_remove+0x6d/0xb1
acpi_device_remove+0x89/0xab
__device_release_driver+0x7c/0xf0
device_release_driver+0x2f/0x50
acpi_bus_device_detach+0x6c/0x70
acpi_ns_walk_namespace+0x11a/0x250
acpi_walk_namespace+0xee/0x137
acpi_bus_trim+0x33/0x7a
acpi_bus_hot_remove_device+0xc4/0x1a1
acpi_os_execute_deferred+0x27/0x34
process_one_work+0x1f7/0x590
worker_thread+0x11a/0x370
kthread+0xee/0x100
ret_from_fork+0x7c/0xb0
RIP [<ffffffff811c41d2>] kfree+0x232/0x240
RSP <ffff88084678d968>
The reason why the messages are shown is to release a resource
structure, allocated by bootmem, by kfree(). So when we release a
resource structure, we should check whether it is allocated by bootmem
or not.
But even if we know a resource structure is allocated by bootmem, we
cannot release it since SLxB cannot treat it. So for reusing a resource
structure, this patch remembers it by using bootmem_resource as follows:
When releasing a resource structure by free_resource(), free_resource()
checks whether the resource structure is allocated by bootmem or not.
If it is allocated by bootmem, free_resource() adds it to
bootmem_resource. If it is not allocated by bootmem, free_resource()
release it by kfree().
And when getting a new resource structure by get_resource(),
get_resource() checks whether bootmem_resource has released resource
structures or not. If there is a released resource structure,
get_resource() returns it. If there is not a releaed resource
structure, get_resource() returns new resource structure allocated by
kzalloc().
[akpm@linux-foundation.org: s/get_resource/alloc_resource/]
Signed-off-by: Yasuaki Ishimatsu <isimatu.yasuaki@jp.fujitsu.com>
Reviewed-by: Toshi Kani <toshi.kani@hp.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Ram Pai <linuxram@us.ibm.com>
Cc: David Rientjes <rientjes@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-04-29 16:08:56 -06:00
|
|
|
/* The alloc_resource() result gets checked later */
|
|
|
|
new_res = alloc_resource(GFP_KERNEL);
|
resource: add release_mem_region_adjustable()
Add release_mem_region_adjustable(), which releases a requested region
from a currently busy memory resource. This interface adjusts the
matched memory resource accordingly even if the requested region does
not match exactly but still fits into.
This new interface is intended for memory hot-delete. During bootup,
memory resources are inserted from the boot descriptor table, such as
EFI Memory Table and e820. Each memory resource entry usually covers
the whole contigous memory range. Memory hot-delete request, on the
other hand, may target to a particular range of memory resource, and its
size can be much smaller than the whole contiguous memory. Since the
existing release interfaces like __release_region() require a requested
region to be exactly matched to a resource entry, they do not allow a
partial resource to be released.
This new interface is restrictive (i.e. release under certain
conditions), which is consistent with other release interfaces,
__release_region() and __release_resource(). Additional release
conditions, such as an overlapping region to a resource entry, can be
supported after they are confirmed as valid cases.
There is no change to the existing interfaces since their restriction is
valid for I/O resources.
[akpm@linux-foundation.org: use GFP_ATOMIC under write_lock()]
[akpm@linux-foundation.org: switch back to GFP_KERNEL, less buggily]
[akpm@linux-foundation.org: remove unneeded and wrong kfree(), per Toshi]
Signed-off-by: Toshi Kani <toshi.kani@hp.com>
Reviewed-by : Yasuaki Ishimatsu <isimatu.yasuaki@jp.fujitsu.com>
Cc: David Rientjes <rientjes@google.com>
Reviewed-by: Ram Pai <linuxram@us.ibm.com>
Cc: T Makphaibulchoke <tmac@hp.com>
Cc: Wen Congyang <wency@cn.fujitsu.com>
Cc: Tang Chen <tangchen@cn.fujitsu.com>
Cc: Jiang Liu <jiang.liu@huawei.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-04-29 16:08:19 -06:00
|
|
|
|
|
|
|
p = &parent->child;
|
|
|
|
write_lock(&resource_lock);
|
|
|
|
|
|
|
|
while ((res = *p)) {
|
|
|
|
if (res->start >= end)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* look for the next resource if it does not fit into */
|
|
|
|
if (res->start > start || res->end < end) {
|
|
|
|
p = &res->sibling;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(res->flags & IORESOURCE_MEM))
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (!(res->flags & IORESOURCE_BUSY)) {
|
|
|
|
p = &res->child;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* found the target resource; let's adjust accordingly */
|
|
|
|
if (res->start == start && res->end == end) {
|
|
|
|
/* free the whole entry */
|
|
|
|
*p = res->sibling;
|
mem hotunplug: fix kfree() of bootmem memory
When hot removing memory presented at boot time, following messages are shown:
kernel BUG at mm/slub.c:3409!
invalid opcode: 0000 [#1] SMP
Modules linked in: ebtable_nat ebtables xt_CHECKSUM iptable_mangle bridge stp llc ipmi_devintf ipmi_msghandler sunrpc ipt_REJECT nf_conntrack_ipv4 nf_defrag_ipv4 iptable_filter ip_tables ip6t_REJECT nf_conntrack_ipv6 nf_defrag_ipv6 xt_state nf_conntrack ip6table_filter ip6_tables binfmt_misc vfat fat dm_mirror dm_region_hash dm_log dm_mod vhost_net macvtap macvlan tun uinput iTCO_wdt iTCO_vendor_support coretemp kvm_intel kvm crc32c_intel ghash_clmulni_intel microcode pcspkr sg i2c_i801 lpc_ich mfd_core igb i2c_algo_bit i2c_core e1000e ptp pps_core tpm_infineon ioatdma dca sr_mod cdrom sd_mod crc_t10dif usb_storage megaraid_sas lpfc scsi_transport_fc scsi_tgt scsi_mod
CPU 0
Pid: 5091, comm: kworker/0:2 Tainted: G W 3.9.0-rc6+ #15
RIP: kfree+0x232/0x240
Process kworker/0:2 (pid: 5091, threadinfo ffff88084678c000, task ffff88083928ca80)
Call Trace:
__release_region+0xd4/0xe0
__remove_pages+0x52/0x110
arch_remove_memory+0x89/0xd0
remove_memory+0xc4/0x100
acpi_memory_device_remove+0x6d/0xb1
acpi_device_remove+0x89/0xab
__device_release_driver+0x7c/0xf0
device_release_driver+0x2f/0x50
acpi_bus_device_detach+0x6c/0x70
acpi_ns_walk_namespace+0x11a/0x250
acpi_walk_namespace+0xee/0x137
acpi_bus_trim+0x33/0x7a
acpi_bus_hot_remove_device+0xc4/0x1a1
acpi_os_execute_deferred+0x27/0x34
process_one_work+0x1f7/0x590
worker_thread+0x11a/0x370
kthread+0xee/0x100
ret_from_fork+0x7c/0xb0
RIP [<ffffffff811c41d2>] kfree+0x232/0x240
RSP <ffff88084678d968>
The reason why the messages are shown is to release a resource
structure, allocated by bootmem, by kfree(). So when we release a
resource structure, we should check whether it is allocated by bootmem
or not.
But even if we know a resource structure is allocated by bootmem, we
cannot release it since SLxB cannot treat it. So for reusing a resource
structure, this patch remembers it by using bootmem_resource as follows:
When releasing a resource structure by free_resource(), free_resource()
checks whether the resource structure is allocated by bootmem or not.
If it is allocated by bootmem, free_resource() adds it to
bootmem_resource. If it is not allocated by bootmem, free_resource()
release it by kfree().
And when getting a new resource structure by get_resource(),
get_resource() checks whether bootmem_resource has released resource
structures or not. If there is a released resource structure,
get_resource() returns it. If there is not a releaed resource
structure, get_resource() returns new resource structure allocated by
kzalloc().
[akpm@linux-foundation.org: s/get_resource/alloc_resource/]
Signed-off-by: Yasuaki Ishimatsu <isimatu.yasuaki@jp.fujitsu.com>
Reviewed-by: Toshi Kani <toshi.kani@hp.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Ram Pai <linuxram@us.ibm.com>
Cc: David Rientjes <rientjes@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-04-29 16:08:56 -06:00
|
|
|
free_resource(res);
|
resource: add release_mem_region_adjustable()
Add release_mem_region_adjustable(), which releases a requested region
from a currently busy memory resource. This interface adjusts the
matched memory resource accordingly even if the requested region does
not match exactly but still fits into.
This new interface is intended for memory hot-delete. During bootup,
memory resources are inserted from the boot descriptor table, such as
EFI Memory Table and e820. Each memory resource entry usually covers
the whole contigous memory range. Memory hot-delete request, on the
other hand, may target to a particular range of memory resource, and its
size can be much smaller than the whole contiguous memory. Since the
existing release interfaces like __release_region() require a requested
region to be exactly matched to a resource entry, they do not allow a
partial resource to be released.
This new interface is restrictive (i.e. release under certain
conditions), which is consistent with other release interfaces,
__release_region() and __release_resource(). Additional release
conditions, such as an overlapping region to a resource entry, can be
supported after they are confirmed as valid cases.
There is no change to the existing interfaces since their restriction is
valid for I/O resources.
[akpm@linux-foundation.org: use GFP_ATOMIC under write_lock()]
[akpm@linux-foundation.org: switch back to GFP_KERNEL, less buggily]
[akpm@linux-foundation.org: remove unneeded and wrong kfree(), per Toshi]
Signed-off-by: Toshi Kani <toshi.kani@hp.com>
Reviewed-by : Yasuaki Ishimatsu <isimatu.yasuaki@jp.fujitsu.com>
Cc: David Rientjes <rientjes@google.com>
Reviewed-by: Ram Pai <linuxram@us.ibm.com>
Cc: T Makphaibulchoke <tmac@hp.com>
Cc: Wen Congyang <wency@cn.fujitsu.com>
Cc: Tang Chen <tangchen@cn.fujitsu.com>
Cc: Jiang Liu <jiang.liu@huawei.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-04-29 16:08:19 -06:00
|
|
|
ret = 0;
|
|
|
|
} else if (res->start == start && res->end != end) {
|
|
|
|
/* adjust the start */
|
|
|
|
ret = __adjust_resource(res, end + 1,
|
|
|
|
res->end - end);
|
|
|
|
} else if (res->start != start && res->end == end) {
|
|
|
|
/* adjust the end */
|
|
|
|
ret = __adjust_resource(res, res->start,
|
|
|
|
start - res->start);
|
|
|
|
} else {
|
|
|
|
/* split into two entries */
|
|
|
|
if (!new_res) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
new_res->name = res->name;
|
|
|
|
new_res->start = end + 1;
|
|
|
|
new_res->end = res->end;
|
|
|
|
new_res->flags = res->flags;
|
|
|
|
new_res->parent = res->parent;
|
|
|
|
new_res->sibling = res->sibling;
|
|
|
|
new_res->child = NULL;
|
|
|
|
|
|
|
|
ret = __adjust_resource(res, res->start,
|
|
|
|
start - res->start);
|
|
|
|
if (ret)
|
|
|
|
break;
|
|
|
|
res->sibling = new_res;
|
|
|
|
new_res = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
write_unlock(&resource_lock);
|
mem hotunplug: fix kfree() of bootmem memory
When hot removing memory presented at boot time, following messages are shown:
kernel BUG at mm/slub.c:3409!
invalid opcode: 0000 [#1] SMP
Modules linked in: ebtable_nat ebtables xt_CHECKSUM iptable_mangle bridge stp llc ipmi_devintf ipmi_msghandler sunrpc ipt_REJECT nf_conntrack_ipv4 nf_defrag_ipv4 iptable_filter ip_tables ip6t_REJECT nf_conntrack_ipv6 nf_defrag_ipv6 xt_state nf_conntrack ip6table_filter ip6_tables binfmt_misc vfat fat dm_mirror dm_region_hash dm_log dm_mod vhost_net macvtap macvlan tun uinput iTCO_wdt iTCO_vendor_support coretemp kvm_intel kvm crc32c_intel ghash_clmulni_intel microcode pcspkr sg i2c_i801 lpc_ich mfd_core igb i2c_algo_bit i2c_core e1000e ptp pps_core tpm_infineon ioatdma dca sr_mod cdrom sd_mod crc_t10dif usb_storage megaraid_sas lpfc scsi_transport_fc scsi_tgt scsi_mod
CPU 0
Pid: 5091, comm: kworker/0:2 Tainted: G W 3.9.0-rc6+ #15
RIP: kfree+0x232/0x240
Process kworker/0:2 (pid: 5091, threadinfo ffff88084678c000, task ffff88083928ca80)
Call Trace:
__release_region+0xd4/0xe0
__remove_pages+0x52/0x110
arch_remove_memory+0x89/0xd0
remove_memory+0xc4/0x100
acpi_memory_device_remove+0x6d/0xb1
acpi_device_remove+0x89/0xab
__device_release_driver+0x7c/0xf0
device_release_driver+0x2f/0x50
acpi_bus_device_detach+0x6c/0x70
acpi_ns_walk_namespace+0x11a/0x250
acpi_walk_namespace+0xee/0x137
acpi_bus_trim+0x33/0x7a
acpi_bus_hot_remove_device+0xc4/0x1a1
acpi_os_execute_deferred+0x27/0x34
process_one_work+0x1f7/0x590
worker_thread+0x11a/0x370
kthread+0xee/0x100
ret_from_fork+0x7c/0xb0
RIP [<ffffffff811c41d2>] kfree+0x232/0x240
RSP <ffff88084678d968>
The reason why the messages are shown is to release a resource
structure, allocated by bootmem, by kfree(). So when we release a
resource structure, we should check whether it is allocated by bootmem
or not.
But even if we know a resource structure is allocated by bootmem, we
cannot release it since SLxB cannot treat it. So for reusing a resource
structure, this patch remembers it by using bootmem_resource as follows:
When releasing a resource structure by free_resource(), free_resource()
checks whether the resource structure is allocated by bootmem or not.
If it is allocated by bootmem, free_resource() adds it to
bootmem_resource. If it is not allocated by bootmem, free_resource()
release it by kfree().
And when getting a new resource structure by get_resource(),
get_resource() checks whether bootmem_resource has released resource
structures or not. If there is a released resource structure,
get_resource() returns it. If there is not a releaed resource
structure, get_resource() returns new resource structure allocated by
kzalloc().
[akpm@linux-foundation.org: s/get_resource/alloc_resource/]
Signed-off-by: Yasuaki Ishimatsu <isimatu.yasuaki@jp.fujitsu.com>
Reviewed-by: Toshi Kani <toshi.kani@hp.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Ram Pai <linuxram@us.ibm.com>
Cc: David Rientjes <rientjes@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-04-29 16:08:56 -06:00
|
|
|
free_resource(new_res);
|
resource: add release_mem_region_adjustable()
Add release_mem_region_adjustable(), which releases a requested region
from a currently busy memory resource. This interface adjusts the
matched memory resource accordingly even if the requested region does
not match exactly but still fits into.
This new interface is intended for memory hot-delete. During bootup,
memory resources are inserted from the boot descriptor table, such as
EFI Memory Table and e820. Each memory resource entry usually covers
the whole contigous memory range. Memory hot-delete request, on the
other hand, may target to a particular range of memory resource, and its
size can be much smaller than the whole contiguous memory. Since the
existing release interfaces like __release_region() require a requested
region to be exactly matched to a resource entry, they do not allow a
partial resource to be released.
This new interface is restrictive (i.e. release under certain
conditions), which is consistent with other release interfaces,
__release_region() and __release_resource(). Additional release
conditions, such as an overlapping region to a resource entry, can be
supported after they are confirmed as valid cases.
There is no change to the existing interfaces since their restriction is
valid for I/O resources.
[akpm@linux-foundation.org: use GFP_ATOMIC under write_lock()]
[akpm@linux-foundation.org: switch back to GFP_KERNEL, less buggily]
[akpm@linux-foundation.org: remove unneeded and wrong kfree(), per Toshi]
Signed-off-by: Toshi Kani <toshi.kani@hp.com>
Reviewed-by : Yasuaki Ishimatsu <isimatu.yasuaki@jp.fujitsu.com>
Cc: David Rientjes <rientjes@google.com>
Reviewed-by: Ram Pai <linuxram@us.ibm.com>
Cc: T Makphaibulchoke <tmac@hp.com>
Cc: Wen Congyang <wency@cn.fujitsu.com>
Cc: Tang Chen <tangchen@cn.fujitsu.com>
Cc: Jiang Liu <jiang.liu@huawei.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-04-29 16:08:19 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_MEMORY_HOTREMOVE */
|
|
|
|
|
devres: device resource management
Implement device resource management, in short, devres. A device
driver can allocate arbirary size of devres data which is associated
with a release function. On driver detach, release function is
invoked on the devres data, then, devres data is freed.
devreses are typed by associated release functions. Some devreses are
better represented by single instance of the type while others need
multiple instances sharing the same release function. Both usages are
supported.
devreses can be grouped using devres group such that a device driver
can easily release acquired resources halfway through initialization
or selectively release resources (e.g. resources for port 1 out of 4
ports).
This patch adds devres core including documentation and the following
managed interfaces.
* alloc/free : devm_kzalloc(), devm_kzfree()
* IO region : devm_request_region(), devm_release_region()
* IRQ : devm_request_irq(), devm_free_irq()
* DMA : dmam_alloc_coherent(), dmam_free_coherent(),
dmam_declare_coherent_memory(), dmam_pool_create(),
dmam_pool_destroy()
* PCI : pcim_enable_device(), pcim_pin_device(), pci_is_managed()
* iomap : devm_ioport_map(), devm_ioport_unmap(), devm_ioremap(),
devm_ioremap_nocache(), devm_iounmap(), pcim_iomap_table(),
pcim_iomap(), pcim_iounmap()
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-01-20 00:00:26 -07:00
|
|
|
/*
|
|
|
|
* Managed region resource
|
|
|
|
*/
|
|
|
|
struct region_devres {
|
|
|
|
struct resource *parent;
|
|
|
|
resource_size_t start;
|
|
|
|
resource_size_t n;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void devm_region_release(struct device *dev, void *res)
|
|
|
|
{
|
|
|
|
struct region_devres *this = res;
|
|
|
|
|
|
|
|
__release_region(this->parent, this->start, this->n);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int devm_region_match(struct device *dev, void *res, void *match_data)
|
|
|
|
{
|
|
|
|
struct region_devres *this = res, *match = match_data;
|
|
|
|
|
|
|
|
return this->parent == match->parent &&
|
|
|
|
this->start == match->start && this->n == match->n;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct resource * __devm_request_region(struct device *dev,
|
|
|
|
struct resource *parent, resource_size_t start,
|
|
|
|
resource_size_t n, const char *name)
|
|
|
|
{
|
|
|
|
struct region_devres *dr = NULL;
|
|
|
|
struct resource *res;
|
|
|
|
|
|
|
|
dr = devres_alloc(devm_region_release, sizeof(struct region_devres),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!dr)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
dr->parent = parent;
|
|
|
|
dr->start = start;
|
|
|
|
dr->n = n;
|
|
|
|
|
2008-10-22 20:55:31 -06:00
|
|
|
res = __request_region(parent, start, n, name, 0);
|
devres: device resource management
Implement device resource management, in short, devres. A device
driver can allocate arbirary size of devres data which is associated
with a release function. On driver detach, release function is
invoked on the devres data, then, devres data is freed.
devreses are typed by associated release functions. Some devreses are
better represented by single instance of the type while others need
multiple instances sharing the same release function. Both usages are
supported.
devreses can be grouped using devres group such that a device driver
can easily release acquired resources halfway through initialization
or selectively release resources (e.g. resources for port 1 out of 4
ports).
This patch adds devres core including documentation and the following
managed interfaces.
* alloc/free : devm_kzalloc(), devm_kzfree()
* IO region : devm_request_region(), devm_release_region()
* IRQ : devm_request_irq(), devm_free_irq()
* DMA : dmam_alloc_coherent(), dmam_free_coherent(),
dmam_declare_coherent_memory(), dmam_pool_create(),
dmam_pool_destroy()
* PCI : pcim_enable_device(), pcim_pin_device(), pci_is_managed()
* iomap : devm_ioport_map(), devm_ioport_unmap(), devm_ioremap(),
devm_ioremap_nocache(), devm_iounmap(), pcim_iomap_table(),
pcim_iomap(), pcim_iounmap()
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-01-20 00:00:26 -07:00
|
|
|
if (res)
|
|
|
|
devres_add(dev, dr);
|
|
|
|
else
|
|
|
|
devres_free(dr);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(__devm_request_region);
|
|
|
|
|
|
|
|
void __devm_release_region(struct device *dev, struct resource *parent,
|
|
|
|
resource_size_t start, resource_size_t n)
|
|
|
|
{
|
|
|
|
struct region_devres match_data = { parent, start, n };
|
|
|
|
|
|
|
|
__release_region(parent, start, n);
|
|
|
|
WARN_ON(devres_destroy(dev, devm_region_release, devm_region_match,
|
|
|
|
&match_data));
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(__devm_release_region);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Called from init/main.c to reserve IO ports.
|
|
|
|
*/
|
|
|
|
#define MAXRESERVE 4
|
|
|
|
static int __init reserve_setup(char *str)
|
|
|
|
{
|
|
|
|
static int reserved;
|
|
|
|
static struct resource reserve[MAXRESERVE];
|
|
|
|
|
|
|
|
for (;;) {
|
2009-06-30 12:41:31 -06:00
|
|
|
unsigned int io_start, io_num;
|
2005-04-16 16:20:36 -06:00
|
|
|
int x = reserved;
|
|
|
|
|
|
|
|
if (get_option (&str, &io_start) != 2)
|
|
|
|
break;
|
|
|
|
if (get_option (&str, &io_num) == 0)
|
|
|
|
break;
|
|
|
|
if (x < MAXRESERVE) {
|
|
|
|
struct resource *res = reserve + x;
|
|
|
|
res->name = "reserved";
|
|
|
|
res->start = io_start;
|
|
|
|
res->end = io_start + io_num - 1;
|
|
|
|
res->flags = IORESOURCE_BUSY;
|
|
|
|
res->child = NULL;
|
|
|
|
if (request_resource(res->start >= 0x10000 ? &iomem_resource : &ioport_resource, res) == 0)
|
|
|
|
reserved = x+1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
__setup("reserve=", reserve_setup);
|
2008-09-25 19:43:34 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if the requested addr and size spans more than any slot in the
|
|
|
|
* iomem resource tree.
|
|
|
|
*/
|
|
|
|
int iomem_map_sanity_check(resource_size_t addr, unsigned long size)
|
|
|
|
{
|
|
|
|
struct resource *p = &iomem_resource;
|
|
|
|
int err = 0;
|
|
|
|
loff_t l;
|
|
|
|
|
|
|
|
read_lock(&resource_lock);
|
|
|
|
for (p = p->child; p ; p = r_next(NULL, p, &l)) {
|
|
|
|
/*
|
|
|
|
* We can probably skip the resources without
|
|
|
|
* IORESOURCE_IO attribute?
|
|
|
|
*/
|
|
|
|
if (p->start >= addr + size)
|
|
|
|
continue;
|
|
|
|
if (p->end < addr)
|
|
|
|
continue;
|
2008-10-28 12:45:42 -06:00
|
|
|
if (PFN_DOWN(p->start) <= PFN_DOWN(addr) &&
|
|
|
|
PFN_DOWN(p->end) >= PFN_DOWN(addr + size - 1))
|
2008-09-25 19:43:34 -06:00
|
|
|
continue;
|
2008-12-13 10:15:27 -07:00
|
|
|
/*
|
|
|
|
* if a resource is "BUSY", it's not a hardware resource
|
|
|
|
* but a driver mapping of such a resource; we don't want
|
|
|
|
* to warn for those; some drivers legitimately map only
|
|
|
|
* partial hardware resources. (example: vesafb)
|
|
|
|
*/
|
|
|
|
if (p->flags & IORESOURCE_BUSY)
|
|
|
|
continue;
|
|
|
|
|
2008-09-25 19:43:34 -06:00
|
|
|
printk(KERN_WARNING "resource map sanity check conflict: "
|
|
|
|
"0x%llx 0x%llx 0x%llx 0x%llx %s\n",
|
2008-09-26 02:10:12 -06:00
|
|
|
(unsigned long long)addr,
|
|
|
|
(unsigned long long)(addr + size - 1),
|
|
|
|
(unsigned long long)p->start,
|
|
|
|
(unsigned long long)p->end,
|
|
|
|
p->name);
|
2008-09-25 19:43:34 -06:00
|
|
|
err = -1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
read_unlock(&resource_lock);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
2008-10-22 20:55:31 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_STRICT_DEVMEM
|
|
|
|
static int strict_iomem_checks = 1;
|
|
|
|
#else
|
|
|
|
static int strict_iomem_checks;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* check if an address is reserved in the iomem resource tree
|
|
|
|
* returns 1 if reserved, 0 if not reserved.
|
|
|
|
*/
|
|
|
|
int iomem_is_exclusive(u64 addr)
|
|
|
|
{
|
|
|
|
struct resource *p = &iomem_resource;
|
|
|
|
int err = 0;
|
|
|
|
loff_t l;
|
|
|
|
int size = PAGE_SIZE;
|
|
|
|
|
|
|
|
if (!strict_iomem_checks)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
addr = addr & PAGE_MASK;
|
|
|
|
|
|
|
|
read_lock(&resource_lock);
|
|
|
|
for (p = p->child; p ; p = r_next(NULL, p, &l)) {
|
|
|
|
/*
|
|
|
|
* We can probably skip the resources without
|
|
|
|
* IORESOURCE_IO attribute?
|
|
|
|
*/
|
|
|
|
if (p->start >= addr + size)
|
|
|
|
break;
|
|
|
|
if (p->end < addr)
|
|
|
|
continue;
|
|
|
|
if (p->flags & IORESOURCE_BUSY &&
|
|
|
|
p->flags & IORESOURCE_EXCLUSIVE) {
|
|
|
|
err = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
read_unlock(&resource_lock);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init strict_iomem(char *str)
|
|
|
|
{
|
|
|
|
if (strstr(str, "relaxed"))
|
|
|
|
strict_iomem_checks = 0;
|
|
|
|
if (strstr(str, "strict"))
|
|
|
|
strict_iomem_checks = 1;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
__setup("iomem=", strict_iomem);
|