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