This file is indexed.

/usr/share/doc/HOWTO/fr-html/Unix-and-Internet-Fundamentals-HOWTO.html is in doc-linux-fr-html 2013.01-3.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
<head>
<meta name="generator" content=
"HTML Tidy for Linux (vers 25 March 2009), see www.w3.org">
<meta name="GENERATOR" content="LinuxDoc-Tools 0.9.71">
<title>The Unix and Internet Fundamentals HOWTO</title>
</head>
<body>
<h1>The Unix and Internet Fundamentals HOWTO</h1>
<h2>by Eric S. Raymond</h2>
v1.1, 3 D&eacute;cembre 1998
<hr>
<em>Ce document d&eacute;crit les principes fondamentaux des
ordinateurs de type PC, des syst&egrave;mes d'exploitation de type
UNIX et d'Internet dans un langage non technique. (Traduction
fran&ccedil;aise Philippe Malinge <a href=
"mailto:pmal@easynet.fr">pmal@easynet.fr</a>)</em>
<hr>
<h2><a name="s1">1. Introduction</a></h2>
<h2><a name="ss1.1">1.1 Sujet de ce document</a></h2>
<p>Ce document est con&ccedil;u pour aider les utilisateurs de
Linux et d'Internet qui d&eacute;sirent apprendre en faisant. Bien
que ce soit un bon moyen d'acqu&eacute;rir des comp&eacute;tences,
quelquefois cela laisse de singuli&egrave;res lacunes dans la
connaissance des bases --&nbsp;lacunes qui peuvent rendre difficile
la r&eacute;flexion cr&eacute;ative ou perturber fortement, par
manque d'un mod&egrave;le mental clair sur ce qu'il devrait se
passer.</p>
<p>J'essaierai de d&eacute;crire clairement, dans un langage
simple, comment tout marche. La pr&eacute;sentation sera
adapt&eacute;e aux personnes qui utilisent Unix ou Linux sur du
mat&eacute;riel de type PC. Cependant, je ferai ici couramment
r&eacute;f&eacute;rence &agrave; 'Unix'&nbsp;: ce que je
d&eacute;crirai se retrouvera sur toutes les plates-formes et sur
toutes les variantes d'Unix.</p>
<p>Je suppose que vous utilisez un PC avec un processeur de type
Intel. Les d&eacute;tails diff&egrave;rent quelque peu si vous
utilisez un processeur Alpha ou PowerPC ou une autre machine Unix,
mais les concepts de base restent les m&ecirc;mes.</p>
<p>Je ne voudrais pas r&eacute;p&eacute;ter les choses, alors vous
allez devoir faire attention, mais cela veut dire que vous
retiendrez chaque mot que vous lirez. C'est une bonne id&eacute;e
que de tout parcourir rapidement la premi&egrave;re fois&nbsp;;
vous devrez y revenir et relire un certain nombre de fois afin de
dig&eacute;rer ce que vous avez appris.</p>
<p>C'est un document en permanente &eacute;volution. Je
pr&eacute;vois d'ajouter des chapitres en r&eacute;ponse aux
feedbacks, ainsi vous pourrez p&eacute;riodiquement le passer en
revue.</p>
<h2><a name="ss1.2">1.2 Ressources rattach&eacute;es</a></h2>
<p>Si vous lisez dans l'espoir d'apprendre comment 'hacker', vous
devrez lire <a href=
"http://www.tuxedo.org/~esr/faqs/hacker-howto.html">How To Become A
Hacker FAQ</a>. Il y a beaucoup de liens vers d'autres ressources
utiles.</p>
<h2><a name="ss1.3">1.3 Nouvelles versions de ce document</a></h2>
<p>Les nouvelles versions de 'Unix and Internet Fundamentals HOWTO'
seront post&eacute;es p&eacute;riodiquement dans <a href=
"news:comp.os.linux.help">comp.os.linux.help</a> et <a href=
"news:comp.os.linux.announce">news:comp.os.linux.announce</a> et
<a href="news:answers">news.answers</a>. Elles pourront &ecirc;tre
t&eacute;l&eacute;charg&eacute;es &agrave; partir de divers sites
Linux WWW ou FTP, y compris la page d'accueil du LDP.</p>
<p>Vous pouvez acc&eacute;der &agrave; la derni&egrave;re version
(en anglais) de ce document sur le World Wide Web via l'URL
<a href="http://sunsite.unc.edu/LDP/HOWTO/Unix-Internet-Fundamentals-HOWTO.html">
http://sunsite.unc.edu/LDP/HOWTO/Unix-Internet-Fundamentals-HOWTO.html</a>.</p>
<h2><a name="ss1.4">1.4 R&eacute;actions et corrections</a></h2>
<p>Si vous avez des questions ou des commentaires &agrave; propos
de ce document, vous pouvez envoyer vos courriers
&eacute;lectroniques &agrave; Eric S. Raymond, &agrave; <a href=
"mailto:esr@thyrsus.com">esr@thyrsus.com</a>. Toutes suggestions ou
critiques seront les bienvenues. Seront sp&eacute;cialement
appr&eacute;ci&eacute;s les liens hypertexte vers des explications
plus d&eacute;taill&eacute;es ou vers des concepts propres. Si vous
trouvez des erreurs dans ce document, faites-le moi savoir afin que
je puisse les corriger dans la nouvelle version. Merci.</p>
<h2><a name="s2">2. Anatomie de base de votre ordinateur</a></h2>
<p>Votre ordinateur poss&egrave;de un processeur &agrave;
l'int&eacute;rieur duquel se font r&eacute;ellement les calculs. Il
poss&egrave;de une m&eacute;moire interne (ce que les gens
DOS/Windows d&eacute;signent par ``RAM'' et que les gens UNIX
d&eacute;signent souvent par ``core''). Le processeur et la
m&eacute;moire r&eacute;sident sur la <em>carte m&egrave;re</em>
qui est le coeur de votre ordinateur.</p>
<p>Votre ordinateur poss&egrave;de un &eacute;cran et un clavier.
Il a un (ou des) disque(s) dur(s) et un lecteur de disquettes.
L'&eacute;cran et vos disques ont des <em>cartes
contr&ocirc;leur</em> que l'on connecte sur la carte m&egrave;re et
qui aident l'ordinateur &agrave; piloter ces
p&eacute;riph&eacute;riques externes. Votre clavier est trop simple
pour n&eacute;cessiter une carte s&eacute;par&eacute;e&nbsp;; le
contr&ocirc;leur est int&eacute;gr&eacute; dans le ch&acirc;ssis du
clavier.)</p>
<p>Nous d&eacute;crirons plus tard en d&eacute;tails comment
fonctionnent ces p&eacute;riph&eacute;riques. Pour l'instant,
quelques notions de base afin de garder &agrave; l'esprit comment
ils fonctionnent ensemble&nbsp;:</p>
<p>Tous les &eacute;l&eacute;ments internes de votre ordinateur
sont connect&eacute;s par un <em>bus</em>. Physiquement, le bus est
ce sur quoi vous connectez vos cartes contr&ocirc;leur (carte
vid&eacute;o, contr&ocirc;leur disque, carte son si vous en avez
une). Le bus est l'autoroute emprunt&eacute;e par les
donn&eacute;es entre votre processeur, votre &eacute;cran, votre
disque et le reste.</p>
<p>Le processeur, qui fait tout marcher, ne peut r&eacute;ellement
voir tous les &eacute;l&eacute;ments directement&nbsp;; il doit
communiquer avec eux via le bus, le seul sous-syst&egrave;me qui
soit effectivement tr&egrave;s rapide, qui acc&egrave;de
directement &agrave; la m&eacute;moire (le core). Afin que les
programmes puissent s'ex&eacute;cuter, ils doivent &ecirc;tre en
m&eacute;moire <em>core</em>.</p>
<p>Lorsque votre ordinateur lit un programme ou une donn&eacute;e
sur le disque, il se passe r&eacute;ellement les choses
suivantes&nbsp;: le processeur utilise le bus pour envoyer une
requ&ecirc;te de lecture du disque &agrave; votre contr&ocirc;leur
de disque. Quelques instants apr&egrave;s, le contr&ocirc;leur de
disque utilise le bus pour signaler &agrave; l'ordinateur qu'il a
lu la donn&eacute;e et qu'il l'a mise &agrave; un certain endroit
de la m&eacute;moire. Le processeur peut utiliser le bus pour aller
chercher ce qu'il y a &agrave; cet endroit de la
m&eacute;moire.</p>
<p>Votre clavier et votre &eacute;cran communiquent
&eacute;galement avec le processeur via le bus mais d'une
mani&egrave;re plus simple. Nous exposerons cela plus loin. Pour
l'instant vous en savez suffisamment pour comprendre ce qu'il se
passe lorsque vous allumez votre ordinateur.</p>
<h2><a name="s3">3. Que se passe-t-il lorsque vous allumez votre
ordinateur ?</a></h2>
<p>Un ordinateur sans programme qui s'ex&eacute;cute est juste un
tas inerte d'&eacute;lectronique. La premi&egrave;re chose que doit
faire un ordinateur lorsqu'il est allum&eacute; est de
d&eacute;marrer un programme sp&eacute;cial appel&eacute; <a name=
"os"></a> <em>syst&egrave;me d'exploitation</em>. Le travail du
syst&egrave;me d'exploitation est d'aider les autres programmes de
l'ordinateur &agrave; travailler, en traitant les d&eacute;tails
m&eacute;prisables du contr&ocirc;le du mat&eacute;riel de
l'ordinateur.</p>
<p>Le processus de d&eacute;marrage du syst&egrave;me
d'exploitation est appel&eacute; <a name="boot"></a>
<em>booting</em> (originalement c'&eacute;tait <em>bootstrapping
(la&ccedil;age des chaussures)</em>, allusion &agrave; la
difficult&eacute; d'enfiler soi m&ecirc;me ses chaussures `par les
lacets'. Votre ordinateur sait comment booter car les instructions
de boot sont stock&eacute;es dans un de ses composants, le
composant BIOS (ou Basic Input/Output System).</p>
<p>Le composant BIOS dit o&ugrave; aller chercher, &agrave; une
place fixe sur le disque dur de plus basse adresse (le <em>disque
de boot</em>), un programme sp&eacute;cial appel&eacute;
<em>chargeur de boot (boot loader)</em> (sous Linux le chargeur de
boot est appel&eacute; LILO). Le chargeur de boot est charg&eacute;
en m&eacute;moire puis lanc&eacute;. Le travail du chargeur de boot
est de d&eacute;marrer le syst&egrave;me d'exploitation
r&eacute;el.</p>
<p>Le chargeur fait cela en allant chercher un <em>noyau</em>, en
le chargeant en m&eacute;moire et en le d&eacute;marrant. Lorsque
vous bootez Linux et voyez "LILO" sur l'&eacute;cran suivi par une
succession de points, c'est qu'il charge le noyau. (Chaque point
signifie qu'il vient de charger un autre <a name="diskblock"></a>
<em>bloc du disque</em> du code du noyau.)</p>
<p>(Vous pouvez vous demander pourquoi le BIOS ne charge pas le
noyau directement --&nbsp;pourquoi ces deux &eacute;tapes du
processus avec le chargeur de boot ? C'est que le BIOS n'est pas
vraiment intelligent. En fait il est carr&eacute;ment stupide, et
Linux ne l'utilise jamais apr&egrave;s avoir boot&eacute;. A
l'origine, j'ai programm&eacute; sur des PC 8-bits primitifs avec
de petits disques&nbsp;: litt&eacute;ralement ils ne pouvaient
acc&eacute;der &agrave; suffisamment de disque pour charger le
noyau directement. L'&eacute;tape du chargeur de boot vous permet
de d&eacute;marrer plusieurs syst&egrave;mes d'exploitation
&agrave; partir de diff&eacute;rents emplacements de votre disque,
dans le cas o&ugrave; Unix n'est pas assez bon pour vous.)</p>
<p>Une fois que le noyau d&eacute;marre, il doit chercher autour de
lui, trouver le reste du mat&eacute;riel et &ecirc;tre pr&ecirc;t
pour ex&eacute;cuter des programmes. Il fait cela non pas en
fouillant &agrave; des adresses m&eacute;moire ordinaires, mais
&agrave; des <em>ports d'Entr&eacute;e/Sortie</em> --&nbsp;des
adresses sp&eacute;ciales du bus, sens&eacute;es avoir une carte
contr&ocirc;leur de p&eacute;riph&eacute;riques en attente de
commandes &agrave; cet endroit. Le noyau ne fouille pas au
hasard&nbsp;; il a un ensemble de connaissances qui lui permet de
savoir ce qu'il est sens&eacute; trouver ici, et comment les
contr&ocirc;leurs r&eacute;pondraient s'ils &eacute;taient
pr&eacute;sents. Ce processus est appel&eacute; <em>Exploration
automatique</em>.</p>
<p>La plupart des messages que vous voyez au moment du boot sont
l'exploration de votre mat&eacute;riel par le noyau &agrave;
travers les ports d'Entr&eacute;e/Sortie, le chiffrage de ce qui
est disponible et l'adaptation &agrave; votre machine. Le noyau
Linux est extr&ecirc;mement bon pour cela, meilleur que la plupart
des autres Unix et <em>tellement</em> meilleur que DOS ou Windows.
En fait, beaucoup de vieux adeptes de Linux pensent que
l'ing&eacute;niosit&eacute; des explorations de Linux lors du boot
(qui lui permettent de s'installer relativement simplement) ont
&eacute;t&eacute; une raison de s'&eacute;panouir dans le monde des
exp&eacute;riences des Unix libres pour attirer une masse critique
d'utilisateurs.</p>
<p>Mais rendre le noyau compl&egrave;tement charg&eacute; et
s'ex&eacute;cutant n'est pas la fin du processus de boot&nbsp;;
c'est juste la premi&egrave;re &eacute;tape (quelquefois
appel&eacute;e <em>niveau d'ex&eacute;cution 1 (run level
1)</em>).</p>
<p>L'&eacute;tape suivante du noyau est de s'assurer que vos
disques sont OK. Les syst&egrave;mes de fichiers sur disques sont
des choses fragiles&nbsp;; s'ils ont &eacute;t&eacute;
endommag&eacute;s par une panne mat&eacute;rielle ou par une
coupure soudaine d'alimentation &eacute;lectrique, il y a de bonnes
raisons de r&eacute;tablir l'int&eacute;grit&eacute; avant que
votre Unix ne puisse aller plus loin. Nous parlerons plus tard de
ce que l'on dit &agrave; propos de <a href="#fsck">comment les
syst&egrave;mes de fichiers peuvent devenir mauvais</a>.</p>
<p>L'&eacute;tape suivante du noyau est de lancer plusieurs
<em>d&eacute;mons</em>. Un d&eacute;mon est un programme comme un
spouleur d'imprimante, un serveur de mail ou un serveur WWW qui se
cache en arri&egrave;re-plan en attendant d'avoir des choses
&agrave; faire. Ces programmes sp&eacute;ciaux doivent coordonner
plusieurs requ&ecirc;tes qui peuvent entrer en conflit. Il y a des
d&eacute;mons car il est souvent plus facile d'&eacute;crire un
programme qui s'ex&eacute;cute constamment et qui sait tout des
requ&ecirc;tes, plut&ocirc;t que d'essayer de s'assurer qu'un
troupeau de copies (chacune traitant une requ&ecirc;te et toutes
s'ex&eacute;cutant en m&ecirc;me temps) ne se g&ecirc;neraient pas
mutuellement. La collection particuli&egrave;re de d&eacute;mons
que le syst&egrave;me d&eacute;marre peut varier, mais inclura
presque toujours un spouleur d'imprimante (un d&eacute;mon
garde-barri&egrave;re de votre imprimante).</p>
<p>Une fois que tous les d&eacute;mons ont d&eacute;marr&eacute;,
nous sommes dans le <em>niveau d'ex&eacute;cution 2 (run level
2)</em>. L'&eacute;tape suivante est la pr&eacute;paration pour les
utilisateurs. Le noyau d&eacute;marre une copie d'un programme
appel&eacute; <code>getty</code> pour surveiller votre console (et
peut &ecirc;tre d'autres copies pour surveiller des
ports-s&eacute;rie entrants) Ce programme est celui duquel jaillit
le prompt <code>login</code> sur votre console. Nous sommes
maintenant dans le <em>niveau d'ex&eacute;cution 3 (run level
3)</em> et pr&ecirc;ts pour votre connexion et l'ex&eacute;cution
de vos programmes.</p>
<p>Quand vous vous connectez (en donnant un nom et un mot de
passe), vous vous identifiez aupr&egrave;s de <code>getty</code> et
de l'ordinateur. Il ex&eacute;cute maintenant un programme
appel&eacute; (assez naturellement) <code>login</code>, qui
r&eacute;alise des t&acirc;ches ancillaires et d&eacute;marre un
interpr&eacute;teur de commandes, le <em>shell</em>. (Oui
<code>getty</code> et <code>login</code> pourraient &ecirc;tre un
seul et m&ecirc;me programme. Ils sont s&eacute;par&eacute;s pour
des raisons historiques que nous n'expliciterons pas ici.)</p>
<p>Dans la section suivante, nous parlerons de ce qui se passe
lorsque vous ex&eacute;cutez des programmes &agrave; partir du
shell.</p>
<h2><a name="run"></a> <a name="s4">4. Que se passe-t-il lorsque
vous ex&eacute;cutez des programmes &agrave; partir du
shell?</a></h2>
<p>Le shell normal vous donne le prompt '$' que vous voyez
apr&egrave;s vous &ecirc;tre connect&eacute; (cependant vous pouvez
le modifier et mettre autre chose). Nous ne parlerons pas de la
syntaxe du shell et des choses faciles que vous pouvez voir sur
votre &eacute;cran ici&nbsp;; alors que nous 'jetterons un oeil'
sur ce qu'il se passe du point de vue de l'ordinateur.</p>
<p>Apr&egrave;s la phase de boot et avant que vous
n'ex&eacute;cutiez un programme, vous pouvez penser &agrave; votre
ordinateur comme &eacute;tant un zoo de processus qui attendent
qu'il se passe quelque chose. Ils attendent des
<em>&eacute;v&eacute;nements</em>. Un &eacute;v&eacute;nement, ce
peut &ecirc;tre l'enfoncement d'une touche ou un d&eacute;placement
de la souris. Ou, si votre machine est connect&eacute;e &agrave; un
r&eacute;seau, un &eacute;v&eacute;nement peut &ecirc;tre un paquet
de donn&eacute;es venant de ce r&eacute;seau.</p>
<p>Le noyau est un de ces processus. C'en est un sp&eacute;cial,
car il contr&ocirc;le le moment o&ugrave; les autres processus
<em>utilisateur</em> peuvent s'ex&eacute;cuter, et c'est
normalement le seul processus qui acc&egrave;de directement au
mat&eacute;riel de la machine. En fait, les processus utilisateurs
font des requ&ecirc;tes au noyau lorsqu'ils veulent obtenir une
entr&eacute;e clavier, &eacute;crire sur votre &eacute;cran, lire
ou &eacute;crire sur votre disque ou juste autre chose que
consommer quelques bits en m&eacute;moire. Ces requ&ecirc;tes sont
appel&eacute;es <em>appels syst&egrave;me</em>.</p>
<p>Normalement toute Entr&eacute;e/Sortie passe par le noyau de
mani&egrave;re &agrave; ce qu'il puisse ordonnancer les
op&eacute;rations et &eacute;viter ainsi aux processus de se
marcher les uns sur les autres. Quelques processus utilisateur sont
autoris&eacute;s &agrave; contourner le noyau, habituellement en
ayant acc&egrave;s directement aux ports d'Entr&eacute;e/Sortie.
Les serveurs X (les programmes qui traitent les requ&ecirc;tes
graphiques des autres programmes sur la plupart des machines Unix)
sont des exemples classiques. Mais nous n'avons pas vu de serveur X
pour l'instant&nbsp;; vous &ecirc;tes au prompt du shell sur une
console en mode caract&egrave;res.</p>
<p>Le shell est juste un processus utilisateur, et non un processus
particuli&egrave;rement sp&eacute;cial. Il attend vos frappes sur
les touches du clavier, &eacute;coutant (&agrave; travers le noyau)
le port d'E/S du clavier. Comme le noyau les voit, il les affiche
sur votre &eacute;cran et les passe au shell. Le shell essaie de
les interpr&eacute;ter comme &eacute;tant des commandes.</p>
<p>Tapez `ls' suivi de `Enter' afin de lister le contenu d'un
r&eacute;pertoire. Le shell applique ses r&egrave;gles internes
pour &eacute;valuer la commande que vous voulez ex&eacute;cuter
dans le fichier `/bin/ls'. Il fait un appel syst&egrave;me en
demandant au noyau de lancer `/bin/ls' comme un processus
<em>fils</em> et donne son acc&egrave;s &agrave; l'&eacute;cran et
au clavier &agrave; travers le noyau. Le shell se rendort en
attendant que 'ls' se termine.</p>
<p>Lorsque /bin/ls est termin&eacute;, il dit au noyau qu'il a
termin&eacute; en effectuant un appel syst&egrave;me <em>exit</em>.
Le noyau r&eacute;veille le shell et lui dit qu'il peut continuer
&agrave; s'ex&eacute;cuter. Le shell affiche un autre prompt et
attend une autre ligne en entr&eacute;e.</p>
<p>D'autres choses peuvent &ecirc;tre faites pendant
l'ex&eacute;cution de `ls', cependant (nous supposerons que la
liste du r&eacute;pertoire est tr&egrave;s longue). Vous pourriez
basculer sur une autre console virtuelle, vous connecter, et lancer
une jeu de Quake par exemple. Ou bien, supposez que vous &ecirc;tes
connect&eacute; &agrave; Internet&nbsp;: votre machine peut envoyer
ou recevoir des mails pendant que `/bin/ls' s'ex&eacute;cute.</p>
<h2><a name="s5">5. Comment marchent les
p&eacute;riph&eacute;riques d'entr&eacute;e et les interruptions
?</a></h2>
<p>Votre clavier est un p&eacute;riph&eacute;rique tr&egrave;s
simple&nbsp;; simple car il g&eacute;n&egrave;re un petit flux de
donn&eacute;es tr&egrave;s lentement (sur un ordinateur standard).
Lorsque vous rel&acirc;chez une touche, cet &eacute;v&eacute;nement
est signal&eacute; par le c&acirc;ble du clavier qui va provoquer
une <em>interruption mat&eacute;riel</em>.</p>
<p>C'est au syst&egrave;me d'exploitation de surveiller de telles
interruptions. Pour chaque type possible d'interruption, il y a un
<em>handler d'interruption</em>, une partie du syst&egrave;me
d'exploitation dissimule toutes les donn&eacute;es associ&eacute;es
(comme la valeur touche enfonc&eacute;e/touche
rel&acirc;ch&eacute;e) tant qu'elle ne peut &ecirc;tre
trait&eacute;e.</p>
<p>Ce que le fait le handler d'interruption disque pour votre
clavier est de d&eacute;poser la valeur de la touche dans une zone
en bas de la m&eacute;moire (core). Ainsi elle sera disponible pour
l'inspection lorsque le syst&egrave;me d'exploitation passera le
contr&ocirc;le &agrave; n'importe quel programme suppos&eacute;
attendre pr&eacute;sentement une entr&eacute;e clavier.</p>
<p>Des p&eacute;riph&eacute;riques d'entr&eacute;e plus complexes
comme les disques travaillent de mani&egrave;re similaire.
Pr&eacute;c&eacute;demment nous faisions r&eacute;f&eacute;rence
&agrave; un contr&ocirc;leur de disques utilisant le bus pour
signaler qu'une requ&ecirc;te disque a bien &eacute;t&eacute;
ex&eacute;cut&eacute;e. Que se passe-t-il si ce disque
re&ccedil;oit une interruption ? Le handler de l'interruption
disque copie alors la donn&eacute;e trouv&eacute;e dans la
m&eacute;moire, pour une utilisation future par le programme qui en
avait fait la demande.</p>
<p>Chaque type d'interruption est associ&eacute; &agrave; un
<em>niveau de priorit&eacute;</em>. Les interruptions de plus basse
priorit&eacute; (comme les &eacute;v&egrave;nements clavier) sont
trait&eacute;es apr&egrave;s celles de priorit&eacute;
sup&eacute;rieures (comme les tops d'horloge ou les
&eacute;v&eacute;nements disque). Unix a &eacute;t&eacute;
con&ccedil;u pour traiter prioritairement les types
d'&eacute;v&eacute;nements qui doivent &ecirc;tre trait&eacute;s
rapidement afin de conserver une machine sur laquelle les temps de
r&eacute;ponse sont sont sans &agrave;-coup.</p>
<p>Les messages que vous voyez pendant la phase de boot font
r&eacute;f&eacute;rence &agrave; des num&eacute;ros d'<em>IRQ</em>.
Vous devez &ecirc;tre pr&eacute;venus qu'une des causes les plus
courantes de mauvaise configuration de votre mat&eacute;riel est
d'avoir deux p&eacute;riph&eacute;riques qui essaient d'utiliser la
m&ecirc;me IRQ, sans savoir ce que c'est r&eacute;ellement.</p>
<p>La r&eacute;ponse est ici. IRQ est l'abbr&eacute;viation de
"Interrupt ReQuest". Le syst&egrave;me d'exploitation a besoin de
savoir au d&eacute;marrage quel num&eacute;ro d'interruption sera
utilis&eacute; par chaque p&eacute;riph&eacute;rique, ainsi il peut
associer le handler ad&eacute;quat pour chacun. Si deux
p&eacute;riph&eacute;riques diff&eacute;rents essaient d'utiliser
la m&ecirc;me IRQ, les interruptions seraient quelquefois
distribu&eacute;es au mauvais handler. Cela est classique au moins
au verrouillage du p&eacute;riph&eacute;rique, et peut parfois
d&eacute;stabiliser le syst&egrave;me d'exploitation, qu'il se
"d&eacute;sint&egrave;gre" ou qu'il se crashe.</p>
<h2><a name="s6">6. Comment mon ordinateur fait-il plusieurs choses
en m&ecirc;me temps ?</a></h2>
<p>En fait, il ne le fait pas. Les ordinateurs ne peuvent traiter
qu'une seule t&acirc;che (ou <em>processus</em>) &agrave; la fois.
Mais un ordinateur peut changer de t&acirc;che tr&egrave;s
rapidement, et duper l'esprit humain en lui faisant croire qu'il
fait plusieurs choses en m&ecirc;me temps. C'est ce que l'on
appelle le <em>temps partag&eacute;</em>.</p>
<p>Une des t&acirc;ches du noyau est de g&eacute;rer le temps
partag&eacute;. C'est une partie d&eacute;di&eacute;e &agrave;
l'<em>ordonnanceur</em> qui conserve chez lui toutes les
informations sur les autres processus (non noyau) de votre
environnement. Chaque 1/60 &egrave;me de seconde, une horloge
avertit le noyau, g&eacute;n&eacute;rant une interruption horloge.
L'ordonnanceur arr&ecirc;te le processus qui s'ex&eacute;cute, le
suspend dans l'&eacute;tat, et donne le contr&ocirc;le &agrave; un
autre processus.</p>
<p>1/60 &egrave;me de seconde peut para&icirc;tre peu de temps.
Mais sur les microprocesseurs actuels c'est assez pour
ex&eacute;cuter des dizaines de milliers d'instructions machine, ce
qui permet d'effectuer beaucoup de choses. M&ecirc;me si vous avez
plusieurs processus, chacun peut accomplir un petit peu sa
t&acirc;che pendant ses tranches de temps.</p>
<p>En pratique, un programme ne dispose pas de sa tranche de temps
enti&egrave;re. Si une interruption arrive d'un
p&eacute;riph&eacute;rique d'E/S, le noyau arr&ecirc;tera en
r&eacute;alit&eacute; la t&acirc;che courante, ex&eacute;cutera le
handler d'interruption et retournera &agrave; la t&acirc;che
courante. Une temp&ecirc;te d'interruption de haute priorit&eacute;
peut interdire tout traitement normal&nbsp;; ce mauvais
comportement est appel&eacute; <em>d&eacute;faite (thrashing)</em>
et est difficile &agrave; provoquer sur les Unix modernes.</p>
<p>En fait, la vitesse des programmes est tr&egrave;s rarement
limit&eacute;e par le temps machine qu'ils peuvent obtenir (il y a
quelques exceptions &agrave; cette r&egrave;gle, comme la
g&eacute;n&eacute;ration de son ou de graphiques en 3-D. Le plus
souvent, les d&eacute;lais sont dus &agrave; l'attente, par le
programme, des donn&eacute;es d'un disque ou d'une connexion
r&eacute;seau.</p>
<p>Un syst&egrave;me d'exploitation qui peut supporter de
mani&egrave;re routini&egrave;re plusieurs processus est
appel&eacute; "multit&acirc;che". Les syst&egrave;mes
d'exploitation de la famille Unix ont &eacute;t&eacute;
con&ccedil;us d&egrave;s le d&eacute;but pour le multit&acirc;che
et sont vraiment bons pour &ccedil;a --&nbsp;beaucoup plus
efficaces que celui de Windows et MAC OS, pour lesquels le
multit&acirc;che a &eacute;t&eacute; introduit a posteriori et qui
le traitent plut&ocirc;t pauvrement. Efficace, multit&acirc;che,
fiable sont quelques-unes des raisons qui rendent Linux
sup&eacute;rieur pour le r&eacute;seau, les communications et les
services WEB.</p>
<h2><a name="s7">7. Comment mon ordinateur &eacute;vite aux
processus d'empi&eacute;ter les uns sur les autres ?</a></h2>
<p>L'ordonnanceur du noyau fait attention &agrave; s&eacute;parer
les processus dans le temps. Votre syst&egrave;me d'exploitation
les divise aussi dans l'espace, de telle mani&egrave;re que ces
processus n'empi&egrave;tent pas sur la m&eacute;moire de travail
des autres. Ces choses que votre syst&egrave;me d'exploitation
r&eacute;alise sont appel&eacute;es <em>gestion de la
m&eacute;moire</em>.</p>
<p>Chaque processus de votre 'troupeau' a besoin de son propre
espace m&eacute;moire afin de mettre son code et de garder des
variables et leur r&eacute;sultat. Vous pouvez imaginer cet
ensemble constitu&eacute; d'un <em>segment de code</em> accessible
en lecture uniquement (contenant les instrucions du processus) et
un <em>segment de donn&eacute;es</em> accessible en &eacute;criture
(contenant toutes les variables du processus). Le segment de
donn&eacute;es est v&eacute;ritablement propre &agrave; chaque
processus, mais si deux processus ex&eacute;cutent le m&ecirc;me
code, Unix s'arrange automatiquement pour qu'ils partagent le
m&ecirc;me segment de code dans un soucis d'efficacit&eacute;.</p>
<p>L'efficacit&eacute; est importante car la m&eacute;moire est
ch&egrave;re. Quelquefois, vous ne disposez pas de suffisamment de
m&eacute;moire pour faire tenir tous les programmes,
sp&eacute;cialement si vous utilisez un gros programme comme un
serveur X-WINDOW. Pour contourner cela, Unix utilise une
strat&eacute;gie appel&eacute;e <a name="vm"></a>
<em>m&eacute;moire virtuelle</em>. Cela n'essaie pas de faire tenir
tout le code et les donn&eacute;es d'un processus en
m&eacute;moire. Cependant, il garde seulement un espace de
travail&nbsp;; le reste de l'&eacute;tat du processus est
laiss&eacute; dans un endroit sp&eacute;cial sur votre
disque&nbsp;: <em>l'espace d'&eacute;change (swap space)</em>.</p>
<p>Lorsque le processus s'ex&eacute;cute, Unix essaie d'anticiper
comment l' espace de travail changera, et ne chargera en
m&eacute;moire que les morceaux dont il a besoin. Faire cela
efficacement est compliqu&eacute; et d&eacute;licat, je n'essaierai
pas de le d&eacute;crire ici --&nbsp;mais cela d&eacute;pend du
fait que le code et les r&eacute;f&eacute;rences aux donn&eacute;es
peuvent arriver en blocs, avec chaque nouveau
r&eacute;f&eacute;ren&ccedil;ant vraisemblablement un proche ou un
ancien. Ainsi, si Unix garde le code ou les donn&eacute;es
fr&eacute;quemment (ou r&eacute;cemment) utilis&eacute;s, vous
gagnerez du temps.</p>
<p>Notez que dans le pass&eacute;, le "quelquefois" que nous
employons deux paragraphes plus haut &eacute;tait "souvent" voire
"toujours", --&nbsp;la taille de la m&eacute;moire &eacute;tait
habituellement petite par rapport &agrave; la taille des programmes
en cours d'ex&eacute;cution, de telle mani&egrave;re que les
&eacute;changes entre le disque et la m&eacute;moire ("swapping")
&eacute;taient fr&eacute;quents. La m&eacute;moire est beaucoup
moins ch&egrave;re de nos jours et m&ecirc;me les machines bas de
gamme en sont bien dot&eacute;es. Sur les machines mono-utilisateur
avec 64Mo de m&eacute;moire, il est possible de faire tourner
X-WINDOW et un m&eacute;lange de programmes sans jamais
swapper.</p>
<p>M&ecirc;me dans cette situation joyeuse, la part du
syst&egrave;me d'exploitation appel&eacute;e le <em>gestionnaire de
m&eacute;moire</em> a un important travail &agrave; faire. Il doit
&ecirc;tre s&ucirc;r que les programmes ne peuvent modifier que
leurs segments de m&eacute;moire --&nbsp;ce qui emp&ecirc;che un
code erron&eacute; ou malicieux dans un programme de ramasser les
donn&eacute;es dans un autre. Pour faire cela, il conserve une
table des segments de donn&eacute;es et de code. La table est mise
&agrave; jour chaque fois qu'un processus demande de la
m&eacute;moire ou en lib&egrave;re (habituellement plus tard
lorsqu'il se termine).</p>
<p>Cette table est utilis&eacute;e pour passer des commandes
&agrave; une partie sp&eacute;cialis&eacute;e du mat&eacute;riel
sous-jacent appel&eacute;e un <em>UGM (MMU)</em> ou
<em>unit&eacute; de gestion m&eacute;moire (memory management
unit)</em>. Les processeurs modernes disposent de MMUs
int&eacute;gr&eacute;s. Le MMU a la facult&eacute; de mettre des
barri&egrave;res autour de zones m&eacute;moire, ainsi une
r&eacute;f&eacute;rence en "dehors des clous" sera refus&eacute;e
et g&eacute;n&eacute;rera une interruption sp&eacute;ciale pour
&ecirc;tre trait&eacute;e.</p>
<p>Si vous avez d&eacute;j&agrave; vu le message Unix qui dit
"Segmentation fault", "core dumped" ou quelque chose de similaire,
c'est exactement ce qu'il se passe&nbsp;; un programme en cours
d'ex&eacute;cution a tent&eacute; d'acc&eacute;der &agrave; de la
m&eacute;moire en dehors de son segment et a provoqu&eacute; une
interruption fatale. Cela indique un bug dans le code du
programme&nbsp;; le <em>core dump</em> laisse une information en
vue d'un diagnostic &agrave; l'attention du programmeur afin qu'il
puisse trouver la trace de son erreur.</p>
<h2><a name="s8">8. Comment mon ordinateur stocke des choses sur le
disque ?</a></h2>
<p>Sur votre disque dur sous Unix, vous voyez un arbre de
r&eacute;pertoires nomm&eacute;s et des fichiers. Normalement vous
ne devriez pas &agrave; chercher &agrave; en savoir plus, mais cela
peut s'av&eacute;rer utile de savoir ce qu'il y a dessous si vous
avez un crash disque et besoin d'essayer de nettoyer des fichiers.
Malheureusement il n'y a pas de bon moyen de d&eacute;crire
l'organisation du disque en partant du niveau fichier et en
descendant, c'est pour cela que je le d&eacute;crirai en remontant
&agrave; partir du niveau mat&eacute;riel.</p>
<h2><a name="ss8.1">8.1 Bas niveau du disque et structure du
syst&egrave;me de fichiers</a></h2>
<p>La surface de votre disque , sur laquelle il stocke les
donn&eacute;es est divis&eacute;e comme une cible de jeu de
fl&eacute;chettes --&nbsp;en pistes circulaires qui sont
partag&eacute;es en secteurs. Parce que les pistes de
l'ext&eacute;rieur contiennent plus de surface que celles
pr&egrave;s de l'axe de rotation, au centre du disque, les pistes
externes ont plus de secteurs que celles de l'int&eacute;rieur.
Chaque secteur (ou <em>bloc disque</em>) a la m&ecirc;me taille,
qui est g&eacute;n&eacute;ralement de 1Ko (1024 mots de 8 bits).
Chaque bloc disque a une adresse unique ou un <em>num&eacute;ro de
bloc disque</em>.</p>
<p>Unix divise le disque en <em>partitions disque</em>. Chaque
partition est une succession de blocs qui est utilis&eacute;e
ind&eacute;pendamment des autres partitions, comme un
syst&egrave;me de fichiers ou un espace d'&eacute;change (swap
space). La partition ayant le plus petit num&eacute;ro est souvent
trait&eacute;e sp&eacute;cialement, telle la <em>partition de
boot</em> dans laquelle vous pouvez mettre un noyau pour
booter.</p>
<p>Chaque partition est soit un <em>espace de swap</em>
(utilis&eacute; pour impl&eacute;menter la <a href=
"#vm">m&eacute;moire virtuelle</a>) soit un <a name=
"systeme de fichiers"></a> <em>syst&egrave;me de fichiers</em> pour
stocker des fichiers. Les partitions de swap sont trait&eacute;es
comme une s&eacute;quence lin&eacute;aire de blocs. Les
syst&egrave;mes de fichiers d'un autre cot&eacute;, ont besoin de
relier les noms de fichiers &agrave; des s&eacute;quences de blocs
disque. Parce que les fichiers grossissent, diminuent, et changent
tout le temps, les blocs de donn&eacute;es d'un fichier ne seront
pas une s&eacute;quence lin&eacute;aire mais pourront &ecirc;tre
dispers&eacute;s sur toute la partition (tant que le syst&egrave;me
d'exploitation pourra trouver un bloc libre).</p>
<h2><a name="ss8.2">8.2 Noms de fichiers et
r&eacute;pertoires</a></h2>
<p>Dans chaque syst&egrave;me de fichiers, la liaison entre les
noms et les blocs est r&eacute;alis&eacute;e gr&acirc;ce &agrave;
une structure appel&eacute;e <em>i-node (noeud d'index)</em>. Il y
en a tout un tas proche de la "base" (num&eacute;ro de bloc les
plus faibles) du syst&egrave;me de fichiers (les tout premiers sont
utilis&eacute;s pour des besoins d'int&eacute;grit&eacute; et de
label que nous ne d&eacute;crirons pas ici). Chaque i-node
d&eacute;crit un fichier. Les blocs de donn&eacute;es des fichiers
sont au dessus des i-nodes (conceptuellement).</p>
<p>Chaque i-node contient la liste des num&eacute;ros des blocs du
fichier (r&eacute;ellement c'est une demi-v&eacute;rit&eacute;,
c'est seulement valable pour les petits fichiers, mais le reste de
ces d&eacute;tails ne sont pas importants ici). Notez que l'i-node
<em>ne contient pas</em> le nom du fichier.</p>
<p>Les noms des fichiers r&eacute;sident dans les <em>structures de
r&eacute;pertoires</em>. Une structure de r&eacute;pertoire
contient juste une table des noms et des num&eacute;ros d'i-node
associ&eacute;s. C'est la raison pour laquelle, sous Unix, un
fichier peut avoir plusieurs noms r&eacute;els (ou <em>liens forts
(hard links)</em>)&nbsp;; Il y a juste plusieurs entr&eacute;es
dans un r&eacute;pertoire qui pointent vers le m&ecirc;me
i-node.</p>
<h2><a name="ss8.3">8.3 Points de montage</a></h2>
<p>Dans le cas le plus simple, votre syst&egrave;me de fichiers
Unix tient sur une seule partition disque. Cependant vous verrez
que cette disposition sur des petits syst&egrave;mes Unix n'est pas
pratique. Typiquement il est r&eacute;parti sur plusieurs
partitions disque voire sur plusieurs disques physiques. Ainsi par
exemple, votre syst&egrave;me peut avoir une petite partition
o&ugrave; le noyau r&eacute;side, une un peu plus grande pour les
utilitaires du syst&egrave;me et une beaucoup plus grosse pour les
r&eacute;pertoires des utilisateurs.</p>
<p>La seule partition &agrave; laquelle vous aurez acc&egrave;s
imm&eacute;diatement apr&egrave;s le boot est votre <em>partition
racine (root partition)</em>, qui est (presque toujours) celle
&agrave; partir de laquelle vous avez boot&eacute;. Elle contient
le r&eacute;pertoire racine du syst&egrave;me de fichiers, le noeud
le plus haut &agrave; partir duquel tout est raccroch&eacute;.</p>
<p>Les autres partitions du syst&egrave;me doivent &ecirc;tre
attach&eacute;es &agrave; cette racine afin que votre
syst&egrave;me de fichiers unique ou multi-partition soit
accessible. Au milieu du processus de boot, votre Unix rendra ces
partitions 'non root' accessibles. Il devra <em>monter</em> chacune
d'elles sur un r&eacute;pertoire de la partition racine.</p>
<p>Par exemple, si votre Unix a un r&eacute;pertoire appel&eacute;
'/usr', c'est probablement un point de montage d'une partition qui
contient un tas de programmes install&eacute;s avec votre Unix mais
qui ne sont pas n&eacute;cessaires durant la phase initiale de
boot.</p>
<h2><a name="ss8.4">8.4 Comment un fichier est retrouv&eacute;
?</a></h2>
<p>Maintenant nous pouvons consid&eacute;rer le syst&egrave;me de
fichiers dans une d&eacute;marche descendante. Lorsque vous ouvrez
un fichier (tel que /home/esr/WWW/ldp/fundamentals.sgml) voici ce
qu'il arrive&nbsp;:</p>
<p>Votre noyau d&eacute;marre de la racine de votre syst&egrave;me
de fichiers Unix (dans la partition root). Il cherche un
r&eacute;pertoire appel&eacute; `home'. Habituellement `home' est
un point de montage d'une grande partition pour les utilisateurs,
il descend &agrave; l'int&eacute;rieur. Au sommet de la structure
du r&eacute;pertoire de cette partition utilisateur, il va chercher
une entr&eacute;e nomm&eacute;e `esr' et en extraire le
num&eacute;ro d'i-node. Il ira &agrave; cette i-node, notez que
c'est une structure de r&eacute;pertoire, et retrouvera `WWW'. En
exploitant <em>cet</em> i-node, il ira au sous r&eacute;pertoire
correspondant et retrouvera `ldp'. Ce qui lui donnera encore un
autre i-node r&eacute;pertoire. En ouvrant ce dernier, il trouvera
un num&eacute;ro d'i-node pour `fundamentals.sgml'. Cet i-node
n'est pas un r&eacute;pertoire mais fournit la liste des blocs
associ&eacute;s au fichier.</p>
<h2><a name="ss8.5">8.5 Comment les choses peuvent
d&eacute;g&eacute;n&eacute;rer ?</a></h2>
<p><a name="fsck"></a> Plus haut, nous avons laiss&eacute; entendre
que les syst&egrave;mes de fichiers &eacute;taient fragiles.
Maintenant nous savons que pour acc&eacute;der &agrave; un fichier
vous devez parcourir une longue cha&icirc;ne arbitraire de
r&eacute;f&eacute;rences &agrave; des r&eacute;pertoires et
&agrave; des inodes. A pr&eacute;sent, supposons que votre disque
dur poss&egrave;de une zone d&eacute;fectueuse.</p>
<p>Si vous &ecirc;tes chanceux, il d&eacute;truira quelques
donn&eacute;es d'un fichier. Si vous &ecirc;tes malchanceux, il va
corrompre une structure de r&eacute;pertoire ou un num&eacute;ro
d'inode et laissera un sous arbre entier de votre syst&egrave;me
dans l'oubli --&nbsp;ou, pire, cela a donn&eacute; une structure
corrompue qui pointe par plusieurs chemins au m&ecirc;me bloc
disque ou inode. Une telle corruption peut s'&eacute;tendre par des
op&eacute;rations courantes sur les fichiers qui ne se trouvent pas
au point d'origine.</p>
<p>Heureusement, ce genre de d'impr&eacute;vu devient de plus en
plus rare car les disques sont de plus en plus fiables.
Malgr&eacute; tout, cela veut dire que votre Unix voudra
v&eacute;rifier p&eacute;riodiquement l'int&eacute;grit&eacute; du
syst&egrave;me de fichiers afin de s'assurer que rien ne cloche.
Les Unix modernes font une v&eacute;rification rapide sur chaque
partition au moment du boot, juste avant de les monter. Au bout
d'un certain nombre de red&eacute;marrages (reboot), la
v&eacute;rification sera plus approfondie et durera quelques
minutes.</p>
<p>Si tout cela vous parait, comme Unix, terriblement complexe et
pr&eacute;dispos&eacute; aux d&eacute;faillances, au contraire,
c'est rassurant de savoir que ces v&eacute;rifications faites au
d&eacute;marrage de la machine, d&eacute;tectent et corrigent les
probl&egrave;mes courants <em>avant</em> qu'ils ne deviennent
r&eacute;ellement d&eacute;sastreux. D'autres syst&egrave;mes
d'exploitation ne disposent pas de ces fonctionnalit&eacute;s, qui
acc&eacute;l&egrave;rent un petit peu le d&eacute;marrage, mais
peuvent vous laisser tout 'bousiller' en essayant de
r&eacute;cup&eacute;rer &agrave; la main (et en supposant que vous
ayez une copie des Utilitaires Norton ou autre &agrave;
port&eacute;e de main...).</p>
<h2><a name="s9">9. Comment fonctionnent les langages d'ordinateur
?</a></h2>
<p>Nous avons d&eacute;j&agrave; &eacute;voqu&eacute; <a href=
"#run">comment les programmes sont ex&eacute;cut&eacute;s</a>.
Chaque programme en fin de compte doit ex&eacute;cuter une
succession d'octets qui sont les instructions dans le <em>langage
machine</em> de votre ordinateur. Les humains ne pratiquent pas
tr&egrave;s bien le langage machine&nbsp;; cela est devenu rare,
art obscur m&ecirc;me parmi les hackers.</p>
<p>La plupart du code du noyau d'Unix except&eacute; une petite
partie de l'interface avec le mat&eacute;riel est de nos jours
&eacute;crite dans un <em>langage de haut niveau</em>. (Le terme
'haut niveau' est un h&eacute;ritage du pass&eacute; afin de le
distinguer du 'bas-niveau' des <em>langages assembleur</em>, qui
sont de maigres "couches" autour du code machine.</p>
<p>Il y plusieurs types diff&eacute;rents de langages de haut
niveau. Afin de parler d'eux, vous trouverez utile que j'attire
votre attention sur le fait que le <em>code source</em> d'un
programme (la cr&eacute;ation humaine, la version &eacute;ditable)
est pass&eacute; &agrave; travers plusieurs types de traductions
pour arriver en code machine, que la machine peut effectivement
ex&eacute;cuter.</p>
<h2><a name="ss9.1">9.1 Langages compil&eacute;s</a></h2>
<p>Le type le plus classique de langage est un <em>langage
compil&eacute;</em>. Les langages compil&eacute;s sont traduits en
fichiers ex&eacute;cutables de code machine binaire par un
programme sp&eacute;cial appel&eacute; (assez logiquement) un
<em>compilateur</em>. Lorsque le binaire est
g&eacute;n&eacute;r&eacute;, vous pouvez l'ex&eacute;cuter
directement sans regarder &agrave; nouveau dans le code source. (La
plupart des logiciels d&eacute;livr&eacute;s sous forme de binaires
compil&eacute;s sont faits &agrave; partir d'un source auquel vous
n'avez pas acc&egrave;s.)</p>
<p>Les langages compil&eacute;s tendent &agrave; fournir une
excellente performance et ont un acc&egrave;s le plus complet au
syst&egrave;me d'exploitation, mais il difficile de programmer
avec.</p>
<p>Le langage C, langage dans lequel chaque Unix est lui-m&ecirc;me
&eacute;crit, est de tous le plus important (avec sa variante C++).
FORTRAN est un autre langage compil&eacute; qui reste
utilis&eacute; par de nombreux ing&eacute;nieurs et scientifiques
mais plus vieux et plus primitif. Dans le monde Unix aucun autre
langage compil&eacute; n'est autant utilis&eacute;. En dehors de
lui, COBOL est tr&egrave;s largement utilis&eacute; pour les
logiciels de finance et comptabilit&eacute;.</p>
<p>Il y a bien d'autres compilateurs de langages, mais la plupart
sont en voie d'extinction ou sont strictement des outils de
recherche. Si vous &ecirc;tes un nouveau d&eacute;veloppeur Unix
qui utilise un langage compil&eacute;, il est incontournable que ce
soit C ou C++.</p>
<h2><a name="ss9.2">9.2 Langages interpr&eacute;t&eacute;s</a></h2>
<p>Un <em>langage interpr&eacute;t&eacute;</em> d&eacute;pend d'un
programme interpr&eacute;teur qui lit le code source et traduit
&agrave; la vol&eacute;e en calculs et appels syst&egrave;me. Le
source doit &ecirc;tre r&eacute;-interpr&eacute;t&eacute; (et
l'interpr&eacute;teur pr&eacute;sent) &agrave; chaque fois que le
programme est ex&eacute;cut&eacute;.</p>
<p>Les langages interpr&eacute;t&eacute;s tendent &agrave;
&ecirc;tre plus lents que les langages compil&eacute;s, et limitent
souvent les acc&egrave;s au syst&egrave;me d'exploitation ou au
mat&eacute;riel sous-jacent. D'un autre c&ocirc;t&eacute;, il est
plus facile de programmer et ils tol&egrave;rent plus d'erreurs de
codage que les langages compil&eacute;s.</p>
<p>Quelques utilitaires Unix, incluant le shell et bc(1) et sed(1)
et awk(1), sont effectivement des petits langages
interpr&eacute;t&eacute;s. Les BASICs sont
g&eacute;n&eacute;ralement interpr&eacute;t&eacute;s. Ainsi est
Tcl. Historiquement, le langage le plus interpr&eacute;t&eacute;
&eacute;tait LISP (une am&eacute;lioration &eacute;norme sur la
plupart de ses successeurs). Aujourd'hui, Perl est tr&egrave;s
largement utilis&eacute; et devient r&eacute;solument plus
populaire.</p>
<h2><a name="ss9.3">9.3 Langages P-code</a></h2>
<p>Depuis 1990 un type de langage hybride qui utilise la
compilation et l'interpr&eacute;tation est devenu incroyablement
important. Les langages P-code sont comme des langages
compil&eacute;s dans le sens o&ugrave; le code est traduit dans une
forme binaire compacte qui est celle que vous ex&eacute;cutez, mais
cette forme n'est pas du code machine. Au lieu de cela, c'est du
<em>pseudo-code</em> (ou <em>p-code</em>), qui est
g&eacute;n&eacute;ralement un peu plus simple mais plus puissant
qu'un langage machine r&eacute;el. Lorsque vous ex&eacute;cutez le
programme, vous interpr&eacute;tez du p-code.</p>
<p>Le p-code peut s'ex&eacute;cuter pratiquement aussi rapidement
que du binaire compil&eacute; (les interpr&eacute;teurs de p-code
peuvent &ecirc;tre relativement simples, petits et rapides). Mais
les langages p-code peuvent garder la flexibilit&eacute; et la
puissance d'un bon interpr&eacute;teur.</p>
<p>D'importants langages p-code sont Python et Java.</p>
<h2><a name="s10">10. Comment Internet fonctionne ?</a></h2>
<p>Afin de vous aider &agrave; comprendre comment Internet
fonctionne, nous verrons ce qui se passe lorsque vous effectuez une
op&eacute;ration classique --&nbsp;pointer dans un navigateur ce
document &agrave; partir du site Web de r&eacute;f&eacute;rence du
Projet de Documentation de Linux (Linux Documentation Project). Ce
document est&nbsp;:</p>
<pre>
http://sunsite.unc.edu/LDP/HOWTO/Fundamentals.html
</pre>
<p>ce qui veut dire qu'il r&eacute;side dans le fichier
LDP/HOWTO/Fundamentals.html, sous le r&eacute;pertoire
export&eacute; World Wide Web de la machine sunsite.unc.edu.</p>
<h2><a name="ss10.1">10.1 Noms et localisations</a></h2>
<p>La premi&egrave;re chose que votre navigateur doit faire est
d'&eacute;tablir une connexion r&eacute;seau avec la machine sur
laquelle se trouve le document. Pour faire cela, il doit tout
d'abord trouver la localisation r&eacute;seau de
<em>l'h&ocirc;te</em> sunsite.unc.edu (h&ocirc;te est un raccourci
pour `machine h&ocirc;te' ou `h&ocirc;te r&eacute;seau'&nbsp;;
sunsite.unc.edu est un <em>nom d'h&ocirc;te (hostname)</em>
typique). La localisation correspondante est en fait un nombre
appel&eacute; <em>adresse IP</em> (nous expliquerons la partie `IP'
de ce terme plus tard).</p>
<p>Pour faire cela, votre navigateur sollicite un programme
nomm&eacute; <em>serveur de noms</em>. Le serveur de noms peut
r&eacute;sider sur votre machine, mais il est plus probable qu'il
soit sur une machine de service avec laquelle vous pouvez
dialoguer. Lorsque vous abonnez chez un Fournisseur d'Acc&eacute;s
&agrave; Internet (FAI), une partie de la proc&eacute;dure
d'installation d&eacute;crit certainement la mani&egrave;re
d'indiquer &agrave; votre logiciel Internet l'adresse IP du serveur
de noms du r&eacute;seau du FAI.</p>
<p>Les serveurs de noms sur diff&eacute;rentes machines
communiquent avec les autres en &eacute;changeant et en gardant
&agrave; jour toutes les informations n&eacute;cessaires &agrave;
la r&eacute;solution de noms d'h&ocirc;te (en les associant
&agrave; des adresses IP). Votre serveur de noms doit demander
&agrave; trois ou quatre sites &agrave; travers le r&eacute;seau
afin de r&eacute;soudre sunsite.unc.edu, mais cela se
d&eacute;roule vraiment rapidement (en moins d'une seconde).</p>
<p>Le serveur de noms dira &agrave; votre navigateur que l'adresse
IP de Sunsite est 152.2.22.81&nbsp;; sachant cela, votre machine
sera capable d'&eacute;changer des bits avec Sunsite
directement.</p>
<h2><a name="ss10.2">10.2 Paquets et routeurs</a></h2>
<p>Ce que le navigateur veut faire est d'envoyer une commande au
serveur Web sur Sunsite qui a la forme suivante&nbsp;:</p>
<pre>
GET /LDP/HOWTO/Fundamentals.html HTTP/1.0
</pre>
<p>Que se passe-t-il alors ? La commande est faite de
<em>paquets</em>&nbsp;; un bloc de bits comme un
t&eacute;l&eacute;gramme est d&eacute;coup&eacute; en trois choses
importantes&nbsp;: <em>l'adresse source</em> (l'IP de votre
machine), <em>l'adresse destination</em> (152.2.22.81), et le
<em>num&eacute;ro de service</em> ou <em>num&eacute;ro de port</em>
(80, dans ce cas) qui indique que c'est une requ&ecirc;te World
Wide Web.</p>
<p>Alors votre machine envoie le paquet par le fil (de la connexion
modem avec votre FAI, ou le r&eacute;seau local) jusqu'&agrave; ce
qu'il rencontre une machine sp&eacute;cialis&eacute;e
appel&eacute;e <em>routeur</em>. Le routeur poss&egrave;de une
carte de l'Internet dans sa m&eacute;moire --&nbsp;pas une
compl&egrave;te mais une qui d&eacute;crit votre voisinage
r&eacute;seau et sait comment aller aux routeurs pour les autres
voisinages sur l'Internet.</p>
<p>Votre paquet peut passer &agrave; travers plusieurs routeurs sur
le chemin de sa destination. Les routeurs sont adroits. Ils
regardent combien de temps prend un accus&eacute; r&eacute;ception
pour recevoir un paquet. Ils utilisent cette information pour
aiguiller le trafic sur les liens rapides. Ils l'utilisent pour
s'apercevoir que d'autres routeurs (ou un c&acirc;ble) sont
d&eacute;connect&eacute;s du r&eacute;seau et modifier le chemin si
possible en trouvant une autre route.</p>
<p>Il existe une l&eacute;gende urbaine qui dit qu'Internet a
&eacute;t&eacute; con&ccedil;u pour survivre a une guerre
nucl&eacute;aire. Ce n'est pas vrai, mais la conception d'Internet
est extr&ecirc;mement bonne en ayant une performance fiable
bas&eacute; sur des couches mat&eacute;rielles d'un monde
incertain... C'est directement du au fait que son intelligence est
distribu&eacute;e &agrave; travers des milliers de routeurs
plut&ocirc;t qu'&agrave; quelques auto-commutateurs massifs (comme
le r&eacute;seau t&eacute;l&eacute;phonique). Cela veut dire que
les d&eacute;faillances tendent &agrave; &ecirc;tre bien
localis&eacute;es et le r&eacute;seau peut les contourner.</p>
<p>Une fois que le paquet est arriv&eacute; &agrave; destination,
la machine utilise le num&eacute;ro de service pour le fournir au
serveur Web. Le serveur Web peut savoir &agrave; qui
r&eacute;pondre en regardant l'adresse source du paquet. Quand le
serveur Web renvoie ce document, il sera coup&eacute; en plusieurs
paquets. La taille des paquets varie en fonction du m&eacute;dia de
transmission du r&eacute;seau et du type de service.</p>
<h2><a name="ss10.3">10.3 TCP et IP</a></h2>
<p>Pour comprendre comment des transmissions de multiples paquets
sont r&eacute;alis&eacute;es, vous devez savoir que l'Internet
utilise actuellement deux protocoles empil&eacute;s l'un sur
l'autre.</p>
<p>Le plus bas niveau, <em>IP</em> (Internet Protocol), sait
comment recevoir des paquets individuels d'une adresse source vers
une adresse destination (c'est pourquoi elles sont appel&eacute;es
adresses IP). Cependant, IP n'est pas fiable&nbsp;; si un paquet
est perdu ou jet&eacute;, les machines source et destination ne le
sauront jamais. Dans le jargon r&eacute;seau, IP est un protocole
<em>sans connexion (ou mode non connect&eacute;)</em>&nbsp;;
l'exp&eacute;diteur envoie juste un paquet au destinataire et
n'attend jamais un accus&eacute; de r&eacute;ception.</p>
<p>Cependant, IP est rapide et peu co&ucirc;teux. Quelquefois,
rapide, peu co&ucirc;teux et non fiable c'est OK. Lorsque vous
jouez en r&eacute;seau &agrave; Doom ou Quake, chaque balle est
repr&eacute;sent&eacute;e par un paquet IP. Si quelques-unes sont
perdues, c'est OK.</p>
<p>Le niveau sup&eacute;rieur, <em>TCP</em> (Transmission Control
Protocol), fournit la fiabilit&eacute;. Quand deux machine
n&eacute;gocient une connexion TCP (ce qu'elles font en utilisant
IP), le destinataire doit envoyer des accus&eacute;s de
r&eacute;ception des paquets qu'il re&ccedil;oit &agrave;
l'exp&eacute;diteur. Si l'exp&eacute;diteur ne re&ccedil;oit pas un
accus&eacute; de r&eacute;ception pour un paquet apr&egrave;s un
certain temps, il renvoie ce paquet. De plus, l'exp&eacute;diteur
donne &agrave; chaque paquet TCP un num&eacute;ro de
s&eacute;quence, que le destinataire peut utiliser pour
r&eacute;-assembler les paquets dans le cas o&ugrave; il sont
arriv&eacute;s dans le d&eacute;sordre. (Cela peut arriver si les
liens r&eacute;seau se r&eacute;tablissent ou cassent pendant une
connexion.)</p>
<p>Les paquets TCP/IP contiennent &eacute;galement un checksum pour
permettre la d&eacute;tection de donn&eacute;es
alt&eacute;r&eacute;es par de mauvais liens. Ainsi, du point de vue
de quelqu'un utilisant TCP/IP et des serveurs de noms, il ressemble
&agrave; une voie fiable pour faire passer des flux d'octets entre
des paires h&ocirc;te/num&eacute;ro de services. Les gens qui
&eacute;crivent des protocoles r&eacute;seau ne doivent pas se
soucier la plupart du temps de la taille des paquets, du
r&eacute;-assemblage des paquets, de la v&eacute;rification
d'erreurs, le calcul du checksum et la retransmission qui sont au
niveau inf&eacute;rieurs.</p>
<h2><a name="ss10.4">10.4 HTTP, un protocole d'application</a></h2>
<p>Maintenant revenons &agrave; notre exemple. Les navigateurs et
les serveurs Web parlent un <em>protocole d'application</em> qui
est au dessus de TCP/IP, en l'utilisant simplement comme une
mani&egrave;re de passer des cha&icirc;nes d'octets dans les deux
sens. Ce protocole est appel&eacute; <em>HTTP</em> (Hyper-Text
Transfer Protocol) et nous en avons d&eacute;j&agrave; vu une
commande --&nbsp;la commande GET utilis&eacute;e ci-dessus.</p>
<p>Lorsque la commande GET arrive au serveur Web de sunsite.unc.edu
avec comme num&eacute;ro de service 80, elle sera
exp&eacute;di&eacute;e &agrave; un <em>d&eacute;mon serveur</em>
qui &eacute;coute le port 80. La plupart des services Internet sont
impl&eacute;ment&eacute;s par des d&eacute;mons serveurs qui ne
font rien d'autre qu'attendre sur des num&eacute;ros de port,
r&eacute;colter et ex&eacute;cuter les commandes entrantes.</p>
<p>Cette conception de l'Internet a une r&egrave;gle qui prime sur
les autres, c'est que toutes les parties sont le plus simple
possible et humainement accessible. HTTP, et ses comp&egrave;res
(comme le Simple Mail Transfer Protocol, <em>SMTP</em>, qui est
utilis&eacute; pour transporter du courrier &eacute;lectronique
entre des machines) utilisent de simples commandes de texte qui se
terminent par un retour chariot.</p>
<p>C'est rarement inefficace&nbsp;; dans certaines circonstances
vous pouvez obtenir plus de rapidit&eacute; en employant un
protocole binaire fortement cod&eacute;. Mais l'exp&eacute;rience a
montr&eacute; que le b&eacute;n&eacute;fice d'avoir des commandes
qui sont faciles &agrave; d&eacute;crire et &agrave; comprendre
l'emportent sur le gain marginal de l'efficacit&eacute; que l'on
peut esp&eacute;rer au prix de choses compliqu&eacute;es et
compactes.</p>
<p>Par cons&eacute;quent, ce que le d&eacute;mon serveur vous
renvoie via TCP/IP est aussi du texte. Le d&eacute;but de la
r&eacute;ponse ressemblera &agrave; quelque chose comme (quelques
en-t&ecirc;tes ont &eacute;t&eacute; supprim&eacute;s)&nbsp;:</p>
<pre>
HTTP/1.1 200 OK
Date: Sat, 10 Oct 1998 18:43:35 GMT
Server: Apache/1.2.6 Red Hat
Last-Modified: Thu, 27 Aug 1998 17:55:15 GMT
Content-Length: 2982
Content-Type: text/html
</pre>
<p>Ces en-t&ecirc;tes seront suivis d'une ligne vide et du texte de
la page Web (apr&egrave;s que la connexion sera rompue). Votre
navigateur affichera simplement cette page. Les en-t&ecirc;tes
indiquent --&nbsp;en particulier, l'en-t&ecirc;te Type de Contenu
(Content-Type)&nbsp;-- comment les donn&eacute;es re&ccedil;ues
sont vraiment du HTML).</p>
</body>
</html>