source: tags/unix/20081113/unix.tex @ 216

% $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{2in}
\begin{exampleblock}{ASUS AV7333}
\centering
\includegraphics[height=40mm]{asus_mb}
\end{exampleblock}
\column{2.5in}
\begin{block}{}
\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}
\pause
\item le reste
\begin{itemize}
\item mulot et autres rongeurs
\item disques durs
\item carte son
\item \ldots
\end{itemize}
\end{itemize}
\end{block}
\end{columns}
\end{frame}

\begin{frame}[fragile]
\frametitle{Fonctionnement général}
\begin{block}{Roles de chacun}
\begin{itemize}
\item \textcolor{red}{CPU} (Central processor unit)
\begin{itemize}
\item fait les calculs
\item presque pas de mémoire (registres)
\end{itemize}
\pause
\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}
\pause
\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{block}
\end{frame}

\subsection{LES UNIX}

\begin{frame}
\frametitle{la grande famille des UNIX}
\begin{block}{Définition \href{http://fr.wikipedia.org/wiki/UNIX}{Wikipédia}}
\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.}
\end{block}
\pause
\vfill

\begin{block}{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{block}
\end{frame}

\begin{frame}
\frametitle{Vite une Norme !}
\begin{block}{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}
\end{block}
\vfill
\pause
\begin{block}{Norme POSIX:}
standard de fonctionnement et commandes (IEEE).
\end{block}
\end{frame}

\subsection{GNU/Linux}

\begin{frame}
\frametitle{GNU/Linux}
\begin{block}{Contenu du système}
\begin{itemize}
\item Linux: le noyau lui même (\href{http://www.kernel.org}{kernel.org})
\item des applis éparpillées sur internet
\end{itemize}
\end{block}
\pause
\begin{block}{Les distributions}
\textbf{Ensemble cohérent noyau/applications}

\begin{itemize}
\item Redhat: Mandriva Suse Centos \ldots
\item Debian: ubuntu
\item gentoo
\item slackware
\item \ldots
\end{itemize}
\end{block}
\end{frame}

\begin{frame}
\frametitle{De l'ordinateur à l'utilisateur}
\begin{columns}[c]
\column{2in}
\centering
\includegraphics[height=40mm]{process}
\column{2.5in}
\begin{block}{Rôle 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{Systèmes de fichiers}

\begin{frame}[fragile]
\frametitle{Vue globale}
\begin{exampleblock}{tree  / -L 2 -d}
\tiny
\listinginput[5]{1}{tree.txt}
\end{exampleblock}
\end{frame}

\begin{frame}[fragile]
\frametitle{Organisation globale}
\begin{block}{L'emplacement des fichiers}
\begin{tabular}{ll}
\verb+/home+&les données utilisateurs\\
\verb+/etc+&fichiers de configuration\\
\verb+/bin+, \verb+/usr/bin+&les executables\\
\verb+/sbin+, \verb+/usr/sbin+&idem, réservés à 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\\
\end{tabular}
\end{block}
\end{frame}

\begin{frame}[fragile]
\frametitle{Organisation globale (2)}
\begin{block}{Système de fichiers spéciaux}
\begin{tabular}{ll}
\verb+/dev+&les fichiers de périphériques\\
\verb+/proc+&représentation temp réelle du système\\
\verb+/sys+&configuration du noyau, informations sur le matériel\\
\end{tabular}
\end{block}
\pause
\vfill
\begin{alertblock}{le FHS}
Le Filesystem Hierarchy Standard normalise l'empacement des fichiers
\end{alertblock}
\end{frame}

\begin{frame}[fragile]
\frametitle{principe}
\begin{block}{le montage}
Le système de fichiers est stocké sur un support (disque, fichier, cdrom, \ldots)

Le noyau le fait apparaitre dans un répertoire.
\end{block}
\vfill
\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}

\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+/+ n'en font qu'un
\item la longueur maximale d'un chemin est de 1024 octets (POSIX)
\item tous les caractères sont permis sauf \verb+/+ et \emph{NULL}
\end{itemize}
\end{block}
\vfill
\begin{alertblock}{On évitera cependant}
\begin{itemize}
\item l'espace (qu'il faut échaper sur la ligne de commande)
\item \verb+-+ (surtout en premier, option en ligne de commande)
\item ce qui ne se tape pas au clavier
\item les accents (problème d'encodage)
\end{itemize}
\end{alertblock}
\end{frame}

\begin{frame}[fragile]
\frametitle{les types de fichiers}
\begin{exampleblock}{ls -l}
- \emph{rw-r--r-- 1 olivier olivier 3049 17:30 unix2.tex}
\end{exampleblock}

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

\begin{frame}[fragile]
\frametitle{. et ..}
\begin{block}{chaque répertoire contient:}
\begin{itemize}
\item \verb+.+ le répertoire lui même
\item \verb+..+ son répertoire parent
\end{itemize}
\end{block}
\vfill
\pause
\begin{alertblock}{trop de ..}
\verb+/..+ pointe sur \verb+/+

\begin{verbatim}
$ ls ../../../../../../etc/passwd
../../../../../../etc/passwd
\end{verbatim}

On rebondit sur \verb+/+ et on redescend dans \verb+/etc/passwd+.
\end{alertblock}
\end{frame}

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

\begin{exampleblock}{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}
}
\end{exampleblock}

\begin{block}{L'inode contient}
\begin{itemize}
\item un numéro (6160386)
\item des métadata
\begin{itemize}
\item taille (3049)
\item propriétaires / droits d'accès
\item dates: d'accès (atime), création (ctime), modification (mtime)
\end{itemize}
\item éventuellement un contenu
\end{itemize}
\end{block}
\pause
\begin{alertblock}{}
Créer un fichier créer l'inode\\
Effacer un fichier efface l'inode (si plus référencée)
\end{alertblock}
\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}
}
\pause
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}
}
\pause
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{existence 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}
\pause
\vfill
\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}
\pause
\begin{block}{Conséquences:}
\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 l'effacement du fichier
\end{itemize}
\pause
{\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{Fichiers temporaires}
\begin{block}{Un fichier qu'on ne va pas garder, mais:}
\begin{itemize}
\item il ne doit pas exister
\pause
\item nom aléatoire (écrasement basé sur un lien symbolique)
\pause
\item le placer au bon endroit
\end{itemize}
\pause
\vfill
\textbf{en pratique}
\begin{itemize}
\item shell: mktemp
\item C: mkstemp
\item Perl: module File::Temp
\end{itemize}
\end{block}
\pause
\vfill
\begin{exampleblock}{}
\small
\listinginput[1]{1}{temp.sh}
\end{exampleblock}
\end{frame}

\begin{frame}[fragile]
\frametitle{les fichiers à trous (sparse files)}
\begin{block}{théorie}
\begin{itemize}
\item certaines données n'existent pas
\item les trous ne prennent pas de place
\item le système renvoient des 0 en cas de lecture
\item le fichier peut être plus gros que le système de fichiers
\end{itemize}
\end{block}
\pause
\vfill
\begin{block}{utilisation ?}
Chaque fois que des données seront allouées à des emplacements dans le fichier:
\begin{itemize}
\item disques virtuels
\item bases de données
\end{itemize}
\end{block}
\end{frame}

\begin{frame}[fragile]
\frametitle{fichiers à trous: exemple}
\begin{exampleblock}{sparce.c}
\begin{small}
\listinginput{1}{sparse.c}

\begin{verbatim}
[olivier@andromede unix]$ ls -ls sparsed
8 -rw-rw-r-- 1 olivier olivier 1048582 02:57 sparsed
\end{verbatim}
\end{small}
\end{exampleblock}
\end{frame}

\begin{frame}[fragile]
\frametitle{Liens symboliques}
\begin{block}{Fichier qui pointe sur un autre:}
\begin{itemize}
\item gérés le système
\item il ne contient que le nom de l'élément pointé
\begin{itemize}
\pause
\item l'élément pointer peut être n'importe quoi
\item l'élément peut ne pas existé (lien cassé)
\end{itemize}
\pause
\item les actions s'appliquent à l'élément pointé sauf:
\begin{itemize}
\item ls/rm
\item les appels systèmes prévus
\end{itemize}
\end{itemize}
\end{block}
\pause
\begin{exampleblock}{exemple}
\tiny
\begin{verbatim}
$ ln -s  fichier lien
$ ls -l lien
lrwxrwxrwx 1 olivier olivier 7 19:13 lien -> fichier
$ ls -l lien fichier
ls: ne peut accéder fichier: Aucun fichier ou dossier de ce type
lrwxrwxrwx 1 olivier olivier 7 19:13 lien -> fichier
$ echo 'coucou' > lien
$ ls -l lien fichier
-rw-rw-r-- 1 olivier olivier 7 19:14 fichier
lrwxrwxrwx 1 olivier olivier 7 19:13 lien -> fichier
\end{verbatim}
\end{exampleblock}
\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}
\pause
\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é)

\pause
Je peux le lire comme un fichier:
\begin{verbatim}
$ 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}
$ mkfifo /tmp/fifo
$ cat /etc/passwd > /tmp/fifo
\end{verbatim}
\end{exampleblock}
\pause
\vfill
\begin{exampleblock}{Deuxième console:}
\begin{verbatim}
$ grep root < /tmp/fifo
root:x:0:0:root:/root:/bin/bash
\end{verbatim}
\end{exampleblock}
\pause
\vfill
\begin{block}{Cet exemple simple revient à}
\begin{verbatim}
cat /etc/passwd | grep root
\end{verbatim}
\end{block}
\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 aloué !
\end{alertblock}
\pause
\vfill
\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}
\pause
\item Mémoire haute (swappable):
\begin{itemize}
\item code des applications
\item données des applications
\end{itemize}
\pause
\item Mémoire vive libre:
\begin{itemize}
\item buffers
\item cache (disque)
\end{itemize}
\pause
\item swap (sur disque, très lente)
\end{itemize}
\end{block}
\end{frame}

\begin{frame}
\frametitle{Gestion}

\begin{block}{la swap ?}
Extension sur disque de la mémoire.
\pause

Elle sert:
\begin{itemize}
\item quand la mémoire vive est pleine
\item pour mettre de coté des données peu utilisées
\end{itemize}

Mémoire disponible = mémoire vive + swap
\end{block}
\pause
\vfill
\begin{alertblock}{}
Un système qui swap \textbf{un peu} n'est pas surchargé !
\end{alertblock}
\vfill
\pause
\begin{block}{La Ram est virtuelle}
De par les aller retour RAM-SWAP, et la fragmentation, le système virutalize
les adresses allouées.
\end{block}
\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}
\pause
\vfill
\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{exampleblock}{malloc.c}
\small
\listinginput{1}{malloc.c}
\end{exampleblock}
\begin{columns}
\column{2.5in}
\pause
\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}
\column{2in}
\pause
\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{columns}

\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}
\pause
\begin{columns}
\column{2.5in}
\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}
\pause
\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}
\pause
\begin{block}{Ram utilisée}
\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{block}
\end{columns}
\end{frame}

\begin{frame}[fragile]
\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 et gestion différentes
\item complexe mais éfficace
\end{itemize}
\end{itemize}
\end{block}
\pause
\begin{alertblock}{Linux: libpthread (glibc) POSIX}
Je ne garantie pas que tout les UNIX fournissent le support des threads
\end{alertblock}
\pause
\begin{exampleblock}{}
\small
\begin{verbatim}
[olivier@andromede unix]$ ps aux | grep transcode
PID %CPU %MEM    VSZ   RSS  TIME  COMMAND
3477  124  1.3 119972 41344 36:32 transcode
\end{verbatim}
\end{exampleblock}
\end{frame}

\subsection{Communication inter-processus}

\begin{frame}[fragile]
\frametitle{Pipe}
\begin{block}{points à retenir}
\begin{itemize}
\item flux de donnée continu unique
\item sens unique
\item bloquants
\end{itemize}
\end{block}
\pause
\vfill
\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/SHM, 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}
\pause
\vfill
\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}
\pause
\vfill
\begin{block}{La doc (pour le C)}
\textbf{man}
shmat, shmdt, shmop, shm\_overview,
shmctl, shmget, shm\_open, shm\_unlink
\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}
\pause
\vfill
\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}
\pause
\item écoute sur un socket (fichier de type \ldots)
\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}
\begin{columns}
\column{2in}
\includegraphics[height=40mm]{compil}
\column{2.5in}
\begin{block}{un quoi ?}
\begin{itemize}
\item données formatées (format ELF ces jours-ci)
\pause
\item executable (ou presque) par le processeur
\pause
\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{columns}
\end{frame}

\subsection{Bibliothèques}

\begin{frame}
\frametitle{Le standard}
\begin{block}{Normallement un programme fournit}
\begin{itemize}
\item foo.h: l'entête pour la compilation
\pause
\item libfoo.so.1: la librairie utilisée, versionnée
\pause
\item libfoo.so: (lien) pour l'éditeur de lien
\pause
\item libfoo.a: la version statique
\end{itemize}
\end{block}
\pause
\vfill
\begin{block}{le point sur les dynamiques}
\begin{itemize}
\item avantages:
\begin{itemize}
\item les maj sont répercutés sans recompilation des applis
\item factorisation du code dans la RAM et sur le disque
\end{itemize}
\pause
\item inconvénients
\begin{itemize}
\item doit être disponible lors de l'éxecution
\end{itemize}
\end{itemize}
\end{block}
\end{frame}

\begin{frame}[fragile]
\frametitle{Trouver les dynamiques}
\begin{block}{la recherche}
\begin{itemize}
\item codé dans l'executable (\emph{rpath})
\pause
\item codé en dur: \verb+/lib(64)+, \verb+/usr/lib(64)+
\pause
\item indiqués dans \verb+/etc/ld.so.conf+
\end{itemize}
\end{block}
\pause
\vfill
\begin{exampleblock}{ldd}
\begin{small}
\begin{verbatim}
[olivier@andromede unix]$ ldd /bin/rm
        linux-gate.so.1 =>  (0xffffe000)
        libc.so.6 => /lib/i686/libc.so.6 (0xb7ee3000)
        /lib/ld-linux.so.2 (0xb8064000)
\end{verbatim}
\end{small}
\end{exampleblock}
\pause
\vfill
\begin{alertblock}{linux-gate.so.1}
Code injecté directement par le kernel, ignorez le !
\end{alertblock}
\end{frame}

\begin{frame}[fragile]
\frametitle{l'exemple: la librairie}
\begin{exampleblock}{libsmall.h}
\small
\listinginput[1]{1}{libsmall.h}
\end{exampleblock}
\begin{exampleblock}{libsmall.c}
\small
\listinginput[1]{1}{libsmall.c}
\end{exampleblock}
\pause
\vfill
\begin{block}{la version statique}
\begin{verbatim}
gcc -c libsmall.o libsmall.c
ar rcs libsmall.a libsmall.o
\end{verbatim}
\end{block}
\pause
\begin{block}{la version dynamique}
\begin{verbatim}
gcc -c libsmall.o libsmall.c
gcc -shared -o libsmall.so libsmall.o
\end{verbatim}
\end{block}
\end{frame}

\begin{frame}[fragile]
\frametitle{l'exemple: le programme}
\begin{exampleblock}{small.c}
\small
\listinginput[1]{1}{small.c}
\end{exampleblock}
\pause
\vfill
\begin{block}{la version statique}
\begin{verbatim}
gcc -c -o small.o small.c
gcc -o small.static libsmall.a small.o
\end{verbatim}
\end{block}
\pause
\begin{block}{la version dynamique}
\begin{verbatim}
gcc -c -o small.o libsmall.c
gcc -o small.dyn -L. -lsmall small.o
    -Wl,-rpath=$(pwd) # $(PWD) pour le chemin courant
\end{verbatim}
\end{block}
\end{frame}

\begin{frame}
\frametitle{Et puis il y a \emph{dlopen()}}

\begin{alertblock}{le mode standard dynamique}
Un code lié à une bibliothèque ne fonctionnera jamais sans.
\end{alertblock}
\pause
\vfill
\begin{block}{les deux clefs:}
\begin{itemize}
\item \emph{dlopen()} charge une bibliotèque
\item \emph{dlsym()} va chercher les fonctions
\end{itemize}
\end{block}
\pause
\vfill
\begin{block}{exemple d'utilisation}
\begin{itemize}
\item pour étendre les fonctionnalités d'une appli (perl, python, apache)
\item pour eviter de charger du code inutilement
\end{itemize}
\end{block}
\end{frame}

\section{X11}

\begin{frame}
\frametitle{Histoire}
\begin{block}{}
\begin{itemize}
\item \textbf{1984 création par le MIT}
\item X est le successeur de W (sur system V)
\item 1985 ajout de la couleur (DEC VAXstation)
\item 1986 X10R2, X10R3, X10R4
\item 1987 X11, 1988 X11R2, 1991 X11R5
\item \textbf{1992 création de XFree86 (utilisé par Linux)}
\item 1999 X11R6.5
\item 2004 Xorg se sépare de XFree86 (pb de licence)
\item \textbf{depuis tout les UNIX libres utilisent Xorg}
\end{itemize}
\end{block}
\pause
\vfill
\begin{alertblock}{X ça pue !}
Oui, c'est le prix de la compatibilité\ldots
\end{alertblock}
\end{frame}

\begin{frame}
\frametitle{X: serveur d'affichage}
\begin{columns}
\column{2in}
\begin{block}{}
\begin{itemize}
\item gestionnaire de matériel
\begin{itemize}
\item carte graphique
\item ecran
\item clavier
\item souris (et autres rongeurs)
\end{itemize}
\pause
\item protocol d'affichage (reseau)
\pause
\item \textbf{serveur d'affichage}
\end{itemize}
\end{block}
\column{2.5in}
\pause
\begin{exampleblock}{le serveur X, c'est ça:}
\centering
\includegraphics[height=40mm]{x}
\end{exampleblock}
\end{columns}
\end{frame}

\begin{frame}
\frametitle{Applications X11}
\begin{columns}
\column{2.5in}
\begin{block}{}
Une application X11 se connecte au serveur X,
et demande un affichage.
\end{block}
\column{2in}
\pause
\begin{exampleblock}{}
\centering
\includegraphics[height=30mm]{x-mplayer-capcv}
\end{exampleblock}
\end{columns}
\pause
\vfill
\begin{columns}
\column{2.5in}
\begin{block}{le Window Manager}
\begin{itemize}
\item application X11
\item il créé les fenetres
\item fourni un menu (éventuellement)
\end{itemize}
\end{block}
\begin{alertblock}{}
KDE, GNOME, XFCE: envirronements de bureau
\end{alertblock}
\column{2in}
\pause
\begin{exampleblock}{}
\centering
\includegraphics[height=30mm]{x-mplayer-capcv-twm}
\end{exampleblock}
\end{columns}
\end{frame}

\begin{frame}
\frametitle{X11: résumé}
\begin{exampleblock}{}
\centering
\includegraphics[height=60mm]{x-resume}
\end{exampleblock}
\end{frame}

\section*{Fin}

\begin{frame}{Des questions}
\center{
\hfill
\includegraphics{150px-Tux}
\hfill
}
\end{frame}

\end{document}