Changeset 46577995 in mainline for uspace/srv/fs


Ignore:
Timestamp:
2018-01-04T20:50:52Z (8 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Children:
e211ea04
Parents:
facacc71
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-01-04 20:47:53)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-01-04 20:50:52)
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.

After this commit, HelenOS is free of code that mixes error codes with non-error
values on the assumption that error codes are negative.

Location:
uspace/srv/fs
Files:
41 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/fs/cdfs/cdfs.c

    rfacacc71 r46577995  
    8282        }
    8383       
    84         int rc = fs_register(vfs_sess, &cdfs_vfs_info, &cdfs_ops,
     84        errno_t rc = fs_register(vfs_sess, &cdfs_vfs_info, &cdfs_ops,
    8585            &cdfs_libfs_ops);
    8686        if (rc != EOK) {

  • uspace/srv/fs/cdfs/cdfs_ops.c

    rfacacc71 r46577995  
    331331};
    332332
    333 static int cdfs_node_get(fs_node_t **rfn, service_id_t service_id,
     333static errno_t cdfs_node_get(fs_node_t **rfn, service_id_t service_id,
    334334    fs_index_t index)
    335335{
    … …  
    351351}
    352352
    353 static int cdfs_root_get(fs_node_t **rfn, service_id_t service_id)
     353static errno_t cdfs_root_get(fs_node_t **rfn, service_id_t service_id)
    354354{
    355355        return cdfs_node_get(rfn, service_id, CDFS_SOME_ROOT);
    … …  
    371371}
    372372
    373 static int create_node(fs_node_t **rfn, cdfs_t *fs, int lflag,
     373static errno_t create_node(fs_node_t **rfn, cdfs_t *fs, int lflag,
    374374    fs_index_t index)
    375375{
    … …  
    392392       
    393393        fs_node_t *rootfn;
    394         int rc = cdfs_root_get(&rootfn, fs->service_id);
     394        errno_t rc = cdfs_root_get(&rootfn, fs->service_id);
    395395       
    396396        assert(rc == EOK);
    … …  
    417417}
    418418
    419 static int link_node(fs_node_t *pfn, fs_node_t *fn, const char *name)
     419static errno_t link_node(fs_node_t *pfn, fs_node_t *fn, const char *name)
    420420{
    421421        cdfs_node_t *parent = CDFS_NODE(pfn);
    … …  
    460460static char *cdfs_decode_str(void *data, size_t dsize, cdfs_enc_t enc)
    461461{
    462         int rc;
     462        errno_t rc;
    463463        char *str;
    464464        uint16_t *buf;
    … …  
    566566}
    567567
    568 static int cdfs_readdir(cdfs_t *fs, fs_node_t *fs_node)
     568static errno_t cdfs_readdir(cdfs_t *fs, fs_node_t *fs_node)
    569569{
    570570        cdfs_node_t *node = CDFS_NODE(fs_node);
    … …  
    580580        for (uint32_t i = 0; i < blocks; i++) {
    581581                block_t *block;
    582                 int rc = block_get(&block, fs->service_id, node->lba + i, BLOCK_FLAGS_NONE);
     582                errno_t rc = block_get(&block, fs->service_id, node->lba + i, BLOCK_FLAGS_NONE);
    583583                if (rc != EOK)
    584584                        return rc;
    … …  
    614614                       
    615615                        fs_node_t *fn;
    616                         int rc = create_node(&fn, fs, dentry_type,
     616                        errno_t rc = create_node(&fn, fs, dentry_type,
    617617                            (node->lba + i) * BLOCK_SIZE + offset);
    618618                        if (rc != EOK)
    … …  
    652652       
    653653        block_t *block;
    654         int rc = block_get(&block, fs->service_id, lba, BLOCK_FLAGS_NONE);
     654        errno_t rc = block_get(&block, fs->service_id, lba, BLOCK_FLAGS_NONE);
    655655        if (rc != EOK)
    656656                return NULL;
    … …  
    698698}
    699699
    700 static int cdfs_match(fs_node_t **fn, fs_node_t *pfn, const char *component)
     700static errno_t cdfs_match(fs_node_t **fn, fs_node_t *pfn, const char *component)
    701701{
    702702        cdfs_node_t *parent = CDFS_NODE(pfn);
    703703       
    704704        if (!parent->processed) {
    705                 int rc = cdfs_readdir(parent->fs, pfn);
     705                errno_t rc = cdfs_readdir(parent->fs, pfn);
    706706                if (rc != EOK)
    707707                        return rc;
    … …  
    719719}
    720720
    721 static int cdfs_node_open(fs_node_t *fn)
     721static errno_t cdfs_node_open(fs_node_t *fn)
    722722{
    723723        cdfs_node_t *node = CDFS_NODE(fn);
    … …  
    730730}
    731731
    732 static int cdfs_node_put(fs_node_t *fn)
     732static errno_t cdfs_node_put(fs_node_t *fn)
    733733{
    734734        /* Nothing to do */
    … …  
    736736}
    737737
    738 static int cdfs_create_node(fs_node_t **fn, service_id_t service_id, int lflag)
     738static errno_t cdfs_create_node(fs_node_t **fn, service_id_t service_id, int lflag)
    739739{
    740740        /* Read-only */
    … …  
    742742}
    743743
    744 static int cdfs_destroy_node(fs_node_t *fn)
     744static errno_t cdfs_destroy_node(fs_node_t *fn)
    745745{
    746746        /* Read-only */
    … …  
    748748}
    749749
    750 static int cdfs_link_node(fs_node_t *pfn, fs_node_t *cfn, const char *name)
     750static errno_t cdfs_link_node(fs_node_t *pfn, fs_node_t *cfn, const char *name)
    751751{
    752752        /* Read-only */
    … …  
    754754}
    755755
    756 static int cdfs_unlink_node(fs_node_t *pfn, fs_node_t *cfn, const char *name)
     756static errno_t cdfs_unlink_node(fs_node_t *pfn, fs_node_t *cfn, const char *name)
    757757{
    758758        /* Read-only */
    … …  
    760760}
    761761
    762 static int cdfs_has_children(bool *has_children, fs_node_t *fn)
     762static errno_t cdfs_has_children(bool *has_children, fs_node_t *fn)
    763763{
    764764        cdfs_node_t *node = CDFS_NODE(fn);
    … …  
    806806}
    807807
    808 static int cdfs_size_block(service_id_t service_id, uint32_t *size)
     808static errno_t cdfs_size_block(service_id_t service_id, uint32_t *size)
    809809{
    810810        *size = BLOCK_SIZE;
    … …  
    813813}
    814814
    815 static int cdfs_total_block_count(service_id_t service_id, uint64_t *count)
     815static errno_t cdfs_total_block_count(service_id_t service_id, uint64_t *count)
    816816{
    817817        *count = 0;
    … …  
    820820}
    821821
    822 static int cdfs_free_block_count(service_id_t service_id, uint64_t *count)
     822static errno_t cdfs_free_block_count(service_id_t service_id, uint64_t *count)
    823823{
    824824        *count = 0;
    … …  
    851851/** Verify that escape sequence corresonds to one of the allowed encoding
    852852 * escape sequences allowed for Joliet. */
    853 static int cdfs_verify_joliet_esc_seq(uint8_t *seq)
     853static errno_t cdfs_verify_joliet_esc_seq(uint8_t *seq)
    854854{
    855855        size_t i, j, k;
    … …  
    895895 * @return              EOK if found, ENOENT if not
    896896 */
    897 static int cdfs_find_joliet_svd(service_id_t sid, cdfs_lba_t altroot,
     897static errno_t cdfs_find_joliet_svd(service_id_t sid, cdfs_lba_t altroot,
    898898    uint32_t *rlba, uint32_t *rsize, char **vol_ident)
    899899{
    … …  
    902902        for (bi = altroot + 17; ; bi++) {
    903903                block_t *block;
    904                 int rc = block_get(&block, sid, bi, BLOCK_FLAGS_NONE);
     904                errno_t rc = block_get(&block, sid, bi, BLOCK_FLAGS_NONE);
    905905                if (rc != EOK)
    906906                        break;
    … …  
    963963
    964964/** Read the volume descriptors. */
    965 static int iso_read_vol_desc(service_id_t sid, cdfs_lba_t altroot,
     965static errno_t iso_read_vol_desc(service_id_t sid, cdfs_lba_t altroot,
    966966    uint32_t *rlba, uint32_t *rsize, cdfs_enc_t *enc, char **vol_ident)
    967967{
    968968        /* First 16 blocks of isofs are empty */
    969969        block_t *block;
    970         int rc = block_get(&block, sid, altroot + 16, BLOCK_FLAGS_NONE);
     970        errno_t rc = block_get(&block, sid, altroot + 16, BLOCK_FLAGS_NONE);
    971971        if (rc != EOK)
    972972                return rc;
    … …  
    10361036}
    10371037
    1038 static int iso_readfs(cdfs_t *fs, fs_node_t *rfn,
     1038static errno_t iso_readfs(cdfs_t *fs, fs_node_t *rfn,
    10391039    cdfs_lba_t altroot)
    10401040{
    10411041        cdfs_node_t *node = CDFS_NODE(rfn);
    10421042       
    1043         int rc = iso_read_vol_desc(fs->service_id, altroot, &node->lba,
     1043        errno_t rc = iso_read_vol_desc(fs->service_id, altroot, &node->lba,
    10441044            &node->size, &fs->enc, &fs->vol_ident);
    10451045        if (rc != EOK)
    … …  
    10641064       
    10651065        /* Create root node */
    1066         int rc = create_node(&rfn, fs, L_DIRECTORY, cdfs_index++);
     1066        errno_t rc = create_node(&rfn, fs, L_DIRECTORY, cdfs_index++);
    10671067       
    10681068        if ((rc != EOK) || (!rfn))
    … …  
    10861086}
    10871087
    1088 static int cdfs_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
     1088static errno_t cdfs_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
    10891089{
    10901090        char *vol_ident;
    10911091
    10921092        /* Initialize the block layer */
    1093         int rc = block_init(service_id, BLOCK_SIZE);
     1093        errno_t rc = block_init(service_id, BLOCK_SIZE);
    10941094        if (rc != EOK)
    10951095                return rc;
    … …  
    11441144}
    11451145
    1146 static int cdfs_mounted(service_id_t service_id, const char *opts,
     1146static errno_t cdfs_mounted(service_id_t service_id, const char *opts,
    11471147    fs_index_t *index, aoff64_t *size)
    11481148{
    11491149        /* Initialize the block layer */
    1150         int rc = block_init(service_id, BLOCK_SIZE);
     1150        errno_t rc = block_init(service_id, BLOCK_SIZE);
    11511151        if (rc != EOK)
    11521152                return rc;
    … …  
    12381238}
    12391239
    1240 static int cdfs_unmounted(service_id_t service_id)
     1240static errno_t cdfs_unmounted(service_id_t service_id)
    12411241{
    12421242        cdfs_t *fs;
    … …  
    12501250}
    12511251
    1252 static int cdfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
     1252static errno_t cdfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
    12531253    size_t *rbytes)
    12541254{
    … …  
    12661266       
    12671267        if (!node->processed) {
    1268                 int rc = cdfs_readdir(node->fs, FS_NODE(node));
     1268                errno_t rc = cdfs_readdir(node->fs, FS_NODE(node));
    12691269                if (rc != EOK)
    12701270                        return rc;
    … …  
    12901290                       
    12911291                        block_t *block;
    1292                         int rc = block_get(&block, service_id, node->lba + lba,
     1292                        errno_t rc = block_get(&block, service_id, node->lba + lba,
    12931293                            BLOCK_FLAGS_NONE);
    12941294                        if (rc != EOK) {
    … …  
    13211321}
    13221322
    1323 static int cdfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
     1323static errno_t cdfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
    13241324    size_t *wbytes, aoff64_t *nsize)
    13251325{
    … …  
    13321332}
    13331333
    1334 static int cdfs_truncate(service_id_t service_id, fs_index_t index,
     1334static errno_t cdfs_truncate(service_id_t service_id, fs_index_t index,
    13351335    aoff64_t size)
    13361336{
    … …  
    13731373}
    13741374
    1375 static int cdfs_close(service_id_t service_id, fs_index_t index)
     1375static errno_t cdfs_close(service_id_t service_id, fs_index_t index)
    13761376{
    13771377        /* Root node is always in memory */
    … …  
    13991399}
    14001400
    1401 static int cdfs_destroy(service_id_t service_id, fs_index_t index)
     1401static errno_t cdfs_destroy(service_id_t service_id, fs_index_t index)
    14021402{
    14031403        /*
    … …  
    14091409}
    14101410
    1411 static int cdfs_sync(service_id_t service_id, fs_index_t index)
     1411static errno_t cdfs_sync(service_id_t service_id, fs_index_t index)
    14121412{
    14131413        /*

  • uspace/srv/fs/exfat/exfat.c

    rfacacc71 r46577995  
    7272        }
    7373
    74         int rc = exfat_idx_init();
     74        errno_t rc = exfat_idx_init();
    7575        if (rc != EOK)
    7676                goto err;

  • uspace/srv/fs/exfat/exfat.h

    rfacacc71 r46577995  
    169169extern libfs_ops_t exfat_libfs_ops;
    170170
    171 extern int exfat_idx_get_new(exfat_idx_t **, service_id_t);
     171extern errno_t exfat_idx_get_new(exfat_idx_t **, service_id_t);
    172172extern exfat_idx_t *exfat_idx_get_by_pos(service_id_t, exfat_cluster_t, unsigned);
    173173extern exfat_idx_t *exfat_idx_get_by_index(service_id_t, fs_index_t);
    … …  
    176176extern void exfat_idx_hashout(exfat_idx_t *);
    177177
    178 extern int exfat_idx_init(void);
     178extern errno_t exfat_idx_init(void);
    179179extern void exfat_idx_fini(void);
    180 extern int exfat_idx_init_by_service_id(service_id_t);
     180extern errno_t exfat_idx_init_by_service_id(service_id_t);
    181181extern void exfat_idx_fini_by_service_id(service_id_t);
    182182
    183 extern int exfat_node_expand(service_id_t, exfat_node_t *, exfat_cluster_t);
    184 extern int exfat_node_put(fs_node_t *);
    185 extern int exfat_bitmap_get(fs_node_t **, service_id_t);
    186 extern int exfat_uctable_get(fs_node_t **, service_id_t);
     183extern errno_t exfat_node_expand(service_id_t, exfat_node_t *, exfat_cluster_t);
     184extern errno_t exfat_node_put(fs_node_t *);
     185extern errno_t exfat_bitmap_get(fs_node_t **, service_id_t);
     186extern errno_t exfat_uctable_get(fs_node_t **, service_id_t);
    187187
    188188

  • uspace/srv/fs/exfat/exfat_bitmap.c

    rfacacc71 r46577995  
    4848
    4949
    50 int exfat_bitmap_is_free(exfat_bs_t *bs, service_id_t service_id,
     50errno_t exfat_bitmap_is_free(exfat_bs_t *bs, service_id_t service_id,
    5151    exfat_cluster_t clst)
    5252{
    … …  
    5555        exfat_node_t *bitmapp;
    5656        uint8_t *bitmap;
    57         int rc;
     57        errno_t rc;
    5858        bool alloc;
    5959
    … …  
    8989}
    9090
    91 int exfat_bitmap_set_cluster(exfat_bs_t *bs, service_id_t service_id,
     91errno_t exfat_bitmap_set_cluster(exfat_bs_t *bs, service_id_t service_id,
    9292    exfat_cluster_t clst)
    9393{
    … …  
    9696        exfat_node_t *bitmapp;
    9797        uint8_t *bitmap;
    98         int rc;
     98        errno_t rc;
    9999
    100100        clst -= EXFAT_CLST_FIRST;
    … …  
    124124}
    125125
    126 int exfat_bitmap_clear_cluster(exfat_bs_t *bs, service_id_t service_id,
     126errno_t exfat_bitmap_clear_cluster(exfat_bs_t *bs, service_id_t service_id,
    127127    exfat_cluster_t clst)
    128128{
    … …  
    131131        exfat_node_t *bitmapp;
    132132        uint8_t *bitmap;
    133         int rc;
     133        errno_t rc;
    134134
    135135        clst -= EXFAT_CLST_FIRST;
    … …  
    160160}
    161161
    162 int exfat_bitmap_set_clusters(exfat_bs_t *bs, service_id_t service_id,
     162errno_t exfat_bitmap_set_clusters(exfat_bs_t *bs, service_id_t service_id,
    163163    exfat_cluster_t firstc, exfat_cluster_t count)
    164164{
    165         int rc;
     165        errno_t rc;
    166166        exfat_cluster_t clst;
    167167        clst = firstc;
    … …  
    180180}
    181181
    182 int exfat_bitmap_clear_clusters(exfat_bs_t *bs, service_id_t service_id,
     182errno_t exfat_bitmap_clear_clusters(exfat_bs_t *bs, service_id_t service_id,
    183183    exfat_cluster_t firstc, exfat_cluster_t count)
    184184{
    185         int rc;
     185        errno_t rc;
    186186        exfat_cluster_t clst;
    187187        clst = firstc;
    … …  
    196196}
    197197
    198 int exfat_bitmap_alloc_clusters(exfat_bs_t *bs, service_id_t service_id,
     198errno_t exfat_bitmap_alloc_clusters(exfat_bs_t *bs, service_id_t service_id,
    199199    exfat_cluster_t *firstc, exfat_cluster_t count)
    200200{
    … …  
    217217
    218218
    219 int exfat_bitmap_append_clusters(exfat_bs_t *bs, exfat_node_t *nodep,
     219errno_t exfat_bitmap_append_clusters(exfat_bs_t *bs, exfat_node_t *nodep,
    220220    exfat_cluster_t count)
    221221{
    … …  
    240240
    241241
    242 int exfat_bitmap_free_clusters(exfat_bs_t *bs, exfat_node_t *nodep,
     242errno_t exfat_bitmap_free_clusters(exfat_bs_t *bs, exfat_node_t *nodep,
    243243    exfat_cluster_t count)
    244244{
    … …  
    251251
    252252
    253 int exfat_bitmap_replicate_clusters(exfat_bs_t *bs, exfat_node_t *nodep)
    254 {
    255         int rc;
     253errno_t exfat_bitmap_replicate_clusters(exfat_bs_t *bs, exfat_node_t *nodep)
     254{
     255        errno_t rc;
    256256        exfat_cluster_t lastc, clst;
    257257        service_id_t service_id = nodep->idx->service_id;

  • uspace/srv/fs/exfat/exfat_bitmap.h

    rfacacc71 r46577995  
    4242struct exfat_bs;
    4343
    44 extern int exfat_bitmap_alloc_clusters(struct exfat_bs *, service_id_t,
     44extern errno_t exfat_bitmap_alloc_clusters(struct exfat_bs *, service_id_t,
    4545    exfat_cluster_t *, exfat_cluster_t);
    46 extern int exfat_bitmap_append_clusters(struct exfat_bs *, struct exfat_node *,
     46extern errno_t exfat_bitmap_append_clusters(struct exfat_bs *, struct exfat_node *,
    4747    exfat_cluster_t);
    48 extern int exfat_bitmap_free_clusters(struct exfat_bs *, struct exfat_node *,
     48extern errno_t exfat_bitmap_free_clusters(struct exfat_bs *, struct exfat_node *,
    4949    exfat_cluster_t);
    50 extern int exfat_bitmap_replicate_clusters(struct exfat_bs *, struct exfat_node *);
     50extern errno_t exfat_bitmap_replicate_clusters(struct exfat_bs *, struct exfat_node *);
    5151
    52 extern int exfat_bitmap_is_free(struct exfat_bs *, service_id_t, exfat_cluster_t);
    53 extern int exfat_bitmap_set_cluster(struct exfat_bs *, service_id_t, exfat_cluster_t);
    54 extern int exfat_bitmap_clear_cluster(struct exfat_bs *, service_id_t,
     52extern errno_t exfat_bitmap_is_free(struct exfat_bs *, service_id_t, exfat_cluster_t);
     53extern errno_t exfat_bitmap_set_cluster(struct exfat_bs *, service_id_t, exfat_cluster_t);
     54extern errno_t exfat_bitmap_clear_cluster(struct exfat_bs *, service_id_t,
    5555    exfat_cluster_t);
    5656
    57 extern int exfat_bitmap_set_clusters(struct exfat_bs *, service_id_t,
     57extern errno_t exfat_bitmap_set_clusters(struct exfat_bs *, service_id_t,
    5858    exfat_cluster_t, exfat_cluster_t);
    59 extern int exfat_bitmap_clear_clusters(struct exfat_bs *, service_id_t,
     59extern errno_t exfat_bitmap_clear_clusters(struct exfat_bs *, service_id_t,
    6060    exfat_cluster_t, exfat_cluster_t);
    6161

  • uspace/srv/fs/exfat/exfat_directory.c

    rfacacc71 r46577995  
    6060}
    6161
    62 int exfat_directory_open(exfat_node_t *nodep, exfat_directory_t *di)
     62errno_t exfat_directory_open(exfat_node_t *nodep, exfat_directory_t *di)
    6363{
    6464        exfat_directory_init(di);
    … …  
    7676}
    7777
    78 int exfat_directory_open_parent(exfat_directory_t *di,
     78errno_t exfat_directory_open_parent(exfat_directory_t *di,
    7979    service_id_t service_id, exfat_cluster_t firstc, bool fragmented)
    8080{
    … …  
    8888}
    8989
    90 int exfat_directory_close(exfat_directory_t *di)
    91 {
    92         int rc = EOK;
     90errno_t exfat_directory_close(exfat_directory_t *di)
     91{
     92        errno_t rc = EOK;
    9393       
    9494        if (di->b) {
    … …  
    100100}
    101101
    102 static int exfat_directory_block_load(exfat_directory_t *di)
     102static errno_t exfat_directory_block_load(exfat_directory_t *di)
    103103{
    104104        uint32_t i;
    105         int rc = EOK;
     105        errno_t rc = EOK;
    106106
    107107        i = (di->pos * sizeof(exfat_dentry_t)) / BPS(di->bs);
    … …  
    133133}
    134134
    135 int exfat_directory_next(exfat_directory_t *di)
    136 {
    137         int rc;
     135errno_t exfat_directory_next(exfat_directory_t *di)
     136{
     137        errno_t rc;
    138138
    139139        di->pos += 1;
    … …  
    145145}
    146146
    147 int exfat_directory_prev(exfat_directory_t *di)
    148 {
    149         int rc = EOK;
     147errno_t exfat_directory_prev(exfat_directory_t *di)
     148{
     149        errno_t rc = EOK;
    150150       
    151151        if (di->pos > 0) {
    … …  
    161161}
    162162
    163 int exfat_directory_seek(exfat_directory_t *di, aoff64_t pos)
     163errno_t exfat_directory_seek(exfat_directory_t *di, aoff64_t pos)
    164164{
    165165        aoff64_t _pos = di->pos;
    166         int rc;
     166        errno_t rc;
    167167
    168168        di->pos = pos;
    … …  
    174174}
    175175
    176 int exfat_directory_get(exfat_directory_t *di, exfat_dentry_t **d)
    177 {
    178         int rc;
     176errno_t exfat_directory_get(exfat_directory_t *di, exfat_dentry_t **d)
     177{
     178        errno_t rc;
    179179       
    180180        rc = exfat_directory_block_load(di);
    … …  
    187187}
    188188
    189 int exfat_directory_find(exfat_directory_t *di, exfat_dentry_clsf_t type,
     189errno_t exfat_directory_find(exfat_directory_t *di, exfat_dentry_clsf_t type,
    190190    exfat_dentry_t **d)
    191191{
    … …  
    201201}
    202202
    203 int
     203errno_t
    204204exfat_directory_find_continue(exfat_directory_t *di, exfat_dentry_clsf_t type,
    205205    exfat_dentry_t **d)
    206206{
    207         int rc;
     207        errno_t rc;
    208208        rc = exfat_directory_next(di);
    209209        if (rc != EOK)
    … …  
    213213
    214214
    215 int exfat_directory_read_file(exfat_directory_t *di, char *name, size_t size,
     215errno_t exfat_directory_read_file(exfat_directory_t *di, char *name, size_t size,
    216216    exfat_file_dentry_t *df, exfat_stream_dentry_t *ds)
    217217{
    218218        uint16_t wname[EXFAT_FILENAME_LEN + 1];
    219219        exfat_dentry_t *d = NULL;
    220         int rc;
     220        errno_t rc;
    221221        int i;
    222222        size_t offset = 0;
    … …  
    261261}
    262262
    263 int exfat_directory_read_vollabel(exfat_directory_t *di, char *label,
     263errno_t exfat_directory_read_vollabel(exfat_directory_t *di, char *label,
    264264    size_t size)
    265265{
    266266        uint16_t wlabel[EXFAT_VOLLABEL_LEN + 1];
    267267        exfat_dentry_t *d = NULL;
    268         int rc;
     268        errno_t rc;
    269269        aoff64_t start_pos = 0;
    270270
    … …  
    303303}
    304304
    305 int exfat_directory_sync_file(exfat_directory_t *di, exfat_file_dentry_t *df,
     305errno_t exfat_directory_sync_file(exfat_directory_t *di, exfat_file_dentry_t *df,
    306306    exfat_stream_dentry_t *ds)
    307307{
    308         int rc;
     308        errno_t rc;
    309309        int i, count;
    310310        exfat_dentry_t *array = NULL, *de;
    … …  
    367367}
    368368
    369 int exfat_directory_write_file(exfat_directory_t *di, const char *name)
     369errno_t exfat_directory_write_file(exfat_directory_t *di, const char *name)
    370370{
    371371        fs_node_t *fn;
    … …  
    374374        exfat_dentry_t df, ds, *de;
    375375        uint16_t wname[EXFAT_FILENAME_LEN + 1];
    376         int rc;
     376        errno_t rc;
    377377        int i;
    378378        size_t uctable_chars, j;
    … …  
    474474}
    475475
    476 int exfat_directory_erase_file(exfat_directory_t *di, aoff64_t pos)
    477 {
    478         int rc;
     476errno_t exfat_directory_erase_file(exfat_directory_t *di, aoff64_t pos)
     477{
     478        errno_t rc;
    479479        int count;
    480480        exfat_dentry_t *de;
    … …  
    502502}
    503503
    504 int exfat_directory_expand(exfat_directory_t *di)
    505 {
    506         int rc;
     504errno_t exfat_directory_expand(exfat_directory_t *di)
     505{
     506        errno_t rc;
    507507
    508508        if (!di->nodep)
    … …  
    521521}
    522522
    523 int exfat_directory_lookup_free(exfat_directory_t *di, size_t count)
    524 {
    525         int rc;
     523errno_t exfat_directory_lookup_free(exfat_directory_t *di, size_t count)
     524{
     525        errno_t rc;
    526526        exfat_dentry_t *d;
    527527        size_t found;

  • uspace/srv/fs/exfat/exfat_directory.h

    rfacacc71 r46577995  
    5555
    5656extern void exfat_directory_init(exfat_directory_t *);
    57 extern int exfat_directory_open(exfat_node_t *, exfat_directory_t *);
    58 extern int exfat_directory_open_parent(exfat_directory_t *, service_id_t,
     57extern errno_t exfat_directory_open(exfat_node_t *, exfat_directory_t *);
     58extern errno_t exfat_directory_open_parent(exfat_directory_t *, service_id_t,
    5959    exfat_cluster_t, bool);
    60 extern int exfat_directory_close(exfat_directory_t *);
     60extern errno_t exfat_directory_close(exfat_directory_t *);
    6161
    62 extern int exfat_directory_next(exfat_directory_t *);
    63 extern int exfat_directory_prev(exfat_directory_t *);
    64 extern int exfat_directory_seek(exfat_directory_t *, aoff64_t);
    65 extern int exfat_directory_get(exfat_directory_t *, exfat_dentry_t **);
    66 extern int exfat_directory_find(exfat_directory_t *, exfat_dentry_clsf_t,
     62extern errno_t exfat_directory_next(exfat_directory_t *);
     63extern errno_t exfat_directory_prev(exfat_directory_t *);
     64extern errno_t exfat_directory_seek(exfat_directory_t *, aoff64_t);
     65extern errno_t exfat_directory_get(exfat_directory_t *, exfat_dentry_t **);
     66extern errno_t exfat_directory_find(exfat_directory_t *, exfat_dentry_clsf_t,
    6767    exfat_dentry_t **);
    68 extern int exfat_directory_find_continue(exfat_directory_t *,
     68extern errno_t exfat_directory_find_continue(exfat_directory_t *,
    6969    exfat_dentry_clsf_t, exfat_dentry_t **);
    7070
    71 extern int exfat_directory_read_file(exfat_directory_t *, char *, size_t,
     71extern errno_t exfat_directory_read_file(exfat_directory_t *, char *, size_t,
    7272    exfat_file_dentry_t *, exfat_stream_dentry_t *);
    73 extern int exfat_directory_read_vollabel(exfat_directory_t *, char *, size_t);
    74 extern int exfat_directory_sync_file(exfat_directory_t *, exfat_file_dentry_t *,
     73extern errno_t exfat_directory_read_vollabel(exfat_directory_t *, char *, size_t);
     74extern errno_t exfat_directory_sync_file(exfat_directory_t *, exfat_file_dentry_t *,
    7575    exfat_stream_dentry_t *);
    76 extern int exfat_directory_write_file(exfat_directory_t *, const char *);
    77 extern int exfat_directory_erase_file(exfat_directory_t *, aoff64_t);
     76extern errno_t exfat_directory_write_file(exfat_directory_t *, const char *);
     77extern errno_t exfat_directory_erase_file(exfat_directory_t *, aoff64_t);
    7878
    7979
    80 extern int exfat_directory_expand(exfat_directory_t *);
    81 extern int exfat_directory_lookup_free(exfat_directory_t *, size_t);
    82 extern int exfat_directory_print(exfat_directory_t *);
     80extern errno_t exfat_directory_expand(exfat_directory_t *);
     81extern errno_t exfat_directory_lookup_free(exfat_directory_t *, size_t);
     82extern errno_t exfat_directory_print(exfat_directory_t *);
    8383
    8484

  • uspace/srv/fs/exfat/exfat_fat.c

    rfacacc71 r46577995  
    7373 * @return              EOK on success or an error code.
    7474 */
    75 int
     75errno_t
    7676exfat_cluster_walk(exfat_bs_t *bs, service_id_t service_id,
    7777    exfat_cluster_t firstc, exfat_cluster_t *lastc, uint32_t *numc,
    … …  
    8080        uint32_t clusters = 0;
    8181        exfat_cluster_t clst = firstc;
    82         int rc;
     82        errno_t rc;
    8383
    8484        if (firstc < EXFAT_CLST_FIRST) {
    … …  
    122122 * @return              EOK on success or an error code.
    123123 */
    124 int
     124errno_t
    125125exfat_block_get(block_t **block, exfat_bs_t *bs, exfat_node_t *nodep,
    126126    aoff64_t bn, int flags)
    … …  
    129129        exfat_cluster_t currc = 0;
    130130        aoff64_t relbn = bn;
    131         int rc;
     131        errno_t rc;
    132132
    133133        if (!nodep->size)
    … …  
    186186 * @return              EOK on success or an error code.
    187187 */
    188 int
     188errno_t
    189189exfat_block_get_by_clst(block_t **block, exfat_bs_t *bs,
    190190    service_id_t service_id, bool fragmented, exfat_cluster_t fcl,
    … …  
    194194        uint32_t max_clusters;
    195195        exfat_cluster_t c = EXFAT_CLST_FIRST;
    196         int rc;
     196        errno_t rc;
    197197
    198198        if (fcl < EXFAT_CLST_FIRST || fcl > DATA_CNT(bs) + 2)
    … …  
    229229 * @return              EOK or an error code.
    230230 */
    231 int
     231errno_t
    232232exfat_get_cluster(exfat_bs_t *bs, service_id_t service_id,
    233233    exfat_cluster_t clst, exfat_cluster_t *value)
    … …  
    235235        block_t *b;
    236236        aoff64_t offset;
    237         int rc;
     237        errno_t rc;
    238238
    239239        offset = clst * sizeof(exfat_cluster_t);
    … …  
    259259 * @return              EOK on success or an error code.
    260260 */
    261 int
     261errno_t
    262262exfat_set_cluster(exfat_bs_t *bs, service_id_t service_id,
    263263    exfat_cluster_t clst, exfat_cluster_t value)
    … …  
    265265        block_t *b;
    266266        aoff64_t offset;
    267         int rc;
     267        errno_t rc;
    268268
    269269        offset = clst * sizeof(exfat_cluster_t);
    … …  
    297297 * @return              EOK on success, an error code otherwise.
    298298 */
    299 int
     299errno_t
    300300exfat_alloc_clusters(exfat_bs_t *bs, service_id_t service_id, unsigned nclsts,
    301301    exfat_cluster_t *mcl, exfat_cluster_t *lcl)
    … …  
    304304        unsigned found = 0;     /* top of the free cluster number stack */
    305305        exfat_cluster_t clst;
    306         int rc = EOK;
     306        errno_t rc = EOK;
    307307
    308308        lifo = (exfat_cluster_t *) malloc(nclsts * sizeof(exfat_cluster_t));
    … …  
    363363 * @return              EOK on success or an error code.
    364364 */
    365 int
     365errno_t
    366366exfat_free_clusters(exfat_bs_t *bs, service_id_t service_id, exfat_cluster_t firstc)
    367367{
    368368        exfat_cluster_t nextc;
    369         int rc;
     369        errno_t rc;
    370370
    371371        /* Mark all clusters in the chain as free */
    … …  
    396396 * @return              EOK on success or an error code.
    397397 */
    398 int
     398errno_t
    399399exfat_append_clusters(exfat_bs_t *bs, exfat_node_t *nodep, exfat_cluster_t mcl,
    400400    exfat_cluster_t lcl)
    … …  
    402402        service_id_t service_id = nodep->idx->service_id;
    403403        exfat_cluster_t lastc = 0;
    404         int rc;
     404        errno_t rc;
    405405
    406406        if (nodep->firstc == 0) {
    … …  
    440440 * @return              EOK on success or an error code.
    441441 */
    442 int exfat_chop_clusters(exfat_bs_t *bs, exfat_node_t *nodep, exfat_cluster_t lcl)
    443 {
    444         int rc;
     442errno_t exfat_chop_clusters(exfat_bs_t *bs, exfat_node_t *nodep, exfat_cluster_t lcl)
     443{
     444        errno_t rc;
    445445        service_id_t service_id = nodep->idx->service_id;
    446446
    … …  
    486486}
    487487
    488 int
     488errno_t
    489489exfat_zero_cluster(exfat_bs_t *bs, service_id_t service_id, exfat_cluster_t c)
    490490{
    491491        size_t i;
    492492        block_t *b;
    493         int rc;
     493        errno_t rc;
    494494
    495495        for (i = 0; i < SPC(bs); i++) {
    … …  
    508508}
    509509
    510 int
     510errno_t
    511511exfat_read_uctable(exfat_bs_t *bs, exfat_node_t *nodep, uint8_t *uctable)
    512512{
    513513        size_t i, blocks, count;
    514514        block_t *b;
    515         int rc;
     515        errno_t rc;
    516516        blocks = ROUND_UP(nodep->size, BPS(bs))/BPS(bs);
    517517        count = BPS(bs);
    … …  
    540540 * does not contain a exfat file system.
    541541 */
    542 int exfat_sanity_check(exfat_bs_t *bs)
     542errno_t exfat_sanity_check(exfat_bs_t *bs)
    543543{
    544544        if (str_cmp((char const *)bs->oem_name, "EXFAT   "))

  • uspace/srv/fs/exfat/exfat_fat.h

    rfacacc71 r46577995  
    6161    exfat_cluster_walk((bs), (sid), (fc), NULL, (numc), (uint32_t) -1)
    6262
    63 extern int exfat_cluster_walk(struct exfat_bs *, service_id_t,
     63extern errno_t exfat_cluster_walk(struct exfat_bs *, service_id_t,
    6464    exfat_cluster_t, exfat_cluster_t *, uint32_t *, uint32_t);
    65 extern int exfat_block_get(block_t **, struct exfat_bs *, struct exfat_node *,
     65extern errno_t exfat_block_get(block_t **, struct exfat_bs *, struct exfat_node *,
    6666    aoff64_t, int);
    67 extern int exfat_block_get_by_clst(block_t **, struct exfat_bs *, service_id_t,
     67extern errno_t exfat_block_get_by_clst(block_t **, struct exfat_bs *, service_id_t,
    6868    bool, exfat_cluster_t, exfat_cluster_t *, aoff64_t, int);
    6969
    70 extern int exfat_get_cluster(struct exfat_bs *, service_id_t, exfat_cluster_t,
     70extern errno_t exfat_get_cluster(struct exfat_bs *, service_id_t, exfat_cluster_t,
    7171    exfat_cluster_t *);
    72 extern int exfat_set_cluster(struct exfat_bs *, service_id_t, exfat_cluster_t,
     72extern errno_t exfat_set_cluster(struct exfat_bs *, service_id_t, exfat_cluster_t,
    7373    exfat_cluster_t);
    74 extern int exfat_sanity_check(struct exfat_bs *);
     74extern errno_t exfat_sanity_check(struct exfat_bs *);
    7575
    76 extern int exfat_append_clusters(struct exfat_bs *, struct exfat_node *,
     76extern errno_t exfat_append_clusters(struct exfat_bs *, struct exfat_node *,
    7777    exfat_cluster_t, exfat_cluster_t);
    78 extern int exfat_chop_clusters(struct exfat_bs *, struct exfat_node *,
     78extern errno_t exfat_chop_clusters(struct exfat_bs *, struct exfat_node *,
    7979    exfat_cluster_t);
    80 extern int exfat_alloc_clusters(struct exfat_bs *, service_id_t, unsigned,
     80extern errno_t exfat_alloc_clusters(struct exfat_bs *, service_id_t, unsigned,
    8181    exfat_cluster_t *, exfat_cluster_t *);
    82 extern int exfat_free_clusters(struct exfat_bs *, service_id_t, exfat_cluster_t);
    83 extern int exfat_zero_cluster(struct exfat_bs *, service_id_t, exfat_cluster_t);
     82extern errno_t exfat_free_clusters(struct exfat_bs *, service_id_t, exfat_cluster_t);
     83extern errno_t exfat_zero_cluster(struct exfat_bs *, service_id_t, exfat_cluster_t);
    8484
    85 extern int exfat_read_uctable(struct exfat_bs *, struct exfat_node *,
     85extern errno_t exfat_read_uctable(struct exfat_bs *, struct exfat_node *,
    8686    uint8_t *);
    8787

  • uspace/srv/fs/exfat/exfat_idx.c

    rfacacc71 r46577995  
    328328}
    329329
    330 static int exfat_idx_create(exfat_idx_t **fidxp, service_id_t service_id)
     330static errno_t exfat_idx_create(exfat_idx_t **fidxp, service_id_t service_id)
    331331{
    332332        exfat_idx_t *fidx;
    … …  
    350350}
    351351
    352 int exfat_idx_get_new(exfat_idx_t **fidxp, service_id_t service_id)
     352errno_t exfat_idx_get_new(exfat_idx_t **fidxp, service_id_t service_id)
    353353{
    354354        exfat_idx_t *fidx;
    355         int rc;
     355        errno_t rc;
    356356
    357357        fibril_mutex_lock(&used_lock);
    … …  
    386386                fidx = hash_table_get_inst(l, exfat_idx_t, uph_link);
    387387        } else {
    388                 int rc;
     388                errno_t rc;
    389389
    390390                rc = exfat_idx_create(&fidx, service_id);
    … …  
    468468}
    469469
    470 int exfat_idx_init(void)
     470errno_t exfat_idx_init(void)
    471471{
    472472        if (!hash_table_create(&up_hash, 0, 0, &uph_ops))
    … …  
    487487}
    488488
    489 int exfat_idx_init_by_service_id(service_id_t service_id)
     489errno_t exfat_idx_init_by_service_id(service_id_t service_id)
    490490{
    491491        unused_t *u;
    492         int rc = EOK;
     492        errno_t rc = EOK;
    493493
    494494        u = (unused_t *) malloc(sizeof(unused_t));

  • uspace/srv/fs/exfat/exfat_ops.c

    rfacacc71 r46577995  
    7272 */
    7373
    74 static int exfat_root_get(fs_node_t **, service_id_t);
    75 static int exfat_match(fs_node_t **, fs_node_t *, const char *);
    76 static int exfat_node_get(fs_node_t **, service_id_t, fs_index_t);
    77 static int exfat_node_open(fs_node_t *);
    78 /* static int exfat_node_put(fs_node_t *); */
    79 static int exfat_create_node(fs_node_t **, service_id_t, int);
    80 static int exfat_destroy_node(fs_node_t *);
    81 static int exfat_link(fs_node_t *, fs_node_t *, const char *);
    82 static int exfat_unlink(fs_node_t *, fs_node_t *, const char *);
    83 static int exfat_has_children(bool *, fs_node_t *);
     74static errno_t exfat_root_get(fs_node_t **, service_id_t);
     75static errno_t exfat_match(fs_node_t **, fs_node_t *, const char *);
     76static errno_t exfat_node_get(fs_node_t **, service_id_t, fs_index_t);
     77static errno_t exfat_node_open(fs_node_t *);
     78/* static errno_t exfat_node_put(fs_node_t *); */
     79static errno_t exfat_create_node(fs_node_t **, service_id_t, int);
     80static errno_t exfat_destroy_node(fs_node_t *);
     81static errno_t exfat_link(fs_node_t *, fs_node_t *, const char *);
     82static errno_t exfat_unlink(fs_node_t *, fs_node_t *, const char *);
     83static errno_t exfat_has_children(bool *, fs_node_t *);
    8484static fs_index_t exfat_index_get(fs_node_t *);
    8585static aoff64_t exfat_size_get(fs_node_t *);
    … …  
    8888static bool exfat_is_file(fs_node_t *node);
    8989static service_id_t exfat_service_get(fs_node_t *node);
    90 static int exfat_size_block(service_id_t, uint32_t *);
    91 static int exfat_total_block_count(service_id_t, uint64_t *);
    92 static int exfat_free_block_count(service_id_t, uint64_t *);
     90static errno_t exfat_size_block(service_id_t, uint32_t *);
     91static errno_t exfat_total_block_count(service_id_t, uint64_t *);
     92static errno_t exfat_free_block_count(service_id_t, uint64_t *);
    9393
    9494/*
    … …  
    114114}
    115115
    116 static int exfat_node_sync(exfat_node_t *node)
    117 {
    118         int rc;
     116static errno_t exfat_node_sync(exfat_node_t *node)
     117{
     118        errno_t rc;
    119119        exfat_directory_t di;
    120120        exfat_file_dentry_t df;
    … …  
    155155}
    156156
    157 static int exfat_node_fini_by_service_id(service_id_t service_id)
    158 {
    159         int rc;
     157static errno_t exfat_node_fini_by_service_id(service_id_t service_id)
     158{
     159        errno_t rc;
    160160
    161161        /*
    … …  
    211211}
    212212
    213 static int exfat_node_get_new(exfat_node_t **nodepp)
     213static errno_t exfat_node_get_new(exfat_node_t **nodepp)
    214214{
    215215        fs_node_t *fn;
    216216        exfat_node_t *nodep;
    217         int rc;
     217        errno_t rc;
    218218
    219219        fibril_mutex_lock(&ffn_mutex);
    … …  
    269269}
    270270
    271 static int exfat_node_get_new_by_pos(exfat_node_t **nodepp,
     271static errno_t exfat_node_get_new_by_pos(exfat_node_t **nodepp,
    272272    service_id_t service_id, exfat_cluster_t pfc, unsigned pdi)
    273273{
    … …  
    287287 * @param idxp          Locked index structure.
    288288 */
    289 static int exfat_node_get_core(exfat_node_t **nodepp, exfat_idx_t *idxp)
     289static errno_t exfat_node_get_core(exfat_node_t **nodepp, exfat_idx_t *idxp)
    290290{
    291291        exfat_dentry_t *d;
    292292        exfat_node_t *nodep = NULL;
    293293        exfat_directory_t di;
    294         int rc;
     294        errno_t rc;
    295295
    296296        if (idxp->nodep) {
    … …  
    398398}
    399399
    400 int exfat_node_expand(service_id_t service_id, exfat_node_t *nodep,
     400errno_t exfat_node_expand(service_id_t service_id, exfat_node_t *nodep,
    401401    exfat_cluster_t clusters)
    402402{
    403403        exfat_bs_t *bs;
    404         int rc;
     404        errno_t rc;
    405405        bs = block_bb_get(service_id);
    406406
    … …  
    443443}
    444444
    445 static int exfat_node_shrink(service_id_t service_id, exfat_node_t *nodep,
     445static errno_t exfat_node_shrink(service_id_t service_id, exfat_node_t *nodep,
    446446    aoff64_t size)
    447447{
    448448        exfat_bs_t *bs;
    449         int rc;
     449        errno_t rc;
    450450        bs = block_bb_get(service_id);
    451451
    … …  
    491491 */
    492492
    493 int exfat_root_get(fs_node_t **rfn, service_id_t service_id)
     493errno_t exfat_root_get(fs_node_t **rfn, service_id_t service_id)
    494494{
    495495        return exfat_node_get(rfn, service_id, EXFAT_ROOT_IDX);
    496496}
    497497
    498 int exfat_bitmap_get(fs_node_t **rfn, service_id_t service_id)
     498errno_t exfat_bitmap_get(fs_node_t **rfn, service_id_t service_id)
    499499{
    500500        return exfat_node_get(rfn, service_id, EXFAT_BITMAP_IDX);
    501501}
    502502
    503 int exfat_uctable_get(fs_node_t **rfn, service_id_t service_id)
     503errno_t exfat_uctable_get(fs_node_t **rfn, service_id_t service_id)
    504504{
    505505        return exfat_node_get(rfn, service_id, EXFAT_UCTABLE_IDX);
    … …  
    507507
    508508
    509 int exfat_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
     509errno_t exfat_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
    510510{
    511511        exfat_node_t *parentp = EXFAT_NODE(pfn);
    … …  
    514514        exfat_stream_dentry_t ds;
    515515        service_id_t service_id;
    516         int rc;
     516        errno_t rc;
    517517
    518518        fibril_mutex_lock(&parentp->idx->lock);
    … …  
    565565
    566566/** Instantiate a exFAT in-core node. */
    567 int exfat_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
     567errno_t exfat_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
    568568{
    569569        exfat_node_t *nodep;
    570570        exfat_idx_t *idxp;
    571         int rc;
     571        errno_t rc;
    572572
    573573        idxp = exfat_idx_get_by_index(service_id, index);
    … …  
    584584}
    585585
    586 int exfat_node_open(fs_node_t *fn)
     586errno_t exfat_node_open(fs_node_t *fn)
    587587{
    588588        /*
    … …  
    593593}
    594594
    595 int exfat_node_put(fs_node_t *fn)
     595errno_t exfat_node_put(fs_node_t *fn)
    596596{
    597597        if (fn == NULL)
    … …  
    625625}
    626626
    627 int exfat_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
     627errno_t exfat_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
    628628{
    629629        exfat_idx_t *idxp;
    630630        exfat_node_t *nodep;
    631631        exfat_bs_t *bs;
    632         int rc;
     632        errno_t rc;
    633633
    634634        bs = block_bb_get(service_id);
    … …  
    677677}
    678678
    679 int exfat_destroy_node(fs_node_t *fn)
     679errno_t exfat_destroy_node(fs_node_t *fn)
    680680{
    681681        exfat_node_t *nodep = EXFAT_NODE(fn);
    682682        exfat_bs_t *bs;
    683683        bool has_children;
    684         int rc;
     684        errno_t rc;
    685685
    686686        /*
    … …  
    718718}
    719719
    720 int exfat_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
     720errno_t exfat_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
    721721{
    722722        exfat_node_t *parentp = EXFAT_NODE(pfn);
    723723        exfat_node_t *childp = EXFAT_NODE(cfn);
    724724        exfat_directory_t di;
    725         int rc;
     725        errno_t rc;
    726726
    727727        fibril_mutex_lock(&childp->lock);
    … …  
    783783}
    784784
    785 int exfat_unlink(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
     785errno_t exfat_unlink(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
    786786{
    787787        exfat_node_t *parentp = EXFAT_NODE(pfn);
    788788        exfat_node_t *childp = EXFAT_NODE(cfn);
    789789        bool has_children;
    790         int rc;
     790        errno_t rc;
    791791
    792792        if (!parentp)
    … …  
    838838}
    839839
    840 int exfat_has_children(bool *has_children, fs_node_t *fn)
     840errno_t exfat_has_children(bool *has_children, fs_node_t *fn)
    841841{
    842842        exfat_directory_t di;
    843843        exfat_dentry_t *d;
    844844        exfat_node_t *nodep = EXFAT_NODE(fn);
    845         int rc;
     845        errno_t rc;
    846846
    847847        *has_children = false;
    … …  
    915915}
    916916
    917 int exfat_size_block(service_id_t service_id, uint32_t *size)
     917errno_t exfat_size_block(service_id_t service_id, uint32_t *size)
    918918{
    919919        exfat_bs_t *bs;
    … …  
    924924}
    925925
    926 int exfat_total_block_count(service_id_t service_id, uint64_t *count)
     926errno_t exfat_total_block_count(service_id_t service_id, uint64_t *count)
    927927{
    928928        exfat_bs_t *bs;
    … …  
    933933}
    934934
    935 int exfat_free_block_count(service_id_t service_id, uint64_t *count)
     935errno_t exfat_free_block_count(service_id_t service_id, uint64_t *count)
    936936{
    937937        fs_node_t *node = NULL;
    … …  
    941941        uint64_t block_count;
    942942        unsigned sector;
    943         int rc;
     943        errno_t rc;
    944944
    945945        rc = exfat_total_block_count(service_id, &block_count);
    … …  
    10151015};
    10161016
    1017 static int exfat_fs_open(service_id_t service_id, enum cache_mode cmode,
     1017static errno_t exfat_fs_open(service_id_t service_id, enum cache_mode cmode,
    10181018    fs_node_t **rrfn, exfat_idx_t **rridxp, vfs_fs_probe_info_t *info)
    10191019{
    1020         int rc;
     1020        errno_t rc;
    10211021        exfat_node_t *rootp = NULL, *bitmapp = NULL, *uctablep = NULL;
    10221022        exfat_bs_t *bs;
    … …  
    12671267*/
    12681268
    1269 static int exfat_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
    1270 {
    1271         int rc;
     1269static errno_t exfat_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
     1270{
     1271        errno_t rc;
    12721272        exfat_idx_t *ridxp;
    12731273        fs_node_t *rfn;
    … …  
    12811281}
    12821282
    1283 static int
     1283static errno_t
    12841284exfat_mounted(service_id_t service_id, const char *opts, fs_index_t *index,
    12851285    aoff64_t *size)
    12861286{
    1287         int rc;
     1287        errno_t rc;
    12881288        enum cache_mode cmode;
    12891289        exfat_idx_t *ridxp;
    … …  
    13061306}
    13071307
    1308 static int exfat_unmounted(service_id_t service_id)
     1308static errno_t exfat_unmounted(service_id_t service_id)
    13091309{
    13101310        fs_node_t *rfn;
    1311         int rc;
     1311        errno_t rc;
    13121312
    13131313        rc = exfat_root_get(&rfn, service_id);
    … …  
    13191319}
    13201320
    1321 static int
     1321static errno_t
    13221322exfat_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
    13231323    size_t *rbytes)
    … …  
    13281328        size_t bytes = 0;
    13291329        block_t *b;
    1330         int rc;
     1330        errno_t rc;
    13311331
    13321332        rc = exfat_node_get(&fn, service_id, index);
    … …  
    14381438}
    14391439
    1440 static int exfat_close(service_id_t service_id, fs_index_t index)
    1441 {
    1442         return EOK;
    1443 }
    1444 
    1445 static int exfat_sync(service_id_t service_id, fs_index_t index)
     1440static errno_t exfat_close(service_id_t service_id, fs_index_t index)
     1441{
     1442        return EOK;
     1443}
     1444
     1445static errno_t exfat_sync(service_id_t service_id, fs_index_t index)
    14461446{
    14471447        fs_node_t *fn;
    1448         int rc = exfat_node_get(&fn, service_id, index);
     1448        errno_t rc = exfat_node_get(&fn, service_id, index);
    14491449        if (rc != EOK)
    14501450                return rc;
    … …  
    14611461}
    14621462
    1463 static int
     1463static errno_t
    14641464exfat_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
    14651465    size_t *wbytes, aoff64_t *nsize)
    … …  
    14721472        aoff64_t boundary;
    14731473        int flags = BLOCK_FLAGS_NONE;
    1474         int rc;
     1474        errno_t rc;
    14751475
    14761476        rc = exfat_node_get(&fn, service_id, index);
    … …  
    15481548}
    15491549
    1550 static int
     1550static errno_t
    15511551exfat_truncate(service_id_t service_id, fs_index_t index, aoff64_t size)
    15521552{
    … …  
    15541554        exfat_node_t *nodep;
    15551555        exfat_bs_t *bs;
    1556         int rc;
     1556        errno_t rc;
    15571557
    15581558        rc = exfat_node_get(&fn, service_id, index);
    … …  
    15841584        }
    15851585
    1586         int rc2 = exfat_node_put(fn);
     1586        errno_t rc2 = exfat_node_put(fn);
    15871587        if (rc == EOK && rc2 != EOK)
    15881588                rc = rc2;
    … …  
    15911591}
    15921592
    1593 static int exfat_destroy(service_id_t service_id, fs_index_t index)
     1593static errno_t exfat_destroy(service_id_t service_id, fs_index_t index)
    15941594{
    15951595        fs_node_t *fn;
    15961596        exfat_node_t *nodep;
    1597         int rc;
     1597        errno_t rc;
    15981598
    15991599        rc = exfat_node_get(&fn, service_id, index);

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

    rfacacc71 r46577995  
    7373        }
    7474       
    75         int rc = ext4_global_init();
     75        errno_t rc = ext4_global_init();
    7676        if (rc != EOK) {
    7777                printf("%s: Global initialization failed\n", NAME);

  • uspace/srv/fs/fat/fat.c

    rfacacc71 r46577995  
    7272        }
    7373
    74         int rc = fat_idx_init();
     74        errno_t rc = fat_idx_init();
    7575        if (rc != EOK)
    7676                goto err;

  • uspace/srv/fs/fat/fat.h

    rfacacc71 r46577995  
    250250extern libfs_ops_t fat_libfs_ops;
    251251
    252 extern int fat_idx_get_new(fat_idx_t **, service_id_t);
     252extern errno_t fat_idx_get_new(fat_idx_t **, service_id_t);
    253253extern fat_idx_t *fat_idx_get_by_pos(service_id_t, fat_cluster_t, unsigned);
    254254extern fat_idx_t *fat_idx_get_by_index(service_id_t, fs_index_t);
    … …  
    257257extern void fat_idx_hashout(fat_idx_t *);
    258258
    259 extern int fat_idx_init(void);
     259extern errno_t fat_idx_init(void);
    260260extern void fat_idx_fini(void);
    261 extern int fat_idx_init_by_service_id(service_id_t);
     261extern errno_t fat_idx_init_by_service_id(service_id_t);
    262262extern void fat_idx_fini_by_service_id(service_id_t);
    263263

  • uspace/srv/fs/fat/fat_directory.c

    rfacacc71 r46577995  
    4646#include <stdio.h>
    4747
    48 int fat_directory_open(fat_node_t *nodep, fat_directory_t *di)
     48errno_t fat_directory_open(fat_node_t *nodep, fat_directory_t *di)
    4949{
    5050        di->b = NULL;
    … …  
    6262}
    6363
    64 int fat_directory_close(fat_directory_t *di)
    65 {
    66         int rc = EOK;
     64errno_t fat_directory_close(fat_directory_t *di)
     65{
     66        errno_t rc = EOK;
    6767       
    6868        if (di->b)
    … …  
    7272}
    7373
    74 static int fat_directory_block_load(fat_directory_t *di)
     74static errno_t fat_directory_block_load(fat_directory_t *di)
    7575{
    7676        uint32_t i;
    77         int rc;
     77        errno_t rc;
    7878
    7979        i = (di->pos * sizeof(fat_dentry_t)) / BPS(di->bs);
    … …  
    9898}
    9999
    100 int fat_directory_next(fat_directory_t *di)
    101 {
    102         int rc;
     100errno_t fat_directory_next(fat_directory_t *di)
     101{
     102        errno_t rc;
    103103
    104104        di->pos += 1;
    … …  
    110110}
    111111
    112 int fat_directory_prev(fat_directory_t *di)
    113 {
    114         int rc = EOK;
     112errno_t fat_directory_prev(fat_directory_t *di)
     113{
     114        errno_t rc = EOK;
    115115       
    116116        if (di->pos > 0) {
    … …  
    126126}
    127127
    128 int fat_directory_seek(fat_directory_t *di, aoff64_t pos)
     128errno_t fat_directory_seek(fat_directory_t *di, aoff64_t pos)
    129129{
    130130        aoff64_t _pos = di->pos;
    131         int rc;
     131        errno_t rc;
    132132
    133133        di->pos = pos;
    … …  
    139139}
    140140
    141 int fat_directory_get(fat_directory_t *di, fat_dentry_t **d)
    142 {
    143         int rc;
     141errno_t fat_directory_get(fat_directory_t *di, fat_dentry_t **d)
     142{
     143        errno_t rc;
    144144       
    145145        rc = fat_directory_block_load(di);
    … …  
    152152}
    153153
    154 int fat_directory_read(fat_directory_t *di, char *name, fat_dentry_t **de)
     154errno_t fat_directory_read(fat_directory_t *di, char *name, fat_dentry_t **de)
    155155{
    156156        fat_dentry_t *d = NULL;
    … …  
    160160        int long_entry_count = 0;
    161161        uint8_t checksum = 0;
    162         int rc;
     162        errno_t rc;
    163163
    164164        void *data;
    … …  
    236236}
    237237
    238 int fat_directory_erase(fat_directory_t *di)
    239 {
    240         int rc;
     238errno_t fat_directory_erase(fat_directory_t *di)
     239{
     240        errno_t rc;
    241241        fat_dentry_t *d;
    242242        bool flag = false;
    … …  
    267267}
    268268
    269 int fat_directory_write(fat_directory_t *di, const char *name, fat_dentry_t *de)
    270 {
    271         int rc;
     269errno_t fat_directory_write(fat_directory_t *di, const char *name, fat_dentry_t *de)
     270{
     271        errno_t rc;
    272272        void *data;
    273273        fat_instance_t *instance;
    … …  
    348348}
    349349
    350 int fat_directory_create_sfn(fat_directory_t *di, fat_dentry_t *de,
     350errno_t fat_directory_create_sfn(fat_directory_t *di, fat_dentry_t *de,
    351351    const char *lname)
    352352{
    … …  
    398398}
    399399
    400 int fat_directory_write_dentry(fat_directory_t *di, fat_dentry_t *de)
     400errno_t fat_directory_write_dentry(fat_directory_t *di, fat_dentry_t *de)
    401401{
    402402        fat_dentry_t *d;
    403         int rc;
     403        errno_t rc;
    404404
    405405        rc = fat_directory_get(di, &d);
    … …  
    412412}
    413413
    414 int fat_directory_expand(fat_directory_t *di)
    415 {
    416         int rc;
     414errno_t fat_directory_expand(fat_directory_t *di)
     415{
     416        errno_t rc;
    417417        fat_cluster_t mcl, lcl;
    418418
    … …  
    444444}
    445445
    446 int fat_directory_lookup_free(fat_directory_t *di, size_t count)
     446errno_t fat_directory_lookup_free(fat_directory_t *di, size_t count)
    447447{
    448448        fat_dentry_t *d;
    449449        size_t found;
    450450        aoff64_t pos;
    451         int rc;
     451        errno_t rc;
    452452       
    453453        do {
    … …  
    485485}
    486486
    487 int fat_directory_lookup_name(fat_directory_t *di, const char *name,
     487errno_t fat_directory_lookup_name(fat_directory_t *di, const char *name,
    488488    fat_dentry_t **de)
    489489{
    … …  
    506506{
    507507        fat_dentry_t *d;
    508         int rc;
     508        errno_t rc;
    509509
    510510        fat_directory_seek(di, 0);
    … …  
    538538 * @return EOK on success, ENOENT if not found, EIO on I/O error
    539539 */
    540 int fat_directory_vollabel_get(fat_directory_t *di, char *label)
     540errno_t fat_directory_vollabel_get(fat_directory_t *di, char *label)
    541541{
    542542        fat_dentry_t *d;
    543         int rc;
     543        errno_t rc;
    544544
    545545        fat_directory_seek(di, 0);

  • uspace/srv/fs/fat/fat_directory.h

    rfacacc71 r46577995  
    5252
    5353
    54 extern int fat_directory_open(fat_node_t *, fat_directory_t *);
    55 extern int fat_directory_close(fat_directory_t *);
     54extern errno_t fat_directory_open(fat_node_t *, fat_directory_t *);
     55extern errno_t fat_directory_close(fat_directory_t *);
    5656
    57 extern int fat_directory_next(fat_directory_t *);
    58 extern int fat_directory_prev(fat_directory_t *);
    59 extern int fat_directory_seek(fat_directory_t *, aoff64_t);
    60 extern int fat_directory_get(fat_directory_t *, fat_dentry_t **);
     57extern errno_t fat_directory_next(fat_directory_t *);
     58extern errno_t fat_directory_prev(fat_directory_t *);
     59extern errno_t fat_directory_seek(fat_directory_t *, aoff64_t);
     60extern errno_t fat_directory_get(fat_directory_t *, fat_dentry_t **);
    6161
    62 extern int fat_directory_read(fat_directory_t *, char *, fat_dentry_t **);
    63 extern int fat_directory_write(fat_directory_t *, const char *, fat_dentry_t *);
    64 extern int fat_directory_erase(fat_directory_t *);
    65 extern int fat_directory_lookup_name(fat_directory_t *, const char *,
     62extern errno_t fat_directory_read(fat_directory_t *, char *, fat_dentry_t **);
     63extern errno_t fat_directory_write(fat_directory_t *, const char *, fat_dentry_t *);
     64extern errno_t fat_directory_erase(fat_directory_t *);
     65extern errno_t fat_directory_lookup_name(fat_directory_t *, const char *,
    6666    fat_dentry_t **);
    6767extern bool fat_directory_is_sfn_exist(fat_directory_t *, fat_dentry_t *);
    6868
    69 extern int fat_directory_lookup_free(fat_directory_t *, size_t);
    70 extern int fat_directory_write_dentry(fat_directory_t *, fat_dentry_t *);
    71 extern int fat_directory_create_sfn(fat_directory_t *, fat_dentry_t *,
     69extern errno_t fat_directory_lookup_free(fat_directory_t *, size_t);
     70extern errno_t fat_directory_write_dentry(fat_directory_t *, fat_dentry_t *);
     71extern errno_t fat_directory_create_sfn(fat_directory_t *, fat_dentry_t *,
    7272    const char *);
    73 extern int fat_directory_expand(fat_directory_t *);
    74 extern int fat_directory_vollabel_get(fat_directory_t *, char *);
     73extern errno_t fat_directory_expand(fat_directory_t *);
     74extern errno_t fat_directory_vollabel_get(fat_directory_t *, char *);
    7575
    7676#endif

  • uspace/srv/fs/fat/fat_fat.c

    rfacacc71 r46577995  
    7373 * @return              EOK on success or an error code.
    7474 */
    75 int
     75errno_t
    7676fat_cluster_walk(fat_bs_t *bs, service_id_t service_id, fat_cluster_t firstc,
    7777    fat_cluster_t *lastc, uint32_t *numc, uint32_t max_clusters)
    … …  
    8080        fat_cluster_t clst = firstc, clst_last1 = FAT_CLST_LAST1(bs);
    8181        fat_cluster_t clst_bad = FAT_CLST_BAD(bs);
    82         int rc;
     82        errno_t rc;
    8383
    8484        if (firstc == FAT_CLST_RES0) {
    … …  
    123123 * @return              EOK on success or an error code.
    124124 */
    125 int
     125errno_t
    126126fat_block_get(block_t **block, struct fat_bs *bs, fat_node_t *nodep,
    127127    aoff64_t bn, int flags)
    … …  
    130130        fat_cluster_t currc = 0;
    131131        aoff64_t relbn = bn;
    132         int rc;
     132        errno_t rc;
    133133
    134134        if (!nodep->size)
    … …  
    188188 * @return              EOK on success or an error code.
    189189 */
    190 int
     190errno_t
    191191_fat_block_get(block_t **block, fat_bs_t *bs, service_id_t service_id,
    192192    fat_cluster_t fcl, fat_cluster_t *clp, aoff64_t bn, int flags)
    … …  
    195195        uint32_t max_clusters;
    196196        fat_cluster_t c = 0;
    197         int rc;
     197        errno_t rc;
    198198
    199199        /*
    … …  
    237237 * @return              EOK on success or an error code.
    238238 */
    239 int
     239errno_t
    240240fat_fill_gap(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl, aoff64_t pos)
    241241{
    242242        block_t *b;
    243243        aoff64_t o, boundary;
    244         int rc;
     244        errno_t rc;
    245245
    246246        boundary = ROUND_UP(nodep->size, BPS(bs) * SPC(bs));
    … …  
    289289 * @return              EOK or an error code.
    290290 */
    291 static int
     291static errno_t
    292292fat_get_cluster_fat12(fat_bs_t *bs, service_id_t service_id, unsigned fatno,
    293293    fat_cluster_t clst, fat_cluster_t *value)
    … …  
    296296        uint16_t byte1, byte2;
    297297        aoff64_t offset;
    298         int rc;
     298        errno_t rc;
    299299
    300300        offset = (clst + clst / 2);
    … …  
    359359 * @return              EOK or an error code.
    360360 */
    361 static int
     361static errno_t
    362362fat_get_cluster_fat16(fat_bs_t *bs, service_id_t service_id, unsigned fatno,
    363363    fat_cluster_t clst, fat_cluster_t *value)
    … …  
    365365        block_t *b;
    366366        aoff64_t offset;
    367         int rc;
     367        errno_t rc;
    368368
    369369        offset = (clst * FAT16_CLST_SIZE);
    … …  
    390390 * @return              EOK or an error code.
    391391 */
    392 static int
     392static errno_t
    393393fat_get_cluster_fat32(fat_bs_t *bs, service_id_t service_id, unsigned fatno,
    394394    fat_cluster_t clst, fat_cluster_t *value)
    … …  
    396396        block_t *b;
    397397        aoff64_t offset;
    398         int rc;
     398        errno_t rc;
    399399
    400400        offset = (clst * FAT32_CLST_SIZE);
    … …  
    423423 * @return              EOK or an error code.
    424424 */
    425 int
     425errno_t
    426426fat_get_cluster(fat_bs_t *bs, service_id_t service_id, unsigned fatno,
    427427    fat_cluster_t clst, fat_cluster_t *value)
    428428{
    429         int rc;
     429        errno_t rc;
    430430
    431431        assert(fatno < FATCNT(bs));
    … …  
    451451 * @return              EOK on success or an error code.
    452452 */
    453 static int
     453static errno_t
    454454fat_set_cluster_fat12(fat_bs_t *bs, service_id_t service_id, unsigned fatno,
    455455    fat_cluster_t clst, fat_cluster_t value)
    … …  
    458458        aoff64_t offset;
    459459        uint16_t byte1, byte2;
    460         int rc;
     460        errno_t rc;
    461461
    462462        offset = (clst + clst / 2);
    … …  
    539539 * @return              EOK on success or an error code.
    540540 */
    541 static int
     541static errno_t
    542542fat_set_cluster_fat16(fat_bs_t *bs, service_id_t service_id, unsigned fatno,
    543543    fat_cluster_t clst, fat_cluster_t value)
    … …  
    545545        block_t *b;
    546546        aoff64_t offset;
    547         int rc;
     547        errno_t rc;
    548548
    549549        offset = (clst * FAT16_CLST_SIZE);
    … …  
    572572 * @return              EOK on success or an error code.
    573573 */
    574 static int
     574static errno_t
    575575fat_set_cluster_fat32(fat_bs_t *bs, service_id_t service_id, unsigned fatno,
    576576    fat_cluster_t clst, fat_cluster_t value)
    … …  
    578578        block_t *b;
    579579        aoff64_t offset;
    580         int rc;
     580        errno_t rc;
    581581        fat_cluster_t temp;
    582582
    … …  
    609609 * @return              EOK on success or an error code.
    610610 */
    611 int
     611errno_t
    612612fat_set_cluster(fat_bs_t *bs, service_id_t service_id, unsigned fatno,
    613613    fat_cluster_t clst, fat_cluster_t value)
    614614{
    615         int rc;
     615        errno_t rc;
    616616
    617617        assert(fatno < FATCNT(bs));
    … …  
    636636 * @return              EOK on success or an error code.
    637637 */
    638 int fat_alloc_shadow_clusters(fat_bs_t *bs, service_id_t service_id,
     638errno_t fat_alloc_shadow_clusters(fat_bs_t *bs, service_id_t service_id,
    639639    fat_cluster_t *lifo, unsigned nclsts)
    640640{
    … …  
    642642        unsigned c;
    643643        fat_cluster_t clst_last1 = FAT_CLST_LAST1(bs);
    644         int rc;
     644        errno_t rc;
    645645
    646646        for (fatno = FAT1 + 1; fatno < FATCNT(bs); fatno++) {
    … …  
    673673 * @return              EOK on success, an error code otherwise.
    674674 */
    675 int
     675errno_t
    676676fat_alloc_clusters(fat_bs_t *bs, service_id_t service_id, unsigned nclsts,
    677677    fat_cluster_t *mcl, fat_cluster_t *lcl)
    … …  
    682682        fat_cluster_t value = 0;
    683683        fat_cluster_t clst_last1 = FAT_CLST_LAST1(bs);
    684         int rc = EOK;
     684        errno_t rc = EOK;
    685685
    686686        lifo = (fat_cluster_t *) malloc(nclsts * sizeof(fat_cluster_t));
    … …  
    744744 * @return              EOK on success or an error code.
    745745 */
    746 int
     746errno_t
    747747fat_free_clusters(fat_bs_t *bs, service_id_t service_id, fat_cluster_t firstc)
    748748{
    … …  
    750750        fat_cluster_t nextc = 0;
    751751        fat_cluster_t clst_bad = FAT_CLST_BAD(bs);
    752         int rc;
     752        errno_t rc;
    753753
    754754        /* Mark all clusters in the chain as free in all copies of FAT. */
    … …  
    782782 * @return              EOK on success or an error code.
    783783 */
    784 int fat_append_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl,
     784errno_t fat_append_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl,
    785785    fat_cluster_t lcl)
    786786{
    … …  
    788788        fat_cluster_t lastc = 0;
    789789        uint8_t fatno;
    790         int rc;
     790        errno_t rc;
    791791
    792792        if (nodep->firstc == FAT_CLST_RES0) {
    … …  
    829829 * @return              EOK on success or an error code.
    830830 */
    831 int fat_chop_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t lcl)
     831errno_t fat_chop_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t lcl)
    832832{
    833833        fat_cluster_t clst_last1 = FAT_CLST_LAST1(bs);
    834         int rc;
     834        errno_t rc;
    835835        service_id_t service_id = nodep->idx->service_id;
    836836
    … …  
    880880}
    881881
    882 int
     882errno_t
    883883fat_zero_cluster(struct fat_bs *bs, service_id_t service_id, fat_cluster_t c)
    884884{
    885885        int i;
    886886        block_t *b;
    887         int rc;
     887        errno_t rc;
    888888
    889889        for (i = 0; i < SPC(bs); i++) {
    … …  
    908908 * does not contain a fat file system.
    909909 */
    910 int fat_sanity_check(fat_bs_t *bs, service_id_t service_id)
     910errno_t fat_sanity_check(fat_bs_t *bs, service_id_t service_id)
    911911{
    912912        fat_cluster_t e0 = 0;
    913913        fat_cluster_t e1 = 0;
    914914        unsigned fat_no;
    915         int rc;
     915        errno_t rc;
    916916
    917917        /* Check number of FATs. */

  • uspace/srv/fs/fat/fat_fat.h

    rfacacc71 r46577995  
    108108#define fat_clusters_get(numc, bs, sid, fc) \
    109109    fat_cluster_walk((bs), (sid), (fc), NULL, (numc), (uint32_t) -1)
    110 extern int fat_cluster_walk(struct fat_bs *, service_id_t, fat_cluster_t,
     110extern errno_t fat_cluster_walk(struct fat_bs *, service_id_t, fat_cluster_t,
    111111    fat_cluster_t *, uint32_t *, uint32_t);
    112112
    113 extern int fat_block_get(block_t **, struct fat_bs *, struct fat_node *,
     113extern errno_t fat_block_get(block_t **, struct fat_bs *, struct fat_node *,
    114114    aoff64_t, int);
    115 extern int _fat_block_get(block_t **, struct fat_bs *, service_id_t,
     115extern errno_t _fat_block_get(block_t **, struct fat_bs *, service_id_t,
    116116    fat_cluster_t, fat_cluster_t *, aoff64_t, int);
    117117
    118 extern int fat_append_clusters(struct fat_bs *, struct fat_node *,
     118extern errno_t fat_append_clusters(struct fat_bs *, struct fat_node *,
    119119    fat_cluster_t, fat_cluster_t);
    120 extern int fat_chop_clusters(struct fat_bs *, struct fat_node *,
     120extern errno_t fat_chop_clusters(struct fat_bs *, struct fat_node *,
    121121    fat_cluster_t);
    122 extern int fat_alloc_clusters(struct fat_bs *, service_id_t, unsigned,
     122extern errno_t fat_alloc_clusters(struct fat_bs *, service_id_t, unsigned,
    123123    fat_cluster_t *, fat_cluster_t *);
    124 extern int fat_free_clusters(struct fat_bs *, service_id_t, fat_cluster_t);
    125 extern int fat_alloc_shadow_clusters(struct fat_bs *, service_id_t,
     124extern errno_t fat_free_clusters(struct fat_bs *, service_id_t, fat_cluster_t);
     125extern errno_t fat_alloc_shadow_clusters(struct fat_bs *, service_id_t,
    126126    fat_cluster_t *, unsigned);
    127 extern int fat_get_cluster(struct fat_bs *, service_id_t, unsigned,
     127extern errno_t fat_get_cluster(struct fat_bs *, service_id_t, unsigned,
    128128    fat_cluster_t, fat_cluster_t *);
    129 extern int fat_set_cluster(struct fat_bs *, service_id_t, unsigned,
     129extern errno_t fat_set_cluster(struct fat_bs *, service_id_t, unsigned,
    130130    fat_cluster_t, fat_cluster_t);
    131 extern int fat_fill_gap(struct fat_bs *, struct fat_node *, fat_cluster_t,
     131extern errno_t fat_fill_gap(struct fat_bs *, struct fat_node *, fat_cluster_t,
    132132    aoff64_t);
    133 extern int fat_zero_cluster(struct fat_bs *, service_id_t, fat_cluster_t);
    134 extern int fat_sanity_check(struct fat_bs *, service_id_t);
     133extern errno_t fat_zero_cluster(struct fat_bs *, service_id_t, fat_cluster_t);
     134extern errno_t fat_sanity_check(struct fat_bs *, service_id_t);
    135135
    136136#endif

  • uspace/srv/fs/fat/fat_idx.c

    rfacacc71 r46577995  
    328328}
    329329
    330 static int fat_idx_create(fat_idx_t **fidxp, service_id_t service_id)
     330static errno_t fat_idx_create(fat_idx_t **fidxp, service_id_t service_id)
    331331{
    332332        fat_idx_t *fidx;
    … …  
    350350}
    351351
    352 int fat_idx_get_new(fat_idx_t **fidxp, service_id_t service_id)
     352errno_t fat_idx_get_new(fat_idx_t **fidxp, service_id_t service_id)
    353353{
    354354        fat_idx_t *fidx;
    355         int rc;
     355        errno_t rc;
    356356
    357357        fibril_mutex_lock(&used_lock);
    … …  
    386386                fidx = hash_table_get_inst(l, fat_idx_t, uph_link);
    387387        } else {
    388                 int rc;
     388                errno_t rc;
    389389
    390390                rc = fat_idx_create(&fidx, service_id);
    … …  
    467467}
    468468
    469 int fat_idx_init(void)
     469errno_t fat_idx_init(void)
    470470{
    471471        if (!hash_table_create(&up_hash, 0, 0, &uph_ops))
    … …  
    486486}
    487487
    488 int fat_idx_init_by_service_id(service_id_t service_id)
     488errno_t fat_idx_init_by_service_id(service_id_t service_id)
    489489{
    490490        unused_t *u;
    491         int rc = EOK;
     491        errno_t rc = EOK;
    492492
    493493        u = (unused_t *) malloc(sizeof(unused_t));

  • uspace/srv/fs/fat/fat_ops.c

    rfacacc71 r46577995  
    7373 * Forward declarations of FAT libfs operations.
    7474 */
    75 static int fat_root_get(fs_node_t **, service_id_t);
    76 static int fat_match(fs_node_t **, fs_node_t *, const char *);
    77 static int fat_node_get(fs_node_t **, service_id_t, fs_index_t);
    78 static int fat_node_open(fs_node_t *);
    79 static int fat_node_put(fs_node_t *);
    80 static int fat_create_node(fs_node_t **, service_id_t, int);
    81 static int fat_destroy_node(fs_node_t *);
    82 static int fat_link(fs_node_t *, fs_node_t *, const char *);
    83 static int fat_unlink(fs_node_t *, fs_node_t *, const char *);
    84 static int fat_has_children(bool *, fs_node_t *);
     75static errno_t fat_root_get(fs_node_t **, service_id_t);
     76static errno_t fat_match(fs_node_t **, fs_node_t *, const char *);
     77static errno_t fat_node_get(fs_node_t **, service_id_t, fs_index_t);
     78static errno_t fat_node_open(fs_node_t *);
     79static errno_t fat_node_put(fs_node_t *);
     80static errno_t fat_create_node(fs_node_t **, service_id_t, int);
     81static errno_t fat_destroy_node(fs_node_t *);
     82static errno_t fat_link(fs_node_t *, fs_node_t *, const char *);
     83static errno_t fat_unlink(fs_node_t *, fs_node_t *, const char *);
     84static errno_t fat_has_children(bool *, fs_node_t *);
    8585static fs_index_t fat_index_get(fs_node_t *);
    8686static aoff64_t fat_size_get(fs_node_t *);
    … …  
    8989static bool fat_is_file(fs_node_t *node);
    9090static service_id_t fat_service_get(fs_node_t *node);
    91 static int fat_size_block(service_id_t, uint32_t *);
    92 static int fat_total_block_count(service_id_t, uint64_t *);
    93 static int fat_free_block_count(service_id_t, uint64_t *);
     91static errno_t fat_size_block(service_id_t, uint32_t *);
     92static errno_t fat_total_block_count(service_id_t, uint64_t *);
     93static errno_t fat_free_block_count(service_id_t, uint64_t *);
    9494
    9595/*
    … …  
    114114}
    115115
    116 static int fat_node_sync(fat_node_t *node)
     116static errno_t fat_node_sync(fat_node_t *node)
    117117{
    118118        block_t *b;
    119119        fat_bs_t *bs;
    120120        fat_dentry_t *d;
    121         int rc;
     121        errno_t rc;
    122122
    123123        assert(node->dirty);
    … …  
    148148}
    149149
    150 static int fat_node_fini_by_service_id(service_id_t service_id)
    151 {
    152         int rc;
     150static errno_t fat_node_fini_by_service_id(service_id_t service_id)
     151{
     152        errno_t rc;
    153153
    154154        /*
    … …  
    204204}
    205205
    206 static int fat_node_get_new(fat_node_t **nodepp)
     206static errno_t fat_node_get_new(fat_node_t **nodepp)
    207207{
    208208        fs_node_t *fn;
    209209        fat_node_t *nodep;
    210         int rc;
     210        errno_t rc;
    211211
    212212        fibril_mutex_lock(&ffn_mutex);
    … …  
    266266 * @param idxp          Locked index structure.
    267267 */
    268 static int fat_node_get_core(fat_node_t **nodepp, fat_idx_t *idxp)
     268static errno_t fat_node_get_core(fat_node_t **nodepp, fat_idx_t *idxp)
    269269{
    270270        block_t *b;
    … …  
    272272        fat_dentry_t *d;
    273273        fat_node_t *nodep = NULL;
    274         int rc;
     274        errno_t rc;
    275275
    276276        if (idxp->nodep) {
    … …  
    365365 */
    366366
    367 int fat_root_get(fs_node_t **rfn, service_id_t service_id)
     367errno_t fat_root_get(fs_node_t **rfn, service_id_t service_id)
    368368{
    369369        return fat_node_get(rfn, service_id, 0);
    370370}
    371371
    372 int fat_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
     372errno_t fat_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
    373373{
    374374        fat_node_t *parentp = FAT_NODE(pfn);
    … …  
    376376        fat_dentry_t *d;
    377377        service_id_t service_id;
    378         int rc;
     378        errno_t rc;
    379379
    380380        fibril_mutex_lock(&parentp->idx->lock);
    … …  
    426426
    427427/** Instantiate a FAT in-core node. */
    428 int fat_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
     428errno_t fat_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
    429429{
    430430        fat_node_t *nodep;
    431431        fat_idx_t *idxp;
    432         int rc;
     432        errno_t rc;
    433433
    434434        idxp = fat_idx_get_by_index(service_id, index);
    … …  
    445445}
    446446
    447 int fat_node_open(fs_node_t *fn)
     447errno_t fat_node_open(fs_node_t *fn)
    448448{
    449449        /*
    … …  
    454454}
    455455
    456 int fat_node_put(fs_node_t *fn)
     456errno_t fat_node_put(fs_node_t *fn)
    457457{
    458458        fat_node_t *nodep = FAT_NODE(fn);
    … …  
    483483}
    484484
    485 int fat_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
     485errno_t fat_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
    486486{
    487487        fat_idx_t *idxp;
    … …  
    489489        fat_bs_t *bs;
    490490        fat_cluster_t mcl, lcl;
    491         int rc;
     491        errno_t rc;
    492492
    493493        bs = block_bb_get(service_id);
    … …  
    538538}
    539539
    540 int fat_destroy_node(fs_node_t *fn)
     540errno_t fat_destroy_node(fs_node_t *fn)
    541541{
    542542        fat_node_t *nodep = FAT_NODE(fn);
    543543        fat_bs_t *bs;
    544544        bool has_children;
    545         int rc;
     545        errno_t rc;
    546546
    547547        /*
    … …  
    575575}
    576576
    577 int fat_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
     577errno_t fat_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
    578578{
    579579        fat_node_t *parentp = FAT_NODE(pfn);
    … …  
    584584        fat_directory_t di;
    585585        fat_dentry_t de;
    586         int rc;
     586        errno_t rc;
    587587
    588588        fibril_mutex_lock(&childp->lock);
    … …  
    696696}
    697697
    698 int fat_unlink(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
     698errno_t fat_unlink(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
    699699{
    700700        fat_node_t *parentp = FAT_NODE(pfn);
    701701        fat_node_t *childp = FAT_NODE(cfn);
    702702        bool has_children;
    703         int rc;
     703        errno_t rc;
    704704
    705705        if (!parentp)
    … …  
    753753}
    754754
    755 int fat_has_children(bool *has_children, fs_node_t *fn)
     755errno_t fat_has_children(bool *has_children, fs_node_t *fn)
    756756{
    757757        fat_bs_t *bs;
    … …  
    760760        block_t *b;
    761761        unsigned i, j;
    762         int rc;
     762        errno_t rc;
    763763
    764764        if (nodep->type != FAT_DIRECTORY) {
    … …  
    843843}
    844844
    845 int fat_size_block(service_id_t service_id, uint32_t *size)
     845errno_t fat_size_block(service_id_t service_id, uint32_t *size)
    846846{
    847847        fat_bs_t *bs;
    … …  
    853853}
    854854
    855 int fat_total_block_count(service_id_t service_id, uint64_t *count)
     855errno_t fat_total_block_count(service_id_t service_id, uint64_t *count)
    856856{
    857857        fat_bs_t *bs;
    … …  
    863863}
    864864
    865 int fat_free_block_count(service_id_t service_id, uint64_t *count)
     865errno_t fat_free_block_count(service_id_t service_id, uint64_t *count)
    866866{
    867867        fat_bs_t *bs;
    868868        fat_cluster_t e0;
    869869        uint64_t block_count;
    870         int rc;
     870        errno_t rc;
    871871        uint32_t cluster_no, clusters;
    872872
    … …  
    910910};
    911911
    912 static int fat_fs_open(service_id_t service_id, enum cache_mode cmode,
     912static errno_t fat_fs_open(service_id_t service_id, enum cache_mode cmode,
    913913    fs_node_t **rrfn, fat_idx_t **rridxp)
    914914{
    915915        fat_bs_t *bs;
    916         int rc;
     916        errno_t rc;
    917917
    918918        /* initialize libblock */
    … …  
    10371037 */
    10381038
    1039 static int fat_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
     1039static errno_t fat_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
    10401040{
    10411041        fat_idx_t *ridxp;
    … …  
    10441044        fat_directory_t di;
    10451045        char label[FAT_VOLLABEL_LEN + 1];
    1046         int rc;
     1046        errno_t rc;
    10471047
    10481048        rc = fat_fs_open(service_id, CACHE_MODE_WT, &rfn, &ridxp);
    … …  
    10761076}
    10771077
    1078 static int
     1078static errno_t
    10791079fat_mounted(service_id_t service_id, const char *opts, fs_index_t *index,
    10801080    aoff64_t *size)
    … …  
    10841084        fat_idx_t *ridxp;
    10851085        fs_node_t *rfn;
    1086         int rc;
     1086        errno_t rc;
    10871087
    10881088        instance = malloc(sizeof(fat_instance_t));
    … …  
    11251125}
    11261126
    1127 static int fat_update_fat32_fsinfo(service_id_t service_id)
     1127static errno_t fat_update_fat32_fsinfo(service_id_t service_id)
    11281128{
    11291129        fat_bs_t *bs;
    11301130        fat32_fsinfo_t *info;
    11311131        block_t *b;
    1132         int rc;
     1132        errno_t rc;
    11331133
    11341134        bs = block_bb_get(service_id);
    … …  
    11561156}
    11571157
    1158 static int fat_unmounted(service_id_t service_id)
     1158static errno_t fat_unmounted(service_id_t service_id)
    11591159{
    11601160        fs_node_t *fn;
    11611161        fat_node_t *nodep;
    11621162        fat_bs_t *bs;
    1163         int rc;
     1163        errno_t rc;
    11641164
    11651165        bs = block_bb_get(service_id);
    … …  
    12081208}
    12091209
    1210 static int
     1210static errno_t
    12111211fat_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
    12121212    size_t *rbytes)
    … …  
    12171217        size_t bytes;
    12181218        block_t *b;
    1219         int rc;
     1219        errno_t rc;
    12201220
    12211221        rc = fat_node_get(&fn, service_id, index);
    … …  
    13181318}
    13191319
    1320 static int
     1320static errno_t
    13211321fat_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
    13221322    size_t *wbytes, aoff64_t *nsize)
    … …  
    13291329        aoff64_t boundary;
    13301330        int flags = BLOCK_FLAGS_NONE;
    1331         int rc;
     1331        errno_t rc;
    13321332       
    13331333        rc = fat_node_get(&fn, service_id, index);
    … …  
    14551455}
    14561456
    1457 static int
     1457static errno_t
    14581458fat_truncate(service_id_t service_id, fs_index_t index, aoff64_t size)
    14591459{
    … …  
    14611461        fat_node_t *nodep;
    14621462        fat_bs_t *bs;
    1463         int rc;
     1463        errno_t rc;
    14641464
    14651465        rc = fat_node_get(&fn, service_id, index);
    … …  
    15141514}
    15151515
    1516 static int fat_close(service_id_t service_id, fs_index_t index)
    1517 {
    1518         return EOK;
    1519 }
    1520 
    1521 static int fat_destroy(service_id_t service_id, fs_index_t index)
     1516static errno_t fat_close(service_id_t service_id, fs_index_t index)
     1517{
     1518        return EOK;
     1519}
     1520
     1521static errno_t fat_destroy(service_id_t service_id, fs_index_t index)
    15221522{
    15231523        fs_node_t *fn;
    15241524        fat_node_t *nodep;
    1525         int rc;
     1525        errno_t rc;
    15261526
    15271527        rc = fat_node_get(&fn, service_id, index);
    … …  
    15421542}
    15431543
    1544 static int fat_sync(service_id_t service_id, fs_index_t index)
     1544static errno_t fat_sync(service_id_t service_id, fs_index_t index)
    15451545{
    15461546        fs_node_t *fn;
    1547         int rc = fat_node_get(&fn, service_id, index);
     1547        errno_t rc = fat_node_get(&fn, service_id, index);
    15481548        if (rc != EOK)
    15491549                return rc;

  • uspace/srv/fs/locfs/locfs.c

    rfacacc71 r46577995  
    8686        }
    8787       
    88         int rc = fs_register(vfs_sess, &locfs_vfs_info, &locfs_ops,
     88        errno_t rc = fs_register(vfs_sess, &locfs_vfs_info, &locfs_ops,
    8989            &locfs_libfs_ops);
    9090        if (rc != EOK) {

  • uspace/srv/fs/locfs/locfs_ops.c

    rfacacc71 r46577995  
    101101};
    102102
    103 static int locfs_node_get_internal(fs_node_t **rfn, loc_object_type_t type,
     103static errno_t locfs_node_get_internal(fs_node_t **rfn, loc_object_type_t type,
    104104    service_id_t service_id)
    105105{
    … …  
    125125}
    126126
    127 static int locfs_root_get(fs_node_t **rfn, service_id_t service_id)
     127static errno_t locfs_root_get(fs_node_t **rfn, service_id_t service_id)
    128128{
    129129        return locfs_node_get_internal(rfn, LOC_OBJECT_NONE, 0);
    130130}
    131131
    132 static int locfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
     132static errno_t locfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
    133133{
    134134        locfs_node_t *node = (locfs_node_t *) pfn->data;
    135         int ret;
     135        errno_t ret;
    136136       
    137137        if (node->service_id == 0) {
    … …  
    208208}
    209209
    210 static int locfs_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
     210static errno_t locfs_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
    211211{
    212212        return locfs_node_get_internal(rfn, loc_id_probe(index), index);
    213213}
    214214
    215 static int locfs_node_open(fs_node_t *fn)
     215static errno_t locfs_node_open(fs_node_t *fn)
    216216{
    217217        locfs_node_t *node = (locfs_node_t *) fn->data;
    … …  
    312312}
    313313
    314 static int locfs_node_put(fs_node_t *fn)
     314static errno_t locfs_node_put(fs_node_t *fn)
    315315{
    316316        free(fn->data);
    … …  
    319319}
    320320
    321 static int locfs_create_node(fs_node_t **rfn, service_id_t service_id, int lflag)
     321static errno_t locfs_create_node(fs_node_t **rfn, service_id_t service_id, int lflag)
    322322{
    323323        assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
    … …  
    327327}
    328328
    329 static int locfs_destroy_node(fs_node_t *fn)
     329static errno_t locfs_destroy_node(fs_node_t *fn)
    330330{
    331331        return ENOTSUP;
    332332}
    333333
    334 static int locfs_link_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
     334static errno_t locfs_link_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
    335335{
    336336        return ENOTSUP;
    337337}
    338338
    339 static int locfs_unlink_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
     339static errno_t locfs_unlink_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
    340340{
    341341        return ENOTSUP;
    342342}
    343343
    344 static int locfs_has_children(bool *has_children, fs_node_t *fn)
     344static errno_t locfs_has_children(bool *has_children, fs_node_t *fn)
    345345{
    346346        locfs_node_t *node = (locfs_node_t *) fn->data;
    … …  
    455455}
    456456
    457 static int locfs_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
     457static errno_t locfs_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
    458458{
    459459        return ENOTSUP;
    460460}
    461461
    462 static int locfs_mounted(service_id_t service_id, const char *opts,
     462static errno_t locfs_mounted(service_id_t service_id, const char *opts,
    463463    fs_index_t *index, aoff64_t *size)
    464464{
    … …  
    468468}
    469469
    470 static int locfs_unmounted(service_id_t service_id)
     470static errno_t locfs_unmounted(service_id_t service_id)
    471471{
    472472        return ENOTSUP;
    473473}
    474474
    475 static int
     475static errno_t
    476476locfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
    477477    size_t *rbytes)
    … …  
    590590               
    591591                /* Wait for reply from the driver. */
    592                 int rc;
     592                errno_t rc;
    593593                async_wait_for(msg, &rc);
    594594
    595595                /* Do not propagate EHANGUP back to VFS. */
    596                 if ((int) rc == EHANGUP)
     596                if ((errno_t) rc == EHANGUP)
    597597                        rc = ENOTSUP;
    598598               
    … …  
    604604}
    605605
    606 static int
     606static errno_t
    607607locfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
    608608    size_t *wbytes, aoff64_t *nsize)
    … …  
    654654               
    655655                /* Wait for reply from the driver. */
    656                 int rc;
     656                errno_t rc;
    657657                async_wait_for(msg, &rc);
    658658
    659659                /* Do not propagate EHANGUP back to VFS. */
    660                 if ((int) rc == EHANGUP)
     660                if ((errno_t) rc == EHANGUP)
    661661                        rc = ENOTSUP;
    662662               
    … …  
    669669}
    670670
    671 static int
     671static errno_t
    672672locfs_truncate(service_id_t service_id, fs_index_t index, aoff64_t size)
    673673{
    … …  
    675675}
    676676
    677 static int locfs_close(service_id_t service_id, fs_index_t index)
     677static errno_t locfs_close(service_id_t service_id, fs_index_t index)
    678678{
    679679        if (index == 0)
    … …  
    715715}
    716716
    717 static int locfs_sync(service_id_t service_id, fs_index_t index)
     717static errno_t locfs_sync(service_id_t service_id, fs_index_t index)
    718718{
    719719        if (index == 0)
    … …  
    752752               
    753753                /* Wait for reply from the driver */
    754                 int rc;
     754                errno_t rc;
    755755                async_wait_for(msg, &rc);
    756756               
    … …  
    761761}
    762762
    763 static int locfs_destroy(service_id_t service_id, fs_index_t index)
     763static errno_t locfs_destroy(service_id_t service_id, fs_index_t index)
    764764{
    765765        return ENOTSUP;

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

    rfacacc71 r46577995  
    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

    rfacacc71 r46577995  
    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

    rfacacc71 r46577995  
    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

    rfacacc71 r46577995  
    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

    rfacacc71 r46577995  
    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

    rfacacc71 r46577995  
    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

    rfacacc71 r46577995  
    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;

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

    rfacacc71 r46577995  
    8888        }
    8989       
    90         int rc = fs_register(vfs_sess, &tmpfs_vfs_info, &tmpfs_ops,
     90        errno_t rc = fs_register(vfs_sess, &tmpfs_vfs_info, &tmpfs_ops,
    9191            &tmpfs_libfs_ops);
    9292        if (rc != EOK) {

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

    rfacacc71 r46577995  
    6363        struct rdentry entry;
    6464        libfs_ops_t *ops = &tmpfs_libfs_ops;
    65         int rc;
     65        errno_t rc;
    6666       
    6767        do {
    … …  
    168168        libfs_ops_t *ops = &tmpfs_libfs_ops;
    169169        fs_node_t *fn;
    170         int rc;
     170        errno_t rc;
    171171
    172172        rc = block_init(dsid, TMPFS_COMM_SIZE);

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

    rfacacc71 r46577995  
    6464
    6565/* Forward declarations of static functions. */
    66 static int tmpfs_match(fs_node_t **, fs_node_t *, const char *);
    67 static int tmpfs_node_get(fs_node_t **, service_id_t, fs_index_t);
    68 static int tmpfs_node_open(fs_node_t *);
    69 static int tmpfs_node_put(fs_node_t *);
    70 static int tmpfs_create_node(fs_node_t **, service_id_t, int);
    71 static int tmpfs_destroy_node(fs_node_t *);
    72 static int tmpfs_link_node(fs_node_t *, fs_node_t *, const char *);
    73 static int tmpfs_unlink_node(fs_node_t *, fs_node_t *, const char *);
     66static errno_t tmpfs_match(fs_node_t **, fs_node_t *, const char *);
     67static errno_t tmpfs_node_get(fs_node_t **, service_id_t, fs_index_t);
     68static errno_t tmpfs_node_open(fs_node_t *);
     69static errno_t tmpfs_node_put(fs_node_t *);
     70static errno_t tmpfs_create_node(fs_node_t **, service_id_t, int);
     71static errno_t tmpfs_destroy_node(fs_node_t *);
     72static errno_t tmpfs_link_node(fs_node_t *, fs_node_t *, const char *);
     73static errno_t tmpfs_unlink_node(fs_node_t *, fs_node_t *, const char *);
    7474
    7575/* Implementation of helper functions. */
    76 static int tmpfs_root_get(fs_node_t **rfn, service_id_t service_id)
     76static errno_t tmpfs_root_get(fs_node_t **rfn, service_id_t service_id)
    7777{
    7878        return tmpfs_node_get(rfn, service_id, TMPFS_SOME_ROOT);
    7979}
    8080
    81 static int tmpfs_has_children(bool *has_children, fs_node_t *fn)
     81static errno_t tmpfs_has_children(bool *has_children, fs_node_t *fn)
    8282{
    8383        *has_children = !list_empty(&TMPFS_NODE(fn)->cs_list);
    … …  
    227227{
    228228        fs_node_t *rfn;
    229         int rc;
     229        errno_t rc;
    230230       
    231231        rc = tmpfs_create_node(&rfn, service_id, L_DIRECTORY);
    … …  
    252252}
    253253
    254 int tmpfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
     254errno_t tmpfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
    255255{
    256256        tmpfs_node_t *parentp = TMPFS_NODE(pfn);
    … …  
    267267}
    268268
    269 int tmpfs_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
     269errno_t tmpfs_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
    270270{
    271271        node_key_t key = {
    … …  
    286286}
    287287
    288 int tmpfs_node_open(fs_node_t *fn)
     288errno_t tmpfs_node_open(fs_node_t *fn)
    289289{
    290290        /* nothing to do */
    … …  
    292292}
    293293
    294 int tmpfs_node_put(fs_node_t *fn)
     294errno_t tmpfs_node_put(fs_node_t *fn)
    295295{
    296296        /* nothing to do */
    … …  
    298298}
    299299
    300 int tmpfs_create_node(fs_node_t **rfn, service_id_t service_id, int lflag)
     300errno_t tmpfs_create_node(fs_node_t **rfn, service_id_t service_id, int lflag)
    301301{
    302302        fs_node_t *rootfn;
    303         int rc;
     303        errno_t rc;
    304304
    305305        assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
    … …  
    335335}
    336336
    337 int tmpfs_destroy_node(fs_node_t *fn)
     337errno_t tmpfs_destroy_node(fs_node_t *fn)
    338338{
    339339        tmpfs_node_t *nodep = TMPFS_NODE(fn);
    … …  
    351351}
    352352
    353 int tmpfs_link_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
     353errno_t tmpfs_link_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
    354354{
    355355        tmpfs_node_t *parentp = TMPFS_NODE(pfn);
    … …  
    386386}
    387387
    388 int tmpfs_unlink_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
     388errno_t tmpfs_unlink_node(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
    389389{
    390390        tmpfs_node_t *parentp = TMPFS_NODE(pfn);
    … …  
    421421 */
    422422
    423 static int tmpfs_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
     423static errno_t tmpfs_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
    424424{
    425425        return ENOTSUP;
    426426}
    427427
    428 static int
     428static errno_t
    429429tmpfs_mounted(service_id_t service_id, const char *opts, fs_index_t *index,
    430430    aoff64_t *size)
    431431{
    432432        fs_node_t *rootfn;
    433         int rc;
     433        errno_t rc;
    434434       
    435435        /* Check if this device is not already mounted. */
    … …  
    458458}
    459459
    460 static int tmpfs_unmounted(service_id_t service_id)
     460static errno_t tmpfs_unmounted(service_id_t service_id)
    461461{
    462462        tmpfs_instance_done(service_id);
    … …  
    464464}
    465465
    466 static int tmpfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
     466static errno_t tmpfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
    467467    size_t *rbytes)
    468468{
    … …  
    525525}
    526526
    527 static int
     527static errno_t
    528528tmpfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
    529529    size_t *wbytes, aoff64_t *nsize)
    … …  
    589589}
    590590
    591 static int tmpfs_truncate(service_id_t service_id, fs_index_t index,
     591static errno_t tmpfs_truncate(service_id_t service_id, fs_index_t index,
    592592    aoff64_t size)
    593593{
    … …  
    626626}
    627627
    628 static int tmpfs_close(service_id_t service_id, fs_index_t index)
    629 {
    630         return EOK;
    631 }
    632 
    633 static int tmpfs_destroy(service_id_t service_id, fs_index_t index)
     628static errno_t tmpfs_close(service_id_t service_id, fs_index_t index)
     629{
     630        return EOK;
     631}
     632
     633static errno_t tmpfs_destroy(service_id_t service_id, fs_index_t index)
    634634{
    635635        node_key_t key = {
    … …  
    646646}
    647647
    648 static int tmpfs_sync(service_id_t service_id, fs_index_t index)
     648static errno_t tmpfs_sync(service_id_t service_id, fs_index_t index)
    649649{
    650650        /*

  • uspace/srv/fs/udf/udf.c

    rfacacc71 r46577995  
    8181        }
    8282       
    83         int rc = fs_register(vfs_sess, &udf_vfs_info, &udf_ops,
     83        errno_t rc = fs_register(vfs_sess, &udf_vfs_info, &udf_ops,
    8484            &udf_libfs_ops);
    8585        if (rc != EOK)

  • uspace/srv/fs/udf/udf_file.c

    rfacacc71 r46577995  
    5757 *
    5858 */
    59 static int udf_read_extended_allocator(udf_node_t *node, uint16_t icb_flag,
     59static errno_t udf_read_extended_allocator(udf_node_t *node, uint16_t icb_flag,
    6060    uint32_t pos)
    6161{
    6262        block_t *block = NULL;
    63         int rc = block_get(&block, node->instance->service_id, pos,
     63        errno_t rc = block_get(&block, node->instance->service_id, pos,
    6464            BLOCK_FLAGS_NONE);
    6565        if (rc != EOK)
    … …  
    9393 *
    9494 */
    95 int udf_read_allocation_sequence(udf_node_t *node, uint8_t *af,
     95errno_t udf_read_allocation_sequence(udf_node_t *node, uint8_t *af,
    9696    uint16_t icb_flag, uint32_t start_alloc, uint32_t len)
    9797{
    … …  
    233233 * @return    EOK on success or an error code.
    234234 */
    235 int udf_read_icb(udf_node_t *node)
     235errno_t udf_read_icb(udf_node_t *node)
    236236{
    237237        while (true) {
    … …  
    239239               
    240240                block_t *block = NULL;
    241                 int rc = block_get(&block, node->instance->service_id, pos,
     241                errno_t rc = block_get(&block, node->instance->service_id, pos,
    242242                    BLOCK_FLAGS_NONE);
    243243                if (rc != EOK)
    … …  
    303303 *
    304304 */
    305 int udf_node_get_core(udf_node_t *node)
     305errno_t udf_node_get_core(udf_node_t *node)
    306306{
    307307        node->link_cnt = 1;
    … …  
    318318 *
    319319 */
    320 static int udf_get_fid_in_data(udf_file_identifier_descriptor_t **fid,
     320static errno_t udf_get_fid_in_data(udf_file_identifier_descriptor_t **fid,
    321321    udf_node_t *node, aoff64_t pos)
    322322{
    … …  
    369369 *
    370370 */
    371 int udf_get_fid(udf_file_identifier_descriptor_t **fid, block_t **block,
     371errno_t udf_get_fid(udf_file_identifier_descriptor_t **fid, block_t **block,
    372372    udf_node_t *node, aoff64_t pos)
    373373{
    … …  
    388388 *
    389389 */
    390 int udf_get_fid_in_allocator(udf_file_identifier_descriptor_t **fid,
     390errno_t udf_get_fid_in_allocator(udf_file_identifier_descriptor_t **fid,
    391391    block_t **block, udf_node_t *node, aoff64_t pos)
    392392{
    … …  
    402402                size_t i = 0;
    403403                while (i * node->instance->sector_size < node->allocators[j].length) {
    404                         int rc = block_get(block, node->instance->service_id,
     404                        errno_t rc = block_get(block, node->instance->service_id,
    405405                            node->allocators[j].position + i, BLOCK_FLAGS_NONE);
    406406                        if (rc != EOK) {
    … …  
    469469 *
    470470 */
    471 int udf_get_fid_in_sector(udf_file_identifier_descriptor_t **fid,
     471errno_t udf_get_fid_in_sector(udf_file_identifier_descriptor_t **fid,
    472472    block_t **block, udf_node_t *node, aoff64_t pos, size_t *n, void **buf,
    473473    size_t *len)
    … …  
    576576 *
    577577 */
    578 int udf_read_file(size_t *read_len, ipc_callid_t callid, udf_node_t *node,
     578errno_t udf_read_file(size_t *read_len, ipc_callid_t callid, udf_node_t *node,
    579579    aoff64_t pos, size_t len)
    580580{
    … …  
    594594       
    595595        block_t *block = NULL;
    596         int rc = block_get(&block, node->instance->service_id,
     596        errno_t rc = block_get(&block, node->instance->service_id,
    597597            node->allocators[i].position + (sector_num - sector_cnt),
    598598            BLOCK_FLAGS_NONE);

  • uspace/srv/fs/udf/udf_file.h

    rfacacc71 r46577995  
    194194}__attribute__((packed)) udf_space_bitmap_descriptor_t;
    195195
    196 extern int udf_node_get_core(udf_node_t *);
    197 extern int udf_read_icb(udf_node_t *);
    198 extern int udf_read_allocation_sequence(udf_node_t *, uint8_t *, uint16_t,
     196extern errno_t udf_node_get_core(udf_node_t *);
     197extern errno_t udf_read_icb(udf_node_t *);
     198extern errno_t udf_read_allocation_sequence(udf_node_t *, uint8_t *, uint16_t,
    199199    uint32_t, uint32_t);
    200 extern int udf_read_file(size_t *, ipc_callid_t, udf_node_t *, aoff64_t,
     200extern errno_t udf_read_file(size_t *, ipc_callid_t, udf_node_t *, aoff64_t,
    201201    size_t);
    202 extern int udf_get_fid(udf_file_identifier_descriptor_t **, block_t **,
     202extern errno_t udf_get_fid(udf_file_identifier_descriptor_t **, block_t **,
    203203    udf_node_t *, aoff64_t);
    204 extern int udf_get_fid_in_allocator(udf_file_identifier_descriptor_t **,
     204extern errno_t udf_get_fid_in_allocator(udf_file_identifier_descriptor_t **,
    205205    block_t **, udf_node_t *, aoff64_t);
    206 extern int udf_get_fid_in_sector(udf_file_identifier_descriptor_t **,
     206extern errno_t udf_get_fid_in_sector(udf_file_identifier_descriptor_t **,
    207207    block_t **, udf_node_t *, aoff64_t, size_t *, void **, size_t *);
    208208

  • uspace/srv/fs/udf/udf_idx.c

    rfacacc71 r46577995  
    9191 *
    9292 */
    93 int udf_idx_init(void)
     93errno_t udf_idx_init(void)
    9494{
    9595        if (!hash_table_create(&udf_idx, 0, 0, &udf_idx_ops))
    … …  
    104104 *
    105105 */
    106 int udf_idx_fini(void)
     106errno_t udf_idx_fini(void)
    107107{
    108108        hash_table_destroy(&udf_idx);
    … …  
    119119 *
    120120 */
    121 int udf_idx_get(udf_node_t **udfn, udf_instance_t *instance, fs_index_t index)
     121errno_t udf_idx_get(udf_node_t **udfn, udf_instance_t *instance, fs_index_t index)
    122122{
    123123        fibril_mutex_lock(&udf_idx_lock);
    … …  
    153153 *
    154154 */
    155 int udf_idx_add(udf_node_t **udfn, udf_instance_t *instance, fs_index_t index)
     155errno_t udf_idx_add(udf_node_t **udfn, udf_instance_t *instance, fs_index_t index)
    156156{
    157157        fibril_mutex_lock(&udf_idx_lock);
    … …  
    199199 *
    200200 */
    201 int udf_idx_del(udf_node_t *node)
     201errno_t udf_idx_del(udf_node_t *node)
    202202{
    203203        assert(node->ref_cnt == 0);

  • uspace/srv/fs/udf/udf_idx.h

    rfacacc71 r46577995  
    3636#include "udf.h"
    3737
    38 extern int udf_idx_init(void);
    39 extern int udf_idx_fini(void);
    40 extern int udf_idx_get(udf_node_t **, udf_instance_t *, fs_index_t);
    41 extern int udf_idx_add(udf_node_t **, udf_instance_t *, fs_index_t);
    42 extern int udf_idx_del(udf_node_t *);
     38extern errno_t udf_idx_init(void);
     39extern errno_t udf_idx_fini(void);
     40extern errno_t udf_idx_get(udf_node_t **, udf_instance_t *, fs_index_t);
     41extern errno_t udf_idx_add(udf_node_t **, udf_instance_t *, fs_index_t);
     42extern errno_t udf_idx_del(udf_node_t *);
    4343
    4444#endif /* UDF_IDX_H_ */

  • uspace/srv/fs/udf/udf_ops.c

    rfacacc71 r46577995  
    6868static LIST_INITIALIZE(ffn_list);
    6969
    70 static int udf_node_get(fs_node_t **rfn, service_id_t service_id,
     70static errno_t udf_node_get(fs_node_t **rfn, service_id_t service_id,
    7171    fs_index_t index)
    7272{
    7373        udf_instance_t *instance;
    74         int rc = fs_instance_get(service_id, (void **) &instance);
     74        errno_t rc = fs_instance_get(service_id, (void **) &instance);
    7575        if (rc != EOK)
    7676                return rc;
    … …  
    9494}
    9595
    96 static int udf_root_get(fs_node_t **rfn, service_id_t service_id)
     96static errno_t udf_root_get(fs_node_t **rfn, service_id_t service_id)
    9797{
    9898        udf_instance_t *instance;
    99         int rc = fs_instance_get(service_id, (void **) &instance);
     99        errno_t rc = fs_instance_get(service_id, (void **) &instance);
    100100        if (rc != EOK)
    101101                return rc;
    … …  
    114114}
    115115
    116 static int udf_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
     116static errno_t udf_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
    117117{
    118118        char *name = malloc(MAX_FILE_NAME_LEN + 1);
    … …  
    132132               
    133133                if (str_casecmp(name, component) == 0) {
    134                         int rc = udf_node_get(rfn, udf_service_get(pfn),
     134                        errno_t rc = udf_node_get(rfn, udf_service_get(pfn),
    135135                            udf_long_ad_to_pos(UDF_NODE(pfn)->instance, &long_ad));
    136136                       
    … …  
    143143               
    144144                if (block != NULL) {
    145                         int rc = block_put(block);
     145                        errno_t rc = block_put(block);
    146146                        if (rc != EOK)
    147147                                return rc;
    … …  
    155155}
    156156
    157 static int udf_node_open(fs_node_t *fn)
    158 {
    159         return EOK;
    160 }
    161 
    162 static int udf_node_put(fs_node_t *fn)
     157static errno_t udf_node_open(fs_node_t *fn)
     158{
     159        return EOK;
     160}
     161
     162static errno_t udf_node_put(fs_node_t *fn)
    163163{
    164164        udf_node_t *node = UDF_NODE(fn);
    … …  
    177177}
    178178
    179 static int udf_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
    180 {
    181         return ENOTSUP;
    182 }
    183 
    184 static int udf_destroy_node(fs_node_t *fn)
    185 {
    186         return ENOTSUP;
    187 }
    188 
    189 static int udf_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
    190 {
    191         return ENOTSUP;
    192 }
    193 
    194 static int udf_unlink(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
    195 {
    196         return ENOTSUP;
    197 }
    198 
    199 static int udf_has_children(bool *has_children, fs_node_t *fn)
     179static errno_t udf_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
     180{
     181        return ENOTSUP;
     182}
     183
     184static errno_t udf_destroy_node(fs_node_t *fn)
     185{
     186        return ENOTSUP;
     187}
     188
     189static errno_t udf_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
     190{
     191        return ENOTSUP;
     192}
     193
     194static errno_t udf_unlink(fs_node_t *pfn, fs_node_t *cfn, const char *nm)
     195{
     196        return ENOTSUP;
     197}
     198
     199static errno_t udf_has_children(bool *has_children, fs_node_t *fn)
    200200{
    201201        *has_children = true;
    … …  
    248248}
    249249
    250 static int udf_size_block(service_id_t service_id, uint32_t *size)
     250static errno_t udf_size_block(service_id_t service_id, uint32_t *size)
    251251{
    252252        udf_instance_t *instance;
    253         int rc = fs_instance_get(service_id, (void **) &instance);
     253        errno_t rc = fs_instance_get(service_id, (void **) &instance);
    254254        if (rc != EOK)
    255255                return rc;
    … …  
    263263}
    264264
    265 static int udf_total_block_count(service_id_t service_id, uint64_t *count)
     265static errno_t udf_total_block_count(service_id_t service_id, uint64_t *count)
    266266{
    267267        *count = 0;
    … …  
    270270}
    271271
    272 static int udf_free_block_count(service_id_t service_id, uint64_t *count)
     272static errno_t udf_free_block_count(service_id_t service_id, uint64_t *count)
    273273{
    274274        *count = 0;
    … …  
    299299};
    300300
    301 static int udf_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
    302 {
    303         return ENOTSUP;
    304 }
    305 
    306 static int udf_mounted(service_id_t service_id, const char *opts,
     301static errno_t udf_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
     302{
     303        return ENOTSUP;
     304}
     305
     306static errno_t udf_mounted(service_id_t service_id, const char *opts,
    307307    fs_index_t *index, aoff64_t *size)
    308308{
    … …  
    330330       
    331331        /* initialize block cache */
    332         int rc = block_init(service_id, MAX_SIZE);
     332        errno_t rc = block_init(service_id, MAX_SIZE);
    333333        if (rc != EOK)
    334334                return rc;
    … …  
    415415}
    416416
    417 static int udf_unmounted(service_id_t service_id)
     417static errno_t udf_unmounted(service_id_t service_id)
    418418{
    419419        fs_node_t *fn;
    420         int rc = udf_root_get(&fn, service_id);
     420        errno_t rc = udf_root_get(&fn, service_id);
    421421        if (rc != EOK)
    422422                return rc;
    … …  
    449449}
    450450
    451 static int udf_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
     451static errno_t udf_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
    452452    size_t *rbytes)
    453453{
    454454        udf_instance_t *instance;
    455         int rc = fs_instance_get(service_id, (void **) &instance);
     455        errno_t rc = fs_instance_get(service_id, (void **) &instance);
    456456        if (rc != EOK)
    457457                return rc;
    … …  
    523523}
    524524
    525 static int udf_close(service_id_t service_id, fs_index_t index)
    526 {
    527         return EOK;
    528 }
    529 
    530 static int udf_sync(service_id_t service_id, fs_index_t index)
    531 {
    532         return ENOTSUP;
    533 }
    534 
    535 static int udf_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
     525static errno_t udf_close(service_id_t service_id, fs_index_t index)
     526{
     527        return EOK;
     528}
     529
     530static errno_t udf_sync(service_id_t service_id, fs_index_t index)
     531{
     532        return ENOTSUP;
     533}
     534
     535static errno_t udf_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
    536536    size_t *wbytes, aoff64_t *nsize)
    537537{
    … …  
    539539}
    540540
    541 static int udf_truncate(service_id_t service_id, fs_index_t index,
     541static errno_t udf_truncate(service_id_t service_id, fs_index_t index,
    542542    aoff64_t size)
    543543{
    … …  
    545545}
    546546
    547 static int udf_destroy(service_id_t service_id, fs_index_t index)
     547static errno_t udf_destroy(service_id_t service_id, fs_index_t index)
    548548{
    549549        return ENOTSUP;

  • uspace/srv/fs/udf/udf_volume.c

    rfacacc71 r46577995  
    8484 *
    8585 */
    86 static int udf_volume_recongnition_structure_test(service_id_t service_id,
     86static errno_t udf_volume_recongnition_structure_test(service_id_t service_id,
    8787    aoff64_t addr, udf_vrs_descriptor_t *vd)
    8888{
    … …  
    100100 * @return    EOK on success or an error code.
    101101 */
    102 int udf_volume_recongnition(service_id_t service_id)
     102errno_t udf_volume_recongnition(service_id_t service_id)
    103103{
    104104        aoff64_t addr = VRS_ADDR;
    … …  
    109109                return ENOMEM;
    110110       
    111         int rc = udf_volume_recongnition_structure_test(service_id, addr, vd);
     111        errno_t rc = udf_volume_recongnition_structure_test(service_id, addr, vd);
    112112        if (rc != EOK) {
    113113                free(vd);
    … …  
    170170 *
    171171 */
    172 static int udf_get_anchor_volume_descriptor_by_ssize(service_id_t service_id,
     172static errno_t udf_get_anchor_volume_descriptor_by_ssize(service_id_t service_id,
    173173    udf_anchor_volume_descriptor_t *avd, uint32_t sector_size)
    174174{
    175         int rc = block_read_bytes_direct(service_id,
     175        errno_t rc = block_read_bytes_direct(service_id,
    176176            UDF_AVDP_SECTOR * sector_size,
    177177            sizeof(udf_anchor_volume_descriptor_t), avd);
    … …  
    207207 *
    208208 */
    209 int udf_get_anchor_volume_descriptor(service_id_t service_id,
     209errno_t udf_get_anchor_volume_descriptor(service_id_t service_id,
    210210    udf_anchor_volume_descriptor_t *avd)
    211211{
    … …  
    213213       
    214214        udf_instance_t *instance;
    215         int rc = fs_instance_get(service_id, (void **) &instance);
     215        errno_t rc = fs_instance_get(service_id, (void **) &instance);
    216216        if (rc != EOK)
    217217                return rc;
    … …  
    360360 *
    361361 */
    362 static int udf_read_virtual_partition(udf_instance_t *instance, uint32_t pos,
     362static errno_t udf_read_virtual_partition(udf_instance_t *instance, uint32_t pos,
    363363    uint32_t id)
    364364{
    365365        block_t *block = NULL;
    366         int rc = block_get(&block, instance->service_id, pos,
     366        errno_t rc = block_get(&block, instance->service_id, pos,
    367367            BLOCK_FLAGS_NONE);
    368368        if (rc != EOK)
    … …  
    441441 *
    442442 */
    443 static int udf_fill_volume_info(udf_logical_volume_descriptor_t *lvd,
     443static errno_t udf_fill_volume_info(udf_logical_volume_descriptor_t *lvd,
    444444    size_t lvd_cnt, udf_partition_descriptor_t *pd, size_t pd_cnt,
    445445    udf_instance_t *instance)
    … …  
    553553                                instance->partitions[j].number =
    554554                                    FLE16(metadata->partition_number);
    555                                 int rc = udf_read_virtual_partition(instance,
     555                                errno_t rc = udf_read_virtual_partition(instance,
    556556                                    FLE32(metadata->metadata_fileloc) +
    557557                                    FLE32(pd[pd_num].starting_location), j);
    … …  
    601601 *
    602602 */
    603 int udf_read_volume_descriptor_sequence(service_id_t service_id,
     603errno_t udf_read_volume_descriptor_sequence(service_id_t service_id,
    604604    udf_extent_t addr)
    605605{
    606606        udf_instance_t *instance;
    607         int rc = fs_instance_get(service_id, (void **) &instance);
     607        errno_t rc = fs_instance_get(service_id, (void **) &instance);
    608608        if (rc != EOK)
    609609                return rc;

  • uspace/srv/fs/udf/udf_volume.h

    rfacacc71 r46577995  
    212212} __attribute__((packed)) udf_partition_header_descriptor_t;
    213213
    214 extern int udf_volume_recongnition(service_id_t);
    215 extern int udf_get_anchor_volume_descriptor(service_id_t,
     214extern errno_t udf_volume_recongnition(service_id_t);
     215extern errno_t udf_get_anchor_volume_descriptor(service_id_t,
    216216    udf_anchor_volume_descriptor_t *);
    217 extern int udf_read_volume_descriptor_sequence(service_id_t, udf_extent_t);
     217extern errno_t udf_read_volume_descriptor_sequence(service_id_t, udf_extent_t);
    218218extern fs_index_t udf_long_ad_to_pos(udf_instance_t *, udf_long_ad_t *);
    219219
Note: See TracChangeset for help on using the changeset viewer.