path: root/src/pkg/runtime/race.c

// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Implementation of the race detector API.
// +build race

#include "runtime.h"
#include "arch_GOARCH.h"
#include "malloc.h"
#include "race.h"
#include "type.h"
#include "typekind.h"

// Race runtime functions called via runtime·racecall.
void __tsan_init(void);
void __tsan_fini(void);
void __tsan_map_shadow(void);
void __tsan_finalizer_goroutine(void);
void __tsan_go_start(void);
void __tsan_go_end(void);
void __tsan_malloc(void);
void __tsan_acquire(void);
void __tsan_release(void);
void __tsan_release_merge(void);

// Mimic what cmd/cgo would do.
#pragma cgo_import_static __tsan_init
#pragma cgo_import_static __tsan_fini
#pragma cgo_import_static __tsan_map_shadow
#pragma cgo_import_static __tsan_finalizer_goroutine
#pragma cgo_import_static __tsan_go_start
#pragma cgo_import_static __tsan_go_end
#pragma cgo_import_static __tsan_malloc
#pragma cgo_import_static __tsan_acquire
#pragma cgo_import_static __tsan_release
#pragma cgo_import_static __tsan_release_merge

// These are called from race_amd64.s.
#pragma cgo_import_static __tsan_read
#pragma cgo_import_static __tsan_read_pc
#pragma cgo_import_static __tsan_read_range
#pragma cgo_import_static __tsan_write
#pragma cgo_import_static __tsan_write_pc
#pragma cgo_import_static __tsan_write_range
#pragma cgo_import_static __tsan_func_enter
#pragma cgo_import_static __tsan_func_exit

extern byte noptrdata[];
extern byte enoptrbss[];
  
// start/end of heap for race_amd64.s
uintptr runtime·racearenastart;
uintptr runtime·racearenaend;

void runtime·racefuncenter(void *callpc);
void runtime·racefuncexit(void);
void runtime·racereadrangepc1(void *addr, uintptr sz, void *pc);
void runtime·racewriterangepc1(void *addr, uintptr sz, void *pc);
void runtime·racesymbolizethunk(void*);

// racecall allows calling an arbitrary function f from C race runtime
// with up to 4 uintptr arguments.
void runtime·racecall(void(*f)(void), ...);

uintptr
runtime·raceinit(void)
{
	uintptr racectx, start, size;

	// cgo is required to initialize libc, which is used by race runtime
	if(!runtime·iscgo)
		runtime·throw("raceinit: race build must use cgo");
	runtime·racecall(__tsan_init, &racectx, runtime·racesymbolizethunk);
	// Round data segment to page boundaries, because it's used in mmap().
	start = (uintptr)noptrdata & ~(PageSize-1);
	size = ROUND((uintptr)enoptrbss - start, PageSize);
	runtime·racecall(__tsan_map_shadow, start, size);
	return racectx;
}

void
runtime·racefini(void)
{
	runtime·racecall(__tsan_fini);
}

void
runtime·racemapshadow(void *addr, uintptr size)
{
	if(runtime·racearenastart == 0)
		runtime·racearenastart = (uintptr)addr;
	if(runtime·racearenaend < (uintptr)addr+size)
		runtime·racearenaend = (uintptr)addr+size;
	runtime·racecall(__tsan_map_shadow, addr, size);
}

void
runtime·racemalloc(void *p, uintptr sz)
{
	runtime·racecall(__tsan_malloc, p, sz);
}

uintptr
runtime·racegostart(void *pc)
{
	uintptr racectx;

	runtime·racecall(__tsan_go_start, g->racectx, &racectx, pc);
	return racectx;
}

void
runtime·racegoend(void)
{
	runtime·racecall(__tsan_go_end, g->racectx);
}

void
runtime·racewriterangepc(void *addr, uintptr sz, void *callpc, void *pc)
{
	if(callpc != nil)
		runtime·racefuncenter(callpc);
	runtime·racewriterangepc1(addr, sz, pc);
	if(callpc != nil)
		runtime·racefuncexit();
}

void
runtime·racereadrangepc(void *addr, uintptr sz, void *callpc, void *pc)
{
	if(callpc != nil)
		runtime·racefuncenter(callpc);
	runtime·racereadrangepc1(addr, sz, pc);
	if(callpc != nil)
		runtime·racefuncexit();
}

void
runtime·racewriteobjectpc(void *addr, Type *t, void *callpc, void *pc)
{
	uint8 kind;

	kind = t->kind & ~KindNoPointers;
	if(kind == KindArray || kind == KindStruct)
		runtime·racewriterangepc(addr, t->size, callpc, pc);
	else
		runtime·racewritepc(addr, callpc, pc);
}

void
runtime·racereadobjectpc(void *addr, Type *t, void *callpc, void *pc)
{
	uint8 kind;

	kind = t->kind & ~KindNoPointers;
	if(kind == KindArray || kind == KindStruct)
		runtime·racereadrangepc(addr, t->size, callpc, pc);
	else
		runtime·racereadpc(addr, callpc, pc);
}

void
runtime·raceacquire(void *addr)
{
	runtime·raceacquireg(g, addr);
}

void
runtime·raceacquireg(G *gp, void *addr)
{
	if(g->raceignore)
		return;
	runtime·racecall(__tsan_acquire, gp->racectx, addr);
}

void
runtime·racerelease(void *addr)
{
	runtime·racereleaseg(g, addr);
}

void
runtime·racereleaseg(G *gp, void *addr)
{
	if(g->raceignore)
		return;
	runtime·racecall(__tsan_release, gp->racectx, addr);
}

void
runtime·racereleasemerge(void *addr)
{
	runtime·racereleasemergeg(g, addr);
}

void
runtime·racereleasemergeg(G *gp, void *addr)
{
	if(g->raceignore)
		return;
	runtime·racecall(__tsan_release_merge, gp->racectx, addr);
}

void
runtime·racefingo(void)
{
	runtime·racecall(__tsan_finalizer_goroutine, g->racectx);
}

// func RaceAcquire(addr unsafe.Pointer)
void
runtime·RaceAcquire(void *addr)
{
	runtime·raceacquire(addr);
}

// func RaceRelease(addr unsafe.Pointer)
void
runtime·RaceRelease(void *addr)
{
	runtime·racerelease(addr);
}

// func RaceReleaseMerge(addr unsafe.Pointer)
void
runtime·RaceReleaseMerge(void *addr)
{
	runtime·racereleasemerge(addr);
}

// func RaceSemacquire(s *uint32)
void
runtime·RaceSemacquire(uint32 *s)
{
	runtime·semacquire(s, false);
}

// func RaceSemrelease(s *uint32)
void
runtime·RaceSemrelease(uint32 *s)
{
	runtime·semrelease(s);
}

// func RaceDisable()
void
runtime·RaceDisable(void)
{
	g->raceignore++;
}

// func RaceEnable()
void
runtime·RaceEnable(void)
{
	g->raceignore--;
}

typedef struct SymbolizeContext SymbolizeContext;
struct SymbolizeContext
{
	uintptr	pc;
	int8*	func;
	int8*	file;
	uintptr	line;
	uintptr	off;
	uintptr	res;
};

// Callback from C into Go, runs on g0.
void
runtime·racesymbolize(SymbolizeContext *ctx)
{
	Func *f;
	String file;

	f = runtime·findfunc(ctx->pc);
	if(f == nil) {
		ctx->func = "??";
		ctx->file = "-";
		ctx->line = 0;
		ctx->off = ctx->pc;
		ctx->res = 1;
		return;
	}
	ctx->func = runtime·funcname(f);
	ctx->line = runtime·funcline(f, ctx->pc, &file);
	ctx->file = (int8*)file.str;  // assume zero-terminated
	ctx->off = ctx->pc - f->entry;
	ctx->res = 1;
}