#include <sys/eventfd.h>
#include <daq_dlt.h>
-#include <daq_module_api.h>
#include "daq_vpp.h"
{
daq_vpp_main_t *vdm = &daq_vpp_main;
daq_vpp_ctx_t *ctx = (daq_vpp_ctx_t *) handle;
+ uint16_t instance_id = ctx->instance_id;
+ DEBUG ("destroying instance %u", instance_id);
free (ctx->qpairs);
if (ctx->epoll_fd != -1)
close (ctx->epoll_fd);
free (vdm->bpools);
}
}
+ DEBUG ("destroyed instance %u", instance_id);
}
daq_vpp_qpair_t *
sizeof (daq_vpp_qpair_t *));
ctx->qpairs[ctx->num_qpairs++] = qp;
+ DEBUG ("qpair %u.%u added to instance %u", qp->qpair_id.thread_id,
+ qp->qpair_id.queue_id, ctx->instance_id);
return DAQ_SUCCESS;
}
strncpy (name, input_name, input_name_len);
name[input_name_len] = 0;
- rv = daq_vpp_parse_qpair_ids (ctx, end_of_name, &qpair_ids, &n_qpair_ids);
- if (rv != DAQ_SUCCESS)
- goto err;
-
if (!vdm->config_parsed)
{
rv = daq_vpp_parse_config (ctx, modcfg);
vdm->config_parsed = 1;
}
+ rv = daq_vpp_parse_qpair_ids (ctx, end_of_name, &qpair_ids, &n_qpair_ids);
+ if (rv != DAQ_SUCCESS)
+ goto err;
+
DEBUG ("creating instance %u out of %u with input %s", instance_id,
n_instances, name);
daq_vpp_get_msg_pool_info (void *handle, DAQ_MsgPoolInfo_t *info)
{
daq_vpp_ctx_t *ctx = (daq_vpp_ctx_t *) handle;
+ DEBUG ("getting msg pool info");
*info = ctx->msg_pool_info;
return DAQ_SUCCESS;
}
daq_vpp_get_stats (void __unused *handle, DAQ_Stats_t *stats)
{
daq_vpp_ctx_t *ctx = (daq_vpp_ctx_t *) handle;
+ DEBUG ("getting stats");
*stats = ctx->stats;
return DAQ_SUCCESS;
}
daq_vpp_reset_stats (void *handle)
{
daq_vpp_ctx_t *ctx = (daq_vpp_ctx_t *) handle;
+ DEBUG ("resetting stats");
ctx->stats = (DAQ_Stats_t){};
}
return DLT_IPV4;
}
+static char *
+daq_vpp_ioctl_cmd_to_str (DAQ_IoctlCmd cmd)
+{
+#define IOCTL_CMD_STR(cmd) \
+ case cmd: \
+ return #cmd;
+
+ switch (cmd)
+ {
+ IOCTL_CMD_STR (DIOCTL_GET_DEVICE_INDEX)
+ IOCTL_CMD_STR (DIOCTL_SET_FLOW_OPAQUE)
+ IOCTL_CMD_STR (DIOCTL_SET_FLOW_HA_STATE)
+ IOCTL_CMD_STR (DIOCTL_GET_FLOW_HA_STATE)
+ IOCTL_CMD_STR (DIOCTL_SET_FLOW_QOS_ID)
+ IOCTL_CMD_STR (DIOCTL_SET_PACKET_TRACE_DATA)
+ IOCTL_CMD_STR (DIOCTL_SET_PACKET_VERDICT_REASON)
+ IOCTL_CMD_STR (DIOCTL_SET_FLOW_PRESERVE)
+ IOCTL_CMD_STR (DIOCTL_GET_FLOW_TCP_SCRUBBED_SYN)
+ IOCTL_CMD_STR (DIOCTL_GET_FLOW_TCP_SCRUBBED_SYN_ACK)
+ IOCTL_CMD_STR (DIOCTL_CREATE_EXPECTED_FLOW)
+ IOCTL_CMD_STR (DIOCTL_DIRECT_INJECT_PAYLOAD)
+ IOCTL_CMD_STR (DIOCTL_DIRECT_INJECT_RESET)
+ IOCTL_CMD_STR (DIOCTL_GET_PRIV_DATA_LEN)
+ IOCTL_CMD_STR (DIOCTL_GET_CPU_PROFILE_DATA)
+ IOCTL_CMD_STR (DIOCTL_GET_SNORT_LATENCY_DATA)
+ IOCTL_CMD_STR (DIOCTL_SET_INJECT_DROP)
+ default:
+ return "UNKNOWN";
+ }
+}
+
static int
daq_vpp_ioctl (void *handle, DAQ_IoctlCmd cmd, void *arg, size_t arglen)
{
daq_vpp_ctx_t *ctx = (daq_vpp_ctx_t *) handle;
DIOCTL_QueryDeviceIndex *qdi = (DIOCTL_QueryDeviceIndex *) arg;
+ DEBUG ("ioctl cmd %s", daq_vpp_ioctl_cmd_to_str (cmd));
+
if (cmd == DIOCTL_GET_DEVICE_INDEX)
{
char name[DAQ_VPP_MAX_INST_NAME_LEN], *colon;
#include "daq.h"
#include "daq_vpp.h"
+static char *
+daq_vpp_msg_type_string (daq_vpp_msg_type_t t)
+{
+ switch (t)
+ {
+ case DAQ_VPP_MSG_TYPE_CONNECT:
+ return "CONNECT";
+ case DAQ_VPP_MSG_TYPE_GET_BUFFER_POOL:
+ return "GET_BUFFER_POOL";
+ case DAQ_VPP_MSG_TYPE_GET_INPUT:
+ return "GET_INPUT";
+ case DAQ_VPP_MSG_TYPE_ATTACH_QPAIR:
+ return "ATTACH_QPAIR";
+ default:
+ return "UNKNOWN";
+ }
+}
+
+static char *
+daq_vpp_daq_version_string (uint32_t v)
+{
+ static char buf[32];
+ if (v == 0)
+ return "unknown";
+ else
+ snprintf (buf, sizeof (buf), "%d.%d.%d", (v >> 24) & 0xff,
+ (v >> 16) & 0xff, (v >> 8) & 0xff);
+ return buf;
+}
+
+static char *
+daq_vpp_mode_string (daq_vpp_mode_t m)
+{
+ switch (m)
+ {
+ case DAQ_VPP_MODE_INLINE:
+ return "INLINE";
+ case DAQ_VPP_MODE_PASSIVE:
+ return "PASSIVE";
+ case DAQ_VPP_MODE_READ_FILE:
+ return "READ_FILE";
+ default:
+ return "UNKNOWN";
+ }
+}
+
+static char *
+daq_vpp_sendmsg_data_string (daq_vpp_msg_req_t *req, ssize_t sz)
+{
+ static char buf[256];
+ int n = 0;
+
+ n += snprintf (buf + n, sizeof (buf) - n, "{ type: %s",
+ daq_vpp_msg_type_string (req->type));
+
+ switch (req->type)
+ {
+ case DAQ_VPP_MSG_TYPE_CONNECT:
+ n += snprintf (
+ buf + n, sizeof (buf) - n,
+ ", connect: { num_snort_instances: %u, daq_version: %s, mode: %s }",
+ req->connect.num_snort_instances,
+ daq_vpp_daq_version_string (req->connect.daq_version),
+ daq_vpp_mode_string (req->connect.mode));
+ break;
+ case DAQ_VPP_MSG_TYPE_GET_BUFFER_POOL:
+ n += snprintf (buf + n, sizeof (buf) - n,
+ ", get_buffer_pool: { buffer_pool_index: %u }",
+ req->get_buffer_pool.buffer_pool_index);
+ break;
+ case DAQ_VPP_MSG_TYPE_GET_INPUT:
+ n += snprintf (buf + n, sizeof (buf) - n,
+ ", get_input: { input_name: \"%s\" }",
+ req->get_input.input_name);
+ break;
+ case DAQ_VPP_MSG_TYPE_ATTACH_QPAIR:
+ n += snprintf (buf + n, sizeof (buf) - n,
+ ", attach_qpair: { input_index: %u, qpair_index: %u }",
+ req->attach_qpair.input_index,
+ req->attach_qpair.qpair_index);
+ break;
+ default:
+ n += snprintf (buf + n, sizeof (buf) - n, ", unknown");
+ break;
+ }
+
+ n += snprintf (buf + n, sizeof (buf) - n, " }");
+
+ if (n >= sizeof (buf))
+ return "<truncated>";
+
+ return buf;
+}
+
+static char *
+daq_vpp_recvmsg_data_string (daq_vpp_msg_reply_t *reply, ssize_t sz)
+{
+ static char buf[256];
+ int n = 0;
+
+ n += snprintf (buf + n, sizeof (buf) - n, "{ err: %d", reply->err);
+
+ switch (reply->type)
+ {
+ case DAQ_VPP_MSG_TYPE_CONNECT:
+ n +=
+ snprintf (buf + n, sizeof (buf) - n, ", connect: { num_bpools: %u }",
+ reply->connect.num_bpools);
+ break;
+ case DAQ_VPP_MSG_TYPE_GET_BUFFER_POOL:
+ n += snprintf (buf + n, sizeof (buf) - n,
+ ", get_buffer_pool: { size: %lu }",
+ reply->get_buffer_pool.size);
+ break;
+ case DAQ_VPP_MSG_TYPE_GET_INPUT:
+ n += snprintf (
+ buf + n, sizeof (buf) - n,
+ ", get_input: { input_index: %u, num_qpairs: %u, shm_size: %lu }",
+ reply->get_input.input_index, reply->get_input.num_qpairs,
+ reply->get_input.shm_size);
+ break;
+ case DAQ_VPP_MSG_TYPE_ATTACH_QPAIR:
+ n += snprintf (buf + n, sizeof (buf) - n,
+ ", attach_qpair: { qpair_id: { thread_id: %u, "
+ "queue_id: %u }, log2_queue_size: %u, "
+ "qpair_header_offset: %u, enq_ring_offset: %u, "
+ "deq_ring_offset: %u }",
+ reply->attach_qpair.qpair_id.thread_id,
+ reply->attach_qpair.qpair_id.queue_id,
+ reply->attach_qpair.log2_queue_size,
+ reply->attach_qpair.qpair_header_offset,
+ reply->attach_qpair.enq_ring_offset,
+ reply->attach_qpair.deq_ring_offset);
+ break;
+ default:
+ n += snprintf (buf + n, sizeof (buf) - n, ", unknown");
+ break;
+ }
+
+ n += snprintf (buf + n, sizeof (buf) - n, " }");
+
+ if (n >= sizeof (buf))
+ return "<truncated>";
+
+ return buf;
+}
+
static daq_vpp_rv_t
daq_vpp_request (daq_vpp_msg_req_t *req, daq_vpp_msg_reply_t *reply, int n_fds,
int fds[])
struct cmsghdr *cmsg;
ssize_t rv;
+ DEBUG ("send msg: %s", daq_vpp_sendmsg_data_string (req, req_msg_sz));
if (send (vdm->socket_fd, req, req_msg_sz, 0) != req_msg_sz)
return DAQ_VPP_ERR_SOCKET;
if (rv != sizeof (daq_vpp_msg_reply_t))
return DAQ_VPP_ERR_SOCKET;
+ DEBUG ("recv msg: %s",
+ daq_vpp_recvmsg_data_string (reply, sizeof (daq_vpp_msg_reply_t)));
cmsg = CMSG_FIRSTHDR (&mh);
while (cmsg)
{
{
daq_vpp_main_t *vdm = &daq_vpp_main;
+ DEBUG ("disconnecting...");
if (vdm->bpools)
free (vdm->bpools);
if (vdm->socket_fd > -1)
{
+ DEBUG ("closing socket %s", vdm->socket_name);
close (vdm->socket_fd);
vdm->socket_fd = -1;
}
- vdm->connected = 1;
+ vdm->connected = 0;
+ DEBUG ("disconnected");
}
daq_vpp_rv_t
struct sockaddr_un sun = { .sun_family = AF_UNIX };
int fd;
+ DEBUG ("connecting to socket %s", vdm->socket_name);
+
fd = socket (AF_UNIX, SOCK_SEQPACKET, 0);
if (fd < 0)
}
vdm->socket_fd = fd;
+
+ DEBUG ("connected to socket %s", vdm->socket_name);
+
return DAQ_VPP_OK;
}
qp->qpair_id.thread_id, qp->qpair_id.queue_id);
goto err;
}
-
- DEBUG ("qpair %u.%u added, size %u", qp->qpair_id.thread_id,
- qp->qpair_id.queue_id, qp->queue_size);
+ DEBUG ("input %s qpair %u.%u: size %u, hdr %p, enq %p, deq %p", name,
+ qp->qpair_id.thread_id, qp->qpair_id.queue_id, qp->queue_size,
+ qp->hdr, qp->enq_ring, qp->deq_ring);
}
vdm->inputs =
Code Review / vpp.git / commitdiff