Ch10 Signals

# On macOS:
# zsh
> kill -l | awk '{for(i=1;i<=NF;i++) printf "%2d) %-8s%s", i, $i, (i%6?"":"\n")}'

 1) HUP      2) INT      3) QUIT     4) ILL      5) TRAP     6) ABRT
 7) EMT      8) FPE      9) KILL    10) BUS     11) SEGV    12) SYS
13) PIPE    14) ALRM    15) TERM    16) URG     17) STOP    18) TSTP
19) CONT    20) CHLD    21) TTIN    22) TTOU    23) IO      24) XCPU
25) XFSZ    26) VTALRM  27) PROF    28) WINCH   29) INFO    30) USR1
31) USR2

# bash
> kill -l
 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL       5) SIGTRAP
 6) SIGABRT      7) SIGEMT       8) SIGFPE       9) SIGKILL     10) SIGBUS
11) SIGSEGV     12) SIGSYS      13) SIGPIPE     14) SIGALRM     15) SIGTERM
16) SIGURG      17) SIGSTOP     18) SIGTSTP     19) SIGCONT     20) SIGCHLD
21) SIGTTIN     22) SIGTTOU     23) SIGIO       24) SIGXCPU     25) SIGXFSZ
26) SIGVTALRM   27) SIGPROF     28) SIGWINCH    29) SIGINFO     30) SIGUSR1
31) SIGUSR2

# On Linux (Debian 12):
# zsh
> kill -l | awk '{for(i=1;i<=NF;i++) printf "%2d) %-8s%s", i, $i, (i%6?"":"\n")}'
 1) HUP      2) INT      3) QUIT     4) ILL      5) TRAP     6) IOT
 7) BUS      8) FPE      9) KILL    10) USR1    11) SEGV    12) USR2
13) PIPE    14) ALRM    15) TERM    16) STKFLT  17) CHLD    18) CONT
19) STOP    20) TSTP    21) TTIN    22) TTOU    23) URG     24) XCPU
25) XFSZ    26) VTALRM  27) PROF    28) WINCH   29) POLL    30) PWR
31) SYS

# bash
> kill -l
 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL       5) SIGTRAP
 6) SIGABRT      7) SIGBUS       8) SIGFPE       9) SIGKILL     10) SIGUSR1
11) SIGSEGV     12) SIGUSR2     13) SIGPIPE     14) SIGALRM     15) SIGTERM
16) SIGSTKFLT   17) SIGCHLD     18) SIGCONT     19) SIGSTOP     20) SIGTSTP
21) SIGTTIN     22) SIGTTOU     23) SIGURG      24) SIGXCPU     25) SIGXFSZ
26) SIGVTALRM   27) SIGPROF     28) SIGWINCH    29) SIGIO       30) SIGPWR
31) SIGSYS      34) SIGRTMIN    35) SIGRTMIN+1  36) SIGRTMIN+2  37) SIGRTMIN+3
38) SIGRTMIN+4  39) SIGRTMIN+5  40) SIGRTMIN+6  41) SIGRTMIN+7  42) SIGRTMIN+8
43) SIGRTMIN+9  44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9  56) SIGRTMAX-8  57) SIGRTMAX-7
58) SIGRTMAX-6  59) SIGRTMAX-5  60) SIGRTMAX-4  61) SIGRTMAX-3  62) SIGRTMAX-2
63) SIGRTMAX-1  64) SIGRTMAX

#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <sys/signal.h>

void print_signal_info(int sig) {
#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
    if (sig > 0 && sig < NSIG) {
      printf("sys_signame[%d]=%s, sys_siglist[%d]=%s, strsignal[%d]=%s\n",
             sig, sys_signame[sig], sig, sys_siglist[sig], sig, strsignal(sig));
    }
#else
    printf("strsignal(%d): %s\n", sig, strsignal(sig));
#endif
}

int main(int argc, char *argv[]) {
  for (int i = 0; i < NSIG; i++) {
    print_signal_info(i);
  }
  psignal(SIGSTOP, "STOP");
  psignal(SIGTSTP, "TSTP");
  return 0;
}

No    Name         Default Action       Description
1     SIGHUP       terminate process    terminal line hangup
2     SIGINT       terminate process    interrupt program
3     SIGQUIT      create core image    quit program
4     SIGILL       create core image    illegal instruction
5     SIGTRAP      create core image    trace trap
6     SIGABRT      create core image    abort program (formerly SIGIOT)
7     SIGEMT       create core image    emulate instruction executed
8     SIGFPE       create core image    floating‐point exception
9     SIGKILL      terminate process    kill program
10    SIGBUS       create core image    bus error
11    SIGSEGV      create core image    segmentation violation
12    SIGSYS       create core image    non‐existent system call invoked
13    SIGPIPE      terminate process    write on a pipe with no reader
14    SIGALRM      terminate process    real‐time timer expired
15    SIGTERM      terminate process    software termination signal
16    SIGURG       discard signal       urgent condition present on socket
17    SIGSTOP      stop process         stop (cannot be caught or ignored)
18    SIGTSTP      stop process         stop signal generated from keyboard
19    SIGCONT      discard signal       continue after stop
20    SIGCHLD      discard signal       child status has changed
21    SIGTTIN      stop process         background read attempted from control terminal
22    SIGTTOU      stop process         background write attempted to control terminal
23    SIGIO        discard signal       I/O is possible on a descriptor (see fcntl(2))
24    SIGXCPU      terminate process    cpu time limit exceeded (see setrlimit(2))
25    SIGXFSZ      terminate process    file size limit exceeded (see setrlimit(2))
26    SIGVTALRM    terminate process    virtual time alarm (see setitimer(2))
27    SIGPROF      terminate process    profiling timer alarm (see setitimer(2))
28    SIGWINCH     discard signal       Window size change
29    SIGINFO      discard signal       status request from keyboard
30    SIGUSR1      terminate process    User defined signal 1
31    SIGUSR2      terminate process    User defined signal 2

# check if core dump enabled
> sysctl kern.coredump
kern.coredump: 1
# check core file location
> sysctl kern.corefile
kern.corefile: /cores/core.%P
# list core files
> ls -lh /cores
total 7.1G
-r-------- 1 gpanda wheel 3.6G Aug 17 17:37 core.36330
-r-------- 1 gpanda wheel 3.6G Aug 17 17:54 core.44110

# use debugger `lldb` to inspect core file
> lldb ./Debug/signal/abort -c /cores/core.44110
(lldb) bt
(lldb) thread list
(lldb) thread backtrace all
(lldb) image list
(lldb) register read
(lldb) frame variable

void pr_statsig(int);

int main(int argc, char *argv[]) {
  int pid;
  if ((pid = fork()) < 0) {
    my_perror("error: fork");
  } else if (pid == 0) { // child
    sleep(10);
    exit(0);
  } else { // parent
    sleep(3);
    int rc = 0;
    kill(pid, SIGSTOP); // send signal 17 to the child
    if (waitpid(pid, &rc, WUNTRACED) == -1) {
      my_perror("error: waitpid");
      exit(1);
    }
    assert(WIFSTOPPED(rc));
    printf("child rc = %d\n", rc);
    pr_statsig(rc);
  }
  return 0;
}

void pr_statsig(int status) {
  if (WIFSTOPPED(status)) {
    printf("Child stopped by signal %d (%s)\n", WSTOPSIG(status),
           strsignal(WSTOPSIG(status)));
  } else if (WIFEXITED(status)) {
    printf("Child exited with status %d\n", WEXITSTATUS(status));
  } else if (WIFSIGNALED(status)) {
    printf("Child killed by signal %d (%s)\n", WTERMSIG(status),
           strsignal(WTERMSIG(status)));
  }
}

/*
 * Sample output:
 *
!Debug/signals/basic
child rc = 4479
Child stopped by signal 17 (Suspended (signal): 17)
 */

#include <signal.h>
void (*signal(int, void (*)(int)))(int);
            // Returns: **previous disposition** of signal if OK, SIG_ERR on error

// friendlier declaration with a typedef
typedef void (*sighandler_t)(int);
sighandler_t signal(int, sighandler_t);

// or
typedef void Sigfunc(int);
Sigfunc *signal(int, Sigfunc *);

static void	sig_usr(int);	/* one handler for both signals */
int
main(void)
{
	if (signal(SIGUSR1, sig_usr) == SIG_ERR)
		my_perror("can't catch SIGUSR1");
	if (signal(SIGUSR2, sig_usr) == SIG_ERR)
		my_perror("can't catch SIGUSR2");
	for ( ; ; )
		pause();
}

static void
sig_usr(int signo)		/* argument is signal number */
{
	if (signo == SIGUSR1)
		printf("received SIGUSR1\n");
	else if (signo == SIGUSR2)
		printf("received SIGUSR2\n");
	else
		my_perr_dump("received signal %d\n", signo);
}

int main(int argc, char *argv[]) {
  pid_t pid;

  if ((pid = fork()) < 0) {
    my_perror("error: fork");
  } else if (pid == 0) { // child
    while(1) pause();
    _exit(1);
  } else { // parent
    sleep(3);
    printf("I'm a parent (PID:%d), I have a child (PID:%d)\n", getpid(), pid);
    int rc;
    waitpid(pid, &rc, WUNTRACED);
    pr_statsig(rc);
  }

  return 0;
}

> ulimit -c
0
> ulimit -c unlimited

# Tells a process to generate core dump

> ./Debug/signals/sigcore &
[2] 53132
> I'm a parent (PID:53132), I have a child (PID:53135)
>
> jobs
[1]  + suspended  vim
[2]  - running    ./Debug/signals/sigcore
> myps -p 53132,53135
  UID   PID  PPID  PGID   SESS TTY      STAT COMM
  501 53132 49433 53132      0 ttys001  SN   ./Debug/signals/sigcore
  501 53135 53132 53132      0 ttys001  SN   ./Debug/signals/sigcore

> kill -SIGABRT 53135

> myps -p 53132,53135
  UID   PID  PPID  PGID   SESS TTY      STAT COMM
  501 53132 49433 53132      0 ttys001  SN   ./Debug/signals/sigcore
  501 53135 53132 53132      0 ttys001  R    ./Debug/signals/sigcore
> Child killed by signal 6 (Abort trap: 6)

[2]  - 53132 done       ./Debug/signals/sigcore

> myps -p 53132,53135
  UID   PID  PPID  PGID   SESS TTY      STAT COMM

> ll -h /cores
total 3.6G
drwxrwxrwt  3 root   wheel   96 Aug 18 19:36 ./
drwxr-xr-x 20 root   wheel  640 Jul 17  2024 ../
-r--------  1 scv wheel 3.6G Aug 18 19:36 core.53135

# Tells a process group to generate core dump

> ./Debug/signals/sigcore &
[2] 62114
> I'm a parent (PID:62114), I have a child (PID:62117)
>
> kill -SIGABRT -62114
>
[2]    62114 abort (core dumped)  ./Debug/signals/sigcore
> ll -h /cores
total 7.1G
drwxrwxrwt  4 root   wheel  128 Aug 18 19:54 ./
drwxr-xr-x 20 root   wheel  640 Jul 17  2024 ../
-r--------  1 gpanda wheel 3.6G Aug 18 19:54 core.62114
-r--------  1 gpanda wheel 3.6G Aug 18 19:54 core.62117


# Tells a job to generate core dump

> ./Debug/signals/sigcore &
[2] 59032
> I'm a parent (PID:59032), I have a child (PID:59035)
>
> kill -SIGABRT %2
>
[2]    59032 abort (core dumped)  ./Debug/signals/sigcore

> ll -h /cores/
total 7.1G
drwxrwxrwt  4 root   wheel  128 Aug 18 19:48 ./
drwxr-xr-x 20 root   wheel  640 Jul 17  2024 ../
-r--------  1 gpanda wheel 3.6G Aug 18 19:48 core.59032
-r--------  1 gpanda wheel 3.6G Aug 18 19:48 core.59035

abort         faccessat     linkat        select        socketpair
accept        fchmod        listen        sem_post      stat
access        fchmodat      lseek         send          symlink
aio_error     fchown        lstat         sendmsg       symlinkat
aio_return    fchownat      mkdir         sendto        tcdrain
aio_suspend   fcntl         mkdirat       setgid        tcflow
alarm         fdatasync     mkfifo        setpgid       tcflush
bind          fexecve       mkfifoat      setsid        tcgetattr
cfgetispeed   fork          mknod         setsockopt    tcgetpgrp
cfgetospeed   fstat         mknodat       setuid        tcsendbreak
cfsetispeed   fstatat       open          shutdown      tcsetattr
cfsetospeed   fsync         openat        sigaction     tcsetpgrp
chdir         ftruncate     pause         sigaddset     time
chmod         futimens      pipe          sigdelset     timer_getover
chown         getegid       poll          sigemptyset   timer_gettime
clock_gettime geteuid       posix_trace_e sigfillset    timer_settime
close         getgid        pselect       sigismember   times
connect       getgroups     raise         signal        umask
creat         getpeername   read          sigpause      uname
dup           getpgrp       readlink      sigpending    unlink
dup2          getpid        readlinkat    sigprocmask   unlinkat
execl         getppid       recv          sigqueue      utime
execle        getsockname   recvfrom      sigset        utimensat
execv         getsockopt    recvmsg       sigsuspend    utimes
execve        getuid        rename        sleep         wait
_Exit         kill          renameat      sockatmark    waitpid
_exit         link          rmdir         socket        write

int main(int argc, char *argv[]) {
  alarm(5); // modern version: setitimer(2)
  pause();  // modern version: sigsuspend(2)
            // race-condition-safe, precise control over signal masking
  return 0;
}

/*

> ./Debug/signals/sigalarm
[2]    16246 alarm      ./Debug/signals/sigalarm
> echo $?
142           <- (128 + SIGALRM(14))

 */

volatile sig_atomic_t got_alarm = 0;

void sig_alrm(int);

int main(int argc, char *argv[]) {
  pid_t pid;
  if ((pid = fork()) < 0) {
    my_perror("error: fork");
  } else if (pid == 0) { // child
    sleep(2);
    printf("I'm child: %d, my parent ps info:\n", getpid());
    ps(getppid());
    exit(0);
  } else {
    if (signal(SIGALRM, sig_alrm) == SIG_ERR) {
      my_perror("error: signal");
    }
    printf("I'm parent: %d\n", getpid());
    alarm(3);
    while (got_alarm == 0) {
      pause();    // returns after any caught signal is delivered
                  // during pause, the process is still in running/sleep state
                  // not suspended
    }
    alarm(0);
    printf("Alarm: Time out!\n");
  }
  return 0;
}

void sig_alrm(int signo) {
  got_alarm = 1;
  printf("sig_alrm handler: I'm: %d\n", getpid());
}

/*

> ./Debug/signals/sigalarm2
I'm parent: 74574
I'm child: 74575, my parent ps info:
  UID   PID  PPID  PGID   SESS TTY      STAT COMM
  501 74574 49433 74574      0 ttys001  S+   ./Debug/signals/sigalarm2
sig_alrm handler: I'm: 74574
Alarm: Time out!

 */

static jmp_buf env;
static void sig_alrm(int signo) {
  longjmp(env, 1);
}

int main(void) {
  ...
  if (signal(SIGALRM, sig_alrm) == SIG_ERR) {
    my_perror("error: signal");
    return 1;
  }

  if (setjmp(env) != 0) { // Returns 0 first time, 1 if longjmp called
    printf("Time out!\n");
    return 1;
  }

  alarm(TIMEOUT);
  // slow I/O
  alarm(0);

...
}

int main(int argc, char *argv[]) {
  sigset_t mask, old, delta;
  sigemptyset(&old);
  sigprocmask(0, NULL, &old);             // get current masked signals
  pr_mask2("      Old Mask: ", &old);
  pr_mask ("  Current Mask: ");

  sigemptyset(&delta);
  sigaddset(&delta, SIGABRT);
  pr_mask2(" Block signals: ", &delta);
  sigprocmask(SIG_BLOCK, &delta, NULL);   // union of current and delta
  pr_mask ("  Current Mask: ");

  sigfillset(&mask);
  sigdelset(&mask, SIGABRT);              // remove SIGABRT from complete set
  pr_mask2("   Mask to set: ", &mask);
  sigprocmask(SIG_SETMASK, &mask, &old);  // set current to mask (exclude
                                          // SIGKILL & SIGSTOP)
  pr_mask ("  Current Mask: ");

  sigemptyset(&delta);
  sigaddset(&delta, SIGQUIT);
  pr_mask2("Unblock signal: ", &delta);
  sigprocmask(SIG_UNBLOCK, &delta, &old); // subtract delta from current
  pr_mask ("  Current Mask: ");

  sigemptyset(&delta);
  sigaddset(&delta, SIGSTOP);
  sigaddset(&delta, SIGKILL);
  pr_mask2(" Block signals: ", &delta);
  sigprocmask(SIG_BLOCK, &delta, &old);   // union of current and delta
                                          // (exclude SIGKILL & SIGSTOP)
  pr_mask ("  Current Mask: ");

  return 0;
}

/*

> Debug/signals/sigmask
      Old Mask:
  Current Mask:
 Block signals:  SIGABRT
  Current Mask:  SIGABRT
   Mask to set:  SIGINT SIGQUIT SIGUSR1 SIGUSR2 SIGALRM SIGTSTP SIGCHLD SIGKILL SIGSTOP
  Current Mask:  SIGINT SIGQUIT SIGUSR1 SIGUSR2 SIGALRM SIGTSTP SIGCHLD
Unblock signal:  SIGQUIT
  Current Mask:  SIGINT SIGUSR1 SIGUSR2 SIGALRM SIGTSTP SIGCHLD
 Block signals:  SIGKILL SIGSTOP
  Current Mask:  SIGINT SIGUSR1 SIGUSR2 SIGALRM SIGTSTP SIGCHLD

 */

static void sig_quit(int);

int main(void) {
  sigset_t newmask, oldmask, pendmask;

  if (signal(SIGQUIT, sig_quit) == SIG_ERR) err_sys("can't catch SIGQUIT");

  /*
   * Block SIGQUIT and save current signal mask.
   */
  sigemptyset(&newmask);
  sigaddset(&newmask, SIGQUIT);
  if (sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0)
    err_sys("SIG_BLOCK error");

  sleep(5); /* SIGQUIT here will remain pending */

  if (sigpending(&pendmask) < 0) err_sys("sigpending error");
  if (sigismember(&pendmask, SIGQUIT)) printf("\nSIGQUIT pending\n");

  /*
   * Restore signal mask which unblocks SIGQUIT.
   */
  if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0)
    err_sys("SIG_SETMASK error");
  printf("SIGQUIT unblocked\n");  // sig_quit runs before sigprocmask returns

  sleep(5); /* SIGQUIT here will terminate with core file */
  exit(0);
}

static void sig_quit(int signo) {
  printf("caught SIGQUIT\n");
  if (signal(SIGQUIT, SIG_DFL) == SIG_ERR) err_sys("can't reset SIGQUIT");
}

/*
$ ./a.out
ˆ\                          generate signal once (before 5 seconds are up)
SIGQUIT pending             after return from sleep
caught SIGQUIT              in signal handler
SIGQUIT unblocked           after return from sigprocmask
ˆ\Quit(coredump)            generate signal again
$ ./a.out
ˆ\ˆ\ˆ\ˆ\ˆ\ˆ\ˆ\ˆ\ˆ\ˆ\        generate signal 10 times (before 5 seconds are up)
SIGQUIT pending
caught SIGQUIT              signal is generated only once
SIGQUIT unblocked
ˆ\Quit(coredump)            generate signal again

 */

#include <signal.h>
int sigaction(int signo, const struct sigaction *restrict act,
              struct sigaction *restrict oact);
                                        // Returns: 0 if OK, −1 on error

struct  sigaction {
  union __sigaction_u __sigaction_u;    /* signal handler */
  sigset_t sa_mask;                     /* signal mask to apply */
  int     sa_flags;                     /* see signal options below */
};

union __sigaction_u {
  void (*__sa_handler)(int);
  void (*__sa_sigaction)(int, siginfo_t *, void *);
};

#define sa_handler      __sigaction_u.__sa_handler
#define sa_sigaction    __sigaction_u.__sa_sigaction

typedef struct __siginfo {
	int     si_signo;               /* signal number */
	int     si_errno;               /* errno association */
	int     si_code;                /* signal code */
	pid_t   si_pid;                 /* sending process */
	uid_t   si_uid;                 /* sender's ruid */
	int     si_status;              /* exit value */
	void    *si_addr;               /* faulting instruction */
	union sigval si_value;          /* signal value */
	long    si_band;                /* band event for SIGPOLL */
	unsigned long   __pad[7];       /* Reserved for Future Use */
} siginfo_t;

#include "apue.h"
/* Reliable version of signal(), using POSIX sigaction().  */
Sigfunc *
signal(int signo, Sigfunc *func)
{
  struct sigaction    act, oact;
  act.sa_handler = func;
  sigemptyset(&act.sa_mask);
  act.sa_flags = 0;
  if (signo == SIGALRM) {
#ifdef  SA_INTERRUPT
    act.sa_flags |= SA_INTERRUPT;
#endif
  } else {
    act.sa_flags |= SA_RESTART;
  }
  if (sigaction(signo, &act, &oact) < 0)
    return(SIG_ERR);
  return(oact.sa_handler);
}

void sig_intr(int);
void sig_usr1(int);

static volatile int intr_flag = 0;

int main(int argc, char *argv[]) {

  printf ("Let's examine how the signal mask of the process is changed:\n\n");

  struct sigaction act, oact;
  sigemptyset(&act.sa_mask); /* Initialize sa_mask to empty */
  act.sa_flags = 0;           /* Set flags to 0 for default behavior */
  act.sa_handler = sig_usr1;
  if (sigaction(SIGUSR1, &act, &oact) < 0) {
    my_perror("error: sigaction");
  } else {
    printf("Original signal handler for SIGUSR1: %p\n", oact.sa_handler);
  }

  Sigfunc *pOHand;
  if ((pOHand = signal(SIGINT, sig_intr)) == SIG_ERR) {
    my_perror("error: signal");
  } else {
    printf("Original signal handler for SIGINT: %p\n", pOHand);
  }

  sigset_t mask;
  sigemptyset(&mask);
  sigaddset(&mask, SIGABRT);
  sigaddset(&mask, SIGQUIT);
  sigaddset(&mask, SIGINT);
  sigprocmask(SIG_SETMASK, &mask, NULL);
  pr_mask("Main: initial setup signal mask after sigprocmask: ");

  while(1) {
    pause();
    if (intr_flag == 1) {
      sigemptyset(&mask);
      sigaddset(&mask, SIGINT);
      sigprocmask(SIG_UNBLOCK, &mask, NULL);
      pr_mask("Main: after sigprocmask, unblock SIGINT: ");
      intr_flag = 2;
    }
    pr_mask("Main: ");
  }

  return 0;
}

void sig_intr(int signo) {
  pr_mask("sig_intr: ");
  if (intr_flag == 3) {
    printf("exit(1111)\n");
    exit(1111); // normal exit: $? = status % 256 = 87
  }
}

void sig_usr1(int signo) {
  pr_mask("sig_usr1: ");
  if (intr_flag == 0) {
    printf("sig_usr1: change intr_flag to 1\n");
    intr_flag = 1;
  } else if (intr_flag == 2) {
    printf("sig_usr1: change intr_flag to 3\n");
    intr_flag = 3;
  } else {
    printf("sig_usr1: intr_flag is %d\n", intr_flag);
  }
}


/*

# Shell A:
> ./Debug/signals/sigmask2
Let's examine how the signal mask of the process is changed:

Original signal handler for SIGUSR1: 0x0
Original signal handler for SIGINT: 0x0
Main: initial setup signal mask after sigprocmask:  SIGINT SIGQUIT SIGABRT
^C^C^Csig_usr1:  SIGINT SIGQUIT SIGUSR1 SIGABRT   <-- kill -USR1 81753
sig_usr1: change intr_flag to 1
sig_intr:  SIGINT SIGQUIT SIGABRT                 <-- unblocked pending signal delivered before sigprocmask returns
Main: after sigprocmask, unblock SIGINT:  SIGQUIT SIGABRT
Main:  SIGQUIT SIGABRT
^Csig_intr:  SIGINT SIGQUIT SIGABRT               <-- avoid re-entrancy issue during the time of execution a handler
Main:  SIGQUIT SIGABRT
sig_usr1:  SIGQUIT SIGUSR1 SIGABRT                <-- kill -USR1 81753
sig_usr1: change intr_flag to 3
Main:  SIGQUIT SIGABRT
^Csig_intr:  SIGINT SIGQUIT SIGABRT
exit(1111)
> echo $?
87                                                <-- normal exit, status % 256

# Shell B:
> pgrep sigmask
81753
> kill -USR1 81753
> kill -USR1 81753

NOTE:
1. When a signal (e.g. SIGINT) is blocked, only one instance is recorded
   as pending after sending multiple <CTRL-C>s.
2. At least one of unblocked pending signals is selected to deliver before
   sigprocmask(2), which change the mask setting, returns.
3. During the execution of signal-catching handler, the signal causes it is
   temporarily added to the mask and removed after the execution, to avoid
   re-entrancy issue (recursive calls of the handler).
4. Two types of terminations and different shell return code:
   4.1 Normal `exit(n)`: rc = n % 256
   4.2 Terminated by signal: rc = 128 + <signal number>
 */

void sig_hand(int signo) {
  // just for test, shouldn't use non-reentrant `printf` in a signal handler
  printf("sig_hand: [%s] is caught by PID[%d].\n", strsignal(signo), getpid());
}

void non_restartable_syscall_test() {
  pid_t pid;
  if ((pid = fork()) < 0) {
    my_perror("error: fork");
  } else if (pid == 0) {  // child
    printf("Child[PID=%d]: blocking on pause()...\n", getpid());
    pause();  // not restartable
    printf("Child[PID=%d]: Exiting...\n", getpid());
    exit(0);
  } else {
    sleep(2);
    printf("Parent[PID=%d]: Send [%s] to Child[%d]\n",
        getpid(), strsignal(SIGINT), pid);
    kill(pid, SIGINT);
    wait(NULL);
    printf("Parent[PID=%d]: Exiting non_restartable_syscall_test()\n",
           getpid());
  }
}

void restartable_syscall_test() {
  pid_t pid;
  if ((pid = fork()) < 0) {
    my_perror("error: fork");
  } else if (pid == 0) {  // child
    char buf[BUFSIZ];
    size_t n;
    printf("Child[PID=%d]: blocking on read()...\n", getpid());
    while ((n = read(STDIN_FILENO, buf, sizeof(buf)-1)) > 0) {
      buf[n] = '\0';
      printf("Child[PID=%d]: Read %ld chars: [%s]\n", getpid(), n, buf);
    }
    if (n == 0) {
      printf("Child[PID=%d]: End of reading.\n", getpid());
      exit(0);
    } else {
      my_perror("Child[PID=%d]: error: read", getpid());
      exit(1);
    }
  } else {
    sleep(1);
    int exitFlag = 3;
    while (exitFlag-- > 0) {
      sleep(3);
      printf("Parent[%d]: Send [%s] to Child[%d]\n",
          getpid(), strsignal(SIGINT), pid);
      kill(pid, SIGINT);
    }
    sleep(1);
    printf("Parent[PID=%d]: Now wait() for the child."
           "Type <CTRL-D> to end the talk.\n\n", getpid());
    wait(NULL);
    printf("Parent[PID=%d]: Exiting estartable_syscall_test()\n", getpid());
  }
}

int main(int argc, char *argv[]) {
  struct sigaction act = {0}, oact = {0};
  act.sa_flags |= SA_RESTART;
  act.sa_handler = sig_hand;

  if (sigaction(SIGINT, &act, &oact) < 0) {
    my_perror("error: sigaction");
  }

  pr_sep_msg('-', 25, "non_restartable_syscall_test()");
  non_restartable_syscall_test();
  pr_sep_msg('-', 25, "restartable_syscall_test()");
  restartable_syscall_test();
  return 0;
}

/*
 * Sample:
> ./Debug/signals/sigaction
-------------------------  non_restartable_syscall_test()  -------------------------
Child[PID=65200]: blocking on pause()...
Parent[PID=65199]: Send [Interrupt: 2] to Child[65200]
sig_hand: [Interrupt: 2] is caught by PID[65200].
Child[PID=65200]: Exiting...
Parent[PID=65199]: Exiting non_restartable_syscall_test()
-------------------------  restartable_syscall_test()  -------------------------
Child[PID=65245]: blocking on read()...
Parent[65199]: Send [Interrupt: 2] to Child[65245]
sig_hand: [Interrupt: 2] is caught by PID[65245].
Parent[65199]: Send [Interrupt: 2] to Child[65245]
sig_hand: [Interrupt: 2] is caught by PID[65245].
Parent[65199]: Send [Interrupt: 2] to Child[65245]
sig_hand: [Interrupt: 2] is caught by PID[65245].
Parent[PID=65199]: Now wait() for the child.Type <CTRL-D> to end the talk.

Hello, world!
Child[PID=65245]: Read 14 chars: [Hello, world!
]
Hello, world!Child[PID=65245]: Read 13 chars: [Hello, world!]
The difference is: 1) first input ended with new line 2) 2nd input ended with <CTRL-D> (EOF).
Child[PID=65245]: Read 94 chars: [The difference is: 1) first input ended with new line 2) 2nd input ended with <CTRL-D> (EOF).
]
Child[PID=65245]: End of reading.
Parent[PID=65199]: Exiting estartable_syscall_test()
 */

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <dlfcn.h>

static void sig_alrm(int signo) {
  /* nothing to do, just returning wakes up sigsuspend() */

  /* Just for mark the difference for test */
  printf("sig_alrm\n");
}


unsigned int sleep(unsigned int seconds) {
  struct sigaction newact, oldact;
  sigset_t newmask, oldmask, suspmask;
  unsigned int unslept;

  /* set our handler, save previous information */
  newact.sa_handler = sig_alrm;
  sigemptyset(&newact.sa_mask);
  newact.sa_flags = 0;
  sigaction(SIGALRM, &newact, &oldact);

  /* block SIGALRM and save current signal mask */
  sigemptyset(&newmask);
  sigaddset(&newmask, SIGALRM);
  sigprocmask(SIG_BLOCK, &newmask, &oldmask);

  alarm(seconds);
  suspmask = oldmask;

  /* make sure SIGALRM isn't blocked */
  sigdelset(&suspmask, SIGALRM);

  /* wait for any signal to be caught */
  sigsuspend(&suspmask);

  /* some signal has been caught, SIGALRM is now blocked */

  unslept = alarm(0);

  /* reset previous action */
  sigaction(SIGALRM, &oldact, NULL);

  /* reset signal mask, which unblocks SIGALRM */
  sigprocmask(SIG_SETMASK, &oldmask, NULL);
  return (unslept);
}

int main(int argc, char *argv[]) {
  int timeout = 5;
  if (argc > 1) {
    int n = atoi(argv[1]);
    if (n > 0) timeout = n;
  }
  printf("Call local sleep(%d)\n", timeout);
  sleep(timeout);   // strong definition overrides weak alias of libc

  // unsigned int (*libc_sleep)(unsigned int) = NULL;
  __typeof(sleep) *libc_sleep = dlsym(RTLD_NEXT, "sleep");
  printf("Call the C standard library sleep(%d)\n", timeout);
  libc_sleep(timeout);
  return 0;
}

/*
> Debug/signals/sleep
Call local sleep(5)
sig_alrm
Call the C standard library sleep(5)
>
 */

#include <time.h>
int nanosleep(const struct timespec *reqtp, struct timespec *remtp);
         // Returns: 0 if slept for requested time or −1 on error

int
clock_nanosleep(clockid_t clock_id, int flags, const struct timespec *reqtp,
                struct timespec *remtp);
        // Returns: 0 if slept for requested time or error number on failure

clock_nanosleep(CLOCK_REALTIME, 0, reqtp, remtp);   // equivalent to
nanosleep(reqtp, remtp);

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void
abort(void)
{
    sigset_t
    struct sigaction    action;
    /* Caller can’t ignore SIGABRT, if so reset to default */
    sigaction(SIGABRT, NULL, &action);
    if (action.sa_handler == SIG_IGN) {
        action.sa_handler = SIG_DFL;
        sigaction(SIGABRT, &action, NULL);
    }
    if (action.sa_handler == SIG_DFL)
        fflush(NULL);           /* flush all open stdio streams */
    /* Caller can’t block SIGABRT; make sure it’s unblocked */
    sigfillset(&mask);
    sigdelset(&mask, SIGABRT);  /* mask has only SIGABRT turned off */
    sigprocmask(SIG_SETMASK, &mask, NULL);
    kill(getpid(), SIGABRT);    /* send the signal */
    /* If we’re here, process caught SIGABRT and returned */
    fflush(NULL);               /* flush all open stdio streams */
    action.sa_handler = SIG_DFL;
    sigaction(SIGABRT, &action, NULL);  /* reset to default */
    sigprocmask(SIG_SETMASK, &mask, NULL);  /* just in case ... */
    kill(getpid(), SIGABRT);                /* and one more time */
    exit(1);    /* this should never be executed ... */
}

#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <sys/_types/_pid_t.h>
#include <sys/errno.h>
#include <sys/signal.h>
#include <sys/wait.h>
#include <unistd.h>
#include "rltapue.h"

static const int CHILD_COUNT = 5;
volatile sig_atomic_t live_children = CHILD_COUNT;

void sigchld(int signo) {
  int save_err = errno;
  int stat;
  pid_t pid;
  while ((pid = waitpid(-1, &stat, WNOHANG)) > 0) {
    // printf() is not reentrant, async-signal-safe for use in signal handler
    // just for test in informal way
    printf("sigchld: Reap terminated child: %d\n", pid);
    live_children--;
  }
  errno = save_err;
}

int main(int argc, char *argv[]) {
  // sa_flags = 0, sa_handler / sigaction = NULL, sa_mask = 0
  struct sigaction act_chld = {0};
  sigemptyset(&act_chld.sa_mask); // For portability of sigset_t
  act_chld.sa_handler = sigchld;
  if (sigaction(SIGCHLD, &act_chld, NULL) < 0) {
    my_perror("error: sigaction");
  }


  for (int i = 0; i < CHILD_COUNT; i++) {
    pid_t pid;
    if ((pid = fork()) < 0) {
      my_perror("error: fork()");
    } else if (pid == 0) {
      printf("Child(%d): Enter >>>\n", getpid());
      sleep(i+1);
      printf("Child(%d): Exit <<<\n", getpid());
      exit(0);
    }
  }

  while (live_children > 0) {
    pause();
    printf ("Main: pause() was interrupted and now returned.\n");
  }
  return 0;
}

/**

> Debug/signals/waitpid
Child(78710): Enter >>>
Child(78711): Enter >>>
Child(78712): Enter >>>
Child(78713): Enter >>>
Child(78714): Enter >>>
Child(78710): Exit <<<
sigchld: Reap terminated child: 78710
Main: pause() was interrupted and now returned.
Child(78711): Exit <<<
sigchld: Reap terminated child: 78711
Main: pause() was interrupted and now returned.
Child(78712): Exit <<<
sigchld: Reap terminated child: 78712
Main: pause() was interrupted and now returned.
Child(78713): Exit <<<
sigchld: Reap terminated child: 78713
Main: pause() was interrupted and now returned.
Child(78714): Exit <<<
sigchld: Reap terminated child: 78714
Main: pause() was interrupted and now returned.
>

NOTE:

A. `pause(3)` workflow
1. `pause(3)` is called and the process sleeps.
2. A signal is delivered.
3. The operating system interrupts `pause(3)` and executes the registered
   signal handler.
4. The signal handler completes its execution and returns.
5. *Only then* does the `pause(3)` call, which was interrupted, return to the
   calling code.
If the handler calls `exit()` functions, the process just terminates w/o
returning from `pause(3)` to the calling code.

B. Reentrant and async-signal-safe calls in a signal handler

`printf(3)` is NOT reentrant, because it uses shared internal state:
   - Static/global buffers
   - Locks inside the stdio library
   - Heap allocation for formatting
   - Global variables like errno

Then it is not async-signal-safe. Example:
The main process is in the middle of `printf(3)`. Internally, libc has locked
a mutex on `stdout`'s buffer. Now a child dies, `SIGCHLD` arrives and handler
runs. In the handler, another call of `printf(3)` tries to lock the same mutex.
Since the lock is already held by the interrupted code (in `printf(3)`). Thus
deadlock happens. Besides, same `stdout` buffer can be corrupted.

 */

#include <errno.h>
#include <signal.h>
#include <sys/wait.h>
#include <unistd.h>

int system(const char *cmdstring) /* with appropriate signal handling */
{
  pid_t pid;
  int status;
  struct sigaction ignore, saveintr, savequit;
  sigset_t chldmask, savemask;

  if (cmdstring == NULL) return (1); /* always a command processor with UNIX */

  ignore.sa_handler = SIG_IGN; /* ignore SIGINT and SIGQUIT */
  sigemptyset(&ignore.sa_mask);
  ignore.sa_flags = 0;
  if (sigaction(SIGINT, &ignore, &saveintr) < 0) return (-1);
  if (sigaction(SIGQUIT, &ignore, &savequit) < 0) return (-1);
  sigemptyset(&chldmask); /* now block SIGCHLD */
  sigaddset(&chldmask, SIGCHLD);
  if (sigprocmask(SIG_BLOCK, &chldmask, &savemask) < 0) return (-1);

  if ((pid = fork()) < 0) {
    status = -1;         /* probably out of processes */
  } else if (pid == 0) { /* child */
    /* restore previous signal actions & reset signal mask */
    sigaction(SIGINT, &saveintr, NULL);
    sigaction(SIGQUIT, &savequit, NULL);
    sigprocmask(SIG_SETMASK, &savemask, NULL);

    execl("/bin/sh", "sh", "-c", cmdstring, (char *)0);
    _exit(127); /* exec error */
  } else {      /* parent */
    while (waitpid(pid, &status, 0) < 0)
      if (errno != EINTR) {
        status = -1; /* error other than EINTR from waitpid() */
        break;
      }
  }

  /* restore previous signal actions & reset signal mask */
  if (sigaction(SIGINT, &saveintr, NULL) < 0) return (-1);
  if (sigaction(SIGQUIT, &savequit, NULL) < 0) return (-1);
  if (sigprocmask(SIG_SETMASK, &savemask, NULL) < 0) return (-1);

  return (status);
}

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/signal.h>
#include "rltapue.h"

/**
 `system(3)` ignores SIGINT and SIGQUIT, blocks SIGCHLD
 */

void sig_hand(int signo) {
  printf("Caught signal[%d]=%s\n", signo, strsignal(signo));
}

int main(int argc, char *argv[]) {
  struct sigaction act = {0};
  sigemptyset(&act.sa_mask);
  act.sa_handler = sig_hand;
  if (sigaction(SIGINT, &act, NULL) < 0) {
    my_perror("error: sigaction: %d", SIGINT);
  }
  if (sigaction(SIGCHLD, &act, NULL) < 0) {
    my_perror("error: sigaction: %d", SIGCHLD);
  }
  if (sigaction(SIGUSR1, &act, NULL) < 0) {
    my_perror("error: sigaction: %d", SIGUSR1);
  }
  if (system("/bin/ed") < 0) {
    my_perror("error: system()");
  }

  pause();
  return 0;
}

/*

# Terminal A:
> Debug/signals/systemsig
a
hello
^C                                            <-- SIGINT only received by child
?                                             <-- and interrupts `ed` input
你好
?                                             <-- `ed` is in command mode
a                                             <-- needs `a` to resume appending
你好
Caught signal[30]=User defined signal 1: 30   <-- kill -USR1 89613, received by parent
Ciao
.
w out
18
q
^CCaught signal[2]=Interrupt: 2               <-- <CTRL-C> to interrupt parent pause()
> cat out
hello
你好
Ciao
>

# Terminal B:
> pgrep systemsig
89613
> kill -USR1 89613                            <-- caught by parent
> kill -INT 89613                             <-- ignored by parent
> kill -QUIT 89613                            <-- ignored by parent
> kill -CHLD 89613                            <-- blocked by parent
>

NOTE:
The above example illustrates:
1. In system(), the parent ignores SIGQUIT and SIGINT (via `sigaction(2)` and
   `(struct sigaction).sa_handler`). But the child running program via
   `exec()`, respects both.
2. In system(), parent blocks SIGCHLD (via `sigprocmask(2)`). When `ed` is
   running, received `SIGCHLD` is at pending state. When `ed` quits, the kernel
   sends another `SIGCHLD` to the parent. Standard (non-RT) signals are
   not queued, so two `SIGCHLD` collapse into one. And when `waitpid(2)` reaps
   the terminated child (`ed`), the kernel clears the pending `SIGCHLD` bit.
   Thus, even if `SIGCHLD` gets unblocked before `system()` returns, no active
   pending `SIGCHLD` left for the pause(). It keeps blocking until new signal
   arrives.
3. It needs `a` command for `ed` to resume appending mode after interruption.
4. In UTF-8 encoding, each Chinese character consists of 3 bytes.
 */

/**
 * NOTE:
 *
 * fflush() stream buffer BEFORE fork()!!! Otherwise there will be another
 * integer 0 written in the file.
 *
 * > hexdump tmp/data/signals/sharedfile
 * 0000000 001a 0000 0000 0000
 * 0000008
 *
 * Reason:
 *
 * The problem lies in the child's first run of incre_file() and how fseek()
 * interacts with the child's inherited, unflushed buffer.
 *
 * https://pubs.opengroup.org/onlinepubs/9799919799/functions/fopen.html
 *
 * "When a file is opened with update mode ('+' in the mode argument), both
 * input and output can be performed on the associated stream. However, the
 * application shall ensure that output is not directly followed by input
 * without an intervening call to fflush() or to a file positioning function
 * (fseek(), fsetpos(), or rewind()), and input is not directly followed by
 * output without an intervening call to a file positioning function, unless
 * the input operation encounters end-of-file."
 *
 * "If the stream is writable and buffered data had not been written to the
 * underlying file, fseek() shall cause the unwritten data to be written to
 * the file and shall mark the st_ctime and st_mtime fields of the file for
 * update."

 * fseek(pf, 0, SEEK_SET); (== rewind(pf);)
 *
 * 1. init_file() calls fwrite() to write an integer 0. If there's no
 * fflush(), this 0 sits in the stdio user-space buffer. When fork() is
 * called, both the parent and child processes inherit an identical copy of
 * this memory, which includes this unflushed buffer containing the integer 0

 * 2. The Parent's Turn:
 * fseek(pf, 0, SEEK_SET): The parent's stream has pending output (the 0 in
 * its buffer). To fulfill the fseek request, the stdio library must flush the
 * buffer first. At this point, the kernel file offset is at 0, so the 0 is
 * written to the start of the file. The file now contains 00 00 00 00. The
 * fseek then completes, leaving the offset at 0.

 * fread(): Reads the 0 from the file. The kernel's file offset is now at
 * position 4.

 * fseek(pf, 0, SEEK_SET): Rewinds the kernel offset back to 0.

 * fwrite(): The parent increments the value to 1 and writes it into its
 * buffer.

 * fflush(): The parent's buffer (containing 1) is written to the file at
 * offset 0, overwriting the original 0.

 * Result of Parent's Turn: The file on disk contains the 4-byte integer 1.
 * The shared kernel file offset is now at position 4.

 * 3. The Child's Turn (The Critical Moment) This is where the 8-byte problem
 * occurs, just as you reasoned.

 * Child Wakes Up: The child begins its first run of incre_file(). Crucially,
 * its stdio buffer still contains the original, stale integer 0 that it
 * inherited from before the fork().

 * fseek(pf, 0, SEEK_SET): The child's stream also has pending output (the
 * stale 0). To handle the seek, the stdio library must flush this buffer
 * first. But where does it flush? It flushes to the current kernel file
 * offset, which the parent just left at position 4.

 * The Append: The child's stale 0 is written to the file starting at
 * offset 4. The file now contains the integer 1 (from the parent) followed
 * by the integer 0 (from the child's stale buffer). The file is now 8 bytes
 * long.

 * The Rest of the Function: The fseek now completes, moving the kernel offset
 * to 0. The child then fread()s the integer 1 from the start of the file,
 * increments it to 2, seeks back to 0, and fwrite()s/fflush()es the 2,
 * overwriting the 1.

 * The Final Result After the first round, the file's contents are:

 * Bytes 0-3: The integer 2
 * Bytes 4-7: The integer 0
 *
 */

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

#include "rltapue.h"

FILE* init_file(const char *const path) {
  if (!path) return NULL;
  // Use "w+b" or "wb+" for binary read/write mode
  FILE *pf = fopen(path, "wb+");
  if (!pf) my_perror("error: fopen");

  int value = 0;
  if (fwrite(&value, sizeof(int), 1, pf) < 1) {
    if (feof(pf)) {
      printf("End of file reached.\n");
    } else if (ferror(pf)) {
      printf("Read error occurred (ferror set).\n");
    }
    my_perror("error: fwrite()");
  }
  fflush(pf); // !!! Flush the buffer to disk BEFORE fork() !!!
  return pf;
}

int incre_file(FILE *pf) {
  fseek(pf, 0, SEEK_SET); // move to the start before read, == rewind(pf);
  int value;
  if (fread(&value, sizeof(int), 1, pf) < 1) {
    if (feof(pf)) {
      printf("End of file reached.\n");
    } else if (ferror(pf)) {
      printf("Read error occurred (ferror set).\n");
    }
    my_perror("error: fwrite()");
  }
  printf("value: %d\n", value);

  fseek(pf, 0, SEEK_SET); // move to the start before write
  value++;
  if (fwrite(&value, sizeof(int), 1, pf) < 1) {
    if (feof(pf)) {
      printf("End of file reached.\n");
    } else if (ferror(pf)) {
      printf("Read error occurred (ferror set).\n");
    }
    my_perror("error: fwrite()");
  }
  fflush(pf);             // make sure push changes to disk
  return value;
}

void test(void) {
  const char *const file = "tmp/data/signals/sharedfile";
  FILE *pf = init_file(file);
  const int rounds = 13;
  TELL_WAIT();
  pid_t pid = fork();
  if (pid < 0) {
    my_perror("error: fork()");
  } else if (pid == 0) {  // child
    for (int i = 0; i < rounds; i++) {
      WAIT_PARENT();
      // critical section
      printf("Child: incrementing, value: %d\n", incre_file(pf));
      TELL_PARENT(getppid());
    }
    exit(0);
  } else {  // parent
    for (int i = 0; i < rounds; i++) {
      // critical section
      printf("Parent: incrementing, value: %d\n", incre_file(pf));
      TELL_CHILD(pid);
      WAIT_CHILD();
    }
  }
  fclose(pf);
}

int main(int argc, char **argv) {
  test();
  return 0;
}

/*

### Running in command line: stdout is line-buffered

> ./Debug/signals/Ex10_6_procsync
Parent: incrementing, value: 1
Child: incrementing, value: 2
Parent: incrementing, value: 3
Child: incrementing, value: 4
Parent: incrementing, value: 5
Child: incrementing, value: 6
Parent: incrementing, value: 7
Child: incrementing, value: 8
Parent: incrementing, value: 9
Child: incrementing, value: 10
Parent: incrementing, value: 11
Child: incrementing, value: 12
Parent: incrementing, value: 13
Child: incrementing, value: 14
Parent: incrementing, value: 15
Child: incrementing, value: 16
Parent: incrementing, value: 17
Child: incrementing, value: 18
Parent: incrementing, value: 19
Child: incrementing, value: 20
Parent: incrementing, value: 21
Child: incrementing, value: 22
Parent: incrementing, value: 23
Child: incrementing, value: 24
Parent: incrementing, value: 25
Child: incrementing, value: 26


### Running in Neovim command mode: stdout redirected to fully-buffered pipe

:!Debug/signals/Ex10_6_procsync
Child: incrementing, value: 2
Child: incrementing, value: 4
Child: incrementing, value: 6
Child: incrementing, value: 8
Child: incrementing, value: 10
Child: incrementing, value: 12
Child: incrementing, value: 14
Child: incrementing, value: 16
Child: incrementing, value: 18
Child: incrementing, value: 20
Child: incrementing, value: 22
Child: incrementing, value: 24
Child: incrementing, value: 26
Parent: incrementing, value: 1
Parent: incrementing, value: 3
Parent: incrementing, value: 5
Parent: incrementing, value: 7
Parent: incrementing, value: 9
Parent: incrementing, value: 11
Parent: incrementing, value: 13
Parent: incrementing, value: 15
Parent: incrementing, value: 17
Parent: incrementing, value: 19
Parent: incrementing, value: 21
Parent: incrementing, value: 23
Parent: incrementing, value: 25

Child exits first, its stdout buffer gets flushed first.
Parent waits for the child and exits later, stdout buffer gets flushed later.

### The content of sharedfile

> hexdump -C tmp/data/signals/sharedfile

00000000  1a 00 00 00                                       |....|
00000004
> hexdump tmp/data/signals/sharedfile

0000000 001a 0000
0000004

001a -> 26, the value is correct.

*/