Table des matières

Optimisation d'installation debian sur support CF / clef USB

optimisation, disque, SSD, CF, partition, partition alignement, tmpfs

Optimisation d'installation debian sur support CF / clef USB

Conseils pour installer une Debian sur un support ayant un nombre d'ecriture limité (carte CompactFlash, SD, clef USB, …)

La plupart de ces manipulations ont été testées sur :

ubuntu 10.04 installée sur le “SSD du pauvre” OCZ throttle (clef eSATA branchée en SATA) , utilisation: médiacenter
ubuntu 10.10 installée sur une Clef USB Corsair Voyager 8 Go , utilisation : desktop

Aligner les partitions sur les blocs physiques

Il faut aligner les partitions sur les blocks physiques des SSD : l'ecriture d'un bloc sur le filesystem ne se fera donc pas “a cheval” sur 2 blocs physiques et ne nécessitera donc pas d'ecrire 2 blocs, mais bel et bien un seul, d'ou un gain substantiel aussi bien en temps d'ecriture (/2) mais aussi pour la durée de vie des blocks.

En général les SSD ont des blocs physiques de 512k ou 2048k (a vérifier pour votre modele exact de SSD).

Un alignement a 2048k étant aussi aligné pour 512k, l'alignement 2048k est a privilégier si vous ne connaissez pas la taille exacte de blocs de votre SSD.

Cette création de partitions alignées ne sera pas décrite dans le détail ici, voir par exemple cette doc en anglais : http://blog.nuclex-games.com/2009/12/aligning-an-ssd-on-linux/

Utiliser un système de fichier non journalisé

Les systèmes de fichier journalisés (ext3 ou ext4 par exemple) écrivent continuellement un fichier journal des modifications sur le SSD, ce qui peut l'user prématurément.

En utilisant un système de fichiers non journalisé on évite l'écriture du journal sur le support : le système de fichier ext2 sera utilisé sur le SSD pour en maximiser la durée de vie.

Diminuer la fréquence d'écriture des partitions

Utiliser l'option relatime pour éviter d'écrire sur le disque la date du dernier accès en lecture lorsqu'il n'y a pas d'écriture. Il s'agit du meilleur compromis entre cohérence du système de fichier et minimisation des écritures sur le disque.

exemple de fstab correspondant pour le /:

UUID=38e729d4-d0ba-410c-8d09-155de85b646a /               ext2    defaults,relatime,errors=remount-ro 0       1

Placer les fichiers temporaires en mémoire vive

Pour faire ca il faut disposer d'un peu de RAM, mais vue le prix actuel, ca n'est pas un problème.

Le système utilise un certains nombre de fichiers temporaires, qu'il n'est pas nécessaire de conserver d'un démarrage à l'autre. Il est ainsi possible de les placer dans la mémoire vive (qui est vidée à l'arrêt de l'ordinateur) au lieu de les avoir sur la CF (cela peut ralentir le démarrage de certains logiciels, qui doivent recréer leur fichiers temporaires a chaque reboot, mais who cares)

Pour mettre les fichier temporaires en mémoire vive, voici un exemple de fichier /etc/fstab :

tmpfs      /tmp            tmpfs        defaults           0    0
tmpfs      /var/tmp        tmpfs        defaults           0    0
tmpfs      /var/cache/apt/archives tmpfs defaults          0    0

on pourrait utiliser quelques options de montage bien choisies pour /tmp comme par exemple :

tmpfs /tmp tmpfs size=25%,mode=1777,nodev,nosuid,noexec 0 0

Les logs sur un mediacenter, on s'en fout un peu , non ? On pourrait donc rajouter le /var/log dans la liste des tmpfs

Il faut cependant recréer les sous répertoires nécessaires lors de chaque reboot, comme par exemple /var/cache/apt/archives/partial : on peut placer ces commandes dans un script appelé au démarrage

Le répertoire /var/cache/apt/archives/partial/ mentionné ci dessous est maintenant (depuis la ubuntu 10.10 et contrairement la 10.04) recréé automatiquement et ne nécessite donc plus la manipulation décrite

Script de recréation de répertoires nécessaires lors du boot

pour créer automatiquement certains répertoires au reboot :

cat << EOF > /etc/cron.d/create_directories
# creer les sous repertoires des tmpfs au reboot
@reboot root /usr/local/sbin/createDirectoriesOnBoot.sh
EOF

chmod +x /etc/cron.d/create_directories

cat << EOF > /usr/local/sbin/createDirectoriesOnBoot.sh
#!/bin/bash
# cree les repertoires nécessaires (a cause du tmpfs sur les partitions)

DIRECTORIES="/var/cache/apt/archives/partial/"
for DIR in $DIRECTORIES; do
	mkdir $DIR
done
EOF

chmod +x /usr/local/sbin/createDirectoriesOnBoot.sh

Placer les profils utilisateur des logiciels en RAM

Les fichiers temporaire sont très souvent lus/écrits par les différents logiciels (FireFox par exemple) dans le profil utilisateur. Il s'agit ici de limiter les accès au SSD par FireFox, sans pour autant perdre tout son profil à chaque boot.

Le principe est donc d'utiliser une partie de la RAM comme répertoire de stockage du profil (appelé ramfs ou encore tmpfs) pour le profil FireFox pendant son fonctionnement :les lectures/écritures se feront alors dans la RAM et non pas sur le SSD.

Pour ne pas perdre son profil a chaque fois il suffira de sauvegarder ce profil sur le SSD a chaque arrêt de la machine (et de recopier cette sauvegarde en RAM lors du démarrage)

Création initiale (firefox non lancé) :

cp -r /home/jerome/.mozilla /home/jerome/.mozilla_ref

On monte en RamDisk le répertoire du profil FireFox : extrait du fstab :

tmpfs		/home/jerome/.mozilla	tmpfs	defaults,uid=jerome,gid=jerome        0       0

attention de bien adapter les login/uid/gid a votre cas

Pour la synchronisation on utilisera l'outil rsync qui fait de la copie incrémentale :
```
rsync -a /home/jerome/.mozilla_ref/ /home/jerome/.mozilla/
```

A l'extinction de la machine on sauve ce profile sur le SSD :
```
rsync -a /home/jerome/.mozilla/ /home/jerome/.mozilla_ref/
```

Ce principe peut bien sur être étendu a tout logiciel utilisant de manière intense les fichiers du profil utilisateur

attention toutefois a vous assurez que vous aurez assez de RAM libre pour continuer a utiliser votre ordinateur une fois le(s) profil(s) chargé(s) en RAM : en général un profil Thunderbird est tres gros ( ~700 Mo)

Vous n'avez pas envie de taper ça a la main a chaque fois ?
Je vous comprends :

Script de sauvegarde/restauration de profils

Voici un exemple de script à placer dans /etc/init.d/ qui réalise ces opérations.

Le –start est à appeler au demarrage de la machine (SSD → tmpfs) et le –stop a l'arrêt pour sauvegarder le profil (tmpfs → SSD) :

#! /bin/sh
# /etc/init.d/syncProfiles - synchroniser les profils utilisateurs entre la RAM (tmpfs) et le SSD

### BEGIN INIT INFO
# Provides:          syncProfiles
# Required-Start:    $local_fs $syslog
# Required-Stop:     $local_fs $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Synchonises user profiles between tmpfs and SSD/USB drive
### END INIT INFO

# utilisateurs par defaut lorsque ce script est appelé par root - sinon synchronise pour l'utilisateur courant
DEFAULT_USERS="jerome fred"

# liste profils a sauvegarder (les profils de sauvegarde seront suffixés en "_ref") séparés par des espaces
# pour sauvegarder/restaurer le ~/.mozilla, mettre "mozilla"
PROFILES="mozilla"

PATH=/sbin:/usr/sbin:/bin:/usr/bin
. /lib/init/vars.sh

. /lib/lsb/init-functions

umask 022

if [ "${USER}" = "root" ]
then
	USERS=${DEFAULT_USERS}
else
	USERS=${USER:-$DEFAULT_USERS}
fi

sync_start () {
    # synchro SSD -> TMPFS
    for USER in $USERS; do
        for profile in $PROFILES; do
            if [ -d /home/${USER}/.${profile}_ref/ ]
            then
	        rsync -a --delete /home/${USER}/.${profile}_ref/ /home/${USER}/.${profile}/
            fi
        done
    done
}

sync_stop () {
    # synchro TMPFS -> SSD
    for USER in $USERS; do
        for profile in $PROFILES; do
            if [ -d /home/${USER}/.${profile}/ ]
            then
                rsync -a --delete /home/${USER}/.${profile}/ /home/${USER}/.${profile}_ref/
            fi
        done
    done
}

do_start () {
	if [ "$VERBOSE" = no ]
	then
		log_action_begin_msg "Synchonising profiles SSD -> TMPFS for users ${USERS}"
		sync_start
		log_action_end_msg $?
	else
		log_daemon_msg "Will now synchronise profiles SSD -> TMPFS for users ${USERS}"
		sync_start
		log_end_msg $?
	fi
}
do_stop () {
	if [ "$VERBOSE" = no ]
	then
		log_action_begin_msg "Synchonising profiles TMPFS -> SSD for users ${USERS}"
		sync_stop
		log_action_end_msg $?
	else
		log_daemon_msg "Will now synchronise profiles TMPFS -> SSD for users ${USERS}"
		sync_stop
		log_end_msg $?
	fi
}

case "$1" in
  start)
    #echo "syncProfiles : synchro disque->RAM"
    do_start
    ;;
  stop)
    #echo "syncProfiles : synchro RAM->disque"
    do_stop
    ;;
  status)
    echo "syncProfiles: status OK"
    exit 0
    ;;
  *)
    echo "Usage: /etc/init.d/syncProfiles {start|stop|status}"
    exit 1
    ;;
esac
 
exit 0

Il faut ensuite faire exécuter automatiquement ce script au démarrage et a l'arrêt de la machine :
```
update-rc.d syncProfiles defaults
```

Minimiser l'usage de la partition swap

non testé : je n'utilise pas de swap sur ces machines

L'utilisation d'une patrition/fichier de swap est déconseillé sur une carte CF à cause du grand nombre d'écriture (sans tuning du moins)

Si on veut tout de même utiliser une parition swap (notamment pour bénéficier de l'hibernation), il faut en minimiser l'usage en editant le fichier /etc/sysctl.conf : rajouter à la fin :

vm.swappiness=0

Peut etre une idee en plus

Vu sur le net : a vérifier/voir l'intérêt

“Je rajouterais juste peut-être un petit tuning de /proc/sys/vm/dirty_ratio et /proc/sys/vm/dirty_background_ratio qui indiquent avec quelle agressivité le kernel écrit sur le disque les fichiers en cache (RAM). Je tiens ça des différents scripts de laptop-mode-tools, qui est l'utilitaire utilisé sur les portables pour améliorer l'autonomie. Tu peux t'en inspirer car il essaye en général de minimiser les accès disque.”

Minimiser la fréquence des écritures sur le SSD

Ajouter dans le fichier /etc/sysctl.conf :

vm.dirty_writeback_centisecs=1500

Cela modifie la valeur de l'intervalle (en centaines de millisecondes) entre les moments ou pdflush se réveille pour écrire les éventuels changements sur le disque.

On passe ainsi cette valeur à 15s au lieu des 5s par défaut.