Skip to contentSkip to conversation

shared memory between 32bit & 64bit applications

DISCUSSION Matthew Wilcox 4 participants 4 messages May 3, 2004 – May 4, 2004

lore
Share & tools
lore
#0 lore raw
Quoted 9 lines · CHINMAYA TM (STSD)

The information which is held in the shared memory is interpreted as in the structure
typedef struct shmtest

{
        int req;
        long long id;
        int abc;
}shmtest_t;
Quoted 4 lines

The 64 bit application fills in {1,5,5} in the shared memory and when I access these values from a 32 bit application I get it as {1,21474836480,0}. I guess this is due to switch of lower and upper significant bytes.

Nope. You're being bitten by different struct padding rules.

#include <stdio.h>

struct foo {
        int req;
        long long id;
        int abc;
};

int main(void) { return printf("%d\n", sizeof(struct foo)); }

On ia64, this prints 24; on i386 it prints 16.

You could declare it __attribute__((packed)) or you could reorder the elements in the struct to put the largest elements first.

Signature · 6 lines
"Next the statesmen will invent cheap lies, putting the blame upon 
the nation that is attacked, and every man will be glad of those
conscience-soothing falsities, and will diligently study them, and refuse
to examine any refutations of them; and thus he will by and by convince 
himself that the war is just, and will thank God for the better sleep 
he enjoys after this process of grotesque self-deception." -- Mark Twain
#1 lore raw

hi,

I am seeing this weird problem when I am trying
to pass on some data from a 64bit application to
a 32bit application via shared memory.

The information which is held in the shared memory is interpreted as in the structure
typedef struct shmtest

{
        int req;
        long long id;
        int abc;
}shmtest_t;

The 64 bit application fills in {1,5,5} in the shared memory and when I access these values from a 32 bit application I get it as {1,21474836480,0}. I guess this is due to switch of lower and upper significant bytes. Strangely when the 64bit application fills in {2,69472139471924,6} the value read by the 32bit application would be {2,4481622812292808704,16175}.

Could somebody tell me whether I need to do something different to handle shared memory b/w 32-64bit applications..or am I missing out some thing basic.

Kernel version: 2.4.21-4.EL

TIA
-Chinmaya

PS: Please point me to the right group if this question does not belong here.

#2 lore raw
In reply to Matthew Wilcox
Quoted 3 lines · CHINMAYA TM (STSD)

The 64 bit application fills in {1,5,5} in the shared memory and when I access these values from a 32 bit application I get it as {1,21474836480,0}.

Besides the different padding rules mentioned by willy, I'd advise debugging with with hex output instead of decimal. It makes it very obvious which bits are going where.

And do some experiments with filling in the fields with known values and then dumping the entire struct as a byte array.

grant

#3 lore raw
In reply to Matthew Wilcox
Quoted 10 lines · Matthew Wilcox

Nope. You're being bitten by different struct padding rules.

#include <stdio.h>

struct foo {
       int req;
       long long id;
       int abc;
};
Quoted 6 lines

int main(void) { return printf("%d\n", sizeof(struct foo)); }

On ia64, this prints 24; on i386 it prints 16.

You could declare it __attribute__((packed)) or you could reorder the elements in the struct to put the largest elements first.

Or compile i386 code with -malign-double which will align i386 long long values on 8 byte boundaries, the same as ia64.