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

Changeset 135486d in mainline


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.

Location:
uspace
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/bus/usb/usbmast/main.c

    r4802dd7 r135486d  
    8282    void *arg);
    8383
    84 static int usbmast_bd_open(bd_srv_t *);
     84static int usbmast_bd_open(bd_srvs_t *, bd_srv_t *);
    8585static int usbmast_bd_close(bd_srv_t *);
    8686static int usbmast_bd_read_blocks(bd_srv_t *, aoff64_t, size_t, void *, size_t);
     
    100100static usbmast_fun_t *bd_srv_usbmast(bd_srv_t *bd)
    101101{
    102         return (usbmast_fun_t *)bd->arg;
     102        return (usbmast_fun_t *)bd->srvs->sarg;
    103103}
    104104
     
    240240        mfun->lun = lun;
    241241
    242         bd_srv_init(&mfun->bd);
    243         mfun->bd.ops = &usbmast_bd_ops;
    244         mfun->bd.arg = mfun;
     242        bd_srvs_init(&mfun->bds);
     243        mfun->bds.ops = &usbmast_bd_ops;
     244        mfun->bds.sarg = mfun;
    245245
    246246        /* Set up a connection handler. */
     
    311311
    312312        mfun = (usbmast_fun_t *) ((ddf_fun_t *)arg)->driver_data;
    313         bd_conn(iid, icall, &mfun->bd);
     313        bd_conn(iid, icall, &mfun->bds);
    314314}
    315315
    316316/** Open device. */
    317 static int usbmast_bd_open(bd_srv_t *bd)
     317static int usbmast_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
    318318{
    319319        return EOK;
  • uspace/drv/bus/usb/usbmast/usbmast.h

    r4802dd7 r135486d  
    6969        /** Block size in bytes */
    7070        size_t block_size;
    71         /** Block device server structure */
    72         bd_srv_t bd;
     71        /** Block device service structure */
     72        bd_srvs_t bds;
    7373} usbmast_fun_t;
    7474
  • 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
  • uspace/lib/c/include/bd_srv.h

    r4802dd7 r135486d  
    3636#define LIBC_BD_SRV_H_
    3737
     38#include <adt/list.h>
    3839#include <async.h>
    3940#include <fibril_synch.h>
     
    4344typedef struct bd_ops bd_ops_t;
    4445
     46/** Service setup (per sevice) */
    4547typedef struct {
    46         fibril_mutex_t lock;
    47         bool connected;
    4848        bd_ops_t *ops;
    49         void *arg;
     49        void *sarg;
     50} bd_srvs_t;
     51
     52/** Server structure (per client session) */
     53typedef struct {
     54        bd_srvs_t *srvs;
    5055        async_sess_t *client_sess;
     56        void *carg;
    5157} bd_srv_t;
    5258
    5359typedef struct bd_ops {
    54         int (*open)(bd_srv_t *);
     60        int (*open)(bd_srvs_t *, bd_srv_t *);
    5561        int (*close)(bd_srv_t *);
    5662        int (*read_blocks)(bd_srv_t *, aoff64_t, size_t, void *, size_t);
     
    6167} bd_ops_t;
    6268
    63 extern void bd_srv_init(bd_srv_t *);
     69extern void bd_srvs_init(bd_srvs_t *);
    6470
    65 extern int bd_conn(ipc_callid_t, ipc_call_t *, void *);
     71extern int bd_conn(ipc_callid_t, ipc_call_t *, bd_srvs_t *);
    6672
    6773#endif
  • uspace/srv/bd/ata_bd/ata_bd.c

    r4802dd7 r135486d  
    104104static void ata_bd_connection(ipc_callid_t iid, ipc_call_t *icall, void *);
    105105
    106 static int ata_bd_open(bd_srv_t *);
     106static int ata_bd_open(bd_srvs_t *, bd_srv_t *);
    107107static int ata_bd_close(bd_srv_t *);
    108108static int ata_bd_read_blocks(bd_srv_t *, uint64_t ba, size_t cnt, void *buf,
     
    146146static disk_t *bd_srv_disk(bd_srv_t *bd)
    147147{
    148         return (disk_t *)bd->arg;
     148        return (disk_t *)bd->srvs->sarg;
    149149}
    150150
     
    312312        }
    313313
    314         bd_conn(iid, icall, &ata_disk[disk_id].bd);
     314        bd_conn(iid, icall, &ata_disk[disk_id].bds);
    315315}
    316316
     
    336336        fibril_mutex_initialize(&d->lock);
    337337
    338         bd_srv_init(&d->bd);
    339         d->bd.ops = &ata_bd_ops;
    340         d->bd.arg = d;
     338        bd_srvs_init(&d->bds);
     339        d->bds.ops = &ata_bd_ops;
     340        d->bds.sarg = d;
    341341
    342342        /* Try identify command. */
     
    467467}
    468468
    469 static int ata_bd_open(bd_srv_t *bd)
     469static int ata_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
    470470{
    471471        return EOK;
  • uspace/srv/bd/ata_bd/ata_bd.h

    r4802dd7 r135486d  
    119119        service_id_t service_id;
    120120        int disk_id;
    121         bd_srv_t bd;
     121        bd_srvs_t bds;
    122122} disk_t;
    123123
  • uspace/srv/bd/file_bd/file_bd.c

    r4802dd7 r135486d  
    6262
    6363static service_id_t service_id;
    64 static bd_srv_t bd_srv;
     64static bd_srvs_t bd_srvs;
    6565static fibril_mutex_t dev_lock;
    6666
     
    6969static void file_bd_connection(ipc_callid_t iid, ipc_call_t *icall, void *);
    7070
    71 static int file_bd_open(bd_srv_t *);
     71static int file_bd_open(bd_srvs_t *, bd_srv_t *);
    7272static int file_bd_close(bd_srv_t *);
    7373static int file_bd_read_blocks(bd_srv_t *, aoff64_t, size_t, void *, size_t);
     
    154154static int file_bd_init(const char *fname)
    155155{
    156         bd_srv_init(&bd_srv);
    157         bd_srv.ops = &file_bd_ops;
     156        bd_srvs_init(&bd_srvs);
     157        bd_srvs.ops = &file_bd_ops;
    158158       
    159159        async_set_client_connection(file_bd_connection);
     
    188188static void file_bd_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    189189{
    190         bd_conn(iid, icall, &bd_srv);
     190        bd_conn(iid, icall, &bd_srvs);
    191191}
    192192
    193193/** Open device. */
    194 static int file_bd_open(bd_srv_t *bd)
     194static int file_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
    195195{
    196196        return EOK;
  • uspace/srv/bd/gxe_bd/gxe_bd.c

    r4802dd7 r135486d  
    8888/** GXE block device soft state */
    8989typedef struct {
    90         /** Block device server structure */
    91         bd_srv_t bd;
     90        /** Block device service structure */
     91        bd_srvs_t bds;
    9292        int disk_id;
    9393} gxe_bd_t;
     
    109109static int gxe_bd_write_block(int disk_id, uint64_t ba, const void *buf);
    110110
    111 static int gxe_bd_open(bd_srv_t *);
     111static int gxe_bd_open(bd_srvs_t *, bd_srv_t *);
    112112static int gxe_bd_close(bd_srv_t *);
    113113static int gxe_bd_read_blocks(bd_srv_t *, aoff64_t, size_t, void *, size_t);
     
    127127static gxe_bd_t *bd_srv_gxe(bd_srv_t *bd)
    128128{
    129         return (gxe_bd_t *)bd->arg;
     129        return (gxe_bd_t *)bd->srvs->sarg;
    130130}
    131131
     
    166166                char name[16];
    167167               
    168                 bd_srv_init(&gxe_bd[i].bd);
    169                 gxe_bd[i].bd.ops = &gxe_bd_ops;
    170                 gxe_bd[i].bd.arg = (void *)&gxe_bd[i];
     168                bd_srvs_init(&gxe_bd[i].bds);
     169                gxe_bd[i].bds.ops = &gxe_bd_ops;
     170                gxe_bd[i].bds.sarg = (void *)&gxe_bd[i];
    171171               
    172172                snprintf(name, 16, "%s/disk%u", NAMESPACE, i);
     
    203203        }
    204204
    205         bd_conn(iid, icall, &gxe_bd[disk_id].bd);
     205        bd_conn(iid, icall, &gxe_bd[disk_id].bds);
    206206}
    207207
    208208/** Open device. */
    209 static int gxe_bd_open(bd_srv_t *bd)
     209static int gxe_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
    210210{
    211211        return EOK;
  • uspace/srv/bd/part/guid_part/guid_part.c

    r4802dd7 r135486d  
    8383        /** Service representing the partition (outbound device) */
    8484        service_id_t dsid;
    85         /** Block device server structure */
    86         bd_srv_t bd;
     85        /** Block device service structure */
     86        bd_srvs_t bds;
    8787        /** Points to next partition structure. */
    8888        struct part *next;
     
    104104static int gpt_bsa_translate(part_t *p, aoff64_t ba, size_t cnt, aoff64_t *gba);
    105105
    106 static int gpt_bd_open(bd_srv_t *);
     106static int gpt_bd_open(bd_srvs_t *, bd_srv_t *);
    107107static int gpt_bd_close(bd_srv_t *);
    108108static int gpt_bd_read_blocks(bd_srv_t *, aoff64_t, size_t, void *, size_t);
     
    122122static part_t *bd_srv_part(bd_srv_t *bd)
    123123{
    124         return (part_t *)bd->arg;
     124        return (part_t *)bd->srvs->sarg;
    125125}
    126126
     
    325325        }
    326326
    327         bd_srv_init(&part->bd);
    328         part->bd.ops = &gpt_bd_ops;
    329         part->bd.arg = part;
     327        bd_srvs_init(&part->bds);
     328        part->bds.ops = &gpt_bd_ops;
     329        part->bds.sarg = part;
    330330
    331331        part->dsid = 0;
     
    357357        assert(part->present == true);
    358358
    359         bd_conn(iid, icall, &part->bd);
     359        bd_conn(iid, icall, &part->bds);
    360360}
    361361
    362362/** Open device. */
    363 static int gpt_bd_open(bd_srv_t *bd)
     363static int gpt_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
    364364{
    365365        return EOK;
  • uspace/srv/bd/part/mbr_part/mbr_part.c

    r4802dd7 r135486d  
    100100        /** Device representing the partition (outbound device) */
    101101        service_id_t dsid;
    102         /** Block device server structure */
    103         bd_srv_t bd;
     102        /** Block device service sturcture */
     103        bd_srvs_t bds;
    104104        /** Points to next partition structure. */
    105105        struct part *next;
     
    154154static int mbr_bsa_translate(part_t *p, uint64_t ba, size_t cnt, uint64_t *gba);
    155155
    156 static int mbr_bd_open(bd_srv_t *);
     156static int mbr_bd_open(bd_srvs_t *, bd_srv_t *);
    157157static int mbr_bd_close(bd_srv_t *);
    158158static int mbr_bd_read_blocks(bd_srv_t *, aoff64_t, size_t, void *, size_t);
     
    172172static part_t *bd_srv_part(bd_srv_t *bd)
    173173{
    174         return (part_t *)bd->arg;
     174        return (part_t *)bd->srvs->sarg;
    175175}
    176176
     
    402402        part->present = (pte->ptype != PT_UNUSED) ? true : false;
    403403
    404         bd_srv_init(&part->bd);
    405         part->bd.ops = &mbr_bd_ops;
    406         part->bd.arg = part;
     404        bd_srvs_init(&part->bds);
     405        part->bds.ops = &mbr_bd_ops;
     406        part->bds.sarg = part;
    407407
    408408        part->dsid = 0;
     
    433433
    434434        assert(part->present == true);
    435         bd_conn(iid, icall, &part->bd);
     435        bd_conn(iid, icall, &part->bds);
    436436}
    437437
    438438/** Open device. */
    439 static int mbr_bd_open(bd_srv_t *bd)
     439static int mbr_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
    440440{
    441441        return EOK;
  • uspace/srv/bd/rd/rd.c

    r4802dd7 r135486d  
    6868static const size_t block_size = 512;
    6969
    70 static int rd_open(bd_srv_t *);
     70static int rd_open(bd_srvs_t *, bd_srv_t *);
    7171static int rd_close(bd_srv_t *);
    7272static int rd_read_blocks(bd_srv_t *, aoff64_t, size_t, void *, size_t);
     
    9393};
    9494
    95 static bd_srv_t bd_srv;
     95static bd_srvs_t bd_srvs;
    9696
    9797static void rd_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    9898{
    99         bd_conn(iid, icall, &bd_srv);
     99        bd_conn(iid, icall, &bd_srvs);
    100100}
    101101
    102102/** Open device. */
    103 static int rd_open(bd_srv_t *bd)
     103static int rd_open(bd_srvs_t *bds, bd_srv_t *bd)
    104104{
    105105        return EOK;
     
    175175            (void *) addr_phys, size);
    176176       
    177         bd_srv_init(&bd_srv);
    178         bd_srv.ops = &rd_bd_ops;
     177        bd_srvs_init(&bd_srvs);
     178        bd_srvs.ops = &rd_bd_ops;
    179179       
    180180        async_set_client_connection(rd_client_conn);
  • uspace/srv/bd/sata_bd/sata_bd.c

    r4802dd7 r135486d  
    5757static int disk_count;
    5858
    59 static int sata_bd_open(bd_srv_t *);
     59static int sata_bd_open(bd_srvs_t *, bd_srv_t *);
    6060static int sata_bd_close(bd_srv_t *);
    6161static int sata_bd_read_blocks(bd_srv_t *, aoff64_t, size_t, void *, size_t);
     
    7575static sata_bd_dev_t *bd_srv_sata(bd_srv_t *bd)
    7676{
    77         return (sata_bd_dev_t *)bd->arg;
     77        return (sata_bd_dev_t *)bd->srvs->sarg;
    7878}
    7979
     
    104104                ahci_get_num_blocks(disk[disk_count].sess, &disk[disk_count].blocks);
    105105               
    106                 bd_srv_init(&disk[disk_count].bd);
    107                 disk[disk_count].bd.ops = &sata_bd_ops;
    108                 disk[disk_count].bd.arg = &disk[disk_count];
     106                bd_srvs_init(&disk[disk_count].bds);
     107                disk[disk_count].bds.ops = &sata_bd_ops;
     108                disk[disk_count].bds.sarg = &disk[disk_count];
    109109               
    110110                printf("Device %s - %s , blocks: %lu, block_size: %lu\n",
     
    183183        }
    184184
    185         bd_conn(iid, icall, &disk[disk_id].bd);
     185        bd_conn(iid, icall, &disk[disk_id].bds);
    186186}
    187187
    188188/** Open device. */
    189 static int sata_bd_open(bd_srv_t *bd)
     189static int sata_bd_open(bd_srvs_t *bds, bd_srv_t *bd)
    190190{
    191191        return EOK;
  • uspace/srv/bd/sata_bd/sata_bd.h

    r4802dd7 r135486d  
    5858        size_t block_size;
    5959        /** Block device server structure */
    60         bd_srv_t bd;
     60        bd_srvs_t bds;
    6161} sata_bd_dev_t;
    6262
Note: See TracChangeset for help on using the changeset viewer.