586 lines
12 KiB
C++
586 lines
12 KiB
C++
/*
|
|
* \brief Glue code for Linux network drivers
|
|
* \author Sebastian Sumpf
|
|
* \author Josef Soentgen
|
|
* \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.
|
|
*/
|
|
|
|
/* Genode includes */
|
|
#include <base/rpc_server.h>
|
|
#include <base/snprintf.h>
|
|
#include <cap_session/connection.h>
|
|
#include <nic/xml_node.h>
|
|
#include <nic_session/nic_session.h>
|
|
#include <os/config.h>
|
|
#include <util/xml_node.h>
|
|
|
|
/* local includes */
|
|
#include <lx.h>
|
|
#include <nic/component.h>
|
|
|
|
#include <extern_c_begin.h>
|
|
# include <lx_emul.h>
|
|
# include <net/cfg80211.h>
|
|
#include <extern_c_end.h>
|
|
|
|
|
|
enum {
|
|
HEAD_ROOM = 128, /* XXX guessed value but works */
|
|
};
|
|
|
|
/**
|
|
* Net_device to session glue code
|
|
*/
|
|
class Nic_device : public Nic::Device
|
|
{
|
|
public: /* FIXME */
|
|
|
|
struct net_device *_ndev;
|
|
Nic::Session_component *_session = nullptr;
|
|
bool _has_link = false;
|
|
|
|
public:
|
|
|
|
Nic_device(struct net_device *ndev) : _ndev(ndev) { }
|
|
|
|
void rx(sk_buff *skb)
|
|
{
|
|
/* get mac header back */
|
|
skb_push(skb, ETH_HLEN);
|
|
|
|
void *packet = skb->data;
|
|
size_t packet_size = ETH_HLEN;
|
|
void *frag = 0;
|
|
size_t frag_size = 0;
|
|
|
|
/**
|
|
* If received packets are too large (as of now 128 bytes) the actually
|
|
* payload is put into a fragment. Otherwise the payload is stored directly
|
|
* in the sk_buff.
|
|
*/
|
|
if (skb_shinfo(skb)->nr_frags) {
|
|
if (skb_shinfo(skb)->nr_frags > 1)
|
|
PERR("more than 1 fragment in skb");
|
|
|
|
skb_frag_t *f = &skb_shinfo(skb)->frags[0];
|
|
frag = skb_frag_address(f);
|
|
frag_size = skb_frag_size(f);
|
|
}
|
|
else
|
|
packet_size += skb->len;
|
|
|
|
_session->rx((Genode::addr_t)packet, packet_size, (Genode::addr_t)frag, frag_size);
|
|
}
|
|
|
|
/**
|
|
* 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 **
|
|
**********************/
|
|
|
|
void session(Nic::Session_component *s) override { _session = s; }
|
|
|
|
Nic::Mac_address mac_address() override
|
|
{
|
|
Nic::Mac_address m;
|
|
Genode::memcpy(&m, _ndev->perm_addr, ETH_ALEN);
|
|
return m;
|
|
}
|
|
|
|
bool link_state() override { return _has_link; }
|
|
|
|
bool tx(Genode::addr_t virt, Genode::size_t size) override
|
|
{
|
|
struct sk_buff *skb = ::alloc_skb(size + HEAD_ROOM, GFP_KERNEL);
|
|
skb_reserve(skb, HEAD_ROOM);
|
|
|
|
unsigned char *data = skb_put(skb, size);
|
|
Genode::memcpy(data, (void*)virt, size);
|
|
|
|
_ndev->netdev_ops->ndo_start_xmit(skb, _ndev);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
|
|
static Nic_device *_nic = 0;
|
|
|
|
static Server::Entrypoint *_ep;
|
|
|
|
void Lx::nic_init(Server::Entrypoint &ep) {
|
|
_ep = &ep; }
|
|
|
|
|
|
void Lx::get_mac_address(unsigned char *addr)
|
|
{
|
|
Genode::memcpy(addr, _nic->_ndev->perm_addr, ETH_ALEN);
|
|
}
|
|
|
|
|
|
namespace Lx {
|
|
class Notifier;
|
|
}
|
|
|
|
class Lx::Notifier
|
|
{
|
|
private:
|
|
|
|
struct Block : public Genode::List<Block>::Element
|
|
{
|
|
struct notifier_block *nb;
|
|
|
|
Block(struct notifier_block *nb) : nb(nb) { }
|
|
};
|
|
|
|
Lx::List<Block> _list;
|
|
Genode::Tslab<Block, 32 * sizeof(Block)> _block_alloc;
|
|
|
|
public:
|
|
|
|
Notifier() : _block_alloc(Genode::env()->heap()) { }
|
|
|
|
void register_block(struct notifier_block *nb)
|
|
{
|
|
Block *b = new (&_block_alloc) Block(nb);
|
|
_list.insert(b);
|
|
}
|
|
|
|
void unregister_block(struct notifier_block *nb)
|
|
{
|
|
for (Block *b = _list.first(); b; b = b->next())
|
|
if (b->nb == nb) {
|
|
_list.remove(b);
|
|
destroy(&_block_alloc, b);
|
|
break;
|
|
}
|
|
}
|
|
|
|
int call_all_blocks(unsigned long val, void *v)
|
|
{
|
|
int rv = NOTIFY_DONE;
|
|
for (Block *b = _list.first(); b; b = b->next()) {
|
|
rv = b->nb->notifier_call(b->nb, val, v);
|
|
if (rv & NOTIFY_STOP_MASK)
|
|
break;
|
|
}
|
|
return rv;
|
|
}
|
|
};
|
|
|
|
|
|
/* XXX move blocking_notifier_call to proper location */
|
|
/**********************
|
|
** linux/notifier.h **
|
|
**********************/
|
|
|
|
static Lx::Notifier &blocking_notifier()
|
|
{
|
|
static Lx::Notifier inst;
|
|
return inst;
|
|
}
|
|
|
|
|
|
int blocking_notifier_chain_register(struct blocking_notifier_head *nh,
|
|
struct notifier_block *nb)
|
|
{
|
|
blocking_notifier().register_block(nb);
|
|
return 0;
|
|
}
|
|
|
|
int blocking_notifier_chain_unregister(struct blocking_notifier_head *nh,
|
|
struct notifier_block *nb)
|
|
{
|
|
blocking_notifier().unregister_block(nb);
|
|
return 0;
|
|
}
|
|
|
|
|
|
int blocking_notifier_call_chain(struct blocking_notifier_head *nh,
|
|
unsigned long val, void *v)
|
|
{
|
|
return blocking_notifier().call_all_blocks(val, v);
|
|
}
|
|
|
|
|
|
/***********************
|
|
** linux/netdevice.h **
|
|
***********************/
|
|
|
|
static Lx::Notifier &net_notifier()
|
|
{
|
|
static Lx::Notifier inst;
|
|
return inst;
|
|
}
|
|
|
|
|
|
extern "C" int register_netdevice_notifier(struct notifier_block *nb)
|
|
{
|
|
/**
|
|
* In Linux the nb is actually called upon on registration. We do not
|
|
* that semantic because we add a net_device only after all notifiers
|
|
* were registered.
|
|
*/
|
|
net_notifier().register_block(nb);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
extern "C" int unregster_netdevice_notifier(struct notifier_block *nb)
|
|
{
|
|
net_notifier().unregister_block(nb);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
extern "C" struct net_device * netdev_notifier_info_to_dev(struct netdev_notifier_info *info)
|
|
{
|
|
/* we always pass a net_device pointer to this function */
|
|
return reinterpret_cast<net_device *>(info);
|
|
}
|
|
|
|
|
|
struct Proto_hook : public Lx::List<Proto_hook>::Element
|
|
{
|
|
struct packet_type &pt;
|
|
|
|
Proto_hook(struct packet_type *pt) : pt(*pt) { }
|
|
};
|
|
|
|
|
|
class Proto_hook_list
|
|
{
|
|
private:
|
|
|
|
Lx::List<Proto_hook> _list;
|
|
Genode::Allocator &_alloc;
|
|
|
|
public:
|
|
|
|
Proto_hook_list(Genode::Allocator &alloc) : _alloc(alloc) { }
|
|
|
|
void insert(struct packet_type *pt) {
|
|
_list.insert(new (&_alloc) Proto_hook(pt)); }
|
|
|
|
void remove(struct packet_type *pt)
|
|
{
|
|
for (Proto_hook *ph = _list.first(); ph; ph = ph->next())
|
|
if (&ph->pt == pt) {
|
|
_list.remove(ph);
|
|
destroy(&_alloc, ph);
|
|
break;
|
|
}
|
|
}
|
|
|
|
Proto_hook* first() { return _list.first(); }
|
|
};
|
|
|
|
|
|
static Proto_hook_list& proto_hook_list()
|
|
{
|
|
static Proto_hook_list inst(*Genode::env()->heap());
|
|
return inst;
|
|
}
|
|
|
|
|
|
extern "C" void dev_add_pack(struct packet_type *pt)
|
|
{
|
|
proto_hook_list().insert(pt);
|
|
}
|
|
|
|
|
|
extern "C" void __dev_remove_pack(struct packet_type *pt)
|
|
{
|
|
proto_hook_list().remove(pt);
|
|
}
|
|
|
|
|
|
extern "C" struct net_device *__dev_get_by_index(struct net *net, int ifindex)
|
|
{
|
|
if (!_nic || !_nic->_ndev) {
|
|
PERR("no net device registered!");
|
|
return 0;
|
|
}
|
|
|
|
return _nic->_ndev;
|
|
}
|
|
|
|
|
|
extern "C" struct net_device *dev_get_by_index(struct net *net, int ifindex)
|
|
{
|
|
return __dev_get_by_index(net, ifindex);
|
|
}
|
|
|
|
|
|
extern "C" int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
|
|
unsigned short type, const void *daddr,
|
|
const void *saddr, unsigned int len)
|
|
{
|
|
if (!dev->header_ops || !dev->header_ops->create)
|
|
return 0;
|
|
|
|
return dev->header_ops->create(skb, dev, type, daddr, saddr, len);
|
|
}
|
|
|
|
|
|
extern "C" int dev_parse_header(const struct sk_buff *skb, unsigned char *haddr)
|
|
{
|
|
struct net_device const *dev = skb->dev;
|
|
|
|
if (!dev->header_ops || dev->header_ops->parse)
|
|
return 0;
|
|
|
|
return dev->header_ops->parse(skb, haddr);
|
|
}
|
|
|
|
|
|
extern "C" int dev_queue_xmit(struct sk_buff *skb)
|
|
{
|
|
struct net_device *dev = skb->dev;
|
|
struct net_device_ops const *ops = dev->netdev_ops;
|
|
int rv = NETDEV_TX_OK;
|
|
|
|
if (skb->next)
|
|
PWRN("more skb's queued");
|
|
|
|
rv = ops->ndo_start_xmit(skb, dev);
|
|
|
|
return rv;
|
|
}
|
|
|
|
|
|
extern "C" size_t LL_RESERVED_SPACE(struct net_device *dev)
|
|
{
|
|
return dev->hard_header_len ?
|
|
(dev->hard_header_len + (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0;
|
|
}
|
|
|
|
|
|
extern "C" int register_netdevice(struct net_device *ndev)
|
|
{
|
|
static bool already_registered = false;
|
|
|
|
if (already_registered) {
|
|
PERR("We don't support multiple network devices in one driver instance");
|
|
return -ENODEV;
|
|
}
|
|
|
|
static Nic_device nic_device(ndev);
|
|
static Nic::Root nic_root(*_ep, Genode::env()->heap(), nic_device);
|
|
|
|
/*
|
|
* XXX This is just a starting point for removing all the static stuff from
|
|
* this file...
|
|
*/
|
|
ndev->lx_nic_device = (void *)&nic_device;
|
|
_nic = &nic_device;
|
|
|
|
already_registered = true;
|
|
|
|
ndev->state |= 1UL << __LINK_STATE_START;
|
|
netif_carrier_off(ndev);
|
|
|
|
/* execute all notifier blocks */
|
|
net_notifier().call_all_blocks(NETDEV_REGISTER, ndev);
|
|
net_notifier().call_all_blocks(NETDEV_UP, ndev);
|
|
ndev->ifindex = 1;
|
|
|
|
/* set mac adress */
|
|
Genode::memcpy(ndev->perm_addr, ndev->ieee80211_ptr->wiphy->perm_addr, ETH_ALEN);
|
|
|
|
int err = ndev->netdev_ops->ndo_open(ndev);
|
|
if (err) {
|
|
PERR("ndev->netdev_ops->ndo_open(ndev): %d", err);
|
|
return err;
|
|
}
|
|
|
|
if (ndev->netdev_ops->ndo_set_rx_mode)
|
|
ndev->netdev_ops->ndo_set_rx_mode(ndev);
|
|
|
|
Genode::env()->parent()->announce(_ep->rpc_ep().manage(&nic_root));
|
|
|
|
list_add_tail_rcu(&ndev->dev_list, &init_net.dev_base_head);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
extern "C" int netif_running(const struct net_device *dev)
|
|
{
|
|
return dev->state & (1UL << __LINK_STATE_START);
|
|
}
|
|
|
|
|
|
extern "C" int netif_device_present(struct net_device *dev) { return 1; }
|
|
|
|
|
|
extern "C" int netif_carrier_ok(const struct net_device *dev)
|
|
{
|
|
return !(dev->state & (1UL << __LINK_STATE_NOCARRIER));
|
|
}
|
|
|
|
|
|
extern "C" void netif_carrier_on(struct net_device *dev)
|
|
{
|
|
dev->state &= ~(1UL << __LINK_STATE_NOCARRIER);
|
|
|
|
Nic_device *nic = (Nic_device *)dev->lx_nic_device;
|
|
|
|
nic->link_state(true);
|
|
}
|
|
|
|
|
|
extern "C" void netif_carrier_off(struct net_device *dev)
|
|
{
|
|
if (!dev)
|
|
PERR("!dev %p", __builtin_return_address(0));
|
|
|
|
dev->state |= 1UL << __LINK_STATE_NOCARRIER;
|
|
|
|
Nic_device *nic = (Nic_device *)dev->lx_nic_device;
|
|
|
|
nic->link_state(false);
|
|
}
|
|
|
|
|
|
extern "C" int netif_receive_skb(struct sk_buff *skb)
|
|
{
|
|
/**
|
|
* XXX check original linux implementation if it is really
|
|
* necessary to free the skb if it was not handled.
|
|
*/
|
|
|
|
/* send EAPOL related frames only to the wpa_supplicant */
|
|
if (ntohs(skb->protocol) == ETH_P_PAE) {
|
|
/* XXX call only AF_PACKET hook */
|
|
for (Proto_hook* ph = proto_hook_list().first(); ph; ph = ph->next()) {
|
|
ph->pt.func(skb, _nic->_ndev, &ph->pt, _nic->_ndev);
|
|
}
|
|
return NET_RX_SUCCESS;
|
|
}
|
|
|
|
if (_nic && _nic->_session) {
|
|
_nic->rx(skb);
|
|
}
|
|
|
|
dev_kfree_skb(skb);
|
|
return NET_RX_SUCCESS;
|
|
}
|
|
|
|
|
|
extern "C" u16 netdev_cap_txqueue(struct net_device *dev, u16 queue_index)
|
|
{
|
|
if (queue_index > dev-> real_num_tx_queues) {
|
|
PERR("error: queue_index %d out of range (%d max) called from: %p",
|
|
queue_index, dev->real_num_tx_queues, __builtin_return_address(0));
|
|
return 0;
|
|
}
|
|
|
|
return queue_index;
|
|
}
|
|
|
|
|
|
extern "C" struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name,
|
|
void (*setup)(struct net_device *),
|
|
unsigned int txqs, unsigned int rxqs)
|
|
{
|
|
struct net_device *dev;
|
|
size_t alloc_size;
|
|
struct net_device *p;
|
|
|
|
alloc_size = ALIGN(sizeof(struct net_device), NETDEV_ALIGN);
|
|
/* ensure 32-byte alignment of whole construct */
|
|
alloc_size += NETDEV_ALIGN - 1;
|
|
|
|
p = (net_device *)kzalloc(alloc_size, GFP_KERNEL | __GFP_NOWARN | __GFP_REPEAT);
|
|
if (!p)
|
|
return NULL;
|
|
|
|
dev = PTR_ALIGN(p, NETDEV_ALIGN);
|
|
|
|
dev->gso_max_size = GSO_MAX_SIZE;
|
|
dev->gso_max_segs = GSO_MAX_SEGS;
|
|
|
|
setup(dev);
|
|
|
|
/* actually set by dev_open() */
|
|
dev->flags |= IFF_UP;
|
|
|
|
|
|
/* XXX our dev is always called wlan0 */
|
|
strcpy(dev->name, "wlan0");
|
|
|
|
dev->dev_addr = (unsigned char *)kzalloc(ETH_ALEN, GFP_KERNEL);
|
|
if (!dev->dev_addr)
|
|
return 0;
|
|
|
|
if (sizeof_priv) {
|
|
/* ensure 32-byte alignment of private area */
|
|
dev->priv = kzalloc(sizeof_priv, GFP_KERNEL);
|
|
if (!dev->priv)
|
|
return 0;
|
|
}
|
|
|
|
dev->num_tx_queues = txqs;
|
|
dev->real_num_tx_queues = txqs;
|
|
struct netdev_queue *tx = (struct netdev_queue*)
|
|
kcalloc(txqs, sizeof(struct netdev_queue),
|
|
GFP_KERNEL | GFP_LX_DMA);
|
|
if (!tx) {
|
|
PERR("could not allocate ndev_queues");
|
|
}
|
|
|
|
dev->_tx = tx;
|
|
for (unsigned i = 0; i < txqs; i++) {
|
|
tx[i].dev = dev;
|
|
tx[i].numa_node = NUMA_NO_NODE;
|
|
}
|
|
|
|
return dev;
|
|
}
|
|
|
|
|
|
/**********************
|
|
** linux/inerrupt.h **
|
|
**********************/
|
|
|
|
|
|
|
|
/*************************
|
|
** linux/etherdevice.h **
|
|
*************************/
|
|
|
|
int is_valid_ether_addr(const u8 *addr)
|
|
{
|
|
/* is multicast */
|
|
if ((addr[0] & 0x1))
|
|
return 0;
|
|
|
|
/* zero */
|
|
if (!(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5]))
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|