Changeset b7fd2a0 in mainline for uspace/lib/ext4


Ignore:
Timestamp:
2018-01-13T03:10:29Z (8 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a53ed3a
Parents:
36f0738
Message:

Use errno_t in all uspace and kernel code.

Change type of every variable, parameter and return value that holds an
<errno.h> constant to either errno_t (the usual case), or sys_errno_t
(some places in kernel). This is for the purpose of self-documentation,
as well as for type-checking with a bit of type definition hackery.

Although this is a massive commit, it is a simple text replacement, and thus
is very easy to verify. Simply do the following:

`
git checkout <this commit's hash>
git reset HEAD
git add .
tools/srepl '\berrno_t\b' int
git add .
tools/srepl '\bsys_errno_t\b' sysarg_t
git reset
git diff
`

While this doesn't ensure that the replacements are correct, it does ensure
that the commit doesn't do anything except those replacements. Since errno_t
is typedef'd to int in the usual case (and sys_errno_t to sysarg_t), even if
incorrect, this commit cannot change behavior.

Location:
uspace/lib/ext4
Files:
22 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/ext4/include/ext4/balloc.h

    r36f0738 rb7fd2a0  
    3737#include "types.h"
    3838
    39 extern int ext4_balloc_free_block(ext4_inode_ref_t *, uint32_t);
    40 extern int ext4_balloc_free_blocks(ext4_inode_ref_t *, uint32_t, uint32_t);
     39extern errno_t ext4_balloc_free_block(ext4_inode_ref_t *, uint32_t);
     40extern errno_t ext4_balloc_free_blocks(ext4_inode_ref_t *, uint32_t, uint32_t);
    4141extern uint32_t ext4_balloc_get_first_data_block_in_group(ext4_superblock_t *,
    4242    ext4_block_group_ref_t *);
    43 extern int ext4_balloc_alloc_block(ext4_inode_ref_t *, uint32_t *);
    44 extern int ext4_balloc_try_alloc_block(ext4_inode_ref_t *, uint32_t, bool *);
     43extern errno_t ext4_balloc_alloc_block(ext4_inode_ref_t *, uint32_t *);
     44extern errno_t ext4_balloc_try_alloc_block(ext4_inode_ref_t *, uint32_t, bool *);
    4545
    4646#endif
  • uspace/lib/ext4/include/ext4/bitmap.h

    r36f0738 rb7fd2a0  
    4040extern void ext4_bitmap_set_bit(uint8_t *, uint32_t);
    4141extern bool ext4_bitmap_is_free_bit(uint8_t *, uint32_t);
    42 extern int ext4_bitmap_find_free_byte_and_set_bit(uint8_t *, uint32_t,
     42extern errno_t ext4_bitmap_find_free_byte_and_set_bit(uint8_t *, uint32_t,
    4343    uint32_t *, uint32_t);
    44 extern int ext4_bitmap_find_free_bit_and_set(uint8_t *, uint32_t, uint32_t *,
     44extern errno_t ext4_bitmap_find_free_bit_and_set(uint8_t *, uint32_t, uint32_t *,
    4545    uint32_t);
    4646
  • uspace/lib/ext4/include/ext4/directory.h

    r36f0738 rb7fd2a0  
    5353    ext4_directory_entry_ll_t *, uint8_t);
    5454
    55 extern int ext4_directory_iterator_init(ext4_directory_iterator_t *,
     55extern errno_t ext4_directory_iterator_init(ext4_directory_iterator_t *,
    5656    ext4_inode_ref_t *, aoff64_t);
    57 extern int ext4_directory_iterator_next(ext4_directory_iterator_t *);
    58 extern int ext4_directory_iterator_fini(ext4_directory_iterator_t *);
     57extern errno_t ext4_directory_iterator_next(ext4_directory_iterator_t *);
     58extern errno_t ext4_directory_iterator_fini(ext4_directory_iterator_t *);
    5959
    6060extern void ext4_directory_write_entry(ext4_superblock_t *,
    6161    ext4_directory_entry_ll_t *, uint16_t, ext4_inode_ref_t *,
    6262    const char *, size_t);
    63 extern int ext4_directory_add_entry(ext4_inode_ref_t *, const char *,
     63extern errno_t ext4_directory_add_entry(ext4_inode_ref_t *, const char *,
    6464    ext4_inode_ref_t *);
    65 extern int ext4_directory_find_entry(ext4_directory_search_result_t *,
     65extern errno_t ext4_directory_find_entry(ext4_directory_search_result_t *,
    6666    ext4_inode_ref_t *, const char *);
    67 extern int ext4_directory_remove_entry(ext4_inode_ref_t *, const char *);
     67extern errno_t ext4_directory_remove_entry(ext4_inode_ref_t *, const char *);
    6868
    69 extern int ext4_directory_try_insert_entry(ext4_superblock_t *, block_t *,
     69extern errno_t ext4_directory_try_insert_entry(ext4_superblock_t *, block_t *,
    7070    ext4_inode_ref_t *, const char *, uint32_t);
    7171
    72 extern int ext4_directory_find_in_block(block_t *, ext4_superblock_t *, size_t,
     72extern errno_t ext4_directory_find_in_block(block_t *, ext4_superblock_t *, size_t,
    7373    const char *, ext4_directory_entry_ll_t **);
    7474
    75 extern int ext4_directory_destroy_result(ext4_directory_search_result_t *);
     75extern errno_t ext4_directory_destroy_result(ext4_directory_search_result_t *);
    7676
    7777#endif
  • uspace/lib/ext4/include/ext4/directory_index.h

    r36f0738 rb7fd2a0  
    6565    uint32_t);
    6666
    67 extern int ext4_directory_dx_init(ext4_inode_ref_t *);
    68 extern int ext4_directory_dx_find_entry(ext4_directory_search_result_t *,
     67extern errno_t ext4_directory_dx_init(ext4_inode_ref_t *);
     68extern errno_t ext4_directory_dx_find_entry(ext4_directory_search_result_t *,
    6969    ext4_inode_ref_t *, size_t, const char *);
    70 extern int ext4_directory_dx_add_entry(ext4_inode_ref_t *, ext4_inode_ref_t *,
     70extern errno_t ext4_directory_dx_add_entry(ext4_inode_ref_t *, ext4_inode_ref_t *,
    7171    const char *);
    7272
  • uspace/lib/ext4/include/ext4/extent.h

    r36f0738 rb7fd2a0  
    6161extern void ext4_extent_header_set_generation(ext4_extent_header_t *, uint32_t);
    6262
    63 extern int ext4_extent_find_block(ext4_inode_ref_t *, uint32_t, uint32_t *);
    64 extern int ext4_extent_release_blocks_from(ext4_inode_ref_t *, uint32_t);
     63extern errno_t ext4_extent_find_block(ext4_inode_ref_t *, uint32_t, uint32_t *);
     64extern errno_t ext4_extent_release_blocks_from(ext4_inode_ref_t *, uint32_t);
    6565
    66 extern int ext4_extent_append_block(ext4_inode_ref_t *, uint32_t *, uint32_t *,
     66extern errno_t ext4_extent_append_block(ext4_inode_ref_t *, uint32_t *, uint32_t *,
    6767    bool);
    6868
  • uspace/lib/ext4/include/ext4/filesystem.h

    r36f0738 rb7fd2a0  
    3939#include "ext4/types.h"
    4040
    41 extern int ext4_filesystem_probe(service_id_t);
    42 extern int ext4_filesystem_open(ext4_instance_t *, service_id_t,
     41extern errno_t ext4_filesystem_probe(service_id_t);
     42extern errno_t ext4_filesystem_open(ext4_instance_t *, service_id_t,
    4343    enum cache_mode, aoff64_t *, ext4_filesystem_t **);
    44 extern int ext4_filesystem_close(ext4_filesystem_t *);
     44extern errno_t ext4_filesystem_close(ext4_filesystem_t *);
    4545extern uint32_t ext4_filesystem_blockaddr2_index_in_group(ext4_superblock_t *,
    4646    uint32_t);
     
    4848    uint32_t, uint32_t);
    4949extern uint32_t ext4_filesystem_blockaddr2group(ext4_superblock_t *, uint64_t);
    50 extern int ext4_filesystem_get_block_group_ref(ext4_filesystem_t *, uint32_t,
     50extern errno_t ext4_filesystem_get_block_group_ref(ext4_filesystem_t *, uint32_t,
    5151    ext4_block_group_ref_t **);
    52 extern int ext4_filesystem_put_block_group_ref(ext4_block_group_ref_t *);
    53 extern int ext4_filesystem_get_inode_ref(ext4_filesystem_t *, uint32_t,
     52extern errno_t ext4_filesystem_put_block_group_ref(ext4_block_group_ref_t *);
     53extern errno_t ext4_filesystem_get_inode_ref(ext4_filesystem_t *, uint32_t,
    5454    ext4_inode_ref_t **);
    55 extern int ext4_filesystem_put_inode_ref(ext4_inode_ref_t *);
    56 extern int ext4_filesystem_alloc_inode(ext4_filesystem_t *, ext4_inode_ref_t **,
     55extern errno_t ext4_filesystem_put_inode_ref(ext4_inode_ref_t *);
     56extern errno_t ext4_filesystem_alloc_inode(ext4_filesystem_t *, ext4_inode_ref_t **,
    5757    int);
    58 extern int ext4_filesystem_free_inode(ext4_inode_ref_t *);
    59 extern int ext4_filesystem_truncate_inode(ext4_inode_ref_t *, aoff64_t);
    60 extern int ext4_filesystem_get_inode_data_block_index(ext4_inode_ref_t *,
     58extern errno_t ext4_filesystem_free_inode(ext4_inode_ref_t *);
     59extern errno_t ext4_filesystem_truncate_inode(ext4_inode_ref_t *, aoff64_t);
     60extern errno_t ext4_filesystem_get_inode_data_block_index(ext4_inode_ref_t *,
    6161    aoff64_t iblock, uint32_t *);
    62 extern int ext4_filesystem_set_inode_data_block_index(ext4_inode_ref_t *,
     62extern errno_t ext4_filesystem_set_inode_data_block_index(ext4_inode_ref_t *,
    6363    aoff64_t, uint32_t);
    64 extern int ext4_filesystem_release_inode_block(ext4_inode_ref_t *, uint32_t);
    65 extern int ext4_filesystem_append_inode_block(ext4_inode_ref_t *, uint32_t *,
     64extern errno_t ext4_filesystem_release_inode_block(ext4_inode_ref_t *, uint32_t);
     65extern errno_t ext4_filesystem_append_inode_block(ext4_inode_ref_t *, uint32_t *,
    6666    uint32_t *);
    6767uint32_t ext4_filesystem_bg_get_backup_blocks(ext4_block_group_ref_t *bg);
  • uspace/lib/ext4/include/ext4/hash.h

    r36f0738 rb7fd2a0  
    3636#include "ext4/types.h"
    3737
    38 extern int ext4_hash_string(ext4_hash_info_t *, int, const char *);
     38extern errno_t ext4_hash_string(ext4_hash_info_t *, int, const char *);
    3939
    4040#endif
  • uspace/lib/ext4/include/ext4/ialloc.h

    r36f0738 rb7fd2a0  
    3636#include "ext4/types.h"
    3737
    38 extern int ext4_ialloc_free_inode(ext4_filesystem_t *, uint32_t, bool);
    39 extern int ext4_ialloc_alloc_inode(ext4_filesystem_t *, uint32_t *, bool);
     38extern errno_t ext4_ialloc_free_inode(ext4_filesystem_t *, uint32_t, bool);
     39extern errno_t ext4_ialloc_alloc_inode(ext4_filesystem_t *, uint32_t *, bool);
    4040
    4141#endif
  • uspace/lib/ext4/include/ext4/inode.h

    r36f0738 rb7fd2a0  
    5959extern uint64_t ext4_inode_get_blocks_count(ext4_superblock_t *,
    6060    ext4_inode_t *);
    61 extern int ext4_inode_set_blocks_count(ext4_superblock_t *, ext4_inode_t *,
     61extern errno_t ext4_inode_set_blocks_count(ext4_superblock_t *, ext4_inode_t *,
    6262    uint64_t);
    6363extern uint32_t ext4_inode_get_flags(ext4_inode_t *);
  • uspace/lib/ext4/include/ext4/ops.h

    r36f0738 rb7fd2a0  
    4040extern libfs_ops_t ext4_libfs_ops;
    4141
    42 extern int ext4_global_init(void);
    43 extern int ext4_global_fini(void);
     42extern errno_t ext4_global_init(void);
     43extern errno_t ext4_global_fini(void);
    4444
    45 extern int ext4_node_get_core(fs_node_t **, ext4_instance_t *, fs_index_t);
    46 extern int ext4_node_put(fs_node_t *);
     45extern errno_t ext4_node_get_core(fs_node_t **, ext4_instance_t *, fs_index_t);
     46extern errno_t ext4_node_put(fs_node_t *);
    4747
    4848
  • uspace/lib/ext4/include/ext4/superblock.h

    r36f0738 rb7fd2a0  
    152152extern bool ext4_superblock_has_feature_read_only(ext4_superblock_t *,
    153153    uint32_t);
    154 extern int ext4_superblock_read_direct(service_id_t, ext4_superblock_t **);
    155 extern int ext4_superblock_write_direct(service_id_t, ext4_superblock_t *);
     154extern errno_t ext4_superblock_read_direct(service_id_t, ext4_superblock_t **);
     155extern errno_t ext4_superblock_write_direct(service_id_t, ext4_superblock_t *);
    156156extern void ext4_superblock_release(ext4_superblock_t *);
    157 extern int ext4_superblock_check_sanity(ext4_superblock_t *);
     157extern errno_t ext4_superblock_check_sanity(ext4_superblock_t *);
    158158
    159159extern uint32_t ext4_superblock_get_block_group_count(ext4_superblock_t *);
  • uspace/lib/ext4/src/balloc.c

    r36f0738 rb7fd2a0  
    5353 *
    5454 */
    55 int ext4_balloc_free_block(ext4_inode_ref_t *inode_ref, uint32_t block_addr)
     55errno_t ext4_balloc_free_block(ext4_inode_ref_t *inode_ref, uint32_t block_addr)
    5656{
    5757        ext4_filesystem_t *fs = inode_ref->fs;
     
    6565        /* Load block group reference */
    6666        ext4_block_group_ref_t *bg_ref;
    67         int rc = ext4_filesystem_get_block_group_ref(fs, block_group, &bg_ref);
     67        errno_t rc = ext4_filesystem_get_block_group_ref(fs, block_group, &bg_ref);
    6868        if (rc != EOK)
    6969                return rc;
     
    118118}
    119119
    120 static int ext4_balloc_free_blocks_internal(ext4_inode_ref_t *inode_ref,
     120static errno_t ext4_balloc_free_blocks_internal(ext4_inode_ref_t *inode_ref,
    121121    uint32_t first, uint32_t count)
    122122{
     
    134134        /* Load block group reference */
    135135        ext4_block_group_ref_t *bg_ref;
    136         int rc = ext4_filesystem_get_block_group_ref(fs, block_group_first, &bg_ref);
     136        errno_t rc = ext4_filesystem_get_block_group_ref(fs, block_group_first, &bg_ref);
    137137        if (rc != EOK)
    138138                return rc;
     
    198198 *
    199199 */
    200 int ext4_balloc_free_blocks(ext4_inode_ref_t *inode_ref,
     200errno_t ext4_balloc_free_blocks(ext4_inode_ref_t *inode_ref,
    201201    uint32_t first, uint32_t count)
    202202{
    203         int r;
     203        errno_t r;
    204204        uint32_t gid;
    205205        uint64_t limit;
     
    293293 *
    294294 */
    295 static int ext4_balloc_find_goal(ext4_inode_ref_t *inode_ref, uint32_t *goal)
     295static errno_t ext4_balloc_find_goal(ext4_inode_ref_t *inode_ref, uint32_t *goal)
    296296{
    297297        *goal = 0;
     
    307307        /* If inode has some blocks, get last block address + 1 */
    308308        if (inode_block_count > 0) {
    309                 int rc = ext4_filesystem_get_inode_data_block_index(inode_ref,
     309                errno_t rc = ext4_filesystem_get_inode_data_block_index(inode_ref,
    310310                    inode_block_count - 1, goal);
    311311                if (rc != EOK)
     
    325325        /* Load block group reference */
    326326        ext4_block_group_ref_t *bg_ref;
    327         int rc = ext4_filesystem_get_block_group_ref(inode_ref->fs,
     327        errno_t rc = ext4_filesystem_get_block_group_ref(inode_ref->fs,
    328328            block_group, &bg_ref);
    329329        if (rc != EOK)
     
    343343 *
    344344 */
    345 int ext4_balloc_alloc_block(ext4_inode_ref_t *inode_ref, uint32_t *fblock)
     345errno_t ext4_balloc_alloc_block(ext4_inode_ref_t *inode_ref, uint32_t *fblock)
    346346{
    347347        uint32_t allocated_block = 0;
     
    354354       
    355355        /* Find GOAL */
    356         int rc = ext4_balloc_find_goal(inode_ref, &goal);
     356        errno_t rc = ext4_balloc_find_goal(inode_ref, &goal);
    357357        if (rc != EOK)
    358358                return rc;
     
    625625 *
    626626 */
    627 int ext4_balloc_try_alloc_block(ext4_inode_ref_t *inode_ref, uint32_t fblock,
     627errno_t ext4_balloc_try_alloc_block(ext4_inode_ref_t *inode_ref, uint32_t fblock,
    628628    bool *free)
    629629{
    630         int rc;
     630        errno_t rc;
    631631       
    632632        ext4_filesystem_t *fs = inode_ref->fs;
  • uspace/lib/ext4/src/bitmap.c

    r36f0738 rb7fd2a0  
    169169 *
    170170 */
    171 int ext4_bitmap_find_free_byte_and_set_bit(uint8_t *bitmap, uint32_t start,
     171errno_t ext4_bitmap_find_free_byte_and_set_bit(uint8_t *bitmap, uint32_t start,
    172172    uint32_t *index, uint32_t max)
    173173{
     
    211211 *
    212212 */
    213 int ext4_bitmap_find_free_bit_and_set(uint8_t *bitmap, uint32_t start_idx,
     213errno_t ext4_bitmap_find_free_bit_and_set(uint8_t *bitmap, uint32_t start_idx,
    214214    uint32_t *index, uint32_t max)
    215215{
  • uspace/lib/ext4/src/directory.c

    r36f0738 rb7fd2a0  
    169169}
    170170
    171 static int ext4_directory_iterator_seek(ext4_directory_iterator_t *, aoff64_t);
    172 static int ext4_directory_iterator_set(ext4_directory_iterator_t *, uint32_t);
     171static errno_t ext4_directory_iterator_seek(ext4_directory_iterator_t *, aoff64_t);
     172static errno_t ext4_directory_iterator_set(ext4_directory_iterator_t *, uint32_t);
    173173
    174174/** Initialize directory iterator.
     
    183183 *
    184184 */
    185 int ext4_directory_iterator_init(ext4_directory_iterator_t *it,
     185errno_t ext4_directory_iterator_init(ext4_directory_iterator_t *it,
    186186    ext4_inode_ref_t *inode_ref, aoff64_t pos)
    187187{
     
    201201 *
    202202 */
    203 int ext4_directory_iterator_next(ext4_directory_iterator_t *it)
     203errno_t ext4_directory_iterator_next(ext4_directory_iterator_t *it)
    204204{
    205205        assert(it->current != NULL);
     
    220220 *
    221221 */
    222 int ext4_directory_iterator_seek(ext4_directory_iterator_t *it, aoff64_t pos)
     222errno_t ext4_directory_iterator_seek(ext4_directory_iterator_t *it, aoff64_t pos)
    223223{
    224224        uint64_t size = ext4_inode_get_size(it->inode_ref->fs->superblock,
     
    231231        if (pos >= size) {
    232232                if (it->current_block) {
    233                         int rc = block_put(it->current_block);
     233                        errno_t rc = block_put(it->current_block);
    234234                        it->current_block = NULL;
    235235                       
     
    255255            (current_block_idx != next_block_idx)) {
    256256                if (it->current_block) {
    257                         int rc = block_put(it->current_block);
     257                        errno_t rc = block_put(it->current_block);
    258258                        it->current_block = NULL;
    259259                       
     
    263263               
    264264                uint32_t next_block_phys_idx;
    265                 int rc = ext4_filesystem_get_inode_data_block_index(it->inode_ref,
     265                errno_t rc = ext4_filesystem_get_inode_data_block_index(it->inode_ref,
    266266                    next_block_idx, &next_block_phys_idx);
    267267                if (rc != EOK)
     
    289289 *
    290290 */
    291 static int ext4_directory_iterator_set(ext4_directory_iterator_t *it,
     291static errno_t ext4_directory_iterator_set(ext4_directory_iterator_t *it,
    292292    uint32_t block_size)
    293293{
     
    331331 *
    332332 */
    333 int ext4_directory_iterator_fini(ext4_directory_iterator_t *it)
     333errno_t ext4_directory_iterator_fini(ext4_directory_iterator_t *it)
    334334{
    335335        it->inode_ref = NULL;
     
    386386 *
    387387 */
    388 int ext4_directory_add_entry(ext4_inode_ref_t *parent, const char *name,
     388errno_t ext4_directory_add_entry(ext4_inode_ref_t *parent, const char *name,
    389389    ext4_inode_ref_t *child)
    390390{
     
    395395            EXT4_FEATURE_COMPAT_DIR_INDEX)) &&
    396396            (ext4_inode_has_flag(parent->inode, EXT4_INODE_FLAG_INDEX))) {
    397                 int rc = ext4_directory_dx_add_entry(parent, child, name);
     397                errno_t rc = ext4_directory_dx_add_entry(parent, child, name);
    398398
    399399                /* Check if index is not corrupted */
     
    419419        bool success = false;
    420420        for (iblock = 0; iblock < total_blocks; ++iblock) {
    421                 int rc = ext4_filesystem_get_inode_data_block_index(parent,
     421                errno_t rc = ext4_filesystem_get_inode_data_block_index(parent,
    422422                    iblock, &fblock);
    423423                if (rc != EOK)
     
    447447        iblock = 0;
    448448        fblock = 0;
    449         int rc = ext4_filesystem_append_inode_block(parent, &fblock, &iblock);
     449        errno_t rc = ext4_filesystem_append_inode_block(parent, &fblock, &iblock);
    450450        if (rc != EOK)
    451451                return rc;
     
    479479 *
    480480 */
    481 int ext4_directory_find_entry(ext4_directory_search_result_t *result,
     481errno_t ext4_directory_find_entry(ext4_directory_search_result_t *result,
    482482    ext4_inode_ref_t *parent, const char *name)
    483483{
     
    490490            EXT4_FEATURE_COMPAT_DIR_INDEX)) &&
    491491            (ext4_inode_has_flag(parent->inode, EXT4_INODE_FLAG_INDEX))) {
    492                 int rc = ext4_directory_dx_find_entry(result, parent, name_len,
     492                errno_t rc = ext4_directory_dx_find_entry(result, parent, name_len,
    493493                    name);
    494494               
     
    517517        for (iblock = 0; iblock < total_blocks; ++iblock) {
    518518                /* Load block address */
    519                 int rc = ext4_filesystem_get_inode_data_block_index(parent, iblock,
     519                errno_t rc = ext4_filesystem_get_inode_data_block_index(parent, iblock,
    520520                    &fblock);
    521521                if (rc != EOK)
     
    561561 *
    562562 */
    563 int ext4_directory_remove_entry(ext4_inode_ref_t *parent, const char *name)
     563errno_t ext4_directory_remove_entry(ext4_inode_ref_t *parent, const char *name)
    564564{
    565565        /* Check if removing from directory */
     
    570570        /* Try to find entry */
    571571        ext4_directory_search_result_t result;
    572         int rc = ext4_directory_find_entry(&result, parent, name);
     572        errno_t rc = ext4_directory_find_entry(&result, parent, name);
    573573        if (rc != EOK)
    574574                return rc;
     
    626626 *
    627627 */
    628 int ext4_directory_try_insert_entry(ext4_superblock_t *sb,
     628errno_t ext4_directory_try_insert_entry(ext4_superblock_t *sb,
    629629    block_t *target_block, ext4_inode_ref_t *child, const char *name,
    630630    uint32_t name_len)
     
    705705 *
    706706 */
    707 int ext4_directory_find_in_block(block_t *block, ext4_superblock_t *sb,
     707errno_t ext4_directory_find_in_block(block_t *block, ext4_superblock_t *sb,
    708708    size_t name_len, const char *name, ext4_directory_entry_ll_t **res_entry)
    709709{
     
    756756 *
    757757 */
    758 int ext4_directory_destroy_result(ext4_directory_search_result_t *result)
     758errno_t ext4_directory_destroy_result(ext4_directory_search_result_t *result)
    759759{
    760760        if (result->block)
  • uspace/lib/ext4/src/directory_index.c

    r36f0738 rb7fd2a0  
    236236 *
    237237 */
    238 int ext4_directory_dx_init(ext4_inode_ref_t *dir)
     238errno_t ext4_directory_dx_init(ext4_inode_ref_t *dir)
    239239{
    240240        /* Load block 0, where will be index root located */
    241241        uint32_t fblock;
    242         int rc = ext4_filesystem_get_inode_data_block_index(dir, 0,
     242        errno_t rc = ext4_filesystem_get_inode_data_block_index(dir, 0,
    243243            &fblock);
    244244        if (rc != EOK)
     
    322322 *
    323323 */
    324 static int ext4_directory_hinfo_init(ext4_hash_info_t *hinfo,
     324static errno_t ext4_directory_hinfo_init(ext4_hash_info_t *hinfo,
    325325    block_t *root_block, ext4_superblock_t *sb, size_t name_len,
    326326    const char *name)
     
    384384 *
    385385 */
    386 static int ext4_directory_dx_get_leaf(ext4_hash_info_t *hinfo,
     386static errno_t ext4_directory_dx_get_leaf(ext4_hash_info_t *hinfo,
    387387    ext4_inode_ref_t *inode_ref, block_t *root_block,
    388388    ext4_directory_dx_block_t **dx_block, ext4_directory_dx_block_t *dx_blocks)
     
    443443               
    444444                uint32_t fblock;
    445                 int rc = ext4_filesystem_get_inode_data_block_index(inode_ref,
     445                errno_t rc = ext4_filesystem_get_inode_data_block_index(inode_ref,
    446446                    next_block, &fblock);
    447447                if (rc != EOK)
     
    484484 *
    485485 */
    486 static int ext4_directory_dx_next_block(ext4_inode_ref_t *inode_ref,
     486static errno_t ext4_directory_dx_next_block(ext4_inode_ref_t *inode_ref,
    487487    uint32_t hash, ext4_directory_dx_block_t *dx_block,
    488488    ext4_directory_dx_block_t *dx_blocks)
     
    520520                uint32_t block_addr;
    521521               
    522                 int rc = ext4_filesystem_get_inode_data_block_index(inode_ref,
     522                errno_t rc = ext4_filesystem_get_inode_data_block_index(inode_ref,
    523523                    block_idx, &block_addr);
    524524                if (rc != EOK)
     
    556556 *
    557557 */
    558 int ext4_directory_dx_find_entry(ext4_directory_search_result_t *result,
     558errno_t ext4_directory_dx_find_entry(ext4_directory_search_result_t *result,
    559559    ext4_inode_ref_t *inode_ref, size_t name_len, const char *name)
    560560{
    561561        /* Load direct block 0 (index root) */
    562562        uint32_t root_block_addr;
    563         int rc2;
    564         int rc = ext4_filesystem_get_inode_data_block_index(inode_ref, 0,
     563        errno_t rc2;
     564        errno_t rc = ext4_filesystem_get_inode_data_block_index(inode_ref, 0,
    565565            &root_block_addr);
    566566        if (rc != EOK)
     
    728728 *
    729729 */
    730 static int ext4_directory_dx_split_data(ext4_inode_ref_t *inode_ref,
     730static errno_t ext4_directory_dx_split_data(ext4_inode_ref_t *inode_ref,
    731731    ext4_hash_info_t *hinfo, block_t *old_data_block,
    732732    ext4_directory_dx_block_t *index_block, block_t **new_data_block)
    733733{
    734         int rc = EOK;
     734        errno_t rc = EOK;
    735735       
    736736        /* Allocate buffer for directory entries */
     
    897897 *
    898898 */
    899 static int ext4_directory_dx_split_index(ext4_inode_ref_t *inode_ref,
     899static errno_t ext4_directory_dx_split_index(ext4_inode_ref_t *inode_ref,
    900900                ext4_directory_dx_block_t *dx_blocks, ext4_directory_dx_block_t *dx_block)
    901901{
     
    937937                uint32_t new_fblock;
    938938                uint32_t new_iblock;
    939                 int rc = ext4_filesystem_append_inode_block(inode_ref,
     939                errno_t rc = ext4_filesystem_append_inode_block(inode_ref,
    940940                    &new_fblock, &new_iblock);
    941941                if (rc != EOK)
     
    10451045 *
    10461046 */
    1047 int ext4_directory_dx_add_entry(ext4_inode_ref_t *parent,
     1047errno_t ext4_directory_dx_add_entry(ext4_inode_ref_t *parent,
    10481048    ext4_inode_ref_t *child, const char *name)
    10491049{
    1050         int rc2 = EOK;
     1050        errno_t rc2 = EOK;
    10511051       
    10521052        /* Get direct block 0 (index root) */
    10531053        uint32_t root_block_addr;
    1054         int rc = ext4_filesystem_get_inode_data_block_index(parent, 0,
     1054        errno_t rc = ext4_filesystem_get_inode_data_block_index(parent, 0,
    10551055            &root_block_addr);
    10561056        if (rc != EOK)
  • uspace/lib/ext4/src/extent.c

    r36f0738 rb7fd2a0  
    372372 *
    373373 */
    374 int ext4_extent_find_block(ext4_inode_ref_t *inode_ref, uint32_t iblock,
     374errno_t ext4_extent_find_block(ext4_inode_ref_t *inode_ref, uint32_t iblock,
    375375    uint32_t *fblock)
    376376{
    377         int rc = EOK;
     377        errno_t rc = EOK;
    378378        /* Compute bound defined by i-node size */
    379379        uint64_t inode_size =
     
    454454 *
    455455 */
    456 static int ext4_extent_find_extent(ext4_inode_ref_t *inode_ref, uint32_t iblock,
     456static errno_t ext4_extent_find_extent(ext4_inode_ref_t *inode_ref, uint32_t iblock,
    457457    ext4_extent_path_t **ret_path)
    458458{
     
    475475        /* Walk through the extent tree */
    476476        uint16_t pos = 0;
    477         int rc;
     477        errno_t rc;
    478478        while (ext4_extent_header_get_depth(eh) != 0) {
    479479                /* Search index in index node by iblock */
     
    515515        ;
    516516
    517         int rc2 = EOK;
     517        errno_t rc2 = EOK;
    518518
    519519        /*
     
    543543 *
    544544 */
    545 static int ext4_extent_release(ext4_inode_ref_t *inode_ref,
     545static errno_t ext4_extent_release(ext4_inode_ref_t *inode_ref,
    546546    ext4_extent_t *extent)
    547547{
     
    565565 *
    566566 */
    567 static int ext4_extent_release_branch(ext4_inode_ref_t *inode_ref,
     567static errno_t ext4_extent_release_branch(ext4_inode_ref_t *inode_ref,
    568568                ext4_extent_index_t *index)
    569569{
     
    571571       
    572572        block_t* block;
    573         int rc = block_get(&block, inode_ref->fs->device, fblock, BLOCK_FLAGS_NONE);
     573        errno_t rc = block_get(&block, inode_ref->fs->device, fblock, BLOCK_FLAGS_NONE);
    574574        if (rc != EOK)
    575575                return rc;
     
    618618 *
    619619 */
    620 int ext4_extent_release_blocks_from(ext4_inode_ref_t *inode_ref,
     620errno_t ext4_extent_release_blocks_from(ext4_inode_ref_t *inode_ref,
    621621    uint32_t iblock_from)
    622622{
    623623        /* Find the first extent to modify */
    624624        ext4_extent_path_t *path;
    625         int rc = ext4_extent_find_extent(inode_ref, iblock_from, &path);
     625        errno_t rc = ext4_extent_find_extent(inode_ref, iblock_from, &path);
    626626        if (rc != EOK)
    627627                return rc;
     
    736736        ;
    737737
    738         int rc2 = EOK;
     738        errno_t rc2 = EOK;
    739739
    740740        /*
     
    767767 *
    768768 */
    769 static int ext4_extent_append_extent(ext4_inode_ref_t *inode_ref,
     769static errno_t ext4_extent_append_extent(ext4_inode_ref_t *inode_ref,
    770770    ext4_extent_path_t *path, uint32_t iblock)
    771771{
     
    785785                        /* Full node - allocate block for new one */
    786786                        uint32_t fblock;
    787                         int rc = ext4_balloc_alloc_block(inode_ref, &fblock);
     787                        errno_t rc = ext4_balloc_alloc_block(inode_ref, &fblock);
    788788                        if (rc != EOK)
    789789                                return rc;
     
    863863        if (entries == limit) {
    864864                uint32_t new_fblock;
    865                 int rc = ext4_balloc_alloc_block(inode_ref, &new_fblock);
     865                errno_t rc = ext4_balloc_alloc_block(inode_ref, &new_fblock);
    866866                if (rc != EOK)
    867867                        return rc;
     
    964964 *
    965965 */
    966 int ext4_extent_append_block(ext4_inode_ref_t *inode_ref, uint32_t *iblock,
     966errno_t ext4_extent_append_block(ext4_inode_ref_t *inode_ref, uint32_t *iblock,
    967967    uint32_t *fblock, bool update_size)
    968968{
     
    982982        /* Load the nearest leaf (with extent) */
    983983        ext4_extent_path_t *path;
    984         int rc = ext4_extent_find_extent(inode_ref, new_block_idx, &path);
     984        errno_t rc = ext4_extent_find_extent(inode_ref, new_block_idx, &path);
    985985        if (rc != EOK)
    986986                return rc;
     
    10881088        ;
    10891089
    1090         int rc2 = EOK;
     1090        errno_t rc2 = EOK;
    10911091
    10921092        /* Set return values */
  • uspace/lib/ext4/src/filesystem.c

    r36f0738 rb7fd2a0  
    5454#include "ext4/superblock.h"
    5555
    56 static int ext4_filesystem_check_features(ext4_filesystem_t *, bool *);
     56static errno_t ext4_filesystem_check_features(ext4_filesystem_t *, bool *);
    5757
    5858/** Initialize filesystem for opening.
     
    6767 *
    6868 */
    69 static int ext4_filesystem_init(ext4_filesystem_t *fs, service_id_t service_id,
     69static errno_t ext4_filesystem_init(ext4_filesystem_t *fs, service_id_t service_id,
    7070    enum cache_mode cmode)
    7171{
    72         int rc;
     72        errno_t rc;
    7373        ext4_superblock_t *temp_superblock = NULL;
    7474
     
    164164 *
    165165 */
    166 int ext4_filesystem_probe(service_id_t service_id)
     166errno_t ext4_filesystem_probe(service_id_t service_id)
    167167{
    168168        ext4_filesystem_t *fs = NULL;
    169         int rc;
     169        errno_t rc;
    170170
    171171        fs = calloc(1, sizeof(ext4_filesystem_t));
     
    195195 *
    196196 */
    197 int ext4_filesystem_open(ext4_instance_t *inst, service_id_t service_id,
     197errno_t ext4_filesystem_open(ext4_instance_t *inst, service_id_t service_id,
    198198    enum cache_mode cmode, aoff64_t *size, ext4_filesystem_t **rfs)
    199199{
    200200        ext4_filesystem_t *fs = NULL;
    201201        fs_node_t *root_node = NULL;
    202         int rc;
     202        errno_t rc;
    203203
    204204        fs = calloc(1, sizeof(ext4_filesystem_t));
     
    256256 *
    257257 */
    258 int ext4_filesystem_close(ext4_filesystem_t *fs)
     258errno_t ext4_filesystem_close(ext4_filesystem_t *fs)
    259259{
    260260        /* Write the superblock to the device */
    261261        ext4_superblock_set_state(fs->superblock, EXT4_SUPERBLOCK_STATE_VALID_FS);
    262         int rc = ext4_superblock_write_direct(fs->device, fs->superblock);
     262        errno_t rc = ext4_superblock_write_direct(fs->device, fs->superblock);
    263263        if (rc != EOK)
    264264                return rc;
     
    281281 *
    282282 */
    283 static int ext4_filesystem_check_features(ext4_filesystem_t *fs,
     283static errno_t ext4_filesystem_check_features(ext4_filesystem_t *fs,
    284284    bool *read_only)
    285285{
     
    380380 *
    381381 */
    382 static int ext4_filesystem_init_block_bitmap(ext4_block_group_ref_t *bg_ref)
     382static errno_t ext4_filesystem_init_block_bitmap(ext4_block_group_ref_t *bg_ref)
    383383{
    384384        uint64_t itb;
     
    394394       
    395395        block_t *bitmap_block;
    396         int rc = block_get(&bitmap_block, bg_ref->fs->device,
     396        errno_t rc = block_get(&bitmap_block, bg_ref->fs->device,
    397397            bitmap_block_addr, BLOCK_FLAGS_NOREAD);
    398398        if (rc != EOK)
     
    451451 *
    452452 */
    453 static int ext4_filesystem_init_inode_bitmap(ext4_block_group_ref_t *bg_ref)
     453static errno_t ext4_filesystem_init_inode_bitmap(ext4_block_group_ref_t *bg_ref)
    454454{
    455455        /* Load bitmap */
     
    458458        block_t *bitmap_block;
    459459       
    460         int rc = block_get(&bitmap_block, bg_ref->fs->device,
     460        errno_t rc = block_get(&bitmap_block, bg_ref->fs->device,
    461461            bitmap_block_addr, BLOCK_FLAGS_NOREAD);
    462462        if (rc != EOK)
     
    494494 *
    495495 */
    496 static int ext4_filesystem_init_inode_table(ext4_block_group_ref_t *bg_ref)
     496static errno_t ext4_filesystem_init_inode_table(ext4_block_group_ref_t *bg_ref)
    497497{
    498498        ext4_superblock_t *sb = bg_ref->fs->superblock;
     
    519519        for (uint32_t fblock = first_block; fblock <= last_block; ++fblock) {
    520520                block_t *block;
    521                 int rc = block_get(&block, bg_ref->fs->device, fblock,
     521                errno_t rc = block_get(&block, bg_ref->fs->device, fblock,
    522522                    BLOCK_FLAGS_NOREAD);
    523523                if (rc != EOK)
     
    544544 *
    545545 */
    546 int ext4_filesystem_get_block_group_ref(ext4_filesystem_t *fs, uint32_t bgid,
     546errno_t ext4_filesystem_get_block_group_ref(ext4_filesystem_t *fs, uint32_t bgid,
    547547    ext4_block_group_ref_t **ref)
    548548{
     
    568568       
    569569        /* Load block with descriptors */
    570         int rc = block_get(&newref->block, fs->device, block_id, 0);
     570        errno_t rc = block_get(&newref->block, fs->device, block_id, 0);
    571571        if (rc != EOK) {
    572572                free(newref);
     
    804804 *
    805805 */
    806 int ext4_filesystem_put_block_group_ref(ext4_block_group_ref_t *ref)
     806errno_t ext4_filesystem_put_block_group_ref(ext4_block_group_ref_t *ref)
    807807{
    808808        /* Check if reference modified */
     
    819819       
    820820        /* Put back block, that contains block group descriptor */
    821         int rc = block_put(ref->block);
     821        errno_t rc = block_put(ref->block);
    822822        free(ref);
    823823       
     
    834834 *
    835835 */
    836 int ext4_filesystem_get_inode_ref(ext4_filesystem_t *fs, uint32_t index,
     836errno_t ext4_filesystem_get_inode_ref(ext4_filesystem_t *fs, uint32_t index,
    837837    ext4_inode_ref_t **ref)
    838838{
     
    857857        /* Load block group, where i-node is located */
    858858        ext4_block_group_ref_t *bg_ref;
    859         int rc = ext4_filesystem_get_block_group_ref(fs, block_group, &bg_ref);
     859        errno_t rc = ext4_filesystem_get_block_group_ref(fs, block_group, &bg_ref);
    860860        if (rc != EOK) {
    861861                free(newref);
     
    909909 *
    910910 */
    911 int ext4_filesystem_put_inode_ref(ext4_inode_ref_t *ref)
     911errno_t ext4_filesystem_put_inode_ref(ext4_inode_ref_t *ref)
    912912{
    913913        /* Check if reference modified */
     
    918918       
    919919        /* Put back block, that contains i-node */
    920         int rc = block_put(ref->block);
     920        errno_t rc = block_put(ref->block);
    921921        free(ref);
    922922       
     
    933933 *
    934934 */
    935 int ext4_filesystem_alloc_inode(ext4_filesystem_t *fs,
     935errno_t ext4_filesystem_alloc_inode(ext4_filesystem_t *fs,
    936936    ext4_inode_ref_t **inode_ref, int flags)
    937937{
     
    943943        /* Allocate inode by allocation algorithm */
    944944        uint32_t index;
    945         int rc = ext4_ialloc_alloc_inode(fs, &index, is_dir);
     945        errno_t rc = ext4_ialloc_alloc_inode(fs, &index, is_dir);
    946946        if (rc != EOK)
    947947                return rc;
     
    10251025 *
    10261026 */
    1027 int ext4_filesystem_free_inode(ext4_inode_ref_t *inode_ref)
     1027errno_t ext4_filesystem_free_inode(ext4_inode_ref_t *inode_ref)
    10281028{
    10291029        ext4_filesystem_t *fs = inode_ref->fs;
     
    10421042        uint32_t fblock = ext4_inode_get_indirect_block(inode_ref->inode, 0);
    10431043        if (fblock != 0) {
    1044                 int rc = ext4_balloc_free_block(inode_ref, fblock);
     1044                errno_t rc = ext4_balloc_free_block(inode_ref, fblock);
    10451045                if (rc != EOK)
    10461046                        return rc;
     
    10561056        fblock = ext4_inode_get_indirect_block(inode_ref->inode, 1);
    10571057        if (fblock != 0) {
    1058                 int rc = block_get(&block, fs->device, fblock, BLOCK_FLAGS_NONE);
     1058                errno_t rc = block_get(&block, fs->device, fblock, BLOCK_FLAGS_NONE);
    10591059                if (rc != EOK)
    10601060                        return rc;
     
    10881088        fblock = ext4_inode_get_indirect_block(inode_ref->inode, 2);
    10891089        if (fblock != 0) {
    1090                 int rc = block_get(&block, fs->device, fblock, BLOCK_FLAGS_NONE);
     1090                errno_t rc = block_get(&block, fs->device, fblock, BLOCK_FLAGS_NONE);
    10911091                if (rc != EOK)
    10921092                        return rc;
     
    11531153            inode_ref->inode, fs->superblock);
    11541154        if (xattr_block) {
    1155                 int rc = ext4_balloc_free_block(inode_ref, xattr_block);
     1155                errno_t rc = ext4_balloc_free_block(inode_ref, xattr_block);
    11561156                if (rc != EOK)
    11571157                        return rc;
     
    11611161       
    11621162        /* Free inode by allocator */
    1163         int rc;
     1163        errno_t rc;
    11641164        if (ext4_inode_is_type(fs->superblock, inode_ref->inode,
    11651165            EXT4_INODE_MODE_DIRECTORY))
     
    11791179 *
    11801180 */
    1181 int ext4_filesystem_truncate_inode(ext4_inode_ref_t *inode_ref,
     1181errno_t ext4_filesystem_truncate_inode(ext4_inode_ref_t *inode_ref,
    11821182    aoff64_t new_size)
    11831183{
     
    12121212            (ext4_inode_has_flag(inode_ref->inode, EXT4_INODE_FLAG_EXTENTS))) {
    12131213                /* Extents require special operation */
    1214                 int rc = ext4_extent_release_blocks_from(inode_ref,
     1214                errno_t rc = ext4_extent_release_blocks_from(inode_ref,
    12151215                    old_blocks_count - diff_blocks_count);
    12161216                if (rc != EOK)
     
    12211221                /* Starting from 1 because of logical blocks are numbered from 0 */
    12221222                for (uint32_t i = 1; i <= diff_blocks_count; ++i) {
    1223                         int rc = ext4_filesystem_release_inode_block(inode_ref,
     1223                        errno_t rc = ext4_filesystem_release_inode_block(inode_ref,
    12241224                            old_blocks_count - i);
    12251225                        if (rc != EOK)
     
    12441244 *
    12451245 */
    1246 int ext4_filesystem_get_inode_data_block_index(ext4_inode_ref_t *inode_ref,
     1246errno_t ext4_filesystem_get_inode_data_block_index(ext4_inode_ref_t *inode_ref,
    12471247    aoff64_t iblock, uint32_t *fblock)
    12481248{
     
    12611261            EXT4_FEATURE_INCOMPAT_EXTENTS)) &&
    12621262            (ext4_inode_has_flag(inode_ref->inode, EXT4_INODE_FLAG_EXTENTS))) {
    1263                 int rc = ext4_extent_find_block(inode_ref, iblock, &current_block);
     1263                errno_t rc = ext4_extent_find_block(inode_ref, iblock, &current_block);
    12641264                if (rc != EOK)
    12651265                        return rc;
     
    13111311        while (level > 0) {
    13121312                /* Load indirect block */
    1313                 int rc = block_get(&block, fs->device, current_block, 0);
     1313                errno_t rc = block_get(&block, fs->device, current_block, 0);
    13141314                if (rc != EOK)
    13151315                        return rc;
     
    13571357 *
    13581358 */
    1359 int ext4_filesystem_set_inode_data_block_index(ext4_inode_ref_t *inode_ref,
     1359errno_t ext4_filesystem_set_inode_data_block_index(ext4_inode_ref_t *inode_ref,
    13601360    aoff64_t iblock, uint32_t fblock)
    13611361{
     
    14071407        if (current_block == 0) {
    14081408                /* Allocate new indirect block */
    1409                 int rc = ext4_balloc_alloc_block(inode_ref, &new_block_addr);
     1409                errno_t rc = ext4_balloc_alloc_block(inode_ref, &new_block_addr);
    14101410                if (rc != EOK)
    14111411                        return rc;
     
    14411441         */
    14421442        while (level > 0) {
    1443                 int rc = block_get(&block, fs->device, current_block, 0);
     1443                errno_t rc = block_get(&block, fs->device, current_block, 0);
    14441444                if (rc != EOK)
    14451445                        return rc;
     
    15181518 *
    15191519 */
    1520 int ext4_filesystem_release_inode_block(ext4_inode_ref_t *inode_ref,
     1520errno_t ext4_filesystem_release_inode_block(ext4_inode_ref_t *inode_ref,
    15211521    uint32_t iblock)
    15221522{
     
    15751575                        return EOK;
    15761576               
    1577                 int rc = block_get(&block, fs->device, current_block, 0);
     1577                errno_t rc = block_get(&block, fs->device, current_block, 0);
    15781578                if (rc != EOK)
    15791579                        return rc;
     
    16251625 *
    16261626 */
    1627 int ext4_filesystem_append_inode_block(ext4_inode_ref_t *inode_ref,
     1627errno_t ext4_filesystem_append_inode_block(ext4_inode_ref_t *inode_ref,
    16281628    uint32_t *fblock, uint32_t *iblock)
    16291629{
     
    16491649        /* Allocate new physical block */
    16501650        uint32_t phys_block;
    1651         int rc = ext4_balloc_alloc_block(inode_ref, &phys_block);
     1651        errno_t rc = ext4_balloc_alloc_block(inode_ref, &phys_block);
    16521652        if (rc != EOK)
    16531653                return rc;
  • uspace/lib/ext4/src/hash.c

    r36f0738 rb7fd2a0  
    3838#include "ext4/hash.h"
    3939
    40 int ext4_hash_string(ext4_hash_info_t *hinfo, int len, const char *name)
     40errno_t ext4_hash_string(ext4_hash_info_t *hinfo, int len, const char *name)
    4141{
    4242        // TODO
  • uspace/lib/ext4/src/ialloc.c

    r36f0738 rb7fd2a0  
    9797 *
    9898 */
    99 int ext4_ialloc_free_inode(ext4_filesystem_t *fs, uint32_t index, bool is_dir)
     99errno_t ext4_ialloc_free_inode(ext4_filesystem_t *fs, uint32_t index, bool is_dir)
    100100{
    101101        ext4_superblock_t *sb = fs->superblock;
     
    105105       
    106106        ext4_block_group_ref_t *bg_ref;
    107         int rc = ext4_filesystem_get_block_group_ref(fs, block_group, &bg_ref);
     107        errno_t rc = ext4_filesystem_get_block_group_ref(fs, block_group, &bg_ref);
    108108        if (rc != EOK)
    109109                return rc;
     
    175175 *
    176176 */
    177 int ext4_ialloc_alloc_inode(ext4_filesystem_t *fs, uint32_t *index, bool is_dir)
     177errno_t ext4_ialloc_alloc_inode(ext4_filesystem_t *fs, uint32_t *index, bool is_dir)
    178178{
    179179        ext4_superblock_t *sb = fs->superblock;
     
    188188                /* Load block group to check */
    189189                ext4_block_group_ref_t *bg_ref;
    190                 int rc = ext4_filesystem_get_block_group_ref(fs, bgid, &bg_ref);
     190                errno_t rc = ext4_filesystem_get_block_group_ref(fs, bgid, &bg_ref);
    191191                if (rc != EOK)
    192192                        return rc;
  • uspace/lib/ext4/src/inode.c

    r36f0738 rb7fd2a0  
    324324 *
    325325 */
    326 int ext4_inode_set_blocks_count(ext4_superblock_t *sb, ext4_inode_t *inode,
     326errno_t ext4_inode_set_blocks_count(ext4_superblock_t *sb, ext4_inode_t *inode,
    327327    uint64_t count)
    328328{
  • uspace/lib/ext4/src/ops.c

    r36f0738 rb7fd2a0  
    5858/* Forward declarations of auxiliary functions */
    5959
    60 static int ext4_read_directory(ipc_callid_t, aoff64_t, size_t,
     60static errno_t ext4_read_directory(ipc_callid_t, aoff64_t, size_t,
    6161    ext4_instance_t *, ext4_inode_ref_t *, size_t *);
    62 static int ext4_read_file(ipc_callid_t, aoff64_t, size_t, ext4_instance_t *,
     62static errno_t ext4_read_file(ipc_callid_t, aoff64_t, size_t, ext4_instance_t *,
    6363    ext4_inode_ref_t *, size_t *);
    6464static bool ext4_is_dots(const uint8_t *, size_t);
    65 static int ext4_instance_get(service_id_t, ext4_instance_t **);
     65static errno_t ext4_instance_get(service_id_t, ext4_instance_t **);
    6666
    6767/* Forward declarations of ext4 libfs operations. */
    6868
    69 static int ext4_root_get(fs_node_t **, service_id_t);
    70 static int ext4_match(fs_node_t **, fs_node_t *, const char *);
    71 static int ext4_node_get(fs_node_t **, service_id_t, fs_index_t);
    72 static int ext4_node_open(fs_node_t *);
    73        int ext4_node_put(fs_node_t *);
    74 static int ext4_create_node(fs_node_t **, service_id_t, int);
    75 static int ext4_destroy_node(fs_node_t *);
    76 static int ext4_link(fs_node_t *, fs_node_t *, const char *);
    77 static int ext4_unlink(fs_node_t *, fs_node_t *, const char *);
    78 static int ext4_has_children(bool *, fs_node_t *);
     69static errno_t ext4_root_get(fs_node_t **, service_id_t);
     70static errno_t ext4_match(fs_node_t **, fs_node_t *, const char *);
     71static errno_t ext4_node_get(fs_node_t **, service_id_t, fs_index_t);
     72static errno_t ext4_node_open(fs_node_t *);
     73       errno_t ext4_node_put(fs_node_t *);
     74static errno_t ext4_create_node(fs_node_t **, service_id_t, int);
     75static errno_t ext4_destroy_node(fs_node_t *);
     76static errno_t ext4_link(fs_node_t *, fs_node_t *, const char *);
     77static errno_t ext4_unlink(fs_node_t *, fs_node_t *, const char *);
     78static errno_t ext4_has_children(bool *, fs_node_t *);
    7979static fs_index_t ext4_index_get(fs_node_t *);
    8080static aoff64_t ext4_size_get(fs_node_t *);
     
    8383static bool ext4_is_file(fs_node_t *node);
    8484static service_id_t ext4_service_get(fs_node_t *node);
    85 static int ext4_size_block(service_id_t, uint32_t *);
    86 static int ext4_total_block_count(service_id_t, uint64_t *);
    87 static int ext4_free_block_count(service_id_t, uint64_t *);
     85static errno_t ext4_size_block(service_id_t, uint32_t *);
     86static errno_t ext4_total_block_count(service_id_t, uint64_t *);
     87static errno_t ext4_free_block_count(service_id_t, uint64_t *);
    8888
    8989/* Static variables */
     
    138138 *
    139139 */
    140 int ext4_global_init(void)
     140errno_t ext4_global_init(void)
    141141{
    142142        if (!hash_table_create(&open_nodes, 0, 0, &open_nodes_ops))
     
    152152 * @return Error code
    153153 */
    154 int ext4_global_fini(void)
     154errno_t ext4_global_fini(void)
    155155{
    156156        hash_table_destroy(&open_nodes);
     
    170170 *
    171171 */
    172 int ext4_instance_get(service_id_t service_id, ext4_instance_t **inst)
     172errno_t ext4_instance_get(service_id_t service_id, ext4_instance_t **inst)
    173173{
    174174        fibril_mutex_lock(&instance_list_mutex);
     
    199199 *
    200200 */
    201 int ext4_root_get(fs_node_t **rfn, service_id_t service_id)
     201errno_t ext4_root_get(fs_node_t **rfn, service_id_t service_id)
    202202{
    203203        return ext4_node_get(rfn, service_id, EXT4_INODE_ROOT_INDEX);
     
    215215 *
    216216 */
    217 int ext4_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
     217errno_t ext4_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
    218218{
    219219        ext4_node_t *eparent = EXT4_NODE(pfn);
     
    226226        /* Try to find entry */
    227227        ext4_directory_search_result_t result;
    228         int rc = ext4_directory_find_entry(&result, eparent->inode_ref,
     228        errno_t rc = ext4_directory_find_entry(&result, eparent->inode_ref,
    229229            component);
    230230        if (rc != EOK) {
     
    247247
    248248        /* Destroy search result structure */
    249         int const rc2 = ext4_directory_destroy_result(&result);
     249        errno_t const rc2 = ext4_directory_destroy_result(&result);
    250250        return rc == EOK ? rc2 : rc;
    251251}
     
    262262 *
    263263 */
    264 int ext4_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
     264errno_t ext4_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
    265265{
    266266        ext4_instance_t *inst;
    267         int rc = ext4_instance_get(service_id, &inst);
     267        errno_t rc = ext4_instance_get(service_id, &inst);
    268268        if (rc != EOK)
    269269                return rc;
     
    281281 *
    282282 */
    283 int ext4_node_get_core(fs_node_t **rfn, ext4_instance_t *inst,
     283errno_t ext4_node_get_core(fs_node_t **rfn, ext4_instance_t *inst,
    284284    fs_index_t index)
    285285{
     
    322322        /* Load i-node from filesystem */
    323323        ext4_inode_ref_t *inode_ref;
    324         int rc = ext4_filesystem_get_inode_ref(inst->filesystem, index,
     324        errno_t rc = ext4_filesystem_get_inode_ref(inst->filesystem, index,
    325325            &inode_ref);
    326326        if (rc != EOK) {
     
    355355 *
    356356 */
    357 static int ext4_node_put_core(ext4_node_t *enode)
     357static errno_t ext4_node_put_core(ext4_node_t *enode)
    358358{
    359359        hash_table_remove_item(&open_nodes, &enode->link);
     
    362362       
    363363        /* Put inode back in filesystem */
    364         int rc = ext4_filesystem_put_inode_ref(enode->inode_ref);
     364        errno_t rc = ext4_filesystem_put_inode_ref(enode->inode_ref);
    365365        if (rc != EOK)
    366366                return rc;
     
    382382 *
    383383 */
    384 int ext4_node_open(fs_node_t *fn)
     384errno_t ext4_node_open(fs_node_t *fn)
    385385{
    386386        /* Stateless operation */
     
    396396 *
    397397 */
    398 int ext4_node_put(fs_node_t *fn)
     398errno_t ext4_node_put(fs_node_t *fn)
    399399{
    400400        fibril_mutex_lock(&open_nodes_lock);
     
    404404        enode->references--;
    405405        if (enode->references == 0) {
    406                 int rc = ext4_node_put_core(enode);
     406                errno_t rc = ext4_node_put_core(enode);
    407407                if (rc != EOK) {
    408408                        fibril_mutex_unlock(&open_nodes_lock);
     
    425425 *
    426426 */
    427 int ext4_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
     427errno_t ext4_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
    428428{
    429429        /* Allocate enode */
     
    443443        /* Load instance */
    444444        ext4_instance_t *inst;
    445         int rc = ext4_instance_get(service_id, &inst);
     445        errno_t rc = ext4_instance_get(service_id, &inst);
    446446        if (rc != EOK) {
    447447                free(enode);
     
    486486 *
    487487 */
    488 int ext4_destroy_node(fs_node_t *fn)
     488errno_t ext4_destroy_node(fs_node_t *fn)
    489489{
    490490        /* If directory, check for children */
    491491        bool has_children;
    492         int rc = ext4_has_children(&has_children, fn);
     492        errno_t rc = ext4_has_children(&has_children, fn);
    493493        if (rc != EOK) {
    494494                ext4_node_put(fn);
     
    537537 *
    538538 */
    539 int ext4_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
     539errno_t ext4_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
    540540{
    541541        /* Check maximum name length */
     
    548548       
    549549        /* Add entry to parent directory */
    550         int rc = ext4_directory_add_entry(parent->inode_ref, name,
     550        errno_t rc = ext4_directory_add_entry(parent->inode_ref, name,
    551551            child->inode_ref);
    552552        if (rc != EOK)
     
    610610 *
    611611 */
    612 int ext4_unlink(fs_node_t *pfn, fs_node_t *cfn, const char *name)
     612errno_t ext4_unlink(fs_node_t *pfn, fs_node_t *cfn, const char *name)
    613613{
    614614        bool has_children;
    615         int rc = ext4_has_children(&has_children, cfn);
     615        errno_t rc = ext4_has_children(&has_children, cfn);
    616616        if (rc != EOK)
    617617                return rc;
     
    683683 *
    684684 */
    685 int ext4_has_children(bool *has_children, fs_node_t *fn)
     685errno_t ext4_has_children(bool *has_children, fs_node_t *fn)
    686686{
    687687        ext4_node_t *enode = EXT4_NODE(fn);
     
    696696       
    697697        ext4_directory_iterator_t it;
    698         int rc = ext4_directory_iterator_init(&it, enode->inode_ref, 0);
     698        errno_t rc = ext4_directory_iterator_init(&it, enode->inode_ref, 0);
    699699        if (rc != EOK)
    700700                return rc;
     
    824824}
    825825
    826 int ext4_size_block(service_id_t service_id, uint32_t *size)
     826errno_t ext4_size_block(service_id_t service_id, uint32_t *size)
    827827{
    828828        ext4_instance_t *inst;
    829         int rc = ext4_instance_get(service_id, &inst);
     829        errno_t rc = ext4_instance_get(service_id, &inst);
    830830        if (rc != EOK)
    831831                return rc;
     
    840840}
    841841
    842 int ext4_total_block_count(service_id_t service_id, uint64_t *count)
     842errno_t ext4_total_block_count(service_id_t service_id, uint64_t *count)
    843843{
    844844        ext4_instance_t *inst;
    845         int rc = ext4_instance_get(service_id, &inst);
     845        errno_t rc = ext4_instance_get(service_id, &inst);
    846846        if (rc != EOK)
    847847                return rc;
     
    856856}
    857857
    858 int ext4_free_block_count(service_id_t service_id, uint64_t *count)
     858errno_t ext4_free_block_count(service_id_t service_id, uint64_t *count)
    859859{
    860860        ext4_instance_t *inst;
    861         int rc = ext4_instance_get(service_id, &inst);
     861        errno_t rc = ext4_instance_get(service_id, &inst);
    862862        if (rc != EOK)
    863863                return rc;
     
    907907 * @return Error code
    908908 */
    909 static int ext4_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
     909static errno_t ext4_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
    910910{
    911911        return ext4_filesystem_probe(service_id);
     
    924924 *
    925925 */
    926 static int ext4_mounted(service_id_t service_id, const char *opts,
     926static errno_t ext4_mounted(service_id_t service_id, const char *opts,
    927927    fs_index_t *index, aoff64_t *size)
    928928{
     
    948948        /* Initialize the filesystem */
    949949        aoff64_t rnsize;
    950         int rc = ext4_filesystem_open(inst, service_id, cmode, &rnsize, &fs);
     950        errno_t rc = ext4_filesystem_open(inst, service_id, cmode, &rnsize, &fs);
    951951        if (rc != EOK) {
    952952                free(inst);
     
    974974 *
    975975 */
    976 static int ext4_unmounted(service_id_t service_id)
     976static errno_t ext4_unmounted(service_id_t service_id)
    977977{
    978978        ext4_instance_t *inst;
    979         int rc = ext4_instance_get(service_id, &inst);
     979        errno_t rc = ext4_instance_get(service_id, &inst);
    980980        if (rc != EOK)
    981981                return rc;
     
    10161016 *
    10171017 */
    1018 static int ext4_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
     1018static errno_t ext4_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
    10191019    size_t *rbytes)
    10201020{
     
    10301030       
    10311031        ext4_instance_t *inst;
    1032         int rc = ext4_instance_get(service_id, &inst);
     1032        errno_t rc = ext4_instance_get(service_id, &inst);
    10331033        if (rc != EOK) {
    10341034                async_answer_0(callid, rc);
     
    10591059        }
    10601060       
    1061         int const rc2 = ext4_filesystem_put_inode_ref(inode_ref);
     1061        errno_t const rc2 = ext4_filesystem_put_inode_ref(inode_ref);
    10621062       
    10631063        return rc == EOK ? rc2 : rc;
     
    10951095 *
    10961096 */
    1097 int ext4_read_directory(ipc_callid_t callid, aoff64_t pos, size_t size,
     1097errno_t ext4_read_directory(ipc_callid_t callid, aoff64_t pos, size_t size,
    10981098    ext4_instance_t *inst, ext4_inode_ref_t *inode_ref, size_t *rbytes)
    10991099{
    11001100        ext4_directory_iterator_t it;
    1101         int rc = ext4_directory_iterator_init(&it, inode_ref, pos);
     1101        errno_t rc = ext4_directory_iterator_init(&it, inode_ref, pos);
    11021102        if (rc != EOK) {
    11031103                async_answer_0(callid, rc);
     
    11861186 *
    11871187 */
    1188 int ext4_read_file(ipc_callid_t callid, aoff64_t pos, size_t size,
     1188errno_t ext4_read_file(ipc_callid_t callid, aoff64_t pos, size_t size,
    11891189    ext4_instance_t *inst, ext4_inode_ref_t *inode_ref, size_t *rbytes)
    11901190{
     
    12111211        /* Get the real block number */
    12121212        uint32_t fs_block;
    1213         int rc = ext4_filesystem_get_inode_data_block_index(inode_ref,
     1213        errno_t rc = ext4_filesystem_get_inode_data_block_index(inode_ref,
    12141214            file_block, &fs_block);
    12151215        if (rc != EOK) {
     
    12751275 *
    12761276 */
    1277 static int ext4_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
     1277static errno_t ext4_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
    12781278    size_t *wbytes, aoff64_t *nsize)
    12791279{
    12801280        fs_node_t *fn;
    1281         int rc = ext4_node_get(&fn, service_id, index);
     1281        errno_t rc = ext4_node_get(&fn, service_id, index);
    12821282        if (rc != EOK)
    12831283                return rc;
     
    13971397        ;
    13981398
    1399         int const rc2 = ext4_node_put(fn);
     1399        errno_t const rc2 = ext4_node_put(fn);
    14001400        return rc == EOK ? rc2 : rc;
    14011401}
     
    14121412 *
    14131413 */
    1414 static int ext4_truncate(service_id_t service_id, fs_index_t index,
     1414static errno_t ext4_truncate(service_id_t service_id, fs_index_t index,
    14151415    aoff64_t new_size)
    14161416{
    14171417        fs_node_t *fn;
    1418         int rc = ext4_node_get(&fn, service_id, index);
     1418        errno_t rc = ext4_node_get(&fn, service_id, index);
    14191419        if (rc != EOK)
    14201420                return rc;
     
    14241424       
    14251425        rc = ext4_filesystem_truncate_inode(inode_ref, new_size);
    1426         int const rc2 = ext4_node_put(fn);
     1426        errno_t const rc2 = ext4_node_put(fn);
    14271427       
    14281428        return rc == EOK ? rc2 : rc;
     
    14371437 *
    14381438 */
    1439 static int ext4_close(service_id_t service_id, fs_index_t index)
     1439static errno_t ext4_close(service_id_t service_id, fs_index_t index)
    14401440{
    14411441        return EOK;
     
    14501450 *
    14511451 */
    1452 static int ext4_destroy(service_id_t service_id, fs_index_t index)
     1452static errno_t ext4_destroy(service_id_t service_id, fs_index_t index)
    14531453{
    14541454        fs_node_t *fn;
    1455         int rc = ext4_node_get(&fn, service_id, index);
     1455        errno_t rc = ext4_node_get(&fn, service_id, index);
    14561456        if (rc != EOK)
    14571457                return rc;
     
    14671467 *
    14681468 */
    1469 static int ext4_sync(service_id_t service_id, fs_index_t index)
     1469static errno_t ext4_sync(service_id_t service_id, fs_index_t index)
    14701470{
    14711471        fs_node_t *fn;
    1472         int rc = ext4_node_get(&fn, service_id, index);
     1472        errno_t rc = ext4_node_get(&fn, service_id, index);
    14731473        if (rc != EOK)
    14741474                return rc;
  • uspace/lib/ext4/src/superblock.c

    r36f0738 rb7fd2a0  
    11271127 *
    11281128 */
    1129 int ext4_superblock_read_direct(service_id_t service_id, ext4_superblock_t **sb)
     1129errno_t ext4_superblock_read_direct(service_id_t service_id, ext4_superblock_t **sb)
    11301130{
    11311131        /* Allocated memory for superblock structure */
     
    11351135       
    11361136        /* Read data from block device */
    1137         int rc = block_read_bytes_direct(service_id, EXT4_SUPERBLOCK_OFFSET,
     1137        errno_t rc = block_read_bytes_direct(service_id, EXT4_SUPERBLOCK_OFFSET,
    11381138            EXT4_SUPERBLOCK_SIZE, data);
    11391139       
     
    11571157 *
    11581158 */
    1159 int ext4_superblock_write_direct(service_id_t service_id, ext4_superblock_t *sb)
     1159errno_t ext4_superblock_write_direct(service_id_t service_id, ext4_superblock_t *sb)
    11601160{
    11611161        /* Load physical block size from block device */
    11621162        size_t phys_block_size;
    1163         int rc = block_get_bsize(service_id, &phys_block_size);
     1163        errno_t rc = block_get_bsize(service_id, &phys_block_size);
    11641164        if (rc != EOK)
    11651165                return rc;
     
    11991199 *
    12001200 */
    1201 int ext4_superblock_check_sanity(ext4_superblock_t *sb)
     1201errno_t ext4_superblock_check_sanity(ext4_superblock_t *sb)
    12021202{
    12031203        if (ext4_superblock_get_magic(sb) != EXT4_SUPERBLOCK_MAGIC)
Note: See TracChangeset for help on using the changeset viewer.