vipregistermem.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 "vipl_priv.h"


VIP_ENTRY_POINT VIP_RETURN
VipRegisterMem (VIP_NIC_HANDLE NicHandle,
                VIP_PVOID VirtualAddress,
                VIP_ULONG Length,
                VIP_MEM_ATTRIBUTES * MemAttribs,
                VIP_MEM_HANDLE * MemoryHandle)
{
  VIP_NIC *vip_nic_ptr;
  VIP_MEM *vip_mem_ptr;
  VIP_GM *vip_gm_ptr;
  VIP_PTAG *vip_ptag_ptr;
  VIP_UINTPTR start;
  VIP_UINTPTR end;
  VIP_UINT32 registered;
  VIP_MEM_HANDLE vip_mem_handle;
  VIP_DEBUG_LABEL (("VipRegisterMem"));


  if (MemoryHandle == NULL)
    {
      VIP_DEBUG (("MemoryHandle is null"));
      return VIP_INVALID_PARAMETER;
    }
  *MemoryHandle = (VIP_MEM_HANDLE) NULL;

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

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

  if (Length > VI_GM_MAX_REGISTER_BLOCK_BYTES)
    {
      VIP_DEBUG (("Length > VI_GM_MAX_REGISTER_BLOCK_BYTES"));
      return VIP_ERROR_RESOURCE;
    }

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

  if (MemAttribs->EnableRdmaRead != VI_GM_ENABLE_RDMAREAD)
    {
      VIP_DEBUG (("Invalid EnableRdmaRead in MemAttribs"));
      return VIP_INVALID_RDMAREAD;
    }

  if ((MemAttribs->EnableRdmaWrite != VIP_TRUE)
      && (MemAttribs->EnableRdmaWrite != VIP_FALSE))
    {
      VIP_DEBUG (("Invalid EnableRdmaWrite in MemAttribs"));
      return VIP_INVALID_PARAMETER;
    }

  /* check nic handle */
  vip_nic_ptr = (VIP_NIC *) NicHandle;
  if (VIP_INVALID_NIC_HANDLE (vip_nic_ptr))
    {
      VIP_DEBUG (("Invalid NIC handle"));
      return VIP_INVALID_PARAMETER;
    }
  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 limit */
  if ((vip_gm_ptr->memory_registered + Length) > VI_GM_MAX_REGISTER_BYTES)
    {
      VIP_DEBUG (("VI_GM_MAX_REGISTER_BYTES reached"));
      VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
      VIP_MUTEX_UNLOCK (&(vip_gm_ptr->lock));
      return VIP_ERROR_RESOURCE;
    }

  /* check ptag */
  vip_ptag_ptr = (VIP_PTAG *) MemAttribs->Ptag;
  if (VIP_INVALID_PTAG_HANDLE (vip_ptag_ptr))
    {
      VIP_DEBUG (("Invalid PTAG handle"));
      VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
      VIP_MUTEX_UNLOCK (&(vip_gm_ptr->lock));
      return VIP_INVALID_PTAG;
    }

  /* check ptag's nic */
  if (vip_ptag_ptr->handle.vip_nic_ptr != vip_nic_ptr)
    {
      VIP_DEBUG (("Invalid NIC in PTAG"));
      VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
      VIP_MUTEX_UNLOCK (&(vip_gm_ptr->lock));
      return VIP_INVALID_PTAG;
    }

  /* allocate regmem */
  vip_mem_ptr = (VIP_MEM *) vip_allocate_handle (&(vip_nic_ptr->vip_mem_set));
  if (vip_mem_ptr == NULL)
    {
      VIP_DEBUG (("VIP_MEM alloc failed"));
      VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
      VIP_MUTEX_UNLOCK (&(vip_gm_ptr->lock));
      return VIP_ERROR_RESOURCE;
    }

  /* try to register memory, using the AVL tree as a cache */
  start = ((VIP_UINTPTR) VirtualAddress) & ~((VIP_UINTPTR) GM_PAGE_LEN - 1);
  end = ((((VIP_UINTPTR) VirtualAddress) 
          + Length + GM_PAGE_LEN - 1) & ~((VIP_UINTPTR) GM_PAGE_LEN - 1));
  registered = vip_avl_register_memory (vip_gm_ptr, start, end);
  VIP_ASSERT (registered <= (end - start));
  if (registered < (end - start))
    {
      vip_avl_deregister_memory (vip_gm_ptr, start, start + registered);
      VIP_DEBUG (("Memory registration failed"));
      vip_free_handle (&(vip_nic_ptr->vip_mem_set),
                       (VIP_HANDLE *) vip_mem_ptr);
      VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
      VIP_MUTEX_UNLOCK (&(vip_gm_ptr->lock));
      return VIP_ERROR_RESOURCE;
    }

  /* increment ptag reference counter */
  vip_ptag_ptr->handle.ref_count++;

  /* update the amount of registered memory */
  vip_gm_ptr->memory_registered += Length;

  vip_mem_ptr->address = VirtualAddress;
  vip_mem_ptr->vip_ptag_ptr = MemAttribs->Ptag;
  vip_mem_ptr->rdma_write = MemAttribs->EnableRdmaWrite;
  vip_mem_ptr->length = Length;

  /* register the mem handle pointer into the mem handle tab */
  vip_mem_handle = vip_nic_ptr->vip_mem_handle_free;
  vip_nic_ptr->vip_mem_handle_free = (VIP_MEM_HANDLE) 
    (((VIP_UINTPTR) (vip_nic_ptr->vip_mem_handle_ptrs[vip_mem_handle])) 
     & 0xFFFFFFFF);
  vip_nic_ptr->vip_mem_handle_ptrs[vip_mem_handle] = vip_mem_ptr;

  *MemoryHandle = vip_mem_handle;
  VIP_DEBUG (("Success"));
  VIP_MUTEX_UNLOCK (&(vip_nic_ptr->lock));
  VIP_MUTEX_UNLOCK (&(vip_gm_ptr->lock));
  return VIP_SUCCESS;
}