patch, 2 partsDelete ref $frotz by moving ref file to "deleted-$frotz~ref".

refs.c, refs.h

diff --git a/refs.c b/refs.c
index 89cffaf..6a8da58 100644
--- a/refs.c
+++ b/refs.c
@@ -176,6 +176,38 @@ static struct ref_list *get_loose_refs(v
 	return cached_refs.loose;
 }
 
+static char *get_del_ref_name(const char *ref_name)
+{
+	size_t ref_name_len = strlen(ref_name);
+	char *delref_name = xmalloc(ref_name_len + 13);
+
+	strncpy(delref_name, "deleted-", 8);
+	strncpy(delref_name + 8, ref_name, ref_name_len);
+	strcpy(delref_name + 8 + ref_name_len, "~ref");
+
+	return delref_name;
+}
+
+static int lstat_del_ref_file(const char *ref_name, struct stat *st)
+{
+	char *delref_name = get_del_ref_name(ref_name);
+	char *delref_file = git_path("%s", delref_name);
+
+	int ret = lstat(delref_file, st);
+
+	free(delref_name);
+	return ret;
+}
+
+static char *get_del_ref_file(const char *ref_name)
+{
+	char *delref_name = get_del_ref_name(ref_name);
+	char *delref_file = xstrdup(git_path("%s", delref_name));
+
+	free(delref_name);
+	return delref_file;
+}
+
 /* We allow "recursive" symbolic refs. Only within reason, though */
 #define MAXDEPTH 5
 
@@ -204,6 +236,17 @@ const char *resolve_ref(const char *ref,
 		 * born.  It is NOT OK if we are resolving for
 		 * reading.
 		 */
+
+		if (!lstat_del_ref_file(ref, &st)) {
+			/* The ref has been deleted. */
+			if (flag)
+				*flag |= REF_ISDELETED;
+			if (reading)
+				return NULL;
+			hashclr(sha1);
+			return ref;
+		}
+
 		if (lstat(path, &st) < 0) {
 			struct ref_list *list = get_packed_refs();
 			while (list) {
@@ -541,12 +584,14 @@ static struct ref_lock *lock_ref_sha1_ba
 	struct ref_lock *lock;
 	struct stat st;
 	int last_errno = 0;
+	int default_flag;
+	int *ref_flag = flag ? flag : &default_flag;
 	int mustexist = (old_sha1 && !is_null_sha1(old_sha1));
 
 	lock = xcalloc(1, sizeof(struct ref_lock));
 	lock->lock_fd = -1;
 
-	ref = resolve_ref(ref, lock->old_sha1, mustexist, flag);
+	ref = resolve_ref(ref, lock->old_sha1, mustexist, ref_flag);
 	if (!ref && errno == EISDIR) {
 		/* we are trying to lock foo but we used to
 		 * have foo/bar which now does not exist;
@@ -559,7 +604,7 @@ static struct ref_lock *lock_ref_sha1_ba
 			error("there are still refs under '%s'", orig_ref);
 			goto error_return;
 		}
-		ref = resolve_ref(orig_ref, lock->old_sha1, mustexist, flag);
+		ref = resolve_ref(orig_ref, lock->old_sha1, mustexist, ref_flag);
 	}
 	if (!ref) {
 		last_errno = errno;
@@ -568,7 +613,8 @@ static struct ref_lock *lock_ref_sha1_ba
 		goto error_return;
 	}
 	if (is_null_sha1(lock->old_sha1)) {
-		/* The ref did not exist and we are creating it.
+		/* The ref did not exist (or has been deleted)
+		 * and we are (re)creating it.
 		 * Make sure there is no existing ref that is packed
 		 * whose name begins with our refname, nor a ref whose
 		 * name is a proper prefix of our refname.
@@ -580,15 +626,19 @@ static struct ref_lock *lock_ref_sha1_ba
 			int len = strlen(list->name);
 			int cmplen = (namlen < len) ? namlen : len;
 			const char *lead = (namlen < len) ? list->name : ref;
+			struct stat st;
 
 			if (!strncmp(ref, list->name, cmplen) &&
-			    lead[cmplen] == '/') {
+			    lead[cmplen] == '/' &&
+			    lstat_del_ref_file(list->name, &st)) {
 				error("'%s' exists; cannot create '%s'",
 				      list->name, ref);
 				goto error_return;
 			}
 			list = list->next;
 		}
+		if (*ref_flag & REF_ISDELETED)
+			lock->del_file = get_del_ref_file(ref);
 	}
 
 	lock->lk = xcalloc(1, sizeof(struct lock_file));
@@ -627,77 +677,60 @@ struct ref_lock *lock_any_ref_for_update
 	return lock_ref_sha1_basic(ref, old_sha1, NULL);
 }
 
-static struct lock_file packlock;
-
-static int repack_without_ref(const char *refname)
+/* Remove the ref "refs/$frotz" by creating "deleted-refs/$frotz~ref". */
+int delete_ref(const char *ref_name, unsigned char *sha1)
 {
-	struct ref_list *list, *packed_ref_list;
-	int fd;
-	int found = 0;
+	int flag = 0;
+	static char term = '\n';
+	struct ref_lock *lock = lock_ref_sha1_basic(ref_name, sha1, &flag);
 
-	packed_ref_list = get_packed_refs();
-	for (list = packed_ref_list; list; list = list->next) {
-		if (!strcmp(refname, list->name)) {
-			found = 1;
-			break;
-		}
+	if (!lock)
+		return -1;
+	if (flag & REF_ISDELETED) {
+		unlock_ref(lock);
+		return 0; /* Already deleted is ok. */
 	}
-	if (!found)
-		return 0;
-	memset(&packlock, 0, sizeof(packlock));
-	fd = hold_lock_file_for_update(&packlock, git_path("packed-refs"), 0);
-	if (fd < 0)
-		return error("cannot delete '%s' from packed refs", refname);
-
-	for (list = packed_ref_list; list; list = list->next) {
-		char line[PATH_MAX + 100];
-		int len;
-
-		if (!strcmp(refname, list->name))
-			continue;
-		len = snprintf(line, sizeof(line), "%s %s\n",
-			       sha1_to_hex(list->sha1), list->name);
-		/* this should not happen but just being defensive */
-		if (len > sizeof(line))
-			die("too long a refname '%s'", list->name);
-		write_or_die(fd, line, len);
+	if (write(lock->lock_fd, sha1_to_hex(sha1), 40) != 40 ||
+	    write(lock->lock_fd, &term, 1) != 1
+		|| close(lock->lock_fd) < 0) {
+		error("Couldn't write %s", lock->lk->filename);
+		unlock_ref(lock);
+		return -1;
 	}
-	return commit_lock_file(&packlock);
-}
-
-int delete_ref(const char *refname, unsigned char *sha1)
-{
-	struct ref_lock *lock;
-	int err, i, ret = 0, flag = 0;
-
-	lock = lock_ref_sha1_basic(refname, sha1, &flag);
-	if (!lock)
-		return 1;
+	invalidate_cached_refs();
 	if (!(flag & REF_ISPACKED)) {
 		/* loose */
-		i = strlen(lock->lk->filename) - 5; /* .lock */
+		int i = strlen(lock->lk->filename) - 5; /* .lock */
 		lock->lk->filename[i] = 0;
-		err = unlink(lock->lk->filename);
-		if (err) {
-			ret = 1;
+		if (unlink(lock->lk->filename)) {
 			error("unlink(%s) failed: %s",
 			      lock->lk->filename, strerror(errno));
+			unlock_ref(lock);
+			return -1;
 		}
 		lock->lk->filename[i] = '.';
 	}
-	/* removing the loose one could have resurrected an earlier
-	 * packed one.  Also, if it was not loose we need to repack
-	 * without it.
-	 */
-	ret |= repack_without_ref(refname);
-
-	err = unlink(lock->log_file);
-	if (err && errno != ENOENT)
+	if (unlink(lock->log_file) && errno != ENOENT)
 		fprintf(stderr, "warning: unlink(%s) failed: %s",
 			lock->log_file, strerror(errno));
-	invalidate_cached_refs();
+	if (!lock->del_file)
+		lock->del_file = get_del_ref_file(ref_name);
+	if (safe_create_leading_directories(lock->del_file)) {
+		error("unable to create directory for %s: %s",
+		      lock->del_file, strerror(errno));
+		unlock_ref(lock);
+		return -1;
+	}
+	if (rename(lock->lk->filename, lock->del_file)) {
+		error("rename(%s -> %s) failed: %s",
+		      lock->lk->filename, lock->del_file,
+		      strerror(errno));
+		unlock_ref(lock);
+		return -1;
+	}
+	lock->lock_fd = -1;
 	unlock_ref(lock);
-	return ret;
+	return 0;
 }
 
 void unlock_ref(struct ref_lock *lock)
@@ -710,6 +743,7 @@ void unlock_ref(struct ref_lock *lock)
 	}
 	free(lock->ref_name);
 	free(lock->log_file);
+	free(lock->del_file);
 	free(lock);
 }
 
@@ -786,6 +820,12 @@ int write_ref_sha1(struct ref_lock *lock
 		unlock_ref(lock);
 		return -1;
 	}
+	if (lock->del_file && unlink(lock->del_file) && errno != ENOENT) {
+		error("unlink(%s) failed: %s",
+		      lock->del_file, strerror(errno));
+		unlock_ref(lock);
+		return -1;
+	}
 	if (commit_lock_file(lock->lk)) {
 		error("Couldn't set %s", lock->ref_name);
 		unlock_ref(lock);
diff --git a/refs.h b/refs.h
index a57d437..5aa7755 100644
--- a/refs.h
+++ b/refs.h
@@ -4,6 +4,7 @@ #define REFS_H
 struct ref_lock {
 	char *ref_name;
 	char *log_file;
+	char *del_file;
 	struct lock_file *lk;
 	unsigned char old_sha1[20];
 	int lock_fd;
@@ -16,6 +17,7 @@ struct ref_lock {
  */
 #define REF_ISSYMREF 01
 #define REF_ISPACKED 02
+#define REF_ISDELETED 04
 typedef int each_ref_fn(const char *refname, const unsigned char *sha1, int flags, void *cb_data);
 extern int head_ref(each_ref_fn, void *);
 extern int for_each_ref(each_ref_fn, void *);