Changeset b7fd2a0 in mainline for uspace/srv/fs/mfs


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/srv/fs/mfs
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/fs/mfs/mfs.c

    r36f0738 rb7fd2a0  
    5959int main(int argc, char **argv)
    6060{
    61         int rc;
     61        errno_t rc;
    6262
    6363        printf(NAME ": HelenOS Minix file system server\n");

  • uspace/srv/fs/mfs/mfs.h

    r36f0738 rb7fd2a0  
    169169extern libfs_ops_t mfs_libfs_ops;
    170170
    171 extern int
     171extern errno_t
    172172mfs_global_init(void);
    173173
    174174/* mfs_inode.c */
    175 extern int
     175extern errno_t
    176176mfs_get_inode(struct mfs_instance *inst, struct mfs_ino_info **ino_i,
    177177    fs_index_t index);
    178178
    179 extern int
     179extern errno_t
    180180mfs_put_inode(struct mfs_node *mnode);
    181181
    182 extern int
     182extern errno_t
    183183mfs_inode_shrink(struct mfs_node *mnode, size_t size_shrink);
    184184
    185185/* mfs_rw.c */
    186 extern int
     186extern errno_t
    187187mfs_read_map(uint32_t *b, const struct mfs_node *mnode, const uint32_t pos);
    188188
    189 extern int
     189extern errno_t
    190190mfs_write_map(struct mfs_node *mnode, uint32_t pos, uint32_t new_zone,
    191191    uint32_t *old_zone);
    192192
    193 extern int
     193extern errno_t
    194194mfs_prune_ind_zones(struct mfs_node *mnode, size_t new_size);
    195195
    196196/* mfs_dentry.c */
    197 extern int
     197extern errno_t
    198198mfs_read_dentry(struct mfs_node *mnode,
    199199    struct mfs_dentry_info *d_info, unsigned index);
    200200
    201 extern int
     201extern errno_t
    202202mfs_write_dentry(struct mfs_dentry_info *d_info);
    203203
    204 extern int
     204extern errno_t
    205205mfs_remove_dentry(struct mfs_node *mnode, const char *d_name);
    206206
    207 extern int
     207extern errno_t
    208208mfs_insert_dentry(struct mfs_node *mnode, const char *d_name, fs_index_t d_inum);
    209209
    210210/* mfs_balloc.c */
    211 extern int
     211extern errno_t
    212212mfs_alloc_inode(struct mfs_instance *inst, uint32_t *inum);
    213213
    214 extern int
     214extern errno_t
    215215mfs_free_inode(struct mfs_instance *inst, uint32_t inum);
    216216
    217 extern int
     217extern errno_t
    218218mfs_alloc_zone(struct mfs_instance *inst, uint32_t *zone);
    219219
    220 extern int
     220extern errno_t
    221221mfs_free_zone(struct mfs_instance *inst, uint32_t zone);
    222222
    223 extern int
     223extern errno_t
    224224mfs_count_free_zones(struct mfs_instance *inst, uint32_t *zones);
    225225
    226 extern int
     226extern errno_t
    227227mfs_count_free_inodes(struct mfs_instance *inst, uint32_t *inodes);
    228228

  • uspace/srv/fs/mfs/mfs_balloc.c

    r36f0738 rb7fd2a0  
    3838    const bool native, unsigned start_bit);
    3939
    40 static int
     40static errno_t
    4141mfs_free_bit(struct mfs_instance *inst, uint32_t idx, bmap_id_t bid);
    4242
    43 static int
     43static errno_t
    4444mfs_alloc_bit(struct mfs_instance *inst, uint32_t *idx, bmap_id_t bid);
    4545
    46 static int
     46static errno_t
    4747mfs_count_free_bits(struct mfs_instance *inst, bmap_id_t bid, uint32_t *free);
    4848
    … …  
    5656 * @return              EOK on success or an error code.
    5757 */
    58 int
     58errno_t
    5959mfs_alloc_inode(struct mfs_instance *inst, uint32_t *inum)
    6060{
    61         int r = mfs_alloc_bit(inst, inum, BMAP_INODE);
     61        errno_t r = mfs_alloc_bit(inst, inum, BMAP_INODE);
    6262        return r;
    6363}
    … …  
    7070 * @return              EOK on success or an error code.
    7171 */
    72 int
     72errno_t
    7373mfs_free_inode(struct mfs_instance *inst, uint32_t inum)
    7474{
    … …  
    8484 * @return              EOK on success or an error code.
    8585 */
    86 int
     86errno_t
    8787mfs_alloc_zone(struct mfs_instance *inst, uint32_t *zone)
    8888{
    89         int r = mfs_alloc_bit(inst, zone, BMAP_ZONE);
     89        errno_t r = mfs_alloc_bit(inst, zone, BMAP_ZONE);
    9090        if (r != EOK)
    9191                return r;
    … …  
    107107 * @return              EOK on success or an error code.
    108108 */
    109 int
     109errno_t
    110110mfs_free_zone(struct mfs_instance *inst, uint32_t zone)
    111111{
    112         int r;
     112        errno_t r;
    113113
    114114        zone -= inst->sbi->firstdatazone - 1;
    … …  
    134134 * @return              EOK on success or an error code.
    135135 */
    136 int
     136errno_t
    137137mfs_count_free_zones(struct mfs_instance *inst, uint32_t *zones)
    138138{
    … …  
    149149 */
    150150
    151 int
     151errno_t
    152152mfs_count_free_inodes(struct mfs_instance *inst, uint32_t *inodes)
    153153{
    … …  
    164164 * @return              EOK on success or an error code.
    165165 */
    166 static int
     166static errno_t
    167167mfs_count_free_bits(struct mfs_instance *inst, bmap_id_t bid, uint32_t *free)
    168168{
    169         int r;
     169        errno_t r;
    170170        unsigned start_block;
    171171        unsigned long nblocks;
    … …  
    228228 * @return              EOK on success or an error code.
    229229 */
    230 static int
     230static errno_t
    231231mfs_free_bit(struct mfs_instance *inst, uint32_t idx, bmap_id_t bid)
    232232{
    233233        struct mfs_sb_info *sbi;
    234         int r;
     234        errno_t r;
    235235        unsigned start_block;
    236236        unsigned *search;
    … …  
    295295 * @return              EOK on success or an error code.
    296296 */
    297 static int
     297static errno_t
    298298mfs_alloc_bit(struct mfs_instance *inst, uint32_t *idx, bmap_id_t bid)
    299299{
    … …  
    303303        unsigned *search, i, start_block;
    304304        unsigned bits_per_block;
    305         int r;
     305        errno_t r;
    306306        int freebit;
    307307

  • uspace/srv/fs/mfs/mfs_dentry.c

    r36f0738 rb7fd2a0  
    4242 * @return              EOK on success or an error code.
    4343 */
    44 int
     44errno_t
    4545mfs_read_dentry(struct mfs_node *mnode,
    4646    struct mfs_dentry_info *d_info, unsigned index)
    … …  
    5252        block_t *b;
    5353
    54         int r = mfs_read_map(&block, mnode, index * sbi->dirsize);
     54        errno_t r = mfs_read_map(&block, mnode, index * sbi->dirsize);
    5555        if (r != EOK)
    5656                goto out_err;
    … …  
    105105 * @return       EOK on success or an error code.
    106106 */
    107 int
     107errno_t
    108108mfs_write_dentry(struct mfs_dentry_info *d_info)
    109109{
    … …  
    114114        block_t *b;
    115115        uint32_t block;
    116         int r;
     116        errno_t r;
    117117
    118118        r = mfs_read_map(&block, mnode, d_off_bytes);
    … …  
    156156 * @return              EOK on success or an error code.
    157157 */
    158 int
     158errno_t
    159159mfs_remove_dentry(struct mfs_node *mnode, const char *d_name)
    160160{
    161161        struct mfs_sb_info *sbi = mnode->instance->sbi;
    162162        struct mfs_dentry_info d_info;
    163         int r;
     163        errno_t r;
    164164
    165165        const size_t name_len = str_size(d_name);
    … …  
    197197 * @return              EOK on success or an error code.
    198198 */
    199 int
     199errno_t
    200200mfs_insert_dentry(struct mfs_node *mnode, const char *d_name,
    201201    fs_index_t d_inum)
    202202{
    203         int r;
     203        errno_t r;
    204204        struct mfs_sb_info *sbi = mnode->instance->sbi;
    205205        struct mfs_dentry_info d_info;

  • uspace/srv/fs/mfs/mfs_inode.c

    r36f0738 rb7fd2a0  
    3434#include "mfs.h"
    3535
    36 static int
     36static errno_t
    3737mfs_write_inode_raw(struct mfs_node *mnode);
    3838
    39 static int
     39static errno_t
    4040mfs2_write_inode_raw(struct mfs_node *mnode);
    4141
    42 static int
     42static errno_t
    4343mfs_read_inode_raw(const struct mfs_instance *instance,
    4444    struct mfs_ino_info **ino_ptr, uint16_t inum);
    4545
    46 static int
     46static errno_t
    4747mfs2_read_inode_raw(const struct mfs_instance *instance,
    4848    struct mfs_ino_info **ino_ptr, uint32_t inum);
    … …  
    5757 * @return              EOK on success or an error code.
    5858 */
    59 int
     59errno_t
    6060mfs_get_inode(struct mfs_instance *inst, struct mfs_ino_info **ino_i,
    6161    fs_index_t index)
    6262{
    6363        struct mfs_sb_info *sbi = inst->sbi;
    64         int r;
     64        errno_t r;
    6565
    6666        if (sbi->fs_version == MFS_VERSION_V1) {
    … …  
    7575}
    7676
    77 static int
     77static errno_t
    7878mfs_read_inode_raw(const struct mfs_instance *instance,
    7979    struct mfs_ino_info **ino_ptr, uint16_t inum)
    … …  
    8484        block_t *b;
    8585        int i;
    86         int r;
     86        errno_t r;
    8787
    8888        sbi = instance->sbi;
    … …  
    135135}
    136136
    137 static int
     137static errno_t
    138138mfs2_read_inode_raw(const struct mfs_instance *instance,
    139139    struct mfs_ino_info **ino_ptr, uint32_t inum)
    … …  
    144144        block_t *b;
    145145        int i;
    146         int r;
     146        errno_t r;
    147147
    148148        ino_i = malloc(sizeof(*ino_i));
    … …  
    203203 * @return              EOK on success or an error code.
    204204 */
    205 int
     205errno_t
    206206mfs_put_inode(struct mfs_node *mnode)
    207207{
    208         int rc = EOK;
     208        errno_t rc = EOK;
    209209
    210210        if (!mnode->ino_i->dirty)
    … …  
    223223}
    224224
    225 static int
     225static errno_t
    226226mfs_write_inode_raw(struct mfs_node *mnode)
    227227{
    228228        int i;
    229         int r;
     229        errno_t r;
    230230        block_t *b;
    231231        struct mfs_ino_info *ino_i = mnode->ino_i;
    … …  
    267267}
    268268
    269 static int
     269static errno_t
    270270mfs2_write_inode_raw(struct mfs_node *mnode)
    271271{
    … …  
    274274        block_t *b;
    275275        int i;
    276         int r;
     276        errno_t r;
    277277
    278278        const uint32_t inum = ino_i->index - 1;
    … …  
    321321 * @return              EOK on success or an error code.
    322322 */
    323 int
     323errno_t
    324324mfs_inode_shrink(struct mfs_node *mnode, size_t size_shrink)
    325325{
    … …  
    327327        struct mfs_ino_info *ino_i = mnode->ino_i;
    328328        const size_t bs = sbi->block_size;
    329         int r;
     329        errno_t r;
    330330
    331331        if (size_shrink == 0) {

  • uspace/srv/fs/mfs/mfs_ops.c

    r36f0738 rb7fd2a0  
    4141static bool check_magic_number(uint16_t magic, bool *native,
    4242    mfs_version_t *version, bool *longfilenames);
    43 static int mfs_node_core_get(fs_node_t **rfn, struct mfs_instance *inst,
     43static errno_t mfs_node_core_get(fs_node_t **rfn, struct mfs_instance *inst,
    4444    fs_index_t index);
    45 static int mfs_node_put(fs_node_t *fsnode);
    46 static int mfs_node_open(fs_node_t *fsnode);
     45static errno_t mfs_node_put(fs_node_t *fsnode);
     46static errno_t mfs_node_open(fs_node_t *fsnode);
    4747static fs_index_t mfs_index_get(fs_node_t *fsnode);
    4848static unsigned mfs_lnkcnt_get(fs_node_t *fsnode);
    4949static bool mfs_is_directory(fs_node_t *fsnode);
    5050static bool mfs_is_file(fs_node_t *fsnode);
    51 static int mfs_has_children(bool *has_children, fs_node_t *fsnode);
    52 static int mfs_root_get(fs_node_t **rfn, service_id_t service_id);
     51static errno_t mfs_has_children(bool *has_children, fs_node_t *fsnode);
     52static errno_t mfs_root_get(fs_node_t **rfn, service_id_t service_id);
    5353static service_id_t mfs_service_get(fs_node_t *fsnode);
    5454static aoff64_t mfs_size_get(fs_node_t *node);
    55 static int mfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component);
    56 static int mfs_create_node(fs_node_t **rfn, service_id_t service_id, int flags);
    57 static int mfs_link(fs_node_t *pfn, fs_node_t *cfn, const char *name);
    58 static int mfs_unlink(fs_node_t *, fs_node_t *, const char *name);
    59 static int mfs_destroy_node(fs_node_t *fn);
    60 static int mfs_node_get(fs_node_t **rfn, service_id_t service_id,
     55static errno_t mfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component);
     56static errno_t mfs_create_node(fs_node_t **rfn, service_id_t service_id, int flags);
     57static errno_t mfs_link(fs_node_t *pfn, fs_node_t *cfn, const char *name);
     58static errno_t mfs_unlink(fs_node_t *, fs_node_t *, const char *name);
     59static errno_t mfs_destroy_node(fs_node_t *fn);
     60static errno_t mfs_node_get(fs_node_t **rfn, service_id_t service_id,
    6161    fs_index_t index);
    62 static int mfs_instance_get(service_id_t service_id,
     62static errno_t mfs_instance_get(service_id_t service_id,
    6363    struct mfs_instance **instance);
    64 static int mfs_check_sanity(struct mfs_sb_info *sbi);
     64static errno_t mfs_check_sanity(struct mfs_sb_info *sbi);
    6565static bool is_power_of_two(uint32_t n);
    66 static int mfs_size_block(service_id_t service_id, uint32_t *size);
    67 static int mfs_total_block_count(service_id_t service_id, uint64_t *count);
    68 static int mfs_free_block_count(service_id_t service_id, uint64_t *count);
     66static errno_t mfs_size_block(service_id_t service_id, uint32_t *size);
     67static errno_t mfs_total_block_count(service_id_t service_id, uint64_t *count);
     68static errno_t mfs_free_block_count(service_id_t service_id, uint64_t *count);
    6969
    7070static hash_table_t open_nodes;
    … …  
    131131};
    132132
    133 int
     133errno_t
    134134mfs_global_init(void)
    135135{
    … …  
    142142/** Read the superblock.
    143143 */
    144 static int mfs_read_sb(service_id_t service_id, struct mfs_sb_info **rsbi)
     144static errno_t mfs_read_sb(service_id_t service_id, struct mfs_sb_info **rsbi)
    145145{
    146146        struct mfs_superblock *sb = NULL;
    … …  
    151151        mfs_version_t version;
    152152        uint16_t magic;
    153         int rc;
     153        errno_t rc;
    154154
    155155        /* Allocate space for generic MFS superblock */
    … …  
    277277
    278278
    279 static int mfs_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
     279static errno_t mfs_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
    280280{
    281281        struct mfs_sb_info *sbi = NULL;
    282         int rc;
     282        errno_t rc;
    283283
    284284        /* Initialize libblock */
    … …  
    294294}
    295295
    296 static int
     296static errno_t
    297297mfs_mounted(service_id_t service_id, const char *opts, fs_index_t *index,
    298298    aoff64_t *size)
    … …  
    301301        struct mfs_sb_info *sbi = NULL;
    302302        struct mfs_instance *instance = NULL;
    303         int rc;
     303        errno_t rc;
    304304
    305305        /* Check for option enabling write through. */
    … …  
    365365}
    366366
    367 static int
     367static errno_t
    368368mfs_unmounted(service_id_t service_id)
    369369{
    … …  
    372372        mfsdebug("%s()\n", __FUNCTION__);
    373373
    374         int r = mfs_instance_get(service_id, &inst);
     374        errno_t r = mfs_instance_get(service_id, &inst);
    375375        if (r != EOK)
    376376                return r;
    … …  
    396396}
    397397
    398 static int
     398static errno_t
    399399mfs_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
    400400{
    401         int r;
     401        errno_t r;
    402402        struct mfs_instance *inst;
    403403        struct mfs_node *mnode;
    … …  
    483483}
    484484
    485 static int
     485static errno_t
    486486mfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
    487487{
    … …  
    489489        struct mfs_ino_info *ino_i = mnode->ino_i;
    490490        struct mfs_dentry_info d_info;
    491         int r;
     491        errno_t r;
    492492
    493493        if (!S_ISDIR(ino_i->i_mode))
    … …  
    530530}
    531531
    532 static int
     532static errno_t
    533533mfs_node_get(fs_node_t **rfn, service_id_t service_id,
    534534    fs_index_t index)
    535535{
    536         int rc;
     536        errno_t rc;
    537537        struct mfs_instance *instance;
    538538
    … …  
    544544}
    545545
    546 static int
     546static errno_t
    547547mfs_node_put(fs_node_t *fsnode)
    548548{
    549         int rc = EOK;
     549        errno_t rc = EOK;
    550550        struct mfs_node *mnode = fsnode->data;
    551551
    … …  
    568568}
    569569
    570 static int
     570static errno_t
    571571mfs_node_open(fs_node_t *fsnode)
    572572{
    … …  
    601601}
    602602
    603 static int
     603static errno_t
    604604mfs_node_core_get(fs_node_t **rfn, struct mfs_instance *inst,
    605605    fs_index_t index)
    … …  
    607607        fs_node_t *node = NULL;
    608608        struct mfs_node *mnode = NULL;
    609         int rc;
     609        errno_t rc;
    610610
    611611        fibril_mutex_lock(&open_nodes_lock);
    … …  
    688688}
    689689
    690 static int
     690static errno_t
    691691mfs_root_get(fs_node_t **rfn, service_id_t service_id)
    692692{
    693         int rc = mfs_node_get(rfn, service_id, MFS_ROOT_INO);
     693        errno_t rc = mfs_node_get(rfn, service_id, MFS_ROOT_INO);
    694694        return rc;
    695695}
    696696
    697 static int
     697static errno_t
    698698mfs_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
    699699{
    … …  
    706706                return ENAMETOOLONG;
    707707
    708         int r = mfs_insert_dentry(parent, name, child->ino_i->index);
     708        errno_t r = mfs_insert_dentry(parent, name, child->ino_i->index);
    709709        if (r != EOK)
    710710                return r;
    … …  
    736736exit:
    737737        if (destroy_dentry) {
    738                 int r2 = mfs_remove_dentry(parent, name);
     738                errno_t r2 = mfs_remove_dentry(parent, name);
    739739                if (r2 != EOK)
    740740                        r = r2;
    … …  
    746746}
    747747
    748 static int
     748static errno_t
    749749mfs_unlink(fs_node_t *pfn, fs_node_t *cfn, const char *name)
    750750{
    … …  
    752752        struct mfs_node *child = cfn->data;
    753753        bool has_children;
    754         int r;
     754        errno_t r;
    755755
    756756        if (!parent)
    … …  
    787787}
    788788
    789 static int
     789static errno_t
    790790mfs_has_children(bool *has_children, fs_node_t *fsnode)
    791791{
    792792        struct mfs_node *mnode = fsnode->data;
    793793        struct mfs_sb_info *sbi = mnode->instance->sbi;
    794         int r;
     794        errno_t r;
    795795
    796796        *has_children = false;
    … …  
    819819}
    820820
    821 static int
     821static errno_t
    822822mfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
    823823    size_t *rbytes)
    824824{
    825         int rc;
     825        errno_t rc;
    826826        fs_node_t *fn = NULL;
    827827
    … …  
    926926out_error:
    927927        ;
    928         int tmp = mfs_node_put(fn);
     928        errno_t tmp = mfs_node_put(fn);
    929929        async_answer_0(callid, tmp != EOK ? tmp : rc);
    930930        return tmp != EOK ? tmp : rc;
    931931}
    932932
    933 static int
     933static errno_t
    934934mfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
    935935    size_t *wbytes, aoff64_t *nsize)
    936936{
    937937        fs_node_t *fn;
    938         int r;
     938        errno_t r;
    939939        int flags = BLOCK_FLAGS_NONE;
    940940
    … …  
    10151015}
    10161016
    1017 static int
     1017static errno_t
    10181018mfs_destroy(service_id_t service_id, fs_index_t index)
    10191019{
    10201020        fs_node_t *fn = NULL;
    1021         int r;
     1021        errno_t r;
    10221022
    10231023        r = mfs_node_get(&fn, service_id, index);
    … …  
    10311031}
    10321032
    1033 static int
     1033static errno_t
    10341034mfs_destroy_node(fs_node_t *fn)
    10351035{
    10361036        struct mfs_node *mnode = fn->data;
    10371037        bool has_children;
    1038         int r;
     1038        errno_t r;
    10391039
    10401040        mfsdebug("mfs_destroy_node %d\n", mnode->ino_i->index);
    … …  
    10591059}
    10601060
    1061 static int
     1061static errno_t
    10621062mfs_truncate(service_id_t service_id, fs_index_t index, aoff64_t size)
    10631063{
    10641064        fs_node_t *fn;
    1065         int r;
     1065        errno_t r;
    10661066
    10671067        r = mfs_node_get(&fn, service_id, index);
    … …  
    10831083}
    10841084
    1085 static int
     1085static errno_t
    10861086mfs_instance_get(service_id_t service_id, struct mfs_instance **instance)
    10871087{
    10881088        void *data;
    1089         int rc;
     1089        errno_t rc;
    10901090
    10911091        rc = fs_instance_get(service_id, &data);
    … …  
    11351135 * @return EOK on success, ENOTSUP otherwise.
    11361136 */
    1137 static int
     1137static errno_t
    11381138mfs_check_sanity(struct mfs_sb_info *sbi)
    11391139{
    … …  
    11521152}
    11531153
    1154 static int
     1154static errno_t
    11551155mfs_close(service_id_t service_id, fs_index_t index)
    11561156{
    … …  
    11581158}
    11591159
    1160 static int
     1160static errno_t
    11611161mfs_sync(service_id_t service_id, fs_index_t index)
    11621162{
    11631163        fs_node_t *fn = NULL;
    1164         int rc = mfs_node_get(&fn, service_id, index);
     1164        errno_t rc = mfs_node_get(&fn, service_id, index);
    11651165        if (rc != EOK)
    11661166                return rc;
    … …  
    11891189}
    11901190
    1191 static int
     1191static errno_t
    11921192mfs_size_block(service_id_t service_id, uint32_t *size)
    11931193{
    11941194        struct mfs_instance *inst;
    1195         int rc;
     1195        errno_t rc;
    11961196
    11971197        rc = mfs_instance_get(service_id, &inst);
    … …  
    12071207}
    12081208
    1209 static int
     1209static errno_t
    12101210mfs_total_block_count(service_id_t service_id, uint64_t *count)
    12111211{
    12121212        struct mfs_instance *inst;
    1213         int rc;
     1213        errno_t rc;
    12141214       
    12151215        rc = mfs_instance_get(service_id, &inst);
    … …  
    12251225}
    12261226
    1227 static int
     1227static errno_t
    12281228mfs_free_block_count(service_id_t service_id, uint64_t *count)
    12291229{
    … …  
    12311231       
    12321232        struct mfs_instance *inst;
    1233         int rc = mfs_instance_get(service_id, &inst);
     1233        errno_t rc = mfs_instance_get(service_id, &inst);
    12341234        if (rc != EOK)
    12351235                return rc;

  • uspace/srv/fs/mfs/mfs_rw.c

    r36f0738 rb7fd2a0  
    3434#include "mfs.h"
    3535
    36 static int
     36static errno_t
    3737rw_map_ondisk(uint32_t *b, const struct mfs_node *mnode, int rblock,
    3838    bool write_mode, uint32_t w_block);
    3939
    40 static int
     40static errno_t
    4141reset_zone_content(struct mfs_instance *inst, uint32_t zone);
    4242
    43 static int
     43static errno_t
    4444alloc_zone_and_clear(struct mfs_instance *inst, uint32_t *zone);
    4545
    46 static int
     46static errno_t
    4747read_ind_zone(struct mfs_instance *inst, uint32_t zone, uint32_t **ind_zone);
    4848
    49 static int
     49static errno_t
    5050write_ind_zone(struct mfs_instance *inst, uint32_t zone, uint32_t *ind_zone);
    5151
    … …  
    6161 * @return      EOK on success or an error code.
    6262 */
    63 int
     63errno_t
    6464mfs_read_map(uint32_t *b, const struct mfs_node *mnode, uint32_t pos)
    6565{
    66         int r;
     66        errno_t r;
    6767        const struct mfs_sb_info *sbi = mnode->instance->sbi;
    6868        const int block_size = sbi->block_size;
    … …  
    8383}
    8484
    85 int
     85errno_t
    8686mfs_write_map(struct mfs_node *mnode, const uint32_t pos, uint32_t new_zone,
    8787    uint32_t *old_zone)
    … …  
    100100}
    101101
    102 static int
     102static errno_t
    103103rw_map_ondisk(uint32_t *b, const struct mfs_node *mnode, int rblock,
    104104    bool write_mode, uint32_t w_block)
    … …  
    107107        int ptrs_per_block;
    108108        uint32_t *ind_zone = NULL, *ind2_zone = NULL;
    109         int r = EOK;
     109        errno_t r = EOK;
    110110
    111111        struct mfs_ino_info *ino_i = mnode->ino_i;
    … …  
    238238 * @return              EOK on success or an error code.
    239239 */
    240 int
     240errno_t
    241241mfs_prune_ind_zones(struct mfs_node *mnode, size_t new_size)
    242242{
    … …  
    245245        struct mfs_ino_info *ino_i = mnode->ino_i;
    246246        int nr_direct, ptrs_per_block, rblock;
    247         int r;
     247        errno_t r;
    248248        int i;
    249249
    … …  
    312312}
    313313
    314 static int
     314static errno_t
    315315reset_zone_content(struct mfs_instance *inst, uint32_t zone)
    316316{
    317317        block_t *b;
    318         int r;
     318        errno_t r;
    319319
    320320        r = block_get(&b, inst->service_id, zone, BLOCK_FLAGS_NOREAD);
    … …  
    328328}
    329329
    330 static int
     330static errno_t
    331331alloc_zone_and_clear(struct mfs_instance *inst, uint32_t *zone)
    332332{
    333         int r;
     333        errno_t r;
    334334
    335335        r = mfs_alloc_zone(inst, zone);
    … …  
    341341}
    342342
    343 static int
     343static errno_t
    344344read_ind_zone(struct mfs_instance *inst, uint32_t zone, uint32_t **ind_zone)
    345345{
    346346        struct mfs_sb_info *sbi = inst->sbi;
    347         int r;
     347        errno_t r;
    348348        unsigned i;
    349349        block_t *b;
    … …  
    376376}
    377377
    378 static int
     378static errno_t
    379379write_ind_zone(struct mfs_instance *inst, uint32_t zone, uint32_t *ind_zone)
    380380{
    381381        struct mfs_sb_info *sbi = inst->sbi;
    382         int r;
     382        errno_t r;
    383383        unsigned i;
    384384        block_t *b;
Note: See TracChangeset for help on using the changeset viewer.