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