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

Changeset cf982ff in mainline


Ignore:
Timestamp:
2014-01-28T21:08:38Z (8 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master
Children:
0dd022ec
Parents:
476f62c (diff), 5828554 (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.
Message:

merge libext4 fixes

Location:
uspace
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/ext4/libext4_balloc.c

    r476f62c rcf982ff  
    9191        block_t *bitmap_block;
    9292        rc = block_get(&bitmap_block, fs->device, bitmap_block_addr, 0);
    93         if (rc != EOK)
    94                 return rc;
     93        if (rc != EOK) {
     94                ext4_filesystem_put_block_group_ref(bg_ref);
     95                return rc;
     96        }
    9597       
    9698        /* Modify bitmap */
     
    130132       
    131133        /* Release block group reference */
    132         rc = ext4_filesystem_put_block_group_ref(bg_ref);
    133         if (rc != EOK)
    134                 return rc;
    135        
    136         return EOK;
     134        return ext4_filesystem_put_block_group_ref(bg_ref);
    137135}
    138136
     
    173171        block_t *bitmap_block;
    174172        rc = block_get(&bitmap_block, fs->device, bitmap_block_addr, 0);
    175         if (rc != EOK)
    176                 return rc;
     173        if (rc != EOK) {
     174                ext4_filesystem_put_block_group_ref(bg_ref);
     175                return rc;
     176        }
    177177       
    178178        /* Modify bitmap */
     
    212212       
    213213        /* Release block group reference */
    214         rc = ext4_filesystem_put_block_group_ref(bg_ref);
    215         if (rc != EOK)
    216                 return rc;
    217        
    218         return EOK;
     214        return ext4_filesystem_put_block_group_ref(bg_ref);
    219215}
    220216
     
    264260 *
    265261 */
    266 static uint32_t ext4_balloc_find_goal(ext4_inode_ref_t *inode_ref)
     262static int ext4_balloc_find_goal(ext4_inode_ref_t *inode_ref, uint32_t *goal)
    267263{
    268         uint32_t goal = 0;
    269        
     264        *goal = 0;
    270265        ext4_superblock_t *sb = inode_ref->fs->superblock;
    271266       
     
    280275        if (inode_block_count > 0) {
    281276                int rc = ext4_filesystem_get_inode_data_block_index(inode_ref,
    282                     inode_block_count - 1, &goal);
     277                    inode_block_count - 1, goal);
    283278                if (rc != EOK)
    284                         return 0;
     279                        return rc;
    285280               
    286281                if (goal != 0) {
    287                         goal++;
    288                         return goal;
     282                        (*goal)++;
     283                        return EOK;
    289284                }
    290285               
     
    302297            block_group, &bg_ref);
    303298        if (rc != EOK)
    304                 return 0;
     299                return rc;
    305300       
    306301        /* Compute indexes */
     
    327322                inode_table_blocks++;
    328323       
    329         goal = inode_table_first_block + inode_table_blocks;
    330        
    331         ext4_filesystem_put_block_group_ref(bg_ref);
    332        
    333         return goal;
     324        *goal = inode_table_first_block + inode_table_blocks;
     325       
     326        return ext4_filesystem_put_block_group_ref(bg_ref);
    334327}
    335328
     
    349342        block_t *bitmap_block;
    350343        uint32_t rel_block_idx = 0;
     344        uint32_t goal;
    351345       
    352346        /* Find GOAL */
    353         uint32_t goal = ext4_balloc_find_goal(inode_ref);
    354         if (goal == 0) {
     347        int rc = ext4_balloc_find_goal(inode_ref, &goal);
     348        if (rc != EOK)
     349                return rc;
     350        else if (goal == 0) {
    355351                /* no goal found => partition is full */
    356                 return ENOSPC;
     352                return ENOMEM;
    357353        }
    358354       
     
    366362        /* Load block group reference */
    367363        ext4_block_group_ref_t *bg_ref;
    368         int rc = ext4_filesystem_get_block_group_ref(inode_ref->fs,
     364        rc = ext4_filesystem_get_block_group_ref(inode_ref->fs,
    369365            block_group, &bg_ref);
    370366        if (rc != EOK)
     
    467463       
    468464        /* No free block found yet */
    469         block_put(bitmap_block);
    470         ext4_filesystem_put_block_group_ref(bg_ref);
     465        rc = block_put(bitmap_block);
     466        if (rc != EOK) {
     467                ext4_filesystem_put_block_group_ref(bg_ref);
     468                return rc;
     469        }
     470
     471        rc = ext4_filesystem_put_block_group_ref(bg_ref);
     472        if (rc != EOK)
     473                return rc;
    471474       
    472475        /* Try other block groups */
     
    512515                        bitmap_block->dirty = true;
    513516                        rc = block_put(bitmap_block);
    514                         if (rc != EOK)
     517                        if (rc != EOK) {
     518                                ext4_filesystem_put_block_group_ref(bg_ref);
    515519                                return rc;
     520                        }
    516521                       
    517522                        allocated_block =
     
    528533                        bitmap_block->dirty = true;
    529534                        rc = block_put(bitmap_block);
    530                         if (rc != EOK)
     535                        if (rc != EOK) {
     536                                ext4_filesystem_put_block_group_ref(bg_ref);
    531537                                return rc;
     538                        }
    532539                       
    533540                        allocated_block =
     
    538545                }
    539546               
    540                 block_put(bitmap_block);
    541                 ext4_filesystem_put_block_group_ref(bg_ref);
     547                rc = block_put(bitmap_block);
     548                if (rc != EOK) {
     549                        ext4_filesystem_put_block_group_ref(bg_ref);
     550                        return rc;
     551                }
     552
     553                rc = ext4_filesystem_put_block_group_ref(bg_ref);
     554                if (rc != EOK)
     555                        return rc;
    542556               
    543557                /* Goto next group */
     
    574588        bg_ref->dirty = true;
    575589       
    576         ext4_filesystem_put_block_group_ref(bg_ref);
     590        rc = ext4_filesystem_put_block_group_ref(bg_ref);
    577591       
    578592        *fblock = allocated_block;
    579         return EOK;
     593        return rc;
    580594}
    581595
     
    592606    bool *free)
    593607{
    594         int rc = EOK;
     608        int rc;
    595609       
    596610        ext4_filesystem_t *fs = inode_ref->fs;
     
    613627        block_t *bitmap_block;
    614628        rc = block_get(&bitmap_block, fs->device, bitmap_block_addr, 0);
    615         if (rc != EOK)
    616                 return rc;
     629        if (rc != EOK) {
     630                ext4_filesystem_put_block_group_ref(bg_ref);
     631                return rc;
     632        }
    617633       
    618634        /* Check if block is free */
  • uspace/lib/ext4/libext4_directory_index.c

    r476f62c rcf982ff  
    527527               
    528528                /* Don't forget to put old block (prevent memory leak) */
    529                 block_put(p->block);
     529                rc = block_put(p->block);
     530                if (rc != EOK)
     531                        return rc;
    530532               
    531533                p->block = block;
     
    553555        /* Load direct block 0 (index root) */
    554556        uint32_t root_block_addr;
     557        int rc2;
    555558        int rc = ext4_filesystem_get_inode_data_block_index(inode_ref, 0,
    556559            &root_block_addr);
     
    620623               
    621624                /* Not found, leave untouched */
    622                 block_put(leaf_block);
     625                rc2 = block_put(leaf_block);
     626                if (rc2 != EOK)
     627                        goto cleanup;
    623628               
    624629                if (rc != ENOENT)
     
    628633                rc = ext4_directory_dx_next_block(inode_ref, hinfo.hash,
    629634                    dx_block, &dx_blocks[0]);
    630                 if (rc < 0)
     635                if (rc != EOK)
    631636                        goto cleanup;
     637
    632638        } while (rc == ENOENT);
    633639       
     
    640646       
    641647        while (tmp <= dx_block) {
    642                 block_put(tmp->block);
     648                rc2 = block_put(tmp->block);
     649                if (rc == EOK && rc2 != EOK)
     650                        rc = rc2;
    643651                ++tmp;
    644652        }
  • uspace/lib/ext4/libext4_extent.c

    r476f62c rcf982ff  
    371371    uint32_t *fblock)
    372372{
     373        int rc;
    373374        /* Compute bound defined by i-node size */
    374375        uint64_t inode_size =
     
    400401                uint64_t child = ext4_extent_index_get_leaf(index);
    401402               
    402                 if (block != NULL)
    403                         block_put(block);
    404                
    405                 int rc = block_get(&block, inode_ref->fs->device, child,
     403                if (block != NULL) {
     404                        rc = block_put(block);
     405                        if (rc != EOK)
     406                                return rc;
     407                }
     408               
     409                rc = block_get(&block, inode_ref->fs->device, child,
    406410                    BLOCK_FLAGS_NONE);
    407411                if (rc != EOK)
     
    429433        /* Cleanup */
    430434        if (block != NULL)
    431                 block_put(block);
    432        
    433         return EOK;
     435                rc = block_put(block);
     436       
     437        return rc;
    434438}
    435439
     
    505509       
    506510cleanup:
     511        ;
     512
     513        int rc2 = EOK;
     514
    507515        /*
    508516         * Put loaded blocks
     
    510518         */
    511519        for (uint16_t i = 1; i < tmp_path->depth; ++i) {
    512                 if (tmp_path[i].block)
    513                         block_put(tmp_path[i].block);
     520                if (tmp_path[i].block) {
     521                        rc2 = block_put(tmp_path[i].block);
     522                        if (rc == EOK && rc2 != EOK)
     523                                rc = rc2;
     524                }
    514525        }
    515526       
     
    594605                return rc;
    595606       
    596         ext4_balloc_free_block(inode_ref, fblock);
    597        
    598         return EOK;
     607        return ext4_balloc_free_block(inode_ref, fblock);
    599608}
    600609
     
    721730       
    722731cleanup:
     732        ;
     733
     734        int rc2 = EOK;
     735
    723736        /*
    724737         * Put loaded blocks
     
    726739         */
    727740        for (uint16_t i = 1; i <= path->depth; ++i) {
    728                 if (path[i].block)
    729                         block_put(path[i].block);
     741                if (path[i].block) {
     742                        rc2 = block_put(path[i].block);
     743                        if (rc == EOK && rc2 != EOK)
     744                                rc = rc2;
     745                }
    730746        }
    731747       
     
    778794                       
    779795                        /* Put back not modified old block */
    780                         block_put(path_ptr->block);
     796                        rc = block_put(path_ptr->block);
     797                        if (rc != EOK) {
     798                                ext4_balloc_free_block(inode_ref, fblock);
     799                                return rc;
     800                        }
    781801                       
    782802                        /* Initialize newly allocated block and remember it */
     
    10611081       
    10621082finish:
     1083        ;
     1084
     1085        int rc2 = EOK;
     1086
    10631087        /* Set return values */
    10641088        *iblock = new_block_idx;
     
    10701094         */
    10711095        for (uint16_t i = 1; i <= path->depth; ++i) {
    1072                 if (path[i].block)
    1073                         block_put(path[i].block);
     1096                if (path[i].block) {
     1097                        rc2 = block_put(path[i].block);
     1098                        if (rc == EOK && rc2 != EOK)
     1099                                rc = rc2;
     1100                }
    10741101        }
    10751102       
  • uspace/lib/ext4/libext4_filesystem.c

    r476f62c rcf982ff  
    797797                }
    798798               
    799                 block_put(block);
     799                rc = block_put(block);
     800                if (rc != EOK)
     801                        return rc;
     802
    800803                rc = ext4_balloc_free_block(inode_ref, fblock);
    801804                if (rc != EOK)
     
    841844                                }
    842845                               
    843                                 block_put(subblock);
     846                                rc = block_put(subblock);
     847                                if (rc != EOK)
     848                                        return rc;
    844849                        }
    845850                       
     
    851856                }
    852857               
    853                 block_put(block);
     858                rc = block_put(block);
     859                if (rc != EOK)
     860                        return rc;
     861
    854862                rc = ext4_balloc_free_block(inode_ref, fblock);
    855863                if (rc != EOK)
  • uspace/lib/ext4/libext4_ialloc.c

    r476f62c rcf982ff  
    204204                        rc = block_get(&bitmap_block, fs->device, bitmap_block_addr,
    205205                            BLOCK_FLAGS_NONE);
    206                         if (rc != EOK)
     206                        if (rc != EOK) {
     207                                ext4_filesystem_put_block_group_ref(bg_ref);
    207208                                return rc;
     209                        }
    208210                       
    209211                        /* Try to allocate i-node in the bitmap */
     
    215217                        /* Block group has not any free i-node */
    216218                        if (rc == ENOSPC) {
    217                                 block_put(bitmap_block);
    218                                 ext4_filesystem_put_block_group_ref(bg_ref);
     219                                rc = block_put(bitmap_block);
     220                                if (rc != EOK) {
     221                                        ext4_filesystem_put_block_group_ref(bg_ref);
     222                                        return rc;
     223                                }
     224
     225                                rc = ext4_filesystem_put_block_group_ref(bg_ref);
     226                                if (rc != EOK)
     227                                        return rc;
     228
     229                                bgid++;
    219230                                continue;
    220231                        }
     
    224235                       
    225236                        rc = block_put(bitmap_block);
    226                         if (rc != EOK)
     237                        if (rc != EOK) {
     238                                ext4_filesystem_put_block_group_ref(bg_ref);
    227239                                return rc;
     240                        }
    228241                       
    229242                        /* Modify filesystem counters */
     
    272285               
    273286                /* Block group not modified, put it and jump to the next block group */
    274                 ext4_filesystem_put_block_group_ref(bg_ref);
     287                rc = ext4_filesystem_put_block_group_ref(bg_ref);
     288                if (rc != EOK)
     289                        return rc;
     290
    275291                ++bgid;
    276292        }
  • uspace/srv/fs/ext4fs/ext4fs_ops.c

    r476f62c rcf982ff  
    259259        rc = ext4fs_node_get_core(rfn, eparent->instance, inode);
    260260        if (rc != EOK)
    261                 return rc;
    262        
     261                goto exit;
     262
     263exit:
     264        ;
     265
    263266        /* Destroy search result structure */
    264         return ext4_directory_destroy_result(&result);
     267        int const rc2 = ext4_directory_destroy_result(&result);
     268        return rc == EOK ? rc2 : rc;
    265269}
    266270
     
    10021006        *lnkcnt = 1;
    10031007       
    1004         ext4fs_node_put(root_node);
    1005        
    1006         return EOK;
     1008        return ext4fs_node_put(root_node);
    10071009}
    10081010
     
    10931095        }
    10941096       
    1095         ext4_filesystem_put_inode_ref(inode_ref);
    1096        
    1097         return rc;
     1097        int const rc2 = ext4_filesystem_put_inode_ref(inode_ref);
     1098       
     1099        return rc == EOK ? rc2 : rc;
    10981100}
    10991101
     
    12681270                memset(buffer, 0, bytes);
    12691271               
    1270                 async_data_read_finalize(callid, buffer, bytes);
     1272                rc = async_data_read_finalize(callid, buffer, bytes);
    12711273                *rbytes = bytes;
    12721274               
    12731275                free(buffer);
    1274                 return EOK;
     1276                return rc;
    12751277        }
    12761278       
     
    12841286       
    12851287        assert(offset_in_block + bytes <= block_size);
    1286         async_data_read_finalize(callid, block->data + offset_in_block, bytes);
     1288        rc = async_data_read_finalize(callid, block->data + offset_in_block, bytes);
     1289        if (rc != EOK) {
     1290                block_put(block);
     1291                return rc;
     1292        }
    12871293       
    12881294        rc = block_put(block);
     
    13161322        size_t len;
    13171323        if (!async_data_write_receive(&callid, &len)) {
    1318                 ext4fs_node_put(fn);
    1319                 async_answer_0(callid, EINVAL);
    1320                 return EINVAL;
     1324                rc = EINVAL;
     1325                async_answer_0(callid, rc);
     1326                goto exit;
    13211327        }
    13221328       
     
    13411347            &fblock);
    13421348        if (rc != EOK) {
    1343                 ext4fs_node_put(fn);
    13441349                async_answer_0(callid, rc);
    1345                 return rc;
     1350                goto exit;
    13461351        }
    13471352       
     
    13591364                                    &fblock, true);
    13601365                                if (rc != EOK) {
    1361                                         ext4fs_node_put(fn);
    13621366                                        async_answer_0(callid, rc);
    1363                                         return rc;
     1367                                        goto exit;
    13641368                                }
    13651369                        }
     
    13681372                            &fblock, false);
    13691373                        if (rc != EOK) {
    1370                                 ext4fs_node_put(fn);
    13711374                                async_answer_0(callid, rc);
    1372                                 return rc;
     1375                                goto exit;
    13731376                        }
    13741377                } else {
    13751378                        rc = ext4_balloc_alloc_block(inode_ref, &fblock);
    13761379                        if (rc != EOK) {
    1377                                 ext4fs_node_put(fn);
    13781380                                async_answer_0(callid, rc);
    1379                                 return rc;
     1381                                goto exit;
    13801382                        }
    13811383                       
     
    13841386                        if (rc != EOK) {
    13851387                                ext4_balloc_free_block(inode_ref, fblock);
    1386                                 ext4fs_node_put(fn);
    13871388                                async_answer_0(callid, rc);
    1388                                 return rc;
     1389                                goto exit;
    13891390                        }
    13901391                }
     
    13981399        rc = block_get(&write_block, service_id, fblock, flags);
    13991400        if (rc != EOK) {
    1400                 ext4fs_node_put(fn);
    14011401                async_answer_0(callid, rc);
    1402                 return rc;
    1403         }
    1404        
    1405         if (flags == BLOCK_FLAGS_NOREAD)
     1402                goto exit;
     1403        }
     1404       
     1405        if (flags == BLOCK_FLAGS_NOREAD) {
    14061406                memset(write_block->data, 0, block_size);
    1407        
     1407                write_block->dirty = true;
     1408        }
     1409
    14081410        rc = async_data_write_finalize(callid, write_block->data +
    14091411            (pos % block_size), bytes);
    14101412        if (rc != EOK) {
    1411                 ext4fs_node_put(fn);
    1412                 return rc;
    1413         }
    1414        
    1415         write_block->dirty = true;
    1416        
     1413                block_put(write_block);
     1414                goto exit;
     1415        }
     1416
    14171417        rc = block_put(write_block);
    1418         if (rc != EOK) {
    1419                 ext4fs_node_put(fn);
    1420                 return rc;
    1421         }
    1422        
     1418        if (rc != EOK)
     1419                goto exit;
     1420
    14231421        /* Do some counting */
    14241422        uint32_t old_inode_size = ext4_inode_get_size(fs->superblock,
     
    14281426                inode_ref->dirty = true;
    14291427        }
    1430        
     1428
    14311429        *nsize = ext4_inode_get_size(fs->superblock, inode_ref->inode);
    14321430        *wbytes = bytes;
    1433        
    1434         return ext4fs_node_put(fn);
     1431
     1432exit:
     1433        ;
     1434
     1435        int const rc2 = ext4fs_node_put(fn);
     1436        return rc == EOK ? rc2 : rc;
    14351437}
    14361438
     
    14581460       
    14591461        rc = ext4_filesystem_truncate_inode(inode_ref, new_size);
    1460         ext4fs_node_put(fn);
    1461        
    1462         return rc;
     1462        int const rc2 = ext4fs_node_put(fn);
     1463       
     1464        return rc == EOK ? rc2 : rc;
    14631465}
    14641466
Note: See TracChangeset for help on using the changeset viewer.