// mksyscall.pl -l32 -plan9 -tags plan9,arm syscall_plan9.go
// Code generated by the command above; DO NOT EDIT.

//go:build plan9 && arm

package syscall

import "unsafe"

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func fd2path(fd int, buf []byte) (err error) {
	var _p0 unsafe.Pointer
	if len(buf) > 0 {
		_p0 = unsafe.Pointer(&buf[0])
	} else {
		_p0 = unsafe.Pointer(&_zero)
	}

	if int32(r0) == -1 {
		err = e1
	}
	return
}

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

func pipe(p *[2]int32) (err error) {
	r0, _, e1 := Syscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0)
	if int32(r0) == -1 {
		err = e1
	}
	return
}

// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT

)

// For testing: clients can set this flag to force
// creation of IPv6 sockets to return EAFNOSUPPORT.
var SocketDisableIPv6 bool

func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.ErrorString)
func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.ErrorString)
func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr)
func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr)

// mksysnum_plan9.sh /opt/plan9/sys/src/libc/9syscall/sys.h
// MACHINE GENERATED BY THE ABOVE COMMAND; DO NOT EDIT

package plan9

const (
	SYS_SYSR1       = 0
	SYS_BIND        = 2
	SYS_CHDIR       = 3
	SYS_CLOSE       = 4
	SYS_DUP         = 5
	SYS_ALARM       = 6
	SYS_EXEC        = 7
	SYS_EXITS       = 8
	SYS_FAUTH       = 10
	SYS_SEGBRK      = 12
	SYS_OPEN        = 14
	SYS_OSEEK       = 16
	SYS_SLEEP       = 17

	},
}

type GoStatus uint8

const (
	GoBad GoStatus = iota
	GoRunnable
	GoRunning
	GoSyscall
	GoWaiting
)

func (s GoStatus) String() string {
	switch s {
	case GoRunnable:
		return "Runnable"
	case GoRunning:
		return "Running"
	case GoSyscall:
		return "Syscall"
	case GoWaiting:
		return "Waiting"
	}
	return "Bad"
}

type ProcStatus uint8

	case trace.GoRunning:
		return traceviewer.GRunning
	case trace.GoWaiting:
		if inMarkAssist {
			return traceviewer.GWaitingGC
		}
		return traceviewer.GWaiting
	case trace.GoSyscall:
		// N.B. A goroutine in a syscall is considered "executing" (state.Executing() == true).
		return traceviewer.GRunning
	default:
		panic(fmt.Sprintf("unknown GoState: %s", state.String()))
	}
}

		name:       "syscall",
		startTime:  gs.syscall.time,
		endTime:    ts,
		startStack: gs.syscall.stack,
		arg:        format.BlockedArg{Blocked: blockString},
	})
	gs.syscall.active = false
	gs.syscall.time = 0
	gs.syscall.stack = trace.NoStack
}

// blockedSyscallEnd indicates the point at which the blocked syscall ended. This is distinct

)

type GoroutineCountersArg struct {
	Running   uint64
	Runnable  uint64
	GCWaiting uint64
}

type ThreadCountersArg struct {
	Running   int64
	InSyscall int64
}

type ThreadIDArg struct {
	ThreadID uint64

	in1, err := os.ReadFile(syscallFilename)
	if err != nil {
		log.Fatalf("can't open syscall file: %s", err)
	}
	in2, err := os.ReadFile(syscallArchFilename)
	if err != nil {
		log.Fatalf("can't open syscall file: %s", err)
	}
	in3, err := os.ReadFile("z" + syscallArchFilename)
	if err != nil {
		log.Fatalf("can't open syscall file: %s", err)
	}
	in := string(in1) + string(in2) + string(in3)

		// Bind the goroutine to the new context, since it's running.
		newCtx.G = gid
	case go122.GoSyscall:
		if mid == NoThread {
			return curCtx, false, fmt.Errorf("found goroutine %d in syscall without a thread", gid)
		}
		// Is the syscall on this thread? If so, bind it to the context.
		// Otherwise, we're talking about a G sitting in a syscall on an M.
		// Validate the named M.
		if mid == curCtx.M {