src/core/path.c

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