static uint64_t __osmv_txn_timeout_cb(IN uint64_t key, IN uint32_t num_regs, IN void *cb_context) { osmv_bind_obj_t *p_bo = (osmv_bind_obj_t *) cb_context; uint64_t ret = 0; osmv_txn_ctx_t *p_txn; osmv_rmpp_send_ctx_t *p_send_ctx; osm_madw_t *p_madw = NULL; ib_mad_t *p_mad; osm_mad_addr_t *p_mad_addr; boolean_t invoke_err_cb = FALSE; OSM_LOG_ENTER(p_bo->p_vendor->p_log); /* Don't try to acquire a lock on the Bind Object - * it's taken by the mechanism that drives the timeout based events! * (Recall the special constructor that the Event Wheel is applied with) */ if (p_bo->is_closing) { goto txn_done; } ret = osmv_txn_lookup(p_bo, key, &p_txn); if (IB_NOT_FOUND == ret) { /* Prevent a race - the transaction is already destroyed */ goto txn_done; } p_madw = p_txn->p_madw; switch (osmv_txn_get_rmpp_state(p_txn)) { case OSMV_TXN_RMPP_NONE: if (num_regs <= OSMV_MAX_RETRANSMIT) { /* We still did not exceed the limit of retransmissions. * Set the next timeout's value. */ osm_log(p_bo->p_vendor->p_log, OSM_LOG_DEBUG, "__osmv_txn_timeout_cb: " "The transaction request (tid=0x%llX) timed out %d times. " "Retrying the send.\n", osmv_txn_get_tid(p_txn), num_regs); /* resend this mad */ ret = osmv_simple_send_madw((osm_bind_handle_t *) p_bo, p_madw, p_txn, TRUE); if (ret != IB_SUCCESS) { osm_log(p_bo->p_vendor->p_log, OSM_LOG_ERROR, "__osmv_txn_timeout_cb: " "Fail to send retry for transaction request (tid=0x%llX).\n", osmv_txn_get_tid(p_txn)); osmv_txn_done((osm_bind_handle_t) p_bo, key, TRUE /*in timeout callback */ ); /* This is a requester. Always apply the callback */ invoke_err_cb = TRUE; } else { uint64_t next_timeout_ms; next_timeout_ms = p_bo->p_vendor->resp_timeout * (num_regs + 1) * (num_regs + 1); /* when do we need to timeout again */ ret = cl_get_time_stamp() + (uint64_t) (1000 * next_timeout_ms); osm_log(p_bo->p_vendor->p_log, OSM_LOG_DEBUG, "__osmv_txn_timeout_cb: " "Retry request timout in : %lu [msec].\n", next_timeout_ms); } } else { osm_log(p_bo->p_vendor->p_log, OSM_LOG_ERROR, "__osmv_txn_timeout_cb: ERR 6702: " "The transaction request (tid=0x%llX) timed out (after %d retries). " "Invoking the error callback.\n", osmv_txn_get_tid(p_txn), num_regs); osmv_txn_done((osm_bind_handle_t) p_bo, key, TRUE /*in timeout callback */ ); /* This is a requester. Always apply the callback */ invoke_err_cb = TRUE; } break; case OSMV_TXN_RMPP_SENDER: osm_log(p_bo->p_vendor->p_log, OSM_LOG_DEBUG, "RMPP sender (tid=0x%llX) did not receive ACK " "on every segment in the current send window.\n", osmv_txn_get_tid(p_txn)); p_send_ctx = osmv_txn_get_rmpp_send_ctx(p_txn); if (num_regs <= OSMV_MAX_RETRANSMIT) { /* We still did not exceed the limit of retransmissions. * Set the next timeout's value. */ ret = cl_get_time_stamp() + 1000 * p_bo->p_vendor->resp_timeout; } else { p_send_ctx->status = IB_TIMEOUT; p_mad = osm_madw_get_mad_ptr(p_madw); p_mad_addr = osm_madw_get_mad_addr_ptr(p_madw); /* Send an ABORT to the other side */ osmv_rmpp_send_nak((osm_bind_handle_t) p_bo, p_mad, p_mad_addr, IB_RMPP_TYPE_ABORT, IB_RMPP_STATUS_T2L); } /* Wake the RMPP sender thread up */ cl_event_signal(&p_send_ctx->event); break; case OSMV_TXN_RMPP_RECEIVER: osm_log(p_bo->p_vendor->p_log, OSM_LOG_DEBUG, "Transaction timeout on an RMPP receiver (tid=0x%llX). " "Dropping the transaction.\n", osmv_txn_get_tid(p_txn)); osmv_txn_done((osm_bind_handle_t) p_bo, key, TRUE /*in timeout callback */ ); if (FALSE == osmv_txn_is_rmpp_init_by_peer(p_txn)) { /* This is a requester, still waiting for the reply. Apply the callback */ invoke_err_cb = TRUE; } break; default: CL_ASSERT(FALSE); } if (TRUE == invoke_err_cb) { CL_ASSERT(NULL != p_madw); /* update the status in the p_madw */ p_madw->status = IB_TIMEOUT; p_bo->send_err_cb(p_bo->cb_context, p_madw); /* no re-registration */ ret = 0; } txn_done: OSM_LOG_EXIT(p_bo->p_vendor->p_log); return ret; }
static void __osmv_dispatch_rmpp_mad(IN osm_bind_handle_t h_bind, IN const ib_mad_t * p_mad, IN osmv_txn_ctx_t * p_txn, IN const osm_mad_addr_t * p_mad_addr) { ib_api_status_t status = IB_SUCCESS; uint64_t key = cl_ntoh64(p_mad->trans_id); boolean_t is_init_by_peer = FALSE; osmv_bind_obj_t *p_bo = (osmv_bind_obj_t *) h_bind; osm_madw_t *p_madw; OSM_LOG_ENTER(p_bo->p_vendor->p_log); if (NULL == p_txn) { if (FALSE == osmv_rmpp_is_data(p_mad) || FALSE == osmv_rmpp_is_first(p_mad)) { osm_log(p_bo->p_vendor->p_log, OSM_LOG_DEBUG, "The MAD does not match any transaction " "and does not start a sender-initiated RMPP transfer.\n"); goto dispatch_rmpp_mad_done; } /* IB Spec 13.6.2.2. This is a Sender Initiated Transfer. My peer is the requester and RMPP Sender. I am the RMPP Receiver. */ status = osmv_txn_init(h_bind, /*tid==key */ key, key, &p_txn); if (IB_SUCCESS != status) { goto dispatch_rmpp_mad_done; } is_init_by_peer = TRUE; osm_log(p_bo->p_vendor->p_log, OSM_LOG_DEBUG, "A new sender-initiated transfer (TID=0x%" PRIx64 ") started\n", key); } if (OSMV_TXN_RMPP_NONE == osmv_txn_get_rmpp_state(p_txn)) { /* Case 1: Fall through from above. * Case 2: When the transaction was initiated by me * (a single request MAD), there was an uncertainty * whether the reply will be RMPP. Now it's resolved, * since the reply is RMPP! */ status = osmv_txn_init_rmpp_receiver(h_bind, p_txn, is_init_by_peer); if (IB_SUCCESS != status) { goto dispatch_rmpp_mad_done; } } switch (osmv_txn_get_rmpp_state(p_txn)) { case OSMV_TXN_RMPP_RECEIVER: status = __osmv_dispatch_rmpp_rcv(h_bind, p_mad, p_txn, p_mad_addr); if (IB_SUCCESS != status) { if (FALSE == osmv_txn_is_rmpp_init_by_peer(p_txn)) { /* This is a requester, still waiting for the reply. Apply the callback */ /* update the status of the p_madw */ p_madw = osmv_txn_get_madw(p_txn); p_madw->status = status; p_bo->send_err_cb(p_bo->cb_context, p_madw); } /* ABORT/STOP/LOCAL ERROR */ osmv_txn_done(h_bind, osmv_txn_get_key(p_txn), FALSE); } break; case OSMV_TXN_RMPP_SENDER: __osmv_dispatch_rmpp_snd(h_bind, p_mad, p_txn, p_mad_addr); /* If an error happens here, it's the sender thread to cleanup the txn */ break; default: CL_ASSERT(FALSE); } dispatch_rmpp_mad_done: OSM_LOG_EXIT(p_bo->p_vendor->p_log); }