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 (errno == EACCES || errno == 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 (errno == EAGAIN || errno == 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 ((s->type == PATH_CHANGED || s->type == 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 (s->type == PATH_EXISTS || s->type == 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 (p->deserialized_state == PATH_WAITING ||
 445                     p->deserialized_state == PATH_RUNNING)
 446                         path_enter_waiting(p, true, true);
 447                 else
 448                         path_set_state(p, p->deserialized_state);
 449         }
 450
 451         return 0;
 452 }
 453
 454 static void path_enter_dead(Path *p, PathResult f) {
 455         assert(p);
 456
 457         if (f != PATH_SUCCESS)
 458                 p->result = f;
 459
 460         path_set_state(p, p->result != PATH_SUCCESS ? PATH_FAILED : PATH_DEAD);
 461 }
 462
 463 static void path_enter_running(Path *p) {
 464         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
 465         Unit *trigger;
 466         int r;
 467
 468         assert(p);
 469
 470         /* Don't start job if we are supposed to go down */
 471         if (unit_stop_pending(UNIT(p)))
 472                 return;
 473
 474         trigger = UNIT_TRIGGER(UNIT(p));
 475         if (!trigger) {
 476                 log_unit_error(UNIT(p), "Unit to trigger vanished.");
 477                 path_enter_dead(p, PATH_FAILURE_RESOURCES);
 478                 return;
 479         }
 480
 481         r = manager_add_job(UNIT(p)->manager, JOB_START, trigger, JOB_REPLACE, &error, NULL);
 482         if (r < 0)
 483                 goto fail;
 484
 485         p->inotify_triggered = false;
 486
 487         r = path_watch(p);
 488         if (r < 0)
 489                 goto fail;
 490
 491         path_set_state(p, PATH_RUNNING);
 492         return;
 493
 494 fail:
 495         log_unit_warning(UNIT(p), "Failed to queue unit startup job: %s", bus_error_message(&error, r));
 496         path_enter_dead(p, PATH_FAILURE_RESOURCES);
 497 }
 498
 499 static bool path_check_good(Path *p, bool initial) {
 500         PathSpec *s;
 501         bool good = false;
 502
 503         assert(p);
 504
 505         LIST_FOREACH(spec, s, p->specs) {
 506                 good = path_spec_check_good(s, initial);
 507
 508                 if (good)
 509                         break;
 510         }
 511
 512         return good;
 513 }
 514
 515 static void path_enter_waiting(Path *p, bool initial, bool recheck) {
 516         int r;
 517
 518         if (recheck)
 519                 if (path_check_good(p, initial)) {
 520                         log_unit_debug(UNIT(p), "Got triggered.");
 521                         path_enter_running(p);
 522                         return;
 523                 }
 524
 525         r = path_watch(p);
 526         if (r < 0)
 527                 goto fail;
 528
 529         /* Hmm, so now we have created inotify watches, but the file
 530          * might have appeared/been removed by now, so we must
 531          * recheck */
 532
 533         if (recheck)
 534                 if (path_check_good(p, false)) {
 535                         log_unit_debug(UNIT(p), "Got triggered.");
 536                         path_enter_running(p);
 537                         return;
 538                 }
 539
 540         path_set_state(p, PATH_WAITING);
 541         return;
 542
 543 fail:
 544         log_unit_warning_errno(UNIT(p), r, "Failed to enter waiting state: %m");
 545         path_enter_dead(p, PATH_FAILURE_RESOURCES);
 546 }
 547
 548 static void path_mkdir(Path *p) {
 549         PathSpec *s;
 550
 551         assert(p);
 552
 553         if (!p->make_directory)
 554                 return;
 555
 556         LIST_FOREACH(spec, s, p->specs)
 557                 path_spec_mkdir(s, p->directory_mode);
 558 }
 559
 560 static int path_start(Unit *u) {
 561         Path *p = PATH(u);
 562         Unit *trigger;
 563         int r;
 564
 565         assert(p);
 566         assert(p->state == PATH_DEAD || p->state == PATH_FAILED);
 567
 568         trigger = UNIT_TRIGGER(u);
 569         if (!trigger || trigger->load_state != UNIT_LOADED) {
 570                 log_unit_error(u, "Refusing to start, unit to trigger not loaded.");
 571                 return -ENOENT;
 572         }
 573
 574         r = unit_start_limit_test(u);
 575         if (r < 0) {
 576                 path_enter_dead(p, PATH_FAILURE_START_LIMIT_HIT);
 577                 return r;
 578         }
 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(p->state == PATH_WAITING || p->state == 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         unit_serialize_item(u, f, "state", path_state_to_string(p->state));
 606         unit_serialize_item(u, 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 (p->state != PATH_WAITING &&
 667             p->state != PATH_RUNNING)
 668                 return 0;
 669
 670         /* log_debug("inotify wakeup on %s.", u->id); */
 671
 672         LIST_FOREACH(spec, s, p->specs)
 673                 if (path_spec_owns_inotify_fd(s, fd))
 674                         break;
 675
 676         if (!s) {
 677                 log_error("Got event on unknown fd.");
 678                 goto fail;
 679         }
 680
 681         changed = path_spec_fd_event(s, revents);
 682         if (changed < 0)
 683                 goto fail;
 684
 685         /* If we are already running, then remember that one event was
 686          * dispatched so that we restart the service only if something
 687          * actually changed on disk */
 688         p->inotify_triggered = true;
 689
 690         if (changed)
 691                 path_enter_running(p);
 692         else
 693                 path_enter_waiting(p, false, true);
 694
 695         return 0;
 696
 697 fail:
 698         path_enter_dead(p, PATH_FAILURE_RESOURCES);
 699         return 0;
 700 }
 701
 702 static void path_trigger_notify(Unit *u, Unit *other) {
 703         Path *p = PATH(u);
 704
 705         assert(u);
 706         assert(other);
 707
 708         /* Invoked whenever the unit we trigger changes state or gains
 709          * or loses a job */
 710
 711         if (other->load_state != UNIT_LOADED)
 712                 return;
 713
 714         if (p->state == PATH_RUNNING &&
 715             UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other))) {
 716                 log_unit_debug(UNIT(p), "Got notified about unit deactivation.");
 717
 718                 /* Hmm, so inotify was triggered since the
 719                  * last activation, so I guess we need to
 720                  * recheck what is going on. */
 721                 path_enter_waiting(p, false, p->inotify_triggered);
 722         }
 723 }
 724
 725 static void path_reset_failed(Unit *u) {
 726         Path *p = PATH(u);
 727
 728         assert(p);
 729
 730         if (p->state == PATH_FAILED)
 731                 path_set_state(p, PATH_DEAD);
 732
 733         p->result = PATH_SUCCESS;
 734 }
 735
 736 static const char* const path_type_table[_PATH_TYPE_MAX] = {
 737         [PATH_EXISTS] = "PathExists",
 738         [PATH_EXISTS_GLOB] = "PathExistsGlob",
 739         [PATH_DIRECTORY_NOT_EMPTY] = "DirectoryNotEmpty",
 740         [PATH_CHANGED] = "PathChanged",
 741         [PATH_MODIFIED] = "PathModified",
 742 };
 743
 744 DEFINE_STRING_TABLE_LOOKUP(path_type, PathType);
 745
 746 static const char* const path_result_table[_PATH_RESULT_MAX] = {
 747         [PATH_SUCCESS] = "success",
 748         [PATH_FAILURE_RESOURCES] = "resources",
 749         [PATH_FAILURE_START_LIMIT_HIT] = "start-limit-hit",
 750 };
 751
 752 DEFINE_STRING_TABLE_LOOKUP(path_result, PathResult);
 753
 754 const UnitVTable path_vtable = {
 755         .object_size = sizeof(Path),
 756
 757         .sections =
 758                 "Unit\0"
 759                 "Path\0"
 760                 "Install\0",
 761
 762         .init = path_init,
 763         .done = path_done,
 764         .load = path_load,
 765
 766         .coldplug = path_coldplug,
 767
 768         .dump = path_dump,
 769
 770         .start = path_start,
 771         .stop = path_stop,
 772
 773         .serialize = path_serialize,
 774         .deserialize_item = path_deserialize_item,
 775
 776         .active_state = path_active_state,
 777         .sub_state_to_string = path_sub_state_to_string,
 778
 779         .trigger_notify = path_trigger_notify,
 780
 781         .reset_failed = path_reset_failed,
 782
 783         .bus_vtable = bus_path_vtable
 784 };