Changeset 46577995 in mainline for uspace/srv/fs/fat


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/fat
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • 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;
Note: See TracChangeset for help on using the changeset viewer.