P/Invoke ioctl system call

本文关键字：system call ioctl Invoke | 更新日期: 2023-09-27 18:32:55

我正在开发一个需要与Video4Linux抽象交互的应用程序。该应用程序是使用 C# 开发的，使用 mono 框架。

我

面临的问题是我无法P/调用ioctl系统调用。或者，更准确地说，我可以 P/调用它，但它崩溃得很厉害。

外部声明如下：

[DllImport("libc", EntryPoint = "ioctl", SetLastError = true)]
private extern static int KernelIoCtrl(int fd, int request, IntPtr data);

目前为止，一切都好。

使用该KernelIoCtrl的实际例程如下：

protected virtual int Control(IoSpecification request, object data)
{
    GCHandle dataHandle;
    IntPtr dataPointer = IntPtr.Zero;
    try {
        // Pin I/O control data
        if (data != null) {
            dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
            dataPointer = dataHandle.AddrOfPinnedObject();
        }
        // Perform I/O control
        int result =  KernelIoCtrl(mFileDescriptor, request.RequestCode, dataPointer);
        int errno = Marshal.GetLastWin32Error();
        // Throw exception on errors
        if (errno != (int)ErrNumber.NoError)
            throw new System.ComponentModel.Win32Exception(errno);
        return (result);
    } finally {
        if (dataPointer != IntPtr.Zero)
            dataHandle.Free();
    }
}

上面的所有代码似乎都不错。类 IoSpecification 用于计算遵循标头规范的 I/O 请求代码(基本上它遵循在 /usr/include/linux/asm/ioctl.h 处声明的_IOC宏。

data参数是一个结构，声明如下：

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct Capability
{
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)]
    public string Driver;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
    public string Device;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
    public string BusInfo;
    public UInt32 Version;
    public CapabilityFlags Capabilities;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst=4)]
    public UInt32[] Reserved;
}

它应该模仿以下结构(在/usr/include/linux/videodev2.h声明(：

struct v4l2_capability {
    __u8    driver[16];     /* i.e. "bttv" */
    __u8    card[32];       /* i.e. "Hauppauge WinTV" */
    __u8    bus_info[32];   /* "PCI:" + pci_name(pci_dev) */
    __u32   version;        /* should use KERNEL_VERSION() */
    __u32   capabilities;   /* Device capabilities */
    __u32   reserved[4];
};

在发生崩溃之前，IOCTL 请求代码计算存在问题，KernelIoCtrl按预期工作(返回等于 EINVAL 的errno(。当我纠正错误(并且确实具有正确的 IOCTRL 请求代码(时，调用已开始导致崩溃。

总之，结构编组似乎存在问题，但我看不出出了什么问题。

我担心问题是变量参数列表，因为 ioctl 例程声明如下(取自 man(：

int ioctl(int d, int request, ...);

但是我看到很多代码将上述例程声明为 int ioctl(int d, int request, void*); ，我可以确保特定的 IOCTRL 请求只包含一个参数。

P/Invoke ioctl system call

示例用法： 

Capability capability;
if (UnsafeNativeMethods.Ioctl(handle, request, ref capability) == -1)
{
    throw new UnixIOException();
}

能力：

[StructLayout(LayoutKind.Sequential, Size = 104)]
internal struct Capability
{
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)]
    public string Driver;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
    public string Device;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
    public string BusInfo;
    public uint Version;
    public CapabilityFlags Capabilities;
}

不安全的本机方法：

internal static class UnsafeNativeMethods
{
    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
    [DllImport("libc", EntryPoint = "close", SetLastError = true)]
    internal static extern int Close(IntPtr handle);
    [DllImport("libc", EntryPoint = "ioctl", SetLastError = true)]
    internal static extern int Ioctl(SafeUnixHandle handle, uint request, ref Capability capability);
    [DllImport("libc", EntryPoint = "open", SetLastError = true)]
    internal static extern SafeUnixHandle Open(string path, uint flag, int mode);
    internal static string Strerror(int error)
    {
        try
        {
            var buffer = new StringBuilder(256);
            var result = Strerror(error, buffer, (ulong)buffer.Capacity);
            return (result != -1) ? buffer.ToString() : null;
        }
        catch (EntryPointNotFoundException)
        {
            return null;
        }
    }
    [DllImport("MonoPosixHelper", EntryPoint = "Mono_Posix_Syscall_strerror_r", SetLastError = true)]
    private static extern int Strerror(int error, [Out] StringBuilder buffer, ulong length);
}

SafeUnixHandle：

[SecurityPermission(SecurityAction.InheritanceDemand, UnmanagedCode = true)]
[SecurityPermission(SecurityAction.Demand, UnmanagedCode = true)]
internal sealed class SafeUnixHandle : SafeHandle
{
    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
    private SafeUnixHandle()
        : base(new IntPtr(-1), true)
    {
    }
    public override bool IsInvalid
    {
        get { return this.handle == new IntPtr(-1); }
    }
    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
    protected override bool ReleaseHandle()
    {
        return UnsafeNativeMethods.Close(this.handle) != -1;
    }
}

UnixIOException：

[Serializable]
public class UnixIOException : ExternalException
{
    private readonly int nativeErrorCode;
    [SecurityPermission(SecurityAction.Demand, UnmanagedCode = true)]
    public UnixIOException()
        : this(Marshal.GetLastWin32Error())
    {
    }
    [SecurityPermission(SecurityAction.Demand, UnmanagedCode = true)]
    public UnixIOException(int error)
        : this(error, GetErrorMessage(error))
    {
    }
    [SecurityPermission(SecurityAction.Demand, UnmanagedCode = true)]
    public UnixIOException(string message)
        : this(Marshal.GetLastWin32Error(), message)
    {
    }
    public UnixIOException(int error, string message)
        : base(message)
    {
        this.nativeErrorCode = error;
    }
    public UnixIOException(string message, Exception innerException)
        : base(message, innerException)
    {
    }
    protected UnixIOException(SerializationInfo info, StreamingContext context)
        : base(info, context)
    {
        this.nativeErrorCode = info.GetInt32("NativeErrorCode");
    }
    public int NativeErrorCode
    {
        get { return this.nativeErrorCode; }
    }
    public override void GetObjectData(SerializationInfo info, StreamingContext context)
    {
        if (info == null)
        {
            throw new ArgumentNullException("info");
        }
        info.AddValue("NativeErrorCode", this.nativeErrorCode);
        base.GetObjectData(info, context);
    }
    private static string GetErrorMessage(int error)
    {
        var errorDescription = UnsafeNativeMethods.Strerror(error);
        return errorDescription ?? string.Format("Unknown error (0x{0:x})", error);
    }
}
相关文章：