system함수가 thread-safe한가요??

문제 없습니다.
fork 하면, 현재 thread를 제외한 모든 thread는 닫혀지게 되며,
thread unsafe한 데이터를 내부에 가지고 있지 않으니.. 그다지 문제 없어 보입니다.

signal을 masking 해두었다면 문제가 있을지도 모르겠습니다만, 아래 코드를 보니 __sigprocmask를 사용하여 masking을 잠시 푸는 군요.

glibc-2.2.2/sysdeps/posix/system.c

     1  /* Copyright (C) 1991-1999, 2000 Free Software Foundation, Inc.
     2     This file is part of the GNU C Library.
     3
     4     The GNU C Library is free software; you can redistribute it and/or
     5     modify it under the terms of the GNU Library General Public License as
     6     published by the Free Software Foundation; either version 2 of the
     7     License, or (at your option) any later version.
     8
     9     The GNU C Library is distributed in the hope that it will be useful,
    10     but WITHOUT ANY WARRANTY; without even the implied warranty of
    11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    12     Library General Public License for more details.
    13
    14     You should have received a copy of the GNU Library General Public
    15     License along with the GNU C Library; see the file COPYING.LIB.  If not,
    16     write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    17     Boston, MA 02111-1307, USA.  */
    18
    19  #include <stddef.h>
    20  #include <stdlib.h>
    21  #include <unistd.h>
    22  #include <sys/wait.h>
    23  #include <signal.h>
    24  #include <sys/types.h>
    25  #include <errno.h>
    26
    27
    28  #ifndef HAVE_GNU_LD
    29  #define __environ       environ
    30  #endif
    31
    32  #define SHELL_PATH      "/bin/sh"       /* Path of the shell.  */
    33  #define SHELL_NAME      "sh"            /* Name to give it.  */
    34
    35  /* Execute LINE as a shell command, returning its status.  */
    36  int
    37  __libc_system (const char *line)
    38  {
    39    int status, save;
    40    pid_t pid;
    41    struct sigaction sa, intr, quit;
    42  #ifndef WAITPID_CANNOT_BLOCK_SIGCHLD
    43    sigset_t block, omask;
    44  #endif
    45
    46    if (line == NULL)
    47      /* Check that we have a command processor available.  It might
    48         not be available after a chroot(), for example.  */
    49      return __libc_system ("exit 0") == 0;
    50
    51    sa.sa_handler = SIG_IGN;
    52    sa.sa_flags = 0;
    53    __sigemptyset (&sa.sa_mask);
    54
    55    if (__sigaction (SIGINT, &sa, &intr) < 0)
    56      return -1;
    57    if (__sigaction (SIGQUIT, &sa, &quit) < 0)
    58      {
    59        save = errno;
    60        (void) __sigaction (SIGINT, &intr, (struct sigaction *) NULL);
    61        __set_errno (save);
    62        return -1;
    63      }
    64
    65  #ifndef WAITPID_CANNOT_BLOCK_SIGCHLD
    66
    67  /* SCO 3.2v4 has a bug where `waitpid' will never return if SIGCHLD is
    68     blocked.  This makes it impossible for `system' to be implemented in
    69     compliance with POSIX.2-1992.  They have acknowledged that this is a bug
    70     but I have not seen nor heard of any forthcoming fix.  */
    71
    72    __sigemptyset (&block);
    73    __sigaddset (&block, SIGCHLD);
    74    save = errno;
    75    if (__sigprocmask (SIG_BLOCK, &block, &omask) < 0)
    76      {
    77        if (errno == ENOSYS)
    78          __set_errno (save);
    79        else
    80          {
    81            save = errno;
    82            (void) __sigaction (SIGINT, &intr, (struct sigaction *) NULL);
    83            (void) __sigaction (SIGQUIT, &quit, (struct sigaction *) NULL);
    84            __set_errno (save);
    85            return -1;
    86          }
    87      }
    88  # define UNBLOCK __sigprocmask (SIG_SETMASK, &omask, (sigset_t *) NULL)
    89  #else
    90  # define UNBLOCK 0
    91  #endif
    92
    93    pid = __fork ();
    94    if (pid == (pid_t) 0)
    95      {
    96        /* Child side.  */
    97        const char *new_argv[4];
    98        new_argv[0] = SHELL_NAME;
    99        new_argv[1] = "-c";
   100        new_argv[2] = line;
   101        new_argv[3] = NULL;
   102
   103        /* Restore the signals.  */
   104        (void) __sigaction (SIGINT, &intr, (struct sigaction *) NULL);
   105        (void) __sigaction (SIGQUIT, &quit, (struct sigaction *) NULL);
   106        (void) UNBLOCK;
   107
   108        /* Exec the shell.  */
   109        (void) __execve (SHELL_PATH, (char *const *) new_argv, __environ);
   110        _exit (127);
   111      }
   112    else if (pid < (pid_t) 0)
   113      /* The fork failed.  */
   114      status = -1;
   115    else
   116      /* Parent side.  */
   117      {
   118  #ifdef  NO_WAITPID
   119        pid_t child;
   120        do
   121          {
   122            child = __wait (&status);
   123            if (child <= -1 && errno != EINTR)
   124              {
   125                status = -1;
   126                break;
   127              }
   128            /* Note that pid cannot be <= -1 and therefore the loop continues
   129               when __wait returned with EINTR.  */
   130          }
   131        while (child != pid);
   132  #else
   133        int n;
   134
   135        do
   136          n = __waitpid (pid, &status, 0);
   137        while (n == -1 && errno == EINTR);
   138
   139        if (n != pid)
   140          status = -1;
   141  #endif
   142      }
   143
   144    save = errno;
   145    if ((__sigaction (SIGINT, &intr, (struct sigaction *) NULL) |
   146         __sigaction (SIGQUIT, &quit, (struct sigaction *) NULL) |
   147         UNBLOCK) != 0)
   148      {
   149        if (errno == ENOSYS)
   150          __set_errno (save);
   151        else
   152          return -1;
   153      }
   154
   155    return status;
   156  }
   157  weak_alias (__libc_system, system)

아.. 오해가 있을 것 같군요.

fork 하고 나면, 자식 프로세스에서는 다른 쓰레드는 모두 닫히고 하나만 남는다는 것이었습니다.