Modules/resource.c

   1 /***********************************************************
   2 Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
   3 The Netherlands.
   4
   5                         All Rights Reserved
   6
   7 Permission to use, copy, modify, and distribute this software and its
   8 documentation for any purpose and without fee is hereby granted,
   9 provided that the above copyright notice appear in all copies and that
  10 both that copyright notice and this permission notice appear in
  11 supporting documentation, and that the names of Stichting Mathematisch
  12 Centrum or CWI or Corporation for National Research Initiatives or
  13 CNRI not be used in advertising or publicity pertaining to
  14 distribution of the software without specific, written prior
  15 permission.
  16
  17 While CWI is the initial source for this software, a modified version
  18 is made available by the Corporation for National Research Initiatives
  19 (CNRI) at the Internet address ftp://ftp.python.org.
  20
  21 STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
  22 REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
  23 MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
  24 CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  25 DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  26 PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  27 TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  28 PERFORMANCE OF THIS SOFTWARE.
  29
  30 ******************************************************************/
  31
  32 #include "Python.h"
  33 #include "mytime.h" /* needed for SunOS4.1 */
  34 #include <sys/resource.h>
  35 #include <sys/time.h>
  36 #include <unistd.h>
  37 #include <string.h>
  38 #include <errno.h>
  39
  40 /* On some systems, these aren't in any header file.
  41    On others they are, with inconsistent prototypes.
  42    We declare the (default) return type, to shut up gcc -Wall;
  43    but we can't declare the prototype, to avoid errors
  44    when the header files declare it different.
  45    Worse, on some Linuxes, getpagesize() returns a size_t... */
  46 #ifndef linux
  47 int getrusage();
  48 int getpagesize();
  49 #endif
  50
  51 #define doubletime(TV) ((double)(TV).tv_sec + (TV).tv_usec * 0.000001)
  52
  53 static PyObject *ResourceError;
  54
  55 static PyObject *
  56 resource_getrusage(self, args)
  57         PyObject *self;
  58         PyObject *args;
  59 {
  60         int who;
  61         struct rusage ru;
  62
  63         if (!PyArg_ParseTuple(args, "i", &who))
  64                 return NULL;
  65
  66         if (getrusage(who, &ru) == -1) {
  67                 if (errno == EINVAL) {
  68                         PyErr_SetString(PyExc_ValueError,
  69                                         "invalid who parameter");
  70                         return NULL;
  71                 }
  72                 PyErr_SetFromErrno(ResourceError);
  73                 return NULL;
  74         }
  75
  76         /* Yeah, this 16-tuple is way ugly. It's probably a lot less
  77            ugly than a dictionary with keys (or object attributes)
  78            named things like 'ixrss'.
  79            */
  80         return Py_BuildValue(
  81                 "ddiiiiiiiiiiiiii",
  82                 doubletime(ru.ru_utime),     /* user time used */
  83                 doubletime(ru.ru_stime),     /* system time used */
  84                 ru.ru_maxrss,                /* max. resident set size */
  85                 ru.ru_ixrss,                 /* shared memory size */
  86                 ru.ru_idrss,                 /* unshared memory size */
  87                 ru.ru_isrss,                 /* unshared stack size */
  88                 ru.ru_minflt,                /* page faults not requiring I/O*/
  89                 ru.ru_majflt,                /* page faults requiring I/O */
  90                 ru.ru_nswap,                 /* number of swap outs */
  91                 ru.ru_inblock,               /* block input operations */
  92                 ru.ru_oublock,               /* block output operations */
  93                 ru.ru_msgsnd,                /* messages sent */
  94                 ru.ru_msgrcv,                /* messages received */
  95                 ru.ru_nsignals,              /* signals received */
  96                 ru.ru_nvcsw,                 /* voluntary context switchs */
  97                 ru.ru_nivcsw                 /* involuntary context switchs */
  98                 );
  99 }
 100
 101
 102 static PyObject *
 103 resource_getrlimit(self, args)
 104         PyObject *self;
 105         PyObject *args;
 106 {
 107         struct rlimit rl;
 108         int resource;
 109
 110         if (!PyArg_ParseTuple(args, "i", &resource))
 111                 return NULL;
 112
 113         if (resource < 0 || resource >= RLIM_NLIMITS) {
 114                 PyErr_SetString(PyExc_ValueError,
 115                                 "invalid resource specified");
 116                 return NULL;
 117         }
 118
 119         if (getrlimit(resource, &rl) == -1) {
 120                 PyErr_SetFromErrno(ResourceError);
 121                 return NULL;
 122         }
 123
 124 #if defined(HAVE_LONG_LONG)
 125         if (sizeof(rl.rlim_cur) > sizeof(long)) {
 126                 return Py_BuildValue("LL",
 127                                      (LONG_LONG) rl.rlim_cur,
 128                                      (LONG_LONG) rl.rlim_max);
 129         }
 130 #endif
 131         return Py_BuildValue("ii", (long) rl.rlim_cur, (long) rl.rlim_max);
 132 }
 133
 134 static PyObject *
 135 resource_setrlimit(self, args)
 136         PyObject *self;
 137         PyObject *args;
 138 {
 139         struct rlimit rl;
 140         int resource;
 141         PyObject *curobj, *maxobj;
 142
 143         if (!PyArg_ParseTuple(args, "i(OO)", &resource, &curobj, &maxobj))
 144                 return NULL;
 145
 146         if (resource < 0 || resource >= RLIM_NLIMITS) {
 147                 PyErr_SetString(PyExc_ValueError,
 148                                 "invalid resource specified");
 149                 return NULL;
 150         }
 151
 152 #if !defined(HAVE_LARGEFILE_SUPPORT)
 153         rl.rlim_cur = PyInt_AsLong(curobj);
 154         rl.rlim_max = PyInt_AsLong(maxobj);
 155 #else
 156         /* The limits are probably bigger than a long */
 157         rl.rlim_cur = PyLong_Check(curobj) ?
 158                 PyLong_AsLongLong(curobj) : PyInt_AsLong(curobj);
 159         rl.rlim_max = PyLong_Check(maxobj) ?
 160                 PyLong_AsLongLong(maxobj) : PyInt_AsLong(maxobj);
 161 #endif
 162
 163         rl.rlim_cur = rl.rlim_cur & RLIM_INFINITY;
 164         rl.rlim_max = rl.rlim_max & RLIM_INFINITY;
 165         if (setrlimit(resource, &rl) == -1) {
 166                 if (errno == EINVAL)
 167                         PyErr_SetString(PyExc_ValueError,
 168                                         "current limit exceeds maximum limit");
 169                 else if (errno == EPERM)
 170                         PyErr_SetString(PyExc_ValueError,
 171                                         "not allowed to raise maximum limit");
 172                 else
 173                         PyErr_SetFromErrno(ResourceError);
 174                 return NULL;
 175         }
 176         Py_INCREF(Py_None);
 177         return Py_None;
 178 }
 179
 180 static PyObject *
 181 resource_getpagesize(self, args)
 182         PyObject *self;
 183         PyObject *args;
 184 {
 185         if (!PyArg_ParseTuple(args, ""))
 186                 return NULL;
 187         return Py_BuildValue("i", getpagesize());
 188 }
 189
 190 /* List of functions */
 191
 192 static struct PyMethodDef
 193 resource_methods[] = {
 194         {"getrusage",    resource_getrusage,   1},
 195         {"getrlimit",    resource_getrlimit,   1},
 196         {"setrlimit",    resource_setrlimit,   1},
 197         {"getpagesize",  resource_getpagesize, 1},
 198         {NULL, NULL}                         /* sentinel */
 199 };
 200
 201
 202 /* Module initialization */
 203
 204 static void
 205 ins(PyObject *dict, char *name, int value)
 206 {
 207         PyObject *v = PyInt_FromLong((long) value);
 208         if (v) {
 209                 PyDict_SetItemString(dict, name, v);
 210                 Py_DECREF(v);
 211         }
 212         /* errors will be checked by initresource() */
 213 }
 214
 215 void initresource()
 216 {
 217         PyObject *m, *d;
 218
 219         /* Create the module and add the functions */
 220         m = Py_InitModule("resource", resource_methods);
 221
 222         /* Add some symbolic constants to the module */
 223         d = PyModule_GetDict(m);
 224         ResourceError = PyErr_NewException("resource.error", NULL, NULL);
 225         PyDict_SetItemString(d, "error", ResourceError);
 226
 227         /* insert constants */
 228 #ifdef RLIMIT_CPU
 229         ins(d, "RLIMIT_CPU", RLIMIT_CPU);
 230 #endif
 231
 232 #ifdef RLIMIT_FSIZE
 233         ins(d, "RLIMIT_FSIZE", RLIMIT_FSIZE);
 234 #endif
 235
 236 #ifdef RLIMIT_DATA
 237         ins(d, "RLIMIT_DATA", RLIMIT_DATA);
 238 #endif
 239
 240 #ifdef RLIMIT_STACK
 241         ins(d, "RLIMIT_STACK", RLIMIT_STACK);
 242 #endif
 243
 244 #ifdef RLIMIT_CORE
 245         ins(d, "RLIMIT_CORE", RLIMIT_CORE);
 246 #endif
 247
 248 #ifdef RLIMIT_NOFILE
 249         ins(d, "RLIMIT_NOFILE", RLIMIT_NOFILE);
 250 #endif
 251
 252 #ifdef RLIMIT_OFILE
 253         ins(d, "RLIMIT_OFILE", RLIMIT_OFILE);
 254 #endif
 255
 256 #ifdef RLIMIT_VMEM
 257         ins(d, "RLIMIT_VMEM", RLIMIT_VMEM);
 258 #endif
 259
 260 #ifdef RLIMIT_AS
 261         ins(d, "RLIMIT_AS", RLIMIT_AS);
 262 #endif
 263
 264 #ifdef RLIMIT_RSS
 265         ins(d, "RLIMIT_RSS", RLIMIT_RSS);
 266 #endif
 267
 268 #ifdef RLIMIT_NPROC
 269         ins(d, "RLIMIT_NPROC", RLIMIT_NPROC);
 270 #endif
 271
 272 #ifdef RLIMIT_MEMLOCK
 273         ins(d, "RLIMIT_MEMLOCK", RLIMIT_MEMLOCK);
 274 #endif
 275
 276 #ifdef RUSAGE_SELF
 277         ins(d, "RUSAGE_SELF", RUSAGE_SELF);
 278 #endif
 279
 280 #ifdef RUSAGE_CHILDREN
 281         ins(d, "RUSAGE_CHILDREN", RUSAGE_CHILDREN);
 282 #endif
 283
 284 #ifdef RUSAGE_BOTH
 285         ins(d, "RUSAGE_BOTH", RUSAGE_BOTH);
 286 #endif
 287 }