src/core/path.c

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