/* * kernel/rt.c * * Real-Time Preemption Support * * started by Ingo Molnar: * * Copyright (C) 2004-2006 Red Hat, Inc., Ingo Molnar * Copyright (C) 2006, Timesys Corp., Thomas Gleixner * * historic credit for proving that Linux spinlocks can be implemented via * RT-aware mutexes goes to many people: The Pmutex project (Dirk Grambow * and others) who prototyped it on 2.4 and did lots of comparative * research and analysis; TimeSys, for proving that you can implement a * fully preemptible kernel via the use of IRQ threading and mutexes; * Bill Huey for persuasively arguing on lkml that the mutex model is the * right one; and to MontaVista, who ported pmutexes to 2.6. * * This code is a from-scratch implementation and is not based on pmutexes, * but the idea of converting spinlocks to mutexes is used here too. * * lock debugging, locking tree, deadlock detection: * * Copyright (C) 2004, LynuxWorks, Inc., Igor Manyilov, Bill Huey * Released under the General Public License (GPL). * * Includes portions of the generic R/W semaphore implementation from: * * Copyright (c) 2001 David Howells (dhowells@redhat.com). * - Derived partially from idea by Andrea Arcangeli * - Derived also from comments by Linus * * Pending ownership of locks and ownership stealing: * * Copyright (C) 2005, Kihon Technologies Inc., Steven Rostedt * * (also by Steven Rostedt) * - Converted single pi_lock to individual task locks. * * By Esben Nielsen: * Doing priority inheritance with help of the scheduler. * * Copyright (C) 2006, Timesys Corp., Thomas Gleixner * - major rework based on Esben Nielsens initial patch * - replaced thread_info references by task_struct refs * - removed task->pending_owner dependency * - BKL drop/reacquire for semaphore style locks to avoid deadlocks * in the scheduler return path as discussed with Steven Rostedt * * Copyright (C) 2006, Kihon Technologies Inc. * Steven Rostedt * - debugged and patched Thomas Gleixner's rework. * - added back the cmpxchg to the rework. * - turned atomic require back on for SMP. */ #include #include #include #include #include #include #include #include #include #include #include #include #include "rtmutex_common.h" /* * struct mutex functions */ void __mutex_do_init(struct mutex *mutex, const char *name, struct lock_class_key *key) { #ifdef CONFIG_DEBUG_LOCK_ALLOC /* * Make sure we are not reinitializing a held lock: */ debug_check_no_locks_freed((void *)mutex, sizeof(*mutex)); lockdep_init_map(&mutex->dep_map, name, key, 0); #endif mutex->lock.save_state = 0; } EXPORT_SYMBOL(__mutex_do_init); void __lockfunc _mutex_lock(struct mutex *lock) { mutex_acquire(&lock->dep_map, 0, 0, _RET_IP_); __rt_mutex_lock_state(&lock->lock, TASK_UNINTERRUPTIBLE); } EXPORT_SYMBOL(_mutex_lock); void __lockfunc _mutex_lock_io(struct mutex *lock) { int token; token = io_schedule_prepare(); _mutex_lock(lock); io_schedule_finish(token); } EXPORT_SYMBOL_GPL(_mutex_lock_io); int __lockfunc _mutex_lock_interruptible(struct mutex *lock) { int ret; mutex_acquire(&lock->dep_map, 0, 0, _RET_IP_); ret = __rt_mutex_lock_state(&lock->lock, TASK_INTERRUPTIBLE); if (ret) mutex_release(&lock->dep_map, 1, _RET_IP_); return ret; } EXPORT_SYMBOL(_mutex_lock_interruptible); int __lockfunc _mutex_lock_killable(struct mutex *lock) { int ret; mutex_acquire(&lock->dep_map, 0, 0, _RET_IP_); ret = __rt_mutex_lock_state(&lock->lock, TASK_KILLABLE); if (ret) mutex_release(&lock->dep_map, 1, _RET_IP_); return ret; } EXPORT_SYMBOL(_mutex_lock_killable); #ifdef CONFIG_DEBUG_LOCK_ALLOC void __lockfunc _mutex_lock_nested(struct mutex *lock, int subclass) { mutex_acquire_nest(&lock->dep_map, subclass, 0, NULL, _RET_IP_); __rt_mutex_lock_state(&lock->lock, TASK_UNINTERRUPTIBLE); } EXPORT_SYMBOL(_mutex_lock_nested); void __lockfunc _mutex_lock_io_nested(struct mutex *lock, int subclass) { int token; token = io_schedule_prepare(); mutex_acquire_nest(&lock->dep_map, subclass, 0, NULL, _RET_IP_); __rt_mutex_lock_state(&lock->lock, TASK_UNINTERRUPTIBLE); io_schedule_finish(token); } EXPORT_SYMBOL_GPL(_mutex_lock_io_nested); void __lockfunc _mutex_lock_nest_lock(struct mutex *lock, struct lockdep_map *nest) { mutex_acquire_nest(&lock->dep_map, 0, 0, nest, _RET_IP_); __rt_mutex_lock_state(&lock->lock, TASK_UNINTERRUPTIBLE); } EXPORT_SYMBOL(_mutex_lock_nest_lock); int __lockfunc _mutex_lock_interruptible_nested(struct mutex *lock, int subclass) { int ret; mutex_acquire_nest(&lock->dep_map, subclass, 0, NULL, _RET_IP_); ret = __rt_mutex_lock_state(&lock->lock, TASK_INTERRUPTIBLE); if (ret) mutex_release(&lock->dep_map, 1, _RET_IP_); return ret; } EXPORT_SYMBOL(_mutex_lock_interruptible_nested); int __lockfunc _mutex_lock_killable_nested(struct mutex *lock, int subclass) { int ret; mutex_acquire(&lock->dep_map, subclass, 0, _RET_IP_); ret = __rt_mutex_lock_state(&lock->lock, TASK_KILLABLE); if (ret) mutex_release(&lock->dep_map, 1, _RET_IP_); return ret; } EXPORT_SYMBOL(_mutex_lock_killable_nested); #endif int __lockfunc _mutex_trylock(struct mutex *lock) { int ret = __rt_mutex_trylock(&lock->lock); if (ret) mutex_acquire(&lock->dep_map, 0, 1, _RET_IP_); return ret; } EXPORT_SYMBOL(_mutex_trylock); void __lockfunc _mutex_unlock(struct mutex *lock) { mutex_release(&lock->dep_map, 1, _RET_IP_); __rt_mutex_unlock(&lock->lock); } EXPORT_SYMBOL(_mutex_unlock); /** * atomic_dec_and_mutex_lock - return holding mutex if we dec to 0 * @cnt: the atomic which we are to dec * @lock: the mutex to return holding if we dec to 0 * * return true and hold lock if we dec to 0, return false otherwise */ int atomic_dec_and_mutex_lock(atomic_t *cnt, struct mutex *lock) { /* dec if we can't possibly hit 0 */ if (atomic_add_unless(cnt, -1, 1)) return 0; /* we might hit 0, so take the lock */ mutex_lock(lock); if (!atomic_dec_and_test(cnt)) { /* when we actually did the dec, we didn't hit 0 */ mutex_unlock(lock); return 0; } /* we hit 0, and we hold the lock */ return 1; } EXPORT_SYMBOL(atomic_dec_and_mutex_lock);