Manuel de suivi dynamique Solaris

Arguments

Les types d'argument des sondes proc sont répertoriés dans le Tableau 25–2. Les arguments sont décrits dans le Tableau 25–1.

Tableau 25–2 Arguments de sonde proc


Sonder	`args[0]`	`args[1]`	`args[2]`
`create`	`psinfo_t *`	—	—
`exec`	`char *`	—	—
`exec-failure`	`int`	—	—
`exit`	`int`	—	—
`fault`	`int`	`siginfo_t *`	—
`lwp-create`	`lwpsinfo_t *`	`psinfo_t *`	—
`lwp-start`	—	—	—
`lwp-exit`	—	—	—
`signal-discard`	`lwpsinfo_t *`	`psinfo_t *`	`int`
`signal-discard`	`lwpsinfo_t *`	`psinfo_t *`	`int`
`signal-send`	`lwpsinfo_t *`	`psinfo_t *`	`int`
`signal-handle`	`int`	`siginfo_t *`	`void (*)(void)`
`signal-clear`	`int`	—	—
`start`	—	—	—

`lwpsinfo_t`

Plusieurs sondes proc comprennent des arguments du type lwpsinfo_t, structure abordée dans proc(4). La définition de la structure lwpsinfo_t, telle qu'accessible aux clients DTrace, est la suivante :

typedef struct lwpsinfo {
	int pr_flag;              /* flags; see below */
	id_t pr_lwpid;            /* LWP id */
	uintptr_t pr_addr;        /* internal address of thread */
	uintptr_t pr_wchan;       /* wait addr for sleeping thread */
	char pr_stype;            /* synchronization event type */
	char pr_state;            /* numeric thread state */
	char pr_sname;            /* printable character for pr_state */
	char pr_nice;             /* nice for cpu usage */
	short pr_syscall;         /* system call number (if in syscall) */
	int pr_pri;               /* priority, high value = high priority */
	char pr_clname[PRCLSZ];   /* scheduling class name */
	processorid_t pr_onpro;   /* processor which last ran this thread */
	processorid_t pr_bindpro; /* processor to which thread is bound */
	psetid_t pr_bindpset;     /* processor set to which thread is bound */
} lwpsinfo_t;

Le champ pr_flag est un masque contenant des indicateurs décrivant le processus. Ces indicateurs et leur signification sont décrits dans le Tableau 25–3.

Tableau 25–3 Valeurs de pr_flag


`PR_ISSYS`	Le processus est un processus système.
`PR_VFORKP`	Le processus est le parent d'un enfant vfork(2).
`PR_FORK`	Le processus est défini en mode d'héritage fork.
`PR_RLC`	Le processus est défini en mode d'exécution à la dernière fermeture.
`PR_KLC`	Le processus est défini en mode de destruction à la dernière fermeture.
`PR_ASYNC`	Le processus est défini en mode d'arrêt asynchrone.
`PR_MSACCT`	Le processus est activé en gestion microscopique.
`PR_MSFORK`	La gestion microscopique du processus est héritée de fork.
`PR_BPTADJ`	Le processus est défini en mode d'ajustement du point d'arrêt.
`PR_PTRACE`	Le processus est défini en mode de compatibilité ptrace(3C).
`PR_STOPPED`	Le thread est un LWP arrêté.
`PR_ISTOP`	Le thread est un LWP arrêté en cas d'événement intéressant.
`PR_DSTOP`	Le thread est un LWP disposant d'une directive d'arrêt en vigueur.
`PR_STEP`	Le thread est un LWP disposant d'une directive d'étape unique en vigueur.
`PR_ASLEEP`	Le thread est un LWP en sommeil interruptible dans un appel système.
`PR_DETACH`	Le thread est un LWP détaché. Reportez-vous aux pages Web de pthread_create(3C) et pthread_join(3C).
`PR_DAEMON`	Le thread est un LWP démon. Reportez-vous à la page Web de pthread_create(3C).
`PR_AGENT`	Le thread est le LWP agent du processus.
`PR_IDLE`	Le thread est un thread inactif pour une CPU. Les threads inactifs ne sont exécutés sur une CPU que lorsque les files d'attente d'exécution de la CPU sont vides.

Le champ pr_addr indique l'adresse d'une structure de données privée et du noyau représentant le thread. Alors que la structure de données est privée, le champ pr_addr peut être utilisé en tant que jeton unique pour déterminer la durée de vie d'un thread.

Le champ pr_wchan est défini lorsque le thread est en sommeil sur un objet de synchronisation. La signification du champ pr_wchan est spécifique à la mise en œuvre du noyau, mais le champ peut être utilisé en tant que jeton unique pour l'objet de synchronisation.

Le champ pr_stype est défini lorsque le thread est en sommeil sur un objet de synchronisation. Les valeurs possibles du champ pr_stype sont indiquées dans le Tableau 25–4.

Tableau 25–4 Valeurs de pr_stype


`SOBJ_MUTEX`	Objet de synchronisation mutex du noyau. Utilisé pour sérialiser l'accès aux zones de données partagées du noyau. Pour plus d'informations sur les objets de synchronisation mutex du noyau, reportez-vous au Chapitre18Fournisseur `lockstat` et à la page Web mutex_init(9F).
`SOBJ_RWLOCK`	Objet de synchronisation de lecture/écriture du noyau. Utilisé pour synchroniser l'accès aux objets partagés du noyau pouvant autoriser plusieurs lecteurs simultanés ou un seul rédacteur. Pour plus d'informations sur les objets de synchronisation de lecture/écriture du noyau, reportez-vous au Chapitre18Fournisseur `lockstat` et à la page Web rwlock(9F).
`SOBJ_CV`	Objet de synchronisation de variable de condition. Une variable de condition est conçue pour attendre indéfiniment jusqu'à ce qu'une condition soit vraie. Les variables de condition sont généralement utilisées pour synchroniser pour des raisons autres que l'accès à une zone de données partagées, et constituent le mécanisme généralement utilisé lorsqu'un processus attend indéfiniment un programme. Par exemple, un blocage dans poll(2), pause(2), wait(3C) et similaire.
`SOBJ_SEMA`	Objet de synchronisation de sémaphore. Objet de synchronisation universel qui, comme des objets de variable de condition, ne suit pas la notion de propriété. La propriété étant nécessaire pour mettre en œuvre l'héritage de la priorité dans le noyau Solaris, l'absence de propriété inhérente aux objets de sémaphore empêche leur totale utilisation. Pour plus d'informations, reportez-vous à la page Web semaphore(9F).
`SOBJ_USER`	Objet de synchronisation au niveau utilisateur. Tout blocage d'objets de synchronisation au niveau utilisateur est géré avec des objets de synchronisation `SOBJ_USER`. Les objets de synchronisation au niveau utilisateur incluent ceux créés avec mutex_init(3C), sema_init(3C), rwlock_init(3C), cond_init(3C) et leurs équivalents POSIX.
`SOBJ_USER_PI`	Objet de synchronisation au niveau utilisateur mettant en œuvre l'héritage de la priorité. Certains objets de synchronisation au niveau utilisateur suivant la propriété autorisent en outre l'héritage de la priorité. Par exemple, des objets mutex créés avec pthread_mutex_init(3C) peuvent servir à hériter la priorité via pthread_mutexattr_setprotocol(3C).
`SOBJ_SHUTTLE`	Objet de synchronisation d'accélération. Les objets d'accélération sont utilisés pour mettre en œuvre des portes. Pour plus d'informations, voir door_create(3DOOR).

Le champ pr_state est défini sur l'une des valeurs indiquées dans le Tableau 25–5. Le champ pr_sname est défini sur un caractère correspondant indiqué entre parenthèses dans le même tableau.

Tableau 25–5 Valeurs de pr_state


`SSLEEP` (`S`)	Le thread est au repos. La sonde `sched:::sleep` se déclenche immédiatement avant la transition de l'état d'un thread en `SSLEEP`.
`SRUN` (`R`)	Le thread peut être exécuté, mais ne l'est pas actuellement. La sonde `sched:::enqueue` se déclenche immédiatement avant la transition de l'état d'un thread en `SRUN`.
`SZOMB` (`Z`)	Le thread est un LWP zombie.
`SSTOP` (`T`)	Le thread est arrêté, en raison d'une directive proc(4) explicite ou d'un autre mécanisme d'arrêt.
`SIDL` (`I`)	Le thread se trouve dans un état intermédiaire lors de la création du processus.
`SONPROC` (`O`)	Le thread est exécuté sur une CPU. La sonde `sched:::on-cpu` se déclenche dans le cadre du thread `SONPROC` sur une courte durée après la transition de l'état du thread en `SONPROC`.

`psinfo_t`

Plusieurs sondes proc comprennent un argument du type psinfo_t, structure abordée dans proc(4). La définition de la structure psinfo_t, telle qu'accessible aux clients DTrace, est la suivante :

typedef struct psinfo {
	int     pr_nlwp;            /* number of active lwps in the process */
	pid_t   pr_pid;             /* unique process id */
	pid_t   pr_ppid;            /* process id of parent */
	pid_t   pr_pgid;            /* pid of process group leader */
	pid_t   pr_sid;             /* session id */
	uid_t   pr_uid;             /* real user id */
	uid_t   pr_euid;            /* effective user id */
	gid_t   pr_gid;             /* real group id */
	gid_t   pr_egid;            /* effective group id */
	uintptr_t pr_addr;          /* address of process */
	dev_t   pr_ttydev;          /* controlling tty device (or PRNODEV) */
	timestruc_t pr_start;       /* process start time, from the epoch */
	char    pr_fname[PRFNSZ];   /* name of execed file */
	char    pr_psargs[PRARGSZ]; /* initial characters of arg list */
	int     pr_argc;            /* initial argument count */
	uintptr_t pr_argv;          /* address of initial argument vector */
	uintptr_t pr_envp;          /* address of initial environment vector */
	char    pr_dmodel;          /* data model of the process */
	taskid_t pr_taskid;         /* task id */
	projid_t pr_projid;         /* project id */
	poolid_t pr_poolid;         /* pool id */
	zoneid_t pr_zoneid;         /* zone id */
} psinfo_t;

Le champ pr_dmodel est défini sur PR_MODEL_ILP32, représentant un processus 32 bits ou sur PR_MODEL_LP64, représentant un processus 64 bits.