Logo Search packages:      
Sourcecode: ibutils version File versions  Download package

server.cpp

/*
 * Copyright (c) 2004 Mellanox Technologies LTD. All rights reserved.
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL) Version 2, available from the file
 * COPYING in the main directory of this source tree, or the
 * OpenIB.org BSD license below:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - Redistributions in binary form must reproduce the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer in the documentation and/or other materials
 *        provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * $Id$
 */

#include "server.h"
#include "msgmgr.h"
#include "helper.h"

//////////////////////////////////////////////////////////////
//
// CLASS  IBMSClientConn
//
#include <fstream>      /* for C++ file IO */
#include <sys/socket.h> /* for socket(), bind(), and connect() */
#include <arpa/inet.h>  /* for sockaddr_in and inet_ntoa() */
#include <unistd.h>     /* for gethostname() */
#include <string.h>     /* for memset() */
#include "sim.h"

/*
  One instance of this class exists for each connected client.
  The instance is created when the client sends the connect message,
  providing the port guid it attaches to.
*/

/* handle client request - should be called under lock */
/* NOTE: to avoid deadlocks we require the node to be
      locked before. We are using special constructor for
      the MADProcessor marking the node is preLocked  */
int
IBMSClientConn::handleBindMsg(
  ibms_bind_msg_t &msg)
{
  MSG_ENTER_FUNC;
  MSGREG(err1, 'E', "Fail to create a new mad processor.", "server");

  /* create a new client mad processor */
  IBMSClientMsgProcessor *madProcessor =
    new IBMSClientMsgProcessor(this, msg);
  if (madProcessor == NULL)
  {
    MSGSND(err1);
    MSG_EXIT_FUNC;
    return 1;
  }

  /* keep track of active mad processors */
  madProcessors.push_back(madProcessor);

  MSG_EXIT_FUNC;
  return 0;
}

/* destructor - needs to cleanup any binding done through this conn */
IBMSClientConn::~IBMSClientConn()
{
  MSG_ENTER_FUNC;
  /* NOTE: each mad processor will lock the node */
  for(list_pmad_proc::iterator lI = madProcessors.begin();
      lI != madProcessors.end();
      lI++)
  {
    delete *lI;
  }
  MSG_EXIT_FUNC;
}

//////////////////////////////////////////////////////////////
//
// CLASS  IBMSServer
//

IBMSServer::IBMSServer(IBMgtSim *pS, unsigned short portNum) :
  GenServer(portNum, sizeof(ibms_client_msg_t))
{
  MSG_ENTER_FUNC;
  char hostName[32];
  gethostname(hostName, sizeof(hostName)-1);

  pSim = pS;

  /* the generic gen server might fail */
  if (isAlive())
  {
    /* write down the server port into the appropriate file */
    std::ofstream serverFile;
    string serverFileName(pSim->getSimulatorDir());
    serverFileName += "/ibmgtsim.server";
    serverFile.open(serverFileName.c_str());
    if (!serverFile.fail())
    {
      serverFile << hostName << " " << portNum << endl;
      serverFile.close();
    }
    else
    {
      MSGREG(err1, 'E', "Fail to create file:$", "server");
      MSGSND(err1, serverFileName);
    }
  }
  MSG_EXIT_FUNC;
}

/* cleaning up client when notified it is closing */
int IBMSServer::closingClient(
  int clientSock)
{
  MSG_ENTER_FUNC;
  map_sock_client::iterator sI = sockToClientMap.find(clientSock);
  if (sI != sockToClientMap.end())
  {
    IBMSClientConn *pClientConn = (*sI).second;
    sockToClientMap.erase(sI);
    delete pClientConn;
  }
  MSG_EXIT_FUNC;
  return(0);
}

/* handle a connection message */
int IBMSServer::handleConnectionMsg(
  int clientSock,
  ibms_conn_msg_t &connMsg)
{
  MSG_ENTER_FUNC;
  MSGREG(err1, 'E', "Given port guid:$ does not exists in fabric.", "server");
  MSGREG(err2, 'E', "Socket $ has previously connected.", "server");
  MSGREG(err3, 'E', "Fail to create client connection.", "server");
  MSGREG(inf1, 'V', "Received connection requests to node:$ port:$.", "server");

  IBFabric *pFabric = pSim->getFabric();

  /* validate the given guid exists */
  map_guid_pport::const_iterator pI =
    pFabric->PortByGuid.find(connMsg.port_guid);
  if (pI == pFabric->PortByGuid.end())
  {
    MSGSND(err1, connMsg.port_guid);
    MSG_EXIT_FUNC;
    return 1;
  }

  IBPort *pPort = (*pI).second;
  IBNode *pNode = pPort->p_node;
  IBMSNode *pMgtNode = ibmsGetIBNodeSimNode(pNode);

  MSGSND(inf1, pNode->name, pPort->num);

  /* we need to lock the map of the server to insert the new client */
  pthread_mutex_lock(&lock);

  /* if the client is not previously registered */
  map_sock_client::iterator sI = sockToClientMap.find(clientSock);
  if (sI != sockToClientMap.end())
  {
    MSGSND(err2, clientSock);
    pthread_mutex_unlock(&lock);
    MSG_EXIT_FUNC;
    return 1;
  }

  /* create a new client object */
  IBMSClientConn *clientConn =
    new IBMSClientConn(pMgtNode, pPort->num,
                       &connMsg.host[0], connMsg.in_msg_port);

  if (clientConn == NULL)
  {
    MSGSND(err3);
    pthread_mutex_unlock(&lock);
    MSG_EXIT_FUNC;
    return 1;
  }

  /* insert to the map */
  sockToClientMap[clientSock] = clientConn;

  /* unlock the map */
  pthread_mutex_unlock(&lock);

  MSG_EXIT_FUNC;
  return 0;
}

/* handle a disconnect message */
int
IBMSServer::handleDisconnectMsg(
  int clientSock,
  ibms_disconn_msg_t &discMsg)
{
  MSG_ENTER_FUNC;
  MSGREG(err1, 'E', "Given port guid:$ does not exists in fabric.", "server");
  MSGREG(err2, 'E', "Socket $ was not previously connected.", "server");
  MSGREG(inf1, 'V', "Received disconnect requests from node:$ port:$.",
         "server");

  IBFabric *pFabric = pSim->getFabric();

  /* validate the given guid exists */
  map_guid_pport::const_iterator pI =
    pFabric->PortByGuid.find(discMsg.port_guid);
  if (pI == pFabric->PortByGuid.end())
  {
    MSGSND(err1, discMsg.port_guid);
    MSG_EXIT_FUNC;
    return 1;
  }

  IBPort *pPort = (*pI).second;
  IBNode *pNode = pPort->p_node;

  MSGSND(inf1, pNode->name, pPort->num);

  /* we need to lock the map of the server to delete the client */
  pthread_mutex_lock(&lock);

  /* if the client is not previously registered */
  map_sock_client::iterator sI = sockToClientMap.find(clientSock);
  if (sI == sockToClientMap.end())
  {
    MSGSND(err2, clientSock);
    pthread_mutex_unlock(&lock);
    MSG_EXIT_FUNC;
    return 1;
  }

  /* remove the connection from the list and delete it */
  IBMSClientConn *clientConn = (*sI).second;
  sockToClientMap.erase(sI);

  /* unlock the map */
  pthread_mutex_unlock(&lock);

  /*
       we need to delete the client itself not under the lock
       since otherwise we will run into deadlock with the node lock
  */
  delete clientConn;

  MSG_EXIT_FUNC;
  return 0;
}

/* handle a bind message */
int
IBMSServer::handleBindMsg(
  int clientSock,
  ibms_bind_msg_t &bindMsg)
{
  MSG_ENTER_FUNC;
  int status;

  MSGREG(err1, 'E', "Socket $ was not previously connected.", "server");

  pthread_mutex_lock(&lock);

  /* find the client conn for the given sock */
  map_sock_client::iterator sI = sockToClientMap.find(clientSock);

  /* if none then fail */
  if (sI == sockToClientMap.end())
  {
    MSGSND(err1, clientSock);
    pthread_mutex_unlock(&lock);
    MSG_EXIT_FUNC;
    return 1;
  }

  IBMSClientConn *pClient = (*sI).second;
  IBMSNode *pSimNode = pClient->pSimNode;

  pthread_mutex_unlock(&lock);

  /* now that we know the client we can pre-lock the node */
  pthread_mutex_lock(&pSimNode->lock);
  pthread_mutex_lock(&lock);

  /* to be safe we find again */
  sI = sockToClientMap.find(clientSock);
  if (sI == sockToClientMap.end())
  {
    MSGSND(err1, clientSock);
    pthread_mutex_unlock(&lock);
       pthread_mutex_unlock(&pSimNode->lock);
    MSG_EXIT_FUNC;
    return 1;
  }

  status = (*sI).second->handleBindMsg(bindMsg);

  pthread_mutex_unlock(&lock);
  pthread_mutex_unlock(&pSimNode->lock);

  MSG_EXIT_FUNC;
  return(status);
}

/* handle a bind message */
int
IBMSServer::handleCapMsg(
  int clientSock,
  ibms_cap_msg_t &capMsg)
{
  MSG_ENTER_FUNC;
  MSGREG(err1, 'E', "Socket $ was not previously connected.", "server");

  pthread_mutex_lock(&lock);

  /* find the client conn for the given sock */
  map_sock_client::iterator sI = sockToClientMap.find(clientSock);

  /* if none then fail */
  if (sI == sockToClientMap.end())
  {
    MSGSND(err1, clientSock);
    pthread_mutex_unlock(&lock);
    MSG_EXIT_FUNC;
    return 1;
  }

  /* if we know the client we know the port number and node */
  IBMSClientConn *pCli = (*sI).second;

  ib_port_info_t *pPortInfo =
    &(pCli->getSimNode()->nodePortsInfo[pCli->getIbPortNum()]);

  pthread_mutex_unlock(&lock);

  /* OK we got the port info - now set/clr the capability mask */
  pPortInfo->capability_mask =
    (~capMsg.mask & pPortInfo->capability_mask) |
    ( capMsg.mask & capMsg.capabilities );

  MSG_EXIT_FUNC;
  return(0);
}

/* handle a mad message */
int
IBMSServer::handleMadMsg(
  int clientSock,
  ibms_mad_msg_t &madMsg)
{
  MSG_ENTER_FUNC;
  int status;
  MSGREG(err1, 'E', "Socket $ was not previously connected.", "server");

  pthread_mutex_lock(&lock);

  /* find the client conn for the given sock */
  map_sock_client::iterator sI = sockToClientMap.find(clientSock);

  /* if none then fail */
  if (sI == sockToClientMap.end())
  {
    MSGSND(err1, clientSock);
    pthread_mutex_unlock(&lock);
    MSG_EXIT_FUNC;
    return 1;
  }

  IBMSClientConn *pClientConn = (*sI).second;

  /* we need to replace the source lid with the lid of the port */
  madMsg.addr.slid =
    cl_hton16(
      pClientConn->getSimNode()->nodePortsInfo[pClientConn->getIbPortNum()].base_lid);

  status = pSim->getDispatcher()->dispatchMad(
    pClientConn->getSimNode(),
    pClientConn->getIbPortNum(),
    madMsg);

  pthread_mutex_unlock(&lock);

  MSG_EXIT_FUNC;
  return status;
}

/* handle client request -
   either create a new client conn or pass it there */
/* return 1 on error 0 otherwise */
int IBMSServer::proccessClientMsg(
  int clientSock,
  int reqLen, char request[],
  int &resLen, char *(pResponse[]) )
{

  MSG_ENTER_FUNC;
  MSGREG(err1, 'E', "Message is not of ibms_client_msg_t size ($ != $)",
         "server");
  MSGREG(inf1, 'V', "Received:\n$","server");

  if (reqLen != sizeof(ibms_client_msg_t))
  {
    MSGSND(err1, reqLen, sizeof(ibms_client_msg_t));
    MSG_EXIT_FUNC;
    return 1;
  }

  ibms_client_msg_t *p_req = (ibms_client_msg_t*)request;
  MSGSND(inf1, ibms_get_msg_str(p_req));

  /* allocate new response */
  /* NOTE: the allocated buffer for the response is deallocated by
     the call from the GenServer::clientThreadMain */
  resLen = sizeof(ibms_response_t);
  *pResponse = new char[sizeof(ibms_response_t)];
  ibms_response_t *pResp = (ibms_response_t *)(*pResponse);
  memset(pResp, 0, sizeof(ibms_response_t));

  switch (p_req->msg_type)
  {
  case IBMS_CLI_MSG_CONN:
    pResp->status = handleConnectionMsg(clientSock, p_req->msg.conn);
    break;
  case IBMS_CLI_MSG_DISCONN:
    pResp->status = handleDisconnectMsg(clientSock, p_req->msg.disc);
    break;
  case IBMS_CLI_MSG_BIND:
    pResp->status = handleBindMsg(clientSock, p_req->msg.bind);
    break;
  case IBMS_CLI_MSG_CAP:
    pResp->status = handleCapMsg(clientSock, p_req->msg.cap);
    break;
  case IBMS_CLI_MSG_MAD:
    pResp->status = handleMadMsg(clientSock, p_req->msg.mad);
    break;
  case IBMS_CLI_MSG_QUIT:
    MSGREG(inf2, 'V', "Asked to quit. Quitting...","server");
    MSGSND(inf2);
    usleep(100000);
    exit(0);
    break;
  default:
    break;
  }

  /* we always succeed for now */

  MSG_EXIT_FUNC;
  return 0;
}

//////////////////////////////////////////////////////////////
//
// CLASS  IBMSClientMsgProcessor
//

/*
  Specialization of IBMSMadProcessor - this processor is being created
  for each "BIND" command requested by the client. It should handle
  forwarding of the MAD that it got to the client by invoking the
  client send method.
*/

/* if filter is matched - forward the mad msg to the client send() */
int
IBMSClientMsgProcessor::processMad(
  uint8_t inPort,
  ibms_mad_msg_t &madMsg)
{
  MSG_ENTER_FUNC;

  ibms_response_t response;
  ibms_client_msg_t fwdMsg;
  int respSize;

  MSGREG(inf1, 'V', "Forwarding MAD tid:$ to client node:$ port:$","server");
  MSGREG(inf2, 'V', "Ignoring MAD tid:$ node:$ port:$ != cli port:$","server");

  fwdMsg.msg_type = IBMS_CLI_MSG_MAD;
  fwdMsg.msg.mad = madMsg;

  IBNode *pNode = pClient->getSimNode()->getIBNode();

  /* ignore mads arriving on the other port */
  if ((inPort != 0) && (pClient->getIbPortNum() != inPort))
  {
    MSGSND(inf2, cl_ntoh64(fwdMsg.msg.mad.header.trans_id),
           pNode->name, inPort, pClient->getIbPortNum());
    MSG_EXIT_FUNC;
    return 0;
  }

  MSGSND(inf1, cl_ntoh64(fwdMsg.msg.mad.header.trans_id),
         pNode->name, pClient->getIbPortNum());

  /* get the clientConn object */
  /* invoke its sendMsg with the provided message */
  pClient->sendMsg(sizeof(ibms_client_msg_t), (char*)&fwdMsg,
                   respSize, (char *)&response);

  MSG_EXIT_FUNC;
  return 0;
}

Generated by  Doxygen 1.6.0   Back to index