"testing"
	"time"
)

type command struct {
	pipe io.WriteCloser
	proc *exec.Cmd
	test *testing.T
}

func (c *command) Info() (pid, pgrp int) {
	pid = c.proc.Process.Pid

	pgrp, err := syscall.Getpgid(pid)
	if err != nil {
		c.test.Fatal(err)
	}

	return
}

func (c *command) Start() {
	if err := c.proc.Start(); err != nil {
		c.test.Fatal(err)
	}
}

func (c *command) Stop() {

	// will clobber the test pattern created by the caller
	ADD	$(1024 * 8), RSP

	// Ask signaller to setgid
	MOVD	$·Baton(SB), R0
	MOVD	$1, R1
storeloop:
	LDAXRW	(R0), R2
	STLXRW	R1, (R0), R3
	CBNZ	R3, storeloop

	// Wait for setgid completion
	MOVW	$0, R1
	MOVW	$0, R2
loop:
	LDAXRW	(R0), R3
	CMPW	R1, R3
	BNE	loop
	STLXRW	R2, (R0), R3
	CBNZ	R3, loop

//go:build aix

package syscall

import "unsafe"

//go:cgo_import_dynamic libc_Getpgid getpgid "libc.a/shr_64.o"
//go:cgo_import_dynamic libc_Getpgrp getpgrp "libc.a/shr_64.o"

//go:linkname libc_Getpgid libc_Getpgid
//go:linkname libc_Getpgrp libc_Getpgrp

var (
	libc_Getpgid,
	libc_Getpgrp libcFunc
)

func Getpgid(pid int) (pgid int, err error) {

//go:cgo_import_dynamic exit exit ""
//go:cgo_import_dynamic fstat$INODE64 fstat$INODE64 ""
//go:cgo_import_dynamic ftruncate ftruncate ""
//go:cgo_import_dynamic getpid getpid ""
//go:cgo_import_dynamic getrlimit getrlimit ""
//go:cgo_import_dynamic gettimeofday gettimeofday ""
//go:cgo_import_dynamic getuid getuid ""
//go:cgo_import_dynamic grantpt grantpt ""
//go:cgo_import_dynamic ioctl ioctl ""
//go:cgo_import_dynamic isatty isatty ""

//go:cgo_import_dynamic exit exit ""
//go:cgo_import_dynamic fstat fstat ""
//go:cgo_import_dynamic ftruncate ftruncate ""
//go:cgo_import_dynamic getpid getpid ""
//go:cgo_import_dynamic getrlimit getrlimit ""
//go:cgo_import_dynamic gettimeofday gettimeofday ""
//go:cgo_import_dynamic getuid getuid ""
//go:cgo_import_dynamic grantpt grantpt ""
//go:cgo_import_dynamic ioctl ioctl ""
//go:cgo_import_dynamic isatty isatty ""

		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 {

#cgo CFLAGS: -g -fsanitize=thread
#cgo LDFLAGS: -g -fsanitize=thread
*/
import "C"

func main() {
	c := make(chan os.Signal, 1)
	signal.Notify(c, syscall.SIGUSR1)
	defer signal.Stop(c)
	syscall.Kill(syscall.Getpid(), syscall.SIGUSR1)
	<-c

                    if (status != null) {
                        statuses.add(status);
                    } else { // Handle failure
                        statuses.add(new Status(connection.getDaemon().getPid(), "UNKNOWN", "UNKNOWN"));
                    }
                } finally {
                    connection.stop();
                }
            }
        }

                            tree.send(new SmbComClose(sess.getConfig(), resp2.getFid(), 0L));
                        }
                    }
                }
                finally {
                    if ( resp != null && !trans.isDisconnected() ) {
                        tree.send(new SmbComClose(sess.getConfig(), resp.getFid(), 0L));
                    }
                }
            }
            else {

}

func getcwd() (string, error) {
	if !syscall.ImplementsGetwd {
		return "", nil
	}
	// Use the syscall to get the current working directory.
	// This is imperative for checking for OS thread state
	// after an unshare since os.Getwd might just check the
	// environment, or use some other mechanism.
	var buf [4096]byte
	n, err := syscall.Getcwd(buf[:])
	if err != nil {
		return "", err
	}