Changeset 8b655705 in mainline for uspace/srv/devman/main.c
- Timestamp:
- 2011-04-15T19:38:07Z (13 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- 9dd730d1
- Parents:
- 6b9e85b (diff), b2fb47f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the(diff)
links above to see all the changes relative to each parent. - File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
uspace/srv/devman/main.c
r6b9e85b r8b655705 43 43 #include <stdio.h> 44 44 #include <errno.h> 45 #include <str_error.h> 45 46 #include <bool.h> 46 47 #include <fibril_synch.h> … … 51 52 #include <sys/stat.h> 52 53 #include <ctype.h> 54 #include <io/log.h> 53 55 #include <ipc/devman.h> 54 56 #include <ipc/driver.h> … … 71 73 driver_t *driver = NULL; 72 74 73 printf(NAME ": devman_driver_register \n");75 log_msg(LVL_DEBUG, "devman_driver_register"); 74 76 75 77 iid = async_get_call(&icall); 76 78 if (IPC_GET_IMETHOD(icall) != DEVMAN_DRIVER_REGISTER) { 77 ipc_answer_0(iid, EREFUSED);79 async_answer_0(iid, EREFUSED); 78 80 return NULL; 79 81 } … … 84 86 int rc = async_data_write_accept((void **) &drv_name, true, 0, 0, 0, 0); 85 87 if (rc != EOK) { 86 ipc_answer_0(iid, rc);88 async_answer_0(iid, rc); 87 89 return NULL; 88 90 } 89 91 90 printf(NAME ": the %s driver is trying to register by the service.\n",92 log_msg(LVL_DEBUG, "The `%s' driver is trying to register.", 91 93 drv_name); 92 94 93 95 /* Find driver structure. */ 94 96 driver = find_driver(&drivers_list, drv_name); 95 96 97 if (driver == NULL) { 97 printf(NAME ": no driver named %s was found.\n", drv_name);98 log_msg(LVL_ERROR, "No driver named `%s' was found.", drv_name); 98 99 free(drv_name); 99 100 drv_name = NULL; 100 ipc_answer_0(iid, ENOENT);101 async_answer_0(iid, ENOENT); 101 102 return NULL; 102 103 } … … 105 106 drv_name = NULL; 106 107 108 fibril_mutex_lock(&driver->driver_mutex); 109 110 if (driver->phone >= 0) { 111 /* We already have a connection to the driver. */ 112 log_msg(LVL_ERROR, "Driver '%s' already started.\n", 113 driver->name); 114 fibril_mutex_unlock(&driver->driver_mutex); 115 async_answer_0(iid, EEXISTS); 116 return NULL; 117 } 118 119 switch (driver->state) { 120 case DRIVER_NOT_STARTED: 121 /* Somebody started the driver manually. */ 122 log_msg(LVL_NOTE, "Driver '%s' started manually.\n", 123 driver->name); 124 driver->state = DRIVER_STARTING; 125 break; 126 case DRIVER_STARTING: 127 /* The expected case */ 128 break; 129 case DRIVER_RUNNING: 130 /* Should not happen since we do not have a connected phone */ 131 assert(false); 132 } 133 107 134 /* Create connection to the driver. */ 108 printf(NAME ": creating connection to the %s driver.\n", driver->name); 135 log_msg(LVL_DEBUG, "Creating connection to the `%s' driver.", 136 driver->name); 109 137 ipc_call_t call; 110 138 ipc_callid_t callid = async_get_call(&call); 111 139 if (IPC_GET_IMETHOD(call) != IPC_M_CONNECT_TO_ME) { 112 ipc_answer_0(callid, ENOTSUP); 113 ipc_answer_0(iid, ENOTSUP); 140 fibril_mutex_unlock(&driver->driver_mutex); 141 async_answer_0(callid, ENOTSUP); 142 async_answer_0(iid, ENOTSUP); 114 143 return NULL; 115 144 } 116 145 117 146 /* Remember driver's phone. */ 118 set_driver_phone(driver, IPC_GET_ARG5(call)); 119 120 printf(NAME ": the %s driver was successfully registered as running.\n", 147 driver->phone = IPC_GET_ARG5(call); 148 149 fibril_mutex_unlock(&driver->driver_mutex); 150 151 log_msg(LVL_NOTE, 152 "The `%s' driver was successfully registered as running.", 121 153 driver->name); 122 154 123 ipc_answer_0(callid, EOK);124 ipc_answer_0(iid, EOK);155 async_answer_0(callid, EOK); 156 async_answer_0(iid, EOK); 125 157 126 158 return driver; … … 142 174 callid = async_get_call(&call); 143 175 if (DEVMAN_ADD_MATCH_ID != IPC_GET_IMETHOD(call)) { 144 printf(NAME ": ERROR: devman_receive_match_id - invalid "145 " protocol.\n");146 ipc_answer_0(callid, EINVAL);176 log_msg(LVL_ERROR, 177 "Invalid protocol when trying to receive match id."); 178 async_answer_0(callid, EINVAL); 147 179 delete_match_id(match_id); 148 180 return EINVAL; … … 150 182 151 183 if (match_id == NULL) { 152 printf(NAME ": ERROR: devman_receive_match_id - failed to " 153 "allocate match id.\n"); 154 ipc_answer_0(callid, ENOMEM); 184 log_msg(LVL_ERROR, "Failed to allocate match id."); 185 async_answer_0(callid, ENOMEM); 155 186 return ENOMEM; 156 187 } 157 188 158 ipc_answer_0(callid, EOK);189 async_answer_0(callid, EOK); 159 190 160 191 match_id->score = IPC_GET_ARG1(call); … … 165 196 if (rc != EOK) { 166 197 delete_match_id(match_id); 167 printf(NAME ": devman_receive_match_id - failed to receive "168 "match id string.\n");198 log_msg(LVL_ERROR, "Failed to receive match id string: %s.", 199 str_error(rc)); 169 200 return rc; 170 201 } … … 172 203 list_append(&match_id->link, &match_ids->ids); 173 204 174 printf(NAME ": received match id '%s', score = %d \n",205 log_msg(LVL_DEBUG, "Received match id `%s', score %d.", 175 206 match_id->id, match_id->score); 176 207 return rc; … … 199 230 static int assign_driver_fibril(void *arg) 200 231 { 201 node_t *node = (node_t *) arg;202 assign_driver( node, &drivers_list, &device_tree);232 dev_node_t *dev_node = (dev_node_t *) arg; 233 assign_driver(dev_node, &drivers_list, &device_tree); 203 234 return EOK; 204 235 } 205 236 206 /** Handle child deviceregistration.237 /** Handle function registration. 207 238 * 208 239 * Child devices are registered by their parent's device driver. 209 240 */ 210 static void devman_add_child(ipc_callid_t callid, ipc_call_t *call) 211 { 212 devman_handle_t parent_handle = IPC_GET_ARG1(*call); 213 sysarg_t match_count = IPC_GET_ARG2(*call); 241 static void devman_add_function(ipc_callid_t callid, ipc_call_t *call) 242 { 243 fun_type_t ftype = (fun_type_t) IPC_GET_ARG1(*call); 244 devman_handle_t dev_handle = IPC_GET_ARG2(*call); 245 sysarg_t match_count = IPC_GET_ARG3(*call); 214 246 dev_tree_t *tree = &device_tree; 215 247 216 248 fibril_rwlock_write_lock(&tree->rwlock); 217 node_t *parent = find_dev_node_no_lock(&device_tree, parent_handle); 218 219 if (parent == NULL) { 249 250 dev_node_t *dev = NULL; 251 dev_node_t *pdev = find_dev_node_no_lock(&device_tree, dev_handle); 252 253 if (pdev == NULL) { 220 254 fibril_rwlock_write_unlock(&tree->rwlock); 221 ipc_answer_0(callid, ENOENT); 222 return; 223 } 224 225 char *dev_name = NULL; 226 int rc = async_data_write_accept((void **)&dev_name, true, 0, 0, 0, 0); 255 async_answer_0(callid, ENOENT); 256 return; 257 } 258 259 if (ftype != fun_inner && ftype != fun_exposed) { 260 /* Unknown function type */ 261 log_msg(LVL_ERROR, 262 "Unknown function type %d provided by driver.", 263 (int) ftype); 264 265 fibril_rwlock_write_unlock(&tree->rwlock); 266 async_answer_0(callid, EINVAL); 267 return; 268 } 269 270 char *fun_name = NULL; 271 int rc = async_data_write_accept((void **)&fun_name, true, 0, 0, 0, 0); 227 272 if (rc != EOK) { 228 273 fibril_rwlock_write_unlock(&tree->rwlock); 229 ipc_answer_0(callid, rc);230 return; 231 } 232 233 node_t *node = create_dev_node();234 if ( !insert_dev_node(&device_tree, node, dev_name, parent)) {274 async_answer_0(callid, rc); 275 return; 276 } 277 278 /* Check that function with same name is not there already. */ 279 if (find_fun_node_in_device(pdev, fun_name) != NULL) { 235 280 fibril_rwlock_write_unlock(&tree->rwlock); 236 delete_dev_node(node); 237 ipc_answer_0(callid, ENOMEM); 238 return; 281 async_answer_0(callid, EEXISTS); 282 printf(NAME ": Warning, driver tried to register `%s' twice.\n", 283 fun_name); 284 free(fun_name); 285 return; 286 } 287 288 fun_node_t *fun = create_fun_node(); 289 if (!insert_fun_node(&device_tree, fun, fun_name, pdev)) { 290 fibril_rwlock_write_unlock(&tree->rwlock); 291 delete_fun_node(fun); 292 async_answer_0(callid, ENOMEM); 293 return; 294 } 295 296 if (ftype == fun_inner) { 297 dev = create_dev_node(); 298 if (dev == NULL) { 299 fibril_rwlock_write_unlock(&tree->rwlock); 300 delete_fun_node(fun); 301 async_answer_0(callid, ENOMEM); 302 return; 303 } 304 305 insert_dev_node(tree, dev, fun); 239 306 } 240 307 241 308 fibril_rwlock_write_unlock(&tree->rwlock); 242 309 243 printf(NAME ": devman_add_child %s\n", node->pathname); 244 245 devman_receive_match_ids(match_count, &node->match_ids); 246 247 /* 248 * Try to find a suitable driver and assign it to the device. We do 249 * not want to block the current fibril that is used for processing 250 * incoming calls: we will launch a separate fibril to handle the 251 * driver assigning. That is because assign_driver can actually include 252 * task spawning which could take some time. 253 */ 254 fid_t assign_fibril = fibril_create(assign_driver_fibril, node); 255 if (assign_fibril == 0) { 310 log_msg(LVL_DEBUG, "devman_add_function(fun=\"%s\")", fun->pathname); 311 312 devman_receive_match_ids(match_count, &fun->match_ids); 313 314 if (ftype == fun_inner) { 315 assert(dev != NULL); 256 316 /* 257 * Fallback in case we are out of memory. 258 * Probably not needed as we will die soon anyway ;-). 317 * Try to find a suitable driver and assign it to the device. We do 318 * not want to block the current fibril that is used for processing 319 * incoming calls: we will launch a separate fibril to handle the 320 * driver assigning. That is because assign_driver can actually include 321 * task spawning which could take some time. 259 322 */ 260 (void) assign_driver_fibril(node); 323 fid_t assign_fibril = fibril_create(assign_driver_fibril, dev); 324 if (assign_fibril == 0) { 325 /* 326 * Fallback in case we are out of memory. 327 * Probably not needed as we will die soon anyway ;-). 328 */ 329 (void) assign_driver_fibril(fun); 330 } else { 331 fibril_add_ready(assign_fibril); 332 } 261 333 } else { 262 fibril_add_ready(assign_fibril);263 } 264 334 devmap_register_tree_function(fun, tree); 335 } 336 265 337 /* Return device handle to parent's driver. */ 266 ipc_answer_1(callid, EOK, node->handle);338 async_answer_1(callid, EOK, fun->handle); 267 339 } 268 340 … … 288 360 * mapper. 289 361 */ 290 class_add_devmap_ device(&class_list, cli);362 class_add_devmap_function(&class_list, cli); 291 363 292 364 free(devmap_pathname); 293 365 } 294 366 295 static void devman_add_ device_to_class(ipc_callid_t callid, ipc_call_t *call)367 static void devman_add_function_to_class(ipc_callid_t callid, ipc_call_t *call) 296 368 { 297 369 devman_handle_t handle = IPC_GET_ARG1(*call); … … 302 374 0, 0, 0, 0); 303 375 if (rc != EOK) { 304 ipc_answer_0(callid, rc);376 async_answer_0(callid, rc); 305 377 return; 306 378 } 307 379 308 node_t *dev = find_dev_node(&device_tree, handle);309 if ( dev== NULL) {310 ipc_answer_0(callid, ENOENT);380 fun_node_t *fun = find_fun_node(&device_tree, handle); 381 if (fun == NULL) { 382 async_answer_0(callid, ENOENT); 311 383 return; 312 384 } 313 385 314 386 dev_class_t *cl = get_dev_class(&class_list, class_name); 315 dev_class_info_t *class_info = add_ device_to_class(dev, cl, NULL);387 dev_class_info_t *class_info = add_function_to_class(fun, cl, NULL); 316 388 317 389 /* Register the device's class alias by devmapper. */ 318 390 devmap_register_class_dev(class_info); 319 391 320 printf(NAME ": device '%s' added to class '%s', class name '%s' was "321 "asigned to it\n", dev->pathname, class_name, class_info->dev_name);322 323 ipc_answer_0(callid, EOK);392 log_msg(LVL_NOTE, "Function `%s' added to class `%s' as `%s'.", 393 fun->pathname, class_name, class_info->dev_name); 394 395 async_answer_0(callid, EOK); 324 396 } 325 397 … … 334 406 335 407 initialize_running_driver(driver, &device_tree); 336 printf(NAME ": the %s driver was successfully initialized. \n",408 log_msg(LVL_DEBUG, "The `%s` driver was successfully initialized.", 337 409 driver->name); 338 410 return 0; … … 343 415 { 344 416 /* Accept the connection. */ 345 ipc_answer_0(iid, EOK);417 async_answer_0(iid, EOK); 346 418 347 419 driver_t *driver = devman_driver_register(); … … 356 428 fid_t fid = fibril_create(init_running_drv, driver); 357 429 if (fid == 0) { 358 printf(NAME ": Error creating fibril for the initialization of "359 " the newly registered running driver.\n");430 log_msg(LVL_ERROR, "Failed to create initialization fibril " \ 431 "for driver `%s'.", driver->name); 360 432 return; 361 433 } … … 372 444 cont = false; 373 445 continue; 374 case DEVMAN_ADD_ CHILD_DEVICE:375 devman_add_ child(callid, &call);446 case DEVMAN_ADD_FUNCTION: 447 devman_add_function(callid, &call); 376 448 break; 377 449 case DEVMAN_ADD_DEVICE_TO_CLASS: 378 devman_add_ device_to_class(callid, &call);450 devman_add_function_to_class(callid, &call); 379 451 break; 380 452 default: 381 ipc_answer_0(callid, EINVAL);453 async_answer_0(callid, EINVAL); 382 454 break; 383 455 } … … 387 459 /** Find handle for the device instance identified by the device's path in the 388 460 * device tree. */ 389 static void devman_ device_get_handle(ipc_callid_t iid, ipc_call_t *icall)461 static void devman_function_get_handle(ipc_callid_t iid, ipc_call_t *icall) 390 462 { 391 463 char *pathname; … … 393 465 int rc = async_data_write_accept((void **) &pathname, true, 0, 0, 0, 0); 394 466 if (rc != EOK) { 395 ipc_answer_0(iid, rc);396 return; 397 } 398 399 node_t * dev = find_dev_node_by_path(&device_tree, pathname);467 async_answer_0(iid, rc); 468 return; 469 } 470 471 fun_node_t *fun = find_fun_node_by_path(&device_tree, pathname); 400 472 401 473 free(pathname); 402 474 403 if (dev == NULL) { 404 ipc_answer_0(iid, ENOENT); 405 return; 406 } 407 408 ipc_answer_1(iid, EOK, dev->handle); 475 if (fun == NULL) { 476 async_answer_0(iid, ENOENT); 477 return; 478 } 479 480 async_answer_1(iid, EOK, fun->handle); 481 } 482 483 /** Find handle for the device instance identified by device class name. */ 484 static void devman_function_get_handle_by_class(ipc_callid_t iid, 485 ipc_call_t *icall) 486 { 487 char *classname; 488 char *devname; 489 490 int rc = async_data_write_accept((void **) &classname, true, 0, 0, 0, 0); 491 if (rc != EOK) { 492 async_answer_0(iid, rc); 493 return; 494 } 495 rc = async_data_write_accept((void **) &devname, true, 0, 0, 0, 0); 496 if (rc != EOK) { 497 free(classname); 498 async_answer_0(iid, rc); 499 return; 500 } 501 502 503 fun_node_t *fun = find_fun_node_by_class(&class_list, 504 classname, devname); 505 506 free(classname); 507 free(devname); 508 509 if (fun == NULL) { 510 async_answer_0(iid, ENOENT); 511 return; 512 } 513 514 async_answer_1(iid, EOK, fun->handle); 409 515 } 410 516 … … 414 520 { 415 521 /* Accept connection. */ 416 ipc_answer_0(iid, EOK);522 async_answer_0(iid, EOK); 417 523 418 524 bool cont = true; … … 426 532 continue; 427 533 case DEVMAN_DEVICE_GET_HANDLE: 428 devman_device_get_handle(callid, &call); 534 devman_function_get_handle(callid, &call); 535 break; 536 case DEVMAN_DEVICE_GET_HANDLE_BY_CLASS: 537 devman_function_get_handle_by_class(callid, &call); 429 538 break; 430 539 default: 431 ipc_answer_0(callid, ENOENT);540 async_answer_0(callid, ENOENT); 432 541 } 433 542 } … … 438 547 { 439 548 devman_handle_t handle = IPC_GET_ARG2(*icall); 440 441 node_t *dev = find_dev_node(&device_tree, handle); 549 devman_handle_t fwd_h; 550 fun_node_t *fun = NULL; 551 dev_node_t *dev = NULL; 552 553 fun = find_fun_node(&device_tree, handle); 554 if (fun == NULL) 555 dev = find_dev_node(&device_tree, handle); 556 else 557 dev = fun->dev; 558 559 /* 560 * For a valid function to connect to we need a device. The root 561 * function, for example, has no device and cannot be connected to. 562 * This means @c dev needs to be valid regardless whether we are 563 * connecting to a device or to a function. 564 */ 442 565 if (dev == NULL) { 443 printf(NAME ": devman_forward error - no device with handle %" PRIun 444 " was found.\n", handle); 445 ipc_answer_0(iid, ENOENT); 566 log_msg(LVL_ERROR, "IPC forwarding failed - no device or " 567 "function with handle %" PRIun " was found.", handle); 568 async_answer_0(iid, ENOENT); 569 return; 570 } 571 572 if (fun == NULL && !drv_to_parent) { 573 log_msg(LVL_ERROR, NAME ": devman_forward error - cannot " 574 "connect to handle %" PRIun ", refers to a device.", 575 handle); 576 async_answer_0(iid, ENOENT); 446 577 return; 447 578 } … … 450 581 451 582 if (drv_to_parent) { 452 if (dev->parent != NULL) 453 driver = dev->parent->drv; 583 /* Connect to parent function of a device (or device function). */ 584 if (dev->pfun->dev != NULL) 585 driver = dev->pfun->dev->drv; 586 fwd_h = dev->pfun->handle; 454 587 } else if (dev->state == DEVICE_USABLE) { 588 /* Connect to the specified function */ 455 589 driver = dev->drv; 456 590 assert(driver != NULL); 591 592 fwd_h = handle; 457 593 } 458 594 459 595 if (driver == NULL) { 460 printf(NAME ": devman_forward error - the device is not in %" PRIun461 " usable state.\n", handle);462 ipc_answer_0(iid, ENOENT);596 log_msg(LVL_ERROR, "IPC forwarding refused - " \ 597 "the device %" PRIun " is not in usable state.", handle); 598 async_answer_0(iid, ENOENT); 463 599 return; 464 600 } … … 470 606 method = DRIVER_CLIENT; 471 607 472 if (driver->phone <= 0) { 473 printf(NAME ": devman_forward: cound not forward to driver %s ", 474 driver->name); 475 printf("the driver's phone is %" PRIun ").\n", driver->phone); 476 ipc_answer_0(iid, EINVAL); 477 return; 478 } 479 480 printf(NAME ": devman_forward: forward connection to device %s to " 481 "driver %s.\n", dev->pathname, driver->name); 482 ipc_forward_fast(iid, driver->phone, method, dev->handle, 0, IPC_FF_NONE); 608 if (driver->phone < 0) { 609 log_msg(LVL_ERROR, 610 "Could not forward to driver `%s' (phone is %d).", 611 driver->name, (int) driver->phone); 612 async_answer_0(iid, EINVAL); 613 return; 614 } 615 616 if (fun != NULL) { 617 log_msg(LVL_DEBUG, 618 "Forwarding request for `%s' function to driver `%s'.", 619 fun->pathname, driver->name); 620 } else { 621 log_msg(LVL_DEBUG, 622 "Forwarding request for `%s' device to driver `%s'.", 623 dev->pfun->pathname, driver->name); 624 } 625 626 async_forward_fast(iid, driver->phone, method, fwd_h, 0, IPC_FF_NONE); 483 627 } 484 628 … … 488 632 { 489 633 devmap_handle_t devmap_handle = IPC_GET_ARG2(*icall); 490 node_t *dev; 491 492 dev = find_devmap_tree_device(&device_tree, devmap_handle); 493 if (dev == NULL) 494 dev = find_devmap_class_device(&class_list, devmap_handle); 495 496 if (dev == NULL || dev->drv == NULL) { 497 ipc_answer_0(iid, ENOENT); 498 return; 499 } 500 501 if (dev->state != DEVICE_USABLE || dev->drv->phone <= 0) { 502 ipc_answer_0(iid, EINVAL); 503 return; 504 } 505 506 ipc_forward_fast(iid, dev->drv->phone, DRIVER_CLIENT, dev->handle, 0, 634 fun_node_t *fun; 635 dev_node_t *dev; 636 637 fun = find_devmap_tree_function(&device_tree, devmap_handle); 638 if (fun == NULL) 639 fun = find_devmap_class_function(&class_list, devmap_handle); 640 641 if (fun == NULL || fun->dev->drv == NULL) { 642 async_answer_0(iid, ENOENT); 643 return; 644 } 645 646 dev = fun->dev; 647 648 if (dev->state != DEVICE_USABLE || dev->drv->phone < 0) { 649 async_answer_0(iid, EINVAL); 650 return; 651 } 652 653 async_forward_fast(iid, dev->drv->phone, DRIVER_CLIENT, fun->handle, 0, 507 654 IPC_FF_NONE); 508 printf(NAME ": devman_connection_devmapper: forwarded connection to " 509 "device %s to driver %s.\n", dev->pathname, dev->drv->name); 655 log_msg(LVL_DEBUG, 656 "Forwarding devmapper request for `%s' function to driver `%s'.", 657 fun->pathname, dev->drv->name); 510 658 } 511 659 … … 535 683 default: 536 684 /* No such interface */ 537 ipc_answer_0(iid, ENOENT);685 async_answer_0(iid, ENOENT); 538 686 } 539 687 } … … 542 690 static bool devman_init(void) 543 691 { 544 printf(NAME ": devman_init - looking for available drivers.\n");692 log_msg(LVL_DEBUG, "devman_init - looking for available drivers."); 545 693 546 694 /* Initialize list of available drivers. */ … … 548 696 if (lookup_available_drivers(&drivers_list, 549 697 DRIVER_DEFAULT_STORE) == 0) { 550 printf(NAME " no drivers found.");698 log_msg(LVL_FATAL, "No drivers found."); 551 699 return false; 552 700 } 553 701 554 printf(NAME ": devman_init - list of drivers has been initialized.\n");702 log_msg(LVL_DEBUG, "devman_init - list of drivers has been initialized."); 555 703 556 704 /* Create root device node. */ 557 705 if (!init_device_tree(&device_tree, &drivers_list)) { 558 printf(NAME " failed to initialize device tree.");706 log_msg(LVL_FATAL, "Failed to initialize device tree."); 559 707 return false; 560 708 } … … 577 725 printf(NAME ": HelenOS Device Manager\n"); 578 726 727 if (log_init(NAME, LVL_ERROR) != EOK) { 728 printf(NAME ": Error initializing logging subsystem.\n"); 729 return -1; 730 } 731 579 732 if (!devman_init()) { 580 printf(NAME ": Error while initializing service\n");733 log_msg(LVL_ERROR, "Error while initializing service."); 581 734 return -1; 582 735 } … … 586 739 587 740 /* Register device manager at naming service. */ 588 sysarg_t phonead;589 if (ipc_connect_to_me(PHONE_NS, SERVICE_DEVMAN, 0, 0, &phonead) != 0)741 if (service_register(SERVICE_DEVMAN) != EOK) { 742 log_msg(LVL_ERROR, "Failed registering as a service."); 590 743 return -1; 591 592 printf(NAME ": Accepting connections\n"); 744 } 745 746 printf(NAME ": Accepting connections.\n"); 593 747 async_manager(); 594 748
Note:
See TracChangeset
for help on using the changeset viewer.