CINXE.COM

<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>LKML: David Howells: [PATCH 8/12]: MUTEX: Rename DECLARE_MUTEX for kernel/ dir</title><link href="/css/message.css" rel="stylesheet" type="text/css" /><link href="/css/wrap.css" rel="alternate stylesheet" type="text/css" title="wrap" /><link href="/css/nowrap.css" rel="stylesheet" type="text/css" title="nowrap" /><link href="/favicon.ico" rel="shortcut icon" /><script src="/js/simple-calendar.js" type="text/javascript"></script><script src="/js/styleswitcher.js" type="text/javascript"></script><link rel="alternate" type="application/rss+xml" title="lkml.org : last 100 messages" href="/rss.php" /><link rel="alternate" type="application/rss+xml" title="lkml.org : last messages by David Howells" href="/groupie.php?aid=345" /><script> var _paq = window._paq = window._paq || []; /* tracker methods like "setCustomDimension" should be called before "trackPageView" */ _paq.push(["setDoNotTrack", true]); _paq.push(["disableCookies"]); _paq.push(['trackPageView']); _paq.push(['enableLinkTracking']); (function() { var u="//m.lkml.org/"; _paq.push(['setTrackerUrl', u+'matomo.php']); _paq.push(['setSiteId', '1']); var d=document, g=d.createElement('script'), s=d.getElementsByTagName('script')[0]; g.async=true; g.src=u+'matomo.js'; s.parentNode.insertBefore(g,s); })(); </script></head><body onload="es.jasper.simpleCalendar.init();" itemscope="itemscope" itemtype="http://schema.org/BlogPosting"><table border="0" cellpadding="0" cellspacing="0"><tr><td width="180" align="center"><a href="/"><img style="border:0;width:135px;height:32px" src="/images/toprowlk.gif" alt="lkml.org" /></a></td><td width="32">聽</td><td class="nb"><div><a class="nb" href="/lkml"> [lkml]</a> 聽 <a class="nb" href="/lkml/2005"> [2005]</a> 聽 <a class="nb" href="/lkml/2005/12"> [Dec]</a> 聽 <a class="nb" href="/lkml/2005/12/16"> [16]</a> 聽 <a class="nb" href="/lkml/last100"> [last100]</a> 聽 <a href="/rss.php"><img src="/images/rss-or.gif" border="0" alt="RSS Feed" /></a></div><div>Views: <a href="#" class="nowrap" onclick="setActiveStyleSheet('wrap');return false;">[wrap]</a><a href="#" class="wrap" onclick="setActiveStyleSheet('nowrap');return false;">[no wrap]</a> 聽 <a class="nb" href="/lkml/mheaders/2005/12/16/278" onclick="this.href='/lkml/headers'+'/2005/12/16/278';">[headers]</a>聽 <a href="/lkml/bounce/2005/12/16/278">[forward]</a>聽 </div></td><td width="32">聽</td></tr><tr><td valign="top"><div class="es-jasper-simpleCalendar" baseurl="/lkml/"></div><div class="threadlist">Messages in this thread</div><ul class="threadlist"><li class="root"><a href="/lkml/2005/12/16/277">First message in thread</a></li><li><a href="/lkml/2005/12/16/277">David Howells</a><ul><li><a href="/lkml/2005/12/16/270">David Howells</a></li><li><a href="/lkml/2005/12/16/271">David Howells</a></li><li><a href="/lkml/2005/12/16/272">David Howells</a></li><li><a href="/lkml/2005/12/16/273">David Howells</a></li><li><a href="/lkml/2005/12/16/274">David Howells</a></li><li><a href="/lkml/2005/12/16/275">David Howells</a></li><li><a href="/lkml/2005/12/16/276">David Howells</a></li><li class="origin"><a href="">David Howells</a></li><li><a href="/lkml/2005/12/16/279">David Howells</a></li><li><a href="/lkml/2005/12/16/280">David Howells</a></li><li><a href="/lkml/2005/12/16/281">David Howells</a></li><li><a href="/lkml/2005/12/16/282">David Howells</a></li><li><a href="/lkml/2005/12/16/335">Steven Rostedt</a><ul><li><a href="/lkml/2005/12/17/13">Linus Torvalds</a><ul><li><a href="/lkml/2005/12/17/60">David Howells</a><ul><li><a href="/lkml/2005/12/17/63">Linus Torvalds</a></li></ul></li></ul></li><li><a href="/lkml/2005/12/17/15">Nick Piggin</a><ul><li><a href="/lkml/2005/12/17/24">Steven Rostedt</a></li></ul></li></ul></li></ul></li></ul><div class="threadlist">Patch in this message</div><ul class="threadlist"><li><a href="/lkml/diff/2005/12/16/278/1">Get diff 1</a></li></ul></td><td width="32" rowspan="2" class="c" valign="top"><img src="/images/icornerl.gif" width="32" height="32" alt="/" /></td><td class="c" rowspan="2" valign="top" style="padding-top: 1em"><table><tr><td><table><tr><td class="lp">Date</td><td class="rp" itemprop="datePublished">Fri, 16 Dec 2005 23:13:08 GMT</td></tr><tr><td class="lp">From</td><td class="rp" itemprop="author">David Howells <></td></tr><tr><td class="lp">Subject</td><td class="rp" itemprop="name">[PATCH 8/12]: MUTEX: Rename DECLARE_MUTEX for kernel/ dir</td></tr></table></td><td></td></tr></table><pre itemprop="articleBody">The attached patch renames DECLARE_MUTEX*() to DECLARE_SEM_MUTEX*() for the kernel/ directory. Signed-Off-By: David Howells <dhowells@redhat.com> --- warthog>diffstat -p1 mutex-kernel-2615rc5-2.diff kernel/Makefile | 3 kernel/audit.c | 2 kernel/cpu.c | 2 kernel/cpuset.c | 4 kernel/irq/autoprobe.c | 2 kernel/kthread.c | 2 kernel/module.c | 4 kernel/mutex-cmpxchg.c | 298 +++++++++++++++++++++++++++++++++++++++++++++++++ kernel/mutex-xchg.c | 220 ++++++++++++++++++++++++++++++++++++ kernel/posix-timers.c | 2 kernel/power/main.c | 2 kernel/power/pm.c | 2 kernel/printk.c | 2 kernel/profile.c | 2 kernel/stop_machine.c | 2 15 files changed, 535 insertions(+), 14 deletions(-) diff -uNrp linux-2.6.15-rc5/kernel/Makefile linux-2.6.15-rc5-mutex/kernel/Makefile --- linux-2.6.15-rc5/kernel/Makefile 2005-12-08 16:23:55.000000000 +0000 +++ linux-2.6.15-rc5-mutex/kernel/Makefile 2005-12-16 17:38:19.000000000 +0000 @@ -33,6 +33,9 @@ obj-$(CONFIG_CRASH_DUMP) += crash_dump.o obj-$(CONFIG_SECCOMP) += seccomp.o obj-$(CONFIG_RCU_TORTURE_TEST) += rcutorture.o +obj-$(CONFIG_ARCH_CMPXCHG_MUTEX) += mutex-cmpxchg.o +obj-$(CONFIG_ARCH_XCHG_MUTEX) += mutex-xchg.o + ifneq ($(CONFIG_SCHED_NO_NO_OMIT_FRAME_POINTER),y) # According to Alan Modra <alan@linuxcare.com.au>, the -fno-omit-frame-pointer is # needed for x86 only. Why this used to be enabled for all architectures is beyond diff -uNrp linux-2.6.15-rc5/kernel/audit.c linux-2.6.15-rc5-mutex/kernel/audit.c --- linux-2.6.15-rc5/kernel/audit.c 2005-12-08 16:23:55.000000000 +0000 +++ linux-2.6.15-rc5-mutex/kernel/audit.c 2005-12-15 17:14:57.000000000 +0000 @@ -113,7 +113,7 @@ static DECLARE_WAIT_QUEUE_HEAD(audit_bac /* The netlink socket is only to be read by 1 CPU, which lets us assume * that list additions and deletions never happen simultaneously in * auditsc.c */ -DECLARE_MUTEX(audit_netlink_sem); +DECLARE_SEM_MUTEX(audit_netlink_sem); /* AUDIT_BUFSIZ is the size of the temporary buffer used for formatting * audit records. Since printk uses a 1024 byte buffer, this buffer diff -uNrp linux-2.6.15-rc5/kernel/cpu.c linux-2.6.15-rc5-mutex/kernel/cpu.c --- linux-2.6.15-rc5/kernel/cpu.c 2005-12-08 16:23:55.000000000 +0000 +++ linux-2.6.15-rc5-mutex/kernel/cpu.c 2005-12-15 17:14:57.000000000 +0000 @@ -16,7 +16,7 @@ #include <asm/semaphore.h> /* This protects CPUs going up and down... */ -static DECLARE_MUTEX(cpucontrol); +static DECLARE_SEM_MUTEX(cpucontrol); static struct notifier_block *cpu_chain; diff -uNrp linux-2.6.15-rc5/kernel/cpuset.c linux-2.6.15-rc5-mutex/kernel/cpuset.c --- linux-2.6.15-rc5/kernel/cpuset.c 2005-12-08 16:23:55.000000000 +0000 +++ linux-2.6.15-rc5-mutex/kernel/cpuset.c 2005-12-15 17:14:57.000000000 +0000 @@ -229,8 +229,8 @@ static struct super_block *cpuset_sb = N * such matters. */ -static DECLARE_MUTEX(manage_sem); -static DECLARE_MUTEX(callback_sem); +static DECLARE_SEM_MUTEX(manage_sem); +static DECLARE_SEM_MUTEX(callback_sem); /* * A couple of forward declarations required, due to cyclic reference loop: diff -uNrp linux-2.6.15-rc5/kernel/irq/autoprobe.c linux-2.6.15-rc5-mutex/kernel/irq/autoprobe.c --- linux-2.6.15-rc5/kernel/irq/autoprobe.c 2005-08-30 13:56:39.000000000 +0100 +++ linux-2.6.15-rc5-mutex/kernel/irq/autoprobe.c 2005-12-15 17:14:57.000000000 +0000 @@ -16,7 +16,7 @@ * comes in on to an unassigned handler will get stuck with * "IRQ_WAITING" cleared and the interrupt disabled. */ -static DECLARE_MUTEX(probe_sem); +static DECLARE_SEM_MUTEX(probe_sem); /** * probe_irq_on - begin an interrupt autodetect diff -uNrp linux-2.6.15-rc5/kernel/kthread.c linux-2.6.15-rc5-mutex/kernel/kthread.c --- linux-2.6.15-rc5/kernel/kthread.c 2005-12-08 16:23:55.000000000 +0000 +++ linux-2.6.15-rc5-mutex/kernel/kthread.c 2005-12-15 17:14:57.000000000 +0000 @@ -41,7 +41,7 @@ struct kthread_stop_info /* Thread stopping is done by setthing this var: lock serializes * multiple kthread_stop calls. */ -static DECLARE_MUTEX(kthread_stop_lock); +static DECLARE_SEM_MUTEX(kthread_stop_lock); static struct kthread_stop_info kthread_stop_info; int kthread_should_stop(void) diff -uNrp linux-2.6.15-rc5/kernel/module.c linux-2.6.15-rc5-mutex/kernel/module.c --- linux-2.6.15-rc5/kernel/module.c 2005-12-08 16:23:55.000000000 +0000 +++ linux-2.6.15-rc5-mutex/kernel/module.c 2005-12-15 17:14:57.000000000 +0000 @@ -59,10 +59,10 @@ static DEFINE_SPINLOCK(modlist_lock); /* List of modules, protected by module_mutex AND modlist_lock */ -static DECLARE_MUTEX(module_mutex); +static DECLARE_SEM_MUTEX(module_mutex); static LIST_HEAD(modules); -static DECLARE_MUTEX(notify_mutex); +static DECLARE_SEM_MUTEX(notify_mutex); static struct notifier_block * module_notify_list; int register_module_notifier(struct notifier_block * nb) diff -uNrp linux-2.6.15-rc5/kernel/mutex-cmpxchg.c linux-2.6.15-rc5-mutex/kernel/mutex-cmpxchg.c --- linux-2.6.15-rc5/kernel/mutex-cmpxchg.c 1970-01-01 01:00:00.000000000 +0100 +++ linux-2.6.15-rc5-mutex/kernel/mutex-cmpxchg.c 2005-12-15 17:25:06.000000000 +0000 @@ -0,0 +1,298 @@ +/* mutex-cmpxchg.c: cmpxchg-based mutex slow paths + * + * Copyright (C) 2005 Red Hat, Inc. All Rights Reserved. + * Written by David Howells (dhowells@redhat.com) + * + * 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. + */ + +#include <linux/config.h> +#include <linux/sched.h> +#include <linux/module.h> +#include <linux/mutex.h> + +struct mutex_waiter { + struct list_head list; + struct task_struct *task; +}; + +#define CONTENTION_FLAG 1UL + +/* + * wait for a token to be granted from a mutex + * - noinlined to improve the fastpath case + */ +static noinline fastcall __sched +void __mutex_lock(struct mutex *mutex, unsigned long me) +{ + struct mutex_waiter waiter; + struct task_struct *tsk; + unsigned long flags, state, old; + + me = (unsigned long) current_thread_info(); + + /* slow path */ + spin_lock_irqsave(&mutex->wait_lock, flags); + + do { + /* see if we can grab the mutex immediately */ + state = __mutex_cmpxchg(mutex, 0, me); + if (!state) { + /* we did */ + spin_unlock_irqrestore(&mutex->wait_lock, flags); + return; + } + + if (state & CONTENTION_FLAG) + goto sleep; /* already flagged for contention */ + + /* attempt to mark the mutex as being contended + * - it may get released whilst we're doing this + */ + do { + old = state; + state = __mutex_cmpxchg(mutex, state, + old | CONTENTION_FLAG); + + } while (state && state != old); + } while (!state); + +sleep: + /* need to sleep; set up my own style of waitqueue */ + tsk = current; + waiter.task = tsk; + + get_task_struct(tsk); + list_add_tail(&waiter.list, &mutex->wait_list); + + /* we don't need to touch the mutex struct anymore */ + spin_unlock_irqrestore(&mutex->wait_lock, flags); + + /* wait to be given the mutex */ + set_task_state(tsk, TASK_UNINTERRUPTIBLE); + + for (;;) { + if (!waiter.task) + break; + schedule(); + set_task_state(tsk, TASK_UNINTERRUPTIBLE); + } + + tsk->state = TASK_RUNNING; +} + +/* + * fast path for attempting to grab the mutex + */ +fastcall __sched void mutex_lock(struct mutex *mutex) +{ + unsigned long me = __mutex_owner(); + + if (likely(__mutex_cmpxchg(mutex, 0, me) == 0)) + return; + + /* tail-call the slow path */ + __mutex_lock(mutex, me); +} + +EXPORT_SYMBOL(mutex_lock); + +/* + * slow path to interruptibly wait for a mutex to be granted to the caller + * - noinlined to improve the fastpath case + */ +static noinline fastcall __sched +int __mutex_lock_interruptible(struct mutex *mutex, unsigned long me) +{ + struct mutex_waiter waiter; + struct task_struct *tsk; + unsigned long flags, state, old; + int ret; + + spin_lock_irqsave(&mutex->wait_lock, flags); + + do { + /* see if we can grab the mutex immediately */ + state = __mutex_cmpxchg(mutex, 0, me); + if (!state) { + /* we did */ + spin_unlock_irqrestore(&mutex->wait_lock, flags); + return 0; + } + + if (unlikely(signal_pending(current))) + goto early_interrupt; + + if (state & CONTENTION_FLAG) + goto sleep; /* already flagged for contention */ + + /* attempt to mark the mutex as being contended + * - it may get released whilst we're doing this + */ + do { + old = state; + state = __mutex_cmpxchg(mutex, state, + old | CONTENTION_FLAG); + + } while (state && state != old); + } while (!state); + +sleep: + /* need to sleep; set up my own style of waitqueue */ + tsk = current; + waiter.task = tsk; + + get_task_struct(tsk); + list_add_tail(&waiter.list, &mutex->wait_list); + + /* we don't need to touch the mutex struct anymore */ + set_task_state(tsk, TASK_INTERRUPTIBLE); + + spin_unlock_irqrestore(&mutex->wait_lock, flags); + + /* wait to be given the mutex */ + for (;;) { + if (!waiter.task) + break; + if (unlikely(signal_pending(current))) + goto interrupted; + schedule(); + set_task_state(tsk, TASK_INTERRUPTIBLE); + } + + tsk->state = TASK_RUNNING; + return 0; + +interrupted: + spin_lock_irqsave(&mutex->wait_lock, flags); + list_del(&waiter.list); + spin_unlock_irqrestore(&mutex->wait_lock, flags); + + /* we may still have been given the mutex */ + ret = 0; + if (waiter.task) { + put_task_struct(current); + ret = -EINTR; + } + return ret; + +early_interrupt: + spin_unlock_irqrestore(&mutex->wait_lock, flags); + return -EINTR; +} + +/* + * fast path for attempting to grab the mutex interruptibly + */ +fastcall __sched +int mutex_lock_interruptible(struct mutex *mutex) +{ + unsigned long me = __mutex_owner(); + + if (likely(__mutex_cmpxchg(mutex, 0, me) == 0)) + return 0; + + /* tail-call the slow path */ + return __mutex_lock_interruptible(mutex, me); +} + +EXPORT_SYMBOL(mutex_lock_interruptible); + +/* + * report an unlock that doesn't balance a lock in the right context + */ +#ifdef CONFIG_DEBUG_MUTEX_OWNER +static void __bad_mutex_state(struct mutex *mutex) +{ + struct task_struct *owner = + ((struct thread_info *) + (mutex->state & ~CONTENTION_FLAG) + )->task; + + BUG_ON(mutex->state == CONTENTION_FLAG); + + if (!mutex->state) { + printk(KERN_ERR + "BUG: process %d [%s] releasing unowned mutex\n", + current->pid, + current->comm); + } + else { + printk(KERN_ERR + "BUG: process %d [%s] releasing mutex owned by %d [%s]\n", + current->pid, + current->comm, + owner->pid, + owner->comm); + } +} +#endif + +/* + * slow path to release a mutex that's under contention + * - the queue should not be empty + * - noinlined to improve the fastpath case + */ +static noinline fastcall __sched +void __mutex_unlock(struct mutex *mutex, unsigned long me) +{ + struct mutex_waiter *waiter; + struct task_struct *tsk; + unsigned long flags, state; + + /* slow path */ +#ifdef CONFIG_DEBUG_MUTEX_OWNER + if ((mutex->state & ~CONTENTION_FLAG) != me) + __bad_mutex_state(mutex); +#endif + + /* must prevent a race */ + spin_lock_irqsave(&mutex->wait_lock, flags); + + if (!list_empty(&mutex->wait_list)) { + /* grant the token to the process at the front of the queue */ + waiter = list_entry(mutex->wait_list.next, + struct mutex_waiter, list); + + /* we must be careful not to touch 'waiter' after we set ->task + * to NULL. + * - it is an allocated on the waiter's stack and may become + * invalid at any time after that point (due to a wakeup from + * another source). + */ + list_del_init(&waiter->list); + tsk = waiter->task; + state = (unsigned long) tsk; + if (!list_empty(&waiter->list)) + state |= CONTENTION_FLAG; + mutex->state = state; + smp_mb(); + waiter->task = NULL; + wake_up_process(tsk); + put_task_struct(tsk); + } + else { + mutex->state = 0; + } + + spin_unlock_irqrestore(&mutex->wait_lock, flags); +} + +/* + * fast path to release a mutex + */ +fastcall __sched +void mutex_unlock(struct mutex *mutex) +{ + unsigned long me = __mutex_owner(); + + if (__mutex_cmpxchg(mutex, me, 0) == me) + return; + + __mutex_unlock(mutex, me); +} + +EXPORT_SYMBOL(mutex_unlock); diff -uNrp linux-2.6.15-rc5/kernel/mutex-xchg.c linux-2.6.15-rc5-mutex/kernel/mutex-xchg.c --- linux-2.6.15-rc5/kernel/mutex-xchg.c 1970-01-01 01:00:00.000000000 +0100 +++ linux-2.6.15-rc5-mutex/kernel/mutex-xchg.c 2005-12-15 19:44:13.000000000 +0000 @@ -0,0 +1,220 @@ +/* mutex-xchg.c: simple exchange-based mutex slow paths + * + * Copyright (C) 2005 Red Hat, Inc. All Rights Reserved. + * Written by David Howells (dhowells@redhat.com) + * + * 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. + */ + +#include <linux/config.h> +#include <linux/sched.h> +#include <linux/module.h> +#include <linux/mutex.h> + +struct mutex_waiter { + struct list_head list; + struct task_struct *task; +}; + +/* + * wait for a token to be granted from a mutex + */ +noinline fastcall __sched +void __mutex_lock(struct mutex *mutex) +{ + struct mutex_waiter waiter; + struct task_struct *tsk = current; + unsigned long flags; + + /* set up my own style of waitqueue */ + waiter.task = tsk; + + spin_lock_irqsave(&mutex->wait_lock, flags); + + if (mutex_trylock(mutex)) { + /* we got the mutex anyway */ + spin_unlock_irqrestore(&mutex->wait_lock, flags); + return; + } + + /* need to sleep */ + get_task_struct(tsk); + list_add_tail(&waiter.list, &mutex->wait_list); + + /* we don't need to touch the mutex struct anymore */ + spin_unlock_irqrestore(&mutex->wait_lock, flags); + + /* wait to be given the mutex */ + set_task_state(tsk, TASK_UNINTERRUPTIBLE); + + for (;;) { + if (!waiter.task) + break; + schedule(); + set_task_state(tsk, TASK_UNINTERRUPTIBLE); + } + + tsk->state = TASK_RUNNING; +} + +/* + * fast path for attempting to grab the mutex + */ +#if 0 +fastcall __sched +void mutex_lock(struct mutex *mutex) +{ + if (!mutex_trylock(mutex)) + __mutex_lock(mutex); +} +#endif + +EXPORT_SYMBOL(__mutex_lock); + +/* + * slow path to interruptibly wait for a mutex to be granted to the caller + */ +noinline fastcall __sched +int __mutex_lock_interruptible(struct mutex *mutex) +{ + struct mutex_waiter waiter; + struct task_struct *tsk = current; + unsigned long flags; + int ret; + + /* set up my own style of waitqueue */ + waiter.task = tsk; + + spin_lock_irqsave(&mutex->wait_lock, flags); + + if (mutex_trylock(mutex)) { + /* we got the mutex anyway */ + spin_unlock_irqrestore(&mutex->wait_lock, flags); + return 0; + } + + /* need to sleep */ + get_task_struct(tsk); + list_add_tail(&waiter.list, &mutex->wait_list); + + /* we don't need to touch the mutex struct anymore */ + set_task_state(tsk, TASK_INTERRUPTIBLE); + + spin_unlock_irqrestore(&mutex->wait_lock, flags); + + /* wait to be given the mutex */ + for (;;) { + if (!waiter.task) + break; + if (unlikely(signal_pending(current))) + goto interrupted; + schedule(); + set_task_state(tsk, TASK_INTERRUPTIBLE); + } + + tsk->state = TASK_RUNNING; + return 0; + +interrupted: + spin_lock_irqsave(&mutex->wait_lock, flags); + list_del(&waiter.list); + spin_unlock_irqrestore(&mutex->wait_lock, flags); + + /* we may still have been given the mutex */ + ret = 0; + if (waiter.task) { + put_task_struct(current); + ret = -EINTR; + } + return ret; +} + +/* + * fast path for attempting to grab the mutex interruptibly + */ +#if 0 +fastcall __sched +int mutex_lock_interruptible(struct mutex *mutex) +{ + if (mutex_trylock(mutex)) + return 0; + + return __mutex_lock_interruptible(mutex); +} +#endif + +EXPORT_SYMBOL(__mutex_lock_interruptible); + +/* + * report an up() that doesn't match a mutex_lock() + */ +#ifdef CONFIG_DEBUG_MUTEX_OWNER +static void __bad_mutex_state(struct mutex *mutex) +{ + if (!mutex->__owner) { + printk(KERN_ERR + "BUG: process %d [%s] releasing unowned mutex\n", + current->pid, + current->comm); + } + else { + printk(KERN_ERR + "BUG: process %d [%s] releasing mutex owned by %d [%s]\n", + current->pid, + current->comm, + mutex->__owner->pid, + mutex->__owner->comm); + } +} +#endif + +/* + * release a mutex + */ +void fastcall __sched mutex_unlock(struct mutex *mutex) +{ + struct mutex_waiter *waiter; + struct task_struct *tsk; + unsigned long flags; + +#ifdef CONFIG_DEBUG_MUTEX_OWNER + if (mutex->__owner != current) + __bad_mutex_state(mutex); + mutex->__owner = NULL; +#endif + + /* must prevent a race */ + spin_lock_irqsave(&mutex->wait_lock, flags); + + if (!list_empty(&mutex->wait_list)) { + /* grant the token to the process at the front of the queue */ + waiter = list_entry(mutex->wait_list.next, + struct mutex_waiter, list); + + /* we must be careful not to touch 'waiter' after we set ->task + * to NULL. + * - it is an allocated on the waiter's stack and may become + * invalid at any time after that point (due to a wakeup from + * another source). + */ + list_del_init(&waiter->list); + tsk = waiter->task; +#ifdef CONFIG_DEBUG_MUTEX_OWNER + mutex->__owner = tsk; +#endif + smp_mb(); + waiter->task = NULL; + wake_up_process(tsk); + put_task_struct(tsk); + } + else { + __mutex_release(mutex); + } + + spin_unlock_irqrestore(&mutex->wait_lock, flags); +} + +EXPORT_SYMBOL(mutex_unlock); diff -uNrp linux-2.6.15-rc5/kernel/posix-timers.c linux-2.6.15-rc5-mutex/kernel/posix-timers.c --- linux-2.6.15-rc5/kernel/posix-timers.c 2005-12-08 16:23:55.000000000 +0000 +++ linux-2.6.15-rc5-mutex/kernel/posix-timers.c 2005-12-15 17:14:57.000000000 +0000 @@ -1312,7 +1312,7 @@ sys_clock_getres(clockid_t which_clock, static DECLARE_WAIT_QUEUE_HEAD(nanosleep_abs_wqueue); static DECLARE_WORK(clock_was_set_work, (void(*)(void*))clock_was_set, NULL); -static DECLARE_MUTEX(clock_was_set_lock); +static DECLARE_SEM_MUTEX(clock_was_set_lock); void clock_was_set(void) { diff -uNrp linux-2.6.15-rc5/kernel/power/main.c linux-2.6.15-rc5-mutex/kernel/power/main.c --- linux-2.6.15-rc5/kernel/power/main.c 2005-12-08 16:23:55.000000000 +0000 +++ linux-2.6.15-rc5-mutex/kernel/power/main.c 2005-12-15 17:14:57.000000000 +0000 @@ -22,7 +22,7 @@ /*This is just an arbitrary number */ #define FREE_PAGE_NUMBER (100) -DECLARE_MUTEX(pm_sem); +DECLARE_SEM_MUTEX(pm_sem); struct pm_ops *pm_ops; suspend_disk_method_t pm_disk_mode = PM_DISK_SHUTDOWN; diff -uNrp linux-2.6.15-rc5/kernel/power/pm.c linux-2.6.15-rc5-mutex/kernel/power/pm.c --- linux-2.6.15-rc5/kernel/power/pm.c 2005-12-08 16:23:55.000000000 +0000 +++ linux-2.6.15-rc5-mutex/kernel/power/pm.c 2005-12-15 17:14:57.000000000 +0000 @@ -40,7 +40,7 @@ int pm_active; * until a resume but that will be fine. */ -static DECLARE_MUTEX(pm_devs_lock); +static DECLARE_SEM_MUTEX(pm_devs_lock); static LIST_HEAD(pm_devs); /** diff -uNrp linux-2.6.15-rc5/kernel/printk.c linux-2.6.15-rc5-mutex/kernel/printk.c --- linux-2.6.15-rc5/kernel/printk.c 2005-12-08 16:23:56.000000000 +0000 +++ linux-2.6.15-rc5-mutex/kernel/printk.c 2005-12-15 17:14:57.000000000 +0000 @@ -66,7 +66,7 @@ EXPORT_SYMBOL(oops_in_progress); * provides serialisation for access to the entire console * driver system. */ -static DECLARE_MUTEX(console_sem); +static DECLARE_SEM_MUTEX(console_sem); struct console *console_drivers; /* * This is used for debugging the mess that is the VT code by diff -uNrp linux-2.6.15-rc5/kernel/profile.c linux-2.6.15-rc5-mutex/kernel/profile.c --- linux-2.6.15-rc5/kernel/profile.c 2005-08-30 13:56:40.000000000 +0100 +++ linux-2.6.15-rc5-mutex/kernel/profile.c 2005-12-15 17:14:57.000000000 +0000 @@ -44,7 +44,7 @@ static cpumask_t prof_cpu_mask = CPU_MAS #ifdef CONFIG_SMP static DEFINE_PER_CPU(struct profile_hit *[2], cpu_profile_hits); static DEFINE_PER_CPU(int, cpu_profile_flip); -static DECLARE_MUTEX(profile_flip_mutex); +static DECLARE_SEM_MUTEX(profile_flip_mutex); #endif /* CONFIG_SMP */ static int __init profile_setup(char * str) diff -uNrp linux-2.6.15-rc5/kernel/stop_machine.c linux-2.6.15-rc5-mutex/kernel/stop_machine.c --- linux-2.6.15-rc5/kernel/stop_machine.c 2005-12-08 16:23:56.000000000 +0000 +++ linux-2.6.15-rc5-mutex/kernel/stop_machine.c 2005-12-15 17:14:57.000000000 +0000 @@ -23,7 +23,7 @@ enum stopmachine_state { static enum stopmachine_state stopmachine_state; static unsigned int stopmachine_num_threads; static atomic_t stopmachine_thread_ack; -static DECLARE_MUTEX(stopmachine_mutex); +static DECLARE_SEM_MUTEX(stopmachine_mutex); static int stopmachine(void *cpu) { - To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at <a href="http://vger.kernel.org/majordomo-info.html">http://vger.kernel.org/majordomo-info.html</a> Please read the FAQ at <a href="http://www.tux.org/lkml/">http://www.tux.org/lkml/</a> </pre></td><td width="32" rowspan="2" class="c" valign="top"><img src="/images/icornerr.gif" width="32" height="32" alt="\" /></td></tr><tr><td align="right" valign="bottom"> 聽 </td></tr><tr><td align="right" valign="bottom">聽</td><td class="c" valign="bottom" style="padding-bottom: 0px"><img src="/images/bcornerl.gif" width="32" height="32" alt="\" /></td><td class="c">聽</td><td class="c" valign="bottom" style="padding-bottom: 0px"><img src="/images/bcornerr.gif" width="32" height="32" alt="/" /></td></tr><tr><td align="right" valign="top" colspan="2"> 聽 </td><td class="lm">Last update: 2005-12-17 00:18 聽聽 [from the cache] 漏2003-2020 <a href="http://blog.jasper.es/">Jasper Spaans</a>|hosted at <a href="https://www.digitalocean.com/?refcode=9a8e99d24cf9">Digital Ocean</a> and my Meterkast|<a href="http://blog.jasper.es/categories.html#lkml-ref">Read the blog</a></td><td>聽</td></tr></table><script language="javascript" src="/js/styleswitcher.js" type="text/javascript"></script></body></html>