Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rffa2c8ef r69a60c4  
    3939#include "tmpfs.h"
    4040#include "../../vfs/vfs.h"
     41#include <ipc/ipc.h>
    4142#include <macros.h>
    4243#include <stdint.h>
    … …  
    6970/* Forward declarations of static functions. */
    7071static int tmpfs_match(fs_node_t **, fs_node_t *, const char *);
    71 static int tmpfs_node_get(fs_node_t **, devmap_handle_t, fs_index_t);
     72static int tmpfs_node_get(fs_node_t **, dev_handle_t, fs_index_t);
    7273static int tmpfs_node_open(fs_node_t *);
    7374static int tmpfs_node_put(fs_node_t *);
    74 static int tmpfs_create_node(fs_node_t **, devmap_handle_t, int);
     75static int tmpfs_create_node(fs_node_t **, dev_handle_t, int);
    7576static int tmpfs_destroy_node(fs_node_t *);
    7677static int tmpfs_link_node(fs_node_t *, fs_node_t *, const char *);
    … …  
    7879
    7980/* Implementation of helper functions. */
    80 static int tmpfs_root_get(fs_node_t **rfn, devmap_handle_t devmap_handle)
    81 {
    82         return tmpfs_node_get(rfn, devmap_handle, TMPFS_SOME_ROOT);
     81static int tmpfs_root_get(fs_node_t **rfn, dev_handle_t dev_handle)
     82{
     83        return tmpfs_node_get(rfn, dev_handle, TMPFS_SOME_ROOT);
    8384}
    8485
    … …  
    119120}
    120121
    121 static devmap_handle_t tmpfs_device_get(fs_node_t *fn)
     122static dev_handle_t tmpfs_device_get(fs_node_t *fn)
    122123{
    123124        return 0;
    … …  
    164165        switch (keys) {
    165166        case 1:
    166                 return (nodep->devmap_handle == key[NODES_KEY_DEV]);
     167                return (nodep->dev_handle == key[NODES_KEY_DEV]);
    167168        case 2:
    168                 return ((nodep->devmap_handle == key[NODES_KEY_DEV]) &&
     169                return ((nodep->dev_handle == key[NODES_KEY_DEV]) &&
    169170                    (nodep->index == key[NODES_KEY_INDEX]));
    170171        default:
    … …  
    208209        nodep->bp = NULL;
    209210        nodep->index = 0;
    210         nodep->devmap_handle = 0;
     211        nodep->dev_handle = 0;
    211212        nodep->type = TMPFS_NONE;
    212213        nodep->lnkcnt = 0;
    … …  
    232233}
    233234
    234 static bool tmpfs_instance_init(devmap_handle_t devmap_handle)
     235static bool tmpfs_instance_init(dev_handle_t dev_handle)
    235236{
    236237        fs_node_t *rfn;
    237238        int rc;
    238239       
    239         rc = tmpfs_create_node(&rfn, devmap_handle, L_DIRECTORY);
     240        rc = tmpfs_create_node(&rfn, dev_handle, L_DIRECTORY);
    240241        if (rc != EOK || !rfn)
    241242                return false;
    … …  
    244245}
    245246
    246 static void tmpfs_instance_done(devmap_handle_t devmap_handle)
     247static void tmpfs_instance_done(dev_handle_t dev_handle)
    247248{
    248249        unsigned long key[] = {
    249                 [NODES_KEY_DEV] = devmap_handle
     250                [NODES_KEY_DEV] = dev_handle
    250251        };
    251252        /*
    … …  
    278279}
    279280
    280 int tmpfs_node_get(fs_node_t **rfn, devmap_handle_t devmap_handle, fs_index_t index)
     281int tmpfs_node_get(fs_node_t **rfn, dev_handle_t dev_handle, fs_index_t index)
    281282{
    282283        unsigned long key[] = {
    283                 [NODES_KEY_DEV] = devmap_handle,
     284                [NODES_KEY_DEV] = dev_handle,
    284285                [NODES_KEY_INDEX] = index
    285286        };
    … …  
    307308}
    308309
    309 int tmpfs_create_node(fs_node_t **rfn, devmap_handle_t devmap_handle, int lflag)
     310int tmpfs_create_node(fs_node_t **rfn, dev_handle_t dev_handle, int lflag)
    310311{
    311312        fs_node_t *rootfn;
    … …  
    326327        nodep->bp->data = nodep;        /* link the FS and TMPFS nodes */
    327328
    328         rc = tmpfs_root_get(&rootfn, devmap_handle);
     329        rc = tmpfs_root_get(&rootfn, dev_handle);
    329330        assert(rc == EOK);
    330331        if (!rootfn)
    … …  
    332333        else
    333334                nodep->index = tmpfs_next_index++;
    334         nodep->devmap_handle = devmap_handle;
     335        nodep->dev_handle = dev_handle;
    335336        if (lflag & L_DIRECTORY)
    336337                nodep->type = TMPFS_DIRECTORY;
    … …  
    340341        /* Insert the new node into the nodes hash table. */
    341342        unsigned long key[] = {
    342                 [NODES_KEY_DEV] = nodep->devmap_handle,
     343                [NODES_KEY_DEV] = nodep->dev_handle,
    343344                [NODES_KEY_INDEX] = nodep->index
    344345        };
    … …  
    356357
    357358        unsigned long key[] = {
    358                 [NODES_KEY_DEV] = nodep->devmap_handle,
     359                [NODES_KEY_DEV] = nodep->dev_handle,
    359360                [NODES_KEY_INDEX] = nodep->index
    360361        };
    … …  
    441442void tmpfs_mounted(ipc_callid_t rid, ipc_call_t *request)
    442443{
    443         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     444        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
    444445        fs_node_t *rootfn;
    445446        int rc;
    … …  
    449450        rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL);
    450451        if (rc != EOK) {
    451                 async_answer_0(rid, rc);
     452                ipc_answer_0(rid, rc);
    452453                return;
    453454        }
    454455
    455456        /* Check if this device is not already mounted. */
    456         rc = tmpfs_root_get(&rootfn, devmap_handle);
     457        rc = tmpfs_root_get(&rootfn, dev_handle);
    457458        if ((rc == EOK) && (rootfn)) {
    458459                (void) tmpfs_node_put(rootfn);
    459460                free(opts);
    460                 async_answer_0(rid, EEXIST);
     461                ipc_answer_0(rid, EEXIST);
    461462                return;
    462463        }
    463464
    464465        /* Initialize TMPFS instance. */
    465         if (!tmpfs_instance_init(devmap_handle)) {
     466        if (!tmpfs_instance_init(dev_handle)) {
    466467                free(opts);
    467                 async_answer_0(rid, ENOMEM);
    468                 return;
    469         }
    470 
    471         rc = tmpfs_root_get(&rootfn, devmap_handle);
     468                ipc_answer_0(rid, ENOMEM);
     469                return;
     470        }
     471
     472        rc = tmpfs_root_get(&rootfn, dev_handle);
    472473        assert(rc == EOK);
    473474        tmpfs_node_t *rootp = TMPFS_NODE(rootfn);
    474475        if (str_cmp(opts, "restore") == 0) {
    475                 if (tmpfs_restore(devmap_handle))
    476                         async_answer_3(rid, EOK, rootp->index, rootp->size,
     476                if (tmpfs_restore(dev_handle))
     477                        ipc_answer_3(rid, EOK, rootp->index, rootp->size,
    477478                            rootp->lnkcnt);
    478479                else
    479                         async_answer_0(rid, ELIMIT);
     480                        ipc_answer_0(rid, ELIMIT);
    480481        } else {
    481                 async_answer_3(rid, EOK, rootp->index, rootp->size,
     482                ipc_answer_3(rid, EOK, rootp->index, rootp->size,
    482483                    rootp->lnkcnt);
    483484        }
    … …  
    492493void tmpfs_unmounted(ipc_callid_t rid, ipc_call_t *request)
    493494{
    494         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    495 
    496         tmpfs_instance_done(devmap_handle);
    497         async_answer_0(rid, EOK);
     495        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
     496
     497        tmpfs_instance_done(dev_handle);
     498        ipc_answer_0(rid, EOK);
    498499}
    499500
    … …  
    510511void tmpfs_read(ipc_callid_t rid, ipc_call_t *request)
    511512{
    512         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     513        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
    513514        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    514515        aoff64_t pos =
    … …  
    520521        link_t *hlp;
    521522        unsigned long key[] = {
    522                 [NODES_KEY_DEV] = devmap_handle,
     523                [NODES_KEY_DEV] = dev_handle,
    523524                [NODES_KEY_INDEX] = index
    524525        };
    525526        hlp = hash_table_find(&nodes, key);
    526527        if (!hlp) {
    527                 async_answer_0(rid, ENOENT);
     528                ipc_answer_0(rid, ENOENT);
    528529                return;
    529530        }
    … …  
    537538        size_t size;
    538539        if (!async_data_read_receive(&callid, &size)) {
    539                 async_answer_0(callid, EINVAL);
    540                 async_answer_0(rid, EINVAL);
     540                ipc_answer_0(callid, EINVAL);
     541                ipc_answer_0(rid, EINVAL);
    541542                return;
    542543        }
    … …  
    565566
    566567                if (lnk == &nodep->cs_head) {
    567                         async_answer_0(callid, ENOENT);
    568                         async_answer_1(rid, ENOENT, 0);
     568                        ipc_answer_0(callid, ENOENT);
     569                        ipc_answer_1(rid, ENOENT, 0);
    569570                        return;
    570571                }
    … …  
    580581         * Answer the VFS_READ call.
    581582         */
    582         async_answer_1(rid, EOK, bytes);
     583        ipc_answer_1(rid, EOK, bytes);
    583584}
    584585
    585586void tmpfs_write(ipc_callid_t rid, ipc_call_t *request)
    586587{
    587         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     588        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
    588589        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    589590        aoff64_t pos =
    … …  
    595596        link_t *hlp;
    596597        unsigned long key[] = {
    597                 [NODES_KEY_DEV] = devmap_handle,
     598                [NODES_KEY_DEV] = dev_handle,
    598599                [NODES_KEY_INDEX] = index
    599600        };
    600601        hlp = hash_table_find(&nodes, key);
    601602        if (!hlp) {
    602                 async_answer_0(rid, ENOENT);
     603                ipc_answer_0(rid, ENOENT);
    603604                return;
    604605        }
    … …  
    612613        size_t size;
    613614        if (!async_data_write_receive(&callid, &size)) {
    614                 async_answer_0(callid, EINVAL);
    615                 async_answer_0(rid, EINVAL);
     615                ipc_answer_0(callid, EINVAL);   
     616                ipc_answer_0(rid, EINVAL);
    616617                return;
    617618        }
    … …  
    623624                /* The file size is not changing. */
    624625                (void) async_data_write_finalize(callid, nodep->data + pos, size);
    625                 async_answer_2(rid, EOK, size, nodep->size);
     626                ipc_answer_2(rid, EOK, size, nodep->size);
    626627                return;
    627628        }
    … …  
    636637        void *newdata = realloc(nodep->data, nodep->size + delta);
    637638        if (!newdata) {
    638                 async_answer_0(callid, ENOMEM);
    639                 async_answer_2(rid, EOK, 0, nodep->size);
     639                ipc_answer_0(callid, ENOMEM);
     640                ipc_answer_2(rid, EOK, 0, nodep->size);
    640641                return;
    641642        }
    … …  
    645646        nodep->data = newdata;
    646647        (void) async_data_write_finalize(callid, nodep->data + pos, size);
    647         async_answer_2(rid, EOK, size, nodep->size);
     648        ipc_answer_2(rid, EOK, size, nodep->size);
    648649}
    649650
    650651void tmpfs_truncate(ipc_callid_t rid, ipc_call_t *request)
    651652{
    652         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     653        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
    653654        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    654655        aoff64_t size =
    … …  
    659660         */
    660661        unsigned long key[] = {
    661                 [NODES_KEY_DEV] = devmap_handle,
     662                [NODES_KEY_DEV] = dev_handle,
    662663                [NODES_KEY_INDEX] = index
    663664        };
    664665        link_t *hlp = hash_table_find(&nodes, key);
    665666        if (!hlp) {
    666                 async_answer_0(rid, ENOENT);
     667                ipc_answer_0(rid, ENOENT);
    667668                return;
    668669        }
    … …  
    671672       
    672673        if (size == nodep->size) {
    673                 async_answer_0(rid, EOK);
     674                ipc_answer_0(rid, EOK);
    674675                return;
    675676        }
    676677       
    677678        if (size > SIZE_MAX) {
    678                 async_answer_0(rid, ENOMEM);
     679                ipc_answer_0(rid, ENOMEM);
    679680                return;
    680681        }
    … …  
    682683        void *newdata = realloc(nodep->data, size);
    683684        if (!newdata) {
    684                 async_answer_0(rid, ENOMEM);
     685                ipc_answer_0(rid, ENOMEM);
    685686                return;
    686687        }
    … …  
    693694        nodep->size = size;
    694695        nodep->data = newdata;
    695         async_answer_0(rid, EOK);
     696        ipc_answer_0(rid, EOK);
    696697}
    697698
    698699void tmpfs_close(ipc_callid_t rid, ipc_call_t *request)
    699700{
    700         async_answer_0(rid, EOK);
     701        ipc_answer_0(rid, EOK);
    701702}
    702703
    703704void tmpfs_destroy(ipc_callid_t rid, ipc_call_t *request)
    704705{
    705         devmap_handle_t devmap_handle = (devmap_handle_t)IPC_GET_ARG1(*request);
     706        dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
    706707        fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
    707708        int rc;
    … …  
    709710        link_t *hlp;
    710711        unsigned long key[] = {
    711                 [NODES_KEY_DEV] = devmap_handle,
     712                [NODES_KEY_DEV] = dev_handle,
    712713                [NODES_KEY_INDEX] = index
    713714        };
    714715        hlp = hash_table_find(&nodes, key);
    715716        if (!hlp) {
    716                 async_answer_0(rid, ENOENT);
     717                ipc_answer_0(rid, ENOENT);
    717718                return;
    718719        }
    … …  
    720721            nh_link);
    721722        rc = tmpfs_destroy_node(FS_NODE(nodep));
    722         async_answer_0(rid, rc);
     723        ipc_answer_0(rid, rc);
    723724}
    724725
    … …  
    739740         * thus the sync operation is a no-op.
    740741         */
    741         async_answer_0(rid, EOK);
     742        ipc_answer_0(rid, EOK);
    742743}
    743744
Note: See TracChangeset for help on using the changeset viewer.