Comprendre les processus sous Linux

Ce tutoriel donne des détails sur ce que sont les processus, comment ils sont utilisés et comment ils peuvent être gérés sous Linux.

En tant qu'administrateur système, vous avez probablement interagi avec des processus de différentes manières.

Parfois, vous souhaiterez peut-être exécuter des commandes afin d'identifier les processus qui consomment beaucoup de ressources sur votre hébergeur.

Vous avez peut-être reçu un appel d'un utilisateur indiquant que l'un de ses processus était bloqué et que vous deviez peut-être le tuer pour continuer à travailler.

Les processus sont vraiment au centre du système d'exploitation Linux :créés par le noyau lui-même, ils représentent les opérations en cours d'exécution qui se déroulent actuellement sur votre hôte Linux.

Les processus sont partout, ils peuvent s'exécuter en arrière-plan ou vous pouvez choisir de les initialiser vous-même pour des opérations personnalisées.

Vous pouvez choisir de commencer eux, pour interrompre eux, pour reprendre eux ou pour arrêter eux.

Dans le didacticiel d'aujourd'hui, nous examinons de très près les processus, ce qu'ils sont et comment ils sont utilisés sur notre système d'exploitation.

Nous découvrirons toutes les commandes associées aux processus, quels sont les signaux et comment nous pouvons affecter plus de ressources de calcul à nos processus existants.

Prêt ?

Ce que vous allez apprendre

En lisant ce tutoriel jusqu'à la fin, vous découvrirez les concepts suivants

Ce que traite sont et comment ils sont créés sur un système Linux
Comment les processus peuvent être identifiés sur un système Linux
Quel contexte et au premier plan les processus sont
Qu'est-ce que signale sont et comment ils peuvent être utilisés pour interagir avec les processus
Comment utiliser le pgrep ainsi que le pkill commander efficacement
Comment ajuster la priorité des processus à l'aide de nice et renice
Comment voir l'activité des processus en temps réel sous Linux

C'est un programme assez long, alors sans plus tarder, commençons par une brève description de ce que sont les processus.

Principes de base des processus Linux

En bref, les processus exécutent des programmes sur votre hôte Linux qui effectuent des opérations telles que l'écriture sur un disque, l'écriture dans un fichier ou l'exécution d'un serveur Web par exemple.

Le processus a un propriétaire et ils sont identifiés par un ID de processus (également appelé PID )

D'autre part, les programmes sont des lignes ou du code ou des lignes d'instructions machine stockées sur un stockage de données persistant.

Ils peuvent simplement rester sur votre stockage de données ou être en cours d'exécution, c'est-à-dire en tant que processus.

Afin d'effectuer les opérations qui leur sont assignées, les processus ont besoin de ressources :temps CPU , mémoire (comme la RAM ou espace disque ), mais aussi de la mémoire virtuelle comme l'espace de swap au cas où votre processus deviendrait trop gourmand.

Évidemment, les processus peuvent être démarrés , arrêté , interrompu et même tué .

Avant d'émettre des commandes, voyons comment les processus sont créés et gérés par le noyau lui-même.

Initialisation du processus sous Linux

Comme nous l'avons déjà dit, les processus sont gérés par le noyau sur Linux.

Cependant, il existe un concept de base que vous devez comprendre afin de savoir comment Linux crée des processus.

Par défaut, lorsque vous démarrez un système Linux, votre noyau Linux est chargé en mémoire, il reçoit un système de fichiers virtuel dans la RAM (également appelé initramfs ) et les commandes initiales sont exécutées.

L'une de ces commandes démarre le tout premier processus sous Linux.

Historiquement, ce processus s'appelait le processus init, mais il a été remplacé par le processus d'initialisation systemd sur de nombreuses distributions Linux récentes.

Pour le prouver, exécutez la commande suivante sur votre hébergeur

$ ps -aux | head -n 2

Comme vous pouvez le voir, le processus systemd a un PID de 1.

Si vous deviez imprimer tous les processus sur votre système, en utilisant un affichage arborescent, vous constateriez que tous les processus sont des enfants de systemd.

$ pstree

Il convient de souligner le fait que toutes ces étapes d'initialisation (à l'exception du lancement du processus initial) se font dans un espace réservé appelé l'espace noyau.

L'espace noyau est un espace réservé au noyau afin qu'il exécute correctement les outils système essentiels et pour s'assurer que l'ensemble de votre hôte fonctionne de manière cohérente.

En revanche, l'espace utilisateur est réservé aux processus lancé par l'utilisateur et géré par le noyau lui-même.

Par conséquent, le processus systemd est le tout premier processus lancé dans l'espace utilisateur.

Création de processus à l'aide de Fork et Exec

Lorsque vous créez et exécutez un programme sous Linux, cela implique généralement deux étapes principales :fork et exécuter .

Fonctionnement en fourche

Fork est une opération de clonage, il prend le processus actuel, également appelé processus parent, et le clone dans un nouveau processus avec un tout nouvel ID de processus.

Lors du fork, tout est copié depuis le processus parent :la pile , le tas , mais aussi les descripteurs de fichiers signifiant l'entrée standard, la sortie standard et l'erreur standard.

Cela signifie que si mon processus parent écrivait sur la console shell actuelle, le processus enfant écrira également sur la console shell.

L'exécution du processus cloné commencera également à la même instruction que le processus parent.

Exécuter l'opération

L'opération d'exécution est utilisée sous Linux pour remplacer l'image de processus actuelle par l'image d'un autre processus.

Sur le schéma précédent, nous avons vu que la pile du processus parent contenait trois instructions restantes.

Par conséquent, les instructions ont été copiées dans le nouveau processus mais elles ne sont pas pertinentes pour ce que nous voulons exécuter.

L'opération exec remplacera l'image de processus (c'est-à-dire l'ensemble d'instructions qui doivent être exécutées) par une autre.

Si vous deviez par exemple exécuter la commande exec dans votre terminal bash, votre shell se terminerait dès que la commande serait terminée car votre image de processus actuelle (votre interpréteur bash) serait remplacée par le contexte de la commande que vous essayez de lancer .

$ exec ls -l

Si vous deviez retracer les appels système effectués lors de la création d'un processus, vous constateriez que la première commande C appelée est exec.

Créer des processus à partir d'un environnement shell

Lorsque vous lancez une console shell, les mêmes principes s'appliquent lorsque vous lancez une commande.

Une console shell est un processus qui attend une entrée de l'utilisateur.

Il lance également un interpréteur bash lorsque vous appuyez sur Entrée et fournit un environnement pour l'exécution de vos commandes.

Mais le shell suit les étapes que nous avons décrites précédemment.

Lorsque vous appuyez sur Entrée, le shell est dérivé vers un processus enfant qui sera responsable de l'exécution de votre commande. Le shell attendra patiemment la fin de l'exécution du processus enfant.

D'autre part, le processus enfant est lié aux mêmes descripteurs de fichiers et il peut partager des variables qui ont été déclarées sur une portée globale.

Le processus enfant exécute le "exec ” afin de remplacer l'image de processus actuelle (qui est l'image de processus du shell) dans l'image de processus de la commande que vous essayez d'exécuter.

Le processus enfant finira par se terminer et il imprimera son résultat sur la sortie standard héritée du processus parent, dans ce cas la console shell elle-même.

Maintenant que vous avez quelques bases sur la façon dont les processus sont créés dans votre environnement Linux, voyons quelques détails sur les processus et comment ils peuvent être facilement identifiés.

Identifier les processus en cours d'exécution sous Linux

Le moyen le plus simple d'identifier les processus en cours d'exécution sous Linux consiste à exécuter le ps commande.

$ ps

Par défaut, la commande ps vous montrera la liste des processus en cours d'exécution appartenant à l'utilisateur actuel.

Dans ce cas, seuls deux processus sont en cours d'exécution pour mon utilisateur :l'interpréteur bash et la commande ps Je suis tombé dessus.

La partie importante ici est que les processus ont des propriétaires , la plupart du temps l'utilisateur qui les exécute en premier lieu.

Pour illustrer cela, prenons une liste des dix premiers processus de votre système d'exploitation Linux, avec un format d'affichage différent.

$ ps -ef | head -n 10

Comme vous pouvez le voir ici, les dix principaux processus appartiennent à l'utilisateur "root ".

Ces informations seront particulièrement importantes lorsqu'il s'agira d'interagir avec des processus avec des signaux.

Pour afficher les processus détenus et exécutés par l'utilisateur actuellement connecté, exécutez la commande suivante

$ ps u

Il existe de nombreuses options différentes pour la commande ps, et elles peuvent être vues en exécutant la commande manuelle.

$ man ps

Par expérience, les deux commandes les plus importantes pour voir les processus en cours d'exécution sont

ps aux

USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND

Cela correspond à une liste de processus de style BSD , où la commande suivante

ps -ef

UID  PID  PPID C STIME TTY  TIME CMD

Correspond à une liste de processus de style POSIX .

Ils représentent tous les deux les processus en cours d'exécution sur un système, mais le premier a l'option "u" pour "orienté utilisateur" qui facilite la lecture des métriques de processus.

Maintenant que vous avez vu ce que sont les processus et comment ils peuvent être répertoriés, voyons quels sont les processus d'arrière-plan et de premier plan sur votre hôte.

Processus d'arrière-plan et de premier plan

La définition des processus d'arrière-plan et de premier plan est assez explicite.

Tâches et processus dans le shell actuel

Un processus d'arrière-plan sous Linux est un processus qui s'exécute en arrière-plan, ce qui signifie qu'il n'est pas géré activement par un utilisateur via un shell par exemple.

À l'opposé, un processus de premier plan est un processus avec lequel il est possible d'interagir via une entrée directe de l'utilisateur.

Disons par exemple que vous avez ouvert un terminal shell, et que vous avez tapé la commande suivante dans votre console.

$ sleep 10000

Comme vous l'avez probablement remarqué, votre terminal restera bloqué jusqu'à la fin du processus de mise en veille. Par conséquent, le processus n'est pas exécuté en arrière-plan, il est exécuté au premier plan.

Je suis capable d'interagir avec. Si j'appuie sur Ctrl + Z, cela enverra directement un signal d'arrêt au processus par exemple.

Cependant, il existe un moyen d'exécuter le processus en arrière-plan.

Pour exécuter un processus en arrière-plan, il suffit de mettre un "& ” signe à la fin de votre commande.

$ sleep 10000 &

Comme vous pouvez le voir, le contrôle a été directement rendu à l'utilisateur et le processus a commencé à s'exécuter en arrière-plan

Pour voir votre processus en cours d'exécution, dans le contexte du shell actuel, vous pouvez exécuter la commande jobs

$ jobs

Les travaux sont une liste de processus qui ont été démarrés dans le contexte du shell actuel et qui peuvent encore s'exécuter en arrière-plan.

Comme vous pouvez le voir dans l'exemple ci-dessus, j'ai deux processus en cours d'exécution en arrière-plan.

Les différentes colonnes de gauche à droite représentent l'ID de la tâche, l'état du processus (que vous découvrirez dans la section suivante), et la commande exécutée.

Utilisation des commandes bg et fg

Pour interagir avec les jobs, vous disposez de deux commandes :bg et fg .

La commande bg est utilisée sous Linux afin d'envoyer un processus en arrière-plan et la syntaxe est la suivante

$ bg %<job_id>

De même, pour envoyer un processus au premier plan, vous pouvez utiliser le fg de la même façon

$ fg %<job_id>

Si nous revenons à la liste des jobs de notre exemple précédent, si je veux amener le job 3 au premier plan, c'est-à-dire à la fenêtre courante du shell, j'exécuterai la commande suivante

$ fg %3

En émettant une commande Ctrl + Z, je suis en mesure d'arrêter le processus. Je peux le lier avec une commande bg afin de l'envoyer en arrière-plan.

Maintenant que vous avez une meilleure idée de ce que sont les processus d'arrière-plan et de premier plan, voyons comment il vous est possible d'interagir avec le processus à l'aide de signaux.

Interagir avec les processus à l'aide de signaux

Sous Linux, les signaux sont une forme de communication interprocessus (également appelé IPC ) qui crée et envoie des notifications asynchrones aux processus en cours d'exécution concernant l'occurrence d'un événement spécifique.

Les signaux sont souvent utilisés pour envoyer une mise à mort ou une commande de terminaison à un processus afin de l'arrêter (aussi appelé kill signal).

Pour envoyer un signal à un processus, vous devez utiliser le kill commande.

$ kill -<signal number> <pid>|<process_name>

Par exemple, pour forcer un processus HTTPD (PID =123) à se terminer (sans arrêt propre), vous exécuterez la commande suivante

$ kill -9 123

Catégories de signaux expliquées

Comme expliqué, il existe de nombreux signaux que l'on peut envoyer afin de notifier un processus spécifique.

Voici la liste des plus couramment utilisés :

SIGINT :l'abréviation de signal interrupt est un signal utilisé pour interrompre un processus en cours d'exécution. C'est aussi le signal qui est envoyé lorsqu'un utilisateur appuie sur Ctrl + C sur un terminal ;
SIGHUP :abréviation de signal hangup est le signal envoyé par votre terminal lorsqu'il est fermé. Comme pour un SIGINT, le processus se termine ;
SIGKILL :signal utilisé pour forcer un processus à s'arrêter, qu'il puisse être arrêté gracieusement ou non. Ce signal ne peut être ignoré sauf pour le processus init (ou systemd sur les distributions récentes) ;

SIGQUITTER :signal spécifique envoyé lorsqu'un utilisateur veut quitter ou quitter le processus en cours. Il peut être appelé en appuyant sur Ctrl + D et il est souvent utilisé dans les shells de terminaux ou dans les sessions SSH ;
SIGUSR1, SIGUSR2 :ces signaux sont utilisés uniquement à des fins de communication et peuvent être utilisés dans des programmes afin d'implémenter des gestionnaires personnalisés ;
SIGSTOP :ordonne au processus d'arrêter son exécution sans terminer le processus. Le processus attend alors d'être poursuivi ou d'être complètement tué ;
SIGCONT :si le processus est marqué comme arrêté, il ordonne au processus de recommencer son exécution.

Afin de voir la liste complète de tous les signaux disponibles, vous pouvez exécuter la commande suivante

$ kill -l

 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL
 5) SIGTRAP      6) SIGABRT      7) SIGBUS       8) SIGFPE
 9) SIGKILL     10) SIGUSR1     11) SIGSEGV     12) SIGUSR2
13) SIGPIPE     14) SIGALRM     15) SIGTERM     16) SIGSTKFLT
17) SIGCHLD     18) SIGCONT     19) SIGSTOP     20) SIGTSTP
21) SIGTTIN     22) SIGTTOU     23) SIGURG      24) SIGXCPU
25) SIGXFSZ     26) SIGVTALRM   27) SIGPROF     28) SIGWINCH
29) SIGIO       30) SIGPWR      31) SIGSYS      34) SIGRTMIN
35) SIGRTMIN+1  36) SIGRTMIN+2  37) SIGRTMIN+3  38) SIGRTMIN+4
39) SIGRTMIN+5  40) SIGRTMIN+6  41) SIGRTMIN+7  42) SIGRTMIN+8
43) SIGRTMIN+9  44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12
47) SIGRTMIN+13 48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14
51) SIGRTMAX-13 52) SIGRTMAX-12 53) SIGRTMAX-11 54) SIGRTMAX-10
55) SIGRTMAX-9  56) SIGRTMAX-8  57) SIGRTMAX-7  58) SIGRTMAX-6
59) SIGRTMAX-5  60) SIGRTMAX-4  61) SIGRTMAX-3  62) SIGRTMAX-2
63) SIGRTMAX-1  64) SIGRTMAX

États des signaux et des processus

Maintenant que vous savez qu'il est possible d'interrompre, de tuer ou d'arrêter des processus, il est temps pour vous de vous renseigner sur les états des processus.

Les processus ont de nombreux états différents, ils peuvent être :

En cours d'exécution :les processus en cours d'exécution sont ceux qui utilisent une certaine puissance de calcul (comme le temps CPU) à l'heure actuelle. Un processus peut également être appelé "exécutable" si toutes les conditions d'exécution sont remplies et qu'il attend un certain temps CPU par le planificateur CPU.
Arrêté :un signal est arrêté est lié au signal SIGSTOP ou au raccourci clavier Ctrl + Z. L'exécution du processus est suspendue et il attend soit un SIGCONT, soit un SIGKILL.
Dormir :un processus endormi est un processus qui attend qu'un événement ou qu'une ressource (comme un disque) soit disponible.

Voici un schéma qui représente les différents états des processus liés aux signaux que vous pouvez leur envoyer.

Maintenant que vous en savez un peu plus sur les états de processus, examinons les commandes pgrep et pkill.

Manipulation du processus avec pgrep et pkill

Sous Linux, il y a déjà beaucoup de choses que vous pouvez faire en utilisant simplement la commande ps.

Vous pouvez restreindre votre recherche à un processus particulier et vous pouvez utiliser le PID pour le tuer complètement.

Cependant, il y a deux commandes qui ont été conçues pour que vos commandes soient encore plus courtes :pgrep et pkill

Utiliser la commande pgrep

Le pgrep La commande est un raccourci pour utiliser la commande ps canalisée avec la commande grep.

La commande pgrep recherchera toutes les occurrences d'un processus spécifique en utilisant un nom ou un modèle défini.

La syntaxe de la commande pgrep est la suivante

$ pgrep <options> <pattern>

Par exemple, si vous deviez rechercher tous les processus nommés "bash" sur votre hôte, vous exécuteriez la commande suivante

$ pgrep bash

La commande pgrep n'est pas limitée aux processus appartenant à l'utilisateur actuel par défaut.

Si un autre utilisateur devait exécuter la commande bash, elle apparaîtrait dans la sortie de la commande pgrep.

Il est également possible de rechercher des processus à l'aide de caractères génériques.

Utiliser la commande pkill

D'autre part, la commande pkill est également un raccourci pour la commande ps utilisée avec la commande kill.

La commande pkill est utilisée pour envoyer un signal aux processus en fonction de leurs identifiants ou de leurs noms.

La syntaxe de la commande pkill est la suivante

$ pkill <options> <pattern>

Par exemple, si vous voulez tuer toutes les fenêtres Firefox sur votre hôte, vous exécuterez la commande suivante

$ pkill firefox

Comme pour la commande pgrep, vous avez la possibilité d'affiner vos résultats en spécifiant un utilisateur avec l'option -u.

Pour tuer tous les processus commençant par "fire" et appartenant à l'utilisateur et à la racine actuels, vous devez exécuter la commande suivante

$ pkill user,root fire*

Si vous n'avez pas le droit d'arrêter un processus, vous recevrez un message d'erreur d'autorisation refusée sur votre sortie standard.

Vous avez également la possibilité d'envoyer des signaux spécifiques en spécifiant le numéro de signal dans la commande pkill

Par exemple, pour arrêter Firefox avec un signal SIGSTOP, vous exécuterez la commande suivante

$ pkill -19 firefox

Ajustement de la priorité des processus à l'aide de nice et renice

Sous Linux, tous les processus n'ont pas la même priorité en ce qui concerne le temps CPU.

Certains processus, tels que les processus très importants exécutés par root, reçoivent une priorité plus élevée afin que le système d'exploitation puisse travailler sur des tâches qui comptent vraiment pour le système.

La priorité des processus sous Linux est appelée le niveau agréable.

Le niveau gentil est une échelle de priorité allant de -20 à 19.

Plus vous descendez sur l'échelle de gentillesse, plus la priorité sera élevée.

De même, plus vous êtes haut sur l'échelle de gentillesse, plus votre priorité sera faible.

Pour vous en souvenir, vous pouvez vous souvenir du fait que "plus vous êtes gentil, plus vous êtes prêt à partager des ressources avec les autres".

Afin de démarrer un certain programme ou processus avec un niveau de confort donné, vous exécuterez la commande suivante

$ nice -n <level> <command>

Par exemple, pour exécuter la commande tar avec un niveau de tar personnalisé, vous devez exécuter la commande suivante

$ nice -n 19 tar -cvf test.tar file

De même, vous pouvez utiliser la commande renice pour définir le niveau de gentillesse d'un processus en cours d'exécution sur une valeur donnée.

$ renice -n <priority> <pid>

Par exemple, si j'ai un processus en cours d'exécution avec le PID 123, je peux utiliser la commande renice afin de définir sa priorité sur une valeur donnée.

$ renice -n 18 123

Gentillesse et autorisations

Si vous n'êtes pas membre du groupe sudo (ou membre du groupe wheel sur les distributions basées sur Red Hat), il existe certaines restrictions concernant ce que vous pouvez faire avec la commande nice.

Pour l'illustrer, essayez d'exécuter la commande suivante en tant qu'utilisateur non sudo

$ nice -n -1 tar -cvf test.tar file

nice: cannot set niceness: Permission denied

En matière de gentillesse, il y a une règle que vous devez connaître :

En tant qu'utilisateur non root (ou sudo), vous ne pourrez pas définir un niveau agréable inférieur à celui attribué par défaut (qui est zéro), et vous ne pourrez pas modifier un processus en cours d'exécution pour un niveau inférieur à celui actuel.

Pour illustrer le dernier point, lancez une commande sleep en arrière-plan avec une belle valeur de 2.

$ nice -n 2 sleep 10000 &

Ensuite, identifiez l'ID de processus du processus que vous venez de créer.

Maintenant, essayez de définir le niveau de satisfaction de votre processus sur une valeur inférieure à celle que vous avez spécifiée en premier lieu.

$ renice -n 1 8363

Comme vous l'avez probablement remarqué, vous ne pourrez pas définir le niveau de gentillesse sur 1, mais uniquement sur une valeur supérieure à celle que vous avez spécifiée.

Maintenant, si vous choisissez d'exécuter la commande en tant que sudo, vous pourrez définir le niveau de gentillesse sur une valeur inférieure.

Maintenant que vous avez une idée claire des commandes nice et renice, voyons comment vous pouvez surveiller vos processus en temps réel sous Linux.

Surveillance des processus sous Linux à l'aide de top et htop

Dans un article précédent, nous avons expliqué comment il est possible de construire un pipeline de surveillance complet afin de surveiller les processus Linux en temps réel.

Utiliser top sous Linux

Top est une commande interactive que n'importe quel utilisateur peut exécuter afin d'avoir une liste complète et ordonnée de tous les processus exécutés sur un hôte Linux.

Pour exécuter top, exécutez-le simplement sans aucun argument.

Top fonctionnera en mode interactif.

$ top

Si vous souhaitez exécuter top pour un nombre personnalisé d'itérations, exécutez la commande suivante

$ top -n <number>

La commande top affichera d'abord des statistiques récapitulatives sur votre système en haut, par exemple le nombre de tâches en cours d'exécution, le pourcentage de CPU utilisé ou la consommation de mémoire.

Juste en dessous, vous avez accès à une liste en direct de tous les processus en cours d'exécution ou en veille sur votre hôte.

Cette vue sera actualisée toutes les trois secondes, mais vous pouvez évidemment modifier ce paramètre.

Pour augmenter le taux de rafraîchissement dans la commande du haut, appuyez sur la commande "d" et choisissez un nouveau taux de rafraîchissement

De même, vous pouvez modifier la valeur nice d'un processus en cours d'exécution en appuyant sur la touche "r" de votre clavier.

Les mêmes règles d'autorisations s'appliquent si vous souhaitez modifier les processus à une valeur inférieure à celle qui leur est déjà attribuée.

Par conséquent, vous devrez peut-être exécuter la commande en tant que sudo.

Utiliser htop sous Linux

Alternativement, si vous cherchez une meilleure façon de visualiser les processus sur votre hôte Linux, vous pouvez utiliser la commande htop.

Par défaut, la commande htop n'est pas disponible sur la plupart des distributions, vous devrez donc l'installer en suivant les instructions suivantes.

$ sudo apt-get update
$ sudo apt-get install htop

Si vous exécutez une distribution basée sur Red Hat, exécutez les commandes suivantes.

$ sudo yum -y install epel-release
$ sudo yum -y update
$ sudo yum -y install htop

Enfin, pour exécuter la commande htop, exécutez-la simplement sans aucun argument.

$ htop

Comme vous pouvez le voir, la sortie est très similaire, sauf qu'elle présente les informations dans une sortie plus conviviale.

Conclusion

Dans ce didacticiel, vous avez appris de nombreux concepts sur les processus :comment ils sont créés, comment ils peuvent être gérés et comment ils peuvent être surveillés efficacement.

Si vous recherchez d'autres tutoriels liés à l'administration système Linux, nous avons une section complète qui lui est consacrée sur le site Web, alors assurez-vous de la consulter.