Changeset 5614c7f in mainline


Ignore:
Timestamp:
2012-01-21T12:52:50Z (13 years ago)
Author:
Frantisek Princ <frantisek.princ@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
47a89fe
Parents:
73196d2
Message:

Code refactiorization - local variables declarations moved by principle of locality

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/fs/ext4fs/ext4fs_ops.c

    r73196d2 r5614c7f  
    169169int ext4fs_instance_get(service_id_t service_id, ext4fs_instance_t **inst)
    170170{
    171         ext4fs_instance_t *tmp;
    172 
    173171        fibril_mutex_lock(&instance_list_mutex);
    174172
    … …  
    178176        }
    179177
     178        ext4fs_instance_t *tmp;
    180179        list_foreach(instance_list, link) {
    181180                tmp = list_get_instance(link, ext4fs_instance_t, link);
    … …  
    201200int ext4fs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
    202201{
     202        int rc;
     203
    203204        ext4fs_node_t *eparent = EXT4FS_NODE(pfn);
    204         ext4_filesystem_t *fs;
    205         ext4_directory_iterator_t it;
    206         int rc;
    207 
    208         fs = eparent->instance->filesystem;
     205        ext4_filesystem_t *fs = eparent->instance->filesystem;
    209206
    210207        if (!ext4_inode_is_type(fs->superblock, eparent->inode_ref->inode,
    … …  
    213210        }
    214211
     212        ext4_directory_iterator_t it;
    215213        rc = ext4_directory_iterator_init(&it, fs, eparent->inode_ref, 0);
    216214        if (rc != EOK) {
    … …  
    239237int ext4fs_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
    240238{
    241         ext4fs_instance_t *inst = NULL;
    242         int rc;
    243 
     239        int rc;
     240
     241        ext4fs_instance_t *inst;
    244242        rc = ext4fs_instance_get(service_id, &inst);
    245243        if (rc != EOK) {
    … …  
    255253{
    256254        int rc;
    257         fs_node_t *node = NULL;
    258         ext4fs_node_t *enode = NULL;
    259 
    260         ext4_inode_ref_t *inode_ref = NULL;
    261255
    262256        fibril_mutex_lock(&open_nodes_lock);
    … …  
    267261                [OPEN_NODES_INODE_KEY] = index,
    268262        };
     263
    269264        link_t *already_open = hash_table_find(&open_nodes, key);
    270 
     265        ext4fs_node_t *enode = NULL;
    271266        if (already_open) {
    272267                enode = hash_table_get_instance(already_open, ext4fs_node_t, link);
    … …  
    284279        }
    285280
    286         node = malloc(sizeof(fs_node_t));
    287         if (node == NULL) {
     281        fs_node_t *fs_node = malloc(sizeof(fs_node_t));
     282        if (fs_node == NULL) {
    288283                free(enode);
    289284                fibril_mutex_unlock(&open_nodes_lock);
    290285                return ENOMEM;
    291286        }
    292         fs_node_initialize(node);
    293 
     287        fs_node_initialize(fs_node);
     288
     289        ext4_inode_ref_t *inode_ref;
    294290        rc = ext4_filesystem_get_inode_ref(inst->filesystem, index, &inode_ref);
    295291        if (rc != EOK) {
    296292                free(enode);
    297                 free(node);
     293                free(fs_node);
    298294                fibril_mutex_unlock(&open_nodes_lock);
    299295                return rc;
    … …  
    303299        enode->instance = inst;
    304300        enode->references = 1;
    305         enode->fs_node = node;
     301        enode->fs_node = fs_node;
    306302        link_initialize(&enode->link);
    307303
    308         node->data = enode;
    309         *rfn = node;
     304        fs_node->data = enode;
     305        *rfn = fs_node;
    310306
    311307        hash_table_insert(&open_nodes, key, &enode->link);
    … …  
    351347{
    352348        int rc;
     349
     350        fibril_mutex_lock(&open_nodes_lock);
     351
    353352        ext4fs_node_t *enode = EXT4FS_NODE(fn);
    354 
    355         fibril_mutex_lock(&open_nodes_lock);
    356 
    357353        assert(enode->references > 0);
    358354        enode->references--;
    … …  
    412408        }
    413409
    414 
    415410        // TODO set real deletion time
    416411//      time_t now = time(NULL);
    … …  
    511506int ext4fs_has_children(bool *has_children, fs_node_t *fn)
    512507{
     508        int rc;
     509
    513510        ext4fs_node_t *enode = EXT4FS_NODE(fn);
    514         ext4_directory_iterator_t it;
    515         ext4_filesystem_t *fs;
    516         int rc;
    517         bool found = false;
    518         size_t name_size;
    519 
    520         fs = enode->instance->filesystem;
     511        ext4_filesystem_t *fs = enode->instance->filesystem;
    521512
    522513        if (!ext4_inode_is_type(fs->superblock, enode->inode_ref->inode,
    … …  
    526517        }
    527518
     519        ext4_directory_iterator_t it;
    528520        rc = ext4_directory_iterator_init(&it, fs, enode->inode_ref, 0);
    529521        if (rc != EOK) {
    … …  
    532524
    533525        /* Find a non-empty directory entry */
     526        bool found = false;
    534527        while (it.current != NULL) {
    535528                if (it.current->inode != 0) {
    536                         name_size = ext4_directory_entry_ll_get_name_length(fs->superblock,
     529                        uint16_t name_size = ext4_directory_entry_ll_get_name_length(fs->superblock,
    537530                                it.current);
    538531                        if (!ext4fs_is_dots(it.current->name, name_size)) {
    … …  
    570563{
    571564        ext4fs_node_t *enode = EXT4FS_NODE(fn);
    572         aoff64_t size = ext4_inode_get_size(
    573                         enode->instance->filesystem->superblock, enode->inode_ref->inode);
    574         return size;
     565        ext4_superblock_t *sb = enode->instance->filesystem->superblock;
     566        return ext4_inode_get_size(sb, enode->inode_ref->inode);
    575567}
    576568
    … …  
    597589{
    598590        ext4fs_node_t *enode = EXT4FS_NODE(fn);
    599         bool is_dir = ext4_inode_is_type(enode->instance->filesystem->superblock,
    600             enode->inode_ref->inode, EXT4_INODE_MODE_DIRECTORY);
    601         return is_dir;
     591        ext4_superblock_t *sb = enode->instance->filesystem->superblock;
     592        return ext4_inode_is_type(
     593                        sb, enode->inode_ref->inode, EXT4_INODE_MODE_DIRECTORY);
    602594}
    603595
    … …  
    606598{
    607599        ext4fs_node_t *enode = EXT4FS_NODE(fn);
    608         bool is_file = ext4_inode_is_type(enode->instance->filesystem->superblock,
    609             enode->inode_ref->inode, EXT4_INODE_MODE_FILE);
    610         return is_file;
     600        ext4_superblock_t *sb = enode->instance->filesystem->superblock;
     601        return ext4_inode_is_type(
     602                        sb, enode->inode_ref->inode, EXT4_INODE_MODE_FILE);
    611603}
    612604
    … …  
    649641{
    650642        int rc;
     643
     644        /* Allocate libext4 filesystem structure */
    651645        ext4_filesystem_t *fs;
    652         ext4fs_instance_t *inst;
    653         bool read_only;
    654 
    655         /* Allocate libext4 filesystem structure */
    656646        fs = (ext4_filesystem_t *) malloc(sizeof(ext4_filesystem_t));
    657647        if (fs == NULL) {
    … …  
    660650
    661651        /* Allocate instance structure */
     652        ext4fs_instance_t *inst;
    662653        inst = (ext4fs_instance_t *) malloc(sizeof(ext4fs_instance_t));
    663654        if (inst == NULL) {
    … …  
    684675
    685676        /* Check flags */
     677        bool read_only;
    686678        rc = ext4_filesystem_check_features(fs, &read_only);
    687679        if (rc != EOK) {
    … …  
    726718{
    727719        int rc;
     720
    728721        ext4fs_instance_t *inst;
    729 
    730722        rc = ext4fs_instance_get(service_id, &inst);
    731 
    732723        if (rc != EOK) {
    733724                return rc;
    … …  
    755746                aoff64_t pos, size_t *rbytes)
    756747{
    757         ext4fs_instance_t *inst;
    758         ext4_inode_ref_t *inode_ref;
    759748        int rc;
    760749
    … …  
    769758        }
    770759
     760        ext4fs_instance_t *inst;
    771761        rc = ext4fs_instance_get(service_id, &inst);
    772762        if (rc != EOK) {
    … …  
    775765        }
    776766
     767        ext4_inode_ref_t *inode_ref;
    777768        rc = ext4_filesystem_get_inode_ref(inst->filesystem, index, &inode_ref);
    778769        if (rc != EOK) {
    … …  
    816807    ext4fs_instance_t *inst, ext4_inode_ref_t *inode_ref, size_t *rbytes)
    817808{
     809        int rc;
     810
    818811        ext4_directory_iterator_t it;
    819         aoff64_t next;
    820         uint8_t *buf;
    821         size_t name_size;
    822         int rc;
    823         bool found = false;
    824 
    825812        rc = ext4_directory_iterator_init(&it, inst->filesystem, inode_ref, pos);
    826813        if (rc != EOK) {
    … …  
    833820         * as these are not used in HelenOS
    834821         */
     822        bool found = false;
    835823        while (it.current != NULL) {
    836824
    … …  
    839827                }
    840828
    841                 name_size = ext4_directory_entry_ll_get_name_length(
     829                uint16_t name_size = ext4_directory_entry_ll_get_name_length(
    842830                    inst->filesystem->superblock, it.current);
    843831
    … …  
    851839                 * and add the \0 at the end
    852840                 */
    853                 buf = malloc(name_size+1);
     841                uint8_t *buf = malloc(name_size+1);
    854842                if (buf == NULL) {
    855843                        ext4_directory_iterator_fini(&it);
    … …  
    873861        }
    874862
     863        uint64_t next;
    875864        if (found) {
    876865                rc = ext4_directory_iterator_next(&it);
    … …  
    899888{
    900889        int rc;
    901         uint32_t block_size;
    902         aoff64_t file_block;
    903         uint64_t file_size;
    904         uint32_t fs_block;
    905         size_t offset_in_block;
    906         size_t bytes;
    907         block_t *block;
    908         uint8_t *buffer;
    909 
    910         file_size = ext4_inode_get_size(inst->filesystem->superblock,
    911                 inode_ref->inode);
     890
     891        ext4_superblock_t *sb = inst->filesystem->superblock;
     892        uint64_t file_size = ext4_inode_get_size(sb, inode_ref->inode);
    912893
    913894        if (pos >= file_size) {
    … …  
    919900
    920901        /* For now, we only read data from one block at a time */
    921         block_size = ext4_superblock_get_block_size(inst->filesystem->superblock);
    922         file_block = pos / block_size;
    923         offset_in_block = pos % block_size;
    924         bytes = min(block_size - offset_in_block, size);
     902        uint32_t block_size = ext4_superblock_get_block_size(sb);
     903        aoff64_t file_block = pos / block_size;
     904        uint32_t offset_in_block = pos % block_size;
     905        uint32_t bytes = min(block_size - offset_in_block, size);
    925906
    926907        /* Handle end of file */
    … …  
    930911
    931912        /* Get the real block number */
     913        uint32_t fs_block;
    932914        rc = ext4_filesystem_get_inode_data_block_index(inst->filesystem,
    933915                inode_ref->inode, file_block, &fs_block);
    … …  
    942924         * file and we need to return a buffer of zeros
    943925         */
     926        uint8_t *buffer;
    944927        if (fs_block == 0) {
    945928                buffer = malloc(bytes);
    … …  
    960943
    961944        /* Usual case - we need to read a block from device */
     945        block_t *block;
    962946        rc = block_get(&block, inst->service_id, fs_block, BLOCK_FLAGS_NONE);
    963947        if (rc != EOK) {
    … …  
    982966{
    983967        int rc;
    984         int flags = BLOCK_FLAGS_NONE;
     968
    985969        fs_node_t *fn;
    986         ext4fs_node_t *enode;
    987         ext4_filesystem_t *fs;
    988         ext4_inode_ref_t *inode_ref;
     970        rc = ext4fs_node_get(&fn, service_id, index);
     971        if (rc != EOK) {
     972                EXT4FS_DBG("node get error");
     973                return rc;
     974        }
     975
    989976        ipc_callid_t callid;
    990         size_t len, bytes, block_size;
    991         block_t *write_block;
    992         uint32_t fblock, iblock;
    993         uint32_t old_inode_size;
    994 
    995         rc = ext4fs_node_get(&fn, service_id, index);
    996         if (rc != EOK) {
    997                 EXT4FS_DBG("node get error");
    998                 return rc;
    999         }
    1000 
     977        size_t len;
    1001978        if (!async_data_write_receive(&callid, &len)) {
    1002979                rc = EINVAL;
    … …  
    1008985
    1009986
    1010         enode = EXT4FS_NODE(fn);
    1011         inode_ref = enode->inode_ref;
    1012         fs = enode->instance->filesystem;
    1013 
    1014         block_size = ext4_superblock_get_block_size(fs->superblock);
     987        ext4fs_node_t *enode = EXT4FS_NODE(fn);
     988        ext4_filesystem_t *fs = enode->instance->filesystem;
     989
     990        uint32_t block_size = ext4_superblock_get_block_size(fs->superblock);
    1015991
    1016992        // Prevent writing to more than one block
    1017         bytes = min(len, block_size - (pos % block_size));
    1018 
     993        uint32_t bytes = min(len, block_size - (pos % block_size));
     994
     995        int flags = BLOCK_FLAGS_NONE;
    1019996        if (bytes == block_size) {
    1020997                flags = BLOCK_FLAGS_NOREAD;
    1021998        }
    1022999
    1023         iblock =  pos / block_size;
    1024 
     1000        uint32_t iblock =  pos / block_size;
     1001        uint32_t fblock;
     1002
     1003        ext4_inode_ref_t *inode_ref = enode->inode_ref;
    10251004        rc = ext4_filesystem_get_inode_data_block_index(fs, inode_ref->inode, iblock, &fblock);
    10261005        if (rc != EOK) {
    … …  
    10481027        }
    10491028
     1029        block_t *write_block;
    10501030        rc = block_get(&write_block, service_id, fblock, flags);
    10511031        if (rc != EOK) {
    … …  
    10751055        }
    10761056
    1077         old_inode_size = ext4_inode_get_size(fs->superblock, inode_ref->inode);
     1057        uint32_t old_inode_size = ext4_inode_get_size(fs->superblock, inode_ref->inode);
    10781058        if (pos + bytes > old_inode_size) {
    10791059                ext4_inode_set_size(inode_ref->inode, pos + bytes);
    … …  
    10921072{
    10931073        int rc;
     1074
    10941075        fs_node_t *fn;
    1095 
    10961076        rc = ext4fs_node_get(&fn, service_id, index);
    10971077        if (rc != EOK) {
    … …  
    11191099{
    11201100        int rc;
     1101
    11211102        fs_node_t *fn;
    1122 
    11231103        rc = ext4fs_node_get(&fn, service_id, index);
    11241104        if (rc != EOK) {
    … …  
    11341114{
    11351115        int rc;
     1116
    11361117        fs_node_t *fn;
    1137         ext4fs_node_t *enode;
    1138 
    11391118        rc = ext4fs_node_get(&fn, service_id, index);
    11401119        if (rc != EOK) {
    … …  
    11421121        }
    11431122
    1144         enode = EXT4FS_NODE(fn);
     1123        ext4fs_node_t *enode = EXT4FS_NODE(fn);
    11451124        enode->inode_ref->dirty = true;
    11461125
Note: See TracChangeset for help on using the changeset viewer.