mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-06 02:24:14 +08:00
3757b94802
This changeset is aimed at fixing a few different but related problems in the ACPI hotplug infrastructure. First of all, since notify handlers may be run in parallel with acpi_bus_scan(), acpi_bus_trim() and acpi_bus_hot_remove_device() and some of them are installed for ACPI handles that have no struct acpi_device objects attached (i.e. before those objects are created), those notify handlers have to take acpi_scan_lock to prevent races from taking place (e.g. a struct acpi_device is found to be present for the given ACPI handle, but right after that it is removed by acpi_bus_trim() running in parallel to the given notify handler). Moreover, since some of them call acpi_bus_scan() and acpi_bus_trim(), this leads to the conclusion that acpi_scan_lock should be acquired by the callers of these two funtions rather by these functions themselves. For these reasons, make all notify handlers that can handle device addition and eject events take acpi_scan_lock and remove the acpi_scan_lock locking from acpi_bus_scan() and acpi_bus_trim(). Accordingly, update all of their users to make sure that they are always called under acpi_scan_lock. Furthermore, since eject operations are carried out asynchronously with respect to the notify events that trigger them, with the help of acpi_bus_hot_remove_device(), even if notify handlers take the ACPI scan lock, it still is possible that, for example, acpi_bus_trim() will run between acpi_bus_hot_remove_device() and the notify handler that scheduled its execution and that acpi_bus_trim() will remove the device node passed to acpi_bus_hot_remove_device() for ejection. In that case, the struct acpi_device object obtained by acpi_bus_hot_remove_device() will be invalid and not-so-funny things will ensue. To protect agaist that, make the users of acpi_bus_hot_remove_device() run get_device() on ACPI device node objects that are about to be passed to it and make acpi_bus_hot_remove_device() run put_device() on them and check if their ACPI handles are not NULL (make acpi_device_unregister() clear the device nodes' ACPI handles for that check to work). Finally, observe that acpi_os_hotplug_execute() actually can fail, in which case its caller ought to free memory allocated for the context object to prevent leaks from happening. It also needs to run put_device() on the device node that it ran get_device() on previously in that case. Modify the code accordingly. Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com> Acked-by: Yinghai Lu <yinghai@kernel.org>
191 lines
5.0 KiB
C
191 lines
5.0 KiB
C
/*
|
|
* acpi_container.c - ACPI Generic Container Driver
|
|
* ($Revision: )
|
|
*
|
|
* Copyright (C) 2004 Anil S Keshavamurthy (anil.s.keshavamurthy@intel.com)
|
|
* Copyright (C) 2004 Keiichiro Tokunaga (tokunaga.keiich@jp.fujitsu.com)
|
|
* Copyright (C) 2004 Motoyuki Ito (motoyuki@soft.fujitsu.com)
|
|
* Copyright (C) 2004 Intel Corp.
|
|
* Copyright (C) 2004 FUJITSU LIMITED
|
|
*
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or (at
|
|
* your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
|
|
*
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
*/
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/init.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/types.h>
|
|
#include <linux/acpi.h>
|
|
#include <acpi/acpi_bus.h>
|
|
#include <acpi/acpi_drivers.h>
|
|
|
|
#define PREFIX "ACPI: "
|
|
|
|
#define _COMPONENT ACPI_CONTAINER_COMPONENT
|
|
ACPI_MODULE_NAME("container");
|
|
|
|
static const struct acpi_device_id container_device_ids[] = {
|
|
{"ACPI0004", 0},
|
|
{"PNP0A05", 0},
|
|
{"PNP0A06", 0},
|
|
{"", 0},
|
|
};
|
|
|
|
static int container_device_attach(struct acpi_device *device,
|
|
const struct acpi_device_id *not_used)
|
|
{
|
|
/*
|
|
* FIXME: This is necessary, so that acpi_eject_store() doesn't return
|
|
* -ENODEV for containers.
|
|
*/
|
|
return 1;
|
|
}
|
|
|
|
static struct acpi_scan_handler container_device_handler = {
|
|
.ids = container_device_ids,
|
|
.attach = container_device_attach,
|
|
};
|
|
|
|
static int is_device_present(acpi_handle handle)
|
|
{
|
|
acpi_handle temp;
|
|
acpi_status status;
|
|
unsigned long long sta;
|
|
|
|
|
|
status = acpi_get_handle(handle, "_STA", &temp);
|
|
if (ACPI_FAILURE(status))
|
|
return 1; /* _STA not found, assume device present */
|
|
|
|
status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
|
|
if (ACPI_FAILURE(status))
|
|
return 0; /* Firmware error */
|
|
|
|
return ((sta & ACPI_STA_DEVICE_PRESENT) == ACPI_STA_DEVICE_PRESENT);
|
|
}
|
|
|
|
static void container_notify_cb(acpi_handle handle, u32 type, void *context)
|
|
{
|
|
struct acpi_device *device = NULL;
|
|
int result;
|
|
int present;
|
|
acpi_status status;
|
|
u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE; /* default */
|
|
|
|
acpi_scan_lock_acquire();
|
|
|
|
switch (type) {
|
|
case ACPI_NOTIFY_BUS_CHECK:
|
|
/* Fall through */
|
|
case ACPI_NOTIFY_DEVICE_CHECK:
|
|
pr_debug("Container driver received %s event\n",
|
|
(type == ACPI_NOTIFY_BUS_CHECK) ?
|
|
"ACPI_NOTIFY_BUS_CHECK" : "ACPI_NOTIFY_DEVICE_CHECK");
|
|
|
|
present = is_device_present(handle);
|
|
status = acpi_bus_get_device(handle, &device);
|
|
if (!present) {
|
|
if (ACPI_SUCCESS(status)) {
|
|
/* device exist and this is a remove request */
|
|
device->flags.eject_pending = 1;
|
|
kobject_uevent(&device->dev.kobj, KOBJ_OFFLINE);
|
|
goto out;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (!ACPI_FAILURE(status) || device)
|
|
break;
|
|
|
|
result = acpi_bus_scan(handle);
|
|
if (result) {
|
|
acpi_handle_warn(handle, "Failed to add container\n");
|
|
break;
|
|
}
|
|
result = acpi_bus_get_device(handle, &device);
|
|
if (result) {
|
|
acpi_handle_warn(handle, "Missing device object\n");
|
|
break;
|
|
}
|
|
|
|
kobject_uevent(&device->dev.kobj, KOBJ_ONLINE);
|
|
ost_code = ACPI_OST_SC_SUCCESS;
|
|
break;
|
|
|
|
case ACPI_NOTIFY_EJECT_REQUEST:
|
|
if (!acpi_bus_get_device(handle, &device) && device) {
|
|
device->flags.eject_pending = 1;
|
|
kobject_uevent(&device->dev.kobj, KOBJ_OFFLINE);
|
|
goto out;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
/* non-hotplug event; possibly handled by other handler */
|
|
goto out;
|
|
}
|
|
|
|
/* Inform firmware that the hotplug operation has completed */
|
|
(void) acpi_evaluate_hotplug_ost(handle, type, ost_code, NULL);
|
|
|
|
out:
|
|
acpi_scan_lock_release();
|
|
}
|
|
|
|
static bool is_container(acpi_handle handle)
|
|
{
|
|
struct acpi_device_info *info;
|
|
bool ret = false;
|
|
|
|
if (ACPI_FAILURE(acpi_get_object_info(handle, &info)))
|
|
return false;
|
|
|
|
if (info->valid & ACPI_VALID_HID) {
|
|
const struct acpi_device_id *id;
|
|
|
|
for (id = container_device_ids; id->id[0]; id++) {
|
|
ret = !strcmp((char *)id->id, info->hardware_id.string);
|
|
if (ret)
|
|
break;
|
|
}
|
|
}
|
|
kfree(info);
|
|
return ret;
|
|
}
|
|
|
|
static acpi_status acpi_container_register_notify_handler(acpi_handle handle,
|
|
u32 lvl, void *ctxt,
|
|
void **retv)
|
|
{
|
|
if (is_container(handle))
|
|
acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
|
|
container_notify_cb, NULL);
|
|
|
|
return AE_OK;
|
|
}
|
|
|
|
void __init acpi_container_init(void)
|
|
{
|
|
acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
|
|
acpi_container_register_notify_handler, NULL,
|
|
NULL, NULL);
|
|
|
|
acpi_scan_add_handler(&container_device_handler);
|
|
}
|