static void sm_state_mgr_start_polling(osm_sm_t * sm)
{
uint32_t timeout = sm->p_subn->opt.sminfo_polling_timeout;
cl_status_t cl_status;
OSM_LOG_ENTER(sm->p_log);
/*
* Init the retry_number back to zero - need to restart counting
*/
sm->retry_number = 0;
/*
* Send a SubnGet(SMInfo) query to the current (or new) master found.
*/
sm_state_mgr_send_master_sm_info_req(sm);
/*
* Start a timer that will wake up every sminfo_polling_timeout milliseconds.
* The callback of the timer will send a SubnGet(SMInfo) to the Master SM
* and restart the timer
*/
cl_status = cl_timer_start(&sm->polling_timer, timeout);
if (cl_status != CL_SUCCESS)
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3210: "
"Failed to start timer\n");
OSM_LOG_EXIT(sm->p_log);
}
cl_status_t
cl_timer_trim(IN cl_timer_t * const p_timer, IN const uint32_t time_ms)
{
struct timeval curtime;
struct timespec newtime;
cl_status_t status;
CL_ASSERT(p_timer);
CL_ASSERT(p_timer->state == CL_INITIALIZED);
pthread_mutex_lock(&gp_timer_prov->mutex);
/* Get the current time */
timerclear(&curtime);
gettimeofday(&curtime, NULL);
/* Calculate the timeout. */
newtime.tv_sec = curtime.tv_sec + (time_ms / 1000);
newtime.tv_nsec = (curtime.tv_usec + ((time_ms % 1000) * 1000)) * 1000;
if (p_timer->timer_state == CL_TIMER_QUEUED) {
/* If the old time is earlier, do not trim it. Just return. */
if (__cl_timer_is_earlier(&p_timer->timeout, &newtime)) {
pthread_mutex_unlock(&gp_timer_prov->mutex);
return (CL_SUCCESS);
}
}
/* Reset the timer to the new timeout value. */
pthread_mutex_unlock(&gp_timer_prov->mutex);
status = cl_timer_start(p_timer, time_ms);
return (status);
}
osm_bind_handle_t
osm_vendor_bind(IN osm_vendor_t * const p_vend,
IN osm_bind_info_t * const p_osm_bind_info,
IN osm_mad_pool_t * const p_mad_pool,
IN osm_vend_mad_recv_callback_t mad_recv_callback,
IN void *context)
{
cl_status_t cl_status;
FSTATUS Status; /* GEN1 Status for Umadt */
mad_bind_info_t *p_mad_bind_info;
RegisterClassStruct *p_umadt_reg_class;
umadt_obj_t *p_umadt_obj;
OSM_LOG_ENTER(((umadt_obj_t *) p_vend)->p_log);
CL_ASSERT(p_vend);
p_umadt_obj = (umadt_obj_t *) p_vend;
/* Sanity check */
CL_ASSERT(p_umadt_obj->init_done);
CL_ASSERT(p_osm_bind_info);
CL_ASSERT(p_mad_pool);
CL_ASSERT(mad_recv_callback);
/* Allocate memory for registering the handle. */
p_mad_bind_info = (mad_bind_info_t *) malloc(sizeof(*p_mad_bind_info));
if (p_mad_bind_info) {
memset(p_mad_bind_info, 0, sizeof(*p_mad_bind_info));
p_umadt_reg_class = &p_mad_bind_info->umadt_reg_class;
}
p_umadt_reg_class->PortGuid = cl_ntoh64(p_osm_bind_info->port_guid);
p_umadt_reg_class->ClassId = p_osm_bind_info->mad_class;
p_umadt_reg_class->ClassVersion = p_osm_bind_info->class_version;
p_umadt_reg_class->isResponder = p_osm_bind_info->is_responder;
p_umadt_reg_class->isTrapProcessor = p_osm_bind_info->is_trap_processor;
p_umadt_reg_class->isReportProcessor =
p_osm_bind_info->is_report_processor;
p_umadt_reg_class->SendQueueSize = p_osm_bind_info->send_q_size;
p_umadt_reg_class->RecvQueueSize = p_osm_bind_info->recv_q_size;
p_umadt_reg_class->NotifySendCompletion = TRUE;
p_mad_bind_info->p_umadt_obj = p_umadt_obj;
p_mad_bind_info->p_mad_pool = p_mad_pool;
p_mad_bind_info->mad_recv_callback = mad_recv_callback;
p_mad_bind_info->client_context = context;
/* register with Umadt for MAD interface */
Status = p_umadt_obj->uMadtInterface.uMadtRegister(p_umadt_reg_class,
&p_mad_bind_info->
umadt_handle);
if (Status != FSUCCESS) {
free(p_mad_bind_info);
OSM_LOG_EXIT(p_umadt_obj->p_log);
return (OSM_BIND_INVALID_HANDLE);
}
CL_ASSERT(p_mad_bind_info->umadt_handle);
/* */
/* Start a worker thread to process receives. */
/* */
cl_thread_construct(&p_mad_bind_info->recv_processor_thread);
cl_status = cl_thread_init(&p_mad_bind_info->recv_processor_thread,
__mad_recv_processor,
(void *)p_mad_bind_info, "mad_recv_worker");
CL_ASSERT(cl_status == CL_SUCCESS);
cl_qlist_init(&p_mad_bind_info->trans_ctxt_list);
cl_spinlock_construct(&p_mad_bind_info->trans_ctxt_lock);
cl_spinlock_init(&p_mad_bind_info->trans_ctxt_lock);
cl_spinlock_construct(&p_mad_bind_info->timeout_list_lock);
cl_spinlock_init(&p_mad_bind_info->timeout_list_lock);
cl_status = cl_timer_init(&p_mad_bind_info->timeout_timer,
__osm_vendor_timer_callback,
(void *)p_mad_bind_info);
CL_ASSERT(cl_status == CL_SUCCESS);
cl_qlist_init(&p_mad_bind_info->timeout_list);
/* */
/* Insert the mad_reg_struct in list and return pointer to it as the handle */
/* */
cl_spinlock_acquire(&p_umadt_obj->register_lock);
cl_qlist_insert_head(&p_umadt_obj->register_list,
&p_mad_bind_info->list_item);
cl_spinlock_release(&p_umadt_obj->register_lock);
/*
A timeout value of 0 means disable timeouts.
*/
if (p_umadt_obj->timeout) {
cl_timer_start(&p_mad_bind_info->timeout_timer,
DEFAULT_TIMER_INTERVAL_MSEC);
}
OSM_LOG_EXIT(p_umadt_obj->p_log);
return ((osm_bind_handle_t) p_mad_bind_info);
}
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);
}
ib_api_status_t
osm_transaction_mgr_insert_madw(IN osm_bind_handle_t * const p_bind,
IN osm_madw_t * p_madw)
{
#ifdef OSM_VENDOR_INTF_MTL
osm_vendor_t *const p_vend = ((osm_mtl_bind_info_t *) p_bind)->p_vend;
#else
osm_vendor_t *const p_vend = ((osm_ts_bind_info_t *) p_bind)->p_vend;
#endif
osm_transaction_mgr_t *trans_mgr_p;
osm_madw_req_t *osm_madw_req_p;
uint64_t timeout;
uint64_t waking_time;
cl_status_t cl_status;
uint64_t key;
const ib_mad_t *mad_p = p_madw->p_mad;
OSM_LOG_ENTER(p_vend->p_log);
CL_ASSERT(mad_p);
trans_mgr_p = (osm_transaction_mgr_t *) p_vend->p_transaction_mgr;
timeout = (uint64_t) (p_vend->timeout) * 1000; /* change the miliseconds value of timeout to microseconds. */
waking_time = timeout + cl_get_time_stamp();
osm_madw_req_p = (osm_madw_req_t *) malloc(sizeof(osm_madw_req_t));
osm_madw_req_p->p_madw = p_madw;
osm_madw_req_p->waking_time = waking_time;
osm_madw_req_p->retry_cnt = OSM_DEFAULT_RETRY_COUNT;
osm_madw_req_p->p_bind = p_bind;
osm_log(p_vend->p_log, OSM_LOG_DEBUG,
"osm_transaction_mgr_insert_madw: "
"Inserting MADW:%p with waking_time: <0x%" PRIx64 "> TID:<0x%"
PRIx64 ">.\n", p_madw, waking_time, p_madw->p_mad->trans_id);
/* Get the lock on the manager */
cl_spinlock_acquire(&(trans_mgr_p->transaction_mgr_lock));
/* If the list is empty - need to start the timer with timer of timeout (in miliseconds) */
if (cl_is_qlist_empty(trans_mgr_p->madw_reqs_list_p)) {
/* stop the timer if it is running */
cl_timer_stop(&trans_mgr_p->madw_list_timer);
/* start the timer to the timeout (in miliseconds) */
cl_status = cl_timer_start(&trans_mgr_p->madw_list_timer,
p_vend->timeout);
if (cl_status != CL_SUCCESS) {
osm_log(p_vend->p_log, OSM_LOG_ERROR,
"osm_transaction_mgr_insert_madw : ERROR 1000: "
"Failed to start timer\n");
}
}
/* 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));
/* get the key */
key = (uint64_t) mad_p->trans_id;
cl_qmap_insert(trans_mgr_p->madw_by_tid_map_p, key,
&(osm_madw_req_p->map_item));
cl_spinlock_release(&trans_mgr_p->transaction_mgr_lock);
OSM_LOG_EXIT(p_vend->p_log);
return (IB_SUCCESS);
}
/* 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_sm_state_mgr_polling_callback(IN void *context)
{
osm_sm_t *sm = context;
uint32_t timeout = sm->p_subn->opt.sminfo_polling_timeout;
cl_status_t cl_status;
OSM_LOG_ENTER(sm->p_log);
/*
* We can be here in one of two cases:
* 1. We are a STANDBY sm polling on the master SM.
* 2. We are a MASTER sm, waiting for a handover from a remote master sm.
* If we are not in one of these cases - don't need to restart the poller.
*/
if (!((sm->p_subn->sm_state == IB_SMINFO_STATE_MASTER &&
sm->p_polling_sm != NULL) ||
sm->p_subn->sm_state == IB_SMINFO_STATE_STANDBY))
goto Exit;
/*
* If we are a STANDBY sm and the osm_exit_flag is set, then let's
* signal the subnet_up. This is relevant for the case of running only
* once. In that case - the program is stuck until this signal is
* received. In other cases - it is not relevant whether or not the
* signal is on - since we are currently in exit flow
*/
if (sm->p_subn->sm_state == IB_SMINFO_STATE_STANDBY && osm_exit_flag) {
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Signalling subnet_up_event\n");
cl_event_signal(&sm->subnet_up_event);
goto Exit;
}
/*
* Incr the retry number.
* If it reached the max_retry_number in the subnet opt - call
* osm_sm_state_mgr_process with signal OSM_SM_SIGNAL_POLLING_TIMEOUT
*/
sm->retry_number++;
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE, "Retry number:%d\n",
sm->retry_number);
if (sm->retry_number >= sm->p_subn->opt.polling_retry_number) {
OSM_LOG(sm->p_log, OSM_LOG_DEBUG,
"Reached polling_retry_number value in retry_number. "
"Go to DISCOVERY state\n");
osm_sm_state_mgr_process(sm, OSM_SM_SIGNAL_POLLING_TIMEOUT);
goto Exit;
}
/* Send a SubnGet(SMInfo) request to the remote sm (depends on our state) */
sm_state_mgr_send_master_sm_info_req(sm);
/* restart the timer */
cl_status = cl_timer_start(&sm->polling_timer, timeout);
if (cl_status != CL_SUCCESS)
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3211: "
"Failed to restart timer\n");
Exit:
OSM_LOG_EXIT(sm->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);
}
cl_status_t cl_event_wheel_reg(IN cl_event_wheel_t * const p_event_wheel,
IN const uint64_t key,
IN const uint64_t aging_time_usec,
IN cl_pfn_event_aged_cb_t pfn_callback,
IN void *const context)
{
cl_event_wheel_reg_info_t *p_event;
uint64_t timeout;
uint32_t to;
cl_status_t cl_status = CL_SUCCESS;
cl_list_item_t *prev_event_list_item;
cl_map_item_t *p_map_item;
/* Get the lock on the manager */
cl_spinlock_acquire(&(p_event_wheel->lock));
cl_event_wheel_dump(p_event_wheel);
/* Make sure such a key does not exists */
p_map_item = cl_qmap_get(&p_event_wheel->events_map, key);
if (p_map_item != cl_qmap_end(&p_event_wheel->events_map)) {
CL_DBG("cl_event_wheel_reg: Already exists key:0x%"
PRIx64 "\n", key);
/* already there - remove it from the list as it is getting a new time */
p_event =
PARENT_STRUCT(p_map_item, cl_event_wheel_reg_info_t,
map_item);
/* remove the item from the qlist */
cl_qlist_remove_item(&p_event_wheel->events_wheel,
&p_event->list_item);
/* and the qmap */
cl_qmap_remove_item(&p_event_wheel->events_map,
&p_event->map_item);
} else {
/* make a new one */
p_event = (cl_event_wheel_reg_info_t *)
malloc(sizeof(cl_event_wheel_reg_info_t));
p_event->num_regs = 0;
}
p_event->key = key;
p_event->aging_time = aging_time_usec;
p_event->pfn_aged_callback = pfn_callback;
p_event->context = context;
p_event->num_regs++;
CL_DBG("cl_event_wheel_reg: Registering event key:0x%" PRIx64
" aging in %u [msec]\n", p_event->key,
(uint32_t) ((p_event->aging_time - cl_get_time_stamp()) / 1000));
/* If the list is empty - need to start the timer */
if (cl_is_qlist_empty(&p_event_wheel->events_wheel)) {
/* Edward Bortnikov 03/29/2003
* ++TBD Consider moving the timer manipulation behind the list manipulation.
*/
/* calculate the new timeout */
timeout =
(p_event->aging_time - cl_get_time_stamp() + 500) / 1000;
/* stop the timer if it is running */
/* Edward Bortnikov 03/29/2003
* Don't call cl_timer_stop() because it spins forever.
* cl_timer_start() will invoke cl_timer_stop() by itself.
*
* The problematic scenario is when __cl_event_wheel_callback()
* is in race condition with this code. It sets timer.in_timer_cb
* to TRUE and then blocks on p_event_wheel->lock. Following this,
* the call to cl_timer_stop() hangs. Following this, the whole system
* enters into a deadlock.
*
* cl_timer_stop(&p_event_wheel->timer);
*/
/* The timeout for the cl_timer_start should be given as uint32_t.
if there is an overflow - warn about it. */
to = (uint32_t) timeout;
if (timeout > (uint32_t) timeout) {
to = 0xffffffff; /* max 32 bit timer */
CL_DBG("cl_event_wheel_reg: timeout requested is "
"too large. Using timeout: %u\n", to);
}
/* start the timer to the timeout [msec] */
cl_status = cl_timer_start(&p_event_wheel->timer, to);
if (cl_status != CL_SUCCESS) {
CL_DBG("cl_event_wheel_reg : ERR 6203: "
"Failed to start timer\n");
goto Exit;
}
}
/* insert the object to the qlist and the qmap */
/* BUT WE MUST INSERT IT IN A SORTED MANNER */
prev_event_list_item =
cl_qlist_find_from_tail(&p_event_wheel->events_wheel,
__event_will_age_before,
&p_event->aging_time);
cl_qlist_insert_next(&p_event_wheel->events_wheel,
prev_event_list_item, &p_event->list_item);
cl_qmap_insert(&p_event_wheel->events_map, key, &(p_event->map_item));
Exit:
cl_spinlock_release(&p_event_wheel->lock);
return cl_status;
}
