source: trunk/unix/unix.tex @ 199

% $Id: perl.tex 183 2008-09-04 23:55:50Z nanardon $
\documentclass[notes]{beamer}
\usepackage[frenchb]{babel}
\usepackage[T1]{fontenc}
\usepackage{moreverb}
\usepackage{graphicx}
\usepackage{listings}
\usepackage{color}

\mode<presentation>
{
  \definecolor{beamerstructure}{RGB}{143,79,112}
  \definecolor{sidebackground}{RGB}{230,242,250}
  \color{beamerstructure}
  \usetheme[secheader]{Madrid}
  \usepackage{times}
  \userightsidebarcolortemplate{\color{sidebackground}}
  \beamertemplateballitem
}

\AtBeginSection[]
{
\begin{frame}<beamer>
    \frametitle{Plan}
    \tableofcontents[currentsection,hideothersubsections]
\end{frame}
}

\AtBeginSubsection[]
{
\begin{frame}<beamer>
    \frametitle{}
    \tableofcontents[sectionstyle=show/hide,subsectionstyle=show/shaded/hide]
\end{frame}
}

\title{UNIX/Linux}
\subtitle{Jouer avec le système}
\author{Olivier Thauvin}
\date{\today}

\begin{document}

\frame{\titlepage}

\begin{frame}
\tableofcontents[hideallsubsections]
\end{frame}

\section{Préambule}

\subsection{L'Ordinateur}

\begin{frame}
\frametitle{Principaux composants}
\begin{columns}[c]
\column{2.5in}
\centering
\includegraphics[height=40mm]{asus_mb}

\column{2.5in}
\begin{itemize}
\item les éléments vitaux (PC)
\begin{itemize}
\item \textcolor{red}{CPU}
\item \textcolor{green}{Mémoire}
\item \textcolor{blue}{Bus}
\item clavier
\item carte graphique
\end{itemize}
\item le reste
\begin{itemize}
\item mulot et autres rongeurs
\item disques durs
\item carte son
\item \ldots
\end{itemize}
\end{itemize}
\end{columns}
\end{frame}

\begin{frame}[fragile]
\frametitle{Fonctionnement général}
\begin{itemize}
\item \textcolor{red}{CPU} (Central processor unit)
\begin{itemize}
\item fait les calculs
\item presque pas de mémoire (registres)
\end{itemize}
\item \textcolor{green}{Mémoire}
\begin{itemize}
\item sert à stocker les données
\item est moins rapide que le CPU (rapport \verb+~+ 1/3)
\end{itemize}
\item \textcolor{blue}{Bus}
\begin{itemize}
\item sur la carte mère
\item transporte les données entre les différents composants
\end{itemize}
\end{itemize}
\end{frame}

\subsection{LES UNIX}

\begin{frame}
\frametitle{la grande famille des UNIX}
\emph{
UNIX est le nom d'un système d'exploitation multitâche et multi-utilisateur créé en 1969,
conceptuellement ouvert et fondé sur une approche par laquelle il offre de nombreux petits
outils chacun dotés d'une mission spécifique.}

Définition \href{http://fr.wikipedia.org/wiki/UNIX}{Wikipédia}
\vfill

\textbf{Les grandes lignes:}

\begin{itemize}
\item mulitâche préemptif
\item multiutilisateurs (donc gestion de droit)
\item multisessions
\item tout est fichier
\end{itemize}
\end{frame}

\begin{frame}
\frametitle{Vite une Norme !}
\textbf{Exemples d'UNIX:}

\begin{itemize}
\item GNU/Linux
\item *BSD (Net, Free, Open, \ldots)
\item MacOS X (est un BSD, d'Apple)
\item Digital UNIX (de Digital)
\item Solaris (de Sun)
\item AIX (de IBM)
\item \ldots
\end{itemize}
\vfill

\textbf{Norme POSIX:}
standard de fonctionnement et commandes (IEEE).
\end{frame}

\begin{frame}
\frametitle{De l'ordi à l'utilisateur}
\begin{columns}[c]
\column{2.5in}
\centering
\includegraphics[height=40mm]{process}
\column{2.5in}
\begin{block}{Role du kernel}
\begin{itemize}
\item gérer le matériel
\item donner le temps CPU aux applications
\item vérifier les droits d'accès
\item assurer l'intégrité du système
\end{itemize}
\end{block}
\end{columns}
\end{frame}

\section{Les fichiers}

\subsection{Les fichiers}

\begin{frame}[fragile]
\frametitle{Nom de fichiers}

\begin{block}{Accès aux fichiers}
\begin{itemize}
\item le séparateur est \verb+/+
\item plusieurs \verb+/+ ne font qu'un
\item la longueur maximal d'un chemin est de 1024 (POSIX)
\item tout les caractère sont permis sauf \verb+/+ et \emph{NULL}
\end{itemize}
\end{block}

\begin{alertblock}{On évitera}
\begin{itemize}
\item l'espace
\item \verb+-+ (surtout en premier, option en ligne de commande)
\item ce qui ne se tape au clavier
\item les accents
\end{itemize}
\end{alertblock}

\end{frame}

\begin{frame}[fragile]
\frametitle{L'inode}

Le fichier est matérialisé par une inode:

{\small\begin{verbatim}
[olivier@andromede unix]$ ls -li unix.tex
6160386 -rw-r--r-- 1 olivier olivier 3049 17:30 unix.tex
\end{verbatim}
}

\begin{itemize}
\item un numéro (6160386)
\item un type
\item des métadata
\begin{itemize}
\item taille (3049)
\item propriétaires / droits d'accès
\item date d'accès (access time)
\item date de création \textbf{de l'inode} (creation time)
\item date de dernière modification (modification time)
\item \ldots
\end{itemize}
\item éventuellement un contenu
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\begin{alertblock}{quand ctime dépasse mtime}
Copie en préservant les métadata:
{\small\begin{verbatim}
[olivier@andromede unix]$ cp -a unix.tex unix2.tex
\end{verbatim}
}
Le fichier vient d'être créé:
{\small\begin{verbatim}
[olivier@andromede unix]$ ls -l --time=c unix2.tex
-rw-r--r-- 1 olivier olivier 3049 18:47 unix2.tex
\end{verbatim}
}
Pourtant la date de modification est antérieur:
{\small\begin{verbatim}
[olivier@andromede unix]$ ls -l  unix2.tex
-rw-r--r-- 1 olivier olivier 3049 17:30 unix2.tex
\end{verbatim}
}
\end{alertblock}
\end{frame}

\begin{frame}[fragile]
\frametitle{les types de fichiers}

- \emph{rw-r--r-- 1 olivier olivier 3049 17:30 unix2.tex}

\begin{itemize}
\item les simples fichiers (-)
\item les répertoires (d)
\item les liens symboliques (l)
\item les fichiers de périphérique (c ou b)
\item les fifo (tubes nommés, p)
\item les sockets (=)
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{existance d'un fichier}
\begin{block}{un fichier existe tant que}
\begin{itemize}
\item l'inode est référencée par un nom (lien hard)
\item l'inode est ouverte
\end{itemize}
\end{block}

\begin{exampleblock}{liens hard}
{\small\begin{verbatim}
[olivier@andromede unix]$ ln fichier1 fichier2
[olivier@andromede unix]$ ls -li fichier*
6160393 -rw-r--r-- 2 olivier olivier 1101 19:54 fichier1
6160393 -rw-r--r-- 2 olivier olivier 1101 19:54 fichier2
[olivier@andromede unix]$ rm -f fichier1
[olivier@andromede unix]$ ls -li fichier*
6160393 -rw-r--r-- 1 olivier olivier 1101 19:54 fichier2
\end{verbatim}
}
\end{exampleblock}
\end{frame}

\begin{frame}[fragile]
\begin{exampleblock}{deleteopen.pl}
\frametitle{existance d'un fichier}
\listinginput[2]{1}{deleteopen.pl}
\end{exampleblock}

\begin{block}{}
\begin{itemize}
\item le fichier n'est accessible que par l'application
\item si l'application quitte: l'espace disque est récupéré
\item la fermeture du descripteur entraine la fin du fichier
\end{itemize}
{\small\begin{verbatim}
perl 23536 ol 3w REG  8,7  0  49065 /tmp/opened (deleted)
\end{verbatim}
}
Utile pour les fichiers temporaires.
\end{block}
\end{frame}

\begin{frame}[fragile]
\frametitle{les fichiers à trous (sparse files)}
\end{frame}

\begin{frame}[fragile]
\frametitle{Fichier de périphérique}
\begin{block}{2 types}
\begin{itemize}
\item block (b)
\item caractères (c)
\end{itemize}
\end{block}

\begin{exampleblock}{Tout est fichier}
\begin{verbatim}
brw-rw---- 1 nanardon cdwriter 11, 0 12:26 /dev/sr0
\end{verbatim}

C'est le premier lecteur CDROM SCSI (SATA en réalité)

Je peux le lire comme un fichier:
\begin{verbatim}
[nanardon@virgo ~]$ dd if=/dev/sr0 bs=1024 count=20 | wc
20+0 enregistrements lus
20+0 enregistrements écrits
20480 octets (20 kB) copiés, 0,803619 s, 25,5 kB/s
      0       0   20480
\end{verbatim}
\end{exampleblock}
\end{frame}

\begin{frame}[fragile]
\frametitle{les fifos}
\begin{exampleblock}{Première console:}
\begin{verbatim}
[olivier@andromede unix]$ mkfifo /tmp/fifo
[olivier@andromede unix]$ cat /etc/passwd > /tmp/fifo
\end{verbatim}
\end{exampleblock}

\begin{exampleblock}{Deuxième console:}
\begin{verbatim}
[olivier@andromede ~]$ grep root < /tmp/fifo
root:x:0:0:root:/root:/bin/bash
\end{verbatim}
\end{exampleblock}

\begin{block}{Cet exemple simple revient à}
\begin{verbatim}
cat /etc/passwd | grep root
\end{verbatim}
\end{block}
\end{frame}

\subsection{Systèmes de fichiers}

\begin{frame}[fragile]
\frametitle{principe}
\begin{block}{le montage}
\begin{itemize}
\item une méthode d'accès
\item une structure arborescente
\item on le fait apparaitre dans un répertoire existant
\end{itemize}
\end{block}

\begin{exampleblock}{la commande mount}
\begin{verbatim}
[olivier@andromede unix]$ mount
/dev/sda3 on / type ext3 (rw,noatime)
/dev/sda8 on /home type ext3 (rw,noatime)
[...]
virgo:/home/data on /mnt/disk type nfs (ro,addr=192.168.76.1)
\end{verbatim}
\end{exampleblock}
\end{frame}

\begin{frame}[fragile]
\frametitle{Organisation globale}
\begin{block}{}
\begin{tabular}{ll}
\verb+/etc+&fichiers de configuration\\
\verb+/bin+, \verb+/usr/bin+&les executables utilisateur\\
\verb+/sbin+, \verb+/usr/sbin+&idem, pour root\\
\verb+/lib+, \verb+/usr/lib+&les librairies\\
\verb+/usr/share+&les données statiques des programmes\\
\verb+/usr/include+&les fichiers .h (C)\\
\verb+/var+&les données variables (spool, etc...)\\
\verb+/tmp+, \verb+/var/tmp+&données temporaires\\
\verb+/opt+&espace pour les apps. propriétaires\\
\verb+/proc+, \verb+/sys+&représentation temp réelle du système\\
\end{tabular}
\end{block}

\begin{alertblock}{le FHS}
Le Filesystem Hierarchy Standard normalise l'empacement des fichiers
\end{alertblock}
\end{frame}


\section{les processus}

\subsection{le temps CPU}

\begin{frame}
\frametitle{scheduler préemptif}
\begin{alertblock}{préemptif ?}
Seul le noyau décide du temps CPU alouer !
\end{alertblock}

\begin{block}{Le scheduler}
Le scheduler est appelé à interval régulier (plusieurs centaintes de fois par seconde) pour donner du temps
CPU à l'application sauf si:
\begin{itemize}
\item l'application ne demande pas de temps CPU (sleep)
\item est en attente d'une réponse matériel (IO wait)
\end{itemize}
Le temps CPU est donné en fonction de la priorité
\end{block}
\end{frame}

\subsection{la ram}

\begin{frame}
\frametitle{La RAM}
\begin{block}{le contenu}
\begin{itemize}
\item Mémoire vérouillée:
\begin{itemize}
\item le BIOS (programme interne du PC)
\item mémoire du matériel
\item le code et données du noyau
\end{itemize}
\item Mémoire haute (swappable):
\begin{itemize}
\item code des applications
\item données des applications
\end{itemize}
\item Mémoire vive libre:
\begin{itemize}
\item buffers
\item cache (disque)
\end{itemize}
\item swap (sur disque, très lente)
\end{itemize}
\end{block}

\begin{alertblock}{}
Un système qui swap un peu n'est pas surchargé !
\end{alertblock}
\end{frame}

\begin{frame}[fragile]
\frametitle{Allocation par segment}
\begin{exampleblock}{Un très mauvais code}
\listinginput{1}{nosegfault.c}
Et ça ne plante pas !
\end{exampleblock}

\begin{alertblock}{Explication}
Le système n'alloue pas des octets mais des segments

Le système n'intervient que si l'application sort du segment !
\end{alertblock}
\end{frame}

\begin{frame}[fragile]
\frametitle{Mémoire à crédit}
\begin{block}{malloc est une promesse}
\begin{itemize}
\item malloc promet la ram
\item la ram n'est allouée qu'à l'écriture
\end{itemize}
\end{block}
\end{frame}

\begin{frame}
\frametitle{la crise des subprime}
\begin{exampleblock}{malloc.c}
\listinginput{1}{malloc.c}
\end{exampleblock}

\begin{block}{sortie formatée}
\begin{tabular}{|c|c|c|}
\hline
Mem virtuel&Mem résidente\\
\hline
978116&332\\
\hline
\hline
978116&976888\\
\hline
\end{tabular}
\end{block}
\end{frame}

\subsection{plusieurs processus: sur 1 ordinateur}

\begin{frame}
\frametitle{fork()}
\begin{block}{la fourchette}
Permet à un processus de se dupliquer, et de donner naissance à un processus "fils" \textbf{indépendant}\\

\centering
\includegraphics[height=15mm]{fork}
\end{block}

\begin{columns}
\column{2in}
\begin{block}{motivation}
\begin{itemize}
\item excution parallèle
\item perte de privilège de fils
\item préserver l'environnement du père
\item serveur: remettre le père en attente
\end{itemize}
\end{block}
\column{2in}
\begin{block}{pros \& cons}
\begin{itemize}
\item existe sur tout les UNIX (glibc)
\item simple
\item pas de communication
\end{itemize}
\end{block}
\end{columns}
\end{frame}

\begin{frame}[fragile]
\frametitle{fork et la RAM}
\begin{columns}
\column{2in}
\tiny
\begin{exampleblock}{fork.c}
\listinginput[5]{1}{fork.c}
\end{exampleblock}
\column{2.5in}
\begin{tabular}{|l|c|}
\hline
&mem utilisée\\
\hline
\hline
Avant allocation&1687848\\
\hline
Après allocation&2664948\\
\hline
Après fork()&2666332\\
\hline
\end{tabular}
\end{columns}
\end{frame}

\begin{frame}
\frametitle{les threads}
\begin{block}{Sépare un processus en deux}

\begin{itemize}
\item partage de la mémoire
\begin{itemize}
\item tout n'est pas forcément partagé
\item gestion de lock pour les écriture
\end{itemize}
\item le fonctionnement ressemble à fork mais
\begin{itemize}
\item programmation différente
\item gestion par le système différente
\item complexe mais éfficace
\end{itemize}
\end{itemize}
\end{block}

\begin{alertblock}{Linux: libpthread (glibc)}
Les threads sont POSIX.

Je ne garantie pas que tout les UNIX fournissent le support des threads
\end{alertblock}
\end{frame}

\subsection{Communication inter-processus}

\begin{frame}[fragile]
\frametitle{Pipe}
\begin{block}{points à retenir}
\begin{itemize}
\item flux de donnée continu
\item sens unique
\item bloquants
\item flux unique
\end{itemize}
\end{block}

\begin{block}{Utilisation}
\begin{itemize}
\item \verb+fork()+/\verb+pipe()+ (\verb+p1 | p2+)
\item avec tube nommé (\verb+open++\verb+write+ / \verb+open++\verb+read+)
\end{itemize}
\end{block}
\end{frame}

\begin{frame}
\frametitle{IPC, la boite aux lettres système}
\begin{block}{fonctions}
\begin{itemize}
\item file d'attente de message
\item zone de mémoire partagée
\end{itemize}
\end{block}

\begin{block}{+ et -}
\begin{itemize}
\item relativement simple
\item très performant
\item taille allouable limitée (protection du kernel, configurable)
\item protection des données par gestion de droit
\end{itemize}
\end{block}
\end{frame}

\begin{frame}
\frametitle{Socket, Client/Serveur}

\begin{block}{principe}
\begin{itemize}
\item un serveur attends une connection
\item un client se connecte
\item les deux échangent des données
\end{itemize}
\end{block}

\begin{block}{modes}
\begin{itemize}
\item écoute sur le réseau
\begin{itemize}
\item definir un port d'écoute
\item savoir quelle(s) machine(s) contacter
\item communication inter-machines
\item problème de latence
\end{itemize}
\item écoute sur un socket
\begin{itemize}
\item communication locale
\item restriction d'accès par gestion de droit
\end{itemize}
\end{itemize}
\end{block}
\end{frame}

\section{Executables: format}

\subsection{Code exécutable}

\begin{frame}
\frametitle{la logique}
\includegraphics[height=50mm]{compil}
\end{frame}

\begin{frame}
\frametitle{le code executable}
\begin{block}{un quoi ?}
\begin{itemize}
\item données formatées (format ELF ces jours-ci)
\item executable (ou presque) par le processeur
\item contient des objets:
\begin{itemize}
\item des variables (globales)
\item des fonctions
\item d'autres objets à trouver
\end{itemize}
\end{itemize}
\end{block}
\end{frame}

\subsection{Programme}

\begin{frame}[fragile]
\frametitle{programme}
\begin{exampleblock}{empty.c}
\listinginput[1]{1}{empty.c}
\begin{verbatim}
gcc -o empty empty.c
\end{verbatim}
\end{exampleblock}
\end{frame}

\section{X11}

\end{document}