]>
git.proxmox.com Git - mirror_spl.git/blob - include/sys/mutex.h
1 /*****************************************************************************\
2 * Copyright (C) 2007-2010 Lawrence Livermore National Security, LLC.
3 * Copyright (C) 2007 The Regents of the University of California.
4 * Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
5 * Written by Brian Behlendorf <behlendorf1@llnl.gov>.
8 * This file is part of the SPL, Solaris Porting Layer.
9 * For details, see <http://github.com/behlendorf/spl/>.
11 * The SPL is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the
13 * Free Software Foundation; either version 2 of the License, or (at your
14 * option) any later version.
16 * The SPL is distributed in the hope that it will be useful, but WITHOUT
17 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
21 * You should have received a copy of the GNU General Public License along
22 * with the SPL. If not, see <http://www.gnu.org/licenses/>.
23 \*****************************************************************************/
28 #include <sys/types.h>
29 #include <linux/mutex.h>
30 #include <linux/compiler_compat.h>
38 #if defined(HAVE_MUTEX_OWNER) && defined(CONFIG_SMP) && !defined(CONFIG_DEBUG_MUTEXES)
41 * We define a 1-field struct rather than a straight typedef to enforce type
48 static inline kthread_t
*
49 mutex_owner(kmutex_t
*mp
)
51 #if defined(HAVE_MUTEX_OWNER_TASK_STRUCT)
52 return ACCESS_ONCE(mp
->m
.owner
);
54 struct thread_info
*owner
= ACCESS_ONCE(mp
->m
.owner
);
62 #define mutex_owned(mp) (mutex_owner(mp) == current)
63 #define MUTEX_HELD(mp) mutex_owned(mp)
64 #define MUTEX_NOT_HELD(mp) (!MUTEX_HELD(mp))
66 #define mutex_init(mp, name, type, ibc) \
68 static struct lock_class_key __key; \
69 ASSERT(type == MUTEX_DEFAULT); \
71 __mutex_init(&(mp)->m, #mp, &__key); \
75 #define mutex_destroy(mp) \
77 VERIFY3P(mutex_owner(mp), ==, NULL); \
80 #define mutex_tryenter(mp) mutex_trylock(&(mp)->m)
81 #define mutex_enter(mp) mutex_lock(&(mp)->m)
82 #define mutex_exit(mp) mutex_unlock(&(mp)->m)
84 #ifdef HAVE_GPL_ONLY_SYMBOLS
85 # define mutex_enter_nested(mp, sc) mutex_lock_nested(&(mp)->m, sc)
87 # define mutex_enter_nested(mp, sc) mutex_enter(mp)
88 #endif /* HAVE_GPL_ONLY_SYMBOLS */
90 #else /* HAVE_MUTEX_OWNER */
98 extern int spl_mutex_spin_max(void);
99 #else /* HAVE_TASK_CURR */
100 # define task_curr(owner) 0
101 # define spl_mutex_spin_max() 0
102 #endif /* HAVE_TASK_CURR */
104 #define MUTEX(mp) ((struct mutex *)(mp))
107 spl_mutex_set_owner(kmutex_t
*mp
)
109 mp
->m_owner
= current
;
113 spl_mutex_clear_owner(kmutex_t
*mp
)
118 #define mutex_owner(mp) (ACCESS_ONCE((mp)->m_owner))
119 #define mutex_owned(mp) (mutex_owner(mp) == current)
120 #define MUTEX_HELD(mp) mutex_owned(mp)
121 #define MUTEX_NOT_HELD(mp) (!MUTEX_HELD(mp))
124 * The following functions must be a #define and not static inline.
125 * This ensures that the native linux mutex functions (lock/unlock)
126 * will be correctly located in the users code which is important
127 * for the built in kernel lock analysis tools
130 #define mutex_init(mp, name, type, ibc) \
132 static struct lock_class_key __key; \
133 ASSERT(type == MUTEX_DEFAULT); \
135 __mutex_init(MUTEX(mp), #mp, &__key); \
136 spl_mutex_clear_owner(mp); \
140 #define mutex_destroy(mp) \
142 VERIFY3P(mutex_owner(mp), ==, NULL); \
145 #define mutex_tryenter(mp) \
149 if ((_rc_ = mutex_trylock(MUTEX(mp))) == 1) \
150 spl_mutex_set_owner(mp); \
156 * Adaptive mutexs assume that the lock may be held by a task running
157 * on a different cpu. The expectation is that the task will drop the
158 * lock before leaving the head of the run queue. So the ideal thing
159 * to do is spin until we acquire the lock and avoid a context switch.
160 * However it is also possible the task holding the lock yields the
161 * processor with out dropping lock. In this case, we know it's going
162 * to be a while so we stop spinning and go to sleep waiting for the
163 * lock to be available. This should strike the optimum balance
164 * between spinning and sleeping waiting for a lock.
166 #define mutex_enter(mp) \
168 kthread_t *_owner_; \
173 _owner_ = mutex_owner(mp); \
175 while (_owner_ && task_curr(_owner_) && \
176 _count_ <= spl_mutex_spin_max()) { \
177 if ((_rc_ = mutex_trylock(MUTEX(mp)))) \
184 mutex_lock(MUTEX(mp)); \
186 spl_mutex_set_owner(mp); \
189 #define mutex_exit(mp) \
191 spl_mutex_clear_owner(mp); \
192 mutex_unlock(MUTEX(mp)); \
195 #ifdef HAVE_GPL_ONLY_SYMBOLS
196 # define mutex_enter_nested(mp, sc) \
198 mutex_lock_nested(MUTEX(mp, sc)); \
199 spl_mutex_set_owner(mp); \
202 # define mutex_enter_nested(mp, sc) \
208 #endif /* HAVE_MUTEX_OWNER */
210 int spl_mutex_init(void);
211 void spl_mutex_fini(void);
213 #endif /* _SPL_MUTEX_H */