File Manager

X7ROOT File Manager

Current Path: /opt/golang/1.22.0/src/os

📁 ..
📄 dir.go(4.4 KB)
📄 dir_darwin.go(3.34 KB)
📄 dir_plan9.go(2.1 KB)
📄 dir_unix.go(5.24 KB)
📄 dir_windows.go(7.17 KB)
📄 dirent_aix.go(759 B)
📄 dirent_dragonfly.go(1.28 KB)
📄 dirent_freebsd.go(1.16 KB)
📄 dirent_js.go(678 B)
📄 dirent_linux.go(1.18 KB)
📄 dirent_netbsd.go(1.16 KB)
📄 dirent_openbsd.go(1.16 KB)
📄 dirent_solaris.go(759 B)
📄 dirent_wasip1.go(1.36 KB)
📄 endian_big.go(244 B)
📄 endian_little.go(304 B)
📄 env.go(3.85 KB)
📄 env_test.go(5.04 KB)
📄 env_unix_test.go(1.22 KB)
📄 error.go(4.76 KB)
📄 error_errno.go(247 B)
📄 error_plan9.go(234 B)
📄 error_posix.go(538 B)
📄 error_test.go(4.92 KB)
📄 error_unix_test.go(1.49 KB)
📄 error_windows_test.go(1.72 KB)
📄 example_test.go(8.39 KB)
📁 exec
📄 exec.go(6.01 KB)
📄 exec_plan9.go(3.27 KB)
📄 exec_posix.go(3.44 KB)
📄 exec_unix.go(2.09 KB)
📄 exec_unix_test.go(999 B)
📄 exec_windows.go(4.57 KB)
📄 exec_windows_test.go(1.78 KB)
📄 executable.go(774 B)
📄 executable_darwin.go(613 B)
📄 executable_dragonfly.go(293 B)
📄 executable_freebsd.go(292 B)
📄 executable_path.go(2.31 KB)
📄 executable_plan9.go(427 B)
📄 executable_procfs.go(904 B)
📄 executable_solaris.go(695 B)
📄 executable_sysctl.go(891 B)
📄 executable_test.go(3.4 KB)
📄 executable_wasm.go(333 B)
📄 executable_windows.go(641 B)
📄 export_linux_test.go(337 B)
📄 export_test.go(433 B)
📄 export_unix_test.go(241 B)
📄 export_windows_test.go(395 B)
📄 fifo_test.go(4.62 KB)
📄 file.go(24.91 KB)
📄 file_mutex_plan9.go(1.81 KB)
📄 file_open_unix.go(397 B)
📄 file_open_wasip1.go(818 B)
📄 file_plan9.go(15.99 KB)
📄 file_posix.go(7.1 KB)
📄 file_unix.go(14.05 KB)
📄 file_wasip1.go(633 B)
📄 file_windows.go(12.65 KB)
📄 getwd.go(2.52 KB)
📄 os_test.go(77.07 KB)
📄 os_unix_test.go(11.47 KB)
📄 os_windows_test.go(41.83 KB)
📄 path.go(2.27 KB)
📄 path_plan9.go(492 B)
📄 path_test.go(2.96 KB)
📄 path_unix.go(1.56 KB)
📄 path_windows.go(5.66 KB)
📄 path_windows_test.go(4.03 KB)
📄 pipe2_unix.go(640 B)
📄 pipe_test.go(12.41 KB)
📄 pipe_unix.go(760 B)
📄 pipe_wasm.go(488 B)
📄 proc.go(2.27 KB)
📄 rawconn.go(993 B)
📄 rawconn_test.go(1.15 KB)
📄 read_test.go(3.2 KB)
📄 readfrom_linux_test.go(20.3 KB)
📄 removeall_at.go(4.91 KB)
📄 removeall_noat.go(3.13 KB)
📄 removeall_test.go(11.96 KB)
📁 signal
📄 stat.go(965 B)
📄 stat_aix.go(1.18 KB)
📄 stat_darwin.go(1.09 KB)
📄 stat_dragonfly.go(1.06 KB)
📄 stat_freebsd.go(1.07 KB)
📄 stat_js.go(1.11 KB)
📄 stat_linux.go(1.06 KB)
📄 stat_netbsd.go(1.07 KB)
📄 stat_openbsd.go(1.06 KB)
📄 stat_plan9.go(2.37 KB)
📄 stat_solaris.go(1.3 KB)
📄 stat_test.go(6.46 KB)
📄 stat_unix.go(1.23 KB)
📄 stat_wasip1.go(956 B)
📄 stat_windows.go(4.93 KB)
📄 sticky_bsd.go(425 B)
📄 sticky_notbsd.go(320 B)
📄 sys.go(294 B)
📄 sys_aix.go(682 B)
📄 sys_bsd.go(466 B)
📄 sys_js.go(313 B)
📄 sys_linux.go(1.04 KB)
📄 sys_plan9.go(453 B)
📄 sys_solaris.go(265 B)
📄 sys_unix.go(493 B)
📄 sys_wasip1.go(309 B)
📄 sys_windows.go(874 B)
📄 tempfile.go(3.8 KB)
📄 tempfile_test.go(5.49 KB)
📁 testdata
📄 timeout_test.go(17.09 KB)
📄 types.go(2.79 KB)
📄 types_plan9.go(797 B)
📄 types_unix.go(776 B)
📄 types_windows.go(10.01 KB)
📁 user
📄 wait6_dragonfly.go(496 B)
📄 wait6_freebsd64.go(547 B)
📄 wait6_freebsd_386.go(544 B)
📄 wait6_freebsd_arm.go(549 B)
📄 wait6_netbsd.go(534 B)
📄 wait_unimp.go(831 B)
📄 wait_wait6.go(781 B)
📄 wait_waitid.go(1.32 KB)
📄 writeto_linux_test.go(4.21 KB)
📄 zero_copy_linux.go(4.38 KB)
📄 zero_copy_stub.go(406 B)

Editing: fifo_test.go

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

//go:build darwin || dragonfly || freebsd || (linux && !android) || netbsd || openbsd

package os_test

import (
	"errors"
	"internal/syscall/unix"
	"internal/testenv"
	"io/fs"
	"os"
	"path/filepath"
	"strconv"
	"sync"
	"syscall"
	"testing"
)

func TestFifoEOF(t *testing.T) {
	t.Parallel()

dir := t.TempDir()
	fifoName := filepath.Join(dir, "fifo")
	if err := syscall.Mkfifo(fifoName, 0600); err != nil {
		t.Fatal(err)
	}

// Per https://pubs.opengroup.org/onlinepubs/9699919799/functions/open.html#tag_16_357_03:
	//
	// - “If O_NONBLOCK is clear, an open() for reading-only shall block the
	//   calling thread until a thread opens the file for writing. An open() for
	//   writing-only shall block the calling thread until a thread opens the file
	//   for reading.”
	//
	// In order to unblock both open calls, we open the two ends of the FIFO
	// simultaneously in separate goroutines.

rc := make(chan *os.File, 1)
	go func() {
		r, err := os.Open(fifoName)
		if err != nil {
			t.Error(err)
		}
		rc <- r
	}()

w, err := os.OpenFile(fifoName, os.O_WRONLY, 0)
	if err != nil {
		t.Error(err)
	}

r := <-rc
	if t.Failed() {
		if r != nil {
			r.Close()
		}
		if w != nil {
			w.Close()
		}
		return
	}

testPipeEOF(t, r, w)
}

// Issue #59545.
func TestNonPollable(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping test with tight loops in short mode")
	}

// We need to open a non-pollable file.
	// This is almost certainly Linux-specific,
	// but if other systems have non-pollable files,
	// we can add them here.
	const nonPollable = "/dev/net/tun"

f, err := os.OpenFile(nonPollable, os.O_RDWR, 0)
	if err != nil {
		if errors.Is(err, fs.ErrNotExist) || errors.Is(err, fs.ErrPermission) || testenv.SyscallIsNotSupported(err) {
			t.Skipf("can't open %q: %v", nonPollable, err)
		}
		t.Fatal(err)
	}
	f.Close()

// On a Linux laptop, before the problem was fixed,
	// this test failed about 50% of the time with this
	// number of iterations.
	// It takes about 1/2 second when it passes.
	const attempts = 20000

start := make(chan bool)
	var wg sync.WaitGroup
	wg.Add(1)
	defer wg.Wait()
	go func() {
		defer wg.Done()
		close(start)
		for i := 0; i < attempts; i++ {
			f, err := os.OpenFile(nonPollable, os.O_RDWR, 0)
			if err != nil {
				t.Error(err)
				return
			}
			if err := f.Close(); err != nil {
				t.Error(err)
				return
			}
		}
	}()

dir := t.TempDir()
	<-start
	for i := 0; i < attempts; i++ {
		name := filepath.Join(dir, strconv.Itoa(i))
		if err := syscall.Mkfifo(name, 0o600); err != nil {
			t.Fatal(err)
		}
		// The problem only occurs if we use O_NONBLOCK here.
		rd, err := os.OpenFile(name, os.O_RDONLY|syscall.O_NONBLOCK, 0o600)
		if err != nil {
			t.Fatal(err)
		}
		wr, err := os.OpenFile(name, os.O_WRONLY|syscall.O_NONBLOCK, 0o600)
		if err != nil {
			t.Fatal(err)
		}
		const msg = "message"
		if _, err := wr.Write([]byte(msg)); err != nil {
			if errors.Is(err, syscall.EAGAIN) || errors.Is(err, syscall.ENOBUFS) {
				t.Logf("ignoring write error %v", err)
				rd.Close()
				wr.Close()
				continue
			}
			t.Fatalf("write to fifo %d failed: %v", i, err)
		}
		if _, err := rd.Read(make([]byte, len(msg))); err != nil {
			if errors.Is(err, syscall.EAGAIN) || errors.Is(err, syscall.ENOBUFS) {
				t.Logf("ignoring read error %v", err)
				rd.Close()
				wr.Close()
				continue
			}
			t.Fatalf("read from fifo %d failed; %v", i, err)
		}
		if err := rd.Close(); err != nil {
			t.Fatal(err)
		}
		if err := wr.Close(); err != nil {
			t.Fatal(err)
		}
	}
}

// Issue 60211.
func TestOpenFileNonBlocking(t *testing.T) {
	exe, err := os.Executable()
	if err != nil {
		t.Skipf("can't find executable: %v", err)
	}
	f, err := os.OpenFile(exe, os.O_RDONLY|syscall.O_NONBLOCK, 0666)
	if err != nil {
		t.Fatal(err)
	}
	defer f.Close()
	nonblock, err := unix.IsNonblock(int(f.Fd()))
	if err != nil {
		t.Fatal(err)
	}
	if !nonblock {
		t.Errorf("file opened with O_NONBLOCK but in blocking mode")
	}
}

func TestNewFileNonBlocking(t *testing.T) {
	var p [2]int
	if err := syscall.Pipe(p[:]); err != nil {
		t.Fatal(err)
	}
	if err := syscall.SetNonblock(p[0], true); err != nil {
		t.Fatal(err)
	}
	f := os.NewFile(uintptr(p[0]), "pipe")
	nonblock, err := unix.IsNonblock(p[0])
	if err != nil {
		t.Fatal(err)
	}
	if !nonblock {
		t.Error("pipe blocking after NewFile")
	}
	fd := f.Fd()
	if fd != uintptr(p[0]) {
		t.Errorf("Fd returned %d, want %d", fd, p[0])
	}
	nonblock, err = unix.IsNonblock(p[0])
	if err != nil {
		t.Fatal(err)
	}
	if !nonblock {
		t.Error("pipe blocking after Fd")
	}
}

X7ROOT File Manager

Editing: fifo_test.go

Upload File

Create Folder