Changes in uspace/lib/fs/libfs.c [5bf76c1:b946bf83] in mainline
- File:
-
- 1 edited
-
uspace/lib/fs/libfs.c (modified) (35 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/fs/libfs.c
r5bf76c1 rb946bf83 45 45 #include <mem.h> 46 46 #include <sys/stat.h> 47 #include <stdlib.h>48 47 49 48 #define on_error(rc, action) \ … … 62 61 } while (0) 63 62 64 static fs_reg_t reg;65 66 static vfs_out_ops_t *vfs_out_ops = NULL;67 static libfs_ops_t *libfs_ops = NULL;68 69 static void libfs_mount(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *);70 static void libfs_unmount(libfs_ops_t *, ipc_callid_t, ipc_call_t *);71 static void libfs_lookup(libfs_ops_t *, fs_handle_t, ipc_callid_t,72 ipc_call_t *);73 static void libfs_stat(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *);74 static void libfs_open_node(libfs_ops_t *, fs_handle_t, ipc_callid_t,75 ipc_call_t *);76 77 static void vfs_out_mounted(ipc_callid_t rid, ipc_call_t *req)78 {79 service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);80 char *opts;81 int rc;82 83 /* Accept the mount options. */84 rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL);85 if (rc != EOK) {86 async_answer_0(rid, rc);87 return;88 }89 90 fs_index_t index;91 aoff64_t size;92 unsigned lnkcnt;93 rc = vfs_out_ops->mounted(service_id, opts, &index, &size, &lnkcnt);94 95 if (rc == EOK)96 async_answer_4(rid, EOK, index, LOWER32(size), UPPER32(size),97 lnkcnt);98 else99 async_answer_0(rid, rc);100 101 free(opts);102 }103 104 static void vfs_out_mount(ipc_callid_t rid, ipc_call_t *req)105 {106 libfs_mount(libfs_ops, reg.fs_handle, rid, req);107 }108 109 static void vfs_out_unmounted(ipc_callid_t rid, ipc_call_t *req)110 {111 service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);112 int rc;113 114 rc = vfs_out_ops->unmounted(service_id);115 116 async_answer_0(rid, rc);117 }118 119 static void vfs_out_unmount(ipc_callid_t rid, ipc_call_t *req)120 {121 122 libfs_unmount(libfs_ops, rid, req);123 }124 125 static void vfs_out_lookup(ipc_callid_t rid, ipc_call_t *req)126 {127 libfs_lookup(libfs_ops, reg.fs_handle, rid, req);128 }129 130 static void vfs_out_read(ipc_callid_t rid, ipc_call_t *req)131 {132 service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);133 fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req);134 aoff64_t pos = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*req),135 IPC_GET_ARG4(*req));136 size_t rbytes;137 int rc;138 139 rc = vfs_out_ops->read(service_id, index, pos, &rbytes);140 141 if (rc == EOK)142 async_answer_1(rid, EOK, rbytes);143 else144 async_answer_0(rid, rc);145 }146 147 static void vfs_out_write(ipc_callid_t rid, ipc_call_t *req)148 {149 service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);150 fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req);151 aoff64_t pos = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*req),152 IPC_GET_ARG4(*req));153 size_t wbytes;154 aoff64_t nsize;155 int rc;156 157 rc = vfs_out_ops->write(service_id, index, pos, &wbytes, &nsize);158 159 if (rc == EOK)160 async_answer_3(rid, EOK, wbytes, LOWER32(nsize), UPPER32(nsize));161 else162 async_answer_0(rid, rc);163 }164 165 static void vfs_out_truncate(ipc_callid_t rid, ipc_call_t *req)166 {167 service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);168 fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req);169 aoff64_t size = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*req),170 IPC_GET_ARG4(*req));171 int rc;172 173 rc = vfs_out_ops->truncate(service_id, index, size);174 175 async_answer_0(rid, rc);176 }177 178 static void vfs_out_close(ipc_callid_t rid, ipc_call_t *req)179 {180 service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);181 fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req);182 int rc;183 184 rc = vfs_out_ops->close(service_id, index);185 186 async_answer_0(rid, rc);187 }188 189 static void vfs_out_destroy(ipc_callid_t rid, ipc_call_t *req)190 {191 service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);192 fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req);193 int rc;194 195 rc = vfs_out_ops->destroy(service_id, index);196 197 async_answer_0(rid, rc);198 }199 200 static void vfs_out_open_node(ipc_callid_t rid, ipc_call_t *req)201 {202 libfs_open_node(libfs_ops, reg.fs_handle, rid, req);203 }204 205 static void vfs_out_stat(ipc_callid_t rid, ipc_call_t *req)206 {207 libfs_stat(libfs_ops, reg.fs_handle, rid, req);208 }209 210 static void vfs_out_sync(ipc_callid_t rid, ipc_call_t *req)211 {212 service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);213 fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req);214 int rc;215 216 rc = vfs_out_ops->sync(service_id, index);217 218 async_answer_0(rid, rc);219 }220 221 static void vfs_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)222 {223 if (iid) {224 /*225 * This only happens for connections opened by226 * IPC_M_CONNECT_ME_TO calls as opposed to callback connections227 * created by IPC_M_CONNECT_TO_ME.228 */229 async_answer_0(iid, EOK);230 }231 232 while (true) {233 ipc_call_t call;234 ipc_callid_t callid = async_get_call(&call);235 236 if (!IPC_GET_IMETHOD(call))237 return;238 239 switch (IPC_GET_IMETHOD(call)) {240 case VFS_OUT_MOUNTED:241 vfs_out_mounted(callid, &call);242 break;243 case VFS_OUT_MOUNT:244 vfs_out_mount(callid, &call);245 break;246 case VFS_OUT_UNMOUNTED:247 vfs_out_unmounted(callid, &call);248 break;249 case VFS_OUT_UNMOUNT:250 vfs_out_unmount(callid, &call);251 break;252 case VFS_OUT_LOOKUP:253 vfs_out_lookup(callid, &call);254 break;255 case VFS_OUT_READ:256 vfs_out_read(callid, &call);257 break;258 case VFS_OUT_WRITE:259 vfs_out_write(callid, &call);260 break;261 case VFS_OUT_TRUNCATE:262 vfs_out_truncate(callid, &call);263 break;264 case VFS_OUT_CLOSE:265 vfs_out_close(callid, &call);266 break;267 case VFS_OUT_DESTROY:268 vfs_out_destroy(callid, &call);269 break;270 case VFS_OUT_OPEN_NODE:271 vfs_out_open_node(callid, &call);272 break;273 case VFS_OUT_STAT:274 vfs_out_stat(callid, &call);275 break;276 case VFS_OUT_SYNC:277 vfs_out_sync(callid, &call);278 break;279 default:280 async_answer_0(callid, ENOTSUP);281 break;282 }283 }284 }285 286 63 /** Register file system server. 287 64 * … … 290 67 * code. 291 68 * 292 * @param sess Session for communication with VFS. 293 * @param info VFS info structure supplied by the file system 294 * implementation. 295 * @param vops Address of the vfs_out_ops_t structure. 296 * @param lops Address of the libfs_ops_t structure. 69 * @param vfs_phone Open phone for communication with VFS. 70 * @param reg File system registration structure. It will be 71 * initialized by this function. 72 * @param info VFS info structure supplied by the file system 73 * implementation. 74 * @param conn Connection fibril for handling all calls originating in 75 * VFS. 297 76 * 298 77 * @return EOK on success or a non-zero error code on errror. 299 78 * 300 79 */ 301 int fs_register( async_sess_t *sess, vfs_info_t *info, vfs_out_ops_t *vops,302 libfs_ops_t *lops)80 int fs_register(int vfs_phone, fs_reg_t *reg, vfs_info_t *info, 81 async_client_conn_t conn) 303 82 { 304 83 /* … … 307 86 * out-of-order, when it knows that the operation succeeded or failed. 308 87 */ 309 310 async_exch_t *exch = async_exchange_begin(sess);311 312 88 ipc_call_t answer; 313 aid_t req = async_send_0( exch, VFS_IN_REGISTER, &answer);89 aid_t req = async_send_0(vfs_phone, VFS_IN_REGISTER, &answer); 314 90 315 91 /* 316 92 * Send our VFS info structure to VFS. 317 93 */ 318 int rc = async_data_write_start(exch, info, sizeof(*info)); 319 94 int rc = async_data_write_start(vfs_phone, info, sizeof(*info)); 320 95 if (rc != EOK) { 321 async_exchange_end(exch);322 96 async_wait_for(req, NULL); 323 97 return rc; … … 325 99 326 100 /* 327 * Set VFS_OUT and libfs operations.328 */329 vfs_out_ops = vops;330 libfs_ops = lops;331 332 /*333 101 * Ask VFS for callback connection. 334 102 */ 335 async_connect_to_me( exch, 0, 0, 0, vfs_connection, NULL);103 async_connect_to_me(vfs_phone, 0, 0, 0, conn); 336 104 337 105 /* 338 106 * Allocate piece of address space for PLB. 339 107 */ 340 reg.plb_ro = as_get_mappable_page(PLB_SIZE); 341 if (!reg.plb_ro) { 342 async_exchange_end(exch); 108 reg->plb_ro = as_get_mappable_page(PLB_SIZE); 109 if (!reg->plb_ro) { 343 110 async_wait_for(req, NULL); 344 111 return ENOMEM; … … 348 115 * Request sharing the Path Lookup Buffer with VFS. 349 116 */ 350 rc = async_share_in_start_0_0(exch, reg.plb_ro, PLB_SIZE); 351 352 async_exchange_end(exch); 353 117 rc = async_share_in_start_0_0(vfs_phone, reg->plb_ro, PLB_SIZE); 354 118 if (rc) { 355 119 async_wait_for(req, NULL); … … 361 125 */ 362 126 async_wait_for(req, NULL); 363 reg .fs_handle = (int) IPC_GET_ARG1(answer);127 reg->fs_handle = (int) IPC_GET_ARG1(answer); 364 128 365 129 /* … … 367 131 * the same connection fibril as well. 368 132 */ 369 async_set_client_connection( vfs_connection);133 async_set_client_connection(conn); 370 134 371 135 return IPC_GET_RETVAL(answer); … … 378 142 379 143 void libfs_mount(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid, 380 ipc_call_t *req )144 ipc_call_t *request) 381 145 { 382 service_id_t mp_service_id = (service_id_t) IPC_GET_ARG1(*req); 383 fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*req); 384 fs_handle_t mr_fs_handle = (fs_handle_t) IPC_GET_ARG3(*req); 385 service_id_t mr_service_id = (service_id_t) IPC_GET_ARG4(*req); 386 387 async_sess_t *mountee_sess = async_clone_receive(EXCHANGE_PARALLEL); 388 if (mountee_sess == NULL) { 146 devmap_handle_t mp_devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request); 147 fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*request); 148 fs_handle_t mr_fs_handle = (fs_handle_t) IPC_GET_ARG3(*request); 149 devmap_handle_t mr_devmap_handle = (devmap_handle_t) IPC_GET_ARG4(*request); 150 int res; 151 sysarg_t rc; 152 153 ipc_call_t call; 154 ipc_callid_t callid; 155 156 /* Accept the phone */ 157 callid = async_get_call(&call); 158 int mountee_phone = (int) IPC_GET_ARG1(call); 159 if ((IPC_GET_IMETHOD(call) != IPC_M_CONNECTION_CLONE) || 160 (mountee_phone < 0)) { 161 async_answer_0(callid, EINVAL); 389 162 async_answer_0(rid, EINVAL); 390 163 return; 391 164 } 392 165 166 /* Acknowledge the mountee_phone */ 167 async_answer_0(callid, EOK); 168 393 169 fs_node_t *fn; 394 int res = ops->node_get(&fn, mp_service_id, mp_fs_index);170 res = ops->node_get(&fn, mp_devmap_handle, mp_fs_index); 395 171 if ((res != EOK) || (!fn)) { 396 async_hangup(mountee_ sess);172 async_hangup(mountee_phone); 397 173 async_data_write_void(combine_rc(res, ENOENT)); 398 174 async_answer_0(rid, combine_rc(res, ENOENT)); … … 401 177 402 178 if (fn->mp_data.mp_active) { 403 async_hangup(mountee_ sess);179 async_hangup(mountee_phone); 404 180 (void) ops->node_put(fn); 405 181 async_data_write_void(EBUSY); … … 408 184 } 409 185 410 async_exch_t *exch = async_exchange_begin(mountee_sess); 411 async_sess_t *sess = async_connect_me(EXCHANGE_PARALLEL, exch); 412 413 if (!sess) { 414 async_exchange_end(exch); 415 async_hangup(mountee_sess); 186 rc = async_req_0_0(mountee_phone, IPC_M_CONNECT_ME); 187 if (rc != EOK) { 188 async_hangup(mountee_phone); 416 189 (void) ops->node_put(fn); 417 async_data_write_void( errno);418 async_answer_0(rid, errno);190 async_data_write_void(rc); 191 async_answer_0(rid, rc); 419 192 return; 420 193 } 421 194 422 195 ipc_call_t answer; 423 int rc = async_data_write_forward_1_1(exch, VFS_OUT_MOUNTED, 424 mr_service_id, &answer); 425 async_exchange_end(exch); 196 rc = async_data_write_forward_1_1(mountee_phone, VFS_OUT_MOUNTED, 197 mr_devmap_handle, &answer); 426 198 427 199 if (rc == EOK) { 428 200 fn->mp_data.mp_active = true; 429 201 fn->mp_data.fs_handle = mr_fs_handle; 430 fn->mp_data. service_id = mr_service_id;431 fn->mp_data. sess = mountee_sess;202 fn->mp_data.devmap_handle = mr_devmap_handle; 203 fn->mp_data.phone = mountee_phone; 432 204 } 433 205 … … 435 207 * Do not release the FS node so that it stays in memory. 436 208 */ 437 async_answer_ 4(rid, rc, IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),438 IPC_GET_ARG3(answer) , IPC_GET_ARG4(answer));209 async_answer_3(rid, rc, IPC_GET_ARG1(answer), IPC_GET_ARG2(answer), 210 IPC_GET_ARG3(answer)); 439 211 } 440 212 441 void libfs_unmount(libfs_ops_t *ops, ipc_callid_t rid, ipc_call_t *req )213 void libfs_unmount(libfs_ops_t *ops, ipc_callid_t rid, ipc_call_t *request) 442 214 { 443 service_id_t mp_service_id = (service_id_t) IPC_GET_ARG1(*req);444 fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*req );215 devmap_handle_t mp_devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request); 216 fs_index_t mp_fs_index = (fs_index_t) IPC_GET_ARG2(*request); 445 217 fs_node_t *fn; 446 218 int res; 447 219 448 res = ops->node_get(&fn, mp_ service_id, mp_fs_index);220 res = ops->node_get(&fn, mp_devmap_handle, mp_fs_index); 449 221 if ((res != EOK) || (!fn)) { 450 222 async_answer_0(rid, combine_rc(res, ENOENT)); … … 464 236 * Tell the mounted file system to unmount. 465 237 */ 466 async_exch_t *exch = async_exchange_begin(fn->mp_data.sess); 467 res = async_req_1_0(exch, VFS_OUT_UNMOUNTED, fn->mp_data.service_id); 468 async_exchange_end(exch); 238 res = async_req_1_0(fn->mp_data.phone, VFS_OUT_UNMOUNTED, 239 fn->mp_data.devmap_handle); 469 240 470 241 /* … … 472 243 */ 473 244 if (res == EOK) { 474 async_hangup(fn->mp_data. sess);245 async_hangup(fn->mp_data.phone); 475 246 fn->mp_data.mp_active = false; 476 247 fn->mp_data.fs_handle = 0; 477 fn->mp_data.service_id = 0; 478 fn->mp_data.sess = NULL; 479 248 fn->mp_data.devmap_handle = 0; 249 fn->mp_data.phone = 0; 480 250 /* Drop the reference created in libfs_mount(). */ 481 251 (void) ops->node_put(fn); … … 484 254 (void) ops->node_put(fn); 485 255 async_answer_0(rid, res); 486 }487 488 static char plb_get_char(unsigned pos)489 {490 return reg.plb_ro[pos % PLB_SIZE];491 256 } 492 257 … … 505 270 */ 506 271 void libfs_lookup(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid, 507 ipc_call_t *req )272 ipc_call_t *request) 508 273 { 509 unsigned int first = IPC_GET_ARG1(*req );510 unsigned int last = IPC_GET_ARG2(*req );274 unsigned int first = IPC_GET_ARG1(*request); 275 unsigned int last = IPC_GET_ARG2(*request); 511 276 unsigned int next = first; 512 service_id_t service_id = IPC_GET_ARG3(*req);513 int lflag = IPC_GET_ARG4(*req );514 fs_index_t index = IPC_GET_ARG5(*req );277 devmap_handle_t devmap_handle = IPC_GET_ARG3(*request); 278 int lflag = IPC_GET_ARG4(*request); 279 fs_index_t index = IPC_GET_ARG5(*request); 515 280 char component[NAME_MAX + 1]; 516 281 int len; … … 524 289 fs_node_t *tmp = NULL; 525 290 526 rc = ops->root_get(&cur, service_id);291 rc = ops->root_get(&cur, devmap_handle); 527 292 on_error(rc, goto out_with_answer); 528 293 529 294 if (cur->mp_data.mp_active) { 530 async_exch_t *exch = async_exchange_begin(cur->mp_data.sess); 531 async_forward_slow(rid, exch, VFS_OUT_LOOKUP, next, last, 532 cur->mp_data.service_id, lflag, index, 295 async_forward_slow(rid, cur->mp_data.phone, VFS_OUT_LOOKUP, 296 next, last, cur->mp_data.devmap_handle, lflag, index, 533 297 IPC_FF_ROUTE_FROM_ME); 534 async_exchange_end(exch);535 536 298 (void) ops->node_put(cur); 537 299 return; … … 539 301 540 302 /* Eat slash */ 541 if ( plb_get_char(next) == '/')303 if (ops->plb_get_char(next) == '/') 542 304 next++; 543 305 … … 552 314 /* Collect the component */ 553 315 len = 0; 554 while ((next <= last) && ( plb_get_char(next) != '/')) {316 while ((next <= last) && (ops->plb_get_char(next) != '/')) { 555 317 if (len + 1 == NAME_MAX) { 556 318 /* Component length overflow */ … … 558 320 goto out; 559 321 } 560 component[len++] = plb_get_char(next);322 component[len++] = ops->plb_get_char(next); 561 323 /* Process next character */ 562 324 next++; … … 589 351 next--; 590 352 591 async_exch_t *exch = async_exchange_begin(tmp->mp_data.sess); 592 async_forward_slow(rid, exch, VFS_OUT_LOOKUP, next, 593 last, tmp->mp_data.service_id, lflag, index, 594 IPC_FF_ROUTE_FROM_ME); 595 async_exchange_end(exch); 596 353 async_forward_slow(rid, tmp->mp_data.phone, 354 VFS_OUT_LOOKUP, next, last, tmp->mp_data.devmap_handle, 355 lflag, index, IPC_FF_ROUTE_FROM_ME); 597 356 (void) ops->node_put(cur); 598 357 (void) ops->node_put(tmp); … … 620 379 fs_node_t *fn; 621 380 if (lflag & L_CREATE) 622 rc = ops->create(&fn, service_id,381 rc = ops->create(&fn, devmap_handle, 623 382 lflag); 624 383 else 625 rc = ops->node_get(&fn, service_id,384 rc = ops->node_get(&fn, devmap_handle, 626 385 index); 627 386 on_error(rc, goto out_with_answer); … … 638 397 aoff64_t size = ops->size_get(fn); 639 398 async_answer_5(rid, fs_handle, 640 service_id,399 devmap_handle, 641 400 ops->index_get(fn), 642 401 LOWER32(size), … … 684 443 len = 0; 685 444 while (next <= last) { 686 if ( plb_get_char(next) == '/') {445 if (ops->plb_get_char(next) == '/') { 687 446 /* More than one component */ 688 447 async_answer_0(rid, ENOENT); … … 696 455 } 697 456 698 component[len++] = plb_get_char(next);457 component[len++] = ops->plb_get_char(next); 699 458 /* Process next character */ 700 459 next++; … … 706 465 fs_node_t *fn; 707 466 if (lflag & L_CREATE) 708 rc = ops->create(&fn, service_id, lflag);467 rc = ops->create(&fn, devmap_handle, lflag); 709 468 else 710 rc = ops->node_get(&fn, service_id, index);469 rc = ops->node_get(&fn, devmap_handle, index); 711 470 on_error(rc, goto out_with_answer); 712 471 … … 722 481 aoff64_t size = ops->size_get(fn); 723 482 async_answer_5(rid, fs_handle, 724 service_id,483 devmap_handle, 725 484 ops->index_get(fn), 726 485 LOWER32(size), … … 748 507 if (rc == EOK) { 749 508 aoff64_t size = ops->size_get(cur); 750 async_answer_5(rid, fs_handle, service_id,509 async_answer_5(rid, fs_handle, devmap_handle, 751 510 ops->index_get(cur), LOWER32(size), UPPER32(size), 752 511 old_lnkcnt); … … 786 545 if (rc == EOK) { 787 546 aoff64_t size = ops->size_get(cur); 788 async_answer_5(rid, fs_handle, service_id,547 async_answer_5(rid, fs_handle, devmap_handle, 789 548 ops->index_get(cur), LOWER32(size), UPPER32(size), 790 549 ops->lnkcnt_get(cur)); … … 810 569 ipc_call_t *request) 811 570 { 812 service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);571 devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request); 813 572 fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request); 814 573 815 574 fs_node_t *fn; 816 int rc = ops->node_get(&fn, service_id, index);575 int rc = ops->node_get(&fn, devmap_handle, index); 817 576 on_error(rc, answer_and_return(rid, rc)); 818 577 … … 831 590 832 591 stat.fs_handle = fs_handle; 833 stat. service_id = service_id;592 stat.devmap_handle = devmap_handle; 834 593 stat.index = index; 835 594 stat.lnkcnt = ops->lnkcnt_get(fn); … … 837 596 stat.is_directory = ops->is_directory(fn); 838 597 stat.size = ops->size_get(fn); 839 stat. service = ops->service_get(fn);598 stat.device = ops->device_get(fn); 840 599 841 600 ops->node_put(fn); … … 856 615 ipc_call_t *request) 857 616 { 858 service_id_t service_id= IPC_GET_ARG1(*request);617 devmap_handle_t devmap_handle = IPC_GET_ARG1(*request); 859 618 fs_index_t index = IPC_GET_ARG2(*request); 860 619 861 620 fs_node_t *fn; 862 int rc = ops->node_get(&fn, service_id, index);621 int rc = ops->node_get(&fn, devmap_handle, index); 863 622 on_error(rc, answer_and_return(rid, rc)); 864 623 … … 870 629 rc = ops->node_open(fn); 871 630 aoff64_t size = ops->size_get(fn); 872 async_answer_4(rid, rc, LOWER32(size), UPPER32(size), 873 ops->lnkcnt_get(fn), 631 async_answer_4(rid, rc, LOWER32(size), UPPER32(size), ops->lnkcnt_get(fn), 874 632 (ops->is_file(fn) ? L_FILE : 0) | (ops->is_directory(fn) ? L_DIRECTORY : 0)); 875 633 … … 877 635 } 878 636 879 static FIBRIL_MUTEX_INITIALIZE(instances_mutex);880 static LIST_INITIALIZE(instances_list);881 882 typedef struct {883 service_id_t service_id;884 link_t link;885 void *data;886 } fs_instance_t;887 888 int fs_instance_create(service_id_t service_id, void *data)889 {890 fs_instance_t *inst = malloc(sizeof(fs_instance_t));891 if (!inst)892 return ENOMEM;893 894 link_initialize(&inst->link);895 inst->service_id = service_id;896 inst->data = data;897 898 fibril_mutex_lock(&instances_mutex);899 list_foreach(instances_list, link) {900 fs_instance_t *cur = list_get_instance(link, fs_instance_t,901 link);902 903 if (cur->service_id == service_id) {904 fibril_mutex_unlock(&instances_mutex);905 free(inst);906 return EEXIST;907 }908 909 /* keep the list sorted */910 if (cur->service_id < service_id) {911 list_insert_before(&inst->link, &cur->link);912 fibril_mutex_unlock(&instances_mutex);913 return EOK;914 }915 }916 list_append(&inst->link, &instances_list);917 fibril_mutex_unlock(&instances_mutex);918 919 return EOK;920 }921 922 int fs_instance_get(service_id_t service_id, void **idp)923 {924 fibril_mutex_lock(&instances_mutex);925 list_foreach(instances_list, link) {926 fs_instance_t *inst = list_get_instance(link, fs_instance_t,927 link);928 929 if (inst->service_id == service_id) {930 *idp = inst->data;931 fibril_mutex_unlock(&instances_mutex);932 return EOK;933 }934 }935 fibril_mutex_unlock(&instances_mutex);936 return ENOENT;937 }938 939 int fs_instance_destroy(service_id_t service_id)940 {941 fibril_mutex_lock(&instances_mutex);942 list_foreach(instances_list, link) {943 fs_instance_t *inst = list_get_instance(link, fs_instance_t,944 link);945 946 if (inst->service_id == service_id) {947 list_remove(&inst->link);948 fibril_mutex_unlock(&instances_mutex);949 free(inst);950 return EOK;951 }952 }953 fibril_mutex_unlock(&instances_mutex);954 return ENOENT;955 }956 957 637 /** @} 958 638 */
Note:
See TracChangeset
for help on using the changeset viewer.
