---
# System prepended metadata

title: SO Lista 1 Procesy

---

# SO Lista 1 Procesy
Należy przygotować się do zajęć czytając następujące rozdziały książek:
• Arpaci-Dusseau: Processes1, Process API2, Address Spaces3
• Tanenbaum (wydanie czwarte): 2.1, 10.3, 11.4
UWAGA! W trakcie prezentacji należy być gotowym do zdefiniowania pojęć oznaczonych wytłuszczoną czcionką.Podręcznikiem do zadań praktycznych jest „Advanced Programming in the UNIX Environment” (w skrócie APUE) oraz „The Linux Programming Interface” (w skrócie LPI). Proszę przede wszystkim korzystać z rozdziałów 2 i 3 anglojęzycznego podręcznika systemowego – np. man 2 read. Kiedy jego treść nie jest wystarczająco klarowna, to warto spojrzeć na rozdziały opisujące analogiczne tematy w podręczniku FreeBSD – np. man 2freebsd read.
*Wskazówka: W systemie bazującym na Debianie zainstaluj pakiety manpages-dev, manpages-posix-dev, freebsd-manpages.*
Rozwiązania zadań należy prezentować przy pomocy rzutnika. Każde rozwiązanie należy starannie przygotować do prezentacji przed zajęciami – najlepiej w postaci pliku tekstowego z listą poleceń do wykonania i komentarzami. W przypadku zbędnego przeciągania czasu odpowiedzi ze względu na problemy techniczne prowadzący ma prawo skreślić zadanie i postawić jeden punkt ujemny.
**UWAGA! Każdy student musi przygotować skrypt, który przy pomocy programu xrandr4 ustawi rozdzielczość ekranu wbudowanego na 1280×800 i sklonuje go na zewnętrzne złącze VGA lub HDMI. Dla programu terminala należy wybrać dużą czcionkę (około 32 wierszy w trybie pełnoekranowym), kontrastowe kolory i jasne tło. Starannie przetestuj swoją konfigurację przed zajęciami!**

![](https://i.imgur.com/OIwtd1k.png)
**kthreadd** – wątek-matka, jego zadaniem jest tworzenie nowych wątków jądra
## Zadanie 1
::: info
![](https://i.imgur.com/YATA5Fs.png)
* **rodzic-dziecko** - relacja między procesami mówiąca, który jest twórcą (rodzic), a który został stworzony (dziecko)
* **indetyfikator procesu** - unikatowy identyfikator procesu w wielozadaniowych systemach operacyjnych (np. Unix, Microsoft Windows NT), wyrażony jako liczba całkowita z określonego przedziału. PID(ang. Process IDentifier)
* **identyfikator grupy procesów** - indentyifkator grupy procesów, które mogą razem otrzymywać sygnały (od rodzica do wszystkich dzieci zazwyczaj)
* **identyfikator rodzica** - PID procesu, który jest rodzicem danego procesu
* **właściciel procesu** - Użytkownik który uruchomił proces i posiada prawa do jego kontrolowania
* **wątki jądra** - Lekkie procesy, działające asynchronicznie w przestrzeni jądra (podobnie jak zwykłe wątki w przestrzeni użytkownika), niezwiązane z żadnym procesem użytkownika. Ich nazwy przedstawione są na liście procesów w nawiasach kwadratowych Rodzicem wszystkich wątków jądra jest kthreadd - ```PID = 2```

Wątki jądra to wątki wykonujące kod jądra, nie są one powiązane z procesami z przestrzeni użytkownika, nie używają również pamięci użytkownika (gdy dodamy vsz do tabeli polecenia ps -eo ... zobaczymy 0 (KiB) dla procesów root). W kolumnie STAT oznacza je litera I. Wywołanie ps bez argumentów sprawi, że wypisana zostanie lista procesów w bieżącej sesji.
* STAT - obecny stan procesu: (513 linijka manuala do ps)
    ![](https://i.imgur.com/uh7gpRA.png)

* **hierarchia procesów** - reprezentacja zależności między procesami w relacjach rodzic-dziecko gdzie rodzice są wyżej w hierarchii od swoich dzieci
po uruchomieniu ``pstree`` wątki rozpoznamy po sposobie zapisu ich nazw: ``n*[{name}]``  to grupa n wątków
:::
:::spoiler Wypluty wynik ``ps -eo user,pid,ppid,pgid,tid,pri,stat,wchan,cmd ``:
1. Właściciel 2. PID 3. Parent PID 4. Process group ID 5. Threat ID 6.PRI(Priority of the procces of the Kernel Threat) 7.STAT 8.WCHAN 9. Command - co się dzieje
![](https://i.imgur.com/hgBoxdc.png)
![](https://i.imgur.com/erEE8Iq.png)
![](https://i.imgur.com/RJPlMnF.png)
![](https://i.imgur.com/5DyMiAh.png)
![](https://i.imgur.com/k4roY1L.png)
![](https://i.imgur.com/hT4WItd.png)
![](https://i.imgur.com/KDvJmBe.png)
![](https://i.imgur.com/QBFw5TC.png)

:::
* Rodzicem procesu ```init``` jest kernel sam ```init``` jest na szczycie drzewa w hierarhii procesów, można więc powiedzieć, że jest on mniej więcej rodzicem wszystkich procesów
::: spoiler Wynik ```pstree```
![](https://i.imgur.com/1LhAaaR.png)
![](https://i.imgur.com/VWw3bCY.png)
![](https://i.imgur.com/xXAqYUD.png)
![](https://i.imgur.com/lj7OWTn.png)

:::
::: spoiler Wypluty wynik ``ps -eo user,pid,ppid,pgid,tid,pri,stat,wchan,cmd,vsz ``:
![](https://i.imgur.com/0WVHUDY.png)
![](https://i.imgur.com/1MsEors.png)
![](https://i.imgur.com/gJC7QGu.png)
![](https://i.imgur.com/zQCwjUH.png)
![](https://i.imgur.com/FvOj3HT.png)
![](https://i.imgur.com/j8Lp05E.png)
![](https://i.imgur.com/MhHtfPp.png)
![](https://i.imgur.com/JrAJSLf.png)

:::
## Zadanie 2
:::    info
![](https://i.imgur.com/qivh0L7.png)
* **sierota** - proces bez rodzica, którego rodzic został już zabity
* **zombie** - proces, który skończył się wykonywać ale nie został jeszcze pogrzebany
* **stan procesu** - running(also waiting for input)/stopped/terminated 
![](https://imgur.com/0VO2LRb.png)

![](https://i.imgur.com/7STozyO.png)
:::
* Kiedy proces staje się sierotą jądro systemu przypisuje osierocony proces do ```init-a``` (init staje się rodzicem wszystkich sierot)
* Trzeba użyć komendy ```kill()``` na rodzicu wtedy init pogrzebie proces albo użyć wait() który poczeka aż dziecko zakończy działanie.
* Żeby mógł nastąpić status zombie? Czyli źeby mógł wysłać informacje do rodzica.   
    * a) dziecko czeka na zmianę stanu rodzica. Procesy nie mogłyby umrzeć bo grzebnie procesu to czekanie aż się zakończy, więc procesy ojceic i dziekco mogłby czekać na siebie w nieskończoność
    * b) wiele procesów oczekuje na zmianę stanu jednego procesu? Kiedy skończyłby się proces niewiadomobybyło komu wysłać wynik exitu.

## Zadanie 3
![](https://i.imgur.com/0Prm8cZ.png)
:::info
* **argumenty programu** - argumenty wpisywane do wiersza poleceń po nazwie programu, pozwalające przekazać wejście w trakcie działania programu
* **zmienne środowiskowe** - to nazwana wartość, zazwyczaj zawierająca ciąg znaków, przechowywana i zarządzana przez powłokę. Zmienna środowiskowa może wpływać na działanie procesów uruchamianych w systemie operacyjnym i wtedy staje się pewnym mechanizmem komunikacji lub też przechowywać wartość w celu jej późniejszego wykorzystania. 
:::
* **proc**  is virtual file system created on fly when system boots and is dissolved at time of system shut down. It contains useful information about the processes that are currently running, it is regarded as control and information center for kernel.
* używając ```ps -aux``` wyświetlamy PIDy działających procesów.
![](https://imgur.com/lWSkxQG.png)
Wybieramy jakiś i drukujemy zawartość za pomocą ```ls /proc/<PID>```
![](https://imgur.com/bXWgdOF.png)
* argumenty programu ```cat /proc/<PID>/cmdline | tr '\000' '\n'```
![](https://imgur.com/2z2ry0X.png)
* zmienne środowiskowe ```cat /proc/<PID>/environ | tr '\000' '\n'```
![](https://imgur.com/t2olFlQ.png)

* plik status \(```cat /proc/<PID>`/status```\): 
![](https://imgur.com/PsDd8Ws.png)
    * Uid - Real, effective, saved set, and filesystem UIDs \(numeryczny identyfikator użytkownika),
    * Gid - Real, effective, saved set, and filesystem GIDs \(numeryczny identyfikator grupy \),
    * Groups - Supplementary group list,
    * VmPeak - Peak virtual memory size,
    * VmSize - Virtual memory size, 
    * VmRSS - Resident set size.  Note that the value here is the sum of RssAnon, RssFile, and RssShmem.  This value is inaccurate
    * Threads - Number of threads in process containing this thread, 
    * voluntary_ctxt_switches - Number of voluntary context switches, 
    * nonvoluntary_ctxt_switches - Number of involuntary context switches, 
:::info
Grupy - W systemach uniksowych, konta użytkowników przydzielane są do grup. Dana grupa posiada ściśle określone prawa dostępu do systemu plików z uprawnieniami. Korzystanie z grup umożliwia nadawanie uprawnień użytkownikom przez superużytkownika w sposób zorganizowany, np. prawa do uruchamiania programów, dostęp do plików, drukarek, skanerów i innych urządzeń peryferyjnych. Część zadań o charakterze administracyjnym również może zostać powierzona wybranym grupom, a przez to użytkownikom przypisanym do danej grupy. 
 :::


## Zadanie 4
![](https://i.imgur.com/kIvk82Y.png)
Używamy polecenia ``ps ax | grep X``
![](https://i.imgur.com/ocGLUhg.png)
Flaga `ax` odpowiada za szukanie w procesach innych użytkowników oraz pośród procesów działających poza terminalem.
![](https://i.imgur.com/QAvqiyr.png)
![](https://i.imgur.com/rUMri2e.png)

Używamy polecenia ``sudo pmap 69``
Uzyskujemy zawartość przestrzeni adresowej procesu o PID 69
[Wydruk powyższego polecenia](https://pastebin.com/raw/UbJLXfzB)

Stos znajduje się na samym dole przestrzeni adresowej
```
00007ffe1c060000    132K rw---   [ stack ]
```
Adres sterty odnajdziemy przy pomocy polecenia ``sudo less /proc/69/maps``
[Wydruk powyższego polecenia](https://pastebin.com/raw/LKpivH8g)
```
5607d5d59000-5607d908b000 rw-p 00000000 00:00 0    [heap]
```
Poszczególne kolumny wydruku pmap oznaczają:

- Address - adres początku
- Kbytes - rozmiar
- Mode - uprawnienia rwx (czytanie, pisanie, wykonywanie)
- Mapping - plik na jaki zmapowana jest pamięć lub [anon]/[stack]

![](https://i.imgur.com/t7vJ7iG.png)





* **segmenty programu** - spójne bloki o jednolitym przeznaczeniu i atrybutach z punktu widzenia procesu ładowania i uruchamiania programu. Jeden segment może zawierać wiele sekcji. Nasze segmenty programu są zmapowane do `Xorg`
* **pamięć anonimowa** - pamięć, która nie jest powiązana z żadnym innym plikiem ani obiektem. Powszechnym anonimowym mapowaniem jest stos i sterta wspomniane powyżej, Jest ona oznaczana jako [anon]
* **pliki odwzorowane w pamięci** - segment pamięci wirtualnej mający bezpośrednie mapowanie co do bajta z jakimś plikiem lub zasobem. Dzięki temu unika się stosowania funkcji systemowych na plikach takich jak read() lub write(), gdyż proces adresuje plik bezpośrednio. Plik może być traktowany jak ciągły obszar w pamięci procesu, dostępny poprzez bezpośrednie operacje pobrania i podstawienia wartości. Wszystkie modyfikacje dokonane w pamięci są później zapisywane nad dysku. Znaleźć je można w `Mapping` jako pliki `*.so`
## Zadanie 5
![](https://i.imgur.com/ie2Lxqn.png)
* **zasoby plikopodobne** - identyfikatory plików wykorzystywane przez system operacyjny; każdy proces ma 3 standardowe deskryptory : standardowe wejście (stdin), standardowe wyjście (stdout), standardowe wyjście diagnostyczne (stderr) 
* **pliki zwykłe** - zwykły plik to plik w systemie, który zawiera dane, tekst lub instrukcje programu
* **katalogi** - struktura organizacji danych, zawierająca referencje do plików lub innych katalogów
* **urządzenia**
* **gniazda** - dwukierunkowy punkt końcowy połączenia, używany głównie do komunikacji z odleglym procesem za pośrednictwem sieci, ale także w przypadku wymiany informacji między procesami działającymi w obrębie jednej maszyny; jest opisywane za pomocą kombinacji trzech atrybutów: domeny adresowej, sposobu komunikacji i protokołu sieciowego
* **potok** - mechanizm komunikacji między procesami, umożliwia wymianę danych pomiędzy nimi. Odbywa się to najczęściej poprzez połączenie standardowego wyjścia jednego procesu ze standardowym wejściem drugiego. 
## Zadanie 6
:::info
![](https://i.imgur.com/JgEQOjg.png)
* **czas wykonania** - czas jaki program spędził wykonując zadanie
* **ograniczenie na czas wykonania** - to limit czasu jaki program ma na wykonanie zadania
:::
:::spoiler Wydruk polecenia ```time find /usr```
![](https://i.imgur.com/f41wAbq.png)

:::
* ```user``` to czas CPU spędzony w trybie użytkownika podczas wykonywania procesu określonego przez polecenie ```time```
* ```sys``` to czas CPU spędzony na wykonywaniu różnych syscall przez jądro, liczony jest tylko dla tego konkretnego procesu
* ```real``` to realny czas od uruchomienia procesu do jego zakończenia.
```usr```+```sys```!=```real```, ponieważ system i user mogą pracować jednocześnie na kilku rdzeniach. Czasy na każdym rdzeniu są wtedy sumowane.
:::spoiler przykład ```usr```+```sys```>```real``` z StackOverflow [link](https://stackoverflow.com/questions/15928334/user-time-larger-than-real-time)
![](https://i.imgur.com/dTjHBlp.png)
:::
::: spoiler Wszystkie limity na wykonywanie programu ```ulimit -a```
![](https://i.imgur.com/QXwsG4Q.png)
:::
Ograniczenie czasu wykonania nakładamy przez ```ulimit -t [sekundy]```. Czas ograniczenia liczy się tylko jako ```user + sys```, ```real``` może być większy niż nałożony przez nas limit. Proces zostaje zabity sygnałem ```SIGKILL```.

## Zadanie 7
:::info
![](https://i.imgur.com/jz9ARE8.png)
* **kopiowanie przez referencję** - to kopiowanie wskaźnika na obiekt, a nie zawartości obiektu.
* **pozycja kursora** - to offset od początku pliku, od którego następuje czytanie/pisanie.
:::

``` C
#include "csapp.h"

static char buf[256];

#define LINE1 49
#define LINE2 33
#define LINE3 78

static void do_read(int fd) {
  /* TODO: Spawn a child. Read from the file descriptor in both parent and
   * child. Check how file cursor value has changed in both processes. */
  pid_t pid;
    pid = Fork();
    int pidint = pid;
    if (pid == 0) {      //dziecko
        Read(fd, buf, 16);
        printf("%d: %ld\n", pidint, Lseek(fd, 0, SEEK_CUR));
    }
    else {              //rodzic
        Read(fd, buf, 16);
        printf("%d: %ld\n", pidint, Lseek(fd, 0, SEEK_CUR));
    }
  exit(0);
}

static void do_close(int fd) {
  /* TODO: In the child close file descriptor, in the parent wait for child to
   * die and check if the file descriptor is still accessible. */
  int child_status;
    pid_t pid;          // pid_t to typ zmiennej na PIDY istnieje taki naprawdę
    pid = Fork();
    int pidint = pid;
    if (pid == 0) {     //to robi dziecko
        printf("%d: Closing the file %d\n", pidint, fd);
        Close(fd);
        exit(0);
    }
    else {             //to robi rodzic
        Waitpid(pid, &child_status, 0);
        printf("%d: Child status: %d\n", pidint, child_status);
        printf("%d: Cursor position: %ld\n", pidint, Lseek(fd, 0, SEEK_CUR));
        Read(fd, buf, 16);
        printf("%d: Reading from file %d: %s\n", pidint, fd, buf);
        exit(0);
    }
  exit(0);
}

int main(int argc, char **argv) {
  if (argc != 2)
    app_error("Usage: %s [read|close]", argv[0]);

  int fd = Open("test.txt", O_RDONLY, 0);

  if (!strcmp(argv[1], "read"))
    do_read(fd);
  if (!strcmp(argv[1], "close"))
    do_close(fd);
  app_error("Unknown variant '%s'", argv[1]);
}



```

``` ./fileref read```
![](https://i.imgur.com/MEFThIa.png)

Widzimy że dziecko współdzieli kursor z rodzicem bo funkcja zwróciła nam miejsce kursora w pliku. Możemy zauważyć, że oba procesy korzystają z tego samego kursora, ponieważ końcowa pozycja kursora wynosi 32, a w obu procesach odczytujemy 16 znaków. Gdyby procesy nie korzystały ze wspólnego kursora, i nie byłoby żadnej innej synchronizacji wyjścia, to dochodziłoby do nadpisywania wyjścia jednego procesu przez wyjście innego. Aktualna pozycja kursora znajduje się w strukturze *file description*, która znajduje się w jądrze. (Jak było powiedziane na repetach)

Wynik polecenia ```./fileref close ```
![](https://i.imgur.com/K8IqZtH.png)

 Mimo tego, że dziecko zamknęło plik, zanim rodzic zaczął z niego czytać, to nie wystąpił żaden błąd. Oznacza to, że plik rodzica nie został zamknięty. Wynika to z faktu, że każdy proces posiada własną "kopię" pliku z którego może czytać. A dziecko zamknęło jedynie "swój" plik.
 
---

## Zadanie 8
:::danger
**!! OSTRZEŻENIE !! ZADANIE !! POLESIUKA !!**
:::
![](https://i.imgur.com/H6lTuwE.png)

:::danger
**!! OSTRZEŻENIE !! ZADANIE !! POLESIUKA !!**
:::
```C
#include "csapp.h"

static int ndselect(int n) {
  /* TODO: A loop is missing here that spawns processes and waits for them! */
  exit(0);
}

static int conflict(int x1, int y1, int x2, int y2) {
  return x1 == x2
    || y1 == y2
    || x1 + y1 == x2 + y2
    || x1 - y1 == x2 - y2;
}

static void print_line_sep(int size) {
  for (int i = 0; i < size; ++i) 
    printf("+---");
  printf("+\n");
}

static void print_board(int size, int board[size]) {
  for (int i = 0; i < size; ++i) {
    print_line_sep(size);
    for (int j = 0; j < size; ++j)
      printf("|%s", board[i] == j ? " Q " : "   ");
    printf("|\n");
  }
  print_line_sep(size);
  printf("\n");
}

int main(int argc, char **argv) {
  if (argc != 2)
    app_error("Usage: %s [SIZE]", argv[0]);

  int size = atoi(argv[1]);

  if (size < 3 || size > 9)
    app_error("Give board size in range from 4 to 9!");

  int board[size];

  /* TODO: A loop is missing here that initializes recursive algorithm. */

  print_board(size, board);

  return 0;
}

```
## Notatki z repetów
Procesy mają wspólny kursor z dziećmi.
Init robi 3 rzeczy :
* Ustawia siebie jako żniwairza i czeka na Sygnał SICKCHILD
* co 30 s próbuje pogrzebać dzieci
* 