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