vipconnectpeerrequest.c

Go to the documentation of this file.

/********************************************************
 * Myricom VI-GM  networking software and documentation *
 * Copyright (c) 2001 by Myricom, Inc.                  *
 * All rights reserved.                                 *
 * See the file `COPYING' for copyright notice.         *
 ********************************************************/

#include <string.h>

#include "vipl_priv.h"


VIP_ENTRY_POINT VIP_RETURN
VipConnectPeerRequest (VIP_VI_HANDLE ViHandle,
                       VIP_NET_ADDRESS * LocalAddr,
                       VIP_NET_ADDRESS * RemoteAddr, VIP_ULONG Timeout)
{
  VIP_VI *vip_vi_ptr;
  VIP_GM *vip_gm_ptr;
  VIP_NIC *vip_nic_ptr;
  VIP_CONN *vip_conn_ptr;
  VIP_UINT32 remote_gm_id;
  VIP_UINT32 conn_mgr_node_id;
  VIP_UCHAR *gm_name_ptr;
  VIP_UCHAR gm_name[GM_MAX_HOST_NAME_LEN];
  VIP_SEND_REQ *vip_send_req_ptr;
  VIP_PACKET_CONN_LIST *pkt_list_ptr;
  gm_status_t gm_status;
  VIP_DEBUG_LABEL (("VipConnectPeerRequest"));


  if (LocalAddr == NULL)
    {
      VIP_DEBUG (("LocalAddr is NULL"));
      return VIP_INVALID_PARAMETER;
    }

  if (RemoteAddr == NULL)
    {
      VIP_DEBUG (("RemoteAddr is NULL"));
      return VIP_INVALID_PARAMETER;
    }

  if (Timeout == 0)
    {
      VIP_DEBUG (("Timeout 0"));
      return VIP_INVALID_PARAMETER;
    }

  /* check local address (host part) */
  if (LocalAddr->HostAddressLen != VI_GM_MAC_ADDRESS_LEN)
    {
      VIP_DEBUG (("Local Host Address Length is invalid (should be %d)",
                  VI_GM_MAC_ADDRESS_LEN));
      return VIP_INVALID_PARAMETER;
    }

  /* check local address (discriminator part) */
  if (LocalAddr->DiscriminatorLen > VI_GM_MAX_DISCRIMINATOR_LEN)
    {
      VIP_DEBUG (("Local Discriminator Length is too large (max=%d)",
                  VI_GM_MAX_DISCRIMINATOR_LEN));
      return VIP_INVALID_PARAMETER;
    }

  /* check remote address (host part) */
  if (RemoteAddr->HostAddressLen != VI_GM_MAC_ADDRESS_LEN)
    {
      VIP_DEBUG (("Remote Host Address Length is invalid (should be %d)",
                  VI_GM_MAC_ADDRESS_LEN));
      return VIP_INVALID_PARAMETER;
    }

  /* check remote address (discriminator part) */
  if (RemoteAddr->DiscriminatorLen > VI_GM_MAX_DISCRIMINATOR_LEN)
    {
      VIP_DEBUG (("Remote Discriminator Length is too large (max=%d)",
                  VI_GM_MAX_DISCRIMINATOR_LEN));
      return VIP_INVALID_PARAMETER;
    }

  /* check VI handle */
  vip_vi_ptr = (VIP_VI *) ViHandle;
  if (VIP_INVALID_VI_HANDLE (vip_vi_ptr))
    {
      VIP_DEBUG (("Invalid VI handle"));
      return VIP_INVALID_PARAMETER;
    }
  vip_nic_ptr = vip_vi_ptr->handle.vip_nic_ptr;
  vip_gm_ptr = vip_nic_ptr->vip_gm_ptr;
  VIP_MUTEX_LOCK (&(vip_gm_ptr->lock));
  VIP_PROGRESSION (vip_gm_ptr);
  VIP_MUTEX_LOCK (&(vip_nic_ptr->lock));

  /* check VI state */
  if (vip_vi_ptr->state != VIP_STATE_IDLE)
    {
      VIP_DEBUG (("VI is not in IDLE state"));
      VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
      VIP_MUTEX_UNLOCK (&(vip_gm_ptr->lock));
      return VIP_INVALID_STATE;
    }

  /* check NIC address consistency */
  if (memcmp (vip_gm_ptr->mac_address,
              LocalAddr->HostAddress, LocalAddr->HostAddressLen) != 0)
    {
      VIP_DEBUG (("Host Address does not match NIC id"));
      VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
      VIP_MUTEX_UNLOCK (&(vip_gm_ptr->lock));
      return VIP_INVALID_PARAMETER;
    }

  /* allocate conn handle */
  vip_conn_ptr = (VIP_CONN *)
    vip_allocate_handle (&(vip_nic_ptr->vip_conn_set));
  if (vip_conn_ptr == NULL)
    {
      VIP_DEBUG (("VIP_CONN alloc failed"));
      VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
      VIP_MUTEX_UNLOCK (&(vip_gm_ptr->lock));
      return VIP_ERROR_RESOURCE;
    }

  vip_conn_ptr->next_waiting_conn_ptr = NULL;
  vip_conn_ptr->remote_vi_attribs.ReliabilityLevel = vip_vi_ptr->reliability;
  vip_conn_ptr->remote_vi_attribs.MaxTransferSize = vip_vi_ptr->mtu;
  vip_conn_ptr->remote_vi_attribs.QoS = vip_vi_ptr->qos;
  vip_conn_ptr->remote_vi_attribs.EnableRdmaRead = VIP_FALSE;
  vip_conn_ptr->locale_disc_len = LocalAddr->DiscriminatorLen;
  memcpy (vip_conn_ptr->locale_net_addr, LocalAddr->HostAddress,
          VI_GM_MAC_ADDRESS_LEN + LocalAddr->DiscriminatorLen);
  vip_conn_ptr->remote_disc_len = RemoteAddr->DiscriminatorLen;
  memcpy (vip_conn_ptr->remote_net_addr, RemoteAddr->HostAddress,
          VI_GM_MAC_ADDRESS_LEN + RemoteAddr->DiscriminatorLen);
  vip_conn_ptr->remote_port_id = 1;
  vip_conn_ptr->type = VIP_CONN_TYPE_PEER;
  vip_conn_ptr->status = VIP_NOT_DONE;
  vip_conn_ptr->vip_vi_ptr = vip_vi_ptr;
  VIP_EVENT_INIT (&(vip_conn_ptr->event));

  gm_initialize_alarm (&(vip_conn_ptr->peer_timeout_alarm));

  /* insert connection in the waiting list */
  if (vip_gm_ptr->head_waiting_conn_ptr == NULL)
    {
      VIP_ASSERT (vip_gm_ptr->tail_waiting_conn_ptr == NULL);
      vip_gm_ptr->head_waiting_conn_ptr = vip_conn_ptr;
      vip_gm_ptr->tail_waiting_conn_ptr = vip_conn_ptr;
      vip_conn_ptr->prev_waiting_conn_ptr = NULL;
    }
  else
    {
      VIP_ASSERT (vip_gm_ptr->tail_waiting_conn_ptr != NULL);
      vip_gm_ptr->tail_waiting_conn_ptr->next_waiting_conn_ptr = vip_conn_ptr;
      vip_conn_ptr->prev_waiting_conn_ptr = vip_gm_ptr->tail_waiting_conn_ptr;
      vip_gm_ptr->tail_waiting_conn_ptr = vip_conn_ptr;
    }
  vip_conn_ptr->waiting_list = VIP_TRUE;

  vip_vi_ptr->conn_ptr = vip_conn_ptr;
  vip_vi_ptr->state = VIP_STATE_CONNECT_PENDING;

  /* look if we know the remote end */
  VIP_ENTER_IOCTL (vip_gm_ptr);
  gm_status = gm_unique_id_to_node_id (vip_gm_ptr->gm_port,
                                       RemoteAddr->HostAddress,
                                       &remote_gm_id);

  if ((remote_gm_id == GM_NO_SUCH_NODE_ID) || (gm_status != GM_SUCCESS))
    {
      goto out_with_unknown_remote_endpoint;
    }

  VIP_MUTEX_LOCK (&vip_gm_host_name_lock);
  gm_name_ptr = gm_node_id_to_host_name (vip_gm_ptr->gm_port, remote_gm_id);

  /* check if we really know it, gm_unique_id_to_node_id is not reliable */
  if (gm_name_ptr == NULL)
    {
      VIP_MUTEX_UNLOCK (&vip_gm_host_name_lock);
      goto out_with_unknown_remote_endpoint;
    }

  /* we know the remote NIC, try to connect */
  if (strchr (gm_name_ptr, ':') != NULL)
    {
      strcpy (gm_name, gm_name_ptr);
      *(strchr (gm_name, ':')) = '\0';
      conn_mgr_node_id = gm_host_name_to_node_id (vip_gm_ptr->gm_port,
                                                  gm_name);
      if (conn_mgr_node_id == GM_NO_SUCH_NODE_ID)
        {
          VIP_MUTEX_UNLOCK (&vip_gm_host_name_lock);
          goto out_with_unknown_remote_endpoint;
        }
    }
  else
    {
      conn_mgr_node_id = remote_gm_id;
    }
  vip_conn_ptr->remote_gm_id = remote_gm_id;
  VIP_MUTEX_UNLOCK (&vip_gm_host_name_lock);
  VIP_EXIT_IOCTL (vip_gm_ptr);
  
  /* allocate a send buffer */
  vip_send_req_ptr = vip_allocate_packet (vip_gm_ptr,
                                          sizeof (VIP_PACKET_CONN_LIST));
  if (vip_send_req_ptr == NULL)
    {
      vip_remove_conn_waiting_list (vip_gm_ptr, vip_conn_ptr);
      vip_free_handle (&(vip_nic_ptr->vip_conn_set),
                       (VIP_HANDLE *) vip_conn_ptr);
      VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
      VIP_MUTEX_UNLOCK (&(vip_gm_ptr->lock));
      return VIP_ERROR_RESOURCE;
    }

  /* fill the packet and send it */
  pkt_list_ptr = (VIP_PACKET_CONN_LIST *) (vip_send_req_ptr->ptr);
  pkt_list_ptr->type = VIP_HTON_UCHAR (VIP_CONN_LIST_REQ_PKT);
  memcpy(pkt_list_ptr->gm_unique_id, RemoteAddr->HostAddress, 6);
  pkt_list_ptr->clt_seq_num = VIP_HTON_UINT16 (vip_conn_ptr->handle.seq_num);
  pkt_list_ptr->clt_conn_ptr = 
    VIP_HTON_UINT64 (vip_addr2addrbits (vip_conn_ptr));

  vip_send_req_ptr->type |= VIP_SEND_REQ_RELIABLE;
  vip_send_req_ptr->dest_port_id = VI_GM_PORT_CONN_MANAGER;
  vip_send_req_ptr->dest_gm_id = conn_mgr_node_id;
  vip_send_req_ptr->vip_nic_ptr = vip_nic_ptr;
  vip_send_req_ptr->vip_vi_ptr = vip_vi_ptr;
  vip_send_data (vip_send_req_ptr);

  gm_set_alarm (vip_gm_ptr->gm_port, &(vip_conn_ptr->peer_timeout_alarm),
                (Timeout * 1000), vip_conn_peer_request_alarm_callback,
                vip_conn_ptr);

  VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
  VIP_MUTEX_UNLOCK (&(vip_gm_ptr->lock));
  VIP_DEBUG (("Success"));
  return VIP_SUCCESS;

out_with_unknown_remote_endpoint:
  VIP_EXIT_IOCTL (vip_gm_ptr);
  gm_set_alarm (vip_gm_ptr->gm_port, &(vip_conn_ptr->peer_timeout_alarm),
                (Timeout * 1000), vip_conn_peer_request_alarm_callback,
                vip_conn_ptr);

  VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
  VIP_MUTEX_UNLOCK (&(vip_gm_ptr->lock));
  VIP_DEBUG (("Remote endpoint is unknown, connection will never complete"));
  return VIP_SUCCESS;
}