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

Changeset edb14ca in mainline


Ignore:
Timestamp:
2009-09-21T16:11:52Z (11 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
master
Children:
0daba21, d27ed12
Parents:
c1618ed (diff), 46c0498 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge FAT server error handling improvements.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/fs/fat/fat_ops.c

    rc1618ed redb14ca  
    7878}
    7979
    80 static void fat_node_sync(fat_node_t *node)
     80static int fat_node_sync(fat_node_t *node)
    8181{
    8282        block_t *b;
     
    9696        rc = _fat_block_get(&b, bs, node->idx->dev_handle, node->idx->pfc,
    9797            (node->idx->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
    98         assert(rc == EOK);
     98        if (rc != EOK)
     99                return rc;
    99100
    100101        d = ((fat_dentry_t *)b->data) + (node->idx->pdi % dps);
     
    111112        b->dirty = true;                /* need to sync block */
    112113        rc = block_put(b);
    113         assert(rc == EOK);
     114        return rc;
    114115}
    115116
     
    118119        fs_node_t *fn;
    119120        fat_node_t *nodep;
     121        int rc;
    120122
    121123        fibril_mutex_lock(&ffn_mutex);
     
    133135                list_remove(&nodep->ffn_link);
    134136                fibril_mutex_unlock(&ffn_mutex);
    135                 if (nodep->dirty)
    136                         fat_node_sync(nodep);
     137                if (nodep->dirty) {
     138                        rc = fat_node_sync(nodep);
     139                        assert(rc == EOK);
     140                }
    137141                idxp_tmp->nodep = NULL;
    138142                fibril_mutex_unlock(&nodep->lock);
     
    441445        for (i = 0; i < blocks; i++) {
    442446                rc = fat_block_get(&b, bs, parentp, i, BLOCK_FLAGS_NONE);
    443                 assert(rc == EOK);
     447                if (rc != EOK) {
     448                        fibril_mutex_unlock(&parentp->idx->lock);
     449                        return rc;
     450                }
    444451                for (j = 0; j < dps; j++) {
    445452                        d = ((fat_dentry_t *)b->data) + j;
     
    456463                }
    457464                rc = block_put(b);
    458                 assert(rc == EOK);
     465                if (rc != EOK) {
     466                        fibril_mutex_unlock(&parentp->idx->lock);
     467                        return rc;
     468                }
    459469        }
    460470        j = 0;
     
    474484        }
    475485        rc = fat_zero_cluster(bs, parentp->idx->dev_handle, mcl);
    476         assert(rc == EOK);
     486        if (rc != EOK) {
     487                fibril_mutex_unlock(&parentp->idx->lock);
     488                return rc;
     489        }
    477490        rc = fat_append_clusters(bs, parentp, mcl);
    478         assert(rc == EOK);
     491        if (rc != EOK) {
     492                fibril_mutex_unlock(&parentp->idx->lock);
     493                return rc;
     494        }
    479495        parentp->size += bps * bs->spc;
    480496        parentp->dirty = true;          /* need to sync node */
    481497        rc = fat_block_get(&b, bs, parentp, i, BLOCK_FLAGS_NONE);
    482         assert(rc == EOK);
     498        if (rc != EOK) {
     499                fibril_mutex_unlock(&parentp->idx->lock);
     500                return rc;
     501        }
    483502        d = (fat_dentry_t *)b->data;
    484503
     
    494513        b->dirty = true;                /* need to sync block */
    495514        rc = block_put(b);
    496         assert(rc == EOK);
    497515        fibril_mutex_unlock(&parentp->idx->lock);
     516        if (rc != EOK)
     517                return rc;
    498518
    499519        fibril_mutex_lock(&childp->idx->lock);
     
    506526         */
    507527        rc = fat_block_get(&b, bs, childp, 0, BLOCK_FLAGS_NONE);
    508         assert(rc == EOK);
     528        if (rc != EOK) {
     529                /*
     530                 * Rather than returning an error, simply skip the creation of
     531                 * these two entries.
     532                 */
     533                goto skip_dots;
     534        }
    509535        d = (fat_dentry_t *)b->data;
    510536        if (fat_classify_dentry(d) == FAT_DENTRY_LAST ||
     
    530556        }
    531557        b->dirty = true;                /* need to sync block */
    532         rc = block_put(b);
    533         assert(rc == EOK);
     558        /*
     559         * Ignore the return value as we would have fallen through on error
     560         * anyway.
     561         */
     562        (void) block_put(b);
     563skip_dots:
    534564
    535565        childp->idx->pfc = parentp->firstc;
     
    576606            (childp->idx->pdi * sizeof(fat_dentry_t)) / bps,
    577607            BLOCK_FLAGS_NONE);
    578         assert(rc == EOK);
     608        if (rc != EOK)
     609                goto error;
    579610        d = (fat_dentry_t *)b->data +
    580611            (childp->idx->pdi % (bps / sizeof(fat_dentry_t)));
     
    583614        b->dirty = true;                /* need to sync block */
    584615        rc = block_put(b);
    585         assert(rc == EOK);
     616        if (rc != EOK)
     617                goto error;
    586618
    587619        /* remove the index structure from the position hash */
     
    597629
    598630        return EOK;
     631
     632error:
     633        fibril_mutex_unlock(&parentp->idx->lock);
     634        fibril_mutex_unlock(&childp->lock);
     635        fibril_mutex_unlock(&childp->idx->lock);
     636        return rc;
    599637}
    600638
Note: See TracChangeset for help on using the changeset viewer.