# define VC_ATTR_UNUSED __attribute__((__unused__))
# define VC_ATTR_NORETURN __attribute__((__noreturn__))
# define VC_ATTR_CONST __attribute__((__const__))
+# define VC_ATTR_DEPRECATED __attribute__((__deprecated__))
# if __GNUC__*0x10000 + __GNUC_MINOR__*0x100 + __GNUC_PATCHLEVEL__ >= 0x30300
# define VC_ATTR_NONNULL(ARGS) __attribute__((__nonnull__ ARGS))
# define VC_ATTR_ALWAYSINLINE __attribute__((__always_inline__))
# define VC_ATTR_UNUSED
# define VC_ATTR_NORETURN
# define VC_ATTR_ALWAYSINLINE
+# define VC_ATTR_DEPRECATED
# define VC_ATTR_PURE
# define VC_ATTR_CONST
#endif
/** the value which is returned in error-case (no ctx found) */
#define VC_NOCTX ((xid_t)(-1))
+#define VC_NOXID ((xid_t)(-1))
/** the value which means a random (the next free) ctx */
#define VC_DYNAMIC_XID ((xid_t)(-1))
/** the value which means the current ctx */
#define VC_SAMECTX ((xid_t)(-2))
+#define VC_NONID ((nid_t)(-1))
+#define VC_DYNAMIC_NID ((nid_t)(-1))
+
#define VC_LIM_INFINITY (~0ULL)
#define VC_LIM_KEEP (~1ULL)
#define VC_CAP_LEASE 28
#define VC_CAP_QUOTACTL 29
-#define VC_IMMUTABLE_FILE_FL 0x00000010l
-#define VC_IMMUTABLE_LINK_FL 0x00008000l
+#define VC_IMMUTABLE_FILE_FL 0x0000010lu
+#define VC_IMMUTABLE_LINK_FL 0x0008000lu
#define VC_IMMUTABLE_ALL (VC_IMMUTABLE_LINK_FL|VC_IMMUTABLE_FILE_FL)
-#define VC_IATTR_XID 0x01000000
+#define VC_IATTR_XID 0x01000000u
-#define VC_IATTR_ADMIN 0x00000001
-#define VC_IATTR_WATCH 0x00000002
-#define VC_IATTR_HIDE 0x00000004
-#define VC_IATTR_FLAGS 0x00000007
+#define VC_IATTR_ADMIN 0x00000001u
+#define VC_IATTR_WATCH 0x00000002u
+#define VC_IATTR_HIDE 0x00000004u
+#define VC_IATTR_FLAGS 0x00000007u
-#define VC_IATTR_BARRIER 0x00010000
-#define VC_IATTR_IUNLINK 0x00020000
-#define VC_IATTR_IMMUTABLE 0x00040000
+#define VC_IATTR_BARRIER 0x00010000u
+#define VC_IATTR_IUNLINK 0x00020000u
+#define VC_IATTR_IMMUTABLE 0x00040000u
// the flags
-#define VC_VXF_INFO_LOCK 0x00000001
-#define VC_VXF_INFO_NPROC 0x00000004
-#define VC_VXF_INFO_PRIVATE 0x00000008
-#define VC_VXF_INFO_INIT 0x00000010
+#define VC_VXF_INFO_LOCK 0x00000001ull
+#define VC_VXF_INFO_NPROC 0x00000004ull
+#define VC_VXF_INFO_PRIVATE 0x00000008ull
+#define VC_VXF_INFO_INIT 0x00000010ull
-#define VC_VXF_INFO_HIDEINFO 0x00000020
-#define VC_VXF_INFO_ULIMIT 0x00000040
-#define VC_VXF_INFO_NAMESPACE 0x00000080
+#define VC_VXF_INFO_HIDEINFO 0x00000020ull
+#define VC_VXF_INFO_ULIMIT 0x00000040ull
+#define VC_VXF_INFO_NAMESPACE 0x00000080ull
-#define VC_VXF_SCHED_HARD 0x00000100
-#define VC_VXF_SCHED_PRIO 0x00000200
-#define VC_VXF_SCHED_PAUSE 0x00000400
+#define VC_VXF_SCHED_HARD 0x00000100ull
+#define VC_VXF_SCHED_PRIO 0x00000200ull
+#define VC_VXF_SCHED_PAUSE 0x00000400ull
-#define VC_VXF_VIRT_MEM 0x00010000
-#define VC_VXF_VIRT_UPTIME 0x00020000
-#define VC_VXF_VIRT_CPU 0x00040000
+#define VC_VXF_VIRT_MEM 0x00010000ull
+#define VC_VXF_VIRT_UPTIME 0x00020000ull
+#define VC_VXF_VIRT_CPU 0x00040000ull
+#define VC_VXF_VIRT_LOAD 0x00080000ull
-#define VC_VXF_HIDE_MOUNT 0x01000000
-#define VC_VXF_HIDE_NETIF 0x02000000
+#define VC_VXF_HIDE_MOUNT 0x01000000ull
+#define VC_VXF_HIDE_NETIF 0x02000000ull
#define VC_VXF_STATE_SETUP (1ULL<<32)
#define VC_VXF_STATE_INIT (1ULL<<33)
+#define VC_VXF_FORK_RSS (1ULL<<48)
+#define VC_VXF_PROLIFIC (1ULL<<49)
+
+#define VC_VXF_IGNEG_NICE (1ULL<<52)
+
+
// the ccapabilities
-#define VC_VXC_SET_UTSNAME 0x00000001
-#define VC_VXC_SET_RLIMIT 0x00000002
+#define VC_VXC_SET_UTSNAME 0x00000001ull
+#define VC_VXC_SET_RLIMIT 0x00000002ull
+
+#define VC_VXC_RAW_ICMP 0x00000100ull
-#define VC_VXC_ICMP_PING 0x00000100
+#define VC_VXC_SECURE_MOUNT 0x00010000ull
+#define VC_VXC_SECURE_REMOUNT 0x00020000ull
+
+
+#define VC_VXSM_FILL_RATE 0x0001
+#define VC_VXSM_INTERVAL 0x0002
+#define VC_VXSM_TOKENS 0x0010
+#define VC_VXSM_TOKENS_MIN 0x0020
+#define VC_VXSM_TOKENS_MAX 0x0040
+#define VC_VXSM_PRIO_BIAS 0x0100
-#define VC_VXC_SECURE_MOUNT 0x00010000
/** \defgroup syscalls Syscall wrappers
#ifdef IS_DOXYGEN
typedef an_unsigned_integer_type xid_t;
+typedef an_unsigned_integer_type nid_t;
#endif
#ifdef __cplusplus
#endif
struct vc_ip_mask_pair {
- uint32_t ip;
+ uint32_t ip;
uint32_t mask;
};
+ /** \brief The generic vserver syscall
+ * \ingroup syscalls
+ *
+ * This function executes the generic vserver syscall. It uses the
+ * correct syscallnumber (which may differ between the different
+ * architectures).
+ *
+ * \param cmd the command to be executed
+ * \param xid the xid on which the cmd shall be applied
+ * \param data additional arguments; depends on \c cmd
+ * \returns depends on \c cmd; usually, -1 stands for an error
+ */
+ int vc_syscall(uint32_t cmd, xid_t xid, void *data);
+
/** \brief Returns the version of the current kernel API.
* \ingroup syscalls
* \returns The versionnumber of the kernel API
* \param remove_cap The linux capabilities which will be \b removed.
* \param flags Special flags which will be set.
*
- * \returns The new context-id, or VC_NOCTX on errors; errno
+ * \returns The new context-id, or VC_NOCTX on errors; \c errno
* will be set appropriately
*
* See http://vserver.13thfloor.at/Stuff/Logic.txt for details */
* \param xid The new context; special values are:
* - VC_DYNAMIC_XID which means to create a dynamic context
*
- * \returns the xid of the created context, or VC_NOCTX on errors. errno
+ * \returns the xid of the created context, or VC_NOCTX on errors. \c errno
* will be set appropriately. */
- xid_t vc_create_context(xid_t xid);
+ xid_t vc_ctx_create(xid_t xid);
/** \brief Moves the current process into the specified context.
* \ingroup syscalls
*
* \param xid The new context
* \returns 0 on success, -1 on errors */
- int vc_migrate_context(xid_t xid);
+ int vc_ctx_migrate(xid_t xid);
/* rlimit related functions */
int vc_ctx_kill(xid_t ctx, pid_t pid, int sig);
+ struct vc_nx_info {
+ nid_t nid;
+ };
+
+ nid_t vc_get_task_nid(pid_t pid);
+ int vc_get_nx_info(nid_t nid, struct vc_nx_info *) VC_ATTR_NONNULL((2));
+
+ typedef enum { vcNET_IPV4, vcNET_IPV6, vcNET_IPV4R, vcNET_IPV6R } vc_net_nx_type;
+
+ struct vc_net_nx {
+ vc_net_nx_type type;
+ size_t count;
+ uint32_t ip;
+ uint32_t mask;
+ };
+
+ nid_t vc_net_create(nid_t nid);
+ int vc_net_migrate(nid_t nid);
+
+ int vc_net_add(nid_t nid, struct vc_net_nx const *info);
+ int vc_net_remove(nid_t nid, struct vc_net_nx const *info);
+
+ struct vc_net_flags {
+ uint_least64_t flagword;
+ uint_least64_t mask;
+ };
+
+ int vc_get_nflags(nid_t, struct vc_net_flags *);
+ int vc_set_nflags(nid_t, struct vc_net_flags const *);
+
+
+ struct vc_net_caps {
+ uint_least64_t ncaps;
+ uint_least64_t cmask;
+ };
+
+ int vc_get_ncaps(nid_t, struct vc_net_caps *);
+ int vc_set_ncaps(nid_t, struct vc_net_caps const *);
+
+
+
int vc_set_iattr(char const *filename, xid_t xid,
uint_least32_t flags, uint_least32_t mask) VC_ATTR_NONNULL((1));
+
+ /** \brief Returns information about attributes and assigned context of a file.
+ * \ingroup syscalls
+ *
+ * This function returns the VC_IATTR_XXX flags and about the assigned
+ * context of a file. To request an information, the appropriate bit in
+ * \c mask must be set and the corresponding parameter (\a xid or \a
+ * flags) must not be NULL.
+ *
+ * E.g. to receive the assigned context, the \c VC_IATTR_XID bit must be
+ * set in \a mask, and \a xid must point to valid memory.
+ *
+ * Possible flags are \c VC_IATTR_ADMIN, \c VC_IATTR_WATCH , \c VC_IATTR_HIDE,
+ * \c VC_IATTR_BARRIER, \c VC_IATTR_IUNLINK and \c VC_IATTR_IMMUTABLE.
+ *
+ * \param filename The name of the file whose attributes shall be determined.
+
+ * \param xid When non-zero and the VC_IATTR_XID bit is set in \a mask,
+ * the assigned context of \a filename will be stored there.
+ * \param flags When non-zero, a bitmask of current attributes will be
+ * stored there. These attributes must be requested explicitly
+ * by setting the appropriate bit in \a mask
+ * \param mask Points to a bitmask which tells which attributes shall be
+ * determined. On return, it will masquerade the attributes
+ * which were determined.
+ *
+ * \pre mask!=0 && !((*mask&VC_IATTR_XID) && xid==0) && !((*mask&~VC_IATTR_XID) && flags==0) */
int vc_get_iattr(char const *filename, xid_t * /*@null@*/ xid,
uint_least32_t * /*@null@*/ flags,
uint_least32_t * /*@null@*/ mask) VC_ATTR_NONNULL((1));
pid_t initpid;
};
- /** Returns the context of the given process. pid==0 means the current process. */
+ /** \brief Returns the context of the given process.
+ * \ingroup syscalls
+ *
+ * \param pid the process-id whose xid shall be determined;
+ * pid==0 means the current process.
+ * \returns the xid of process \c pid or -1 on errors
+ */
xid_t vc_get_task_xid(pid_t pid);
int vc_get_vx_info(xid_t xid, struct vc_vx_info *info) VC_ATTR_NONNULL((2));
int vc_set_namespace();
int vc_cleanup_namespace();
+
+ /** \brief Flags of process-contexts
+ */
struct vc_ctx_flags {
+ /** \brief Mask of set context flags */
uint_least64_t flagword;
+ /** \brief Mask of set and unset context flags when used by set
+ * operations, or modifiable flags when used by get
+ * operations */
uint_least64_t mask;
};
-
+
+ /** \brief Capabilities of process-contexts */
struct vc_ctx_caps {
+ /** \brief Mask of set common system capabilities */
uint_least64_t bcaps;
+ /** \brief Mask of set and unset common system capabilities when used by
+ * set operations, or the modifiable capabilities when used by
+ * get operations */
uint_least64_t bmask;
+ /** \brief Mask of set process context capabilities */
uint_least64_t ccaps;
+ /** \brief Mask of set and unset process context capabilities when used
+ * by set operations, or the modifiable capabilities when used
+ * by get operations */
uint_least64_t cmask;
};
+ /** \brief Information about parsing errors
+ * \ingroup helper
+ */
struct vc_err_listparser {
- char const *ptr;
- size_t len;
+ char const *ptr; ///< Pointer to the first character of an erroneous string
+ size_t len; ///< Length of the erroneous string
};
- int vc_get_flags(xid_t xid, struct vc_ctx_flags *) VC_ATTR_NONNULL((2));
- int vc_set_flags(xid_t xid, struct vc_ctx_flags const *) VC_ATTR_NONNULL((2));
+ int vc_get_cflags(xid_t xid, struct vc_ctx_flags *) VC_ATTR_NONNULL((2));
+ int vc_set_cflags(xid_t xid, struct vc_ctx_flags const *) VC_ATTR_NONNULL((2));
int vc_get_ccaps(xid_t xid, struct vc_ctx_caps *);
int vc_set_ccaps(xid_t xid, struct vc_ctx_caps const *);
- uint_least64_t vc_text2bcap(char const *, size_t len);
- char const * vc_lobcap2text(uint_least64_t *);
- int vc_list2bcap(char const *, size_t len,
+ /** \brief Converts a single string into bcapability
+ * \ingroup helper
+ *
+ * \param str The string to be parsed;
+ * both "CAP_xxx" and "xxx" will be accepted
+ * \param len The length of the string, or \c 0 for automatic detection
+ *
+ * \returns 0 on error; a bitmask on success
+ * \pre \a str != 0
+ */
+ uint_least64_t vc_text2bcap(char const *str, size_t len);
+
+ /** \brief Converts the lowest bit of a bcapability or the entire value
+ * (when possible) to a textual representation
+ * \ingroup helper
+ *
+ * \param val The string to be converted; on success, the detected bit(s)
+ * will be unset, in errorcase only the lowest set bit
+ *
+ * \returns A textual representation of \a val resp. of its lowest set bit;
+ * or \c NULL in errorcase.
+ * \pre \a val!=0
+ * \post \a *val<sub>old</sub> \c != 0 \c <-->
+ * \a *val<sub>old</sub> > \a *val<sub>new</sub>
+ * \post \a *val<sub>old</sub> \c == 0 \c ---> \a result == 0
+ */
+ char const * vc_lobcap2text(uint_least64_t *val) VC_ATTR_NONNULL((1));
+
+ /** \brief Converts a string into a bcapability-bitmask
+ * \ingroup helper
+ *
+ * Syntax of \a str: \verbinclude list2xxx.syntax
+ *
+ * When the \c `~' prefix is used, the bits will be unset and a `~' after
+ * another `~' will cancel both ones. The \c `^' prefix specifies a
+ * bitnumber instead of a bitmask.
+ *
+ * "literal name" is everything which will be accepted by the
+ * vc_text2bcap() function. The special values for \c NAME will be
+ * recognized case insensitively
+ *
+ * \param str The string to be parsed
+ * \param len The length of the string, or \c 0 for automatic detection
+ * \param err Pointer to a structure for error-information, or \c NULL.
+ * \param cap Pointer to a vc_ctx_caps structure holding the results;
+ * only the \a bcaps and \a bmask fields will be changed and
+ * already set values will not be honored. When an error
+ * occured, \a cap will have the value of all processed valid
+ * \c BCAP parts.
+ *
+ * \returns 0 on success, -1 on error. In error case, \a err will hold
+ * position and length of the first not understood BCAP part
+ * \pre \a str != 0 && \a cap != 0;
+ * \a cap->bcaps and \a cap->bmask must be initialized
+ */
+ int vc_list2bcap(char const *str, size_t len,
struct vc_err_listparser *err,
- struct vc_ctx_caps *);
+ struct vc_ctx_caps *cap) VC_ATTR_NONNULL((1,4));
uint_least64_t vc_text2ccap(char const *, size_t len);
char const * vc_loccap2text(uint_least64_t *);
struct vc_err_listparser *err,
struct vc_ctx_caps *);
- int vc_list2flag(char const *, size_t len,
+ int vc_list2cflag(char const *, size_t len,
struct vc_err_listparser *err,
struct vc_ctx_flags *flags);
- uint_least64_t vc_text2flag(char const *, size_t len);
- char const * vc_loflag2text(uint_least64_t *);
+ uint_least64_t vc_text2cflag(char const *, size_t len);
+ char const * vc_locflag2text(uint_least64_t *);
- uint_least32_t vc_list2flag_compat(char const *, size_t len,
+ uint_least32_t vc_list2cflag_compat(char const *, size_t len,
struct vc_err_listparser *err);
- uint_least32_t vc_text2flag_compat(char const *, size_t len);
- char const * vc_hiflag2text_compat(uint_least32_t);
+ uint_least32_t vc_text2cflag_compat(char const *, size_t len);
+ char const * vc_hicflag2text_compat(uint_least32_t);
- uint_least32_t vc_get_insecurecaps() VC_ATTR_CONST;
int vc_text2cap(char const *);
char const * vc_cap2text(unsigned int);
+
+ int vc_list2nflag(char const *, size_t len,
+ struct vc_err_listparser *err,
+ struct vc_net_flags *flags);
+ uint_least64_t vc_text2nflag(char const *, size_t len);
+ char const * vc_lonflag2text(uint_least64_t *);
+
+ uint_least64_t vc_text2ncap(char const *, size_t len);
+ char const * vc_loncap2text(uint_least64_t *);
+ int vc_list2ncap(char const *, size_t len,
+ struct vc_err_listparser *err,
+ struct vc_net_caps *);
+ uint_least64_t vc_get_insecurebcaps() VC_ATTR_CONST;
+ inline static uint_least64_t vc_get_insecureccaps() {
+ return ~(VC_VXC_SET_UTSNAME|VC_VXC_RAW_ICMP);
+ }
+
inline static int vc_setfilecontext(char const *filename, xid_t xid) {
return vc_set_iattr(filename, xid, 0, VC_IATTR_XID);
}
- inline static xid_t vc_getfilecontext(char const *filename) {
- xid_t res;
- if (vc_get_iattr(filename, &res, 0,0)==-1) return VC_NOCTX;
- return res;
- }
+ /** \brief Returns the context of \c filename
+ * \ingroup syscalls
+ *
+ * This function calls vc_get_iattr() with appropriate arguments to
+ * determine the context of \c filename. In error-case or when no context
+ * is assigned, \c VC_NOCTX will be returned. To differ between both cases,
+ * \c errno must be examined.
+ *
+ * \b WARNING: this function can modify \c errno although no error happened.
+ *
+ * \param filename The file to check
+ * \returns The assigned context, or VC_NOCTX when an error occured or no
+ * such assignment exists. \c errno will be 0 in the latter case */
+ xid_t vc_getfilecontext(char const *filename) VC_ATTR_NONNULL((1));
struct vc_set_sched {
- int32_t fill_rate;
- int32_t interval;
- int32_t tokens;
- int32_t tokens_min;
- int32_t tokens_max;
- uint64_t cpu_mask;
+ uint_least32_t set_mask;
+ int_least32_t fill_rate;
+ int_least32_t interval;
+ int_least32_t tokens;
+ int_least32_t tokens_min;
+ int_least32_t tokens_max;
+ int_least32_t priority_bias;
};
int vc_set_sched(xid_t xid, struct vc_set_sched const *);
typedef enum { vcFEATURE_VKILL, vcFEATURE_IATTR, vcFEATURE_RLIMIT,
vcFEATURE_COMPAT, vcFEATURE_MIGRATE, vcFEATURE_NAMESPACE,
vcFEATURE_SCHED, vcFEATURE_VINFO, vcFEATURE_VHI,
- vcFEATURE_VSHELPER }
+ vcFEATURE_VSHELPER0, vcFEATURE_VSHELPER }
vcFeatureSet;
bool vc_isSupported(vcFeatureSet) VC_ATTR_CONST;