global/git
1
0
Fork 0
mirror of https://github.com/git/git.git synced 2026-01-10 10:13:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

reftable/stack: reorder code to avoid forward declarations

Browse Source 
We have a couple of forward declarations in the stack-related code of
the reftable library. These declarations aren't really required, but are
simply caused by unfortunate ordering.

Reorder the code and remove the forward declarations.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
Patrick Steinhardt
2025-08-12 11:54:17 +02:00
committed by Junio C Hamano
parent d4a2159a78
commit 5ed5f5dc01
1 changed files with 176 additions and 188 deletions
Download Patch File Download Diff File Expand all files Collapse all files

364
reftable/stack.c
View File

@@ -17,18 +17,6 @@
#include "table.h" #include "table.h"
#include "writer.h" #include "writer.h"
static int stack_try_add(struct reftable_stack *st,
int (*write_table)(struct reftable_writer *wr,
void *arg),
void *arg);
static int stack_write_compact(struct reftable_stack *st,
struct reftable_writer *wr,
size_t first, size_t last,
struct reftable_log_expiry_config *config);
static void reftable_addition_close(struct reftable_addition *add);
static int reftable_stack_reload_maybe_reuse(struct reftable_stack *st,
int reuse_open);
static int stack_filename(struct reftable_buf *dest, struct reftable_stack *st, static int stack_filename(struct reftable_buf *dest, struct reftable_stack *st,
const char *name) const char *name)
{ {
@@ -84,54 +72,6 @@ static int fd_writer_flush(void *arg)
return stack_fsync(writer->opts, writer->fd); return stack_fsync(writer->opts, writer->fd);
} }
int reftable_new_stack(struct reftable_stack **dest, const char *dir,
const struct reftable_write_options *_opts)
{
struct reftable_buf list_file_name = REFTABLE_BUF_INIT;
struct reftable_write_options opts = { 0 };
struct reftable_stack *p;
int err;
p = reftable_calloc(1, sizeof(*p));
if (!p) {
err = REFTABLE_OUT_OF_MEMORY_ERROR;
goto out;
}
if (_opts)
opts = *_opts;
if (opts.hash_id == 0)
opts.hash_id = REFTABLE_HASH_SHA1;
*dest = NULL;
reftable_buf_reset(&list_file_name);
if ((err = reftable_buf_addstr(&list_file_name, dir)) < 0 ||
(err = reftable_buf_addstr(&list_file_name, "/tables.list")) < 0)
goto out;
p->list_file = reftable_buf_detach(&list_file_name);
p->list_fd = -1;
p->opts = opts;
p->reftable_dir = reftable_strdup(dir);
if (!p->reftable_dir) {
err = REFTABLE_OUT_OF_MEMORY_ERROR;
goto out;
}
err = reftable_stack_reload_maybe_reuse(p, 1);
if (err < 0)
goto out;
*dest = p;
err = 0;
out:
if (err < 0)
reftable_stack_destroy(p);
return err;
}
static int fd_read_lines(int fd, char ***namesp) static int fd_read_lines(int fd, char ***namesp)
{ {
char *buf = NULL; char *buf = NULL;
@@ -591,6 +531,54 @@ out:
return err; return err;
} }
int reftable_new_stack(struct reftable_stack **dest, const char *dir,
const struct reftable_write_options *_opts)
{
struct reftable_buf list_file_name = REFTABLE_BUF_INIT;
struct reftable_write_options opts = { 0 };
struct reftable_stack *p;
int err;
p = reftable_calloc(1, sizeof(*p));
if (!p) {
err = REFTABLE_OUT_OF_MEMORY_ERROR;
goto out;
}
if (_opts)
opts = *_opts;
if (opts.hash_id == 0)
opts.hash_id = REFTABLE_HASH_SHA1;
*dest = NULL;
reftable_buf_reset(&list_file_name);
if ((err = reftable_buf_addstr(&list_file_name, dir)) < 0 ||
(err = reftable_buf_addstr(&list_file_name, "/tables.list")) < 0)
goto out;
p->list_file = reftable_buf_detach(&list_file_name);
p->list_fd = -1;
p->opts = opts;
p->reftable_dir = reftable_strdup(dir);
if (!p->reftable_dir) {
err = REFTABLE_OUT_OF_MEMORY_ERROR;
goto out;
}
err = reftable_stack_reload_maybe_reuse(p, 1);
if (err < 0)
goto out;
*dest = p;
err = 0;
out:
if (err < 0)
reftable_stack_destroy(p);
return err;
}
/* -1 = error /* -1 = error
0 = up to date 0 = up to date
1 = changed. */ 1 = changed. */
@@ -667,34 +655,6 @@ int reftable_stack_reload(struct reftable_stack *st)
return err; return err;
} }
int reftable_stack_add(struct reftable_stack *st,
int (*write)(struct reftable_writer *wr, void *arg),
void *arg)
{
int err = stack_try_add(st, write, arg);
if (err < 0) {
if (err == REFTABLE_OUTDATED_ERROR) {
/* Ignore error return, we want to propagate
REFTABLE_OUTDATED_ERROR.
*/
reftable_stack_reload(st);
}
return err;
}
return 0;
}
static int format_name(struct reftable_buf *dest, uint64_t min, uint64_t max)
{
char buf[100];
uint32_t rnd = reftable_rand();
snprintf(buf, sizeof(buf), "0x%012" PRIx64 "-0x%012" PRIx64 "-%08x",
min, max, rnd);
reftable_buf_reset(dest);
return reftable_buf_addstr(dest, buf);
}
struct reftable_addition { struct reftable_addition {
struct reftable_flock tables_list_lock; struct reftable_flock tables_list_lock;
struct reftable_stack *stack; struct reftable_stack *stack;
@@ -706,6 +666,26 @@ struct reftable_addition {
#define REFTABLE_ADDITION_INIT {0} #define REFTABLE_ADDITION_INIT {0}
static void reftable_addition_close(struct reftable_addition *add)
{
struct reftable_buf nm = REFTABLE_BUF_INIT;
size_t i;
for (i = 0; i < add->new_tables_len; i++) {
if (!stack_filename(&nm, add->stack, add->new_tables[i]))
unlink(nm.buf);
reftable_free(add->new_tables[i]);
add->new_tables[i] = NULL;
}
reftable_free(add->new_tables);
add->new_tables = NULL;
add->new_tables_len = 0;
add->new_tables_cap = 0;
flock_release(&add->tables_list_lock);
reftable_buf_release(&nm);
}
static int reftable_stack_init_addition(struct reftable_addition *add, static int reftable_stack_init_addition(struct reftable_addition *add,
struct reftable_stack *st, struct reftable_stack *st,
unsigned int flags) unsigned int flags)
@@ -754,24 +734,52 @@ done:
return err; return err;
} }
static void reftable_addition_close(struct reftable_addition *add) static int stack_try_add(struct reftable_stack *st,
int (*write_table)(struct reftable_writer *wr,
void *arg),
void *arg)
{ {
struct reftable_buf nm = REFTABLE_BUF_INIT; struct reftable_addition add = REFTABLE_ADDITION_INIT;
size_t i; int err = reftable_stack_init_addition(&add, st, 0);
if (err < 0)
goto done;
for (i = 0; i < add->new_tables_len; i++) { err = reftable_addition_add(&add, write_table, arg);
if (!stack_filename(&nm, add->stack, add->new_tables[i])) if (err < 0)
unlink(nm.buf); goto done;
reftable_free(add->new_tables[i]);
add->new_tables[i] = NULL; err = reftable_addition_commit(&add);
done:
reftable_addition_close(&add);
return err;
}
int reftable_stack_add(struct reftable_stack *st,
int (*write)(struct reftable_writer *wr, void *arg),
void *arg)
{
int err = stack_try_add(st, write, arg);
if (err < 0) {
if (err == REFTABLE_OUTDATED_ERROR) {
/* Ignore error return, we want to propagate
REFTABLE_OUTDATED_ERROR.
*/
reftable_stack_reload(st);
}
return err;
} }
reftable_free(add->new_tables);
add->new_tables = NULL;
add->new_tables_len = 0;
add->new_tables_cap = 0;
flock_release(&add->tables_list_lock); return 0;
reftable_buf_release(&nm); }
static int format_name(struct reftable_buf *dest, uint64_t min, uint64_t max)
{
char buf[100];
uint32_t rnd = reftable_rand();
snprintf(buf, sizeof(buf), "0x%012" PRIx64 "-0x%012" PRIx64 "-%08x",
min, max, rnd);
reftable_buf_reset(dest);
return reftable_buf_addstr(dest, buf);
} }
void reftable_addition_destroy(struct reftable_addition *add) void reftable_addition_destroy(struct reftable_addition *add)
@@ -874,26 +882,6 @@ int reftable_stack_new_addition(struct reftable_addition **dest,
return err; return err;
} }
static int stack_try_add(struct reftable_stack *st,
int (*write_table)(struct reftable_writer *wr,
void *arg),
void *arg)
{
struct reftable_addition add = REFTABLE_ADDITION_INIT;
int err = reftable_stack_init_addition(&add, st, 0);
if (err < 0)
goto done;
err = reftable_addition_add(&add, write_table, arg);
if (err < 0)
goto done;
err = reftable_addition_commit(&add);
done:
reftable_addition_close(&add);
return err;
}
int reftable_addition_add(struct reftable_addition *add, int reftable_addition_add(struct reftable_addition *add,
int (*write_table)(struct reftable_writer *wr, int (*write_table)(struct reftable_writer *wr,
void *arg), void *arg),
@@ -1007,72 +995,6 @@ uint64_t reftable_stack_next_update_index(struct reftable_stack *st)
return 1; return 1;
} }
static int stack_compact_locked(struct reftable_stack *st,
size_t first, size_t last,
struct reftable_log_expiry_config *config,
struct reftable_tmpfile *tab_file_out)
{
struct reftable_buf next_name = REFTABLE_BUF_INIT;
struct reftable_buf tab_file_path = REFTABLE_BUF_INIT;
struct reftable_writer *wr = NULL;
struct fd_writer writer= {
.opts = &st->opts,
};
struct reftable_tmpfile tab_file = REFTABLE_TMPFILE_INIT;
int err = 0;
err = format_name(&next_name, reftable_table_min_update_index(st->tables[first]),
reftable_table_max_update_index(st->tables[last]));
if (err < 0)
goto done;
err = stack_filename(&tab_file_path, st, next_name.buf);
if (err < 0)
goto done;
err = reftable_buf_addstr(&tab_file_path, ".temp.XXXXXX");
if (err < 0)
goto done;
err = tmpfile_from_pattern(&tab_file, tab_file_path.buf);
if (err < 0)
goto done;
if (st->opts.default_permissions &&
chmod(tab_file.path, st->opts.default_permissions) < 0) {
err = REFTABLE_IO_ERROR;
goto done;
}
writer.fd = tab_file.fd;
err = reftable_writer_new(&wr, fd_writer_write, fd_writer_flush,
&writer, &st->opts);
if (err < 0)
goto done;
err = stack_write_compact(st, wr, first, last, config);
if (err < 0)
goto done;
err = reftable_writer_close(wr);
if (err < 0)
goto done;
err = tmpfile_close(&tab_file);
if (err < 0)
goto done;
*tab_file_out = tab_file;
tab_file = REFTABLE_TMPFILE_INIT;
done:
tmpfile_delete(&tab_file);
reftable_writer_free(wr);
reftable_buf_release(&next_name);
reftable_buf_release(&tab_file_path);
return err;
}
static int stack_write_compact(struct reftable_stack *st, static int stack_write_compact(struct reftable_stack *st,
struct reftable_writer *wr, struct reftable_writer *wr,
size_t first, size_t last, size_t first, size_t last,
@@ -1172,6 +1094,72 @@ done:
return err; return err;
} }
static int stack_compact_locked(struct reftable_stack *st,
size_t first, size_t last,
struct reftable_log_expiry_config *config,
struct reftable_tmpfile *tab_file_out)
{
struct reftable_buf next_name = REFTABLE_BUF_INIT;
struct reftable_buf tab_file_path = REFTABLE_BUF_INIT;
struct reftable_writer *wr = NULL;
struct fd_writer writer= {
.opts = &st->opts,
};
struct reftable_tmpfile tab_file = REFTABLE_TMPFILE_INIT;
int err = 0;
err = format_name(&next_name, reftable_table_min_update_index(st->tables[first]),
reftable_table_max_update_index(st->tables[last]));
if (err < 0)
goto done;
err = stack_filename(&tab_file_path, st, next_name.buf);
if (err < 0)
goto done;
err = reftable_buf_addstr(&tab_file_path, ".temp.XXXXXX");
if (err < 0)
goto done;
err = tmpfile_from_pattern(&tab_file, tab_file_path.buf);
if (err < 0)
goto done;
if (st->opts.default_permissions &&
chmod(tab_file.path, st->opts.default_permissions) < 0) {
err = REFTABLE_IO_ERROR;
goto done;
}
writer.fd = tab_file.fd;
err = reftable_writer_new(&wr, fd_writer_write, fd_writer_flush,
&writer, &st->opts);
if (err < 0)
goto done;
err = stack_write_compact(st, wr, first, last, config);
if (err < 0)
goto done;
err = reftable_writer_close(wr);
if (err < 0)
goto done;
err = tmpfile_close(&tab_file);
if (err < 0)
goto done;
*tab_file_out = tab_file;
tab_file = REFTABLE_TMPFILE_INIT;
done:
tmpfile_delete(&tab_file);
reftable_writer_free(wr);
reftable_buf_release(&next_name);
reftable_buf_release(&tab_file_path);
return err;
}
enum stack_compact_range_flags { enum stack_compact_range_flags {
/* /*
* Perform a best-effort compaction. That is, even if we cannot lock * Perform a best-effort compaction. That is, even if we cannot lock