Linux Sinyalleri —
sigaction, masking, graceful shutdown.

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 ... 64) SIGRTMAX

# nginx log rotation: önce log dosyalarını rotate et, sonra sinyal gönder
mv /var/log/nginx/access.log /var/log/nginx/access.log.1
kill -SIGUSR1 $(cat /var/run/nginx.pid)
# nginx yeni access.log açar, eski dosya kapatılır

# pidof ile: çalışan prosese sinyal gönder
kill -SIGUSR1 $(pidof nginx)

# SIGUSR2 ile config reload (uygulama bunu destekliyorsa)
kill -SIGUSR2 $(pidof myapp)

#include <signal.h>

/* struct sigaction alanları */
struct sigaction {
    void     (*sa_handler)(int);           /* basit handler */
    void     (*sa_sigaction)(int, siginfo_t *, void *); /* SA_SIGINFO ile */
    sigset_t   sa_mask;                     /* handler çalışırken blokla */
    int        sa_flags;                    /* SA_RESTART vb. */
    void     (*sa_restorer)(void);          /* dahili, kullanma */
};

/* imza */
int sigaction(int signum,
              const struct sigaction *act,
              struct sigaction *oldact); /* eski handler'ı kaydet */

#include <signal.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

static void term_handler(int sig) {
    /* Bu bölümde ne yazılmalı — s3'te detaylandırılıyor */
    (void)sig;
}

int setup_signals(void) {
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));

    sa.sa_handler = term_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;  /* sistem çağrılarını yeniden başlat */

    if (sigaction(SIGTERM, &sa, NULL) != 0) {
        perror("sigaction SIGTERM");
        return -1;
    }
    if (sigaction(SIGINT, &sa, NULL) != 0) {
        perror("sigaction SIGINT");
        return -1;
    }

    /* SIGPIPE: yazılan pipe kapanınca crash yerine hata kodu dönsün */
    sa.sa_handler = SIG_IGN;
    sigaction(SIGPIPE, &sa, NULL);

    return 0;
}

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

/* volatile: derleyici optimize etmesin; sig_atomic_t: atomik okuma/yazma */
static volatile sig_atomic_t g_shutdown = 0;
static volatile sig_atomic_t g_reload   = 0;

static void handle_term(int sig) {
    (void)sig;
    g_shutdown = 1; /* tek ve güvenli işlem */
}

static void handle_usr1(int sig) {
    (void)sig;
    g_reload = 1;
}

static int setup_signals(void) {
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;

    sa.sa_handler = handle_term;
    sigaction(SIGTERM, &sa, NULL);
    sigaction(SIGINT,  &sa, NULL);

    sa.sa_handler = handle_usr1;
    sigaction(SIGUSR1, &sa, NULL);

    return 0;
}

static void do_reload(void) {
    /* burası normal akışta çalışır — malloc, printf hepsi serbest */
    printf("Config yeniden yükleniyor...\n");
}

int main(void) {
    setup_signals();
    printf("PID: %d — SIGTERM veya SIGINT ile durdurun\n", getpid());

    while (!g_shutdown) {
        if (g_reload) {
            g_reload = 0;
            do_reload(); /* normal akışta güvenli */
        }
        /* asıl iş burada */
        sleep(1);
    }

    printf("Kapatılıyor...\n");
    return 0;
}

#include <signal.h>

/* sinyal seti oluşturma */
sigset_t mask, oldmask;
sigemptyset(&mask);             /* boş set */
sigfillset(&mask);              /* tüm sinyaller */
sigaddset(&mask, SIGTERM);     /* belirli sinyal ekle */
sigdelset(&mask, SIGTERM);     /* belirli sinyal çıkar */
sigismember(&mask, SIGTERM);   /* üye mi? → 1/0 */

/* mask uygula */
sigprocmask(SIG_BLOCK,   &mask, &oldmask); /* ekle, eskiyi kaydet */
sigprocmask(SIG_UNBLOCK, &mask, NULL);    /* kaldır */
sigprocmask(SIG_SETMASK, &mask, NULL);    /* tam değiştir */

/* kritik bölüm: SIGTERM gelirse pending'de beklesin */
sigprocmask(SIG_BLOCK, &mask, &oldmask);
    /* ... kritik işlem ... */
sigprocmask(SIG_SETMASK, &oldmask, NULL); /* eski mask'e dön */

#include <signal.h>
#include <stdio.h>

sigset_t pending;
sigpending(&pending); /* mevcut pending sinyalleri al */

if (sigismember(&pending, SIGTERM)) {
    printf("SIGTERM pending — mask kaldırıldığında teslim edilecek\n");
}

#include <signal.h>

sigset_t wait_mask;
sigemptyset(&wait_mask);
/* SIGTERM dışındaki her şeyi blokla ve sinyal bekle */
sigfillset(&wait_mask);
sigdelset(&wait_mask, SIGTERM);

/* atomik: mask'i uygula + uyku, sinyal gelince dön */
sigsuspend(&wait_mask); /* her zaman -1 döndürür, errno=EINTR */

#include <signal.h>
#include <pthread.h>

void *worker_thread(void *arg) {
    sigset_t mask;
    sigfillset(&mask); /* bu thread tüm sinyalleri bloklar */
    pthread_sigmask(SIG_BLOCK, &mask, NULL);
    /* sinyaller yalnızca main thread'e teslim edilir */
    return NULL;
}

int main(void) {
    /* main thread: sinyalleri dinler */
    pthread_t t;
    pthread_create(&t, NULL, worker_thread, NULL);
    /* ... signal handling burada ... */
    return 0;
}

# nazik sonlandırma — process'e SIGTERM gönder
kill <PID>          # varsayılan: SIGTERM
kill -SIGTERM <PID>  # açık
kill -15 <PID>       # numarası ile

# 5 saniye bekle, hâlâ çalışıyorsa SIGKILL
kill -SIGTERM <PID>
sleep 5
if kill -0 <PID> 2>/dev/null; then
    kill -SIGKILL <PID>  # son çare
fi

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

static void cleanup_db(void) {
    printf("DB bağlantısı kapatılıyor\n");
}

static void remove_pidfile(void) {
    unlink("/var/run/myapp.pid");
}

int main(void) {
    /* atexit: exit() veya return çağrısında çalışır */
    /* Kayıt sırası LIFO: en son kayıt ilk çalışır */
    atexit(remove_pidfile); /* 2. çalışır */
    atexit(cleanup_db);    /* 1. çalışır */

    /* NOT: atexit _exit() veya SIGKILL'de çalışmaz */
    return 0;
}

# zombie'leri görmek
ps aux | grep " Z "
pstree -p  # ağaç yapısında — <defunct> = zombie

#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>

/* belirli bir child bekle — bloklayan */
pid_t pid = fork();
if (pid == 0) { _exit(42); }   /* child */

int status;
waitpid(pid, &status, 0);         /* blokla: child bitene kadar bekle */
if (WIFEXITED(status))
    printf("exit: %d\n", WEXITSTATUS(status));  /* 42 */

/* tüm child'ları non-blocking topla (SIGCHLD handler içinde) */
while (waitpid(-1, NULL, WNOHANG) > 0)
    ;  /* daha fazla zombie kalmayınca -1 döner */

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

static void sigchld_handler(int sig) {
    (void)sig;
    int saved_errno = errno; /* handler errno'yu bozabilir */
    while (waitpid(-1, NULL, WNOHANG) > 0)
        ;
    errno = saved_errno;
}

/* setup */
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = sigchld_handler;
sa.sa_flags   = SA_RESTART | SA_NOCLDSTOP; /* yalnızca exit, stop değil */
sigaction(SIGCHLD, &sa, NULL);

/* SA_NOCLDWAIT: child'lar zombie olmadan doğrudan silinir
   SIGCHLD hâlâ üretilir ama waitpid() gerek kalmaz */
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_DFL;
sa.sa_flags   = SA_NOCLDWAIT;
sigaction(SIGCHLD, &sa, NULL);

/* Linux'ta signal(SIGCHLD, SIG_IGN) de zombie önler ama POSIX garantisi yok */
signal(SIGCHLD, SIG_IGN); /* çalışır ama taşınabilir değil */

/* gcc -o daemon daemon.c
   Derle: gcc -Wall -Wextra -o daemon daemon.c */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <fcntl.h>
#include <errno.h>
#include <poll.h>
#include <sys/wait.h>
#include <sys/stat.h>

#define PID_FILE "/var/run/mydaemon.pid"

static volatile sig_atomic_t g_shutdown = 0;
static volatile sig_atomic_t g_reload   = 0;

/* ─── signal handlers ─────────────────────────────── */

static void handle_term(int sig) { (void)sig; g_shutdown = 1; }
static void handle_usr1(int sig) { (void)sig; g_reload   = 1; }

static void handle_chld(int sig) {
    (void)sig;
    int saved = errno;
    while (waitpid(-1, NULL, WNOHANG) > 0) ;
    errno = saved;
}

/* ─── PID file ────────────────────────────────────── */

static int write_pidfile(void) {
    int fd = open(PID_FILE,
                   O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd < 0) { perror("open pid"); return -1; }
    char buf[32];
    int n = snprintf(buf, sizeof(buf), "%d\n", getpid());
    write(fd, buf, n);
    close(fd);
    return 0;
}

static void remove_pidfile(void) {
    unlink(PID_FILE);
}

/* ─── cleanup ─────────────────────────────────────── */

static void cleanup(void) {
    remove_pidfile();
    /* flush buffers, close DB, release locks... */
    printf("[daemon] temizlendi, çıkılıyor.\n");
}

/* ─── signal setup ────────────────────────────────── */

static void setup_signals(void) {
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;

    sa.sa_handler = handle_term;
    sigaction(SIGTERM, &sa, NULL);
    sigaction(SIGINT,  &sa, NULL);

    sa.sa_handler = handle_usr1;
    sigaction(SIGUSR1, &sa, NULL);

    sa.sa_handler = handle_chld;
    sa.sa_flags  |= SA_NOCLDSTOP;
    sigaction(SIGCHLD, &sa, NULL);

    sa.sa_handler = SIG_IGN;
    sa.sa_flags   = 0;
    sigaction(SIGPIPE, &sa, NULL);
}

/* ─── main ────────────────────────────────────────── */

int main(void) {
    if (write_pidfile() != 0) return 1;
    atexit(remove_pidfile);
    setup_signals();

    printf("[daemon] başladı, PID=%d\n", getpid());

    /* systemd Type=notify ile entegrasyon */
    /* sd_notify(0, "READY=1"); */

    struct pollfd pfd = { .fd = -1, .events = 0 };

    while (!g_shutdown) {
        int ret = poll(&pfd, 1, 1000); /* 1s timeout */

        if (ret < 0 && errno != EINTR) {
            perror("poll");
            break;
        }

        if (g_reload) {
            g_reload = 0;
            printf("[daemon] SIGUSR1 — config reload\n");
            /* load_config() burada */
        }

        /* periyodik iş */
        printf("[daemon] çalışıyor...\n");
    }

    cleanup();
    return 0;
}

[Unit]
Description=Signal-safe örnek daemon
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/daemon
ExecReload=/bin/kill -SIGUSR1 $MAINPID
Restart=on-failure
RestartSec=5s
TimeoutStopSec=10s

[Install]
WantedBy=multi-user.target