misc: fix coverity warnings

[vpp.git] / src / vppinfra / linux / mem.c

diff --git a/src/vppinfra/linux/mem.c b/src/vppinfra/linux/mem.c
index 2fbda96..5826a6a 100644 (file)
--- a/src/vppinfra/linux/mem.c
+++ b/src/vppinfra/linux/mem.c
@@ -46,8 +46,49 @@
 #define F_SEAL_WRITE    0x0008 /* prevent writes */
 #endif
 
+
+uword
+clib_mem_get_page_size (void)
+{
+  return getpagesize ();
+}
+
+uword
+clib_mem_get_default_hugepage_size (void)
+{
+  unformat_input_t input;
+  static u32 size = 0;
+  int fd;
+
+  if (size)
+    goto done;
+
+  /*
+   * If the kernel doesn't support hugepages, /proc/meminfo won't
+   * say anything about it. Use the regular page size as a default.
+   */
+  size = clib_mem_get_page_size () / 1024;
+
+  if ((fd = open ("/proc/meminfo", 0)) == -1)
+    return 0;
+
+  unformat_init_clib_file (&input, fd);
+
+  while (unformat_check_input (&input) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat (&input, "Hugepagesize:%_%u kB", &size))
+       ;
+      else
+       unformat_skip_line (&input);
+    }
+  unformat_free (&input);
+  close (fd);
+done:
+  return 1024ULL * size;
+}
+
 u64
-clib_mem_vm_get_page_size (int fd)
+clib_mem_get_fd_page_size (int fd)
 {
   struct stat st = { 0 };
   if (fstat (fd, &st) == -1)
@@ -56,9 +97,9 @@ clib_mem_vm_get_page_size (int fd)
 }
 
 int
-clib_mem_vm_get_log2_page_size (int fd)
+clib_mem_get_fd_log2_page_size (int fd)
 {
-  return min_log2 (clib_mem_vm_get_page_size (fd));
+  return min_log2 (clib_mem_get_fd_page_size (fd));
 }
 
 void
@@ -81,6 +122,26 @@ clib_mem_vm_randomize_va (uword * requested_va, u32 log2_page_size)
 #define MFD_HUGETLB 0x0004U
 #endif
 
+clib_error_t *
+clib_mem_create_fd (char *name, int *fdp)
+{
+  int fd;
+
+  ASSERT (name);
+
+  if ((fd = memfd_create (name, MFD_ALLOW_SEALING)) == -1)
+    return clib_error_return_unix (0, "memfd_create");
+
+  if ((fcntl (fd, F_ADD_SEALS, F_SEAL_SHRINK)) == -1)
+    {
+      close (fd);
+      return clib_error_return_unix (0, "fcntl (F_ADD_SEALS)");
+    }
+
+  *fdp = fd;
+  return 0;
+}
+
 clib_error_t *
 clib_mem_create_hugetlb_fd (char *name, int *fdp)
 {
@@ -177,20 +238,11 @@ clib_mem_vm_ext_alloc (clib_mem_vm_alloc_t * a)
        }
       else
        {
-         if ((fd = memfd_create (a->name, MFD_ALLOW_SEALING)) == -1)
-           {
-             err = clib_error_return_unix (0, "memfd_create");
-             goto error;
-           }
-
-         if ((fcntl (fd, F_ADD_SEALS, F_SEAL_SHRINK)) == -1)
-           {
-             err = clib_error_return_unix (0, "fcntl (F_ADD_SEALS)");
-             goto error;
-           }
+         if ((err = clib_mem_create_fd (a->name, &fd)))
+           goto error;
        }
 
-      log2_page_size = clib_mem_vm_get_log2_page_size (fd);
+      log2_page_size = clib_mem_get_fd_log2_page_size (fd);
       if (log2_page_size == 0)
        {
          err = clib_error_return_unix (0, "cannot determine page size");
@@ -269,6 +321,7 @@ clib_mem_vm_ext_alloc (clib_mem_vm_alloc_t * a)
   a->n_pages = n_pages;
   a->addr = addr;
   a->fd = fd;
+  CLIB_MEM_UNPOISON (addr, a->size);
   goto done;
 
 error:
@@ -291,6 +344,38 @@ clib_mem_vm_ext_free (clib_mem_vm_alloc_t * a)
     }
 }
 
+uword
+clib_mem_vm_reserve (uword start, uword size, u32 log2_page_sz)
+{
+  uword off, pagesize = 1ULL << log2_page_sz;
+  int mmap_flags = MAP_PRIVATE | MAP_ANONYMOUS;
+  u8 *p;
+
+  if (start)
+    mmap_flags |= MAP_FIXED;
+
+  size = round_pow2 (size, pagesize);
+
+  p = uword_to_pointer (start, void *);
+  p = mmap (p, size + pagesize, PROT_NONE, mmap_flags, -1, 0);
+
+  if (p == MAP_FAILED)
+    return ~0;
+
+  off = round_pow2 ((uword) p, pagesize) - (uword) p;
+
+  /* trim start and end of reservation to be page aligned */
+  if (off)
+    {
+      munmap (p, off);
+      p += off;
+    }
+
+  munmap (p + size, pagesize - off);
+
+  return (uword) p;
+}
+
 u64 *
 clib_mem_vm_get_paddr (void *mem, int log2_page_size, int n_pages)
 {
@@ -333,20 +418,59 @@ done:
 clib_error_t *
 clib_mem_vm_ext_map (clib_mem_vm_map_t * a)
 {
+  long unsigned int old_mask[16] = { 0 };
   int mmap_flags = MAP_SHARED;
+  clib_error_t *err = 0;
+  int old_mpol = -1;
   void *addr;
+  int rv;
+
+  if (a->numa_node)
+    {
+      rv = get_mempolicy (&old_mpol, old_mask, sizeof (old_mask) * 8 + 1, 0,
+                         0);
+
+      if (rv == -1)
+       {
+         err = clib_error_return_unix (0, "get_mempolicy");
+         goto done;
+       }
+    }
 
   if (a->requested_va)
     mmap_flags |= MAP_FIXED;
 
+  if (old_mpol != -1)
+    {
+      long unsigned int mask[16] = { 0 };
+      mask[0] = 1 << a->numa_node;
+      rv = set_mempolicy (MPOL_BIND, mask, sizeof (mask) * 8 + 1);
+      if (rv == -1)
+       {
+         err = clib_error_return_unix (0, "set_mempolicy");
+         goto done;
+       }
+    }
+
   addr = (void *) mmap (uword_to_pointer (a->requested_va, void *), a->size,
                        PROT_READ | PROT_WRITE, mmap_flags, a->fd, 0);
 
   if (addr == MAP_FAILED)
     return clib_error_return_unix (0, "mmap");
 
+  /* re-apply old numa memory policy */
+  if (old_mpol != -1 &&
+      set_mempolicy (old_mpol, old_mask, sizeof (old_mask) * 8 + 1) == -1)
+    {
+      err = clib_error_return_unix (0, "set_mempolicy");
+      goto done;
+    }
+
   a->addr = addr;
-  return 0;
+  CLIB_MEM_UNPOISON (addr, a->size);
+
+done:
+  return err;
 }
 
 /*