Verified Commit 120b7153 authored by Stephane Bonnet's avatar Stephane Bonnet
Browse files

semi-adv v1.0

parent b1a2572a
Pipeline #33806 failed with stage
in 18 seconds
......@@ -12,6 +12,7 @@
\usepackage{fancyvrb}
\usepackage{xcolor}
\usepackage{bold-extra}
\usepackage{array}
\hypersetup{
pdfauthor={Stéphane Bonnet},
pdftitle={Api/casoft Init - Jour 2 : Linux avancé},
......
......@@ -844,27 +844,308 @@ The quick yellow fox jumps over the lazy dog
\subsection{Processus et jobs}
\begin{frame}[fragile]{Les processus}
\framesubtitle{Définition}
\begin{block}{Qu'est-ce que c'est?}
\begin{itemize}
\item Un processus est un programme en cours d'exécution.
\item Un programme est un exécutable binaire stocké sur le disque dans un fichier
\item A son exécution, le programme est copié en mémoire par le système et
devient un processus.
\item De nombreux processus s'exécutent en même temps: c'est une des fonctions
principales du système de partager le processeur et la mémoire entre ceux-ci.
\end{itemize}
\end{block}
\end{frame}
\begin{frame}[fragile]{Mettre fin à des processus}
\begin{frame}[fragile]{Les processus}
\framesubtitle{Hierarchie des processus}
\begin{block}{PID}
Les processus sont identifiés par in nombre: l'identifiant du processus,
ou \emph{Process ID (PID)}.
\end{block}
\begin{block}{Arborescence des processus}
Un processus a un père unique: c'est le processus qui l'a créé. L'ID du
processus père est le \emph{Parent Process ID (PPID)}.
\end{block}
\begin{block}{Processus initial}
Le premier processus est exécuté directement par le noyau au démarrage. Il s'agit du
processus \cmd{init} (\cmd{systemd} sur Ubuntu). Son PID est 0 et il est l'ancêtre de
tous les processus.
\end{block}
\end{frame}
\begin{frame}[fragile]{Les processus}
\framesubtitle{État des processus}
A tout instant, un processus est dans l'un des états suivants:
\begin{center}
\begin{tabular}{|m{1cm}|m{3cm}|m{5.5cm}|}
\hline
\textbf{Lettre} & \textbf{Signification} & \textbf{Description} \\
\hline\hline
R & Running & Processus éligible au processeur \\
\hline
S & Sleeping & Processus en attente d'un événement \\
\hline
D & Uninterruptible Sleep & Processus en attente d'une entrée / sortie \\
\hline
T & Stopped & Processus interrompu par un signal de contrôle \\
\hline
Z & Zombie & Terminé, en attente du processus père \\
\hline
\end{tabular}
\end{center}
\end{frame}
\begin{frame}[fragile]{Les processus}
\framesubtitle{Voir les processus}
\begin{block}{\cmd{ps}}
\begin{description}
\item[\cmd{ps}] affiche les processus en cours d'exécution et les informations associées
\end{description}
\end{block}
\cmd{ps} seul affiche tous les processus de l'utilisateur associé au terminal:
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ ps
PID TTY TIME CMD
10923 pts/2 00:00:01 bash
12472 pts/2 00:00:00 cat
12622 pts/2 00:00:00 ps
\end{Verbatim}
\end{beamercolorbox}
Il y a ici trois processus. Les champs s'interprètent comme suit:
\begin{description}
\item[PID] Le PID
\item[TTY] Le terminal de contrôle
\item[TIME] Le temps réellement passé à utiliser le processeur
\item[CMD] La commande exécutée
\end{description}
\end{frame}
\begin{frame}[fragile]{Les processus}
\framesubtitle{Voir les processus}
La commande ``\cmd{ps a}'' affiche tous les processus de l'utilisateur.
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ ps a
PID TTY STAT TIME COMMAND
986 tty1 Ssl+ 0:00 /usr/lib/gdm3/gdm-x-session --run-script env GNOME_S
988 tty1 Sl+ 21:46 /usr/lib/xorg/Xorg vt1 -displayfd 3 -auth /run/user/
999 tty1 Sl+ 0:00 /usr/lib/gnome-session/gnome-session-binary --sessio
1163 tty1 Sl+ 41:15 /usr/bin/gnome-shell
1208 tty1 Sl 14:18 ibus-daemon --xim --panel disable
1212 tty1 Sl 0:00 /usr/lib/ibus/ibus-dconf
[...]
\end{Verbatim}
\end{beamercolorbox}
\medskip
La commande ``\cmd{ps aux}'' affiche tous les processus de tous les utilisateurs.
\end{frame}
\begin{frame}[fragile]{Les processus}
\framesubtitle{Voir les processus}
\begin{block}{\cmd{pstree}}
La commande \cmd{pstree} affiche l'arbre des processus en cours d'exécution/
\end{block}
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ pstree -A
systemd-+-ModemManager---2*[{ModemManager}]
|-NetworkManager-+-dhclient
| `-2*[{NetworkManager}]
|-2*[VBoxClient---VBoxClient]
|-2*[VBoxClient---VBoxClient---{VBoxClient}]
|-VBoxClient---VBoxClient---2*[{VBoxClient}]
|-VBoxService---7*[{VBoxService}]
|-accounts-daemon---2*[{accounts-daemon}]
|-acpid
|-avahi-daemon---avahi-daemon
|-boltd---2*[{boltd}]
|-colord---2*[{colord}]
|-cron
[...]
\end{Verbatim}
\end{beamercolorbox}
\begin{alertblock}{}
\cmd{systemd} est bien l'ancêtre de tout les processus...
\end{alertblock}
\end{frame}
\begin{frame}[fragile]{Les processus}
\framesubtitle{Suivre les processus en temps réel}
\begin{block}{\cmd{top}, \cmd{htop}}
\begin{itemize}
\item \cmd{top} affiche l'évolution des processus en temps réel. Quitter avec ``q''.
\item \cmd{htop} fait la même chose avec une interface plus moderne.
\end{itemize}
Ces deux commandes montrent aussi en temps réel l'utilisation des processeurs et
l'occupation de la mémoire. Elles permettent de suivre les performances du système.
\end{block}
\end{frame}
\begin{frame}[fragile]{Les processus}
\framesubtitle{Les signaux}
\begin{block}{Signal}
Le noyau peut transmettre des signaux aux processus pour des raisons diverses.
Les processus peuvent intercepter certains de ces signaux. S'il ne le font pas, alors
les signaux ont des effets par défaut sur le processus.
\end{block}
\begin{block}{Transmission de signaux par le clavier}
Quand un processus est exécuté au premier plan, certaines combinaisons de touches
provoquent la transmission de signaux vers celui-ci.
\begin{itemize}
\item \cmd{CTRL+C} envoie SIGINT. Met fin au processus avec potentielle perte de données.
\item \cmd{CTRL+Z} envoie SIGTSTP. Stoppe le processus et rend la main au shell.
\item \cmd{CTRL+]} envoie SIGQUIT. Met fin au processus plus brutalement que \cmd{CTRL+C}.
\end{itemize}
\end{block}
\end{frame}
\begin{frame}[fragile]{Les processus}
\framesubtitle{Effet des signaux}
\begin{exampleblock}{CTRL+C vs. CTRL+]}
\begin{itemize}
\item Installez \cmd{sl}: \cmd{sudo apt install sl}
\item Lancer sl. Le train passe.
\item Observez la différence entre CTRL+C et CTRL+] pendant le passage du train.
\end{itemize}
\end{exampleblock}
\end{frame}
\begin{frame}[fragile]{Exécution en arrière plan}
Une commande exécutée en arrière plan est dite \emph{détachée} du terminal.
\begin{block}{Exécution en arrière plan}
Faire suivre la commande de ``\&''. La commande se lance et rend la main au shell.
``\cmd{gedit \&}'' lance l'éditeur de texte gedit et rend la main.
\end{block}
\begin{block}{Arrière plan et signaux}
\cmd{CTRL+Z} suspend le processus attaché au terminal.
``\cmd{bg}'' le relance en arrière plan, comme si on l'avait exécuté avec ``\&''.
\end{block}
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ xeyes
^Z
[1]+ Arrêté xeyes
$ \textcolor{yellow}{bg}
[1]+ xeyes &
$
\end{Verbatim}
\end{beamercolorbox}
\end{frame}
\begin{frame}[fragile]{Mettre fin à des processus}
\begin{block}{\cmd{kill}}
Pour mettre fin à un processus, la commande à utiliser est \cmd{kill} suivie du PID du processus à tuer.
\end{block}
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ ps
PID TTY TIME CMD
13154 pts/5 00:00:00 bash
\textcolor{yellow}{13162} pts/5 00:00:01 xeyes
13178 pts/5 00:00:00 ps
$ kill \textcolor{yellow}{13162}
$
[1]+ Complété xeyes
$
\end{Verbatim}
\end{beamercolorbox}
\begin{alertblock}{Processus récalcitrants}
Par défaut, \cmd{kill} envoie \cmd{SIGTERM} au processus. Si le processus ne se termine pas avec
ce signal,
``\cmd{kill -KILL}'' (ou ``\cmd{kill -9}'') suivie du PID y mettra fin systématiquement mais avec plus de
risques de perte de données.
\end{alertblock}
\end{frame}
\begin{frame}[fragile]{Gestion des jobs}
\begin{itemize}
\item \cmd{jobs} affiche la liste des processus en arrière plan
\item \cmd{fg} ramène le processus indiquer en avant plan
\item \cmd{bg} passe le dernier processus arrêté en arrière plan
\item \cmd{kill} peut aussi s'utiliser avec un numéro de job.
\end{itemize}
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ xeyes &
[1] 13507
$ jobs
[\textcolor{yellow}{1}]+ En cours d'exécution xeyes &
$ kill \textcolor{yellow}{%1}
$
[1]+ Complété xeyes
$
\end{Verbatim}
\end{beamercolorbox}
\end{frame}
\subsection{Substitution de commandes}
\begin{frame}[fragile]{Substitution de commandes}
Consiste à récupérer la sortie d'une commande pour remplacer le texte de la commande.
\begin{block}{Syntaxe de la substitution de commande}
Deux syntaxes sont possibles:
\begin{itemize}
\item \cmd{\$( commande )}
\item \cmd{` commande `}
\end{itemize}
\end{block}
\begin{beamercolorbox}[rounded=true,shadow=true]{terminal}
\begin{Verbatim}
$ echo Nous sommes le \textcolor{yellow}{$(date +'%A %d %B %Y').}
Nous sommes le mardi 22 janvier 2019.
\end{Verbatim}
\end{beamercolorbox}
\end{frame}
\subsection{L'historique}
\begin{frame}[fragile]{Rappeler des commandes}
%% Historique + manipulation
%% Où est l'historique (bases)
\end{frame}
\begin{frame}[fragile]{Rechercher dans l'historique}
\cmd{bash} maintient un historique des commandes et permet de les rappeler pour ne pas avoir à les retaper. L'historique est stocké
dans le fichier \verb+~/.bash\_history+.
\begin{itemize}
\item La commande ``\cmd{history}'' affiche l'historique.
\item Les touches haut et bas permettent de naviguer dans l'historique.
\item Le point d'exclamation suivi d'une chaîne rappelle la dernière commande commençant par cette chaîne.
\item La combinaison \cmd{CTRL+R} entre en mode recherche dans l'historique. \cmd{CTRL+R} recherche à nouveau.
\end{itemize}
\begin{block}{Astuce}
La commande \cmd{!!} relance la dernière commande. On peut l'utiliser avec \cmd{sudo} pour relancer une commande
en superutilisateur:
\begin{center}
\cmd{sudo !!}
\end{center}
\end{block}
\end{frame}
\ No newline at end of file
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment