commit-graph.h

   1 #ifndef COMMIT_GRAPH_H
   2 #define COMMIT_GRAPH_H
   3
   4 #include "object-store-ll.h"
   5 #include "oidset.h"
   6
   7 #define GIT_TEST_COMMIT_GRAPH "GIT_TEST_COMMIT_GRAPH"
   8 #define GIT_TEST_COMMIT_GRAPH_DIE_ON_PARSE "GIT_TEST_COMMIT_GRAPH_DIE_ON_PARSE"
   9 #define GIT_TEST_COMMIT_GRAPH_CHANGED_PATHS "GIT_TEST_COMMIT_GRAPH_CHANGED_PATHS"
  10
  11 /*
  12  * This environment variable controls whether commits looked up via the
  13  * commit graph will be double checked to exist in the object database.
  14  */
  15 #define GIT_COMMIT_GRAPH_PARANOIA "GIT_COMMIT_GRAPH_PARANOIA"
  16
  17 /*
  18  * This method is only used to enhance coverage of the commit-graph
  19  * feature in the test suite with the GIT_TEST_COMMIT_GRAPH and
  20  * GIT_TEST_COMMIT_GRAPH_CHANGED_PATHS environment variables. Do not
  21  * call this method oustide of a builtin, and only if you know what
  22  * you are doing!
  23  */
  24 void git_test_write_commit_graph_or_die(void);
  25
  26 struct commit;
  27 struct bloom_filter_settings;
  28 struct repository;
  29 struct raw_object_store;
  30 struct string_list;
  31
  32 char *get_commit_graph_filename(struct object_directory *odb);
  33 char *get_commit_graph_chain_filename(struct object_directory *odb);
  34 int open_commit_graph(const char *graph_file, int *fd, struct stat *st);
  35 int open_commit_graph_chain(const char *chain_file, int *fd, struct stat *st);
  36
  37 /*
  38  * Given a commit struct, try to fill the commit struct info, including:
  39  *  1. tree object
  40  *  2. date
  41  *  3. parents.
  42  *
  43  * Returns 1 if and only if the commit was found in the packed graph.
  44  *
  45  * See parse_commit_buffer() for the fallback after this call.
  46  */
  47 int parse_commit_in_graph(struct repository *r, struct commit *item);
  48
  49 /*
  50  * Fills `*pos` with the graph position of `c`, and returns 1 if `c` is
  51  * found in the commit-graph belonging to `r`, or 0 otherwise.
  52  * Initializes the commit-graph belonging to `r` if it hasn't been
  53  * already.
  54  *
  55  * Note: this is a low-level helper that does not alter any slab data
  56  * associated with `c`. Useful in circumstances where the slab data is
  57  * already being modified (e.g., writing the commit-graph itself).
  58  *
  59  * In most cases, callers should use `parse_commit_in_graph()` instead.
  60  */
  61 int repo_find_commit_pos_in_graph(struct repository *r, struct commit *c,
  62                                   uint32_t *pos);
  63
  64 /*
  65  * Look up the given commit ID in the commit-graph. This will only return a
  66  * commit if the ID exists both in the graph and in the object database such
  67  * that we don't return commits whose object has been pruned. Otherwise, this
  68  * function returns `NULL`.
  69  */
  70 struct commit *lookup_commit_in_graph(struct repository *repo, const struct object_id *id);
  71
  72 /*
  73  * It is possible that we loaded commit contents from the commit buffer,
  74  * but we also want to ensure the commit-graph content is correctly
  75  * checked and filled. Fill the graph_pos and generation members of
  76  * the given commit.
  77  */
  78 void load_commit_graph_info(struct repository *r, struct commit *item);
  79
  80 struct tree *get_commit_tree_in_graph(struct repository *r,
  81                                       const struct commit *c);
  82
  83 struct commit_graph {
  84         const unsigned char *data;
  85         size_t data_len;
  86
  87         unsigned char hash_len;
  88         unsigned char num_chunks;
  89         uint32_t num_commits;
  90         struct object_id oid;
  91         char *filename;
  92         struct object_directory *odb;
  93
  94         uint32_t num_commits_in_base;
  95         unsigned int read_generation_data;
  96         struct commit_graph *base_graph;
  97
  98         const uint32_t *chunk_oid_fanout;
  99         const unsigned char *chunk_oid_lookup;
 100         const unsigned char *chunk_commit_data;
 101         const unsigned char *chunk_generation_data;
 102         const unsigned char *chunk_generation_data_overflow;
 103         size_t chunk_generation_data_overflow_size;
 104         const unsigned char *chunk_extra_edges;
 105         size_t chunk_extra_edges_size;
 106         const unsigned char *chunk_base_graphs;
 107         size_t chunk_base_graphs_size;
 108         const unsigned char *chunk_bloom_indexes;
 109         const unsigned char *chunk_bloom_data;
 110         size_t chunk_bloom_data_size;
 111
 112         struct topo_level_slab *topo_levels;
 113         struct bloom_filter_settings *bloom_filter_settings;
 114 };
 115
 116 struct commit_graph *load_commit_graph_one_fd_st(struct repository *r,
 117                                                  int fd, struct stat *st,
 118                                                  struct object_directory *odb);
 119 struct commit_graph *load_commit_graph_chain_fd_st(struct repository *r,
 120                                                    int fd, struct stat *st,
 121                                                    int *incomplete_chain);
 122 struct commit_graph *read_commit_graph_one(struct repository *r,
 123                                            struct object_directory *odb);
 124
 125 struct repo_settings;
 126
 127 /*
 128  * Callers should initialize the repo_settings with prepare_repo_settings()
 129  * prior to calling parse_commit_graph().
 130  */
 131 struct commit_graph *parse_commit_graph(struct repo_settings *s,
 132                                         void *graph_map, size_t graph_size);
 133
 134 /*
 135  * Return 1 if and only if the repository has a commit-graph
 136  * file and generation numbers are computed in that file.
 137  */
 138 int generation_numbers_enabled(struct repository *r);
 139
 140 /*
 141  * Return 1 if and only if the repository has a commit-graph
 142  * file and generation data chunk has been written for the file.
 143  */
 144 int corrected_commit_dates_enabled(struct repository *r);
 145
 146 struct bloom_filter_settings *get_bloom_filter_settings(struct repository *r);
 147
 148 enum commit_graph_write_flags {
 149         COMMIT_GRAPH_WRITE_APPEND     = (1 << 0),
 150         COMMIT_GRAPH_WRITE_PROGRESS   = (1 << 1),
 151         COMMIT_GRAPH_WRITE_SPLIT      = (1 << 2),
 152         COMMIT_GRAPH_WRITE_BLOOM_FILTERS = (1 << 3),
 153         COMMIT_GRAPH_NO_WRITE_BLOOM_FILTERS = (1 << 4),
 154 };
 155
 156 enum commit_graph_split_flags {
 157         COMMIT_GRAPH_SPLIT_UNSPECIFIED      = 0,
 158         COMMIT_GRAPH_SPLIT_MERGE_PROHIBITED = 1,
 159         COMMIT_GRAPH_SPLIT_REPLACE          = 2
 160 };
 161
 162 struct commit_graph_opts {
 163         int size_multiple;
 164         int max_commits;
 165         timestamp_t expire_time;
 166         enum commit_graph_split_flags split_flags;
 167         int max_new_filters;
 168 };
 169
 170 /*
 171  * The write_commit_graph* methods return zero on success
 172  * and a negative value on failure. Note that if the repository
 173  * is not compatible with the commit-graph feature, then the
 174  * methods will return 0 without writing a commit-graph.
 175  */
 176 int write_commit_graph_reachable(struct object_directory *odb,
 177                                  enum commit_graph_write_flags flags,
 178                                  const struct commit_graph_opts *opts);
 179 int write_commit_graph(struct object_directory *odb,
 180                        const struct string_list *pack_indexes,
 181                        struct oidset *commits,
 182                        enum commit_graph_write_flags flags,
 183                        const struct commit_graph_opts *opts);
 184
 185 #define COMMIT_GRAPH_VERIFY_SHALLOW     (1 << 0)
 186
 187 int verify_commit_graph(struct repository *r, struct commit_graph *g, int flags);
 188
 189 void close_commit_graph(struct raw_object_store *);
 190 void free_commit_graph(struct commit_graph *);
 191
 192 /*
 193  * Disable further use of the commit graph in this process when parsing a
 194  * "struct commit".
 195  */
 196 void disable_commit_graph(struct repository *r);
 197
 198 struct commit_graph_data {
 199         uint32_t graph_pos;
 200         timestamp_t generation;
 201 };
 202
 203 /*
 204  * Commits should be parsed before accessing generation, graph positions.
 205  */
 206 timestamp_t commit_graph_generation(const struct commit *);
 207 uint32_t commit_graph_position(const struct commit *);
 208
 209 /*
 210  * After this method, all commits reachable from those in the given
 211  * list will have non-zero, non-infinite generation numbers.
 212  */
 213 void ensure_generations_valid(struct repository *r,
 214                               struct commit **commits, size_t nr);
 215
 216 #endif