/*

 * Copyright (C) the libgit2 contributors. All rights reserved.

 *

 * This file is part of libgit2, distributed under the GNU GPL v2 with

 * a Linking Exception. For full terms see the included COPYING file.

 */

#if defined(GIT_MSVC_CRTDBG)

#include "w32_stack.h"

#include "w32_crtdbg_stacktrace.h"

#define CRTDBG_STACKTRACE__UID_LEN (15)

/**

 * The stacktrace of an allocation can be distilled

 * to a unique id based upon the stackframe pointers

 * and ignoring any size arguments. We will use these

 * UIDs as the (char const*) __FILE__ argument we

 * give to the CRT malloc routines.

 */

typedef struct {

	char uid[CRTDBG_STACKTRACE__UID_LEN + 1];

} git_win32__crtdbg_stacktrace__uid;

/**

 * All mallocs with the same stacktrace will be de-duped

 * and aggregated into this row.

 */

typedef struct {

	git_win32__crtdbg_stacktrace__uid uid; /* must be first */

	git_win32__stack__raw_data raw_data;

	unsigned int count_allocs; /* times this alloc signature seen since init */

	unsigned int count_allocs_at_last_checkpoint; /* times since last mark */

	unsigned int transient_count_leaks; /* sum of leaks */

} git_win32__crtdbg_stacktrace__row;

static CRITICAL_SECTION g_crtdbg_stacktrace_cs;

/**

 * CRTDBG memory leak tracking takes a "char const * const file_name"

 * and stores the pointer in the heap data (instead of allocing a copy

 * for itself).  Normally, this is not a problem, since we usually pass

 * in __FILE__.  But I'm going to lie to it and pass in the address of

 * the UID in place of the file_name.  Also, I do not want to alloc the

 * stacktrace data (because we are called from inside our alloc routines).

 * Therefore, I'm creating a very large static pool array to store row

 * data. This also eliminates the temptation to realloc it (and move the

 * UID pointers).

 *

 * And to efficiently look for duplicates we need an index on the rows

 * so we can bsearch it.  Again, without mallocing.

 *

 * If we observe more than MY_ROW_LIMIT unique malloc signatures, we

 * fall through and use the traditional __FILE__ processing and don't

 * try to de-dup them.  If your testing hits this limit, just increase

 * it and try again.

 */

#define MY_ROW_LIMIT (1024 * 1024)

static git_win32__crtdbg_stacktrace__row  g_cs_rows[MY_ROW_LIMIT];

static git_win32__crtdbg_stacktrace__row *g_cs_index[MY_ROW_LIMIT];

static unsigned int g_cs_end = MY_ROW_LIMIT;

static unsigned int g_cs_ins = 0; /* insertion point == unique allocs seen */

static unsigned int g_count_total_allocs = 0; /* number of allocs seen */

static unsigned int g_transient_count_total_leaks = 0; /* number of total leaks */

static unsigned int g_transient_count_dedup_leaks = 0; /* number of unique leaks */

static bool g_limit_reached = false; /* had allocs after we filled row table */

static unsigned int g_checkpoint_id = 0; /* to better label leak checkpoints */

static bool g_transient_leaks_since_mark = false; /* payload for hook */

/**

 * Compare function for bsearch on g_cs_index table.

 */

static int row_cmp(const void *v1, const void *v2)

{

	git_win32__stack__raw_data *d1 = (git_win32__stack__raw_data*)v1;

	git_win32__crtdbg_stacktrace__row *r2 = (git_win32__crtdbg_stacktrace__row *)v2;

	return (git_win32__stack_compare(d1, &r2->raw_data));

}

/**

 * Unique insert the new data into the row and index tables.

 * We have to sort by the stackframe data itself, not the uid.

 */

static git_win32__crtdbg_stacktrace__row * insert_unique(

	const git_win32__stack__raw_data *pdata)

{

	size_t pos;

	if (git__bsearch(g_cs_index, g_cs_ins, pdata, row_cmp, &pos) < 0) {

		/* Append new unique item to row table. */

		memcpy(&g_cs_rows[g_cs_ins].raw_data, pdata, sizeof(*pdata));

		sprintf(g_cs_rows[g_cs_ins].uid.uid, "##%08lx", g_cs_ins);

		/* Insert pointer to it into the proper place in the index table. */

		if (pos < g_cs_ins)

			memmove(&g_cs_index[pos+1], &g_cs_index[pos], (g_cs_ins - pos)*sizeof(g_cs_index[0]));

		g_cs_index[pos] = &g_cs_rows[g_cs_ins];

		g_cs_ins++;

	}

	g_cs_index[pos]->count_allocs++;

	return g_cs_index[pos];

}

/**

 * Hook function to receive leak data from the CRT. (This includes

 * both "<file_name>:(<line_number>)" data, but also each of the

 * various headers and fields.

 *

 * Scan this for the special "##<pos>" UID forms that we substituted

 * for the "<file_name>".  Map <pos> back to the row data and

 * increment its leak count.

 *

 * See https://msdn.microsoft.com/en-us/library/74kabxyx.aspx

 *

 * We suppress the actual crtdbg output.

 */

static int __cdecl report_hook(int nRptType, char *szMsg, int *retVal)

{

	static int hook_result = TRUE; /* FALSE to get stock dump; TRUE to suppress. */

	unsigned int pos;

	*retVal = 0; /* do not invoke debugger */

	if ((szMsg[0] != '#') || (szMsg[1] != '#'))

		return hook_result;

	if (sscanf(&szMsg[2], "%08lx", &pos) < 1)

		return hook_result;

	if (pos >= g_cs_ins)

		return hook_result;

	if (g_transient_leaks_since_mark) {

		if (g_cs_rows[pos].count_allocs == g_cs_rows[pos].count_allocs_at_last_checkpoint)

			return hook_result;

	}

	g_cs_rows[pos].transient_count_leaks++;

	if (g_cs_rows[pos].transient_count_leaks == 1)

		g_transient_count_dedup_leaks++;

	g_transient_count_total_leaks++;

	return hook_result;

}

/**

 * Write leak data to all of the various places we need.

 * We force the caller to sprintf() the message first

 * because we want to avoid fprintf() because it allocs.

 */

static void my_output(const char *buf)

{

	fwrite(buf, strlen(buf), 1, stderr);

	OutputDebugString(buf);

}

/**

 * For each row with leaks, dump a stacktrace for it.

 */

static void dump_summary(const char *label)

{

	unsigned int k;

	char buf[10 * 1024];

	if (g_transient_count_total_leaks == 0)

		return;

	fflush(stdout);

	fflush(stderr);

	my_output("\n");

	if (g_limit_reached) {

		sprintf(buf,

				"LEAK SUMMARY: de-dup row table[%d] filled. Increase MY_ROW_LIMIT.\n",

				MY_ROW_LIMIT);

		my_output(buf);

	}

	if (!label)

		label = "";

	if (g_transient_leaks_since_mark) {

		sprintf(buf, "LEAK CHECKPOINT %d: leaks %d unique %d: %s\n",

				g_checkpoint_id, g_transient_count_total_leaks, g_transient_count_dedup_leaks, label);

		my_output(buf);

	} else {

		sprintf(buf, "LEAK SUMMARY: TOTAL leaks %d de-duped %d: %s\n",

				g_transient_count_total_leaks, g_transient_count_dedup_leaks, label);

		my_output(buf);

	}

	my_output("\n");

	for (k = 0; k < g_cs_ins; k++) {

		if (g_cs_rows[k].transient_count_leaks > 0) {

			sprintf(buf, "LEAK: %s leaked %d of %d times:\n",

					g_cs_rows[k].uid.uid,

					g_cs_rows[k].transient_count_leaks,

					g_cs_rows[k].count_allocs);

			my_output(buf);

			if (git_win32__stack_format(

					buf, sizeof(buf), &g_cs_rows[k].raw_data,

					NULL, NULL) >= 0) {

				my_output(buf);

			}

			my_output("\n");

		}

	}

	fflush(stderr);

}

void git_win32__crtdbg_stacktrace_init(void)

{

	InitializeCriticalSection(&g_crtdbg_stacktrace_cs);

	EnterCriticalSection(&g_crtdbg_stacktrace_cs);

	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);

	_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_DEBUG | _CRTDBG_MODE_FILE);

	_CrtSetReportMode(_CRT_ERROR,  _CRTDBG_MODE_DEBUG | _CRTDBG_MODE_FILE);

	_CrtSetReportMode(_CRT_WARN,   _CRTDBG_MODE_DEBUG | _CRTDBG_MODE_FILE);

	_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);

	_CrtSetReportFile(_CRT_ERROR,  _CRTDBG_FILE_STDERR);

	_CrtSetReportFile(_CRT_WARN,   _CRTDBG_FILE_STDERR);

	LeaveCriticalSection(&g_crtdbg_stacktrace_cs);

}

int git_win32__crtdbg_stacktrace__dump(

	git_win32__crtdbg_stacktrace_options opt,

	const char *label)

{

	_CRT_REPORT_HOOK old;

	unsigned int k;

	int r = 0;

#define IS_BIT_SET(o,b) (((o) & (b)) != 0)

	bool b_set_mark         = IS_BIT_SET(opt, GIT_WIN32__CRTDBG_STACKTRACE__SET_MARK);

	bool b_leaks_since_mark = IS_BIT_SET(opt, GIT_WIN32__CRTDBG_STACKTRACE__LEAKS_SINCE_MARK);

	bool b_leaks_total      = IS_BIT_SET(opt, GIT_WIN32__CRTDBG_STACKTRACE__LEAKS_TOTAL);

	bool b_quiet            = IS_BIT_SET(opt, GIT_WIN32__CRTDBG_STACKTRACE__QUIET);

	if (b_leaks_since_mark && b_leaks_total) {

		giterr_set(GITERR_INVALID, "cannot combine LEAKS_SINCE_MARK and LEAKS_TOTAL.");

		return GIT_ERROR;

	}

	if (!b_set_mark && !b_leaks_since_mark && !b_leaks_total) {

		giterr_set(GITERR_INVALID, "nothing to do.");

		return GIT_ERROR;

	}

	EnterCriticalSection(&g_crtdbg_stacktrace_cs);

	if (b_leaks_since_mark || b_leaks_total) {

		/* All variables with "transient" in the name are per-dump counters

		 * and reset before each dump.  This lets us handle checkpoints.

		 */

		g_transient_count_total_leaks = 0;

		g_transient_count_dedup_leaks = 0;

		for (k = 0; k < g_cs_ins; k++) {

			g_cs_rows[k].transient_count_leaks = 0;

		}

	}

	g_transient_leaks_since_mark = b_leaks_since_mark;

	old = _CrtSetReportHook(report_hook);

	_CrtDumpMemoryLeaks();

	_CrtSetReportHook(old);

	if (b_leaks_since_mark || b_leaks_total) {

		r = g_transient_count_dedup_leaks;

		if (!b_quiet)

			dump_summary(label);

	}

	if (b_set_mark) {

		for (k = 0; k < g_cs_ins; k++) {

			g_cs_rows[k].count_allocs_at_last_checkpoint = g_cs_rows[k].count_allocs;

		}

		g_checkpoint_id++;

	}

	LeaveCriticalSection(&g_crtdbg_stacktrace_cs);

	return r;

}

void git_win32__crtdbg_stacktrace_cleanup(void)

{

	/* At shutdown/cleanup, dump cummulative leak info

	 * with everything since startup.  This might generate

	 * extra noise if the caller has been doing checkpoint

	 * dumps, but it might also eliminate some false

	 * positives for resources previously reported during

	 * checkpoints.

	 */

	git_win32__crtdbg_stacktrace__dump(

		GIT_WIN32__CRTDBG_STACKTRACE__LEAKS_TOTAL,

		"CLEANUP");

	DeleteCriticalSection(&g_crtdbg_stacktrace_cs);

}

const char *git_win32__crtdbg_stacktrace(int skip, const char *file)

{

	git_win32__stack__raw_data new_data;

	git_win32__crtdbg_stacktrace__row *row;

	const char * result = file;

	if (git_win32__stack_capture(&new_data, skip+1) < 0)

		return result;

	EnterCriticalSection(&g_crtdbg_stacktrace_cs);

	if (g_cs_ins < g_cs_end) {

		row = insert_unique(&new_data);

		result = row->uid.uid;

	} else {

		g_limit_reached = true;

	}

	g_count_total_allocs++;

	LeaveCriticalSection(&g_crtdbg_stacktrace_cs);

	return result;

}

#endif