Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rffa2c8ef r49bd793b  
    11/*
    22 * Copyright (c) 2009 Lukas Mejdrech
     3 * Copyright (c) 2011 Radim Vansa
    34 * All rights reserved.
    45 *
    … …  
    3637 */
    3738
     39#include <assert.h>
    3840#include <async.h>
    3941#include <malloc.h>
    … …  
    4446#include <ipc/net.h>
    4547#include <ipc/services.h>
    46 
    4748#include <net/modules.h>
    4849#include <net/device.h>
    … …  
    5152#include <net/packet.h>
    5253#include <packet_remote.h>
    53 #include <netif_remote.h>
     54#include <packet_client.h>
     55#include <devman.h>
     56#include <device/nic.h>
    5457#include <nil_skel.h>
    55 
    5658#include "nildummy.h"
    5759
    … …  
    6769DEVICE_MAP_IMPLEMENT(nildummy_devices, nildummy_device_t);
    6870
    69 int nil_device_state_msg_local(int nil_phone, device_id_t device_id, int state)
     71int nil_device_state_msg_local(nic_device_id_t device_id, sysarg_t state)
    7072{
    7173        fibril_rwlock_read_lock(&nildummy_globals.protos_lock);
    72         if (nildummy_globals.proto.phone)
    73                 il_device_state_msg(nildummy_globals.proto.phone, device_id,
     74        if (nildummy_globals.proto.sess)
     75                il_device_state_msg(nildummy_globals.proto.sess, device_id,
    7476                    state, nildummy_globals.proto.service);
    7577        fibril_rwlock_read_unlock(&nildummy_globals.protos_lock);
    … …  
    7880}
    7981
    80 int nil_initialize(int net_phone)
     82int nil_initialize(async_sess_t *sess)
    8183{
    8284        fibril_rwlock_initialize(&nildummy_globals.devices_lock);
    … …  
    8587        fibril_rwlock_write_lock(&nildummy_globals.protos_lock);
    8688       
    87         nildummy_globals.net_phone = net_phone;
    88         nildummy_globals.proto.phone = 0;
     89        nildummy_globals.net_sess = sess;
     90        nildummy_globals.proto.sess = NULL;
    8991        int rc = nildummy_devices_initialize(&nildummy_globals.devices);
    9092       
    … …  
    9395       
    9496        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  */
    103 static 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         }
    13297}
    13398
    … …  
    149114 *
    150115 */
    151 static int nildummy_device_message(device_id_t device_id, services_t service,
    152     size_t mtu)
     116static int nildummy_device_message(nic_device_id_t device_id,
     117    devman_handle_t handle, size_t mtu)
    153118{
    154119        fibril_rwlock_write_lock(&nildummy_globals.devices_lock);
    … …  
    158123            nildummy_devices_find(&nildummy_globals.devices, device_id);
    159124        if (device) {
    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);
     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);
    164129                        return EEXIST;
    165130                }
    … …  
    171136                        device->mtu = NET_DEFAULT_MTU;
    172137               
    173                 printf("Device %d already exists:\tMTU\t= %zu\n",
    174                     device->device_id, device->mtu);
     138                printf("Device %d already exists (mtu: %zu)\n", device->device_id,
     139                    device->mtu);
    175140                fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
    176141               
    177142                /* Notify the upper layer module */
    178143                fibril_rwlock_read_lock(&nildummy_globals.protos_lock);
    179                 if (nildummy_globals.proto.phone) {
    180                         il_mtu_changed_msg(nildummy_globals.proto.phone,
     144                if (nildummy_globals.proto.sess) {
     145                        il_mtu_changed_msg(nildummy_globals.proto.sess,
    181146                            device->device_id, device->mtu,
    182147                            nildummy_globals.proto.service);
    … …  
    193158       
    194159        device->device_id = device_id;
    195         device->service = service;
     160        device->handle = handle;
    196161        if (mtu > 0)
    197162                device->mtu = mtu;
    198163        else
    199164                device->mtu = NET_DEFAULT_MTU;
    200 
     165       
    201166        /* Bind the device driver */
    202         device->phone = netif_bind_service(device->service, device->device_id,
    203             SERVICE_ETHERNET, nildummy_receiver);
    204         if (device->phone < 0) {
     167        device->sess = devman_device_connect(EXCHANGE_SERIALIZE, handle,
     168            IPC_FLAG_BLOCKING);
     169        if (device->sess == NULL) {
    205170                fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
    206171                free(device);
    207                 return device->phone;
    208         }
     172                return ENOENT;
     173        }
     174       
     175        nic_connect_to_nil(device->sess, SERVICE_NILDUMMY, device_id);
    209176       
    210177        /* Get hardware address */
    211         int rc = netif_get_addr_req(device->phone, device->device_id,
    212             &device->addr, &device->addr_data);
     178        int rc = nic_get_address(device->sess, &device->addr);
    213179        if (rc != EOK) {
    214180                fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
    … …  
    216182                return rc;
    217183        }
     184       
     185        device->addr_len = ETH_ADDR;
    218186       
    219187        /* Add to the cache */
    … …  
    222190        if (index < 0) {
    223191                fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
    224                 free(device->addr);
    225                 free(device->addr_data);
    226192                free(device);
    227193                return index;
    228194        }
    229195       
    230         printf("%s: Device registered (id: %d, service: %d, mtu: %zu)\n",
    231             NAME, device->device_id, device->service, device->mtu);
     196        printf("%s: Device registered (id: %d, mtu: %zu)\n", NAME,
     197            device->device_id, device->mtu);
    232198        fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
    233199        return EOK;
    … …  
    244210 *
    245211 */
    246 static int nildummy_addr_message(device_id_t device_id,
    247     measured_string_t **address)
    248 {
    249         if (!address)
     212static int nildummy_addr_message(nic_device_id_t device_id, size_t *addrlen)
     213{
     214        if (!addrlen)
    250215                return EBADMEM;
    251216       
    … …  
    259224        }
    260225       
    261         *address = device->addr;
     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;
    262247       
    263248        fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
    264        
    265         return (*address) ? EOK : ENOENT;
     249        return EOK;
    266250}
    267251
    … …  
    279263 *
    280264 */
    281 static int nildummy_packet_space_message(device_id_t device_id, size_t *addr_len,
    282     size_t *prefix, size_t *content, size_t *suffix)
     265static 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)
    283267{
    284268        if ((!addr_len) || (!prefix) || (!content) || (!suffix))
    … …  
    304288}
    305289
    306 int nil_received_msg_local(int nil_phone, device_id_t device_id,
    307     packet_t *packet, services_t target)
     290int nil_received_msg_local(nic_device_id_t device_id, packet_t *packet)
    308291{
    309292        fibril_rwlock_read_lock(&nildummy_globals.protos_lock);
    310293       
    311         if (nildummy_globals.proto.phone) {
     294        if (nildummy_globals.proto.sess) {
    312295                do {
    313296                        packet_t *next = pq_detach(packet);
    314                         il_received_msg(nildummy_globals.proto.phone, device_id,
     297                        il_received_msg(nildummy_globals.proto.sess, device_id,
    315298                            packet, nildummy_globals.proto.service);
    316299                        packet = next;
    … …  
    328311 *
    329312 * @param[in] service Module service.
    330  * @param[in] phone   Service phone.
     313 * @param[in] sess    Service session.
    331314 *
    332315 * @return EOK on success.
    … …  
    335318 *
    336319 */
    337 static int nildummy_register_message(services_t service, int phone)
     320static int nildummy_register_message(services_t service, async_sess_t *sess)
    338321{
    339322        fibril_rwlock_write_lock(&nildummy_globals.protos_lock);
    340323        nildummy_globals.proto.service = 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);
     324        nildummy_globals.proto.sess = sess;
     325       
     326        printf("%s: Protocol registered (service: %#x)\n",
     327            NAME, nildummy_globals.proto.service);
    345328       
    346329        fibril_rwlock_write_unlock(&nildummy_globals.protos_lock);
    … …  
    359342 *
    360343 */
    361 static int nildummy_send_message(device_id_t device_id, packet_t *packet,
     344static int nildummy_send_message(nic_device_id_t device_id, packet_t *packet,
    362345    services_t sender)
    363346{
    … …  
    373356        /* Send packet queue */
    374357        if (packet)
    375                 netif_send_msg(device->phone, device_id, packet,
    376                     SERVICE_NILDUMMY);
     358                nic_send_message(device->sess, packet_get_id(packet));
    377359       
    378360        fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
    … …  
    384366    ipc_call_t *answer, size_t *answer_count)
    385367{
    386         measured_string_t *address;
    387368        packet_t *packet;
    388369        size_t addrlen;
    … …  
    393374       
    394375        *answer_count = 0;
     376       
     377        if (!IPC_GET_IMETHOD(*call))
     378                return EOK;
     379       
     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       
    395385        switch (IPC_GET_IMETHOD(*call)) {
    396         case IPC_M_PHONE_HUNGUP:
    397                 return EOK;
    398        
    399386        case NET_NIL_DEVICE:
    400387                return nildummy_device_message(IPC_GET_DEVICE(*call),
    401                     IPC_GET_SERVICE(*call), IPC_GET_MTU(*call));
     388                    IPC_GET_DEVICE_HANDLE(*call), IPC_GET_MTU(*call));
    402389       
    403390        case NET_NIL_SEND:
    404                 rc = packet_translate_remote(nildummy_globals.net_phone,
     391                rc = packet_translate_remote(nildummy_globals.net_sess,
    405392                    &packet, IPC_GET_PACKET(*call));
    406393                if (rc != EOK)
    … …  
    422409       
    423410        case NET_NIL_ADDR:
    424                 rc = nildummy_addr_message(IPC_GET_DEVICE(*call), &address);
     411        case NET_NIL_BROADCAST_ADDR:
     412                rc = nildummy_addr_message(IPC_GET_DEVICE(*call), &addrlen);
    425413                if (rc != EOK)
    426414                        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));
     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;
    438433        }
    439434       
Note: See TracChangeset for help on using the changeset viewer.