我在C中实现了一个共享内存，让分叉的孩子互相交流，这里是一个Minimal，Complete和Verificable示例：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#define SHMEMORY
#define NUM_SEMS 2
#define LOCK \
sops.sem_num = 1; \
sops.sem_op = -1; \
semop(sem_Id, &sops, 1);
#define UNLOCK \
sops.sem_num = 1; \
sops.sem_op = 1; \
semop(sem_Id, &sops, 1);
#define TEST_ERROR if (errno) {dprintf(STDERR_FILENO, \
"%s:%d: PID=%5d: Error %d (%s)\n", \
__FILE__, \
__LINE__, \
getpid(), \
errno, \
strerror(errno));}
#define POP_SIZE 100 //number of child
#define TRUE 1
struct shared_data {
/* index where next write will happen */
unsigned long cur_idx;
int invite_sent[POP_SIZE][POP_SIZE];
};
static void init();
static int invite_sent_check(int stud);
int maxMin_rand(int max,int min);
void handle_signal(int sig);
int sim_time = 10;
unsigned long next_num;
struct sembuf sops;
pid_t *kid_pids;
int mem_Id, sem_Id;
int main() {
int i = 0;
int j = 0;
int status, cur_i;
struct shared_data* corso;
pid_t child_pid, my_pid;
int stud = 0;
int exit_loop = 0;
/*********************************************************/
struct sigaction sa;
sigset_t my_mask;
/* handler SIGALRM
*/
sa.sa_handler = handle_signal;
sa.sa_flags = 0;
sigemptyset(&my_mask);
sa.sa_mask = my_mask;
sigaction(SIGALRM, &sa, NULL);
/**********************************************************/
mem_Id = shmget(IPC_PRIVATE, sizeof(*corso), 0600);
TEST_ERROR;
/* Attach the shared memory to a pointer */
corso = shmat(mem_Id, NULL, 0);
TEST_ERROR;
corso->cur_idx = 0; /* init first counter */
/*********************************************************/
sem_Id = semget(IPC_PRIVATE, NUM_SEMS, 0600);
TEST_ERROR;
/* Sem 0 to syncronize the start of child processes */
semctl(sem_Id, 0, SETVAL, 0);
#ifdef SHMEMORY
semctl(sem_Id, 1, SETVAL, 1);
#endif
TEST_ERROR;
sops.sem_num = 0; /* check the 0-th semaphore */
sops.sem_flg = 0; /* no flag */
init();
kid_pids = malloc(POP_SIZE*sizeof(*kid_pids));
for (i = 0; i < POP_SIZE; i++) {
switch (kid_pids[i] = fork()) {
case -1:
/* Handle error */
TEST_ERROR;
break;
case 0:
/* Wait for the green light */
sops.sem_op = -1;
semop(sem_Id, &sops, 1);
while(exit_loop==0 || exit_loop==1){
LOCK;
if(exit_loop == 0){
stud = corso->cur_idx;
printf("%d %d\n",stud,getpid());
corso->cur_idx++;
exit_loop = 1;
}
if(invite_sent_check(stud) == 1){
}
UNLOCK;
}
exit(0);
break;
default:
break;
}
}
alarm(sim_time);
while (shmctl(mem_Id, IPC_RMID, NULL)) { TEST_ERROR; }
sops.sem_op = POP_SIZE;
semop(sem_Id, &sops, 1);
/* Waiting for all child POP_SIZEesses to terminate */
while ((child_pid = wait(&status)) != -1) {
dprintf(2,"PID=%d. Sender (PID=%d) terminated with status 0x%04X\n",
getpid(),
child_pid,
status);
}
/* Now the semaphore may be deallocated */
semctl(sem_Id, 0, IPC_RMID);
exit(0);
}
static void init(){
printf("INIT\n");
struct shared_data * corso;
corso = shmat(mem_Id, NULL, 0);
corso->cur_idx=0;
int r, q, j;
j = 0;
q = 0;
while(j < POP_SIZE){
q = 0;
while(q < POP_SIZE){
corso->invite_sent[j][q] = -1;
q++;
}
j++;
}
}
int maxMin_rand(int max, int min){
int reset;
int randomics=12345;
int w=0;
while(w<reset) {
randomics++;
w++;
}
next_num = next_num+randomics;
next_num = next_num*1103515245 +12345;
unsigned int result=(unsigned int) ((next_num*65536)%(max+1))+min;
int reload;
w=0;
while(w<reload) {
next_num++;
w++;
}
return result;
}
static int invite_sent_check(int stud){
struct shared_data * corso;
corso = shmat(mem_Id, NULL, 0);
int i = 0;
int q = 0;
while(i < POP_SIZE){
if(i == stud){
q = 0;
while(q < POP_SIZE){
if(corso->invite_sent[i][q] != -1){
return 1;
}
q++;
}
}
i++;
}
return 0;
}
void handle_signal(int signal){
int child_pid;
int status;
struct shared_data * corso;
corso = shmat(mem_Id, NULL, 0);
switch (signal) {
case SIGALRM:
for(int i = 0; i < POP_SIZE; i++){
kill(kid_pids[i], SIGKILL);
}
while (shmctl(mem_Id, IPC_RMID, NULL)) {
TEST_ERROR;
}
while ((child_pid = wait(&status)) != -1) {
dprintf(2,"PID=%d. Sender (PID=%d) terminated with status 0x%04X\n",
getpid(),
child_pid,
status);
}
semctl(sem_Id, 0, IPC_RMID);
exit(0);
break;
}
}
只要计时器进入（sim_time = 10），分叉的孩子就会保持LOCK和UNLOCK。然后SIGNAL_HANDLER杀死所有孩子，并终止。我一直从一个以状态008B终止的RANDOM子节点收到一个SIGSEGV错误并停止他的“兄弟”，直到处理程序杀死所有其他进程。只要我知道，这个错误关注共享内存中的指针，是吗？或者我想念/我写错了什么？即使是在INVITE_SENT矩阵中检查是否至少1个值与-1不同的这个小方法导致崩溃，而不是仅返回0.感谢您的时间。
我无法在本地重现segfault，Valgrind也没有检测到任何无效的内存访问。段错误还有其他可能的原因，但它们并不常见。无法在本地重现问题，我无法确定其来源，但代码中存在许多问题，主要是次要问题。
似乎与您的问题有关的唯一问题是您在函数invite_sent_check()中冗余附加共享内存段，特别是考虑到您使用shmat()的返回值而不检查它（(void*)-1在失败时返回） ）。明确允许冗余附件，但是调用者只需将其现有指针传递给段的原始附加点，它就会更清晰，更有效。此外，如果您在该函数中形成本地附件，则必须确保在函数返回之前再次分离。如果不这样做可能会成为问题的根源，因为由此产生的许多附件的元数据和地址空间预留可能耗尽可用资源。
其他问题包括
dprintf()不是异步信号安全的，而是从信号处理程序（显式和通过宏TEST_ERROR）调用。shmat()不是异步信号安全的，但它是从信号处理程序调用的。此外，这似乎是不必要的，因为新的段附件未在处理程序中使用。此外，它也没有分离。semctl()不是异步信号安全的，但它是从信号处理程序调用的。exit()不是异步信号安全的，但它是从信号处理程序调用的。您可以使用_Exit()或_exit()，但似乎这个处理程序应该退出程序，因为主进程似乎还有其他要清理的工作。SIGALRM时你似乎想要做的所有事情，其中许多不是异步信号安全的，你应该考虑使用sigsupend()同步接收信号，然后调用常规函数来完成这项工作。如果你朝那个方向前进，那么最安全，最可靠的方法将包括在发出警报之前首先阻止SIGALRM，然后将信号掩码传递给允许该信号的sigsuspend()。这将防止在过程准备好之前传递信号的任何可能性。init()冗余地附加共享内存段。这是允许的，但是调用者只需将指针传递给要初始化的struct shared_data就更好了。此功能也无法分离。errno来检查错误，则必须确定在要检查的调用之前将其设置为0（并在执行任何其他操作之前立即对其进行测试）。但是，最好使用函数的返回值来检测是否发生了错误，并且仅依靠errno来识别哪一个。maxMin_rand()的名称和签名表明它旨在返回max和min之间的数字，但看起来它可以返回与max + min一样大的数字。