LCOV - code coverage report
Current view: top level - journal - journal-file.h (source / functions) Hit Total Coverage
Test: systemd test coverage Lines: 4 6 66.7 %
Date: 2015-07-29 18:47:03 Functions: 2 3 66.7 %

          Line data    Source code
       1             : /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
       2             : 
       3             : #pragma once
       4             : 
       5             : /***
       6             :   This file is part of systemd.
       7             : 
       8             :   Copyright 2011 Lennart Poettering
       9             : 
      10             :   systemd is free software; you can redistribute it and/or modify it
      11             :   under the terms of the GNU Lesser General Public License as published by
      12             :   the Free Software Foundation; either version 2.1 of the License, or
      13             :   (at your option) any later version.
      14             : 
      15             :   systemd is distributed in the hope that it will be useful, but
      16             :   WITHOUT ANY WARRANTY; without even the implied warranty of
      17             :   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
      18             :   Lesser General Public License for more details.
      19             : 
      20             :   You should have received a copy of the GNU Lesser General Public License
      21             :   along with systemd; If not, see <http://www.gnu.org/licenses/>.
      22             : ***/
      23             : 
      24             : #include <inttypes.h>
      25             : 
      26             : #ifdef HAVE_GCRYPT
      27             : #include <gcrypt.h>
      28             : #endif
      29             : 
      30             : #include "sd-id128.h"
      31             : 
      32             : #include "sparse-endian.h"
      33             : #include "journal-def.h"
      34             : #include "macro.h"
      35             : #include "mmap-cache.h"
      36             : #include "hashmap.h"
      37             : 
      38             : typedef struct JournalMetrics {
      39             :         uint64_t max_use;
      40             :         uint64_t use;
      41             :         uint64_t max_size;
      42             :         uint64_t min_size;
      43             :         uint64_t keep_free;
      44             : } JournalMetrics;
      45             : 
      46             : typedef enum direction {
      47             :         DIRECTION_UP,
      48             :         DIRECTION_DOWN
      49             : } direction_t;
      50             : 
      51             : typedef enum LocationType {
      52             :         /* The first and last entries, resp. */
      53             :         LOCATION_HEAD,
      54             :         LOCATION_TAIL,
      55             : 
      56             :         /* We already read the entry we currently point to, and the
      57             :          * next one to read should probably not be this one again. */
      58             :         LOCATION_DISCRETE,
      59             : 
      60             :         /* We should seek to the precise location specified, and
      61             :          * return it, as we haven't read it yet. */
      62             :         LOCATION_SEEK
      63             : } LocationType;
      64             : 
      65             : typedef struct JournalFile {
      66             :         int fd;
      67             : 
      68             :         mode_t mode;
      69             : 
      70             :         int flags;
      71             :         int prot;
      72             :         bool writable:1;
      73             :         bool compress_xz:1;
      74             :         bool compress_lz4:1;
      75             :         bool seal:1;
      76             :         bool defrag_on_close:1;
      77             : 
      78             :         bool tail_entry_monotonic_valid:1;
      79             : 
      80             :         direction_t last_direction;
      81             :         LocationType location_type;
      82             :         uint64_t last_n_entries;
      83             : 
      84             :         char *path;
      85             :         struct stat last_stat;
      86             :         usec_t last_stat_usec;
      87             : 
      88             :         Header *header;
      89             :         HashItem *data_hash_table;
      90             :         HashItem *field_hash_table;
      91             : 
      92             :         uint64_t current_offset;
      93             :         uint64_t current_seqnum;
      94             :         uint64_t current_realtime;
      95             :         uint64_t current_monotonic;
      96             :         sd_id128_t current_boot_id;
      97             :         uint64_t current_xor_hash;
      98             : 
      99             :         JournalMetrics metrics;
     100             :         MMapCache *mmap;
     101             : 
     102             :         OrderedHashmap *chain_cache;
     103             : 
     104             : #if defined(HAVE_XZ) || defined(HAVE_LZ4)
     105             :         void *compress_buffer;
     106             :         size_t compress_buffer_size;
     107             : #endif
     108             : 
     109             : #ifdef HAVE_GCRYPT
     110             :         gcry_md_hd_t hmac;
     111             :         bool hmac_running;
     112             : 
     113             :         FSSHeader *fss_file;
     114             :         size_t fss_file_size;
     115             : 
     116             :         uint64_t fss_start_usec;
     117             :         uint64_t fss_interval_usec;
     118             : 
     119             :         void *fsprg_state;
     120             :         size_t fsprg_state_size;
     121             : 
     122             :         void *fsprg_seed;
     123             :         size_t fsprg_seed_size;
     124             : #endif
     125             : } JournalFile;
     126             : 
     127             : int journal_file_open(
     128             :                 const char *fname,
     129             :                 int flags,
     130             :                 mode_t mode,
     131             :                 bool compress,
     132             :                 bool seal,
     133             :                 JournalMetrics *metrics,
     134             :                 MMapCache *mmap_cache,
     135             :                 JournalFile *template,
     136             :                 JournalFile **ret);
     137             : 
     138             : int journal_file_set_offline(JournalFile *f);
     139             : void journal_file_close(JournalFile *j);
     140             : 
     141             : int journal_file_open_reliably(
     142             :                 const char *fname,
     143             :                 int flags,
     144             :                 mode_t mode,
     145             :                 bool compress,
     146             :                 bool seal,
     147             :                 JournalMetrics *metrics,
     148             :                 MMapCache *mmap_cache,
     149             :                 JournalFile *template,
     150             :                 JournalFile **ret);
     151             : 
     152             : #define ALIGN64(x) (((x) + 7ULL) & ~7ULL)
     153             : #define VALID64(x) (((x) & 7ULL) == 0ULL)
     154             : 
     155             : /* Use six characters to cover the offsets common in smallish journal
     156             :  * files without adding too many zeros. */
     157             : #define OFSfmt "%06"PRIx64
     158             : 
     159        6000 : static inline bool VALID_REALTIME(uint64_t u) {
     160             :         /* This considers timestamps until the year 3112 valid. That should be plenty room... */
     161        6000 :         return u > 0 && u < (1ULL << 55);
     162             : }
     163             : 
     164        6000 : static inline bool VALID_MONOTONIC(uint64_t u) {
     165             :         /* This considers timestamps until 1142 years of runtime valid. */
     166        6000 :         return u < (1ULL << 55);
     167             : }
     168             : 
     169           0 : static inline bool VALID_EPOCH(uint64_t u) {
     170             :         /* This allows changing the key for 1142 years, every usec. */
     171           0 :         return u < (1ULL << 55);
     172             : }
     173             : 
     174             : #define JOURNAL_HEADER_CONTAINS(h, field) \
     175             :         (le64toh((h)->header_size) >= offsetof(Header, field) + sizeof((h)->field))
     176             : 
     177             : #define JOURNAL_HEADER_SEALED(h) \
     178             :         (!!(le32toh((h)->compatible_flags) & HEADER_COMPATIBLE_SEALED))
     179             : 
     180             : #define JOURNAL_HEADER_COMPRESSED_XZ(h) \
     181             :         (!!(le32toh((h)->incompatible_flags) & HEADER_INCOMPATIBLE_COMPRESSED_XZ))
     182             : 
     183             : #define JOURNAL_HEADER_COMPRESSED_LZ4(h) \
     184             :         (!!(le32toh((h)->incompatible_flags) & HEADER_INCOMPATIBLE_COMPRESSED_LZ4))
     185             : 
     186             : int journal_file_move_to_object(JournalFile *f, ObjectType type, uint64_t offset, Object **ret);
     187             : 
     188             : uint64_t journal_file_entry_n_items(Object *o) _pure_;
     189             : uint64_t journal_file_entry_array_n_items(Object *o) _pure_;
     190             : uint64_t journal_file_hash_table_n_items(Object *o) _pure_;
     191             : 
     192             : int journal_file_append_object(JournalFile *f, ObjectType type, uint64_t size, Object **ret, uint64_t *offset);
     193             : int journal_file_append_entry(JournalFile *f, const dual_timestamp *ts, const struct iovec iovec[], unsigned n_iovec, uint64_t *seqno, Object **ret, uint64_t *offset);
     194             : 
     195             : int journal_file_find_data_object(JournalFile *f, const void *data, uint64_t size, Object **ret, uint64_t *offset);
     196             : int journal_file_find_data_object_with_hash(JournalFile *f, const void *data, uint64_t size, uint64_t hash, Object **ret, uint64_t *offset);
     197             : 
     198             : int journal_file_find_field_object(JournalFile *f, const void *field, uint64_t size, Object **ret, uint64_t *offset);
     199             : int journal_file_find_field_object_with_hash(JournalFile *f, const void *field, uint64_t size, uint64_t hash, Object **ret, uint64_t *offset);
     200             : 
     201             : void journal_file_reset_location(JournalFile *f);
     202             : void journal_file_save_location(JournalFile *f, Object *o, uint64_t offset);
     203             : int journal_file_compare_locations(JournalFile *af, JournalFile *bf);
     204             : int journal_file_next_entry(JournalFile *f, uint64_t p, direction_t direction, Object **ret, uint64_t *offset);
     205             : 
     206             : int journal_file_next_entry_for_data(JournalFile *f, Object *o, uint64_t p, uint64_t data_offset, direction_t direction, Object **ret, uint64_t *offset);
     207             : 
     208             : int journal_file_move_to_entry_by_seqnum(JournalFile *f, uint64_t seqnum, direction_t direction, Object **ret, uint64_t *offset);
     209             : int journal_file_move_to_entry_by_realtime(JournalFile *f, uint64_t realtime, direction_t direction, Object **ret, uint64_t *offset);
     210             : int journal_file_move_to_entry_by_monotonic(JournalFile *f, sd_id128_t boot_id, uint64_t monotonic, direction_t direction, Object **ret, uint64_t *offset);
     211             : 
     212             : int journal_file_move_to_entry_by_offset_for_data(JournalFile *f, uint64_t data_offset, uint64_t p, direction_t direction, Object **ret, uint64_t *offset);
     213             : int journal_file_move_to_entry_by_seqnum_for_data(JournalFile *f, uint64_t data_offset, uint64_t seqnum, direction_t direction, Object **ret, uint64_t *offset);
     214             : int journal_file_move_to_entry_by_realtime_for_data(JournalFile *f, uint64_t data_offset, uint64_t realtime, direction_t direction, Object **ret, uint64_t *offset);
     215             : int journal_file_move_to_entry_by_monotonic_for_data(JournalFile *f, uint64_t data_offset, sd_id128_t boot_id, uint64_t monotonic, direction_t direction, Object **ret, uint64_t *offset);
     216             : 
     217             : int journal_file_copy_entry(JournalFile *from, JournalFile *to, Object *o, uint64_t p, uint64_t *seqnum, Object **ret, uint64_t *offset);
     218             : 
     219             : void journal_file_dump(JournalFile *f);
     220             : void journal_file_print_header(JournalFile *f);
     221             : 
     222             : int journal_file_rotate(JournalFile **f, bool compress, bool seal);
     223             : 
     224             : void journal_file_post_change(JournalFile *f);
     225             : 
     226             : void journal_default_metrics(JournalMetrics *m, int fd);
     227             : 
     228             : int journal_file_get_cutoff_realtime_usec(JournalFile *f, usec_t *from, usec_t *to);
     229             : int journal_file_get_cutoff_monotonic_usec(JournalFile *f, sd_id128_t boot, usec_t *from, usec_t *to);
     230             : 
     231             : bool journal_file_rotate_suggested(JournalFile *f, usec_t max_file_usec);
     232             : 
     233             : int journal_file_map_data_hash_table(JournalFile *f);
     234             : int journal_file_map_field_hash_table(JournalFile *f);

Generated by: LCOV version 1.11