int odp_pktio_send(odp_pktio_t id, odp_packet_t pkt_table[], unsigned len)
{
pktio_entry_t *pktio_entry = get_entry(id);
int pkts;
if (pktio_entry == NULL)
return -1;
lock_entry(pktio_entry);
switch (pktio_entry->s.params.type) {
case ODP_PKTIO_TYPE_SOCKET_BASIC:
pkts = send_pkt_sock_basic(&pktio_entry->s.pkt_sock,
pkt_table, len);
break;
case ODP_PKTIO_TYPE_SOCKET_MMSG:
pkts = send_pkt_sock_mmsg(&pktio_entry->s.pkt_sock,
pkt_table, len);
break;
case ODP_PKTIO_TYPE_SOCKET_MMAP:
pkts = send_pkt_sock_mmap(&pktio_entry->s.pkt_sock_mmap,
pkt_table, len);
break;
#ifdef ODP_HAVE_NETMAP
case ODP_PKTIO_TYPE_NETMAP:
pkts = send_pkt_netmap(&pktio_entry->s.pkt_nm,
pkt_table, len);
break;
#endif
default:
pkts = -1;
}
unlock_entry(pktio_entry);
return pkts;
}
odp_pktio_t odp_pktio_lookup(const char *dev)
{
odp_pktio_t id = ODP_PKTIO_INVALID;
pktio_entry_t *entry;
int i;
odp_spinlock_lock(&pktio_tbl->lock);
for (i = 1; i <= ODP_CONFIG_PKTIO_ENTRIES; ++i) {
entry = get_pktio_entry(_odp_cast_scalar(odp_pktio_t, i));
if (!entry || is_free(entry))
continue;
lock_entry(entry);
if (!is_free(entry) &&
strncmp(entry->s.name, dev, IF_NAMESIZE) == 0)
id = _odp_cast_scalar(odp_pktio_t, i);
unlock_entry(entry);
if (id != ODP_PKTIO_INVALID)
break;
}
odp_spinlock_unlock(&pktio_tbl->lock);
return id;
}
odp_pktio_t odp_pktio_open(const char *dev, odp_buffer_pool_t pool,
odp_pktio_params_t *params)
{
odp_pktio_t id;
pktio_entry_t *pktio_entry;
char name[ODP_QUEUE_NAME_LEN];
queue_entry_t *queue_entry;
odp_queue_t qid = ODP_QUEUE_INVALID;
if (params == NULL) {
ODP_ERR("Invalid pktio params\n");
return ODP_PKTIO_INVALID;
}
ODP_DBG("Allocating HW pktio\n");
id = alloc_lock_pktio_entry(params);
if (id == ODP_PKTIO_INVALID) {
ODP_ERR("No resources available.\n");
return ODP_PKTIO_INVALID;
}
/* if successful, alloc_pktio_entry() returns with the entry locked */
pktio_entry = get_entry(id);
/* Create a default output queue for each pktio resource */
snprintf(name, sizeof(name), "%i-pktio_outq_default", (int)id);
name[ODP_QUEUE_NAME_LEN-1] = '\0';
pktio_entry->s.dev = _odp_pktio_dev_lookup(dev);
if (!pktio_entry->s.dev) {
free_pktio_entry(id);
id = ODP_PKTIO_INVALID;
goto unlock;
}
qid = _odp_queue_create(name, ODP_QUEUE_TYPE_PKTOUT, NULL,
pktio_entry->s.dev->tx_hw_queue);
ODP_DBG("Created queue %u for hw queue %d\n", (uint32_t)qid,
pktio_entry->s.dev->tx_hw_queue);
if (qid == ODP_QUEUE_INVALID) {
free_pktio_entry(id);
id = ODP_PKTIO_INVALID;
goto unlock;
}
pktio_entry->s.in_pool = pool;
pktio_entry->s.outq_default = qid;
queue_entry = queue_to_qentry(qid);
queue_entry->s.pktout = id;
queue_entry->s.out_port_id = pktio_entry->s.dev->port_id;
unlock:
unlock_entry(pktio_entry);
return id;
}
void ts_onreply(struct cell* t, int type, struct tmcb_params *param)
{
ts_urecord_t* _r;
ts_entry_t* _e;
ts_transaction_t *cb_ptr, *ptr;
if(t_table==0) return;
if((type & (TMCB_DESTROY)) && destroy_modules_phase()) return;
cb_ptr = (ts_transaction_t*)(*param->param);
if (cb_ptr == NULL) {
LM_DBG("NULL param for type %d\n", type);
return;
}
if (type &(TMCB_DESTROY)) {
LM_DBG("TMCB_DESTROY called for transaction %u:%u\n", cb_ptr->tindex, cb_ptr->tlabel);
_r = cb_ptr->urecord;
_e = _r->entry;
lock_entry(_e);
ptr = _r->transactions;
while(ptr) {
if ((ptr->tindex == cb_ptr->tindex) && (ptr->tlabel == cb_ptr->tlabel)) {
remove_ts_transaction(ptr);
if (_r->transactions == NULL) {
LM_DBG("last transaction for %.*s, removing urecord\n", _r->ruri.len, _r->ruri.s);
remove_ts_urecord(_r);
}
unlock_entry(_e);
return;
}
ptr = ptr->next;
}
LM_DBG("transaction %u:%u not found\n",cb_ptr->tindex, cb_ptr->tlabel);
unlock_entry(_e);
} else {
LM_DBG("called with uknown type %d\n", type);
}
return;
}
int odp_pktio_send(odp_pktio_t id, odp_packet_t pkt_table[], int len)
{
pktio_entry_t *pktio_entry = get_pktio_entry(id);
int pkts;
if (pktio_entry == NULL)
return -1;
lock_entry(pktio_entry);
pkts = pktio_entry->s.ops->send(pktio_entry, pkt_table, len);
unlock_entry(pktio_entry);
return pkts;
}
int odp_pktio_recv(odp_pktio_t id, odp_packet_t pkt_table[], unsigned len)
{
pktio_entry_t *pktio_entry = get_entry(id);
unsigned pkts = 0;
odp_buffer_t buf;
if (pktio_entry == NULL)
return -1;
lock_entry(pktio_entry);
if (pktio_entry->s.inq_default == ODP_QUEUE_INVALID) {
char name[ODP_QUEUE_NAME_LEN];
odp_queue_param_t qparam;
odp_queue_t inq_def;
/*
* Create a default input queue.
* FIXME: IT is a kind of WA for current ODP API usage.
* It should be revised.
*/
ODP_DBG("Creating default input queue\n");
qparam.sched.prio = ODP_SCHED_PRIO_DEFAULT;
qparam.sched.sync = ODP_SCHED_SYNC_NONE;
qparam.sched.group = ODP_SCHED_GROUP_DEFAULT;
snprintf(name, sizeof(name), "%i-pktio_inq_default", (int)id);
name[ODP_QUEUE_NAME_LEN-1] = '\0';
inq_def = odp_queue_create(name, ODP_QUEUE_TYPE_PKTIN, &qparam);
if (inq_def == ODP_QUEUE_INVALID) {
ODP_ERR("pktio queue creation failed\n");
goto unlock;
}
if (odp_pktio_inq_setdef(id, inq_def)) {
ODP_ERR("default input-Q setup\n");
goto unlock;
}
}
for (pkts = 0; pkts < len; pkts++) {
buf = odp_queue_deq(pktio_entry->s.inq_default);
if (!odp_buffer_is_valid(buf))
break;
pkt_table[pkts] = odp_packet_from_buffer(buf);
}
unlock:
unlock_entry(pktio_entry);
return pkts;
}
int pr_scoreboard_del_entry(unsigned char verbose) {
if (scoreboard_fd < 0) {
errno = EINVAL;
return -1;
}
memset(&entry, '\0', sizeof(entry));
/* Write-lock this entry */
wlock_entry();
if (write_entry() < 0 && verbose)
pr_log_pri(PR_LOG_NOTICE, "error deleting scoreboard entry: %s",
strerror(errno));
unlock_entry();
return 0;
}
int odp_pktio_inq_setdef(odp_pktio_t id, odp_queue_t queue)
{
pktio_entry_t *pktio_entry = get_pktio_entry(id);
queue_entry_t *qentry;
if (pktio_entry == NULL || queue == ODP_QUEUE_INVALID)
return -1;
qentry = queue_to_qentry(queue);
if (qentry->s.type != ODP_QUEUE_TYPE_PKTIN)
return -1;
lock_entry(pktio_entry);
pktio_entry->s.inq_default = queue;
unlock_entry(pktio_entry);
switch (qentry->s.type) {
/* Change to ODP_QUEUE_TYPE_POLL when ODP_QUEUE_TYPE_PKTIN is removed */
case ODP_QUEUE_TYPE_PKTIN:
/* User polls the input queue */
queue_lock(qentry);
qentry->s.pktin = id;
queue_unlock(qentry);
/* Uncomment when ODP_QUEUE_TYPE_PKTIN is removed
break;
case ODP_QUEUE_TYPE_SCHED:
*/
/* Packet input through the scheduler */
if (schedule_pktio_start(id, ODP_SCHED_PRIO_LOWEST)) {
ODP_ERR("Schedule pktio start failed\n");
return -1;
}
break;
default:
ODP_ABORT("Bad queue type\n");
}
return 0;
}
int odp_pktio_send(odp_pktio_t id, odp_packet_t pkt_table[], unsigned len)
{
pktio_entry_t *pktio_entry = get_entry(id);
unsigned pkts;
int ret;
if (pktio_entry == NULL)
return -1;
lock_entry(pktio_entry);
for (pkts = 0; pkts < len; pkts++) {
ret = odp_queue_enq(pktio_entry->s.outq_default,
odp_buffer_from_packet(pkt_table[pkts]));
if (ret)
break;
}
unlock_entry(pktio_entry);
return pkts;
}
static odp_pktio_t alloc_lock_pktio_entry(odp_pktio_params_t *params)
{
odp_pktio_t id;
pktio_entry_t *entry;
int i;
for (i = 0; i < ODP_CONFIG_PKTIO_ENTRIES; ++i) {
entry = &pktio_tbl->entries[i];
if (is_free(entry)) {
lock_entry(entry);
if (is_free(entry)) {
init_pktio_entry(entry, params);
id = i + 1;
return id; /* return with entry locked! */
}
unlock_entry(entry);
}
}
return ODP_PKTIO_INVALID;
}
int odp_pktio_close(odp_pktio_t id)
{
pktio_entry_t *entry;
int res = -1;
entry = get_pktio_entry(id);
if (entry == NULL)
return -1;
lock_entry(entry);
if (!is_free(entry)) {
res = entry->s.ops->close(entry);
res |= free_pktio_entry(id);
}
unlock_entry(entry);
if (res != 0)
return -1;
return 0;
}
int odp_pktio_close(odp_pktio_t id)
{
pktio_entry_t *entry;
int res = -1;
entry = get_entry(id);
if (entry == NULL)
return -1;
lock_entry(entry);
if (!is_free(entry)) {
/* FIXME: Here rx/tx channels should be closed */
res |= free_pktio_entry(id);
}
unlock_entry(entry);
if (res != 0)
return -1;
return 0;
}
int odp_pktio_inq_remdef(odp_pktio_t id)
{
pktio_entry_t *pktio_entry = get_pktio_entry(id);
odp_queue_t queue;
queue_entry_t *qentry;
if (pktio_entry == NULL)
return -1;
lock_entry(pktio_entry);
queue = pktio_entry->s.inq_default;
qentry = queue_to_qentry(queue);
queue_lock(qentry);
qentry->s.pktin = ODP_PKTIO_INVALID;
queue_unlock(qentry);
pktio_entry->s.inq_default = ODP_QUEUE_INVALID;
unlock_entry(pktio_entry);
return 0;
}
static odp_pktio_t alloc_lock_pktio_entry(odp_pktio_params_t *params)
{
odp_pktio_t id;
pktio_entry_t *entry;
int i;
(void)params;
for (i = 0; i < ODP_CONFIG_PKTIO_ENTRIES; ++i) {
entry = &pktio_tbl->entries[i];
if (is_free(entry)) {
lock_entry(entry);
if (is_free(entry)) {
set_taken(entry);
entry->s.inq_default = ODP_QUEUE_INVALID;
entry->s.outq_default = ODP_QUEUE_INVALID;
id = i + 1;
return id; /* return with entry locked! */
}
unlock_entry(entry);
}
}
return ODP_PKTIO_INVALID;
}
int odp_pktio_close(odp_pktio_t id)
{
pktio_entry_t *entry;
int res = -1;
entry = get_entry(id);
if (entry == NULL)
return -1;
lock_entry(entry);
if (!is_free(entry)) {
switch (entry->s.params.type) {
case ODP_PKTIO_TYPE_SOCKET_BASIC:
case ODP_PKTIO_TYPE_SOCKET_MMSG:
res = close_pkt_sock(&entry->s.pkt_sock);
break;
case ODP_PKTIO_TYPE_SOCKET_MMAP:
res = close_pkt_sock_mmap(&entry->s.pkt_sock_mmap);
break;
#ifdef ODP_HAVE_NETMAP
case ODP_PKTIO_TYPE_NETMAP:
res = close_pkt_netmap(&entry->s.pkt_nm);
break;
#endif
default:
break;
res |= free_pktio_entry(id);
}
}
unlock_entry(entry);
if (res != 0)
return -1;
return 0;
}
int odp_pktio_inq_setdef(odp_pktio_t id, odp_queue_t queue)
{
pktio_entry_t *pktio_entry = get_entry(id);
queue_entry_t *qentry = queue_to_qentry(queue);
if (pktio_entry == NULL || qentry == NULL)
return -1;
if (qentry->s.type != ODP_QUEUE_TYPE_PKTIN)
return -1;
lock_entry(pktio_entry);
pktio_entry->s.inq_default = queue;
unlock_entry(pktio_entry);
queue_lock(qentry);
qentry->s.pktin = id;
qentry->s.status = QUEUE_STATUS_SCHED;
queue_unlock(qentry);
odp_schedule_queue(queue, qentry->s.param.sched.prio);
return 0;
}
/*!
* \brief Dump the content of the tsilo table
* \param rpc RPC node that should be filled
* \param c RPC void pointer
*/
static void rpc_tsilo_dump(rpc_t *rpc, void *c)
{
ts_transaction_t* trans;
struct ts_urecord* record;
struct ts_entry* entry;
str brief = {0, 0};
int max, res, n, ntrans, i;
int short_dump = 0;
void* th;
void* ah;
void* ih;
void* sh;
rpc->scan(c, "*S", &brief);
if(brief.len==5 && (strncmp(brief.s, "brief", 5)==0))
/* short version */
short_dump = 1;
if (rpc->add(c, "{", &th) < 0)
{
rpc->fault(c, 500, "Internal error creating top rpc");
return;
}
if (short_dump==0) {
res = rpc->struct_add(th, "d{",
"Size", t_table->size,
"R-URIs", &ah);
} else {
res = rpc->struct_add(th, "d",
"Size", t_table->size);
}
if (res<0)
{
rpc->fault(c, 500, "Internal error creating inner struct");
return;
}
/* add the entries per hash */
for(i=0,n=0,max=0,ntrans=0; i<t_table->size; i++) {
entry = &t_table->entries[i];
lock_entry(entry);
n += entry->n;
if(max<entry->n)
max= entry->n;
for( record = entry->first ; record ; record=record->next ) {
/* add entry */
if(short_dump==0)
{
if(rpc->struct_add(ah, "Sd{",
"R-URI", &record->ruri,
"Hash", record->rurihash,
"Transactions", &ih)<0)
{
unlock_entry(entry);
rpc->fault(c, 500, "Internal error creating ruri struct");
return;
}
}
for( trans=record->transactions ; trans ; trans=trans->next) {
ntrans += 1;
if (short_dump==0) {
if (rpc_dump_transaction(rpc, c, ih, trans) == -1) {
unlock_entry(entry);
return;
}
}
}
}
unlock_entry(entry);
}
/* extra attributes node */
if(rpc->struct_add(th, "{", "Stats", &sh)<0) {
rpc->fault(c, 500, "Internal error creating stats struct");
return;
}
if(rpc->struct_add(sh, "ddd",
"RURIs", n,
"Max-Slots", max,
"Transactions", ntrans)<0)
{
rpc->fault(c, 500, "Internal error adding stats");
return;
}
}
/* We get clever with this function, so that it can be used to update
* various entry attributes.
*/
int pr_scoreboard_update_entry(pid_t pid, ...) {
va_list ap;
char *tmp = NULL;
int entry_tag = 0;
if (scoreboard_fd < 0) {
errno = EINVAL;
return -1;
}
/* If updating some fields, clear the begin_idle field.
*/
va_start(ap, pid);
while ((entry_tag = va_arg(ap, int)) != 0) {
switch (entry_tag) {
case PR_SCORE_USER:
tmp = va_arg(ap, char *);
memset(entry.sce_user, '\0', sizeof(entry.sce_user));
sstrncpy(entry.sce_user, tmp, sizeof(entry.sce_user));
break;
case PR_SCORE_CLIENT_ADDR: {
pr_netaddr_t *remote_addr = va_arg(ap, pr_netaddr_t *);
snprintf(entry.sce_client_addr, sizeof(entry.sce_client_addr),
"%s", remote_addr ? pr_netaddr_get_ipstr(remote_addr) :
"(unknown)");
entry.sce_client_addr[sizeof(entry.sce_client_addr) - 1] = '\0';
}
break;
case PR_SCORE_CLIENT_NAME: {
char *remote_name = va_arg(ap, char *);
snprintf(entry.sce_client_name, sizeof(entry.sce_client_name),
"%s", remote_name ? remote_name : "(unknown)");
entry.sce_client_name[sizeof(entry.sce_client_name) - 1] = '\0';
}
break;
case PR_SCORE_CLASS:
tmp = va_arg(ap, char *);
memset(entry.sce_class, '\0', sizeof(entry.sce_class));
sstrncpy(entry.sce_class, tmp, sizeof(entry.sce_class));
break;
case PR_SCORE_CWD:
tmp = va_arg(ap, char *);
memset(entry.sce_cwd, '\0', sizeof(entry.sce_cwd));
sstrncpy(entry.sce_cwd, tmp, sizeof(entry.sce_cwd));
break;
case PR_SCORE_CMD: {
char *cmdstr = NULL;
tmp = va_arg(ap, char *);
cmdstr = handle_score_str(tmp, ap);
memset(entry.sce_cmd, '\0', sizeof(entry.sce_cmd));
sstrncpy(entry.sce_cmd, cmdstr, sizeof(entry.sce_cmd));
tmp = va_arg(ap, void *);
}
break;
case PR_SCORE_CMD_ARG: {
char *argstr = NULL;
tmp = va_arg(ap, char *);
argstr = handle_score_str(tmp, ap);
memset(entry.sce_cmd_arg, '\0', sizeof(entry.sce_cmd_arg));
sstrncpy(entry.sce_cmd_arg, argstr, sizeof(entry.sce_cmd_arg));
tmp = va_arg(ap, void *);
}
break;
case PR_SCORE_SERVER_PORT:
entry.sce_server_port = va_arg(ap, int);
break;
case PR_SCORE_SERVER_ADDR: {
pr_netaddr_t *server_addr = va_arg(ap, pr_netaddr_t *);
int server_port = va_arg(ap, int);
snprintf(entry.sce_server_addr, sizeof(entry.sce_server_addr),
"%s:%d", server_addr ? pr_netaddr_get_ipstr(server_addr) :
"(unknown)", server_port);
entry.sce_server_addr[sizeof(entry.sce_server_addr)-1] = '\0';
}
break;
case PR_SCORE_SERVER_LABEL:
tmp = va_arg(ap, char *);
memset(entry.sce_server_label, '\0', sizeof(entry.sce_server_label));
sstrncpy(entry.sce_server_label, tmp, sizeof(entry.sce_server_label));
break;
case PR_SCORE_BEGIN_IDLE:
/* Ignore this */
(void) va_arg(ap, time_t);
time(&entry.sce_begin_idle);
break;
case PR_SCORE_BEGIN_SESSION:
/* Ignore this */
(void) va_arg(ap, time_t);
time(&entry.sce_begin_session);
break;
case PR_SCORE_XFER_DONE:
entry.sce_xfer_done = va_arg(ap, off_t);
break;
case PR_SCORE_XFER_SIZE:
entry.sce_xfer_size = va_arg(ap, off_t);
break;
case PR_SCORE_XFER_LEN:
entry.sce_xfer_len = va_arg(ap, off_t);
break;
case PR_SCORE_XFER_ELAPSED:
entry.sce_xfer_elapsed = va_arg(ap, unsigned long);
break;
default:
errno = EINVAL;
return -1;
}
}
/* Write-lock this entry */
wlock_entry();
if (write_entry() < 0)
pr_log_pri(PR_LOG_NOTICE, "error writing scoreboard entry: %s",
strerror(errno));
unlock_entry();
return 0;
}
odp_pktio_t odp_pktio_open(const char *dev, odp_buffer_pool_t pool,
odp_pktio_params_t *params)
{
odp_pktio_t id;
pktio_entry_t *pktio_entry;
int res;
if (params == NULL) {
ODP_ERR("Invalid pktio params\n");
return ODP_PKTIO_INVALID;
}
switch (params->type) {
case ODP_PKTIO_TYPE_SOCKET_BASIC:
case ODP_PKTIO_TYPE_SOCKET_MMSG:
case ODP_PKTIO_TYPE_SOCKET_MMAP:
ODP_DBG("Allocating socket pktio\n");
break;
#ifdef ODP_HAVE_NETMAP
case ODP_PKTIO_TYPE_NETMAP:
ODP_DBG("Allocating netmap pktio\n");
break;
#endif
default:
ODP_ERR("Invalid pktio type: %02x\n", params->type);
return ODP_PKTIO_INVALID;
}
id = alloc_lock_pktio_entry(params);
if (id == ODP_PKTIO_INVALID) {
ODP_ERR("No resources available.\n");
return ODP_PKTIO_INVALID;
}
/* if successful, alloc_pktio_entry() returns with the entry locked */
pktio_entry = get_entry(id);
switch (params->type) {
case ODP_PKTIO_TYPE_SOCKET_BASIC:
case ODP_PKTIO_TYPE_SOCKET_MMSG:
res = setup_pkt_sock(&pktio_entry->s.pkt_sock, dev, pool);
if (res == -1) {
close_pkt_sock(&pktio_entry->s.pkt_sock);
free_pktio_entry(id);
id = ODP_PKTIO_INVALID;
}
break;
case ODP_PKTIO_TYPE_SOCKET_MMAP:
res = setup_pkt_sock_mmap(&pktio_entry->s.pkt_sock_mmap, dev,
pool, params->sock_params.fanout);
if (res == -1) {
close_pkt_sock_mmap(&pktio_entry->s.pkt_sock_mmap);
free_pktio_entry(id);
id = ODP_PKTIO_INVALID;
}
break;
#ifdef ODP_HAVE_NETMAP
case ODP_PKTIO_TYPE_NETMAP:
res = setup_pkt_netmap(&pktio_entry->s.pkt_nm, dev,
pool, ¶ms->nm_params);
if (res == -1) {
close_pkt_netmap(&pktio_entry->s.pkt_nm);
free_pktio_entry(id);
id = ODP_PKTIO_INVALID;
}
break;
#endif
default:
free_pktio_entry(id);
id = ODP_PKTIO_INVALID;
ODP_ERR("This type of I/O is not supported. Please recompile.\n");
break;
}
unlock_entry(pktio_entry);
return id;
}
