1
2#include "Python.h"
3#include "structseq.h"
4#include <sys/resource.h>
5#include <sys/time.h>
6#include <string.h>
7#include <errno.h>
8/* for sysconf */
9#if defined(HAVE_UNISTD_H)
10#include <unistd.h>
11#endif
12
13/* On some systems, these aren't in any header file.
14   On others they are, with inconsistent prototypes.
15   We declare the (default) return type, to shut up gcc -Wall;
16   but we can't declare the prototype, to avoid errors
17   when the header files declare it different.
18   Worse, on some Linuxes, getpagesize() returns a size_t... */
19
20#define doubletime(TV) ((double)(TV).tv_sec + (TV).tv_usec * 0.000001)
21
22static PyObject *ResourceError;
23
24PyDoc_STRVAR(struct_rusage__doc__,
25"struct_rusage: Result from getrusage.\n\n"
26"This object may be accessed either as a tuple of\n"
27"    (utime,stime,maxrss,ixrss,idrss,isrss,minflt,majflt,\n"
28"    nswap,inblock,oublock,msgsnd,msgrcv,nsignals,nvcsw,nivcsw)\n"
29"or via the attributes ru_utime, ru_stime, ru_maxrss, and so on.");
30
31static PyStructSequence_Field struct_rusage_fields[] = {
32    {"ru_utime",        "user time used"},
33    {"ru_stime",        "system time used"},
34    {"ru_maxrss",       "max. resident set size"},
35    {"ru_ixrss",        "shared memory size"},
36    {"ru_idrss",        "unshared data size"},
37    {"ru_isrss",        "unshared stack size"},
38    {"ru_minflt",       "page faults not requiring I/O"},
39    {"ru_majflt",       "page faults requiring I/O"},
40    {"ru_nswap",        "number of swap outs"},
41    {"ru_inblock",      "block input operations"},
42    {"ru_oublock",      "block output operations"},
43    {"ru_msgsnd",       "IPC messages sent"},
44    {"ru_msgrcv",       "IPC messages received"},
45    {"ru_nsignals",     "signals received"},
46    {"ru_nvcsw",        "voluntary context switches"},
47    {"ru_nivcsw",       "involuntary context switches"},
48    {0}
49};
50
51static PyStructSequence_Desc struct_rusage_desc = {
52    "resource.struct_rusage",           /* name */
53    struct_rusage__doc__,       /* doc */
54    struct_rusage_fields,       /* fields */
55    16          /* n_in_sequence */
56};
57
58static int initialized;
59static PyTypeObject StructRUsageType;
60
61static PyObject *
62resource_getrusage(PyObject *self, PyObject *args)
63{
64    int who;
65    struct rusage ru;
66    PyObject *result;
67
68    if (!PyArg_ParseTuple(args, "i:getrusage", &who))
69        return NULL;
70
71    if (getrusage(who, &ru) == -1) {
72        if (errno == EINVAL) {
73            PyErr_SetString(PyExc_ValueError,
74                            "invalid who parameter");
75            return NULL;
76        }
77        PyErr_SetFromErrno(ResourceError);
78        return NULL;
79    }
80
81    result = PyStructSequence_New(&StructRUsageType);
82    if (!result)
83        return NULL;
84
85    PyStructSequence_SET_ITEM(result, 0,
86                    PyFloat_FromDouble(doubletime(ru.ru_utime)));
87    PyStructSequence_SET_ITEM(result, 1,
88                    PyFloat_FromDouble(doubletime(ru.ru_stime)));
89    PyStructSequence_SET_ITEM(result, 2, PyInt_FromLong(ru.ru_maxrss));
90    PyStructSequence_SET_ITEM(result, 3, PyInt_FromLong(ru.ru_ixrss));
91    PyStructSequence_SET_ITEM(result, 4, PyInt_FromLong(ru.ru_idrss));
92    PyStructSequence_SET_ITEM(result, 5, PyInt_FromLong(ru.ru_isrss));
93    PyStructSequence_SET_ITEM(result, 6, PyInt_FromLong(ru.ru_minflt));
94    PyStructSequence_SET_ITEM(result, 7, PyInt_FromLong(ru.ru_majflt));
95    PyStructSequence_SET_ITEM(result, 8, PyInt_FromLong(ru.ru_nswap));
96    PyStructSequence_SET_ITEM(result, 9, PyInt_FromLong(ru.ru_inblock));
97    PyStructSequence_SET_ITEM(result, 10, PyInt_FromLong(ru.ru_oublock));
98    PyStructSequence_SET_ITEM(result, 11, PyInt_FromLong(ru.ru_msgsnd));
99    PyStructSequence_SET_ITEM(result, 12, PyInt_FromLong(ru.ru_msgrcv));
100    PyStructSequence_SET_ITEM(result, 13, PyInt_FromLong(ru.ru_nsignals));
101    PyStructSequence_SET_ITEM(result, 14, PyInt_FromLong(ru.ru_nvcsw));
102    PyStructSequence_SET_ITEM(result, 15, PyInt_FromLong(ru.ru_nivcsw));
103
104    if (PyErr_Occurred()) {
105        Py_DECREF(result);
106        return NULL;
107    }
108
109    return result;
110}
111
112
113static PyObject *
114resource_getrlimit(PyObject *self, PyObject *args)
115{
116    struct rlimit rl;
117    int resource;
118
119    if (!PyArg_ParseTuple(args, "i:getrlimit", &resource))
120        return NULL;
121
122    if (resource < 0 || resource >= RLIM_NLIMITS) {
123        PyErr_SetString(PyExc_ValueError,
124                        "invalid resource specified");
125        return NULL;
126    }
127
128    if (getrlimit(resource, &rl) == -1) {
129        PyErr_SetFromErrno(ResourceError);
130        return NULL;
131    }
132
133#if defined(HAVE_LONG_LONG)
134    if (sizeof(rl.rlim_cur) > sizeof(long)) {
135        return Py_BuildValue("LL",
136                             (PY_LONG_LONG) rl.rlim_cur,
137                             (PY_LONG_LONG) rl.rlim_max);
138    }
139#endif
140    return Py_BuildValue("ll", (long) rl.rlim_cur, (long) rl.rlim_max);
141}
142
143static PyObject *
144resource_setrlimit(PyObject *self, PyObject *args)
145{
146    struct rlimit rl;
147    int resource;
148    PyObject *curobj, *maxobj;
149
150    if (!PyArg_ParseTuple(args, "i(OO):setrlimit",
151                          &resource, &curobj, &maxobj))
152        return NULL;
153
154    if (resource < 0 || resource >= RLIM_NLIMITS) {
155        PyErr_SetString(PyExc_ValueError,
156                        "invalid resource specified");
157        return NULL;
158    }
159
160#if !defined(HAVE_LARGEFILE_SUPPORT)
161    rl.rlim_cur = PyInt_AsLong(curobj);
162    if (rl.rlim_cur == (rlim_t)-1 && PyErr_Occurred())
163        return NULL;
164    rl.rlim_max = PyInt_AsLong(maxobj);
165    if (rl.rlim_max == (rlim_t)-1 && PyErr_Occurred())
166        return NULL;
167#else
168    /* The limits are probably bigger than a long */
169    rl.rlim_cur = PyLong_Check(curobj) ?
170        PyLong_AsLongLong(curobj) : PyInt_AsLong(curobj);
171    if (rl.rlim_cur == (rlim_t)-1 && PyErr_Occurred())
172        return NULL;
173    rl.rlim_max = PyLong_Check(maxobj) ?
174        PyLong_AsLongLong(maxobj) : PyInt_AsLong(maxobj);
175    if (rl.rlim_max == (rlim_t)-1 && PyErr_Occurred())
176        return NULL;
177#endif
178
179    rl.rlim_cur = rl.rlim_cur & RLIM_INFINITY;
180    rl.rlim_max = rl.rlim_max & RLIM_INFINITY;
181    if (setrlimit(resource, &rl) == -1) {
182        if (errno == EINVAL)
183            PyErr_SetString(PyExc_ValueError,
184                            "current limit exceeds maximum limit");
185        else if (errno == EPERM)
186            PyErr_SetString(PyExc_ValueError,
187                            "not allowed to raise maximum limit");
188        else
189            PyErr_SetFromErrno(ResourceError);
190        return NULL;
191    }
192    Py_INCREF(Py_None);
193    return Py_None;
194}
195
196static PyObject *
197resource_getpagesize(PyObject *self, PyObject *unused)
198{
199    long pagesize = 0;
200#if defined(HAVE_GETPAGESIZE)
201    pagesize = getpagesize();
202#elif defined(HAVE_SYSCONF)
203#if defined(_SC_PAGE_SIZE)
204    pagesize = sysconf(_SC_PAGE_SIZE);
205#else
206    /* Irix 5.3 has _SC_PAGESIZE, but not _SC_PAGE_SIZE */
207    pagesize = sysconf(_SC_PAGESIZE);
208#endif
209#endif
210    return Py_BuildValue("i", pagesize);
211
212}
213
214/* List of functions */
215
216static struct PyMethodDef
217resource_methods[] = {
218    {"getrusage",    resource_getrusage,   METH_VARARGS},
219    {"getrlimit",    resource_getrlimit,   METH_VARARGS},
220    {"setrlimit",    resource_setrlimit,   METH_VARARGS},
221    {"getpagesize",  resource_getpagesize, METH_NOARGS},
222    {NULL, NULL}                             /* sentinel */
223};
224
225
226/* Module initialization */
227
228PyMODINIT_FUNC
229initresource(void)
230{
231    PyObject *m, *v;
232
233    /* Create the module and add the functions */
234    m = Py_InitModule("resource", resource_methods);
235    if (m == NULL)
236        return;
237
238    /* Add some symbolic constants to the module */
239    if (ResourceError == NULL) {
240        ResourceError = PyErr_NewException("resource.error",
241                                           NULL, NULL);
242    }
243    Py_INCREF(ResourceError);
244    PyModule_AddObject(m, "error", ResourceError);
245    if (!initialized)
246        PyStructSequence_InitType(&StructRUsageType,
247                                  &struct_rusage_desc);
248    Py_INCREF(&StructRUsageType);
249    PyModule_AddObject(m, "struct_rusage",
250                       (PyObject*) &StructRUsageType);
251
252    /* insert constants */
253#ifdef RLIMIT_CPU
254    PyModule_AddIntConstant(m, "RLIMIT_CPU", RLIMIT_CPU);
255#endif
256
257#ifdef RLIMIT_FSIZE
258    PyModule_AddIntConstant(m, "RLIMIT_FSIZE", RLIMIT_FSIZE);
259#endif
260
261#ifdef RLIMIT_DATA
262    PyModule_AddIntConstant(m, "RLIMIT_DATA", RLIMIT_DATA);
263#endif
264
265#ifdef RLIMIT_STACK
266    PyModule_AddIntConstant(m, "RLIMIT_STACK", RLIMIT_STACK);
267#endif
268
269#ifdef RLIMIT_CORE
270    PyModule_AddIntConstant(m, "RLIMIT_CORE", RLIMIT_CORE);
271#endif
272
273#ifdef RLIMIT_NOFILE
274    PyModule_AddIntConstant(m, "RLIMIT_NOFILE", RLIMIT_NOFILE);
275#endif
276
277#ifdef RLIMIT_OFILE
278    PyModule_AddIntConstant(m, "RLIMIT_OFILE", RLIMIT_OFILE);
279#endif
280
281#ifdef RLIMIT_VMEM
282    PyModule_AddIntConstant(m, "RLIMIT_VMEM", RLIMIT_VMEM);
283#endif
284
285#ifdef RLIMIT_AS
286    PyModule_AddIntConstant(m, "RLIMIT_AS", RLIMIT_AS);
287#endif
288
289#ifdef RLIMIT_RSS
290    PyModule_AddIntConstant(m, "RLIMIT_RSS", RLIMIT_RSS);
291#endif
292
293#ifdef RLIMIT_NPROC
294    PyModule_AddIntConstant(m, "RLIMIT_NPROC", RLIMIT_NPROC);
295#endif
296
297#ifdef RLIMIT_MEMLOCK
298    PyModule_AddIntConstant(m, "RLIMIT_MEMLOCK", RLIMIT_MEMLOCK);
299#endif
300
301#ifdef RLIMIT_SBSIZE
302    PyModule_AddIntConstant(m, "RLIMIT_SBSIZE", RLIMIT_SBSIZE);
303#endif
304
305#ifdef RUSAGE_SELF
306    PyModule_AddIntConstant(m, "RUSAGE_SELF", RUSAGE_SELF);
307#endif
308
309#ifdef RUSAGE_CHILDREN
310    PyModule_AddIntConstant(m, "RUSAGE_CHILDREN", RUSAGE_CHILDREN);
311#endif
312
313#ifdef RUSAGE_BOTH
314    PyModule_AddIntConstant(m, "RUSAGE_BOTH", RUSAGE_BOTH);
315#endif
316
317#if defined(HAVE_LONG_LONG)
318    if (sizeof(RLIM_INFINITY) > sizeof(long)) {
319        v = PyLong_FromLongLong((PY_LONG_LONG) RLIM_INFINITY);
320    } else
321#endif
322    {
323        v = PyInt_FromLong((long) RLIM_INFINITY);
324    }
325    if (v) {
326        PyModule_AddObject(m, "RLIM_INFINITY", v);
327    }
328    initialized = 1;
329}
330