resource.c 8.09 KB
Newer Older
1

2
#include "Python.h"
3
#include "structseq.h"
4 5 6 7 8
#include <sys/resource.h>
#include <sys/time.h>
#include <string.h>
#include <errno.h>

9 10 11 12 13 14
/* On some systems, these aren't in any header file.
   On others they are, with inconsistent prototypes.
   We declare the (default) return type, to shut up gcc -Wall;
   but we can't declare the prototype, to avoid errors
   when the header files declare it different.
   Worse, on some Linuxes, getpagesize() returns a size_t... */
15 16 17 18 19

#define doubletime(TV) ((double)(TV).tv_sec + (TV).tv_usec * 0.000001)

static PyObject *ResourceError;

20 21 22 23 24 25
PyDoc_STRVAR(struct_rusage__doc__,
"struct_rusage: Result from getrusage.\n\n"
"This object may be accessed either as a tuple of\n"
"    (utime,stime,maxrss,ixrss,idrss,isrss,minflt,majflt,\n"
"    nswap,inblock,oublock,msgsnd,msgrcv,nsignals,nvcsw,nivcsw)\n"
"or via the attributes ru_utime, ru_stime, ru_maxrss, and so on.");
26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

static PyStructSequence_Field struct_rusage_fields[] = {
	{"ru_utime",	"user time used"},
	{"ru_stime",	"system time used"},
	{"ru_maxrss",	"max. resident set size"},
	{"ru_ixrss",	"shared memory size"},
	{"ru_idrss",	"unshared data size"},
	{"ru_isrss",	"unshared stack size"},
	{"ru_minflt",	"page faults not requiring I/O"},
	{"ru_majflt",	"page faults requiring I/O"},
	{"ru_nswap",	"number of swap outs"},
	{"ru_inblock",	"block input operations"},
	{"ru_oublock",	"block output operations"},
	{"ru_msgsnd",	"IPC messages sent"},
	{"ru_msgrcv",	"IPC messages received"},
	{"ru_nsignals",	"signals received"},
	{"ru_nvcsw",	"voluntary context switches"},
	{"ru_nivcsw",	"involuntary context switches"},
	{0}
};

static PyStructSequence_Desc struct_rusage_desc = {
	"resource.struct_rusage",	/* name */
	struct_rusage__doc__,	/* doc */
	struct_rusage_fields,	/* fields */
	16	/* n_in_sequence */
};

static PyTypeObject StructRUsageType;

56
static PyObject *
Peter Schneider-Kamp's avatar
Peter Schneider-Kamp committed
57
resource_getrusage(PyObject *self, PyObject *args)
58 59 60
{
	int who;
	struct rusage ru;
61
	PyObject *result;
62

63
	if (!PyArg_ParseTuple(args, "i:getrusage", &who))
64 65 66 67 68 69 70 71 72 73 74 75
		return NULL;

	if (getrusage(who, &ru) == -1) {
		if (errno == EINVAL) {
			PyErr_SetString(PyExc_ValueError,
					"invalid who parameter");
			return NULL;
		} 
		PyErr_SetFromErrno(ResourceError);
		return NULL;
	}

76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104
	result = PyStructSequence_New(&StructRUsageType);
	if (!result)
		return NULL;

	PyStructSequence_SET_ITEM(result, 0,
			PyFloat_FromDouble(doubletime(ru.ru_utime)));
	PyStructSequence_SET_ITEM(result, 1,
			PyFloat_FromDouble(doubletime(ru.ru_stime)));
	PyStructSequence_SET_ITEM(result, 2, PyInt_FromLong(ru.ru_maxrss));
	PyStructSequence_SET_ITEM(result, 3, PyInt_FromLong(ru.ru_ixrss));
	PyStructSequence_SET_ITEM(result, 4, PyInt_FromLong(ru.ru_idrss));
	PyStructSequence_SET_ITEM(result, 5, PyInt_FromLong(ru.ru_isrss));
	PyStructSequence_SET_ITEM(result, 6, PyInt_FromLong(ru.ru_minflt));
	PyStructSequence_SET_ITEM(result, 7, PyInt_FromLong(ru.ru_majflt));
	PyStructSequence_SET_ITEM(result, 8, PyInt_FromLong(ru.ru_nswap));
	PyStructSequence_SET_ITEM(result, 9, PyInt_FromLong(ru.ru_inblock));
	PyStructSequence_SET_ITEM(result, 10, PyInt_FromLong(ru.ru_oublock));
	PyStructSequence_SET_ITEM(result, 11, PyInt_FromLong(ru.ru_msgsnd));
	PyStructSequence_SET_ITEM(result, 12, PyInt_FromLong(ru.ru_msgrcv));
	PyStructSequence_SET_ITEM(result, 13, PyInt_FromLong(ru.ru_nsignals));
	PyStructSequence_SET_ITEM(result, 14, PyInt_FromLong(ru.ru_nvcsw));
	PyStructSequence_SET_ITEM(result, 15, PyInt_FromLong(ru.ru_nivcsw));

	if (PyErr_Occurred()) {
		Py_DECREF(result);
		return NULL;
	}

	return result;
105 106 107 108
}


static PyObject *
Peter Schneider-Kamp's avatar
Peter Schneider-Kamp committed
109
resource_getrlimit(PyObject *self, PyObject *args)
110 111 112 113
{
	struct rlimit rl;
	int resource;

114
	if (!PyArg_ParseTuple(args, "i:getrlimit", &resource)) 
115 116 117 118 119 120 121 122 123 124 125 126
		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;
	}
127 128 129 130 131 132 133 134

#if defined(HAVE_LONG_LONG)
	if (sizeof(rl.rlim_cur) > sizeof(long)) {
		return Py_BuildValue("LL",
				     (LONG_LONG) rl.rlim_cur,
				     (LONG_LONG) rl.rlim_max);
	}
#endif
135
	return Py_BuildValue("ll", (long) rl.rlim_cur, (long) rl.rlim_max);
136 137 138
}

static PyObject *
Peter Schneider-Kamp's avatar
Peter Schneider-Kamp committed
139
resource_setrlimit(PyObject *self, PyObject *args)
140 141 142
{
	struct rlimit rl;
	int resource;
143
	PyObject *curobj, *maxobj;
144

145 146
	if (!PyArg_ParseTuple(args, "i(OO):setrlimit", 
			      &resource, &curobj, &maxobj))
147 148 149 150 151 152 153 154
		return NULL;

	if (resource < 0 || resource >= RLIM_NLIMITS) {
		PyErr_SetString(PyExc_ValueError,
				"invalid resource specified");
		return NULL;
	}

155 156
#if !defined(HAVE_LARGEFILE_SUPPORT)
	rl.rlim_cur = PyInt_AsLong(curobj);
157 158
	if (rl.rlim_cur == -1 && PyErr_Occurred())
	    return NULL;
159
	rl.rlim_max = PyInt_AsLong(maxobj);
160 161
	if (rl.rlim_max == -1 && PyErr_Occurred())
	    return NULL;
162 163 164 165
#else
	/* The limits are probably bigger than a long */
	rl.rlim_cur = PyLong_Check(curobj) ?
		PyLong_AsLongLong(curobj) : PyInt_AsLong(curobj);
166 167
	if (rl.rlim_cur == -1 && PyErr_Occurred())
	    return NULL;
168 169
	rl.rlim_max = PyLong_Check(maxobj) ?
		PyLong_AsLongLong(maxobj) : PyInt_AsLong(maxobj);
170 171
	if (rl.rlim_max == -1 && PyErr_Occurred())
	    return NULL;
172 173
#endif

174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
	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 *
Peter Schneider-Kamp's avatar
Peter Schneider-Kamp committed
192
resource_getpagesize(PyObject *self, PyObject *args)
193
{
194
	if (!PyArg_ParseTuple(args, ":getpagesize"))
195 196 197 198 199 200 201 202
		return NULL;
	return Py_BuildValue("i", getpagesize());
}

/* List of functions */

static struct PyMethodDef
resource_methods[] = {
203 204 205 206
	{"getrusage",    resource_getrusage,   METH_VARARGS},
	{"getrlimit",    resource_getrlimit,   METH_VARARGS},
	{"setrlimit",    resource_setrlimit,   METH_VARARGS},
	{"getpagesize",  resource_getpagesize, METH_VARARGS},
207 208 209 210 211 212
	{NULL, NULL}			     /* sentinel */
};


/* Module initialization */

213
PyMODINIT_FUNC
214
initresource(void)
215
{
216
	PyObject *m, *v;
217 218 219 220 221

	/* Create the module and add the functions */
	m = Py_InitModule("resource", resource_methods);

	/* Add some symbolic constants to the module */
222 223 224 225 226 227
	if (ResourceError == NULL) {
		ResourceError = PyErr_NewException("resource.error",
						   NULL, NULL);
	}
	Py_INCREF(ResourceError);
	PyModule_AddObject(m, "error", ResourceError);
228 229 230
 	PyStructSequence_InitType(&StructRUsageType, &struct_rusage_desc);
 	PyModule_AddObject(m, "struct_rusage", 
			   (PyObject*) &StructRUsageType);
231 232 233

	/* insert constants */
#ifdef RLIMIT_CPU
234
	PyModule_AddIntConstant(m, "RLIMIT_CPU", RLIMIT_CPU);
235 236 237
#endif

#ifdef RLIMIT_FSIZE
238
	PyModule_AddIntConstant(m, "RLIMIT_FSIZE", RLIMIT_FSIZE);
239 240 241
#endif

#ifdef RLIMIT_DATA
242
	PyModule_AddIntConstant(m, "RLIMIT_DATA", RLIMIT_DATA);
243 244 245
#endif

#ifdef RLIMIT_STACK
246
	PyModule_AddIntConstant(m, "RLIMIT_STACK", RLIMIT_STACK);
247 248 249
#endif

#ifdef RLIMIT_CORE
250
	PyModule_AddIntConstant(m, "RLIMIT_CORE", RLIMIT_CORE);
251 252 253
#endif

#ifdef RLIMIT_NOFILE
254
	PyModule_AddIntConstant(m, "RLIMIT_NOFILE", RLIMIT_NOFILE);
255 256 257
#endif

#ifdef RLIMIT_OFILE
258
	PyModule_AddIntConstant(m, "RLIMIT_OFILE", RLIMIT_OFILE);
259 260 261
#endif

#ifdef RLIMIT_VMEM
262
	PyModule_AddIntConstant(m, "RLIMIT_VMEM", RLIMIT_VMEM);
263 264 265
#endif

#ifdef RLIMIT_AS
266
	PyModule_AddIntConstant(m, "RLIMIT_AS", RLIMIT_AS);
267 268 269
#endif

#ifdef RLIMIT_RSS
270
	PyModule_AddIntConstant(m, "RLIMIT_RSS", RLIMIT_RSS);
271 272 273
#endif

#ifdef RLIMIT_NPROC
274
	PyModule_AddIntConstant(m, "RLIMIT_NPROC", RLIMIT_NPROC);
275 276 277
#endif

#ifdef RLIMIT_MEMLOCK
278
	PyModule_AddIntConstant(m, "RLIMIT_MEMLOCK", RLIMIT_MEMLOCK);
279 280 281
#endif

#ifdef RUSAGE_SELF
282
	PyModule_AddIntConstant(m, "RUSAGE_SELF", RUSAGE_SELF);
283 284
#endif

285
#ifdef RUSAGE_CHILDREN
286
	PyModule_AddIntConstant(m, "RUSAGE_CHILDREN", RUSAGE_CHILDREN);
287 288 289
#endif

#ifdef RUSAGE_BOTH
290
	PyModule_AddIntConstant(m, "RUSAGE_BOTH", RUSAGE_BOTH);
291
#endif
292 293 294 295 296 297 298 299 300 301 302 303

#if defined(HAVE_LONG_LONG)
	if (sizeof(RLIM_INFINITY) > sizeof(long)) {
		v = PyLong_FromLongLong((LONG_LONG) RLIM_INFINITY);
	} else 
#endif
	{
		v = PyInt_FromLong((long) RLIM_INFINITY);
	}
	if (v) {
		PyModule_AddObject(m, "RLIM_INFINITY", v);
	}
304
}