Programming

i have to shared a variable between two different c programs with shared memory and i do these:

Code:

int main() {
    int a=5,b=7;
    int buffer[1];
    int *point;
    int shmid;
    shmid=shmget(IPC_PRIVATE , sizeof(buffer[1]),0666);
    point=(int *)shmat(shmid,NULL,0);
    point[0]=a;
    point[1]=b;
    printf("FIRST = %d\nSECOND = %d",point[0],point[1]);
    fflush(stdout);
    sleep(300);
    shmdt(point);
    exit(0);
}

the other is :

Code:

int main(){
    int buffer[1];
    int *point;
    int shmid;
    shmid=shmget(IPC_PRIVATE,sizeof(buffer[1]),0666);
    point=(int *)shmat(shmid,NULL,0);
    printf("first number =%d\nsecond number =%d\n",point[0],point[1]);
    fflush(stdout);
    shmdt(point);
    exit(0);
}

but if i execute the first and after the second, i don't have 5 on first number and 7 on second but both zero. why?
maybe i have to use a key to identify shared memory and not IPC_PRIVATE? ( i also must use semaphores but it's only begin of this program )

Yes, you either need a key or to pass the segment's ID. IPC_PRIVATE is meant to be used between two programs that can pass the ID, either because one forked the other and the ID is resident, or because they passed it in some other way. So, in IPC_PRIVATE world, you'd shmget in one and then pass the shmid to the other to shmat.

If you use the command "ipcs -m" you'll see all the shared memory segments. The KEY for IPC_PRIVATE (usually) is 0xffffffff, but you'll see a bunch of them. Each time you run this program you'll be creating another one. The ID for each will be different. Ultimately, it's the ID that determines which segment you attach to.

Think of shmget as a way to both create and lookup that ID. If you don't pass the same ID to each shmat call, you won't be looking at the same segment. Make sense?

Also, you probably mean sizeof(buffer) not sizeof(buffer[1]). The first will insure the segment can store the whole array, your way provides the segment only enough space to hold one element. Of course, this will cause an overflow.

edit: P.S. since you're never asking the shared memory segment be removed, it'll linger forever. You'll want to use ipcrm to get rid of it. Of course, you could also shmctl with the IPC_RMID command to ask it be removed. It'll hang around until all applications currently attached to it have detached. The kernel will detach the application when it is killed as well, so while it's good practice to shmdt, if you application dies in the middle the kernel will do it. Of course, on some O/Ses I've seen that fail and segments get "stuck" and the dumb machine needs a reboot to clean them up, lol.

You can avoid IPC issues by using mmap instead. It can map memory from a file, allowing you to access the same data into two processes' memory:

Code:

#include <sys/types.h>
#include <sys/mman.h>
#include <unistd.h>
#include <fcntl.h>

int main(void)
{
        int *mem;
        int fd=open("datafile", O_RDWR);
        if(fd < 0)
        {
                perror("couldn't open");
                return(1);
        }


        ftruncate(fd, getpagesize());  // make file long enough
        mem=mmap(NULL, getpagesize(), PROT_READ|PROT_WRITE, 
                MAP_SHARED, fd, 0);

        if(mem == MAP_FAILED)
        {
                 perror("Couldn't mmap");
                 return(1);
        }

        mem[0]=0xdeadbeef; // Should appear in file and other process
        munmap(mem, getpagesize());
        close(fd);
        return(0);
}

thanks a lot for your exhaustive answer, i will try soon

---------- Post updated at 05:06 PM ---------- Previous update was at 04:26 PM ----------

so, for example i have to declare :

Code:

key_t shmkey=0x200;

and then use that for shmget in both programs?

You're welcome.
That will work, there is also the ftok function. I've seen hard-coded keys and ftok used, more often the former (don't know why, really). Another method I've seen is a hard-coded base with a xor'd in integer from the environment. I suppose for a toy application, it doesn't much matter. For something more production quality, you should probably at the very least insure that the key is configurable so that it can't conflict with any other potentially running application.

if i use

Code:

key_t shmkey=0x200;

it doesn't work, it gives segmentation fault and also if i use ftok function...
maybe i'm wrong to use ftok(), which type of file i use in path argument?

It shouldn't segmentation fault even if you give it a wrong token. It sounds like you forgot to do any error checking.

Please post your program. We can't see your computer from here.