umka/vnet.c

137 lines
3.6 KiB
C

/*
SPDX-License-Identifier: GPL-2.0-or-later
UMKa - User-Mode KolibriOS developer tools
vnet - virtual network card
Copyright (C) 2020-2023 Ivan Baravy <dunkaist@gmail.com>
Copyright (C) 2021 Magomed Kostoev <mkostoevr@yandex.ru>
*/
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <pthread.h>
#include <signal.h>
#include <stdatomic.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "umka.h"
#include "umkart.h"
#include "trace.h"
#include "vnet.h"
#include "vnet/tap.h"
#include "vnet/file.h"
#ifndef _WIN32
#include <unistd.h>
#else
#include <io.h>
#endif
#define STACK_SIZE 0x10000
static int
vnet_input(void *udata) {
umka_sti();
int plen = 0;
struct vnet *vnet = udata;
// fprintf(stderr, "[vnet] input interrupt\n");
net_buff_t *buf = kos_net_buff_alloc(NET_BUFFER_SIZE);
if (!buf) {
fprintf(stderr, "[vnet] Can't allocate network buffer!\n");
return 1;
}
buf->device = &vnet->eth.net;
/*
plen = read(fd, buf->data, NET_BUFFER_SIZE - offsetof(net_buff_t, data));
if (plen == -1) {
plen = 0; // we have just allocated a buffer, so we have to submit it
}
*/
plen = vnet->bufin_len;
memcpy(buf->data, vnet->bufin, vnet->bufin_len);
/*
fprintf(stderr, "[vnet] read %i bytes\n", plen);
for (int i = 0; i < plen; i++) {
fprintf(stderr, " %2.2x", buf->data[i]);
}
fprintf(stderr, "\n");
*/
buf->length = plen;
buf->offset = offsetof(net_buff_t, data);
kos_eth_input(buf);
vnet->input_processed = 1;
//fprintf(stderr, "[vnet_input] signal before\n");
// pthread_cond_signal(&vnet->cond);
//fprintf(stderr, "[vnet_input] signal after\n");
return 1; // acknowledge our interrupt
}
static void *
vnet_input_monitor(void *arg) {
struct vnet *vnet = arg;
while (1) {
ssize_t nread = read(vnet->fdin, vnet->bufin, VNET_BUFIN_CAP);
vnet->input_processed = 0;
vnet->bufin_len = nread;
atomic_store_explicit(&umka_irq_number, UMKA_IRQ_NETWORK,
memory_order_release);
raise(UMKA_SIGNAL_IRQ); // FIXME: not atomic with the above
//fprintf(stderr, "[vnet_input_monitor] wait for signal\n");
// pthread_cond_wait(&vnet->cond, &vnet->mutex); // TODO: handle spurious
//fprintf(stderr, "[vnet_input_monitor] got signal\n");
}
return NULL;
}
struct vnet *
vnet_init(enum vnet_type type) {
struct vnet *vnet;
switch (type) {
case VNET_FILE:
vnet = vnet_init_file();
break;
case VNET_TAP:
vnet = vnet_init_tap();
break;
default:
fprintf(stderr, "[vnet] bad vnet type: %d\n", type);
return NULL;
}
if (!vnet) {
fprintf(stderr, "[vnet] device initialization failed\n");
return NULL;
}
vnet->eth.net.link_state = ETH_LINK_FD + ETH_LINK_10M;
vnet->eth.net.hwacc = 0;
vnet->eth.net.bytes_tx = 0;
vnet->eth.net.bytes_rx = 0;
vnet->eth.net.packets_tx = 0;
vnet->eth.net.packets_tx_err = 0;
vnet->eth.net.packets_tx_drop = 0;
vnet->eth.net.packets_tx_ovr = 0;
vnet->eth.net.packets_rx = 0;
vnet->eth.net.packets_rx_err = 0;
vnet->eth.net.packets_rx_drop = 0;
vnet->eth.net.packets_rx_ovr = 0;
// pthread_cond_init(&vnet->cond, NULL);
// pthread_mutex_init(&vnet->mutex, NULL);
// pthread_mutex_lock(&vnet->mutex);
kos_attach_int_handler(UMKA_IRQ_NETWORK, vnet_input, vnet);
fprintf(stderr, "[vnet] start input_monitor thread\n");
pthread_t thread_input_monitor;
pthread_create(&thread_input_monitor, NULL, vnet_input_monitor, vnet);
return vnet;
}