kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

csum-file: rename sha1file to hashfile 

Rename struct sha1file to struct hashfile, along with all of its related
functions.

The transformation in this commit was made by global search-and-replace.

Signed-off-by: Junio C Hamano <gitster@pobox.com>
maint
brian m. carlson 2018-02-01 02:18:46 +00:00 committed by Junio C Hamano
parent aab6135906
commit 98a3beab6a
9 changed files with 126 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
builtin/index-pack.c
View File

@ -1241,7 +1241,7 @@ static void resolve_deltas(void)
* - append objects to convert thin pack to full pack if required * - append objects to convert thin pack to full pack if required
* - write the final pack hash * - write the final pack hash
*/ */
static void fix_unresolved_deltas(struct sha1file *f); static void fix_unresolved_deltas(struct hashfile *f);
static void conclude_pack(int fix_thin_pack, const char *curr_pack, unsigned char *pack_hash) static void conclude_pack(int fix_thin_pack, const char *curr_pack, unsigned char *pack_hash)
{ {
if (nr_ref_deltas + nr_ofs_deltas == nr_resolved_deltas) { if (nr_ref_deltas + nr_ofs_deltas == nr_resolved_deltas) {
@ -1252,7 +1252,7 @@ static void conclude_pack(int fix_thin_pack, const char *curr_pack, unsigned cha
} }


if (fix_thin_pack) { if (fix_thin_pack) {
struct sha1file *f; struct hashfile *f;
unsigned char read_hash[GIT_MAX_RAWSZ], tail_hash[GIT_MAX_RAWSZ]; unsigned char read_hash[GIT_MAX_RAWSZ], tail_hash[GIT_MAX_RAWSZ];
struct strbuf msg = STRBUF_INIT; struct strbuf msg = STRBUF_INIT;
int nr_unresolved = nr_ofs_deltas + nr_ref_deltas - nr_resolved_deltas; int nr_unresolved = nr_ofs_deltas + nr_ref_deltas - nr_resolved_deltas;
@ -1262,7 +1262,7 @@ static void conclude_pack(int fix_thin_pack, const char *curr_pack, unsigned cha
REALLOC_ARRAY(objects, nr_objects + nr_unresolved + 1); REALLOC_ARRAY(objects, nr_objects + nr_unresolved + 1);
memset(objects + nr_objects + 1, 0, memset(objects + nr_objects + 1, 0,
nr_unresolved * sizeof(*objects)); nr_unresolved * sizeof(*objects));
f = sha1fd(output_fd, curr_pack); f = hashfd(output_fd, curr_pack);
fix_unresolved_deltas(f); fix_unresolved_deltas(f);
strbuf_addf(&msg, Q_("completed with %d local object", strbuf_addf(&msg, Q_("completed with %d local object",
"completed with %d local objects", "completed with %d local objects",
@ -1270,7 +1270,7 @@ static void conclude_pack(int fix_thin_pack, const char *curr_pack, unsigned cha
nr_objects - nr_objects_initial); nr_objects - nr_objects_initial);
stop_progress_msg(&progress, msg.buf); stop_progress_msg(&progress, msg.buf);
strbuf_release(&msg); strbuf_release(&msg);
sha1close(f, tail_hash, 0); hashclose(f, tail_hash, 0);
hashcpy(read_hash, pack_hash); hashcpy(read_hash, pack_hash);
fixup_pack_header_footer(output_fd, pack_hash, fixup_pack_header_footer(output_fd, pack_hash,
curr_pack, nr_objects, curr_pack, nr_objects,
@ -1286,7 +1286,7 @@ static void conclude_pack(int fix_thin_pack, const char *curr_pack, unsigned cha
nr_ofs_deltas + nr_ref_deltas - nr_resolved_deltas); nr_ofs_deltas + nr_ref_deltas - nr_resolved_deltas);
} }


static int write_compressed(struct sha1file *f, void *in, unsigned int size) static int write_compressed(struct hashfile *f, void *in, unsigned int size)
{ {
git_zstream stream; git_zstream stream;
int status; int status;
@ -1300,7 +1300,7 @@ static int write_compressed(struct sha1file *f, void *in, unsigned int size)
stream.next_out = outbuf; stream.next_out = outbuf;
stream.avail_out = sizeof(outbuf); stream.avail_out = sizeof(outbuf);
status = git_deflate(&stream, Z_FINISH); status = git_deflate(&stream, Z_FINISH);
sha1write(f, outbuf, sizeof(outbuf) - stream.avail_out); hashwrite(f, outbuf, sizeof(outbuf) - stream.avail_out);
} while (status == Z_OK); } while (status == Z_OK);


if (status != Z_STREAM_END) if (status != Z_STREAM_END)
@ -1310,7 +1310,7 @@ static int write_compressed(struct sha1file *f, void *in, unsigned int size)
return size; return size;
} }


static struct object_entry *append_obj_to_pack(struct sha1file *f, static struct object_entry *append_obj_to_pack(struct hashfile *f,
const unsigned char *sha1, void *buf, const unsigned char *sha1, void *buf,
unsigned long size, enum object_type type) unsigned long size, enum object_type type)
{ {
@ -1327,7 +1327,7 @@ static struct object_entry *append_obj_to_pack(struct sha1file *f,
} }
header[n++] = c; header[n++] = c;
crc32_begin(f); crc32_begin(f);
sha1write(f, header, n); hashwrite(f, header, n);
obj[0].size = size; obj[0].size = size;
obj[0].hdr_size = n; obj[0].hdr_size = n;
obj[0].type = type; obj[0].type = type;
@ -1335,7 +1335,7 @@ static struct object_entry *append_obj_to_pack(struct sha1file *f,
obj[1].idx.offset = obj[0].idx.offset + n; obj[1].idx.offset = obj[0].idx.offset + n;
obj[1].idx.offset += write_compressed(f, buf, size); obj[1].idx.offset += write_compressed(f, buf, size);
obj[0].idx.crc32 = crc32_end(f); obj[0].idx.crc32 = crc32_end(f);
sha1flush(f); hashflush(f);
hashcpy(obj->idx.oid.hash, sha1); hashcpy(obj->idx.oid.hash, sha1);
return obj; return obj;
} }
@ -1347,7 +1347,7 @@ static int delta_pos_compare(const void *_a, const void *_b)
return a->obj_no - b->obj_no; return a->obj_no - b->obj_no;
} }


static void fix_unresolved_deltas(struct sha1file *f) static void fix_unresolved_deltas(struct hashfile *f)
{ {
struct ref_delta_entry **sorted_by_pos; struct ref_delta_entry **sorted_by_pos;
int i; int i;

52
builtin/pack-objects.c
View File

@ -161,7 +161,7 @@ static unsigned long do_compress(void **pptr, unsigned long size)
return stream.total_out; return stream.total_out;
} }


static unsigned long write_large_blob_data(struct git_istream *st, struct sha1file *f, static unsigned long write_large_blob_data(struct git_istream *st, struct hashfile *f,
const struct object_id *oid) const struct object_id *oid)
{ {
git_zstream stream; git_zstream stream;
@ -185,7 +185,7 @@ static unsigned long write_large_blob_data(struct git_istream *st, struct sha1fi
stream.next_out = obuf; stream.next_out = obuf;
stream.avail_out = sizeof(obuf); stream.avail_out = sizeof(obuf);
zret = git_deflate(&stream, readlen ? 0 : Z_FINISH); zret = git_deflate(&stream, readlen ? 0 : Z_FINISH);
sha1write(f, obuf, stream.next_out - obuf); hashwrite(f, obuf, stream.next_out - obuf);
olen += stream.next_out - obuf; olen += stream.next_out - obuf;
} }
if (stream.avail_in) if (stream.avail_in)
@ -230,7 +230,7 @@ static int check_pack_inflate(struct packed_git *p,
stream.total_in == len) ? 0 : -1; stream.total_in == len) ? 0 : -1;
} }


static void copy_pack_data(struct sha1file *f, static void copy_pack_data(struct hashfile *f,
struct packed_git *p, struct packed_git *p,
struct pack_window **w_curs, struct pack_window **w_curs,
off_t offset, off_t offset,
@ -243,14 +243,14 @@ static void copy_pack_data(struct sha1file *f,
in = use_pack(p, w_curs, offset, &avail); in = use_pack(p, w_curs, offset, &avail);
if (avail > len) if (avail > len)
avail = (unsigned long)len; avail = (unsigned long)len;
sha1write(f, in, avail); hashwrite(f, in, avail);
offset += avail; offset += avail;
len -= avail; len -= avail;
} }
} }


/* Return 0 if we will bust the pack-size limit */ /* Return 0 if we will bust the pack-size limit */
static unsigned long write_no_reuse_object(struct sha1file *f, struct object_entry *entry, static unsigned long write_no_reuse_object(struct hashfile *f, struct object_entry *entry,
unsigned long limit, int usable_delta) unsigned long limit, int usable_delta)
{ {
unsigned long size, datalen; unsigned long size, datalen;
@ -323,8 +323,8 @@ static unsigned long write_no_reuse_object(struct sha1file *f, struct object_ent
free(buf); free(buf);
return 0; return 0;
} }
sha1write(f, header, hdrlen); hashwrite(f, header, hdrlen);
sha1write(f, dheader + pos, sizeof(dheader) - pos); hashwrite(f, dheader + pos, sizeof(dheader) - pos);
hdrlen += sizeof(dheader) - pos; hdrlen += sizeof(dheader) - pos;
} else if (type == OBJ_REF_DELTA) { } else if (type == OBJ_REF_DELTA) {
/* /*
@ -337,8 +337,8 @@ static unsigned long write_no_reuse_object(struct sha1file *f, struct object_ent
free(buf); free(buf);
return 0; return 0;
} }
sha1write(f, header, hdrlen); hashwrite(f, header, hdrlen);
sha1write(f, entry->delta->idx.oid.hash, 20); hashwrite(f, entry->delta->idx.oid.hash, 20);
hdrlen += 20; hdrlen += 20;
} else { } else {
if (limit && hdrlen + datalen + 20 >= limit) { if (limit && hdrlen + datalen + 20 >= limit) {
@ -347,13 +347,13 @@ static unsigned long write_no_reuse_object(struct sha1file *f, struct object_ent
free(buf); free(buf);
return 0; return 0;
} }
sha1write(f, header, hdrlen); hashwrite(f, header, hdrlen);
} }
if (st) { if (st) {
datalen = write_large_blob_data(st, f, &entry->idx.oid); datalen = write_large_blob_data(st, f, &entry->idx.oid);
close_istream(st); close_istream(st);
} else { } else {
sha1write(f, buf, datalen); hashwrite(f, buf, datalen);
free(buf); free(buf);
} }


@ -361,7 +361,7 @@ static unsigned long write_no_reuse_object(struct sha1file *f, struct object_ent
} }


/* Return 0 if we will bust the pack-size limit */ /* Return 0 if we will bust the pack-size limit */
static off_t write_reuse_object(struct sha1file *f, struct object_entry *entry, static off_t write_reuse_object(struct hashfile *f, struct object_entry *entry,
unsigned long limit, int usable_delta) unsigned long limit, int usable_delta)
{ {
struct packed_git *p = entry->in_pack; struct packed_git *p = entry->in_pack;
@ -412,8 +412,8 @@ static off_t write_reuse_object(struct sha1file *f, struct object_entry *entry,
unuse_pack(&w_curs); unuse_pack(&w_curs);
return 0; return 0;
} }
sha1write(f, header, hdrlen); hashwrite(f, header, hdrlen);
sha1write(f, dheader + pos, sizeof(dheader) - pos); hashwrite(f, dheader + pos, sizeof(dheader) - pos);
hdrlen += sizeof(dheader) - pos; hdrlen += sizeof(dheader) - pos;
reused_delta++; reused_delta++;
} else if (type == OBJ_REF_DELTA) { } else if (type == OBJ_REF_DELTA) {
@ -421,8 +421,8 @@ static off_t write_reuse_object(struct sha1file *f, struct object_entry *entry,
unuse_pack(&w_curs); unuse_pack(&w_curs);
return 0; return 0;
} }
sha1write(f, header, hdrlen); hashwrite(f, header, hdrlen);
sha1write(f, entry->delta->idx.oid.hash, 20); hashwrite(f, entry->delta->idx.oid.hash, 20);
hdrlen += 20; hdrlen += 20;
reused_delta++; reused_delta++;
} else { } else {
@ -430,7 +430,7 @@ static off_t write_reuse_object(struct sha1file *f, struct object_entry *entry,
unuse_pack(&w_curs); unuse_pack(&w_curs);
return 0; return 0;
} }
sha1write(f, header, hdrlen); hashwrite(f, header, hdrlen);
} }
copy_pack_data(f, p, &w_curs, offset, datalen); copy_pack_data(f, p, &w_curs, offset, datalen);
unuse_pack(&w_curs); unuse_pack(&w_curs);
@ -439,7 +439,7 @@ static off_t write_reuse_object(struct sha1file *f, struct object_entry *entry,
} }


/* Return 0 if we will bust the pack-size limit */ /* Return 0 if we will bust the pack-size limit */
static off_t write_object(struct sha1file *f, static off_t write_object(struct hashfile *f,
struct object_entry *entry, struct object_entry *entry,
off_t write_offset) off_t write_offset)
{ {
@ -512,7 +512,7 @@ enum write_one_status {
WRITE_ONE_RECURSIVE = 2 /* already scheduled to be written */ WRITE_ONE_RECURSIVE = 2 /* already scheduled to be written */
}; };


static enum write_one_status write_one(struct sha1file *f, static enum write_one_status write_one(struct hashfile *f,
struct object_entry *e, struct object_entry *e,
off_t *offset) off_t *offset)
{ {
@ -731,7 +731,7 @@ static struct object_entry **compute_write_order(void)
return wo; return wo;
} }


static off_t write_reused_pack(struct sha1file *f) static off_t write_reused_pack(struct hashfile *f)
{ {
unsigned char buffer[8192]; unsigned char buffer[8192];
off_t to_write, total; off_t to_write, total;
@ -762,7 +762,7 @@ static off_t write_reused_pack(struct sha1file *f)
if (read_pack > to_write) if (read_pack > to_write)
read_pack = to_write; read_pack = to_write;


sha1write(f, buffer, read_pack); hashwrite(f, buffer, read_pack);
to_write -= read_pack; to_write -= read_pack;


/* /*
@ -791,7 +791,7 @@ static const char no_split_warning[] = N_(
static void write_pack_file(void) static void write_pack_file(void)
{ {
uint32_t i = 0, j; uint32_t i = 0, j;
struct sha1file *f; struct hashfile *f;
off_t offset; off_t offset;
uint32_t nr_remaining = nr_result; uint32_t nr_remaining = nr_result;
time_t last_mtime = 0; time_t last_mtime = 0;
@ -807,7 +807,7 @@ static void write_pack_file(void)
char *pack_tmp_name = NULL; char *pack_tmp_name = NULL;


if (pack_to_stdout) if (pack_to_stdout)
f = sha1fd_throughput(1, "<stdout>", progress_state); f = hashfd_throughput(1, "<stdout>", progress_state);
else else
f = create_tmp_packfile(&pack_tmp_name); f = create_tmp_packfile(&pack_tmp_name);


@ -834,11 +834,11 @@ static void write_pack_file(void)
* If so, rewrite it like in fast-import * If so, rewrite it like in fast-import
*/ */
if (pack_to_stdout) { if (pack_to_stdout) {
sha1close(f, oid.hash, CSUM_CLOSE); hashclose(f, oid.hash, CSUM_CLOSE);
} else if (nr_written == nr_remaining) { } else if (nr_written == nr_remaining) {
sha1close(f, oid.hash, CSUM_FSYNC); hashclose(f, oid.hash, CSUM_FSYNC);
} else { } else {
int fd = sha1close(f, oid.hash, 0); int fd = hashclose(f, oid.hash, 0);
fixup_pack_header_footer(fd, oid.hash, pack_tmp_name, fixup_pack_header_footer(fd, oid.hash, pack_tmp_name,
nr_written, oid.hash, offset); nr_written, oid.hash, offset);
close(fd); close(fd);

16
bulk-checkin.c
View File

@ -12,7 +12,7 @@ static struct bulk_checkin_state {
unsigned plugged:1; unsigned plugged:1;


char *pack_tmp_name; char *pack_tmp_name;
struct sha1file *f; struct hashfile *f;
off_t offset; off_t offset;
struct pack_idx_option pack_idx_opts; struct pack_idx_option pack_idx_opts;


@ -35,9 +35,9 @@ static void finish_bulk_checkin(struct bulk_checkin_state *state)
unlink(state->pack_tmp_name); unlink(state->pack_tmp_name);
goto clear_exit; goto clear_exit;
} else if (state->nr_written == 1) { } else if (state->nr_written == 1) {
sha1close(state->f, oid.hash, CSUM_FSYNC); hashclose(state->f, oid.hash, CSUM_FSYNC);
} else { } else {
int fd = sha1close(state->f, oid.hash, 0); int fd = hashclose(state->f, oid.hash, 0);
fixup_pack_header_footer(fd, oid.hash, state->pack_tmp_name, fixup_pack_header_footer(fd, oid.hash, state->pack_tmp_name,
state->nr_written, oid.hash, state->nr_written, oid.hash,
state->offset); state->offset);
@ -149,7 +149,7 @@ static int stream_to_pack(struct bulk_checkin_state *state,
return -1; return -1;
} }


sha1write(state->f, obuf, written); hashwrite(state->f, obuf, written);
state->offset += written; state->offset += written;
} }
s.next_out = obuf; s.next_out = obuf;
@ -195,7 +195,7 @@ static int deflate_to_pack(struct bulk_checkin_state *state,
git_SHA_CTX ctx; git_SHA_CTX ctx;
unsigned char obuf[16384]; unsigned char obuf[16384];
unsigned header_len; unsigned header_len;
struct sha1file_checkpoint checkpoint; struct hashfile_checkpoint checkpoint;
struct pack_idx_entry *idx = NULL; struct pack_idx_entry *idx = NULL;


seekback = lseek(fd, 0, SEEK_CUR); seekback = lseek(fd, 0, SEEK_CUR);
@ -216,7 +216,7 @@ static int deflate_to_pack(struct bulk_checkin_state *state,
while (1) { while (1) {
prepare_to_stream(state, flags); prepare_to_stream(state, flags);
if (idx) { if (idx) {
sha1file_checkpoint(state->f, &checkpoint); hashfile_checkpoint(state->f, &checkpoint);
idx->offset = state->offset; idx->offset = state->offset;
crc32_begin(state->f); crc32_begin(state->f);
} }
@ -230,7 +230,7 @@ static int deflate_to_pack(struct bulk_checkin_state *state,
*/ */
if (!idx) if (!idx)
die("BUG: should not happen"); die("BUG: should not happen");
sha1file_truncate(state->f, &checkpoint); hashfile_truncate(state->f, &checkpoint);
state->offset = checkpoint.offset; state->offset = checkpoint.offset;
finish_bulk_checkin(state); finish_bulk_checkin(state);
if (lseek(fd, seekback, SEEK_SET) == (off_t) -1) if (lseek(fd, seekback, SEEK_SET) == (off_t) -1)
@ -242,7 +242,7 @@ static int deflate_to_pack(struct bulk_checkin_state *state,


idx->crc32 = crc32_end(state->f); idx->crc32 = crc32_end(state->f);
if (already_written(state, result_sha1)) { if (already_written(state, result_sha1)) {
sha1file_truncate(state->f, &checkpoint); hashfile_truncate(state->f, &checkpoint);
state->offset = checkpoint.offset; state->offset = checkpoint.offset;
free(idx); free(idx);
} else { } else {

36
csum-file.c
View File

@ -11,7 +11,7 @@
#include "progress.h" #include "progress.h"
#include "csum-file.h" #include "csum-file.h"


static void flush(struct sha1file *f, const void *buf, unsigned int count) static void flush(struct hashfile *f, const void *buf, unsigned int count)
{ {
if (0 <= f->check_fd && count) { if (0 <= f->check_fd && count) {
unsigned char check_buffer[8192]; unsigned char check_buffer[8192];
@ -42,7 +42,7 @@ static void flush(struct sha1file *f, const void *buf, unsigned int count)
} }
} }


void sha1flush(struct sha1file *f) void hashflush(struct hashfile *f)
{ {
unsigned offset = f->offset; unsigned offset = f->offset;


@ -53,11 +53,11 @@ void sha1flush(struct sha1file *f)
} }
} }


int sha1close(struct sha1file *f, unsigned char *result, unsigned int flags) int hashclose(struct hashfile *f, unsigned char *result, unsigned int flags)
{ {
int fd; int fd;


sha1flush(f); hashflush(f);
git_SHA1_Final(f->buffer, &f->ctx); git_SHA1_Final(f->buffer, &f->ctx);
if (result) if (result)
hashcpy(result, f->buffer); hashcpy(result, f->buffer);
@ -86,7 +86,7 @@ int sha1close(struct sha1file *f, unsigned char *result, unsigned int flags)
return fd; return fd;
} }


void sha1write(struct sha1file *f, const void *buf, unsigned int count) void hashwrite(struct hashfile *f, const void *buf, unsigned int count)
{ {
while (count) { while (count) {
unsigned offset = f->offset; unsigned offset = f->offset;
@ -118,15 +118,15 @@ void sha1write(struct sha1file *f, const void *buf, unsigned int count)
} }
} }


struct sha1file *sha1fd(int fd, const char *name) struct hashfile *hashfd(int fd, const char *name)
{ {
return sha1fd_throughput(fd, name, NULL); return hashfd_throughput(fd, name, NULL);
} }


struct sha1file *sha1fd_check(const char *name) struct hashfile *hashfd_check(const char *name)
{ {
int sink, check; int sink, check;
struct sha1file *f; struct hashfile *f;


sink = open("/dev/null", O_WRONLY); sink = open("/dev/null", O_WRONLY);
if (sink < 0) if (sink < 0)
@ -134,14 +134,14 @@ struct sha1file *sha1fd_check(const char *name)
check = open(name, O_RDONLY); check = open(name, O_RDONLY);
if (check < 0) if (check < 0)
die_errno("unable to open '%s'", name); die_errno("unable to open '%s'", name);
f = sha1fd(sink, name); f = hashfd(sink, name);
f->check_fd = check; f->check_fd = check;
return f; return f;
} }


struct sha1file *sha1fd_throughput(int fd, const char *name, struct progress *tp) struct hashfile *hashfd_throughput(int fd, const char *name, struct progress *tp)
{ {
struct sha1file *f = xmalloc(sizeof(*f)); struct hashfile *f = xmalloc(sizeof(*f));
f->fd = fd; f->fd = fd;
f->check_fd = -1; f->check_fd = -1;
f->offset = 0; f->offset = 0;
@ -153,14 +153,14 @@ struct sha1file *sha1fd_throughput(int fd, const char *name, struct progress *tp
return f; return f;
} }


void sha1file_checkpoint(struct sha1file *f, struct sha1file_checkpoint *checkpoint) void hashfile_checkpoint(struct hashfile *f, struct hashfile_checkpoint *checkpoint)
{ {
sha1flush(f); hashflush(f);
checkpoint->offset = f->total; checkpoint->offset = f->total;
checkpoint->ctx = f->ctx; checkpoint->ctx = f->ctx;
} }


int sha1file_truncate(struct sha1file *f, struct sha1file_checkpoint *checkpoint) int hashfile_truncate(struct hashfile *f, struct hashfile_checkpoint *checkpoint)
{ {
off_t offset = checkpoint->offset; off_t offset = checkpoint->offset;


@ -169,17 +169,17 @@ int sha1file_truncate(struct sha1file *f, struct sha1file_checkpoint *checkpoint
return -1; return -1;
f->total = offset; f->total = offset;
f->ctx = checkpoint->ctx; f->ctx = checkpoint->ctx;
f->offset = 0; /* sha1flush() was called in checkpoint */ f->offset = 0; /* hashflush() was called in checkpoint */
return 0; return 0;
} }


void crc32_begin(struct sha1file *f) void crc32_begin(struct hashfile *f)
{ {
f->crc32 = crc32(0, NULL, 0); f->crc32 = crc32(0, NULL, 0);
f->do_crc = 1; f->do_crc = 1;
} }


uint32_t crc32_end(struct sha1file *f) uint32_t crc32_end(struct hashfile *f)
{ {
f->do_crc = 0; f->do_crc = 0;
return f->crc32; return f->crc32;

34
csum-file.h
View File

@ -4,7 +4,7 @@
struct progress; struct progress;


/* A SHA1-protected file */ /* A SHA1-protected file */
struct sha1file { struct hashfile {
int fd; int fd;
int check_fd; int check_fd;
unsigned int offset; unsigned int offset;
@ -18,36 +18,36 @@ struct sha1file {
}; };


/* Checkpoint */ /* Checkpoint */
struct sha1file_checkpoint { struct hashfile_checkpoint {
off_t offset; off_t offset;
git_SHA_CTX ctx; git_SHA_CTX ctx;
}; };


extern void sha1file_checkpoint(struct sha1file *, struct sha1file_checkpoint *); extern void hashfile_checkpoint(struct hashfile *, struct hashfile_checkpoint *);
extern int sha1file_truncate(struct sha1file *, struct sha1file_checkpoint *); extern int hashfile_truncate(struct hashfile *, struct hashfile_checkpoint *);


/* sha1close flags */ /* hashclose flags */
#define CSUM_CLOSE 1 #define CSUM_CLOSE 1
#define CSUM_FSYNC 2 #define CSUM_FSYNC 2


extern struct sha1file *sha1fd(int fd, const char *name); extern struct hashfile *hashfd(int fd, const char *name);
extern struct sha1file *sha1fd_check(const char *name); extern struct hashfile *hashfd_check(const char *name);
extern struct sha1file *sha1fd_throughput(int fd, const char *name, struct progress *tp); extern struct hashfile *hashfd_throughput(int fd, const char *name, struct progress *tp);
extern int sha1close(struct sha1file *, unsigned char *, unsigned int); extern int hashclose(struct hashfile *, unsigned char *, unsigned int);
extern void sha1write(struct sha1file *, const void *, unsigned int); extern void hashwrite(struct hashfile *, const void *, unsigned int);
extern void sha1flush(struct sha1file *f); extern void hashflush(struct hashfile *f);
extern void crc32_begin(struct sha1file *); extern void crc32_begin(struct hashfile *);
extern uint32_t crc32_end(struct sha1file *); extern uint32_t crc32_end(struct hashfile *);


static inline void sha1write_u8(struct sha1file *f, uint8_t data) static inline void hashwrite_u8(struct hashfile *f, uint8_t data)
{ {
sha1write(f, &data, sizeof(data)); hashwrite(f, &data, sizeof(data));
} }


static inline void sha1write_be32(struct sha1file *f, uint32_t data) static inline void hashwrite_be32(struct hashfile *f, uint32_t data)
{ {
data = htonl(data); data = htonl(data);
sha1write(f, &data, sizeof(data)); hashwrite(f, &data, sizeof(data));
} }


#endif #endif

28
fast-import.c
View File

@ -316,7 +316,7 @@ static struct atom_str **atom_table;
/* The .pack file being generated */ /* The .pack file being generated */
static struct pack_idx_option pack_idx_opts; static struct pack_idx_option pack_idx_opts;
static unsigned int pack_id; static unsigned int pack_id;
static struct sha1file *pack_file; static struct hashfile *pack_file;
static struct packed_git *pack_data; static struct packed_git *pack_data;
static struct packed_git **all_packs; static struct packed_git **all_packs;
static off_t pack_size; static off_t pack_size;
@ -905,12 +905,12 @@ static void start_packfile(void)


p->pack_fd = pack_fd; p->pack_fd = pack_fd;
p->do_not_close = 1; p->do_not_close = 1;
pack_file = sha1fd(pack_fd, p->pack_name); pack_file = hashfd(pack_fd, p->pack_name);


hdr.hdr_signature = htonl(PACK_SIGNATURE); hdr.hdr_signature = htonl(PACK_SIGNATURE);
hdr.hdr_version = htonl(2); hdr.hdr_version = htonl(2);
hdr.hdr_entries = 0; hdr.hdr_entries = 0;
sha1write(pack_file, &hdr, sizeof(hdr)); hashwrite(pack_file, &hdr, sizeof(hdr));


pack_data = p; pack_data = p;
pack_size = sizeof(hdr); pack_size = sizeof(hdr);
@ -1016,7 +1016,7 @@ static void end_packfile(void)
struct tag *t; struct tag *t;


close_pack_windows(pack_data); close_pack_windows(pack_data);
sha1close(pack_file, cur_pack_oid.hash, 0); hashclose(pack_file, cur_pack_oid.hash, 0);
fixup_pack_header_footer(pack_data->pack_fd, pack_data->sha1, fixup_pack_header_footer(pack_data->pack_fd, pack_data->sha1,
pack_data->pack_name, object_count, pack_data->pack_name, object_count,
cur_pack_oid.hash, pack_size); cur_pack_oid.hash, pack_size);
@ -1182,23 +1182,23 @@ static int store_object(


hdrlen = encode_in_pack_object_header(hdr, sizeof(hdr), hdrlen = encode_in_pack_object_header(hdr, sizeof(hdr),
OBJ_OFS_DELTA, deltalen); OBJ_OFS_DELTA, deltalen);
sha1write(pack_file, hdr, hdrlen); hashwrite(pack_file, hdr, hdrlen);
pack_size += hdrlen; pack_size += hdrlen;


hdr[pos] = ofs & 127; hdr[pos] = ofs & 127;
while (ofs >>= 7) while (ofs >>= 7)
hdr[--pos] = 128 | (--ofs & 127); hdr[--pos] = 128 | (--ofs & 127);
sha1write(pack_file, hdr + pos, sizeof(hdr) - pos); hashwrite(pack_file, hdr + pos, sizeof(hdr) - pos);
pack_size += sizeof(hdr) - pos; pack_size += sizeof(hdr) - pos;
} else { } else {
e->depth = 0; e->depth = 0;
hdrlen = encode_in_pack_object_header(hdr, sizeof(hdr), hdrlen = encode_in_pack_object_header(hdr, sizeof(hdr),
type, dat->len); type, dat->len);
sha1write(pack_file, hdr, hdrlen); hashwrite(pack_file, hdr, hdrlen);
pack_size += hdrlen; pack_size += hdrlen;
} }


sha1write(pack_file, out, s.total_out); hashwrite(pack_file, out, s.total_out);
pack_size += s.total_out; pack_size += s.total_out;


e->idx.crc32 = crc32_end(pack_file); e->idx.crc32 = crc32_end(pack_file);
@ -1217,9 +1217,9 @@ static int store_object(
return 0; return 0;
} }


static void truncate_pack(struct sha1file_checkpoint *checkpoint) static void truncate_pack(struct hashfile_checkpoint *checkpoint)
{ {
if (sha1file_truncate(pack_file, checkpoint)) if (hashfile_truncate(pack_file, checkpoint))
die_errno("cannot truncate pack to skip duplicate"); die_errno("cannot truncate pack to skip duplicate");
pack_size = checkpoint->offset; pack_size = checkpoint->offset;
} }
@ -1235,7 +1235,7 @@ static void stream_blob(uintmax_t len, struct object_id *oidout, uintmax_t mark)
off_t offset; off_t offset;
git_hash_ctx c; git_hash_ctx c;
git_zstream s; git_zstream s;
struct sha1file_checkpoint checkpoint; struct hashfile_checkpoint checkpoint;
int status = Z_OK; int status = Z_OK;


/* Determine if we should auto-checkpoint. */ /* Determine if we should auto-checkpoint. */
@ -1243,7 +1243,7 @@ static void stream_blob(uintmax_t len, struct object_id *oidout, uintmax_t mark)
|| (pack_size + 60 + len) < pack_size) || (pack_size + 60 + len) < pack_size)
cycle_packfile(); cycle_packfile();


sha1file_checkpoint(pack_file, &checkpoint); hashfile_checkpoint(pack_file, &checkpoint);
offset = checkpoint.offset; offset = checkpoint.offset;


hdrlen = xsnprintf((char *)out_buf, out_sz, "blob %" PRIuMAX, len) + 1; hdrlen = xsnprintf((char *)out_buf, out_sz, "blob %" PRIuMAX, len) + 1;
@ -1277,7 +1277,7 @@ static void stream_blob(uintmax_t len, struct object_id *oidout, uintmax_t mark)


if (!s.avail_out || status == Z_STREAM_END) { if (!s.avail_out || status == Z_STREAM_END) {
size_t n = s.next_out - out_buf; size_t n = s.next_out - out_buf;
sha1write(pack_file, out_buf, n); hashwrite(pack_file, out_buf, n);
pack_size += n; pack_size += n;
s.next_out = out_buf; s.next_out = out_buf;
s.avail_out = out_sz; s.avail_out = out_sz;
@ -1362,7 +1362,7 @@ static void *gfi_unpack_entry(
* the newly written data. * the newly written data.
*/ */
close_pack_windows(p); close_pack_windows(p);
sha1flush(pack_file); hashflush(pack_file);


/* We have to offer rawsz bytes additional on the end of /* We have to offer rawsz bytes additional on the end of
* the packfile as the core unpacker code assumes the * the packfile as the core unpacker code assumes the

30
pack-bitmap-write.c
View File

@ -440,19 +440,19 @@ void bitmap_writer_select_commits(struct commit **indexed_commits,
} }




static int sha1write_ewah_helper(void *f, const void *buf, size_t len) static int hashwrite_ewah_helper(void *f, const void *buf, size_t len)
{ {
/* sha1write will die on error */ /* hashwrite will die on error */
sha1write(f, buf, len); hashwrite(f, buf, len);
return len; return len;
} }


/** /**
* Write the bitmap index to disk * Write the bitmap index to disk
*/ */
static inline void dump_bitmap(struct sha1file *f, struct ewah_bitmap *bitmap) static inline void dump_bitmap(struct hashfile *f, struct ewah_bitmap *bitmap)
{ {
if (ewah_serialize_to(bitmap, sha1write_ewah_helper, f) < 0) if (ewah_serialize_to(bitmap, hashwrite_ewah_helper, f) < 0)
die("Failed to write bitmap index"); die("Failed to write bitmap index");
} }


@ -462,7 +462,7 @@ static const unsigned char *sha1_access(size_t pos, void *table)
return index[pos]->oid.hash; return index[pos]->oid.hash;
} }


static void write_selected_commits_v1(struct sha1file *f, static void write_selected_commits_v1(struct hashfile *f,
struct pack_idx_entry **index, struct pack_idx_entry **index,
uint32_t index_nr) uint32_t index_nr)
{ {
@ -477,15 +477,15 @@ static void write_selected_commits_v1(struct sha1file *f,
if (commit_pos < 0) if (commit_pos < 0)
die("BUG: trying to write commit not in index"); die("BUG: trying to write commit not in index");


sha1write_be32(f, commit_pos); hashwrite_be32(f, commit_pos);
sha1write_u8(f, stored->xor_offset); hashwrite_u8(f, stored->xor_offset);
sha1write_u8(f, stored->flags); hashwrite_u8(f, stored->flags);


dump_bitmap(f, stored->write_as); dump_bitmap(f, stored->write_as);
} }
} }


static void write_hash_cache(struct sha1file *f, static void write_hash_cache(struct hashfile *f,
struct pack_idx_entry **index, struct pack_idx_entry **index,
uint32_t index_nr) uint32_t index_nr)
{ {
@ -494,7 +494,7 @@ static void write_hash_cache(struct sha1file *f,
for (i = 0; i < index_nr; ++i) { for (i = 0; i < index_nr; ++i) {
struct object_entry *entry = (struct object_entry *)index[i]; struct object_entry *entry = (struct object_entry *)index[i];
uint32_t hash_value = htonl(entry->hash); uint32_t hash_value = htonl(entry->hash);
sha1write(f, &hash_value, sizeof(hash_value)); hashwrite(f, &hash_value, sizeof(hash_value));
} }
} }


@ -511,13 +511,13 @@ void bitmap_writer_finish(struct pack_idx_entry **index,
static uint16_t default_version = 1; static uint16_t default_version = 1;
static uint16_t flags = BITMAP_OPT_FULL_DAG; static uint16_t flags = BITMAP_OPT_FULL_DAG;
struct strbuf tmp_file = STRBUF_INIT; struct strbuf tmp_file = STRBUF_INIT;
struct sha1file *f; struct hashfile *f;


struct bitmap_disk_header header; struct bitmap_disk_header header;


int fd = odb_mkstemp(&tmp_file, "pack/tmp_bitmap_XXXXXX"); int fd = odb_mkstemp(&tmp_file, "pack/tmp_bitmap_XXXXXX");


f = sha1fd(fd, tmp_file.buf); f = hashfd(fd, tmp_file.buf);


memcpy(header.magic, BITMAP_IDX_SIGNATURE, sizeof(BITMAP_IDX_SIGNATURE)); memcpy(header.magic, BITMAP_IDX_SIGNATURE, sizeof(BITMAP_IDX_SIGNATURE));
header.version = htons(default_version); header.version = htons(default_version);
@ -525,7 +525,7 @@ void bitmap_writer_finish(struct pack_idx_entry **index,
header.entry_count = htonl(writer.selected_nr); header.entry_count = htonl(writer.selected_nr);
hashcpy(header.checksum, writer.pack_checksum); hashcpy(header.checksum, writer.pack_checksum);


sha1write(f, &header, sizeof(header)); hashwrite(f, &header, sizeof(header));
dump_bitmap(f, writer.commits); dump_bitmap(f, writer.commits);
dump_bitmap(f, writer.trees); dump_bitmap(f, writer.trees);
dump_bitmap(f, writer.blobs); dump_bitmap(f, writer.blobs);
@ -535,7 +535,7 @@ void bitmap_writer_finish(struct pack_idx_entry **index,
if (options & BITMAP_OPT_HASH_CACHE) if (options & BITMAP_OPT_HASH_CACHE)
write_hash_cache(f, index, index_nr); write_hash_cache(f, index, index_nr);


sha1close(f, NULL, CSUM_FSYNC); hashclose(f, NULL, CSUM_FSYNC);


if (adjust_shared_perm(tmp_file.buf)) if (adjust_shared_perm(tmp_file.buf))
die_errno("unable to make temporary bitmap file readable"); die_errno("unable to make temporary bitmap file readable");

32
pack-write.c
View File

@ -46,7 +46,7 @@ const char *write_idx_file(const char *index_name, struct pack_idx_entry **objec
int nr_objects, const struct pack_idx_option *opts, int nr_objects, const struct pack_idx_option *opts,
const unsigned char *sha1) const unsigned char *sha1)
{ {
struct sha1file *f; struct hashfile *f;
struct pack_idx_entry **sorted_by_sha, **list, **last; struct pack_idx_entry **sorted_by_sha, **list, **last;
off_t last_obj_offset = 0; off_t last_obj_offset = 0;
uint32_t array[256]; uint32_t array[256];
@ -68,7 +68,7 @@ const char *write_idx_file(const char *index_name, struct pack_idx_entry **objec


if (opts->flags & WRITE_IDX_VERIFY) { if (opts->flags & WRITE_IDX_VERIFY) {
assert(index_name); assert(index_name);
f = sha1fd_check(index_name); f = hashfd_check(index_name);
} else { } else {
if (!index_name) { if (!index_name) {
struct strbuf tmp_file = STRBUF_INIT; struct strbuf tmp_file = STRBUF_INIT;
@ -80,7 +80,7 @@ const char *write_idx_file(const char *index_name, struct pack_idx_entry **objec
if (fd < 0) if (fd < 0)
die_errno("unable to create '%s'", index_name); die_errno("unable to create '%s'", index_name);
} }
f = sha1fd(fd, index_name); f = hashfd(fd, index_name);
} }


/* if last object's offset is >= 2^31 we should use index V2 */ /* if last object's offset is >= 2^31 we should use index V2 */
@ -91,7 +91,7 @@ const char *write_idx_file(const char *index_name, struct pack_idx_entry **objec
struct pack_idx_header hdr; struct pack_idx_header hdr;
hdr.idx_signature = htonl(PACK_IDX_SIGNATURE); hdr.idx_signature = htonl(PACK_IDX_SIGNATURE);
hdr.idx_version = htonl(index_version); hdr.idx_version = htonl(index_version);
sha1write(f, &hdr, sizeof(hdr)); hashwrite(f, &hdr, sizeof(hdr));
} }


/* /*
@ -110,7 +110,7 @@ const char *write_idx_file(const char *index_name, struct pack_idx_entry **objec
array[i] = htonl(next - sorted_by_sha); array[i] = htonl(next - sorted_by_sha);
list = next; list = next;
} }
sha1write(f, array, 256 * 4); hashwrite(f, array, 256 * 4);


/* /*
* Write the actual SHA1 entries.. * Write the actual SHA1 entries..
@ -120,9 +120,9 @@ const char *write_idx_file(const char *index_name, struct pack_idx_entry **objec
struct pack_idx_entry *obj = *list++; struct pack_idx_entry *obj = *list++;
if (index_version < 2) { if (index_version < 2) {
uint32_t offset = htonl(obj->offset); uint32_t offset = htonl(obj->offset);
sha1write(f, &offset, 4); hashwrite(f, &offset, 4);
} }
sha1write(f, obj->oid.hash, the_hash_algo->rawsz); hashwrite(f, obj->oid.hash, the_hash_algo->rawsz);
if ((opts->flags & WRITE_IDX_STRICT) && if ((opts->flags & WRITE_IDX_STRICT) &&
(i && !oidcmp(&list[-2]->oid, &obj->oid))) (i && !oidcmp(&list[-2]->oid, &obj->oid)))
die("The same object %s appears twice in the pack", die("The same object %s appears twice in the pack",
@ -137,7 +137,7 @@ const char *write_idx_file(const char *index_name, struct pack_idx_entry **objec
for (i = 0; i < nr_objects; i++) { for (i = 0; i < nr_objects; i++) {
struct pack_idx_entry *obj = *list++; struct pack_idx_entry *obj = *list++;
uint32_t crc32_val = htonl(obj->crc32); uint32_t crc32_val = htonl(obj->crc32);
sha1write(f, &crc32_val, 4); hashwrite(f, &crc32_val, 4);
} }


/* write the 32-bit offset table */ /* write the 32-bit offset table */
@ -150,7 +150,7 @@ const char *write_idx_file(const char *index_name, struct pack_idx_entry **objec
? (0x80000000 | nr_large_offset++) ? (0x80000000 | nr_large_offset++)
: obj->offset); : obj->offset);
offset = htonl(offset); offset = htonl(offset);
sha1write(f, &offset, 4); hashwrite(f, &offset, 4);
} }


/* write the large offset table */ /* write the large offset table */
@ -164,25 +164,25 @@ const char *write_idx_file(const char *index_name, struct pack_idx_entry **objec
continue; continue;
split[0] = htonl(offset >> 32); split[0] = htonl(offset >> 32);
split[1] = htonl(offset & 0xffffffff); split[1] = htonl(offset & 0xffffffff);
sha1write(f, split, 8); hashwrite(f, split, 8);
nr_large_offset--; nr_large_offset--;
} }
} }


sha1write(f, sha1, the_hash_algo->rawsz); hashwrite(f, sha1, the_hash_algo->rawsz);
sha1close(f, NULL, ((opts->flags & WRITE_IDX_VERIFY) hashclose(f, NULL, ((opts->flags & WRITE_IDX_VERIFY)
? CSUM_CLOSE : CSUM_FSYNC)); ? CSUM_CLOSE : CSUM_FSYNC));
return index_name; return index_name;
} }


off_t write_pack_header(struct sha1file *f, uint32_t nr_entries) off_t write_pack_header(struct hashfile *f, uint32_t nr_entries)
{ {
struct pack_header hdr; struct pack_header hdr;


hdr.hdr_signature = htonl(PACK_SIGNATURE); hdr.hdr_signature = htonl(PACK_SIGNATURE);
hdr.hdr_version = htonl(PACK_VERSION); hdr.hdr_version = htonl(PACK_VERSION);
hdr.hdr_entries = htonl(nr_entries); hdr.hdr_entries = htonl(nr_entries);
sha1write(f, &hdr, sizeof(hdr)); hashwrite(f, &hdr, sizeof(hdr));
return sizeof(hdr); return sizeof(hdr);
} }


@ -333,14 +333,14 @@ int encode_in_pack_object_header(unsigned char *hdr, int hdr_len,
return n; return n;
} }


struct sha1file *create_tmp_packfile(char **pack_tmp_name) struct hashfile *create_tmp_packfile(char **pack_tmp_name)
{ {
struct strbuf tmpname = STRBUF_INIT; struct strbuf tmpname = STRBUF_INIT;
int fd; int fd;


fd = odb_mkstemp(&tmpname, "pack/tmp_pack_XXXXXX"); fd = odb_mkstemp(&tmpname, "pack/tmp_pack_XXXXXX");
*pack_tmp_name = strbuf_detach(&tmpname, NULL); *pack_tmp_name = strbuf_detach(&tmpname, NULL);
return sha1fd(fd, *pack_tmp_name); return hashfd(fd, *pack_tmp_name);
} }


void finish_tmp_packfile(struct strbuf *name_buffer, void finish_tmp_packfile(struct strbuf *name_buffer,

4
pack.h
View File

@ -81,7 +81,7 @@ extern const char *write_idx_file(const char *index_name, struct pack_idx_entry
extern int check_pack_crc(struct packed_git *p, struct pack_window **w_curs, off_t offset, off_t len, unsigned int nr); extern int check_pack_crc(struct packed_git *p, struct pack_window **w_curs, off_t offset, off_t len, unsigned int nr);
extern int verify_pack_index(struct packed_git *); extern int verify_pack_index(struct packed_git *);
extern int verify_pack(struct packed_git *, verify_fn fn, struct progress *, uint32_t); extern int verify_pack(struct packed_git *, verify_fn fn, struct progress *, uint32_t);
extern off_t write_pack_header(struct sha1file *f, uint32_t); extern off_t write_pack_header(struct hashfile *f, uint32_t);
extern void fixup_pack_header_footer(int, unsigned char *, const char *, uint32_t, unsigned char *, off_t); extern void fixup_pack_header_footer(int, unsigned char *, const char *, uint32_t, unsigned char *, off_t);
extern char *index_pack_lockfile(int fd); extern char *index_pack_lockfile(int fd);


@ -98,7 +98,7 @@ extern int encode_in_pack_object_header(unsigned char *hdr, int hdr_len,
#define PH_ERROR_PROTOCOL (-3) #define PH_ERROR_PROTOCOL (-3)
extern int read_pack_header(int fd, struct pack_header *); extern int read_pack_header(int fd, struct pack_header *);


extern struct sha1file *create_tmp_packfile(char **pack_tmp_name); extern struct hashfile *create_tmp_packfile(char **pack_tmp_name);
extern void finish_tmp_packfile(struct strbuf *name_buffer, const char *pack_tmp_name, struct pack_idx_entry **written_list, uint32_t nr_written, struct pack_idx_option *pack_idx_opts, unsigned char sha1[]); extern void finish_tmp_packfile(struct strbuf *name_buffer, const char *pack_tmp_name, struct pack_idx_entry **written_list, uint32_t nr_written, struct pack_idx_option *pack_idx_opts, unsigned char sha1[]);


#endif #endif