Changeset 1dff985 in mainline for uspace/lib/fs/libfs.c
- Timestamp:
- 2017-03-03T21:32:38Z (8 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- c577a9a
- Parents:
- 5b46ec8 (diff), b8dbe2f (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
-
uspace/lib/fs/libfs.c (modified) (12 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/fs/libfs.c
r5b46ec8 r1dff985 36 36 37 37 #include "libfs.h" 38 #include "../../srv/vfs/vfs.h"39 38 #include <macros.h> 40 39 #include <errno.h> … … 47 46 #include <sys/statfs.h> 48 47 #include <stdlib.h> 48 #include <fibril_synch.h> 49 49 50 50 #define on_error(rc, action) \ … … 63 63 } while (0) 64 64 65 #define DPRINTF(...) 66 67 #define LOG_EXIT(rc) \ 68 DPRINTF("Exiting %s() with rc = %d at line %d\n", __FUNC__, rc, __LINE__); 69 65 70 static fs_reg_t reg; 66 71 … … 68 73 static libfs_ops_t *libfs_ops = NULL; 69 74 70 static void libfs_ mount(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *);71 static void libfs_unmount(libfs_ops_t *, ipc_callid_t,ipc_call_t *);75 static void libfs_link(libfs_ops_t *, fs_handle_t, ipc_callid_t, 76 ipc_call_t *); 72 77 static void libfs_lookup(libfs_ops_t *, fs_handle_t, ipc_callid_t, 73 78 ipc_call_t *); … … 104 109 } 105 110 106 static void vfs_out_mount(ipc_callid_t rid, ipc_call_t *req)107 {108 libfs_mount(libfs_ops, reg.fs_handle, rid, req);109 }110 111 111 static void vfs_out_unmounted(ipc_callid_t rid, ipc_call_t *req) 112 112 { … … 119 119 } 120 120 121 static void vfs_out_unmount(ipc_callid_t rid, ipc_call_t *req) 122 { 123 124 libfs_unmount(libfs_ops, rid, req); 121 static void vfs_out_link(ipc_callid_t rid, ipc_call_t *req) 122 { 123 libfs_link(libfs_ops, reg.fs_handle, rid, req); 125 124 } 126 125 … … 193 192 service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req); 194 193 fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req); 194 195 195 int rc; 196 197 rc = vfs_out_ops->destroy(service_id, index); 198 196 fs_node_t *node = NULL; 197 rc = libfs_ops->node_get(&node, service_id, index); 198 if (rc == EOK && node != NULL) { 199 bool destroy = (libfs_ops->lnkcnt_get(node) == 0); 200 libfs_ops->node_put(node); 201 if (destroy) { 202 rc = vfs_out_ops->destroy(service_id, index); 203 } 204 } 199 205 async_answer_0(rid, rc); 200 206 } … … 225 231 libfs_statfs(libfs_ops, reg.fs_handle, rid, req); 226 232 } 233 234 static void vfs_out_get_size(ipc_callid_t rid, ipc_call_t *req) 235 { 236 service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req); 237 fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req); 238 int rc; 239 240 fs_node_t *node = NULL; 241 rc = libfs_ops->node_get(&node, service_id, index); 242 if (rc != EOK) { 243 async_answer_0(rid, rc); 244 } 245 if (node == NULL) { 246 async_answer_0(rid, EINVAL); 247 } 248 249 uint64_t size = libfs_ops->size_get(node); 250 libfs_ops->node_put(node); 251 252 async_answer_2(rid, EOK, LOWER32(size), UPPER32(size)); 253 } 254 255 static void vfs_out_is_empty(ipc_callid_t rid, ipc_call_t *req) 256 { 257 service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req); 258 fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req); 259 int rc; 260 261 fs_node_t *node = NULL; 262 rc = libfs_ops->node_get(&node, service_id, index); 263 if (rc != EOK) { 264 async_answer_0(rid, rc); 265 } 266 if (node == NULL) { 267 async_answer_0(rid, EINVAL); 268 } 269 270 bool children = false; 271 rc = libfs_ops->has_children(&children, node); 272 libfs_ops->node_put(node); 273 274 if (rc != EOK) { 275 async_answer_0(rid, rc); 276 } 277 async_answer_0(rid, children ? ENOTEMPTY : EOK); 278 } 279 227 280 static void vfs_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg) 228 281 { … … 247 300 vfs_out_mounted(callid, &call); 248 301 break; 249 case VFS_OUT_MOUNT:250 vfs_out_mount(callid, &call);251 break;252 302 case VFS_OUT_UNMOUNTED: 253 303 vfs_out_unmounted(callid, &call); 254 304 break; 255 case VFS_OUT_ UNMOUNT:256 vfs_out_ unmount(callid, &call);305 case VFS_OUT_LINK: 306 vfs_out_link(callid, &call); 257 307 break; 258 308 case VFS_OUT_LOOKUP: … … 285 335 case VFS_OUT_STATFS: 286 336 vfs_out_statfs(callid, &call); 337 break; 338 case VFS_OUT_GET_SIZE: 339 vfs_out_get_size(callid, &call); 340 break; 341 case VFS_OUT_IS_EMPTY: 342 vfs_out_is_empty(callid, &call); 287 343 break; 288 344 default: … … 383 439 } 384 440 385 void libfs_mount(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid, 386 ipc_call_t *req) 387 { 388 service_id_t mp_service_id = (service_id_t) IPC_GET_ARG1(*req); 389 fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*req); 390 fs_handle_t mr_fs_handle = (fs_handle_t) IPC_GET_ARG3(*req); 391 service_id_t mr_service_id = (service_id_t) IPC_GET_ARG4(*req); 392 393 async_sess_t *mountee_sess = async_clone_receive(EXCHANGE_PARALLEL); 394 if (mountee_sess == NULL) { 395 async_answer_0(rid, EINVAL); 441 static char plb_get_char(unsigned pos) 442 { 443 return reg.plb_ro[pos % PLB_SIZE]; 444 } 445 446 static int plb_get_component(char *dest, unsigned *sz, unsigned *ppos, unsigned last) 447 { 448 unsigned pos = *ppos; 449 unsigned size = 0; 450 451 if (pos == last) { 452 *sz = 0; 453 return ERANGE; 454 } 455 456 char c = plb_get_char(pos); 457 if (c == '/') { 458 pos++; 459 } 460 461 for (int i = 0; i <= NAME_MAX; i++) { 462 c = plb_get_char(pos); 463 if (pos == last || c == '/') { 464 dest[i] = 0; 465 *ppos = pos; 466 *sz = size; 467 return EOK; 468 } 469 dest[i] = c; 470 pos++; 471 size++; 472 } 473 return ENAMETOOLONG; 474 } 475 476 static int receive_fname(char *buffer) 477 { 478 size_t size; 479 ipc_callid_t wcall; 480 481 if (!async_data_write_receive(&wcall, &size)) { 482 return ENOENT; 483 } 484 if (size > NAME_MAX + 1) { 485 async_answer_0(wcall, ERANGE); 486 return ERANGE; 487 } 488 return async_data_write_finalize(wcall, buffer, size); 489 } 490 491 /** Link a file at a path. 492 */ 493 void libfs_link(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid, ipc_call_t *req) 494 { 495 service_id_t parent_sid = IPC_GET_ARG1(*req); 496 fs_index_t parent_index = IPC_GET_ARG2(*req); 497 fs_index_t child_index = IPC_GET_ARG3(*req); 498 499 char component[NAME_MAX + 1]; 500 int rc = receive_fname(component); 501 if (rc != EOK) { 502 async_answer_0(rid, rc); 396 503 return; 397 504 } 398 399 fs_node_t *fn; 400 int res = ops->node_get(&fn, mp_service_id, mp_fs_index); 401 if ((res != EOK) || (!fn)) { 402 async_hangup(mountee_sess); 403 async_data_write_void(combine_rc(res, ENOENT)); 404 async_answer_0(rid, combine_rc(res, ENOENT)); 505 506 fs_node_t *parent = NULL; 507 rc = ops->node_get(&parent, parent_sid, parent_index); 508 if (parent == NULL) { 509 async_answer_0(rid, rc == EOK ? EBADF : rc); 405 510 return; 406 511 } 407 512 408 if (fn->mp_data.mp_active) {409 async_hangup(mountee_sess);410 (void) ops->node_put(fn);411 async_ data_write_void(EBUSY);412 async_answer_0(rid, EBUSY);513 fs_node_t *child = NULL; 514 rc = ops->node_get(&child, parent_sid, child_index); 515 if (child == NULL) { 516 async_answer_0(rid, rc == EOK ? EBADF : rc); 517 ops->node_put(parent); 413 518 return; 414 519 } 415 520 416 async_exch_t *exch = async_exchange_begin(mountee_sess); 417 async_sess_t *sess = async_clone_establish(EXCHANGE_PARALLEL, exch); 418 419 if (!sess) { 420 async_exchange_end(exch); 421 async_hangup(mountee_sess); 422 (void) ops->node_put(fn); 423 async_data_write_void(errno); 424 async_answer_0(rid, errno); 425 return; 426 } 427 428 ipc_call_t answer; 429 int rc = async_data_write_forward_1_1(exch, VFS_OUT_MOUNTED, 430 mr_service_id, &answer); 431 async_exchange_end(exch); 432 433 if (rc == EOK) { 434 fn->mp_data.mp_active = true; 435 fn->mp_data.fs_handle = mr_fs_handle; 436 fn->mp_data.service_id = mr_service_id; 437 fn->mp_data.sess = mountee_sess; 438 } 439 440 /* 441 * Do not release the FS node so that it stays in memory. 442 */ 443 async_answer_4(rid, rc, IPC_GET_ARG1(answer), IPC_GET_ARG2(answer), 444 IPC_GET_ARG3(answer), IPC_GET_ARG4(answer)); 445 } 446 447 void libfs_unmount(libfs_ops_t *ops, ipc_callid_t rid, ipc_call_t *req) 448 { 449 service_id_t mp_service_id = (service_id_t) IPC_GET_ARG1(*req); 450 fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*req); 451 fs_node_t *fn; 452 int res; 453 454 res = ops->node_get(&fn, mp_service_id, mp_fs_index); 455 if ((res != EOK) || (!fn)) { 456 async_answer_0(rid, combine_rc(res, ENOENT)); 457 return; 458 } 459 460 /* 461 * We are clearly expecting to find the mount point active. 462 */ 463 if (!fn->mp_data.mp_active) { 464 (void) ops->node_put(fn); 465 async_answer_0(rid, EINVAL); 466 return; 467 } 468 469 /* 470 * Tell the mounted file system to unmount. 471 */ 472 async_exch_t *exch = async_exchange_begin(fn->mp_data.sess); 473 res = async_req_1_0(exch, VFS_OUT_UNMOUNTED, fn->mp_data.service_id); 474 async_exchange_end(exch); 475 476 /* 477 * If everything went well, perform the clean-up on our side. 478 */ 479 if (res == EOK) { 480 async_hangup(fn->mp_data.sess); 481 fn->mp_data.mp_active = false; 482 fn->mp_data.fs_handle = 0; 483 fn->mp_data.service_id = 0; 484 fn->mp_data.sess = NULL; 485 486 /* Drop the reference created in libfs_mount(). */ 487 (void) ops->node_put(fn); 488 } 489 490 (void) ops->node_put(fn); 491 async_answer_0(rid, res); 492 } 493 494 static char plb_get_char(unsigned pos) 495 { 496 return reg.plb_ro[pos % PLB_SIZE]; 521 rc = ops->link(parent, child, component); 522 ops->node_put(parent); 523 ops->node_put(child); 524 async_answer_0(rid, rc); 497 525 } 498 526 … … 513 541 ipc_call_t *req) 514 542 { 515 unsigned int first = IPC_GET_ARG1(*req); 516 unsigned int last = IPC_GET_ARG2(*req); 517 unsigned int next = first; 543 unsigned first = IPC_GET_ARG1(*req); 544 unsigned len = IPC_GET_ARG2(*req); 518 545 service_id_t service_id = IPC_GET_ARG3(*req); 519 int lflag = IPC_GET_ARG4(*req); 520 fs_index_t index = IPC_GET_ARG5(*req); 546 fs_index_t index = IPC_GET_ARG4(*req); 547 int lflag = IPC_GET_ARG5(*req); 548 549 assert((int) index != -1); 550 551 DPRINTF("Entered libfs_lookup()\n"); 552 553 // TODO: Validate flags. 554 555 unsigned next = first; 556 unsigned last = first + len; 557 521 558 char component[NAME_MAX + 1]; 522 int len;523 559 int rc; 524 525 if (last < next)526 last += PLB_SIZE;527 560 528 561 fs_node_t *par = NULL; 529 562 fs_node_t *cur = NULL; 530 563 fs_node_t *tmp = NULL; 531 532 rc = ops->root_get(&cur, service_id); 533 on_error(rc, goto out_with_answer); 534 535 if (cur->mp_data.mp_active) { 536 async_exch_t *exch = async_exchange_begin(cur->mp_data.sess); 537 async_forward_slow(rid, exch, VFS_OUT_LOOKUP, next, last, 538 cur->mp_data.service_id, lflag, index, 539 IPC_FF_ROUTE_FROM_ME); 540 async_exchange_end(exch); 564 unsigned clen = 0; 565 566 rc = ops->node_get(&cur, service_id, index); 567 if (rc != EOK) { 568 async_answer_0(rid, rc); 569 LOG_EXIT(rc); 570 goto out; 571 } 572 573 assert(cur != NULL); 574 575 /* Find the file and its parent. */ 576 577 unsigned last_next = 0; 578 579 while (next != last) { 580 if (cur == NULL) { 581 assert(par != NULL); 582 goto out1; 583 } 584 585 if (!ops->is_directory(cur)) { 586 async_answer_0(rid, ENOTDIR); 587 LOG_EXIT(ENOTDIR); 588 goto out; 589 } 541 590 542 (void) ops->node_put(cur); 543 return; 544 } 545 546 /* Eat slash */ 547 if (plb_get_char(next) == '/') 548 next++; 549 550 while (next <= last) { 551 bool has_children; 591 last_next = next; 592 /* Collect the component */ 593 rc = plb_get_component(component, &clen, &next, last); 594 assert(rc != ERANGE); 595 if (rc != EOK) { 596 async_answer_0(rid, rc); 597 LOG_EXIT(rc); 598 goto out; 599 } 552 600 553 rc = ops->has_children(&has_children, cur);554 on_error(rc, goto out_with_answer);555 if (!has_children)556 break;601 if (clen == 0) { 602 /* The path is just "/". */ 603 break; 604 } 557 605 558 /* Collect the component */ 559 len = 0; 560 while ((next <= last) && (plb_get_char(next) != '/')) { 561 if (len + 1 == NAME_MAX) { 562 /* Component length overflow */ 563 async_answer_0(rid, ENAMETOOLONG); 564 goto out; 565 } 566 component[len++] = plb_get_char(next); 567 /* Process next character */ 568 next++; 569 } 570 571 assert(len); 572 component[len] = '\0'; 573 /* Eat slash */ 574 next++; 606 assert(component[clen] == 0); 575 607 576 608 /* Match the component */ 577 609 rc = ops->match(&tmp, cur, component); 578 on_error(rc, goto out_with_answer); 610 if (rc != EOK) { 611 async_answer_0(rid, rc); 612 LOG_EXIT(rc); 613 goto out; 614 } 579 615 580 /* 581 * If the matching component is a mount point, there are two 582 * legitimate semantics of the lookup operation. The first is 583 * the commonly used one in which the lookup crosses each mount 584 * point into the mounted file system. The second semantics is 585 * used mostly during unmount() and differs from the first one 586 * only in that the last mount point in the looked up path, 587 * which is also its last component, is not crossed. 588 */ 589 590 if ((tmp) && (tmp->mp_data.mp_active) && 591 (!(lflag & L_MP) || (next <= last))) { 592 if (next > last) 593 next = last = first; 594 else 595 next--; 616 /* Descend one level */ 617 if (par) { 618 rc = ops->node_put(par); 619 if (rc != EOK) { 620 async_answer_0(rid, rc); 621 LOG_EXIT(rc); 622 goto out; 623 } 624 } 625 626 par = cur; 627 cur = tmp; 628 tmp = NULL; 629 } 630 631 /* At this point, par is either NULL or a directory. 632 * If cur is NULL, the looked up file does not exist yet. 633 */ 634 635 assert(par == NULL || ops->is_directory(par)); 636 assert(par != NULL || cur != NULL); 637 638 /* Check for some error conditions. */ 639 640 if (cur && (lflag & L_FILE) && (ops->is_directory(cur))) { 641 async_answer_0(rid, EISDIR); 642 LOG_EXIT(EISDIR); 643 goto out; 644 } 645 646 if (cur && (lflag & L_DIRECTORY) && (ops->is_file(cur))) { 647 async_answer_0(rid, ENOTDIR); 648 LOG_EXIT(ENOTDIR); 649 goto out; 650 } 651 652 /* Unlink. */ 653 654 if (lflag & L_UNLINK) { 655 if (!cur) { 656 async_answer_0(rid, ENOENT); 657 LOG_EXIT(ENOENT); 658 goto out; 659 } 660 if (!par) { 661 async_answer_0(rid, EINVAL); 662 LOG_EXIT(EINVAL); 663 goto out; 664 } 665 666 rc = ops->unlink(par, cur, component); 667 if (rc == EOK) { 668 int64_t size = ops->size_get(cur); 669 int32_t lsize = LOWER32(size); 670 if (lsize != size) { 671 lsize = -1; 672 } 596 673 597 async_exch_t *exch = async_exchange_begin(tmp->mp_data.sess); 598 async_forward_slow(rid, exch, VFS_OUT_LOOKUP, next, 599 last, tmp->mp_data.service_id, lflag, index, 600 IPC_FF_ROUTE_FROM_ME); 601 async_exchange_end(exch); 602 603 (void) ops->node_put(cur); 604 (void) ops->node_put(tmp); 605 if (par) 606 (void) ops->node_put(par); 607 return; 608 } 609 610 /* Handle miss: match amongst siblings */ 611 if (!tmp) { 612 if (next <= last) { 613 /* There are unprocessed components */ 614 async_answer_0(rid, ENOENT); 674 async_answer_5(rid, fs_handle, service_id, 675 ops->index_get(cur), last, lsize, 676 ops->is_directory(cur)); 677 LOG_EXIT(EOK); 678 } else { 679 async_answer_0(rid, rc); 680 LOG_EXIT(rc); 681 } 682 goto out; 683 } 684 685 /* Create. */ 686 687 if (lflag & L_CREATE) { 688 if (cur && (lflag & L_EXCLUSIVE)) { 689 async_answer_0(rid, EEXIST); 690 LOG_EXIT(EEXIST); 691 goto out; 692 } 693 694 if (!cur) { 695 rc = ops->create(&cur, service_id, lflag & (L_FILE|L_DIRECTORY)); 696 if (rc != EOK) { 697 async_answer_0(rid, rc); 698 LOG_EXIT(rc); 699 goto out; 700 } 701 if (!cur) { 702 async_answer_0(rid, ENOSPC); 703 LOG_EXIT(ENOSPC); 615 704 goto out; 616 705 } 617 706 618 /* Miss in the last component */ 619 if (lflag & (L_CREATE | L_LINK)) { 620 /* Request to create a new link */ 621 if (!ops->is_directory(cur)) { 622 async_answer_0(rid, ENOTDIR); 623 goto out; 624 } 625 626 fs_node_t *fn; 627 if (lflag & L_CREATE) 628 rc = ops->create(&fn, service_id, 629 lflag); 630 else 631 rc = ops->node_get(&fn, service_id, 632 index); 633 on_error(rc, goto out_with_answer); 634 635 if (fn) { 636 rc = ops->link(cur, fn, component); 637 if (rc != EOK) { 638 if (lflag & L_CREATE) 639 (void) ops->destroy(fn); 640 else 641 (void) ops->node_put(fn); 642 async_answer_0(rid, rc); 643 } else { 644 (void) ops->node_put(cur); 645 cur = fn; 646 goto out_with_answer; 647 } 648 } else 649 async_answer_0(rid, ENOSPC); 650 707 rc = ops->link(par, cur, component); 708 if (rc != EOK) { 709 (void) ops->destroy(cur); 710 cur = NULL; 711 async_answer_0(rid, rc); 712 LOG_EXIT(rc); 651 713 goto out; 652 714 } 653 654 async_answer_0(rid, ENOENT); 715 } 716 } 717 718 /* Return. */ 719 out1: 720 if (!cur) { 721 async_answer_5(rid, fs_handle, service_id, 722 ops->index_get(par), last_next, -1, true); 723 LOG_EXIT(EOK); 724 goto out; 725 } 726 727 if (lflag & L_OPEN) { 728 rc = ops->node_open(cur); 729 if (rc != EOK) { 730 async_answer_0(rid, rc); 731 LOG_EXIT(rc); 655 732 goto out; 656 733 } 657 658 if (par) { 659 rc = ops->node_put(par); 660 on_error(rc, goto out_with_answer); 661 } 662 663 /* Descend one level */ 664 par = cur; 665 cur = tmp; 666 tmp = NULL; 667 } 668 669 /* Handle miss: excessive components */ 670 if (next <= last) { 671 bool has_children; 672 rc = ops->has_children(&has_children, cur); 673 on_error(rc, goto out_with_answer); 674 675 if (has_children) 676 goto skip_miss; 677 678 if (lflag & (L_CREATE | L_LINK)) { 679 if (!ops->is_directory(cur)) { 680 async_answer_0(rid, ENOTDIR); 681 goto out; 682 } 683 684 /* Collect next component */ 685 len = 0; 686 while (next <= last) { 687 if (plb_get_char(next) == '/') { 688 /* More than one component */ 689 async_answer_0(rid, ENOENT); 690 goto out; 691 } 692 693 if (len + 1 == NAME_MAX) { 694 /* Component length overflow */ 695 async_answer_0(rid, ENAMETOOLONG); 696 goto out; 697 } 698 699 component[len++] = plb_get_char(next); 700 /* Process next character */ 701 next++; 702 } 703 704 assert(len); 705 component[len] = '\0'; 706 707 fs_node_t *fn; 708 if (lflag & L_CREATE) 709 rc = ops->create(&fn, service_id, lflag); 710 else 711 rc = ops->node_get(&fn, service_id, index); 712 on_error(rc, goto out_with_answer); 713 714 if (fn) { 715 rc = ops->link(cur, fn, component); 716 if (rc != EOK) { 717 if (lflag & L_CREATE) 718 (void) ops->destroy(fn); 719 else 720 (void) ops->node_put(fn); 721 async_answer_0(rid, rc); 722 } else { 723 (void) ops->node_put(cur); 724 cur = fn; 725 goto out_with_answer; 726 } 727 } else 728 async_answer_0(rid, ENOSPC); 729 730 goto out; 731 } 732 733 async_answer_0(rid, ENOENT); 734 goto out; 735 } 736 737 skip_miss: 738 739 /* Handle hit */ 740 if (lflag & L_UNLINK) { 741 unsigned int old_lnkcnt = ops->lnkcnt_get(cur); 742 rc = ops->unlink(par, cur, component); 743 744 if (rc == EOK) { 745 aoff64_t size = ops->size_get(cur); 746 async_answer_5(rid, fs_handle, service_id, 747 ops->index_get(cur), LOWER32(size), UPPER32(size), 748 old_lnkcnt); 749 } else 750 async_answer_0(rid, rc); 751 752 goto out; 753 } 754 755 if (((lflag & (L_CREATE | L_EXCLUSIVE)) == (L_CREATE | L_EXCLUSIVE)) || 756 (lflag & L_LINK)) { 757 async_answer_0(rid, EEXIST); 758 goto out; 759 } 760 761 if ((lflag & L_FILE) && (ops->is_directory(cur))) { 762 async_answer_0(rid, EISDIR); 763 goto out; 764 } 765 766 if ((lflag & L_DIRECTORY) && (ops->is_file(cur))) { 767 async_answer_0(rid, ENOTDIR); 768 goto out; 769 } 770 771 if ((lflag & L_ROOT) && par) { 772 async_answer_0(rid, EINVAL); 773 goto out; 774 } 775 776 out_with_answer: 777 778 if (rc == EOK) { 779 if (lflag & L_OPEN) 780 rc = ops->node_open(cur); 781 782 if (rc == EOK) { 783 aoff64_t size = ops->size_get(cur); 784 async_answer_5(rid, fs_handle, service_id, 785 ops->index_get(cur), LOWER32(size), UPPER32(size), 786 ops->lnkcnt_get(cur)); 787 } else 788 async_answer_0(rid, rc); 789 790 } else 791 async_answer_0(rid, rc); 792 734 } 735 736 int64_t size = ops->size_get(cur); 737 int32_t lsize = LOWER32(size); 738 if (lsize != size) { 739 lsize = -1; 740 } 741 742 async_answer_5(rid, fs_handle, service_id, ops->index_get(cur), last, 743 lsize, ops->is_directory(cur)); 744 745 LOG_EXIT(EOK); 793 746 out: 794 795 if (par) 747 if (par) { 796 748 (void) ops->node_put(par); 797 798 if (cur) 749 } 750 751 if (cur) { 799 752 (void) ops->node_put(cur); 800 801 if (tmp) 753 } 754 755 if (tmp) { 802 756 (void) ops->node_put(tmp); 757 } 803 758 } 804 759
Note:
See TracChangeset
for help on using the changeset viewer.
