]>
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))
106 static inline kthread_t
*
107 spl_mutex_get_owner(kmutex_t
*mp
)
113 spl_mutex_set_owner(kmutex_t
*mp
)
117 spin_lock_irqsave(&MUTEX(mp
)->wait_lock
, flags
);
118 mp
->m_owner
= current
;
119 spin_unlock_irqrestore(&MUTEX(mp
)->wait_lock
, flags
);
123 spl_mutex_clear_owner(kmutex_t
*mp
)
127 spin_lock_irqsave(&MUTEX(mp
)->wait_lock
, flags
);
129 spin_unlock_irqrestore(&MUTEX(mp
)->wait_lock
, flags
);
132 static inline kthread_t
*
133 mutex_owner(kmutex_t
*mp
)
138 spin_lock_irqsave(&MUTEX(mp
)->wait_lock
, flags
);
139 owner
= spl_mutex_get_owner(mp
);
140 spin_unlock_irqrestore(&MUTEX(mp
)->wait_lock
, flags
);
145 #define mutex_owned(mp) (mutex_owner(mp) == current)
146 #define MUTEX_HELD(mp) mutex_owned(mp)
147 #define MUTEX_NOT_HELD(mp) (!MUTEX_HELD(mp))
150 * The following functions must be a #define and not static inline.
151 * This ensures that the native linux mutex functions (lock/unlock)
152 * will be correctly located in the users code which is important
153 * for the built in kernel lock analysis tools
156 #define mutex_init(mp, name, type, ibc) \
158 static struct lock_class_key __key; \
159 ASSERT(type == MUTEX_DEFAULT); \
161 __mutex_init(MUTEX(mp), #mp, &__key); \
162 spl_mutex_clear_owner(mp); \
166 #define mutex_destroy(mp) \
168 VERIFY3P(mutex_owner(mp), ==, NULL); \
171 #define mutex_tryenter(mp) \
175 if ((_rc_ = mutex_trylock(MUTEX(mp))) == 1) \
176 spl_mutex_set_owner(mp); \
182 * Adaptive mutexs assume that the lock may be held by a task running
183 * on a different cpu. The expectation is that the task will drop the
184 * lock before leaving the head of the run queue. So the ideal thing
185 * to do is spin until we acquire the lock and avoid a context switch.
186 * However it is also possible the task holding the lock yields the
187 * processor with out dropping lock. In this case, we know it's going
188 * to be a while so we stop spinning and go to sleep waiting for the
189 * lock to be available. This should strike the optimum balance
190 * between spinning and sleeping waiting for a lock.
192 #define mutex_enter(mp) \
194 kthread_t *_owner_; \
199 _owner_ = mutex_owner(mp); \
201 while (_owner_ && task_curr(_owner_) && \
202 _count_ <= spl_mutex_spin_max()) { \
203 if ((_rc_ = mutex_trylock(MUTEX(mp)))) \
210 mutex_lock(MUTEX(mp)); \
212 spl_mutex_set_owner(mp); \
215 #define mutex_exit(mp) \
217 spl_mutex_clear_owner(mp); \
218 mutex_unlock(MUTEX(mp)); \
221 #ifdef HAVE_GPL_ONLY_SYMBOLS
222 # define mutex_enter_nested(mp, sc) \
224 mutex_lock_nested(MUTEX(mp, sc)); \
225 spl_mutex_set_owner(mp); \
228 # define mutex_enter_nested(mp, sc) \
234 #endif /* HAVE_MUTEX_OWNER */
236 int spl_mutex_init(void);
237 void spl_mutex_fini(void);
239 #endif /* _SPL_MUTEX_H */