hermon_agents.c revision 9e39c5ba00a55fa05777cc94b148296af305e135
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Hermon InfiniBand Management Agent (SMA, PMA, BMA) routines
*
* Implements all the routines necessary for initializing, handling,
* and (later) tearing down all the infrastructure necessary for Hermon
* MAD processing.
*/
static void hermon_agent_handle_req(void *cb_args);
/*
* hermon_agent_handlers_init()
*/
int
{
int status;
char *rsrc_name;
/* Determine if we need to register any agents with the IBMF */
return (DDI_SUCCESS);
}
/*
* Build a unique name for the Hermon task queue from the Hermon driver
* instance number and HERMON_TASKQ_NAME
*/
/* Initialize the Hermon IB management agent list */
if (status != DDI_SUCCESS) {
goto agentsinit_fail;
}
/*
* Initialize the agent handling task queue. Note: We set the task
* queue priority to the minimum system priority. At this point this
* is considered acceptable because MADs are unreliable datagrams
* and could get lost (in general) anyway.
*/
goto agentsinit_fail;
}
/* Now attempt to register all of the agents with the IBMF */
if (status != DDI_SUCCESS) {
goto agentsinit_fail;
}
return (DDI_SUCCESS);
return (status);
}
/*
* hermon_agent_handlers_fini()
* Context: Only called from detach() path context
*/
int
{
int status;
/* Determine if we need to unregister any agents from the IBMF */
return (DDI_SUCCESS);
}
/* Now attempt to unregister all of the agents from the IBMF */
if (status != DDI_SUCCESS) {
return (DDI_FAILURE);
}
/*
* Destroy the task queue. The task queue destroy is guaranteed to
* wait until any scheduled tasks have completed. We are able to
* guarantee that no _new_ tasks will be added the task queue while
* we are in the ddi_taskq_destroy() call because we have
* (at this point) successfully unregistered from IBMF (in
* hermon_agent_unregister_all() above).
*/
/* Teardown the Hermon IB management agent list */
return (DDI_SUCCESS);
}
/*
* hermon_agent_request_cb()
* Context: Called from the IBMF context
*/
static void
void *args)
{
int status;
/*
* Allocate space to hold the callback args (for passing to the
* task queue). Note: If we are unable to allocate space for the
* the callback args here, then we just return. But we must ensure
* that we call ibmf_free_msg() to free up the message.
*/
sizeof (hermon_agent_handler_arg_t), KM_NOSLEEP);
return;
}
/* Fill in the callback args */
/*
* Dispatch the message to the task queue. Note: Just like above,
* if this request fails for any reason then make sure to free up
* the IBMF message and then return
*/
if (status == DDI_FAILURE) {
}
}
/*
* hermon_get_smlid()
* Simple helper function for hermon_agent_handle_req() below.
* Get the portinfo and extract the smlid.
*/
static ib_lid_t
{
int status;
if (status != HERMON_CMD_SUCCESS) {
return (0);
}
return (portinfo.MasterSMLID);
}
/*
* hermon_agent_handle_req()
* Context: Called with priority of taskQ thread
*/
static void
hermon_agent_handle_req(void *cb_args)
{
int status;
/* Extract the necessary info from the callback args parameter */
/*
* Set the message send buffer pointers to the message receive buffer
* pointers to reuse the IBMF provided buffers for the sender
* information.
*/
/*
* Check if the incoming packet is a special "Hermon Trap" MAD. If it
* is, then do the special handling. If it isn't, then simply pass it
* on to the firmware and forward the response back to the IBMF.
*
* Note: Hermon has a unique method for handling internally generated
* automatically received by the IBMF (as receive completions on QP0),
* which (because all Hermon Trap MADs have SLID == 0) detects it as a
* special "Hermon Trap" and forwards it here to the driver's SMA.
* It is then our responsibility here to fill in the Trap MAD's DLID
* for forwarding to the real Master SM (as programmed in the port's
* PortInfo.MasterSMLID field.)
*/
if (HERMON_IS_SPECIAL_TRAP_MAD(msgp)) {
} else {
/*
* Post the command to the firmware (using the MAD_IFC
* command). Note: We also reuse the command that was passed
* in. We pass the pointer to the original MAD payload as if
* it were both the source of the incoming MAD as well as the
* destination for the response. This is acceptable and saves
* us the step of one additional copy. Note: If this command
* fails for any reason other than HERMON_CMD_BAD_PKT, it
* probably indicates a serious problem.
*/
if (status != HERMON_CMD_SUCCESS) {
if ((status != HERMON_CMD_BAD_PKT) &&
(status != HERMON_CMD_INSUFF_RSRC)) {
}
/* finish cleanup */
}
}
/*
* If incoming MAD was "TrapRepress", then no response is necessary.
* Free the IBMF message and return.
*/
if (HERMON_IS_TRAP_REPRESS_MAD(msgp)) {
}
/*
* Modify the response MAD as necessary (for any special cases).
* Specifically, if this MAD was a directed route MAD, then some
* additional packet manipulation may be necessary because the Hermon
* firmware does not do all the required steps to respond to the
* MAD.
*/
/*
* Send response (or forwarded "Trap" MAD) back to IBMF. We use the
* "response callback" to indicate when it is appropriate (later) to
* free the IBMF msg.
*/
if (status != IBMF_SUCCESS) {
}
/* Free up the callback args parameter */
return;
/* Free up the ibmf message */
/* Free up the callback args parameter */
}
/*
* hermon_agent_response_cb()
* Context: Called from the IBMF context
*/
/* ARGSUSED */
static void
void *args)
{
/*
* It is the responsibility of each IBMF callback recipient to free
* the packets that it has been given. Now that we are in the
* response callback, we can be assured that it is safe to do so.
*/
}
/*
* hermon_agent_list_init()
* Context: Only called from attach() path context
*/
static int
{
uint_t num_sma_agents = 0;
uint_t num_pma_agents = 0;
uint_t num_bma_agents = 0;
int i, j, indx;
/*
* Calculate the number of registered agents for each port
* (SMA, PMA, and BMA) and determine whether or not to register
* a given agent with the IBMF (or whether to let the Hermon firmware
* handle it)
*/
num_agents = 0;
num_agents_per_port = 0;
if (do_qp0 == 0) {
}
if (do_qp1 == 0) {
/*
* The following line is commented out because the Hermon
* firmware does not currently support a BMA. If it did,
* then we would want to register the agent with the IBMF.
* (We would also need to have HERMON_NUM_QP1_AGENTS_PER_PORT
* set to 2, instead of 1.)
*
* num_bma_agents = num_ports;
*/
}
/*
* Allocate the memory for all of the agent list entries
*/
sizeof (hermon_agent_list_t), KM_SLEEP);
return (DDI_FAILURE);
}
/*
* Fill in each of the agent list entries with the agent's
* MgmtClass, port number, and Hermon softstate pointer
*/
indx = 0;
for (i = 0; i < num_agents_per_port; i++) {
for (j = 0; j < num_ports; j++) {
if ((do_qp0 == 0) && num_sma_agents) {
indx++;
} else if ((do_qp1 == 0) && (num_pma_agents)) {
indx++;
} else if ((do_qp1 == 0) && (num_bma_agents)) {
indx++;
}
}
}
return (DDI_SUCCESS);
}
/*
* hermon_agent_list_fini()
*/
static void
{
/* Free up the memory for the agent list entries */
}
/*
* hermon_agent_register_all()
* Context: Only called from attach() path context
*/
static int
{
int i, status, num_registered;
/* Get the Hermon NodeGUID from the softstate */
/*
* Register each of the agents with the IBMF (and add callbacks for
* each to the hermon_agent_request_cb() routine). Note: If we
* fail somewhere along the line here, we attempt to cleanup as much
* of the mess as we can and then jump to hermon_agent_unregister_all()
* to cleanup the rest.
*/
num_registered = 0;
if (state->hs_num_agents == 0) {
return (DDI_SUCCESS);
}
for (i = 0; i < state->hs_num_agents; i++) {
/* Register each agent with the IBMF */
if (status != IBMF_SUCCESS) {
goto agents_reg_fail;
}
/* Setup callbacks with the IBMF */
if (status != IBMF_SUCCESS) {
goto agents_reg_fail;
}
}
return (DDI_SUCCESS);
return (DDI_FAILURE);
}
/*
* hermon_agent_unregister_all()
* Context: Only called from detach() path context
*/
static int
{
int i, status;
if (num_reg == 0) {
return (DDI_SUCCESS);
}
/*
* For each registered agent in the agent list, teardown the
* callbacks from the IBMF and unregister.
*/
for (i = 0; i < num_reg; i++) {
/* Teardown the IBMF callback */
if (status != IBMF_SUCCESS) {
return (DDI_FAILURE);
}
/* Unregister the agent from the IBMF */
if (status != IBMF_SUCCESS) {
return (DDI_FAILURE);
}
}
return (DDI_SUCCESS);
}
/*
* hermon_agent_mad_resp_handling()
* Context: Called with priority of taskQ thread
*/
/* ARGSUSED */
static void
{
/*
* Handle directed route MADs as a special case. Hermon firmware
* does not update the "direction" bit, "hop pointer", "Return
* Path" or, in fact, any of the "directed route" parameters. So
* the responsibility falls on Hermon driver software to inspect the
* MADs and update those fields as appropriate (see section 14.2.2
* of the IBA specification, rev 1.1)
*/
if (HERMON_MAD_IS_DR(rmadhdrp)) {
/*
* Set the "Direction" bit to one. This indicates that this
* is now directed route response
*/
/* Extract the "hop pointer" and "hop count" from the MAD */
/* Append the port we came in on to the "Return Path" */
}
/* Then increment the "hop pointer" in the MAD */
hop_point++;
}
}