339 lines
8.8 KiB
C++
339 lines
8.8 KiB
C++
/* resource.cc: getrusage () and friends.
|
|
|
|
Written by Steve Chamberlain (sac@cygnus.com), Doug Evans (dje@cygnus.com),
|
|
Geoffrey Noer (noer@cygnus.com) of Cygnus Support.
|
|
Rewritten by Sergey S. Okhapkin (sos@prospect.com.ru)
|
|
|
|
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 <unistd.h>
|
|
#include <sys/param.h>
|
|
#include "pinfo.h"
|
|
#include "cygtls.h"
|
|
#include "path.h"
|
|
#include "fhandler.h"
|
|
#include "pinfo.h"
|
|
#include "dtable.h"
|
|
#include "cygheap.h"
|
|
#include "shared_info.h"
|
|
#include "ntdll.h"
|
|
|
|
/* add timeval values */
|
|
static void
|
|
add_timeval (struct timeval *tv1, struct timeval *tv2)
|
|
{
|
|
tv1->tv_sec += tv2->tv_sec;
|
|
tv1->tv_usec += tv2->tv_usec;
|
|
if (tv1->tv_usec >= USPERSEC)
|
|
{
|
|
tv1->tv_usec -= USPERSEC;
|
|
tv1->tv_sec++;
|
|
}
|
|
}
|
|
|
|
/* add rusage values of r2 to r1 */
|
|
void __stdcall
|
|
add_rusage (struct rusage *r1, struct rusage *r2)
|
|
{
|
|
add_timeval (&r1->ru_utime, &r2->ru_utime);
|
|
add_timeval (&r1->ru_stime, &r2->ru_stime);
|
|
r1->ru_maxrss += r2->ru_maxrss;
|
|
r1->ru_ixrss += r2->ru_ixrss;
|
|
r1->ru_idrss += r2->ru_idrss;
|
|
r1->ru_isrss += r2->ru_isrss;
|
|
r1->ru_minflt += r2->ru_minflt;
|
|
r1->ru_majflt += r2->ru_majflt;
|
|
r1->ru_nswap += r2->ru_nswap;
|
|
r1->ru_inblock += r2->ru_inblock;
|
|
r1->ru_oublock += r2->ru_oublock;
|
|
r1->ru_msgsnd += r2->ru_msgsnd;
|
|
r1->ru_msgrcv += r2->ru_msgrcv;
|
|
r1->ru_nsignals += r2->ru_nsignals;
|
|
r1->ru_nvcsw += r2->ru_nvcsw;
|
|
r1->ru_nivcsw += r2->ru_nivcsw;
|
|
}
|
|
|
|
/* FIXME: what about other fields? */
|
|
void __stdcall
|
|
fill_rusage (struct rusage *r, HANDLE h)
|
|
{
|
|
KERNEL_USER_TIMES kut;
|
|
|
|
struct timeval tv;
|
|
|
|
memset (&kut, 0, sizeof kut);
|
|
memset (r, 0, sizeof *r);
|
|
NtQueryInformationProcess (h, ProcessTimes, &kut, sizeof kut, NULL);
|
|
totimeval (&tv, &kut.KernelTime, 0, 0);
|
|
add_timeval (&r->ru_stime, &tv);
|
|
totimeval (&tv, &kut.UserTime, 0, 0);
|
|
add_timeval (&r->ru_utime, &tv);
|
|
|
|
VM_COUNTERS vmc;
|
|
NTSTATUS status = NtQueryInformationProcess (h, ProcessVmCounters, &vmc,
|
|
sizeof vmc, NULL);
|
|
if (NT_SUCCESS (status))
|
|
{
|
|
r->ru_maxrss += (long) (vmc.WorkingSetSize / 1024);
|
|
r->ru_majflt += vmc.PageFaultCount;
|
|
}
|
|
}
|
|
|
|
extern "C" int
|
|
getrusage (int intwho, struct rusage *rusage_in)
|
|
{
|
|
int res = 0;
|
|
struct rusage r;
|
|
|
|
if (intwho == RUSAGE_SELF)
|
|
{
|
|
memset (&r, 0, sizeof (r));
|
|
fill_rusage (&r, GetCurrentProcess ());
|
|
*rusage_in = r;
|
|
}
|
|
else if (intwho == RUSAGE_CHILDREN)
|
|
*rusage_in = myself->rusage_children;
|
|
else
|
|
{
|
|
set_errno (EINVAL);
|
|
res = -1;
|
|
}
|
|
|
|
syscall_printf ("%R = getrusage(%d, %p)", res, intwho, rusage_in);
|
|
return res;
|
|
}
|
|
|
|
/* Default stacksize in case RLIMIT_STACK is RLIM_INFINITY is 2 Megs with
|
|
system-dependent number of guard pages. The pthread stacksize does not
|
|
include the guardpage size, so we have to subtract the default guardpage
|
|
size. Additionally the Windows stack handling disallows to commit the
|
|
last page, so we subtract it, too. */
|
|
#define DEFAULT_STACKSIZE (2 * 1024 * 1024)
|
|
#define DEFAULT_STACKGUARD (wincap.def_guard_page_size() + wincap.page_size ())
|
|
|
|
muto NO_COPY rlimit_stack_guard;
|
|
static struct rlimit rlimit_stack = { 0, RLIM_INFINITY };
|
|
|
|
static void
|
|
__set_rlimit_stack (const struct rlimit *rlp)
|
|
{
|
|
rlimit_stack_guard.init ("rlimit_stack_guard")->acquire ();
|
|
rlimit_stack = *rlp;
|
|
rlimit_stack_guard.release ();
|
|
}
|
|
|
|
static void
|
|
__get_rlimit_stack (struct rlimit *rlp)
|
|
{
|
|
rlimit_stack_guard.init ("rlimit_stack_guard")->acquire ();
|
|
if (!rlimit_stack.rlim_cur)
|
|
{
|
|
/* Fetch the default stacksize from the executable header... */
|
|
PIMAGE_DOS_HEADER dosheader;
|
|
PIMAGE_NT_HEADERS ntheader;
|
|
|
|
dosheader = (PIMAGE_DOS_HEADER) GetModuleHandle (NULL);
|
|
ntheader = (PIMAGE_NT_HEADERS) ((PBYTE) dosheader + dosheader->e_lfanew);
|
|
rlimit_stack.rlim_cur = ntheader->OptionalHeader.SizeOfStackReserve;
|
|
/* ...and subtract the guardpages. */
|
|
rlimit_stack.rlim_cur -= DEFAULT_STACKGUARD;
|
|
}
|
|
*rlp = rlimit_stack;
|
|
rlimit_stack_guard.release ();
|
|
}
|
|
|
|
/* Interface to stack limit called from pthread_create and
|
|
pthread_attr_getstacksize. */
|
|
size_t
|
|
get_rlimit_stack (void)
|
|
{
|
|
struct rlimit rl;
|
|
|
|
__get_rlimit_stack (&rl);
|
|
/* RLIM_INFINITY doesn't make much sense. As in glibc, use an
|
|
"architecture-specific default". */
|
|
if (rl.rlim_cur == RLIM_INFINITY)
|
|
rl.rlim_cur = DEFAULT_STACKSIZE - DEFAULT_STACKGUARD;
|
|
/* Always return at least minimum stacksize. */
|
|
else if (rl.rlim_cur < PTHREAD_STACK_MIN)
|
|
rl.rlim_cur = PTHREAD_STACK_MIN;
|
|
return (size_t) rl.rlim_cur;
|
|
}
|
|
|
|
static LONG job_serial_number __attribute__((section (".cygwin_dll_common"), shared));
|
|
|
|
static PWCHAR
|
|
job_shared_name (PWCHAR buf, LONG num)
|
|
{
|
|
__small_swprintf (buf, L"rlimit.%d", num);
|
|
return buf;
|
|
}
|
|
|
|
extern "C" int
|
|
getrlimit (int resource, struct rlimit *rlp)
|
|
{
|
|
__try
|
|
{
|
|
rlp->rlim_cur = RLIM_INFINITY;
|
|
rlp->rlim_max = RLIM_INFINITY;
|
|
|
|
switch (resource)
|
|
{
|
|
case RLIMIT_CPU:
|
|
case RLIMIT_FSIZE:
|
|
case RLIMIT_DATA:
|
|
break;
|
|
case RLIMIT_AS:
|
|
{
|
|
UNICODE_STRING uname;
|
|
WCHAR jobname[32];
|
|
OBJECT_ATTRIBUTES attr;
|
|
HANDLE job = NULL;
|
|
NTSTATUS status;
|
|
JOBOBJECT_EXTENDED_LIMIT_INFORMATION jobinfo;
|
|
|
|
if (cygheap->rlim_as_id)
|
|
{
|
|
RtlInitUnicodeString (&uname,
|
|
job_shared_name (jobname,
|
|
cygheap->rlim_as_id));
|
|
InitializeObjectAttributes (&attr, &uname, 0,
|
|
get_session_parent_dir (), NULL);
|
|
/* May fail, just check NULL job in that case. */
|
|
NtOpenJobObject (&job, JOB_OBJECT_QUERY, &attr);
|
|
}
|
|
status = NtQueryInformationJobObject (job,
|
|
JobObjectExtendedLimitInformation,
|
|
&jobinfo, sizeof jobinfo, NULL);
|
|
if (!NT_SUCCESS (status))
|
|
break;
|
|
if (jobinfo.BasicLimitInformation.LimitFlags & JOB_OBJECT_LIMIT_PROCESS_MEMORY)
|
|
rlp->rlim_cur = rlp->rlim_max = jobinfo.ProcessMemoryLimit;
|
|
if (job)
|
|
NtClose (job);
|
|
}
|
|
break;
|
|
case RLIMIT_STACK:
|
|
__get_rlimit_stack (rlp);
|
|
break;
|
|
case RLIMIT_NOFILE:
|
|
rlp->rlim_cur = rlp->rlim_max = OPEN_MAX;
|
|
break;
|
|
case RLIMIT_CORE:
|
|
rlp->rlim_cur = cygheap->rlim_core;
|
|
break;
|
|
default:
|
|
set_errno (EINVAL);
|
|
__leave;
|
|
}
|
|
return 0;
|
|
}
|
|
__except (EFAULT) {}
|
|
__endtry
|
|
return -1;
|
|
}
|
|
|
|
extern "C" int
|
|
setrlimit (int resource, const struct rlimit *rlp)
|
|
{
|
|
struct rlimit oldlimits;
|
|
|
|
/* Check if the request is to actually change the resource settings.
|
|
If it does not result in a change, take no action and do not fail. */
|
|
if (getrlimit (resource, &oldlimits) < 0)
|
|
return -1;
|
|
|
|
__try
|
|
{
|
|
if (oldlimits.rlim_cur == rlp->rlim_cur &&
|
|
oldlimits.rlim_max == rlp->rlim_max)
|
|
/* No change in resource requirements, succeed immediately */
|
|
return 0;
|
|
|
|
if (rlp->rlim_cur > rlp->rlim_max)
|
|
{
|
|
set_errno (EINVAL);
|
|
__leave;
|
|
}
|
|
|
|
if (rlp->rlim_cur > oldlimits.rlim_max)
|
|
{
|
|
set_errno (EPERM);
|
|
__leave;
|
|
}
|
|
|
|
switch (resource)
|
|
{
|
|
case RLIMIT_AS:
|
|
{
|
|
LONG new_as_id = 0;
|
|
UNICODE_STRING uname;
|
|
WCHAR jobname[32];
|
|
OBJECT_ATTRIBUTES attr;
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
HANDLE job = NULL;
|
|
JOBOBJECT_EXTENDED_LIMIT_INFORMATION jobinfo = { 0 };
|
|
|
|
/* If we already have a limit, we must not change it because that
|
|
would potentially influence already running child processes.
|
|
Just try to create another, nested job. On systems prior to
|
|
Windows 8 / Server 2012 this will fail, but that's ok. */
|
|
while (new_as_id == 0)
|
|
new_as_id = InterlockedIncrement (&job_serial_number);
|
|
RtlInitUnicodeString (&uname,
|
|
job_shared_name (jobname, new_as_id));
|
|
InitializeObjectAttributes (&attr, &uname, 0,
|
|
get_session_parent_dir (), NULL);
|
|
status = NtCreateJobObject (&job, JOB_OBJECT_ALL_ACCESS, &attr);
|
|
if (!NT_SUCCESS (status))
|
|
{
|
|
__seterrno_from_nt_status (status);
|
|
__leave;
|
|
}
|
|
status = NtAssignProcessToJobObject (job, NtCurrentProcess ());
|
|
if (NT_SUCCESS (status))
|
|
{
|
|
jobinfo.BasicLimitInformation.LimitFlags
|
|
= JOB_OBJECT_LIMIT_PROCESS_MEMORY;
|
|
/* Per Linux man page, round down to system pagesize. */
|
|
jobinfo.ProcessMemoryLimit
|
|
= rounddown (rlp->rlim_cur, wincap.allocation_granularity ());
|
|
status = NtSetInformationJobObject (job,
|
|
JobObjectExtendedLimitInformation,
|
|
&jobinfo, sizeof jobinfo);
|
|
}
|
|
NtClose (job);
|
|
if (!NT_SUCCESS (status))
|
|
{
|
|
__seterrno_from_nt_status (status);
|
|
__leave;
|
|
}
|
|
cygheap->rlim_as_id = new_as_id;
|
|
}
|
|
break;
|
|
case RLIMIT_CORE:
|
|
cygheap->rlim_core = rlp->rlim_cur;
|
|
break;
|
|
case RLIMIT_NOFILE:
|
|
if (rlp->rlim_cur != RLIM_INFINITY)
|
|
return setdtablesize (rlp->rlim_cur);
|
|
break;
|
|
case RLIMIT_STACK:
|
|
__set_rlimit_stack (rlp);
|
|
break;
|
|
default:
|
|
set_errno (EINVAL);
|
|
__leave;
|
|
}
|
|
return 0;
|
|
}
|
|
__except (EFAULT)
|
|
__endtry
|
|
return -1;
|
|
}
|