Changeset f302586 in mainline


Ignore:
Timestamp:
2012-01-14T23:31:26Z (13 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
3ea725e, 8989f2a7, a1347a7
Parents:
6d8455d
Message:

make sure the client_connection is explicitly set at most once
it is not a mutable variable, it is a weak symbol

Location:
uspace
Files:
19 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/async.c

    r6d8455d rf302586  
    257257void async_set_client_data_constructor(async_client_data_ctor_t ctor)
    258258{
     259        assert(async_client_data_create == default_client_data_constructor);
    259260        async_client_data_create = ctor;
    260261}
    … …  
    262263void async_set_client_data_destructor(async_client_data_dtor_t dtor)
    263264{
     265        assert(async_client_data_destroy == default_client_data_destructor);
    264266        async_client_data_destroy = dtor;
    265267}
    … …  
    303305void async_set_client_connection(async_client_conn_t conn)
    304306{
     307        assert(client_connection == default_client_connection);
    305308        client_connection = conn;
    306309}

  • uspace/lib/c/generic/devman.c

    r6d8455d rf302586  
    177177
    178178/** Register running driver with device manager. */
    179 int devman_driver_register(const char *name, async_client_conn_t conn)
     179int devman_driver_register(const char *name)
    180180{
    181181        async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
    … …  
    192192        }
    193193       
    194         async_set_client_connection(conn);
    195        
    196194        exch = devman_exchange_begin(DEVMAN_DRIVER);
    197         async_connect_to_me(exch, 0, 0, 0, conn, NULL);
     195        async_connect_to_me(exch, 0, 0, 0, NULL, NULL);
    198196        devman_exchange_end(exch);
    199197       

  • uspace/lib/c/generic/loc.c

    r6d8455d rf302586  
    242242
    243243/** Register new driver with loc. */
    244 int loc_server_register(const char *name, async_client_conn_t conn)
     244int loc_server_register(const char *name)
    245245{
    246246        async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_SUPPLIER);
    … …  
    256256                return retval;
    257257        }
    258        
    259         async_set_client_connection(conn);
    260258       
    261259        exch = loc_exchange_begin(LOC_PORT_SUPPLIER);

  • uspace/lib/c/include/devman.h

    r6d8455d rf302586  
    4646extern void devman_exchange_end(async_exch_t *);
    4747
    48 extern int devman_driver_register(const char *, async_client_conn_t);
     48extern int devman_driver_register(const char *);
    4949extern int devman_add_function(const char *, fun_type_t, match_id_list_t *,
    5050    devman_handle_t, devman_handle_t *);

  • uspace/lib/c/include/loc.h

    r6d8455d rf302586  
    4646extern void loc_exchange_end(async_exch_t *);
    4747
    48 extern int loc_server_register(const char *, async_client_conn_t);
     48extern int loc_server_register(const char *);
    4949extern int loc_service_register(const char *, service_id_t *);
    5050extern int loc_service_register_with_iface(const char *, service_id_t *,

  • uspace/lib/drv/generic/driver.c

    r6d8455d rf302586  
    10161016         * incoming connections.
    10171017         */
    1018         rc = devman_driver_register(driver->name, driver_connection);
     1018        async_set_client_connection(driver_connection);
     1019        rc = devman_driver_register(driver->name);
    10191020        if (rc != EOK) {
    10201021                printf("Error: Failed to register driver with device manager "

  • uspace/srv/bd/ata_bd/ata_bd.c

    r6d8455d rf302586  
    245245        void *vaddr;
    246246        int rc;
    247 
    248         rc = loc_server_register(NAME, ata_bd_connection);
     247       
     248        async_set_client_connection(ata_bd_connection);
     249        rc = loc_server_register(NAME);
    249250        if (rc < 0) {
    250251                printf(NAME ": Unable to register driver.\n");

  • uspace/srv/bd/file_bd/file_bd.c

    r6d8455d rf302586  
    141141        int rc;
    142142        long img_size;
    143 
    144         rc = loc_server_register(NAME, file_bd_connection);
     143       
     144        async_set_client_connection(file_bd_connection);
     145        rc = loc_server_register(NAME);
    145146        if (rc < 0) {
    146147                printf(NAME ": Unable to register driver.\n");

  • uspace/srv/bd/gxe_bd/gxe_bd.c

    r6d8455d rf302586  
    125125        int rc, i;
    126126        char name[16];
    127 
    128         rc = loc_server_register(NAME, gxe_bd_connection);
     127       
     128        async_set_client_connection(gxe_bd_connection);
     129        rc = loc_server_register(NAME);
    129130        if (rc < 0) {
    130131                printf(NAME ": Unable to register driver.\n");

  • uspace/srv/bd/part/guid_part/guid_part.c

    r6d8455d rf302586  
    164164
    165165        /* Register server with location service. */
    166         rc = loc_server_register(NAME, gpt_connection);
     166        async_set_client_connection(gpt_connection);
     167        rc = loc_server_register(NAME);
    167168        if (rc != EOK) {
    168169                printf(NAME ": Unable to register server.\n");

  • uspace/srv/bd/part/mbr_part/mbr_part.c

    r6d8455d rf302586  
    214214
    215215        /* Register server with location service. */
    216         rc = loc_server_register(NAME, mbr_connection);
     216        async_set_client_connection(mbr_connection);
     217        rc = loc_server_register(NAME);
    217218        if (rc != EOK) {
    218219                printf(NAME ": Unable to register server.\n");

  • uspace/srv/bd/rd/rd.c

    r6d8455d rf302586  
    235235            (void *) addr_phys, size);
    236236       
    237         ret = loc_server_register(NAME, rd_connection);
     237        async_set_client_connection(rd_connection);
     238        ret = loc_server_register(NAME);
    238239        if (ret < 0) {
    239240                printf("%s: Unable to register driver (%d)\n", NAME, ret);

  • uspace/srv/devman/main.c

    r6d8455d rf302586  
    13091309
    13101310        /*
    1311          * !!! devman_connection ... as the device manager is not a real loc
    1312          * driver (it uses a completely different ipc protocol than an ordinary
    1313          * loc driver) forwarding a connection from client to the devman by
    1314          * location service would not work.
     1311         * Caution: As the device manager is not a real loc
     1312         * driver (it uses a completely different IPC protocol
     1313         * than an ordinary loc driver), forwarding a connection
     1314         * from client to the devman by location service will
     1315         * not work.
    13151316         */
    1316         loc_server_register(NAME, devman_connection);
     1317        loc_server_register(NAME);
    13171318       
    13181319        return true;
    … …  
    13251326        if (log_init(NAME, LVL_WARN) != EOK) {
    13261327                printf(NAME ": Error initializing logging subsystem.\n");
    1327                 return -1;
    1328         }
    1329 
    1330         if (!devman_init()) {
    1331                 log_msg(LVL_ERROR, "Error while initializing service.");
    13321328                return -1;
    13331329        }
    … …  
    13381334        async_set_client_connection(devman_connection);
    13391335
     1336        if (!devman_init()) {
     1337                log_msg(LVL_ERROR, "Error while initializing service.");
     1338                return -1;
     1339        }
     1340
    13401341        /* Register device manager at naming service. */
    13411342        if (service_register(SERVICE_DEVMAN) != EOK) {

  • uspace/srv/hid/console/console.c

    r6d8455d rf302586  
    825825       
    826826        /* Register server */
    827         int rc = loc_server_register(NAME, client_connection);
     827        async_set_client_connection(client_connection);
     828        int rc = loc_server_register(NAME);
    828829        if (rc < 0) {
    829830                printf("%s: Unable to register server (%s)\n", NAME,

  • uspace/srv/hid/fb/fb.c

    r6d8455d rf302586  
    987987       
    988988        /* Register server */
    989         int rc = loc_server_register(NAME, client_connection);
     989        async_set_client_connection(client_connection);
     990        int rc = loc_server_register(NAME);
    990991        if (rc != EOK) {
    991992                printf("%s: Unable to register driver (%d)\n", NAME, rc);

  • uspace/srv/hid/input/generic/input.c

    r6d8455d rf302586  
    649649       
    650650        /* Register driver */
    651         int rc = loc_server_register(NAME, client_connection);
     651        async_set_client_connection(client_connection);
     652        int rc = loc_server_register(NAME);
    652653        if (rc < 0) {
    653654                printf("%s: Unable to register server (%d)\n", NAME, rc);

  • uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.c

    r6d8455d rf302586  
    8585
    8686        printf(NAME ": S3C24xx touchscreen driver\n");
    87 
    88         rc = loc_server_register(NAME, s3c24xx_ts_connection);
     87       
     88        async_set_client_connection(s3c24xx_ts_connection);
     89        rc = loc_server_register(NAME);
    8990        if (rc < 0) {
    9091                printf(NAME ": Unable to register driver.\n");

  • uspace/srv/hw/bus/cuda_adb/cuda_adb.c

    r6d8455d rf302586  
    154154        }
    155155
    156         rc = loc_server_register(NAME, cuda_connection);
     156        async_set_client_connection(cuda_connection);
     157        rc = loc_server_register(NAME);
    157158        if (rc < 0) {
    158159                printf(NAME ": Unable to register server.\n");

  • uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.c

    r6d8455d rf302586  
    7979        printf(NAME ": S3C24xx on-chip UART driver\n");
    8080
    81         rc = loc_server_register(NAME, s3c24xx_uart_connection);
     81        async_set_client_connection(s3c24xx_uart_connection);
     82        rc = loc_server_register(NAME);
    8283        if (rc < 0) {
    8384                printf(NAME ": Unable to register server.\n");
Note: See TracChangeset for help on using the changeset viewer.