manpages-fr - en to fr_FR translation catalogue (193 entries)

note: ----------------------------------------------------------------- * MAIN CONTENT STARTS HERE * type: SH
en: NAME
fr_FR: NOM

note: type: Plain text
en: systemd-analyze - Analyze and debug system manager
fr_FR: systemd-analyze - Analyser et déboguer le gestionnaire du système

note: type: Plain text
en: B<systemd-analyze> [OPTIONS...] critical-chain [I<UNIT>...]
fr_FR: B<systemd-analyze> [OPTIONS...] critical-chain [I<UNITÉ>...]

note: type: Plain text
en: B<systemd-analyze> [OPTIONS...] dump [I<PATTERN>...]
fr_FR: B<systemd-analyze> [OPTIONS...] dump [I<MOTIF>...]

note: type: Plain text
en: B<systemd-analyze> [OPTIONS...] plot [E<gt>file\&.svg]
fr_FR: B<systemd-analyze> [OPTIONS...] plot [E<gt>fichier\&.svg]

note: type: Plain text
en: B<systemd-analyze> [OPTIONS...] dot [I<PATTERN>...] [E<gt>file\&.dot]
fr_FR: B<systemd-analyze> [OPTIONS...] dot [I<MOTIF>...] [E<gt>fichier\&.dot]

note: type: Plain text
en: B<systemd-analyze> [OPTIONS...] exit-status [I<STATUS>...]
fr_FR: B<systemd-analyze> [OPTIONS...] exit-status [I<ÉTAT>...]

note: type: Plain text
en: B<systemd-analyze> [OPTIONS...] capability [I<CAPABILITY>...]
fr_FR: B<systemd-analyze> [OPTIONS...] capability [I<CAPACITÉ>...]

note: type: Plain text
en: B<systemd-analyze> [OPTIONS...] syscall-filter [I<SET>\&...]
fr_FR: B<systemd-analyze> [OPTIONS...] syscall-filter [I<ENSEMBLE>\&...]

note: type: Plain text
en: B<systemd-analyze> [OPTIONS...] filesystems [I<SET>\&...]
fr_FR: B<systemd-analyze> [OPTIONS...] filesystems [I<ENSEMBLE>\&...]

note: type: Plain text
en: B<systemd-analyze> [OPTIONS...] timestamp I<TIMESTAMP>...
fr_FR: B<systemd-analyze> [OPTIONS...] timestamp I<HORODATAGE>...

note: type: Plain text
en: B<systemd-analyze> [OPTIONS...] timespan I<SPAN>...
fr_FR: B<systemd-analyze> [OPTIONS...] timespan I<DURÉE>...

note: type: Plain text
en: B<systemd-analyze> [OPTIONS...] cat-config I<NAME>|I<PATH>...
fr_FR: B<systemd-analyze> [OPTIONS...] cat-config I<NOM>|I<CHEMIN>...

note: type: Plain text
en: B<systemd-analyze> [OPTIONS...] verify [I<FILE>...]
fr_FR: B<systemd-analyze> [OPTIONS...] verify [I<FICHIER>...]

note: type: Plain text
en: B<systemd-analyze> [OPTIONS...] security I<UNIT>...
fr_FR: B<systemd-analyze> [OPTIONS...] security I<UNITÉ>...

note: type: Plain text
en: B<systemd-analyze> [OPTIONS...] inspect-elf I<FILE>...
fr_FR: B<systemd-analyze> [OPTIONS...] inspect-elf I<FICHIER>...

note: type: Plain text
en: B<systemd-analyze> may be used to determine system boot-up performance statistics and retrieve other state and tracing information from the system and service manager, and to verify the correctness of unit files\&. It is also used to access special functions useful for advanced system manager debugging\&.
fr_FR: B<systemd-analyze> peut être utilisée pour déterminer les statistiques de performance du démarrage du système et récupérer d'autres informations d'état et de traçage du système et du gestionnaire de services, et vérifier la justesse des fichiers d'unité\&. Elle est aussi utilisée pour accéder à des fonctions spéciales utiles au débogage avancé du gestionnaire du système\&.

note: type: Plain text
en: If no command is passed, B<systemd-analyze time> is implied\&.
fr_FR: Si aucune commande n'est passée, B<systemd-analyze-time> est implicite\&.

note: type: Plain text
en: This command prints the time spent in the kernel before userspace has been reached, the time spent in the initrd before normal system userspace has been reached, and the time normal system userspace took to initialize\&. Note that these measurements simply measure the time passed up to the point where all system services have been spawned, but not necessarily until they fully finished initialization or the disk is idle\&.
fr_FR: Cette commande affiche le temps écoulé dans le noyau avant que l'espace utilisateur n'ait été atteint, le temps écoulé dans l'initrd avant que l'espace utilisateur normal du système ne soit atteint, et le temps pris par l'espace utilisateur normal du système pour s'initialiser\&. Notez que ces mesures ne font que mesurer le temps écoulé jusqu'au moment où tous les services du système ont été lancés, mais pas nécessairement jusqu'à ce qu'ils aient terminé leur initialisation ou que le disque soit inactif\&.

note: type: Plain text
en: B<Example\ \&1.\ \&Show how long the boot took>
fr_FR: B<Exemple\ \&1.\ \&Afficher la durée de l'amorçage (boot)>

note: type: Plain text
en: # in a container
    $ systemd-analyze time
    Startup finished in 296ms (userspace)
    multi-user\&.target reached after 275ms in userspace
fr_FR: # dans un conteneur
    $ systemd-analyze time
    Startup finished in 296ms (userspace)
    multi-user\&.target reached after 275ms in userspace

note: type: Plain text
en: # on a real machine
    $ systemd-analyze time
    Startup finished in 2\&.584s (kernel) + 19\&.176s (initrd) + 47\&.847s (userspace) = 1min 9\&.608s
    multi-user\&.target reached after 47\&.820s in userspace
fr_FR: # sur une vraie machine
    $ systemd-analyze time
    Startup finished in 2\&.584s (kernel) + 19\&.176s (initrd) + 47\&.847s (userspace) = 1min 9\&.608s
    multi-user\&.target reached after 47\&.820s in userspace

note: type: Plain text
en: This command prints a list of all running units, ordered by the time they took to initialize\&. This information may be used to optimize boot-up times\&. Note that the output might be misleading as the initialization of one service might be slow simply because it waits for the initialization of another service to complete\&. Also note: B<systemd-analyze blame> doesn\*(Aqt display results for services with I<Type=simple>, because systemd considers such services to be started immediately, hence no measurement of the initialization delays can be done\&. Also note that this command only shows the time units took for starting up, it does not show how long unit jobs spent in the execution queue\&. In particular it shows the time units spent in "activating" state, which is not defined for units such as device units that transition directly from "inactive" to "active"\&. This command hence gives an impression of the performance of program code, but cannot accurately reflect latency introduced by waiting for hardware and similar events\&.
fr_FR: Cette commande affiche une liste de toutes les unités en service, classées en fonction du temps passé à s'initialiser\&. Cette information peut être utilisée pour optimiser les temps d'amorçage\&. Prenez en compte que la sortie peut être trompeuse étant donné que l'initialisation d'un service peut apparaître lente simplement parce qu'il attend l'initialisation d'un autre service pour se finaliser\&. Notez aussi : B<systemd-analyze blame> n'affiche pas de résultats pour les services avec I<Type=simple>, car systemd considère de tels services comme démarrant immédiatement, ce qui fait qu'aucune mesure de délai d'initialisation ne peut être faite\&. Notez aussi que cette commande ne montre que le temps pris par les unités pour démarrer, elle ne montre pas combien de temps ont passé les tâches de l'unité dans la file d'attente d'exécutions\&. Cela montre en particulier le temps que l'unité a passé en état « actif », lequel n'est pas défini pour les unités telles que les unités périphériques qui effectuent une transition directement d'« inactive » à « active »\&. Cette commande donne ainsi une impression de la performance du code du programme, mais ne peut refléter avec exactitude la latence introduite par l'attente du matériel et d'évènements similaires\&.

note: type: Plain text
en: B<Example\ \&2.\ \&Show which units took the most time during boot>
fr_FR: B<Exemple\ \&2.\ \&Afficher quelles unités prennent le plus de temps lors de l'amorçage>

note: type: SS
en: systemd-analyze critical-chain [I<UNIT>R<\&.\&.\&.]>
fr_FR: systemd-analyze critical-chain [I<UNITÉ>R<\&.\&.\&.]>

note: type: Plain text
en: This command prints a tree of the time-critical chain of units (for each of the specified I<UNIT>s or for the default target otherwise)\&. The time after the unit is active or started is printed after the "@" character\&. The time the unit takes to start is printed after the "+" character\&. Note that the output might be misleading as the initialization of services might depend on socket activation and because of the parallel execution of units\&. Also, similarly to the B<blame> command, this only takes into account the time units spent in "activating" state, and hence does not cover units that never went through an "activating" state (such as device units that transition directly from "inactive" to "active")\&. Moreover it does not show information on jobs (and in particular not jobs that timed out)\&.
fr_FR: Cette commande affiche un arbre de la chaîne de temps critique d'unités (pour chacune des I<UNITÉ>s indiquées ou pour la cible par défaut sinon)\&. Le temps écoulé pour que l'unité soit active ou démarrée est affiché après le caractère « @ »\&. Le temps pris par l'unité pour démarrer est affiché après le caractère « + »\&. Notez que la sortie peut être inexacte dans la mesure où l'initialisation de services pourrait dépendre de l'activation d'un socket et à cause de l'exécution en parallèle d'unités\&. Aussi, à l'instar de la commande B<blame>, cette commande ne prend en compte que le temps passé par les unités en état d'« activation », et donc ne couvre pas les unités qui ne sont jamais passées par un état d'« activation » (telles les unités de périphériques d'unité qui passent directement de l'état « inactif » à « actif »)\&. En outre, elle ne montre pas d'information sur les tâches (et en particulier sur les tâches achevées)\&.

note: type: Plain text
en: B<Example\ \&3.\ \&systemd-analyze critical-chain>
fr_FR: B<Exemple\ \&3.\ \&systemd-analyze critical-chain>

note: type: SS
en: systemd-analyze dump [I<pattern>R<\&...]>
fr_FR: systemd-analyze dump [I<motif>R<\&...]>

note: type: Plain text
en: Without any parameter, this command outputs a (usually very long) human-readable serialization of the complete service manager state\&. Optional glob pattern may be specified, causing the output to be limited to units whose names match one of the patterns\&. The output format is subject to change without notice and should not be parsed by applications\&. This command is rate limited for unprivileged users\&.
fr_FR: Sans aucun paramètre, cette commande renvoie une sérialisation lisible (habituellement très longue) de l'état complet du gestionnaire de services. Un motif global (glob) facultatif peut être spécifié, limitant la sortie aux unités dont les noms correspondent à l'un des motifs\&. Le format de sortie est susceptible d'être modifié sans préavis et ne devrait pas être soumis à l'analyse par des applications\&. Cette commande a un débit limité pour les utilisateurs non privilégiés

note: type: Plain text
en: B<Example\ \&4.\ \&Show the internal state of user manager>
fr_FR: B<Exemple\ \&4.\ \&Afficher l'état interne du gestionnaire utilisateur>

note: type: Plain text
en: This command prints either an SVG graphic, detailing which system services have been started at what time, highlighting the time they spent on initialization, or the raw time data in JSON or table format\&.
fr_FR: Cette commande affiche un graphique SVG détaillant quels services du système ont démarré à quel moment, mettant en évidence le temps passé à leur initialisation, ou les données horaires brutes en format JSON ou tableau\&.

note: type: Plain text
en: B<Example\ \&5.\ \&Plot a bootchart>
fr_FR: B<Exemple\ \&5.\ \&Tracer un graphique d'amorçage>

note: type: Plain text
en: Note that this plot is based on the most recent per-unit timing data of loaded units\&. This means that if a unit gets started, then stopped and then started again the information shown will cover the most recent start cycle, not the first one\&. Thus it\*(Aqs recommended to consult this information only shortly after boot, so that this distinction doesn\*(Aqt matter\&. Moreover, units that are not referenced by any other unit through a dependency might be unloaded by the service manager once they terminate (and did not fail)\&. Such units will not show up in the plot\&.
fr_FR: Il convient de noter que ce graphique est basé sur les données les plus récentes relatives à la synchronisation des unités chargées\&. Cela signifie que si une unité démarre, est stoppée et redémarre encore, les informations affichées ne couvriront que le cycle de démarrage le plus récent, pas le premier\&. Par conséquent, il est conseillé de consulter ces informations peu de temps après l'amorçage, pour que cette distinction importe peu\&. En outre, les unités qui ne sont référencées par aucune autre unité par le biais d'une dépendance peuvent être déchargées par le gestionnaire de service une fois qu'elles se terminent (et qu'elles n'ont pas échoué)\&. Ces unités n'apparaîtront pas dans le graphique\&.

note: type: SS
en: systemd-analyze dot [I<pattern>R<\&.\&.\&.]>
fr_FR: systemd-analyze dot [I<motif>R<\&.\&.\&.]>

note: type: Plain text
en: This command generates textual dependency graph description in dot format for further processing with the GraphViz B<dot>(1)  tool\&. Use a command line like B<systemd-analyze dot | dot -Tsvg E<gt>systemd\&.svg> to generate a graphical dependency tree\&. Unless B<--order> or B<--require> is passed, the generated graph will show both ordering and requirement dependencies\&. Optional pattern globbing style specifications (e\&.g\&.  *\&.target) may be given at the end\&. A unit dependency is included in the graph if any of these patterns match either the origin or destination node\&.
fr_FR: Cette commande génère une description textuelle du graphe de dépendances au format dot pour un traitement ultérieur avec l'outil GraphViz B<dot>(1)\&.  Utilisez une ligne de commande telle que B<systemd-analyze dot | dot -Tsvg E<gt>systemd\&.svg> pour générer un arbre de dépendances graphique\&. À moins que B<--order> ou B<--require> ne soit passées, le graphe obtenu montrera à la fois les dépendances d'ordre et d'exigence\&. Le motif optionnel de spécifications de style globbing (par exemple *\&.cible) peut être donné à la fin\&. Une dépendance d'unité n'est inclue dans le graphe que si l'un des motifs correspond à la fois au nœud d'origine ou de destination\&.

note: type: Plain text
en: B<Example\ \&6.\ \&Plot all dependencies of any unit whose name starts with "avahi-daemon">
fr_FR: B<Exemple\ \&6.\ \&Tracer toutes les dépendances des unités dont le nom commence avec « avahi-daemon »>

note: type: Plain text
en: B<Example\ \&7.\ \&Plot the dependencies between all known target units>
fr_FR: B<Exemple\ \&7.\ \&Tracer les dépendances entre toutes les unités cibles connues>

note: type: Plain text
en: $ systemd-analyze dot --to-pattern=\*(Aq*\&.target\*(Aq --from-pattern=\*(Aq*\&.target\*(Aq \e
          | dot -Tsvg E<gt>targets\&.svg
    $ eog targets\&.svg
fr_FR: $ systemd-analyze dot --to-pattern=\*(Aq*\&.cible\*(Aq --from-pattern=\*(Aq*\&.cible\*(Aq \e
          | dot -Tsvg E<gt>cibles\&.svg
    $ eog cibles\&.svg

note: type: Plain text
en: This command outputs a list of all directories from which unit files, \&.d overrides, and \&.wants, \&.requires symlinks may be loaded\&. Combine with B<--user> to retrieve the list for the user manager instance, and B<--global> for the global configuration of user manager instances\&.
fr_FR: Cette commande affiche une liste de tous les répertoires desquels les fichiers d'unité, \&.d remplace, et les liens symboliques \&.voulu, \&.requis doivent être chargés. À combiner avec B<-- user> pour retrouver la liste pour l'instance du gestionnaire utilisateur, et B<-- global> pour la configuration globale des instances du gestionnaire utilisateur\&.

note: type: Plain text
en: B<Example\ \&8.\ \&Show all paths for generated units>
fr_FR: B<Exemple\ \&8.\ \&Afficher tous les chemins pour les unités générées>

note: type: Plain text
en: Note that this verb prints the list that is compiled into B<systemd-analyze> itself, and does not communicate with the running manager\&. Use
fr_FR: Remarquez que cette commande affiche la liste qui est compilée à l'intérieur de B<systemd-analyze> et ne communique pas avec le gestionnaire en cours d'exécution\&. Utilisez

note: type: Plain text
en: to retrieve the actual list that the manager uses, with any empty directories omitted\&.
fr_FR: pour retrouver la liste réellement utilisée par le gestionnaire, avec tout répertoire vide omis\&.

note: type: SS
en: systemd-analyze exit-status [I<STATUS>R<\&.\&.\&.]>
fr_FR: systemd-analyze exit-status [I<ÉTAT>R<\&.\&.\&.]>

note: type: Plain text
en: This command prints a list of exit statuses along with their "class", i\&.e\&. the source of the definition (one of "glibc", "systemd", "LSB", or "BSD"), see the Process Exit Codes section in B<systemd.exec>(5)\&. If no additional arguments are specified, all known statuses are shown\&. Otherwise, only the definitions for the specified codes are shown\&.
fr_FR: Cette commande affiche une liste des codes de retour avec leur « classe », c'est à dire la source de la définition (une parmi « glibc », « systemd », « LSB » ou « BSD »), voir la section des codes retour des processus dans B<systemd.exec>(5)\&. Si aucun autre argument n'est indiqué, tous les états connus sont affichés\&. Sinon, seules les définitions pour les codes indiqués sont affichées\&.

note: type: Plain text
en: B<Example\ \&9.\ \&Show some example exit status names>
fr_FR: B<Exemple\ \&9.\ \&Afficher quelques exemples de noms d'état de retour>

note: type: SS
en: systemd-analyze capability [I<CAPABILITY>R<\&.\&.\&.]>
fr_FR: systemd-analyze capability [I<CAPACITÉ>R<\&.\&.\&.]>

note: type: Plain text
en: This command prints a list of Linux capabilities along with their numeric IDs\&. See B<capabilities>(7)  for details\&. If no argument is specified the full list of capabilities known to the service manager and the kernel is shown\&. Capabilities defined by the kernel but not known to the service manager are shown as "cap_???"\&. Optionally, if arguments are specified they may refer to specific cabilities by name or numeric ID, in which case only the indicated capabilities are shown in the table\&.
fr_FR: Cette commande affiche une liste des capacités (capabilities) de Linux avec leur identifiant numérique\&. Consulter B<capabilities>(7) pour les détails\&. Si aucun argument n'est indiqué, la liste entière des capacités connues du gestionnaire de services et du noyau est affichée\&. Les capacités définies par le noyau, mais inconnues du gestionnaire de services sont affichées en tant que « cap_??? »\&. En option, si des arguments sont spécifiés, ils doivent se référer aux capacités spécifiées par leur nom ou identifiant numérique, auquel cas seules les capacités indiquées sont montrées dans la table\&.

note: type: Plain text
en: B<Example\ \&10.\ \&Show some example capability names>
fr_FR: B<Exemple\ \&10.\ \&Afficher quelques exemples de noms de capacité>

note: type: Plain text
en: This command will evaluate I<Condition*=\&.\&.\&.> and I<Assert*=\&.\&.\&.> assignments, and print their values, and the resulting value of the combined condition set\&. See B<systemd.unit>(5)  for a list of available conditions and asserts\&.
fr_FR: Cette commande évaluera les affectations I<Condition*=\&.\&.\&.> et I<Assert*=\&.\&.\&.> et affichera leurs valeurs, et la valeur résultante de l'ensemble de conditions jointes\&. Consulter B<systemd.unit>(5) pour une liste des conditions disponibles et assertions\&.

note: type: Plain text
en: B<Example\ \&11.\ \&Evaluate conditions that check kernel versions>
fr_FR: B<Exemple\ \&11.\ \&Evaluer les conditions qui vérifient les versions du noyau>

note: type: SS
en: systemd-analyze syscall-filter [I<SET>R<\&.\&.\&.]>
fr_FR: systemd-analyze syscall-filter [I<ENSEMBLE>R<\&.\&.\&.]>

note: type: Plain text
en: This command will list system calls contained in the specified system call set I<SET>, or all known sets if no sets are specified\&. Argument I<SET> must include the "@" prefix\&.
fr_FR: Cette commande listera tous les appels système contenus dans l'ensemble des appels système indiqué I<ENSEMBLE>, ou tout ensemble si aucun ensemble n'est spécifié\&. L'argument I<ENSEMBLE> doit inclure le préfixe « @ »\&.

note: type: SS
en: systemd-analyze filesystems [I<SET>R<\&.\&.\&.]>
fr_FR: systemd-analyze filesystems [I<ENSEMBLE>R<\&.\&.\&.]>

note: type: Plain text
en: This command will list filesystems in the specified filesystem set I<SET>, or all known sets if no sets are specified\&. Argument I<SET> must include the "@" prefix\&.
fr_FR: Cette commande listera les systèmes de fichiers dans l'ensemble de systèmes de fichiers indiqué I<ENSEMBLE>, ou tout ensemble connu si aucun ensemble n'est spécifié\&. L'argument I<ENSEMBLE> doit inclure le préfixe « @ »\&.

note: type: Plain text
en: This command will parse and normalize repetitive calendar time events, and will calculate when they elapse next\&. This takes the same input as the I<OnCalendar=> setting in B<systemd.timer>(5), following the syntax described in B<systemd.time>(7)\&. By default, only the next time the calendar expression will elapse is shown; use B<--iterations=> to show the specified number of next times the expression elapses\&. Each time the expression elapses forms a timestamp, see the B<timestamp> verb below\&.
fr_FR: Cette commande va analyser et normaliser les événements calendaires répétitifs, et calculera la prochaine échéance\&. Elle prend la même entrée que le I<OnCalendar=> défini dans B<systemd.timer>(5), en suivant la syntaxe décrite dans B<systemd.time>(7)\&. Seule la prochaine échéance de l'expression moment calendaire à survenir est montrée par défaut : utiliser B<-- iterations=> pour afficher le nombre de fois indiqué des prochaines échéances où l'expression se produira\&. Chaque moment où l'expression se déroule forme un horodatage, voir le verbatim B<timestamp> ci-dessous\&.

note: type: Plain text
en: B<Example\ \&12.\ \&Show leap days in the near future>
fr_FR: B<Exemple\ \&12.\ \&Afficher les jours bissextiles dans un futur proche>

note: type: SS
en: systemd-analyze timestamp I<TIMESTAMP>R<\&.\&.\&.>
fr_FR: systemd-analyze timestamp I<HORODATAGE>R<\&.\&.\&.>

note: type: Plain text
en: This command parses a timestamp (i\&.e\&. a single point in time) and outputs the normalized form and the difference between this timestamp and now\&. The timestamp should adhere to the syntax documented in B<systemd.time>(7), section "PARSING TIMESTAMPS"\&.
fr_FR: Cette commande analyse un horodatage (c.-à-d. un simple point dans le temps) et renvoie la forme normalisée et la différence entre cet horodatage et maintenant\&. L'horodatage doit se conformer à la syntaxe documentée dans B<systemd.time>(7), section « PARSING TIMESTAMPS » (analyse des horodatages)\&.

note: type: Plain text
en: B<Example\ \&13.\ \&Show parsing of timestamps>
fr_FR: B<Exemple\ \&13.\ \&Afficher l'analyse d'horodatages>

note: type: Plain text
en: This command parses a time span (i\&.e\&. a difference between two timestamps) and outputs the normalized form and the equivalent value in microseconds\&. The time span should adhere to the syntax documented in B<systemd.time>(7), section "PARSING TIME SPANS"\&. Values without units are parsed as seconds\&.
fr_FR: Cette commande analyse un laps de temps (timespan) (c'est-à-dire la différence entre deux horodatages) et renvoie la forme normalisée et la valeur équivalente en microsecondes\&. La durée doit se conformer à la syntaxe documentée dans B<systemd.time>(7), section « PARSING TIME SPANS » (analyse de durées)\&. Les valeurs sans unités sont analysées comme des secondes\&.

note: type: Plain text
en: B<Example\ \&14.\ \&Show parsing of timespans>
fr_FR: B<Exemple\ \&14.\ \&Afficher l'analyse des durées>

note: type: SS
en: systemd-analyze cat-config I<NAME>R<|>I<PATH>R<\&.\&.\&.>
fr_FR: systemd-analyze cat-config I<NOM>R<|>I<CHEMIN>R<\&.\&.\&.>

note: type: Plain text
en: This command is similar to B<systemctl cat>, but operates on config files\&. It will copy the contents of a config file and any drop-ins to standard output, using the usual systemd set of directories and rules for precedence\&. Each argument must be either an absolute path including the prefix (such as /etc/systemd/logind\&.conf or /usr/lib/systemd/logind\&.conf), or a name relative to the prefix (such as systemd/logind\&.conf)\&.
fr_FR: Cette commande est similaire à B<systemctl cat>, mais opère sur les fichiers de configuration\&. Elle copiera les contenus d'un fichier de configuration et autres bagatelles dans la sortie standard, en utilisant l'ensemble des répertoires et des règles de priorité habituel de systemd\&. Chaque argument doit être soit un chemin absolu incluant le préfixe (tel que /etc/systemd/logind\&.conf ou /usr/lib/systemd/logind\&.conf), ou un nom relatif au préfixe (tel que systemd/logind\&.conf)\&.

note: type: Plain text
en: B<Example\ \&15.\ \&Showing logind configuration>
fr_FR: B<Exemple\ \&15.\ \&Afficher la configuration de logind>

note: type: Plain text
en: # /usr/lib/systemd/logind\&.conf\&.d/20-test\&.conf
    \&.\&.\&. some override from another package
fr_FR: # /usr/lib/systemd/logind\&.conf\&.d/20-test\&.conf
    \&.\&.\&. quelque dérogation d'un autre paquet

note: type: Plain text
en: # /etc/systemd/logind\&.conf\&.d/50-override\&.conf
    \&.\&.\&. some administrator override
fr_FR: # /etc/systemd/logind\&.conf\&.d/50-override\&.conf
    \&.\&.\&. quelque dérogation d'un administrateur

note: type: Plain text
en: This command has two distinct modes of operation, depending on whether the operator I<OP> is specified\&.
fr_FR: Cette commande a deux modes opératoires distincts, selon que l'opérateur I<OP> est spécifié ou non\&.

note: type: Plain text
en: In the first mode \(em when I<OP> is not specified \(em it will compare the two version strings and print either "I<VERSION1> E<lt> I<VERSION2>", or "I<VERSION1> == I<VERSION2>", or "I<VERSION1> E<gt> I<VERSION2>" as appropriate\&.
fr_FR: Dans le premier mode \(em lorsque I<OP> n'est pas indiqué \(em cette commande comparera les deux chaînes de version et affichera soit « I<VERSION1> E<lt> I<VERSION2> », ou « I<VERSION1> == I<VERSION2> », ou « I<VERSION1> E<gt> I<VERSION2> » en fonction du résultat\&.

note: type: Plain text
en: The exit status is B<0> if the versions are equal, B<11> if the version of the right is smaller, and B<12> if the version of the left is smaller\&. (This matches the convention used by B<rpmdev-vercmp>\&.)
fr_FR: Le code retour est B<0> si les versions sont identiques, B<11> si la version de droite est plus petite et B<12> si la version de gauche est plus petite (cela correspond à la convention utilisée par B<rpmdev-vercmp>)\&.

note: type: Plain text
en: In the second mode \(em when I<OP> is specified \(em it will compare the two version strings using the operation I<OP> and return B<0> (success) if they condition is satisfied, and B<1> (failure) otherwise\&.  B<OP> may be B<lt>, B<le>, B<eq>, B<ne>, B<ge>, B<gt>\&. In this mode, no output is printed\&. (This matches the convention used by B<dpkg>(1)  B<--compare-versions>\&.)
fr_FR: Dans le second mode (lorsque I<OP> est indiqué), cette commande comparera les deux chaînes de version en utilisant l'opération I<OP> et renverra B<0> (succès) si les conditions sont satisfaites, et B<1> (échec) sinon \&. B<OP> peut être B<it>, B<te>, B<eq>, B<ne>, B<ge>, B<gt>\&. Dans ce mode, aucun retour n'est affiché (cela correspond à la convention utilisée par B<dpkg>(1) B<--compare-versions>)\&.

note: type: Plain text
en: B<Example\ \&16.\ \&Compare versions of a package>
fr_FR: B<Exemple\ \&16.\ \&Comparer les versions d'un paquet>

note: type: Plain text
en: $ systemd-analyze compare-versions systemd-250~rc1\&.fc36\&.aarch64 systemd-251\&.fc36\&.aarch64
    systemd-250~rc1\&.fc36\&.aarch64 E<lt> systemd-251\&.fc36\&.aarch64
    $ echo $?
    12
fr_FR: $ systemd-analyze compare-versions systemd-250~rc1\&.fc36\&.aarch64 systemd-251\&.fc36\&.aarch64
    systemd-250~rc1\&.fc36\&.aarch64 E<lt> systemd-251\&.fc36\&.aarch64
    $ echo $?

note: type: SS
en: systemd-analyze verify I<FILE>R<\&.\&.\&.>
fr_FR: systemd-analyze verify I<FICHIER>R<\&.\&.\&.>

note: type: Plain text
en: This command will load unit files and print warnings if any errors are detected\&. Files specified on the command line will be loaded, but also any other units referenced by them\&. A unit\*(Aqs name on disk can be overridden by specifying an alias after a colon; see below for an example\&. The full unit search path is formed by combining the directories for all command line arguments, and the usual unit load paths\&. The variable I<$SYSTEMD_UNIT_PATH> is supported, and may be used to replace or augment the compiled in set of unit load paths; see B<systemd.unit>(5)\&. All units files present in the directories containing the command line arguments will be used in preference to the other paths\&.
fr_FR: Cette commande chargera les fichiers d'unité et affichera des avertissements si des erreurs sont détectées\&. Les fichiers indiqués sur la ligne de commande seront chargés, mais aussi toute autre unité référencée par eux\&. Un nom d'unité sur disque peut être remplacé en spécifiant un alias après un « deux-points » ; voir ci-dessous pour un exemple\&. Le chemin de recherche complet de l'unité est formé en combinant les répertoires de tous les arguments de la ligne de commande et les chemins habituels de chargement des unités\&. La variable I<$SYSTEMD_UNIT_PATH> est prise en charge et peut être utilisée pour remplacer ou augmenter l'ensemble compilé des chemins des unités chargées ; consulter B<systemd.unit>(5)\&. Tous les fichiers présents dans les répertoires contenant les arguments de ligne de commande seront utilisés en préférence aux autres chemins\&.

note: type: Plain text
en: The following errors are currently detected:
fr_FR: Les erreurs suivantes sont souvent détectées :

note: type: Plain text
en: unknown sections and directives,
fr_FR: instructions et sections inconnues.

note: type: Plain text
en: missing dependencies which are required to start the given unit,
fr_FR: dépendances nécessaires au démarrage de l'unité donnée manquantes.

note: type: Plain text
en: man pages listed in I<Documentation=> which are not found in the system,
fr_FR: pages de manuel listées dans I<Documentation=> qui sont introuvables dans le système.

note: type: Plain text
en: commands listed in I<ExecStart=> and similar which are not found in the system or not executable\&.
fr_FR: commandes listées dans I<ExecStart=> et similaires qui sont introuvables dans le système ou non exécutables\&.

note: type: Plain text
en: B<Example\ \&17.\ \&Misspelt directives>
fr_FR: B<Exemple\ \&17.\ \&Directives mal écrites>

note: type: Plain text
en: B<Example\ \&18.\ \&Missing service units>
fr_FR: B<Exemple\ \&18.\ \&Unités de service manquantes>

note: type: Plain text
en: B<Example\ \&19.\ \&Aliasing a unit>
fr_FR: B<Exemple\ \&19.\ \&Faire un alias d'une unité>

note: type: SS
en: systemd-analyze security [I<UNIT>R<\&.\&.\&.]>
fr_FR: systemd-analyze security [I<UNITÉ>R<\&.\&.\&.]>

note: type: Plain text
en: This command analyzes the security and sandboxing settings of one or more specified service units\&. If at least one unit name is specified the security settings of the specified service units are inspected and a detailed analysis is shown\&. If no unit name is specified, all currently loaded, long-running service units are inspected and a terse table with results shown\&. The command checks for various security-related service settings, assigning each a numeric "exposure level" value, depending on how important a setting is\&. It then calculates an overall exposure level for the whole unit, which is an estimation in the range 0\&.0\&...10\&.0 indicating how exposed a service is security-wise\&. High exposure levels indicate very little applied sandboxing\&. Low exposure levels indicate tight sandboxing and strongest security restrictions\&. Note that this only analyzes the per-service security features systemd itself implements\&. This means that any additional security mechanisms applied by the service code itself are not accounted for\&. The exposure level determined this way should not be misunderstood: a high exposure level neither means that there is no effective sandboxing applied by the service code itself, nor that the service is actually vulnerable to remote or local attacks\&. High exposure levels do indicate however that most likely the service might benefit from additional settings applied to them\&.
fr_FR: Cette commande analyse la sécurité et l'ensemble des bacs à sable pour une ou plusieurs unités de service\&. Si au moins un nom d'unité est spécifié, les réglages des unités du service spécifiées sont inspectés et une analyse détaillée est affichée\&. Si aucun nom d'unité n'est spécifié, toutes les unités de service chargées et en fonctionnement sont inspectées et un tableau succinct des résultats est affiché\&. La commande vérifie différents réglages relatifs à la sécurité du service, assignant à chacun une valeur de « niveau d'exposition », en fonction de l'importance du réglage\&.  Elle calcule ensuite un niveau d'exposition global pour l'ensemble de l'unité, qui est une estimation dans l'intervalle de 0\&.0\&...10\&.0 indiquant le degré d'exposition d'un service en matière de sécurité\&. Des degrés d'exposition élevés indiquent un « bac à sable » très peu appliqué\&. Les faibles niveaux d'exposition indiquent une application du bac à sable serrée et des restrictions de sécurité très strictes\&. Notez que cette commande n'analyse que les fonctionnalités de sécurité par service que systemd lui-même met en œuvre. Cela signifie que tout mécanisme de sécurité supplémentaire appliqué par le code du service lui-même n'est pas pris en compte\&. Le niveau d'exposition déterminé de cette manière ne doit pas être mal compris : un haut niveau d'exposition ne signifie pas qu'il n'y a pas de bac à sable effectif appliqué par le code du service lui-même, ni que le service est réellement vulnérable à des attaques à distance ou locales\&. De hauts niveaux d'exposition indiquent que le service devrait bénéficier de réglages supplémentaires\&.

note: type: Plain text
en: Please note that many of the security and sandboxing settings individually can be circumvented \(em unless combined with others\&. For example, if a service retains the privilege to establish or undo mount points many of the sandboxing options can be undone by the service code itself\&. Due to that is essential that each service uses the most comprehensive and strict sandboxing and security settings possible\&. The tool will take into account some of these combinations and relationships between the settings, but not all\&. Also note that the security and sandboxing settings analyzed here only apply to the operations executed by the service code itself\&. If a service has access to an IPC system (such as D-Bus) it might request operations from other services that are not subject to the same restrictions\&. Any comprehensive security and sandboxing analysis is hence incomplete if the IPC access policy is not validated too\&.
fr_FR: Veuillez prendre en compte que la plupart des réglages individuels pour le bac à sable ou la sécurité peuvent être contournés \(em à moins d'être combinés avec d'autres\&. Par exemple, si un service conserve le privilège d'établir ou de démonter des points de montage, beaucoup des options du bac à sable peuvent être défaites par le code du service lui-même\&. C'est pour cela qu'il est essentiel que chaque service use de réglages de bac à sable et de sécurité les plus exhaustifs et stricts possibles\&. L'outil prendra en compte quelques unes de ces combinaisons et relations entre les réglages, mais pas toutes\&. Remarquez aussi que les réglages de bac à sable et de sécurité analysés ici ne concernent que les opérations faites par le code du service lui-même\&. Si un service a accès à un système IPC (tel que D-Bus), il pourrait nécessiter des opérations de la part d'autres services qui ne sont pas astreints aux mêmes restrictions\&. Toute analyse exhaustive de bac à sable et de sécurité est donc incomplète si la politique d'accès IPC n'est pas aussi validée\&.

note: type: Plain text
en: B<Example\ \&20.\ \&Analyze systemd-logind\&.service>
fr_FR: B<Exemple\ \&20.\ \&Analyser systemd-logind\&.service>

note: type: SS
en: systemd-analyze inspect-elf I<FILE>R<\&.\&.\&.>
fr_FR: systemd-analyze inspect-elf I<FICHIER>R<\&.\&.\&.>

note: type: Plain text
en: This command will load the specified files, and if they are ELF objects (executables, libraries, core files, etc\&.) it will parse the embedded packaging metadata, if any, and print it in a table or json format\&. See the \m[blue]B<Packaging Metadata>\m[]\&\s-2\u[1]\d\s+2 documentation for more information\&.
fr_FR: Cette commande charge les fichiers spécifiés et, s'ils sont des objets ELF (exécutables, bibliothèques, fichier core, etc\&.), elle analysera les métadonnées d'empaquetage incorporées, si présentes et les affichera dans une table ou au format json\&. Voir la documentation \m[blue]B<Packaging Metadata>\m[]\&\s-2\u[1]\d\s+2 pour plus d'information\&.

note: type: Plain text
en: B<Example\ \&21.\ \&Table output>
fr_FR: B<Exemple\ \&21.\ \&Sortie sous forme de table>

note: type: Plain text
en: The following options are understood:
fr_FR: Les options suivantes sont comprises :

note: type: Plain text
en: Operates on the system systemd instance\&. This is the implied default\&.
fr_FR: Agir sur l'instance systemd du système\&. C'est l'option implicite par défaut\&.

note: type: Plain text
en: Operates on the user systemd instance\&.
fr_FR: Agir sur l'instance systemd de l'utilisateur\&.

note: type: Plain text
en: Operates on the system-wide configuration for user systemd instance\&.
fr_FR: Agir sur la configuration de l'ensemble du système pour l'instance systemd de l'utilisateur\&.

note: type: Plain text
en: When used in conjunction with the B<dot> command (see above), selects which dependencies are shown in the dependency graph\&. If B<--order> is passed, only dependencies of type I<After=> or I<Before=> are shown\&. If B<--require> is passed, only dependencies of type I<Requires=>, I<Requisite=>, I<Wants=> and I<Conflicts=> are shown\&. If neither is passed, this shows dependencies of all these types\&.
fr_FR: Ces options sélectionnent quelles dépendances seront montrées dans le graphe de dépendances, lorsque utilisées conjointement à la commande B<dot> (voir ci-dessus)\&. Si B<--order> est passée, seules les dépendances du type I<After=> ou I<Before=> sont affichées\&. Si B<--require> est passée, seules les dépendances du type I<Requires=>, I<Requisite>, I<Wants=> et I<Conflicts=> sont affichées\&. Si aucune n'est passée, les dépendances de tous ces types seront affichées\&.

note: type: Plain text
en: When used in conjunction with the B<dot> command (see above), this selects which relationships are shown in the dependency graph\&. Both options require a B<glob>(7)  pattern as an argument, which will be matched against the left-hand and the right-hand, respectively, nodes of a relationship\&.
fr_FR: Ces options sélectionnent quelles relations sont montrées dans le graphe de dépendances lorsque utilisées avec la commande B<dot> (voir ci-dessus)\&. Les deux options nécessitent un motif B<glob>(7) comme argument, qui sera comparé au côté droit et au côté gauche, respectivement, des nœuds de la relation\&.

note: type: Plain text
en: Each of these can be used more than once, in which case the unit name must match one of the values\&. When tests for both sides of the relation are present, a relation must pass both tests to be shown\&. When patterns are also specified as positional arguments, they must match at least one side of the relation\&. In other words, patterns specified with those two options will trim the list of edges matched by the positional arguments, if any are given, and fully determine the list of edges shown otherwise\&.
fr_FR: Chacune d'elles peut être utilisée plus d'une fois, auquel cas le nom de l'unité doit correspondre à l'une de ces valeurs\&. Une relation doit passer les deux tests pour être affichée lorsque les tests pour les deux côtés de la relation sont présents\&. Quand les motifs sont aussi spécifiés comme argument de position, ils doivent correspondre a minima à l'un des côtés de la relation\&. En d'autres termes, les motifs indiqués dans ces deux options réduiront la liste des extrémités correspondant aux arguments de position, s'il y en a de donnés, et détermineront totalement la liste des extrémités qui seront affichées sinon\&.

note: type: Plain text
en: B<--fuzz=>I<timespan>
fr_FR: B<--fuzz=>I<durée>

note: type: Plain text
en: When used in conjunction with the B<critical-chain> command (see above), also show units, which finished I<timespan> earlier, than the latest unit in the same level\&. The unit of I<timespan> is seconds unless specified with a different unit, e\&.g\&. "50ms"\&.
fr_FR: Lorsque utilisée conjointement avec la commande B<critical-chain> (voir ci-dessus), cette option montrera aussi les unités qui ont fini leur I<durée> avant la dernière unité sur le même niveau\&. L'unité de la I<durée> est la seconde, à moins qu'une unité différente soit spécifiée, par exemple « 50ms »\&.

note: type: Plain text
en: Do not invoke B<man>(1)  to verify the existence of man pages listed in I<Documentation=>\&.
fr_FR: Ne pas invoquer B<man>(1) pour vérifier la présence de pages de manuel listées dans I<Documentation=>\&.

note: type: Plain text
en: Invoke unit generators, see B<systemd.generator>(7)\&. Some generators require root privileges\&. Under a normal user, running with generators enabled will generally result in some warnings\&.
fr_FR: Invoquer les générateurs d'unités, consulter B<systemd.generator>(7)\&. Certains générateurs nécessitent les privilèges du superutilisateur\&. Fonctionner avec les générateurs activés en tant qu'utilisateur normal résultera en général en plusieurs avertissements\&.

note: type: Plain text
en: Control verification of units and their dependencies and whether B<systemd-analyze verify> exits with a non-zero process exit status or not\&. With B<yes>, return a non-zero process exit status when warnings arise during verification of either the specified unit or any of its associated dependencies\&. With B<no>, return a non-zero process exit status when warnings arise during verification of only the specified unit\&. With B<one>, return a non-zero process exit status when warnings arise during verification of either the specified unit or its immediate dependencies\&. If this option is not specified, zero is returned as the exit status regardless whether warnings arise during verification or not\&.
fr_FR: Contrôler la vérification des unités et leurs dépendances et si B<systemd-analyze verify> finit avec un code de retour différent de zéro ou pas\&. Avec B<yes>, renvoyer un code de retour de processus différent de zéro lorsque des avertissements surviennent pendant la vérification de l'unité spécifiée ou de l'une de ses dépendances associées\&. Avec B<no>, renvoyer un code de retour de processus différent de zéro lorsque des avertissements surviennent durant la vérification de l'unité spécifiée uniquement\&. Avec B<one>, renvoyer un code de retour de processus différent de zéro lorsque des avertissements surviennent lors de la vérification de l'unité indiquée ou de ses dépendances immédiates\&. Si cette option n'est pas spécifiée, zéro est renvoyé comme code de retour, que des avertissements surviennent ou pas lors de la vérification\&.

note: type: Plain text
en: B<--root=>I<PATH>
fr_FR: B<--root=>I<CHEMIN>

note: type: Plain text
en: With B<cat-files> and B<verify>, operate on files underneath the specified root path I<PATH>\&.
fr_FR: Opérer sur les fichiers sous le chemin racine spécifié I<CHEMIN>, avec B<cat-files> et B<verify>\&.

note: type: Plain text
en: B<--image=>I<PATH>
fr_FR: B<--image=>I<CHEMIN>

note: type: Plain text
en: With B<cat-files> and B<verify>, operate on files inside the specified image path I<PATH>\&.
fr_FR: Avec B<cat-files> et B<verify>, opérer sur les fichiers dans le chemin d'image spécifié I<CHEMIN>\&.

note: type: Plain text
en: With B<security>, perform an offline security review of the specified unit files, i\&.e\&. does not have to rely on PID 1 to acquire security information for the files like the B<security> verb when used by itself does\&. This means that B<--offline=> can be used with B<--root=> and B<--image=> as well\&. If a unit\*(Aqs overall exposure level is above that set by B<--threshold=> (default value is 100), B<--offline=> will return an error\&.
fr_FR: Avec B<security>, effectuer un audit de sécurité hors-ligne des fichiers d'unité spécifiés, c'est à dire ne pas dépendre du PID 1 pour avoir des informations de sécurité sur les fichiers de la même façon que la commande B<security> lorsque utilisée seule\&. Cela signifie que B<--offline=> peut être utilisée aussi bien avec B<--root=> qu'avec B<--image=>\&. Si le niveau d'exposition global d'une unité est plus élevé que ce qui est défini par B<--threshold=> (dont la valeur par défaut est 100), B<--offline=> enverra une erreur\&.

note: type: Plain text
en: B<--profile=>I<PATH>
fr_FR: B<--profile=>I<CHEMIN>

note: type: Plain text
en: With B<security> B<--offline=>, takes into consideration the specified portable profile when assessing unit settings\&. The profile can be passed by name, in which case the well-known system locations will be searched, or it can be the full path to a specific drop-in file\&.
fr_FR: Avec B<security> B<--offline=>, prend en considération le profil portable indiqué lors de l'accession aux réglages de l'unité\&. Le profil peut être passé sous la forme d'un nom, auquel cas son emplacement connu sur le système sera cherché, ou il peut être un chemin complet vers un fichier de remplacement spécifique\&.

note: type: Plain text
en: B<--threshold=>I<NUMBER>
fr_FR: B<--threshold=>I<NOMBRE>

note: type: Plain text
en: With B<security>, allow the user to set a custom value to compare the overall exposure level with, for the specified unit files\&. If a unit\*(Aqs overall exposure level, is greater than that set by the user, B<security> will return an error\&.  B<--threshold=> can be used with B<--offline=> as well and its default value is 100\&.
fr_FR: Avec B<security>, autorise l'utilisateur à définir une valeur personnalisée à comparer au niveau d'exposition global pour les fichiers d'unité indiqués\&. Si le niveau d'exposition global d'une unité est supérieur à ce qui a été défini par l'utilisateur, B<security> renverra une erreur\&. B<--threshold=> peut aussi être utilisé avec B<--offline=> et sa valeur par défaut est 100\&.

note: type: Plain text
en: B<--security-policy=>I<PATH>
fr_FR: B<--security-policy=>I<CHEMIN>

note: type: Plain text
en: With B<security>, allow the user to define a custom set of requirements formatted as a JSON file against which to compare the specified unit file(s) and determine their overall exposure level to security threats\&.
fr_FR: Avec B<security>, permettre à l'utilisateur de définir un ensemble personnalisé d'exigences formatées comme un fichier JSON auquel comparer le(s) fichier(s) d'unité spécifié(s) et déterminer leur niveau d'exposition global aux menaces de sécurité\&.

note: type: Plain text
en: B<Table\ \&1.\ \&Accepted Assessment Test Identifiers>
fr_FR: B<Table\ \&1.\ \&Identificateurs de test d'évaluation acceptés>

note: type: tbl table
en: Assessment Test Identifier
fr_FR: Identificateurs de test d'évaluation

note: type: tbl table
en: l
fr_FR: B<l>

note: type: Plain text
en: See example "JSON Policy" below\&.
fr_FR: Voir l'exemple « JSON Policy » ci-dessous\&.

note: type: Plain text
en: With the B<security> command, generate a JSON formatted output of the security analysis table\&. The format is a JSON array with objects containing the following fields: I<set> which indicates if the setting has been enabled or not, I<name> which is what is used to refer to the setting, I<json_field> which is the JSON compatible identifier of the setting, I<description> which is an outline of the setting state, and I<exposure> which is a number in the range 0\&.0\&...10\&.0, where a higher value corresponds to a higher security threat\&. The JSON version of the table is printed to standard output\&. The I<MODE> passed to the option can be one of three: B<off> which is the default, B<pretty> and B<short> which respectively output a prettified or shorted JSON version of the security table\&. With the B<plot> command, generate a JSON formatted output of the raw time data\&. The format is a JSON array with objects containing the following fields: I<name> which is the unit name, I<activated> which is the time after startup the service was activated, I<activating> which is how long after startup the service was initially started, I<time> which is how long the service took to activate from when it was initially started, I<deactivated> which is the time after startup that the service was deactivated, I<deactivating> which is the time after startup that the service was initially told to deactivate\&.
fr_FR: Avec la commande B<security>, générer une sortie formatée JSON de la table d'analyse de sécurité\&. Le format est un tableau JSON avec des objets contenant les champs suivants : I<réglage> qui indique si le réglage est activé ou pas, I<nom> qui est ce qui est utilisé pour se référer au réglage, I<champ_json> qui est l'identifiant compatible JSON du réglage, I<description> qui est un aperçu de l'état du réglage et I<exposition> qui est un nombre dans l'intervalle de 0\&.0\&...10\&.0, où une valeur haute correspond à une menace de sécurité élevée\&. La version JSON de la table est affichée dans la sortie standard\&. Le I<MODE> passé à l'option peut être l'un des trois suivants : B<off> la valeur par défaut, B<pretty> et B<short> qui renvoient respectivement une version enjolivée ou courte de la version JSON de la table de sécurité\&. Avec la commande B<plot>, générer une sortie formatée JSON des données horaires brutes\&. Le format est un tableau JSON avec des objets contenant les champs suivant : I<nom> qui est le nom de l'unité, I<activated> qui est le temps mis par le service pour être activé après le démarrage, I<activating> qui est le temps mis par le service pour être initialement lancé après le démarrage, I<time> qui est le temps mis par le service pour s'activer à partir du moment où il a été démarré initialement, I<desactivated> qui est le temps mis par le service pour se désactiver après le démarrage, I<desactivating> qui est le temps après lequel il a été initialement demandé au service de se désactiver après le démarrage\&.

note: type: Plain text
en: B<--iterations=>I<NUMBER>
fr_FR: B<--iterations=>I<NOMBRE>

note: type: Plain text
en: When used with the B<calendar> command, show the specified number of iterations the specified calendar expression will elapse next\&. Defaults to 1\&.
fr_FR: Lorsque utilisée avec la commande B<calendar>, cette option affiche le nombre spécifique d'itérations de prochaines échéances de l'expression calendaire indiquée\&. La valeur par défaut est B<1>\&.

note: type: Plain text
en: B<--base-time=>I<TIMESTAMP>
fr_FR: B<--base-time=>I<HORODATAGE>

note: type: Plain text
en: When used with the B<calendar> command, show next iterations relative to the specified point in time\&. If not specified defaults to the current time\&.
fr_FR: Lorsque utilisée avec la commande B<calendar>, cette option affiche les prochaines itérations relatives à un moment indiqué\&. Si rien n'est spécifié, ce sera l'heure actuelle par défaut\&.

note: type: Plain text
en: B<--unit=>I<UNIT>
fr_FR: B<--unit=>I<UNITÉ>

note: type: Plain text
en: When used with the B<condition> command, evaluate all the I<Condition*=\&.\&.\&.> and I<Assert*=\&.\&.\&.> assignments in the specified unit file\&. The full unit search path is formed by combining the directories for the specified unit with the usual unit load paths\&. The variable I<$SYSTEMD_UNIT_PATH> is supported, and may be used to replace or augment the compiled in set of unit load paths; see B<systemd.unit>(5)\&. All units files present in the directory containing the specified unit will be used in preference to the other paths\&.
fr_FR: Lorsque utilisée avec la commande B<condition>, cette option permet d'évaluer toutes les assignations I<Condition*=\&.\&.\&.> et I<Assert*=\&.\&.\&.> dans le fichier de l'unité indiquée\&. Le chemin complet de recherche de l'unité est formé en combinant les répertoires de l'unité indiquée avec les chemins habituels de chargement des unités\&. La variable I<$SYSTEMD_UNIT_PATH> est prise en charge et peut être utilisée pour remplacer ou augmenter l'ensemble compilé des chemins de chargement des unités ; consulter B<systemd.unit>(5)\&. Tous les fichiers d'unités présents dans le répertoire contenant l'unité indiquée seront utilisés de préférence aux autres chemins\&.

note: type: Plain text
en: When used with the B<plot> command, the raw time data is output in a table\&.
fr_FR: Lorsqu'utilisée avec la commande B<plot>, la sortie des données horaires brutes s'affiche sous la forme d'un tableau\&.

note: type: Plain text
en: When used with the B<plot> command in combination with either B<--table> or B<--json=>, no legends or hints are included in the output\&.
fr_FR: Lorsqu'utilisé avec la commande B<plot> combinée avec soit B<--table> ou B<--json=>, aucune légende ou indication ne sont inclues dans la sortie\&.

note: type: Plain text
en: Execute the operation remotely\&. Specify a hostname, or a username and hostname separated by "@", to connect to\&. The hostname may optionally be suffixed by a port ssh is listening on, separated by ":", and then a container name, separated by "/", which connects directly to a specific container on the specified host\&. This will use SSH to talk to the remote machine manager instance\&. Container names may be enumerated with B<machinectl -H >I<HOST>\&. Put IPv6 addresses in brackets\&.
fr_FR: Effectuer l'opération à distance\&. Indiquez un nom d'hôte, ou un nom d'utilisateur et un nom d'hôte séparés par un « @ », auquel se connecter\&. Le nom de l'hôte peut, de façon optionnelle, être suffixé par un port sur lequel B<ssh> écoute, séparé par un « : », puis le nom d'un conteneur, séparé par un « / », ce qui connecte alors directement à un conteneur donné sur l'hôte\&. Cela utilisera SSH pour dialoguer avec le contrôleur de la machine distante\&. Les noms des conteneurs peuvent être énumérés avec B<machinectl -H >I<HOST>\&. Mettre les adresses IPv6 entre crochets\&.

note: type: Plain text
en: Execute operation on a local container\&. Specify a container name to connect to, optionally prefixed by a user name to connect as and a separating "@" character\&. If the special string "\&.host" is used in place of the container name, a connection to the local system is made (which is useful to connect to a specific user\*(Aqs user bus: "--user --machine=lennart@\&.host")\&. If the "@" syntax is not used, the connection is made as root user\&. If the "@" syntax is used either the left hand side or the right hand side may be omitted (but not both) in which case the local user name and "\&.host" are implied\&.
fr_FR: Effectuer l'opération dans un conteneur local\&. Précisez le nom d'un conteneur auquel se connecter, optionnellement préfixé par le nom sous lequel se connecter et un caractère de séparation « @ »\&. Si la chaîne spéciale « \&.host » est utilisée à la place du nom du conteneur, une connexion au système local se produit (ce qui est utile pour se connecter à un utilisateur particulier )\*(Aqs user bus: « --user --machine=lennart@\&.host »)\&. Si la syntaxe « @ » n'est pas utilisée, la connexion est réalisée en tant que superutilisateur\. Si la syntaxe « @ » est utilisée, le côté gauche ou le côté droit peuvent être omis (mais pas les deux à la fois), auquel cas le nom de l'utilisateur local et « \&.host » sont implicites\.

note: type: Plain text
en: Suppress hints and other non-essential output\&.
fr_FR: Supprimer les notes et sorties non essentielles\&.

note: type: Plain text
en: Print a short help text and exit\&.
fr_FR: Afficher un aide-mémoire succinct et quitter\&.

note: type: Plain text
en: Print a short version string and exit\&.
fr_FR: Afficher une information de version courte et quitter\&.

note: type: Plain text
en: Do not pipe output into a pager\&.
fr_FR: Ne pas rediriger (pipe) la sortie vers un afficheur (pager)\&.

note: type: SH
en: EXIT STATUS
fr_FR: CODE DE RETOUR

note: type: Plain text
en: For most commands, 0 is returned on success, and a non-zero failure code otherwise\&.
fr_FR: Pour la plupart des commandes, B<0> est renvoyé en cas de succès et un code d'échec différent de zéro sinon\&.

note: type: Plain text
en: With the verb B<compare-versions>, in the two-argument form, B<12>, B<0>, B<11> is returned if the second version string is respectively larger, equal, or smaller to the first\&. In the three-argument form, B<0> or B<1> if the condition is respectively true or false\&.
fr_FR: Avec le verbatim B<compare-versions> sous la forme de deux arguments, B<12>, B<0> ou B<11> est renvoyé si la seconde chaîne de version est respectivement plus grande, égale ou plus petite que la première\&. Sous la forme de trois arguments, B<0> ou B<1> est renvoyé si la condition est respectivement vraie ou fausse\&.

note: type: SH
en: ENVIRONMENT
fr_FR: ENVIRONNEMENT

note: type: Plain text
en: The maximum log level of emitted messages (messages with a higher log level, i\&.e\&. less important ones, will be suppressed)\&. Either one of (in order of decreasing importance)  B<emerg>, B<alert>, B<crit>, B<err>, B<warning>, B<notice>, B<info>, B<debug>, or an integer in the range 0\&...7\&. See B<syslog>(3)  for more information\&.
fr_FR: Le niveau maximal de journalisation des messages émis (les messages avec un niveau de journalisation plus élevé, c'est-à-dire les moins importants seront supprimés)\&. Soit un de ces niveaux (par ordre d'importance décroissante) B<emerg>, B<alert>, B<crit>, B<err>, B<warning>, B<notice>, B<info>, B<debug> ou un entier dans l'intervalle 0\&...7\&. Consultez B<syslog>(3) pour plus d'informations\&.

note: type: Plain text
en: A boolean\&. If true, messages written to the tty will be colored according to priority\&.
fr_FR: Un booléen\&. Si la valeur est vrai, les messages écrits sur le terminal seront colorés selon la priorité\&.

note: type: Plain text
en: This setting is only useful when messages are written directly to the terminal, because B<journalctl>(1)  and other tools that display logs will color messages based on the log level on their own\&.
fr_FR: Ce réglage est utile uniquement quand les messages sont écrits directement dans un terminal ou un fichier parce que B<journalctl>(1) et d'autres outils qui affichent des journaux coloreront par eux-mêmes les messages selon le niveau de journalisation.

note: type: Plain text
en: A boolean\&. If true, console log messages will be prefixed with a timestamp\&.
fr_FR: Un booléen\&. Si la valeur est vrai, les messages du journal de la console seront préfixés d'un horodatage\&.

note: type: Plain text
en: This setting is only useful when messages are written directly to the terminal or a file, because B<journalctl>(1)  and other tools that display logs will attach timestamps based on the entry metadata on their own\&.
fr_FR: Ce réglage est utile uniquement quand les messages sont écrits directement dans un terminal ou un fichier parce que B<journalctl>(1) et d'autres outils qui affichent des journaux attacheront par eux-mêmes un horodatage selon les métadonnées de l'entrée.

note: type: Plain text
en: A boolean\&. If true, messages will be prefixed with a filename and line number in the source code where the message originates\&.
fr_FR: Un booléen\&. Si la valeur est vrai, les messages seront préfixés par un nom de fichier et du numéro de ligne du code source d'où vient le message\.

note: type: Plain text
en: Note that the log location is often attached as metadata to journal entries anyway\&. Including it directly in the message text can nevertheless be convenient when debugging programs\&.
fr_FR: Notez que l'emplacement du journal est souvent attaché comme métadonnée aux entrées du journal de toute façon\. L'inclure directement dans le texte du message peut néanmoins être opportun lors du débogage de programmes\&.

note: type: Plain text
en: A boolean\&. If true, messages will be prefixed with the current numerical thread ID (TID)\&.
fr_FR: Un booléen\&. Si la valeur est vrai, les messages seront préfixés par l'identifiant numérique du thread actuel (TID)\&.

note: type: Plain text
en: Note that the this information is attached as metadata to journal entries anyway\&. Including it directly in the message text can nevertheless be convenient when debugging programs\&.
fr_FR: Notez que cette information est attachée comme métadonnée aux entrées du journal de toute façon\. L'inclure directement dans le texte du message peut néanmoins être opportun lors du débogage de programmes\&.

note: type: Plain text
en: The destination for log messages\&. One of B<console> (log to the attached tty), B<console-prefixed> (log to the attached tty but with prefixes encoding the log level and "facility", see B<syslog>(3), B<kmsg> (log to the kernel circular log buffer), B<journal> (log to the journal), B<journal-or-kmsg> (log to the journal if available, and to kmsg otherwise), B<auto> (determine the appropriate log target automatically, the default), B<null> (disable log output)\&.
fr_FR: Destination pour journaliser les messages\&. Une des destinations parmi B<console> (journaliser dans le terminal attaché), B<console-prefixed> (journaliser dans le terminal attaché, mais avec des préfixes qui codent le niveau et le « service » de journalisation, consultez B<syslog>(3)), B<kmsg> (journaliser dans le tampon de journalisation circulaire du noyau), B<journal> (journaliser dans le journal), B<journal-or-kmsg> (journaliser dans le journal s'il est disponible et sinon dans kmsg), B<auto> (déterminer automatiquement la cible appropriée de journalisation , c'est la destination par défaut), B<null> (désactive la sortie de journalisation)\&.

note: type: Plain text
en: Pager to use when B<--no-pager> is not given; overrides I<$PAGER>\&. If neither I<$SYSTEMD_PAGER> nor I<$PAGER> are set, a set of well-known pager implementations are tried in turn, including B<less>(1)  and B<more>(1), until one is found\&. If no pager implementation is discovered no pager is invoked\&. Setting this environment variable to an empty string or the value "cat" is equivalent to passing B<--no-pager>\&.
fr_FR: Afficheur à utiliser lorsque B<--no-pager> n'est pas précisé ; outrepasse I<$PAGER>\&. Si ni I<$SYSTEMD_PAGER>, ni I<$PAGER> n'ont de valeur, un ensemble d’afficheurs bien connus sont essayés à tour de rôle, incluant B<less>(1) et B<more>(1), jusqu'à ce qu'il y en ait un qui soit trouvé\&. Si aucun afficheur n'est trouvé, aucun afficheur n'est appelé\&. Définir cette variable d'environnement à une chaîne vide ou à « cat » est équivalent à l'utilisation de B<--no-pager>\&.

note: type: Plain text
en: Note: if I<$SYSTEMD_PAGERSECURE> is not set, I<$SYSTEMD_PAGER> (as well as I<$PAGER>) will be silently ignored\&.
fr_FR: Remarque : si I<$SYSTEMD_PAGERSECURE> n'est pas défini, I<$SYSTEMD_PAGER> (tout comme I<$PAGER>) sera ignoré silencieusement\&.

note: type: Plain text
en: Override the options passed to B<less> (by default "FRSXMK")\&.
fr_FR: Outrepasser les options passées à B<less> (par défaut « FRSXMK »)\&.

note: type: Plain text
en: Users might want to change two options in particular:
fr_FR: Les utilisateurs voudront peut-être changer deux options en particulier :

note: type: Plain text
en: This option instructs the pager to exit immediately when Ctrl+C is pressed\&. To allow B<less> to handle Ctrl+C itself to switch back to the pager command prompt, unset this option\&.
fr_FR: Cette option ordonne à l’afficheur de quitter immédiatement lorsque Ctrl+C est entré\&. Pour permettre à B<less> de gérer Ctrl+C lui-même le retour à l'invite de commande de l’afficheur, ne pas fournir cette option\&.

note: type: Plain text
en: If the value of I<$SYSTEMD_LESS> does not include "K", and the pager that is invoked is B<less>, Ctrl+C will be ignored by the executable, and needs to be handled by the pager\&.
fr_FR: Si la valeur de I<$SYSTEMD_LESS> n'inclut pas « K » et si l’afficheur appelé est B<less>, Ctrl+C sera ignoré par l'exécutable, et doit être géré par l’afficheur\&.

note: type: Plain text
en: This option instructs the pager to not send termcap initialization and deinitialization strings to the terminal\&. It is set by default to allow command output to remain visible in the terminal even after the pager exits\&. Nevertheless, this prevents some pager functionality from working, in particular paged output cannot be scrolled with the mouse\&.
fr_FR: Cette option ordonne à l’afficheur de ne pas envoyer les chaînes d'initialisation et de désinitialisation de termcap au terminal\&. C'est le choix par défaut afin de permettre aux sorties des commandes de rester visibles dans le terminal même après que l’afficheur soit fermé\&. Toutefois, cela empêche quelques fonctionnalités de l’afficheur de fonctionner, en particulier, il n'est pas possible de faire défiler les sorties affichées avec la souris\&.

note: type: Plain text
en: See B<less>(1)  for more discussion\&.
fr_FR: Voir B<less>(1) pour plus de détails\&.

note: type: Plain text
en: Override the charset passed to B<less> (by default "utf-8", if the invoking terminal is determined to be UTF-8 compatible)\&.
fr_FR: Outrepasser le jeu de caractères passé à B<less> (par défaut « utf-8 », si le terminal invoqué est compatible avec l'UTF-8)\&.

note: type: Plain text
en: Takes a boolean argument\&. When true, the "secure" mode of the pager is enabled; if false, disabled\&. If I<$SYSTEMD_PAGERSECURE> is not set at all, secure mode is enabled if the effective UID is not the same as the owner of the login session, see B<geteuid>(2)  and B<sd_pid_get_owner_uid>(3)\&. In secure mode, B<LESSSECURE=1> will be set when invoking the pager, and the pager shall disable commands that open or create new files or start new subprocesses\&. When I<$SYSTEMD_PAGERSECURE> is not set at all, pagers which are not known to implement secure mode will not be used\&. (Currently only B<less>(1)  implements secure mode\&.)
fr_FR: Prend un argument booléen\&. Quand c'est « vrai », le mode « secure » de l'afficheur est activé et quand c'est « faux », il est désactivé\&. Si I<$SYSTEMD_PAGERSECURE> n'est pas du tout défini, le mode « secure » est activé si l'UID effectif n'est pas le même que celle du propriétaire de la session connectée, consulter B<geteuid>(2) et B<sd_pid_get_owner_uid>(3)\&. En mode « secure », B<LESSSECURE=1> sera défini lors de l'invocation de l'afficheur, et l'afficheur désactivera les commandes qui ouvrent ou créent de nouveaux fichiers ou lancent de nouveaux sous-processus\&. Quand I<$SYSTEMD_PAGERSECURE> n'est pas du tout défini, les afficheurs qui ne sont pas reconnus comme implémentant le mode « secure » ne seront pas utilisés\&. (Actuellement seul B<less>(1) implémente le mode « secure »\&.)

note: type: Plain text
en: Note: when commands are invoked with elevated privileges, for example under B<sudo>(8)  or B<pkexec>(1), care must be taken to ensure that unintended interactive features are not enabled\&. "Secure" mode for the pager may be enabled automatically as describe above\&. Setting I<SYSTEMD_PAGERSECURE=0> or not removing it from the inherited environment allows the user to invoke arbitrary commands\&. Note that if the I<$SYSTEMD_PAGER> or I<$PAGER> variables are to be honoured, I<$SYSTEMD_PAGERSECURE> must be set too\&. It might be reasonable to completely disable the pager using B<--no-pager> instead\&.
fr_FR: Note : quand des commandes sont invoquées avec des privilèges élevés, par exemple avec B<sudo>(8) ou B<pkexec>(1), des précautions doivent être prises pour s'assurer que des fonctions interactives indésirables ne sont pas activées\&. Le mode « Secure » de l'afficheur interactif peut être activé automatiquement comme décrit plus haut\&. Définir I<SYSTEMD_PAGERSECURE=0> ou ne pas le supprimer de l'environnement hérité autorise l'utilisateur à invoquer des commandes arbitraires\. Notez que si les variables I<$SYSTEMD_PAGER> ou I<$PAGER> doivent être respectées, I<$SYSTEMD_PAGERSECURE> doit aussi être défini\&. Il pourrait être raisonnable de désactiver complètement l'afficheur interactif en utilisant plutôt B<--no-pager>\&.

note: type: Plain text
en: Takes a boolean argument\&. When true, B<systemd> and related utilities will use colors in their output, otherwise the output will be monochrome\&. Additionally, the variable can take one of the following special values: "16", "256" to restrict the use of colors to the base 16 or 256 ANSI colors, respectively\&. This can be specified to override the automatic decision based on I<$TERM> and what the console is connected to\&.
fr_FR: Prend un argument booléen\. Quand c'est « vrai », B<systemd> et les utilitaires liés utiliseront la couleur pour leurs sorties, autrement, la sortie sera monochrome\&. En plus, la variable peut prendre une des valeurs spéciales suivantes : B<16> ou B<256> pour limiter l'usage des couleurs aux couleurs ANSI base 16 ou base 256 respectivement\&. Cela peut être précisé pour outrepasser la décision automatique prise sur I<$TERM> et quel que soit ce à quoi la console est connectée.

note: type: Plain text
en: The value must be a boolean\&. Controls whether clickable links should be generated in the output for terminal emulators supporting this\&. This can be specified to override the decision that B<systemd> makes based on I<$TERM> and other conditions\&.
fr_FR: La valeur doit être un booléen\&. Contrôle si les liens cliquables doivent être générés dans la sortie pour des émulateurs de terminaux le prenant en charge\&. Cela peut être indiqué pour passer outre la décision faite par B<systemd> basée sur I<$TERM> et d'autres conditions\&.

note: type: SH
en: EXAMPLES
fr_FR: EXEMPLES

note: type: Plain text
en: B<Example\ \&22.\ \&JSON Policy>
fr_FR: B<Exemple\ \&22.\ \&Politique JSON>

note: type: Plain text
en: The JSON file passed as a path parameter to B<--security-policy=> has a top-level JSON object, with keys being the assessment test identifiers mentioned above\&. The values in the file should be JSON objects with one or more of the following fields: B<description_na> (string), B<description_good> (string), B<description_bad> (string), B<weight> (unsigned integer), and B<range> (unsigned integer)\&. If any of these fields corresponding to a specific id of the unit file is missing from the JSON object, the default built-in field value corresponding to that same id is used for security analysis as default\&. The weight and range fields are used in determining the overall exposure level of the unit files: the value of each setting is assigned a badness score, which is multiplied by the policy weight and divided by the policy range to determine the overall exposure that the setting implies\&. The computed badness is summed across all settings in the unit file, normalized to the 1\&...100 range, and used to determine the overall exposure level of the unit\&. By allowing users to manipulate these fields, the \*(Aqsecurity\*(Aq verb gives them the option to decide for themself which ids are more important and hence should have a greater effect on the exposure level\&. A weight of "0" means the setting will not be checked\&.
fr_FR: Le fichier JSON passé comme paramètre de chemin à B<--security-policy=> a un objet JSON de haut niveau dont les clés sont les identifiants des tests d'évaluation mentionnés ci-dessus\&. Les valeurs dans le fichier doivent être des objets JSON avec un ou plusieurs des champs suivants : B<description_na> (chaîne), B<description_good> (chaîne), B<description_bad> (chaîne), B<weight> (entier non signé) et B<range> (entier non signé)\&. Si l'un de ces champs correspondant à un identifiant spécifique d'un fichier d'unité est manquant dans l'objet JSON, la valeur du champ interne par défaut correspondant à ce même identifiant est utilisée comme valeur par défaut pour l'analyse de sécurité\&. Les champs B<weight> et B<range> sont utilisés pour déterminer le niveau d'exposition global des fichiers de l'unité : un score de médiocrité est assigné comme valeur à chaque réglage, qui est multipliée par le poids de la politique et divisé par la plage de politique pour déterminer l'exposition globale que ce réglage implique\&. Le degré de médiocrité calculé est additionné à tous les paramètres du fichier de l'unité, normalisé dans l'intervalle de 1 à 100, et utilisé pour déterminer le niveau d'exposition global de l'unité\&. En autorisant les utilisateurs à manipuler ces champs, la commande « security » leur donne le choix de décider eux-mêmes quels identifiants sont plus importants et donc susceptibles d'avoir un impact plus grand sur le niveau d'exposition\&. Un poids de B<0> signifie que le réglage ne sera pas vérifié\&.

note: type: SH
en: SEE ALSO
fr_FR: VOIR AUSSI

note: type: Plain text
en: Packaging Metadata
fr_FR: Empaquetage de métadonnées

note: type: Plain text
en: This command prints an SVG graphic detailing which system services have been started at what time, highlighting the time they spent on initialization\&.
fr_FR: Cette commande affiche un graphique SVG détaillant quels services du système ont démarré à quel moment, mettant en évidence le temps passé à leur initialisation\&.

note: type: Plain text
en: With the B<security> command, generate a JSON formatted output of the security analysis table\&. The format is a JSON array with objects containing the following fields: I<set> which indicates if the setting has been enabled or not, I<name> which is what is used to refer to the setting, I<json_field> which is the JSON compatible identifier of the setting, I<description> which is an outline of the setting state, and I<exposure> which is a number in the range 0\&.0\&...10\&.0, where a higher value corresponds to a higher security threat\&. The JSON version of the table is printed to standard output\&. The I<MODE> passed to the option can be one of three: B<off> which is the default, B<pretty> and B<short> which respectively output a prettified or shorted JSON version of the security table\&.
fr_FR: Avec la commande B<security>, générer une sortie formatée JSON de la table d'analyse de sécurité\&. Le format est un tableau JSON avec des objets contenant les champs suivants : I<réglage> qui indique si le réglage est activé ou pas, I<nom> qui est ce qui est utilisé pour se référer au réglage, I<champ_json> qui est l'identifiant compatible JSON du réglage, I<description> qui est un aperçu de l'état du réglage et I<exposition> qui est un nombre dans l'intervalle de 0\&.0\&...10\&.0, où une valeur haute correspond à une menace de sécurité élevée\&. La version JSON de la table est affichée dans la sortie standard\&. Le I<MODE> passé à l'option peut être l'un des trois suivants : B<off> la valeur par défaut, B<pretty> et B<short> qui renvoient respectivement une version enjolivée ou courte de la version JSON de la table de sécurité\&.

note: type: Plain text
en: B<systemd-analyze> [OPTIONS...] fdstore [I<UNIT>...]
fr_FR: B<systemd-analyze> [OPTIONS...] fdstore [I<UNITÉ>...]

note: type: Plain text
en: B<systemd-analyze> [OPTIONS...] image-policy I<POLICY>...
fr_FR: B<systemd-analyze> [OPTIONS...] image-policy I<POLITIQUE>...

note: type: Plain text
en: This command can be used to request the output of the internal memory state (as returned by B<malloc_info>(3)) of a D-Bus service\&. If no service is specified, the query will be sent to org\&.freedesktop\&.systemd1 (the system or user service manager)\&. The output format is not guaranteed to be stable and should not be parsed by applications\&.
fr_FR: Cette commande peut être utilisée pour demander la sortie de l'état de la mémoire interne (comme renvoyé par B<malloc_info>(3)) d'un service D-Bus\&. Si aucun service n'est indiqué, la demande sera envoyée à org\&.freedesktop\&.systemd1 (le gestionnaire de services système ou utilisateur)\&. La stabilité du format de sortie n'est pas garantie et ne devrait pas être analysé par les applications\&.

note: type: Plain text
en: The service must implement the org\&.freedesktop\&.MemoryAllocation1 interface\&. In the systemd suite, it is currently only implemented by the manager\&.
fr_FR: Le service doit implémenter l'interface org\&.freedesktop\&.MemoryAllocation1\&. Dans la suite systemd, elle est actuellement implémentée seulement par le gestionnaire\&.

note: type: Plain text
en: B<Example\ \&21.\ \&Print information about a core file as JSON>
fr_FR: B<Exemple\ \&21.\ \&Afficher les informations d'un fichier core au format JSON>

note: type: SS
en: systemd-analyze fdstore [I<UNIT>R<\&.\&.\&.]>
fr_FR: systemd-analyze fdstore [I<UNITÉ>R<\&.\&.\&.]>

note: type: Plain text
en: Lists the current contents of the specified service unit\*(Aqs file descriptor store\&. This shows names, inode types, device numbers, inode numbers, paths and open modes of the open file descriptors\&. The specified units must have I<FileDescriptorStoreMax=> enabled, see B<systemd.service>(5)  for details\&.
fr_FR: Cette commande liste les contenus actuels du magasin de descripteurs de fichier de l'unité de service spécifiée et affiche les noms, les types d'inœud, les numéros de périphérique, les numéros d'inœud, les chemins et les modes d'ouverture des descripteurs de fichier ouverts\&. Les unités indiquées doivent avoir I<FileDescriptorStoreMax=> activé ; consultez B<systemd.service>(5) pour les détails\&.

note: type: Plain text
en: B<Example\ \&22.\ \&Table output>
fr_FR: B<Exemple\ \&22.\ \&Sortie sous forme de table>

note: type: Plain text
en: Note: the "DEVNO" column refers to the major/minor numbers of the device node backing the file system the file descriptor\*(Aqs inode is on\&. The "RDEVNO" column refers to the major/minor numbers of the device node itself if the file descriptor refers to one\&. Compare with corresponding I<\&.st_dev> and I<\&.st_rdev> fields in B<struct stat> (see B<stat>(2)  for details)\&. The listed inode numbers in the "INODE" column are on the file system indicated by "DEVNO"\&.
fr_FR: Remarque : la colonne « DEVNO » désigne les numéros majeur/mineur du nœud du périphérique associé au système de fichiers dans lequel se trouve le nœud du descripteur de fichier\&. La colonne « RDEVNO » désigne les numéros majeur/mineur du nœud du périphérique lui-même, si le descripteur de fichier s'y réfère\&. Comparer avec les champs correspondants à I<\&.st_dev> et I<\&.st_rdev> dans B<struct stat> (voir B<stat>(2) pour les détails)\&. Les numéros d'inœuds de la colonne « INODE » sont sur le système de fichiers indiqué par « DEVNO »\&.

note: type: SS
en: systemd-analyze image-policy [I<POLICY>R<\&...]>
fr_FR: systemd-analyze image-policy [I<POLITIQUE>R<\&...]>

note: type: Plain text
en: This command analyzes the specified image policy string, as per B<systemd.image-policy>(7)\&. The policy is normalized and simplified\&. For each currently defined partition identifier (as per the \m[blue]B<Discoverable Partitions Specification>\m[]\&\s-2\u[2]\d\s+2 the effect of the image policy string is shown in tabular form\&.
fr_FR: Cette commande analyse la chaîne de politique de l'image indiquée, comme pour B<systemd.image-policy>(7)\&. Cette politique est normalisée et simplifiée\&. Pour chaque identifiant de partition défini actuellement, comme pour la \m[blue]B<Discoverable Partitions Specification>\m[]\&\s-2\u[2]\d\s+2 l'effet de la chaîne de politique de l'image est affiché sous la forme de tableau\&.

note: type: Plain text
en: B<Example\ \&23.\ \&Example Output>
fr_FR: B<Exemple\ \&23.\ \&Exemple de sortie>

note: type: Plain text
en: This command shows the known TPM2 PCRs along with their identifying names and current values\&.
fr_FR: Cette commande affiche les PCR TPM2 connus avec leurs noms d’identification et leurs valeurs actuelles\&.

note: type: Plain text
en: B<Example\ \&24.\ \&Example Output>
fr_FR: B<Exemple\ \&24.\ \&Exemple de sortie>

note: type: Plain text
en: B<--image-policy=>I<policy>
fr_FR: B<--image-policy=>I<politique>

note: type: Plain text
en: Takes an image policy string as argument, as per B<systemd.image-policy>(7)\&. The policy is enforced when operating on the disk image specified via B<--image=>, see above\&. If not specified defaults to the "*" policy, i\&.e\&. all recognized file systems in the image are used\&.
fr_FR: Prendre une chaîne de politique d'image comme argument, comme pour B<systemd.image-policy>(7)\&. L'application de la politique est imposée lors d'opération sur l'image disque indiquée à l'aide de B<--image> ; voir ci-dessus\&. Si rien n'est indiqué, c'est par défaut la politique « * », c-à-d. tous les systèmes de fichiers reconnus de l'image sont utilisés\&.

note: type: Plain text
en: Whether to ratelimit kmsg or not\&. Takes a boolean\&. Defaults to "true"\&. If disabled, systemd will not ratelimit messages written to kmsg\&.
fr_FR: Limiter ou pas le taux de messages kmsg\&. Prend un booléen\&. Par défaut « vrai »\&. Si désactivé, systemd ne limitera pas le taux de messages écrits à kmsg\&.

note: type: Plain text
en: B<Example\ \&25.\ \&JSON Policy>
fr_FR: B<Exemple\ \&25.\ \&Politique JSON>

note: type: Plain text
en: Discoverable Partitions Specification
fr_FR: Spécification des partitions détectables

note: type: Plain text
en: Without any parameter, this command outputs a (usually very long) human-readable serialization of the complete service manager state\&. Optional glob pattern may be specified, causing the output to be limited to units whose names match one of the patterns\&. The output format is subject to change without notice and should not be parsed by applications\&.
fr_FR: Sans aucun paramètre, cette commande renvoie une sérialisation lisible (habituellement très longue) de l'état complet du gestionnaire de services. Un motif global (glob) facultatif peut être spécifié, limitant la sortie aux unités dont les noms correspondent à l'un des motifs\&. Le format de sortie est susceptible d'être modifié sans préavis et ne devrait pas être soumis à l'analyse par des applications\&.

note: type: Plain text
en: This command prints the time spent in the kernel before userspace has been reached, the time spent in the initial RAM disk (initrd) before normal system userspace has been reached, and the time normal system userspace took to initialize\&. Note that these measurements simply measure the time passed up to the point where all system services have been spawned, but not necessarily until they fully finished initialization or the disk is idle\&.
fr_FR: Cette commande affiche le temps passé dans le noyau avant que l'espace utilisateur n'ait été atteint, le temps écoulé dans le disque RAM initial (initrd) avant que l'espace utilisateur normal du système ne soit atteint, et le temps pris par l'espace utilisateur normal du système pour s'initialiser\&. Notez que ces mesures ne font que mesurer le temps écoulé jusqu'au moment où tous les services du système ont été lancés, mais pas nécessairement jusqu'à ce qu'ils aient terminé leur initialisation ou que le disque soit inactif\&.

note: type: Plain text
en: This command prints a tree of the time-critical chain of units (for each of the specified I<UNIT>s or for the default target otherwise)\&. The time after the unit is active or started is printed after the "@" character\&. The time the unit takes to start is printed after the "+" character\&. Note that the output might be misleading as the initialization of services might depend on socket activation and because of the parallel execution of units\&. Also, similar to the B<blame> command, this only takes into account the time units spent in "activating" state, and hence does not cover units that never went through an "activating" state (such as device units that transition directly from "inactive" to "active")\&. Moreover it does not show information on jobs (and in particular not jobs that timed out)\&.
fr_FR: Cette commande affiche un arbre de la chaîne de temps critique d'unités (pour chacune des I<UNITÉ>s indiquées ou pour la cible par défaut sinon)\&. Le temps écoulé depuis que l'unité est active ou démarrée est affiché après le caractère « @ »\&. Le temps pris par l'unité pour démarrer est affiché après le caractère « + »\&. Notez que la sortie peut être inexacte dans la mesure où l'initialisation de services pourrait dépendre de l'activation d'un socket et à cause de l'exécution en parallèle d'unités\&. Aussi, à l'instar de la commande B<blame>, cette commande ne prend en compte que le temps passé par les unités en état d'« activation », et donc ne couvre pas les unités qui ne sont jamais passées par un état d'« activation » (telles les unités de périphérique qui passent directement de l'état « inactif » à « actif »)\&. En outre, elle ne montre pas d'information sur les tâches (et en particulier les tâches achevées)\&.

note: type: Plain text
en: This command will load unit files and print warnings if any errors are detected\&. Files specified on the command line will be loaded, but also any other units referenced by them\&. The full unit search path is formed by combining the directories for all command line arguments, and the usual unit load paths\&. The variable I<$SYSTEMD_UNIT_PATH> is supported, and may be used to replace or augment the compiled in set of unit load paths; see B<systemd.unit>(5)\&. All units files present in the directories containing the command line arguments will be used in preference to the other paths\&.
fr_FR: Cette commande chargera les fichiers d'unité et affichera des avertissements si des erreurs sont détectées\&. Les fichiers indiqués sur la ligne de commande seront chargés, mais aussi d'autres unités qui sont référencées par eux\&. Le chemin entier de recherche de l'unité est formé en combinant les répertoires pour tous les arguments de la ligne de commande et les chemins habituels de chargement des unités\&. La variable I<$SYSTEMD_UNIT_PATH> est prise en charge et peut être utilisée pour augmenter ou remplacer l'ensemble compilé de chemins de chargement des unités ; voir B<systemd.unit>(5)\&. Tous les fichiers d'unités présents dans les répertoires contenus dans les arguments de la ligne de commande seront utilisés de préférence aux autres chemins\&.

note: type: Plain text
en: B<Example\ \&16.\ \&Misspelt directives>
fr_FR: B<Exemple\ \&16.\ \&Instructions mal orthographiées>

note: type: Plain text
en: B<Example\ \&17.\ \&Missing service units>
fr_FR: B<Exemple\ \&17.\ \&Unités de service manquantes>

note: type: Plain text
en: B<Example\ \&18.\ \&Analyze systemd-logind\&.service>
fr_FR: B<Exemple\ \&18.\ \&Analyser systemd-logind\&.service>

note: type: Plain text
en: With B<cat-files>, show config files underneath the specified root path I<PATH>\&.
fr_FR: Avec B<cat-files>, afficher les fichiers de configuration sous-jacents au chemin racine indiqué I<CHEMIN>\&.

note: type: Plain text
en: On success, 0 is returned, a non-zero failure code otherwise\&.
fr_FR: En cas de succès, B<0> est renvoyé, autrement, un code d'échec différent de zéro est renvoyé\&.
