tests/test-free.c

   1 /* Test of free() function.
   2    Copyright (C) 2020-2021 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16
  17 /* Written by Bruno Haible <bruno@clisp.org>, 2020.  */
  18
  19 #include <config.h>
  20
  21 /* Specification.  */
  22 #include <stdlib.h>
  23
  24 #include <errno.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27 #if defined __linux__
  28 # include <fcntl.h>
  29 # include <stdint.h>
  30 # include <string.h>
  31 # include <sys/mman.h>
  32 #endif
  33
  34 #include "macros.h"
  35
  36 /* The indirection through a volatile function pointer is necessary to prevent
  37    a GCC optimization.  Without it, when optimizing, GCC would "know" that errno
  38    is unchanged by calling free(ptr), when ptr was the result of a malloc(...)
  39    call in the same function.  */
  40 static int
  41 get_errno (void)
  42 {
  43   volatile int err = errno;
  44   return err;
  45 }
  46
  47 static int (* volatile get_errno_func) (void) = get_errno;
  48
  49 int
  50 main ()
  51 {
  52   /* Check that free() preserves errno.  */
  53   {
  54     errno = 1789; /* Liberté, égalité, fraternité.  */
  55     free (NULL);
  56     ASSERT_NO_STDIO (get_errno_func () == 1789);
  57   }
  58   { /* Small memory allocations.  */
  59     #define N 10000
  60     void * volatile ptrs[N];
  61     size_t i;
  62     for (i = 0; i < N; i++)
  63       ptrs[i] = malloc (15);
  64     for (i = 0; i < N; i++)
  65       {
  66         errno = 1789;
  67         free (ptrs[i]);
  68         ASSERT_NO_STDIO (get_errno_func () == 1789);
  69       }
  70     #undef N
  71   }
  72   { /* Medium memory allocations.  */
  73     #define N 1000
  74     void * volatile ptrs[N];
  75     size_t i;
  76     for (i = 0; i < N; i++)
  77       ptrs[i] = malloc (729);
  78     for (i = 0; i < N; i++)
  79       {
  80         errno = 1789;
  81         free (ptrs[i]);
  82         ASSERT_NO_STDIO (get_errno_func () == 1789);
  83       }
  84     #undef N
  85   }
  86   { /* Large memory allocations.  */
  87     #define N 10
  88     void * volatile ptrs[N];
  89     size_t i;
  90     for (i = 0; i < N; i++)
  91       ptrs[i] = malloc (5318153);
  92     for (i = 0; i < N; i++)
  93       {
  94         errno = 1789;
  95         free (ptrs[i]);
  96         ASSERT_NO_STDIO (get_errno_func () == 1789);
  97       }
  98     #undef N
  99   }
 100
 101   /* Test a less common code path.
 102      When malloc() is based on mmap(), free() can sometimes call munmap().
 103      munmap() usually succeeds, but fails in a particular situation: when
 104        - it has to unmap the middle part of a VMA, and
 105        - the number of VMAs of a process is limited and the limit is
 106          already reached.
 107      The latter condition is fulfilled on Linux, when the file
 108      /proc/sys/vm/max_map_count exists.  This file contains the limit
 109        - for Linux >= 2.4.19: 65536 (DEFAULT_MAX_MAP_COUNT in linux/include/linux/sched.h)
 110        - for Linux >= 2.6.31: 65530 (DEFAULT_MAX_MAP_COUNT in linux/include/linux/mm.h).
 111      But do not test it with glibc < 2.15, since that triggers a glibc internal
 112      abort: "malloc.c:3551: munmap_chunk: Assertion `ret == 0' failed."
 113    */
 114   #if defined __linux__ && !(__GLIBC__ == 2 && __GLIBC_MINOR__ < 15)
 115   if (open ("/proc/sys/vm/max_map_count", O_RDONLY) >= 0)
 116     {
 117       /* Preparations.  */
 118       size_t pagesize = getpagesize ();
 119       void *firstpage_backup = malloc (pagesize);
 120       void *lastpage_backup = malloc (pagesize);
 121       /* Allocate a large memory area, as a bumper, so that the MAP_FIXED
 122          allocation later will not overwrite parts of the memory areas
 123          allocated to ld.so or libc.so.  */
 124       void *bumper_region =
 125         mmap (NULL, 0x1000000, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
 126       /* A file descriptor pointing to a regular file.  */
 127       int fd = open ("test-free", O_RDONLY);
 128
 129       if (firstpage_backup != NULL && lastpage_backup != NULL
 130           && bumper_region != (void *)(-1)
 131           && fd >= 0)
 132         {
 133           /* Do a large memory allocation.  */
 134           size_t big_size = 0x1000000;
 135           void * volatile ptr = malloc (big_size - 0x100);
 136           char *ptr_aligned = (char *) ((uintptr_t) ptr & ~(pagesize - 1));
 137           /* This large memory allocation allocated a memory area
 138              from ptr_aligned to ptr_aligned + big_size.
 139              Enlarge this memory area by adding a page before and a page
 140              after it.  */
 141           memcpy (firstpage_backup, ptr_aligned, pagesize);
 142           memcpy (lastpage_backup, ptr_aligned + big_size - pagesize, pagesize);
 143           if (mmap (ptr_aligned - pagesize, pagesize + big_size + pagesize,
 144                     PROT_READ | PROT_WRITE,
 145                     MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED, -1, 0)
 146               != (void *)(-1))
 147             {
 148               memcpy (ptr_aligned, firstpage_backup, pagesize);
 149               memcpy (ptr_aligned + big_size - pagesize, lastpage_backup, pagesize);
 150
 151               /* Now add as many mappings as we can.
 152                  Stop at 65536, in order not to crash the machine (in case the
 153                  limit has been increased by the system administrator).  */
 154               size_t i;
 155               for (i = 0; i < 65536; i++)
 156                 if (mmap (NULL, pagesize, PROT_READ, MAP_FILE | MAP_PRIVATE, fd, 0)
 157                     == (void *)(-1))
 158                   break;
 159               /* Now the number of VMAs of this process has hopefully attained
 160                  its limit.  */
 161
 162               errno = 1789;
 163               /* This call to free() is supposed to call
 164                    munmap (ptr_aligned, big_size);
 165                  which increases the number of VMAs by 1, which is supposed
 166                  to fail.  */
 167               free (ptr);
 168               ASSERT_NO_STDIO (get_errno_func () == 1789);
 169             }
 170         }
 171     }
 172   #endif
 173
 174   return 0;
 175 }