/* rtnetproxy.c: a Linux network driver that uses the RTnet driver to
|
* transport IP data from/to Linux kernel mode.
|
* This allows the usage of TCP/IP from linux space using via the RTNET
|
* network adapter.
|
*
|
*
|
* Usage:
|
*
|
* insmod rtnetproxy.o (only after having rtnet up and running)
|
*
|
* ifconfig rtproxy up IP_ADDRESS netmask NETMASK
|
*
|
* Use it like any other network device from linux.
|
*
|
* Restrictions:
|
* Only IPV4 based protocols are supported, UDP and ICMP can be send out
|
* but not received - as these are handled directly by rtnet!
|
*
|
*
|
*
|
* Based on the linux net driver dummy.c by Nick Holloway
|
*
|
*
|
* Changelog:
|
*
|
* 08-Nov-2002 Mathias Koehrer - Clear separation between rtai context and
|
* standard linux driver context.
|
* Data exchange via ringbuffers.
|
* A RTAI thread is used for rtnet transmission.
|
*
|
* 05-Nov-2002 Mathias Koehrer - Initial version!
|
* Development based on rtnet 0.2.6,
|
* rtai-24.1.10, kernel 2.4.19
|
*
|
*
|
* Mathias Koehrer - mathias_koehrer@yahoo.de
|
*/
|
|
#include <linux/module.h>
|
#include <linux/moduleparam.h>
|
#include <linux/kernel.h>
|
#include <linux/netdevice.h>
|
#include <linux/init.h>
|
#include <linux/inet.h>
|
#include <linux/netdevice.h>
|
#include <linux/etherdevice.h>
|
#include <linux/skbuff.h>
|
#include <net/sock.h>
|
#include <net/ip.h>
|
|
#include <linux/if_ether.h> /* For the statistics structure. */
|
#include <linux/if_arp.h> /* For ARPHRD_ETHER */
|
|
#include <rtdev.h>
|
#include <rtskb.h>
|
#include <rtdm/driver.h>
|
#include <ipv4/ip_input.h>
|
#include <ipv4/route.h>
|
#include <rtnet_port.h>
|
|
static struct net_device *dev_rtnetproxy;
|
|
/* **************************************************************************
|
* SKB pool management (JK):
|
* ************************************************************************ */
|
#define DEFAULT_PROXY_RTSKBS 32
|
|
static unsigned int proxy_rtskbs = DEFAULT_PROXY_RTSKBS;
|
module_param(proxy_rtskbs, uint, 0444);
|
MODULE_PARM_DESC(proxy_rtskbs,
|
"Number of realtime socket buffers in proxy pool");
|
|
static struct rtskb_pool rtskb_pool;
|
|
static struct rtskb_queue tx_queue;
|
static struct rtskb_queue rx_queue;
|
|
/* handle for non-real-time signal */
|
static rtdm_nrtsig_t rtnetproxy_rx_signal;
|
|
/* Thread for transmission */
|
static rtdm_task_t rtnetproxy_tx_task;
|
|
static rtdm_event_t rtnetproxy_tx_event;
|
|
#ifdef CONFIG_XENO_DRIVERS_NET_ADDON_PROXY_ARP
|
static char *rtdev_attach = "rteth0";
|
module_param(rtdev_attach, charp, 0444);
|
MODULE_PARM_DESC(rtdev_attach, "Attach to the specified RTnet device");
|
|
struct rtnet_device *rtnetproxy_rtdev;
|
#endif
|
|
/* ************************************************************************
|
* ************************************************************************
|
* T R A N S M I T
|
* ************************************************************************
|
* ************************************************************************ */
|
|
static void rtnetproxy_tx_loop(void *arg)
|
{
|
struct rtnet_device *rtdev;
|
struct rtskb *rtskb;
|
|
while (!rtdm_task_should_stop()) {
|
if (rtdm_event_wait(&rtnetproxy_tx_event) < 0)
|
break;
|
|
while ((rtskb = rtskb_dequeue(&tx_queue)) != NULL) {
|
rtdev = rtskb->rtdev;
|
rtdev_xmit_proxy(rtskb);
|
rtdev_dereference(rtdev);
|
}
|
}
|
}
|
|
/* ************************************************************************
|
* hard_xmit
|
*
|
* This function runs in linux kernel context and is executed whenever
|
* there is a frame to be sent out.
|
* ************************************************************************ */
|
static int rtnetproxy_xmit(struct sk_buff *skb, struct net_device *dev)
|
{
|
struct ethhdr *eth = (struct ethhdr *)skb->data;
|
struct rtskb *rtskb;
|
int len = skb->len;
|
#ifndef CONFIG_XENO_DRIVERS_NET_ADDON_PROXY_ARP
|
struct dest_route rt;
|
struct iphdr *iph;
|
u32 saddr, daddr;
|
#endif
|
|
switch (ntohs(eth->h_proto)) {
|
case ETH_P_IP:
|
if (len < sizeof(struct ethhdr) + sizeof(struct iphdr))
|
goto drop1;
|
#ifdef CONFIG_XENO_DRIVERS_NET_ADDON_PROXY_ARP
|
case ETH_P_ARP:
|
#endif
|
break;
|
default:
|
drop1:
|
dev->stats.tx_dropped++;
|
dev_kfree_skb(skb);
|
return NETDEV_TX_OK;
|
}
|
|
rtskb = alloc_rtskb(len, &rtskb_pool);
|
if (!rtskb)
|
return NETDEV_TX_BUSY;
|
|
memcpy(rtskb_put(rtskb, len), skb->data, len);
|
|
#ifdef CONFIG_XENO_DRIVERS_NET_ADDON_PROXY_ARP
|
dev_kfree_skb(skb);
|
|
rtskb->rtdev = rtnetproxy_rtdev;
|
if (rtdev_reference(rtnetproxy_rtdev) == 0) {
|
dev->stats.tx_dropped++;
|
kfree_rtskb(rtskb);
|
return NETDEV_TX_BUSY;
|
}
|
|
#else /* !CONFIG_XENO_DRIVERS_NET_ADDON_PROXY_ARP */
|
iph = (struct iphdr *)(skb->data + sizeof(struct ethhdr));
|
saddr = iph->saddr;
|
daddr = iph->daddr;
|
|
dev_kfree_skb(skb);
|
|
if (rt_ip_route_output(&rt, daddr, INADDR_ANY) < 0) {
|
drop2:
|
dev->stats.tx_dropped++;
|
kfree_rtskb(rtskb);
|
return NETDEV_TX_OK;
|
}
|
if (rt.rtdev->local_ip != saddr) {
|
rtdev_dereference(rt.rtdev);
|
goto drop2;
|
}
|
|
eth = (struct ethhdr *)rtskb->data;
|
memcpy(eth->h_source, rt.rtdev->dev_addr, rt.rtdev->addr_len);
|
memcpy(eth->h_dest, rt.dev_addr, rt.rtdev->addr_len);
|
|
rtskb->rtdev = rt.rtdev;
|
#endif /* CONFIG_XENO_DRIVERS_NET_ADDON_PROXY_ARP */
|
|
dev->stats.tx_packets++;
|
dev->stats.tx_bytes += len;
|
|
rtskb_queue_tail(&tx_queue, rtskb);
|
rtdm_event_signal(&rtnetproxy_tx_event);
|
|
return NETDEV_TX_OK;
|
}
|
|
/* ************************************************************************
|
* ************************************************************************
|
* R E C E I V E
|
* ************************************************************************
|
* ************************************************************************ */
|
|
/* ************************************************************************
|
* This function runs in real-time context.
|
*
|
* It is called from inside rtnet whenever a packet has been received that
|
* has to be processed by rtnetproxy.
|
* ************************************************************************ */
|
static void rtnetproxy_recv(struct rtskb *rtskb)
|
{
|
/* Acquire rtskb (JK) */
|
if (rtskb_acquire(rtskb, &rtskb_pool) != 0) {
|
dev_rtnetproxy->stats.rx_dropped++;
|
rtdm_printk("rtnetproxy_recv: No free rtskb in pool\n");
|
kfree_rtskb(rtskb);
|
return;
|
}
|
|
if (rtskb_queue_tail_check(&rx_queue, rtskb))
|
rtdm_nrtsig_pend(&rtnetproxy_rx_signal);
|
}
|
|
/* ************************************************************************
|
* This function runs in kernel mode.
|
* It is activated from rtnetproxy_signal_handler whenever rtnet received a
|
* frame to be processed by rtnetproxy.
|
* ************************************************************************ */
|
static inline void rtnetproxy_kernel_recv(struct rtskb *rtskb)
|
{
|
struct sk_buff *skb;
|
struct net_device *dev = dev_rtnetproxy;
|
|
int header_len = rtskb->rtdev->hard_header_len;
|
int len = rtskb->len + header_len;
|
|
/* Copy the realtime skb (rtskb) to the standard skb: */
|
skb = dev_alloc_skb(len + 2);
|
skb_reserve(skb, 2);
|
|
memcpy(skb_put(skb, len), rtskb->data - header_len, len);
|
|
/* Set some relevant entries in the skb: */
|
skb->protocol = eth_type_trans(skb, dev);
|
skb->dev = dev;
|
skb->ip_summed = CHECKSUM_UNNECESSARY;
|
skb->pkt_type = PACKET_HOST; /* Extremely important! Why?!? */
|
|
/* the rtskb stamp is useless (different clock), get new one */
|
__net_timestamp(skb);
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 11, 0)
|
dev->last_rx = jiffies;
|
#endif
|
dev->stats.rx_bytes += skb->len;
|
dev->stats.rx_packets++;
|
|
netif_rx(skb); /* pass it to the received stuff */
|
}
|
|
/* ************************************************************************
|
* This function runs in kernel mode.
|
* It is activated from rtnetproxy_recv whenever rtnet received a frame to
|
* be processed by rtnetproxy.
|
* ************************************************************************ */
|
static void rtnetproxy_signal_handler(rtdm_nrtsig_t *nrtsig, void *arg)
|
{
|
struct rtskb *rtskb;
|
|
while ((rtskb = rtskb_dequeue(&rx_queue)) != NULL) {
|
rtnetproxy_kernel_recv(rtskb);
|
kfree_rtskb(rtskb);
|
}
|
}
|
|
/* ************************************************************************
|
* ************************************************************************
|
* G E N E R A L
|
* ************************************************************************
|
* ************************************************************************ */
|
|
static void fake_multicast_support(struct net_device *dev)
|
{
|
}
|
|
#ifdef CONFIG_NET_FASTROUTE
|
static int rtnetproxy_accept_fastpath(struct net_device *dev,
|
struct dst_entry *dst)
|
{
|
return -1;
|
}
|
#endif
|
|
static int rtnetproxy_open(struct net_device *dev)
|
{
|
int err = try_module_get(THIS_MODULE);
|
if (err == 0)
|
return -EIDRM;
|
|
return 0;
|
}
|
|
static int rtnetproxy_stop(struct net_device *dev)
|
{
|
module_put(THIS_MODULE);
|
return 0;
|
}
|
|
static const struct net_device_ops rtnetproxy_netdev_ops = {
|
.ndo_open = rtnetproxy_open,
|
.ndo_stop = rtnetproxy_stop,
|
.ndo_start_xmit = rtnetproxy_xmit,
|
.ndo_set_rx_mode = fake_multicast_support,
|
};
|
|
/* ************************************************************************
|
* device init
|
* ************************************************************************ */
|
static void __init rtnetproxy_init(struct net_device *dev)
|
{
|
/* Fill in device structure with ethernet-generic values. */
|
ether_setup(dev);
|
|
dev->tx_queue_len = 0;
|
#ifdef CONFIG_XENO_DRIVERS_NET_ADDON_PROXY_ARP
|
dev_addr_set(dev, rtnetproxy_rtdev->dev_addr);
|
#else
|
dev->flags |= IFF_NOARP;
|
#endif
|
dev->flags &= ~IFF_MULTICAST;
|
|
dev->netdev_ops = &rtnetproxy_netdev_ops;
|
}
|
|
/* ************************************************************************
|
* ************************************************************************
|
* I N I T
|
* ************************************************************************
|
* ************************************************************************ */
|
static int __init rtnetproxy_init_module(void)
|
{
|
int err;
|
|
#ifdef CONFIG_XENO_DRIVERS_NET_ADDON_PROXY_ARP
|
if ((rtnetproxy_rtdev = rtdev_get_by_name(rtdev_attach)) == NULL) {
|
printk("Couldn't attach to %s\n", rtdev_attach);
|
return -EINVAL;
|
}
|
printk("RTproxy attached to %s\n", rtdev_attach);
|
#endif
|
|
/* Initialize the proxy's rtskb pool (JK) */
|
if (rtskb_module_pool_init(&rtskb_pool, proxy_rtskbs) < proxy_rtskbs) {
|
err = -ENOMEM;
|
goto err1;
|
}
|
|
dev_rtnetproxy =
|
alloc_netdev(0, "rtproxy", NET_NAME_UNKNOWN, rtnetproxy_init);
|
if (!dev_rtnetproxy) {
|
err = -ENOMEM;
|
goto err1;
|
}
|
|
rtdm_nrtsig_init(&rtnetproxy_rx_signal, rtnetproxy_signal_handler,
|
NULL);
|
|
rtskb_queue_init(&tx_queue);
|
rtskb_queue_init(&rx_queue);
|
|
err = register_netdev(dev_rtnetproxy);
|
if (err < 0)
|
goto err3;
|
|
/* Init the task for transmission */
|
rtdm_event_init(&rtnetproxy_tx_event, 0);
|
err = rtdm_task_init(&rtnetproxy_tx_task, "rtnetproxy",
|
rtnetproxy_tx_loop, 0, RTDM_TASK_LOWEST_PRIORITY,
|
0);
|
if (err)
|
goto err4;
|
|
/* Register with RTnet */
|
rt_ip_fallback_handler = rtnetproxy_recv;
|
|
printk("rtnetproxy installed as \"%s\"\n", dev_rtnetproxy->name);
|
|
return 0;
|
|
err4:
|
unregister_netdev(dev_rtnetproxy);
|
|
err3:
|
rtdm_nrtsig_destroy(&rtnetproxy_rx_signal);
|
|
free_netdev(dev_rtnetproxy);
|
|
err1:
|
rtskb_pool_release(&rtskb_pool);
|
#ifdef CONFIG_XENO_DRIVERS_NET_ADDON_PROXY_ARP
|
rtdev_dereference(rtnetproxy_rtdev);
|
#endif
|
return err;
|
}
|
|
static void __exit rtnetproxy_cleanup_module(void)
|
{
|
struct rtskb *rtskb;
|
|
/* Unregister the fallback at rtnet */
|
rt_ip_fallback_handler = NULL;
|
|
/* Unregister the net device: */
|
unregister_netdev(dev_rtnetproxy);
|
free_netdev(dev_rtnetproxy);
|
|
rtdm_event_destroy(&rtnetproxy_tx_event);
|
rtdm_task_destroy(&rtnetproxy_tx_task);
|
|
/* free the non-real-time signal */
|
rtdm_nrtsig_destroy(&rtnetproxy_rx_signal);
|
|
while ((rtskb = rtskb_dequeue(&tx_queue)) != NULL) {
|
rtdev_dereference(rtskb->rtdev);
|
kfree_rtskb(rtskb);
|
}
|
|
while ((rtskb = rtskb_dequeue(&rx_queue)) != NULL) {
|
kfree_rtskb(rtskb);
|
}
|
|
rtskb_pool_release(&rtskb_pool);
|
|
#ifdef CONFIG_XENO_DRIVERS_NET_ADDON_PROXY_ARP
|
rtdev_dereference(rtnetproxy_rtdev);
|
#endif
|
}
|
|
module_init(rtnetproxy_init_module);
|
module_exit(rtnetproxy_cleanup_module);
|
MODULE_LICENSE("GPL");
|
