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 "config.h"
  36 #include "namespace.h"
  37 #include "state.h"
  38
  39 struct lxc_handler {
  40         /* The clone flags that were requested. */
  41         int clone_flags;
  42
  43         /* File descriptor to pin the rootfs for privileged containers. */
  44         int pinfd;
  45
  46         /* Signal file descriptor. */
  47         int sigfd;
  48
  49         /* List of file descriptors referring to the namespaces of the
  50          * container. Note that these are not necessarily identical to
  51          * the "clone_flags" handler field in case namespace inheritance is
  52          * requested.
  53          */
  54         int nsfd[LXC_NS_MAX];
  55
  56         /* Abstract unix domain SOCK_DGRAM socketpair to pass arbitrary data
  57          * between child and parent.
  58          */
  59         int data_sock[2];
  60
  61         /* The socketpair() fds used to wait on successful daemonized startup. */
  62         int state_socket_pair[2];
  63
  64         /* Socketpair to synchronize processes during container creation. */
  65         int sync_sock[2];
  66
  67         /* Pointer to the name of the container. Do not free! */
  68         const char *name;
  69
  70         /* Pointer to the path the container. Do not free! */
  71         const char *lxcpath;
  72
  73         /* Whether the container's startup process euid is 0. */
  74         bool am_root;
  75
  76         /* Indicates whether should we close std{in,out,err} on start. */
  77         bool backgrounded;
  78
  79         /* The child's pid. */
  80         pid_t pid;
  81
  82         /* The signal mask prior to setting up the signal file descriptor. */
  83         sigset_t oldmask;
  84
  85         /* The container's in-memory configuration. */
  86         struct lxc_conf *conf;
  87
  88         /* A set of operations to be performed at various stages of the
  89          * container's life.
  90          */
  91         struct lxc_operations *ops;
  92
  93         /* This holds the cgroup information. Note that the data here is
  94          * specific to the cgroup driver used.
  95          */
  96         void *cgroup_data;
  97
  98         /* Data to be passed to handler ops. */
  99         void *data;
 100
 101         /* Current state of the container. */
 102         lxc_state_t state;
 103 };
 104
 105 struct lxc_operations {
 106         int (*start)(struct lxc_handler *, void *);
 107         int (*post_start)(struct lxc_handler *, void *);
 108 };
 109
 110 extern int lxc_poll(const char *name, struct lxc_handler *handler);
 111 extern int lxc_set_state(const char *name, struct lxc_handler *handler, lxc_state_t state);
 112 extern void lxc_abort(const char *name, struct lxc_handler *handler);
 113 extern struct lxc_handler *lxc_init_handler(const char *name,
 114                                             struct lxc_conf *conf,
 115                                             const char *lxcpath,
 116                                             bool daemonize);
 117 extern void lxc_free_handler(struct lxc_handler *handler);
 118 extern int lxc_init(const char *name, struct lxc_handler *handler);
 119 extern void lxc_fini(const char *name, struct lxc_handler *handler);
 120
 121 /* lxc_check_inherited: Check for any open file descriptors and close them if
 122  *                      requested.
 123  * @param[in] conf          The container's configuration.
 124  * @param[in] closeall      Whether we should close all open file descriptors.
 125  * @param[in] fds_to_ignore Array of file descriptors to ignore.
 126  * @param[in] len_fds       Length of fds_to_ignore array.
 127  */
 128 extern int lxc_check_inherited(struct lxc_conf *conf, bool closeall,
 129                                int *fds_to_ignore, size_t len_fds);
 130 extern int __lxc_start(const char *, struct lxc_handler *,
 131                        struct lxc_operations *, void *, const char *, bool);
 132
 133 extern void resolve_clone_flags(struct lxc_handler *handler);
 134 #endif
 135