Xilkernel message queue problem

[Martin S. (martin91)]

Hallo!

ich vervende den xilkernel auf einem microblaze prozessor auf einem 
virtex5 fpga. Zur IPC verwende ich message queues, die eigentlich gut 
funktionieren. Das einzige problem das ich habe, ist das ich nur char 
senden kann. Möchte ich zb ein int senden empfange ich nur 0.

hat jemand auch so ein problem? Oder kann mir jemand weiterhelfen? 
Eigentlich sollte man ja jeden typ senden können...

danke
mfg
martin

[Klaus F. (kfalser)]

Ein bischen Code wäre nett.

[Martin S. (martin91)]

also das ganze sieht so aus:

die struktur für die nachricht ist im .h file und sieht so aus:
qkey ist im moment ein char, ich hätte es aber gerne als key_t.

struct _rxmsgq
{
  char qflag; 
  //key_t qkey; 
  char qkey;
};

beide threads machen ein msgget mit dem selben key disp_qkey,
thread 1 schreibt die daten in die struktur, die dann gesendet wird,
thread 2 ließt die queue aus:

Thread 1:

static struct _rxmsgq disptx;

disp_msgid = msgget(disp_qkey, IPC_CREAT);

disptx.qflag=0x0; 
disptx.qkey=eth_qkey; //key wird in die struktur geschrieben

if(msgsnd(disp_msgid, &disptx, RXMSGQ_SIZE, 0) < 0)
{
         //Errorhandling
}

Thread 2:

static struct _rxmsgq disprx;

disp_msgid = msgget(disp_qkey, IPC_CREAT);

while(1)
{
//RXMSGQ_SIZE ist im moment 2
if(msgrcv(disp_msgid,&disprx,RXMSGQ_SIZE,0,IPC_NOWAIT) == RXMSGQ_SIZE)
{
      //hier wird die struktur dann ausgelesen und die daten    weiterverarbeitet
}
}

ich hoffe ich hab das verständlich beschrieben und nichts vergessen! mit 
char typen in der struktur funktioniert ja alles wunderbar, ich fürchte 
nur, dass 1 byte zu klein sein wird und desshalb möchte ich key_t 
senden, weil ich einen key einer anderen message queue senden möchte!

mit int habe ich es auch schon probiert, aber wenn es kein char ist 
empfange ich immer 0.

kann das einfach ein einstellungsproblem im edk sein?
oder liegt das am xilkernel?

danke schon mal im voraus!!

martin

[Klaus F. (kfalser)]

Wie und wo ist RXMSGQ_SIZE definiert?

[Martin S. (martin91)]

Klaus Falser schrieb:
> Wie und wo ist RXMSGQ_SIZE definiert?

#define RXMSGQ_SIZE 2

So ist es definiert, im .h file wo auch die struktur der nachricht 
definiert ist. key_t ist so weit ich weiß 4 byte lang, den wert von 
RXMSGQ_SIZE habe ich auch auf 5 geändert wie ich versucht habe key_t zu 
senden.

danke für die schnelle antwort!

martin

[Klaus F. (kfalser)]

Korrekt wäre wohl

#define RXMSGQ_SIZE (sizeof(struct _rxmsgq))

Es ist gesagt, dass der Compiler die 2 chars unbedingt nebeneinander 
packt.

Außerdem :
Es hat zwar mit deinem Problem  nichts zu tun, aber Bezeichner mit _ 
sollte man nicht verwenden, diese sind laut Konvention für 
implementierungsinterne Dinge reserviert.

[Martin S. (martin91)]

danke für den tipp mit RXMSGQ_SIZE! es funktioniert jetzt!

wenn ich RXMSGQ_SIZE mit 8 definiere dann funktioniert es! wobei ich 
nicht weiß wieso, denn wenn key_t 4 byte hat und ein char 1 byte müsste 
RXMSGQ_SIZE doch eigentlich 5 sein oder? der parameter RXMSGQ_SIZE gibt 
ja die größe der nachricht an?

danke

martin

[Martin S. (martin91)]

Klaus Falser schrieb:
> Korrekt wäre wohl
>
> #define RXMSGQ_SIZE (sizeof(struct _rxmsgq))
>
> Es ist gesagt, dass der Compiler die 2 chars unbedingt nebeneinander
> packt.
>
> Außerdem :
> Es hat zwar mit deinem Problem  nichts zu tun, aber Bezeichner mit _
> sollte man nicht verwenden, diese sind laut Konvention für
> implementierungsinterne Dinge reserviert.

danke für die antwort!
mit sizeof() ist das natürlich am einfachsten gemacht!

danke und lg
martin

[Klaus F. (kfalser)]

Klaus Falser schrieb:
> Es ist gesagt, dass der Compiler die 2 chars unbedingt nebeneinander
> packt.

Eigentlich wollte ich schreiben :
Es ist NICHT gesagt, dass der Compiler die 2 chars unbedingt 
nebeneinander
packt.

[Klaus F. (kfalser)]

Martin S. schrieb:
> wenn wenn key_t 4 byte hat und ein char 1 byte müsste
> RXMSGQ_SIZE doch eigentlich 5 sein oder?

Das wurde in diesen Foren sicher schon öfter diskutiert.
Auf einem 32 Bit Prozessor werden die einzelnen Elemente einer Struktur 
meist an 32 Bit Grenzen ausgerichtet.
Das bedeutet das JEDES Element immer ein Vielfaches von 4 Byte benötigt.
Dies wird aus Performance Gründen gemacht, weil der Prozessor, bzw. die 
Hardware sowieso immer 4 Bytes liest.
Dieses Verhalten kann man meistens auch abschalten.