renegade-project/linux-next
2
0
Fork 0
mirror of https://github.com/edk2-porting/linux-next.git synced 2024-12-18 10:13:57 +08:00
Code

[PATCH] acpi memory hotplug cannot manage _CRS with plural resoureces

Browse Source 
Current acpi memory hotplug just looks into the first entry of resources in
_CRS.  But, _CRS can contain plural resources.  So, if _CRS contains plural
resoureces, acpi memory hot add cannot add all memory.

With this patch, acpi memory hotplug can deal with Memory Device, whose
_CRS contains plural resources.

Tested on ia64 memory hotplug test envrionment (not emulation, uses alpha
version firmware which supports dynamic reconfiguration of NUMA.)

Note: Microsoft's Windows Server 2003 requires big (>4G)resoureces to be
      divided into small (<4G) resources. looks crazy, but not invalid.
      (See http://www.microsoft.com/whdc/system/pnppwr/hotadd/hotaddmem.mspx)
      For this reason, a firmware vendor who supports Windows writes plural
      resources in a _CRS even if they are contiguous.

Signed-off-by: Kenji Kaneshige <kaneshige.kenji@jp.fujitsu.com>
Signed-off-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Cc: "Brown, Len" <len.brown@intel.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
This commit is contained in:
KAMEZAWA Hiroyuki 2006-06-27 02:53:27 -07:00 committed by Linus Torvalds
parent 5c31f2738a
commit 9ac023989e
1 changed files with 77 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

112
drivers/acpi/acpi_memhotplug.c
View File

@ -68,45 +68,75 @@ static struct acpi_driver acpi_memory_device_driver = {
}, },
}; };
struct acpi_memory_info {
struct list_head list;
u64 start_addr; /* Memory Range start physical addr */
u64 length; /* Memory Range length */
unsigned short caching; /* memory cache attribute */
unsigned short write_protect; /* memory read/write attribute */
unsigned int enabled:1;
};
struct acpi_memory_device { struct acpi_memory_device {
acpi_handle handle; acpi_handle handle;
unsigned int state; /* State of the memory device */ unsigned int state; /* State of the memory device */
unsigned short caching; /* memory cache attribute */ struct list_head res_list;
unsigned short write_protect; /* memory read/write attribute */
u64 start_addr; /* Memory Range start physical addr */
u64 length; /* Memory Range length */
}; };
static acpi_status
acpi_memory_get_resource(struct acpi_resource *resource, void *context)
{
struct acpi_memory_device *mem_device = context;
struct acpi_resource_address64 address64;
struct acpi_memory_info *info, *new;
acpi_status status;
status = acpi_resource_to_address64(resource, &address64);
if (ACPI_FAILURE(status) ||
(address64.resource_type != ACPI_MEMORY_RANGE))
return AE_OK;
list_for_each_entry(info, &mem_device->res_list, list) {
/* Can we combine the resource range information? */
if ((info->caching == address64.info.mem.caching) &&
(info->write_protect == address64.info.mem.write_protect) &&
(info->start_addr + info->length == address64.minimum)) {
info->length += address64.address_length;
return AE_OK;
}
}
new = kzalloc(sizeof(struct acpi_memory_info), GFP_KERNEL);
if (!new)
return AE_ERROR;
INIT_LIST_HEAD(&new->list);
new->caching = address64.info.mem.caching;
new->write_protect = address64.info.mem.write_protect;
new->start_addr = address64.minimum;
new->length = address64.address_length;
list_add_tail(&new->list, &mem_device->res_list);
return AE_OK;
}
static int static int
acpi_memory_get_device_resources(struct acpi_memory_device *mem_device) acpi_memory_get_device_resources(struct acpi_memory_device *mem_device)
{ {
acpi_status status; acpi_status status;
struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; struct acpi_memory_info *info, *n;
struct acpi_resource *resource = NULL;
struct acpi_resource_address64 address64;
ACPI_FUNCTION_TRACE("acpi_memory_get_device_resources"); ACPI_FUNCTION_TRACE("acpi_memory_get_device_resources");
/* Get the range from the _CRS */ status = acpi_walk_resources(mem_device->handle, METHOD_NAME__CRS,
status = acpi_get_current_resources(mem_device->handle, &buffer); acpi_memory_get_resource, mem_device);
if (ACPI_FAILURE(status)) if (ACPI_FAILURE(status)) {
return_VALUE(-EINVAL); list_for_each_entry_safe(info, n, &mem_device->res_list, list)
kfree(info);
resource = (struct acpi_resource *)buffer.pointer; return -EINVAL;
status = acpi_resource_to_address64(resource, &address64);
if (ACPI_SUCCESS(status)) {
if (address64.resource_type == ACPI_MEMORY_RANGE) {
/* Populate the structure */
mem_device->caching = address64.info.mem.caching;
mem_device->write_protect =
address64.info.mem.write_protect;
mem_device->start_addr = address64.minimum;
mem_device->length = address64.address_length;
}
} }
acpi_os_free(buffer.pointer); return 0;
return_VALUE(0);
} }
static int static int
@ -181,7 +211,8 @@ static int acpi_memory_check_device(struct acpi_memory_device *mem_device)
static int acpi_memory_enable_device(struct acpi_memory_device *mem_device) static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
{ {
int result; int result, num_enabled = 0;
struct acpi_memory_info *info;
ACPI_FUNCTION_TRACE("acpi_memory_enable_device"); ACPI_FUNCTION_TRACE("acpi_memory_enable_device");
@ -197,12 +228,20 @@ static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
/* /*
* Tell the VM there is more memory here... * Tell the VM there is more memory here...
* Note: Assume that this function returns zero on success * Note: Assume that this function returns zero on success
* We don't have memory-hot-add rollback function,now.
* (i.e. memory-hot-remove function)
*/ */
result = add_memory(mem_device->start_addr, mem_device->length); list_for_each_entry(info, &mem_device->res_list, list) {
if (result) { result = add_memory(info->start_addr, info->length);
if (result)
continue;
info->enabled = 1;
num_enabled++;
}
if (!num_enabled) {
ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "\nadd_memory failed\n")); ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "\nadd_memory failed\n"));
mem_device->state = MEMORY_INVALID_STATE; mem_device->state = MEMORY_INVALID_STATE;
return result; return -EINVAL;
} }
return result; return result;
@ -246,8 +285,7 @@ static int acpi_memory_powerdown_device(struct acpi_memory_device *mem_device)
static int acpi_memory_disable_device(struct acpi_memory_device *mem_device) static int acpi_memory_disable_device(struct acpi_memory_device *mem_device)
{ {
int result; int result;
u64 start = mem_device->start_addr; struct acpi_memory_info *info, *n;
u64 len = mem_device->length;
ACPI_FUNCTION_TRACE("acpi_memory_disable_device"); ACPI_FUNCTION_TRACE("acpi_memory_disable_device");
@ -255,10 +293,13 @@ static int acpi_memory_disable_device(struct acpi_memory_device *mem_device)
* Ask the VM to offline this memory range. * Ask the VM to offline this memory range.
* Note: Assume that this function returns zero on success * Note: Assume that this function returns zero on success
*/ */
result = remove_memory(start, len); list_for_each_entry_safe(info, n, &mem_device->res_list, list) {
if (result) { if (info->enabled) {
ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Hot-Remove failed.\n")); result = remove_memory(info->start_addr, info->length);
return_VALUE(result); if (result)
return result;
}
kfree(info);
} }
/* Power-off and eject the device */ /* Power-off and eject the device */
@ -356,6 +397,7 @@ static int acpi_memory_device_add(struct acpi_device *device)
return_VALUE(-ENOMEM); return_VALUE(-ENOMEM);
memset(mem_device, 0, sizeof(struct acpi_memory_device)); memset(mem_device, 0, sizeof(struct acpi_memory_device));
INIT_LIST_HEAD(&mem_device->res_list);
mem_device->handle = device->handle; mem_device->handle = device->handle;
sprintf(acpi_device_name(device), "%s", ACPI_MEMORY_DEVICE_NAME); sprintf(acpi_device_name(device), "%s", ACPI_MEMORY_DEVICE_NAME);
sprintf(acpi_device_class(device), "%s", ACPI_MEMORY_DEVICE_CLASS); sprintf(acpi_device_class(device), "%s", ACPI_MEMORY_DEVICE_CLASS);