#include "Python.h" | |
#include "structseq.h" | |
#include <sys/resource.h> | |
#include <sys/time.h> | |
#include <string.h> | |
#include <errno.h> | |
/* for sysconf */ | |
#if defined(HAVE_UNISTD_H) | |
#include <unistd.h> | |
#endif | |
/* On some systems, these aren't in any header file. | |
On others they are, with inconsistent prototypes. | |
We declare the (default) return type, to shut up gcc -Wall; | |
but we can't declare the prototype, to avoid errors | |
when the header files declare it different. | |
Worse, on some Linuxes, getpagesize() returns a size_t... */ | |
#define doubletime(TV) ((double)(TV).tv_sec + (TV).tv_usec * 0.000001) | |
static PyObject *ResourceError; | |
PyDoc_STRVAR(struct_rusage__doc__, | |
"struct_rusage: Result from getrusage.\n\n" | |
"This object may be accessed either as a tuple of\n" | |
" (utime,stime,maxrss,ixrss,idrss,isrss,minflt,majflt,\n" | |
" nswap,inblock,oublock,msgsnd,msgrcv,nsignals,nvcsw,nivcsw)\n" | |
"or via the attributes ru_utime, ru_stime, ru_maxrss, and so on."); | |
static PyStructSequence_Field struct_rusage_fields[] = { | |
{"ru_utime", "user time used"}, | |
{"ru_stime", "system time used"}, | |
{"ru_maxrss", "max. resident set size"}, | |
{"ru_ixrss", "shared memory size"}, | |
{"ru_idrss", "unshared data size"}, | |
{"ru_isrss", "unshared stack size"}, | |
{"ru_minflt", "page faults not requiring I/O"}, | |
{"ru_majflt", "page faults requiring I/O"}, | |
{"ru_nswap", "number of swap outs"}, | |
{"ru_inblock", "block input operations"}, | |
{"ru_oublock", "block output operations"}, | |
{"ru_msgsnd", "IPC messages sent"}, | |
{"ru_msgrcv", "IPC messages received"}, | |
{"ru_nsignals", "signals received"}, | |
{"ru_nvcsw", "voluntary context switches"}, | |
{"ru_nivcsw", "involuntary context switches"}, | |
{0} | |
}; | |
static PyStructSequence_Desc struct_rusage_desc = { | |
"resource.struct_rusage", /* name */ | |
struct_rusage__doc__, /* doc */ | |
struct_rusage_fields, /* fields */ | |
16 /* n_in_sequence */ | |
}; | |
static int initialized; | |
static PyTypeObject StructRUsageType; | |
static PyObject * | |
resource_getrusage(PyObject *self, PyObject *args) | |
{ | |
int who; | |
struct rusage ru; | |
PyObject *result; | |
if (!PyArg_ParseTuple(args, "i:getrusage", &who)) | |
return NULL; | |
if (getrusage(who, &ru) == -1) { | |
if (errno == EINVAL) { | |
PyErr_SetString(PyExc_ValueError, | |
"invalid who parameter"); | |
return NULL; | |
} | |
PyErr_SetFromErrno(ResourceError); | |
return NULL; | |
} | |
result = PyStructSequence_New(&StructRUsageType); | |
if (!result) | |
return NULL; | |
PyStructSequence_SET_ITEM(result, 0, | |
PyFloat_FromDouble(doubletime(ru.ru_utime))); | |
PyStructSequence_SET_ITEM(result, 1, | |
PyFloat_FromDouble(doubletime(ru.ru_stime))); | |
PyStructSequence_SET_ITEM(result, 2, PyInt_FromLong(ru.ru_maxrss)); | |
PyStructSequence_SET_ITEM(result, 3, PyInt_FromLong(ru.ru_ixrss)); | |
PyStructSequence_SET_ITEM(result, 4, PyInt_FromLong(ru.ru_idrss)); | |
PyStructSequence_SET_ITEM(result, 5, PyInt_FromLong(ru.ru_isrss)); | |
PyStructSequence_SET_ITEM(result, 6, PyInt_FromLong(ru.ru_minflt)); | |
PyStructSequence_SET_ITEM(result, 7, PyInt_FromLong(ru.ru_majflt)); | |
PyStructSequence_SET_ITEM(result, 8, PyInt_FromLong(ru.ru_nswap)); | |
PyStructSequence_SET_ITEM(result, 9, PyInt_FromLong(ru.ru_inblock)); | |
PyStructSequence_SET_ITEM(result, 10, PyInt_FromLong(ru.ru_oublock)); | |
PyStructSequence_SET_ITEM(result, 11, PyInt_FromLong(ru.ru_msgsnd)); | |
PyStructSequence_SET_ITEM(result, 12, PyInt_FromLong(ru.ru_msgrcv)); | |
PyStructSequence_SET_ITEM(result, 13, PyInt_FromLong(ru.ru_nsignals)); | |
PyStructSequence_SET_ITEM(result, 14, PyInt_FromLong(ru.ru_nvcsw)); | |
PyStructSequence_SET_ITEM(result, 15, PyInt_FromLong(ru.ru_nivcsw)); | |
if (PyErr_Occurred()) { | |
Py_DECREF(result); | |
return NULL; | |
} | |
return result; | |
} | |
static PyObject * | |
resource_getrlimit(PyObject *self, PyObject *args) | |
{ | |
struct rlimit rl; | |
int resource; | |
if (!PyArg_ParseTuple(args, "i:getrlimit", &resource)) | |
return NULL; | |
if (resource < 0 || resource >= RLIM_NLIMITS) { | |
PyErr_SetString(PyExc_ValueError, | |
"invalid resource specified"); | |
return NULL; | |
} | |
if (getrlimit(resource, &rl) == -1) { | |
PyErr_SetFromErrno(ResourceError); | |
return NULL; | |
} | |
#if defined(HAVE_LONG_LONG) | |
if (sizeof(rl.rlim_cur) > sizeof(long)) { | |
return Py_BuildValue("LL", | |
(PY_LONG_LONG) rl.rlim_cur, | |
(PY_LONG_LONG) rl.rlim_max); | |
} | |
#endif | |
return Py_BuildValue("ll", (long) rl.rlim_cur, (long) rl.rlim_max); | |
} | |
static PyObject * | |
resource_setrlimit(PyObject *self, PyObject *args) | |
{ | |
struct rlimit rl; | |
int resource; | |
PyObject *curobj, *maxobj; | |
if (!PyArg_ParseTuple(args, "i(OO):setrlimit", | |
&resource, &curobj, &maxobj)) | |
return NULL; | |
if (resource < 0 || resource >= RLIM_NLIMITS) { | |
PyErr_SetString(PyExc_ValueError, | |
"invalid resource specified"); | |
return NULL; | |
} | |
#if !defined(HAVE_LARGEFILE_SUPPORT) | |
rl.rlim_cur = PyInt_AsLong(curobj); | |
if (rl.rlim_cur == (rlim_t)-1 && PyErr_Occurred()) | |
return NULL; | |
rl.rlim_max = PyInt_AsLong(maxobj); | |
if (rl.rlim_max == (rlim_t)-1 && PyErr_Occurred()) | |
return NULL; | |
#else | |
/* The limits are probably bigger than a long */ | |
rl.rlim_cur = PyLong_Check(curobj) ? | |
PyLong_AsLongLong(curobj) : PyInt_AsLong(curobj); | |
if (rl.rlim_cur == (rlim_t)-1 && PyErr_Occurred()) | |
return NULL; | |
rl.rlim_max = PyLong_Check(maxobj) ? | |
PyLong_AsLongLong(maxobj) : PyInt_AsLong(maxobj); | |
if (rl.rlim_max == (rlim_t)-1 && PyErr_Occurred()) | |
return NULL; | |
#endif | |
rl.rlim_cur = rl.rlim_cur & RLIM_INFINITY; | |
rl.rlim_max = rl.rlim_max & RLIM_INFINITY; | |
if (setrlimit(resource, &rl) == -1) { | |
if (errno == EINVAL) | |
PyErr_SetString(PyExc_ValueError, | |
"current limit exceeds maximum limit"); | |
else if (errno == EPERM) | |
PyErr_SetString(PyExc_ValueError, | |
"not allowed to raise maximum limit"); | |
else | |
PyErr_SetFromErrno(ResourceError); | |
return NULL; | |
} | |
Py_INCREF(Py_None); | |
return Py_None; | |
} | |
static PyObject * | |
resource_getpagesize(PyObject *self, PyObject *unused) | |
{ | |
long pagesize = 0; | |
#if defined(HAVE_GETPAGESIZE) | |
pagesize = getpagesize(); | |
#elif defined(HAVE_SYSCONF) | |
#if defined(_SC_PAGE_SIZE) | |
pagesize = sysconf(_SC_PAGE_SIZE); | |
#else | |
/* Irix 5.3 has _SC_PAGESIZE, but not _SC_PAGE_SIZE */ | |
pagesize = sysconf(_SC_PAGESIZE); | |
#endif | |
#endif | |
return Py_BuildValue("i", pagesize); | |
} | |
/* List of functions */ | |
static struct PyMethodDef | |
resource_methods[] = { | |
{"getrusage", resource_getrusage, METH_VARARGS}, | |
{"getrlimit", resource_getrlimit, METH_VARARGS}, | |
{"setrlimit", resource_setrlimit, METH_VARARGS}, | |
{"getpagesize", resource_getpagesize, METH_NOARGS}, | |
{NULL, NULL} /* sentinel */ | |
}; | |
/* Module initialization */ | |
PyMODINIT_FUNC | |
initresource(void) | |
{ | |
PyObject *m, *v; | |
/* Create the module and add the functions */ | |
m = Py_InitModule("resource", resource_methods); | |
if (m == NULL) | |
return; | |
/* Add some symbolic constants to the module */ | |
if (ResourceError == NULL) { | |
ResourceError = PyErr_NewException("resource.error", | |
NULL, NULL); | |
} | |
Py_INCREF(ResourceError); | |
PyModule_AddObject(m, "error", ResourceError); | |
if (!initialized) | |
PyStructSequence_InitType(&StructRUsageType, | |
&struct_rusage_desc); | |
Py_INCREF(&StructRUsageType); | |
PyModule_AddObject(m, "struct_rusage", | |
(PyObject*) &StructRUsageType); | |
/* insert constants */ | |
#ifdef RLIMIT_CPU | |
PyModule_AddIntConstant(m, "RLIMIT_CPU", RLIMIT_CPU); | |
#endif | |
#ifdef RLIMIT_FSIZE | |
PyModule_AddIntConstant(m, "RLIMIT_FSIZE", RLIMIT_FSIZE); | |
#endif | |
#ifdef RLIMIT_DATA | |
PyModule_AddIntConstant(m, "RLIMIT_DATA", RLIMIT_DATA); | |
#endif | |
#ifdef RLIMIT_STACK | |
PyModule_AddIntConstant(m, "RLIMIT_STACK", RLIMIT_STACK); | |
#endif | |
#ifdef RLIMIT_CORE | |
PyModule_AddIntConstant(m, "RLIMIT_CORE", RLIMIT_CORE); | |
#endif | |
#ifdef RLIMIT_NOFILE | |
PyModule_AddIntConstant(m, "RLIMIT_NOFILE", RLIMIT_NOFILE); | |
#endif | |
#ifdef RLIMIT_OFILE | |
PyModule_AddIntConstant(m, "RLIMIT_OFILE", RLIMIT_OFILE); | |
#endif | |
#ifdef RLIMIT_VMEM | |
PyModule_AddIntConstant(m, "RLIMIT_VMEM", RLIMIT_VMEM); | |
#endif | |
#ifdef RLIMIT_AS | |
PyModule_AddIntConstant(m, "RLIMIT_AS", RLIMIT_AS); | |
#endif | |
#ifdef RLIMIT_RSS | |
PyModule_AddIntConstant(m, "RLIMIT_RSS", RLIMIT_RSS); | |
#endif | |
#ifdef RLIMIT_NPROC | |
PyModule_AddIntConstant(m, "RLIMIT_NPROC", RLIMIT_NPROC); | |
#endif | |
#ifdef RLIMIT_MEMLOCK | |
PyModule_AddIntConstant(m, "RLIMIT_MEMLOCK", RLIMIT_MEMLOCK); | |
#endif | |
#ifdef RLIMIT_SBSIZE | |
PyModule_AddIntConstant(m, "RLIMIT_SBSIZE", RLIMIT_SBSIZE); | |
#endif | |
#ifdef RUSAGE_SELF | |
PyModule_AddIntConstant(m, "RUSAGE_SELF", RUSAGE_SELF); | |
#endif | |
#ifdef RUSAGE_CHILDREN | |
PyModule_AddIntConstant(m, "RUSAGE_CHILDREN", RUSAGE_CHILDREN); | |
#endif | |
#ifdef RUSAGE_BOTH | |
PyModule_AddIntConstant(m, "RUSAGE_BOTH", RUSAGE_BOTH); | |
#endif | |
#if defined(HAVE_LONG_LONG) | |
if (sizeof(RLIM_INFINITY) > sizeof(long)) { | |
v = PyLong_FromLongLong((PY_LONG_LONG) RLIM_INFINITY); | |
} else | |
#endif | |
{ | |
v = PyInt_FromLong((long) RLIM_INFINITY); | |
} | |
if (v) { | |
PyModule_AddObject(m, "RLIM_INFINITY", v); | |
} | |
initialized = 1; | |
} |