diff options
64 files changed, 1269 insertions, 462 deletions
diff --git a/Documentation/config.txt b/Documentation/config.txt index 4318bf9..b4aae0d 100644 --- a/Documentation/config.txt +++ b/Documentation/config.txt @@ -118,6 +118,34 @@ core.legacyheaders:: database directly (where the "http://" and "rsync://" protocols count as direct access). +core.packedGitWindowSize:: + Number of bytes of a pack file to map into memory in a + single mapping operation. Larger window sizes may allow + your system to process a smaller number of large pack files + more quickly. Smaller window sizes will negatively affect + performance due to increased calls to the operating system's + memory manager, but may improve performance when accessing + a large number of large pack files. ++ +Default is 1 MiB if NO_MMAP was set at compile time, otherwise 32 +MiB on 32 bit platforms and 1 GiB on 64 bit platforms. This should +be reasonable for all users/operating systems. You probably do +not need to adjust this value. ++ +Common unit suffixes of 'k', 'm', or 'g' are supported. + +core.packedGitLimit:: + Maximum number of bytes to map simultaneously into memory + from pack files. If Git needs to access more than this many + bytes at once to complete an operation it will unmap existing + regions to reclaim virtual address space within the process. ++ +Default is 256 MiB on 32 bit platforms and 8 GiB on 64 bit platforms. +This should be reasonable for all users/operating systems, except on +the largest projects. You probably do not need to adjust this value. ++ +Common unit suffixes of 'k', 'm', or 'g' are supported. + alias.*:: Command aliases for the gitlink:git[1] command wrapper - e.g. after defining "alias.last = cat-file commit HEAD", the invocation diff --git a/Documentation/everyday.txt b/Documentation/everyday.txt index 2105a3d..4e83994 100644 --- a/Documentation/everyday.txt +++ b/Documentation/everyday.txt @@ -25,7 +25,7 @@ Basic Repository[[Basic Repository]] Everybody uses these commands to maintain git repositories. - * gitlink:git-init-db[1] or gitlink:git-clone[1] to create a + * gitlink:git-init[1] or gitlink:git-clone[1] to create a new repository. * gitlink:git-fsck-objects[1] to check the repository for errors. @@ -107,7 +107,7 @@ Use a tarball as a starting point for a new repository.:: ------------ $ tar zxf frotz.tar.gz $ cd frotz -$ git-init-db +$ git-init $ git add . <1> $ git commit -m 'import of frotz source tree.' $ git tag v2.43 <2> diff --git a/Documentation/git-am.txt b/Documentation/git-am.txt index 910457d..53e81cb 100644 --- a/Documentation/git-am.txt +++ b/Documentation/git-am.txt @@ -9,7 +9,7 @@ git-am - Apply a series of patches in a mailbox SYNOPSIS -------- [verse] -'git-am' [--signoff] [--dotest=<dir>] [--utf8] [--binary] [--3way] +'git-am' [--signoff] [--dotest=<dir>] [--utf8 | --no-utf8] [--binary] [--3way] [--interactive] [--whitespace=<option>] <mbox>... 'git-am' [--skip | --resolved] @@ -29,8 +29,21 @@ OPTIONS Instead of `.dotest` directory, use <dir> as a working area to store extracted patches. ---utf8, --keep:: - Pass `-u` and `-k` flags to `git-mailinfo` (see +--keep:: + Pass `-k` flag to `git-mailinfo` (see gitlink:git-mailinfo[1]). + +--utf8:: + Pass `-u` flag to `git-mailinfo` (see gitlink:git-mailinfo[1]). + The proposed commit log message taken from the e-mail + are re-coded into UTF-8 encoding (configuration variable + `i18n.commitencoding` can be used to specify project's + preferred encoding if it is not UTF-8). ++ +This was optional in prior versions of git, but now it is the +default. You could use `--no-utf8` to override this. + +--no-utf8:: + Do not pass `-u` flag to `git-mailinfo` (see gitlink:git-mailinfo[1]). --binary:: diff --git a/Documentation/git-cvsimport.txt b/Documentation/git-cvsimport.txt index d21d66b..5c402de 100644 --- a/Documentation/git-cvsimport.txt +++ b/Documentation/git-cvsimport.txt @@ -90,7 +90,8 @@ If you need to pass multiple options, separate them with a comma. Print a short usage message and exit. -z <fuzz>:: - Pass the timestamp fuzz factor to cvsps. + Pass the timestamp fuzz factor to cvsps, in seconds. If unset, + cvsps defaults to 300s. -s <subst>:: Substitute the character "/" in branch names with <subst> @@ -99,6 +100,18 @@ If you need to pass multiple options, separate them with a comma. CVS by default uses the unix username when writing its commit logs. Using this option and an author-conv-file in this format + +-a:: + Import all commits, including recent ones. cvsimport by default + skips commits that have a timestamp less than 10 minutes ago. + +-S <regex>:: + Skip paths matching the regex. + +-L <limit>:: + Limit the number of commits imported. Workaround for cases where + cvsimport leaks memory. + + --------- exon=Andreas Ericsson <ae@op5.se> diff --git a/Documentation/git-init-db.txt b/Documentation/git-init-db.txt index ca7d09d..bc3ba14 100644 --- a/Documentation/git-init-db.txt +++ b/Documentation/git-init-db.txt @@ -74,6 +74,7 @@ Running `git-init-db` in an existing repository is safe. It will not overwrite things that are already there. The primary reason for rerunning `git-init-db` is to pick up newly added templates. +Note that `git-init` is the same as `git-init-db`. EXAMPLES diff --git a/Documentation/git-pack-refs.txt b/Documentation/git-pack-refs.txt index 5da5105..464269f 100644 --- a/Documentation/git-pack-refs.txt +++ b/Documentation/git-pack-refs.txt @@ -7,7 +7,7 @@ git-pack-refs - Pack heads and tags for efficient repository access SYNOPSIS -------- -'git-pack-refs' [--all] [--prune] +'git-pack-refs' [--all] [--no-prune] DESCRIPTION ----------- @@ -40,10 +40,11 @@ developed and packing their tips does not help performance. This option causes branch tips to be packed as well. Useful for a repository with many branches of historical interests. -\--prune:: +\--no-prune:: + +The command usually removes loose refs under `$GIT_DIR/refs` +hierarchy after packing them. This option tells it not to. -After packing the refs, remove loose refs under `$GIT_DIR/refs` -hierarchy. This should probably become default. Author ------ diff --git a/Documentation/git-svn.txt b/Documentation/git-svn.txt index ce63def..8df43cb 100644 --- a/Documentation/git-svn.txt +++ b/Documentation/git-svn.txt @@ -139,6 +139,24 @@ manually joining branches on commit. where the repository URL ends and where the repository path begins. +-T<trunk_subdir>:: +--trunk=<trunk_subdir>:: +-t<tags_subdir>:: +--tags=<tags_subdir>:: +-b<branches_subdir>:: +--branches=<branches_subdir>:: + These are the command-line options for multi-init. Each of + these flags can point to a relative repository path + (--tags=project/tags') or a full url + (--tags=https://foo.org/project/tags) + +--prefix=<prefix> + This allows one to specify a prefix which is prepended to the + names of remotes. The prefix does not automatically include a + trailing slash, so be sure you include one in the argument if + that is what you want. This is useful if you wish to track + multiple projects that share a common repository. + 'multi-fetch':: This runs fetch on all known SVN branches we're tracking. This will NOT discover new branches (unlike git-svnimport), so diff --git a/Documentation/git.txt b/Documentation/git.txt index 36b2126..5662cdc 100644 --- a/Documentation/git.txt +++ b/Documentation/git.txt @@ -353,6 +353,7 @@ gitlink:git-hash-object[1]:: gitlink:git-index-pack[1]:: Build pack idx file for an existing packed archive. +gitlink:git-init[1]:: gitlink:git-init-db[1]:: Creates an empty git object database, or reinitialize an existing one. diff --git a/Documentation/glossary.txt b/Documentation/glossary.txt index 7c1a659..cd61aa2 100644 --- a/Documentation/glossary.txt +++ b/Documentation/glossary.txt @@ -235,8 +235,11 @@ push:: local head, the push fails. reachable:: - An object is reachable from a ref/commit/tree/tag, if there is a - chain leading from the latter to the former. + All of the ancestors of a given commit are said to be reachable from + that commit. More generally, one object is reachable from another if + we can reach the one from the other by a chain that follows tags to + whatever they tag, commits to their parents or trees, and trees to the + trees or blobs that they contain. rebase:: To clean a branch by starting from the head of the main line of diff --git a/Documentation/tutorial-2.txt b/Documentation/tutorial-2.txt index 60e5477..f48894c 100644 --- a/Documentation/tutorial-2.txt +++ b/Documentation/tutorial-2.txt @@ -17,7 +17,7 @@ Let's start a new project and create a small amount of history: ------------------------------------------------ $ mkdir test-project $ cd test-project -$ git init-db +$ git init Initialized empty Git repository in .git/ $ echo 'hello world' > file.txt $ git add . diff --git a/Documentation/tutorial.txt b/Documentation/tutorial.txt index 01d4a47..d2bf0b9 100644 --- a/Documentation/tutorial.txt +++ b/Documentation/tutorial.txt @@ -32,7 +32,7 @@ can place it under git revision control as follows. ------------------------------------------------ $ tar xzf project.tar.gz $ cd project -$ git init-db +$ git init ------------------------------------------------ Git will reply @@ -179,7 +179,7 @@ SCRIPT_SH = \ SCRIPT_PERL = \ git-add--interactive.perl \ git-archimport.perl git-cvsimport.perl git-relink.perl \ - git-cvsserver.perl \ + git-cvsserver.perl git-remote.perl \ git-svnimport.perl git-cvsexportcommit.perl \ git-send-email.perl git-svn.perl @@ -210,7 +210,7 @@ EXTRA_PROGRAMS = BUILT_INS = \ git-format-patch$X git-show$X git-whatchanged$X git-cherry$X \ - git-get-tar-commit-id$X \ + git-get-tar-commit-id$X git-init$X \ $(patsubst builtin-%.o,git-%$X,$(BUILTIN_OBJS)) # what 'all' will build and 'install' will install, in gitexecdir diff --git a/builtin-grep.c b/builtin-grep.c index 3b1b1cb..2bfbdb7 100644 --- a/builtin-grep.c +++ b/builtin-grep.c @@ -136,7 +136,7 @@ static int grep_file(struct grep_opt *opt, const char *filename) if (i < 0) goto err_ret; data = xmalloc(st.st_size + 1); - if (st.st_size != xread(i, data, st.st_size)) { + if (st.st_size != read_in_full(i, data, st.st_size)) { error("'%s': short read %s", filename, strerror(errno)); close(i); free(data); diff --git a/builtin-init-db.c b/builtin-init-db.c index 97fd82f..bbef820 100644 --- a/builtin-init-db.c +++ b/builtin-init-db.c @@ -259,7 +259,7 @@ static int create_default_files(const char *git_dir, const char *template_path) } static const char init_db_usage[] = -"git-init-db [--template=<template-directory>] [--shared]"; +"git-init [--template=<template-directory>] [--shared]"; /* * If you want to, you can share the DB area with any number of branches. diff --git a/builtin-pack-objects.c b/builtin-pack-objects.c index 9e15beb..42dd8c8 100644 --- a/builtin-pack-objects.c +++ b/builtin-pack-objects.c @@ -276,7 +276,52 @@ static int encode_header(enum object_type type, unsigned long size, unsigned cha * we are going to reuse the existing object data as is. make * sure it is not corrupt. */ -static int check_inflate(unsigned char *data, unsigned long len, unsigned long expect) +static int check_pack_inflate(struct packed_git *p, + struct pack_window **w_curs, + unsigned long offset, + unsigned long len, + unsigned long expect) +{ + z_stream stream; + unsigned char fakebuf[4096], *in; + int st; + + memset(&stream, 0, sizeof(stream)); + inflateInit(&stream); + do { + in = use_pack(p, w_curs, offset, &stream.avail_in); + stream.next_in = in; + stream.next_out = fakebuf; + stream.avail_out = sizeof(fakebuf); + st = inflate(&stream, Z_FINISH); + offset += stream.next_in - in; + } while (st == Z_OK || st == Z_BUF_ERROR); + inflateEnd(&stream); + return (st == Z_STREAM_END && + stream.total_out == expect && + stream.total_in == len) ? 0 : -1; +} + +static void copy_pack_data(struct sha1file *f, + struct packed_git *p, + struct pack_window **w_curs, + unsigned long offset, + unsigned long len) +{ + unsigned char *in; + unsigned int avail; + + while (len) { + in = use_pack(p, w_curs, offset, &avail); + if (avail > len) + avail = len; + sha1write(f, in, avail); + offset += avail; + len -= avail; + } +} + +static int check_loose_inflate(unsigned char *data, unsigned long len, unsigned long expect) { z_stream stream; unsigned char fakebuf[4096]; @@ -323,7 +368,7 @@ static int revalidate_loose_object(struct object_entry *entry, return -1; map += used; mapsize -= used; - return check_inflate(map, mapsize, size); + return check_loose_inflate(map, mapsize, size); } static unsigned long write_object(struct sha1file *f, @@ -416,6 +461,8 @@ static unsigned long write_object(struct sha1file *f, } else { struct packed_git *p = entry->in_pack; + struct pack_window *w_curs = NULL; + unsigned long offset; if (entry->delta) { obj_type = (allow_ofs_delta && entry->delta->offset) ? @@ -437,16 +484,14 @@ static unsigned long write_object(struct sha1file *f, hdrlen += 20; } - use_packed_git(p); - buf = (char *) p->pack_base - + entry->in_pack_offset - + entry->in_pack_header_size; + offset = entry->in_pack_offset + entry->in_pack_header_size; datalen = find_packed_object_size(p, entry->in_pack_offset) - entry->in_pack_header_size; - if (!pack_to_stdout && check_inflate(buf, datalen, entry->size)) + if (!pack_to_stdout && check_pack_inflate(p, &w_curs, + offset, datalen, entry->size)) die("corrupt delta in pack %s", sha1_to_hex(entry->sha1)); - sha1write(f, buf, datalen); - unuse_packed_git(p); + copy_pack_data(f, p, &w_curs, offset, datalen); + unuse_pack(&w_curs); reused++; } if (entry->delta) @@ -937,22 +982,19 @@ static void check_object(struct object_entry *entry) if (entry->in_pack && !entry->preferred_base) { struct packed_git *p = entry->in_pack; + struct pack_window *w_curs = NULL; unsigned long left = p->pack_size - entry->in_pack_offset; unsigned long size, used; unsigned char *buf; struct object_entry *base_entry = NULL; - use_packed_git(p); - buf = p->pack_base; - buf += entry->in_pack_offset; + buf = use_pack(p, &w_curs, entry->in_pack_offset, NULL); /* We want in_pack_type even if we do not reuse delta. * There is no point not reusing non-delta representations. */ used = unpack_object_header_gently(buf, left, &entry->in_pack_type, &size); - if (!used || left - used <= 20) - die("corrupt pack for %s", sha1_to_hex(entry->sha1)); /* Check if it is delta, and the base is also an object * we are going to pack. If so we will reuse the existing @@ -961,21 +1003,26 @@ static void check_object(struct object_entry *entry) if (!no_reuse_delta) { unsigned char c, *base_name; unsigned long ofs; + unsigned long used_0; /* there is at least 20 bytes left in the pack */ switch (entry->in_pack_type) { case OBJ_REF_DELTA: - base_name = buf + used; + base_name = use_pack(p, &w_curs, + entry->in_pack_offset + used, NULL); used += 20; break; case OBJ_OFS_DELTA: - c = buf[used++]; + buf = use_pack(p, &w_curs, + entry->in_pack_offset + used, NULL); + used_0 = 0; + c = buf[used_0++]; ofs = c & 127; while (c & 128) { ofs += 1; if (!ofs || ofs & ~(~0UL >> 7)) die("delta base offset overflow in pack for %s", sha1_to_hex(entry->sha1)); - c = buf[used++]; + c = buf[used_0++]; ofs = (ofs << 7) + (c & 127); } if (ofs >= entry->in_pack_offset) @@ -983,6 +1030,7 @@ static void check_object(struct object_entry *entry) sha1_to_hex(entry->sha1)); ofs = entry->in_pack_offset - ofs; base_name = find_packed_object_name(p, ofs); + used += used_0; break; default: base_name = NULL; @@ -990,7 +1038,7 @@ static void check_object(struct object_entry *entry) if (base_name) base_entry = locate_object_entry(base_name); } - unuse_packed_git(p); + unuse_pack(&w_curs); entry->in_pack_header_size = used; if (base_entry) { diff --git a/builtin-pack-refs.c b/builtin-pack-refs.c index 8dc5b9e..6de7128 100644 --- a/builtin-pack-refs.c +++ b/builtin-pack-refs.c @@ -4,7 +4,7 @@ #include "tag.h" static const char builtin_pack_refs_usage[] = -"git-pack-refs [--all] [--prune]"; +"git-pack-refs [--all] [--prune | --no-prune]"; struct ref_to_prune { struct ref_to_prune *next; @@ -90,10 +90,15 @@ int cmd_pack_refs(int argc, const char **argv, const char *prefix) memset(&cbdata, 0, sizeof(cbdata)); + cbdata.prune = 1; for (i = 1; i < argc; i++) { const char *arg = argv[i]; if (!strcmp(arg, "--prune")) { - cbdata.prune = 1; + cbdata.prune = 1; /* now the default */ + continue; + } + if (!strcmp(arg, "--no-prune")) { + cbdata.prune = 0; continue; } if (!strcmp(arg, "--all")) { diff --git a/builtin-rerere.c b/builtin-rerere.c index 079c0bd..318d959 100644 --- a/builtin-rerere.c +++ b/builtin-rerere.c @@ -51,9 +51,11 @@ static int write_rr(struct path_list *rr, int out_fd) int i; for (i = 0; i < rr->nr; i++) { const char *path = rr->items[i].path; - write(out_fd, rr->items[i].util, 40); - write(out_fd, "\t", 1); - write(out_fd, path, strlen(path) + 1); + int length = strlen(path) + 1; + if (write_in_full(out_fd, rr->items[i].util, 40) != 40 || + write_in_full(out_fd, "\t", 1) != 1 || + write_in_full(out_fd, path, length) != length) + die("unable to write rerere record"); } close(out_fd); return commit_lock_file(&write_lock); @@ -244,7 +246,8 @@ static int outf(void *dummy, mmbuffer_t *ptr, int nbuf) { int i; for (i = 0; i < nbuf; i++) - write(1, ptr[i].ptr, ptr[i].size); + if (write_in_full(1, ptr[i].ptr, ptr[i].size) != ptr[i].size) + return -1; return 0; } diff --git a/builtin-tar-tree.c b/builtin-tar-tree.c index 11e62fc..8055dda 100644 --- a/builtin-tar-tree.c +++ b/builtin-tar-tree.c @@ -74,7 +74,7 @@ int cmd_get_tar_commit_id(int argc, const char **argv, const char *prefix) char *content = buffer + RECORDSIZE; ssize_t n; - n = xread(0, buffer, HEADERSIZE); + n = read_in_full(0, buffer, HEADERSIZE); if (n < HEADERSIZE) die("git-get-tar-commit-id: read error"); if (header->typeflag[0] != 'g') @@ -82,7 +82,7 @@ int cmd_get_tar_commit_id(int argc, const char **argv, const char *prefix) if (memcmp(content, "52 comment=", 11)) return 1; - n = xwrite(1, content + 11, 41); + n = write_in_full(1, content + 11, 41); if (n < 41) die("git-get-tar-commit-id: write error"); diff --git a/builtin-upload-archive.c b/builtin-upload-archive.c index e4156f8..48ae09e 100644 --- a/builtin-upload-archive.c +++ b/builtin-upload-archive.c @@ -91,7 +91,7 @@ static void process_input(int child_fd, int band) char buf[16384]; ssize_t sz = read(child_fd, buf, sizeof(buf)); if (sz < 0) { - if (errno != EINTR) + if (errno != EAGAIN && errno != EINTR) error_clnt("read error: %s\n", strerror(errno)); return; } diff --git a/builtin-verify-pack.c b/builtin-verify-pack.c index 7d39d9b..4e31c27 100644 --- a/builtin-verify-pack.c +++ b/builtin-verify-pack.c @@ -55,6 +55,7 @@ int cmd_verify_pack(int argc, const char **argv, const char *prefix) int no_more_options = 0; int nothing_done = 1; + git_config(git_default_config); while (1 < argc) { if (!no_more_options && argv[1][0] == '-') { if (!strcmp("-v", argv[1])) @@ -197,6 +197,8 @@ extern int warn_ambiguous_refs; extern int shared_repository; extern const char *apply_default_whitespace; extern int zlib_compression_level; +extern size_t packed_git_window_size; +extern size_t packed_git_limit; #define GIT_REPO_VERSION 0 extern int repository_format_version; @@ -336,14 +338,22 @@ extern struct alternate_object_database { } *alt_odb_list; extern void prepare_alt_odb(void); +struct pack_window { + struct pack_window *next; + unsigned char *base; + off_t offset; + size_t len; + unsigned int last_used; + unsigned int inuse_cnt; +}; + extern struct packed_git { struct packed_git *next; - unsigned long index_size; - unsigned long pack_size; + struct pack_window *windows; unsigned int *index_base; - void *pack_base; - unsigned int pack_last_used; - unsigned int pack_use_cnt; + off_t index_size; + off_t pack_size; + int pack_fd; int pack_local; unsigned char sha1[20]; /* something like ".git/objects/pack/xxxxx.pack" */ @@ -389,13 +399,14 @@ extern void install_packed_git(struct packed_git *pack); extern struct packed_git *find_sha1_pack(const unsigned char *sha1, struct packed_git *packs); -extern int use_packed_git(struct packed_git *); -extern void unuse_packed_git(struct packed_git *); +extern void pack_report(); +extern unsigned char* use_pack(struct packed_git *, struct pack_window **, unsigned long, unsigned int *); +extern void unuse_pack(struct pack_window **); extern struct packed_git *add_packed_git(char *, int, int); extern int num_packed_objects(const struct packed_git *p); extern int nth_packed_object_sha1(const struct packed_git *, int, unsigned char*); extern unsigned long find_pack_entry_one(const unsigned char *, struct packed_git *); -extern void *unpack_entry_gently(struct packed_git *, unsigned long, char *, unsigned long *); +extern void *unpack_entry(struct packed_git *, unsigned long, char *, unsigned long *); extern unsigned long unpack_object_header_gently(const unsigned char *buf, unsigned long len, enum object_type *type, unsigned long *sizep); extern void packed_object_info_detail(struct packed_git *, unsigned long, char *, unsigned long *, unsigned long *, unsigned int *, unsigned char *); @@ -421,9 +432,12 @@ extern char *git_commit_encoding; extern char *git_log_output_encoding; extern int copy_fd(int ifd, int ofd); -extern int write_in_full(int fd, const void *buf, size_t count, const char *); +extern int read_in_full(int fd, void *buf, size_t count); +extern void read_or_die(int fd, void *buf, size_t count); +extern int write_in_full(int fd, const void *buf, size_t count); extern void write_or_die(int fd, const void *buf, size_t count); extern int write_or_whine(int fd, const void *buf, size_t count, const char *msg); +extern int write_or_whine_pipe(int fd, const void *buf, size_t count, const char *msg); /* pager.c */ extern void setup_pager(void); @@ -249,8 +249,10 @@ int write_shallow_commits(int fd, int use_pack_protocol) if (use_pack_protocol) packet_write(fd, "shallow %s", hex); else { - write(fd, hex, 40); - write(fd, "\n", 1); + if (write_in_full(fd, hex, 40) != 40) + break; + if (write_in_full(fd, "\n", 1) != 1) + break; } } return count; @@ -304,6 +304,21 @@ int git_default_config(const char *var, const char *value) return 0; } + if (!strcmp(var, "core.packedgitwindowsize")) { + int pgsz = getpagesize(); + packed_git_window_size = git_config_int(var, value); + packed_git_window_size /= pgsz; + if (packed_git_window_size < 2) + packed_git_window_size = 2; + packed_git_window_size *= pgsz; + return 0; + } + + if (!strcmp(var, "core.packedgitlimit")) { + packed_git_limit = git_config_int(var, value); + return 0; + } + if (!strcmp(var, "user.name")) { strlcpy(git_default_name, value, sizeof(git_default_name)); return 0; @@ -449,7 +464,15 @@ static int store_aux(const char* key, const char* value) return 0; } -static void store_write_section(int fd, const char* key) +static int write_error() +{ + fprintf(stderr, "Failed to write new configuration file\n"); + + /* Same error code as "failed to rename". */ + return 4; +} + +static int store_write_section(int fd, const char* key) { const char *dot = strchr(key, '.'); int len1 = store.baselen, len2 = -1; @@ -463,37 +486,60 @@ static void store_write_section(int fd, const char* key) } } - write(fd, "[", 1); - write(fd, key, len1); + if (write_in_full(fd, "[", 1) != 1 || + write_in_full(fd, key, len1) != len1) + return 0; if (len2 >= 0) { - write(fd, " \"", 2); + if (write_in_full(fd, " \"", 2) != 2) + return 0; while (--len2 >= 0) { unsigned char c = *++dot; if (c == '"') - write(fd, "\\", 1); - write(fd, &c, 1); + if (write_in_full(fd, "\\", 1) != 1) + return 0; + if (write_in_full(fd, &c, 1) != 1) + return 0; } - write(fd, "\"", 1); + if (write_in_full(fd, "\"", 1) != 1) + return 0; } - write(fd, "]\n", 2); + if (write_in_full(fd, "]\n", 2) != 2) + return 0; + + return 1; } -static void store_write_pair(int fd, const char* key, const char* value) +static int store_write_pair(int fd, const char* key, const char* value) { int i; + int length = strlen(key+store.baselen+1); - write(fd, "\t", 1); - write(fd, key+store.baselen+1, - strlen(key+store.baselen+1)); - write(fd, " = ", 3); + if (write_in_full(fd, "\t", 1) != 1 || + write_in_full(fd, key+store.baselen+1, length) != length || + write_in_full(fd, " = ", 3) != 3) + return 0; for (i = 0; value[i]; i++) switch (value[i]) { - case '\n': write(fd, "\\n", 2); break; - case '\t': write(fd, "\\t", 2); break; - case '"': case '\\': write(fd, "\\", 1); - default: write(fd, value+i, 1); - } - write(fd, "\n", 1); + case '\n': + if (write_in_full(fd, "\\n", 2) != 2) + return 0; + break; + case '\t': + if (write_in_full(fd, "\\t", 2) != 2) + return 0; + break; + case '"': + case '\\': + if (write_in_full(fd, "\\", 1) != 1) + return 0; + default: + if (write_in_full(fd, value+i, 1) != 1) + return 0; + break; + } + if (write_in_full(fd, "\n", 1) != 1) + return 0; + return 1; } static int find_beginning_of_line(const char* contents, int size, @@ -633,8 +679,11 @@ int git_config_set_multivar(const char* key, const char* value, } store.key = (char*)key; - store_write_section(fd, key); - store_write_pair(fd, key, value); + if (!store_write_section(fd, key) || + !store_write_pair(fd, key, value)) { + ret = write_error(); + goto out_free; + } } else{ struct stat st; char* contents; @@ -695,7 +744,7 @@ int git_config_set_multivar(const char* key, const char* value, } fstat(in_fd, &st); - contents = mmap(NULL, st.st_size, PROT_READ, + contents = xmmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, in_fd, 0); close(in_fd); @@ -714,10 +763,10 @@ int git_config_set_multivar(const char* key, const char* value, /* write the first part of the config */ if (copy_end > copy_begin) { - write(fd, contents + copy_begin, + write_in_full(fd, contents + copy_begin, copy_end - copy_begin); if (new_line) - write(fd, "\n", 1); + write_in_full(fd, "\n", 1); } copy_begin = store.offset[i]; } @@ -725,13 +774,19 @@ int git_config_set_multivar(const char* key, const char* value, /* write the pair (value == NULL means unset) */ if (value != NULL) { if (store.state == START) - store_write_section(fd, key); - store_write_pair(fd, key, value); + if (!store_write_section(fd, key)) { + ret = write_error(); + goto out_free; + } + if (!store_write_pair(fd, key, value)) { + ret = write_error(); + goto out_free; + } } /* write the rest of the config */ if (copy_begin < st.st_size) - write(fd, contents + copy_begin, + write_in_full(fd, contents + copy_begin, st.st_size - copy_begin); munmap(contents, st.st_size); @@ -785,6 +840,7 @@ int git_config_rename_section(const char *old_name, const char *new_name) while (fgets(buf, sizeof(buf), config_file)) { int i; + int length; for (i = 0; buf[i] && isspace(buf[i]); i++) ; /* do nothing */ if (buf[i] == '[') { @@ -815,15 +871,22 @@ int git_config_rename_section(const char *old_name, const char *new_name) /* old_name matches */ ret++; store.baselen = strlen(new_name); - store_write_section(out_fd, new_name); + if (!store_write_section(out_fd, new_name)) { + ret = write_error(); + goto out; + } continue; } } - write(out_fd, buf, strlen(buf)); + length = strlen(buf); + if (write_in_full(out_fd, buf, length) != length) { + ret = write_error(); + goto out; + } } fclose(config_file); if (close(out_fd) || commit_lock_file(lock) < 0) - ret = error("Cannot commit config file!"); + ret = error("Cannot commit config file!"); out: free(config_filename); return ret; @@ -102,7 +102,7 @@ static void logreport(int priority, const char *err, va_list params) buf[buflen++] = '\n'; buf[buflen] = '\0'; - write(2, buf, buflen); + write_in_full(2, buf, buflen); } static void logerror(const char *err, ...) @@ -97,7 +97,7 @@ int run_diff_files(struct rev_info *revs, int silent_on_removed) * Show the diff for the 'ce' if we found the one * from the desired stage. */ - diff_unmerge(&revs->diffopt, ce->name); + diff_unmerge(&revs->diffopt, ce->name, 0, null_sha1); if (ce_stage(ce) != diff_unmerged_stage) continue; } @@ -297,9 +297,12 @@ static int diff_cache(struct rev_info *revs, !show_modified(revs, ce, ac[1], 0, cached, match_missing)) break; - /* fallthru */ + diff_unmerge(&revs->diffopt, ce->name, + ntohl(ce->ce_mode), ce->sha1); + break; case 3: - diff_unmerge(&revs->diffopt, ce->name); + diff_unmerge(&revs->diffopt, ce->name, + 0, null_sha1); break; default: @@ -1341,10 +1341,8 @@ int diff_populate_filespec(struct diff_filespec *s, int size_only) fd = open(s->path, O_RDONLY); if (fd < 0) goto err_empty; - s->data = mmap(NULL, s->size, PROT_READ, MAP_PRIVATE, fd, 0); + s->data = xmmap(NULL, s->size, PROT_READ, MAP_PRIVATE, fd, 0); close(fd); - if (s->data == MAP_FAILED) - goto err_empty; s->should_munmap = 1; } else { @@ -1391,7 +1389,7 @@ static void prep_temp_blob(struct diff_tempfile *temp, fd = git_mkstemp(temp->tmp_path, TEMPFILE_PATH_LEN, ".diff_XXXXXX"); if (fd < 0) die("unable to create temp-file"); - if (write(fd, blob, size) != size) + if (write_in_full(fd, blob, size) != size) die("unable to write temp-file"); close(fd); temp->name = temp->tmp_path; @@ -2875,10 +2873,12 @@ void diff_change(struct diff_options *options, } void diff_unmerge(struct diff_options *options, - const char *path) + const char *path, + unsigned mode, const unsigned char *sha1) { struct diff_filespec *one, *two; one = alloc_filespec(path); two = alloc_filespec(path); - diff_queue(&diff_queued_diff, one, two); + fill_filespec(one, sha1, mode); + diff_queue(&diff_queued_diff, one, two)->is_unmerged = 1; } @@ -144,7 +144,9 @@ extern void diff_change(struct diff_options *, const char *base, const char *path); extern void diff_unmerge(struct diff_options *, - const char *path); + const char *path, + unsigned mode, + const unsigned char *sha1); extern int diff_scoreopt_parse(const char *opt); @@ -54,9 +54,9 @@ struct diff_filepair { unsigned source_stays : 1; /* all of R/C are copies */ unsigned broken_pair : 1; unsigned renamed_pair : 1; + unsigned is_unmerged : 1; }; -#define DIFF_PAIR_UNMERGED(p) \ - (!DIFF_FILE_VALID((p)->one) && !DIFF_FILE_VALID((p)->two)) +#define DIFF_PAIR_UNMERGED(p) ((p)->is_unmerged) #define DIFF_PAIR_RENAME(p) ((p)->renamed_pair) @@ -142,7 +142,7 @@ static int add_excludes_from_file_1(const char *fname, return 0; } buf = xmalloc(size+1); - if (read(fd, buf, size) != size) + if (read_in_full(fd, buf, size) != size) goto err; close(fd); @@ -89,7 +89,7 @@ static int write_entry(struct cache_entry *ce, char *path, struct checkout *stat return error("git-checkout-index: unable to create file %s (%s)", path, strerror(errno)); } - wrote = write(fd, new, size); + wrote = write_in_full(fd, new, size); close(fd); free(new); if (wrote != size) @@ -104,7 +104,7 @@ static int write_entry(struct cache_entry *ce, char *path, struct checkout *stat return error("git-checkout-index: unable to create " "file %s (%s)", path, strerror(errno)); } - wrote = write(fd, new, size); + wrote = write_in_full(fd, new, size); close(fd); free(new); if (wrote != size) diff --git a/environment.c b/environment.c index a1502c4..09976c7 100644 --- a/environment.c +++ b/environment.c @@ -23,6 +23,8 @@ char *git_log_output_encoding; int shared_repository = PERM_UMASK; const char *apply_default_whitespace; int zlib_compression_level = Z_DEFAULT_COMPRESSION; +size_t packed_git_window_size = DEFAULT_PACKED_GIT_WINDOW_SIZE; +size_t packed_git_limit = DEFAULT_PACKED_GIT_LIMIT; int pager_in_use; int pager_use_color = 1; @@ -2,7 +2,7 @@ # # Copyright (c) 2005, 2006 Junio C Hamano -USAGE='[--signoff] [--dotest=<dir>] [--utf8] [--binary] [--3way] +USAGE='[--signoff] [--dotest=<dir>] [--utf8 | --no-utf8] [--binary] [--3way] [--interactive] [--whitespace=<option>] <mbox>... or, when resuming [--skip | --resolved]' . git-sh-setup @@ -105,7 +105,7 @@ It does not apply to blobs recorded in its index." } prec=4 -dotest=.dotest sign= utf8= keep= skip= interactive= resolved= binary= ws= resolvemsg= +dotest=.dotest sign= utf8=t keep= skip= interactive= resolved= binary= ws= resolvemsg= while case "$#" in 0) break;; esac do @@ -128,7 +128,9 @@ do -s|--s|--si|--sig|--sign|--signo|--signof|--signoff) sign=t; shift ;; -u|--u|--ut|--utf|--utf8) - utf8=t; shift ;; + shift ;; # this is now default + --no-u|--no-ut|--no-utf|--no-utf8) + utf8=; shift ;; -k|--k|--ke|--kee|--keep) keep=t; shift ;; diff --git a/git-commit.sh b/git-commit.sh index 04aad5e..c2beb76 100755 --- a/git-commit.sh +++ b/git-commit.sh @@ -628,7 +628,7 @@ then if test -z "$quiet" then echo "Created${initial_commit:+ initial} commit $commit" - git-diff-tree --shortstat --summary --root --no-commit-id HEAD + git-diff-tree --shortstat --summary --root --no-commit-id HEAD -- fi fi diff --git a/git-compat-util.h b/git-compat-util.h index 5d9eb26..e023bf1 100644 --- a/git-compat-util.h +++ b/git-compat-util.h @@ -92,12 +92,21 @@ extern void set_warn_routine(void (*routine)(const char *warn, va_list params)); extern void *git_mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset); extern int git_munmap(void *start, size_t length); +#define DEFAULT_PACKED_GIT_WINDOW_SIZE (1 * 1024 * 1024) + #else /* NO_MMAP */ #include <sys/mman.h> +#define DEFAULT_PACKED_GIT_WINDOW_SIZE \ + (sizeof(void*) >= 8 \ + ? 1 * 1024 * 1024 * 1024 \ + : 32 * 1024 * 1024) #endif /* NO_MMAP */ +#define DEFAULT_PACKED_GIT_LIMIT \ + ((1024L * 1024L) * (sizeof(void*) >= 8 ? 8192 : 256)) + #ifdef NO_SETENV #define setenv gitsetenv extern int gitsetenv(const char *, const char *, int); @@ -118,11 +127,17 @@ extern char *gitstrcasestr(const char *haystack, const char *needle); extern size_t gitstrlcpy(char *, const char *, size_t); #endif +extern void release_pack_memory(size_t); + static inline char* xstrdup(const char *str) { char *ret = strdup(str); - if (!ret) - die("Out of memory, strdup failed"); + if (!ret) { + release_pack_memory(strlen(str) + 1); + ret = strdup(str); + if (!ret) + die("Out of memory, strdup failed"); + } return ret; } @@ -131,8 +146,14 @@ static inline void *xmalloc(size_t size) void *ret = malloc(size); if (!ret && !size) ret = malloc(1); - if (!ret) - die("Out of memory, malloc failed"); + if (!ret) { + release_pack_memory(size); + ret = malloc(size); + if (!ret && !size) + ret = malloc(1); + if (!ret) + die("Out of memory, malloc failed"); + } #ifdef XMALLOC_POISON memset(ret, 0xA5, size); #endif @@ -144,8 +165,14 @@ static inline void *xrealloc(void *ptr, size_t size) void *ret = realloc(ptr, size); if (!ret && !size) ret = realloc(ptr, 1); - if (!ret) - die("Out of memory, realloc failed"); + if (!ret) { + release_pack_memory(size); + ret = realloc(ptr, size); + if (!ret && !size) + ret = realloc(ptr, 1); + if (!ret) + die("Out of memory, realloc failed"); + } return ret; } @@ -154,8 +181,27 @@ static inline void *xcalloc(size_t nmemb, size_t size) void *ret = calloc(nmemb, size); if (!ret && (!nmemb || !size)) ret = calloc(1, 1); - if (!ret) - die("Out of memory, calloc failed"); + if (!ret) { + release_pack_memory(nmemb * size); + ret = calloc(nmemb, size); + if (!ret && (!nmemb || !size)) + ret = calloc(1, 1); + if (!ret) + die("Out of memory, calloc failed"); + } + return ret; +} + +static inline void *xmmap(void *start, size_t length, + int prot, int flags, int fd, off_t offset) +{ + void *ret = mmap(start, length, prot, flags, fd, offset); + if (ret == MAP_FAILED) { + release_pack_memory(length); + ret = mmap(start, length, prot, flags, fd, offset); + if (ret == MAP_FAILED) + die("Out of memory? mmap failed: %s", strerror(errno)); + } return ret; } diff --git a/git-cvsimport.perl b/git-cvsimport.perl index c5bf2d1..1018f4f 100755 --- a/git-cvsimport.perl +++ b/git-cvsimport.perl @@ -29,7 +29,7 @@ use IPC::Open2; $SIG{'PIPE'}="IGNORE"; $ENV{'TZ'}="UTC"; -our ($opt_h,$opt_o,$opt_v,$opt_k,$opt_u,$opt_d,$opt_p,$opt_C,$opt_z,$opt_i,$opt_P, $opt_s,$opt_m,$opt_M,$opt_A,$opt_S,$opt_L); +our ($opt_h,$opt_o,$opt_v,$opt_k,$opt_u,$opt_d,$opt_p,$opt_C,$opt_z,$opt_i,$opt_P, $opt_s,$opt_m,$opt_M,$opt_A,$opt_S,$opt_L, $opt_a); my (%conv_author_name, %conv_author_email); sub usage() { @@ -37,7 +37,7 @@ sub usage() { Usage: ${\basename $0} # fetch/update GIT from CVS [-o branch-for-HEAD] [-h] [-v] [-d CVSROOT] [-A author-conv-file] [-p opts-for-cvsps] [-C GIT_repository] [-z fuzz] [-i] [-k] [-u] - [-s subst] [-m] [-M regex] [-S regex] [CVS_module] + [-s subst] [-a] [-m] [-M regex] [-S regex] [CVS_module] END exit(1); } @@ -105,6 +105,8 @@ if ($opt_d) { } $opt_o ||= "origin"; $opt_s ||= "-"; +$opt_a ||= 0; + my $git_tree = $opt_C; $git_tree ||= "."; @@ -129,6 +131,11 @@ if ($opt_M) { push (@mergerx, qr/$opt_M/); } +# Remember UTC of our starting time +# we'll want to avoid importing commits +# that are too recent +our $starttime = time(); + select(STDERR); $|=1; select(STDOUT); @@ -568,9 +575,11 @@ if ($opt_A) { # run cvsps into a file unless we are getting # it passed as a file via $opt_P # +my $cvspsfile; unless ($opt_P) { print "Running cvsps...\n" if $opt_v; my $pid = open(CVSPS,"-|"); + my $cvspsfh; die "Cannot fork: $!\n" unless defined $pid; unless ($pid) { my @opt; @@ -583,18 +592,18 @@ unless ($opt_P) { exec("cvsps","--norc",@opt,"-u","-A",'--root',$opt_d,$cvs_tree); die "Could not start cvsps: $!\n"; } - my ($cvspsfh, $cvspsfile) = tempfile('gitXXXXXX', SUFFIX => '.cvsps', - DIR => File::Spec->tmpdir()); + ($cvspsfh, $cvspsfile) = tempfile('gitXXXXXX', SUFFIX => '.cvsps', + DIR => File::Spec->tmpdir()); while (<CVSPS>) { print $cvspsfh $_; } close CVSPS; close $cvspsfh; - $opt_P = $cvspsfile; +} else { + $cvspsfile = $opt_P; } - -open(CVS, "<$opt_P") or die $!; +open(CVS, "<$cvspsfile") or die $!; ## cvsps output: #--------------------- @@ -824,6 +833,15 @@ while (<CVS>) { $state = 11; next; } + if (!$opt_a && $starttime - 300 - (defined $opt_z ? $opt_z : 300) <= $date) { + # skip if the commit is too recent + # that the cvsps default fuzz is 300s, we give ourselves another + # 300s just in case -- this also prevents skipping commits + # due to server clock drift + print "skip patchset $patchset: $date too recent\n" if $opt_v; + $state = 11; + next; + } if (exists $ignorebranch{$branch}) { print STDERR "Skipping $branch\n"; $state = 11; @@ -920,6 +938,10 @@ while (<CVS>) { } commit() if $branch and $state != 11; +unless ($opt_P) { + unlink($cvspsfile); +} + # The heuristic of repacking every 1024 commits can leave a # lot of unpacked data. If there is more than 1MB worth of # not-packed objects, repack once more. diff --git a/git-remote.perl b/git-remote.perl new file mode 100755 index 0000000..059c141 --- /dev/null +++ b/git-remote.perl @@ -0,0 +1,277 @@ +#!/usr/bin/perl -w + +use Git; +my $git = Git->repository(); + +sub add_remote_config { + my ($hash, $name, $what, $value) = @_; + if ($what eq 'url') { + if (exists $hash->{$name}{'URL'}) { + print STDERR "Warning: more than one remote.$name.url\n"; + } + $hash->{$name}{'URL'} = $value; + } + elsif ($what eq 'fetch') { + $hash->{$name}{'FETCH'} ||= []; + push @{$hash->{$name}{'FETCH'}}, $value; + } + if (!exists $hash->{$name}{'SOURCE'}) { + $hash->{$name}{'SOURCE'} = 'config'; + } +} + +sub add_remote_remotes { + my ($hash, $file, $name) = @_; + + if (exists $hash->{$name}) { + $hash->{$name}{'WARNING'} = 'ignored due to config'; + return; + } + + my $fh; + if (!open($fh, '<', $file)) { + print STDERR "Warning: cannot open $file\n"; + return; + } + my $it = { 'SOURCE' => 'remotes' }; + $hash->{$name} = $it; + while (<$fh>) { + chomp; + if (/^URL:\s*(.*)$/) { + # Having more than one is Ok -- it is used for push. + if (! exists $it->{'URL'}) { + $it->{'URL'} = $1; + } + } + elsif (/^Push:\s*(.*)$/) { + ; # later + } + elsif (/^Pull:\s*(.*)$/) { + $it->{'FETCH'} ||= []; + push @{$it->{'FETCH'}}, $1; + } + elsif (/^\#/) { + ; # ignore + } + else { + print STDERR "Warning: funny line in $file: $_\n"; + } + } + close($fh); +} + +sub list_remote { + my ($git) = @_; + my %seen = (); + my @remotes = eval { + $git->command(qw(repo-config --get-regexp), '^remote\.'); + }; + for (@remotes) { + if (/^remote\.([^.]*)\.(\S*)\s+(.*)$/) { + add_remote_config(\%seen, $1, $2, $3); + } + } + + my $dir = $git->repo_path() . "/remotes"; + if (opendir(my $dh, $dir)) { + local $_; + while ($_ = readdir($dh)) { + chomp; + next if (! -f "$dir/$_" || ! -r _); + add_remote_remotes(\%seen, "$dir/$_", $_); + } + } + + return \%seen; +} + +sub add_branch_config { + my ($hash, $name, $what, $value) = @_; + if ($what eq 'remote') { + if (exists $hash->{$name}{'REMOTE'}) { + print STDERR "Warning: more than one branch.$name.remote\n"; + } + $hash->{$name}{'REMOTE'} = $value; + } + elsif ($what eq 'merge') { + $hash->{$name}{'MERGE'} ||= []; + push @{$hash->{$name}{'MERGE'}}, $value; + } +} + +sub list_branch { + my ($git) = @_; + my %seen = (); + my @branches = eval { + $git->command(qw(repo-config --get-regexp), '^branch\.'); + }; + for (@branches) { + if (/^branch\.([^.]*)\.(\S*)\s+(.*)$/) { + add_branch_config(\%seen, $1, $2, $3); + } + } + + return \%seen; +} + +my $remote = list_remote($git); +my $branch = list_branch($git); + +sub update_ls_remote { + my ($harder, $info) = @_; + + return if (($harder == 0) || + (($harder == 1) && exists $info->{'LS_REMOTE'})); + + my @ref = map { + s|^[0-9a-f]{40}\s+refs/heads/||; + $_; + } $git->command(qw(ls-remote --heads), $info->{'URL'}); + $info->{'LS_REMOTE'} = \@ref; +} + +sub show_wildcard_mapping { + my ($forced, $ours, $ls) = @_; + my %refs; + for (@$ls) { + $refs{$_} = 01; # bit #0 to say "they have" + } + for ($git->command('for-each-ref', "refs/remotes/$ours")) { + chomp; + next unless (s|^[0-9a-f]{40}\s[a-z]+\srefs/remotes/$ours/||); + next if ($_ eq 'HEAD'); + $refs{$_} ||= 0; + $refs{$_} |= 02; # bit #1 to say "we have" + } + my (@new, @stale, @tracked); + for (sort keys %refs) { + my $have = $refs{$_}; + if ($have == 1) { + push @new, $_; + } + elsif ($have == 2) { + push @stale, $_; + } + elsif ($have == 3) { + push @tracked, $_; + } + } + if (@new) { + print " New remote branches (next fetch will store in remotes/$ours)\n"; + print " @new\n"; + } + if (@stale) { + print " Stale tracking branches in remotes/$ours (you'd better remove them)\n"; + print " @stale\n"; + } + if (@tracked) { + print " Tracked remote branches\n"; + print " @tracked\n"; + } +} + +sub show_mapping { + my ($name, $info) = @_; + my $fetch = $info->{'FETCH'}; + my $ls = $info->{'LS_REMOTE'}; + my (@stale, @tracked); + + for (@$fetch) { + next unless (/(\+)?([^:]+):(.*)/); + my ($forced, $theirs, $ours) = ($1, $2, $3); + if ($theirs eq 'refs/heads/*' && + $ours =~ /^refs\/remotes\/(.*)\/\*$/) { + # wildcard mapping + show_wildcard_mapping($forced, $1, $ls); + } + elsif ($theirs =~ /\*/ || $ours =~ /\*/) { + print STDERR "Warning: unrecognized mapping in remotes.$name.fetch: $_\n"; + } + elsif ($theirs =~ s|^refs/heads/||) { + if (!grep { $_ eq $theirs } @$ls) { + push @stale, $theirs; + } + elsif ($ours ne '') { + push @tracked, $theirs; + } + } + } + if (@stale) { + print " Stale tracking branches in remotes/$name (you'd better remove them)\n"; + print " @stale\n"; + } + if (@tracked) { + print " Tracked remote branches\n"; + print " @tracked\n"; + } +} + +sub show_remote { + my ($name, $ls_remote) = @_; + if (!exists $remote->{$name}) { + print STDERR "No such remote $name\n"; + return; + } + my $info = $remote->{$name}; + update_ls_remote($ls_remote, $info); + + print "* remote $name\n"; + print " URL: $info->{'URL'}\n"; + for my $branchname (sort keys %$branch) { + next if ($branch->{$branchname}{'REMOTE'} ne $name); + my @merged = map { + s|^refs/heads/||; + $_; + } split(' ',"@{$branch->{$branchname}{'MERGE'}}"); + next unless (@merged); + print " Remote branch(es) merged with 'git pull' while on branch $branchname\n"; + print " @merged\n"; + } + if ($info->{'LS_REMOTE'}) { + show_mapping($name, $info); + } +} + +sub add_remote { + my ($name, $url) = @_; + if (exists $remote->{$name}) { + print STDERR "remote $name already exists.\n"; + exit(1); + } + $git->command('repo-config', "remote.$name.url", $url); + $git->command('repo-config', "remote.$name.fetch", + "+refs/heads/*:refs/remotes/$name/*"); +} + +if (!@ARGV) { + for (sort keys %$remote) { + print "$_\n"; + } +} +elsif ($ARGV[0] eq 'show') { + my $ls_remote = 1; + my $i; + for ($i = 1; $i < @ARGV; $i++) { + if ($ARGV[$i] eq '-n') { + $ls_remote = 0; + } + else { + last; + } + } + if ($i >= @ARGV) { + print STDERR "Usage: git remote show <remote>\n"; + exit(1); + } + for (; $i < @ARGV; $i++) { + show_remote($ARGV[$i], $ls_remote); + } +} +elsif ($ARGV[0] eq 'add') { + if (@ARGV != 3) { + print STDERR "Usage: git remote add <name> <url>\n"; + exit(1); + } + add_remote($ARGV[1], $ARGV[2]); +} + diff --git a/git-reset.sh b/git-reset.sh index a969370..76c8a81 100755 --- a/git-reset.sh +++ b/git-reset.sh @@ -44,8 +44,10 @@ if test $# != 0 then test "$reset_type" == "--mixed" || die "Cannot do partial $reset_type reset." - git ls-tree -r --full-name $rev -- "$@" | - git update-index --add --index-info || exit + + git-diff-index --cached $rev -- "$@" | + sed -e 's/^:\([0-7][0-7]*\) [0-7][0-7]* \([0-9a-f][0-9a-f]*\) [0-9a-f][0-9a-f]* [A-Z] \(.*\)$/\1 \2 \3/' | + git update-index --add --remove --index-info || exit git update-index --refresh exit fi diff --git a/git-svn.perl b/git-svn.perl index 1da31fd..56f1700 100755 --- a/git-svn.perl +++ b/git-svn.perl @@ -70,7 +70,7 @@ my ($_revision,$_stdin,$_no_ignore_ext,$_no_stop_copy,$_help,$_rmdir,$_edit, $_version, $_upgrade, $_authors, $_branch_all_refs, @_opt_m, $_merge, $_strategy, $_dry_run, $_ignore_nodate, $_non_recursive, $_username, $_config_dir, $_no_auth_cache, - $_pager, $_color); + $_pager, $_color, $_prefix); my (@_branch_from, %tree_map, %users, %rusers, %equiv); my ($_svn_can_do_switch); my @repo_path_split_cache; @@ -134,6 +134,7 @@ my %cmd = ( 'username=s' => \$_username, 'config-dir=s' => \$_config_dir, 'no-auth-cache' => \$_no_auth_cache, + 'prefix=s' => \$_prefix, } ], 'multi-fetch' => [ \&multi_fetch, 'Fetch multiple trees (like git-svnimport)', @@ -595,8 +596,9 @@ sub multi_init { command_noisy('repo-config', 'svn.trunk', $trunk_url); } } - complete_url_ls_init($url, $_branches, '--branches/-b', ''); - complete_url_ls_init($url, $_tags, '--tags/-t', 'tags/'); + $_prefix = '' unless defined $_prefix; + complete_url_ls_init($url, $_branches, '--branches/-b', $_prefix); + complete_url_ls_init($url, $_tags, '--tags/-t', $_prefix . 'tags/'); } sub multi_fetch { @@ -1084,7 +1086,7 @@ sub graft_merge_msg { my ($grafts, $l_map, $u, $p, @re) = @_; my $x = $l_map->{$u}->{$p}; - my $rl = rev_list_raw($x); + my $rl = rev_list_raw("refs/remotes/$x"); while (my $c = next_rev_list_entry($rl)) { foreach my $re (@re) { my (@br) = ($c->{m} =~ /$re/g); diff --git a/git-svnimport.perl b/git-svnimport.perl index afbbe63..f1f1a7d 100755 --- a/git-svnimport.perl +++ b/git-svnimport.perl @@ -943,10 +943,10 @@ if ($opt_l < $current_rev) { print "Processing from $current_rev to $opt_l ...\n" if $opt_v; my $from_rev; -my $to_rev = $current_rev; +my $to_rev = $current_rev - 1; while ($to_rev < $opt_l) { - $from_rev = $to_rev; + $from_rev = $to_rev + 1; $to_rev = $from_rev + $repack_after; $to_rev = $opt_l if $opt_l < $to_rev; print "Fetching from $from_rev to $to_rev ...\n" if $opt_v; @@ -231,6 +231,7 @@ static void handle_internal_command(int argc, const char **argv, char **envp) { "get-tar-commit-id", cmd_get_tar_commit_id }, { "grep", cmd_grep, RUN_SETUP }, { "help", cmd_help }, + { "init", cmd_init_db }, { "init-db", cmd_init_db }, { "log", cmd_log, RUN_SETUP | USE_PAGER }, { "ls-files", cmd_ls_files, RUN_SETUP }, diff --git a/gitweb/gitweb.perl b/gitweb/gitweb.perl index f46a422..25e5079 100755 --- a/gitweb/gitweb.perl +++ b/gitweb/gitweb.perl @@ -2239,7 +2239,7 @@ sub git_difftree_body { } print $cgi->a({-href => href(action=>"blob", hash=>$diff{'to_id'}, hash_base=>$hash, file_name=>$diff{'file'})}, - "blob") . " | "; + "blob"); print "</td>\n"; } elsif ($diff{'status'} eq "D") { # deleted diff --git a/http-fetch.c b/http-fetch.c index 396552d..fe8cd7b 100644 --- a/http-fetch.c +++ b/http-fetch.c @@ -71,7 +71,7 @@ static size_t fwrite_sha1_file(void *ptr, size_t eltsize, size_t nmemb, int posn = 0; struct object_request *obj_req = (struct object_request *)data; do { - ssize_t retval = write(obj_req->local, + ssize_t retval = xwrite(obj_req->local, (char *) ptr + posn, size - posn); if (retval < 0) return posn; @@ -175,7 +175,7 @@ static void start_object_request(struct object_request *obj_req) prevlocal = open(prevfile, O_RDONLY); if (prevlocal != -1) { do { - prev_read = read(prevlocal, prev_buf, PREV_BUF_SIZE); + prev_read = xread(prevlocal, prev_buf, PREV_BUF_SIZE); if (prev_read>0) { if (fwrite_sha1_file(prev_buf, 1, diff --git a/http-push.c b/http-push.c index ecefdfd..7e73eac 100644 --- a/http-push.c +++ b/http-push.c @@ -195,7 +195,7 @@ static size_t fwrite_sha1_file(void *ptr, size_t eltsize, size_t nmemb, int posn = 0; struct transfer_request *request = (struct transfer_request *)data; do { - ssize_t retval = write(request->local_fileno, + ssize_t retval = xwrite(request->local_fileno, (char *) ptr + posn, size - posn); if (retval < 0) return posn; @@ -288,7 +288,7 @@ static void start_fetch_loose(struct transfer_request *request) prevlocal = open(prevfile, O_RDONLY); if (prevlocal != -1) { do { - prev_read = read(prevlocal, prev_buf, PREV_BUF_SIZE); + prev_read = xread(prevlocal, prev_buf, PREV_BUF_SIZE); if (prev_read>0) { if (fwrite_sha1_file(prev_buf, 1, diff --git a/imap-send.c b/imap-send.c index ad91858..3eaf025 100644 --- a/imap-send.c +++ b/imap-send.c @@ -224,7 +224,7 @@ socket_perror( const char *func, Socket_t *sock, int ret ) static int socket_read( Socket_t *sock, char *buf, int len ) { - int n = read( sock->fd, buf, len ); + int n = xread( sock->fd, buf, len ); if (n <= 0) { socket_perror( "read", sock, n ); close( sock->fd ); @@ -236,7 +236,7 @@ socket_read( Socket_t *sock, char *buf, int len ) static int socket_write( Socket_t *sock, const char *buf, int len ) { - int n = write( sock->fd, buf, len ); + int n = write_in_full( sock->fd, buf, len ); if (n != len) { socket_perror( "write", sock, n ); close( sock->fd ); @@ -390,7 +390,7 @@ arc4_init( void ) fprintf( stderr, "Fatal: no random number source available.\n" ); exit( 3 ); } - if (read( fd, dat, 128 ) != 128) { + if (read_in_full( fd, dat, 128 ) != 128) { fprintf( stderr, "Fatal: cannot read random number source.\n" ); exit( 3 ); } diff --git a/index-pack.c b/index-pack.c index 5f6d128..8d10d6b 100644 --- a/index-pack.c +++ b/index-pack.c @@ -638,7 +638,7 @@ static void readjust_pack_header_and_sha1(unsigned char *sha1) /* Rewrite pack header with updated object number */ if (lseek(output_fd, 0, SEEK_SET) != 0) die("cannot seek back: %s", strerror(errno)); - if (xread(output_fd, &hdr, sizeof(hdr)) != sizeof(hdr)) + if (read_in_full(output_fd, &hdr, sizeof(hdr)) != sizeof(hdr)) die("cannot read pack header back: %s", strerror(errno)); hdr.hdr_entries = htonl(nr_objects); if (lseek(output_fd, 0, SEEK_SET) != 0) @@ -814,7 +814,7 @@ static void final(const char *final_pack_name, const char *curr_pack_name, char buf[48]; int len = snprintf(buf, sizeof(buf), "%s\t%s\n", report, sha1_to_hex(sha1)); - xwrite(1, buf, len); + write_in_full(1, buf, len); /* * Let's just mimic git-unpack-objects here and write diff --git a/local-fetch.c b/local-fetch.c index 7b6875c..cf99cb7 100644 --- a/local-fetch.c +++ b/local-fetch.c @@ -184,7 +184,7 @@ int fetch_ref(char *ref, unsigned char *sha1) fprintf(stderr, "cannot open %s\n", filename); return -1; } - if (read(ifd, hex, 40) != 40 || get_sha1_hex(hex, sha1)) { + if (read_in_full(ifd, hex, 40) != 40 || get_sha1_hex(hex, sha1)) { close(ifd); fprintf(stderr, "cannot read from %s\n", filename); return -1; diff --git a/merge-recursive.c b/merge-recursive.c index bac16f5..87a27e0 100644 --- a/merge-recursive.c +++ b/merge-recursive.c @@ -517,7 +517,7 @@ static int mkdir_p(const char *path, unsigned long mode) static void flush_buffer(int fd, const char *buf, unsigned long size) { while (size > 0) { - long ret = xwrite(fd, buf, size); + long ret = write_in_full(fd, buf, size); if (ret < 0) { /* Ignore epipe */ if (errno == EPIPE) diff --git a/pack-check.c b/pack-check.c index 8e123b7..08a9fd8 100644 --- a/pack-check.c +++ b/pack-check.c @@ -1,55 +1,45 @@ #include "cache.h" #include "pack.h" -#define BATCH (1u<<20) - -static int verify_packfile(struct packed_git *p) +static int verify_packfile(struct packed_git *p, + struct pack_window **w_curs) { unsigned long index_size = p->index_size; void *index_base = p->index_base; SHA_CTX ctx; unsigned char sha1[20]; - struct pack_header *hdr; + unsigned long offset = 0, pack_sig = p->pack_size - 20; int nr_objects, err, i; - unsigned char *packdata; - unsigned long datasize; - - /* Header consistency check */ - hdr = p->pack_base; - if (hdr->hdr_signature != htonl(PACK_SIGNATURE)) - return error("Packfile %s signature mismatch", p->pack_name); - if (!pack_version_ok(hdr->hdr_version)) - return error("Packfile version %d unsupported", - ntohl(hdr->hdr_version)); - nr_objects = ntohl(hdr->hdr_entries); - if (num_packed_objects(p) != nr_objects) - return error("Packfile claims to have %d objects, " - "while idx size expects %d", nr_objects, - num_packed_objects(p)); - - /* Check integrity of pack data with its SHA-1 checksum */ + + /* Note that the pack header checks are actually performed by + * use_pack when it first opens the pack file. If anything + * goes wrong during those checks then the call will die out + * immediately. + */ + SHA1_Init(&ctx); - packdata = p->pack_base; - datasize = p->pack_size - 20; - while (datasize) { - unsigned long batch = (datasize < BATCH) ? datasize : BATCH; - SHA1_Update(&ctx, packdata, batch); - datasize -= batch; - packdata += batch; + while (offset < pack_sig) { + unsigned int remaining; + unsigned char *in = use_pack(p, w_curs, offset, &remaining); + offset += remaining; + if (offset > pack_sig) + remaining -= offset - pack_sig; + SHA1_Update(&ctx, in, remaining); } SHA1_Final(sha1, &ctx); - - if (hashcmp(sha1, (unsigned char *)(p->pack_base) + p->pack_size - 20)) + if (hashcmp(sha1, use_pack(p, w_curs, pack_sig, NULL))) return error("Packfile %s SHA1 mismatch with itself", p->pack_name); if (hashcmp(sha1, (unsigned char *)index_base + index_size - 40)) return error("Packfile %s SHA1 mismatch with idx", p->pack_name); + unuse_pack(w_curs); /* Make sure everything reachable from idx is valid. Since we * have verified that nr_objects matches between idx and pack, * we do not do scan-streaming check on the pack file. */ + nr_objects = num_packed_objects(p); for (i = err = 0; i < nr_objects; i++) { unsigned char sha1[20]; void *data; @@ -61,7 +51,7 @@ static int verify_packfile(struct packed_git *p) offset = find_pack_entry_one(sha1, p); if (!offset) die("internal error pack-check find-pack-entry-one"); - data = unpack_entry_gently(p, offset, type, &size); + data = unpack_entry(p, offset, type, &size); if (!data) { err = error("cannot unpack %s from %s", sha1_to_hex(sha1), p->pack_name); @@ -84,12 +74,10 @@ static int verify_packfile(struct packed_git *p) static void show_pack_info(struct packed_git *p) { - struct pack_header *hdr; int nr_objects, i; unsigned int chain_histogram[MAX_CHAIN]; - hdr = p->pack_base; - nr_objects = ntohl(hdr->hdr_entries); + nr_objects = num_packed_objects(p); memset(chain_histogram, 0, sizeof(chain_histogram)); for (i = 0; i < nr_objects; i++) { @@ -152,18 +140,16 @@ int verify_pack(struct packed_git *p, int verbose) if (!ret) { /* Verify pack file */ - use_packed_git(p); - ret = verify_packfile(p); - unuse_packed_git(p); + struct pack_window *w_curs = NULL; + ret = verify_packfile(p, &w_curs); + unuse_pack(&w_curs); } if (verbose) { if (ret) printf("%s: bad\n", p->pack_name); else { - use_packed_git(p); show_pack_info(p); - unuse_packed_git(p); printf("%s: ok\n", p->pack_name); } } @@ -113,7 +113,7 @@ int validate_symref(const char *path) fd = open(path, O_RDONLY); if (fd < 0) return -1; - len = read(fd, buffer, sizeof(buffer)-1); + len = read_in_full(fd, buffer, sizeof(buffer)-1); close(fd); /* diff --git a/read-cache.c b/read-cache.c index b8d83cc..8ecd826 100644 --- a/read-cache.c +++ b/read-cache.c @@ -793,16 +793,16 @@ int read_cache_from(const char *path) die("index file open failed (%s)", strerror(errno)); } - cache_mmap = MAP_FAILED; if (!fstat(fd, &st)) { cache_mmap_size = st.st_size; errno = EINVAL; if (cache_mmap_size >= sizeof(struct cache_header) + 20) - cache_mmap = mmap(NULL, cache_mmap_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0); - } + cache_mmap = xmmap(NULL, cache_mmap_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0); + else + die("index file smaller than expected"); + } else + die("cannot stat the open index (%s)", strerror(errno)); close(fd); - if (cache_mmap == MAP_FAILED) - die("index file mmap failed (%s)", strerror(errno)); hdr = cache_mmap; if (verify_hdr(hdr, cache_mmap_size) < 0) @@ -870,7 +870,7 @@ static int ce_write_flush(SHA_CTX *context, int fd) unsigned int buffered = write_buffer_len; if (buffered) { SHA1_Update(context, write_buffer, buffered); - if (write(fd, write_buffer, buffered) != buffered) + if (write_in_full(fd, write_buffer, buffered) != buffered) return -1; write_buffer_len = 0; } @@ -919,7 +919,7 @@ static int ce_flush(SHA_CTX *context, int fd) /* Flush first if not enough space for SHA1 signature */ if (left + 20 > WRITE_BUFFER_SIZE) { - if (write(fd, write_buffer, left) != left) + if (write_in_full(fd, write_buffer, left) != left) return -1; left = 0; } @@ -927,7 +927,7 @@ static int ce_flush(SHA_CTX *context, int fd) /* Append the SHA1 signature at the end */ SHA1_Final(write_buffer + left, context); left += 20; - return (write(fd, write_buffer, left) != left) ? -1 : 0; + return (write_in_full(fd, write_buffer, left) != left) ? -1 : 0; } static void ce_smudge_racily_clean_entry(struct cache_entry *ce) @@ -284,7 +284,7 @@ const char *resolve_ref(const char *ref, unsigned char *sha1, int reading, int * fd = open(path, O_RDONLY); if (fd < 0) return NULL; - len = read(fd, buffer, sizeof(buffer)-1); + len = read_in_full(fd, buffer, sizeof(buffer)-1); close(fd); /* @@ -332,7 +332,7 @@ int create_symref(const char *ref_target, const char *refs_heads_master) } lockpath = mkpath("%s.lock", git_HEAD); fd = open(lockpath, O_CREAT | O_EXCL | O_WRONLY, 0666); - written = write(fd, ref, len); + written = write_in_full(fd, ref, len); close(fd); if (written != len) { unlink(lockpath); @@ -968,7 +968,7 @@ static int log_ref_write(struct ref_lock *lock, sha1_to_hex(sha1), committer); } - written = len <= maxlen ? write(logfd, logrec, len) : -1; + written = len <= maxlen ? write_in_full(logfd, logrec, len) : -1; free(logrec); close(logfd); if (written != len) @@ -987,8 +987,8 @@ int write_ref_sha1(struct ref_lock *lock, unlock_ref(lock); return 0; } - if (write(lock->lock_fd, sha1_to_hex(sha1), 40) != 40 || - write(lock->lock_fd, &term, 1) != 1 + if (write_in_full(lock->lock_fd, sha1_to_hex(sha1), 40) != 40 || + write_in_full(lock->lock_fd, &term, 1) != 1 || close(lock->lock_fd) < 0) { error("Couldn't write %s", lock->lk->filename); unlock_ref(lock); @@ -1025,7 +1025,7 @@ int read_ref_at(const char *ref, unsigned long at_time, int cnt, unsigned char * fstat(logfd, &st); if (!st.st_size) die("Log %s is empty.", logfile); - logdata = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, logfd, 0); + logdata = xmmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, logfd, 0); close(logfd); lastrec = NULL; diff --git a/send-pack.c b/send-pack.c index c195d08..6756264 100644 --- a/send-pack.c +++ b/send-pack.c @@ -65,14 +65,14 @@ static int pack_objects(int fd, struct ref *refs) memcpy(buf + 1, sha1_to_hex(refs->old_sha1), 40); buf[0] = '^'; buf[41] = '\n'; - if (!write_in_full(pipe_fd[1], buf, 42, + if (!write_or_whine(pipe_fd[1], buf, 42, "send-pack: send refs")) break; } if (!is_null_sha1(refs->new_sha1)) { memcpy(buf, sha1_to_hex(refs->new_sha1), 40); buf[40] = '\n'; - if (!write_in_full(pipe_fd[1], buf, 41, + if (!write_or_whine(pipe_fd[1], buf, 41, "send-pack: send refs")) break; } diff --git a/sha1_file.c b/sha1_file.c index 1c4df5b..095a7e1 100644 --- a/sha1_file.c +++ b/sha1_file.c @@ -355,10 +355,8 @@ static void read_info_alternates(const char * relative_base, int depth) close(fd); return; } - map = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0); + map = xmmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0); close(fd); - if (map == MAP_FAILED) - return; link_alt_odb_entries(map, map + st.st_size, '\n', relative_base, depth); @@ -397,11 +395,35 @@ static char *find_sha1_file(const unsigned char *sha1, struct stat *st) return NULL; } -#define PACK_MAX_SZ (1<<26) -static int pack_used_ctr; -static unsigned long pack_mapped; +static unsigned int pack_used_ctr; +static unsigned int pack_mmap_calls; +static unsigned int peak_pack_open_windows; +static unsigned int pack_open_windows; +static size_t peak_pack_mapped; +static size_t pack_mapped; +static size_t page_size; struct packed_git *packed_git; +void pack_report() +{ + fprintf(stderr, + "pack_report: getpagesize() = %10lu\n" + "pack_report: core.packedGitWindowSize = %10lu\n" + "pack_report: core.packedGitLimit = %10lu\n", + page_size, + packed_git_window_size, + packed_git_limit); + fprintf(stderr, + "pack_report: pack_used_ctr = %10u\n" + "pack_report: pack_mmap_calls = %10u\n" + "pack_report: pack_open_windows = %10u / %10u\n" + "pack_report: pack_mapped = %10lu / %10lu\n", + pack_used_ctr, + pack_mmap_calls, + pack_open_windows, peak_pack_open_windows, + pack_mapped, peak_pack_mapped); +} + static int check_packed_git_idx(const char *path, unsigned long *idx_size_, void **idx_map_) { @@ -418,10 +440,8 @@ static int check_packed_git_idx(const char *path, unsigned long *idx_size_, return -1; } idx_size = st.st_size; - idx_map = mmap(NULL, idx_size, PROT_READ, MAP_PRIVATE, fd, 0); + idx_map = xmmap(NULL, idx_size, PROT_READ, MAP_PRIVATE, fd, 0); close(fd); - if (idx_map == MAP_FAILED) - return -1; index = idx_map; *idx_map_ = idx_map; @@ -451,86 +471,198 @@ static int check_packed_git_idx(const char *path, unsigned long *idx_size_, return 0; } -static int unuse_one_packed_git(void) +static void scan_windows(struct packed_git *p, + struct packed_git **lru_p, + struct pack_window **lru_w, + struct pack_window **lru_l) { - struct packed_git *p, *lru = NULL; + struct pack_window *w, *w_l; - for (p = packed_git; p; p = p->next) { - if (p->pack_use_cnt || !p->pack_base) - continue; - if (!lru || p->pack_last_used < lru->pack_last_used) - lru = p; + for (w_l = NULL, w = p->windows; w; w = w->next) { + if (!w->inuse_cnt) { + if (!*lru_w || w->last_used < (*lru_w)->last_used) { + *lru_p = p; + *lru_w = w; + *lru_l = w_l; + } + } + w_l = w; } - if (!lru) - return 0; - munmap(lru->pack_base, lru->pack_size); - lru->pack_base = NULL; - return 1; } -void unuse_packed_git(struct packed_git *p) +static int unuse_one_window(struct packed_git *current) +{ + struct packed_git *p, *lru_p = NULL; + struct pack_window *lru_w = NULL, *lru_l = NULL; + + if (current) + scan_windows(current, &lru_p, &lru_w, &lru_l); + for (p = packed_git; p; p = p->next) + scan_windows(p, &lru_p, &lru_w, &lru_l); + if (lru_p) { + munmap(lru_w->base, lru_w->len); + pack_mapped -= lru_w->len; + if (lru_l) + lru_l->next = lru_w->next; + else { + lru_p->windows = lru_w->next; + if (!lru_p->windows && lru_p != current) { + close(lru_p->pack_fd); + lru_p->pack_fd = -1; + } + } + free(lru_w); + pack_open_windows--; + return 1; + } + return 0; +} + +void release_pack_memory(size_t need) { - p->pack_use_cnt--; + size_t cur = pack_mapped; + while (need >= (cur - pack_mapped) && unuse_one_window(NULL)) + ; /* nothing */ +} + +void unuse_pack(struct pack_window **w_cursor) +{ + struct pack_window *w = *w_cursor; + if (w) { + w->inuse_cnt--; + *w_cursor = NULL; + } } -int use_packed_git(struct packed_git *p) +static void open_packed_git(struct packed_git *p) { + struct stat st; + struct pack_header hdr; + unsigned char sha1[20]; + unsigned char *idx_sha1; + long fd_flag; + + p->pack_fd = open(p->pack_name, O_RDONLY); + if (p->pack_fd < 0 || fstat(p->pack_fd, &st)) + die("packfile %s cannot be opened", p->pack_name); + + /* If we created the struct before we had the pack we lack size. */ if (!p->pack_size) { - struct stat st; - /* We created the struct before we had the pack */ - stat(p->pack_name, &st); if (!S_ISREG(st.st_mode)) die("packfile %s not a regular file", p->pack_name); p->pack_size = st.st_size; - } - if (!p->pack_base) { - int fd; - struct stat st; - void *map; - struct pack_header *hdr; - - pack_mapped += p->pack_size; - while (PACK_MAX_SZ < pack_mapped && unuse_one_packed_git()) - ; /* nothing */ - fd = open(p->pack_name, O_RDONLY); - if (fd < 0) - die("packfile %s cannot be opened", p->pack_name); - if (fstat(fd, &st)) { - close(fd); - die("packfile %s cannot be opened", p->pack_name); - } - if (st.st_size != p->pack_size) - die("packfile %s size mismatch.", p->pack_name); - map = mmap(NULL, p->pack_size, PROT_READ, MAP_PRIVATE, fd, 0); - close(fd); - if (map == MAP_FAILED) - die("packfile %s cannot be mapped.", p->pack_name); - p->pack_base = map; + } else if (p->pack_size != st.st_size) + die("packfile %s size changed", p->pack_name); - /* Check if we understand this pack file. If we don't we're - * likely too old to handle it. - */ - hdr = map; - if (hdr->hdr_signature != htonl(PACK_SIGNATURE)) - die("packfile %s isn't actually a pack.", p->pack_name); - if (!pack_version_ok(hdr->hdr_version)) - die("packfile %s is version %i and not supported" - " (try upgrading GIT to a newer version)", - p->pack_name, ntohl(hdr->hdr_version)); - - /* Check if the pack file matches with the index file. - * this is cheap. - */ - if (hashcmp((unsigned char *)(p->index_base) + - p->index_size - 40, - (unsigned char *)p->pack_base + - p->pack_size - 20)) { - die("packfile %s does not match index.", p->pack_name); + /* We leave these file descriptors open with sliding mmap; + * there is no point keeping them open across exec(), though. + */ + fd_flag = fcntl(p->pack_fd, F_GETFD, 0); + if (fd_flag < 0) + die("cannot determine file descriptor flags"); + fd_flag |= FD_CLOEXEC; + if (fcntl(p->pack_fd, F_SETFD, fd_flag) == -1) + die("cannot set FD_CLOEXEC"); + + /* Verify we recognize this pack file format. */ + read_or_die(p->pack_fd, &hdr, sizeof(hdr)); + if (hdr.hdr_signature != htonl(PACK_SIGNATURE)) + die("file %s is not a GIT packfile", p->pack_name); + if (!pack_version_ok(hdr.hdr_version)) + die("packfile %s is version %u and not supported" + " (try upgrading GIT to a newer version)", + p->pack_name, ntohl(hdr.hdr_version)); + + /* Verify the pack matches its index. */ + if (num_packed_objects(p) != ntohl(hdr.hdr_entries)) + die("packfile %s claims to have %u objects" + " while index size indicates %u objects", + p->pack_name, ntohl(hdr.hdr_entries), + num_packed_objects(p)); + if (lseek(p->pack_fd, p->pack_size - sizeof(sha1), SEEK_SET) == -1) + die("end of packfile %s is unavailable", p->pack_name); + read_or_die(p->pack_fd, sha1, sizeof(sha1)); + idx_sha1 = ((unsigned char *)p->index_base) + p->index_size - 40; + if (hashcmp(sha1, idx_sha1)) + die("packfile %s does not match index", p->pack_name); +} + +static int in_window(struct pack_window *win, unsigned long offset) +{ + /* We must promise at least 20 bytes (one hash) after the + * offset is available from this window, otherwise the offset + * is not actually in this window and a different window (which + * has that one hash excess) must be used. This is to support + * the object header and delta base parsing routines below. + */ + off_t win_off = win->offset; + return win_off <= offset + && (offset + 20) <= (win_off + win->len); +} + +unsigned char* use_pack(struct packed_git *p, + struct pack_window **w_cursor, + unsigned long offset, + unsigned int *left) +{ + struct pack_window *win = *w_cursor; + + if (p->pack_fd == -1) + open_packed_git(p); + + /* Since packfiles end in a hash of their content and its + * pointless to ask for an offset into the middle of that + * hash, and the in_window function above wouldn't match + * don't allow an offset too close to the end of the file. + */ + if (offset > (p->pack_size - 20)) + die("offset beyond end of packfile (truncated pack?)"); + + if (!win || !in_window(win, offset)) { + if (win) + win->inuse_cnt--; + for (win = p->windows; win; win = win->next) { + if (in_window(win, offset)) + break; + } + if (!win) { + if (!page_size) + page_size = getpagesize(); + win = xcalloc(1, sizeof(*win)); + win->offset = (offset / page_size) * page_size; + win->len = p->pack_size - win->offset; + if (win->len > packed_git_window_size) + win->len = packed_git_window_size; + pack_mapped += win->len; + while (packed_git_limit < pack_mapped + && unuse_one_window(p)) + ; /* nothing */ + win->base = xmmap(NULL, win->len, + PROT_READ, MAP_PRIVATE, + p->pack_fd, win->offset); + if (win->base == MAP_FAILED) + die("packfile %s cannot be mapped: %s", + p->pack_name, + strerror(errno)); + pack_mmap_calls++; + pack_open_windows++; + if (pack_mapped > peak_pack_mapped) + peak_pack_mapped = pack_mapped; + if (pack_open_windows > peak_pack_open_windows) + peak_pack_open_windows = pack_open_windows; + win->next = p->windows; + p->windows = win; } } - p->pack_last_used = pack_used_ctr++; - p->pack_use_cnt++; - return 0; + if (win != *w_cursor) { + win->last_used = pack_used_ctr++; + win->inuse_cnt++; + *w_cursor = win; + } + offset -= win->offset; + if (left) + *left = win->len - offset; + return win->base + offset; } struct packed_git *add_packed_git(char *path, int path_len, int local) @@ -559,9 +691,8 @@ struct packed_git *add_packed_git(char *path, int path_len, int local) p->pack_size = st.st_size; p->index_base = idx_map; p->next = NULL; - p->pack_base = NULL; - p->pack_last_used = 0; - p->pack_use_cnt = 0; + p->windows = NULL; + p->pack_fd = -1; p->pack_local = local; if ((path_len > 44) && !get_sha1_hex(path + path_len - 44, sha1)) hashcpy(p->sha1, sha1); @@ -592,9 +723,8 @@ struct packed_git *parse_pack_index_file(const unsigned char *sha1, char *idx_pa p->pack_size = 0; p->index_base = idx_map; p->next = NULL; - p->pack_base = NULL; - p->pack_last_used = 0; - p->pack_use_cnt = 0; + p->windows = NULL; + p->pack_fd = -1; hashcpy(p->sha1, sha1); return p; } @@ -705,10 +835,8 @@ void *map_sha1_file(const unsigned char *sha1, unsigned long *size) */ sha1_file_open_flag = 0; } - map = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0); + map = xmmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0); close(fd); - if (map == MAP_FAILED) - return NULL; *size = st.st_size; return map; } @@ -878,18 +1006,21 @@ void * unpack_sha1_file(void *map, unsigned long mapsize, char *type, unsigned l } static unsigned long get_delta_base(struct packed_git *p, + struct pack_window **w_curs, unsigned long offset, enum object_type kind, unsigned long delta_obj_offset, unsigned long *base_obj_offset) { - unsigned char *base_info = (unsigned char *) p->pack_base + offset; + unsigned char *base_info = use_pack(p, w_curs, offset, NULL); unsigned long base_offset; - /* there must be at least 20 bytes left regardless of delta type */ - if (p->pack_size <= offset + 20) - die("truncated pack file"); - + /* use_pack() assured us we have [base_info, base_info + 20) + * as a range that we can look at without walking off the + * end of the mapped window. Its actually the hash size + * that is assured. An OFS_DELTA longer than the hash size + * is stupid, as then a REF_DELTA would be smaller to store. + */ if (kind == OBJ_OFS_DELTA) { unsigned used = 0; unsigned char c = base_info[used++]; @@ -923,6 +1054,7 @@ static int packed_object_info(struct packed_git *p, unsigned long offset, char *type, unsigned long *sizep); static int packed_delta_info(struct packed_git *p, + struct pack_window **w_curs, unsigned long offset, enum object_type kind, unsigned long obj_offset, @@ -931,7 +1063,8 @@ static int packed_delta_info(struct packed_git *p, { unsigned long base_offset; - offset = get_delta_base(p, offset, kind, obj_offset, &base_offset); + offset = get_delta_base(p, w_curs, offset, kind, + obj_offset, &base_offset); /* We choose to only get the type of the base object and * ignore potentially corrupt pack file that expects the delta @@ -943,20 +1076,23 @@ static int packed_delta_info(struct packed_git *p, if (sizep) { const unsigned char *data; - unsigned char delta_head[20]; + unsigned char delta_head[20], *in; unsigned long result_size; z_stream stream; int st; memset(&stream, 0, sizeof(stream)); - - stream.next_in = (unsigned char *) p->pack_base + offset; - stream.avail_in = p->pack_size - offset; stream.next_out = delta_head; stream.avail_out = sizeof(delta_head); inflateInit(&stream); - st = inflate(&stream, Z_FINISH); + do { + in = use_pack(p, w_curs, offset, &stream.avail_in); + stream.next_in = in; + st = inflate(&stream, Z_FINISH); + offset += stream.next_in - in; + } while ((st == Z_OK || st == Z_BUF_ERROR) + && stream.total_out < sizeof(delta_head)); inflateEnd(&stream); if ((st != Z_STREAM_END) && stream.total_out != sizeof(delta_head)) @@ -977,17 +1113,24 @@ static int packed_delta_info(struct packed_git *p, return 0; } -static unsigned long unpack_object_header(struct packed_git *p, unsigned long offset, - enum object_type *type, unsigned long *sizep) +static unsigned long unpack_object_header(struct packed_git *p, + struct pack_window **w_curs, + unsigned long offset, + enum object_type *type, + unsigned long *sizep) { + unsigned char *base; + unsigned int left; unsigned long used; - if (p->pack_size <= offset) - die("object offset outside of pack file"); - - used = unpack_object_header_gently((unsigned char *)p->pack_base + - offset, - p->pack_size - offset, type, sizep); + /* use_pack() assures us we have [base, base + 20) available + * as a range that we can look at at. (Its actually the hash + * size that is assurred.) With our object header encoding + * the maximum deflated object size is 2^137, which is just + * insane, so we know won't exceed what we have been given. + */ + base = use_pack(p, w_curs, offset, &left); + used = unpack_object_header_gently(base, left, type, sizep); if (!used) die("object offset outside of pack file"); @@ -1002,13 +1145,14 @@ void packed_object_info_detail(struct packed_git *p, unsigned int *delta_chain_length, unsigned char *base_sha1) { + struct pack_window *w_curs = NULL; unsigned long obj_offset, val; unsigned char *next_sha1; enum object_type kind; *delta_chain_length = 0; obj_offset = offset; - offset = unpack_object_header(p, offset, &kind, size); + offset = unpack_object_header(p, &w_curs, offset, &kind, size); for (;;) { switch (kind) { @@ -1021,25 +1165,24 @@ void packed_object_info_detail(struct packed_git *p, case OBJ_TAG: strcpy(type, type_names[kind]); *store_size = 0; /* notyet */ + unuse_pack(&w_curs); return; case OBJ_OFS_DELTA: - get_delta_base(p, offset, kind, obj_offset, &offset); + get_delta_base(p, &w_curs, offset, kind, + obj_offset, &offset); if (*delta_chain_length == 0) { /* TODO: find base_sha1 as pointed by offset */ } break; case OBJ_REF_DELTA: - if (p->pack_size <= offset + 20) - die("pack file %s records an incomplete delta base", - p->pack_name); - next_sha1 = (unsigned char *) p->pack_base + offset; + next_sha1 = use_pack(p, &w_curs, offset, NULL); if (*delta_chain_length == 0) hashcpy(base_sha1, next_sha1); offset = find_pack_entry_one(next_sha1, p); break; } obj_offset = offset; - offset = unpack_object_header(p, offset, &kind, &val); + offset = unpack_object_header(p, &w_curs, offset, &kind, &val); (*delta_chain_length)++; } } @@ -1047,20 +1190,26 @@ void packed_object_info_detail(struct packed_git *p, static int packed_object_info(struct packed_git *p, unsigned long offset, char *type, unsigned long *sizep) { + struct pack_window *w_curs = NULL; unsigned long size, obj_offset = offset; enum object_type kind; + int r; - offset = unpack_object_header(p, offset, &kind, &size); + offset = unpack_object_header(p, &w_curs, offset, &kind, &size); switch (kind) { case OBJ_OFS_DELTA: case OBJ_REF_DELTA: - return packed_delta_info(p, offset, kind, obj_offset, type, sizep); + r = packed_delta_info(p, &w_curs, offset, kind, + obj_offset, type, sizep); + unuse_pack(&w_curs); + return r; case OBJ_COMMIT: case OBJ_TREE: case OBJ_BLOB: case OBJ_TAG: strcpy(type, type_names[kind]); + unuse_pack(&w_curs); break; default: die("pack %s contains unknown object type %d", @@ -1072,23 +1221,27 @@ static int packed_object_info(struct packed_git *p, unsigned long offset, } static void *unpack_compressed_entry(struct packed_git *p, + struct pack_window **w_curs, unsigned long offset, unsigned long size) { int st; z_stream stream; - unsigned char *buffer; + unsigned char *buffer, *in; buffer = xmalloc(size + 1); buffer[size] = 0; memset(&stream, 0, sizeof(stream)); - stream.next_in = (unsigned char*)p->pack_base + offset; - stream.avail_in = p->pack_size - offset; stream.next_out = buffer; stream.avail_out = size; inflateInit(&stream); - st = inflate(&stream, Z_FINISH); + do { + in = use_pack(p, w_curs, offset, &stream.avail_in); + stream.next_in = in; + st = inflate(&stream, Z_FINISH); + offset += stream.next_in - in; + } while (st == Z_OK || st == Z_BUF_ERROR); inflateEnd(&stream); if ((st != Z_STREAM_END) || stream.total_out != size) { free(buffer); @@ -1099,6 +1252,7 @@ static void *unpack_compressed_entry(struct packed_git *p, } static void *unpack_delta_entry(struct packed_git *p, + struct pack_window **w_curs, unsigned long offset, unsigned long delta_size, enum object_type kind, @@ -1109,13 +1263,14 @@ static void *unpack_delta_entry(struct packed_git *p, void *delta_data, *result, *base; unsigned long result_size, base_size, base_offset; - offset = get_delta_base(p, offset, kind, obj_offset, &base_offset); - base = unpack_entry_gently(p, base_offset, type, &base_size); + offset = get_delta_base(p, w_curs, offset, kind, + obj_offset, &base_offset); + base = unpack_entry(p, base_offset, type, &base_size); if (!base) die("failed to read delta base object at %lu from %s", base_offset, p->pack_name); - delta_data = unpack_compressed_entry(p, offset, delta_size); + delta_data = unpack_compressed_entry(p, w_curs, offset, delta_size); result = patch_delta(base, base_size, delta_data, delta_size, &result_size); @@ -1127,43 +1282,34 @@ static void *unpack_delta_entry(struct packed_git *p, return result; } -static void *unpack_entry(struct pack_entry *entry, - char *type, unsigned long *sizep) -{ - struct packed_git *p = entry->p; - void *retval; - - if (use_packed_git(p)) - die("cannot map packed file"); - retval = unpack_entry_gently(p, entry->offset, type, sizep); - unuse_packed_git(p); - if (!retval) - die("corrupted pack file %s", p->pack_name); - return retval; -} - -/* The caller is responsible for use_packed_git()/unuse_packed_git() pair */ -void *unpack_entry_gently(struct packed_git *p, unsigned long offset, +void *unpack_entry(struct packed_git *p, unsigned long offset, char *type, unsigned long *sizep) { + struct pack_window *w_curs = NULL; unsigned long size, obj_offset = offset; enum object_type kind; + void *retval; - offset = unpack_object_header(p, offset, &kind, &size); + offset = unpack_object_header(p, &w_curs, offset, &kind, &size); switch (kind) { case OBJ_OFS_DELTA: case OBJ_REF_DELTA: - return unpack_delta_entry(p, offset, size, kind, obj_offset, type, sizep); + retval = unpack_delta_entry(p, &w_curs, offset, size, + kind, obj_offset, type, sizep); + break; case OBJ_COMMIT: case OBJ_TREE: case OBJ_BLOB: case OBJ_TAG: strcpy(type, type_names[kind]); *sizep = size; - return unpack_compressed_entry(p, offset, size); + retval = unpack_compressed_entry(p, &w_curs, offset, size); + break; default: - return NULL; + die("unknown object type %i in %s", kind, p->pack_name); } + unuse_pack(&w_curs); + return retval; } int num_packed_objects(const struct packed_git *p) @@ -1289,7 +1435,6 @@ static int sha1_loose_object_info(const unsigned char *sha1, char *type, unsigne int sha1_object_info(const unsigned char *sha1, char *type, unsigned long *sizep) { - int status; struct pack_entry e; if (!find_pack_entry(sha1, &e, NULL)) { @@ -1297,11 +1442,7 @@ int sha1_object_info(const unsigned char *sha1, char *type, unsigned long *sizep if (!find_pack_entry(sha1, &e, NULL)) return sha1_loose_object_info(sha1, type, sizep); } - if (use_packed_git(e.p)) - die("cannot map packed file"); - status = packed_object_info(e.p, e.offset, type, sizep); - unuse_packed_git(e.p); - return status; + return packed_object_info(e.p, e.offset, type, sizep); } static void *read_packed_sha1(const unsigned char *sha1, char *type, unsigned long *size) @@ -1312,7 +1453,7 @@ static void *read_packed_sha1(const unsigned char *sha1, char *type, unsigned lo error("cannot read sha1_file for %s", sha1_to_hex(sha1)); return NULL; } - return unpack_entry(&e, type, size); + return unpack_entry(e.p, e.offset, type, size); } void * read_sha1_file(const unsigned char *sha1, char *type, unsigned long *size) @@ -1470,20 +1611,13 @@ int move_temp_to_file(const char *tmpfile, const char *filename) static int write_buffer(int fd, const void *buf, size_t len) { - while (len) { - ssize_t size; + ssize_t size; - size = write(fd, buf, len); - if (!size) - return error("file write: disk full"); - if (size < 0) { - if (errno == EINTR || errno == EAGAIN) - continue; - return error("file write error (%s)", strerror(errno)); - } - len -= size; - buf = (char *) buf + size; - } + size = write_in_full(fd, buf, len); + if (!size) + return error("file write: disk full"); + if (size < 0) + return error("file write error (%s)", strerror(errno)); return 0; } @@ -1728,7 +1862,7 @@ int write_sha1_from_fd(const unsigned char *sha1, int fd, char *buffer, if (ret != Z_OK) break; } - size = read(fd, buffer + *bufposn, bufsize - *bufposn); + size = xread(fd, buffer + *bufposn, bufsize - *bufposn); if (size <= 0) { close(local); unlink(tmpfile); @@ -1851,10 +1985,8 @@ int index_fd(unsigned char *sha1, int fd, struct stat *st, int write_object, con buf = ""; if (size) - buf = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0); + buf = xmmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0); close(fd); - if (buf == MAP_FAILED) - return -1; if (!type) type = blob_type; diff --git a/ssh-fetch.c b/ssh-fetch.c index b006c5c..4c172b6 100644 --- a/ssh-fetch.c +++ b/ssh-fetch.c @@ -20,22 +20,6 @@ static int fd_out; static unsigned char remote_version; static unsigned char local_version = 1; -static ssize_t force_write(int fd, void *buffer, size_t length) -{ - ssize_t ret = 0; - while (ret < length) { - ssize_t size = write(fd, (char *) buffer + ret, length - ret); - if (size < 0) { - return size; - } - if (size == 0) { - return ret; - } - ret += size; - } - return ret; -} - static int prefetches; static struct object_list *in_transit; @@ -53,8 +37,9 @@ void prefetch(unsigned char *sha1) node->item = lookup_unknown_object(sha1); *end_of_transit = node; end_of_transit = &node->next; - force_write(fd_out, &type, 1); - force_write(fd_out, sha1, 20); + /* XXX: what if these writes fail? */ + write_in_full(fd_out, &type, 1); + write_in_full(fd_out, sha1, 20); prefetches++; } @@ -82,7 +67,7 @@ int fetch(unsigned char *sha1) remote = conn_buf[0]; memmove(conn_buf, conn_buf + 1, --conn_buf_posn); } else { - if (read(fd_in, &remote, 1) < 1) + if (xread(fd_in, &remote, 1) < 1) return -1; } /* fprintf(stderr, "Got %d\n", remote); */ @@ -97,9 +82,11 @@ int fetch(unsigned char *sha1) static int get_version(void) { char type = 'v'; - write(fd_out, &type, 1); - write(fd_out, &local_version, 1); - if (read(fd_in, &remote_version, 1) < 1) { + if (write_in_full(fd_out, &type, 1) != 1 || + write_in_full(fd_out, &local_version, 1)) { + return error("Couldn't request version from remote end"); + } + if (xread(fd_in, &remote_version, 1) < 1) { return error("Couldn't read version from remote end"); } return 0; @@ -109,12 +96,17 @@ int fetch_ref(char *ref, unsigned char *sha1) { signed char remote; char type = 'r'; - write(fd_out, &type, 1); - write(fd_out, ref, strlen(ref) + 1); - read(fd_in, &remote, 1); + int length = strlen(ref) + 1; + if (write_in_full(fd_out, &type, 1) != 1 || + write_in_full(fd_out, ref, length) != length) + return -1; + + if (read_in_full(fd_in, &remote, 1) != 1) + return -1; if (remote < 0) return remote; - read(fd_in, sha1, 20); + if (read_in_full(fd_in, sha1, 20) != 20) + return -1; return 0; } diff --git a/ssh-upload.c b/ssh-upload.c index 0b52ae1..2f04572 100644 --- a/ssh-upload.c +++ b/ssh-upload.c @@ -21,17 +21,14 @@ static int serve_object(int fd_in, int fd_out) { ssize_t size; unsigned char sha1[20]; signed char remote; - int posn = 0; - do { - size = read(fd_in, sha1 + posn, 20 - posn); - if (size < 0) { - perror("git-ssh-upload: read "); - return -1; - } - if (!size) - return -1; - posn += size; - } while (posn < 20); + + size = read_in_full(fd_in, sha1, 20); + if (size < 0) { + perror("git-ssh-upload: read "); + return -1; + } + if (!size) + return -1; if (verbose) fprintf(stderr, "Serving %s\n", sha1_to_hex(sha1)); @@ -44,7 +41,8 @@ static int serve_object(int fd_in, int fd_out) { remote = -1; } - write(fd_out, &remote, 1); + if (write_in_full(fd_out, &remote, 1) != 1) + return 0; if (remote < 0) return 0; @@ -54,9 +52,9 @@ static int serve_object(int fd_in, int fd_out) { static int serve_version(int fd_in, int fd_out) { - if (read(fd_in, &remote_version, 1) < 1) + if (xread(fd_in, &remote_version, 1) < 1) return -1; - write(fd_out, &local_version, 1); + write_in_full(fd_out, &local_version, 1); return 0; } @@ -67,7 +65,7 @@ static int serve_ref(int fd_in, int fd_out) int posn = 0; signed char remote = 0; do { - if (read(fd_in, ref + posn, 1) < 1) + if (posn >= PATH_MAX || xread(fd_in, ref + posn, 1) < 1) return -1; posn++; } while (ref[posn - 1]); @@ -77,10 +75,11 @@ static int serve_ref(int fd_in, int fd_out) if (get_ref_sha1(ref, sha1)) remote = -1; - write(fd_out, &remote, 1); + if (write_in_full(fd_out, &remote, 1) != 1) + return 0; if (remote) return 0; - write(fd_out, sha1, 20); + write_in_full(fd_out, sha1, 20); return 0; } @@ -89,7 +88,7 @@ static void service(int fd_in, int fd_out) { char type; int retval; do { - retval = read(fd_in, &type, 1); + retval = xread(fd_in, &type, 1); if (retval < 1) { if (retval < 0) perror("git-ssh-upload: read "); diff --git a/t/t3210-pack-refs.sh b/t/t3210-pack-refs.sh index b1e9f2e..16bdae4 100755 --- a/t/t3210-pack-refs.sh +++ b/t/t3210-pack-refs.sh @@ -34,7 +34,7 @@ test_expect_success \ 'see if a branch still exists when packed' \ 'git-branch b && git-pack-refs --all && - rm .git/refs/heads/b && + rm -f .git/refs/heads/b && echo "$SHA1 refs/heads/b" >expect && git-show-ref b >result && diff expect result' diff --git a/t/t5301-sliding-window.sh b/t/t5301-sliding-window.sh new file mode 100755 index 0000000..5a7232a --- /dev/null +++ b/t/t5301-sliding-window.sh @@ -0,0 +1,60 @@ +#!/bin/sh +# +# Copyright (c) 2006 Shawn Pearce +# + +test_description='mmap sliding window tests' +. ./test-lib.sh + +test_expect_success \ + 'setup' \ + 'rm -f .git/index* + for i in a b c + do + echo $i >$i && + dd if=/dev/urandom bs=32k count=1 >>$i && + git-update-index --add $i || return 1 + done && + echo d >d && cat c >>d && git-update-index --add d && + tree=`git-write-tree` && + commit1=`git-commit-tree $tree </dev/null` && + git-update-ref HEAD $commit1 && + git-repack -a -d && + test "`git-count-objects`" = "0 objects, 0 kilobytes" && + pack1=`ls .git/objects/pack/*.pack` && + test -f "$pack1"' + +test_expect_success \ + 'verify-pack -v, defaults' \ + 'git-verify-pack -v "$pack1"' + +test_expect_success \ + 'verify-pack -v, packedGitWindowSize == 1 page' \ + 'git-repo-config core.packedGitWindowSize 512 && + git-verify-pack -v "$pack1"' + +test_expect_success \ + 'verify-pack -v, packedGit{WindowSize,Limit} == 1 page' \ + 'git-repo-config core.packedGitWindowSize 512 && + git-repo-config core.packedGitLimit 512 && + git-verify-pack -v "$pack1"' + +test_expect_success \ + 'repack -a -d, packedGit{WindowSize,Limit} == 1 page' \ + 'git-repo-config core.packedGitWindowSize 512 && + git-repo-config core.packedGitLimit 512 && + commit2=`git-commit-tree $tree -p $commit1 </dev/null` && + git-update-ref HEAD $commit2 && + git-repack -a -d && + test "`git-count-objects`" = "0 objects, 0 kilobytes" && + pack2=`ls .git/objects/pack/*.pack` && + test -f "$pack2" + test "$pack1" \!= "$pack2"' + +test_expect_success \ + 'verify-pack -v, defaults' \ + 'git-repo-config --unset core.packedGitWindowSize && + git-repo-config --unset core.packedGitLimit && + git-verify-pack -v "$pack2"' + +test_done diff --git a/test-delta.c b/test-delta.c index 795aa08..16595ef 100644 --- a/test-delta.c +++ b/test-delta.c @@ -68,7 +68,7 @@ int main(int argc, char *argv[]) } fd = open (argv[4], O_WRONLY|O_CREAT|O_TRUNC, 0666); - if (fd < 0 || write(fd, out_buf, out_size) != out_size) { + if (fd < 0 || write_in_full(fd, out_buf, out_size) != out_size) { perror(argv[4]); return 1; } @@ -101,7 +101,7 @@ void trace_printf(const char *format, ...) nfvasprintf(&trace_str, format, rest); va_end(rest); - write_or_whine(fd, trace_str, strlen(trace_str), err_msg); + write_or_whine_pipe(fd, trace_str, strlen(trace_str), err_msg); free(trace_str); @@ -139,7 +139,7 @@ void trace_argv_printf(const char **argv, int count, const char *format, ...) strncpy(trace_str + format_len, argv_str, argv_len); strcpy(trace_str + trace_len - 1, "\n"); - write_or_whine(fd, trace_str, trace_len, err_msg); + write_or_whine_pipe(fd, trace_str, trace_len, err_msg); free(argv_str); free(format_str); diff --git a/unpack-file.c b/unpack-file.c index ccddf1d..d24acc2 100644 --- a/unpack-file.c +++ b/unpack-file.c @@ -17,7 +17,7 @@ static char *create_temp_file(unsigned char *sha1) fd = mkstemp(path); if (fd < 0) die("unable to create temp-file"); - if (write(fd, buf, size) != size) + if (write_in_full(fd, buf, size) != size) die("unable to write temp-file"); close(fd); return path; diff --git a/upload-pack.c b/upload-pack.c index c568ef0..3a466c6 100644 --- a/upload-pack.c +++ b/upload-pack.c @@ -55,6 +55,7 @@ static ssize_t send_client_data(int fd, const char *data, ssize_t sz) /* emergency quit */ fd = 2; if (fd == 2) { + /* XXX: are we happy to lose stuff here? */ xwrite(fd, data, sz); return sz; } @@ -242,7 +243,7 @@ static void create_pack_file(void) *cp++ = buffered; outsz++; } - sz = read(pu_pipe[0], cp, + sz = xread(pu_pipe[0], cp, sizeof(data) - outsz); if (0 < sz) ; @@ -267,7 +268,7 @@ static void create_pack_file(void) /* Status ready; we ship that in the side-band * or dump to the standard error. */ - sz = read(pe_pipe[0], progress, + sz = xread(pe_pipe[0], progress, sizeof(progress)); if (0 < sz) send_client_data(2, progress, sz); diff --git a/write_or_die.c b/write_or_die.c index 650f13f..a119e1d 100644 --- a/write_or_die.c +++ b/write_or_die.c @@ -1,67 +1,107 @@ #include "cache.h" -void write_or_die(int fd, const void *buf, size_t count) +int read_in_full(int fd, void *buf, size_t count) { - const char *p = buf; - ssize_t written; + char *p = buf; + ssize_t total = 0; + ssize_t loaded = 0; while (count > 0) { - written = xwrite(fd, p, count); - if (written == 0) - die("disk full?"); - else if (written < 0) { - if (errno == EPIPE) - exit(0); - die("write error (%s)", strerror(errno)); + loaded = xread(fd, p, count); + if (loaded <= 0) { + if (total) + return total; + else + return loaded; } - count -= written; - p += written; + count -= loaded; + p += loaded; + total += loaded; } + + return total; } -int write_or_whine(int fd, const void *buf, size_t count, const char *msg) +void read_or_die(int fd, void *buf, size_t count) +{ + ssize_t loaded; + + loaded = read_in_full(fd, buf, count); + if (loaded == 0) + die("unexpected end of file"); + else if (loaded < 0) + die("read error (%s)", strerror(errno)); +} + +int write_in_full(int fd, const void *buf, size_t count) { const char *p = buf; - ssize_t written; + ssize_t total = 0; + ssize_t written = 0; while (count > 0) { written = xwrite(fd, p, count); - if (written == 0) { - fprintf(stderr, "%s: disk full?\n", msg); - return 0; - } - else if (written < 0) { - if (errno == EPIPE) - exit(0); - fprintf(stderr, "%s: write error (%s)\n", - msg, strerror(errno)); - return 0; + if (written <= 0) { + if (total) + return total; + else + return written; } count -= written; p += written; + total += written; + } + + return total; +} + +void write_or_die(int fd, const void *buf, size_t count) +{ + ssize_t written; + + written = write_in_full(fd, buf, count); + if (written == 0) + die("disk full?"); + else if (written < 0) { + if (errno == EPIPE) + exit(0); + die("write error (%s)", strerror(errno)); + } +} + +int write_or_whine_pipe(int fd, const void *buf, size_t count, const char *msg) +{ + ssize_t written; + + written = write_in_full(fd, buf, count); + if (written == 0) { + fprintf(stderr, "%s: disk full?\n", msg); + return 0; + } + else if (written < 0) { + if (errno == EPIPE) + exit(0); + fprintf(stderr, "%s: write error (%s)\n", + msg, strerror(errno)); + return 0; } return 1; } -int write_in_full(int fd, const void *buf, size_t count, const char *msg) +int write_or_whine(int fd, const void *buf, size_t count, const char *msg) { - const char *p = buf; ssize_t written; - while (count > 0) { - written = xwrite(fd, p, count); - if (written == 0) { - fprintf(stderr, "%s: disk full?\n", msg); - return 0; - } - else if (written < 0) { - fprintf(stderr, "%s: write error (%s)\n", - msg, strerror(errno)); - return 0; - } - count -= written; - p += written; + written = write_in_full(fd, buf, count); + if (written == 0) { + fprintf(stderr, "%s: disk full?\n", msg); + return 0; + } + else if (written < 0) { + fprintf(stderr, "%s: write error (%s)\n", + msg, strerror(errno)); + return 0; } return 1; diff --git a/wt-status.c b/wt-status.c index db42738..c48127d 100644 --- a/wt-status.c +++ b/wt-status.c @@ -15,7 +15,7 @@ static char wt_status_colors[][COLOR_MAXLEN] = { "\033[31m", /* WT_STATUS_CHANGED: red */ "\033[31m", /* WT_STATUS_UNTRACKED: red */ }; -static const char* use_add_msg = "use \"git add file1 file2\" to include for commit"; +static const char* use_add_msg = "use \"git add <file>...\" to incrementally add content to commit"; static int parse_status_slot(const char *var, int offset) { @@ -41,8 +41,6 @@ void wt_status_prepare(struct wt_status *s) unsigned char sha1[20]; const char *head; - s->is_initial = get_sha1("HEAD", sha1) ? 1 : 0; - head = resolve_ref("HEAD", sha1, 0, NULL); s->branch = head ? xstrdup(head) : NULL; @@ -51,6 +49,20 @@ void wt_status_prepare(struct wt_status *s) s->verbose = 0; s->commitable = 0; s->untracked = 0; + + s->workdir_clean = 1; +} + +static void wt_status_print_cached_header(const char *reference) +{ + const char *c = color(WT_STATUS_HEADER); + color_printf_ln(c, "# Changes to be committed:"); + if (reference) { + color_printf_ln(c, "# (use \"git reset %s <file>...\" to unstage)", reference); + } else { + color_printf_ln(c, "# (use \"git rm --cached <file>...\" to unstage)"); + } + color_printf_ln(c, "#"); } static void wt_status_print_header(const char *main, const char *sub) @@ -147,8 +159,7 @@ static void wt_status_print_updated_cb(struct diff_queue_struct *q, if (q->queue[i]->status == 'U') continue; if (!shown_header) { - wt_status_print_header("Added but not yet committed", - "will commit"); + wt_status_print_cached_header(s->reference); s->commitable = 1; shown_header = 1; } @@ -162,9 +173,12 @@ static void wt_status_print_changed_cb(struct diff_queue_struct *q, struct diff_options *options, void *data) { + struct wt_status *s = data; int i; - if (q->nr) + if (q->nr) { + s->workdir_clean = 0; wt_status_print_header("Changed but not added", use_add_msg); + } for (i = 0; i < q->nr; i++) wt_status_print_filepair(WT_STATUS_CHANGED, q->queue[i]); if (q->nr) @@ -179,8 +193,7 @@ void wt_status_print_initial(struct wt_status *s) read_cache(); if (active_nr) { s->commitable = 1; - wt_status_print_header("Added but not yet committed", - "will commit"); + wt_status_print_cached_header(NULL); } for (i = 0; i < active_nr; i++) { color_printf(color(WT_STATUS_HEADER), "#\t"); @@ -215,7 +228,7 @@ static void wt_status_print_changed(struct wt_status *s) run_diff_files(&rev, 0); } -static void wt_status_print_untracked(const struct wt_status *s) +static void wt_status_print_untracked(struct wt_status *s) { struct dir_struct dir; const char *x; @@ -250,6 +263,7 @@ static void wt_status_print_untracked(const struct wt_status *s) continue; } if (!shown_header) { + s->workdir_clean = 0; wt_status_print_header("Untracked files", use_add_msg); shown_header = 1; } @@ -271,6 +285,9 @@ static void wt_status_print_verbose(struct wt_status *s) void wt_status_print(struct wt_status *s) { + unsigned char sha1[20]; + s->is_initial = get_sha1(s->reference, sha1) ? 1 : 0; + if (s->branch) color_printf_ln(color(WT_STATUS_HEADER), "# On branch %s", s->branch); @@ -291,10 +308,16 @@ void wt_status_print(struct wt_status *s) if (s->verbose && !s->is_initial) wt_status_print_verbose(s); - if (!s->commitable) - printf("%s (%s)\n", - s->amend ? "# No changes" : "nothing to commit", - use_add_msg); + if (!s->commitable) { + if (s->amend) + printf("# No changes\n"); + else if (s->workdir_clean) + printf(s->is_initial + ? "nothing to commit\n" + : "nothing to commit (working directory matches HEAD)\n"); + else + printf("no changes added to commit (use \"git add\" and/or \"git commit [-a|-i|-o]\")\n"); + } } int git_status_config(const char *k, const char *v) diff --git a/wt-status.h b/wt-status.h index 0a5a5b7..892a86c 100644 --- a/wt-status.h +++ b/wt-status.h @@ -16,6 +16,7 @@ struct wt_status { int verbose; int amend; int untracked; + int workdir_clean; }; int git_status_config(const char *var, const char *value); |