Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/block/libblock.c

    r08cba4b rc7bbf029  
    22 * Copyright (c) 2008 Jakub Jermar
    33 * Copyright (c) 2008 Martin Decky
    4  * Copyright (c) 2011 Martin Sucha
    54 * All rights reserved.
    65 *
    … …  
    3938#include "libblock.h"
    4039#include "../../srv/vfs/vfs.h"
    41 #include <ipc/loc.h>
     40#include <ipc/devmap.h>
    4241#include <ipc/bd.h>
    4342#include <ipc/services.h>
    … …  
    6059static FIBRIL_MUTEX_INITIALIZE(dcl_lock);
    6160/** Device connection list head. */
    62 static LIST_INITIALIZE(dcl);
    63 
    64 #define CACHE_BUCKETS_LOG2  10
    65 #define CACHE_BUCKETS       (1 << CACHE_BUCKETS_LOG2)
     61static LIST_INITIALIZE(dcl_head);
     62
     63#define CACHE_BUCKETS_LOG2              10
     64#define CACHE_BUCKETS                   (1 << CACHE_BUCKETS_LOG2)
    6665
    6766typedef struct {
    6867        fibril_mutex_t lock;
    69         size_t lblock_size;       /**< Logical block size. */
    70         unsigned blocks_cluster;  /**< Physical blocks per block_t */
    71         unsigned block_count;     /**< Total number of blocks. */
    72         unsigned blocks_cached;   /**< Number of cached blocks. */
     68        size_t lblock_size;             /**< Logical block size. */
     69        unsigned blocks_cluster;        /**< Physical blocks per block_t */
     70        unsigned block_count;           /**< Total number of blocks. */
     71        unsigned blocks_cached;         /**< Number of cached blocks. */
    7372        hash_table_t block_hash;
    74         list_t free_list;
     73        link_t free_head;
    7574        enum cache_mode mode;
    7675} cache_t;
    … …  
    7877typedef struct {
    7978        link_t link;
    80         service_id_t service_id;
    81         async_sess_t *sess;
     79        devmap_handle_t devmap_handle;
     80        int dev_phone;
    8281        fibril_mutex_t comm_area_lock;
    8382        void *comm_area;
    … …  
    8584        void *bb_buf;
    8685        aoff64_t bb_addr;
    87         size_t pblock_size;  /**< Physical block size. */
     86        size_t pblock_size;             /**< Physical block size. */
    8887        cache_t *cache;
    8988} devcon_t;
    9089
    91 static int read_blocks(devcon_t *, aoff64_t, size_t);
    92 static int write_blocks(devcon_t *, aoff64_t, size_t);
    93 static int get_block_size(async_sess_t *, size_t *);
    94 static int get_num_blocks(async_sess_t *, aoff64_t *);
    95 static aoff64_t ba_ltop(devcon_t *, aoff64_t);
    96 
    97 static devcon_t *devcon_search(service_id_t service_id)
    98 {
     90static int read_blocks(devcon_t *devcon, aoff64_t ba, size_t cnt);
     91static int write_blocks(devcon_t *devcon, aoff64_t ba, size_t cnt);
     92static int get_block_size(int dev_phone, size_t *bsize);
     93static int get_num_blocks(int dev_phone, aoff64_t *nblocks);
     94static aoff64_t ba_ltop(devcon_t *devcon, aoff64_t lba);
     95
     96static devcon_t *devcon_search(devmap_handle_t devmap_handle)
     97{
     98        link_t *cur;
     99
    99100        fibril_mutex_lock(&dcl_lock);
    100        
    101         list_foreach(dcl, cur) {
     101        for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) {
    102102                devcon_t *devcon = list_get_instance(cur, devcon_t, link);
    103                 if (devcon->service_id == service_id) {
     103                if (devcon->devmap_handle == devmap_handle) {
    104104                        fibril_mutex_unlock(&dcl_lock);
    105105                        return devcon;
    106106                }
    107107        }
    108        
    109108        fibril_mutex_unlock(&dcl_lock);
    110109        return NULL;
    111110}
    112111
    113 static int devcon_add(service_id_t service_id, async_sess_t *sess,
    114     size_t bsize, void *comm_area, size_t comm_size)
    115 {
     112static int devcon_add(devmap_handle_t devmap_handle, int dev_phone, size_t bsize,
     113    void *comm_area, size_t comm_size)
     114{
     115        link_t *cur;
    116116        devcon_t *devcon;
    117        
     117
    118118        if (comm_size < bsize)
    119119                return EINVAL;
    120        
     120
    121121        devcon = malloc(sizeof(devcon_t));
    122122        if (!devcon)
    … …  
    124124       
    125125        link_initialize(&devcon->link);
    126         devcon->service_id = service_id;
    127         devcon->sess = sess;
     126        devcon->devmap_handle = devmap_handle;
     127        devcon->dev_phone = dev_phone;
    128128        fibril_mutex_initialize(&devcon->comm_area_lock);
    129129        devcon->comm_area = comm_area;
    … …  
    133133        devcon->pblock_size = bsize;
    134134        devcon->cache = NULL;
    135        
     135
    136136        fibril_mutex_lock(&dcl_lock);
    137         list_foreach(dcl, cur) {
     137        for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) {
    138138                devcon_t *d = list_get_instance(cur, devcon_t, link);
    139                 if (d->service_id == service_id) {
     139                if (d->devmap_handle == devmap_handle) {
    140140                        fibril_mutex_unlock(&dcl_lock);
    141141                        free(devcon);
    … …  
    143143                }
    144144        }
    145         list_append(&devcon->link, &dcl);
     145        list_append(&devcon->link, &dcl_head);
    146146        fibril_mutex_unlock(&dcl_lock);
    147147        return EOK;
    … …  
    155155}
    156156
    157 int block_init(exch_mgmt_t mgmt, service_id_t service_id,
    158     size_t comm_size)
    159 {
    160         void *comm_area = mmap(NULL, comm_size, PROTO_READ | PROTO_WRITE,
     157int block_init(devmap_handle_t devmap_handle, size_t comm_size)
     158{
     159        int rc;
     160        int dev_phone;
     161        void *comm_area;
     162        size_t bsize;
     163
     164        comm_area = mmap(NULL, comm_size, PROTO_READ | PROTO_WRITE,
    161165            MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
    162         if (!comm_area)
     166        if (!comm_area) {
    163167                return ENOMEM;
    164        
    165         async_sess_t *sess = loc_service_connect(mgmt, service_id,
    166             IPC_FLAG_BLOCKING);
    167         if (!sess) {
     168        }
     169
     170        dev_phone = devmap_device_connect(devmap_handle, IPC_FLAG_BLOCKING);
     171        if (dev_phone < 0) {
    168172                munmap(comm_area, comm_size);
    169                 return ENOENT;
    170         }
    171        
    172         async_exch_t *exch = async_exchange_begin(sess);
    173         int rc = async_share_out_start(exch, comm_area,
     173                return dev_phone;
     174        }
     175
     176        rc = async_share_out_start(dev_phone, comm_area,
    174177            AS_AREA_READ | AS_AREA_WRITE);
    175         async_exchange_end(exch);
    176        
     178        if (rc != EOK) {
     179                munmap(comm_area, comm_size);
     180                async_hangup(dev_phone);
     181                return rc;
     182        }
     183
     184        if (get_block_size(dev_phone, &bsize) != EOK) {
     185                munmap(comm_area, comm_size);
     186                async_hangup(dev_phone);
     187                return rc;
     188        }
     189       
     190        rc = devcon_add(devmap_handle, dev_phone, bsize, comm_area, comm_size);
    177191        if (rc != EOK) {
    178192                munmap(comm_area, comm_size);
    179                 async_hangup(sess);
     193                async_hangup(dev_phone);
    180194                return rc;
    181195        }
    182        
    183         size_t bsize;
    184         rc = get_block_size(sess, &bsize);
    185        
    186         if (rc != EOK) {
    187                 munmap(comm_area, comm_size);
    188                 async_hangup(sess);
    189                 return rc;
    190         }
    191        
    192         rc = devcon_add(service_id, sess, bsize, comm_area, comm_size);
    193         if (rc != EOK) {
    194                 munmap(comm_area, comm_size);
    195                 async_hangup(sess);
    196                 return rc;
    197         }
    198        
     196
    199197        return EOK;
    200198}
    201199
    202 void block_fini(service_id_t service_id)
    203 {
    204         devcon_t *devcon = devcon_search(service_id);
     200void block_fini(devmap_handle_t devmap_handle)
     201{
     202        devcon_t *devcon = devcon_search(devmap_handle);
    205203        assert(devcon);
    206204       
    207205        if (devcon->cache)
    208                 (void) block_cache_fini(service_id);
    209        
     206                (void) block_cache_fini(devmap_handle);
     207
    210208        devcon_remove(devcon);
    211        
     209
    212210        if (devcon->bb_buf)
    213211                free(devcon->bb_buf);
    214        
     212
    215213        munmap(devcon->comm_area, devcon->comm_size);
    216         async_hangup(devcon->sess);
    217        
    218         free(devcon);
    219 }
    220 
    221 int block_bb_read(service_id_t service_id, aoff64_t ba)
     214        async_hangup(devcon->dev_phone);
     215
     216        free(devcon);   
     217}
     218
     219int block_bb_read(devmap_handle_t devmap_handle, aoff64_t ba)
    222220{
    223221        void *bb_buf;
    224222        int rc;
    225223
    226         devcon_t *devcon = devcon_search(service_id);
     224        devcon_t *devcon = devcon_search(devmap_handle);
    227225        if (!devcon)
    228226                return ENOENT;
    … …  
    249247}
    250248
    251 void *block_bb_get(service_id_t service_id)
    252 {
    253         devcon_t *devcon = devcon_search(service_id);
     249void *block_bb_get(devmap_handle_t devmap_handle)
     250{
     251        devcon_t *devcon = devcon_search(devmap_handle);
    254252        assert(devcon);
    255253        return devcon->bb_buf;
    … …  
    258256static hash_index_t cache_hash(unsigned long *key)
    259257{
    260         return MERGE_LOUP32(key[0], key[1]) & (CACHE_BUCKETS - 1);
     258        return *key & (CACHE_BUCKETS - 1);
    261259}
    262260
    … …  
    264262{
    265263        block_t *b = hash_table_get_instance(item, block_t, hash_link);
    266         return b->lba == MERGE_LOUP32(key[0], key[1]);
     264        return b->lba == *key;
    267265}
    268266
    … …  
    277275};
    278276
    279 int block_cache_init(service_id_t service_id, size_t size, unsigned blocks,
     277int block_cache_init(devmap_handle_t devmap_handle, size_t size, unsigned blocks,
    280278    enum cache_mode mode)
    281279{
    282         devcon_t *devcon = devcon_search(service_id);
     280        devcon_t *devcon = devcon_search(devmap_handle);
    283281        cache_t *cache;
    284282        if (!devcon)
    … …  
    291289       
    292290        fibril_mutex_initialize(&cache->lock);
    293         list_initialize(&cache->free_list);
     291        list_initialize(&cache->free_head);
    294292        cache->lblock_size = size;
    295293        cache->block_count = blocks;
    … …  
    305303        cache->blocks_cluster = cache->lblock_size / devcon->pblock_size;
    306304
    307         if (!hash_table_create(&cache->block_hash, CACHE_BUCKETS, 2,
     305        if (!hash_table_create(&cache->block_hash, CACHE_BUCKETS, 1,
    308306            &cache_ops)) {
    309307                free(cache);
    … …  
    315313}
    316314
    317 int block_cache_fini(service_id_t service_id)
    318 {
    319         devcon_t *devcon = devcon_search(service_id);
     315int block_cache_fini(devmap_handle_t devmap_handle)
     316{
     317        devcon_t *devcon = devcon_search(devmap_handle);
    320318        cache_t *cache;
    321319        int rc;
    … …  
    332330         * bother with the cache and block locks because we are single-threaded.
    333331         */
    334         while (!list_empty(&cache->free_list)) {
    335                 block_t *b = list_get_instance(list_first(&cache->free_list),
     332        while (!list_empty(&cache->free_head)) {
     333                block_t *b = list_get_instance(cache->free_head.next,
    336334                    block_t, free_link);
    337335
    … …  
    344342                }
    345343
    346                 unsigned long key[2] = {
    347                         LOWER32(b->lba),
    348                         UPPER32(b->lba)
    349                 };
    350                 hash_table_remove(&cache->block_hash, key, 2);
     344                unsigned long key = b->lba;
     345                hash_table_remove(&cache->block_hash, &key, 1);
    351346               
    352347                free(b->data);
    … …  
    367362        if (cache->blocks_cached < CACHE_LO_WATERMARK)
    368363                return true;
    369         if (!list_empty(&cache->free_list))
     364        if (!list_empty(&cache->free_head))
    370365                return false;
    371366        return true;
    … …  
    387382 * @param block                 Pointer to where the function will store the
    388383 *                              block pointer on success.
    389  * @param service_id            Service ID of the block device.
     384 * @param devmap_handle         Device handle of the block device.
    390385 * @param ba                    Block address (logical).
    391386 * @param flags                 If BLOCK_FLAGS_NOREAD is specified, block_get()
    … …  
    395390 * @return                      EOK on success or a negative error code.
    396391 */
    397 int block_get(block_t **block, service_id_t service_id, aoff64_t ba, int flags)
     392int block_get(block_t **block, devmap_handle_t devmap_handle, aoff64_t ba, int flags)
    398393{
    399394        devcon_t *devcon;
    … …  
    401396        block_t *b;
    402397        link_t *l;
    403         unsigned long key[2] = {
    404                 LOWER32(ba),
    405                 UPPER32(ba)
    406         };
    407 
     398        unsigned long key = ba;
    408399        int rc;
    409400       
    410         devcon = devcon_search(service_id);
     401        devcon = devcon_search(devmap_handle);
    411402
    412403        assert(devcon);
    … …  
    420411
    421412        fibril_mutex_lock(&cache->lock);
    422         l = hash_table_find(&cache->block_hash, key);
     413        l = hash_table_find(&cache->block_hash, &key);
    423414        if (l) {
    424415found:
    … …  
    458449                         * Try to recycle a block from the free list.
    459450                         */
     451                        unsigned long temp_key;
    460452recycle:
    461                         if (list_empty(&cache->free_list)) {
     453                        if (list_empty(&cache->free_head)) {
    462454                                fibril_mutex_unlock(&cache->lock);
    463455                                rc = ENOMEM;
    464456                                goto out;
    465457                        }
    466                         l = list_first(&cache->free_list);
     458                        l = cache->free_head.next;
    467459                        b = list_get_instance(l, block_t, free_link);
    468460
    … …  
    479471                                 */
    480472                                list_remove(&b->free_link);
    481                                 list_append(&b->free_link, &cache->free_list);
     473                                list_append(&b->free_link, &cache->free_head);
    482474                                fibril_mutex_unlock(&cache->lock);
    483475                                fibril_mutex_lock(&devcon->comm_area_lock);
    … …  
    505497                                        goto retry;
    506498                                }
    507                                 l = hash_table_find(&cache->block_hash, key);
     499                                l = hash_table_find(&cache->block_hash, &key);
    508500                                if (l) {
    509501                                        /*
    … …  
    528520                         */
    529521                        list_remove(&b->free_link);
    530                         unsigned long temp_key[2] = {
    531                                 LOWER32(b->lba),
    532                                 UPPER32(b->lba)
    533                         };
    534                         hash_table_remove(&cache->block_hash, temp_key, 2);
     522                        temp_key = b->lba;
     523                        hash_table_remove(&cache->block_hash, &temp_key, 1);
    535524                }
    536525
    537526                block_initialize(b);
    538                 b->service_id = service_id;
     527                b->devmap_handle = devmap_handle;
    539528                b->size = cache->lblock_size;
    540529                b->lba = ba;
    541530                b->pba = ba_ltop(devcon, b->lba);
    542                 hash_table_insert(&cache->block_hash, key, &b->hash_link);
     531                hash_table_insert(&cache->block_hash, &key, &b->hash_link);
    543532
    544533                /*
    … …  
    586575int block_put(block_t *block)
    587576{
    588         devcon_t *devcon = devcon_search(block->service_id);
     577        devcon_t *devcon = devcon_search(block->devmap_handle);
    589578        cache_t *cache;
    590579        unsigned blocks_cached;
    … …  
    652641                         * Take the block out of the cache and free it.
    653642                         */
    654                         unsigned long key[2] = {
    655                                 LOWER32(block->lba),
    656                                 UPPER32(block->lba)
    657                         };
    658                         hash_table_remove(&cache->block_hash, key, 2);
     643                        unsigned long key = block->lba;
     644                        hash_table_remove(&cache->block_hash, &key, 1);
    659645                        fibril_mutex_unlock(&block->lock);
    660646                        free(block->data);
    … …  
    677663                        goto retry;
    678664                }
    679                 list_append(&block->free_link, &cache->free_list);
     665                list_append(&block->free_link, &cache->free_head);
    680666        }
    681667        fibril_mutex_unlock(&block->lock);
    … …  
    687673/** Read sequential data from a block device.
    688674 *
    689  * @param service_id    Service ID of the block device.
     675 * @param devmap_handle Device handle of the block device.
    690676 * @param bufpos        Pointer to the first unread valid offset within the
    691677 *                      communication buffer.
    … …  
    699685 * @return              EOK on success or a negative return code on failure.
    700686 */
    701 int block_seqread(service_id_t service_id, size_t *bufpos, size_t *buflen,
     687int block_seqread(devmap_handle_t devmap_handle, size_t *bufpos, size_t *buflen,
    702688    aoff64_t *pos, void *dst, size_t size)
    703689{
    … …  
    707693        devcon_t *devcon;
    708694
    709         devcon = devcon_search(service_id);
     695        devcon = devcon_search(devmap_handle);
    710696        assert(devcon);
    711697        block_size = devcon->pblock_size;
    … …  
    753739/** Read blocks directly from device (bypass cache).
    754740 *
    755  * @param service_id    Service ID of the block device.
     741 * @param devmap_handle Device handle of the block device.
    756742 * @param ba            Address of first block (physical).
    757743 * @param cnt           Number of blocks.
    … …  
    760746 * @return              EOK on success or negative error code on failure.
    761747 */
    762 int block_read_direct(service_id_t service_id, aoff64_t ba, size_t cnt, void *buf)
     748int block_read_direct(devmap_handle_t devmap_handle, aoff64_t ba, size_t cnt, void *buf)
    763749{
    764750        devcon_t *devcon;
    765751        int rc;
    766752
    767         devcon = devcon_search(service_id);
     753        devcon = devcon_search(devmap_handle);
    768754        assert(devcon);
    769755       
    … …  
    781767/** Write blocks directly to device (bypass cache).
    782768 *
    783  * @param service_id    Service ID of the block device.
     769 * @param devmap_handle Device handle of the block device.
    784770 * @param ba            Address of first block (physical).
    785771 * @param cnt           Number of blocks.
    … …  
    788774 * @return              EOK on success or negative error code on failure.
    789775 */
    790 int block_write_direct(service_id_t service_id, aoff64_t ba, size_t cnt,
     776int block_write_direct(devmap_handle_t devmap_handle, aoff64_t ba, size_t cnt,
    791777    const void *data)
    792778{
    … …  
    794780        int rc;
    795781
    796         devcon = devcon_search(service_id);
     782        devcon = devcon_search(devmap_handle);
    797783        assert(devcon);
    798784       
    … …  
    809795/** Get device block size.
    810796 *
    811  * @param service_id    Service ID of the block device.
     797 * @param devmap_handle Device handle of the block device.
    812798 * @param bsize         Output block size.
    813799 *
    814800 * @return              EOK on success or negative error code on failure.
    815801 */
    816 int block_get_bsize(service_id_t service_id, size_t *bsize)
     802int block_get_bsize(devmap_handle_t devmap_handle, size_t *bsize)
    817803{
    818804        devcon_t *devcon;
    819805
    820         devcon = devcon_search(service_id);
    821         assert(devcon);
    822        
    823         return get_block_size(devcon->sess, bsize);
     806        devcon = devcon_search(devmap_handle);
     807        assert(devcon);
     808       
     809        return get_block_size(devcon->dev_phone, bsize);
    824810}
    825811
    826812/** Get number of blocks on device.
    827813 *
    828  * @param service_id    Service ID of the block device.
     814 * @param devmap_handle Device handle of the block device.
    829815 * @param nblocks       Output number of blocks.
    830816 *
    831817 * @return              EOK on success or negative error code on failure.
    832818 */
    833 int block_get_nblocks(service_id_t service_id, aoff64_t *nblocks)
    834 {
    835         devcon_t *devcon = devcon_search(service_id);
    836         assert(devcon);
    837        
    838         return get_num_blocks(devcon->sess, nblocks);
    839 }
    840 
    841 /** Read bytes directly from the device (bypass cache)
    842  *
    843  * @param service_id    Service ID of the block device.
    844  * @param abs_offset    Absolute offset in bytes where to start reading
    845  * @param bytes                 Number of bytes to read
    846  * @param data                  Buffer that receives the data
    847  *
    848  * @return              EOK on success or negative error code on failure.
    849  */
    850 int block_read_bytes_direct(service_id_t service_id, aoff64_t abs_offset,
    851     size_t bytes, void *data)
    852 {
    853         int rc;
    854         size_t phys_block_size;
    855         size_t buf_size;
    856         void *buffer;
    857         aoff64_t first_block;
    858         aoff64_t last_block;
    859         size_t blocks;
    860         size_t offset;
    861        
    862         rc = block_get_bsize(service_id, &phys_block_size);
    863         if (rc != EOK) {
    864                 return rc;
    865         }
    866        
    867         /* calculate data position and required space */
    868         first_block = abs_offset / phys_block_size;
    869         offset = abs_offset % phys_block_size;
    870         last_block = (abs_offset + bytes - 1) / phys_block_size;
    871         blocks = last_block - first_block + 1;
    872         buf_size = blocks * phys_block_size;
    873        
    874         /* read the data into memory */
    875         buffer = malloc(buf_size);
    876         if (buffer == NULL) {
    877                 return ENOMEM;
    878         }
    879        
    880         rc = block_read_direct(service_id, first_block, blocks, buffer);
    881         if (rc != EOK) {
    882                 free(buffer);
    883                 return rc;
    884         }
    885        
    886         /* copy the data from the buffer */
    887         memcpy(data, buffer + offset, bytes);
    888         free(buffer);
    889        
    890         return EOK;
    891 }
    892 
    893 /** Get TOC from device.
    894  *
    895  * @param service_id Service ID of the block device.
    896  * @param session    Starting session.
    897  *
    898  * @return Allocated TOC structure.
    899  * @return NULL on failure.
    900  *
    901  */
    902 toc_block_t *block_get_toc(service_id_t service_id, uint8_t session)
    903 {
    904         devcon_t *devcon = devcon_search(service_id);
    905         assert(devcon);
    906        
    907         toc_block_t *toc = NULL;
    908        
    909         fibril_mutex_lock(&devcon->comm_area_lock);
    910        
    911         async_exch_t *exch = async_exchange_begin(devcon->sess);
    912         int rc = async_req_1_0(exch, BD_READ_TOC, session);
    913         async_exchange_end(exch);
    914        
    915         if (rc == EOK) {
    916                 toc = (toc_block_t *) malloc(sizeof(toc_block_t));
    917                 if (toc != NULL) {
    918                         memset(toc, 0, sizeof(toc_block_t));
    919                         memcpy(toc, devcon->comm_area,
    920                             min(devcon->pblock_size, sizeof(toc_block_t)));
    921                 }
    922         }
    923        
    924        
    925         fibril_mutex_unlock(&devcon->comm_area_lock);
    926        
    927         return toc;
     819int block_get_nblocks(devmap_handle_t devmap_handle, aoff64_t *nblocks)
     820{
     821        devcon_t *devcon;
     822
     823        devcon = devcon_search(devmap_handle);
     824        assert(devcon);
     825       
     826        return get_num_blocks(devcon->dev_phone, nblocks);
    928827}
    929828
    … …  
    939838static int read_blocks(devcon_t *devcon, aoff64_t ba, size_t cnt)
    940839{
    941         assert(devcon);
    942        
    943         async_exch_t *exch = async_exchange_begin(devcon->sess);
    944         int rc = async_req_3_0(exch, BD_READ_BLOCKS, LOWER32(ba),
     840        int rc;
     841
     842        assert(devcon);
     843        rc = async_req_3_0(devcon->dev_phone, BD_READ_BLOCKS, LOWER32(ba),
    945844            UPPER32(ba), cnt);
    946         async_exchange_end(exch);
    947        
    948845        if (rc != EOK) {
    949846                printf("Error %d reading %zu blocks starting at block %" PRIuOFF64
    950847                    " from device handle %" PRIun "\n", rc, cnt, ba,
    951                     devcon->service_id);
     848                    devcon->devmap_handle);
    952849#ifndef NDEBUG
    953850                stacktrace_print();
    954851#endif
    955852        }
    956        
    957853        return rc;
    958854}
    … …  
    969865static int write_blocks(devcon_t *devcon, aoff64_t ba, size_t cnt)
    970866{
    971         assert(devcon);
    972        
    973         async_exch_t *exch = async_exchange_begin(devcon->sess);
    974         int rc = async_req_3_0(exch, BD_WRITE_BLOCKS, LOWER32(ba),
     867        int rc;
     868
     869        assert(devcon);
     870        rc = async_req_3_0(devcon->dev_phone, BD_WRITE_BLOCKS, LOWER32(ba),
    975871            UPPER32(ba), cnt);
    976         async_exchange_end(exch);
    977        
    978872        if (rc != EOK) {
    979873                printf("Error %d writing %zu blocks starting at block %" PRIuOFF64
    980                     " to device handle %" PRIun "\n", rc, cnt, ba, devcon->service_id);
     874                    " to device handle %" PRIun "\n", rc, cnt, ba, devcon->devmap_handle);
    981875#ifndef NDEBUG
    982876                stacktrace_print();
    983877#endif
    984878        }
    985        
    986879        return rc;
    987880}
    988881
    989882/** Get block size used by the device. */
    990 static int get_block_size(async_sess_t *sess, size_t *bsize)
     883static int get_block_size(int dev_phone, size_t *bsize)
    991884{
    992885        sysarg_t bs;
    993        
    994         async_exch_t *exch = async_exchange_begin(sess);
    995         int rc = async_req_0_1(exch, BD_GET_BLOCK_SIZE, &bs);
    996         async_exchange_end(exch);
    997        
     886        int rc;
     887
     888        rc = async_req_0_1(dev_phone, BD_GET_BLOCK_SIZE, &bs);
    998889        if (rc == EOK)
    999890                *bsize = (size_t) bs;
    1000        
     891
    1001892        return rc;
    1002893}
    1003894
    1004895/** Get total number of blocks on block device. */
    1005 static int get_num_blocks(async_sess_t *sess, aoff64_t *nblocks)
    1006 {
    1007         sysarg_t nb_l;
    1008         sysarg_t nb_h;
    1009        
    1010         async_exch_t *exch = async_exchange_begin(sess);
    1011         int rc = async_req_0_2(exch, BD_GET_NUM_BLOCKS, &nb_l, &nb_h);
    1012         async_exchange_end(exch);
    1013        
    1014         if (rc == EOK)
     896static int get_num_blocks(int dev_phone, aoff64_t *nblocks)
     897{
     898        sysarg_t nb_l, nb_h;
     899        int rc;
     900
     901        rc = async_req_0_2(dev_phone, BD_GET_NUM_BLOCKS, &nb_l, &nb_h);
     902        if (rc == EOK) {
    1015903                *nblocks = (aoff64_t) MERGE_LOUP32(nb_l, nb_h);
    1016        
     904        }
     905
    1017906        return rc;
    1018907}
Note: See TracChangeset for help on using the changeset viewer.