| Les deux révisions précédentesRévision précédenteProchaine révision | Révision précédente |
| nethserver_101_cahier_01_linux [2019-07-10 19:29] – michelandre | nethserver_101_cahier_01_linux [2025-01-12 19:30] (Version actuelle) – modification externe 127.0.0.1 |
|---|
| | \\ |
| | [[cours_nethserver_101|{{ Images_Cahier-101-01-000.png?650 }}]] |
| | \\ |
| | ====== Description générale ====== |
| |
| | ===== Introduction ===== |
| | |
| | Vous pouvez consulter ce document pour connaître les rudiments de Linux ou rafraîchir vos connaissances. Ce cours donne un aperçu des fonctionnalités de base de Linux qui sont indispensables à toute personne qui désire se familiariser à l'environnement Linux et surtout comprendre et maîtriser les concepts de base. |
| | |
| | Vous serez en mesure de recourir à la documentation en ligne //(man)//, manipuler l'arborescence des fichiers, comprendre l'organisation générale du système, gérer les droits d'accès, découvrir les variables d’environnement, les fichiers particuliers, la quincaillerie réseau, utiliser les principales commandes **bash**, etc. |
| | |
| | Un chapitre particulier, qu'il n'est pas nécessaire de maîtriser mais simplement connaître, explique les principes de base de la communication **TCP/IP**. |
| | |
| | Enfin, une introduction à l'éditeur **vi** est donnée à la fin du document. |
| | |
| | //Référence:// Ce cahier est une adaptation de la page [[http://www.linux-france.org/article/kafkafr/|http://www.linux-france.org/article/kafkafr/]].\\ |
| | //Autre référence:// [[http://free-electrons.com/doc/legacy/command-line/unix_linux_introduction_fr.pdf|free-electrons.com/doc/legacy/command-line/unix_linux_introduction_fr.pdf]].\\ |
| | |
| | ===== Cours NethServer-101 ===== |
| | |
| | Le //Cours NethServer-101//, se voulant une base solide pour la création d'un site de **Commerce en ligne**, comprend plusieurs cahiers: |
| | |
| | - [[nethserver_101_cahier_01_linux|Cahier-01]]: -> Les bases de Linux. |
| | - [[nethserver_101_cahier_02_installations_configurations_logiciels_prerequis|Cahier-02]]: -> Installation et configuration des logiciels prérequis sur le poste de travail. |
| | - [[nethserver_101_cahier_03_creation_un_serveur_virtuel|Cahier-03]]: -> Création d'un Serveur NethServer virtuel. |
| | - [[nethserver_101_cahier_04_local_certificat_let_encrypt|Cahier-04]]: -> Serveur NethServer LOCAL & Let's Encrypt. |
| | - [[nethserver_101_cahier_05_vdsl_fqdn_internet_et_nethserver|Cahier-05]]: -> FAI, modem VDSL, domaine FQDN(( **FQDN**: Dans le //DNS//, un Fully Qualified Domain Name //(FQDN, ou nom de domaine complètement qualifié)// est un nom de domaine qui révèle la position absolue d'un nœud dans l'arborescence //DNS// en indiquant tous les domaines de niveau supérieur jusqu'à la racine. On parle également de domaine absolu, par opposition aux domaines relatifs. Par convention, le //FQDN// est ponctué par un point final.\\ |
| | //Référence:// [[https://fr.wikipedia.org/wiki/Fully_qualified_domain_name|https://fr.wikipedia.org/wiki/Fully_qualified_domain_name]]. \\ \\ )) et Serveur NethServer physique. |
| | - [[nethserver_101_cahier_06_nethserver_wordPress|Cahier-06]]: -> Installation de WordPress. |
| | - [[nethserver_101_cahier_07_nethserver_wordPress_wordfence|Cahier-07]]: -> Installation de l'extension de sécurité Wordfence. |
| | - [[nethserver_101_cahier_08_woocommerce_paypal_stripe|Cahier-08]]: -> WooCommerce, comptes chez Stripe et PayPal pour les paiements en ligne. |
| | - [[nethserver_101_cahier_09_duplicator_migration|Cahier-09]]: -> Sauvegarde/restauration ou migration d'un site avec l'extension Duplicator. |
| | - [[nethserver_101_cahier_10_mandataire_inverse|Cahier-10]]: -> Serveur mandataire inversé. |
| | - [[nethserver_101_cahier_11_nethserver_backuppc|Cahier-11]]: -> Sauvegarde/restauration avec BackupPC. |
| | |
| | ==== Cours NethServer-201 ==== |
| | |
| | Le //Cours NethServer-201// décrit l'installation et la configuration d'applications sur un serveur NethServer. |
| | |
| | - [[nethserver_201_cahier_01_nethserver_et_dolibarr|Cahier-201-01]]: -> Dolibarr. |
| | - [[nethserver_201_cahier_02_odoo_12|Cahier-201-02]]: -> Odoo-12. |
| | - [[nethserver_201_cahier_03_mediawiki|Cahier-201-03]]: -> MediaWiki. |
| | - [[nethserver_201_cahier_04_dokuwiki|Cahier-201-04]]: -> DokuWiki. |
| | - [[nethserver_201_cahier_05_moodle|Cahier-201-05]]: -> Moodle. |
| | - [[nethserver_201_cahier_06_proxmox|Cahier-201-06]]: -> Proxmox. |
| | - [[nethserver_201_cahier_07_flectra|Cahier-201-07]]: -> Flectra. |
| | |
| | ==== Logiciels ==== |
| | |
| | Tous les logiciels nécessaires sont du domaine public ou LIBRE sous licence //GPL//; ils ne coûtent pas un sou. Le seul achat nécessaire est l'obtention d'un nom de domaine au prix initial de $15 CAD et son renouvellement annuel d'environ $30 CAD. |
| | |
| | ==== But final ==== |
| | |
| | Après avoir suivi le //Cours NethServer-101//, vous posséderez un site de //Commerce en ligne// fiable et hautement sécuritaire. De plus, vous pourrez utiliser un clone de votre site, sur un //Serveur NethServer// virtuel roulant sur votre poste de travail, pour tester de nouvelles extensions et applications sans compromettre la sécurité ou l'intégrité de votre site en ligne. |
| | |
| | {{ NS-101_001_Diagramme.png?500 }} |
| | |
| | ===== Particularités de ce document ===== |
| | |
| | ==== Notes au lecteur ==== |
| | |
| | <nowiki>*</nowiki> Les captures d'écrans ne sont que des références.\\ |
| | <nowiki>**</nowiki> Les informations écrites ont préséance sur celles retrouvées dans les captures d'écrans. Veillez vous référer aux différents tableaux lorsque ceux-ci sont présents.\\ |
| | <nowiki>***</nowiki> Une capture d'écran avec une accentuation en magenta indique qu'il faut remplacer cette distinction par vos propres paramètres ou implique un choix laissé à votre appréciation. |
| | |
| | ==== Conventions ==== |
| | |
| | {{Images_icone-201-001_doigt.png?22}} Manipulation, truc ou ruse pour se tirer d'embarras.\\ |
| | {{Images_icone-201-002_Lumiere.png?25}} Une recommandation ou astuce.\\ |
| | {{Images_icone-201-003_Note.png?25}} Une note.\\ |
| | {{Images_icone-201-004_Triangle.png?25}} Une étape, note ou procédure à surveiller.\\ |
| | {{Images_icone-201-005_Non-termine.png?25}} Paragraphe non complété ou non vérifié.\\ |
| | {{Images_icone-201-006_Securite.png?25}} Danger pour la sécurité du système. |
| | |
| | Toutes les commandes à la console ou à travers //PuTTY// sont précédées d'une invite qui est toujours présente. |
| | |
| | <file> |
| | [root@dorgee ~]# ping 10.10.10.75 -c1 |
| | |
| | PING 10.10.10.75 (10.10.10.75) 56(84) bytes of data. |
| | 64 bytes from 10.10.10.75: icmp_seq=1 ttl=64 time=1.63 ms |
| | |
| | --- 10.10.10.75 ping statistics --- |
| | 1 packets transmitted, 1 received, 0% packet loss, time 0ms |
| | rtt min/avg/max/mdev = 1.639/1.639/1.639/0.000 ms |
| | [root@dorgee ~]# |
| | </file> |
| | |
| | <WRAP box round> |
| | <file> |
| | Commande à exécuter si ce n'est déjà fait. |
| | </file> |
| | </WRAP> |
| | |
| | <WRAP box> |
| | <file> |
| | Commande indiquée à titre d'information seulement. |
| | </file> |
| | </WRAP> |
| | \\ |
| | |
| | ===== Aperçu général ===== |
| | |
| | Nous présentons ici ce qu'est Linux, d'où il vient et comment il est distribué actuellement. Pour ceux ayant déjà une connaissance d'autres systèmes d'exploitation, nous proposons également une comparaison avec quelques-uns d'entre eux. |
| | |
| | ===== Un peu d'histoire... UNIX! ===== |
| | |
| | ==== Caractéristiques principales ==== |
| | |
| | Linux est un système multitâche. Cela signifie que plusieurs programmes peuvent s'exécuter simultanément; par exemple, vous pourriez rédiger une lettre sur un traitement de textes, tout en attendant qu'un programme d'images de synthèse termine son calcul, et ce en même temps qu'un CD diffuse une musique plus ou moins mélodieuse. Il n'y a pas de limite théorique au nombre d'applications qui peuvent ainsi fonctionner simultanément: les facteurs limitants sont en premier lieu la quantité de mémoire dont dispose l'ordinateur, et en second lieu, la puissance du processeur. Pour fixer les idées, il est très courant d'avoir une cinquantaine de programmes //(on dit aussi "processus")// s'exécutant sous Linux dès qu'une couche graphique est démarrée. |
| | |
| | Ensuite, Linux est multi-utilisateur. C'est-à-dire que tout est prévu pour que plusieurs personnes utilisent le système, éventuellement simultanément //(si le "câblage" le permet)//. En pratique, chaque personne utilisant le système dispose d'un compte, qui peut être vu comme une certaine zone qui lui est allouée, accessible par un nom et un mot de passe. Elle ne peut normalement pas en sortir, et encore moins aller modifier //(volontairement ou non)// les zones allouées à d'autres personnes. Il existe un mécanisme de droits permettant d'assurer ce contrôle permanent qui peut paraître contraignant mais évite bien des erreurs. |
| | |
| | Linux est de plus fortement "orienté réseaux": il offre tous les outils et tous les mécanismes pour la mise en place de réseaux locaux, l'intégration dans des réseaux existants, la connexion à l'Internet, que ce soit comme source, traiteur ou collectionneur d'informations. Héritée de son inspirateur Unix, cette caractéristique fait de Linux l'un des systèmes les plus ouverts qui soit. |
| | |
| | Enfin, et c'est probablement ce qui fait sa plus grande force, Linux est LIBRE //(Open Source)//: chacun peut examiner le code en langage C du système, le modifier selon ses besoins, proposer des ajouts ou des améliorations... Aujourd'hui, plusieurs milliers de programmeurs, communicant par l'Internet, participent au développement de Linux. Dès qu'une nouvelle version apparaît, des milliers d'utilisateurs l'installent, la testent, signalent les erreurs. Une entreprise ne peut qu'approcher de la force colossale que représente cette masse. |
| | |
| | Ajoutons que s'il fut initialement développé pour les ordinateurs de types PC, Linux existe également sur de nombreuses autres plateformes, à base de processeurs PowerPC, Alpha, 68K, et d'autres. À l'heure où nous écrivons ces lignes, il existe même un projet de portage pour le PalmPilot de 3Com! |
| | |
| | ==== Les distributions ==== |
| | |
| | Si l'on veut être rigoureux, le terme "Linux" en lui-même ne désigne que le coeur du système //(appelé le noyau, ou plus communément le kernel)//, cette zone un peu obscure qui permet d'utiliser le matériel et de communiquer avec le reste du monde. Mais par lui-même, Linux serait bien incapable d'enregistrer le moindre texte tapé au clavier! |
| | |
| | La méthode usuelle pour obtenir Linux est d'acquérir l'une des nombreuses distributions qui existent. Une distribution est un assemblage, autour d'un noyau Linux, d'un ensemble plus ou moins vaste de programmes utilitaires permettant d'utiliser toute la puissance de Linux. En général, ces distributions sont gratuites, et se présentent soit sous forme de CD-ROM, soit de disquettes //(pour les petites...)//, et sont même parfois directement téléchargeables depuis l'Internet //(ce qui peut prendre beaucoup de temps!)// |
| | |
| | Il est possible d'obtenir une distribution, soit en la commandant directement auprès du fournisseur //(en général par l'Internet)//, soit en l'achetant en magasin spécialisé. Ce que l'on paye alors correspond le plus souvent à l'emballage et à la documentation imprimée qui accompagnent le CD-ROM... Toutefois, il existe des distributions payantes, qui ne sont alors pas librement re-distribuables. Enfin, il n'est pas rare de trouver une distribution pour accompagner un ouvrage traitant de Linux, ou une simple revue disponible en bureau de presse... |
| | |
| | Citons quelques-unes des distributions Linux les plus célèbres: RedHat, CentOS, NethServer, SuSE, etc. |
| | |
| | ===== Système de fichiers ===== |
| | |
| | Le système de fichiers d'un système d'exploitation est un ensemble de principes et de règles selon lesquels les fichiers sont organisés et manipulés. Chaque système d'exploitation possède son système de fichier privilégié, même s'il peut en utiliser d'autres. Le tableau ci-dessous donne quelques noms. |
| | |
| | ^ <WRAP centeralign>\\ Tableau 1: Systèmes de fichiers.</WRAP> ^^ |
| | |//**Système**//|//**Système de fichier**//| |
| | |MS-DOS|FAT, aussi appelé FAT-16 //(File Allocation Table 16bits)//| |
| | |Windows 95/98|FAT32, extension du système FAT-16 //(File Allocation Table 32bits)//| |
| | |Windows NT/7/8.x|NTFS //(New Technology File System)//| |
| | |OS/2|HPFS //(High Performance File System)//| |
| | |Linux|Ext2fs //(Second Extended File System)//, Ext3, Ext4| |
| | |
| | ==== Qu'est-ce qu'un fichier? ==== |
| | |
| | Fondamentalement, un fichier est une suite de caractères //(on dit "octets")// qui constitue un ensemble cohérent //(en principe)// d'informations. Le fichier est l'élément fondamental d'un système d'exploitation: les instructions nécessaires au fonctionnement de ce système, sa configuration, comment il doit réagir à telle situation, toutes ces informations sont stockées dans des fichiers. |
| | |
| | Plus généralement, les fichiers sont utilisés pour stocker les travaux des utilisateurs. Pour ces derniers, les fichiers sont identifiables par un nom, qui doit respecter certaines contraintes //(voir plus bas)//. Cette définition, très générale, inclut également les fichiers qui rassemblent des informations sous forme structurée selon les principes des bases de données, par exemple le fichier des assurés sociaux de la Sécurité Sociale: c'est là une forme plus restrictive de la notion de fichier. |
| | |
| | Enfin, les fichiers sont eux-mêmes stockés physiquement sur différents supports, comme les disquettes, les disques durs, les CD-ROMs... |
| | |
| | ==== Tout est fichier! ==== |
| | |
| | Il en est ainsi sous Unix, et donc sous Linux: tous les éléments du système sont manipulés par des fichiers! Cela peut paraître un peu déroutant de penser que le clavier sur lequel on frappe désespérément est considéré par le système comme un fichier, spécial certes, mais fichier tout de même. Toutefois cette uniformisation permet de simplifier grandement la manipulation du système en général, et sa programmation en particulier. |
| | |
| | Sous Linux, les noms de fichiers sont limités à 255 caractères et ne doivent en principe comporter que des caractères alphanumériques //(c'est-à-dire des lettres et des chiffres)//, ainsi que les symboles . - _ ~ + %. Il est toutefois possible d'insérer un espace ou d'autres caractères "bizarres" dans un nom de fichier, mais ceci est très fortement déconseillé. |
| | |
| | Attention, le système fait la différence entre les majuscules et les minuscules! Ainsi, dans un même répertoire on peut avoir les deux fichiers ''lettre.txt'' et ''Lettre.txt''. Nous ne saurions trop vous déconseiller d'abuser de ce genre de possibilités. |
| | |
| | Une petite particularité: les fichiers //(ou répertoires)// dont le nom commence par un point //('.')// sont des fichiers cachés, c'est-à-dire qu'ils ne sont pas listés normalement par la commande ''ls''. |
| | |
| | Vous aurez sans doute remarqué que nous utilisons une forme de caractère particulière pour les noms de fichiers, ceci afin de faciliter la lecture: il en sera ainsi tout au long de ce document. |
| | |
| | ===== Les répertoires ===== |
| | |
| | Les répertoires sont des fichiers un peu particuliers, qui "contiennent" d'autres fichiers et d'autres répertoires. |
| | |
| | Le terme de "contenir" n'est pas tout à fait approprié, ce n'est qu'une image. Plus précisément, un répertoire est un fichier contenant des références et des descriptions pour d'autres fichiers //(qui peuvent être des répertoires...)//. Ce terme est toutefois celui employé couramment. |
| | |
| | On obtient ainsi une structure arborescente, telle que celle visible sur la //Figure 1//. L'utilisation de répertoires est vivement conseillée pour organiser ses informations. |
| | |
| | Il existe sous Linux //(et Unix)// un répertoire "ancêtre" de tous les autres, qui contient tous les autres (directement ou suite à des intermédiaires): le répertoire root, que l'on note simplement '/' //(ce symbole se lit barre oblique ou slash)//. |
| | |
| | Prenons une analogie, pour bien faire saisir cette notion de répertoire. Considérez votre système comme une bibliothèque: la bibliothèque dans son ensemble peut être assimilée au répertoire racine. Mais généralement, une bibliothèque est subdivisée en sections: la section "histoire", la section "géographie", la section "roman"... ce sont là les répertoires situés dans la racine. Entrons dans la section "roman". On y trouve d'autres divisions, les romans "policiers", les romans "picaresques", les romans "à l'eau de rose"... ce sont des sous-répertoires du répertoire "roman". Mais peut-être y a-t-il des romans inclassables, qui n'entrent dans aucune des divisions prévues: ils seront simplement entassés à l'entrée de la section "roman", directement accessibles, comme les fichiers présents dans un répertoire. Au sein des romans policiers, on peut trouver encore d'autres catégories selon la langue, l'auteur, etc. pour parvenir enfin jusqu'à une étagère ou un rayon, qui ne soit pas subdivisé: les rayons sont remplis de livres, qui sont les fichiers, car comme les fichiers ils ont un nom //(le titre)// et un propriétaire //(l'auteur)//. |
| | |
| | Chaque répertoire contient deux répertoires particuliers: //'**.**'// qui désigne le répertoire lui-même et //'**..**'// désigne le répertoire de niveau juste supérieur. |
| | |
| | Ainsi, sur la //Figure 1//, le '..' du répertoire ''rc.d'' désigne le répertoire ''etc''. |
| | |
| | Une notion importante sous Linux est celle de répertoire courant. On peut considérer une arborescence comme un ensemble de villes reliées par des routes; le répertoire courant désigne alors la ville où l'on se trouve. Pour reprendre l'analogie de la bibliothèque, le répertoire courant est la section ou sous-section dans laquelle on est en train de déambuler nonchalamment. |
| | |
| | Pour définir complètement un fichier, il est nécessaire de connaître la succession de répertoires qu'il faut parcourir pour le trouver: c'est le chemin du fichier. |
| | |
| | Si ce chemin commence par le symbole ''/'', il est dit absolu: il indique la succession de répertoires depuis la racine pour obtenir le fichier. Par exemple, le texte ''/etc/passwd'' est le chemin pour le fichier ''passwd'' qui se trouve dans le répertoire ''etc''. Par abus de langage, on appelle également chemin absolu le texte ''/usr/local/man'', qui ne désigne pas un fichier particulier, car comme on le voit sur la //Figure 1//, ''man'' est un répertoire dans ''/usr/local''. Mais rappelons que les répertoires ne sont que des fichiers particuliers... |
| | |
| | Dans le cas contraire, le chemin est dit relatif: il prend comme point de départ le répertoire courant. Ainsi, si le répertoire courant est ''/usr/local'', le texte ''man/man1'' équivaut au chemin absolu ''/usr/local/man/man1''. En utilisant le ''..'' évoqué plus haut, en partant du même point de départ, le texte ''../bin'' équivaut au chemin absolu ''/usr/bin''. On parle également d'indirection, lorsque le chemin commence par un ''..''. |
| | |
| | Ces principes et notions peuvent paraître déroutantes dans un premier temps, mais un peu de pratique les font devenir une seconde nature. |
| | |
| | ===== Hiérarchie standard ===== |
| | |
| | Il existe une certaine normalisation dans l'architecture des répertoires sous Linux //(comme sous Unix, d'ailleurs)//. La //Figure 1// présente une organisation standard. Il peut toutefois exister des variations d'une distribution à l'autre, mais dans l'ensemble c'est assez bien respecté. |
| | |
| | Les flèches en pointillés indiquent qu'il est fréquent de trouver d'autres répertoires, mais sans qu'il existe véritablement de norme. |
| | |
| | <WRAP centeralign>//**Figure 1: Hiérarchie standard des répertoires.**//</WRAP> |
| | {{ Images_Cahier-101-01-002.png?800 }} |
| | |
| | === Quelques précisions concernant la Figure 1 === |
| | |
| | //**/etc**// -> ontient les fichiers généraux de configuration, les commandes à exécuter au démarrage du système et même le mode de démarrage du système. |
| | |
| | //**/bin**// -> Contient des commandes nécessaires lors du démarrage du système. Ces commandes pourront par la suite être utilisées par les utilisateurs. |
| | |
| | //**/sbin**// -> Contient des commandes nécessaires lors du démarrage du système, mais en quelque sorte réservées à l'administrateur du système ou super-utilisateur. |
| | |
| | //**/home**// -> Est réservé à l'hébergement des comptes des utilisateurs. |
| | |
| | //**/dev**// -> Ce répertoire contient tous les fichiers spéciaux utilisés pour accéder au matériel qu'il s'agisse: du clavier, du disque dur, de la carte son... |
| | |
| | //**/proc**// -> Voici un pseudo-répertoire: en réalité, son contenu n'existe pas physiquement sur le disque, mais est manipulé directement par le système lui-même. On y trouve nombre d'informations techniques utiles. |
| | |
| | //**/usr**// -> Répertoire à usages multiples, dont les principaux sont: |
| | <WRAP indent> |
| | //**/usr/bin**// -> Commandes utilisables par tous les utilisateurs, et non nécessaires lors du démarrage du système. \\ |
| | //**/usr/sbin**// -> Commandes réservées au super-utilisateur, et non nécessaires lors du démarrage du système. \\ |
| | //**/usr/man**// -> Contient les pages de manuel. -> |
| | //**/usr/doc**// -> Contient de nombreuses documentations et sources d'informations. \\ |
| | //**/usr/X11R6**// -> Contient //(normalement)// tous les fichiers se rapportant à la couche graphique X-Window. \\ |
| | //**/usr/local**// -> Lieu où sont stockés les fichiers spécifiques au système installé. |
| | </WRAP> |
| | |
| | //**/var**// -> Contient des données mises à jour par différents programmes durant le fonctionnement du système. \\ |
| | <WRAP indent> |
| | //**/var/lock**// -> Fichiers de blocage, pour interdire par exemple deux utilisations simultanées du modem. \\ |
| | //**/var/spool**// -> Répertoires utilisés pour l'organisation du travail des imprimantes, de la messagerie électronique, etc. \\ |
| | //**/var/log**// -> Contient les fichiers journaux //(logs)// provenant de différents points du système. |
| | </WRAP> |
| | |
| | ===== Quelques fichiers sensibles ===== |
| | |
| | Ces fichiers sensibles sont des fichiers particulièrement importants, sur lesquels repose une grande partie de la stabilité du système, voire de son simple fonctionnement. Il est donc vivement recommandé de ne pas modifier, encore moins d'effacer, ces fichiers, sans un luxe de précautions et sans savoir très précisément ce que l'on fait. |
| | |
| | - ''/etc/passwd'' -> |
| | Le fichier des utilisateurs et des mots de passe associés. Supprimez ce fichier, et il vous sera impossible d'utiliser votre système! |
| | |
| | - ''/etc/inittab'' -> |
| | Précise le mode de démarrage du système et les actions associées. La suppression ou une altération malheureuse de ce fichier peut rendre le système impossible à démarrer. |
| | |
| | - ''/etc/fstab'' -> |
| | Liste des partitions utilisées par le système et selon quelle méthode il les utilise. À ne pas toucher sans savoir! Vous pourriez rendre votre système très instable. |
| | |
| | - ''XF86Config'' -> |
| | Peut se situer en différents endroits //(mais souvent sous ''/etc/X11'')// selon la distribution employée. Contient la configuration de la couche graphique. Attention, les informations qu'il contient sont spécifiques au matériel utilisé: une modification hasardeuse peut rendre la couche graphique non fonctionnelle, voire endommager le matériel, notamment l'écran. |
| | |
| | - ''vmlinuz...'' -> |
| | Peut-être le plus important de tous. Se situe généralement, soit sous la racine ''/'', soit sous ''/boot''. En fait, il s'agit du système lui-même! C'est le coeur des fonctions internes qui réalisent le fonctionnement de tout le système. |
| | |
| | Ne sont évoqués ici que les fichiers les plus importants. Il existe naturellement un grand nombre d'autres fichiers, qu'il convient de traiter avec douceur, même si les effets d'une erreur sont moins catastrophiques. |
| | |
| | ===== Accéder au système et le quitter proprement ===== |
| | |
| | ==== Procédure d'accès au système ==== |
| | |
| | Sauf circonstance exceptionnelle, l'accès à un système Linux se fait par une procédure d'identification, en fournissant un mot de passe: Linux est en effet protégé, dans le sens où seules les personnes autorisées peuvent l'utiliser. Celles-ci sont appelées les utilisateurs du système. L'ensemble de cette procédure //(nom et mot de passe)// est appelée communément procédure de login, ou simplement login. Bien que cela ne soit pas très français, on dit aussi d'un utilisateur qu'il se "logue" sur le système. |
| | |
| | Pour l'instant, bornons-nous à décrire brièvement la connexion au système. Lorsque vous démarrez Linux, après un défilement plus ou moins long et ésotérique d'informations diverses, une ligne avec un curseur attend une entrée de votre part, par exemple: |
| | |
| | <file> |
| | login as: |
| | </file> |
| | |
| | Le terme login fait référence à l'identification attendue: à cet endroit, vous devez taper un nom d'utilisateur, validé par la touche **[Entrée]**. Pour un système qui vient d'être installé, ce nom est généralement **root**. |
| | |
| | <file> |
| | login as: root |
| | </file> |
| | |
| | Puis apparaît la ligne: |
| | |
| | <file> |
| | root@10.10.10.75's password: |
| | </file> |
| | |
| | Le premier mot est le nom utilisé pour se loguer suivi du caractère "@" et le nom du domaine du serveur ou son adresse IP. Enfin le mot ''password:''. |
| | |
| | A cet endroit vous donnez le mot de passe correspondant à l'utilisateur indiqué précédemment. Il est normal de ne rien voir s'afficher à l'écran: c'est pour éviter que quelqu'un ne lise votre mot de passe par-dessus votre épaule. Validez par [Entrée], et vous pouvez alors commencer à utiliser le système. |
| | |
| | ===== Notion de console ===== |
| | |
| | Considérez un ordinateur sur lequel tourne, par exemple, Linux. Ce que l'on appelle la console, c'est l'ensemble écran-clavier-souris, directement branchés sur l'ordinateur en question. La console se distingue du terminal //(constitué des mêmes éléments)// en ceci que ce dernier accède à l'ordinateur par l'intermédiaire d'un réseau. |
| | |
| | Physiquement, il ne peut y avoir qu'une seule console pour un ordinateur donné //(sauf de très rares exceptions)//. Linux, toutefois, offre la possibilité de "faire comme si" l'ordinateur disposait de plusieurs consoles: ces consoles sont alors dites virtuelles, car à un instant donné, seule l'une d'entre elles correspond à une réalité physique. Dans la littérature que vous pouvez rencontrer, il n'est pas rare de voir désigner les consoles par le terme "TTY" //(qui vient du mot "__t__ele__ty__pe")//. |
| | |
| | En mode texte, ces consoles sont habituellement au nombre de **6**. Ce nombre peut varier, être adapté à vos besoins spécifiques, selon le contenu du fichier ''/etc/inittab''. |
| | |
| | Le passage d'une console virtuelle à l'autre peut se faire à n'importe quel moment durant le fonctionnement du système: il suffit, au clavier, de presser simultanément la touche **[Alt]** et l'une des touches de fonction **[Fn]**, où n est le numéro de la console virtuelle que vous souhaitez obtenir. Au démarrage, vous êtes sous la console 1. |
| | |
| | {{Images_Cahier-101-03-005.png?25}} Ce mécanisme peut vous paraître un gadget, mais son utilité vous apparaîtra rapidement à l'usage. Une utilisation typique est d'utiliser une console pour saisir et exécuter des commandes plus ou moins complexes, et une ou plusieurs autres consoles pour visualiser diverses documentations expliquant comment utiliser ces commandes. |
| | |
| | Nous n'avons évoqué ici que le cas du mode texte. Un mécanisme analogue existe pour le mode graphique, plus sophistiqué //(sans pour autant être plus complexe)//. |
| | |
| | ===== Quitter le système ===== |
| | |
| | Au stade actuel de son développement, Linux est suffisamment robuste pour fonctionner vingt-quatre heures sur vingt-quatre, pour une durée théoriquement infinie //(sauf dysfonctionnement grave d'un programme, au point de déstabiliser le système)//. Mais pour une machine personnelle, il est plus courant de ne l'allumer que lorsqu'on en a besoin, et de l'éteindre aussitôt que l'on a terminé ce que l'on avait à faire. |
| | |
| | Du fait de sa complexité, Linux ne doit pas être arrêté brutalement, sous peine de risquer d'endommager gravement le système dans son ensemble //(ceci est également vrai pour d'autres systèmes, tels que Windows ou Unix)//: il est nécessaire, en quelque sorte, de prévenir Linux que l'on s'apprête à stopper son fonctionnement. Ceci afin de lui permettre de s'assurer que tout ce qui devait être sauvegardé l'a bien été, et plus généralement de prévenir les éventuels utilisateurs ou machines qui lui sont connectés. |
| | |
| | L'arrêt immédiat du système se fait par l'une des deux commandes, équivalentes: |
| | |
| | <file> |
| | shutdown -h now |
| | </file> |
| | |
| | <file> |
| | halt |
| | </file> |
| | |
| | Si l'on désire non seulement arrêter immédiatement le système, mais en plus redémarrer la machine juste après cet arrêt, l'une des deux commandes suivantes peut être utilisée: |
| | |
| | <file> |
| | shutdown -r now |
| | </file> |
| | |
| | <file> |
| | reboot |
| | </file> |
| | |
| | Seul l'utilisateur root est normalement autorisé à utiliser ces commandes, mais certains environnements graphiques permettent à d'autres utilisateurs d'arrêter la machine. |
| | |
| | Nous n'avons évoqué ici que les procédures d'arrêt les plus simples. Vous pouvez toutefois avoir besoin d'un comportement plus sophistiqué, selon vos besoins: consultez les pages man de ''shutdown'' pour plus de détails. |
| | |
| | ===== Le shell ===== |
| | |
| | Le **shell** est l'interpréteur de commandes. C'est un programme lancé juste après la procédure de login //(voir plus haut)//, dont le rôle est d'interpréter et d'exécuter les diverses commandes que vous pouvez lui donner: c'est en quelque sorte lui qui va réaliser la communication entre vous et le système. |
| | |
| | En fait, shell est un terme générique: il existe en effet plusieurs types de shell, chacun ayant sa propre syntaxe, son propre langage de programmation - car on peut écrire de véritables programmes pour le shell, pour des opérations trop sophistiquées pour la ligne de commande. |
| | |
| | Le shell standard //(aussi appelé shell de base)// fait partie des éléments fondamentaux du système et doit donc toujours être présent. C'est une reproduction fidèle du shell standard qui accompagne tout système Unix: il est assez fortement normalisé, ce qui permet d'écrire des programmes relativement portables d'un système à l'autre. On le désigne simplement par **sh**, du nom du programme correspondant. |
| | |
| | Sous Linux, on utilise plutôt une extension de ce shell, le shell **bash** //(pour "Bourne Again SHell", du nom du créateur du shell standard qui développa également cette extension)//. En fait, bash est considéré comme le shell standard sous Linux: il respecte complètement la norme standard, avec quelques fonctionnalités en plus. |
| | |
| | De nombreux autres shells existent. Citons les plus répandus, le C-shell et le KornShell. |
| | |
| | Le C-shell //(ou ''csh'')//, comme son nom l'indique, présente une syntaxe proche de celle du langage C. Sans doute plus complexe à utiliser que le shell standard, les possibilités offertes sont toutefois plus vastes. C'est le deuxième shell le plus utilisé sous Linux, derrière bash. |
| | |
| | Le KornShell //(ou ''ksh'')// peut être vu comme une mixture du C-Shell et du Bourne Shell. Sa richesse n'a d'égale que sa complexité, c'est pourquoi il est assez peu utilisé. Mais il est bon de le connaître, même vaguement, ne serait-ce que pour votre culture personnelle. |
| | |
| | En pratique, seule une connaissance générale du Bourne Shell est indispensable: c'est en effet lui qui est utilisé pour exécuter la très grande majorité des scripts de configurations, si ce n'est tous. Mais gardez à l'esprit que nombre d'outils graphiques, très conviviaux, vous permettent de réaliser nombre d'opérations sans taper une seule ligne de programme. |
| | |
| | ===== Commandes de bases ===== |
| | |
| | ==== Format général des commandes ==== |
| | |
| | Une fois le système démarré, il attend les ordres que vous voudrez bien lui donner, sous la forme de ce que l'on appelle un prompt. Celui-ci qui peut présenter différentes formes selon les cas, par exemple: |
| | |
| | <file> |
| | [root@tchana ~]# ▌ |
| | </file> |
| | |
| | Dans celui-ci, les informations affichées sont //(de gauche à droite)//: |
| | |
| | - le nom de l'utilisateur; |
| | - le nom de la machine sur laquelle cet utilisateur est connecté; |
| | - le répertoire courant. |
| | Le caractère ▌ symbolise le curseur. C'est à cet endroit que vous entrez les commandes au clavier, en terminant par la touche [Entrée] //(en général, la plus grosse du clavier, sur la droite des lettres)//. Par entrer une commande, on entend frapper au clavier une suite de lettres ou autres caractères, de manière à constituer des mots que le système pourra interpréter. Dans l'exemple qui suit, le symbole "**˽**"représente un espace frappé au clavier //(qui donc n'affiche rien à l'écran)//: |
| | |
| | <file> |
| | [root@tchana ~]# gzip˽-9˽Rapport.lyx˽Lettre.txt |
| | </file> |
| | |
| | Les espaces sont très importants lorsque vous donnez une commande. Par exemple, les deux mots ''gzip˽'' - ''9'' seront interprétés de manière totalement différente par le système sous la forme ''gzip-9'', sans espace. Ceci fait partie des règles à respecter pour donner correctement une commande au système; l'ensemble de ces règles est désigné sous le terme de syntaxe, qui a en fait le même sens que lorsqu'on l'emploie pour parler de la syntaxe de la langue française. |
| | |
| | Par ailleurs, il n'est pas rare que les commandes produisent un résultat à l'écran, c'est-à-dire affichent diverses informations. Dans la suite, nous parlerons alors d'affichage résultant, pour désigner ce qu'une commande pourra ainsi afficher. |
| | |
| | Normalement, le système exécute la commande //(si celle-ci est correctement orthographiée)// avant d'autoriser la saisie d'une nouvelle commande. Toutefois, Linux est multitâche: il est donc possible de lancer une commande en arrière-plan, et de récupérer immédiatement la main. La commande s'exécutera alors pendant que vous faites autre chose. Ceci est particulièrement intéressant pour les commandes de longue durée, dont on peut ignorer l'affichage résultant. On réalise l'exécution d'une commande en arrière-plan en la faisant suivre du symbole "et-commercial" ''&''. Par exemple: |
| | |
| | <file> |
| | [root@tchana ~]# ls -alR / > tous_fichiers & |
| | </file> |
| | |
| | Cette commande va donner une liste complète des fichiers du système, et stocker le résultat dans le fichier ''tous_fichiers''. C'est généralement quelque chose d'assez long //(un système Linux comporte souvent quelque dix mille ou vingt mille fichiers)//... Des explications permettant de comprendre cette commande viennent ci-dessous. |
| | |
| | Comme vous l'avez constaté, nous utilisons une forme de caractère différente lorsqu'il s'agit de commandes ou de nom de fichiers. |
| | |
| | ==== Options ==== |
| | |
| | La plupart des commandes acceptent des options //(appelées aussi paramètres)//, qui permettent de préciser la manière dont elles doivent s'exécuter. |
| | |
| | Sous Linux, la manière usuelle de spécifier des options est un tiret '**-**' précédé d'un espace et suivi d'une lettre, ou alors d'un double-tiret '**--**' suivi d'un mot. Il est généralement possible de combiner plusieurs options "mono-lettres" en une seule. Par exemple: |
| | |
| | <file> |
| | ls˽-lisa˽-color=tty |
| | </file> |
| | |
| | Equivaut à: |
| | |
| | <file> |
| | ls˽-l˽-i˽-s˽-a˽-color=tty |
| | </file> |
| | \\ |
| | |
| | <file> |
| | rpm˽-i˽libg++-2.7.2.8-9.i386.rpm˽-nodeps |
| | </file> |
| | |
| | Encore une fois, les espaces sont très importants. Dans la deuxième commande, le mot ''libg++-2.7.2.8-9.i386.rpm'' est un nom de fichier. Remarquez que ce nom comporte justement un tiret: l'absence d'espace avant permet au système de comprendre que ce qui vient après le tiret n'est pas une option, mais la suite du nom de fichier. |
| | |
| | Deux options très répandues sont: //**-h**// et //**--help**// qui donnent une //(courte!)// aide sur l'utilisation de la commande. |
| | |
| | <file> |
| | commande -h |
| | </file> |
| | |
| | <file> |
| | commande --help |
| | </file> |
| | |
| | |
| | |
| | Pour afficher le numéro de version de la commande utilisée. |
| | |
| | <file> |
| | commande -V |
| | </file> |
| | |
| | <file> |
| | commande -ver |
| | </file> |
| | |
| | ==== Redirections ==== |
| | |
| | Il est fréquent que les commandes produisent un résultat à l'écran ou parfois demandent des informations complémentaires à l'utilisateur. Il est possible de rediriger ces entrées/sorties à l'aide des symboles '**>**' et '**<**': par exemple, le résultat d'une commande est trop long pour être affiché dans l'écran, ou bien on désire en garder une trace. Une redirection de la sortie de cette commande permet de stocker ce qu'elle afficherait normalement dans un fichier. |
| | |
| | La commande suivante liste tous les éléments //(habituellement désignés sous le vocable de packages)// d'un système installé à partir d'une distribution RedHat, CentOS, NethServer ou SuSE: |
| | |
| | <file> |
| | rpm -qa |
| | </file> |
| | |
| | Si vous possédez une telle distribution, le nombre de packages dépasse en général largement la hauteur de l'écran... Et c'est assez malcommode à consulter. Ce problème peut être résolu en envoyant l'affichage dans un fichier, qu'il sera alors possible de consulter à loisir ou d'imprimer: |
| | |
| | <file> |
| | rpm -qa > tous_les_packages.txt |
| | </file> |
| | |
| | Les redirections peuvent être effectuées dans l'autre sens. Supposons que vous souhaitiez envoyer un courrier électronique dont le texte se trouve dans un fichier. Une méthode consiste à exécuter: |
| | |
| | <file> |
| | mail untel@tel.adresse < message.txt |
| | </file> |
| | |
| | Ces exemples simples ne montrent pas toute la puissance des redirections. Disons simplement qu'il est possible de combiner les deux types ensemble, ou encore d'utiliser les **pipes** exposés maintenant... |
| | |
| | ==== Pipe ==== |
| | |
| | Ce mécanisme de Pipe(( **Pipe**: En français, on parle de tubes. )) permet d'enchaîner l'exécution de plusieurs commandes, en branchant la sortie d'une commande sur l'entrée de la suivante, à l'aide du symbole '|' //(obtenu sur un clavier Français //(Canada)// usuel en pressant simultanément sur la touche //**[ AltGr ]**// et la touche à gauche du caractère //1// c.-à-d. //**[ | ]**// )//. Prenons un exemple. |
| | |
| | Vous souhaitez connaître tous les fichiers de votre système dont le nom comporte les caractères 'doc'. |
| | |
| | La commande permettant d'obtenir tous les fichiers du système est ''ls -alR /'', nous l'avons déjà rencontrée. |
| | |
| | Il existe une commande permettant de rechercher les lignes comportant un certain texte dans un fichier, et de n'afficher que celles-ci: la commande **grep** //(inutile pour l'instant de la comprendre pleinement!)//. |
| | |
| | Avec les redirections, nous pourrions obtenir ce que nous voulons par: |
| | |
| | <file> |
| | ls -alR / > tous_fichiers |
| | </file> |
| | |
| | <file> |
| | grep doc tous_fichiers |
| | </file> |
| | |
| | Un pipe nous permet toutefois de simplifier l'expression et d'éviter la création d'un fichier: |
| | |
| | <file> |
| | ls -alR / | grep doc |
| | </file> |
| | |
| | Le fonctionnement peut être illustré par la //Figure 2//. |
| | |
| | <WRAP centeralign>//**Figure 2: Mécanisme d'un pipe.**//</WRAP> |
| | {{ Images_Cahier-101-01-003.png?400 }} |
| | |
| | Ce qui se passe en réalité est ce qui est normalement affiché par la première commande, est utilisé par la deuxième comme s'il s'agissait d'un véritable fichier. |
| | |
| | La combinaison des pipes et des redirections, en donnant les options judicieuses aux commandes impliquées, permet de réaliser en une seule ligne de commande des opérations très complexes. Mais gare à ne pas se perdre soi-même... |
| | |
| | ==== Jokers ==== |
| | |
| | Il est fréquent qu'une commande fasse référence à, ou utilise, un fichier. On peut toutefois vouloir appliquer une commande à plusieurs fichiers, parfois en très grand nombre; le fait de retaper la commande pour chaque fichier peut devenir rapidement fastidieux. |
| | |
| | C'est pourquoi il existe les caractères **jokers**. Leur rôle est de remplacer une ou plusieurs lettres dans un nom de fichier, de la même manière que le joker d'un jeu de cartes remplace la carte manquante. Il existe deux caractères jokers selon ce que l'on veut faire: |
| | |
| | Le premier, sans doute le plus utilisé, permet de remplacer un groupe de caractères //(lettres ou autre)//. |
| | <file> |
| | * |
| | </file> |
| | |
| | Le second permet de remplacer un seul caractère. |
| | <file> |
| | ? |
| | </file> |
| | |
| | Envisageons quelques exemples. |
| | |
| | Vous souhaitez obtenir la liste de tous les fichiers du répertoire courant commençants par les lettres **courrier_**. La commande est la suivante: |
| | |
| | <file> |
| | ls courrier_* |
| | </file> |
| | |
| | Le caractère ''*'' est interprété comme "n'importe quoi": on demande donc la liste des fichiers commençant par ''courrier_'' suivi de "n'importe quoi". Par contre, la commande: |
| | |
| | <file> |
| | ls courrier_? |
| | </file> |
| | |
| | limite l'affichage aux fichiers dont le nom commence par ''courrier_'' suivi d'un seul caractère //(quel qu'il soit)//. |
| | |
| | Pour reprendre en partie l'exemple donné sur les pipes plus haut, une recherche équivalente dans le répertoire courant s'écrirait: |
| | |
| | <file> |
| | ls *doc* |
| | </file> |
| | |
| | ===== man ===== |
| | |
| | Besoin d'un renseignement sur la fonction ou l'utilisation d'une commande? Des questions sur la structure d'un fichier de configuration? La commande ''man'' est là pour ça! |
| | |
| | La commande man donne accès aux "pages man(( **man**: man-pages en anglais, "man" pour manual, manuel en français. ))", les pages de manuel. Ces pages se trouvent dans le répertoire ''/usr/man'', mais peuvent également se trouver en d'autres endroits plus spécialisés //(voir Figure 1)//. |
| | |
| | Ce que l'on appelle communément "le man" est subdivisé en plusieurs sections selon le propos des pages(( **pages**: Liste extraite du Man-Page mini-Howto. )), comme le montre le //Tableau 2//. |
| | |
| | ^ <WRAP centeralign>\\ Tableau 2: Les sections des pages man</WRAP> ^^ |
| | |//**Nom**//|//**Description**//| |
| | |1|Commandes utilisateurs usuels et communes| |
| | |2|Appels système //(fonctions du kernel)//| |
| | |3|Sous-programmes //(fonctions des librairies de programmation)//| |
| | |4|Périphériques //(fichiers dans /dev)//| |
| | |5|Format //(structure)// de certains fichiers, comme /etc/passwd| |
| | |6|Jeux| |
| | |7|Divers| |
| | |8|Outils d'administration système //(réservé à root)//| |
| | |9|Autres fonctions du noyau //(kernel)//| |
| | |n|Documentation nouvelle //(qui peut être déplacée par la suite)//| |
| | |o|Documentation ancienne //(qui peut disparaître un jour)//| |
| | |l|Documentation locale //(spécifique au système que l'on utilise)//| |
| | |
| | Pour accéder à la page concernant une commande //(par exemple,'' chmod'')//, il suffit de taper: |
| | |
| | <file> |
| | man chmod |
| | </file> |
| | |
| | La commande man possède de nombreuses options de ligne de commande. Citons par exemple: |
| | |
| | Permettre d'obtenir toutes les pages concernant le nom donné: ''-a''. |
| | |
| | <file> |
| | man -a kill |
| | </file> |
| | |
| | Pour provoquer un formatage PostScript de la page, avant de l'envoyer sur la sortie standard: ''-t''.\\ |
| | Une redirection permettant d'obtenir un fichier PostScript immédiatement imprimable: |
| | |
| | <file> |
| | man -t adduser > adduser.ps |
| | </file> |
| | |
| | Il existe de nombreuses autres possibilités, mais rien de vous empêche de faire: |
| | |
| | <file> |
| | man man |
| | </file> |
| | |
| | Enfin, si vous savez dans quelle section se trouve la page cherchée //(dans le cas de commandes possédant un équivalent en programmation)//, il est possible d'indiquer la section où chercher la page voulue: |
| | |
| | <file> |
| | man 2 mount |
| | </file> |
| | |
| | <file> |
| | man 8 mount |
| | </file> |
| | |
| | Le man est une source inépuisable de renseignements. Surtout ne jamais le négliger! Mais il est également possible d'obtenir de nombreuses informations dans le répertoire ''/usr/doc'', notamment le sous-répertoire ''HOWTO''. |
| | |
| | ===== Parcours et manipulation des répertoires ===== |
| | |
| | ==== Promenade dans les répertoires ==== |
| | |
| | La commande ''cd'' permet de changer le répertoire courant. |
| | |
| | Supposons nous trouver dans le répertoire ''/home'', et pour quelque raison nous voulons aller dans le répertoire ''/usr/doc''. Les trois séries de commandes suivantes effectuent l'opération souhaitée: |
| | |
| | <file> |
| | cd /usr/doc |
| | </file> |
| | |
| | <file> |
| | cd ../usr/doc |
| | </file> |
| | |
| | <file> |
| | cd .. |
| | |
| | cd usr |
| | |
| | cd doc |
| | </file> |
| | |
| | Encore un exemple: nous sommes dans ''/usr/local/doc'', et nous voulons aller dans ''/usr/X11R6/doc''. Trois manières d'y parvenir: |
| | |
| | <file> |
| | cd .. |
| | |
| | cd .. |
| | |
| | cd X11R6 |
| | |
| | cd doc |
| | </file> |
| | |
| | <file> |
| | cd ../../X11R6/doc |
| | </file> |
| | |
| | <file> |
| | cd /usr/X11R6/doc |
| | </file> |
| | |
| | A vous de trouver laquelle vous préférez... |
| | |
| | ==== Création de répertoires ==== |
| | |
| | La commande ''mkdir'' est utilisée pour créer un répertoire. Il est naturellement possible d'utiliser un chemin relatif ou un chemin absolu. Pour créer un répertoire dans le répertoire courant, il suffit de taper quelque chose du genre: |
| | |
| | <file> |
| | mkdir rep |
| | </file> |
| | |
| | Une option intéressante est l'option ''-p'': elle permet de créer en une fois une hiérarchie de répertoire. Supposons que dans le répertoire courant, le répertoire ''Lettres'' n'existe pas, que l'on veuille le créer, ainsi qu'un sous-répertoire ''perso'', contenant lui-même un répertoire ''Nath''. On peut le faire en exécutant simplement: |
| | |
| | <file> |
| | mkdir -p Lettres/perso/Nath |
| | </file> |
| | |
| | ==== Suppression de répertoires ==== |
| | |
| | La commande ''rmdir'' est utilisée pour supprimer un répertoire. Normalement, si le répertoire n'est pas vide, la commande envoie un message d'erreur. Il est toutefois possible de supprimer une hiérarchie de répertoires vides en une seule fois, avec l'option ''-p''. Par exemple, juste après avoir exécuté: |
| | |
| | <file> |
| | mkdir -p Lettre/perso/Nath |
| | </file> |
| | |
| | on peut supprimer tous les répertoires que l'on vient de créer avec: |
| | |
| | <file> |
| | rmdir -p Lettre/perso/Nath |
| | </file> |
| | |
| | Par contre, la commande |
| | |
| | <file> |
| | rmdir -p Lettre/perso |
| | </file> |
| | |
| | renverra une erreur, car ''perso'' contient encore ''Nath'' et donc n'est pas vide. |
| | |
| | ==== Savoir où l'on est ==== |
| | |
| | La commande ''pwd'' toute simple donne le répertoire courant, par son chemin absolu. Bien pratique dans certains cas... |
| | |
| | === Encombrements des répertoires et des fichiers === |
| | |
| | Deux outils pour le contrôle de l'espace disque occupé par les fichiers. |
| | |
| | Pour connaître l'espace disque occupé par les fichiers d'un répertoire. |
| | |
| | <file> |
| | du |
| | </file> |
| | |
| | Pour connaître l'espace disque total occupé et restant sur les partitions de votre système. |
| | |
| | <file> |
| | df |
| | </file> |
| | |
| | ==== Illustration ==== |
| | |
| | La //Figure 3// illustre l'utilisation des commandes évoquées dans cette section. Le répertoire courant apparaît en grisé sur le dessin. Naturellement, seule une partie de l'arborescence est présentée. |
| | |
| | <WRAP centeralign>//**Figure 3: Démonstration de manipulations de répertoires.**//</WRAP> |
| | {{ Images_Cahier-101-01-004.png?600 }} |
| | |
| | ===== Manipulation des fichiers ===== |
| | |
| | ==== Liste des fichiers dans un répertoire ==== |
| | |
| | La commande ''ls'' donne la liste des fichiers contenus dans un répertoire. Appelée sans arguments, ls donne la liste des fichiers dans le répertoire courant. |
| | |
| | Il existe de nombreuses options à ''ls''. Nous n'évoquerons ici que les principales et les plus utiles, pour le reste, consultez la page man correspondante ''man ls''. |
| | |
| | Lister les fichiers cachés //(dont le nom commence par un point)//. |
| | |
| | <file> |
| | ls -a |
| | </file> |
| | |
| | Affichage "long": donne des informations supplémentaires sur les fichiers, tels que la taille, la date de dernière modification, les droits d'accès, etc. |
| | |
| | <file> |
| | ls -l |
| | </file> |
| | |
| | Lister récursivement le contenu des sous-répertoires. Essayez donc un ''ls -alR /''... |
| | |
| | <file> |
| | ls -R |
| | </file> |
| | |
| | Affiche les fichiers en les ordonnant selon leur extension //(les caractères après le dernier point)//. |
| | |
| | <file> |
| | ls -X |
| | </file> |
| | |
| | Lister sur une seule colonne. Par défaut, ''ls'' utilise plusieurs colonnes, selon la longueur des noms à afficher. |
| | |
| | <file> |
| | ls -1 |
| | </file> |
| | |
| | Appliquer une couleur selon le type de fichier: une pour les répertoires, une pour les commandes exécutables, etc. |
| | |
| | <file> |
| | ls -color=tty |
| | </file> |
| | |
| | ==== Supprimer des fichiers ==== |
| | |
| | Il est évidemment possible de supprimer des fichiers sous Linux. La commande à utiliser est ''rm''. Prenez garde aux erreurs de manipulation: une fois un fichier effacé, il n'est plus possible de récupérer son contenu, celui-ci est irrémédiablement perdu. Par exemple, s'il existe dans le répertoire courant un fichier nommé core //(les fichiers de ce nom sont généralement générés lorsqu'un programme provoque une erreur)//, vous pouvez le supprimer par: |
| | |
| | <file> |
| | rm core |
| | </file> |
| | |
| | === Les options les plus utilisées de rm === |
| | |
| | Supprimer tout un répertoire, ainsi que ses sous-répertoires. |
| | |
| | <wrap em>Attention!</wrap> Sur certains systèmes, une commande telle que ''rm -R .*'' peut avoir des conséquences catastrophiques: elle supprime le répertoire courant, ainsi que les répertoires qu'il contient. Or, le répertoire ''..'', qui désigne l'ancêtre du répertoire courant, est contenu dans celui-ci: sur certaines versions, ''rm'' va alors "remonter" dans l'arborescence, parvenir à la racine, puis redescendre... En quelques secondes, vous pouvez ainsi supprimer tous les fichiers de votre système Linux! |
| | |
| | <file> |
| | rm -R |
| | </file> |
| | |
| | Demander une confirmation avant de supprimer un fichier. |
| | |
| | <file> |
| | rm -i |
| | </file> |
| | |
| | ==== Copier des fichiers ==== |
| | |
| | La copie de fichiers //(c'est-à-dire une duplication à l'identique, comme un clonage)// s'effectue par ''cp''. Il est toujours nécessaire d'indiquer ce que l'on copie //(la source)//, puis vers quel endroit on le copie //(la destination)//. Les caractères jockers //(voir ci-haut, le paragraphe [[nethserver_101_cahier_01_linux#Jokers]])// peuvent bien entendu être utilisés. |
| | |
| | Méfiez-vous lorsque vous utilisez cette commande, surtout en tant qu'utilisateur root //(voir le paragraphe [[nethserver_101_cahier_01_linux#Le super-utilisateur]])//: sauf configuration particulière, si vous copiez un fichier sur un autre de même nom dans un autre répertoire, ce dernier sera purement et simplement écrasé sans avertissement, c'est-à-dire que son contenu sera irrémédiablement perdu. |
| | |
| | Enfin, la commande ''cp'' peut être utilisée pour simplement dupliquer un fichier dans un même répertoire. Par exemple, si dans le répertoire courant se trouve un fichier nommé ''Rapport.lyx'', que vous souhaitez modifier mais en conservant la version précédente, vous pouvez effectuer: |
| | |
| | <file> |
| | cp Rapport.lyx Rapport.lyx.org |
| | </file> |
| | |
| | Le fichier actuel sera ainsi sauvegardé en tant que ''Rapport.lyx.org''. Si vous n'êtes pas satisfait de vos modifications, vous pourrez toujours restaurer la version précédente par: |
| | |
| | <file> |
| | cp Rapport.lyx.org Rapport.lyx |
| | </file> |
| | |
| | Nous utilisons ici le fait que copier un fichier sur un fichier de même nom, écrase celui-ci: le ''Rapport.lyx'' sera exactement identique à celui que vous aviez sauvegardé avec la première commande. |
| | |
| | Une utilisation plus courante de ''cp'' est de copier un fichier situé quelque part dans le répertoire courant, pour, par exemple l'éditer. Si vous souhaitez ainsi disposer dans le répertoire courant du fichier ''Printing-HOWTO'' situé dans le répertoire ''/usr/doc/HOWTO'', vous pouvez utiliser: |
| | |
| | <file> |
| | cp /usr/doc/HOWTO/Printing-HOWTO . |
| | </file> |
| | |
| | Le ''.'' final désigne, rappelez-vous, le répertoire courant. |
| | |
| | === Quelques options === |
| | |
| | Pour copier une arborescence récursivement: si la source est un répertoire, cette option va copier ce répertoire et son contenu ainsi que tous les sous-répertoires qu'il contient. |
| | |
| | <file> |
| | cp -R source destination |
| | </file> |
| | |
| | Demander une confirmation si un fichier risque d'être écrasé. |
| | |
| | <file> |
| | cp -i source destination |
| | </file> |
| | |
| | Afficher le nom de chaque fichier avant de le copier. Utile lorsqu'on copie un répertoire ou qu'on utilise les caractères jockers. |
| | |
| | <file> |
| | cp -v source destination |
| | </file> |
| | |
| | ==== Déplacer ou renommer des fichiers ==== |
| | |
| | La commande ''mv'' permet de déplacer des fichiers //(les fichiers sont copiés comme avec ''cp'', puis effacés de la source)//. Si le répertoire source est le même que le répertoire destination, cette commande permet de renommer des fichiers. |
| | |
| | Par exemple, s'il se trouve dans le répertoire courant un fichier nommé ''Lettre'' que vous voudriez renommer //(changer son nom)// en ''Lettre-2017.01.06'' //(une bonne manière d'insérer la date dans un nom de fichier)//, vous pouvez effectuer: |
| | |
| | <file> |
| | mv Lettre Lettre-2017.01.06 |
| | </file> |
| | |
| | Supposons maintenant que vous souhaitiez déplacer ce fichier dans un répertoire qui s'appellerait ''Archives'', c'est-à-dire placer une copie du fichier dans ce répertoire et supprimer l'original. Une première méthode est: |
| | |
| | <file> |
| | cp Lettre-2017.01.06 Archives |
| | |
| | rm Lettre-2017.01.06 |
| | </file> |
| | |
| | La commande ''mv'' permet de faire la même chose en une seule ligne: |
| | |
| | <file> |
| | mv Lettre-2017.01.06 Archives |
| | </file> |
| | |
| | {{Images_Cahier-101-03-006.png?25}} De même qu'avec la commande ''cp'', méfiez-vous; cette commande peut écraser des fichiers si la cible existe déjà. |
| | |
| | La commande ''mv'' possède peu d'options. |
| | |
| | Forcer le déplacement, même si la cible existe déjà: ceci supprime les éventuels messages d'avertissement. |
| | |
| | <file> |
| | mv -f source destination |
| | </file> |
| | |
| | Au contraire, l'option ''-i'' provoque une demande de confirmation si des fichiers risquent d'être écrasés. |
| | |
| | <file> |
| | mv -i source destination |
| | </file> |
| | |
| | ==== La complétion des noms de fichier ==== |
| | |
| | Il s'agit là d'un petit quelque chose très pratique du shell Bash. Prenons un exemple: entrez la commande suivante //(sans danger)//: |
| | |
| | <file> |
| | cd /etc |
| | </file> |
| | |
| | Le résultat de cette commande est de nous amener dans le répertoire ''/etc'', qui devient donc le répertoire courant. |
| | |
| | Maintenant, tapez les caractères suivants, mais n'appuyez pas immédiatement sur [Entrée]: |
| | |
| | <file> |
| | more H |
| | </file> |
| | |
| | Appuyez maintenant sur la touche de **[Tab]**. Normalement, vous devriez voir apparaître: |
| | |
| | <file> |
| | more HOSTNAME |
| | </file> |
| | |
| | Que s'est-il passe? Lorsque vous avez appuyé sur la touche [Tab], le shell a recherché dans le répertoire courant les fichiers dont le nom commence par la lettre 'H' //(rappelez-vous que Linux distingue les majuscules des minuscules dans les noms de fichiers)//. En principe, il n'y en qu'un seul, et le shell complète alors le nom du fichier. Recommencez, avec cette fois: |
| | |
| | <file> |
| | more f |
| | </file> |
| | |
| | suivi à nouveau de la touche [Tab]. Rien ne se passe, avec un peu de chance vous devriez même entendre un bip: c'est que plusieurs fichiers commencent par la lettre ''f''. Appuyez une deuxième fois sur [Tab] rapidement, et le shell affichera tous les fichiers commençant par ''f''. |
| | |
| | Ceci fonctionne également si vous donnez un groupe de lettres, ou un chemin //(relatif ou absolu)//. |
| | |
| | Si [Tab] est suivi d'un bip, plusieurs fichiers commencent par 'rc' dans le répertoire /etc/rc.d. |
| | |
| | <file> |
| | more /etc/rc.d/rc |
| | </file> |
| | |
| | Cette petite fonctionnalité est très pratique dès que l'on se trouve confronté à des noms de fichiers un peu longs. Expérimentez-la, vous l'apprécierez rapidement! |
| | |
| | Pour vous replacer dans votre répertoire de login. |
| | |
| | <file> |
| | cd |
| | </file> |
| | |
| | ==== Affichage de fichiers (texte) ==== |
| | |
| | Les commandes ''more'' et ''less'' permettent de consulter le contenu d'un fichier à l'écran, en l'affichant page par page. Par exemple: |
| | |
| | <file> |
| | more /etc/inittab |
| | </file> |
| | |
| | <file> |
| | less /etc/passwd |
| | </file> |
| | |
| | Vous pouvez passer à la page suivante en appuyant sur la barre d'espace de votre clavier. Pour remonter d'une page avec ''less'', il suffit de presser la touche 'b' //(back)//. Normalement, ''less'' ne vous rend pas automatiquement la main: une fois arrivé à la fin du document, il faut presser la touche 'q' pour terminer ''less'' et pouvoir entrer une autre commande. |
| | |
| | La commande more est plus ancienne. La commande ''less'' est une sorte de "super-more", en ceci qu'elle ajoute nombre de fonctionnalités. Consultez la page man correspondante pour plus de détails. La commande ''less'' accepte des commandes lors de son fonctionnement: vous les tapez simplement au clavier lorsque ''less'' a fini d'afficher une page, suivies d'un appui sur [Entrée]. |
| | |
| | Effectuer une recherche du motif dans le texte //(les caractères '<' et '>' ne doivent pas être inclus)//. Très utile pour rechercher un mot dans un document long: pour rechercher le mot ''bonjour'', entrez la commande ''/<bonjour>''. |
| | |
| | <file> |
| | /<motif> |
| | </file> |
| | |
| | //**g**// -> pour retourner au début du fichier. |
| | |
| | //**G**// -> pour aller à la fin du fichier. |
| | |
| | //**ng**// -> pour aller à la ligne "n" du fichier. |
| | |
| | Il est assez fréquent d'utiliser ces commandes à travers un pipe (voir plus haut, le paragarphe [[nethserver_101_cahier_01_linux#Pipe]]) pour lire un affichage long résultant d'une commande. Par exemple, la commande ''dmesg'' permet de voir les messages du système lors du démarrage: cela représente souvent plus d'une page-écran. Pour pouvoir consulter facilement ces messages, vous pouvez effectuer: |
| | |
| | <file> |
| | dmesg | more |
| | </file> |
| | |
| | === Illustration === |
| | |
| | La //Figure 4// vous propose une démonstration des commandes rm, cp et mv évoquées plus haut. Les répertoires sont dans des cadres aux coins arrondis, les fichiers dans des cadres aux coins droits. Le répertoire courant est toujours ''yves''. |
| | |
| | <WRAP centeralign>//**Figure 4: Démonstration de manipulation de fichiers.**//</WRAP> |
| | {{ Images_Cahier-101-01-005.png?700 }} |
| | |
| | Le contenu des fichiers est symbolisé par un motif de remplissage: un même motif remplissant les cadres de deux fichiers différents, signifie des contenus identiques. |
| | |
| | ===== Programme, processus, logiciel & Cie ===== |
| | |
| | Nous allons tenter ici de clarifier quelques termes d'emploi fréquent. Commençons par un que nous avons déjà rencontré, le terme de programme. |
| | |
| | Une définition un peu abstraite, tirée d'un dictionnaire, est de dire qu'un programme est une suite d'instructions compréhensible par l'ordinateur, organisée de manière à ce que celui-ci accomplisse une tâche donnée. C'est sans doute exact, mais ça ne nous renseigne pas sur la forme que prennent les programmes sur notre système Linux... |
| | |
| | Essayez donc la commande suivante: |
| | |
| | <file> |
| | more /bin/more |
| | </file> |
| | |
| | Normalement, vous devriez voir une série de caractères parfaitement incompréhensible, peut-être même entendre quelques beeps et récupérer un affichage désordonné //(dans ce dernier cas, changez de console virtuelle, comme indiqué au paragraphe [[nethserver_101_cahier_01_linux#Notion de console]])//. Que vient-il de se passer? |
| | |
| | La commande ''more'' vous est déjà connue, elle permet d'afficher le contenu d'un fichier. Lorsque vous appuyez sur [Entrée] après avoir tapé la commande, vous demandez au système d'exécuter un programme; ''more'' en l'occurrence. Mais sans doute avez-vous remarqué que le fichier dont nous avons demandé l'affichage porte le même nom que la commande... |
| | |
| | Ce fichier est justement celui qui contient le programme correspondant à la commande ''more''. Les instructions d'un programme //(ce qu'il doit faire)// sont en effet contenues dans un fichier, le plus souvent sous une forme que l’œil humain ne peut saisir mais, aisément utilisable par l'ordinateur //(on parle alors de fichier binaire et tous les programmes ne se présentent pas sous cette forme)//. La très grande majorité des commandes sont donc des programmes dont les instructions sont contenues dans des fichiers binaires. |
| | |
| | Mais continuons notre enquête. Lorsque le système tente d'exécuter un programme, il lit le fichier qui le contient pour le placer dans sa mémoire. Alors seulement les instructions du programme sont exécutées, laquelle exécution se traduit le plus souvent par l'utilisation de davantage de mémoire par la lecture ou l'écriture de divers fichiers, des affichages à l'écran... Le programme que nous avons exécuté plus haut, par exemple, a lu un fichier ''/bin/more'' et affiché son contenu à l'écran. |
| | |
| | On se trouve alors en présence d'une entité dans la mémoire de l'ordinateur, qui évolue, qui agit sur différents éléments qui lui sont accessibles. On pourrait même considérer qu'elle est née //(lors de la lecture du "fichier-programme" par le système)//, qu'elle vit //(lors de l'exécution des instructions contenues dans le programme), et qu'elle mourra (lorsque sa tâche sera accomplie)//. Cette entité presque vivante est ce que l'on appelle un processus. Dans un système tel que Linux, tout processus est "lancé" par un autre processus et est à même d'"enfanter" un ou plusieurs processus: on peut donc parler de "relation père-fils" entre les processus. Sachez qu'il est très courant d'avoir plus d'une vingtaine de processus s'exécutant simultanément lors du fonctionnement d'un système Linux, éventuellement communiquant entre eux. Pour s'y retrouver, le système attribue à chacun d'eux un numéro unique, désigné par le terme de PID //(**Process Identifier**//(( Identifiant ou Identificateur du Processus en français. ))//)//. Par ailleurs, un même programme peut être exécuté plusieurs fois: à chaque exécution correspondra un processus à part. |
| | |
| | Naturellement, la plupart des processus ne font guère parler d'eux: sinon, votre écran serait rapidement rempli de messages et il vous serait impossible de vous retrouver dans un fouillis pareil. En fait, la plupart des processus tournent en arrière-plan; c'est-à-dire qu'ils font ce qu'ils doivent faire en silence. Par exemple, le processus qui vous permet d'accéder au système n'intervient que lorsqu'il est sollicité; le reste du temps il est silencieux. On parle communément de **daemons**(( **d****ae****mon**: De l'anglais daemon __D__isk __a__nd __E__nvironment __Mon__itor. La traduction n'est peut-être pas très heureuse linguistiquement, mais elle correspond bien à l'idée. En fait, services et démons sont deux choses différentes: le démon est le processus mémoire qui, par son exécution, rend un certain service //(comme la gestion du courrier électronique)//. Mais la confusion est pour l'instant sans grande conséquence. )) pour désigner de tels processus lorsqu'ils font partie des composantes du système. |
| | |
| | Pour finir notre "bestiaire occulte", citons le cas des zombies. Ce sont des processus parvenus au terme de leur exécution //(soit normalement, soit à la suite d'une erreur)//, mais que le système ne parvient pas à éradiquer de la mémoire. Ils demeurent donc ainsi, le plus souvent totalement inactifs, mais occupant une certaine quantité de mémoire, ce qui peut devenir gênant si leur nombre augmente trop. En général, cet état survient quand un processus se termine alors que le système n'a pas le temps de s'occuper de l'effacer de la mémoire parce qu'il est trop sollicité. Cela peut également arriver lorsque le processus a provoqué une erreur telle que le système ne sait pas quoi en faire. Mais cela reste assez rare, ne vous inquiétez pas. |
| | |
| | Nous savons maintenant ce qu'est un programme et un processus. Donnons alors quelques définitions. |
| | |
| | Un logiciel est un ensemble de programmes fortement liés entre eux, destinés à remplir une mission nécessitant plusieurs tâches plus ou moins complexes. Par exemple, un traitement de texte qui peut aussi bien être utilisé pour rédiger un curriculum vitae que pour rédiger un livre entier. |
| | |
| | Un système d'exploitation, dont nous parlons depuis le début, est un logiciel particulier; son rôle est de permettre à d'autres programmes de s'exécuter dans les meilleures conditions et d'utiliser le matériel électronique de l'ordinateur. L'exécution d'un système tel que Linux peut donner lieu à l'apparition d'une multitude de processus. |
| | |
| | Enfin, ce que l'on désigne par code source est ce qu'un //(ou plusieurs)// être humain a tapé au clavier, dans un certain langage de programmation compréhensible par lui, pour construire un programme. Ce texte n'est pas compréhensible par l'ordinateur et doit subir une phase de traduction //(ou compilation)// pour obtenir un fichier binaire. Par exemple, Linux lui-même est programmé dans un langage //(presque)// intelligible, nommé langage C et normalement le code source de Linux se trouve dans une arborescence située dans le répertoire ''/usr/src/linux''. Notez qu'habituellement le code source des logiciels et systèmes commerciaux n'est pas ainsi librement disponible: Linux //(et la plupart des outils qui l'accompagnent)// appartient au mouvement **LIBRE** //(OpenSource)// et fait figure d'exception. |
| | |
| | ===== Programmes usuels ===== |
| | |
| | ==== Manipuler fichiers et répertoires aisément: mc ==== |
| | |
| | Ce petit programme est inspiré de Norton Commander qui était disponible pour le système MS-DOS. Son nom "complet" est Midnight Commander et on l'obtient avec la commande ''mc''. Il en résulte alors un écran ressemblant à celui proposé à la //Figure 5//. |
| | |
| | <WRAP centeralign>//**Figure 5: Écran de Midnight Commander (mc).**//</WRAP> |
| | {{ Images_Cahier-101-01-006.png?800 }} |
| | |
| | Il est possible que le résultat que vous obtenez ne soit pas en couleur: il faut alors utiliser l'option ''-c'' et exécuter plutôt ''mc -c''. |
| | |
| | L'écran se trouve divisé en deux parties que nous appellerons les volets de gauche et de droite. Chacun vous permet de consulter le contenu d'un répertoire dont le chemin complet figure en haut du volet. Dans notre exemple, le volet de gauche affiche le contenu du répertoire ''/lib'', tandis que celui de droite affiche le contenu du répertoire propre à l'utilisateur qui a lancé ''mc'' //(c'est le sens du symbole ''~'', qui représente toujours le répertoire principal d'un utilisateur)//. |
| | |
| | Dans les listes contenues dans chacun des volets, différents codes de couleur sont utilisés pour représenter différents éléments. Ainsi, les répertoires contenus dans le répertoire visité apparaissent en blanc brillant et caractères gras, précédés d'un slash ''/''. Les fichiers exécutables //(correspondant à des programmes)// apparaissent en vert et le nom est précédé d'une étoile ''*''. Les fichiers dont le nom est précédé d'une arobase ''@'' sont des liens symboliques //(voyez le paragraphe [[nethserver_101_cahier_01_linux#Mécanisme des liens]] pour plus d'information sur les liens)//. |
| | |
| | Sur la droite des noms de fichier, vous voyez également une colonne avec la taille du fichier //(en octets)// et une colonne avec la date de dernière modification du fichier. Dans l'un des deux volets, il y a toujours un fichier sélectionné et celui-ci est marqué par une barre de couleur; dans notre exemple c'est le répertoire ''/..'' du volet de gauche qui est sélectionné. Vous pouvez déplacer la sélection avec les touches de déplacement //(flèches Haut et Bas)//, ou bien les touches **[Début]** //(retour au début de la liste)//, **[Fin]** //(aller à la fin de la liste)//, **[Page Avant]** //(descendre de plusieurs lignes)// et **[Page Arrière]** //(remonter de plusieurs lignes)//. Pour passer d'un volet à l'autre, utilisez la touche de **[Tab]**. |
| | |
| | Tout en bas de l'écran figure la liste des fonctions que vous pouvez appeler, à l'aide d'une des touches de fonction. Le fonctionnement est assez simple. Par exemple, si vous pressez la touche **[F5]** //(notez le mot "Copy" à côté du 5 dans la ligne du bas)//, cela va réaliser la copie de l'élément sélectionné dans un volet vers le répertoire affiché dans l'autre volet. Vous pouvez ainsi copier un seul fichier, ou bien toute une arborescence. |
| | |
| | Essayez-le, vous ne tarderez pas à l'apprécier! |
| | |
| | ====== Quincaillerie ====== |
| | |
| | ===== Notions d'architecture matérielle ===== |
| | |
| | Linux demeure un système exigeant. Si vous devez "administrer" une machine Linux //(la configurer, installer le système...)//, nous pensons qu'il est indispensable de posséder quelques notions concernant les matériels des ordinateurs de type PC. Aussi aborderons-nous ici quelques aspects essentiels et volontairement simplifiés. |
| | |
| | ===== Les disquettes et les disques durs ===== |
| | |
| | Les disquettes et les disques durs entrent dans la catégorie des supports de mémoire de masse. Bien que cela ne soit pas tout à fait vrai pour une disquette, un disque dur est généralement capable de stocker beaucoup plus d'informations que la mémoire centrale d'un ordinateur. En général, le disque dur est le support sur lequel les systèmes d'exploitation, les logiciels divers que vous utilisez ainsi que vos fichiers personnels sont installés. |
| | |
| | La disquette était souvent utilisée comme outil de sauvegarde ou de transport de données si celles-ci n'étaient pas trop volumineuses. Dans le cas de Linux ou MS-DOS, il était également possible d'installer un système d'exploitation sur une disquette, encore que ses fonctionnalités soient grandement réduites. Habituellement le lecteur de disquettes est le premier endroit où l'ordinateur va chercher un système lorsqu'il démarre; c'était souvent la seule façon de réparer un système sur disque dur qui avait été endommagé d'une manière ou d'une autre. |
| | |
| | Physiquement, une disquette était un disque souple de plastique magnétisé comparable à une bande de cassette audio ou vidéo. Les informations étaient enregistrées sur ce support de façon analogue. Un disque dur se présente de la même façon, mais cette fois le disque est rigide, plus épais et se compose de plusieurs plateaux superposés. Voyez les photos de la //Figure 6// pour apprécier la façon dont un disque dur est construit. Le nombre de têtes de lecture, c'est-à-dire le nombre de faces utilisés sur les différents plateaux, est l'un des éléments de ce que l'on appelle la géométrie d'un disque dur. Pour une disquette, ce nombre valait 2 dans la grande majorité des cas //(un disque, donc deux faces, donc deux têtes)//. |
| | |
| | <WRAP centeralign>//**Figure 6: L'intérieur d'un disque dur.**//</WRAP> |
| | <WRAP center> |
| | <WRAP column 45%> |
| | |{{ Images_Cahier-101-01-007.png?400 }}| |
| | </WRAP> |
| | <WRAP column 45%> |
| | |{{ Images_Cahier-101-01-008.png?400 }}|</WRAP> |
| | </WRAP> |
| | <WRAP clear></WRAP> |
| | |
| | Un autre élément est le nombre de **pistes** ou de cylindres. Les pistes sont des anneaux concentriques subdivisant la face d'un plateau en autant de zones distinctes. Sauf situation très exceptionnelle, toutes les faces du disque présentent le même nombre de pistes. Lorsqu'il y a plusieurs plateaux //(dans le cas des disques durs)//, les pistes des différentes faces qui sont à l'aplomb les unes des autres forment un ensemble que l'on désigne alors sous le terme de **cylindre**. Une disquette usuelle comportait 80 cylindres, certains disques durs, plusieurs milliers. |
| | |
| | <WRAP column 45%> |
| | Le "découpage" du disque ne s'arrête pas là. Les pistes sont elle-mêmes subdivisées en **secteurs**. Le secteur est la plus petite unité discernable sur un disque. Le plus souvent, toutes les pistes ont le même nombre de secteurs, mais il arrive que les pistes extérieures en possèdent davantage que les pistes intérieures pour tirer parti de la surface plus grande. Ceci est toutefois assez rare. Un secteur contient 512 octets ou caractères de données. D'autres tailles sont possibles //(128, 256, 1024, 2048, 4096...)//. Une disquette normale contenait 18 secteurs par piste et un disque dur en contient au moins 63. |
| | |
| | La //Figure 7// vous propose un schéma de la structure qui vient d'être évoquée. Sur la vue de dessus, les zones d'un même ton de gris appartiennent à la même piste. Sur la vue par la tranche //(imaginez le disque dur coupé en son centre)//, les tons de gris représentent alors chacun un cylindre particulier. |
| | |
| | En termes de performances, le taux de transfert maximal pour une disquette avoisinait les 300 kilo-octets par seconde tandis que certains disques durs atteignent des taux tels que 80 méga-octets par seconde, voire davantage! Un paramètre important est le temps moyen d'accès à une information; pour un disque dur, il est de l'ordre de quelques millisecondes //(millième de seconde)// et pour la disquette... certains esprits chagrins ironisent en disant qu'il fallait changer d'échelle et compter plutôt en minutes... |
| | </WRAP> |
| | <WRAP column 45%> |
| | <WRAP centeralign>//**Figure 7: Structure d'un disque dur: vue de dessus et par la tranche.**//</WRAP> |
| | |{{ Images_Cahier-101-01-009.png?400 }}| |
| | </WRAP> |
| | <WRAP clear></WRAP> |
| | |
| | ===== Partition des disques durs ===== |
| | |
| | Il existe un mécanisme qui permet de subdiviser un disque dur en plusieurs parties distinctes: les partitions. Celles-ci permettent de séparer, par exemple, les éléments constitutifs du système des données des utilisateurs. Ainsi, en cas de problème dans le système, les erreurs ont moins de chance de s'étendre aux données - et réciproquement. Typiquement, sur un système Linux, les répertoires qui contiennent les données des utilisateurs sont sur une //(ou plusieurs)// partition distincte du reste du système; une surcharge de données ne risque donc pas d'endommager le système et une erreur dans celui-ci a peu de chance de corrompre les données. |
| | |
| | Le découpage d'un disque en partitions suit des règles un peu complexes, pour l'essentiel héritées de l'histoire. La première d'entre elles, est qu'une partition recouvre une suite continue de cylindres: les limites de partitions sont donc celles des cylindres et l'on dit qu'une partition s'étend du cylindre n au cylindre m. Une formule qui peut être utile donne la taille d'une telle partition, en méga-octets: <nowiki>((</nowiki>m - n + 1) * Nt * Ns) / 2048; où //Nt// est le nombre de têtes, et //Ns// le nombre de secteurs par piste, du disque. |
| | |
| | On distingue par ailleurs deux types de partitions: les partitions primaires et les partitions logiques. |
| | |
| | Pour des raisons historiques, datant de l'époque où les disques étaient de taille bien moins importante qu'aujourd'hui, il n'était possible de créer que quatre partitions primaires qui sont numérotées par Linux de 1 à 4. Cette limite vient du fait que la faible capacité des disques durs ne justifiait pas de prévoir un nombre plus élevé. |
| | |
| | Toutefois les capacités actuelles des disques rendent ce nombre insuffisant. C'est pourquoi fut développé la technique des partitions étendues et des partitions logiques. |
| | |
| | Une partition étendue est l'une des quatre partitions primaires //(généralement la dernière)//, destinée à être un réceptacle pour d'autres partitions en nombre théoriquement illimité. Ces partitions, contenues dans une partition étendue, sont appelées partitions logiques. Linux les numérote toujours à partir de __**5**__. |
| | |
| | Les partitions trouvent également leur utilité lorsque l'on veut faire cohabiter plusieurs systèmes. Il est possible, sur un même ordinateur, d'avoir côte à côte Windows-7, Windows-8.1, Linux... et même plusieurs fois le même système! Par exemple, un Linux d'utilisation normale et un autre pour effectuer des tests sur lequel un plantage est sans grande conséquence. |
| | |
| | La manipulation des partitions se fait à l'aide d'outils spécialisés. Linux possède un programme nommé ''fdisk''. Nous vous recommandons toutefois, si cela vous est possible, l'utilisation du programme [[http://gparted.sourceforge.net/download.php|GParted]] plus simple à manipuler et beaucoup plus puissant. |
| | |
| | Les //Figure 8// et //Figure 9// vous propose deux exemples pour illustrer tout cela. |
| | |
| | <WRAP centeralign>//**Figure 8: Exemple de partitions sur un disque dur (voir Tableau 3).**//</WRAP> |
| | |
| | {{ Images_Cahier-101-01-010.png?800 }} |
| | |
| | Dans cet exemple, les quatre possibilités de partition primaire ont été utilisées. L'une d'entre elles est utilisée en partition étendue //(la deuxième)//, pour contenir des partitions logiques //(la deuxième partition primaire contient quatre partitions logiques)//. |
| | |
| | L'exemple suivant est plus classique. |
| | |
| | <WRAP centeralign>//**Figure 9: Exemple de partitions sur un disque dur.**//</WRAP> |
| | |
| | {{ Images_Cahier-101-01-011.png?800 }} |
| | |
| | Seules deux possibilités de partition primaire sont utilisées, la première pour Windows-7, la deuxième pour faire une partition étendue qui contient en l'occurrence six partitions logiques. Cet exemple vous montre par ailleurs comment il est possible de répartir différents éléments d'un système Linux sur plusieurs partitions: notez comment les répertoires ''/home'', ''/root'' et ''/usr'' ne sont pas sur la même partition que la racine. |
| | |
| | ===== Structure logique d'un disque dur ===== |
| | |
| | Le début de cette section vous a exposé la structure physique d'un disque dur, divisé en cylindres, secteurs, etc. Puis nous avons évoqué le mécanisme des partitions. Mais où sont donc stockées les informations relatives aux partitions? Comment les systèmes reconnaissent-ils les partitions? Les réponses à ces questions sont l'objet de ce paragraphe. |
| | |
| | La structure logique d'un disque dur est la manière dont sont organisées les différentes informations fondamentales concernant la manière dont le disque dur doit être utilisé par les systèmes. |
| | |
| | Le premier secteur //(physique)// de chaque partition est un peu particulier: on l'appelle le **secteur d'amorce**(( **boot sector:** en anglais. Rappelez-vous du terme boot //(amorce ou démarrage)//, il revient fréquemment.)), car il contient généralement le code nécessaire au lancement du système contenu dans la partition. S'il ne s'agit que d'une partition de données, ce secteur contient quelques informations utiles concernant la taille de la partition, son type, etc. |
| | |
| | Encore plus particulier est le premier secteur physique du disque dur: ce secteur contient non seulement le code nécessaire au lancement du système actif sur votre système, mais en plus la fameuse **Table des Partitions**; cette table contient les paramètres des quatre partitions primaires du disque, c'est-à-dire les cylindres de début et de fin, le type, etc. Ce secteur si spécial, si fondamental pour le fonctionnement de la machine, est appelé le **Master Boot Record**(( **Master Boot Record**: à peu près //enregistrement principal pour le démarrage//, en français. On utilise plus volontiers le terme anglais ou l'abréviation MBR. )), MBR en abrégé. |
| | |
| | La //Table des Partitions// n'est toutefois pas suffisante en elle-même: elle ne peut contenir les informations des éventuelles partitions logiques contenue dans une ou plusieurs partitions étendues. Aussi, chaque partition logique contient une "mini" //Table des Partitions// pour réaliser en quelque sorte, un chaînage des partitions les unes au bout des autres. Le début de la chaîne, le premier maillon, se situe dans la //Table des Partitions// du MBR, où l'une des entrées est marquée comme partition étendue. |
| | |
| | Enfin, la structure logique de chaque partition dépend directement du système de fichiers qu'elle abrite. |
| | |
| | Le //Tableau 3// reprend l'Exemple de la //Figure 8//, en montrant de quelle façon les partitions s'enchaînent les unes derrières les autres. Les références ''/dev/sdax'' sont données à titre d'exemple, et représentent les partitions d'un disque SCSI sur un système Linux. |
| | |
| | {{Images_Cahier-101-03-005.png?25}} Les disques IDE utilisent la nomenclature **hd** et les disques SCSI la nomenclature **sd**. |
| | <WRAP centeralign>\\ **Tableau 3: Structure logique d'un disque dur SCSI.**</WRAP> |
| | {{ Images_Cahier-101-01-021.png?800 }} |
| | \\ |
| | |
| | Utilisation de la commande ''fdisk'' pour afficher les partitions d'un disque SCSI d'un système Linux. |
| | |
| | <file> |
| | [root@tchana ~]# fdisk /dev/sda |
| | |
| | WARNING: DOS-compatible mode is deprecated. It's strongly recommended to |
| | switch off the mode (command 'c') and change display units to |
| | sectors (command 'u'). |
| | |
| | Commande (m pour l'aide): |
| | </file> |
| | |
| | Affichage de l'aide. |
| | |
| | <file> |
| | Commande (m pour l'aide): m |
| | |
| | Commande d'action |
| | a bascule le fanion d'amorce |
| | b éditer l'étiquette BSD du disque |
| | c basculer le fanion de compatibilité DOS |
| | d supprimer la partition |
| | l lister les types de partitions connues |
| | m afficher ce menu |
| | n ajouter une nouvelle partition |
| | o créer une nouvelle table vide de partitions DOS |
| | p afficher la table de partitions |
| | q quitter sans enregistrer les changements |
| | s créer une nouvelle étiquette vide pour disque de type Sun |
| | t modifier l'id de système de fichiers d'une partition |
| | u modifier les unités d'affichage/saisie |
| | v vérifier la table de partitions |
| | w écrire la table sur le disque et quitter |
| | x fonctions avancées (pour experts seulement) |
| | |
| | Commande (m pour l'aide): |
| | </file> |
| | |
| | Affichage de la //Table des partitions// d'un disque SCSI d'un système Linux. |
| | |
| | <file> |
| | Commande (m pour l'aide):p |
| | |
| | Disque /dev/sdb: 4294 Mo, 4294967296 octets |
| | 255 têtes, 63 secteurs/piste, 522 cylindres |
| | Unités = cylindres de 16065 * 512 = 8225280 octets |
| | Sector size (logical/physical): 512 bytes / 512 bytes |
| | I/O size (minimum/optimal): 512 bytes / 512 bytes |
| | Identifiant de disque : 0xe474cc36 |
| | |
| | Périphérique Amorce Début Fin Blocs Id Système |
| | /dev/sda1 1 65 522081 7 HPFS/NTFS |
| | /dev/sda2 66 321 2056320 5 Etendue |
| | /dev/sda3 322 386 522112+ 7 HPFS/NTFS |
| | /dev/sda4 387 451 522112+ 83 Linux |
| | /dev/sda5 66 130 522081 7 HPFS/NTFS |
| | /dev/sda6 131 195 522081 7 HPFS/NTFS |
| | /dev/sda7 196 260 522081 82 Linux swap / Solaris |
| | /dev/sda8 261 321 489951 83 Linux |
| | |
| | Commande (m pour l'aide): |
| | </file> |
| | |
| | ===== Les mémoires ===== |
| | |
| | Le sujet de la mémoire dans un ordinateur est suffisamment vaste pour lui consacrer un ouvrage entier. Nous n'aborderons ici que des notions très générales afin de clarifier quelques termes courants. |
| | |
| | ==== La mémoire centrale ou RAM ==== |
| | |
| | La mémoire centrale ou **RAM**(( **RAM**: __R__andom __A__ccess __M__emory, mémoire à accès libre en lecture et écriture. )) de l'ordinateur est utilisée pour contenir le code exécutable et les données des programmes que vous utilisez, y compris le système lui-même. Sa caractéristique principale est que son contenu est irrémédiablement perdu lorsqu'on coupe l'alimentation électrique de l'ordinateur, d'où son nom courant de "mémoire vive". |
| | |
| | A l'heure actuelle, le temps d'accès moyen à une information contenue dans la mémoire centrale est de l'ordre de quelques nanosecondes (milliardième de seconde). Une taille usuelle pour la mémoire centrale est de 4 Go. Il est évident que plus cette taille est importante, plus le système peut l'utiliser pour stocker des informations auxquelles il accédera très rapidement par la suite. |
| | |
| | ==== La mémoire CMOS ==== |
| | |
| | Cette mémoire est utilisée pour conserver des paramètres généraux de la machine lorsque celle-ci est arrêtée, tels que la configuration du ou des disques durs, l'heure, la date, etc. Elle est entretenue par une pile branchée sur la carte mère et son contenu est perdu si on retire la pile ou si elle s'épuise. Mais inutile de paniquer, la durée de vie d'une telle pile est en général d'au moins quatre à cinq ans... |
| | |
| | ==== La mémoire vidéo ou VRAM ==== |
| | |
| | Cette mémoire est spécialisée pour l'affichage de l'écran. La quantité dont vous disposez détermine directement le nombre de couleurs et la finesse de graphisme que vous pouvez obtenir sur votre écran. Elle a généralement des temps d'accès très faibles, de l'ordre de quelques nanosecondes, sauf sur certains systèmes où elle n'est rien d'autre qu'une portion de la mémoire centrale réservée à cet usage //(ce que nous déconseillons pour des questions évidentes de performances générales)//. |
| | |
| | ==== La mémoire cache ==== |
| | |
| | Il serait plus juste de parler des mémoires cache. Ces mémoires, qui se trouvent un peu partout, sont utilisées comme intermédiaires entre des composants relativement lents de la machine et d'autres plus rapides. Une de ses utilisations est de stocker des informations fréquemment utilisées pour permettre des accès plus rapides; par exemple entre le disque dur //(lent, temps d'accès de l'ordre de millièmes de seconde) et la mémoire centrale (environ un million de fois plus rapide!)//. |
| | |
| | Un exemple particulièrement important pour la puissance générale d'un système est la mémoire cache du processeur: il s'agit d'une mémoire ultra-rapide, bien plus que la mémoire centrale. Elle est utilisée pour stocker des informations venant de cette dernière fréquemment utilisées, telles que des données ou des portions de code exécutable. |
| | |
| | ==== La mémoire virtuelle ==== |
| | |
| | Imaginez la situation suivante: vous travaillez sur une machine dotée de 4Go de mémoire centrale, dont 3,5Go sont déjà occupés par divers programmes. Vous souhaitez lancer un logiciel qui a besoin d'au moins 1Go de mémoire centrale pour fonctionner. Vous allez donc vous trouver en "déficit" de 500Mo de mémoire. |
| | |
| | Sur d'anciens systèmes tel que MS-DOS, cela se passe très simplement: le système refuse simplement de lancer le logiciel. Les systèmes modernes //(dont fait partie Linux)// sont plus subtils, et utilise le mécanisme de la mémoire virtuelle(( **virtuelle**: swap memory en anglais. )). L'idée est d'utiliser une partie du disque dur comme s'il s'agissait de mémoire centrale, dont la taille paraît ainsi augmentée. Ce mécanisme vous permet d'utiliser plus de mémoire que votre machine n'en dispose réellement. Si cela est fort utile, surtout pour les machines disposant de peu de mémoire, gardez toutefois à l'esprit que le temps d'accès à une information sur le disque dur se mesure en millième de seconde tandis qu'il se mesure en milliardième de seconde pour la mémoire... Quand le système commence à utiliser ce mécanisme //(on dit qu'il "swap")//, attendez-vous donc à des performances fortement dégradées. |
| | |
| | ===== Autres matériels et périphériques ===== |
| | |
| | Un système d'exploitation digne de ce nom doit permettre à son propriétaire d'utiliser tous ses périphériques sans exception... du moins en théorie. En effet, la pratique est nettement moins drôle, surtout pour ceux qui osent sortir des sentiers battus en faisant confiance à Linux. Et là, les choses se gâtent. |
| | |
| | - Il faut déjà oublier les "win-périphériques", en général des modems et des imprimantes, conçus pour n'être utilisés que dans un environnement déterminé. |
| | - Il faut également tirer un trait sur le fameux pilote //(driver)// qui n'est fourni, en général, que pour le même environnement précité. |
| | - Il faut faire confiance à la "communauté" Linux qui développe chaque jour de nouveaux pilotes pour faire fonctionner votre périphérique //(avant-)// dernier cri. |
| | Le système de fichiers de Linux en détail |
| | |
| | ===== Introduction ===== |
| | |
| | Nous détaillons ici quelques aspects importants du système de fichiers de Linux. Il n'est pas utile de parfaitement maîtriser toutes les notions abordées ici mais, au moins nous vous recommandons d'en avoir une connaissance générale. |
| | |
| | ===== Accès aux périphériques, au matériel ===== |
| | |
| | Comme nous l'avions évoqué au début de ce document, les systèmes Unix - et donc Linux - accèdent aux éléments matériels de la machine par l'intermédiaire de fichiers spéciaux. |
| | |
| | Sous Linux, ces fichiers sont tous regroupés dans le répertoire ''/dev'' //(comme device, périphérique en français)//. Le principe de fonctionnement de ces fichiers est un peu particulier et leurs noms sont //(plus ou moins)// normalisés. Un fichier spécial du répertoire ''/dev'' est caractérisé par deux nombres, les numéros **majeur** et **mineur**. |
| | |
| | ==== Disque IDE ==== |
| | |
| | Considérons l'affichage suivant: |
| | |
| | <file> |
| | [root@tchana ~]# ls -l /dev/hda |
| | |
| | brw-rw-- 1 root disk 3, 0 6 janv. 10:01 /dev/hda |
| | [root@tchana ~]# |
| | </file> |
| | |
| | <file> |
| | [root@tchana ~]# ls -l /dev/ttyS1 |
| | |
| | crw-r-r- 1 root root 4, 65 6 janv. 10:02 /dev/ttyS1 |
| | [root@tchana ~]# |
| | </file> |
| | |
| | Les numéros //majeurs// et //mineurs// apparaissent juste avant la date. Décrivons-les. |
| | |
| | Le numéro majeur correspond à un périphérique donné: par exemple, //03// correspond au premier port IDE sur la carte mère, et les disques associés sont désignés par des fichiers dont le nom commence par ''hda'' pour le disque maître, ''hdb'' pour le disque esclave. Ainsi, le fichier ''/dev/hda'' est un accès direct au premier disque dur, pris dans sa globalité, en tant que suite ininterrompue d'octets pratiquement non structurée. Inutile de préciser qu'il vaut mieux éviter d'écrire dans ce fichier! Le début est notamment la //Table des Partitions//, à manier avec délicatesse... Voir le paragraphe [[nethserver_101_cahier_01_linux#Partition des disques durs]] pour plus de détails concernant les partitions des disques. |
| | |
| | Le numéro mineur correspond à une subdivision du périphérique. Dans le cas du port IDE, les mineurs à partir de //1// numérotent les partitions du premier disque //(le disque maître)//, les mineurs à partir de //65// numérotent les partitions du second disque //(le disque esclave)//. Par exemple, ''/dev/hda5'' //(dont on note les caractéristiques par 03:05)// désigne la première partition logique du disque dur maître sur le premier port IDE, tandis que ''/dev/hdb2'' //(dont on note les caractéristiques par 03:66)// désigne la deuxième partition primaire du disque dur esclave sur le premier port IDE. |
| | |
| | ==== Disque SCSI ==== |
| | |
| | <file> |
| | [root@tchana ~]# ls -l /dev/sd* |
| | |
| | brw-rw---- 1 root disk 8, 0 Dec 17 12:05 /dev/sda |
| | brw-rw---- 1 root disk 8, 1 Dec 17 12:05 /dev/sda1 |
| | brw-rw---- 1 root disk 8, 2 Dec 17 12:05 /dev/sda2 |
| | [root@tchana ~]# |
| | </file> |
| | |
| | Dans cet exemple, nous avons quatre disques SCSI. Chaque disque a deux partitions. |
| | |
| | Le numéro majeur //8// correspond au port SCSI sur la carte mère, et les disques associés sont désignés par des fichiers dont le nom commence par ''sda'' pour le premier disque, ''sdb'' pour le deuxième disque, etc. Ainsi, le fichier ''/dev/sda'' est un accès direct au premier disque dur, pris dans sa globalité, en tant que suite ininterrompue d'octets pratiquement non structurée. |
| | |
| | ==== Disquette ==== |
| | |
| | Sauf situation assez exceptionnelle, vous n'aurez que très rarement à utiliser directement ces fichiers spéciaux. Un exemple d'une telle situation est lorsque le besoin de prendre une image d'une disquette se présente, par exemple pour la dupliquer. |
| | |
| | Le fichier spécial correspondant au premier lecteur de disquette est ''/dev/fd0'' //(02:00)//. Pour dupliquer une disquette en conservant très précisément sa structure //(notamment s'il s'agit d'une disquette de démarrage)//, la première étape consiste à prendre une image de la disquette: |
| | |
| | <file> |
| | [root@tchana ~]# cp /dev/fd0 disque.img |
| | |
| | [root@tchana ~]# |
| | </file> |
| | |
| | Cette commande //(notez l'utilisation de la commande usuelle cp)// va lire la disquette octet par octet //(ou plutôt secteur par secteur)//, sans s'occuper de sa structure et encore moins du système de fichier qu'elle contient //(qu'il soit de type Linux, MS-DOS, ou autre)//. Le résultat est placé dans le fichier ''disque.img'' dans le répertoire courant. Ce fichier est ce qu'on appelle une **image** de la disquette //(d'où son extension ''.img'')//. |
| | |
| | La seconde étape //(après avoir changé la disquette dans le lecteur!)// est exactement symétrique de la première: |
| | |
| | <file> |
| | [root@tchana ~]# cp disque.img /dev/fd0 |
| | |
| | [root@tchana ~]# |
| | </file> |
| | |
| | ... va écrire le fichier //image// sur la disquette dans le lecteur. Vous aurez alors une copie absolument exacte de la disquette originale, au bit près. |
| | |
| | Ceci peut évidemment se généraliser aux disques durs ou CD-ROMs. |
| | |
| | Mais attention! Si vous avez une partition désignée par exemple par ''/dev/hda7'', d'une taille de 900 Mo, la commande: |
| | |
| | <file> |
| | [root@tchana ~]# cp /dev/hda7 partition-hda7.img |
| | |
| | [root@tchana ~]# |
| | </file> |
| | |
| | ... va vous créer un fichier de 900 Mo dans le répertoire courant! Donc prenez garde à avoir l'espace nécessaire... |
| | |
| | ==== Character vs block ==== |
| | |
| | Enfin et pour finir, Linux effectue une distinction entre les périphériques d'entrée-sortie par caractères //(character devices)// et les périphériques d'entrée-sortie par blocs //(blockdevices)//. La différence apparaît dans les exemples plus haut sur le premier caractère de la ligne résultant du ''ls'': 'c' pour caractères, 'b' pour blocs. Les périphériques d'entrée-sortie par caractères ont comme caractéristique de transmettre et recevoir les informations octet par octet. C'est le cas des ports séries ou parallèles, des modems, etc. Par contre, les périphériques d'entrée-sortie par blocs transmettent ou reçoivent les informations sous forme de paquets d'octets, d'une taille fixe: c'est le cas des supports de mémoire de masse //(disquettes, disques durs...)//. Ainsi, un même couple majeur/mineur peut désigner deux périphériques différents, selon que l'on considère un périphérique par caractères ou un périphérique par blocs. |
| | |
| | A titre indicatif, voici quelques fichiers avec les périphériques associés dans le //Tableau 4//. La colonne B/C indique s'il s'agit d'un périphérique de caractères ou un périphérique par blocks. |
| | |
| | ^ <WRAP centeralign>\\ Tableau 4: Quelques fichiers spéciaux et les périphériques associés.</WRAP> ^^^^^ |
| | |//**Fichier**//|//**Majeur**//|//**Mineur**//|//**B/C**//|//**Périphérique**//| |
| | |/dev/mem|1|1|c|accès direct à la mémoire centrale| |
| | | /dev/fd0|2|0|b|premier lecteur de disquettes| |
| | | /dev/hda|3|0|b|disque maître sur le premier port IDE| |
| | | /dev/hda2|3|2|b|seconde partition primaire sur ce disque| |
| | | /dev/hdb|3|64|b|disque esclave sur le premier port IDE| |
| | | /dev/hdb5|3|69|b|première partition logique sur ce disque| |
| | | /dev/tty1|4|1|c|première console virtuelle| |
| | | /dev/lp0|6|2|c|troisième port parallèle (imprimante)| |
| | | /dev/sda|8|0|b|premier disque dur SCSI| |
| | | /dev/sda2|8|2|b|deuxième partition sur ce disque| |
| | | /dev/sdb|8|16|b|deuxième disque dur SCSI| |
| | | /dev/sdb1|8|17|b|deuxième partition sur ce disque| |
| | | /dev/psaux|10|1|c|port PS/2 (souris)| |
| | | /dev/kdb|11|0|c|accès direct au clavier| |
| | | /dev/scd0|11|0|b|premier CD-ROM SCSI| |
| | | /dev/sequencer|14|1|c|séquenceur de la carte son| |
| | | /dev/hdc|22|0|b|disque maître sur le second port IDE| |
| | | /dev/video0|81|0|c|Acquisition vidéo| |
| | |
| | et ainsi de suite... la liste complète occuperait plusieurs pages! |
| | |
| | {{Images_Cahier-101-03-005.png?25}} Pour la liste complète des numéros majeur et mineur, voir: [[http://www.linux-france.org/article/kafkafr/node19.html|http://www.linux-france.org/article/kafkafr/node19.html]] |
| | |
| | ==== L'arborescence unique et les systèmes de fichiers ==== |
| | |
| | === Notion de montage === |
| | |
| | Affirmons-le encore une fois, sous le système Unix, et donc sous Linux, tout est fichier. Notamment, toutes les informations auxquelles accède le système sont incluses dans une arborescence unique; qu'elles soient sur le même support physique que le système ou sur des supports différents //(autres partitions, disques, CD-ROMs, etc.)//. |
| | |
| | D'où la notion de système de fichiers: un système de fichier, en gros, désigne une partition sur un support physique quelconque. Dans le cas d'une disquette ou d'un CD-ROM, désigne en général tout le disque. Cette notion peut être rapprochée de celle évoquée en début de document, au paragraphe [[nethserver_101_cahier_01_linux#Système de fichiers]]; une partition donnée applique en général un seul système de fichier //(au sens du paragraphe Système de fichiers, donc FAT16, NTFS, EXT3FS, ...)//, donc la confusion des deux notions est possible - et très souvent effectuée. |
| | |
| | Lorsque l'on désire accéder aux informations d'un support donné //(par exemple, un CD-ROM)//, il est nécessaire, en quelque sorte, "d'accrocher" le système de fichier qu'il contient à un point de l'arborescence, c'est-à-dire un répertoire //(de préférence prévu à cet effet)//. Cette opération s'appelle le montage(( **montage**: action de monter: to mount, en anglais. )) du support en question. Une fois cette opération effectuée, les fichiers et répertoires du support apparaissent comme se trouvant dans le répertoire sur lequel le support a été monté. |
| | |
| | Par exemple, vous possédez un CD-ROM contenant à sa racine le fichier ''liste.txt'', ainsi que le répertoire ''Images''. Si vous montez le CD-ROM sous le répertoire ''/mnt'', l'accès au fichier se fera par ''/mnt/liste.txt'', l'accès au répertoire par ''/mnt/Images'', l'accès aux fichiers du répertoire ''Images'' par ''/mnt/Images/nom_de_fichier'', et ainsi de suite. |
| | |
| | Notez bien que si le répertoire ''/mnt'' contenait des fichiers avant le montage, ceux-ci deviennent absolument inaccessibles une fois le montage effectué. Prenons un exemple; supposons un répertoire ''/mnt'', qui contient des fichiers: |
| | |
| | <file> |
| | [root@tchana ~]# ls /mnt |
| | |
| | cdrom dos1 dos2 eit floppy iomega nfs |
| | [root@tchana ~]# |
| | </file> |
| | |
| | Montons un CD-ROM sur ce répertoire //(la commande utilisée est mount, elle sera détaillée par la suite)//, et examinons le contenu du répertoire: |
| | |
| | <file> |
| | [root@tchana ~]# mount /dev/hdd /mnt |
| | |
| | mount: block device /dev/hdd is write-protected, mounting read-only |
| | [root@tchana ~]# |
| | </file> |
| | |
| | <file> |
| | [root@tchana ~]# ls /mnt |
| | |
| | 3DFx GTK1.2 Koffice Sound |
| | Alien Gnome1.0_Sources Lisezmoi.txt Themes |
| | ContribSuite Java1.2_pre1 Noyaux docs |
| | Dev_Graphique Jeux Revue kde |
| | EnVrac KDE1.1 SciTech |
| | [root@tchana ~]# |
| | </file> |
| | |
| | On constate que les fichiers qui se trouvaient dans ''/mnt'' ont comme "disparus". |
| | |
| | Mais que faire lorsque l'on souhaite changer le CD-ROM? Il existe l'opération inverse du montage, il s'agit - vous l'aurez deviné du démontage(( **démontage**: démonter: to unmount, en anglais )) des systèmes de fichiers //(avec ''umount'', détaillée plus loin)//. Si le point de montage contenait des fichiers avant le montage, ceux-ci redeviennent visibles: |
| | |
| | <file> |
| | [root@tchana ~]# umount /mnt |
| | |
| | [root@tchana ~]# |
| | </file> |
| | |
| | <file> |
| | [root@tchana ~]# ls /mnt |
| | |
| | cdrom dos1 dos2 eit floppy iomega nfs |
| | [root@tchana ~]# |
| | </file> |
| | |
| | Prenons un exemple réel. Il est assez commun, sur un système Linux, de répartir les différents éléments du système sur différents systèmes de fichiers, pas nécessairement sur le même disque. À la //Figure 10//, les éléments sur un même système de fichiers sont entourés de pointillés, le tout constituant un système Linux complet //(l'arborescence est ici simplifiée)//. |
| | |
| | <WRAP centeralign>//**Figure 10: Différents systèmes de fichiers pour un système Linux.**//</WRAP> |
| | |
| | {{ Images_Cahier-101-01-012.png?500 }} |
| | |
| | Pour finir, disons simplement qu'il est usuel de réserver plusieurs sous-répertoires dans le répertoire ''/mnt'' pour les montages temporaires, tels que disquettes et CD-ROMs, par exemple, ''/mnt/cdrom'', ''/mnt/floppy'', etc. |
| | |
| | Deux commandes sont dédiées aux opérations de montage et démontage, les commandes ''mount'' et ''umount'', exposées au paragraphe [[nethserver_101_cahier_01_linux#Montage et démontage de systèmes de fichiers: mount et umount]]. |
| | |
| | ===== Mécanisme des liens ===== |
| | |
| | Les principes de fonctionnement du système de fichiers de Linux comporte la notion de liens. Pour être simple, un lien(( **liens**: link en anglais. )) est un point d'accès à un fichier. Ce point d'accès prenant la forme d'un nom dans un répertoire - la notion de fichier ne représente qu'une suite de caractères quelque part sur un disque. Quelle différence alors, entre le nom de fichier tel qu'exposé au début de ce document et le lien? En fait, le nom de fichier est un élément du lien qui comporte de nombreuses informations concernant le fichier //(droits d'accès, taille, date de création...)//. De plus, nous avions évoqué une sorte d'équivalence entre le nom de fichier et le fichier lui-même. Mais un même fichier peut être référencé par plusieurs liens de noms différents s'ils sont dans le même répertoire, éventuellement de mêmes noms s'ils sont dans des répertoires différents. |
| | |
| | On distingue deux types de liens: les liens **physiques** et les liens **symboliques**(( **symboliques**: respectivement, hard links et symbolic links en anglais. )). |
| | |
| | Un lien physique est un accès direct à la suite de caractères sur disque qu'est le fichier. Accéder au lien, c'est accéder directement au fichier. En pratique, lorsque vous effacez un fichier avec rm, vous indiquez un nom de fichier, donc un lien. Mais l'espace occupé par le fichier n'est effectivement libéré que lorsque le dernier lien physique qui y fait référence est effacé: rm ne supprime donc pas le fichier, seulement un lien qui lui est attaché. Ceci est une façon de protéger des fichiers contre l'effacement, mais rend l'utilisation des liens physiques délicates: il est facile d'engendrer un véritable capharnaüm dans l'arborescence... |
| | |
| | Un lien symbolique, à contrario, est un accès indirect au fichier; on peut plutôt le voir comme une référence à un autre lien. Comme un lien secondaire sur le fichier correspondant. La grosse différence avec le lien physique est qu'il est possible d'effacer le fichier //(c'est-à-dire effacer tous ses liens physiques)// sans toucher aux liens symboliques //(qui deviennent alors en quelque sorte orphelins; on parle de liens brisés)//. D'un maniement plus souple que les liens physiques, les liens symboliques peuvent également amener à une forêt inextricable de références, n'en abusez donc pas. |
| | |
| | Une commande est dédiée à la manipulation des liens, la commande ln, présentée au paragraphe [[nethserver_101_cahier_01_linux#Manipulation des liens: ln]]. |
| | |
| | ===== Utilisateurs: droits et devoirs ===== |
| | |
| | Linux est un système multi-utilisateur. C'est-à-dire que tout est prévu dans le système pour que plusieurs personnes puissent l'utiliser, même simultanément //(dans le cas de configurations en réseau)//, sans se gêner les uns les autres. |
| | |
| | Chaque utilisateur est identifié par un nom, et doit fournir un mot de passe(( **mot de passe**: password en anglais. )) pour pouvoir utiliser le système. La procédure au cours de laquelle un utilisateur donne son nom et son mot de passe est appelée "procédure de login", ou simplement "login". Ce mot de passe est strictement personnel: théoriquement, vous ne devez communiquer le vôtre à personne, encore que cela ne prête pas beaucoup à conséquence sur une machine individuelle //(sauf si vous possédez des fichiers confidentiels...)//. |
| | |
| | De même, chaque utilisateur se voit attribué une certaine zone dans l'arborescence des répertoires //(typiquement, un sous-répertoire dont le nom est celui de l'utilisateur dans le répertoire /home)//, que l'on appelle parfois le "répertoire personnel(( **répertoire personnel**: home directory en anglais. ))"de l'utilisateur. L'utilisateur possède un pouvoir quasiment absolu de création, modification et destruction sur les fichiers de son répertoire personnel //(fichiers dont il est le propriétaire)//, mais normalement il ne peut pas intervenir sur les répertoires des autres utilisateurs et encore moins sur les éléments constitutifs du système. Ceci confère à Linux un haut degré de sécurité vis-à-vis des diverses manipulations et autres fausses manoeuvres de ceux qui l'utilisent. |
| | |
| | Afin de faciliter le travail coopératif, les utilisateurs peuvent êtres regroupés par **groupes**. Il est ainsi possible d'autoriser tout un groupe à accéder à certains fichiers, mais pas les autres utilisateurs. |
| | |
| | ==== Le super-utilisateur ==== |
| | |
| | Comme indiqué plus haut, normalement les utilisateurs ne peuvent accéder aux éléments constitutifs du système. Comment alors, accéder à ceux-ci quand le besoin s'en fait sentir, comme lors de l'installation d'un nouveau logiciel? |
| | |
| | Pour les opérations nécessitant une modification particulière du système, il existe un utilisateur particulier, privilégié, le super-utilisateur(( **super-utilisateur**: super-user en anglais. )), dont le nom est **root**. En fait, l'utilisateur root possède un pouvoir total sur l'intégralité du système, y compris celui de le détruire en quelques secondes. Il peut consulter, modifier et détruire n'importe quel fichier du système et on peut estimer qu'en pratique, root est implicitement propriétaire de tous les fichiers du système. |
| | |
| | Si vous êtes seul à utiliser Linux sur votre machine personnelle, l'utilisateur root, c'est vous. Donc lorsque vous utilisez votre machine en tant que root, il convient de prendre un luxe de précautions et de bien savoir ce que vous faites; la précipitation est le chemin le plus sûr vers le massacre de votre système et la perte de vos données. C'est pourquoi il est vivement recommandé de créer au moins un autre utilisateur pour l'utilisation quotidienne du système. Une erreur de manipulation n'aura alors que des conséquences limitées sur l'intégrité du système. |
| | |
| | ==== Droits des fichiers et des répertoires ==== |
| | |
| | Pour réaliser la protection des fichiers évoquée plus haut, il existe un mécanisme de droits et de propriété attribués à chacun des fichiers du système. Tout fichier est la propriété d'un utilisateur et les droits s'articulent autour de cette notion. |
| | |
| | ==== Droits généraux: lecture, écriture, exécution ==== |
| | |
| | Linux //(comme Unix)// reconnaît trois droits fondamentaux. |
| | |
| | - le droit de lecture, symbolisé par la lettre ''r'' //(pour read)//, indique si l'on est autorisé à consulter le fichier, c'est-à-dire, par exemple, à afficher son contenu par une commande telle que ''more''. |
| | - le droit de écriture, symbolisé par la lettre ''w'' //(pour write)//, indique si l'on est autorisé à modifier le contenu du fichier, par exemple à l'aide d'un programme tel que ''vi''. |
| | - le droit de exécution, symbolisé par la lettre ''x'' //(pour execute)//, indique si l'on peut exécuter le fichier comme s'il s'agissait d'une commande. Ceci n'a évidemment de sens que pour les fichiers contenant des instructions compréhensibles par le système comme c'est le cas de fichiers tels que: ''/bin/more'', ''/sbin/fdisk''... |
| | Les droits individuels d'un fichier peuvent être modifiés à l'aide de la commande ''chmod'', exposée au paragraphe [[nethserver_101_cahier_01_linux#Modifier les droits sur un fichier ou un répertoire: chmod]]. |
| | |
| | ==== Regroupement des droits ==== |
| | |
| | Les droits fondamentaux qui viennent d'être exposés sont, pour chaque fichier, présents dans trois groupes de droits distincts. |
| | |
| | - le premier groupe, symbolisé par la lettre ''u'' //(pour user)//, précise les droits pour le propriétaire du fichier. |
| | - le deuxième groupe, symbolisé par la lettre ''g'' //(pour group)//, précise les droits pour les utilisateurs du groupe auquel appartient le propriétaire du fichier. |
| | - le troisième groupe, symbolisé par la lettre ''o'' //(pour other)//, précise les droits pour, disons, le reste du monde, c'est-à-dire n'importe quel utilisateur //(autre que le propriétaire du fichier et les utilisateurs de son groupe)//. |
| | Par exemple, la commande more (voir le paragraphe [[nethserver_101_cahier_01_linux#Affichage de fichiers (texte)]]), normalement accessible à tout le monde, possède le droit en exécution du groupe other activé //(de même que les droits en exécution des deux autres groupes)//. Par contre, la commande ''dd'' //(voir le paragraphe [[nethserver_101_cahier_01_linux#Entrées/sorties directes de données: dd]])// ne devrait avoir que le droit en exécution du propriétaire //(en occurrence, root)// d'activé. |
| | |
| | Le propriétaire d'un fichier peut être modifié avec la commande ''chown''. |
| | |
| | ==== Cas particulier des répertoires ==== |
| | |
| | Lorsque le fichier considéré est un répertoire, les droits prennent une signification un peu différente. |
| | |
| | - le droit en lecture indique que l'on peut obtenir la liste des fichiers du répertoire, par la commande ''ls'' par exemple. |
| | - le droit en écriture indique que l'on peut créer ou supprimer des fichiers du répertoire //(la modification ou la consultation de ceux-ci dépend des droits de chaque fichier)//. |
| | - le droit en exécution indique si l'on peut "transiter" par le répertoire, c'est-à-dire le faire figurer dans une succession de répertoires dans un chemin, ou bien en faire le répertoire courant. Ceci est totalement indépendant des deux droits précédents. |
| | |
| | ===== Fichiers impliqués dans la gestion des utilisateurs ===== |
| | |
| | ==== Le fichier des utilisateurs et de leur mot de passe: /etc/passwd ==== |
| | |
| | Ce fichier contient la liste des utilisateurs qui peuvent utiliser le système. Attention! Ne le supprimez pas. Si vous le supprimez, il vous sera impossible de vous connecter au système, même en tant que root. |
| | |
| | ====== Les variables d'environnement ====== |
| | |
| | ===== Introduction ===== |
| | |
| | Il arrive parfois que certaines informations doivent être mise à disposition d'un grand nombre de programmes. Par exemple, nous avons vu que lorsque vous exécutez une commande //(telle qu'un simple ''ls'')//, c'est en réalité un programme qui est exécuté. Or ce programme est contenu dans un fichier qui doit être lu pour que le système puisse exécuter le programme. Mais comment le système fait-il pour trouver le fichier en question? L'information indiquant à quels endroits chercher les fichiers contenant les programmes des diverses commandes doit donc être aisément accessible et, comme certaines commandes en appellent d'autres, cette information doit également être lisible par tout le monde. |
| | |
| | Ce genre d'information largement diffusée dans le système est contenu dans ce que l'on appelle des **variables d'environnement**. Une variable est une zone de la mémoire, identifiée par une étiquette //(un nom)// et contenant quelque chose //(un nombre, un mot...)// Ces variables sont fixées, certaines au démarrage du système et d'autres lors de la connexion d'un utilisateur. Examinons l'une d'entre elle. |
| | |
| | ===== PATH ===== |
| | |
| | Exécutez la commande suivante: |
| | |
| | <file> |
| | [root@tchana ~]# echo $PATH |
| | |
| | /sbin/e-smith:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/opt/puppetlabs/bin:/root/bin |
| | [root@tchana ~]# |
| | </file> |
| | |
| | La commande echo permet d'afficher quelque chose. Dans la commande précédente, nous lui demandons d'afficher le contenu d'une variable dont le nom est **PATH**. Notez l'utilisation du symbole dollar ''$'' devant le nom de la variable, nécessaire lorsque l'on souhaite accéder au contenu de la variable. |
| | |
| | C'est manifestement là une suite de répertoires, donnés par leur chemin absolu et séparés par le caractère deux-points '':''. Nous avons là précisément la réponse au problème posé au début de ce paragraphe. La variable d'environnement PATH contient une liste de répertoires dans lesquels chercher les fichiers contenant les programmes des commandes que l'on souhaite exécuter. |
| | |
| | Supposons maintenant que vous souhaitiez modifier cette variable pour lui rajouter le répertoire ''/toto''. Si vous utilisez le shell Bash, la commande à utiliser est: |
| | |
| | <file> |
| | [root@tchana ~]# export PATH="$PATH:/toto" |
| | |
| | [root@tchana ~]# |
| | </file> |
| | |
| | Notez les deux modes d'emploi du nom de la variable. D'abord sans le dollar à gauche du signe égal, parce que l'on fixe sa valeur puis, avec le dollar ''$'', parce que l'on lit sa valeur. Vérifions ce que nous venons de faire. |
| | |
| | <file> |
| | [root@tchana ~]# echo $PATH |
| | |
| | /sbin/e-smith:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/opt/puppetlabs/bin:/root/bin:/toto |
| | [root@tchana ~]# |
| | </file> |
| | |
| | Ce qui est bien le résultat escompté. |
| | |
| | Si par contre vous utilisez le C-shell, la commande est: |
| | |
| | <file> |
| | setenv PATH "${PATH}:/toto" |
| | </file> |
| | |
| | Le résultat est le même, la variable PATH est modifiée. |
| | |
| | Il existe un grand nombre de variables d'environnement, chacune destinée à un usage particulier. Chaque shell actif possède son propre ensemble de variables d'environnement. Si deux utilisateurs sont connectés simultanément sur la même machine, on a deux shells actifs. Chacun des shells possède ses propres variables d'environnement qui ne sont pas forcément les mêmes. Mieux, une variable donnée peut avoir deux valeurs différentes selon l'utilisateur. |
| | |
| | Pour obtenir l'ensemble des variables d'environnement définies lorsque vous êtes connectés avec leurs valeurs, utilisez la commande ''env''. |
| | |
| | <file> |
| | [root@tchana ~]# env |
| | |
| | MANPATH=/opt/remi/php72/root/usr/share/man: |
| | XDG_SESSION_ID=1 |
| | HOSTNAME=tchana.micronator-dev.org |
| | TERM=xterm |
| | SHELL=/bin/bash |
| | HISTSIZE=1000 |
| | SSH_CLIENT=10.10.10.81 64484 2222 |
| | X_SCLS=php72 |
| | SSH_TTY=/dev/pts/0 |
| | USER=root |
| | LS_COLORS=rs=0:di=01;34:ln=01;36:mh=00:pi=40;33:so=01;35:do=01;35:bd=40;33;01:cd=40;33;01:or=40;31;01:mi=01;05;37;41:su=37;41:sg=30;43:ca=30;41:tw=30;42:ow=34;42:st=37;44:ex=01;32:*.tar=01;31:*.tgz=01;31:*.arc=01;31:*.arj=01;31:*.taz=01;31:*.lha=01;31:*.lz4=01;31:*.lzh=01;31:*.lzma=01;31:*.tlz=01;31:*.txz=01;31:*.tzo=01;31:*.t7z=01;31:*.zip=01;31:*.z=01;31:*.Z=01;31:*.dz=01;31:*.gz=01;31:*.lrz=01;31:*.lz=01;31:*.lzo=01;31:*.xz=01;31:*.bz2=01;31:*.bz=01;31:*.tbz=01;31:*.tbz2=01;31:*.tz=01;31:*.deb=01;31:*.rpm=01;31:*.jar=01;31:*.war=01;31:*.ear=01;31:*.sar=01;31:*.rar=01;31:*.alz=01;31:*.ace=01;31:*.zoo=01;31:*.cpio=01;31:*.7z=01;31:*.rz=01;31:*.cab=01;31:*.jpg=01;35:*.jpeg=01;35:*.gif=01;35:*.bmp=01;35:*.pbm=01;35:*.pgm=01;35:*.ppm=01;35:*.tga=01;35:*.xbm=01;35:*.xpm=01;35:*.tif=01;35:*.tiff=01;35:*.png=01;35:*.svg=01;35:*.svgz=01;35:*.mng=01;35:*.pcx=01;35:*.mov=01;35:*.mpg=01;35:*.mpeg=01;35:*.m2v=01;35:*.mkv=01;35:*.webm=01;35:*.ogm=01;35:*.mp4=01;35:*.m4v=01;35:*.mp4v=01;35:*.vob=01;35:*.qt=01;35:*.nuv=01;35:*.wmv=01;35:*.asf=01;35:*.rm=01;35:*.rmvb=01;35:*.flc=01;35:*.avi=01;35:*.fli=01;35:*.flv=01;35:*.gl=01;35:*.dl=01;35:*.xcf=01;35:*.xwd=01;35:*.yuv=01;35:*.cgm=01;35:*.emf=01;35:*.axv=01;35:*.anx=01;35:*.ogv=01;35:*.ogx=01;35:*.aac=01;36:*.au=01;36:*.flac=01;36:*.mid=01;36:*.midi=01;36:*.mka=01;36:*.mp3=01;36:*.mpc=01;36:*.ogg=01;36:*.ra=01;36:*.wav=01;36:*.axa=01;36:*.oga=01;36: |
