Status_t
sm_jm_alloc_job(JmEntry_t **job)
{
Status_t s;
JmEntry_t *j;
s = vs_lock(&smJobTable.lock);
if (s != VSTATUS_OK) {
IB_LOG_ERROR_FMT(__func__,
"Failed to take job table lock (status %d)", s);
return s;
}
s = vs_pool_alloc(&sm_pool, sizeof(JmEntry_t), (void *)&j);
if (s != VSTATUS_OK) {
(void)vs_unlock(&smJobTable.lock);
IB_LOG_ERROR_FMT(__func__,
"Failed to allocate job entry (status %d)", s);
return s;
}
(void)vs_unlock(&smJobTable.lock);
memset(j, 0, sizeof(*j));
*job = j;
return VSTATUS_OK;
}
Status_t
sa_cntxt_data( sa_cntxt_t* sa_cntxt, void* buf, uint32_t len )
{
Status_t status ;
IB_ENTER( "sa_cntxt_data", sa_cntxt, buf, len, 0 );
status = VSTATUS_OK ;
if (!buf || !len) {
sa_cntxt->data = NULL;
sa_cntxt->len = 0;
sa_cntxt->freeDataFunc = NULL;
goto done;
}
status = vs_pool_alloc(&sm_pool, len, (void*)&sa_cntxt->data);
if (status == VSTATUS_OK) {
sa_cntxt->len = len;
memcpy(sa_cntxt->data, buf, len);
sa_cntxt->freeDataFunc = sa_cntxt_free_data;
} else {
sa_cntxt->len = 0;
sa_cntxt->data = NULL; /* If data is NULL, sa_send_reply will send error response to caller */
sa_cntxt->freeDataFunc = NULL;
}
done:
IB_EXIT("sa_cntxt_data", status);
return status ;
}
Status_t
sm_routing_alloc_cost_matrix(Topology_t *topop)
{
Status_t status;
size_t bytesCost;
/* Allocate space for the cost array. */
bytesCost = topop->max_sws * topop->max_sws * sizeof(uint16_t);
if (bytesCost > topop->bytes) {
topop->bytes = 0;
if (topop->cost != NULL) {
(void)vs_pool_free(&sm_pool, (void *)topop->cost);
topop->cost = NULL;
}
status = vs_pool_alloc(&sm_pool, bytesCost, (void *)&topop->cost);
if (status != VSTATUS_OK) {
IB_LOG_ERRORRC("can't malloc cost array rc:", status);
IB_EXIT(__func__, status);
return status;
}
topop->bytes = bytesCost;
}
return VSTATUS_OK;
}
Status_t
sm_jm_get_cost
( Topology_t *topop
, JmEntry_t *job
, uint16_t **outCost
, int *outLen
)
{
Status_t s;
uint16_t *cost;
int len;
int pos = 0;
uint16_t js1, js2; // job switch indicies
uint16_t ts1, ts2; // topology switch indices
// don't allocate for the case of 1 switch
if (job->switchCount <= 1) {
*outCost = NULL;
*outLen = 0;
return VSTATUS_OK;
}
// allocate space for triangular matrix minus the diagonal, so:
// 1 + 2 + ... + (n - 1) ==> n * (n - 1) / 2
len = job->switchCount * (job->switchCount - 1) / 2;
s = vs_pool_alloc(&sm_pool, len * sizeof(uint16_t), (void *)&cost);
if (s != VSTATUS_OK) {
IB_LOG_ERROR_FMT(__func__,
"Failed to allocate space for cost matrix (status %d)", s);
return VSTATUS_BAD;
}
// encode all <src,dst> pairs where src < dst (upper-right triangle)
for (js1 = 0; js1 < job->switchCount; ++js1) {
ts1 = job->jobSwToTopoSwMap[js1];
if (ts1 == 0xffff) {
memset(cost + pos, 0xff, (job->switchCount - js1 - 1) * sizeof(uint16_t));
pos += job->switchCount - js1 - 1;
continue;
}
for (js2 = js1 + 1; js2 < job->switchCount; ++js2) {
ts2 = job->jobSwToTopoSwMap[js2];
if (ts2 == 0xffff)
cost[pos++] = 0xffff;
else
cost[pos++] = topop->cost[Index(ts1, ts2)];
}
}
*outCost = cost;
*outLen = len;
return VSTATUS_OK;
}
void*
getFeXmlParserMemory(uint32_t size, char* info) {
void *address;
Status_t status;
#ifdef XML_MEMORY
printf("called getFeXmlParserMemory() size (%u) (%s) from fe_main.c\n", size, info);
#endif
status = vs_pool_alloc(&fe_xml_pool, size, (void*)&address);
if (status != VSTATUS_OK || !address)
return NULL;
return address;
}
int bitset_init(Pool_t* pool, bitset_t *bitset, size_t nbits) {
Status_t status;
bitset->pool_m = pool;
bitset->bits_m = NULL;
bitset->nset_m = 0;
bitset->nbits_m = nbits;
bitset->nwords_m = (nbits/32);
if (nbits%32) {
bitset->nwords_m++;
}
status = vs_pool_alloc(pool, sizeof(uint32_t)*bitset->nwords_m, (void *)&bitset->bits_m);
if (status != VSTATUS_OK) {
IB_LOG_ERRORRC("can't allocate space for bitset, rc:", status);
memset(bitset, 0, sizeof(bitset_t));
return 0;
}
memset(bitset->bits_m, 0, sizeof(uint32_t)*bitset->nwords_m);
return 1;
}
Status_t
sm_routing_makeModule(const char * name, RoutingModule_t ** module)
{
cl_map_item_t * it;
*module = NULL;
if (name == NULL || strlen(name) == 0)
return VSTATUS_ILLPARM;
if ((it = cl_qmap_get(&moduleFacMap, UGLY_CHAR_U64(name))) == cl_qmap_end(&moduleFacMap))
return VSTATUS_BAD;
routing_mod_factory fac = cl_qmap_obj((const cl_map_obj_t * const) it);
Status_t s;
if ((s = vs_pool_alloc(&sm_pool, sizeof(RoutingModule_t), (void*)module)) != VSTATUS_OK) {
return s;
}
memset(*module, 0, sizeof(RoutingModule_t));
return fac(*module);
}
Status_t
sm_routing_addModuleFac(const char * name, routing_mod_factory fac)
{
Status_t s;
cl_map_obj_t * wrp = NULL;
if (name == NULL || strlen(name) == 0 || fac == NULL)
return VSTATUS_ILLPARM;
if (cl_qmap_get(&moduleFacMap, UGLY_CHAR_U64(name)) != cl_qmap_end(&moduleFacMap))
return VSTATUS_BAD;
if ((s = vs_pool_alloc(&sm_pool, sizeof(cl_map_obj_t), (void*)&wrp)) != VSTATUS_OK)
return s;
memset(wrp, 0, sizeof(*wrp));
wrp->p_object = fac;
if (cl_qmap_insert(&moduleFacMap, UGLY_CHAR_U64(name), &wrp->item) == NULL)
return VSTATUS_BAD;
return VSTATUS_OK;
}
int
sa_main(void) {
Status_t status;
int i;
IB_ENTER("sa_main", 0, 0, 0, 0);
if (sa_SubscriberInit() != VSTATUS_OK) {
IB_FATAL_ERROR("sa_main: Can't allocate Subscriber hash table");
return 1;
}
if (sa_ServiceRecInit() != VSTATUS_OK) {
IB_FATAL_ERROR("sa_main: Can't allocate Service Record hash table");
return 1;
}
//
// Zero context hash table
//
memset( sa_hash, 0, sizeof( sa_hash ));
sa_cntxt_pool = NULL;
IB_LOG_VERBOSE("sa_main: Allocating SA context pool with num entries=", sa_max_cntxt);
status = vs_pool_alloc(&sm_pool, sizeof(sa_cntxt_t) * sa_max_cntxt, (void *)&sa_cntxt_pool);
if (status != VSTATUS_OK) {
IB_FATAL_ERROR("sa_main: Can't allocate SA context pool");
return 2;
}
memset( sa_cntxt_pool, 0, sizeof( sa_cntxt_t ) * sa_max_cntxt);
sa_cntxt_free_list = NULL ;
for( i = 0 ; i < sa_max_cntxt ; ++i ) {
sa_cntxt_insert_head( sa_cntxt_free_list, &sa_cntxt_pool[i] );
}
sa_cntxt_nfree = sa_max_cntxt;
sa_cntxt_nalloc = 0;
// initialize SA context lock
status = vs_lock_init(&sa_cntxt_lock, VLOCK_FREE, VLOCK_THREAD);
if (status != VSTATUS_OK) {
IB_LOG_ERRORRC("sa_main: can't initialize SA context pool lock rc:", status);
return 3;
}
//
// Allocate the SA storage pool.
//
status = vs_pool_alloc(&sm_pool, sa_data_length, (void*)&sa_data);
if (status != VSTATUS_OK) {
IB_FATAL_ERROR("sa_main: can't allocate sa data");
return 4;
}
//
// Fill in my ClassPortInfo_t and add it to the database.
//
(void)memset((void *)&saClassPortInfo, 0, sizeof(STL_CLASS_PORT_INFO));
saClassPortInfo.BaseVersion = STL_BASE_VERSION; //MAD_BVERSION;
saClassPortInfo.ClassVersion = STL_SA_CLASS_VERSION; //SA_MAD_CVERSION;
saClassPortInfo.CapMask =
STL_CLASS_PORT_CAPMASK_CM2 |
STL_SA_CAPABILITY_MULTICAST_SUPPORT |
STL_SA_CAPABILITY_PORTINFO_CAPMASK_MATCH |
STL_SA_CAPABILITY_PA_SERVICES_SUPPORT;
saClassPortInfo.u1.s.CapMask2 =
STL_SA_CAPABILITY2_QOS_SUPPORT |
STL_SA_CAPABILITY2_MFTTOP_SUPPORT |
STL_SA_CAPABILITY2_FULL_PORTINFO |
STL_SA_CAPABILITY2_EXT_SUPPORT;
saClassPortInfo.u1.s.RespTimeValue = sm_config.sa_resp_time_n2;
saClassPortInfo.u3.s.RedirectQP = 1;
saClassPortInfo.u5.s.TrapHopLimit = 0xff;
saClassPortInfo.u5.s.TrapQP = 1;
//
// Init Sa Groups table and Set up the default Multicast group if one is set.
//
status = sa_McGroupInit();
if (status != VSTATUS_OK) {
IB_FATAL_ERROR("sa_main: can't initialize SA McMember/Groups table lock");
return 5;
}
sa_SetDefBcGrp();
//
// Init SA caching
//
status = sa_cache_init();
if (status != VSTATUS_OK) {
IB_FATAL_ERROR("sa_main: can't initialize SA caching");
return 6;
}
return 0;
}
// outCount wil be set to the number of ports actually found and valid in the
// topology
//
Status_t
sm_jm_fill_ports
( Topology_t *topop
, JmMsgReqCreate_t *input
, JmEntry_t *job
, uint16_t *outCount
)
{
Status_t s;
int i;
Node_t *nodep;
Port_t *portp;
int count = 0, nextIdx = 0;
uint16_t *topoSwToJobSwMap;
s = vs_pool_alloc(&sm_pool, input->guids.count * sizeof(JmPort_t),
(void *)&job->ports);
if (s != VSTATUS_OK) {
IB_LOG_ERROR_FMT(__func__,
"Failed to allocate space for PortGuid list (status %d)", s);
goto fail1;
}
s = vs_pool_alloc(&sm_pool, input->guids.count * sizeof(uint16_t),
(void *)&job->jobSwToTopoSwMap);
if (s != VSTATUS_OK) {
IB_LOG_ERROR_FMT(__func__,
"Failed to allocate space for switch translation map (status %d)", s);
goto fail2;
}
s = vs_pool_alloc(&sm_pool, topop->max_sws * sizeof(uint16_t),
(void *)&topoSwToJobSwMap);
if (s != VSTATUS_OK) {
IB_LOG_ERROR_FMT(__func__,
"Failed to allocate space for switch translation map (status %d)", s);
goto fail3;
}
memset(topoSwToJobSwMap, 0xff, topop->max_sws * sizeof(uint16_t));
// for each portguid: find the port/switch in the topology
for (i = 0; i < input->guids.count; ++i) {
job->ports[i].guid = input->guids.entries[i];
portp = sm_find_port_guid(topop, input->guids.entries[i]);
if ( !sm_valid_port(portp)
|| portp->state < IB_PORT_INIT
|| portp->portData->nodePtr->nodeInfo.NodeType == NI_TYPE_SWITCH) {
// port not found; clear port in job
job->ports[i].portp = NULL;
job->ports[i].jobSwIdx = 0xffff;
} else {
// port found; find neighbor switch
job->ports[i].portp = portp;
nodep = sm_find_node(topop, portp->nodeno);
if (nodep == NULL) {
// switch not found; clear port in job
job->ports[i].jobSwIdx = 0xffff;
} else {
// switch found; determine job-specific switch index
if (topoSwToJobSwMap[nodep->swIdx] != 0xffff) {
// index already created; use it
job->ports[i].jobSwIdx = topoSwToJobSwMap[nodep->swIdx];
} else {
// index not created; use next available
job->ports[i].jobSwIdx = topoSwToJobSwMap[nodep->swIdx] = nextIdx;
job->jobSwToTopoSwMap[nextIdx] = nodep->swIdx;
++nextIdx;
}
++count;
}
}
}
(void)vs_pool_free(&sm_pool, topoSwToJobSwMap);
job->portCount = input->guids.count;
job->switchCount = nextIdx;
*outCount = count;
return VSTATUS_OK;
fail3:
(void)vs_pool_free(&sm_pool, job->jobSwToTopoSwMap);
fail2:
(void)vs_pool_free(&sm_pool, job->ports);
fail1:
return VSTATUS_BAD;
}
//
// This uses log level INFINI_INFO and should probably only
// be called under debug mode.
//
void bitset_info_log(bitset_t* bitset, char* prelude) {
char* string = NULL;
int first = 1;
int range = 0;
int range_start = -1;
int prev = -1;
int bit = -1;
size_t max_str_len = bitset->nset_m*5+1;
size_t pos = 0;
int res = 0;
Status_t status;
if (!bitset) return;
if (bitset->bits_m == NULL) {
IB_LOG_INFINI_INFO_FMT( __func__, "NOBITS");
return;
}
if (bitset->nset_m == 0) {
if (prelude) {
IB_LOG_INFINI_INFO_FMT(__func__, "%s <nil>", prelude);
} else {
IB_LOG_INFINI_INFO_FMT(__func__, "<nil>");
}
return;
} else if (!bitset->pool_m || (bitset->nset_m>500)) {
if (prelude) {
IB_LOG_INFINI_INFO_FMT(__func__, "%s, nset= %d", prelude, (int)bitset->nset_m);
} else {
IB_LOG_INFINI_INFO_FMT(__func__, "nset= %d", (int)bitset->nset_m);
}
return;
}
status = vs_pool_alloc(bitset->pool_m, max_str_len, (void *)&string);
if (status != VSTATUS_OK) {
if (prelude) {
IB_LOG_INFINI_INFO_FMT(__func__, "%s, nset= %d", prelude, (int)bitset->nset_m);
} else {
IB_LOG_INFINI_INFO_FMT(__func__, "nset= %d", (int)bitset->nset_m);
}
return;
}
string[0] = '\0';
bit = bitset_find_first_one(bitset);
while (bit != -1) {
if (first) {
res = snprintf(string + pos, max_str_len - pos, "%d", bit);
if (res > 0){
pos += res;
} else {
if (res == 0)
break;
else
goto bail;
}
first = 0;
} else {
if (range && (prev != bit-1)) {
range = 0;
if ((prev - range_start) > 1) {
res = snprintf(string + pos, max_str_len - pos, "-%d,%d", prev, bit);
} else {
res = snprintf(string + pos, max_str_len - pos, ",%d,%d", prev, bit);
}
if (res > 0){
pos += res;
} else {
if (res == 0)
break;
else
goto bail;
}
prev = -1;
range_start = -1;
} else if (!range && (prev == bit-1)) {
range_start = prev;
range = 1;
} else if (!range) {
res = snprintf(string + pos, max_str_len - pos, ",%d", bit);
if (res > 0){
pos += res;
} else {
if (res == 0)
break;
else
goto bail;
}
}
}
prev = bit;
bit = bitset_find_next_one(bitset, bit+1);
}
if (range && (prev != -1)) {
if ((prev - range_start) > 1) {
res = snprintf(string + pos, max_str_len - pos, "-%d", prev);
} else {
res = snprintf(string + pos, max_str_len - pos, ",%d", prev);
}
if (res > 0){
pos += res;
}
}
bail:
if (prelude) {
IB_LOG_INFINI_INFO_FMT(__func__, "%s %s", prelude, string);
} else {
IB_LOG_INFINI_INFO_FMT(__func__, "%s", string);
}
if ((status = vs_pool_free(bitset->pool_m, string)) != VSTATUS_OK) {
IB_LOG_ERRORRC("can't free allocated space for bitset log, rc:", status);
}
}
