5

我编写了一个代码来创建一些线程，每当其中一个线程完成时，就会创建一个新线程来替换它。由于我无法使用 pthreads 创建大量线程 (>450)，因此我使用了 clone 系统调用。（请注意，我知道拥有如此大量线程的含义，但这个程序只是为了给系统施加压力）。
由于 clone() 需要将子线程的堆栈空间指定为参数，因此我为每个线程分配所需的堆栈空间块并在线程完成时释放它。当一个线程完成时，我向父级发送一个信号以通知它。
代码如下：

#include <sched.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>

#define NUM_THREADS 5

unsigned long long total_count=0;
int num_threads = NUM_THREADS;
static int thread_pids[NUM_THREADS];
static void *thread_stacks[NUM_THREADS];
int ppid;

int worker() {
 int i;
 union sigval s={0};
 for(i=0;i!=99999999;i++);
 if(sigqueue(ppid, SIGUSR1, s)!=0)
  fprintf(stderr, "ERROR sigqueue");
 fprintf(stderr, "Child [%d] done\n", getpid());
 return 0;
}

void sigint_handler(int signal) {
 char fname[35]="";
 FILE *fp;
 int ch;
 if(signal == SIGINT) {
  fprintf(stderr, "Caught SIGINT\n");
  sprintf(fname, "/proc/%d/status", getpid());
  fp = fopen(fname,"r");
  while((ch=fgetc(fp))!=EOF)
   fprintf(stderr, "%c", (char)ch);
  fclose(fp);
  fprintf(stderr, "No. of threads created so far = %llu\n", total_count);
  exit(0);
 } else
  fprintf(stderr, "Unhandled signal (%d) received\n", signal);
}


int main(int argc, char *argv[]) {
 int rc, i; long t;
 void *chld_stack, *chld_stack2;
 siginfo_t siginfo;
 sigset_t sigset, oldsigset;

 if(argc>1) {
  num_threads = atoi(argv[1]);
  if(num_threads<1) {
   fprintf(stderr, "Number of threads must be >0\n");
   return -1;
  }
 }
 signal(SIGINT, sigint_handler);

 /* Block SIGUSR1 */
 sigemptyset(&sigset);
 sigaddset(&sigset, SIGUSR1); 
 if(sigprocmask(SIG_BLOCK, &sigset, &oldsigset)==-1)
  fprintf(stderr, "ERROR: cannot block SIGUSR1 \"%s\"\n", strerror(errno));

 printf("Number of threads = %d\n", num_threads);
 ppid = getpid();
 for(t=0,i=0;t<num_threads;t++,i++) {
  chld_stack = (void *) malloc(148*512);
  chld_stack2 = ((char *)chld_stack + 148*512 - 1);
  if(chld_stack == NULL) {
   fprintf(stderr, "ERROR[%ld]: malloc for stack-space failed\n", t);
   break;
  }
  rc = clone(worker, chld_stack2, CLONE_VM|CLONE_FS|CLONE_FILES, NULL);
  if(rc == -1) {
   fprintf(stderr, "ERROR[%ld]: return code from pthread_create() is %d\n", t, errno);
   break;
  }
  thread_pids[i]=rc;
  thread_stacks[i]=chld_stack;
  fprintf(stderr, " [index:%d] = [pid:%d] ; [stack:0x%p]\n", i, thread_pids[i], thread_stacks[i]);
  total_count++;
 }
 sigemptyset(&sigset);
 sigaddset(&sigset, SIGUSR1); 
 while(1) {
  fprintf(stderr, "Waiting for signal from childs\n");
  if(sigwaitinfo(&sigset, &siginfo) == -1)
   fprintf(stderr, "- ERROR returned by sigwaitinfo : \"%s\"\n", strerror(errno));
  fprintf(stderr, "Got some signal from pid:%d\n", siginfo.si_pid);

  /* A child finished, free the stack area allocated for it */ 
  for(i=0;i<NUM_THREADS;i++) {
   fprintf(stderr, " [index:%d] = [pid:%d] ; [stack:%p]\n", i, thread_pids[i], thread_stacks[i]);
   if(thread_pids[i]==siginfo.si_pid) {
    free(thread_stacks[i]);
    thread_stacks[i]=NULL;
    break;
   }
  }
  fprintf(stderr, "Search for child ended with i=%d\n",i);
  if(i==NUM_THREADS) 
   continue;
  /* Create a new thread in its place */
  chld_stack = (void *) malloc(148*512);
  chld_stack2 = ((char *)chld_stack + 148*512 - 1);
  if(chld_stack == NULL) {
   fprintf(stderr, "ERROR[%ld]: malloc for stack-space failed\n", t);
   break;
  }
  rc = clone(worker, chld_stack2, CLONE_VM|CLONE_FS|CLONE_FILES, NULL);
  if(rc == -1) {
   fprintf(stderr, "ERROR[%ld]: return code from clone() is %d\n", t, errno);
   break;
  }
  thread_pids[i]=rc;
  thread_stacks[i]=chld_stack;
  total_count++;
 }
 fprintf(stderr, "Broke out of infinite loop. [total_count=%llu] [i=%d]\n",total_count, i);
 return 0;
}

我使用了几个数组来跟踪子进程的 pid 和堆栈区基地址（用于释放它）。
当我运行这个程序时，它会在一段时间后终止。使用 gdb 运行告诉我其中一个线程出现 SIGSEGV（分段错误）。但它没有给我任何位置，输出类似于以下内容：

Program received signal SIGSEGV, Segmentation fault.
[Switching to LWP 15864]
0x00000000 in ?? ()

我尝试使用以下命令行在 valgrind 下运行它：

valgrind --tool=memcheck --leak-check=yes --show-reachable=yes -v --num-callers=20 --track-fds=yes ./a.out

但它在 valgrind 下继续运行，没有任何问题。
我对如何调试这个程序感到困惑。我觉得这可能是一些堆栈溢出或其他问题，但增加堆栈大小（高达 74KB）并没有解决问题。
我唯一的疑问是分段错误的原因和位置或如何调试此程序。

4

2 回答 2

4

发现了实际问题。
当工作线程使用 sigqueue() 向父进程发出信号时，父进程有时会立即获得控制权并在子进程执行 return 语句之前释放堆栈。当同一个子线程使用 return 语句时，由于堆栈损坏，会导致分段错误。
为了解决这个问题，我更换了 

exit(0)

代替

return 0;
于 2010-01-25T09:32:39.160 回答
1

我想我找到了答案

步骤1

替换这个：

static int thread_pids[NUM_THREADS];
static void *thread_stacks[NUM_THREADS];

这样：

static int *thread_pids;
static void **thread_stacks;

第2步

在主函数中添加这个（检查参数后）：

thread_pids = malloc(sizeof(int) * num_threads);
thread_stacks = malloc(sizeof(void *) * num_threads);

第 3 步

替换这个：

chld_stack2 = ((char *)chld_stack + 148*512 - 1);

这样：

chld_stack2 = ((char *)chld_stack + 148*512);

在这两个地方你都使用它。

我不知道这是否真的是你的问题，但在测试之后我没有遇到任何分段错误。顺便说一句，我只在使用超过 5 个线程时出现分段错误。

希望我有帮助！

编辑：用 1000 个线程测试并完美运行

edit2：解释为什么 thread_pids 和 thread_stacks 的静态分配会导致错误。

最好的方法是举个例子。

假设 num_threads = 10;

问题出现在以下代码中：

for(t=0,i=0;t<num_threads;t++,i++) {
...

thread_pids[i]=rc; 
thread_stacks[i]=chld_stack;

...
}

在这里，您尝试访问不属于您的内存（0 <= i <= 9，但两个数组的大小均为 5）。这可能导致分段错误或数据损坏。如果两个数组一个接一个地分配，可能会发生数据损坏，从而导致写入另一个数组。如果您写入未分配的内存（静态或动态），则可能会发生分段。

你可能很幸运，完全没有错误，但代码肯定不安全。

关于非对齐指针：我想我不必在评论中解释更多。

于 2010-01-24T18:22:41.357 回答