C++博客-键盘上的舞者-随笔分类-Linux

system V IPC —— 共享内存(下)

Marcky — Thu, 20 Aug 2009 06:57:00 GMT

使用共享内存和记录锁实例。本例中，父进程创建一段共享内存，然后向其中追加字符串"Parent"(在写入“Parent”的时候，采用一个字符一个字符的写入，目的是为了验证记录锁对父子进程同步的正确性)；子进程向共享内存中追加字符串“Child”（同样是一个一个的字符写入）。由于记录锁是针对文件的，所以得先创建一个空文件作为记录锁的操作对象，作为共享内存访问的辅助工具，如果一个进程对这个空文件加写锁成功后，就开始访问共享内存，访问结束就对文件解锁。

代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

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

#include <sys/wait.h>
#include <fcntl.h>

#include <sys/ipc.h>
#include <sys/shm.h>

#define SHM_SIZE 1024            /* shared memory size(bytes) */
#define SHM_MODE 0600            /* user read/write */

#define WRITE_LOCK(fd) regLock((fd), F_SETLKW, F_WRLCK, 0, SEEK_SET, 0)
#define UN_LOCK(fd) regLock((fd), F_SETLK, F_UNLCK, 0, SEEK_SET, 0)
/* 创建一个文件 */
int createFile()
{
    int fd;

    if ( (fd = open("/tmp/emptyfile4shm", O_RDWR | O_CREAT, 0666)) < 0) {
        fprintf(stderr, "Create a empty file failed!\n");
        exit(EXIT_FAILURE);
    }

    return fd;
}
/* 在文件fd上加锁或解锁*/
int regLock(int fd, int cmd, int type, off_t offset, int whence, off_t len)
{
    struct flock lock;

    lock.l_type = type;         /* lock type: F_RDLCK, F_WRLCK, F_UNLCK */
    lock.l_start = offset;      /* byte offset relative to l_whence */
    lock.l_whence = whence;    /* it's value : SEEK_SET, SEEK_CUR, SEEK_END */
    lock.l_len = len;           /* bytes (0 means to EOF) */

    return fcntl(fd, cmd, &lock);
}

int main(void)
{
    int shmid;
    int filed;
    pid_t pid;
    char *shmptr = NULL;

    filed = createFile();

    if ( (shmid = shmget(IPC_PRIVATE, SHM_SIZE, SHM_MODE)) < 0) { /* Create shared memory */
        fprintf(stderr, "Create shared memory failed!\n");
        exit(EXIT_FAILURE);
    }

    if ( (pid = fork()) < 0) {  /* Create a child process */
        fprintf(stderr, "Create child process failed!\n");
        exit(EXIT_FAILURE);
    }

    if (pid == 0) {             /* In child process */
        if ( (shmptr = shmat(shmid, 0, 0)) == (void *)-1) {
            fprintf(stderr, "Attached shared memory failed!\n");
            exit(EXIT_FAILURE);
        }
        while (1) {
            WRITE_LOCK(filed);  /* add a write lock to filed */
            /* shared memory 剩余的空间不能存储"Child"字符串和结束符0时就退出循环 */
            if (SHM_SIZE - strlen(shmptr) < strlen("Child") + 1) break;
            strcat(shmptr, "C"); /* 由于加了锁，每个Child将会连续出现 */
            strcat(shmptr, "h");
            strcat(shmptr, "i");
            strcat(shmptr, "l");
            strcat(shmptr, "d");
            UN_LOCK(filed);     /* release lock */
        }
        printf("child process:\n\t%s\n", shmptr); /* child process print shared memory */

        exit(0);
    }

    /* In parent process */
    if ( (shmptr = shmat(shmid, 0, 0)) == (void *)-1) { /* Attached shared memory */
        fprintf(stderr, "Attached shared memory failed!\n");
        exit(EXIT_FAILURE);
    }

    while (1) {
        WRITE_LOCK(filed);
        /* shared memory 剩余的空间不能存储"Parent"字符串和结束符0时就退出循环 */
        if (SHM_SIZE - strlen(shmptr) < strlen("Parent") + 1) break;
        strcat(shmptr, "P");/* 由于加了锁，每个Parent将会连续出现 */
        strcat(shmptr, "a");
        strcat(shmptr, "r");
        strcat(shmptr, "e");
        strcat(shmptr, "n");
        strcat(shmptr, "t");
        UN_LOCK(filed);
    }
    printf("parent process:\n\t%s\n", shmptr); /* parent print shared memory */

    wait(0);
    exit(0);
}

Marcky 2009-08-20 14:57 发表评论

system V IPC —— 共享内存(上)

Marcky — Thu, 20 Aug 2009 06:48:00 GMT

共享内存允许多个进程共享一给定的存储区。因为数据不需要在两个进程之间进行copy，所以这是最快的一种IPC。使用共享内存技术的时候，需要掌握好的是多个进程之间如何同步。信号量和记录锁可以用来实现共享内存的多个进程之间的同步。

linux内核定义的shared memory结构shmid_ds如下：

struct shmid_ds {
    struct ipc_perm  shm_perm;  /*权限*/
    size_t           shm_segsz; /*大小*/
    pid_t            shm_lpid;
    pid_t            shm_cpid;  /*创建者pid*/
    shmatt_t         shm_nattch;/*连接到此段内存的进程数*/
    time_t           shm_atime;
    time_t           shm_dtime;
    time_t           shm_ctime;

};

1、创建或使用一段共享内存使用shmget函数，此函数将返回共享内存标示符。

#include <sys/shm.h>
int shmget(key_t key, size_t size, int flag);

如果key取值为IPC_PRIVATE或者key当前为和特定类型的IPC结构相结合，并且flag指定了IPC_CREAT位，则创建一个新的share memory结构。
size为共享内存段的长度（字节）。

2、对一个共享内存段进行操作使用shmctl。

#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);

shmid指定需要操作的shared memory
cmd指定需要进行的操作
       IPC_STAT取得此段的shmid_ds结构放入buf中。
       IPC_SET用buf的值设置此段中的：shm_perm.uid，shm_perm.gid，shm_perm.mode。
       IPC_RMID从系统中删除此共享内存段。
       SHM_LOCK将共享内存锁定到内存中。
       SHM_UNLOCK解锁共享内存段。

3、将一个共享内存段连接到自己的地址空间使用shmat：

#include <sys/shm.h>
void *shmat(int shmid, const void *addr, int flag);

推荐addr取0值，将此段连接到内核选择的第一个可用的地址上。增加程序的可移植性。

4、对共享内存操作结束后，要脱离该段用shmdt：

#include <sys/shm.h>
int shmdt(void *addr);

addr是shmat的返回值。

Marcky 2009-08-20 14:48 发表评论

Linux命令:(){ :|:& };:分析

Marcky — Tue, 30 Jun 2009 08:46:00 GMT

摘要: 有人说:(){ :|:& };: 命令就是一个系统炸弹。在linux的shell里执行此命令将会不停的创建新的进程，直到系统挂掉为止。刚看到这个怪七怪八的命令，也是完全不知所云，在水木高手解释后，总算是明白了。阅读全文

Marcky 2009-06-30 16:46 发表评论