Implement getrlimit and setrlimit for MS-Windows

* src/w32heap.c (getrlimit, setrlimit): New functions.
Include w32.h.
* src/emacs.c (main): Use 'rlim_t', not 'long', for values that
should be compatible with 'struct rlimit' members.

* nt/inc/sys/resource.h: New header file.

* nt/mingw-cfg.site (ac_cv_func_getrlimit, ac_cv_func_setrlimit):
Set to "yes".

1 files changed, 84 insertions, 1 deletions

diff --git a/src/w32heap.c b/src/w32heap.c
index 43b5f352a1d..26a04413df1 100644
--- a/src/w32heap.c
+++ b/src/w32heap.c
@@ -50,9 +50,11 @@
 #include <errno.h>
 
 #include <sys/mman.h>
+#include <sys/resource.h>
 #include "w32common.h"
 #include "w32heap.h"
 #include "lisp.h"
+#include "w32.h"        /* for FD_SETSIZE */
 
 /* We chose to leave those declarations here.  They are used only in
    this file.  The RtlCreateHeap is available since XP.  It is located
@@ -317,6 +319,9 @@ init_heap (void)
   cache_system_info ();
 }
 
+
+/* malloc, realloc, free.  */
+
 #undef malloc
 #undef realloc
 #undef free
@@ -623,9 +628,12 @@ sbrk (ptrdiff_t increment)
   return data_region_end;
 }
 
-#define MAX_BUFFER_SIZE (512 * 1024 * 1024)
+
 
 /* MMAP allocation for buffers.  */
+
+#define MAX_BUFFER_SIZE (512 * 1024 * 1024)
+
 void *
 mmap_alloc (void **var, size_t nbytes)
 {
@@ -788,3 +796,78 @@ mmap_realloc (void **var, size_t nbytes)
   /* Not enlarging, not shrinking by more than one page.  */
   return *var;
 }
+
+
+/* Emulation of getrlimit and setrlimit.  */
+
+int
+getrlimit (rlimit_resource_t rltype, struct rlimit *rlp)
+{
+  int retval = -1;
+
+  switch (rltype)
+    {
+    case RLIMIT_STACK:
+      {
+        MEMORY_BASIC_INFORMATION m;
+        /* Implementation note: Posix says that RLIMIT_STACK returns
+           information about the stack size for the main thread.  The
+           implementation below returns the stack size for the calling
+           thread, so it's more like pthread_attr_getstacksize.  But
+           Emacs clearly wants the latter, given how it uses the
+           results, so the implementation below is more future-proof,
+           if what's now the main thread will become some other thread
+           at some future point.  */
+        if (!VirtualQuery ((LPCVOID) &m, &m, sizeof m))
+          errno = EPERM;
+        else
+          {
+            rlp->rlim_cur = (DWORD_PTR) &m - (DWORD_PTR) m.AllocationBase;
+            rlp->rlim_max =
+              (DWORD_PTR) m.BaseAddress + m.RegionSize
+              - (DWORD_PTR) m.AllocationBase;
+
+            /* The last page is the guard page, so subtract that.  */
+            rlp->rlim_cur -= getpagesize ();
+            rlp->rlim_max -= getpagesize ();
+            retval = 0;
+          }
+        }
+      break;
+    case RLIMIT_NOFILE:
+      /* Implementation note: The real value is returned by
+         _getmaxstdio.  But our FD_SETSIZE is smaller, to cater to
+         Windows 9X, and process.c includes some logic that's based on
+         the assumption that the handle resource is inherited to child
+         processes.  We want to avoid that logic, so we tell process.c
+         our current limit is already equal to FD_SETSIZE.  */
+      rlp->rlim_cur = FD_SETSIZE;
+      rlp->rlim_max = 2048;     /* see _setmaxstdio documentation */
+      retval = 0;
+      break;
+    default:
+      /* Note: we could return meaningful results for other RLIMIT_*
+         requests, but Emacs doesn't currently need that, so we just
+         punt for them.  */
+      errno = ENOSYS;
+      break;
+    }
+  return retval;
+}
+
+int
+setrlimit (rlimit_resource_t rltype, const struct rlimit *rlp)
+{
+  switch (rltype)
+    {
+    case RLIMIT_STACK:
+    case RLIMIT_NOFILE:
+      /* We cannot modfy these limits, so we always fail.  */
+      errno = EPERM;
+      break;
+    default:
+      errno = ENOSYS;
+      break;
+    }
+  return -1;
+}