src/lxc/start.h

   1 /*
   2  * lxc: linux Container library
   3  *
   4  * (C) Copyright IBM Corp. 2007, 2008
   5  *
   6  * Authors:
   7  * Daniel Lezcano <daniel.lezcano at free.fr>
   8  * Serge Hallyn <serge@hallyn.com>
   9  * Christian Brauner <christian.brauner@ubuntu.com>
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2.1 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with this library; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  24  */
  25 #ifndef __LXC_START_H
  26 #define __LXC_START_H
  27
  28 #include <signal.h>
  29 #include <stdbool.h>
  30 #include <sys/param.h>
  31 #include <sys/socket.h>
  32 #include <sys/un.h>
  33
  34 #include "conf.h"
  35 #include "namespace.h"
  36 #include "state.h"
  37
  38 struct lxc_handler {
  39         /* Record the clone for namespaces flags that the container requested.
  40          *
  41          * @ns_clone_flags
  42          * - All clone flags that were requested.
  43          *
  44          * @ns_on_clone_flags
  45          * - The clone flags for namespaces to actually use when calling
  46          *   lxc_clone(): After the container has started ns_on_clone_flags will
  47          *   list the clone flags that were unshare()ed rather then clone()ed
  48          *   because of ordering requirements (e.g. e.g. CLONE_NEWNET and
  49          *   CLONE_NEWUSER) or implementation details.
  50          *
  51          * @ns_keep_flags;
  52          * - The clone flags for the namespaces that the container will inherit
  53          *   from the parent. They are not recorded in the handler itself but
  54          *   are present in the container's config.
  55          *
  56          * @ns_share_flags;
  57          * - The clone flags for the namespaces that the container will share
  58          *   with another process.  They are not recorded in the handler itself
  59          *   but are present in the container's config.
  60          */
  61         struct /* lxc_ns */ {
  62                 int ns_clone_flags;
  63                 int ns_on_clone_flags;
  64         };
  65
  66         /* File descriptor to pin the rootfs for privileged containers. */
  67         int pinfd;
  68
  69         /* Signal file descriptor. */
  70         int sigfd;
  71
  72         /* List of file descriptors referring to the namespaces of the
  73          * container. Note that these are not necessarily identical to
  74          * the "clone_flags" handler field in case namespace inheritance is
  75          * requested.
  76          */
  77         int nsfd[LXC_NS_MAX];
  78
  79         /* Abstract unix domain SOCK_DGRAM socketpair to pass arbitrary data
  80          * between child and parent.
  81          */
  82         int data_sock[2];
  83
  84         /* The socketpair() fds used to wait on successful daemonized startup. */
  85         int state_socket_pair[2];
  86
  87         /* Socketpair to synchronize processes during container creation. */
  88         int sync_sock[2];
  89
  90         /* Pointer to the name of the container. Do not free! */
  91         const char *name;
  92
  93         /* Pointer to the path the container. Do not free! */
  94         const char *lxcpath;
  95
  96         /* Whether the container's startup process euid is 0. */
  97         bool am_root;
  98
  99         /* Indicates whether should we close std{in,out,err} on start. */
 100         bool daemonize;
 101
 102         /* The child's pid. */
 103         pid_t pid;
 104
 105         /* Whether the child has already exited. */
 106         bool init_died;
 107
 108         /* The signal mask prior to setting up the signal file descriptor. */
 109         sigset_t oldmask;
 110
 111         /* The container's in-memory configuration. */
 112         struct lxc_conf *conf;
 113
 114         /* A set of operations to be performed at various stages of the
 115          * container's life.
 116          */
 117         struct lxc_operations *ops;
 118
 119         /* This holds the cgroup information. Note that the data here is
 120          * specific to the cgroup driver used.
 121          */
 122         void *cgroup_data;
 123
 124         /* Data to be passed to handler ops. */
 125         void *data;
 126
 127         /* Current state of the container. */
 128         lxc_state_t state;
 129
 130         /* The exit status of the container; not defined unless ->init_died ==
 131          * true.
 132          */
 133         int exit_status;
 134
 135         struct cgroup_ops *cgroup_ops;
 136 };
 137
 138 struct execute_args {
 139         char *init_path;
 140         int init_fd;
 141         char *const *argv;
 142         int quiet;
 143 };
 144
 145 struct lxc_operations {
 146         int (*start)(struct lxc_handler *, void *);
 147         int (*post_start)(struct lxc_handler *, void *);
 148 };
 149
 150 extern int lxc_poll(const char *name, struct lxc_handler *handler);
 151 extern int lxc_set_state(const char *name, struct lxc_handler *handler,
 152                          lxc_state_t state);
 153 extern int lxc_serve_state_clients(const char *name,
 154                                    struct lxc_handler *handler,
 155                                    lxc_state_t state);
 156 extern void lxc_abort(const char *name, struct lxc_handler *handler);
 157 extern struct lxc_handler *lxc_init_handler(const char *name,
 158                                             struct lxc_conf *conf,
 159                                             const char *lxcpath,
 160                                             bool daemonize);
 161 extern void lxc_zero_handler(struct lxc_handler *handler);
 162 extern void lxc_free_handler(struct lxc_handler *handler);
 163 extern int lxc_init(const char *name, struct lxc_handler *handler);
 164 extern void lxc_fini(const char *name, struct lxc_handler *handler);
 165
 166 /* lxc_check_inherited: Check for any open file descriptors and close them if
 167  *                      requested.
 168  * @param[in] conf          The container's configuration.
 169  * @param[in] closeall      Whether we should close all open file descriptors.
 170  * @param[in] fds_to_ignore Array of file descriptors to ignore.
 171  * @param[in] len_fds       Length of fds_to_ignore array.
 172  */
 173 extern int lxc_check_inherited(struct lxc_conf *conf, bool closeall,
 174                                int *fds_to_ignore, size_t len_fds);
 175 extern int __lxc_start(const char *, struct lxc_handler *,
 176                        struct lxc_operations *, void *, const char *, bool,
 177                        int *);
 178
 179 extern int resolve_clone_flags(struct lxc_handler *handler);
 180
 181 #endif