source: mainline/uspace/lib/c/generic/devman.c@ 79ae36dd

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 79ae36dd was 79ae36dd, checked in by Martin Decky <martin@…>, 14 years ago

new async framework with integrated exchange tracking

  • strict isolation between low-level IPC and high-level async framework with integrated exchange tracking
    • each IPC connection is represented by an async_sess_t structure
    • each IPC exchange is represented by an async_exch_t structure
    • exchange management is either based on atomic messages (EXCHANGE_ATOMIC), locking (EXCHANGE_SERIALIZE) or connection cloning (EXCHANGE_CLONE)
  • async_obsolete: temporary compatibility layer to keep old async clients working (several pieces of code are currently broken, but only non-essential functionality)
  • IPC_M_PHONE_HANGUP is now method no. 0 (for elegant boolean evaluation)
  • IPC_M_DEBUG_ALL has been renamed to IPC_M_DEBUG
  • IPC_M_PING has been removed (VFS protocol now has VFS_IN_PING)
  • console routines in libc have been rewritten for better abstraction
  • additional use for libc-private header files (FILE structure opaque to the client)
  • various cstyle changes (typos, indentation, missing externs in header files, improved comments, etc.)
  • Property mode set to 100644
File size: 11.7 KB
Line 
1/*
2 * Copyright (c) 2007 Josef Cejka
3 * Copyright (c) 2009 Jiri Svoboda
4 * Copyright (c) 2010 Lenka Trochtova
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * - Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * - Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * - The name of the author may not be used to endorse or promote products
17 * derived from this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31/** @addtogroup libc
32 * @{
33 */
34/** @file
35 */
36
37#include <str.h>
38#include <ipc/services.h>
39#include <ns.h>
40#include <ipc/devman.h>
41#include <devman.h>
42#include <fibril_synch.h>
43#include <async.h>
44#include <errno.h>
45#include <malloc.h>
46#include <bool.h>
47
48static FIBRIL_MUTEX_INITIALIZE(devman_driver_block_mutex);
49static FIBRIL_MUTEX_INITIALIZE(devman_client_block_mutex);
50
51static FIBRIL_MUTEX_INITIALIZE(devman_driver_mutex);
52static FIBRIL_MUTEX_INITIALIZE(devman_client_mutex);
53
54static async_sess_t *devman_driver_block_sess = NULL;
55static async_sess_t *devman_client_block_sess = NULL;
56
57static async_sess_t *devman_driver_sess = NULL;
58static async_sess_t *devman_client_sess = NULL;
59
60static void clone_session(fibril_mutex_t *mtx, async_sess_t *src,
61 async_sess_t **dst)
62{
63 fibril_mutex_lock(mtx);
64
65 if ((*dst == NULL) && (src != NULL))
66 *dst = src;
67
68 fibril_mutex_unlock(mtx);
69}
70
71/** Start an async exchange on the devman session (blocking).
72 *
73 * @param iface Device manager interface to choose
74 *
75 * @return New exchange.
76 *
77 */
78async_exch_t *devman_exchange_begin_blocking(devman_interface_t iface)
79{
80 switch (iface) {
81 case DEVMAN_DRIVER:
82 fibril_mutex_lock(&devman_driver_block_mutex);
83
84 while (devman_driver_block_sess == NULL) {
85 clone_session(&devman_driver_mutex, devman_driver_sess,
86 &devman_driver_block_sess);
87
88 if (devman_driver_block_sess == NULL)
89 devman_driver_block_sess =
90 service_connect_blocking(EXCHANGE_SERIALIZE,
91 SERVICE_DEVMAN, DEVMAN_DRIVER, 0);
92 }
93
94 fibril_mutex_unlock(&devman_driver_block_mutex);
95
96 clone_session(&devman_driver_mutex, devman_driver_block_sess,
97 &devman_driver_sess);
98
99 return async_exchange_begin(devman_driver_block_sess);
100 case DEVMAN_CLIENT:
101 fibril_mutex_lock(&devman_client_block_mutex);
102
103 while (devman_client_block_sess == NULL) {
104 clone_session(&devman_client_mutex, devman_client_sess,
105 &devman_client_block_sess);
106
107 if (devman_client_block_sess == NULL)
108 devman_client_block_sess =
109 service_connect_blocking(EXCHANGE_SERIALIZE,
110 SERVICE_DEVMAN, DEVMAN_CLIENT, 0);
111 }
112
113 fibril_mutex_unlock(&devman_client_block_mutex);
114
115 clone_session(&devman_client_mutex, devman_client_block_sess,
116 &devman_client_sess);
117
118 return async_exchange_begin(devman_client_block_sess);
119 default:
120 return NULL;
121 }
122}
123
124/** Start an async exchange on the devman session.
125 *
126 * @param iface Device manager interface to choose
127 *
128 * @return New exchange.
129 *
130 */
131async_exch_t *devman_exchange_begin(devman_interface_t iface)
132{
133 switch (iface) {
134 case DEVMAN_DRIVER:
135 fibril_mutex_lock(&devman_driver_mutex);
136
137 if (devman_driver_sess == NULL)
138 devman_driver_sess =
139 service_connect(EXCHANGE_SERIALIZE, SERVICE_DEVMAN,
140 DEVMAN_DRIVER, 0);
141
142 fibril_mutex_unlock(&devman_driver_mutex);
143
144 if (devman_driver_sess == NULL)
145 return NULL;
146
147 return async_exchange_begin(devman_driver_sess);
148 case DEVMAN_CLIENT:
149 fibril_mutex_lock(&devman_client_mutex);
150
151 if (devman_client_sess == NULL)
152 devman_client_sess =
153 service_connect(EXCHANGE_SERIALIZE, SERVICE_DEVMAN,
154 DEVMAN_CLIENT, 0);
155
156 fibril_mutex_unlock(&devman_client_mutex);
157
158 if (devman_client_sess == NULL)
159 return NULL;
160
161 return async_exchange_begin(devman_client_sess);
162 default:
163 return NULL;
164 }
165}
166
167/** Finish an async exchange on the devman session.
168 *
169 * @param exch Exchange to be finished.
170 *
171 */
172void devman_exchange_end(async_exch_t *exch)
173{
174 async_exchange_end(exch);
175}
176
177/** Register running driver with device manager. */
178int devman_driver_register(const char *name, async_client_conn_t conn)
179{
180 async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
181
182 ipc_call_t answer;
183 aid_t req = async_send_2(exch, DEVMAN_DRIVER_REGISTER, 0, 0, &answer);
184 sysarg_t retval = async_data_write_start(exch, name, str_size(name));
185
186 devman_exchange_end(exch);
187
188 if (retval != EOK) {
189 async_wait_for(req, NULL);
190 return retval;
191 }
192
193 async_set_client_connection(conn);
194
195 exch = devman_exchange_begin(DEVMAN_DRIVER);
196 async_connect_to_me(exch, 0, 0, 0, NULL);
197 devman_exchange_end(exch);
198
199 async_wait_for(req, &retval);
200 return retval;
201}
202
203/** Add function to a device.
204 *
205 * Request devman to add a new function to the specified device owned by
206 * this driver task.
207 *
208 * @param name Name of the new function
209 * @param ftype Function type, fun_inner or fun_exposed
210 * @param match_ids Match IDs (should be empty for fun_exposed)
211 * @param devh Devman handle of the device
212 * @param funh Place to store handle of the new function
213 *
214 * @return EOK on success or negative error code.
215 *
216 */
217int devman_add_function(const char *name, fun_type_t ftype,
218 match_id_list_t *match_ids, devman_handle_t devh, devman_handle_t *funh)
219{
220 int match_count = list_count(&match_ids->ids);
221 async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
222
223 ipc_call_t answer;
224 aid_t req = async_send_3(exch, DEVMAN_ADD_FUNCTION, (sysarg_t) ftype,
225 devh, match_count, &answer);
226 sysarg_t retval = async_data_write_start(exch, name, str_size(name));
227 if (retval != EOK) {
228 devman_exchange_end(exch);
229 async_wait_for(req, NULL);
230 return retval;
231 }
232
233 async_wait_for(req, &retval);
234 if (retval != EOK) {
235 devman_exchange_end(exch);
236
237 if (funh != NULL)
238 *funh = -1;
239
240 return retval;
241 }
242
243 if (funh != NULL)
244 *funh = (int) IPC_GET_ARG1(answer);
245
246 link_t *link = match_ids->ids.next;
247 match_id_t *match_id = NULL;
248
249 while (link != &match_ids->ids) {
250 match_id = list_get_instance(link, match_id_t, link);
251
252 ipc_call_t answer;
253 aid_t req = async_send_1(exch, DEVMAN_ADD_MATCH_ID,
254 match_id->score, &answer);
255 retval = async_data_write_start(exch, match_id->id,
256 str_size(match_id->id));
257 if (retval != EOK) {
258 devman_exchange_end(exch);
259 async_wait_for(req, NULL);
260 return retval;
261 }
262
263 async_wait_for(req, &retval);
264 if (retval != EOK) {
265 devman_exchange_end(exch);
266 return retval;
267 }
268
269 link = link->next;
270 }
271
272 devman_exchange_end(exch);
273 return EOK;
274}
275
276int devman_add_device_to_class(devman_handle_t devman_handle,
277 const char *class_name)
278{
279 async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
280
281 ipc_call_t answer;
282 aid_t req = async_send_1(exch, DEVMAN_ADD_DEVICE_TO_CLASS,
283 devman_handle, &answer);
284 sysarg_t retval = async_data_write_start(exch, class_name,
285 str_size(class_name));
286
287 devman_exchange_end(exch);
288
289 if (retval != EOK) {
290 async_wait_for(req, NULL);
291 return retval;
292 }
293
294 async_wait_for(req, &retval);
295 return retval;
296}
297
298async_sess_t *devman_device_connect(exch_mgmt_t mgmt, devman_handle_t handle,
299 unsigned int flags)
300{
301 async_sess_t *sess;
302
303 if (flags & IPC_FLAG_BLOCKING)
304 sess = service_connect_blocking(mgmt, SERVICE_DEVMAN,
305 DEVMAN_CONNECT_TO_DEVICE, handle);
306 else
307 sess = service_connect(mgmt, SERVICE_DEVMAN,
308 DEVMAN_CONNECT_TO_DEVICE, handle);
309
310 return sess;
311}
312
313async_sess_t *devman_parent_device_connect(exch_mgmt_t mgmt,
314 devman_handle_t handle, unsigned int flags)
315{
316 async_sess_t *sess;
317
318 if (flags & IPC_FLAG_BLOCKING)
319 sess = service_connect_blocking(mgmt, SERVICE_DEVMAN,
320 DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle);
321 else
322 sess = service_connect(mgmt, SERVICE_DEVMAN,
323 DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle);
324
325 return sess;
326}
327
328int devman_device_get_handle(const char *pathname, devman_handle_t *handle,
329 unsigned int flags)
330{
331 async_exch_t *exch;
332
333 if (flags & IPC_FLAG_BLOCKING)
334 exch = devman_exchange_begin_blocking(DEVMAN_CLIENT);
335 else {
336 exch = devman_exchange_begin(DEVMAN_CLIENT);
337 if (exch == NULL)
338 return errno;
339 }
340
341 ipc_call_t answer;
342 aid_t req = async_send_2(exch, DEVMAN_DEVICE_GET_HANDLE, flags, 0,
343 &answer);
344 sysarg_t retval = async_data_write_start(exch, pathname,
345 str_size(pathname));
346
347 devman_exchange_end(exch);
348
349 if (retval != EOK) {
350 async_wait_for(req, NULL);
351 return retval;
352 }
353
354 async_wait_for(req, &retval);
355
356 if (retval != EOK) {
357 if (handle != NULL)
358 *handle = (devman_handle_t) -1;
359
360 return retval;
361 }
362
363 if (handle != NULL)
364 *handle = (devman_handle_t) IPC_GET_ARG1(answer);
365
366 return retval;
367}
368
369int devman_device_get_handle_by_class(const char *classname,
370 const char *devname, devman_handle_t *handle, unsigned int flags)
371{
372 async_exch_t *exch;
373
374 if (flags & IPC_FLAG_BLOCKING)
375 exch = devman_exchange_begin_blocking(DEVMAN_CLIENT);
376 else {
377 exch = devman_exchange_begin(DEVMAN_CLIENT);
378 if (exch == NULL)
379 return errno;
380 }
381
382 ipc_call_t answer;
383 aid_t req = async_send_1(exch, DEVMAN_DEVICE_GET_HANDLE_BY_CLASS,
384 flags, &answer);
385 sysarg_t retval = async_data_write_start(exch, classname,
386 str_size(classname));
387
388 if (retval != EOK) {
389 devman_exchange_end(exch);
390 async_wait_for(req, NULL);
391 return retval;
392 }
393
394 retval = async_data_write_start(exch, devname,
395 str_size(devname));
396
397 devman_exchange_end(exch);
398
399 if (retval != EOK) {
400 async_wait_for(req, NULL);
401 return retval;
402 }
403
404 async_wait_for(req, &retval);
405
406 if (retval != EOK) {
407 if (handle != NULL)
408 *handle = (devman_handle_t) -1;
409
410 return retval;
411 }
412
413 if (handle != NULL)
414 *handle = (devman_handle_t) IPC_GET_ARG1(answer);
415
416 return retval;
417}
418
419int devman_get_device_path(devman_handle_t handle, char *path, size_t path_size)
420{
421 async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
422 if (exch == NULL)
423 return errno;
424
425 ipc_call_t answer;
426 aid_t req = async_send_1(exch, DEVMAN_DEVICE_GET_DEVICE_PATH,
427 handle, &answer);
428
429 ipc_call_t data_request_call;
430 aid_t data_request = async_data_read(exch, path, path_size,
431 &data_request_call);
432
433 devman_exchange_end(exch);
434
435 if (data_request == 0) {
436 async_wait_for(req, NULL);
437 return ENOMEM;
438 }
439
440 sysarg_t data_request_rc;
441 async_wait_for(data_request, &data_request_rc);
442
443 sysarg_t opening_request_rc;
444 async_wait_for(req, &opening_request_rc);
445
446 if (data_request_rc != EOK) {
447 /* Prefer the return code of the opening request. */
448 if (opening_request_rc != EOK)
449 return (int) opening_request_rc;
450 else
451 return (int) data_request_rc;
452 }
453
454 if (opening_request_rc != EOK)
455 return (int) opening_request_rc;
456
457 /* To be on the safe-side. */
458 path[path_size - 1] = 0;
459 size_t transferred_size = IPC_GET_ARG2(data_request_call);
460 if (transferred_size >= path_size)
461 return ELIMIT;
462
463 /* Terminate the string (trailing 0 not send over IPC). */
464 path[transferred_size] = 0;
465 return EOK;
466}
467
468/** @}
469 */
Note: See TracBrowser for help on using the repository browser.