Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r49bd793b rffa2c8ef  
    11/*
    22 * Copyright (c) 2009 Lukas Mejdrech
    3  * Copyright (c) 2011 Radim Vansa
    43 * All rights reserved.
    54 *
    … …  
    3736 */
    3837
    39 #include <assert.h>
    4038#include <async.h>
    4139#include <malloc.h>
    … …  
    4644#include <ipc/net.h>
    4745#include <ipc/services.h>
     46
    4847#include <net/modules.h>
    4948#include <net/device.h>
    … …  
    5251#include <net/packet.h>
    5352#include <packet_remote.h>
    54 #include <packet_client.h>
    55 #include <devman.h>
    56 #include <device/nic.h>
     53#include <netif_remote.h>
    5754#include <nil_skel.h>
     55
    5856#include "nildummy.h"
    5957
    … …  
    6967DEVICE_MAP_IMPLEMENT(nildummy_devices, nildummy_device_t);
    7068
    71 int nil_device_state_msg_local(nic_device_id_t device_id, sysarg_t state)
     69int nil_device_state_msg_local(int nil_phone, device_id_t device_id, int state)
    7270{
    7371        fibril_rwlock_read_lock(&nildummy_globals.protos_lock);
    74         if (nildummy_globals.proto.sess)
    75                 il_device_state_msg(nildummy_globals.proto.sess, device_id,
     72        if (nildummy_globals.proto.phone)
     73                il_device_state_msg(nildummy_globals.proto.phone, device_id,
    7674                    state, nildummy_globals.proto.service);
    7775        fibril_rwlock_read_unlock(&nildummy_globals.protos_lock);
    … …  
    8078}
    8179
    82 int nil_initialize(async_sess_t *sess)
     80int nil_initialize(int net_phone)
    8381{
    8482        fibril_rwlock_initialize(&nildummy_globals.devices_lock);
    … …  
    8785        fibril_rwlock_write_lock(&nildummy_globals.protos_lock);
    8886       
    89         nildummy_globals.net_sess = sess;
    90         nildummy_globals.proto.sess = NULL;
     87        nildummy_globals.net_phone = net_phone;
     88        nildummy_globals.proto.phone = 0;
    9189        int rc = nildummy_devices_initialize(&nildummy_globals.devices);
    9290       
    … …  
    9593       
    9694        return rc;
     95}
     96
     97/** Process IPC messages from the registered device driver modules
     98 *
     99 * @param[in]     iid   Message identifier.
     100 * @param[in,out] icall Message parameters.
     101 *
     102 */
     103static void nildummy_receiver(ipc_callid_t iid, ipc_call_t *icall)
     104{
     105        packet_t *packet;
     106        int rc;
     107       
     108        while (true) {
     109                switch (IPC_GET_IMETHOD(*icall)) {
     110                case NET_NIL_DEVICE_STATE:
     111                        rc = nil_device_state_msg_local(0,
     112                            IPC_GET_DEVICE(*icall), IPC_GET_STATE(*icall));
     113                        async_answer_0(iid, (sysarg_t) rc);
     114                        break;
     115               
     116                case NET_NIL_RECEIVED:
     117                        rc = packet_translate_remote(nildummy_globals.net_phone,
     118                            &packet, IPC_GET_PACKET(*icall));
     119                        if (rc == EOK)
     120                                rc = nil_received_msg_local(0,
     121                                    IPC_GET_DEVICE(*icall), packet, 0);
     122                       
     123                        async_answer_0(iid, (sysarg_t) rc);
     124                        break;
     125               
     126                default:
     127                        async_answer_0(iid, (sysarg_t) ENOTSUP);
     128                }
     129               
     130                iid = async_get_call(icall);
     131        }
    97132}
    98133
    … …  
    114149 *
    115150 */
    116 static int nildummy_device_message(nic_device_id_t device_id,
    117     devman_handle_t handle, size_t mtu)
     151static int nildummy_device_message(device_id_t device_id, services_t service,
     152    size_t mtu)
    118153{
    119154        fibril_rwlock_write_lock(&nildummy_globals.devices_lock);
    … …  
    123158            nildummy_devices_find(&nildummy_globals.devices, device_id);
    124159        if (device) {
    125                 if (device->handle != handle) {
    126                         printf("Device %d exists, handles do not match\n",
    127                             device->device_id);
    128                         fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
     160                if (device->service != service) {
     161                        printf("Device %d already exists\n", device->device_id);
     162                        fibril_rwlock_write_unlock(
     163                            &nildummy_globals.devices_lock);
    129164                        return EEXIST;
    130165                }
    … …  
    136171                        device->mtu = NET_DEFAULT_MTU;
    137172               
    138                 printf("Device %d already exists (mtu: %zu)\n", device->device_id,
    139                     device->mtu);
     173                printf("Device %d already exists:\tMTU\t= %zu\n",
     174                    device->device_id, device->mtu);
    140175                fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
    141176               
    142177                /* Notify the upper layer module */
    143178                fibril_rwlock_read_lock(&nildummy_globals.protos_lock);
    144                 if (nildummy_globals.proto.sess) {
    145                         il_mtu_changed_msg(nildummy_globals.proto.sess,
     179                if (nildummy_globals.proto.phone) {
     180                        il_mtu_changed_msg(nildummy_globals.proto.phone,
    146181                            device->device_id, device->mtu,
    147182                            nildummy_globals.proto.service);
    … …  
    158193       
    159194        device->device_id = device_id;
    160         device->handle = handle;
     195        device->service = service;
    161196        if (mtu > 0)
    162197                device->mtu = mtu;
    163198        else
    164199                device->mtu = NET_DEFAULT_MTU;
    165        
     200
    166201        /* Bind the device driver */
    167         device->sess = devman_device_connect(EXCHANGE_SERIALIZE, handle,
    168             IPC_FLAG_BLOCKING);
    169         if (device->sess == NULL) {
     202        device->phone = netif_bind_service(device->service, device->device_id,
     203            SERVICE_ETHERNET, nildummy_receiver);
     204        if (device->phone < 0) {
    170205                fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
    171206                free(device);
    172                 return ENOENT;
    173         }
    174        
    175         nic_connect_to_nil(device->sess, SERVICE_NILDUMMY, device_id);
     207                return device->phone;
     208        }
    176209       
    177210        /* Get hardware address */
    178         int rc = nic_get_address(device->sess, &device->addr);
     211        int rc = netif_get_addr_req(device->phone, device->device_id,
     212            &device->addr, &device->addr_data);
    179213        if (rc != EOK) {
    180214                fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
    … …  
    182216                return rc;
    183217        }
    184        
    185         device->addr_len = ETH_ADDR;
    186218       
    187219        /* Add to the cache */
    … …  
    190222        if (index < 0) {
    191223                fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
     224                free(device->addr);
     225                free(device->addr_data);
    192226                free(device);
    193227                return index;
    194228        }
    195229       
    196         printf("%s: Device registered (id: %d, mtu: %zu)\n", NAME,
    197             device->device_id, device->mtu);
     230        printf("%s: Device registered (id: %d, service: %d, mtu: %zu)\n",
     231            NAME, device->device_id, device->service, device->mtu);
    198232        fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
    199233        return EOK;
    … …  
    210244 *
    211245 */
    212 static int nildummy_addr_message(nic_device_id_t device_id, size_t *addrlen)
    213 {
    214         if (!addrlen)
     246static int nildummy_addr_message(device_id_t device_id,
     247    measured_string_t **address)
     248{
     249        if (!address)
    215250                return EBADMEM;
    216251       
    … …  
    224259        }
    225260       
    226         ipc_callid_t callid;
    227         size_t max_len;
    228         if (!async_data_read_receive(&callid, &max_len)) {
    229                 fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
    230                 return EREFUSED;
    231         }
    232        
    233         if (max_len < device->addr_len) {
    234                 fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
    235                 async_data_read_finalize(callid, NULL, 0);
    236                 return ELIMIT;
    237         }
    238        
    239         int rc = async_data_read_finalize(callid,
    240             (uint8_t *) &device->addr.address, device->addr_len);
    241         if (rc != EOK) {
    242                 fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
    243                 return rc;
    244         }
    245        
    246         *addrlen = device->addr_len;
     261        *address = device->addr;
    247262       
    248263        fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
    249         return EOK;
     264       
     265        return (*address) ? EOK : ENOENT;
    250266}
    251267
    … …  
    263279 *
    264280 */
    265 static int nildummy_packet_space_message(nic_device_id_t device_id,
    266     size_t *addr_len, size_t *prefix, size_t *content, size_t *suffix)
     281static int nildummy_packet_space_message(device_id_t device_id, size_t *addr_len,
     282    size_t *prefix, size_t *content, size_t *suffix)
    267283{
    268284        if ((!addr_len) || (!prefix) || (!content) || (!suffix))
    … …  
    288304}
    289305
    290 int nil_received_msg_local(nic_device_id_t device_id, packet_t *packet)
     306int nil_received_msg_local(int nil_phone, device_id_t device_id,
     307    packet_t *packet, services_t target)
    291308{
    292309        fibril_rwlock_read_lock(&nildummy_globals.protos_lock);
    293310       
    294         if (nildummy_globals.proto.sess) {
     311        if (nildummy_globals.proto.phone) {
    295312                do {
    296313                        packet_t *next = pq_detach(packet);
    297                         il_received_msg(nildummy_globals.proto.sess, device_id,
     314                        il_received_msg(nildummy_globals.proto.phone, device_id,
    298315                            packet, nildummy_globals.proto.service);
    299316                        packet = next;
    … …  
    311328 *
    312329 * @param[in] service Module service.
    313  * @param[in] sess    Service session.
     330 * @param[in] phone   Service phone.
    314331 *
    315332 * @return EOK on success.
    … …  
    318335 *
    319336 */
    320 static int nildummy_register_message(services_t service, async_sess_t *sess)
     337static int nildummy_register_message(services_t service, int phone)
    321338{
    322339        fibril_rwlock_write_lock(&nildummy_globals.protos_lock);
    323340        nildummy_globals.proto.service = service;
    324         nildummy_globals.proto.sess = sess;
    325        
    326         printf("%s: Protocol registered (service: %#x)\n",
    327             NAME, nildummy_globals.proto.service);
     341        nildummy_globals.proto.phone = phone;
     342       
     343        printf("%s: Protocol registered (service: %d, phone: %d)\n",
     344            NAME, nildummy_globals.proto.service, nildummy_globals.proto.phone);
    328345       
    329346        fibril_rwlock_write_unlock(&nildummy_globals.protos_lock);
    … …  
    342359 *
    343360 */
    344 static int nildummy_send_message(nic_device_id_t device_id, packet_t *packet,
     361static int nildummy_send_message(device_id_t device_id, packet_t *packet,
    345362    services_t sender)
    346363{
    … …  
    356373        /* Send packet queue */
    357374        if (packet)
    358                 nic_send_message(device->sess, packet_get_id(packet));
     375                netif_send_msg(device->phone, device_id, packet,
     376                    SERVICE_NILDUMMY);
    359377       
    360378        fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
    … …  
    366384    ipc_call_t *answer, size_t *answer_count)
    367385{
     386        measured_string_t *address;
    368387        packet_t *packet;
    369388        size_t addrlen;
    … …  
    374393       
    375394        *answer_count = 0;
    376        
    377         if (!IPC_GET_IMETHOD(*call))
     395        switch (IPC_GET_IMETHOD(*call)) {
     396        case IPC_M_PHONE_HUNGUP:
    378397                return EOK;
    379398       
    380         async_sess_t *callback =
    381             async_callback_receive_start(EXCHANGE_SERIALIZE, call);
    382         if (callback)
    383                 return nildummy_register_message(NIL_GET_PROTO(*call), callback);
    384        
    385         switch (IPC_GET_IMETHOD(*call)) {
    386399        case NET_NIL_DEVICE:
    387400                return nildummy_device_message(IPC_GET_DEVICE(*call),
    388                     IPC_GET_DEVICE_HANDLE(*call), IPC_GET_MTU(*call));
     401                    IPC_GET_SERVICE(*call), IPC_GET_MTU(*call));
    389402       
    390403        case NET_NIL_SEND:
    391                 rc = packet_translate_remote(nildummy_globals.net_sess,
     404                rc = packet_translate_remote(nildummy_globals.net_phone,
    392405                    &packet, IPC_GET_PACKET(*call));
    393406                if (rc != EOK)
    … …  
    409422       
    410423        case NET_NIL_ADDR:
    411         case NET_NIL_BROADCAST_ADDR:
    412                 rc = nildummy_addr_message(IPC_GET_DEVICE(*call), &addrlen);
     424                rc = nildummy_addr_message(IPC_GET_DEVICE(*call), &address);
    413425                if (rc != EOK)
    414426                        return rc;
    415                
    416                 IPC_SET_ADDR(*answer, addrlen);
    417                 *answer_count = 1;
    418                 return rc;
    419         case NET_NIL_DEVICE_STATE:
    420                 rc = nil_device_state_msg_local(IPC_GET_DEVICE(*call),
    421                     IPC_GET_STATE(*call));
    422                 async_answer_0(callid, (sysarg_t) rc);
    423                 return rc;
    424        
    425         case NET_NIL_RECEIVED:
    426                 rc = packet_translate_remote(nildummy_globals.net_sess, &packet,
    427                     IPC_GET_ARG2(*call));
    428                 if (rc == EOK)
    429                         rc = nil_received_msg_local(IPC_GET_ARG1(*call), packet);
    430                
    431                 async_answer_0(callid, (sysarg_t) rc);
    432                 return rc;
     427                return measured_strings_reply(address, 1);
     428       
     429        case NET_NIL_BROADCAST_ADDR:
     430                rc = nildummy_addr_message(IPC_GET_DEVICE(*call), &address);
     431                if (rc != EOK)
     432                        return rc;
     433                return measured_strings_reply(address, 1);
     434       
     435        case IPC_M_CONNECT_TO_ME:
     436                return nildummy_register_message(NIL_GET_PROTO(*call),
     437                    IPC_GET_PHONE(*call));
    433438        }
    434439       
Note: See TracChangeset for help on using the changeset viewer.