src/core/busname.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2013 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 <sys/mman.h>
  23
  24 #include "special.h"
  25 #include "bus-kernel.h"
  26 #include "bus-internal.h"
  27 #include "bus-util.h"
  28 #include "service.h"
  29 #include "dbus-busname.h"
  30 #include "busname.h"
  31 #include "kdbus.h"
  32
  33 static const UnitActiveState state_translation_table[_BUSNAME_STATE_MAX] = {
  34         [BUSNAME_DEAD] = UNIT_INACTIVE,
  35         [BUSNAME_MAKING] = UNIT_ACTIVATING,
  36         [BUSNAME_REGISTERED] = UNIT_ACTIVE,
  37         [BUSNAME_LISTENING] = UNIT_ACTIVE,
  38         [BUSNAME_RUNNING] = UNIT_ACTIVE,
  39         [BUSNAME_SIGTERM] = UNIT_DEACTIVATING,
  40         [BUSNAME_SIGKILL] = UNIT_DEACTIVATING,
  41         [BUSNAME_FAILED] = UNIT_FAILED
  42 };
  43
  44 static int busname_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
  45 static int busname_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
  46
  47 static void busname_init(Unit *u) {
  48         BusName *n = BUSNAME(u);
  49
  50         assert(u);
  51         assert(u->load_state == UNIT_STUB);
  52
  53         n->starter_fd = -1;
  54         n->accept_fd = true;
  55         n->activating = true;
  56
  57         n->timeout_usec = u->manager->default_timeout_start_usec;
  58 }
  59
  60 static void busname_unwatch_control_pid(BusName *n) {
  61         assert(n);
  62
  63         if (n->control_pid <= 0)
  64                 return;
  65
  66         unit_unwatch_pid(UNIT(n), n->control_pid);
  67         n->control_pid = 0;
  68 }
  69
  70 static void busname_free_policy(BusName *n) {
  71         BusNamePolicy *p;
  72
  73         assert(n);
  74
  75         while ((p = n->policy)) {
  76                 LIST_REMOVE(policy, n->policy, p);
  77
  78                 free(p->name);
  79                 free(p);
  80         }
  81 }
  82
  83 static void busname_close_fd(BusName *n) {
  84         assert(n);
  85
  86         n->starter_event_source = sd_event_source_unref(n->starter_event_source);
  87         n->starter_fd = safe_close(n->starter_fd);
  88 }
  89
  90 static void busname_done(Unit *u) {
  91         BusName *n = BUSNAME(u);
  92
  93         assert(n);
  94
  95         free(n->name);
  96         n->name = NULL;
  97
  98         busname_free_policy(n);
  99         busname_unwatch_control_pid(n);
 100         busname_close_fd(n);
 101
 102         unit_ref_unset(&n->service);
 103
 104         n->timer_event_source = sd_event_source_unref(n->timer_event_source);
 105 }
 106
 107 static int busname_arm_timer(BusName *n) {
 108         int r;
 109
 110         assert(n);
 111
 112         if (n->timeout_usec <= 0) {
 113                 n->timer_event_source = sd_event_source_unref(n->timer_event_source);
 114                 return 0;
 115         }
 116
 117         if (n->timer_event_source) {
 118                 r = sd_event_source_set_time(n->timer_event_source, now(CLOCK_MONOTONIC) + n->timeout_usec);
 119                 if (r < 0)
 120                         return r;
 121
 122                 return sd_event_source_set_enabled(n->timer_event_source, SD_EVENT_ONESHOT);
 123         }
 124
 125         return sd_event_add_time(
 126                         UNIT(n)->manager->event,
 127                         &n->timer_event_source,
 128                         CLOCK_MONOTONIC,
 129                         now(CLOCK_MONOTONIC) + n->timeout_usec, 0,
 130                         busname_dispatch_timer, n);
 131 }
 132
 133 static int busname_add_default_default_dependencies(BusName *n) {
 134         int r;
 135
 136         assert(n);
 137
 138         r = unit_add_dependency_by_name(UNIT(n), UNIT_BEFORE, SPECIAL_BUSNAMES_TARGET, NULL, true);
 139         if (r < 0)
 140                 return r;
 141
 142         if (UNIT(n)->manager->running_as == SYSTEMD_SYSTEM) {
 143                 r = unit_add_two_dependencies_by_name(UNIT(n), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
 144                 if (r < 0)
 145                         return r;
 146         }
 147
 148         return unit_add_two_dependencies_by_name(UNIT(n), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
 149 }
 150
 151 static int busname_add_extras(BusName *n) {
 152         Unit *u = UNIT(n);
 153         int r;
 154
 155         assert(n);
 156
 157         if (!n->name) {
 158                 n->name = unit_name_to_prefix(u->id);
 159                 if (!n->name)
 160                         return -ENOMEM;
 161         }
 162
 163         if (!u->description) {
 164                 r = unit_set_description(u, n->name);
 165                 if (r < 0)
 166                         return r;
 167         }
 168
 169         if (n->activating) {
 170                 if (!UNIT_DEREF(n->service)) {
 171                         Unit *x;
 172
 173                         r = unit_load_related_unit(u, ".service", &x);
 174                         if (r < 0)
 175                                 return r;
 176
 177                         unit_ref_set(&n->service, x);
 178                 }
 179
 180                 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(n->service), true);
 181                 if (r < 0)
 182                         return r;
 183         }
 184
 185         if (u->default_dependencies) {
 186                 r = busname_add_default_default_dependencies(n);
 187                 if (r < 0)
 188                         return r;
 189         }
 190
 191         return 0;
 192 }
 193
 194 static int busname_verify(BusName *n) {
 195         char *e;
 196
 197         assert(n);
 198
 199         if (UNIT(n)->load_state != UNIT_LOADED)
 200                 return 0;
 201
 202         if (!service_name_is_valid(n->name)) {
 203                 log_error_unit(UNIT(n)->id, "%s's Name= setting is not a valid service name Refusing.", UNIT(n)->id);
 204                 return -EINVAL;
 205         }
 206
 207         e = strappenda(n->name, ".busname");
 208         if (!unit_has_name(UNIT(n), e)) {
 209                 log_error_unit(UNIT(n)->id, "%s's Name= setting doesn't match unit name. Refusing.", UNIT(n)->id);
 210                 return -EINVAL;
 211         }
 212
 213         return 0;
 214 }
 215
 216 static int busname_load(Unit *u) {
 217         BusName *n = BUSNAME(u);
 218         int r;
 219
 220         assert(u);
 221         assert(u->load_state == UNIT_STUB);
 222
 223         r = unit_load_fragment_and_dropin(u);
 224         if (r < 0)
 225                 return r;
 226
 227         if (u->load_state == UNIT_LOADED) {
 228                 /* This is a new unit? Then let's add in some extras */
 229                 r = busname_add_extras(n);
 230                 if (r < 0)
 231                         return r;
 232         }
 233
 234         return busname_verify(n);
 235 }
 236
 237 static void busname_dump(Unit *u, FILE *f, const char *prefix) {
 238         BusName *n = BUSNAME(u);
 239
 240         assert(n);
 241         assert(f);
 242
 243         fprintf(f,
 244                 "%sBus Name State: %s\n"
 245                 "%sResult: %s\n"
 246                 "%sName: %s\n"
 247                 "%sActivating: %s\n"
 248                 "%sAccept FD: %s\n",
 249                 prefix, busname_state_to_string(n->state),
 250                 prefix, busname_result_to_string(n->result),
 251                 prefix, n->name,
 252                 prefix, yes_no(n->activating),
 253                 prefix, yes_no(n->accept_fd));
 254
 255         if (n->control_pid > 0)
 256                 fprintf(f,
 257                         "%sControl PID: "PID_FMT"\n",
 258                         prefix, n->control_pid);
 259 }
 260
 261 static void busname_unwatch_fd(BusName *n) {
 262         int r;
 263
 264         assert(n);
 265
 266         if (!n->starter_event_source)
 267                 return;
 268
 269         r = sd_event_source_set_enabled(n->starter_event_source, SD_EVENT_OFF);
 270         if (r < 0)
 271                 log_debug_unit(UNIT(n)->id, "Failed to disable event source.");
 272 }
 273
 274 static int busname_watch_fd(BusName *n) {
 275         int r;
 276
 277         assert(n);
 278
 279         if (n->starter_fd < 0)
 280                 return 0;
 281
 282         if (n->starter_event_source)
 283                 r = sd_event_source_set_enabled(n->starter_event_source, SD_EVENT_ON);
 284         else
 285                 r = sd_event_add_io(UNIT(n)->manager->event, &n->starter_event_source, n->starter_fd, EPOLLIN, busname_dispatch_io, n);
 286         if (r < 0) {
 287                 log_warning_unit(UNIT(n)->id, "Failed to watch starter fd: %s", strerror(-r));
 288                 busname_unwatch_fd(n);
 289                 return r;
 290         }
 291
 292         return 0;
 293 }
 294
 295 static int busname_open_fd(BusName *n) {
 296         _cleanup_free_ char *path = NULL;
 297         const char *mode;
 298
 299         assert(n);
 300
 301         if (n->starter_fd >= 0)
 302                 return 0;
 303
 304         mode = UNIT(n)->manager->running_as == SYSTEMD_SYSTEM ? "system" : "user";
 305         n->starter_fd = bus_kernel_open_bus_fd(mode, &path);
 306         if (n->starter_fd < 0) {
 307                 log_warning_unit(UNIT(n)->id, "Failed to open %s: %s", path ?: "kdbus", strerror(-n->starter_fd));
 308                 return n->starter_fd;
 309         }
 310
 311         return 0;
 312 }
 313
 314 static void busname_set_state(BusName *n, BusNameState state) {
 315         BusNameState old_state;
 316         assert(n);
 317
 318         old_state = n->state;
 319         n->state = state;
 320
 321         if (!IN_SET(state, BUSNAME_MAKING, BUSNAME_SIGTERM, BUSNAME_SIGKILL)) {
 322                 n->timer_event_source = sd_event_source_unref(n->timer_event_source);
 323                 busname_unwatch_control_pid(n);
 324         }
 325
 326         if (state != BUSNAME_LISTENING)
 327                 busname_unwatch_fd(n);
 328
 329         if (!IN_SET(state, BUSNAME_LISTENING, BUSNAME_MAKING, BUSNAME_REGISTERED, BUSNAME_RUNNING))
 330                 busname_close_fd(n);
 331
 332         if (state != old_state)
 333                 log_debug_unit(UNIT(n)->id, "%s changed %s -> %s",
 334                                UNIT(n)->id, busname_state_to_string(old_state), busname_state_to_string(state));
 335
 336         unit_notify(UNIT(n), state_translation_table[old_state], state_translation_table[state], true);
 337 }
 338
 339 static int busname_coldplug(Unit *u) {
 340         BusName *n = BUSNAME(u);
 341         int r;
 342
 343         assert(n);
 344         assert(n->state == BUSNAME_DEAD);
 345
 346         if (n->deserialized_state == n->state)
 347                 return 0;
 348
 349         if (IN_SET(n->deserialized_state, BUSNAME_MAKING, BUSNAME_SIGTERM, BUSNAME_SIGKILL)) {
 350
 351                 if (n->control_pid <= 0)
 352                         return -EBADMSG;
 353
 354                 r = unit_watch_pid(UNIT(n), n->control_pid);
 355                 if (r < 0)
 356                         return r;
 357
 358                 r = busname_arm_timer(n);
 359                 if (r < 0)
 360                         return r;
 361         }
 362
 363         if (IN_SET(n->deserialized_state, BUSNAME_MAKING, BUSNAME_LISTENING, BUSNAME_REGISTERED, BUSNAME_RUNNING)) {
 364                 r = busname_open_fd(n);
 365                 if (r < 0)
 366                         return r;
 367         }
 368
 369         if (n->deserialized_state == BUSNAME_LISTENING) {
 370                 r = busname_watch_fd(n);
 371                 if (r < 0)
 372                         return r;
 373         }
 374
 375         busname_set_state(n, n->deserialized_state);
 376         return 0;
 377 }
 378
 379 static int busname_make_starter(BusName *n, pid_t *_pid) {
 380         pid_t pid;
 381         int r;
 382
 383         r = busname_arm_timer(n);
 384         if (r < 0)
 385                 goto fail;
 386
 387         /* We have to resolve the user/group names out-of-process,
 388          * hence let's fork here. It's messy, but well, what can we
 389          * do? */
 390
 391         pid = fork();
 392         if (pid < 0)
 393                 return -errno;
 394
 395         if (pid == 0) {
 396                 int ret;
 397
 398                 default_signals(SIGNALS_CRASH_HANDLER, SIGNALS_IGNORE, -1);
 399                 ignore_signals(SIGPIPE, -1);
 400                 log_forget_fds();
 401
 402                 r = bus_kernel_make_starter(n->starter_fd, n->name, n->activating, n->accept_fd, n->policy, n->policy_world);
 403                 if (r < 0) {
 404                         ret = EXIT_MAKE_STARTER;
 405                         goto fail_child;
 406                 }
 407
 408                 _exit(0);
 409
 410         fail_child:
 411                 log_open();
 412                 log_error("Failed to create starter connection at step %s: %s", exit_status_to_string(ret, EXIT_STATUS_SYSTEMD), strerror(-r));
 413
 414                 _exit(ret);
 415         }
 416
 417         r = unit_watch_pid(UNIT(n), pid);
 418         if (r < 0)
 419                 goto fail;
 420
 421         *_pid = pid;
 422         return 0;
 423
 424 fail:
 425         n->timer_event_source = sd_event_source_unref(n->timer_event_source);
 426         return r;
 427 }
 428
 429 static void busname_enter_dead(BusName *n, BusNameResult f) {
 430         assert(n);
 431
 432         if (f != BUSNAME_SUCCESS)
 433                 n->result = f;
 434
 435         busname_set_state(n, n->result != BUSNAME_SUCCESS ? BUSNAME_FAILED : BUSNAME_DEAD);
 436 }
 437
 438 static void busname_enter_signal(BusName *n, BusNameState state, BusNameResult f) {
 439         KillContext kill_context = {};
 440         int r;
 441
 442         assert(n);
 443
 444         if (f != BUSNAME_SUCCESS)
 445                 n->result = f;
 446
 447         kill_context_init(&kill_context);
 448
 449         r = unit_kill_context(UNIT(n),
 450                               &kill_context,
 451                               state != BUSNAME_SIGTERM ? KILL_KILL : KILL_TERMINATE,
 452                               -1,
 453                               n->control_pid,
 454                               false);
 455         if (r < 0) {
 456                 log_warning_unit(UNIT(n)->id, "%s failed to kill control process: %s", UNIT(n)->id, strerror(-r));
 457                 goto fail;
 458         }
 459
 460         if (r > 0) {
 461                 r = busname_arm_timer(n);
 462                 if (r < 0) {
 463                         log_warning_unit(UNIT(n)->id, "%s failed to arm timer: %s", UNIT(n)->id, strerror(-r));
 464                         goto fail;
 465                 }
 466
 467                 busname_set_state(n, state);
 468         } else if (state == BUSNAME_SIGTERM)
 469                 busname_enter_signal(n, BUSNAME_SIGKILL, BUSNAME_SUCCESS);
 470         else
 471                 busname_enter_dead(n, BUSNAME_SUCCESS);
 472
 473         return;
 474
 475 fail:
 476         busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
 477 }
 478
 479 static void busname_enter_listening(BusName *n) {
 480         int r;
 481
 482         assert(n);
 483
 484         if (n->activating) {
 485                 r = busname_watch_fd(n);
 486                 if (r < 0) {
 487                         log_warning_unit(UNIT(n)->id, "%s failed to watch names: %s", UNIT(n)->id, strerror(-r));
 488                         goto fail;
 489                 }
 490
 491                 busname_set_state(n, BUSNAME_LISTENING);
 492         } else
 493                 busname_set_state(n, BUSNAME_REGISTERED);
 494
 495         return;
 496
 497 fail:
 498         busname_enter_signal(n, BUSNAME_SIGTERM, BUSNAME_FAILURE_RESOURCES);
 499 }
 500
 501 static void busname_enter_making(BusName *n) {
 502         int r;
 503
 504         assert(n);
 505
 506         r = busname_open_fd(n);
 507         if (r < 0)
 508                 goto fail;
 509
 510         if (n->policy) {
 511                 /* If there is a policy, we need to resolve user/group
 512                  * names, which we can't do from PID1, hence let's
 513                  * fork. */
 514                 busname_unwatch_control_pid(n);
 515
 516                 r = busname_make_starter(n, &n->control_pid);
 517                 if (r < 0) {
 518                         log_warning_unit(UNIT(n)->id, "%s failed to fork 'making' task: %s", UNIT(n)->id, strerror(-r));
 519                         goto fail;
 520                 }
 521
 522                 busname_set_state(n, BUSNAME_MAKING);
 523         } else {
 524                 /* If there is no policy, we can do everything
 525                  * directly from PID 1, hence do so. */
 526
 527                 r = bus_kernel_make_starter(n->starter_fd, n->name, n->activating, n->accept_fd, NULL, n->policy_world);
 528                 if (r < 0) {
 529                         log_warning_unit(UNIT(n)->id, "%s failed to make starter: %s", UNIT(n)->id, strerror(-r));
 530                         goto fail;
 531                 }
 532
 533                 busname_enter_listening(n);
 534         }
 535
 536         return;
 537
 538 fail:
 539         busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
 540 }
 541
 542 static void busname_enter_running(BusName *n) {
 543         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 544         bool pending = false;
 545         Unit *other;
 546         Iterator i;
 547         int r;
 548
 549         assert(n);
 550
 551         if (!n->activating)
 552                 return;
 553
 554         /* We don't take conenctions anymore if we are supposed to
 555          * shut down anyway */
 556
 557         if (unit_stop_pending(UNIT(n))) {
 558                 log_debug_unit(UNIT(n)->id, "Suppressing activation request on %s since unit stop is scheduled.", UNIT(n)->id);
 559
 560                 /* Flush all queued activation reqeuest by closing and reopening the connection */
 561                 bus_kernel_drop_one(n->starter_fd);
 562
 563                 busname_enter_listening(n);
 564                 return;
 565         }
 566
 567         /* If there's already a start pending don't bother to do
 568          * anything */
 569         SET_FOREACH(other, UNIT(n)->dependencies[UNIT_TRIGGERS], i)
 570                 if (unit_active_or_pending(other)) {
 571                         pending = true;
 572                         break;
 573                 }
 574
 575         if (!pending) {
 576                 r = manager_add_job(UNIT(n)->manager, JOB_START, UNIT_DEREF(n->service), JOB_REPLACE, true, &error, NULL);
 577                 if (r < 0)
 578                         goto fail;
 579         }
 580
 581         busname_set_state(n, BUSNAME_RUNNING);
 582         return;
 583
 584 fail:
 585         log_warning_unit(UNIT(n)->id, "%s failed to queue service startup job: %s", UNIT(n)->id, bus_error_message(&error, r));
 586         busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
 587 }
 588
 589 static int busname_start(Unit *u) {
 590         BusName *n = BUSNAME(u);
 591
 592         assert(n);
 593
 594         /* We cannot fulfill this request right now, try again later
 595          * please! */
 596         if (IN_SET(n->state, BUSNAME_SIGTERM, BUSNAME_SIGKILL))
 597                 return -EAGAIN;
 598
 599         /* Already on it! */
 600         if (n->state == BUSNAME_MAKING)
 601                 return 0;
 602
 603         if (n->activating && UNIT_ISSET(n->service)) {
 604                 Service *service;
 605
 606                 service = SERVICE(UNIT_DEREF(n->service));
 607
 608                 if (UNIT(service)->load_state != UNIT_LOADED) {
 609                         log_error_unit(u->id, "Bus service %s not loaded, refusing.", UNIT(service)->id);
 610                         return -ENOENT;
 611                 }
 612         }
 613
 614         assert(IN_SET(n->state, BUSNAME_DEAD, BUSNAME_FAILED));
 615
 616         n->result = BUSNAME_SUCCESS;
 617         busname_enter_making(n);
 618
 619         return 0;
 620 }
 621
 622 static int busname_stop(Unit *u) {
 623         BusName *n = BUSNAME(u);
 624
 625         assert(n);
 626
 627         /* Already on it */
 628         if (IN_SET(n->state, BUSNAME_SIGTERM, BUSNAME_SIGKILL))
 629                 return 0;
 630
 631         /* If there's already something running, we go directly into
 632          * kill mode. */
 633
 634         if (n->state == BUSNAME_MAKING) {
 635                 busname_enter_signal(n, BUSNAME_SIGTERM, BUSNAME_SUCCESS);
 636                 return -EAGAIN;
 637         }
 638
 639         assert(IN_SET(n->state, BUSNAME_REGISTERED, BUSNAME_LISTENING, BUSNAME_RUNNING));
 640
 641         busname_enter_dead(n, BUSNAME_SUCCESS);
 642         return 0;
 643 }
 644
 645 static int busname_serialize(Unit *u, FILE *f, FDSet *fds) {
 646         BusName *n = BUSNAME(u);
 647
 648         assert(n);
 649         assert(f);
 650         assert(fds);
 651
 652         unit_serialize_item(u, f, "state", busname_state_to_string(n->state));
 653         unit_serialize_item(u, f, "result", busname_result_to_string(n->result));
 654
 655         if (n->control_pid > 0)
 656                 unit_serialize_item_format(u, f, "control-pid", PID_FMT, n->control_pid);
 657
 658         if (n->starter_fd >= 0) {
 659                 int copy;
 660
 661                 copy = fdset_put_dup(fds, n->starter_fd);
 662                 if (copy < 0)
 663                         return copy;
 664
 665                 unit_serialize_item_format(u, f, "starter-fd", "%i", copy);
 666         }
 667
 668         return 0;
 669 }
 670
 671 static int busname_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
 672         BusName *n = BUSNAME(u);
 673
 674         assert(n);
 675         assert(key);
 676         assert(value);
 677
 678         if (streq(key, "state")) {
 679                 BusNameState state;
 680
 681                 state = busname_state_from_string(value);
 682                 if (state < 0)
 683                         log_debug_unit(u->id, "Failed to parse state value %s", value);
 684                 else
 685                         n->deserialized_state = state;
 686
 687         } else if (streq(key, "result")) {
 688                 BusNameResult f;
 689
 690                 f = busname_result_from_string(value);
 691                 if (f < 0)
 692                         log_debug_unit(u->id, "Failed to parse result value %s", value);
 693                 else if (f != BUSNAME_SUCCESS)
 694                         n->result = f;
 695
 696         } else if (streq(key, "control-pid")) {
 697                 pid_t pid;
 698
 699                 if (parse_pid(value, &pid) < 0)
 700                         log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
 701                 else
 702                         n->control_pid = pid;
 703         } else if (streq(key, "starter-fd")) {
 704                 int fd;
 705
 706                 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
 707                         log_debug_unit(u->id, "Failed to parse starter fd value %s", value);
 708                 else {
 709                         safe_close(n->starter_fd);
 710                         n->starter_fd = fdset_remove(fds, fd);
 711                 }
 712         } else
 713                 log_debug_unit(u->id, "Unknown serialization key '%s'", key);
 714
 715         return 0;
 716 }
 717
 718 _pure_ static UnitActiveState busname_active_state(Unit *u) {
 719         assert(u);
 720
 721         return state_translation_table[BUSNAME(u)->state];
 722 }
 723
 724 _pure_ static const char *busname_sub_state_to_string(Unit *u) {
 725         assert(u);
 726
 727         return busname_state_to_string(BUSNAME(u)->state);
 728 }
 729
 730 static int busname_peek_message(BusName *n) {
 731         struct kdbus_cmd_recv cmd_recv = {
 732                 .flags = KDBUS_RECV_PEEK,
 733         };
 734         const char *comm = NULL;
 735         struct kdbus_item *d;
 736         struct kdbus_msg *k;
 737         size_t start, ps, sz, delta;
 738         void *p = NULL;
 739         pid_t pid = 0;
 740         int r;
 741
 742         assert(n);
 743
 744         /* Generate a friendly log message about which process caused
 745          * triggering of this bus name. This simply peeks the metadata
 746          * of the first queued message and logs it. */
 747
 748         r = ioctl(n->starter_fd, KDBUS_CMD_MSG_RECV, &cmd_recv);
 749         if (r < 0) {
 750                 if (errno == EINTR || errno == EAGAIN)
 751                         return 0;
 752
 753                 log_error_unit(UNIT(n)->id, "%s: Failed to query activation message: %m", UNIT(n)->id);
 754                 return -errno;
 755         }
 756
 757         /* We map as late as possible, and unmap imemdiately after
 758          * use. On 32bit address space is scarce and we want to be
 759          * able to handle a lot of activator connections at the same
 760          * time, and hence shouldn't keep the mmap()s around for
 761          * longer than necessary. */
 762
 763         ps = page_size();
 764         start = (cmd_recv.offset / ps) * ps;
 765         delta = cmd_recv.offset - start;
 766         sz = PAGE_ALIGN(delta + cmd_recv.msg_size);
 767
 768         p = mmap(NULL, sz, PROT_READ, MAP_SHARED, n->starter_fd, start);
 769         if (p == MAP_FAILED) {
 770                 log_error_unit(UNIT(n)->id, "%s: Failed to map activation message: %m", UNIT(n)->id);
 771                 r = -errno;
 772                 goto finish;
 773         }
 774
 775         k = (struct kdbus_msg *) ((uint8_t *) p + delta);
 776         KDBUS_ITEM_FOREACH(d, k, items) {
 777                 switch (d->type) {
 778
 779                 case KDBUS_ITEM_PIDS:
 780                         pid = d->pids.pid;
 781                         break;
 782
 783                 case KDBUS_ITEM_PID_COMM:
 784                         comm = d->str;
 785                         break;
 786                 }
 787         }
 788
 789         if (pid > 0)
 790                 log_debug_unit(UNIT(n)->id, "%s: Activation triggered by process " PID_FMT " (%s)", UNIT(n)->id, pid, strna(comm));
 791
 792         r = 0;
 793
 794 finish:
 795         if (p)
 796                 (void) munmap(p, sz);
 797
 798         /* Hint: we don't invoke KDBUS_CMD_MSG_FREE here, as we only
 799          * PEEKed the message, and didn't ask for it to be dropped
 800          * from the queue. */
 801
 802         return r;
 803 }
 804
 805 static int busname_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
 806         BusName *n = userdata;
 807
 808         assert(n);
 809         assert(fd >= 0);
 810
 811         if (n->state != BUSNAME_LISTENING)
 812                 return 0;
 813
 814         log_debug_unit(UNIT(n)->id, "Activation request on %s", UNIT(n)->id);
 815
 816         if (revents != EPOLLIN) {
 817                 log_error_unit(UNIT(n)->id, "%s: Got unexpected poll event (0x%x) on starter fd.",
 818                                UNIT(n)->id, revents);
 819                 goto fail;
 820         }
 821
 822         busname_peek_message(n);
 823         busname_enter_running(n);
 824         return 0;
 825 fail:
 826
 827         busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
 828         return 0;
 829 }
 830
 831 static void busname_sigchld_event(Unit *u, pid_t pid, int code, int status) {
 832         BusName *n = BUSNAME(u);
 833         BusNameResult f;
 834
 835         assert(n);
 836         assert(pid >= 0);
 837
 838         if (pid != n->control_pid)
 839                 return;
 840
 841         n->control_pid = 0;
 842
 843         if (is_clean_exit(code, status, NULL))
 844                 f = BUSNAME_SUCCESS;
 845         else if (code == CLD_EXITED)
 846                 f = BUSNAME_FAILURE_EXIT_CODE;
 847         else if (code == CLD_KILLED)
 848                 f = BUSNAME_FAILURE_SIGNAL;
 849         else if (code == CLD_DUMPED)
 850                 f = BUSNAME_FAILURE_CORE_DUMP;
 851         else
 852                 assert_not_reached("Unknown sigchld code");
 853
 854         log_full_unit(f == BUSNAME_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
 855                       u->id, "%s control process exited, code=%s status=%i",
 856                       u->id, sigchld_code_to_string(code), status);
 857
 858         if (f != BUSNAME_SUCCESS)
 859                 n->result = f;
 860
 861         switch (n->state) {
 862
 863         case BUSNAME_MAKING:
 864                 if (f == BUSNAME_SUCCESS)
 865                         busname_enter_listening(n);
 866                 else
 867                         busname_enter_signal(n, BUSNAME_SIGTERM, f);
 868                 break;
 869
 870         case BUSNAME_SIGTERM:
 871         case BUSNAME_SIGKILL:
 872                 busname_enter_dead(n, f);
 873                 break;
 874
 875         default:
 876                 assert_not_reached("Uh, control process died at wrong time.");
 877         }
 878
 879         /* Notify clients about changed exit status */
 880         unit_add_to_dbus_queue(u);
 881 }
 882
 883 static int busname_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
 884         BusName *n = BUSNAME(userdata);
 885
 886         assert(n);
 887         assert(n->timer_event_source == source);
 888
 889         switch (n->state) {
 890
 891         case BUSNAME_MAKING:
 892                 log_warning_unit(UNIT(n)->id, "%s making timed out. Terminating.", UNIT(n)->id);
 893                 busname_enter_signal(n, BUSNAME_SIGTERM, BUSNAME_FAILURE_TIMEOUT);
 894                 break;
 895
 896         case BUSNAME_SIGTERM:
 897                 log_warning_unit(UNIT(n)->id, "%s stopping timed out. Killing.", UNIT(n)->id);
 898                 busname_enter_signal(n, BUSNAME_SIGKILL, BUSNAME_FAILURE_TIMEOUT);
 899                 break;
 900
 901         case BUSNAME_SIGKILL:
 902                 log_warning_unit(UNIT(n)->id, "%s still around after SIGKILL. Ignoring.", UNIT(n)->id);
 903                 busname_enter_dead(n, BUSNAME_FAILURE_TIMEOUT);
 904                 break;
 905
 906         default:
 907                 assert_not_reached("Timeout at wrong time.");
 908         }
 909
 910         return 0;
 911 }
 912
 913 static void busname_reset_failed(Unit *u) {
 914         BusName *n = BUSNAME(u);
 915
 916         assert(n);
 917
 918         if (n->state == BUSNAME_FAILED)
 919                 busname_set_state(n, BUSNAME_DEAD);
 920
 921         n->result = BUSNAME_SUCCESS;
 922 }
 923
 924 static void busname_trigger_notify(Unit *u, Unit *other) {
 925         BusName *n = BUSNAME(u);
 926         Service *s;
 927
 928         assert(n);
 929         assert(other);
 930
 931         if (!IN_SET(n->state, BUSNAME_RUNNING, BUSNAME_LISTENING))
 932                 return;
 933
 934         if (other->load_state != UNIT_LOADED || other->type != UNIT_SERVICE)
 935                 return;
 936
 937         s = SERVICE(other);
 938
 939         if (s->state == SERVICE_FAILED && s->result == SERVICE_FAILURE_START_LIMIT)
 940                 busname_enter_dead(n, BUSNAME_FAILURE_SERVICE_FAILED_PERMANENT);
 941         else if (IN_SET(s->state,
 942                         SERVICE_DEAD, SERVICE_FAILED,
 943                         SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
 944                         SERVICE_STOP_POST, SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
 945                         SERVICE_AUTO_RESTART))
 946                 busname_enter_listening(n);
 947 }
 948
 949 static int busname_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
 950         return unit_kill_common(u, who, signo, -1, BUSNAME(u)->control_pid, error);
 951 }
 952
 953 static int busname_get_timeout(Unit *u, uint64_t *timeout) {
 954         BusName *n = BUSNAME(u);
 955         int r;
 956
 957         if (!n->timer_event_source)
 958                 return 0;
 959
 960         r = sd_event_source_get_time(n->timer_event_source, timeout);
 961         if (r < 0)
 962                 return r;
 963
 964         return 1;
 965 }
 966
 967 static const char* const busname_state_table[_BUSNAME_STATE_MAX] = {
 968         [BUSNAME_DEAD] = "dead",
 969         [BUSNAME_MAKING] = "making",
 970         [BUSNAME_REGISTERED] = "registered",
 971         [BUSNAME_LISTENING] = "listening",
 972         [BUSNAME_RUNNING] = "running",
 973         [BUSNAME_SIGTERM] = "sigterm",
 974         [BUSNAME_SIGKILL] = "sigkill",
 975         [BUSNAME_FAILED] = "failed",
 976 };
 977
 978 DEFINE_STRING_TABLE_LOOKUP(busname_state, BusNameState);
 979
 980 static const char* const busname_result_table[_BUSNAME_RESULT_MAX] = {
 981         [BUSNAME_SUCCESS] = "success",
 982         [BUSNAME_FAILURE_RESOURCES] = "resources",
 983         [BUSNAME_FAILURE_TIMEOUT] = "timeout",
 984         [BUSNAME_FAILURE_EXIT_CODE] = "exit-code",
 985         [BUSNAME_FAILURE_SIGNAL] = "signal",
 986         [BUSNAME_FAILURE_CORE_DUMP] = "core-dump",
 987         [BUSNAME_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent",
 988 };
 989
 990 DEFINE_STRING_TABLE_LOOKUP(busname_result, BusNameResult);
 991
 992 const UnitVTable busname_vtable = {
 993         .object_size = sizeof(BusName),
 994
 995         .sections =
 996                 "Unit\0"
 997                 "BusName\0"
 998                 "Install\0",
 999         .private_section = "BusName",
1000
1001         .init = busname_init,
1002         .done = busname_done,
1003         .load = busname_load,
1004
1005         .coldplug = busname_coldplug,
1006
1007         .dump = busname_dump,
1008
1009         .start = busname_start,
1010         .stop = busname_stop,
1011
1012         .kill = busname_kill,
1013
1014         .get_timeout = busname_get_timeout,
1015
1016         .serialize = busname_serialize,
1017         .deserialize_item = busname_deserialize_item,
1018
1019         .active_state = busname_active_state,
1020         .sub_state_to_string = busname_sub_state_to_string,
1021
1022         .sigchld_event = busname_sigchld_event,
1023
1024         .trigger_notify = busname_trigger_notify,
1025
1026         .reset_failed = busname_reset_failed,
1027
1028         .bus_interface = "org.freedesktop.systemd1.BusName",
1029         .bus_vtable = bus_busname_vtable,
1030
1031         .status_message_formats = {
1032                 .finished_start_job = {
1033                         [JOB_DONE]       = "Listening on %s.",
1034                         [JOB_FAILED]     = "Failed to listen on %s.",
1035                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
1036                         [JOB_TIMEOUT]    = "Timed out starting %s.",
1037                 },
1038                 .finished_stop_job = {
1039                         [JOB_DONE]       = "Closed %s.",
1040                         [JOB_FAILED]     = "Failed stopping %s.",
1041                         [JOB_TIMEOUT]    = "Timed out stopping %s.",
1042                 },
1043         },
1044 };