kmx git

Commit	Date	Message
d1101263	2015-11-13T15:32:48	index: don't detect raciness in uptodate entries Keep track of entries that we believe are up-to-date, because we added the index entries since the index was loaded. This prevents us from unnecessarily examining files that we wrote during the cleanup of racy entries (when we smudge racily clean files that have a timestamp newer than or equal to the index's timestamp when we read it). Without keeping track of this, we would examine every file that we just checked out for raciness, since all their timestamps would be newer than the index's timestamp.
cb0ff012	2015-11-06T17:15:35	racy-git: do a single index->workdir diff When examining paths that are racily clean, do a single index->workdir diff over the entirety of the racily clean files, instead of a diff per file.
75a0ccf5	2015-11-12T19:53:09	Merge pull request #3170 from CmdrMoozy/nsec_fix git_index_entry__init_from_stat: set nsec fields in entry stats
16604d74	2015-11-11T00:36:15	index: correctly report which conflict stage has a wrong filemode When we're at offset 'i', we're dealing with the 'i+1' stage, since conflicts start at 1.
ad8509ef	2015-11-12T11:54:06	index: overwrite the path when inserting conflicts When we insert a conflict in a case-insensitive index, accept the new entry's path as the correct case instead of leaving the path we already had. This puts `git_index_conflict_add()` on the same level as `git_index_add()` in this respect.
0bf77e32	2015-10-30T13:07:02	index: read_index must update hashes
1e5e02b4	2015-10-27T17:26:04	pool: Simplify implementation
d307a013	2015-10-27T22:17:32	reuc: Be smarter when inserting new REUC entries Inserting new REUC entries can quickly become pathological given that each insert unsorts the REUC vector, and both subsequent lookups and insertions will require sorting it again before being successful. To avoid this, we're switching to `git_vector_insert_sorted`: this keeps the REUC vector constantly sorted and lets us use the `on_dup` callback to skip an extra binary search on each insertion.
128e94bb	2015-10-21T12:04:53	index: Remove unneeded consts
21515f22	2015-09-29T15:49:16	index: also try conflict mode when inserting When we do not trust the on-disk mode, we use the mode of an existing index entry. This allows us to preserve executable bits on platforms that do not honor them on the filesystem. If there is no stage 0 index entry, also look at conflicts to attempt to answer this question: prefer the data from the 'ours' side, then the 'theirs' side before falling back to the common ancestor.
0226f7dd	2015-08-29T13:59:20	diff/index: respect USE_NSEC for racily clean file detection
e9e6df2c	2015-06-15T09:28:55	cmake: Only provide USE_NSEC if struct stat members are avilable. This allows us to remove OS checks from source code, instead relying on CMake to detect whether or not `struct stat` has the nanoseconds members we rely on.
e7de893e	2015-06-01T13:43:54	cmake: add USE_NSEC, and only check nanosec m/ctime if enabled
6d6020de	2015-09-08T18:34:51	Merge pull request #3353 from ethomson/wrongcase_add index: canonicalize directory case when adding
2964cbea	2015-09-08T11:50:08	Merge pull request #3381 from leoyanggit/index_directory_iterator New feature: add the ablility to iterate through a directory in index
a32bc85e	2015-08-07T12:43:49	git_index_add: allow case changing renames On case insensitive platforms, allow `git_index_add` to provide a new path for an existing index entry. Previously, we would maintain the case in an index entry without the ability to change it (except by removing an entry and re-adding it.) Higher-level functions (like `git_index_add_bypath` and `git_index_add_frombuffers`) continue to keep the old path for easier usage.
280adb3f	2015-08-04T16:51:00	index: canonicalize directory case when adding On case insensitive systems, when given a user-provided path in the higher-level index addition functions (eg `git_index_add_bypath` / `git_index_add_frombuffer`), examine the index to try to match the given path to an existing directory. Various mechanisms can cause the on-disk representation of a folder to not match the representation in HEAD or the index - for example, a case changing rename of some file `a/file.txt` to `A/file.txt` will update the paths in the index, but not rename the folder on disk. If a user subsequently adds `a/other.txt`, then this should be stored in the index as `A/other.txt`.
9fd4c9c8	2015-09-06T10:50:22	Merge pull request #3366 from libgit2/cmn/index-hashmap Use a hashmap for path-based lookups in the index
c097f717	2015-08-17T15:02:02	New API: git_index_find_prefix Find the first index entry matching a prefix.
81b76367	2015-09-04T13:30:49	index: put the icase insert choice in macros This should let us see more clearly what we're doing and avoid the ugly 'if' we need every time we want to interact with the map.
810cabb9	2015-07-28T20:04:11	racy-git: TODO to use improved diffing
ed1c6446	2015-07-28T11:41:27	iterator: use an options struct instead of args
af1d5239	2015-08-14T21:10:12	index: keep a hash table as well as a vector of entries The hash table allows quick lookup of specific paths, while we use the vector for enumeration.
ef4857c2	2015-08-03T16:50:27	errors: tighten up git_error_state OOMs a bit more When an error state is an OOM, make sure that we treat is specially and do not try to free it.
ea961abf	2015-08-01T19:53:53	index: stage an unregistered submodule as well We previously added logic to `_add_bypath()` to update a submodule. Go further and stage the submodule even if it's not registered to behave like git.
247d27c2	2015-07-11T19:41:03	index: allow add_bypath to update submodules Similarly to how git itself does it, allow the index update operation to stage a change in a submodule's HEAD.
74975846	2015-06-18T14:22:10	index: check racily clean entries more thoroughly When an entry has a racy timestamp, we need to check whether the file itself has changed since we put its entry in the index. Only then do we smudge the size field to force a check the next time around.
624c949f	2015-06-20T16:17:28	index: make relative comparison use the checksum as well This is used by the submodule in order to figure out if the index has changed since it last read it. Using a timestamp is racy, so let's make it use the checksum, just like we now do for reloading the index itself.
5e947c91	2015-06-19T22:05:08	index: use the checksum to check whether it's been modified We currently use a timetamp to check whether an index file has been modified since we last read it, but this is racy. If two updates happen in the same second and we read after the first one, we won't detect the second one. Instead read the SHA-1 checksum of the file, which are its last 20 bytes which gives us a sure-fire way to detect whether the file has changed since we last read it. As we're now keeping track of it, expose an accessor to this data.
316b820b	2015-06-15T09:55:40	index: zero the size of racily-clean entries If a file entry has the same timestamp as the index itself, it is considered racily-clean, as it may have been modified after the index was written, but during the same second. We take extra steps to check the contents, but this is just one part of avoiding races. For files which do have changes but have not been updated in the index, updating the on-disk index means updating its timestamp, which means we would no longer recognise these entries as racy and we would trust the timestamp to tell us whether they have changed. In order to work around this, git zeroes out the file-size field in entries with the same timestamp as the index in order to force the next diff to check the contents. Do so in libgit2 as well.
8147b1af	2015-05-25T20:03:59	diff: introduce binary diff callbacks Introduce a new binary diff callback to provide the actual binary delta contents to callers. Create this data from the diff contents (instead of directly from the ODB) to support binary diffs including the workdir, not just things coming out of the ODB.
9b3e41f7	2015-05-19T18:29:15	index_add_all: remove conflicts when no wd file If there exists a conflict in the index, but no file in the working directory, this implies that the user wants to accept the resolution by removing the file. Thus, remove the conflict entry from the index, instead of trying to add a (nonexistent) file.
9f545b9d	2015-05-19T11:23:59	introduce `git_index_entry_is_conflict` It's not always obvious the mapping between stage level and conflict-ness. More importantly, this can lead otherwise sane people to write constructs like `if (!git_index_entry_stage(entry))`, which (while technically correct) is unreadable. Provide a nice method to help avoid such messy thinking.
d67f270e	2015-05-14T13:30:29	index: validate mode of new conflicts
3ab5a659	2015-05-14T12:54:39	index: remove error message in non-error remove If `git_index_remove_bypath` does no work, and returns an OK error code, it should not set an error message.
ecd60a56	2015-05-14T11:52:48	conflicts: when adding conflicts, remove staged When adding a conflict for some path, remove the staged entry. Otherwise, an illegal index (with both stage 0 and high-stage entries) would result.
cbfeecf3	2015-05-20T20:13:45	git_index_add_all: don't recurse ignored dirs No need to get reports about individual ignored files, having a single ignored directory delta is enough.
fa9a969d	2015-05-20T18:22:17	index_add_all: include untracked files in new subdirs
2b2dfe80	2015-05-12T12:07:33	index: include TYPECHANGE in the diff Without this option, we would not be able to catch exec bit changes.
0a78a52e	2015-05-11T16:09:09	index: make add_all to act on a diff Instead of going through each entry we have and re-adding, which may not even be correct for certain crlf options and has bad performance, use the function which performs a diff against the worktree and try to add and remove files from that list.
197307f6	2015-05-11T15:19:15	index: refactor diff-based update_all to match other applies Refactor so we look like the code we're replacing, which should also allow us to more easily inplement add-all.
713e11e0	2015-05-11T13:24:53	index: use a diff to perform update_all We currently iterate over all the entries and re-add them to the index. While this provides correctness, it is wasteful as we try to re-insert files which have not changed. Instead, take a diff between the index and the worktree and only re-add those which we already know have changed.
35d39761	2015-03-18T00:25:18	index: introduce git_index_read_index
d3282680	2015-04-20T23:41:04	Fix index-adding functions to know when to trust filemodes. The idea...sometimes, a filemode is user-specified via an explicit git_index_entry. In this case, believe the user, always. Sometimes, it is instead built up by statting the file system. In those cases, go with the existing logic we have to determine whether the file system supports all filemodes and symlinks, and make the best guess. On file systems which have full filemode and symlink support, this commit should make no difference. On others (most notably Windows), this will fix problems things like: * git_index_add and git_index_add_frombuffer() should be believed. * As a consequence, git_checkout_tree should make the filemodes in the index match the ones in the tree. * And diffs with GIT_DIFF_UPDATE_INDEX don't write the wrong filemodes. * And merges, and probably other downstream stuff now fixed, too. This makes my previous changes to checkout.c unnecessary, so they are now reverted. Also, added a test for index_entry permissions from git_index_add and git_index_add_frombuffer, both of which failed before these changes.
807566d5	2015-04-03T18:59:11	Entry argument passed to git_index_add_frombuffer() should be const
a275fbc0	2015-02-05T11:40:16	Add API to add a memory buffer to an index git_index_add_frombuffer enables now to store a memory buffer in the odb and to store an entry in the index directly if the index is attached to a repository.
a291790a	2015-02-15T05:18:01	Merge pull request #2831 from ethomson/merge_lock merge: lock index during the merge (not just checkout)
41fae48d	2015-02-03T22:31:10	indexwriter: an indexwriter for repo operations Provide git_indexwriter_init_for_operation for the common locking pattern in merge, rebase, revert and cherry-pick.
55798fd1	2015-01-17T20:49:04	git_indexwriter: lock then write the index Introduce `git_indexwriter`, to allow us to lock the index while performing additional operations, then complete the write (or abort, unlocking the index).
f1453c59	2015-02-12T12:19:37	Make our overflow check look more like gcc/clang's Make our overflow checking look more like gcc and clang's, so that we can substitute it out with the compiler instrinsics on platforms that support it. This means dropping the ability to pass `NULL` as an out parameter. As a result, the macros also get updated to reflect this as well.
2884cc42	2015-02-11T09:39:38	overflow checking: don't make callers set oom Have the ALLOC_OVERFLOW testing macros also simply set_oom in the case where a computation would overflow, so that callers don't need to.
392702ee	2015-02-09T23:41:13	allocations: test for overflow of requested size Introduce some helper macros to test integer overflow from arithmetic and set error message appropriately.
b63b3b0e	2015-01-25T14:08:05	Ensure git_index_entry is not NULL before trying to free it
2fe8157e	2014-12-22T18:42:03	index: reuc and name entrycounts should be size_t For the REUC and NAME entries, we use size_t internally, and we take size_t for the get_byindex() functions, but the entrycount() functions strangely cast to an unsigned int instead.
a64119e3	2014-11-25T18:13:00	checkout: disallow bad paths on win32 Disallow: 1. paths with trailing dot 2. paths with trailing space 3. paths with trailing colon 4. paths that are 8.3 short names of .git folders ("GIT~1") 5. paths that are reserved path names (COM1, LPT1, etc). 6. paths with reserved DOS characters (colons, asterisks, etc) These paths would (without \\?\ syntax) be elided to other paths - for example, ".git." would be written as ".git". As a result, writing these paths literally (using \\?\ syntax) makes them hard to operate with from the shell, Windows Explorer or other tools. Disallow these.
0d388adc	2014-11-25T00:58:03	index: Check for valid paths before creating an index entry
62a617dc	2014-11-06T16:16:46	iterator: submodules are determined by an index or tree We cannot know from looking at .gitmodules whether a directory is a submodule or not. We need the index or tree we are comparing against to tell us. Otherwise we have to assume the entry in .gitmodules is stale or otherwise invalid. Thus we pass the index of the repository into the workdir iterator, even if we do not want to compare against it. This follows what git does, which even for `git diff <tree>`, it will consider staged submodules as such.
c2f8b215	2014-09-28T07:00:49	index: write out the tree cache extension Keeping the cache around after read-tree is only one part of the optimisation opportunities. In order to share the cache between program instances, we need to write the TREE extension to the index. Do so, taking the opportunity to rename 'entries' to 'entry_count' to match the name given in the format description. The included test is rather trivial, but works as a sanity check.
6843cebe	2014-07-10T14:10:39	index: fill the tree cache when reading from a tree When reading from a tree, we know what every tree is going to look like, so we can fill in the tree cache completely, making use of the index for modification of trees a lot quicker.
19c88310	2014-07-10T13:48:13	tree-cache: move to use a pool allocator This simplifies freeing the entries quite a bit; though there aren't that many failure paths right now, introducing filling the cache from a tree will introduce more. This makes sure not to leak memory on errors.
ff97778a	2014-09-25T13:07:36	The raw index buffer content is not guaranteed to be aligned * Ensure alignment by copying the content into a structure on the stack
052a2ffd	2014-05-22T16:01:02	index: check for valid filemodes on add
0fc8e1f6	2014-04-28T14:34:55	Lay groundwork for updating stat cache in diff This reorganized the diff OID calculation to make it easier to correctly update the stat cache during a diff once the flags to do so are enabled. This includes marking the path of a git_index_entry as const so we can make a "fake" git_index_entry with a "const char *" path and not get warnings. I was a little surprised at how unobtrusive this change was, but I think it's probably a good thing.
17ef678c	2014-04-21T11:55:57	Fix some coverity-found issues
ea642d61	2014-04-14T12:29:27	Fix race checking for existing index items In the threading tests, I was still seeing a race condition where the same item could end up being inserted multiple times into the index. Preserving the sorted-ness of the index outside of the `index_insert` call fixes the issue.
7d490872	2014-04-10T22:31:01	Attribute file cache refactor This is a big refactoring of the attribute file cache to be a bit simpler which in turn makes it easier to enforce a lock around any updates to the cache so that it can be used in a threaded env. Tons of changes to the attributes and ignores code.
aba6b5ed	2014-03-14T21:59:26	Fix leak in git_index_conflict_cleanup I introduced a leak into conflict cleanup by removing items from inside the git_vector_remove_matching call. This simplifies the code to just use one common way for the two conflict cleanup APIs. When an index has an active snapshot, removing an item can cause an error (inserting into the deferred deletion vector), so I made the git_index_conflict_cleanup API return an error code. I felt like this wasn't so bad since it is just like the other APIs. I fixed up a couple of comments while I was changing the header.
52bb0476	2014-03-14T13:53:15	Clean up index snapshot function naming Clear up some of the various "find" functions and the snapshot API naming to be things I like more.
8a2834d3	2014-03-14T13:20:51	Index locking and entry allocation changes This makes the lock management on the index a little bit broader, having a number of routines hold the lock across looking up the item to be modified and actually making the modification. Still not true thread safety, but more pure index modifications are now safe which allows the simple cases (such as starting up a diff while index modifications are underway) safe enough to get the snapshot without hitting allocation problems. As part of this, I simplified the allocation of index entries to use a flex array and just put the path at the end of the index entry. This makes every entry self-contained and makes it a little easier to feel sure that pointers to strings aren't being accidentally copied and freed while other references are still being held.
3b4c401a	2014-02-10T13:20:08	Decouple index iterator sort from index This makes the index iterator honor the GIT_ITERATOR_IGNORE_CASE and GIT_ITERATOR_DONT_IGNORE_CASE flags without modifying the index data itself. To take advantage of this, I had to export a number of the internal index entry comparison functions. I also wrote some new tests to exercise the capability.
dac16048	2014-02-08T16:42:26	Add mutex around index entries changes This surrounds any function that mutates the entries vector with a mutex so it can be safely snapshotted.
54edbb98	2014-02-07T16:48:27	Add index snapshot and use it for iterator
3dbee456	2014-02-07T14:10:35	Some index internals refactoring Again, laying groundwork for some index iterator changes, this contains a bunch of code refactorings for index internals that should make it easier down the line to add locking around index modifications. Also this removes the redundant prefix_position function and fixes some potential memory leaks.
c67fd4c9	2014-02-07T11:20:36	Some vector utility tweaks This is just laying some groundwork for internal index changes that I'm working on.
923c8400	2014-04-04T14:24:08	Merge pull request #2215 from libgit2/rb/submodule-cache-fixes Improve submodule cache management
3b4ba278	2014-04-03T15:50:21	Const correctness!
8f4e5275	2014-04-01T16:46:25	More tests and fix submodule index refresh There was a little bug where the submodule cache thought that the index date was out of date even when it wasn't that was resulting in some extra scans of index data even when not needed. Mostly this commit adds a bunch of new tests including adding and removing submodules in the index and in the HEAD and seeing if we can automatically pick them up when refreshing.
db0e7878	2014-03-28T16:50:49	Make submodule refresh a bit smarter This makes submodule cache refresh actually look at the timestamps from the data sources for submodules and reload as needed if they have changed since the last refresh.
05d47768	2014-03-10T22:30:41	Introduce git_merge_file for consumers
0782c89e	2014-03-10T14:40:07	corrected typo in error message
b1f2c2e2	2014-02-22T10:18:42	Prevent icc warning
72556cc6	2014-02-20T14:27:10	Address PR comments * Make GIT_INLINE an internal definition so it cannot be used in public headers * Fix language in CONTRIBUTING * Make index caps API use signed instead of unsigned values
3158e2fe	2014-02-07T15:24:39	Fix some Windows warnings This fixes a number of warnings with the Windows 64-bit build including a test failure in test_repo_message__message where an invalid pointer to a git_buf was being used.
43709ca8	2014-02-04T10:33:30	Fix typo setting sorted flag when reloading index This fixes a typo I made for setting the sorted flag on the index after a reload. That typo didn't actually cause any test failures so I'm also adding a test that explicitly checks that the index is correctly sorted after a reload when ignoring case and when not.
882c7742	2014-02-04T10:01:37	Convert pqueue to just be a git_vector This updates the git_pqueue to simply be a set of specialized init/insert/pop functions on a git_vector. To preserve the pqueue feature of having a fixed size heap, I converted the "sorted" field in git_vectors to a more general "flags" field so that pqueue could mix in it's own flag. This had a bunch of ramifications because a number of places were directly looking at the vector "sorted" field - I added a couple new git_vector helpers (is_sorted, set_sorted) so the specific representation of this information could be abstracted.
b794cbcd	2014-01-30T11:38:25	Rename conflict to collision to prevent confusion
b747eb14	2014-01-29T12:55:33	Give index_isrch the same semantics as index_srch In case insensitive index mode, we would stop at a prefixed entry, treating the provided search key length as a substring, not the length of the string to match.
1eefd356	2014-01-29T18:44:29	index: Implement folder-file checks
53bec813	2014-01-29T18:17:08	index: Compare with given len
d541170c	2014-01-24T11:36:41	index: rename an entry's id to 'id' This was not converted when we converted the rest, so do it now.
26c1cb91	2013-12-09T09:44:03	One more rename/cleanup for callback err functions
25e0b157	2013-12-06T15:07:57	Remove converting user error to GIT_EUSER This changes the behavior of callbacks so that the callback error code is not converted into GIT_EUSER and instead we propagate the return value through to the caller. Instead of using the giterr_capture and giterr_restore functions, we now rely on all functions to pass back the return value from a callback. To avoid having a return value with no error message, the user can call the public giterr_set_str or some such function to set an error message. There is a new helper 'giterr_set_callback' that functions can invoke after making a callback which ensures that some error message was set in case the callback did not set one. In places where the sign of the callback return value is meaningful (e.g. positive to skip, negative to abort), only the negative values are returned back to the caller, obviously, since the other values allow for continuing the loop. The hardest parts of this were in the checkout code where positive return values were overloaded as meaningful values for checkout. I fixed this by adding an output parameter to many of the internal checkout functions and removing the overload. This added some code, but it is probably a better implementation. There is some funkiness in the network code where user provided callbacks could be returning a positive or a negative value and we want to rely on that to cancel the loop. There are still a couple places where an user error might get turned into GIT_EUSER there, I think, though none exercised by the tests.
dab89f9b	2013-12-04T21:22:57	Further EUSER and error propagation fixes This continues auditing all the places where GIT_EUSER is being returned and making sure to clear any existing error using the new giterr_user_cancel helper. As a result, places that relied on intercepting GIT_EUSER but having the old error preserved also needed to be cleaned up to correctly stash and then retrieve the actual error. Additionally, as I encountered places where error codes were not being propagated correctly, I tried to fix them up. A number of those fixes are included in the this commit as well.
bd15b513	2013-11-19T13:24:10	index: Free the index on git_index_open() failure
1d3a8aeb	2013-11-04T18:28:57	move mode_t to filebuf_open instead of _commit
8e5a8ef8	2013-11-01T09:51:01	Convert git_index_read to have a "force" flag This is a little more intuitive than the turned-around option that I originally wrote.
4bf630b6	2013-10-31T14:36:52	Make diff and status perform soft index reload This changes `git_index_read` to have two modes - a hard index reload that always resets the index to match the on-disk data (which was the old behavior) and a soft index reload that uses the timestamp / file size information and only replaces the index data if the file on disk has been modified. This then updates the git_status code to do a soft reload unless the new GIT_STATUS_OPT_NO_REFRESH flag is passed in. This also changes the behavior of the git_diff functions that use the index so that when an index is not explicitly passed in (i.e. when the functions call git_repository_index for you), they will also do a soft reload for you. This intentionally breaks the file signature of git_index_read because there has been some confusion about the behavior previously and it seems like all existing uses of the API should probably be examined to select the desired behavior.
95c148b2	2013-10-08T17:03:12	Merge pull request #1886 from libgit2/precompose-utf8 Add support for core.precomposeunicode on Mac
14997dc5	2013-10-08T12:45:43	More filemode cleanups for FAT on MacOS This cleans up some additional issues. The main change is that on a filesystem that doesn't support mode bits, libgit2 will now create new blobs with GIT_FILEMODE_BLOB always instead of being at the mercy to the filesystem driver to report executable or not. This means that if "core.filemode" lies and claims that filemode is not supported, then we will ignore the executable bit from the filesystem. Previously we would have allowed it. This adds an option to the new git_repository_reset_filesystem to recurse through submodules if desired. There may be other types of APIs that would like a "recurse submodules" option, but this one is particularly useful. This also has a number of cleanups, etc., for related things including trying to give better error messages when problems come up from the filesystem. For example, the FAT filesystem driver on MacOS appears to return errno EINVAL if you attempt to write a filename with invalid UTF-8 in it. We try to capture that with a better error message now.
da7b78fa	2013-10-04T14:03:12	index: Make _read() cope with index file creation

d1101263

2015-11-13T15:32:48

index: don't detect raciness in uptodate entries Keep track of entries that we believe are up-to-date, because we added the index entries since the index was loaded. This prevents us from unnecessarily examining files that we wrote during the cleanup of racy entries (when we smudge racily clean files that have a timestamp newer than or equal to the index's timestamp when we read it). Without keeping track of this, we would examine every file that we just checked out for raciness, since all their timestamps would be newer than the index's timestamp.

cb0ff012

2015-11-06T17:15:35

racy-git: do a single index->workdir diff When examining paths that are racily clean, do a single index->workdir diff over the entirety of the racily clean files, instead of a diff per file.

75a0ccf5

2015-11-12T19:53:09

Merge pull request #3170 from CmdrMoozy/nsec_fix git_index_entry__init_from_stat: set nsec fields in entry stats

16604d74

2015-11-11T00:36:15

index: correctly report which conflict stage has a wrong filemode When we're at offset 'i', we're dealing with the 'i+1' stage, since conflicts start at 1.

ad8509ef

2015-11-12T11:54:06

index: overwrite the path when inserting conflicts When we insert a conflict in a case-insensitive index, accept the new entry's path as the correct case instead of leaving the path we already had. This puts `git_index_conflict_add()` on the same level as `git_index_add()` in this respect.

0bf77e32

2015-10-30T13:07:02

index: read_index must update hashes

1e5e02b4

2015-10-27T17:26:04

pool: Simplify implementation

d307a013

2015-10-27T22:17:32

reuc: Be smarter when inserting new REUC entries Inserting new REUC entries can quickly become pathological given that each insert unsorts the REUC vector, and both subsequent lookups *and* insertions will require sorting it again before being successful. To avoid this, we're switching to `git_vector_insert_sorted`: this keeps the REUC vector constantly sorted and lets us use the `on_dup` callback to skip an extra binary search on each insertion.

128e94bb

2015-10-21T12:04:53

index: Remove unneeded consts

21515f22

2015-09-29T15:49:16

index: also try conflict mode when inserting When we do not trust the on-disk mode, we use the mode of an existing index entry. This allows us to preserve executable bits on platforms that do not honor them on the filesystem. If there is no stage 0 index entry, also look at conflicts to attempt to answer this question: prefer the data from the 'ours' side, then the 'theirs' side before falling back to the common ancestor.

0226f7dd

2015-08-29T13:59:20

diff/index: respect USE_NSEC for racily clean file detection

e9e6df2c

2015-06-15T09:28:55

cmake: Only provide USE_NSEC if struct stat members are avilable. This allows us to remove OS checks from source code, instead relying on CMake to detect whether or not `struct stat` has the nanoseconds members we rely on.

e7de893e

2015-06-01T13:43:54

cmake: add USE_NSEC, and only check nanosec m/ctime if enabled

6d6020de

2015-09-08T18:34:51

Merge pull request #3353 from ethomson/wrongcase_add index: canonicalize directory case when adding

2964cbea

2015-09-08T11:50:08

Merge pull request #3381 from leoyanggit/index_directory_iterator New feature: add the ablility to iterate through a directory in index

a32bc85e

2015-08-07T12:43:49

git_index_add: allow case changing renames On case insensitive platforms, allow `git_index_add` to provide a new path for an existing index entry. Previously, we would maintain the case in an index entry without the ability to change it (except by removing an entry and re-adding it.) Higher-level functions (like `git_index_add_bypath` and `git_index_add_frombuffers`) continue to keep the old path for easier usage.

280adb3f

2015-08-04T16:51:00

index: canonicalize directory case when adding On case insensitive systems, when given a user-provided path in the higher-level index addition functions (eg `git_index_add_bypath` / `git_index_add_frombuffer`), examine the index to try to match the given path to an existing directory. Various mechanisms can cause the on-disk representation of a folder to not match the representation in HEAD or the index - for example, a case changing rename of some file `a/file.txt` to `A/file.txt` will update the paths in the index, but not rename the folder on disk. If a user subsequently adds `a/other.txt`, then this should be stored in the index as `A/other.txt`.

9fd4c9c8

2015-09-06T10:50:22

Merge pull request #3366 from libgit2/cmn/index-hashmap Use a hashmap for path-based lookups in the index

c097f717

2015-08-17T15:02:02

New API: git_index_find_prefix Find the first index entry matching a prefix.

81b76367

2015-09-04T13:30:49

index: put the icase insert choice in macros This should let us see more clearly what we're doing and avoid the ugly 'if' we need every time we want to interact with the map.

810cabb9

2015-07-28T20:04:11

racy-git: TODO to use improved diffing

ed1c6446

2015-07-28T11:41:27

iterator: use an options struct instead of args

af1d5239

2015-08-14T21:10:12

index: keep a hash table as well as a vector of entries The hash table allows quick lookup of specific paths, while we use the vector for enumeration.

ef4857c2

2015-08-03T16:50:27

errors: tighten up git_error_state OOMs a bit more When an error state is an OOM, make sure that we treat is specially and do not try to free it.

ea961abf

2015-08-01T19:53:53

index: stage an unregistered submodule as well We previously added logic to `_add_bypath()` to update a submodule. Go further and stage the submodule even if it's not registered to behave like git.

247d27c2

2015-07-11T19:41:03

index: allow add_bypath to update submodules Similarly to how git itself does it, allow the index update operation to stage a change in a submodule's HEAD.

74975846

2015-06-18T14:22:10

index: check racily clean entries more thoroughly When an entry has a racy timestamp, we need to check whether the file itself has changed since we put its entry in the index. Only then do we smudge the size field to force a check the next time around.

624c949f

2015-06-20T16:17:28

index: make relative comparison use the checksum as well This is used by the submodule in order to figure out if the index has changed since it last read it. Using a timestamp is racy, so let's make it use the checksum, just like we now do for reloading the index itself.

5e947c91

2015-06-19T22:05:08

index: use the checksum to check whether it's been modified We currently use a timetamp to check whether an index file has been modified since we last read it, but this is racy. If two updates happen in the same second and we read after the first one, we won't detect the second one. Instead read the SHA-1 checksum of the file, which are its last 20 bytes which gives us a sure-fire way to detect whether the file has changed since we last read it. As we're now keeping track of it, expose an accessor to this data.

316b820b

2015-06-15T09:55:40

index: zero the size of racily-clean entries If a file entry has the same timestamp as the index itself, it is considered racily-clean, as it may have been modified after the index was written, but during the same second. We take extra steps to check the contents, but this is just one part of avoiding races. For files which do have changes but have not been updated in the index, updating the on-disk index means updating its timestamp, which means we would no longer recognise these entries as racy and we would trust the timestamp to tell us whether they have changed. In order to work around this, git zeroes out the file-size field in entries with the same timestamp as the index in order to force the next diff to check the contents. Do so in libgit2 as well.

8147b1af

2015-05-25T20:03:59

diff: introduce binary diff callbacks Introduce a new binary diff callback to provide the actual binary delta contents to callers. Create this data from the diff contents (instead of directly from the ODB) to support binary diffs including the workdir, not just things coming out of the ODB.

9b3e41f7

2015-05-19T18:29:15

index_add_all: remove conflicts when no wd file If there exists a conflict in the index, but no file in the working directory, this implies that the user wants to accept the resolution by removing the file. Thus, remove the conflict entry from the index, instead of trying to add a (nonexistent) file.

9f545b9d

2015-05-19T11:23:59

introduce `git_index_entry_is_conflict` It's not always obvious the mapping between stage level and conflict-ness. More importantly, this can lead otherwise sane people to write constructs like `if (!git_index_entry_stage(entry))`, which (while technically correct) is unreadable. Provide a nice method to help avoid such messy thinking.

d67f270e

2015-05-14T13:30:29

index: validate mode of new conflicts

3ab5a659

2015-05-14T12:54:39

index: remove error message in non-error remove If `git_index_remove_bypath` does no work, and returns an OK error code, it should not set an error message.

ecd60a56

2015-05-14T11:52:48

conflicts: when adding conflicts, remove staged When adding a conflict for some path, remove the staged entry. Otherwise, an illegal index (with both stage 0 and high-stage entries) would result.

cbfeecf3

2015-05-20T20:13:45

git_index_add_all: don't recurse ignored dirs No need to get reports about individual ignored files, having a single ignored directory delta is enough.

fa9a969d

2015-05-20T18:22:17

index_add_all: include untracked files in new subdirs

2b2dfe80

2015-05-12T12:07:33

index: include TYPECHANGE in the diff Without this option, we would not be able to catch exec bit changes.

0a78a52e

2015-05-11T16:09:09

index: make add_all to act on a diff Instead of going through each entry we have and re-adding, which may not even be correct for certain crlf options and has bad performance, use the function which performs a diff against the worktree and try to add and remove files from that list.

197307f6

2015-05-11T15:19:15

index: refactor diff-based update_all to match other applies Refactor so we look like the code we're replacing, which should also allow us to more easily inplement add-all.

713e11e0

2015-05-11T13:24:53

index: use a diff to perform update_all We currently iterate over all the entries and re-add them to the index. While this provides correctness, it is wasteful as we try to re-insert files which have not changed. Instead, take a diff between the index and the worktree and only re-add those which we already know have changed.

35d39761

2015-03-18T00:25:18

index: introduce git_index_read_index

d3282680

2015-04-20T23:41:04

Fix index-adding functions to know when to trust filemodes. The idea...sometimes, a filemode is user-specified via an explicit git_index_entry. In this case, believe the user, always. Sometimes, it is instead built up by statting the file system. In those cases, go with the existing logic we have to determine whether the file system supports all filemodes and symlinks, and make the best guess. On file systems which have full filemode and symlink support, this commit should make no difference. On others (most notably Windows), this will fix problems things like: * git_index_add and git_index_add_frombuffer() should be believed. * As a consequence, git_checkout_tree should make the filemodes in the index match the ones in the tree. * And diffs with GIT_DIFF_UPDATE_INDEX don't write the wrong filemodes. * And merges, and probably other downstream stuff now fixed, too. This makes my previous changes to checkout.c unnecessary, so they are now reverted. Also, added a test for index_entry permissions from git_index_add and git_index_add_frombuffer, both of which failed before these changes.

807566d5

2015-04-03T18:59:11

Entry argument passed to git_index_add_frombuffer() should be const

a275fbc0

2015-02-05T11:40:16

Add API to add a memory buffer to an index git_index_add_frombuffer enables now to store a memory buffer in the odb and to store an entry in the index directly if the index is attached to a repository.

a291790a

2015-02-15T05:18:01

Merge pull request #2831 from ethomson/merge_lock merge: lock index during the merge (not just checkout)

41fae48d

2015-02-03T22:31:10

indexwriter: an indexwriter for repo operations Provide git_indexwriter_init_for_operation for the common locking pattern in merge, rebase, revert and cherry-pick.

55798fd1

2015-01-17T20:49:04

git_indexwriter: lock then write the index Introduce `git_indexwriter`, to allow us to lock the index while performing additional operations, then complete the write (or abort, unlocking the index).

f1453c59

2015-02-12T12:19:37

Make our overflow check look more like gcc/clang's Make our overflow checking look more like gcc and clang's, so that we can substitute it out with the compiler instrinsics on platforms that support it. This means dropping the ability to pass `NULL` as an out parameter. As a result, the macros also get updated to reflect this as well.

2884cc42

2015-02-11T09:39:38

overflow checking: don't make callers set oom Have the ALLOC_OVERFLOW testing macros also simply set_oom in the case where a computation would overflow, so that callers don't need to.

392702ee

2015-02-09T23:41:13

allocations: test for overflow of requested size Introduce some helper macros to test integer overflow from arithmetic and set error message appropriately.

b63b3b0e

2015-01-25T14:08:05

Ensure git_index_entry is not NULL before trying to free it

2fe8157e

2014-12-22T18:42:03

index: reuc and name entrycounts should be size_t For the REUC and NAME entries, we use size_t internally, and we take size_t for the get_byindex() functions, but the entrycount() functions strangely cast to an unsigned int instead.

a64119e3

2014-11-25T18:13:00

checkout: disallow bad paths on win32 Disallow: 1. paths with trailing dot 2. paths with trailing space 3. paths with trailing colon 4. paths that are 8.3 short names of .git folders ("GIT~1") 5. paths that are reserved path names (COM1, LPT1, etc). 6. paths with reserved DOS characters (colons, asterisks, etc) These paths would (without \\?\ syntax) be elided to other paths - for example, ".git." would be written as ".git". As a result, writing these paths literally (using \\?\ syntax) makes them hard to operate with from the shell, Windows Explorer or other tools. Disallow these.

0d388adc

2014-11-25T00:58:03

index: Check for valid paths before creating an index entry

62a617dc

2014-11-06T16:16:46

iterator: submodules are determined by an index or tree We cannot know from looking at .gitmodules whether a directory is a submodule or not. We need the index or tree we are comparing against to tell us. Otherwise we have to assume the entry in .gitmodules is stale or otherwise invalid. Thus we pass the index of the repository into the workdir iterator, even if we do not want to compare against it. This follows what git does, which even for `git diff <tree>`, it will consider staged submodules as such.

c2f8b215

2014-09-28T07:00:49

index: write out the tree cache extension Keeping the cache around after read-tree is only one part of the optimisation opportunities. In order to share the cache between program instances, we need to write the TREE extension to the index. Do so, taking the opportunity to rename 'entries' to 'entry_count' to match the name given in the format description. The included test is rather trivial, but works as a sanity check.

6843cebe

2014-07-10T14:10:39

index: fill the tree cache when reading from a tree When reading from a tree, we know what every tree is going to look like, so we can fill in the tree cache completely, making use of the index for modification of trees a lot quicker.

19c88310

2014-07-10T13:48:13

tree-cache: move to use a pool allocator This simplifies freeing the entries quite a bit; though there aren't that many failure paths right now, introducing filling the cache from a tree will introduce more. This makes sure not to leak memory on errors.

ff97778a

2014-09-25T13:07:36

The raw index buffer content is not guaranteed to be aligned * Ensure alignment by copying the content into a structure on the stack

052a2ffd

2014-05-22T16:01:02

index: check for valid filemodes on add

0fc8e1f6

2014-04-28T14:34:55

Lay groundwork for updating stat cache in diff This reorganized the diff OID calculation to make it easier to correctly update the stat cache during a diff once the flags to do so are enabled. This includes marking the path of a git_index_entry as const so we can make a "fake" git_index_entry with a "const char *" path and not get warnings. I was a little surprised at how unobtrusive this change was, but I think it's probably a good thing.

17ef678c

2014-04-21T11:55:57

Fix some coverity-found issues

ea642d61

2014-04-14T12:29:27

Fix race checking for existing index items In the threading tests, I was still seeing a race condition where the same item could end up being inserted multiple times into the index. Preserving the sorted-ness of the index outside of the `index_insert` call fixes the issue.

7d490872

2014-04-10T22:31:01

Attribute file cache refactor This is a big refactoring of the attribute file cache to be a bit simpler which in turn makes it easier to enforce a lock around any updates to the cache so that it can be used in a threaded env. Tons of changes to the attributes and ignores code.

aba6b5ed

2014-03-14T21:59:26

Fix leak in git_index_conflict_cleanup I introduced a leak into conflict cleanup by removing items from inside the git_vector_remove_matching call. This simplifies the code to just use one common way for the two conflict cleanup APIs. When an index has an active snapshot, removing an item can cause an error (inserting into the deferred deletion vector), so I made the git_index_conflict_cleanup API return an error code. I felt like this wasn't so bad since it is just like the other APIs. I fixed up a couple of comments while I was changing the header.

52bb0476

2014-03-14T13:53:15

Clean up index snapshot function naming Clear up some of the various "find" functions and the snapshot API naming to be things I like more.

8a2834d3

2014-03-14T13:20:51

Index locking and entry allocation changes This makes the lock management on the index a little bit broader, having a number of routines hold the lock across looking up the item to be modified and actually making the modification. Still not true thread safety, but more pure index modifications are now safe which allows the simple cases (such as starting up a diff while index modifications are underway) safe enough to get the snapshot without hitting allocation problems. As part of this, I simplified the allocation of index entries to use a flex array and just put the path at the end of the index entry. This makes every entry self-contained and makes it a little easier to feel sure that pointers to strings aren't being accidentally copied and freed while other references are still being held.

3b4c401a

2014-02-10T13:20:08

Decouple index iterator sort from index This makes the index iterator honor the GIT_ITERATOR_IGNORE_CASE and GIT_ITERATOR_DONT_IGNORE_CASE flags without modifying the index data itself. To take advantage of this, I had to export a number of the internal index entry comparison functions. I also wrote some new tests to exercise the capability.

dac16048

2014-02-08T16:42:26

Add mutex around index entries changes This surrounds any function that mutates the entries vector with a mutex so it can be safely snapshotted.

54edbb98

2014-02-07T16:48:27

Add index snapshot and use it for iterator

3dbee456

2014-02-07T14:10:35

Some index internals refactoring Again, laying groundwork for some index iterator changes, this contains a bunch of code refactorings for index internals that should make it easier down the line to add locking around index modifications. Also this removes the redundant prefix_position function and fixes some potential memory leaks.

c67fd4c9

2014-02-07T11:20:36

Some vector utility tweaks This is just laying some groundwork for internal index changes that I'm working on.

923c8400

2014-04-04T14:24:08

Merge pull request #2215 from libgit2/rb/submodule-cache-fixes Improve submodule cache management

3b4ba278

2014-04-03T15:50:21

Const correctness!

8f4e5275

2014-04-01T16:46:25

More tests and fix submodule index refresh There was a little bug where the submodule cache thought that the index date was out of date even when it wasn't that was resulting in some extra scans of index data even when not needed. Mostly this commit adds a bunch of new tests including adding and removing submodules in the index and in the HEAD and seeing if we can automatically pick them up when refreshing.

db0e7878

2014-03-28T16:50:49

Make submodule refresh a bit smarter This makes submodule cache refresh actually look at the timestamps from the data sources for submodules and reload as needed if they have changed since the last refresh.

05d47768

2014-03-10T22:30:41

Introduce git_merge_file for consumers

0782c89e

2014-03-10T14:40:07

corrected typo in error message

b1f2c2e2

2014-02-22T10:18:42

Prevent icc warning

72556cc6

2014-02-20T14:27:10

Address PR comments * Make GIT_INLINE an internal definition so it cannot be used in public headers * Fix language in CONTRIBUTING * Make index caps API use signed instead of unsigned values

3158e2fe

2014-02-07T15:24:39

Fix some Windows warnings This fixes a number of warnings with the Windows 64-bit build including a test failure in test_repo_message__message where an invalid pointer to a git_buf was being used.

43709ca8

2014-02-04T10:33:30

Fix typo setting sorted flag when reloading index This fixes a typo I made for setting the sorted flag on the index after a reload. That typo didn't actually cause any test failures so I'm also adding a test that explicitly checks that the index is correctly sorted after a reload when ignoring case and when not.

882c7742

2014-02-04T10:01:37

Convert pqueue to just be a git_vector This updates the git_pqueue to simply be a set of specialized init/insert/pop functions on a git_vector. To preserve the pqueue feature of having a fixed size heap, I converted the "sorted" field in git_vectors to a more general "flags" field so that pqueue could mix in it's own flag. This had a bunch of ramifications because a number of places were directly looking at the vector "sorted" field - I added a couple new git_vector helpers (is_sorted, set_sorted) so the specific representation of this information could be abstracted.

b794cbcd

2014-01-30T11:38:25

Rename conflict to collision to prevent confusion

b747eb14

2014-01-29T12:55:33

Give index_isrch the same semantics as index_srch In case insensitive index mode, we would stop at a prefixed entry, treating the provided search key length as a substring, not the length of the string to match.

1eefd356

2014-01-29T18:44:29

index: Implement folder-file checks

53bec813

2014-01-29T18:17:08

index: Compare with given len

d541170c

2014-01-24T11:36:41

index: rename an entry's id to 'id' This was not converted when we converted the rest, so do it now.

26c1cb91

2013-12-09T09:44:03

One more rename/cleanup for callback err functions

25e0b157

2013-12-06T15:07:57

Remove converting user error to GIT_EUSER This changes the behavior of callbacks so that the callback error code is not converted into GIT_EUSER and instead we propagate the return value through to the caller. Instead of using the giterr_capture and giterr_restore functions, we now rely on all functions to pass back the return value from a callback. To avoid having a return value with no error message, the user can call the public giterr_set_str or some such function to set an error message. There is a new helper 'giterr_set_callback' that functions can invoke after making a callback which ensures that some error message was set in case the callback did not set one. In places where the sign of the callback return value is meaningful (e.g. positive to skip, negative to abort), only the negative values are returned back to the caller, obviously, since the other values allow for continuing the loop. The hardest parts of this were in the checkout code where positive return values were overloaded as meaningful values for checkout. I fixed this by adding an output parameter to many of the internal checkout functions and removing the overload. This added some code, but it is probably a better implementation. There is some funkiness in the network code where user provided callbacks could be returning a positive or a negative value and we want to rely on that to cancel the loop. There are still a couple places where an user error might get turned into GIT_EUSER there, I think, though none exercised by the tests.

dab89f9b

2013-12-04T21:22:57

Further EUSER and error propagation fixes This continues auditing all the places where GIT_EUSER is being returned and making sure to clear any existing error using the new giterr_user_cancel helper. As a result, places that relied on intercepting GIT_EUSER but having the old error preserved also needed to be cleaned up to correctly stash and then retrieve the actual error. Additionally, as I encountered places where error codes were not being propagated correctly, I tried to fix them up. A number of those fixes are included in the this commit as well.

bd15b513

2013-11-19T13:24:10

index: Free the index on git_index_open() failure

1d3a8aeb

2013-11-04T18:28:57

move mode_t to filebuf_open instead of _commit

8e5a8ef8

2013-11-01T09:51:01

Convert git_index_read to have a "force" flag This is a little more intuitive than the turned-around option that I originally wrote.

4bf630b6

2013-10-31T14:36:52

Make diff and status perform soft index reload This changes `git_index_read` to have two modes - a hard index reload that always resets the index to match the on-disk data (which was the old behavior) and a soft index reload that uses the timestamp / file size information and only replaces the index data if the file on disk has been modified. This then updates the git_status code to do a soft reload unless the new GIT_STATUS_OPT_NO_REFRESH flag is passed in. This also changes the behavior of the git_diff functions that use the index so that when an index is not explicitly passed in (i.e. when the functions call git_repository_index for you), they will also do a soft reload for you. This intentionally breaks the file signature of git_index_read because there has been some confusion about the behavior previously and it seems like all existing uses of the API should probably be examined to select the desired behavior.

95c148b2

2013-10-08T17:03:12

Merge pull request #1886 from libgit2/precompose-utf8 Add support for core.precomposeunicode on Mac

14997dc5

2013-10-08T12:45:43

More filemode cleanups for FAT on MacOS This cleans up some additional issues. The main change is that on a filesystem that doesn't support mode bits, libgit2 will now create new blobs with GIT_FILEMODE_BLOB always instead of being at the mercy to the filesystem driver to report executable or not. This means that if "core.filemode" lies and claims that filemode is not supported, then we will ignore the executable bit from the filesystem. Previously we would have allowed it. This adds an option to the new git_repository_reset_filesystem to recurse through submodules if desired. There may be other types of APIs that would like a "recurse submodules" option, but this one is particularly useful. This also has a number of cleanups, etc., for related things including trying to give better error messages when problems come up from the filesystem. For example, the FAT filesystem driver on MacOS appears to return errno EINVAL if you attempt to write a filename with invalid UTF-8 in it. We try to capture that with a better error message now.

da7b78fa

2013-10-04T14:03:12

index: Make _read() cope with index file creation

thodg/libgit2/src/index.c

src/index.c

Log