2 * Copyright (C) 2008 Daniel Hokka Zakrisson
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 * vim:set ts=2 sw=2 expandtab:
24 #include <sys/types.h>
25 #include <sys/socket.h>
26 #include <arpa/inet.h>
35 static inline PyObject *NONE(void)
43 pyvserver_get_version(PyObject UNUSED *self, PyObject UNUSED *args)
45 int ver = vc_get_version();
47 return PyErr_SetFromErrno(PyExc_OSError);
49 return Py_BuildValue("i", ver);
53 pyvserver_get_vci(PyObject UNUSED *self, PyObject UNUSED *args)
55 vc_vci_t vci = vc_get_vci();
56 if (vci == (vc_vci_t)-1)
57 return PyErr_SetFromErrno(PyExc_OSError);
59 return Py_BuildValue("K", vci);
63 pyvserver_ctx_create(PyObject UNUSED *self, PyObject *args)
66 struct vc_ctx_flags flags = { .mask = 0 };
68 if (!PyArg_ParseTuple(args, "I|KK", &xid, &flags.flagword, &flags.mask))
71 if (flags.flagword && !flags.mask)
72 flags.mask = flags.flagword;
74 ret = vc_ctx_create(xid, &flags);
76 return PyErr_SetFromErrno(PyExc_OSError);
78 return Py_BuildValue("I", ret);
82 pyvserver_ctx_migrate(PyObject UNUSED *self, PyObject *args)
87 if (!PyArg_ParseTuple(args, "IK", &xid, &flags))
90 if (vc_ctx_migrate(xid, flags) == -1)
91 return PyErr_SetFromErrno(PyExc_OSError);
97 pyvserver_ctx_stat(PyObject UNUSED *self, PyObject *args)
100 struct vc_ctx_stat stats;
102 if (!PyArg_ParseTuple(args, "I", &xid))
105 if (vc_ctx_stat(xid, &stats) == -1)
106 return PyErr_SetFromErrno(PyExc_OSError);
108 return Py_BuildValue("(II)", stats.usecnt, stats.tasks);
112 pyvserver_virt_stat(PyObject UNUSED *self, PyObject *args)
115 struct vc_virt_stat stats;
117 if (!PyArg_ParseTuple(args, "I", &xid))
120 if (vc_virt_stat(xid, &stats) == -1)
121 return PyErr_SetFromErrno(PyExc_OSError);
123 return Py_BuildValue("(KKIIIII(III))", stats.offset, stats.uptime,
124 stats.nr_threads, stats.nr_running,
125 stats.nr_uninterruptible, stats.nr_onhold,
126 stats.nr_forks, stats.load[0], stats.load[1],
131 pyvserver_ctx_kill(PyObject UNUSED *self, PyObject *args)
137 if (!PyArg_ParseTuple(args, "Iii", &xid, &pid, &signal))
140 if (vc_ctx_kill(xid, pid, signal) == -1)
141 return PyErr_SetFromErrno(PyExc_OSError);
147 pyvserver_get_cflags(PyObject UNUSED *self, PyObject *args)
150 struct vc_ctx_flags flags;
152 if (!PyArg_ParseTuple(args, "I", &xid))
155 if (vc_get_cflags(xid, &flags) == -1)
156 return PyErr_SetFromErrno(PyExc_OSError);
158 return Py_BuildValue("(KK)", flags.flagword, flags.mask);
162 pyvserver_set_cflags(PyObject UNUSED *self, PyObject *args)
165 struct vc_ctx_flags flags;
167 if (!PyArg_ParseTuple(args, "I(KK)", &xid, flags.flagword, flags.mask))
170 if (vc_set_cflags(xid, &flags) == -1)
171 return PyErr_SetFromErrno(PyExc_OSError);
177 pyvserver_get_ccaps(PyObject UNUSED *self, PyObject *args)
180 struct vc_ctx_caps caps;
182 if (!PyArg_ParseTuple(args, "I", &xid))
185 if (vc_get_ccaps(xid, &caps) == -1)
186 return PyErr_SetFromErrno(PyExc_OSError);
188 return Py_BuildValue("(KKKK)", caps.bcaps, caps.bmask, caps.ccaps,
193 pyvserver_set_ccaps(PyObject UNUSED *self, PyObject *args)
196 struct vc_ctx_caps caps;
198 if (!PyArg_ParseTuple(args, "I(KKKK)", &xid, &caps.bcaps, &caps.bmask,
199 &caps.ccaps, &caps.cmask))
202 if (vc_set_ccaps(xid, &caps) == -1)
203 return PyErr_SetFromErrno(PyExc_OSError);
209 pyvserver_get_vx_info(PyObject UNUSED *self, PyObject *args)
212 struct vc_vx_info info;
214 if (!PyArg_ParseTuple(args, "I", &xid))
217 if (vc_get_vx_info(xid, &info) == -1)
218 return PyErr_SetFromErrno(PyExc_OSError);
220 return Py_BuildValue("(Ii)", info.xid, info.initpid);
224 pyvserver_get_task_xid(PyObject UNUSED *self, PyObject *args)
229 if (!PyArg_ParseTuple(args, "i", &pid))
232 xid = vc_get_task_xid(pid);
234 return PyErr_SetFromErrno(PyExc_OSError);
236 return Py_BuildValue("I", xid);
240 pyvserver_wait_exit(PyObject UNUSED *self, PyObject *args)
244 if (!PyArg_ParseTuple(args, "I", &xid))
247 if (vc_wait_exit(xid) == -1)
254 pyvserver_get_rlimit_mask(PyObject UNUSED *self, PyObject *args)
257 struct vc_rlimit_mask mask;
259 if (!PyArg_ParseTuple(args, "I", &xid))
262 if (vc_get_rlimit_mask(xid, &mask) == -1)
263 return PyErr_SetFromErrno(PyExc_OSError);
265 return Py_BuildValue("(III)", mask.min, mask.soft, mask.hard);
269 pyvserver_get_rlimit(PyObject UNUSED *self, PyObject *args)
273 struct vc_rlimit limit = { .min = 0 };
275 if (!PyArg_ParseTuple(args, "Ii", &xid, &resource))
278 if (vc_get_rlimit(xid, resource, &limit) == -1)
279 return PyErr_SetFromErrno(PyExc_OSError);
281 return Py_BuildValue("(LLL)", limit.min, limit.soft, limit.hard);
285 pyvserver_set_rlimit(PyObject UNUSED *self, PyObject *args)
289 struct vc_rlimit limit = {
295 if (!PyArg_ParseTuple(args, "Ii(KKK)", &xid, &resource, &limit.min,
296 &limit.soft, &limit.hard))
299 if (vc_set_rlimit(xid, resource, &limit) == -1)
300 return PyErr_SetFromErrno(PyExc_OSError);
306 pyvserver_rlimit_stat(PyObject UNUSED *self, PyObject *args)
310 struct vc_rlimit_stat stats;
312 if (!PyArg_ParseTuple(args, "Ii", &xid, &resource))
315 if (vc_rlimit_stat(xid, resource, &stats) == -1)
316 return PyErr_SetFromErrno(PyExc_OSError);
318 return Py_BuildValue("(IKKK)", stats.hits, stats.value, stats.minimum,
323 pyvserver_reset_minmax(PyObject UNUSED *self, PyObject *args)
327 if (!PyArg_ParseTuple(args, "I", &xid))
330 if (vc_reset_minmax(xid) == -1)
331 return PyErr_SetFromErrno(PyExc_OSError);
337 pyvserver_get_task_nid(PyObject UNUSED *self, PyObject *args)
342 if (!PyArg_ParseTuple(args, "i", &pid))
345 nid = vc_get_task_nid(pid);
347 return PyErr_SetFromErrno(PyExc_OSError);
349 return Py_BuildValue("I", nid);
353 pyvserver_get_nx_info(PyObject UNUSED *self, PyObject *args)
356 struct vc_nx_info info;
358 if (!PyArg_ParseTuple(args, "I", &nid))
361 if (vc_get_nx_info(nid, &info) == -1)
362 return PyErr_SetFromErrno(PyExc_OSError);
364 return Py_BuildValue("(I)", info.nid);
368 pyvserver_net_create(PyObject UNUSED *self, PyObject *args)
372 if (!PyArg_ParseTuple(args, "I", &nid))
375 ret = vc_net_create(nid);
377 return PyErr_SetFromErrno(PyExc_OSError);
379 return Py_BuildValue("I", ret);
383 pyvserver_net_migrate(PyObject UNUSED *self, PyObject *args)
387 if (!PyArg_ParseTuple(args, "I", &nid))
390 if (vc_net_migrate(nid) == -1)
391 return PyErr_SetFromErrno(PyExc_OSError);
397 pyvserver_net_handle(PyObject UNUSED *self, PyObject *args,
398 int (*func)(nid_t nid, struct vc_net_addr const *addr))
401 struct vc_net_addr addr;
402 char *ip1, *ip2, *mask;
404 if (!PyArg_ParseTuple(args, "I(HHHHsss)", &nid, &addr.vna_type,
405 &addr.vna_flags, &addr.vna_prefix, &addr.vna_parent,
409 if (addr.vna_type & VC_NXA_TYPE_IPV6) {
410 if (inet_pton(AF_INET6, ip1, &addr.vna_v6_ip) <= 0 ||
411 inet_pton(AF_INET6, ip2, &addr.vna_v6_ip2) <= 0 ||
412 inet_pton(AF_INET6, mask, &addr.vna_v6_mask) <= 0) {
413 PyErr_SetString(PyExc_ValueError, "invalid IPv6 addresses");
417 else if (addr.vna_type & VC_NXA_TYPE_IPV4) {
418 if (inet_pton(AF_INET, ip1, &addr.vna_v4_ip) <= 0 ||
419 inet_pton(AF_INET, ip2, &addr.vna_v4_ip2) <= 0 ||
420 inet_pton(AF_INET, mask, &addr.vna_v4_mask) <= 0) {
421 PyErr_SetString(PyExc_ValueError, "invalid IPv4 addresses");
425 else if (addr.vna_type != VC_NXA_TYPE_ANY) {
426 PyErr_SetString(PyExc_ValueError, "type");
430 if (func(nid, &addr) == -1)
431 return PyErr_SetFromErrno(PyExc_OSError);
437 pyvserver_net_add(PyObject UNUSED *self, PyObject *args)
439 return pyvserver_net_handle(self, args, vc_net_add);
443 pyvserver_net_remove(PyObject UNUSED *self, PyObject *args)
445 return pyvserver_net_handle(self, args, vc_net_remove);
449 pyvserver_get_nflags(PyObject UNUSED *self, PyObject *args)
452 struct vc_net_flags flags;
454 if (!PyArg_ParseTuple(args, "I", &nid))
457 if (vc_get_nflags(nid, &flags) == -1)
458 return PyErr_SetFromErrno(PyExc_OSError);
460 return Py_BuildValue("(KK)", flags.flagword, flags.mask);
464 pyvserver_set_nflags(PyObject UNUSED *self, PyObject *args)
467 struct vc_net_flags flags;
469 if (!PyArg_ParseTuple(args, "I(KK)", &nid, &flags.flagword, &flags.mask))
472 if (vc_set_nflags(nid, &flags) == -1)
473 return PyErr_SetFromErrno(PyExc_OSError);
479 pyvserver_get_ncaps(PyObject UNUSED *self, PyObject *args)
482 struct vc_net_caps caps;
484 if (!PyArg_ParseTuple(args, "I", &nid))
487 if (vc_get_ncaps(nid, &caps) == -1)
488 return PyErr_SetFromErrno(PyExc_OSError);
490 return Py_BuildValue("(KK)", caps.ncaps, caps.cmask);
494 pyvserver_set_ncaps(PyObject UNUSED *self, PyObject *args)
497 struct vc_net_caps caps;
499 if (!PyArg_ParseTuple(args, "I(KK)", &nid, &caps.ncaps, &caps.cmask))
502 if (vc_set_ncaps(nid, &caps) == -1)
503 return PyErr_SetFromErrno(PyExc_OSError);
509 pyvserver_set_iattr(PyObject UNUSED *self, PyObject *args)
511 char const *filename;
513 uint_least32_t flags, mask;
515 if (!PyArg_ParseTuple(args, "sIII", &filename, &tag, &flags, &mask))
518 if (vc_set_iattr(filename, tag, flags, mask) == -1)
519 return PyErr_SetFromErrno(PyExc_OSError);
525 pyvserver_fset_iattr(PyObject UNUSED *self, PyObject *args)
529 uint_least32_t flags, mask;
531 if (!PyArg_ParseTuple(args, "iIII", &fd, &tag, &flags, &mask))
534 if (vc_fset_iattr(fd, tag, flags, mask) == -1)
535 return PyErr_SetFromErrno(PyExc_OSError);
541 pyvserver_get_iattr(PyObject UNUSED *self, PyObject *args)
543 char const *filename;
545 uint_least32_t flags, mask;
547 if (!PyArg_ParseTuple(args, "sI", &filename, &mask))
550 if (vc_get_iattr(filename, &tag, &flags, &mask) == -1)
551 return PyErr_SetFromErrno(PyExc_OSError);
553 return Py_BuildValue("(III)", tag, flags, mask);
557 pyvserver_fget_iattr(PyObject UNUSED *self, PyObject *args)
561 uint_least32_t flags, mask;
563 if (!PyArg_ParseTuple(args, "iI", &fd, &mask))
566 if (vc_fget_iattr(fd, &tag, &flags, &mask) == -1)
567 return PyErr_SetFromErrno(PyExc_OSError);
569 return Py_BuildValue("(III)", tag, flags, mask);
573 pyvserver_set_vhi_name(PyObject UNUSED *self, PyObject *args)
580 if (!PyArg_ParseTuple(args, "Iis#", &xid, &type, &val, &len))
583 if (vc_set_vhi_name(xid, type, val, len) == -1)
584 return PyErr_SetFromErrno(PyExc_OSError);
590 pyvserver_get_vhi_name(PyObject UNUSED *self, PyObject *args)
596 if (!PyArg_ParseTuple(args, "Ii", &xid, &type))
599 if (vc_get_vhi_name(xid, type, val, sizeof(val)) == -1)
600 return PyErr_SetFromErrno(PyExc_OSError);
602 return Py_BuildValue("s#", val, sizeof(val));
606 pyvserver_enter_namespace(PyObject UNUSED *self, PyObject *args)
612 if (!PyArg_ParseTuple(args, "IKI", &xid, &mask, &index))
615 if (vc_enter_namespace(xid, mask, index) == -1)
616 return PyErr_SetFromErrno(PyExc_OSError);
622 pyvserver_set_namespace(PyObject UNUSED *self, PyObject *args)
628 if (!PyArg_ParseTuple(args, "IKI", &xid, &mask, &index))
631 if (vc_set_namespace(xid, mask, index) == -1)
632 return PyErr_SetFromErrno(PyExc_OSError);
638 pyvserver_get_space_mask(PyObject UNUSED *self, PyObject UNUSED *args)
640 uint_least64_t mask = vc_get_space_mask();
641 return Py_BuildValue("K", mask);
645 pyvserver_get_space_default(PyObject UNUSED *self, PyObject UNUSED *args)
647 uint_least64_t mask = vc_get_space_default();
648 return Py_BuildValue("K", mask);
652 pyvserver_add_dlimit(PyObject UNUSED *self, PyObject *args)
654 char const *filename;
656 uint_least32_t flags;
658 if (!PyArg_ParseTuple(args, "sII", &filename, &tag, &flags))
661 if (vc_add_dlimit(filename, tag, flags) == -1)
662 return PyErr_SetFromErrno(PyExc_OSError);
668 pyvserver_rem_dlimit(PyObject UNUSED *self, PyObject *args)
670 char const *filename;
672 uint_least32_t flags;
674 if (!PyArg_ParseTuple(args, "sII", &filename, &tag, &flags))
677 if (vc_rem_dlimit(filename, tag, flags) == -1)
678 return PyErr_SetFromErrno(PyExc_OSError);
684 pyvserver_set_dlimit(PyObject UNUSED *self, PyObject *args)
686 char const *filename;
688 uint_least32_t flags;
689 struct vc_ctx_dlimit limit;
691 if (!PyArg_ParseTuple(args, "sII(IIIII)", &filename, &tag, &flags,
692 &limit.space_used, &limit.space_total,
693 &limit.inodes_used, &limit.inodes_total,
697 if (vc_set_dlimit(filename, tag, flags, &limit) == -1)
698 return PyErr_SetFromErrno(PyExc_OSError);
704 pyvserver_get_dlimit(PyObject UNUSED *self, PyObject *args)
706 char const *filename;
708 uint_least32_t flags;
709 struct vc_ctx_dlimit limit;
711 if (!PyArg_ParseTuple(args, "sII", &filename, &tag, &flags))
714 if (vc_get_dlimit(filename, tag, flags, &limit) == -1)
715 return PyErr_SetFromErrno(PyExc_OSError);
717 return Py_BuildValue("(IIIII)", limit.space_used, limit.space_total,
718 limit.inodes_used, limit.inodes_total, limit.reserved);
722 pyvserver_get_task_tag(PyObject UNUSED *self, PyObject *args)
727 if (!PyArg_ParseTuple(args, "i", &pid))
730 tag = vc_get_task_tag(pid);
731 if (tag == (tag_t) -1)
732 return PyErr_SetFromErrno(PyExc_OSError);
734 return Py_BuildValue("I", tag);
738 pyvserver_tag_create(PyObject UNUSED *self, PyObject *args)
742 if (!PyArg_ParseTuple(args, "I", &tag))
745 if (vc_tag_create(tag) == -1)
746 return PyErr_SetFromErrno(PyExc_OSError);
752 pyvserver_tag_migrate(PyObject UNUSED *self, PyObject *args)
756 if (!PyArg_ParseTuple(args, "I", &tag))
759 if (vc_tag_migrate(tag) == -1)
760 return PyErr_SetFromErrno(PyExc_OSError);
766 pyvserver_set_sched(PyObject UNUSED *self, PyObject *args)
769 struct vc_set_sched sched;
771 if (!PyArg_ParseTuple(args, "I(Iiiiiiiiiii)", &xid, &sched.set_mask,
772 &sched.fill_rate, &sched.interval, &sched.fill_rate2,
773 &sched.interval2, &sched.tokens, &sched.tokens_min,
774 &sched.tokens_max, &sched.priority_bias, &sched.cpu_id,
778 if (vc_set_sched(xid, &sched) == -1)
779 return PyErr_SetFromErrno(PyExc_OSError);
785 pyvserver_get_sched(PyObject UNUSED *self, PyObject *args)
788 struct vc_set_sched sched;
790 if (!PyArg_ParseTuple(args, "Iii", &xid, &sched.cpu_id, &sched.bucket_id))
793 if (vc_get_sched(xid, &sched) == -1)
794 return PyErr_SetFromErrno(PyExc_OSError);
796 return Py_BuildValue("(Iiiiiiiiiii)", sched.set_mask, sched.fill_rate,
797 sched.interval, sched.fill_rate2, sched.interval2,
798 sched.tokens, sched.tokens_min, sched.tokens_max,
799 sched.priority_bias, sched.cpu_id, sched.bucket_id);
803 pyvserver_sched_info(PyObject UNUSED *self, PyObject *args)
806 struct vc_sched_info info;
808 if (!PyArg_ParseTuple(args, "Iii", &xid, &info.cpu_id, &info.bucket_id))
811 if (vc_sched_info(xid, &info) == -1)
812 return PyErr_SetFromErrno(PyExc_OSError);
814 return Py_BuildValue("(iiKKKIi)", info.cpu_id, info.bucket_id,
815 info.user_msec, info.sys_msec, info.hold_msec,
816 info.token_usec, info.vavavoom);
820 pyvserver_set_mapping(PyObject UNUSED *self, PyObject *args)
823 const char *device, *target;
826 if (!PyArg_ParseTuple(args, "IssI", &xid, &device, &target, &flags))
829 if (vc_set_mapping(xid, device, target, flags) == -1)
830 return PyErr_SetFromErrno(PyExc_OSError);
836 pyvserver_unset_mapping(PyObject UNUSED *self, PyObject *args)
839 const char *device, *target;
842 if (!PyArg_ParseTuple(args, "IssI", &xid, &device, &target, &flags))
845 if (vc_unset_mapping(xid, device, target, flags) == -1)
846 return PyErr_SetFromErrno(PyExc_OSError);
852 pyvserver_get_badness(PyObject UNUSED *self, PyObject *args)
857 if (!PyArg_ParseTuple(args, "I", &xid))
860 if (vc_get_badness(xid, &badness) == -1)
861 return PyErr_SetFromErrno(PyExc_OSError);
863 return Py_BuildValue("L", badness);
867 pyvserver_set_badness(PyObject UNUSED *self, PyObject *args)
872 if (!PyArg_ParseTuple(args, "IL", &xid, &badness))
875 if (vc_set_badness(xid, badness) == -1)
876 return PyErr_SetFromErrno(PyExc_OSError);
882 pyvserver_get_insecurebcaps(PyObject UNUSED *self, PyObject UNUSED *args)
884 uint_least64_t bcaps = vc_get_insecurebcaps();
885 return Py_BuildValue("K", bcaps);
889 pyvserver_get_insecureccaps(PyObject UNUSED *self, PyObject UNUSED *args)
891 uint_least64_t ccaps = vc_get_insecureccaps();
892 return Py_BuildValue("K", ccaps);
896 pyvserver_isSupported(PyObject UNUSED *self, PyObject *args)
900 if (!PyArg_ParseTuple(args, "i", &feature))
903 if (vc_isSupported(feature))
910 pyvserver_isSupportedString(PyObject UNUSED *self, PyObject *args)
914 if (!PyArg_ParseTuple(args, "s", &feature))
917 if (vc_isSupportedString(feature))
924 pyvserver_getXIDType(PyObject UNUSED *self, PyObject *args)
928 if (!PyArg_ParseTuple(args, "I", &xid))
931 return Py_BuildValue("i", vc_getXIDType(xid));
935 pyvserver_xidopt2xid(PyObject UNUSED *self, PyObject *args)
938 PyObject *honor_static;
940 char const *err_info;
942 if (!PyArg_ParseTuple(args, "sO", &xidopt, &honor_static))
945 xid = vc_xidopt2xid(xidopt, honor_static != Py_False, &err_info);
946 if (xid == VC_NOXID) {
947 PyErr_SetString(PyExc_OSError, err_info);
951 return Py_BuildValue("I", xid);
955 pyvserver_nidopt2nid(PyObject UNUSED *self, PyObject *args)
958 PyObject *honor_static;
960 char const *err_info;
962 if (!PyArg_ParseTuple(args, "sO", &nidopt, &honor_static))
965 nid = vc_nidopt2nid(nidopt, honor_static != Py_False, &err_info);
966 if (nid == VC_NONID) {
967 PyErr_SetString(PyExc_OSError, err_info);
971 return Py_BuildValue("I", nid);
975 pyvserver_tagopt2tag(PyObject UNUSED *self, PyObject *args)
978 PyObject *honor_static;
980 char const *err_info;
982 if (!PyArg_ParseTuple(args, "sO", &tagopt, &honor_static))
985 tag = vc_tagopt2tag(tagopt, honor_static != Py_False, &err_info);
986 if (tag == (tag_t) -1) {
987 PyErr_SetString(PyExc_OSError, err_info);
991 return Py_BuildValue("I", tag);
994 #define pyvserver_handle_list(name, list_type, flag_member, mask_member) \
996 pyvserver_text2 ## name(PyObject UNUSED *self, PyObject *args) \
1000 uint_least64_t val; \
1002 if (!PyArg_ParseTuple(args, "s#", &str, &len)) \
1005 val = vc_text2 ## name(str, len); \
1006 return Py_BuildValue("K", val); \
1010 pyvserver_lo ## name ## 2text(PyObject UNUSED *self, PyObject *args) \
1012 uint_least64_t val; \
1015 if (!PyArg_ParseTuple(args, "K", &val)) \
1018 ret = vc_lo ## name ## 2text(&val); \
1019 return Py_BuildValue("(Kz)", val, ret); \
1023 pyvserver_list2 ## name(PyObject UNUSED *self, PyObject *args) \
1027 struct vc_err_listparser err; \
1030 if (!PyArg_ParseTuple(args, "s#", &str, &len)) \
1033 if (vc_list2 ## name(str, len, &err, &val) == -1) { \
1035 if (asprintf(&error, "unknown value '%.*s'", (int)err.len, err.ptr) == -1) \
1036 return PyErr_SetFromErrno(PyExc_MemoryError); \
1037 PyErr_SetString(PyExc_ValueError, error); \
1042 return Py_BuildValue("(KK)", val.flag_member, val.mask_member); \
1045 pyvserver_handle_list(bcap, struct vc_ctx_caps, bcaps, bmask)
1046 pyvserver_handle_list(ccap, struct vc_ctx_caps, ccaps, cmask)
1047 pyvserver_handle_list(cflag, struct vc_ctx_flags, flagword, mask)
1048 pyvserver_handle_list(nflag, struct vc_net_flags, flagword, mask)
1049 pyvserver_handle_list(ncap, struct vc_net_caps, ncaps, cmask)
1051 static PyMethodDef methods[] = {
1052 { "vc_get_version", pyvserver_get_version, METH_NOARGS, "FIXME" },
1053 { "vc_get_vci", pyvserver_get_vci, METH_NOARGS, "FIXME" },
1054 { "vc_ctx_create", pyvserver_ctx_create, METH_VARARGS, "FIXME" },
1055 { "vc_ctx_migrate", pyvserver_ctx_migrate, METH_VARARGS, "FIXME" },
1056 { "vc_ctx_stat", pyvserver_ctx_stat, METH_VARARGS, "FIXME" },
1057 { "vc_virt_stat", pyvserver_virt_stat, METH_VARARGS, "FIXME" },
1058 { "vc_ctx_kill", pyvserver_ctx_kill, METH_VARARGS, "FIXME" },
1059 { "vc_get_cflags", pyvserver_get_cflags, METH_VARARGS, "FIXME" },
1060 { "vc_set_cflags", pyvserver_set_cflags, METH_VARARGS, "FIXME" },
1061 { "vc_get_ccaps", pyvserver_get_ccaps, METH_VARARGS, "FIXME" },
1062 { "vc_set_ccaps", pyvserver_set_ccaps, METH_VARARGS, "FIXME" },
1063 { "vc_get_vx_info", pyvserver_get_vx_info, METH_VARARGS, "FIXME" },
1064 { "vc_get_task_xid", pyvserver_get_task_xid, METH_VARARGS, "FIXME" },
1065 { "vc_wait_exit", pyvserver_wait_exit, METH_VARARGS, "FIXME" },
1066 { "vc_get_rlimit_mask", pyvserver_get_rlimit_mask, METH_VARARGS, "FIXME" },
1067 { "vc_get_rlimit", pyvserver_get_rlimit, METH_VARARGS, "FIXME" },
1068 { "vc_set_rlimit", pyvserver_set_rlimit, METH_VARARGS, "FIXME" },
1069 { "vc_rlimit_stat", pyvserver_rlimit_stat, METH_VARARGS, "FIXME" },
1070 { "vc_reset_minmax", pyvserver_reset_minmax, METH_VARARGS, "FIXME" },
1071 { "vc_get_task_nid", pyvserver_get_task_nid, METH_VARARGS, "FIXME" },
1072 { "vc_get_nx_info", pyvserver_get_nx_info, METH_VARARGS, "FIXME" },
1073 { "vc_net_create", pyvserver_net_create, METH_VARARGS, "FIXME" },
1074 { "vc_net_migrate", pyvserver_net_migrate, METH_VARARGS, "FIXME" },
1075 { "vc_net_add", pyvserver_net_add, METH_VARARGS, "FIXME" },
1076 { "vc_net_remove", pyvserver_net_remove, METH_VARARGS, "FIXME" },
1077 { "vc_get_nflags", pyvserver_get_nflags, METH_VARARGS, "FIXME" },
1078 { "vc_set_nflags", pyvserver_set_nflags, METH_VARARGS, "FIXME" },
1079 { "vc_get_ncaps", pyvserver_get_ncaps, METH_VARARGS, "FIXME" },
1080 { "vc_set_ncaps", pyvserver_set_ncaps, METH_VARARGS, "FIXME" },
1081 { "vc_set_iattr", pyvserver_set_iattr, METH_VARARGS, "FIXME" },
1082 { "vc_fset_iattr", pyvserver_fset_iattr, METH_VARARGS, "FIXME" },
1083 { "vc_get_iattr", pyvserver_get_iattr, METH_VARARGS, "FIXME" },
1084 { "vc_fget_iattr", pyvserver_fget_iattr, METH_VARARGS, "FIXME" },
1085 { "vc_set_vhi_name", pyvserver_set_vhi_name, METH_VARARGS, "FIXME" },
1086 { "vc_get_vhi_name", pyvserver_get_vhi_name, METH_VARARGS, "FIXME" },
1087 { "vc_enter_namespace", pyvserver_enter_namespace, METH_VARARGS, "FIXME" },
1088 { "vc_set_namespace", pyvserver_set_namespace, METH_VARARGS, "FIXME" },
1089 { "vc_get_space_mask", pyvserver_get_space_mask, METH_NOARGS, "FIXME" },
1090 { "vc_get_space_default", pyvserver_get_space_default, METH_NOARGS, "FIXME" },
1091 { "vc_add_dlimit", pyvserver_add_dlimit, METH_VARARGS, "FIXME" },
1092 { "vc_rem_dlimit", pyvserver_rem_dlimit, METH_VARARGS, "FIXME" },
1093 { "vc_set_dlimit", pyvserver_set_dlimit, METH_VARARGS, "FIXME" },
1094 { "vc_get_dlimit", pyvserver_get_dlimit, METH_VARARGS, "FIXME" },
1095 { "vc_get_task_tag", pyvserver_get_task_tag, METH_VARARGS, "FIXME" },
1096 { "vc_tag_create", pyvserver_tag_create, METH_VARARGS, "FIXME" },
1097 { "vc_tag_migrate", pyvserver_tag_migrate, METH_VARARGS, "FIXME" },
1098 { "vc_set_sched", pyvserver_set_sched, METH_VARARGS, "FIXME" },
1099 { "vc_get_sched", pyvserver_get_sched, METH_VARARGS, "FIXME" },
1100 { "vc_sched_info", pyvserver_sched_info, METH_VARARGS, "FIXME" },
1101 { "vc_set_mapping", pyvserver_set_mapping, METH_VARARGS, "FIXME" },
1102 { "vc_unset_mapping", pyvserver_unset_mapping, METH_VARARGS, "FIXME" },
1103 { "vc_get_badness", pyvserver_get_badness, METH_VARARGS, "FIXME" },
1104 { "vc_set_badness", pyvserver_set_badness, METH_VARARGS, "FIXME" },
1105 { "vc_get_insecurebcaps", pyvserver_get_insecurebcaps, METH_NOARGS, "FIXME" },
1106 { "vc_get_insecureccaps", pyvserver_get_insecureccaps, METH_NOARGS, "FIXME" },
1107 { "vc_isSupported", pyvserver_isSupported, METH_VARARGS, "FIXME" },
1108 { "vc_isSupportedString", pyvserver_isSupportedString, METH_VARARGS, "FIXME" },
1109 { "vc_getXIDType", pyvserver_getXIDType, METH_VARARGS, "FIXME" },
1110 { "vc_xidopt2xid", pyvserver_xidopt2xid, METH_VARARGS, "FIXME" },
1111 { "vc_nidopt2nid", pyvserver_nidopt2nid, METH_VARARGS, "FIXME" },
1112 { "vc_tagopt2tag", pyvserver_tagopt2tag, METH_VARARGS, "FIXME" },
1113 { "vc_text2bcap", pyvserver_text2bcap, METH_VARARGS, "FIXME" },
1114 { "vc_lobcap2text", pyvserver_lobcap2text, METH_VARARGS, "FIXME" },
1115 { "vc_list2bcap", pyvserver_list2bcap, METH_VARARGS, "FIXME" },
1116 { "vc_text2ccap", pyvserver_text2ccap, METH_VARARGS, "FIXME" },
1117 { "vc_loccap2text", pyvserver_loccap2text, METH_VARARGS, "FIXME" },
1118 { "vc_list2ccap", pyvserver_list2ccap, METH_VARARGS, "FIXME" },
1119 { "vc_text2cflag", pyvserver_text2cflag, METH_VARARGS, "FIXME" },
1120 { "vc_locflag2text", pyvserver_locflag2text, METH_VARARGS, "FIXME" },
1121 { "vc_list2cflag", pyvserver_list2cflag, METH_VARARGS, "FIXME" },
1122 { "vc_text2nflag", pyvserver_text2nflag, METH_VARARGS, "FIXME" },
1123 { "vc_lonflag2text", pyvserver_lonflag2text, METH_VARARGS, "FIXME" },
1124 { "vc_list2nflag", pyvserver_list2nflag, METH_VARARGS, "FIXME" },
1125 { "vc_text2ncap", pyvserver_text2ncap, METH_VARARGS, "FIXME" },
1126 { "vc_loncap2text", pyvserver_loncap2text, METH_VARARGS, "FIXME" },
1127 { "vc_list2ncap", pyvserver_list2ncap, METH_VARARGS, "FIXME" },
1128 { NULL, NULL, 0, NULL }
1132 PyModule_AddLongLongConstant(PyObject *mod, const char *str, long long val)
1134 PyObject *o = PyLong_FromLongLong(val);
1135 if (!o || PyModule_AddObject(mod, str, o) == -1)
1136 /* This ought to be reported somehow... */
1140 PyMODINIT_FUNC init_libvserver(void)
1144 mod = Py_InitModule("_libvserver", methods);
1145 #include "_libvserver-constants.c"