740 lines
14 KiB
C++
740 lines
14 KiB
C++
/*
|
|
* \brief Glue code for Linux network drivers
|
|
* \author Sebastian Sumpf
|
|
* \date 2012-07-05
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2012-2013 Genode Labs GmbH
|
|
*
|
|
* This file is part of the Genode OS framework, which is distributed
|
|
* under the terms of the GNU General Public License version 2.
|
|
*/
|
|
|
|
#include <base/rpc_server.h>
|
|
#include <base/snprintf.h>
|
|
#include <nic_session/nic_session.h>
|
|
#include <cap_session/connection.h>
|
|
#include <nic/xml_node.h>
|
|
#include <util/xml_node.h>
|
|
#include <os/config.h>
|
|
|
|
#include <extern_c_begin.h>
|
|
#include <lx_emul.h>
|
|
#include <linux/usb.h>
|
|
#include <linux/usb/usbnet.h>
|
|
#include <extern_c_end.h>
|
|
|
|
#include <nic/component.h>
|
|
#include "signal.h"
|
|
|
|
|
|
static Signal_helper *_signal = 0;
|
|
|
|
enum {
|
|
HEAD_ROOM = 8, /* head room in skb in bytes */
|
|
MAC_LEN = 17, /* 12 number and 6 colons */
|
|
};
|
|
|
|
|
|
/**
|
|
* Internal alloc function
|
|
*/
|
|
struct sk_buff *_alloc_skb(unsigned int size, bool tx = true);
|
|
|
|
|
|
/**
|
|
* Skb-bitmap allocator
|
|
*/
|
|
class Skb
|
|
{
|
|
private:
|
|
|
|
unsigned const _entries;
|
|
|
|
sk_buff *_buf;
|
|
unsigned *_free;
|
|
unsigned _idx;
|
|
|
|
enum { ENTRY_ELEMENT_SIZE = sizeof(unsigned) * 8 };
|
|
|
|
public:
|
|
|
|
Skb(unsigned const entries, unsigned const buffer_size)
|
|
:
|
|
_entries(entries), _idx(0)
|
|
{
|
|
unsigned const size = _entries / sizeof(unsigned);
|
|
|
|
_buf = (sk_buff *)kmalloc(sizeof(sk_buff) * _entries, GFP_KERNEL);
|
|
_free = (unsigned *)kmalloc(sizeof(unsigned) * size, GFP_KERNEL);
|
|
|
|
Genode::memset(_free, 0xff, size * sizeof(unsigned));
|
|
|
|
for (unsigned i = 0; i < _entries; i++)
|
|
_buf[i].start = (unsigned char *)kmalloc(buffer_size + NET_IP_ALIGN, GFP_NOIO);
|
|
}
|
|
|
|
sk_buff *alloc()
|
|
{
|
|
unsigned const IDX = _entries / ENTRY_ELEMENT_SIZE;
|
|
|
|
for (register unsigned i = 0; i < IDX; i++) {
|
|
if (_free[_idx] != 0) {
|
|
unsigned msb = Genode::log2(_free[_idx]);
|
|
_free[_idx] ^= (1 << msb);
|
|
|
|
sk_buff *r = &_buf[(_idx * ENTRY_ELEMENT_SIZE) + msb];
|
|
r->data = r->start;
|
|
r->phys = 0;
|
|
r->cloned = 0;
|
|
r->clone = 0;
|
|
r->len = 0;
|
|
return r;
|
|
}
|
|
_idx = (_idx + 1) % IDX;
|
|
}
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
void free(sk_buff *buf)
|
|
{
|
|
unsigned entry = buf - &_buf[0];
|
|
if (&_buf[0] > buf || entry > _entries)
|
|
return;
|
|
|
|
_idx = entry / ENTRY_ELEMENT_SIZE;
|
|
_free[_idx] |= (1 << (entry % ENTRY_ELEMENT_SIZE));
|
|
}
|
|
};
|
|
|
|
|
|
/* send/receive skb allocators */
|
|
static Skb *skb_tx(unsigned const elements = 0, unsigned const buffer_size = 0)
|
|
{
|
|
static Skb _skb(elements, buffer_size);
|
|
return &_skb;
|
|
}
|
|
|
|
|
|
static Skb *skb_rx(unsigned const elements = 0, unsigned const buffer_size = 0)
|
|
{
|
|
static Skb _skb(elements, buffer_size);
|
|
return &_skb;
|
|
}
|
|
|
|
|
|
/**
|
|
* Prototype of fixup function
|
|
*/
|
|
extern "C" {
|
|
typedef struct sk_buff* (*fixup_t)(struct usbnet *, struct sk_buff *, gfp_t);
|
|
}
|
|
|
|
|
|
/**
|
|
* Net_device to session glue code
|
|
*/
|
|
class Nic_device : public Nic::Device
|
|
{
|
|
public:
|
|
|
|
struct net_device *_ndev; /* Linux-net device */
|
|
fixup_t _tx_fixup;
|
|
bool const _burst;
|
|
bool _has_link { false };
|
|
|
|
public:
|
|
|
|
Nic_device(struct net_device *ndev)
|
|
:
|
|
_ndev(ndev),
|
|
/* XXX should be configurable instead of guessing burst mode */
|
|
_burst(((usbnet *)netdev_priv(ndev))->rx_urb_size > 2048)
|
|
{
|
|
struct usbnet *dev = (usbnet *)netdev_priv(_ndev);
|
|
|
|
/* initialize skb allocators */
|
|
unsigned urb_cnt = dev->rx_urb_size <= 2048 ? 128 : 64;
|
|
skb_rx(urb_cnt, dev->rx_urb_size);
|
|
skb_tx(urb_cnt, dev->rx_urb_size);
|
|
|
|
if (!burst()) return;
|
|
|
|
/*
|
|
* Retrieve 'tx_fixup' function from driver and set it to zero,
|
|
* so it cannot be called by the actual driver. Required for
|
|
* burst mode.
|
|
*/
|
|
_tx_fixup = dev->driver_info->tx_fixup;
|
|
dev->driver_info->tx_fixup = 0;
|
|
}
|
|
|
|
/**
|
|
* Add device
|
|
*/
|
|
static Nic_device *add(struct net_device *ndev) {
|
|
return new (Genode::env()->heap()) Nic_device(ndev); }
|
|
|
|
/**
|
|
* Report link state
|
|
*/
|
|
void link_state(bool link)
|
|
{
|
|
/* only report changes of the link state */
|
|
if (link == _has_link)
|
|
return;
|
|
|
|
_has_link = link;
|
|
|
|
if (_session)
|
|
_session->link_state_changed();
|
|
}
|
|
|
|
|
|
|
|
/**********************
|
|
** Device interface **
|
|
**********************/
|
|
|
|
bool link_state() override { return _has_link; }
|
|
|
|
/**
|
|
* Submit packet to driver
|
|
*/
|
|
bool tx(Genode::addr_t virt, Genode::size_t size)
|
|
{
|
|
sk_buff *skb;
|
|
|
|
if (!(skb = _alloc_skb(size + HEAD_ROOM)))
|
|
return false;
|
|
|
|
skb->len = size;
|
|
skb->data += HEAD_ROOM;
|
|
Genode::memcpy(skb->data, (void *)virt, skb->len);
|
|
|
|
tx_skb(skb);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Alloc an SKB
|
|
*/
|
|
sk_buff *alloc_skb()
|
|
{
|
|
struct usbnet *dev = (usbnet *)netdev_priv(_ndev);
|
|
sk_buff *skb;
|
|
|
|
if (!(skb = _alloc_skb(dev->rx_urb_size)))
|
|
return 0;
|
|
|
|
skb->len = 0;
|
|
return skb;
|
|
}
|
|
|
|
/**
|
|
* Submit SKB to the driver
|
|
*/
|
|
void tx_skb(sk_buff *skb)
|
|
{
|
|
struct usbnet *dev = (usbnet *)netdev_priv(_ndev);
|
|
unsigned long dropped = dev->net->stats.tx_dropped;
|
|
_ndev->netdev_ops->ndo_start_xmit(skb, _ndev);
|
|
|
|
if (dropped < dev->net->stats.tx_dropped)
|
|
PWRN("Dropped SKB");
|
|
}
|
|
|
|
/**
|
|
* Call tx_fixup function of driver
|
|
*/
|
|
void tx_fixup(struct sk_buff *skb)
|
|
{
|
|
struct usbnet *dev = (usbnet *)netdev_priv(_ndev);
|
|
if(!_tx_fixup || !_tx_fixup(dev, skb, 0))
|
|
PERR("Tx fixup error");
|
|
}
|
|
|
|
|
|
/**
|
|
* Fill an SKB with 'data' if 'size', return false if SKB is greater than
|
|
* 'end'
|
|
*/
|
|
bool skb_fill(struct sk_buff *skb, unsigned char *data, Genode::size_t size, unsigned char *end)
|
|
{
|
|
Genode::addr_t align = ((Genode::addr_t)(data + 3) & ~3);
|
|
skb->truesize = skb->data == 0 ? 0 : (unsigned char*)align - data;
|
|
data = skb->data == 0 ? data : (unsigned char*)align;
|
|
|
|
skb->start = data;
|
|
data += HEAD_ROOM;
|
|
skb->len = size;
|
|
skb->data = data;
|
|
skb->end = skb->tail = data + size;
|
|
skb->truesize += (skb->end - skb->start);
|
|
|
|
|
|
return skb->end >= end ? false : true;
|
|
}
|
|
|
|
/**
|
|
* Submit packet for session
|
|
*/
|
|
inline void rx(sk_buff *skb) { _session->rx((Genode::addr_t)skb->data, skb->len); }
|
|
|
|
/**
|
|
* Return mac address
|
|
*/
|
|
Nic::Mac_address mac_address()
|
|
{
|
|
Nic::Mac_address m;
|
|
Genode::memcpy(&m, _ndev->_dev_addr, ETH_ALEN);
|
|
return m;
|
|
}
|
|
|
|
bool burst() { return _burst; }
|
|
};
|
|
|
|
|
|
/* XXX support multiple devices */
|
|
static Nic_device *_nic = 0;
|
|
|
|
|
|
void Nic::init(Server::Entrypoint &ep) {
|
|
_signal = new (Genode::env()->heap()) Signal_helper(ep); }
|
|
|
|
|
|
/***********************
|
|
** linux/netdevice.h **
|
|
***********************/
|
|
|
|
int register_netdev(struct net_device *ndev)
|
|
{
|
|
using namespace Genode;
|
|
static bool announce = false;
|
|
int err = -ENODEV;
|
|
|
|
Nic_device *nic = Nic_device::add(ndev);
|
|
|
|
/* XXX: move to 'main' */
|
|
if (!announce) {
|
|
static Nic::Root root(_signal->ep(), env()->heap(), nic);
|
|
|
|
announce = true;
|
|
|
|
ndev->state |= 1 << __LINK_STATE_START;
|
|
netif_carrier_off(ndev);
|
|
|
|
if ((err = ndev->netdev_ops->ndo_open(ndev)))
|
|
return err;
|
|
|
|
if (ndev->netdev_ops->ndo_set_rx_mode)
|
|
ndev->netdev_ops->ndo_set_rx_mode(ndev);
|
|
|
|
/*
|
|
if(ndev->netdev_ops->ndo_change_mtu)
|
|
ndev->netdev_ops->ndo_change_mtu(ndev, 4000);
|
|
*/
|
|
_nic = nic;
|
|
env()->parent()->announce(_signal->ep().rpc_ep().manage(&root));
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
|
|
int netif_running(const struct net_device *dev)
|
|
{
|
|
return dev->state & (1 << __LINK_STATE_START);
|
|
}
|
|
|
|
|
|
int netif_device_present(struct net_device *dev) { return 1; }
|
|
|
|
|
|
int netif_carrier_ok(const struct net_device *dev)
|
|
{
|
|
return !(dev->state & (1 << __LINK_STATE_NOCARRIER));
|
|
}
|
|
|
|
|
|
void netif_carrier_on(struct net_device *dev)
|
|
{
|
|
dev->state &= ~(1 << __LINK_STATE_NOCARRIER);
|
|
if (_nic)
|
|
_nic->link_state(true);
|
|
}
|
|
|
|
|
|
void netif_carrier_off(struct net_device *dev)
|
|
{
|
|
dev->state |= 1 << __LINK_STATE_NOCARRIER;
|
|
if (_nic)
|
|
_nic->link_state(false);
|
|
}
|
|
|
|
#ifdef GENODE_NET_STAT
|
|
#include <nic/stat.h>
|
|
static Timer::Connection _timer;
|
|
static Nic::Measurement _stat(_timer);
|
|
#endif
|
|
|
|
int netif_rx(struct sk_buff *skb)
|
|
{
|
|
if (_nic && _nic->session()) {
|
|
_nic->rx(skb);
|
|
}
|
|
#ifdef GENODE_NET_STAT
|
|
else if (_nic) {
|
|
try {
|
|
_stat.data(new (skb->data) Net::Ethernet_frame(skb->len), skb->len);
|
|
} catch(Net::Ethernet_frame::No_ethernet_frame) {
|
|
PWRN("No ether frame");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
dev_kfree_skb(skb);
|
|
return NET_RX_SUCCESS;
|
|
}
|
|
|
|
|
|
/********************
|
|
** linux/skbuff.h **
|
|
********************/
|
|
|
|
struct sk_buff *_alloc_skb(unsigned int size, bool tx)
|
|
{
|
|
sk_buff *skb = tx ? skb_tx()->alloc() : skb_rx()->alloc();
|
|
|
|
if (!skb)
|
|
return 0;
|
|
|
|
size = (size + 3) & ~(0x3);
|
|
|
|
skb->end = skb->start + size;
|
|
skb->tail = skb->start;
|
|
skb->truesize = size;
|
|
|
|
return skb;
|
|
}
|
|
|
|
|
|
struct sk_buff *alloc_skb(unsigned int size, gfp_t priority)
|
|
{
|
|
/*
|
|
* Note: This is only called for RX skb's by the driver
|
|
*/
|
|
struct sk_buff *skb = _alloc_skb(size, false);
|
|
return skb;
|
|
}
|
|
|
|
struct sk_buff *netdev_alloc_skb_ip_align(struct net_device *dev, unsigned int length)
|
|
{
|
|
struct sk_buff *s = _alloc_skb(length + NET_IP_ALIGN, false);
|
|
if (s && dev->net_ip_align) {
|
|
s->data += NET_IP_ALIGN;
|
|
s->tail += NET_IP_ALIGN;
|
|
}
|
|
return s;
|
|
}
|
|
|
|
|
|
void dev_kfree_skb(struct sk_buff *skb)
|
|
{
|
|
dde_kit_log(DEBUG_SKB, "free skb: %p start: %p cloned: %d",
|
|
skb, skb->start, skb->cloned);
|
|
|
|
if (skb->cloned) {
|
|
skb->start = skb->clone;
|
|
skb->cloned = false;
|
|
skb_rx()->free(skb);
|
|
return;
|
|
}
|
|
|
|
skb_tx()->free(skb);
|
|
skb_rx()->free(skb);
|
|
}
|
|
|
|
|
|
void dev_kfree_skb_any(struct sk_buff *skb) { dev_kfree_skb(skb); }
|
|
|
|
void kfree_skb(struct sk_buff *skb) { dev_kfree_skb(skb); }
|
|
|
|
|
|
/**
|
|
* Reserve 'len'
|
|
*/
|
|
void skb_reserve(struct sk_buff *skb, int len)
|
|
{
|
|
if ((skb->data + len) > skb->end) {
|
|
PERR("Error resevring SKB data: skb: %p data: %p end: %p len: %d",
|
|
skb, skb->data, skb->end, skb->len);
|
|
return;
|
|
}
|
|
skb->data += len;
|
|
dde_kit_log(DEBUG_SKB, "skb: %p slen: %u len: %d", skb, skb->len, len);
|
|
}
|
|
|
|
|
|
/**
|
|
* Prepend 'len'
|
|
*/
|
|
unsigned char *skb_push(struct sk_buff *skb, unsigned int len)
|
|
{
|
|
if((skb->data - len) < skb->start) {
|
|
PERR("Error SKB head room too small: %p data: %p start: %p len: %u",
|
|
skb, skb->data, skb->start, len);
|
|
return 0;
|
|
}
|
|
|
|
skb->len += len;
|
|
skb->data -= len;
|
|
|
|
dde_kit_log(DEBUG_SKB, "skb: %p slen: %u len: %u", skb, skb->len, len);
|
|
return skb->data;
|
|
}
|
|
|
|
|
|
/**
|
|
* Append 'len'
|
|
*/
|
|
unsigned char *skb_put(struct sk_buff *skb, unsigned int len)
|
|
{
|
|
if ((skb->data + len > skb->end)) {
|
|
PERR("Error increasing SKB length: skb: %p data: %p end: %p len: %u",
|
|
skb, skb->data, skb->end, len);
|
|
return 0;
|
|
}
|
|
|
|
unsigned char *old = skb_tail_pointer(skb);
|
|
skb->len += len;
|
|
skb->tail += len;
|
|
dde_kit_log(DEBUG_SKB, "skb: %p slen: %u len: %u", skb, skb->len, len);
|
|
return old;
|
|
}
|
|
|
|
|
|
/**
|
|
* Return current head room
|
|
*/
|
|
unsigned int skb_headroom(const struct sk_buff *skb)
|
|
{
|
|
return skb->data - skb->start;
|
|
}
|
|
|
|
|
|
int skb_tailroom(const struct sk_buff *skb)
|
|
{
|
|
return skb->end - skb->tail;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Take 'len' from front
|
|
*/
|
|
unsigned char *skb_pull(struct sk_buff *skb, unsigned int len)
|
|
{
|
|
if (len > skb->len) {
|
|
PERR("Error try to pull too much: skb: %p len: %u pull len: %u",
|
|
skb, skb->len, len);
|
|
return 0;
|
|
}
|
|
skb->len -= len;
|
|
dde_kit_log(DEBUG_SKB, "skb: %p slen: %u len: %u", skb, skb->len, len);
|
|
return skb->data += len;
|
|
}
|
|
|
|
|
|
/**
|
|
* Set 'len' and 'tail'
|
|
*/
|
|
void skb_trim(struct sk_buff *skb, unsigned int len)
|
|
{
|
|
if (skb->len <= len) {
|
|
PERR("Error trimming to %u bytes skb: %p data: %p start: %p len %u ret: %p",
|
|
len, skb, skb->data, skb->start, skb->len, __builtin_return_address((0)));
|
|
return;
|
|
}
|
|
|
|
skb->len = len;
|
|
skb_set_tail_pointer(skb, len);
|
|
|
|
dde_kit_log(DEBUG_SKB, "skb: %p slen: %u len: %u", skb, skb->len, len);
|
|
}
|
|
|
|
|
|
/**
|
|
* Clone skb
|
|
*/
|
|
struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t gfp_mask)
|
|
{
|
|
sk_buff *c;
|
|
|
|
if (!(c = alloc_skb(0,0)))
|
|
return 0;
|
|
|
|
unsigned char *start = c->start;
|
|
*c = *skb;
|
|
|
|
/* save old start pointer */
|
|
c->cloned = 1;
|
|
c->clone = start;
|
|
return c;
|
|
}
|
|
|
|
|
|
int skb_header_cloned(const struct sk_buff *skb)
|
|
{
|
|
return skb->cloned;
|
|
}
|
|
|
|
|
|
void skb_set_tail_pointer(struct sk_buff *skb, const int offset)
|
|
{
|
|
skb->tail = skb->data + offset;
|
|
}
|
|
|
|
|
|
unsigned char *skb_tail_pointer(const struct sk_buff *skb)
|
|
{
|
|
return skb->tail;
|
|
}
|
|
|
|
|
|
/**
|
|
* Dummy for shared info
|
|
*/
|
|
struct skb_shared_info *skb_shinfo(struct sk_buff const * /* skb */)
|
|
{
|
|
static skb_shared_info _s = { 0 };
|
|
return &_s;
|
|
}
|
|
|
|
|
|
/**
|
|
* Init list head
|
|
*/
|
|
void skb_queue_head_init(struct sk_buff_head *list)
|
|
{
|
|
static int count_x = 0;
|
|
list->prev = list->next = (sk_buff *)list;
|
|
list->qlen = 0;
|
|
}
|
|
|
|
/**
|
|
* Add to tail of queue
|
|
*/
|
|
void __skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk)
|
|
{
|
|
newsk->next = (sk_buff *)list;
|
|
newsk->prev = list->prev;
|
|
list->prev->next = newsk;
|
|
list->prev = newsk;
|
|
list->qlen++;
|
|
}
|
|
|
|
|
|
void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk) {
|
|
__skb_queue_tail(list, newsk); }
|
|
|
|
|
|
/**
|
|
* Remove skb from queue
|
|
*/
|
|
void __skb_unlink(struct sk_buff *skb, struct sk_buff_head *list)
|
|
{
|
|
if (!list->qlen)
|
|
return;
|
|
|
|
skb->prev->next = skb->next;
|
|
skb->next->prev = skb->prev;
|
|
skb->next = skb->prev = 0;
|
|
list->qlen--;
|
|
}
|
|
|
|
|
|
/**
|
|
* Remove from head of queue
|
|
*/
|
|
struct sk_buff *skb_dequeue(struct sk_buff_head *list)
|
|
{
|
|
if (list->qlen == 0)
|
|
return 0;
|
|
|
|
sk_buff *skb = list->next;
|
|
__skb_unlink(skb, list);
|
|
|
|
return skb;
|
|
}
|
|
|
|
|
|
/**********************
|
|
** linux/inerrupt.h **
|
|
**********************/
|
|
|
|
static void snprint_mac(u8 *buf, u8 *mac)
|
|
{
|
|
for (int i = 0; i < ETH_ALEN; i++)
|
|
{
|
|
Genode::snprintf((char *)&buf[i * 3], 3, "%02x", mac[i]);
|
|
if ((i * 3) < MAC_LEN)
|
|
buf[(i * 3) + 2] = ':';
|
|
}
|
|
|
|
buf[MAC_LEN] = 0;
|
|
}
|
|
|
|
|
|
/*************************
|
|
** linux/etherdevice.h **
|
|
*************************/
|
|
|
|
void eth_hw_addr_random(struct net_device *dev)
|
|
{
|
|
random_ether_addr(dev->_dev_addr);
|
|
}
|
|
|
|
|
|
void eth_random_addr(u8 *addr)
|
|
{
|
|
random_ether_addr(addr);
|
|
}
|
|
|
|
|
|
void random_ether_addr(u8 *addr)
|
|
{
|
|
using namespace Genode;
|
|
u8 str[MAC_LEN + 1];
|
|
u8 fallback[] = { 0x2e, 0x60, 0x90, 0x0c, 0x4e, 0x01 };
|
|
Nic::Mac_address mac;
|
|
|
|
/* try using configured mac */
|
|
try {
|
|
Xml_node nic_config = config()->xml_node().sub_node("nic");
|
|
Xml_node::Attribute mac_node = nic_config.attribute("mac");
|
|
mac_node.value(&mac);
|
|
} catch (...) {
|
|
/* use fallback mac */
|
|
snprint_mac(str, fallback);
|
|
PWRN("No mac address or wrong format attribute in <nic> - using fallback (%s)",
|
|
str);
|
|
|
|
Genode::memcpy(addr, fallback, ETH_ALEN);
|
|
return;
|
|
}
|
|
|
|
/* use configured mac*/
|
|
Genode::memcpy(addr, mac.addr, ETH_ALEN);
|
|
snprint_mac(str, (u8 *)mac.addr);
|
|
PINF("Using configured mac: %s", str);
|
|
|
|
#ifdef GENODE_NET_STAT
|
|
_stat.set_mac(mac.addr);
|
|
#endif
|
|
}
|
|
|