vipl_priv.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.         *
 ********************************************************/

#ifndef WIN32
#include <unistd.h>
#include <sys/time.h>
#include <syslog.h>
#else
#include <sys/timeb.h>
#endif
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>

#include "vipl_priv.h"


VIP_MUTEX_ATTR;

#ifndef WIN32

VIP_MUTEX_T vip_glob_lock = PTHREAD_MUTEX_INITIALIZER;
VIP_MUTEX_T vip_gm_host_name_lock = PTHREAD_MUTEX_INITIALIZER;
#else
VIP_MUTEX_T vip_glob_lock;
VIP_MUTEX_T vip_gm_host_name_lock;
#endif

struct gm_lookaside *vip_glob_nic_lookaside = NULL;

VIP_GM *vip_glob_gm_ptrs[VI_GM_MAX_NICS] = { 0 };


/************************/
/*                      */
/* conversion functions */
/*                      */
/************************/

VIP_UINT64
vip_addr2addrbits (VIP_PVOID Address)
{
  VIP_PVOID64 p;
  
  p.AddressBits = 0;
  p.Address = Address;
  return p.AddressBits;
}

VIP_PVOID
vip_addrbits2addr (VIP_UINT64 AddressBits)
{
  VIP_PVOID64 p;
  
  p.AddressBits = AddressBits;
  return p.Address;
}

VIP_ENTRY_POINT void
vip_millisleep (unsigned int milliseconds)
{
#ifndef WIN32
  usleep (milliseconds * 1000);
#else
  Sleep (milliseconds);
#endif
}

VIP_ENTRY_POINT int
vip_gettimeofday (struct timeval *tv, void *p)
{
#ifndef WIN32
  return gettimeofday (tv, p);
#else
  struct _timeb tb;

  _ftime (&tb);
  if (tv != NULL) {
    tv->tv_sec = tb.time;
    tv->tv_usec = tb.millitm * 1000;
  }
  return 0;
#endif
}

VIP_ENTRY_POINT int
vip_gethostname (char *name, size_t len)
{
#ifndef WIN32
  return gethostname (name, len);
#else
  strcpy (name, "hostname");
  return 0;
#endif
}


/*******************/
/*                 */
/* debug functions */
/*                 */
/*******************/

VIP_ENTRY_POINT void
vip_notice (char *msg, ...)
{
  va_list ap;

  va_start (ap, msg);
  vfprintf (stderr, msg, ap);
  va_end (ap);
}

VIP_ENTRY_POINT char *
vip_vsprintf (const char *msg, ...)
{
  char* output;
  va_list ap;

  va_start (ap, msg);
  output = malloc (4096);
  if (output != NULL) 
    {
      vsprintf (output, msg, ap); 
    }
  va_end (ap);
  return output;
}

void
vip_debug (const char *function_name, const char *file, VIP_UINT32 line,
           const char *msg, ...)
{
  va_list ap;
  char hostname[64];
  char fmt[4096];

  va_start (ap, msg);
  VIP_ASSERT (gethostname (hostname, 64) == 0);
  sprintf (fmt, "VI-GM [%s/%lu] <%s>: %s (%s:%d)\n",
           hostname, (unsigned long) VIP_THREAD_SELF (),
           function_name, msg, file, line);
  vfprintf (stderr, fmt, ap);
  va_end (ap);
}

void
vip_debug_gm (const char *function_name, const char *file, VIP_UINT32 line,
              gm_status_t gm_status, const char *msg, ...)
{
  va_list ap;
  char fmt[4096];
  char output[4096];

  va_start (ap, msg);
  sprintf (fmt, "VI-GM <%s>: %s (%s:%d)\n", function_name, msg, file, line);
  vsprintf (output, fmt, ap);
  gm_perror (output, gm_status);
}

void
vi_gm_debug_checksum_compute (VIP_CHKSUM * cksum_ptr,
                               void *ptr, VIP_UINT32 len)
{
  cksum_ptr->sum = gm_crc (ptr, len);
  cksum_ptr->len = len;
}

void
vi_gm_debug_checksum_check (VIP_UCHAR * msg, void *buf,
                             VIP_CHKSUM * chksum_ptr)
{
  VIP_CHKSUM chksum_comp;
  VIP_DEBUG_LABEL (("vi_gm_debug_checksum_check"));

  vi_gm_debug_checksum_compute (&chksum_comp, buf, chksum_ptr->len);
  if (chksum_comp.sum != chksum_ptr->sum)
    {
      VIP_ABORT (("VI-GM checksum error (%s)", msg));
    }
}

void
vi_gm_debug_checksum_copy (VIP_CHKSUM * cksum_target,
                            VIP_CHKSUM * cksum_source)
{
  cksum_target->sum = cksum_source->sum;
  cksum_target->len = cksum_source->len;
}


/*******************/
/*                 */
/* event functions */
/*                 */
/*******************/

VIP_RETURN
vip_wait_for_notification (VIP_ULONG timeout,
                           VIP_HANDLE * handle_ptr,
                           VIP_EVENT_T * event_ptr,
                           VIP_BOOLEAN (*check) (VIP_PVOID),
                           VIP_PVOID context)
{
  struct timespec timeout_abs;
  struct timeval time_abs;
  double time_now, time_finish;
  VIP_GM *vip_gm_ptr;
  VIP_NIC *vip_nic_ptr;
  VIP_UINT32 return_code;
  VIP_DEBUG_LABEL (("vip_wait_for_notification"));

  handle_ptr->ref_count++;
  vip_nic_ptr = handle_ptr->vip_nic_ptr;
  vip_gm_ptr = vip_nic_ptr->vip_gm_ptr;
  VIP_ASSERT_MUTEX_LOCKED (&(vip_gm_ptr->lock));

  if (timeout == 0)
    {
      if (check (context) == VIP_FALSE)
        {
          VIP_DEBUG (("Check is unsuccessfull (timeout 0)"));
          handle_ptr->ref_count--;
          return VIP_TIMEOUT;
        }
    }
  else
    {
      VIP_SEMAPHORE_POST (&(vip_gm_ptr->blocking_plumber_tokens));
      if (timeout == VIP_INFINITE)
        {
          while (check (context) == VIP_FALSE)
            {
              VIP_EVENT_WAIT (event_ptr, &(vip_gm_ptr->lock));
              if (vip_nic_ptr->magic != VIP_NIC_MAGIC)
                {
                  VIP_SEMAPHORE_WAIT (&(vip_gm_ptr->blocking_plumber_tokens));
                  VIP_DEBUG (("NIC has been destroyed during waiting time"));
                  handle_ptr->ref_count--;
                  return VIP_INVALID_PARAMETER;
                }
            }
        }
      else
        {
          return_code = vip_gettimeofday (&time_abs, NULL);
          VIP_ASSERT (return_code == 0);

          time_now = time_abs.tv_sec + (time_abs.tv_usec / 1000000.);
          time_finish = time_now + (timeout / 1000.);
          timeout_abs.tv_sec = (VIP_ULONG) time_finish;
          timeout_abs.tv_nsec = ((time_finish - timeout_abs.tv_sec)
                                 * 1000000000);

          while (check (context) == VIP_FALSE)
            {
              VIP_EVENT_WAIT_TIMEOUT (event_ptr, &(vip_gm_ptr->lock), 
                                      &timeout_abs);

              if (vip_nic_ptr->magic != VIP_NIC_MAGIC)
                {
                  VIP_SEMAPHORE_WAIT (&(vip_gm_ptr->blocking_plumber_tokens));
                  VIP_DEBUG (("NIC has been destroyed during waiting time"));
                  handle_ptr->ref_count--;
                  return VIP_INVALID_PARAMETER;
                }

              if (check (context) == VIP_FALSE)
                {
                  return_code = vip_gettimeofday (&time_abs, NULL);
                  VIP_ASSERT (return_code == 0);

                  time_now = time_abs.tv_sec + (time_abs.tv_usec / 1000000.);
                  if (time_now > time_finish)
                    {
                      VIP_SEMAPHORE_WAIT (&(vip_gm_ptr->blocking_plumber_tokens));
                      VIP_DEBUG (("Check is unsuccessfull after timeout"));
                      handle_ptr->ref_count--;
                      return VIP_TIMEOUT;
                    }
                }
            }
        }

      VIP_SEMAPHORE_WAIT (&(vip_gm_ptr->blocking_plumber_tokens));
    }

  VIP_DEBUG (("Success"));
  handle_ptr->ref_count--;
  return VIP_SUCCESS;
}

void
vip_default_error_callback (VIP_PVOID Context,
                            VIP_ERROR_DESCRIPTOR * ErrorDesc)
{
  char vip_error_msg[2048];
  VIP_DEBUG_LABEL (("vip_default_error_callback"));

  if (ErrorDesc == NULL)
    {
#ifndef WIN32
      syslog (LOG_WARNING,
              "VI/GM: Error callback called with null error descriptor");
#else
      fprintf (stderr, 
               "VI/GM: Error callback called with null error descriptor\n");
#endif
      return;
    }

  sprintf (vip_error_msg, "VI/GM error callback: Operation = ");
  switch ((VIP_UINT32) (ErrorDesc->OpCode))
    {
    case VIP_STATUS_OP_SEND:
      strcat (vip_error_msg, "Send");
      break;
    case VIP_STATUS_OP_RECEIVE:
      strcat (vip_error_msg, "Receive");
      break;
    case VIP_STATUS_OP_RDMA_WRITE:
      strcat (vip_error_msg, "RDMA Write");
      break;
    case VIP_STATUS_OP_REMOTE_RDMA_WRITE:
      strcat (vip_error_msg, "Remote RDMA Write");
      break;
    case VIP_STATUS_OP_RDMA_READ:
      strcat (vip_error_msg, "RDMA Read");
      break;
    default:
      strcat (vip_error_msg, "undefined");
    }

  strcat (vip_error_msg, ", Ressource = ");
  switch (ErrorDesc->ResourceCode)
    {
    case VIP_RESOURCE_NIC:
      strcat (vip_error_msg, "NIC");
      break;
    case VIP_RESOURCE_VI:
      strcat (vip_error_msg, "VI");
      break;
    case VIP_RESOURCE_CQ:
      strcat (vip_error_msg, "CQ");
      break;
    case VIP_RESOURCE_DESCRIPTOR:
      strcat (vip_error_msg, "DESCRIPTOR");
      break;
    default:
      strcat (vip_error_msg, "undefined");
    }

  strcat (vip_error_msg, ", Error = ");
  switch (ErrorDesc->ErrorCode)
    {
    case VIP_ERROR_POST_DESC:
      strcat (vip_error_msg, "\"Post Descriptor Error (A1)\"");
      break;
    case VIP_ERROR_CONN_LOST:
      strcat (vip_error_msg, "\"Connection Lost (A2)\"");
      break;
    case VIP_ERROR_RECVQ_EMPTY:
      strcat (vip_error_msg, "\"Receive Queue Empty (A3)\"");
      break;
    case VIP_ERROR_VI_OVERRUN:
      strcat (vip_error_msg, "\"VI Overrun (A4)\"");
      break;
    case VIP_ERROR_RDMAW_PROT:
      strcat (vip_error_msg, "\"RDMA Write Protection Error (A5)\"");
      break;
    case VIP_ERROR_RDMAW_DATA:
      strcat (vip_error_msg, "\"RDMA Write Data Error (A6)\"");
      break;
    case VIP_ERROR_RDMAW_ABORT:
      strcat (vip_error_msg, "\"RDMA Write Packet Abort (A7)\"");
      break;
    case VIP_ERROR_RDMAR_PROT:
      strcat (vip_error_msg, "\"RDMA Read Protection Error (A8)\"");
      break;
    case VIP_ERROR_COMP_PROT:
      strcat (vip_error_msg, "\"Completion Protection Error (A9)\"");
      break;
    case VIP_ERROR_RDMA_TRANSPORT:
      strcat (vip_error_msg, "\"RDMA Write Transport Error (A10)\"");
      break;
    case VIP_ERROR_CATASTROPHIC:
      strcat (vip_error_msg, "\"Catastrophic Error (A11)\"");
      break;
    default:
      strcat (vip_error_msg, "undefined");
    }

  VIP_DEBUG (("%s", vip_error_msg));
#ifndef WIN32
  syslog (LOG_ERR, vip_error_msg);
#else
  fprintf (stderr, "%s\n", vip_error_msg);
#endif
}

void
vip_generate_async_error (VIP_NIC * vip_nic_ptr,
                          VIP_VI * vip_vi_ptr,
                          VIP_CQ * vip_cq_ptr,
                          VIP_DESCRIPTOR * vip_desc_ptr,
                          VIP_RESOURCE_CODE resource_code,
                          VIP_ERROR_CODE error_code, 
                          VIP_UINT32 opcode)
{
  VIP_ERROR_DESCRIPTOR vip_error_desc;
  VIP_DEBUG_LABEL (("vip_generate_async_error"));

  VIP_ASSERT (vip_nic_ptr != NULL);
  VIP_ASSERT_MUTEX_LOCKED (&(vip_nic_ptr->lock));
  VIP_ASSERT_MUTEX_LOCKED (&(vip_nic_ptr->vip_gm_ptr->lock));
  vip_error_desc.NicHandle = vip_nic_ptr;
  vip_error_desc.ViHandle = vip_vi_ptr;
  vip_error_desc.CQHandle = vip_cq_ptr;
  vip_error_desc.DescriptorPtr = vip_desc_ptr;

  if (opcode != 0)
    {
      vip_error_desc.OpCode = opcode;
    }
  else
    {
      vip_error_desc.OpCode = 0x000F0000;
    }

  vip_error_desc.ResourceCode = resource_code;
  vip_error_desc.ErrorCode = error_code;

  VIP_ASSERT (vip_nic_ptr->error_callback != NULL);
  VIP_DEBUG (("Generate an asynchronous error"));
  vip_nic_ptr->error_callback (vip_nic_ptr->error_callback_context,
                               &vip_error_desc);

  VIP_DEBUG (("Success"));
}

void
vip_notify_desc_completion (VIP_DESCRIPTOR * vip_desc_ptr,
                            VIP_VI * vip_vi_ptr, 
                            VIP_BOOLEAN recv_queue)
{
  VIP_NIC *vip_nic_ptr;
  VIP_CQ *vip_cq_ptr;
  VIP_CQ_ENTRY *vip_cq_entry_ptr;
  VIP_VI_QUEUE *vip_vi_queue_ptr;
  VIP_DEBUG_LABEL (("vip_notify_desc_completion"));

  vip_nic_ptr = vip_vi_ptr->handle.vip_nic_ptr;
  VIP_ASSERT (vip_desc_ptr != NULL);
  VIP_ASSERT ((vip_desc_ptr->CS.Status & VIP_STATUS_DONE) == 0);
  VIP_ASSERT_MUTEX_LOCKED (&(vip_nic_ptr->lock));
  VIP_ASSERT_MUTEX_LOCKED (&(vip_nic_ptr->vip_gm_ptr->lock));

  if (recv_queue == VIP_FALSE)
    {
      vip_vi_queue_ptr = &(vip_vi_ptr->send_queue);
      vip_cq_ptr = vip_vi_ptr->send_queue.vip_cq_ptr;
    }
  else
    {
      vip_vi_queue_ptr = &(vip_vi_ptr->recv_queue);
      vip_cq_ptr = vip_vi_ptr->recv_queue.vip_cq_ptr;
    }

  /* check MemoryHandle */
  VIP_ASSERT (vip_desc_ptr == vip_vi_queue_ptr->current_desc);
  if (vip_check_memory_handle (vip_nic_ptr, vip_vi_queue_ptr->current_mem,
                               (VIP_UINTPTR) vip_desc_ptr,
                               sizeof (VIP_CONTROL_SEGMENT),
                               vip_vi_ptr->vip_ptag_ptr->id) != VIP_SUCCESS)
    {
      VIP_DEBUG (("Control segment Memory Handle check error (comp)"));
      vip_generate_async_error
        (vip_nic_ptr, vip_vi_ptr, NULL, vip_desc_ptr,
         VIP_RESOURCE_DESCRIPTOR, VIP_ERROR_COMP_PROT,
         (vip_desc_ptr->CS.Status & VIP_STATUS_OP_MASK));

      /* VI in error state if fatal report */
      if (vip_vi_ptr->state != VIP_STATE_ERROR)
        {
          /* the VI transition to error state */
          vip_vi_transition_to_error_state (vip_vi_ptr, VIP_TRUE);

          /* a connection lost asynchronous error is generated */
          vip_generate_async_error (vip_nic_ptr, vip_vi_ptr, NULL, NULL,
                                    VIP_RESOURCE_VI, VIP_ERROR_CONN_LOST, 0);
        }

      return;
    }

  vip_desc_ptr->CS.Status |= VIP_STATUS_DONE;

  if (vip_desc_ptr == vip_vi_queue_ptr->first)
    {
      /* signal the completion to a thread blocking on the queue */
      VIP_DEBUG (("Notify %s completion (desc=%p) to the VI",
                  ((recv_queue == VIP_FALSE) ? "Send" : "Receive"),
                  vip_desc_ptr));
      if (vip_vi_queue_ptr->event_count > 0)
        {
          VIP_EVENT_SIGNAL (&(vip_vi_queue_ptr->event));
        }
    }

  if (vip_cq_ptr != NULL)
    {
      /* generate an entry in the completion queue */
      VIP_DEBUG (("Notify completion queue"));
      vip_cq_entry_ptr = &(vip_cq_ptr->queue[vip_cq_ptr->next_completion]);
      vip_cq_entry_ptr->vip_vi_ptr = vip_vi_ptr;
      vip_cq_entry_ptr->recv_queue = recv_queue;
      vip_cq_entry_ptr->completed = VIP_TRUE;

      /* shift the completion queue entry to the next available */
      if ((vip_cq_ptr->next_completion + 1) < vip_cq_ptr->count)
        {
          vip_cq_ptr->next_completion++;
        }
      else
        {
          vip_cq_ptr->next_completion = 0;
        }

      /* wake up any VipCQWait() */
      if (vip_cq_ptr->event_count > 0)
        {
          VIP_EVENT_SIGNAL (&(vip_cq_ptr->event));
        }
    }

  VIP_DEBUG (("Success"));
}

void
vip_vi_transition_to_error_state (VIP_VI * vip_vi_ptr,
                                  VIP_BOOLEAN send_conn_lost)
{
  VIP_NIC *vip_nic_ptr;
  VIP_CQ *vip_cq_ptr;
  VIP_CQ_ENTRY *vip_cq_entry_ptr;
  VIP_VI_QUEUE *vip_vi_queue_ptr;
  VIP_DESCRIPTOR *vip_desc_ptr;
  VIP_DEBUG_LABEL (("vip_vi_transition_to_error_state"));

  vip_nic_ptr = vip_vi_ptr->handle.vip_nic_ptr;
  VIP_ASSERT_MUTEX_LOCKED (&(vip_nic_ptr->lock));
  VIP_ASSERT_MUTEX_LOCKED (&(vip_nic_ptr->vip_gm_ptr->lock));
  vip_vi_ptr->state = VIP_STATE_ERROR;

  /* recv queue */
  vip_vi_queue_ptr = &(vip_vi_ptr->recv_queue);
  vip_cq_ptr = vip_vi_ptr->recv_queue.vip_cq_ptr;
  vip_desc_ptr = vip_vi_ptr->recv_queue.current_desc;

  while (vip_desc_ptr != NULL)
    {
      if ((vip_desc_ptr->CS.Status & VIP_STATUS_DONE) == 0)
        {
          vip_desc_ptr->CS.Status |= VIP_STATUS_DESC_FLUSHED_ERROR;
          vip_desc_ptr->CS.Status |= VIP_STATUS_DONE;

          /* signal the completion to a thread blocking on the queue */
          if ((vip_desc_ptr == vip_vi_queue_ptr->first)
              && (vip_vi_queue_ptr->event_count > 0))
            {
              VIP_EVENT_SIGNAL (&(vip_vi_queue_ptr->event));
            }
        }

      if (vip_cq_ptr != NULL)
        {
          /* generate an entry in the completion queue */
          VIP_DEBUG (("Notify completion queue"));
          vip_cq_entry_ptr =
            &(vip_cq_ptr->queue[vip_cq_ptr->next_completion]);
          vip_cq_entry_ptr->vip_vi_ptr = vip_vi_ptr;
          vip_cq_entry_ptr->recv_queue = VIP_TRUE;
          vip_cq_entry_ptr->completed = VIP_TRUE;

          /* shift the completion queue entry to the next available */
          if ((vip_cq_ptr->next_completion + 1) < vip_cq_ptr->count)
            {
              vip_cq_ptr->next_completion++;
            }
          else
            {
              vip_cq_ptr->next_completion = 0;
            }

          if (vip_cq_ptr->event_count > 0)
            {
              VIP_EVENT_SIGNAL (&(vip_cq_ptr->event));
            }
        }

      VIP_ASSERT ((vip_vi_queue_ptr->last != vip_desc_ptr)
                  || (vip_desc_ptr->CS.Next.Address == NULL));
      vip_vi_queue_ptr->current_desc = vip_desc_ptr->CS.Next.Address;
      vip_vi_queue_ptr->current_mem = vip_desc_ptr->CS.NextHandle;
      vip_desc_ptr = vip_vi_queue_ptr->current_desc;
    }
  VIP_ASSERT (vip_vi_queue_ptr->current_desc == NULL);
  vip_vi_queue_ptr->current_mem = 0;
  vip_vi_queue_ptr->count_to_process = 0;

  /* send queue */
  vip_vi_queue_ptr = &(vip_vi_ptr->send_queue);
  vip_cq_ptr = vip_vi_ptr->send_queue.vip_cq_ptr;
  vip_desc_ptr = vip_vi_ptr->send_queue.current_desc;

  while (vip_desc_ptr != NULL)
    {
      /* check MemoryHandle */
      if (vip_check_memory_handle (vip_nic_ptr,
                                   vip_vi_queue_ptr->current_mem,
                                   (VIP_UINTPTR) vip_desc_ptr,
                                   sizeof (VIP_CONTROL_SEGMENT),
                                   vip_vi_ptr->vip_ptag_ptr->id)
          != VIP_SUCCESS)
        {
          VIP_DEBUG (("Control segment Memory Handle completion check error"));
          goto next_send_desc;
        }

      if ((vip_desc_ptr->CS.Status & VIP_STATUS_DONE) == 0)
        {
          vip_desc_ptr->CS.Status |= VIP_STATUS_DESC_FLUSHED_ERROR;
          vip_desc_ptr->CS.Status |= VIP_STATUS_DONE;

          /* signal the completion to a thread blocking on the queue */
          if (vip_vi_queue_ptr->event_count > 0)
            {
              VIP_EVENT_SIGNAL (&(vip_vi_queue_ptr->event));
            }
        }

      if (vip_cq_ptr != NULL)
        {
          /* generate an entry in the completion queue */
          VIP_DEBUG (("Notify completion queue"));
          vip_cq_entry_ptr =
            &(vip_cq_ptr->queue[vip_cq_ptr->next_completion]);
          vip_cq_entry_ptr->vip_vi_ptr = vip_vi_ptr;
          vip_cq_entry_ptr->recv_queue = VIP_FALSE;
          vip_cq_entry_ptr->completed = VIP_TRUE;

          /* shift the completion queue entry to the next available */
          if ((vip_cq_ptr->next_completion + 1) < vip_cq_ptr->count)
            {
              vip_cq_ptr->next_completion++;
            }
          else
            {
              vip_cq_ptr->next_completion = 0;
            }

          if (vip_cq_ptr->event_count > 0)
            {
              VIP_EVENT_SIGNAL (&(vip_cq_ptr->event));
            }
        }

    next_send_desc:
      VIP_ASSERT ((vip_vi_queue_ptr->last != vip_desc_ptr)
                  || (vip_desc_ptr->CS.Next.Address == NULL));
      vip_vi_queue_ptr->current_desc = vip_desc_ptr->CS.Next.Address;
      vip_vi_queue_ptr->current_mem = vip_desc_ptr->CS.NextHandle;
      vip_desc_ptr = vip_vi_queue_ptr->current_desc;
    }
  VIP_ASSERT (vip_vi_queue_ptr->current_desc == NULL);
  vip_vi_queue_ptr->current_mem = 0;
  vip_vi_queue_ptr->count_to_process = 0;

  /* send a connection lost report to the other end */
  if (send_conn_lost == VIP_TRUE)
    {
      /* a little delay to be sure that the send callbacks 
         have been processed before receiving this report. */
      vip_millisleep (100);
      vip_return_report (vip_nic_ptr->vip_gm_ptr, vip_nic_ptr, vip_vi_ptr,
                         VIP_REPORT_CONN_LOST, VIP_TRUE);
    }
  VIP_DEBUG (("Success"));
}

VIP_RETURN
vip_check_memory_handle (VIP_NIC * vip_nic_ptr,
                         VIP_MEM_HANDLE vip_mem_handle,
                         VIP_UINT64 range_start,
                         VIP_UINT64 range_length, 
                         VIP_UINT32 vip_vi_ptag_id)
{
  VIP_MEM *vip_mem_ptr;
  VIP_DEBUG_LABEL (("vip_check_memory_handle"));

  VIP_ASSERT_MUTEX_LOCKED (&(vip_nic_ptr->lock));

  /* check the MemoryHandle */
  if ((vip_mem_handle == 0) || (vip_mem_handle > VI_GM_MAX_REGISTER_REGIONS))
    {
      VIP_DEBUG (("Memory Handle is out of range"));
      return VIP_INVALID_PARAMETER;
    }

  /* check regmem handle */
  vip_mem_ptr = vip_nic_ptr->vip_mem_handle_ptrs[vip_mem_handle];
  if (VIP_INVALID_MEM_HANDLE (vip_mem_ptr))
    {
      VIP_DEBUG (("Invalid Memory Handle"));
      return VIP_INVALID_PARAMETER;
    }

  /* check regmem's NIC */
  if (vip_mem_ptr->handle.vip_nic_ptr != vip_nic_ptr)
    {
      VIP_DEBUG (("Memory Handle from another NIC"));
      return VIP_INVALID_PARAMETER;
    }

  if (range_start + range_length < range_start)
    {
      VIP_DEBUG (("Segment overflow"));
      return VIP_INVALID_PARAMETER;
    }

  /* check memory handle coverage */
  if (((VIP_UINT64) ((VIP_UINTPTR) vip_mem_ptr->address) > range_start)
      || ((((VIP_UINT64) ((VIP_UINTPTR) vip_mem_ptr->address)) 
           + vip_mem_ptr->length) < (range_start + range_length)))
    {
      VIP_DEBUG (("Segment not covered by Memory Handle"));
      return VIP_INVALID_PARAMETER;
    }

  /* check MEM PTAG handle */
  if (VIP_INVALID_PTAG_HANDLE (vip_mem_ptr->vip_ptag_ptr))
    {
      VIP_DEBUG (("Invalid MEM PTAG handle"));
      return VIP_INVALID_PARAMETER;
    }

  /* check ptag's NIC */
  if (vip_mem_ptr->vip_ptag_ptr->handle.vip_nic_ptr != vip_nic_ptr)
    {
      VIP_DEBUG (("Ptag Handle from another NIC"));
      return VIP_INVALID_PARAMETER;
    }

  /* compare PTAG ids */
  if (vip_mem_ptr->vip_ptag_ptr->id != vip_vi_ptag_id)
    {
      VIP_DEBUG (("VI PTAG and MEM PTAG do not match"));
      return VIP_INVALID_PARAMETER;
    }

  VIP_DEBUG (("Success"));
  return VIP_SUCCESS;
}

void
vip_alive_alarm_callback (void *ptr)
{
  VIP_GM *vip_gm_ptr;
  VIP_PACKET_ALIVE *pkt_ptr;
  VIP_DEBUG_LABEL (("vip_alive_alarm_callback"));

  vip_gm_ptr = (VIP_GM *) ptr;
  VIP_ASSERT (vip_gm_ptr->alive_buffer != NULL);
  VIP_ASSERT_MUTEX_LOCKED (&(vip_gm_ptr->lock));
  pkt_ptr = vip_gm_ptr->alive_buffer;

  if (VIP_NTOH_UINT32 (pkt_ptr->net_srv_magic) == 0)
    {
      /* the previous heartbeat has been sent */
      pkt_ptr->type = VIP_HTON_UCHAR (VIP_ALIVE_PKT);
      pkt_ptr->net_srv_magic = VIP_HTON_UINT32 (vip_gm_ptr->magic);
      gm_send_with_callback (vip_gm_ptr->gm_port, pkt_ptr,
                             VI_GM_CTRL_GM_SIZE,
                             sizeof (VIP_PACKET_ALIVE),
                             GM_LOW_PRIORITY,
                             vip_gm_ptr->conn_mgr_gm_id,
                             VI_GM_PORT_CONN_MANAGER,
                             vip_alive_sent_callback, vip_gm_ptr);

      gm_set_alarm (vip_gm_ptr->gm_port, &(vip_gm_ptr->alive_alarm),
                    ((VI_GM_CONN_MGR_TTL * 1000) / 4),
                    vip_alive_alarm_callback, vip_gm_ptr);
    }
  else
    {
      VIP_DEBUG (("Previous heartbeat message sent completion too late"));
      gm_set_alarm (vip_gm_ptr->gm_port, &(vip_gm_ptr->alive_alarm),
                    ((VI_GM_CONN_MGR_TTL * 1000) / 2),
                    vip_alive_alarm_callback, vip_gm_ptr);
    }

  VIP_DEBUG (("Heartbeat message sent to connection manager"));
}

void
vip_alive_sent_callback (struct gm_port *gm_port,
                         void *context, 
                         gm_status_t status)
{
  VIP_GM *vip_gm_ptr;
  VIP_DEBUG_LABEL (("vip_alive_sent_callback"));

  vip_gm_ptr = (VIP_GM *) context;
  VIP_ASSERT_MUTEX_LOCKED (&(vip_gm_ptr->lock));
  if (status != GM_SUCCESS)
    {
      VIP_NOTICE (("Heartbeat message to Connection Manager "
                   "(GM id %d, port %d) completed with error (%s)\n",
                   vip_gm_ptr->conn_mgr_gm_id, VI_GM_PORT_CONN_MANAGER,
                   gm_strerror (status)));
      gm_resume_sending (gm_port, GM_LOW_PRIORITY,
                         vip_gm_ptr->conn_mgr_gm_id,
                         VI_GM_PORT_CONN_MANAGER,
                         vip_alive_sent_callback, context);
      return;
    }

  /* notify the send completion for next alive alarm */
  vip_gm_ptr->alive_buffer->net_srv_magic = VIP_HTON_UINT32 (0);
  VIP_DEBUG (("Success"));
}


void
vip_remove_conn_waiting_list (VIP_GM * vip_gm_ptr, VIP_CONN * vip_conn_ptr)
{
  VIP_DEBUG_LABEL (("vip_remove_conn_waiting_list"));

  VIP_ASSERT_MUTEX_LOCKED (&(vip_gm_ptr->lock));
  VIP_ASSERT_MUTEX_LOCKED (&(vip_conn_ptr->handle.vip_nic_ptr->lock));
  VIP_ASSERT (vip_conn_ptr->waiting_list == VIP_TRUE);

  /* if the connection is the head of the waiting list */
  if (vip_conn_ptr->prev_waiting_conn_ptr == NULL)
    {
      VIP_ASSERT (vip_conn_ptr == vip_gm_ptr->head_waiting_conn_ptr);
      vip_gm_ptr->head_waiting_conn_ptr = vip_conn_ptr->next_waiting_conn_ptr;
    }
  else
    {
      vip_conn_ptr->prev_waiting_conn_ptr->next_waiting_conn_ptr =
        vip_conn_ptr->next_waiting_conn_ptr;
    }

  /* if the connection is the tail of the waiting list */
  if (vip_conn_ptr->next_waiting_conn_ptr == NULL)
    {
      VIP_ASSERT (vip_conn_ptr == vip_gm_ptr->tail_waiting_conn_ptr);
      vip_gm_ptr->tail_waiting_conn_ptr = vip_conn_ptr->prev_waiting_conn_ptr;
    }
  else
    {
      vip_conn_ptr->next_waiting_conn_ptr->prev_waiting_conn_ptr =
        vip_conn_ptr->prev_waiting_conn_ptr;
    }

  vip_conn_ptr->waiting_list = VIP_FALSE;
  VIP_DEBUG (("Success"));
}

void
vip_conn_peer_request_alarm_callback (void *ptr)
{
  VIP_GM *vip_gm_ptr;
  VIP_CONN *vip_conn_ptr;
  VIP_DEBUG_LABEL (("vip_conn_peer_request_alarm_callback"));

  /* check the connection */
  vip_conn_ptr = (VIP_CONN *) ptr;
  if (VIP_INVALID_CONN_HANDLE (vip_conn_ptr))
    {
      VIP_DEBUG (("Invalid CONN handle ptr in conn peer request alarm"));
      return;
    }
  VIP_MUTEX_LOCK (&(vip_conn_ptr->handle.vip_nic_ptr->lock));

  /* complete the connection if needed */
  if (vip_conn_ptr->status == VIP_NOT_DONE)
    {
      vip_gm_ptr = vip_conn_ptr->handle.vip_nic_ptr->vip_gm_ptr;
      vip_remove_conn_waiting_list (vip_gm_ptr, vip_conn_ptr);
      vip_conn_ptr->status = VIP_TIMEOUT;
      VIP_EVENT_SIGNAL (&(vip_conn_ptr->event));
    }

  VIP_MUTEX_UNLOCK (&(vip_conn_ptr->handle.vip_nic_ptr->lock));
  VIP_DEBUG (("Success"));
}

int
vip_avl_compare_function (const void *a, const void *b, void *param)
{
  if (((VIP_AVL_RANGE *) (a))->addr < ((VIP_AVL_RANGE *) (b))->addr)
    {
      return -1;
    }
  else
    {
      if (((VIP_AVL_RANGE *) (a))->addr 
          >= (((VIP_AVL_RANGE *) (b))->addr + ((VIP_AVL_RANGE *) (b))->length))
        {
          return 1;
        }
      else
        {
          return 0;
        }
    }
}

void
vip_avl_free_function (void * data, void * param)
{
  gm_lookaside_free (data);
}

VIP_UINT32
vip_avl_register_memory (VIP_GM * vip_gm_ptr, 
                         VIP_UINTPTR start, 
                         VIP_UINTPTR end)
{
  VIP_UINTPTR addr;
  VIP_UINTPTR batch_addr;
  VIP_UINT32 batch_pages;
  VIP_AVL_RANGE *vip_avl_range_ptr;
  VIP_AVL_RANGE *vip_old_avl_range_ptr;
  gm_status_t gm_status;
  VIP_DEBUG_LABEL (("vip_avl_register_memory"));

  VIP_ASSERT (start < end);
  VIP_ASSERT ((start % GM_PAGE_LEN) == 0);
  VIP_ASSERT ((end % GM_PAGE_LEN) == 0);
  VIP_ASSERT_MUTEX_LOCKED (&(vip_gm_ptr->lock));

  /* allocate an AVL tree entry */
  vip_avl_range_ptr =
    (VIP_AVL_RANGE *) gm_lookaside_alloc (vip_gm_ptr->regmem_avl_lookaside);
  if (vip_avl_range_ptr == NULL)
    {
      VIP_DEBUG (("Unable to allocate AVL range from lookaside list"));
      return 0;
    }

  addr = start;
  batch_addr = 0;
  batch_pages = 0;
  
  /* look into the AVL tree if pages are already registered */
  while (addr < end)
    {
      vip_avl_range_ptr->addr = addr;
      vip_avl_range_ptr->length = GM_PAGE_LEN;
      vip_avl_range_ptr->count = 1;
      vip_old_avl_range_ptr = VIP_AVL_TREE_FIND (vip_gm_ptr->regmem_avl_tree,
                                                 vip_avl_range_ptr);

      if (vip_old_avl_range_ptr == NULL)
        {
          /* page not allocated, one more to register */
          if (batch_addr == 0)
            {
              batch_addr = addr;
            }
          batch_pages++;
        }
      else
        {
          /* page already allocated */
          VIP_ASSERT ((vip_old_avl_range_ptr->addr <= addr) 
                      && (vip_old_avl_range_ptr->addr 
                          + vip_old_avl_range_ptr->length > addr)) ;

          if (batch_addr != 0)
            {
              VIP_ASSERT (vip_old_avl_range_ptr->addr == addr);

              /* try to register previously unregistered pages */
              VIP_ENTER_IOCTL (vip_gm_ptr);
              gm_status = gm_register_memory (vip_gm_ptr->gm_port,
                                              ((VIP_PVOID) batch_addr),
                                              batch_pages * GM_PAGE_LEN);
              VIP_EXIT_IOCTL (vip_gm_ptr);
              
              if (gm_status != GM_SUCCESS)
                {
                  VIP_DEBUG_GM (("gm_register_memory() failed"));
                  gm_lookaside_free (vip_avl_range_ptr);
                  return (batch_addr - start);
                }

              vip_avl_range_ptr->addr = batch_addr;
              vip_avl_range_ptr->length = batch_pages * GM_PAGE_LEN;
              vip_avl_range_ptr->count = 1;
              VIP_AVL_TREE_INSERT (vip_gm_ptr->regmem_avl_tree,
                                   vip_avl_range_ptr);

              /* allocate another AVL tree entry */
              vip_avl_range_ptr = (VIP_AVL_RANGE *)
                gm_lookaside_alloc (vip_gm_ptr->regmem_avl_lookaside);
              if (vip_avl_range_ptr == NULL)
                {
                  VIP_DEBUG (("Unable to allocate AVL range from lookaside"));
                  return (batch_addr - start + (batch_pages * GM_PAGE_LEN));
                }

              batch_addr = 0;
              batch_pages = 0;
            }

          /* Check if the old segment start before the new one */
          if (vip_old_avl_range_ptr->addr < addr)
            {
              /* build a new range for the part of the old segment 
                 before the new one */
              vip_avl_range_ptr->addr = vip_old_avl_range_ptr->addr;
              vip_avl_range_ptr->length = addr - vip_old_avl_range_ptr->addr;
              VIP_ASSERT ((vip_avl_range_ptr->length % GM_PAGE_LEN) == 0);
              vip_avl_range_ptr->count = vip_old_avl_range_ptr->count;
              
              /* change the beginning of the rest to align on the new range */
              vip_old_avl_range_ptr->addr = addr;
              vip_old_avl_range_ptr->length -= vip_avl_range_ptr->length;
              
              VIP_AVL_TREE_INSERT (vip_gm_ptr->regmem_avl_tree,
                                   vip_avl_range_ptr);
              
              /* allocate another AVL tree entry */
              vip_avl_range_ptr = (VIP_AVL_RANGE *)
                gm_lookaside_alloc (vip_gm_ptr->regmem_avl_lookaside);
              if (vip_avl_range_ptr == NULL)
                {
                  VIP_DEBUG (("Unable to allocate AVL range from lookaside"));
                  return (addr - start);
                }
            }


          /* now the old segment and the new one are aligned, 
             let's look at the end */
          if ((vip_old_avl_range_ptr->addr
               + vip_old_avl_range_ptr->length) > end)
            {
              /* build a new range for the part of the old segment 
                 after the new one */
              vip_avl_range_ptr->addr = end;
              vip_avl_range_ptr->length = (vip_old_avl_range_ptr->addr
                                           + vip_old_avl_range_ptr->length
                                           - end);
              vip_avl_range_ptr->count = vip_old_avl_range_ptr->count;

              /* shrink the old segment and increase the reference count */
              vip_old_avl_range_ptr->length -= vip_avl_range_ptr->length;
              vip_old_avl_range_ptr->count++;
              
              VIP_AVL_TREE_INSERT (vip_gm_ptr->regmem_avl_tree,
                                   vip_avl_range_ptr);

              VIP_DEBUG (("Success"));
              return (end - start);
            }
          else
            {
              if ((vip_old_avl_range_ptr->addr
                   + vip_old_avl_range_ptr->length) == end)
                {
                  vip_old_avl_range_ptr->count++;
                  gm_lookaside_free (vip_avl_range_ptr);
                  VIP_DEBUG (("Success"));
                  return (end - start);
                }
              else
                {
                  VIP_ASSERT ((vip_old_avl_range_ptr->addr
                               + vip_old_avl_range_ptr->length) < end);
                  vip_old_avl_range_ptr->count++;
                  addr = addr + vip_old_avl_range_ptr->length - GM_PAGE_LEN;
                }
            }
        }

      addr += GM_PAGE_LEN;
    }

  VIP_ASSERT (batch_addr != 0);
  
  /* try to register previously unregistered pages */
  VIP_ENTER_IOCTL (vip_gm_ptr);
  gm_status = gm_register_memory (vip_gm_ptr->gm_port,
                                  ((VIP_PVOID) batch_addr),
                                  batch_pages * GM_PAGE_LEN);
  VIP_EXIT_IOCTL (vip_gm_ptr);
  
  if (gm_status != GM_SUCCESS)
    {
      VIP_DEBUG_GM (("gm_register_memory() failed"));
      gm_lookaside_free (vip_avl_range_ptr);
      return (batch_addr - start);
    }
  else
    {
      vip_avl_range_ptr->addr = batch_addr;
      vip_avl_range_ptr->length = batch_pages * GM_PAGE_LEN;
      vip_avl_range_ptr->count = 1;
      VIP_AVL_TREE_INSERT (vip_gm_ptr->regmem_avl_tree,
                           vip_avl_range_ptr);
      VIP_DEBUG (("Success"));
      return (end - start);
    }

  VIP_ABORT (("Memory registration internal error"));
  return 0;
}

VIP_RETURN
vip_avl_deregister_memory (VIP_GM * vip_gm_ptr, 
                           VIP_UINTPTR start,
                           VIP_UINTPTR end)
{
  VIP_UINTPTR addr;
  VIP_AVL_RANGE vip_avl_range;
  VIP_AVL_RANGE *vip_old_avl_range_ptr;
  gm_status_t gm_status;
  VIP_DEBUG_LABEL (("vip_avl_deregister_memory"));

  VIP_ASSERT (start < end);
  VIP_ASSERT ((start % GM_PAGE_LEN) == 0);
  VIP_ASSERT ((end % GM_PAGE_LEN) == 0);
  VIP_ASSERT_MUTEX_LOCKED (&(vip_gm_ptr->lock));

  addr = start;
  while (addr < end)
    {
      vip_avl_range.addr = addr;
      vip_avl_range.length = GM_PAGE_LEN;
      vip_avl_range.count = 1;
      vip_old_avl_range_ptr = VIP_AVL_TREE_FIND (vip_gm_ptr->regmem_avl_tree,
                                                 &(vip_avl_range));
      VIP_ASSERT (vip_old_avl_range_ptr != NULL);
      VIP_ASSERT (vip_old_avl_range_ptr->addr == addr);
      VIP_ASSERT ((vip_old_avl_range_ptr->addr
                   + vip_old_avl_range_ptr->length) <= end);

      if (vip_old_avl_range_ptr->count == 1)
        {
          /* deregister memory */
          VIP_ENTER_IOCTL (vip_gm_ptr);
          gm_status =
            gm_deregister_memory (vip_gm_ptr->gm_port,
                                  ((VIP_PVOID) vip_old_avl_range_ptr->addr),
                                  vip_old_avl_range_ptr->length);
          VIP_EXIT_IOCTL (vip_gm_ptr);

          if (gm_status != GM_SUCCESS)
            {
              VIP_DEBUG_GM (("gm_deregister_memory() failed"));
              return VIP_ERROR_RESOURCE;
            }

          /* remove the entry in the AVL tree */
          VIP_AVL_TREE_DELETE (vip_gm_ptr->regmem_avl_tree, vip_old_avl_range_ptr);
          addr += vip_old_avl_range_ptr->length;
          gm_lookaside_free (vip_old_avl_range_ptr);
        }
      else
        {
          vip_old_avl_range_ptr->count--;
          addr += vip_old_avl_range_ptr->length;
        }
    }
  
  VIP_DEBUG (("Success"));
  return VIP_SUCCESS;
}