src/initctl/initctl.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <stdio.h>
  23 #include <errno.h>
  24 #include <unistd.h>
  25 #include <sys/epoll.h>
  26 #include <ctype.h>
  27
  28 #include "sd-daemon.h"
  29 #include "sd-bus.h"
  30
  31 #include "util.h"
  32 #include "log.h"
  33 #include "list.h"
  34 #include "initreq.h"
  35 #include "special.h"
  36 #include "bus-util.h"
  37 #include "bus-error.h"
  38 #include "def.h"
  39 #include "formats-util.h"
  40
  41 #define SERVER_FD_MAX 16
  42 #define TIMEOUT_MSEC ((int) (DEFAULT_EXIT_USEC/USEC_PER_MSEC))
  43
  44 typedef struct Fifo Fifo;
  45
  46 typedef struct Server {
  47         int epoll_fd;
  48
  49         LIST_HEAD(Fifo, fifos);
  50         unsigned n_fifos;
  51
  52         sd_bus *bus;
  53
  54         bool quit;
  55 } Server;
  56
  57 struct Fifo {
  58         Server *server;
  59
  60         int fd;
  61
  62         struct init_request buffer;
  63         size_t bytes_read;
  64
  65         LIST_FIELDS(Fifo, fifo);
  66 };
  67
  68 static const char *translate_runlevel(int runlevel, bool *isolate) {
  69         static const struct {
  70                 const int runlevel;
  71                 const char *special;
  72                 bool isolate;
  73         } table[] = {
  74                 { '0', SPECIAL_POWEROFF_TARGET,   false },
  75                 { '1', SPECIAL_RESCUE_TARGET,     true  },
  76                 { 's', SPECIAL_RESCUE_TARGET,     true  },
  77                 { 'S', SPECIAL_RESCUE_TARGET,     true  },
  78                 { '2', SPECIAL_MULTI_USER_TARGET, true  },
  79                 { '3', SPECIAL_MULTI_USER_TARGET, true  },
  80                 { '4', SPECIAL_MULTI_USER_TARGET, true  },
  81                 { '5', SPECIAL_GRAPHICAL_TARGET,  true  },
  82                 { '6', SPECIAL_REBOOT_TARGET,     false },
  83         };
  84
  85         unsigned i;
  86
  87         assert(isolate);
  88
  89         for (i = 0; i < ELEMENTSOF(table); i++)
  90                 if (table[i].runlevel == runlevel) {
  91                         *isolate = table[i].isolate;
  92                         if (runlevel == '6' && kexec_loaded())
  93                                 return SPECIAL_KEXEC_TARGET;
  94                         return table[i].special;
  95                 }
  96
  97         return NULL;
  98 }
  99
 100 static void change_runlevel(Server *s, int runlevel) {
 101         const char *target;
 102         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 103         const char *mode;
 104         bool isolate = false;
 105         int r;
 106
 107         assert(s);
 108
 109         target = translate_runlevel(runlevel, &isolate);
 110         if (!target) {
 111                 log_warning("Got request for unknown runlevel %c, ignoring.", runlevel);
 112                 return;
 113         }
 114
 115         if (isolate)
 116                 mode = "isolate";
 117         else
 118                 mode = "replace-irreversibly";
 119
 120         log_debug("Running request %s/start/%s", target, mode);
 121
 122         r = sd_bus_call_method(
 123                         s->bus,
 124                         "org.freedesktop.systemd1",
 125                         "/org/freedesktop/systemd1",
 126                         "org.freedesktop.systemd1.Manager",
 127                         "StartUnit",
 128                         &error,
 129                         NULL,
 130                         "ss", target, mode);
 131         if (r < 0) {
 132                 log_error("Failed to change runlevel: %s", bus_error_message(&error, -r));
 133                 return;
 134         }
 135 }
 136
 137 static void request_process(Server *s, const struct init_request *req) {
 138         assert(s);
 139         assert(req);
 140
 141         if (req->magic != INIT_MAGIC) {
 142                 log_error("Got initctl request with invalid magic. Ignoring.");
 143                 return;
 144         }
 145
 146         switch (req->cmd) {
 147
 148         case INIT_CMD_RUNLVL:
 149                 if (!isprint(req->runlevel))
 150                         log_error("Got invalid runlevel. Ignoring.");
 151                 else
 152                         switch (req->runlevel) {
 153
 154                         /* we are async anyway, so just use kill for reexec/reload */
 155                         case 'u':
 156                         case 'U':
 157                                 if (kill(1, SIGTERM) < 0)
 158                                         log_error_errno(errno, "kill() failed: %m");
 159
 160                                 /* The bus connection will be
 161                                  * terminated if PID 1 is reexecuted,
 162                                  * hence let's just exit here, and
 163                                  * rely on that we'll be restarted on
 164                                  * the next request */
 165                                 s->quit = true;
 166                                 break;
 167
 168                         case 'q':
 169                         case 'Q':
 170                                 if (kill(1, SIGHUP) < 0)
 171                                         log_error_errno(errno, "kill() failed: %m");
 172                                 break;
 173
 174                         default:
 175                                 change_runlevel(s, req->runlevel);
 176                         }
 177                 return;
 178
 179         case INIT_CMD_POWERFAIL:
 180         case INIT_CMD_POWERFAILNOW:
 181         case INIT_CMD_POWEROK:
 182                 log_warning("Received UPS/power initctl request. This is not implemented in systemd. Upgrade your UPS daemon!");
 183                 return;
 184
 185         case INIT_CMD_CHANGECONS:
 186                 log_warning("Received console change initctl request. This is not implemented in systemd.");
 187                 return;
 188
 189         case INIT_CMD_SETENV:
 190         case INIT_CMD_UNSETENV:
 191                 log_warning("Received environment initctl request. This is not implemented in systemd.");
 192                 return;
 193
 194         default:
 195                 log_warning("Received unknown initctl request. Ignoring.");
 196                 return;
 197         }
 198 }
 199
 200 static int fifo_process(Fifo *f) {
 201         ssize_t l;
 202
 203         assert(f);
 204
 205         errno = EIO;
 206         l = read(f->fd,
 207                  ((uint8_t*) &f->buffer) + f->bytes_read,
 208                  sizeof(f->buffer) - f->bytes_read);
 209         if (l <= 0) {
 210                 if (errno == EAGAIN)
 211                         return 0;
 212
 213                 log_warning_errno(errno, "Failed to read from fifo: %m");
 214                 return -errno;
 215         }
 216
 217         f->bytes_read += l;
 218         assert(f->bytes_read <= sizeof(f->buffer));
 219
 220         if (f->bytes_read == sizeof(f->buffer)) {
 221                 request_process(f->server, &f->buffer);
 222                 f->bytes_read = 0;
 223         }
 224
 225         return 0;
 226 }
 227
 228 static void fifo_free(Fifo *f) {
 229         assert(f);
 230
 231         if (f->server) {
 232                 assert(f->server->n_fifos > 0);
 233                 f->server->n_fifos--;
 234                 LIST_REMOVE(fifo, f->server->fifos, f);
 235         }
 236
 237         if (f->fd >= 0) {
 238                 if (f->server)
 239                         epoll_ctl(f->server->epoll_fd, EPOLL_CTL_DEL, f->fd, NULL);
 240
 241                 safe_close(f->fd);
 242         }
 243
 244         free(f);
 245 }
 246
 247 static void server_done(Server *s) {
 248         assert(s);
 249
 250         while (s->fifos)
 251                 fifo_free(s->fifos);
 252
 253         safe_close(s->epoll_fd);
 254
 255         if (s->bus) {
 256                 sd_bus_flush(s->bus);
 257                 sd_bus_unref(s->bus);
 258         }
 259 }
 260
 261 static int server_init(Server *s, unsigned n_sockets) {
 262         int r;
 263         unsigned i;
 264
 265         assert(s);
 266         assert(n_sockets > 0);
 267
 268         zero(*s);
 269
 270         s->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
 271         if (s->epoll_fd < 0) {
 272                 r = log_error_errno(errno,
 273                                     "Failed to create epoll object: %m");
 274                 goto fail;
 275         }
 276
 277         for (i = 0; i < n_sockets; i++) {
 278                 struct epoll_event ev;
 279                 Fifo *f;
 280                 int fd;
 281
 282                 fd = SD_LISTEN_FDS_START+i;
 283
 284                 r = sd_is_fifo(fd, NULL);
 285                 if (r < 0) {
 286                         log_error_errno(r, "Failed to determine file descriptor type: %m");
 287                         goto fail;
 288                 }
 289
 290                 if (!r) {
 291                         log_error("Wrong file descriptor type.");
 292                         r = -EINVAL;
 293                         goto fail;
 294                 }
 295
 296                 f = new0(Fifo, 1);
 297                 if (!f) {
 298                         r = -ENOMEM;
 299                         log_error_errno(errno, "Failed to create fifo object: %m");
 300                         goto fail;
 301                 }
 302
 303                 f->fd = -1;
 304
 305                 zero(ev);
 306                 ev.events = EPOLLIN;
 307                 ev.data.ptr = f;
 308                 if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0) {
 309                         r = -errno;
 310                         fifo_free(f);
 311                         log_error_errno(errno, "Failed to add fifo fd to epoll object: %m");
 312                         goto fail;
 313                 }
 314
 315                 f->fd = fd;
 316                 LIST_PREPEND(fifo, s->fifos, f);
 317                 f->server = s;
 318                 s->n_fifos ++;
 319         }
 320
 321         r = bus_open_system_systemd(&s->bus);
 322         if (r < 0) {
 323                 log_error_errno(r, "Failed to get D-Bus connection: %m");
 324                 r = -EIO;
 325                 goto fail;
 326         }
 327
 328         return 0;
 329
 330 fail:
 331         server_done(s);
 332
 333         return r;
 334 }
 335
 336 static int process_event(Server *s, struct epoll_event *ev) {
 337         int r;
 338         Fifo *f;
 339
 340         assert(s);
 341
 342         if (!(ev->events & EPOLLIN)) {
 343                 log_info("Got invalid event from epoll. (3)");
 344                 return -EIO;
 345         }
 346
 347         f = (Fifo*) ev->data.ptr;
 348         r = fifo_process(f);
 349         if (r < 0) {
 350                 log_info_errno(r, "Got error on fifo: %m");
 351                 fifo_free(f);
 352                 return r;
 353         }
 354
 355         return 0;
 356 }
 357
 358 int main(int argc, char *argv[]) {
 359         Server server;
 360         int r = EXIT_FAILURE, n;
 361
 362         if (getppid() != 1) {
 363                 log_error("This program should be invoked by init only.");
 364                 return EXIT_FAILURE;
 365         }
 366
 367         if (argc > 1) {
 368                 log_error("This program does not take arguments.");
 369                 return EXIT_FAILURE;
 370         }
 371
 372         log_set_target(LOG_TARGET_AUTO);
 373         log_parse_environment();
 374         log_open();
 375
 376         umask(0022);
 377
 378         n = sd_listen_fds(true);
 379         if (n < 0) {
 380                 log_error_errno(r, "Failed to read listening file descriptors from environment: %m");
 381                 return EXIT_FAILURE;
 382         }
 383
 384         if (n <= 0 || n > SERVER_FD_MAX) {
 385                 log_error("No or too many file descriptors passed.");
 386                 return EXIT_FAILURE;
 387         }
 388
 389         if (server_init(&server, (unsigned) n) < 0)
 390                 return EXIT_FAILURE;
 391
 392         log_debug("systemd-initctl running as pid "PID_FMT, getpid());
 393
 394         sd_notify(false,
 395                   "READY=1\n"
 396                   "STATUS=Processing requests...");
 397
 398         while (!server.quit) {
 399                 struct epoll_event event;
 400                 int k;
 401
 402                 k = epoll_wait(server.epoll_fd, &event, 1, TIMEOUT_MSEC);
 403                 if (k < 0) {
 404                         if (errno == EINTR)
 405                                 continue;
 406                         log_error_errno(errno, "epoll_wait() failed: %m");
 407                         goto fail;
 408                 }
 409
 410                 if (k <= 0)
 411                         break;
 412
 413                 if (process_event(&server, &event) < 0)
 414                         goto fail;
 415         }
 416
 417         r = EXIT_SUCCESS;
 418
 419         log_debug("systemd-initctl stopped as pid "PID_FMT, getpid());
 420
 421 fail:
 422         sd_notify(false,
 423                   "STOPPING=1\n"
 424                   "STATUS=Shutting down...");
 425
 426         server_done(&server);
 427
 428         return r;
 429 }