source: trunk/unix/unix.tex @ 191

% $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{L'Ordinateur}

\subsection{Anatomie}

\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}

\section{UNIX}

\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}

\end{document}