journal: change direction tests to use the same convention (cp </> np)

[elogind.git] / src / journal / sd-journal.c

diff --git a/src/journal/sd-journal.c b/src/journal/sd-journal.c
index 46511df6be0dfc145ed98cd264b263c64a48d66c..1e70739295c2c0f3508e6aa0e699b55fd567bb5e 100644 (file)
--- a/src/journal/sd-journal.c
+++ b/src/journal/sd-journal.c
@@ -33,6 +33,7 @@
 #include "journal-file.h"
 #include "hashmap.h"
 #include "list.h"
 #include "journal-file.h"
 #include "hashmap.h"
 #include "list.h"

+#include "strv.h"

 #include "path-util.h"
 #include "lookup3.h"
 #include "compress.h"
 #include "path-util.h"
 #include "lookup3.h"
 #include "compress.h"


@@ -101,7 +102,8 @@ static void init_location(Location *l, LocationType type, JournalFile *f, Object
         l->seqnum_set = l->realtime_set = l->monotonic_set = l->xor_hash_set = true;
 }
 
         l->seqnum_set = l->realtime_set = l->monotonic_set = l->xor_hash_set = true;
 }
 

-static void set_location(sd_journal *j, LocationType type, JournalFile *f, Object *o, uint64_t offset) {
+static void set_location(sd_journal *j, LocationType type, JournalFile *f, Object *o,
+                         direction_t direction, uint64_t offset) {

         assert(j);
         assert(type == LOCATION_DISCRETE || type == LOCATION_SEEK);
         assert(f);
         assert(j);
         assert(type == LOCATION_DISCRETE || type == LOCATION_SEEK);
         assert(f);


@@ -109,12 +111,10 @@ static void set_location(sd_journal *j, LocationType type, JournalFile *f, Objec
 
         init_location(&j->current_location, type, f, o);
 
 
         init_location(&j->current_location, type, f, o);
 

-        if (j->current_file)
-                j->current_file->current_offset = 0;
-

         j->current_file = f;
         j->current_field = 0;
 
         j->current_file = f;
         j->current_field = 0;
 

+        f->last_direction = direction;

         f->current_offset = offset;
 }
 
         f->current_offset = offset;
 }
 


@@ -163,7 +163,7 @@ static bool same_field(const void *_a, size_t s, const void *_b, size_t t) {
                         return true;
         }
 
                         return true;
         }
 

-        return true;
+        assert_not_reached("\"=\" not found");

 }
 
 static Match *match_new(Match *p, MatchType t) {
 }
 
 static Match *match_new(Match *p, MatchType t) {


@@ -371,10 +371,8 @@ static char *match_make_string(Match *m) {
                         p = k;
 
                         enclose = true;
                         p = k;
 
                         enclose = true;

-                } else {
-                        free(p);
+                } else

                         p = t;
                         p = t;

-                }

         }
 
         if (enclose) {
         }
 
         if (enclose) {


@@ -587,52 +585,47 @@ static int next_for_match(
                         if (r < 0)
                                 return r;
                         else if (r > 0) {
                         if (r < 0)
                                 return r;
                         else if (r > 0) {

-                                if (np == 0 || (direction == DIRECTION_DOWN ? np > cp : np < cp))
+                                if (np == 0 || (direction == DIRECTION_DOWN ? cp < np : cp > np))

                                         np = cp;
                         }
                 }
 
                                         np = cp;
                         }
                 }
 

+                if (np == 0)
+                        return 0;
+

         } else if (m->type == MATCH_AND_TERM) {
         } else if (m->type == MATCH_AND_TERM) {

-                Match *i;
-                bool continue_looking;
+                Match *i, *last_moved;

 
                 /* Always jump to the next matching entry and repeat
 
                 /* Always jump to the next matching entry and repeat

-                 * this until we fine and offset that matches for all
+                 * this until we find an offset that matches for all

                  * matches. */
 
                 if (!m->matches)
                         return 0;
 
                  * matches. */
 
                 if (!m->matches)
                         return 0;
 

-                np = 0;
-                do {
-                        continue_looking = false;
+                r = next_for_match(j, m->matches, f, after_offset, direction, NULL, &np);
+                if (r <= 0)
+                        return r;

 
 

-                        LIST_FOREACH(matches, i, m->matches) {
-                                uint64_t cp, limit;
+                assert(direction == DIRECTION_DOWN ? np >= after_offset : np <= after_offset);
+                last_moved = m->matches;

 
 

-                                if (np == 0)
-                                        limit = after_offset;
-                                else if (direction == DIRECTION_DOWN)
-                                        limit = MAX(np, after_offset);
-                                else
-                                        limit = MIN(np, after_offset);
+                LIST_LOOP_BUT_ONE(matches, i, m->matches, last_moved) {
+                        uint64_t cp;

 
 

-                                r = next_for_match(j, i, f, limit, direction, NULL, &cp);
-                                if (r <= 0)
-                                        return r;
+                        r = next_for_match(j, i, f, np, direction, NULL, &cp);
+                        if (r <= 0)
+                                return r;

 
 

-                                if ((direction == DIRECTION_DOWN ? cp >= after_offset : cp <= after_offset) &&
-                                    (np == 0 || (direction == DIRECTION_DOWN ? cp > np : cp < np))) {
-                                        np = cp;
-                                        continue_looking = true;
-                                }
+                        assert(direction == DIRECTION_DOWN ? cp >= np : cp <= np);
+                        if (direction == DIRECTION_DOWN ? cp > np : cp < np) {
+                                np = cp;
+                                last_moved = i;

                         }
                         }

-
-                } while (continue_looking);
+                }

         }
 
         }
 

-        if (np == 0)
-                return 0;
+        assert(np > 0);

 
         r = journal_file_move_to_object(f, OBJECT_ENTRY, np, &n);
         if (r < 0)
 
         r = journal_file_move_to_object(f, OBJECT_ENTRY, np, &n);
         if (r < 0)


@@ -737,7 +730,7 @@ static int find_location_for_match(
                         if (r <= 0)
                                 return r;
 
                         if (r <= 0)
                                 return r;
 

-                        if (np == 0 || (direction == DIRECTION_DOWN ? np < cp : np > cp))
+                        if (np == 0 || (direction == DIRECTION_DOWN ? cp > np : cp < np))

                                 np = cp;
                 }
 
                                 np = cp;
                 }
 


@@ -817,7 +810,7 @@ static int next_beyond_location(sd_journal *j, JournalFile *f, direction_t direc
         assert(j);
         assert(f);
 
         assert(j);
         assert(f);
 

-        if (f->current_offset > 0) {
+        if (f->last_direction == direction && f->current_offset > 0) {

                 cp = f->current_offset;
 
                 r = journal_file_move_to_object(f, OBJECT_ENTRY, cp, &c);
                 cp = f->current_offset;
 
                 r = journal_file_move_to_object(f, OBJECT_ENTRY, cp, &c);


@@ -833,7 +826,7 @@ static int next_beyond_location(sd_journal *j, JournalFile *f, direction_t direc
                         return r;
         }
 
                         return r;
         }
 

-        /* OK, we found the spot, now let's advance until to an entry
+        /* OK, we found the spot, now let's advance until an entry

          * that is actually different from what we were previously
          * looking at. This is necessary to handle entries which exist
          * in two (or more) journal files, and which shall all be
          * that is actually different from what we were previously
          * looking at. This is necessary to handle entries which exist
          * in two (or more) journal files, and which shall all be


@@ -895,10 +888,7 @@ static int real_journal_next(sd_journal *j, direction_t direction) {
 
                         k = compare_entry_order(f, o, new_file, new_offset);
 
 
                         k = compare_entry_order(f, o, new_file, new_offset);
 

-                        if (direction == DIRECTION_DOWN)
-                                found = k < 0;
-                        else
-                                found = k > 0;
+                        found = direction == DIRECTION_DOWN ? k < 0 : k > 0;

                 }
 
                 if (found) {
                 }
 
                 if (found) {


@@ -914,7 +904,7 @@ static int real_journal_next(sd_journal *j, direction_t direction) {
         if (r < 0)
                 return r;
 
         if (r < 0)
                 return r;
 

-        set_location(j, LOCATION_DISCRETE, new_file, o, new_offset);
+        set_location(j, LOCATION_DISCRETE, new_file, o, direction, new_offset);

 
         return 1;
 }
 
         return 1;
 }


@@ -986,11 +976,11 @@ _public_ int sd_journal_get_cursor(sd_journal *j, char **cursor) {
         sd_id128_to_string(o->entry.boot_id, bid);
 
         if (asprintf(cursor,
         sd_id128_to_string(o->entry.boot_id, bid);
 
         if (asprintf(cursor,

-                     "s=%s;i=%llx;b=%s;m=%llx;t=%llx;x=%llx",
-                     sid, (unsigned long long) le64toh(o->entry.seqnum),
-                     bid, (unsigned long long) le64toh(o->entry.monotonic),
-                     (unsigned long long) le64toh(o->entry.realtime),
-                     (unsigned long long) le64toh(o->entry.xor_hash)) < 0)
+                     "s=%s;i=%"PRIx64";b=%s;m=%"PRIx64";t=%"PRIx64";x=%"PRIx64,
+                     sid, le64toh(o->entry.seqnum),
+                     bid, le64toh(o->entry.monotonic),
+                     le64toh(o->entry.realtime),
+                     le64toh(o->entry.xor_hash)) < 0)

                 return -ENOMEM;
 
         return 0;
                 return -ENOMEM;
 
         return 0;


@@ -1285,37 +1275,24 @@ static bool file_type_wanted(int flags, const char *filename) {
         return false;
 }
 
         return false;
 }
 

-static int add_file(sd_journal *j, const char *prefix, const char *filename) {
-        _cleanup_free_ char *path = NULL;
-        int r;
+static int add_any_file(sd_journal *j, const char *path) {

         JournalFile *f;
         JournalFile *f;

+        int r;

 
         assert(j);
 
         assert(j);

-        assert(prefix);
-        assert(filename);
-
-        if (!file_type_wanted(j->flags, filename))
-                return 0;
-
-        path = strjoin(prefix, "/", filename, NULL);
-        if (!path)
-                return -ENOMEM;
+        assert(path);

 
         if (hashmap_get(j->files, path))
                 return 0;
 
         if (hashmap_size(j->files) >= JOURNAL_FILES_MAX) {
 
         if (hashmap_get(j->files, path))
                 return 0;
 
         if (hashmap_size(j->files) >= JOURNAL_FILES_MAX) {

-                log_debug("Too many open journal files, not adding %s, ignoring.", path);
+                log_warning("Too many open journal files, not adding %s.", path);

                 return set_put_error(j, -ETOOMANYREFS);
         }
 
         r = journal_file_open(path, O_RDONLY, 0, false, false, NULL, j->mmap, NULL, &f);
                 return set_put_error(j, -ETOOMANYREFS);
         }
 
         r = journal_file_open(path, O_RDONLY, 0, false, false, NULL, j->mmap, NULL, &f);

-        if (r < 0) {
-                if (errno == ENOENT)
-                        return 0;
-
+        if (r < 0)

                 return r;
                 return r;

-        }

 
         /* journal_file_dump(f); */
 
 
         /* journal_file_dump(f); */
 


@@ -1334,6 +1311,28 @@ static int add_file(sd_journal *j, const char *prefix, const char *filename) {
         return 0;
 }
 
         return 0;
 }
 

+static int add_file(sd_journal *j, const char *prefix, const char *filename) {
+        _cleanup_free_ char *path = NULL;
+        int r;
+
+        assert(j);
+        assert(prefix);
+        assert(filename);
+
+        if (j->no_new_files ||
+            !file_type_wanted(j->flags, filename))
+                return 0;
+
+        path = strjoin(prefix, "/", filename, NULL);
+        if (!path)
+                return -ENOMEM;
+
+        r = add_any_file(j, path);
+        if (r == -ENOENT)
+                return 0;
+        return 0;
+}
+

 static int remove_file(sd_journal *j, const char *prefix, const char *filename) {
         char *path;
         JournalFile *f;
 static int remove_file(sd_journal *j, const char *prefix, const char *filename) {
         char *path;
         JournalFile *f;


@@ -1514,6 +1513,9 @@ static int add_root_directory(sd_journal *j, const char *p) {
                         inotify_rm_watch(j->inotify_fd, m->wd);
         }
 
                         inotify_rm_watch(j->inotify_fd, m->wd);
         }
 

+        if (j->no_new_files)
+                return 0;
+

         for (;;) {
                 struct dirent *de;
                 union dirent_storage buf;
         for (;;) {
                 struct dirent *de;
                 union dirent_storage buf;


@@ -1594,6 +1596,36 @@ static int add_search_paths(sd_journal *j) {
         return 0;
 }
 
         return 0;
 }
 

+static int add_current_paths(sd_journal *j) {
+        Iterator i;
+        JournalFile *f;
+
+        assert(j);
+        assert(j->no_new_files);
+
+        /* Simply adds all directories for files we have open as
+         * "root" directories. We don't expect errors here, so we
+         * treat them as fatal. */
+
+        HASHMAP_FOREACH(f, j->files, i) {
+                int r;
+                _cleanup_free_ char *dir;
+
+                dir = dirname_malloc(f->path);
+                if (!dir)
+                        return -ENOMEM;
+
+                r = add_root_directory(j, dir);
+                if (r < 0) {
+                        set_put_error(j, r);
+                        return r;
+                }
+        }
+
+        return 0;
+}
+
+

 static int allocate_inotify(sd_journal *j) {
         assert(j);
 
 static int allocate_inotify(sd_journal *j) {
         assert(j);
 


@@ -1704,6 +1736,40 @@ fail:
         return r;
 }
 
         return r;
 }
 

+_public_ int sd_journal_open_files(sd_journal **ret, const char **paths, int flags) {
+        sd_journal *j;
+        const char **path;
+        int r;
+
+        if (!ret)
+                return -EINVAL;
+
+        if (flags != 0)
+                return -EINVAL;
+
+        j = journal_new(flags, NULL);
+        if (!j)
+                return -ENOMEM;
+
+        STRV_FOREACH(path, paths) {
+                r = add_any_file(j, *path);
+                if (r < 0) {
+                        log_error("Failed to open %s: %s", *path, strerror(-r));
+                        goto fail;
+                }
+        }
+
+        j->no_new_files = true;
+
+        *ret = j;
+        return 0;
+
+fail:
+        sd_journal_close(j);
+
+        return r;
+}
+

 _public_ void sd_journal_close(sd_journal *j) {
         Directory *d;
         JournalFile *f;
 _public_ void sd_journal_close(sd_journal *j) {
         Directory *d;
         JournalFile *f;


@@ -2024,7 +2090,9 @@ _public_ int sd_journal_get_fd(sd_journal *j) {
 
         /* Iterate through all dirs again, to add them to the
          * inotify */
 
         /* Iterate through all dirs again, to add them to the
          * inotify */

-        if (j->path)
+        if (j->no_new_files)
+                r = add_current_paths(j);
+        else if (j->path)

                 r = add_root_directory(j, j->path);
         else
                 r = add_search_paths(j);
                 r = add_root_directory(j, j->path);
         else
                 r = add_search_paths(j);