[PATH_FAILED] = UNIT_FAILED
};
+static void path_init(Unit *u) {
+ Path *p = PATH(u);
+
+ assert(u);
+ assert(u->meta.load_state == UNIT_STUB);
+
+ p->directory_mode = 0755;
+}
+
+static void path_unwatch_one(Path *p, PathSpec *s) {
+
+ if (s->inotify_fd < 0)
+ return;
+
+ unit_unwatch_fd(UNIT(p), &s->watch);
+
+ close_nointr_nofail(s->inotify_fd);
+ s->inotify_fd = -1;
+}
+
static void path_done(Unit *u) {
Path *p = PATH(u);
PathSpec *s;
assert(p);
while ((s = p->specs)) {
+ path_unwatch_one(p, s);
LIST_REMOVE(PathSpec, spec, p->specs, s);
+ free(s->path);
free(s);
}
}
assert(p);
- LIST_FOREACH(units_per_type, other, p->meta.manager->units_per_type[UNIT_MOUNT])
+ LIST_FOREACH(units_by_type, other, p->meta.manager->units_by_type[UNIT_MOUNT])
if ((r = path_add_one_mount_link(p, (Mount*) other)) < 0)
return r;
fprintf(f,
"%sPath State: %s\n"
- "%sUnit: %s\n",
+ "%sUnit: %s\n"
+ "%sMakeDirectory: %s\n"
+ "%sDirectoryMode: %04o\n",
prefix, path_state_to_string(p->state),
- prefix, p->unit->meta.id);
+ prefix, p->unit->meta.id,
+ prefix, yes_no(p->make_directory),
+ prefix, p->directory_mode);
LIST_FOREACH(spec, s, p->specs)
fprintf(f,
s->path);
}
-static void path_unwatch_one(Path *p, PathSpec *s) {
-
- if (s->inotify_fd < 0)
- return;
-
- unit_unwatch_fd(UNIT(p), &s->watch);
-
- close_nointr_nofail(s->inotify_fd);
- s->inotify_fd = -1;
-}
-
static int path_watch_one(Path *p, PathSpec *s) {
static const int flags_table[_PATH_TYPE_MAX] = {
[PATH_EXISTS] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB,
+ [PATH_EXISTS_GLOB] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB,
[PATH_CHANGED] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB|IN_CLOSE_WRITE|IN_CREATE|IN_DELETE|IN_MOVED_FROM|IN_MOVED_TO,
[PATH_DIRECTORY_NOT_EMPTY] = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB|IN_CREATE|IN_MOVED_TO
};
bool exists = false;
- char *k;
+ char *k, *slash;
int r;
assert(p);
if ((s->primary_wd = inotify_add_watch(s->inotify_fd, k, flags_table[s->type])) >= 0)
exists = true;
- for (;;) {
+ do {
int flags;
- char *slash;
/* This assumes the path was passed through path_kill_slashes()! */
if (!(slash = strrchr(k, '/')))
break;
- *slash = 0;
+ /* Trim the path at the last slash. Keep the slash if it's the root dir. */
+ slash[slash == k] = 0;
- flags = IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB;
+ flags = IN_MOVE_SELF;
if (!exists)
- flags |= IN_CREATE | IN_MOVED_TO;
+ flags |= IN_DELETE_SELF | IN_ATTRIB | IN_CREATE | IN_MOVED_TO;
if (inotify_add_watch(s->inotify_fd, k, flags) >= 0)
exists = true;
- }
+ } while (slash != k);
return 0;
path_state_to_string(old_state),
path_state_to_string(state));
- unit_notify(UNIT(p), state_translation_table[old_state], state_translation_table[state]);
+ unit_notify(UNIT(p), state_translation_table[old_state], state_translation_table[state], true);
}
static void path_enter_waiting(Path *p, bool initial, bool recheck);
dbus_error_free(&error);
}
-
-static void path_enter_waiting(Path *p, bool initial, bool recheck) {
+static bool path_check_good(Path *p, bool initial) {
PathSpec *s;
- int r;
bool good = false;
- if (!recheck)
- goto waiting;
+ assert(p);
LIST_FOREACH(spec, s, p->specs) {
good = access(s->path, F_OK) >= 0;
break;
+ case PATH_EXISTS_GLOB:
+ good = glob_exists(s->path) > 0;
+ break;
+
case PATH_DIRECTORY_NOT_EMPTY: {
int k;
break;
}
- if (good) {
- path_enter_running(p);
- return;
- }
+ return good;
+}
+
+static void path_enter_waiting(Path *p, bool initial, bool recheck) {
+ int r;
+
+ if (recheck)
+ if (path_check_good(p, initial)) {
+ log_debug("%s got triggered.", p->meta.id);
+ path_enter_running(p);
+ return;
+ }
-waiting:
if ((r = path_watch(p)) < 0)
goto fail;
+ /* Hmm, so now we have created inotify watches, but the file
+ * might have appeared/been removed by now, so we must
+ * recheck */
+
+ if (recheck)
+ if (path_check_good(p, false)) {
+ log_debug("%s got triggered.", p->meta.id);
+ path_enter_running(p);
+ return;
+ }
+
path_set_state(p, PATH_WAITING);
return;
path_enter_dead(p, false);
}
+static void path_mkdir(Path *p) {
+ PathSpec *s;
+
+ assert(p);
+
+ if (!p->make_directory)
+ return;
+
+ LIST_FOREACH(spec, s, p->specs) {
+ int r;
+
+ if (s->type == PATH_EXISTS || s->type == PATH_EXISTS_GLOB)
+ continue;
+
+ if ((r = mkdir_p(s->path, p->directory_mode)) < 0)
+ log_warning("mkdir(%s) failed: %s", s->path, strerror(-r));
+ }
+}
+
static int path_start(Unit *u) {
Path *p = PATH(u);
if (p->unit->meta.load_state != UNIT_LOADED)
return -ENOENT;
+ path_mkdir(p);
+
p->failure = false;
path_enter_waiting(p, true, true);
p->state != PATH_RUNNING)
return;
- log_debug("inotify wakeup on %s.", u->meta.id);
+ /* log_debug("inotify wakeup on %s.", u->meta.id); */
if (events != EPOLLIN) {
log_error("Got Invalid poll event on inotify.");
goto fail;
}
+ assert(l > 0);
+
if (!(buf = malloc(l))) {
- log_error("Failed to allocate buffer: %s", strerror(-ENOMEM));
+ log_error("Failed to allocate buffer: %s", strerror(ENOMEM));
goto fail;
}
static const char* const path_type_table[_PATH_TYPE_MAX] = {
[PATH_EXISTS] = "PathExists",
+ [PATH_EXISTS_GLOB] = "PathExistsGlob",
[PATH_CHANGED] = "PathChanged",
[PATH_DIRECTORY_NOT_EMPTY] = "DirectoryNotEmpty"
};
const UnitVTable path_vtable = {
.suffix = ".path",
+ .sections =
+ "Unit\0"
+ "Path\0"
+ "Install\0",
+ .init = path_init,
.done = path_done,
.load = path_load,