package unix

import (
	"sync/atomic"
	"syscall"
	"unsafe"
)

var getrandomUnsupported atomic.Bool

// GetRandomFlag is a flag supported by the getrandom system call.
type GetRandomFlag uintptr

// GetRandom calls the getrandom system call.
func GetRandom(p []byte, flags GetRandomFlag) (n int, err error) {
	if len(p) == 0 {
		return 0, nil
	}
	if getrandomUnsupported.Load() {
		return 0, syscall.ENOSYS
	}

// reading from /dev/urandom in rand_unix.go. unix.GetRandom caches the ENOSYS
// result so we only suffer the syscall overhead once in this case.
// If the kernel supports the getrandom() syscall, unix.GetRandom will block
// until the kernel has sufficient randomness (as we don't use GRND_NONBLOCK).
// In this case, unix.GetRandom will not return an error.
func getRandom(p []byte) error {
	n, err := unix.GetRandom(p, 0)
	if err != nil {
		return err
	}

	// GRND_RANDOM means use the /dev/random pool instead of /dev/urandom.
	GRND_RANDOM GetRandomFlag = 0x0002
)

// GetRandom calls the getrandom system call.
func GetRandom(p []byte, flags GetRandomFlag) (n int, err error) {
	if len(p) == 0 {
		return 0, nil
	}
	if getrandomUnsupported.Load() {
		return 0, syscall.ENOSYS
	}
	r1, _, errno := syscall6(uintptr(unsafe.Pointer(&procGetrandom)),
		3,

const maxGetRandomRead = 64 << 10

var batchedGetRandom func([]byte) error

func init() {
	Reader = &reader{}
	batchedGetRandom = batched(getRandom, maxGetRandomRead)
}

var jsCrypto = js.Global().Get("crypto")
var uint8Array = js.Global().Get("Uint8Array")

// reader implements a pseudorandom generator
// using JavaScript crypto.getRandomValues method.

// Copyright 2021 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 unix

// DragonFlyBSD getrandom system call number.
const getrandomTrap uintptr = 550

const (
	// GRND_RANDOM is only set for portability purpose, no-op on DragonFlyBSD.
	GRND_RANDOM GetRandomFlag = 0x0001

	// GRND_NONBLOCK means return EAGAIN rather than blocking.

// Copyright 2018 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 unix

// FreeBSD getrandom system call number.
const getrandomTrap uintptr = 563

const (
	// GRND_NONBLOCK means return EAGAIN rather than blocking.
	GRND_NONBLOCK GetRandomFlag = 0x0001

	// GRND_RANDOM is only set for portability purpose, no-op on FreeBSD.

### OpenBSD {#openbsd}

<!-- go.dev/issue/55999, CL 518629, CL 518630 -->
Go 1.23 adds experimental support for OpenBSD on 64-bit RISC-V (`GOOS=openbsd`, `GOARCH=riscv64`).

### ARM64 {#arm64}

    }

    private static final long SEED = ( new Random() ).nextLong();


    @Override
    @Before
    public void setUp () throws Exception {
        super.setUp();
    }


    static Random getRandom () {
        return new Random(SEED);
    }


    @Parameters ( name = "{0}" )
    public static Collection<Object> configs () {

        long start = System.currentTimeMillis();
        byte buffer[] = new byte[bufSize];
        long p = 0;
        Random r = ReadWriteTest.getRandom();
        while ( p < length ) {

            int rs = Math.min(bufSize, (int) ( length - p ));
            int read = is.read(buffer, 0, rs);
            if ( read < 0 ) {
                fail("Unexpected EOF");

// random number generator.
package rand

import "io"

// Reader is a global, shared instance of a cryptographically
// secure random number generator.
//
//   - On Linux, FreeBSD, Dragonfly, and Solaris, Reader uses getrandom(2)
//     if available, and /dev/urandom otherwise.
//   - On macOS and iOS, Reader uses arc4random_buf(3).
//   - On OpenBSD and NetBSD, Reader uses getentropy(2).