if physPageSize == 0 {
		physPageSize = getPageSize()
	}
}

func tstart_sysvicall(newm *m) uint32

// May run with m.p==nil, so write barriers are not allowed.
//
//go:nowritebarrier
func newosproc(mp *m) {
	var (
		attr pthreadattr
		oset sigset
		tid  pthread
		ret  int32
		size uint64
	)

	if pthread_attr_init(&attr) != 0 {
		throw("pthread_attr_init")
	}

//
//go:nowritebarrierrec
//go:nosplit
func newosproc0(mp *m, stk unsafe.Pointer) {
	// TODO: this is completely broken. The args passed to newosproc0 (in asm_amd64.s)
	// are stacksize and function, not *m and stack.
	// Check os_linux.go for an implementation that might actually work.
	throw("bad newosproc0")
}

func exitThread(wait *atomic.Uint32) {

	// behaviour around exec'ing while creating/destroying threads. See
	// issue #19546.
	execLock rwmutex
)

// These errors are reported (via writeErrStr) by some OS-specific
// versions of newosproc and newosproc0.
const (
	failthreadcreate  = "runtime: failed to create new OS thread\n"
	failallocatestack = "runtime: failed to allocate stack for the new OS thread\n"
)

// license that can be found in the LICENSE file.

// Export guts for testing.

package runtime

const SiginfoMaxSize = _si_max_size
const SigeventMaxSize = _sigev_max_size

var NewOSProc0 = newosproc0
var Mincore = mincore

type Siginfo siginfo

	procWSARecv                            = modws2_32.NewProc("WSARecv")
	procWSARecvFrom                        = modws2_32.NewProc("WSARecvFrom")
	procWSASend                            = modws2_32.NewProc("WSASend")
	procWSASendTo                          = modws2_32.NewProc("WSASendTo")
	procWSAStartup                         = modws2_32.NewProc("WSAStartup")
	procbind                               = modws2_32.NewProc("bind")

	procOpenThreadToken                   = modadvapi32.NewProc("OpenThreadToken")
	procQueryServiceStatus                = modadvapi32.NewProc("QueryServiceStatus")
	procRevertToSelf                      = modadvapi32.NewProc("RevertToSelf")
	procSetTokenInformation               = modadvapi32.NewProc("SetTokenInformation")
	procProcessPrng                       = modbcryptprimitives.NewProc("ProcessPrng")

	// Also do a sanity correctness check: under race detector atomic operations
	// are implemented inside of race runtime.
	kernel32 := syscall.NewLazyDLL("kernel32.dll")
	VirtualAlloc := kernel32.NewProc("VirtualAlloc")
	VirtualFree := kernel32.NewProc("VirtualFree")
	const (
		MEM_COMMIT     = 0x00001000
		MEM_RESERVE    = 0x00002000
		MEM_RELEASE    = 0x8000
		PAGE_READWRITE = 0x04
	)

	procAdjustTokenPrivileges                                = modadvapi32.NewProc("AdjustTokenPrivileges")
	procAllocateAndInitializeSid                             = modadvapi32.NewProc("AllocateAndInitializeSid")
	procBuildSecurityDescriptorW                             = modadvapi32.NewProc("BuildSecurityDescriptorW")
	procChangeServiceConfig2W                                = modadvapi32.NewProc("ChangeServiceConfig2W")

	// Check the validity of g because without a g during
	// newosproc0.
	if gp != nil {
		syscall1(&libc_exit, uintptr(code))
		return
	}
	exit1(code)
}

func write2(fd, p uintptr, n int32) int32

//go:nosplit
func write1(fd uintptr, p unsafe.Pointer, n int32) int32 {
	gp := getg()

	// Check the validity of g because without a g during
	// newosproc0.
	if gp != nil {

//go:nosplit
func newOSProcCreated() {
	newOSProcDone = true
}

// Can't be run with -race because it inserts calls into newOSProcCreated()
// that require a valid G/M.
func TestNewOSProc0(t *testing.T) {
	runtime.NewOSProc0(0x800000, unsafe.Pointer(abi.FuncPCABIInternal(newOSProcCreated)))
	check := time.NewTicker(100 * time.Millisecond)
	defer check.Stop()
	end := time.After(5 * time.Second)
	for {
		select {
		case <-check.C: