4 #include <sys/resource.h>
9 #if defined(HAVE_UNISTD_H)
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... */
20 #define doubletime(TV) ((double)(TV).tv_sec + (TV).tv_usec * 0.000001)
22 static PyObject
*ResourceError
;
24 PyDoc_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.");
31 static 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"},
51 static 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 */
58 static PyTypeObject StructRUsageType
;
61 resource_getrusage(PyObject
*self
, PyObject
*args
)
67 if (!PyArg_ParseTuple(args
, "i:getrusage", &who
))
70 if (getrusage(who
, &ru
) == -1) {
71 if (errno
== EINVAL
) {
72 PyErr_SetString(PyExc_ValueError
,
73 "invalid who parameter");
76 PyErr_SetFromErrno(ResourceError
);
80 result
= PyStructSequence_New(&StructRUsageType
);
84 PyStructSequence_SET_ITEM(result
, 0,
85 PyFloat_FromDouble(doubletime(ru
.ru_utime
)));
86 PyStructSequence_SET_ITEM(result
, 1,
87 PyFloat_FromDouble(doubletime(ru
.ru_stime
)));
88 PyStructSequence_SET_ITEM(result
, 2, PyInt_FromLong(ru
.ru_maxrss
));
89 PyStructSequence_SET_ITEM(result
, 3, PyInt_FromLong(ru
.ru_ixrss
));
90 PyStructSequence_SET_ITEM(result
, 4, PyInt_FromLong(ru
.ru_idrss
));
91 PyStructSequence_SET_ITEM(result
, 5, PyInt_FromLong(ru
.ru_isrss
));
92 PyStructSequence_SET_ITEM(result
, 6, PyInt_FromLong(ru
.ru_minflt
));
93 PyStructSequence_SET_ITEM(result
, 7, PyInt_FromLong(ru
.ru_majflt
));
94 PyStructSequence_SET_ITEM(result
, 8, PyInt_FromLong(ru
.ru_nswap
));
95 PyStructSequence_SET_ITEM(result
, 9, PyInt_FromLong(ru
.ru_inblock
));
96 PyStructSequence_SET_ITEM(result
, 10, PyInt_FromLong(ru
.ru_oublock
));
97 PyStructSequence_SET_ITEM(result
, 11, PyInt_FromLong(ru
.ru_msgsnd
));
98 PyStructSequence_SET_ITEM(result
, 12, PyInt_FromLong(ru
.ru_msgrcv
));
99 PyStructSequence_SET_ITEM(result
, 13, PyInt_FromLong(ru
.ru_nsignals
));
100 PyStructSequence_SET_ITEM(result
, 14, PyInt_FromLong(ru
.ru_nvcsw
));
101 PyStructSequence_SET_ITEM(result
, 15, PyInt_FromLong(ru
.ru_nivcsw
));
103 if (PyErr_Occurred()) {
113 resource_getrlimit(PyObject
*self
, PyObject
*args
)
118 if (!PyArg_ParseTuple(args
, "i:getrlimit", &resource
))
121 if (resource
< 0 || resource
>= RLIM_NLIMITS
) {
122 PyErr_SetString(PyExc_ValueError
,
123 "invalid resource specified");
127 if (getrlimit(resource
, &rl
) == -1) {
128 PyErr_SetFromErrno(ResourceError
);
132 #if defined(HAVE_LONG_LONG)
133 if (sizeof(rl
.rlim_cur
) > sizeof(long)) {
134 return Py_BuildValue("LL",
135 (PY_LONG_LONG
) rl
.rlim_cur
,
136 (PY_LONG_LONG
) rl
.rlim_max
);
139 return Py_BuildValue("ll", (long) rl
.rlim_cur
, (long) rl
.rlim_max
);
143 resource_setrlimit(PyObject
*self
, PyObject
*args
)
147 PyObject
*curobj
, *maxobj
;
149 if (!PyArg_ParseTuple(args
, "i(OO):setrlimit",
150 &resource
, &curobj
, &maxobj
))
153 if (resource
< 0 || resource
>= RLIM_NLIMITS
) {
154 PyErr_SetString(PyExc_ValueError
,
155 "invalid resource specified");
159 #if !defined(HAVE_LARGEFILE_SUPPORT)
160 rl
.rlim_cur
= PyInt_AsLong(curobj
);
161 if (rl
.rlim_cur
== -1 && PyErr_Occurred())
163 rl
.rlim_max
= PyInt_AsLong(maxobj
);
164 if (rl
.rlim_max
== -1 && PyErr_Occurred())
167 /* The limits are probably bigger than a long */
168 rl
.rlim_cur
= PyLong_Check(curobj
) ?
169 PyLong_AsLongLong(curobj
) : PyInt_AsLong(curobj
);
170 if (rl
.rlim_cur
== -1 && PyErr_Occurred())
172 rl
.rlim_max
= PyLong_Check(maxobj
) ?
173 PyLong_AsLongLong(maxobj
) : PyInt_AsLong(maxobj
);
174 if (rl
.rlim_max
== -1 && PyErr_Occurred())
178 rl
.rlim_cur
= rl
.rlim_cur
& RLIM_INFINITY
;
179 rl
.rlim_max
= rl
.rlim_max
& RLIM_INFINITY
;
180 if (setrlimit(resource
, &rl
) == -1) {
182 PyErr_SetString(PyExc_ValueError
,
183 "current limit exceeds maximum limit");
184 else if (errno
== EPERM
)
185 PyErr_SetString(PyExc_ValueError
,
186 "not allowed to raise maximum limit");
188 PyErr_SetFromErrno(ResourceError
);
196 resource_getpagesize(PyObject
*self
, PyObject
*args
)
199 if (!PyArg_ParseTuple(args
, ":getpagesize"))
202 #if defined(HAVE_GETPAGESIZE)
203 pagesize
= getpagesize();
204 #elif defined(HAVE_SYSCONF)
205 #if defined(_SC_PAGE_SIZE)
206 pagesize
= sysconf(_SC_PAGE_SIZE
);
208 /* Irix 5.3 has _SC_PAGESIZE, but not _SC_PAGE_SIZE */
209 pagesize
= sysconf(_SC_PAGESIZE
);
212 return Py_BuildValue("i", pagesize
);
216 /* List of functions */
218 static struct PyMethodDef
219 resource_methods
[] = {
220 {"getrusage", resource_getrusage
, METH_VARARGS
},
221 {"getrlimit", resource_getrlimit
, METH_VARARGS
},
222 {"setrlimit", resource_setrlimit
, METH_VARARGS
},
223 {"getpagesize", resource_getpagesize
, METH_VARARGS
},
224 {NULL
, NULL
} /* sentinel */
228 /* Module initialization */
235 /* Create the module and add the functions */
236 m
= Py_InitModule("resource", resource_methods
);
240 /* Add some symbolic constants to the module */
241 if (ResourceError
== NULL
) {
242 ResourceError
= PyErr_NewException("resource.error",
245 Py_INCREF(ResourceError
);
246 PyModule_AddObject(m
, "error", ResourceError
);
247 PyStructSequence_InitType(&StructRUsageType
, &struct_rusage_desc
);
248 PyModule_AddObject(m
, "struct_rusage",
249 (PyObject
*) &StructRUsageType
);
251 /* insert constants */
253 PyModule_AddIntConstant(m
, "RLIMIT_CPU", RLIMIT_CPU
);
257 PyModule_AddIntConstant(m
, "RLIMIT_FSIZE", RLIMIT_FSIZE
);
261 PyModule_AddIntConstant(m
, "RLIMIT_DATA", RLIMIT_DATA
);
265 PyModule_AddIntConstant(m
, "RLIMIT_STACK", RLIMIT_STACK
);
269 PyModule_AddIntConstant(m
, "RLIMIT_CORE", RLIMIT_CORE
);
273 PyModule_AddIntConstant(m
, "RLIMIT_NOFILE", RLIMIT_NOFILE
);
277 PyModule_AddIntConstant(m
, "RLIMIT_OFILE", RLIMIT_OFILE
);
281 PyModule_AddIntConstant(m
, "RLIMIT_VMEM", RLIMIT_VMEM
);
285 PyModule_AddIntConstant(m
, "RLIMIT_AS", RLIMIT_AS
);
289 PyModule_AddIntConstant(m
, "RLIMIT_RSS", RLIMIT_RSS
);
293 PyModule_AddIntConstant(m
, "RLIMIT_NPROC", RLIMIT_NPROC
);
296 #ifdef RLIMIT_MEMLOCK
297 PyModule_AddIntConstant(m
, "RLIMIT_MEMLOCK", RLIMIT_MEMLOCK
);
301 PyModule_AddIntConstant(m
, "RUSAGE_SELF", RUSAGE_SELF
);
304 #ifdef RUSAGE_CHILDREN
305 PyModule_AddIntConstant(m
, "RUSAGE_CHILDREN", RUSAGE_CHILDREN
);
309 PyModule_AddIntConstant(m
, "RUSAGE_BOTH", RUSAGE_BOTH
);
312 #if defined(HAVE_LONG_LONG)
313 if (sizeof(RLIM_INFINITY
) > sizeof(long)) {
314 v
= PyLong_FromLongLong((PY_LONG_LONG
) RLIM_INFINITY
);
318 v
= PyInt_FromLong((long) RLIM_INFINITY
);
321 PyModule_AddObject(m
, "RLIM_INFINITY", v
);