Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 54e4479 in mainline


Ignore:
Timestamp:
2009-09-24T16:49:02Z (11 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
master
Children:
073f550
Parents:
0daba21
Message:

Update tmpfs implementation of libfs operations wrt. the preceding API change.

Location:
uspace/srv/fs/tmpfs
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/fs/tmpfs/tmpfs_dump.c

    r0daba21 r54e4479  
    8282                                return false;
    8383                       
    84                         fn = ops->create(dev, L_FILE);
    85                         if (fn == NULL) {
     84                        rc = ops->create(&fn, dev, L_FILE);
     85                        if (rc != EOK || fn == NULL) {
    8686                                free(fname);
    8787                                return false;
     
    9090                        if (block_seqread(dev, bufpos, buflen, pos, fname,
    9191                            entry.len) != EOK) {
    92                                 ops->destroy(fn);
     92                                (void) ops->destroy(fn);
    9393                                free(fname);
    9494                                return false;
     
    9898                        rc = ops->link(pfn, fn, fname);
    9999                        if (rc != EOK) {
    100                                 ops->destroy(fn);
     100                                (void) ops->destroy(fn);
    101101                                free(fname);
    102102                                return false;
     
    126126                                return false;
    127127                       
    128                         fn = ops->create(dev, L_DIRECTORY);
    129                         if (fn == NULL) {
     128                        rc = ops->create(&fn, dev, L_DIRECTORY);
     129                        if (rc != EOK || fn == NULL) {
    130130                                free(fname);
    131131                                return false;
     
    134134                        if (block_seqread(dev, bufpos, buflen, pos, fname,
    135135                            entry.len) != EOK) {
    136                                 ops->destroy(fn);
     136                                (void) ops->destroy(fn);
    137137                                free(fname);
    138138                                return false;
     
    142142                        rc = ops->link(pfn, fn, fname);
    143143                        if (rc != EOK) {
    144                                 ops->destroy(fn);
     144                                (void) ops->destroy(fn);
    145145                                free(fname);
    146146                                return false;
     
    164164{
    165165        libfs_ops_t *ops = &tmpfs_libfs_ops;
     166        fs_node_t *fn;
    166167        int rc;
    167168
     
    182183                goto error;
    183184       
    184         if (!tmpfs_restore_recursion(dev, &bufpos, &buflen, &pos,
    185             ops->root_get(dev)))
     185        rc = ops->root_get(&fn, dev);
     186        if (rc != EOK)
     187                goto error;
     188
     189        if (!tmpfs_restore_recursion(dev, &bufpos, &buflen, &pos, fn))
    186190                goto error;
    187191               
  • uspace/srv/fs/tmpfs/tmpfs_ops.c

    r0daba21 r54e4479  
    6767
    6868/* Forward declarations of static functions. */
    69 static fs_node_t *tmpfs_match(fs_node_t *, const char *);
    70 static fs_node_t *tmpfs_node_get(dev_handle_t, fs_index_t);
    71 static void tmpfs_node_put(fs_node_t *);
    72 static fs_node_t *tmpfs_create_node(dev_handle_t, int);
     69static int tmpfs_match(fs_node_t **, fs_node_t *, const char *);
     70static int tmpfs_node_get(fs_node_t **, dev_handle_t, fs_index_t);
     71static int tmpfs_node_put(fs_node_t *);
     72static int tmpfs_create_node(fs_node_t **, dev_handle_t, int);
     73static int tmpfs_destroy_node(fs_node_t *);
    7374static int tmpfs_link_node(fs_node_t *, fs_node_t *, const char *);
    7475static int tmpfs_unlink_node(fs_node_t *, fs_node_t *, const char *);
    75 static int tmpfs_destroy_node(fs_node_t *);
    7676
    7777/* Implementation of helper functions. */
     78static 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
     83static 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
    7889static fs_index_t tmpfs_index_get(fs_node_t *fn)
    7990{
     
    89100{
    90101        return TMPFS_NODE(fn)->lnkcnt;
    91 }
    92 
    93 static bool tmpfs_has_children(fs_node_t *fn)
    94 {
    95         return !list_empty(&TMPFS_NODE(fn)->cs_head);
    96 }
    97 
    98 static fs_node_t *tmpfs_root_get(dev_handle_t dev_handle)
    99 {
    100         return tmpfs_node_get(dev_handle, TMPFS_SOME_ROOT);
    101102}
    102103
     
    118119/** libfs operations */
    119120libfs_ops_t tmpfs_libfs_ops = {
     121        .root_get = tmpfs_root_get,
    120122        .match = tmpfs_match,
    121123        .node_get = tmpfs_node_get,
     
    125127        .link = tmpfs_link_node,
    126128        .unlink = tmpfs_unlink_node,
     129        .has_children = tmpfs_has_children,
    127130        .index_get = tmpfs_index_get,
    128131        .size_get = tmpfs_size_get,
    129132        .lnkcnt_get = tmpfs_lnkcnt_get,
    130         .has_children = tmpfs_has_children,
    131         .root_get = tmpfs_root_get,
    132133        .plb_get_char = tmpfs_plb_get_char,
    133134        .is_directory = tmpfs_is_directory,
     
    197198{
    198199        fs_node_t *rfn;
     200        int rc;
    199201       
    200         rfn = tmpfs_create_node(dev_handle, L_DIRECTORY);
    201         if (!rfn)
     202        rc = tmpfs_create_node(&rfn, dev_handle, L_DIRECTORY);
     203        if (rc != EOK || !rfn)
    202204                return false;
    203205        TMPFS_NODE(rfn)->lnkcnt = 0;    /* FS root is not linked */
     
    205207}
    206208
    207 fs_node_t *tmpfs_match(fs_node_t *pfn, const char *component)
     209int tmpfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
    208210{
    209211        tmpfs_node_t *parentp = TMPFS_NODE(pfn);
     
    212214        for (lnk = parentp->cs_head.next; lnk != &parentp->cs_head;
    213215            lnk = lnk->next) {
    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 
    223 fs_node_t *tmpfs_node_get(dev_handle_t dev_handle, fs_index_t index)
     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
     228int tmpfs_node_get(fs_node_t **rfn, dev_handle_t dev_handle, fs_index_t index)
    224229{
    225230        unsigned long key[] = {
     
    228233        };
    229234        link_t *lnk = hash_table_find(&nodes, key);
    230         if (!lnk)
    231                 return NULL;
    232         return FS_NODE(hash_table_get_instance(lnk, tmpfs_node_t, nh_link));
    233 }
    234 
    235 void tmpfs_node_put(fs_node_t *fn)
     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
     245int tmpfs_node_put(fs_node_t *fn)
    236246{
    237247        /* nothing to do */
    238 }
    239 
    240 fs_node_t *tmpfs_create_node(dev_handle_t dev_handle, int lflag)
    241 {
     248        return EOK;
     249}
     250
     251int tmpfs_create_node(fs_node_t **rfn, dev_handle_t dev_handle, int lflag)
     252{
     253        fs_node_t *rootfn;
     254        int rc;
     255
    242256        assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
    243257
    244258        tmpfs_node_t *nodep = malloc(sizeof(tmpfs_node_t));
    245259        if (!nodep)
    246                 return NULL;
     260                return ENOMEM;
    247261        tmpfs_node_initialize(nodep);
    248262        nodep->bp = malloc(sizeof(fs_node_t));
    249263        if (!nodep->bp) {
    250264                free(nodep);
    251                 return NULL;
     265                return ENOMEM;
    252266        }
    253267        fs_node_initialize(nodep->bp);
    254268        nodep->bp->data = nodep;        /* link the FS and TMPFS nodes */
    255         if (!tmpfs_root_get(dev_handle))
     269
     270        rc = tmpfs_root_get(&rootfn, dev_handle);
     271        assert(rc == EOK);
     272        if (!rootfn)
    256273                nodep->index = TMPFS_SOME_ROOT;
    257274        else
     
    269286        };
    270287        hash_table_insert(&nodes, key, &nodep->nh_link);
    271         return FS_NODE(nodep);
     288        *rfn = FS_NODE(nodep);
     289        return EOK;
     290}
     291
     292int 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;
    272310}
    273311
     
    343381}
    344382
    345 int 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 
    365383void tmpfs_mounted(ipc_callid_t rid, ipc_call_t *request)
    366384{
    367385        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
     386        int rc;
    368387
    369388        /* accept the mount options */
     
    395414        }
    396415
    397         tmpfs_node_t *rootp = TMPFS_NODE(tmpfs_root_get(dev_handle));
     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);
    398420        if (str_cmp(opts, "restore") == 0) {
    399421                if (tmpfs_restore(dev_handle))
Note: See TracChangeset for help on using the changeset viewer.