Git 到底在磁盘上
做了什么？

static struct cmd_struct commands[] = {
	{ "add", cmd_add, RUN_SETUP | NEED_WORK_TREE },
	{ "am", cmd_am, RUN_SETUP | NEED_WORK_TREE },
	...
	{ "commit", cmd_commit, RUN_SETUP | NEED_WORK_TREE },
	...
};

int add_to_index(struct index_state *istate, const char *path,
		 struct stat *st, int flags)
{
	...
	unsigned hash_flags = pretend ? 0 : INDEX_WRITE_OBJECT;
	...
	ce = make_empty_cache_entry(istate, namelen);
	memcpy(ce->name, path, namelen);
	ce->ce_namelen = namelen;
	if (!intent_only)
		fill_stat_cache_info(istate, ce, st);
	...
	if (!intent_only) {
		if (index_path(istate, &ce->oid, path, st, hash_flags)) {
			discard_cache_entry(ce);
			return error(_("unable to index file '%s'"), path);
		}
	} else
		set_object_name_for_intent_to_add_entry(ce);
	...

int add_index_entry(struct index_state *istate, struct cache_entry *ce, int option)
{
	int pos;
	...
	ALLOC_GROW(istate->cache, istate->cache_nr + 1,
		   istate->cache_alloc);
	istate->cache_nr++;
	if (istate->cache_nr > pos + 1)
		MOVE_ARRAY(istate->cache + pos + 1,
			   istate->cache + pos,
			   istate->cache_nr - pos - 1);
	set_index_entry(istate, pos, ce);
	istate->cache_changed |= CE_ENTRY_ADDED;
	return 0;
}

	repo_hold_locked_index(the_repository, &index_lock,
			       LOCK_DIE_ON_ERROR);
	add_remove_files(&partial);
	refresh_index(the_repository->index, REFRESH_QUIET,
		      NULL, NULL, NULL);
	cache_tree_update(the_repository->index, WRITE_TREE_SILENT);
	if (write_locked_index(the_repository->index, &index_lock, 0))
		die(_("unable to write new index file"));

	if (commit_tree_extended(sb.buf, sb.len,
				 &the_repository->index->cache_tree->oid,
				 parents, &oid, author_ident.buf, NULL,
				 sign_commit, extra)) {
		rollback_index_files();
		die(_("failed to write commit object"));
	}

	if (update_head_with_reflog(current_head, &oid, reflog_msg, &sb,
				    &err)) {
		rollback_index_files();
		die("%s", err.buf);
	}

int format_object_header(char *str, size_t size, enum object_type type,
			 size_t objsize)
{
	const char *name = type_name(type);
	...
	return xsnprintf(str, size, "%s %"PRIuMAX,
			 name, (uintmax_t)objsize) + 1;
}

void hash_object_file(const struct git_hash_algo *algo, const void *buf,
		      size_t len, enum object_type type,
		      struct object_id *oid)
{
	struct git_hash_ctx c;
	char hdr[MAX_HEADER_LEN];
	int hdrlen;

	hdrlen = format_object_header(hdr, sizeof(hdr), type, len);

	git_hash_init(&c, algo);
	git_hash_update(&c, hdr, hdrlen);
	git_hash_update(&c, buf, len);
	git_hash_final_oid(oid, &c);
}

struct cache_entry {
	struct hashmap_entry ent;
	struct stat_data ce_stat_data;
	unsigned int ce_mode;
	unsigned int ce_flags;
	unsigned int mem_pool_allocated;
	unsigned int ce_namelen;
	unsigned int index;	/* for link extension */
	struct object_id oid;
	char name[FLEX_ARRAY]; /* more */
};

static enum ref_transaction_error write_ref_to_lockfile(
		struct files_ref_store *refs, struct ref_lock *lock,
		const struct object_id *oid, struct strbuf *err)
{
	static char term = '\n';
	int fd;

	fd = get_lock_file_fd(&lock->lk);
	if (write_in_full(fd, oid_to_hex(oid),
			  refs->base.repo->hash_algo->hexsz) < 0 ||
	    write_in_full(fd, &term, 1) < 0 ||
	    fsync_component(FSYNC_COMPONENT_REFERENCE,
			    get_lock_file_fd(&lock->lk)) < 0 ||
	    close_ref_gently(lock) < 0) {
		...
		return REF_TRANSACTION_ERROR_GENERIC;
	}
	return 0;
}

int refs_update_ref(struct ref_store *refs, const char *msg,
		    const char *refname, const struct object_id *new_oid,
		    const struct object_id *old_oid, unsigned int flags,
		    enum action_on_err onerr)
{
	...
	t = ref_store_transaction_begin(refs, 0, &err);
	if (!t ||
	    ref_transaction_update(t, refname, new_oid, old_oid,
				   NULL, NULL, flags, msg, &err) ||
	    ref_transaction_commit(t, &err)) {
		ret = 1;
		...
	}

    fanout: 256 * 4 bytes
        fanout[i] = number of objects whose first byte is <= i

    object names: N * hash_size
        sorted by object name

    CRC32: N * 4 bytes
    offsets: N * 4 bytes
    large offsets: M * 8 bytes
    pack checksum: hash_size
    idx checksum: hash_size