perf_event_open

NOM

BIBLIOTHÈQUE

SYNOPSIS

#include <linux/perf_event.h>    /* Définition des constantes PERF_* */
#include <linux/hw_breakpoint.h> /* Définition des constantes HW_* */
#include <sys/syscall.h>         /* Définition des constantes SYS_* */
#include <unistd.h>

int syscall(SYS_perf_event_open, struct perf_event_attr *attr,
            pid_t pid, int cpu, int group_fd, unsigned long flags);

DESCRIPTION

Arguments

pid == 0 et cpu == -1

Cela mesure le processus ou thread appelant sur tous les processeurs.

pid == 0 et cpu >= 0

Cela ne mesure le processus ou thread appelant que s’il est en cours d’exécution sur le processeur indiqué.

pid > 0 et cpu == -1

Cela mesure le processus ou thread indiqué sur tous les processeurs.

pid > 0 et cpu >= 0

Cela ne mesure le processus ou thread indiqué que s’il est en cours d’exécution sur le processeur indiqué.

pid == -1 et cpu >= 0

Cela mesure tous les processus et threads du processeur indiqué. Cela nécessite la capacité CAP_PERFMON (depuis Linux 5.8) ou CAP_SYS_ADMIN ou une valeur /proc/sys/kernel/perf_event_paranoid strictement inférieure à 1.

pid == -1 et cpu == -1

Ce réglage est incorrect et renverra une erreur.

PERF_FLAG_FD_CLOEXEC (depuis Linux 3.14)

Cet attribut active l’attribut « close-on-exec » pour le descripteur de fichier de l’événement créé, de telle sorte que le descripteur de fichier est automatiquement fermé par execve(2). L’attribution de « close-on-exec » au moment de la création, plutôt qu’ensuite avec fcntl(2), évite de potentielles situations de compétition où le thread appelant invoque perf_event_open() et fcntl() en même temps qu’un autre thread appelle fork(2) puis execve(2).

PERF_FLAG_FD_NO_GROUP

Cet attribut dit à l'événement d'ignorer le paramètre group_fd, sauf pour initialiser la redirection de la sortie en utilisant l'attribut PERF_FLAG_FD_OUTPUT.

PERF_FLAG_FD_OUTPUT (cassé depuis Linux 2.6.35)

Cet attribut redirige la sortie échantillonnée de l'événement vers le tampon mmap de l'événement indiqué par group_fd.

PERF_FLAG_PID_CGROUP (depuis Linux 2.6.39)

Cet attribut active la surveillance par conteneur sur tout le système. Un conteneur est une abstraction qui isole un ensemble de ressources à contrôler plus finement (processeurs, mémoire, etc.). Dans ce mode, l'événement n'est mesuré que si le thread exécuté sur le processeur surveillé appartient au conteneur désigné (cgroup). Le cgroup est identifié en passant un fichier au descripteur de fichier ouvert sur son répertoire dans le système de fichiers cgroupfs. Par exemple, si le cgroup à surveiller est appelé test, alors un descripteur de fichier ouvert sur /dev/cgroup/test (en supposant que cgroupfs est monté sur /dev/cgroup) doit être passé au paramètre pid. La surveillance de cgroup n'est disponible que pour les événements sur tout le système et pourrait donc nécessiter des droits supplémentaires.

struct perf_event_attr {
    __u32 type;         /* Type d'événement */
    __u32 size;         /* Taille de la structure d'attributs */
    __u64 config;       /* Configuration spécifique au type */

    union {
        __u64 sample_period;    /* Période d'échantillonnage */
        __u64 sample_freq;      /* Fréquence d'échantillonnage */
    };

    __u64 sample_type;  /* Indique les valeurs incluses dans
                           l’échantillon */
    __u64 read_format;  /* Indique les valeurs renvoyées en
                           lecture */

    __u64 disabled       : 1,   /* désactivé par défaut */
          inherit        : 1,   /* les enfants en héritent */
          pinned         : 1,   /* doit toujours être en PMU */
          exclusive      : 1,   /* ne regrouper qu'en PMU */
          exclude_user   : 1,   /* ne pas compter l'utilisateur */
          exclude_kernel : 1,   /* ne pas compter le noyau */
          exclude_hv     : 1,   /* ne pas compter l'hyperviseur */
          exclude_idle   : 1,   /* ne pas compter quand inactif */
          mmap           : 1,   /* inclure les données mmap */
          comm           : 1,   /* inclure les données comm */
          freq           : 1,   /* utiliser la fréquence, pas la
                                   période */
          inherit_stat   : 1,   /* décomptes par tâche */
          enable_on_exec : 1,   /* prochain exec activé */
          task           : 1,   /* tracer la création d’enfant
                                   et la fin */
          watermark      : 1,   /* wakeup_watermark */
          precise_ip     : 2,   /* contrainte de dérapage */
          mmap_data      : 1,   /* données mmap non exécutées */
          sample_id_all  : 1,   /* tous les événements sample_type */
          exclude_host   : 1,   /* ne pas compter dans l'hôte */
          exclude_guest  : 1,   /* ne pas compter dans l'invité */
          exclude_callchain_kernel : 1,
                                /* exclure les appels en chaîne
                                   du noyau */
          exclude_callchain_user   : 1,
                                /* exclure les appels en chaîne
                                   d’utilisateur */
          mmap2          :  1,  /* inclure mmap avec les données d'inœud */
          comm_exec      :  1,  /* événements flag comm devant être
                                   exécutés */
          use_clockid    :  1,  /* utiliser clockid pour les champs de temps */
          context_switch :  1,  /* données de changement de contexte */
          write_backward :  1,  /* Écrire le tampon circulaire de la fin
                                   vers le début */
          namespaces     :  1,  /* inclure les données des espaces de noms */
          ksymbol        :  1,  /* inclure les événements ksymbol */
          bpf_event      :  1,  /* inclure les événements BPF */
          aux_output     :  1,  /* générer les enregistrements AUX au lieu des
                                   événements */
          cgroup         :  1,  /* inclure les événements cgroup */
          text_poke      :  1,  /* inclure les événements de poke de texte */
          build_id       :  1,  /* utiliser build id dans les événements mmap2 */
          inherit_thread :  1,  /* seuls les enfants en héritent */
                                /* si cloné avec CLONE_THREAD */
          remove_on_exec :  1,  /* l'événement est supprimé des tâches
                                   à l'exécution */
          sigtrap        :  1,  /* envoyer un SIGTRAP synchrone
                                   lors d'un événement */

          __reserved_1   : 26;

    union {
        __u32 wakeup_events;    /* réveil tous les n événements */
        __u32 wakeup_watermark; /* octets avant le réveil */
    };

    __u32     bp_type;          /* type de point d'arrêt */

    union {
        __u64 bp_addr;          /* adresse de point d'arrêt */
        __u64 kprobe_func;      /* pour perf_kprobe */
        __u64 uprobe_path;      /* pour perf_uprobe */
        __u64 config1;          /* extension de config */
    };

    union {
        __u64 bp_len;           /* taille de point d'arrêt */
        __u64 kprobe_addr;      /* avec  kprobe_func == NULL */
        __u64 probe_offset;     /* pour perf_[k,u]probe */
        __u64 config2;          /* extension de config1 */
    };
    __u64 branch_sample_type;   /* enum perf_branch_sample_type */
    __u64 sample_regs_user;     /* registres utilisateur à renvoyer
                                   dans les échantillons */
    __u32 sample_stack_user;    /* taille de pile à renvoyer dans
                                   les échantillons */
    __s32 clockid;              /* horloge à utiliser pour les champs
                                   de temps */
    __u64 sample_regs_intr;     /* registres à renvoyer dans les
                                   échantillons */
    __u32 aux_watermark;        /* octets supp. avant le réveil */
    __u16 sample_max_stack;     /* nombre maximal de trames dans la
                                   chaîne d'appel */
    __u32 __reserved_2;         /* aligner sur u64 */
    __u32 aux_sample_size;      /* taille maximale d'échantillon aux */
    __u32 __reserved_3;         /* aligner sur u64 */
    __u64 sig_data;             /* données utilisateur pour sigtrap */

};

type

Ce champ indique le type d'événement dans son ensemble. Il a une des valeurs suivantes :

size

La taille de la structure perf_event_attr pour compatibilités ascendante et descendante. Définissez-la en utilisant sizeof(struct perf_event_attr) pour permettre au noyau de voir la taille de struct au moment de la compilation.

Le PERF_ATTR_SIZE_VER0 relatif est défini à 64 ; c'était la taille de la première struct publiée. PERF_ATTR_SIZE_VER1 est 72, correspondant à l'addition des points d'arrêts dans Linux 2.6.33. PERF_ATTR_SIZE_VER2 est 80, correspondant à l'addition d'échantillonnage de branchement dans Linux 3.4. PERF_ATR_SIZE_VER3 est 96, correspondant à l'addition de sample_regs_user et sample_stack_user dans Linux 3.7. PERF_ATTR_SIZE_VER4 vaut 104, correspondant à l'ajout de sample_regs_intr dans Linux 3.19. PERF_ATTR_SIZE_VER5 vaut 112, correspondant à l'ajout de aux_watermark dans Linux 4.1.

config

Cela indique l'événement voulu, en conjonction avec le champ type. Les champs config1 et config2 sont aussi pris en compte dans les cas où 64 bits ne suffisent pas pour spécifier complètement l'événement. L'encodage de ces champs dépend de l'événement.

Le champ config peut être défini de différentes façons, en fonction de la valeur du champ type précédemment décrit. Suivent les divers réglages possibles pour config, distingués par type.

Si type est PERF_TYPE_HARDWARE, un des événements processeur matériel généralisé est mesuré. Ils ne sont pas tous disponibles sur toutes les plateformes. Définissez config à une des valeurs suivantes :

Si type est PERF_TYPE_SOFTWARE, les événements logiciels fournis par le noyau sont mesurés. Définissez config à une des valeurs suivantes :

config = (perf_hw_cache_id) |
         (perf_hw_cache_op_id << 8) |
         (perf_hw_cache_op_result_id << 16);

kprobe_func, uprobe_path, kprobe_addr et probe_offset

Ces champs décrivent les kprobe/uprobe pour les PMU dynamiques kprobe et uprobe. Pour kprobe utilisez kprobe_func et probe_offset ou alors utilisez kprobe_addr et laissez le champ kprobe_func à NULL. Pour uprobe, utilisez uprobe_path et probe_offset.

sample_period, sample_freq

Un compteur d'« échantillonnage » génère une notification de dépassement tous les N événements, où N est donné par sample_period. Un compteur d'échantillonnage a sample_period > 0. Quand un dépassement arrive, les données demandées sont enregistrées dans le tampon mmap. Le champ sample_type contrôle les données qui sont enregistrées à chaque dépassement.

sample_freq permet d'utiliser la fréquence au lieu de la période. Dans ce cas, l'attribut freq doit être défini. Le noyau ajustera la période d'échantillonnage pour essayer d'atteindre le taux voulu. Le taux d'ajustement est un tic d'horloge.

sample_type

Les divers bits de ce champ indiquent les valeurs à inclure dans l'échantillon. Elles seront enregistrées dans un tampon circulaire, disponible en espace utilisateur avec mmap(2). L'ordre de sauvegarde des valeurs dans l'échantillon est documenté dans la sous-section Disposition MMAP ci-dessous ; ce n'est pas l'ordre enum perf_event_sample_format.

union perf_sample_weight {
    u64  full;           /* PERF_SAMPLE_WEIGHT */
    struct {             /* PERF_SAMPLE_WEIGHT_STRUCT */
        u32  var1_dw;
        u16  var2_w;
        u16  var3_w;
    };
};

read_format

Ce champ indique le format des données renvoyées par read(2) sur un descripteur de fichier perf_event_open().

disabled

Le bit disabled indique si le compteur commence désactivé ou activé. Si désactivé, l'événement peut être activé plus tard par ioctl(2), prctl(2) ou enable_on_exec.

Lors de la création d’un groupe d’événements, le leader de groupe est généralement initialisé avec disabled défini à 1 et tous les événements enfants sont initialisés avec disabled défini à 0. Bien que disabled soit 0, les événements enfants ne démarrent pas avant que le leader de groupe ne soit activé.

inherit

Le bit inherit indique que le compteur devrait compter les événements des tâches enfant comme les tâches indiquées. Cela ne s'applique qu'aux nouveaux enfants, pas à ceux existants au moment où le compteur est créé (ni aux nouveaux enfants des enfants existants).

L'héritage ne fonctionne pas pour certaines combinaisons de read_format, comme PERF_FORMAT_GROUP.

pinned

Le bit pinned indique que le compteur devrait toujours être sur le processeur si c'est possible. Cela ne s'applique qu'aux compteurs matériels et seulement aux leaders de groupe. Si un compteur épinglé ne peut pas être mis dans le processeur (par exemple s'il n'y a pas assez de compteurs matériels ou en cas de confit avec n'importe quel autre événement), alors le compteur arrive en état d'« erreur », où les lectures renvoient une fin de fichier (c'est-à-dire que read(2) renvoie 0) jusqu'à ce que le compteur soit ensuite activé ou désactivé.

exclusive

Le bit exclusive indique que si ce groupe du compteur est sur le processeur, il devrait être le seul groupe utilisant les compteurs du processeur. Cela pourrait permettre à l'avenir de surveiller des programmes pour gérer les fonctionnalités PMU qui doivent fonctionner seules, sans perturber d'autres compteurs matériels.

Remarquez que de nombreuses situations non attendues pourraient empêcher de démarrer les événements avec le bit exclusive défini. Cela concerne tous les utilisateurs exécutant des mesures au niveau du système ainsi que toutes les utilisations par le noyau des compteurs de performance (y compris l’interface NMI Watchdog Timer habituellemen activée).

exclude_user

Si ce bit est défini, le décompte exclut les événements qui arrivent dans l'espace utilisateur.

exclude_kernel

Si ce bit est défini, le décompte exclut les événements qui arrivent dans l'espace du noyau.

exclude_hv

Si ce bit est défini, le décompte exclut les événements qui arrivent dans l'hyperviseur. C'est surtout pour les PMU avec prise en charge intégrée de leur traitement (comme POWER). Une prise en charge supplémentaire est nécessaire pour traiter les mesures d'hyperviseur sur la plupart des machines.

exclude_idle

S'il est défini, ne pas décompter quand le processeur exécute la tâche inactive. Si vous pouvez actuellement activer cela pour n'importe quel type d'événement, il est ignoré pour tous, sauf ceux de type logiciel.

mmap

Le bit mmap active la génération des échantillons PERF_RECORD_MMAP pour tous les appels mmap(2) qui ont PROT_EXEC défini. Cela permet aux outils de remarquer le nouveau code exécutable en train d’être associé dans un programme (les bibliothèques partagées dynamiques par exemple) de telle sorte que les adresses peuvent être réassociées au code d’origine.

comm

Le bit comm active le suivi du nom de commande de processus tel que modifié par les appels système execve(2) et prctl(PR_SET_NAME) ainsi que l'écriture dans /proc/self/comm. Si l'attribut comm_exec est positionné avec succès (ce qui est possible depuis Linux 3.16), l'attribut général PERF_RECORD_MISC_COMM_EXEC peut être utilisé pour différencier le cas execve(2) des autres.

freq

Si ce bit est activé, alors sample_frequency est utilisé au lieu de sample_period lors du réglage de l'intervalle d'échantillonnage.

inherit_stat

Ce bit active la sauvegarde des décomptes d'événements lors du changement de contexte pour les tâches héritées. Cela n'a de sens que si le champ inherit est défini.

enable_on_exec

Si ce bit est défini, un compteur est automatiquement activé après un appel d' execve(2).

task

Si ce bit est défini, alors les notifications de création d’enfant et de fin sont inclues au tampon circulaire.

watermark

Si défini, une notification de débordement arrive lors du passage de la frontière wakeup_watermark. Sinon, les notifications arrivent après les échantillons wakeup_events.

precise_ip (depuis Linux 2.6.35)

Cela contrôle la quantité de dérapage. Le dérapage est le nombre d'instructions qui s'exécutent entre l'arrivée d'un événement d'intérêt et la possibilité du noyau de s'arrêter pour enregistrer l'événement. Les plus petits dérapages sont meilleurs et permettent d'associer plus précisément les événements correspondant aux instructions, mais le matériel est souvent limité par leur taille.

Les valeurs possibles du champ sont les suivantes :

mmap_data (depuis Linux 2.6.36)

L’opposé du champ mmap. Cela active la génération des échantillons PERF_RECORD_MMAP pour les appels mmap(2) qui n’ont pas PROT_EXEC défini (par exemple les données et la mémoire partagée SysV).

sample_id_all (depuis Linux 2.6.38)

Si défini, alors TID, TIME, ID, STREAM_ID et CPU peuvent de plus être inclus dans les non PERF_RECORD_SAMPLE si le sample_type correspondant est sélectionné.

Si PERF_SAMPLE_IDENTIFIER est indiqué, alors une valeur d’identifiant supplémentaire est incluse en dernière valeur pour faciliter l’analyse du flux d’enregistrement. Cela peut avoir pour conséquence de voir apparaître la valeur id deux fois.

La disposition est décrite par cette pseudostructure :

struct sample_id {
    { u32 pid, tid; } /* si PERF_SAMPLE_TID est défini        */
    { u64 time;     } /* si PERF_SAMPLE_TIME est défini       */
    { u64 id;       } /* si PERF_SAMPLE_ID est défini         */
    { u64 stream_id;} /* si PERF_SAMPLE_STREAM_ID est défini  */
    { u32 cpu, res; } /* si PERF_SAMPLE_CPU est défini        */
    { u64 id;       } /* si PERF_SAMPLE_IDENTIFIER est défini */
};
    

exclude_host (depuis Linux 3.2)

Quand on prend des mesures comprenant les processus exécutant des instances de VM (à savoir si on exécute ioctl(2) KVM_RUN), ne mesurer que les événements dans l'instance de l'invité. Cela n'a de sens qu'à l'extérieur de l'invité ; ce paramètre ne modifie pas les compteurs à l'intérieur d'un invité. Actuellement, cette fonctionnalité n'existe que sur x86.

exclude_guest (depuis Linux 3.2)

Quand on prend des mesures comprenant les processus exécutant des instances de VM (à savoir si on exécute ioctl(2) KVM_RUN), ne pas mesurer les événements dans l'instance de l'invité. Cela n'a de sens qu'à l'extérieur de l'invité ; ce paramètre ne modifie pas les compteurs à l'intérieur d'un invité. Actuellement, cette fonctionnalité n'existe que sur x86.

exclude_callchain_kernel (depuis Linux 3.7)

Ne pas inclure les appels en chaîne du noyau.

exclude_callchain_user (depuis Linux 3.7)

Ne pas inclure les appels en chaîne d'utilisateur.

mmap2 (depuis Linux 3.16)

Générer un enregistrement mmap exécutable étendu contenant assez d'informations supplémentaires pour n'identifier que les projections partagées. L'attribut mmap doit aussi être défini pour que cela fonctionne.

comm_exec (depuis Linux 3.16)

Il s'agit d'un attribut de pure détection de fonctionnalité, il ne modifie pas le comportement du noyau. Si cet attribut peut être positionné avec succès, quand comm est activé, l'attribut PERF_RECORD_MISC_COMM_EXEC sera positionné dans le champ misc de l'entête de l'enregistrement comm si l'événement de renommage signalé a été causé par un appel à execve(2). Cela permet aux outils de distinguer les types de renommage du processus.

use_clockid (depuis Linux 4.1)

Cela permet de sélectionner l'horloge interne du noyau Linux à utiliser lors de la génération des horodatages à l'aide du champ clockid. Cela peut faciliter la corrélation des durées d'échantillonnage des perf avec les horodatages générés par d'autres outils.

context_switch (depuis Linux 4.3)

Cela active la génération d'enregistrements PERF_RECORD_SWITCH lors d'un changement de contexte. Cela active aussi la génération d'enregistrements PERF_RECORD_SWITCH_CPU_WIDE lors d'un échantillonnage en mode processeur complet. Cette fonctionnalité s'ajoute aux points de trace existants et aux événements logiciels de mesure des changements de contexte. L'avantage de cette méthode est qu'elle fournira toutes les informations même avec des réglages perf_event_paranoid stricts.

write_backward (depuis Linux 4.6)

Cela fait écrire le tampon circulaire de la fin vers le début. Cela permet de gérer la lecture à partir d’un tampon circulaire réinscriptible.

namespaces (depuis Linux 4.11)

Cela active la génération d'enregistrements PERF_RECORD_NAMESPACES lorsqu'une tâche entre dans un nouvel espace de noms. Chaque espace de noms a une combinaison de numéros de périphérique et d'inœud.

ksymbol (depuis Linux 5.0)

Cela active la génération d'enregistrements PERF_RECORD_KSYMBOL quand de nouveaux symboles du noyau sont enregistrés ou désenregistrés. Cela concerne les fonctions dynamiques d’analyse du noyau comme eBPF.

bpf_event (depuis Linux 5.0)

Cela active la génération d'enregistrements PERF_RECORD_BPF_EVENT lorsqu'un programme eBPF est chargé ou déchargé.

aux_output (depuis Linux 5.4)

Cela permet aux événements normaux (non-AUX) de générer des données pour des événements AUX si le matériel le prend en charge.

cgroup (depuis Linux 5.7)

Cela active la génération d'enregistrements PERF_RECORD_CGROUP quand un nouveau cgroup est créé (et activé).

text_poke (depuis Linux 5.8)

Cela active la génération d'enregistrements PERF_RECORD_TEXT_POKE quand un changement se produit dans le texte du noyau (c'est-à-dire quand du code se modifie lui-même).

build_id (depuis Linux 5.12)

Cela modifie le contenu dePERF_RECORD_MMAP2 pour avoir un build-id à la place des numéros de périphérique et d'inœud.

inherit_thread (depuis Linux 5.13)

Cela désactive l'héritage de l'événement vers un processus enfant. Seuls les nouveaux threads dans le même processus (qui est cloné avec CLONE_THREAD) hériteront de l'événement.

remove_on_exec (depuis Linux 5.13)

Cela clôt l'événement quand il démarre une nouvelle image de processus avec execve(2).

sigtrap (depuis Linux 5.13)

Cela permet l'envoi d'un signal synchrone de SIGTRAP quand un événement déborde.

wakeup_events, wakeup_watermark

Cette union indique le nombre d'échantillons (wakeup_events) ou d'octets ( wakeup_watermark) qui arrivent avant un signal de dépassement. Celui utilisé est sélectionné par l'attribut watermark.

wakeup_events ne compte que les types d’enregistrement PERF_RECORD_SAMPLE. Pour recevoir un signal pour tous les types PERF_RECORD arrivant, choisissez watermark et définissez wakeup_watermark à 1.

Avant Linux 3.0, positionner wakeup_events à 0 ne signalait aucun dépassement ; les noyaux plus récents traitent 0 comme 1.

bp_type (depuis Linux 2.6.33)

Cela choisit le type de point d'arrêt. Il s'agit d'un des suivants :

bp_addr (depuis Linux 2.6.33)

Il s'agit de l'adresse du point d'arrêt. Pour les points d'arrêt d'exécution, c'est l'adresse mémoire de l'instruction d'intérêt ; pour les points d'arrêt de lecture et écriture, c'est l'adresse mémoire de l'emplacement mémoire d'intérêt.

config1 (depuis Linux 2.6.39)

config1 est utilisé pour définir des événements qui ont besoin d'un registre supplémentaire ou qui sinon ne rentrent pas dans le champ config normal. OFFCORE_EVENTS brut sur Nehalem/Westmere/SandyBridge utilise ce champ sur Linux 3.3 et les noyaux suivants.

bp_len (depuis Linux 2.6.33)

bp_len est la taille du point d'arrêt mesuré si type est PERF_TYPE_BREAKPOINT. Les options sont HW_BREAKPOINT_LEN_1, HW_BREAKPOINT_LEN_2, HW_BREAKPOINT_LEN_4 et HW_BREAKPOINT_LEN_8. Pour un point d'arrêt, définissez-la à sizeof(long).

config2 (depuis Linux 2.6.39)

config2 est une extension supplémentaire du champ config1.

branch_sample_type (depuis Linux 3.4)

Si PERF_SAMPLE_BRANCH_STACK est activé, alors cela indique les branchements à inclure dans l’enregistrement de branchements.

La première partie de la valeur est le niveau de droits qui est une combinaison d’une des valeurs suivantes. Si l’utilisateur ne définit pas explicitement le niveau de droits, le noyau utilisera celui de l’événement. Les niveaux de droits de l’événement et du branchement ne doivent pas nécessairement correspondre.

sample_regs_user (depuis Linux 3.7)

Ce masque binaire définit l’ensemble des registres processeur utilisateur à renvoyer dans les échantillons. La disposition du masque de registre est spécifique à l’architecture et définie dans l’en-tête du noyau arch/ARCH/include/uapi/asm/perf_regs.h.

sample_stack_user (depuis Linux 3.7)

Cela définit la taille de la pile utilisateur à renvoyer si PERF_SAMPLE_STACK_USER est indiqué.

clockid (depuis Linux 4.1)

Si use_clockid est positionné, ce champ sélectionne l'horloge interne de Linux à utiliser pour les horodatages. Les horloges disponibles sont définies dans linux/time.h, où sont actuellement prises en charge CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW, CLOCK_REALTIME, CLOCK_BOOTTIME et CLOCK_TAI.

aux_watermark (depuis Linux 4.1)

Cela indique la quantité de données nécessaires pour récupérer un échantillonnage PERF_RECORD_AUX.

sample_max_stack (depuis Linux 4.8)

Quand sample_type comprend PERF_SAMPLE_CALLCHAIN, ce champ indique le nombre de trames de pile à rendre compte lors de la génération de la chaîne d'appels.

aux_sample_size (depuis Linux 5.5)

Quand l'attribut PERF_SAMPLE_AUX est défini, spécification de la taille souhaitée aux données AUX. Notez qu'il peut recevoir des données plus petites que la taille indiquée.

sig_data (depuis Linux 5.13)

Cette donnée sera copiée vers le gestionnaire de signal de l'utilisateur (au moyen de si_perf dans siginfo_t ) pour disambiguïser l'événement qui a déclenché le signal.

Lecture des résultats

•

Si PERF_FORMAT_GROUP a été indiqué pour permettre de lire tous les événements d'un groupe en une fois :

struct read_format {
    u64 nr;            /* Le nombre d'événements */
    u64 time_enabled;  /* si PERF_FORMAT_TOTAL_TIME_ENABLED */
    u64 time_running;  /* si PERF_FORMAT_TOTAL_TIME_RUNNING */
    struct
        u64 value;     /* La valeur de l'événement */
        u64 id;        /* si PERF_FORMAT_ID */
        u64 lost;      /* si PERF_FORMAT_LOST */
    } values[nr];
};
    

•

Si PERF_FORMAT_GROUP n'a pas été indiqué :

struct read_format {
    u64 value;         /* La valeur de l'événement */
    u64 time_enabled;  /* si PERF_FORMAT_TOTAL_TIME_ENABLED */
    u64 time_running;  /* si PERF_FORMAT_TOTAL_TIME_RUNNING */
    u64 id;            /* si PERF_FORMAT_ID */
    u64 lost;          /* si PERF_FORMAT_LOST */
};
    

nr

Le nombre d'événements dans le descripteur de fichier. Seulement disponible si PERF_FORMAT_GROUP a été indiqué.

time_enabled, time_running

Temps total pendant lequel l'événement a été activé et exécuté. Normalement ce sont les mêmes. Si plus d'événements sont démarrés que d'emplacements de compteur disponibles sur la PMU, alors il y a multiplexage et les événements ne sont pas exécutés tout le temps. Dans ce cas, les valeurs time_enabled et time running peuvent être utilisées pour estimer une valeur d'ordre de grandeur du décompte.

value

Une valeur positive sur 64 bits contenant le résultat du compteur.

id

Une valeur unique globale pour cet événement en particulier, seulement si PERF_FORMAT_ID a été indiqué dans read_format.

lost

Le nombre des échantillons perdus de cet événement ; seulement si PERF_FORMAT_LOST a été indiqué dans read_format.

Disposition MMAP

struct perf_event_mmap_page {
    __u32 version;        /* numéro de version de la structure */
    __u32 compat_version; /* plus petite version compatible */
    __u32 lock;           /* seqlock pour synchronisation */
    __u32 index;          /* identifiant de compteur matériel */
    __s64 offset;         /* ajouter au compteur matériel */
    __u64 time_enabled;   /* temps d'événement actif */
    __u64 time_running;   /* temps d'événement sur processeur */
    union {
        __u64   capabilities;
        struct {
            __u64 cap_usr_time / cap_usr_rdpmc / cap_bit0 : 1,
                  cap_bit0_is_deprecated : 1,
                  cap_user_rdpmc         : 1,
                  cap_user_time          : 1,
                  cap_user_time_zero     : 1,
        };
    };
    __u16 pmc_width;
    __u16 time_shift;
    __u32 time_mult;
    __u64 time_offset;
    __u64 __reserved[120];   /* remplissage à 1 k */
    __u64 data_head;         /* tête de la section de données */
    __u64 data_tail;         /* queue écrite en espace utilisateur */
    __u64 data_offset;       /* où commence le tampon */
    __u64 data_size;         /* taille du tampon de données */
    __u64 aux_head;
    __u64 aux_tail;
    __u64 aux_offset;
    __u64 aux_size;
}

}

version

Numéro de version de cette structure.

compat_version

La plus petite version avec laquelle elle est compatible.

lock

Un seqlock (sequence lock) pour la synchronisation.

index

Un identifiant unique de compteur matériel.

décalage

Quand l’instruction rdpmc est utilisée pour lire, cette valeur de position doit être ajoutée à celle renvoyée par rdpmc pour obtenir le décompte total actuel d’événements.

time_enabled

Temps d'activité de l'événement.

time_running

Temps d'exécution de l'événement.

cap_usr_time / cap_usr_rdpmc / cap_bit0 (depuis Linux 3.4)

Un bogue existait dans la définition de cap_usr_time et cap_usr_rdpmc de Linux 3.4 à Linux 3.11. Les deux bits étaient définis pour pointer vers le même endroit, il était donc impossible de savoir si cap_usr_time ou cap_usr_rdpmc étaient vraiment définis.

Depuis Linux 3.12, ils ont été renommés en cap_bit0 et vous devriez plutôt utiliser les nouveaux champs cap_user_time et cap_user_rdpmc à la place.

cap_bit0_is_deprecated (depuis Linux 3.12)

Si défini, ce bit indique que le noyau est capable de gérer les bits cap_user_time et cap_user_rdpmc différenciés correctement.

Si non, cela indique qu’il s’agit d’un ancien noyau où cap_usr_time et cap_usr_rdpmc pointent vers le même bit et donc que ces deux fonctionnalités devraient être utilisées avec prudence.

cap_usr_rdpmc (depuis Linux 3.12)

Si le matériel permet la lecture en espace utilisateur des compteurs de performance sans appel système (c'est l'instruction « rdpmc » sur x86), alors le code suivant peut être utilisé pour faire une lecture :

u32 seq, time_mult, time_shift, idx, width;
u64 count, enabled, running;
u64 cyc, time_offset;

do {
    seq = pc->lock;
    barrier();
    enabled = pc->time_enabled;
    running = pc->time_running;

    if (pc->cap_usr_time && enabled != running) {
        cyc = rdtsc();
        time_offset = pc->time_offset;
        time_mult   = pc->time_mult;
        time_shift  = pc->time_shift;
    }

    idx = pc->index;
    count = pc->offset;

    if (pc->cap_usr_rdpmc && idx) {
        width = pc->pmc_width;
        count += rdpmc(idx - 1);
    }

    barrier();
} while (pc->lock != seq);
    

cap_user_time (depuis Linux 3.12)

Ce bit indique que le matériel a un compteur temporel sans arrêt, constant (TSC sur x86).

cap_usr_time_zero (depuis Linux 3.12)

Indique la présence de time_zero qui permet d’associer les valeurs d’horodatage à l’horloge matérielle.

pmc_width

Si cap_usr_rdpmc, ce champ fournit la taille en bit de la valeur lue en utilisant l'instruction rdpmc ou équivalente. Cela permet d'étendre avec signe le résultat comme ceci :

pmc <<= 64 - pmc_width;
pmc >>= 64 - pmc_width; // déplacement du signe à droite
count += pmc;
    

time_shift, time_mult, time_offset

Si cap_usr_time, ces champs peuvent être utilisés pour calculer la différence de temps depuis time_enabled (en nanoseconde) en utilisant rdtsc ou similaire.

u64 quot, rem;
u64 delta;

quot = cyc >> time_shift;
rem  = cyc & (((u64)1 << time_shift) - 1);
delta = time_offset + quot * time_mult +
        ((rem * time_mult) >> time_shift);
    

Où time_offset, time_mult, time_shift et cyc sont lus dans la boucle seqcount décrite ci-dessus. Cette différence peut être ajoutée à enabled et éventuellement running (si idx), pour améliorer l'échelle :

enabled += delta;
if (idx)
    running += delta;
quot = count / running;
rem  = count % running;
count = quot * enabled + (rem * enabled) / running;
    

time_zero (depuis Linux 3.12)

Si cap_usr_time_zero est défini, alors l'horloge matérielle (le compteur temporel TSC sur x86) peut être calculée à partir des valeurs time_zero, time_mult et time_shift :

time = timestamp - time_zero;
quot = time / time_mult;
rem  = time % time_mult;
cyc  = (quot << time_shift) + (rem << time_shift) / time_mult;
    

et vice versa :

quot = cyc >> time_shift;
rem  = cyc & (((u64)1 << time_shift) - 1);
timestamp = time_zero + quot * time_mult +
            ((rem * time_mult) >> time_shift);
    

data_head

Cela pointe vers la tête de la section de données. La valeur augmente continuellement, elle n'est pas coupée. Vous devrez couper vous-même la valeur à la taille du tampon mmap avant d'accéder aux échantillons.

Sur les plateformes compatibles SMP, après la lecture de la valeur data_head, l'espace utilisateur devrait renvoyer un rmb().

data_tail

Quand l'association est PROT_WRITE, la valeur data_tail devrait être écrite par l'espace utilisateur pour refléter les dernières données lues. Dans ce cas, le noyau n'écrasera pas les données non lues.

data_offset (depuis Linux 4.1)

Contient la position de l'emplacement du tampon mmap où les données de l'échantillon de perf commencent.

data_size (depuis Linux 4.1)

Contient la taille de la zone de l'échantillon de perf dans le tampon mmap.

aux_head, aux_tail, aux_offset, aux_size (depuis Linux 4.1)

La zone AUX permet d'appliquer à un mmap(2) un tampon d'échantillonnage distinct pour les flux de données à forte bande passante (séparément du tampon d'échantillonnage de perf principal). Un exemple de flux à forte bande passante est la prise en charge du traçage d'une instruction telle qu'elle se fait dans les nouveaux processeurs Intel.

Pour définir une zone AUX, il faut d'abord positionner aux_offset à une position supérieure à data_offset+data_size puis positionner aux_size à la taille de tampon désirée. La position et la taille désirée doivent être alignées sur la page et la taille doit être une puissance de deux. Ces valeurs sont alors passées à mmap pour projeter le tampon AUX. Les pages du tampon AUX sont comprises dans la limite de ressource RLIMIT_MEMLOCK (voir setrlimit(2)) et dans la gestion des droits perf_event_mlock_kb.

Par défaut, le tampon AUX sera tronqué s'il ne rentre pas dans l'espace disponible du tampon circulaire. Si le tampon AUX est projeté en tant que tampon en lecture seule, il agira dans le mode du tampon circulaire là où les données seront remplacées par de nouvelles. En mode remplacement, il se pourrait qu'il ne soit pas possible de présumer l'endroit où commencent les données et il appartient au consommateur de désactiver la mesure pendant la lecture pour éviter les possibles collisions de données.

Les pointeurs de tampon circulaire aux_head et aux_tail ont le même comportement et les mêmes règles d'organisation que celles décrites précédemment pour data_head et data_tail.

struct perf_event_header {
    __u32   type;
    __u16   misc;
    __u16   size;
};

size

Cela indique la taille de l'enregistrement.

misc

Le champ misc contient des renseignements supplémentaires sur l'échantillon.

Le mode de processeur peut être déterminé à partir de cette valeur en la masquant avec PERF_RECORD_MISC_CPUMODE_MASK et en recherchant un des suivants (remarquez que ce ne sont pas des masques de bits, un seul peut être défini à la fois).

type

La valeur type est une des suivantes. Les valeurs dans l'enregistrement correspondant (qui suit l'en-tête) dépendent du type sélectionné comme c'est montré.

Gestion du dépassement

Instruction rdpmc

Appels ioctl perf_event

PERF_EVENT_IOC_ENABLE

Cela active l'événement individuel ou le groupe d'événements indiqué par l'argument de descripteur de fichier.

Si le bit PERF_IOC_FLAG_GROUP est défini dans l’argument ioctl, alors tous les événements d’un groupe sont activés, même si l’événement indiqué n’est pas le leader de groupe (mais consultez la section BOGUES).

PERF_EVENT_IOC_DISABLE

Cela désactive le compteur individuel ou le groupe d'événements indiqué par l'argument de descripteur de fichier.

L'activation ou la désactivation du leader d'un groupe active ou désactive la totalité du groupe. Autrement dit pendant que le leader de groupe est désactivé, aucun des compteurs du groupe ne compte. L'activation ou la désactivation d'un membre du groupe qui n'est pas le leader arrête ce son compteur, mais n'affecte aucun des autres compteurs.

Si le bit PERF_IOC_FLAG_GROUP est défini dans l’argument ioctl, alors tous les événements d’un groupe sont désactivés, même si l’événement indiqué n’est pas le leader de groupe (mais consultez la section BOGUES).

PERF_EVENT_IOC_REFRESH

Les compteurs de dépassements non hérités peuvent utiliser cela pour activer un compteur pour un nombre de dépassements indiqué par l'argument, après lequel il est désactivé. Les appels suivants de cet ioctl ajoutent la valeur de l'argument au décompte actuel. Un signal avec POLL_IN défini est envoyé à chaque dépassement jusqu'à ce que ce compte atteigne 0 ; quand cela arrive, un signal avec POLL_HUP défini est envoyé et l'événement est désactivé. L'utilisation de 0 comme argument est considéré comme un comportement indéfini.

PERF_EVENT_IOC_RESET

Redéfinir le compte d'événements indiqué par l'argument à zéro. Cela ne réinitialise que les décomptes ; réinitialiser les valeurs de multiplexage time_enabled et time_running est impossible.

Si le bit PERF_IOC_FLAG_GROUP est défini dans l’argument ioctl, alors tous les événements d’un groupe sont réinitialisés, même si l’événement indiqué n’est pas le leader de groupe (mais consultez la section BOGUES).

PERF_EVENT_IOC_PERIOD

Cela met à jour la période de dépassement pour l’événement.

Depuis Linux 3.7 (sur ARM) et Linux 3.14 (toutes les autres architectures), la nouvelle période est effective immédiatement. Sur les noyaux précédents, la nouvelle période n’était effective qu’après le dépassement suivant.

L'argument est un pointeur vers une valeur sur 64 bits contenant la nouvelle période voulue.

Avant Linux 2.6.36, cet ioctl échouait toujours à cause d’un bogue dans le noyau.

PERF_EVENT_IOC_SET_OUTPUT

Cela indique au noyau de signaler les notifications d'événement dans le descripteur de fichier indiqué plutôt que dans celui par défaut. Les descripteurs de fichier doivent tous être sur le même processeur.

L'argument indique le descripteur de fichier désiré ou -1 si la sortie devrait être ignorée.

PERF_EVENT_IOC_SET_FILTER (depuis Linux 2.6.33)

Cela ajoute un filtre ftrace à cet événement.

L'argument est un pointeur vers le filtre ftrace voulu.

PERF_EVENT_IOC_ID (depuis Linux 3.12)

Cela renvoie la valeur d’identifiant de l’événement pour le descripteur de fichier d’événement donné.

L'argument est un pointeur vers un entier non signé de 64 bits pour garder le résultat.

PERF_EVENT_IOC_SET_BPF (depuis Linux 4.1)

Cela permet de rattacher un programme Berkeley Packet Filter (BPF) à un événement de traçage d'un kprobe existant. Vous avez besoin des privilèges CAP_PERFMON (depuis Linux 5.8) ou CAP_SYS_ADMIN pour utiliser cet ioctl.

Le paramètre est un descripteur de fichier de programme BPF créé par un appel système bpf(2) précédent.

PERF_EVENT_IOC_PAUSE_OUTPUT (depuis Linux 4.7)

Cela permet de mettre en pause et de relancer le tampon circulaire d'un événement. Un tampon mis en pause n'empêche pas la génération d'échantillons mais il les désactive. Les échantillons désactivés sont considérés comme perdus et provoquent la génération d'un PERF_RECORD_LOST si possible. Un signal de dépassement peut toujours être récupéré par l'échantillon désactivé bien que le tampon circulaire reste vide.

Le paramètre est un entier 32 bits non signé. Une valeur autre que zéro met en pause le tampon circulaire alors qu'une valeur de zéro réactive le tampon circulaire.

PERF_EVENT_MODIFY_ATTRIBUTES (depuis Linux 4.17)

Cela permet de modifier un événement existant sans le gaspillage de fermeture et réouverture d’un nouvel événement. Actuellement, cela n'est pris en charge que pour les événements de points d'arrêt.

L'argument est un pointeur vers une structure perf_event_attr contenant les paramètres de l'événement mis à jour.

PERF_EVENT_IOC_QUERY_BPF (depuis Linux 4.16)

Cela permet de chercher les programmes Berkeley Packet Filter (BPF) rattachés à un point de traçage kprobe existant. Vous ne pouvez rattacher qu'un programme BPF par événement mais vous pouvez avoir plusieurs événements rattachés à un point de traçage. Rechercher cette valeur sur un événement de point de traçage renvoie l'identifiant de tous les programmes BPF dans tous les événements rattachés au point de traçage. Il vous faut les privilèges CAP_PERFMON (depuis Linux 5.8) ou CAP_SYS_ADMIN pour utiliser cet ioctl.

L'argument est un pointeur vers une structure

struct perf_event_query_bpf {
    __u32    ids_len;
    __u32    prog_cnt;
    __u32    ids[0];
};
    

Le champ ids_len indique le nombre d'identifiants pouvant entrer dans le tableau ids fourni. La valeur prog_cnt est remplie par le noyau avec le nombre de programmes BPF rattachés. Le tableau ids est rempli par l'identifiant de chaque programme BPF rattaché. S'il y a plus de programmes que de place dans le tableau, le noyau renverra ENOSPC et ids_len indiquera le nombre d'identifiants de programme copiés avec succès.

Utilisation_de_prctl(2)">Utilisation_de_prctl(2)">Utilisation de prctl(2)

Fichiers de configuration relatifs à perf_event

VALEUR RENVOYÉE

ERREURS

E2BIG

Renvoyé si la valeur size de perf_event_attr est trop petite (plus petite que PERF_ATTR_SIZE_VER0), trop grande (plus grande que la taille de page) ou plus grande que ce que le noyau peut gérer et que les octets supplémentaires ne sont pas zéro. Lorsque E2BIG est renvoyé, le champ size de perf_event_attr est remplacé, par le noyau, par la taille attendue de la structure.

EACCES

Renvoyé quand l’événement demandé nécessite les droits CAP_PERFMON (depuis Linux 5.8) ou CAP_SYS_ADMIN (ou un réglage paranoïaque de perf_event plus permissif). Quelques cas habituels où un processus non privilégié pourrait tomber sur cette erreur : l’attachement à un processus appartenant à un autre utilisateur, la surveillance de tous les processus sur un processeur donné (c’est-à-dire en indiquant -1 pour l’argument pid) et l’absence de réglage exclude_kernel quand le réglage paranoïaque le nécessite.

EBADF

Renvoyé si le descripteur de fichier group_fd n’est pas valable, ou, si PERF_FLAG_PID_CGROUP est défini, si le descripteur de fichier cgroup dans pid n’est pas valable.

EBUSY (depuis Linux 4.1)

Renvoyé si un événement a déjà un accès exclusif à la PMU.

EFAULT

Renvoyé si le pointeur attr pointe vers un adresse de mémoire non valable.

EINTR

Renvoyé si on essaie de mélanger la gestion de perf et de ftrace pour un uprobe.

EINVAL

Renvoyé si l’événement indiqué n’est pas valable. De nombreuse raisons sont possibles pour cela. Une liste non exhaustive : sample_freq est plus grand que le réglage maximal ; le cpu à surveiller n’existe pas ; read_format est hors intervalle ; sample_type est hors intervalle ; la valeur flags est hors intervalle ; exclusive ou pinned sont définis et l’événement n’est pas un leader de groupe ; les valeurs config de l’événement sont hors de l’intervalle ou des bits réservés définis ; l’événement générique sélectionné n’est pas pris en charge ; la place est insuffisante pour ajouter l’événement sélectionné.

EMFILE

Chaque événement ouvert utilise un descripteur de fichier. Si un grand nombre d’événements est ouvert, la limite de descripteurs de fichier par processus sera atteinte et aucun événement supplémentaire ne pourra être créé.

ENODEV

Renvoyé quand l’événement implique une fonctionnalité non prise en charge par le processeur actuel.

ENOENT

Renvoyé si le réglage type n’est pas valable. Cette erreur est également renvoyée pour certains événements génériques non pris en charge.

ENOSPC

Avant Linux 3.3, s'il manquait de la place pour l'événement, ENOSPC était renvoyé. Dans Linux 3.3, cela a été modifié en EINVAL. ENOSPC est toujours renvoyé en cas de tentative d’ajout de plus d’événements de point d'arrêt que permis par le matériel.

ENOSYS

Renvoyé si PERF_SAMPLE_STACK_USER est défini dans sample_type et que ce n’est pas pris en charge par le matériel.

EOPNOTSUPP

Renvoyé si un événement nécessitant une fonctionnalité spécifique du matériel est demandé alors qu’il n’y a pas de prise en charge matérielle. Cela comprend la demande d’événement à faible dérapage si ce n’est pas pris en charge, le suivi de branchement s’il n’est pas pris en charge, l’échantillonnage si aucune interruption PMU n’est disponible et les piles de branchement pour les événements logiciels.

EOVERFLOW (depuis Linux 4.8)

Renvoyé si PERF_SAMPLE_CALLCHAIN est demandé et si sample_max_stack est plus grand que le maximum indiqué dans /proc/sys/kernel/perf_event_max_stack.

EPERM

Renvoyé sur beaucoup d’architectures (mais pas toutes) quand un des réglages exclude_hv, exclude_idle, exclude_user ou exclude_kernel non pris en charge est indiqué.

Cela peut aussi arriver, comme avec EACCES, quand l’événement demandé nécessite les droits CAP_PERFMON (depuis Linux 5.8) ou CAP_SYS_ADMIN (ou un réglage paranoïaque de perf_event plus permissif). Cela comprend le réglage d’un point d'arrêt sur une adresse du noyau et (depuis Linux 3.13) le réglage d’un point de trace de fonction du noyau.

ESRCH

Renvoyé en cas de tentative d’attachement à un processus qui n’existe pas.

VERSIONS

STANDARDS

NOTES

BOGUES

EXEMPLES

#include <linux/perf_event.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/syscall.h>
#include <unistd.h>

static long
perf_event_open(struct perf_event_attr *hw_event, pid_t pid,
                int cpu, int group_fd, unsigned long flags)
{
    int ret;

    ret = syscall(SYS_perf_event_open, hw_event, pid, cpu,
                  group_fd, flags);
    return ret;
}

int
main(void)
{
    int                     fd;
    long long               count;
    struct perf_event_attr  pe;

    memset(&pe, 0, sizeof(pe));
    pe.type = PERF_TYPE_HARDWARE;
    pe.size = sizeof(pe);
    pe.config = PERF_COUNT_HW_INSTRUCTIONS;
    pe.disabled = 1;
    pe.exclude_kernel = 1;
    pe.exclude_hv = 1;

    fd = perf_event_open(&pe, 0, -1, -1, 0);
    if (fd == -1) {
       fprintf(stderr, "Erreur d'ouverture du leader %llx\n", pe.config);
       exit(EXIT_FAILURE);
    }

    ioctl(fd, PERF_EVENT_IOC_RESET, 0);
    ioctl(fd, PERF_EVENT_IOC_ENABLE, 0);

    printf("Mesure du décompte d'instructions pour ce printf\n");

    ioctl(fd, PERF_EVENT_IOC_DISABLE, 0);
    read(fd, &count, sizeof(count));

    printf("%lld instructions utilisées\n", count);

    close(fd);
}

VOIR AUSSI

TRADUCTION