From a23c2cd59812a536963d88ed70ecd05781003293 Mon Sep 17 00:00:00 2001
From: Ben Peart <Ben.Peart@microsoft.com>
Date: Tue, 24 May 2016 00:32:38 +0000
Subject: [PATCH 01/15] gvfs: add global command pre and post hook procs

This adds hard-coded call to GVFS.hooks.exe before and after each Git
command runs.

To make sure that this is only called on repositories cloned with GVFS, we
test for the tell-tale .gvfs.

Signed-off-by: Ben Peart <Ben.Peart@microsoft.com>
---
 git.c                        | 79 ++++++++++++++++++++++++++++++++++--
 run-command.c                | 51 ++++++++++++++++++++++-
 t/t0400-pre-command-hook.sh  | 34 ++++++++++++++++
 t/t0401-post-command-hook.sh | 32 +++++++++++++++
 4 files changed, 192 insertions(+), 4 deletions(-)
 create mode 100755 t/t0400-pre-command-hook.sh
 create mode 100755 t/t0401-post-command-hook.sh

diff --git a/git.c b/git.c
index 4bdcdad2ccd3e7..ecf49567c823da 100644
--- a/git.c
+++ b/git.c
@@ -5,6 +5,7 @@
 #include "run-command.h"
 #include "alias.h"
 #include "shallow.h"
+#include "dir.h"
 
 #define RUN_SETUP		(1<<0)
 #define RUN_SETUP_GENTLY	(1<<1)
@@ -405,6 +406,63 @@ static int handle_alias(int *argcp, const char ***argv)
 	return ret;
 }
 
+/* Runs pre/post-command hook */
+static struct strvec sargv = STRVEC_INIT;
+static int run_post_hook = 0;
+static int exit_code = -1;
+
+static int run_pre_command_hook(const char **argv)
+{
+	char *lock;
+	int ret = 0;
+
+	/*
+	 * Ensure the global pre/post command hook is only called for
+	 * the outer command and not when git is called recursively
+	 * or spawns multiple commands (like with the alias command)
+	 */
+	lock = getenv("COMMAND_HOOK_LOCK");
+	if (lock && !strcmp(lock, "true"))
+		return 0;
+	setenv("COMMAND_HOOK_LOCK", "true", 1);
+
+	/* call the hook proc */
+	strvec_pushv(&sargv, argv);
+	ret = run_hook_strvec(NULL, "pre-command", &sargv);
+
+	if (!ret)
+		run_post_hook = 1;
+	return ret;
+}
+
+static int run_post_command_hook(void)
+{
+	char *lock;
+	int ret = 0;
+
+	/*
+	 * Only run post_command if pre_command succeeded in this process
+	 */
+	if (!run_post_hook)
+		return 0;
+	lock = getenv("COMMAND_HOOK_LOCK");
+	if (!lock || strcmp(lock, "true"))
+		return 0;
+
+	strvec_pushf(&sargv, "--exit_code=%u", exit_code);
+	ret = run_hook_strvec(NULL, "post-command", &sargv);
+
+	run_post_hook = 0;
+	strvec_clear(&sargv);
+	setenv("COMMAND_HOOK_LOCK", "false", 1);
+	return ret;
+}
+
+static void post_command_hook_atexit(void)
+{
+	run_post_command_hook();
+}
+
 static int run_builtin(struct cmd_struct *p, int argc, const char **argv)
 {
 	int status, help;
@@ -441,18 +499,23 @@ static int run_builtin(struct cmd_struct *p, int argc, const char **argv)
 	if (!help && p->option & NEED_WORK_TREE)
 		setup_work_tree();
 
+	if (run_pre_command_hook(argv))
+		die("pre-command hook aborted command");
+
 	trace_argv_printf(argv, "trace: built-in: git");
 	trace2_cmd_name(p->cmd);
 	trace2_cmd_list_config();
 	trace2_cmd_list_env_vars();
 
 	validate_cache_entries(the_repository->index);
-	status = p->fn(argc, argv, prefix);
+	exit_code = status = p->fn(argc, argv, prefix);
 	validate_cache_entries(the_repository->index);
 
 	if (status)
 		return status;
 
+	run_post_command_hook();
+
 	/* Somebody closed stdout? */
 	if (fstat(fileno(stdout), &st))
 		return 0;
@@ -728,13 +791,16 @@ static void execv_dashed_external(const char **argv)
 	 */
 	trace_argv_printf(cmd.args.v, "trace: exec:");
 
+	if (run_pre_command_hook(cmd.args.v))
+		die("pre-command hook aborted command");
+
 	/*
 	 * If we fail because the command is not found, it is
 	 * OK to return. Otherwise, we just pass along the status code,
 	 * or our usual generic code if we were not even able to exec
 	 * the program.
 	 */
-	status = run_command(&cmd);
+	exit_code = status = run_command(&cmd);
 
 	/*
 	 * If the child process ran and we are now going to exit, emit a
@@ -745,6 +811,8 @@ static void execv_dashed_external(const char **argv)
 		exit(status);
 	else if (errno != ENOENT)
 		exit(128);
+
+	run_post_command_hook();
 }
 
 static int run_argv(int *argcp, const char ***argv)
@@ -852,6 +920,7 @@ int cmd_main(int argc, const char **argv)
 	}
 
 	trace_command_performance(argv);
+	atexit(post_command_hook_atexit);
 
 	/*
 	 * "git-xxxx" is the same as "git xxxx", but we obviously:
@@ -879,10 +948,14 @@ int cmd_main(int argc, const char **argv)
 	} else {
 		/* The user didn't specify a command; give them help */
 		commit_pager_choice();
+		if (run_pre_command_hook(argv))
+			die("pre-command hook aborted command");
 		printf(_("usage: %s\n\n"), git_usage_string);
 		list_common_cmds_help();
 		printf("\n%s\n", _(git_more_info_string));
-		exit(1);
+		exit_code = 1;
+		run_post_command_hook();
+		exit(exit_code);
 	}
 	cmd = argv[0];
 
diff --git a/run-command.c b/run-command.c
index afcda96f1d0ffa..e003e514016013 100644
--- a/run-command.c
+++ b/run-command.c
@@ -7,6 +7,7 @@
 #include "strbuf.h"
 #include "string-list.h"
 #include "quote.h"
+#include "config.h"
 
 void child_process_init(struct child_process *child)
 {
@@ -1309,12 +1310,60 @@ int async_with_fork(void)
 #endif
 }
 
+static int early_hooks_path_config(const char *var, const char *value, void *data)
+{
+	if (!strcmp(var, "core.hookspath"))
+		return git_config_pathname((const char **)data, var, value);
+
+	return 0;
+}
+
+/* Discover the hook before setup_git_directory() was called */
+static const char *hook_path_early(const char *name, struct strbuf *result)
+{
+	static struct strbuf hooks_dir = STRBUF_INIT;
+	static int initialized;
+
+	if (initialized < 0)
+		return NULL;
+
+	if (!initialized) {
+		struct strbuf gitdir = STRBUF_INIT, commondir = STRBUF_INIT;
+		const char *early_hooks_dir = NULL;
+
+		if (discover_git_directory(&commondir, &gitdir) < 0) {
+			initialized = -1;
+			return NULL;
+		}
+
+		read_early_config(early_hooks_path_config, &early_hooks_dir);
+		if (!early_hooks_dir)
+			strbuf_addf(&hooks_dir, "%s/hooks/", commondir.buf);
+		else {
+			strbuf_add_absolute_path(&hooks_dir, early_hooks_dir);
+			strbuf_addch(&hooks_dir, '/');
+		}
+
+		strbuf_release(&gitdir);
+		strbuf_release(&commondir);
+
+		initialized = 1;
+	}
+
+	strbuf_addf(result, "%s%s", hooks_dir.buf, name);
+	return result->buf;
+}
+
 const char *find_hook(const char *name)
 {
 	static struct strbuf path = STRBUF_INIT;
 
 	strbuf_reset(&path);
-	strbuf_git_path(&path, "hooks/%s", name);
+	if (have_git_dir())
+		strbuf_git_path(&path, "hooks/%s", name);
+	else if (!hook_path_early(name, &path))
+		return NULL;
+
 	if (access(path.buf, X_OK) < 0) {
 		int err = errno;
 
diff --git a/t/t0400-pre-command-hook.sh b/t/t0400-pre-command-hook.sh
new file mode 100755
index 00000000000000..4f4f610b52b0a0
--- /dev/null
+++ b/t/t0400-pre-command-hook.sh
@@ -0,0 +1,34 @@
+#!/bin/sh
+
+test_description='pre-command hook'
+
+. ./test-lib.sh
+
+test_expect_success 'with no hook' '
+	echo "first" > file &&
+	git add file &&
+	git commit -m "first"
+'
+
+test_expect_success 'with succeeding hook' '
+	mkdir -p .git/hooks &&
+	write_script .git/hooks/pre-command <<-EOF &&
+	echo "\$*" >\$(git rev-parse --git-dir)/pre-command.out
+	EOF
+	echo "second" >> file &&
+	git add file &&
+	test "add file" = "$(cat .git/pre-command.out)" &&
+	echo Hello | git hash-object --stdin &&
+	test "hash-object --stdin" = "$(cat .git/pre-command.out)"
+'
+
+test_expect_success 'with failing hook' '
+	write_script .git/hooks/pre-command <<-EOF &&
+	exit 1
+	EOF
+	echo "third" >> file &&
+	test_must_fail git add file &&
+	test_path_is_missing "$(cat .git/pre-command.out)"
+'
+
+test_done
diff --git a/t/t0401-post-command-hook.sh b/t/t0401-post-command-hook.sh
new file mode 100755
index 00000000000000..64646f7ad03b57
--- /dev/null
+++ b/t/t0401-post-command-hook.sh
@@ -0,0 +1,32 @@
+#!/bin/sh
+
+test_description='post-command hook'
+
+. ./test-lib.sh
+
+test_expect_success 'with no hook' '
+	echo "first" > file &&
+	git add file &&
+	git commit -m "first"
+'
+
+test_expect_success 'with succeeding hook' '
+	mkdir -p .git/hooks &&
+	write_script .git/hooks/post-command <<-EOF &&
+	echo "\$*" >\$(git rev-parse --git-dir)/post-command.out
+	EOF
+	echo "second" >> file &&
+	git add file &&
+	test "add file --exit_code=0" = "$(cat .git/post-command.out)"
+'
+
+test_expect_success 'with failing pre-command hook' '
+	write_script .git/hooks/pre-command <<-EOF &&
+	exit 1
+	EOF
+	echo "third" >> file &&
+	test_must_fail git add file &&
+	test_path_is_missing "$(cat .git/post-command.out)"
+'
+
+test_done

From 336f8c88bb141a6c2d28b7b8c9e15af232c9c4db Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johasc@microsoft.com>
Date: Thu, 16 Mar 2017 21:07:54 +0100
Subject: [PATCH 02/15] t0400: verify that the hook is called correctly from a
 subdirectory

Suggested by Ben Peart.

Signed-off-by: Johannes Schindelin <johasc@microsoft.com>
---
 t/t0400-pre-command-hook.sh | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/t/t0400-pre-command-hook.sh b/t/t0400-pre-command-hook.sh
index 4f4f610b52b0a0..83c453c9643eae 100755
--- a/t/t0400-pre-command-hook.sh
+++ b/t/t0400-pre-command-hook.sh
@@ -31,4 +31,27 @@ test_expect_success 'with failing hook' '
 	test_path_is_missing "$(cat .git/pre-command.out)"
 '
 
+test_expect_success 'in a subdirectory' '
+	echo touch i-was-here | write_script .git/hooks/pre-command &&
+	mkdir sub &&
+	(
+		cd sub &&
+		git version
+	) &&
+	test_path_is_file sub/i-was-here
+'
+
+test_expect_success 'in a subdirectory, using an alias' '
+	git reset --hard &&
+	echo "echo \"\$@; \$(pwd)\" >>log" |
+	write_script .git/hooks/pre-command &&
+	mkdir -p sub &&
+	(
+		cd sub &&
+		git -c alias.v="version" v
+	) &&
+	test_path_is_missing log &&
+	test_line_count = 2 sub/log
+'
+
 test_done

From cd1a9c5e84507fd3e1cd752a7cf6bfe3d6570b6a Mon Sep 17 00:00:00 2001
From: Alejandro Pauly <alpauly@microsoft.com>
Date: Mon, 10 Apr 2017 13:26:14 -0400
Subject: [PATCH 03/15] Pass PID of git process to hooks.

Signed-off-by: Alejandro Pauly <alpauly@microsoft.com>
---
 git.c                        | 1 +
 t/t0400-pre-command-hook.sh  | 3 ++-
 t/t0401-post-command-hook.sh | 3 ++-
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/git.c b/git.c
index ecf49567c823da..e52ae487ff6adb 100644
--- a/git.c
+++ b/git.c
@@ -428,6 +428,7 @@ static int run_pre_command_hook(const char **argv)
 
 	/* call the hook proc */
 	strvec_pushv(&sargv, argv);
+	strvec_pushf(&sargv, "--git-pid=%"PRIuMAX, (uintmax_t)getpid());
 	ret = run_hook_strvec(NULL, "pre-command", &sargv);
 
 	if (!ret)
diff --git a/t/t0400-pre-command-hook.sh b/t/t0400-pre-command-hook.sh
index 83c453c9643eae..f04a55a695bc97 100755
--- a/t/t0400-pre-command-hook.sh
+++ b/t/t0400-pre-command-hook.sh
@@ -13,7 +13,8 @@ test_expect_success 'with no hook' '
 test_expect_success 'with succeeding hook' '
 	mkdir -p .git/hooks &&
 	write_script .git/hooks/pre-command <<-EOF &&
-	echo "\$*" >\$(git rev-parse --git-dir)/pre-command.out
+	echo "\$*" | sed "s/ --git-pid=[0-9]*//" \
+		>\$(git rev-parse --git-dir)/pre-command.out
 	EOF
 	echo "second" >> file &&
 	git add file &&
diff --git a/t/t0401-post-command-hook.sh b/t/t0401-post-command-hook.sh
index 64646f7ad03b57..fcbfc4a0c79c1e 100755
--- a/t/t0401-post-command-hook.sh
+++ b/t/t0401-post-command-hook.sh
@@ -13,7 +13,8 @@ test_expect_success 'with no hook' '
 test_expect_success 'with succeeding hook' '
 	mkdir -p .git/hooks &&
 	write_script .git/hooks/post-command <<-EOF &&
-	echo "\$*" >\$(git rev-parse --git-dir)/post-command.out
+	echo "\$*" | sed "s/ --git-pid=[0-9]*//" \
+		>\$(git rev-parse --git-dir)/post-command.out
 	EOF
 	echo "second" >> file &&
 	git add file &&

From 3938eb290b06ce42183b5460543324998e697a28 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johasc@microsoft.com>
Date: Tue, 8 Aug 2017 00:27:50 +0200
Subject: [PATCH 04/15] pre-command: always respect core.hooksPath

We need to respect that config setting even if we already know that we
have a repository, but have not yet read the config.

The regression test was written by Alejandro Pauly.

Signed-off-by: Johannes Schindelin <johasc@microsoft.com>
---
 run-command.c               | 13 +++++++++++--
 t/t0400-pre-command-hook.sh | 11 +++++++++++
 2 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/run-command.c b/run-command.c
index e003e514016013..fdb7d70c17b9d4 100644
--- a/run-command.c
+++ b/run-command.c
@@ -1359,9 +1359,18 @@ const char *find_hook(const char *name)
 	static struct strbuf path = STRBUF_INIT;
 
 	strbuf_reset(&path);
-	if (have_git_dir())
+	if (have_git_dir()) {
+		static int forced_config;
+
+		if (!forced_config) {
+			if (!git_hooks_path)
+				git_config_get_pathname("core.hookspath",
+							&git_hooks_path);
+			forced_config = 1;
+		}
+
 		strbuf_git_path(&path, "hooks/%s", name);
-	else if (!hook_path_early(name, &path))
+	} else if (!hook_path_early(name, &path))
 		return NULL;
 
 	if (access(path.buf, X_OK) < 0) {
diff --git a/t/t0400-pre-command-hook.sh b/t/t0400-pre-command-hook.sh
index f04a55a695bc97..f2a9115e299385 100755
--- a/t/t0400-pre-command-hook.sh
+++ b/t/t0400-pre-command-hook.sh
@@ -55,4 +55,15 @@ test_expect_success 'in a subdirectory, using an alias' '
 	test_line_count = 2 sub/log
 '
 
+test_expect_success 'with core.hooksPath' '
+	mkdir -p .git/alternateHooks &&
+	write_script .git/alternateHooks/pre-command <<-EOF &&
+	echo "alternate" >\$(git rev-parse --git-dir)/pre-command.out
+	EOF
+	write_script .git/hooks/pre-command <<-EOF &&
+	echo "original"	>\$(git rev-parse --git-dir)/pre-command.out
+	EOF
+	git -c core.hooksPath=.git/alternateHooks status &&
+	test "alternate" = "$(cat .git/pre-command.out)"
+'
 test_done

From 6693e1a019631054d403a954833de3c3a8360c3a Mon Sep 17 00:00:00 2001
From: Kevin Willford <kewillf@microsoft.com>
Date: Wed, 22 Feb 2017 12:50:43 -0700
Subject: [PATCH 05/15] sparse-checkout: update files with a modify/delete
 conflict

When using the sparse-checkout feature, the file might not be on disk
because the skip-worktree bit is on.

Signed-off-by: Kevin Willford <kewillf@microsoft.com>
---
 merge-recursive.c                |  2 +-
 t/t7615-merge-sparse-checkout.sh | 30 ++++++++++++++++++++++++++++++
 2 files changed, 31 insertions(+), 1 deletion(-)
 create mode 100755 t/t7615-merge-sparse-checkout.sh

diff --git a/merge-recursive.c b/merge-recursive.c
index 8b669e5f26cf4a..beaf3722bb4819 100644
--- a/merge-recursive.c
+++ b/merge-recursive.c
@@ -1500,7 +1500,7 @@ static int handle_change_delete(struct merge_options *opt,
 		 * path.  We could call update_file_flags() with update_cache=0
 		 * and update_wd=0, but that's a no-op.
 		 */
-		if (change_branch != opt->branch1 || alt_path)
+		if (change_branch != opt->branch1 || alt_path || !file_exists(update_path))
 			ret = update_file(opt, 0, changed, update_path);
 	}
 	free(alt_path);
diff --git a/t/t7615-merge-sparse-checkout.sh b/t/t7615-merge-sparse-checkout.sh
new file mode 100755
index 00000000000000..8e8208a61d39eb
--- /dev/null
+++ b/t/t7615-merge-sparse-checkout.sh
@@ -0,0 +1,30 @@
+#!/bin/sh
+
+test_description='merge can handle sparse-checkout'
+
+. ./test-lib.sh
+
+# merges with conflicts
+
+test_expect_success 'setup' '
+	test_commit a &&
+	test_commit file &&
+	git checkout -b delete-file &&
+	git rm file.t &&
+	test_tick &&
+	git commit -m "remove file" &&
+	git checkout master &&
+	test_commit modify file.t changed
+'
+
+test_expect_success 'merge conflict deleted file and modified' '
+	echo "/a.t" >.git/info/sparse-checkout &&
+	test_config core.sparsecheckout true &&
+	git checkout -f &&
+	test_path_is_missing file.t &&
+	test_must_fail git merge delete-file &&
+	test_path_is_file file.t &&
+	test "changed" = "$(cat file.t)"
+'
+
+test_done

From 969d3e3503b54536149d79da492d88f1e635926a Mon Sep 17 00:00:00 2001
From: Kevin Willford <kewillf@microsoft.com>
Date: Wed, 1 Mar 2017 15:17:12 -0800
Subject: [PATCH 06/15] sparse-checkout: avoid writing entries with the
 skip-worktree bit

When using the sparse-checkout feature git should not write to the working
directory for files with the skip-worktree bit on.  With the skip-worktree
bit on the file may or may not be in the working directory and if it is
not we don't want or need to create it by calling checkout_entry.

There are two callers of checkout_target.  Both of which check that the
file does not exist before calling checkout_target.  load_current which
make a call to lstat right before calling checkout_target and
check_preimage which will only run checkout_taret it stat_ret is less than
zero.  It sets stat_ret to zero and only if !stat->cached will it lstat
the file and set stat_ret to something other than zero.

This patch checks if skip-worktree bit is on in checkout_target and just
returns so that the entry doesn't not end up in the working directory.
This is so that apply will not create a file in the working directory,
then update the index but not keep the working directory up to date with
the changes that happened in the index.

Signed-off-by: Kevin Willford <kewillf@microsoft.com>
---
 apply.c | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/apply.c b/apply.c
index 3f2c22bc96dbe0..d880cf877bbe11 100644
--- a/apply.c
+++ b/apply.c
@@ -3346,6 +3346,24 @@ static int checkout_target(struct index_state *istate,
 {
 	struct checkout costate = CHECKOUT_INIT;
 
+	/*
+	 * Do not checkout the entry if the skipworktree bit is set
+	 *
+	 * Both callers of this method (check_preimage and load_current)
+	 * check for the existance of the file before calling this
+	 * method so we know that the file doesn't exist at this point
+	 * and we don't need to perform that check again here.
+	 * We just need to check the skip-worktree and return.
+	 *
+	 * This is to prevent git from creating a file in the
+	 * working directory that has the skip-worktree bit on,
+	 * then updating the index from the patch and not keeping
+	 * the working directory version up to date with what it
+	 * changed the index version to be.
+	 */
+	if (ce_skip_worktree(ce))
+		return 0;
+
 	costate.refresh_cache = 1;
 	costate.istate = istate;
 	if (checkout_entry(ce, &costate, NULL, NULL) ||

From 3abacacd3fb9aab7a322b00facf3f37826190205 Mon Sep 17 00:00:00 2001
From: Kevin Willford <kewillf@microsoft.com>
Date: Wed, 15 Mar 2017 16:36:53 -0600
Subject: [PATCH 07/15] Fix reset when using the sparse-checkout feature.

When using the sparse checkout feature the git reset command will add
entries to the index that will have the skip-worktree bit off but will
leave the working directory empty.  File data is lost because the index
version of the files has been changed but there is nothing that is in
the working directory.  This will cause the next status call to show
either deleted for files modified or deleting or nothing for files
added.  The added files should be shown as untracked and modified files
should be shown as modified.

To fix this when the reset is running if there is not a file in the
working directory and if it will be missing with the new index entry or
was not missing in the previous version, we create the previous index
version of the file in the working directory so that status will report
correctly and the files will be availble for the user to deal with.

Signed-off-by: Kevin Willford <kewillf@microsoft.com>
---
 builtin/reset.c                  | 34 +++++++++++++++++++
 t/t7114-reset-sparse-checkout.sh | 58 ++++++++++++++++++++++++++++++++
 2 files changed, 92 insertions(+)
 create mode 100755 t/t7114-reset-sparse-checkout.sh

diff --git a/builtin/reset.c b/builtin/reset.c
index e56834e7cc0eed..7aa305439d4310 100644
--- a/builtin/reset.c
+++ b/builtin/reset.c
@@ -27,6 +27,7 @@
 #include "submodule-config.h"
 #include "strbuf.h"
 #include "quote.h"
+#include "dir.h"
 
 #define REFRESH_INDEX_DELAY_WARNING_IN_MS (2 * 1000)
 
@@ -130,12 +131,45 @@ static void update_index_from_diff(struct diff_queue_struct *q,
 		struct diff_options *opt, void *data)
 {
 	int i;
+	int pos;
 	int intent_to_add = *(int *)data;
 
 	for (i = 0; i < q->nr; i++) {
 		struct diff_filespec *one = q->queue[i]->one;
+		struct diff_filespec *two = q->queue[i]->two;
 		int is_missing = !(one->mode && !is_null_oid(&one->oid));
+		int was_missing = !two->mode && is_null_oid(&two->oid);
 		struct cache_entry *ce;
+		struct cache_entry *ceBefore;
+		struct checkout state = CHECKOUT_INIT;
+
+		/*
+		 * When using the sparse-checkout feature the cache entries that are
+		 * added here will not have the skip-worktree bit set.
+		 * Without this code there is data that is lost because the files that
+		 * would normally be in the working directory are not there and show as
+		 * deleted for the next status or in the case of added files just disappear.
+		 * We need to create the previous version of the files in the working
+		 * directory so that they will have the right content and the next
+		 * status call will show modified or untracked files correctly.
+		 */
+		if (core_apply_sparse_checkout && !file_exists(two->path))
+		{
+			pos = cache_name_pos(two->path, strlen(two->path));
+			if ((pos >= 0 && ce_skip_worktree(active_cache[pos])) && (is_missing || !was_missing))
+			{
+				state.force = 1;
+				state.refresh_cache = 1;
+				state.istate = &the_index;
+				ceBefore = make_cache_entry(&the_index, two->mode, &two->oid, two->path,
+					0, 0);
+				if (!ceBefore)
+					die(_("make_cache_entry failed for path '%s'"),
+						two->path);
+
+				checkout_entry(ceBefore, &state, NULL, NULL);
+			}
+		}
 
 		if (is_missing && !intent_to_add) {
 			remove_file_from_cache(one->path);
diff --git a/t/t7114-reset-sparse-checkout.sh b/t/t7114-reset-sparse-checkout.sh
new file mode 100755
index 00000000000000..c46cbdb64e4ebc
--- /dev/null
+++ b/t/t7114-reset-sparse-checkout.sh
@@ -0,0 +1,58 @@
+#!/bin/sh
+
+test_description='reset when using a sparse-checkout'
+
+. ./test-lib.sh
+
+# reset using a sparse-checkout file
+
+test_expect_success 'setup' '
+	test_tick &&
+	echo "checkout file" >c &&
+	echo "modify file" >m &&
+	echo "delete file" >d &&
+	git add . &&
+	git commit -m "initial commit" &&
+	echo "added file" >a &&
+	echo "modification of a file" >m &&
+	git rm d &&
+	git add . &&
+	git commit -m "second commit" &&
+	git checkout -b endCommit
+'
+
+test_expect_success 'reset when there is a sparse-checkout' '
+	echo "/c" >.git/info/sparse-checkout &&
+	test_config core.sparsecheckout true &&
+	git checkout -B resetBranch &&
+	test_path_is_missing m &&
+	test_path_is_missing a &&
+	test_path_is_missing d &&
+	git reset HEAD~1 &&
+	test "checkout file" = "$(cat c)" &&
+	test "modification of a file" = "$(cat m)" &&
+	test "added file" = "$(cat a)" &&
+	test_path_is_missing d
+'
+
+test_expect_success 'reset after deleting file without skip-worktree bit' '
+	git checkout -f endCommit &&
+	git clean -xdf &&
+	echo "/c
+/m" >.git/info/sparse-checkout &&
+	test_config core.sparsecheckout true &&
+	git checkout -B resetAfterDelete &&
+	test_path_is_file m &&
+	test_path_is_missing a &&
+	test_path_is_missing d &&
+	rm -f m &&
+	git reset HEAD~1 &&
+	test "checkout file" = "$(cat c)" &&
+	test "added file" = "$(cat a)" &&
+	test_path_is_missing m &&
+	test_path_is_missing d
+'
+
+
+
+test_done

From 3fdd44fe056af393bbb27582b773c577c284be5d Mon Sep 17 00:00:00 2001
From: Kevin Willford <kewillf@microsoft.com>
Date: Wed, 5 Apr 2017 10:55:32 -0600
Subject: [PATCH 08/15] Do not remove files outside the sparse-checkout

Signed-off-by: Kevin Willford <kewillf@microsoft.com>
---
 unpack-trees.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/unpack-trees.c b/unpack-trees.c
index cf542868c109f2..ecf59a463a94d1 100644
--- a/unpack-trees.c
+++ b/unpack-trees.c
@@ -543,7 +543,9 @@ static int apply_sparse_checkout(struct index_state *istate,
 			ce->ce_flags &= ~CE_SKIP_WORKTREE;
 			return -1;
 		}
-		ce->ce_flags |= CE_WT_REMOVE;
+		if (!gvfs_config_is_set(GVFS_NO_DELETE_OUTSIDE_SPARSECHECKOUT))
+			ce->ce_flags |= CE_WT_REMOVE;
+
 		ce->ce_flags &= ~CE_UPDATE;
 	}
 	if (was_skip_worktree && !ce_skip_worktree(ce)) {

From b9263f75b325098ae346fa7a6069d77f6c59522d Mon Sep 17 00:00:00 2001
From: Kevin Willford <kewillf@microsoft.com>
Date: Fri, 14 Apr 2017 10:59:20 -0600
Subject: [PATCH 09/15] gvfs: refactor loading the core.gvfs config value

This code change makes sure that the config value for core_gvfs
is always loaded before checking it.

Signed-off-by: Kevin Willford <kewillf@microsoft.com>
---
 Makefile |  1 +
 gvfs.c   | 38 ++++++++++++++++++++++++++++++++++++++
 gvfs.h   | 31 ++-----------------------------
 3 files changed, 41 insertions(+), 29 deletions(-)
 create mode 100644 gvfs.c

diff --git a/Makefile b/Makefile
index 3f4bc82979d4a1..57891978afedf1 100644
--- a/Makefile
+++ b/Makefile
@@ -901,6 +901,7 @@ LIB_OBJS += gettext.o
 LIB_OBJS += gpg-interface.o
 LIB_OBJS += graph.o
 LIB_OBJS += grep.o
+LIB_OBJS += gvfs.o
 LIB_OBJS += hashmap.o
 LIB_OBJS += help.o
 LIB_OBJS += hex.o
diff --git a/gvfs.c b/gvfs.c
new file mode 100644
index 00000000000000..7235199c04ac39
--- /dev/null
+++ b/gvfs.c
@@ -0,0 +1,38 @@
+#include "cache.h"
+#include "gvfs.h"
+#include "config.h"
+
+static int gvfs_config_loaded;
+static int core_gvfs_is_bool;
+
+static int early_core_gvfs_config(const char *var, const char *value, void *data)
+{
+	if (!strcmp(var, "core.gvfs"))
+		core_gvfs = git_config_bool_or_int("core.gvfs", value, &core_gvfs_is_bool);
+	return 0;
+}
+
+void gvfs_load_config_value(const char *value)
+{
+	if (gvfs_config_loaded)
+		return;
+
+	if (value)
+		core_gvfs = git_config_bool_or_int("core.gvfs", value, &core_gvfs_is_bool);
+	else if (startup_info->have_repository == 0)
+		read_early_config(early_core_gvfs_config, NULL);
+	else
+		git_config_get_bool_or_int("core.gvfs", &core_gvfs_is_bool, &core_gvfs);
+
+	/* Turn on all bits if a bool was set in the settings */
+	if (core_gvfs_is_bool && core_gvfs)
+		core_gvfs = -1;
+
+	gvfs_config_loaded = 1;
+}
+
+int gvfs_config_is_set(int mask)
+{
+	gvfs_load_config_value(0);
+	return (core_gvfs & mask) == mask;
+}
diff --git a/gvfs.h b/gvfs.h
index 2d6de575bf4a65..7c9367866f502a 100644
--- a/gvfs.h
+++ b/gvfs.h
@@ -1,8 +1,6 @@
 #ifndef GVFS_H
 #define GVFS_H
 
-#include "cache.h"
-#include "config.h"
 
 /*
  * This file is for the specific settings and methods
@@ -19,32 +17,7 @@
 #define GVFS_FETCH_SKIP_REACHABILITY_AND_UPLOADPACK (1 << 4)
 #define GVFS_BLOCK_FILTERS_AND_EOL_CONVERSIONS      (1 << 6)
 
-static inline int gvfs_config_is_set(int mask) {
-	return (core_gvfs & mask) == mask;
-}
-
-static inline int gvfs_config_is_set_any(void) {
-	return core_gvfs > 0;
-}
-
-static inline void gvfs_load_config_value(const char *value) {
-	int is_bool = 0;
-
-	if (value)
-		core_gvfs = git_config_bool_or_int("core.gvfs", value, &is_bool);
-	else
-		git_config_get_bool_or_int("core.gvfs", &is_bool, &core_gvfs);
-
-	/* Turn on all bits if a bool was set in the settings */
-	if (is_bool && core_gvfs)
-		core_gvfs = -1;
-}
-
-
-static inline int gvfs_config_load_and_is_set(int mask) {
-	gvfs_load_config_value(0);
-	return gvfs_config_is_set(mask);
-}
-
+void gvfs_load_config_value(const char *value);
+int gvfs_config_is_set(int mask);
 
 #endif /* GVFS_H */

From b910c1fe3b45a2d7e98e5093107e1dd0336cb71d Mon Sep 17 00:00:00 2001
From: Kevin Willford <kewillf@microsoft.com>
Date: Fri, 16 Nov 2018 11:28:59 -0700
Subject: [PATCH 10/15] send-pack: do not check for sha1 file when
 GVFS_MISSING_OK set

---
 send-pack.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/send-pack.c b/send-pack.c
index 041712e6295791..ca2cf373e0bcb7 100644
--- a/send-pack.c
+++ b/send-pack.c
@@ -2,6 +2,7 @@
 #include "config.h"
 #include "commit.h"
 #include "refs.h"
+#include "gvfs.h"
 #include "object-store.h"
 #include "pkt-line.h"
 #include "sideband.h"
@@ -51,7 +52,7 @@ static int send_pack_config(const char *var, const char *value, void *unused)
 
 static void feed_object(const struct object_id *oid, FILE *fh, int negative)
 {
-	if (negative &&
+	if (negative && !gvfs_config_is_set(GVFS_MISSING_OK) &&
 	    !has_object_file_with_flags(oid,
 					OBJECT_INFO_SKIP_FETCH_OBJECT |
 					OBJECT_INFO_QUICK))

From d275e6b3636e7298a3bddb50188c7a1b644048a2 Mon Sep 17 00:00:00 2001
From: Kevin Willford <kewillf@microsoft.com>
Date: Mon, 3 Jul 2017 13:39:45 -0600
Subject: [PATCH 11/15] cache-tree: remove use of strbuf_addf in update_one

String formatting can be a performance issue when there are
hundreds of thousands of trees.

Change to stop using the strbuf_addf and just add the strings
or characters individually.

There are a limited number of modes so added a switch for the
known ones and a default case if something comes through that
are not a known one for git.

In one scenario regarding a huge worktree, this reduces the
time required for a `git checkout <branch>` from 44 seconds
to 38 seconds, i.e. it is a non-negligible performance
improvement.

Signed-off-by: Kevin Willford <kewillf@microsoft.com>
---
 cache-tree.c | 24 +++++++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/cache-tree.c b/cache-tree.c
index 9a59dafa26a07d..cc4dfd8c53d402 100644
--- a/cache-tree.c
+++ b/cache-tree.c
@@ -398,7 +398,29 @@ static int update_one(struct cache_tree *it,
 			continue;
 
 		strbuf_grow(&buffer, entlen + 100);
-		strbuf_addf(&buffer, "%o %.*s%c", mode, entlen, path + baselen, '\0');
+
+		switch (mode) {
+		case 0100644:
+			strbuf_add(&buffer, "100644 ", 7);
+			break;
+		case 0100664:
+			strbuf_add(&buffer, "100664 ", 7);
+			break;
+		case 0100755:
+			strbuf_add(&buffer, "100755 ", 7);
+			break;
+		case 0120000:
+			strbuf_add(&buffer, "120000 ", 7);
+			break;
+		case 0160000:
+			strbuf_add(&buffer, "160000 ", 7);
+			break;
+		default:
+			strbuf_addf(&buffer, "%o ", mode);
+			break;
+		}
+		strbuf_add(&buffer, path + baselen, entlen);
+		strbuf_addch(&buffer, '\0');
 		strbuf_add(&buffer, oid->hash, the_hash_algo->rawsz);
 
 #if DEBUG_CACHE_TREE

From 944ebf072a2502846f35488699e49f0c8c3f64ab Mon Sep 17 00:00:00 2001
From: Ben Peart <benpeart@microsoft.com>
Date: Thu, 6 Dec 2018 11:09:19 -0500
Subject: [PATCH 12/15] gvfs: block unsupported commands when running in a GVFS
 repo

The following commands and options are not currently supported when working
in a GVFS repo.  Add code to detect and block these commands from executing.

1) fsck
2) gc
4) prune
5) repack
6) submodule
8) update-index --split-index
9) update-index --index-version (other than 4)
10) update-index --[no-]skip-worktree
11) worktree

Signed-off-by: Ben Peart <benpeart@microsoft.com>
---
 builtin/gc.c                     |  4 ++++
 builtin/update-index.c           | 10 ++++++++
 git.c                            | 15 ++++++++----
 gvfs.h                           |  1 +
 t/t0402-block-command-on-gvfs.sh | 39 ++++++++++++++++++++++++++++++++
 5 files changed, 64 insertions(+), 5 deletions(-)
 create mode 100755 t/t0402-block-command-on-gvfs.sh

diff --git a/builtin/gc.c b/builtin/gc.c
index 090959350e06c0..7c24ac46362c9e 100644
--- a/builtin/gc.c
+++ b/builtin/gc.c
@@ -12,6 +12,7 @@
 
 #include "builtin.h"
 #include "repository.h"
+#include "gvfs.h"
 #include "config.h"
 #include "tempfile.h"
 #include "lockfile.h"
@@ -586,6 +587,9 @@ int cmd_gc(int argc, const char **argv, const char *prefix)
 	if (quiet)
 		strvec_push(&repack, "-q");
 
+	if ((!auto_gc || (auto_gc && gc_auto_threshold > 0)) && gvfs_config_is_set(GVFS_BLOCK_COMMANDS))
+		die(_("'git gc' is not supported on a GVFS repo"));
+
 	if (auto_gc) {
 		/*
 		 * Auto-gc should be least intrusive as possible.
diff --git a/builtin/update-index.c b/builtin/update-index.c
index 79087bccea4b8b..669c5a411e6b73 100644
--- a/builtin/update-index.c
+++ b/builtin/update-index.c
@@ -18,6 +18,7 @@
 #include "dir.h"
 #include "split-index.h"
 #include "fsmonitor.h"
+#include "gvfs.h"
 
 /*
  * Default to not allowing changes to the list of files. The
@@ -1133,7 +1134,13 @@ int cmd_update_index(int argc, const char **argv, const char *prefix)
 	argc = parse_options_end(&ctx);
 
 	getline_fn = nul_term_line ? strbuf_getline_nul : strbuf_getline_lf;
+	if (mark_skip_worktree_only && gvfs_config_is_set(GVFS_BLOCK_COMMANDS))
+		die(_("modifying the skip worktree bit is not supported on a GVFS repo"));
+	
 	if (preferred_index_format) {
+		if (preferred_index_format != 4 && gvfs_config_is_set(GVFS_BLOCK_COMMANDS))
+			die(_("changing the index version is not supported on a GVFS repo"));
+
 		if (preferred_index_format < INDEX_FORMAT_LB ||
 		    INDEX_FORMAT_UB < preferred_index_format)
 			die("index-version %d not in range: %d..%d",
@@ -1169,6 +1176,9 @@ int cmd_update_index(int argc, const char **argv, const char *prefix)
 	}
 
 	if (split_index > 0) {
+		if (gvfs_config_is_set(GVFS_BLOCK_COMMANDS))
+			die(_("split index is not supported on a GVFS repo"));
+
 		if (git_config_get_split_index() == 0)
 			warning(_("core.splitIndex is set to false; "
 				  "remove or change it, if you really want to "
diff --git a/git.c b/git.c
index e52ae487ff6adb..131bb7cb5998c9 100644
--- a/git.c
+++ b/git.c
@@ -6,6 +6,7 @@
 #include "alias.h"
 #include "shallow.h"
 #include "dir.h"
+#include "gvfs.h"
 
 #define RUN_SETUP		(1<<0)
 #define RUN_SETUP_GENTLY	(1<<1)
@@ -18,6 +19,7 @@
 #define SUPPORT_SUPER_PREFIX	(1<<4)
 #define DELAY_PAGER_CONFIG	(1<<5)
 #define NO_PARSEOPT		(1<<6) /* parse-options is not used */
+#define BLOCK_ON_GVFS_REPO	(1<<7) /* command not allowed in GVFS repos */
 
 struct cmd_struct {
 	const char *cmd;
@@ -500,6 +502,9 @@ static int run_builtin(struct cmd_struct *p, int argc, const char **argv)
 	if (!help && p->option & NEED_WORK_TREE)
 		setup_work_tree();
 
+	if (!help && p->option & BLOCK_ON_GVFS_REPO && gvfs_config_is_set(GVFS_BLOCK_COMMANDS))
+		die("'git %s' is not supported on a GVFS repo", p->cmd);
+
 	if (run_pre_command_hook(argv))
 		die("pre-command hook aborted command");
 
@@ -581,7 +586,7 @@ static struct cmd_struct commands[] = {
 	{ "fmt-merge-msg", cmd_fmt_merge_msg, RUN_SETUP },
 	{ "for-each-ref", cmd_for_each_ref, RUN_SETUP },
 	{ "format-patch", cmd_format_patch, RUN_SETUP },
-	{ "fsck", cmd_fsck, RUN_SETUP },
+	{ "fsck", cmd_fsck, RUN_SETUP | BLOCK_ON_GVFS_REPO},
 	{ "fsck-objects", cmd_fsck, RUN_SETUP },
 	{ "gc", cmd_gc, RUN_SETUP },
 	{ "get-tar-commit-id", cmd_get_tar_commit_id, NO_PARSEOPT },
@@ -620,7 +625,7 @@ static struct cmd_struct commands[] = {
 	{ "pack-refs", cmd_pack_refs, RUN_SETUP },
 	{ "patch-id", cmd_patch_id, RUN_SETUP_GENTLY | NO_PARSEOPT },
 	{ "pickaxe", cmd_blame, RUN_SETUP },
-	{ "prune", cmd_prune, RUN_SETUP },
+	{ "prune", cmd_prune, RUN_SETUP | BLOCK_ON_GVFS_REPO},
 	{ "prune-packed", cmd_prune_packed, RUN_SETUP },
 	{ "pull", cmd_pull, RUN_SETUP | NEED_WORK_TREE },
 	{ "push", cmd_push, RUN_SETUP },
@@ -633,7 +638,7 @@ static struct cmd_struct commands[] = {
 	{ "remote", cmd_remote, RUN_SETUP },
 	{ "remote-ext", cmd_remote_ext, NO_PARSEOPT },
 	{ "remote-fd", cmd_remote_fd, NO_PARSEOPT },
-	{ "repack", cmd_repack, RUN_SETUP },
+	{ "repack", cmd_repack, RUN_SETUP | BLOCK_ON_GVFS_REPO },
 	{ "replace", cmd_replace, RUN_SETUP },
 	{ "rerere", cmd_rerere, RUN_SETUP },
 	{ "reset", cmd_reset, RUN_SETUP },
@@ -653,7 +658,7 @@ static struct cmd_struct commands[] = {
 	{ "stash", cmd_stash, RUN_SETUP | NEED_WORK_TREE },
 	{ "status", cmd_status, RUN_SETUP | NEED_WORK_TREE },
 	{ "stripspace", cmd_stripspace },
-	{ "submodule--helper", cmd_submodule__helper, RUN_SETUP | SUPPORT_SUPER_PREFIX | NO_PARSEOPT },
+	{ "submodule--helper", cmd_submodule__helper, RUN_SETUP | SUPPORT_SUPER_PREFIX | NO_PARSEOPT | BLOCK_ON_GVFS_REPO },
 	{ "switch", cmd_switch, RUN_SETUP | NEED_WORK_TREE },
 	{ "symbolic-ref", cmd_symbolic_ref, RUN_SETUP },
 	{ "tag", cmd_tag, RUN_SETUP | DELAY_PAGER_CONFIG },
@@ -671,7 +676,7 @@ static struct cmd_struct commands[] = {
 	{ "verify-tag", cmd_verify_tag, RUN_SETUP },
 	{ "version", cmd_version },
 	{ "whatchanged", cmd_whatchanged, RUN_SETUP },
-	{ "worktree", cmd_worktree, RUN_SETUP | NO_PARSEOPT },
+	{ "worktree", cmd_worktree, RUN_SETUP | NO_PARSEOPT | BLOCK_ON_GVFS_REPO },
 	{ "write-tree", cmd_write_tree, RUN_SETUP },
 };
 
diff --git a/gvfs.h b/gvfs.h
index 7c9367866f502a..e193502151467a 100644
--- a/gvfs.h
+++ b/gvfs.h
@@ -12,6 +12,7 @@
  * The list of bits in the core_gvfs setting
  */
 #define GVFS_SKIP_SHA_ON_INDEX                      (1 << 0)
+#define GVFS_BLOCK_COMMANDS                         (1 << 1)
 #define GVFS_MISSING_OK                             (1 << 2)
 #define GVFS_NO_DELETE_OUTSIDE_SPARSECHECKOUT       (1 << 3)
 #define GVFS_FETCH_SKIP_REACHABILITY_AND_UPLOADPACK (1 << 4)
diff --git a/t/t0402-block-command-on-gvfs.sh b/t/t0402-block-command-on-gvfs.sh
new file mode 100755
index 00000000000000..3370abad464d50
--- /dev/null
+++ b/t/t0402-block-command-on-gvfs.sh
@@ -0,0 +1,39 @@
+#!/bin/sh
+
+test_description='block commands in GVFS repo'
+
+. ./test-lib.sh
+
+not_with_gvfs () {
+    command=$1 &&
+    shift &&
+    test_expect_success "test $command $*" "
+        test_config alias.g4rbled $command &&
+        test_config core.gvfs true &&
+        test_must_fail git $command $* &&
+        test_must_fail git g4rbled $* &&
+        test_unconfig core.gvfs &&
+        test_must_fail git -c core.gvfs=true $command $* &&
+        test_must_fail git -c core.gvfs=true g4rbled $*
+    "
+}
+
+not_with_gvfs fsck
+not_with_gvfs gc
+not_with_gvfs gc --auto
+not_with_gvfs prune
+not_with_gvfs repack
+not_with_gvfs submodule status
+not_with_gvfs update-index --index-version 2
+not_with_gvfs update-index --skip-worktree
+not_with_gvfs update-index --no-skip-worktree
+not_with_gvfs update-index --split-index
+not_with_gvfs worktree list
+
+test_expect_success 'test gc --auto succeeds when disabled via config' '
+	test_config core.gvfs true &&
+	test_config gc.auto 0 &&
+	git gc --auto
+'
+
+test_done

From 9ab63f9c3507bce07892ad0a47d2e32830025a9c Mon Sep 17 00:00:00 2001
From: Derrick Stolee <dstolee@microsoft.com>
Date: Wed, 15 Apr 2020 16:19:31 +0000
Subject: [PATCH 13/15] gvfs: allow overriding core.gvfs

We found a user who had set "core.gvfs = false" in their global
config. This should not have been necessary, but it also should not
have caused a problem. However, it did.

The reason is that gvfs_load_config_value() is called from config.c
when reading config key/value pairs from all the config files. The
local config should override the global config, and this is done by
config.c reading the global config first then reading the local
config. However, our logic only allowed writing the core_gvfs
variable once.

Put the guards against multiple assignments of core_gvfs into
gvfs_config_is_set() instead, because that will fix the problem
_and_ keep multiple calls to gvfs_config_is_set() from slowing down.

Signed-off-by: Derrick Stolee <dstolee@microsoft.com>
---
 gvfs.c                | 10 ++++------
 t/t0021-conversion.sh |  4 ++++
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/gvfs.c b/gvfs.c
index 7235199c04ac39..4360d77075ea0f 100644
--- a/gvfs.c
+++ b/gvfs.c
@@ -14,9 +14,6 @@ static int early_core_gvfs_config(const char *var, const char *value, void *data
 
 void gvfs_load_config_value(const char *value)
 {
-	if (gvfs_config_loaded)
-		return;
-
 	if (value)
 		core_gvfs = git_config_bool_or_int("core.gvfs", value, &core_gvfs_is_bool);
 	else if (startup_info->have_repository == 0)
@@ -27,12 +24,13 @@ void gvfs_load_config_value(const char *value)
 	/* Turn on all bits if a bool was set in the settings */
 	if (core_gvfs_is_bool && core_gvfs)
 		core_gvfs = -1;
-
-	gvfs_config_loaded = 1;
 }
 
 int gvfs_config_is_set(int mask)
 {
-	gvfs_load_config_value(0);
+	if (!gvfs_config_loaded)
+		gvfs_load_config_value(0);
+
+	gvfs_config_loaded = 1;
 	return (core_gvfs & mask) == mask;
 }
diff --git a/t/t0021-conversion.sh b/t/t0021-conversion.sh
index 75e5d77435b4f8..75940df651c9a5 100755
--- a/t/t0021-conversion.sh
+++ b/t/t0021-conversion.sh
@@ -328,6 +328,10 @@ test_expect_success "filter: smudge filters blocked when under GVFS" '
 	test_config filter.empty-in-repo.smudge "echo smudged && cat" &&
 	test_config core.gvfs 64 &&
 
+	test_must_fail git checkout &&
+
+	# ensure the local core.gvfs setting overwrites the global setting
+	git config --global core.gvfs false &&
 	test_must_fail git checkout
 '
 

From 0653afc4a80afe673acdb0fd7a25483faf0320a5 Mon Sep 17 00:00:00 2001
From: Kevin Willford <kewillf@microsoft.com>
Date: Fri, 27 Jul 2018 12:00:44 -0600
Subject: [PATCH 14/15] BRANCHES.md: Add explanation of branches and using
 forks

---
 BRANCHES.md | 53 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 BRANCHES.md

diff --git a/BRANCHES.md b/BRANCHES.md
new file mode 100644
index 00000000000000..cecee7cf7ba6ab
--- /dev/null
+++ b/BRANCHES.md
@@ -0,0 +1,53 @@
+Branches used in this repo
+==========================
+
+The document explains the branching structure that we are using in the VFSForGit repository as well as the forking strategy that we have adopted for contributing.
+
+Repo Branches
+-------------
+
+1. master
+
+    This will track the Git for Windows repository master branch
+
+2. vfs
+
+    Would like to use this branch as an ever-green branch that continually rebases the VFSForGit changes onto a windows ever-green branch that is on the core/master, so that we can detect when the patches for VFSForGit have issues or if we have a new version patches sent upstream git we can regenerate this branch.
+
+3. vs/master
+
+    This tracks with the Git for Windows repository vs/master branch and are the generated files for using a Visual Studio solution.
+
+4. vfs-#
+
+    These branches are used to track the specific version that match Git for Windows with the VFSForGit specific patches on top.  When a new version of Git for Windows is released, the VFSForGit patches will be rebased on that windows version and a new gvfs-# branch created to create pull requests against.
+
+    #### Examples
+
+    ```
+    vfs-2.20.0
+    vfs-2.20.1
+    ```
+
+    The versions of git for VFSForGit are based on the Git for Windows versions.  v2.20.0.vfs.1 will correspond with the v2.20.0.windows.1 with the VFSForGit specific patches applied to the windows version.
+
+Tags
+----
+
+We are using annotated tags to build the version number for git.  The build will look back through the commit history to find the first tag matching `v[0-9]*vfs*` and build the git version number using that tag.
+
+Forking
+-------
+
+A personal fork of this repository and a branch in that repository should be used for development.
+
+These branches should be based on the latest vfs-# branch.  If there are work in progress pull requests that you have based on a previous version branch when a new version branch is created, you will need to move your patches to the new branch to get them in that latest version.
+
+#### Example
+
+```
+git clone <personal fork repo URL>
+git remote add ms https://github.com/Microsoft/git.git
+git checkout -b my-changes ms/vfs-2.20.0 --no-track
+git push -fu origin HEAD
+```

From 5b820702e314a6f54162e1022fb5135fecb3d3e9 Mon Sep 17 00:00:00 2001
From: Johannes Schindelin <johasc@microsoft.com>
Date: Tue, 4 Feb 2020 19:36:46 +0100
Subject: [PATCH 15/15] vfs: disable `git update-git-for-windows`

If a user runs git update-git-for-windows, then they will upgrade to a
version that does not support microsoft/vfsforgit or microsoft/scalar.

Therefore, let's prevent this.

This addresses https://github.com/microsoft/git/issues/241
---
 builtin.h                        |  1 +
 git.c                            |  2 ++
 help.c                           | 16 ++++++++++++++++
 t/t0402-block-command-on-gvfs.sh |  7 +++++++
 4 files changed, 26 insertions(+)

diff --git a/builtin.h b/builtin.h
index 53fb290963377b..f8a86c8f8ab12f 100644
--- a/builtin.h
+++ b/builtin.h
@@ -226,6 +226,7 @@ int cmd_tag(int argc, const char **argv, const char *prefix);
 int cmd_tar_tree(int argc, const char **argv, const char *prefix);
 int cmd_unpack_file(int argc, const char **argv, const char *prefix);
 int cmd_unpack_objects(int argc, const char **argv, const char *prefix);
+int cmd_update(int argc, const char **argv, const char *prefix);
 int cmd_update_index(int argc, const char **argv, const char *prefix);
 int cmd_update_ref(int argc, const char **argv, const char *prefix);
 int cmd_update_server_info(int argc, const char **argv, const char *prefix);
diff --git a/git.c b/git.c
index 131bb7cb5998c9..5ccc764791a4e2 100644
--- a/git.c
+++ b/git.c
@@ -664,6 +664,8 @@ static struct cmd_struct commands[] = {
 	{ "tag", cmd_tag, RUN_SETUP | DELAY_PAGER_CONFIG },
 	{ "unpack-file", cmd_unpack_file, RUN_SETUP | NO_PARSEOPT },
 	{ "unpack-objects", cmd_unpack_objects, RUN_SETUP | NO_PARSEOPT },
+	{ "update", cmd_update },
+	{ "update-git-for-windows", cmd_update },
 	{ "update-index", cmd_update_index, RUN_SETUP },
 	{ "update-ref", cmd_update_ref, RUN_SETUP },
 	{ "update-server-info", cmd_update_server_info, RUN_SETUP },
diff --git a/help.c b/help.c
index 919cbb9206aedf..7b7cd2fee83ac7 100644
--- a/help.c
+++ b/help.c
@@ -722,3 +722,19 @@ NORETURN void help_unknown_ref(const char *ref, const char *cmd,
 	string_list_clear(&suggested_refs, 0);
 	exit(1);
 }
+
+int cmd_update(int argc, const char **argv, const char *prefix)
+{
+	const char * const usage[] = {
+		N_("git update-git-for-windows [<options>]\n"
+		   "\t(not supported in this build of Git for Windows)"),
+		NULL
+	};
+	struct option options[] = {
+		OPT_END()
+	};
+
+	argc = parse_options(argc, argv, prefix, options, usage, 0);
+
+	die(_("git %s is not supported in VFSforGit"), argv[0]);
+}
diff --git a/t/t0402-block-command-on-gvfs.sh b/t/t0402-block-command-on-gvfs.sh
index 3370abad464d50..fd30430b09accc 100755
--- a/t/t0402-block-command-on-gvfs.sh
+++ b/t/t0402-block-command-on-gvfs.sh
@@ -36,4 +36,11 @@ test_expect_success 'test gc --auto succeeds when disabled via config' '
 	git gc --auto
 '
 
+test_expect_success 'update-git-for-windows disabled' '
+	test_must_fail git update 2>out &&
+	test_i18ngrep VFS out &&
+	test_must_fail git update-git-for-windows 2>out &&
+	test_i18ngrep VFS out
+'
+
 test_done