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