X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fjournal%2Fsd-journal.c;h=82cacf3674446cd6cc600277da4a8e13364d1539;hp=c3f19ca697a4396150c8c43d99b5dd4ee00822a0;hb=54b1da83ed8cadde4a53b541a48ce303ade862f7;hpb=9f8d29834ba97052403e50ec9b358c0470fa4ceb diff --git a/src/journal/sd-journal.c b/src/journal/sd-journal.c index c3f19ca69..82cacf367 100644 --- a/src/journal/sd-journal.c +++ b/src/journal/sd-journal.c @@ -25,6 +25,8 @@ #include #include #include +#include +#include #include "sd-journal.h" #include "journal-def.h" @@ -35,9 +37,33 @@ #include "lookup3.h" #include "compress.h" #include "journal-internal.h" +#include "missing.h" +#include "catalog.h" +#include "replace-var.h" #define JOURNAL_FILES_MAX 1024 +#define JOURNAL_FILES_RECHECK_USEC (2 * USEC_PER_SEC) + +#define REPLACE_VAR_MAX 256 + +#define DEFAULT_DATA_THRESHOLD (64*1024) + +/* We return an error here only if we didn't manage to + memorize the real error. */ +static int set_put_error(sd_journal *j, int r) { + int k; + + if (r >= 0) + return r; + + k = set_ensure_allocated(&j->errors, trivial_hash_func, trivial_compare_func); + if (k < 0) + return k; + + return set_put(j->errors, INT_TO_PTR(r)); +} + static void detach_location(sd_journal *j) { Iterator i; JournalFile *f; @@ -58,12 +84,13 @@ static void reset_location(sd_journal *j) { zero(j->current_location); } -static void init_location(Location *l, JournalFile *f, Object *o) { +static void init_location(Location *l, LocationType type, JournalFile *f, Object *o) { assert(l); + assert(type == LOCATION_DISCRETE || type == LOCATION_SEEK); assert(f); assert(o->object.type == OBJECT_ENTRY); - l->type = LOCATION_DISCRETE; + l->type = type; l->seqnum = le64toh(o->entry.seqnum); l->seqnum_id = f->header->seqnum_id; l->realtime = le64toh(o->entry.realtime); @@ -74,12 +101,13 @@ static void init_location(Location *l, JournalFile *f, Object *o) { l->seqnum_set = l->realtime_set = l->monotonic_set = l->xor_hash_set = true; } -static void set_location(sd_journal *j, JournalFile *f, Object *o, uint64_t offset) { +static void set_location(sd_journal *j, LocationType type, JournalFile *f, Object *o, uint64_t offset) { assert(j); + assert(type == LOCATION_DISCRETE || type == LOCATION_SEEK); assert(f); assert(o); - init_location(&j->current_location, f, o); + init_location(&j->current_location, type, f, o); j->current_file = f; j->current_field = 0; @@ -357,15 +385,27 @@ _public_ void sd_journal_flush_matches(sd_journal *j) { detach_location(j); } -static int compare_order(JournalFile *af, Object *ao, - JournalFile *bf, Object *bo) { +static int compare_entry_order(JournalFile *af, Object *_ao, + JournalFile *bf, uint64_t bp) { uint64_t a, b; + Object *ao, *bo; + int r; assert(af); - assert(ao); assert(bf); - assert(bo); + assert(_ao); + + /* The mmap cache might invalidate the object from the first + * file if we look at the one from the second file. Hence + * temporarily copy the header of the first one, and look at + * that only. */ + ao = alloca(offsetof(EntryObject, items)); + memcpy(ao, _ao, offsetof(EntryObject, items)); + + r = journal_file_move_to_object(bf, OBJECT_ENTRY, bp, &bo); + if (r < 0) + return strcmp(af->path, bf->path); /* We operate on two different files here, hence we can access * two objects at the same time, which we normally can't. @@ -435,7 +475,7 @@ static int compare_with_location(JournalFile *af, Object *ao, Location *l) { assert(af); assert(ao); assert(l); - assert(l->type == LOCATION_DISCRETE); + assert(l->type == LOCATION_DISCRETE || l->type == LOCATION_SEEK); if (l->monotonic_set && sd_id128_equal(ao->entry.boot_id, l->boot_id) && @@ -808,18 +848,17 @@ static int next_beyond_location(sd_journal *j, JournalFile *f, direction_t direc } static int real_journal_next(sd_journal *j, direction_t direction) { - JournalFile *f, *new_current = NULL; + JournalFile *f, *new_file = NULL; + uint64_t new_offset = 0; + Object *o; + uint64_t p; Iterator i; int r; - uint64_t new_offset = 0; - Object *new_entry = NULL; if (!j) return -EINVAL; HASHMAP_FOREACH(f, j->files, i) { - Object *o; - uint64_t p; bool found; r = next_beyond_location(j, f, direction, &o, &p); @@ -829,12 +868,12 @@ static int real_journal_next(sd_journal *j, direction_t direction) { } else if (r == 0) continue; - if (!new_current) + if (!new_file) found = true; else { int k; - k = compare_order(f, o, new_current, new_entry); + k = compare_entry_order(f, o, new_file, new_offset); if (direction == DIRECTION_DOWN) found = k < 0; @@ -843,16 +882,19 @@ static int real_journal_next(sd_journal *j, direction_t direction) { } if (found) { - new_current = f; - new_entry = o; + new_file = f; new_offset = p; } } - if (!new_current) + if (!new_file) return 0; - set_location(j, new_current, new_entry, new_offset); + r = journal_file_move_to_object(new_file, OBJECT_ENTRY, new_offset, &o); + if (r < 0) + return r; + + set_location(j, LOCATION_DISCRETE, new_file, o, new_offset); return 1; } @@ -924,21 +966,19 @@ _public_ int sd_journal_get_cursor(sd_journal *j, char **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;p=%s", + "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), - path_get_file_name(j->current_file->path)) < 0) + (unsigned long long) le64toh(o->entry.xor_hash)) < 0) return -ENOMEM; - return 1; + return 0; } _public_ int sd_journal_seek_cursor(sd_journal *j, const char *cursor) { - char *w; + char *w, *state; size_t l; - char *state; unsigned long long seqnum, monotonic, realtime, xor_hash; bool seqnum_id_set = false, @@ -951,7 +991,7 @@ _public_ int sd_journal_seek_cursor(sd_journal *j, const char *cursor) { if (!j) return -EINVAL; - if (!cursor) + if (isempty(cursor)) return -EINVAL; FOREACH_WORD_SEPARATOR(w, l, cursor, ";", state) { @@ -969,35 +1009,35 @@ _public_ int sd_journal_seek_cursor(sd_journal *j, const char *cursor) { case 's': seqnum_id_set = true; - k = sd_id128_from_string(w+2, &seqnum_id); + k = sd_id128_from_string(item+2, &seqnum_id); break; case 'i': seqnum_set = true; - if (sscanf(w+2, "%llx", &seqnum) != 1) + if (sscanf(item+2, "%llx", &seqnum) != 1) k = -EINVAL; break; case 'b': boot_id_set = true; - k = sd_id128_from_string(w+2, &boot_id); + k = sd_id128_from_string(item+2, &boot_id); break; case 'm': monotonic_set = true; - if (sscanf(w+2, "%llx", &monotonic) != 1) + if (sscanf(item+2, "%llx", &monotonic) != 1) k = -EINVAL; break; case 't': realtime_set = true; - if (sscanf(w+2, "%llx", &realtime) != 1) + if (sscanf(item+2, "%llx", &realtime) != 1) k = -EINVAL; break; case 'x': xor_hash_set = true; - if (sscanf(w+2, "%llx", &xor_hash) != 1) + if (sscanf(item+2, "%llx", &xor_hash) != 1) k = -EINVAL; break; } @@ -1015,7 +1055,7 @@ _public_ int sd_journal_seek_cursor(sd_journal *j, const char *cursor) { reset_location(j); - j->current_location.type = LOCATION_DISCRETE; + j->current_location.type = LOCATION_SEEK; if (realtime_set) { j->current_location.realtime = (uint64_t) realtime; @@ -1042,12 +1082,95 @@ _public_ int sd_journal_seek_cursor(sd_journal *j, const char *cursor) { return 0; } +_public_ int sd_journal_test_cursor(sd_journal *j, const char *cursor) { + int r; + char *w, *state; + size_t l; + Object *o; + + if (!j) + return -EINVAL; + if (isempty(cursor)) + return -EINVAL; + + if (!j->current_file || j->current_file->current_offset <= 0) + return -EADDRNOTAVAIL; + + r = journal_file_move_to_object(j->current_file, OBJECT_ENTRY, j->current_file->current_offset, &o); + if (r < 0) + return r; + + FOREACH_WORD_SEPARATOR(w, l, cursor, ";", state) { + _cleanup_free_ char *item = NULL; + sd_id128_t id; + unsigned long long ll; + int k = 0; + + if (l < 2 || w[1] != '=') + return -EINVAL; + + item = strndup(w, l); + if (!item) + return -ENOMEM; + + switch (w[0]) { + + case 's': + k = sd_id128_from_string(item+2, &id); + if (k < 0) + return k; + if (!sd_id128_equal(id, j->current_file->header->seqnum_id)) + return 0; + break; + + case 'i': + if (sscanf(item+2, "%llx", &ll) != 1) + return -EINVAL; + if (ll != le64toh(o->entry.seqnum)) + return 0; + break; + + case 'b': + k = sd_id128_from_string(item+2, &id); + if (k < 0) + return k; + if (!sd_id128_equal(id, o->entry.boot_id)) + return 0; + break; + + case 'm': + if (sscanf(item+2, "%llx", &ll) != 1) + return -EINVAL; + if (ll != le64toh(o->entry.monotonic)) + return 0; + break; + + case 't': + if (sscanf(item+2, "%llx", &ll) != 1) + return -EINVAL; + if (ll != le64toh(o->entry.realtime)) + return 0; + break; + + case 'x': + if (sscanf(item+2, "%llx", &ll) != 1) + return -EINVAL; + if (ll != le64toh(o->entry.xor_hash)) + return 0; + break; + } + } + + return 1; +} + + _public_ int sd_journal_seek_monotonic_usec(sd_journal *j, sd_id128_t boot_id, uint64_t usec) { if (!j) return -EINVAL; reset_location(j); - j->current_location.type = LOCATION_DISCRETE; + j->current_location.type = LOCATION_SEEK; j->current_location.boot_id = boot_id; j->current_location.monotonic = usec; j->current_location.monotonic_set = true; @@ -1060,7 +1183,7 @@ _public_ int sd_journal_seek_realtime_usec(sd_journal *j, uint64_t usec) { return -EINVAL; reset_location(j); - j->current_location.type = LOCATION_DISCRETE; + j->current_location.type = LOCATION_SEEK; j->current_location.realtime = usec; j->current_location.realtime_set = true; @@ -1087,8 +1210,27 @@ _public_ int sd_journal_seek_tail(sd_journal *j) { return 0; } +static void check_network(sd_journal *j, int fd) { + struct statfs sfs; + + assert(j); + + if (j->on_network) + return; + + if (fstatfs(fd, &sfs) < 0) + return; + + j->on_network = + (long)sfs.f_type == (long)CIFS_MAGIC_NUMBER || + sfs.f_type == CODA_SUPER_MAGIC || + sfs.f_type == NCP_SUPER_MAGIC || + sfs.f_type == NFS_SUPER_MAGIC || + sfs.f_type == SMB_SUPER_MAGIC; +} + static int add_file(sd_journal *j, const char *prefix, const char *filename) { - char *path; + char _cleanup_free_ *path = NULL; int r; JournalFile *f; @@ -1098,27 +1240,24 @@ static int add_file(sd_journal *j, const char *prefix, const char *filename) { if ((j->flags & SD_JOURNAL_SYSTEM_ONLY) && !(streq(filename, "system.journal") || - (startswith(filename, "system@") && endswith(filename, ".journal")))) + streq(filename, "system.journal~") || + (startswith(filename, "system@") && + (endswith(filename, ".journal") || endswith(filename, ".journal~"))))) return 0; path = strjoin(prefix, "/", filename, NULL); if (!path) return -ENOMEM; - if (hashmap_get(j->files, path)) { - free(path); + 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); - free(path); - return 0; + return set_put_error(j, -ETOOMANYREFS); } - r = journal_file_open(path, O_RDONLY, 0, NULL, NULL, &f); - free(path); - + r = journal_file_open(path, O_RDONLY, 0, false, false, NULL, j->mmap, NULL, &f); if (r < 0) { if (errno == ENOENT) return 0; @@ -1134,10 +1273,12 @@ static int add_file(sd_journal *j, const char *prefix, const char *filename) { return r; } - j->current_invalidate_counter ++; - log_debug("File %s got added.", f->path); + check_network(j, f->fd); + + j->current_invalidate_counter ++; + return 0; } @@ -1159,18 +1300,30 @@ static int remove_file(sd_journal *j, const char *prefix, const char *filename) return 0; hashmap_remove(j->files, f->path); + + log_debug("File %s got removed.", f->path); + + if (j->current_file == f) { + j->current_file = NULL; + j->current_field = 0; + } + + if (j->unique_file == f) { + j->unique_file = NULL; + j->unique_offset = 0; + } + journal_file_close(f); j->current_invalidate_counter ++; - log_debug("File %s got removed.", f->path); return 0; } static int add_directory(sd_journal *j, const char *prefix, const char *dirname) { - char *path; + char _cleanup_free_ *path = NULL; int r; - DIR *d; + DIR _cleanup_closedir_ *d = NULL; sd_id128_t id, mid; Directory *m; @@ -1178,10 +1331,12 @@ static int add_directory(sd_journal *j, const char *prefix, const char *dirname) assert(prefix); assert(dirname); + log_debug("Considering %s/%s.", prefix, dirname); + if ((j->flags & SD_JOURNAL_LOCAL_ONLY) && (sd_id128_from_string(dirname, &id) < 0 || sd_id128_get_machine(&mid) < 0 || - !sd_id128_equal(id, mid))) + !(sd_id128_equal(id, mid) || path_startswith(prefix, "/run")))) return 0; path = strjoin(prefix, "/", dirname, NULL); @@ -1191,8 +1346,6 @@ static int add_directory(sd_journal *j, const char *prefix, const char *dirname) d = opendir(path); if (!d) { log_debug("Failed to open %s: %m", path); - free(path); - if (errno == ENOENT) return 0; return -errno; @@ -1201,65 +1354,64 @@ static int add_directory(sd_journal *j, const char *prefix, const char *dirname) m = hashmap_get(j->directories_by_path, path); if (!m) { m = new0(Directory, 1); - if (!m) { - closedir(d); - free(path); + if (!m) return -ENOMEM; - } m->is_root = false; m->path = path; if (hashmap_put(j->directories_by_path, m->path, m) < 0) { - closedir(d); - free(m->path); free(m); return -ENOMEM; } + path = NULL; /* avoid freeing in cleanup */ j->current_invalidate_counter ++; log_debug("Directory %s got added.", m->path); - } else if (m->is_root) { - free (path); - closedir(d); + } else if (m->is_root) return 0; - } else - free(path); if (m->wd <= 0 && j->inotify_fd >= 0) { m->wd = inotify_add_watch(j->inotify_fd, m->path, IN_CREATE|IN_MOVED_TO|IN_MODIFY|IN_ATTRIB|IN_DELETE| - IN_DELETE_SELF|IN_MOVE_SELF|IN_UNMOUNT| - IN_DONT_FOLLOW|IN_ONLYDIR); + IN_DELETE_SELF|IN_MOVE_SELF|IN_UNMOUNT|IN_MOVED_FROM| + IN_ONLYDIR); if (m->wd > 0 && hashmap_put(j->directories_by_wd, INT_TO_PTR(m->wd), m) < 0) inotify_rm_watch(j->inotify_fd, m->wd); } for (;;) { - struct dirent buf, *de; + struct dirent *de; + union dirent_storage buf; - r = readdir_r(d, &buf, &de); + r = readdir_r(d, &buf.de, &de); if (r != 0 || !de) break; - if (dirent_is_file_with_suffix(de, ".journal")) { + if (dirent_is_file_with_suffix(de, ".journal") || + dirent_is_file_with_suffix(de, ".journal~")) { r = add_file(j, m->path, de->d_name); - if (r < 0) - log_debug("Failed to add file %s/%s: %s", m->path, de->d_name, strerror(-r)); + if (r < 0) { + log_debug("Failed to add file %s/%s: %s", + m->path, de->d_name, strerror(-r)); + r = set_put_error(j, r); + if (r < 0) + return r; + } } } - closedir(d); + check_network(j, dirfd(d)); return 0; } static int add_root_directory(sd_journal *j, const char *p) { - DIR *d; + DIR _cleanup_closedir_ *d = NULL; Directory *m; int r; @@ -1277,21 +1429,17 @@ static int add_root_directory(sd_journal *j, const char *p) { m = hashmap_get(j->directories_by_path, p); if (!m) { m = new0(Directory, 1); - if (!m) { - closedir(d); + if (!m) return -ENOMEM; - } m->is_root = true; m->path = strdup(p); if (!m->path) { - closedir(d); free(m); return -ENOMEM; } if (hashmap_put(j->directories_by_path, m->path, m) < 0) { - closedir(d); free(m->path); free(m); return -ENOMEM; @@ -1301,35 +1449,39 @@ static int add_root_directory(sd_journal *j, const char *p) { log_debug("Root directory %s got added.", m->path); - } else if (!m->is_root) { - closedir(d); + } else if (!m->is_root) return 0; - } if (m->wd <= 0 && j->inotify_fd >= 0) { m->wd = inotify_add_watch(j->inotify_fd, m->path, IN_CREATE|IN_MOVED_TO|IN_MODIFY|IN_ATTRIB|IN_DELETE| - IN_DONT_FOLLOW|IN_ONLYDIR); + IN_ONLYDIR); if (m->wd > 0 && hashmap_put(j->directories_by_wd, INT_TO_PTR(m->wd), m) < 0) inotify_rm_watch(j->inotify_fd, m->wd); } for (;;) { - struct dirent buf, *de; + struct dirent *de; + union dirent_storage buf; sd_id128_t id; - r = readdir_r(d, &buf, &de); + r = readdir_r(d, &buf.de, &de); if (r != 0 || !de) break; - if (dirent_is_file_with_suffix(de, ".journal")) { + if (dirent_is_file_with_suffix(de, ".journal") || + dirent_is_file_with_suffix(de, ".journal~")) { r = add_file(j, m->path, de->d_name); - if (r < 0) - log_debug("Failed to add file %s/%s: %s", m->path, de->d_name, strerror(-r)); - - } else if ((de->d_type == DT_DIR || de->d_type == DT_UNKNOWN) && + if (r < 0) { + log_debug("Failed to add file %s/%s: %s", + m->path, de->d_name, strerror(-r)); + r = set_put_error(j, r); + if (r < 0) + return r; + } + } else if ((de->d_type == DT_DIR || de->d_type == DT_LNK || de->d_type == DT_UNKNOWN) && sd_id128_from_string(de->d_name, &id) >= 0) { r = add_directory(j, m->path, de->d_name); @@ -1338,7 +1490,7 @@ static int add_root_directory(sd_journal *j, const char *p) { } } - closedir(d); + check_network(j, dirfd(d)); return 0; } @@ -1367,7 +1519,7 @@ static int remove_directory(sd_journal *j, Directory *d) { } static int add_search_paths(sd_journal *j) { - + int r; const char search_paths[] = "/run/log/journal\0" "/var/log/journal\0"; @@ -1378,8 +1530,14 @@ static int add_search_paths(sd_journal *j) { /* We ignore most errors here, since the idea is to only open * what's actually accessible, and ignore the rest. */ - NULSTR_FOREACH(p, search_paths) - add_root_directory(j, p); + NULSTR_FOREACH(p, search_paths) { + r = add_root_directory(j, p); + if (r < 0 && r != -ENOENT) { + r = set_put_error(j, r); + if (r < 0) + return r; + } + } return 0; } @@ -1402,7 +1560,7 @@ static int allocate_inotify(sd_journal *j) { return 0; } -static sd_journal *journal_new(int flags) { +static sd_journal *journal_new(int flags, const char *path) { sd_journal *j; j = new0(sd_journal, 1); @@ -1411,21 +1569,25 @@ static sd_journal *journal_new(int flags) { j->inotify_fd = -1; j->flags = flags; + j->data_threshold = DEFAULT_DATA_THRESHOLD; - j->files = hashmap_new(string_hash_func, string_compare_func); - if (!j->files) { - free(j); - return NULL; + if (path) { + j->path = strdup(path); + if (!j->path) + goto fail; } + j->files = hashmap_new(string_hash_func, string_compare_func); j->directories_by_path = hashmap_new(string_hash_func, string_compare_func); - if (!j->directories_by_path) { - hashmap_free(j->files); - free(j); - return NULL; - } + j->mmap = mmap_cache_new(); + if (!j->files || !j->directories_by_path || !j->mmap) + goto fail; return j; + +fail: + sd_journal_close(j); + return NULL; } _public_ int sd_journal_open(sd_journal **ret, int flags) { @@ -1440,7 +1602,7 @@ _public_ int sd_journal_open(sd_journal **ret, int flags) { SD_JOURNAL_SYSTEM_ONLY)) return -EINVAL; - j = journal_new(flags); + j = journal_new(flags, NULL); if (!j) return -ENOMEM; @@ -1464,19 +1626,21 @@ _public_ int sd_journal_open_directory(sd_journal **ret, const char *path, int f if (!ret) return -EINVAL; - if (!path || !path_is_absolute(path)) + if (!path) return -EINVAL; if (flags != 0) return -EINVAL; - j = journal_new(flags); + j = journal_new(flags, path); if (!j) return -ENOMEM; r = add_root_directory(j, path); - if (r < 0) + if (r < 0) { + set_put_error(j, r); goto fail; + } *ret = j; return 0; @@ -1494,6 +1658,8 @@ _public_ void sd_journal_close(sd_journal *j) { if (!j) return; + sd_journal_flush_matches(j); + while ((f = hashmap_steal_first(j->files))) journal_file_close(f); @@ -1511,8 +1677,12 @@ _public_ void sd_journal_close(sd_journal *j) { if (j->inotify_fd >= 0) close_nointr_nofail(j->inotify_fd); - sd_journal_flush_matches(j); + if (j->mmap) + mmap_cache_unref(j->mmap); + free(j->path); + free(j->unique_field); + set_free(j->errors); free(j); } @@ -1665,7 +1835,8 @@ _public_ int sd_journal_get_data(sd_journal *j, const char *field, const void ** uint64_t rsize; if (!uncompress_blob(o->data.payload, l, - &f->compress_buffer, &f->compress_buffer_size, &rsize)) + &f->compress_buffer, &f->compress_buffer_size, &rsize, + j->data_threshold)) return -EBADMSG; *data = f->compress_buffer; @@ -1700,13 +1871,43 @@ _public_ int sd_journal_get_data(sd_journal *j, const char *field, const void ** return -ENOENT; } +static int return_data(sd_journal *j, JournalFile *f, Object *o, const void **data, size_t *size) { + size_t t; + uint64_t l; + + l = le64toh(o->object.size) - offsetof(Object, data.payload); + t = (size_t) l; + + /* We can't read objects larger than 4G on a 32bit machine */ + if ((uint64_t) t != l) + return -E2BIG; + + if (o->object.flags & OBJECT_COMPRESSED) { +#ifdef HAVE_XZ + uint64_t rsize; + + if (!uncompress_blob(o->data.payload, l, &f->compress_buffer, &f->compress_buffer_size, &rsize, j->data_threshold)) + return -EBADMSG; + + *data = f->compress_buffer; + *size = (size_t) rsize; +#else + return -EPROTONOSUPPORT; +#endif + } else { + *data = o->data.payload; + *size = t; + } + + return 0; +} + _public_ int sd_journal_enumerate_data(sd_journal *j, const void **data, size_t *size) { JournalFile *f; - uint64_t p, l, n; + uint64_t p, n; le64_t le_hash; int r; Object *o; - size_t t; if (!j) return -EINVAL; @@ -1739,29 +1940,9 @@ _public_ int sd_journal_enumerate_data(sd_journal *j, const void **data, size_t if (le_hash != o->data.hash) return -EBADMSG; - l = le64toh(o->object.size) - offsetof(Object, data.payload); - t = (size_t) l; - - /* We can't read objects larger than 4G on a 32bit machine */ - if ((uint64_t) t != l) - return -E2BIG; - - if (o->object.flags & OBJECT_COMPRESSED) { -#ifdef HAVE_XZ - uint64_t rsize; - - if (!uncompress_blob(o->data.payload, l, &f->compress_buffer, &f->compress_buffer_size, &rsize)) - return -EBADMSG; - - *data = f->compress_buffer; - *size = (size_t) rsize; -#else - return -EPROTONOSUPPORT; -#endif - } else { - *data = o->data.payload; - *size = t; - } + r = return_data(j, f, o, data, size); + if (r < 0) + return r; j->current_field ++; @@ -1790,7 +1971,10 @@ _public_ int sd_journal_get_fd(sd_journal *j) { /* Iterate through all dirs again, to add them to the * inotify */ - r = add_search_paths(j); + if (j->path) + r = add_root_directory(j, j->path); + else + r = add_search_paths(j); if (r < 0) return r; @@ -1809,16 +1993,21 @@ static void process_inotify_event(sd_journal *j, struct inotify_event *e) { if (d) { sd_id128_t id; - if (!(e->mask & IN_ISDIR) && e->len > 0 && endswith(e->name, ".journal")) { + if (!(e->mask & IN_ISDIR) && e->len > 0 && + (endswith(e->name, ".journal") || + endswith(e->name, ".journal~"))) { /* Event for a journal file */ if (e->mask & (IN_CREATE|IN_MOVED_TO|IN_MODIFY|IN_ATTRIB)) { r = add_file(j, d->path, e->name); - if (r < 0) - log_debug("Failed to add file %s/%s: %s", d->path, e->name, strerror(-r)); + if (r < 0) { + log_debug("Failed to add file %s/%s: %s", + d->path, e->name, strerror(-r)); + set_put_error(j, r); + } - } else if (e->mask & (IN_DELETE|IN_UNMOUNT)) { + } else if (e->mask & (IN_DELETE|IN_MOVED_FROM|IN_UNMOUNT)) { r = remove_file(j, d->path, e->name); if (r < 0) @@ -1925,6 +2114,14 @@ _public_ int sd_journal_wait(sd_journal *j, uint64_t timeout_usec) { return determine_change(j); } + if (j->on_network) { + /* If we are on the network we need to regularly check + * for changes manually */ + + if (timeout_usec == (uint64_t) -1 || timeout_usec > JOURNAL_FILES_RECHECK_USEC) + timeout_usec = JOURNAL_FILES_RECHECK_USEC; + } + do { r = fd_wait_for_event(j->inotify_fd, POLLIN, timeout_usec); } while (r == -EINTR); @@ -1967,7 +2164,7 @@ _public_ int sd_journal_get_cutoff_realtime_usec(sd_journal *j, uint64_t *from, if (from) *from = MIN(fr, *from); if (to) - *to = MIN(t, *to); + *to = MAX(t, *to); } } @@ -2006,7 +2203,7 @@ _public_ int sd_journal_get_cutoff_monotonic_usec(sd_journal *j, sd_id128_t boot if (from) *from = MIN(fr, *from); if (to) - *to = MIN(t, *to); + *to = MAX(t, *to); } } @@ -2030,27 +2227,251 @@ void journal_print_header(sd_journal *j) { } } -/* _public_ int sd_journal_query_unique(sd_journal *j, const char *field) { */ -/* if (!j) */ -/* return -EINVAL; */ -/* if (!field) */ -/* return -EINVAL; */ +_public_ int sd_journal_get_usage(sd_journal *j, uint64_t *bytes) { + Iterator i; + JournalFile *f; + uint64_t sum = 0; + + if (!j) + return -EINVAL; + if (!bytes) + return -EINVAL; + + HASHMAP_FOREACH(f, j->files, i) { + struct stat st; + + if (fstat(f->fd, &st) < 0) + return -errno; + + sum += (uint64_t) st.st_blocks * 512ULL; + } + + *bytes = sum; + return 0; +} + +_public_ int sd_journal_query_unique(sd_journal *j, const char *field) { + char *f; + + if (!j) + return -EINVAL; + if (isempty(field)) + return -EINVAL; + if (!field_is_valid(field)) + return -EINVAL; + + f = strdup(field); + if (!f) + return -ENOMEM; + + free(j->unique_field); + j->unique_field = f; + j->unique_file = NULL; + j->unique_offset = 0; + + return 0; +} + +_public_ int sd_journal_enumerate_unique(sd_journal *j, const void **data, size_t *l) { + Object *o; + size_t k; + int r; + + if (!j) + return -EINVAL; + if (!data) + return -EINVAL; + if (!l) + return -EINVAL; + if (!j->unique_field) + return -EINVAL; + + k = strlen(j->unique_field); + + if (!j->unique_file) { + j->unique_file = hashmap_first(j->files); + if (!j->unique_file) + return 0; + j->unique_offset = 0; + } + + for (;;) { + JournalFile *of; + Iterator i; + const void *odata; + size_t ol; + bool found; + + /* Proceed to next data object in the field's linked list */ + if (j->unique_offset == 0) { + r = journal_file_find_field_object(j->unique_file, j->unique_field, k, &o, NULL); + if (r < 0) + return r; + + j->unique_offset = r > 0 ? le64toh(o->field.head_data_offset) : 0; + } else { + r = journal_file_move_to_object(j->unique_file, OBJECT_DATA, j->unique_offset, &o); + if (r < 0) + return r; + + j->unique_offset = le64toh(o->data.next_field_offset); + } + + /* We reached the end of the list? Then start again, with the next file */ + if (j->unique_offset == 0) { + JournalFile *n; + + n = hashmap_next(j->files, j->unique_file->path); + if (!n) + return 0; + + j->unique_file = n; + continue; + } + + /* We do not use the type context here, but 0 instead, + * so that we can look at this data object at the same + * time as one on another file */ + r = journal_file_move_to_object(j->unique_file, 0, j->unique_offset, &o); + if (r < 0) + return r; + + /* Let's do the type check by hand, since we used 0 context above. */ + if (o->object.type != OBJECT_DATA) + return -EBADMSG; + + r = return_data(j, j->unique_file, o, &odata, &ol); + if (r < 0) + return r; + + /* OK, now let's see if we already returned this data + * object by checking if it exists in the earlier + * traversed files. */ + found = false; + HASHMAP_FOREACH(of, j->files, i) { + Object *oo; + uint64_t op; + + if (of == j->unique_file) + break; + + /* Skip this file it didn't have any fields + * indexed */ + if (JOURNAL_HEADER_CONTAINS(of->header, n_fields) && + le64toh(of->header->n_fields) <= 0) + continue; + + r = journal_file_find_data_object_with_hash(of, odata, ol, le64toh(o->data.hash), &oo, &op); + if (r < 0) + return r; + + if (r > 0) + found = true; + } + + if (found) + continue; + + r = return_data(j, j->unique_file, o, data, l); + if (r < 0) + return r; + + return 1; + } +} + +_public_ void sd_journal_restart_unique(sd_journal *j) { + if (!j) + return; + + j->unique_file = NULL; + j->unique_offset = 0; +} + +_public_ int sd_journal_reliable_fd(sd_journal *j) { + if (!j) + return -EINVAL; + + return !j->on_network; +} + +static char *lookup_field(const char *field, void *userdata) { + sd_journal *j = userdata; + const void *data; + size_t size, d; + int r; + + assert(field); + assert(j); + + r = sd_journal_get_data(j, field, &data, &size); + if (r < 0 || + size > REPLACE_VAR_MAX) + return strdup(field); + + d = strlen(field) + 1; + + return strndup((const char*) data + d, size - d); +} + +_public_ int sd_journal_get_catalog(sd_journal *j, char **ret) { + const void *data; + size_t size; + sd_id128_t id; + _cleanup_free_ char *text = NULL, *cid = NULL; + char *t; + int r; + + if (!j) + return -EINVAL; + if (!ret) + return -EINVAL; + + r = sd_journal_get_data(j, "MESSAGE_ID", &data, &size); + if (r < 0) + return r; + + cid = strndup((const char*) data + 11, size - 11); + if (!cid) + return -ENOMEM; + + r = sd_id128_from_string(cid, &id); + if (r < 0) + return r; + + r = catalog_get(id, &text); + if (r < 0) + return r; + + t = replace_var(text, lookup_field, j); + if (!t) + return -ENOMEM; + + *ret = t; + return 0; +} + +_public_ int sd_journal_get_catalog_for_message_id(sd_id128_t id, char **ret) { + if (!ret) + return -EINVAL; + + return catalog_get(id, ret); +} -/* return -ENOTSUP; */ -/* } */ +_public_ int sd_journal_set_data_threshold(sd_journal *j, size_t sz) { + if (!j) + return -EINVAL; -/* _public_ int sd_journal_enumerate_unique(sd_journal *j, const void **data, size_t *l) { */ -/* if (!j) */ -/* return -EINVAL; */ -/* if (!data) */ -/* return -EINVAL; */ -/* if (!l) */ -/* return -EINVAL; */ + j->data_threshold = sz; + return 0; +} -/* return -ENOTSUP; */ -/* } */ +_public_ int sd_journal_get_data_threshold(sd_journal *j, size_t *sz) { + if (!j) + return -EINVAL; + if (!sz) + return -EINVAL; -/* _public_ void sd_journal_restart_unique(sd_journal *j) { */ -/* if (!j) */ -/* return; */ -/* } */ + *sz = j->data_threshold; + return 0; +}