source: trunk/kernel/libk/remote_condvar.c@ 23

Last change on this file since 23 was 23, checked in by alain, 9 years ago

Introduce syscalls.
File size: 8.9 KB
Line 
1/*
2 * remote_condvar.c - distributed kernel condvar implementaion
3 *
4 * Author Alain Greiner (2016)
5 *
6 * Copyright (c) UPMC Sorbonne Universites
7 *
8 * This file is part of ALMOS-MKH.
9 *
10 * ALMOS-MKH is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; version 2.0 of the License.
13 *
14 * ALMOS-MKH is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with ALMOS-MKH; if not, write to the Free Software Foundation,
21 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 */
23
24#include <hal_types.h>
25#include <hal_remote.h>
26#include <hal_irqmask.h>
27#include <thread.h>
28#include <kmem.h>
29#include <printk.h>
30#include <process.h>
31#include <vmm.h>
32#include <xlist.h>
33#include <remote_mutex.h>
34#include <remote_condvar.h>
35
36///////////////////////////////////////////////////
37xptr_t remote_condvar_from_ident( intptr_t ident )
38{
39 // get pointer on local process_descriptor
40 process_t * process = CURRENT_THREAD->process;
41
42 // get extended pointer on reference process
43 xptr_t ref_xp = process->ref_xp;
44
45 // get cluster and local pointer on reference process
46 cxy_t ref_cxy = GET_CXY( ref_xp );
47 process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
48
49 // get extended pointer on root of condvars list
50 xptr_t root_xp = XPTR( ref_cxy , &ref_ptr->condvar_root );
51
52 // scan reference process condvars list
53 xptr_t iter_xp;
54 xptr_t condvar_xp;
55 cxy_t condvar_cxy;
56 struct remote_condvar_s * condvar_ptr;
57 intptr_t current;
58 bool_t found = false;
59
60 XLIST_FOREACH( root_xp , iter_xp )
61 {
62 condvar_xp = XLIST_ELEMENT( iter_xp , remote_condvar_t , list );
63 condvar_cxy = GET_CXY( condvar_xp );
64 condvar_ptr = (remote_condvar_t *)GET_PTR( condvar_xp );
65 current = (intptr_t)hal_remote_lpt( XPTR( condvar_cxy , &condvar_ptr->ident ) );
66 if( ident == current )
67 {
68 found = true;
69 break;
70 }
71 }
72
73 if( found == false ) return XPTR_NULL;
74 else return condvar_xp;
75
76} // end remote_condvar_from_ident()
77
78///////////////////////////////////////////////
79error_t remote_condvar_create( intptr_t ident )
80{
81 xptr_t condvar_xp;
82 remote_condvar_t * condvar_ptr;
83
84 // get pointer on local process descriptor
85 process_t * process = CURRENT_THREAD->process;
86
87 // get extended pointer on reference process
88 xptr_t ref_xp = process->ref_xp;
89
90 // get reference process cluster and local pointer
91 cxy_t ref_cxy = GET_CXY( ref_xp );
92 process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
93
94 // allocate memory for condvar descriptor
95 if( ref_cxy == local_cxy ) // local cluster is the reference
96 {
97 kmem_req_t req;
98 req.type = KMEM_CONDVAR;
99 req.flags = AF_ZERO;
100 condvar_ptr = kmem_alloc( &req );
101 condvar_xp = XPTR( local_cxy , condvar_ptr );
102 }
103 else // reference is remote
104 {
105 rpc_kcm_alloc_client( ref_cxy , KMEM_CONDVAR , &condvar_xp );
106 condvar_ptr = (remote_condvar_t *)GET_PTR( condvar_xp );
107 }
108
109 if( condvar_ptr == NULL ) return ENOMEM;
110
111 // initialise condvar
112 hal_remote_spt( XPTR( ref_cxy , &condvar_ptr->ident ) , (void*)ident );
113 xlist_entry_init( XPTR( ref_cxy , &condvar_ptr->list ) );
114 xlist_root_init( XPTR( ref_cxy , &condvar_ptr->root ) );
115
116 // register condvar in reference process xlist
117 xptr_t root_xp = XPTR( ref_cxy , &ref_ptr->condvar_root );
118 xptr_t xp_list = XPTR( ref_cxy , &condvar_ptr->list );
119
120 remote_spinlock_lock( XPTR( ref_cxy , &ref_ptr->sync_lock ) );
121 xlist_add_first( root_xp , xp_list );
122 remote_spinlock_unlock( XPTR( ref_cxy , &ref_ptr->sync_lock ) );
123
124 return 0;
125
126} // end remote_condvar_create()
127
128////////////////////////////////////////////////
129void remote_condvar_destroy( xptr_t condvar_xp )
130{
131 // get pointer on local process descriptor
132 process_t * process = CURRENT_THREAD->process;
133
134 // get extended pointer on reference process
135 xptr_t ref_xp = process->ref_xp;
136
137 // get reference process cluster and local pointer
138 cxy_t ref_cxy = GET_CXY( ref_xp );
139 process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
140
141 // get condvar cluster and local pointer
142 cxy_t condvar_cxy = GET_CXY( condvar_xp );
143 remote_condvar_t * condvar_ptr = (remote_condvar_t *)GET_PTR( condvar_xp );
144
145 // remove condvar from reference process xlist
146 remote_spinlock_lock( XPTR( ref_cxy , &ref_ptr->sync_lock ) );
147 xlist_unlink( XPTR( condvar_cxy , &condvar_ptr->list ) );
148 remote_spinlock_unlock( XPTR( ref_cxy , &ref_ptr->sync_lock ) );
149
150 // release memory allocated for condvaraphore descriptor
151 if( condvar_cxy == local_cxy ) // reference is local
152 {
153 kmem_req_t req;
154 req.type = KMEM_BARRIER;
155 req.ptr = condvar_ptr;
156 kmem_free( &req );
157 }
158 else // reference is remote
159 {
160 rpc_kcm_free_client( condvar_cxy , condvar_ptr , KMEM_BARRIER );
161 }
162
163} // end remote_condvar_destroy()
164
165////////////////////////////////////////////
166void remote_condvar_wait( xptr_t condvar_xp,
167 xptr_t mutex_xp )
168{
169 // unlock the mutex
170 remote_mutex_unlock( mutex_xp );
171
172 thread_t * this = CURRENT_THREAD;
173
174 // get condvar cluster an local pointer
175 remote_condvar_t * condvar_ptr = (remote_condvar_t *)GET_PTR( condvar_xp );
176 cxy_t condvar_cxy = GET_CXY( condvar_xp );
177
178 // get extended pointer on condvar waiting queue
179 xptr_t root_xp = XPTR( condvar_cxy , &condvar_ptr->root );
180
181 // get extended pointer on calling thread xlist_entry
182 xptr_t entry_xp = XPTR( local_cxy , &this->wait_list );
183
184 // register the calling thread in the condvar waiting queue
185 remote_spinlock_lock( XPTR( condvar_cxy , &condvar_ptr->lock ) );
186 xlist_add_last( root_xp , entry_xp );
187 remote_spinlock_unlock( XPTR( condvar_cxy , &condvar_ptr->lock ) );
188
189 // block the calling thread
190 thread_block( CURRENT_THREAD , THREAD_BLOCKED_USERSYNC );
191 sched_yield();
192
193 // lock the mutex before return
194 remote_mutex_unlock( mutex_xp );
195
196} // end remote_condvar_wait()
197
198///////////////////////////////////////////////
199void remote_condvar_signal( xptr_t condvar_xp )
200{
201 uint32_t irq_state;
202
203 // get condvar cluster an local pointer
204 remote_condvar_t * condvar_ptr = (remote_condvar_t *)GET_PTR( condvar_xp );
205 cxy_t condvar_cxy = GET_CXY( condvar_xp );
206
207 // get extended pointer on condvar waiting queue
208 xptr_t root_xp = XPTR( condvar_cxy , &condvar_ptr->root );
209
210 if( xlist_is_empty( root_xp ) ) return;
211
212 // disable interrupts
213 hal_disable_irq( &irq_state );
214
215 // get extended pointer on the first waiting thread
216 xptr_t thread_xp = XLIST_FIRST_ELEMENT( root_xp , thread_t , wait_list );
217
218 // remove the first waiting thread from queue
219 remote_spinlock_lock( XPTR( condvar_cxy , &condvar_ptr->lock ) );
220 xlist_unlink( XPTR( condvar_cxy , &condvar_ptr->list ) );
221 remote_spinlock_unlock( XPTR( condvar_cxy , &condvar_ptr->lock ) );
222
223 // unblock first waiting thread
224 thread_unblock( thread_xp , THREAD_BLOCKED_USERSYNC );
225
226 // restore interrupts
227 hal_restore_irq( irq_state );
228
229} // end remote_condvar_signal()
230
231//////////////////////////////////////////////////
232void remote_condvar_broadcast( xptr_t condvar_xp )
233{
234 uint32_t irq_state;
235
236 // get condvar cluster an local pointer
237 remote_condvar_t * condvar_ptr = (remote_condvar_t *)GET_PTR( condvar_xp );
238 cxy_t condvar_cxy = GET_CXY( condvar_xp );
239
240 // get extended pointer on condvar waiting queue
241 xptr_t root_xp = XPTR( condvar_cxy , &condvar_ptr->root );
242
243 if( xlist_is_empty( root_xp ) ) return;
244
245 // disable interrupts
246 hal_disable_irq( &irq_state );
247
248 // loop on waiting threads
249 xptr_t iter_xp;
250 xptr_t thread_xp;
251 XLIST_FOREACH( root_xp , iter_xp )
252 {
253 // get extended pointer on waiting thread
254 thread_xp = XLIST_ELEMENT( iter_xp , thread_t , wait_list );
255
256 // remove waiting thread from queue
257 remote_spinlock_lock( XPTR( condvar_cxy , &condvar_ptr->lock ) );
258 xlist_unlink( XPTR( condvar_cxy , &condvar_ptr->list ) );
259 remote_spinlock_unlock( XPTR( condvar_cxy , &condvar_ptr->lock ) );
260
261 // unblock waiting thread
262 thread_unblock( thread_xp , THREAD_BLOCKED_USERSYNC );
263 }
264
265 // restore interrupts
266 hal_restore_irq( irq_state );
267
268} // end remote_condvar_broadcast()
Note: See TracBrowser for help on using the repository browser.