Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/fs/devfs/devfs_ops.c

    refcebe1 r79ae36dd  
    403403}
    404404
     405static char devfs_plb_get_char(unsigned pos)
     406{
     407        return devfs_reg.plb_ro[pos % PLB_SIZE];
     408}
     409
    405410static bool devfs_is_directory(fs_node_t *fn)
    406411{
     
    442447        .size_get = devfs_size_get,
    443448        .lnkcnt_get = devfs_lnkcnt_get,
     449        .plb_get_char = devfs_plb_get_char,
    444450        .is_directory = devfs_is_directory,
    445451        .is_file = devfs_is_file,
     
    456462}
    457463
    458 static int devfs_mounted(devmap_handle_t devmap_handle, const char *opts,
    459     fs_index_t *index, aoff64_t *size, unsigned *lnkcnt)
    460 {
    461         *index = 0;
    462         *size = 0;
    463         *lnkcnt = 0;
    464         return EOK;
    465 }
    466 
    467 static int devfs_unmounted(devmap_handle_t devmap_handle)
    468 {
    469         return ENOTSUP;
    470 }
    471 
    472 static int
    473 devfs_read(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
    474     size_t *rbytes)
    475 {
     464void devfs_mounted(ipc_callid_t rid, ipc_call_t *request)
     465{
     466        char *opts;
     467       
     468        /* Accept the mount options */
     469        sysarg_t retval = async_data_write_accept((void **) &opts, true, 0, 0,
     470            0, NULL);
     471        if (retval != EOK) {
     472                async_answer_0(rid, retval);
     473                return;
     474        }
     475       
     476        free(opts);
     477        async_answer_3(rid, EOK, 0, 0, 0);
     478}
     479
     480void devfs_mount(ipc_callid_t rid, ipc_call_t *request)
     481{
     482        libfs_mount(&devfs_libfs_ops, devfs_reg.fs_handle, rid, request);
     483}
     484
     485void devfs_unmounted(ipc_callid_t rid, ipc_call_t *request)
     486{
     487        async_answer_0(rid, ENOTSUP);
     488}
     489
     490void devfs_unmount(ipc_callid_t rid, ipc_call_t *request)
     491{
     492        libfs_unmount(&devfs_libfs_ops, rid, request);
     493}
     494
     495void devfs_lookup(ipc_callid_t rid, ipc_call_t *request)
     496{
     497        libfs_lookup(&devfs_libfs_ops, devfs_reg.fs_handle, rid, request);
     498}
     499
     500void devfs_open_node(ipc_callid_t rid, ipc_call_t *request)
     501{
     502        libfs_open_node(&devfs_libfs_ops, devfs_reg.fs_handle, rid, request);
     503}
     504
     505void devfs_stat(ipc_callid_t rid, ipc_call_t *request)
     506{
     507        libfs_stat(&devfs_libfs_ops, devfs_reg.fs_handle, rid, request);
     508}
     509
     510void devfs_read(ipc_callid_t rid, ipc_call_t *request)
     511{
     512        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
     513        aoff64_t pos =
     514            (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
     515       
    476516        if (index == 0) {
    477517                ipc_callid_t callid;
     
    479519                if (!async_data_read_receive(&callid, &size)) {
    480520                        async_answer_0(callid, EINVAL);
    481                         return EINVAL;
     521                        async_answer_0(rid, EINVAL);
     522                        return;
    482523                }
    483524               
     
    499540                        async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1);
    500541                        free(desc);
    501                         *rbytes = 1;
    502                         return EOK;
     542                        async_answer_1(rid, EOK, 1);
     543                        return;
    503544                }
    504545               
     
    514555                                async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1);
    515556                                free(desc);
    516                                 *rbytes = 1;
    517                                 return EOK;
     557                                async_answer_1(rid, EOK, 1);
     558                                return;
    518559                        }
    519560                       
     
    522563               
    523564                async_answer_0(callid, ENOENT);
    524                 return ENOENT;
     565                async_answer_1(rid, ENOENT, 0);
     566                return;
    525567        }
    526568       
     
    533575                if (!async_data_read_receive(&callid, &size)) {
    534576                        async_answer_0(callid, EINVAL);
    535                         return EINVAL;
     577                        async_answer_0(rid, EINVAL);
     578                        return;
    536579                }
    537580               
     
    542585                        async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1);
    543586                        free(desc);
    544                         *rbytes = 1;
    545                         return EOK;
     587                        async_answer_1(rid, EOK, 1);
     588                        return;
    546589                }
    547590               
    548591                free(desc);
    549592                async_answer_0(callid, ENOENT);
    550                 return ENOENT;
     593                async_answer_1(rid, ENOENT, 0);
     594                return;
    551595        }
    552596       
     
    562606                if (lnk == NULL) {
    563607                        fibril_mutex_unlock(&devices_mutex);
    564                         return ENOENT;
     608                        async_answer_0(rid, ENOENT);
     609                        return;
    565610                }
    566611               
     
    572617                        fibril_mutex_unlock(&devices_mutex);
    573618                        async_answer_0(callid, EINVAL);
    574                         return EINVAL;
     619                        async_answer_0(rid, EINVAL);
     620                        return;
    575621                }
    576622               
     
    579625               
    580626                ipc_call_t answer;
    581                 aid_t msg = async_send_4(exch, VFS_OUT_READ, devmap_handle,
    582                     index, LOWER32(pos), UPPER32(pos), &answer);
     627                aid_t msg = async_send_3(exch, IPC_GET_IMETHOD(*request),
     628                    IPC_GET_ARG1(*request), IPC_GET_ARG2(*request),
     629                    IPC_GET_ARG3(*request), &answer);
    583630               
    584631                /* Forward the IPC_M_DATA_READ request to the driver */
     
    592639                sysarg_t rc;
    593640                async_wait_for(msg, &rc);
    594                
    595                 *rbytes = IPC_GET_ARG1(answer);
    596                 return rc;
    597         }
    598        
    599         return ENOENT;
    600 }
    601 
    602 static int
    603 devfs_write(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
    604     size_t *wbytes, aoff64_t *nsize)
    605 {
    606         if (index == 0)
    607                 return ENOTSUP;
     641                size_t bytes = IPC_GET_ARG1(answer);
     642               
     643                /* Driver reply is the final result of the whole operation */
     644                async_answer_1(rid, rc, bytes);
     645                return;
     646        }
     647       
     648        async_answer_0(rid, ENOENT);
     649}
     650
     651void devfs_write(ipc_callid_t rid, ipc_call_t *request)
     652{
     653        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
     654        if (index == 0) {
     655                async_answer_0(rid, ENOTSUP);
     656                return;
     657        }
    608658       
    609659        devmap_handle_type_t type = devmap_handle_probe(index);
     
    611661        if (type == DEV_HANDLE_NAMESPACE) {
    612662                /* Namespace directory */
    613                 return ENOTSUP;
     663                async_answer_0(rid, ENOTSUP);
     664                return;
    614665        }
    615666       
     
    624675                if (lnk == NULL) {
    625676                        fibril_mutex_unlock(&devices_mutex);
    626                         return ENOENT;
     677                        async_answer_0(rid, ENOENT);
     678                        return;
    627679                }
    628680               
     
    634686                        fibril_mutex_unlock(&devices_mutex);
    635687                        async_answer_0(callid, EINVAL);
    636                         return EINVAL;
     688                        async_answer_0(rid, EINVAL);
     689                        return;
    637690                }
    638691               
     
    641694               
    642695                ipc_call_t answer;
    643                 aid_t msg = async_send_4(exch, VFS_OUT_WRITE, devmap_handle,
    644                     index, LOWER32(pos), UPPER32(pos), &answer);
     696                aid_t msg = async_send_3(exch, IPC_GET_IMETHOD(*request),
     697                    IPC_GET_ARG1(*request), IPC_GET_ARG2(*request),
     698                    IPC_GET_ARG3(*request), &answer);
    645699               
    646700                /* Forward the IPC_M_DATA_WRITE request to the driver */
     
    654708                sysarg_t rc;
    655709                async_wait_for(msg, &rc);
    656                
    657                 *wbytes = IPC_GET_ARG1(answer);
    658                 *nsize = 0;
    659                 return rc;
    660         }
    661        
    662         return ENOENT;
    663 }
    664 
    665 static int
    666 devfs_truncate(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t size)
    667 {
    668         return ENOTSUP;
    669 }
    670 
    671 static int devfs_close(devmap_handle_t devmap_handle, fs_index_t index)
    672 {
    673         if (index == 0)
    674                 return EOK;
     710                size_t bytes = IPC_GET_ARG1(answer);
     711               
     712                /* Driver reply is the final result of the whole operation */
     713                async_answer_1(rid, rc, bytes);
     714                return;
     715        }
     716       
     717        async_answer_0(rid, ENOENT);
     718}
     719
     720void devfs_truncate(ipc_callid_t rid, ipc_call_t *request)
     721{
     722        async_answer_0(rid, ENOTSUP);
     723}
     724
     725void devfs_close(ipc_callid_t rid, ipc_call_t *request)
     726{
     727        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
     728       
     729        if (index == 0) {
     730                async_answer_0(rid, EOK);
     731                return;
     732        }
    675733       
    676734        devmap_handle_type_t type = devmap_handle_probe(index);
     
    678736        if (type == DEV_HANDLE_NAMESPACE) {
    679737                /* Namespace directory */
    680                 return EOK;
     738                async_answer_0(rid, EOK);
     739                return;
    681740        }
    682741       
     
    690749                if (lnk == NULL) {
    691750                        fibril_mutex_unlock(&devices_mutex);
    692                         return ENOENT;
     751                        async_answer_0(rid, ENOENT);
     752                        return;
    693753                }
    694754               
     
    704764                fibril_mutex_unlock(&devices_mutex);
    705765               
    706                 return EOK;
    707         }
    708        
    709         return ENOENT;
    710 }
    711 
    712 static int devfs_sync(devmap_handle_t devmap_handle, fs_index_t index)
    713 {
    714         if (index == 0)
    715                 return EOK;
     766                async_answer_0(rid, EOK);
     767                return;
     768        }
     769       
     770        async_answer_0(rid, ENOENT);
     771}
     772
     773void devfs_sync(ipc_callid_t rid, ipc_call_t *request)
     774{
     775        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
     776       
     777        if (index == 0) {
     778                async_answer_0(rid, EOK);
     779                return;
     780        }
    716781       
    717782        devmap_handle_type_t type = devmap_handle_probe(index);
     
    719784        if (type == DEV_HANDLE_NAMESPACE) {
    720785                /* Namespace directory */
    721                 return EOK;
     786                async_answer_0(rid, EOK);
     787                return;
    722788        }
    723789       
     
    731797                if (lnk == NULL) {
    732798                        fibril_mutex_unlock(&devices_mutex);
    733                         return ENOENT;
     799                        async_answer_0(rid, ENOENT);
     800                        return;
    734801                }
    735802               
     
    741808               
    742809                ipc_call_t answer;
    743                 aid_t msg = async_send_2(exch, VFS_OUT_SYNC, devmap_handle,
    744                     index, &answer);
     810                aid_t msg = async_send_2(exch, IPC_GET_IMETHOD(*request),
     811                    IPC_GET_ARG1(*request), IPC_GET_ARG2(*request), &answer);
    745812               
    746813                async_exchange_end(exch);
     
    752819                async_wait_for(msg, &rc);
    753820               
    754                 return rc;
    755         }
    756        
    757         return  ENOENT;
    758 }
    759 
    760 static int devfs_destroy(devmap_handle_t devmap_handle, fs_index_t index)
    761 {
    762         return ENOTSUP;
    763 }
    764 
    765 vfs_out_ops_t devfs_ops = {
    766         .mounted = devfs_mounted,
    767         .unmounted = devfs_unmounted,
    768         .read = devfs_read,
    769         .write = devfs_write,
    770         .truncate = devfs_truncate,
    771         .close = devfs_close,
    772         .destroy = devfs_destroy,
    773         .sync = devfs_sync,
    774 };
     821                /* Driver reply is the final result of the whole operation */
     822                async_answer_0(rid, rc);
     823                return;
     824        }
     825       
     826        async_answer_0(rid, ENOENT);
     827}
     828
     829void devfs_destroy(ipc_callid_t rid, ipc_call_t *request)
     830{
     831        async_answer_0(rid, ENOTSUP);
     832}
    775833
    776834/**
Note: See TracChangeset for help on using the changeset viewer.