Changeset 609243f4 in mainline for uspace/srv/net/il


Ignore:
Timestamp:
2011-10-07T15:46:01Z (14 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
e2c50e1
Parents:
f51b1d3
Message:

cherrypick general networking improvements from lp:~helenos-nicf/helenos/nicf (after sanitization)
remove obsolete networking drivers
this renders the networking non-functional for the time being

Location:
uspace/srv/net/il
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/il/arp/arp.c

    rf51b1d3 r609243f4  
    174174                    count);
    175175               
    176                 if (device) {
     176                if (device)
    177177                        arp_clear_device(device);
    178                         if (device->addr_data)
    179                                 free(device->addr_data);
    180                        
    181                         if (device->broadcast_data)
    182                                 free(device->broadcast_data);
    183                 }
    184178        }
    185179       
    … …  
    190184}
    191185
    192 static int arp_clear_address_req(device_id_t device_id, services_t protocol,
    193     measured_string_t *address)
     186static int arp_clear_address_req(nic_device_id_t device_id,
     187    services_t protocol, measured_string_t *address)
    194188{
    195189        fibril_mutex_lock(&arp_globals.lock);
    … …  
    218212}
    219213
    220 static int arp_clear_device_req(device_id_t device_id)
     214static int arp_clear_device_req(nic_device_id_t device_id)
    221215{
    222216        fibril_mutex_lock(&arp_globals.lock);
    … …  
    289283 *
    290284 */
    291 static int arp_receive_message(device_id_t device_id, packet_t *packet)
     285static int arp_receive_message(nic_device_id_t device_id, packet_t *packet)
    292286{
    293287        int rc;
    … …  
    365359                        memcpy(src_proto, proto->addr->value,
    366360                            header->protocol_length);
    367                         memcpy(src_hw, device->addr->value,
     361                        memcpy(src_hw, device->addr,
    368362                            device->packet_dimension.addr_len);
    369363                        memcpy(des_hw, trans->hw_addr->value,
    … …  
    393387 *
    394388 */
    395 static int arp_mtu_changed_message(device_id_t device_id, size_t mtu)
     389static int arp_mtu_changed_message(nic_device_id_t device_id, size_t mtu)
    396390{
    397391        fibril_mutex_lock(&arp_globals.lock);
    … …  
    409403        printf("%s: Device %d changed MTU to %zu\n", NAME, device_id, mtu);
    410404       
     405        return EOK;
     406}
     407
     408static int arp_addr_changed_message(nic_device_id_t device_id)
     409{
     410        uint8_t addr_buffer[NIC_MAX_ADDRESS_LENGTH];
     411        size_t length;
     412        ipc_callid_t data_callid;
     413        if (!async_data_write_receive(&data_callid, &length)) {
     414                async_answer_0(data_callid, EINVAL);
     415                return EINVAL;
     416        }
     417        if (length > NIC_MAX_ADDRESS_LENGTH) {
     418                async_answer_0(data_callid, ELIMIT);
     419                return ELIMIT;
     420        }
     421        if (async_data_write_finalize(data_callid, addr_buffer, length) != EOK) {
     422                return EINVAL;
     423        }
     424
     425        fibril_mutex_lock(&arp_globals.lock);
     426
     427        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
     428        if (!device) {
     429                fibril_mutex_unlock(&arp_globals.lock);
     430                return ENOENT;
     431        }
     432
     433        memcpy(device->addr, addr_buffer, length);
     434        device->addr_len = length;
     435
     436        fibril_mutex_unlock(&arp_globals.lock);
    411437        return EOK;
    412438}
    … …  
    456482                        async_answer_0(iid, (sysarg_t) rc);
    457483                        break;
     484                case NET_IL_ADDR_CHANGED:
     485                        rc = arp_addr_changed_message(IPC_GET_DEVICE(*icall));
     486                        async_answer_0(iid, (sysarg_t) rc);
    458487               
    459488                default:
    … …  
    483512 *
    484513 */
    485 static int arp_device_message(device_id_t device_id, services_t service,
     514static int arp_device_message(nic_device_id_t device_id, services_t service,
    486515    services_t protocol, measured_string_t *address)
    487516{
    … …  
    586615               
    587616                /* Get hardware address */
    588                 rc = nil_get_addr_req(device->sess, device_id, &device->addr,
    589                     &device->addr_data);
    590                 if (rc != EOK) {
     617                int len = nil_get_addr_req(device->sess, device_id, device->addr,
     618                    NIC_MAX_ADDRESS_LENGTH);
     619                if (len < 0) {
    591620                        fibril_mutex_unlock(&arp_globals.lock);
    592621                        arp_protos_destroy(&device->protos, free);
    593622                        free(device);
    594                         return rc;
    595                 }
     623                        return len;
     624                }
     625               
     626                device->addr_len = len;
    596627               
    597628                /* Get broadcast address */
    598                 rc = nil_get_broadcast_addr_req(device->sess, device_id,
    599                     &device->broadcast_addr, &device->broadcast_data);
    600                 if (rc != EOK) {
    601                         fibril_mutex_unlock(&arp_globals.lock);
    602                         free(device->addr);
    603                         free(device->addr_data);
     629                len = nil_get_broadcast_addr_req(device->sess, device_id,
     630                    device->broadcast_addr, NIC_MAX_ADDRESS_LENGTH);
     631                if (len < 0) {
     632                        fibril_mutex_unlock(&arp_globals.lock);
    604633                        arp_protos_destroy(&device->protos, free);
    605634                        free(device);
    606                         return rc;
    607                 }
     635                        return len;
     636                }
     637               
     638                device->broadcast_addr_len = len;
    608639               
    609640                rc = arp_cache_add(&arp_globals.cache, device->device_id,
    … …  
    611642                if (rc != EOK) {
    612643                        fibril_mutex_unlock(&arp_globals.lock);
    613                         free(device->addr);
    614                         free(device->addr_data);
    615                         free(device->broadcast_addr);
    616                         free(device->broadcast_data);
    617644                        arp_protos_destroy(&device->protos, free);
    618645                        free(device);
    … …  
    640667}
    641668
    642 static int arp_send_request(device_id_t device_id, services_t protocol,
     669static int arp_send_request(nic_device_id_t device_id, services_t protocol,
    643670    measured_string_t *target, arp_device_t *device, arp_proto_t *proto)
    644671{
    645672        /* ARP packet content size = header + (address + translation) * 2 */
    646         size_t length = 8 + 2 * (proto->addr->length + device->addr->length);
     673        size_t length = 8 + 2 * (proto->addr->length + device->addr_len);
    647674        if (length > device->packet_dimension.content)
    648675                return ELIMIT;
    … …  
    661688       
    662689        header->hardware = htons(device->hardware);
    663         header->hardware_length = (uint8_t) device->addr->length;
     690        header->hardware_length = (uint8_t) device->addr_len;
    664691        header->protocol = htons(protocol_map(device->service, protocol));
    665692        header->protocol_length = (uint8_t) proto->addr->length;
    … …  
    667694       
    668695        length = sizeof(arp_header_t);
    669        
    670         memcpy(((uint8_t *) header) + length, device->addr->value,
    671             device->addr->length);
    672         length += device->addr->length;
     696        memcpy(((uint8_t *) header) + length, device->addr,
     697            device->addr_len);
     698        length += device->addr_len;
    673699        memcpy(((uint8_t *) header) + length, proto->addr->value,
    674700            proto->addr->length);
    675701        length += proto->addr->length;
    676         bzero(((uint8_t *) header) + length, device->addr->length);
    677         length += device->addr->length;
     702        bzero(((uint8_t *) header) + length, device->addr_len);
     703        length += device->addr_len;
    678704        memcpy(((uint8_t *) header) + length, target->value, target->length);
    679        
    680         int rc = packet_set_addr(packet, (uint8_t *) device->addr->value,
    681             (uint8_t *) device->broadcast_addr->value, device->addr->length);
     705
     706        int rc = packet_set_addr(packet, device->addr, device->broadcast_addr,
     707            device->addr_len);
    682708        if (rc != EOK) {
    683709                pq_release_remote(arp_globals.net_sess, packet_get_id(packet));
    … …  
    704730 *
    705731 */
    706 static int arp_translate_message(device_id_t device_id, services_t protocol,
     732static int arp_translate_message(nic_device_id_t device_id, services_t protocol,
    707733    measured_string_t *target, measured_string_t **translation)
    708734{

  • uspace/srv/net/il/arp/arp.h

    rf51b1d3 r609243f4  
    9292struct arp_device {
    9393        /** Actual device hardware address. */
    94         measured_string_t *addr;
    95         /** Actual device hardware address data. */
    96         uint8_t *addr_data;
     94        uint8_t addr[NIC_MAX_ADDRESS_LENGTH];
     95        /** Actual device hardware address length. */
     96        size_t addr_len;
    9797        /** Broadcast device hardware address. */
    98         measured_string_t *broadcast_addr;
    99         /** Broadcast device hardware address data. */
    100         uint8_t *broadcast_data;
     98        uint8_t broadcast_addr[NIC_MAX_ADDRESS_LENGTH];
     99        /** Broadcast device hardware address length. */
     100        size_t broadcast_addr_len;
    101101        /** Device identifier. */
    102         device_id_t device_id;
     102        nic_device_id_t device_id;
    103103        /** Hardware type. */
    104104        hw_type_t hardware;

  • uspace/srv/net/il/ip/ip.c

    rf51b1d3 r609243f4  
    482482}
    483483
    484 static int ip_device_req_local(device_id_t device_id, services_t netif)
     484static int ip_device_req_local(nic_device_id_t device_id, services_t netif)
    485485{
    486486        ip_netif_t *ip_netif;
    … …  
    501501        ip_netif->device_id = device_id;
    502502        ip_netif->service = netif;
    503         ip_netif->state = NETIF_STOPPED;
     503        ip_netif->state = NIC_STATE_STOPPED;
    504504
    505505        fibril_rwlock_write_lock(&ip_globals.netifs_lock);
    … …  
    594594        while (index >= 0) {
    595595                netif = ip_netifs_get_index(&ip_globals.netifs, index);
    596                 if (netif && (netif->state == NETIF_ACTIVE)) {
     596                if (netif && (netif->state == NIC_STATE_ACTIVE)) {
    597597                        route = ip_netif_find_route(netif, destination);
    598598                        if (route)
    … …  
    11421142}
    11431143
    1144 static int ip_send_msg_local(device_id_t device_id, packet_t *packet,
     1144static int ip_send_msg_local(nic_device_id_t device_id, packet_t *packet,
    11451145    services_t sender, services_t error)
    11461146{
    … …  
    12581258 * @return              ENOENT if device is not found.
    12591259 */
    1260 static int ip_device_state_message(device_id_t device_id, device_state_t state)
     1260static int ip_device_state_message(nic_device_id_t device_id,
     1261    nic_device_state_t state)
    12611262{
    12621263        ip_netif_t *netif;
    … …  
    12721273        fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
    12731274
    1274         printf("%s: Device %d changed state to %d\n", NAME, device_id, state);
     1275        printf("%s: Device %d changed state to '%s'\n", NAME, device_id,
     1276            nic_device_state_to_string(state));
    12751277
    12761278        return EOK;
    … …  
    13121314 *                      tl_received_msg() function.
    13131315 */
    1314 static int ip_deliver_local(device_id_t device_id, packet_t *packet,
     1316static int ip_deliver_local(nic_device_id_t device_id, packet_t *packet,
    13151317    ip_header_t *header, services_t error)
    13161318{
    … …  
    14131415 *                      is disabled.
    14141416 */
    1415 static int ip_process_packet(device_id_t device_id, packet_t *packet)
     1417static int ip_process_packet(nic_device_id_t device_id, packet_t *packet)
    14161418{
    14171419        ip_header_t *header;
    … …  
    15141516 *
    15151517 */
    1516 static int ip_packet_size_message(device_id_t device_id, size_t *addr_len,
     1518static int ip_packet_size_message(nic_device_id_t device_id, size_t *addr_len,
    15171519    size_t *prefix, size_t *content, size_t *suffix)
    15181520{
    … …  
    15721574 * @return              ENOENT if device is not found.
    15731575 */
    1574 static int ip_mtu_changed_message(device_id_t device_id, size_t mtu)
     1576static int ip_mtu_changed_message(nic_device_id_t device_id, size_t mtu)
    15751577{
    15761578        ip_netif_t *netif;
    … …  
    16291631                        async_answer_0(iid, (sysarg_t) rc);
    16301632                        break;
    1631                
     1633                case NET_IL_ADDR_CHANGED:
     1634                        async_answer_0(iid, (sysarg_t) EOK);
     1635                        break;
     1636
    16321637                default:
    16331638                        async_answer_0(iid, (sysarg_t) ENOTSUP);
    … …  
    16891694}
    16901695
    1691 static int ip_add_route_req_local(device_id_t device_id, in_addr_t address,
     1696static int ip_add_route_req_local(nic_device_id_t device_id, in_addr_t address,
    16921697    in_addr_t netmask, in_addr_t gateway)
    16931698{
    … …  
    17231728}
    17241729
    1725 static int ip_set_gateway_req_local(device_id_t device_id, in_addr_t gateway)
     1730static int ip_set_gateway_req_local(nic_device_id_t device_id,
     1731    in_addr_t gateway)
    17261732{
    17271733        ip_netif_t *netif;
    … …  
    17571763 *
    17581764 */
    1759 static int ip_received_error_msg_local(device_id_t device_id,
     1765static int ip_received_error_msg_local(nic_device_id_t device_id,
    17601766    packet_t *packet, services_t target, services_t error)
    17611767{
    … …  
    18181824static int ip_get_route_req_local(ip_protocol_t protocol,
    18191825    const struct sockaddr *destination, socklen_t addrlen,
    1820     device_id_t *device_id, void **header, size_t *headerlen)
     1826    nic_device_id_t *device_id, void **header, size_t *headerlen)
    18211827{
    18221828        struct sockaddr_in *address_in;
    … …  
    19091915        size_t suffix;
    19101916        size_t content;
    1911         device_id_t device_id;
     1917        nic_device_id_t device_id;
    19121918        int rc;
    19131919       

  • uspace/srv/net/il/ip/ip.h

    rf51b1d3 r609243f4  
    9292        in_addr_t broadcast;
    9393        /** Device identifier. */
    94         device_id_t device_id;
     94        nic_device_id_t device_id;
    9595        /** Indicates whether using DHCP. */
    9696        int dhcp;
    … …  
    108108        services_t service;
    109109        /** Device state. */
    110         device_state_t state;
     110        nic_device_state_t state;
    111111};
    112112
Note: See TracChangeset for help on using the changeset viewer.