vipl_priv_recv.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 <sys/time.h>
#endif
#include <stdlib.h>
#include <string.h>

#include "vipl_priv.h"

void
vip_return_report (VIP_GM * vip_gm_ptr,
                   VIP_NIC * vip_nic_ptr,
                   VIP_VI * vip_vi_ptr, 
                   VIP_UCHAR report, 
                   VIP_UCHAR recv_side)
{
  VIP_SEND_REQ *vip_send_req_ptr;
  VIP_PACKET_REPORT *pkt_report_ptr;
  VIP_DEBUG_LABEL ("vip_return_report");

  if (vip_vi_ptr->gm_dest_port == 0)
    {
      VIP_DEBUG (("Report %d NOT sent back to unknown sender", report));
      return;
    }
  
  vip_send_req_ptr = vip_allocate_packet (vip_gm_ptr,
                                          sizeof (VIP_PACKET_REPORT));
  VIP_ASSERT (vip_send_req_ptr != NULL);
  pkt_report_ptr = (VIP_PACKET_REPORT *) (vip_send_req_ptr->ptr);
  pkt_report_ptr->type = VIP_HTON_UCHAR (VIP_REPORT_PKT);
  pkt_report_ptr->report = VIP_HTON_UCHAR (report);
  pkt_report_ptr->recv_side = VIP_HTON_UCHAR (recv_side);
  pkt_report_ptr->net_remote_nic_index = vip_vi_ptr->net_remote_nic_index;
  pkt_report_ptr->net_remote_vi_index = vip_vi_ptr->net_remote_vi_index;

  vip_send_req_ptr->type |= VIP_SEND_REQ_RELIABLE;
  vip_send_req_ptr->dest_port_id = (VIP_UCHAR) (vip_vi_ptr->gm_dest_port);
  vip_send_req_ptr->dest_gm_id = vip_vi_ptr->gm_dest_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);

  VIP_DEBUG (("Report %d sent back to sender", report));
}

static VIP_RETURN
vip_check_nic_and_vi (VIP_GM * vip_gm_ptr,
                      gm_recv_event_t * event,
                      VIP_PACKET_EAGER_UR * ptr,
                      VIP_NIC ** result_vip_nic_ptr,
                      VIP_VI ** result_vip_vi_ptr, 
                      VIP_UCHAR recv_side)
{
  VIP_NIC *vip_nic_ptr;
  VIP_VI *vip_vi_ptr;
  VIP_UINT16 vip_nic_index;
  VIP_UINT16 vip_vi_index;
  VIP_DEBUG_LABEL (("vip_check_nic_and_vi"));

  /* check NIC index */
  vip_nic_index = VIP_NTOH_UINT16 (ptr->net_remote_nic_index);
  VIP_ASSERT (vip_nic_index <= VI_GM_MAX_NIC_HANDLES);
  vip_nic_ptr = vip_gm_ptr->vip_nic_ptrs[vip_nic_index];
  if (VIP_INVALID_NIC_HANDLE (vip_nic_ptr))
    {
      VIP_DEBUG (("Invalid NIC index"));
      *result_vip_nic_ptr = NULL;
      *result_vip_vi_ptr = NULL;
      return VIP_INVALID_PARAMETER;
    }
  VIP_MUTEX_LOCK (&(vip_nic_ptr->lock));

  /* check vi handle ptr */
  vip_vi_index = VIP_NTOH_UINT16 (ptr->net_remote_vi_index);
  VIP_ASSERT (vip_vi_index <= VI_GM_MAX_VI);
  vip_vi_ptr = vip_nic_ptr->vip_vi_ptrs[vip_vi_index];
  if (VIP_INVALID_VI_HANDLE (vip_vi_ptr))
    {
      VIP_DEBUG (("Invalid VI index"));
      *result_vip_nic_ptr = vip_nic_ptr;
      *result_vip_vi_ptr = NULL;
      return VIP_INVALID_PARAMETER;
    }

  /* check that the sender is the other end of the VI */
  if ((vip_vi_ptr->gm_dest_port != gm_ntohc (event->recv.sender_port_id))
      || (vip_vi_ptr->gm_dest_id != gm_ntohs (event->recv.sender_node_id)))
    {
      VIP_DEBUG (("Sender is not the end of VI"));
      *result_vip_nic_ptr = vip_nic_ptr;
      *result_vip_vi_ptr = vip_vi_ptr;
      vip_return_report (vip_gm_ptr, vip_nic_ptr, vip_vi_ptr,
                         VIP_REPORT_INVALID_SENDER, recv_side);
      return VIP_INVALID_PARAMETER;
    }

  *result_vip_nic_ptr = vip_nic_ptr;
  *result_vip_vi_ptr = vip_vi_ptr;
  return VIP_SUCCESS;
}

static void
vip_handle_matching_message (VIP_PACKET * inc_ptr,
                             gm_recv_event_t * event, 
                             VIP_GM * vip_gm_ptr)
{
  VIP_VI *vip_vi_ptr;
  VIP_NIC *vip_nic_ptr;
  VIP_UINT32 vip_vi_ptag_id;
  VIP_UINT32 total_length;
  VIP_UINT32 length;
  VIP_UINT32 data_length;
  VIP_UINT32 i;
  VIP_PVOID data_ptr;
  VIP_PACKET *pkt_ptr;
  VIP_DESCRIPTOR *vip_desc_ptr;
  VIP_SEND_REQ *vip_send_req_ptr;
  VIP_DATA_SEGMENT *vip_data_segment_ptr;
  VIP_DEBUG_LABEL (("vip_handle_matching_message"));

  length = (((VIP_NTOH_UCHAR (inc_ptr->vip_pkt_eager_ur.length_24)) << 16)
            + ((VIP_NTOH_UCHAR (inc_ptr->vip_pkt_eager_ur.length_16)) << 8)
            + VIP_NTOH_UCHAR (inc_ptr->vip_pkt_eager_ur.length_8));

  /* check the NIC and VI */
  if (vip_check_nic_and_vi (vip_gm_ptr, event,
                            (VIP_PACKET_EAGER_UR *) inc_ptr, &vip_nic_ptr,
                            &vip_vi_ptr, VIP_TRUE) != VIP_SUCCESS)
    {
      if (vip_nic_ptr != NULL)
        {
          VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
        }
      return;
    }

  /* check if the VI is in connected state */
  if (vip_vi_ptr->state != VIP_STATE_CONNECTED)
    {
      VIP_DEBUG (("VI is not in connected state, refuse incoming packet"));
      VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
      return;
    }

  /* check if the recv queue is empty */
  if (vip_vi_ptr->recv_queue.count_to_process <= 0)
    {
      /* recv queue empty */
      VIP_ASSERT (vip_vi_ptr->recv_queue.current_desc == NULL);
      switch (vip_vi_ptr->reliability)
        {
        case VIP_SERVICE_UNRELIABLE:
          if ((VIP_NTOH_UCHAR (inc_ptr->type) == VIP_3WAY_REQ_PKT)
              || (VIP_NTOH_UCHAR (inc_ptr->type) == VIP_PUT_REQ_IMM_PKT))
            {
              /* return a remote descriptor error report */
              vip_return_report (vip_gm_ptr, vip_nic_ptr, vip_vi_ptr,
                                 VIP_REPORT_RECV_QUEUE_EMPTY, VIP_TRUE);
            }
          break;

        case VIP_SERVICE_RELIABLE_DELIVERY:
          if ((VIP_NTOH_UCHAR (inc_ptr->type) == VIP_3WAY_REQ_PKT)
              || (VIP_NTOH_UCHAR (inc_ptr->type) == VIP_PUT_REQ_IMM_PKT))
            {
              /* return a remote descriptor error report */
              vip_return_report (vip_gm_ptr, vip_nic_ptr, vip_vi_ptr,
                                 VIP_REPORT_RECV_QUEUE_EMPTY, VIP_TRUE);
            }

          /* the VI transition to error state */
          vip_vi_transition_to_error_state (vip_vi_ptr, VIP_TRUE);

          /* generate the asynchronous error */
          vip_generate_async_error (vip_nic_ptr, vip_vi_ptr, NULL, NULL,
                                    VIP_RESOURCE_VI, VIP_ERROR_RECVQ_EMPTY,
                                    VIP_STATUS_OP_RECEIVE);

          /* 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);
          break;

        case VIP_SERVICE_RELIABLE_RECEPTION:
          /* generate the asynchronous error */
          vip_generate_async_error (vip_nic_ptr, vip_vi_ptr, NULL, NULL,
                                    VIP_RESOURCE_VI, VIP_ERROR_RECVQ_EMPTY,
                                    VIP_STATUS_OP_RECEIVE);

          /* generate the asynchronous error */
          vip_generate_async_error (vip_nic_ptr, vip_vi_ptr, NULL, NULL,
                                    VIP_RESOURCE_VI, VIP_ERROR_CONN_LOST, 0);

          /* the VI transition to error state */
          vip_vi_transition_to_error_state (vip_vi_ptr, VIP_FALSE);

          /* return a remote descriptor error report */
          vip_return_report (vip_gm_ptr, vip_nic_ptr, vip_vi_ptr,
                             VIP_REPORT_RECV_QUEUE_EMPTY, VIP_TRUE);
          break;
        }

      VIP_DEBUG (("No descriptors on the receive queue"));
      VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
      return;
    }
  else
    {
      total_length = 0;
      vip_desc_ptr = vip_vi_ptr->recv_queue.current_desc;
      vip_vi_ptag_id = vip_vi_ptr->vip_ptag_ptr->id;
      VIP_ASSERT (vip_vi_ptr->state == VIP_STATE_CONNECTED);
      VIP_ASSERT ((vip_desc_ptr->CS.Status & VIP_STATUS_DONE) == 0);

      /* check MemoryHandle */
      if (vip_check_memory_handle (vip_nic_ptr,
                                   vip_vi_ptr->recv_queue.current_mem,
                                   (VIP_UINTPTR) vip_desc_ptr,
                                   sizeof (VIP_CONTROL_SEGMENT),
                                   vip_vi_ptag_id) != VIP_SUCCESS)
        {
          VIP_DEBUG (("Control segment Memory Handle completion check error"));
          goto async_comp_desc_error;
        }

      /* check reserved part of the control field */
      if ((vip_desc_ptr->CS.Control & VIP_CONTROL_RESERVED) != 0)
        {
          VIP_DEBUG (("Control field reserved part is not set to 0"));
          vip_desc_ptr->CS.Status |= VIP_STATUS_FORMAT_ERROR;
          goto out_with_sync_error;
        }

      /* check that the Reserved field is set to 0 */
      if (vip_desc_ptr->CS.Reserved != 0)
        {
          VIP_DEBUG (("Reserved field is not set to 0"));
          vip_desc_ptr->CS.Status |= VIP_STATUS_FORMAT_ERROR;
          goto out_with_sync_error;
        }

      /* check number of segments */
      if (vip_desc_ptr->CS.SegCount > VI_GM_MAX_SEGMENTS_PER_DESCRIPTOR)
        {
          VIP_DEBUG (("Number of Address/Data segments is exceeding capacity "
                      "(max=%d)", VI_GM_MAX_SEGMENTS_PER_DESCRIPTOR));
          vip_desc_ptr->CS.Status |= VIP_STATUS_LENGTH_ERROR;
          goto out_with_sync_error;
        }

      /* check length of data */
      VIP_ASSERT (vip_vi_ptr->mtu <= VI_GM_MAX_TRANSFER_SIZE);
      if (vip_desc_ptr->CS.Length > vip_vi_ptr->mtu)
        {
          VIP_DEBUG (("Data length is exceeding the MTU of the VI"));
          vip_desc_ptr->CS.Status |= VIP_STATUS_LENGTH_ERROR;
          goto out_with_sync_error;
        }

      /* check MemoryHandle for data */
      if (vip_check_memory_handle (vip_nic_ptr,
                                   vip_vi_ptr->recv_queue.current_mem,
                                   (VIP_UINTPTR) vip_desc_ptr,
                                   (sizeof (VIP_CONTROL_SEGMENT)
                                    + (vip_desc_ptr->CS.SegCount
                                       * sizeof (VIP_DESCRIPTOR_SEGMENT))),
                                   vip_vi_ptag_id) != VIP_SUCCESS)
        {
          VIP_DEBUG (("Data segments not covered by Memory Handle"));
          vip_desc_ptr->CS.Status |= VIP_STATUS_PROTECTION_ERROR;
          goto out_with_sync_error;
        }

      /* check the operation type */
      switch (vip_desc_ptr->CS.Control & VIP_CONTROL_OP_MASK)
        {
        case VIP_CONTROL_OP_SENDRECV:
          break;

        case VIP_CONTROL_OP_RDMAWRITE:
          VIP_DEBUG (("RDMA Write operation is not valid on recv queue"));
          vip_desc_ptr->CS.Status |= VIP_STATUS_FORMAT_ERROR;
          goto out_with_sync_error;

        case VIP_CONTROL_OP_RDMAREAD:
          VIP_DEBUG (("RDMA Read operation is not valid on recv queue"));
          vip_desc_ptr->CS.Status |= VIP_STATUS_FORMAT_ERROR;
          goto out_with_sync_error;

        default:
          VIP_DEBUG (("Control field Operation type is set to Reserved value"));
          vip_desc_ptr->CS.Status |= VIP_STATUS_FORMAT_ERROR;
          goto out_with_sync_error;
        }

      /* check the Data segments */
      if (length > 0)
        {
          for (i = 0; i < vip_desc_ptr->CS.SegCount; i++)
            {
              vip_data_segment_ptr = &(vip_desc_ptr->DS[i].Local);
              if (vip_check_memory_handle (vip_nic_ptr,
                                           vip_data_segment_ptr->Handle,
                                           (VIP_UINTPTR)
                                           vip_data_segment_ptr->Data.Address,
                                           vip_data_segment_ptr->Length,
                                           vip_vi_ptag_id) != VIP_SUCCESS)
                {
                  VIP_DEBUG (("Data segment Memory Handle check error"));
                  vip_desc_ptr->CS.Status |= VIP_STATUS_PROTECTION_ERROR;
                  goto out_with_sync_error;
                }

              total_length += vip_data_segment_ptr->Length;
            }
        }
    }

  /* dispatch each packet type */
  switch (VIP_NTOH_UCHAR (inc_ptr->type))
    {
    case VIP_EAGER_PKT:
    case VIP_EAGER_IMM_PKT:
      VIP_DEBUG_PROTECTED
        (("Received VIP_EAGER_%sPKT from %s/%d\n",
          (VIP_NTOH_UCHAR (inc_ptr->type) == VIP_EAGER_PKT) ? "" : "IMM_",
          gm_node_id_to_host_name (vip_gm_ptr->gm_port,
                                   gm_ntohs (event->recv.sender_node_id)),
          gm_ntohc (event->recv.sender_port_id)));

      vip_desc_ptr->CS.Status |= VIP_STATUS_OP_RECEIVE;

      /* check if the recv descriptor is large enough */
      if (total_length < length)
        {
          VIP_DEBUG (("Data overrun"));
          vip_desc_ptr->CS.Length = 0;
          vip_desc_ptr->CS.Status |= VIP_STATUS_LENGTH_ERROR;
          if (VIP_NTOH_UCHAR (inc_ptr->type) == VIP_EAGER_IMM_PKT)
            {
              vip_desc_ptr->CS.Status |= VIP_STATUS_IMMEDIATE;
            }
          goto out_with_sync_error;
        }

      /* copy immediate data */
      data_ptr = NULL;
      if (VIP_NTOH_UCHAR (inc_ptr->type) == VIP_EAGER_IMM_PKT)
        {
          vip_desc_ptr->CS.Status |= VIP_STATUS_IMMEDIATE;

          switch (vip_vi_ptr->reliability)
            {
            case VIP_SERVICE_UNRELIABLE:
              vip_desc_ptr->CS.ImmediateData =
                VIP_NTOH_UINT32(inc_ptr->vip_pkt_eager_imm_ur.net_imm_data);
              data_ptr = (VIP_PVOID) (((VIP_UINTPTR) inc_ptr)
                                      + sizeof (VIP_PACKET_EAGER_IMM_UR));
              break;

            case VIP_SERVICE_RELIABLE_DELIVERY:
              vip_desc_ptr->CS.ImmediateData =
                VIP_NTOH_UINT32(inc_ptr->vip_pkt_eager_imm_rd.net_imm_data);
              data_ptr = (VIP_PVOID) (((VIP_UINTPTR) inc_ptr)
                                      + sizeof (VIP_PACKET_EAGER_IMM_RD));
              break;

            case VIP_SERVICE_RELIABLE_RECEPTION:
              vip_desc_ptr->CS.ImmediateData =
                VIP_NTOH_UINT32(inc_ptr->vip_pkt_eager_imm_rr.net_imm_data);
              data_ptr = (VIP_PVOID) (((VIP_UINTPTR) inc_ptr)
                                      + sizeof (VIP_PACKET_EAGER_IMM_RR));
              break;
            }
        }
      else
        {
          switch (vip_vi_ptr->reliability)
            {
            case VIP_SERVICE_UNRELIABLE:
              data_ptr = (VIP_PVOID) (((VIP_UINTPTR) inc_ptr)
                                      + sizeof (VIP_PACKET_EAGER_UR));
              break;

            case VIP_SERVICE_RELIABLE_DELIVERY:
              data_ptr = (VIP_PVOID) (((VIP_UINTPTR) inc_ptr)
                                      + sizeof (VIP_PACKET_EAGER_RD));
              break;

            case VIP_SERVICE_RELIABLE_RECEPTION:
              data_ptr = (VIP_PVOID) (((VIP_UINTPTR) inc_ptr)
                                      + sizeof (VIP_PACKET_EAGER_RR));
              break;
            }
        }

      /* copy the incoming data into the Data segments */
      vip_desc_ptr->CS.Length = length;
      if (length > 0)
        {
          for (i = 0; i < vip_desc_ptr->CS.SegCount; i++)
            {
              vip_data_segment_ptr = &(vip_desc_ptr->DS[i].Local);
              if (length > vip_data_segment_ptr->Length)
                {
                  data_length = vip_data_segment_ptr->Length;
                  memcpy (vip_data_segment_ptr->Data.Address, data_ptr,
                          vip_data_segment_ptr->Length);
                  data_ptr = (VIP_PVOID)
                    ((VIP_UINTPTR) data_ptr + vip_data_segment_ptr->Length);
                  length -= vip_data_segment_ptr->Length;
                }
              else
                {
                  memcpy (vip_data_segment_ptr->Data.Address, data_ptr,
                          length);
                  data_ptr = (VIP_PVOID) ((VIP_UINTPTR) data_ptr + length);
                  length = 0;
                  break;
                }
            }
        }

      /* notify the completion */
      vip_notify_desc_completion (vip_desc_ptr, vip_vi_ptr, VIP_TRUE);

      /* send the report if reliable reception */
      if (vip_vi_ptr->reliability == VIP_SERVICE_RELIABLE_RECEPTION)
        {
          /* return a remote descriptor error report */
          vip_return_report (vip_gm_ptr, vip_nic_ptr, vip_vi_ptr,
                             VIP_REPORT_COMPLETION_RR, VIP_TRUE);
        }

      /* shift to the next recv descriptor */
      VIP_ASSERT (vip_vi_ptr->recv_queue.count_to_process > 0);
      vip_vi_ptr->recv_queue.count_to_process--;
      vip_vi_ptr->recv_queue.current_desc = vip_desc_ptr->CS.Next.Address;
      vip_vi_ptr->recv_queue.current_mem = vip_desc_ptr->CS.NextHandle;
      break;

    case VIP_3WAY_REQ_PKT:
      VIP_DEBUG_PROTECTED
        (("Received VIP_3WAY_REQ_PKT from %s/%d\n",
          gm_node_id_to_host_name (vip_gm_ptr->gm_port,
                                   gm_ntohs (event->recv.sender_node_id)),
          gm_ntohc (event->recv.sender_port_id)));

      vip_desc_ptr->CS.Status |= VIP_STATUS_OP_RECEIVE;

      /* check if the recv descriptor is large enough */
      if (total_length < length)
        {
          VIP_DEBUG (("Data overrun"));
          vip_desc_ptr->CS.Length = 0;
          vip_desc_ptr->CS.Status |= VIP_STATUS_LENGTH_ERROR;
          goto out_with_sync_error;
        }

      /* check (again) the memory handles */
      i = 0;
      data_length = 0;
      while (data_length < length)
        {
          data_length += vip_desc_ptr->DS[i].Local.Length;
          if (vip_desc_ptr->DS[i].Local.Length > 0)
            {
              i++;
            }
        }
      VIP_ASSERT (i <= vip_desc_ptr->CS.SegCount);

      /* send the 3way OK to send */
      i = ((i * sizeof (VIP_SEGMENT_HEADER)) + sizeof (VIP_PACKET_3WAY_OK));
      vip_send_req_ptr = vip_allocate_packet (vip_gm_ptr, i);
      VIP_ASSERT (vip_send_req_ptr != NULL);
      pkt_ptr = (VIP_PACKET *) (vip_send_req_ptr->ptr);
      VIP_FILL_GENERIC_HEAD (pkt_ptr, 0, vip_vi_ptr, VIP_3WAY_OK_PKT);
      pkt_ptr->vip_pkt_3way_ok.net_local_nic_index =
        VIP_HTON_UINT16 (vip_nic_ptr->index);
      pkt_ptr->vip_pkt_3way_ok.net_local_vi_index =
        VIP_HTON_UINT16 (vip_vi_ptr->index);

      i = 0;
      data_length = 0;
      while (data_length < length)
        {
          pkt_ptr->vip_pkt_3way_ok.segments[i].address =
            VIP_HTON_UINT64 (vip_desc_ptr->DS[i].Local.Data.AddressBits);
          pkt_ptr->vip_pkt_3way_ok.segments[i].length =
            VIP_HTON_UINT64 (vip_desc_ptr->DS[i].Local.Length);

          data_length += vip_desc_ptr->DS[i].Local.Length;
          if (vip_desc_ptr->DS[i].Local.Length > 0)
            {
              i++;
            }
        }
      pkt_ptr->vip_pkt_3way_ok.seg_count = VIP_HTON_UINT16 (i);

      vip_send_req_ptr->type |= VIP_SEND_REQ_RELIABLE;
      vip_send_req_ptr->dest_port_id = vip_vi_ptr->gm_dest_port;
      vip_send_req_ptr->dest_gm_id = vip_vi_ptr->gm_dest_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);
      break;


    case VIP_PUT_REQ_IMM_PKT:
      VIP_DEBUG_PROTECTED
        (("Received VIP_PUT_REQ_IMM_PKT from %s/%d\n",
          gm_node_id_to_host_name (vip_gm_ptr->gm_port,
                                   gm_ntohs (event->recv.sender_node_id)),
          gm_ntohc (event->recv.sender_port_id)));

      vip_desc_ptr->CS.Status |= VIP_STATUS_OP_REMOTE_RDMA_WRITE;
      vip_desc_ptr->CS.Status |= VIP_STATUS_IMMEDIATE;

      /* check if RDMA Write is enabled on the VI */
      if (vip_vi_ptr->rdma_write == VIP_FALSE)
        {
          VIP_DEBUG (("RDMA Write is not enabled on the VI"));
          vip_desc_ptr->CS.Status |= VIP_STATUS_PROTECTION_ERROR;
          goto sync_rdma_prot_error;
        }

      if (length > 0)
        {
          /* check the memory handle */
          if (vip_check_memory_handle
              (vip_nic_ptr,
               VIP_NTOH_UINT32 (inc_ptr->vip_pkt_put_req_imm.net_remote_mem),
               VIP_NTOH_UINT64 (inc_ptr->vip_pkt_put_req_imm.net_remote_buf),
               length, vip_vi_ptr->vip_ptag_ptr->id) != VIP_SUCCESS)
            {
              VIP_DEBUG (("Data segment Memory Handle check error"));
              vip_desc_ptr->CS.Status |= VIP_STATUS_PROTECTION_ERROR;
              goto sync_rdma_prot_error;
            }

          /* check RDMA write authorization */
          if (vip_nic_ptr->vip_mem_handle_ptrs
              [VIP_NTOH_UINT32
               (inc_ptr->vip_pkt_put_req_imm.net_remote_mem)]->rdma_write ==
              VIP_FALSE)
            {
              VIP_DEBUG (("RDMA write not allowed on the data segment"));
              vip_desc_ptr->CS.Status |= VIP_STATUS_PROTECTION_ERROR;
              goto sync_rdma_prot_error;
            }
        }

      /* copy immediate data */
      vip_desc_ptr->CS.ImmediateData =
        VIP_NTOH_UINT32(inc_ptr->vip_pkt_put_req_imm.net_imm_data);
      
#ifndef VI_GM_FAST_RDMA
      /* send the PUT OK to send */
      vip_send_req_ptr = vip_allocate_packet (vip_gm_ptr,
                                              sizeof (VIP_PACKET_PUT_OK));
      VIP_ASSERT (vip_send_req_ptr != NULL);
      pkt_ptr = (VIP_PACKET *) (vip_send_req_ptr->ptr);
      VIP_FILL_GENERIC_HEAD (pkt_ptr, 0, vip_vi_ptr, VIP_PUT_OK_PKT);
      pkt_ptr->vip_pkt_put_ok.net_local_nic_index =
        VIP_HTON_UINT16 (vip_nic_ptr->index);
      pkt_ptr->vip_pkt_put_ok.net_local_vi_index =
        VIP_HTON_UINT16 (vip_vi_ptr->index);

      vip_send_req_ptr->type |= VIP_SEND_REQ_RELIABLE;
      vip_send_req_ptr->dest_port_id = vip_vi_ptr->gm_dest_port;
      vip_send_req_ptr->dest_gm_id = vip_vi_ptr->gm_dest_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);
#endif
      break;

    default:
      VIP_ABORT (("Unknown packet type in incoming matching message (%d)",
                  VIP_NTOH_UCHAR (inc_ptr->type)));
    }

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

out_with_sync_error:
  /* complete the current descriptor */
  vip_notify_desc_completion (vip_desc_ptr, vip_vi_ptr, VIP_TRUE);
  switch (vip_vi_ptr->reliability)
    {
    case VIP_SERVICE_UNRELIABLE:
      /* shift to the next recv descriptor */
      VIP_ASSERT (vip_vi_ptr->recv_queue.count_to_process > 0);
      vip_vi_ptr->recv_queue.count_to_process--;
      vip_vi_ptr->recv_queue.current_desc = vip_desc_ptr->CS.Next.Address;
      vip_vi_ptr->recv_queue.current_mem = vip_desc_ptr->CS.NextHandle;

      if ((VIP_NTOH_UCHAR (inc_ptr->type) == VIP_3WAY_REQ_PKT)
          || (VIP_NTOH_UCHAR (inc_ptr->type) == VIP_PUT_REQ_IMM_PKT))
        {
          /* return a remote descriptor error report */
          vip_return_report (vip_gm_ptr, vip_nic_ptr, vip_vi_ptr,
                             VIP_REPORT_REM_DESC_ERROR, VIP_TRUE);
        }
      break;

    case VIP_SERVICE_RELIABLE_DELIVERY:
      if ((VIP_NTOH_UCHAR (inc_ptr->type) == VIP_3WAY_REQ_PKT)
          || (VIP_NTOH_UCHAR (inc_ptr->type) == VIP_PUT_REQ_IMM_PKT))
        {
          /* return a remote descriptor error report */
          vip_return_report (vip_gm_ptr, vip_nic_ptr, vip_vi_ptr,
                             VIP_REPORT_REM_DESC_ERROR, VIP_TRUE);

          /* the VI transition to error state */
          vip_vi_transition_to_error_state (vip_vi_ptr, VIP_FALSE);
        }
      else
        {
          /* 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);
      break;

    case VIP_SERVICE_RELIABLE_RECEPTION:
      /* the VI transition to error state */
      vip_vi_transition_to_error_state (vip_vi_ptr, VIP_FALSE);

      /* 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 a remote descriptor error report */
      vip_return_report (vip_gm_ptr, vip_nic_ptr, vip_vi_ptr,
                         VIP_REPORT_REM_DESC_ERROR, VIP_TRUE);
      break;
    }
  VIP_DEBUG (("Synchronous error"));
  VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
  return;

sync_rdma_prot_error:
  /* complete the current descriptor */
  vip_notify_desc_completion (vip_desc_ptr, vip_vi_ptr, VIP_TRUE);

  switch (vip_vi_ptr->reliability)
    {
    case VIP_SERVICE_UNRELIABLE:
      /* shift to the next recv descriptor */
      VIP_ASSERT (vip_vi_ptr->recv_queue.count_to_process > 0);
      vip_vi_ptr->recv_queue.count_to_process--;
      vip_vi_ptr->recv_queue.current_desc = vip_desc_ptr->CS.Next.Address;
      vip_vi_ptr->recv_queue.current_mem = vip_desc_ptr->CS.NextHandle;

      if ((VIP_NTOH_UCHAR (inc_ptr->type) == VIP_3WAY_REQ_PKT)
          || (VIP_NTOH_UCHAR (inc_ptr->type) == VIP_PUT_REQ_IMM_PKT))
        {
          /* return a remote descriptor error report */
          vip_return_report (vip_gm_ptr, vip_nic_ptr, vip_vi_ptr,
                             VIP_REPORT_RDMA_PROT_ERROR, VIP_TRUE);
        }
      break;

    case VIP_SERVICE_RELIABLE_DELIVERY:
      if ((VIP_NTOH_UCHAR (inc_ptr->type) == VIP_3WAY_REQ_PKT)
          || (VIP_NTOH_UCHAR (inc_ptr->type) == VIP_PUT_REQ_IMM_PKT))
        {
          /* return a remote descriptor error report */
          vip_return_report (vip_gm_ptr, vip_nic_ptr, vip_vi_ptr,
                             VIP_REPORT_RDMA_PROT_ERROR, VIP_TRUE);
        }

      /* 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);
      break;

    case VIP_SERVICE_RELIABLE_RECEPTION:
      /* the VI transition to error state */
      vip_vi_transition_to_error_state (vip_vi_ptr, VIP_FALSE);

      /* 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 a remote descriptor error report */
      vip_return_report (vip_gm_ptr, vip_nic_ptr, vip_vi_ptr,
                         VIP_REPORT_RDMA_PROT_ERROR, VIP_TRUE);
      break;
    }

  VIP_DEBUG (("RDMA Write protection error"));
  VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
  return;

async_comp_desc_error:
  /* generate the asynchronous error */
  vip_generate_async_error (vip_nic_ptr, vip_vi_ptr, NULL, vip_desc_ptr,
                            VIP_RESOURCE_DESCRIPTOR, VIP_ERROR_COMP_PROT, 0);

  if (vip_vi_ptr->reliability == VIP_SERVICE_RELIABLE_RECEPTION)
    {
      /* return a remote descriptor error report */
      vip_return_report (vip_gm_ptr, vip_nic_ptr, vip_vi_ptr,
                         VIP_REPORT_REM_DESC_ERROR, VIP_TRUE);

      /* the VI transition to error state */
      vip_vi_transition_to_error_state (vip_vi_ptr, VIP_FALSE);

      /* 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);
    }
  else
    {
      /* 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);
    }

  VIP_DEBUG (("Asynchronous Post Descriptor error"));
  VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
  return;
}

static void
vip_handle_3way_ok (VIP_PACKET_3WAY_OK * ptr,
                    gm_recv_event_t * event, 
                    VIP_GM * vip_gm_ptr)
{
  VIP_VI *vip_vi_ptr;
  VIP_NIC *vip_nic_ptr;
  VIP_UINT32 chunck_length;
  VIP_UINT32 total_length;
  VIP_PVOID source_ptr;
  VIP_PVOID64 target_ptr;
  VIP_UINT32 source_length;
  VIP_UINT32 target_length;
  VIP_UCHAR source_curseg;
  VIP_UCHAR target_curseg;
  VIP_UINT16 source_segnum;
  VIP_UINT16 target_segnum;
  VIP_PACKET *pkt_ptr;
  VIP_DESCRIPTOR *vip_desc_ptr;
  VIP_SEND_REQ *vip_send_req_ptr;
  VIP_DEBUG_LABEL (("vip_handle_3way_ok"));

  /* check the NIC and VI */
  if (vip_check_nic_and_vi (vip_gm_ptr, event, (VIP_PACKET_EAGER_UR *) ptr,
                            &vip_nic_ptr, &vip_vi_ptr,
                            VIP_FALSE) != VIP_SUCCESS)
    {
      if (vip_nic_ptr != NULL)
        {
          VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
        }
      return;
    }

  /* check if the VI is in connected state */
  if (vip_vi_ptr->state != VIP_STATE_CONNECTED)
    {
      VIP_DEBUG (("VI is not in connected state, refuse incoming packet"));
      VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
      return;
    }

  vip_desc_ptr = vip_vi_ptr->send_queue.current_desc;
  VIP_ASSERT (vip_desc_ptr != NULL);
  VIP_ASSERT ((vip_desc_ptr->CS.Status & VIP_STATUS_DONE) == 0);

  source_ptr = vip_desc_ptr->DS[0].Local.Data.Address;
  source_length = vip_desc_ptr->DS[0].Local.Length;
  source_curseg = 0;
  source_segnum = vip_desc_ptr->CS.SegCount;
  target_ptr.AddressBits = VIP_NTOH_UINT64 (ptr->segments[0].address);
  target_length = VIP_NTOH_UINT64 (ptr->segments[0].length);
  target_curseg = 0;
  target_segnum = VIP_NTOH_UINT16 (ptr->seg_count);
  total_length = 0;

  while (1)
    {
      if (source_length < target_length)
        {
          chunck_length = source_length;
        }
      else
        {
          chunck_length = target_length;
        }

      vip_send_req_ptr = vip_allocate_packet (vip_gm_ptr, 0);
      VIP_ASSERT (vip_send_req_ptr != NULL);
      vip_send_req_ptr->type |= VIP_SEND_REQ_RDMA_WRITE;
      vip_send_req_ptr->dest_port_id = vip_vi_ptr->gm_dest_port;
      vip_send_req_ptr->dest_gm_id = vip_vi_ptr->gm_dest_id;
      vip_send_req_ptr->length = chunck_length;
      vip_send_req_ptr->target_ptr = target_ptr;
      vip_send_req_ptr->ptr = source_ptr;
      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);

      source_length -= chunck_length;
      target_length -= chunck_length;
      source_ptr = (VIP_PVOID) (((VIP_UINTPTR) source_ptr) + chunck_length);
      target_ptr.AddressBits += chunck_length;
      total_length += chunck_length;

      while (source_length == 0)
        {
          source_curseg++;
          if (source_curseg < source_segnum)
            {
              source_ptr = vip_desc_ptr->DS[source_curseg].Local.Data.Address;
              source_length = vip_desc_ptr->DS[source_curseg].Local.Length;
            }
          else
            {
              goto end_scatter;
            }
        }

      while (target_length == 0)
        {
          target_curseg++;
          if (target_curseg < target_segnum)
            {
              target_ptr.AddressBits =
                VIP_NTOH_UINT64 (ptr->segments[target_curseg].address);
              target_length =
                VIP_NTOH_UINT64 (ptr->segments[target_curseg].length);
            }
          else
            {
              VIP_ABORT (("Internal error (segment number overflow)"));
            }
        }
    }

end_scatter:
  VIP_ASSERT (total_length == vip_desc_ptr->CS.Length);

  /* immediate data ? */
  if ((vip_desc_ptr->CS.Control & VIP_CONTROL_IMMEDIATE) != 0)
    {
      VIP_DEBUG (("3Way DONE with immediate"));

      vip_send_req_ptr =
        vip_allocate_packet (vip_gm_ptr, sizeof (VIP_PACKET_3WAY_DONE_IMM));
      VIP_ASSERT (vip_send_req_ptr != NULL);
      pkt_ptr = (VIP_PACKET *) (vip_send_req_ptr->ptr);
      VIP_FILL_GENERIC_HEAD (pkt_ptr, total_length, vip_vi_ptr,
                             VIP_3WAY_DONE_IMM_PKT);
      pkt_ptr->vip_pkt_3way_done_imm.net_imm_data =
        VIP_HTON_UINT32(vip_desc_ptr->CS.ImmediateData);
    }
  else
    {
      VIP_DEBUG (("3Way DONE"));

      vip_send_req_ptr =
        vip_allocate_packet (vip_gm_ptr, sizeof (VIP_PACKET_3WAY_DONE));
      VIP_ASSERT (vip_send_req_ptr != NULL);
      pkt_ptr = (VIP_PACKET *) (vip_send_req_ptr->ptr);
      VIP_FILL_GENERIC_HEAD (pkt_ptr, total_length, vip_vi_ptr,
                             VIP_3WAY_DONE_PKT);
    }

  pkt_ptr->vip_pkt_3way_done.net_local_nic_index =
    VIP_HTON_UINT16 (vip_nic_ptr->index);
  pkt_ptr->vip_pkt_3way_done.net_local_vi_index =
    VIP_HTON_UINT16 (vip_vi_ptr->index);

  vip_send_req_ptr->type |= VIP_SEND_REQ_RELIABLE;
  vip_send_req_ptr->dest_port_id = vip_vi_ptr->gm_dest_port;
  vip_send_req_ptr->dest_gm_id = vip_vi_ptr->gm_dest_id;
  vip_send_req_ptr->vip_nic_ptr = vip_nic_ptr;
  vip_send_req_ptr->vip_vi_ptr = vip_vi_ptr;
  vip_send_req_ptr->vip_desc_ptr = vip_desc_ptr;
  vip_send_data (vip_send_req_ptr);

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

static void
vip_handle_3way_done (VIP_PACKET_3WAY_DONE * ptr,
                      gm_recv_event_t * event, 
                      VIP_GM * vip_gm_ptr)
{
  VIP_VI *vip_vi_ptr;
  VIP_NIC *vip_nic_ptr;
  VIP_UINT32 length;
  VIP_DESCRIPTOR *vip_desc_ptr;
  VIP_DEBUG_LABEL (("vip_handle_3way_done"));

  length = (((VIP_NTOH_UCHAR (ptr->length_24)) << 16)
            + ((VIP_NTOH_UCHAR (ptr->length_16)) << 8)
            + VIP_NTOH_UCHAR (ptr->length_8));

  /* check the NIC and VI */
  if (vip_check_nic_and_vi (vip_gm_ptr, event, (VIP_PACKET_EAGER_UR *) ptr,
                            &vip_nic_ptr, &vip_vi_ptr,
                            VIP_TRUE) != VIP_SUCCESS)
    {
      if (vip_nic_ptr != NULL)
        {
          VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
        }
      return;
    }

  /* check if the VI is in connected state */
  if (vip_vi_ptr->state != VIP_STATE_CONNECTED)
    {
      VIP_DEBUG (("VI is not in connected state, refuse incoming packet"));
      VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
      return;
    }

  vip_desc_ptr = vip_vi_ptr->recv_queue.current_desc;
  VIP_ASSERT (vip_desc_ptr != NULL);
  VIP_ASSERT ((vip_desc_ptr->CS.Status & VIP_STATUS_DONE) == 0);

  /* update length in descriptor */
  vip_desc_ptr->CS.Length = length;

  /* copy immediate data */
  if (VIP_NTOH_UCHAR (ptr->type) == VIP_3WAY_DONE_IMM_PKT)
    {
      vip_desc_ptr->CS.ImmediateData =
        VIP_NTOH_UINT32(((VIP_PACKET_3WAY_DONE_IMM *) ptr)->net_imm_data);

      vip_desc_ptr->CS.Status |= VIP_STATUS_IMMEDIATE;
    }

  vip_notify_desc_completion (vip_desc_ptr, vip_vi_ptr, VIP_TRUE);

  /* send the report if reliable reception */
  if (vip_vi_ptr->reliability == VIP_SERVICE_RELIABLE_RECEPTION)
    {
      vip_return_report (vip_gm_ptr, vip_nic_ptr, vip_vi_ptr,
                         VIP_REPORT_COMPLETION_RR, VIP_TRUE);
    }

  /* shift to the next recv descriptor */
  VIP_ASSERT (vip_vi_ptr->recv_queue.count_to_process > 0);
  vip_vi_ptr->recv_queue.count_to_process--;
  vip_vi_ptr->recv_queue.current_desc = vip_desc_ptr->CS.Next.Address;
  vip_vi_ptr->recv_queue.current_mem = vip_desc_ptr->CS.NextHandle;

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

static void
vip_handle_put_req (VIP_PACKET_PUT_REQ * ptr,
                    gm_recv_event_t * event, 
                    VIP_GM * vip_gm_ptr)
{
  VIP_VI *vip_vi_ptr;
  VIP_NIC *vip_nic_ptr;
  VIP_UINT32 length;
  VIP_UINT32 vip_vi_ptag_id;
  VIP_PACKET *pkt_ptr;
  VIP_SEND_REQ *vip_send_req_ptr;
  VIP_DEBUG_LABEL (("vip_handle_put_req"));

  length = (((VIP_NTOH_UCHAR (ptr->length_24)) << 16)
            + ((VIP_NTOH_UCHAR (ptr->length_16)) << 8)
            + VIP_NTOH_UCHAR (ptr->length_8));

  /* check the NIC and VI */
  if (vip_check_nic_and_vi (vip_gm_ptr, event, (VIP_PACKET_EAGER_UR *) ptr,
                            &vip_nic_ptr, &vip_vi_ptr,
                            VIP_TRUE) != VIP_SUCCESS)
    {
      if (vip_nic_ptr != NULL)
        {
          VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
        }
      return;
    }

  /* check if the VI is in connected state */
  if (vip_vi_ptr->state != VIP_STATE_CONNECTED)
    {
      VIP_DEBUG (("VI is not in connected state, refuse incoming packet"));
      VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
      return;
    }

  /* check if RDMA Write is enabled on the VI */
  if (vip_vi_ptr->rdma_write == VIP_FALSE)
    {
      VIP_DEBUG (("RDMA Write is not enabled on the VI"));
      goto out_with_rdma_protection_error;
    }

  if (length > 0)
    {
      /* check VI PTAG handle */
      if (VIP_INVALID_PTAG_HANDLE (vip_vi_ptr->vip_ptag_ptr))
        {
          VIP_DEBUG (("Invalid VI PTAG handle"));
          goto out_with_rdma_protection_error;
        }
      vip_vi_ptag_id = vip_vi_ptr->vip_ptag_ptr->id;

      /* check the memory handle */
      if (vip_check_memory_handle (vip_nic_ptr,
                                   VIP_NTOH_UINT32 (ptr->net_remote_mem),
                                   VIP_NTOH_UINT64 (ptr->net_remote_buf),
                                   length, vip_vi_ptr->vip_ptag_ptr->id)
          != VIP_SUCCESS)
        {
          VIP_DEBUG (("Data segment Memory Handle check error"));
          goto out_with_rdma_protection_error;
        }

      /* check RDMA write authorization */
      if (vip_nic_ptr->vip_mem_handle_ptrs
          [VIP_NTOH_UINT32 (ptr->net_remote_mem)]->rdma_write == VIP_FALSE)
        {
          VIP_DEBUG (("RDMA write not allowed on the data segment"));
          goto out_with_rdma_protection_error;
        }
    }

  /* send the PUT OK to send */
  vip_send_req_ptr = vip_allocate_packet (vip_gm_ptr,
                                          sizeof (VIP_PACKET_PUT_OK));
  VIP_ASSERT (vip_send_req_ptr != NULL);
  pkt_ptr = (VIP_PACKET *) (vip_send_req_ptr->ptr);
  VIP_FILL_GENERIC_HEAD (pkt_ptr, 0, vip_vi_ptr, VIP_PUT_OK_PKT);

  pkt_ptr->vip_pkt_put_ok.net_local_nic_index =
    VIP_HTON_UINT16 (vip_nic_ptr->index);
  pkt_ptr->vip_pkt_put_ok.net_local_vi_index =
    VIP_HTON_UINT16 (vip_vi_ptr->index);

  vip_send_req_ptr->type |= VIP_SEND_REQ_RELIABLE;
  vip_send_req_ptr->dest_port_id = vip_vi_ptr->gm_dest_port;
  vip_send_req_ptr->dest_gm_id = vip_vi_ptr->gm_dest_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);

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

out_with_rdma_protection_error:
  switch (vip_vi_ptr->reliability)
    {
    case VIP_SERVICE_UNRELIABLE:
      /* return a remote descriptor error report */
      vip_return_report (vip_gm_ptr, vip_nic_ptr, vip_vi_ptr,
                         VIP_REPORT_RDMA_PROT_ERROR, VIP_TRUE);
      break;

    case VIP_SERVICE_RELIABLE_DELIVERY:
      /* return a remote descriptor error report */
      vip_return_report (vip_gm_ptr, vip_nic_ptr, vip_vi_ptr,
                         VIP_REPORT_RDMA_PROT_ERROR, VIP_TRUE);

      /* generate the asynchronous error */
      vip_generate_async_error (vip_nic_ptr, vip_vi_ptr, NULL, NULL,
                                VIP_RESOURCE_VI, VIP_ERROR_RDMAW_PROT, 0);

      /* 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);
      break;

    case VIP_SERVICE_RELIABLE_RECEPTION:
      /* return a remote descriptor error report */
      vip_return_report (vip_gm_ptr, vip_nic_ptr, vip_vi_ptr,
                         VIP_REPORT_RDMA_PROT_ERROR, VIP_TRUE);

      /* generate the asynchronous error */
      vip_generate_async_error (vip_nic_ptr, vip_vi_ptr, NULL, NULL,
                                VIP_RESOURCE_VI, VIP_ERROR_RDMAW_PROT, 0);

      /* the VI transition to error state */
      vip_vi_transition_to_error_state (vip_vi_ptr, VIP_FALSE);

      /* 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);
      break;
    }

  VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
  return;
}

static void
vip_handle_put_ok (VIP_PACKET_PUT_OK * ptr,
                   gm_recv_event_t * event, 
                   VIP_GM * vip_gm_ptr)
{
  VIP_VI *vip_vi_ptr;
  VIP_NIC