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

Changeset 135486d in mainline for uspace/lib/c/generic/bd_srv.c


Ignore:
Timestamp:
2012-08-15T14:44:59Z (9 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master
Children:
affaf2e, b546231
Parents:
4802dd7
Message:

Allow more than one client connection to block device.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/c/generic/bd_srv.c

    r4802dd7 r135486d  
    6767        }
    6868
    69         if (srv->ops->read_blocks == NULL) {
     69        if (srv->srvs->ops->read_blocks == NULL) {
    7070                async_answer_0(rcallid, ENOTSUP);
    7171                async_answer_0(callid, ENOTSUP);
     
    7373        }
    7474
    75         rc = srv->ops->read_blocks(srv, ba, cnt, buf, size);
     75        rc = srv->srvs->ops->read_blocks(srv, ba, cnt, buf, size);
    7676        if (rc != EOK) {
    7777                async_answer_0(rcallid, ENOMEM);
     
    109109        }
    110110
    111         if (srv->ops->read_toc == NULL) {
     111        if (srv->srvs->ops->read_toc == NULL) {
    112112                async_answer_0(rcallid, ENOTSUP);
    113113                async_answer_0(callid, ENOTSUP);
     
    115115        }
    116116
    117         rc = srv->ops->read_toc(srv, session, buf, size);
     117        rc = srv->srvs->ops->read_toc(srv, session, buf, size);
    118118        if (rc != EOK) {
    119119                async_answer_0(rcallid, ENOMEM);
     
    146146        }
    147147
    148         if (srv->ops->write_blocks == NULL) {
    149                 async_answer_0(callid, ENOTSUP);
    150                 return;
    151         }
    152 
    153         rc = srv->ops->write_blocks(srv, ba, cnt, data, size);
     148        if (srv->srvs->ops->write_blocks == NULL) {
     149                async_answer_0(callid, ENOTSUP);
     150                return;
     151        }
     152
     153        rc = srv->srvs->ops->write_blocks(srv, ba, cnt, data, size);
    154154        free(data);
    155155        async_answer_0(callid, rc);
     
    162162        size_t block_size;
    163163
    164         if (srv->ops->get_block_size == NULL) {
    165                 async_answer_0(callid, ENOTSUP);
    166                 return;
    167         }
    168 
    169         rc = srv->ops->get_block_size(srv, &block_size);
     164        if (srv->srvs->ops->get_block_size == NULL) {
     165                async_answer_0(callid, ENOTSUP);
     166                return;
     167        }
     168
     169        rc = srv->srvs->ops->get_block_size(srv, &block_size);
    170170        async_answer_1(callid, rc, block_size);
    171171}
     
    177177        aoff64_t num_blocks;
    178178
    179         if (srv->ops->get_num_blocks == NULL) {
    180                 async_answer_0(callid, ENOTSUP);
    181                 return;
    182         }
    183 
    184         rc = srv->ops->get_num_blocks(srv, &num_blocks);
     179        if (srv->srvs->ops->get_num_blocks == NULL) {
     180                async_answer_0(callid, ENOTSUP);
     181                return;
     182        }
     183
     184        rc = srv->srvs->ops->get_num_blocks(srv, &num_blocks);
    185185        async_answer_2(callid, rc, LOWER32(num_blocks), UPPER32(num_blocks));
    186186}
    187187
    188 void bd_srv_init(bd_srv_t *srv)
    189 {
    190         fibril_mutex_initialize(&srv->lock);
    191         srv->connected = false;
    192         srv->ops = NULL;
    193         srv->arg = NULL;
    194         srv->client_sess = NULL;
    195 }
    196 
    197 int bd_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    198 {
    199         bd_srv_t *srv = (bd_srv_t *)arg;
    200         int rc;
    201 
    202         fibril_mutex_lock(&srv->lock);
    203         if (srv->connected) {
    204                 fibril_mutex_unlock(&srv->lock);
    205                 async_answer_0(iid, EBUSY);
    206                 return EBUSY;
    207         }
    208 
    209         srv->connected = true;
    210         fibril_mutex_unlock(&srv->lock);
     188static bd_srv_t *bd_srv_create(bd_srvs_t *srvs)
     189{
     190        bd_srv_t *srv;
     191
     192        srv = calloc(1, sizeof(srv));
     193        if (srv == NULL)
     194                return NULL;
     195
     196        srv->srvs = srvs;
     197        return srv;
     198}
     199
     200void bd_srvs_init(bd_srvs_t *srvs)
     201{
     202        srvs->ops = NULL;
     203        srvs->sarg = NULL;
     204}
     205
     206int bd_conn(ipc_callid_t iid, ipc_call_t *icall, bd_srvs_t *srvs)
     207{
     208        bd_srv_t *srv;
     209        int rc;
    211210
    212211        /* Accept the connection */
    213212        async_answer_0(iid, EOK);
     213
     214        srv = bd_srv_create(srvs);
     215        if (srv == NULL)
     216                return ENOMEM;
    214217
    215218        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
     
    219222        srv->client_sess = sess;
    220223
    221         rc = srv->ops->open(srv);
     224        rc = srvs->ops->open(srvs, srv);
    222225        if (rc != EOK)
    223226                return rc;
     
    230233                if (!method) {
    231234                        /* The other side has hung up */
    232                         fibril_mutex_lock(&srv->lock);
    233                         srv->connected = false;
    234                         fibril_mutex_unlock(&srv->lock);
    235235                        async_answer_0(callid, EOK);
    236236                        break;
     
    258258        }
    259259
    260         return srv->ops->close(srv);
     260        rc = srvs->ops->close(srv);
     261        free(srv);
     262
     263        return rc;
    261264}
    262265
Note: See TracChangeset for help on using the changeset viewer.