Qu’est-ce que l’époque Unix et comment fonctionne l’heure Unix ?

Unix stocke le temps en nombre de secondes depuis le 1er janvier 1970. Et cela signifie que Linux le fait aussi. Nous expliquons ce système apparemment étrange et pourquoi la fin du monde était prévue pour 2038.

La première époque Unix

Goethe (1749-1832) a déclaré « Chaque seconde a une valeur infinie ». C’est vrai, nous n’avons chacun que quelques secondes ici sur la planète Terre, et nous ne savons pas quand sera notre dernière seconde. Mais nous connaissons notre anniversaire et quand notre compte à rebours mortel a commencé.

Unix—comme le Reine britannique– a deux anniversaires. Ou, plus précisément, il y a eu deux occasions distinctes où il a commencé à compter les secondes de son existence. La première fois qu’Unix a commencé à compter à partir du 1er janvier 1971 à minuit.

On le voit assez clairement en revoyant une partie de la première édition du Manuel du programmeur Unix, daté du 3 novembre 1971. Faites défiler jusqu’à la page 13 de cette section, et vous verrez une description du (maintenant disparu) time commander. On nous dit ça » time renvoie l’heure depuis 00:00:00, le 1er janvier 1971, mesurée en soixantièmes de seconde.

Les calendriers et les systèmes temporels mesurent le temps à partir d’un moment important dans le passé, tel qu’un événement cosmologique, la fondation d’un empire ou le succès d’une révolution. Dans les systèmes d’exploitation, une heure et une date arbitraires sont choisies comme point de départ du comptage. C’est l’époque de ce système d’exploitation.

Unix a utilisé un entier non signé de 32 bits pour contenir le nombre de 60e de seconde depuis l’époque. Il s’agit d’une variable numérique capable de contenir des valeurs comprises entre 0 et 4 294 967 295 (232−1). Ça semble beaucoup. Mais le compteur s’incrémentait à 60 fois par seconde et, comme le souligne le manuel du programmeur, « l’utilisateur soucieux de la chronologie remarquera que 2**32 soixantièmes de seconde ne représentent qu’environ 2,5 ans. »

Avec un taux de consommation de 60 chiffres par seconde, le compteur aurait atteint sa valeur maximale le 8 avril 1973, un peu moins de 829 jours plus tard.

La deuxième époque Unix

Inutile de dire que cela a été agi rapidement. L’entier non signé a été remplacé par un entier signé 32 bits. Cela peut sembler un choix surprenant car un entier signé est capable de contenir un plus petit nombre de valeurs positives – 2 147 483 647 (231) – qu’un entier non signé. Cependant, la vitesse de consommation a également été réduite de 60e de seconde à des secondes entières.

Il faut plus de temps pour compter de 0 à 2 147 483 647 en comptant un nombre par seconde que pour compter de 0 à 4 294 967 295 à 60 coups par seconde. Et de loin. Le nouveau régime n’atteindrait sa valeur maximale qu’à un peu plus de 68 ans. Cela semblait si loin dans le futur que l’époque a même été réinitialisée à un point antérieur dans le temps. La nouvelle époque a été fixée à minuit le 1er janvier 1970, UTC.

Ce point 68 ans dans le futur est maintenant incroyablement proche. Pour être précis, nous l’atteindrons à 03:14:07 UTC le 19 janvier 2038.

Un schéma simple mais efficace

L’utilisation d’un seul entier pour compter le nombre de pas de temps à partir d’un moment donné est un moyen efficace de stocker le temps. Vous n’avez pas besoin de stocker des structures compliquées d’années, de mois, de jours et d’heures. et il est indépendant du pays, des paramètres régionaux et du fuseau horaire.

Multiplier le nombre dans l’entier par la taille du pas de temps – dans ce cas, une seconde – vous donne le temps écoulé depuis l’époque, et la conversion de cela en formats spécifiques aux paramètres régionaux avec des ajustements de fuseau horaire est relativement triviale.

Cela vous donne cependant une limite supérieure intégrée. Tôt ou tard, vous atteindrez la valeur maximale que vous pouvez conserver dans le type de variable que vous avez choisi. Au moment d’écrire cet article, l’année 2038 n’est que dans 17 ans.

C’est similaire mais légèrement différent du problème des premiers systèmes informatiques du siècle dernier utilisant deux chiffres pour stocker les années. Lorsque le calendrier est passé à la nouvelle année et au nouveau siècle de 2000, une valeur d’année stockée comme « 00 » serait-elle interprétée comme 2000 ou 1900 ?

On estime que la correction du soi-disant « bug du millénaire » a coûté aux États-Unis à eux seuls plus de 100 milliards de dollars et qu’il a fallu des milliers d’années-homme pour y remédier à l’échelle mondiale. Il y a eu quelques problèmes au cours des premiers jours de janvier 2000, mais rien à voir avec les catastrophes qui auraient eu lieu si le bogue avait été ignoré.

La fin du monde est reportée

Étant donné que Linux et tous les systèmes d’exploitation similaires à Unix partagent le même problème, le problème de l’année 2038 est pris au sérieux depuis un certain temps, des correctifs étant ajoutés au noyau depuis 2014. Ceci est en cours avec des correctifs. être ajouté au noyau aussi récemment qu’en janvier 2020 pour résoudre le problème des entiers 32 bits.

Bien sûr, un ordinateur Linux fonctionnel contient bien plus qu’un noyau. Tous les utilitaires d’exploitation et les applications utilisateur qui utilisent l’heure système via les différentes API et interfaces doivent être modifiés pour s’attendre à des valeurs 64 bits. Les systèmes de fichiers aussi doit être mis à jour pour accepter les horodatages 64 bits pour les fichiers et les répertoires.

Linux est partout. Une panne catastrophique de Linux signifierait des pannes dans toutes sortes de systèmes informatiques. Linux exécute la plupart du Web, la plupart du cloud public et même des engins spatiaux. Il gère des maisons intelligentes et des voitures autonomes. Les smartphones ont en leur cœur un noyau dérivé d’Unix. Pratiquement tout, comme les pare-feu de réseau, les routeurs et les modems à large bande, qui contient des systèmes d’exploitation intégrés s’exécute sous Linux.

C’est bien que Linux soit en bonne voie d’être réparé. Nous installerons les mises à jour et ce sera tout. Mais quelles sont les chances que tous ces appareils soient corrigés et mis à jour ? Beaucoup d’entre eux ne seront même pas en service d’ici là, ce sera donc un point discutable, mais certains seront toujours en panne. Cachés dans des recoins sombres et poussiéreux des salles de serveurs et des armoires rack peut-être, mais ils seront là, travaillant tranquillement, pendant que les secondes s’écoulent jusqu’à environ trois heures et quart du matin du 19 janvier 2038.

Mais des appareils comme celui-ci devraient être une infime minorité. La grande majorité des systèmes verront le temps critique aller et venir sans incident. Encore une fois, nous allons pouvoir nous détendre. Au moins, jusqu’à ce que l’année 2486 approche, entraînant exactement le même problème pour les systèmes qui utilisent des entiers basés sur 64 bits pour compter le temps écoulé depuis l’époque.

La commande de date

Nous pouvons utiliser le date La commande pour vérifier Linux et d’autres dérivés d’Unix utilise toujours le schéma original et simple de stockage de la valeur temporelle en nombre de secondes depuis l’époque.

En utilisant le date La commande sans aucun paramètre imprime la date et l’heure actuelles dans la fenêtre du terminal. Le fuseau horaire pour lequel l’heure est ajustée s’affiche également. EDT est l’heure avancée de l’Est, ce qui signifie que notre ordinateur de test se trouve dans le fuseau horaire de l’Est, et heure d’été est en vigueur. Lorsque l’heure d’été n’est pas en vigueur, le fuseau horaire de l’Est utilise l’heure normale de l’Est.

Pour voir la valeur entière sous-jacente, nous pouvons utiliser une chaîne de format d’affichage. Les chaînes de format ont un signe plus « + » comme premier caractère. Le jeton de format « %s » signifie « afficher les secondes depuis l’époque ».

Si nous prenons la valeur des secondes renvoyée par date et le réinjecter dans le date commande avec le -d (heure d’affichage décrite par une chaîne), elle la reconvertira en une date et une heure normales.

date

date +%s

date -d @1633183955

Nous pouvons montrer que la valeur entière représente vraiment le temps en affichant le nombre de secondes, en dormant pendant 10 secondes et en affichant le nouveau nombre de secondes. Les deux valeurs entières seront différentes d’exactement 10.

date +%s && sleep 10 && date +%s

On a vu qu’on peut passer quelques secondes au date commande et il se convertit en une heure et une date pour nous. Si nous faisons exactement cela en utilisant zéro seconde comme entrée de notre valeur, date devrait imprimer la date et l’heure de l’époque Unix.

TZ='UTC' date -d @0 +'%x %R'

La commande se décompose ainsi :

• TZ=’UTC’: L’époque a été définie en utilisant le temps universel coordonné (UTC, nous devons donc dire date pour utiliser UTC. La construction « TZ= » définit le fuseau horaire effectif pour la commande actuelle uniquement.
• Date: Les date commander.
• -d @0: Nous disons date pour utiliser une chaîne comme entrée, pas l’heure « en ce moment ». La chaîne que nous passons contient zéro seconde.
• +’%x %R’: la chaîne de format de sortie. Le jeton de format « %x » indique date pour afficher l’année, le mois et le jour. Le jeton au format « %R » indique date pour utiliser le format 24 heures pour les heures et les minutes. Parce qu’il y a des espaces dans la chaîne de format, nous enveloppons la chaîne entière entre guillemets simples ” ' ” afin qu’il s’agisse de la chaîne traitée comme un seul élément.

Comme prévu, la sortie est à minuit le 1er janvier 1970.

Jusqu’à la prochaine fois

La simplicité est souvent la meilleure. Compter les secondes à partir d’une donnée fixe est le moyen le plus simple de marquer le passage du temps. Mais le passage du temps apporte de nouveaux défis. Avec les correctifs qui ont été mis en place, il semble que nous soyons clairs jusqu’en 2486.

Je pense qu’il est prudent de dire que nous nous en préoccuperons un peu plus près du moment.