P / Richiamare la chiamata di sistema ioctl

Sto sviluppando un’applicazione che deve interagire con l’astrazione di Video4Linux. L’applicazione è sviluppata in C #, usando il framework mono.

Il problema che sto affrontando è che non riesco a P / Richiamare la ioctl sistema ioctl . O, più precisamente, posso P / Invocarlo, ma si blocca male.

La dichiarazione extern è la seguente:

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

Fin qui tutto bene.

La routine effettiva che utilizza KernelIoCtrl è la seguente:

 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(); } } 

Tutto il codice sopra sembra buono. La class IoSpecification viene utilizzata per calcolare il codice di richiesta I / O che segue la specifica dell’intestazione (in pratica segue la macro _IOC dichiarata in /usr/include/linux/asm/ioctl.h .

Il parametro data è una struttura, dichiarata come segue:

 [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; } 

che dovrebbe imitare la seguente struttura (dichiarata in /usr/include/linux/videodev2.h ):

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

Prima del crash, c’era un problema nel calcolo del codice di richiesta IOCTL e il KernelIoCtrl funzionava come previsto (restituire un errno equivale a EINVAL ). Quando ho corretto il bug (e infatti avevo il codice di richiesta IOCTRL corretto), la chiamata ha iniziato a causare un arresto anomalo.

In conclusione, sembra che ci sia un problema nel marshalling della struttura, ma non riesco a vedere cosa sta andando storto.

Temo che il problema sia la lista degli argomenti variabili, perché la routine ioctl è dichiarata come segue (tratta dall’uomo):

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

Ma ho visto molto codice dichiarando la routine precedente come int ioctl(int d, int request, void*); e posso garantire che la specifica richiesta IOCTRL richieda solo un argomento.

Esempio di utilizzo:

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

Capacità:

 [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; } 

UnsafeNativeMethods:

 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); } }