—
arborescence unique dans laquelle tout va se retrouver
sous linux, tout est fichier.
hd = hard drive (disque IDE)
sd = SCSI drive (SATA, USB, SCSI)hda = premier disque dur
sdc = troisième disque SATAil y a un MBR sur chaque disque présent dans le PC

serveur X
———

interface graphique
c’est un serveur car sous linux, le serveru X be va servir qu’à gérer l’affichage et ce sont les prog qui ont besoin d’affichage graphique qui vont demander au serveur X d’afficher leur fenêtre. Gère la carte graphique
avantage: dans un même espace d’affichage, plusieurs programmes

premier serveur graphique: XFree86 (avec quelques drivers propriétaires)
le plus utilisé: X.org: les 3/4 des dev de XFree86 (rien de propriétaire)

couches applicatives:
les gestionnaire de bureau = gest. de fenêtre ( window manager) (position, taille, superposition des fenêtres) + applications (tout le reste)

gestionnaire de bureaux:

KDE:

Gnome: gest de fenêtre= metacity, beryl, compiz
, emerald(gest de bordure),

avantages de X sur windows:
3ième bouton: copier le texte sélectionner
killer une application graphique:
KDE: CTRL+alt+esc
Gnome: alt+F2 et taper “xkill”

ouvrir des sessions de terminal console: CTRL+ALT Fx (de 1 à 7, 7 étant X)
passer d’un terminal à un autre, il suffit de taper ALT+Fx

u!tilisateur@nom de machine: répertoir eoù on se trouve $(utilisateur)/#(root)

shell: interpréteur de commande
BASH: Bourne Again SHell
va regarder si c’est une commande interne ()
va regarder si c’est un alias de commande
va regarder dans le path une commande qui porte ce nom-là (/bin:/usr:/…)
voir ce qu’il y a dans le path: taper en ligne de commande echo $PATH
~ = répertoire personnel. pour les users, c’est dans /home/login/…
pour root, c’est /root

les arguments de commande: séparé de la commande par un espace. exemple: cd ..
les options de commande (se placent entre la commande et l’option):
exemple: ls -l /home (un - pour les lettres, — pour des mots)

quelques *, ?, [] qui permettent de remplacer de trucs inconnus
*= chaine de caractères
? = un caractère
[]= parmi un choix de caractères

caractéres interprétés pas BASH qu’on ne peut pas utiliser dans un nom de fichier
>, <, |(entrée-sortie), $: variable, / (lié au système de fichiers)

les variables d'environnement: taper "set"
SHIFT+page up/down: pour naviguer jusqu'à 4 écrans en arrière

bash_env ~/.bashrc
HISTFILE ~/.bash_history
colors
!ls: va appeler la dernière commande commancant par "ls"
CTRL-r "truc": permet de rappeler les commandes déjà tapées commançant par ça et on peut choisir

autocomplétion: touche TAB

CTRL r: recherche
CTRL c: arrêter un processus en cours
CTRL u: efface la ligne tapée
CTRL d: exit

dans un terminal:
CTRL-SHIFT-c: copier
CTRL-SHIFT-v: coller

aide sur une commande:
----------------------
stockée dans l'applicatif
commande -h
commande --help
stockée dans un répertoire à part
man commande
man se trouve dans /usr/share/man
ce sont des fichiers compressés. il y en a 8 (man -1 -> man -8)
en français:
info commande

système de fichier:
——————-
ext equivalent FAT16
ext2 equivalent FAT32
ext3 equivalent NTFS
reiserFS n’existe pas sous windows simulation de la taille de blocs
LVM: couche de LVM ne va contenir qu’un gros fichier qui va se répartir et se réorganiser tout seul

les programmes ne se basent pas sur l’extension pour détecter le programme pour l’ouvrir mais sur le type MIME. C’est ce que fait windows.

Les droits
———-
R-W-X

le problème de la fragmentation n’existe pas sous linux. C’est dû à la façon de remplir le disque.

pour ouvrir avec nautilus
————————-
ouvrir une fenêtre
edit -> preferences -> onglet behaviour -> always open in a browser window

les répertoires
—————
/bin : les executables
/boot: les noyaux, tout ce qui est nécessiare au noyau ( et GRUB)
/dev : les peripheriques, hardware,…
/etc : tout ce qui est configuration (rc.d: les scripts de démarrage)
/etc/rc.d (r configuration.demon)
/etc/X11/xorg.conf ()
/etc/sysconfig (peripheriques specifiques: )
/etc/cron
/etc/skel
/home: tous les répertoires des utiisateurs
/home/user: seul root a acces à tout, user ne peut acceder qu’à /home/userx
/lib : les librairies utilisées par les binaires de base (/bin)
on y trouve aussi les modules du noyau linux
/mnt devenu aujourd’hui /media: monter les disques qui ne sont pas montées de base (clé usb)
/opt : répertoire des programmes que l’utilisateur gère (optional)
pgm externes installées par l’utilisateur
/proc: pseudo repaertoires comme /dev qui permet de voir l’état de la machine(processus) (cpu, ram, …)
/root
/sbin : tous les binaires qui ne sont ni utilisables par les users ni necessaires au démarrage -> utilisable par root uniquement
/usr: tout ce qui est disponible pour tous les utiliateurs
/usr/X11R6
/usr/bin
/usr/doc
/usr/share: bordel (icônes, images, ..)
/usr/src : on recommande de placer là les sources des programmes qu’on fait
/var : fichier variables
/var/spool : mails
/var/log : fichiers de log

COMMANDES ESSENTIELLES:
———————–
cd: change directory
********************
. : répertoire courant
cd .. : remonter dans l’arborescence
rep absolu : cd /home/…..
rep relatif: cd ….. (basé sur le rep courant)
cd ~ : rep personnel
cd : idem

pwd: print working directory:
*****************************
si on ne sait plus où on est dans l’arborescence:

ls: list:
*********
lister le contenu du rep courant
ls -a: all
ls -l:
ls -lits:
on peut faire ls -a /home (où que je sois dans l’arborescence)

glob: tout ce qui est joker (*, ?, [])
*****
faire man glob
—————————————————–
REPERTOIRES
mkdir nom_rep(abs. ou rel.): make directory
*******************************************
créer répertoire

rmdir nom_rep(abs. ou rel.): remove directory
*******************************************
supprimer répertoire (il DOIT être vide !!!)
——————————————————
FICHIERS
touch nom_fic(abs. ou rel.):
****************************
créer fichier

rm nom_fic(abs. ou rel.): remove file
*************************************
supprimer fichier
rm -r nom_rep: suprimer RECURSIVEMENT un répertoire non-vide et tous les fichiers qu’il contient
rm -rf: pas de confirmation

cp fic1 fic2 (on peut mettre des noms relatifs)
************
copier fic1 dans fic2 si fic2 n’existepas, il est créé et s’il existe, il est écrasé

cp rep1 rep2: erreur: il ne copie pas le contenu
cp -r rep1 rep2: ok

cp -r /home/toto /home/jp: va créer jp va copier le contenu dans jp
cp -r /home/toto /home/jp/: va créer toto DANS jp à cause du /
cp -u: ne copier que les fichiers de tot qui sont les plus récents
cp -i: il va demander si il faut ecraser
-> cp iu, c’est mieux si on le fait à la main
cp -u c’estmieux si on fait backup auto dans un cron
cp -a: faire un backup (-a = -dpr)
cp -d: permet de garder les liens symboliques
cp -p: permet de conserver les droits
cp -r: recursif pour les REPERTOIRES

mv fic1 fic2 : move
mv /home/toto/fic1 home/toto/Desktop
mv /home/toto/fic1 home/toto/

mv rep1 rep2 : pas besoin de mettre -r ici car ici, l’OS sait que c’est récursif

mv fic1 fic2: renomme un fichier sans le déplacer

————————————————-
du /home: disk usage (specifique à un répertoire)
du -s: donne la taille sans donner les details fichier par fichier
du -sh: (h=human readable: ne pas avoir la taille en octets)

df -h: la place qui reste sur les disques (specifique à un disque)

cat /home/fichier.txt: pour lire le contenu d’un fichier et l’afficher à l’écran
****
cat /home/fichier.txt: va afficher tout et tant pis si on n’a pas le temps de lire
more /home/fichier.txt: idem cat mais permet de naviguer vers le bas
less /home/fichier.txt: idem mais permet de naviguer vers le haut et le bas (pgup/pgdown)
pour quitter ces 3 commandes: taper “q”

commande specifiques:
head -x: pour voir les x premières lignes
tail -x: pour voir les x dernières lignes

sort: lister le fichier par ordre alphabetique:

wc: word count: compter
wc : compte w, c, l
wc -w: compter les mots
wc -l: compter les ligne
wc -c: compter les caracteres

outils de recherche:
——————–
find rep : rep dans lequel il va chercher
find –size=0 taille superieure à zero

locate .txt: avantage: on lui donne un nom ou un morceau de nom et il va chercher dans une base de données tous les fichier qui contiennent .txt

updatedb: ne peut de lancer qu’en root. Mettre à jour la db dans laquelle va chercher la commande locate

grep: pour faire une recherche à l’intérieur d’un fichier
grep -r mot fichier

wich: permet de déterminer l’exécutable utilisé et où se trouve cet exécutable
wich commande

file: commande pour déterminer le type d’un fichier (se base sur la BD MIME)

split: commande pour…

les pipes: | : effectuer une redirection
permet d’utiliser la sortie d’un fichier comme entrée pour un autre
cat fichier | more
cat fichier | head -10 | less

cas où le | est très utilisé aussi: find * | grep mot
exemple: savoir dans quel groupe on est en tant que user
cat /etc/group |grep seb

redirection de type INJECTION
cat fichier.txt|sort > fichier_trie.txt

si on veut rediriger la sortie d’erreur au lieu de la sortie standard:
—————
md5sum /usr/bin/* | sort > fichier.txt 2> erreur.txt
>: rediriger la sortie standard vers…
2>: rediriger la sortie std vers…
1&2>: rediriger 1 et 2 vers…
&>: idem

cat /dev/mice > toto.txt
ecrasement
cat /dev/mice > toto.txt

ajouter une ligne à la fin d’un fichier?
>>: rediriger deux fois ajoute des lignes à la fin du fichier

more < cat fichier.txt | sort |...
on prend un fichier et on met son contenu dans...?
entrée < fichier
l'entrée va chercher ses infos dans un fichier
on mets "-l" dans ls.txt
si on fait ls

SLPIT
-----
commande split permet de partager un fichier
split -b 1k fichier_à_découper debut
on va avoir debutaa, debutab, debutac, ..., debutaaa, ...

l'inverse de SPLIT: CAT
-----------------------
cat permet d'afficher à la suite une série de fichier
cat debutaa debutab...
cat debut*
au final on fait: cat debut* > fichier.txt

Utilitaires pour vérifier qu’aucun paquet n’a été corrompu:
md5sum
md5sum du fichier original et sur le fichier recomposé
md5sum debut*> md5.txt
md5sum debut*> verif.txt
diff md5.txt verif.txt: si diff n’affiche rien, c’est bon

si les 2 md5 sont différents, il y a eu corruption
——————————————————————————
exercices:
afficher de la ligne 27 à la ligne 43 d’un fichier
cat fichier | head -43 | tail -17

ecrire dans un fichier les groupes auquels on appartient classé par ordre alphabetique inverse
cat /etc/group | grep root |sort -r > /root/Desktop/fichier.txt

compter le nombre de fichiers qui contiennent le nom de votre utilisateur sur la machine
cat / | grep root | wc ()
locate mot
—————————————————————————–
COMPRESSIONS
tar.gz ou tgz (gunzip)
tar.bz2 ou tbz

c= creer
tar= concaténé mais non-compressé

tar -cf resultat.tar *
tar -cf nom_de_l’archive_qu’on_veut_générer les_fichiers_qu’on_veut_mettre_dedans
tar -czf : pour compresser en même temps en gzip
tar -cjf : pour compresser en même temps en bz2
rat -v : pour voir les fichier qu’on (dé)compresse
f doit toujours être le dernière option écrite car elle doit précéder le nom du fichier

—————————————————————————————–
—————————————————————————————–
jour2
UTILISATEURS:
————-

chaque user a un UID (user ID). les UID commencent à 1000
le seul à avoir un ID toujours le même, c’est root: ID 0

Changer d’utilisateur: 2 méthodes:
fermer session + (login+mdp)

su xxx: switch user
mais les paramètres d’environnement sont conserves
su - xxx:
les param d’environnement de xxx sont aussi appellés
c’est comme si on se déloggait de son login et qu’on se reloggait

si on fait ls -l:

droits associées à ce fichier dont le nom se trouve en bout de ligne
user
groupe primaire de l’utilisateur

seul root a le droit de changer l’utilisateur d’un fichier ou le groupe
mais un utilisateur peut changer de groupe

chown: changer propriétaire: change owner
—–
$ chown :groupe fichier
# chown utilisateur:groupe fichier

chmod: changer les droits : change mode
premiere façon de l’utiliser: utiliser les lettres
même si certains chmod peuvent accepter u+x u-w fichier, la seule ecriture resant valalble partout est:
chmod u+x fichier
chmod u-w fichier
chmod o+w fichier
chmod g-x fichier

chown user:group fichier -> on n’est pas obligé de mettre le user si on attribue le fichier à un groupe
chown :group

deuxième méthode: (r=4, w=2, x=1)
chmod 744 fichier: donner en même temps les droits à l’utilisateur, au groupe, au reste du monde

ajouter un user:
—————-
useradd -g eleve -G ecole, classe1 eleve1
useradd -u 1016 -g users -G cdrom, usb, groupe2, groupe3 -n -d /home/share -s /bin/bash nom_user
-u nom de l’utilisateur
-g son groupe par defaut
-G tous les autres groupes auxquel il appartient
-n evite qu’un groupe du nom de l’utilistaeur soit créé
-M evite de créer un rep personnel (incompatible avec -d)
-d crée le rep personnel
-s le shell qui va être utilisé
-e date à laquelle on veut que le compte soit effacé
-k permet de choisir le rep dans lequel on place la personnalisation (icônes,…)(normalement dans /etc/skel (skeleton))
-c commentaires

useradd -D: permet de savoir quelles sont les options par defaut lors de l’utilisation de useradd (s’utilise sans nom!!!)

comment savoir à quoi correspond 100 quand on tape useradd?
cat /etc/group | grep 100

là, on peut pas encore se logger car on n’a pas de passwd
il faut générer un passwd par defaut
root peut mettre ce qu’il veut
un utilisateur peut changer son mdp mais avec des restrictions (min un caractere special, min 6 car, pas du dico, pas systématique(123456) )

userdel (-r) user : avec -r: vire aussi le rep personnel et pas de confirmation!!!
——————-
modifier un user:
—————–

usermod même chose que useradd

GROUPES
——-
groupes primaires:
si un user crée un fichier: groupe primaire (par defaut) et masque par defaut pour les droits (umask)
pour définir/changer le groupe par defaut de façon TEMPORAIRE:
newgrp groupe1

voir les groupes auxquels on appartient:
id ou groups

gpasswd: donner un mdp pour un groupe en particulier
un groupe qui a un mdp peut être utilisé par un utilisateur qui ne fait pas partie du groupe
si je fais un touch sur ce fichier, le fichier fera partie de ce groupe

chgrp: pour changer le groupe primaire de manière PERMANENTE

umask -S (le -S n’est pas obligatoire)
u=rwx, g=rw, o=r

pour le faire en chiffres, on ne mets pas le S
les droits inverses de ceux qu’on aurait mis avec un chmod
umask 0013: 3 = 2+1 = w+x: je ne donne ni x ni w mais je donne R
le premier 0, on verra ça plus tard

exemples: umask u=rwx, g=rwx, o=rwx
umask 0000

/etc/passwd: anciennement, le fichier qui contenait tout sur les utilisateurs
user:x:0:0:nom_complet_de_user:rep_utilisateur:shell par defaut
x = anciennement mdp mais plus ménant

/etc/shadow: le répertoire où il y a les mdp
user: mdp en md5 amélioré: le nombre de jours en date UNIX (1/1/1970): le nombre de jours sans modifiction du mot de passe: nombre de jours fixé entre 2 chgts de mdp: nombre de jours à partir duquel un avertissement est envoyé pour chgt mdp: nombre de jours de désactivation sans chgt de mdp: nombre de jours avant désactivation après chgt de mdp (syllabus 6.2.2)

pour les groupes, c’est +/- la même chose
/etc/group
nom_grp:x: gid: user1, user2, user3,…
x = anciennement mdp mais plus ménant

pas beaucoup d’options pour les groupes:
groupadd -g nom_group
-g: definir un groupid
groupdel nom_group

toutes les opérations dans le groupe vont se faire avec la commande gpasswd
gpasswd -a user groupe (ajouter un user)
-d user groupe (supprim un user)
groupe (associer un mdp)

definir un ADMINISTRATEUR du groupe:
gpasswd -A user1, user2 groupe

virer l’admin:
gpasswd -A “” groupe

commandes pour lister les users connectés:
——————————————
users: commande sur les utilisateurs connectés
w: :0
:0 : dans quelle session graphique on est connecté
pts: consoles graphiques (?)
TTY: vraie console (?)
:0.0 première console graphique sur le premier écran
login@: heure de login
idle:
heure de login
temps depuis lequel il n’a plus rien fait

dernière commande utilisée

who -h: moins de détails (-h permet d’avoir les headers - les noms des colonnes)

last (-x): toutes les x dernières connexions avec des details - c’est une sorte d’historique
lastlog -u root: dernier log pour l’-u-tilisateur root

/var/run/utmp
/var/log/wtmp
/var/log/lastlog

touch /var/log/btmp
touch /var/log/faillog
il suffit que ces deux fichiers soient créés pour être utilisés

————————————————————————————————-
Exercice:
créer groupes: ecole
prof
eleve
classe1
classe2
classe3
créer users: 3 eleves dans classe1 (élèves de l’école) (groupe par defaut: eleve)
3 eleves dans classe2
3 eleves dans classe3
3 profs: groupe par defaut: prof

pour voir: cat /etc/passwd

créer les répertoires /usr/share/ecole/
/usr/share/ecole/prof
/usr/share/ecole/eleve/classe1
/usr/share/ecole/eleve/classe2
/usr/share/ecole/eleve/classe3

mkdir /usr/share/ecole/eleve/classe1
…

mettre les droits pour que seuls les membres des groupes aient acces en rw (et x)
chmod 770 /usr/share/ecole/eleve/classe1
…
remarque chmod -R : recursif…

lier les rep aux propriétaires
chown :prof /usr/share/ecole/eleve/prof
chown :classe3 /usr/share/ecole/eleve/classe3
…

jusqu’à present, tout appartient à root. il faut changer

changer les umask pour que, chaque fois qu’un utilisateur crée un truc, il soit en 770
1°) mettre un mot de passe aux users
2°) logger en tant que user
3°) umask 007

LES LIENS
———

toujours ecrire des chmins absolus quand on crée des liens

le lien en dur (le vieux…) ln
——————————-

!!! un lien en dur ne marche que sur des fichiers. ça ne marche pas sur des répertoires !!!

touch fichier.txt -> stocké quelque part sur le disque et on va avoir un inode dans notre répertoire
ln /home/toto/fichier.txt-> le lien en dur permet d’avoir à 2 endroits un lien vers le même fichier (le même inode)

avantage: on peut gérer les droits au même fichier de manière indépendante

inconvénient: si on fait un “du”: il fait 2*la somme de la taille du fichier
si on fait un “rm”, il vire le lien mais pas le fichier
on doit virer jusqu’au dernier lien hard pour que l’espace puisse être libéré

lien symbolique: ln -s (+- raccourci)

ln -s /home/toto/texte1.txt /home/toto/texte2.txt (fichier d’origine - lien symbolique)

va pointer vers l’entrée de ce ficher dans le système de fichier et pas directement vers le fichier
ln -s /home/toto/fichier.txt
si on fait un “rm”, le fichier est réellement effacé mais pas le lien symbolique qui sera considéré comme cassé si on fait un ls -l (montrer les liens symboliques)

inconvénient: pas une aussi bonne gestion des droits: on peut les diminuer mais pas les augmenter

pour modifier un lien symbolique: ln -sf: pour le forcer à le supprimer et le recréer
on a le lien créé par: ln -s /home/toto /home/jp

on modifie par: ln -sf /home/hubert /home/jp
f = force

devices de type bloc devices de type character
——————– ————————-
disques et periphériques de stockage souris (/dev/mouse - mice - )
hda
hda1
hda2
ont une priorité inférieure ont une priorité supérieure car on ne peut pas redemander l’info
cat /dev/sda1 cat /dev/psaux

/dev/par1 -> port parallele
/dev/lp1 -> imprimantes
/dev/tty -> consoles
/dev/ttys1 -> ports serie

“pérpheriques” particuliers
————————-

/dev/random
/dev/urandom
fournissent des nombres aléatoires

/dev/zero
fourni des zero

/dev/null
“trou noir”
si on fait un cat /dev/zero > /dev/null
ça va tourner à l’infini
machinchose > /dev/null

MONTAGE DE PERIPHERIQUES
————————

prevoir un point de montage: chemin dans le système de fichiers
repertoire qui doit être vide

créer:
cd /media
mkdir disqueC
cd disqueC

monter (mount: root uniquement peut mettre les 2 param):
********************************************************
# mount -t /dev/hdc1 /media/disqueC (-t = type)
par defaut, mount va essayer de detecter le type de formatage (FAT32, …)

automatiser mount:
tous les periphériques montés automatiquement sont souvent déclarés dans /etc/fstab/ (fichier statique - )
/dev/origine /montage /type options bits de dump bit de pass
auto
noauto (pas monté automatiquement au démarrage)
user (un utilisateur peut dé-monter et tout le monde peut utiliser le periph monté)
(gestion des droits classique)
users (tout le monde peut monter/démonter et utiliser le periph monté)
rw, ro sont des options d’écriture
udi=toto, gid=users (comme il n’y a pas de gestion des droits dans windows,
ça, ça donne accès à un disque windows. si on ne mets rien, ça appartient à root)

mtab (pseudo-fichier dynamique)
c’est là-dedans que tous les peripheriques types clé usb sont montés

cat /etc/mtab

montage par un utilisateur:
***************************
Ne peut spécifier qu’un seul des 2 param:
soit origine(entrée dans /dev: le peripherique en tant que tel), soit destination(point de montage)
$ mount /media/cdrom
/dev/sda1

FORMATER UNE PARTITION:
***********************
mkfs .ext2
.vfat
.reiser
mksf -t ext
mke2fs

fsck: file system check
uniquement sur un disque démonté !!!
fsck -v -a
-V:afficher ce qu’il fait (verbose)
-a: (sans demander de confirmation, va deplacer dans lost+found)
-t: quels types de fichiers

—————————————————————-
composition de /boot:
vmlinuz:le noyau en tant que tel
config: fichiers textes (modules et modules compilés)(on peut s’en passer)
initrd: amorçage
system.map: modules, compilés, pour le système
—————————————————————-

PARTITONNEMENT
————–
fdisk: dans CentOS, c’est la version interactive de fdisk
options: m: liste des options
p: “print” des partitions
d: delete: supprimer une partition
n: créer une nouvelle partition
n° partition
premier block
taille des blocks
donner un label
t: choisir le type de partition (fs)
l: lister les types
q: quitter sans sauver
w: quitter en sauvant

fdisk /dev/sda
fdisk “hdd qu’on veut partitionner”

—————————————————————————
toutes les commandes à exécuter, il les exécute sur la machine.
Il va les chercher dans $PATH
dans $PATH, il y a les rep suivants: /root/bin/, /usr/bin, /usr/local/bin
$./executable
$/home/sim/executable

export PATH = PATH…???
—————————————————————————
PROCESSUS SYSTEMES
——————
un programme va être chargé du disque vers la RAM, un PID va lui être attribué et va être exécuté
commande ps : lister les processus dans la console
-a: voir tous les processus à moi dans tous les terminaus à moi
-u: de tous les users lancés en mode console
-x: tous les processus généré par le système SAUF ceux de root
on peut écrire ps aux
utilisateur PID utilisation CPU derniere commande passée

on voit tous les processus lancés les uns en-dessous des autres
comment voir les processus lancés parents-enfants: commande pstree

commande top:
————-
voir les processus qui tournent en temps réel
* A: PID = Process Id
* E: USER = User Name
* H: PR = Priority
* I: NI = Nice value
* O: VIRT = Virtual Image (kb)
* Q: RES = Resident size (kb)
* T: SHR = Shared Mem size (kb)
* W: S = Process Status
* K: %CPU = CPU usage
* N: %MEM = Memory usage (RES)
* M: TIME+ = CPU Time, hundredths
b: PPID = Parent Process Pid
c: RUSER = Real user name
d: UID = User Id
* F: GROUP = Group Name
g: TTY = Controlling Tty
j: #C = Last used cpu (SMP)
p: SWAP = Swapped size (kb)
l: TIME = CPU Time
r: CODE = Code size (kb)
s: DATA = Data+Stack size (kb)
u: nFLT = Page Fault count
v: nDRT = Dirty Pages count
y: WCHAN = Sleeping in Function
z: Flags = Task Flags
* X: COMMAND = Command name/line

killer un processus:
——————–
kill: pas bien

reload: SIGHUP ( -1)
arrête-toi proprement mais vite: SIGINT ( -2)
termine( avec opérations de clôture): SIGQUIT ( -3)
arrêt brutal: SIGKILL ( -9)
arrête-toi quand tu as envie: SIGTERM (-15)

kill -SIGKILL “pid”
kill -9 “pid” arrêt du processus

killall “nom_de_l’application”

priorité des processus:
-20 ->12 lancé par root
0->12 lancé par user
il y a aussi RT… ?

élevé: système
bas: graphique

nice -n val nom_du_programme
renice val pid

CONTROLER LES PROCESSUS AVEC UN TERMINAL
—————————————-
gedit toto.txt
on ne peut rien faire tant qu’on n’a pas fermé le processus
CTRL-z: mettre le procesus en pause - il écrit [xxx] nom_du_processus
bg: prend le dernier processus mis en pause et le mets en arrière-plan

pour récupérer un process:
fg: reprend le dernier mis en arrière-plan
si on veut en récupérer un autre, on met fg[xxx]

gedit toto.txt &
le & permet de garder la main sur la console
fg marche aussi ici

problème: un processus est toujours lié à un terminal
-> si on ferme un terminal, tous les processus se ferment aussi
-> nohup: ne pas lier le processus à la console (PAS DANS LES NOTES!!!)
nohup gedit toto.txt &

——————————————————–
watch cat /proc/cpuinfo
watch (souvent utilisé avec un cat) fonctionne comme un top
dès qu’un fichier est modifié, il mets à jour l’affichage de la liste du fichier ouvert qu’on surveille

cat /proc/devices: fichier contenant les peripheriques classés par bloc/character

——————————————————–

ressources utilisées au niveau de la swap et de la RAM: commande “free”
avoir des infos sur la version, le noyau, le nom d’hôte: commande “uname”
-a: all
-m: type de machine
-n: hostname
-r: version
-s: OS
-v: date où le noyau a été compilé

pour installer le nouveau hardware:

lspci: permet de lister le hardware et d’avoir des infos dessus
-v: verbose: plus d’info sur chaque peripherique
-vv: super-verbose: encore + de bla-bla
ça veut dire quoi, SMP ???
——————————————————–

installation from scratch:
compiler à partitr des souorces:
1°) récuperer les sources (souvent un targz). souvent sur www.sourceforge.net

2°) décompresser dans /usr/src
on rentre: cd /usr/src
tar -xvzf /home/toto/Desktop/www.targz
on rentre dans le rep decompressé: cd /usr/src

3°) vérification de la configuration
vérifier que tout ce qui est nécessaire va fonctionner (pas de gestion de dependances)
si l’archive est bien faite, il va avoir dans la racine l’utilitaire et le répertoire configure
./configure: va vérifier que tout est là
si success à la fin: => génère un fichier makefile

4°) compiler
make (va chercher ça dans makefile)

5°) installation: il faut être root
make install

make clean
make mrproper

6°) execution…

———————————————————
quand on prévoit de lancer des commandes à la suite:
make && make install
make ; make install
une fois que make est fini, le make install se lance
;: il se lance même si echec.
———————————————————
lsof: lister des processus:

lsof -p “pid” lsof -p 1024
pour surveiller un keylogger, par exemple
keylogger: pgm qui va s’exécuter et enregistrer tout dans un fichier

exemple: fichiers qui sont courremment utiisés par gedit:
lsof -c gedit

lsof /media/cdrom: lister directement tous les users/processus qui utilisent un fichier/répertoire
lsof +D xxx: fichiers couramment utilisés dans repertoire xxx
———————————————————

GESTION DES PACKAGES red hat / debian
——————–
rpm (redhat package manager)/ deb
rpm: la commande rpm signale les dependances qu’il faut
rmp -i xxx.rpm

deb: debian
dpkg -i xxx.deb: idem
————————————————–
utilitaires qui gèrent les dépendances: yum / apt
yum: pour redhat

apt-get: pour debian
aptitude install: idem
————————————————–
interfaces graphiques pour les utilitaires:
yumex:

synaptic:
—————————————————–
OUTILS
——

pour travailler sur des images disques (mettre des fichiers ext3 sur un cd)
cd: mkisofs -R (rockridge) (garder les noms longs linux+ droits linux)
problème:va créer un fichier moved visible de tout le monde
ajouter –hide –rr–moved (pour masquer le répertoire)
–hide –rr–moved -V “nom du cd” -o image.iso
-r =R et rajoute a+r +garde les droits
-J (joliet) (garder les noms longs windows)

faire une copie: dd
dd if=/dev/hdc of=/dev/hda1
dd if=/dev/sda1 of=ghost.dsk

on peut monter les copies faites par dd en local
mount -o loop image.iso /media/iso

——————————————————-
recupérer un maximum de données:
********************************
photorec fait partie du package testdisk
chercher “testdisk” pour l’installer
photorec /dev/sda1
photorec backup.dsk
photorec.x/ tous les 500 fichiers
——————————————————-
pour graver en ligne de commande:

cdrecord -dev=/dev/dvd -speed=2 (blank= fast/all)

burnproof
driveropts= burnproof

-data fichier.iso

de cd->cd: -isosize /dev/cdrom

———————————————————
editeurs en lignes de commande

nano: le meilleur et le plus léger, qu’il dit, simon… tu entends ça, ronald?
vi
vim
emacs

————————-
cal: avoir un calendrier en ligne de commande
date: avoir la date en lmigne de commande

—————————-
clear

echo ‘texte’: permet d’afficher le texte
—————————-