Changes in uspace/srv/fs/locfs/locfs_ops.c [a35b458:1b20da0] in mainline
- File:
-
- 1 edited
-
uspace/srv/fs/locfs/locfs_ops.c (modified) (42 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/srv/fs/locfs/locfs_ops.c
ra35b458 r1b20da0 109 109 return ENOMEM; 110 110 } 111 111 112 112 *rfn = (fs_node_t *) malloc(sizeof(fs_node_t)); 113 113 if (*rfn == NULL) { … … 116 116 return ENOMEM; 117 117 } 118 118 119 119 fs_node_initialize(*rfn); 120 120 node->type = type; 121 121 node->service_id = service_id; 122 122 123 123 (*rfn)->data = node; 124 124 return EOK; … … 134 134 locfs_node_t *node = (locfs_node_t *) pfn->data; 135 135 errno_t ret; 136 136 137 137 if (node->service_id == 0) { 138 138 /* Root directory */ 139 139 140 140 loc_sdesc_t *nspaces; 141 141 size_t count = loc_get_namespaces(&nspaces); 142 142 143 143 if (count > 0) { 144 144 size_t pos; … … 147 147 if (str_cmp(nspaces[pos].name, "") == 0) 148 148 continue; 149 149 150 150 if (str_cmp(nspaces[pos].name, component) == 0) { 151 151 ret = locfs_node_get_internal(rfn, LOC_OBJECT_NAMESPACE, nspaces[pos].id); … … 154 154 } 155 155 } 156 156 157 157 free(nspaces); 158 158 } 159 159 160 160 /* Search root namespace */ 161 161 service_id_t namespace; … … 163 163 if (loc_namespace_get_id("", &namespace, 0) == EOK) { 164 164 count = loc_get_services(namespace, &svcs); 165 165 166 166 if (count > 0) { 167 167 size_t pos; … … 173 173 } 174 174 } 175 175 176 176 free(svcs); 177 177 } 178 178 } 179 179 180 180 *rfn = NULL; 181 181 return EOK; 182 182 } 183 183 184 184 if (node->type == LOC_OBJECT_NAMESPACE) { 185 185 /* Namespace directory */ 186 186 187 187 loc_sdesc_t *svcs; 188 188 size_t count = loc_get_services(node->service_id, &svcs); … … 196 196 } 197 197 } 198 198 199 199 free(svcs); 200 200 } 201 201 202 202 *rfn = NULL; 203 203 return EOK; 204 204 } 205 205 206 206 *rfn = NULL; 207 207 return EOK; … … 216 216 { 217 217 locfs_node_t *node = (locfs_node_t *) fn->data; 218 218 219 219 if (node->service_id == 0) { 220 220 /* Root directory */ 221 221 return EOK; 222 222 } 223 223 224 224 loc_object_type_t type = loc_id_probe(node->service_id); 225 225 226 226 if (type == LOC_OBJECT_NAMESPACE) { 227 227 /* Namespace directory */ 228 228 return EOK; 229 229 } 230 230 231 231 if (type == LOC_OBJECT_SERVICE) { 232 232 /* Device node */ 233 233 234 234 fibril_mutex_lock(&services_mutex); 235 235 ht_link_t *lnk; … … 242 242 return ENOMEM; 243 243 } 244 244 245 245 dev->service_id = node->service_id; 246 246 247 247 /* Mark as incomplete */ 248 248 dev->sess = NULL; 249 249 dev->refcount = 1; 250 250 fibril_condvar_initialize(&dev->cv); 251 251 252 252 /* 253 253 * Insert the incomplete device structure so that other … … 256 256 */ 257 257 hash_table_insert(&services, &dev->link); 258 258 259 259 /* 260 260 * Drop the mutex to allow recursive locfs requests. 261 261 */ 262 262 fibril_mutex_unlock(&services_mutex); 263 263 264 264 async_sess_t *sess = loc_service_connect(node->service_id, 265 265 INTERFACE_FS, 0); 266 266 267 267 fibril_mutex_lock(&services_mutex); 268 268 269 269 /* 270 270 * Notify possible waiters about this device structure … … 272 272 */ 273 273 fibril_condvar_broadcast(&dev->cv); 274 274 275 275 if (!sess) { 276 276 /* … … 280 280 hash_table_remove(&services, &node->service_id); 281 281 fibril_mutex_unlock(&services_mutex); 282 282 283 283 return ENOENT; 284 284 } 285 285 286 286 /* Set the correct session. */ 287 287 dev->sess = sess; 288 288 } else { 289 289 service_t *dev = hash_table_get_inst(lnk, service_t, link); 290 290 291 291 if (!dev->sess) { 292 292 /* … … 303 303 dev->refcount++; 304 304 } 305 305 306 306 fibril_mutex_unlock(&services_mutex); 307 308 return EOK; 309 } 310 307 308 return EOK; 309 } 310 311 311 return ENOENT; 312 312 } … … 322 322 { 323 323 assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY)); 324 324 325 325 *rfn = NULL; 326 326 return ENOTSUP; … … 345 345 { 346 346 locfs_node_t *node = (locfs_node_t *) fn->data; 347 347 348 348 if (node->service_id == 0) { 349 349 size_t count = loc_count_namespaces(); … … 352 352 return EOK; 353 353 } 354 354 355 355 /* Root namespace */ 356 356 service_id_t namespace; … … 362 362 } 363 363 } 364 364 365 365 *has_children = false; 366 366 return EOK; 367 367 } 368 368 369 369 if (node->type == LOC_OBJECT_NAMESPACE) { 370 370 size_t count = loc_count_services(node->service_id); … … 373 373 return EOK; 374 374 } 375 375 376 376 *has_children = false; 377 377 return EOK; 378 378 } 379 379 380 380 *has_children = false; 381 381 return EOK; … … 396 396 { 397 397 locfs_node_t *node = (locfs_node_t *) fn->data; 398 398 399 399 if (node->service_id == 0) 400 400 return 0; 401 401 402 402 return 1; 403 403 } … … 406 406 { 407 407 locfs_node_t *node = (locfs_node_t *) fn->data; 408 408 409 409 return ((node->type == LOC_OBJECT_NONE) || (node->type == LOC_OBJECT_NAMESPACE)); 410 410 } … … 413 413 { 414 414 locfs_node_t *node = (locfs_node_t *) fn->data; 415 415 416 416 return (node->type == LOC_OBJECT_SERVICE); 417 417 } … … 420 420 { 421 421 locfs_node_t *node = (locfs_node_t *) fn->data; 422 422 423 423 if (node->type == LOC_OBJECT_SERVICE) 424 424 return node->service_id; 425 425 426 426 return 0; 427 427 } … … 451 451 if (!hash_table_create(&services, 0, 0, &services_ops)) 452 452 return false; 453 453 454 454 return true; 455 455 } … … 484 484 return EINVAL; 485 485 } 486 486 487 487 loc_sdesc_t *desc; 488 488 size_t count = loc_get_namespaces(&desc); 489 489 490 490 /* Get rid of root namespace */ 491 491 size_t i; … … 494 494 if (pos >= i) 495 495 pos++; 496 496 497 497 break; 498 498 } 499 499 } 500 500 501 501 if (pos < count) { 502 502 async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1); … … 505 505 return EOK; 506 506 } 507 507 508 508 free(desc); 509 509 pos -= count; 510 510 511 511 /* Search root namespace */ 512 512 service_id_t namespace; 513 513 if (loc_namespace_get_id("", &namespace, 0) == EOK) { 514 514 count = loc_get_services(namespace, &desc); 515 515 516 516 if (pos < count) { 517 517 async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1); … … 520 520 return EOK; 521 521 } 522 522 523 523 free(desc); 524 524 } 525 525 526 526 async_answer_0(callid, ENOENT); 527 527 return ENOENT; 528 528 } 529 529 530 530 loc_object_type_t type = loc_id_probe(index); 531 531 532 532 if (type == LOC_OBJECT_NAMESPACE) { 533 533 /* Namespace directory */ … … 538 538 return EINVAL; 539 539 } 540 540 541 541 loc_sdesc_t *desc; 542 542 size_t count = loc_get_services(index, &desc); 543 543 544 544 if (pos < count) { 545 545 async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1); … … 548 548 return EOK; 549 549 } 550 550 551 551 free(desc); 552 552 async_answer_0(callid, ENOENT); 553 553 return ENOENT; 554 554 } 555 555 556 556 if (type == LOC_OBJECT_SERVICE) { 557 557 /* Device node */ 558 558 559 559 fibril_mutex_lock(&services_mutex); 560 560 service_id_t service_index = index; … … 564 564 return ENOENT; 565 565 } 566 566 567 567 service_t *dev = hash_table_get_inst(lnk, service_t, link); 568 568 assert(dev->sess); 569 569 570 570 ipc_callid_t callid; 571 571 if (!async_data_read_receive(&callid, NULL)) { … … 574 574 return EINVAL; 575 575 } 576 576 577 577 /* Make a request at the driver */ 578 578 async_exch_t *exch = async_exchange_begin(dev->sess); 579 579 580 580 ipc_call_t answer; 581 581 aid_t msg = async_send_4(exch, VFS_OUT_READ, service_id, 582 582 index, LOWER32(pos), UPPER32(pos), &answer); 583 583 584 584 /* Forward the IPC_M_DATA_READ request to the driver */ 585 585 async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME); 586 586 587 587 async_exchange_end(exch); 588 588 589 589 fibril_mutex_unlock(&services_mutex); 590 590 591 591 /* Wait for reply from the driver. */ 592 592 errno_t rc; … … 596 596 if ((errno_t) rc == EHANGUP) 597 597 rc = ENOTSUP; 598 598 599 599 *rbytes = IPC_GET_ARG1(answer); 600 600 return rc; 601 601 } 602 602 603 603 return ENOENT; 604 604 } … … 610 610 if (index == 0) 611 611 return ENOTSUP; 612 612 613 613 loc_object_type_t type = loc_id_probe(index); 614 614 615 615 if (type == LOC_OBJECT_NAMESPACE) { 616 616 /* Namespace directory */ 617 617 return ENOTSUP; 618 618 } 619 619 620 620 if (type == LOC_OBJECT_SERVICE) { 621 621 /* Device node */ 622 622 623 623 fibril_mutex_lock(&services_mutex); 624 624 service_id_t service_index = index; … … 628 628 return ENOENT; 629 629 } 630 630 631 631 service_t *dev = hash_table_get_inst(lnk, service_t, link); 632 632 assert(dev->sess); 633 633 634 634 ipc_callid_t callid; 635 635 if (!async_data_write_receive(&callid, NULL)) { … … 638 638 return EINVAL; 639 639 } 640 640 641 641 /* Make a request at the driver */ 642 642 async_exch_t *exch = async_exchange_begin(dev->sess); 643 643 644 644 ipc_call_t answer; 645 645 aid_t msg = async_send_4(exch, VFS_OUT_WRITE, service_id, 646 646 index, LOWER32(pos), UPPER32(pos), &answer); 647 647 648 648 /* Forward the IPC_M_DATA_WRITE request to the driver */ 649 649 async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME); 650 650 651 651 async_exchange_end(exch); 652 652 653 653 fibril_mutex_unlock(&services_mutex); 654 654 655 655 /* Wait for reply from the driver. */ 656 656 errno_t rc; … … 660 660 if ((errno_t) rc == EHANGUP) 661 661 rc = ENOTSUP; 662 662 663 663 *wbytes = IPC_GET_ARG1(answer); 664 664 *nsize = 0; 665 665 return rc; 666 666 } 667 667 668 668 return ENOENT; 669 669 } … … 679 679 if (index == 0) 680 680 return EOK; 681 681 682 682 loc_object_type_t type = loc_id_probe(index); 683 683 684 684 if (type == LOC_OBJECT_NAMESPACE) { 685 685 /* Namespace directory */ 686 686 return EOK; 687 687 } 688 688 689 689 if (type == LOC_OBJECT_SERVICE) { 690 690 691 691 fibril_mutex_lock(&services_mutex); 692 692 service_id_t service_index = index; … … 696 696 return ENOENT; 697 697 } 698 698 699 699 service_t *dev = hash_table_get_inst(lnk, service_t, link); 700 700 assert(dev->sess); 701 701 dev->refcount--; 702 702 703 703 if (dev->refcount == 0) { 704 704 async_hangup(dev->sess); … … 706 706 hash_table_remove(&services, &service_index); 707 707 } 708 708 709 709 fibril_mutex_unlock(&services_mutex); 710 711 return EOK; 712 } 713 710 711 return EOK; 712 } 713 714 714 return ENOENT; 715 715 } … … 719 719 if (index == 0) 720 720 return EOK; 721 721 722 722 loc_object_type_t type = loc_id_probe(index); 723 723 724 724 if (type == LOC_OBJECT_NAMESPACE) { 725 725 /* Namespace directory */ 726 726 return EOK; 727 727 } 728 728 729 729 if (type == LOC_OBJECT_SERVICE) { 730 730 … … 736 736 return ENOENT; 737 737 } 738 738 739 739 service_t *dev = hash_table_get_inst(lnk, service_t, link); 740 740 assert(dev->sess); 741 741 742 742 /* Make a request at the driver */ 743 743 async_exch_t *exch = async_exchange_begin(dev->sess); 744 744 745 745 ipc_call_t answer; 746 746 aid_t msg = async_send_2(exch, VFS_OUT_SYNC, service_id, 747 747 index, &answer); 748 748 749 749 async_exchange_end(exch); 750 750 751 751 fibril_mutex_unlock(&services_mutex); 752 752 753 753 /* Wait for reply from the driver */ 754 754 errno_t rc; 755 755 async_wait_for(msg, &rc); 756 756 757 757 return rc; 758 758 } 759 759 760 760 return ENOENT; 761 761 }
Note:
See TracChangeset
for help on using the changeset viewer.
