2005-04-08 00:16:10 +02:00
|
|
|
/*
|
|
|
|
* GIT - The information manager from hell
|
|
|
|
*
|
|
|
|
* Copyright (C) Linus Torvalds, 2005
|
|
|
|
*/
|
2005-04-08 00:13:13 +02:00
|
|
|
#include "cache.h"
|
2017-06-14 20:07:36 +02:00
|
|
|
#include "config.h"
|
2014-10-01 12:28:42 +02:00
|
|
|
#include "lockfile.h"
|
2005-10-16 09:39:07 +02:00
|
|
|
#include "quote.h"
|
2006-04-24 09:23:54 +02:00
|
|
|
#include "cache-tree.h"
|
2006-04-20 08:52:05 +02:00
|
|
|
#include "tree-walk.h"
|
2006-06-13 22:21:57 +02:00
|
|
|
#include "builtin.h"
|
2007-04-12 21:29:40 +02:00
|
|
|
#include "refs.h"
|
2009-12-25 19:31:26 +01:00
|
|
|
#include "resolve-undo.h"
|
2010-12-02 00:34:06 +01:00
|
|
|
#include "parse-options.h"
|
2013-07-14 10:35:25 +02:00
|
|
|
#include "pathspec.h"
|
2014-01-24 14:40:28 +01:00
|
|
|
#include "dir.h"
|
2014-06-13 14:19:44 +02:00
|
|
|
#include "split-index.h"
|
2017-09-22 18:35:40 +02:00
|
|
|
#include "fsmonitor.h"
|
2005-04-08 00:13:13 +02:00
|
|
|
|
2005-04-10 20:32:54 +02:00
|
|
|
/*
|
|
|
|
* Default to not allowing changes to the list of files. The
|
|
|
|
* tool doesn't actually care, but this makes it harder to add
|
|
|
|
* files to the revision control by mistake by doing something
|
2008-09-13 19:18:36 +02:00
|
|
|
* like "git update-index *" and suddenly having all the object
|
2005-04-10 20:32:54 +02:00
|
|
|
* files be revision controlled.
|
|
|
|
*/
|
2005-10-15 06:56:46 +02:00
|
|
|
static int allow_add;
|
|
|
|
static int allow_remove;
|
|
|
|
static int allow_replace;
|
|
|
|
static int info_only;
|
2005-05-31 18:52:43 +02:00
|
|
|
static int force_remove;
|
2005-10-15 06:56:46 +02:00
|
|
|
static int verbose;
|
2006-08-15 19:23:48 +02:00
|
|
|
static int mark_valid_only;
|
2009-08-20 15:46:57 +02:00
|
|
|
static int mark_skip_worktree_only;
|
2017-09-22 18:35:43 +02:00
|
|
|
static int mark_fsmonitor_only;
|
2009-08-20 15:46:55 +02:00
|
|
|
#define MARK_FLAG 1
|
|
|
|
#define UNMARK_FLAG 2
|
2015-03-08 11:12:43 +01:00
|
|
|
static struct strbuf mtime_dir = STRBUF_INIT;
|
2006-02-09 06:15:24 +01:00
|
|
|
|
2016-01-24 16:28:15 +01:00
|
|
|
/* Untracked cache mode */
|
|
|
|
enum uc_mode {
|
|
|
|
UC_UNSPECIFIED = -1,
|
|
|
|
UC_DISABLE = 0,
|
|
|
|
UC_ENABLE,
|
2016-01-24 16:28:16 +01:00
|
|
|
UC_TEST,
|
2016-01-24 16:28:15 +01:00
|
|
|
UC_FORCE
|
|
|
|
};
|
|
|
|
|
2009-11-14 22:33:13 +01:00
|
|
|
__attribute__((format (printf, 1, 2)))
|
2005-10-15 06:56:46 +02:00
|
|
|
static void report(const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list vp;
|
|
|
|
|
|
|
|
if (!verbose)
|
|
|
|
return;
|
|
|
|
|
|
|
|
va_start(vp, fmt);
|
|
|
|
vprintf(fmt, vp);
|
|
|
|
putchar('\n');
|
|
|
|
va_end(vp);
|
|
|
|
}
|
|
|
|
|
2015-03-08 11:12:43 +01:00
|
|
|
static void remove_test_directory(void)
|
|
|
|
{
|
|
|
|
if (mtime_dir.len)
|
|
|
|
remove_dir_recursively(&mtime_dir, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char *get_mtime_path(const char *path)
|
|
|
|
{
|
|
|
|
static struct strbuf sb = STRBUF_INIT;
|
|
|
|
strbuf_reset(&sb);
|
|
|
|
strbuf_addf(&sb, "%s/%s", mtime_dir.buf, path);
|
|
|
|
return sb.buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void xmkdir(const char *path)
|
|
|
|
{
|
|
|
|
path = get_mtime_path(path);
|
|
|
|
if (mkdir(path, 0700))
|
|
|
|
die_errno(_("failed to create directory %s"), path);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int xstat_mtime_dir(struct stat *st)
|
|
|
|
{
|
|
|
|
if (stat(mtime_dir.buf, st))
|
|
|
|
die_errno(_("failed to stat %s"), mtime_dir.buf);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int create_file(const char *path)
|
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
path = get_mtime_path(path);
|
|
|
|
fd = open(path, O_CREAT | O_RDWR, 0644);
|
|
|
|
if (fd < 0)
|
|
|
|
die_errno(_("failed to create file %s"), path);
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void xunlink(const char *path)
|
|
|
|
{
|
|
|
|
path = get_mtime_path(path);
|
|
|
|
if (unlink(path))
|
|
|
|
die_errno(_("failed to delete file %s"), path);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void xrmdir(const char *path)
|
|
|
|
{
|
|
|
|
path = get_mtime_path(path);
|
|
|
|
if (rmdir(path))
|
|
|
|
die_errno(_("failed to delete directory %s"), path);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void avoid_racy(void)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* not use if we could usleep(10) if USE_NSEC is defined. The
|
|
|
|
* field nsec could be there, but the OS could choose to
|
|
|
|
* ignore it?
|
|
|
|
*/
|
|
|
|
sleep(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int test_if_untracked_cache_is_supported(void)
|
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
struct stat_data base;
|
|
|
|
int fd, ret = 0;
|
2017-03-30 08:22:08 +02:00
|
|
|
char *cwd;
|
2015-03-08 11:12:43 +01:00
|
|
|
|
|
|
|
strbuf_addstr(&mtime_dir, "mtime-test-XXXXXX");
|
|
|
|
if (!mkdtemp(mtime_dir.buf))
|
|
|
|
die_errno("Could not make temporary directory");
|
|
|
|
|
2017-03-30 08:22:08 +02:00
|
|
|
cwd = xgetcwd();
|
|
|
|
fprintf(stderr, _("Testing mtime in '%s' "), cwd);
|
|
|
|
free(cwd);
|
|
|
|
|
2015-03-08 11:12:43 +01:00
|
|
|
atexit(remove_test_directory);
|
|
|
|
xstat_mtime_dir(&st);
|
|
|
|
fill_stat_data(&base, &st);
|
|
|
|
fputc('.', stderr);
|
|
|
|
|
|
|
|
avoid_racy();
|
|
|
|
fd = create_file("newfile");
|
|
|
|
xstat_mtime_dir(&st);
|
|
|
|
if (!match_stat_data(&base, &st)) {
|
|
|
|
close(fd);
|
|
|
|
fputc('\n', stderr);
|
|
|
|
fprintf_ln(stderr,_("directory stat info does not "
|
|
|
|
"change after adding a new file"));
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
fill_stat_data(&base, &st);
|
|
|
|
fputc('.', stderr);
|
|
|
|
|
|
|
|
avoid_racy();
|
|
|
|
xmkdir("new-dir");
|
|
|
|
xstat_mtime_dir(&st);
|
|
|
|
if (!match_stat_data(&base, &st)) {
|
|
|
|
close(fd);
|
|
|
|
fputc('\n', stderr);
|
|
|
|
fprintf_ln(stderr, _("directory stat info does not change "
|
|
|
|
"after adding a new directory"));
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
fill_stat_data(&base, &st);
|
|
|
|
fputc('.', stderr);
|
|
|
|
|
|
|
|
avoid_racy();
|
|
|
|
write_or_die(fd, "data", 4);
|
|
|
|
close(fd);
|
|
|
|
xstat_mtime_dir(&st);
|
|
|
|
if (match_stat_data(&base, &st)) {
|
|
|
|
fputc('\n', stderr);
|
|
|
|
fprintf_ln(stderr, _("directory stat info changes "
|
|
|
|
"after updating a file"));
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
fputc('.', stderr);
|
|
|
|
|
|
|
|
avoid_racy();
|
|
|
|
close(create_file("new-dir/new"));
|
|
|
|
xstat_mtime_dir(&st);
|
|
|
|
if (match_stat_data(&base, &st)) {
|
|
|
|
fputc('\n', stderr);
|
|
|
|
fprintf_ln(stderr, _("directory stat info changes after "
|
|
|
|
"adding a file inside subdirectory"));
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
fputc('.', stderr);
|
|
|
|
|
|
|
|
avoid_racy();
|
|
|
|
xunlink("newfile");
|
|
|
|
xstat_mtime_dir(&st);
|
|
|
|
if (!match_stat_data(&base, &st)) {
|
|
|
|
fputc('\n', stderr);
|
|
|
|
fprintf_ln(stderr, _("directory stat info does not "
|
|
|
|
"change after deleting a file"));
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
fill_stat_data(&base, &st);
|
|
|
|
fputc('.', stderr);
|
|
|
|
|
|
|
|
avoid_racy();
|
|
|
|
xunlink("new-dir/new");
|
|
|
|
xrmdir("new-dir");
|
|
|
|
xstat_mtime_dir(&st);
|
|
|
|
if (!match_stat_data(&base, &st)) {
|
|
|
|
fputc('\n', stderr);
|
|
|
|
fprintf_ln(stderr, _("directory stat info does not "
|
|
|
|
"change after deleting a directory"));
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rmdir(mtime_dir.buf))
|
|
|
|
die_errno(_("failed to delete directory %s"), mtime_dir.buf);
|
|
|
|
fprintf_ln(stderr, _(" OK"));
|
|
|
|
ret = 1;
|
|
|
|
|
|
|
|
done:
|
|
|
|
strbuf_release(&mtime_dir);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-08-20 15:46:55 +02:00
|
|
|
static int mark_ce_flags(const char *path, int flag, int mark)
|
2006-02-09 06:15:24 +01:00
|
|
|
{
|
|
|
|
int namelen = strlen(path);
|
|
|
|
int pos = cache_name_pos(path, namelen);
|
|
|
|
if (0 <= pos) {
|
2017-09-22 18:35:43 +02:00
|
|
|
mark_fsmonitor_invalid(&the_index, active_cache[pos]);
|
2009-08-20 15:46:55 +02:00
|
|
|
if (mark)
|
|
|
|
active_cache[pos]->ce_flags |= flag;
|
|
|
|
else
|
|
|
|
active_cache[pos]->ce_flags &= ~flag;
|
2014-06-13 14:19:39 +02:00
|
|
|
active_cache[pos]->ce_flags |= CE_UPDATE_IN_BASE;
|
2014-06-13 14:19:31 +02:00
|
|
|
cache_tree_invalidate_path(&the_index, path);
|
2014-06-13 14:19:28 +02:00
|
|
|
active_cache_changed |= CE_ENTRY_CHANGED;
|
2006-02-09 06:15:24 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2007-04-12 21:29:40 +02:00
|
|
|
static int remove_one_path(const char *path)
|
2005-04-08 00:13:13 +02:00
|
|
|
{
|
2007-04-12 21:29:40 +02:00
|
|
|
if (!allow_remove)
|
|
|
|
return error("%s: does not exist and --remove not passed", path);
|
|
|
|
if (remove_file_from_cache(path))
|
|
|
|
return error("%s: cannot remove from the index", path);
|
|
|
|
return 0;
|
|
|
|
}
|
2006-04-24 09:23:54 +02:00
|
|
|
|
2007-04-12 21:29:40 +02:00
|
|
|
/*
|
|
|
|
* Handle a path that couldn't be lstat'ed. It's either:
|
|
|
|
* - missing file (ENOENT or ENOTDIR). That's ok if we're
|
|
|
|
* supposed to be removing it and the removal actually
|
|
|
|
* succeeds.
|
|
|
|
* - permission error. That's never ok.
|
|
|
|
*/
|
|
|
|
static int process_lstat_error(const char *path, int err)
|
|
|
|
{
|
2017-05-30 02:23:33 +02:00
|
|
|
if (is_missing_file_error(err))
|
2007-04-12 21:29:40 +02:00
|
|
|
return remove_one_path(path);
|
2016-05-08 11:47:32 +02:00
|
|
|
return error("lstat(\"%s\"): %s", path, strerror(err));
|
2007-04-12 21:29:40 +02:00
|
|
|
}
|
2006-04-24 09:23:54 +02:00
|
|
|
|
Convert "struct cache_entry *" to "const ..." wherever possible
I attempted to make index_state->cache[] a "const struct cache_entry **"
to find out how existing entries in index are modified and where. The
question I have is what do we do if we really need to keep track of on-disk
changes in the index. The result is
- diff-lib.c: setting CE_UPTODATE
- name-hash.c: setting CE_HASHED
- preload-index.c, read-cache.c, unpack-trees.c and
builtin/update-index: obvious
- entry.c: write_entry() may refresh the checked out entry via
fill_stat_cache_info(). This causes "non-const struct cache_entry
*" in builtin/apply.c, builtin/checkout-index.c and
builtin/checkout.c
- builtin/ls-files.c: --with-tree changes stagemask and may set
CE_UPDATE
Of these, write_entry() and its call sites are probably most
interesting because it modifies on-disk info. But this is stat info
and can be retrieved via refresh, at least for porcelain
commands. Other just uses ce_flags for local purposes.
So, keeping track of "dirty" entries is just a matter of setting a
flag in index modification functions exposed by read-cache.c. Except
unpack-trees, the rest of the code base does not do anything funny
behind read-cache's back.
The actual patch is less valueable than the summary above. But if
anyone wants to re-identify the above sites. Applying this patch, then
this:
diff --git a/cache.h b/cache.h
index 430d021..1692891 100644
--- a/cache.h
+++ b/cache.h
@@ -267,7 +267,7 @@ static inline unsigned int canon_mode(unsigned int mode)
#define cache_entry_size(len) (offsetof(struct cache_entry,name) + (len) + 1)
struct index_state {
- struct cache_entry **cache;
+ const struct cache_entry **cache;
unsigned int version;
unsigned int cache_nr, cache_alloc, cache_changed;
struct string_list *resolve_undo;
will help quickly identify them without bogus warnings.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-09 17:29:00 +02:00
|
|
|
static int add_one_path(const struct cache_entry *old, const char *path, int len, struct stat *st)
|
2007-04-12 21:29:40 +02:00
|
|
|
{
|
2007-08-10 18:51:58 +02:00
|
|
|
int option, size;
|
|
|
|
struct cache_entry *ce;
|
2005-10-12 03:45:33 +02:00
|
|
|
|
2007-08-10 18:51:58 +02:00
|
|
|
/* Was the old index entry already up-to-date? */
|
|
|
|
if (old && !ce_stage(old) && !ce_match_stat(old, st, 0))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
size = cache_entry_size(len);
|
|
|
|
ce = xcalloc(1, size);
|
2007-04-12 21:29:40 +02:00
|
|
|
memcpy(ce->name, path, len);
|
2012-07-11 11:22:37 +02:00
|
|
|
ce->ce_flags = create_ce_flags(0);
|
|
|
|
ce->ce_namelen = len;
|
2007-04-12 21:29:40 +02:00
|
|
|
fill_stat_cache_info(ce, st);
|
|
|
|
ce->ce_mode = ce_mode_from_stat(old, st->st_mode);
|
2005-10-07 12:42:00 +02:00
|
|
|
|
2017-08-20 22:09:28 +02:00
|
|
|
if (index_path(&ce->oid, path, st,
|
2011-06-20 09:40:06 +02:00
|
|
|
info_only ? 0 : HASH_WRITE_OBJECT)) {
|
|
|
|
free(ce);
|
2005-10-07 12:42:00 +02:00
|
|
|
return -1;
|
2011-06-20 09:40:06 +02:00
|
|
|
}
|
2005-05-08 06:55:21 +02:00
|
|
|
option = allow_add ? ADD_CACHE_OK_TO_ADD : 0;
|
|
|
|
option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE : 0;
|
2017-09-05 15:04:14 +02:00
|
|
|
if (add_cache_entry(ce, option)) {
|
|
|
|
free(ce);
|
2007-04-12 21:29:40 +02:00
|
|
|
return error("%s: cannot add to the index - missing --add option?", path);
|
2017-09-05 15:04:14 +02:00
|
|
|
}
|
2005-09-18 21:09:22 +02:00
|
|
|
return 0;
|
2005-04-10 20:32:54 +02:00
|
|
|
}
|
|
|
|
|
2007-04-12 21:29:40 +02:00
|
|
|
/*
|
|
|
|
* Handle a path that was a directory. Four cases:
|
|
|
|
*
|
|
|
|
* - it's already a gitlink in the index, and we keep it that
|
|
|
|
* way, and update it if we can (if we cannot find the HEAD,
|
|
|
|
* we're going to keep it unchanged in the index!)
|
|
|
|
*
|
|
|
|
* - it's a *file* in the index, in which case it should be
|
|
|
|
* removed as a file if removal is allowed, since it doesn't
|
|
|
|
* exist as such any more. If removal isn't allowed, it's
|
|
|
|
* an error.
|
|
|
|
*
|
|
|
|
* (NOTE! This is old and arguably fairly strange behaviour.
|
|
|
|
* We might want to make this an error unconditionally, and
|
|
|
|
* use "--force-remove" if you actually want to force removal).
|
|
|
|
*
|
|
|
|
* - it used to exist as a subdirectory (ie multiple files with
|
|
|
|
* this particular prefix) in the index, in which case it's wrong
|
|
|
|
* to try to update it as a directory.
|
|
|
|
*
|
|
|
|
* - it doesn't exist at all in the index, but it is a valid
|
|
|
|
* git directory, and it should be *added* as a gitlink.
|
|
|
|
*/
|
|
|
|
static int process_directory(const char *path, int len, struct stat *st)
|
|
|
|
{
|
2016-09-05 22:08:06 +02:00
|
|
|
struct object_id oid;
|
2007-04-12 21:29:40 +02:00
|
|
|
int pos = cache_name_pos(path, len);
|
|
|
|
|
|
|
|
/* Exact match: file or existing gitlink */
|
|
|
|
if (pos >= 0) {
|
Convert "struct cache_entry *" to "const ..." wherever possible
I attempted to make index_state->cache[] a "const struct cache_entry **"
to find out how existing entries in index are modified and where. The
question I have is what do we do if we really need to keep track of on-disk
changes in the index. The result is
- diff-lib.c: setting CE_UPTODATE
- name-hash.c: setting CE_HASHED
- preload-index.c, read-cache.c, unpack-trees.c and
builtin/update-index: obvious
- entry.c: write_entry() may refresh the checked out entry via
fill_stat_cache_info(). This causes "non-const struct cache_entry
*" in builtin/apply.c, builtin/checkout-index.c and
builtin/checkout.c
- builtin/ls-files.c: --with-tree changes stagemask and may set
CE_UPDATE
Of these, write_entry() and its call sites are probably most
interesting because it modifies on-disk info. But this is stat info
and can be retrieved via refresh, at least for porcelain
commands. Other just uses ce_flags for local purposes.
So, keeping track of "dirty" entries is just a matter of setting a
flag in index modification functions exposed by read-cache.c. Except
unpack-trees, the rest of the code base does not do anything funny
behind read-cache's back.
The actual patch is less valueable than the summary above. But if
anyone wants to re-identify the above sites. Applying this patch, then
this:
diff --git a/cache.h b/cache.h
index 430d021..1692891 100644
--- a/cache.h
+++ b/cache.h
@@ -267,7 +267,7 @@ static inline unsigned int canon_mode(unsigned int mode)
#define cache_entry_size(len) (offsetof(struct cache_entry,name) + (len) + 1)
struct index_state {
- struct cache_entry **cache;
+ const struct cache_entry **cache;
unsigned int version;
unsigned int cache_nr, cache_alloc, cache_changed;
struct string_list *resolve_undo;
will help quickly identify them without bogus warnings.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-09 17:29:00 +02:00
|
|
|
const struct cache_entry *ce = active_cache[pos];
|
2008-01-15 01:03:17 +01:00
|
|
|
if (S_ISGITLINK(ce->ce_mode)) {
|
2007-04-12 21:29:40 +02:00
|
|
|
|
|
|
|
/* Do nothing to the index if there is no HEAD! */
|
refs: convert resolve_gitlink_ref to struct object_id
Convert the declaration and definition of resolve_gitlink_ref to use
struct object_id and apply the following semantic patch:
@@
expression E1, E2, E3;
@@
- resolve_gitlink_ref(E1, E2, E3.hash)
+ resolve_gitlink_ref(E1, E2, &E3)
@@
expression E1, E2, E3;
@@
- resolve_gitlink_ref(E1, E2, E3->hash)
+ resolve_gitlink_ref(E1, E2, E3)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-10-16 00:07:07 +02:00
|
|
|
if (resolve_gitlink_ref(path, "HEAD", &oid) < 0)
|
2007-04-12 21:29:40 +02:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
return add_one_path(ce, path, len, st);
|
|
|
|
}
|
|
|
|
/* Should this be an unconditional error? */
|
|
|
|
return remove_one_path(path);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Inexact match: is there perhaps a subdirectory match? */
|
|
|
|
pos = -pos-1;
|
|
|
|
while (pos < active_nr) {
|
Convert "struct cache_entry *" to "const ..." wherever possible
I attempted to make index_state->cache[] a "const struct cache_entry **"
to find out how existing entries in index are modified and where. The
question I have is what do we do if we really need to keep track of on-disk
changes in the index. The result is
- diff-lib.c: setting CE_UPTODATE
- name-hash.c: setting CE_HASHED
- preload-index.c, read-cache.c, unpack-trees.c and
builtin/update-index: obvious
- entry.c: write_entry() may refresh the checked out entry via
fill_stat_cache_info(). This causes "non-const struct cache_entry
*" in builtin/apply.c, builtin/checkout-index.c and
builtin/checkout.c
- builtin/ls-files.c: --with-tree changes stagemask and may set
CE_UPDATE
Of these, write_entry() and its call sites are probably most
interesting because it modifies on-disk info. But this is stat info
and can be retrieved via refresh, at least for porcelain
commands. Other just uses ce_flags for local purposes.
So, keeping track of "dirty" entries is just a matter of setting a
flag in index modification functions exposed by read-cache.c. Except
unpack-trees, the rest of the code base does not do anything funny
behind read-cache's back.
The actual patch is less valueable than the summary above. But if
anyone wants to re-identify the above sites. Applying this patch, then
this:
diff --git a/cache.h b/cache.h
index 430d021..1692891 100644
--- a/cache.h
+++ b/cache.h
@@ -267,7 +267,7 @@ static inline unsigned int canon_mode(unsigned int mode)
#define cache_entry_size(len) (offsetof(struct cache_entry,name) + (len) + 1)
struct index_state {
- struct cache_entry **cache;
+ const struct cache_entry **cache;
unsigned int version;
unsigned int cache_nr, cache_alloc, cache_changed;
struct string_list *resolve_undo;
will help quickly identify them without bogus warnings.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-09 17:29:00 +02:00
|
|
|
const struct cache_entry *ce = active_cache[pos++];
|
2007-04-12 21:29:40 +02:00
|
|
|
|
|
|
|
if (strncmp(ce->name, path, len))
|
|
|
|
break;
|
|
|
|
if (ce->name[len] > '/')
|
|
|
|
break;
|
|
|
|
if (ce->name[len] < '/')
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Subdirectory match - error out */
|
|
|
|
return error("%s: is a directory - add individual files instead", path);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* No match - should we add it as a gitlink? */
|
refs: convert resolve_gitlink_ref to struct object_id
Convert the declaration and definition of resolve_gitlink_ref to use
struct object_id and apply the following semantic patch:
@@
expression E1, E2, E3;
@@
- resolve_gitlink_ref(E1, E2, E3.hash)
+ resolve_gitlink_ref(E1, E2, &E3)
@@
expression E1, E2, E3;
@@
- resolve_gitlink_ref(E1, E2, E3->hash)
+ resolve_gitlink_ref(E1, E2, E3)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-10-16 00:07:07 +02:00
|
|
|
if (!resolve_gitlink_ref(path, "HEAD", &oid))
|
2007-04-12 21:29:40 +02:00
|
|
|
return add_one_path(NULL, path, len, st);
|
|
|
|
|
|
|
|
/* Error out. */
|
|
|
|
return error("%s: is a directory - add files inside instead", path);
|
|
|
|
}
|
|
|
|
|
2018-05-14 17:00:56 +02:00
|
|
|
static int process_path(const char *path, struct stat *st, int stat_errno)
|
2007-04-12 21:29:40 +02:00
|
|
|
{
|
2009-08-20 15:46:58 +02:00
|
|
|
int pos, len;
|
Convert "struct cache_entry *" to "const ..." wherever possible
I attempted to make index_state->cache[] a "const struct cache_entry **"
to find out how existing entries in index are modified and where. The
question I have is what do we do if we really need to keep track of on-disk
changes in the index. The result is
- diff-lib.c: setting CE_UPTODATE
- name-hash.c: setting CE_HASHED
- preload-index.c, read-cache.c, unpack-trees.c and
builtin/update-index: obvious
- entry.c: write_entry() may refresh the checked out entry via
fill_stat_cache_info(). This causes "non-const struct cache_entry
*" in builtin/apply.c, builtin/checkout-index.c and
builtin/checkout.c
- builtin/ls-files.c: --with-tree changes stagemask and may set
CE_UPDATE
Of these, write_entry() and its call sites are probably most
interesting because it modifies on-disk info. But this is stat info
and can be retrieved via refresh, at least for porcelain
commands. Other just uses ce_flags for local purposes.
So, keeping track of "dirty" entries is just a matter of setting a
flag in index modification functions exposed by read-cache.c. Except
unpack-trees, the rest of the code base does not do anything funny
behind read-cache's back.
The actual patch is less valueable than the summary above. But if
anyone wants to re-identify the above sites. Applying this patch, then
this:
diff --git a/cache.h b/cache.h
index 430d021..1692891 100644
--- a/cache.h
+++ b/cache.h
@@ -267,7 +267,7 @@ static inline unsigned int canon_mode(unsigned int mode)
#define cache_entry_size(len) (offsetof(struct cache_entry,name) + (len) + 1)
struct index_state {
- struct cache_entry **cache;
+ const struct cache_entry **cache;
unsigned int version;
unsigned int cache_nr, cache_alloc, cache_changed;
struct string_list *resolve_undo;
will help quickly identify them without bogus warnings.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-09 17:29:00 +02:00
|
|
|
const struct cache_entry *ce;
|
2007-04-12 21:29:40 +02:00
|
|
|
|
2008-08-04 09:51:42 +02:00
|
|
|
len = strlen(path);
|
2009-02-09 21:54:06 +01:00
|
|
|
if (has_symlink_leading_path(path, len))
|
2008-08-04 09:51:42 +02:00
|
|
|
return error("'%s' is beyond a symbolic link", path);
|
|
|
|
|
2009-08-20 15:46:58 +02:00
|
|
|
pos = cache_name_pos(path, len);
|
|
|
|
ce = pos < 0 ? NULL : active_cache[pos];
|
|
|
|
if (ce && ce_skip_worktree(ce)) {
|
|
|
|
/*
|
|
|
|
* working directory version is assumed "good"
|
|
|
|
* so updating it does not make sense.
|
|
|
|
* On the other hand, removing it from index should work
|
|
|
|
*/
|
|
|
|
if (allow_remove && remove_file_from_cache(path))
|
|
|
|
return error("%s: cannot remove from the index", path);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-04-12 21:29:40 +02:00
|
|
|
/*
|
|
|
|
* First things first: get the stat information, to decide
|
|
|
|
* what to do about the pathname!
|
|
|
|
*/
|
2018-05-14 17:00:56 +02:00
|
|
|
if (stat_errno)
|
|
|
|
return process_lstat_error(path, stat_errno);
|
2007-04-12 21:29:40 +02:00
|
|
|
|
2018-05-14 17:00:56 +02:00
|
|
|
if (S_ISDIR(st->st_mode))
|
|
|
|
return process_directory(path, len, st);
|
2007-04-12 21:29:40 +02:00
|
|
|
|
2018-05-14 17:00:56 +02:00
|
|
|
return add_one_path(ce, path, len, st);
|
2007-04-12 21:29:40 +02:00
|
|
|
}
|
|
|
|
|
2016-09-05 22:08:06 +02:00
|
|
|
static int add_cacheinfo(unsigned int mode, const struct object_id *oid,
|
2005-12-07 10:45:38 +01:00
|
|
|
const char *path, int stage)
|
2005-04-15 20:08:33 +02:00
|
|
|
{
|
2005-05-08 06:55:21 +02:00
|
|
|
int size, len, option;
|
2005-04-15 20:08:33 +02:00
|
|
|
struct cache_entry *ce;
|
|
|
|
|
verify_path: disallow symlinks in .gitmodules
There are a few reasons it's not a good idea to make
.gitmodules a symlink, including:
1. It won't be portable to systems without symlinks.
2. It may behave inconsistently, since Git may look at
this file in the index or a tree without bothering to
resolve any symbolic links. We don't do this _yet_, but
the config infrastructure is there and it's planned for
the future.
With some clever code, we could make (2) work. And some
people may not care about (1) if they only work on one
platform. But there are a few security reasons to simply
disallow it:
a. A symlinked .gitmodules file may circumvent any fsck
checks of the content.
b. Git may read and write from the on-disk file without
sanity checking the symlink target. So for example, if
you link ".gitmodules" to "../oops" and run "git
submodule add", we'll write to the file "oops" outside
the repository.
Again, both of those are problems that _could_ be solved
with sufficient code, but given the complications in (1) and
(2), we're better off just outlawing it explicitly.
Note the slightly tricky call to verify_path() in
update-index's update_one(). There we may not have a mode if
we're not updating from the filesystem (e.g., we might just
be removing the file). Passing "0" as the mode there works
fine; since it's not a symlink, we'll just skip the extra
checks.
Signed-off-by: Jeff King <peff@peff.net>
2018-05-05 02:03:35 +02:00
|
|
|
if (!verify_path(path, mode))
|
2008-10-11 18:39:37 +02:00
|
|
|
return error("Invalid path '%s'", path);
|
2005-04-15 20:08:33 +02:00
|
|
|
|
2005-12-07 10:45:38 +01:00
|
|
|
len = strlen(path);
|
2005-04-15 20:08:33 +02:00
|
|
|
size = cache_entry_size(len);
|
2006-04-03 20:30:46 +02:00
|
|
|
ce = xcalloc(1, size);
|
2005-04-15 20:08:33 +02:00
|
|
|
|
2016-09-05 22:08:06 +02:00
|
|
|
oidcpy(&ce->oid, oid);
|
2005-12-07 10:45:38 +01:00
|
|
|
memcpy(ce->name, path, len);
|
2012-07-11 11:22:37 +02:00
|
|
|
ce->ce_flags = create_ce_flags(stage);
|
|
|
|
ce->ce_namelen = len;
|
2005-04-17 07:26:31 +02:00
|
|
|
ce->ce_mode = create_ce_mode(mode);
|
2006-02-09 06:15:24 +01:00
|
|
|
if (assume_unchanged)
|
2008-01-15 01:03:17 +01:00
|
|
|
ce->ce_flags |= CE_VALID;
|
2005-05-08 06:55:21 +02:00
|
|
|
option = allow_add ? ADD_CACHE_OK_TO_ADD : 0;
|
|
|
|
option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE : 0;
|
2005-10-15 06:56:46 +02:00
|
|
|
if (add_cache_entry(ce, option))
|
|
|
|
return error("%s: cannot add to the index - missing --add option?",
|
2005-12-07 10:45:38 +01:00
|
|
|
path);
|
|
|
|
report("add '%s'", path);
|
2005-10-15 06:56:46 +02:00
|
|
|
return 0;
|
2005-04-15 20:08:33 +02:00
|
|
|
}
|
|
|
|
|
2016-09-14 23:07:45 +02:00
|
|
|
static void chmod_path(char flip, const char *path)
|
2005-10-12 03:45:33 +02:00
|
|
|
{
|
|
|
|
int pos;
|
|
|
|
struct cache_entry *ce;
|
2005-04-26 20:55:42 +02:00
|
|
|
|
2005-10-12 03:45:33 +02:00
|
|
|
pos = cache_name_pos(path, strlen(path));
|
|
|
|
if (pos < 0)
|
2006-04-23 09:01:29 +02:00
|
|
|
goto fail;
|
2005-10-12 03:45:33 +02:00
|
|
|
ce = active_cache[pos];
|
2016-09-14 23:07:46 +02:00
|
|
|
if (chmod_cache_entry(ce, flip) < 0)
|
2006-04-23 09:01:29 +02:00
|
|
|
goto fail;
|
2016-09-14 23:07:46 +02:00
|
|
|
|
2006-04-23 09:01:29 +02:00
|
|
|
report("chmod %cx '%s'", flip, path);
|
|
|
|
return;
|
|
|
|
fail:
|
2008-08-31 18:39:19 +02:00
|
|
|
die("git update-index: cannot chmod %cx '%s'", flip, path);
|
2005-10-12 03:45:33 +02:00
|
|
|
}
|
|
|
|
|
2013-11-14 20:24:08 +01:00
|
|
|
static void update_one(const char *path)
|
2005-09-27 03:13:08 +02:00
|
|
|
{
|
2018-05-14 17:00:56 +02:00
|
|
|
int stat_errno = 0;
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
if (mark_valid_only || mark_skip_worktree_only || force_remove)
|
|
|
|
st.st_mode = 0;
|
|
|
|
else if (lstat(path, &st) < 0) {
|
|
|
|
st.st_mode = 0;
|
|
|
|
stat_errno = errno;
|
|
|
|
} /* else stat is valid */
|
|
|
|
|
verify_path: disallow symlinks in .gitmodules
There are a few reasons it's not a good idea to make
.gitmodules a symlink, including:
1. It won't be portable to systems without symlinks.
2. It may behave inconsistently, since Git may look at
this file in the index or a tree without bothering to
resolve any symbolic links. We don't do this _yet_, but
the config infrastructure is there and it's planned for
the future.
With some clever code, we could make (2) work. And some
people may not care about (1) if they only work on one
platform. But there are a few security reasons to simply
disallow it:
a. A symlinked .gitmodules file may circumvent any fsck
checks of the content.
b. Git may read and write from the on-disk file without
sanity checking the symlink target. So for example, if
you link ".gitmodules" to "../oops" and run "git
submodule add", we'll write to the file "oops" outside
the repository.
Again, both of those are problems that _could_ be solved
with sufficient code, but given the complications in (1) and
(2), we're better off just outlawing it explicitly.
Note the slightly tricky call to verify_path() in
update-index's update_one(). There we may not have a mode if
we're not updating from the filesystem (e.g., we might just
be removing the file). Passing "0" as the mode there works
fine; since it's not a symlink, we'll just skip the extra
checks.
Signed-off-by: Jeff King <peff@peff.net>
2018-05-05 02:03:35 +02:00
|
|
|
if (!verify_path(path, st.st_mode)) {
|
2005-09-27 03:13:08 +02:00
|
|
|
fprintf(stderr, "Ignoring path %s\n", path);
|
2013-11-14 20:24:08 +01:00
|
|
|
return;
|
2005-09-27 03:13:08 +02:00
|
|
|
}
|
2006-02-09 06:15:24 +01:00
|
|
|
if (mark_valid_only) {
|
2013-11-14 20:24:08 +01:00
|
|
|
if (mark_ce_flags(path, CE_VALID, mark_valid_only == MARK_FLAG))
|
2006-02-09 06:15:24 +01:00
|
|
|
die("Unable to mark file %s", path);
|
2013-11-14 20:24:08 +01:00
|
|
|
return;
|
2006-02-09 06:15:24 +01:00
|
|
|
}
|
2009-08-20 15:46:57 +02:00
|
|
|
if (mark_skip_worktree_only) {
|
2013-11-14 20:24:08 +01:00
|
|
|
if (mark_ce_flags(path, CE_SKIP_WORKTREE, mark_skip_worktree_only == MARK_FLAG))
|
2006-02-09 06:15:24 +01:00
|
|
|
die("Unable to mark file %s", path);
|
2013-11-14 20:24:08 +01:00
|
|
|
return;
|
2006-02-09 06:15:24 +01:00
|
|
|
}
|
2017-09-22 18:35:43 +02:00
|
|
|
if (mark_fsmonitor_only) {
|
|
|
|
if (mark_ce_flags(path, CE_FSMONITOR_VALID, mark_fsmonitor_only == MARK_FLAG))
|
|
|
|
die("Unable to mark file %s", path);
|
|
|
|
return;
|
|
|
|
}
|
2006-02-09 06:15:24 +01:00
|
|
|
|
2005-09-27 03:13:08 +02:00
|
|
|
if (force_remove) {
|
2013-11-14 20:24:08 +01:00
|
|
|
if (remove_file_from_cache(path))
|
2008-08-31 18:39:19 +02:00
|
|
|
die("git update-index: unable to remove %s", path);
|
2005-10-15 06:56:46 +02:00
|
|
|
report("remove '%s'", path);
|
2013-11-14 20:24:08 +01:00
|
|
|
return;
|
2005-09-27 03:13:08 +02:00
|
|
|
}
|
2018-05-14 17:00:56 +02:00
|
|
|
if (process_path(path, &st, stat_errno))
|
2007-04-12 21:29:40 +02:00
|
|
|
die("Unable to process path %s", path);
|
2005-10-15 06:56:46 +02:00
|
|
|
report("add '%s'", path);
|
2005-09-27 03:13:08 +02:00
|
|
|
}
|
|
|
|
|
2016-01-14 22:34:29 +01:00
|
|
|
static void read_index_info(int nul_term_line)
|
2005-10-07 12:42:00 +02:00
|
|
|
{
|
2008-10-09 21:12:12 +02:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
struct strbuf uq = STRBUF_INIT;
|
2016-01-14 22:34:29 +01:00
|
|
|
strbuf_getline_fn getline_fn;
|
2007-09-20 00:42:14 +02:00
|
|
|
|
2016-01-14 22:34:29 +01:00
|
|
|
getline_fn = nul_term_line ? strbuf_getline_nul : strbuf_getline_lf;
|
|
|
|
while (getline_fn(&buf, stdin) != EOF) {
|
2005-11-22 06:46:57 +01:00
|
|
|
char *ptr, *tab;
|
2005-10-16 09:39:07 +02:00
|
|
|
char *path_name;
|
2016-09-05 22:08:06 +02:00
|
|
|
struct object_id oid;
|
2005-10-07 12:42:00 +02:00
|
|
|
unsigned int mode;
|
2007-04-10 01:01:44 +02:00
|
|
|
unsigned long ul;
|
2005-12-07 10:45:38 +01:00
|
|
|
int stage;
|
|
|
|
|
|
|
|
/* This reads lines formatted in one of three formats:
|
|
|
|
*
|
|
|
|
* (1) mode SP sha1 TAB path
|
2008-09-13 19:18:36 +02:00
|
|
|
* The first format is what "git apply --index-info"
|
2005-12-07 10:45:38 +01:00
|
|
|
* reports, and used to reconstruct a partial tree
|
|
|
|
* that is used for phony merge base tree when falling
|
|
|
|
* back on 3-way merge.
|
|
|
|
*
|
|
|
|
* (2) mode SP type SP sha1 TAB path
|
2008-09-13 19:18:36 +02:00
|
|
|
* The second format is to stuff "git ls-tree" output
|
2005-12-07 10:45:38 +01:00
|
|
|
* into the index file.
|
2006-06-13 22:21:57 +02:00
|
|
|
*
|
2005-12-07 10:45:38 +01:00
|
|
|
* (3) mode SP sha1 SP stage TAB path
|
|
|
|
* This format is to put higher order stages into the
|
2008-09-13 19:18:36 +02:00
|
|
|
* index file and matches "git ls-files --stage" output.
|
2005-12-07 10:45:38 +01:00
|
|
|
*/
|
2007-04-10 01:01:44 +02:00
|
|
|
errno = 0;
|
|
|
|
ul = strtoul(buf.buf, &ptr, 8);
|
|
|
|
if (ptr == buf.buf || *ptr != ' '
|
|
|
|
|| errno || (unsigned int) ul != ul)
|
2005-10-07 12:42:00 +02:00
|
|
|
goto bad_line;
|
2007-04-10 01:01:44 +02:00
|
|
|
mode = ul;
|
2005-10-07 12:42:00 +02:00
|
|
|
|
2005-11-22 06:46:57 +01:00
|
|
|
tab = strchr(ptr, '\t');
|
2016-09-05 22:08:06 +02:00
|
|
|
if (!tab || tab - ptr < GIT_SHA1_HEXSZ + 1)
|
2005-11-22 06:46:57 +01:00
|
|
|
goto bad_line;
|
2005-12-07 10:45:38 +01:00
|
|
|
|
2006-02-01 03:03:37 +01:00
|
|
|
if (tab[-2] == ' ' && '0' <= tab[-1] && tab[-1] <= '3') {
|
2005-12-07 10:45:38 +01:00
|
|
|
stage = tab[-1] - '0';
|
|
|
|
ptr = tab + 1; /* point at the head of path */
|
|
|
|
tab = tab - 2; /* point at tail of sha1 */
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
stage = 0;
|
|
|
|
ptr = tab + 1; /* point at the head of path */
|
|
|
|
}
|
|
|
|
|
2016-09-05 22:08:06 +02:00
|
|
|
if (get_oid_hex(tab - GIT_SHA1_HEXSZ, &oid) ||
|
|
|
|
tab[-(GIT_SHA1_HEXSZ + 1)] != ' ')
|
2005-11-22 06:46:57 +01:00
|
|
|
goto bad_line;
|
2005-10-16 09:39:07 +02:00
|
|
|
|
2007-09-20 00:42:14 +02:00
|
|
|
path_name = ptr;
|
2016-01-14 22:34:29 +01:00
|
|
|
if (!nul_term_line && path_name[0] == '"') {
|
2007-09-20 00:42:14 +02:00
|
|
|
strbuf_reset(&uq);
|
|
|
|
if (unquote_c_style(&uq, path_name, NULL)) {
|
2008-08-31 18:39:19 +02:00
|
|
|
die("git update-index: bad quoting of path name");
|
2007-09-20 00:42:14 +02:00
|
|
|
}
|
|
|
|
path_name = uq.buf;
|
|
|
|
}
|
2005-10-16 09:39:07 +02:00
|
|
|
|
verify_path: disallow symlinks in .gitmodules
There are a few reasons it's not a good idea to make
.gitmodules a symlink, including:
1. It won't be portable to systems without symlinks.
2. It may behave inconsistently, since Git may look at
this file in the index or a tree without bothering to
resolve any symbolic links. We don't do this _yet_, but
the config infrastructure is there and it's planned for
the future.
With some clever code, we could make (2) work. And some
people may not care about (1) if they only work on one
platform. But there are a few security reasons to simply
disallow it:
a. A symlinked .gitmodules file may circumvent any fsck
checks of the content.
b. Git may read and write from the on-disk file without
sanity checking the symlink target. So for example, if
you link ".gitmodules" to "../oops" and run "git
submodule add", we'll write to the file "oops" outside
the repository.
Again, both of those are problems that _could_ be solved
with sufficient code, but given the complications in (1) and
(2), we're better off just outlawing it explicitly.
Note the slightly tricky call to verify_path() in
update-index's update_one(). There we may not have a mode if
we're not updating from the filesystem (e.g., we might just
be removing the file). Passing "0" as the mode there works
fine; since it's not a symlink, we'll just skip the extra
checks.
Signed-off-by: Jeff King <peff@peff.net>
2018-05-05 02:03:35 +02:00
|
|
|
if (!verify_path(path_name, mode)) {
|
2005-10-16 09:39:07 +02:00
|
|
|
fprintf(stderr, "Ignoring path %s\n", path_name);
|
2005-10-07 12:42:00 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!mode) {
|
|
|
|
/* mode == 0 means there is no such path -- remove */
|
2005-10-16 09:39:07 +02:00
|
|
|
if (remove_file_from_cache(path_name))
|
2008-08-31 18:39:19 +02:00
|
|
|
die("git update-index: unable to remove %s",
|
2005-10-07 12:42:00 +02:00
|
|
|
ptr);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* mode ' ' sha1 '\t' name
|
|
|
|
* ptr[-1] points at tab,
|
|
|
|
* ptr[-41] is at the beginning of sha1
|
|
|
|
*/
|
2016-09-05 22:08:06 +02:00
|
|
|
ptr[-(GIT_SHA1_HEXSZ + 2)] = ptr[-1] = 0;
|
|
|
|
if (add_cacheinfo(mode, &oid, path_name, stage))
|
2008-08-31 18:39:19 +02:00
|
|
|
die("git update-index: unable to update %s",
|
2005-10-16 09:39:07 +02:00
|
|
|
path_name);
|
2005-10-07 12:42:00 +02:00
|
|
|
}
|
|
|
|
continue;
|
|
|
|
|
|
|
|
bad_line:
|
|
|
|
die("malformed index info %s", buf.buf);
|
|
|
|
}
|
2007-09-17 11:19:04 +02:00
|
|
|
strbuf_release(&buf);
|
2007-09-20 00:42:14 +02:00
|
|
|
strbuf_release(&uq);
|
2005-10-07 12:42:00 +02:00
|
|
|
}
|
|
|
|
|
2010-12-02 00:34:06 +01:00
|
|
|
static const char * const update_index_usage[] = {
|
2015-01-13 08:44:47 +01:00
|
|
|
N_("git update-index [<options>] [--] [<file>...]"),
|
2010-12-02 00:34:06 +01:00
|
|
|
NULL
|
|
|
|
};
|
2005-10-25 17:26:25 +02:00
|
|
|
|
2016-09-05 22:08:06 +02:00
|
|
|
static struct object_id head_oid;
|
|
|
|
static struct object_id merge_head_oid;
|
2006-04-20 08:52:05 +02:00
|
|
|
|
|
|
|
static struct cache_entry *read_one_ent(const char *which,
|
2016-09-05 22:08:06 +02:00
|
|
|
struct object_id *ent, const char *path,
|
2006-04-20 08:52:05 +02:00
|
|
|
int namelen, int stage)
|
|
|
|
{
|
|
|
|
unsigned mode;
|
2016-09-05 22:08:06 +02:00
|
|
|
struct object_id oid;
|
2006-04-20 08:52:05 +02:00
|
|
|
int size;
|
|
|
|
struct cache_entry *ce;
|
|
|
|
|
2016-09-05 22:08:06 +02:00
|
|
|
if (get_tree_entry(ent->hash, path, oid.hash, &mode)) {
|
2006-05-06 02:40:47 +02:00
|
|
|
if (which)
|
|
|
|
error("%s: not in %s branch.", path, which);
|
2006-04-20 08:52:05 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (mode == S_IFDIR) {
|
2006-05-06 02:40:47 +02:00
|
|
|
if (which)
|
|
|
|
error("%s: not a blob in %s branch.", path, which);
|
2006-04-20 08:52:05 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
size = cache_entry_size(namelen);
|
|
|
|
ce = xcalloc(1, size);
|
|
|
|
|
2016-09-05 22:08:06 +02:00
|
|
|
oidcpy(&ce->oid, &oid);
|
2006-04-20 08:52:05 +02:00
|
|
|
memcpy(ce->name, path, namelen);
|
2012-07-11 11:22:37 +02:00
|
|
|
ce->ce_flags = create_ce_flags(stage);
|
|
|
|
ce->ce_namelen = namelen;
|
2006-04-20 08:52:05 +02:00
|
|
|
ce->ce_mode = create_ce_mode(mode);
|
|
|
|
return ce;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int unresolve_one(const char *path)
|
|
|
|
{
|
|
|
|
int namelen = strlen(path);
|
|
|
|
int pos;
|
|
|
|
int ret = 0;
|
|
|
|
struct cache_entry *ce_2 = NULL, *ce_3 = NULL;
|
|
|
|
|
|
|
|
/* See if there is such entry in the index. */
|
|
|
|
pos = cache_name_pos(path, namelen);
|
2009-12-25 22:40:02 +01:00
|
|
|
if (0 <= pos) {
|
|
|
|
/* already merged */
|
|
|
|
pos = unmerge_cache_entry_at(pos);
|
|
|
|
if (pos < active_nr) {
|
Convert "struct cache_entry *" to "const ..." wherever possible
I attempted to make index_state->cache[] a "const struct cache_entry **"
to find out how existing entries in index are modified and where. The
question I have is what do we do if we really need to keep track of on-disk
changes in the index. The result is
- diff-lib.c: setting CE_UPTODATE
- name-hash.c: setting CE_HASHED
- preload-index.c, read-cache.c, unpack-trees.c and
builtin/update-index: obvious
- entry.c: write_entry() may refresh the checked out entry via
fill_stat_cache_info(). This causes "non-const struct cache_entry
*" in builtin/apply.c, builtin/checkout-index.c and
builtin/checkout.c
- builtin/ls-files.c: --with-tree changes stagemask and may set
CE_UPDATE
Of these, write_entry() and its call sites are probably most
interesting because it modifies on-disk info. But this is stat info
and can be retrieved via refresh, at least for porcelain
commands. Other just uses ce_flags for local purposes.
So, keeping track of "dirty" entries is just a matter of setting a
flag in index modification functions exposed by read-cache.c. Except
unpack-trees, the rest of the code base does not do anything funny
behind read-cache's back.
The actual patch is less valueable than the summary above. But if
anyone wants to re-identify the above sites. Applying this patch, then
this:
diff --git a/cache.h b/cache.h
index 430d021..1692891 100644
--- a/cache.h
+++ b/cache.h
@@ -267,7 +267,7 @@ static inline unsigned int canon_mode(unsigned int mode)
#define cache_entry_size(len) (offsetof(struct cache_entry,name) + (len) + 1)
struct index_state {
- struct cache_entry **cache;
+ const struct cache_entry **cache;
unsigned int version;
unsigned int cache_nr, cache_alloc, cache_changed;
struct string_list *resolve_undo;
will help quickly identify them without bogus warnings.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-09 17:29:00 +02:00
|
|
|
const struct cache_entry *ce = active_cache[pos];
|
2009-12-25 22:40:02 +01:00
|
|
|
if (ce_stage(ce) &&
|
|
|
|
ce_namelen(ce) == namelen &&
|
|
|
|
!memcmp(ce->name, path, namelen))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/* no resolve-undo information; fall back */
|
|
|
|
} else {
|
2006-04-20 08:52:05 +02:00
|
|
|
/* If there isn't, either it is unmerged, or
|
|
|
|
* resolved as "removed" by mistake. We do not
|
|
|
|
* want to do anything in the former case.
|
|
|
|
*/
|
|
|
|
pos = -pos-1;
|
|
|
|
if (pos < active_nr) {
|
Convert "struct cache_entry *" to "const ..." wherever possible
I attempted to make index_state->cache[] a "const struct cache_entry **"
to find out how existing entries in index are modified and where. The
question I have is what do we do if we really need to keep track of on-disk
changes in the index. The result is
- diff-lib.c: setting CE_UPTODATE
- name-hash.c: setting CE_HASHED
- preload-index.c, read-cache.c, unpack-trees.c and
builtin/update-index: obvious
- entry.c: write_entry() may refresh the checked out entry via
fill_stat_cache_info(). This causes "non-const struct cache_entry
*" in builtin/apply.c, builtin/checkout-index.c and
builtin/checkout.c
- builtin/ls-files.c: --with-tree changes stagemask and may set
CE_UPDATE
Of these, write_entry() and its call sites are probably most
interesting because it modifies on-disk info. But this is stat info
and can be retrieved via refresh, at least for porcelain
commands. Other just uses ce_flags for local purposes.
So, keeping track of "dirty" entries is just a matter of setting a
flag in index modification functions exposed by read-cache.c. Except
unpack-trees, the rest of the code base does not do anything funny
behind read-cache's back.
The actual patch is less valueable than the summary above. But if
anyone wants to re-identify the above sites. Applying this patch, then
this:
diff --git a/cache.h b/cache.h
index 430d021..1692891 100644
--- a/cache.h
+++ b/cache.h
@@ -267,7 +267,7 @@ static inline unsigned int canon_mode(unsigned int mode)
#define cache_entry_size(len) (offsetof(struct cache_entry,name) + (len) + 1)
struct index_state {
- struct cache_entry **cache;
+ const struct cache_entry **cache;
unsigned int version;
unsigned int cache_nr, cache_alloc, cache_changed;
struct string_list *resolve_undo;
will help quickly identify them without bogus warnings.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-09 17:29:00 +02:00
|
|
|
const struct cache_entry *ce = active_cache[pos];
|
2006-04-20 08:52:05 +02:00
|
|
|
if (ce_namelen(ce) == namelen &&
|
|
|
|
!memcmp(ce->name, path, namelen)) {
|
|
|
|
fprintf(stderr,
|
|
|
|
"%s: skipping still unmerged path.\n",
|
|
|
|
path);
|
|
|
|
goto free_return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Grab blobs from given path from HEAD and MERGE_HEAD,
|
|
|
|
* stuff HEAD version in stage #2,
|
|
|
|
* stuff MERGE_HEAD version in stage #3.
|
|
|
|
*/
|
2016-09-05 22:08:06 +02:00
|
|
|
ce_2 = read_one_ent("our", &head_oid, path, namelen, 2);
|
|
|
|
ce_3 = read_one_ent("their", &merge_head_oid, path, namelen, 3);
|
2006-04-20 08:52:05 +02:00
|
|
|
|
|
|
|
if (!ce_2 || !ce_3) {
|
|
|
|
ret = -1;
|
|
|
|
goto free_return;
|
|
|
|
}
|
2016-09-05 22:07:52 +02:00
|
|
|
if (!oidcmp(&ce_2->oid, &ce_3->oid) &&
|
2006-04-20 08:52:05 +02:00
|
|
|
ce_2->ce_mode == ce_3->ce_mode) {
|
|
|
|
fprintf(stderr, "%s: identical in both, skipping.\n",
|
|
|
|
path);
|
|
|
|
goto free_return;
|
|
|
|
}
|
|
|
|
|
|
|
|
remove_file_from_cache(path);
|
|
|
|
if (add_cache_entry(ce_2, ADD_CACHE_OK_TO_ADD)) {
|
|
|
|
error("%s: cannot add our version to the index.", path);
|
|
|
|
ret = -1;
|
|
|
|
goto free_return;
|
|
|
|
}
|
|
|
|
if (!add_cache_entry(ce_3, ADD_CACHE_OK_TO_ADD))
|
|
|
|
return 0;
|
|
|
|
error("%s: cannot add their version to the index.", path);
|
|
|
|
ret = -1;
|
|
|
|
free_return:
|
|
|
|
free(ce_2);
|
|
|
|
free(ce_3);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void read_head_pointers(void)
|
|
|
|
{
|
2017-10-16 00:06:56 +02:00
|
|
|
if (read_ref("HEAD", &head_oid))
|
2009-01-04 19:38:41 +01:00
|
|
|
die("No HEAD -- no initial commit yet?");
|
2017-10-16 00:06:56 +02:00
|
|
|
if (read_ref("MERGE_HEAD", &merge_head_oid)) {
|
2006-04-20 08:52:05 +02:00
|
|
|
fprintf(stderr, "Not in the middle of a merge.\n");
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-05-06 02:50:06 +02:00
|
|
|
static int do_unresolve(int ac, const char **av,
|
|
|
|
const char *prefix, int prefix_length)
|
2006-04-20 08:52:05 +02:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
/* Read HEAD and MERGE_HEAD; if MERGE_HEAD does not exist, we
|
|
|
|
* are not doing a merge, so exit with success status.
|
|
|
|
*/
|
|
|
|
read_head_pointers();
|
|
|
|
|
|
|
|
for (i = 1; i < ac; i++) {
|
|
|
|
const char *arg = av[i];
|
2015-05-04 21:11:54 +02:00
|
|
|
char *p = prefix_path(prefix, prefix_length, arg);
|
2006-05-06 02:50:06 +02:00
|
|
|
err |= unresolve_one(p);
|
2015-05-04 21:11:54 +02:00
|
|
|
free(p);
|
2006-04-20 08:52:05 +02:00
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2006-05-06 02:40:47 +02:00
|
|
|
static int do_reupdate(int ac, const char **av,
|
|
|
|
const char *prefix, int prefix_length)
|
|
|
|
{
|
|
|
|
/* Read HEAD and run update-index on paths that are
|
|
|
|
* merged and already different between index and HEAD.
|
|
|
|
*/
|
|
|
|
int pos;
|
|
|
|
int has_head = 1;
|
2010-12-17 13:43:07 +01:00
|
|
|
struct pathspec pathspec;
|
|
|
|
|
2013-07-14 10:35:31 +02:00
|
|
|
parse_pathspec(&pathspec, 0,
|
|
|
|
PATHSPEC_PREFER_CWD,
|
|
|
|
prefix, av + 1);
|
2006-05-06 02:40:47 +02:00
|
|
|
|
2017-10-16 00:06:56 +02:00
|
|
|
if (read_ref("HEAD", &head_oid))
|
2006-05-06 02:40:47 +02:00
|
|
|
/* If there is no HEAD, that means it is an initial
|
|
|
|
* commit. Update everything in the index.
|
|
|
|
*/
|
|
|
|
has_head = 0;
|
|
|
|
redo:
|
|
|
|
for (pos = 0; pos < active_nr; pos++) {
|
Convert "struct cache_entry *" to "const ..." wherever possible
I attempted to make index_state->cache[] a "const struct cache_entry **"
to find out how existing entries in index are modified and where. The
question I have is what do we do if we really need to keep track of on-disk
changes in the index. The result is
- diff-lib.c: setting CE_UPTODATE
- name-hash.c: setting CE_HASHED
- preload-index.c, read-cache.c, unpack-trees.c and
builtin/update-index: obvious
- entry.c: write_entry() may refresh the checked out entry via
fill_stat_cache_info(). This causes "non-const struct cache_entry
*" in builtin/apply.c, builtin/checkout-index.c and
builtin/checkout.c
- builtin/ls-files.c: --with-tree changes stagemask and may set
CE_UPDATE
Of these, write_entry() and its call sites are probably most
interesting because it modifies on-disk info. But this is stat info
and can be retrieved via refresh, at least for porcelain
commands. Other just uses ce_flags for local purposes.
So, keeping track of "dirty" entries is just a matter of setting a
flag in index modification functions exposed by read-cache.c. Except
unpack-trees, the rest of the code base does not do anything funny
behind read-cache's back.
The actual patch is less valueable than the summary above. But if
anyone wants to re-identify the above sites. Applying this patch, then
this:
diff --git a/cache.h b/cache.h
index 430d021..1692891 100644
--- a/cache.h
+++ b/cache.h
@@ -267,7 +267,7 @@ static inline unsigned int canon_mode(unsigned int mode)
#define cache_entry_size(len) (offsetof(struct cache_entry,name) + (len) + 1)
struct index_state {
- struct cache_entry **cache;
+ const struct cache_entry **cache;
unsigned int version;
unsigned int cache_nr, cache_alloc, cache_changed;
struct string_list *resolve_undo;
will help quickly identify them without bogus warnings.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-09 17:29:00 +02:00
|
|
|
const struct cache_entry *ce = active_cache[pos];
|
2006-05-06 02:40:47 +02:00
|
|
|
struct cache_entry *old = NULL;
|
|
|
|
int save_nr;
|
2013-11-14 20:24:37 +01:00
|
|
|
char *path;
|
2006-05-06 08:09:05 +02:00
|
|
|
|
2014-01-24 14:40:28 +01:00
|
|
|
if (ce_stage(ce) || !ce_path_match(ce, &pathspec, NULL))
|
2006-05-06 02:40:47 +02:00
|
|
|
continue;
|
|
|
|
if (has_head)
|
2016-09-05 22:08:06 +02:00
|
|
|
old = read_one_ent(NULL, &head_oid,
|
2006-05-06 02:40:47 +02:00
|
|
|
ce->name, ce_namelen(ce), 0);
|
|
|
|
if (old && ce->ce_mode == old->ce_mode &&
|
2016-09-05 22:07:52 +02:00
|
|
|
!oidcmp(&ce->oid, &old->oid)) {
|
2006-05-06 02:40:47 +02:00
|
|
|
free(old);
|
|
|
|
continue; /* unchanged */
|
|
|
|
}
|
|
|
|
/* Be careful. The working tree may not have the
|
|
|
|
* path anymore, in which case, under 'allow_remove',
|
|
|
|
* or worse yet 'allow_replace', active_nr may decrease.
|
|
|
|
*/
|
|
|
|
save_nr = active_nr;
|
2013-11-14 20:24:37 +01:00
|
|
|
path = xstrdup(ce->name);
|
|
|
|
update_one(path);
|
|
|
|
free(path);
|
2015-03-21 01:28:01 +01:00
|
|
|
free(old);
|
2006-05-06 02:40:47 +02:00
|
|
|
if (save_nr != active_nr)
|
|
|
|
goto redo;
|
|
|
|
}
|
2016-06-02 23:09:22 +02:00
|
|
|
clear_pathspec(&pathspec);
|
2006-05-06 02:40:47 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-12-02 00:34:06 +01:00
|
|
|
struct refresh_params {
|
|
|
|
unsigned int flags;
|
|
|
|
int *has_errors;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int refresh(struct refresh_params *o, unsigned int flag)
|
|
|
|
{
|
|
|
|
setup_work_tree();
|
2012-10-30 10:50:42 +01:00
|
|
|
read_cache_preload(NULL);
|
2010-12-02 00:34:06 +01:00
|
|
|
*o->has_errors |= refresh_cache(o->flags | flag);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int refresh_callback(const struct option *opt,
|
|
|
|
const char *arg, int unset)
|
|
|
|
{
|
|
|
|
return refresh(opt->value, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int really_refresh_callback(const struct option *opt,
|
|
|
|
const char *arg, int unset)
|
|
|
|
{
|
|
|
|
return refresh(opt->value, REFRESH_REALLY);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int chmod_callback(const struct option *opt,
|
|
|
|
const char *arg, int unset)
|
|
|
|
{
|
|
|
|
char *flip = opt->value;
|
|
|
|
if ((arg[0] != '-' && arg[0] != '+') || arg[1] != 'x' || arg[2])
|
|
|
|
return error("option 'chmod' expects \"+x\" or \"-x\"");
|
|
|
|
*flip = arg[0];
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int resolve_undo_clear_callback(const struct option *opt,
|
|
|
|
const char *arg, int unset)
|
|
|
|
{
|
|
|
|
resolve_undo_clear();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-03-24 00:57:28 +01:00
|
|
|
static int parse_new_style_cacheinfo(const char *arg,
|
|
|
|
unsigned int *mode,
|
2016-09-05 22:08:06 +02:00
|
|
|
struct object_id *oid,
|
2014-03-24 00:57:28 +01:00
|
|
|
const char **path)
|
|
|
|
{
|
|
|
|
unsigned long ul;
|
|
|
|
char *endp;
|
|
|
|
|
2014-06-04 09:11:11 +02:00
|
|
|
if (!arg)
|
|
|
|
return -1;
|
|
|
|
|
2014-03-24 00:57:28 +01:00
|
|
|
errno = 0;
|
|
|
|
ul = strtoul(arg, &endp, 8);
|
|
|
|
if (errno || endp == arg || *endp != ',' || (unsigned int) ul != ul)
|
|
|
|
return -1; /* not a new-style cacheinfo */
|
|
|
|
*mode = ul;
|
|
|
|
endp++;
|
2016-09-05 22:08:06 +02:00
|
|
|
if (get_oid_hex(endp, oid) || endp[GIT_SHA1_HEXSZ] != ',')
|
2014-03-24 00:57:28 +01:00
|
|
|
return -1;
|
2016-09-05 22:08:06 +02:00
|
|
|
*path = endp + GIT_SHA1_HEXSZ + 1;
|
2014-03-24 00:57:28 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-12-02 00:34:06 +01:00
|
|
|
static int cacheinfo_callback(struct parse_opt_ctx_t *ctx,
|
|
|
|
const struct option *opt, int unset)
|
|
|
|
{
|
2016-09-05 22:08:06 +02:00
|
|
|
struct object_id oid;
|
2010-12-02 00:34:06 +01:00
|
|
|
unsigned int mode;
|
2014-03-24 00:57:28 +01:00
|
|
|
const char *path;
|
2010-12-02 00:34:06 +01:00
|
|
|
|
2016-09-05 22:08:06 +02:00
|
|
|
if (!parse_new_style_cacheinfo(ctx->argv[1], &mode, &oid, &path)) {
|
|
|
|
if (add_cacheinfo(mode, &oid, path, 0))
|
2014-03-24 00:57:28 +01:00
|
|
|
die("git update-index: --cacheinfo cannot add %s", path);
|
|
|
|
ctx->argv++;
|
|
|
|
ctx->argc--;
|
|
|
|
return 0;
|
|
|
|
}
|
2010-12-02 00:34:06 +01:00
|
|
|
if (ctx->argc <= 3)
|
2014-03-24 00:57:28 +01:00
|
|
|
return error("option 'cacheinfo' expects <mode>,<sha1>,<path>");
|
2010-12-02 00:34:06 +01:00
|
|
|
if (strtoul_ui(*++ctx->argv, 8, &mode) ||
|
2016-09-05 22:08:06 +02:00
|
|
|
get_oid_hex(*++ctx->argv, &oid) ||
|
|
|
|
add_cacheinfo(mode, &oid, *++ctx->argv, 0))
|
2010-12-02 00:34:06 +01:00
|
|
|
die("git update-index: --cacheinfo cannot add %s", *ctx->argv);
|
|
|
|
ctx->argc -= 3;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int stdin_cacheinfo_callback(struct parse_opt_ctx_t *ctx,
|
|
|
|
const struct option *opt, int unset)
|
|
|
|
{
|
2016-01-14 22:34:29 +01:00
|
|
|
int *nul_term_line = opt->value;
|
2010-12-02 00:34:06 +01:00
|
|
|
|
|
|
|
if (ctx->argc != 1)
|
|
|
|
return error("option '%s' must be the last argument", opt->long_name);
|
|
|
|
allow_add = allow_replace = allow_remove = 1;
|
2016-01-14 22:34:29 +01:00
|
|
|
read_index_info(*nul_term_line);
|
2010-12-02 00:34:06 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int stdin_callback(struct parse_opt_ctx_t *ctx,
|
|
|
|
const struct option *opt, int unset)
|
|
|
|
{
|
|
|
|
int *read_from_stdin = opt->value;
|
|
|
|
|
|
|
|
if (ctx->argc != 1)
|
|
|
|
return error("option '%s' must be the last argument", opt->long_name);
|
|
|
|
*read_from_stdin = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int unresolve_callback(struct parse_opt_ctx_t *ctx,
|
|
|
|
const struct option *opt, int flags)
|
|
|
|
{
|
|
|
|
int *has_errors = opt->value;
|
|
|
|
const char *prefix = startup_info->prefix;
|
|
|
|
|
|
|
|
/* consume remaining arguments. */
|
|
|
|
*has_errors = do_unresolve(ctx->argc, ctx->argv,
|
|
|
|
prefix, prefix ? strlen(prefix) : 0);
|
|
|
|
if (*has_errors)
|
|
|
|
active_cache_changed = 0;
|
|
|
|
|
|
|
|
ctx->argv += ctx->argc - 1;
|
|
|
|
ctx->argc = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int reupdate_callback(struct parse_opt_ctx_t *ctx,
|
|
|
|
const struct option *opt, int flags)
|
|
|
|
{
|
|
|
|
int *has_errors = opt->value;
|
|
|
|
const char *prefix = startup_info->prefix;
|
|
|
|
|
|
|
|
/* consume remaining arguments. */
|
|
|
|
setup_work_tree();
|
|
|
|
*has_errors = do_reupdate(ctx->argc, ctx->argv,
|
|
|
|
prefix, prefix ? strlen(prefix) : 0);
|
|
|
|
if (*has_errors)
|
|
|
|
active_cache_changed = 0;
|
|
|
|
|
|
|
|
ctx->argv += ctx->argc - 1;
|
|
|
|
ctx->argc = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-07-29 07:44:25 +02:00
|
|
|
int cmd_update_index(int argc, const char **argv, const char *prefix)
|
2005-04-08 00:13:13 +02:00
|
|
|
{
|
2016-01-14 22:34:29 +01:00
|
|
|
int newfd, entries, has_errors = 0, nul_term_line = 0;
|
2016-01-24 16:28:15 +01:00
|
|
|
enum uc_mode untracked_cache = UC_UNSPECIFIED;
|
2005-09-27 03:13:08 +02:00
|
|
|
int read_from_stdin = 0;
|
|
|
|
int prefix_length = prefix ? strlen(prefix) : 0;
|
2012-04-04 18:37:02 +02:00
|
|
|
int preferred_index_format = 0;
|
2006-04-23 09:01:29 +02:00
|
|
|
char set_executable_bit = 0;
|
2010-12-02 00:34:06 +01:00
|
|
|
struct refresh_params refresh_args = {0, &has_errors};
|
2007-02-22 09:30:45 +01:00
|
|
|
int lock_error = 0;
|
2014-06-13 14:19:44 +02:00
|
|
|
int split_index = -1;
|
2017-09-22 18:35:39 +02:00
|
|
|
int force_write = 0;
|
2017-09-22 18:35:43 +02:00
|
|
|
int fsmonitor = -1;
|
2017-09-05 14:15:21 +02:00
|
|
|
struct lock_file lock_file = LOCK_INIT;
|
2010-12-02 00:34:06 +01:00
|
|
|
struct parse_opt_ctx_t ctx;
|
2016-01-14 22:34:29 +01:00
|
|
|
strbuf_getline_fn getline_fn;
|
2010-12-02 00:34:06 +01:00
|
|
|
int parseopt_state = PARSE_OPT_UNKNOWN;
|
|
|
|
struct option options[] = {
|
|
|
|
OPT_BIT('q', NULL, &refresh_args.flags,
|
2012-08-20 14:32:48 +02:00
|
|
|
N_("continue refresh even when index needs update"),
|
2010-12-02 00:34:06 +01:00
|
|
|
REFRESH_QUIET),
|
|
|
|
OPT_BIT(0, "ignore-submodules", &refresh_args.flags,
|
2012-08-20 14:32:48 +02:00
|
|
|
N_("refresh: ignore submodules"),
|
2010-12-02 00:34:06 +01:00
|
|
|
REFRESH_IGNORE_SUBMODULES),
|
|
|
|
OPT_SET_INT(0, "add", &allow_add,
|
2012-08-20 14:32:48 +02:00
|
|
|
N_("do not ignore new files"), 1),
|
2010-12-02 00:34:06 +01:00
|
|
|
OPT_SET_INT(0, "replace", &allow_replace,
|
2012-08-20 14:32:48 +02:00
|
|
|
N_("let files replace directories and vice-versa"), 1),
|
2010-12-02 00:34:06 +01:00
|
|
|
OPT_SET_INT(0, "remove", &allow_remove,
|
2012-08-20 14:32:48 +02:00
|
|
|
N_("notice files missing from worktree"), 1),
|
2010-12-02 00:34:06 +01:00
|
|
|
OPT_BIT(0, "unmerged", &refresh_args.flags,
|
2012-08-20 14:32:48 +02:00
|
|
|
N_("refresh even if index contains unmerged entries"),
|
2010-12-02 00:34:06 +01:00
|
|
|
REFRESH_UNMERGED),
|
|
|
|
{OPTION_CALLBACK, 0, "refresh", &refresh_args, NULL,
|
2012-08-20 14:32:48 +02:00
|
|
|
N_("refresh stat information"),
|
2010-12-02 00:34:06 +01:00
|
|
|
PARSE_OPT_NOARG | PARSE_OPT_NONEG,
|
|
|
|
refresh_callback},
|
|
|
|
{OPTION_CALLBACK, 0, "really-refresh", &refresh_args, NULL,
|
2012-08-20 14:32:48 +02:00
|
|
|
N_("like --refresh, but ignore assume-unchanged setting"),
|
2010-12-02 00:34:06 +01:00
|
|
|
PARSE_OPT_NOARG | PARSE_OPT_NONEG,
|
|
|
|
really_refresh_callback},
|
|
|
|
{OPTION_LOWLEVEL_CALLBACK, 0, "cacheinfo", NULL,
|
2014-03-24 00:57:28 +01:00
|
|
|
N_("<mode>,<object>,<path>"),
|
2012-08-20 14:32:48 +02:00
|
|
|
N_("add the specified entry to the index"),
|
2014-03-24 00:57:28 +01:00
|
|
|
PARSE_OPT_NOARG | /* disallow --cacheinfo=<mode> form */
|
2010-12-02 00:34:06 +01:00
|
|
|
PARSE_OPT_NONEG | PARSE_OPT_LITERAL_ARGHELP,
|
|
|
|
(parse_opt_cb *) cacheinfo_callback},
|
2018-08-02 21:17:35 +02:00
|
|
|
{OPTION_CALLBACK, 0, "chmod", &set_executable_bit, "(+|-)x",
|
2012-08-20 14:32:48 +02:00
|
|
|
N_("override the executable bit of the listed files"),
|
2018-08-02 21:18:14 +02:00
|
|
|
PARSE_OPT_NONEG,
|
2010-12-02 00:34:06 +01:00
|
|
|
chmod_callback},
|
|
|
|
{OPTION_SET_INT, 0, "assume-unchanged", &mark_valid_only, NULL,
|
2012-08-20 14:32:48 +02:00
|
|
|
N_("mark files as \"not changing\""),
|
2010-12-02 00:34:06 +01:00
|
|
|
PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, MARK_FLAG},
|
|
|
|
{OPTION_SET_INT, 0, "no-assume-unchanged", &mark_valid_only, NULL,
|
2012-08-20 14:32:48 +02:00
|
|
|
N_("clear assumed-unchanged bit"),
|
2010-12-02 00:34:06 +01:00
|
|
|
PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, UNMARK_FLAG},
|
|
|
|
{OPTION_SET_INT, 0, "skip-worktree", &mark_skip_worktree_only, NULL,
|
2012-08-20 14:32:48 +02:00
|
|
|
N_("mark files as \"index-only\""),
|
2010-12-02 00:34:06 +01:00
|
|
|
PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, MARK_FLAG},
|
|
|
|
{OPTION_SET_INT, 0, "no-skip-worktree", &mark_skip_worktree_only, NULL,
|
2012-08-20 14:32:48 +02:00
|
|
|
N_("clear skip-worktree bit"),
|
2010-12-02 00:34:06 +01:00
|
|
|
PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, UNMARK_FLAG},
|
|
|
|
OPT_SET_INT(0, "info-only", &info_only,
|
2012-08-20 14:32:48 +02:00
|
|
|
N_("add to index only; do not add content to object database"), 1),
|
2010-12-02 00:34:06 +01:00
|
|
|
OPT_SET_INT(0, "force-remove", &force_remove,
|
2012-08-20 14:32:48 +02:00
|
|
|
N_("remove named paths even if present in worktree"), 1),
|
2016-01-14 22:34:29 +01:00
|
|
|
OPT_BOOL('z', NULL, &nul_term_line,
|
|
|
|
N_("with --stdin: input lines are terminated by null bytes")),
|
2010-12-02 00:34:06 +01:00
|
|
|
{OPTION_LOWLEVEL_CALLBACK, 0, "stdin", &read_from_stdin, NULL,
|
2012-08-20 14:32:48 +02:00
|
|
|
N_("read list of paths to be updated from standard input"),
|
2010-12-02 00:34:06 +01:00
|
|
|
PARSE_OPT_NONEG | PARSE_OPT_NOARG,
|
|
|
|
(parse_opt_cb *) stdin_callback},
|
2016-01-14 22:34:29 +01:00
|
|
|
{OPTION_LOWLEVEL_CALLBACK, 0, "index-info", &nul_term_line, NULL,
|
2012-08-20 14:32:48 +02:00
|
|
|
N_("add entries from standard input to the index"),
|
2010-12-02 00:34:06 +01:00
|
|
|
PARSE_OPT_NONEG | PARSE_OPT_NOARG,
|
|
|
|
(parse_opt_cb *) stdin_cacheinfo_callback},
|
|
|
|
{OPTION_LOWLEVEL_CALLBACK, 0, "unresolve", &has_errors, NULL,
|
2012-08-20 14:32:48 +02:00
|
|
|
N_("repopulate stages #2 and #3 for the listed paths"),
|
2010-12-02 00:34:06 +01:00
|
|
|
PARSE_OPT_NONEG | PARSE_OPT_NOARG,
|
|
|
|
(parse_opt_cb *) unresolve_callback},
|
|
|
|
{OPTION_LOWLEVEL_CALLBACK, 'g', "again", &has_errors, NULL,
|
2012-08-20 14:32:48 +02:00
|
|
|
N_("only update entries that differ from HEAD"),
|
2010-12-02 00:34:06 +01:00
|
|
|
PARSE_OPT_NONEG | PARSE_OPT_NOARG,
|
|
|
|
(parse_opt_cb *) reupdate_callback},
|
|
|
|
OPT_BIT(0, "ignore-missing", &refresh_args.flags,
|
2012-08-20 14:32:48 +02:00
|
|
|
N_("ignore files missing from worktree"),
|
2010-12-02 00:34:06 +01:00
|
|
|
REFRESH_IGNORE_MISSING),
|
|
|
|
OPT_SET_INT(0, "verbose", &verbose,
|
2012-08-20 14:32:48 +02:00
|
|
|
N_("report actions to standard output"), 1),
|
2010-12-02 00:34:06 +01:00
|
|
|
{OPTION_CALLBACK, 0, "clear-resolve-undo", NULL, NULL,
|
2012-08-20 14:32:48 +02:00
|
|
|
N_("(for porcelains) forget saved unresolved conflicts"),
|
2010-12-02 00:34:06 +01:00
|
|
|
PARSE_OPT_NOARG | PARSE_OPT_NONEG,
|
|
|
|
resolve_undo_clear_callback},
|
2012-04-04 18:37:02 +02:00
|
|
|
OPT_INTEGER(0, "index-version", &preferred_index_format,
|
2012-08-20 14:32:48 +02:00
|
|
|
N_("write index in this format")),
|
2014-06-13 14:19:44 +02:00
|
|
|
OPT_BOOL(0, "split-index", &split_index,
|
|
|
|
N_("enable or disable split index")),
|
2015-03-08 11:12:42 +01:00
|
|
|
OPT_BOOL(0, "untracked-cache", &untracked_cache,
|
|
|
|
N_("enable/disable untracked cache")),
|
2016-01-24 16:28:16 +01:00
|
|
|
OPT_SET_INT(0, "test-untracked-cache", &untracked_cache,
|
|
|
|
N_("test if the filesystem supports untracked cache"), UC_TEST),
|
2015-03-08 11:12:43 +01:00
|
|
|
OPT_SET_INT(0, "force-untracked-cache", &untracked_cache,
|
2016-01-24 16:28:15 +01:00
|
|
|
N_("enable untracked cache without testing the filesystem"), UC_FORCE),
|
2017-09-22 18:35:39 +02:00
|
|
|
OPT_SET_INT(0, "force-write-index", &force_write,
|
|
|
|
N_("write out the index even if is not flagged as changed"), 1),
|
2017-09-22 18:35:43 +02:00
|
|
|
OPT_BOOL(0, "fsmonitor", &fsmonitor,
|
|
|
|
N_("enable or disable file system monitor")),
|
|
|
|
{OPTION_SET_INT, 0, "fsmonitor-valid", &mark_fsmonitor_only, NULL,
|
|
|
|
N_("mark files as fsmonitor valid"),
|
|
|
|
PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, MARK_FLAG},
|
|
|
|
{OPTION_SET_INT, 0, "no-fsmonitor-valid", &mark_fsmonitor_only, NULL,
|
|
|
|
N_("clear fsmonitor valid bit"),
|
|
|
|
PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, UNMARK_FLAG},
|
2010-12-02 00:34:06 +01:00
|
|
|
OPT_END()
|
|
|
|
};
|
2005-04-21 19:55:18 +02:00
|
|
|
|
2010-10-22 08:51:00 +02:00
|
|
|
if (argc == 2 && !strcmp(argv[1], "-h"))
|
2013-02-23 19:10:41 +01:00
|
|
|
usage_with_options(update_index_usage, options);
|
2010-10-22 08:51:00 +02:00
|
|
|
|
2008-05-14 19:46:53 +02:00
|
|
|
git_config(git_default_config, NULL);
|
2005-10-12 03:45:33 +02:00
|
|
|
|
2016-12-07 19:33:54 +01:00
|
|
|
/* we will diagnose later if it turns out that we need to update it */
|
2017-09-05 14:15:21 +02:00
|
|
|
newfd = hold_locked_index(&lock_file, 0);
|
2007-02-22 09:30:45 +01:00
|
|
|
if (newfd < 0)
|
|
|
|
lock_error = errno;
|
2005-04-12 00:39:26 +02:00
|
|
|
|
2005-04-08 00:13:13 +02:00
|
|
|
entries = read_cache();
|
2005-04-12 00:39:26 +02:00
|
|
|
if (entries < 0)
|
2005-04-13 11:28:48 +02:00
|
|
|
die("cache corrupted");
|
2005-04-08 00:13:13 +02:00
|
|
|
|
2010-12-02 00:34:06 +01:00
|
|
|
/*
|
|
|
|
* Custom copy of parse_options() because we want to handle
|
|
|
|
* filename arguments as they come.
|
|
|
|
*/
|
|
|
|
parse_options_start(&ctx, argc, argv, prefix,
|
|
|
|
options, PARSE_OPT_STOP_AT_NON_OPTION);
|
|
|
|
while (ctx.argc) {
|
|
|
|
if (parseopt_state != PARSE_OPT_DONE)
|
|
|
|
parseopt_state = parse_options_step(&ctx, options,
|
|
|
|
update_index_usage);
|
|
|
|
if (!ctx.argc)
|
|
|
|
break;
|
|
|
|
switch (parseopt_state) {
|
|
|
|
case PARSE_OPT_HELP:
|
|
|
|
exit(129);
|
|
|
|
case PARSE_OPT_NON_OPTION:
|
|
|
|
case PARSE_OPT_DONE:
|
|
|
|
{
|
|
|
|
const char *path = ctx.argv[0];
|
2015-05-04 21:11:54 +02:00
|
|
|
char *p;
|
2005-04-10 20:32:54 +02:00
|
|
|
|
2010-12-02 00:34:06 +01:00
|
|
|
setup_work_tree();
|
|
|
|
p = prefix_path(prefix, prefix_length, path);
|
2013-11-14 20:24:08 +01:00
|
|
|
update_one(p);
|
2010-12-02 00:34:06 +01:00
|
|
|
if (set_executable_bit)
|
|
|
|
chmod_path(set_executable_bit, p);
|
2015-05-04 21:11:54 +02:00
|
|
|
free(p);
|
2010-12-02 00:34:06 +01:00
|
|
|
ctx.argc--;
|
|
|
|
ctx.argv++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case PARSE_OPT_UNKNOWN:
|
|
|
|
if (ctx.argv[0][1] == '-')
|
|
|
|
error("unknown option '%s'", ctx.argv[0] + 2);
|
|
|
|
else
|
|
|
|
error("unknown switch '%c'", *ctx.opt);
|
|
|
|
usage_with_options(update_index_usage, options);
|
2005-04-10 20:32:54 +02:00
|
|
|
}
|
2005-09-27 03:13:08 +02:00
|
|
|
}
|
2010-12-02 00:34:06 +01:00
|
|
|
argc = parse_options_end(&ctx);
|
2016-01-14 22:34:29 +01:00
|
|
|
|
|
|
|
getline_fn = nul_term_line ? strbuf_getline_nul : strbuf_getline_lf;
|
2012-04-04 18:37:02 +02:00
|
|
|
if (preferred_index_format) {
|
|
|
|
if (preferred_index_format < INDEX_FORMAT_LB ||
|
|
|
|
INDEX_FORMAT_UB < preferred_index_format)
|
|
|
|
die("index-version %d not in range: %d..%d",
|
|
|
|
preferred_index_format,
|
|
|
|
INDEX_FORMAT_LB, INDEX_FORMAT_UB);
|
|
|
|
|
|
|
|
if (the_index.version != preferred_index_format)
|
2014-06-13 14:19:28 +02:00
|
|
|
active_cache_changed |= SOMETHING_CHANGED;
|
2012-04-04 18:37:02 +02:00
|
|
|
the_index.version = preferred_index_format;
|
|
|
|
}
|
2010-12-02 00:34:06 +01:00
|
|
|
|
2005-09-27 03:13:08 +02:00
|
|
|
if (read_from_stdin) {
|
2016-01-31 12:25:26 +01:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
struct strbuf unquoted = STRBUF_INIT;
|
2007-09-20 00:42:14 +02:00
|
|
|
|
2008-08-30 11:13:58 +02:00
|
|
|
setup_work_tree();
|
2016-01-14 22:34:29 +01:00
|
|
|
while (getline_fn(&buf, stdin) != EOF) {
|
2015-05-04 21:11:54 +02:00
|
|
|
char *p;
|
2016-01-14 22:34:29 +01:00
|
|
|
if (!nul_term_line && buf.buf[0] == '"') {
|
2016-01-31 12:25:26 +01:00
|
|
|
strbuf_reset(&unquoted);
|
|
|
|
if (unquote_c_style(&unquoted, buf.buf, NULL))
|
2007-09-20 00:42:14 +02:00
|
|
|
die("line is badly quoted");
|
2016-01-31 12:25:26 +01:00
|
|
|
strbuf_swap(&buf, &unquoted);
|
2007-09-20 00:42:14 +02:00
|
|
|
}
|
|
|
|
p = prefix_path(prefix, prefix_length, buf.buf);
|
2013-11-14 20:24:08 +01:00
|
|
|
update_one(p);
|
2006-05-06 07:53:56 +02:00
|
|
|
if (set_executable_bit)
|
2006-04-23 09:01:29 +02:00
|
|
|
chmod_path(set_executable_bit, p);
|
2015-05-04 21:11:54 +02:00
|
|
|
free(p);
|
2005-05-31 18:52:43 +02:00
|
|
|
}
|
2016-01-31 12:25:26 +01:00
|
|
|
strbuf_release(&unquoted);
|
2007-09-17 11:19:04 +02:00
|
|
|
strbuf_release(&buf);
|
2005-04-08 00:13:13 +02:00
|
|
|
}
|
2006-04-20 08:52:05 +02:00
|
|
|
|
2014-06-13 14:19:44 +02:00
|
|
|
if (split_index > 0) {
|
2017-02-27 19:00:03 +01:00
|
|
|
if (git_config_get_split_index() == 0)
|
|
|
|
warning(_("core.splitIndex is set to false; "
|
|
|
|
"remove or change it, if you really want to "
|
|
|
|
"enable split index"));
|
2017-02-27 19:00:01 +01:00
|
|
|
if (the_index.split_index)
|
|
|
|
the_index.cache_changed |= SPLIT_INDEX_ORDERED;
|
|
|
|
else
|
|
|
|
add_split_index(&the_index);
|
2017-02-27 19:00:03 +01:00
|
|
|
} else if (!split_index) {
|
|
|
|
if (git_config_get_split_index() == 1)
|
|
|
|
warning(_("core.splitIndex is set to true; "
|
|
|
|
"remove or change it, if you really want to "
|
|
|
|
"disable split index"));
|
2017-02-27 19:00:01 +01:00
|
|
|
remove_split_index(&the_index);
|
2017-02-27 19:00:03 +01:00
|
|
|
}
|
2015-03-08 11:12:42 +01:00
|
|
|
|
config: add core.untrackedCache
When we know that mtime on directory as given by the environment
is usable for the purpose of untracked cache, we may want the
untracked cache to be always used without any mtime test or
kernel name check being performed.
Also when we know that mtime is not usable for the purpose of
untracked cache, for example because the repo is shared over a
network file system, we may want the untracked-cache to be
automatically removed from the index.
Allow the user to express such preference by setting the
'core.untrackedCache' configuration variable, which can take
'keep', 'false', or 'true' and default to 'keep'.
When read_index_from() is called, it now adds or removes the
untracked cache in the index to respect the value of this
variable. So it does nothing if the value is `keep` or if the
variable is unset; it adds the untracked cache if the value is
`true`; and it removes the cache if the value is `false`.
`git update-index --[no-|force-]untracked-cache` still adds the
untracked cache to, or removes it, from the index, but this
shows a warning if it goes against the value of
core.untrackedCache, because the next time the index is read
the untracked cache will be added or removed if the
configuration is set to do so.
Also `--untracked-cache` used to check that the underlying
operating system and file system change `st_mtime` field of a
directory if files are added or deleted in that directory. But
because those tests take a long time, `--untracked-cache` no
longer performs them. Instead, there is now
`--test-untracked-cache` to perform the tests. This change
makes `--untracked-cache` the same as `--force-untracked-cache`.
This last change is backward incompatible and should be
mentioned in the release notes.
Helped-by: Duy Nguyen <pclouds@gmail.com>
Helped-by: Torsten Bögershausen <tboegi@web.de>
Helped-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
read-cache: Duy'sfixup
Signed-off-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-01-27 07:58:05 +01:00
|
|
|
switch (untracked_cache) {
|
|
|
|
case UC_UNSPECIFIED:
|
|
|
|
break;
|
|
|
|
case UC_DISABLE:
|
|
|
|
if (git_config_get_untracked_cache() == 1)
|
2016-09-15 16:59:08 +02:00
|
|
|
warning(_("core.untrackedCache is set to true; "
|
|
|
|
"remove or change it, if you really want to "
|
|
|
|
"disable the untracked cache"));
|
2016-01-24 16:28:20 +01:00
|
|
|
remove_untracked_cache(&the_index);
|
2016-01-24 16:28:17 +01:00
|
|
|
report(_("Untracked cache disabled"));
|
config: add core.untrackedCache
When we know that mtime on directory as given by the environment
is usable for the purpose of untracked cache, we may want the
untracked cache to be always used without any mtime test or
kernel name check being performed.
Also when we know that mtime is not usable for the purpose of
untracked cache, for example because the repo is shared over a
network file system, we may want the untracked-cache to be
automatically removed from the index.
Allow the user to express such preference by setting the
'core.untrackedCache' configuration variable, which can take
'keep', 'false', or 'true' and default to 'keep'.
When read_index_from() is called, it now adds or removes the
untracked cache in the index to respect the value of this
variable. So it does nothing if the value is `keep` or if the
variable is unset; it adds the untracked cache if the value is
`true`; and it removes the cache if the value is `false`.
`git update-index --[no-|force-]untracked-cache` still adds the
untracked cache to, or removes it, from the index, but this
shows a warning if it goes against the value of
core.untrackedCache, because the next time the index is read
the untracked cache will be added or removed if the
configuration is set to do so.
Also `--untracked-cache` used to check that the underlying
operating system and file system change `st_mtime` field of a
directory if files are added or deleted in that directory. But
because those tests take a long time, `--untracked-cache` no
longer performs them. Instead, there is now
`--test-untracked-cache` to perform the tests. This change
makes `--untracked-cache` the same as `--force-untracked-cache`.
This last change is backward incompatible and should be
mentioned in the release notes.
Helped-by: Duy Nguyen <pclouds@gmail.com>
Helped-by: Torsten Bögershausen <tboegi@web.de>
Helped-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
read-cache: Duy'sfixup
Signed-off-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-01-27 07:58:05 +01:00
|
|
|
break;
|
|
|
|
case UC_TEST:
|
|
|
|
setup_work_tree();
|
|
|
|
return !test_if_untracked_cache_is_supported();
|
|
|
|
case UC_ENABLE:
|
|
|
|
case UC_FORCE:
|
|
|
|
if (git_config_get_untracked_cache() == 0)
|
2016-09-15 16:59:08 +02:00
|
|
|
warning(_("core.untrackedCache is set to false; "
|
|
|
|
"remove or change it, if you really want to "
|
|
|
|
"enable the untracked cache"));
|
config: add core.untrackedCache
When we know that mtime on directory as given by the environment
is usable for the purpose of untracked cache, we may want the
untracked cache to be always used without any mtime test or
kernel name check being performed.
Also when we know that mtime is not usable for the purpose of
untracked cache, for example because the repo is shared over a
network file system, we may want the untracked-cache to be
automatically removed from the index.
Allow the user to express such preference by setting the
'core.untrackedCache' configuration variable, which can take
'keep', 'false', or 'true' and default to 'keep'.
When read_index_from() is called, it now adds or removes the
untracked cache in the index to respect the value of this
variable. So it does nothing if the value is `keep` or if the
variable is unset; it adds the untracked cache if the value is
`true`; and it removes the cache if the value is `false`.
`git update-index --[no-|force-]untracked-cache` still adds the
untracked cache to, or removes it, from the index, but this
shows a warning if it goes against the value of
core.untrackedCache, because the next time the index is read
the untracked cache will be added or removed if the
configuration is set to do so.
Also `--untracked-cache` used to check that the underlying
operating system and file system change `st_mtime` field of a
directory if files are added or deleted in that directory. But
because those tests take a long time, `--untracked-cache` no
longer performs them. Instead, there is now
`--test-untracked-cache` to perform the tests. This change
makes `--untracked-cache` the same as `--force-untracked-cache`.
This last change is backward incompatible and should be
mentioned in the release notes.
Helped-by: Duy Nguyen <pclouds@gmail.com>
Helped-by: Torsten Bögershausen <tboegi@web.de>
Helped-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
read-cache: Duy'sfixup
Signed-off-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-01-27 07:58:05 +01:00
|
|
|
add_untracked_cache(&the_index);
|
|
|
|
report(_("Untracked cache enabled for '%s'"), get_git_work_tree());
|
|
|
|
break;
|
|
|
|
default:
|
2016-07-26 18:05:50 +02:00
|
|
|
die("BUG: bad untracked_cache value: %d", untracked_cache);
|
2015-03-08 11:12:42 +01:00
|
|
|
}
|
2014-06-13 14:19:44 +02:00
|
|
|
|
2017-09-22 18:35:43 +02:00
|
|
|
if (fsmonitor > 0) {
|
|
|
|
if (git_config_get_fsmonitor() == 0)
|
|
|
|
warning(_("core.fsmonitor is unset; "
|
|
|
|
"set it if you really want to "
|
|
|
|
"enable fsmonitor"));
|
|
|
|
add_fsmonitor(&the_index);
|
|
|
|
report(_("fsmonitor enabled"));
|
|
|
|
} else if (!fsmonitor) {
|
|
|
|
if (git_config_get_fsmonitor() == 1)
|
|
|
|
warning(_("core.fsmonitor is set; "
|
|
|
|
"remove it if you really want to "
|
|
|
|
"disable fsmonitor"));
|
|
|
|
remove_fsmonitor(&the_index);
|
|
|
|
report(_("fsmonitor disabled"));
|
|
|
|
}
|
|
|
|
|
2017-09-22 18:35:39 +02:00
|
|
|
if (active_cache_changed || force_write) {
|
2007-02-22 09:30:45 +01:00
|
|
|
if (newfd < 0) {
|
2010-12-02 00:34:06 +01:00
|
|
|
if (refresh_args.flags & REFRESH_QUIET)
|
2007-02-22 09:30:45 +01:00
|
|
|
exit(128);
|
2014-10-01 12:28:05 +02:00
|
|
|
unable_to_lock_die(get_index_file(), lock_error);
|
2007-02-22 09:30:45 +01:00
|
|
|
}
|
2017-09-05 14:15:21 +02:00
|
|
|
if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))
|
2006-06-06 21:51:49 +02:00
|
|
|
die("Unable to write new index file");
|
2005-10-01 22:39:47 +02:00
|
|
|
}
|
2005-04-12 00:39:26 +02:00
|
|
|
|
2017-09-05 14:15:21 +02:00
|
|
|
rollback_lock_file(&lock_file);
|
2006-06-13 22:21:57 +02:00
|
|
|
|
2005-05-06 00:29:06 +02:00
|
|
|
return has_errors ? 1 : 0;
|
2005-04-08 00:13:13 +02:00
|
|
|
}
|