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

sha1-file.c: remove implicit dependency on the_index 

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
maint
Nguyễn Thái Ngọc Duy 2018-09-21 17:57:31 +02:00 committed by Junio C Hamano
parent a7edadda59
commit 58bf2a4cc7
9 changed files with 61 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
builtin/difftool.c
View File

@ -112,7 +112,7 @@ static int use_wt_file(const char *workdir, const char *name,
int fd = open(buf.buf, O_RDONLY); int fd = open(buf.buf, O_RDONLY);


if (fd >= 0 && if (fd >= 0 &&
!index_fd(&wt_oid, fd, &st, OBJ_BLOB, name, 0)) { !index_fd(&the_index, &wt_oid, fd, &st, OBJ_BLOB, name, 0)) {
if (is_null_oid(oid)) { if (is_null_oid(oid)) {
oidcpy(oid, &wt_oid); oidcpy(oid, &wt_oid);
use = 1; use = 1;

2
builtin/hash-object.c
View File

@ -40,7 +40,7 @@ static void hash_fd(int fd, const char *type, const char *path, unsigned flags,
if (fstat(fd, &st) < 0 || if (fstat(fd, &st) < 0 ||
(literally (literally
? hash_literally(&oid, fd, type, flags) ? hash_literally(&oid, fd, type, flags)
: index_fd(&oid, fd, &st, type_from_string(type), path, flags))) : index_fd(&the_index, &oid, fd, &st, type_from_string(type), path, flags)))
die((flags & HASH_WRITE_OBJECT) die((flags & HASH_WRITE_OBJECT)
? "Unable to add %s to database" ? "Unable to add %s to database"
: "Unable to hash %s", path); : "Unable to hash %s", path);

2
builtin/replace.c
View File

@ -295,7 +295,7 @@ static int import_object(struct object_id *oid, enum object_type type,
close(fd); close(fd);
return -1; return -1;
} }
if (index_fd(oid, fd, &st, type, NULL, flags) < 0) if (index_fd(&the_index, oid, fd, &st, type, NULL, flags) < 0)
return error(_("unable to write object to database")); return error(_("unable to write object to database"));
/* index_fd close()s fd for us */ /* index_fd close()s fd for us */
} }

2
builtin/update-index.c
View File

@ -282,7 +282,7 @@ static int add_one_path(const struct cache_entry *old, const char *path, int len
fill_stat_cache_info(ce, st); fill_stat_cache_info(ce, st);
ce->ce_mode = ce_mode_from_stat(old, st->st_mode); ce->ce_mode = ce_mode_from_stat(old, st->st_mode);


if (index_path(&ce->oid, path, st, if (index_path(&the_index, &ce->oid, path, st,
info_only ? 0 : HASH_WRITE_OBJECT)) { info_only ? 0 : HASH_WRITE_OBJECT)) {
discard_cache_entry(ce); discard_cache_entry(ce);
return -1; return -1;

4
cache.h
View File

@ -787,8 +787,8 @@ extern int ie_modified(struct index_state *, const struct cache_entry *, struct
#define HASH_WRITE_OBJECT 1 #define HASH_WRITE_OBJECT 1
#define HASH_FORMAT_CHECK 2 #define HASH_FORMAT_CHECK 2
#define HASH_RENORMALIZE 4 #define HASH_RENORMALIZE 4
extern int index_fd(struct object_id *oid, int fd, struct stat *st, enum object_type type, const char *path, unsigned flags); extern int index_fd(struct index_state *istate, struct object_id *oid, int fd, struct stat *st, enum object_type type, const char *path, unsigned flags);
extern int index_path(struct object_id *oid, const char *path, struct stat *st, unsigned flags); extern int index_path(struct index_state *istate, struct object_id *oid, const char *path, struct stat *st, unsigned flags);


/* /*
* Record to sd the data from st that we use to check whether a file * Record to sd the data from st that we use to check whether a file

20
diff.c
View File

@ -4252,7 +4252,7 @@ static void run_diff_cmd(const char *pgm,
fprintf(o->file, "* Unmerged path %s\n", name); fprintf(o->file, "* Unmerged path %s\n", name);
} }


static void diff_fill_oid_info(struct diff_filespec *one) static void diff_fill_oid_info(struct diff_filespec *one, struct index_state *istate)
{ {
if (DIFF_FILE_VALID(one)) { if (DIFF_FILE_VALID(one)) {
if (!one->oid_valid) { if (!one->oid_valid) {
@ -4263,7 +4263,7 @@ static void diff_fill_oid_info(struct diff_filespec *one)
} }
if (lstat(one->path, &st) < 0) if (lstat(one->path, &st) < 0)
die_errno("stat '%s'", one->path); die_errno("stat '%s'", one->path);
if (index_path(&one->oid, one->path, &st, 0)) if (index_path(istate, &one->oid, one->path, &st, 0))
die("cannot hash %s", one->path); die("cannot hash %s", one->path);
} }
} }
@ -4311,8 +4311,8 @@ static void run_diff(struct diff_filepair *p, struct diff_options *o)
return; return;
} }


diff_fill_oid_info(one); diff_fill_oid_info(one, o->repo->index);
diff_fill_oid_info(two); diff_fill_oid_info(two, o->repo->index);


if (!pgm && if (!pgm &&
DIFF_FILE_VALID(one) && DIFF_FILE_VALID(two) && DIFF_FILE_VALID(one) && DIFF_FILE_VALID(two) &&
@ -4359,8 +4359,8 @@ static void run_diffstat(struct diff_filepair *p, struct diff_options *o,
if (o->prefix_length) if (o->prefix_length)
strip_prefix(o->prefix_length, &name, &other); strip_prefix(o->prefix_length, &name, &other);


diff_fill_oid_info(p->one); diff_fill_oid_info(p->one, o->repo->index);
diff_fill_oid_info(p->two); diff_fill_oid_info(p->two, o->repo->index);


builtin_diffstat(name, other, p->one, p->two, builtin_diffstat(name, other, p->one, p->two,
diffstat, o, p); diffstat, o, p);
@ -4384,8 +4384,8 @@ static void run_checkdiff(struct diff_filepair *p, struct diff_options *o)
if (o->prefix_length) if (o->prefix_length)
strip_prefix(o->prefix_length, &name, &other); strip_prefix(o->prefix_length, &name, &other);


diff_fill_oid_info(p->one); diff_fill_oid_info(p->one, o->repo->index);
diff_fill_oid_info(p->two); diff_fill_oid_info(p->two, o->repo->index);


builtin_checkdiff(name, other, attr_path, p->one, p->two, o); builtin_checkdiff(name, other, attr_path, p->one, p->two, o);
} }
@ -5685,8 +5685,8 @@ static int diff_get_patch_id(struct diff_options *options, struct object_id *oid
if (DIFF_PAIR_UNMERGED(p)) if (DIFF_PAIR_UNMERGED(p))
continue; continue;


diff_fill_oid_info(p->one); diff_fill_oid_info(p->one, options->repo->index);
diff_fill_oid_info(p->two); diff_fill_oid_info(p->two, options->repo->index);


len1 = remove_space(p->one->path, strlen(p->one->path)); len1 = remove_space(p->one->path, strlen(p->one->path));
len2 = remove_space(p->two->path, strlen(p->two->path)); len2 = remove_space(p->two->path, strlen(p->two->path));

2
notes-merge.c
View File

@ -710,7 +710,7 @@ int notes_merge_commit(struct notes_merge_options *o,
/* write file as blob, and add to partial_tree */ /* write file as blob, and add to partial_tree */
if (stat(path.buf, &st)) if (stat(path.buf, &st))
die_errno("Failed to stat '%s'", path.buf); die_errno("Failed to stat '%s'", path.buf);
if (index_path(&blob_oid, path.buf, &st, HASH_WRITE_OBJECT)) if (index_path(&the_index, &blob_oid, path.buf, &st, HASH_WRITE_OBJECT))
die("Failed to write blob object from '%s'", path.buf); die("Failed to write blob object from '%s'", path.buf);
if (add_note(partial_tree, &obj_oid, &blob_oid, NULL)) if (add_note(partial_tree, &obj_oid, &blob_oid, NULL))
die("Failed to add resolved note '%s' to notes tree", die("Failed to add resolved note '%s' to notes tree",

25
read-cache.c
View File

@ -205,14 +205,16 @@ void fill_stat_cache_info(struct cache_entry *ce, struct stat *st)
} }
} }


static int ce_compare_data(const struct cache_entry *ce, struct stat *st) static int ce_compare_data(struct index_state *istate,
const struct cache_entry *ce,
struct stat *st)
{ {
int match = -1; int match = -1;
int fd = git_open_cloexec(ce->name, O_RDONLY); int fd = git_open_cloexec(ce->name, O_RDONLY);


if (fd >= 0) { if (fd >= 0) {
struct object_id oid; struct object_id oid;
if (!index_fd(&oid, fd, st, OBJ_BLOB, ce->name, 0)) if (!index_fd(istate, &oid, fd, st, OBJ_BLOB, ce->name, 0))
match = oidcmp(&oid, &ce->oid); match = oidcmp(&oid, &ce->oid);
/* index_fd() closed the file descriptor already */ /* index_fd() closed the file descriptor already */
} }
@ -257,11 +259,13 @@ static int ce_compare_gitlink(const struct cache_entry *ce)
return oidcmp(&oid, &ce->oid); return oidcmp(&oid, &ce->oid);
} }


static int ce_modified_check_fs(const struct cache_entry *ce, struct stat *st) static int ce_modified_check_fs(struct index_state *istate,
const struct cache_entry *ce,
struct stat *st)
{ {
switch (st->st_mode & S_IFMT) { switch (st->st_mode & S_IFMT) {
case S_IFREG: case S_IFREG:
if (ce_compare_data(ce, st)) if (ce_compare_data(istate, ce, st))
return DATA_CHANGED; return DATA_CHANGED;
break; break;
case S_IFLNK: case S_IFLNK:
@ -407,7 +411,7 @@ int ie_match_stat(struct index_state *istate,
if (assume_racy_is_modified) if (assume_racy_is_modified)
changed |= DATA_CHANGED; changed |= DATA_CHANGED;
else else
changed |= ce_modified_check_fs(ce, st); changed |= ce_modified_check_fs(istate, ce, st);
} }


return changed; return changed;
@ -447,7 +451,7 @@ int ie_modified(struct index_state *istate,
(S_ISGITLINK(ce->ce_mode) || ce->ce_stat_data.sd_size != 0)) (S_ISGITLINK(ce->ce_mode) || ce->ce_stat_data.sd_size != 0))
return changed; return changed;


changed_fs = ce_modified_check_fs(ce, st); changed_fs = ce_modified_check_fs(istate, ce, st);
if (changed_fs) if (changed_fs)
return changed | changed_fs; return changed | changed_fs;
return 0; return 0;
@ -753,7 +757,7 @@ int add_to_index(struct index_state *istate, const char *path, struct stat *st,
} }
} }
if (!intent_only) { if (!intent_only) {
if (index_path(&ce->oid, path, st, newflags)) { if (index_path(istate, &ce->oid, path, st, newflags)) {
discard_cache_entry(ce); discard_cache_entry(ce);
return error("unable to index file %s", path); return error("unable to index file %s", path);
} }
@ -2230,7 +2234,8 @@ static int ce_flush(git_hash_ctx *context, int fd, unsigned char *hash)
return (write_in_full(fd, write_buffer, left) < 0) ? -1 : 0; return (write_in_full(fd, write_buffer, left) < 0) ? -1 : 0;
} }


static void ce_smudge_racily_clean_entry(struct cache_entry *ce) static void ce_smudge_racily_clean_entry(struct index_state *istate,
struct cache_entry *ce)
{ {
/* /*
* The only thing we care about in this function is to smudge the * The only thing we care about in this function is to smudge the
@ -2249,7 +2254,7 @@ static void ce_smudge_racily_clean_entry(struct cache_entry *ce)
return; return;
if (ce_match_stat_basic(ce, &st)) if (ce_match_stat_basic(ce, &st))
return; return;
if (ce_modified_check_fs(ce, &st)) { if (ce_modified_check_fs(istate, ce, &st)) {
/* This is "racily clean"; smudge it. Note that this /* This is "racily clean"; smudge it. Note that this
* is a tricky code. At first glance, it may appear * is a tricky code. At first glance, it may appear
* that it can break with this sequence: * that it can break with this sequence:
@ -2494,7 +2499,7 @@ static int do_write_index(struct index_state *istate, struct tempfile *tempfile,
if (ce->ce_flags & CE_REMOVE) if (ce->ce_flags & CE_REMOVE)
continue; continue;
if (!ce_uptodate(ce) && is_racy_timestamp(istate, ce)) if (!ce_uptodate(ce) && is_racy_timestamp(istate, ce))
ce_smudge_racily_clean_entry(ce); ce_smudge_racily_clean_entry(istate, ce);
if (is_null_oid(&ce->oid)) { if (is_null_oid(&ce->oid)) {
static const char msg[] = "cache entry has null sha1: %s"; static const char msg[] = "cache entry has null sha1: %s";
static int allow = -1; static int allow = -1;

50
sha1-file.c
View File

@ -1813,7 +1813,8 @@ static void check_tag(const void *buf, size_t size)
die(_("corrupt tag")); die(_("corrupt tag"));
} }


static int index_mem(struct object_id *oid, void *buf, size_t size, static int index_mem(struct index_state *istate,
struct object_id *oid, void *buf, size_t size,
enum object_type type, enum object_type type,
const char *path, unsigned flags) const char *path, unsigned flags)
{ {
@ -1828,7 +1829,7 @@ static int index_mem(struct object_id *oid, void *buf, size_t size,
*/ */
if ((type == OBJ_BLOB) && path) { if ((type == OBJ_BLOB) && path) {
struct strbuf nbuf = STRBUF_INIT; struct strbuf nbuf = STRBUF_INIT;
if (convert_to_git(&the_index, path, buf, size, &nbuf, if (convert_to_git(istate, path, buf, size, &nbuf,
get_conv_flags(flags))) { get_conv_flags(flags))) {
buf = strbuf_detach(&nbuf, &size); buf = strbuf_detach(&nbuf, &size);
re_allocated = 1; re_allocated = 1;
@ -1852,17 +1853,20 @@ static int index_mem(struct object_id *oid, void *buf, size_t size,
return ret; return ret;
} }


static int index_stream_convert_blob(struct object_id *oid, int fd, static int index_stream_convert_blob(struct index_state *istate,
const char *path, unsigned flags) struct object_id *oid,
int fd,
const char *path,
unsigned flags)
{ {
int ret; int ret;
const int write_object = flags & HASH_WRITE_OBJECT; const int write_object = flags & HASH_WRITE_OBJECT;
struct strbuf sbuf = STRBUF_INIT; struct strbuf sbuf = STRBUF_INIT;


assert(path); assert(path);
assert(would_convert_to_git_filter_fd(&the_index, path)); assert(would_convert_to_git_filter_fd(istate, path));


convert_to_git_filter_fd(&the_index, path, fd, &sbuf, convert_to_git_filter_fd(istate, path, fd, &sbuf,
get_conv_flags(flags)); get_conv_flags(flags));


if (write_object) if (write_object)
@ -1875,14 +1879,15 @@ static int index_stream_convert_blob(struct object_id *oid, int fd,
return ret; return ret;
} }


static int index_pipe(struct object_id *oid, int fd, enum object_type type, static int index_pipe(struct index_state *istate, struct object_id *oid,
int fd, enum object_type type,
const char *path, unsigned flags) const char *path, unsigned flags)
{ {
struct strbuf sbuf = STRBUF_INIT; struct strbuf sbuf = STRBUF_INIT;
int ret; int ret;


if (strbuf_read(&sbuf, fd, 4096) >= 0) if (strbuf_read(&sbuf, fd, 4096) >= 0)
ret = index_mem(oid, sbuf.buf, sbuf.len, type, path, flags); ret = index_mem(istate, oid, sbuf.buf, sbuf.len, type, path, flags);
else else
ret = -1; ret = -1;
strbuf_release(&sbuf); strbuf_release(&sbuf);
@ -1891,14 +1896,15 @@ static int index_pipe(struct object_id *oid, int fd, enum object_type type,


#define SMALL_FILE_SIZE (32*1024) #define SMALL_FILE_SIZE (32*1024)


static int index_core(struct object_id *oid, int fd, size_t size, static int index_core(struct index_state *istate,
struct object_id *oid, int fd, size_t size,
enum object_type type, const char *path, enum object_type type, const char *path,
unsigned flags) unsigned flags)
{ {
int ret; int ret;


if (!size) { if (!size) {
ret = index_mem(oid, "", size, type, path, flags); ret = index_mem(istate, oid, "", size, type, path, flags);
} else if (size <= SMALL_FILE_SIZE) { } else if (size <= SMALL_FILE_SIZE) {
char *buf = xmalloc(size); char *buf = xmalloc(size);
ssize_t read_result = read_in_full(fd, buf, size); ssize_t read_result = read_in_full(fd, buf, size);
@ -1909,11 +1915,11 @@ static int index_core(struct object_id *oid, int fd, size_t size,
ret = error(_("short read while indexing %s"), ret = error(_("short read while indexing %s"),
path ? path : "<unknown>"); path ? path : "<unknown>");
else else
ret = index_mem(oid, buf, size, type, path, flags); ret = index_mem(istate, oid, buf, size, type, path, flags);
free(buf); free(buf);
} else { } else {
void *buf = xmmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0); void *buf = xmmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
ret = index_mem(oid, buf, size, type, path, flags); ret = index_mem(istate, oid, buf, size, type, path, flags);
munmap(buf, size); munmap(buf, size);
} }
return ret; return ret;
@ -1941,7 +1947,8 @@ static int index_stream(struct object_id *oid, int fd, size_t size,
return index_bulk_checkin(oid, fd, size, type, path, flags); return index_bulk_checkin(oid, fd, size, type, path, flags);
} }


int index_fd(struct object_id *oid, int fd, struct stat *st, int index_fd(struct index_state *istate, struct object_id *oid,
int fd, struct stat *st,
enum object_type type, const char *path, unsigned flags) enum object_type type, const char *path, unsigned flags)
{ {
int ret; int ret;
@ -1950,14 +1957,14 @@ int index_fd(struct object_id *oid, int fd, struct stat *st,
* Call xsize_t() only when needed to avoid potentially unnecessary * Call xsize_t() only when needed to avoid potentially unnecessary
* die() for large files. * die() for large files.
*/ */
if (type == OBJ_BLOB && path && would_convert_to_git_filter_fd(&the_index, path)) if (type == OBJ_BLOB && path && would_convert_to_git_filter_fd(istate, path))
ret = index_stream_convert_blob(oid, fd, path, flags); ret = index_stream_convert_blob(istate, oid, fd, path, flags);
else if (!S_ISREG(st->st_mode)) else if (!S_ISREG(st->st_mode))
ret = index_pipe(oid, fd, type, path, flags); ret = index_pipe(istate, oid, fd, type, path, flags);
else if (st->st_size <= big_file_threshold || type != OBJ_BLOB || else if (st->st_size <= big_file_threshold || type != OBJ_BLOB ||
(path && would_convert_to_git(&the_index, path))) (path && would_convert_to_git(istate, path)))
ret = index_core(oid, fd, xsize_t(st->st_size), type, path, ret = index_core(istate, oid, fd, xsize_t(st->st_size),
flags); type, path, flags);
else else
ret = index_stream(oid, fd, xsize_t(st->st_size), type, path, ret = index_stream(oid, fd, xsize_t(st->st_size), type, path,
flags); flags);
@ -1965,7 +1972,8 @@ int index_fd(struct object_id *oid, int fd, struct stat *st,
return ret; return ret;
} }


int index_path(struct object_id *oid, const char *path, struct stat *st, unsigned flags) int index_path(struct index_state *istate, struct object_id *oid,
const char *path, struct stat *st, unsigned flags)
{ {
int fd; int fd;
struct strbuf sb = STRBUF_INIT; struct strbuf sb = STRBUF_INIT;
@ -1976,7 +1984,7 @@ int index_path(struct object_id *oid, const char *path, struct stat *st, unsigne
fd = open(path, O_RDONLY); fd = open(path, O_RDONLY);
if (fd < 0) if (fd < 0)
return error_errno("open(\"%s\")", path); return error_errno("open(\"%s\")", path);
if (index_fd(oid, fd, st, OBJ_BLOB, path, flags) < 0) if (index_fd(istate, oid, fd, st, OBJ_BLOB, path, flags) < 0)
return error(_("%s: failed to insert into database"), return error(_("%s: failed to insert into database"),
path); path);
break; break;