mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 19:00:25 +00:00
![Steven Rostedt](/assets/img/avatar_default.png)
We hit the following bug with -RT: |BUG: scheduling while atomic: swapper/7/0/0x00000002 |Pid: 0, comm: swapper/7 Not tainted 3.6.11-rt28.19.el6rt.x86_64.debug #1 |Call Trace: | rt_spin_lock+0x16/0x40 | __schedule_bug+0x67/0x90 | __schedule+0x793/0x7a0 | acpi_os_acquire_lock+0x1f/0x23 | acpi_write_bit_register+0x33/0xb0 | rt_spin_lock_slowlock+0xe5/0x2f0 | acpi_idle_enter_bm+0x8a/0x28e … As the acpi code disables interrupts in acpi_idle_enter_bm, and calls code that grabs the acpi lock, it causes issues as the lock is currently in RT a sleeping lock. The lock was converted from a raw to a sleeping lock due to some previous issues, and tests that showed it didn't seem to matter. Unfortunately, it did matter for one of our boxes. This patch converts the lock back to a raw lock. I've run this code on a few of my own machines, one being my laptop that uses the acpi quite extensively. I've been able to suspend and resume without issues. [ tglx: Made the change exclusive for acpi_gbl_hardware_lock ] Signed-off-by: Steven Rostedt <rostedt@goodmis.org> Link: http://lkml.kernel.org/r/1360765565.23152.5.camel@gandalf.local.home Signed-off-by: Thomas Gleixner <tglx@linutronix.de> [bigeasy: shorten the backtrace, use the type acpi_raw_spinlock incl. accessor] Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de> Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
330 lines
8.4 KiB
C
330 lines
8.4 KiB
C
// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
|
|
/*******************************************************************************
|
|
*
|
|
* Module Name: utmutex - local mutex support
|
|
*
|
|
******************************************************************************/
|
|
|
|
#include <acpi/acpi.h>
|
|
#include "accommon.h"
|
|
|
|
#define _COMPONENT ACPI_UTILITIES
|
|
ACPI_MODULE_NAME("utmutex")
|
|
|
|
/* Local prototypes */
|
|
static acpi_status acpi_ut_create_mutex(acpi_mutex_handle mutex_id);
|
|
|
|
static void acpi_ut_delete_mutex(acpi_mutex_handle mutex_id);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: acpi_ut_mutex_initialize
|
|
*
|
|
* PARAMETERS: None.
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: Create the system mutex objects. This includes mutexes,
|
|
* spin locks, and reader/writer locks.
|
|
*
|
|
******************************************************************************/
|
|
|
|
acpi_status acpi_ut_mutex_initialize(void)
|
|
{
|
|
u32 i;
|
|
acpi_status status;
|
|
|
|
ACPI_FUNCTION_TRACE(ut_mutex_initialize);
|
|
|
|
/* Create each of the predefined mutex objects */
|
|
|
|
for (i = 0; i < ACPI_NUM_MUTEX; i++) {
|
|
status = acpi_ut_create_mutex(i);
|
|
if (ACPI_FAILURE(status)) {
|
|
return_ACPI_STATUS(status);
|
|
}
|
|
}
|
|
|
|
/* Create the spinlocks for use at interrupt level or for speed */
|
|
|
|
status = acpi_os_create_lock (&acpi_gbl_gpe_lock);
|
|
if (ACPI_FAILURE (status)) {
|
|
return_ACPI_STATUS (status);
|
|
}
|
|
|
|
status = acpi_os_create_raw_lock(&acpi_gbl_hardware_lock);
|
|
if (ACPI_FAILURE (status)) {
|
|
return_ACPI_STATUS (status);
|
|
}
|
|
|
|
status = acpi_os_create_lock(&acpi_gbl_reference_count_lock);
|
|
if (ACPI_FAILURE(status)) {
|
|
return_ACPI_STATUS(status);
|
|
}
|
|
|
|
/* Mutex for _OSI support */
|
|
|
|
status = acpi_os_create_mutex(&acpi_gbl_osi_mutex);
|
|
if (ACPI_FAILURE(status)) {
|
|
return_ACPI_STATUS(status);
|
|
}
|
|
|
|
/* Create the reader/writer lock for namespace access */
|
|
|
|
status = acpi_ut_create_rw_lock(&acpi_gbl_namespace_rw_lock);
|
|
if (ACPI_FAILURE(status)) {
|
|
return_ACPI_STATUS(status);
|
|
}
|
|
|
|
return_ACPI_STATUS(status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: acpi_ut_mutex_terminate
|
|
*
|
|
* PARAMETERS: None.
|
|
*
|
|
* RETURN: None.
|
|
*
|
|
* DESCRIPTION: Delete all of the system mutex objects. This includes mutexes,
|
|
* spin locks, and reader/writer locks.
|
|
*
|
|
******************************************************************************/
|
|
|
|
void acpi_ut_mutex_terminate(void)
|
|
{
|
|
u32 i;
|
|
|
|
ACPI_FUNCTION_TRACE(ut_mutex_terminate);
|
|
|
|
/* Delete each predefined mutex object */
|
|
|
|
for (i = 0; i < ACPI_NUM_MUTEX; i++) {
|
|
acpi_ut_delete_mutex(i);
|
|
}
|
|
|
|
acpi_os_delete_mutex(acpi_gbl_osi_mutex);
|
|
|
|
/* Delete the spinlocks */
|
|
|
|
acpi_os_delete_lock(acpi_gbl_gpe_lock);
|
|
acpi_os_delete_raw_lock(acpi_gbl_hardware_lock);
|
|
acpi_os_delete_lock(acpi_gbl_reference_count_lock);
|
|
|
|
/* Delete the reader/writer lock */
|
|
|
|
acpi_ut_delete_rw_lock(&acpi_gbl_namespace_rw_lock);
|
|
return_VOID;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: acpi_ut_create_mutex
|
|
*
|
|
* PARAMETERS: mutex_ID - ID of the mutex to be created
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: Create a mutex object.
|
|
*
|
|
******************************************************************************/
|
|
|
|
static acpi_status acpi_ut_create_mutex(acpi_mutex_handle mutex_id)
|
|
{
|
|
acpi_status status = AE_OK;
|
|
|
|
ACPI_FUNCTION_TRACE_U32(ut_create_mutex, mutex_id);
|
|
|
|
if (!acpi_gbl_mutex_info[mutex_id].mutex) {
|
|
status =
|
|
acpi_os_create_mutex(&acpi_gbl_mutex_info[mutex_id].mutex);
|
|
acpi_gbl_mutex_info[mutex_id].thread_id =
|
|
ACPI_MUTEX_NOT_ACQUIRED;
|
|
acpi_gbl_mutex_info[mutex_id].use_count = 0;
|
|
}
|
|
|
|
return_ACPI_STATUS(status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: acpi_ut_delete_mutex
|
|
*
|
|
* PARAMETERS: mutex_ID - ID of the mutex to be deleted
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: Delete a mutex object.
|
|
*
|
|
******************************************************************************/
|
|
|
|
static void acpi_ut_delete_mutex(acpi_mutex_handle mutex_id)
|
|
{
|
|
|
|
ACPI_FUNCTION_TRACE_U32(ut_delete_mutex, mutex_id);
|
|
|
|
acpi_os_delete_mutex(acpi_gbl_mutex_info[mutex_id].mutex);
|
|
|
|
acpi_gbl_mutex_info[mutex_id].mutex = NULL;
|
|
acpi_gbl_mutex_info[mutex_id].thread_id = ACPI_MUTEX_NOT_ACQUIRED;
|
|
|
|
return_VOID;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: acpi_ut_acquire_mutex
|
|
*
|
|
* PARAMETERS: mutex_ID - ID of the mutex to be acquired
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: Acquire a mutex object.
|
|
*
|
|
******************************************************************************/
|
|
|
|
acpi_status acpi_ut_acquire_mutex(acpi_mutex_handle mutex_id)
|
|
{
|
|
acpi_status status;
|
|
acpi_thread_id this_thread_id;
|
|
|
|
ACPI_FUNCTION_NAME(ut_acquire_mutex);
|
|
|
|
if (mutex_id > ACPI_MAX_MUTEX) {
|
|
return (AE_BAD_PARAMETER);
|
|
}
|
|
|
|
this_thread_id = acpi_os_get_thread_id();
|
|
|
|
#ifdef ACPI_MUTEX_DEBUG
|
|
{
|
|
u32 i;
|
|
/*
|
|
* Mutex debug code, for internal debugging only.
|
|
*
|
|
* Deadlock prevention. Check if this thread owns any mutexes of value
|
|
* greater than or equal to this one. If so, the thread has violated
|
|
* the mutex ordering rule. This indicates a coding error somewhere in
|
|
* the ACPI subsystem code.
|
|
*/
|
|
for (i = mutex_id; i < ACPI_NUM_MUTEX; i++) {
|
|
if (acpi_gbl_mutex_info[i].thread_id == this_thread_id) {
|
|
if (i == mutex_id) {
|
|
ACPI_ERROR((AE_INFO,
|
|
"Mutex [%s] already acquired by this thread [%u]",
|
|
acpi_ut_get_mutex_name
|
|
(mutex_id),
|
|
(u32)this_thread_id));
|
|
|
|
return (AE_ALREADY_ACQUIRED);
|
|
}
|
|
|
|
ACPI_ERROR((AE_INFO,
|
|
"Invalid acquire order: Thread %u owns [%s], wants [%s]",
|
|
(u32)this_thread_id,
|
|
acpi_ut_get_mutex_name(i),
|
|
acpi_ut_get_mutex_name(mutex_id)));
|
|
|
|
return (AE_ACQUIRE_DEADLOCK);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
|
|
"Thread %u attempting to acquire Mutex [%s]\n",
|
|
(u32)this_thread_id,
|
|
acpi_ut_get_mutex_name(mutex_id)));
|
|
|
|
status =
|
|
acpi_os_acquire_mutex(acpi_gbl_mutex_info[mutex_id].mutex,
|
|
ACPI_WAIT_FOREVER);
|
|
if (ACPI_SUCCESS(status)) {
|
|
ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
|
|
"Thread %u acquired Mutex [%s]\n",
|
|
(u32)this_thread_id,
|
|
acpi_ut_get_mutex_name(mutex_id)));
|
|
|
|
acpi_gbl_mutex_info[mutex_id].use_count++;
|
|
acpi_gbl_mutex_info[mutex_id].thread_id = this_thread_id;
|
|
} else {
|
|
ACPI_EXCEPTION((AE_INFO, status,
|
|
"Thread %u could not acquire Mutex [%s] (0x%X)",
|
|
(u32)this_thread_id,
|
|
acpi_ut_get_mutex_name(mutex_id), mutex_id));
|
|
}
|
|
|
|
return (status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: acpi_ut_release_mutex
|
|
*
|
|
* PARAMETERS: mutex_ID - ID of the mutex to be released
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: Release a mutex object.
|
|
*
|
|
******************************************************************************/
|
|
|
|
acpi_status acpi_ut_release_mutex(acpi_mutex_handle mutex_id)
|
|
{
|
|
ACPI_FUNCTION_NAME(ut_release_mutex);
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Thread %u releasing Mutex [%s]\n",
|
|
(u32)acpi_os_get_thread_id(),
|
|
acpi_ut_get_mutex_name(mutex_id)));
|
|
|
|
if (mutex_id > ACPI_MAX_MUTEX) {
|
|
return (AE_BAD_PARAMETER);
|
|
}
|
|
|
|
/*
|
|
* Mutex must be acquired in order to release it!
|
|
*/
|
|
if (acpi_gbl_mutex_info[mutex_id].thread_id == ACPI_MUTEX_NOT_ACQUIRED) {
|
|
ACPI_ERROR((AE_INFO,
|
|
"Mutex [%s] (0x%X) is not acquired, cannot release",
|
|
acpi_ut_get_mutex_name(mutex_id), mutex_id));
|
|
|
|
return (AE_NOT_ACQUIRED);
|
|
}
|
|
#ifdef ACPI_MUTEX_DEBUG
|
|
{
|
|
u32 i;
|
|
/*
|
|
* Mutex debug code, for internal debugging only.
|
|
*
|
|
* Deadlock prevention. Check if this thread owns any mutexes of value
|
|
* greater than this one. If so, the thread has violated the mutex
|
|
* ordering rule. This indicates a coding error somewhere in
|
|
* the ACPI subsystem code.
|
|
*/
|
|
for (i = mutex_id; i < ACPI_NUM_MUTEX; i++) {
|
|
if (acpi_gbl_mutex_info[i].thread_id ==
|
|
acpi_os_get_thread_id()) {
|
|
if (i == mutex_id) {
|
|
continue;
|
|
}
|
|
|
|
ACPI_ERROR((AE_INFO,
|
|
"Invalid release order: owns [%s], releasing [%s]",
|
|
acpi_ut_get_mutex_name(i),
|
|
acpi_ut_get_mutex_name(mutex_id)));
|
|
|
|
return (AE_RELEASE_DEADLOCK);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* Mark unlocked FIRST */
|
|
|
|
acpi_gbl_mutex_info[mutex_id].thread_id = ACPI_MUTEX_NOT_ACQUIRED;
|
|
|
|
acpi_os_release_mutex(acpi_gbl_mutex_info[mutex_id].mutex);
|
|
return (AE_OK);
|
|
}
|