Liens connexes

Dépêche modérée par

Dépêche éditée par

: Nouvelle version 2.6.33 du noyau Linux

Posté par patrick_g (page perso, ). Modéré le 25 février 2010.
120
La sortie de la version stable 2.6.33 du noyau Linux vient d'être annoncée par Linus Torvalds. Le nouveau noyau est - comme d'habitude - téléchargeable sur les serveurs du site kernel.org.

Le détail des évolutions, nouveautés et prévisions est dans la seconde partie de la dépêche (qui est sous licence libre CC BY-SA).

PS : Je tiens à remercier tout particulièrement Frédéric Weisbecker, premier contributeur en terme de patchs sur le noyau 2.6.33, qui a accepté de donner un peu de son temps pour répondre à mes questions. Vous trouverez un entretien en fin de dépêche.

PS 2 : Merci aussi aux relecteurs/correcteurs de cette (longue) dépêche.

> Lire la suite (213 commentaires, moyenne: 3,2).   [dépêche : 100085 caractères]

Le sommaire...

La phase de test ()

RC-1


La version RC-1 a été annoncée par Linus le 17 décembre dernier :

« Bon la période de merge est fermée et la RC-1 est maintenant disponible.
En parlant de période de merge, il y a eu un _paquet_ de branches qui n'ont envoyé leur demande de merge que très tard. Je suis habitué à avoir un dernier jour de la période vraiment très chargé, mais cette fois, ça a duré deux jours. Bien pire que d'habitude.
La période d'ouverture de deux semaines n'est pas supposée être "une demande de merge après un silence de treize jours". En fait, je pense que la prochaine fois, je vais réduire la phase à onze ou douze jours. Ainsi, les gens qui auront essayé de jouer au plus fin en envoyant leur demande au dernier moment auront une sale surprise. Ils seront obligés d'attendre le 2.6.35.
En dehors de ce grognement cela a été une phase assez classique, je pense. Les changements se répartissent en :
  • 1/3 dans la branche staging
  • 1/3 "le reste des pilotes"
  • 1/3 "tout le reste"
avec environ la moitié de ce "tout le reste" final qui concerne les diverses architectures et l'autre moitié les autres trucs (micrologiciels, systèmes de fichiers, réseau, etc.).
Les ajouts notables ? Personnellement, j'aime la façon dont j'ai enfin réussi à merger le code de Nouveau par exemple.
Merci de tester à fond cette RC-1, comme ça nous commencerons à avoir une idée au sujet des inévitables régressions
».

RC-2


C'est pile le jour de Noël que Linus a mis a disposition la version RC-2 :

« Joyeux Noël… ou quoi que vous célébriez aujourd'hui/demain.
Et, si vous ne célébrez rien du tout et que vous crevez d'ennui assis dans votre cave sombre, alors vous pouvez au moins essayer la dernière RC. C'est toujours mieux que de se morfondre sans rien faire.
Et si vous fêtez un truc, mais que vous avez une indigestion de jambon (ou que vous en avez marre de perdre tous vos vêtements dans des parties de strip et d'être la risée de tout le monde) alors faites une pause, compilez un noyau et essayez-le.
Parce que, si votre pantalon ne vous va peut-être plus pendant un mois, le nouveau noyau, lui, sera peut-être bien adapté à votre ordinateur.

J'aurais apprécié une RC-2 plus petite mais j'ai vu pire, donc je ne vais pas me plaindre.
Et maintenant je suis off, car je vais aller peler des patates. Et les manger ensuite.
Amusez-vous.
».

RC-3


Après cette interruption culinaire et digestive, il a fallu attendre le 5 janvier pour la RC-3 :

« Tout a été tranquille du fait des vacances et la RC-3 est raisonnablement petite en dépit de son retard de quelques jours. La plupart des changements sont triviaux, mais il y a eu des problèmes sur ext4 et ReiserFS dans la RC-2, avec un peu de chance tout est corrigé maintenant.
Le changement qui est peut-être le plus notable n'est pas une modification de code, mais le fait de recommander maintenant officiellement la "nouvelle" pile firewire par rapport à l'ancienne.
Espérons que l'une des raisons pour expliquer ce calme est que tout est réellement stable. Essayez-le !
».

RC-4


Une semaine plus tard, c'est la version RC-4 qui a été annoncée :

« Hmm. Une version bizarre. Il y a environ 40% des patchs qui concernent DRM (surtout nouveau et radeon, qui sont en staging, donc c'est un peu moins effrayant qu'il ne semble. Mais il y a aussi des trucs sur i915). C'est assez inhabituel pour autant que je sache. ».

RC-5


La version RC-5 a été annoncée le 21 janvier :

« Je ne pense pas qu'il y ait quoi que ce soit de renversant là-dedans, mais la modification du pilote KMS i915 est assez importante. Notamment, si vous avez un port eDP ("embedded DisplayPort" - Je pense que c'est une fonction que vous retrouvez dans un nouvel iMac), eh bien maintenant il fonctionne. Mais aussi, si vous aviez des problèmes de tremblement d'image du fait de la réduction de fréquence LVDS (ça économise du courant, mais c'est maintenant désactivé par défaut jusqu'à ce que ce problème soit résolu).
À part ça, c'est un bon paquet de petites corrections.
».

RC-6


C'est le 29 janvier que Linus a annoncé la disponibilité de la version de test RC-6 :

« Hmm. À peu près 50% des patchs sont sur les diverses architectures et 40% sur les pilotes. Le reste concerne principalement les systèmes de fichiers et le réseau.
Nous arrivons dans cette étape du cycle ou tout devrait plus ou moins "juste marcher" et où les gens qui découvrent des régressions devraient commencer à beugler très fort pour que ce soit corrigé
».

RC-7


Lors de la mise à disposition de la version RC-7 le 6 février, Linus a indiqué qu'il restait encore du travail à faire :

« Je dois admettre que j'aurais souhaité avoir moins de régressions à cette étape du processus. J'incite les développeurs à aller regarder sur la liste juste pour voir s'ils reconnaissent des régressions qui leur semblent familières. Prendre quelques minutes pour regarder cette liste et se dire "Hmm, peut-être que je connais celle-là" est une bonne idée.
Mais nous avons certainement corrigé un certain nombre de choses, et ça fait une semaine donc voilà la RC-7. J'aimerais pouvoir dire que c'est la dernière RC, mais j'en doute fortement et il y en aura presque certainement au moins une autre
».

RC-8


Enfin, le 13 février, Linus a annoncé la dernière version candidate avant la sortie du noyau officiel :
« Je pense que ce sera la dernière RC de ce cycle, donc s'il vous plaît testez-là bien. Un certain nombre de régressions devraient être corrigées et - même si la liste des régressions ne me rend pas _content_ - au moins nous n'avons pas ces sales trucs qui m'inquiétaient avant la RC-7 ».

Les nouveautés ()

Stockage distribué DRBD


Le système de stockage distribué DRBD (Distributed Replicated Block Device) fait maintenant partie du noyau Linux depuis cette version 2.6.33.
Écrit à l'origine par Philipp Reisner dans le cadre de son master d'informatique de l'Université technique de Vienne ce système de stockage est développé par la société LINBIT qu'il a fondée en 2001.
DRBD peut être compris comme un équivalent réseau du système de réplication RAID 1 (disques durs en miroir) et cela permet de construire des serveurs répartis de haute disponibilité avec des systèmes de fichiers distribués de type GFS ou OCFS2.
Les périphériques de stockages utilisent en interne des blocs de données. Ce sont ces blocs de bas niveau qui sont répliqués par DRBD sur plusieurs machines de façon automatique. Cette réplication peut se faire de façon synchrone (un bloc est considéré comme répliqué uniquement quand il a été écrit en local, envoyé vers le disque du nœud distant et que ce nœud distant a confirmé qu'il était correctement écrit) ou bien de façon asynchrone (un bloc est considéré comme répliqué quand il a été écrit en local et qu'il a juste été envoyé vers le nœud distant, sans confirmation en retour). On voit bien que la méthode synchrone est plus robuste mais qu'elle dépend de la vitesse du réseau. La méthode asynchrone peut impliquer des pertes de données (sans perte de cohérence toutefois) mais elle est utile pour des nœuds séparés par de longues distances avec une latence importante. Pour avoir une idée des performances ce test indique que la version synchrone (c'est le "protocole C" en langage DRBD) tombe à 163,8 Mo/s par rapport aux 239,8 Mo/s de la version asynchrone.

Actuellement DRBD ne supporte que deux nœuds mais cette limitation sera supprimée par la suite. Il y a plusieurs avantages de cette technique de réplication au niveau du bloc de données par rapport à une classique grappe de serveurs (cluster).
Tout d'abord les opérations de lecture de données, qui sont prépondérantes, s'effectuent purement en local puisque les données sont répliquées sur tous les nœuds. Plus besoin de passer par le goulet d'étranglement que constitue le réseau.
Ensuite et surtout la réplication de données est naturellement plus robuste que le simple partage qui est souvent utilisé dans les grappes de serveurs. La perte du réseau entre deux nœuds ne risque pas de provoquer de situation de conflit ou d'accaparement des ressources par les nœuds qui croient chacun que l'autre n'est plus actif.
Pour ceux qui désirent se plonger dans les entrailles techniques du système un fichier PDF explicatif est disponible ainsi qu'un guide d'utilisation détaillé.

Le patch externe implémentant DRBD a été soumis initialement sur la liste de diffusion du noyau en juillet 2007 mais il a été en butte à de nombreuses critiques et ses développeurs ont du le modifier profondément avant que Jens Axboe, mainteneur de la couche bloc, n'accepte finalement le patch.
Comme plusieurs distributions incluaient déjà ce patch dans leur noyau, cette entrée dans la branche principale est bienvenue et va permettre de réduire leur charge de maintenance des patchs externes.
Les utilisateurs de Linux pourront eux profiter de ce système fort utile pour réduire le coût des systèmes de haute disponibilité. Avec DRBD il devient possible de se passer des coûteuses machines spécialisées SAN et d'utiliser de simples serveurs Linux reliés entre eux par l'intermédiaire de ce système de stockage distribué.

Transaction TCP par cookie


La pile réseau du noyau 2.6.33 accueille les patchs initiaux du mécanisme de "transaction TCP par cookie" qui va permettre, quand l'implémentation sera complète, de résoudre deux problèmes réseau d'un seul coup.

En premier lieu la technique de "transaction TCP par cookie" (TCPCT pour "TCP cookie transactions protocol" en anglais) est une amélioration du mécanisme classique SYN cookies qui est en place depuis plusieurs années et qui permet d'éviter les attaques par flots de SYN (SYN flood attacks).
En gros l'attaque se déroule comme ceci : Le client envoie un message SYN au serveur (un message de SYNchronisation pour ouvrir une connexion) et le serveur répond par un SYN-ACK (la SYNchronisation plus l'accusé de réception ACKnowledgement). L'ennui c'est qu'après ça le client malicieux se garde bien de finir la troisième phase de la poignée de main en trois temps (Three-way handshake) et que le serveur reste le bec dans l'eau avec sa connexion ouverte jusqu'à la fin de sa durée d'activité (timeout). Si le client envoie un grand nombre de demandes de connexions qui restent incomplètes alors le serveur finit par être la victime d'un déni de service puisque toutes ses connexions sont ouvertes et attendent des réponses qui ne viendront jamais.
Daniel J. Bernstein a inventé le mécanisme "SYN cookies" pour contrer ce genre d'attaques. En résumé, après le SYN initial du client le serveur va lui renvoyer un SYN-ACK modifié et contenant un numéro de séquence haché par une clé secrète, un "cookie", et il va tout de suite fermer la connexion. Le serveur économise ainsi ses ressources et n'est plus susceptible d'être victime du déni de service. Quand le client répond par le ACK final, la troisième phase de la poignée de main, le serveur est capable de reconnaitre le client car il se base sur le numéro de séquence.
SYN cookies est une solution "bricolée" (un hack) mais ça fonctionne assez bien pour bloquer les attaques par flots de SYN. L'inconvénient de cette technique est qu'il devient impossible d'utiliser certaines options bien utiles du protocole TCP. De plus la sécurité du cookie est relativement faible et des techniques astucieuses permettent de leurrer le serveur.
La solution qui est apportée par la nouvelle technique de "transaction TCP par cookie" est simple. Le client va envoyer lui aussi, et ce dès l'étape initiale du SYN, un cookie signé cryptographiquement en direction du serveur. Le serveur se sert de ce cookie-client pour générer un cookie-serveur et le renvoyer au client avec son SYN-ACK. Il coupe ensuite la connexion et n'attends pas de réponse en dépensant des ressources pour rien. Le client renvoie alors le ACK final avec le cookie-serveur qui contient toutes les informations permettant au serveur de connecter le client comme si une poignée de main en trois temps normale avait eu lieu.
Cette solution élégante est bien plus sécurisée que SYN cookies et elle reste compatible avec les options du protocole TCP.

Le second avantage de cette nouvelle fonction de "transaction TCP par cookie" est qu'elle permet d'améliorer la mise en œuvre de DNSSEC (Domain Name System Security Extensions). Ce mécanisme de sécurisation du protocole DNS (qui fait la correspondance entre une adresse IP et un nom de domaine) a été conçu pour protéger de bout en bout les données échangées par DNS. L'ennui c'est que DNSSEC, outre sa grande complexité, impose de renvoyer des gros paquets. Ces paquets sont trop gros pour le protocole de transmission UDP qui est normalement utilisé par DNS. La taille d'un paquet UDP est de 512 octets alors qu'en moyenne DNSSEC exige 1749 octets. On peut bien entendu fragmenter les échanges en multiples paquets UDP mais cela pose de nombreux problèmes avec les pare-feu et les NAT. On peut alors basculer vers la solution de secours qui consiste à utiliser TCP à la place d'UDP… mais la charge de la machine augmente énormément puisqu'on répète sous TCP une requête qui n'a pas abouti sous UDP et qui a généré un timeout.
Comment faire ? La réponse est simple puisque le mécanisme "transaction TCP par cookie" permet d'encoder des informations dans les cookies-client et cookies-serveur ! Le mécanisme de "transaction TCP par cookie" se sert de cet espace pour permettre au client d'envoyer une requête DNS dans la première partie de la poignée de main et pour permettre au serveur de renvoyer la réponse. Plus besoin de fragmenter des paquets UDP ou d'attendre les interminables timeouts de bascule vers TCP puisque tout se fait directement dans TCP par l'intermédiaire des cookies.

L'article "improving TCP security with robust cookies" (au format PDF) permet d'approfondir le sujet et de mieux comprendre les avantages et les inconvénients de cette solution.
Et oui comme dans toute solution technique il y a des inconvénients. Le principal problème est que SYN cookies (la solution de Bernstein) ne nécessitait qu'une adaptation côté serveur alors que TCPCT impose aussi une mise à jour de tous les clients. Si on ajoute le temps que va prendre l'implémentation complète du protocole dans Linux (le 2.6.33 n'accueille que les patchs initiaux), le temps de déploiement dans toutes les distributions de ces noyaux complètement compatibles et enfin le temps de mise à jour des clients eux-mêmes, on peut penser que le déploiement généralisé est encore assez loin.

Compactage mémoire ramzswap


Une fonction de compactage de la mémoire nommée ramzswap (anciennement compcache) est entrée dans la partie -staging du noyau 2.6.33.
L'idée derrière compcache/ramzswap est de permettre aux LiveCD ou aux petites configurations (netbooks, vieux ordinateurs, clients légers, systèmes embarqués) d'avoir une capacité mémoire artificiellement augmentée grâce à la compression d'une partie des pages mémoires.
Pour cela un périphérique virtuel en mode bloc est créé à l'amorçage et ce périphérique va jouer le rôle d'une zone de swap dans laquelle les pages mémoire non utilisées depuis un certain temps vont être compressées et stockées.
Techniquement ramzswap utilise l'algorithme de compression LZO (par l'intermédiaire des modules noyaux lzo_compress et lzo_decompress) ainsi qu'un allocateur mémoire spécifique (xvmalloc). Cet allocateur est nécessaire car les développeurs ont découvert que ceux qui sont déjà disponibles dans le noyau Linux ne remplissaient pas leur cahier des charges très spécial. SLOB a une complexité linéaire, soit O(n), alors que xvmalloc n'a qu'une complexité constante en O(1). SLUB de son côté a une tendance à la fragmentation mémoire que xvmalloc permet d'éviter.

Pour utiliser cette fonction de compression de la RAM il suffit (outre les modprobe de chargement des modules) d'une initialisation avec un rzscontrol /dev/ramzswap0 --init suivie d'une activation avec swapon /dev/ramzswap0. Par défaut 15% de la mémoire sera utilisée pour stocker les pages mémoire compressées mais on peut changer ça avec l'option memlimit_kb.
Pour des raisons de performances et de montée en charge il est préconisé de créer autant de ramswap qu'il y a de cœurs de calcul sur la machine.
Ainsi si je veux un ramzswap de 256 Mo sur mon laptop bi-cœur je vais faire dans l'ordre :
modprobe ramzswap num_devices=2
puis
rzscontrol /dev/ramzswap0 --init --disksize_kb=131072
rzscontrol /dev/ramzswap1 --init --disksize_kb=131072

et enfin
swapon /dev/ramzswap0
swapon /dev/ramzswap1


Bien entendu toutes ces actions seront la plupart du temps exécutés par des scripts sur nos distributions/LiveCD et l'utilisateur de ramzswap n'aura vraisemblablement pas à se plonger souvent dans la page du manuel.

D'après les test de performances la fonction ramzswap est très efficace et elle permet vraiment d'être "à l'aise" dans des tailles mémoires non démesurées. Par exemple page dédiée du site de compcache donne les résultats de plusieurs expérimentations et le niveau de performance auquel on peut s'attendre lors de l'utilisation (L'expérience a montré que le taux moyen de compression était de 4 pour 1). Un client léger sous LTSP et ayant peu de mémoire peut ainsi utiliser kpdf pour ouvrir simultanément 11 fichiers PDF au lieu de 2 et peut utiliser Firefox pour ouvrir 15 pages webs au lieu de 6.

L'implémentation de ramzswap qui se trouve dans le noyau 2.6.33 est considérée pour l'instant comme préliminaire. Tout d'abord elle se trouve dans la partie -staging qui accueille le code non finalisé et surtout les développeurs projettent d'ajouter plusieurs fonctions avant de considérer que l'outil est vraiment complet. On peut donc à brève échéance s'attendre à voir apparaître un meilleur algorithme de défragmentation de la mémoire, une compression des pages de cache et une possibilité de redimensionnement adaptatif du swap de la mémoire.

Contrôleur IO-Block


Le noyau 2.6.33 accueille dans cette version un contrôleur des entrées/sorties en mode bloc.
Depuis un certain temps plusieurs groupes concurrents avaient commencé à travailler sur ce contrôleur dont le rôle est de faire un arbitrage entre les divers groupes de processus pour accéder aux précieuses ressources d'entrées/sorties. Grâce à ce contrôleur plus de risque qu'un groupe de processus ne monopolise le disque dur et n'affame ses petits camarades.
L'ennui c'est que les équipes de développeurs concurrents n'arrivaient pas à se mettre d'accord sur l'architecture globale qu'il fallait utiliser dans Linux. Comme l'explique très bien cet article LWN, il y avait trois concurrents pour entrer dans la branche principale : dm-ioband, io-throttle et io-controller.
Le premier, comme son nom le laisse supposer, s'appuie sur le mécanisme du device mapper (une couche d'indirection entre les périphériques blocs qui permet par exemple de faire du RAID logiciel ou du chiffrement de disques). Le second est un mécanisme qui s'implante à plus haut niveau que le device mapper mais qui est aussi plus invasif. Enfin le dernier candidat, io-controller, a choisi de s'interfacer directement dans l'ordonnanceur des entrées/sorties.
Après plusieurs mois de chamailleries sans issue entre les trois groupes il fallait bien désigner un vainqueur… mais comment faire ?
Andrew Morton a dit avec humour qu'il songeait à enfermer les développeurs de ces trois solutions dans une chambre verrouillée et à revenir 15 minutes plus tard pour voir qui est le gagnant.
C'est une solution moins coercitive qui a finalement été choisie puisqu'à l'issue du Linux Storage and Filesystem Workshop d'avril dernier les divers développeurs sont enfin tombés d'accord sur une stratégie de couplage avec l'ordonnanceur des entrées/sorties (io-controller remporte donc la mise) et lors du dernier mini-sommet d'octobre à Tokyo une stratégie globale en deux temps a été décidée.
Comme l'écrit Vivek Goyal :
« Le contrôle des entrées/sorties est un problème complexe et si nous essayons de tout résoudre d'un seul coup en un patch cela devient ingérable et rien n'est accepté dans le noyau. Donc lors du dernier mini-sommet nous nous sommes mis d'accord pour y aller par étape et une fois que le premier bout de code sera dans le noyau et bien stabilisé nous nous occuperons des étapes suivantes »

La première étape, celle qui concerne le noyau 2.6.33, voit donc l'inclusion d'un mécanisme de contrôle des entrées/sorties sur les groupes de processus à l'intérieur même de CFQ (l'ordonnanceur I/O par défaut de Linux). Ce nouveau mécanisme utilise bien entendu l'infrastructure cgroup qui a été introduite dans le noyau 2.6.24. Le nouveau cgroup se nomme "blkio" et il permet d'attribuer un poids au différents groupe de processus (avec une valeur comprise entre 100 et 1000).
La documentation indique comment se servir facilement de cette fonction.
On commence par créer deux groupes : mkdir -p /cgroup/test1/ /cgroup/test2

Et ensuite on fixe les poids respectifs :
echo 1000 > /cgroup/test1/blkio.weight
echo 500 > /cgroup/test2/blkio.weight


Le groupe test1 aura alors deux fois plus de ressources d'entrées/sorties que le groupe test2.

La seconde étape, concernant le contrôleur des entrées/sorties en mode bloc, sera implémentée dans les versions suivantes du noyau Linux. Afin de prendre des décisions d'allocation ayant une visibilité complète de la hiérarchie de stockage (Topology-aware scheduling) il est nécessaire d'inclure des composants à un plus haut niveau que celui de l'ordonnanceur CFS.
De même, les entrées/sorties asynchrones (buffered writes) ne sont pas gérées par le mécanisme actuel du noyau 2.6.33 et les développeurs s'en occuperont par la suite:
« Les entrées/sorties asynchrones c'est un gros bordel et cela réclame des changements dans plein d'endroits pour résoudre le problème. Comme le patch devient trop gros nous ne supportons que le contrôle des I/O synchrones pour le moment ».

Même si la solution de contrôle n'est pas encore complète et s'il reste du travail à faire, on peut constater que le noyau Linux avance dans la bonne direction. Les sommets divers qui sont organisés chaque année permettent vraiment aux développeurs de se parler et d'élaborer des compromis afin de développer des solutions techniques aux problèmes. Quant aux administrateurs, ils ont maintenant la possibilité de gérer finement les allocations de ressources entrées/sorties entre les différents groupes de processus.

Les pilotes Android retirés du noyau


Comme évoqué dans ce journal les pilotes Android ont été retirés par Greg Kroah-Hartman de la branche -staging du noyau 2.6.33. De nombreux commentaires intéressants à ce sujet peuvent être lus sur cet article du site Linux Weekly News. On a ainsi Chris DiBona, Engineering Manager Open Source à Google, qui affirme: « la réalité c'est que la branche principale ne veut pas notre code donc un fork est la réponse normale à cet état de fait ». Greg KH a immédiatement répliqué : « Ce n'est pas vrai. Nous ne voulons pas du code tel qu'il est mais c'est juste parce qu'il nécessite un gros travail. Ce n'est pas différent pour toutes les autres contributions au noyau ».

La discussion a été quelque peu acrimonieuse mais elle a également permis de lire plusieurs avis techniques. Apparemment c'est l'ajout de "wakelock" qui est apparu aux yeux de beaucoup de kernel hackers comme le point le plus problématique du code d'Android.
Wakelock est une fonction spécifique du noyau utilisé dans Android et qui permet d'empêcher le système d'entrer en phase économie d'énergie. Cela semble contre-intuitif de procéder ainsi mais la philosophie des ingénieurs de Google est que par défaut le système devrait toujours être dans cet état d'économie d'énergie. Si une application a besoin d'utiliser des cycles du processeur alors elle doit poser explicitement un verrou wakelock interdisant la mise en veille pour que le travail soit effectué. Sinon le système restera endormi par défaut.
En envoyant la commande WAKE_LOCK_SUSPEND le système ne pourra plus entrer en veille tandis que WAKE_LOCK_IDLE empêche le processeur d'entrer dans un mode à faible consommation. Tout ce mécanisme interne au noyau patché d'Android est accessible aux applications qui peuvent placer leurs verrous et les enlever par l'intermédiaire de /sys/power/wake_lock et /sys/power/wake_unlock.
Les développeurs du noyau Linux considèrent cependant que wakelock est un très vilain hack pour plusieurs raisons. Tout d'abord ce mécanisme est en grande partie redondant avec l'API pm_qos (Power Management Quality of Service) qui existe déjà dans le noyau. Si Android a besoin de choses très spécifiques alors le travail aurait du consister en l'ajout de fonctions à pm_qos et pas au développement d'une solution différente.
Autre problème : La gestion de l'énergie traditionnelle sous Linux qui se base sur des écritures de commandes dans /sys/power/state est désactivée par le patch wakelock d'Android car la compatibilité n'est pas prévue.
Les développeurs de Linux relèvent également que le code de wakelock est inutilement compliqué avec plusieurs possibilités différentes alors qu'en réalité tout cela pourrait en définitive se ramener à un simple indicateur pour empêcher la mise en veille.
Enfin si une application utilisateur se crashe au mauvais moment alors qu'elle détient un wakelock... dommage pour vous mais le système ne passera plus en veille !

Il faudra donc que Google réponde à toutes ces critiques techniques et arrive à convaincre les développeurs de la pertinence de sa solution si le géant américain désire vraiment intégrer son code dans la branche principale. Selon Chris DiBona il faut que les développeurs de Linux acceptent le code tel qu'il est car les besoins d'un système pour smartphone sont très différents des autres et nécessitent des solutions particulières : « Android n'est pas la même chose qu'un serveur relié à Internet et penser que Linux sur un mobile est la même chose que Linux sur un serveur explique pourquoi, avant qu'Android n'arrive, Linux sur les mobiles ne rencontrait presque aucun succès ».

Il lui a été immédiatement répondu que, même si le monde des systèmes d'exploitation pour téléphones est sans doute particulier avec des besoins spécifiques, on ne peut que constater que jusqu'à présent le noyau Linux a réussi à répondre aux besoins d'une très large gamme de machines (du gigantesque supercalculateur au minuscule ordinateur embarqué). La synergie permise par un développement unifié autour d'un seul noyau modulaire est une force redoutable et Google, avec son fork, refuse de jouer le jeu de ce développement unifié et choisit la fragmentation. Il est vrai que pour participer à ce jeu la barre est assez haute puisqu'il faut écouter les avis d'autres développeurs hautement expérimentés et accepter de modifier plusieurs fois son code afin de répondre à leurs critiques.
L'ennui c'est que ce retour de la communauté Linux n'a pu être pris en compte par Google qui a choisi de créer Android en secret. Les patchs concernant wakelock ont été postés sur la LKML seulement en février 2009 alors qu'Android était en développement depuis au moins l'année 2005 et le kit de développement des applications disponible depuis novembre 2007.
Google a vraiment jeté son paquet de code "par dessus le mur" comme disent les anglo-saxons (dumping code over the wall) sans aucune volonté de l'adapter aux exigences des mainteneurs de Linux.

Matthew Garrett a répliqué à Chris DiBona que le code d'Android pouvait être accepté si Google voulait bien faire l'effort d'écouter les remarques des développeurs du noyau : « Si le monde entier vous suggère de faire un truc de façon différente et que vous refusez alors cela ne constitue pas un effort honnête de travail en commun. Nokia a réussi à obtenir le même niveau d'économie d'énergie sans tous ces changements invasifs donc toute affirmation selon laquelle wakelock serait absolument nécessaire pour qu'Android atteigne ses objectifs est sans fondement ».
L'attitude des développeurs de Google ayant consisté à développer ce code secrètement et à refuser d'écouter les critiques techniques des autres développeurs a été jugé arrogante par plusieurs personnes. Le message résumant le mieux ce sentiment est celui de rahvin : « Je suis content que les développeurs Google aient participé à cette discussion. Ils m'ont appris quelque chose que je ne savais pas : Que Google et ses développeurs croient qu'ils ont raison quoi que pensent les autres. C'est peut-être un problème de culture d'entreprise. Ils croient vraiment qu'ils ont raison et que tous les autres ont tort.
Je pense que n'importe qui serait d'accord pour dire que parfois c'est mieux d'être en dehors de la branche principale mais c'est l'exception et pas la règle. Pour entrer dans la branche principale, il faut écouter les autres développeurs quand ils vous disent que votre code est une saleté, que votre solution est mauvaise et qu'il en existe une meilleure. C'est d'autant plus vrai quand ce sont tous les développeurs travaillant dans le même domaine (ici l'embarqué) qui vous disent que votre approche est mauvaise.
Pour moi c'est une révélation de constater à quel point les développeurs de Google sont arrogants au sujet de leur code
».

Cet avis est sans doute exagérément critique puisqu'il semble y avoir de la bonne volonté du côté des développeurs de Google pour collaborer plus avant avec la branche principale. Brian Swetland, ingénieur à Google, a ainsi expliqué: « J'aimerai bien discuter de tout ça dans un forum où le but est de résoudre des problèmes communs plutôt que de blâmer les gens. Nous savons que pas mal de gens auraient été plus contents si nous avions résolu tout ça avant que nous ne sortions notre version 1.0... mais ça ne s'est pas passé comme ça et argumenter à ce sujet n'apporte rien à personne. Comprendre comment collaborer afin que les problèmes futurs puissent être résolus plus tôt me semble en revanche bien plus productif.
Donc quand et où pouvons-nous nous rencontrer avec les autres développeurs qui s'occupent de la gestion de l'énergie sous Linux afin de parler de tout ça ?
».

On voit donc qu'il y a une chance que Google fasse l'effort d'adapter son code et le prochain rendez-vous est planifié pour le sommet "Power Management" du mois d'août à Boston.
La morale de l'histoire - comme toujours - est qu'il faut poster son code "tôt et souvent" afin d'obtenir un retour de la communauté, qu'il faut penser à intégrer la branche principale dès le début, avant même de sortir son produit, pour éviter d'être bloqué par la suite en cas de changement du code. Enfin, et comme le rappelle Jonathan Corbet, « les développeurs du noyau doivent travailler pour tout le monde alors que les développeurs de l'embarqué résolvent des problèmes spécifiques sous une forte contrainte de délai. Souvent ils ne pensent pas à étendre un mécanisme pré-existant qui pourrait répondre à leur besoin. Au lieu de ça ils bricolent en vitesse un truc bancal qui n'est pas soumis à un passage en revue par les développeurs de la branche principale. On pourrait penser que Google a le temps, les ressources et la connaissance du développement noyau qui lui permettraient d'éviter tous ces problèmes et faire les choses proprement. Au lieu de ça nous avons là un exemple classique de la façon dont les choses peuvent mal tourner ».

Intégration de Nouveau


Au début de la période de merge du 2.6.33 quand Dave Airlie, responsable de la partie graphique du noyau (Direct Rendering Manager), a proposé à Linus de fusionner sa branche de développement il ne s'attendait certainement pas au message cinglant qu'il allait recevoir en retour.
Pourtant sa demande de récupération du code ("pull" dans le langage du gestionnaire de versions git) était tout à fait banale. Durant les quinze jours de la "fenêtre de tir" chaque gardien d'une sous-partie du noyau indique ainsi à Linus quelles sont les nouveautés qui sont incluses dans la branche et lui demande de faire un pull de sa branche... mais là Linus a eu le sentiment d'être volé sur la marchandise puisque le pilote libre Nouveau, destiné à faire fonctionner les cartes graphiques NVidia, n'était pas dans le paquet cadeau !
Selon le message de commit de Dave Airlie le plus gros manque de sa branche était la gestion de l'énergie du pilote Radeon ce qui lui a valu cette réplique immédiate:
« Non, le plus gros manque c'est que Fedora continue d'inclure Nouveau et que je ne vois toujours pas les gens de Red Hat essayer de l'inclure dans la branche principale. Bordel, qu'est-ce qu'il se passe ? ».
Certains développeurs ont essayé d'expliquer que le pilote n'était pas encore vraiment mûr... mais Linus sait être brutalement franc dans ses échanges :
«J'ai déjà entendu toutes ces excuses. Si ce n'est pas encore prêt alors ils ne devraient pas le proposer à des millions de personnes. Et si c'est prêt alors ils devraient travailler pour l'inclure. Pas d'excuse ».
Suivi de:
« Quand j'ai soulevé ce point lors du dernier sommet du noyau j'ai entendu plein d'excuses différentes. L'une d'elle était que cela ne faisait pas partie d'une version officielle de Fedora (ce qui n'est certainement pas vrai au moins pour Fedora 12).
J'ai aussi entendu l'excuse "Oh mais c'est difficile à inclure" mais je sais que c'est de la connerie parce que je regarde la branche git de Fedora et je vois ça merge sans aucun conflit.
L'excuse la plus commune est "Oh mais le code va encore changer". Pour commencer ce n'est même pas une bonne excuse mais de toute façon la branche -staging est justement là pour ça.
Quelqu'un a même fait un commentaire grotesque disant que "Fedora n'est pas une vraie distribution, donc elle n'est pas obligée de suivre les règles que tout le monde a accepté de suivre il y a des années, c'est-à-dire d'inclure les trucs dans la branche principale".
Je pense que cette dernière excuse est une blague. Mais c'est vraiment difficile d'être affirmatif, car les autres excuses sont tout autant débiles. Les gens semblent vraiment sortir n'importe quelle excuse merdeuse pour justifier un truc que tout le monde sait être complètement faux
».

Devant ce tir de barrage les développeurs du pilote Nouveau ont dû céder et Dave Airlie a promptement annoncé que la branche "Le poney Nouveau pour Noël" était disponible pour merge dans le 2.6.33. Le "poney" du titre de cette branche vient de l'expression anglo-saxonne "Can I have a pony too?" qu'on utilise traditionnellement pour réclamer humoristiquement une chose extraordinaire en plus de tout ce qu'on vient déjà d'avoir. C'est un peu l'équivalent de "Je peux avoir aussi cent balles et un mars ?".
Bien entendu Linus a été content d'avoir obtenu ce qu'il voulait ("PONEYS ! Super ! J'adoooore les poneys !") et les utilisateurs du noyau 2.6.33 pourront profiter d'un pilote libre pour leurs cartes NVidia qui sera de meilleure qualité que le très limité et incompréhensible pilote nv (rendu sciemment illisible par les développeurs de NVidia qui utilisent la technique de l'obfuscation).
Le blob binaire qui est nécessaire pour faire fonctionner Nouveau (le micrologiciel ctxprogs) a même été réécrit par ingéniérie inverse et une version libre, compatible avec les cartes GeForce 6 et 7, a été rendue disponible.
Le support de double écran est possible via RandR et Nouveau propose aussi l'accélération par l'intermédiaire de Xvideo. Bien entendu le support de la 3D n'est pas encore vraiment au top car c'est une tâche très complexe mais nul doute doute que le support va s'améliorer. Une matrice de compatibilité est disponible sur le site du projet.
Nouveau, fondé par le français Stéphane Marchesin, continue d'avancer à bon rythme et comme c'était prévu le code bouge beaucoup. Ainsi la partie en espace utilisateur de Nouveau a rompu la compatibilité avec le pilote DRM (Direct Rendering Manager) intégrée dans le noyau. De plus, juste après l'intégration dans la branche -staging, tout le code a été nettoyé, plus de 15000 lignes ont été supprimées, car il a été décidé que le pilote dépendrait désormais exclusivement de KMS (Kernel Mode Setting). Si votre noyau n'inclut pas KMS et que vous voulez profiter de Nouveau il va falloir songer à mettre à jour !

En bref ()


Le bilan en chiffres ()


Côté statistiques, l'article récapitulatif pour le 2.6.33 du site LWN est disponible et on pourra également se reporter au site dédié aux statistiques du noyau Linux. Un autre article récent du site LWN (accessible dès maintenant pour les abonnés et visible par tous à partir du jeudi 25 février) s'est également penché sur les statistiques cumulées depuis l'introduction du gestionnaire de version git, c'est-à-dire en avril 2005 avec la version 2.6.12-rc2.

Pour le noyau 2.6.33, le nombre de patchs était de 10 784 au 21 février (10 944 pour le 2.6.32). Il semble bien que l'équipe de développement de Linux se soit plus ou moins calée sur un rythme de développement qui représente un peu plus de dix mille patchs tous les trois mois, écrits par un peu plus de 1000 développeurs (1188 cette fois-ci).
En terme de lignes de codes, nous avons près d'un million et demi de changements (ajout de 900 000 lignes et suppression de 520 000 lignes).
Dans l'article récapitulant l'évolution entre le 2.6.12-rc2 et le 2.6.33 ("How old is our kernel?"), on apprend notamment qu'en cinq ans le code du noyau Linux dans son ensemble a beaucoup changé puisqu'il ne reste plus que 31% des lignes de code du noyau actuel qui n'ont pas été modifiées depuis avril 2005. Les parties ayant le moins changé sont les sous-répertoires documentation (41% de code identique) et sound (45% de code identique). Le cœur du noyau quant à lui (kernel) ne contient plus que 13% de code datant du 2.6.12-rc2.
Une autre statistique intéressante à considérer est celle des primo-contributeurs (ceux qui ont fait un patch dans le noyau pour la toute première fois lors d'un cycle donné). Si on utilise les pages "First commit" du site Linux Kernel Patch Statistic on trouve les résultats suivants :
Noyau 2.6.27 : 216 primo-contributeurs
Noyau 2.6.28 : 252 primo-contributeurs
Noyau 2.6.29 : 279 primo-contributeurs
Noyau 2.6.30 : 256 primo-contributeurs
Noyau 2.6.31 : 275 primo-contributeurs
Noyau 2.6.32 : 294 primo-contributeurs
Noyau 2.6.33 : 272 primo-contributeurs

On voit que chaque noyau enregistre la participation de plus de 250 nouvelles têtes à chaque fois, ce qui est rassurant pour la pérennité du modèle de développement utilisé.

Enfin, si on regarde les statistiques en terme de nombre de patchs nous pouvons pousser un franc cocorico, puisque c'est le français Frédéric Weisbecker (fweisbec sur LinuxFr) qui est médaille d'or dans cette version 2.6.33 avec un total impressionnant de 146 patchs ! On y retrouve le travail évoqué plus haut sur le traçage/profilage, la suppression du BKL dans reiserfs, ainsi que la réimplémentation de Hardware-breakpoint par dessus perf events.
Comme ces travaux me semblent particulièrement difficiles à comprendre et à expliquer (oui, ça s'est vu dans la dépêche que je patauge sur le tracing), j'ai pensé que Frédéric serait mieux à même d'en parler directement aux lecteurs de LinuxFr et que cela nous permettrait par la même occasion de mieux faire sa connaissance.
Je lui ai donc soumis une petite liste de questions auxquelles il a eu la gentillesse de répondre.

Questions/Réponses avec Frédéric Weisbecker ()


Patrick_g : Pourquoi avoir choisi de contribuer à Linux ? La GPL c'est important dans ton choix ou pas ?

Frédéric Weisbecker : Pourquoi Linux ? D'abord parce que les noyaux sont ce qui me fascine le plus dans l'informatique. J'ai toujours voulu savoir comment mes logiciels contrôlaient mon matériel. Quand j'ai commencé à chercher des informations sur le sujet, c'étaient toujours des bribes disséminées un peu partout sur le web.
Je crois que c'est le côté cryptique de la chose qui est attirant, un peu pour la même raison que j'aime bien le reverse engineering :)
Partant de là, j'ai exploré le développement noyau sous Windows et Linux. Mais comme le noyau Windows est complètement obfusqué et que je n'y trouvais que des informations très schématiques, je ne m'y suis pas beaucoup attardé.
Linux étant open source, ça a été déterminant bien sûr, même s'il a fallu que je relise Linux Device Drivers ed.3 de nombreuses fois et que - même après - je ne comprenais toujours rien au code :)

Mais sa licence et surtout son développement ouvert (oui, oui, il y a des logiciels GPL/BSD/etc. qui ont un processus de développement tout à fait fermé) ont été très importants pour moi. C'est un processus très démocratique, qui fait qu'un inconnu lambda - comme je l'ai été en arrivant - peut participer lui aussi, pas besoin d'être employé par Red Hat ou Intel pour ça.
Bien sûr ce n'est pas une démocratie pure et parfaite, elle implique aussi une chaîne de confiance complexe avec des nœuds divers ayant plus ou moins de poids qui varie selon les sous-systèmes, mais tout de même, le plus gros poids reste dans le patch, je pense.

Ensuite, le côté logiciel libre et développement ouvert permet de vous faire un nom, visible rapidement sur le Web et qui reflète ce que vous avez fait. Si vous êtes étudiant en informatique et que vous voulez bosser dans un domaine particulier, prenez un logiciel libre dans ce domaine, et participez. La liste des bénéfices à en tirer est innombrable.

Autre chose : ça émousse aussi un peu le Complexe de la Momie. Si vous vouez votre vie au logiciel propriétaire, est-ce-que les gens pourront réutiliser votre travail ? À quel point ? Pendant combien de temps ?
Participer au logiciel libre implique le principe de "se hisser sur les épaules des géants", votre travail aura plus de chances d'être réutilisé, vous aurez agrandi le géant à votre tour et les briques laissées derrière votre passage auront plus de pérennité.

C'est aussi la raison pour laquelle je préfère les licences de type GPL aux licences BSD. Ça force plus le travail en commun. Plutôt que chacun réinvente le même moulin, des entreprises concurrentes qui bossent sur des produits éphémères se rejoignent tout de même sur un point commun, un travail à long terme, un truc particulier.
La GPL amène ça par la coercition, une œuvre qui fait réellement progresser les choses. Je pense que la BSD amène ça aussi, mais avec beaucoup moins d'efficacité.

Patrick_g : Es-tu payé pour ton travail sur Linux ou travailles-tu sur ton temps libre ?

Frédéric Weisbecker : Non, que du temps libre.

Patrick_g : Si tu es bénévole as-tu reçu/t'attends-tu à recevoir des propositions de job à la suite de tes contributions ?

Frédéric Weisbecker : Je n'ai pas reçu de propositions de job. Et je suis étudiant, alors jusque là je n'ai pas vraiment cherché. Mais je suis en fin de cursus, avec beaucoup de temps libre, donc si quelqu'un veut d'un développeur noyau (upstream de préférence) à mi-temps je suis preneur :)

Patrick_g : La LKML a-t-elle été accueillante pour tes patchs ou y a-t-il eu des oppositions virulentes ?

Frédéric Weisbecker : Selon les patchs, l'un ou l'autre. Et c'est le cas pour tous les développeurs du noyau, ce sera toujours comme ça et heureusement. Même les plus expérimentés se font refuser des patchs. Même les mainteneurs d'un sous-système peuvent se voir refuser des patchs dans le domaine qu'ils maintiennent.
En fait, il y a plusieurs niveaux de passage en revue d'un patch, par ordre de priorité :

1) Le changement répond-il à un vrai besoin ? Est-ce-qu'il résout un vrai problème, est-ce-que ce changement est utile?

2) Le changement répond-il d'une bonne manière à ce besoin ? Est-ce une bonne solution ? Devrait-on le faire autrement ?

3) L'architecture du nouveau code est-elle propre ?

4) Y a-t-il des fautes de code, des bugs, des problèmes de verrous, etc.

5) Le changement respecte-il les standards de style de Linux ? (espaces blancs, indentations, accolades mal placées, etc.)

Bien souvent, si le niveau n ne passe pas, le niveau n+1 ne sera même pas examiné.
Ceci étant, lorsque l'on devient familier avec un sous système particulier, on devient très à l'écoute de son cycle de vie, on a une meilleure vision globale de son code, des problèmes qui sont en suspens. On passe aussi en revue les patchs des autres et on découvre les problèmes qu'ils ont vu, ce qui en déterre d'autres, on découvre également les besoins des autres. À partir de là, l'étape 1 ne pose plus beaucoup de problèmes.

Reste l'étape 2. Si votre changement implique beaucoup de boulot (plus qu'une journée), surtout parlez-en d'abord sur LKML, voyez l'opinion générale sur l'architecture qui conviendrait le mieux avant de vous lancer, ou vous risquez de vous casser les dents après des jours, voire des mois de boulot. Lorsqu'on agit seul, même si l'on est familier avec le code en question, on a souvent une vision erratique et incomplète du problème ou de la solution à adopter.
Il faut entamer une discussion, et/ou proposer des maquettes très brouillonnes, à peine testées (patchs RFC), juste pour tâter l'opinion avant de se lancer pour de bon.
Souvent on passe l'étape 3 par la même occasion à force de proposer des patch RFC et de corriger à partir des commentaires donnés par les relecteurs sur LKML.
Le reste de l'étape 3, puis la 4 et 5 se résolvent à force d'adresser les commentaires des autres, après quelques versions du patch.
Ça peut aller jusqu'à prendre parfois une dizaine d'itérations, ça arrive...
Il est rare qu'un changement significatif soit accepté dès la première version.

Patrick_g : Vas-tu continuer ton travail d'élimination du BKL dans d'autres coins du noyau que reiserfs ?

Frédéric Weisbecker : Peut-être, oui. J'ai déjà enlevé quelques traces de bkl ailleurs que dans reiserfs.
Les restes de Bkl sont dans des vieux pilotes, donc difficiles à tester, mais aussi encore un peu dans le cœur du noyau : VFS, Block, TTY... Ce qui reste à supprimer dans le cœur est délicat, on ne sait pas toujours ce qu'il protège.
Ça donne lieu à beaucoup de "Pushdown". C'est-à-dire que lorsque l'on a :

lock_kernel();
func1();
unlock_kernel();

Si func1() est une callback(), on va descendre l'appel de la BKL dans toutes les instances de func1() (toutes les fonctions susceptibles d'être pointées par func1).
Ce sera plus facile de la supprimer après ça, car on finira au fur et à mesure par arriver à passer en revue chacune de ces fonctions, voir laquelle a besoin d'un verrou et remplacer par un verrou traditionnel si c'est le cas, sinon supprimer la bkl à cet endroit. Ce travail peut passer par un pushdown de plus en plus profond, jusqu'à ce qu'on aie une vision nette et chirugicale de ce qu'elle protège (lorsqu'elle protège quelque chose).
Si func1 est une fonction en dur, c'est le même principe, on pushdown sur les function que func1() appelle.
D'ailleurs ce travail donne l'illusion que la suppression du bkl n'avance pas. Si tu fais un grep sur lock_kernel dans les sources du noyau, tu trouveras peut être plus d'appels que dans une version précédente, mais en réalité il est pris moins souvent et plus sélectivement.

Patrick_g : Ton patch "bkl ftrace events" peut-il permettre de faciliter le travail ?

Frédéric Weisbecker : Non. Il permet de tracer l'activité de la bkl pendant que le système tourne. Ça permet de déterminer la fréquence de son usage dynamiquement, le temps durant lequel il est acquis, où et quand.
Si un grep lock_kernel est inefficace pour voir la progression de la suppression du bkl, en revanche les événements donnés par ces points de traçage par ftrace offrent une meilleure vue à ce niveau (pour une configuration de noyau donnée).
Ça peut aussi être utile pour quelqu'un qui a des pré-requis en termes de latence, vérifier le taux d'utilisation du bkl avec une configuration noyau donnée ou un matériel spécifique (dans le cas où un pilote utilise le bkl). Et également ça permet de voir à quel endroit on l'utilise le plus à l'exécution.

Patrick_g : Pourquoi les gens de FreeBSD ont-ils réussi a enlever le BKL de TTY dans leur version 8.0 alors que Linux se traîne encore un code antique ?

Frédéric Weisbecker : Héhé, bonne question. Je ne connais pas bien le code de FreeBSD.
Ceci dit, TTY est un sous-système maudit sous Linux. Je crois que peu de gens osent s'y aventurer, peut être parce que c'est le bordel, je ne sais pas trop. Je dois avouer que chaque fois que j'y vais, ça pique les yeux :)
Mais Alan Cox y a consacré beaucoup de temps. C'est l'un des seuls à bien connaître ce code, et il a, parait-il, assaini considérablement le code de tty et a supprimé beaucoup d'empreintes de Bkl dedans. Il en reste peu d'ailleurs. Il est surtout présent dans les évènements "hangups" de tty.
Malheureusement, Alan Cox a rendu son tablier de mainteneur de Tty, il y a quelques temps. Il devait en avoir marre. Ceci étant, il envoie encore des patchs pour TTY, notamment des pushdown de bkl dans les chemins de hangup :)

Patrick_g : T'arrive-t-il de regarder le code des systèmes BSD pour comparer avec Linux ou bien est-ce terra incognita pour toi ?

Frédéric Weisbecker : Terra incognita :)

Patrick_g : Où en est la situation générale du tracing sous Linux à l'heure actuelle ? Le noyau est-il en retard sur DTrace ?

Frédéric Weisbecker : Euh... je me sens un peu honteux. Mais je ne connais pas bien le tracing en dehors de ce qu'il y a sur la branche principale du noyau Linux. Mais bon je vais essayer de décrire un peu ce que je sais (ou ce que je crois savoir).

Premièrement, je ne sais strictement rien sur DTrace.

Le noyau Linux n'avait pas de sous-système de tracing avant 2.6.27. Mais il y avait beaucoup de mouvement dans des branches de développement avant cela, avec des orientations et des buts tout à fait différents :

- LTTng
Il y avait LTT, "Linux Tracing Toolkit", un patch out of tree avec des outils utilisateurs qui permettait de tracer l'utilisation du processeur. Je ne connais pas les détails, il s'agissait peut être de hooks sur l'ordonnanceur de tâches, entre autres.
Puis l'Ecole Polytechnique de Montréal a repris ce projet pour en faire LTTng (Linux Tracing Toolkit next generation) dont le développeur et mainteneur principal est Mathieu Desnoyers avec de multiples contributions par diverses compagnies comme Fujitsu, Sony, etc.
L'orientation principale de LTTng est de fournir un tracing qui tient bien le passage à l'échelle (utilisable même avec la multiplication de multi-cœurs, etc.), et un tracing fortement optimisé pour être même utilisable lorsque les services tournent, sans trop d'impact sur les performances. Ainsi on peut utiliser LTTng sans besoin d'interruption de service. Un utilisateur peut tracer son noyau sans impact sur le service qu'il offre à ses clients.

LTTng est basé sur les tracepoints (mergés d'ailleurs dans le noyau principal) et les markers, ainsi qu'un tampon circulaire qui centralise les données et enfin un jeu d'outils utilisateurs pour exploiter les événements tracés. Les tracepoints sont des points de traçage statiques dans le noyau. LTTng en a placés sur de multiples points clés du cœur du noyau (ordonnanceur, irqs, appels systèmes, timers, etc.) pour offrir une vue assez complète de ce qui se passe. Les outils utilisateurs synthétisent tout ça.

Mathieu a fait un très bon boulot. Il avait essayé à l'époque de bosser sur la branche principale plutôt qu'out-of-tree, mais je crois que ça s'est soldé par un échec. À cette époque, les développeurs du noyau ne considéraient peut-être pas encore l'importance des tracepoints statiques. Et avoir des points de traçage statiques un peu partout dans le noyau n'enchantait pas grand monde dans la branche principale.
Je ne sais pas exactement pourquoi. Peut être parce que l'importance du tracing était encore trop peu considérée à l'époque, à moins que ce ne soit parce que ces tracepoints étaient sortis de leur contexte et ne semblaient pas encore avoir d'application directe. Je ne sais pas.

Je ne sais pas non plus où Mathieu en est avec ses projets de "mainlining" de LTTng. Je pense que l'une des difficultés est peut être d'adapter LTTng en cohérence avec l'existant en amont : Ftrace.

- SystemTap
L'orientation de SystemTap est fortement basée sur le scripting et les tracepoints dynamiques.
Un utilisateur peut écrire un script (dans un langage dédié) pour extraire des évènements du noyau divers et variés, sortir des statistiques, etc. le tout sans besoin de tracepoints statiques.
Les tracepoints sont insérés dynamiquement par le biais d'un hot-patching (modification du code en mémoire).
Pour ça, Systemtap utilise kprobes (permet de créer/gérer des tracepoints dynamiques dans le noyau), et uprobes (même chose mais en espace utilisateur). Kprobes est mergé dans la branche principale, mais pas uprobes.
Il y a également, si je ne me trompe pas, un compilateur script -> bytecode et un interpréteur bytecode dans un module noyau (out of tree).

SystemTap est également basé sur utrace, un outil pour faciliter l'implantation de code pour gérer le traçage des processus, etc.

SystemTap n'est pas dans la branche principale car je crois qu'il y a eu des désaccords fondamentaux sur son architecture entre les développeurs de la branche principale et ceux de systemtap.

- Ftrace
Le patch Preempt-rt, la branche out of tree dédiée au développement de Linux pour en faire un noyau utilisable pour faire du temps réel soft, avait besoin de faire beaucoup de tracing afin de repérer les zones responsables de latences non voulues.
Quelques traceurs sont nés : un traceur de fonctions (responsable du nom ftrace), un traceur de zones non-préemptibles, un traceur d'événements de l'ordonnanceur, etc. écrits par Steven Rostedt, Ingo Molnar et d'autres.
Ces traceurs ont fini par former un sous-système à part entière, avec possibilité d'écrire de nouveaux traceurs sous forme de greffons. Le tout a été mis au propre et mergé dans la branche principale dans 2.6.27.

Ftrace est devenu plus qu'ftrace, et est maintenant le sous système de tracing de la branche principale. D'autres greffons ont été développés ou adaptés pour ftrace : traceur d'allocateur de mémoire, traceur d'évènements blocks, mmiotrace, un traceur de graphe de fonctions, etc. Le tout, tournant autour d'un tampon circulaire qui agglomère le tout et d'une interface debugfs.

- Aujourd'hui
Maintenant où en sommes nous? Justement les choses ont beaucoup évolué, le tracing est devenu un sujet très actif dans la branche principale.

Les tracepoints statiques ont pris beaucoup d'importance depuis qu'ils ont une nouvelle surcouche : les ftrace events. Ceux-ci permettent d'exploiter les tracepoints depuis debugfs. On peut les activer en utilisant des pseudo-fichiers et récupérer leurs traces facilement.
Donc l'insertion de tracepoints statiques dans le noyau se fait beaucoup plus allègrement. On a maintenant des tracepoints pour la plupart des points clés du cœur du noyau. Certains de ces efforts viennent d'ailleurs des développeurs de LTTng qui ont adapté certains de leurs tracepoints pour la branche principale.

Les tracepoints dynamiques ont également gagné en importance. Kprobes, qui jusque là n'avait pas d'utilisateur dans la branche principale, a gagné son interface utilisateur par le biais des ftrace events (permettant de créer des tracepoints statiques qui sont en fait virtuels : ce sont des tracepoints dynamiques).

2.6.31 a également vu arriver un nouveau sous-système de profiling : perf events (autrefois perf counters). Les tracepoints, qu'ils soient dynamiques ou statiques, peuvent maintenant être utilisés pour faire du profiling, voire pour coupler du tracing et du profiling, un outil très puissant. Et justement, on voit aujourd'hui arriver des changements permettant de scripter l'exploitation de ces évènements de tracing par le biais de scripts python ou perl.
L'utilisation de filtres dans les événements de ftrace, couplés avec ce genre de scripting, nous rapproche finalement des buts de SystemTap, mais avec des langages connus, bien que les choses ne se fassent finalement pas au même niveau d'action.

Parallèlement, les développeurs de SystemTap ont fait des tentatives pour merger utrace, sans trop de succès étant donné le manque de couche d'utilisation existante de utrace dans la branche principale, ainsi que des divergences d'opinions sur son architecture et son rôle.
Utrace génère des doutes et est décrié par les développeurs de la branche principale qui le taxent de "machine à tout faire sans rôle clairement défini" (traduction grossière de ce qu'en dit Linus).

Voyant la puissance offerte par l'utilisation de kprobes en utilisant perf events et ftrace, on commence à vouloir explorer les tracepoints dynamiques sur les processus utilisateurs. Exactement ce que fait uprobes. Uprobes a donc été proposé récemment pour la branche principale.
Beaucoup de controverses ont été levées : la dépendance à utrace par uprobes, son interface ftrace à renouveler pour pouvoir l'exploiter avec perf events, l'architecture du hot patching : divergences d'opinions sur la manière de rebondir sur l'application utilisateur après déclenchement d'un hook. Mais il y a fort à parier que uprobes fera son chemin un jour dans la branche principale, étant donnée la puissance de ce genre d'outil.

Il y a également encore beaucoup de choses en prévisions, ex. : utilisation du traceur de fonctions pour faire du profiling par fonction avec perf events, par exemple (compter les cache-hit, cache-miss au sein d'une fonction, entre autres possibilités).

Patrick_g : Entre les patchs sur l'élimination du BKL, ton travail sur les hw-breakpoints et celui sur le profilage et le tracing tu as touché des parties compliquées et diverses du noyau. Es-tu surhumain ?

Frédéric Weisbecker : Héhé :) Non. En fait j'ai eu la chance de bosser sur des sous-systèmes jeunes, voire naissants.
Essayez de travailler sur l'ordonnanceur de tâches, par exemple. Je pense que c'est difficile parce que CFS (l'ordonnanceur actuel) a été mergé il y a quelques cycles déjà. C'est un gros morceau qui a eu le temps de se stabiliser et de mûrir. Il y a certainement des choses à faire encore, mais pour un nouveau venu ça prendra un peu de temps de se familiariser avec ses milliers de lignes de code qui ont déjà de la bouteille. C'est tout à fait possible, ça demandera juste du temps.

Or, si vous arrivez sur le développement d'un nouveau sous-système, ou d'une grosse refonte d'un sous-système, c'est du code encore frais, plein de bugs, plein de choses à améliorer, à augmenter, à repenser. Il suffit de compiler, tester et les bugs viennent tout seuls, plus qu'à envoyer les patchs pour corriger les problèmes.
Quand on commence cet engrenage, on se familiarise très vite avec le code en question, et des idées d'améliorations plus larges viennent avec le temps étant donnée la meilleure compréhension du sous-système que l'on gagne, et les relations/suggestions/plaintes des autres développeurs ou utilisateurs.
C'est ce qui m'est arrivé avec ftrace qui venait d'être mergé quand je suis arrivé. Pareil avec perf events (d'autant qu'il y avait besoin de créer un pont avec ftrace, que je connaissais déjà bien).
Idem avec les hardware breakpoints, une nouvelle API générique proposée par K. Prasad que nous avons rediscutée, puis améliorée à partir de sa version.
Pour reiserfs, c'est plus du hasard. Je pensais que ça prendrait juste un après-midi pour transformer le BKL en un mutex.
Plus je corrigeais les bugs dûs à la conversion, plus je me disais "nan mais après ce patch là ce sera bon, ça marchera, c'est le dernier".
Finalement, ça m'a pris plusieurs mois, j'ai vraiment mal anticipé la tâche :)

Patrick_g : Merci encore Frédéric d'avoir pris le temps de répondre à mes questions.

Pour la suite ()


En ce qui concerne les futures nouveautés des prochaines versions du noyau on peut se tourner vers la page spécifique de la Fondation Linux et surtout vers cet article du site Linux Weekly News qui désigne deux candidats évidents.

Ceph


Ceph est un système de fichiers distribué qui à l'ambition de pouvoir évoluer et monter en charge sans aucun problème. Cette capacité à absorber la charge (en terme d'utilisateurs simultanés) et à évoluer en taille (en terme de disques connectés) représente les deux points forts de Ceph qui est issu de la thèse de doctorat de son concepteur Sage Weil.
Pour atteindre ses objectifs Ceph migre automatiquement les données sur les différents disques afin d'avoir une bonne répartition des accès sans "point chaud". Il n'y a pas de disque de secours spécifique et, en cas de nécessité, la récupération des données se fait à partir de dizaines de disques simultanément et à destination de dizaines d'autres disques (N-way replication).
Une particularité de Ceph est qu'il existe des serveurs de méta-données (MDS pour MetaData Server) qui sont séparés des serveurs de données (OSD pour Object Storage Devices). Ils servent à répartir intelligemment les données, journalisent les modifications et permettent de s'adapter dynamiquement à la charge (dynamic scaling).
Ce fonctionnement ressemble un peu à celui du système de fichiers Lustre et Ceph, avec le slogan "scale from gigabytes to petabytes and beyond", vise clairement à devenir un concurrent plus facile à administrer.
L'opportunité d'intégrer la branche principale du noyau a été manquée lors de la "fenêtre de tir" du 2.6.33 pour diverses raisons dont la plus visible est le refus de Linus de se laisser impressionner par la liste des fonctions. Son message détaillé est très intéressant à lire car il explique ce qui motive son choix d'inclure ou pas une nouvelle fonction dans le noyau : « Quand il s'agit d'ajouter tout un nouveau morceau de code ma réponse par défaut est toujours "non". Il faut d'abord m'expliquer pourquoi je _dois_ inclure ce truc ».

AlacrityVM


S'il est probable que Ceph sera ajouté rapidement au noyau, la situation est beaucoup moins rose pour AlacrityVM et la bataille fait rage entre les développeurs. AlacrityVM est une nouvelle proposition (encore une !) dans le domaine de la virtualisation puisqu'il s'agit d'un dérivé de KVM qui se concentre sur les performances dans le domaine des entrées/sorties. Le but de Novell, qui est derrière le projet, est d'arriver à un débit équivalent aux spécifications maximales du matériel et d'obtenir une virtualisation sans aucun impact négatif en terme de performances. Le code se base sur une utilisation directe des pilotes d'entrées/sorties au lieu de passer par des pilotes émulés. Ces deux schémas successifs (avant - après) aident à comprendre la logique du développement d'AlacrityVM.
L'ennui c'est que les développeurs de KVM ne sont pas très contents de cette solution qui constitue essentiellement un "fork" de leur code. Ils réclament un travail en commun plutôt que l'écriture d'une nouvelle solution complètement séparée. Ingo Molnar semble leur donner raison puisqu'il signale que : « Ces patchs ont reçus de multiples objections par les gens de KVM, pour des raisons techniques, car cela consiste basiquement à forker tous les pilotes KVM sans qu'aucune raison convaincante n'ait été apportée dans une discussion s'étendant sur plus de cent messages. Le résultat serait à mon humble avis un désagrément pour les utilisateurs car nous aurions deux infrastructures, des incompatibilités d'outils, etc. ».
Ce message d'Ingo a relancé la bataille et une magnifique flame war s'est développée sur la LKML.
Comme c'est toujours Linus qui prend la décision finale, il a choisi de ne pas inclure AlacrityVM dans le noyau 2.6.33 et d'attendre que la poussière retombe un peu avant de choisir.
Son message explique bien, avec son ton inimitable, quelle est sa position :
« Les gens de la virtualisation discutent toujours à propos des 36 000 façons différentes qu'il y a de faire les choses. Au lieu de se concentrer sur les vrais pilotes, là où s'exerce vraiment la contrainte due au matériel, ils semblent se complaire à créer de nouvelles interfaces à un rythme hebdomadaire.
Quand je vois une nouvelle interface de virtualisation, je voudrais que les spécialistes se disputent à son sujet _entre eux_. Du fait que, personnellement, je ne me soucie absolument pas le moins du monde de la virtualisation, je peux prendre un peu de recul et admirer le feu d'artifice. Cela ne veut pas dire que ça ne m'amuse pas, j'aime bien une flame war à l'occasion, mais pour être vraiment impliqué dans une flame war, il faut que j'y attache assez d'importance pour m'enflammer à ce sujet.
Donc je ne veux pas que cette bataille se déroule dans mon dépôt et je préférerais vraiment que les combats s'achèvent _avant_ que je ne merge.
Vous êtes tous des malades les gars.
».

Cette discussion est archivée, il n'est plus possible de laisser des commentaires.

Note : les commentaires appartiennent à ceux qui les ont postés. Nous n'en sommes pas responsables.

CFS/CFQ

Posté par fweisbec () le 25/02/2010 à 06:57. (lien). Évalué à 7.

Dans la partie "Contrôleur IO-Block", tu fais référence à CFS comme l'ordonnanceur IO par défaut. Je pense que tu voulais parler de CFQ. CFS c'est l'ordonnanceur de tâches. CFQ est un des ordonnanceurs IO.

Enfin bon je cherche des poux hein? Je suis bien evidemment complètement fan de cette dépêche :p

RCU

Posté par Brice Goglin () le 25/02/2010 à 07:55. (lien). Évalué à 3.

> La technique du Read-Copy update est utilisée dans Linux afin de synchroniser
> de multiples threads pour leur permettre de lire simultanément une donnée
> sans poser dessus un verrou coûteux.

Mouaif... Tant qu'on ne fait que lire une donnée, y a jamais besoin de verrou, c'est quand quelqu'un la modifie qu'on est embetté.

L'intérêt de RCU, c'est que ces multiples tâches peuvent lire une donnée alors que d'autres sont en train de la modifier. La modification est faite de manière à ce que les lecteurs aient toujours une vue cohérente de la donnée (typiquement une liste doublement chaînée) et qu'on ne libère pas la mémoire alors qu'ils y accèdent.

Obtenir un boulot via LKML

Posté par Brice Goglin () le 25/02/2010 à 08:09. (lien). Évalué à 4.

Que Frédéric Weisbecker se rassure, on recoit assez facilement des offres d'emploi quand a une activité régulière sur LKML et en terme de patchs. Y a au moins Google et VMWare qui s'intéressent à ce genre de contributeurs...

L'ordonnanceur stabilisé et mur ?

Posté par Brice Goglin () le 25/02/2010 à 08:17. (lien). Évalué à 9.

> Essayez de travailler sur l'ordonnanceur de tâches, par exemple. Je pense que c'est
> difficile parce que CFS (l'ordonnanceur actuel) a été mergé il y a quelques cycles déjà.
> C'est un gros morceau qui a eu le temps de se stabiliser et de mûrir.

Ahah la bonne blague ! L'ordonnanceur change en profondeur toutes les 3 ou 4 releases. C'est le parfait exemple du sous-système qui aurait dû être stable (on pouvait l'espérer après tout le flan qu'on a fait autour du O(1)-scheduler quand 2.6.0 est sorti), et pourtant non, il continue à être complètement changé régulièrement, bien avant d'être stable ou mûr.

Un vrai exemple de sous-système stable et mûr, c'est la pile réseau (au moins la partie basse qui touche aux drivers Ethernet, je sais pas pour les protocoles au dessus). Les drivers Ethernet ont eu très peu de modifications majeures depuis des lustres (je sais de quoi je parle...).

Super article

Posté par Edouard (page perso, ) le 25/02/2010 à 08:48. (lien). Évalué à 3.

Super article, à la fois technique et accessible. Merci

--
(pub): baggle, le boggle libre sur internet

Questions aux lecteurs

Posté par patrick_g (page perso, ) le 25/02/2010 à 09:00. (lien). Évalué à 10.

Lors de la phase de relecture il y a eu des discussions sur la mailing-list modéros en raison de la longueur inhabituelle de cette news. La question qui se posait c'était de savoir si une borne n'avait pas été franchie.
Comme l'a écrit un des participants à la discussion en découvrant la taille de la dépêche: "Le problème est que ça coupe tout simplement l'envie de lire".

Si je regarde la longueur des dépêches noyau j'obtiens ceci (en me basant sur ce qu'indique la ligne Linuxfr juste en dessous des liens de la news) :

2.6.24 => 33 614 caractères
2.6.25 => 34 938 caractères
2.6.26 => 27 383 caractères
2.6.27 => 45 996 caractères
2.6.28 => 36 479 caractères
2.6.29 => 37 616 caractères
2.6.30 => 54 211 caractères
2.6.31 => 68 189 caractères
2.6.32 => 73 197 caractères
2.6.33 => 100 088 caractères

On constate donc que jusqu'au 2.6.29 ça oscille gentiment entre 35k et 45k caractères. L'inflation réelle commence avec le 2.6.30 et n'a fait qu'augmenter depuis (même si la taille vraiment inhabituelle de la news 2.6.33 s'explique aussi par l'inclusion de l'interview de Frédéric).
Donc des questions se posent auxquelles j'aimerais, gentil lecteur, que tu répondes:

1) Est-ce que c'est trop long à lire ou pas ?
2) Si oui qu'est-ce qu'il faut enlever ?
3) Z'avez d'autres suggestions ?

[+] Très bon

Posté par Carl Chenet (page perso, ) le 25/02/2010 à 10:56. (lien). Évalué à -2.

Super l'article, merci bien !

Stockage distribué DRBD

Posté par Olivier Bernard () le 25/02/2010 à 10:58. (lien). Évalué à 4.

Merci pour la dépêche, très intéressante comme à son habitude.

Petite question concernant DRDB.
En lisant sa description :

<<
Ce sont ces blocs de bas niveau qui sont répliqués par DRBD sur plusieurs machines de façon automatique. Cette réplication peut se faire de façon synchrone (un bloc est considéré comme répliqué uniquement quand il a été écrit en local, envoyé vers le disque du nœud distant et que ce nœud distant a confirmé qu'il était correctement écrit) ou bien de façon asynchrone (un bloc est considéré comme répliqué quand il a été écrit en local et qu'il a juste été envoyé vers le nœud distant, sans confirmation en retour).
>>

J'aurai cru justement que ce type de mécanisme permettait [b]d'éviter[\b] d'avoir à utiliser des systèmes de fichiers distribués (possédant souvent des limitations), le mirroring se faisant justement au niveau réseau.
Y a-t-il quelque chose qui m'échappe ?

Beamo

Remerciements

Posté par Laifen () le 25/02/2010 à 11:14. (lien). Évalué à 2.

Merci pour toutes ces descriptions, c'est chaque fois une joie de pouvoir être si bien mis au courant pour chaque release.

Bonne continuation ;)

Juste une question

Posté par campagnard () le 25/02/2010 à 14:37. (lien). Évalué à 6.

Je n'ai pas fini de lire la dépeche, mais je pose cette question tout de suite car sinon je risque d'oublier et apparement elle n'a pas été posée en commentaire. C'est peut etre une question basique mais pas pour moi. (Et si ca m'interesse ca interessera quelqu'un d'autre)

"Techniquement ramzswap utilise l'algorithme de compression LZO (...) ainsi qu'un allocateur mémoire spécifique (xvmalloc). Cet allocateur est nécessaire car les développeurs ont découvert que ceux qui sont déjà disponibles dans le noyau Linux ne remplissaient pas leur cahier des charges très spécial. (..). SLUB de son côté a une tendance à la fragmentation mémoire que xvmalloc permet d'éviter."

Quel est le problème de la fragmentation mémoire pour de la mémoire RAM ? Je comprends le problème de la fragmentation pour des périphériques avec un temps d'accès lent, typiquement les disques durs avec leur parties mécaniques qui doivent donc se déplacer de fragment en fragment. Mais lors d'accès en RAM, ce problème ne se pose pas. Quel est donc le problème ?


Je retourne lire la suite de l'article, et je reviens si j'ai d'autres questions ^^

PS : j'ai failli oublier : félicitations patrick_g pour cette excellente depeche, comme toujours ! Atteindre la perfection est une chose, s'y maintenir en est une autre !

Support hyperV

Posté par xavier Granveaux () le 25/02/2010 à 17:48. (lien). Évalué à 3.

Salut,

Un petit point pour lequel il me faudrait une précision.
Je ne suis pas au fait de tous les détails des différentes phases de développement du noyau.
Mais concrètement, pour la partie hyperV (oui, je suis un peu intéressé), ça veut dire que tot ou tard les linuxIC de Microsoft seront intégrés nativement dans le noyau (sous réserve d'activer l'option qui va bien) ?
Ou ca va rester sous forme de patch comme aujourd'hui ?
J'avoue qu'entre ça, le petit patch fourni par Microsoft, et le petit complément au patch fourni par Citrix, je ne sais pas trop quoi en penser.

Est-ce que je peux nourir le rêve qu'un jour ce soit directement intégré dans le noyau de ma distribution préférée ?

GNU/Linux Magazine France

Posté par Raphaël SurcouF (Jabber id, page perso, ) le 25/02/2010 à 18:30. (lien). Évalué à 3.

Patrick ! Il ne va plus rien rester au Kernel Corner de GLMF avec tes dépêches ! ;-)

plus de net

Posté par n3os () le 25/02/2010 à 20:05. (lien). Évalué à 1.

Hello,

tiens plus de net avec RTL-8169 Gigabit Ethernet et son module r8169 en dur

sinon superbe description, sacré taf.

petite erreur sur UDP

Posté par gato () le 25/02/2010 à 20:55. (lien). Évalué à 2.

Une petite erreur s'est glissée dans le paragraphe parlant de la taille des datagrammes UDP : la taille utile (le MTU) est de 1500 octets pas 512.

au sujet DNSSEC

Posté par steph1978 () le 25/02/2010 à 22:13. (lien). Évalué à 1.

> La taille d'un paquet UDP est de 512 octets

Pourquoi parle-t-on d'une taille de 512 octets alors que la longueur est codée sur 16bits permettant d'aller jusqu'à 65536 ?

.

Posté par Matthieu C () le 26/02/2010 à 00:30. (lien). Évalué à 3.

Merci pour ta super dépêche.


SystemTap ne risque pas de ce faire concurrencer par le système perf qui gère de plus en plus de chose (hw-breakpoint, kprobe, syscall trace, ...) ?


noyau 2.6.33 pourront profiter d'un pilote libre pour leurs cartes NVidia qui sera de meilleure qualité que le très limité et incompréhensible pilote nv

Perso nouveau est plus lent chez moi dans certain cas utilisation (fonte bitmap, firefox). Certaines lenteurs sont du au passage XAA vers EXA.
J'ai commencé à investiguer, mais j'ai pas eu le temps de trop creuser (par exemple un changement de tabulation dans firefox engendre un nombre impressionnant de memcpy pour lire des données du GPU dans le CPU).


Si votre noyau n'inclut pas KMS et que vous voulez profiter de Nouveau il va falloir songer à mettre à jour !
KMS c'est super violent, il faut mettre une grosse partie du driver X dans le kernel. Et aujourd'hui ce n'est pas fait pour l'overlay [1], du coup le rendu video n'est pas toujours au top.


[1] sauf pour les cartes intels (et encore avec des limitations) http://git.kernel.org/linus/02e792fbaadb75dec8e476a05b610e49(...)

Et un autre driver intéressant inclus dans ce 2.6.33

Posté par benoar (Jabber id, ) le 26/02/2010 à 02:44. (lien). Évalué à 2.

Pour tous les possesseurs de Mac PPC, sachez que Benjamin Herrenschmidt a inclus dans cette release son driver macio qui est le portage vers la "nouvelle" pile ATA (libata) de l'ensemble des drivers ATA (IDE) utilisés sur les PowerPC newworld (au moins ; je ne sais pas pour les autres).

Vu que l'ancienne pile va sûrement jarter un jour, c'est une bonne nouvelle pour cette archi qui se voit ainsi encore un peu considérée. Par contre, même si c'est un "simple" portage, testez !

Le vendredi, c'est permis \o/

Posté par Axioplase ıɥs∀ (page perso, ) le 26/02/2010 à 08:31. (lien). Évalué à 9.

>> Le système de fichiers Reiserfs est maintenant officiellement déclaré libéré de l'infâme verrou global du noyau (BKL).

Et l'infâme Reiser, lui, n'est pas encore libéré de derrière les verrous.

--
Je ne suis pas toujours de mon avis.

TRIM ?

Posté par Jokernathan () le 26/02/2010 à 09:08. (lien). Évalué à 1.

D'après l'article de silicon.fr le noyau 2.6.33 supporterait également la commande TRIM.
Si c'est vrai c'est une excellente nouvelle pour les possesseurs de disques SSD mais je suis surpris qu'on en parle si peu d'où mon léger scepticisme.

--
Mess with the best
Die like the rest

DNSSEC et UDP

Posté par Yohann Lepage (Jabber id, page perso, ) le 26/02/2010 à 09:30. (lien). Évalué à 3.

Tout d'abord, merci pour cette news !

Il y a une petite erreur au niveau du paragraphe sur la transaction TCP par cookie : les paquets sont trop gros pour le protocole de transmission UDP qui est normalement utilisé par DNS. La taille d'un paquet UDP est de 512 octets alors qu'en moyenne DNSSEC exige 1749 octets.

A l'origine, l'UDP[0] était en effet limité à 512 octets. Cependant, cette limite a été augmenté depuis 12 ans avec l'EDNS0 ( Extension Mechanisms for DNS) [1] à 4096 octets. Le DNSSEC peut fonctionner uniquement avec UDP.

D'autre part, d'où sort cette moyenne de 1749 octets ? Ne confonds-tu pas avec ce thread : [dnsext] root DNSKEY response is 1749 bytes ?

0 :http://www.ietf.org/rfc/rfc1035.txt
1 :http://www.ietf.org/rfc/rfc2671.txt

Ca decolle

Posté par Kévin FERRARE (page perso, ) le 26/02/2010 à 11:46. (lien). Évalué à 4.

Ces graphiques montrent quelque chose d'interessant je trouve
http://www.remword.com/kps_result/evolvement.php
Du 2.6.12 (mi 2005) au 2.6.33, donc en 4 ans 1/2, le nombre de contributeurs a triple et le nombre de lignes changees par release a ete multiplie par 10.
Ici, on vois que 75% des contributions proviennent d'entreprises.
http://lwn.net/Articles/373405/
Si le nombre d'entreprises et la quantite de leurs contributions a augmente si rapidement, c'est que linux est vraiment entrain de gagner du marche et d'interesser plus de monde, avec une progression importante.
Ca serait interessant d'avoir des donnes de ce genre pour les environnements de bureau.

Pas de news de fanotify ?

Posté par Hardy Damien () le 26/02/2010 à 12:02. (lien). Évalué à 1.

Hello,

Sur le dernier noyaux 2.6.32 E. Paris de chez redhat avait échoué à faire rentrer l'outil fanotify s'appuyant sur l'API fsnotify qu'il avait introduite dans le 2.6.31 (en récrivant inotify et dnotify à iso fonctionnalités sur cette API) qui permet de tracer les évènements d'un file system. (aujourd'hui impossible avec inotify/dnotify qui ne peuvent pas surveiller une hiérarchie de répertoire autrement qu'en ouvrant un file descriptor sur chaque répertoires de celle-ci)

A t'on des nouvelles de ce projet ? qui m'intéresse assez dans le cadre de la sauvegarde de gros file system et de la gestion de split-brain sur drbd master/master (qui entre donc dans le noyaux \o/ ce qui est une excellente nouvelle).

Merci pour cette news.

À propos du tracing

Posté par Dreamkey () le 26/02/2010 à 19:38. (lien). Évalué à 1.

Alors que quelques personnes se plaignent que la news est trop longue, je trouve que ça permet à des curieux comme moi de se tenir au courant des avancées du kernel de son OS préféré.
Par contre je n'ai pas compris l'utilité du tracing : c'est juste à des fins de monitoring ou c'est plus poussé (ce dont je suppose, mais je ne vois pas en quoi).
De plus il y a point de traçage statique et dynamique, quel sont les avantages/inconvénients de chacun ? Frédéric dit qu'"avoir des points de traçage statiques un peu partout dans le noyau n'enchantait pas grand monde dans la branche principale", mais pourquoi est-ce que maintenant ça ne les dérangent plus ?

Sinon autre chose, à propos des "régressions" : est-ce que c'est une manière élégante de dire "bugs" ? Dans la RC-8 il est traduit à propos de Linus qu'"un certain nombre de régressions devraient être corrigées et - même si la liste des régressions ne me rend pas _content_".
Cela veut dire que même s'il reste des bugs, le kernel est déclaré comme stable, car Linus ne veut pas avoir plus de 8 RC pour une nouvelle version d'un kernel, et qu'en extrapolant les version 2.6.33.X ne sont que des versions 2.6.33 RC(8+X) ?

device-mapper : snapshot

Posté par ElectronLibre () le 26/02/2010 à 20:13. (lien). Évalué à 0.

Hi guys,

J'ai vraiment envie de faire joujou avec des FS chiffrés en LVM2 RAID5, mais je ne trouve pas de HOWTO sur comment faire des snapshots avec device-mapper.

Est-ce que c'est encore "trop nouveau" pour qu'il y ait de la littérature ?

Autre petite question, je ne me souviens plus comment compiloner avec plusieurs thread (--enable-threads). Je ne trouve pas comment demander à Make de le dire dans le Makefile. Et je n'ai pas l'impression, en regardant le System Monitor, que mes 8 threads soient exploités.

+

Félicitation

Posté par dedesite () le 27/02/2010 à 11:29. (lien). Évalué à 3.

Un GRAND merci à toi patrick_g pour cette merveilleuse dépêche. C'est toujours extrêment intéressant de lire tout se qui se trame lors du développement/merge d'un projet aussi important (en terme de nombre de participants et d'utilisateurs/utilisation) que Linux.
J'ai beaucoup apprécié cette nouvelle partie "interview" et j'espère qu'il y en aura d'autre dans le futur. Le fait d'avoir un regard "interne" sur les problèmes apporte une meilleure compréhension je trouve.

Je ne suis pas forcément fan de tout ce qui est bas niveau, mais étant moi même développeur (dans le jeu vidéo), j'aime tout de même comprendre un minimum ce qui se passe au niveau noyau. Je considère tes dépèche comme des petits cours et j'ai beaucoup sur le fonctionnement d'un noyau grâce à elles. Continue comme ça!!

Andréas

erreur au linkage ?

Posté par Guillaume Revaillot (page perso, ) le 01/03/2010 à 12:39. (lien). Évalué à 3.

Petite erreur dans l'interview de Frédéric Weisbecker : on parle de LTTng, qui serait maintenu par un étudiant de Polytech Montréal, alors que le lien pointe vers le site de l'ETS, une autre école Montréalaise. Le lien correct est http://www.polymtl.ca/ .

Erratum

Posté par murphy2712 () le 02/03/2010 à 17:59. (lien). Évalué à 1.

"Son message explique bien, avec son ton inimitable, qu'elle est sa position"
=> "quelle est sa position"

module ath5k

Posté par Jllc () le 03/03/2010 à 21:37. (lien). Évalué à 1.

Est-ce qu'il y en a ici qui utilise le module ath5k pour leur carte wifi Atheros ?

Ça fait plusieurs versions que je n'arrive plus à la faire fonctionner (et encore, sur le 2.6.27.x que j'utilise, c'est avec un débit catastrophique). J'ai vu dans le Changelog de ce 2.6.33 que ce module avait subis pas mal d'évolutions, mais après recompilation et reboot, ça ne marche pas mieux. J'arrive bien à voir les réseaux wifi du coin, mais impossible de me connecter à ma box.

Revenir en haut de page