Linux进程通讯之一：共享内存

应用级代码说话。操作共享内存，就和操作已知的内存一样（可以想象直接读写一个可知的结构体）。

本demo参考了lgui中内存共享的代码。在lgui中，画笔/画板之类需要全局共用的都放在共享区。

在共享区内，每个结构体有自己的index方便读写。

demo分为server/client，直接在Linux下运行即可。

1 共同的代码

   semaphore.h

#ifndef __SEMAPHORE_H__
#define __SEMAPHORE_H__

#include <sys/sem.h>

#ifdef __cplusplus
extern "C" {
#endif

union semun{
int val;
struct semid_ds* buf;
unsigned short int *array;
};

int  sem_create(key_t sem_id);
void sem_lock(int sem_set_id);
void sem_unlock(int sem_set_id);
void sem_remove(int sem_set_id);

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif

semaphore.cpp

#include <sys/types.h>
#include "semaphore.h"

//create semaphore

int sem_create(key_t sem_id)
{
union semun sem_val;
int sem_set_id;
int rc;
sem_set_id=semget(sem_id,1,IPC_CREAT | 0600);
if(sem_set_id==-1)
{
return -1;
}
sem_val.val=1;
rc=semctl(sem_set_id,0,SETVAL,sem_val);
if(rc==-1)
{
return -1;
}
else
{
return sem_set_id;
}
}

//Lock
void sem_lock(int sem_set_id)
{
struct sembuf sem_op;
sem_op.sem_num	=0;
sem_op.sem_op	=-1;
sem_op.sem_flg	=0;
semop(sem_set_id,&sem_op,1);
}

//unlock
void sem_unlock(int sem_set_id)
{
struct sembuf sem_op;
sem_op.sem_num	=0;
sem_op.sem_op	=1;
sem_op.sem_flg	=0;
semop(sem_set_id,&sem_op,1);
}

//destroy
void sem_remove(int sem_set_id)
{
semctl(sem_set_id,0,IPC_RMID);
}

shmem.h

#ifndef __SHMEM_H__
#define __SHMEM_H__

#ifdef __cplusplus
extern "C" {
#endif

#define SHMEM_SIZE					1024*1024
#define	SHMEM_CGI_SIZE				4*1024
//index 4k
#define SHMEM_CGI_OFFSET_INDEX		0

#define SHMEM_CGI_OFFSET_0			SHMEM_CGI_SIZE
#define SHMEM_CGI_OFFSET_1			SHMEM_CGI_SIZE + SHMEM_CGI_SIZE

//cgi为client
#define SHMEM_SERVER	1
#define SHMEM_CLIENT	0
#define SHMEM_CS		SHMEM_SERVER

typedef int 			BOOL;
typedef void			*PVOID,*LPVOID;
typedef PVOID			HVODIOBJ;
typedef PVOID			HCGI;

typedef struct _CgiCmdTag
{
int   cmdindex;
int   cmd0;
int   cmd1;
int   cmd2;
int   cmd3;
int   cmdsize;
char  cmdname[20];
}CgiCmdTag,*pCgiCmdTag;

BOOL InitShareMemServer();
BOOL InitShareMemClient();

void UnInitShareMem(int cs);

int shm_read(char* pDest, int iOffset, int iLen);
int shm_write(char* pSource, int iOffset, int iLen);

char* GetShmAddr();
void LockShMem();
void UnLockShMem();

#ifdef __cplusplus
}

#endif /* __cplusplus */
#endif

shmem.cpp

#include "semaphore.h"
#include "shmem.h"
#include <stdlib.h>
#include <malloc.h>
#include <string.h>
#include <sys/shm.h>

#define	SEM_ID		250

#define SHMEM_ID	100
//#define SHMEM_FLAG	IPC_CREAT | 0600
#define SHMEM_FLAG	IPC_CREAT | 0666

int sem_set_id;
int shm_id;
char* pShmCgi;

char* GetShmAddr()
{
return pShmCgi;
}

int shm_read(char* pDest, int iOffset, int iLen)
{
memcpy(pDest,pShmCgi+iOffset,iLen);
return 0;
}

int shm_write(char* pSource, int iOffset, int iLen)
{
memcpy(pShmCgi+iOffset,pSource,iLen);
return 0;
}

BOOL InitShareMemServer()
{
struct shmid_ds shm_desc;

sem_set_id=sem_create(SEM_ID);
if(sem_set_id == -1)
{
return false;
}

shm_id = shmget(SHMEM_ID,SHMEM_SIZE,SHMEM_FLAG);
if(shm_id == -1)
{
sem_remove(sem_set_id);
return false;
}
pShmCgi = (char*)shmat(shm_id,NULL,0);
if(!pShmCgi)
{
sem_remove(sem_set_id);
shmctl(shm_id,IPC_RMID,&shm_desc);
return false;
}
return true;

}

BOOL InitShareMemClient()
{
struct shmid_ds shm_desc;

shm_id = shmget(SHMEM_ID,SHMEM_SIZE,SHMEM_FLAG);
if(shm_id == -1)
{
sem_remove(sem_set_id);
return false;
}
pShmCgi = (char*)shmat(shm_id,NULL,0);
if(!pShmCgi)
{
sem_remove(sem_set_id);
shmctl(shm_id,IPC_RMID,&shm_desc);
return false;
}
return true;
}

void UnInitShareMem(int cs)
{
struct shmid_ds shm_desc;
if(cs)
{
sem_remove(sem_set_id);
shmdt(pShmCgi);
shmctl(shm_id,IPC_RMID,&shm_desc);
}
else
{
shmdt(pShmCgi);
}

}

void LockShMem()
{
sem_lock(sem_set_id);
}

void UnLockShMem()
{
sem_unlock(sem_set_id);
}

2 client端

//cgi client
#include <string.h>
#include <unistd.h>
#include <stdio.h>
#include <malloc.h>
#include "semaphore.h"
#include "shmem.h"

//g++ cgibin_client.cpp semaphore.cpp shmem.cpp -o client.bin

//HCGI :CreateCgiObject()中的shm可能存储不同的数据结构
HCGI GetCgiObject(int index)
{
int CgiOffset;
int CgiIndex;
char *pname;
char* pShmAddr;
CgiCmdTag *pCgiCmd;

pShmAddr = GetShmAddr();
if(!pShmAddr)
{
return NULL;
}

CgiOffset = *(((int*)(pShmAddr+SHMEM_CGI_OFFSET_INDEX))+index);
//get cgi index
shm_read((char*)(&CgiIndex),CgiOffset,sizeof(int));
pCgiCmd = (CgiCmdTag*)malloc(sizeof(CgiCmdTag));

if(!pCgiCmd)
{
return NULL;
}
shm_read((char*)pCgiCmd,CgiOffset,sizeof(CgiCmdTag));

return (HCGI)pCgiCmd;
}

int main(int argc, char **argv)
{

CgiCmdTag *pCgiCmd = NULL;
InitShareMemClient();
while(1)
{
for(int i=0;i<2;i++)
{
pCgiCmd = (CgiCmdTag*)GetCgiObject(i);
printf("cgicmd[%d]:\n",i);
printf("cmdindex :0x%04x\n",pCgiCmd->cmdindex);
printf("cmd0     :0x%04x\n",pCgiCmd->cmd0);
printf("cmd1     :0x%04x\n",pCgiCmd->cmd1);
printf("cmd2     :0x%04x\n",pCgiCmd->cmd2);
printf("cmd3     :0x%04x\n",pCgiCmd->cmd3);
printf("cmdsize  :0x%04x\n",pCgiCmd->cmdsize);
printf("cmdname  :%s\n",pCgiCmd->cmdname);
printf("cgicmd[%d] print ok:\n\n",i);
sleep(1);
}
}
UnInitShareMem(SHMEM_CLIENT);
printf( "UnInitShareMem ok\n" );
return 0;
}

3 server端

//cgi server
#include <string.h>
#include <unistd.h>
#include <stdio.h>
#include <malloc.h>
#include "semaphore.h"
#include "shmem.h"

//g++ cgibin_server.cpp semaphore.cpp shmem.cpp -o server.bin

BOOL CreateCgiObject()
{
char* pShmAddr;
int*  pIdxAddr;
int   CgiOffset;
CgiCmdTag CgiCmd0;
CgiCmdTag CgiCmd1;

pShmAddr = GetShmAddr();
if(!pShmAddr)
{
return false;
}
pIdxAddr  = (int*)(pShmAddr+SHMEM_CGI_OFFSET_INDEX);

//CgiCmd0
CgiOffset = SHMEM_CGI_OFFSET_0;
CgiCmd0.cmdindex = 0x0000;
CgiCmd0.cmd0 	 = 0x8000;
CgiCmd0.cmd1 	 = 0x8001;
CgiCmd0.cmd2 	 = 0x8002;
CgiCmd0.cmd3 	 = 0x8003;
CgiCmd0.cmdsize  = 0x8004;
memcpy(CgiCmd0.cmdname,"CgiCmd0",sizeof(CgiCmd0.cmdname));
memcpy((void*)(pShmAddr+CgiOffset),&CgiCmd0,sizeof(CgiCmd0));

*(pIdxAddr+CgiCmd0.cmdindex) = CgiOffset;

//CgiCmd1
CgiOffset = SHMEM_CGI_OFFSET_1;
CgiCmd1.cmdindex = 0x0001;
CgiCmd1.cmd0 	 = 0x9000;
CgiCmd1.cmd1 	 = 0x9001;
CgiCmd1.cmd2 	 = 0x9002;
CgiCmd1.cmd3 	 = 0x9003;
CgiCmd1.cmdsize  = 0x9004;
memcpy(CgiCmd1.cmdname,"CgiCmd1",sizeof(CgiCmd0.cmdname));
memcpy((void*)(pShmAddr+CgiOffset),&CgiCmd1,sizeof(CgiCmd1));

*(pIdxAddr+CgiCmd1.cmdindex) = CgiOffset;
CgiOffset = CgiOffset + SHMEM_CGI_SIZE;

return true;
}

//HCGI :CreateCgiObject()中的shm可能存储不同的数据结构
HCGI GetCgiObject(int index)
{
int CgiOffset;
int CgiIndex;
char *pname;
char* pShmAddr;
CgiCmdTag *pCgiCmd;

pShmAddr = GetShmAddr();
if(!pShmAddr)
{
return NULL;
}

CgiOffset = *(((int*)(pShmAddr+SHMEM_CGI_OFFSET_INDEX))+index);
//get cgi index
shm_read((char*)(&CgiIndex),CgiOffset,sizeof(int));
pCgiCmd = (CgiCmdTag*)malloc(sizeof(CgiCmdTag));

if(!pCgiCmd)
{
return NULL;
}
shm_read((char*)pCgiCmd,CgiOffset,sizeof(CgiCmdTag));

return (HCGI)pCgiCmd;
}

int SetCgiObject(int index)
{
CgiCmdTag *pCgiCmd = NULL;
pCgiCmd = (CgiCmdTag*)GetCgiObject(index);

char* pShmAddr;
pShmAddr = GetShmAddr();
if(index==0)
{
pCgiCmd->cmdindex = 0;
pCgiCmd->cmd0 = 0xa000;
pCgiCmd->cmd1 = 0xa001;
pCgiCmd->cmd2 = 0xa002;
pCgiCmd->cmd3 = 0xa003;
//pCgiCmd->cmdsize = 0xa000 + 1<<(index+1)+4;
shm_write((char*)pCgiCmd,SHMEM_CGI_OFFSET_0,sizeof(CgiCmdTag));
}

if(index==1)
{
pCgiCmd->cmdindex = 1;
pCgiCmd->cmd0 = 0xb000;
pCgiCmd->cmd1 = 0xb001;
pCgiCmd->cmd2 = 0xb002;
pCgiCmd->cmd3 = 0xb003;
//pCgiCmd->cmdsize = 0xb000 + 1<<(index+1)+4;
memcpy(pCgiCmd->cmdname,"CgiCmd1_Modify",sizeof(pCgiCmd->cmdname));
shm_write((char*)pCgiCmd,SHMEM_CGI_OFFSET_1,sizeof(CgiCmdTag));
}
}

int main(int argc, char **argv)
{
InitShareMemServer();
CreateCgiObject();
printf("CreateCgiObject ok\n");

sleep(10);

SetCgiObject(0);
SetCgiObject(1);
printf("SetCgiObject ok\n");

sleep(20);
UnInitShareMem(SHMEM_SERVER);
printf( "UnInitShareMem ok\n" );
return 0;
}