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_errno(UNIT(n)->id, r, "Failed to watch starter fd: %m");
 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                 return log_unit_warning_errno(UNIT(n)->id, n->starter_fd, "Failed to open %s: %m", path ?: "kdbus");
 308
 309         return 0;
 310 }
 311
 312 static void busname_set_state(BusName *n, BusNameState state) {
 313         BusNameState old_state;
 314         assert(n);
 315
 316         old_state = n->state;
 317         n->state = state;
 318
 319         if (!IN_SET(state, BUSNAME_MAKING, BUSNAME_SIGTERM, BUSNAME_SIGKILL)) {
 320                 n->timer_event_source = sd_event_source_unref(n->timer_event_source);
 321                 busname_unwatch_control_pid(n);
 322         }
 323
 324         if (state != BUSNAME_LISTENING)
 325                 busname_unwatch_fd(n);
 326
 327         if (!IN_SET(state, BUSNAME_LISTENING, BUSNAME_MAKING, BUSNAME_REGISTERED, BUSNAME_RUNNING))
 328                 busname_close_fd(n);
 329
 330         if (state != old_state)
 331                 log_unit_debug(UNIT(n)->id, "%s changed %s -> %s",
 332                                UNIT(n)->id, busname_state_to_string(old_state), busname_state_to_string(state));
 333
 334         unit_notify(UNIT(n), state_translation_table[old_state], state_translation_table[state], true);
 335 }
 336
 337 static int busname_coldplug(Unit *u) {
 338         BusName *n = BUSNAME(u);
 339         int r;
 340
 341         assert(n);
 342         assert(n->state == BUSNAME_DEAD);
 343
 344         if (n->deserialized_state == n->state)
 345                 return 0;
 346
 347         if (IN_SET(n->deserialized_state, BUSNAME_MAKING, BUSNAME_SIGTERM, BUSNAME_SIGKILL)) {
 348
 349                 if (n->control_pid <= 0)
 350                         return -EBADMSG;
 351
 352                 r = unit_watch_pid(UNIT(n), n->control_pid);
 353                 if (r < 0)
 354                         return r;
 355
 356                 r = busname_arm_timer(n);
 357                 if (r < 0)
 358                         return r;
 359         }
 360
 361         if (IN_SET(n->deserialized_state, BUSNAME_MAKING, BUSNAME_LISTENING, BUSNAME_REGISTERED, BUSNAME_RUNNING)) {
 362                 r = busname_open_fd(n);
 363                 if (r < 0)
 364                         return r;
 365         }
 366
 367         if (n->deserialized_state == BUSNAME_LISTENING) {
 368                 r = busname_watch_fd(n);
 369                 if (r < 0)
 370                         return r;
 371         }
 372
 373         busname_set_state(n, n->deserialized_state);
 374         return 0;
 375 }
 376
 377 static int busname_make_starter(BusName *n, pid_t *_pid) {
 378         pid_t pid;
 379         int r;
 380
 381         r = busname_arm_timer(n);
 382         if (r < 0)
 383                 goto fail;
 384
 385         /* We have to resolve the user/group names out-of-process,
 386          * hence let's fork here. It's messy, but well, what can we
 387          * do? */
 388
 389         pid = fork();
 390         if (pid < 0)
 391                 return -errno;
 392
 393         if (pid == 0) {
 394                 int ret;
 395
 396                 default_signals(SIGNALS_CRASH_HANDLER, SIGNALS_IGNORE, -1);
 397                 ignore_signals(SIGPIPE, -1);
 398                 log_forget_fds();
 399
 400                 r = bus_kernel_make_starter(n->starter_fd, n->name, n->activating, n->accept_fd, n->policy, n->policy_world);
 401                 if (r < 0) {
 402                         ret = EXIT_MAKE_STARTER;
 403                         goto fail_child;
 404                 }
 405
 406                 _exit(0);
 407
 408         fail_child:
 409                 log_open();
 410                 log_error_errno(r, "Failed to create starter connection at step %s: %m", exit_status_to_string(ret, EXIT_STATUS_SYSTEMD));
 411
 412                 _exit(ret);
 413         }
 414
 415         r = unit_watch_pid(UNIT(n), pid);
 416         if (r < 0)
 417                 goto fail;
 418
 419         *_pid = pid;
 420         return 0;
 421
 422 fail:
 423         n->timer_event_source = sd_event_source_unref(n->timer_event_source);
 424         return r;
 425 }
 426
 427 static void busname_enter_dead(BusName *n, BusNameResult f) {
 428         assert(n);
 429
 430         if (f != BUSNAME_SUCCESS)
 431                 n->result = f;
 432
 433         busname_set_state(n, n->result != BUSNAME_SUCCESS ? BUSNAME_FAILED : BUSNAME_DEAD);
 434 }
 435
 436 static void busname_enter_signal(BusName *n, BusNameState state, BusNameResult f) {
 437         KillContext kill_context = {};
 438         int r;
 439
 440         assert(n);
 441
 442         if (f != BUSNAME_SUCCESS)
 443                 n->result = f;
 444
 445         kill_context_init(&kill_context);
 446
 447         r = unit_kill_context(UNIT(n),
 448                               &kill_context,
 449                               state != BUSNAME_SIGTERM ? KILL_KILL : KILL_TERMINATE,
 450                               -1,
 451                               n->control_pid,
 452                               false);
 453         if (r < 0) {
 454                 log_unit_warning_errno(UNIT(n)->id, r, "%s failed to kill control process: %m", UNIT(n)->id);
 455                 goto fail;
 456         }
 457
 458         if (r > 0) {
 459                 r = busname_arm_timer(n);
 460                 if (r < 0) {
 461                         log_unit_warning_errno(UNIT(n)->id, r, "%s failed to arm timer: %m", UNIT(n)->id);
 462                         goto fail;
 463                 }
 464
 465                 busname_set_state(n, state);
 466         } else if (state == BUSNAME_SIGTERM)
 467                 busname_enter_signal(n, BUSNAME_SIGKILL, BUSNAME_SUCCESS);
 468         else
 469                 busname_enter_dead(n, BUSNAME_SUCCESS);
 470
 471         return;
 472
 473 fail:
 474         busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
 475 }
 476
 477 static void busname_enter_listening(BusName *n) {
 478         int r;
 479
 480         assert(n);
 481
 482         if (n->activating) {
 483                 r = busname_watch_fd(n);
 484                 if (r < 0) {
 485                         log_unit_warning_errno(UNIT(n)->id, r, "%s failed to watch names: %m", UNIT(n)->id);
 486                         goto fail;
 487                 }
 488
 489                 busname_set_state(n, BUSNAME_LISTENING);
 490         } else
 491                 busname_set_state(n, BUSNAME_REGISTERED);
 492
 493         return;
 494
 495 fail:
 496         busname_enter_signal(n, BUSNAME_SIGTERM, BUSNAME_FAILURE_RESOURCES);
 497 }
 498
 499 static void busname_enter_making(BusName *n) {
 500         int r;
 501
 502         assert(n);
 503
 504         r = busname_open_fd(n);
 505         if (r < 0)
 506                 goto fail;
 507
 508         if (n->policy) {
 509                 /* If there is a policy, we need to resolve user/group
 510                  * names, which we can't do from PID1, hence let's
 511                  * fork. */
 512                 busname_unwatch_control_pid(n);
 513
 514                 r = busname_make_starter(n, &n->control_pid);
 515                 if (r < 0) {
 516                         log_unit_warning_errno(UNIT(n)->id, r, "%s failed to fork 'making' task: %m", UNIT(n)->id);
 517                         goto fail;
 518                 }
 519
 520                 busname_set_state(n, BUSNAME_MAKING);
 521         } else {
 522                 /* If there is no policy, we can do everything
 523                  * directly from PID 1, hence do so. */
 524
 525                 r = bus_kernel_make_starter(n->starter_fd, n->name, n->activating, n->accept_fd, NULL, n->policy_world);
 526                 if (r < 0) {
 527                         log_unit_warning_errno(UNIT(n)->id, r, "%s failed to make starter: %m", UNIT(n)->id);
 528                         goto fail;
 529                 }
 530
 531                 busname_enter_listening(n);
 532         }
 533
 534         return;
 535
 536 fail:
 537         busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
 538 }
 539
 540 static void busname_enter_running(BusName *n) {
 541         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 542         bool pending = false;
 543         Unit *other;
 544         Iterator i;
 545         int r;
 546
 547         assert(n);
 548
 549         if (!n->activating)
 550                 return;
 551
 552         /* We don't take conenctions anymore if we are supposed to
 553          * shut down anyway */
 554
 555         if (unit_stop_pending(UNIT(n))) {
 556                 log_unit_debug(UNIT(n)->id, "Suppressing activation request on %s since unit stop is scheduled.", UNIT(n)->id);
 557
 558                 /* Flush all queued activation reqeuest by closing and reopening the connection */
 559                 bus_kernel_drop_one(n->starter_fd);
 560
 561                 busname_enter_listening(n);
 562                 return;
 563         }
 564
 565         /* If there's already a start pending don't bother to do
 566          * anything */
 567         SET_FOREACH(other, UNIT(n)->dependencies[UNIT_TRIGGERS], i)
 568                 if (unit_active_or_pending(other)) {
 569                         pending = true;
 570                         break;
 571                 }
 572
 573         if (!pending) {
 574                 r = manager_add_job(UNIT(n)->manager, JOB_START, UNIT_DEREF(n->service), JOB_REPLACE, true, &error, NULL);
 575                 if (r < 0)
 576                         goto fail;
 577         }
 578
 579         busname_set_state(n, BUSNAME_RUNNING);
 580         return;
 581
 582 fail:
 583         log_unit_warning(UNIT(n)->id, "%s failed to queue service startup job: %s", UNIT(n)->id, bus_error_message(&error, r));
 584         busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
 585 }
 586
 587 static int busname_start(Unit *u) {
 588         BusName *n = BUSNAME(u);
 589
 590         assert(n);
 591
 592         /* We cannot fulfill this request right now, try again later
 593          * please! */
 594         if (IN_SET(n->state, BUSNAME_SIGTERM, BUSNAME_SIGKILL))
 595                 return -EAGAIN;
 596
 597         /* Already on it! */
 598         if (n->state == BUSNAME_MAKING)
 599                 return 0;
 600
 601         if (n->activating && UNIT_ISSET(n->service)) {
 602                 Service *service;
 603
 604                 service = SERVICE(UNIT_DEREF(n->service));
 605
 606                 if (UNIT(service)->load_state != UNIT_LOADED) {
 607                         log_unit_error(u->id, "Bus service %s not loaded, refusing.", UNIT(service)->id);
 608                         return -ENOENT;
 609                 }
 610         }
 611
 612         assert(IN_SET(n->state, BUSNAME_DEAD, BUSNAME_FAILED));
 613
 614         n->result = BUSNAME_SUCCESS;
 615         busname_enter_making(n);
 616
 617         return 0;
 618 }
 619
 620 static int busname_stop(Unit *u) {
 621         BusName *n = BUSNAME(u);
 622
 623         assert(n);
 624
 625         /* Already on it */
 626         if (IN_SET(n->state, BUSNAME_SIGTERM, BUSNAME_SIGKILL))
 627                 return 0;
 628
 629         /* If there's already something running, we go directly into
 630          * kill mode. */
 631
 632         if (n->state == BUSNAME_MAKING) {
 633                 busname_enter_signal(n, BUSNAME_SIGTERM, BUSNAME_SUCCESS);
 634                 return -EAGAIN;
 635         }
 636
 637         assert(IN_SET(n->state, BUSNAME_REGISTERED, BUSNAME_LISTENING, BUSNAME_RUNNING));
 638
 639         busname_enter_dead(n, BUSNAME_SUCCESS);
 640         return 0;
 641 }
 642
 643 static int busname_serialize(Unit *u, FILE *f, FDSet *fds) {
 644         BusName *n = BUSNAME(u);
 645
 646         assert(n);
 647         assert(f);
 648         assert(fds);
 649
 650         unit_serialize_item(u, f, "state", busname_state_to_string(n->state));
 651         unit_serialize_item(u, f, "result", busname_result_to_string(n->result));
 652
 653         if (n->control_pid > 0)
 654                 unit_serialize_item_format(u, f, "control-pid", PID_FMT, n->control_pid);
 655
 656         if (n->starter_fd >= 0) {
 657                 int copy;
 658
 659                 copy = fdset_put_dup(fds, n->starter_fd);
 660                 if (copy < 0)
 661                         return copy;
 662
 663                 unit_serialize_item_format(u, f, "starter-fd", "%i", copy);
 664         }
 665
 666         return 0;
 667 }
 668
 669 static int busname_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
 670         BusName *n = BUSNAME(u);
 671
 672         assert(n);
 673         assert(key);
 674         assert(value);
 675
 676         if (streq(key, "state")) {
 677                 BusNameState state;
 678
 679                 state = busname_state_from_string(value);
 680                 if (state < 0)
 681                         log_unit_debug(u->id, "Failed to parse state value %s", value);
 682                 else
 683                         n->deserialized_state = state;
 684
 685         } else if (streq(key, "result")) {
 686                 BusNameResult f;
 687
 688                 f = busname_result_from_string(value);
 689                 if (f < 0)
 690                         log_unit_debug(u->id, "Failed to parse result value %s", value);
 691                 else if (f != BUSNAME_SUCCESS)
 692                         n->result = f;
 693
 694         } else if (streq(key, "control-pid")) {
 695                 pid_t pid;
 696
 697                 if (parse_pid(value, &pid) < 0)
 698                         log_unit_debug(u->id, "Failed to parse control-pid value %s", value);
 699                 else
 700                         n->control_pid = pid;
 701         } else if (streq(key, "starter-fd")) {
 702                 int fd;
 703
 704                 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
 705                         log_unit_debug(u->id, "Failed to parse starter fd value %s", value);
 706                 else {
 707                         safe_close(n->starter_fd);
 708                         n->starter_fd = fdset_remove(fds, fd);
 709                 }
 710         } else
 711                 log_unit_debug(u->id, "Unknown serialization key '%s'", key);
 712
 713         return 0;
 714 }
 715
 716 _pure_ static UnitActiveState busname_active_state(Unit *u) {
 717         assert(u);
 718
 719         return state_translation_table[BUSNAME(u)->state];
 720 }
 721
 722 _pure_ static const char *busname_sub_state_to_string(Unit *u) {
 723         assert(u);
 724
 725         return busname_state_to_string(BUSNAME(u)->state);
 726 }
 727
 728 static int busname_peek_message(BusName *n) {
 729         struct kdbus_cmd_recv cmd_recv = {
 730                 .flags = KDBUS_RECV_PEEK,
 731         };
 732         struct kdbus_cmd_free cmd_free = {};
 733         const char *comm = NULL;
 734         struct kdbus_item *d;
 735         struct kdbus_msg *k;
 736         size_t start, ps, sz, delta;
 737         void *p = NULL;
 738         pid_t pid = 0;
 739         int r;
 740
 741         /* Generate a friendly debug log message about which process
 742          * caused triggering of this bus name. This simply peeks the
 743          * metadata of the first queued message and logs it. */
 744
 745         assert(n);
 746
 747         /* Let's shortcut things a bit, if debug logging is turned off
 748          * anyway. */
 749
 750         if (log_get_max_level() < LOG_DEBUG)
 751                 return 0;
 752
 753         r = ioctl(n->starter_fd, KDBUS_CMD_MSG_RECV, &cmd_recv);
 754         if (r < 0) {
 755                 if (errno == EINTR || errno == EAGAIN)
 756                         return 0;
 757
 758                 log_unit_error(UNIT(n)->id, "%s: Failed to query activation message: %m", UNIT(n)->id);
 759                 return -errno;
 760         }
 761
 762         /* We map as late as possible, and unmap imemdiately after
 763          * use. On 32bit address space is scarce and we want to be
 764          * able to handle a lot of activator connections at the same
 765          * time, and hence shouldn't keep the mmap()s around for
 766          * longer than necessary. */
 767
 768         ps = page_size();
 769         start = (cmd_recv.offset / ps) * ps;
 770         delta = cmd_recv.offset - start;
 771         sz = PAGE_ALIGN(delta + cmd_recv.msg_size);
 772
 773         p = mmap(NULL, sz, PROT_READ, MAP_SHARED, n->starter_fd, start);
 774         if (p == MAP_FAILED) {
 775                 log_unit_error(UNIT(n)->id, "%s: Failed to map activation message: %m", UNIT(n)->id);
 776                 r = -errno;
 777                 goto finish;
 778         }
 779
 780         k = (struct kdbus_msg *) ((uint8_t *) p + delta);
 781         KDBUS_ITEM_FOREACH(d, k, items) {
 782                 switch (d->type) {
 783
 784                 case KDBUS_ITEM_PIDS:
 785                         pid = d->pids.pid;
 786                         break;
 787
 788                 case KDBUS_ITEM_PID_COMM:
 789                         comm = d->str;
 790                         break;
 791                 }
 792         }
 793
 794         if (pid > 0)
 795                 log_unit_debug(UNIT(n)->id, "%s: Activation triggered by process " PID_FMT " (%s)", UNIT(n)->id, pid, strna(comm));
 796
 797         r = 0;
 798
 799 finish:
 800         if (p)
 801                 (void) munmap(p, sz);
 802
 803         cmd_free.offset = cmd_recv.offset;
 804         if (ioctl(n->starter_fd, KDBUS_CMD_FREE, &cmd_free) < 0)
 805                 log_unit_warning(UNIT(n)->id, "Failed to free peeked message, ignoring: %m");
 806
 807         return r;
 808 }
 809
 810 static int busname_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
 811         BusName *n = userdata;
 812
 813         assert(n);
 814         assert(fd >= 0);
 815
 816         if (n->state != BUSNAME_LISTENING)
 817                 return 0;
 818
 819         log_unit_debug(UNIT(n)->id, "Activation request on %s", UNIT(n)->id);
 820
 821         if (revents != EPOLLIN) {
 822                 log_unit_error(UNIT(n)->id, "%s: Got unexpected poll event (0x%x) on starter fd.",
 823                                UNIT(n)->id, revents);
 824                 goto fail;
 825         }
 826
 827         busname_peek_message(n);
 828         busname_enter_running(n);
 829         return 0;
 830 fail:
 831
 832         busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
 833         return 0;
 834 }
 835
 836 static void busname_sigchld_event(Unit *u, pid_t pid, int code, int status) {
 837         BusName *n = BUSNAME(u);
 838         BusNameResult f;
 839
 840         assert(n);
 841         assert(pid >= 0);
 842
 843         if (pid != n->control_pid)
 844                 return;
 845
 846         n->control_pid = 0;
 847
 848         if (is_clean_exit(code, status, NULL))
 849                 f = BUSNAME_SUCCESS;
 850         else if (code == CLD_EXITED)
 851                 f = BUSNAME_FAILURE_EXIT_CODE;
 852         else if (code == CLD_KILLED)
 853                 f = BUSNAME_FAILURE_SIGNAL;
 854         else if (code == CLD_DUMPED)
 855                 f = BUSNAME_FAILURE_CORE_DUMP;
 856         else
 857                 assert_not_reached("Unknown sigchld code");
 858
 859         log_unit_full(u->id,
 860                       f == BUSNAME_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
 861                       "%s control process exited, code=%s status=%i",
 862                       u->id, sigchld_code_to_string(code), status);
 863
 864         if (f != BUSNAME_SUCCESS)
 865                 n->result = f;
 866
 867         switch (n->state) {
 868
 869         case BUSNAME_MAKING:
 870                 if (f == BUSNAME_SUCCESS)
 871                         busname_enter_listening(n);
 872                 else
 873                         busname_enter_signal(n, BUSNAME_SIGTERM, f);
 874                 break;
 875
 876         case BUSNAME_SIGTERM:
 877         case BUSNAME_SIGKILL:
 878                 busname_enter_dead(n, f);
 879                 break;
 880
 881         default:
 882                 assert_not_reached("Uh, control process died at wrong time.");
 883         }
 884
 885         /* Notify clients about changed exit status */
 886         unit_add_to_dbus_queue(u);
 887 }
 888
 889 static int busname_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
 890         BusName *n = BUSNAME(userdata);
 891
 892         assert(n);
 893         assert(n->timer_event_source == source);
 894
 895         switch (n->state) {
 896
 897         case BUSNAME_MAKING:
 898                 log_unit_warning(UNIT(n)->id, "%s making timed out. Terminating.", UNIT(n)->id);
 899                 busname_enter_signal(n, BUSNAME_SIGTERM, BUSNAME_FAILURE_TIMEOUT);
 900                 break;
 901
 902         case BUSNAME_SIGTERM:
 903                 log_unit_warning(UNIT(n)->id, "%s stopping timed out. Killing.", UNIT(n)->id);
 904                 busname_enter_signal(n, BUSNAME_SIGKILL, BUSNAME_FAILURE_TIMEOUT);
 905                 break;
 906
 907         case BUSNAME_SIGKILL:
 908                 log_unit_warning(UNIT(n)->id, "%s still around after SIGKILL. Ignoring.", UNIT(n)->id);
 909                 busname_enter_dead(n, BUSNAME_FAILURE_TIMEOUT);
 910                 break;
 911
 912         default:
 913                 assert_not_reached("Timeout at wrong time.");
 914         }
 915
 916         return 0;
 917 }
 918
 919 static void busname_reset_failed(Unit *u) {
 920         BusName *n = BUSNAME(u);
 921
 922         assert(n);
 923
 924         if (n->state == BUSNAME_FAILED)
 925                 busname_set_state(n, BUSNAME_DEAD);
 926
 927         n->result = BUSNAME_SUCCESS;
 928 }
 929
 930 static void busname_trigger_notify(Unit *u, Unit *other) {
 931         BusName *n = BUSNAME(u);
 932         Service *s;
 933
 934         assert(n);
 935         assert(other);
 936
 937         if (!IN_SET(n->state, BUSNAME_RUNNING, BUSNAME_LISTENING))
 938                 return;
 939
 940         if (other->load_state != UNIT_LOADED || other->type != UNIT_SERVICE)
 941                 return;
 942
 943         s = SERVICE(other);
 944
 945         if (s->state == SERVICE_FAILED && s->result == SERVICE_FAILURE_START_LIMIT)
 946                 busname_enter_dead(n, BUSNAME_FAILURE_SERVICE_FAILED_PERMANENT);
 947         else if (IN_SET(s->state,
 948                         SERVICE_DEAD, SERVICE_FAILED,
 949                         SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
 950                         SERVICE_STOP_POST, SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
 951                         SERVICE_AUTO_RESTART))
 952                 busname_enter_listening(n);
 953 }
 954
 955 static int busname_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
 956         return unit_kill_common(u, who, signo, -1, BUSNAME(u)->control_pid, error);
 957 }
 958
 959 static int busname_get_timeout(Unit *u, uint64_t *timeout) {
 960         BusName *n = BUSNAME(u);
 961         int r;
 962
 963         if (!n->timer_event_source)
 964                 return 0;
 965
 966         r = sd_event_source_get_time(n->timer_event_source, timeout);
 967         if (r < 0)
 968                 return r;
 969
 970         return 1;
 971 }
 972
 973 static const char* const busname_state_table[_BUSNAME_STATE_MAX] = {
 974         [BUSNAME_DEAD] = "dead",
 975         [BUSNAME_MAKING] = "making",
 976         [BUSNAME_REGISTERED] = "registered",
 977         [BUSNAME_LISTENING] = "listening",
 978         [BUSNAME_RUNNING] = "running",
 979         [BUSNAME_SIGTERM] = "sigterm",
 980         [BUSNAME_SIGKILL] = "sigkill",
 981         [BUSNAME_FAILED] = "failed",
 982 };
 983
 984 DEFINE_STRING_TABLE_LOOKUP(busname_state, BusNameState);
 985
 986 static const char* const busname_result_table[_BUSNAME_RESULT_MAX] = {
 987         [BUSNAME_SUCCESS] = "success",
 988         [BUSNAME_FAILURE_RESOURCES] = "resources",
 989         [BUSNAME_FAILURE_TIMEOUT] = "timeout",
 990         [BUSNAME_FAILURE_EXIT_CODE] = "exit-code",
 991         [BUSNAME_FAILURE_SIGNAL] = "signal",
 992         [BUSNAME_FAILURE_CORE_DUMP] = "core-dump",
 993         [BUSNAME_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent",
 994 };
 995
 996 DEFINE_STRING_TABLE_LOOKUP(busname_result, BusNameResult);
 997
 998 const UnitVTable busname_vtable = {
 999         .object_size = sizeof(BusName),
1000
1001         .sections =
1002                 "Unit\0"
1003                 "BusName\0"
1004                 "Install\0",
1005         .private_section = "BusName",
1006
1007         .init = busname_init,
1008         .done = busname_done,
1009         .load = busname_load,
1010
1011         .coldplug = busname_coldplug,
1012
1013         .dump = busname_dump,
1014
1015         .start = busname_start,
1016         .stop = busname_stop,
1017
1018         .kill = busname_kill,
1019
1020         .get_timeout = busname_get_timeout,
1021
1022         .serialize = busname_serialize,
1023         .deserialize_item = busname_deserialize_item,
1024
1025         .active_state = busname_active_state,
1026         .sub_state_to_string = busname_sub_state_to_string,
1027
1028         .sigchld_event = busname_sigchld_event,
1029
1030         .trigger_notify = busname_trigger_notify,
1031
1032         .reset_failed = busname_reset_failed,
1033
1034         .bus_interface = "org.freedesktop.systemd1.BusName",
1035         .bus_vtable = bus_busname_vtable,
1036
1037         .status_message_formats = {
1038                 .finished_start_job = {
1039                         [JOB_DONE]       = "Listening on %s.",
1040                         [JOB_FAILED]     = "Failed to listen on %s.",
1041                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
1042                         [JOB_TIMEOUT]    = "Timed out starting %s.",
1043                 },
1044                 .finished_stop_job = {
1045                         [JOB_DONE]       = "Closed %s.",
1046                         [JOB_FAILED]     = "Failed stopping %s.",
1047                         [JOB_TIMEOUT]    = "Timed out stopping %s.",
1048                 },
1049         },
1050 };