golang.org/x/sys@v0.20.1-0.20240517151509-673e0f94c16d/unix/ioctl_linux.go (about) 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 235 // IoctlLoopConfigure configures all loop device parameters in a single step 236 func IoctlLoopConfigure(fd int, value *LoopConfig) error { 237 return ioctlPtr(fd, LOOP_CONFIGURE, unsafe.Pointer(value)) 238 }