source: mainline/uspace/lib/c/generic/devman.c@ 50b581d

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 50b581d was 50b581d, checked in by Jakub Jermar <jakub@…>, 13 years ago

Replace the async_wait_for(msg, NULL) pattern in the error paths with
async_forget(msg).
  • Property mode set to 100644
File size: 14.3 KB
Line 
1/*
2 * Copyright (c) 2007 Josef Cejka
3 * Copyright (c) 2011 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 <adt/list.h>
38#include <str.h>
39#include <ipc/services.h>
40#include <ns.h>
41#include <ipc/devman.h>
42#include <devman.h>
43#include <fibril_synch.h>
44#include <async.h>
45#include <errno.h>
46#include <malloc.h>
47#include <bool.h>
48
49static FIBRIL_MUTEX_INITIALIZE(devman_driver_block_mutex);
50static FIBRIL_MUTEX_INITIALIZE(devman_client_block_mutex);
51
52static FIBRIL_MUTEX_INITIALIZE(devman_driver_mutex);
53static FIBRIL_MUTEX_INITIALIZE(devman_client_mutex);
54
55static async_sess_t *devman_driver_block_sess = NULL;
56static async_sess_t *devman_client_block_sess = NULL;
57
58static async_sess_t *devman_driver_sess = NULL;
59static async_sess_t *devman_client_sess = NULL;
60
61static void clone_session(fibril_mutex_t *mtx, async_sess_t *src,
62 async_sess_t **dst)
63{
64 fibril_mutex_lock(mtx);
65
66 if ((*dst == NULL) && (src != NULL))
67 *dst = src;
68
69 fibril_mutex_unlock(mtx);
70}
71
72/** Start an async exchange on the devman session (blocking).
73 *
74 * @param iface Device manager interface to choose
75 *
76 * @return New exchange.
77 *
78 */
79async_exch_t *devman_exchange_begin_blocking(devman_interface_t iface)
80{
81 switch (iface) {
82 case DEVMAN_DRIVER:
83 fibril_mutex_lock(&devman_driver_block_mutex);
84
85 while (devman_driver_block_sess == NULL) {
86 clone_session(&devman_driver_mutex, devman_driver_sess,
87 &devman_driver_block_sess);
88
89 if (devman_driver_block_sess == NULL)
90 devman_driver_block_sess =
91 service_connect_blocking(EXCHANGE_PARALLEL,
92 SERVICE_DEVMAN, DEVMAN_DRIVER, 0);
93 }
94
95 fibril_mutex_unlock(&devman_driver_block_mutex);
96
97 clone_session(&devman_driver_mutex, devman_driver_block_sess,
98 &devman_driver_sess);
99
100 return async_exchange_begin(devman_driver_block_sess);
101 case DEVMAN_CLIENT:
102 fibril_mutex_lock(&devman_client_block_mutex);
103
104 while (devman_client_block_sess == NULL) {
105 clone_session(&devman_client_mutex, devman_client_sess,
106 &devman_client_block_sess);
107
108 if (devman_client_block_sess == NULL)
109 devman_client_block_sess =
110 service_connect_blocking(EXCHANGE_SERIALIZE,
111 SERVICE_DEVMAN, DEVMAN_CLIENT, 0);
112 }
113
114 fibril_mutex_unlock(&devman_client_block_mutex);
115
116 clone_session(&devman_client_mutex, devman_client_block_sess,
117 &devman_client_sess);
118
119 return async_exchange_begin(devman_client_block_sess);
120 default:
121 return NULL;
122 }
123}
124
125/** Start an async exchange on the devman session.
126 *
127 * @param iface Device manager interface to choose
128 *
129 * @return New exchange.
130 *
131 */
132async_exch_t *devman_exchange_begin(devman_interface_t iface)
133{
134 switch (iface) {
135 case DEVMAN_DRIVER:
136 fibril_mutex_lock(&devman_driver_mutex);
137
138 if (devman_driver_sess == NULL)
139 devman_driver_sess =
140 service_connect(EXCHANGE_PARALLEL, SERVICE_DEVMAN,
141 DEVMAN_DRIVER, 0);
142
143 fibril_mutex_unlock(&devman_driver_mutex);
144
145 if (devman_driver_sess == NULL)
146 return NULL;
147
148 return async_exchange_begin(devman_driver_sess);
149 case DEVMAN_CLIENT:
150 fibril_mutex_lock(&devman_client_mutex);
151
152 if (devman_client_sess == NULL)
153 devman_client_sess =
154 service_connect(EXCHANGE_SERIALIZE, SERVICE_DEVMAN,
155 DEVMAN_CLIENT, 0);
156
157 fibril_mutex_unlock(&devman_client_mutex);
158
159 if (devman_client_sess == NULL)
160 return NULL;
161
162 return async_exchange_begin(devman_client_sess);
163 default:
164 return NULL;
165 }
166}
167
168/** Finish an async exchange on the devman session.
169 *
170 * @param exch Exchange to be finished.
171 *
172 */
173void devman_exchange_end(async_exch_t *exch)
174{
175 async_exchange_end(exch);
176}
177
178/** Register running driver with device manager. */
179int devman_driver_register(const char *name)
180{
181 async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
182
183 ipc_call_t answer;
184 aid_t req = async_send_2(exch, DEVMAN_DRIVER_REGISTER, 0, 0, &answer);
185 sysarg_t retval = async_data_write_start(exch, name, str_size(name));
186
187 devman_exchange_end(exch);
188
189 if (retval != EOK) {
190 async_forget(req);
191 return retval;
192 }
193
194 exch = devman_exchange_begin(DEVMAN_DRIVER);
195 async_connect_to_me(exch, 0, 0, 0, NULL, NULL);
196 devman_exchange_end(exch);
197
198 async_wait_for(req, &retval);
199 return retval;
200}
201
202/** Add function to a device.
203 *
204 * Request devman to add a new function to the specified device owned by
205 * this driver task.
206 *
207 * @param name Name of the new function
208 * @param ftype Function type, fun_inner or fun_exposed
209 * @param match_ids Match IDs (should be empty for fun_exposed)
210 * @param devh Devman handle of the device
211 * @param funh Place to store handle of the new function
212 *
213 * @return EOK on success or negative error code.
214 *
215 */
216int devman_add_function(const char *name, fun_type_t ftype,
217 match_id_list_t *match_ids, devman_handle_t devh, devman_handle_t *funh)
218{
219 int match_count = list_count(&match_ids->ids);
220 async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
221
222 ipc_call_t answer;
223 aid_t req = async_send_3(exch, DEVMAN_ADD_FUNCTION, (sysarg_t) ftype,
224 devh, match_count, &answer);
225 sysarg_t retval = async_data_write_start(exch, name, str_size(name));
226 if (retval != EOK) {
227 devman_exchange_end(exch);
228 async_forget(req);
229 return retval;
230 }
231
232 match_id_t *match_id = NULL;
233
234 list_foreach(match_ids->ids, link) {
235 match_id = list_get_instance(link, match_id_t, link);
236
237 ipc_call_t answer2;
238 aid_t req2 = async_send_1(exch, DEVMAN_ADD_MATCH_ID,
239 match_id->score, &answer2);
240 retval = async_data_write_start(exch, match_id->id,
241 str_size(match_id->id));
242 if (retval != EOK) {
243 devman_exchange_end(exch);
244 async_forget(req2);
245 async_forget(req);
246 return retval;
247 }
248
249 async_wait_for(req2, &retval);
250 if (retval != EOK) {
251 devman_exchange_end(exch);
252 async_forget(req);
253 return retval;
254 }
255 }
256
257 devman_exchange_end(exch);
258
259 async_wait_for(req, &retval);
260 if (retval == EOK) {
261 if (funh != NULL)
262 *funh = (int) IPC_GET_ARG1(answer);
263 } else {
264 if (funh != NULL)
265 *funh = -1;
266 }
267
268 return retval;
269}
270
271int devman_add_device_to_category(devman_handle_t devman_handle,
272 const char *cat_name)
273{
274 async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
275
276 ipc_call_t answer;
277 aid_t req = async_send_1(exch, DEVMAN_ADD_DEVICE_TO_CATEGORY,
278 devman_handle, &answer);
279 sysarg_t retval = async_data_write_start(exch, cat_name,
280 str_size(cat_name));
281
282 devman_exchange_end(exch);
283
284 if (retval != EOK) {
285 async_forget(req);
286 return retval;
287 }
288
289 async_wait_for(req, &retval);
290 return retval;
291}
292
293async_sess_t *devman_device_connect(exch_mgmt_t mgmt, devman_handle_t handle,
294 unsigned int flags)
295{
296 async_sess_t *sess;
297
298 if (flags & IPC_FLAG_BLOCKING)
299 sess = service_connect_blocking(mgmt, SERVICE_DEVMAN,
300 DEVMAN_CONNECT_TO_DEVICE, handle);
301 else
302 sess = service_connect(mgmt, SERVICE_DEVMAN,
303 DEVMAN_CONNECT_TO_DEVICE, handle);
304
305 return sess;
306}
307
308/** Remove function from device.
309 *
310 * Request devman to remove function owned by this driver task.
311 * @param funh Devman handle of the function
312 *
313 * @return EOK on success or negative error code.
314 */
315int devman_remove_function(devman_handle_t funh)
316{
317 async_exch_t *exch;
318 sysarg_t retval;
319
320 exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
321 retval = async_req_1_0(exch, DEVMAN_REMOVE_FUNCTION, (sysarg_t) funh);
322 devman_exchange_end(exch);
323
324 return (int) retval;
325}
326
327int devman_drv_fun_online(devman_handle_t funh)
328{
329 async_exch_t *exch = devman_exchange_begin(DEVMAN_DRIVER);
330 if (exch == NULL)
331 return ENOMEM;
332
333 sysarg_t retval = async_req_1_0(exch, DEVMAN_DRV_FUN_ONLINE, funh);
334
335 devman_exchange_end(exch);
336 return (int) retval;
337}
338
339int devman_drv_fun_offline(devman_handle_t funh)
340{
341 async_exch_t *exch = devman_exchange_begin(DEVMAN_DRIVER);
342 if (exch == NULL)
343 return ENOMEM;
344
345 sysarg_t retval = async_req_1_0(exch, DEVMAN_DRV_FUN_OFFLINE, funh);
346
347 devman_exchange_end(exch);
348 return (int) retval;
349}
350
351async_sess_t *devman_parent_device_connect(exch_mgmt_t mgmt,
352 devman_handle_t handle, unsigned int flags)
353{
354 async_sess_t *sess;
355
356 if (flags & IPC_FLAG_BLOCKING)
357 sess = service_connect_blocking(mgmt, SERVICE_DEVMAN,
358 DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle);
359 else
360 sess = service_connect(mgmt, SERVICE_DEVMAN,
361 DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle);
362
363 return sess;
364}
365
366int devman_fun_get_handle(const char *pathname, devman_handle_t *handle,
367 unsigned int flags)
368{
369 async_exch_t *exch;
370
371 if (flags & IPC_FLAG_BLOCKING)
372 exch = devman_exchange_begin_blocking(DEVMAN_CLIENT);
373 else {
374 exch = devman_exchange_begin(DEVMAN_CLIENT);
375 if (exch == NULL)
376 return ENOMEM;
377 }
378
379 ipc_call_t answer;
380 aid_t req = async_send_2(exch, DEVMAN_DEVICE_GET_HANDLE, flags, 0,
381 &answer);
382 sysarg_t retval = async_data_write_start(exch, pathname,
383 str_size(pathname));
384
385 devman_exchange_end(exch);
386
387 if (retval != EOK) {
388 async_forget(req);
389 return retval;
390 }
391
392 async_wait_for(req, &retval);
393
394 if (retval != EOK) {
395 if (handle != NULL)
396 *handle = (devman_handle_t) -1;
397
398 return retval;
399 }
400
401 if (handle != NULL)
402 *handle = (devman_handle_t) IPC_GET_ARG1(answer);
403
404 return retval;
405}
406
407static int devman_get_str_internal(sysarg_t method, sysarg_t arg1, char *buf,
408 size_t buf_size)
409{
410 async_exch_t *exch;
411 ipc_call_t dreply;
412 size_t act_size;
413 sysarg_t dretval;
414
415 exch = devman_exchange_begin_blocking(LOC_PORT_CONSUMER);
416
417 ipc_call_t answer;
418 aid_t req = async_send_1(exch, method, arg1, &answer);
419 aid_t dreq = async_data_read(exch, buf, buf_size - 1, &dreply);
420 async_wait_for(dreq, &dretval);
421
422 devman_exchange_end(exch);
423
424 if (dretval != EOK) {
425 async_forget(req);
426 return dretval;
427 }
428
429 sysarg_t retval;
430 async_wait_for(req, &retval);
431
432 if (retval != EOK)
433 return retval;
434
435 act_size = IPC_GET_ARG2(dreply);
436 assert(act_size <= buf_size - 1);
437 buf[act_size] = '\0';
438
439 return EOK;
440}
441
442int devman_fun_get_path(devman_handle_t handle, char *buf, size_t buf_size)
443{
444 return devman_get_str_internal(DEVMAN_FUN_GET_PATH, handle, buf,
445 buf_size);
446}
447
448int devman_fun_get_name(devman_handle_t handle, char *buf, size_t buf_size)
449{
450 return devman_get_str_internal(DEVMAN_FUN_GET_NAME, handle, buf,
451 buf_size);
452}
453
454int devman_fun_online(devman_handle_t funh)
455{
456 async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
457 if (exch == NULL)
458 return ENOMEM;
459
460 sysarg_t retval = async_req_1_0(exch, DEVMAN_FUN_ONLINE, funh);
461
462 devman_exchange_end(exch);
463 return (int) retval;
464}
465
466int devman_fun_offline(devman_handle_t funh)
467{
468 async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
469 if (exch == NULL)
470 return ENOMEM;
471
472 sysarg_t retval = async_req_1_0(exch, DEVMAN_FUN_OFFLINE, funh);
473
474 devman_exchange_end(exch);
475 return (int) retval;
476}
477
478static int devman_get_handles_once(sysarg_t method, sysarg_t arg1,
479 devman_handle_t *handle_buf, size_t buf_size, size_t *act_size)
480{
481 async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_CLIENT);
482
483 ipc_call_t answer;
484 aid_t req = async_send_1(exch, method, arg1, &answer);
485 int rc = async_data_read_start(exch, handle_buf, buf_size);
486
487 devman_exchange_end(exch);
488
489 if (rc != EOK) {
490 async_forget(req);
491 return rc;
492 }
493
494 sysarg_t retval;
495 async_wait_for(req, &retval);
496
497 if (retval != EOK) {
498 return retval;
499 }
500
501 *act_size = IPC_GET_ARG1(answer);
502 return EOK;
503}
504
505/** Get list of handles.
506 *
507 * Returns an allocated array of handles.
508 *
509 * @param method IPC method
510 * @param arg1 IPC argument 1
511 * @param data Place to store pointer to array of handles
512 * @param count Place to store number of handles
513 * @return EOK on success or negative error code
514 */
515static int devman_get_handles_internal(sysarg_t method, sysarg_t arg1,
516 devman_handle_t **data, size_t *count)
517{
518 devman_handle_t *handles;
519 size_t act_size;
520 size_t alloc_size;
521 int rc;
522
523 *data = NULL;
524 act_size = 0; /* silence warning */
525
526 rc = devman_get_handles_once(method, arg1, NULL, 0,
527 &act_size);
528 if (rc != EOK)
529 return rc;
530
531 alloc_size = act_size;
532 handles = malloc(alloc_size);
533 if (handles == NULL)
534 return ENOMEM;
535
536 while (true) {
537 rc = devman_get_handles_once(method, arg1, handles, alloc_size,
538 &act_size);
539 if (rc != EOK)
540 return rc;
541
542 if (act_size <= alloc_size)
543 break;
544
545 alloc_size *= 2;
546 free(handles);
547
548 handles = malloc(alloc_size);
549 if (handles == NULL)
550 return ENOMEM;
551 }
552
553 *count = act_size / sizeof(devman_handle_t);
554 *data = handles;
555 return EOK;
556}
557
558int devman_fun_get_child(devman_handle_t funh, devman_handle_t *devh)
559{
560 async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
561 if (exch == NULL)
562 return ENOMEM;
563
564 sysarg_t retval = async_req_1_1(exch, DEVMAN_FUN_GET_CHILD,
565 funh, devh);
566
567 devman_exchange_end(exch);
568 return (int) retval;
569}
570
571int devman_dev_get_functions(devman_handle_t devh, devman_handle_t **funcs,
572 size_t *count)
573{
574 return devman_get_handles_internal(DEVMAN_DEV_GET_FUNCTIONS,
575 devh, funcs, count);
576}
577
578int devman_fun_sid_to_handle(service_id_t sid, devman_handle_t *handle)
579{
580 async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
581 if (exch == NULL)
582 return ENOMEM;
583
584 sysarg_t retval = async_req_1_1(exch, DEVMAN_FUN_SID_TO_HANDLE,
585 sid, handle);
586
587 devman_exchange_end(exch);
588 return (int) retval;
589}
590
591/** @}
592 */
Note: See TracBrowser for help on using the repository browser.