src/lxc/conf.h

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #ifndef __LXC_CONF_H
   4 #define __LXC_CONF_H
   5
   6 #ifndef _GNU_SOURCE
   7 #define _GNU_SOURCE 1
   8 #endif
   9 #include <linux/magic.h>
  10 #include <net/if.h>
  11 #include <netinet/in.h>
  12 #include <stdbool.h>
  13 #include <stdio.h>
  14 #include <sys/param.h>
  15 #include <sys/types.h>
  16 #include <sys/vfs.h>
  17
  18 #include "compiler.h"
  19 #include "config.h"
  20 #include "list.h"
  21 #include "lxcseccomp.h"
  22 #include "memory_utils.h"
  23 #include "ringbuf.h"
  24 #include "start.h"
  25 #include "terminal.h"
  26
  27 #if HAVE_SYS_RESOURCE_H
  28 #include <sys/resource.h>
  29 #endif
  30
  31 #if HAVE_SCMP_FILTER_CTX
  32 typedef void * scmp_filter_ctx;
  33 #endif
  34
  35 /* worth moving to configure.ac? */
  36 #define subuidfile "/etc/subuid"
  37 #define subgidfile "/etc/subgid"
  38
  39 /*
  40  * Defines a generic struct to configure the control group. It is up to the
  41  * programmer to specify the right subsystem.
  42  * @subsystem : the targeted subsystem
  43  * @value     : the value to set
  44  * @version   : The version of the cgroup filesystem on which the controller
  45  *              resides.
  46  *
  47  * @controllers : The controllers to use for this container.
  48  * @dir         : The name of the directory containing the container's cgroup.
  49  *                Not that this is a per-container setting.
  50  */
  51 struct lxc_cgroup {
  52         union {
  53                 /* information about a specific controller */
  54                 struct /* controller */ {
  55                         int version;
  56                         char *subsystem;
  57                         char *value;
  58                 };
  59
  60                 /* meta information about cgroup configuration */
  61                 struct /* meta */ {
  62                         char *controllers;
  63                         char *dir;
  64                         char *monitor_dir;
  65                         char *monitor_pivot_dir;
  66                         char *container_dir;
  67                         char *namespace_dir;
  68                         bool relative;
  69                 };
  70         };
  71 };
  72
  73 static void free_lxc_cgroup(struct lxc_cgroup *ptr)
  74 {
  75         if (ptr) {
  76                 free(ptr->subsystem);
  77                 free(ptr->value);
  78                 free_disarm(ptr);
  79         }
  80 }
  81 define_cleanup_function(struct lxc_cgroup *, free_lxc_cgroup);
  82
  83 #if !HAVE_SYS_RESOURCE_H
  84 #define RLIM_INFINITY ((unsigned long)-1)
  85 struct rlimit {
  86         unsigned long rlim_cur;
  87         unsigned long rlim_max;
  88 };
  89 #endif
  90
  91 /*
  92  * Defines a structure to configure resource limits to set via setrlimit().
  93  * @resource : the resource name in lowercase without the RLIMIT_ prefix
  94  * @limit    : the limit to set
  95  */
  96 struct lxc_limit {
  97         char *resource;
  98         struct rlimit limit;
  99 };
 100
 101 static void free_lxc_limit(struct lxc_limit *ptr)
 102 {
 103         if (ptr) {
 104                 free(ptr->resource);
 105                 free_disarm(ptr);
 106         }
 107 }
 108 define_cleanup_function(struct lxc_limit *, free_lxc_limit);
 109
 110 enum idtype {
 111         ID_TYPE_UID,
 112         ID_TYPE_GID
 113 };
 114
 115 /*
 116  * Defines a structure to configure kernel parameters at runtime.
 117  * @key      : the kernel parameters will be configured without the "lxc.sysctl" prefix
 118  * @value    : the value to set
 119  */
 120 struct lxc_sysctl {
 121         char *key;
 122         char *value;
 123 };
 124
 125 static void free_lxc_sysctl(struct lxc_sysctl *ptr)
 126 {
 127         if (ptr) {
 128                 free(ptr->key);
 129                 free(ptr->value);
 130                 free_disarm(ptr);
 131         }
 132 }
 133 define_cleanup_function(struct lxc_sysctl *, free_lxc_sysctl);
 134
 135 /*
 136  * Defines a structure to configure proc filesystem at runtime.
 137  * @filename : the proc filesystem will be configured without the "lxc.proc" prefix
 138  * @value    : the value to set
 139  */
 140 struct lxc_proc {
 141         char *filename;
 142         char *value;
 143 };
 144
 145 static void free_lxc_proc(struct lxc_proc *ptr)
 146 {
 147         if (ptr) {
 148                 free(ptr->filename);
 149                 free(ptr->value);
 150                 free_disarm(ptr);
 151         }
 152 }
 153 define_cleanup_function(struct lxc_proc *, free_lxc_proc);
 154
 155 /*
 156  * id_map is an id map entry.  Form in confile is:
 157  * lxc.idmap = u 0    9800 100
 158  * lxc.idmap = u 1000 9900 100
 159  * lxc.idmap = g 0    9800 100
 160  * lxc.idmap = g 1000 9900 100
 161  * meaning the container can use uids and gids 0-99 and 1000-1099,
 162  * with [ug]id 0 mapping to [ug]id 9800 on the host, and [ug]id 1000 to
 163  * [ug]id 9900 on the host.
 164  */
 165 struct id_map {
 166         enum idtype idtype;
 167         unsigned long hostid, nsid, range;
 168 };
 169
 170 /* Defines the number of tty configured and contains the
 171  * instantiated ptys
 172  * @max = number of configured ttys
 173  */
 174 struct lxc_tty_info {
 175         size_t max;
 176         char *dir;
 177         char *tty_names;
 178         struct lxc_terminal_info *tty;
 179 };
 180
 181 /* Defines a structure to store the rootfs location, the
 182  * optionals pivot_root, rootfs mount paths
 183  * @path         : the rootfs source (directory or device)
 184  * @mount        : where it is mounted
 185  * @bev_type     : optional backing store type
 186  * @options      : mount options
 187  * @mountflags   : the portion of @options that are flags
 188  * @data         : the portion of @options that are not flags
 189  * @managed      : whether it is managed by LXC
 190  * @mntpt_fd     : fd for @mount
 191  * @dev_mntpt_fd : fd for /dev of the container
 192  */
 193 struct lxc_rootfs {
 194         int mntpt_fd;
 195         int dev_mntpt_fd;
 196         char *path;
 197         char *mount;
 198         char *bdev_type;
 199         char *options;
 200         unsigned long mountflags;
 201         char *data;
 202         bool managed;
 203 };
 204
 205 /*
 206  * Automatic mounts for LXC to perform inside the container
 207  */
 208 enum {
 209         LXC_AUTO_PROC_RW              = 0x001, /* /proc read-write */
 210         LXC_AUTO_PROC_MIXED           = 0x002, /* /proc/sys and /proc/sysrq-trigger read-only */
 211         LXC_AUTO_PROC_MASK            = 0x003,
 212
 213         LXC_AUTO_SYS_RW               = 0x004, /* /sys */
 214         LXC_AUTO_SYS_RO               = 0x008, /* /sys read-only */
 215         LXC_AUTO_SYS_MIXED            = 0x00C, /* /sys read-only and /sys/class/net read-write */
 216         LXC_AUTO_SYS_MASK             = 0x00C,
 217
 218         LXC_AUTO_CGROUP_RO            = 0x010, /* /sys/fs/cgroup (partial mount, read-only) */
 219         LXC_AUTO_CGROUP_RW            = 0x020, /* /sys/fs/cgroup (partial mount, read-write) */
 220         LXC_AUTO_CGROUP_MIXED         = 0x030, /* /sys/fs/cgroup (partial mount, paths r/o, cgroup r/w) */
 221         LXC_AUTO_CGROUP_FULL_RO       = 0x040, /* /sys/fs/cgroup (full mount, read-only) */
 222         LXC_AUTO_CGROUP_FULL_RW       = 0x050, /* /sys/fs/cgroup (full mount, read-write) */
 223         LXC_AUTO_CGROUP_FULL_MIXED    = 0x060, /* /sys/fs/cgroup (full mount, parent r/o, own r/w) */
 224         /*
 225          * These are defined in such a way as to retain binary compatibility
 226          * with earlier versions of this code. If the previous mask is applied,
 227          * both of these will default back to the _MIXED variants, which is
 228          * safe.
 229          */
 230         LXC_AUTO_CGROUP_NOSPEC        = 0x0B0, /* /sys/fs/cgroup (partial mount, r/w or mixed, depending on caps) */
 231         LXC_AUTO_CGROUP_FULL_NOSPEC   = 0x0E0, /* /sys/fs/cgroup (full mount, r/w or mixed, depending on caps) */
 232         LXC_AUTO_CGROUP_FORCE         = 0x100, /* mount cgroups even when cgroup namespaces are supported */
 233         LXC_AUTO_CGROUP_MASK          = 0x1F0, /* all known cgroup options, doe not contain LXC_AUTO_CGROUP_FORCE */
 234
 235         LXC_AUTO_SHMOUNTS             = 0x200, /* shared mount point */
 236         LXC_AUTO_SHMOUNTS_MASK        = 0x200, /* shared mount point mask */
 237         LXC_AUTO_ALL_MASK             = 0x1FF, /* all known settings */
 238 };
 239
 240 enum lxchooks {
 241         LXCHOOK_PRESTART,
 242         LXCHOOK_PREMOUNT,
 243         LXCHOOK_MOUNT,
 244         LXCHOOK_AUTODEV,
 245         LXCHOOK_START,
 246         LXCHOOK_STOP,
 247         LXCHOOK_POSTSTOP,
 248         LXCHOOK_CLONE,
 249         LXCHOOK_DESTROY,
 250         LXCHOOK_START_HOST,
 251         NUM_LXC_HOOKS
 252 };
 253
 254 __hidden extern char *lxchook_names[NUM_LXC_HOOKS];
 255
 256 struct lxc_state_client {
 257         int clientfd;
 258         lxc_state_t states[MAX_STATE];
 259 };
 260
 261 enum {
 262         LXC_BPF_DEVICE_CGROUP_LOCAL_RULE = -1,
 263         LXC_BPF_DEVICE_CGROUP_ALLOWLIST  =  0,
 264         LXC_BPF_DEVICE_CGROUP_DENYLIST  =  1,
 265 };
 266
 267 struct device_item {
 268         char type;
 269         int major;
 270         int minor;
 271         char access[4];
 272         int allow;
 273         /*
 274          * LXC_BPF_DEVICE_CGROUP_LOCAL_RULE -> no global rule
 275          * LXC_BPF_DEVICE_CGROUP_ALLOWLIST  -> allowlist (deny all)
 276          * LXC_BPF_DEVICE_CGROUP_DENYLIST   -> denylist (allow all)
 277          */
 278         int global_rule;
 279 };
 280
 281 struct timens_offsets {
 282         /* Currently, either s_boot or ns_boot is set, but not both. */
 283         int64_t s_boot;
 284         int64_t ns_boot;
 285
 286         /* Currently, either s_monotonic or ns_monotonic is set, but not both. */
 287         int64_t s_monotonic;
 288         int64_t ns_monotonic;
 289 };
 290
 291 struct lxc_conf {
 292         /* Pointer to the name of the container. Do not free! */
 293         const char *name;
 294         bool is_execute;
 295         int reboot;
 296         signed long personality;
 297         struct utsname *utsname;
 298
 299         struct {
 300                 struct lxc_list cgroup;
 301                 struct lxc_list cgroup2;
 302                 struct bpf_program *cgroup2_devices;
 303                 /* This should be reimplemented as a hashmap. */
 304                 struct lxc_list devices;
 305         };
 306
 307         struct {
 308                 struct lxc_list id_map;
 309
 310                 /*
 311                  * Pointer to the idmap entry for the container's root uid in
 312                  * the id_map list. Do not free!
 313                  */
 314                 const struct id_map *root_nsuid_map;
 315
 316                 /*
 317                  * Pointer to the idmap entry for the container's root gid in
 318                  * the id_map list. Do not free!
 319                  */
 320                 const struct id_map *root_nsgid_map;
 321         };
 322
 323         struct lxc_list network;
 324
 325         struct {
 326                 char *fstab;
 327                 int auto_mounts;
 328                 struct lxc_list mount_list;
 329         };
 330
 331         struct lxc_list caps;
 332         struct lxc_list keepcaps;
 333
 334         /* /dev/tty<idx> devices */
 335         struct lxc_tty_info ttys;
 336         /* /dev/console device */
 337         struct lxc_terminal console;
 338         /* maximum pty devices allowed by devpts mount */
 339         size_t pty_max;
 340         /* file descriptor for the container's /dev/pts mount */
 341         int devpts_fd;
 342
 343         /* set to true when rootfs has been setup */
 344         bool rootfs_setup;
 345         struct lxc_rootfs rootfs;
 346
 347         bool close_all_fds;
 348
 349         struct {
 350                 unsigned int hooks_version;
 351                 struct lxc_list hooks[NUM_LXC_HOOKS];
 352         };
 353
 354         char *lsm_aa_profile;
 355         char *lsm_aa_profile_computed;
 356         bool lsm_aa_profile_created;
 357         unsigned int lsm_aa_allow_nesting;
 358         unsigned int lsm_aa_allow_incomplete;
 359         struct lxc_list lsm_aa_raw;
 360         char *lsm_se_context;
 361         char *lsm_se_keyring_context;
 362         bool keyring_disable_session;
 363         bool tmp_umount_proc;
 364         struct lxc_seccomp seccomp;
 365         int maincmd_fd;
 366         unsigned int autodev;  /* if 1, mount and fill a /dev at start */
 367         int autodevtmpfssize; /* size of the /dev tmpfs */
 368         int haltsignal; /* signal used to halt container */
 369         int rebootsignal; /* signal used to reboot container */
 370         int stopsignal; /* signal used to hard stop container */
 371         char *rcfile;   /* Copy of the top level rcfile we read */
 372
 373         /* Logfile and loglevel can be set in a container config file. Those
 374          * function as defaults. The defaults can be overridden by command line.
 375          * However we don't want the command line specified values to be saved
 376          * on c->save_config(). So we store the config file specified values
 377          * here. */
 378         char *logfile; /* the logfile as specified in config */
 379         int loglevel; /* loglevel as specified in config (if any) */
 380         int logfd;
 381
 382         unsigned int start_auto;
 383         unsigned int start_delay;
 384         int start_order;
 385         struct lxc_list groups;
 386         int nbd_idx;
 387
 388         /* unshare the mount namespace in the monitor */
 389         unsigned int monitor_unshare;
 390         unsigned int monitor_signal_pdeath;
 391
 392         /* list of included files */
 393         struct lxc_list includes;
 394         /* config entries which are not "lxc.*" are aliens */
 395         struct lxc_list aliens;
 396
 397         /* list of environment variables we'll add to the container when
 398          * started */
 399         struct lxc_list environment;
 400
 401         /* text representation of the config file */
 402         char *unexpanded_config;
 403         size_t unexpanded_len;
 404         size_t unexpanded_alloced;
 405
 406         /* default command for lxc-execute */
 407         char *execute_cmd;
 408
 409         /* init command */
 410         char *init_cmd;
 411
 412         /* if running in a new user namespace, the UID/GID that init and COMMAND
 413          * should run under when using lxc-execute */
 414         uid_t init_uid;
 415         gid_t init_gid;
 416
 417         /* indicator if the container will be destroyed on shutdown */
 418         unsigned int ephemeral;
 419
 420         /* The facility to pass to syslog. Let's users establish as what type of
 421          * program liblxc is supposed to write to the syslog. */
 422         char *syslog;
 423
 424         /* Whether PR_SET_NO_NEW_PRIVS will be set for the container. */
 425         bool no_new_privs;
 426
 427         /* RLIMIT_* limits */
 428         struct lxc_list limits;
 429
 430         /* Contains generic info about the cgroup configuration for this
 431          * container. Note that struct lxc_cgroup contains a union. It is only
 432          * valid to access the members of the anonymous "meta" struct within
 433          * that union.
 434          */
 435         struct lxc_cgroup cgroup_meta;
 436
 437         struct {
 438                 int ns_clone;
 439                 int ns_keep;
 440                 char *ns_share[LXC_NS_MAX];
 441         };
 442
 443         /* init working directory */
 444         char *init_cwd;
 445
 446         /* A list of clients registered to be informed about a container state. */
 447         struct lxc_list state_clients;
 448
 449         /* sysctls */
 450         struct lxc_list sysctls;
 451
 452         /* procs */
 453         struct lxc_list procs;
 454
 455         struct shmount {
 456                 /* Absolute path to the shared mount point on the host */
 457                 char *path_host;
 458                 /* Absolute path (in the container) to the shared mount point */
 459                 char *path_cont;
 460         } shmount;
 461
 462         struct timens_offsets timens;
 463 };
 464
 465 __hidden extern int write_id_mapping(enum idtype idtype, pid_t pid, const char *buf, size_t buf_size)
 466     __access_r(3, 4);
 467
 468 #ifdef HAVE_TLS
 469 extern thread_local struct lxc_conf *current_config;
 470 #else
 471 extern struct lxc_conf *current_config;
 472 #endif
 473
 474 __hidden extern int run_lxc_hooks(const char *name, char *hook, struct lxc_conf *conf, char *argv[]);
 475 __hidden extern struct lxc_conf *lxc_conf_init(void);
 476 __hidden extern void lxc_conf_free(struct lxc_conf *conf);
 477 __hidden extern int pin_rootfs(const char *rootfs);
 478 __hidden extern int lxc_map_ids(struct lxc_list *idmap, pid_t pid);
 479 __hidden extern int lxc_create_tty(const char *name, struct lxc_conf *conf);
 480 __hidden extern void lxc_delete_tty(struct lxc_tty_info *ttys);
 481 __hidden extern int lxc_clear_config_caps(struct lxc_conf *c);
 482 __hidden extern int lxc_clear_config_keepcaps(struct lxc_conf *c);
 483 __hidden extern int lxc_clear_cgroups(struct lxc_conf *c, const char *key, int version);
 484 __hidden extern int lxc_clear_mount_entries(struct lxc_conf *c);
 485 __hidden extern int lxc_clear_automounts(struct lxc_conf *c);
 486 __hidden extern int lxc_clear_hooks(struct lxc_conf *c, const char *key);
 487 __hidden extern int lxc_clear_idmaps(struct lxc_conf *c);
 488 __hidden extern int lxc_clear_groups(struct lxc_conf *c);
 489 __hidden extern int lxc_clear_environment(struct lxc_conf *c);
 490 __hidden extern int lxc_clear_limits(struct lxc_conf *c, const char *key);
 491 __hidden extern int lxc_delete_autodev(struct lxc_handler *handler);
 492 __hidden extern int lxc_clear_autodev_tmpfs_size(struct lxc_conf *c);
 493 __hidden extern void lxc_clear_includes(struct lxc_conf *conf);
 494 __hidden extern int lxc_setup_rootfs_prepare_root(struct lxc_conf *conf, const char *name,
 495                                                   const char *lxcpath);
 496 __hidden extern int lxc_setup(struct lxc_handler *handler);
 497 __hidden extern int lxc_setup_parent(struct lxc_handler *handler);
 498 __hidden extern int setup_resource_limits(struct lxc_list *limits, pid_t pid);
 499 __hidden extern int find_unmapped_nsid(const struct lxc_conf *conf, enum idtype idtype);
 500 __hidden extern int mapped_hostid(unsigned id, const struct lxc_conf *conf, enum idtype idtype);
 501 __hidden extern int userns_exec_1(const struct lxc_conf *conf, int (*fn)(void *), void *data,
 502                                   const char *fn_name);
 503 __hidden extern int userns_exec_full(struct lxc_conf *conf, int (*fn)(void *), void *data,
 504                                      const char *fn_name);
 505 __hidden extern int parse_mntopts(const char *mntopts, unsigned long *mntflags, char **mntdata);
 506 __hidden extern int parse_propagationopts(const char *mntopts, unsigned long *pflags);
 507 __hidden extern void tmp_proc_unmount(struct lxc_conf *lxc_conf);
 508 __hidden extern void turn_into_dependent_mounts(void);
 509 __hidden extern void suggest_default_idmap(void);
 510 __hidden extern FILE *make_anonymous_mount_file(struct lxc_list *mount, bool include_nesting_helpers);
 511 __hidden extern struct lxc_list *sort_cgroup_settings(struct lxc_list *cgroup_settings);
 512 __hidden extern unsigned long add_required_remount_flags(const char *s, const char *d,
 513                                                          unsigned long flags);
 514 __hidden extern int run_script(const char *name, const char *section, const char *script, ...);
 515 __hidden extern int run_script_argv(const char *name, unsigned int hook_version, const char *section,
 516                                     const char *script, const char *hookname, char **argsin);
 517 __hidden extern int in_caplist(int cap, struct lxc_list *caps);
 518 __hidden extern int setup_sysctl_parameters(struct lxc_list *sysctls);
 519 __hidden extern int lxc_clear_sysctls(struct lxc_conf *c, const char *key);
 520 __hidden extern int setup_proc_filesystem(struct lxc_list *procs, pid_t pid);
 521 __hidden extern int lxc_clear_procs(struct lxc_conf *c, const char *key);
 522 __hidden extern int lxc_clear_apparmor_raw(struct lxc_conf *c);
 523 __hidden extern int lxc_clear_namespace(struct lxc_conf *c);
 524 __hidden extern int userns_exec_minimal(const struct lxc_conf *conf, int (*fn_parent)(void *),
 525                                         void *fn_parent_data, int (*fn_child)(void *),
 526                                         void *fn_child_data);
 527 __hidden extern int userns_exec_mapped_root(const char *path, int path_fd,
 528                                             const struct lxc_conf *conf);
 529 static inline int chown_mapped_root(const char *path, const struct lxc_conf *conf)
 530 {
 531         return userns_exec_mapped_root(path, -EBADF, conf);
 532 }
 533
 534 __hidden int lxc_setup_devpts_parent(struct lxc_handler *handler);
 535
 536 #endif /* __LXC_CONF_H */