Changeset 948911d in mainline for uspace/srv/net


Ignore:
Timestamp:
2012-01-24T02:27:43Z (14 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
230385c
Parents:
8afeb04 (diff), 2df6f6fe (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:

Mainline changes.

Location:
uspace/srv/net
Files:
10 edited

Legend:

Unmodified
Added
Removed

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

    r8afeb04 r948911d  
    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

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

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

    r8afeb04 r948911d  
    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

    r8afeb04 r948911d  
    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

    r8afeb04 r948911d  
    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

    r8afeb04 r948911d  
    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 */
     98        service_id_t sid;  /**< Service ID */
    9999        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

    r8afeb04 r948911d  
    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(nic_device_id_t device_id, sysarg_t state)
    172176{
    173177        int index;
    … …  
    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, device_id,
     350            eth_nic_cb_connection, NULL);
     351        if (rc != EOK) {
     352                fibril_rwlock_write_unlock(&eth_globals.devices_lock);
     353                async_hangup(device->sess);
     354                free(device);
     355                return EIO;
     356        }
    346357       
    347358        /* Get hardware address */
    … …  
    362373        }
    363374       
    364         printf("%s: Device registered (id: %d, handle: %zu: mtu: %zu, "
     375        printf("%s: Device registered (id: %d, sid: %zu: mtu: %zu, "
    365376            "mac: " PRIMAC ", flags: 0x%x)\n", NAME,
    366             device->device_id, device->handle, device->mtu,
     377            device->device_id, device->sid, device->mtu,
    367378            ARGSMAC(device->addr.address), device->flags);
    368379
    … …  
    802813                        next = tmp;
    803814                } else {
     815                        nic_send_frame(device->sess, packet_get_data(next),
     816                            packet_get_data_length(next));
    804817                        next = pq_next(next);
    805818                }
    806819        } while (next);
    807820       
    808         /* Send packet queue */
    809         if (packet)
    810                 nic_send_message(device->sess, packet_get_id(packet));
     821        pq_release_remote(eth_globals.net_sess, packet_get_id(packet));
    811822       
    812823        fibril_rwlock_read_unlock(&eth_globals.devices_lock);
    813824        return EOK;
     825}
     826
     827static int eth_received(nic_device_id_t device_id)
     828{
     829        void *data;
     830        size_t size;
     831        int rc;
     832       
     833        rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
     834        if (rc != EOK) {
     835                printf("%s: data_write_accept() failed\n", NAME);
     836                return rc;
     837        }
     838       
     839        packet_t *packet = packet_get_1_remote(eth_globals.net_sess, size);
     840        if (packet == NULL)
     841                return ENOMEM;
     842       
     843        void *pdata = packet_suffix(packet, size);
     844        memcpy(pdata, data, size);
     845        free(data);
     846       
     847        return nil_received_msg_local(device_id, packet);
    814848}
    815849
    … …  
    921955               
    922956                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;
    939957        }
    940958       
    941959        return ENOTSUP;
     960}
     961
     962static void eth_nic_cb_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
     963{
     964        int rc;
     965       
     966        async_answer_0(iid, EOK);
     967       
     968        while (true) {
     969                ipc_call_t call;
     970                ipc_callid_t callid = async_get_call(&call);
     971               
     972                if (!IPC_GET_IMETHOD(call))
     973                        break;
     974               
     975                switch (IPC_GET_IMETHOD(call)) {
     976                case NIC_EV_DEVICE_STATE:
     977                        rc = eth_device_state(IPC_GET_ARG1(call),
     978                            IPC_GET_ARG2(call));
     979                        async_answer_0(callid, (sysarg_t) rc);
     980                        break;
     981                case NIC_EV_RECEIVED:
     982                        rc = eth_received(IPC_GET_ARG1(call));
     983                        async_answer_0(callid, (sysarg_t) rc);
     984                        break;
     985                case NIC_EV_ADDR_CHANGED:
     986                        rc = eth_addr_changed(IPC_GET_ARG1(call));
     987                        async_answer_0(callid, (sysarg_t) rc);
     988                        break;
     989                default:
     990                        async_answer_0(callid, ENOTSUP);
     991                }
     992        }
    942993}
    943994

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

    r8afeb04 r948911d  
    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

    r8afeb04 r948911d  
    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(nic_device_id_t device_id, sysarg_t state)
    7276{
    7377        fibril_rwlock_read_lock(&nildummy_globals.protos_lock);
    … …  
    7882       
    7983        return EOK;
     84}
     85
     86static int nildummy_addr_changed(nic_device_id_t device_id)
     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, device_id,
     185            nildummy_nic_cb_conn, NULL);
     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{
     362        packet_t *p;
     363       
    347364        fibril_rwlock_read_lock(&nildummy_globals.devices_lock);
    348365       
    … …  
    354371        }
    355372       
    356         /* Send packet queue */
    357         if (packet)
    358                 nic_send_message(device->sess, packet_get_id(packet));
     373        p = packet;
     374        do {
     375                nic_send_frame(device->sess, packet_get_data(p),
     376                    packet_get_data_length(p));
     377                p = pq_next(p);
     378        } while (p != NULL);
     379       
     380        pq_release_remote(nildummy_globals.net_sess, packet_get_id(packet));
    359381       
    360382        fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
    361383       
    362384        return EOK;
     385}
     386
     387static int nildummy_received(nic_device_id_t device_id)
     388{
     389        void *data;
     390        size_t size;
     391        int rc;
     392
     393        rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
     394        if (rc != EOK)
     395                return rc;
     396
     397        packet_t *packet = packet_get_1_remote(nildummy_globals.net_sess, size);
     398        if (packet == NULL)
     399                return ENOMEM;
     400
     401        void *pdata = packet_suffix(packet, size);
     402        memcpy(pdata, data, size);
     403        free(pdata);
     404
     405        return nil_received_msg_local(device_id, packet);
    363406}
    364407
    … …  
    417460                *answer_count = 1;
    418461                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;
    433462        }
    434463       
    435464        return ENOTSUP;
    436465}
     466
     467static void nildummy_nic_cb_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
     468{
     469        int rc;
     470       
     471        async_answer_0(iid, EOK);
     472       
     473        while (true) {
     474                ipc_call_t call;
     475                ipc_callid_t callid = async_get_call(&call);
     476               
     477                if (!IPC_GET_IMETHOD(call))
     478                        break;
     479               
     480                switch (IPC_GET_IMETHOD(call)) {
     481                case NIC_EV_DEVICE_STATE:
     482                        rc = nildummy_device_state(IPC_GET_ARG1(call),
     483                            IPC_GET_ARG2(call));
     484                        async_answer_0(callid, (sysarg_t) rc);
     485                        break;
     486                case NIC_EV_RECEIVED:
     487                        rc = nildummy_received(IPC_GET_ARG1(call));
     488                        async_answer_0(callid, (sysarg_t) rc);
     489                        break;
     490                case NIC_EV_ADDR_CHANGED:
     491                        rc = nildummy_addr_changed(IPC_GET_ARG1(call));
     492                        async_answer_0(callid, (sysarg_t) rc);
     493                        break;
     494                default:
     495                        async_answer_0(callid, ENOTSUP);
     496                }
     497        }
     498}
     499
    437500
    438501int main(int argc, char *argv[])

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

    r8afeb04 r948911d  
    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.