Example #1
0
osm_madw_t *osm_mad_pool_get_wrapper(IN osm_mad_pool_t * const p_pool,
                                     IN osm_bind_handle_t h_bind,
                                     IN const uint32_t total_size,
                                     IN const ib_mad_t * const p_mad,
                                     IN const osm_mad_addr_t * const p_mad_addr)
{
    osm_madw_t *p_madw;

    CL_ASSERT(h_bind != OSM_BIND_INVALID_HANDLE);
    CL_ASSERT(total_size);
    CL_ASSERT(p_mad);

    /*
       First, acquire a mad wrapper from the mad wrapper pool.
     */
    p_madw = malloc(sizeof(*p_madw));
    if (p_madw == NULL)
        goto Exit;

    /*
       Finally, initialize the wrapper object.
     */
    cl_atomic_inc(&p_pool->mads_out);
    osm_madw_init(p_madw, h_bind, total_size, p_mad_addr);
    osm_madw_set_mad(p_madw, p_mad);

Exit:
    return (p_madw);
}
Example #2
0
osm_madw_t *osm_mad_pool_get_wrapper_raw(IN osm_mad_pool_t * const p_pool)
{
    osm_madw_t *p_madw;

    p_madw = malloc(sizeof(*p_madw));
    if (!p_madw)
        return NULL;

    osm_madw_init(p_madw, 0, 0, 0);
    osm_madw_set_mad(p_madw, 0);
    cl_atomic_inc(&p_pool->mads_out);

    return (p_madw);
}
Example #3
0
osm_madw_t *osm_mad_pool_get(IN osm_mad_pool_t * const p_pool,
                             IN osm_bind_handle_t h_bind,
                             IN const uint32_t total_size,
                             IN const osm_mad_addr_t * const p_mad_addr)
{
    osm_madw_t *p_madw;
    ib_mad_t *p_mad;

    CL_ASSERT(h_bind != OSM_BIND_INVALID_HANDLE);
    CL_ASSERT(total_size);

    /*
       First, acquire a mad wrapper from the mad wrapper pool.
     */
    p_madw = malloc(sizeof(*p_madw));
    if (p_madw == NULL)
        goto Exit;

    osm_madw_init(p_madw, h_bind, total_size, p_mad_addr);

    /*
       Next, acquire a wire mad of the specified size.
     */
    p_mad = osm_vendor_get(h_bind, total_size, &p_madw->vend_wrap);
    if (p_mad == NULL) {
        /* Don't leak wrappers! */
        free(p_madw);
        p_madw = NULL;
        goto Exit;
    }

    cl_atomic_inc(&p_pool->mads_out);
    /*
       Finally, attach the wire MAD to this wrapper.
     */
    osm_madw_set_mad(p_madw, p_mad);

Exit:
    return p_madw;
}
Example #4
0
static void
__osm_al_rcv_callback(IN void *mad_svc_context, IN ib_mad_element_t * p_elem)
{
	osm_al_bind_info_t *const p_bind =
	    (osm_al_bind_info_t *) mad_svc_context;
	osm_vendor_t *const p_vend = p_bind->p_vend;
	osm_madw_t *p_old_madw;
	osm_madw_t *p_new_madw;
	osm_vend_wrap_t *p_old_vw;
	osm_vend_wrap_t *p_new_vw;
	ib_mad_t *p_new_mad;
	osm_mad_addr_t mad_addr;

	OSM_LOG_ENTER(p_vend->p_log);

	CL_ASSERT(p_elem->context1 == NULL);
	CL_ASSERT(p_elem->context2 == NULL);

	p_new_mad = ib_get_mad_buf(p_elem);

	/*
	   In preperation for initializing the new mad wrapper,
	   Initialize the mad_addr structure for the received wire MAD.
	 */
	mad_addr.dest_lid = p_elem->remote_lid;
	mad_addr.path_bits = p_elem->path_bits;

	/* TO DO - figure out which #define to use for the 2.5 Gb rate... */
	mad_addr.static_rate = 0;

	if (p_new_mad->mgmt_class == IB_MCLASS_SUBN_LID ||
	    p_new_mad->mgmt_class == IB_MCLASS_SUBN_DIR) {
		mad_addr.addr_type.smi.source_lid = p_elem->remote_lid;
	} else {
		mad_addr.addr_type.gsi.remote_qp = p_elem->remote_qp;
		mad_addr.addr_type.gsi.remote_qkey = p_elem->remote_qkey;
		mad_addr.addr_type.gsi.pkey_ix = p_elem->pkey_index;
		mad_addr.addr_type.gsi.service_level = p_elem->remote_sl;
		mad_addr.addr_type.gsi.global_route = FALSE;
	}

	/*
	   If this MAD is a response to a previous request,
	   then grab our pre-allocated MAD wrapper.
	   Otherwise, allocate a new MAD wrapper.
	 */
	if (ib_mad_is_response(p_new_mad)) {
		CL_ASSERT(p_elem->send_context1 != NULL);
		CL_ASSERT(p_elem->send_context2 == NULL);

		p_old_madw = (osm_madw_t *) p_elem->send_context1;
		p_old_vw = osm_madw_get_vend_ptr(p_old_madw);
		p_new_madw = p_old_vw->p_resp_madw;

		CL_ASSERT(p_new_madw);

		osm_madw_init(p_new_madw, p_bind, p_elem->size, &mad_addr);
		osm_madw_set_mad(p_new_madw, p_new_mad);
	} else {
		CL_ASSERT(p_elem->send_context1 == NULL);
		CL_ASSERT(p_elem->send_context2 == NULL);

		p_new_madw = osm_mad_pool_get_wrapper(p_bind->p_osm_pool,
						      p_bind, p_elem->size,
						      p_new_mad, &mad_addr);
	}

	CL_ASSERT(p_new_madw);
	p_new_vw = osm_madw_get_vend_ptr(p_new_madw);

	p_new_vw->h_bind = p_bind;
	p_new_vw->size = p_elem->size;
	p_new_vw->p_elem = p_elem;
	p_new_vw->h_av = 0;
	p_new_vw->p_resp_madw = NULL;

	osm_log(p_vend->p_log, OSM_LOG_DEBUG,
		"__osm_al_rcv_callback: "
		"Calling receive callback function %p.\n",
		p_bind->rcv_callback);

	p_bind->rcv_callback(p_new_madw, p_bind->client_context,
			     p_elem->send_context1);

	OSM_LOG_EXIT(p_vend->p_log);
}