From 2e6313930eab9dbadf6ffb5afed341a809f2c5c5 Mon Sep 17 00:00:00 2001 From: Guido van Rossum Date: Wed, 18 Dec 1996 18:37:27 +0000 Subject: [PATCH] Added Jeremy's resource module. --- Modules/Makefile.pre.in | 1 + Modules/Setup.in | 1 + Modules/resource.c | 240 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 242 insertions(+) create mode 100644 Modules/resource.c diff --git a/Modules/Makefile.pre.in b/Modules/Makefile.pre.in index ec80f899f6e..a5f0d9a5c4f 100644 --- a/Modules/Makefile.pre.in +++ b/Modules/Makefile.pre.in @@ -185,6 +185,7 @@ posixmodule.o: posixmodule.c pwdmodule.o: pwdmodule.c regexmodule.o: regexmodule.c regexpr.o: regexpr.c +resource.o: resource.c rgbimgmodule.o: rgbimgmodule.c rotormodule.o: rotormodule.c selectmodule.o: selectmodule.c diff --git a/Modules/Setup.in b/Modules/Setup.in index 6538cd44fbf..1097378083c 100644 --- a/Modules/Setup.in +++ b/Modules/Setup.in @@ -140,6 +140,7 @@ errno errnomodule.c # posix (UNIX) errno values #nis nismodule.c # Sun yellow pages -- not everywhere #termios termios.c # Steen Lumholt's termios module #_xdr _xdrmodule.c # -lnsl # Helper for xdrlib.py +#resource resource.c # Jeremy Hylton's rlimit interface # Multimedia modules -- on by default. diff --git a/Modules/resource.c b/Modules/resource.c new file mode 100644 index 00000000000..48d148d7819 --- /dev/null +++ b/Modules/resource.c @@ -0,0 +1,240 @@ +#include "Python.h" +#include +#include +#include +#include +#include + +/* don't know why this isn't defined in a header file */ +#ifndef getrusage +int getrusage(int who, struct rusage *rusage); +#endif + +#ifndef getpagesize +int getpagesize(void); +#endif + +#define doubletime(TV) ((double)(TV).tv_sec + (TV).tv_usec * 0.000001) + +static PyObject *ResourceError; + +static PyObject * +resource_getrusage(self, args) + PyObject *self; + PyObject *args; +{ + int who; + struct rusage ru; + + if (!PyArg_ParseTuple(args, "i", &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; + } + + /* Yeah, this 16-tuple is way ugly. It's probably a lot less + ugly than a dictionary with keys (or object attributes) + named things like 'ixrss'. + */ + return Py_BuildValue( + "ddiiiiiiiiiiiiii", + doubletime(ru.ru_utime), /* user time used */ + doubletime(ru.ru_stime), /* system time used */ + ru.ru_maxrss, /* max. resident set size */ + ru.ru_ixrss, /* shared memory size */ + ru.ru_idrss, /* unshared memory size */ + ru.ru_isrss, /* unshared stack size */ + ru.ru_minflt, /* page faults not requiring I/O*/ + ru.ru_majflt, /* page faults requiring I/O */ + ru.ru_nswap, /* number of swap outs */ + ru.ru_inblock, /* block input operations */ + ru.ru_oublock, /* block output operations */ + ru.ru_msgsnd, /* messages sent */ + ru.ru_msgrcv, /* messages received */ + ru.ru_nsignals, /* signals received */ + ru.ru_nvcsw, /* voluntary context switchs */ + ru.ru_nivcsw /* involuntary context switchs */ + ); +} + + +static PyObject * +resource_getrlimit(self, args) + PyObject *self; + PyObject *args; +{ + struct rlimit rl; + int resource; + char *errstr; + + if (!PyArg_ParseTuple(args, "i", &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; + } + return Py_BuildValue("ii", rl.rlim_cur, rl.rlim_max); +} + +static PyObject * +resource_setrlimit(self, args) + PyObject *self; + PyObject *args; +{ + struct rlimit rl; + int resource; + char *errstr; + + if (!PyArg_ParseTuple(args, "i(ii)", &resource, &rl.rlim_cur, + &rl.rlim_max)) + return NULL; + + if (resource < 0 || resource >= RLIM_NLIMITS) { + PyErr_SetString(PyExc_ValueError, + "invalid resource specified"); + return NULL; + } + + 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(self, args) + PyObject *self; + PyObject *args; +{ + if (!PyArg_ParseTuple(args, "")) + return NULL; + return Py_BuildValue("i", getpagesize()); +} + +/* List of functions */ + +static struct PyMethodDef +resource_methods[] = { + {"getrusage", resource_getrusage, 1}, + {"getrlimit", resource_getrlimit, 1}, + {"setrlimit", resource_setrlimit, 1}, + {"getpagesize", resource_getpagesize, 1}, + {NULL, NULL} /* sentinel */ +}; + + +/* Module initialization */ + +static void +ins(PyObject *dict, char *name, int value) +{ + PyObject *v = PyInt_FromLong((long) value); + if (v) { + PyDict_SetItemString(dict, name, v); + Py_DECREF(v); + } + /* errors will be checked by initresource() */ +} + +void initresource() +{ + PyObject *m, *d; + + /* Create the module and add the functions */ + m = Py_InitModule("resource", resource_methods); + + /* Add some symbolic constants to the module */ + d = PyModule_GetDict(m); + ResourceError = PyString_FromString("resource.error"); + PyDict_SetItemString(d, "error", ResourceError); + + /* insert constants */ +#ifdef RLIMIT_CPU + ins(d, "RLIMIT_CPU", RLIMIT_CPU); +#endif + +#ifdef RLIMIT_FSIZE + ins(d, "RLIMIT_FSIZE", RLIMIT_FSIZE); +#endif + +#ifdef RLIMIT_DATA + ins(d, "RLIMIT_DATA", RLIMIT_DATA); +#endif + +#ifdef RLIMIT_STACK + ins(d, "RLIMIT_STACK", RLIMIT_STACK); +#endif + +#ifdef RLIMIT_CORE + ins(d, "RLIMIT_CORE", RLIMIT_CORE); +#endif + +#ifdef RLIMIT_NOFILE + ins(d, "RLIMIT_NOFILE", RLIMIT_NOFILE); +#endif + +#ifdef RLIMIT_OFILE + ins(d, "RLIMIT_OFILE", RLIMIT_OFILE); +#endif + +#ifdef RLIMIT_VMEM + ins(d, "RLIMIT_VMEM", RLIMIT_VMEM); +#endif + +#ifdef RLIMIT_AS + ins(d, "RLIMIT_AS", RLIMIT_AS); +#endif + +#ifdef RLIMIT_RSS + ins(d, "RLIMIT_RSS", RLIMIT_RSS); +#endif + +#ifdef RLIMIT_NPROC + ins(d, "RLIMIT_NPROC", RLIMIT_NPROC); +#endif + +#ifdef RLIMIT_MEMLOCK + ins(d, "RLIMIT_MEMLOCK", RLIMIT_MEMLOCK); +#endif + +#ifdef RUSAGE_SELF + ins(d, "RUSAGE_SELF", RUSAGE_SELF); +#endif + +#ifdef RUSAGE_CHILDERN + ins(d, "RUSAGE_CHILDREN", RUSAGE_CHILDREN); +#endif + +#ifdef RUSAGE_BOTH + ins(d, "RUSAGE_BOTH", RUSAGE_BOTH); +#endif + + /* Check for errors */ + if (PyErr_Occurred()) + Py_FatalError("can't initialize module resource"); +}