static int netdev_register_port(struct net_device *ndev)
{
struct vmm_netport *port;
const char *attr;
struct vmm_netswitch *nsw;
struct vmm_device *dev = ndev->vmm_dev;
port = vmm_netport_alloc(ndev->name, VMM_NETPORT_DEF_QUEUE_SIZE);
if (!port) {
vmm_printf("Failed to allocate netport for %s\n", ndev->name);
return VMM_ENOMEM;
}
port->dev.parent = dev;
port->mtu = ndev->mtu;
port->link_changed = netdev_set_link;
port->can_receive = netdev_can_receive;
port->switch2port_xfer = netdev_switch2port_xfer;
port->priv = ndev;
memcpy(port->macaddr, ndev->dev_addr, ETH_ALEN);
ndev->nsw_priv = port;
vmm_netport_register(port);
if (dev) {
if (dev->of_node &&
vmm_devtree_read_string(dev->of_node,
"switch", &attr) == VMM_OK) {
nsw = vmm_netswitch_find(attr);
if (!nsw) {
vmm_panic("%s: Cannot find netswitch \"%s\"\n",
ndev->name, attr);
}
vmm_netswitch_port_add(nsw, port);
} else {
/* Add port to default switch if not specified. */
nsw = vmm_netswitch_default();
if (nsw) {
vmm_netswitch_port_add(nsw, port);
} else {
vmm_panic("%s: Failed to find default "
"netswitch\n", ndev->name);
}
}
}
return VMM_OK;
}
static int virtio_net_connect(struct virtio_device *dev,
struct virtio_emulator *emu)
{
int i, rc;
char *attr;
struct virtio_net_dev *ndev;
struct vmm_netswitch *nsw;
ndev = vmm_zalloc(sizeof(struct virtio_net_dev));
if (!ndev) {
vmm_printf("Failed to allocate virtio net device....\n");
return VMM_EFAIL;
}
ndev->vdev = dev;
vmm_snprintf(ndev->name, VIRTIO_DEVICE_MAX_NAME_LEN, "%s", dev->name);
ndev->port = vmm_netport_alloc(ndev->name, VMM_NETPORT_DEF_QUEUE_SIZE);
ndev->port->mtu = VIRTIO_NET_MTU;
ndev->port->link_changed = virtio_net_set_link;
ndev->port->can_receive = virtio_net_can_receive;
ndev->port->switch2port_xfer = virtio_net_switch2port_xfer;
ndev->port->priv = ndev;
rc = vmm_netport_register(ndev->port);
if (rc) {
vmm_netport_free(ndev->port);
vmm_free(ndev);
return rc;
}
attr = vmm_devtree_attrval(dev->edev->node, "switch");
if (attr) {
nsw = vmm_netswitch_find((char *)attr);
if (!nsw) {
vmm_printf("%s: Cannot find netswitch \"%s\"\n",
__func__, (char *)attr);
} else {
vmm_netswitch_port_add(nsw, ndev->port);
}
}
for (i = 0; i < 6; i++) {
ndev->config.mac[i] = vmm_netport_mac(ndev->port)[i];
}
ndev->config.status = VIRTIO_NET_S_LINK_UP;
dev->emu_data = ndev;
return VMM_OK;
}
static int __init lwip_netstack_init(void)
{
int rc;
struct vmm_netswitch *nsw;
struct vmm_devtree_node *node;
const char *str;
u8 ip[] = {169, 254, 1, 1};
u8 mask[] = {255, 255, 255, 0};
ip_addr_t __ip, __nm, __gw;
/* Clear lwIP state */
memset(&lns, 0, sizeof(lns));
/* Get netstack device tree node if available */
node = vmm_devtree_getnode(VMM_DEVTREE_PATH_SEPARATOR_STRING
VMM_DEVTREE_VMMINFO_NODE_NAME
VMM_DEVTREE_PATH_SEPARATOR_STRING
VMM_DEVTREE_VMMNET_NODE_NAME
VMM_DEVTREE_PATH_SEPARATOR_STRING
VMM_DEVTREE_NETSTACK_NODE_NAME);
/* Retrive preferred IP address */
if (vmm_devtree_read_string(node, "ipaddr", &str) == VMM_OK) {
/* Read ip address from netstack node */
str2ipaddr(ip, str);
}
/* Retrive preferred IP address */
if (vmm_devtree_read_string(node, "netmask", &str) == VMM_OK) {
/* Read network mask from netstack node */
str2ipaddr(mask, str);
}
/* Retrive preferred netswitch */
if (vmm_devtree_read_string(node, "netswitch", &str) == VMM_OK) {
/* Find netswitch with given name */
nsw = vmm_netswitch_find(str);
} else {
/* Get default netswitch */
nsw = vmm_netswitch_default();
}
if (!nsw) {
vmm_panic("%s: No netswitch found\n", __func__);
}
/* Release netstack device tree node */
vmm_devtree_dref_node(node);
/* Allocate a netport */
lns.port = vmm_netport_alloc("lwip-netport", VMM_NETPORT_DEF_QUEUE_SIZE);
if (!lns.port) {
vmm_printf("%s: vmm_netport_alloc() failed\n", __func__);
rc = VMM_ENOMEM;
goto fail;
}
/* Setup a netport */
lns.port->mtu = 1500;
lns.port->link_changed = lwip_set_link;
lns.port->can_receive = lwip_can_receive;
lns.port->switch2port_xfer = lwip_switch2port_xfer;
lns.port->priv = &lns;
/* Register a netport */
rc = vmm_netport_register(lns.port);
if (rc) {
goto fail1;
}
/* Initialize lwIP + TCP/IP APIs */
tcpip_init(NULL, NULL);
/* Add netif */
IP4_ADDR(&__ip, ip[0],ip[1],ip[2],ip[3]);
IP4_ADDR(&__nm, mask[0],mask[1],mask[2],mask[3]);
IP4_ADDR(&__gw, ip[0],ip[1],ip[2],ip[3]);
netif_add(&lns.nif, &__ip, &__nm, &__gw, &lns,
lwip_netstack_netif_init, ethernet_input);
/* Set default netif */
netif_set_default(&lns.nif);
/* Attach netport with netswitch
* Note: This will cause netport link_change()
*/
rc = vmm_netswitch_port_add(nsw, lns.port);
if (rc) {
goto fail2;
}
#if !defined(PING_USE_SOCKETS)
/* Initalize RAW PCB for ping */
ping_raw_init();
#endif
return VMM_OK;
fail2:
vmm_netport_unregister(lns.port);
fail1:
vmm_netport_free(lns.port);
fail:
return rc;
}
int uip_netport_init(void)
{
struct vmm_netswitch *nsw;
struct uip_port_state *s = &uip_port_state;
struct uip_fw_netif *netif;
uip_ipaddr_t ipaddr;
char tname[64];
uip_buf = vmm_malloc(UIP_BUFSIZE + 2);
if(!uip_buf) {
vmm_panic("%s: uip_buf alloc failed\n", __func__);
}
INIT_SPIN_LOCK(&s->lock);
INIT_LIST_HEAD(&s->rxbuf);
INIT_COMPLETION(&s->rx_possible);
/* Get the first netswitch */
nsw = vmm_netswitch_get(0);
if(!nsw) {
vmm_panic("No netswitch found\n");
}
/* Create a port-name */
vmm_sprintf(tname, "%s-uip", nsw->name);
/* Allocate a netport for this netswitch */
s->port = vmm_netport_alloc(tname);
if(!s->port) {
vmm_printf("UIP->netport alloc failed\n");
return VMM_EFAIL;
}
/* Allocate a uip_fw_netif */
netif = vmm_malloc(sizeof(struct uip_fw_netif));
if(!netif) {
vmm_printf("UIP->netif alloc failed\n");
return VMM_EFAIL;
}
/* Register the netport */
s->port->mtu = UIP_BUFSIZE;
s->port->link_changed = uip_set_link;
s->port->can_receive = uip_can_receive;
s->port->switch2port_xfer = uip_switch2port_xfer;
s->port->priv = s;
s->netif = netif;
vmm_netport_register(s->port);
/* Attach with the netswitch */
vmm_netswitch_port_add(nsw, s->port);
/* Notify our ethernet address */
uip_setethaddr(((struct uip_eth_addr *)(s->port->macaddr)));
/* Generate an IP address */
uip_ipaddr(ipaddr, 192,168,0,1);
uip_fw_setipaddr(netif, ipaddr);
uip_ipaddr(ipaddr, 255,255,255,0);
uip_fw_setnetmask(netif, ipaddr);
/* Register the netif with uip stack */
netif->output = &uip_netport_output;
netif->priv = s;
uip_fw_register(netif);
/* Set this interface as default one */
uip_fw_default(netif);
return 0;
}
