Changes in uspace/srv/devman/main.c [79ae36dd:f278930] in mainline
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
uspace/srv/devman/main.c
r79ae36dd rf278930 56 56 #include <ipc/driver.h> 57 57 #include <thread.h> 58 #include < devmap.h>58 #include <loc.h> 59 59 60 60 #include "devman.h" … … 64 64 static driver_list_t drivers_list; 65 65 static dev_tree_t device_tree; 66 static class_list_t class_list; 66 67 static int init_running_drv(void *drv); 67 68 68 69 /** Register running driver. */ 69 static driver_t *devman_driver_register(void) 70 { 71 ipc_call_t icall; 72 ipc_callid_t iid; 70 static driver_t *devman_driver_register(ipc_callid_t callid, ipc_call_t *call) 71 { 73 72 driver_t *driver = NULL; 73 char *drv_name = NULL; 74 74 75 75 log_msg(LVL_DEBUG, "devman_driver_register"); 76 77 iid = async_get_call(&icall);78 if (IPC_GET_IMETHOD(icall) != DEVMAN_DRIVER_REGISTER) {79 async_answer_0(iid, EREFUSED);80 return NULL;81 }82 83 char *drv_name = NULL;84 76 85 77 /* Get driver name. */ 86 78 int rc = async_data_write_accept((void **) &drv_name, true, 0, 0, 0, 0); 87 79 if (rc != EOK) { 88 async_answer_0( iid, rc);80 async_answer_0(callid, rc); 89 81 return NULL; 90 82 } … … 99 91 free(drv_name); 100 92 drv_name = NULL; 101 async_answer_0( iid, ENOENT);93 async_answer_0(callid, ENOENT); 102 94 return NULL; 103 95 } … … 113 105 driver->name); 114 106 fibril_mutex_unlock(&driver->driver_mutex); 115 async_answer_0( iid, EEXISTS);107 async_answer_0(callid, EEXISTS); 116 108 return NULL; 117 109 } … … 135 127 log_msg(LVL_DEBUG, "Creating connection to the `%s' driver.", 136 128 driver->name); 137 driver->sess = async_callback_receive(EXCHANGE_ SERIALIZE);129 driver->sess = async_callback_receive(EXCHANGE_PARALLEL); 138 130 if (!driver->sess) { 139 131 fibril_mutex_unlock(&driver->driver_mutex); 140 async_answer_0( iid, ENOTSUP);132 async_answer_0(callid, ENOTSUP); 141 133 return NULL; 142 134 } 143 144 fibril_mutex_unlock(&driver->driver_mutex);135 /* FIXME: Work around problem with callback sessions */ 136 async_sess_args_set(driver->sess, DRIVER_DEVMAN, 0, 0); 145 137 146 138 log_msg(LVL_NOTE, … … 148 140 driver->name); 149 141 150 async_answer_0(iid, EOK); 151 142 /* 143 * Initialize the driver as running (e.g. pass assigned devices to it) 144 * in a separate fibril; the separate fibril is used to enable the 145 * driver to use devman service during the driver's initialization. 146 */ 147 fid_t fid = fibril_create(init_running_drv, driver); 148 if (fid == 0) { 149 log_msg(LVL_ERROR, "Failed to create initialization fibril " \ 150 "for driver `%s'.", driver->name); 151 fibril_mutex_unlock(&driver->driver_mutex); 152 async_answer_0(callid, ENOMEM); 153 return NULL; 154 } 155 156 fibril_add_ready(fid); 157 fibril_mutex_unlock(&driver->driver_mutex); 158 159 async_answer_0(callid, EOK); 152 160 return driver; 153 161 } … … 226 234 dev_node_t *dev_node = (dev_node_t *) arg; 227 235 assign_driver(dev_node, &drivers_list, &device_tree); 236 237 /* Delete one reference we got from the caller. */ 238 dev_del_ref(dev_node); 228 239 return EOK; 229 240 } 230 241 231 /** Handle function registration. 232 * 233 * Child devices are registered by their parent's device driver. 234 */ 235 static void devman_add_function(ipc_callid_t callid, ipc_call_t *call) 236 { 237 fun_type_t ftype = (fun_type_t) IPC_GET_ARG1(*call); 238 devman_handle_t dev_handle = IPC_GET_ARG2(*call); 239 sysarg_t match_count = IPC_GET_ARG3(*call); 240 dev_tree_t *tree = &device_tree; 241 242 fibril_rwlock_write_lock(&tree->rwlock); 243 244 dev_node_t *dev = NULL; 245 dev_node_t *pdev = find_dev_node_no_lock(&device_tree, dev_handle); 246 247 if (pdev == NULL) { 248 fibril_rwlock_write_unlock(&tree->rwlock); 249 async_answer_0(callid, ENOENT); 250 return; 251 } 252 253 if (ftype != fun_inner && ftype != fun_exposed) { 254 /* Unknown function type */ 255 log_msg(LVL_ERROR, 256 "Unknown function type %d provided by driver.", 257 (int) ftype); 258 259 fibril_rwlock_write_unlock(&tree->rwlock); 260 async_answer_0(callid, EINVAL); 261 return; 262 } 263 264 char *fun_name = NULL; 265 int rc = async_data_write_accept((void **)&fun_name, true, 0, 0, 0, 0); 266 if (rc != EOK) { 267 fibril_rwlock_write_unlock(&tree->rwlock); 268 async_answer_0(callid, rc); 269 return; 270 } 271 272 /* Check that function with same name is not there already. */ 273 if (find_fun_node_in_device(pdev, fun_name) != NULL) { 274 fibril_rwlock_write_unlock(&tree->rwlock); 275 async_answer_0(callid, EEXISTS); 276 printf(NAME ": Warning, driver tried to register `%s' twice.\n", 277 fun_name); 278 free(fun_name); 279 return; 280 } 281 282 fun_node_t *fun = create_fun_node(); 283 if (!insert_fun_node(&device_tree, fun, fun_name, pdev)) { 284 fibril_rwlock_write_unlock(&tree->rwlock); 285 delete_fun_node(fun); 286 async_answer_0(callid, ENOMEM); 287 return; 288 } 289 290 if (ftype == fun_inner) { 242 static int online_function(fun_node_t *fun) 243 { 244 dev_node_t *dev; 245 246 fibril_rwlock_write_lock(&device_tree.rwlock); 247 248 if (fun->state == FUN_ON_LINE) { 249 fibril_rwlock_write_unlock(&device_tree.rwlock); 250 log_msg(LVL_WARN, "Function %s is already on line.", 251 fun->pathname); 252 return EOK; 253 } 254 255 if (fun->ftype == fun_inner) { 291 256 dev = create_dev_node(); 292 257 if (dev == NULL) { 293 fibril_rwlock_write_unlock(&tree->rwlock); 294 delete_fun_node(fun); 295 async_answer_0(callid, ENOMEM); 296 return; 258 fibril_rwlock_write_unlock(&device_tree.rwlock); 259 return ENOMEM; 297 260 } 298 261 299 insert_dev_node(tree, dev, fun); 300 } 301 302 fibril_rwlock_write_unlock(&tree->rwlock); 262 insert_dev_node(&device_tree, dev, fun); 263 dev_add_ref(dev); 264 } 303 265 304 266 log_msg(LVL_DEBUG, "devman_add_function(fun=\"%s\")", fun->pathname); 305 267 306 devman_receive_match_ids(match_count, &fun->match_ids); 307 308 if (ftype == fun_inner) { 268 if (fun->ftype == fun_inner) { 269 dev = fun->child; 309 270 assert(dev != NULL); 271 272 /* Give one reference over to assign_driver_fibril(). */ 273 dev_add_ref(dev); 310 274 /* 311 275 * Try to find a suitable driver and assign it to the device. We do … … 317 281 fid_t assign_fibril = fibril_create(assign_driver_fibril, dev); 318 282 if (assign_fibril == 0) { 319 /* 320 * Fallback in case we are out of memory. 321 * Probably not needed as we will die soon anyway ;-). 322 */ 323 (void) assign_driver_fibril(fun); 324 } else { 325 fibril_add_ready(assign_fibril); 283 log_msg(LVL_ERROR, "Failed to create fibril for " 284 "assigning driver."); 285 /* XXX Cleanup */ 286 fibril_rwlock_write_unlock(&device_tree.rwlock); 287 return ENOMEM; 288 } 289 fibril_add_ready(assign_fibril); 290 } else { 291 loc_register_tree_function(fun, &device_tree); 292 } 293 294 fibril_rwlock_write_unlock(&device_tree.rwlock); 295 296 return EOK; 297 } 298 299 static int offline_function(fun_node_t *fun) 300 { 301 int rc; 302 303 fibril_rwlock_write_lock(&device_tree.rwlock); 304 305 if (fun->state == FUN_OFF_LINE) { 306 fibril_rwlock_write_unlock(&device_tree.rwlock); 307 log_msg(LVL_WARN, "Function %s is already off line.", 308 fun->pathname); 309 return EOK; 310 } 311 312 if (fun->ftype == fun_inner) { 313 log_msg(LVL_DEBUG, "Offlining inner function %s.", 314 fun->pathname); 315 316 if (fun->child != NULL) { 317 dev_node_t *dev = fun->child; 318 319 dev_add_ref(dev); 320 fibril_rwlock_write_unlock(&device_tree.rwlock); 321 322 /* If device is owned by driver, ask driver to give it up. */ 323 if (dev->state == DEVICE_USABLE) { 324 rc = driver_dev_remove(&device_tree, dev); 325 if (rc != EOK) { 326 dev_del_ref(dev); 327 return ENOTSUP; 328 } 329 } 330 331 /* Verify that driver removed all functions */ 332 fibril_rwlock_read_lock(&device_tree.rwlock); 333 if (!list_empty(&dev->functions)) { 334 fibril_rwlock_read_unlock(&device_tree.rwlock); 335 return EIO; 336 } 337 driver_t *driver = dev->drv; 338 fibril_rwlock_read_unlock(&device_tree.rwlock); 339 340 if (driver) 341 detach_driver(&device_tree, dev); 342 343 fibril_rwlock_write_lock(&device_tree.rwlock); 344 remove_dev_node(&device_tree, dev); 345 346 /* Delete ref created when node was inserted */ 347 dev_del_ref(dev); 348 /* Delete ref created by dev_add_ref(dev) above */ 349 dev_del_ref(dev); 326 350 } 327 351 } else { 328 devmap_register_tree_function(fun, tree); 352 /* Unregister from location service */ 353 rc = loc_service_unregister(fun->service_id); 354 if (rc != EOK) { 355 fibril_rwlock_write_unlock(&device_tree.rwlock); 356 log_msg(LVL_ERROR, "Failed unregistering tree service."); 357 return EIO; 358 } 359 360 fun->service_id = 0; 361 } 362 363 fun->state = FUN_OFF_LINE; 364 fibril_rwlock_write_unlock(&device_tree.rwlock); 365 366 return EOK; 367 } 368 369 /** Handle function registration. 370 * 371 * Child devices are registered by their parent's device driver. 372 */ 373 static void devman_add_function(ipc_callid_t callid, ipc_call_t *call) 374 { 375 fun_type_t ftype = (fun_type_t) IPC_GET_ARG1(*call); 376 devman_handle_t dev_handle = IPC_GET_ARG2(*call); 377 sysarg_t match_count = IPC_GET_ARG3(*call); 378 dev_tree_t *tree = &device_tree; 379 380 dev_node_t *pdev = find_dev_node(&device_tree, dev_handle); 381 if (pdev == NULL) { 382 async_answer_0(callid, ENOENT); 383 return; 384 } 385 386 if (ftype != fun_inner && ftype != fun_exposed) { 387 /* Unknown function type */ 388 log_msg(LVL_ERROR, 389 "Unknown function type %d provided by driver.", 390 (int) ftype); 391 392 dev_del_ref(pdev); 393 async_answer_0(callid, EINVAL); 394 return; 395 } 396 397 char *fun_name = NULL; 398 int rc = async_data_write_accept((void **)&fun_name, true, 0, 0, 0, 0); 399 if (rc != EOK) { 400 dev_del_ref(pdev); 401 async_answer_0(callid, rc); 402 return; 403 } 404 405 fibril_rwlock_write_lock(&tree->rwlock); 406 407 /* Check device state */ 408 if (pdev->state == DEVICE_REMOVED) { 409 fibril_rwlock_write_unlock(&tree->rwlock); 410 dev_del_ref(pdev); 411 async_answer_0(callid, ENOENT); 412 return; 413 } 414 415 /* Check that function with same name is not there already. */ 416 if (find_fun_node_in_device(tree, pdev, fun_name) != NULL) { 417 fibril_rwlock_write_unlock(&tree->rwlock); 418 dev_del_ref(pdev); 419 async_answer_0(callid, EEXISTS); 420 printf(NAME ": Warning, driver tried to register `%s' twice.\n", 421 fun_name); 422 free(fun_name); 423 return; 424 } 425 426 fun_node_t *fun = create_fun_node(); 427 fun_add_ref(fun); 428 fun->ftype = ftype; 429 430 if (!insert_fun_node(&device_tree, fun, fun_name, pdev)) { 431 fibril_rwlock_write_unlock(&tree->rwlock); 432 dev_del_ref(pdev); 433 delete_fun_node(fun); 434 async_answer_0(callid, ENOMEM); 435 return; 436 } 437 438 fibril_rwlock_write_unlock(&tree->rwlock); 439 dev_del_ref(pdev); 440 441 devman_receive_match_ids(match_count, &fun->match_ids); 442 443 rc = online_function(fun); 444 if (rc != EOK) { 445 /* XXX clean up */ 446 async_answer_0(callid, rc); 447 return; 329 448 } 330 449 … … 333 452 } 334 453 335 static void devmap_register_class_dev(dev_class_info_t *cli) 336 { 337 /* Create devmap path and name for the device. */ 338 char *devmap_pathname = NULL; 339 340 asprintf(&devmap_pathname, "%s/%s%c%s", DEVMAP_CLASS_NAMESPACE, 341 cli->dev_class->name, DEVMAP_SEPARATOR, cli->dev_name); 342 if (devmap_pathname == NULL) 343 return; 344 345 /* 346 * Register the device by the device mapper and remember its devmap 347 * handle. 348 */ 349 devmap_device_register_with_iface(devmap_pathname, 350 &cli->devmap_handle, DEVMAN_CONNECT_FROM_DEVMAP); 351 352 /* 353 * Add device to the hash map of class devices registered by device 354 * mapper. 355 */ 356 class_add_devmap_function(&class_list, cli); 357 358 free(devmap_pathname); 359 } 360 361 static void devman_add_function_to_class(ipc_callid_t callid, ipc_call_t *call) 454 static void devman_add_function_to_cat(ipc_callid_t callid, ipc_call_t *call) 362 455 { 363 456 devman_handle_t handle = IPC_GET_ARG1(*call); 364 365 /* Get class name. */ 366 char *class_name; 367 int rc = async_data_write_accept((void **) &class_name, true, 457 category_id_t cat_id; 458 int rc; 459 460 /* Get category name. */ 461 char *cat_name; 462 rc = async_data_write_accept((void **) &cat_name, true, 368 463 0, 0, 0, 0); 369 464 if (rc != EOK) { 370 465 async_answer_0(callid, rc); 371 466 return; 372 } 467 } 373 468 374 469 fun_node_t *fun = find_fun_node(&device_tree, handle); … … 378 473 } 379 474 380 dev_class_t *cl = get_dev_class(&class_list, class_name); 381 dev_class_info_t *class_info = add_function_to_class(fun, cl, NULL); 382 383 /* Register the device's class alias by devmapper. */ 384 devmap_register_class_dev(class_info); 385 386 log_msg(LVL_NOTE, "Function `%s' added to class `%s' as `%s'.", 387 fun->pathname, class_name, class_info->dev_name); 388 475 fibril_rwlock_read_lock(&device_tree.rwlock); 476 477 /* Check function state */ 478 if (fun->state == FUN_REMOVED) { 479 fibril_rwlock_read_unlock(&device_tree.rwlock); 480 async_answer_0(callid, ENOENT); 481 return; 482 } 483 484 rc = loc_category_get_id(cat_name, &cat_id, IPC_FLAG_BLOCKING); 485 if (rc == EOK) { 486 loc_service_add_to_cat(fun->service_id, cat_id); 487 } else { 488 log_msg(LVL_ERROR, "Failed adding function `%s' to category " 489 "`%s'.", fun->pathname, cat_name); 490 } 491 492 log_msg(LVL_NOTE, "Function `%s' added to category `%s'.", 493 fun->pathname, cat_name); 494 495 fibril_rwlock_read_unlock(&device_tree.rwlock); 496 fun_del_ref(fun); 497 498 async_answer_0(callid, EOK); 499 } 500 501 /** Online function by driver request. 502 * 503 */ 504 static void devman_drv_fun_online(ipc_callid_t iid, ipc_call_t *icall, 505 driver_t *drv) 506 { 507 fun_node_t *fun; 508 int rc; 509 510 printf("devman_drv_fun_online()\n"); 511 fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall)); 512 if (fun == NULL) { 513 async_answer_0(iid, ENOENT); 514 return; 515 } 516 517 fibril_rwlock_read_lock(&device_tree.rwlock); 518 if (fun->dev == NULL || fun->dev->drv != drv) { 519 fibril_rwlock_read_unlock(&device_tree.rwlock); 520 fun_del_ref(fun); 521 async_answer_0(iid, ENOENT); 522 return; 523 } 524 fibril_rwlock_read_unlock(&device_tree.rwlock); 525 526 rc = online_function(fun); 527 if (rc != EOK) { 528 printf("devman_drv_fun_online() online_fun->ERROR\n"); 529 fun_del_ref(fun); 530 async_answer_0(iid, (sysarg_t) rc); 531 return; 532 } 533 534 fun_del_ref(fun); 535 printf("devman_drv_fun_online() online_fun->OK\n"); 536 537 async_answer_0(iid, (sysarg_t) EOK); 538 } 539 540 541 /** Offline function by driver request. 542 * 543 */ 544 static void devman_drv_fun_offline(ipc_callid_t iid, ipc_call_t *icall, 545 driver_t *drv) 546 { 547 fun_node_t *fun; 548 int rc; 549 550 fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall)); 551 if (fun == NULL) { 552 async_answer_0(iid, ENOENT); 553 return; 554 } 555 556 fibril_rwlock_write_lock(&device_tree.rwlock); 557 if (fun->dev == NULL || fun->dev->drv != drv) { 558 fun_del_ref(fun); 559 async_answer_0(iid, ENOENT); 560 return; 561 } 562 fibril_rwlock_write_unlock(&device_tree.rwlock); 563 564 rc = offline_function(fun); 565 if (rc != EOK) { 566 fun_del_ref(fun); 567 async_answer_0(iid, (sysarg_t) rc); 568 return; 569 } 570 571 fun_del_ref(fun); 572 async_answer_0(iid, (sysarg_t) EOK); 573 } 574 575 /** Remove function. */ 576 static void devman_remove_function(ipc_callid_t callid, ipc_call_t *call) 577 { 578 devman_handle_t fun_handle = IPC_GET_ARG1(*call); 579 dev_tree_t *tree = &device_tree; 580 int rc; 581 582 583 fun_node_t *fun = find_fun_node(&device_tree, fun_handle); 584 if (fun == NULL) { 585 async_answer_0(callid, ENOENT); 586 return; 587 } 588 589 fibril_rwlock_write_lock(&tree->rwlock); 590 591 log_msg(LVL_DEBUG, "devman_remove_function(fun='%s')", fun->pathname); 592 593 /* Check function state */ 594 if (fun->state == FUN_REMOVED) { 595 fibril_rwlock_write_unlock(&tree->rwlock); 596 async_answer_0(callid, ENOENT); 597 return; 598 } 599 600 if (fun->ftype == fun_inner) { 601 /* Handle possible descendants */ 602 /* TODO - This is a surprise removal */ 603 if (fun->child != NULL) { 604 log_msg(LVL_WARN, "devman_remove_function(): not handling " 605 "descendants\n"); 606 } 607 } else { 608 if (fun->service_id != 0) { 609 /* Unregister from location service */ 610 rc = loc_service_unregister(fun->service_id); 611 if (rc != EOK) { 612 log_msg(LVL_ERROR, "Failed unregistering tree " 613 "service."); 614 fibril_rwlock_write_unlock(&tree->rwlock); 615 fun_del_ref(fun); 616 async_answer_0(callid, EIO); 617 return; 618 } 619 } 620 } 621 622 remove_fun_node(&device_tree, fun); 623 fibril_rwlock_write_unlock(&tree->rwlock); 624 625 /* Delete ref added when inserting function into tree */ 626 fun_del_ref(fun); 627 /* Delete ref added above when looking up function */ 628 fun_del_ref(fun); 629 630 log_msg(LVL_DEBUG, "devman_remove_function() succeeded."); 389 631 async_answer_0(callid, EOK); 390 632 } … … 408 650 static void devman_connection_driver(ipc_callid_t iid, ipc_call_t *icall) 409 651 { 652 client_t *client; 653 driver_t *driver; 654 410 655 /* Accept the connection. */ 411 656 async_answer_0(iid, EOK); 412 657 413 driver_t *driver = devman_driver_register(); 414 if (driver == NULL) 415 return; 416 417 /* 418 * Initialize the driver as running (e.g. pass assigned devices to it) 419 * in a separate fibril; the separate fibril is used to enable the 420 * driver to use devman service during the driver's initialization. 421 */ 422 fid_t fid = fibril_create(init_running_drv, driver); 423 if (fid == 0) { 424 log_msg(LVL_ERROR, "Failed to create initialization fibril " \ 425 "for driver `%s'.", driver->name); 426 return; 427 } 428 fibril_add_ready(fid); 658 client = async_get_client_data(); 659 if (client == NULL) { 660 log_msg(LVL_ERROR, "Failed to allocate client data."); 661 return; 662 } 429 663 430 664 while (true) { … … 435 669 break; 436 670 671 if (IPC_GET_IMETHOD(call) != DEVMAN_DRIVER_REGISTER) { 672 fibril_mutex_lock(&client->mutex); 673 driver = client->driver; 674 fibril_mutex_unlock(&client->mutex); 675 if (driver == NULL) { 676 /* First call must be to DEVMAN_DRIVER_REGISTER */ 677 async_answer_0(callid, ENOTSUP); 678 continue; 679 } 680 } 681 437 682 switch (IPC_GET_IMETHOD(call)) { 683 case DEVMAN_DRIVER_REGISTER: 684 fibril_mutex_lock(&client->mutex); 685 if (client->driver != NULL) { 686 fibril_mutex_unlock(&client->mutex); 687 async_answer_0(callid, EINVAL); 688 continue; 689 } 690 client->driver = devman_driver_register(callid, &call); 691 fibril_mutex_unlock(&client->mutex); 692 break; 438 693 case DEVMAN_ADD_FUNCTION: 439 694 devman_add_function(callid, &call); 440 695 break; 441 case DEVMAN_ADD_DEVICE_TO_CLASS: 442 devman_add_function_to_class(callid, &call); 696 case DEVMAN_ADD_DEVICE_TO_CATEGORY: 697 devman_add_function_to_cat(callid, &call); 698 break; 699 case DEVMAN_DRV_FUN_ONLINE: 700 devman_drv_fun_online(callid, &call, driver); 701 break; 702 case DEVMAN_DRV_FUN_OFFLINE: 703 devman_drv_fun_offline(callid, &call, driver); 704 break; 705 case DEVMAN_REMOVE_FUNCTION: 706 devman_remove_function(callid, &call); 443 707 break; 444 708 default: 445 async_answer_0(callid, EINVAL); 709 async_answer_0(callid, EINVAL); 446 710 break; 447 711 } … … 454 718 { 455 719 char *pathname; 720 devman_handle_t handle; 456 721 457 722 int rc = async_data_write_accept((void **) &pathname, true, 0, 0, 0, 0); … … 470 735 } 471 736 472 async_answer_1(iid, EOK, fun->handle); 473 } 474 475 /** Find handle for the device instance identified by device class name. */ 476 static void devman_function_get_handle_by_class(ipc_callid_t iid, 477 ipc_call_t *icall) 478 { 479 char *classname; 480 char *devname; 481 482 int rc = async_data_write_accept((void **) &classname, true, 0, 0, 0, 0); 483 if (rc != EOK) { 484 async_answer_0(iid, rc); 485 return; 486 } 487 rc = async_data_write_accept((void **) &devname, true, 0, 0, 0, 0); 488 if (rc != EOK) { 489 free(classname); 490 async_answer_0(iid, rc); 491 return; 492 } 493 494 495 fun_node_t *fun = find_fun_node_by_class(&class_list, 496 classname, devname); 497 498 free(classname); 499 free(devname); 500 501 if (fun == NULL) { 502 async_answer_0(iid, ENOENT); 503 return; 504 } 505 506 async_answer_1(iid, EOK, fun->handle); 507 } 508 509 /** Find device path by its handle. */ 510 static void devman_get_device_path_by_handle(ipc_callid_t iid, 511 ipc_call_t *icall) 737 fibril_rwlock_read_lock(&device_tree.rwlock); 738 739 /* Check function state */ 740 if (fun->state == FUN_REMOVED) { 741 fibril_rwlock_read_unlock(&device_tree.rwlock); 742 async_answer_0(iid, ENOENT); 743 return; 744 } 745 handle = fun->handle; 746 747 fibril_rwlock_read_unlock(&device_tree.rwlock); 748 749 /* Delete reference created above by find_fun_node_by_path() */ 750 fun_del_ref(fun); 751 752 async_answer_1(iid, EOK, handle); 753 } 754 755 /** Get device name. */ 756 static void devman_fun_get_name(ipc_callid_t iid, ipc_call_t *icall) 512 757 { 513 758 devman_handle_t handle = IPC_GET_ARG1(*icall); … … 523 768 if (!async_data_read_receive(&data_callid, &data_len)) { 524 769 async_answer_0(iid, EINVAL); 770 fun_del_ref(fun); 525 771 return; 526 772 } … … 530 776 async_answer_0(data_callid, ENOMEM); 531 777 async_answer_0(iid, ENOMEM); 532 return; 533 } 534 778 fun_del_ref(fun); 779 return; 780 } 781 782 fibril_rwlock_read_lock(&device_tree.rwlock); 783 784 /* Check function state */ 785 if (fun->state == FUN_REMOVED) { 786 fibril_rwlock_read_unlock(&device_tree.rwlock); 787 free(buffer); 788 789 async_answer_0(data_callid, ENOENT); 790 async_answer_0(iid, ENOENT); 791 fun_del_ref(fun); 792 return; 793 } 794 795 size_t sent_length = str_size(fun->name); 796 if (sent_length > data_len) { 797 sent_length = data_len; 798 } 799 800 async_data_read_finalize(data_callid, fun->name, sent_length); 801 async_answer_0(iid, EOK); 802 803 fibril_rwlock_read_unlock(&device_tree.rwlock); 804 fun_del_ref(fun); 805 free(buffer); 806 } 807 808 809 /** Get device path. */ 810 static void devman_fun_get_path(ipc_callid_t iid, ipc_call_t *icall) 811 { 812 devman_handle_t handle = IPC_GET_ARG1(*icall); 813 814 fun_node_t *fun = find_fun_node(&device_tree, handle); 815 if (fun == NULL) { 816 async_answer_0(iid, ENOMEM); 817 return; 818 } 819 820 ipc_callid_t data_callid; 821 size_t data_len; 822 if (!async_data_read_receive(&data_callid, &data_len)) { 823 async_answer_0(iid, EINVAL); 824 fun_del_ref(fun); 825 return; 826 } 827 828 void *buffer = malloc(data_len); 829 if (buffer == NULL) { 830 async_answer_0(data_callid, ENOMEM); 831 async_answer_0(iid, ENOMEM); 832 fun_del_ref(fun); 833 return; 834 } 835 836 fibril_rwlock_read_lock(&device_tree.rwlock); 837 838 /* Check function state */ 839 if (fun->state == FUN_REMOVED) { 840 fibril_rwlock_read_unlock(&device_tree.rwlock); 841 free(buffer); 842 843 async_answer_0(data_callid, ENOENT); 844 async_answer_0(iid, ENOENT); 845 fun_del_ref(fun); 846 return; 847 } 848 535 849 size_t sent_length = str_size(fun->pathname); 536 850 if (sent_length > data_len) { … … 541 855 async_answer_0(iid, EOK); 542 856 857 fibril_rwlock_read_unlock(&device_tree.rwlock); 858 fun_del_ref(fun); 543 859 free(buffer); 544 860 } 545 861 862 static void devman_dev_get_functions(ipc_callid_t iid, ipc_call_t *icall) 863 { 864 ipc_callid_t callid; 865 size_t size; 866 size_t act_size; 867 int rc; 868 869 if (!async_data_read_receive(&callid, &size)) { 870 async_answer_0(callid, EREFUSED); 871 async_answer_0(iid, EREFUSED); 872 return; 873 } 874 875 fibril_rwlock_read_lock(&device_tree.rwlock); 876 877 dev_node_t *dev = find_dev_node_no_lock(&device_tree, 878 IPC_GET_ARG1(*icall)); 879 if (dev == NULL || dev->state == DEVICE_REMOVED) { 880 fibril_rwlock_read_unlock(&device_tree.rwlock); 881 async_answer_0(callid, ENOENT); 882 async_answer_0(iid, ENOENT); 883 return; 884 } 885 886 devman_handle_t *hdl_buf = (devman_handle_t *) malloc(size); 887 if (hdl_buf == NULL) { 888 fibril_rwlock_read_unlock(&device_tree.rwlock); 889 async_answer_0(callid, ENOMEM); 890 async_answer_0(iid, ENOMEM); 891 return; 892 } 893 894 rc = dev_get_functions(&device_tree, dev, hdl_buf, size, &act_size); 895 if (rc != EOK) { 896 fibril_rwlock_read_unlock(&device_tree.rwlock); 897 async_answer_0(callid, rc); 898 async_answer_0(iid, rc); 899 return; 900 } 901 902 fibril_rwlock_read_unlock(&device_tree.rwlock); 903 904 sysarg_t retval = async_data_read_finalize(callid, hdl_buf, size); 905 free(hdl_buf); 906 907 async_answer_1(iid, retval, act_size); 908 } 909 910 911 /** Get handle for child device of a function. */ 912 static void devman_fun_get_child(ipc_callid_t iid, ipc_call_t *icall) 913 { 914 fun_node_t *fun; 915 916 fibril_rwlock_read_lock(&device_tree.rwlock); 917 918 fun = find_fun_node_no_lock(&device_tree, IPC_GET_ARG1(*icall)); 919 if (fun == NULL || fun->state == FUN_REMOVED) { 920 fibril_rwlock_read_unlock(&device_tree.rwlock); 921 async_answer_0(iid, ENOENT); 922 return; 923 } 924 925 if (fun->child == NULL) { 926 fibril_rwlock_read_unlock(&device_tree.rwlock); 927 async_answer_0(iid, ENOENT); 928 return; 929 } 930 931 async_answer_1(iid, EOK, fun->child->handle); 932 933 fibril_rwlock_read_unlock(&device_tree.rwlock); 934 } 935 936 /** Online function. 937 * 938 * Send a request to online a function to the responsible driver. 939 * The driver may offline other functions if necessary (i.e. if the state 940 * of this function is linked to state of another function somehow). 941 */ 942 static void devman_fun_online(ipc_callid_t iid, ipc_call_t *icall) 943 { 944 fun_node_t *fun; 945 int rc; 946 947 fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall)); 948 if (fun == NULL) { 949 async_answer_0(iid, ENOENT); 950 return; 951 } 952 953 rc = driver_fun_online(&device_tree, fun); 954 fun_del_ref(fun); 955 956 async_answer_0(iid, (sysarg_t) rc); 957 } 958 959 /** Offline function. 960 * 961 * Send a request to offline a function to the responsible driver. As 962 * a result the subtree rooted at that function should be cleanly 963 * detatched. The driver may offline other functions if necessary 964 * (i.e. if the state of this function is linked to state of another 965 * function somehow). 966 */ 967 static void devman_fun_offline(ipc_callid_t iid, ipc_call_t *icall) 968 { 969 fun_node_t *fun; 970 int rc; 971 972 fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall)); 973 if (fun == NULL) { 974 async_answer_0(iid, ENOENT); 975 return; 976 } 977 978 rc = driver_fun_offline(&device_tree, fun); 979 fun_del_ref(fun); 980 981 async_answer_0(iid, (sysarg_t) rc); 982 } 983 984 /** Find handle for the function instance identified by its service ID. */ 985 static void devman_fun_sid_to_handle(ipc_callid_t iid, ipc_call_t *icall) 986 { 987 fun_node_t *fun; 988 989 fun = find_loc_tree_function(&device_tree, IPC_GET_ARG1(*icall)); 990 991 if (fun == NULL) { 992 async_answer_0(iid, ENOENT); 993 return; 994 } 995 996 fibril_rwlock_read_lock(&device_tree.rwlock); 997 998 /* Check function state */ 999 if (fun->state == FUN_REMOVED) { 1000 fibril_rwlock_read_unlock(&device_tree.rwlock); 1001 async_answer_0(iid, ENOENT); 1002 return; 1003 } 1004 1005 async_answer_1(iid, EOK, fun->handle); 1006 fibril_rwlock_read_unlock(&device_tree.rwlock); 1007 fun_del_ref(fun); 1008 } 546 1009 547 1010 /** Function for handling connections from a client to the device manager. */ … … 562 1025 devman_function_get_handle(callid, &call); 563 1026 break; 564 case DEVMAN_DEVICE_GET_HANDLE_BY_CLASS: 565 devman_function_get_handle_by_class(callid, &call); 566 break; 567 case DEVMAN_DEVICE_GET_DEVICE_PATH: 568 devman_get_device_path_by_handle(callid, &call); 1027 case DEVMAN_DEV_GET_FUNCTIONS: 1028 devman_dev_get_functions(callid, &call); 1029 break; 1030 case DEVMAN_FUN_GET_CHILD: 1031 devman_fun_get_child(callid, &call); 1032 break; 1033 case DEVMAN_FUN_GET_NAME: 1034 devman_fun_get_name(callid, &call); 1035 break; 1036 case DEVMAN_FUN_GET_PATH: 1037 devman_fun_get_path(callid, &call); 1038 break; 1039 case DEVMAN_FUN_ONLINE: 1040 devman_fun_online(callid, &call); 1041 break; 1042 case DEVMAN_FUN_OFFLINE: 1043 devman_fun_offline(callid, &call); 1044 break; 1045 case DEVMAN_FUN_SID_TO_HANDLE: 1046 devman_fun_sid_to_handle(callid, &call); 569 1047 break; 570 1048 default: … … 585 1063 if (fun == NULL) 586 1064 dev = find_dev_node(&device_tree, handle); 587 else 1065 else { 1066 fibril_rwlock_read_lock(&device_tree.rwlock); 588 1067 dev = fun->dev; 1068 if (dev != NULL) 1069 dev_add_ref(dev); 1070 fibril_rwlock_read_unlock(&device_tree.rwlock); 1071 } 589 1072 590 1073 /* … … 598 1081 "function with handle %" PRIun " was found.", handle); 599 1082 async_answer_0(iid, ENOENT); 600 return;1083 goto cleanup; 601 1084 } 602 1085 … … 606 1089 handle); 607 1090 async_answer_0(iid, ENOENT); 608 return;1091 goto cleanup; 609 1092 } 610 1093 611 1094 driver_t *driver = NULL; 1095 1096 fibril_rwlock_read_lock(&device_tree.rwlock); 612 1097 613 1098 if (drv_to_parent) { … … 624 1109 } 625 1110 1111 fibril_rwlock_read_unlock(&device_tree.rwlock); 1112 626 1113 if (driver == NULL) { 627 1114 log_msg(LVL_ERROR, "IPC forwarding refused - " \ 628 1115 "the device %" PRIun " is not in usable state.", handle); 629 1116 async_answer_0(iid, ENOENT); 630 return;1117 goto cleanup; 631 1118 } 632 1119 … … 641 1128 "Could not forward to driver `%s'.", driver->name); 642 1129 async_answer_0(iid, EINVAL); 643 return;1130 goto cleanup; 644 1131 } 645 1132 … … 657 1144 async_forward_fast(iid, exch, method, fwd_h, 0, IPC_FF_NONE); 658 1145 async_exchange_end(exch); 659 } 660 661 /** Function for handling connections from a client forwarded by the device 662 * mapper to the device manager. */ 663 static void devman_connection_devmapper(ipc_callid_t iid, ipc_call_t *icall) 664 { 665 devmap_handle_t devmap_handle = IPC_GET_ARG2(*icall); 1146 1147 cleanup: 1148 if (dev != NULL) 1149 dev_del_ref(dev); 1150 if (fun != NULL) 1151 fun_del_ref(fun); 1152 } 1153 1154 /** Function for handling connections from a client forwarded by the location 1155 * service to the device manager. */ 1156 static void devman_connection_loc(ipc_callid_t iid, ipc_call_t *icall) 1157 { 1158 service_id_t service_id = IPC_GET_ARG2(*icall); 666 1159 fun_node_t *fun; 667 1160 dev_node_t *dev; 668 669 fun = find_devmap_tree_function(&device_tree, devmap_handle); 670 if (fun == NULL) 671 fun = find_devmap_class_function(&class_list, devmap_handle); 672 673 if (fun == NULL || fun->dev->drv == NULL) { 1161 devman_handle_t handle; 1162 driver_t *driver; 1163 1164 fun = find_loc_tree_function(&device_tree, service_id); 1165 1166 fibril_rwlock_read_lock(&device_tree.rwlock); 1167 1168 if (fun == NULL || fun->dev == NULL || fun->dev->drv == NULL) { 1169 log_msg(LVL_WARN, "devman_connection_loc(): function " 1170 "not found.\n"); 1171 fibril_rwlock_read_unlock(&device_tree.rwlock); 674 1172 async_answer_0(iid, ENOENT); 675 1173 return; … … 677 1175 678 1176 dev = fun->dev; 679 680 if ((dev->state != DEVICE_USABLE) || (!dev->drv->sess)) { 681 async_answer_0(iid, EINVAL); 682 return; 683 } 684 685 async_exch_t *exch = async_exchange_begin(dev->drv->sess); 686 async_forward_fast(iid, exch, DRIVER_CLIENT, fun->handle, 0, 1177 driver = dev->drv; 1178 handle = fun->handle; 1179 1180 fibril_rwlock_read_unlock(&device_tree.rwlock); 1181 1182 async_exch_t *exch = async_exchange_begin(driver->sess); 1183 async_forward_fast(iid, exch, DRIVER_CLIENT, handle, 0, 687 1184 IPC_FF_NONE); 688 1185 async_exchange_end(exch); 689 1186 690 1187 log_msg(LVL_DEBUG, 691 "Forwarding devmapper request for `%s' function to driver `%s'.", 692 fun->pathname, dev->drv->name); 1188 "Forwarding loc service request for `%s' function to driver `%s'.", 1189 fun->pathname, driver->name); 1190 1191 fun_del_ref(fun); 693 1192 } 694 1193 695 1194 /** Function for handling connections to device manager. */ 696 static void devman_connection(ipc_callid_t iid, ipc_call_t *icall )697 { 698 /* Select interface. */1195 static void devman_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg) 1196 { 1197 /* Select port. */ 699 1198 switch ((sysarg_t) (IPC_GET_ARG1(*icall))) { 700 1199 case DEVMAN_DRIVER: … … 708 1207 devman_forward(iid, icall, false); 709 1208 break; 710 case DEVMAN_CONNECT_FROM_ DEVMAP:711 /* Someone connected through devmapnode. */712 devman_connection_ devmapper(iid, icall);1209 case DEVMAN_CONNECT_FROM_LOC: 1210 /* Someone connected through loc node. */ 1211 devman_connection_loc(iid, icall); 713 1212 break; 714 1213 case DEVMAN_CONNECT_TO_PARENTS_DEVICE: … … 722 1221 } 723 1222 1223 static void *devman_client_data_create(void) 1224 { 1225 client_t *client; 1226 1227 client = calloc(1, sizeof(client_t)); 1228 if (client == NULL) 1229 return NULL; 1230 1231 fibril_mutex_initialize(&client->mutex); 1232 return client; 1233 } 1234 1235 static void devman_client_data_destroy(void *data) 1236 { 1237 free(data); 1238 } 1239 724 1240 /** Initialize device manager internal structures. */ 725 1241 static bool devman_init(void) … … 743 1259 } 744 1260 745 init_class_list(&class_list);746 747 1261 /* 748 * !!! devman_connection ... as the device manager is not a real devmap1262 * !!! devman_connection ... as the device manager is not a real loc 749 1263 * driver (it uses a completely different ipc protocol than an ordinary 750 * devmapdriver) forwarding a connection from client to the devman by751 * devmapperwould not work.1264 * loc driver) forwarding a connection from client to the devman by 1265 * location service would not work. 752 1266 */ 753 devmap_driver_register(NAME, devman_connection);1267 loc_server_register(NAME, devman_connection); 754 1268 755 1269 return true; … … 760 1274 printf(NAME ": HelenOS Device Manager\n"); 761 1275 762 if (log_init(NAME, LVL_ ERROR) != EOK) {1276 if (log_init(NAME, LVL_WARN) != EOK) { 763 1277 printf(NAME ": Error initializing logging subsystem.\n"); 764 1278 return -1; … … 770 1284 } 771 1285 772 /* Set a handler of incomming connections. */ 1286 /* Set handlers for incoming connections. */ 1287 async_set_client_data_constructor(devman_client_data_create); 1288 async_set_client_data_destructor(devman_client_data_destroy); 773 1289 async_set_client_connection(devman_connection); 774 1290
Note:
See TracChangeset
for help on using the changeset viewer.