C 共享内存和信号量：意外的分段错误

我正在尝试创建两个节目，由一个制作人和一个消费者组成。生产者生成从0到9的一定数量的随机数，并将其存储在共享内存中的循环队列中，然后消费者从共享内存读取队列，并打印从0到9的每个数字的频率

制片人没有给我一个错误。然而，当我试图运行消费者时，程序立即给出了一个分段错误。我希望有人能发现哪里出了问题。我还想知道是否有任何方法可以检查dev/shm目录，以验证我尝试创建的共享内存文件是否正常工作？谢谢

制作人

#include <fcntl.h>
#include <math.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <semaphore.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
#include "cola_circular.c"

#define SHM_NAME "/shm_eje4"
#define QUEUE_SIZE 10

typedef struct {
    circular_queue queue;
    sem_t sem_mutex;
} ShmStruct;

int main(int argc, char *argv[]) {
    int fd_shm;
    int i;
    pid_t ppid = 0;
    pid_t pid = 0;
    ShmStruct *input;

    if (argc < 3) {
        fprintf(stderr,"usage: %s <n_numbers> <generation_method>", argv[0]);
        return EXIT_FAILURE;
    } else {
        if (atoi(argv[1]) < 0) {
            fprintf(stderr,"<n_numbers> has to be greater than or equal to 0");
            return EXIT_FAILURE;
        }
        if (atoi(argv[2]) < 0 || atoi(argv[2]) > 1) {
            fprintf(stderr,"<generation_method>: 0 for random, 1 for sequential");
            return EXIT_FAILURE;
        }
    }

    /* Crear memoria compartida para la cola, semafaros */
    fd_shm = shm_open(SHM_NAME,
         O_RDWR | O_CREAT | O_EXCL,
          S_IRUSR | S_IWUSR);
    if  (fd_shm == -1) {
        fprintf(stderr, "Error creating the shared memory segments");
        shm_unlink(SHM_NAME);
        return EXIT_FAILURE;
    }

    /* Cambiar el tamaño del segmento de memoria */
    if (ftruncate(fd_shm, sizeof(ShmStruct)) == -1) {
        fprintf(stderr, "Error resizing the shared memory segment\n");
        shm_unlink(SHM_NAME);
        close(fd_shm);
        return EXIT_FAILURE;
    }

    /* Mapear el segmento de memoria */
    input = mmap(NULL,
         sizeof(*input),
         PROT_READ | PROT_WRITE, MAP_SHARED,
         fd_shm,
         0);
    close(fd_shm);
    if (input == MAP_FAILED) {
        fprintf(stderr, "Error mapping the shared memory segment\n");
        shm_unlink(SHM_NAME);
        close(fd_shm);
        return EXIT_FAILURE;
    }

    if (sem_init(&(input->sem_mutex),1,1) < 0) {
        fprintf(stderr, "Error initializing mutex semaphore\n");
        perror("sem_init");
        return EXIT_FAILURE;
    }
    input->queue = queue_ini(QUEUE_SIZE);

    /*Generamos N numeros aleatorios/secuencia entre 0 y 9*/
    sem_wait(&(input->sem_mutex));
    if (argv[2] == 0) {
        for (i=0; i<atoi(argv[1]); i++) {
            insert_queue(input->queue, rand()%10);
        }
    } else if (atoi(argv[2]) == 1) {
        for (i=0; i<atoi(argv[1]); i++) {
            insert_queue(input->queue, i%10);
        }
    }
    sem_post(&(input->sem_mutex));

    /*El programa espera un caracter mientras ejecutamos el hijo*/
    getchar();

    sem_destroy(&(input->sem_mutex));
    munmap(input, sizeof(*input));
    shm_unlink(SHM_NAME);
    close(fd_shm);
    return EXIT_SUCCESS;
} 

 #include <errno.h>
 #include <fcntl.h>
 #include <math.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <semaphore.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <time.h>
 #include <unistd.h>
 #include "cola_circular.c"

 #define SHM_NAME "/shm_eje4"

 typedef struct {
     circular_queue queue;
     sem_t sem_mutex;
 } ShmStruct;

 int  main(void) {
     fprintf(stdout, "1");
     int i;
     int count[10];
     int fd_shm = shm_open(SHM_NAME,
        O_RDONLY,
        0);
    if (fd_shm == -1) {
        fprintf(stderr, "Error opening the shared memory segment\n");
        return EXIT_FAILURE;
    }

    ShmStruct *output = mmap(NULL,
        sizeof(*output),
        PROT_READ,
        MAP_SHARED,
        fd_shm,
        0);
    close(fd_shm);
    if (output == MAP_FAILED) {
        fprintf(stderr, "Error mapping the shared memory segment\n");
        return EXIT_FAILURE;
    }

    sem_wait(&(output->sem_mutex));
    for (i=0; i<10; i++) {
        count[i] = 0;
    }
    for (i=0; i<output->queue.num; i++) {
        count[output->queue.queue[i]]++;
    }
    fprintf(stdout, "Histograma de numeros de queue:\n");
    for  (i=0; i<10; i++) {
        fprintf(stdout, "%d ---> %d\n", i, count[i]);
    }
    sem_post(&(output->sem_mutex));

    munmap(output, sizeof(*output));
    close(fd_shm);
    return EXIT_SUCCESS;
 }

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括“cola_circular.c”
#定义SHM_名称“/SHM_eje4”
#定义队列大小为10
类型定义结构{
循环队列；
sem_t sem_互斥体；
}ShmStruct；
int main（int argc，char*argv[]）{
int fd_shm；
int i；
pid_t ppid=0；
pid_t pid=0；
ShmStruct*输入；
如果（argc<3）{
fprintf（stderr，“用法：%s”，argv[0]）；
返回退出失败；
}否则{
if（atoi（argv[1]）<0）{
fprintf（标准“必须大于或等于0”）；
返回退出失败；
}
if（atoi（argv[2]）<0 | | atoi（argv[2]）>1）{
fprintf（stderr，“：0表示随机，1表示顺序”）；
返回退出失败；
}
}
/*塞马法罗斯可乐公司*/
fd_shm=shm_打开（shm_名称，
O|RDWR | O|u CREAT | O|u EXCL，
S|u IRUSR | S|u IWUSR）；
如果（fd_shm==-1）{
fprintf（stderr，“创建共享内存段时出错”）；
shm_取消链接（shm_名称）；
返回退出失败；
}
/*坎比亚埃尔塔马诺纪念节酒店*/
如果（ftruncate（fd_shm，sizeof（ShmStruct））=-1）{
fprintf（stderr，“调整共享内存段大小时出错\n”）；
shm_取消链接（shm_名称）；
关闭（fd_shm）；
返回退出失败；
}
/*记忆片段地图*/
输入=mmap（空，
sizeof（*输入），
保护读取、保护写入、地图共享、，
孙明扬，
0);
关闭（fd_shm）；
如果（输入==映射_失败）{
fprintf（stderr，“映射共享内存段时出错\n”）；
shm_取消链接（shm_名称）；
关闭（fd_shm）；
返回退出失败；
}
if（sem_init（&（input->sem_mutex），1,1）<0）{
fprintf（stderr，“初始化互斥信号量时出错\n”）；
perror（“sem_init”）；
返回退出失败；
}
输入->队列=队列ini（队列大小）；
/*第0和第9届中央选举委员会委员长*/
sem_wait（&（输入->sem_互斥体））；
如果（argv[2]==0）{
对于（i=0；iqueue，rand（）%10）；
}
}else if（atoi（argv[2]）==1）{
对于（i=0；iqueue，i%10）；
}
}
sem_post（&（输入->sem_互斥体））；
/*这是一个非常重要的项目*/
getchar（）；
sem_destroy（&（输入->sem_互斥体））；
munmap（输入，sizeof（*输入））；
shm_取消链接（shm_名称）；
关闭（fd_shm）；
返回退出成功；
} 

消费者

#include <fcntl.h>
#include <math.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <semaphore.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
#include "cola_circular.c"

#define SHM_NAME "/shm_eje4"
#define QUEUE_SIZE 10

typedef struct {
    circular_queue queue;
    sem_t sem_mutex;
} ShmStruct;

int main(int argc, char *argv[]) {
    int fd_shm;
    int i;
    pid_t ppid = 0;
    pid_t pid = 0;
    ShmStruct *input;

    if (argc < 3) {
        fprintf(stderr,"usage: %s <n_numbers> <generation_method>", argv[0]);
        return EXIT_FAILURE;
    } else {
        if (atoi(argv[1]) < 0) {
            fprintf(stderr,"<n_numbers> has to be greater than or equal to 0");
            return EXIT_FAILURE;
        }
        if (atoi(argv[2]) < 0 || atoi(argv[2]) > 1) {
            fprintf(stderr,"<generation_method>: 0 for random, 1 for sequential");
            return EXIT_FAILURE;
        }
    }

    /* Crear memoria compartida para la cola, semafaros */
    fd_shm = shm_open(SHM_NAME,
         O_RDWR | O_CREAT | O_EXCL,
          S_IRUSR | S_IWUSR);
    if  (fd_shm == -1) {
        fprintf(stderr, "Error creating the shared memory segments");
        shm_unlink(SHM_NAME);
        return EXIT_FAILURE;
    }

    /* Cambiar el tamaño del segmento de memoria */
    if (ftruncate(fd_shm, sizeof(ShmStruct)) == -1) {
        fprintf(stderr, "Error resizing the shared memory segment\n");
        shm_unlink(SHM_NAME);
        close(fd_shm);
        return EXIT_FAILURE;
    }

    /* Mapear el segmento de memoria */
    input = mmap(NULL,
         sizeof(*input),
         PROT_READ | PROT_WRITE, MAP_SHARED,
         fd_shm,
         0);
    close(fd_shm);
    if (input == MAP_FAILED) {
        fprintf(stderr, "Error mapping the shared memory segment\n");
        shm_unlink(SHM_NAME);
        close(fd_shm);
        return EXIT_FAILURE;
    }

    if (sem_init(&(input->sem_mutex),1,1) < 0) {
        fprintf(stderr, "Error initializing mutex semaphore\n");
        perror("sem_init");
        return EXIT_FAILURE;
    }
    input->queue = queue_ini(QUEUE_SIZE);

    /*Generamos N numeros aleatorios/secuencia entre 0 y 9*/
    sem_wait(&(input->sem_mutex));
    if (argv[2] == 0) {
        for (i=0; i<atoi(argv[1]); i++) {
            insert_queue(input->queue, rand()%10);
        }
    } else if (atoi(argv[2]) == 1) {
        for (i=0; i<atoi(argv[1]); i++) {
            insert_queue(input->queue, i%10);
        }
    }
    sem_post(&(input->sem_mutex));

    /*El programa espera un caracter mientras ejecutamos el hijo*/
    getchar();

    sem_destroy(&(input->sem_mutex));
    munmap(input, sizeof(*input));
    shm_unlink(SHM_NAME);
    close(fd_shm);
    return EXIT_SUCCESS;
} 

 #include <errno.h>
 #include <fcntl.h>
 #include <math.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <semaphore.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <time.h>
 #include <unistd.h>
 #include "cola_circular.c"

 #define SHM_NAME "/shm_eje4"

 typedef struct {
     circular_queue queue;
     sem_t sem_mutex;
 } ShmStruct;

 int  main(void) {
     fprintf(stdout, "1");
     int i;
     int count[10];
     int fd_shm = shm_open(SHM_NAME,
        O_RDONLY,
        0);
    if (fd_shm == -1) {
        fprintf(stderr, "Error opening the shared memory segment\n");
        return EXIT_FAILURE;
    }

    ShmStruct *output = mmap(NULL,
        sizeof(*output),
        PROT_READ,
        MAP_SHARED,
        fd_shm,
        0);
    close(fd_shm);
    if (output == MAP_FAILED) {
        fprintf(stderr, "Error mapping the shared memory segment\n");
        return EXIT_FAILURE;
    }

    sem_wait(&(output->sem_mutex));
    for (i=0; i<10; i++) {
        count[i] = 0;
    }
    for (i=0; i<output->queue.num; i++) {
        count[output->queue.queue[i]]++;
    }
    fprintf(stdout, "Histograma de numeros de queue:\n");
    for  (i=0; i<10; i++) {
        fprintf(stdout, "%d ---> %d\n", i, count[i]);
    }
    sem_post(&(output->sem_mutex));

    munmap(output, sizeof(*output));
    close(fd_shm);
    return EXIT_SUCCESS;
 }

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括“cola_circular.c”
#定义SHM_名称“/SHM_eje4”
类型定义结构{
循环队列；
sem_t sem_互斥体；
}ShmStruct；
内部主（空）{
fprintf（标准值，“1”）；
int i；
整数计数[10]；
int fd_shm=shm_打开（shm_名称，
Ordonly，
0);
如果（fd_shm==-1）{
fprintf（stderr，“打开共享内存段时出错\n”）；
返回退出失败；
}
ShmStruct*输出=mmap（空，
sizeof（*输出），
PROT_READ，
地图共享，
孙明扬，
0);
关闭（fd_shm）；
如果（输出==映射_失败）{
fprintf（stderr，“映射共享内存段时出错\n”）；
返回退出失败；
}
sem_wait（&（output->sem_mutex））；
对于（i=0；iqueue.queue[i]]++；
}
fprintf（stdout，“队列编号的历史记录：\n”）；
对于（i=0；isem_互斥体））；
munmap（输出，sizeof（*输出））；
关闭（fd_shm）；
返回退出成功；
}

循环队列

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

#define SIZE 124

typedef struct circular_queue {
    int *queue;
    int rear;
    int front;
    int size;
    int num;
} circular_queue;

circular_queue queue_ini(int size) {
    int i;
    circular_queue ret;
    ret.queue = (int*) malloc(0);
    ret.rear = -1;
    ret.front = -1;
    ret.size = size;
    ret.num = 0;
    return ret;
}

int queue_isFull(circular_queue queue) {
    if (queue.num == queue.size) {
        return 1;
    } else {
        fprintf(stderr, "Error inseting, the queue is full.\n");
        return 0;
    }
}

int insert_queue(circular_queue queue, int num) {
    if (queue_isFull(queue) == 1) {
        return 0;
    }
    ret.queue = (int*) realloc(ret.queue, sizeof(int)*(ret.num+1));
    if (queue.front == -1) queue.front = 0;
    queue.rear = (queue.rear+1)%SIZE;
    queue.queue[queue.rear] = num;
    queue.num++;
    fprintf(stdout, "\n Inserted --> %d", queue.num);
    return 1;
}

int queue_isEmpty(circular_queue queue) {
    if  (queue.num == 0) return 1;
    return 0;
}

#包括
#包括
#定义大小124
typedef结构循环_队列{
int*队列；
内部后部；
内锋；
整数大小；
int-num；
}循环队列；
循环队列ini（整数大小）{
int i；
环形队列ret；
ret.queue=（int*）malloc（0）；
后倾角=-1；
ret.front=-1；
ret.size=尺寸；
ret.num=0；
返回ret；
}
int队列已满（循环队列）{
if（queue.num==queue.size）{
返回1；
}否则{
fprintf（stderr，“插入错误，队列已满。\n”）；
返回0；
}
}
int insert_队列（循环_队列，int num）{
如果（队列已满（队列）=1）{
返回0；
}
ret.queue=（int*）realloc（ret.queue，sizeof（int）*（ret.num+1））；
如果（queue.front==-1）queue.front=0；
queue.rear=（queue.rear+1）%SIZE；
queue.queue[queue.rear]=num；
queue.num++；
fprintf（stdout，“\n已插入-->%d”，queue.num）；
返回1；
}
int queue_isEmpty（循环队列）{
如果（queue.num==0）返回1；
返回0；
}

realloc

函数不分配共享内存。如果不将队列放入共享内存中，则它不是共享的。当您试图从一个进程从另一个进程访问在一个进程中分配的常规内存的指针时，最常见的结果是崩溃

您需要将所有共享数据放在共享内存中。当您跨进程共享指针时，您需要将一个相对指针共享到共享内存中，并且每个进程都需要将