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
 114                            too closely. */
 115                         if (oldslash) {
 116                                 char *cut2 = oldslash + (oldslash == s->path);
 117                                 char tmp2 = *cut2;
 118                                 *cut2 = '\0';
 119
 120                                 inotify_add_watch(s->inotify_fd, s->path, IN_MOVE_SELF);
 121                                 /* Error is ignored, the worst can happen is
 122                                    we get spurious events. */
 123
 124                                 *cut2 = tmp2;
 125                         }
 126                 }
 127
 128                 if (cut)
 129                         *cut = tmp;
 130
 131                 if (slash)
 132                         oldslash = slash;
 133                 else {
 134                         /* whole path has been iterated over */
 135                         s->primary_wd = r;
 136                         break;
 137                 }
 138         }
 139
 140         if (!exists) {
 141                 r = log_error_errno(errno, "Failed to add watch on any of the components of %s: %m", s->path);
 142                 /* either EACCESS or ENOENT */
 143                 goto fail;
 144         }
 145
 146         return 0;
 147
 148 fail:
 149         path_spec_unwatch(s);
 150         return r;
 151 }
 152
 153 void path_spec_unwatch(PathSpec *s) {
 154         assert(s);
 155
 156         s->event_source = sd_event_source_unref(s->event_source);
 157         s->inotify_fd = safe_close(s->inotify_fd);
 158 }
 159
 160 int path_spec_fd_event(PathSpec *s, uint32_t revents) {
 161         union inotify_event_buffer buffer;
 162         struct inotify_event *e;
 163         ssize_t 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         l = read(s->inotify_fd, &buffer, sizeof(buffer));
 172         if (l < 0) {
 173                 if (errno == EAGAIN || errno == EINTR)
 174                         return 0;
 175
 176                 return log_error_errno(errno, "Failed to read inotify event: %m");
 177         }
 178
 179         FOREACH_INOTIFY_EVENT(e, buffer, l) {
 180                 if ((s->type == PATH_CHANGED || s->type == PATH_MODIFIED) &&
 181                     s->primary_wd == e->wd)
 182                         r = 1;
 183         }
 184
 185         return r;
 186 }
 187
 188 static bool path_spec_check_good(PathSpec *s, bool initial) {
 189         bool good = false;
 190
 191         switch (s->type) {
 192
 193         case PATH_EXISTS:
 194                 good = access(s->path, F_OK) >= 0;
 195                 break;
 196
 197         case PATH_EXISTS_GLOB:
 198                 good = glob_exists(s->path) > 0;
 199                 break;
 200
 201         case PATH_DIRECTORY_NOT_EMPTY: {
 202                 int k;
 203
 204                 k = dir_is_empty(s->path);
 205                 good = !(k == -ENOENT || k > 0);
 206                 break;
 207         }
 208
 209         case PATH_CHANGED:
 210         case PATH_MODIFIED: {
 211                 bool b;
 212
 213                 b = access(s->path, F_OK) >= 0;
 214                 good = !initial && b != s->previous_exists;
 215                 s->previous_exists = b;
 216                 break;
 217         }
 218
 219         default:
 220                 ;
 221         }
 222
 223         return good;
 224 }
 225
 226 static void path_spec_mkdir(PathSpec *s, mode_t mode) {
 227         int r;
 228
 229         if (s->type == PATH_EXISTS || s->type == PATH_EXISTS_GLOB)
 230                 return;
 231
 232         r = mkdir_p_label(s->path, mode);
 233         if (r < 0)
 234                 log_warning_errno(r, "mkdir(%s) failed: %m", s->path);
 235 }
 236
 237 static void path_spec_dump(PathSpec *s, FILE *f, const char *prefix) {
 238         fprintf(f,
 239                 "%s%s: %s\n",
 240                 prefix,
 241                 path_type_to_string(s->type),
 242                 s->path);
 243 }
 244
 245 void path_spec_done(PathSpec *s) {
 246         assert(s);
 247         assert(s->inotify_fd == -1);
 248
 249         free(s->path);
 250 }
 251
 252 static void path_init(Unit *u) {
 253         Path *p = PATH(u);
 254
 255         assert(u);
 256         assert(u->load_state == UNIT_STUB);
 257
 258         p->directory_mode = 0755;
 259 }
 260
 261 void path_free_specs(Path *p) {
 262         PathSpec *s;
 263
 264         assert(p);
 265
 266         while ((s = p->specs)) {
 267                 path_spec_unwatch(s);
 268                 LIST_REMOVE(spec, p->specs, s);
 269                 path_spec_done(s);
 270                 free(s);
 271         }
 272 }
 273
 274 static void path_done(Unit *u) {
 275         Path *p = PATH(u);
 276
 277         assert(p);
 278
 279         path_free_specs(p);
 280 }
 281
 282 static int path_add_mount_links(Path *p) {
 283         PathSpec *s;
 284         int r;
 285
 286         assert(p);
 287
 288         LIST_FOREACH(spec, s, p->specs) {
 289                 r = unit_require_mounts_for(UNIT(p), s->path);
 290                 if (r < 0)
 291                         return r;
 292         }
 293
 294         return 0;
 295 }
 296
 297 static int path_verify(Path *p) {
 298         assert(p);
 299
 300         if (UNIT(p)->load_state != UNIT_LOADED)
 301                 return 0;
 302
 303         if (!p->specs) {
 304                 log_unit_error(UNIT(p), "Path unit lacks path setting. Refusing.");
 305                 return -EINVAL;
 306         }
 307
 308         return 0;
 309 }
 310
 311 static int path_add_default_dependencies(Path *p) {
 312         int r;
 313
 314         assert(p);
 315
 316         if (!UNIT(p)->default_dependencies)
 317                 return 0;
 318
 319         r = unit_add_dependency_by_name(UNIT(p), UNIT_BEFORE, SPECIAL_PATHS_TARGET, NULL, true);
 320         if (r < 0)
 321                 return r;
 322
 323         if (UNIT(p)->manager->running_as == MANAGER_SYSTEM) {
 324                 r = unit_add_two_dependencies_by_name(UNIT(p), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
 325                 if (r < 0)
 326                         return r;
 327         }
 328
 329         return unit_add_two_dependencies_by_name(UNIT(p), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
 330 }
 331
 332 static int path_load(Unit *u) {
 333         Path *p = PATH(u);
 334         int r;
 335
 336         assert(u);
 337         assert(u->load_state == UNIT_STUB);
 338
 339         r = unit_load_fragment_and_dropin(u);
 340         if (r < 0)
 341                 return r;
 342
 343         if (u->load_state == UNIT_LOADED) {
 344
 345                 if (set_isempty(u->dependencies[UNIT_TRIGGERS])) {
 346                         Unit *x;
 347
 348                         r = unit_load_related_unit(u, ".service", &x);
 349                         if (r < 0)
 350                                 return r;
 351
 352                         r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, x, true);
 353                         if (r < 0)
 354                                 return r;
 355                 }
 356
 357                 r = path_add_mount_links(p);
 358                 if (r < 0)
 359                         return r;
 360
 361                 r = path_add_default_dependencies(p);
 362                 if (r < 0)
 363                         return r;
 364         }
 365
 366         return path_verify(p);
 367 }
 368
 369 static void path_dump(Unit *u, FILE *f, const char *prefix) {
 370         Path *p = PATH(u);
 371         Unit *trigger;
 372         PathSpec *s;
 373
 374         assert(p);
 375         assert(f);
 376
 377         trigger = UNIT_TRIGGER(u);
 378
 379         fprintf(f,
 380                 "%sPath State: %s\n"
 381                 "%sResult: %s\n"
 382                 "%sUnit: %s\n"
 383                 "%sMakeDirectory: %s\n"
 384                 "%sDirectoryMode: %04o\n",
 385                 prefix, path_state_to_string(p->state),
 386                 prefix, path_result_to_string(p->result),
 387                 prefix, trigger ? trigger->id : "n/a",
 388                 prefix, yes_no(p->make_directory),
 389                 prefix, p->directory_mode);
 390
 391         LIST_FOREACH(spec, s, p->specs)
 392                 path_spec_dump(s, f, prefix);
 393 }
 394
 395 static void path_unwatch(Path *p) {
 396         PathSpec *s;
 397
 398         assert(p);
 399
 400         LIST_FOREACH(spec, s, p->specs)
 401                 path_spec_unwatch(s);
 402 }
 403
 404 static int path_watch(Path *p) {
 405         int r;
 406         PathSpec *s;
 407
 408         assert(p);
 409
 410         LIST_FOREACH(spec, s, p->specs) {
 411                 r = path_spec_watch(s, path_dispatch_io);
 412                 if (r < 0)
 413                         return r;
 414         }
 415
 416         return 0;
 417 }
 418
 419 static void path_set_state(Path *p, PathState state) {
 420         PathState old_state;
 421         assert(p);
 422
 423         old_state = p->state;
 424         p->state = state;
 425
 426         if (state != PATH_WAITING &&
 427             (state != PATH_RUNNING || p->inotify_triggered))
 428                 path_unwatch(p);
 429
 430         if (state != old_state)
 431                 log_unit_debug(UNIT(p), "Changed %s -> %s", path_state_to_string(old_state), path_state_to_string(state));
 432
 433         unit_notify(UNIT(p), state_translation_table[old_state], state_translation_table[state], true);
 434 }
 435
 436 static void path_enter_waiting(Path *p, bool initial, bool recheck);
 437
 438 static int path_coldplug(Unit *u) {
 439         Path *p = PATH(u);
 440
 441         assert(p);
 442         assert(p->state == PATH_DEAD);
 443
 444         if (p->deserialized_state != p->state) {
 445
 446                 if (p->deserialized_state == PATH_WAITING ||
 447                     p->deserialized_state == PATH_RUNNING)
 448                         path_enter_waiting(p, true, true);
 449                 else
 450                         path_set_state(p, p->deserialized_state);
 451         }
 452
 453         return 0;
 454 }
 455
 456 static void path_enter_dead(Path *p, PathResult f) {
 457         assert(p);
 458
 459         if (f != PATH_SUCCESS)
 460                 p->result = f;
 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, TIMER_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
 566         assert(p);
 567         assert(p->state == PATH_DEAD || p->state == PATH_FAILED);
 568
 569         trigger = UNIT_TRIGGER(u);
 570         if (!trigger || trigger->load_state != UNIT_LOADED) {
 571                 log_unit_error(u, "Refusing to start, unit to trigger not loaded.");
 572                 return -ENOENT;
 573         }
 574
 575         path_mkdir(p);
 576
 577         p->result = PATH_SUCCESS;
 578         path_enter_waiting(p, true, true);
 579
 580         return 1;
 581 }
 582
 583 static int path_stop(Unit *u) {
 584         Path *p = PATH(u);
 585
 586         assert(p);
 587         assert(p->state == PATH_WAITING || p->state == PATH_RUNNING);
 588
 589         path_enter_dead(p, PATH_SUCCESS);
 590         return 1;
 591 }
 592
 593 static int path_serialize(Unit *u, FILE *f, FDSet *fds) {
 594         Path *p = PATH(u);
 595
 596         assert(u);
 597         assert(f);
 598         assert(fds);
 599
 600         unit_serialize_item(u, f, "state", path_state_to_string(p->state));
 601         unit_serialize_item(u, f, "result", path_result_to_string(p->result));
 602
 603         return 0;
 604 }
 605
 606 static int path_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
 607         Path *p = PATH(u);
 608
 609         assert(u);
 610         assert(key);
 611         assert(value);
 612         assert(fds);
 613
 614         if (streq(key, "state")) {
 615                 PathState state;
 616
 617                 state = path_state_from_string(value);
 618                 if (state < 0)
 619                         log_unit_debug(u, "Failed to parse state value: %s", value);
 620                 else
 621                         p->deserialized_state = state;
 622
 623         } else if (streq(key, "result")) {
 624                 PathResult f;
 625
 626                 f = path_result_from_string(value);
 627                 if (f < 0)
 628                         log_unit_debug(u, "Failed to parse result value: %s", value);
 629                 else if (f != PATH_SUCCESS)
 630                         p->result = f;
 631
 632         } else
 633                 log_unit_debug(u, "Unknown serialization key: %s", key);
 634
 635         return 0;
 636 }
 637
 638 _pure_ static UnitActiveState path_active_state(Unit *u) {
 639         assert(u);
 640
 641         return state_translation_table[PATH(u)->state];
 642 }
 643
 644 _pure_ static const char *path_sub_state_to_string(Unit *u) {
 645         assert(u);
 646
 647         return path_state_to_string(PATH(u)->state);
 648 }
 649
 650 static int path_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
 651         PathSpec *s = userdata;
 652         Path *p;
 653         int changed;
 654
 655         assert(s);
 656         assert(s->unit);
 657         assert(fd >= 0);
 658
 659         p = PATH(s->unit);
 660
 661         if (p->state != PATH_WAITING &&
 662             p->state != PATH_RUNNING)
 663                 return 0;
 664
 665         /* log_debug("inotify wakeup on %s.", u->id); */
 666
 667         LIST_FOREACH(spec, s, p->specs)
 668                 if (path_spec_owns_inotify_fd(s, fd))
 669                         break;
 670
 671         if (!s) {
 672                 log_error("Got event on unknown fd.");
 673                 goto fail;
 674         }
 675
 676         changed = path_spec_fd_event(s, revents);
 677         if (changed < 0)
 678                 goto fail;
 679
 680         /* If we are already running, then remember that one event was
 681          * dispatched so that we restart the service only if something
 682          * actually changed on disk */
 683         p->inotify_triggered = true;
 684
 685         if (changed)
 686                 path_enter_running(p);
 687         else
 688                 path_enter_waiting(p, false, true);
 689
 690         return 0;
 691
 692 fail:
 693         path_enter_dead(p, PATH_FAILURE_RESOURCES);
 694         return 0;
 695 }
 696
 697 static void path_trigger_notify(Unit *u, Unit *other) {
 698         Path *p = PATH(u);
 699
 700         assert(u);
 701         assert(other);
 702
 703         /* Invoked whenever the unit we trigger changes state or gains
 704          * or loses a job */
 705
 706         if (other->load_state != UNIT_LOADED)
 707                 return;
 708
 709         if (p->state == PATH_RUNNING &&
 710             UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other))) {
 711                 log_unit_debug(UNIT(p), "Got notified about unit deactivation.");
 712
 713                 /* Hmm, so inotify was triggered since the
 714                  * last activation, so I guess we need to
 715                  * recheck what is going on. */
 716                 path_enter_waiting(p, false, p->inotify_triggered);
 717         }
 718 }
 719
 720 static void path_reset_failed(Unit *u) {
 721         Path *p = PATH(u);
 722
 723         assert(p);
 724
 725         if (p->state == PATH_FAILED)
 726                 path_set_state(p, PATH_DEAD);
 727
 728         p->result = PATH_SUCCESS;
 729 }
 730
 731 static const char* const path_type_table[_PATH_TYPE_MAX] = {
 732         [PATH_EXISTS] = "PathExists",
 733         [PATH_EXISTS_GLOB] = "PathExistsGlob",
 734         [PATH_DIRECTORY_NOT_EMPTY] = "DirectoryNotEmpty",
 735         [PATH_CHANGED] = "PathChanged",
 736         [PATH_MODIFIED] = "PathModified",
 737 };
 738
 739 DEFINE_STRING_TABLE_LOOKUP(path_type, PathType);
 740
 741 static const char* const path_result_table[_PATH_RESULT_MAX] = {
 742         [PATH_SUCCESS] = "success",
 743         [PATH_FAILURE_RESOURCES] = "resources",
 744 };
 745
 746 DEFINE_STRING_TABLE_LOOKUP(path_result, PathResult);
 747
 748 const UnitVTable path_vtable = {
 749         .object_size = sizeof(Path),
 750
 751         .sections =
 752                 "Unit\0"
 753                 "Path\0"
 754                 "Install\0",
 755
 756         .init = path_init,
 757         .done = path_done,
 758         .load = path_load,
 759
 760         .coldplug = path_coldplug,
 761
 762         .dump = path_dump,
 763
 764         .start = path_start,
 765         .stop = path_stop,
 766
 767         .serialize = path_serialize,
 768         .deserialize_item = path_deserialize_item,
 769
 770         .active_state = path_active_state,
 771         .sub_state_to_string = path_sub_state_to_string,
 772
 773         .trigger_notify = path_trigger_notify,
 774
 775         .reset_failed = path_reset_failed,
 776
 777         .bus_vtable = bus_path_vtable
 778 };