1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
// 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
)
// wrapSyscallError takes an error and a syscall name. If the error is
// a syscall.Errno, it wraps it in an os.SyscallError using the syscall name.
func wrapSyscallError(name string, err error) error {
if _, ok := err.(syscall.Errno); ok {
err = NewSyscallError(name, err)
}
return err
}
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
}
written, handled, err = pollSplice(&f.pfd, pfd, remain)
if lr != nil {
lr.N = remain - written
}
return written, handled, wrapSyscallError("splice", 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
}
}
|
