X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=python%2Fvserverimpl.c;h=cc500e3a32d71b295c3560ddf538de044af1f5e6;hb=1ebbdce8199d983100040664c6d9171a568b6280;hp=ad58d487141aabc40d3d7c505febf13b683c9352;hpb=4fcf6f41a9e748a046fee6b6d7d97d7f96c7cb1b;p=util-vserver.git diff --git a/python/vserverimpl.c b/python/vserverimpl.c index ad58d48..cc500e3 100644 --- a/python/vserverimpl.c +++ b/python/vserverimpl.c @@ -53,21 +53,145 @@ POSSIBILITY OF SUCH DAMAGE. #include "virtual.h" /* - * chcontext + * context create */ static PyObject * -vserver_chcontext(PyObject *self, PyObject *args) +vserver_create(PyObject *self, PyObject *args) { - unsigned xid; - unsigned caps_remove = 0; + xid_t ctx, xid; - if (!PyArg_ParseTuple(args, "I|I", &xid, &caps_remove)) - return NULL; + if (!PyArg_ParseTuple(args, "I", &ctx)) + return NULL; - if (vc_new_s_context(xid, caps_remove, 0) < 0) - return PyErr_SetFromErrno(PyExc_OSError); + xid = vc_ctx_create(ctx); +#ifdef MEF_DEBUG + printf("vserver_create xid = %d\n",xid); +#endif + if (xid == VC_NOCTX && errno != EEXIST) + return PyErr_SetFromErrno(PyExc_OSError); + return Py_None; +} - return Py_None; +/* + * set flags + */ +static PyObject * +vserver_flags(PyObject *self, PyObject *args) +{ + struct vc_ctx_caps caps; + struct vc_ctx_flags flags; +#ifdef MEF_DEBUG + xid_t xid; +#endif + xid_t ctx; + + caps.ccaps = ~vc_get_insecureccaps(); + caps.cmask = ~0ull; + caps.bcaps = ~vc_get_insecurebcaps(); + caps.bmask = ~0ull; + + flags.flagword = VC_VXF_STATE_SETUP| VC_VXF_INFO_LOCK; + flags.mask = VC_VXF_STATE_SETUP | VC_VXF_INFO_LOCK; + + if (!PyArg_ParseTuple(args, "I", &ctx)) + return NULL; + +#ifdef MEF_DEBUG + xid = vc_get_task_xid(0); + printf("vserver_flags xid = %d, ctx = %d\n",xid,ctx); +#endif + + if (vc_set_ccaps(ctx, &caps) == -1) + return PyErr_SetFromErrno(PyExc_OSError); + +#ifdef MEF_DEBUG + xid = vc_get_task_xid(0); + printf("vserver_flags xid = %d, ctx = %d\n",xid,ctx); +#endif + + if (vc_set_cflags(ctx, &flags) == -1) + return PyErr_SetFromErrno(PyExc_OSError); + +#ifdef MEF_DEBUG + xid = vc_get_task_xid(0); + printf("vserver_flags xid = %d, ctx = %d\n",xid,ctx); +#endif + + + return Py_None; +} + +/* + * enter + */ +static PyObject * +vserver_enter(PyObject *self, PyObject *args) +{ + xid_t ctx, xid; + if (!PyArg_ParseTuple(args, "I", &ctx)) + return NULL; + + xid = vc_get_task_xid(0); +#ifdef MEF_DEBUG + printf("vserver_enter xid = %d\n",xid); +#endif + if (xid != ctx) { + if (xid!=0) { + errno=EPERM; + return PyErr_SetFromErrno(PyExc_OSError); + } else if (vc_ctx_migrate(ctx) == -1) + return PyErr_SetFromErrno(PyExc_OSError); + } + + return Py_None; +} + +static PyObject * +vserver_set_rlimit(PyObject *self, PyObject *args) { + struct vc_rlimit limits; + xid_t xid; + int resource; + PyObject *ret; + + limits.min = VC_LIM_KEEP; + limits.soft = VC_LIM_KEEP; + limits.hard = VC_LIM_KEEP; + + if (!PyArg_ParseTuple(args, "IiL", &xid, &resource, &limits.hard)) + return NULL; + + ret = Py_None; + if (vc_set_rlimit(xid, resource, &limits)) + ret = PyErr_SetFromErrno(PyExc_OSError); + else if (vc_get_rlimit(xid, resource, &limits)==-1) + ret = PyErr_SetFromErrno(PyExc_OSError); + else + ret = Py_BuildValue("L",limits.hard); + + return ret; +} + +static PyObject * +vserver_get_rlimit(PyObject *self, PyObject *args) { + struct vc_rlimit limits; + xid_t xid; + int resource; + PyObject *ret; + + limits.min = VC_LIM_KEEP; + limits.soft = VC_LIM_KEEP; + limits.hard = VC_LIM_KEEP; + + if (!PyArg_ParseTuple(args, "Ii", &xid, &resource)) + return NULL; + + ret = Py_None; + if (vc_get_rlimit(xid, resource, &limits)==-1) + ret = PyErr_SetFromErrno(PyExc_OSError); + else + ret = Py_BuildValue("L",limits.hard); + + return ret; } /* @@ -76,23 +200,40 @@ vserver_chcontext(PyObject *self, PyObject *args) static PyObject * vserver_setsched(PyObject *self, PyObject *args) { - unsigned xid; + xid_t xid; struct vc_set_sched sched; + struct vc_ctx_flags flags; + unsigned cpuguaranteed = 0; sched.set_mask = (VC_VXSM_FILL_RATE | VC_VXSM_INTERVAL | VC_VXSM_TOKENS_MIN | VC_VXSM_TOKENS_MAX); - if (!PyArg_ParseTuple(args, "I|I|I|I|I", &xid, + if (!PyArg_ParseTuple(args, "I|I|I|I|I|I|I", &xid, &sched.fill_rate, &sched.interval, + &sched.tokens, &sched.tokens_min, - &sched.tokens_max)) + &sched.tokens_max, + &cpuguaranteed)) return NULL; + flags.flagword = VC_VXF_INFO_LOCK; + flags.mask = VC_VXF_INFO_LOCK; + flags.flagword |= VC_VXF_SCHED_HARD; + flags.mask |= VC_VXF_SCHED_HARD; +#define VC_VXF_SCHED_SHARE 0x00000800ull + if (cpuguaranteed==0) { + flags.flagword |= VC_VXF_SCHED_SHARE; + flags.mask |= VC_VXF_SCHED_SHARE; + } + + if (vc_set_cflags(xid, &flags) == -1) + return PyErr_SetFromErrno(PyExc_OSError); + if (vc_set_sched(xid, &sched) == -1) - return PyErr_SetFromErrno(PyExc_OSError); + return PyErr_SetFromErrno(PyExc_OSError); return Py_None; } @@ -107,29 +248,44 @@ vserver_setsched(PyObject *self, PyObject *args) #define VCMD_set_dlimit VC_CMD(DLIMIT, 5, 0) #define VCMD_get_dlimit VC_CMD(DLIMIT, 6, 0) -struct vcmd_ctx_dlimit_base_v0 { - char *name; - uint32_t flags; -}; - -struct vcmd_ctx_dlimit_v0 { - char *name; - uint32_t space_used; /* used space in kbytes */ - uint32_t space_total; /* maximum space in kbytes */ - uint32_t inodes_used; /* used inodes */ - uint32_t inodes_total; /* maximum inodes */ - uint32_t reserved; /* reserved for root in % */ - uint32_t flags; -}; - #define CDLIM_UNSET (0ULL) #define CDLIM_INFINITY (~0ULL) #define CDLIM_KEEP (~1ULL) static PyObject * -vserver_dlimit(PyObject *self, PyObject *args) +vserver_get_dlimit(PyObject *self, PyObject *args) { PyObject *res; + char* path; + unsigned xid; + struct vcmd_ctx_dlimit_v0 data; + int r; + + if (!PyArg_ParseTuple(args, "si", &path,&xid)) + return NULL; + + memset(&data, 0, sizeof(data)); + data.name = path; + data.flags = 0; + r = vserver(VCMD_get_dlimit, xid, &data); + if (r>=0) { + res = Py_BuildValue("(i,i,i,i,i)", + data.space_used, + data.space_total, + data.inodes_used, + data.inodes_total, + data.reserved); + } else { + res = PyErr_SetFromErrno(PyExc_OSError); + } + + return res; +} + + +static PyObject * +vserver_set_dlimit(PyObject *self, PyObject *args) +{ char* path; unsigned xid; struct vcmd_ctx_dlimit_base_v0 init; @@ -149,6 +305,7 @@ vserver_dlimit(PyObject *self, PyObject *args) data.name = path; data.flags = 0; + memset(&init, 0, sizeof(init)); init.name = path; init.flags = 0; @@ -158,34 +315,26 @@ vserver_dlimit(PyObject *self, PyObject *args) if (r<0){} r = vserver(VCMD_set_dlimit, xid, &data); if (r<0){} - - memset(&data, 0, sizeof(data)); - data.name = path; - data.flags = 0; - r = vserver(VCMD_get_dlimit, xid, &data); - if (r>=0) { - res = Py_BuildValue("(i,i,i,i,i)", - data.space_used, - data.space_total, - data.inodes_used, - data.inodes_total, - data.reserved); - } else { - res = PyErr_SetFromErrno(PyExc_OSError); - } - - return res; + return Py_None; } - - static PyMethodDef methods[] = { - { "chcontext", vserver_chcontext, METH_VARARGS, - "Change to the given vserver context" }, + { "create", vserver_create, METH_VARARGS, + "Create a new vserver context" }, + { "flags", vserver_flags, METH_VARARGS, + "Set the default flags and caps" }, + { "enter", vserver_enter, METH_VARARGS, + "Enter the vserver context" }, { "setsched", vserver_setsched, METH_VARARGS, "Change vserver scheduling attributes for given vserver context" }, - { "dlimit", vserver_dlimit, METH_VARARGS, + { "setdlimit", vserver_set_dlimit, METH_VARARGS, "Set disk limits for given vserver context" }, + { "getdlimit", vserver_get_dlimit, METH_VARARGS, + "Get disk limits for given vserver context" }, + { "setrlimit", vserver_set_rlimit, METH_VARARGS, + "Set resource limits for given resource of a vserver context" }, + { "getrlimit", vserver_get_rlimit, METH_VARARGS, + "Get resource limits for given resource of a vserver context" }, { NULL, NULL, 0, NULL } };