/* heap.cc: Cygwin heap manager.

This file is part of Cygwin.

This software is a copyrighted work licensed under the terms of the
Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
details. */

#include "winsup.h"
#include "cygerrno.h"
#include "shared_info.h"
#include "path.h"
#include "fhandler.h"
#include "dtable.h"
#include "cygheap.h"
#include "child_info.h"
#include "ntdll.h"
#include "memory_layout.h"
#include <sys/param.h>

#define assert(x)

static ptrdiff_t page_const;

/* Minimum size of the base heap. */
#define MINHEAP_SIZE (4 * 1024 * 1024)
/* Chunksize of subsequent heap reservations. */
#define RAISEHEAP_SIZE (1 * 1024 * 1024)

static SIZE_T
eval_initial_heap_size ()
{
  PIMAGE_DOS_HEADER dosheader;
  PIMAGE_NT_HEADERS ntheader;
  SIZE_T size;

  dosheader = (PIMAGE_DOS_HEADER) GetModuleHandle (NULL);
  ntheader = (PIMAGE_NT_HEADERS) ((PBYTE) dosheader + dosheader->e_lfanew);
  /* LoaderFlags is an obsolete DWORD member of the PE/COFF file header.
     Its value is ignored by the loader, so we're free to use it for
     Cygwin.  If it's 0, we default to 512.  Otherwise, we use it as
     the default initial heap size in megabyte.  Valid values are
     between 4 and 8388608 Megs. */

  size = ntheader->OptionalHeader.LoaderFlags;
  if (size == 0)
    size = 512;
  else if (size < 4)
    size = 4;
  else if (size > 8388608)
    size = 8388608;
  return size << 20;
}

/* Initialize the heap at process start up.  */
void
user_heap_info::init ()
{
  const DWORD alloctype = MEM_RESERVE;
  /* If we're the forkee, we must allocate the heap at exactly the same place
     as our parent.  If not, we (almost) don't care where it ends up.  */

  page_const = wincap.page_size ();
  if (!base)
    {
      uintptr_t start_address = USERHEAP_START;
      PVOID largest_found = NULL;
      SIZE_T largest_found_size = 0;
      SIZE_T ret;
      MEMORY_BASIC_INFORMATION mbi;

      chunk = eval_initial_heap_size ();
      do
	{
	  base = VirtualAlloc ((LPVOID) start_address, chunk, alloctype,
			       PAGE_NOACCESS);
	  if (base)
	    break;

	  /* Ok, so we are at the 1% which didn't work with USERHEAP_START out
	     of the box.  What we do now is to search for the next free
	     region which matches our desired heap size.  While doing that,
	     we keep track of the largest region we found, including the
	     region starting at USERHEAP_START. */
	  while ((ret = VirtualQuery ((LPCVOID) start_address, &mbi,
				      sizeof mbi)) != 0)
	    {
	      if (mbi.State == MEM_FREE)
		{
		  if (mbi.RegionSize >= chunk)
		    break;
		  if (mbi.RegionSize > largest_found_size)
		    {
		      largest_found = mbi.BaseAddress;
		      largest_found_size = mbi.RegionSize;
		    }
		}
	      /* Since VirtualAlloc only reserves at allocation granularity
		 boundaries, we round up here, too.  Otherwise we might end
		 up at a bogus page-aligned address. */
	      start_address = roundup2 (start_address + mbi.RegionSize,
					wincap.allocation_granularity ());
	    }
	  if (!ret)
	    {
	      /* In theory this should not happen.  But if it happens, we have
		 collected the information about the largest available region
		 in the above loop.  So, next we squeeze the heap into that
		 region, unless it's smaller than the minimum size. */
	      if (largest_found_size >= MINHEAP_SIZE)
		{
		  chunk = largest_found_size;
		  base = VirtualAlloc (largest_found, chunk, alloctype,
				       PAGE_NOACCESS);
		}
	      /* Last resort (but actually we are probably broken anyway):
		 Use the minimal heap size and let the system decide. */
	      if (!base)
		{
		  chunk = MINHEAP_SIZE;
		  base = VirtualAlloc (NULL, chunk, alloctype, PAGE_NOACCESS);
		}
	    }
	}
      while (!base && ret);
      if (base == NULL)
	api_fatal ("unable to allocate heap, heap_chunk_size %ly, %E",
		   chunk);
      ptr = top = base;
      max = (char *) base + chunk;
    }
  else
    {
      /* total size commited in parent */
      SIZE_T allocsize = (char *) top - (char *) base;

      /* Loop until we've managed to reserve an adequate amount of memory. */
      SIZE_T reserve_size = chunk * ((allocsize + (chunk - 1)) / chunk);

      /* With ptmalloc3 there's a good chance that there has been no memory
	 allocated on the heap.  If we don't check that, reserve_size will
	 be 0 and from there, the below loop will end up overallocating due
	 to integer overflow. */
      if (!reserve_size)
	reserve_size = chunk;

      char *p;
      while (1)
	{
	  p = (char *) VirtualAlloc (base, reserve_size, alloctype,
				     PAGE_READWRITE);
	  if (p)
	    break;
	  if ((reserve_size -= page_const) < allocsize)
	    break;
	}
      if (!p && __in_forkee == FORKING && !fork_info->abort (NULL))
	api_fatal ("couldn't allocate heap, %E, base %p, top %p, "
		   "reserve_size %ld, allocsize %ld, page_const %d",
		   base, top,
		   reserve_size, allocsize, page_const);
      if (p != base)
	api_fatal ("heap allocated at wrong address %p (mapped) "
		   "!= %p (expected)", p, base);
      if (allocsize && !VirtualAlloc (base, allocsize,
				      MEM_COMMIT, PAGE_READWRITE))
	api_fatal ("MEM_COMMIT failed, %E");
    }

  /* CV 2012-05-21: Moved printing heap size here from strace::activate.
     The value printed in strace.activate was always wrong, because at the
     time it's called, cygheap points to cygheap_dummy.  Above all, the heap
     size has not been evaluated yet, except in a forked child.  Since
     heap_init is called early, the heap size is printed pretty much at the
     start of the strace output, so there isn't anything lost. */
  debug_printf ("heap base %p, heap top %p, heap size %ly (%lu)",
		base, top, chunk, chunk);
  page_const--;
}

#define pround(n) (((size_t)(n) + page_const) & ~page_const)
/* Linux defines n to be intptr_t, newlib defines it to be ptrdiff_t.
   It shouldn't matter much, though, since the function is not standarized
   and sizeof(ptrdiff_t) == sizeof(intptr_t) anyway. */
extern "C" void *
sbrk (ptrdiff_t n)
{
  return cygheap->user_heap.sbrk (n);
}

void *
user_heap_info::sbrk (ptrdiff_t n)
{
/* FIXME: This function no longer handles "split heaps". */

  char *newtop, *newbrk;
  SIZE_T commitbytes, newbrksize, reservebytes;

  if (n == 0)
    return ptr;					/* Just wanted to find current ptr
						   address */

  newbrk = (char *) ptr + n;			/* Where new cptr will be */
  newtop = (char *) pround (newbrk);		/* Actual top of allocated memory -
						   on page boundary */

  if (newtop == top)
    goto good;

  if (n < 0)
    {						/* Freeing memory */
      assert (newtop < top);
      n = (char *) top - newtop;
      /* FIXME: This doesn't work if we cross a virtual memory reservation
	 border.  If that happens, we have to free the space in multiple
	 VirtualFree calls, aligned to the former reservation borders. */
      if (VirtualFree (newtop, n, MEM_DECOMMIT)) /* Give it back to OS */
	goto good;
      goto err;					/*  Didn't take */
    }

  assert (newtop > top);

  /* Find the number of bytes to commit, rounded up to the nearest page. */
  commitbytes = pround (newtop - (char *) top);

  /* Need to grab more pages from the OS.  If this fails it may be because
     we have used up previously reserved memory.  Or, we're just plumb out
     of memory.  Only attempt to commit memory that we know we've previously
     reserved.  */
  if (newtop <= max)
    {
      if (VirtualAlloc (top, commitbytes, MEM_COMMIT, PAGE_READWRITE))
	goto good;
      goto err;
    }

  /* The remainder of the existing heap is too small to fulfill the memory
     request.  We have to extend the heap, so we reserve some more memory
     and then commit the remainder of the old heap, if any, and the rest of
     the required space from the extended heap. */

  /* For subsequent chunks following the base heap, reserve either 1 Megs
     per chunk, or the requested amount if it's bigger than 1 Megs. */
  reservebytes = commitbytes - ((char *) max - (char *) top);
  commitbytes -= reservebytes;
  if ((newbrksize = RAISEHEAP_SIZE) < reservebytes)
    newbrksize = reservebytes;

  if (VirtualAlloc (max, newbrksize, MEM_RESERVE, PAGE_NOACCESS)
      || VirtualAlloc (max, newbrksize = reservebytes, MEM_RESERVE,
		       PAGE_NOACCESS))
    {
      /* Now commit the requested memory.  Windows keeps all virtual
	 reservations separate, so we can't commit the two regions in a single,
	 combined call or we suffer an ERROR_INVALID_ADDRESS.  The same error
	 is returned when trying to VirtualAlloc 0 bytes, which would occur if
	 the existing heap was already full. */
      if ((!commitbytes || VirtualAlloc (top, commitbytes, MEM_COMMIT,
					 PAGE_READWRITE))
	  && VirtualAlloc (max, reservebytes, MEM_COMMIT, PAGE_READWRITE))
	{
	  max = (char *) max + pround (newbrksize);
	  goto good;
	}
      /* If committing the memory failed, we must free the extendend reserved
         region, otherwise any other try to fetch memory (for instance by using
	 mmap) may fail just because we still reserve memory we don't even know
	 about. */
      VirtualFree (max, newbrksize, MEM_RELEASE);
    }

err:
  set_errno (ENOMEM);
  return (void *) -1;

good:
  void *oldbrk = ptr;
  ptr = newbrk;
  top = newtop;
  return oldbrk;
}
