src/core/execute.h

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 #ifndef fooexecutehfoo
   4 #define fooexecutehfoo
   5
   6 /***
   7   This file is part of systemd.
   8
   9   Copyright 2010 Lennart Poettering
  10
  11   systemd is free software; you can redistribute it and/or modify it
  12   under the terms of the GNU Lesser General Public License as published by
  13   the Free Software Foundation; either version 2.1 of the License, or
  14   (at your option) any later version.
  15
  16   systemd is distributed in the hope that it will be useful, but
  17   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 License
  22   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  23 ***/
  24
  25 typedef struct ExecStatus ExecStatus;
  26 typedef struct ExecCommand ExecCommand;
  27 typedef struct ExecContext ExecContext;
  28
  29 #include <linux/types.h>
  30 #include <sys/time.h>
  31 #include <sys/resource.h>
  32 #include <sys/capability.h>
  33 #include <stdbool.h>
  34 #include <stdio.h>
  35 #include <sched.h>
  36
  37 struct CGroupBonding;
  38 struct CGroupAttribute;
  39
  40 #include "list.h"
  41 #include "util.h"
  42
  43 typedef enum KillMode {
  44         KILL_CONTROL_GROUP = 0,
  45         KILL_PROCESS,
  46         KILL_NONE,
  47         _KILL_MODE_MAX,
  48         _KILL_MODE_INVALID = -1
  49 } KillMode;
  50
  51 typedef enum KillWho {
  52         KILL_MAIN,
  53         KILL_CONTROL,
  54         KILL_ALL,
  55         _KILL_WHO_MAX,
  56         _KILL_WHO_INVALID = -1
  57 } KillWho;
  58
  59 typedef enum ExecInput {
  60         EXEC_INPUT_NULL,
  61         EXEC_INPUT_TTY,
  62         EXEC_INPUT_TTY_FORCE,
  63         EXEC_INPUT_TTY_FAIL,
  64         EXEC_INPUT_SOCKET,
  65         _EXEC_INPUT_MAX,
  66         _EXEC_INPUT_INVALID = -1
  67 } ExecInput;
  68
  69 typedef enum ExecOutput {
  70         EXEC_OUTPUT_INHERIT,
  71         EXEC_OUTPUT_NULL,
  72         EXEC_OUTPUT_TTY,
  73         EXEC_OUTPUT_SYSLOG,
  74         EXEC_OUTPUT_SYSLOG_AND_CONSOLE,
  75         EXEC_OUTPUT_KMSG,
  76         EXEC_OUTPUT_KMSG_AND_CONSOLE,
  77         EXEC_OUTPUT_JOURNAL,
  78         EXEC_OUTPUT_JOURNAL_AND_CONSOLE,
  79         EXEC_OUTPUT_SOCKET,
  80         _EXEC_OUTPUT_MAX,
  81         _EXEC_OUTPUT_INVALID = -1
  82 } ExecOutput;
  83
  84 struct ExecStatus {
  85         dual_timestamp start_timestamp;
  86         dual_timestamp exit_timestamp;
  87         pid_t pid;
  88         int code;     /* as in siginfo_t::si_code */
  89         int status;   /* as in sigingo_t::si_status */
  90 };
  91
  92 struct ExecCommand {
  93         char *path;
  94         char **argv;
  95         ExecStatus exec_status;
  96         LIST_FIELDS(ExecCommand, command); /* useful for chaining commands */
  97         bool ignore;
  98 };
  99
 100 struct ExecContext {
 101         char **environment;
 102         char **environment_files;
 103
 104         struct rlimit *rlimit[RLIMIT_NLIMITS];
 105         char *working_directory, *root_directory;
 106
 107         mode_t umask;
 108         int oom_score_adjust;
 109         int nice;
 110         int ioprio;
 111         int cpu_sched_policy;
 112         int cpu_sched_priority;
 113
 114         cpu_set_t *cpuset;
 115         unsigned cpuset_ncpus;
 116
 117         ExecInput std_input;
 118         ExecOutput std_output;
 119         ExecOutput std_error;
 120
 121         unsigned long timer_slack_nsec;
 122
 123         char *tcpwrap_name;
 124
 125         char *tty_path;
 126
 127         bool tty_reset;
 128         bool tty_vhangup;
 129         bool tty_vt_disallocate;
 130
 131         bool ignore_sigpipe;
 132
 133         /* Since resolving these names might might involve socket
 134          * connections and we don't want to deadlock ourselves these
 135          * names are resolved on execution only and in the child
 136          * process. */
 137         char *user;
 138         char *group;
 139         char **supplementary_groups;
 140
 141         char *pam_name;
 142
 143         char *utmp_id;
 144
 145         char **read_write_dirs, **read_only_dirs, **inaccessible_dirs;
 146         unsigned long mount_flags;
 147
 148         uint64_t capability_bounding_set_drop;
 149
 150         /* Not relevant for spawning processes, just for killing */
 151         KillMode kill_mode;
 152         int kill_signal;
 153         bool send_sigkill;
 154
 155         cap_t capabilities;
 156         int secure_bits;
 157
 158         int syslog_priority;
 159         char *syslog_identifier;
 160         bool syslog_level_prefix;
 161
 162         bool cpu_sched_reset_on_fork;
 163         bool non_blocking;
 164         bool private_tmp;
 165         bool private_network;
 166
 167         bool control_group_modify;
 168         int control_group_persistent;
 169
 170         /* This is not exposed to the user but available
 171          * internally. We need it to make sure that whenever we spawn
 172          * /bin/mount it is run in the same process group as us so
 173          * that the autofs logic detects that it belongs to us and we
 174          * don't enter a trigger loop. */
 175         bool same_pgrp;
 176
 177         bool oom_score_adjust_set:1;
 178         bool nice_set:1;
 179         bool ioprio_set:1;
 180         bool cpu_sched_set:1;
 181         bool timer_slack_nsec_set:1;
 182 };
 183
 184 int exec_spawn(ExecCommand *command,
 185                char **argv,
 186                const ExecContext *context,
 187                int fds[], unsigned n_fds,
 188                char **environment,
 189                bool apply_permissions,
 190                bool apply_chroot,
 191                bool apply_tty_stdin,
 192                bool confirm_spawn,
 193                struct CGroupBonding *cgroup_bondings,
 194                struct CGroupAttribute *cgroup_attributes,
 195                const char *cgroup_suffix,
 196                int pipe_fd[2],
 197                pid_t *ret);
 198
 199 void exec_command_done(ExecCommand *c);
 200 void exec_command_done_array(ExecCommand *c, unsigned n);
 201
 202 void exec_command_free_list(ExecCommand *c);
 203 void exec_command_free_array(ExecCommand **c, unsigned n);
 204
 205 char *exec_command_line(char **argv);
 206
 207 void exec_command_dump(ExecCommand *c, FILE *f, const char *prefix);
 208 void exec_command_dump_list(ExecCommand *c, FILE *f, const char *prefix);
 209 void exec_command_append_list(ExecCommand **l, ExecCommand *e);
 210 int exec_command_set(ExecCommand *c, const char *path, ...);
 211
 212 void exec_context_init(ExecContext *c);
 213 void exec_context_done(ExecContext *c);
 214 void exec_context_dump(ExecContext *c, FILE* f, const char *prefix);
 215 void exec_context_tty_reset(const ExecContext *context);
 216
 217 int exec_context_load_environment(const ExecContext *c, char ***l);
 218
 219 void exec_status_start(ExecStatus *s, pid_t pid);
 220 void exec_status_exit(ExecStatus *s, ExecContext *context, pid_t pid, int code, int status);
 221 void exec_status_dump(ExecStatus *s, FILE *f, const char *prefix);
 222
 223 const char* exec_output_to_string(ExecOutput i);
 224 ExecOutput exec_output_from_string(const char *s);
 225
 226 const char* exec_input_to_string(ExecInput i);
 227 ExecInput exec_input_from_string(const char *s);
 228
 229 const char *kill_mode_to_string(KillMode k);
 230 KillMode kill_mode_from_string(const char *s);
 231
 232 const char *kill_who_to_string(KillWho k);
 233 KillWho kill_who_from_string(const char *s);
 234
 235 #endif