Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/block/block.c

    rc1f26834 r2463df9  
    5555#include "block.h"
    5656
    57 #define MAX_WRITE_RETRIES 10
    58 
    5957/** Lock protecting the device connection list */
    6058static FIBRIL_MUTEX_INITIALIZE(dcl_lock);
     
    8179        void *bb_buf;
    8280        aoff64_t bb_addr;
    83         aoff64_t pblocks;    /**< Number of physical blocks */
    8481        size_t pblock_size;  /**< Physical block size. */
    8582        cache_t *cache;
     
    106103
    107104static int devcon_add(service_id_t service_id, async_sess_t *sess,
    108     size_t bsize, aoff64_t dev_size, bd_t *bd)
     105    size_t bsize, bd_t *bd)
    109106{
    110107        devcon_t *devcon;
     
    121118        devcon->bb_addr = 0;
    122119        devcon->pblock_size = bsize;
    123         devcon->pblocks = dev_size;
    124120        devcon->cache = NULL;
    125121       
     
    168164                return rc;
    169165        }
    170 
    171         aoff64_t dev_size;
    172         rc = bd_get_num_blocks(bd, &dev_size);
    173         if (rc != EOK) {
    174                 bd_close(bd);
    175                 async_hangup(sess);
    176                 return rc;
    177         }
    178        
    179         rc = devcon_add(service_id, sess, bsize, dev_size, bd);
     166       
     167        rc = devcon_add(service_id, sess, bsize, bd);
    180168        if (rc != EOK) {
    181169                bd_close(bd);
     
    361349        fibril_mutex_initialize(&b->lock);
    362350        b->refcnt = 1;
    363         b->write_failures = 0;
    364351        b->dirty = false;
    365352        b->toxic = false;
     
    386373        block_t *b;
    387374        link_t *link;
    388         aoff64_t p_ba;
     375
    389376        int rc;
    390377       
     
    395382       
    396383        cache = devcon->cache;
    397 
    398         /* Check whether the logical block (or part of it) is beyond
    399          * the end of the device or not.
    400          */
    401         p_ba = ba_ltop(devcon, ba);
    402         p_ba += cache->blocks_cluster;
    403         if (p_ba >= devcon->pblocks) {
    404                 /* This request cannot be satisfied */
    405                 return EIO;
    406         }
    407 
    408384
    409385retry:
     
    482458                                         * another block next time.
    483459                                         */
    484                                         if (b->write_failures < MAX_WRITE_RETRIES) {
    485                                                 b->write_failures++;
    486                                                 fibril_mutex_unlock(&b->lock);
    487                                                 goto retry;
    488                                         } else {
    489                                                 printf("Too many errors writing block %"
    490                                                     PRIuOFF64 "from device handle %" PRIun "\n"
    491                                                     "SEVERE DATA LOSS POSSIBLE\n",
    492                                                     b->lba, devcon->service_id);
    493                                         }
    494                                 } else
    495                                         b->write_failures = 0;
    496 
     460                                        fibril_mutex_unlock(&b->lock);
     461                                        goto retry;
     462                                }
    497463                                b->dirty = false;
    498464                                if (!fibril_mutex_trylock(&cache->lock)) {
     
    611577                rc = write_blocks(devcon, block->pba, cache->blocks_cluster,
    612578                    block->data, block->size);
    613                 if (rc == EOK)
    614                         block->write_failures = 0;
    615579                block->dirty = false;
    616580        }
     
    638602                                 */
    639603                                block->refcnt++;
    640 
    641                                 if (block->write_failures < MAX_WRITE_RETRIES) {
    642                                         block->write_failures++;
    643                                         fibril_mutex_unlock(&block->lock);
    644                                         fibril_mutex_unlock(&cache->lock);
    645                                         goto retry;
    646                                 } else {
    647                                         printf("Too many errors writing block %"
    648                                             PRIuOFF64 "from device handle %" PRIun "\n"
    649                                             "SEVERE DATA LOSS POSSIBLE\n",
    650                                             block->lba, devcon->service_id);
    651                                 }
     604                                fibril_mutex_unlock(&block->lock);
     605                                fibril_mutex_unlock(&cache->lock);
     606                                goto retry;
    652607                        }
    653608                        /*
     
    815770        devcon_t *devcon = devcon_search(service_id);
    816771        assert(devcon);
    817 
     772       
    818773        return bd_get_num_blocks(devcon->bd, nblocks);
    819774}
Note: See TracChangeset for help on using the changeset viewer.