readfrom_linux.go

     1  // Copyright 2020 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package os
     6  
     7  import (
     8  	"internal/poll"
     9  	"io"
    10  	"syscall"
    11  )
    12  
    13  var (
    14  	pollCopyFileRange = poll.CopyFileRange
    15  	pollSplice        = poll.Splice
    16  )
    17  
    18  func (f *File) readFrom(r io.Reader) (written int64, handled bool, err error) {
    19  	// Neither copy_file_range(2) nor splice(2) supports destinations opened with
    20  	// O_APPEND, so don't bother to try zero-copy with these system calls.
    21  	//
    22  	// Visit https://man7.org/linux/man-pages/man2/copy_file_range.2.html#ERRORS and
    23  	// https://man7.org/linux/man-pages/man2/splice.2.html#ERRORS for details.
    24  	if f.appendMode {
    25  		return 0, false, nil
    26  	}
    27  
    28  	written, handled, err = f.copyFileRange(r)
    29  	if handled {
    30  		return
    31  	}
    32  	return f.spliceToFile(r)
    33  }
    34  
    35  func (f *File) spliceToFile(r io.Reader) (written int64, handled bool, err error) {
    36  	var (
    37  		remain int64
    38  		lr     *io.LimitedReader
    39  	)
    40  	if lr, r, remain = tryLimitedReader(r); remain <= 0 {
    41  		return 0, true, nil
    42  	}
    43  
    44  	pfd := getPollFD(r)
    45  	// TODO(panjf2000): run some tests to see if we should unlock the non-streams for splice.
    46  	// Streams benefit the most from the splice(2), non-streams are not even supported in old kernels
    47  	// where splice(2) will just return EINVAL; newer kernels support non-streams like UDP, but I really
    48  	// doubt that splice(2) could help non-streams, cuz they usually send small frames respectively
    49  	// and one splice call would result in one frame.
    50  	// splice(2) is suitable for large data but the generation of fragments defeats its edge here.
    51  	// Therefore, don't bother to try splice if the r is not a streaming descriptor.
    52  	if pfd == nil || !pfd.IsStream {
    53  		return
    54  	}
    55  
    56  	var syscallName string
    57  	written, handled, syscallName, err = pollSplice(&f.pfd, pfd, remain)
    58  
    59  	if lr != nil {
    60  		lr.N = remain - written
    61  	}
    62  
    63  	return written, handled, wrapSyscallError(syscallName, err)
    64  }
    65  
    66  // getPollFD tries to get the poll.FD from the given io.Reader by expecting
    67  // the underlying type of r to be the implementation of syscall.Conn that contains
    68  // a *net.rawConn.
    69  func getPollFD(r io.Reader) *poll.FD {
    70  	sc, ok := r.(syscall.Conn)
    71  	if !ok {
    72  		return nil
    73  	}
    74  	rc, err := sc.SyscallConn()
    75  	if err != nil {
    76  		return nil
    77  	}
    78  	ipfd, ok := rc.(interface{ PollFD() *poll.FD })
    79  	if !ok {
    80  		return nil
    81  	}
    82  	return ipfd.PollFD()
    83  }
    84  
    85  func (f *File) copyFileRange(r io.Reader) (written int64, handled bool, err error) {
    86  	var (
    87  		remain int64
    88  		lr     *io.LimitedReader
    89  	)
    90  	if lr, r, remain = tryLimitedReader(r); remain <= 0 {
    91  		return 0, true, nil
    92  	}
    93  
    94  	src, ok := r.(*File)
    95  	if !ok {
    96  		return 0, false, nil
    97  	}
    98  	if src.checkValid("ReadFrom") != nil {
    99  		// Avoid returning the error as we report handled as false,
   100  		// leave further error handling as the responsibility of the caller.
   101  		return 0, false, nil
   102  	}
   103  
   104  	written, handled, err = pollCopyFileRange(&f.pfd, &src.pfd, remain)
   105  	if lr != nil {
   106  		lr.N -= written
   107  	}
   108  	return written, handled, wrapSyscallError("copy_file_range", err)
   109  }
   110  
   111  // tryLimitedReader tries to assert the io.Reader to io.LimitedReader, it returns the io.LimitedReader,
   112  // the underlying io.Reader and the remaining amount of bytes if the assertion succeeds,
   113  // otherwise it just returns the original io.Reader and the theoretical unlimited remaining amount of bytes.
   114  func tryLimitedReader(r io.Reader) (*io.LimitedReader, io.Reader, int64) {
   115  	var remain int64 = 1<<63 - 1 // by default, copy until EOF
   116  
   117  	lr, ok := r.(*io.LimitedReader)
   118  	if !ok {
   119  		return nil, r, remain
   120  	}
   121  
   122  	remain = lr.N
   123  	return lr, lr.R, remain
   124  }
   125
View as plain text