Version : 1.0.fr.1.0
2007-05-04
| Historique des versions | ||
|---|---|---|
| Version 1.0.fr.1.0 | 2008-05-02 | LG, ED, JPG |
| Première adaptation française. | ||
| Version 1.0 | 2007-05-04 | FB |
| Première édition, révisée par TM. | ||
Résumé
Ce document décrit l'implémentation du TCP keepalive dans le noyau linux, présente le concept global et détaille à la fois la configuration système et le développement d'application.
Table des matières
Les droits de ce document, TCP Keepalive HOWTO, sont déposés sous copyright (c) 2007 par Fabio Busatto. Il est permis de copier, distribuer et/ou modifier ce document dans le cadre de la Licence de Documentation Libre GNU, Version 1.1 ou ultérieure publiée par la Free Software Foundation; aucune section invariable, pas de texte de couverture. Un exemplaire de la licence est disponible à l'adresse http://www.gnu.org/licenses/licenses.fr.html#GPL.
Le code source inclus dans ce document relève de la licence publique générale (GPL) GNU General Public License, Version 2 ou ultérieure publiée par la Free Software Foundation. Un exemplaire de la licence est disponible à l'adresse http://www.gnu.org/licenses/licenses.fr.html#GPL.
Linux est une marque déposée de Linus Torvalds.
En résumé, utilisez vos méninges et soyez prudent.
Dans la section suivante nous distinguerons les deux objectifs de keepalive:
_____ _____ | | | | | A | | B | |_____| |_____| ^ ^ |--->--->--->-------------- SYN -------------->--->--->---| |---<---<---<------------ SYN/ACK ------------<---<---<---| |--->--->--->-------------- ACK -------------->--->--->---| | | | le système meurt ---> X | | le système redémarre ---> ^ | | |--->--->--->-------------- PSH -------------->--->--->---| |---<---<---<-------------- RST --------------<---<---<---| | |
_____ _____ _____ | | | | | | | A | | NAT | | B | |_____| |_____| |_____| ^ ^ ^ |--->--->--->---|----------- SYN ------------->--->--->---| |---<---<---<---|--------- SYN/ACK -----------<---<---<---| |--->--->--->---|----------- ACK ------------->--->--->---| | | | | | <--- connexion supprimée de la table | | | | |--->- PSH ->---| <--- connexion invalide | | | |
Les fonctions impliquant keepalive utilisent trois variables manipulées par l'utilisateur :
Rappelez-vous que le support du keepalive, même s'il est configuré dans le
noyau, n'est pas le comportement par défaut de Linux. Les programmes
doivent requérir le contrôle du keepalive pour que ses sockets puissent
utiliser l'interface setsockopt. Relativement peu de
programmes implémentent keepalive, mais vous pouvez facilement ajouter le
support du keepalive pour la plupart d'entre eux en suivant les
instructions détaillées plus avant dans ce document.
Nous aborderons essentiellement comment procéder au travers de l'interface
procfs car elle est la plus utilisée, recommandée et la plus simple Ã
appréhender. L'interface sysctl, particulièrement sous l'aspect de l'appel
système (syscall)
sysctl(2) et non de l'outil
sysctl(8),
n'est là qu'à titre informatif.
Les deux premiers paramètres sont exprimés en secondes, et le dernier est un nombre simple. Cela signifie que les routines keepalive attendent deux heures (7200 secs) avant d'adresser la première sonde keepalive, et en adressent une nouvelle toutes les 75 secondes. Si aucune réponse ACK n'est reçue après neuf tentatives consécutives, la connexion est considérée comme rompue.
La modification de ces valeurs est directe : il faut écrire de nouvelles valeurs dans les fichiers. Supposons que souhaitiez configurer la machine pour que le keepalive débute après dix minutes d'inactivité sur le lien, et que des sondes soient envoyées chaque minute. En raison de l'instabilité de ce brin de votre réseau et de la faible valeur de l'intervalle, supposons que vous vouliez augmenter le nombre de tentatives à 20.
Voici comment paramétrer ces valeurs :
#echo 600 > /proc/sys/net/ipv4/tcp_keepalive_time#echo 60 > /proc/sys/net/ipv4/tcp_keepalive_intvl#echo 20 > /proc/sys/net/ipv4/tcp_keepalive_probes
Pour confirmer la prise en compte des nouvelles valeurs, affichez à nouveau le contenu des fichiers pour vérifier qu'ils présentent bien les valeurs souhaitées.
Il faut garder présent à l'esprit que procfs manipule
des fichiers spéciaux, et vous ne pouvez pas tout faire sur ces fichiers
qui ne sont qu'une interface vers l'environnement du noyau, non de
véritables fichiers. Testez vos scripts avant de les utiliser et faites
en sorte d'utiliser des modes d'accès simples comme dans les exemples
ci-dessus.
Vous pouvez accéder à l'interface grâce à l'outil sysctl(8), en précisant ce que vos voulez lire ou écrire.
#sysctl \>net.ipv4.tcp_keepalive_time \>net.ipv4.tcp_keepalive_intvl \>net.ipv4.tcp_keepalive_probesnet.ipv4.tcp_keepalive_time = 7200 net.ipv4.tcp_keepalive_intvl = 75 net.ipv4.tcp_keepalive_probes = 9
Remarquez que les noms sysctl sont proches des chemins
procfs. L'écriture se fait grâce à l'option -w
de sysctl
(8):
#sysctl -w \>net.ipv4.tcp_keepalive_time=600 \>net.ipv4.tcp_keepalive_intvl=60 \>net.ipv4.tcp_keepalive_probes=20net.ipv4.tcp_keepalive_time = 600 net.ipv4.tcp_keepalive_intvl = 60 net.ipv4.tcp_keepalive_probes = 20
Remarquez que sysctl
(8) n'utilise pas
l'appel système (syscall)sysctl(2), mais lit et écrit directement
dans l'arborescence procfs, donc procfs
devra être activé dans le noyau et monté dans le système de fichiers,
comme si vous accédiez directement aux fichiers via l'interface
procfs.
Sysctl(8) n'est qu'un moyen différent de faire la même chose.
int setsockopt(int s, int level, int optname,
const void *optval, socklen_t optlen)
Le premier paramètre est la socket, préalablement créée avec
socket(2); le second doit être
SOL_SOCKET, et le troisième SO_KEEPALIVE
. Le quatrième doit être un entier booleéen, indiquant que
l'option est active, alors que le dernier est la taille de la valeur
passée précédemment.
Conformément au manuel, le code retour 0
indique le succès, -1 est la valeur
d'erreur (et errno est correctement renseignée).
Il existe aussi trois autres options de socket qu'il est possible de
renseigner en écrivant votre application. Toutes utilisent le niveau
SOL_TCP au lieu de SOL_SOCKET,
et elles prennent le pas sur les variables système pour la socket
courante. Si vous lisez avant d'écrire, les paramètres système seront
retournés.
TCP_KEEPCNT : prend le pas sur
tcp_keepalive_probes
TCP_KEEPIDLE : prend le pas sur
tcp_keepalive_time
TCP_KEEPINTVL : prend le pas sur
tcp_keepalive_intvl
#grep 'socket *(' *.c
Cela vous montrera à peu près toutes les sockets du code. L'étape
suivante consiste à choisir les bonnes : vous ciblez les sockets TCP,
donc recherchez PF_INET (ou AF_INET),
SOCK_STREAM et IPPROTO_TCP (ou
plus communément, 0) dans les paramètres de votre
liste de sockets, et enlevez celles qui ne correspondent pas.
Il existe un autre moyen de créer une socket au travers de
accept(2). En ce ce cas, suivez les sockets
TCP identifiées et vérifiez si certaines sont en écoute : si c'est
le cas, gardez à l'esprit que
accept(2) retourne un descripteur de socket, qui doit être ajouté
à votre liste de sockets.
Une fois les sockets identifiées, vous pouvez procéder aux modifications.
Le patch le plus 'fast & furious' peut consister à simplement ajouter
la fonction setsockopt(2
) juste après le bloc de création de la socket.
Éventuellement, vous pouvez ajouter des appels supplémentaires pour
modifier les paramètres systèmes par défaut de keepalive. Surtout soyez
attentif au positionnement des vérifications d'erreurs et des handlers
de la fonction, peut-être en recopiant le style du code alentour. Songez
à affecter à optval une valeur non nulle et Ã
initialiser optlen avant d'appeler la fonction.
Si vous en avez le temps ou pensez que ce serait plus élégant, essayez d'implémenter complètement le keepalive à votre programme, en incluant une option de ligne de commande ou un paramètre de configuration pour laisser à l'utilisateur la liberté d'utiliser ou non keepalive.
Le projet libkeepalive a vu le jour pour faciliter l'implémentation du keepalive au sein des applications puisque le noyau Linux ne permet pas de le faire nativement (comme le fait BSD). La page d'accueil du projet libkeepalive est disponible à l'adresse http://libkeepalive.sourceforge.net/
Il consiste en une bibliothèque partagée qui outrepasse l'appel système
socket de la plupart des exécutables, sans aucun besoin de les recompiler
ni de les modifier. La technique repose sur la fonctionnalité de
pré-chargement (preloading) de
ld.so(8), chargeur inclus dans Linux, qui
qui permet le chargement de bibliothèques partagées avec une priorité
supérieure à la normale. Les programmes utilisent habituellement l'appel
de fonction socket
(2) situé dans la
glibc, librairie partagée; avec libkeepalive
il est possible d'encapsuler la fonction
setsockopt(2) juste après la création, retournant
au programme principal une socket avec keepalive déjà positionné.
En raison des mécanismes utilisés pour réaliser l'appel système,
ce procédé ne fonctionne pas lorsque la fonction socket est compilée
statiquement dans le binaire, comme dans le cas d'un programme lié par
l'option -static de
gcc(1
).
Après avoir téléchargé et installé libkeepalive,
vous serez en mesure d'ajouter le support de keepalive à vos programmes
sans être root au préalable, simplement en
initialisant la variable d'environnement LD_PRELOAD
avant d'exécuter le programme. Au fait, le super utilisateur peut aussi
forcer la pré-chargement au travers d'une configuration globale, et
les utilisateurs peuvent choisir de le désactiver en positionnant
la variable d'environnement KEEPALIVE Ã off.
L'environnement est aussi utilisé pour positionner des valeurs
spécifiques pour les paramètres de keepalive, vous avez donc la
possibilité de gérer chaque programme de façon distincte,
en initialisant KEEPCNT, KEEPIDLE
et KEEPINTVL avant de lancer l'application.
Voici un exemple d'utilisation de libkeepalive :
$testSO_KEEPALIVE is OFF$LD_PRELOAD=libkeepalive.so \>KEEPCNT=20 \>KEEPIDLE=180 \>KEEPINTVL=60 \>testSO_KEEPALIVE is ON TCP_KEEPCNT = 20 TCP_KEEPIDLE = 180 TCP_KEEPINTVL = 60
Et vous pouvez utiliser strace (1) pour comprendre ce qui se passe:
$strace testexecve("test", ["test"], [/* 26 vars */]) = 0 [..] open("/lib/libc.so.6", O_RDONLY) = 3 [..] socket(PF_INET, SOCK_STREAM, IPPROTO_TCP) = 3 getsockopt(3, SOL_SOCKET, SO_KEEPALIVE, [0], [4]) = 0 close(3) = 0 [..] _exit(0) = ?$LD_PRELOAD=libkeepalive.so \>strace testexecve("test", ["test"], [/* 27 vars */]) = 0 [..] open("/usr/local/lib/libkeepalive.so", O_RDONLY) = 3 [..] open("/lib/libc.so.6", O_RDONLY) = 3 [..] open("/lib/libdl.so.2", O_RDONLY) = 3 [..] socket(PF_INET, SOCK_STREAM, IPPROTO_TCP) = 3 setsockopt(3, SOL_SOCKET, SO_KEEPALIVE, [1], 4) = 0 setsockopt(3, SOL_TCP, TCP_KEEPCNT, [20], 4) = 0 setsockopt(3, SOL_TCP, TCP_KEEPIDLE, [180], 4) = 0 setsockopt(3, SOL_TCP, TCP_KEEPINTVL, [60], 4) = 0 [..] getsockopt(3, SOL_SOCKET, SO_KEEPALIVE, [1], [4]) = 0 [..] getsockopt(3, SOL_TCP, TCP_KEEPCNT, [20], [4]) = 0 [..] getsockopt(3, SOL_TCP, TCP_KEEPIDLE, [180], [4]) = 0 [..] getsockopt(3, SOL_TCP, TCP_KEEPINTVL, [60], [4]) = 0 [..] close(3) = 0 [..] _exit(0) = ?
Pour d'autres informations, visitez la page d'accueil du projet libkeepalive : http://libkeepalive.sourceforge.net/