Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/libblock/libblock.c

    ra830611 r402a18f  
    5050#include <adt/list.h>
    5151#include <adt/hash_table.h>
    52 #include <macros.h>
    5352#include <mem.h>
    5453
    … …  
    6362typedef struct {
    6463        fibril_mutex_t lock;
    65         size_t lblock_size;             /**< Logical block size. */
     64        size_t block_size;              /**< Block size. */
    6665        unsigned block_count;           /**< Total number of blocks. */
    6766        unsigned blocks_cached;         /**< Number of cached blocks. */
    … …  
    7574        dev_handle_t dev_handle;
    7675        int dev_phone;
    77         fibril_mutex_t comm_area_lock;
    78         void *comm_area;
    79         size_t comm_size;
     76        fibril_mutex_t com_area_lock;
     77        void *com_area;
     78        size_t com_size;
    8079        void *bb_buf;
    81         bn_t bb_addr;
    82         size_t pblock_size;             /**< Physical block size. */
     80        off_t bb_off;
     81        size_t bb_size;
    8382        cache_t *cache;
    8483} devcon_t;
    8584
    86 static int read_blocks(devcon_t *devcon, bn_t ba, size_t cnt);
    87 static int write_blocks(devcon_t *devcon, bn_t ba, size_t cnt);
    88 static size_t get_block_size(int dev_phone, size_t *bsize);
     85static int read_block(devcon_t *devcon, bn_t boff, size_t block_size);
     86static int write_block(devcon_t *devcon, bn_t boff, size_t block_size);
    8987
    9088static devcon_t *devcon_search(dev_handle_t dev_handle)
    … …  
    104102}
    105103
    106 static int devcon_add(dev_handle_t dev_handle, int dev_phone, size_t bsize,
    107     void *comm_area, size_t comm_size)
     104static int devcon_add(dev_handle_t dev_handle, int dev_phone, void *com_area,
     105   size_t com_size)
    108106{
    109107        link_t *cur;
    110108        devcon_t *devcon;
    111 
    112         if (comm_size < bsize)
    113                 return EINVAL;
    114109
    115110        devcon = malloc(sizeof(devcon_t));
    … …  
    120115        devcon->dev_handle = dev_handle;
    121116        devcon->dev_phone = dev_phone;
    122         fibril_mutex_initialize(&devcon->comm_area_lock);
    123         devcon->comm_area = comm_area;
    124         devcon->comm_size = comm_size;
     117        fibril_mutex_initialize(&devcon->com_area_lock);
     118        devcon->com_area = com_area;
     119        devcon->com_size = com_size;
    125120        devcon->bb_buf = NULL;
    126         devcon->bb_addr = 0;
    127         devcon->pblock_size = bsize;
     121        devcon->bb_off = 0;
     122        devcon->bb_size = 0;
    128123        devcon->cache = NULL;
    129124
    … …  
    149144}
    150145
    151 int block_init(dev_handle_t dev_handle, size_t comm_size)
     146int block_init(dev_handle_t dev_handle, size_t com_size)
    152147{
    153148        int rc;
    154149        int dev_phone;
    155         void *comm_area;
    156         size_t bsize;
    157 
    158         comm_area = mmap(NULL, comm_size, PROTO_READ | PROTO_WRITE,
     150        void *com_area;
     151       
     152        com_area = mmap(NULL, com_size, PROTO_READ | PROTO_WRITE,
    159153            MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
    160         if (!comm_area) {
     154        if (!com_area) {
    161155                return ENOMEM;
    162156        }
    … …  
    164158        dev_phone = devmap_device_connect(dev_handle, IPC_FLAG_BLOCKING);
    165159        if (dev_phone < 0) {
    166                 munmap(comm_area, comm_size);
     160                munmap(com_area, com_size);
    167161                return dev_phone;
    168162        }
    169163
    170         rc = ipc_share_out_start(dev_phone, comm_area,
     164        rc = ipc_share_out_start(dev_phone, com_area,
    171165            AS_AREA_READ | AS_AREA_WRITE);
    172166        if (rc != EOK) {
    173                 munmap(comm_area, comm_size);
     167                munmap(com_area, com_size);
    174168                ipc_hangup(dev_phone);
    175169                return rc;
    176170        }
    177 
    178         if (get_block_size(dev_phone, &bsize) != EOK) {
    179                 munmap(comm_area, comm_size);
    180                 ipc_hangup(dev_phone);
    181                 return rc;
    182         }
    183        
    184         rc = devcon_add(dev_handle, dev_phone, bsize, comm_area, comm_size);
     171       
     172        rc = devcon_add(dev_handle, dev_phone, com_area, com_size);
    185173        if (rc != EOK) {
    186                 munmap(comm_area, comm_size);
     174                munmap(com_area, com_size);
    187175                ipc_hangup(dev_phone);
    188176                return rc;
    … …  
    207195        }
    208196
    209         munmap(devcon->comm_area, devcon->comm_size);
     197        munmap(devcon->com_area, devcon->com_size);
    210198        ipc_hangup(devcon->dev_phone);
    211199
    … …  
    213201}
    214202
    215 int block_bb_read(dev_handle_t dev_handle, bn_t ba)
     203int block_bb_read(dev_handle_t dev_handle, off_t off, size_t size)
    216204{
    217205        void *bb_buf;
    … …  
    223211        if (devcon->bb_buf)
    224212                return EEXIST;
    225         bb_buf = malloc(devcon->pblock_size);
     213        bb_buf = malloc(size);
    226214        if (!bb_buf)
    227215                return ENOMEM;
    228 
    229         fibril_mutex_lock(&devcon->comm_area_lock);
    230         rc = read_blocks(devcon, 0, 1);
     216       
     217        fibril_mutex_lock(&devcon->com_area_lock);
     218        rc = read_block(devcon, 0, size);
    231219        if (rc != EOK) {
    232                 fibril_mutex_unlock(&devcon->comm_area_lock);
     220                fibril_mutex_unlock(&devcon->com_area_lock);
    233221                free(bb_buf);
    234222                return rc;
    235223        }
    236         memcpy(bb_buf, devcon->comm_area, devcon->pblock_size);
    237         fibril_mutex_unlock(&devcon->comm_area_lock);
     224        memcpy(bb_buf, devcon->com_area, size);
     225        fibril_mutex_unlock(&devcon->com_area_lock);
    238226
    239227        devcon->bb_buf = bb_buf;
    240         devcon->bb_addr = ba;
     228        devcon->bb_off = off;
     229        devcon->bb_size = size;
    241230
    242231        return EOK;
    … …  
    286275        fibril_mutex_initialize(&cache->lock);
    287276        list_initialize(&cache->free_head);
    288         cache->lblock_size = size;
     277        cache->block_size = size;
    289278        cache->block_count = blocks;
    290279        cache->blocks_cached = 0;
    291280        cache->mode = mode;
    292 
    293         /* No block size translation a.t.m. */
    294         assert(cache->lblock_size == devcon->pblock_size);
    295281
    296282        if (!hash_table_create(&cache->block_hash, CACHE_BUCKETS, 1,
    … …  
    382368                        if (!b)
    383369                                goto recycle;
    384                         b->data = malloc(cache->lblock_size);
     370                        b->data = malloc(cache->block_size);
    385371                        if (!b->data) {
    386372                                free(b);
    … …  
    412398                                list_append(&b->free_link, &cache->free_head);
    413399                                fibril_mutex_unlock(&cache->lock);
    414                                 fibril_mutex_lock(&devcon->comm_area_lock);
    415                                 memcpy(devcon->comm_area, b->data, b->size);
    416                                 rc = write_blocks(devcon, b->boff, 1);
    417                                 fibril_mutex_unlock(&devcon->comm_area_lock);
     400                                fibril_mutex_lock(&devcon->com_area_lock);
     401                                memcpy(devcon->com_area, b->data, b->size);
     402                                rc = write_block(devcon, b->boff,
     403                                    cache->block_size);
     404                                fibril_mutex_unlock(&devcon->com_area_lock);
    418405                                if (rc != EOK) {
    419406                                        /*
    … …  
    450437                block_initialize(b);
    451438                b->dev_handle = dev_handle;
    452                 b->size = cache->lblock_size;
     439                b->size = cache->block_size;
    453440                b->boff = boff;
    454441                hash_table_insert(&cache->block_hash, &key, &b->hash_link);
    … …  
    467454                         * the new contents from the device.
    468455                         */
    469                         fibril_mutex_lock(&devcon->comm_area_lock);
    470                         rc = read_blocks(devcon, b->boff, 1);
    471                         memcpy(b->data, devcon->comm_area, cache->lblock_size);
    472                         fibril_mutex_unlock(&devcon->comm_area_lock);
     456                        fibril_mutex_lock(&devcon->com_area_lock);
     457                        rc = read_block(devcon, b->boff, cache->block_size);
     458                        memcpy(b->data, devcon->com_area, cache->block_size);
     459                        fibril_mutex_unlock(&devcon->com_area_lock);
    473460                        if (rc != EOK)
    474461                                b->toxic = true;
    … …  
    521508        if (block->dirty && (block->refcnt == 1) &&
    522509            (blocks_cached > CACHE_HI_WATERMARK || mode != CACHE_MODE_WB)) {
    523                 fibril_mutex_lock(&devcon->comm_area_lock);
    524                 memcpy(devcon->comm_area, block->data, block->size);
    525                 rc = write_blocks(devcon, block->boff, 1);
    526                 fibril_mutex_unlock(&devcon->comm_area_lock);
     510                fibril_mutex_lock(&devcon->com_area_lock);
     511                memcpy(devcon->com_area, block->data, block->size);
     512                rc = write_block(devcon, block->boff, block->size);
     513                fibril_mutex_unlock(&devcon->com_area_lock);
    527514                block->dirty = false;
    528515        }
    … …  
    601588 */
    602589int block_seqread(dev_handle_t dev_handle, off_t *bufpos, size_t *buflen,
    603     off_t *pos, void *dst, size_t size)
     590    off_t *pos, void *dst, size_t size, size_t block_size)
    604591{
    605592        off_t offset = 0;
    606593        size_t left = size;
    607         size_t block_size;
    608         devcon_t *devcon;
    609 
    610         devcon = devcon_search(dev_handle);
     594        devcon_t *devcon = devcon_search(dev_handle);
    611595        assert(devcon);
    612         block_size = devcon->pblock_size;
    613        
    614         fibril_mutex_lock(&devcon->comm_area_lock);
     596       
     597        fibril_mutex_lock(&devcon->com_area_lock);
    615598        while (left > 0) {
    616599                size_t rd;
    … …  
    626609                         * destination buffer.
    627610                         */
    628                         memcpy(dst + offset, devcon->comm_area + *bufpos, rd);
     611                        memcpy(dst + offset, devcon->com_area + *bufpos, rd);
    629612                        offset += rd;
    630613                        *bufpos += rd;
    … …  
    637620                        int rc;
    638621
    639                         rc = read_blocks(devcon, *pos / block_size, 1);
     622                        rc = read_block(devcon, *pos / block_size, block_size);
    640623                        if (rc != EOK) {
    641                                 fibril_mutex_unlock(&devcon->comm_area_lock);
     624                                fibril_mutex_unlock(&devcon->com_area_lock);
    642625                                return rc;
    643626                        }
    … …  
    647630                }
    648631        }
    649         fibril_mutex_unlock(&devcon->comm_area_lock);
     632        fibril_mutex_unlock(&devcon->com_area_lock);
    650633       
    651634        return EOK;
    652635}
    653636
    654 /** Read blocks from block device.
     637/** Read block from block device.
    655638 *
    656639 * @param devcon        Device connection.
    657  * @param ba            Address of first block.
    658  * @param cnt           Number of blocks.
     640 * @param boff          Block index.
     641 * @param block_size    Block size.
    659642 * @param src           Buffer for storing the data.
    660643 *
    661644 * @return              EOK on success or negative error code on failure.
    662645 */
    663 static int read_blocks(devcon_t *devcon, bn_t ba, size_t cnt)
    664 {
     646static int read_block(devcon_t *devcon, bn_t boff, size_t block_size)
     647{
     648        ipcarg_t retval;
    665649        int rc;
    666650
    667651        assert(devcon);
    668         rc = async_req_3_0(devcon->dev_phone, BD_READ_BLOCKS, LOWER32(ba),
    669             UPPER32(ba), cnt);
    670         return rc;
     652        rc = async_req_2_1(devcon->dev_phone, BD_READ_BLOCK, boff, block_size,
     653            &retval);
     654        if ((rc != EOK) || (retval != EOK))
     655                return (rc != EOK ? rc : (int) retval);
     656
     657        return EOK;
    671658}
    672659
    … …  
    674661 *
    675662 * @param devcon        Device connection.
    676  * @param ba            Address of first block.
    677  * @param cnt           Number of blocks.
     663 * @param boff          Block index.
     664 * @param block_size    Block size.
    678665 * @param src           Buffer containing the data to write.
    679666 *
    680667 * @return              EOK on success or negative error code on failure.
    681668 */
    682 static int write_blocks(devcon_t *devcon, bn_t ba, size_t cnt)
    683 {
     669static int write_block(devcon_t *devcon, bn_t boff, size_t block_size)
     670{
     671        ipcarg_t retval;
    684672        int rc;
    685673
    686674        assert(devcon);
    687         rc = async_req_3_0(devcon->dev_phone, BD_WRITE_BLOCKS, LOWER32(ba),
    688             UPPER32(ba), cnt);
    689         return rc;
    690 }
    691 
    692 /** Get block size used by the device. */
    693 static size_t get_block_size(int dev_phone, size_t *bsize)
    694 {
    695         ipcarg_t bs;
    696         int rc;
    697 
    698         rc = async_req_0_1(dev_phone, BD_GET_BLOCK_SIZE, &bs);
    699         if (rc == EOK)
    700                 *bsize = (size_t) bs;
    701 
    702         return rc;
     675        rc = async_req_2_1(devcon->dev_phone, BD_WRITE_BLOCK, boff, block_size,
     676            &retval);
     677        if ((rc != EOK) || (retval != EOK))
     678                return (rc != EOK ? rc : (int) retval);
     679
     680        return EOK;
    703681}
    704682
Note: See TracChangeset for help on using the changeset viewer.