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("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("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("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("mkdir(%s) failed: %s", s->path, strerror(-r));
 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("%s failed to enter waiting state: %s",
 566                     UNIT(p)->id, strerror(-r));
 567         path_enter_dead(p, PATH_FAILURE_RESOURCES);
 568 }
 569
 570 static void path_mkdir(Path *p) {
 571         PathSpec *s;
 572
 573         assert(p);
 574
 575         if (!p->make_directory)
 576                 return;
 577
 578         LIST_FOREACH(spec, s, p->specs)
 579                 path_spec_mkdir(s, p->directory_mode);
 580 }
 581
 582 static int path_start(Unit *u) {
 583         Path *p = PATH(u);
 584
 585         assert(p);
 586         assert(p->state == PATH_DEAD || p->state == PATH_FAILED);
 587
 588         if (UNIT_TRIGGER(u)->load_state != UNIT_LOADED)
 589                 return -ENOENT;
 590
 591         path_mkdir(p);
 592
 593         p->result = PATH_SUCCESS;
 594         path_enter_waiting(p, true, true);
 595
 596         return 0;
 597 }
 598
 599 static int path_stop(Unit *u) {
 600         Path *p = PATH(u);
 601
 602         assert(p);
 603         assert(p->state == PATH_WAITING || p->state == PATH_RUNNING);
 604
 605         path_enter_dead(p, PATH_SUCCESS);
 606         return 0;
 607 }
 608
 609 static int path_serialize(Unit *u, FILE *f, FDSet *fds) {
 610         Path *p = PATH(u);
 611
 612         assert(u);
 613         assert(f);
 614         assert(fds);
 615
 616         unit_serialize_item(u, f, "state", path_state_to_string(p->state));
 617         unit_serialize_item(u, f, "result", path_result_to_string(p->result));
 618
 619         return 0;
 620 }
 621
 622 static int path_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
 623         Path *p = PATH(u);
 624
 625         assert(u);
 626         assert(key);
 627         assert(value);
 628         assert(fds);
 629
 630         if (streq(key, "state")) {
 631                 PathState state;
 632
 633                 state = path_state_from_string(value);
 634                 if (state < 0)
 635                         log_debug("Failed to parse state value %s", value);
 636                 else
 637                         p->deserialized_state = state;
 638
 639         } else if (streq(key, "result")) {
 640                 PathResult f;
 641
 642                 f = path_result_from_string(value);
 643                 if (f < 0)
 644                         log_debug("Failed to parse result value %s", value);
 645                 else if (f != PATH_SUCCESS)
 646                         p->result = f;
 647
 648         } else
 649                 log_debug("Unknown serialization key '%s'", key);
 650
 651         return 0;
 652 }
 653
 654 _pure_ static UnitActiveState path_active_state(Unit *u) {
 655         assert(u);
 656
 657         return state_translation_table[PATH(u)->state];
 658 }
 659
 660 _pure_ static const char *path_sub_state_to_string(Unit *u) {
 661         assert(u);
 662
 663         return path_state_to_string(PATH(u)->state);
 664 }
 665
 666 static int path_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
 667         PathSpec *s = userdata;
 668         Path *p;
 669         int changed;
 670
 671         assert(s);
 672         assert(s->unit);
 673         assert(fd >= 0);
 674
 675         p = PATH(s->unit);
 676
 677         if (p->state != PATH_WAITING &&
 678             p->state != PATH_RUNNING)
 679                 return 0;
 680
 681         /* log_debug("inotify wakeup on %s.", u->id); */
 682
 683         LIST_FOREACH(spec, s, p->specs)
 684                 if (path_spec_owns_inotify_fd(s, fd))
 685                         break;
 686
 687         if (!s) {
 688                 log_error("Got event on unknown fd.");
 689                 goto fail;
 690         }
 691
 692         changed = path_spec_fd_event(s, revents);
 693         if (changed < 0)
 694                 goto fail;
 695
 696         /* If we are already running, then remember that one event was
 697          * dispatched so that we restart the service only if something
 698          * actually changed on disk */
 699         p->inotify_triggered = true;
 700
 701         if (changed)
 702                 path_enter_running(p);
 703         else
 704                 path_enter_waiting(p, false, true);
 705
 706         return 0;
 707
 708 fail:
 709         path_enter_dead(p, PATH_FAILURE_RESOURCES);
 710         return 0;
 711 }
 712
 713 static void path_trigger_notify(Unit *u, Unit *other) {
 714         Path *p = PATH(u);
 715
 716         assert(u);
 717         assert(other);
 718
 719         /* Invoked whenever the unit we trigger changes state or gains
 720          * or loses a job */
 721
 722         if (other->load_state != UNIT_LOADED)
 723                 return;
 724
 725         if (p->state == PATH_RUNNING &&
 726             UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other))) {
 727                 log_unit_debug(UNIT(p)->id,
 728                                "%s got notified about unit deactivation.",
 729                                UNIT(p)->id);
 730
 731                 /* Hmm, so inotify was triggered since the
 732                  * last activation, so I guess we need to
 733                  * recheck what is going on. */
 734                 path_enter_waiting(p, false, p->inotify_triggered);
 735         }
 736 }
 737
 738 static void path_reset_failed(Unit *u) {
 739         Path *p = PATH(u);
 740
 741         assert(p);
 742
 743         if (p->state == PATH_FAILED)
 744                 path_set_state(p, PATH_DEAD);
 745
 746         p->result = PATH_SUCCESS;
 747 }
 748
 749 static const char* const path_state_table[_PATH_STATE_MAX] = {
 750         [PATH_DEAD] = "dead",
 751         [PATH_WAITING] = "waiting",
 752         [PATH_RUNNING] = "running",
 753         [PATH_FAILED] = "failed"
 754 };
 755
 756 DEFINE_STRING_TABLE_LOOKUP(path_state, PathState);
 757
 758 static const char* const path_type_table[_PATH_TYPE_MAX] = {
 759         [PATH_EXISTS] = "PathExists",
 760         [PATH_EXISTS_GLOB] = "PathExistsGlob",
 761         [PATH_DIRECTORY_NOT_EMPTY] = "DirectoryNotEmpty",
 762         [PATH_CHANGED] = "PathChanged",
 763         [PATH_MODIFIED] = "PathModified",
 764 };
 765
 766 DEFINE_STRING_TABLE_LOOKUP(path_type, PathType);
 767
 768 static const char* const path_result_table[_PATH_RESULT_MAX] = {
 769         [PATH_SUCCESS] = "success",
 770         [PATH_FAILURE_RESOURCES] = "resources",
 771 };
 772
 773 DEFINE_STRING_TABLE_LOOKUP(path_result, PathResult);
 774
 775 const UnitVTable path_vtable = {
 776         .object_size = sizeof(Path),
 777
 778         .sections =
 779                 "Unit\0"
 780                 "Path\0"
 781                 "Install\0",
 782
 783         .init = path_init,
 784         .done = path_done,
 785         .load = path_load,
 786
 787         .coldplug = path_coldplug,
 788
 789         .dump = path_dump,
 790
 791         .start = path_start,
 792         .stop = path_stop,
 793
 794         .serialize = path_serialize,
 795         .deserialize_item = path_deserialize_item,
 796
 797         .active_state = path_active_state,
 798         .sub_state_to_string = path_sub_state_to_string,
 799
 800         .trigger_notify = path_trigger_notify,
 801
 802         .reset_failed = path_reset_failed,
 803
 804         .bus_interface = "org.freedesktop.systemd1.Path",
 805         .bus_vtable = bus_path_vtable
 806 };