void osm_vendor_unbind(IN osm_bind_handle_t h_bind)
{
osmv_bind_obj_t *p_bo = (osmv_bind_obj_t *) h_bind;
osm_log_t *p_log = p_bo->p_vendor->p_log;
cl_list_obj_t *p_obj = NULL;
cl_list_item_t *p_item, *p_item_tmp;
cl_qlist_t *const p_bh_list =
(cl_qlist_t * const)&p_bo->p_vendor->bind_handles;
OSM_LOG_ENTER(p_log);
/* go over all the items in the list and remove the specific item */
p_item = cl_qlist_head(p_bh_list);
while (p_item != cl_qlist_end(p_bh_list)) {
p_obj = PARENT_STRUCT(p_item, cl_list_obj_t, list_item);
if (cl_qlist_obj(p_obj) == h_bind) {
break;
}
p_item_tmp = cl_qlist_next(p_item);
p_item = p_item_tmp;
}
CL_ASSERT(p_item != cl_qlist_end(p_bh_list));
cl_qlist_remove_item(p_bh_list, p_item);
if (p_obj)
free(p_obj);
if (h_bind != 0) {
__osm_vendor_internal_unbind(h_bind);
}
OSM_LOG_EXIT(p_log);
}
/** ===========================================================================
*/
void ssa_db_lft_handle(void)
{
struct ssa_db_lft_change_rec *p_lft_change_rec;
cl_list_item_t *p_item;
pthread_mutex_lock(&ssa_db->lft_rec_list_lock);
while ((p_item = cl_qlist_remove_head(&ssa_db->lft_rec_list)) !=
cl_qlist_end(&ssa_db->lft_rec_list)) {
p_lft_change_rec =
cl_item_obj(p_item, p_lft_change_rec, list_item);
switch (p_lft_change_rec->lft_change.flags) {
case LFT_CHANGED_BLOCK:
lft_block_handle(p_lft_change_rec);
break;
case LFT_CHANGED_LFT_TOP:
lft_top_handle(p_lft_change_rec);
break;
default:
ssa_log(SSA_LOG_ALL, "Unknown LFT change event (%d)\n",
p_lft_change_rec->lft_change.flags);
break;
}
free(p_lft_change_rec);
}
pthread_mutex_unlock(&ssa_db->lft_rec_list_lock);
}
cl_pool_item_t *cl_qcpool_get_tail(IN cl_qcpool_t * const p_pool)
{
cl_list_item_t *p_list_item;
CL_ASSERT(p_pool);
CL_ASSERT(p_pool->state == CL_INITIALIZED);
if (cl_is_qlist_empty(&p_pool->free_list)) {
/*
* No object is available.
* Return NULL if the user does not want automatic growth.
*/
if (!p_pool->grow_size)
return (NULL);
/* We ran out of elements. Get more */
cl_qcpool_grow(p_pool, p_pool->grow_size);
/*
* We may not have gotten everything we wanted but we might have
* gotten something.
*/
if (cl_is_qlist_empty(&p_pool->free_list))
return (NULL);
}
p_list_item = cl_qlist_remove_tail(&p_pool->free_list);
/* OK, at this point we have an object */
CL_ASSERT(p_list_item != cl_qlist_end(&p_pool->free_list));
return ((cl_pool_item_t *) p_list_item);
}
void osm_transaction_mgr_destroy(IN osm_vendor_t * const p_vend)
{
osm_transaction_mgr_t *trans_mgr_p;
cl_list_item_t *p_list_item;
cl_map_item_t *p_map_item;
osm_madw_req_t *osm_madw_req_p;
OSM_LOG_ENTER(p_vend->p_log);
trans_mgr_p = (osm_transaction_mgr_t *) p_vend->p_transaction_mgr;
if (p_vend->p_transaction_mgr != NULL) {
/* we need to get a lock */
cl_spinlock_acquire(&trans_mgr_p->transaction_mgr_lock);
/* go over all the items in the list and remove them */
p_list_item =
cl_qlist_remove_head(trans_mgr_p->madw_reqs_list_p);
while (p_list_item !=
cl_qlist_end(trans_mgr_p->madw_reqs_list_p)) {
osm_madw_req_p = (osm_madw_req_t *) p_list_item;
if (osm_madw_req_p->p_madw->p_mad)
osm_log(p_vend->p_log, OSM_LOG_DEBUG,
"osm_transaction_mgr_destroy: "
"Found outstanding MADW:%p TID:<0x%"
PRIx64 ">.\n", osm_madw_req_p->p_madw,
osm_madw_req_p->p_madw->p_mad->
trans_id);
else
osm_log(p_vend->p_log, OSM_LOG_DEBUG,
"osm_transaction_mgr_destroy: "
"Found outstanding MADW:%p TID:UNDEFINED.\n",
osm_madw_req_p->p_madw);
/* each item - remove it from the map */
p_map_item = &(osm_madw_req_p->map_item);
cl_qmap_remove_item(trans_mgr_p->madw_by_tid_map_p,
p_map_item);
/* free the item */
free(osm_madw_req_p);
p_list_item =
cl_qlist_remove_head(trans_mgr_p->madw_reqs_list_p);
}
/* free the qlist and qmap */
free(trans_mgr_p->madw_reqs_list_p);
free(trans_mgr_p->madw_by_tid_map_p);
/* reliease and destroy the lock */
cl_spinlock_release(&trans_mgr_p->transaction_mgr_lock);
cl_spinlock_destroy(&(trans_mgr_p->transaction_mgr_lock));
/* destroy the timer */
cl_timer_trim(&trans_mgr_p->madw_list_timer, 1);
cl_timer_destroy(&trans_mgr_p->madw_list_timer);
/* free the transaction_manager object */
free(trans_mgr_p);
trans_mgr_p = NULL;
}
OSM_LOG_EXIT(p_vend->p_log);
}
void osm_vendor_unbind(IN osm_bind_handle_t h_bind)
{
mad_bind_info_t *p_mad_bind_info;
umadt_obj_t *p_umadt_obj;
cl_list_item_t *p_list_item, *p_next_list_item;
CL_ASSERT(h_bind);
p_mad_bind_info = (mad_bind_info_t *) h_bind;
p_umadt_obj = p_mad_bind_info->p_umadt_obj;
/* sanity check */
CL_ASSERT(p_umadt_obj);
CL_ASSERT(p_umadt_obj->init_done);
CL_ASSERT(__valid_mad_handle(p_mad_bind_info));
p_umadt_obj->uMadtInterface.uMadtDestroy(&p_mad_bind_info->
umadt_handle);
cl_timer_destroy(&p_mad_bind_info->timeout_timer);
cl_thread_destroy(&p_mad_bind_info->recv_processor_thread);
cl_spinlock_acquire(&p_mad_bind_info->trans_ctxt_lock);
p_list_item = cl_qlist_head(&p_mad_bind_info->trans_ctxt_list);
while (p_list_item != cl_qlist_end(&p_mad_bind_info->trans_ctxt_list)) {
p_next_list_item = cl_qlist_next(p_list_item);
cl_qlist_remove_item(&p_mad_bind_info->trans_ctxt_list,
p_list_item);
free(p_list_item);
p_list_item = p_next_list_item;
}
cl_spinlock_release(&p_mad_bind_info->trans_ctxt_lock);
cl_spinlock_acquire(&p_mad_bind_info->timeout_list_lock);
p_list_item = cl_qlist_head(&p_mad_bind_info->timeout_list);
while (p_list_item != cl_qlist_end(&p_mad_bind_info->timeout_list)) {
p_next_list_item = cl_qlist_next(p_list_item);
cl_qlist_remove_item(&p_mad_bind_info->timeout_list,
p_list_item);
free(p_list_item);
p_list_item = p_next_list_item;
}
cl_spinlock_release(&p_mad_bind_info->timeout_list_lock);
free(p_mad_bind_info);
}
void osm_vl15_shutdown(IN osm_vl15_t * p_vl, IN osm_mad_pool_t * p_mad_pool)
{
osm_madw_t *p_madw;
OSM_LOG_ENTER(p_vl->p_log);
/* we only should get here after the VL15 interface was initialized */
CL_ASSERT(p_vl->state == OSM_VL15_STATE_READY);
/* grap a lock on the object */
cl_spinlock_acquire(&p_vl->lock);
/* go over all outstanding MADs and retire their transactions */
/* first we handle the list of response MADs */
p_madw = (osm_madw_t *) cl_qlist_remove_head(&p_vl->ufifo);
while (p_madw != (osm_madw_t *) cl_qlist_end(&p_vl->ufifo)) {
OSM_LOG(p_vl->p_log, OSM_LOG_DEBUG,
"Releasing Response p_madw = %p\n", p_madw);
osm_mad_pool_put(p_mad_pool, p_madw);
p_madw = (osm_madw_t *) cl_qlist_remove_head(&p_vl->ufifo);
}
/* Request MADs we send out */
p_madw = (osm_madw_t *) cl_qlist_remove_head(&p_vl->rfifo);
while (p_madw != (osm_madw_t *) cl_qlist_end(&p_vl->rfifo)) {
OSM_LOG(p_vl->p_log, OSM_LOG_DEBUG,
"Releasing Request p_madw = %p\n", p_madw);
osm_mad_pool_put(p_mad_pool, p_madw);
osm_stats_dec_qp0_outstanding(p_vl->p_stats);
p_madw = (osm_madw_t *) cl_qlist_remove_head(&p_vl->rfifo);
}
/* free the lock */
cl_spinlock_release(&p_vl->lock);
OSM_LOG_EXIT(p_vl->p_log);
}
void cl_event_wheel_dump(IN cl_event_wheel_t * const p_event_wheel)
{
cl_list_item_t *p_list_item;
cl_event_wheel_reg_info_t __attribute__((__unused__)) *p_event;
p_list_item = cl_qlist_head(&p_event_wheel->events_wheel);
while (p_list_item != cl_qlist_end(&p_event_wheel->events_wheel)) {
p_event =
PARENT_STRUCT(p_list_item, cl_event_wheel_reg_info_t,
list_item);
CL_DBG("cl_event_wheel_dump: Found event key:<0x%"
PRIx64 ">, num_regs:%d, aging time:%" PRIu64 "\n",
p_event->key, p_event->num_regs, p_event->aging_time);
p_list_item = cl_qlist_next(p_list_item);
}
}
static void
__osm_ucast_mgr_process_tbl(IN cl_map_item_t * const p_map_item,
IN void *context)
{
osm_ucast_mgr_t *p_mgr = context;
osm_switch_t *const p_sw = (osm_switch_t *) p_map_item;
unsigned i, lids_per_port;
OSM_LOG_ENTER(p_mgr->p_log);
CL_ASSERT(p_sw && p_sw->p_node);
OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,
"Processing switch 0x%" PRIx64 "\n",
cl_ntoh64(osm_node_get_node_guid(p_sw->p_node)));
/* Initialize LIDs in buffer to invalid port number. */
memset(p_sw->new_lft, OSM_NO_PATH, IB_LID_UCAST_END_HO + 1);
if (p_mgr->p_subn->opt.lmc)
alloc_ports_priv(p_mgr);
/*
Iterate through every port setting LID routes for each
port based on base LID and LMC value.
*/
lids_per_port = 1 << p_mgr->p_subn->opt.lmc;
for (i = 0; i < lids_per_port; i++) {
cl_qlist_t *list = &p_mgr->port_order_list;
cl_list_item_t *item;
for (item = cl_qlist_head(list); item != cl_qlist_end(list);
item = cl_qlist_next(item)) {
osm_port_t *port = cl_item_obj(item, port, list_item);
__osm_ucast_mgr_process_port(p_mgr, p_sw, port, i);
}
}
osm_ucast_mgr_set_fwd_table(p_mgr, p_sw);
if (p_mgr->p_subn->opt.lmc)
free_ports_priv(p_mgr);
OSM_LOG_EXIT(p_mgr->p_log);
}
void osm_vendor_delete(IN osm_vendor_t ** const pp_vend)
{
cl_list_item_t *p_item;
cl_list_obj_t *p_obj;
osm_bind_handle_t bind_h;
osm_log_t *p_log;
OSM_LOG_ENTER((*pp_vend)->p_log);
p_log = (*pp_vend)->p_log;
/* go over the bind handles , unbind them and remove from list */
p_item = cl_qlist_remove_head(&((*pp_vend)->bind_handles));
while (p_item != cl_qlist_end(&((*pp_vend)->bind_handles))) {
p_obj = PARENT_STRUCT(p_item, cl_list_obj_t, list_item);
bind_h = (osm_bind_handle_t *) cl_qlist_obj(p_obj);
osm_log(p_log, OSM_LOG_DEBUG,
"osm_vendor_delete: unbinding bind_h:%p \n", bind_h);
__osm_vendor_internal_unbind(bind_h);
free(p_obj);
/*removing from list */
p_item = cl_qlist_remove_head(&((*pp_vend)->bind_handles));
}
if (NULL != ((*pp_vend)->p_transport_info)) {
free((*pp_vend)->p_transport_info);
(*pp_vend)->p_transport_info = NULL;
}
/* remove the packet randomizer object */
if ((*pp_vend)->run_randomizer == TRUE)
osm_pkt_randomizer_destroy(&((*pp_vend)->p_pkt_randomizer),
p_log);
free(*pp_vend);
*pp_vend = NULL;
OSM_LOG_EXIT(p_log);
}
/* Dump out the complete state of the event wheel */
void __cl_event_wheel_dump(IN cl_event_wheel_t * const p_event_wheel)
{
cl_list_item_t *p_list_item;
cl_map_item_t *p_map_item;
cl_event_wheel_reg_info_t *p_event;
printf("************** Event Wheel Dump ***********************\n");
printf("Event Wheel List has %u items:\n",
cl_qlist_count(&p_event_wheel->events_wheel));
p_list_item = cl_qlist_head(&p_event_wheel->events_wheel);
while (p_list_item != cl_qlist_end(&p_event_wheel->events_wheel)) {
p_event =
PARENT_STRUCT(p_list_item, cl_event_wheel_reg_info_t,
list_item);
printf("Event key:0x%" PRIx64 " Context:%s NumRegs:%u\n",
p_event->key, (char *)p_event->context,
p_event->num_regs);
/* next */
p_list_item = cl_qlist_next(p_list_item);
}
printf("Event Map has %u items:\n",
cl_qmap_count(&p_event_wheel->events_map));
p_map_item = cl_qmap_head(&p_event_wheel->events_map);
while (p_map_item != cl_qmap_end(&p_event_wheel->events_map)) {
p_event =
PARENT_STRUCT(p_map_item, cl_event_wheel_reg_info_t,
map_item);
printf("Event key:0x%" PRIx64 " Context:%s NumRegs:%u\n",
p_event->key, (char *)p_event->context,
p_event->num_regs);
/* next */
p_map_item = cl_qmap_next(p_map_item);
}
}
void cl_event_wheel_destroy(IN cl_event_wheel_t * const p_event_wheel)
{
cl_list_item_t *p_list_item;
cl_map_item_t *p_map_item;
cl_event_wheel_reg_info_t *p_event;
/* we need to get a lock */
cl_spinlock_acquire(&p_event_wheel->lock);
cl_event_wheel_dump(p_event_wheel);
/* go over all the items in the list and remove them */
p_list_item = cl_qlist_remove_head(&p_event_wheel->events_wheel);
while (p_list_item != cl_qlist_end(&p_event_wheel->events_wheel)) {
p_event =
PARENT_STRUCT(p_list_item, cl_event_wheel_reg_info_t,
list_item);
CL_DBG("cl_event_wheel_destroy: Found outstanding event"
" key:<0x%" PRIx64 ">\n", p_event->key);
/* remove it from the map */
p_map_item = &(p_event->map_item);
cl_qmap_remove_item(&p_event_wheel->events_map, p_map_item);
free(p_event); /* allocated by cl_event_wheel_reg */
p_list_item =
cl_qlist_remove_head(&p_event_wheel->events_wheel);
}
/* destroy the timer */
cl_timer_destroy(&p_event_wheel->timer);
/* destroy the lock (this should be done without releasing - we don't want
any other run to grab the lock at this point. */
cl_spinlock_release(&p_event_wheel->lock);
cl_spinlock_destroy(&(p_event_wheel->lock));
}
void __mad_recv_processor(IN void *context)
{
mad_bind_info_t *p_mad_bind_info = (mad_bind_info_t *) context;
umadt_obj_t *p_umadt_obj;
osm_madw_t *p_osm_madw = NULL;
osm_vend_wrap_t *p_vend_wrap = NULL;
osm_mad_addr_t osm_mad_addr = { 0 };
cl_list_item_t *p_list_item;
void *transaction_context;
FSTATUS Status;
MadtStruct *pRecvMad = NULL;
MadWorkCompletion *pRecvCmp = NULL;
CL_ASSERT(context);
p_mad_bind_info = (mad_bind_info_t *) context;
p_umadt_obj = p_mad_bind_info->p_umadt_obj;
/* PollFor a completion */
/* if FNOTFOND, then wait for a completion then again poll and return the MAD */
while (1) {
Status =
p_umadt_obj->uMadtInterface.
uMadtPollForRecvCompletion(p_mad_bind_info->umadt_handle,
&pRecvMad, &pRecvCmp);
if (Status != FSUCCESS) {
if (Status == FNOT_FOUND) {
/* Wait for a completion */
Status = p_umadt_obj->uMadtInterface.uMadtWaitForAnyCompletion(p_mad_bind_info->umadt_handle, RECV_COMPLETION, 0x5000); /* 5 sec timeout */
if (Status == FTIMEOUT) {
continue;
}
CL_ASSERT(Status == FSUCCESS);
Status =
p_umadt_obj->uMadtInterface.
uMadtPollForRecvCompletion(p_mad_bind_info->
umadt_handle,
&pRecvMad,
&pRecvCmp);
if (Status != FSUCCESS) {
printf
(" mad_recv_worker: Error in PollForRecv returning <%x>\n",
Status);
CL_ASSERT(0);
}
} else {
printf
("uMadtPollForRecvCompletion Status=<%x>\n",
Status);
CL_ASSERT(0);
}
}
CL_ASSERT(pRecvMad);
CL_ASSERT(pRecvCmp);
if (((ib_sa_mad_t_vM3 *) (&pRecvMad->IBMad))->frag_flag & 0x20) {
/* Ignore the ACK packet */
Status =
p_umadt_obj->uMadtInterface.
uMadtReleaseRecvMad(p_mad_bind_info->umadt_handle,
pRecvMad);
continue;
}
/* */
/* Extract the return address to pass it on to the client */
/* */
osm_mad_addr.dest_lid = pRecvCmp->AddressInfo.DestLid;
osm_mad_addr.path_bits = pRecvCmp->AddressInfo.PathBits;
osm_mad_addr.static_rate = pRecvCmp->AddressInfo.StaticRate;
if (p_mad_bind_info->umadt_reg_class.ClassId ==
IB_MCLASS_SUBN_LID
|| p_mad_bind_info->umadt_reg_class.ClassId ==
IB_MCLASS_SUBN_DIR) {
osm_mad_addr.addr_type.smi.source_lid =
pRecvCmp->AddressInfo.AddrType.Smi.SourceLid;
/* osm_mad_addr.addr_type.smi.port_num = pRecvCmp->AddressInfo.AddrType.Smi.PortNumber; */
} else {
osm_mad_addr.addr_type.gsi.remote_qp =
pRecvCmp->AddressInfo.AddrType.Gsi.RemoteQpNumber;
osm_mad_addr.addr_type.gsi.remote_qkey =
pRecvCmp->AddressInfo.AddrType.Gsi.RemoteQkey;
osm_mad_addr.addr_type.gsi.pkey_ix = 0;
osm_mad_addr.addr_type.gsi.service_level =
pRecvCmp->AddressInfo.AddrType.Gsi.ServiceLevel;
osm_mad_addr.addr_type.gsi.global_route =
pRecvCmp->AddressInfo.AddrType.Gsi.GlobalRoute;
/* osm_mad_addr.addr_type.gsi.grh_info = pRecvCmp->AddressInfo.AddrType.Gsi.GRHInfo; */
}
p_osm_madw =
osm_mad_pool_get_wrapper(p_mad_bind_info->p_mad_pool,
p_mad_bind_info, MAD_BLOCK_SIZE,
(ib_mad_t *) & pRecvMad->IBMad,
&osm_mad_addr);
CL_ASSERT(p_osm_madw);
p_vend_wrap = osm_madw_get_vend_ptr(p_osm_madw);
CL_ASSERT(p_vend_wrap);
p_vend_wrap->p_madt_struct = pRecvMad;
p_vend_wrap->direction = RECEIVE;
osm_log(p_mad_bind_info->p_umadt_obj->p_log, OSM_LOG_DEBUG,
"__mad_recv_processor: "
"Received data p_osm_madw[0x%p].\n", p_osm_madw);
/* */
/* Do TID Processing. */
/* */
/* If R bit is set swap the TID */
cl_spinlock_acquire(&p_mad_bind_info->trans_ctxt_lock);
p_list_item =
cl_qlist_find_from_head(&p_mad_bind_info->trans_ctxt_list,
__match_tid_context,
&p_osm_madw->p_mad->trans_id);
if (p_list_item ==
cl_qlist_end(&p_mad_bind_info->trans_ctxt_list)) {
transaction_context = NULL;
} else {
transaction_context =
((trans_context_t *) p_list_item)->context;
cl_qlist_remove_item(&p_mad_bind_info->trans_ctxt_list,
p_list_item);
free(p_list_item);
}
cl_spinlock_release(&p_mad_bind_info->trans_ctxt_lock);
((ib_mad_t *) p_osm_madw->p_mad)->trans_id =
cl_ntoh64(p_osm_madw->p_mad->trans_id >> 24);
osm_log(p_mad_bind_info->p_umadt_obj->p_log, OSM_LOG_DEBUG,
"__mad_recv_processor: "
"Received data p_osm_madw [0x%p]" "\n\t\t\t\tTID[0x%"
PRIx64 ", context[%p]. \n", p_osm_madw,
((ib_mad_t *) p_osm_madw->p_mad)->trans_id,
transaction_context);
(*(p_mad_bind_info->mad_recv_callback)) (p_osm_madw,
p_mad_bind_info->
client_context,
transaction_context);
}
}
void __osm_vendor_timer_callback(IN void *context)
{
uint64_t current_time;
mad_bind_info_t *p_mad_bind_info;
umadt_obj_t *p_umadt_obj;
uint32_t timeout;
cl_list_item_t *p_list_item, *p_next_list_item;
CL_ASSERT(context);
p_mad_bind_info = (mad_bind_info_t *) context;
p_umadt_obj = p_mad_bind_info->p_umadt_obj;
timeout = p_umadt_obj->timeout * 1000;
current_time = cl_get_time_stamp();
cl_spinlock_acquire(&p_mad_bind_info->trans_ctxt_lock);
p_list_item = cl_qlist_head(&p_mad_bind_info->trans_ctxt_list);
while (p_list_item != cl_qlist_end(&p_mad_bind_info->trans_ctxt_list)) {
p_next_list_item = cl_qlist_next(p_list_item);
/* DEFAULT_PKT_TIMEOUT is in milli seconds */
if (current_time - ((trans_context_t *) p_list_item)->sent_time
> timeout) {
/* Add this transaction to the timeout_list */
cl_qlist_remove_item(&p_mad_bind_info->trans_ctxt_list,
p_list_item);
cl_qlist_insert_tail(&p_mad_bind_info->timeout_list,
p_list_item);
}
p_list_item = p_next_list_item;
}
cl_spinlock_release(&p_mad_bind_info->trans_ctxt_lock);
p_list_item = cl_qlist_head(&p_mad_bind_info->timeout_list);
while (p_list_item != cl_qlist_end(&p_mad_bind_info->timeout_list)) {
osm_log(p_mad_bind_info->p_umadt_obj->p_log, OSM_LOG_DEBUG,
"__osm_vendor_timer_callback: "
"Timing out transaction context [0x%p].\n",
((trans_context_t *) p_list_item)->context);
(*(p_mad_bind_info->mad_recv_callback)) (NULL,
p_mad_bind_info->
client_context,
((trans_context_t *)
p_list_item)->
context);
p_next_list_item = cl_qlist_next(p_list_item);
cl_qlist_remove_item(&p_mad_bind_info->timeout_list,
p_list_item);
free(p_list_item);
p_list_item = p_next_list_item;
}
cl_timer_start(&p_mad_bind_info->timeout_timer,
DEFAULT_TIMER_INTERVAL_MSEC);
}
/**********************************************************************
Received a Get(InformInfoRecord) or GetTable(InformInfoRecord) MAD
**********************************************************************/
static void
osm_infr_rcv_process_get_method(IN osm_sa_t * sa,
IN osm_madw_t * const p_madw)
{
char gid_str[INET6_ADDRSTRLEN];
ib_sa_mad_t *p_rcvd_mad;
const ib_inform_info_record_t *p_rcvd_rec;
cl_qlist_t rec_list;
osm_iir_search_ctxt_t context;
osm_physp_t *p_req_physp;
osm_iir_item_t *item;
OSM_LOG_ENTER(sa->p_log);
CL_ASSERT(p_madw);
p_rcvd_mad = osm_madw_get_sa_mad_ptr(p_madw);
p_rcvd_rec =
(ib_inform_info_record_t *) ib_sa_mad_get_payload_ptr(p_rcvd_mad);
/* update the requester physical port. */
p_req_physp = osm_get_physp_by_mad_addr(sa->p_log, sa->p_subn,
osm_madw_get_mad_addr_ptr
(p_madw));
if (p_req_physp == NULL) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4309: "
"Cannot find requester physical port\n");
goto Exit;
}
if (osm_log_is_active(sa->p_log, OSM_LOG_DEBUG))
osm_dump_inform_info_record(sa->p_log, p_rcvd_rec,
OSM_LOG_DEBUG);
cl_qlist_init(&rec_list);
context.p_rcvd_rec = p_rcvd_rec;
context.p_list = &rec_list;
context.comp_mask = p_rcvd_mad->comp_mask;
context.subscriber_gid = p_rcvd_rec->subscriber_gid;
context.subscriber_enum = p_rcvd_rec->subscriber_enum;
context.sa = sa;
context.p_req_physp = p_req_physp;
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"Query Subscriber GID:%s(%02X) Enum:0x%X(%02X)\n",
inet_ntop(AF_INET6, p_rcvd_rec->subscriber_gid.raw,
gid_str, sizeof gid_str),
(p_rcvd_mad->comp_mask & IB_IIR_COMPMASK_SUBSCRIBERGID) != 0,
cl_ntoh16(p_rcvd_rec->subscriber_enum),
(p_rcvd_mad->comp_mask & IB_IIR_COMPMASK_ENUM) != 0);
cl_plock_acquire(sa->p_lock);
cl_qlist_apply_func(&sa->p_subn->sa_infr_list,
__osm_sa_inform_info_rec_by_comp_mask_cb, &context);
cl_plock_release(sa->p_lock);
/* clear reserved and pad fields in InformInfoRecord */
for (item = (osm_iir_item_t *) cl_qlist_head(&rec_list);
item != (osm_iir_item_t *) cl_qlist_end(&rec_list);
item = (osm_iir_item_t *)cl_qlist_next(&item->list_item)) {
memset(item->rec.reserved, 0, sizeof(item->rec.reserved));
memset(item->rec.pad, 0, sizeof(item->rec.pad));
}
osm_sa_respond(sa, p_madw, sizeof(ib_inform_info_record_t), &rec_list);
Exit:
OSM_LOG_EXIT(sa->p_log);
}
static void __cl_event_wheel_callback(IN void *context)
{
cl_event_wheel_t *p_event_wheel = (cl_event_wheel_t *) context;
cl_list_item_t *p_list_item, *p_prev_event_list_item;
cl_list_item_t *p_list_next_item;
cl_event_wheel_reg_info_t *p_event;
uint64_t current_time;
uint64_t next_aging_time;
uint32_t new_timeout;
cl_status_t cl_status;
/* might be during closing ... */
if (p_event_wheel->closing)
return;
current_time = cl_get_time_stamp();
if (NULL != p_event_wheel->p_external_lock)
/* Take care of the order of acquiring locks to avoid the deadlock!
* The external lock goes first.
*/
cl_spinlock_acquire(p_event_wheel->p_external_lock);
cl_spinlock_acquire(&p_event_wheel->lock);
p_list_item = cl_qlist_head(&p_event_wheel->events_wheel);
if (p_list_item == cl_qlist_end(&p_event_wheel->events_wheel))
/* the list is empty - nothing to do */
goto Exit;
/* we found such an item. get the p_event */
p_event =
PARENT_STRUCT(p_list_item, cl_event_wheel_reg_info_t, list_item);
while (p_event->aging_time <= current_time) {
/* this object has aged - invoke it's callback */
if (p_event->pfn_aged_callback)
next_aging_time =
p_event->pfn_aged_callback(p_event->key,
p_event->num_regs,
p_event->context);
else
next_aging_time = 0;
/* point to the next object in the wheel */
p_list_next_item = cl_qlist_next(p_list_item);
/* We need to retire the event if the next aging time passed */
if (next_aging_time < current_time) {
/* remove it from the map */
cl_qmap_remove_item(&p_event_wheel->events_map,
&(p_event->map_item));
/* pop p_event from the wheel */
cl_qlist_remove_head(&p_event_wheel->events_wheel);
/* delete the event info object - allocated by cl_event_wheel_reg */
free(p_event);
} else {
/* update the required aging time */
p_event->aging_time = next_aging_time;
p_event->num_regs++;
/* do not remove from the map - but remove from the list head and
place in the correct position */
/* pop p_event from the wheel */
cl_qlist_remove_head(&p_event_wheel->events_wheel);
/* find the event that ages just before */
p_prev_event_list_item =
cl_qlist_find_from_tail(&p_event_wheel->
events_wheel,
__event_will_age_before,
&p_event->aging_time);
/* insert just after */
cl_qlist_insert_next(&p_event_wheel->events_wheel,
p_prev_event_list_item,
&p_event->list_item);
/* as we have modified the list - restart from first item: */
p_list_next_item =
cl_qlist_head(&p_event_wheel->events_wheel);
}
/* advance to next event */
p_list_item = p_list_next_item;
if (p_list_item == cl_qlist_end(&p_event_wheel->events_wheel))
/* the list is empty - nothing to do */
break;
/* get the p_event */
p_event =
PARENT_STRUCT(p_list_item, cl_event_wheel_reg_info_t,
list_item);
}
/* We need to restart the timer only if the list is not empty now */
if (p_list_item != cl_qlist_end(&p_event_wheel->events_wheel)) {
/* get the p_event */
p_event =
PARENT_STRUCT(p_list_item, cl_event_wheel_reg_info_t,
list_item);
/* start the timer to the timeout [msec] */
new_timeout =
(uint32_t) ((p_event->aging_time - current_time + 500) / 1000);
CL_DBG("__cl_event_wheel_callback: Restart timer in: "
"%u [msec]\n", new_timeout);
cl_status = cl_timer_start(&p_event_wheel->timer, new_timeout);
if (cl_status != CL_SUCCESS) {
CL_DBG("__cl_event_wheel_callback : ERR 6200: "
"Failed to start timer\n");
}
}
/* release the lock */
Exit:
cl_spinlock_release(&p_event_wheel->lock);
if (NULL != p_event_wheel->p_external_lock)
cl_spinlock_release(p_event_wheel->p_external_lock);
}
static void vl15_poller(IN void *p_ptr)
{
ib_api_status_t status;
osm_madw_t *p_madw;
osm_vl15_t *p_vl = p_ptr;
cl_qlist_t *p_fifo;
int32_t max_smps = p_vl->max_wire_smps;
int32_t max_smps2 = p_vl->max_wire_smps2;
OSM_LOG_ENTER(p_vl->p_log);
if (p_vl->thread_state == OSM_THREAD_STATE_NONE)
p_vl->thread_state = OSM_THREAD_STATE_RUN;
while (p_vl->thread_state == OSM_THREAD_STATE_RUN) {
/*
Start servicing the FIFOs by pulling off MAD wrappers
and passing them to the transport interface.
There are lots of corner cases here so tread carefully.
The unicast FIFO has priority, since somebody is waiting
for a timely response.
*/
cl_spinlock_acquire(&p_vl->lock);
if (cl_qlist_count(&p_vl->ufifo) != 0)
p_fifo = &p_vl->ufifo;
else
p_fifo = &p_vl->rfifo;
p_madw = (osm_madw_t *) cl_qlist_remove_head(p_fifo);
cl_spinlock_release(&p_vl->lock);
if (p_madw != (osm_madw_t *) cl_qlist_end(p_fifo)) {
OSM_LOG(p_vl->p_log, OSM_LOG_DEBUG,
"Servicing p_madw = %p\n", p_madw);
if (osm_log_is_active(p_vl->p_log, OSM_LOG_FRAMES))
osm_dump_dr_smp(p_vl->p_log,
osm_madw_get_smp_ptr(p_madw),
OSM_LOG_FRAMES);
vl15_send_mad(p_vl, p_madw);
} else
/*
The VL15 FIFO is empty, so we have nothing left to do.
*/
status = cl_event_wait_on(&p_vl->signal,
EVENT_NO_TIMEOUT, TRUE);
while (p_vl->p_stats->qp0_mads_outstanding_on_wire >= max_smps &&
p_vl->thread_state == OSM_THREAD_STATE_RUN) {
status = cl_event_wait_on(&p_vl->signal,
p_vl->max_smps_timeout,
TRUE);
if (status == CL_TIMEOUT) {
if (max_smps < max_smps2)
max_smps++;
break;
} else if (status != CL_SUCCESS) {
OSM_LOG(p_vl->p_log, OSM_LOG_ERROR, "ERR 3E02: "
"Event wait failed (%s)\n",
CL_STATUS_MSG(status));
break;
}
max_smps = p_vl->max_wire_smps;
}
}
/*
since we abort immediately when the state != OSM_THREAD_STATE_RUN
we might have some mads on the queues. After the thread exits
the vl15 destroy routine should put these mads back...
*/
OSM_LOG_EXIT(p_vl->p_log);
}
int osm_qos_setup(osm_opensm_t * p_osm)
{
struct qos_config ca_config, sw0_config, swe_config, rtr_config;
struct qos_config *cfg;
cl_qmap_t *p_tbl;
cl_map_item_t *p_next;
osm_port_t *p_port;
osm_node_t *p_node;
int ret = 0;
int vlarb_only;
qos_mad_list_t *p_list, *p_list_next;
qos_mad_item_t *p_port_mad;
cl_qlist_t qos_mad_list;
if (!p_osm->subn.opt.qos)
return 0;
OSM_LOG_ENTER(&p_osm->log);
qos_build_config(&ca_config, &p_osm->subn.opt.qos_ca_options,
&p_osm->subn.opt.qos_options);
qos_build_config(&sw0_config, &p_osm->subn.opt.qos_sw0_options,
&p_osm->subn.opt.qos_options);
qos_build_config(&swe_config, &p_osm->subn.opt.qos_swe_options,
&p_osm->subn.opt.qos_options);
qos_build_config(&rtr_config, &p_osm->subn.opt.qos_rtr_options,
&p_osm->subn.opt.qos_options);
cl_qlist_init(&qos_mad_list);
cl_plock_excl_acquire(&p_osm->lock);
/* read QoS policy config file */
osm_qos_parse_policy_file(&p_osm->subn);
p_tbl = &p_osm->subn.port_guid_tbl;
p_next = cl_qmap_head(p_tbl);
while (p_next != cl_qmap_end(p_tbl)) {
vlarb_only = 0;
p_port = (osm_port_t *) p_next;
p_next = cl_qmap_next(p_next);
p_list = (qos_mad_list_t *) malloc(sizeof(*p_list));
if (!p_list)
return -1;
memset(p_list, 0, sizeof(*p_list));
cl_qlist_init(&p_list->port_mad_list);
p_node = p_port->p_node;
if (p_node->sw) {
if (qos_extports_setup(&p_osm->sm, p_node, &swe_config,
&p_list->port_mad_list))
ret = -1;
/* skip base port 0 */
if (!ib_switch_info_is_enhanced_port0
(&p_node->sw->switch_info))
goto Continue;
if (ib_switch_info_get_opt_sl2vlmapping(&p_node->sw->switch_info) &&
p_osm->sm.p_subn->opt.use_optimized_slvl &&
!memcmp(&swe_config.sl2vl, &sw0_config.sl2vl,
sizeof(swe_config.sl2vl)))
vlarb_only = 1;
cfg = &sw0_config;
} else if (osm_node_get_type(p_node) == IB_NODE_TYPE_ROUTER)
cfg = &rtr_config;
else
cfg = &ca_config;
if (qos_endport_setup(&p_osm->sm, p_port->p_physp, cfg,
vlarb_only, &p_list->port_mad_list))
ret = -1;
Continue:
/* if MAD list is not empty, add it to the global MAD list */
if (cl_qlist_count(&p_list->port_mad_list)) {
cl_qlist_insert_tail(&qos_mad_list, &p_list->list_item);
} else {
free(p_list);
}
}
while (cl_qlist_count(&qos_mad_list)) {
p_list_next = (qos_mad_list_t *) cl_qlist_head(&qos_mad_list);
while (p_list_next !=
(qos_mad_list_t *) cl_qlist_end(&qos_mad_list)) {
p_list = p_list_next;
p_list_next = (qos_mad_list_t *)
cl_qlist_next(&p_list->list_item);
/* next MAD to send*/
p_port_mad = (qos_mad_item_t *)
cl_qlist_remove_head(&p_list->port_mad_list);
osm_send_req_mad(&p_osm->sm, p_port_mad->p_madw);
osm_qos_mad_delete(&p_port_mad);
/* remove the QoS MAD from global MAD list */
if (cl_qlist_count(&p_list->port_mad_list) == 0) {
cl_qlist_remove_item(&qos_mad_list, &p_list->list_item);
free(p_list);
}
}
}
cl_plock_release(&p_osm->lock);
OSM_LOG_EXIT(&p_osm->log);
return ret;
}
/* this is the callback function of the timer */
void __osm_transaction_mgr_callback(IN void *context)
{
osm_transaction_mgr_t *trans_mgr_p;
osm_vendor_t *p_vend = (osm_vendor_t *) context;
cl_list_item_t *p_list_item;
cl_list_item_t *p_list_next_item;
osm_madw_req_t *osm_madw_req_p;
uint64_t current_time; /* [usec] */
uint32_t new_timeout; /* [msec] */
cl_status_t cl_status;
ib_mad_t *p_mad;
#ifdef OSM_VENDOR_INTF_MTL
osm_mtl_bind_info_t *p_bind;
#else
osm_ts_bind_info_t *p_bind;
#endif
cl_list_t tmp_madw_p_list; /* this list will include all the madw_p that should be removed. */
cl_list_t retry_madw_p_list; /* this list will include all the madw_p that were retried and need to be removed. */
osm_madw_t *madw_p;
OSM_LOG_ENTER(p_vend->p_log);
trans_mgr_p = (osm_transaction_mgr_t *) p_vend->p_transaction_mgr;
/* initialize the tmp_madw_p_list */
cl_list_construct(&tmp_madw_p_list);
cl_status = cl_list_init(&tmp_madw_p_list, 50);
if (cl_status != CL_SUCCESS) {
osm_log(p_vend->p_log, OSM_LOG_ERROR,
"__osm_transaction_mgr_callback : ERROR 1000: "
"Failed to create tmp_madw_p_list\n");
}
cl_list_construct(&retry_madw_p_list);
cl_status = cl_list_init(&retry_madw_p_list, 50);
if (cl_status != CL_SUCCESS) {
osm_log(p_vend->p_log, OSM_LOG_ERROR,
"__osm_transaction_mgr_callback : ERROR 1000: "
"Failed to create retry_madw_p_list\n");
}
current_time = cl_get_time_stamp();
cl_spinlock_acquire(&(trans_mgr_p->transaction_mgr_lock));
p_list_item = cl_qlist_head(trans_mgr_p->madw_reqs_list_p);
if (p_list_item == cl_qlist_end(trans_mgr_p->madw_reqs_list_p)) {
/* the list is empty - nothing to do */
cl_spinlock_release(&trans_mgr_p->transaction_mgr_lock);
osm_log(p_vend->p_log, OSM_LOG_DEBUG,
"__osm_transaction_mgr_callback : Nothing to do\n");
goto Exit;
}
/* non empty list: */
/* get the osm_madw_req_p */
osm_madw_req_p = PARENT_STRUCT(p_list_item, osm_madw_req_t, list_item);
while (osm_madw_req_p->waking_time <= current_time) {
/* this object was supposed to have gotten a response */
/* we need to decide if we need to retry or done with it. */
if (osm_madw_req_p->retry_cnt > 0) {
/* add to the list of the retrys : */
cl_list_insert_tail(&retry_madw_p_list, osm_madw_req_p);
/* update wakeup time and retry count */
osm_madw_req_p->waking_time =
p_vend->timeout * 1000 + cl_get_time_stamp();
osm_madw_req_p->retry_cnt--;
/* make sure we will get some timer call if not earlier */
osm_log(p_vend->p_log, OSM_LOG_DEBUG,
"__osm_transaction_mgr_callback : Timer restart:%u\n",
p_vend->timeout);
cl_status =
cl_timer_start(&trans_mgr_p->madw_list_timer,
p_vend->timeout);
/* go to the next object and check if it also needs to be removed - didn't receive response */
/* we need to do it before we move current item to the end of the list */
p_list_next_item = cl_qlist_next(p_list_item);
/* remove from the head */
cl_qlist_remove_item(trans_mgr_p->madw_reqs_list_p,
&(osm_madw_req_p->list_item));
/* insert the object to the qlist and the qmap */
cl_qlist_insert_tail(trans_mgr_p->madw_reqs_list_p,
&(osm_madw_req_p->list_item));
} else {
/* go to the next object and check if it also needs to be removed - didn't receive response */
p_list_next_item = cl_qlist_next(p_list_item);
/* remove from the head */
cl_qlist_remove_item(trans_mgr_p->madw_reqs_list_p,
&(osm_madw_req_p->list_item));
/* add it to the tmp_madw_p_list to be removed */
cl_list_insert_tail(&tmp_madw_p_list,
osm_madw_req_p->p_madw);
osm_log(p_vend->p_log, OSM_LOG_DEBUG,
"__osm_transaction_mgr_callback : Found failed transaction madw: %p\n",
osm_madw_req_p->p_madw);
}
/* Advance */
p_list_item = p_list_next_item;
if (p_list_item == cl_qlist_end(trans_mgr_p->madw_reqs_list_p)) {
/* the list is empty - nothing to do */
break;
}
/* get the osm_madw_req_p */
osm_madw_req_p =
PARENT_STRUCT(p_list_item, osm_madw_req_t, list_item);
}
/* look at the current p_list_item. If it is not the end item - then we need to */
/* re-start the timer */
if (p_list_item != cl_qlist_end(trans_mgr_p->madw_reqs_list_p)) {
/* get the osm_madw_req_p */
osm_madw_req_p =
PARENT_STRUCT(p_list_item, osm_madw_req_t, list_item);
/* we have the object that still didn't get response - re-start the timer */
/* start the timer to the timeout (in miliseconds) */
new_timeout =
(osm_madw_req_p->waking_time - cl_get_time_stamp()) / 1000 +
1;
cl_status =
cl_timer_start(&trans_mgr_p->madw_list_timer, new_timeout);
osm_log(p_vend->p_log, OSM_LOG_DEBUG,
"__osm_transaction_mgr_callback : Timer restart:%u\n",
new_timeout);
if (cl_status != CL_SUCCESS) {
osm_log(p_vend->p_log, OSM_LOG_ERROR,
"__osm_transaction_mgr_callback : ERROR 1000: "
"Failed to start timer\n");
}
}
/* if not empty - retry on retry list: */
if (!cl_is_list_empty(&retry_madw_p_list)) {
/* remove all elements that were retried: */
osm_madw_req_p =
(osm_madw_req_t
*) (cl_list_remove_head(&retry_madw_p_list));
while (osm_madw_req_p != NULL) {
/* resend: */
osm_log(p_vend->p_log, OSM_LOG_DEBUG,
"__osm_transaction_mgr_callback : "
"Retry %d of madw %p\n",
OSM_DEFAULT_RETRY_COUNT -
osm_madw_req_p->retry_cnt,
osm_madw_req_p->p_madw);
/* actually send it */
#ifdef OSM_VENDOR_INTF_MTL
osm_mtl_send_mad((osm_mtl_bind_info_t *)
osm_madw_req_p->p_bind,
osm_madw_req_p->p_madw);
#else
ib_api_status_t
osm_ts_send_mad(osm_ts_bind_info_t * p_bind,
osm_madw_t * const p_madw);
osm_ts_send_mad((osm_ts_bind_info_t *) osm_madw_req_p->
p_bind, osm_madw_req_p->p_madw);
#endif
/* next one */
osm_madw_req_p =
(osm_madw_req_t
*) (cl_list_remove_head(&retry_madw_p_list));
}
}
/* if the tmp_madw_p_list has elements - need to call the send_err_callback */
madw_p = (osm_madw_t *) (cl_list_remove_head(&tmp_madw_p_list));
while (madw_p != NULL) {
/* need to remove it from pool */
/* obtain the madw_p stored as the wrid in the send call */
p_mad = osm_madw_get_mad_ptr(madw_p);
p_bind = madw_p->h_bind;
/*
Return any wrappers to the pool that may have been
pre-emptively allocated to handle a receive.
*/
if (madw_p->vend_wrap.p_resp_madw) {
#ifdef OSM_VENDOR_INTF_MTL
osm_mad_pool_put(p_bind->p_osm_pool,
madw_p->vend_wrap.p_resp_madw);
#else
osm_mad_pool_put(p_bind->p_osm_pool,
madw_p->vend_wrap.p_resp_madw);
#endif
madw_p->vend_wrap.p_resp_madw = NULL;
}
/* invoke the CB */
(*(osm_vend_mad_send_err_callback_t)
(p_bind->send_err_callback)) (p_bind->client_context, madw_p);
madw_p = (osm_madw_t *) (cl_list_remove_head(&tmp_madw_p_list));
}
Exit:
OSM_LOG_EXIT(p_vend->p_log);
}
void osm_sa_respond(osm_sa_t *sa, osm_madw_t *madw, size_t attr_size,
cl_qlist_t *list)
{
struct item_data {
cl_list_item_t list;
char data[0];
};
cl_list_item_t *item;
osm_madw_t *resp_madw;
ib_sa_mad_t *sa_mad, *resp_sa_mad;
unsigned num_rec, i;
#ifndef VENDOR_RMPP_SUPPORT
unsigned trim_num_rec;
#endif
unsigned char *p;
sa_mad = osm_madw_get_sa_mad_ptr(madw);
num_rec = cl_qlist_count(list);
/*
* C15-0.1.30:
* If we do a SubnAdmGet and got more than one record it is an error!
*/
if (sa_mad->method == IB_MAD_METHOD_GET && num_rec > 1) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4C05: "
"Got %u records for SubnAdmGet(%s) comp_mask 0x%016" PRIx64 "\n",
num_rec, ib_get_sa_attr_str(sa_mad->attr_id),
cl_ntoh64(sa_mad->comp_mask));
osm_sa_send_error(sa, madw, IB_SA_MAD_STATUS_TOO_MANY_RECORDS);
goto Exit;
}
#ifndef VENDOR_RMPP_SUPPORT
trim_num_rec = (MAD_BLOCK_SIZE - IB_SA_MAD_HDR_SIZE) / attr_size;
if (trim_num_rec < num_rec) {
OSM_LOG(sa->p_log, OSM_LOG_VERBOSE,
"Number of records:%u trimmed to:%u to fit in one MAD\n",
num_rec, trim_num_rec);
num_rec = trim_num_rec;
}
#endif
OSM_LOG(sa->p_log, OSM_LOG_DEBUG, "Returning %u records\n", num_rec);
if (sa_mad->method == IB_MAD_METHOD_GET && num_rec == 0) {
osm_sa_send_error(sa, madw, IB_SA_MAD_STATUS_NO_RECORDS);
goto Exit;
}
/*
* Get a MAD to reply. Address of Mad is in the received mad_wrapper
*/
resp_madw = osm_mad_pool_get(sa->p_mad_pool, madw->h_bind,
num_rec * attr_size + IB_SA_MAD_HDR_SIZE,
&madw->mad_addr);
if (!resp_madw) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4C06: "
"osm_mad_pool_get failed\n");
osm_sa_send_error(sa, madw, IB_SA_MAD_STATUS_NO_RESOURCES);
goto Exit;
}
resp_sa_mad = osm_madw_get_sa_mad_ptr(resp_madw);
/*
Copy the MAD header back into the response mad.
Set the 'R' bit and the payload length,
Then copy all records from the list into the response payload.
*/
memcpy(resp_sa_mad, sa_mad, IB_SA_MAD_HDR_SIZE);
if (resp_sa_mad->method == IB_MAD_METHOD_SET)
resp_sa_mad->method = IB_MAD_METHOD_GET;
resp_sa_mad->method |= IB_MAD_METHOD_RESP_MASK;
/* C15-0.1.5 - always return SM_Key = 0 (table 185 p 884) */
resp_sa_mad->sm_key = 0;
/* Fill in the offset (paylen will be done by the rmpp SAR) */
resp_sa_mad->attr_offset = num_rec ? ib_get_attr_offset(attr_size) : 0;
p = ib_sa_mad_get_payload_ptr(resp_sa_mad);
#ifndef VENDOR_RMPP_SUPPORT
/* we support only one packet RMPP - so we will set the first and
last flags for gettable */
if (resp_sa_mad->method == IB_MAD_METHOD_GETTABLE_RESP) {
resp_sa_mad->rmpp_type = IB_RMPP_TYPE_DATA;
resp_sa_mad->rmpp_flags =
IB_RMPP_FLAG_FIRST | IB_RMPP_FLAG_LAST |
IB_RMPP_FLAG_ACTIVE;
}
#else
/* forcefully define the packet as RMPP one */
if (resp_sa_mad->method == IB_MAD_METHOD_GETTABLE_RESP)
resp_sa_mad->rmpp_flags = IB_RMPP_FLAG_ACTIVE;
#endif
for (i = 0; i < num_rec; i++) {
item = cl_qlist_remove_head(list);
memcpy(p, ((struct item_data *)item)->data, attr_size);
p += attr_size;
free(item);
}
osm_dump_sa_mad(sa->p_log, resp_sa_mad, OSM_LOG_FRAMES);
osm_sa_send(sa, resp_madw, FALSE);
Exit:
/* need to set the mem free ... */
item = cl_qlist_remove_head(list);
while (item != cl_qlist_end(list)) {
free(item);
item = cl_qlist_remove_head(list);
}
}