C语言 共享内存的简单签入返回 SIGSEGV 错误 008b

Question

>我在 C 中实现了共享内存，让分叉的孩子相互通信，这里有一个最小、完整和可验证的例子：

#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 %dn",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%04Xn",
getpid(),
child_pid,
status);
}
/* Now the semaphore may be deallocated */
semctl(sem_Id, 0, IPC_RMID);
exit(0);
}
static void init(){
printf("INITn");
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%04Xn",
getpid(),
child_pid,
status);
}
semctl(sem_Id, 0, IPC_RMID);
exit(0);
break;
}   
}

只要计时器运行(sim_time = 10)，分叉的孩子就会保持锁定和解锁。然后SIGNAL_HANDLER杀死所有的孩子，并终止。 我不断收到来自随机子级的 SIGSEGV 错误，该错误以状态 008B 终止并停止他的"兄弟"，直到处理程序杀死所有其他进程。据我所知，此错误与共享内存中的指针有关，对吗？或者我失踪了/我写错了什么？即使是这个检查INVITE_SENT矩阵中至少 1 个值是否与 -1 不同的小方法也会导致崩溃，而不仅仅是返回 0。 谢谢你的时间。

Answer 1

我无法在本地重现段错误，并且 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一样大的数字。