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; }