Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/fs/ext2fs/ext2fs_ops.c

    refcebe1 rb72efe8  
    11/*
     2 * Copyright (c) 2008 Jakub Jermar
    23 * Copyright (c) 2011 Martin Sucha
    34 * All rights reserved.
    … …  
    8687 */
    8788static int ext2fs_instance_get(devmap_handle_t, ext2fs_instance_t **);
    88 static int ext2fs_read_directory(ipc_callid_t, aoff64_t, size_t,
    89     ext2fs_instance_t *, ext2_inode_ref_t *, size_t *);
    90 static int ext2fs_read_file(ipc_callid_t, aoff64_t, size_t, ext2fs_instance_t *,
    91     ext2_inode_ref_t *, size_t *);
     89static void ext2fs_read_directory(ipc_callid_t, ipc_callid_t, aoff64_t,
     90        size_t, ext2fs_instance_t *, ext2_inode_ref_t *);
     91static void ext2fs_read_file(ipc_callid_t, ipc_callid_t, aoff64_t,
     92        size_t, ext2fs_instance_t *, ext2_inode_ref_t *);
    9293static bool ext2fs_is_dots(const uint8_t *, size_t);
    9394static int ext2fs_node_get_core(fs_node_t **, ext2fs_instance_t *, fs_index_t);
    … …  
    110111static aoff64_t ext2fs_size_get(fs_node_t *);
    111112static unsigned ext2fs_lnkcnt_get(fs_node_t *);
     113static char ext2fs_plb_get_char(unsigned);
    112114static bool ext2fs_is_directory(fs_node_t *);
    113115static bool ext2fs_is_file(fs_node_t *node);
    … …  
    238240        }
    239241       
    240         rc = ext2_directory_iterator_init(&it, fs, eparent->inode_ref, 0);
     242        rc = ext2_directory_iterator_init(&it, fs, eparent->inode_ref);
    241243        if (rc != EOK) {
    242244                return rc;
    … …  
    476478        }
    477479       
    478         rc = ext2_directory_iterator_init(&it, fs, enode->inode_ref, 0);
     480        rc = ext2_directory_iterator_init(&it, fs, enode->inode_ref);
    479481        if (rc != EOK) {
    480482                EXT2FS_DBG("error %u", rc);
    … …  
    536538        EXT2FS_DBG("%u", count);
    537539        return count;
     540}
     541
     542char ext2fs_plb_get_char(unsigned pos)
     543{
     544        return ext2fs_reg.plb_ro[pos % PLB_SIZE];
    538545}
    539546
    … …  
    579586        .size_get = ext2fs_size_get,
    580587        .lnkcnt_get = ext2fs_lnkcnt_get,
     588        .plb_get_char = ext2fs_plb_get_char,
    581589        .is_directory = ext2fs_is_directory,
    582590        .is_file = ext2fs_is_file,
    … …  
    588596 */
    589597
    590 static int ext2fs_mounted(devmap_handle_t devmap_handle, const char *opts,
    591    fs_index_t *index, aoff64_t *size, unsigned *lnkcnt)
     598void ext2fs_mounted(ipc_callid_t rid, ipc_call_t *request)
    592599{
    593600        EXT2FS_DBG("");
    594601        int rc;
     602        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    595603        ext2_filesystem_t *fs;
    596604        ext2fs_instance_t *inst;
    597605        bool read_only;
    598606       
     607        /* Accept the mount options */
     608        char *opts;
     609        rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL);
     610       
     611        if (rc != EOK) {
     612                async_answer_0(rid, rc);
     613                return;
     614        }
     615
     616        free(opts);
     617       
    599618        /* Allocate libext2 filesystem structure */
    600619        fs = (ext2_filesystem_t *) malloc(sizeof(ext2_filesystem_t));
    601         if (fs == NULL)
    602                 return ENOMEM;
     620        if (fs == NULL) {
     621                async_answer_0(rid, ENOMEM);
     622                return;
     623        }
    603624       
    604625        /* Allocate instance structure */
    … …  
    606627        if (inst == NULL) {
    607628                free(fs);
    608                 return ENOMEM;
     629                async_answer_0(rid, ENOMEM);
     630                return;
    609631        }
    610632       
    … …  
    614636                free(fs);
    615637                free(inst);
    616                 return rc;
     638                async_answer_0(rid, rc);
     639                return;
    617640        }
    618641       
    … …  
    623646                free(fs);
    624647                free(inst);
    625                 return rc;
     648                async_answer_0(rid, rc);
     649                return;
    626650        }
    627651       
    … …  
    632656                free(fs);
    633657                free(inst);
    634                 return rc;
     658                async_answer_0(rid, rc);
     659                return;
    635660        }
    636661       
    … …  
    648673                free(fs);
    649674                free(inst);
    650                 return rc;
     675                async_answer_0(rid, rc);
     676                return;
    651677        }
    652678        ext2fs_node_t *enode = EXT2FS_NODE(root_node);
    … …  
    657683        fibril_mutex_unlock(&instance_list_mutex);
    658684       
    659         *index = EXT2_INODE_ROOT_INDEX;
    660         *size = 0;
    661         *lnkcnt = ext2_inode_get_usage_count(enode->inode_ref->inode);
     685        async_answer_3(rid, EOK,
     686            EXT2_INODE_ROOT_INDEX,
     687            0,
     688            ext2_inode_get_usage_count(enode->inode_ref->inode));
    662689       
    663690        ext2fs_node_put(root_node);
    664 
    665         return EOK;
    666 }
    667 
    668 static int ext2fs_unmounted(devmap_handle_t devmap_handle)
    669 {
    670         EXT2FS_DBG("");
     691}
     692
     693void ext2fs_mount(ipc_callid_t rid, ipc_call_t *request)
     694{
     695        EXT2FS_DBG("");
     696        libfs_mount(&ext2fs_libfs_ops, ext2fs_reg.fs_handle, rid, request);
     697}
     698
     699void ext2fs_unmounted(ipc_callid_t rid, ipc_call_t *request)
     700{
     701        EXT2FS_DBG("");
     702        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    671703        ext2fs_instance_t *inst;
    672704        int rc;
    … …  
    674706        rc = ext2fs_instance_get(devmap_handle, &inst);
    675707       
    676         if (rc != EOK)
    677                 return rc;
     708        if (rc != EOK) {
     709                async_answer_0(rid, rc);
     710                return;
     711        }
    678712       
    679713        fibril_mutex_lock(&open_nodes_lock);
    … …  
    682716        if (inst->open_nodes_count != 0) {
    683717                fibril_mutex_unlock(&open_nodes_lock);
    684                 return EBUSY;
     718                async_answer_0(rid, EBUSY);
     719                return;
    685720        }
    686721       
    … …  
    694729        ext2_filesystem_fini(inst->filesystem);
    695730       
    696         return EOK;
    697 }
    698 
    699 static int
    700 ext2fs_read(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
    701     size_t *rbytes)
    702 {
    703         EXT2FS_DBG("");
     731        async_answer_0(rid, EOK);
     732}
     733
     734void ext2fs_unmount(ipc_callid_t rid, ipc_call_t *request)
     735{
     736        EXT2FS_DBG("");
     737        libfs_unmount(&ext2fs_libfs_ops, rid, request);
     738}
     739
     740void ext2fs_lookup(ipc_callid_t rid, ipc_call_t *request)
     741{
     742        EXT2FS_DBG("");
     743        libfs_lookup(&ext2fs_libfs_ops, ext2fs_reg.fs_handle, rid, request);
     744}
     745
     746void ext2fs_read(ipc_callid_t rid, ipc_call_t *request)
     747{
     748        EXT2FS_DBG("");
     749        devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     750        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
     751        aoff64_t pos =
     752            (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
    704753       
    705754        ext2fs_instance_t *inst;
    … …  
    714763        if (!async_data_read_receive(&callid, &size)) {
    715764                async_answer_0(callid, EINVAL);
    716                 return EINVAL;
     765                async_answer_0(rid, EINVAL);
     766                return;
    717767        }
    718768       
    … …  
    720770        if (rc != EOK) {
    721771                async_answer_0(callid, rc);
    722                 return rc;
     772                async_answer_0(rid, rc);
     773                return;
    723774        }
    724775       
    … …  
    726777        if (rc != EOK) {
    727778                async_answer_0(callid, rc);
    728                 return rc;
     779                async_answer_0(rid, rc);
     780                return;
    729781        }
    730782       
    731783        if (ext2_inode_is_type(inst->filesystem->superblock, inode_ref->inode,
    732             EXT2_INODE_MODE_FILE)) {
    733                 rc = ext2fs_read_file(callid, pos, size, inst, inode_ref,
    734                     rbytes);
    735         } else if (ext2_inode_is_type(inst->filesystem->superblock,
    736             inode_ref->inode, EXT2_INODE_MODE_DIRECTORY)) {
    737                 rc = ext2fs_read_directory(callid, pos, size, inst, inode_ref,
    738                     rbytes);
    739         } else {
     784                    EXT2_INODE_MODE_FILE)) {
     785                ext2fs_read_file(rid, callid, pos, size, inst, inode_ref);
     786        }
     787        else if (ext2_inode_is_type(inst->filesystem->superblock, inode_ref->inode,
     788                    EXT2_INODE_MODE_DIRECTORY)) {
     789                ext2fs_read_directory(rid, callid, pos, size, inst, inode_ref);
     790        }
     791        else {
    740792                /* Other inode types not supported */
    741793                async_answer_0(callid, ENOTSUP);
    742                 rc = ENOTSUP;
     794                async_answer_0(rid, ENOTSUP);
    743795        }
    744796       
    745797        ext2_filesystem_put_inode_ref(inode_ref);
    746798       
    747         return rc;
    748799}
    749800
    … …  
    763814}
    764815
    765 int ext2fs_read_directory(ipc_callid_t callid, aoff64_t pos, size_t size,
    766     ext2fs_instance_t *inst, ext2_inode_ref_t *inode_ref, size_t *rbytes)
     816void ext2fs_read_directory(ipc_callid_t rid, ipc_callid_t callid, aoff64_t pos,
     817        size_t size, ext2fs_instance_t *inst, ext2_inode_ref_t *inode_ref)
    767818{
    768819        ext2_directory_iterator_t it;
    769         aoff64_t next;
     820        aoff64_t cur;
    770821        uint8_t *buf;
    771822        size_t name_size;
    … …  
    773824        bool found = false;
    774825       
    775         rc = ext2_directory_iterator_init(&it, inst->filesystem, inode_ref, pos);
     826        rc = ext2_directory_iterator_init(&it, inst->filesystem, inode_ref);
    776827        if (rc != EOK) {
    777828                async_answer_0(callid, rc);
    778                 return rc;
    779         }
    780        
    781         /* Find next interesting directory entry.
    782          * We want to skip . and .. entries
     829                async_answer_0(rid, rc);
     830                return;
     831        }
     832       
     833        /* Find the index we want to read
     834         * Note that we need to iterate and count as
     835         * the underlying structure is a linked list
     836         * Moreover, we want to skip . and .. entries
    783837         * as these are not used in HelenOS
    784838         */
     839        cur = 0;
    785840        while (it.current != NULL) {
    786841                if (it.current->inode == 0) {
    … …  
    789844               
    790845                name_size = ext2_directory_entry_ll_get_name_length(
    791                     inst->filesystem->superblock, it.current);
     846                        inst->filesystem->superblock, it.current);
    792847               
    793848                /* skip . and .. */
    … …  
    796851                }
    797852               
    798                 /* The on-disk entry does not contain \0 at the end
    799                  * end of entry name, so we copy it to new buffer
    800                  * and add the \0 at the end
    801                  */
    802                 buf = malloc(name_size+1);
    803                 if (buf == NULL) {
    804                         ext2_directory_iterator_fini(&it);
    805                         async_answer_0(callid, ENOMEM);
    806                         return ENOMEM;
     853                /* Is this the dir entry we want to read? */
     854                if (cur == pos) {
     855                        /* The on-disk entry does not contain \0 at the end
     856                         * end of entry name, so we copy it to new buffer
     857                         * and add the \0 at the end
     858                         */
     859                        buf = malloc(name_size+1);
     860                        if (buf == NULL) {
     861                                ext2_directory_iterator_fini(&it);
     862                                async_answer_0(callid, ENOMEM);
     863                                async_answer_0(rid, ENOMEM);
     864                                return;
     865                        }
     866                        memcpy(buf, &it.current->name, name_size);
     867                        *(buf+name_size) = 0;
     868                        found = true;
     869                        (void) async_data_read_finalize(callid, buf, name_size+1);
     870                        free(buf);
     871                        break;
    807872                }
    808                 memcpy(buf, &it.current->name, name_size);
    809                 *(buf + name_size) = 0;
    810                 found = true;
    811                 (void) async_data_read_finalize(callid, buf, name_size + 1);
    812                 free(buf);
    813                 break;
     873                cur++;
    814874               
    815875skip:
    … …  
    818878                        ext2_directory_iterator_fini(&it);
    819879                        async_answer_0(callid, rc);
    820                         return rc;
     880                        async_answer_0(rid, rc);
     881                        return;
    821882                }
    822883        }
    823884       
     885        rc = ext2_directory_iterator_fini(&it);
     886        if (rc != EOK) {
     887                async_answer_0(rid, rc);
     888                return;
     889        }
     890       
    824891        if (found) {
    825                 rc = ext2_directory_iterator_next(&it);
    826                 if (rc != EOK)
    827                         return rc;
    828                 next = it.current_offset;
    829         }
    830        
    831         rc = ext2_directory_iterator_fini(&it);
    832         if (rc != EOK)
    833                 return rc;
    834        
    835         if (found) {
    836                 *rbytes = next - pos;
    837                 return EOK;
    838         } else {
     892                async_answer_1(rid, EOK, 1);
     893        }
     894        else {
    839895                async_answer_0(callid, ENOENT);
    840                 return ENOENT;
    841         }
    842 }
    843 
    844 int ext2fs_read_file(ipc_callid_t callid, aoff64_t pos, size_t size,
    845     ext2fs_instance_t *inst, ext2_inode_ref_t *inode_ref, size_t *rbytes)
     896                async_answer_0(rid, ENOENT);
     897        }
     898}
     899
     900void ext2fs_read_file(ipc_callid_t rid, ipc_callid_t callid, aoff64_t pos,
     901        size_t size, ext2fs_instance_t *inst, ext2_inode_ref_t *inode_ref)
    846902{
    847903        int rc;
    … …  
    861917                /* Read 0 bytes successfully */
    862918                async_data_read_finalize(callid, NULL, 0);
    863                 *rbytes = 0;
    864                 return EOK;
     919                async_answer_1(rid, EOK, 0);
     920                return;
    865921        }
    866922       
    … …  
    881937        if (rc != EOK) {
    882938                async_answer_0(callid, rc);
    883                 return rc;
     939                async_answer_0(rid, rc);
     940                return;
    884941        }
    885942       
    … …  
    893950                if (buffer == NULL) {
    894951                        async_answer_0(callid, ENOMEM);
    895                         return ENOMEM;
     952                        async_answer_0(rid, ENOMEM);
     953                        return;
    896954                }
    897955               
    … …  
    899957               
    900958                async_data_read_finalize(callid, buffer, bytes);
    901                 *rbytes = bytes;
     959                async_answer_1(rid, EOK, bytes);
    902960               
    903961                free(buffer);
    904962               
    905                 return EOK;
     963                return;
    906964        }
    907965       
    … …  
    910968        if (rc != EOK) {
    911969                async_answer_0(callid, rc);
    912                 return rc;
     970                async_answer_0(rid, rc);
     971                return;
    913972        }
    914973       
    … …  
    917976       
    918977        rc = block_put(block);
    919         if (rc != EOK)
    920                 return rc;
    921        
    922         *rbytes = bytes;
    923         return EOK;
    924 }
    925 
    926 static int
    927 ext2fs_write(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
    928     size_t *wbytes, aoff64_t *nsize)
    929 {
    930         EXT2FS_DBG("");
    931         return ENOTSUP;
    932 }
    933 
    934 static int
    935 ext2fs_truncate(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t size)
    936 {
    937         EXT2FS_DBG("");
    938         return ENOTSUP;
    939 }
    940 
    941 static int ext2fs_close(devmap_handle_t devmap_handle, fs_index_t index)
    942 {
    943         EXT2FS_DBG("");
    944         return EOK;
    945 }
    946 
    947 static int ext2fs_destroy(devmap_handle_t devmap_handle, fs_index_t index)
    948 {
    949         EXT2FS_DBG("");
    950         return ENOTSUP;
    951 }
    952 
    953 static int ext2fs_sync(devmap_handle_t devmap_handle, fs_index_t index)
    954 {
    955         EXT2FS_DBG("");
    956         return ENOTSUP;
    957 }
    958 
    959 vfs_out_ops_t ext2fs_ops = {
    960         .mounted = ext2fs_mounted,
    961         .unmounted = ext2fs_unmounted,
    962         .read = ext2fs_read,
    963         .write = ext2fs_write,
    964         .truncate = ext2fs_truncate,
    965         .close = ext2fs_close,
    966         .destroy = ext2fs_destroy,
    967         .sync = ext2fs_sync,
    968 };
     978        if (rc != EOK) {
     979                async_answer_0(rid, rc);
     980                return;
     981        }
     982               
     983        async_answer_1(rid, EOK, bytes);
     984}
     985
     986void ext2fs_write(ipc_callid_t rid, ipc_call_t *request)
     987{
     988        EXT2FS_DBG("");
     989//      devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     990//      fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
     991//      aoff64_t pos =
     992//          (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
     993       
     994        // TODO
     995        async_answer_0(rid, ENOTSUP);
     996}
     997
     998void ext2fs_truncate(ipc_callid_t rid, ipc_call_t *request)
     999{
     1000        EXT2FS_DBG("");
     1001//      devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     1002//      fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
     1003//      aoff64_t size =
     1004//          (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
     1005       
     1006        // TODO
     1007        async_answer_0(rid, ENOTSUP);
     1008}
     1009
     1010void ext2fs_close(ipc_callid_t rid, ipc_call_t *request)
     1011{
     1012        EXT2FS_DBG("");
     1013        async_answer_0(rid, EOK);
     1014}
     1015
     1016void ext2fs_destroy(ipc_callid_t rid, ipc_call_t *request)
     1017{
     1018        EXT2FS_DBG("");
     1019//      devmap_handle_t devmap_handle = (devmap_handle_t)IPC_GET_ARG1(*request);
     1020//      fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
     1021       
     1022        // TODO
     1023        async_answer_0(rid, ENOTSUP);
     1024}
     1025
     1026void ext2fs_open_node(ipc_callid_t rid, ipc_call_t *request)
     1027{
     1028        EXT2FS_DBG("");
     1029        libfs_open_node(&ext2fs_libfs_ops, ext2fs_reg.fs_handle, rid, request);
     1030}
     1031
     1032void ext2fs_stat(ipc_callid_t rid, ipc_call_t *request)
     1033{
     1034        EXT2FS_DBG("");
     1035        libfs_stat(&ext2fs_libfs_ops, ext2fs_reg.fs_handle, rid, request);
     1036}
     1037
     1038void ext2fs_sync(ipc_callid_t rid, ipc_call_t *request)
     1039{
     1040        EXT2FS_DBG("");
     1041//      devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     1042//      fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
     1043       
     1044        // TODO
     1045        async_answer_0(rid, ENOTSUP);
     1046}
    9691047
    9701048/**
    9711049 * @}
    9721050 */
    973 
Note: See TracChangeset for help on using the changeset viewer.