Changeset 8565a42 in mainline for uspace/srv/fs/tmpfs


Ignore:
Timestamp:
2018-03-02T20:34:50Z (8 years ago)
Author:
GitHub <noreply@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a1a81f69, d5e5fd1
Parents:
3061bc1 (diff), 34e1206 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:34:50)
git-committer:
GitHub <noreply@…> (2018-03-02 20:34:50)
Message:

Remove all trailing whitespace, everywhere.

See individual commit messages for details.

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

Legend:

Unmodified
Added
Removed

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

    r3061bc1 r8565a42  
    7575                }
    7676        }
    77        
     77
    7878        if (!tmpfs_init()) {
    7979                printf(NAME ": failed to initialize TMPFS\n");
    8080                return -1;
    8181        }
    82        
     82
    8383        async_sess_t *vfs_sess = service_connect_blocking(SERVICE_VFS,
    8484            INTERFACE_VFS_DRIVER, 0);
    … …  
    8787                return -1;
    8888        }
    89        
     89
    9090        errno_t rc = fs_register(vfs_sess, &tmpfs_vfs_info, &tmpfs_ops,
    9191            &tmpfs_libfs_ops);
    … …  
    9494                return rc;
    9595        }
    96        
     96
    9797        printf(NAME ": Accepting connections\n");
    9898        task_retval(0);
    9999        async_manager();
    100        
     100
    101101        /* Not reached */
    102102        return 0;

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

    r3061bc1 r8565a42  
    6464        libfs_ops_t *ops = &tmpfs_libfs_ops;
    6565        errno_t rc;
    66        
     66
    6767        do {
    6868                char *fname;
    … …  
    7070                tmpfs_node_t *nodep;
    7171                uint32_t size;
    72                
     72
    7373                if (block_seqread(dsid, tmpfs_buf, bufpos, buflen, pos, &entry,
    7474                    sizeof(entry)) != EOK)
    7575                        return false;
    76                
     76
    7777                entry.len = uint32_t_le2host(entry.len);
    78                
     78
    7979                switch (entry.type) {
    8080                case TMPFS_NONE:
    … …  
    8484                        if (fname == NULL)
    8585                                return false;
    86                        
     86
    8787                        rc = ops->create(&fn, dsid, L_FILE);
    8888                        if (rc != EOK || fn == NULL) {
    … …  
    9090                                return false;
    9191                        }
    92                        
     92
    9393                        if (block_seqread(dsid, tmpfs_buf, bufpos, buflen, pos, fname,
    9494                            entry.len) != EOK) {
    … …  
    9898                        }
    9999                        fname[entry.len] = 0;
    100                        
     100
    101101                        rc = ops->link(pfn, fn, fname);
    102102                        if (rc != EOK) {
    … …  
    106106                        }
    107107                        free(fname);
    108                        
     108
    109109                        if (block_seqread(dsid, tmpfs_buf, bufpos, buflen, pos, &size,
    110110                            sizeof(size)) != EOK)
    111111                                return false;
    112                        
     112
    113113                        size = uint32_t_le2host(size);
    114                        
     114
    115115                        nodep = TMPFS_NODE(fn);
    116116                        nodep->data = malloc(size);
    117117                        if (nodep->data == NULL)
    118118                                return false;
    119                        
     119
    120120                        nodep->size = size;
    121121                        if (block_seqread(dsid, tmpfs_buf, bufpos, buflen, pos, nodep->data,
    122122                            size) != EOK)
    123123                                return false;
    124                        
     124
    125125                        break;
    126126                case TMPFS_DIRECTORY:
    … …  
    128128                        if (fname == NULL)
    129129                                return false;
    130                        
     130
    131131                        rc = ops->create(&fn, dsid, L_DIRECTORY);
    132132                        if (rc != EOK || fn == NULL) {
    … …  
    134134                                return false;
    135135                        }
    136                        
     136
    137137                        if (block_seqread(dsid, tmpfs_buf, bufpos, buflen, pos, fname,
    138138                            entry.len) != EOK) {
    … …  
    150150                        }
    151151                        free(fname);
    152                        
     152
    153153                        if (!tmpfs_restore_recursion(dsid, bufpos, buflen, pos,
    154154                            fn))
    155155                                return false;
    156                        
     156
    157157                        break;
    158158                default:
    … …  
    160160                }
    161161        } while (entry.type != TMPFS_NONE);
    162        
     162
    163163        return true;
    164164}
    … …  
    173173        if (rc != EOK)
    174174                return false;
    175        
     175
    176176        size_t bufpos = 0;
    177177        size_t buflen = 0;
    178178        aoff64_t pos = 0;
    179        
     179
    180180        char tag[6];
    181181        if (block_seqread(dsid, tmpfs_buf, &bufpos, &buflen, &pos, tag, 5) != EOK)
    182182                goto error;
    183        
     183
    184184        tag[5] = 0;
    185185        if (str_cmp(tag, "TMPFS") != 0)
    186186                goto error;
    187        
     187
    188188        rc = ops->root_get(&fn, dsid);
    189189        if (rc != EOK)
    … …  
    192192        if (!tmpfs_restore_recursion(dsid, &bufpos, &buflen, &pos, fn))
    193193                goto error;
    194                
     194
    195195        block_fini(dsid);
    196196        return true;
    197        
     197
    198198error:
    199199        block_fini(dsid);

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

    r3061bc1 r8565a42  
    163163        tmpfs_node_t *node = hash_table_get_inst(item, tmpfs_node_t, nh_link);
    164164        node_key_t *key = (node_key_t *)key_arg;
    165        
     165
    166166        return key->service_id == node->service_id && key->index == node->index;
    167167}
    … …  
    220220        if (!hash_table_create(&nodes, 0, 0, &nodes_ops))
    221221                return false;
    222        
     222
    223223        return true;
    224224}
    … …  
    228228        fs_node_t *rfn;
    229229        errno_t rc;
    230        
     230
    231231        rc = tmpfs_create_node(&rfn, service_id, L_DIRECTORY);
    232232        if (rc != EOK || !rfn)
    … …  
    240240        service_id_t sid = *(service_id_t*)arg;
    241241        tmpfs_node_t *node = hash_table_get_inst(item, tmpfs_node_t, nh_link);
    242        
     242
    243243        if (node->service_id == sid) {
    244244                hash_table_remove_item(&nodes, &node->nh_link);
    … …  
    273273                .index = index
    274274        };
    275        
     275
    276276        ht_link_t *lnk = hash_table_find(&nodes, &key);
    277        
     277
    278278        if (lnk) {
    279279                tmpfs_node_t *nodep;
    … …  
    338338{
    339339        tmpfs_node_t *nodep = TMPFS_NODE(fn);
    340        
     340
    341341        assert(!nodep->lnkcnt);
    342342        assert(list_empty(&nodep->cs_list));
    343        
     343
    344344        hash_table_remove_item(&nodes, &nodep->nh_link);
    345345
    … …  
    406406        if (!childp)
    407407                return ENOENT;
    408                
     408
    409409        if ((childp->lnkcnt == 1) && !list_empty(&childp->cs_list))
    410410                return ENOTEMPTY;
    … …  
    432432        fs_node_t *rootfn;
    433433        errno_t rc;
    434        
     434
    435435        /* Check if this device is not already mounted. */
    436436        rc = tmpfs_root_get(&rootfn, service_id);
    … …  
    474474                .index = index
    475475        };
    476        
     476
    477477        ht_link_t *hlp = hash_table_find(&nodes, &key);
    478478        if (!hlp)
    479479                return ENOENT;
    480        
     480
    481481        tmpfs_node_t *nodep = hash_table_get_inst(hlp, tmpfs_node_t, nh_link);
    482        
     482
    483483        /*
    484484         * Receive the read request.
    … …  
    499499                tmpfs_dentry_t *dentryp;
    500500                link_t *lnk;
    501                
     501
    502502                assert(nodep->type == TMPFS_DIRECTORY);
    503                
     503
    504504                /*
    505505                 * Yes, we really use O(n) algorithm here.
    … …  
    508508                 */
    509509                lnk = list_nth(&nodep->cs_list, pos);
    510                
     510
    511511                if (lnk == NULL) {
    512512                        async_answer_0(callid, ENOENT);
    … …  
    536536                .index = index
    537537        };
    538        
     538
    539539        ht_link_t *hlp = hash_table_find(&nodes, &key);
    540        
     540
    541541        if (!hlp)
    542542                return ENOENT;
    543        
     543
    544544        tmpfs_node_t *nodep = hash_table_get_inst(hlp, tmpfs_node_t, nh_link);
    545545
    … …  
    599599                .index = index
    600600        };
    601        
     601
    602602        ht_link_t *hlp = hash_table_find(&nodes, &key);
    603        
     603
    604604        if (!hlp)
    605605                return ENOENT;
    606606        tmpfs_node_t *nodep = hash_table_get_inst(hlp, tmpfs_node_t, nh_link);
    607        
     607
    608608        if (size == nodep->size)
    609609                return EOK;
    610        
     610
    611611        if (size > SIZE_MAX)
    612612                return ENOMEM;
    613        
     613
    614614        void *newdata = realloc(nodep->data, size);
    615615        if (!newdata)
    616616                return ENOMEM;
    617        
     617
    618618        if (size > nodep->size) {
    619619                size_t delta = size - nodep->size;
    620620                memset(newdata + nodep->size, 0, delta);
    621621        }
    622        
     622
    623623        nodep->size = size;
    624624        nodep->data = newdata;
    … …  
    637637                .index = index
    638638        };
    639        
     639
    640640        ht_link_t *hlp = hash_table_find(&nodes, &key);
    641641        if (!hlp)
Note: See TracChangeset for help on using the changeset viewer.