ioctl_linux.go

     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  // IoctlGetEthtoolTsInfo fetches ethtool timestamping and PHC
    62  // association for the network device specified by ifname.
    63  func IoctlGetEthtoolTsInfo(fd int, ifname string) (*EthtoolTsInfo, error) {
    64  	ifr, err := NewIfreq(ifname)
    65  	if err != nil {
    66  		return nil, err
    67  	}
    68  
    69  	value := EthtoolTsInfo{Cmd: ETHTOOL_GET_TS_INFO}
    70  	ifrd := ifr.withData(unsafe.Pointer(&value))
    71  
    72  	err = ioctlIfreqData(fd, SIOCETHTOOL, &ifrd)
    73  	return &value, err
    74  }
    75  
    76  // IoctlGetHwTstamp retrieves the hardware timestamping configuration
    77  // for the network device specified by ifname.
    78  func IoctlGetHwTstamp(fd int, ifname string) (*HwTstampConfig, error) {
    79  	ifr, err := NewIfreq(ifname)
    80  	if err != nil {
    81  		return nil, err
    82  	}
    83  
    84  	value := HwTstampConfig{}
    85  	ifrd := ifr.withData(unsafe.Pointer(&value))
    86  
    87  	err = ioctlIfreqData(fd, SIOCGHWTSTAMP, &ifrd)
    88  	return &value, err
    89  }
    90  
    91  // IoctlSetHwTstamp updates the hardware timestamping configuration for
    92  // the network device specified by ifname.
    93  func IoctlSetHwTstamp(fd int, ifname string, cfg *HwTstampConfig) error {
    94  	ifr, err := NewIfreq(ifname)
    95  	if err != nil {
    96  		return err
    97  	}
    98  	ifrd := ifr.withData(unsafe.Pointer(cfg))
    99  	return ioctlIfreqData(fd, SIOCSHWTSTAMP, &ifrd)
   100  }
   101  
   102  // FdToClockID derives the clock ID from the file descriptor number
   103  // - see clock_gettime(3), FD_TO_CLOCKID macros. The resulting ID is
   104  // suitable for system calls like ClockGettime.
   105  func FdToClockID(fd int) int32 { return int32((int(^fd) << 3) | 3) }
   106  
   107  // IoctlPtpClockGetcaps returns the description of a given PTP device.
   108  func IoctlPtpClockGetcaps(fd int) (*PtpClockCaps, error) {
   109  	var value PtpClockCaps
   110  	err := ioctlPtr(fd, PTP_CLOCK_GETCAPS2, unsafe.Pointer(&value))
   111  	return &value, err
   112  }
   113  
   114  // IoctlPtpSysOffsetPrecise returns a description of the clock
   115  // offset compared to the system clock.
   116  func IoctlPtpSysOffsetPrecise(fd int) (*PtpSysOffsetPrecise, error) {
   117  	var value PtpSysOffsetPrecise
   118  	err := ioctlPtr(fd, PTP_SYS_OFFSET_PRECISE2, unsafe.Pointer(&value))
   119  	return &value, err
   120  }
   121  
   122  // IoctlPtpSysOffsetExtended returns an extended description of the
   123  // clock offset compared to the system clock. The samples parameter
   124  // specifies the desired number of measurements.
   125  func IoctlPtpSysOffsetExtended(fd int, samples uint) (*PtpSysOffsetExtended, error) {
   126  	value := PtpSysOffsetExtended{Samples: uint32(samples)}
   127  	err := ioctlPtr(fd, PTP_SYS_OFFSET_EXTENDED2, unsafe.Pointer(&value))
   128  	return &value, err
   129  }
   130  
   131  // IoctlPtpPinGetfunc returns the configuration of the specified
   132  // I/O pin on given PTP device.
   133  func IoctlPtpPinGetfunc(fd int, index uint) (*PtpPinDesc, error) {
   134  	value := PtpPinDesc{Index: uint32(index)}
   135  	err := ioctlPtr(fd, PTP_PIN_GETFUNC2, unsafe.Pointer(&value))
   136  	return &value, err
   137  }
   138  
   139  // IoctlPtpPinSetfunc updates configuration of the specified PTP
   140  // I/O pin.
   141  func IoctlPtpPinSetfunc(fd int, pd *PtpPinDesc) error {
   142  	return ioctlPtr(fd, PTP_PIN_SETFUNC2, unsafe.Pointer(pd))
   143  }
   144  
   145  // IoctlPtpPeroutRequest configures the periodic output mode of the
   146  // PTP I/O pins.
   147  func IoctlPtpPeroutRequest(fd int, r *PtpPeroutRequest) error {
   148  	return ioctlPtr(fd, PTP_PEROUT_REQUEST2, unsafe.Pointer(r))
   149  }
   150  
   151  // IoctlPtpExttsRequest configures the external timestamping mode
   152  // of the PTP I/O pins.
   153  func IoctlPtpExttsRequest(fd int, r *PtpExttsRequest) error {
   154  	return ioctlPtr(fd, PTP_EXTTS_REQUEST2, unsafe.Pointer(r))
   155  }
   156  
   157  // IoctlGetWatchdogInfo fetches information about a watchdog device from the
   158  // Linux watchdog API. For more information, see:
   159  // https://www.kernel.org/doc/html/latest/watchdog/watchdog-api.html.
   160  func IoctlGetWatchdogInfo(fd int) (*WatchdogInfo, error) {
   161  	var value WatchdogInfo
   162  	err := ioctlPtr(fd, WDIOC_GETSUPPORT, unsafe.Pointer(&value))
   163  	return &value, err
   164  }
   165  
   166  // IoctlWatchdogKeepalive issues a keepalive ioctl to a watchdog device. For
   167  // more information, see:
   168  // https://www.kernel.org/doc/html/latest/watchdog/watchdog-api.html.
   169  func IoctlWatchdogKeepalive(fd int) error {
   170  	// arg is ignored and not a pointer, so ioctl is fine instead of ioctlPtr.
   171  	return ioctl(fd, WDIOC_KEEPALIVE, 0)
   172  }
   173  
   174  // IoctlFileCloneRange performs an FICLONERANGE ioctl operation to clone the
   175  // range of data conveyed in value to the file associated with the file
   176  // descriptor destFd. See the ioctl_ficlonerange(2) man page for details.
   177  func IoctlFileCloneRange(destFd int, value *FileCloneRange) error {
   178  	return ioctlPtr(destFd, FICLONERANGE, unsafe.Pointer(value))
   179  }
   180  
   181  // IoctlFileClone performs an FICLONE ioctl operation to clone the entire file
   182  // associated with the file description srcFd to the file associated with the
   183  // file descriptor destFd. See the ioctl_ficlone(2) man page for details.
   184  func IoctlFileClone(destFd, srcFd int) error {
   185  	return ioctl(destFd, FICLONE, uintptr(srcFd))
   186  }
   187  
   188  type FileDedupeRange struct {
   189  	Src_offset uint64
   190  	Src_length uint64
   191  	Reserved1  uint16
   192  	Reserved2  uint32
   193  	Info       []FileDedupeRangeInfo
   194  }
   195  
   196  type FileDedupeRangeInfo struct {
   197  	Dest_fd       int64
   198  	Dest_offset   uint64
   199  	Bytes_deduped uint64
   200  	Status        int32
   201  	Reserved      uint32
   202  }
   203  
   204  // IoctlFileDedupeRange performs an FIDEDUPERANGE ioctl operation to share the
   205  // range of data conveyed in value from the file associated with the file
   206  // descriptor srcFd to the value.Info destinations. See the
   207  // ioctl_fideduperange(2) man page for details.
   208  func IoctlFileDedupeRange(srcFd int, value *FileDedupeRange) error {
   209  	buf := make([]byte, SizeofRawFileDedupeRange+
   210  		len(value.Info)*SizeofRawFileDedupeRangeInfo)
   211  	rawrange := (*RawFileDedupeRange)(unsafe.Pointer(&buf[0]))
   212  	rawrange.Src_offset = value.Src_offset
   213  	rawrange.Src_length = value.Src_length
   214  	rawrange.Dest_count = uint16(len(value.Info))
   215  	rawrange.Reserved1 = value.Reserved1
   216  	rawrange.Reserved2 = value.Reserved2
   217  
   218  	for i := range value.Info {
   219  		rawinfo := (*RawFileDedupeRangeInfo)(unsafe.Pointer(
   220  			uintptr(unsafe.Pointer(&buf[0])) + uintptr(SizeofRawFileDedupeRange) +
   221  				uintptr(i*SizeofRawFileDedupeRangeInfo)))
   222  		rawinfo.Dest_fd = value.Info[i].Dest_fd
   223  		rawinfo.Dest_offset = value.Info[i].Dest_offset
   224  		rawinfo.Bytes_deduped = value.Info[i].Bytes_deduped
   225  		rawinfo.Status = value.Info[i].Status
   226  		rawinfo.Reserved = value.Info[i].Reserved
   227  	}
   228  
   229  	err := ioctlPtr(srcFd, FIDEDUPERANGE, unsafe.Pointer(&buf[0]))
   230  
   231  	// Output
   232  	for i := range value.Info {
   233  		rawinfo := (*RawFileDedupeRangeInfo)(unsafe.Pointer(
   234  			uintptr(unsafe.Pointer(&buf[0])) + uintptr(SizeofRawFileDedupeRange) +
   235  				uintptr(i*SizeofRawFileDedupeRangeInfo)))
   236  		value.Info[i].Dest_fd = rawinfo.Dest_fd
   237  		value.Info[i].Dest_offset = rawinfo.Dest_offset
   238  		value.Info[i].Bytes_deduped = rawinfo.Bytes_deduped
   239  		value.Info[i].Status = rawinfo.Status
   240  		value.Info[i].Reserved = rawinfo.Reserved
   241  	}
   242  
   243  	return err
   244  }
   245  
   246  func IoctlHIDGetDesc(fd int, value *HIDRawReportDescriptor) error {
   247  	return ioctlPtr(fd, HIDIOCGRDESC, unsafe.Pointer(value))
   248  }
   249  
   250  func IoctlHIDGetRawInfo(fd int) (*HIDRawDevInfo, error) {
   251  	var value HIDRawDevInfo
   252  	err := ioctlPtr(fd, HIDIOCGRAWINFO, unsafe.Pointer(&value))
   253  	return &value, err
   254  }
   255  
   256  func IoctlHIDGetRawName(fd int) (string, error) {
   257  	var value [_HIDIOCGRAWNAME_LEN]byte
   258  	err := ioctlPtr(fd, _HIDIOCGRAWNAME, unsafe.Pointer(&value[0]))
   259  	return ByteSliceToString(value[:]), err
   260  }
   261  
   262  func IoctlHIDGetRawPhys(fd int) (string, error) {
   263  	var value [_HIDIOCGRAWPHYS_LEN]byte
   264  	err := ioctlPtr(fd, _HIDIOCGRAWPHYS, unsafe.Pointer(&value[0]))
   265  	return ByteSliceToString(value[:]), err
   266  }
   267  
   268  func IoctlHIDGetRawUniq(fd int) (string, error) {
   269  	var value [_HIDIOCGRAWUNIQ_LEN]byte
   270  	err := ioctlPtr(fd, _HIDIOCGRAWUNIQ, unsafe.Pointer(&value[0]))
   271  	return ByteSliceToString(value[:]), err
   272  }
   273  
   274  // IoctlIfreq performs an ioctl using an Ifreq structure for input and/or
   275  // output. See the netdevice(7) man page for details.
   276  func IoctlIfreq(fd int, req uint, value *Ifreq) error {
   277  	// It is possible we will add more fields to *Ifreq itself later to prevent
   278  	// misuse, so pass the raw *ifreq directly.
   279  	return ioctlPtr(fd, req, unsafe.Pointer(&value.raw))
   280  }
   281  
   282  // TODO(mdlayher): export if and when IfreqData is exported.
   283  
   284  // ioctlIfreqData performs an ioctl using an ifreqData structure for input
   285  // and/or output. See the netdevice(7) man page for details.
   286  func ioctlIfreqData(fd int, req uint, value *ifreqData) error {
   287  	// The memory layout of IfreqData (type-safe) and ifreq (not type-safe) are
   288  	// identical so pass *IfreqData directly.
   289  	return ioctlPtr(fd, req, unsafe.Pointer(value))
   290  }
   291  
   292  // IoctlKCMClone attaches a new file descriptor to a multiplexor by cloning an
   293  // existing KCM socket, returning a structure containing the file descriptor of
   294  // the new socket.
   295  func IoctlKCMClone(fd int) (*KCMClone, error) {
   296  	var info KCMClone
   297  	if err := ioctlPtr(fd, SIOCKCMCLONE, unsafe.Pointer(&info)); err != nil {
   298  		return nil, err
   299  	}
   300  
   301  	return &info, nil
   302  }
   303  
   304  // IoctlKCMAttach attaches a TCP socket and associated BPF program file
   305  // descriptor to a multiplexor.
   306  func IoctlKCMAttach(fd int, info KCMAttach) error {
   307  	return ioctlPtr(fd, SIOCKCMATTACH, unsafe.Pointer(&info))
   308  }
   309  
   310  // IoctlKCMUnattach unattaches a TCP socket file descriptor from a multiplexor.
   311  func IoctlKCMUnattach(fd int, info KCMUnattach) error {
   312  	return ioctlPtr(fd, SIOCKCMUNATTACH, unsafe.Pointer(&info))
   313  }
   314  
   315  // IoctlLoopGetStatus64 gets the status of the loop device associated with the
   316  // file descriptor fd using the LOOP_GET_STATUS64 operation.
   317  func IoctlLoopGetStatus64(fd int) (*LoopInfo64, error) {
   318  	var value LoopInfo64
   319  	if err := ioctlPtr(fd, LOOP_GET_STATUS64, unsafe.Pointer(&value)); err != nil {
   320  		return nil, err
   321  	}
   322  	return &value, nil
   323  }
   324  
   325  // IoctlLoopSetStatus64 sets the status of the loop device associated with the
   326  // file descriptor fd using the LOOP_SET_STATUS64 operation.
   327  func IoctlLoopSetStatus64(fd int, value *LoopInfo64) error {
   328  	return ioctlPtr(fd, LOOP_SET_STATUS64, unsafe.Pointer(value))
   329  }
   330  
   331  // IoctlLoopConfigure configures all loop device parameters in a single step
   332  func IoctlLoopConfigure(fd int, value *LoopConfig) error {
   333  	return ioctlPtr(fd, LOOP_CONFIGURE, unsafe.Pointer(value))
   334  }
   335
View as plain text