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         /* The child's pidfd. */
 106         int pidfd;
 107
 108         /*
 109          * File descriptor for the /proc/<pid> directory of the container's
 110          * init process.
 111          */
 112         int proc_pidfd;
 113
 114         /* The monitor's pid. */
 115         pid_t monitor_pid;
 116
 117         /* Whether the child has already exited. */
 118         bool init_died;
 119
 120         /* The signal mask prior to setting up the signal file descriptor. */
 121         sigset_t oldmask;
 122
 123         /* The container's in-memory configuration. */
 124         struct lxc_conf *conf;
 125
 126         /* A set of operations to be performed at various stages of the
 127          * container's life.
 128          */
 129         struct lxc_operations *ops;
 130
 131         /* This holds the cgroup information. Note that the data here is
 132          * specific to the cgroup driver used.
 133          */
 134         void *cgroup_data;
 135
 136         /* Data to be passed to handler ops. */
 137         void *data;
 138
 139         /* Current state of the container. */
 140         lxc_state_t state;
 141
 142         /* The exit status of the container; not defined unless ->init_died ==
 143          * true.
 144          */
 145         int exit_status;
 146
 147         struct cgroup_ops *cgroup_ops;
 148 };
 149
 150 struct execute_args {
 151         char *init_path;
 152         int init_fd;
 153         char *const *argv;
 154         int quiet;
 155 };
 156
 157 struct lxc_operations {
 158         int (*start)(struct lxc_handler *, void *);
 159         int (*post_start)(struct lxc_handler *, void *);
 160 };
 161
 162 extern int lxc_poll(const char *name, struct lxc_handler *handler);
 163 extern int lxc_set_state(const char *name, struct lxc_handler *handler,
 164                          lxc_state_t state);
 165 extern int lxc_serve_state_clients(const char *name,
 166                                    struct lxc_handler *handler,
 167                                    lxc_state_t state);
 168 extern void lxc_abort(const char *name, struct lxc_handler *handler);
 169 extern struct lxc_handler *lxc_init_handler(const char *name,
 170                                             struct lxc_conf *conf,
 171                                             const char *lxcpath,
 172                                             bool daemonize);
 173 extern void lxc_zero_handler(struct lxc_handler *handler);
 174 extern void lxc_free_handler(struct lxc_handler *handler);
 175 extern int lxc_init(const char *name, struct lxc_handler *handler);
 176 extern void lxc_fini(const char *name, struct lxc_handler *handler);
 177
 178 /* lxc_check_inherited: Check for any open file descriptors and close them if
 179  *                      requested.
 180  * @param[in] conf          The container's configuration.
 181  * @param[in] closeall      Whether we should close all open file descriptors.
 182  * @param[in] fds_to_ignore Array of file descriptors to ignore.
 183  * @param[in] len_fds       Length of fds_to_ignore array.
 184  */
 185 extern int lxc_check_inherited(struct lxc_conf *conf, bool closeall,
 186                                int *fds_to_ignore, size_t len_fds);
 187 extern int __lxc_start(const char *, struct lxc_handler *,
 188                        struct lxc_operations *, void *, const char *, bool,
 189                        int *);
 190
 191 extern int resolve_clone_flags(struct lxc_handler *handler);
 192
 193 #endif