Skip to content

GitLab

Commit d4666c97 authored by Antoine Kaufmann's avatar Antoine Kaufmann
Browse files

Reformat closer to google style

parent eb125a88
Show whitespace changes
Inline Side-by-side
Showing with 3623 additions and 3840 deletions
sims/nic/corundum_bm/corundum_bm.h
View file @ d4666c97
......@@ -24,9 +24,10 @@
#pragma once
#include <stdint.h>
#include <list>
#include <vector>
#include <stdint.h>
extern "C" {
#include <simbricks/proto/pcie.h>
}
......@@ -188,7 +189,7 @@ struct DMAOp : public nicbm::DMAOp {
};
class DescRing {
public:
public:
DescRing();
~DescRing();
......@@ -207,7 +208,7 @@ public:
virtual void dmaDone(DMAOp *op) = 0;
protected:
protected:
bool empty();
bool full();
bool updatePtr(ptr_t ptr, bool head);
......@@ -227,7 +228,7 @@ protected:
};
class EventRing : public DescRing {
public:
public:
EventRing();
~EventRing();
......@@ -236,14 +237,14 @@ public:
};
class CplRing : public DescRing {
public:
public:
CplRing(EventRing *eventRing);
~CplRing();
void dmaDone(DMAOp *op) override;
void complete(unsigned index, size_t len, bool tx);
private:
private:
struct CplData {
unsigned index;
size_t len;
......@@ -254,31 +255,31 @@ private:
};
class TxRing : public DescRing {
public:
public:
TxRing(CplRing *cplRing);
~TxRing();
void setHeadPtr(ptr_t ptr) override;
void dmaDone(DMAOp *op) override;
private:
private:
CplRing *txCplRing;
};
class RxRing : public DescRing {
public:
public:
RxRing(CplRing *cplRing);
~RxRing();
void dmaDone(DMAOp *op) override;
void rx(RxData *rx_data);
private:
private:
CplRing *rxCplRing;
};
class Port {
public:
public:
Port();
~Port();
......@@ -304,7 +305,7 @@ public:
void queueEnable();
void queueDisable();
private:
private:
unsigned _id;
unsigned _features;
size_t _mtu;
......@@ -318,7 +319,7 @@ private:
};
class Corundum : public nicbm::SimpleDevice<reg_t> {
public:
public:
Corundum();
~Corundum();
......@@ -328,7 +329,7 @@ public:
virtual void dma_complete(nicbm::DMAOp &op);
virtual void eth_rx(uint8_t port, const void *data, size_t len);
private:
private:
EventRing eventRing;
TxRing txRing;
CplRing txCplRing;
......
sims/nic/corundum_bm/tester.c
View file @ d4666c97
......@@ -22,19 +22,18 @@
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <stdlib.h>
#include <assert.h>
#include <cosim_pcie_proto.h>
#include <fcntl.h>
#include <nicsim.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/mman.h>
#include <unistd.h>
#include <signal.h>
#include <fcntl.h>
#include <assert.h>
#include <nicsim.h>
#include <cosim_pcie_proto.h>
static uint8_t *d2h_queue;
static size_t d2h_pos;
......@@ -46,13 +45,11 @@ static size_t h2d_pos;
static size_t h2d_elen;
static size_t h2d_enum;
static void sigint_handler(int dummy)
{
static void sigint_handler(int dummy) {
exit(1);
}
static int uxsocket_init()
{
static int uxsocket_init() {
int cfd;
if ((cfd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
......@@ -72,8 +69,7 @@ static int uxsocket_init()
return cfd;
}
static int queue_create(const struct cosim_pcie_proto_dev_intro di)
{
static int queue_create(const struct cosim_pcie_proto_dev_intro di) {
int fd = -1;
if ((fd = open("/dev/shm/dummy_nic_shm", O_RDWR)) == -1) {
perror("Failed to open shm file");
......@@ -106,11 +102,9 @@ error:
return -1;
}
volatile union cosim_pcie_proto_h2d *h2d_alloc()
{
volatile union cosim_pcie_proto_h2d *h2d_alloc() {
volatile union cosim_pcie_proto_h2d *msg =
(volatile union cosim_pcie_proto_h2d *)
(h2d_queue + h2d_pos * h2d_elen);
(volatile union cosim_pcie_proto_h2d *)(h2d_queue + h2d_pos * h2d_elen);
if ((msg->dummy.own_type & COSIM_PCIE_PROTO_H2D_OWN_MASK) !=
COSIM_PCIE_PROTO_H2D_OWN_HOST) {
......@@ -122,12 +116,10 @@ volatile union cosim_pcie_proto_h2d *h2d_alloc()
return msg;
}
volatile union cosim_pcie_proto_d2h *d2h_poll()
{
volatile union cosim_pcie_proto_d2h *d2h_poll() {
volatile union cosim_pcie_proto_d2h *msg;
msg = (volatile union cosim_pcie_proto_d2h *)
(d2h_queue + d2h_pos * d2h_elen);
msg = (volatile union cosim_pcie_proto_d2h *)(d2h_queue + d2h_pos * d2h_elen);
if ((msg->dummy.own_type & COSIM_PCIE_PROTO_D2H_OWN_MASK) ==
COSIM_PCIE_PROTO_D2H_OWN_DEV) {
return NULL;
......@@ -135,23 +127,20 @@ volatile union cosim_pcie_proto_d2h *d2h_poll()
return msg;
}
void d2h_done(volatile union cosim_pcie_proto_d2h *msg)
{
msg->dummy.own_type = (msg->dummy.own_type & COSIM_PCIE_PROTO_D2H_MSG_MASK)
| COSIM_PCIE_PROTO_D2H_OWN_DEV;
void d2h_done(volatile union cosim_pcie_proto_d2h *msg) {
msg->dummy.own_type = (msg->dummy.own_type & COSIM_PCIE_PROTO_D2H_MSG_MASK) |
COSIM_PCIE_PROTO_D2H_OWN_DEV;
d2h_pos = (d2h_pos + 1) % d2h_enum;
}
static void dev_read(uint64_t offset, uint16_t len)
{
static void dev_read(uint64_t offset, uint16_t len) {
volatile union cosim_pcie_proto_h2d *h2d_msg = h2d_alloc();
volatile struct cosim_pcie_proto_h2d_read *read = &h2d_msg->read;
read->req_id = 0xF;
read->offset = offset;
read->len = len;
read->bar = 0;
read->own_type = COSIM_PCIE_PROTO_H2D_MSG_READ |
COSIM_PCIE_PROTO_H2D_OWN_DEV;
read->own_type = COSIM_PCIE_PROTO_H2D_MSG_READ | COSIM_PCIE_PROTO_H2D_OWN_DEV;
volatile union cosim_pcie_proto_d2h *d2h_msg = NULL;
while (d2h_msg == NULL) {
......@@ -169,8 +158,7 @@ static void dev_read(uint64_t offset, uint16_t len)
d2h_done(d2h_msg);
}
int main(int argc, char *argv[])
{
int main(int argc, char *argv[]) {
signal(SIGINT, sigint_handler);
int cfd;
......
sims/nic/i40e_bm/headers.h
View file @ d4666c97
......@@ -46,7 +46,6 @@ struct eth_hdr {
uint16_t type;
} __attribute__((packed));
/******************************************************************************/
/* IPv4 */
......@@ -97,7 +96,6 @@ struct ip_hdr {
uint32_t dest;
} __attribute__((packed));
/******************************************************************************/
/* ARP */
......@@ -118,7 +116,6 @@ struct arp_hdr {
uint32_t tpa;
} __attribute__((packed));
/******************************************************************************/
/* TCP */
......@@ -140,21 +137,24 @@ struct arp_hdr {
#define TCPH_HDRLEN(phdr) (ntohs((phdr)->_hdrlen_rsvd_flags) >> 12)
#define TCPH_FLAGS(phdr) (ntohs((phdr)->_hdrlen_rsvd_flags) & TCP_FLAGS)
#define TCPH_HDRLEN_SET(phdr, len) (phdr)->_hdrlen_rsvd_flags = \
htons(((len) << 12) | TCPH_FLAGS(phdr))
#define TCPH_FLAGS_SET(phdr, flags) (phdr)->_hdrlen_rsvd_flags = \
(((phdr)->_hdrlen_rsvd_flags & PP_HTONS( \
(uint16_t)(~(uint16_t)(TCP_FLAGS)))) | htons(flags))
#define TCPH_HDRLEN_SET(phdr, len) \
(phdr)->_hdrlen_rsvd_flags = htons(((len) << 12) | TCPH_FLAGS(phdr))
#define TCPH_FLAGS_SET(phdr, flags) \
(phdr)->_hdrlen_rsvd_flags = \
(((phdr)->_hdrlen_rsvd_flags & \
PP_HTONS((uint16_t)(~(uint16_t)(TCP_FLAGS)))) | \
htons(flags))
#define TCPH_HDRLEN_FLAGS_SET(phdr, len, flags) \
(phdr)->_hdrlen_rsvd_flags = htons(((len) << 12) | (flags))
#define TCPH_SET_FLAG(phdr, flags) (phdr)->_hdrlen_rsvd_flags = \
((phdr)->_hdrlen_rsvd_flags | htons(flags))
#define TCPH_UNSET_FLAG(phdr, flags) (phdr)->_hdrlen_rsvd_flags = \
htons(ntohs((phdr)->_hdrlen_rsvd_flags) | (TCPH_FLAGS(phdr) & ~(flags)) )
#define TCPH_SET_FLAG(phdr, flags) \
(phdr)->_hdrlen_rsvd_flags = ((phdr)->_hdrlen_rsvd_flags | htons(flags))
#define TCPH_UNSET_FLAG(phdr, flags) \
(phdr)->_hdrlen_rsvd_flags = \
htons(ntohs((phdr)->_hdrlen_rsvd_flags) | (TCPH_FLAGS(phdr) & ~(flags)))
#define TCP_TCPLEN(seg) ((seg)->len + ((TCPH_FLAGS((seg)->tcphdr) & \
(TCP_FIN | TCP_SYN)) != 0))
#define TCP_TCPLEN(seg) \
((seg)->len + ((TCPH_FLAGS((seg)->tcphdr) & (TCP_FIN | TCP_SYN)) != 0))
struct tcp_hdr {
uint16_t src;
......@@ -167,7 +167,6 @@ struct tcp_hdr {
uint16_t urgp;
} __attribute__((packed));
/******************************************************************************/
/* UDP */
......@@ -178,7 +177,6 @@ struct udp_hdr {
uint16_t chksum;
} __attribute__((packed));
/******************************************************************************/
/* whole packets */
......
sims/nic/i40e_bm/i40e_adminq.cc
View file @ d4666c97
......@@ -24,40 +24,39 @@
#include <stdlib.h>
#include <string.h>
#include <cassert>
#include <iostream>
#include "sims/nic/i40e_bm/i40e_bm.h"
#include "sims/nic/i40e_bm/i40e_base_wrapper.h"
#include "sims/nic/i40e_bm/i40e_bm.h"
using namespace i40e;
extern nicbm::Runner *runner;
queue_admin_tx::queue_admin_tx(i40e_bm &dev_, uint64_t &reg_base_,
uint32_t &reg_len_, uint32_t &reg_head_, uint32_t &reg_tail_)
: queue_base("atx", reg_head_, reg_tail_), dev(dev_), reg_base(reg_base_),
reg_len(reg_len_)
{
uint32_t &reg_len_, uint32_t &reg_head_,
uint32_t &reg_tail_)
: queue_base("atx", reg_head_, reg_tail_),
dev(dev_),
reg_base(reg_base_),
reg_len(reg_len_) {
desc_len = 32;
ctxs_init();
}
queue_base::desc_ctx &queue_admin_tx::desc_ctx_create()
{
queue_base::desc_ctx &queue_admin_tx::desc_ctx_create() {
return *new admin_desc_ctx(*this, dev);
}
void queue_admin_tx::reg_updated()
{
void queue_admin_tx::reg_updated() {
base = reg_base;
len = (reg_len & I40E_GL_ATQLEN_ATQLEN_MASK) >> I40E_GL_ATQLEN_ATQLEN_SHIFT;
if (!enabled && (reg_len & I40E_GL_ATQLEN_ATQENABLE_MASK)) {
#ifdef DEBUG_ADMINQ
log << " enable base=" << base << " len=" << len <<
logger::endl;
log << " enable base=" << base << " len=" << len << logger::endl;
#endif
enabled = true;
} else if (enabled && !(reg_len & I40E_GL_ATQLEN_ATQENABLE_MASK)) {
......@@ -72,19 +71,16 @@ void queue_admin_tx::reg_updated()
queue_admin_tx::admin_desc_ctx::admin_desc_ctx(queue_admin_tx &queue_,
i40e_bm &dev_)
: i40e::queue_base::desc_ctx(queue_), aq(queue_), dev(dev_)
{
d = reinterpret_cast <struct i40e_aq_desc *> (desc);
: i40e::queue_base::desc_ctx(queue_), aq(queue_), dev(dev_) {
d = reinterpret_cast<struct i40e_aq_desc *>(desc);
}
void queue_admin_tx::admin_desc_ctx::data_written(uint64_t addr, size_t len)
{
void queue_admin_tx::admin_desc_ctx::data_written(uint64_t addr, size_t len) {
processed();
}
void queue_admin_tx::admin_desc_ctx::desc_compl_prepare(uint16_t retval,
uint16_t extra_flags)
{
uint16_t extra_flags) {
d->flags &= ~0x1ff;
d->flags |= I40E_AQ_FLAG_DD | I40E_AQ_FLAG_CMP | extra_flags;
if (retval)
......@@ -92,24 +88,25 @@ void queue_admin_tx::admin_desc_ctx::desc_compl_prepare(uint16_t retval,
d->retval = retval;
#ifdef DEBUG_ADMINQ
queue.log << " desc_compl_prepare index=" << index << " retval=" <<
retval << logger::endl;
queue.log << " desc_compl_prepare index=" << index << " retval=" << retval
<< logger::endl;
#endif
}
void queue_admin_tx::admin_desc_ctx::desc_complete(uint16_t retval,
uint16_t extra_flags)
{
uint16_t extra_flags) {
desc_compl_prepare(retval, extra_flags);
processed();
}
void queue_admin_tx::admin_desc_ctx::desc_complete_indir(uint16_t retval,
const void *data, size_t len, uint16_t extra_flags, bool ignore_datalen)
{
const void *data,
size_t len,
uint16_t extra_flags,
bool ignore_datalen) {
if (!ignore_datalen && len > d->datalen) {
queue.log << "queue_admin_tx::desc_complete_indir: data too long ("
<< len << ") got buffer for (" << d->datalen << ")" << logger::endl;
queue.log << "queue_admin_tx::desc_complete_indir: data too long (" << len
<< ") got buffer for (" << d->datalen << ")" << logger::endl;
abort();
}
d->datalen = len;
......@@ -117,18 +114,17 @@ void queue_admin_tx::admin_desc_ctx::desc_complete_indir(uint16_t retval,
desc_compl_prepare(retval, extra_flags);
uint64_t addr = d->params.external.addr_low |
(((uint64_t) d->params.external.addr_high) << 32);
(((uint64_t)d->params.external.addr_high) << 32);
data_write(addr, len, data);
}
void queue_admin_tx::admin_desc_ctx::prepare()
{
void queue_admin_tx::admin_desc_ctx::prepare() {
if ((d->flags & I40E_AQ_FLAG_RD)) {
uint64_t addr = d->params.external.addr_low |
(((uint64_t) d->params.external.addr_high) << 32);
(((uint64_t)d->params.external.addr_high) << 32);
#ifdef DEBUG_ADMINQ
queue.log << " desc with buffer opc=" << d->opcode << " addr=" <<
addr << logger::endl;
queue.log << " desc with buffer opc=" << d->opcode << " addr=" << addr
<< logger::endl;
#endif
data_fetch(addr, d->datalen);
} else {
......@@ -136,8 +132,7 @@ void queue_admin_tx::admin_desc_ctx::prepare()
}
}
void queue_admin_tx::admin_desc_ctx::process()
{
void queue_admin_tx::admin_desc_ctx::process() {
#ifdef DEBUG_ADMINQ
queue.log << " descriptor " << index << " fetched" << logger::endl;
#endif
......@@ -161,8 +156,7 @@ void queue_admin_tx::admin_desc_ctx::process()
queue.log << " request resource" << logger::endl;
#endif
struct i40e_aqc_request_resource *rr =
reinterpret_cast<struct i40e_aqc_request_resource *>(
d->params.raw);
reinterpret_cast<struct i40e_aqc_request_resource *>(d->params.raw);
rr->timeout = 180000;
#ifdef DEBUG_ADMINQ
queue.log << " res_id=" << rr->resource_id << logger::endl;
......@@ -175,8 +169,7 @@ void queue_admin_tx::admin_desc_ctx::process()
#endif
#ifdef DEBUG_ADMINQ
struct i40e_aqc_request_resource *rr =
reinterpret_cast<struct i40e_aqc_request_resource *>(
d->params.raw);
reinterpret_cast<struct i40e_aqc_request_resource *>(d->params.raw);
queue.log << " res_id=" << rr->resource_id << logger::endl;
queue.log << " res_nu=" << rr->resource_number << logger::endl;
#endif
......@@ -193,16 +186,15 @@ void queue_admin_tx::admin_desc_ctx::process()
queue.log << " get dev/fun caps" << logger::endl;
#endif
struct i40e_aqc_list_capabilites *lc =
reinterpret_cast<struct i40e_aqc_list_capabilites *>(
d->params.raw);
reinterpret_cast<struct i40e_aqc_list_capabilites *>(d->params.raw);
struct i40e_aqc_list_capabilities_element_resp caps[] = {
{ I40E_AQ_CAP_ID_RSS, 1, 0, 512, 6, 0, {} },
{ I40E_AQ_CAP_ID_RXQ, 1, 0, dev.NUM_QUEUES, 0, 0, {} },
{ I40E_AQ_CAP_ID_TXQ, 1, 0, dev.NUM_QUEUES, 0, 0, {} },
{ I40E_AQ_CAP_ID_MSIX, 1, 0, dev.NUM_PFINTS, 0, 0, {} },
{ I40E_AQ_CAP_ID_VSI, 1, 0, dev.NUM_VSIS, 0, 0, {} },
{ I40E_AQ_CAP_ID_DCB, 1, 0, 1, 1, 1, {} },
{I40E_AQ_CAP_ID_RSS, 1, 0, 512, 6, 0, {}},
{I40E_AQ_CAP_ID_RXQ, 1, 0, dev.NUM_QUEUES, 0, 0, {}},
{I40E_AQ_CAP_ID_TXQ, 1, 0, dev.NUM_QUEUES, 0, 0, {}},
{I40E_AQ_CAP_ID_MSIX, 1, 0, dev.NUM_PFINTS, 0, 0, {}},
{I40E_AQ_CAP_ID_VSI, 1, 0, dev.NUM_VSIS, 0, 0, {}},
{I40E_AQ_CAP_ID_DCB, 1, 0, 1, 1, 1, {}},
};
size_t num_caps = sizeof(caps) / sizeof(caps[0]);
......@@ -231,8 +223,7 @@ void queue_admin_tx::admin_desc_ctx::process()
queue.log << " read mac" << logger::endl;
#endif
struct i40e_aqc_mac_address_read *ar =
reinterpret_cast<struct i40e_aqc_mac_address_read *>(
d->params.raw);
reinterpret_cast<struct i40e_aqc_mac_address_read *>(d->params.raw);
struct i40e_aqc_mac_address_read_data ard;
uint64_t mac = runner->get_mac_addr();
......@@ -253,8 +244,7 @@ void queue_admin_tx::admin_desc_ctx::process()
par.phy_type = (1ULL << I40E_PHY_TYPE_40GBASE_CR4_CU);
par.link_speed = I40E_LINK_SPEED_40GB;
par.abilities = I40E_AQ_PHY_LINK_ENABLED |
I40E_AQ_PHY_AN_ENABLED;
par.abilities = I40E_AQ_PHY_LINK_ENABLED | I40E_AQ_PHY_AN_ENABLED;
par.eee_capability = 0;
d->params.external.param0 = 0;
......@@ -266,8 +256,7 @@ void queue_admin_tx::admin_desc_ctx::process()
queue.log << " link status" << logger::endl;
#endif
struct i40e_aqc_get_link_status *gls =
reinterpret_cast<struct i40e_aqc_get_link_status *>(
d->params.raw);
reinterpret_cast<struct i40e_aqc_get_link_status *>(d->params.raw);
gls->command_flags &= I40E_AQ_LSE_IS_ENABLED; // should actually return
// status of link status
......@@ -279,8 +268,7 @@ void queue_admin_tx::admin_desc_ctx::process()
// might need qualified module
gls->an_info = I40E_AQ_AN_COMPLETED | I40E_AQ_LP_AN_ABILITY;
gls->ext_info = 0;
gls->loopback = I40E_AQ_LINK_POWER_CLASS_4 <<
I40E_AQ_PWR_CLASS_SHIFT_LB;
gls->loopback = I40E_AQ_LINK_POWER_CLASS_4 << I40E_AQ_PWR_CLASS_SHIFT_LB;
gls->max_frame_size = dev.MAX_MTU;
gls->config = I40E_AQ_CONFIG_CRC_ENA;
......@@ -289,8 +277,8 @@ void queue_admin_tx::admin_desc_ctx::process()
#ifdef DEBUG_ADMINQ
queue.log << " get switch config" << logger::endl;
#endif
struct i40e_aqc_switch_seid *sw = reinterpret_cast<
struct i40e_aqc_switch_seid *>(d->params.raw);
struct i40e_aqc_switch_seid *sw =
reinterpret_cast<struct i40e_aqc_switch_seid *>(d->params.raw);
struct i40e_aqc_get_switch_config_header_resp hr;
/* Not sure why dpdk doesn't like this?
struct i40e_aqc_switch_config_element_resp els[] = {
......@@ -312,15 +300,22 @@ void queue_admin_tx::admin_desc_ctx::process()
};*/
struct i40e_aqc_switch_config_element_resp els[] = {
// VSI PF
{ I40E_AQ_SW_ELEM_TYPE_VSI, I40E_AQ_SW_ELEM_REV_1, 512, 2, 16, {},
I40E_AQ_CONN_TYPE_REGULAR, 0, 0},
{I40E_AQ_SW_ELEM_TYPE_VSI,
I40E_AQ_SW_ELEM_REV_1,
512,
2,
16,
{},
I40E_AQ_CONN_TYPE_REGULAR,
0,
0},
};
// find start idx
size_t cnt = sizeof(els) / sizeof(els[0]);
size_t first = 0;
for (first = 0; first < cnt && els[first].seid < sw->seid; first++) {}
for (first = 0; first < cnt && els[first].seid < sw->seid; first++) {
}
// figure out how many fit in the buffer
size_t max = (d->datalen - sizeof(hr)) / sizeof(els[0]);
......@@ -337,8 +332,8 @@ void queue_admin_tx::admin_desc_ctx::process()
hr.num_reported = report;
hr.num_total = cnt;
#ifdef DEBUG_ADMINQ
queue.log << " report=" << report << " cnt=" << cnt <<
" seid=" << sw->seid << logger::endl;
queue.log << " report=" << report << " cnt=" << cnt
<< " seid=" << sw->seid << logger::endl;
#endif
// create temporary contiguous buffer
......@@ -369,10 +364,9 @@ void queue_admin_tx::admin_desc_ctx::process()
struct i40e_aqc_vsi_properties_data pd;
memset(&pd, 0, sizeof(pd));
pd.valid_sections |= I40E_AQ_VSI_PROP_SWITCH_VALID |
I40E_AQ_VSI_PROP_QUEUE_MAP_VALID |
I40E_AQ_VSI_PROP_QUEUE_OPT_VALID |
I40E_AQ_VSI_PROP_SCHED_VALID;
pd.valid_sections |=
I40E_AQ_VSI_PROP_SWITCH_VALID | I40E_AQ_VSI_PROP_QUEUE_MAP_VALID |
I40E_AQ_VSI_PROP_QUEUE_OPT_VALID | I40E_AQ_VSI_PROP_SCHED_VALID;
desc_complete_indir(0, &pd, sizeof(pd));
} else if (d->opcode == i40e_aqc_opc_update_vsi_parameters) {
#ifdef DEBUG_ADMINQ
......@@ -397,8 +391,7 @@ void queue_admin_tx::admin_desc_ctx::process()
#endif
struct i40e_aqc_query_vsi_bw_config_resp bwc;
memset(&bwc, 0, sizeof(bwc));
for (size_t i = 0; i < 8; i++)
bwc.qs_handles[i] = 0xffff;
for (size_t i = 0; i < 8; i++) bwc.qs_handles[i] = 0xffff;
desc_complete_indir(0, &bwc, sizeof(bwc));
} else if (d->opcode == i40e_aqc_opc_query_vsi_ets_sla_config) {
#ifdef DEBUG_ADMINQ
......@@ -406,18 +399,16 @@ void queue_admin_tx::admin_desc_ctx::process()
#endif
struct i40e_aqc_query_vsi_ets_sla_config_resp sla;
memset(&sla, 0, sizeof(sla));
for (size_t i = 0; i < 8; i++)
sla.share_credits[i] = 127;
for (size_t i = 0; i < 8; i++) sla.share_credits[i] = 127;
desc_complete_indir(0, &sla, sizeof(sla));
} else if (d->opcode == i40e_aqc_opc_remove_macvlan) {
#ifdef DEBUG_ADMINQ
queue.log << " remove macvlan" << logger::endl;
#endif
struct i40e_aqc_macvlan *m = reinterpret_cast<
struct i40e_aqc_macvlan *>(d->params.raw);
struct i40e_aqc_macvlan *m =
reinterpret_cast<struct i40e_aqc_macvlan *>(d->params.raw);
struct i40e_aqc_remove_macvlan_element_data *rve =
reinterpret_cast<struct i40e_aqc_remove_macvlan_element_data *>(
data);
reinterpret_cast<struct i40e_aqc_remove_macvlan_element_data *>(data);
for (uint16_t i = 0; i < m->num_addresses; i++)
rve[i].error_code = I40E_AQC_REMOVE_MACVLAN_SUCCESS;
......
sims/nic/i40e_bm/i40e_base_wrapper.h
View file @ d4666c97
......@@ -17,9 +17,9 @@ typedef uint16_t __le16;
typedef uint32_t __le32;
typedef uint64_t __le64;
#include "sims/nic/i40e_bm/base/i40e_adminq_cmd.h"
#include "sims/nic/i40e_bm/base/i40e_devids.h"
#include "sims/nic/i40e_bm/base/i40e_register.h"
#include "sims/nic/i40e_bm/base/i40e_adminq_cmd.h"
#include "sims/nic/i40e_bm/base/i40e_rxtxq.h"
/* from i40e_types.h */
......
sims/nic/i40e_bm/i40e_bm.cc
View file @ d4666c97
......@@ -22,12 +22,14 @@
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include "sims/nic/i40e_bm/i40e_bm.h"
#include <stdlib.h>
#include <string.h>
#include <cassert>
#include <iostream>
#include "sims/nic/i40e_bm/i40e_bm.h"
#include "sims/nic/i40e_bm/i40e_base_wrapper.h"
nicbm::Runner *runner;
......@@ -37,24 +39,23 @@ namespace i40e {
i40e_bm::i40e_bm()
: log("i40e"),
pf_atq(*this, regs.pf_atqba, regs.pf_atqlen, regs.pf_atqh, regs.pf_atqt),
hmc(*this), shram(*this), lanmgr(*this, NUM_QUEUES)
{
hmc(*this),
shram(*this),
lanmgr(*this, NUM_QUEUES) {
reset(false);
}
i40e_bm::~i40e_bm()
{
i40e_bm::~i40e_bm() {
}
void i40e_bm::setup_intro(struct cosim_pcie_proto_dev_intro &di)
{
void i40e_bm::setup_intro(struct cosim_pcie_proto_dev_intro &di) {
di.bars[BAR_REGS].len = 4 * 1024 * 1024;
di.bars[BAR_REGS].flags = COSIM_PCIE_PROTO_BAR_64;
di.bars[BAR_IO].len = 32;
di.bars[BAR_IO].flags = COSIM_PCIE_PROTO_BAR_IO;
di.bars[BAR_MSIX].len = 32 * 1024;
di.bars[BAR_MSIX].flags = COSIM_PCIE_PROTO_BAR_64 |
COSIM_PCIE_PROTO_BAR_DUMMY;
di.bars[BAR_MSIX].flags =
COSIM_PCIE_PROTO_BAR_64 | COSIM_PCIE_PROTO_BAR_DUMMY;
di.pci_vendor_id = I40E_INTEL_VENDOR_ID;
di.pci_device_id = I40E_DEV_ID_QSFP_A;
......@@ -71,8 +72,7 @@ void i40e_bm::setup_intro(struct cosim_pcie_proto_dev_intro &di)
di.psi_msix_cap_offset = 0x70;
}
void i40e_bm::dma_complete(nicbm::DMAOp &op)
{
void i40e_bm::dma_complete(nicbm::DMAOp &op) {
dma_base &dma = dynamic_cast<dma_base &>(op);
#ifdef DEBUG_DEV
log << "dma_complete(" << &op << ")" << logger::endl;
......@@ -80,17 +80,15 @@ void i40e_bm::dma_complete(nicbm::DMAOp &op)
dma.done();
}
void i40e_bm::eth_rx(uint8_t port, const void *data, size_t len)
{
void i40e_bm::eth_rx(uint8_t port, const void *data, size_t len) {
#ifdef DEBUG_DEV
log << "i40e: received packet len=" << len << logger::endl;
#endif
lanmgr.packet_received(data, len);
}
void i40e_bm::reg_read(uint8_t bar, uint64_t addr, void *dest, size_t len)
{
uint32_t *dest_p = reinterpret_cast <uint32_t *> (dest);
void i40e_bm::reg_read(uint8_t bar, uint64_t addr, void *dest, size_t len) {
uint32_t *dest_p = reinterpret_cast<uint32_t *>(dest);
if (len == 4) {
dest_p[0] = reg_read32(bar, addr);
......@@ -104,21 +102,20 @@ void i40e_bm::reg_read(uint8_t bar, uint64_t addr, void *dest, size_t len)
}
}
uint32_t i40e_bm::reg_read32(uint8_t bar, uint64_t addr)
{
uint32_t i40e_bm::reg_read32(uint8_t bar, uint64_t addr) {
if (bar == BAR_REGS) {
return reg_mem_read32(addr);
} else if (bar == BAR_IO) {
return reg_io_read(addr);
} else {
log << "invalid BAR " << (int) bar << logger::endl;
log << "invalid BAR " << (int)bar << logger::endl;
abort();
}
}
void i40e_bm::reg_write(uint8_t bar, uint64_t addr, const void *src, size_t len)
{
const uint32_t *src_p = reinterpret_cast<const uint32_t *> (src);
void i40e_bm::reg_write(uint8_t bar, uint64_t addr, const void *src,
size_t len) {
const uint32_t *src_p = reinterpret_cast<const uint32_t *>(src);
if (len == 4) {
reg_write32(bar, addr, src_p[0]);
......@@ -132,32 +129,27 @@ void i40e_bm::reg_write(uint8_t bar, uint64_t addr, const void *src, size_t len)
}
}
void i40e_bm::reg_write32(uint8_t bar, uint64_t addr, uint32_t val)
{
void i40e_bm::reg_write32(uint8_t bar, uint64_t addr, uint32_t val) {
if (bar == BAR_REGS) {
reg_mem_write32(addr, val);
} else if (bar == BAR_IO) {
reg_io_write(addr, val);
} else {
log << "invalid BAR " << (int) bar << logger::endl;
log << "invalid BAR " << (int)bar << logger::endl;
abort();
}
}
uint32_t i40e_bm::reg_io_read(uint64_t addr)
{
uint32_t i40e_bm::reg_io_read(uint64_t addr) {
log << "unhandled io read addr=" << addr << logger::endl;
return 0;
}
void i40e_bm::reg_io_write(uint64_t addr, uint32_t val)
{
log << "unhandled io write addr=" << addr << " val="
<< val << logger::endl;
void i40e_bm::reg_io_write(uint64_t addr, uint32_t val) {
log << "unhandled io write addr=" << addr << " val=" << val << logger::endl;
}
uint32_t i40e_bm::reg_mem_read32(uint64_t addr)
{
uint32_t i40e_bm::reg_mem_read32(uint64_t addr) {
uint32_t val = 0;
if (addr >= I40E_PFINT_DYN_CTLN(0) &&
......@@ -176,20 +168,17 @@ uint32_t i40e_bm::reg_mem_read32(uint64_t addr)
} else if (addr >= I40E_QINT_TQCTL(0) &&
addr <= I40E_QINT_TQCTL(NUM_QUEUES - 1)) {
val = regs.qint_tqctl[(addr - I40E_QINT_TQCTL(0)) / 4];
} else if (addr >= I40E_QTX_ENA(0) &&
addr <= I40E_QTX_ENA(NUM_QUEUES - 1)) {
} else if (addr >= I40E_QTX_ENA(0) && addr <= I40E_QTX_ENA(NUM_QUEUES - 1)) {
val = regs.qtx_ena[(addr - I40E_QTX_ENA(0)) / 4];
} else if (addr >= I40E_QTX_TAIL(0) &&
addr <= I40E_QTX_TAIL(NUM_QUEUES - 1)) {
val = regs.qtx_tail[(addr - I40E_QTX_TAIL(0)) / 4];
} else if (addr >= I40E_QTX_CTL(0) &&
addr <= I40E_QTX_CTL(NUM_QUEUES - 1)) {
} else if (addr >= I40E_QTX_CTL(0) && addr <= I40E_QTX_CTL(NUM_QUEUES - 1)) {
val = regs.qtx_ctl[(addr - I40E_QTX_CTL(0)) / 4];
} else if (addr >= I40E_QINT_RQCTL(0) &&
addr <= I40E_QINT_RQCTL(NUM_QUEUES - 1)) {
val = regs.qint_rqctl[(addr - I40E_QINT_RQCTL(0)) / 4];
} else if (addr >= I40E_QRX_ENA(0) &&
addr <= I40E_QRX_ENA(NUM_QUEUES - 1)) {
} else if (addr >= I40E_QRX_ENA(0) && addr <= I40E_QRX_ENA(NUM_QUEUES - 1)) {
val = regs.qrx_ena[(addr - I40E_QRX_ENA(0)) / 4];
} else if (addr >= I40E_QRX_TAIL(0) &&
addr <= I40E_QRX_TAIL(NUM_QUEUES - 1)) {
......@@ -323,7 +312,6 @@ uint32_t i40e_bm::reg_mem_read32(uint64_t addr)
val = regs.gllan_rctl_0;
break;
case I40E_GLHMC_LANTXOBJSZ:
val = 7; // 128 B
break;
......@@ -440,8 +428,7 @@ uint32_t i40e_bm::reg_mem_read32(uint64_t addr)
default:
#ifdef DEBUG_DEV
log << "unhandled mem read addr=" << addr
<< logger::endl;
log << "unhandled mem read addr=" << addr << logger::endl;
#endif
break;
}
......@@ -450,8 +437,7 @@ uint32_t i40e_bm::reg_mem_read32(uint64_t addr)
return val;
}
void i40e_bm::reg_mem_write32(uint64_t addr, uint32_t val)
{
void i40e_bm::reg_mem_write32(uint64_t addr, uint32_t val) {
if (addr >= I40E_PFINT_DYN_CTLN(0) &&
addr <= I40E_PFINT_DYN_CTLN(NUM_PFINTS - 1)) {
regs.pfint_dyn_ctln[(addr - I40E_PFINT_DYN_CTLN(0)) / 4] = val;
......@@ -467,8 +453,7 @@ void i40e_bm::reg_mem_write32(uint64_t addr, uint32_t val)
} else if (addr >= I40E_QINT_TQCTL(0) &&
addr <= I40E_QINT_TQCTL(NUM_QUEUES - 1)) {
regs.qint_tqctl[(addr - I40E_QINT_TQCTL(0)) / 4] = val;
} else if (addr >= I40E_QTX_ENA(0) &&
addr <= I40E_QTX_ENA(NUM_QUEUES - 1)) {
} else if (addr >= I40E_QTX_ENA(0) && addr <= I40E_QTX_ENA(NUM_QUEUES - 1)) {
size_t idx = (addr - I40E_QTX_ENA(0)) / 4;
regs.qtx_ena[idx] = val;
lanmgr.qena_updated(idx, false);
......@@ -477,14 +462,12 @@ void i40e_bm::reg_mem_write32(uint64_t addr, uint32_t val)
size_t idx = (addr - I40E_QTX_TAIL(0)) / 4;
regs.qtx_tail[idx] = val;
lanmgr.tail_updated(idx, false);
} else if (addr >= I40E_QTX_CTL(0) &&
addr <= I40E_QTX_CTL(NUM_QUEUES - 1)) {
} else if (addr >= I40E_QTX_CTL(0) && addr <= I40E_QTX_CTL(NUM_QUEUES - 1)) {
regs.qtx_ctl[(addr - I40E_QTX_CTL(0)) / 4] = val;
} else if (addr >= I40E_QINT_RQCTL(0) &&
addr <= I40E_QINT_RQCTL(NUM_QUEUES - 1)) {
regs.qint_rqctl[(addr - I40E_QINT_RQCTL(0)) / 4] = val;
} else if (addr >= I40E_QRX_ENA(0) &&
addr <= I40E_QRX_ENA(NUM_QUEUES - 1)) {
} else if (addr >= I40E_QRX_ENA(0) && addr <= I40E_QRX_ENA(NUM_QUEUES - 1)) {
size_t idx = (addr - I40E_QRX_ENA(0)) / 4;
regs.qrx_ena[idx] = val;
lanmgr.qena_updated(idx, true);
......@@ -524,8 +507,7 @@ void i40e_bm::reg_mem_write32(uint64_t addr, uint32_t val)
} else {
switch (addr) {
case I40E_PFGEN_CTRL:
if ((val & I40E_PFGEN_CTRL_PFSWR_MASK) ==
I40E_PFGEN_CTRL_PFSWR_MASK)
if ((val & I40E_PFGEN_CTRL_PFSWR_MASK) == I40E_PFGEN_CTRL_PFSWR_MASK)
reset(true);
break;
......@@ -598,8 +580,7 @@ void i40e_bm::reg_mem_write32(uint64_t addr, uint32_t val)
pf_atq.reg_updated();
break;
case I40E_PF_ATQBAH:
regs.pf_atqba = ((uint64_t) val << 32) |
(regs.pf_atqba & 0xffffffffULL);
regs.pf_atqba = ((uint64_t)val << 32) | (regs.pf_atqba & 0xffffffffULL);
pf_atq.reg_updated();
break;
case I40E_PF_ATQLEN:
......@@ -619,8 +600,7 @@ void i40e_bm::reg_mem_write32(uint64_t addr, uint32_t val)
regs.pf_arqba = val | (regs.pf_atqba & 0xffffffff00000000ULL);
break;
case I40E_PF_ARQBAH:
regs.pf_arqba = ((uint64_t) val << 32) |
(regs.pf_arqba & 0xffffffffULL);
regs.pf_arqba = ((uint64_t)val << 32) | (regs.pf_arqba & 0xffffffffULL);
break;
case I40E_PF_ARQLEN:
regs.pf_arqlen = val;
......@@ -663,20 +643,19 @@ void i40e_bm::reg_mem_write32(uint64_t addr, uint32_t val)
break;
default:
#ifdef DEBUG_DEV
log << "unhandled mem write addr=" << addr
<< " val=" << val << logger::endl;
log << "unhandled mem write addr=" << addr << " val=" << val
<< logger::endl;
#endif
break;
}
}
}
void i40e_bm::timed_event(nicbm::TimedEvent &ev)
{
int_ev &iev = *((int_ev *) &ev);
void i40e_bm::timed_event(nicbm::TimedEvent &ev) {
int_ev &iev = *((int_ev *)&ev);
#ifdef DEBUG_DEV
log << "timed_event: triggering interrupt (" << iev.vec << ")" <<
logger::endl;
log << "timed_event: triggering interrupt (" << iev.vec << ")"
<< logger::endl;
#endif
iev.armed = false;
......@@ -690,8 +669,7 @@ void i40e_bm::timed_event(nicbm::TimedEvent &ev)
}
}
void i40e_bm::signal_interrupt(uint16_t vec, uint8_t itr)
{
void i40e_bm::signal_interrupt(uint16_t vec, uint8_t itr) {
int_ev &iev = intevs[vec];
uint64_t mindelay;
......@@ -715,8 +693,8 @@ void i40e_bm::signal_interrupt(uint16_t vec, uint8_t itr)
if (iev.armed && iev.time <= newtime) {
// already armed and this is not scheduled sooner
#ifdef DEBUG_DEV
log << "signal_interrupt: vec " << vec << " already scheduled" <<
logger::endl;
log << "signal_interrupt: vec " << vec << " already scheduled"
<< logger::endl;
#endif
return;
} else if (iev.armed) {
......@@ -728,15 +706,14 @@ void i40e_bm::signal_interrupt(uint16_t vec, uint8_t itr)
iev.time = newtime;
#ifdef DEBUG_DEV
log << "signal_interrupt: scheduled vec " << vec << " for time=" <<
newtime << " (itr " << itr << ")" << logger::endl;
log << "signal_interrupt: scheduled vec " << vec << " for time=" << newtime
<< " (itr " << itr << ")" << logger::endl;
#endif
runner->event_schedule(iev);
}
void i40e_bm::reset(bool indicate_done)
{
void i40e_bm::reset(bool indicate_done) {
#ifdef DEBUG_DEV
std::cout << "reset triggered" << logger::endl;
#endif
......@@ -778,13 +755,10 @@ void i40e_bm::reset(bool indicate_done)
regs.glrpb_plw = 0x0846;
}
shadow_ram::shadow_ram(i40e_bm &dev_)
: dev(dev_), log("sram")
{
shadow_ram::shadow_ram(i40e_bm &dev_) : dev(dev_), log("sram") {
}
void shadow_ram::reg_updated()
{
void shadow_ram::reg_updated() {
uint32_t val = dev.regs.glnvm_srctl;
uint32_t addr;
bool is_write;
......@@ -792,31 +766,27 @@ void shadow_ram::reg_updated()
if (!(val & I40E_GLNVM_SRCTL_START_MASK))
return;
addr = (val & I40E_GLNVM_SRCTL_ADDR_MASK)
>> I40E_GLNVM_SRCTL_ADDR_SHIFT;
addr = (val & I40E_GLNVM_SRCTL_ADDR_MASK) >> I40E_GLNVM_SRCTL_ADDR_SHIFT;
is_write = (val & I40E_GLNVM_SRCTL_WRITE_MASK);
#ifdef DEBUG_DEV
log << "shadow ram op addr=" << addr << " w=" << is_write
<< logger::endl;
log << "shadow ram op addr=" << addr << " w=" << is_write << logger::endl;
#endif
if (is_write) {
write(addr,
(dev.regs.glnvm_srdata & I40E_GLNVM_SRDATA_WRDATA_MASK)
>> I40E_GLNVM_SRDATA_WRDATA_SHIFT);
write(addr, (dev.regs.glnvm_srdata & I40E_GLNVM_SRDATA_WRDATA_MASK) >>
I40E_GLNVM_SRDATA_WRDATA_SHIFT);
} else {
dev.regs.glnvm_srdata &= ~I40E_GLNVM_SRDATA_RDDATA_MASK;
dev.regs.glnvm_srdata |= ((uint32_t) read(addr)) <<
I40E_GLNVM_SRDATA_RDDATA_SHIFT;
dev.regs.glnvm_srdata |= ((uint32_t)read(addr))
<< I40E_GLNVM_SRDATA_RDDATA_SHIFT;
}
dev.regs.glnvm_srctl &= ~I40E_GLNVM_SRCTL_START_MASK;
dev.regs.glnvm_srctl |= I40E_GLNVM_SRCTL_DONE_MASK;
}
uint16_t shadow_ram::read(uint16_t addr)
{
uint16_t shadow_ram::read(uint16_t addr) {
switch (addr) {
/* for any of these hopefully return 0 should be fine */
/* they are read by drivers but not used */
......@@ -834,8 +804,7 @@ uint16_t shadow_ram::read(uint16_t addr)
default:
#ifdef DEBUG_DEV
log << "TODO shadow memory read addr=" << addr
<< logger::endl;
log << "TODO shadow memory read addr=" << addr << logger::endl;
#endif
break;
}
......@@ -843,16 +812,14 @@ uint16_t shadow_ram::read(uint16_t addr)
return 0;
}
void shadow_ram::write(uint16_t addr, uint16_t val)
{
void shadow_ram::write(uint16_t addr, uint16_t val) {
#ifdef DEBUG_DEV
log << "TODO shadow memory write addr=" << addr <<
" val=" << val << logger::endl;
log << "TODO shadow memory write addr=" << addr << " val=" << val
<< logger::endl;
#endif
}
int_ev::int_ev()
{
int_ev::int_ev() {
armed = false;
time = 0;
}
......@@ -861,8 +828,7 @@ int_ev::int_ev()
using namespace i40e;
int main(int argc, char *argv[])
{
int main(int argc, char *argv[]) {
i40e_bm dev;
runner = new nicbm::Runner(dev);
return runner->runMain(argc, argv);
......
sims/nic/i40e_bm/i40e_bm.h
View file @ d4666c97
......@@ -24,10 +24,11 @@
#pragma once
#include <stdint.h>
#include <deque>
#include <sstream>
#include <string>
#include <stdint.h>
extern "C" {
#include <simbricks/proto/pcie.h>
}
......@@ -61,7 +62,6 @@ class int_ev : public nicbm::TimedEvent {
int_ev();
};
class logger : public std::ostream {
public:
static const char endl = '\n';
......@@ -111,8 +111,10 @@ class queue_base {
class desc_ctx {
friend class queue_base;
public:
enum state {
enum state
{
DESC_EMPTY,
DESC_FETCHING,
DESC_PREPARING,
......@@ -154,6 +156,7 @@ class queue_base {
class dma_fetch : public dma_base {
protected:
queue_base &queue;
public:
uint32_t pos;
dma_fetch(queue_base &queue_, size_t len);
......@@ -164,6 +167,7 @@ class queue_base {
class dma_wb : public dma_base {
protected:
queue_base &queue;
public:
uint32_t pos;
dma_wb(queue_base &queue_, size_t len);
......@@ -186,6 +190,7 @@ class queue_base {
class dma_data_wb : public dma_base {
protected:
desc_ctx &ctx;
public:
size_t total_len;
size_t part_offset;
......@@ -260,8 +265,8 @@ class queue_admin_tx : public queue_base {
// complete direct response
void desc_complete(uint16_t retval, uint16_t extra_flags = 0);
// complete indirect response
void desc_complete_indir(uint16_t retval, const void *data,
size_t len, uint16_t extra_flags = 0,
void desc_complete_indir(uint16_t retval, const void *data, size_t len,
uint16_t extra_flags = 0,
bool ignore_datalen = false);
public:
......@@ -278,8 +283,8 @@ class queue_admin_tx : public queue_base {
virtual desc_ctx &desc_ctx_create();
public:
queue_admin_tx(i40e_bm &dev_, uint64_t &reg_base_,
uint32_t &reg_len_, uint32_t &reg_head_, uint32_t &reg_tail_);
queue_admin_tx(i40e_bm &dev_, uint64_t &reg_base_, uint32_t &reg_len_,
uint32_t &reg_head_, uint32_t &reg_tail_);
void reg_updated();
};
......@@ -322,7 +327,6 @@ class lan_queue_base : public queue_base {
virtual void done();
};
lan &lanmgr;
void ctx_fetched();
......@@ -342,10 +346,9 @@ class lan_queue_base : public queue_base {
uint32_t reg_dummy_head;
lan_queue_base(lan &lanmgr_, const std::string &qtype,
uint32_t &reg_tail, size_t idx_, uint32_t &reg_ena_,
uint32_t &fpm_basereg, uint32_t &reg_intqctl,
uint16_t ctx_size);
lan_queue_base(lan &lanmgr_, const std::string &qtype, uint32_t &reg_tail,
size_t idx_, uint32_t &reg_ena_, uint32_t &fpm_basereg,
uint32_t &reg_intqctl, uint16_t ctx_size);
virtual void reset();
void enable();
void disable();
......@@ -369,10 +372,10 @@ class lan_queue_tx : public lan_queue_base {
virtual void processed();
};
class dma_hwb : public dma_base {
protected:
lan_queue_tx &queue;
public:
uint32_t pos;
uint32_t cnt;
......@@ -400,9 +403,8 @@ class lan_queue_tx : public lan_queue_base {
void trigger_tx();
public:
lan_queue_tx(lan &lanmgr_, uint32_t &reg_tail, size_t idx,
uint32_t &reg_ena, uint32_t &fpm_basereg,
uint32_t &reg_intqctl);
lan_queue_tx(lan &lanmgr_, uint32_t &reg_tail, size_t idx, uint32_t &reg_ena,
uint32_t &fpm_basereg, uint32_t &reg_intqctl);
virtual void reset();
};
......@@ -430,9 +432,8 @@ class lan_queue_rx : public lan_queue_base {
virtual desc_ctx &desc_ctx_create();
public:
lan_queue_rx(lan &lanmgr_, uint32_t &reg_tail, size_t idx,
uint32_t &reg_ena, uint32_t &fpm_basereg,
uint32_t &reg_intqctl);
lan_queue_rx(lan &lanmgr_, uint32_t &reg_tail, size_t idx, uint32_t &reg_ena,
uint32_t &fpm_basereg, uint32_t &reg_intqctl);
virtual void reset();
void packet_received(const void *data, size_t len, uint32_t hash);
};
......@@ -451,8 +452,7 @@ class rss_key_cache {
public:
rss_key_cache(const uint32_t (&key_)[key_len / 4]);
void set_dirty();
uint32_t hash_ipv4(uint32_t sip, uint32_t dip, uint16_t sp,
uint16_t dp);
uint32_t hash_ipv4(uint32_t sip, uint32_t dip, uint16_t sp, uint16_t dp);
};
// rx tx management
......@@ -471,6 +471,7 @@ class lan {
bool rss_steering(const void *data, size_t len, uint16_t &queue,
uint32_t &hash);
public:
lan(i40e_bm &dev, size_t num_qs);
void reset();
......@@ -493,7 +494,7 @@ class shadow_ram {
};
class i40e_bm : public nicbm::Runner::Device {
protected:
protected:
friend class queue_admin_tx;
friend class host_mem_cache;
friend class lan;
......@@ -578,7 +579,7 @@ protected:
uint32_t glrpb_plw;
};
public:
public:
i40e_bm();
~i40e_bm();
......@@ -594,7 +595,7 @@ public:
void signal_interrupt(uint16_t vector, uint8_t itr);
protected:
protected:
logger log;
i40e_regs regs;
queue_admin_tx pf_atq;
......@@ -622,8 +623,7 @@ void xsum_tcp(void *tcphdr, size_t l4len);
// calculates the full ipv4 & tcp checksum without assuming any pseudo header
// xsums
void xsum_tcpip_tso(void *iphdr, uint8_t iplen, uint8_t l4len,
uint16_t paylen);
void xsum_tcpip_tso(void *iphdr, uint8_t iplen, uint8_t l4len, uint16_t paylen);
void tso_postupdate_header(void *iphdr, uint8_t iplen, uint8_t l4len,
uint16_t paylen);
......
sims/nic/i40e_bm/i40e_hmc.cc
View file @ d4666c97
......@@ -24,24 +24,22 @@
#include <stdlib.h>
#include <string.h>
#include <cassert>
#include <iostream>
#include "sims/nic/i40e_bm/i40e_bm.h"
#include "sims/nic/i40e_bm/i40e_base_wrapper.h"
#include "sims/nic/i40e_bm/i40e_bm.h"
using namespace i40e;
extern nicbm::Runner *runner;
host_mem_cache::host_mem_cache(i40e_bm &dev_)
: dev(dev_)
{
host_mem_cache::host_mem_cache(i40e_bm &dev_) : dev(dev_) {
reset();
}
void host_mem_cache::reset()
{
void host_mem_cache::reset() {
for (size_t i = 0; i < MAX_SEGMENTS; i++) {
segs[i].addr = 0;
segs[i].pgcount = 0;
......@@ -50,13 +48,12 @@ void host_mem_cache::reset()
}
}
void host_mem_cache::reg_updated(uint64_t addr)
{
void host_mem_cache::reg_updated(uint64_t addr) {
if (addr == I40E_PFHMC_SDCMD) {
// read/write command for descriptor
uint32_t cmd = dev.regs.pfhmc_sdcmd;
uint16_t idx = (cmd & I40E_PFHMC_SDCMD_PMSDIDX_MASK) >>
I40E_PFHMC_SDCMD_PMSDIDX_SHIFT;
uint16_t idx =
(cmd & I40E_PFHMC_SDCMD_PMSDIDX_MASK) >> I40E_PFHMC_SDCMD_PMSDIDX_SHIFT;
uint32_t lo = dev.regs.pfhmc_sddatalow;
uint32_t hi = dev.regs.pfhmc_sddatahigh;
......@@ -67,17 +64,19 @@ void host_mem_cache::reg_updated(uint64_t addr)
#endif
segs[idx].addr = ((lo & I40E_PFHMC_SDDATALOW_PMSDDATALOW_MASK) >>
I40E_PFHMC_SDDATALOW_PMSDDATALOW_SHIFT) << 12;
segs[idx].addr |= ((uint64_t) hi) << 32;
I40E_PFHMC_SDDATALOW_PMSDDATALOW_SHIFT)
<< 12;
segs[idx].addr |= ((uint64_t)hi) << 32;
segs[idx].pgcount = (lo & I40E_PFHMC_SDDATALOW_PMSDBPCOUNT_MASK) >>
I40E_PFHMC_SDDATALOW_PMSDBPCOUNT_SHIFT;
segs[idx].valid = !!(lo & I40E_PFHMC_SDDATALOW_PMSDVALID_MASK);
segs[idx].direct = !!(lo & I40E_PFHMC_SDDATALOW_PMSDTYPE_MASK);
#ifdef DEBUG_HMC
std::cerr << " addr=" << segs[idx].addr << " pgcount=" <<
segs[idx].pgcount << " valid=" << segs[idx].valid <<
" direct=" << segs[idx].direct << std::endl;
std::cerr << " addr=" << segs[idx].addr
<< " pgcount=" << segs[idx].pgcount
<< " valid=" << segs[idx].valid
<< " direct=" << segs[idx].direct << std::endl;
#endif
} else {
// read
......@@ -85,11 +84,11 @@ void host_mem_cache::reg_updated(uint64_t addr)
std::cerr << "hmc: reading descriptor " << idx << std::endl;
#endif
dev.regs.pfhmc_sddatalow = ((segs[idx].addr >> 12) <<
I40E_PFHMC_SDDATALOW_PMSDDATALOW_SHIFT) &
dev.regs.pfhmc_sddatalow =
((segs[idx].addr >> 12) << I40E_PFHMC_SDDATALOW_PMSDDATALOW_SHIFT) &
I40E_PFHMC_SDDATALOW_PMSDDATALOW_MASK;
dev.regs.pfhmc_sddatalow |= (segs[idx].pgcount <<
I40E_PFHMC_SDDATALOW_PMSDBPCOUNT_SHIFT) &
dev.regs.pfhmc_sddatalow |=
(segs[idx].pgcount << I40E_PFHMC_SDDATALOW_PMSDBPCOUNT_SHIFT) &
I40E_PFHMC_SDDATALOW_PMSDBPCOUNT_MASK;
if (segs[idx].valid)
dev.regs.pfhmc_sddatalow |= I40E_PFHMC_SDDATALOW_PMSDVALID_MASK;
......@@ -100,8 +99,7 @@ void host_mem_cache::reg_updated(uint64_t addr)
}
}
void host_mem_cache::issue_mem_op(mem_op &op)
{
void host_mem_cache::issue_mem_op(mem_op &op) {
uint64_t addr = op.dma_addr;
uint16_t seg_idx = addr >> 21;
uint16_t seg_idx_last = (addr + op.len - 1) >> 21;
......@@ -109,28 +107,26 @@ void host_mem_cache::issue_mem_op(mem_op &op)
struct segment *seg = &segs[seg_idx];
if (seg_idx >= MAX_SEGMENTS) {
std::cerr << "hmc issue_mem_op: seg index too high " << seg_idx <<
std::endl;
std::cerr << "hmc issue_mem_op: seg index too high " << seg_idx
<< std::endl;
abort();
}
if (!seg->valid) {
// TODO(antoinek): errorinfo and data registers
std::cerr << "hmc issue_mem_op: segment invalid addr=" << addr <<
std::endl;
std::cerr << "hmc issue_mem_op: segment invalid addr=" << addr << std::endl;
op.failed = true;
return;
}
if (seg_idx != seg_idx_last) {
std::cerr << "hmc issue_mem_op: operation crosses segs addr=" <<
addr << " len=" << op.len << std::endl;
std::cerr << "hmc issue_mem_op: operation crosses segs addr=" << addr
<< " len=" << op.len << std::endl;
abort();
}
if (!seg->direct) {
std::cerr << "hmc issue_mem_op: TODO paged ops addr=" << addr <<
std::endl;
std::cerr << "hmc issue_mem_op: TODO paged ops addr=" << addr << std::endl;
abort();
}
......@@ -138,8 +134,8 @@ void host_mem_cache::issue_mem_op(mem_op &op)
op.dma_addr = seg->addr + dir_off;
#ifdef DEBUG_HMC
std::cerr << "hmc issue_mem_op: hmc_addr=" << addr << " dma_addr=" <<
op.dma_addr << " len=" << op.len << std::endl;
std::cerr << "hmc issue_mem_op: hmc_addr=" << addr
<< " dma_addr=" << op.dma_addr << " len=" << op.len << std::endl;
#endif
runner->issue_dma(op);
}
sims/nic/i40e_bm/i40e_lan.cc
View file @ d4666c97
......@@ -22,38 +22,37 @@
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <cassert>
#include <iostream>
#include <arpa/inet.h>
#include "sims/nic/i40e_bm/i40e_bm.h"
#include "sims/nic/i40e_bm/i40e_base_wrapper.h"
#include "sims/nic/i40e_bm/headers.h"
#include "sims/nic/i40e_bm/i40e_base_wrapper.h"
#include "sims/nic/i40e_bm/i40e_bm.h"
using namespace i40e;
extern nicbm::Runner *runner;
lan::lan(i40e_bm &dev_, size_t num_qs_)
: dev(dev_), log("lan"), rss_kc(dev_.regs.pfqf_hkey), num_qs(num_qs_)
{
: dev(dev_), log("lan"), rss_kc(dev_.regs.pfqf_hkey), num_qs(num_qs_) {
rxqs = new lan_queue_rx *[num_qs];
txqs = new lan_queue_tx *[num_qs];
for (size_t i = 0; i < num_qs; i++) {
rxqs[i] = new lan_queue_rx(*this, dev.regs.qrx_tail[i], i,
dev.regs.qrx_ena[i], dev.regs.glhmc_lanrxbase[0],
dev.regs.qint_rqctl[i]);
txqs[i] = new lan_queue_tx(*this, dev.regs.qtx_tail[i], i,
dev.regs.qtx_ena[i], dev.regs.glhmc_lantxbase[0],
dev.regs.qint_tqctl[i]);
rxqs[i] =
new lan_queue_rx(*this, dev.regs.qrx_tail[i], i, dev.regs.qrx_ena[i],
dev.regs.glhmc_lanrxbase[0], dev.regs.qint_rqctl[i]);
txqs[i] =
new lan_queue_tx(*this, dev.regs.qtx_tail[i], i, dev.regs.qtx_ena[i],
dev.regs.glhmc_lantxbase[0], dev.regs.qint_tqctl[i]);
}
}
void lan::reset()
{
void lan::reset() {
rss_kc.set_dirty();
for (size_t i = 0; i < num_qs; i++) {
rxqs[i]->reset();
......@@ -61,15 +60,14 @@ void lan::reset()
}
}
void lan::qena_updated(uint16_t idx, bool rx)
{
void lan::qena_updated(uint16_t idx, bool rx) {
uint32_t &reg = (rx ? dev.regs.qrx_ena[idx] : dev.regs.qtx_ena[idx]);
#ifdef DEBUG_LAN
log << " qena updated idx=" << idx << " rx=" << rx << " reg=" << reg <<
logger::endl;
log << " qena updated idx=" << idx << " rx=" << rx << " reg=" << reg
<< logger::endl;
#endif
lan_queue_base &q = (rx ? static_cast<lan_queue_base &>(*rxqs[idx]) :
static_cast<lan_queue_base &>(*txqs[idx]));
lan_queue_base &q = (rx ? static_cast<lan_queue_base &>(*rxqs[idx])
: static_cast<lan_queue_base &>(*txqs[idx]));
if ((reg & I40E_QRX_ENA_QENA_REQ_MASK) && !q.is_enabled()) {
q.enable();
......@@ -78,38 +76,34 @@ void lan::qena_updated(uint16_t idx, bool rx)
}
}
void lan::tail_updated(uint16_t idx, bool rx)
{
void lan::tail_updated(uint16_t idx, bool rx) {
#ifdef DEBUG_LAN
log << " tail updated idx=" << idx << " rx=" << rx << logger::endl;
#endif
lan_queue_base &q = (rx ? static_cast<lan_queue_base &>(*rxqs[idx]) :
static_cast<lan_queue_base &>(*txqs[idx]));
lan_queue_base &q = (rx ? static_cast<lan_queue_base &>(*rxqs[idx])
: static_cast<lan_queue_base &>(*txqs[idx]));
if (q.is_enabled())
q.reg_updated();
}
void lan::rss_key_updated()
{
void lan::rss_key_updated() {
rss_kc.set_dirty();
}
bool lan::rss_steering(const void *data, size_t len, uint16_t &queue,
uint32_t &hash)
{
uint32_t &hash) {
hash = 0;
const headers::pkt_tcp *tcp =
reinterpret_cast<const headers::pkt_tcp *> (data);
reinterpret_cast<const headers::pkt_tcp *>(data);
const headers::pkt_udp *udp =
reinterpret_cast<const headers::pkt_udp *> (data);
reinterpret_cast<const headers::pkt_udp *>(data);
// should actually determine packet type and mask with enabled packet types
// TODO(antoinek): ipv6
if (tcp->eth.type == htons(ETH_TYPE_IP) &&
tcp->ip.proto == IP_PROTO_TCP) {
if (tcp->eth.type == htons(ETH_TYPE_IP) && tcp->ip.proto == IP_PROTO_TCP) {
hash = rss_kc.hash_ipv4(ntohl(tcp->ip.src), ntohl(tcp->ip.dest),
ntohs(tcp->tcp.src), ntohs(tcp->tcp.dest));
} else if (udp->eth.type == htons(ETH_TYPE_IP) &&
......@@ -122,8 +116,8 @@ bool lan::rss_steering(const void *data, size_t len, uint16_t &queue,
return false;
}
uint16_t luts = (!(dev.regs.pfqf_ctl_0 & I40E_PFQF_CTL_0_HASHLUTSIZE_MASK) ?
128 : 512);
uint16_t luts =
(!(dev.regs.pfqf_ctl_0 & I40E_PFQF_CTL_0_HASHLUTSIZE_MASK) ? 128 : 512);
uint16_t idx = hash % luts;
queue = (dev.regs.pfqf_hlut[idx / 4] >> (8 * (idx % 4))) & 0x3f;
#ifdef DEBUG_LAN
......@@ -132,8 +126,7 @@ bool lan::rss_steering(const void *data, size_t len, uint16_t &queue,
return true;
}
void lan::packet_received(const void *data, size_t len)
{
void lan::packet_received(const void *data, size_t len) {
#ifdef DEBUG_LAN
log << " packet received len=" << len << logger::endl;
#endif
......@@ -146,24 +139,25 @@ void lan::packet_received(const void *data, size_t len)
lan_queue_base::lan_queue_base(lan &lanmgr_, const std::string &qtype,
uint32_t &reg_tail_, size_t idx_,
uint32_t &reg_ena_, uint32_t &fpm_basereg_, uint32_t &reg_intqctl_,
uint16_t ctx_size_)
uint32_t &reg_ena_, uint32_t &fpm_basereg_,
uint32_t &reg_intqctl_, uint16_t ctx_size_)
: queue_base(qtype + std::to_string(idx_), reg_dummy_head, reg_tail_),
lanmgr(lanmgr_), enabling(false),
idx(idx_), reg_ena(reg_ena_), fpm_basereg(fpm_basereg_),
reg_intqctl(reg_intqctl_), ctx_size(ctx_size_)
{
lanmgr(lanmgr_),
enabling(false),
idx(idx_),
reg_ena(reg_ena_),
fpm_basereg(fpm_basereg_),
reg_intqctl(reg_intqctl_),
ctx_size(ctx_size_) {
ctx = new uint8_t[ctx_size_];
}
void lan_queue_base::reset()
{
void lan_queue_base::reset() {
enabling = false;
queue_base::reset();
}
void lan_queue_base::enable()
{
void lan_queue_base::enable() {
if (enabling || enabled)
return;
......@@ -175,7 +169,8 @@ void lan_queue_base::enable()
qctx_fetch *qf = new qctx_fetch(*this);
qf->write = false;
qf->dma_addr = ((fpm_basereg & I40E_GLHMC_LANTXBASE_FPMLANTXBASE_MASK) >>
I40E_GLHMC_LANTXBASE_FPMLANTXBASE_SHIFT) * 512;
I40E_GLHMC_LANTXBASE_FPMLANTXBASE_SHIFT) *
512;
qf->dma_addr += ctx_size * idx;
qf->len = ctx_size;
qf->data = ctx;
......@@ -183,8 +178,7 @@ void lan_queue_base::enable()
lanmgr.dev.hmc.issue_mem_op(*qf);
}
void lan_queue_base::ctx_fetched()
{
void lan_queue_base::ctx_fetched() {
#ifdef DEBUG_LAN
log << " lan ctx fetched " << idx << logger::endl;
#endif
......@@ -198,8 +192,7 @@ void lan_queue_base::ctx_fetched()
reg_updated();
}
void lan_queue_base::disable()
{
void lan_queue_base::disable() {
#ifdef DEBUG_LAN
log << " lan disabling queue " << idx << logger::endl;
#endif
......@@ -208,8 +201,7 @@ void lan_queue_base::disable()
reg_ena &= ~I40E_QRX_ENA_QENA_STAT_MASK;
}
void lan_queue_base::interrupt()
{
void lan_queue_base::interrupt() {
uint32_t qctl = reg_intqctl;
uint32_t gctl = lanmgr.dev.regs.pfint_dyn_ctl0;
#ifdef DEBUG_LAN
......@@ -234,44 +226,40 @@ void lan_queue_base::interrupt()
#ifdef DEBUG_LAN
log << " setting int0.qidx=" << msix0_idx << logger::endl;
#endif
lanmgr.dev.regs.pfint_icr0 |= I40E_PFINT_ICR0_INTEVENT_MASK |
lanmgr.dev.regs.pfint_icr0 |=
I40E_PFINT_ICR0_INTEVENT_MASK |
(1 << (I40E_PFINT_ICR0_QUEUE_0_SHIFT + msix0_idx));
}
uint8_t itr = (qctl & I40E_QINT_TQCTL_ITR_INDX_MASK) >>
I40E_QINT_TQCTL_ITR_INDX_SHIFT;
uint8_t itr =
(qctl & I40E_QINT_TQCTL_ITR_INDX_MASK) >> I40E_QINT_TQCTL_ITR_INDX_SHIFT;
lanmgr.dev.signal_interrupt(msix_idx, itr);
}
lan_queue_base::qctx_fetch::qctx_fetch(lan_queue_base &lq_)
: lq(lq_)
{
lan_queue_base::qctx_fetch::qctx_fetch(lan_queue_base &lq_) : lq(lq_) {
}
void lan_queue_base::qctx_fetch::done()
{
void lan_queue_base::qctx_fetch::done() {
lq.ctx_fetched();
delete this;
}
lan_queue_rx::lan_queue_rx(lan &lanmgr_, uint32_t &reg_tail_, size_t idx_,
uint32_t &reg_ena_, uint32_t &reg_fpmbase_, uint32_t &reg_intqctl_)
uint32_t &reg_ena_, uint32_t &reg_fpmbase_,
uint32_t &reg_intqctl_)
: lan_queue_base(lanmgr_, "rxq", reg_tail_, idx_, reg_ena_, reg_fpmbase_,
reg_intqctl_, 32)
{
reg_intqctl_, 32) {
// use larger value for initialization
desc_len = 32;
ctxs_init();
}
void lan_queue_rx::reset()
{
void lan_queue_rx::reset() {
dcache.clear();
queue_base::reset();
}
void lan_queue_rx::initialize()
{
void lan_queue_rx::initialize() {
#ifdef DEBUG_LAN
log << " initialize()" << logger::endl;
#endif
......@@ -299,7 +287,8 @@ void lan_queue_rx::initialize()
if (!longdesc) {
log << "lan_queue_rx::initialize: currently only 32B descs "
" supported" << logger::endl;
" supported"
<< logger::endl;
abort();
}
if (dtype != 0) {
......@@ -309,20 +298,19 @@ void lan_queue_rx::initialize()
}
#ifdef DEBUG_LAN
log << " head=" << reg_dummy_head << " base=" << base <<
" len=" << len << " dbsz=" << dbuff_size << " hbsz=" << hbuff_size <<
" dtype=" << (unsigned) dtype << " longdesc=" << longdesc <<
" crcstrip=" << crc_strip << " rxmax=" << rxmax << logger::endl;
log << " head=" << reg_dummy_head << " base=" << base << " len=" << len
<< " dbsz=" << dbuff_size << " hbsz=" << hbuff_size
<< " dtype=" << (unsigned)dtype << " longdesc=" << longdesc
<< " crcstrip=" << crc_strip << " rxmax=" << rxmax << logger::endl;
#endif
}
queue_base::desc_ctx &lan_queue_rx::desc_ctx_create()
{
queue_base::desc_ctx &lan_queue_rx::desc_ctx_create() {
return *new rx_desc_ctx(*this);
}
void lan_queue_rx::packet_received(const void *data, size_t pktlen, uint32_t h)
{
void lan_queue_rx::packet_received(const void *data, size_t pktlen,
uint32_t h) {
size_t num_descs = (pktlen + dbuff_size - 1) / dbuff_size;
if (!enabled)
......@@ -330,8 +318,8 @@ void lan_queue_rx::packet_received(const void *data, size_t pktlen, uint32_t h)
if (dcache.size() < num_descs) {
#ifdef DEBUG_LAN
log << " not enough rx descs (" << num_descs << ", dropping packet" <<
logger::endl;
log << " not enough rx descs (" << num_descs << ", dropping packet"
<< logger::endl;
#endif
return;
}
......@@ -340,12 +328,12 @@ void lan_queue_rx::packet_received(const void *data, size_t pktlen, uint32_t h)
rx_desc_ctx &ctx = *dcache.front();
#ifdef DEBUG_LAN
log << " packet part=" << i << " received didx=" << ctx.index <<
" cnt=" << dcache.size() << logger::endl;
log << " packet part=" << i << " received didx=" << ctx.index
<< " cnt=" << dcache.size() << logger::endl;
#endif
dcache.pop_front();
const uint8_t *buf = (const uint8_t *) data + (dbuff_size * i);
const uint8_t *buf = (const uint8_t *)data + (dbuff_size * i);
if (i == num_descs - 1) {
// last packet
ctx.packet_received(buf, pktlen - dbuff_size * i, true);
......@@ -356,61 +344,53 @@ void lan_queue_rx::packet_received(const void *data, size_t pktlen, uint32_t h)
}
lan_queue_rx::rx_desc_ctx::rx_desc_ctx(lan_queue_rx &queue_)
: desc_ctx(queue_), rq(queue_)
{
: desc_ctx(queue_), rq(queue_) {
}
void lan_queue_rx::rx_desc_ctx::data_written(uint64_t addr, size_t len)
{
void lan_queue_rx::rx_desc_ctx::data_written(uint64_t addr, size_t len) {
processed();
}
void lan_queue_rx::rx_desc_ctx::process()
{
void lan_queue_rx::rx_desc_ctx::process() {
rq.dcache.push_back(this);
}
void lan_queue_rx::rx_desc_ctx::packet_received(const void *data,
size_t pktlen, bool last)
{
union i40e_32byte_rx_desc *rxd = reinterpret_cast<
union i40e_32byte_rx_desc *> (desc);
void lan_queue_rx::rx_desc_ctx::packet_received(const void *data, size_t pktlen,
bool last) {
union i40e_32byte_rx_desc *rxd =
reinterpret_cast<union i40e_32byte_rx_desc *>(desc);
uint64_t addr = rxd->read.pkt_addr;
memset(rxd, 0, sizeof(*rxd));
rxd->wb.qword1.status_error_len |= (1 << I40E_RX_DESC_STATUS_DD_SHIFT);
rxd->wb.qword1.status_error_len |=
(pktlen << I40E_RXD_QW1_LENGTH_PBUF_SHIFT);
rxd->wb.qword1.status_error_len |= (pktlen << I40E_RXD_QW1_LENGTH_PBUF_SHIFT);
if (last) {
rxd->wb.qword1.status_error_len |= (1 << I40E_RX_DESC_STATUS_EOF_SHIFT);
// TODO(antoinek): only if checksums are correct
rxd->wb.qword1.status_error_len |=
(1 << I40E_RX_DESC_STATUS_L3L4P_SHIFT);
rxd->wb.qword1.status_error_len |= (1 << I40E_RX_DESC_STATUS_L3L4P_SHIFT);
}
data_write(addr, pktlen, data);
}
lan_queue_tx::lan_queue_tx(lan &lanmgr_, uint32_t &reg_tail_, size_t idx_,
uint32_t &reg_ena_, uint32_t &reg_fpmbase_, uint32_t &reg_intqctl)
uint32_t &reg_ena_, uint32_t &reg_fpmbase_,
uint32_t &reg_intqctl)
: lan_queue_base(lanmgr_, "txq", reg_tail_, idx_, reg_ena_, reg_fpmbase_,
reg_intqctl, 128)
{
reg_intqctl, 128) {
desc_len = 16;
ctxs_init();
}
void lan_queue_tx::reset()
{
void lan_queue_tx::reset() {
tso_off = 0;
tso_len = 0;
ready_segments.clear();
queue_base::reset();
}
void lan_queue_tx::initialize()
{
void lan_queue_tx::initialize() {
#ifdef DEBUG_LAN
log << " initialize()" << logger::endl;
#endif
......@@ -430,38 +410,33 @@ void lan_queue_tx::initialize()
hwb_addr = *hwb_addr_p;
#ifdef DEBUG_LAN
log << " head=" << reg_dummy_head << " base=" << base <<
" len=" << len << " hwb=" << hwb << " hwb_addr=" << hwb_addr <<
logger::endl;
log << " head=" << reg_dummy_head << " base=" << base << " len=" << len
<< " hwb=" << hwb << " hwb_addr=" << hwb_addr << logger::endl;
#endif
}
queue_base::desc_ctx &lan_queue_tx::desc_ctx_create()
{
queue_base::desc_ctx &lan_queue_tx::desc_ctx_create() {
return *new tx_desc_ctx(*this);
}
void lan_queue_tx::do_writeback(uint32_t first_idx, uint32_t first_pos,
uint32_t cnt)
{
uint32_t cnt) {
if (!hwb) {
// if head index writeback is disabled we need to write descriptor back
lan_queue_base::do_writeback(first_idx, first_pos, cnt);
} else {
// else we just need to write the index back
dma_hwb *dma = new dma_hwb(*this, first_pos, cnt,
(first_idx + cnt) % len);
dma_hwb *dma = new dma_hwb(*this, first_pos, cnt, (first_idx + cnt) % len);
dma->dma_addr = hwb_addr;
#ifdef DEBUG_LAN
log << " hwb=" << *((uint32_t *) dma->data) << logger::endl;
log << " hwb=" << *((uint32_t *)dma->data) << logger::endl;
#endif
runner->issue_dma(*dma);
}
}
bool lan_queue_tx::trigger_tx_packet()
{
bool lan_queue_tx::trigger_tx_packet() {
size_t n = ready_segments.size();
size_t d_skip = 0, dcnt;
bool eop = false;
......@@ -476,26 +451,24 @@ bool lan_queue_tx::trigger_tx_packet()
return false;
#ifdef DEBUG_LAN
log << "trigger_tx_packet(n=" << n << ", firstidx=" <<
ready_segments.at(0)->index << ")" << logger::endl;
log << "trigger_tx_packet(n=" << n
<< ", firstidx=" << ready_segments.at(0)->index << ")" << logger::endl;
log << " tso_off=" << tso_off << " tso_len=" << tso_len << logger::endl;
#endif
// check if we have a context descriptor first
tx_desc_ctx *rd = ready_segments.at(0);
uint8_t dtype = (rd->d->cmd_type_offset_bsz & I40E_TXD_QW1_DTYPE_MASK) >>
I40E_TXD_QW1_DTYPE_SHIFT;
if (dtype == I40E_TX_DESC_DTYPE_CONTEXT) {
struct i40e_tx_context_desc *ctxd =
reinterpret_cast<struct i40e_tx_context_desc *> (rd->d);
reinterpret_cast<struct i40e_tx_context_desc *>(rd->d);
d1 = ctxd->type_cmd_tso_mss;
uint16_t cmd = ((d1 & I40E_TXD_CTX_QW1_CMD_MASK) >>
I40E_TXD_CTX_QW1_CMD_SHIFT);
uint16_t cmd =
((d1 & I40E_TXD_CTX_QW1_CMD_MASK) >> I40E_TXD_CTX_QW1_CMD_SHIFT);
tso = !!(cmd & I40E_TX_CTX_DESC_TSO);
tso_mss = (d1 & I40E_TXD_CTX_QW1_MSS_MASK) >>
I40E_TXD_CTX_QW1_MSS_SHIFT;
tso_mss = (d1 & I40E_TXD_CTX_QW1_MSS_MASK) >> I40E_TXD_CTX_QW1_MSS_SHIFT;
#ifdef DEBUG_LAN
log << " tso=" << tso << " mss=" << tso_mss << logger::endl;
......@@ -510,8 +483,7 @@ bool lan_queue_tx::trigger_tx_packet()
d1 = rd->d->cmd_type_offset_bsz;
#ifdef DEBUG_LAN
log << " data fetched didx=" << rd->index << " d1=" <<
d1 << logger::endl;
log << " data fetched didx=" << rd->index << " d1=" << d1 << logger::endl;
#endif
dtype = (d1 & I40E_TXD_QW1_DTYPE_MASK) >> I40E_TXD_QW1_DTYPE_SHIFT;
......@@ -527,18 +499,21 @@ bool lan_queue_tx::trigger_tx_packet()
l4t = (cmd & I40E_TX_DESC_CMD_L4T_EOFT_MASK);
if (eop) {
uint32_t off = (d1 & I40E_TXD_QW1_OFFSET_MASK) >>
I40E_TXD_QW1_OFFSET_SHIFT;
uint32_t off =
(d1 & I40E_TXD_QW1_OFFSET_MASK) >> I40E_TXD_QW1_OFFSET_SHIFT;
maclen = ((off & I40E_TXD_QW1_MACLEN_MASK) >>
I40E_TX_DESC_LENGTH_MACLEN_SHIFT) * 2;
iplen = ((off & I40E_TXD_QW1_IPLEN_MASK) >>
I40E_TX_DESC_LENGTH_IPLEN_SHIFT) * 4;
I40E_TX_DESC_LENGTH_MACLEN_SHIFT) *
2;
iplen =
((off & I40E_TXD_QW1_IPLEN_MASK) >> I40E_TX_DESC_LENGTH_IPLEN_SHIFT) *
4;
l4len = ((off & I40E_TXD_QW1_L4LEN_MASK) >>
I40E_TX_DESC_LENGTH_L4_FC_LEN_SHIFT) * 4;
I40E_TX_DESC_LENGTH_L4_FC_LEN_SHIFT) *
4;
}
pkt_len = (d1 & I40E_TXD_QW1_TX_BUF_SZ_MASK) >>
I40E_TXD_QW1_TX_BUF_SZ_SHIFT;
pkt_len =
(d1 & I40E_TXD_QW1_TX_BUF_SZ_MASK) >> I40E_TXD_QW1_TX_BUF_SZ_SHIFT;
total_len += pkt_len;
#ifdef DEBUG_LAN
......@@ -561,31 +536,29 @@ bool lan_queue_tx::trigger_tx_packet()
}
} else {
if (total_len > MTU) {
log << " packet is longer (" << total_len << ") than MTU (" <<
MTU << ")" << logger::endl;
log << " packet is longer (" << total_len << ") than MTU (" << MTU
<< ")" << logger::endl;
abort();
}
data_limit = total_len;
}
#ifdef DEBUG_LAN
log << " iipt=" << iipt << " l4t=" << l4t <<
" maclen=" << maclen << " iplen=" << iplen << " l4len=" << l4len <<
" total_len=" << total_len << " data_limit=" << data_limit <<
logger::endl;
log << " iipt=" << iipt << " l4t=" << l4t << " maclen=" << maclen
<< " iplen=" << iplen << " l4len=" << l4len << " total_len=" << total_len
<< " data_limit=" << data_limit << logger::endl;
#else
(void) iipt;
(void)iipt;
#endif
// copy data for this segment
uint32_t off = 0;
for (dcnt = d_skip; dcnt < n && off < data_limit; dcnt++) {
tx_desc_ctx *rd = ready_segments.at(dcnt);
d1 = rd->d->cmd_type_offset_bsz;
uint16_t pkt_len = (d1 & I40E_TXD_QW1_TX_BUF_SZ_MASK) >>
I40E_TXD_QW1_TX_BUF_SZ_SHIFT;
uint16_t pkt_len =
(d1 & I40E_TXD_QW1_TX_BUF_SZ_MASK) >> I40E_TXD_QW1_TX_BUF_SZ_SHIFT;
if (off <= tso_off && off + pkt_len > tso_off) {
uint32_t start = tso_off;
......@@ -594,12 +567,12 @@ bool lan_queue_tx::trigger_tx_packet()
end = data_limit;
#ifdef DEBUG_LAN
log << " copying data from off=" << off << " idx=" << rd->index <<
" start=" << start << " end=" << end << " tso_len=" << tso_len <<
logger::endl;
log << " copying data from off=" << off << " idx=" << rd->index
<< " start=" << start << " end=" << end << " tso_len=" << tso_len
<< logger::endl;
#endif
memcpy(pktbuf + tso_len, (uint8_t *) rd->data + (start - off),
memcpy(pktbuf + tso_len, (uint8_t *)rd->data + (start - off),
end - start);
tso_off = end;
tso_len += end - start;
......@@ -623,8 +596,8 @@ bool lan_queue_tx::trigger_tx_packet()
runner->eth_send(pktbuf, tso_len);
} else {
#ifdef DEBUG_LAN
log << " tso packet off=" << tso_off << " len=" << tso_len <<
logger::endl;
log << " tso packet off=" << tso_off << " len=" << tso_len
<< logger::endl;
#endif
// TSO gets hairier
......@@ -662,82 +635,73 @@ bool lan_queue_tx::trigger_tx_packet()
return true;
}
void lan_queue_tx::trigger_tx()
{
while (trigger_tx_packet()) {}
void lan_queue_tx::trigger_tx() {
while (trigger_tx_packet()) {
}
}
lan_queue_tx::tx_desc_ctx::tx_desc_ctx(lan_queue_tx &queue_)
: desc_ctx(queue_), tq(queue_)
{
: desc_ctx(queue_), tq(queue_) {
d = reinterpret_cast<struct i40e_tx_desc *>(desc);
}
void lan_queue_tx::tx_desc_ctx::prepare()
{
void lan_queue_tx::tx_desc_ctx::prepare() {
uint64_t d1 = d->cmd_type_offset_bsz;
#ifdef DEBUG_LAN
queue.log << " desc fetched didx=" << index << " d1=" <<
d1 << logger::endl;
queue.log << " desc fetched didx=" << index << " d1=" << d1 << logger::endl;
#endif
uint8_t dtype = (d1 & I40E_TXD_QW1_DTYPE_MASK) >> I40E_TXD_QW1_DTYPE_SHIFT;
if (dtype == I40E_TX_DESC_DTYPE_DATA) {
uint16_t len = (d1 & I40E_TXD_QW1_TX_BUF_SZ_MASK) >>
I40E_TXD_QW1_TX_BUF_SZ_SHIFT;
uint16_t len =
(d1 & I40E_TXD_QW1_TX_BUF_SZ_MASK) >> I40E_TXD_QW1_TX_BUF_SZ_SHIFT;
#ifdef DEBUG_LAN
queue.log << " bufaddr=" << d->buffer_addr <<
" len=" << len << logger::endl;
queue.log << " bufaddr=" << d->buffer_addr << " len=" << len
<< logger::endl;
#endif
data_fetch(d->buffer_addr, len);
} else if (dtype == I40E_TX_DESC_DTYPE_CONTEXT) {
#ifdef DEBUG_LAN
struct i40e_tx_context_desc *ctxd =
reinterpret_cast<struct i40e_tx_context_desc *> (d);
queue.log << " context descriptor: tp=" << ctxd->tunneling_params <<
" l2t=" << ctxd->l2tag2 << " tctm=" << ctxd->type_cmd_tso_mss <<
logger::endl;
reinterpret_cast<struct i40e_tx_context_desc *>(d);
queue.log << " context descriptor: tp=" << ctxd->tunneling_params
<< " l2t=" << ctxd->l2tag2 << " tctm=" << ctxd->type_cmd_tso_mss
<< logger::endl;
#endif
prepared();
} else {
queue.log << "txq: only support context & data descriptors" <<
logger::endl;
queue.log << "txq: only support context & data descriptors" << logger::endl;
abort();
}
}
void lan_queue_tx::tx_desc_ctx::process()
{
void lan_queue_tx::tx_desc_ctx::process() {
tq.ready_segments.push_back(this);
tq.trigger_tx();
}
void lan_queue_tx::tx_desc_ctx::processed()
{
d->cmd_type_offset_bsz = I40E_TX_DESC_DTYPE_DESC_DONE <<
I40E_TXD_QW1_DTYPE_SHIFT;
void lan_queue_tx::tx_desc_ctx::processed() {
d->cmd_type_offset_bsz = I40E_TX_DESC_DTYPE_DESC_DONE
<< I40E_TXD_QW1_DTYPE_SHIFT;
desc_ctx::processed();
}
lan_queue_tx::dma_hwb::dma_hwb(lan_queue_tx &queue_, uint32_t pos_,
uint32_t cnt_, uint32_t nh_)
: queue(queue_), pos(pos_), cnt(cnt_), next_head(nh_)
{
: queue(queue_), pos(pos_), cnt(cnt_), next_head(nh_) {
data = &next_head;
len = 4;
write = true;
}
lan_queue_tx::dma_hwb::~dma_hwb()
{
lan_queue_tx::dma_hwb::~dma_hwb() {
}
void lan_queue_tx::dma_hwb::done()
{
void lan_queue_tx::dma_hwb::done() {
#ifdef DEBUG_LAN
queue.log << " tx head written back" << logger::endl;
#endif
......
sims/nic/i40e_bm/i40e_queues.cc
View file @ d4666c97
......@@ -24,12 +24,13 @@
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <cassert>
#include <iostream>
#include <algorithm>
#include "sims/nic/i40e_bm/i40e_bm.h"
#include "sims/nic/i40e_bm/i40e_base_wrapper.h"
#include "sims/nic/i40e_bm/i40e_bm.h"
using namespace i40e;
......@@ -37,24 +38,29 @@ extern nicbm::Runner *runner;
queue_base::queue_base(const std::string &qname_, uint32_t &reg_head_,
uint32_t &reg_tail_)
: qname(qname_), log(qname_), active_first_pos(0), active_first_idx(0),
active_cnt(0), base(0), len(0), reg_head(reg_head_), reg_tail(reg_tail_),
enabled(false), desc_len(0)
{
: qname(qname_),
log(qname_),
active_first_pos(0),
active_first_idx(0),
active_cnt(0),
base(0),
len(0),
reg_head(reg_head_),
reg_tail(reg_tail_),
enabled(false),
desc_len(0) {
for (size_t i = 0; i < MAX_ACTIVE_DESCS; i++) {
desc_ctxs[i] = nullptr;
}
}
void queue_base::ctxs_init()
{
void queue_base::ctxs_init() {
for (size_t i = 0; i < MAX_ACTIVE_DESCS; i++) {
desc_ctxs[i] = &desc_ctx_create();
}
}
void queue_base::trigger_fetch()
{
void queue_base::trigger_fetch() {
if (!enabled)
return;
......@@ -71,8 +77,8 @@ void queue_base::trigger_fetch()
fetch_cnt = len - next_idx;
#ifdef DEBUG_QUEUES
log << "fetching avail=" << desc_avail << " cnt=" << fetch_cnt << " idx=" <<
next_idx << logger::endl;
log << "fetching avail=" << desc_avail << " cnt=" << fetch_cnt
<< " idx=" << next_idx << logger::endl;
#endif
// abort if nothign to fetch
......@@ -101,23 +107,21 @@ void queue_base::trigger_fetch()
runner->issue_dma(*dma);
}
void queue_base::trigger_process()
{
void queue_base::trigger_process() {
if (!enabled)
return;
// first skip over descriptors that are already done processing
uint32_t i;
for (i = 0; i < active_cnt; i++)
if (desc_ctxs[(active_first_pos + i) % MAX_ACTIVE_DESCS]->state
<= desc_ctx::DESC_PREPARED)
if (desc_ctxs[(active_first_pos + i) % MAX_ACTIVE_DESCS]->state <=
desc_ctx::DESC_PREPARED)
break;
// then run all prepared contexts
uint32_t j;
for (j = 0; i + j < active_cnt; j++) {
desc_ctx &ctx = *desc_ctxs[(active_first_pos + i + j)
% MAX_ACTIVE_DESCS];
desc_ctx &ctx = *desc_ctxs[(active_first_pos + i + j) % MAX_ACTIVE_DESCS];
if (ctx.state != desc_ctx::DESC_PREPARED)
break;
......@@ -129,16 +133,15 @@ void queue_base::trigger_process()
}
}
void queue_base::trigger_writeback()
{
void queue_base::trigger_writeback() {
if (!enabled)
return;
// from first pos count number of processed descriptors
uint32_t avail;
for (avail = 0; avail < active_cnt; avail++)
if (desc_ctxs[(active_first_pos + avail) % MAX_ACTIVE_DESCS]->state
!= desc_ctx::DESC_PROCESSED)
if (desc_ctxs[(active_first_pos + avail) % MAX_ACTIVE_DESCS]->state !=
desc_ctx::DESC_PROCESSED)
break;
uint32_t cnt = std::min(avail, max_writeback_capacity());
......@@ -146,8 +149,8 @@ void queue_base::trigger_writeback()
cnt = len - active_first_idx;
#ifdef DEBUG_QUEUES
log << "writing back avail=" << avail << " cnt=" << cnt <<
" idx=" << active_first_idx << logger::endl;
log << "writing back avail=" << avail << " cnt=" << cnt
<< " idx=" << active_first_idx << logger::endl;
#endif
if (cnt == 0)
......@@ -162,15 +165,13 @@ void queue_base::trigger_writeback()
do_writeback(active_first_idx, active_first_pos, cnt);
}
void queue_base::trigger()
{
void queue_base::trigger() {
trigger_fetch();
trigger_process();
trigger_writeback();
}
void queue_base::reset()
{
void queue_base::reset() {
#ifdef DEBUG_QUEUES
log << "reset" << logger::endl;
#endif
......@@ -185,11 +186,10 @@ void queue_base::reset()
}
}
void queue_base::reg_updated()
{
void queue_base::reg_updated() {
#ifdef DEBUG_QUEUES
log << "reg_updated: tail=" << reg_tail << " enabled=" << (int) enabled <<
logger::endl;
log << "reg_updated: tail=" << reg_tail << " enabled=" << (int)enabled
<< logger::endl;
#endif
if (!enabled)
return;
......@@ -197,39 +197,33 @@ void queue_base::reg_updated()
trigger();
}
bool queue_base::is_enabled()
{
bool queue_base::is_enabled() {
return enabled;
}
uint32_t queue_base::max_fetch_capacity()
{
uint32_t queue_base::max_fetch_capacity() {
return UINT32_MAX;
}
uint32_t queue_base::max_active_capacity()
{
uint32_t queue_base::max_active_capacity() {
return UINT32_MAX;
}
uint32_t queue_base::max_writeback_capacity()
{
uint32_t queue_base::max_writeback_capacity() {
return UINT32_MAX;
}
void queue_base::interrupt()
{
void queue_base::interrupt() {
}
void queue_base::do_writeback(uint32_t first_idx, uint32_t first_pos,
uint32_t cnt)
{
uint32_t cnt) {
dma_wb *dma = new dma_wb(*this, desc_len * cnt);
dma->write = true;
dma->dma_addr = base + first_idx * desc_len;
dma->pos = first_pos;
uint8_t *buf = reinterpret_cast<uint8_t *> (dma->data);
uint8_t *buf = reinterpret_cast<uint8_t *>(dma->data);
for (uint32_t i = 0; i < cnt; i++) {
desc_ctx &ctx = *desc_ctxs[(first_pos + i) % MAX_ACTIVE_DESCS];
assert(ctx.state == desc_ctx::DESC_WRITING_BACK);
......@@ -239,8 +233,7 @@ void queue_base::do_writeback(uint32_t first_idx, uint32_t first_pos,
runner->issue_dma(*dma);
}
void queue_base::writeback_done(uint32_t first_pos, uint32_t cnt)
{
void queue_base::writeback_done(uint32_t first_pos, uint32_t cnt) {
if (!enabled)
return;
......@@ -252,17 +245,17 @@ void queue_base::writeback_done(uint32_t first_pos, uint32_t cnt)
}
#ifdef DEBUG_QUEUES
log << "written back afi=" << active_first_idx << " afp=" <<
active_first_pos << " acnt=" << active_cnt << " pos=" <<
first_pos << " cnt=" << cnt << logger::endl;
log << "written back afi=" << active_first_idx << " afp=" << active_first_pos
<< " acnt=" << active_cnt << " pos=" << first_pos << " cnt=" << cnt
<< logger::endl;
#endif
// then start at the beginning and check how many are written back and then
// free those
uint32_t bump_cnt = 0;
for (bump_cnt = 0; bump_cnt < active_cnt; bump_cnt++) {
desc_ctx &ctx = *desc_ctxs[(active_first_pos + bump_cnt) %
MAX_ACTIVE_DESCS];
desc_ctx &ctx =
*desc_ctxs[(active_first_pos + bump_cnt) % MAX_ACTIVE_DESCS];
if (ctx.state != desc_ctx::DESC_WRITTEN_BACK)
break;
......@@ -281,26 +274,26 @@ void queue_base::writeback_done(uint32_t first_pos, uint32_t cnt)
}
queue_base::desc_ctx::desc_ctx(queue_base &queue_)
: queue(queue_), state(DESC_EMPTY), index(0), data(nullptr), data_len(0),
data_capacity(0)
{
: queue(queue_),
state(DESC_EMPTY),
index(0),
data(nullptr),
data_len(0),
data_capacity(0) {
desc = new uint8_t[queue_.desc_len];
}
queue_base::desc_ctx::~desc_ctx()
{
delete[] ((uint8_t *) desc);
queue_base::desc_ctx::~desc_ctx() {
delete[]((uint8_t *)desc);
if (data_capacity > 0)
delete[] ((uint8_t *) data);
delete[]((uint8_t *)data);
}
void queue_base::desc_ctx::prepare()
{
void queue_base::desc_ctx::prepare() {
prepared();
}
void queue_base::desc_ctx::prepared()
{
void queue_base::desc_ctx::prepared() {
#ifdef DEBUG_QUEUES
queue.log << "prepared desc " << index << logger::endl;
#endif
......@@ -308,8 +301,7 @@ void queue_base::desc_ctx::prepared()
state = DESC_PREPARED;
}
void queue_base::desc_ctx::processed()
{
void queue_base::desc_ctx::processed() {
#ifdef DEBUG_QUEUES
queue.log << "processed desc " << index << logger::endl;
#endif
......@@ -317,47 +309,44 @@ void queue_base::desc_ctx::processed()
state = DESC_PROCESSED;
}
#define MAX_DMA_SIZE ((size_t) 9024)
#define MAX_DMA_SIZE ((size_t)9024)
void queue_base::desc_ctx::data_fetch(uint64_t addr, size_t data_len)
{
void queue_base::desc_ctx::data_fetch(uint64_t addr, size_t data_len) {
if (data_capacity < data_len) {
#ifdef DEBUG_QUEUES
queue.log << "data_fetch allocating" << logger::endl;
#endif
if (data_capacity != 0)
delete[] ((uint8_t *) data);
delete[]((uint8_t *)data);
data = new uint8_t[data_len];
data_capacity = data_len;
}
dma_data_fetch *dma = new dma_data_fetch(*this, std::min(data_len,
MAX_DMA_SIZE), data);
dma_data_fetch *dma =
new dma_data_fetch(*this, std::min(data_len, MAX_DMA_SIZE), data);
dma->part_offset = 0;
dma->total_len = data_len;
dma->write = false;
dma->dma_addr = addr;
#ifdef DEBUG_QUEUES
queue.log << "fetching data idx=" << index << " addr=" << addr << " len=" <<
data_len << logger::endl;
queue.log << "fetching data idx=" << index << " addr=" << addr
<< " len=" << data_len << logger::endl;
queue.log << " dma = " << dma << " data=" << data << logger::endl;
#endif
runner->issue_dma(*dma);
}
void queue_base::desc_ctx::data_fetched(uint64_t addr, size_t len)
{
void queue_base::desc_ctx::data_fetched(uint64_t addr, size_t len) {
prepared();
}
void queue_base::desc_ctx::data_write(uint64_t addr, size_t data_len,
const void *buf)
{
const void *buf) {
#ifdef DEBUG_QUEUES
queue.log << "data_write(addr=" << addr << " datalen=" << data_len << ")" <<
logger::endl;
queue.log << "data_write(addr=" << addr << " datalen=" << data_len << ")"
<< logger::endl;
#endif
dma_data_wb *data_dma = new dma_data_wb(*this, data_len);
data_dma->write = true;
......@@ -367,30 +356,26 @@ void queue_base::desc_ctx::data_write(uint64_t addr, size_t data_len,
runner->issue_dma(*data_dma);
}
void queue_base::desc_ctx::data_written(uint64_t addr, size_t len)
{
void queue_base::desc_ctx::data_written(uint64_t addr, size_t len) {
#ifdef DEBUG_QUEUES
queue.log << "data_written(addr=" << addr << " datalen=" << len << ")" <<
logger::endl;
queue.log << "data_written(addr=" << addr << " datalen=" << len << ")"
<< logger::endl;
#endif
processed();
}
queue_base::dma_fetch::dma_fetch(queue_base &queue_, size_t len_)
: queue(queue_)
{
: queue(queue_) {
data = new char[len_];
len = len_;
}
queue_base::dma_fetch::~dma_fetch()
{
delete[] ((char *) data);
queue_base::dma_fetch::~dma_fetch() {
delete[]((char *)data);
}
void queue_base::dma_fetch::done()
{
uint8_t *buf = reinterpret_cast <uint8_t *> (data);
void queue_base::dma_fetch::done() {
uint8_t *buf = reinterpret_cast<uint8_t *>(data);
for (uint32_t i = 0; i < len / queue.desc_len; i++) {
desc_ctx &ctx = *queue.desc_ctxs[(pos + i) % queue.MAX_ACTIVE_DESCS];
memcpy(ctx.desc, buf + queue.desc_len * i, queue.desc_len);
......@@ -407,26 +392,22 @@ void queue_base::dma_fetch::done()
queue_base::dma_data_fetch::dma_data_fetch(desc_ctx &ctx_, size_t len_,
void *buffer)
: ctx(ctx_)
{
: ctx(ctx_) {
data = buffer;
len = len_;
}
queue_base::dma_data_fetch::~dma_data_fetch()
{
queue_base::dma_data_fetch::~dma_data_fetch() {
}
void queue_base::dma_data_fetch::done()
{
void queue_base::dma_data_fetch::done() {
part_offset += len;
dma_addr += len;
data = (uint8_t *) data + len;
data = (uint8_t *)data + len;
if (part_offset < total_len) {
#ifdef DEBUG_QUEUES
ctx.queue.log << " dma_fetch: next part of multi part dma" <<
logger::endl;
ctx.queue.log << " dma_fetch: next part of multi part dma" << logger::endl;
#endif
len = std::min(total_len - part_offset, MAX_DMA_SIZE);
runner->issue_dma(*this);
......@@ -437,40 +418,31 @@ void queue_base::dma_data_fetch::done()
delete this;
}
queue_base::dma_wb::dma_wb(queue_base &queue_, size_t len_)
: queue(queue_)
{
queue_base::dma_wb::dma_wb(queue_base &queue_, size_t len_) : queue(queue_) {
data = new char[len_];
len = len_;
}
queue_base::dma_wb::~dma_wb()
{
delete[] ((char *) data);
queue_base::dma_wb::~dma_wb() {
delete[]((char *)data);
}
void queue_base::dma_wb::done()
{
void queue_base::dma_wb::done() {
queue.writeback_done(pos, len / queue.desc_len);
queue.trigger();
delete this;
}
queue_base::dma_data_wb::dma_data_wb(desc_ctx &ctx_, size_t len_)
: ctx(ctx_)
{
queue_base::dma_data_wb::dma_data_wb(desc_ctx &ctx_, size_t len_) : ctx(ctx_) {
data = new char[len_];
len = len_;
}
queue_base::dma_data_wb::~dma_data_wb()
{
delete[] ((char *) data);
queue_base::dma_data_wb::~dma_data_wb() {
delete[]((char *)data);
}
void queue_base::dma_data_wb::done()
{
void queue_base::dma_data_wb::done() {
ctx.data_written(dma_addr, len);
ctx.queue.trigger();
delete this;
......
sims/nic/i40e_bm/logger.cc
View file @ d4666c97
......@@ -30,17 +30,14 @@ using namespace i40e;
extern nicbm::Runner *runner;
logger::logger(const std::string &label_)
: label(label_)
{
logger::logger(const std::string &label_) : label(label_) {
ss << std::hex;
}
logger &logger::operator<<(char c)
{
logger &logger::operator<<(char c) {
if (c == endl) {
std::cerr << runner->time_ps() << " " << label << ": " << ss.str() <<
std::endl;
std::cerr << runner->time_ps() << " " << label << ": " << ss.str()
<< std::endl;
ss.str(std::string());
ss << std::hex;
} else {
......@@ -49,50 +46,42 @@ logger &logger::operator<<(char c)
return *this;
}
logger &logger::operator<<(int32_t i)
{
logger &logger::operator<<(int32_t i) {
ss << i;
return *this;
}
logger &logger::operator<<(uint8_t i)
{
ss << (unsigned) i;
logger &logger::operator<<(uint8_t i) {
ss << (unsigned)i;
return *this;
}
logger &logger::operator<<(uint16_t i)
{
logger &logger::operator<<(uint16_t i) {
ss << i;
return *this;
}
logger &logger::operator<<(uint32_t i)
{
logger &logger::operator<<(uint32_t i) {
ss << i;
return *this;
}
logger &logger::operator<<(uint64_t i)
{
logger &logger::operator<<(uint64_t i) {
ss << i;
return *this;
}
logger &logger::operator<<(bool b)
{
logger &logger::operator<<(bool b) {
ss << b;
return *this;
}
logger &logger::operator<<(const char *str)
{
logger &logger::operator<<(const char *str) {
ss << str;
return *this;
}
logger &logger::operator<<(void *ptr)
{
logger &logger::operator<<(void *ptr) {
ss << ptr;
return *this;
}
sims/nic/i40e_bm/rss.cc
View file @ d4666c97
......@@ -26,20 +26,14 @@
using namespace i40e;
rss_key_cache::rss_key_cache(const uint32_t (&key_)[key_len / 4])
: key(key_)
{
rss_key_cache::rss_key_cache(const uint32_t (&key_)[key_len / 4]) : key(key_) {
cache_dirty = true;
}
void rss_key_cache::build()
{
const uint8_t *k = reinterpret_cast<const uint8_t *> (&key);
uint32_t result = (((uint32_t)k[0]) << 24) |
(((uint32_t)k[1]) << 16) |
(((uint32_t)k[2]) << 8) |
((uint32_t)k[3]);
void rss_key_cache::build() {
const uint8_t *k = reinterpret_cast<const uint8_t *>(&key);
uint32_t result = (((uint32_t)k[0]) << 24) | (((uint32_t)k[1]) << 16) |
(((uint32_t)k[2]) << 8) | ((uint32_t)k[3]);
uint32_t idx = 32;
size_t i;
......@@ -56,14 +50,12 @@ void rss_key_cache::build()
cache_dirty = false;
}
void rss_key_cache::set_dirty()
{
void rss_key_cache::set_dirty() {
cache_dirty = true;
}
uint32_t rss_key_cache::hash_ipv4(uint32_t sip, uint32_t dip, uint16_t sp,
uint16_t dp)
{
uint16_t dp) {
static const uint32_t MSB32 = 0x80000000;
static const uint32_t MSB16 = 0x8000;
uint32_t res = 0;
......@@ -79,17 +71,17 @@ uint32_t rss_key_cache::hash_ipv4(uint32_t sip, uint32_t dip, uint16_t sp,
}
for (i = 0; i < 32; i++) {
if (dip & MSB32)
res ^= cache[32+i];
res ^= cache[32 + i];
dip <<= 1;
}
for (i = 0; i < 16; i++) {
if (sp & MSB16)
res ^= cache[64+i];
res ^= cache[64 + i];
sp <<= 1;
}
for (i = 0; i < 16; i++) {
if (dp & MSB16)
res ^= cache[80+i];
res ^= cache[80 + i];
dp <<= 1;
}
......
sims/nic/i40e_bm/xsums.cc
View file @ d4666c97
......@@ -6,9 +6,10 @@
* All rights reserved.
*/
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <cassert>
#include <iostream>
......@@ -29,7 +30,6 @@ struct rte_tcp_hdr {
uint16_t tcp_urp; /**< TCP urgent pointer, if any. */
} __attribute__((packed));
/* from dpdk/lib/librte_net/rte_ip.h */
struct ipv4_hdr {
uint8_t version_ihl; /**< version and header length */
......@@ -45,8 +45,7 @@ struct ipv4_hdr {
} __attribute__((packed));
static inline uint32_t __rte_raw_cksum(const void *buf, size_t len,
uint32_t sum)
{
uint32_t sum) {
/* workaround gcc strict-aliasing warning */
uintptr_t ptr = (uintptr_t)buf;
typedef uint16_t __attribute__((__may_alias__)) u16_p;
......@@ -76,23 +75,20 @@ static inline uint32_t __rte_raw_cksum(const void *buf, size_t len,
return sum;
}
static inline uint16_t __rte_raw_cksum_reduce(uint32_t sum)
{
static inline uint16_t __rte_raw_cksum_reduce(uint32_t sum) {
sum = ((sum & 0xffff0000) >> 16) + (sum & 0xffff);
sum = ((sum & 0xffff0000) >> 16) + (sum & 0xffff);
return (uint16_t)sum;
}
static inline uint16_t rte_raw_cksum(const void *buf, size_t len)
{
static inline uint16_t rte_raw_cksum(const void *buf, size_t len) {
uint32_t sum;
sum = __rte_raw_cksum(buf, len, 0);
return __rte_raw_cksum_reduce(sum);
}
static inline uint16_t rte_ipv4_phdr_cksum(const struct ipv4_hdr *ipv4_hdr)
{
static inline uint16_t rte_ipv4_phdr_cksum(const struct ipv4_hdr *ipv4_hdr) {
struct ipv4_psd_header {
uint32_t src_addr; /* IP address of source host. */
uint32_t dst_addr; /* IP address of destination host. */
......@@ -106,15 +102,12 @@ static inline uint16_t rte_ipv4_phdr_cksum(const struct ipv4_hdr *ipv4_hdr)
psd_hdr.zero = 0;
psd_hdr.proto = ipv4_hdr->next_proto_id;
psd_hdr.len = htons(
(uint16_t)(ntohs(ipv4_hdr->total_length)
- sizeof(struct ipv4_hdr)));
(uint16_t)(ntohs(ipv4_hdr->total_length) - sizeof(struct ipv4_hdr)));
return rte_raw_cksum(&psd_hdr, sizeof(psd_hdr));
}
void xsum_tcp(void *tcphdr, size_t l4_len)
{
struct rte_tcp_hdr *tcph = reinterpret_cast<struct rte_tcp_hdr *> (tcphdr);
void xsum_tcp(void *tcphdr, size_t l4_len) {
struct rte_tcp_hdr *tcph = reinterpret_cast<struct rte_tcp_hdr *>(tcphdr);
uint32_t cksum = rte_raw_cksum(tcphdr, l4_len);
cksum = ((cksum & 0xffff0000) >> 16) + (cksum & 0xffff);
cksum = (~cksum) & 0xffff;
......@@ -122,11 +115,9 @@ void xsum_tcp(void *tcphdr, size_t l4_len)
}
void xsum_tcpip_tso(void *iphdr, uint8_t iplen, uint8_t l4len,
uint16_t paylen)
{
struct ipv4_hdr *ih = (struct ipv4_hdr *) iphdr;
struct rte_tcp_hdr *tcph = (struct rte_tcp_hdr *)
((uint8_t *) iphdr + iplen);
uint16_t paylen) {
struct ipv4_hdr *ih = (struct ipv4_hdr *)iphdr;
struct rte_tcp_hdr *tcph = (struct rte_tcp_hdr *)((uint8_t *)iphdr + iplen);
uint32_t cksum;
// calculate ip xsum
......@@ -147,11 +138,9 @@ void xsum_tcpip_tso(void *iphdr, uint8_t iplen, uint8_t l4len,
}
void tso_postupdate_header(void *iphdr, uint8_t iplen, uint8_t l4len,
uint16_t paylen)
{
struct ipv4_hdr *ih = (struct ipv4_hdr *) iphdr;
struct rte_tcp_hdr *tcph = (struct rte_tcp_hdr *)
((uint8_t *) iphdr + iplen);
uint16_t paylen) {
struct ipv4_hdr *ih = (struct ipv4_hdr *)iphdr;
struct rte_tcp_hdr *tcph = (struct rte_tcp_hdr *)((uint8_t *)iphdr + iplen);
tcph->sent_seq = htonl(ntohl(tcph->sent_seq) + paylen);
ih->packet_id = htons(ntohs(ih->packet_id) + 1);
}
......
trace/events.h
View file @ d4666c97
......@@ -30,12 +30,11 @@ class event {
public:
uint64_t ts;
event(uint64_t ts_)
: ts(ts_)
{
event(uint64_t ts_) : ts(ts_) {
}
virtual ~event() { }
virtual ~event() {
}
virtual void dump(std::ostream &out) = 0;
};
......@@ -44,15 +43,13 @@ class EHostCall : public event {
public:
const std::string &fun;
EHostCall(uint64_t ts_, const std::string &fun_)
: event(ts_), fun(fun_)
{
EHostCall(uint64_t ts_, const std::string &fun_) : event(ts_), fun(fun_) {
}
virtual ~EHostCall() { }
virtual ~EHostCall() {
}
virtual void dump(std::ostream &out)
{
virtual void dump(std::ostream &out) {
out << ts << ": H.CALL " << fun << std::endl;
}
};
......@@ -61,15 +58,13 @@ class EHostMsiX : public event {
public:
uint16_t vec;
EHostMsiX(uint64_t ts_, uint16_t vec_)
: event(ts_), vec(vec_)
{
EHostMsiX(uint64_t ts_, uint16_t vec_) : event(ts_), vec(vec_) {
}
virtual ~EHostMsiX() { }
virtual ~EHostMsiX() {
}
virtual void dump(std::ostream &out)
{
virtual void dump(std::ostream &out) {
out << ts << ": H.MSIX " << vec << std::endl;
}
};
......@@ -81,16 +76,15 @@ class EHostDmaR : public event {
uint64_t size;
EHostDmaR(uint64_t ts_, uint64_t id_, uint64_t addr_, uint64_t size_)
: event(ts_), id(id_), addr(addr_), size(size_)
{
: event(ts_), id(id_), addr(addr_), size(size_) {
}
virtual ~EHostDmaR() { }
virtual ~EHostDmaR() {
}
virtual void dump(std::ostream &out)
{
out << ts << ": H.DMAR id=" << id << " addr=" << addr << " size=" <<
size << std::endl;
virtual void dump(std::ostream &out) {
out << ts << ": H.DMAR id=" << id << " addr=" << addr << " size=" << size
<< std::endl;
}
};
......@@ -101,16 +95,15 @@ class EHostDmaW : public event {
uint64_t size;
EHostDmaW(uint64_t ts_, uint64_t id_, uint64_t addr_, uint64_t size_)
: event(ts_), id(id_), addr(addr_), size(size_)
{
: event(ts_), id(id_), addr(addr_), size(size_) {
}
virtual ~EHostDmaW() { }
virtual ~EHostDmaW() {
}
virtual void dump(std::ostream &out)
{
out << ts << ": H.DMAW id=" << id << " addr=" << addr << " size=" <<
size << std::endl;
virtual void dump(std::ostream &out) {
out << ts << ": H.DMAW id=" << id << " addr=" << addr << " size=" << size
<< std::endl;
}
};
......@@ -118,15 +111,13 @@ class EHostDmaC : public event {
public:
uint64_t id;
EHostDmaC(uint64_t ts_, uint64_t id_)
: event(ts_), id(id_)
{
EHostDmaC(uint64_t ts_, uint64_t id_) : event(ts_), id(id_) {
}
virtual ~EHostDmaC() { }
virtual ~EHostDmaC() {
}
virtual void dump(std::ostream &out)
{
virtual void dump(std::ostream &out) {
out << ts << ": H.DMAC id=" << id << std::endl;
}
};
......@@ -138,16 +129,15 @@ class EHostMmioR : public event {
uint64_t size;
EHostMmioR(uint64_t ts_, uint64_t id_, uint64_t addr_, uint64_t size_)
: event(ts_), id(id_), addr(addr_), size(size_)
{
: event(ts_), id(id_), addr(addr_), size(size_) {
}
virtual ~EHostMmioR() { }
virtual ~EHostMmioR() {
}
virtual void dump(std::ostream &out)
{
out << ts << ": H.MMIOR id=" << id << " addr=" << addr << " size=" <<
size << std::endl;
virtual void dump(std::ostream &out) {
out << ts << ": H.MMIOR id=" << id << " addr=" << addr << " size=" << size
<< std::endl;
}
};
......@@ -158,16 +148,15 @@ class EHostMmioW : public event {
uint64_t size;
EHostMmioW(uint64_t ts_, uint64_t id_, uint64_t addr_, uint64_t size_)
: event(ts_), id(id_), addr(addr_), size(size_)
{
: event(ts_), id(id_), addr(addr_), size(size_) {
}
virtual ~EHostMmioW() { }
virtual ~EHostMmioW() {
}
virtual void dump(std::ostream &out)
{
out << ts << ": H.MMIOW id=" << id << " addr=" << addr << " size=" <<
size << std::endl;
virtual void dump(std::ostream &out) {
out << ts << ": H.MMIOW id=" << id << " addr=" << addr << " size=" << size
<< std::endl;
}
};
......@@ -175,15 +164,13 @@ class EHostMmioC : public event {
public:
uint64_t id;
EHostMmioC(uint64_t ts_, uint64_t id_)
: event(ts_), id(id_)
{
EHostMmioC(uint64_t ts_, uint64_t id_) : event(ts_), id(id_) {
}
virtual ~EHostMmioC() { }
virtual ~EHostMmioC() {
}
virtual void dump(std::ostream &out)
{
virtual void dump(std::ostream &out) {
out << ts << ": H.MMIOC id=" << id << std::endl;
}
};
......@@ -192,15 +179,13 @@ class e_nic_msix : public event {
public:
uint16_t vec;
e_nic_msix(uint64_t ts_, uint16_t vec_)
: event(ts_), vec(vec_)
{
e_nic_msix(uint64_t ts_, uint16_t vec_) : event(ts_), vec(vec_) {
}
virtual ~e_nic_msix() { }
virtual ~e_nic_msix() {
}
virtual void dump(std::ostream &out)
{
virtual void dump(std::ostream &out) {
out << ts << ": N.MSIX " << vec << std::endl;
}
};
......@@ -212,16 +197,15 @@ class e_nic_dma_i : public event {
uint64_t size;
e_nic_dma_i(uint64_t ts_, uint64_t id_, uint64_t addr_, uint64_t size_)
: event(ts_), id(id_), addr(addr_), size(size_)
{
: event(ts_), id(id_), addr(addr_), size(size_) {
}
virtual ~e_nic_dma_i() { }
virtual ~e_nic_dma_i() {
}
virtual void dump(std::ostream &out)
{
out << ts << ": N.DMAI id=" << id << " addr=" << addr << " size=" <<
size << std::endl;
virtual void dump(std::ostream &out) {
out << ts << ": N.DMAI id=" << id << " addr=" << addr << " size=" << size
<< std::endl;
}
};
......@@ -229,14 +213,13 @@ class e_nic_dma_c : public event {
public:
uint64_t id;
e_nic_dma_c(uint64_t ts_, uint64_t id_)
: event(ts_), id(id_) {
e_nic_dma_c(uint64_t ts_, uint64_t id_) : event(ts_), id(id_) {
}
virtual ~e_nic_dma_c() { }
virtual ~e_nic_dma_c() {
}
virtual void dump(std::ostream &out)
{
virtual void dump(std::ostream &out) {
out << ts << ": N.DMAC id=" << id << std::endl;
}
};
......@@ -248,16 +231,15 @@ class e_nic_mmio_r : public event {
uint64_t val;
e_nic_mmio_r(uint64_t ts_, uint64_t addr_, uint64_t size_, uint64_t val_)
: event(ts_), addr(addr_), size(size_), val(val_)
{
: event(ts_), addr(addr_), size(size_), val(val_) {
}
virtual ~e_nic_mmio_r() { }
virtual ~e_nic_mmio_r() {
}
virtual void dump(std::ostream &out)
{
out << ts << ": N.MMIOR addr=" << addr << " size=" << size << " val=" <<
val << std::endl;
virtual void dump(std::ostream &out) {
out << ts << ": N.MMIOR addr=" << addr << " size=" << size << " val=" << val
<< std::endl;
}
};
......@@ -268,16 +250,15 @@ class e_nic_mmio_w : public event {
uint64_t val;
e_nic_mmio_w(uint64_t ts_, uint64_t addr_, uint64_t size_, uint64_t val_)
: event(ts_), addr(addr_), size(size_), val(val_)
{
: event(ts_), addr(addr_), size(size_), val(val_) {
}
virtual ~e_nic_mmio_w() { }
virtual ~e_nic_mmio_w() {
}
virtual void dump(std::ostream &out)
{
out << ts << ": N.MMIOW addr=" << addr << " size=" << size << " val=" <<
val << std::endl;
virtual void dump(std::ostream &out) {
out << ts << ": N.MMIOW addr=" << addr << " size=" << size << " val=" << val
<< std::endl;
}
};
......@@ -285,15 +266,13 @@ class e_nic_tx : public event {
public:
uint16_t len;
e_nic_tx(uint64_t ts_, uint16_t len_)
: event(ts_), len(len_)
{
e_nic_tx(uint64_t ts_, uint16_t len_) : event(ts_), len(len_) {
}
virtual ~e_nic_tx() { }
virtual ~e_nic_tx() {
}
virtual void dump(std::ostream &out)
{
virtual void dump(std::ostream &out) {
out << ts << ": N.TX " << len << std::endl;
}
};
......@@ -302,15 +281,13 @@ class e_nic_rx : public event {
public:
uint16_t len;
e_nic_rx(uint64_t ts_, uint16_t len_)
: event(ts_), len(len_)
{
e_nic_rx(uint64_t ts_, uint16_t len_) : event(ts_), len(len_) {
}
virtual ~e_nic_rx() { }
virtual ~e_nic_rx() {
}
virtual void dump(std::ostream &out)
{
virtual void dump(std::ostream &out) {
out << ts << ": N.RX " << len << std::endl;
}
};
trace/gem5.cc
View file @ d4666c97
......@@ -30,18 +30,14 @@
namespace bio = boost::iostreams;
gem5_parser::gem5_parser(sym_map &syms_)
: syms(syms_)
{
gem5_parser::gem5_parser(sym_map &syms_) : syms(syms_) {
}
gem5_parser::~gem5_parser()
{
gem5_parser::~gem5_parser() {
}
void gem5_parser::process_msg(uint64_t ts, char *comp_name,
size_t comp_name_len, char *msg, size_t msg_len)
{
size_t comp_name_len, char *msg, size_t msg_len) {
parser p(msg, msg_len, 0);
/*if (ts < ts_first)
......@@ -87,12 +83,10 @@ void gem5_parser::process_msg(uint64_t ts, char *comp_name,
// cosim: received DMA write id 94113551528032 addr 236972000
// size 4
cur_event = new EHostDmaW(ts, id, addr, size);
} else if (p.consume_str("read completion id ") &&
p.consume_dec(id)) {
} else if (p.consume_str("read completion id ") && p.consume_dec(id)) {
// cosim: received read completion id 94583743418112
cur_event = new EHostMmioC(ts, id);
} else if (p.consume_str("write completion id ") &&
p.consume_dec(id)) {
} else if (p.consume_str("write completion id ") && p.consume_dec(id)) {
// cosim: received write completion id 94583743418736
cur_event = new EHostMmioC(ts, id);
}
......@@ -119,9 +113,7 @@ void gem5_parser::process_msg(uint64_t ts, char *comp_name,
}*/
}
void gem5_parser::process_line(char *line, size_t line_len)
{
void gem5_parser::process_line(char *line, size_t line_len) {
size_t pos = 0;
size_t line_start = pos;
......@@ -130,7 +122,8 @@ void gem5_parser::process_line(char *line, size_t line_len)
bool valid = true;
// eat spaces
for (; pos < line_len && line[pos] == ' '; pos++) {}
for (; pos < line_len && line[pos] == ' '; pos++) {
}
// parse ts
uint64_t ts = 0;
......@@ -159,8 +152,9 @@ void gem5_parser::process_line(char *line, size_t line_len)
pos++;
comp_name_start = pos;
for (; pos < line_len && line[pos] != ' ' && line[pos] != '\n'; pos++,
comp_name_len++) {}
for (; pos < line_len && line[pos] != ' ' && line[pos] != '\n';
pos++, comp_name_len++) {
}
// skip space
if (line[pos] != ' ') {
valid = false;
......
trace/log_parser.cc
View file @ d4666c97
......@@ -22,10 +22,10 @@
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <boost/iostreams/filter/gzip.hpp>
#include <boost/iostreams/filtering_streambuf.hpp>
#include <fstream>
#include <iostream>
#include <boost/iostreams/filtering_streambuf.hpp>
#include <boost/iostreams/filter/gzip.hpp>
#include "trace/events.h"
#include "trace/parser.h"
......@@ -33,14 +33,11 @@
namespace bio = boost::iostreams;
log_parser::log_parser()
: inf(nullptr), gz_file(nullptr), gz_in(nullptr)
{
log_parser::log_parser() : inf(nullptr), gz_file(nullptr), gz_in(nullptr) {
buf = new char[block_size];
}
log_parser::~log_parser()
{
log_parser::~log_parser() {
if (inf)
delete inf;
if (gz_file) {
......@@ -50,8 +47,7 @@ log_parser::~log_parser()
delete[] buf;
}
bool log_parser::next_block()
{
bool log_parser::next_block() {
if (buf_pos == buf_len) {
buf_pos = 0;
} else {
......@@ -68,15 +64,12 @@ bool log_parser::next_block()
return newlen != 0;
}
void log_parser::open(const char *path)
{
void log_parser::open(const char *path) {
inf = new std::ifstream(path, std::ios_base::in);
}
void log_parser::open_gz(const char *path)
{
gz_file = new std::ifstream(path, std::ios_base::in |
std::ios_base::binary);
void log_parser::open_gz(const char *path) {
gz_file = new std::ifstream(path, std::ios_base::in | std::ios_base::binary);
gz_in = new bio::filtering_streambuf<bio::input>();
gz_in->push(bio::gzip_decompressor());
......@@ -85,12 +78,12 @@ void log_parser::open_gz(const char *path)
inf = new std::istream(gz_in);
}
size_t log_parser::try_line()
{
size_t log_parser::try_line() {
size_t pos = buf_pos;
size_t line_len = 0;
for (; pos < buf_len && buf[pos] != '\n'; pos++, line_len++) {}
for (; pos < buf_len && buf[pos] != '\n'; pos++, line_len++) {
}
if (pos >= buf_len) {
// line is incomplete
return 0;
......@@ -101,9 +94,7 @@ size_t log_parser::try_line()
return pos + 1;
}
bool log_parser::next_event()
{
bool log_parser::next_event() {
cur_event = nullptr;
if (buf_len == 0 && !next_block()) {
......
trace/nicbm.cc
View file @ d4666c97
......@@ -30,12 +30,10 @@
namespace bio = boost::iostreams;
nicbm_parser::~nicbm_parser()
{
nicbm_parser::~nicbm_parser() {
}
void nicbm_parser::process_line(char *line, size_t line_len)
{
void nicbm_parser::process_line(char *line, size_t line_len) {
parser p(line, line_len, 0);
uint64_t ts;
......@@ -47,40 +45,24 @@ void nicbm_parser::process_line(char *line, size_t line_len)
uint64_t id, addr, len, val;
if (p.consume_str("read(off=0x")) {
if (p.consume_hex(addr) &&
p.consume_str(", len=") &&
p.consume_dec(len) &&
p.consume_str(", val=0x") &&
p.consume_hex(val))
{
if (p.consume_hex(addr) && p.consume_str(", len=") && p.consume_dec(len) &&
p.consume_str(", val=0x") && p.consume_hex(val)) {
cur_event = new e_nic_mmio_r(ts, addr, len, val);
}
} else if (p.consume_str("write(off=0x")) {
if (p.consume_hex(addr) &&
p.consume_str(", len=") &&
p.consume_dec(len) &&
p.consume_str(", val=0x") &&
p.consume_hex(val))
{
if (p.consume_hex(addr) && p.consume_str(", len=") && p.consume_dec(len) &&
p.consume_str(", val=0x") && p.consume_hex(val)) {
cur_event = new e_nic_mmio_w(ts, addr, len, val);
}
} else if (p.consume_str("issuing dma op 0x")) {
if (p.consume_hex(id) &&
p.consume_str(" addr ") &&
p.consume_hex(addr) &&
p.consume_str(" len ") &&
p.consume_hex(len))
{
if (p.consume_hex(id) && p.consume_str(" addr ") && p.consume_hex(addr) &&
p.consume_str(" len ") && p.consume_hex(len)) {
cur_event = new e_nic_dma_i(ts, id, addr, len);
}
} else if (p.consume_str("completed dma read op 0x") ||
p.consume_str("completed dma write op 0x")) {
if (p.consume_hex(id) &&
p.consume_str(" addr ") &&
p.consume_hex(addr) &&
p.consume_str(" len ") &&
p.consume_hex(len))
{
if (p.consume_hex(id) && p.consume_str(" addr ") && p.consume_hex(addr) &&
p.consume_str(" len ") && p.consume_hex(len)) {
cur_event = new e_nic_dma_c(ts, id);
}
} else if (p.consume_str("issue MSI-X interrupt vec ")) {
......
trace/parser.h
View file @ d4666c97
......@@ -36,19 +36,17 @@ class parser {
public:
parser(const char *buf_, size_t buf_len_, size_t start_pos = 0)
: buf(buf_), buf_len(buf_len_), pos(start_pos)
{
: buf(buf_), buf_len(buf_len_), pos(start_pos) {
}
inline size_t trim_spaces()
{
inline size_t trim_spaces() {
size_t cnt = 0;
for (; pos < buf_len && buf[pos] == ' '; pos++, cnt++) {}
for (; pos < buf_len && buf[pos] == ' '; pos++, cnt++) {
}
return cnt;
}
inline bool consume_char(char c)
{
inline bool consume_char(char c) {
if (pos == buf_len || buf[pos] != c) {
return false;
}
......@@ -57,8 +55,7 @@ class parser {
return true;
}
inline bool consume_hex(uint64_t &val)
{
inline bool consume_hex(uint64_t &val) {
size_t val_len = 0;
val = 0;
for (; pos < buf_len; pos++) {
......@@ -80,8 +77,7 @@ class parser {
return val_len > 0;
}
inline bool consume_dec(uint64_t &val)
{
inline bool consume_dec(uint64_t &val) {
size_t val_len = 0;
val = 0;
for (; pos < buf_len; pos++) {
......@@ -96,8 +92,7 @@ class parser {
return val_len > 0;
}
inline bool consume_str(const char *str)
{
inline bool consume_str(const char *str) {
size_t str_len = strlen(str);
if (pos + str_len > buf_len || memcmp(buf + pos, str, str_len)) {
return false;
......@@ -107,10 +102,10 @@ class parser {
return true;
}
inline bool extract_until(char end_c, std::string &str)
{
inline bool extract_until(char end_c, std::string &str) {
size_t end = pos;
for (; end < buf_len && buf[end] != end_c; end++) {}
for (; end < buf_len && buf[end] != end_c; end++) {
}
if (end >= buf_len)
return false;
......
trace/process.cc
View file @ d4666c97
......@@ -22,20 +22,20 @@
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include "trace/process.h"
#include <iostream>
#include "trace/events.h"
#include "trace/parser.h"
#include "trace/process.h"
struct log_parser_cmp {
bool operator() (const log_parser *l, const log_parser *r) const {
bool operator()(const log_parser *l, const log_parser *r) const {
return l->cur_event->ts < r->cur_event->ts;
}
};
int main(int argc, char *argv[])
{
int main(int argc, char *argv[]) {
sym_map syms;
syms.add_filter("entry_SYSCALL_64");
syms.add_filter("__do_sys_gettimeofday");
......@@ -90,8 +90,7 @@ int main(int argc, char *argv[])
EHostCall *hc;
event *ev = p->cur_event;
if (p == &ch && (hc = dynamic_cast<EHostCall *>(ev)) &&
hc->fun == "__sys_sendto")
{
hc->fun == "__sys_sendto") {
std::cout << "---------- REQ START:" << ev->ts << std::endl;
ts_off = ev->ts;
}
......
trace/process.h
View file @ d4666c97
......@@ -24,10 +24,10 @@
#pragma once
#include <boost/iostreams/filtering_streambuf.hpp>
#include <map>
#include <set>
#include <string>
#include <boost/iostreams/filtering_streambuf.hpp>
#include "trace/events.h"
......@@ -46,8 +46,7 @@ class sym_map {
void add_filter(const std::string &sym);
void load_file(const char *path, uint64_t offset = 0);
inline const std::string *lookup(uint64_t addr)
{
inline const std::string *lookup(uint64_t addr) {
auto it = map.find(addr);
if (it == map.end())
return nullptr;
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment