• Wprowadzenie
• Wywołanie exit
• Ważniejsze funkcje wywoływane w do_exit
• Algorytm do_exit

Procesy stanowią najbardziej zasadniczy element koncepcyjny architektury wieloprogramowych systemów operacyjnych, do których niewątpliwie należy Linux. Pojęcie "proces" zwykle definiuje się jako "wykonujący się egzemplarz programu". Jest oczywiste, że musi istnieć jakiś mechanizm w systemie, który umożliwi tworzenie procesów. Takim mechanizmem jest wywołanie systemowe fork.

Funkcja fork jest wywoływana w programie w następujący sposób:

switch(pid = fork()) {
  case -1:
    //obsługa błędu przy wykonaniu funkcji fork

  case 0:
    // Tutaj wstawia się kod potomka

  default:
    // Tu wstawia się kod ojca
}

Aby utworzyć nowy proces trzeba skorzystać z jednej z trzech funkcji: fork, vfork, clone. Powodują one wywołanie funkcji systemowych odpowiednio: sys_fork, sys_vfork oraz sys_clone zdefiniowanych w pliku process.c. Wszystkie one są interfejsem do funkcji do_fork, która, wywoływana z różnymi flagami tworzy nowy proces. Różnice między tymi funkcjami są następujące: wywołania fork i vfork są bardzo do siebie podobne dzięki technice kopiowania przy zapisie (copy-on-write) polegającej na pozwoleniu na czytanie przez rodzica i przez potomka tych samych stron fizycznych i kopiowaniu ich dopiero gdy któryś z nich zdecyduje się na zapis. Różnica jest taka, że vfork tworzy proces, który współdzieli przestrzeń pamięci rodzica i, aby zapobiec nadpisywaniu przez rodzica danych potrzebnych potomkowi, rodzic jest zawieszany do momentu zakończenia się potomka lub wykonania przez niego nowego programu. clone natomiast służy jako wsparcie dla tworzenia lekkich procesów posiadających ten sam PID i nie jest domyślnie dostępne w Linuxie. Jądro musi być skompilowane z odpowiednią opcją.

Żeby gładko przebrnąć przez opisy funkcji i algorytmów zamieszczonych dalej proponuję krótkie przypomnienie podstawowych struktur wykorzystywanych przy tworzeniu procesu. Opiszę tylko te pola, które dla rozpatrywanego zagadnienia mają znaczenie

• Dostępne flagi przy tworzeniu procesów (zdefiniowane w pliku sched.h). Podawane są jako argument przy wywołaniu do_fork - określają które zasoby mają być współdzielone przez rodzica i potomka:
  • CLONE_FILES - otwarte pliki
  • CLONE_FS - informacje dotyczące katalogu głównego i aktualnego katalogu roboczego
  • CLONE_SIGHAND - procedury obsługi sygnałów
  • CLONE_PID - numer PID
  • CLONE_VM - deskryptor pamięci i wszystkie tablice stron
  • CLONE_PTRACE - jeśli rodzic procesu jest śledzony przy pomocy funkcji ptrace() to potomek także ma być śledzony
  • CLONE_PARENT - mają mieć tego samego ojca
  • CLONE_VFORK - ustawiana jeśli ojciec chce być obudzony przez dziecko w funkcji mm_release wywoływanej przy kończeniu wykonywania się dziecka na danych ojca (czyli po exec lub exit wykonanych przez owo dziecko)
  • CSIGNAL - flaga, która określa jaki sygnał będzie wysłany do ojca przy zakończeniu się procesu - standardowo jest to SIGCHLD
  Wewnątrz funkcji do_fork używa się jeszcze następujących flag (zdefiniowanych również w sched.h)
  • PF_SUPERPRIV - proces użył przywilejów super-użytkownika
  • PF_FORKNOEXEC - proces jeszcze nie wykonał funkcji exec
• Struktura TASK_STRUCT (zdefinowana w sched.h) - zawiera wszystkie istotne informacje o procesie. Ponieważ dokładnie została opisana w rozdziale dotyczącym struktur danych dlatago też skupię się na polach istotnych przy tworzeniu i kończeniu procesu.

  struct task_struct {
    volatile long state;    /* pole to opisuje co aktualnie dzieje się *
                             * z procesem ustawiana jest jedna i tylko *
  			   * jedna flaga z następujących:  TASK_ZOMBIE *
  			   * TASK_STOPPED, TASK_RUNNING,             *
  			   * TASK_INTERRUPTIBLE, TASK_UNINTERRUPTIBLE*/
    unsigned long flags;  /* flagi zdefiniowane powyżej */
    ...
    volatile long need_resched; /* jeśli jest ustawione na jeden oznacza *
                                 * procesowi skończył się czas procesora */
    unsigned long ptrace;   /* pole określające czy proces ma być śledzony */
    ...
    long counter; /* przechowuje informację o ilości czasu jaka pozostała *
                   * jeszcze procesowi do chwili wywłaszczenia go przez jądro */
    ...
    struct mm_struct *mm;  /*struktura dokładnie będzie opisana w temacie *
            * dotyczącym pamięci. Tu wystarczy powiedzieć, ża zawiera ona *
  	  * wskaźniki do deskryptorów pamięci oraz licznik ilości odwołań*
  	  * do nich                                                     */
    ...
    struct task_struct *next_task, *prev_task; /* wskaźniki do sąsiednich *
                               * procesów na dwukierunkowej liście wszystkich
  			     * procesów                                */
    ...
    int exit_code, exit_signal;
    int pdeath_signal;  /* Sygnał wysyłany kiedy umiera ojciec */
    ...
    int did_exec:1;
    pid_t pid;              /* Numer PID */
    ...
    int leader;             /* ustawiony na jeden jeśli proces jest *
                             * leaderem sesji                       */
    struct task_struct *p_opptr, *p_pptr, *p_cptr, *p_ysptr, *p_osptr;
         /* wzkaźniki do (oryginalnego) ojca, najmłodszego dziecka, *
          * młodszego i straszego rodzeństwa  */
    ...
    struct completion *vfork_done;  /* dla vfork(), zdefiniowana w *
          * pliku completion.h - jest wykorzystywana do zawieszania *
  	* ojca procesu */
    ...
    int swappable:1;
    ...
    struct rlimit rlim[RLIM_NLIMITS]; /* w tej tablicy określone są *
                             * limity zasobów dostępnych dla procesu*
  			   * np maksymalny czas CPU, rozmiar stosu*
  			   * lub danych oraz dopuszczalna liczba  *
  			   * procesów danego użytkownika, czy też *
  			   * ilość otwartych plików dla procesu   */
    ...
    struct tty_struct *tty; /* NULL jeśli proces wykonuje się w tle */
    ...
    struct sem_undo *semundo; /* do cofania operacji semaforowych */
    ...
    struct fs_struct *fs; 
    struct files_struct *files;
    struct signal_struct *sig;
  };
  
  

• Struktura fs_struct (zdefiniowana w fs_struct.h) - przechowuje informacje o masce praw dostępu dla nowo tworzonych plików przez użytkownika (umask), wskaźniki do struktur dotyczących dwu katalogów: głównego oraz aktualnego katalogu roboczego. Zawiera także licznik odwołań do siebie, co umożliwia współdzielenie jej przez wiele procesów.
• Struktura files_struct (zdefiniowana w sched.h) - przechowuje informacje o deskryptorach plików otwartych przez proces. Również zawiera licznik odwołań do siebie.
• Struktura signal_struct (zdefiniowana w sched.h) - w niej, w tablicy przechowywane są informacje o akcjach jakie mają być podjęte w przypadku otrzymania konkretnego sygnału. Zawiera także licznik odwołań do siebie.

Funkcje opisane poniżej wywoływane są w funkcji do_fork. I tak jak do_fork nie są dostępne dla programisty. W większości zostały zaimplementowane w pliku fork.c. Opisuję je w kolejności w jakiej wystąpiły w poniżej opisanym algorytmie do_fork.

• Funkcja pid_t get_pid(long clone_flags)
  Funkcja zwraca unikatowy numer pid dla nowego procesu (nie dotyczy przypadku gdy ustawiono flagę CLONE_PID - wtedy zwraca się pid procesu, który wywołał do_fork). Algorytm szukania nowego pidu jest następujący: zwiększa się ostatnio przydzielony pid. Jeśli otrzymana wartość jest równa lub przekracza stałą PID_MAX, to za ostatnio przydzielony pid podstawia się wartosc 300 (omija się pidy demonów). Następnie sprawdza się, czy nowy pid nie koliduje z jakimkolwiek innym pidem, lub polem session. Jeśli koliduje brany jest kolejny pid i wszystkie kroki ponownie zostają wykonane.
• Funkcja copy_files
  kopiuje informacje o deskryptorach otwartych plików - potomek dziedziczy je po procesie macierzystym, zwiększa liczniki odwołań do odpowiednich i-węzłów. Jeśli ustawiona jest flaga COPY_FILES następuje jedynie zwiększenie licznika odwołań do odpowiedniej struktury u ojca.
• Funkcja copy_fs
  Jeśli ustawiona jest flaga COPY_FS następuje zwiększenie licznika odwołań do odpowiedniej struktury u ojca. W przeciwnym wypadku kopiowane są informacje o właścicielu, prawach dostępu do katalogów: głównego i aktualnego katalogu roboczego procesu
• Funkcja copy_sighand
  Jeśli ustawiona jest flaga COPY_SIGHAND następuje zwiększenie licznika odwołań do odpowiedniej struktury u ojca. W przeciwnym wypadku kopiwane są informacje dotyczące tablicy funkcji-akcji obsługujących sygnały
• Funkcja copy_mm
  Podobnie jak poprzednio jeśli ustawiona jest flaga COPY_VM następuje zwiększenie licznika odwołań do odpowiedniej struktury u ojca i ustawienie wskaźnika na jego struktury. W przeciwnym razie zostają wyzerowane statystyki dotyczące dostępu do pamięci, oraz wywołana zostaje funkcja dup_mmap, która kopiuje strony pamięci procesu macierzystego do przestrzeni potomka na zasadzie copy-on-write.

• clone_flags - flagi opisane są powyżej
• stack_start - początek stosu
• *regs - określa sposób w jaki będą przechowywane rejestry w czasie wywołania systemowego
• stack_size - rozmiar stosu

1. Jeśli została ustawiona flaga CLONE_PID sprawdza się czy PID procesu wywołującego jest równy 0. Jeśli nie, następuje wyjście z do_fork z błędem EPERM (brak uprawnień) - tylko proces 0 może klonować PID.
2. Następuje wywołanie funkcji alloc_task_struct(), która rezerwuje 8kb pamięci na strukturę TASK_STRUCT. W przypadku niepowodzenia do_fork kończy działanie z błędem ENOMEM (brak dostępnej pamięci)
3. Kopiuje się cały obszar pamięci ze wskaźnika makra CURRENT do task_structu tworzonego procesu (*p = * current)
4. Sprawdza się czy użytkownik nie posiada zbyt wielu procesów. Jeśli wartość maksymalna została osiągnięta nowy proces oczywiście nie zostanie stworzony - zapobiega to sytuacji całkowitego sparaliżowania systemu poprzez wytworzenie zbyt dużej ilości procesów. Zawsze gwarantuje się, by w systemie została ilość zasobów wystarczająca do zalogowania się superużytkownika i oczyszczenia przez niego systemu
5. Zwiększa się ilość procesów danego użytkownika
6. Sprawdza się również czy ilość uruchomionych wątków nie przekracza maksymalnej ilości
7. Pobiera się domenę uruchomieniową, która, jak większość struktur o charakterze informacyjnym, może być współdzielona przez wiele procesów
8. Jeśli proces używa jakiegoś modułu jądra, zwiększa się licznik odniesień do tego modułu. Każdy moduł wie ile procesów z niego korzysta i jeśli korzysta choć jeden proces, nie można go usunąć
9. Uaktualniane są niektóre wartości w skopiowanym od rodzica task_strukcie tworzonego procesu (wszystkie zmiany opisywane poniżej dotyczą wyłącznie tworzonego procesu):
   • did_exec = 0 - proces jeszcze nie wykonał funkcji exec
   • swappable = 0 - proces nie podlega wymianie
   • zmieniany jest stan procesu na TASK_UNINTERRUPTIBLE
   • flagi ustawiane są następująco: czyści się: PF_SUPERPRIV, PF_USEDFPU, ustawia: PF_FORKNOEXEC, oraz sprawdza się czy wśród flag podanych na wejściu do_fork znalazła się CLONE_PTRACE
   • zmienia się PID przy pomocy wywołanej funkcji (get_pid(clone_flags)
   • inicjalizje się listy run_list
   • ustawia się wskaźnik na najmłodszego potomka (czyli na NULL)
   • inicjalizuje się kolejkę wait_chldexit czyli kolejkę do czekania na (przyszłe) dzieci w wait4()
   • Jeśli ustawiona jest flaga CLONE_VFORK to inicjalizuje się strukturę completion
   • ustawia się obsługę sygnałów: zeruje się ilość oczekujących sygnałów, oraz inicjalizuje kolejki
   • zeruje się pola dotyczące czasu wykonywania się procesu i uruchamia się zegar czasu rzeczywistego
   • jeśli rodzic był leaderem sesji, potomek tego nie dziedziczy. Również nie dziedziczy tty - będzie się wykonywał w tle
   • zeruje sie wszystkie pola w strukturze times
   • ustawiony zostaje czas startowy procesu
   • kopiowane są informacje o procesie przy wykorzystaniu funkcji: (copy_files), (copy_fs), (copy_sighand), (copy_mm).
   • wywołuje się funkcję copy_thread, w której następuje zainicjowanie stosu trybu jądra u dziecka - tu następuje rozwidlenie: dziecku się będzie się wydawać, że to ono wykonało fork i będzie miało 0 w polu ret_from_fork
   • inicjalizuje się pole semundo odpowiedzialne za anulowanie operacji semaforowych
   • od teraz będzie mógł podlegać wymianie, czyli swappable=1
   • określa się sygnał jaki będzie przesłany ojcu procesu przez potomka przy jego zakończeniu - standardowo jest to SIGCHLD, ale można to zmodyfikować podając odpowiednią flagę na wejściu do_fork
   • ustawia się sygnał jaki wysyła ojciec do dzieci umierając
   • ustawia się pole counter - daje się dziecku połowę czasu rodzica (przy założeniu, że ojciec pierwszy będzie się wykonywał dalej) - oboiwązuje to tylko za pierwszym razem
10. następuje sprawdzenie czy procesowi wywołującemu do_fork pozostał jeszcze czas procesora - jeśli nie to ustawia się mu pole need_resched na 1
Teraz potomek ma już właściwie wszystkie zasoby poustawiane, pozostaje tylko poinformować ojca i jądro o powstaniu nowego procesu
11. w zależności od flag ustawia się nowemu procesowi ojca i oryginalnego ojca
12. wreszcie w makrze SET_LINKS ustawia się resztę powiązań rodzinnych nowemu procesowi oraz jego rodzeństwu i ojcu oraz wstawia się nowy proces do kolejki procesów
13. deskryptor nowego procesu wstawiany jest do tablicy mieszania pidhash
14. nowy proces jest budzony w funkcji wake_up_process
15. zwiększa się ilość wykonanych forków w systemie (liczona od ostatniego uruchomienia systemu)
16. jeśli nowy proces miał być stworzony za pomocą funkcji vfork to zawiesza się ojca nowego procesu do czasu gdy nowy albo skończy działanie, albo wykona exec

Proces w Linuxie może zakończyć się z kilku powodów np gdy otrzyma sygnał, jednakże najczęstszą przyczyną jest napotkanie wywołania systemowego exit lub osiągnięcie ostatniej instrukcji w procedurze głównej wykonywanego programu, co na jedno wychodzi. Funkcja exit, która służy do kończenia procesów w Linuxie zwalnia zasoby zajmowane dotychczas przez wywołujący proces, zmienia jego stan na ZOMBIE.

exit kończy normalnie proces. Interfejs użytkownika jest następujący:

Odpowiedzialna jest za zwalnianie zasobów związanych z procesem, a ściśle z polem mm struktury task_struct. Wykonywana jest funkcja mm_release() istotna dla dla procesu macierzystego jeśli proces kończący się powstał w wyniku wywołania vfork(). Jeżeli struktura mm jest współdzielona przez kilka procesów, to proces wykonujacy exit tylko zmniejsza licznik odwołań do niej, w przeciwnym razie jądro odzyskuje wcześniej przydzieloną pamięć.

Zaimplementowana w celu zapobieżenia sytuacji gdy proces wykona operacje semaforowe blokujące inne procesy i zakończy się. Problem ten jest rozwiązany poprzez cofnięcie wszystkich operacji semaforowych wykonanych przez proces zapisanych w polu semundo deskryptora procesu.

Celem jest zamknięcie otwartych plików. Jeśli struktura files z deskryptora procesu wykonujacego exit jest współdzielona przez kilka procesów zmniejsza się licznik odwołań do tej struktury w przeciwnym razie zamyka się deskryptory plików i zwalnia się pamięć przydzieloną strukturze files.

Celem jest zwolnienie i-wezłów katalogów głównego i roboczego wykorzystywanych przez niszczony proces. Jeśli struktura fs z deskryptora procesu nie jest współdzielona usuwa się ją z pamięci wpp. zmniejsza się licznik odwołań do tej struktury.

Celem jest usunięcie tablicy funkcji obsługujących sygnały. Tak jak powyżej jeśli żaden proces nie współdzieli obsługi sygnałów jest ona usuwana z pamięci, wpp. zmniejsza się licznik odwołań do niej.

Funkcja ta zmienia rodzica dzieciom procesu (próbuje się je oddać innym wątkom z danej grupy procesów, jeśli się to nie uda oddaje się je procesowi init), następnie sprawdza się czy jakaś grupa procesów nie stała się sieroca przez zakończenie się procesu (tzn ojciec umierającego procesu należy do innej grupy) : jeśli tak wysyła się sygnały SIGHUP i SIGCONT, dalej informuje się ojca o śmierci potomka i zmienia się stan procesu na ZOMBIE.

Funkcja do_exit obsługuje wszystkie zakończenia procesów w Linuxie. Jest zdefiniowana jest w pliku kernel/exit.c. Jako parametr przyjmuje wartość typu long, natomiast sama niczego nie zwraca. W do_exit wykonywane są następujące kroki:

1. Bada się na jakim procesie ma być wykonany do_exit: jeśli proces jest w trakcie obsługi przerwania, jest procesem idle (pid=0) lub procesem init (pid=1) do_exit zakończy się niepowodzeniem - wywołana zostanie funkcja panic, po której system jest zwykle rebootowany.
2. Do flag procesu dodaje się flagę PF_EXITING oznaczającą, że proces jest w trakcie wykonywanie funkcji do_exit
3. Usuwa się prywatny zegar procesu z listy zegarów
4. Jeśli zdefiniowano w systemie CONFIG_BSD_PROCESS_ACCT dopisuje się rekord do pliku rozliczeniowego w acct_process(code);. Rekord zawiera informacje o działaniu procesu takie jak: nazwę wykonanego programu, czas zużyty w trybie użytkownika i w trybie jadra, czas pracy w sekundach, czas rozpoczecia pracy, numer ID użykownika i grupy, identyfikator terminala, informacje o zakończonym procesie, błędy obsługi stron, kod zakończenia programu .
5. zwalniane są zasoby związane z (kolejno): stronicowaniem (__exit_mm), wykonanymi operacjami semaforowymi (sem_exit), otwartymi deskryptorami plików (__exit_files), systemem plików (__exit_fs), obsługą sygnałów (exit_sighand), wątkami (exit_thread).
6. jeżeli kończony proces był leaderem grupy procesów to do każdego procesu z tej grupy wysyła się sygnał zawieszenia (SIGHUP) domyślnie kończący proces, a do procesów wstrzymanych (w stanie TASK_STOPPED) wysłany zostaje sygnał (SIGCONT) powodujący ich wznowienie (aby mogły obsłużyć otrzymany SIGHUP)
7. jeśli proces korzystał z modułów jądra sprawdza się czy są one używane jeszcze przez jakieś inne procesy - jeśli nie to się je usuwa, wpp. zmniejsza się licznik odniesień do nich
8. ustawia się kod wyjścia
9. wywołuje się funkcję (exit_notify)
10. wywołuje się funkcję schedule służącą do przeszeregowania procesow (musi zostać wybrany nowy proces do wykonania przez procesor). Stan ustawiony na ZOMBIE powoduje, że funkcja szeregująca nie wybierze już tego procesu do wykonania. Zatem sterowanie nie powróci do funkcji exit.
11. funkcja bug umieszona jest na końcu do_exit na wszelki wypadek jeśli coś się wydarzy i sterowanie jednak wróci do exit - do_exit wykonuje się raz jeszcze.