mirror of
https://github.com/git/git
synced 2024-08-28 20:20:07 +00:00
![Junio C Hamano](/assets/img/avatar_default.png)
This adds "assume unchanged" logic, started by this message in the list discussion recently: <Pine.LNX.4.64.0601311807470.7301@g5.osdl.org> This is a workaround for filesystems that do not have lstat() that is quick enough for the index mechanism to take advantage of. On the paths marked as "assumed to be unchanged", the user needs to explicitly use update-index to register the object name to be in the next commit. You can use two new options to update-index to set and reset the CE_VALID bit: git-update-index --assume-unchanged path... git-update-index --no-assume-unchanged path... These forms manipulate only the CE_VALID bit; it does not change the object name recorded in the index file. Nor they add a new entry to the index. When the configuration variable "core.ignorestat = true" is set, the index entries are marked with CE_VALID bit automatically after: - update-index to explicitly register the current object name to the index file. - when update-index --refresh finds the path to be up-to-date. - when tools like read-tree -u and apply --index update the working tree file and register the current object name to the index file. The flag is dropped upon read-tree that does not check out the index entry. This happens regardless of the core.ignorestat settings. Index entries marked with CE_VALID bit are assumed to be unchanged most of the time. However, there are cases that CE_VALID bit is ignored for the sake of safety and usability: - while "git-read-tree -m" or git-apply need to make sure that the paths involved in the merge do not have local modifications. This sacrifices performance for safety. - when git-checkout-index -f -q -u -a tries to see if it needs to checkout the paths. Otherwise you can never check anything out ;-). - when git-update-index --really-refresh (a new flag) tries to see if the index entry is up to date. You can start with everything marked as CE_VALID and run this once to drop CE_VALID bit for paths that are modified. Most notably, "update-index --refresh" honours CE_VALID and does not actively stat, so after you modified a file in the working tree, update-index --refresh would not notice until you tell the index about it with "git-update-index path" or "git-update-index --no-assume-unchanged path". This version is not expected to be perfect. I think diff between index and/or tree and working files may need some adjustment, and there probably needs other cases we should automatically unmark paths that are marked to be CE_VALID. But the basics seem to work, and ready to be tested by people who asked for this feature. Signed-off-by: Junio C Hamano <junkio@cox.net>
154 lines
3.6 KiB
C
154 lines
3.6 KiB
C
#include <sys/types.h>
|
|
#include <dirent.h>
|
|
#include "cache.h"
|
|
|
|
static void create_directories(const char *path, struct checkout *state)
|
|
{
|
|
int len = strlen(path);
|
|
char *buf = xmalloc(len + 1);
|
|
const char *slash = path;
|
|
|
|
while ((slash = strchr(slash+1, '/')) != NULL) {
|
|
len = slash - path;
|
|
memcpy(buf, path, len);
|
|
buf[len] = 0;
|
|
if (mkdir(buf, 0777)) {
|
|
if (errno == EEXIST) {
|
|
struct stat st;
|
|
if (len > state->base_dir_len && state->force && !unlink(buf) && !mkdir(buf, 0777))
|
|
continue;
|
|
if (!stat(buf, &st) && S_ISDIR(st.st_mode))
|
|
continue; /* ok */
|
|
}
|
|
die("cannot create directory at %s", buf);
|
|
}
|
|
}
|
|
free(buf);
|
|
}
|
|
|
|
static void remove_subtree(const char *path)
|
|
{
|
|
DIR *dir = opendir(path);
|
|
struct dirent *de;
|
|
char pathbuf[PATH_MAX];
|
|
char *name;
|
|
|
|
if (!dir)
|
|
die("cannot opendir %s", path);
|
|
strcpy(pathbuf, path);
|
|
name = pathbuf + strlen(path);
|
|
*name++ = '/';
|
|
while ((de = readdir(dir)) != NULL) {
|
|
struct stat st;
|
|
if ((de->d_name[0] == '.') &&
|
|
((de->d_name[1] == 0) ||
|
|
((de->d_name[1] == '.') && de->d_name[2] == 0)))
|
|
continue;
|
|
strcpy(name, de->d_name);
|
|
if (lstat(pathbuf, &st))
|
|
die("cannot lstat %s", pathbuf);
|
|
if (S_ISDIR(st.st_mode))
|
|
remove_subtree(pathbuf);
|
|
else if (unlink(pathbuf))
|
|
die("cannot unlink %s", pathbuf);
|
|
}
|
|
closedir(dir);
|
|
if (rmdir(path))
|
|
die("cannot rmdir %s", path);
|
|
}
|
|
|
|
static int create_file(const char *path, unsigned int mode)
|
|
{
|
|
mode = (mode & 0100) ? 0777 : 0666;
|
|
return open(path, O_WRONLY | O_CREAT | O_EXCL, mode);
|
|
}
|
|
|
|
static int write_entry(struct cache_entry *ce, const char *path, struct checkout *state)
|
|
{
|
|
int fd;
|
|
void *new;
|
|
unsigned long size;
|
|
long wrote;
|
|
char type[20];
|
|
|
|
new = read_sha1_file(ce->sha1, type, &size);
|
|
if (!new || strcmp(type, "blob")) {
|
|
if (new)
|
|
free(new);
|
|
return error("git-checkout-index: unable to read sha1 file of %s (%s)",
|
|
path, sha1_to_hex(ce->sha1));
|
|
}
|
|
switch (ntohl(ce->ce_mode) & S_IFMT) {
|
|
case S_IFREG:
|
|
fd = create_file(path, ntohl(ce->ce_mode));
|
|
if (fd < 0) {
|
|
free(new);
|
|
return error("git-checkout-index: unable to create file %s (%s)",
|
|
path, strerror(errno));
|
|
}
|
|
wrote = write(fd, new, size);
|
|
close(fd);
|
|
free(new);
|
|
if (wrote != size)
|
|
return error("git-checkout-index: unable to write file %s", path);
|
|
break;
|
|
case S_IFLNK:
|
|
if (symlink(new, path)) {
|
|
free(new);
|
|
return error("git-checkout-index: unable to create "
|
|
"symlink %s (%s)", path, strerror(errno));
|
|
}
|
|
free(new);
|
|
break;
|
|
default:
|
|
free(new);
|
|
return error("git-checkout-index: unknown file mode for %s", path);
|
|
}
|
|
|
|
if (state->refresh_cache) {
|
|
struct stat st;
|
|
lstat(ce->name, &st);
|
|
fill_stat_cache_info(ce, &st);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int checkout_entry(struct cache_entry *ce, struct checkout *state)
|
|
{
|
|
struct stat st;
|
|
static char path[MAXPATHLEN+1];
|
|
int len = state->base_dir_len;
|
|
|
|
memcpy(path, state->base_dir, len);
|
|
strcpy(path + len, ce->name);
|
|
|
|
if (!lstat(path, &st)) {
|
|
unsigned changed = ce_match_stat(ce, &st, 1);
|
|
if (!changed)
|
|
return 0;
|
|
if (!state->force) {
|
|
if (!state->quiet)
|
|
fprintf(stderr, "git-checkout-index: %s already exists\n", path);
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* We unlink the old file, to get the new one with the
|
|
* right permissions (including umask, which is nasty
|
|
* to emulate by hand - much easier to let the system
|
|
* just do the right thing)
|
|
*/
|
|
unlink(path);
|
|
if (S_ISDIR(st.st_mode)) {
|
|
if (!state->force)
|
|
return error("%s is a directory", path);
|
|
remove_subtree(path);
|
|
}
|
|
} else if (state->not_new)
|
|
return 0;
|
|
create_directories(path, state);
|
|
return write_entry(ce, path, state);
|
|
}
|
|
|
|
|