Changeset 40dc422 in mainline


Ignore:
Timestamp:
2010-12-18T11:07:32Z (13 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
557c7d0, 78ffb70
Parents:
bbc74af7 (diff), 6e50466 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge from lp:~vojtech-horky/helenos/ddf-fixes.

Location:
uspace
Files:
4 added
12 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/tester/Makefile

    rbbc74af7 r40dc422  
    5151        loop/loop1.c \
    5252        mm/malloc1.c \
     53        hw/misc/virtchar1.c \
    5354        hw/serial/serial1.c
    5455

  • uspace/app/tester/tester.c

    rbbc74af7 r40dc422  
    6565#include "mm/malloc1.def"
    6666#include "hw/serial/serial1.def"
     67#include "hw/misc/virtchar1.def"
    6768        {NULL, NULL, NULL, false}
    6869};

  • uspace/app/tester/tester.h

    rbbc74af7 r40dc422  
    8282extern const char *test_malloc1(void);
    8383extern const char *test_serial1(void);
     84extern const char *test_virtchar1(void);
    8485
    8586extern test_t tests[];

  • uspace/drv/rootvirt/devices.def

    rbbc74af7 r40dc422  
    1717        .match_id = "virtual&test2"
    1818},
     19{
     20        .name = "null",
     21        .match_id = "virtual&test1"
     22},
    1923#endif

  • uspace/drv/test1/Makefile

    rbbc74af7 r40dc422  
    3333
    3434SOURCES = \
     35        char.c \
    3536        test1.c
    3637

  • uspace/drv/test1/test1.c

    rbbc74af7 r40dc422  
    3434#include <errno.h>
    3535#include <str_error.h>
    36 #include <driver.h>
    37 
    38 #define NAME "test1"
     36#include "test1.h"
    3937
    4038static int add_device(device_t *dev);
    … …  
    9896        add_device_to_class(dev, "virtual");
    9997
    100         if (dev->parent == NULL) {
     98        if (str_cmp(dev->name, "null") == 0) {
     99                dev->ops = &char_device_ops;
     100                add_device_to_class(dev, "virt-null");
     101        } else if (dev->parent == NULL) {
    101102                register_child_verbose(dev, "cloning myself ;-)", "clone",
    102103                    "virtual&test1", 10);
    … …  
    117118}
    118119
    119 

  • uspace/lib/c/generic/devmap.c

    rbbc74af7 r40dc422  
    127127/** Register new device.
    128128 *
    129  * @param namespace Namespace name.
     129 * The @p interface is used when forwarding connection to the driver.
     130 * If not 0, the first argument is the interface and the second argument
     131 * is the devmap handle of the device.
     132 * When the interface is zero (default), the first argument is directly
     133 * the handle (to ensure backward compatibility).
     134 *
     135 * @param fqdn Fully qualified device name.
     136 * @param[out] handle Handle to the created instance of device.
     137 * @param interface Interface when forwarding.
     138 *
     139 */
     140int devmap_device_register_with_iface(const char *fqdn,
     141    devmap_handle_t *handle, sysarg_t interface)
     142{
     143        int phone = devmap_get_phone(DEVMAP_DRIVER, IPC_FLAG_BLOCKING);
     144       
     145        if (phone < 0)
     146                return phone;
     147       
     148        async_serialize_start();
     149       
     150        ipc_call_t answer;
     151        aid_t req = async_send_2(phone, DEVMAP_DEVICE_REGISTER, interface, 0,
     152            &answer);
     153       
     154        sysarg_t retval = async_data_write_start(phone, fqdn, str_size(fqdn));
     155        if (retval != EOK) {
     156                async_wait_for(req, NULL);
     157                async_serialize_end();
     158                return retval;
     159        }
     160       
     161        async_wait_for(req, &retval);
     162       
     163        async_serialize_end();
     164       
     165        if (retval != EOK) {
     166                if (handle != NULL)
     167                        *handle = -1;
     168                return retval;
     169        }
     170       
     171        if (handle != NULL)
     172                *handle = (devmap_handle_t) IPC_GET_ARG1(answer);
     173       
     174        return retval;
     175}
     176
     177/** Register new device.
     178 *
    130179 * @param fqdn      Fully qualified device name.
    131180 * @param handle    Output: Handle to the created instance of device.
    … …  
    134183int devmap_device_register(const char *fqdn, devmap_handle_t *handle)
    135184{
    136         int phone = devmap_get_phone(DEVMAP_DRIVER, IPC_FLAG_BLOCKING);
    137        
    138         if (phone < 0)
    139                 return phone;
    140        
    141         async_serialize_start();
    142        
    143         ipc_call_t answer;
    144         aid_t req = async_send_2(phone, DEVMAP_DEVICE_REGISTER, 0, 0,
    145             &answer);
    146        
    147         sysarg_t retval = async_data_write_start(phone, fqdn, str_size(fqdn));
    148         if (retval != EOK) {
    149                 async_wait_for(req, NULL);
    150                 async_serialize_end();
    151                 return retval;
    152         }
    153        
    154         async_wait_for(req, &retval);
    155        
    156         async_serialize_end();
    157        
    158         if (retval != EOK) {
    159                 if (handle != NULL)
    160                         *handle = -1;
    161                 return retval;
    162         }
    163        
    164         if (handle != NULL)
    165                 *handle = (devmap_handle_t) IPC_GET_ARG1(answer);
    166        
    167         return retval;
    168 }
     185        return devmap_device_register_with_iface(fqdn, handle, 0);
     186}
     187
    169188
    170189int devmap_device_get_handle(const char *fqdn, devmap_handle_t *handle, unsigned int flags)

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

    rbbc74af7 r40dc422  
    4545extern int devmap_driver_register(const char *, async_client_conn_t);
    4646extern int devmap_device_register(const char *, devmap_handle_t *);
     47extern int devmap_device_register_with_iface(const char *, devmap_handle_t *, sysarg_t);
    4748
    4849extern int devmap_device_get_handle(const char *, devmap_handle_t *, unsigned int);

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

    rbbc74af7 r40dc422  
    123123        DEVMAN_CLIENT,
    124124        DEVMAN_CONNECT_TO_DEVICE,
     125        DEVMAN_CONNECT_FROM_DEVMAP,
    125126        DEVMAN_CONNECT_TO_PARENTS_DEVICE
    126127} devman_interface_t;

  • uspace/srv/devman/devman.c

    rbbc74af7 r40dc422  
    6262}
    6363
     64static int devmap_devices_class_compare(unsigned long key[], hash_count_t keys,
     65    link_t *item)
     66{
     67        dev_class_info_t *class_info
     68            = hash_table_get_instance(item, dev_class_info_t, devmap_link);
     69        assert(class_info != NULL);
     70
     71        return (class_info->devmap_handle == (devmap_handle_t) key[0]);
     72}
     73
    6474static void devices_remove_callback(link_t *item)
    6575{
    … …  
    7585        .hash = devices_hash,
    7686        .compare = devmap_devices_compare,
     87        .remove_callback = devices_remove_callback
     88};
     89
     90static hash_table_operations_t devmap_devices_class_ops = {
     91        .hash = devices_hash,
     92        .compare = devmap_devices_class_compare,
    7793        .remove_callback = devices_remove_callback
    7894};
    … …  
    670686        }
    671687       
    672         devmap_device_register(devmap_pathname, &node->devmap_handle);
     688        devmap_device_register_with_iface(devmap_pathname,
     689            &node->devmap_handle, DEVMAN_CONNECT_FROM_DEVMAP);
    673690       
    674691        tree_add_devmap_device(tree, node);
    … …  
    10421059       
    10431060        info = (dev_class_info_t *) malloc(sizeof(dev_class_info_t));
    1044         if (info != NULL)
     1061        if (info != NULL) {
    10451062                memset(info, 0, sizeof(dev_class_info_t));
     1063                list_initialize(&info->dev_classes);
     1064                list_initialize(&info->devmap_link);
     1065                list_initialize(&info->link);
     1066        }
    10461067       
    10471068        return info;
    … …  
    11671188        fibril_rwlock_initialize(&class_list->rwlock);
    11681189        hash_table_create(&class_list->devmap_devices, DEVICE_BUCKETS, 1,
    1169             &devmap_devices_ops);
     1190            &devmap_devices_class_ops);
    11701191}
    11711192
    … …  
    12151236        hash_table_insert(&class_list->devmap_devices, &key, &cli->devmap_link);
    12161237        fibril_rwlock_write_unlock(&class_list->rwlock);
     1238
     1239        assert(find_devmap_class_device(class_list, cli->devmap_handle) != NULL);
    12171240}
    12181241

  • uspace/srv/devman/main.c

    rbbc74af7 r40dc422  
    281281         * handle.
    282282         */
    283         devmap_device_register(devmap_pathname, &cli->devmap_handle);
     283        devmap_device_register_with_iface(devmap_pathname,
     284            &cli->devmap_handle, DEVMAN_CONNECT_FROM_DEVMAP);
    284285       
    285286        /*
    … …  
    486487static void devman_connection_devmapper(ipc_callid_t iid, ipc_call_t *icall)
    487488{
    488         devmap_handle_t devmap_handle = IPC_GET_IMETHOD(*icall);
     489        devmap_handle_t devmap_handle = IPC_GET_ARG2(*icall);
    489490        node_t *dev;
    490491
    … …  
    503504        }
    504505       
    505         printf(NAME ": devman_connection_devmapper: forward connection to "
    506             "device %s to driver %s.\n", dev->pathname, dev->drv->name);
    507506        ipc_forward_fast(iid, dev->drv->phone, DRIVER_CLIENT, dev->handle, 0,
    508507            IPC_FF_NONE);
     508        printf(NAME ": devman_connection_devmapper: forwarded connection to "
     509            "device %s to driver %s.\n", dev->pathname, dev->drv->name);
    509510}
    510511
    … …  
    512513static void devman_connection(ipc_callid_t iid, ipc_call_t *icall)
    513514{
    514         /*
    515          * Silly hack to enable the device manager to register as a driver by
    516          * the device mapper. If the ipc method is not IPC_M_CONNECT_ME_TO, this
    517          * is not the forwarded connection from naming service, so it must be a
    518          * connection from the devmapper which thinks this is a devmapper-style
    519          * driver. So pretend this is a devmapper-style driver. (This does not
    520          * work for device with handle == IPC_M_CONNECT_ME_TO, because devmapper
    521          * passes device handle to the driver as an ipc method.)
    522          */
    523         if (IPC_GET_IMETHOD(*icall) != IPC_M_CONNECT_ME_TO)
    524                 devman_connection_devmapper(iid, icall);
    525 
    526         /*
    527          * ipc method is IPC_M_CONNECT_ME_TO, so this is forwarded connection
    528          * from naming service by which we registered as device manager, so be
    529          * device manager.
    530          */
    531        
    532515        /* Select interface. */
    533516        switch ((sysarg_t) (IPC_GET_ARG1(*icall))) {
    … …  
    542525                devman_forward(iid, icall, false);
    543526                break;
     527        case DEVMAN_CONNECT_FROM_DEVMAP:
     528                /* Someone connected through devmap node. */
     529                devman_connection_devmapper(iid, icall);
     530                break;
    544531        case DEVMAN_CONNECT_TO_PARENTS_DEVICE:
    545532                /* Connect client to selected device. */

  • uspace/srv/devmap/devmap.c

    rbbc74af7 r40dc422  
    9999        /** Device driver handling this device */
    100100        devmap_driver_t *driver;
     101        /** Use this interface when forwarding to driver. */
     102        sysarg_t forward_interface;
    101103} devmap_device_t;
    102104
    … …  
    517519        }
    518520       
     521        /* Set the interface, if any. */
     522        device->forward_interface = IPC_GET_ARG1(*icall);
     523
    519524        /* Get fqdn */
    520525        char *fqdn;
    … …  
    566571        /* Get unique device handle */
    567572        device->handle = devmap_create_handle();
    568        
     573
    569574        devmap_namespace_addref(namespace, device);
    570575        device->driver = driver;
    … …  
    617622        }
    618623       
    619         ipc_forward_fast(callid, dev->driver->phone, dev->handle,
    620             IPC_GET_ARG3(*call), 0, IPC_FF_NONE);
     624        if (dev->forward_interface == 0) {
     625                ipc_forward_fast(callid, dev->driver->phone,
     626                    dev->handle, 0, 0,
     627                    IPC_FF_NONE);
     628        } else {
     629                ipc_forward_fast(callid, dev->driver->phone,
     630                    dev->forward_interface, dev->handle, 0,
     631                    IPC_FF_NONE);
     632        }
    621633       
    622634        fibril_mutex_unlock(&devices_list_mutex);
Note: See TracChangeset for help on using the changeset viewer.