go lockosthread 源码

golang lockosthread 代码

文件路径：/src/runtime/testdata/testprog/lockosthread.go

// Copyright 2017 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.

package main

import (
	"os"
	"runtime"
	"sync"
	"time"
)

var mainTID int

func init() {
	registerInit("LockOSThreadMain", func() {
		// init is guaranteed to run on the main thread.
		mainTID = gettid()
	})
	register("LockOSThreadMain", LockOSThreadMain)

	registerInit("LockOSThreadAlt", func() {
		// Lock the OS thread now so main runs on the main thread.
		runtime.LockOSThread()
	})
	register("LockOSThreadAlt", LockOSThreadAlt)

	registerInit("LockOSThreadAvoidsStatePropagation", func() {
		// Lock the OS thread now so main runs on the main thread.
		runtime.LockOSThread()
	})
	register("LockOSThreadAvoidsStatePropagation", LockOSThreadAvoidsStatePropagation)
	register("LockOSThreadTemplateThreadRace", LockOSThreadTemplateThreadRace)
}

func LockOSThreadMain() {
	// gettid only works on Linux, so on other platforms this just
	// checks that the runtime doesn't do anything terrible.

	// This requires GOMAXPROCS=1 from the beginning to reliably
	// start a goroutine on the main thread.
	if runtime.GOMAXPROCS(-1) != 1 {
		println("requires GOMAXPROCS=1")
		os.Exit(1)
	}

	ready := make(chan bool, 1)
	go func() {
		// Because GOMAXPROCS=1, this *should* be on the main
		// thread. Stay there.
		runtime.LockOSThread()
		if mainTID != 0 && gettid() != mainTID {
			println("failed to start goroutine on main thread")
			os.Exit(1)
		}
		// Exit with the thread locked, which should exit the
		// main thread.
		ready <- true
	}()
	<-ready
	time.Sleep(1 * time.Millisecond)
	// Check that this goroutine is still running on a different
	// thread.
	if mainTID != 0 && gettid() == mainTID {
		println("goroutine migrated to locked thread")
		os.Exit(1)
	}
	println("OK")
}

func LockOSThreadAlt() {
	// This is running locked to the main OS thread.

	var subTID int
	ready := make(chan bool, 1)
	go func() {
		// This goroutine must be running on a new thread.
		runtime.LockOSThread()
		subTID = gettid()
		ready <- true
		// Exit with the thread locked.
	}()
	<-ready
	runtime.UnlockOSThread()
	for i := 0; i < 100; i++ {
		time.Sleep(1 * time.Millisecond)
		// Check that this goroutine is running on a different thread.
		if subTID != 0 && gettid() == subTID {
			println("locked thread reused")
			os.Exit(1)
		}
		exists, supported := tidExists(subTID)
		if !supported || !exists {
			goto ok
		}
	}
	println("sub thread", subTID, "still running")
	return
ok:
	println("OK")
}

func LockOSThreadAvoidsStatePropagation() {
	// This test is similar to LockOSThreadAlt in that it will detect if a thread
	// which should have died is still running. However, rather than do this with
	// thread IDs, it does this by unsharing state on that thread. This way, it
	// also detects whether new threads were cloned from the dead thread, and not
	// from a clean thread. Cloning from a locked thread is undesirable since
	// cloned threads will inherit potentially unwanted OS state.
	//
	// unshareFs, getcwd, and chdir("/tmp") are only guaranteed to work on
	// Linux, so on other platforms this just checks that the runtime doesn't
	// do anything terrible.
	//
	// This is running locked to the main OS thread.

	// GOMAXPROCS=1 makes this fail much more reliably if a tainted thread is
	// cloned from.
	if runtime.GOMAXPROCS(-1) != 1 {
		println("requires GOMAXPROCS=1")
		os.Exit(1)
	}

	if err := chdir("/"); err != nil {
		println("failed to chdir:", err.Error())
		os.Exit(1)
	}
	// On systems other than Linux, cwd == "".
	cwd, err := getcwd()
	if err != nil {
		println("failed to get cwd:", err.Error())
		os.Exit(1)
	}
	if cwd != "" && cwd != "/" {
		println("unexpected cwd", cwd, " wanted /")
		os.Exit(1)
	}

	ready := make(chan bool, 1)
	go func() {
		// This goroutine must be running on a new thread.
		runtime.LockOSThread()

		// Unshare details about the FS, like the CWD, with
		// the rest of the process on this thread.
		// On systems other than Linux, this is a no-op.
		if err := unshareFs(); err != nil {
			if err == errNotPermitted {
				println("unshare not permitted")
				os.Exit(0)
			}
			println("failed to unshare fs:", err.Error())
			os.Exit(1)
		}
		// Chdir to somewhere else on this thread.
		// On systems other than Linux, this is a no-op.
		if err := chdir("/tmp"); err != nil {
			println("failed to chdir:", err.Error())
			os.Exit(1)
		}

		// The state on this thread is now considered "tainted", but it
		// should no longer be observable in any other context.

		ready <- true
		// Exit with the thread locked.
	}()
	<-ready

	// Spawn yet another goroutine and lock it. Since GOMAXPROCS=1, if
	// for some reason state from the (hopefully dead) locked thread above
	// propagated into a newly created thread (via clone), or that thread
	// is actually being re-used, then we should get scheduled on such a
	// thread with high likelihood.
	done := make(chan bool)
	go func() {
		runtime.LockOSThread()

		// Get the CWD and check if this is the same as the main thread's
		// CWD. Every thread should share the same CWD.
		// On systems other than Linux, wd == "".
		wd, err := getcwd()
		if err != nil {
			println("failed to get cwd:", err.Error())
			os.Exit(1)
		}
		if wd != cwd {
			println("bad state from old thread propagated after it should have died")
			os.Exit(1)
		}
		<-done

		runtime.UnlockOSThread()
	}()
	done <- true
	runtime.UnlockOSThread()
	println("OK")
}

func LockOSThreadTemplateThreadRace() {
	// This test attempts to reproduce the race described in
	// golang.org/issue/38931. To do so, we must have a stop-the-world
	// (achieved via ReadMemStats) racing with two LockOSThread calls.
	//
	// While this test attempts to line up the timing, it is only expected
	// to fail (and thus hang) around 2% of the time if the race is
	// present.

	// Ensure enough Ps to actually run everything in parallel. Though on
	// <4 core machines, we are still at the whim of the kernel scheduler.
	runtime.GOMAXPROCS(4)

	go func() {
		// Stop the world; race with LockOSThread below.
		var m runtime.MemStats
		for {
			runtime.ReadMemStats(&m)
		}
	}()

	// Try to synchronize both LockOSThreads.
	start := time.Now().Add(10 * time.Millisecond)

	var wg sync.WaitGroup
	wg.Add(2)

	for i := 0; i < 2; i++ {
		go func() {
			for time.Now().Before(start) {
			}

			// Add work to the local runq to trigger early startm
			// in handoffp.
			go func() {}()

			runtime.LockOSThread()
			runtime.Gosched() // add a preemption point.
			wg.Done()
		}()
	}

	wg.Wait()
	// If both LockOSThreads completed then we did not hit the race.
	println("OK")
}

相关信息

go 源码目录

相关文章

go abort 源码

go badtraceback 源码

go checkptr 源码

go crash 源码

go crashdump 源码

go deadlock 源码

go gc 源码

go main 源码

go map 源码

go memprof 源码