Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/fs/tmpfs/tmpfs_ops.c

    r0da4e41 r75160a6  
    6767
    6868/* Forward declarations of static functions. */
    69 static int tmpfs_match(fs_node_t **, fs_node_t *, const char *);
    70 static int tmpfs_node_get(fs_node_t **, dev_handle_t, fs_index_t);
    71 static int tmpfs_node_put(fs_node_t *);
    72 static int tmpfs_create_node(fs_node_t **, dev_handle_t, int);
    73 static int tmpfs_destroy_node(fs_node_t *);
     69static fs_node_t *tmpfs_match(fs_node_t *, const char *);
     70static fs_node_t *tmpfs_node_get(dev_handle_t, fs_index_t);
     71static void tmpfs_node_put(fs_node_t *);
     72static fs_node_t *tmpfs_create_node(dev_handle_t, int);
    7473static int tmpfs_link_node(fs_node_t *, fs_node_t *, const char *);
    7574static int tmpfs_unlink_node(fs_node_t *, fs_node_t *, const char *);
     75static int tmpfs_destroy_node(fs_node_t *);
    7676
    7777/* Implementation of helper functions. */
    78 static int tmpfs_root_get(fs_node_t **rfn, dev_handle_t dev_handle)
    79 {
    80         return tmpfs_node_get(rfn, dev_handle, TMPFS_SOME_ROOT);
    81 }
    82 
    83 static int tmpfs_has_children(bool *has_children, fs_node_t *fn)
    84 {
    85         *has_children = !list_empty(&TMPFS_NODE(fn)->cs_head);
    86         return EOK;
    87 }
    88 
    8978static fs_index_t tmpfs_index_get(fs_node_t *fn)
    9079{
    … …  
    10089{
    10190        return TMPFS_NODE(fn)->lnkcnt;
     91}
     92
     93static bool tmpfs_has_children(fs_node_t *fn)
     94{
     95        return !list_empty(&TMPFS_NODE(fn)->cs_head);
     96}
     97
     98static fs_node_t *tmpfs_root_get(dev_handle_t dev_handle)
     99{
     100        return tmpfs_node_get(dev_handle, TMPFS_SOME_ROOT);
    102101}
    103102
    … …  
    119118/** libfs operations */
    120119libfs_ops_t tmpfs_libfs_ops = {
    121         .root_get = tmpfs_root_get,
    122120        .match = tmpfs_match,
    123121        .node_get = tmpfs_node_get,
    … …  
    127125        .link = tmpfs_link_node,
    128126        .unlink = tmpfs_unlink_node,
    129         .has_children = tmpfs_has_children,
    130127        .index_get = tmpfs_index_get,
    131128        .size_get = tmpfs_size_get,
    132129        .lnkcnt_get = tmpfs_lnkcnt_get,
     130        .has_children = tmpfs_has_children,
     131        .root_get = tmpfs_root_get,
    133132        .plb_get_char = tmpfs_plb_get_char,
    134133        .is_directory = tmpfs_is_directory,
    … …  
    198197{
    199198        fs_node_t *rfn;
    200         int rc;
    201199       
    202         rc = tmpfs_create_node(&rfn, dev_handle, L_DIRECTORY);
    203         if (rc != EOK || !rfn)
     200        rfn = tmpfs_create_node(dev_handle, L_DIRECTORY);
     201        if (!rfn)
    204202                return false;
    205203        TMPFS_NODE(rfn)->lnkcnt = 0;    /* FS root is not linked */
    … …  
    207205}
    208206
    209 int tmpfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
     207fs_node_t *tmpfs_match(fs_node_t *pfn, const char *component)
    210208{
    211209        tmpfs_node_t *parentp = TMPFS_NODE(pfn);
    … …  
    214212        for (lnk = parentp->cs_head.next; lnk != &parentp->cs_head;
    215213            lnk = lnk->next) {
    216                 tmpfs_dentry_t *dentryp;
    217                 dentryp = list_get_instance(lnk, tmpfs_dentry_t, link);
    218                 if (!str_cmp(dentryp->name, component)) {
    219                         *rfn = FS_NODE(dentryp->node);
    220                         return EOK;
    221                 }
    222         }
    223 
    224         *rfn = NULL;
    225         return EOK;
    226 }
    227 
    228 int tmpfs_node_get(fs_node_t **rfn, dev_handle_t dev_handle, fs_index_t index)
     214                tmpfs_dentry_t *dentryp = list_get_instance(lnk, tmpfs_dentry_t,
     215                    link);
     216                if (!str_cmp(dentryp->name, component))
     217                        return FS_NODE(dentryp->node);
     218        }
     219
     220        return NULL;
     221}
     222
     223fs_node_t *tmpfs_node_get(dev_handle_t dev_handle, fs_index_t index)
    229224{
    230225        unsigned long key[] = {
    … …  
    233228        };
    234229        link_t *lnk = hash_table_find(&nodes, key);
    235         if (lnk) {
    236                 tmpfs_node_t *nodep;
    237                 nodep = hash_table_get_instance(lnk, tmpfs_node_t, nh_link);
    238                 *rfn = FS_NODE(nodep);
    239         } else {
    240                 *rfn = NULL;
    241         }
    242         return EOK;     
    243 }
    244 
    245 int tmpfs_node_put(fs_node_t *fn)
     230        if (!lnk)
     231                return NULL;
     232        return FS_NODE(hash_table_get_instance(lnk, tmpfs_node_t, nh_link));
     233}
     234
     235void tmpfs_node_put(fs_node_t *fn)
    246236{
    247237        /* nothing to do */
    248         return EOK;
    249 }
    250 
    251 int tmpfs_create_node(fs_node_t **rfn, dev_handle_t dev_handle, int lflag)
    252 {
    253         fs_node_t *rootfn;
    254         int rc;
    255 
     238}
     239
     240fs_node_t *tmpfs_create_node(dev_handle_t dev_handle, int lflag)
     241{
    256242        assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
    257243
    258244        tmpfs_node_t *nodep = malloc(sizeof(tmpfs_node_t));
    259245        if (!nodep)
    260                 return ENOMEM;
     246                return NULL;
    261247        tmpfs_node_initialize(nodep);
    262248        nodep->bp = malloc(sizeof(fs_node_t));
    263249        if (!nodep->bp) {
    264250                free(nodep);
    265                 return ENOMEM;
     251                return NULL;
    266252        }
    267253        fs_node_initialize(nodep->bp);
    268254        nodep->bp->data = nodep;        /* link the FS and TMPFS nodes */
    269 
    270         rc = tmpfs_root_get(&rootfn, dev_handle);
    271         assert(rc == EOK);
    272         if (!rootfn)
     255        if (!tmpfs_root_get(dev_handle))
    273256                nodep->index = TMPFS_SOME_ROOT;
    274257        else
    … …  
    286269        };
    287270        hash_table_insert(&nodes, key, &nodep->nh_link);
    288         *rfn = FS_NODE(nodep);
    289         return EOK;
    290 }
    291 
    292 int tmpfs_destroy_node(fs_node_t *fn)
    293 {
    294         tmpfs_node_t *nodep = TMPFS_NODE(fn);
    295        
    296         assert(!nodep->lnkcnt);
    297         assert(list_empty(&nodep->cs_head));
    298 
    299         unsigned long key[] = {
    300                 [NODES_KEY_INDEX] = nodep->index,
    301                 [NODES_KEY_DEV] = nodep->dev_handle
    302         };
    303         hash_table_remove(&nodes, key, 2);
    304 
    305         if (nodep->type == TMPFS_FILE)
    306                 free(nodep->data);
    307         free(nodep->bp);
    308         free(nodep);
    309         return EOK;
     271        return FS_NODE(nodep);
    310272}
    311273
    … …  
    381343}
    382344
     345int tmpfs_destroy_node(fs_node_t *fn)
     346{
     347        tmpfs_node_t *nodep = TMPFS_NODE(fn);
     348       
     349        assert(!nodep->lnkcnt);
     350        assert(list_empty(&nodep->cs_head));
     351
     352        unsigned long key[] = {
     353                [NODES_KEY_INDEX] = nodep->index,
     354                [NODES_KEY_DEV] = nodep->dev_handle
     355        };
     356        hash_table_remove(&nodes, key, 2);
     357
     358        if (nodep->type == TMPFS_FILE)
     359                free(nodep->data);
     360        free(nodep->bp);
     361        free(nodep);
     362        return EOK;
     363}
     364
    383365void tmpfs_mounted(ipc_callid_t rid, ipc_call_t *request)
    384366{
    385367        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
    386         int rc;
    387368
    388369        /* accept the mount options */
    389370        ipc_callid_t callid;
    390371        size_t size;
    391         if (!async_data_write_receive(&callid, &size)) {
     372        if (!ipc_data_write_receive(&callid, &size)) {
    392373                ipc_answer_0(callid, EINVAL);
    393374                ipc_answer_0(rid, EINVAL);
    … …  
    400381                return;
    401382        }
    402         ipcarg_t retval = async_data_write_finalize(callid, opts, size);
     383        ipcarg_t retval = ipc_data_write_finalize(callid, opts, size);
    403384        if (retval != EOK) {
    404385                ipc_answer_0(rid, retval);
    … …  
    414395        }
    415396
    416         fs_node_t *rootfn;
    417         rc = tmpfs_root_get(&rootfn, dev_handle);
    418         assert(rc == EOK);
    419         tmpfs_node_t *rootp = TMPFS_NODE(rootfn);
     397        tmpfs_node_t *rootp = TMPFS_NODE(tmpfs_root_get(dev_handle));
    420398        if (str_cmp(opts, "restore") == 0) {
    421399                if (tmpfs_restore(dev_handle))
    … …  
    467445        ipc_callid_t callid;
    468446        size_t size;
    469         if (!async_data_read_receive(&callid, &size)) {
     447        if (!ipc_data_read_receive(&callid, &size)) {
    470448                ipc_answer_0(callid, EINVAL);   
    471449                ipc_answer_0(rid, EINVAL);
    … …  
    476454        if (nodep->type == TMPFS_FILE) {
    477455                bytes = max(0, min(nodep->size - pos, size));
    478                 (void) async_data_read_finalize(callid, nodep->data + pos,
     456                (void) ipc_data_read_finalize(callid, nodep->data + pos,
    479457                    bytes);
    480458        } else {
    … …  
    503481                dentryp = list_get_instance(lnk, tmpfs_dentry_t, link);
    504482
    505                 (void) async_data_read_finalize(callid, dentryp->name,
     483                (void) ipc_data_read_finalize(callid, dentryp->name,
    506484                    str_size(dentryp->name) + 1);
    507485                bytes = 1;
    … …  
    541519        ipc_callid_t callid;
    542520        size_t size;
    543         if (!async_data_write_receive(&callid, &size)) {
     521        if (!ipc_data_write_receive(&callid, &size)) {
    544522                ipc_answer_0(callid, EINVAL);   
    545523                ipc_answer_0(rid, EINVAL);
    … …  
    552530        if (pos + size <= nodep->size) {
    553531                /* The file size is not changing. */
    554                 (void) async_data_write_finalize(callid, nodep->data + pos, size);
     532                (void) ipc_data_write_finalize(callid, nodep->data + pos, size);
    555533                ipc_answer_2(rid, EOK, size, nodep->size);
    556534                return;
    … …  
    574552        nodep->size += delta;
    575553        nodep->data = newdata;
    576         (void) async_data_write_finalize(callid, nodep->data + pos, size);
     554        (void) ipc_data_write_finalize(callid, nodep->data + pos, size);
    577555        ipc_answer_2(rid, EOK, size, nodep->size);
    578556}
Note: See TracChangeset for help on using the changeset viewer.