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_unit_error(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_unit_error(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_unit_debug(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_unit_warning(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_unit_warning(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_unit_debug(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_errno(r, "Failed to create starter connection at step %s: %m", exit_status_to_string(ret, EXIT_STATUS_SYSTEMD));
 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_unit_warning(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_unit_warning(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_unit_warning(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_unit_warning(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_unit_warning(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_unit_debug(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_unit_warning(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_unit_error(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_unit_debug(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_unit_debug(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_unit_debug(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_unit_debug(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_unit_debug(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         struct kdbus_cmd_free cmd_free = {};
 735         const char *comm = NULL;
 736         struct kdbus_item *d;
 737         struct kdbus_msg *k;
 738         size_t start, ps, sz, delta;
 739         void *p = NULL;
 740         pid_t pid = 0;
 741         int r;
 742
 743         /* Generate a friendly debug log message about which process
 744          * caused triggering of this bus name. This simply peeks the
 745          * metadata of the first queued message and logs it. */
 746
 747         assert(n);
 748
 749         /* Let's shortcut things a bit, if debug logging is turned off
 750          * anyway. */
 751
 752         if (log_get_max_level() < LOG_DEBUG)
 753                 return 0;
 754
 755         r = ioctl(n->starter_fd, KDBUS_CMD_MSG_RECV, &cmd_recv);
 756         if (r < 0) {
 757                 if (errno == EINTR || errno == EAGAIN)
 758                         return 0;
 759
 760                 log_unit_error(UNIT(n)->id, "%s: Failed to query activation message: %m", UNIT(n)->id);
 761                 return -errno;
 762         }
 763
 764         /* We map as late as possible, and unmap imemdiately after
 765          * use. On 32bit address space is scarce and we want to be
 766          * able to handle a lot of activator connections at the same
 767          * time, and hence shouldn't keep the mmap()s around for
 768          * longer than necessary. */
 769
 770         ps = page_size();
 771         start = (cmd_recv.offset / ps) * ps;
 772         delta = cmd_recv.offset - start;
 773         sz = PAGE_ALIGN(delta + cmd_recv.msg_size);
 774
 775         p = mmap(NULL, sz, PROT_READ, MAP_SHARED, n->starter_fd, start);
 776         if (p == MAP_FAILED) {
 777                 log_unit_error(UNIT(n)->id, "%s: Failed to map activation message: %m", UNIT(n)->id);
 778                 r = -errno;
 779                 goto finish;
 780         }
 781
 782         k = (struct kdbus_msg *) ((uint8_t *) p + delta);
 783         KDBUS_ITEM_FOREACH(d, k, items) {
 784                 switch (d->type) {
 785
 786                 case KDBUS_ITEM_PIDS:
 787                         pid = d->pids.pid;
 788                         break;
 789
 790                 case KDBUS_ITEM_PID_COMM:
 791                         comm = d->str;
 792                         break;
 793                 }
 794         }
 795
 796         if (pid > 0)
 797                 log_unit_debug(UNIT(n)->id, "%s: Activation triggered by process " PID_FMT " (%s)", UNIT(n)->id, pid, strna(comm));
 798
 799         r = 0;
 800
 801 finish:
 802         if (p)
 803                 (void) munmap(p, sz);
 804
 805         cmd_free.offset = cmd_recv.offset;
 806         if (ioctl(n->starter_fd, KDBUS_CMD_FREE, &cmd_free) < 0)
 807                 log_unit_warning(UNIT(n)->id, "Failed to free peeked message, ignoring: %m");
 808
 809         return r;
 810 }
 811
 812 static int busname_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
 813         BusName *n = userdata;
 814
 815         assert(n);
 816         assert(fd >= 0);
 817
 818         if (n->state != BUSNAME_LISTENING)
 819                 return 0;
 820
 821         log_unit_debug(UNIT(n)->id, "Activation request on %s", UNIT(n)->id);
 822
 823         if (revents != EPOLLIN) {
 824                 log_unit_error(UNIT(n)->id, "%s: Got unexpected poll event (0x%x) on starter fd.",
 825                                UNIT(n)->id, revents);
 826                 goto fail;
 827         }
 828
 829         busname_peek_message(n);
 830         busname_enter_running(n);
 831         return 0;
 832 fail:
 833
 834         busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
 835         return 0;
 836 }
 837
 838 static void busname_sigchld_event(Unit *u, pid_t pid, int code, int status) {
 839         BusName *n = BUSNAME(u);
 840         BusNameResult f;
 841
 842         assert(n);
 843         assert(pid >= 0);
 844
 845         if (pid != n->control_pid)
 846                 return;
 847
 848         n->control_pid = 0;
 849
 850         if (is_clean_exit(code, status, NULL))
 851                 f = BUSNAME_SUCCESS;
 852         else if (code == CLD_EXITED)
 853                 f = BUSNAME_FAILURE_EXIT_CODE;
 854         else if (code == CLD_KILLED)
 855                 f = BUSNAME_FAILURE_SIGNAL;
 856         else if (code == CLD_DUMPED)
 857                 f = BUSNAME_FAILURE_CORE_DUMP;
 858         else
 859                 assert_not_reached("Unknown sigchld code");
 860
 861         log_unit_full(u->id,
 862                       f == BUSNAME_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
 863                       "%s control process exited, code=%s status=%i",
 864                       u->id, sigchld_code_to_string(code), status);
 865
 866         if (f != BUSNAME_SUCCESS)
 867                 n->result = f;
 868
 869         switch (n->state) {
 870
 871         case BUSNAME_MAKING:
 872                 if (f == BUSNAME_SUCCESS)
 873                         busname_enter_listening(n);
 874                 else
 875                         busname_enter_signal(n, BUSNAME_SIGTERM, f);
 876                 break;
 877
 878         case BUSNAME_SIGTERM:
 879         case BUSNAME_SIGKILL:
 880                 busname_enter_dead(n, f);
 881                 break;
 882
 883         default:
 884                 assert_not_reached("Uh, control process died at wrong time.");
 885         }
 886
 887         /* Notify clients about changed exit status */
 888         unit_add_to_dbus_queue(u);
 889 }
 890
 891 static int busname_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
 892         BusName *n = BUSNAME(userdata);
 893
 894         assert(n);
 895         assert(n->timer_event_source == source);
 896
 897         switch (n->state) {
 898
 899         case BUSNAME_MAKING:
 900                 log_unit_warning(UNIT(n)->id, "%s making timed out. Terminating.", UNIT(n)->id);
 901                 busname_enter_signal(n, BUSNAME_SIGTERM, BUSNAME_FAILURE_TIMEOUT);
 902                 break;
 903
 904         case BUSNAME_SIGTERM:
 905                 log_unit_warning(UNIT(n)->id, "%s stopping timed out. Killing.", UNIT(n)->id);
 906                 busname_enter_signal(n, BUSNAME_SIGKILL, BUSNAME_FAILURE_TIMEOUT);
 907                 break;
 908
 909         case BUSNAME_SIGKILL:
 910                 log_unit_warning(UNIT(n)->id, "%s still around after SIGKILL. Ignoring.", UNIT(n)->id);
 911                 busname_enter_dead(n, BUSNAME_FAILURE_TIMEOUT);
 912                 break;
 913
 914         default:
 915                 assert_not_reached("Timeout at wrong time.");
 916         }
 917
 918         return 0;
 919 }
 920
 921 static void busname_reset_failed(Unit *u) {
 922         BusName *n = BUSNAME(u);
 923
 924         assert(n);
 925
 926         if (n->state == BUSNAME_FAILED)
 927                 busname_set_state(n, BUSNAME_DEAD);
 928
 929         n->result = BUSNAME_SUCCESS;
 930 }
 931
 932 static void busname_trigger_notify(Unit *u, Unit *other) {
 933         BusName *n = BUSNAME(u);
 934         Service *s;
 935
 936         assert(n);
 937         assert(other);
 938
 939         if (!IN_SET(n->state, BUSNAME_RUNNING, BUSNAME_LISTENING))
 940                 return;
 941
 942         if (other->load_state != UNIT_LOADED || other->type != UNIT_SERVICE)
 943                 return;
 944
 945         s = SERVICE(other);
 946
 947         if (s->state == SERVICE_FAILED && s->result == SERVICE_FAILURE_START_LIMIT)
 948                 busname_enter_dead(n, BUSNAME_FAILURE_SERVICE_FAILED_PERMANENT);
 949         else if (IN_SET(s->state,
 950                         SERVICE_DEAD, SERVICE_FAILED,
 951                         SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
 952                         SERVICE_STOP_POST, SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
 953                         SERVICE_AUTO_RESTART))
 954                 busname_enter_listening(n);
 955 }
 956
 957 static int busname_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
 958         return unit_kill_common(u, who, signo, -1, BUSNAME(u)->control_pid, error);
 959 }
 960
 961 static int busname_get_timeout(Unit *u, uint64_t *timeout) {
 962         BusName *n = BUSNAME(u);
 963         int r;
 964
 965         if (!n->timer_event_source)
 966                 return 0;
 967
 968         r = sd_event_source_get_time(n->timer_event_source, timeout);
 969         if (r < 0)
 970                 return r;
 971
 972         return 1;
 973 }
 974
 975 static const char* const busname_state_table[_BUSNAME_STATE_MAX] = {
 976         [BUSNAME_DEAD] = "dead",
 977         [BUSNAME_MAKING] = "making",
 978         [BUSNAME_REGISTERED] = "registered",
 979         [BUSNAME_LISTENING] = "listening",
 980         [BUSNAME_RUNNING] = "running",
 981         [BUSNAME_SIGTERM] = "sigterm",
 982         [BUSNAME_SIGKILL] = "sigkill",
 983         [BUSNAME_FAILED] = "failed",
 984 };
 985
 986 DEFINE_STRING_TABLE_LOOKUP(busname_state, BusNameState);
 987
 988 static const char* const busname_result_table[_BUSNAME_RESULT_MAX] = {
 989         [BUSNAME_SUCCESS] = "success",
 990         [BUSNAME_FAILURE_RESOURCES] = "resources",
 991         [BUSNAME_FAILURE_TIMEOUT] = "timeout",
 992         [BUSNAME_FAILURE_EXIT_CODE] = "exit-code",
 993         [BUSNAME_FAILURE_SIGNAL] = "signal",
 994         [BUSNAME_FAILURE_CORE_DUMP] = "core-dump",
 995         [BUSNAME_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent",
 996 };
 997
 998 DEFINE_STRING_TABLE_LOOKUP(busname_result, BusNameResult);
 999
1000 const UnitVTable busname_vtable = {
1001         .object_size = sizeof(BusName),
1002
1003         .sections =
1004                 "Unit\0"
1005                 "BusName\0"
1006                 "Install\0",
1007         .private_section = "BusName",
1008
1009         .init = busname_init,
1010         .done = busname_done,
1011         .load = busname_load,
1012
1013         .coldplug = busname_coldplug,
1014
1015         .dump = busname_dump,
1016
1017         .start = busname_start,
1018         .stop = busname_stop,
1019
1020         .kill = busname_kill,
1021
1022         .get_timeout = busname_get_timeout,
1023
1024         .serialize = busname_serialize,
1025         .deserialize_item = busname_deserialize_item,
1026
1027         .active_state = busname_active_state,
1028         .sub_state_to_string = busname_sub_state_to_string,
1029
1030         .sigchld_event = busname_sigchld_event,
1031
1032         .trigger_notify = busname_trigger_notify,
1033
1034         .reset_failed = busname_reset_failed,
1035
1036         .bus_interface = "org.freedesktop.systemd1.BusName",
1037         .bus_vtable = bus_busname_vtable,
1038
1039         .status_message_formats = {
1040                 .finished_start_job = {
1041                         [JOB_DONE]       = "Listening on %s.",
1042                         [JOB_FAILED]     = "Failed to listen on %s.",
1043                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
1044                         [JOB_TIMEOUT]    = "Timed out starting %s.",
1045                 },
1046                 .finished_stop_job = {
1047                         [JOB_DONE]       = "Closed %s.",
1048                         [JOB_FAILED]     = "Failed stopping %s.",
1049                         [JOB_TIMEOUT]    = "Timed out stopping %s.",
1050                 },
1051         },
1052 };