cubefs

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

7
import "unsafe"
8

9
// IoctlRetInt performs an ioctl operation specified by req on a device
10
// associated with opened file descriptor fd, and returns a non-negative
11
// integer that is returned by the ioctl syscall.
12
func IoctlRetInt(fd int, req uint) (int, error) {
13
	ret, _, err := Syscall(SYS_IOCTL, uintptr(fd), uintptr(req), 0)
14
	if err != 0 {
15
		return 0, err
16
	}
17
	return int(ret), nil
18
}
19

20
func IoctlGetUint32(fd int, req uint) (uint32, error) {
21
	var value uint32
22
	err := ioctlPtr(fd, req, unsafe.Pointer(&value))
23
	return value, err
24
}
25

26
func IoctlGetRTCTime(fd int) (*RTCTime, error) {
27
	var value RTCTime
28
	err := ioctlPtr(fd, RTC_RD_TIME, unsafe.Pointer(&value))
29
	return &value, err
30
}
31

32
func IoctlSetRTCTime(fd int, value *RTCTime) error {
33
	return ioctlPtr(fd, RTC_SET_TIME, unsafe.Pointer(value))
34
}
35

36
func IoctlGetRTCWkAlrm(fd int) (*RTCWkAlrm, error) {
37
	var value RTCWkAlrm
38
	err := ioctlPtr(fd, RTC_WKALM_RD, unsafe.Pointer(&value))
39
	return &value, err
40
}
41

42
func IoctlSetRTCWkAlrm(fd int, value *RTCWkAlrm) error {
43
	return ioctlPtr(fd, RTC_WKALM_SET, unsafe.Pointer(value))
44
}
45

46
// IoctlGetEthtoolDrvinfo fetches ethtool driver information for the network
47
// device specified by ifname.
48
func IoctlGetEthtoolDrvinfo(fd int, ifname string) (*EthtoolDrvinfo, error) {
49
	ifr, err := NewIfreq(ifname)
50
	if err != nil {
51
		return nil, err
52
	}
53

54
	value := EthtoolDrvinfo{Cmd: ETHTOOL_GDRVINFO}
55
	ifrd := ifr.withData(unsafe.Pointer(&value))
56

57
	err = ioctlIfreqData(fd, SIOCETHTOOL, &ifrd)
58
	return &value, err
59
}
60

61
// IoctlGetWatchdogInfo fetches information about a watchdog device from the
62
// Linux watchdog API. For more information, see:
63
// https://www.kernel.org/doc/html/latest/watchdog/watchdog-api.html.
64
func IoctlGetWatchdogInfo(fd int) (*WatchdogInfo, error) {
65
	var value WatchdogInfo
66
	err := ioctlPtr(fd, WDIOC_GETSUPPORT, unsafe.Pointer(&value))
67
	return &value, err
68
}
69

70
// IoctlWatchdogKeepalive issues a keepalive ioctl to a watchdog device. For
71
// more information, see:
72
// https://www.kernel.org/doc/html/latest/watchdog/watchdog-api.html.
73
func IoctlWatchdogKeepalive(fd int) error {
74
	// arg is ignored and not a pointer, so ioctl is fine instead of ioctlPtr.
75
	return ioctl(fd, WDIOC_KEEPALIVE, 0)
76
}
77

78
// IoctlFileCloneRange performs an FICLONERANGE ioctl operation to clone the
79
// range of data conveyed in value to the file associated with the file
80
// descriptor destFd. See the ioctl_ficlonerange(2) man page for details.
81
func IoctlFileCloneRange(destFd int, value *FileCloneRange) error {
82
	return ioctlPtr(destFd, FICLONERANGE, unsafe.Pointer(value))
83
}
84

85
// IoctlFileClone performs an FICLONE ioctl operation to clone the entire file
86
// associated with the file description srcFd to the file associated with the
87
// file descriptor destFd. See the ioctl_ficlone(2) man page for details.
88
func IoctlFileClone(destFd, srcFd int) error {
89
	return ioctl(destFd, FICLONE, uintptr(srcFd))
90
}
91

92
type FileDedupeRange struct {
93
	Src_offset uint64
94
	Src_length uint64
95
	Reserved1  uint16
96
	Reserved2  uint32
97
	Info       []FileDedupeRangeInfo
98
}
99

100
type FileDedupeRangeInfo struct {
101
	Dest_fd       int64
102
	Dest_offset   uint64
103
	Bytes_deduped uint64
104
	Status        int32
105
	Reserved      uint32
106
}
107

108
// IoctlFileDedupeRange performs an FIDEDUPERANGE ioctl operation to share the
109
// range of data conveyed in value from the file associated with the file
110
// descriptor srcFd to the value.Info destinations. See the
111
// ioctl_fideduperange(2) man page for details.
112
func IoctlFileDedupeRange(srcFd int, value *FileDedupeRange) error {
113
	buf := make([]byte, SizeofRawFileDedupeRange+
114
		len(value.Info)*SizeofRawFileDedupeRangeInfo)
115
	rawrange := (*RawFileDedupeRange)(unsafe.Pointer(&buf[0]))
116
	rawrange.Src_offset = value.Src_offset
117
	rawrange.Src_length = value.Src_length
118
	rawrange.Dest_count = uint16(len(value.Info))
119
	rawrange.Reserved1 = value.Reserved1
120
	rawrange.Reserved2 = value.Reserved2
121

122
	for i := range value.Info {
123
		rawinfo := (*RawFileDedupeRangeInfo)(unsafe.Pointer(
124
			uintptr(unsafe.Pointer(&buf[0])) + uintptr(SizeofRawFileDedupeRange) +
125
				uintptr(i*SizeofRawFileDedupeRangeInfo)))
126
		rawinfo.Dest_fd = value.Info[i].Dest_fd
127
		rawinfo.Dest_offset = value.Info[i].Dest_offset
128
		rawinfo.Bytes_deduped = value.Info[i].Bytes_deduped
129
		rawinfo.Status = value.Info[i].Status
130
		rawinfo.Reserved = value.Info[i].Reserved
131
	}
132

133
	err := ioctlPtr(srcFd, FIDEDUPERANGE, unsafe.Pointer(&buf[0]))
134

135
	// Output
136
	for i := range value.Info {
137
		rawinfo := (*RawFileDedupeRangeInfo)(unsafe.Pointer(
138
			uintptr(unsafe.Pointer(&buf[0])) + uintptr(SizeofRawFileDedupeRange) +
139
				uintptr(i*SizeofRawFileDedupeRangeInfo)))
140
		value.Info[i].Dest_fd = rawinfo.Dest_fd
141
		value.Info[i].Dest_offset = rawinfo.Dest_offset
142
		value.Info[i].Bytes_deduped = rawinfo.Bytes_deduped
143
		value.Info[i].Status = rawinfo.Status
144
		value.Info[i].Reserved = rawinfo.Reserved
145
	}
146

147
	return err
148
}
149

150
func IoctlHIDGetDesc(fd int, value *HIDRawReportDescriptor) error {
151
	return ioctlPtr(fd, HIDIOCGRDESC, unsafe.Pointer(value))
152
}
153

154
func IoctlHIDGetRawInfo(fd int) (*HIDRawDevInfo, error) {
155
	var value HIDRawDevInfo
156
	err := ioctlPtr(fd, HIDIOCGRAWINFO, unsafe.Pointer(&value))
157
	return &value, err
158
}
159

160
func IoctlHIDGetRawName(fd int) (string, error) {
161
	var value [_HIDIOCGRAWNAME_LEN]byte
162
	err := ioctlPtr(fd, _HIDIOCGRAWNAME, unsafe.Pointer(&value[0]))
163
	return ByteSliceToString(value[:]), err
164
}
165

166
func IoctlHIDGetRawPhys(fd int) (string, error) {
167
	var value [_HIDIOCGRAWPHYS_LEN]byte
168
	err := ioctlPtr(fd, _HIDIOCGRAWPHYS, unsafe.Pointer(&value[0]))
169
	return ByteSliceToString(value[:]), err
170
}
171

172
func IoctlHIDGetRawUniq(fd int) (string, error) {
173
	var value [_HIDIOCGRAWUNIQ_LEN]byte
174
	err := ioctlPtr(fd, _HIDIOCGRAWUNIQ, unsafe.Pointer(&value[0]))
175
	return ByteSliceToString(value[:]), err
176
}
177

178
// IoctlIfreq performs an ioctl using an Ifreq structure for input and/or
179
// output. See the netdevice(7) man page for details.
180
func IoctlIfreq(fd int, req uint, value *Ifreq) error {
181
	// It is possible we will add more fields to *Ifreq itself later to prevent
182
	// misuse, so pass the raw *ifreq directly.
183
	return ioctlPtr(fd, req, unsafe.Pointer(&value.raw))
184
}
185

186
// TODO(mdlayher): export if and when IfreqData is exported.
187

188
// ioctlIfreqData performs an ioctl using an ifreqData structure for input
189
// and/or output. See the netdevice(7) man page for details.
190
func ioctlIfreqData(fd int, req uint, value *ifreqData) error {
191
	// The memory layout of IfreqData (type-safe) and ifreq (not type-safe) are
192
	// identical so pass *IfreqData directly.
193
	return ioctlPtr(fd, req, unsafe.Pointer(value))
194
}
195

196
// IoctlKCMClone attaches a new file descriptor to a multiplexor by cloning an
197
// existing KCM socket, returning a structure containing the file descriptor of
198
// the new socket.
199
func IoctlKCMClone(fd int) (*KCMClone, error) {
200
	var info KCMClone
201
	if err := ioctlPtr(fd, SIOCKCMCLONE, unsafe.Pointer(&info)); err != nil {
202
		return nil, err
203
	}
204

205
	return &info, nil
206
}
207

208
// IoctlKCMAttach attaches a TCP socket and associated BPF program file
209
// descriptor to a multiplexor.
210
func IoctlKCMAttach(fd int, info KCMAttach) error {
211
	return ioctlPtr(fd, SIOCKCMATTACH, unsafe.Pointer(&info))
212
}
213

214
// IoctlKCMUnattach unattaches a TCP socket file descriptor from a multiplexor.
215
func IoctlKCMUnattach(fd int, info KCMUnattach) error {
216
	return ioctlPtr(fd, SIOCKCMUNATTACH, unsafe.Pointer(&info))
217
}
218

219
// IoctlLoopGetStatus64 gets the status of the loop device associated with the
220
// file descriptor fd using the LOOP_GET_STATUS64 operation.
221
func IoctlLoopGetStatus64(fd int) (*LoopInfo64, error) {
222
	var value LoopInfo64
223
	if err := ioctlPtr(fd, LOOP_GET_STATUS64, unsafe.Pointer(&value)); err != nil {
224
		return nil, err
225
	}
226
	return &value, nil
227
}
228

229
// IoctlLoopSetStatus64 sets the status of the loop device associated with the
230
// file descriptor fd using the LOOP_SET_STATUS64 operation.
231
func IoctlLoopSetStatus64(fd int, value *LoopInfo64) error {
232
	return ioctlPtr(fd, LOOP_SET_STATUS64, unsafe.Pointer(value))
233
}
234