Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r1313ee9 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_open(fs_node_t *);
    72 static int tmpfs_node_put(fs_node_t *);
    73 static int tmpfs_create_node(fs_node_t **, dev_handle_t, int);
    74 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);
    7573static int tmpfs_link_node(fs_node_t *, fs_node_t *, const char *);
    7674static int tmpfs_unlink_node(fs_node_t *, fs_node_t *, const char *);
     75static int tmpfs_destroy_node(fs_node_t *);
    7776
    7877/* Implementation of helper functions. */
    79 static int tmpfs_root_get(fs_node_t **rfn, dev_handle_t dev_handle)
    80 {
    81         return tmpfs_node_get(rfn, dev_handle, TMPFS_SOME_ROOT);
    82 }
    83 
    84 static int tmpfs_has_children(bool *has_children, fs_node_t *fn)
    85 {
    86         *has_children = !list_empty(&TMPFS_NODE(fn)->cs_head);
    87         return EOK;
    88 }
    89 
    9078static fs_index_t tmpfs_index_get(fs_node_t *fn)
    9179{
    … …  
    10391}
    10492
     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);
     101}
     102
    105103static char tmpfs_plb_get_char(unsigned pos)
    106104{
    … …  
    116114{
    117115        return TMPFS_NODE(fn)->type == TMPFS_FILE;
    118 }
    119 
    120 static dev_handle_t tmpfs_device_get(fs_node_t *fn)
    121 {
    122         return 0;
    123116}
    124117
    125118/** libfs operations */
    126119libfs_ops_t tmpfs_libfs_ops = {
    127         .root_get = tmpfs_root_get,
    128120        .match = tmpfs_match,
    129121        .node_get = tmpfs_node_get,
    130         .node_open = tmpfs_node_open,
    131122        .node_put = tmpfs_node_put,
    132123        .create = tmpfs_create_node,
    … …  
    134125        .link = tmpfs_link_node,
    135126        .unlink = tmpfs_unlink_node,
    136         .has_children = tmpfs_has_children,
    137127        .index_get = tmpfs_index_get,
    138128        .size_get = tmpfs_size_get,
    139129        .lnkcnt_get = tmpfs_lnkcnt_get,
     130        .has_children = tmpfs_has_children,
     131        .root_get = tmpfs_root_get,
    140132        .plb_get_char = tmpfs_plb_get_char,
    141133        .is_directory = tmpfs_is_directory,
    142         .is_file = tmpfs_is_file,
    143         .device_get = tmpfs_device_get
     134        .is_file = tmpfs_is_file
    144135};
    145136
    … …  
    206197{
    207198        fs_node_t *rfn;
    208         int rc;
    209199       
    210         rc = tmpfs_create_node(&rfn, dev_handle, L_DIRECTORY);
    211         if (rc != EOK || !rfn)
     200        rfn = tmpfs_create_node(dev_handle, L_DIRECTORY);
     201        if (!rfn)
    212202                return false;
    213203        TMPFS_NODE(rfn)->lnkcnt = 0;    /* FS root is not linked */
    … …  
    215205}
    216206
    217 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)
    218208{
    219209        tmpfs_node_t *parentp = TMPFS_NODE(pfn);
    … …  
    222212        for (lnk = parentp->cs_head.next; lnk != &parentp->cs_head;
    223213            lnk = lnk->next) {
    224                 tmpfs_dentry_t *dentryp;
    225                 dentryp = list_get_instance(lnk, tmpfs_dentry_t, link);
    226                 if (!str_cmp(dentryp->name, component)) {
    227                         *rfn = FS_NODE(dentryp->node);
    228                         return EOK;
    229                 }
    230         }
    231 
    232         *rfn = NULL;
    233         return EOK;
    234 }
    235 
    236 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)
    237224{
    238225        unsigned long key[] = {
    … …  
    241228        };
    242229        link_t *lnk = hash_table_find(&nodes, key);
    243         if (lnk) {
    244                 tmpfs_node_t *nodep;
    245                 nodep = hash_table_get_instance(lnk, tmpfs_node_t, nh_link);
    246                 *rfn = FS_NODE(nodep);
    247         } else {
    248                 *rfn = NULL;
    249         }
    250         return EOK;     
    251 }
    252 
    253 int tmpfs_node_open(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)
    254236{
    255237        /* nothing to do */
    256         return EOK;
    257 }
    258 
    259 int tmpfs_node_put(fs_node_t *fn)
    260 {
    261         /* nothing to do */
    262         return EOK;
    263 }
    264 
    265 int tmpfs_create_node(fs_node_t **rfn, dev_handle_t dev_handle, int lflag)
    266 {
    267         fs_node_t *rootfn;
    268         int rc;
    269 
     238}
     239
     240fs_node_t *tmpfs_create_node(dev_handle_t dev_handle, int lflag)
     241{
    270242        assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
    271243
    272244        tmpfs_node_t *nodep = malloc(sizeof(tmpfs_node_t));
    273245        if (!nodep)
    274                 return ENOMEM;
     246                return NULL;
    275247        tmpfs_node_initialize(nodep);
    276248        nodep->bp = malloc(sizeof(fs_node_t));
    277249        if (!nodep->bp) {
    278250                free(nodep);
    279                 return ENOMEM;
     251                return NULL;
    280252        }
    281253        fs_node_initialize(nodep->bp);
    282254        nodep->bp->data = nodep;        /* link the FS and TMPFS nodes */
    283 
    284         rc = tmpfs_root_get(&rootfn, dev_handle);
    285         assert(rc == EOK);
    286         if (!rootfn)
     255        if (!tmpfs_root_get(dev_handle))
    287256                nodep->index = TMPFS_SOME_ROOT;
    288257        else
    … …  
    300269        };
    301270        hash_table_insert(&nodes, key, &nodep->nh_link);
    302         *rfn = FS_NODE(nodep);
    303         return EOK;
    304 }
    305 
    306 int tmpfs_destroy_node(fs_node_t *fn)
    307 {
    308         tmpfs_node_t *nodep = TMPFS_NODE(fn);
    309        
    310         assert(!nodep->lnkcnt);
    311         assert(list_empty(&nodep->cs_head));
    312 
    313         unsigned long key[] = {
    314                 [NODES_KEY_INDEX] = nodep->index,
    315                 [NODES_KEY_DEV] = nodep->dev_handle
    316         };
    317         hash_table_remove(&nodes, key, 2);
    318 
    319         if (nodep->type == TMPFS_FILE)
    320                 free(nodep->data);
    321         free(nodep->bp);
    322         free(nodep);
    323         return EOK;
     271        return FS_NODE(nodep);
    324272}
    325273
    … …  
    395343}
    396344
     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
    397365void tmpfs_mounted(ipc_callid_t rid, ipc_call_t *request)
    398366{
    399367        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
    400         int rc;
    401368
    402369        /* accept the mount options */
    403370        ipc_callid_t callid;
    404371        size_t size;
    405         if (!async_data_write_receive(&callid, &size)) {
     372        if (!ipc_data_write_receive(&callid, &size)) {
    406373                ipc_answer_0(callid, EINVAL);
    407374                ipc_answer_0(rid, EINVAL);
    … …  
    414381                return;
    415382        }
    416         ipcarg_t retval = async_data_write_finalize(callid, opts, size);
     383        ipcarg_t retval = ipc_data_write_finalize(callid, opts, size);
    417384        if (retval != EOK) {
    418385                ipc_answer_0(rid, retval);
    … …  
    428395        }
    429396
    430         fs_node_t *rootfn;
    431         rc = tmpfs_root_get(&rootfn, dev_handle);
    432         assert(rc == EOK);
    433         tmpfs_node_t *rootp = TMPFS_NODE(rootfn);
     397        tmpfs_node_t *rootp = TMPFS_NODE(tmpfs_root_get(dev_handle));
    434398        if (str_cmp(opts, "restore") == 0) {
    435399                if (tmpfs_restore(dev_handle))
    … …  
    481445        ipc_callid_t callid;
    482446        size_t size;
    483         if (!async_data_read_receive(&callid, &size)) {
     447        if (!ipc_data_read_receive(&callid, &size)) {
    484448                ipc_answer_0(callid, EINVAL);   
    485449                ipc_answer_0(rid, EINVAL);
    … …  
    490454        if (nodep->type == TMPFS_FILE) {
    491455                bytes = max(0, min(nodep->size - pos, size));
    492                 (void) async_data_read_finalize(callid, nodep->data + pos,
     456                (void) ipc_data_read_finalize(callid, nodep->data + pos,
    493457                    bytes);
    494458        } else {
    … …  
    517481                dentryp = list_get_instance(lnk, tmpfs_dentry_t, link);
    518482
    519                 (void) async_data_read_finalize(callid, dentryp->name,
     483                (void) ipc_data_read_finalize(callid, dentryp->name,
    520484                    str_size(dentryp->name) + 1);
    521485                bytes = 1;
    … …  
    555519        ipc_callid_t callid;
    556520        size_t size;
    557         if (!async_data_write_receive(&callid, &size)) {
     521        if (!ipc_data_write_receive(&callid, &size)) {
    558522                ipc_answer_0(callid, EINVAL);   
    559523                ipc_answer_0(rid, EINVAL);
    … …  
    566530        if (pos + size <= nodep->size) {
    567531                /* The file size is not changing. */
    568                 (void) async_data_write_finalize(callid, nodep->data + pos, size);
     532                (void) ipc_data_write_finalize(callid, nodep->data + pos, size);
    569533                ipc_answer_2(rid, EOK, size, nodep->size);
    570534                return;
    … …  
    588552        nodep->size += delta;
    589553        nodep->data = newdata;
    590         (void) async_data_write_finalize(callid, nodep->data + pos, size);
     554        (void) ipc_data_write_finalize(callid, nodep->data + pos, size);
    591555        ipc_answer_2(rid, EOK, size, nodep->size);
    592556}
Note: See TracChangeset for help on using the changeset viewer.