/* Powrót do opisu ogólnego */
/* Plik linux/arch/i386/kernel/signal.c - obsługa sygnalów, procedury zależne
od architektury. Komentarz: Andrzej Nagórko */
* linux/arch/i386/kernel/signal.c
*
* Copyright (C) 1991, 1992 Linus Torvalds
*/
/*----------------------------------------------------------------------*
| W tym pliku zaimplementowane zostały dwie funkcje systemowe |
| (sigreturn i sigsuspend) oraz podstawowa funkcja mechanizmu obsługi |
| sygnałów - do_signal. |
*----------------------------------------------------------------------*/
#include < linux/config.h>
#include < linux/sched.h>
#include < linux/mm.h>
#include < linux/kernel.h>
#include < linux/signal.h>
#include < linux/errno.h>
#include < linux/wait.h>
#include < linux/ptrace.h>
#include < linux/unistd.h>
#include < asm/segment.h>
// makro zamieniające numer sygnału na jego maskę bitową.
#define _S(nr) (1<<((nr)-1))
// Maska sygnałów które można blokować: 1 - można, 0 - nie można.
#define _BLOCKABLE (~(_S(SIGKILL) | _S(SIGSTOP)))
asmlinkage int sys_waitpid(pid_t pid,unsigned long * stat_addr, int options);
asmlinkage int do_signal(unsigned long oldmask, struct pt_regs * regs);
/*
* atomically swap in the new signal mask, and wait for a signal.
*/
/*--------------------------------------------------------------------------*
| Funkcja systemowa sigsuspend. |
| Wymienia maskę blokowania sygnałów aktualnego procesu na set i usypia |
| proces (czeka na nieblokowane sygnały). Procesu nie zbudzą też sygnały |
| dla których ustawiona jest domyślna akcja lub ignorowanie. |
*--------------------------------------------------------------------------*/
asmlinkage int sys_sigsuspend(int restart, unsigned long oldmask, unsigned long set)
{
unsigned long mask;
struct pt_regs * regs = (struct pt_regs *) &restart;
// wymieniamy maskę sygnałów na podaną w zmiennej set
mask = current->blocked;
current->blocked = set & _BLOCKABLE;
// do procesu z tej funkcji powracamy tylko z wartoscią -EINTR, wywoływany
// jest wczesniej jednak handler obsługi sygnału. Stad konieczność
// przekazania powrotnej wartośći w ten sposób - wstawiając bezposrednio do
// rejestru
regs->eax = -EINTR;
// czekamy na sygnał dla ktorego konieczne jest wywolanie handlera
// użytkownika
while (1) {
// przechodzimy w stan spoczynku
current->state = TASK_INTERRUPTIBLE;
// i oddajemy procesor
schedule();
// zostalismy obudzeni, czyli przyszedł sygnał. Wołamy więc funkcję
// do_signal. Zwróci ona wartość <> 0 jezeli nastąpi konieczność obsługi
// sygnału przez handler użytkownika (patrz treść funkcji do_signal).
// Jednocześnie na stosie będzie już gotowe wywołanie procedury obsługi
// sygnału, czyli instrukcja return wywoła tą procedurę.
if (do_signal(mask,regs))
return -EINTR;
}
}
/*---------------------------------------------------------------------------*
| restore_i387 - odtwarzanie stanu (emulatora) koprocesora - używane przez |
| funkcję sigreturn. |
*---------------------------------------------------------------------------*/
static inline void restore_i387_hard(struct _fpstate *buf)
{
#ifdef __SMP__
if (current->flags & PF_USEDFPU) {
stts();
}
#else
if (current == last_task_used_math) {
last_task_used_math = NULL;
stts();
}
#endif
current->used_math = 1;
current->flags &= ~PF_USEDFPU;
memcpy_fromfs(¤t->tss.i387.hard, buf, sizeof(*buf));
}
static void restore_i387(struct _fpstate *buf)
{
// jeżeli jądro jest kompilowane bez emulatora koprocesora - zakładamy, że
// koprocesor jest zainstalowany
#ifndef CONFIG_MATH_EMULATION
restore_i387_hard(buf);
#else
// w przeciwnym przypadku sprawdzamy czy jest koprocesor; jak jest -
// odpalamy restore_i387_hard, jak nie - restore_i387_soft (implementacja
// w pliku arch/i386/math-emu/fpu_entry.c)
if (hard_math) {
restore_i387_hard(buf);
return;
}
restore_i387_soft(buf);
#endif
}
/*
* This sets regs->esp even though we don't actually use sigstacks yet..
*/
/*--------------------------------------------------------------------------*
| funkcja systemowa sigreturn - uruchamiana zawsze przy powrocie z |
| procedury obsługi sygnału (porownaj z funkcją setup_frame). Odtwarza |
| oryginalną maskę blokowania sygnałow procesu, stan koprocesora i kończy |
| obsługę procedury systemowej. Oczywiście po zakończeniu zaraz zostanie |
| wywołana procedura do_signal, co zapewnia obsłuzenie wszystkich |
| czekających sygnałow za jednym razem. Jako parametr przekazywane jest |
| miejsce na stosie w ktorym znajdują się stare wartości rejestrów. |
| Dziwna nazwa parametru (__unused) bierze się stąd, że jego znaczenie |
| jest różne w różnych architekturach i funkcja ta nie jest przeznaczona |
| do bezpośredniego wołania przez programy użytkownika. |
*--------------------------------------------------------------------------*/
asmlinkage int sys_sigreturn(unsigned long __unused)
{
#define COPY(x) regs->x = context.x
#define COPY_SEG(x) \
if ((context.x & 0xfffc) && (context.x & 3) != 3) goto badframe; COPY(x);
#define COPY_SEG_STRICT(x) \
if (!(context.x & 0xfffc) || (context.x & 3) != 3) goto badframe; COPY(x);
struct sigcontext_struct context;
struct pt_regs * regs;
// Ten kawałek kodu kopiuje wartośći rejestrów z pol wskazanych przez
// zmienną __unused do pól struktury pt_regs. Zajmuje to tyle miejsca
// bo trzeba dokonać konwersji z formatu zgodnego z iBCS2 na format
// pt_regs. Jednocześnie sprawdzana jest poprawność ramki __unused.
regs = (struct pt_regs *) &__unused;
if (verify_area(VERIFY_READ, (void *) regs->esp, sizeof(context)))
goto badframe;
memcpy_fromfs(&context,(void *) regs->esp, sizeof(context));
current->blocked = context.oldmask & _BLOCKABLE;
COPY_SEG(ds);
COPY_SEG(es);
COPY_SEG(fs);
COPY_SEG(gs);
COPY_SEG_STRICT(ss);
COPY_SEG_STRICT(cs);
COPY(eip);
COPY(ecx); COPY(edx);
COPY(ebx);
COPY(esp); COPY(ebp);
COPY(edi); COPY(esi);
regs->eflags &= ~0x40DD5;
regs->eflags |= context.eflags & 0x40DD5;
// wartość orig_eax jest to oryginalna wartość eax przkazywana przez
// proces wołajacy procedurę systemową (patrz entry.S). Jego wartość
// jest wykorzystywana między innymi przez funkcję handle_signal.
regs->orig_eax = -1; /* disable syscall checks */
if (context.fpstate) {
struct _fpstate * buf = context.fpstate;
if (verify_area(VERIFY_READ, buf, sizeof(*buf)))
goto badframe;
restore_i387(buf);
}
return context.eax;
badframe:
do_exit(SIGSEGV);
}
/*--------------------------------------------------------------------------*
| Procedury zachowujące stan koprocesora (emulatora koprocesora). Funkcja |
| save_i387_soft zaimplementowana jest w pliku arch/i386/math-emu/ |
| fpu_entry.c |
*--------------------------------------------------------------------------*/
static inline struct _fpstate * save_i387_hard(struct _fpstate * buf)
{
#ifdef __SMP__
if (current->flags & PF_USEDFPU) {
__asm__ __volatile__("fnsave %0":"=m" (current->tss.i387.hard));
stts();
current->flags &= ~PF_USEDFPU;
}
#else
if (current == last_task_used_math) {
__asm__ __volatile__("fnsave %0":"=m" (current->tss.i387.hard));
last_task_used_math = NULL;
__asm__ __volatile__("fwait"); /* not needed on 486+ */
stts();
}
#endif
current->tss.i387.hard.status = current->tss.i387.hard.swd;
memcpy_tofs(buf, ¤t->tss.i387.hard, sizeof(*buf));
current->used_math = 0;
return buf;
}
static struct _fpstate * save_i387(struct _fpstate * buf)
{
// sprawdzenie czy używamy emulatora czy nie - patrz restore_i387
if (!current->used_math)
return NULL;
#ifndef CONFIG_MATH_EMULATION
return save_i387_hard(buf);
#else
if (hard_math)
return save_i387_hard(buf);
return save_i387_soft(buf);
#endif
}
/*
* Set up a signal frame... Make the stack look the way iBCS2 expects
* it to look.
*/
/*--------------------------------------------------------------------------*
| funkcja setup_frame - ustawienie stosu tak, aby po wyjśćiu z procedury |
| systemowej zostal wykonany handler sygnału signr a po zakończeniu jego |
| wykonywania funkcja systemowa sigreturn. Wartośći na stosie ustawiane |
| są zgodnie ze specyfikacją iBCS2 (Intel Binary Compatibility |
| Specification). |
*--------------------------------------------------------------------------*/
static void setup_frame(struct sigaction * sa,
struct pt_regs * regs, int signr,
unsigned long oldmask)
{
unsigned long * frame;
frame = (unsigned long *) regs->esp;
if (regs->ss != USER_DS && sa->sa_restorer)
frame = (unsigned long *) sa->sa_restorer;
// robimy miejsce na stosie i sprawdzamy czy nie wyszlismy przy tym poza
// segment stosu
frame -= 64;
if (verify_area(VERIFY_WRITE,frame,64*4))
do_exit(SIGSEGV);
// zapamietanie wszystkich rejestrów na stosie
/* set up the "normal" stack seen by the signal handler (iBCS2) */
#define __CODE ((unsigned long)(frame+24))
#define CODE(x) ((unsigned long *) ((x)+__CODE))
put_user(__CODE,frame);
if (current->exec_domain && current->exec_domain->signal_invmap)
put_user(current->exec_domain->signal_invmap[signr], frame+1);
else
put_user(signr, frame+1);
put_user(regs->gs, frame+2);
put_user(regs->fs, frame+3);
put_user(regs->es, frame+4);
put_user(regs->ds, frame+5);
put_user(regs->edi, frame+6);
put_user(regs->esi, frame+7);
put_user(regs->ebp, frame+8);
put_user(regs->esp, frame+9);
put_user(regs->ebx, frame+10);
put_user(regs->edx, frame+11);
put_user(regs->ecx, frame+12);
put_user(regs->eax, frame+13);
put_user(current->tss.trap_no, frame+14);
put_user(current->tss.error_code, frame+15);
put_user(regs->eip, frame+16);
put_user(regs->cs, frame+17);
put_user(regs->eflags, frame+18);
put_user(regs->esp, frame+19);
put_user(regs->ss, frame+20);
put_user(save_i387((struct _fpstate *)(frame+32)),frame+21);
/* non-iBCS2 extensions.. */
// zapamietanie parametrów dla funkcji sigreturn i zapisanie
// instrukcji wywołujacych ją.
put_user(oldmask, frame+22);
put_user(current->tss.cr2, frame+23);
/* set up the return code... */
put_user(0x0000b858, CODE(0)); /* popl %eax ; movl $,%eax */
put_user(0x80cd0000, CODE(4)); /* int $0x80 */
put_user(__NR_sigreturn, CODE(2));
#undef __CODE
#undef CODE
// ustawienie rejestrów dla handlera sygnałów (porównaj
// RESTORE_ALL w entry.S)
/* Set up registers for signal handler */
regs->esp = (unsigned long) frame;
regs->eip = (unsigned long) sa->sa_handler;
regs->cs = USER_CS; regs->ss = USER_DS;
regs->ds = USER_DS; regs->es = USER_DS;
regs->gs = USER_DS; regs->fs = USER_DS;
regs->eflags &= ~TF_MASK;
}
/*
* OK, we're invoking a handler
*/
/*--------------------------------------------------------------------------*
| handle_signal - funkcja przygotowująca wywołanie procedury obsługi |
| sygnału. Przygotowanie obejmuje ustawienie restartu funkcji systemowej |
| po zakończeniu obsługi sygnału. Porownaj funkcje systemowe sigreturn i |
| siginterrupt. Obsluguje też flagi ONESHOT i NOMASK (porównaj manual do |
| funkcji sigaction). |
*--------------------------------------------------------------------------*/
static void handle_signal(unsigned long signr, struct sigaction *sa,
unsigned long oldmask, struct pt_regs * regs)
{
/* are we from a system call? */
if (regs->orig_eax >= 0) {
/* If so, check system call restarting.. */
// sprawdzamy jak system ma się zachować: czy funkcje systemowe
// maja byc restartowane, czy nie (wtedy funkcja systemowa zwraca
// bład EINTR - wykonanie funkcji przerwane przez sygnał). Domyślnym
// zachowaniem Linuxa jest restartowanie funkcji systemowych.
switch (regs->eax) {
case -ERESTARTNOHAND:
regs->eax = -EINTR;
break;
case -ERESTARTSYS:
if (!(sa->sa_flags & SA_RESTART)) {
// wyzerowanie flagi SA_RESTART w polu sa_flags oznacza, że sygnał
// przerywa wykonywanie funkcji systemowej
regs->eax = -EINTR;
break;
}
/* fallthrough */
// odtwarzamy parametr przekazywany przez eax i cofamy się o jedna
// instrukcję (int 0x80 zajmuje 2 bajty)
case -ERESTARTNOINTR:
regs->eax = regs->orig_eax;
regs->eip -= 2;
}
}
// ustawiamy stos - patrz opis setup_frame
setup_frame(sa, regs, signr, oldmask);
// flaga ONESHOT oznacza, że procedura obsługi sygnału wykorzystywana
// ma byc tylko raz (po wywolaniu handlera przywracane jest domyslne
// znaczenie sygnału)
if (sa->sa_flags & SA_ONESHOT)
sa->sa_handler = NULL;
// brak flagi NOMASK oznacza blokowanie sygnału póki wykonywana
// jest procedura jego obsługi z poprzedniego zgłoszenia.
if (!(sa->sa_flags & SA_NOMASK))
current->blocked |= (sa->sa_mask | _S(signr)) & _BLOCKABLE;
}
/*
* Note that 'init' is a special process: it doesn't get signals it doesn't
* want to handle. Thus you cannot kill init even with a SIGKILL even by
* mistake.
*
* Note that we go through the signals twice: once to check the signals that
* the kernel can handle, and then we build all the user-level signal handling
* stack-frames in one go after that.
*/
/*---------------------------------------------------------------------------*
| Wyszukanie i obsługa nie zablokowanych sygnałow, z uwzglednieniem |
| możliwych optymalizacji (w przypadku sygnałow którym przypisano domyślne |
| akcje). Parametry: |
| oldmask - służy do odtworzenia oryginalnej maski sygnałow procesu. |
| Trzeba to zrobić po obsłudze sygnałow bo każdy handler wywoływany jest z |
| własną maską. |
| pt_regs - stan (rejestry) procesu sprzed wywołania funkcji systemowej. |
| |
*---------------------------------------------------------------------------*/
asmlinkage int do_signal(unsigned long oldmask, struct pt_regs * regs)
{
// maska nieblokowanych sygnałów
unsigned long mask = ~current->blocked;
unsigned long signr;
struct sigaction * sa;
// Pod zmienną signr podstawia maskę nieobsłużonych i nieblokowanych
// sygnałów. Zakończy wykonywanie pętli gdy takich już nie bedzię (czyli
// signr przyjmie wartość 0).
while ((signr = current->signal & mask)) {
/*
* This stops gcc flipping out. Otherwise the assembler
* including volatiles for the inline function to get
* current combined with this gets it confused.
*/
// wybiera numer nieobsłużonego sygnału
struct task_struct *t=current;
__asm__("bsf %3,%1\n\t"
"btrl %1,%0"
:"=m" (t->signal),"=r" (signr)
:"0" (t->signal), "1" (signr));
sa = current->sig->action + signr;
signr++;
// gdy proces jest śledzony kazdy sygnał (oprocz SIGKILL) przez niego odebrany
// zatrzymuje jego wykonywanie. Jednocześnie wysylany jest komunikat do
// procesu śledzącego (rodzica). Więcej informacji znajdziesz w opisie ogólnym
// i manualu do funkcji ptrace
if ((current->flags & PF_PTRACED) && signr != SIGKILL) {
current->exit_code = signr;
current->state = TASK_STOPPED;
notify_parent(current);
schedule();
// po wznowieniu wyknoywania procesu z pola exit_code wyciągamy numer
// sygnału ktory spowodował zatrzymanie i obsługujemy go
if (!(signr = current->exit_code))
continue;
// raz starczy
current->exit_code = 0;
// SIGSTOP już oczywiście nie obsługujemy
if (signr == SIGSTOP)
continue;
// jezeli sygnał jest teraz blokowany wstawiamy go do pola signal
// jako sygnał czekający na obsłużenie
if (_S(signr) & current->blocked) {
current->signal |= _S(signr);
continue;
}
// uaktualniamy pole sa - dalsza cześć kodu zadziała jakby nie było
// śledzenia
sa = current->sig->action + signr - 1;
}
// optymalizacja - jeżeli sygnał jest ignorowany i jest różny od SIGCHLD
// nie robimy nic
if (sa->sa_handler == SIG_IGN) {
if (signr != SIGCHLD)
continue;
// gdy ignorowany sygnał to SIGCHLD "odbieramy" po kolei wszystkie
// numery dzieci, które zakończyły działanie i przechodzimy do obsługi
// dalszych sygnałow
/* check for SIGCHLD: it's special */
while (sys_waitpid(-1,NULL,WNOHANG) > 0)
/* nothing */;
continue;
}
// jeżeli ustawiona jest domyślna obsługa sygnału
if (sa->sa_handler == SIG_DFL) {
// proces nr 1 nie obsługuje żadnych sygnałow
if (current->pid == 1)
continue;
// domyślna akcja zależy od tego który to sygnał:
switch (signr) {
// te sygnały ignorujemy (zauważ, że proces został uprzednio obudzony
// do obsługi sygnału więc sygnał SIGCONT już został obsłużony)
case SIGCONT: case SIGCHLD: case SIGWINCH:
continue;
// jeżeli proces sterujący terminalem żyje domyslną akcją tych
// sygnałow jest zatrzymanie procesu
case SIGTSTP: case SIGTTIN: case SIGTTOU:
if (is_orphaned_pgrp(current->pgrp))
continue;
// zatrzymanie procesu
case SIGSTOP:
if (current->flags & PF_PTRACED)
continue;
current->state = TASK_STOPPED;
// w polu exit_code procesu pamiętany jest numer sygnału ktory go
// zatrzymal
current->exit_code = signr;
// jeżeli ojciec ma ustawioną flagę NOCLDSTOP nie informujemy go o
// zatrzymaniu dziecka, jak nie ma - informujemy (sygnałem SIGCHLD)
if (!(current->p_pptr->sig->action[SIGCHLD-1].sa_flags &
SA_NOCLDSTOP))
notify_parent(current);
// usypiamy
schedule();
continue;
// domyślna akcją dla tych sygnałow jest zrzucenie pamięci na dysk i
// zabicie procesu
case SIGQUIT: case SIGILL: case SIGTRAP:
case SIGABRT: case SIGFPE: case SIGSEGV:
if (current->binfmt && current->binfmt->core_dump) {
if (current->binfmt->core_dump(signr, regs))
signr |= 0x80;
}
/* fall through */
// wszystkie inne sygnały domyślnie kończą proces
default:
current->signal |= _S(signr & 0x7f);
current->flags |= PF_SIGNALED;
do_exit(signr);
}
}
// nie ma domyślnej akcji dla sygnału - wywołaj procedurę użytkownika
handle_signal(signr, sa, oldmask, regs);
// wartość 1 oznacza, że wywołano handler obsługi sygnału (wykorzystywane
// przez sigsuspend)
return 1;
}
// Wyjście z pętli oznacza, że sygnały były obslużone w sposób domyślny.
// Wywołujemy więc ponownie funkcję systemową z której wyrwał nas sygnał.
// Zauważ, że jeżeli do_signal zostało wywołane przy powrocie z funkcji
// sigreturn (czyli jednak były wykonywane procedury obsługi sygnału i
// już przygotowano restart procedury / ustawiono bład EINTR) wartość
// orig_eax będzie równa -1 (porównaj sigreturn i handle_signal)
/* Did we come from a system call? */
if (regs->orig_eax >= 0) {
/* Restart the system call - no handlers present */
if (regs->eax == -ERESTARTNOHAND ||
regs->eax == -ERESTARTSYS ||
regs->eax == -ERESTARTNOINTR) {
// cofamy procesor o 2 bajty, czyli na powtórne wywołanie funkcji
// systemowej
regs->eax = regs->orig_eax;
regs->eip -= 2;
}
}
// wartość 0 oznacza, że nie wykonywalismy zadnego handlera
// (wykorzystywane przez sigsuspend)
return 0;
}