source: mainline/uspace/srv/devman/drv_conn.c@ a1b9f63

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

Improve Doxygen documentaion

This is stil WiP. A number of libraries, drivers and services were
converted to using a more hierarchical and decentralized scheme when it
comes to specifying to which doxygen group they belong.
  • Property mode set to 100644
File size: 16.4 KB
Line 
1/*
2 * Copyright (c) 2010 Lenka Trochtova
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/**
30 * @addtogroup devman
31 * @{
32 */
33
34/** @file
35 */
36
37#include <assert.h>
38#include <ipc/services.h>
39#include <ns.h>
40#include <async.h>
41#include <stdio.h>
42#include <errno.h>
43#include <str_error.h>
44#include <stdbool.h>
45#include <fibril_synch.h>
46#include <stdlib.h>
47#include <str.h>
48#include <io/log.h>
49#include <ipc/devman.h>
50#include <loc.h>
51
52#include "client_conn.h"
53#include "dev.h"
54#include "devman.h"
55#include "devtree.h"
56#include "driver.h"
57#include "drv_conn.h"
58#include "fun.h"
59#include "loc.h"
60#include "main.h"
61
62static errno_t init_running_drv(void *drv);
63
64/** Register running driver. */
65static driver_t *devman_driver_register(ipc_call_t *call)
66{
67 driver_t *driver = NULL;
68 char *drv_name = NULL;
69
70 log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_driver_register");
71
72 /* Get driver name. */
73 errno_t rc = async_data_write_accept((void **) &drv_name, true, 0, 0, 0, 0);
74 if (rc != EOK) {
75 async_answer_0(call, rc);
76 return NULL;
77 }
78
79 log_msg(LOG_DEFAULT, LVL_DEBUG, "The `%s' driver is trying to register.",
80 drv_name);
81
82 /* Find driver structure. */
83 driver = driver_find_by_name(&drivers_list, drv_name);
84 if (driver == NULL) {
85 log_msg(LOG_DEFAULT, LVL_ERROR, "No driver named `%s' was found.", drv_name);
86 free(drv_name);
87 drv_name = NULL;
88 async_answer_0(call, ENOENT);
89 return NULL;
90 }
91
92 free(drv_name);
93 drv_name = NULL;
94
95 fibril_mutex_lock(&driver->driver_mutex);
96
97 if (driver->sess) {
98 /* We already have a connection to the driver. */
99 log_msg(LOG_DEFAULT, LVL_ERROR, "Driver '%s' already started.\n",
100 driver->name);
101 fibril_mutex_unlock(&driver->driver_mutex);
102 async_answer_0(call, EEXIST);
103 return NULL;
104 }
105
106 switch (driver->state) {
107 case DRIVER_NOT_STARTED:
108 /* Somebody started the driver manually. */
109 log_msg(LOG_DEFAULT, LVL_NOTE, "Driver '%s' started manually.\n",
110 driver->name);
111 driver->state = DRIVER_STARTING;
112 break;
113 case DRIVER_STARTING:
114 /* The expected case */
115 break;
116 case DRIVER_RUNNING:
117 /* Should not happen since we do not have a connected session */
118 assert(false);
119 }
120
121 /* Create connection to the driver. */
122 log_msg(LOG_DEFAULT, LVL_DEBUG, "Creating connection to the `%s' driver.",
123 driver->name);
124 driver->sess = async_callback_receive(EXCHANGE_PARALLEL);
125 if (!driver->sess) {
126 fibril_mutex_unlock(&driver->driver_mutex);
127 async_answer_0(call, ENOTSUP);
128 return NULL;
129 }
130 /* FIXME: Work around problem with callback sessions */
131 async_sess_args_set(driver->sess, INTERFACE_DDF_DEVMAN, 0, 0);
132
133 log_msg(LOG_DEFAULT, LVL_NOTE,
134 "The `%s' driver was successfully registered as running.",
135 driver->name);
136
137 /*
138 * Initialize the driver as running (e.g. pass assigned devices to it)
139 * in a separate fibril; the separate fibril is used to enable the
140 * driver to use devman service during the driver's initialization.
141 */
142 fid_t fid = fibril_create(init_running_drv, driver);
143 if (fid == 0) {
144 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to create initialization fibril "
145 "for driver `%s'.", driver->name);
146 fibril_mutex_unlock(&driver->driver_mutex);
147 async_answer_0(call, ENOMEM);
148 return NULL;
149 }
150
151 fibril_add_ready(fid);
152 fibril_mutex_unlock(&driver->driver_mutex);
153
154 async_answer_0(call, EOK);
155 return driver;
156}
157
158/** Receive device match ID from the device's parent driver and add it to the
159 * list of devices match ids.
160 *
161 * @param match_ids The list of the device's match ids.
162 * @return Zero on success, error code otherwise.
163 */
164static errno_t devman_receive_match_id(match_id_list_t *match_ids)
165{
166 match_id_t *match_id = create_match_id();
167 ipc_call_t call;
168 errno_t rc = 0;
169
170 async_get_call(&call);
171 if (DEVMAN_ADD_MATCH_ID != IPC_GET_IMETHOD(call)) {
172 log_msg(LOG_DEFAULT, LVL_ERROR,
173 "Invalid protocol when trying to receive match id.");
174 async_answer_0(&call, EINVAL);
175 delete_match_id(match_id);
176 return EINVAL;
177 }
178
179 if (match_id == NULL) {
180 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to allocate match id.");
181 async_answer_0(&call, ENOMEM);
182 return ENOMEM;
183 }
184
185 async_answer_0(&call, EOK);
186
187 match_id->score = IPC_GET_ARG1(call);
188
189 char *match_id_str;
190 rc = async_data_write_accept((void **) &match_id_str, true, 0, 0, 0, 0);
191 match_id->id = match_id_str;
192 if (rc != EOK) {
193 delete_match_id(match_id);
194 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to receive match id string: %s.",
195 str_error(rc));
196 return rc;
197 }
198
199 list_append(&match_id->link, &match_ids->ids);
200
201 log_msg(LOG_DEFAULT, LVL_DEBUG, "Received match id `%s', score %d.",
202 match_id->id, match_id->score);
203 return rc;
204}
205
206/** Receive device match IDs from the device's parent driver and add them to the
207 * list of devices match ids.
208 *
209 * @param match_count The number of device's match ids to be received.
210 * @param match_ids The list of the device's match ids.
211 * @return Zero on success, error code otherwise.
212 */
213static errno_t devman_receive_match_ids(sysarg_t match_count,
214 match_id_list_t *match_ids)
215{
216 errno_t ret = EOK;
217 size_t i;
218
219 for (i = 0; i < match_count; i++) {
220 if (EOK != (ret = devman_receive_match_id(match_ids)))
221 return ret;
222 }
223 return ret;
224}
225
226/** Handle function registration.
227 *
228 * Child devices are registered by their parent's device driver.
229 */
230static void devman_add_function(ipc_call_t *call)
231{
232 fun_type_t ftype = (fun_type_t) IPC_GET_ARG1(*call);
233 devman_handle_t dev_handle = IPC_GET_ARG2(*call);
234 sysarg_t match_count = IPC_GET_ARG3(*call);
235 dev_tree_t *tree = &device_tree;
236
237 dev_node_t *pdev = find_dev_node(&device_tree, dev_handle);
238 if (pdev == NULL) {
239 async_answer_0(call, ENOENT);
240 return;
241 }
242
243 if (ftype != fun_inner && ftype != fun_exposed) {
244 /* Unknown function type */
245 log_msg(LOG_DEFAULT, LVL_ERROR,
246 "Unknown function type %d provided by driver.",
247 (int) ftype);
248
249 dev_del_ref(pdev);
250 async_answer_0(call, EINVAL);
251 return;
252 }
253
254 char *fun_name = NULL;
255 errno_t rc = async_data_write_accept((void **) &fun_name, true, 0, 0, 0, 0);
256 if (rc != EOK) {
257 dev_del_ref(pdev);
258 async_answer_0(call, rc);
259 return;
260 }
261
262 fibril_rwlock_write_lock(&tree->rwlock);
263
264 /* Check device state */
265 if (pdev->state == DEVICE_REMOVED) {
266 fibril_rwlock_write_unlock(&tree->rwlock);
267 dev_del_ref(pdev);
268 async_answer_0(call, ENOENT);
269 return;
270 }
271
272 /* Check that function with same name is not there already. */
273 fun_node_t *tfun = find_fun_node_in_device(tree, pdev, fun_name);
274 if (tfun) {
275 fun_del_ref(tfun); /* drop the new unwanted reference */
276 fibril_rwlock_write_unlock(&tree->rwlock);
277 dev_del_ref(pdev);
278 async_answer_0(call, EEXIST);
279 printf(NAME ": Warning, driver tried to register `%s' twice.\n",
280 fun_name);
281 free(fun_name);
282 return;
283 }
284
285 fun_node_t *fun = create_fun_node();
286 /* One reference for creation, one for us */
287 fun_add_ref(fun);
288 fun_add_ref(fun);
289 fun->ftype = ftype;
290
291 /*
292 * We can lock the function here even when holding the tree because
293 * we know it cannot be held by anyone else yet.
294 */
295 fun_busy_lock(fun);
296
297 if (!insert_fun_node(&device_tree, fun, fun_name, pdev)) {
298 fibril_rwlock_write_unlock(&tree->rwlock);
299 dev_del_ref(pdev);
300 fun_busy_unlock(fun);
301 fun_del_ref(fun);
302 delete_fun_node(fun);
303 async_answer_0(call, ENOMEM);
304 return;
305 }
306
307 fibril_rwlock_write_unlock(&tree->rwlock);
308 dev_del_ref(pdev);
309
310 devman_receive_match_ids(match_count, &fun->match_ids);
311
312 rc = fun_online(fun);
313 if (rc != EOK) {
314 /* XXX Set some failed state? */
315 fun_busy_unlock(fun);
316 fun_del_ref(fun);
317 async_answer_0(call, rc);
318 return;
319 }
320
321 fun_busy_unlock(fun);
322 fun_del_ref(fun);
323
324 /* Return device handle to parent's driver. */
325 async_answer_1(call, EOK, fun->handle);
326}
327
328static void devman_add_function_to_cat(ipc_call_t *call)
329{
330 devman_handle_t handle = IPC_GET_ARG1(*call);
331 category_id_t cat_id;
332 errno_t rc;
333
334 /* Get category name. */
335 char *cat_name;
336 rc = async_data_write_accept((void **) &cat_name, true,
337 0, 0, 0, 0);
338 if (rc != EOK) {
339 async_answer_0(call, rc);
340 return;
341 }
342
343 fun_node_t *fun = find_fun_node(&device_tree, handle);
344 if (fun == NULL) {
345 async_answer_0(call, ENOENT);
346 return;
347 }
348
349 fibril_rwlock_read_lock(&device_tree.rwlock);
350
351 /* Check function state */
352 if (fun->state == FUN_REMOVED) {
353 fibril_rwlock_read_unlock(&device_tree.rwlock);
354 async_answer_0(call, ENOENT);
355 return;
356 }
357
358 rc = loc_category_get_id(cat_name, &cat_id, IPC_FLAG_BLOCKING);
359 if (rc == EOK) {
360 loc_service_add_to_cat(fun->service_id, cat_id);
361 log_msg(LOG_DEFAULT, LVL_NOTE, "Function `%s' added to category `%s'.",
362 fun->pathname, cat_name);
363 } else {
364 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed adding function `%s' to category "
365 "`%s'.", fun->pathname, cat_name);
366 }
367
368 fibril_rwlock_read_unlock(&device_tree.rwlock);
369 fun_del_ref(fun);
370
371 async_answer_0(call, rc);
372}
373
374/** Online function by driver request.
375 *
376 */
377static void devman_drv_fun_online(ipc_call_t *icall, driver_t *drv)
378{
379 fun_node_t *fun;
380 errno_t rc;
381
382 log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_drv_fun_online()");
383
384 fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall));
385 if (fun == NULL) {
386 async_answer_0(icall, ENOENT);
387 return;
388 }
389
390 fun_busy_lock(fun);
391
392 fibril_rwlock_read_lock(&device_tree.rwlock);
393 if (fun->dev == NULL || fun->dev->drv != drv) {
394 fibril_rwlock_read_unlock(&device_tree.rwlock);
395 fun_busy_unlock(fun);
396 fun_del_ref(fun);
397 async_answer_0(icall, ENOENT);
398 return;
399 }
400 fibril_rwlock_read_unlock(&device_tree.rwlock);
401
402 rc = fun_online(fun);
403 if (rc != EOK) {
404 fun_busy_unlock(fun);
405 fun_del_ref(fun);
406 async_answer_0(icall, rc);
407 return;
408 }
409
410 fun_busy_unlock(fun);
411 fun_del_ref(fun);
412
413 async_answer_0(icall, EOK);
414}
415
416
417/** Offline function by driver request.
418 *
419 */
420static void devman_drv_fun_offline(ipc_call_t *icall, driver_t *drv)
421{
422 fun_node_t *fun;
423 errno_t rc;
424
425 fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall));
426 if (fun == NULL) {
427 async_answer_0(icall, ENOENT);
428 return;
429 }
430
431 fun_busy_lock(fun);
432
433 fibril_rwlock_write_lock(&device_tree.rwlock);
434 if (fun->dev == NULL || fun->dev->drv != drv) {
435 fun_busy_unlock(fun);
436 fun_del_ref(fun);
437 async_answer_0(icall, ENOENT);
438 return;
439 }
440 fibril_rwlock_write_unlock(&device_tree.rwlock);
441
442 rc = fun_offline(fun);
443 if (rc != EOK) {
444 fun_busy_unlock(fun);
445 fun_del_ref(fun);
446 async_answer_0(icall, rc);
447 return;
448 }
449
450 fun_busy_unlock(fun);
451 fun_del_ref(fun);
452 async_answer_0(icall, EOK);
453}
454
455/** Remove function. */
456static void devman_remove_function(ipc_call_t *call)
457{
458 devman_handle_t fun_handle = IPC_GET_ARG1(*call);
459 dev_tree_t *tree = &device_tree;
460 errno_t rc;
461
462 fun_node_t *fun = find_fun_node(&device_tree, fun_handle);
463 if (fun == NULL) {
464 async_answer_0(call, ENOENT);
465 return;
466 }
467
468 fun_busy_lock(fun);
469
470 fibril_rwlock_write_lock(&tree->rwlock);
471
472 log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_remove_function(fun='%s')", fun->pathname);
473
474 /* Check function state */
475 if (fun->state == FUN_REMOVED) {
476 fibril_rwlock_write_unlock(&tree->rwlock);
477 fun_busy_unlock(fun);
478 fun_del_ref(fun);
479 async_answer_0(call, ENOENT);
480 return;
481 }
482
483 if (fun->ftype == fun_inner) {
484 /* This is a surprise removal. Handle possible descendants */
485 if (fun->child != NULL) {
486 dev_node_t *dev = fun->child;
487 device_state_t dev_state;
488 errno_t gone_rc;
489
490 dev_add_ref(dev);
491 dev_state = dev->state;
492
493 fibril_rwlock_write_unlock(&device_tree.rwlock);
494
495 /* If device is owned by driver, inform driver it is gone. */
496 if (dev_state == DEVICE_USABLE)
497 gone_rc = driver_dev_gone(&device_tree, dev);
498 else
499 gone_rc = EOK;
500
501 fibril_rwlock_read_lock(&device_tree.rwlock);
502
503 /* Verify that driver succeeded and removed all functions */
504 if (gone_rc != EOK || !list_empty(&dev->functions)) {
505 log_msg(LOG_DEFAULT, LVL_ERROR, "Driver did not remove "
506 "functions for device that is gone. "
507 "Device node is now defunct.");
508
509 /*
510 * Not much we can do but mark the device
511 * node as having invalid state. This
512 * is a driver bug.
513 */
514 dev->state = DEVICE_INVALID;
515 fibril_rwlock_read_unlock(&device_tree.rwlock);
516 dev_del_ref(dev);
517 if (gone_rc == EOK)
518 gone_rc = ENOTSUP;
519 fun_busy_unlock(fun);
520 fun_del_ref(fun);
521 async_answer_0(call, gone_rc);
522 return;
523 }
524
525 driver_t *driver = dev->drv;
526 fibril_rwlock_read_unlock(&device_tree.rwlock);
527
528 if (driver)
529 detach_driver(&device_tree, dev);
530
531 fibril_rwlock_write_lock(&device_tree.rwlock);
532 remove_dev_node(&device_tree, dev);
533
534 /* Delete ref created when node was inserted */
535 dev_del_ref(dev);
536 /* Delete ref created by dev_add_ref(dev) above */
537 dev_del_ref(dev);
538 }
539 } else {
540 if (fun->service_id != 0) {
541 /* Unregister from location service */
542 rc = loc_unregister_tree_function(fun, &device_tree);
543 if (rc != EOK) {
544 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed unregistering tree "
545 "service.");
546 fibril_rwlock_write_unlock(&tree->rwlock);
547 fun_busy_unlock(fun);
548 fun_del_ref(fun);
549 async_answer_0(call, EIO);
550 return;
551 }
552 }
553 }
554
555 remove_fun_node(&device_tree, fun);
556 fibril_rwlock_write_unlock(&tree->rwlock);
557 fun_busy_unlock(fun);
558
559 /* Delete ref added when inserting function into tree */
560 fun_del_ref(fun);
561 /* Delete ref added above when looking up function */
562 fun_del_ref(fun);
563
564 log_msg(LOG_DEFAULT, LVL_DEBUG, "devman_remove_function() succeeded.");
565 async_answer_0(call, EOK);
566}
567
568/** Initialize driver which has registered itself as running and ready.
569 *
570 * The initialization is done in a separate fibril to avoid deadlocks (if the
571 * driver needed to be served by devman during the driver's initialization).
572 */
573static errno_t init_running_drv(void *drv)
574{
575 driver_t *driver = (driver_t *) drv;
576
577 initialize_running_driver(driver, &device_tree);
578 log_msg(LOG_DEFAULT, LVL_DEBUG, "The `%s` driver was successfully initialized.",
579 driver->name);
580 return 0;
581}
582
583/** Function for handling connections from a driver to the device manager. */
584void devman_connection_driver(ipc_call_t *icall, void *arg)
585{
586 client_t *client;
587 driver_t *driver = NULL;
588
589 /* Accept the connection. */
590 async_answer_0(icall, EOK);
591
592 client = async_get_client_data();
593 if (client == NULL) {
594 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed to allocate client data.");
595 return;
596 }
597
598 while (true) {
599 ipc_call_t call;
600 async_get_call(&call);
601
602 if (!IPC_GET_IMETHOD(call))
603 break;
604
605 if (IPC_GET_IMETHOD(call) != DEVMAN_DRIVER_REGISTER) {
606 fibril_mutex_lock(&client->mutex);
607 driver = client->driver;
608 fibril_mutex_unlock(&client->mutex);
609 if (driver == NULL) {
610 /* First call must be to DEVMAN_DRIVER_REGISTER */
611 async_answer_0(&call, ENOTSUP);
612 continue;
613 }
614 }
615
616 switch (IPC_GET_IMETHOD(call)) {
617 case DEVMAN_DRIVER_REGISTER:
618 fibril_mutex_lock(&client->mutex);
619 if (client->driver != NULL) {
620 fibril_mutex_unlock(&client->mutex);
621 async_answer_0(&call, EINVAL);
622 continue;
623 }
624 client->driver = devman_driver_register(&call);
625 fibril_mutex_unlock(&client->mutex);
626 break;
627 case DEVMAN_ADD_FUNCTION:
628 devman_add_function(&call);
629 break;
630 case DEVMAN_ADD_DEVICE_TO_CATEGORY:
631 devman_add_function_to_cat(&call);
632 break;
633 case DEVMAN_DRV_FUN_ONLINE:
634 devman_drv_fun_online(&call, driver);
635 break;
636 case DEVMAN_DRV_FUN_OFFLINE:
637 devman_drv_fun_offline(&call, driver);
638 break;
639 case DEVMAN_REMOVE_FUNCTION:
640 devman_remove_function(&call);
641 break;
642 default:
643 async_answer_0(&call, EINVAL);
644 break;
645 }
646 }
647}
648
649/** @}
650 */
Note: See TracBrowser for help on using the repository browser.