xref: /netbsd-src/sys/dev/raidframe/rf_threadstuff.h (revision 08c81a9c2dc8c7300e893321eb65c0925d60871c)
1 /*	$NetBSD: rf_threadstuff.h,v 1.12 2002/08/08 02:54:30 oster Exp $	*/
2 /*
3  * Copyright (c) 1995 Carnegie-Mellon University.
4  * All rights reserved.
5  *
6  * Author: Mark Holland, Daniel Stodolsky, Jim Zelenka
7  *
8  * Permission to use, copy, modify and distribute this software and
9  * its documentation is hereby granted, provided that both the copyright
10  * notice and this permission notice appear in all copies of the
11  * software, derivative works or modified versions, and any portions
12  * thereof, and that both notices appear in supporting documentation.
13  *
14  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
15  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
16  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
17  *
18  * Carnegie Mellon requests users of this software to return to
19  *
20  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
21  *  School of Computer Science
22  *  Carnegie Mellon University
23  *  Pittsburgh PA 15213-3890
24  *
25  * any improvements or extensions that they make and grant Carnegie the
26  * rights to redistribute these changes.
27  */
28 
29 /*
30  * threadstuff.h -- definitions for threads, locks, and synchronization
31  *
32  * The purpose of this file is provide some illusion of portability.
33  * If the functions below can be implemented with the same semantics on
34  * some new system, then at least the synchronization and thread control
35  * part of the code should not require modification to port to a new machine.
36  * the only other place where the pthread package is explicitly used is
37  * threadid.h
38  *
39  * this file should be included above stdio.h to get some necessary defines.
40  *
41  */
42 
43 #ifndef _RF__RF_THREADSTUFF_H_
44 #define _RF__RF_THREADSTUFF_H_
45 
46 #include <sys/types.h>
47 #include <sys/param.h>
48 #include <sys/systm.h>
49 #include <sys/proc.h>
50 #include <sys/kthread.h>
51 
52 #include <dev/raidframe/raidframevar.h>
53 
54 #define rf_create_managed_mutex(a,b) _rf_create_managed_mutex(a,b,__FILE__,__LINE__)
55 #define rf_create_managed_cond(a,b) _rf_create_managed_cond(a,b,__FILE__,__LINE__)
56 #define rf_init_managed_threadgroup(a,b) _rf_init_managed_threadgroup(a,b,__FILE__,__LINE__)
57 #define rf_init_threadgroup(a) _rf_init_threadgroup(a,__FILE__,__LINE__)
58 #define rf_destroy_threadgroup(a) _rf_destroy_threadgroup(a,__FILE__,__LINE__)
59 
60 int     _rf_init_threadgroup(RF_ThreadGroup_t * g, char *file, int line);
61 int     _rf_destroy_threadgroup(RF_ThreadGroup_t * g, char *file, int line);
62 int
63 _rf_init_managed_threadgroup(RF_ShutdownList_t ** listp,
64     RF_ThreadGroup_t * g, char *file, int line);
65 
66 #include <sys/lock.h>
67 
68 #define decl_simple_lock_data(a,b) a struct simplelock b;
69 #define simple_lock_addr(a) ((struct simplelock *)&(a))
70 
71 typedef struct proc *RF_Thread_t;
72 typedef void *RF_ThreadArg_t;
73 
74 #define RF_DECLARE_MUTEX(_m_)           decl_simple_lock_data(,(_m_))
75 #define RF_DECLARE_STATIC_MUTEX(_m_)    decl_simple_lock_data(static,(_m_))
76 #define RF_DECLARE_EXTERN_MUTEX(_m_)    decl_simple_lock_data(extern,(_m_))
77 
78 #define RF_DECLARE_COND(_c_)            int _c_;
79 #define RF_DECLARE_STATIC_COND(_c_)     static int _c_;
80 #define RF_DECLARE_EXTERN_COND(_c_)     extern int _c_;
81 
82 #define RF_LOCK_MUTEX(_m_)              simple_lock(&(_m_))
83 #define RF_UNLOCK_MUTEX(_m_)            simple_unlock(&(_m_))
84 
85 
86 /* non-spinlock */
87 #define decl_lock_data(a,b) a struct lock b;
88 
89 #define RF_DECLARE_LKMGR_MUTEX(_m_)           decl_lock_data(,(_m_))
90 #define RF_DECLARE_LKMGR_STATIC_MUTEX(_m_)    decl_lock_data(static,(_m_))
91 #define RF_DECLARE_LKMGR_EXTERN_MUTEX(_m_)    decl_lock_data(extern,(_m_))
92 
93 #define RF_LOCK_LKMGR_MUTEX(_m_)        lockmgr(&(_m_),LK_EXCLUSIVE,NULL)
94 #define RF_UNLOCK_LKMGR_MUTEX(_m_)      lockmgr(&(_m_),LK_RELEASE,NULL)
95 
96 
97 /*
98  * In NetBSD, kernel threads are simply processes which share several
99  * substructures and never run in userspace.
100  */
101 #define RF_WAIT_COND(_c_,_m_)		\
102 	ltsleep(&(_c_), PRIBIO, "rfwcond", 0, &(_m_))
103 #define RF_SIGNAL_COND(_c_)            wakeup_one(&(_c_))
104 #define RF_BROADCAST_COND(_c_)         wakeup(&(_c_))
105 #define	RF_CREATE_THREAD(_handle_, _func_, _arg_, _name_) \
106 	kthread_create1((void (*)(void *))(_func_), (void *)(_arg_), \
107 	    (struct proc **)&(_handle_), _name_)
108 
109 struct RF_ThreadGroup_s {
110 	int     created;
111 	int     running;
112 	int     shutdown;
113 	        RF_DECLARE_MUTEX(mutex)
114 	        RF_DECLARE_COND(cond)
115 };
116 /*
117  * Someone has started a thread in the group
118  */
119 #define RF_THREADGROUP_STARTED(_g_) { \
120 	RF_LOCK_MUTEX((_g_)->mutex); \
121 	(_g_)->created++; \
122 	RF_UNLOCK_MUTEX((_g_)->mutex); \
123 }
124 
125 /*
126  * Thread announcing that it is now running
127  */
128 #define RF_THREADGROUP_RUNNING(_g_) { \
129 	RF_LOCK_MUTEX((_g_)->mutex); \
130 	(_g_)->running++; \
131 	RF_UNLOCK_MUTEX((_g_)->mutex); \
132 	RF_SIGNAL_COND((_g_)->cond); \
133 }
134 
135 /*
136  * Thread announcing that it is now done
137  */
138 #define RF_THREADGROUP_DONE(_g_) { \
139 	RF_LOCK_MUTEX((_g_)->mutex); \
140 	(_g_)->shutdown++; \
141 	RF_UNLOCK_MUTEX((_g_)->mutex); \
142 	RF_SIGNAL_COND((_g_)->cond); \
143 }
144 
145 /*
146  * Wait for all threads to start running
147  */
148 #define RF_THREADGROUP_WAIT_START(_g_) { \
149 	RF_LOCK_MUTEX((_g_)->mutex); \
150 	while((_g_)->running < (_g_)->created) { \
151 		RF_WAIT_COND((_g_)->cond, (_g_)->mutex); \
152 	} \
153 	RF_UNLOCK_MUTEX((_g_)->mutex); \
154 }
155 
156 /*
157  * Wait for all threads to stop running
158  */
159 #ifndef __NetBSD__
160 #define RF_THREADGROUP_WAIT_STOP(_g_) { \
161 	RF_LOCK_MUTEX((_g_)->mutex); \
162 	RF_ASSERT((_g_)->running == (_g_)->created); \
163 	while((_g_)->shutdown < (_g_)->running) { \
164 		RF_WAIT_COND((_g_)->cond, (_g_)->mutex); \
165 	} \
166 	RF_UNLOCK_MUTEX((_g_)->mutex); \
167 }
168 #else
169  /* XXX Note that we've removed the assert.  That should get put back in once
170   * we actually get something like a kernel thread running */
171 #define RF_THREADGROUP_WAIT_STOP(_g_) { \
172 	RF_LOCK_MUTEX((_g_)->mutex); \
173 	while((_g_)->shutdown < (_g_)->running) { \
174 		RF_WAIT_COND((_g_)->cond, (_g_)->mutex); \
175 	} \
176 	RF_UNLOCK_MUTEX((_g_)->mutex); \
177 }
178 #endif
179 
180 int     rf_mutex_init(struct simplelock *);
181 int     rf_mutex_destroy(struct simplelock *);
182 int
183 _rf_create_managed_mutex(RF_ShutdownList_t **, struct simplelock *,
184     char *, int);
185 
186 int     rf_lkmgr_mutex_init(struct lock *);
187 int     rf_lkmgr_mutex_destroy(struct lock *);
188 int
189 _rf_create_managed_lkmgr_mutex(RF_ShutdownList_t **, struct lock *,
190     char *, int);
191 
192 
193 int
194 _rf_create_managed_cond(RF_ShutdownList_t ** listp, int *,
195     char *file, int line);
196 
197 int     rf_cond_init(int *c);
198 int     rf_cond_destroy(int *c);
199 #endif				/* !_RF__RF_THREADSTUFF_H_ */
200