static uint64_t queue_id = 0;
static uint64_t card_mac = -1ULL;
-static struct descq *devq_rx = NULL;
-static uint64_t bufid_rx;
-static regionid_t regid_rx;
-
-static struct descq *devq_tx = NULL;
-static uint64_t bufid_tx;
-static regionid_t regid_tx;
-
-static struct devq *devq_direct = NULL;
-static regionid_t regid_direct;
-static bool direct = false;
-static bool reg = false;
+static struct devq *devq = NULL;
+static regionid_t regid;
+static uint64_t bufid;
static struct capref buffer_frame;
size_t more_chunks, uint64_t flags)
{
errval_t err;
+ uint64_t flags_new = flags | NETIF_TXFLAG | NETIF_TXFLAG_LAST;
+
offset += idx * BUFFER_SIZE;
- if (!direct) {
- err = devq_enqueue((struct devq *)devq_tx, regid_tx, offset, length, 0, 0, flags);
- } else {
- flags = 0;
- err = devq_enqueue((struct devq *)devq_direct, regid_direct, offset,
- length, 0, length, (flags | NETIF_TXFLAG | NETIF_TXFLAG_LAST));
- }
+ err = devq_enqueue((struct devq *)devq, regid, offset,
+ length, 0, length, flags_new);
return err;
}
{
errval_t err;
size_t offset;
-
+ uint64_t flags = NETIF_RXFLAG;
+
offset = idx * BUFFER_SIZE;
- if (!direct) {
- err = devq_enqueue((struct devq *)devq_rx, regid_rx, offset, BUFFER_SIZE, 0, 0, 0);
- } else {
- uint64_t flags = 0;
- err = devq_enqueue((struct devq *)devq_direct, regid_direct, offset, BUFFER_SIZE,
- 0, BUFFER_SIZE, flags | NETIF_RXFLAG);
- }
+ err = devq_enqueue((struct devq *)devq, regid, offset, BUFFER_SIZE,
+ 0, BUFFER_SIZE, flags);
return err;
}
errval_t err;
alloc_mem(&buffer_frame, &buffer_base, BUFFER_SIZE * count);
- if (!direct) {
- err = devq_register((struct devq *)devq_rx, buffer_frame, ®id_rx);
- assert(err_is_ok(err));
- err = devq_register((struct devq *)devq_tx, buffer_frame, ®id_tx);
- assert(err_is_ok(err));
- } else {
- err = devq_register((struct devq *)devq_direct, buffer_frame, ®id_direct);
- assert(err_is_ok(err));
- reg = true;
- }
+ err = devq_register((struct devq *)devq, buffer_frame, ®id);
+ assert(err_is_ok(err));
}
// Returns the bufferid for specified type (RX, TX)
uint64_t get_rx_bufferid(void)
{
- return bufid_rx;
+ return bufid;
}
uint64_t get_tx_bufferid(void)
{
- return bufid_tx;
+ return bufid;
}
-static errval_t notify_rx(struct descq *queue)
+static errval_t notify_handler(struct descq *queue)
{
regionid_t rid;
genoffset_t offset;
genoffset_t valid_data;
genoffset_t valid_length;
uint64_t flags;
+ int count = 0;
- for (;;) {
+ for(;;){
errval_t err;
- err = devq_dequeue((struct devq *)queue, &rid, &offset, &length,
+ err = devq_dequeue((struct devq*) queue, &rid, &offset, &length,
&valid_data, &valid_length, &flags);
if (err_is_fail(err))
break;
- size_t idx = offset / BUFFER_SIZE;
- benchmark_rx_done(idx, length, 0/*more*/, flags);
- }
- return SYS_ERR_OK;
-}
-static errval_t notify_tx(struct descq *queue)
-{
- regionid_t rid;
- genoffset_t offset;
- genoffset_t length;
- genoffset_t valid_data;
- genoffset_t valid_length;
- uint64_t flags;
-
- for (;;) {
- errval_t err;
- err = devq_dequeue((struct devq *)queue, &rid, &offset, &length,
- &valid_data, &valid_length, &flags);
- if (err_is_fail(err))
- break;
+ count++;
size_t idx = offset / BUFFER_SIZE;
- benchmark_tx_done(idx);
+ if (flags & NETIF_TXFLAG) {
+ benchmark_tx_done(idx);
+ } else if (flags & NETIF_RXFLAG) {
+ assert(valid_length > 0);
+ benchmark_rx_done(idx, valid_length, 0/*more*/, flags);
+ }
}
return SYS_ERR_OK;
}
-static void connect_to_driver(const char *cname, uint64_t qid, bool isRX, struct waitset *ws)
+
+static void connect_to_driver(const char *cname, uint64_t qid, struct waitset *ws)
{
errval_t err;
char qm_name[MAX_SERVICE_NAME_LEN] = { 0 };
snprintf(qm_name, sizeof(qm_name), "%s_%"PRIu64"", cname, qid);
debug_printf("%s: nqm bind [%s]\n", __func__, qm_name);
+ struct descq* q;
struct descq_func_pointer f;
- f.notify = isRX ? notify_rx: notify_tx;
+ f.notify = notify_handler;
- err = descq_create(isRX ? &devq_rx: &devq_tx, DESCQ_DEFAULT_SIZE, qm_name,
- false, true, !isRX, isRX ? &bufid_rx: &bufid_tx, &f);
+ err = descq_create(&q, DESCQ_DEFAULT_SIZE, qm_name,
+ false, true, 0, &bufid, &f);
assert(err_is_ok(err));
+ devq = (struct devq*) q;
}
+
#if defined(__x86_64__)
static void int_handler(void* args)
{
for(;;){
errval_t err;
- err = devq_dequeue(devq_direct, &rid, &offset, &length,
+ err = devq_dequeue(devq, &rid, &offset, &length,
&valid_data, &valid_length, &flags);
if (err_is_fail(err))
break;
- printf("Dequeue \n");
count++;
size_t idx = offset / BUFFER_SIZE;
if (flags & NETIF_TXFLAG) {
#if defined(__x86_64__)
if ((strcmp(cardname, "e1000") == 0) || (qid == 0)) {
- connect_to_driver(cardname, queue_id, true, ws);
- // Connect TX path
- connect_to_driver(cardname, queue_id, false, ws);
+ connect_to_driver(cardname, queue_id, ws);
} else if ((strcmp(cardname, "e10k") == 0) && (qid != 0)) {
- USER_PANIC("e10k queue NIY \n");
- direct = true;
+ USER_PANIC("e10k queue NIY \n");
struct e10k_queue* e10k;
- err = e10k_queue_create(&e10k, int_handler, false, false);
+ err = e10k_queue_create(&e10k, int_handler, false, true);
assert(err_is_ok(err));
- devq_direct = (struct devq*) e10k;
+ devq = (struct devq*) e10k;
card_mac = 0x1; // TODO
} else if ((strcmp(cardname, "sfn5122f") == 0) && qid != 0) {
- direct = true;
struct sfn5122f_queue* sfn5122f;
err = sfn5122f_queue_create(&sfn5122f, int_handler,
false /*userlevel network feature*/,
true /* user interrupts*/);
assert(err_is_ok(err));
- devq_direct = (struct devq*) sfn5122f;
- //card_mac = 0x000f530748d4; // TODO
+ devq = (struct devq*) sfn5122f;
} else {
USER_PANIC("Unknown card name \n");
}
#else
connect_to_driver(cardname, queue_id, true, ws);
- // Connect TX path
- connect_to_driver(cardname, queue_id, false, ws);
#endif
buffers_init(BUFFER_COUNT);
// Get MAC address
- if(!direct) {
- err = devq_control((struct devq *)devq_rx, 0, 0, &card_mac);
- assert(err_is_ok(err));
- } else {
- err = devq_control((struct devq *)devq_direct, 0, 0, &card_mac);
- printf("MAC %16lX \n", card_mac);
- assert(err_is_ok(err));
- }
+ err = devq_control((struct devq *)devq, 0, 0, &card_mac);
+ assert(err_is_ok(err));
initialized = true;
}
{
debug_printf("Register \n");
// Actual register_buffer function with all it's logic
- ETHERSRV_DEBUG("ethersrv:register buffer called with slots %"PRIu64"\n",
- slots);
+ ETHERSRV_DEBUG("ethersrv:register buffer called \n");
errval_t err;
struct client_closure *closure = (struct client_closure *)devq_get_state((struct devq *)q);
closure->queueid = exported_queueid;
uint64_t offset, uint64_t length,
uint64_t more, uint64_t flags)
{
+ if (flags & NETIF_TXFLAG) {
+ ETHERSRV_DEBUG("Sending TX buf on queue\n");
+ } else {
+ ETHERSRV_DEBUG("Sending RX buf on queue\n");
+ }
struct client_closure *cl = (struct client_closure *)devq_get_state(queue);
errval_t err;
- err = devq_enqueue(queue, cl->region_id, offset, length, 0, 0, flags);
+ err = devq_enqueue(queue, cl->region_id, offset, length, 0, length, flags);
assert(err_is_ok(err));
return err;
} // end function: send_raw_xmit_done
// Handle raw interface
errval_t err = send_raw_xmit_done(bsm->device_queue, (uintptr_t)bsm->offset, 0,
- 0, 0);
+ 0, NETIF_TXFLAG | NETIF_TXFLAG_LAST);
if (err_is_ok(err)) {
return true;
} else {
assert(buf->rxq.buffer_state_used > 0);
errval_t err = send_raw_xmit_done(bsm->device_queue, bsm->offset,
- bufs[i].len, (i != count - 1), flags);
+ bufs[i].len, (i != count - 1), flags | NETIF_RXFLAG);
if (err_is_ok(err)) {
--buf->rxq.buffer_state_used;
return;
#endif // TRACE_ETHERSRV_MODE
// Handle raw interface
- errval_t err = send_raw_xmit_done(q, offset, len, 0, flags);
+ errval_t err = send_raw_xmit_done(q, offset, len, 0, flags | NETIF_RXFLAG);
if (err_is_ok(err)) {
return true;
} else {
if (err_is_fail(err))
break;
- if (cl->buffer_ptr->role == TX_BUFFER_ID) {
+ if (flags & NETIF_TXFLAG) {
// debug_printf("notify_queue_tx: %p: %d:%lx:%ld\n", queue, rid, offset, length);
raw_add_buffer_tx(cl, offset, length, 0, flags);
} else {
// This function tells if netd is registered or not.
bool waiting_for_netd(void)
{
- return (netd_buffer_count < 2);
+ return (netd_buffer_count < 1);
// return ((netd[RECEIVE_CONNECTION] == NULL)
// || (netd[TRANSMIT_CONNECTION] == NULL));
} // end function: is_netd_registered