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: zero_copy_linux.go

// Copyright 2020 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 os

import (
	"internal/poll"
	"io"
	"syscall"
)

var (
	pollCopyFileRange = poll.CopyFileRange
	pollSplice        = poll.Splice
	pollSendFile      = poll.SendFile
)

func (f *File) writeTo(w io.Writer) (written int64, handled bool, err error) {
	pfd, network := getPollFDAndNetwork(w)
	// TODO(panjf2000): same as File.spliceToFile.
	if pfd == nil || !pfd.IsStream || !isUnixOrTCP(string(network)) {
		return
	}

sc, err := f.SyscallConn()
	if err != nil {
		return
	}

rerr := sc.Read(func(fd uintptr) (done bool) {
		written, err, handled = pollSendFile(pfd, int(fd), 1<<63-1)
		return true
	})

if err == nil {
		err = rerr
	}

return written, handled, wrapSyscallError("sendfile", err)
}

func (f *File) readFrom(r io.Reader) (written int64, handled bool, err error) {
	// Neither copy_file_range(2) nor splice(2) supports destinations opened with
	// O_APPEND, so don't bother to try zero-copy with these system calls.
	//
	// Visit https://man7.org/linux/man-pages/man2/copy_file_range.2.html#ERRORS and
	// https://man7.org/linux/man-pages/man2/splice.2.html#ERRORS for details.
	if f.appendMode {
		return 0, false, nil
	}

written, handled, err = f.copyFileRange(r)
	if handled {
		return
	}
	return f.spliceToFile(r)
}

func (f *File) spliceToFile(r io.Reader) (written int64, handled bool, err error) {
	var (
		remain int64
		lr     *io.LimitedReader
	)
	if lr, r, remain = tryLimitedReader(r); remain <= 0 {
		return 0, true, nil
	}

pfd, _ := getPollFDAndNetwork(r)
	// TODO(panjf2000): run some tests to see if we should unlock the non-streams for splice.
	// Streams benefit the most from the splice(2), non-streams are not even supported in old kernels
	// where splice(2) will just return EINVAL; newer kernels support non-streams like UDP, but I really
	// doubt that splice(2) could help non-streams, cuz they usually send small frames respectively
	// and one splice call would result in one frame.
	// splice(2) is suitable for large data but the generation of fragments defeats its edge here.
	// Therefore, don't bother to try splice if the r is not a streaming descriptor.
	if pfd == nil || !pfd.IsStream {
		return
	}

var syscallName string
	written, handled, syscallName, err = pollSplice(&f.pfd, pfd, remain)

if lr != nil {
		lr.N = remain - written
	}

return written, handled, wrapSyscallError(syscallName, err)
}

func (f *File) copyFileRange(r io.Reader) (written int64, handled bool, err error) {
	var (
		remain int64
		lr     *io.LimitedReader
	)
	if lr, r, remain = tryLimitedReader(r); remain <= 0 {
		return 0, true, nil
	}

var src *File
	switch v := r.(type) {
	case *File:
		src = v
	case fileWithoutWriteTo:
		src = v.File
	default:
		return 0, false, nil
	}

if src.checkValid("ReadFrom") != nil {
		// Avoid returning the error as we report handled as false,
		// leave further error handling as the responsibility of the caller.
		return 0, false, nil
	}

written, handled, err = pollCopyFileRange(&f.pfd, &src.pfd, remain)
	if lr != nil {
		lr.N -= written
	}
	return written, handled, wrapSyscallError("copy_file_range", err)
}

// getPollFDAndNetwork tries to get the poll.FD and network type from the given interface
// by expecting the underlying type of i to be the implementation of syscall.Conn
// that contains a *net.rawConn.
func getPollFDAndNetwork(i any) (*poll.FD, poll.String) {
	sc, ok := i.(syscall.Conn)
	if !ok {
		return nil, ""
	}
	rc, err := sc.SyscallConn()
	if err != nil {
		return nil, ""
	}
	irc, ok := rc.(interface {
		PollFD() *poll.FD
		Network() poll.String
	})
	if !ok {
		return nil, ""
	}
	return irc.PollFD(), irc.Network()
}

// tryLimitedReader tries to assert the io.Reader to io.LimitedReader, it returns the io.LimitedReader,
// the underlying io.Reader and the remaining amount of bytes if the assertion succeeds,
// otherwise it just returns the original io.Reader and the theoretical unlimited remaining amount of bytes.
func tryLimitedReader(r io.Reader) (*io.LimitedReader, io.Reader, int64) {
	var remain int64 = 1<<63 - 1 // by default, copy until EOF

lr, ok := r.(*io.LimitedReader)
	if !ok {
		return nil, r, remain
	}

remain = lr.N
	return lr, lr.R, remain
}

func isUnixOrTCP(network string) bool {
	switch network {
	case "tcp", "tcp4", "tcp6", "unix":
		return true
	default:
		return false
	}
}

X7ROOT File Manager

Editing: zero_copy_linux.go

Upload File

Create Folder