Changeset 79ae36dd in mainline for uspace/lib/block


Ignore:
Timestamp:
2011-06-08T19:01:55Z (14 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
0eff68e
Parents:
764d71e
Message:

new async framework with integrated exchange tracking

  • strict isolation between low-level IPC and high-level async framework with integrated exchange tracking
    • each IPC connection is represented by an async_sess_t structure
    • each IPC exchange is represented by an async_exch_t structure
    • exchange management is either based on atomic messages (EXCHANGE_ATOMIC), locking (EXCHANGE_SERIALIZE) or connection cloning (EXCHANGE_CLONE)
  • async_obsolete: temporary compatibility layer to keep old async clients working (several pieces of code are currently broken, but only non-essential functionality)
  • IPC_M_PHONE_HANGUP is now method no. 0 (for elegant boolean evaluation)
  • IPC_M_DEBUG_ALL has been renamed to IPC_M_DEBUG
  • IPC_M_PING has been removed (VFS protocol now has VFS_IN_PING)
  • console routines in libc have been rewritten for better abstraction
  • additional use for libc-private header files (FILE structure opaque to the client)
  • various cstyle changes (typos, indentation, missing externs in header files, improved comments, etc.)
Location:
uspace/lib/block
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/block/libblock.c

    r764d71e r79ae36dd  
    6262static LIST_INITIALIZE(dcl_head);
    6363
    64 #define CACHE_BUCKETS_LOG2              10
    65 #define CACHE_BUCKETS                   (1 << CACHE_BUCKETS_LOG2)
     64#define CACHE_BUCKETS_LOG2  10
     65#define CACHE_BUCKETS       (1 << CACHE_BUCKETS_LOG2)
    6666
    6767typedef struct {
    6868        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. */
     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. */
    7373        hash_table_t block_hash;
    7474        link_t free_head;
    … …  
    7979        link_t link;
    8080        devmap_handle_t devmap_handle;
    81         int dev_phone;
     81        async_sess_t *sess;
    8282        fibril_mutex_t comm_area_lock;
    8383        void *comm_area;
    … …  
    8585        void *bb_buf;
    8686        aoff64_t bb_addr;
    87         size_t pblock_size;             /**< Physical block size. */
     87        size_t pblock_size;  /**< Physical block size. */
    8888        cache_t *cache;
    8989} devcon_t;
    9090
    91 static int read_blocks(devcon_t *devcon, aoff64_t ba, size_t cnt);
    92 static int write_blocks(devcon_t *devcon, aoff64_t ba, size_t cnt);
    93 static int get_block_size(int dev_phone, size_t *bsize);
    94 static int get_num_blocks(int dev_phone, aoff64_t *nblocks);
    95 static aoff64_t ba_ltop(devcon_t *devcon, aoff64_t lba);
     91static int read_blocks(devcon_t *, aoff64_t, size_t);
     92static int write_blocks(devcon_t *, aoff64_t, size_t);
     93static int get_block_size(async_sess_t *, size_t *);
     94static int get_num_blocks(async_sess_t *, aoff64_t *);
     95static aoff64_t ba_ltop(devcon_t *, aoff64_t);
    9696
    9797static devcon_t *devcon_search(devmap_handle_t devmap_handle)
    9898{
    9999        link_t *cur;
    100 
     100       
    101101        fibril_mutex_lock(&dcl_lock);
     102       
    102103        for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) {
    103104                devcon_t *devcon = list_get_instance(cur, devcon_t, link);
    … …  
    107108                }
    108109        }
     110       
    109111        fibril_mutex_unlock(&dcl_lock);
    110112        return NULL;
    111113}
    112114
    113 static int devcon_add(devmap_handle_t devmap_handle, int dev_phone, size_t bsize,
    114     void *comm_area, size_t comm_size)
     115static int devcon_add(devmap_handle_t devmap_handle, async_sess_t *sess,
     116    size_t bsize, void *comm_area, size_t comm_size)
    115117{
    116118        link_t *cur;
    117119        devcon_t *devcon;
    118 
     120       
    119121        if (comm_size < bsize)
    120122                return EINVAL;
    121 
     123       
    122124        devcon = malloc(sizeof(devcon_t));
    123125        if (!devcon)
    … …  
    126128        link_initialize(&devcon->link);
    127129        devcon->devmap_handle = devmap_handle;
    128         devcon->dev_phone = dev_phone;
     130        devcon->sess = sess;
    129131        fibril_mutex_initialize(&devcon->comm_area_lock);
    130132        devcon->comm_area = comm_area;
    … …  
    134136        devcon->pblock_size = bsize;
    135137        devcon->cache = NULL;
    136 
     138       
    137139        fibril_mutex_lock(&dcl_lock);
    138140        for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) {
    … …  
    156158}
    157159
    158 int block_init(devmap_handle_t devmap_handle, size_t comm_size)
    159 {
    160         int rc;
    161         int dev_phone;
    162         void *comm_area;
    163         size_t bsize;
    164 
    165         comm_area = mmap(NULL, comm_size, PROTO_READ | PROTO_WRITE,
     160int block_init(exch_mgmt_t mgmt, devmap_handle_t devmap_handle,
     161    size_t comm_size)
     162{
     163        void *comm_area = mmap(NULL, comm_size, PROTO_READ | PROTO_WRITE,
    166164            MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
    167         if (!comm_area) {
     165        if (!comm_area)
    168166                return ENOMEM;
    169         }
    170 
    171         dev_phone = devmap_device_connect(devmap_handle, IPC_FLAG_BLOCKING);
    172         if (dev_phone < 0) {
     167       
     168        async_sess_t *sess = devmap_device_connect(mgmt, devmap_handle,
     169            IPC_FLAG_BLOCKING);
     170        if (!sess) {
    173171                munmap(comm_area, comm_size);
    174                 return dev_phone;
    175         }
    176 
    177         rc = async_share_out_start(dev_phone, comm_area,
     172                return ENOENT;
     173        }
     174       
     175        async_exch_t *exch = async_exchange_begin(sess);
     176        int rc = async_share_out_start(exch, comm_area,
    178177            AS_AREA_READ | AS_AREA_WRITE);
    179         if (rc != EOK) {
    180                 munmap(comm_area, comm_size);
    181                 async_hangup(dev_phone);
    182                 return rc;
    183         }
    184 
    185         if (get_block_size(dev_phone, &bsize) != EOK) {
    186                 munmap(comm_area, comm_size);
    187                 async_hangup(dev_phone);
    188                 return rc;
    189         }
    190        
    191         rc = devcon_add(devmap_handle, dev_phone, bsize, comm_area, comm_size);
     178        async_exchange_end(exch);
     179       
    192180        if (rc != EOK) {
    193181                munmap(comm_area, comm_size);
    194                 async_hangup(dev_phone);
     182                async_hangup(sess);
    195183                return rc;
    196184        }
    197 
     185       
     186        size_t bsize;
     187        rc = get_block_size(sess, &bsize);
     188       
     189        if (rc != EOK) {
     190                munmap(comm_area, comm_size);
     191                async_hangup(sess);
     192                return rc;
     193        }
     194       
     195        rc = devcon_add(devmap_handle, sess, bsize, comm_area, comm_size);
     196        if (rc != EOK) {
     197                munmap(comm_area, comm_size);
     198                async_hangup(sess);
     199                return rc;
     200        }
     201       
    198202        return EOK;
    199203}
    … …  
    206210        if (devcon->cache)
    207211                (void) block_cache_fini(devmap_handle);
    208 
     212       
    209213        devcon_remove(devcon);
    210 
     214       
    211215        if (devcon->bb_buf)
    212216                free(devcon->bb_buf);
    213 
     217       
    214218        munmap(devcon->comm_area, devcon->comm_size);
    215         async_hangup(devcon->dev_phone);
    216 
    217         free(devcon);   
     219        async_hangup(devcon->sess);
     220       
     221        free(devcon);
    218222}
    219223
    … …  
    808812        assert(devcon);
    809813       
    810         return get_block_size(devcon->dev_phone, bsize);
     814        return get_block_size(devcon->sess, bsize);
    811815}
    812816
    … …  
    820824int block_get_nblocks(devmap_handle_t devmap_handle, aoff64_t *nblocks)
    821825{
    822         devcon_t *devcon;
    823 
    824         devcon = devcon_search(devmap_handle);
    825         assert(devcon);
    826        
    827         return get_num_blocks(devcon->dev_phone, nblocks);
     826        devcon_t *devcon = devcon_search(devmap_handle);
     827        assert(devcon);
     828       
     829        return get_num_blocks(devcon->sess, nblocks);
    828830}
    829831
    … …  
    891893static int read_blocks(devcon_t *devcon, aoff64_t ba, size_t cnt)
    892894{
    893         int rc;
    894 
    895         assert(devcon);
    896         rc = async_req_3_0(devcon->dev_phone, BD_READ_BLOCKS, LOWER32(ba),
     895        assert(devcon);
     896       
     897        async_exch_t *exch = async_exchange_begin(devcon->sess);
     898        int rc = async_req_3_0(exch, BD_READ_BLOCKS, LOWER32(ba),
    897899            UPPER32(ba), cnt);
     900        async_exchange_end(exch);
     901       
    898902        if (rc != EOK) {
    899903                printf("Error %d reading %zu blocks starting at block %" PRIuOFF64
    … …  
    904908#endif
    905909        }
     910       
    906911        return rc;
    907912}
    … …  
    918923static int write_blocks(devcon_t *devcon, aoff64_t ba, size_t cnt)
    919924{
    920         int rc;
    921 
    922         assert(devcon);
    923         rc = async_req_3_0(devcon->dev_phone, BD_WRITE_BLOCKS, LOWER32(ba),
     925        assert(devcon);
     926       
     927        async_exch_t *exch = async_exchange_begin(devcon->sess);
     928        int rc = async_req_3_0(exch, BD_WRITE_BLOCKS, LOWER32(ba),
    924929            UPPER32(ba), cnt);
     930        async_exchange_end(exch);
     931       
    925932        if (rc != EOK) {
    926933                printf("Error %d writing %zu blocks starting at block %" PRIuOFF64
    … …  
    930937#endif
    931938        }
     939       
    932940        return rc;
    933941}
    934942
    935943/** Get block size used by the device. */
    936 static int get_block_size(int dev_phone, size_t *bsize)
     944static int get_block_size(async_sess_t *sess, size_t *bsize)
    937945{
    938946        sysarg_t bs;
    939         int rc;
    940 
    941         rc = async_req_0_1(dev_phone, BD_GET_BLOCK_SIZE, &bs);
     947       
     948        async_exch_t *exch = async_exchange_begin(sess);
     949        int rc = async_req_0_1(exch, BD_GET_BLOCK_SIZE, &bs);
     950        async_exchange_end(exch);
     951       
    942952        if (rc == EOK)
    943953                *bsize = (size_t) bs;
    944 
     954       
    945955        return rc;
    946956}
    947957
    948958/** Get total number of blocks on block device. */
    949 static int get_num_blocks(int dev_phone, aoff64_t *nblocks)
    950 {
    951         sysarg_t nb_l, nb_h;
    952         int rc;
    953 
    954         rc = async_req_0_2(dev_phone, BD_GET_NUM_BLOCKS, &nb_l, &nb_h);
    955         if (rc == EOK) {
     959static int get_num_blocks(async_sess_t *sess, aoff64_t *nblocks)
     960{
     961        sysarg_t nb_l;
     962        sysarg_t nb_h;
     963       
     964        async_exch_t *exch = async_exchange_begin(sess);
     965        int rc = async_req_0_2(exch, BD_GET_NUM_BLOCKS, &nb_l, &nb_h);
     966        async_exchange_end(exch);
     967       
     968        if (rc == EOK)
    956969                *nblocks = (aoff64_t) MERGE_LOUP32(nb_l, nb_h);
    957         }
    958 
     970       
    959971        return rc;
    960972}

  • uspace/lib/block/libblock.h

    r764d71e r79ae36dd  
    4040
    4141#include <stdint.h>
     42#include <async.h>
    4243#include "../../srv/vfs/vfs.h"
    4344#include <fibril_synch.h>
    … …  
    9697};
    9798
    98 extern int block_init(devmap_handle_t, size_t);
     99extern int block_init(exch_mgmt_t, devmap_handle_t, size_t);
    99100extern void block_fini(devmap_handle_t);
    100101
Note: See TracChangeset for help on using the changeset viewer.