Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rb33870b rb72efe8  
    11/*
     2 * Copyright (c) 2008 Jakub Jermar
    23 * Copyright (c) 2011 Martin Sucha
    34 * All rights reserved.
    … …  
    4243#include <libext2.h>
    4344#include <ipc/services.h>
    44 #include <ipc/loc.h>
     45#include <ipc/devmap.h>
    4546#include <macros.h>
    4647#include <async.h>
    … …  
    6970typedef struct ext2fs_instance {
    7071        link_t link;
    71         service_id_t service_id;
     72        devmap_handle_t devmap_handle;
    7273        ext2_filesystem_t *filesystem;
    7374        unsigned int open_nodes_count;
    … …  
    8586 * Forward declarations of auxiliary functions
    8687 */
    87 static int ext2fs_instance_get(service_id_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 *);
     88static int ext2fs_instance_get(devmap_handle_t, ext2fs_instance_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);
    … …  
    9798 * Forward declarations of EXT2 libfs operations.
    9899 */
    99 static int ext2fs_root_get(fs_node_t **, service_id_t);
     100static int ext2fs_root_get(fs_node_t **, devmap_handle_t);
    100101static int ext2fs_match(fs_node_t **, fs_node_t *, const char *);
    101 static int ext2fs_node_get(fs_node_t **, service_id_t, fs_index_t);
     102static int ext2fs_node_get(fs_node_t **, devmap_handle_t, fs_index_t);
    102103static int ext2fs_node_open(fs_node_t *);
    103104static int ext2fs_node_put(fs_node_t *);
    104 static int ext2fs_create_node(fs_node_t **, service_id_t, int);
     105static int ext2fs_create_node(fs_node_t **, devmap_handle_t, int);
    105106static int ext2fs_destroy_node(fs_node_t *);
    106107static int ext2fs_link(fs_node_t *, fs_node_t *, const char *);
    … …  
    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);
    114 static service_id_t ext2fs_service_get(fs_node_t *node);
     116static devmap_handle_t ext2fs_device_get(fs_node_t *node);
    115117
    116118/*
    … …  
    134136        ext2fs_node_t *enode = hash_table_get_instance(item, ext2fs_node_t, link);
    135137        assert(keys > 0);
    136         if (enode->instance->service_id !=
    137             ((service_id_t) key[OPEN_NODES_DEV_HANDLE_KEY])) {
     138        if (enode->instance->devmap_handle !=
     139            ((devmap_handle_t) key[OPEN_NODES_DEV_HANDLE_KEY])) {
    138140                return false;
    139141        }
    … …  
    180182
    181183/**
    182  * Find an instance of filesystem for the given service_id
     184 * Find an instance of filesystem for the given devmap_handle
    183185 */
    184 int ext2fs_instance_get(service_id_t service_id, ext2fs_instance_t **inst)
    185 {
    186         EXT2FS_DBG("(%" PRIun ", -)", service_id);
     186int ext2fs_instance_get(devmap_handle_t devmap_handle, ext2fs_instance_t **inst)
     187{
     188        EXT2FS_DBG("(%" PRIun ", -)", devmap_handle);
    187189        ext2fs_instance_t *tmp;
    188190       
    … …  
    198200                tmp = list_get_instance(link, ext2fs_instance_t, link);
    199201               
    200                 if (tmp->service_id == service_id) {
     202                if (tmp->devmap_handle == devmap_handle) {
    201203                        *inst = tmp;
    202204                        fibril_mutex_unlock(&instance_list_mutex);
    … …  
    213215
    214216
    215 int ext2fs_root_get(fs_node_t **rfn, service_id_t service_id)
    216 {
    217         EXT2FS_DBG("(-, %" PRIun ")", service_id);
    218         return ext2fs_node_get(rfn, service_id, EXT2_INODE_ROOT_INDEX);
     217int ext2fs_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle)
     218{
     219        EXT2FS_DBG("(-, %" PRIun ")", devmap_handle);
     220        return ext2fs_node_get(rfn, devmap_handle, EXT2_INODE_ROOT_INDEX);
    219221}
    220222
    … …  
    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;
    … …  
    289291
    290292/** Instantiate a EXT2 in-core node. */
    291 int ext2fs_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
    292 {
    293         EXT2FS_DBG("(-,%" PRIun ",%u)", service_id, index);
     293int ext2fs_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index)
     294{
     295        EXT2FS_DBG("(-,%" PRIun ",%u)", devmap_handle, index);
    294296       
    295297        ext2fs_instance_t *inst = NULL;
    296298        int rc;
    297299       
    298         rc = ext2fs_instance_get(service_id, &inst);
     300        rc = ext2fs_instance_get(devmap_handle, &inst);
    299301        if (rc != EOK) {
    300302                return rc;
    … …  
    317319        /* Check if the node is not already open */
    318320        unsigned long key[] = {
    319                 [OPEN_NODES_DEV_HANDLE_KEY] = inst->service_id,
     321                [OPEN_NODES_DEV_HANDLE_KEY] = inst->devmap_handle,
    320322                [OPEN_NODES_INODE_KEY] = index,
    321323        };
    … …  
    411413
    412414        unsigned long key[] = {
    413                 [OPEN_NODES_DEV_HANDLE_KEY] = enode->instance->service_id,
     415                [OPEN_NODES_DEV_HANDLE_KEY] = enode->instance->devmap_handle,
    414416                [OPEN_NODES_INODE_KEY] = enode->inode_ref->index,
    415417        };
    … …  
    429431}
    430432
    431 int ext2fs_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
     433int ext2fs_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int flags)
    432434{
    433435        EXT2FS_DBG("");
    … …  
    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);
    … …  
    538540}
    539541
     542char ext2fs_plb_get_char(unsigned pos)
     543{
     544        return ext2fs_reg.plb_ro[pos % PLB_SIZE];
     545}
     546
    540547bool ext2fs_is_directory(fs_node_t *fn)
    541548{
    … …  
    557564}
    558565
    559 service_id_t ext2fs_service_get(fs_node_t *fn)
     566devmap_handle_t ext2fs_device_get(fs_node_t *fn)
    560567{
    561568        EXT2FS_DBG("");
    562569        ext2fs_node_t *enode = EXT2FS_NODE(fn);
    563         return enode->instance->service_id;
     570        return enode->instance->devmap_handle;
    564571}
    565572
    … …  
    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,
    583         .service_get = ext2fs_service_get
     591        .device_get = ext2fs_device_get
    584592};
    585593
    … …  
    588596 */
    589597
    590 static int ext2fs_mounted(service_id_t service_id, 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       
    611633        /* Initialize the filesystem  */
    612         rc = ext2_filesystem_init(fs, service_id);
     634        rc = ext2_filesystem_init(fs, devmap_handle);
    613635        if (rc != EOK) {
    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       
    637662        /* Initialize instance */
    638663        link_initialize(&inst->link);
    639         inst->service_id = service_id;
     664        inst->devmap_handle = devmap_handle;
    640665        inst->filesystem = fs;
    641666        inst->open_nodes_count = 0;
    … …  
    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(service_id_t service_id)
    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;
    673705       
    674         rc = ext2fs_instance_get(service_id, &inst);
    675        
    676         if (rc != EOK)
    677                 return rc;
     706        rc = ext2fs_instance_get(devmap_handle, &inst);
     707       
     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(service_id_t service_id, 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;
    717         }
    718        
    719         rc = ext2fs_instance_get(service_id, &inst);
     765                async_answer_0(rid, EINVAL);
     766                return;
     767        }
     768       
     769        rc = ext2fs_instance_get(devmap_handle, &inst);
    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       
    908966        /* Usual case - we need to read a block from device */
    909         rc = block_get(&block, inst->service_id, fs_block, BLOCK_FLAGS_NONE);
     967        rc = block_get(&block, inst->devmap_handle, fs_block, BLOCK_FLAGS_NONE);
    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(service_id_t service_id, 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(service_id_t service_id, fs_index_t index, aoff64_t size)
    936 {
    937         EXT2FS_DBG("");
    938         return ENOTSUP;
    939 }
    940 
    941 static int ext2fs_close(service_id_t service_id, fs_index_t index)
    942 {
    943         EXT2FS_DBG("");
    944         return EOK;
    945 }
    946 
    947 static int ext2fs_destroy(service_id_t service_id, fs_index_t index)
    948 {
    949         EXT2FS_DBG("");
    950         return ENOTSUP;
    951 }
    952 
    953 static int ext2fs_sync(service_id_t service_id, 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.