[libvirt] virDomainInfo marshalling prolem
?Hi, I am working on the marshaling of the virDomainInfo structure. I have marshalled it in this way : /// <summary> /// Structure to handle domain informations /// </summary> [StructLayout(LayoutKind.Sequential)] public class DomainInfo { /// <summary> /// The running state, one of virDomainState. /// </summary> private Byte state; /// <summary> /// The maximum memory in KBytes allowed. /// </summary> public int maxMem; /// <summary> /// The memory in KBytes used by the domain. /// </summary> public int memory; /// <summary> /// The number of virtual CPUs for the domain. /// </summary> public short nrVirtCpu; /// <summary> /// The CPU time used in nanoseconds. /// </summary> public long cpuTime; /// <summary> /// The running state, one of virDomainState. /// </summary> public DomainState State { get { return (DomainState)state; } } } It work fine in 32 bits, but not in 64 bits, it seems that packing in 64 bits is different so infos are not in order. Am I right ? Regards, Arnaud
2010/10/29 <arnaud.champion@devatom.fr>:
Hi,
I am working on the marshaling of the virDomainInfo structure. I have marshalled it in this way :
///
<summary>
/// Structure to handle domain informations
/// </summary>
[
StructLayout(LayoutKind.Sequential)]
public class DomainInfo
{
/// <summary> /// The running state, one of virDomainState. /// </summary> private Byte state; /// <summary> /// The maximum memory in KBytes allowed. /// </summary> public int maxMem; /// <summary> /// The memory in KBytes used by the domain. /// </summary> public int memory; /// <summary> /// The number of virtual CPUs for the domain. /// </summary> public short nrVirtCpu; /// <summary> /// The CPU time used in nanoseconds. /// </summary> public long cpuTime; /// <summary> /// The running state, one of virDomainState. /// </summary> public DomainState State { get { return (DomainState)state; } }
}
It work fine in 32 bits, but not in 64 bits, it seems that packing in 64 bits is different so infos are not in order. Am I right ?
In the struct looks like this struct _virDomainInfo { unsigned char state; /* the running state, one of virDomainState */ unsigned long maxMem; /* the maximum memory in KBytes allowed */ unsigned long memory; /* the memory in KBytes used by the domain */ unsigned short nrVirtCpu; /* the number of virtual CPUs for the domain */ unsigned long long cpuTime; /* the CPU time used in nanoseconds */ }; but you mapped unsigned long to int. First of all you should map this to an unsigned type. You also lost the unsigned for some other members. The problem probably is that long in C is 32bit on a 32bit platform an 64bit on a 64bit platform. You mapped it to int that is always 32bit in C#, when I looked it up correctly. Matthias
On Fri, Oct 29, 2010 at 04:19:22PM +0200, Matthias Bolte wrote:
2010/10/29 <arnaud.champion@devatom.fr>:
Hi,
I am working on the marshaling of the virDomainInfo structure. I have marshalled it in this way :
///
<summary>
/// Structure to handle domain informations
/// </summary>
[
StructLayout(LayoutKind.Sequential)]
public class DomainInfo
{
/// <summary> /// The running state, one of virDomainState. /// </summary> private Byte state; /// <summary> /// The maximum memory in KBytes allowed. /// </summary> public int maxMem; /// <summary> /// The memory in KBytes used by the domain. /// </summary> public int memory; /// <summary> /// The number of virtual CPUs for the domain. /// </summary> public short nrVirtCpu; /// <summary> /// The CPU time used in nanoseconds. /// </summary> public long cpuTime; /// <summary> /// The running state, one of virDomainState. /// </summary> public DomainState State { get { return (DomainState)state; } }
}
It work fine in 32 bits, but not in 64 bits, it seems that packing in 64 bits is different so infos are not in order. Am I right ?
In the struct looks like this
struct _virDomainInfo { unsigned char state; /* the running state, one of virDomainState */ unsigned long maxMem; /* the maximum memory in KBytes allowed */ unsigned long memory; /* the memory in KBytes used by the domain */ unsigned short nrVirtCpu; /* the number of virtual CPUs for the domain */ unsigned long long cpuTime; /* the CPU time used in nanoseconds */ };
but you mapped unsigned long to int. First of all you should map this to an unsigned type. You also lost the unsigned for some other members.
The problem probably is that long in C is 32bit on a 32bit platform an 64bit on a 64bit platform. You mapped it to int that is always 32bit in C#, when I looked it up correctly.
Not quite. Windows just had to do things diffrently on 64-bit and so used the LLP64 model instead of LP64 used by the rest of the world :-( http://technet.microsoft.com/en-us/library/bb496995.aspx In the UNIX/64 data model: The size of int is 32 bits and the size of long and pointers is 64 bits. In the Win64 model: The size of int and long is 32 bits; the size of int64 (new type) and pointers is 64 bits. Regards, Daniel -- |: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :| |: http://libvirt.org -o- http://virt-manager.org -o- http://deltacloud.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|
2010/10/29 Daniel P. Berrange <berrange@redhat.com>:
On Fri, Oct 29, 2010 at 04:19:22PM +0200, Matthias Bolte wrote:
2010/10/29 <arnaud.champion@devatom.fr>:
Hi,
I am working on the marshaling of the virDomainInfo structure. I have marshalled it in this way :
///
<summary>
/// Structure to handle domain informations
/// </summary>
[
StructLayout(LayoutKind.Sequential)]
public class DomainInfo
{
/// <summary> /// The running state, one of virDomainState. /// </summary> private Byte state; /// <summary> /// The maximum memory in KBytes allowed. /// </summary> public int maxMem; /// <summary> /// The memory in KBytes used by the domain. /// </summary> public int memory; /// <summary> /// The number of virtual CPUs for the domain. /// </summary> public short nrVirtCpu; /// <summary> /// The CPU time used in nanoseconds. /// </summary> public long cpuTime; /// <summary> /// The running state, one of virDomainState. /// </summary> public DomainState State { get { return (DomainState)state; } }
}
It work fine in 32 bits, but not in 64 bits, it seems that packing in 64 bits is different so infos are not in order. Am I right ?
In the struct looks like this
struct _virDomainInfo { unsigned char state; /* the running state, one of virDomainState */ unsigned long maxMem; /* the maximum memory in KBytes allowed */ unsigned long memory; /* the memory in KBytes used by the domain */ unsigned short nrVirtCpu; /* the number of virtual CPUs for the domain */ unsigned long long cpuTime; /* the CPU time used in nanoseconds */ };
but you mapped unsigned long to int. First of all you should map this to an unsigned type. You also lost the unsigned for some other members.
The problem probably is that long in C is 32bit on a 32bit platform an 64bit on a 64bit platform. You mapped it to int that is always 32bit in C#, when I looked it up correctly.
Not quite. Windows just had to do things diffrently on 64-bit and so used the LLP64 model instead of LP64 used by the rest of the world :-(
http://technet.microsoft.com/en-us/library/bb496995.aspx
In the UNIX/64 data model: The size of int is 32 bits and the size of long and pointers is 64 bits.
In the Win64 model: The size of int and long is 32 bits; the size of int64 (new type) and pointers is 64 bits.
Regards, Daniel
Ah yes. I forgot about that one. So this gets even more complicated when you want to get the C# bindings working on 32 and 64 bit Windows and Linux. Matthias
Mouarf, funny thing :) -------------------------------------------------- From: "Matthias Bolte" <matthias.bolte@googlemail.com> Sent: Friday, October 29, 2010 4:36 PM To: "Daniel P. Berrange" <berrange@redhat.com> Cc: <arnaud.champion@devatom.fr>; <libvir-list@redhat.com> Subject: Re: [libvirt] virDomainInfo marshalling prolem
2010/10/29 Daniel P. Berrange <berrange@redhat.com>:
On Fri, Oct 29, 2010 at 04:19:22PM +0200, Matthias Bolte wrote:
2010/10/29 <arnaud.champion@devatom.fr>:
Hi,
I am working on the marshaling of the virDomainInfo structure. I have marshalled it in this way :
///
<summary>
/// Structure to handle domain informations
/// </summary>
[
StructLayout(LayoutKind.Sequential)]
public class DomainInfo
{
/// <summary> /// The running state, one of virDomainState. /// </summary> private Byte state; /// <summary> /// The maximum memory in KBytes allowed. /// </summary> public int maxMem; /// <summary> /// The memory in KBytes used by the domain. /// </summary> public int memory; /// <summary> /// The number of virtual CPUs for the domain. /// </summary> public short nrVirtCpu; /// <summary> /// The CPU time used in nanoseconds. /// </summary> public long cpuTime; /// <summary> /// The running state, one of virDomainState. /// </summary> public DomainState State { get { return (DomainState)state; } }
}
It work fine in 32 bits, but not in 64 bits, it seems that packing in 64 bits is different so infos are not in order. Am I right ?
In the struct looks like this
struct _virDomainInfo { unsigned char state; /* the running state, one of virDomainState */ unsigned long maxMem; /* the maximum memory in KBytes allowed */ unsigned long memory; /* the memory in KBytes used by the domain */ unsigned short nrVirtCpu; /* the number of virtual CPUs for the domain */ unsigned long long cpuTime; /* the CPU time used in nanoseconds */ };
but you mapped unsigned long to int. First of all you should map this to an unsigned type. You also lost the unsigned for some other members.
The problem probably is that long in C is 32bit on a 32bit platform an 64bit on a 64bit platform. You mapped it to int that is always 32bit in C#, when I looked it up correctly.
Not quite. Windows just had to do things diffrently on 64-bit and so used the LLP64 model instead of LP64 used by the rest of the world :-(
http://technet.microsoft.com/en-us/library/bb496995.aspx
In the UNIX/64 data model: The size of int is 32 bits and the size of long and pointers is 64 bits.
In the Win64 model: The size of int and long is 32 bits; the size of int64 (new type) and pointers is 64 bits.
Regards, Daniel
Ah yes. I forgot about that one. So this gets even more complicated when you want to get the C# bindings working on 32 and 64 bit Windows and Linux.
Matthias
There is an unmanaged type to specify when marshaling this : UnamanagedType.SysInt or UnmanagedType.SysUInt, which are 64b or 32bits aware. But the problem under windows : libvirt is compiled thru mingwin so the dll is in 32bits and even if windows is in 64bits, I have to make bindings over 32bits (I'm not sure my english make things clear when I explain) Arnaud -------------------------------------------------- From: <arnaud.champion@devatom.fr> Sent: Friday, October 29, 2010 4:41 PM To: "Matthias Bolte" <matthias.bolte@googlemail.com>; "Daniel P. Berrange" <berrange@redhat.com> Cc: <libvir-list@redhat.com> Subject: Re: [libvirt] virDomainInfo marshalling prolem
Mouarf, funny thing :)
-------------------------------------------------- From: "Matthias Bolte" <matthias.bolte@googlemail.com> Sent: Friday, October 29, 2010 4:36 PM To: "Daniel P. Berrange" <berrange@redhat.com> Cc: <arnaud.champion@devatom.fr>; <libvir-list@redhat.com> Subject: Re: [libvirt] virDomainInfo marshalling prolem
2010/10/29 Daniel P. Berrange <berrange@redhat.com>:
On Fri, Oct 29, 2010 at 04:19:22PM +0200, Matthias Bolte wrote:
2010/10/29 <arnaud.champion@devatom.fr>:
Hi,
I am working on the marshaling of the virDomainInfo structure. I have marshalled it in this way :
///
<summary>
/// Structure to handle domain informations
/// </summary>
[
StructLayout(LayoutKind.Sequential)]
public class DomainInfo
{
/// <summary> /// The running state, one of virDomainState. /// </summary> private Byte state; /// <summary> /// The maximum memory in KBytes allowed. /// </summary> public int maxMem; /// <summary> /// The memory in KBytes used by the domain. /// </summary> public int memory; /// <summary> /// The number of virtual CPUs for the domain. /// </summary> public short nrVirtCpu; /// <summary> /// The CPU time used in nanoseconds. /// </summary> public long cpuTime; /// <summary> /// The running state, one of virDomainState. /// </summary> public DomainState State { get { return (DomainState)state; } }
}
It work fine in 32 bits, but not in 64 bits, it seems that packing in 64 bits is different so infos are not in order. Am I right ?
In the struct looks like this
struct _virDomainInfo { unsigned char state; /* the running state, one of virDomainState */ unsigned long maxMem; /* the maximum memory in KBytes allowed */ unsigned long memory; /* the memory in KBytes used by the domain */ unsigned short nrVirtCpu; /* the number of virtual CPUs for the domain */ unsigned long long cpuTime; /* the CPU time used in nanoseconds */ };
but you mapped unsigned long to int. First of all you should map this to an unsigned type. You also lost the unsigned for some other members.
The problem probably is that long in C is 32bit on a 32bit platform an 64bit on a 64bit platform. You mapped it to int that is always 32bit in C#, when I looked it up correctly.
Not quite. Windows just had to do things diffrently on 64-bit and so used the LLP64 model instead of LP64 used by the rest of the world :-(
http://technet.microsoft.com/en-us/library/bb496995.aspx
In the UNIX/64 data model: The size of int is 32 bits and the size of long and pointers is 64 bits.
In the Win64 model: The size of int and long is 32 bits; the size of int64 (new type) and pointers is 64 bits.
Regards, Daniel
Ah yes. I forgot about that one. So this gets even more complicated when you want to get the C# bindings working on 32 and 64 bit Windows and Linux.
Matthias
-- libvir-list mailing list libvir-list@redhat.com https://www.redhat.com/mailman/listinfo/libvir-list
On 10/30/2010 01:48 AM, arnaud.champion@devatom.fr wrote:
There is an unmanaged type to specify when marshaling this : UnamanagedType.SysInt or UnmanagedType.SysUInt, which are 64b or 32bits aware. But the problem under windows : libvirt is compiled thru mingwin so the dll is in 32bits and even if windows is in 64bits, I have to make bindings over 32bits (I'm not sure my english make things clear when I explain)
Yeah, that's clear. Using mingwin is causing the bindings to be 32-bit, regardless of whether the Windows OS is 32-bit or 64-bit.
Hi, I think I got it. I think I have to marshal in this manner : [StructLayout(LayoutKind.Sequential)] public class DomainInfo { private byte state; [MarshalAs(UnmanagedType.SysUInt)] public UIntPtr maxMem; [MarshalAs(UnmanagedType.SysUInt)] public UIntPtr memory; public ushort nrVirtCpu; [MarshalAs(UnmanagedType.SysUInt)] public UIntPtr cpuTime; public DomainState State { get { return (DomainState)state; } } } And I also have to set the target of the LibvirtBindings project to x86. Why ? The compilation of libvirt under mingwin produce a 32bits binary, so I MUST marshal libvirt with a 32bits schema. That doesn't break compatibility with 64bits project using bindings, and this allow the usage of the attribute [MarshalAs(Unamanged.SysUint)]. This attribute specify the target schema for bindings at runtime. In this way, under 64bits systems, it takes ulong on 8 bytes, and on 4 bytes under 32bits. This make the bindings work under Windows/mono(32bits, as the mono exxcutable is in 32bits, even if my system is 64bits), works also under Windows/.Net(64bits) and works under Ubuntu/Mono(64 bits). Any suggestion ? Regards, Arnaud -------------------------------------------------- From: "Justin Clift" <jclift@redhat.com> Sent: Saturday, October 30, 2010 1:39 AM To: <arnaud.champion@devatom.fr> Cc: "Matthias Bolte" <matthias.bolte@googlemail.com>; "Daniel P. Berrange" <berrange@redhat.com>; <libvir-list@redhat.com> Subject: Re: [libvirt] virDomainInfo marshalling prolem
On 10/30/2010 01:48 AM, arnaud.champion@devatom.fr wrote:
There is an unmanaged type to specify when marshaling this : UnamanagedType.SysInt or UnmanagedType.SysUInt, which are 64b or 32bits aware. But the problem under windows : libvirt is compiled thru mingwin so the dll is in 32bits and even if windows is in 64bits, I have to make bindings over 32bits (I'm not sure my english make things clear when I explain)
Yeah, that's clear. Using mingwin is causing the bindings to be 32-bit, regardless of whether the Windows OS is 32-bit or 64-bit.
On Fri, Oct 29, 2010 at 03:30:08PM +0100, Daniel P. Berrange wrote:
On Fri, Oct 29, 2010 at 04:19:22PM +0200, Matthias Bolte wrote:
2010/10/29 <arnaud.champion@devatom.fr>:
Hi,
I am working on the marshaling of the virDomainInfo structure. I have marshalled it in this way :
///
<summary>
/// Structure to handle domain informations
/// </summary>
[
StructLayout(LayoutKind.Sequential)]
public class DomainInfo
{
/// <summary> /// The running state, one of virDomainState. /// </summary> private Byte state; /// <summary> /// The maximum memory in KBytes allowed. /// </summary> public int maxMem; /// <summary> /// The memory in KBytes used by the domain. /// </summary> public int memory; /// <summary> /// The number of virtual CPUs for the domain. /// </summary> public short nrVirtCpu; /// <summary> /// The CPU time used in nanoseconds. /// </summary> public long cpuTime; /// <summary> /// The running state, one of virDomainState. /// </summary> public DomainState State { get { return (DomainState)state; } }
}
It work fine in 32 bits, but not in 64 bits, it seems that packing in 64 bits is different so infos are not in order. Am I right ?
In the struct looks like this
struct _virDomainInfo { unsigned char state; /* the running state, one of virDomainState */ unsigned long maxMem; /* the maximum memory in KBytes allowed */ unsigned long memory; /* the memory in KBytes used by the domain */ unsigned short nrVirtCpu; /* the number of virtual CPUs for the domain */ unsigned long long cpuTime; /* the CPU time used in nanoseconds */ };
but you mapped unsigned long to int. First of all you should map this to an unsigned type. You also lost the unsigned for some other members.
The problem probably is that long in C is 32bit on a 32bit platform an 64bit on a 64bit platform. You mapped it to int that is always 32bit in C#, when I looked it up correctly.
Not quite. Windows just had to do things diffrently on 64-bit and so used the LLP64 model instead of LP64 used by the rest of the world :-(
http://technet.microsoft.com/en-us/library/bb496995.aspx
In the UNIX/64 data model: The size of int is 32 bits and the size of long and pointers is 64 bits.
In the Win64 model: The size of int and long is 32 bits; the size of int64 (new type) and pointers is 64 bits.
NB, while this means that int, long and long long don't vary in size between on Win32 and Win64, I bet that compiler alignment in structs will be 8 bytes for Win64, and only 4 bytes for Win32. So while the above C# struct definition may be correct in terms of its types, the alignment of fields is possibly wrong for 64 bit. Daniel -- |: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :| |: http://libvirt.org -o- http://virt-manager.org -o- http://deltacloud.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|
Okay, I have corrected to this structure : public class DomainInfo { /// <summary> /// The running state, one of virDomainState. /// </summary> private byte state; /// <summary> /// The maximum memory in KBytes allowed. /// </summary> public ulong maxMem; /// <summary> /// The memory in KBytes used by the domain. /// </summary> public ulong memory; /// <summary> /// The number of virtual CPUs for the domain. /// </summary> public ushort nrVirtCpu; /// <summary> /// The CPU time used in nanoseconds. /// </summary> public ulong cpuTime; /// <summary> /// The running state, one of virDomainState. /// </summary> public DomainState State { get { return (DomainState)state; } } } And now it works in 64bits but not in 32bits :S Arnaud -------------------------------------------------- From: "Matthias Bolte" <matthias.bolte@googlemail.com> Sent: Friday, October 29, 2010 4:19 PM To: <arnaud.champion@devatom.fr> Cc: <libvir-list@redhat.com> Subject: Re: [libvirt] virDomainInfo marshalling prolem
2010/10/29 <arnaud.champion@devatom.fr>:
Hi,
I am working on the marshaling of the virDomainInfo structure. I have marshalled it in this way :
///
<summary>
/// Structure to handle domain informations
/// </summary>
[
StructLayout(LayoutKind.Sequential)]
public class DomainInfo
{
/// <summary> /// The running state, one of virDomainState. /// </summary> private Byte state; /// <summary> /// The maximum memory in KBytes allowed. /// </summary> public int maxMem; /// <summary> /// The memory in KBytes used by the domain. /// </summary> public int memory; /// <summary> /// The number of virtual CPUs for the domain. /// </summary> public short nrVirtCpu; /// <summary> /// The CPU time used in nanoseconds. /// </summary> public long cpuTime; /// <summary> /// The running state, one of virDomainState. /// </summary> public DomainState State { get { return (DomainState)state; } }
}
It work fine in 32 bits, but not in 64 bits, it seems that packing in 64 bits is different so infos are not in order. Am I right ?
In the struct looks like this
struct _virDomainInfo { unsigned char state; /* the running state, one of virDomainState */ unsigned long maxMem; /* the maximum memory in KBytes allowed */ unsigned long memory; /* the memory in KBytes used by the domain */ unsigned short nrVirtCpu; /* the number of virtual CPUs for the domain */ unsigned long long cpuTime; /* the CPU time used in nanoseconds */ };
but you mapped unsigned long to int. First of all you should map this to an unsigned type. You also lost the unsigned for some other members.
The problem probably is that long in C is 32bit on a 32bit platform an 64bit on a 64bit platform. You mapped it to int that is always 32bit in C#, when I looked it up correctly.
Matthias
participants (4)
-
arnaud.champion＠devatom.fr -
Daniel P. Berrange -
Justin Clift -
Matthias Bolte