src/core/path.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <errno.h>
   4 #include <sys/epoll.h>
   5 #include <sys/inotify.h>
   6 #include <unistd.h>
   7
   8 #include "bus-error.h"
   9 #include "bus-util.h"
  10 #include "dbus-path.h"
  11 #include "dbus-unit.h"
  12 #include "fd-util.h"
  13 #include "fs-util.h"
  14 #include "glob-util.h"
  15 #include "macro.h"
  16 #include "mkdir.h"
  17 #include "path.h"
  18 #include "serialize.h"
  19 #include "special.h"
  20 #include "stat-util.h"
  21 #include "string-table.h"
  22 #include "string-util.h"
  23 #include "unit-name.h"
  24 #include "unit.h"
  25
  26 static const UnitActiveState state_translation_table[_PATH_STATE_MAX] = {
  27         [PATH_DEAD] = UNIT_INACTIVE,
  28         [PATH_WAITING] = UNIT_ACTIVE,
  29         [PATH_RUNNING] = UNIT_ACTIVE,
  30         [PATH_FAILED] = UNIT_FAILED
  31 };
  32
  33 static int path_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
  34
  35 int path_spec_watch(PathSpec *s, sd_event_io_handler_t handler) {
  36
  37         static const int flags_table[_PATH_TYPE_MAX] = {
  38                 [PATH_EXISTS] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB,
  39                 [PATH_EXISTS_GLOB] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB,
  40                 [PATH_CHANGED] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB|IN_CLOSE_WRITE|IN_CREATE|IN_DELETE|IN_MOVED_FROM|IN_MOVED_TO,
  41                 [PATH_MODIFIED] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB|IN_CLOSE_WRITE|IN_CREATE|IN_DELETE|IN_MOVED_FROM|IN_MOVED_TO|IN_MODIFY,
  42                 [PATH_DIRECTORY_NOT_EMPTY] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB|IN_CREATE|IN_MOVED_TO
  43         };
  44
  45         bool exists = false;
  46         char *slash, *oldslash = NULL;
  47         int r;
  48
  49         assert(s);
  50         assert(s->unit);
  51         assert(handler);
  52
  53         path_spec_unwatch(s);
  54
  55         s->inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
  56         if (s->inotify_fd < 0) {
  57                 r = -errno;
  58                 goto fail;
  59         }
  60
  61         r = sd_event_add_io(s->unit->manager->event, &s->event_source, s->inotify_fd, EPOLLIN, handler, s);
  62         if (r < 0)
  63                 goto fail;
  64
  65         (void) sd_event_source_set_description(s->event_source, "path");
  66
  67         /* This function assumes the path was passed through path_simplify()! */
  68         assert(!strstr(s->path, "//"));
  69
  70         for (slash = strchr(s->path, '/'); ; slash = strchr(slash+1, '/')) {
  71                 char *cut = NULL;
  72                 int flags;
  73                 char tmp;
  74
  75                 if (slash) {
  76                         cut = slash + (slash == s->path);
  77                         tmp = *cut;
  78                         *cut = '\0';
  79
  80                         flags = IN_MOVE_SELF | IN_DELETE_SELF | IN_ATTRIB | IN_CREATE | IN_MOVED_TO;
  81                 } else
  82                         flags = flags_table[s->type];
  83
  84                 r = inotify_add_watch(s->inotify_fd, s->path, flags);
  85                 if (r < 0) {
  86                         if (IN_SET(errno, EACCES, ENOENT)) {
  87                                 if (cut)
  88                                         *cut = tmp;
  89                                 break;
  90                         }
  91
  92                         r = log_warning_errno(errno, "Failed to add watch on %s: %s", s->path, errno == ENOSPC ? "too many watches" : strerror(-r));
  93                         if (cut)
  94                                 *cut = tmp;
  95                         goto fail;
  96                 } else {
  97                         exists = true;
  98
  99                         /* Path exists, we don't need to watch parent too closely. */
 100                         if (oldslash) {
 101                                 char *cut2 = oldslash + (oldslash == s->path);
 102                                 char tmp2 = *cut2;
 103                                 *cut2 = '\0';
 104
 105                                 (void) inotify_add_watch(s->inotify_fd, s->path, IN_MOVE_SELF);
 106                                 /* Error is ignored, the worst can happen is we get spurious events. */
 107
 108                                 *cut2 = tmp2;
 109                         }
 110                 }
 111
 112                 if (cut)
 113                         *cut = tmp;
 114
 115                 if (slash)
 116                         oldslash = slash;
 117                 else {
 118                         /* whole path has been iterated over */
 119                         s->primary_wd = r;
 120                         break;
 121                 }
 122         }
 123
 124         if (!exists) {
 125                 r = log_error_errno(errno, "Failed to add watch on any of the components of %s: %m", s->path);
 126                 /* either EACCESS or ENOENT */
 127                 goto fail;
 128         }
 129
 130         return 0;
 131
 132 fail:
 133         path_spec_unwatch(s);
 134         return r;
 135 }
 136
 137 void path_spec_unwatch(PathSpec *s) {
 138         assert(s);
 139
 140         s->event_source = sd_event_source_unref(s->event_source);
 141         s->inotify_fd = safe_close(s->inotify_fd);
 142 }
 143
 144 int path_spec_fd_event(PathSpec *s, uint32_t revents) {
 145         union inotify_event_buffer buffer;
 146         struct inotify_event *e;
 147         ssize_t l;
 148         int r = 0;
 149
 150         if (revents != EPOLLIN)
 151                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 152                                        "Got invalid poll event on inotify.");
 153
 154         l = read(s->inotify_fd, &buffer, sizeof(buffer));
 155         if (l < 0) {
 156                 if (IN_SET(errno, EAGAIN, EINTR))
 157                         return 0;
 158
 159                 return log_error_errno(errno, "Failed to read inotify event: %m");
 160         }
 161
 162         FOREACH_INOTIFY_EVENT(e, buffer, l) {
 163                 if (IN_SET(s->type, PATH_CHANGED, PATH_MODIFIED) &&
 164                     s->primary_wd == e->wd)
 165                         r = 1;
 166         }
 167
 168         return r;
 169 }
 170
 171 static bool path_spec_check_good(PathSpec *s, bool initial) {
 172         bool good = false;
 173
 174         switch (s->type) {
 175
 176         case PATH_EXISTS:
 177                 good = access(s->path, F_OK) >= 0;
 178                 break;
 179
 180         case PATH_EXISTS_GLOB:
 181                 good = glob_exists(s->path) > 0;
 182                 break;
 183
 184         case PATH_DIRECTORY_NOT_EMPTY: {
 185                 int k;
 186
 187                 k = dir_is_empty(s->path);
 188                 good = !(k == -ENOENT || k > 0);
 189                 break;
 190         }
 191
 192         case PATH_CHANGED:
 193         case PATH_MODIFIED: {
 194                 bool b;
 195
 196                 b = access(s->path, F_OK) >= 0;
 197                 good = !initial && b != s->previous_exists;
 198                 s->previous_exists = b;
 199                 break;
 200         }
 201
 202         default:
 203                 ;
 204         }
 205
 206         return good;
 207 }
 208
 209 static void path_spec_mkdir(PathSpec *s, mode_t mode) {
 210         int r;
 211
 212         if (IN_SET(s->type, PATH_EXISTS, PATH_EXISTS_GLOB))
 213                 return;
 214
 215         r = mkdir_p_label(s->path, mode);
 216         if (r < 0)
 217                 log_warning_errno(r, "mkdir(%s) failed: %m", s->path);
 218 }
 219
 220 static void path_spec_dump(PathSpec *s, FILE *f, const char *prefix) {
 221         fprintf(f,
 222                 "%s%s: %s\n",
 223                 prefix,
 224                 path_type_to_string(s->type),
 225                 s->path);
 226 }
 227
 228 void path_spec_done(PathSpec *s) {
 229         assert(s);
 230         assert(s->inotify_fd == -1);
 231
 232         free(s->path);
 233 }
 234
 235 static void path_init(Unit *u) {
 236         Path *p = PATH(u);
 237
 238         assert(u);
 239         assert(u->load_state == UNIT_STUB);
 240
 241         p->directory_mode = 0755;
 242 }
 243
 244 void path_free_specs(Path *p) {
 245         PathSpec *s;
 246
 247         assert(p);
 248
 249         while ((s = p->specs)) {
 250                 path_spec_unwatch(s);
 251                 LIST_REMOVE(spec, p->specs, s);
 252                 path_spec_done(s);
 253                 free(s);
 254         }
 255 }
 256
 257 static void path_done(Unit *u) {
 258         Path *p = PATH(u);
 259
 260         assert(p);
 261
 262         path_free_specs(p);
 263 }
 264
 265 static int path_add_mount_dependencies(Path *p) {
 266         PathSpec *s;
 267         int r;
 268
 269         assert(p);
 270
 271         LIST_FOREACH(spec, s, p->specs) {
 272                 r = unit_require_mounts_for(UNIT(p), s->path, UNIT_DEPENDENCY_FILE);
 273                 if (r < 0)
 274                         return r;
 275         }
 276
 277         return 0;
 278 }
 279
 280 static int path_verify(Path *p) {
 281         assert(p);
 282
 283         if (UNIT(p)->load_state != UNIT_LOADED)
 284                 return 0;
 285
 286         if (!p->specs) {
 287                 log_unit_error(UNIT(p), "Path unit lacks path setting. Refusing.");
 288                 return -ENOEXEC;
 289         }
 290
 291         return 0;
 292 }
 293
 294 static int path_add_default_dependencies(Path *p) {
 295         int r;
 296
 297         assert(p);
 298
 299         if (!UNIT(p)->default_dependencies)
 300                 return 0;
 301
 302         r = unit_add_dependency_by_name(UNIT(p), UNIT_BEFORE, SPECIAL_PATHS_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
 303         if (r < 0)
 304                 return r;
 305
 306         if (MANAGER_IS_SYSTEM(UNIT(p)->manager)) {
 307                 r = unit_add_two_dependencies_by_name(UNIT(p), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
 308                 if (r < 0)
 309                         return r;
 310         }
 311
 312         return unit_add_two_dependencies_by_name(UNIT(p), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
 313 }
 314
 315 static int path_add_trigger_dependencies(Path *p) {
 316         Unit *x;
 317         int r;
 318
 319         assert(p);
 320
 321         if (!hashmap_isempty(UNIT(p)->dependencies[UNIT_TRIGGERS]))
 322                 return 0;
 323
 324         r = unit_load_related_unit(UNIT(p), ".service", &x);
 325         if (r < 0)
 326                 return r;
 327
 328         return unit_add_two_dependencies(UNIT(p), UNIT_BEFORE, UNIT_TRIGGERS, x, true, UNIT_DEPENDENCY_IMPLICIT);
 329 }
 330
 331 static int path_load(Unit *u) {
 332         Path *p = PATH(u);
 333         int r;
 334
 335         assert(u);
 336         assert(u->load_state == UNIT_STUB);
 337
 338         r = unit_load_fragment_and_dropin(u);
 339         if (r < 0)
 340                 return r;
 341
 342         if (u->load_state == UNIT_LOADED) {
 343
 344                 r = path_add_trigger_dependencies(p);
 345                 if (r < 0)
 346                         return r;
 347
 348                 r = path_add_mount_dependencies(p);
 349                 if (r < 0)
 350                         return r;
 351
 352                 r = path_add_default_dependencies(p);
 353                 if (r < 0)
 354                         return r;
 355         }
 356
 357         return path_verify(p);
 358 }
 359
 360 static void path_dump(Unit *u, FILE *f, const char *prefix) {
 361         Path *p = PATH(u);
 362         Unit *trigger;
 363         PathSpec *s;
 364
 365         assert(p);
 366         assert(f);
 367
 368         trigger = UNIT_TRIGGER(u);
 369
 370         fprintf(f,
 371                 "%sPath State: %s\n"
 372                 "%sResult: %s\n"
 373                 "%sUnit: %s\n"
 374                 "%sMakeDirectory: %s\n"
 375                 "%sDirectoryMode: %04o\n",
 376                 prefix, path_state_to_string(p->state),
 377                 prefix, path_result_to_string(p->result),
 378                 prefix, trigger ? trigger->id : "n/a",
 379                 prefix, yes_no(p->make_directory),
 380                 prefix, p->directory_mode);
 381
 382         LIST_FOREACH(spec, s, p->specs)
 383                 path_spec_dump(s, f, prefix);
 384 }
 385
 386 static void path_unwatch(Path *p) {
 387         PathSpec *s;
 388
 389         assert(p);
 390
 391         LIST_FOREACH(spec, s, p->specs)
 392                 path_spec_unwatch(s);
 393 }
 394
 395 static int path_watch(Path *p) {
 396         int r;
 397         PathSpec *s;
 398
 399         assert(p);
 400
 401         LIST_FOREACH(spec, s, p->specs) {
 402                 r = path_spec_watch(s, path_dispatch_io);
 403                 if (r < 0)
 404                         return r;
 405         }
 406
 407         return 0;
 408 }
 409
 410 static void path_set_state(Path *p, PathState state) {
 411         PathState old_state;
 412         assert(p);
 413
 414         if (p->state != state)
 415                 bus_unit_send_pending_change_signal(UNIT(p), false);
 416
 417         old_state = p->state;
 418         p->state = state;
 419
 420         if (state != PATH_WAITING &&
 421             (state != PATH_RUNNING || p->inotify_triggered))
 422                 path_unwatch(p);
 423
 424         if (state != old_state)
 425                 log_unit_debug(UNIT(p), "Changed %s -> %s", path_state_to_string(old_state), path_state_to_string(state));
 426
 427         unit_notify(UNIT(p), state_translation_table[old_state], state_translation_table[state], 0);
 428 }
 429
 430 static void path_enter_waiting(Path *p, bool initial, bool recheck);
 431
 432 static int path_coldplug(Unit *u) {
 433         Path *p = PATH(u);
 434
 435         assert(p);
 436         assert(p->state == PATH_DEAD);
 437
 438         if (p->deserialized_state != p->state) {
 439
 440                 if (IN_SET(p->deserialized_state, PATH_WAITING, PATH_RUNNING))
 441                         path_enter_waiting(p, true, true);
 442                 else
 443                         path_set_state(p, p->deserialized_state);
 444         }
 445
 446         return 0;
 447 }
 448
 449 static void path_enter_dead(Path *p, PathResult f) {
 450         assert(p);
 451
 452         if (p->result == PATH_SUCCESS)
 453                 p->result = f;
 454
 455         unit_log_result(UNIT(p), p->result == PATH_SUCCESS, path_result_to_string(p->result));
 456         path_set_state(p, p->result != PATH_SUCCESS ? PATH_FAILED : PATH_DEAD);
 457 }
 458
 459 static void path_enter_running(Path *p) {
 460         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
 461         Unit *trigger;
 462         int r;
 463
 464         assert(p);
 465
 466         /* Don't start job if we are supposed to go down */
 467         if (unit_stop_pending(UNIT(p)))
 468                 return;
 469
 470         trigger = UNIT_TRIGGER(UNIT(p));
 471         if (!trigger) {
 472                 log_unit_error(UNIT(p), "Unit to trigger vanished.");
 473                 path_enter_dead(p, PATH_FAILURE_RESOURCES);
 474                 return;
 475         }
 476
 477         r = manager_add_job(UNIT(p)->manager, JOB_START, trigger, JOB_REPLACE, &error, NULL);
 478         if (r < 0)
 479                 goto fail;
 480
 481         p->inotify_triggered = false;
 482
 483         r = path_watch(p);
 484         if (r < 0)
 485                 goto fail;
 486
 487         path_set_state(p, PATH_RUNNING);
 488         return;
 489
 490 fail:
 491         log_unit_warning(UNIT(p), "Failed to queue unit startup job: %s", bus_error_message(&error, r));
 492         path_enter_dead(p, PATH_FAILURE_RESOURCES);
 493 }
 494
 495 static bool path_check_good(Path *p, bool initial) {
 496         PathSpec *s;
 497         bool good = false;
 498
 499         assert(p);
 500
 501         LIST_FOREACH(spec, s, p->specs) {
 502                 good = path_spec_check_good(s, initial);
 503
 504                 if (good)
 505                         break;
 506         }
 507
 508         return good;
 509 }
 510
 511 static void path_enter_waiting(Path *p, bool initial, bool recheck) {
 512         int r;
 513
 514         if (recheck)
 515                 if (path_check_good(p, initial)) {
 516                         log_unit_debug(UNIT(p), "Got triggered.");
 517                         path_enter_running(p);
 518                         return;
 519                 }
 520
 521         r = path_watch(p);
 522         if (r < 0)
 523                 goto fail;
 524
 525         /* Hmm, so now we have created inotify watches, but the file
 526          * might have appeared/been removed by now, so we must
 527          * recheck */
 528
 529         if (recheck)
 530                 if (path_check_good(p, false)) {
 531                         log_unit_debug(UNIT(p), "Got triggered.");
 532                         path_enter_running(p);
 533                         return;
 534                 }
 535
 536         path_set_state(p, PATH_WAITING);
 537         return;
 538
 539 fail:
 540         log_unit_warning_errno(UNIT(p), r, "Failed to enter waiting state: %m");
 541         path_enter_dead(p, PATH_FAILURE_RESOURCES);
 542 }
 543
 544 static void path_mkdir(Path *p) {
 545         PathSpec *s;
 546
 547         assert(p);
 548
 549         if (!p->make_directory)
 550                 return;
 551
 552         LIST_FOREACH(spec, s, p->specs)
 553                 path_spec_mkdir(s, p->directory_mode);
 554 }
 555
 556 static int path_start(Unit *u) {
 557         Path *p = PATH(u);
 558         Unit *trigger;
 559         int r;
 560
 561         assert(p);
 562         assert(IN_SET(p->state, PATH_DEAD, PATH_FAILED));
 563
 564         trigger = UNIT_TRIGGER(u);
 565         if (!trigger || trigger->load_state != UNIT_LOADED) {
 566                 log_unit_error(u, "Refusing to start, unit to trigger not loaded.");
 567                 return -ENOENT;
 568         }
 569
 570         r = unit_test_start_limit(u);
 571         if (r < 0) {
 572                 path_enter_dead(p, PATH_FAILURE_START_LIMIT_HIT);
 573                 return r;
 574         }
 575
 576         r = unit_acquire_invocation_id(u);
 577         if (r < 0)
 578                 return r;
 579
 580         path_mkdir(p);
 581
 582         p->result = PATH_SUCCESS;
 583         path_enter_waiting(p, true, true);
 584
 585         return 1;
 586 }
 587
 588 static int path_stop(Unit *u) {
 589         Path *p = PATH(u);
 590
 591         assert(p);
 592         assert(IN_SET(p->state, PATH_WAITING, PATH_RUNNING));
 593
 594         path_enter_dead(p, PATH_SUCCESS);
 595         return 1;
 596 }
 597
 598 static int path_serialize(Unit *u, FILE *f, FDSet *fds) {
 599         Path *p = PATH(u);
 600
 601         assert(u);
 602         assert(f);
 603         assert(fds);
 604
 605         (void) serialize_item(f, "state", path_state_to_string(p->state));
 606         (void) serialize_item(f, "result", path_result_to_string(p->result));
 607
 608         return 0;
 609 }
 610
 611 static int path_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
 612         Path *p = PATH(u);
 613
 614         assert(u);
 615         assert(key);
 616         assert(value);
 617         assert(fds);
 618
 619         if (streq(key, "state")) {
 620                 PathState state;
 621
 622                 state = path_state_from_string(value);
 623                 if (state < 0)
 624                         log_unit_debug(u, "Failed to parse state value: %s", value);
 625                 else
 626                         p->deserialized_state = state;
 627
 628         } else if (streq(key, "result")) {
 629                 PathResult f;
 630
 631                 f = path_result_from_string(value);
 632                 if (f < 0)
 633                         log_unit_debug(u, "Failed to parse result value: %s", value);
 634                 else if (f != PATH_SUCCESS)
 635                         p->result = f;
 636
 637         } else
 638                 log_unit_debug(u, "Unknown serialization key: %s", key);
 639
 640         return 0;
 641 }
 642
 643 _pure_ static UnitActiveState path_active_state(Unit *u) {
 644         assert(u);
 645
 646         return state_translation_table[PATH(u)->state];
 647 }
 648
 649 _pure_ static const char *path_sub_state_to_string(Unit *u) {
 650         assert(u);
 651
 652         return path_state_to_string(PATH(u)->state);
 653 }
 654
 655 static int path_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
 656         PathSpec *s = userdata;
 657         Path *p;
 658         int changed;
 659
 660         assert(s);
 661         assert(s->unit);
 662         assert(fd >= 0);
 663
 664         p = PATH(s->unit);
 665
 666         if (!IN_SET(p->state, PATH_WAITING, PATH_RUNNING))
 667                 return 0;
 668
 669         /* log_debug("inotify wakeup on %s.", u->id); */
 670
 671         LIST_FOREACH(spec, s, p->specs)
 672                 if (path_spec_owns_inotify_fd(s, fd))
 673                         break;
 674
 675         if (!s) {
 676                 log_error("Got event on unknown fd.");
 677                 goto fail;
 678         }
 679
 680         changed = path_spec_fd_event(s, revents);
 681         if (changed < 0)
 682                 goto fail;
 683
 684         /* If we are already running, then remember that one event was
 685          * dispatched so that we restart the service only if something
 686          * actually changed on disk */
 687         p->inotify_triggered = true;
 688
 689         if (changed)
 690                 path_enter_running(p);
 691         else
 692                 path_enter_waiting(p, false, true);
 693
 694         return 0;
 695
 696 fail:
 697         path_enter_dead(p, PATH_FAILURE_RESOURCES);
 698         return 0;
 699 }
 700
 701 static void path_trigger_notify(Unit *u, Unit *other) {
 702         Path *p = PATH(u);
 703
 704         assert(u);
 705         assert(other);
 706
 707         /* Invoked whenever the unit we trigger changes state or gains
 708          * or loses a job */
 709
 710         if (other->load_state != UNIT_LOADED)
 711                 return;
 712
 713         if (p->state == PATH_RUNNING &&
 714             UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other))) {
 715                 log_unit_debug(UNIT(p), "Got notified about unit deactivation.");
 716
 717                 /* Hmm, so inotify was triggered since the
 718                  * last activation, so I guess we need to
 719                  * recheck what is going on. */
 720                 path_enter_waiting(p, false, p->inotify_triggered);
 721         }
 722 }
 723
 724 static void path_reset_failed(Unit *u) {
 725         Path *p = PATH(u);
 726
 727         assert(p);
 728
 729         if (p->state == PATH_FAILED)
 730                 path_set_state(p, PATH_DEAD);
 731
 732         p->result = PATH_SUCCESS;
 733 }
 734
 735 static const char* const path_type_table[_PATH_TYPE_MAX] = {
 736         [PATH_EXISTS] = "PathExists",
 737         [PATH_EXISTS_GLOB] = "PathExistsGlob",
 738         [PATH_DIRECTORY_NOT_EMPTY] = "DirectoryNotEmpty",
 739         [PATH_CHANGED] = "PathChanged",
 740         [PATH_MODIFIED] = "PathModified",
 741 };
 742
 743 DEFINE_STRING_TABLE_LOOKUP(path_type, PathType);
 744
 745 static const char* const path_result_table[_PATH_RESULT_MAX] = {
 746         [PATH_SUCCESS] = "success",
 747         [PATH_FAILURE_RESOURCES] = "resources",
 748         [PATH_FAILURE_START_LIMIT_HIT] = "start-limit-hit",
 749 };
 750
 751 DEFINE_STRING_TABLE_LOOKUP(path_result, PathResult);
 752
 753 const UnitVTable path_vtable = {
 754         .object_size = sizeof(Path),
 755
 756         .sections =
 757                 "Unit\0"
 758                 "Path\0"
 759                 "Install\0",
 760         .private_section = "Path",
 761
 762         .can_transient = true,
 763
 764         .init = path_init,
 765         .done = path_done,
 766         .load = path_load,
 767
 768         .coldplug = path_coldplug,
 769
 770         .dump = path_dump,
 771
 772         .start = path_start,
 773         .stop = path_stop,
 774
 775         .serialize = path_serialize,
 776         .deserialize_item = path_deserialize_item,
 777
 778         .active_state = path_active_state,
 779         .sub_state_to_string = path_sub_state_to_string,
 780
 781         .trigger_notify = path_trigger_notify,
 782
 783         .reset_failed = path_reset_failed,
 784
 785         .bus_vtable = bus_path_vtable,
 786         .bus_set_property = bus_path_set_property,
 787 };