Changeset cfb79747 in mainline for uspace/srv


Ignore:
Timestamp:
2012-02-14T22:06:15Z (14 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a31aad1
Parents:
199112e4 (diff), e10d41a (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 mainline changes.

Location:
uspace/srv
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/devman/devman.c

    r199112e4 rcfb79747  
    794794        case EOK:
    795795                dev->state = DEVICE_USABLE;
    796                 exch = async_exchange_begin(drv->sess);
    797                 async_msg_1(exch, DRIVER_DEV_ADDED, dev->handle);
    798                 async_exchange_end(exch);
    799796                break;
    800797        case ENOENT:
    … …  
    803800        default:
    804801                dev->state = DEVICE_INVALID;
     802                break;
    805803        }
    806804       

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

    r199112e4 rcfb79747  
    3939#include <adt/list.h>
    4040#include <bool.h>
     41#include <fibril_synch.h>
    4142#include <ipc/services.h>
    4243#include <ipc/input.h>
    … …  
    8384async_sess_t *irc_sess = NULL;
    8485
     86static FIBRIL_MUTEX_INITIALIZE(discovery_lock);
     87
    8588void kbd_push_data(kbd_dev_t *kdev, sysarg_t data)
    8689{
    … …  
    593596        int rc;
    594597       
     598        fibril_mutex_lock(&discovery_lock);
     599       
    595600        rc = dev_check_new_kbdevs();
    596         if (rc != EOK)
     601        if (rc != EOK) {
     602                fibril_mutex_unlock(&discovery_lock);
    597603                return rc;
     604        }
    598605       
    599606        rc = dev_check_new_mousedevs();
    600         if (rc != EOK)
     607        if (rc != EOK) {
     608                fibril_mutex_unlock(&discovery_lock);
    601609                return rc;
    602 
     610        }
     611       
     612        fibril_mutex_unlock(&discovery_lock);
     613       
    603614        return EOK;
    604615}

  • uspace/srv/loc/loc.c

    r199112e4 rcfb79747  
    5656#define NULL_SERVICES  256
    5757
     58/** Callback session */
     59typedef struct {
     60        link_t cb_sess_list;
     61        async_sess_t *sess;
     62} cb_sess_t;
     63
    5864LIST_INITIALIZE(services_list);
    5965LIST_INITIALIZE(namespaces_list);
    … …  
    8692
    8793static FIBRIL_MUTEX_INITIALIZE(callback_sess_mutex);
    88 static async_sess_t *callback_sess = NULL;
     94static LIST_INITIALIZE(callback_sess_list);
    8995
    9096service_id_t loc_create_id(void)
    … …  
    608614        size_t act_size;
    609615        loc_service_t *svc;
     616        char *fqn;
    610617       
    611618        if (!async_data_read_receive(&callid, &size)) {
    … …  
    625632        }
    626633       
    627         act_size = str_size(svc->name);
     634        if (asprintf(&fqn, "%s/%s", svc->namespace->name, svc->name) < 0) {
     635                fibril_mutex_unlock(&services_list_mutex);
     636                async_answer_0(callid, ENOMEM);
     637                async_answer_0(iid, ENOMEM);
     638                return;
     639        }
     640       
     641        act_size = str_size(fqn);
    628642        if (act_size > size) {
     643                free(fqn);
    629644                fibril_mutex_unlock(&services_list_mutex);
    630645                async_answer_0(callid, EOVERFLOW);
    … …  
    633648        }
    634649       
    635         sysarg_t retval = async_data_read_finalize(callid, svc->name,
     650        sysarg_t retval = async_data_read_finalize(callid, fqn,
    636651            min(size, act_size));
     652        free(fqn);
    637653       
    638654        fibril_mutex_unlock(&services_list_mutex);
    … …  
    790806}
    791807
    792 /** Find ID for category specified by name.
    793  *
    794  * On success, answer will contain EOK int retval and service ID in arg1.
     808/** Create callback connection.
     809 *
     810 * Create callback connection which will be used to send category change
     811 * events.
     812 *
     813 * On success, answer will contain EOK int retval.
    795814 * On failure, error code will be sent in retval.
    796815 *
    … …  
    798817static void loc_callback_create(ipc_callid_t iid, ipc_call_t *icall)
    799818{
    800         async_sess_t *cb_sess = async_callback_receive(EXCHANGE_SERIALIZE);
     819        cb_sess_t *cb_sess = calloc(1, sizeof(cb_sess_t));
    801820        if (cb_sess == NULL) {
    802821                async_answer_0(iid, ENOMEM);
    … …  
    804823        }
    805824       
     825        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
     826        if (sess == NULL) {
     827                free(cb_sess);
     828                async_answer_0(iid, ENOMEM);
     829                return;
     830        }
     831       
     832        cb_sess->sess = sess;
     833        link_initialize(&cb_sess->cb_sess_list);
     834       
    806835        fibril_mutex_lock(&callback_sess_mutex);
    807         if (callback_sess != NULL) {
    808                 fibril_mutex_unlock(&callback_sess_mutex);
    809                 async_answer_0(iid, EEXIST);
    810                 return;
    811         }
    812        
    813         callback_sess = cb_sess;
     836        list_append(&cb_sess->cb_sess_list, &callback_sess_list);
    814837        fibril_mutex_unlock(&callback_sess_mutex);
    815838       
    … …  
    820843{
    821844        fibril_mutex_lock(&callback_sess_mutex);
    822 
    823         if (callback_sess != NULL) {
    824                 async_exch_t *exch = async_exchange_begin(callback_sess);
     845       
     846        list_foreach(callback_sess_list, link) {
     847                cb_sess_t *cb_sess;
     848               
     849                cb_sess = list_get_instance(link, cb_sess_t, cb_sess_list);
     850               
     851                async_exch_t *exch = async_exchange_begin(cb_sess->sess);
    825852                async_msg_0(exch, LOC_EVENT_CAT_CHANGE);
    826853                async_exchange_end(exch);
    827854        }
    828 
     855       
    829856        fibril_mutex_unlock(&callback_sess_mutex);
    830857}

  • uspace/srv/net/cfg/e1k.nic

    r199112e4 rcfb79747  
    33NAME=e1k
    44
    5 HWPATH=/hw/pci0/00:03.0/port0
     5HWPATH=devices/\hw\pci0\00:03.0\port0
    66NIL=eth
    77IL=ip

  • uspace/srv/net/cfg/lo.nic

    r199112e4 rcfb79747  
    33NAME=lo
    44
    5 HWPATH=/virt/lo/port0
     5HWPATH=devices/\virt\lo\port0
    66NIL=nildummy
    77IL=ip

  • uspace/srv/net/cfg/ne2k.nic

    r199112e4 rcfb79747  
    33NAME=ne2k
    44
    5 HWPATH=/hw/pci0/00:01.0/ne2k/port0
     5HWPATH=devices/\hw\pci0\00:01.0\ne2k\port0
    66NIL=eth
    77IL=ip

  • uspace/srv/net/net/Makefile

    r199112e4 rcfb79747  
    3131ROOT_PATH = $(USPACE_PREFIX)/..
    3232LIBS = $(LIBNET_PREFIX)/libnet.a
    33 EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include
     33EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include -I$(LIBNIC_PREFIX)/include \
     34    -I$(LIBDRV_PREFIX)/include
    3435
    3536COMMON_MAKEFILE = $(ROOT_PATH)/Makefile.common

  • uspace/srv/net/net/net.c

    r199112e4 rcfb79747  
    22 * Copyright (c) 2009 Lukas Mejdrech
    33 * Copyright (c) 2011 Radim Vansa
     4 * Copyright (c) 2011 Jiri Svoboda
    45 * All rights reserved.
    56 *
    … …  
    4142#include <stdio.h>
    4243#include <str.h>
    43 #include <devman.h>
    4444#include <str_error.h>
    4545#include <ns.h>
    … …  
    5656#include <adt/measured_strings.h>
    5757#include <adt/module_map.h>
     58#include <fibril_synch.h>
     59#include <loc.h>
     60#include <nic.h>
    5861#include <nil_remote.h>
    5962#include <net_interface.h>
    … …  
    7376GENERIC_CHAR_MAP_IMPLEMENT(measured_strings, measured_string_t);
    7477DEVICE_MAP_IMPLEMENT(netifs, netif_t);
     78LIST_INITIALIZE(netif_list);
     79
     80static FIBRIL_MUTEX_INITIALIZE(discovery_lock);
    7581
    7682/** Add the configured setting to the configuration map.
    … …  
    287293 *
    288294 */
    289 static int init_device(netif_t *netif, devman_handle_t handle)
     295static int init_device(netif_t *netif, service_id_t sid)
    290296{
    291297        printf("%s: Initializing device '%s'\n", NAME, netif->name);
    292298       
    293         netif->handle = handle;
    294         netif->sess = devman_device_connect(EXCHANGE_SERIALIZE, netif->handle,
     299        netif->sid = sid;
     300        netif->sess = loc_service_connect(EXCHANGE_SERIALIZE, netif->sid,
    295301            IPC_FLAG_BLOCKING);
    296302        if (netif->sess == NULL) {
    … …  
    337343                    strtol((const char *) setting->value, NULL, 10) : 0;
    338344                rc = nil_device_req(netif->nil->sess, netif->id,
    339                     netif->handle, mtu);
     345                    netif->sid, mtu);
    340346                if (rc != EOK) {
    341347                        printf("%s: Unable to start network interface layer\n",
    … …  
    359365                break;
    360366        default:
     367                printf("%s: Unknown service\n", NAME);
    361368                return ENOENT;
    362369        }
    363370       
    364371        printf("%s: Activating device '%s'\n", NAME, netif->name);
     372        list_append(&netif->netif_list, &netif_list);
    365373        return nic_set_state(netif->sess, NIC_STATE_ACTIVE);
    366374}
    367375
    368 static int net_port_ready(devman_handle_t handle)
    369 {
    370         char hwpath[MAX_PATH_LENGTH];
    371         int rc = devman_fun_get_path(handle, hwpath, MAX_PATH_LENGTH);
    372         if (rc != EOK)
     376static int net_nic_ready(service_id_t sid)
     377{
     378        int rc;
     379        char *hwpath;
     380       
     381        rc = loc_service_get_name(sid, &hwpath);
     382        if (rc != EOK) {
     383                printf("%s: Failed getting name of service '%u'\n",
     384                    NAME, (unsigned) sid);
    373385                return EINVAL;
     386        }
    374387       
    375388        int index = char_map_find(&net_globals.netif_hwpaths,
    376389            (uint8_t *) hwpath, 0);
    377         if (index == CHAR_MAP_NULL)
     390       
     391        if (index == CHAR_MAP_NULL) {
     392                printf("%s: Service '%s' not found in map.\n", NAME, hwpath);
     393                free(hwpath);
    378394                return ENOENT;
     395        }
     396       
     397        free(hwpath);
    379398       
    380399        netif_t *netif = netifs_get_index(&net_globals.netifs, index);
    … …  
    382401                return ENOENT;
    383402       
    384         rc = init_device(netif, handle);
     403        rc = init_device(netif, sid);
    385404        if (rc != EOK)
    386405                return rc;
    … …  
    391410       
    392411        netif->il->usage++;
    393        
    394         return EOK;
    395 }
    396 
    397 static int net_driver_ready_local(devman_handle_t handle)
    398 {
    399         devman_handle_t *funs;
    400         size_t count;
    401         int rc = devman_dev_get_functions(handle, &funs, &count);
    402         if (rc != EOK)
    403                 return rc;
    404        
    405         for (size_t i = 0; i < count; i++) {
    406                 rc = net_port_ready(funs[i]);
    407                 if (rc != EOK)
    408                         return rc;
    409         }
    410412       
    411413        return EOK;
    … …  
    479481                net_free_devices(strings, count);
    480482                return rc;
    481         case NET_NET_DRIVER_READY:
    482                 rc = net_driver_ready_local(IPC_GET_ARG1(*call));
    483                 *answer_count = 0;
    484                 return rc;
    485483        default:
    486484                return ENOTSUP;
    … …  
    528526                answer_call(callid, res, &answer, count);
    529527        }
     528}
     529
     530static int nic_check_new(void)
     531{
     532        category_id_t nic_cat;
     533        service_id_t *svcs;
     534        size_t count, i;
     535        bool already_known;
     536        int rc;
     537
     538        fibril_mutex_lock(&discovery_lock);
     539
     540        rc = loc_category_get_id(DEVICE_CATEGORY_NIC, &nic_cat, IPC_FLAG_BLOCKING);
     541        if (rc != EOK) {
     542                printf("%s: Failed resolving category '%s'.\n", NAME,
     543                    DEVICE_CATEGORY_NIC);
     544                return ENOENT;
     545        }
     546
     547        rc = loc_category_get_svcs(nic_cat, &svcs, &count);
     548        if (rc != EOK) {
     549                printf("%s: Failed getting list of NIC devices.\n", NAME);
     550                return EIO;
     551        }
     552
     553        for (i = 0; i < count; i++) {
     554                already_known = false;
     555
     556                list_foreach(netif_list, link) {
     557                        netif_t *netif = list_get_instance(link, netif_t, netif_list);
     558                        if (netif->sid == svcs[i]) {
     559                                already_known = true;
     560                                break;
     561                        }
     562                }
     563
     564                if (!already_known) {
     565                        rc = net_nic_ready(svcs[i]);
     566                        if (rc != EOK) {
     567                                printf("%s: Failed adding NIC device #%u.\n",
     568                                    NAME, (unsigned) svcs[i]);
     569                        }
     570                }
     571        }
     572
     573        free(svcs);
     574        fibril_mutex_unlock(&discovery_lock);
     575        return EOK;
     576}
     577
     578static void cat_change_cb(void)
     579{
     580        (void) nic_check_new();
     581}
     582
     583static int net_start_nic_discovery(void)
     584{
     585        int rc;
     586
     587        rc = loc_register_cat_change_cb(cat_change_cb);
     588        if (rc != EOK) {
     589                printf("%s: Failed registering callback for device discovery (%d).\n",
     590                    NAME, rc);
     591                return rc;
     592        }
     593
     594        return nic_check_new();
    530595}
    531596
    … …  
    573638                                continue;
    574639                       
    575                         netif->handle = -1;
     640                        netif->sid = -1;
    576641                        netif->sess = NULL;
    577642                       
    … …  
    697762        }
    698763       
     764        rc = net_start_nic_discovery();
     765        if (rc != EOK) {
     766                printf("%s: Error starting NIC discovery\n", NAME);
     767                pm_destroy();
     768                return rc;
     769        }
     770       
    699771        task_retval(0);
    700772        async_manager();

  • uspace/srv/net/net/net.h

    r199112e4 rcfb79747  
    3535#define NET_NET_H_
    3636
     37#include <ipc/loc.h>
    3738#include <net/device.h>
    3839#include <adt/char_map.h>
    … …  
    4142#include <adt/module_map.h>
    4243#include <net/packet.h>
    43 #include <devman.h>
    4444
    4545#define NAME  "net"
    … …  
    9696       
    9797        /** Serving network interface driver module index. */
    98         devman_handle_t handle;  /**< Handle for devman */
    99         async_sess_t *sess;      /**< Driver session. */
     98        service_id_t sid;    /**< Service ID */
     99        async_sess_t *sess;  /**< Driver session. */
    100100       
    101101        module_t *nil;  /**< Serving link layer module index. */
    102102        module_t *il;   /**< Serving internet layer module index. */
     103       
     104        link_t netif_list;
    103105} netif_t;
    104106

  • uspace/srv/net/nil/eth/eth.c

    r199112e4 rcfb79747  
    4848#include <ipc/net.h>
    4949#include <ipc/services.h>
     50#include <loc.h>
    5051#include <net/modules.h>
    5152#include <net_checksum.h>
    … …  
    169170INT_MAP_IMPLEMENT(eth_protos, eth_proto_t);
    170171
    171 int nil_device_state_msg_local(nic_device_id_t device_id, sysarg_t state)
     172static void eth_nic_cb_connection(ipc_callid_t iid, ipc_call_t *icall,
     173    void *arg);
     174
     175static int eth_device_state(eth_device_t *device, sysarg_t state)
    172176{
    173177        int index;
    … …  
    179183                proto = eth_protos_get_index(&eth_globals.protos, index);
    180184                if ((proto) && (proto->sess)) {
    181                         il_device_state_msg(proto->sess, device_id, state,
    182                             proto->service);
     185                        il_device_state_msg(proto->sess, device->device_id,
     186                            state, proto->service);
    183187                }
    184188        }
    … …  
    226230 *
    227231 * @param[in] device_id New device identifier.
    228  * @param[in] handle    Device driver handle.
     232 * @param[in] sid       NIC service ID.
    229233 * @param[in] mtu       Device maximum transmission unit.
    230234 *
    … …  
    234238 *
    235239 */
    236 static int eth_device_message(nic_device_id_t device_id, devman_handle_t handle,
     240static int eth_device_message(nic_device_id_t device_id, service_id_t sid,
    237241    size_t mtu)
    238242{
    … …  
    259263        device = eth_devices_find(&eth_globals.devices, device_id);
    260264        if (device) {
    261                 if (device->handle != handle) {
     265                if (device->sid != sid) {
    262266                        printf("Device %d already exists\n", device->device_id);
    263267                        fibril_rwlock_write_unlock(&eth_globals.devices_lock);
    … …  
    298302
    299303        device->device_id = device_id;
    300         device->handle = handle;
     304        device->sid = sid;
    301305        device->flags = 0;
    302306        if ((mtu > 0) && (mtu <= ETH_MAX_TAGGED_CONTENT(device->flags)))
    … …  
    335339       
    336340        /* Bind the device driver */
    337         device->sess = devman_device_connect(EXCHANGE_SERIALIZE, handle,
     341        device->sess = loc_service_connect(EXCHANGE_SERIALIZE, sid,
    338342            IPC_FLAG_BLOCKING);
    339343        if (device->sess == NULL) {
    … …  
    343347        }
    344348       
    345         nic_connect_to_nil(device->sess, SERVICE_ETHERNET, device_id);
     349        rc = nic_callback_create(device->sess, eth_nic_cb_connection, device);
     350        if (rc != EOK) {
     351                fibril_rwlock_write_unlock(&eth_globals.devices_lock);
     352                async_hangup(device->sess);
     353                free(device);
     354                return EIO;
     355        }
    346356       
    347357        /* Get hardware address */
    … …  
    362372        }
    363373       
    364         printf("%s: Device registered (id: %d, handle: %zu: mtu: %zu, "
     374        printf("%s: Device registered (id: %d, sid: %zu: mtu: %zu, "
    365375            "mac: " PRIMAC ", flags: 0x%x)\n", NAME,
    366             device->device_id, device->handle, device->mtu,
     376            device->device_id, device->sid, device->mtu,
    367377            ARGSMAC(device->addr.address), device->flags);
    368378
    … …  
    814824}
    815825
    816 static int eth_addr_changed(nic_device_id_t device_id)
     826static int eth_received(eth_device_t *device)
     827{
     828        void *data;
     829        size_t size;
     830        int rc;
     831       
     832        rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
     833        if (rc != EOK) {
     834                printf("%s: data_write_accept() failed\n", NAME);
     835                return rc;
     836        }
     837       
     838        packet_t *packet = packet_get_1_remote(eth_globals.net_sess, size);
     839        if (packet == NULL)
     840                return ENOMEM;
     841       
     842        void *pdata = packet_suffix(packet, size);
     843        memcpy(pdata, data, size);
     844        free(data);
     845       
     846        return nil_received_msg_local(device->device_id, packet);
     847}
     848
     849static int eth_addr_changed(eth_device_t *device)
    817850{
    818851        nic_address_t address;
    … …  
    832865
    833866        fibril_rwlock_write_lock(&eth_globals.devices_lock);
    834         /* An existing device? */
    835         eth_device_t *device = eth_devices_find(&eth_globals.devices, device_id);
    836         if (device) {
    837                 printf("Device %d changing address from " PRIMAC " to " PRIMAC "\n",
    838                         device_id, ARGSMAC(device->addr.address), ARGSMAC(address.address));
    839                 memcpy(&device->addr, &address, sizeof (nic_address_t));
    840                 fibril_rwlock_write_unlock(&eth_globals.devices_lock);
    841 
    842                 /* Notify all upper layer modules */
    843                 fibril_rwlock_read_lock(&eth_globals.protos_lock);
    844                 int index;
    845                 for (index = 0; index < eth_protos_count(&eth_globals.protos); index++) {
    846                         eth_proto_t *proto = eth_protos_get_index(&eth_globals.protos, index);
    847                         if (proto->sess != NULL) {
    848                                 il_addr_changed_msg(proto->sess, device->device_id,
    849                                                 ETH_ADDR, address.address);
    850                         }
    851                 }
    852 
    853                 fibril_rwlock_read_unlock(&eth_globals.protos_lock);
    854                 return EOK;
    855         } else {
    856                 return ENOENT;
    857         }
     867
     868        printf("Device %d changing address from " PRIMAC " to " PRIMAC "\n",
     869                device->device_id, ARGSMAC(device->addr.address),
     870                ARGSMAC(address.address));
     871        memcpy(&device->addr, &address, sizeof (nic_address_t));
     872        fibril_rwlock_write_unlock(&eth_globals.devices_lock);
     873
     874        /* Notify all upper layer modules */
     875        fibril_rwlock_read_lock(&eth_globals.protos_lock);
     876        int index;
     877        for (index = 0; index < eth_protos_count(&eth_globals.protos); index++) {
     878                eth_proto_t *proto = eth_protos_get_index(&eth_globals.protos, index);
     879                if (proto->sess != NULL) {
     880                        il_addr_changed_msg(proto->sess, device->device_id,
     881                                        ETH_ADDR, address.address);
     882                }
     883        }
     884
     885        fibril_rwlock_read_unlock(&eth_globals.protos_lock);
     886        return EOK;
    858887}
    859888
    … …  
    921950               
    922951                return EOK;
    923         case NET_NIL_DEVICE_STATE:
    924                 nil_device_state_msg_local(IPC_GET_DEVICE(*call), IPC_GET_STATE(*call));
    925                 async_answer_0(callid, EOK);
    926                 return EOK;
    927         case NET_NIL_RECEIVED:
    928                 rc = packet_translate_remote(eth_globals.net_sess, &packet,
    929                     IPC_GET_ARG2(*call));
    930                 if (rc == EOK)
    931                         rc = nil_received_msg_local(IPC_GET_ARG1(*call), packet);
    932                
    933                 async_answer_0(callid, (sysarg_t) rc);
    934                 return rc;
    935         case NET_NIL_ADDR_CHANGED:
    936                 rc = eth_addr_changed(IPC_GET_DEVICE(*call));
    937                 async_answer_0(callid, (sysarg_t) rc);
    938                 return rc;
    939952        }
    940953       
    941954        return ENOTSUP;
     955}
     956
     957static void eth_nic_cb_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
     958{
     959        eth_device_t *device = (eth_device_t *)arg;
     960        int rc;
     961       
     962        async_answer_0(iid, EOK);
     963       
     964        while (true) {
     965                ipc_call_t call;
     966                ipc_callid_t callid = async_get_call(&call);
     967               
     968                if (!IPC_GET_IMETHOD(call))
     969                        break;
     970               
     971                switch (IPC_GET_IMETHOD(call)) {
     972                case NIC_EV_DEVICE_STATE:
     973                        rc = eth_device_state(device, IPC_GET_ARG1(call));
     974                        async_answer_0(callid, (sysarg_t) rc);
     975                        break;
     976                case NIC_EV_RECEIVED:
     977                        rc = eth_received(device);
     978                        async_answer_0(callid, (sysarg_t) rc);
     979                        break;
     980                case NIC_EV_ADDR_CHANGED:
     981                        rc = eth_addr_changed(device);
     982                        async_answer_0(callid, (sysarg_t) rc);
     983                        break;
     984                default:
     985                        async_answer_0(callid, ENOTSUP);
     986                }
     987        }
    942988}
    943989

  • uspace/srv/net/nil/eth/eth.h

    r199112e4 rcfb79747  
    4141#include <async.h>
    4242#include <fibril_synch.h>
     43#include <ipc/loc.h>
    4344#include <ipc/services.h>
    4445#include <net/device.h>
    4546#include <adt/measured_strings.h>
    46 #include <devman.h>
    4747
    4848/** Ethernet address length. */
    … …  
    224224        nic_device_id_t device_id;
    225225        /** Device handle */
    226         devman_handle_t handle;
     226        service_id_t sid;
    227227        /** Driver session. */
    228228        async_sess_t *sess;

  • uspace/srv/net/nil/nildummy/nildummy.c

    r199112e4 rcfb79747  
    22 * Copyright (c) 2009 Lukas Mejdrech
    33 * Copyright (c) 2011 Radim Vansa
     4 * Copyright (c) 2011 Jiri Svoboda
    45 * All rights reserved.
    56 *
    … …  
    5354#include <packet_remote.h>
    5455#include <packet_client.h>
    55 #include <devman.h>
    5656#include <device/nic.h>
     57#include <loc.h>
    5758#include <nil_skel.h>
    5859#include "nildummy.h"
    … …  
    6970DEVICE_MAP_IMPLEMENT(nildummy_devices, nildummy_device_t);
    7071
    71 int nil_device_state_msg_local(nic_device_id_t device_id, sysarg_t state)
     72static void nildummy_nic_cb_conn(ipc_callid_t iid, ipc_call_t *icall,
     73    void *arg);
     74
     75static int nildummy_device_state(nildummy_device_t *device, sysarg_t state)
    7276{
    7377        fibril_rwlock_read_lock(&nildummy_globals.protos_lock);
    7478        if (nildummy_globals.proto.sess)
    75                 il_device_state_msg(nildummy_globals.proto.sess, device_id,
    76                     state, nildummy_globals.proto.service);
     79                il_device_state_msg(nildummy_globals.proto.sess,
     80                    device->device_id, state, nildummy_globals.proto.service);
    7781        fibril_rwlock_read_unlock(&nildummy_globals.protos_lock);
    7882       
    7983        return EOK;
     84}
     85
     86static int nildummy_addr_changed(nildummy_device_t *device)
     87{
     88        return ENOTSUP;
    8089}
    8190
    … …  
    115124 */
    116125static int nildummy_device_message(nic_device_id_t device_id,
    117     devman_handle_t handle, size_t mtu)
     126    service_id_t sid, size_t mtu)
    118127{
    119128        fibril_rwlock_write_lock(&nildummy_globals.devices_lock);
    … …  
    123132            nildummy_devices_find(&nildummy_globals.devices, device_id);
    124133        if (device) {
    125                 if (device->handle != handle) {
     134                if (device->sid != sid) {
    126135                        printf("Device %d exists, handles do not match\n",
    127136                            device->device_id);
    … …  
    158167       
    159168        device->device_id = device_id;
    160         device->handle = handle;
     169        device->sid = sid;
    161170        if (mtu > 0)
    162171                device->mtu = mtu;
    … …  
    165174       
    166175        /* Bind the device driver */
    167         device->sess = devman_device_connect(EXCHANGE_SERIALIZE, handle,
     176        device->sess = loc_service_connect(EXCHANGE_SERIALIZE, sid,
    168177            IPC_FLAG_BLOCKING);
    169178        if (device->sess == NULL) {
    … …  
    173182        }
    174183       
    175         nic_connect_to_nil(device->sess, SERVICE_NILDUMMY, device_id);
     184        int rc = nic_callback_create(device->sess, nildummy_nic_cb_conn,
     185            device);
     186        if (rc != EOK) {
     187                async_hangup(device->sess);
     188               
     189                return ENOENT;
     190        }
    176191       
    177192        /* Get hardware address */
    178         int rc = nic_get_address(device->sess, &device->addr);
     193        rc = nic_get_address(device->sess, &device->addr);
    179194        if (rc != EOK) {
    180195                fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
    … …  
    345360    services_t sender)
    346361{
    347         packet_t *p;
    348        
    349362        fibril_rwlock_read_lock(&nildummy_globals.devices_lock);
    350363       
    … …  
    356369        }
    357370       
    358         p = packet;
     371        packet_t *p = packet;
    359372        do {
    360373                nic_send_frame(device->sess, packet_get_data(p),
    … …  
    368381       
    369382        return EOK;
     383}
     384
     385static int nildummy_received(nildummy_device_t *device)
     386{
     387        void *data;
     388        size_t size;
     389        int rc;
     390
     391        rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
     392        if (rc != EOK)
     393                return rc;
     394
     395        packet_t *packet = packet_get_1_remote(nildummy_globals.net_sess, size);
     396        if (packet == NULL)
     397                return ENOMEM;
     398
     399        void *pdata = packet_suffix(packet, size);
     400        memcpy(pdata, data, size);
     401        free(pdata);
     402
     403        return nil_received_msg_local(device->device_id, packet);
    370404}
    371405
    … …  
    424458                *answer_count = 1;
    425459                return rc;
    426         case NET_NIL_DEVICE_STATE:
    427                 rc = nil_device_state_msg_local(IPC_GET_DEVICE(*call),
    428                     IPC_GET_STATE(*call));
    429                 async_answer_0(callid, (sysarg_t) rc);
    430                 return rc;
    431        
    432         case NET_NIL_RECEIVED:
    433                 rc = packet_translate_remote(nildummy_globals.net_sess, &packet,
    434                     IPC_GET_ARG2(*call));
    435                 if (rc == EOK)
    436                         rc = nil_received_msg_local(IPC_GET_ARG1(*call), packet);
    437                
    438                 async_answer_0(callid, (sysarg_t) rc);
    439                 return rc;
    440460        }
    441461       
    442462        return ENOTSUP;
    443463}
     464
     465static void nildummy_nic_cb_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
     466{
     467        nildummy_device_t *device = (nildummy_device_t *)arg;
     468        int rc;
     469       
     470        async_answer_0(iid, EOK);
     471       
     472        while (true) {
     473                ipc_call_t call;
     474                ipc_callid_t callid = async_get_call(&call);
     475               
     476                if (!IPC_GET_IMETHOD(call))
     477                        break;
     478               
     479                switch (IPC_GET_IMETHOD(call)) {
     480                case NIC_EV_DEVICE_STATE:
     481                        rc = nildummy_device_state(device, IPC_GET_ARG1(call));
     482                        async_answer_0(callid, (sysarg_t) rc);
     483                        break;
     484                case NIC_EV_RECEIVED:
     485                        rc = nildummy_received(device);
     486                        async_answer_0(callid, (sysarg_t) rc);
     487                        break;
     488                case NIC_EV_ADDR_CHANGED:
     489                        rc = nildummy_addr_changed(device);
     490                        async_answer_0(callid, (sysarg_t) rc);
     491                        break;
     492                default:
     493                        async_answer_0(callid, ENOTSUP);
     494                }
     495        }
     496}
     497
    444498
    445499int main(int argc, char *argv[])

  • uspace/srv/net/nil/nildummy/nildummy.h

    r199112e4 rcfb79747  
    4141#include <async.h>
    4242#include <fibril_synch.h>
     43#include <ipc/loc.h>
    4344#include <ipc/services.h>
    44 #include <ipc/devman.h>
    4545#include <net/device.h>
    4646
    … …  
    7878        /** Device identifier. */
    7979        nic_device_id_t device_id;
    80         /** Device driver handle. */
    81         devman_handle_t handle;
     80        /** Device service ID. */
     81        service_id_t sid;
    8282        /** Driver session. */
    8383        async_sess_t *sess;
Note: See TracChangeset for help on using the changeset viewer.