Jan Kończak

Ta strona jest tylko do odczytu. Możesz wyświetlić źródła tej strony ale nie możesz ich zmienić.
===== Użytkownicy, uprawnienia do plików  =====

==== Użytkownicy i grupy ====

W uniksopodobnych systemach istnieją użytkownicy i grupy. \\
Użytkownicy identyfikowani są po numerycznych identyfikatorach **uid** (//user identifier//), które są mapowane na nazwy użytkowników.
\\
Podobnie grupy mają identyfikatory numeryczne o nazwie **gid** (//group identifier//), które też są mapowane na nazwy grup.

Każdy użytkownik jest w jednej podstawowej grupie (nazywanej jego grupą podstawową, //primary group//) i może należeć do dowolnie wielu grup (nazywanych jego grupami dodatkowymi, //supplementary groups//).

Lista dostępnych użytkowników i grup oraz powiązania uid/gid z nazwami zwykle są czytane z plików ''/etc/passwd'' i ''/etc/groups'', ale po odpowiedniej konfiguracji może być pobierana też z innych źródeł. \\
<small>Np. można wykorzystać serwer LDAP, czy kontroler domeny AD za pośrednictwem programu ''winbindd''. Więcej informacji na [[https://en.wikipedia.org/wiki/Name_Service_Switch|tutaj]]. \\ Hasła lokalnych użytkowników i grup są przechowywane w ''/etc/shadow'' i ''/etc/gshadow''</small>

W systemie plików zapisane są uidy i gidy (a nie nazwy użytkowników), stąd np. podłączenie dysku z jednego komputera do drugiego przypisze pliki innym nazwom użytkowników i grup jeżeli mapowania uid/gid na nazwy nie są identyczne na obu systemach. \\ <small>To dotyczy również kontenerów (sic!).</small>

<html><small></html>

Dla procesów uniksopodobne systemy przechowują efektywny, zapisany i rzeczywisty uid (analogicznie gid).
\\
Dla zwykłych procesów te identyfikatory są równe, dla procesów które zmieniały użytkownika mogą być różne. Więcej informacji na [[https://en.wikipedia.org/wiki/User_identifier|tutaj]].
\\
W tej chwili zakres uid'ów i gid'ów w Linuksie to 0÷(2<sup>32</sup>-2)

<html></small></html>

Użytkownik o uid równym **0** nazywany jest **superużytkownikiem** (//superuser//) i ma zwyczajowo nadaną nazwę **[[https://pl.wikipedia.org/wiki/Root|root]]**.

Żeby sprawdzić swoją nazwę użytkownika, można skorzystać z komendy ''**whoami**''. \\
Do sprawdzenia listy grup służy komenda ''**groups** [//użytkownik//]''. Bez argumentów wyświetla grupy bieżącego użytkownika.

~~Zadanie.#~~ Przetestuj działanie komendy ''whoami''.

~~Zadanie.#~~ Sprawdź listę grup w której jesteś. Sprawdź listę grup w której jest użytkownik student.

<html><small></html>

Komenda ''**id** [//użytkownik//]'' wyświetla nazwy i numery użytkownika, jego grupy podstawowej i grup dodatkowych.

Informację o użytkowniku można wyciągnąć poleceniem ''getent passwd //użytkownik//'', o grupach – ''getent group //grupa//''.

~~Zadanie.#~~ Sprawdź jaki masz uid i gid, zarówno poleceniem ''id'' jak i ''getent''.

<html></small></html>


Zmiana hasła użytkownika jest wykonywana przy pomocy komendy **''passwd''**. \\ <small>Root może przy pomocy ''passwd //user//'' ustawić hasło każdego użytkownika, może też zmienić czas ważności hasła bądź zablokować konto.</small>

<html><small></html>

Podstawowe komendy administracyjne do zarządzania użytkownikami to:
  * dodawanie nowego użytkownika: ''useradd [-m] [-g //grupa//] //nazwa//''
  * dodawanie nowej grupy: ''groupadd  //nazwa//''
  * dodanie użytkownika do grupy: ''gpasswd -a //użytkownik// //grupa//''
  * zmiana/usunięcie użytkownika/grupy: ''usermod'' / ''userdel'' / ''groupmod'' / ''groupdel''
  
<html></small></html>
  
==== Użytkownicy w systemie, historia logowania, komunikacja ====

Listę osób bieżąco używających systemu można wyświetlić komendą **''w -n''** oraz ''who''.

Historię logowań można wyświetlić używając polecenia ''**last** [-n //ile_ostatnich//] [//username//]''.

~~Zadanie.#~~ Zaloguj się po ssh na polluksa. Sprawdź jacy inni użytkownicy są zalogowani.

~~Zadanie.#~~ Na polluksie sprawdź jacy trzej użytkownicy logowali się ostatnio.

~~Zadanie.#~~ Na polluksie sprawdź kiedy ostatnio logował się użytkownik root.

<html><small></html>

~~Zadanie.#~~ Sprawdź jacy użytkownicy byli zalogowaniu na polluksie w chwili ''2023-03-03 13:30''

<html></small></html>

Komendą ''**write** //użytkownik// [//terminal//]'' można wysłać tekst do wybranego użytkownika (kończąc wpisany tekst przez EOF, zwykle //Ctrl+d//).
\\
Spowoduje to wyświetlenie mu podanego testu poprzedzonego komunikatem "message from…" w terminalu.
\\
Otrzymywanie takich wiadomości można zablokować (bądź odblokować) komendą ''**mesg {n|y}**''.

Można też wysłać wiadomość do wszystkich użytkowników komendą ''wall''.

~~Zadanie.#~~ Napisz do sąsiada wiadomość. Zobacz na własnym ekranie wiadomość wysłaną od kogoś.

<html><small></html>

Istnieje też komenda ''[[https://en.wikipedia.org/wiki/Talk_(software)|talk]] //użytkownik//'' pozwalająca na rozmowę między dwoma użytkownikami.

<html></small></html>

==== Przełączenie się na innego użytkownika ====

Posiadając odpowiednie uprawnienia i/lub znając odpowiednie hasło (w zależności od ustawień systemu) można przełączyć się na innego użytkownika bądź wykonać komendę jako inny użytkownik.

Komenda ''**su** [-] [//użytkownik//]'' po autoryzacji uruchamia domyślną powłokę dla podanego użytkownika (domyślnie roota). \\
Komenda ''su -c //komenda// [-] [//użytkownik//]'' po autoryzacji uruchamia w domyślnej powłoce dla podanego użytkownika (domyślnie roota) podaną komendę. \\
''su'' jest dostępna w każdym uniksopodobnym systemie.
W domyślnych ustawieniach Linuksa komenda ''su'' wymaga podania hasła użytkownika docelowego (i w niektórych dystrybucjach przynależności do odpowiedniej grupy, zwykle ''wheel'').

Na wielu dystrybucjach instalowana jest też komenda ''sudo'' która ma na celu zezwolenie wybranym użytkownikom na wykonywanie wybranych komend z uprawnieniami wskazanych użytkowników. Do autoryzacji ''sudo'' wykorzystuje hasło bieżącego bądź docelowego użytkownika.
W niektórych dystrybucjach komenda ''sudo'' jest nadużywana do zastąpienia komendy ''su''.

~~Zadanie.#~~ Zaloguj się na podany przez prowadzącego serwer przez ssh (prawdopodobnie ''ssh user//N//@fe80::1%br0''). Zmień użytkownika na ''root''. Zmień użytkownika na innego ''user//N//''.

<html><small></html>

Root może też korzystać z komend ''runuser'' i ''setpriv'' do uruchamiania komend z innym uid/gid/[[https://linux.die.net/man/7/capabilities|uprawnieniami]].

<html></small></html>

==== Uprawnienia dostępu do plików ====

=== Rodzaje i zapis uprawnień ===

W uniksopodobnych systemach dostęp do pliku określają trzy podstawowe uprawnienia: odczytu (__**r**__ead), zapisu (__**w**__rite) i wykonania (e__**x**__ecute).
\\
Każde z tych uprawnień jest przyznawane osobno właścicielowi pliku (__**u**__ser), grupie pliku (__**g**__roup) i pozostałym użytkownikom (__**o**__thers).
\\
Dodatkowo można ustawić trzy uprawnienia specjalne: set-user-id (sgid, __**s**__), set-group-id (sgid, __**s**__) i sticky (__**t**__).

Prawo do wykonania dla pliku oznacza możliwość uruchomienia go (jako skryt, program etc.), dla katalogu – wejścia do niego.

Suid/sgid nadany zwykłym plikom oznacza, że po uruchomieniu proces będzie działać z efektywnym uid/gid właściciela pliku.
\\
<small>
Zauważ że skrypt są interpretowane przez inny program, nie uruchamiane. Nadanie skryptowi suid/sgid nie ma wpływu na jego działanie.
\\
Suid pozwala np. zwykłemu użytkownikowi zmienić hasło (czyli zmienić plik /etc/shadow do którego zwykły użytkownik nie ma dostępu).
\\
Sgid pozwala np. zwykłemu użytkownikowi uruchamiać maszyny wirtualne w VirtualBoxie czy analizować pakiety sieciowe w Wiresharku.
</small>

[[https://en.wikipedia.org/wiki/Sticky_bit|Sticky bit]] nadany katalogowi D oznacza, że plik X z katalogu D może usunąć tylko właściciel pliku X bądź katalogu D.
\\
<html><small></html>
Sticky bit ustawiany jest w katalogu ''/tmp'' i innych, gdzie każdy użytkownik może tworzyć pliki o to, by tylko właściciel (bądź root) mogli usunąć pliki.

Suid/sgid dla innych plików niż zwykłe i sticky bit dla innych plików niż katalogi nie mają spójnego znaczenia w uniksopodobnych systemach.

Przy montowaniu systemu plików można ustawić opcję ''nosuid'' która wyłącza działanie suid/sgid

<html></small></html>

Uprawnienia są przechowywane jako liczba, gdzie wartości kolejnych bitów oznaczają (od najstarszego bitu): prawa specjalne (w kolejności suid, sgid, sticky), i prawa dla użytkownika, grupy, innych (w kolejności odczyt, zapis, wykonanie).
\\
Numerycznie uprawnienia zapisuje się w systemie ósemkowym, np: ''<color #f000f0>4</color><color #800000>7</color><color #008000>5</color><color #000080>1</color>'' gdzie kolejne cyfry oznaczają uprawnienia <color #f000f0>specjalne</color> (tutaj: suid), <color #800000>użytkownika</color> (tutaj: wszystkie), <color #008000>grupy</color> (tutaj: odczyt i wykonanie) i <color #000080>innych</color> (tutaj: żadne).

Tekstowo uprawnienia zapisuje się jako: ''<color #800000>rwx</color><color #008000>rwx</color><color #000080>rwx</color>'', gdzie kolejne trójki to właśnie uprawnienia <color #800000>użytkownika</color>, <color #008000>grupy</color> i <color #000080>innych</color>. 
\\
Brak danego uprawnienia zapisuje się przez **''-''**.
\\
Zwykle przed tak zapisanymi uprawnieniami pojawia się dodatkowa litera określająca typ pliku.
\\
Uprawnienia specjalne zapisuje się na pozycji uprawnień wykonania: suid i prawo do wykonanie to ''s'', suid i brak prawa do wykonania to ''S'' na pozycji użytkownika. Analogicznie prezentowany jest sgid na pozycji grupy, i sticky bit z literami ''t'' i ''T'' na pozycji pozostałych.
\\
Przykładowo: ''rw-r--r--'' oznacza że użytkownik ma prawo zapisu i odczytu, a pozostali tylko do odczytu (równoważne ''644''),
\\
a ''rwx--x--x'' pozwalają właścicielowi na odczyt, zapis i wykonanie pliku, a grupie i pozostałym tylko na wykonanie (''711'').

Aby zobaczyć szczegółowe informacje o pliku, w tym uprawnienia, można wykonać ''**stat** //plik//''.
\\
Uprawnienia są też wyświetlane w wynikach ''ls -l'' i ''tree -p''.
\\
Wszystkie powyższe polecenia dodają na początek uprawnień literę określającą rodzaj pliku.

~~Zadanie.#~~ Sprawdź jakie uprawienia mają (na twoim komputerze):
  * twój katalog domowy
  * podkatalog ''.ssh'' w twoim katalogu domowym
  * plik ''.bash_history'' w twoim katalogu domowym
  * plik ''/etc/passwd'' i ''/etc/shadow''
  * katalog ''/tmp''
  * plik ''/usr/bin/passwd'' i ''/usr/bin/write''

~~Zadanie.#~~ Sprawdź jakie mają uprawnienia i jakim są rodzajem plików:
  * ''/var/run''
  * ''/dev/sda'' lub ''/dev/nvme0n1''
  * ''/dev/null''
  * ''/run/initctl''
  * ''/run/rpcbind.sock''
  
=== Zmiana uprawnień, grupy i użytkownika pliku ===

Domyślnie uprawnienia nadawane plikom i katalogom określa maska którą można odczytać poleceniem ''**umask**'' (i zmienić dla bieżącej powłoki poleceniem ''umask //oktalnie//'').

Do zmiany uprawnień służy komenda ''**chmod** //uprawnienia// //plik//''.
\\
''chmod'' przyjmuje uprawnienia w postaci ósemkowej, np. ''chmod 644 plik'' lub w postaci symbolicznej. \\
Postać symboliczna to oddzielone przecinkami wyrażenia na które składa się:
  * litera ''u'', ''g'', ''o'' lub ''a'' (user, group, others lub __**a**__ll - wszyscy)
  * operacja ''+'', ''-'' lub ''='' (dodaj, usuń lub ustaw te prawa)
  * uprawnienia ''r'', ''w'', ''x'', ''s'' lub ''t''.
Przykładowo ''u+x,o='' doda użytkownikowi prawo do zapisu i ustawi brak praw dla innych.
\\
<small>Pominięcie litery ''[ugoa]'' przed operacją ma specjalne znaczenie, szczegóły w podręczniku systemowym.</small>

Właściciel pliku będący w kliku grupach może użyć komendy ''**chgrp** //grupa// //plik//'' do zmiany grupy do której należy plik.

Tylko root może zmienić właściciela (i grupę) pliku poleceniem ''**chown** [//właściciel//][:[//grupa//]] //plik//''.

Zarówno ''chmod'', ''chgrp'' i ''chown'' przyjmują przełączniki ''-R'' (''--recursive'') dla rekursywnej zmiany i ''--reference=//plik//'' dla ustawienia uprawnień/grupy/właściciela identycznego jak we wskazanym pliku.

//Ćwiczenia wykonuj na podanym przez prowadzącego serwerze. \\ Do tworzenia plików możesz wykorzystać np. komendę // ''fortune > //plik//''.

~~Zadanie.#~~ Stwórz plik. Ustaw takie prawa dostępu, żeby tylko właściciel mógł odczytać plik.
\\
Sprawdź poprawność nadanych praw przełączając się na innych użytkowników.

~~Zadanie.#~~ Stwórz plik. Ustaw korzystając z ósemkowego zapisu takie prawa dostępu, żeby właściciel mógł zmodyfikować i odczytać plik, a grupa mogła tylko odczytać plik. Sprawdź poprawność nadanych praw.

~~Zadanie.#~~ Stwórz plik. Ustaw korzystając z symbolicznego zapisu takie prawa dostępu, żeby właściciel mógł zmodyfikować i odczytać plik, a grupa mogła tylko odczytać plik.

~~Zadanie.#~~ Zmień grupę pliku z poprzedniego zadania.

~~Zadanie.#~~ Stwórz plik. Ustaw takie prawa dostępu, żeby tylko właściciel i pozostali mogli odczytać plik. Sprawdź czy osoba należąca do grupy pliku może go odczytać.

~~Zadanie.#~~ Stwórz katalog ze zwykłym plikiem w środku. Odbierz prawo do wykonywania katalogu. Spróbuj wylistować katalog, wejść do katalogu i wyświetlić plik bez wchodzenia do katalogu.

~~Zadanie.#~~ Zmień prawa dostępu katalogu na ''u=rwx,go=rx''. Stwórz w tym katalogu zwykły plik. Wyświetl plik jako inny użytkownik. Wyświetl zawartość katalogu jako inny użytkownik. \\ Następnie zmień prawa do katalogu ''u=rwx,go=x''. Spróbuj ponownie wyświetlić plik i zawartość katalogu jako inny użytkownik.

~~Zadanie.#~~ Stwórz katalog z prawami dostępu ''777'' i stwórz w nim dwa pliki. Jednemu z nich ustaw prawa ''600''. Z innego użytkownika spróbuj usunąć oba pliki.

~~Zadanie.#~~ W katalogu użytkownika A z prawami dostępu ''777'' stwórz jako użytkownik B dwa katalogi: jeden pusty, jeden z plikiem w środku. Spróbuj usunąć te katalogi jako użytkownik A.

~~Zadanie.#~~ Czy możesz zmienić nazwę katalogu K który nie dał się usunąć w poprzednim zadaniu? Czy możesz przenieść katalog K do innego? Czy możesz przenieść katalog zawierający K do innego?

~~Zadanie.#~~ Stwórz plik i katalog z plikiem w środku i odbierz wszystkim trzem wszystkie uprawnienia. Zmień użytkownika na root i spróbuj wyświetlić oba pliki.

~~Zadanie.#~~ Z roota zmień właściciela wybranego pliku. Następnie zmień grupę innego pliku na ''www-data''.

==== Data utworzenia, modyfikacji, dostępu ====

Linuksowe system plików zwykle przechowują datę zmiany metadanych (//change//, ctime), zmiany treści (//modify//, mtime) i ostatniego dostępu (//access//, atime) dla każdego pliku. Niektóre systemy plików dodatkowo przechowują też czas utworzenia pliku.
\\
<small>Montując system plików często wyłącza się rejestrowanie czasu ostatniego dostępu podając opcję ''noatime'' lub ustawia zmianę tego czasu tylko w szczególnych przypadkach podając opcję ''relatime''. Komenda ''mnt'' i ''findmnt'' wyświetlają z jakimi opcjami zamontowano system plików.</small>

Polecenie ''stat //plik//'' pokazuje te czasy.

Komenda ''touch //plik//'' ustawia czas dostępu i modyfikacji pliku, domyślnie na teraz.
\\
Podając ''-d //data//'' lub ''--reference=//plik//'' można wybrać inną datę, a ''-a'', ''-c'' i ''-m'' wybierają który czas zmodyfikować.
\\
Jeśli plik docelowy nie istnieje, domyślnie komenda ''touch'' go stworzy. Jest to często używane do tworzenia pustych plików.


~~Zadanie.#~~ Sprawdź daty dla pliku ''/var/log/wtmp''

~~Zadanie.#~~ Zmień daty do swojego katalogu domowego.

<html><small></html>

~~Zadanie.#~~ Zmień datę zmiany zawartości wybranego pliku na ''13:30 PDT Saturday month ago''.

<html></small></html>

===== Edycja linii poleceń  =====

Bash (i wiele innych programów) korzysta do odczytywania komend ze standardowego wejścia biblioteki [[https://en.wikipedia.org/wiki/GNU_Readline|readline]].
\\
Część programów z przyczyn licencyjnych wybiera do tego samego celu [[https://thrysoee.dk/editline/|libedit]].

Readline pozwala na wygodną edycję linii poleceń i tworzenie historii poleceń.

Lista sensownych skrótów klawiszowych do edycji linii poleceń jest tutaj: https://readline.kablamo.org/emacs.html
\\
Pełna lista komend i przypisanych do nich skrótów jest w podręczniku systemowym (''man readline'' i ''man bash'').
\\
Konwencja zapisu skrótów klawiszowych to:
  * ''^//x//'' lub ''C-//x//'' to //Ctrl+x// (uwaga:''^//X//'' lub ''C-//X//'' to //Ctrl+Shift+x//),
  * ''M-//x//'' to zwykle //Alt-x// (patrz: https://en.wikipedia.org/wiki/Meta_key),
  * ''//a// //b//'' to wciśnięcie po skrócie //a// skrótu //b//.

Bash domyślnie dopisuje historię wykonanych poleceń do pliku ''~/.bash_history'' w momencie wyjścia z powłoki.
\\
Historię (tą z pliku połączoną z bieżącą) można wyświetlić komendą ''history''. (W ''man bash_builtins'' znajduje się opis przełączników.)

<html><small></html>

Do wygodnego przeglądania historii można też użyć programu [[https://dvorka.github.io/hstr/|hstr]]

<html></small></html>

~~Zadanie.#~~ Jakim skrótem czyści się ekran?

~~Zadanie.#~~ Jakimi skrótami wyszukuje się wstecz w historii?

~~Zadanie.#~~ Jakim skrótem przesuwa się kursor o jedno słowo?

<html><small></html>

~~Zadanie.#~~ Jakim złożeniem skrótów przesuwa się kursor o 5 słów?

~~Zadanie.#~~ Jakim skrótów wstawia się ostatnie słowo z poprzedniego polecenia w historii?

~~Zadanie.#~~ Jakim złożeniem skrótów wstawia się trzecie od końca słowo z poprzedniego polecenia w historii?

~~Zadanie.#~~ Jakim skrótem zamienia się kolejnością to słowo z poprzednim?

<html></small></html>

===== Edycja plików w konsoli =====

=== vi i vim ===

''vi'' jest często jedynym domyślnie instalowanym edytorem tekstowym.

''vim'' to ulepszona wersja ''vi''.

Żeby nauczyć się ''vim'', uruchom ''vimtutor''.


<html><small></html>

''vi'' jest wpisane w standard [[https://pubs.opengroup.org/onlinepubs/9699919799/utilities/vi.html|POSIX]].
\\
Jest też częścią minimalistycznych zestawów narzędzi takich jak busybox i toybox.

<html></small></html>

~~Zadanie.#~~ Przejdź całą pierwszą lekcję w ''vimtutor''.

<html><small></html>

~~Zadanie.#~~ Przejdź pozostałe lekcje w ''vimtutor''.

=== nano ===

Nano jest stosunkowo prostym edytorem tekstowym.

Podstawowe skróty są wyświetlone na dole ekranu.

Więcej na: https://www.nano-editor.org/docs.php

=== Emacs ===

[[https://www.gnu.org/software/emacs/|Emacs]] jest [[https://en.wikipedia.org/wiki/Editor_war|odwiecznym rywalem]] ''vim''a w konkurencji programów do edytowania tekstu w konsoli.

Po wpisaniu ''emacs'' możesz wybrać tutorial skrótem //Ctrl+h t//.

=== Inne ===

  * [[https://joe-editor.sourceforge.io/joe]]
  * mcedit – edytor zintegrowany z [[https://en.wikipedia.org/wiki/Midnight_Commander|mc]]
  * [[https://micro-editor.github.io/|micro]]
  * [[https://neovim.io/|neovim]]
  * [[https://helix-editor.com/|hx]]
  
<html></small></html>


===== Spanie, mierzenie i limitowanie czasu =====

Komenda ''sleep //czas//'' śpi podany czas.
\\
Domyślną jednostką czasu są sekundy (''s''), ale można podać też ''m'', ''h'' i ''d''. 
\\
<small>''sleep 1d'' jest równoważne ''sleep 24h'' i ''sleep 1440m'' i ''sleep 86400[s]''.
\\
Niektóre implementacje sleep rozumieją ułamki dziesiętne, np. ''sleep 0.05m'' będzie spać 3s.</small>

Komenda ''time //polecenie// [//argumenty//]...'' uruchamiana podane polecenie z argumentami i mierzy czas jego wykonania.

<small>
Komenda ''timeout //czas// //polecenie// [//argumenty//]...'' uruchamiana podane
polecenie i przerywa je po upłynięciu wskazanego czasu.
</small>

~~Zadanie.#~~ Wykonaj komendę która śpi przez 2 sekundy.

~~Zadanie.#~~ Zmierz ile czasu trwa wykonanie komendy z poprzedniego zadania.


<small>
~~Zadanie.#~~ Zmierz ile czasu trwa wykonanie komendy ''openssl dhparam -text 1536''.

~~Zadanie.#~~ Wykonaj komendę ''openssl dhparam -text 2048'' z limitem czasu 5s.
</small>


===== Procesy =====

==== Proces a program ====

Program jest sekwencją instrukcji((zwykle uzupełnionym o opis tego, w jakim
środowisku je uruchomić – początkowy stan pamięci włączając stan zmiennych
globalnych i załadowane biblioteki dynamiczne)).
Proces to uruchomienie (instancja) programu.

Na proces poza sekwencją instrukcji (załadowaną do pamięci operacyjnej) składa
się wszystko co opisuje stan jego wykonania – np. zawartość rejestrów procesora,
stan pamięci operacyjnej.

Uruchamiając ten sam program (tą samą aplikację) wielokrotnie tworzy się wiele
procesów.

=== Rodzice, dzieci, zombie… ===

W uniksopodobnych systemach nowy proces może być uruchomiony tylko przez inny
proces <small>(poza pierwszym procesem, o identyfikatorze 1, zwanym
[[https://en.wikipedia.org/wiki/Init|init]], uruchamianym przez jądro systemu
operacyjnego przy starcie</small>.

Określenie **procesy potomne** procesu //x// (//child processes//) opisuje procesy
uruchomione przez //x//.
\\
**Rodzic** (//parent process//) procesu //x// to proces który uruchomił //x//.

Procesy są identyfikowane przez **pid** (//process identifier//).
\\
Dla każdego procesu utrzymywany jest identyfikator rodzica – **ppid** (//parent pid//).

Kiedy kończy się proces potomny, system operacyjny utrzymuje proces do czasu aż
jego wartość wyjściowa zostanie zebrana (//reap//) przez rodzica.
\\
Proces który się zakończył, ale jego wartość nie została zebrana przez rodzica,
nazywany jest [[https://en.wikipedia.org/wiki/Zombie_process|zombie]].

<small>
Rodzic procesu dostaje sygnał SIGCHLD kiedy coś się stanie z procesem potomnym,
np. kiedy proces potomny się zakończy.

Jeśli proces //a// uruchomi //b//, proces //b// uruchomi //c//, to po zakończeniu
//b// proces //c// staje się [[https://en.wikipedia.org/wiki/Orphan_process|sierotą]]
(//orphan process//) i jego rodzicem zostaje proces init.

<html> <!--
"Kill process or sacrifice child" znikło już z kernela?
https://github.com/torvalds/linux/commit/5989ad7b5ede38d605c588981f634c08252abfc3#diff-268fe084429e2dda106503d80d590ac28f341bcf5969eaed6c09891eea0ca466L863
--> </html>
</small>

==== Wyświetlanie informacji o procesach ====

=== Lista procesów ===

Do wyświetlenia listy procesów i wątków w systemie można użyć komendy **''ps''**.
\\
Wybór użytecznych opcji dla ''ps'':
  * ''-e'' wybiera wszystkie procesy w systemie
  * ''-l|-f|-F'' wybiera długi, pełny lub ekstra pełny format wyjścia
  * ''-L|-T'' pokazuje wątki
  * <small>''-H'' sortuje hierarchicznie i rysuje (wcięciami w polu komenda) dzieci</small>

<small>
Program ''ps'' posiada dwie składnie poleceń – jedną spójną z typową dla systemu
UNIX (powyższa), drugą pochodzącą z systemów BSD.
\\
Powszechnie spotykane ''ps aux'' to wywołanie ''ps'' z opcjami zapisanymi w
stylu BSD pokazujące wszystkie procesy w systemie w konkretnym formacie.
</small>

~~Zadanie.#~~ Wyświetl listę procesów poleceniem ''ps'' (bez argumentów).

~~Zadanie.#~~ Wyświetl listę procesów poleceniem ''ps'' zmieniając format wyników (kolumny) tak żeby było więcej szczegółów.

~~Zadanie.#~~ Wyświetl listę wszystkich procesów w systemie.

~~Zadanie.#~~ Wyświetl listę wszystkich procesów i wątków w systemie. Znajdź na niej dwa wątki tego samego procesu.

Lista procesów w formie drzewa może być wyświetlona komendą **''pstree''**.
\\
W ''pstree'' przełącznik ''-p'' dodaje pidy, ''-u'' użytkownika, a ''a''
pokazuje argumenty z jakimi został uruchomiony proces.

~~Zadanie.#~~ Wyświetl drzewo procesów. 

~~Zadanie.#~~ Wyświetl drzewo procesów z pidem każdego procesu.

Pseudo system plików ''procfs'', zamontowany standardowo w ''/proc'', pozwala
odczytać informacje o procesach przez dostęp do plików.
Katalog ''/proc/self'' zawiera szczegółowe informacje o procesie który próbuje
je przeczytać.
\\
W ''man 5 proc'' znajdziesz szczegółowe informacje.

~~Zadanie.#~~ Wyświetl zawartość pliku ''/proc/self/status''. Informacje o jakim procesie zostały wyświetlone?

<small>
~~Zadanie.#~~ Doczytaj w podręczniku i sprawdź co jeszcze jest w katalogach ''/proc/****//pid//****/''.

Określenie zużycia pamięci przez proces jest trudne.\\
System wie jakie zakresy pamięci są dostępne dla procesu, więc można określić
ile bajtów zajmuje pamięć wirtualna procesu (//virtual set size//).
Ale system operacyjny nie ładuje wszystkiego czego proces zażądał od razu do
pamięci (część danych jest ładowana dopiero przy próbie dostępu do nich).
\\
System wie za to do czego proces ma w tej chwili dostęp w RAMie
(//resident set size//).
Ale to nie wlicza swapa, a i bez tego jeżeli jakiś plik jest współdzielony przez
wiele procesów (np. biblioteka do rysowania okienek), to suma RSSów nie będzie
równa zajętości pamięci.
\\
Mając odpowiednie uprawnienia, można w Linuksie określić do jakiej pamięci ma
dostęp tylko ten proces (//unique set size//), a rozmiary współdzielonych plików
można proporcjonalnie doliczyć do tej pamięci dostając w miarę rozsądną metrykę
zajętości pamięci (//proportional set size//).
\\
Ale co z swapem i [[https://en.wikipedia.org/wiki/Zram|kompresją wewnątrz RAMu]]…

Zużycie pamięci próbuje sensownie pokazać program ''smem''; sprawdź opcje ''-p'' i ''-t''.
</small>

=== Monitory procesów ===

Komenda **''top''** jest dostępnym w wielu systemach narzędziem pokazującym na
bieżąco listę procesów i podstawowe informacje o obciążeniu systemu.

~~Zadanie.#~~ Uruchom ''top''. Naciśnij ''h'' żeby dostać się do pomocy.
Zmień kolumnę po której są sortowane dane.

~~Zadanie.#~~ Co oznaczają stany procesu ''R'', ''S'', ''D'', ''t'' i  ''Z''?
Sprawdź w ''man ps''.

Program **''[[https://htop.dev/|htop]]''** został stworzony jako wygodny i bardziej
funkcjonalny ''top''.
\\
<small>Podstawowe skróty w htop są w pasku menu na dole; ''h'' pokazuje pomoc,
''t'' przełącza między trybem drzewa i zwykłą listą, ''<'' i ''>'' sortują
procesy, ''k'' wysyła sygnał do procesu, ''a'' ustawia na których procesorach
może działać program (affinity), ''i'' ustawia priorytet dostępu do dysku,
''/'' szuka, a ''\'' filtruje po nazwie, ''u'' filtruje po użytkowniku, //space//
zaznacza procesy, //tab// przełącza między użyciem procesora i pamięci
a użyciem dysku.
\\
''htop'' pozwala używać myszy do nawigacji i pozwala łatwo konfigurować zarówno
pasek górny jak i wygląd listy procesów.</small>

~~Zadanie.#~~ W programie ''htop'' zmień kolumnę sortowania.

<small>
~~Zadanie.#~~ W programie ''htop'' ustaw tryb drzewa i znajdź program ''htop'' w liście procesów.

Poza programem ''htop'', istnieje wiele narzędzi wzorowanych na ''top'' pokazujących
stan systemu i procesów. Są to m. in.. ''iotop'' (użycie I/O), ''atop'', ''glances''.
</small>

=== Wyszukiwanie procesów ===

Programy **''pgrep''** <small>i **''pidof''**</small> pozwalają wyszukiwać pid
procesu na podstawie podanych kryteriów.

Domyślnie ''pgrep //regex//'' dopasowuje //regex// do nazwy programu. \\
Z ''-f'' szuka po pełnej linii poleceń (nazwa programu z argumentami). \\
Inne opcje pozwalają wyszukać procesów potomnych podanego procesu czy procesów
wybranego użytkownika.

<small>Program ''pidof //nazwa//'' wyświetli pidy procesów których nazwa
(przycięta do 15 znaków) jest identyczna z podaną.</small>

~~Zadanie.#~~ Uruchom program ''sleep 1h''.  W innym terminalu znajdź jego pid.

<small>

~~Zadanie.#~~ W jednym terminalu uruchom program ''sleep 1337h'', w drugim ''sleep 42h''. Znajdź pid tego pierwszego.

~~Zadanie.#~~ Znajdź pid procesu ''gdm'' wiedząc, że na twoim komputerze są też inne procesu mające na początku nazwy ciąg liter ''gdm''.

</small>

==== Sygnały ====

Sygnały są dla procesów odpowiednikiem przerwań. 
\\
Posiadając odpowiednie uprawnienia można wysłać sygnał do procesu – tzn. zażądać
od systemu operacyjnego, wykonując wywołanie systemowe ''kill'', dostarczenia
sygnału do procesu.
\\
System operacyjny dodaje każdy wysłany sygnał do listy oczekujących sygnałów
i jeśli tylko może, to dostarcza go.
\\
Dla większości sygnałów programista może ustawić czy dany sygnał ma być
dostarczany do programu i która (napisana przez programistę) funkcja ma być
wywołana kiedy sygnał zostanie dostarczony.
\\
Dostarczenie sygnału przez system operacyjny polega, podobnie jak przy wywołaniu
funkcji, na zapisaniu stanu jednego z wątków, przygotowaniu na stosie informacji
o sygnale i ustawienie licznika rozkazów na funkcję którą programista wskazał
do obsługi sygnału.
<small> Sygnał może być dostarczony w dowolnie niewygodnym momencie </small>

Sygnały rozróżnia się po numerach i odpowiadających im nazwach (''man 7 signal'').
\\
Często jako skrót "sygnał //X//" zapisuje się jako SIG//X//, np. sygnał TERM to SIGTERM.
\\
Sygnały są zwykle używane do informowania procesu o błędach, zewnętrznych
zdarzeniach lub do komunikacji między procesami.

Przykłady sygnałów:
  * INT – prośba o przerwanie procesu, generowane np. przez //Ctrl+c//,
  * TERM – prośba o zakończenie procesu,
  * KILL – żądanie zabicia procesu; jeden z dwóch sygnałów których programista nie może obsłużyć po swojemu,
  * STOP – zatrzymanie (zapauzowania) procesu; drugi z sygnałów których programista nie może obsłużyć po swojemu, \\ CONT – kontynuacja zatrzymanego procesu,
  * <small>ALRM – proces poprosił o sygnał po upływie jakiegoś czasu i ten czas właśnie minął,</small>
  * <small>SEGV – proces próbował dostać się do pamięci niezwiązanej z procesem,</small>
  * <small>USR1 – sygnał bez określonego znaczenia, do dowolnego użycia programisty,</small>
  * HUP – wysyłany przy zamykaniu (pseudo)terminala – tzn. przy zamknięciu emulatora terminala lub rozłączeniu sesji SSH; <small>wiele programów serwerowych przeładowuje pliki po odebraniu tego sygnału. \\ Uruchamiając dowolną komendę jako ''nohup //komenda// //argumenty//...'' spowoduje zignorowanie tego sygnału przez uruchomiony proces.</small>

=== Wysyłanie sygnałów ===

Do wysłania sygnału służy komenda ''**kill** [-//sygnał//] //pid//''.
Jeśli nie określono który sygnał wysłać, ''kill'' wyśle TERM.
\\
Sygnał można zapisać jako jego numer, np. ''kill -3 //pid//'' lub nazwę, np. ''kill -INT //pid//''
\\
<small>Nazwy i numery sygnałów można sprawdzić komendą ''kill -l'' lub ''kill -L''.</small>
\\
Komenda ''kill'' przyjmuje tylko pid – numeryczny identyfikator procesu.
\\
<small>Podanie ujemnej wartości pid ma konkretne znaczenie; więcej w ''man kill''</small>

~~Zadanie.#~~ W jednym terminalu uruchom ''sleep 1h''. Z innego terminala zabij ten proces używając ''kill''.

Komenda ''**pkill**'' działa identycznie jak ''pgrep'', tylko zamiast wyświetlać
identyfikatory, wysyła wskazany (identycznie jak w komendzie ''kill'') sygnał do
pasujących procesów.

<small>
Komenda ''**killall** //nazwa//'' domyślnie wyśle sygnał do wszystkich procesów
których nazwa (przycięta do 15 znaków) jest identyczna z podaną. \\
Opcjami można m. inn. dopasować się do wyrażeń regularnych i pełnej nazwy.
</small>

~~Zadanie.#~~ W jednym terminalu uruchom ''sleep 1h''. Z innego terminala zabij ten proces używając ''pkill''.

~~Zadanie.#~~ Uruchom program ''mousepad''. Wyślij do niego sygnał STOP. Sprawdź jak działa mousepad. Potem wyślij do niego sygnał CONT.

<small>
~~Zadanie.#~~ Uruchom w jednym terminalu komendą ''named -g -c <(:)'' serwer DNS. Z drugiego terminalu wyślij sygnał HUP do ''named''a.
</small>

==== Proces a planiści ====

Przydziałem dostępu do zasobów komputera dla programu zajmuje się system
operacyjny. Użytkownik (administrator) może wpływać na to jakie decyzje
podejmują planiści
([[https://en.wikipedia.org/wiki/Scheduling_(computing)#Process_scheduler|[1]]],
[[https://en.wikipedia.org/wiki/I/O_scheduling|[2]]]).

=== Procesor ===

Procesy w uniksopodobnych systemach mają //[[https://en.wikipedia.org/wiki/Nice_(Unix)|niceness]]//,
które decyduje o priorytecie przydzielania CPU.
\\
Niceness jest ustawialne w zakresie od -20 (najwyższy priorytet) do 19 (najniższy) i dziedziczone od rodzica.
\\
Init startuje procesy z niceness 0.
\\
Podnieść niceness może każdy, obniżyć – tylko root.

Wykonując komendę ''**nice** [-n <//N//>] //komenda// [//argumenty//]...'' można uruchomić proces z podanym niceness.

Można też zmienić niceness działającego procesu komendą ''**renice** [-n]<//N//> //pid//''.

<small>

Część dystrybucji Linuksa włącza ''autogroup'' które umieszcza automatycznie
procesy w osobnych grupach (więcej w ''man 7 sched''). Niceness liczy się
tylko między procesami wewnątrz grupy. ''sysctl -ar sched_autogroup_enabled''
sprawdza czy ta funkcjonalność jest włączona.

Można też wybrać na których fizycznych wątkach procesora będzie się wykonywać
proces programem **''taskset''**.

Komenda ''taskset 0x03 //komenda// [//argumenty//]...'' i
''taskset -c 0,1 //komenda// [//argumenty//]...'' uruchomi proces tylko na
rdzeniach 0 i 1. \\
Komenda ''taskset -p [-c] //pid//'' wyświetli dozwolone fizyczne wątki dla podanego
pid, a ''taskset -p [-c] //spec// //pid//'' je zmieni na //spec//.

''htop'' pozwala zmieniać niceness (skróty //F7//''''/''''//F8//) i wybrać procesory
dla procesu (skrót //a// od affinity).

</small>

~~Zadanie.#~~ Uruchom komendę ''sleep 1h'' z niceness 10. Sprawdź jej nicneness (np. w ''ps'' / ''htop'').

~~Zadanie.#~~ Uruchom komendę ''sleep 1h'' i potem zmień jej niceness na 15.

~~Zadanie.#~~ W dwóch konsolach wykonaj ''taskset -pc 0 $$'' (<small>która zmieni listę dozwolonych procesorów tego shella na pierwszy</small>).\\
Następnie w obu wykonaj ''openssl dhparam -text %%$((2**14))%% [//dowolny tekst//]''
(<small>co uruchomi procesorożerne szukanie dużych liczb pierwszych</small>).\\
W trzeciej konsoli uruchom ''htop'' i obserwuj zużycie CPU. \\
Zmieniaj stopniowo niceness jednego z tych procesów. Jak zmienia się użycie CPU przez te procesy?

<small>

=== I/O ===

Priorytet dostępu do I/O (dysków) można ustawiać / zmieniać komendą **''ionice''**.
\\
Są dostępne "trzy" klasy: 1 (realtime), 2 (best-effort) i 3 (idle) oraz 0 (brak
klasy). Klasy 1 i 2 dzielą się na 8 priorytetów (od najwyższego 0 do
najniższego 7).
\\
Argumenty ''[-c //nr_klasy//] [-n //priorytet//]'' wybierają klasę i priorytet.
\\
Podobnie jak ''taskset'', można uruchomić polecenie z podaną klasą, bądź z
przełącznikiem ''-p'' wyświetlić / zmienić ustawienia dla podanego pid.

''htop'' pozwala zmieniać klasy I/O (skrót //i//).

=== NUMA ===

Sprzęt w których zasoby (głównie pamięć) mają różny koszt dostępu z różnych
procesorów ([[https://en.wikipedia.org/wiki/Non-uniform_memory_access|NUMA]])
jest przez system dzielony na węzły wewnątrz których dostęp ma równy koszt, ale
między którymi koszt dostępu jest większy.
\\
Przykład – na płycie głównej z dwoma gniazdami na procesory pamięć DRAM podłączona
do procesora na którym działa proces ma niższy koszt dostępu niż pamięć RAM
podłączona do procesora w drugim gnieździe.

Polecenie **''numactl''** pozwala kontrolować jak mają być uruchamiane procesy
w takich systemach.
\\
''numactl -H'' pokazuje listę węzłów, a
''numactl -N //x// -m //y// //komenda// [//argumenty//]...'' uruchamia komendę 
na procesorach z węzła //x// i pamięci z węzła //y//.

</small>


  
~~META:
language = pl
~~
Jan Kończak

Narzędzia użytkownika

Narzędzia witryny

Narzędzia strony
