/* 
 Author: Andrew Huang <bluedru@163.com> 
*/ 
#include <unistd.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
#include <signal.h> 
#include <sys/mman.h> /* for mmap,shm_open */ 
#include <string.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <errno.h> 
 
#define PRINT_INTX(e) printf("%s=0x%X\n",#e,e) 
 
typedef struct mmap_fd{ 
   int fd; /* 打开后的文件描述符*/ 
   void * base; /* 在进程内部的地址*/ 
   char * name; /* 共享内存名字 */ 
   int len ; /* 共享内存长度 */ 
   int offset; /* fd中的偏移量*/ 
}MMAP_FD; 
 
#define MMAP_ADDR(p) (p)->base 
 
MMAP_FD * shm_map(char * name,int len,int offset) 
{ 
   MMAP_FD * p_fd; 
   void * base; 
   int fd; 
  //第一步：创建一个共享内存 
   fd = shm_open(name,O_CREAT|O_EXCL|O_RDWR,666); 
   if(fd == -1) 
   { 
      if(errno == EEXIST 
      { 
         fd = shm_open(name,O_RDWR,666); 
      } 
   } 
   if(fd == -1) 
   { 
     perror("shm_open"); 
     return NULL; 
   } 
 
    //第二步：设置内存大小 
    if(ftruncate(fd,len) == -1) 
    { 
      perror("ftruncate"); 
      shm_unlink(name); 
      return NULL; 
    } 
    //第三步，将内核中共享内存映射到进程空间之上 
//void *mmap(void *start, size_t length, int prot, int flags, 
// int fd, off_t offset); 
    base = mmap(NULL,len,PROT_READ | PROT_WRITE, MAP_SHARED ,fd,offset); 
    if(base == MAP_FAILED) 
    { 
      perror("mmap"); 
      shm_unlink(name); 
      return NULL; 
     } 
     p_fd = malloc(sizeof(MMAP_FD)); 
     p_fd->len = len; 
     p_fd->name = strdup(name); 
     p_fd->fd = fd; 
     p_fd->base = base; 
     p_fd->offset = offset; 
  return p_fd; 
} 
 
int shm_destroy(MMAP_FD * p_fd) 
{ 
   if(p_fd == NULL) 
      return -1; 
   //取消映射 
   if(munmap(p_fd->base,p_fd->len) == -1) 
   { 
     perror("munmap"); 
     return -1; 
   } 
 
   //删除共享内存 
   if(shm_unlink(p_fd->name) == -1) 
   { 
     perror("shm_unlink"); 
     return -2; 
   } 
 
   free(p_fd->name); 
   free(p_fd); 
   return 0; 
} 
 
#define SHM_NAME "test_mmap" 
 
MMAP_FD * p_fd = NULL; 
 
void exit_handler(int sig) 
{ 
   printf("EXIT HANDLER\n"); 
   shm_destroy(p_fd); 
   exit(0); 
} 
 
//创建进程，用于写数据 
void write_proc() 
{ 
   char ary[10]; 
   char * p ; 
   static int count = 1; 
 
   printf("WRITE SHM\n"); 
 
   signal(SIGINT,exit_handler); 
   signal(SIGTERM,exit_handler); 
 
   p_fd = shm_map(SHM_NAME,100,0); 
   if(p_fd == NULL) 
         return ; 
 
    p= malloc(10); 
 
 
//注意各种变量地址,ary空间是栈，p是堆的，p_fd->base是内存映射地址 
   PRINT_INTX(ary); 
   PRINT_INTX(MMAP_ADDR(p_fd)); 
 
   PRINT_INTX(p); 
 
   free(p); 
 
   while(1) 
    { 
      snprintf(MMAP_ADDR(p_fd),p_fd->len,"mmap write %d\n",count++); 
      sleep(1); 
    } 
} 
 
void read_proc() 
{ 
   signal(SIGINT,exit_handler); 
   signal(SIGTERM,exit_handler); 
 
   printf("READ SHM\n"); 
 
   p_fd = shm_map(SHM_NAME,100,0); 
   if(p_fd == NULL) 
         return ; 
 
   while(1) 
    { 
      printf(MMAP_ADDR(p_fd)); 
      sleep(1); 
    } 
} 
 
int main(int argc,char * argv[]) 
{ 
   if((argc>1) && (argv[1][0] == 'r')) 
       read_proc(); 
   else 
       write_proc(); 
}