Handbuch zur dynamischen Ablaufverfolgung in Solaris

Argumente

Die Argumenttypen für proc-Prüfpunkte sind in Tabelle 25–2 aufgeführt. In Tabelle 25–1 finden Sie eine Beschreibung der Argumente.

Tabelle 25–2 Argumente für proc-Prüfpunkte


Prüfpunkt	`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`

Einige proc-Prüfpunkte besitzen Argumente des Typs lwpsinfo_t, wobei es sich um eine in proc(4) dokumentierte Struktur handelt. Die Definition der den DTrace-Verbrauchern zur Verfügung stehenden Struktur lwpsinfo_t lautet:

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;

Das Feld pr_flag ist eine Bit-Maske, die den Prozess beschreibende Flags enthält. Diese Flags und ihre Bedeutung sind in Tabelle 25–3 beschrieben.

Tabelle 25–3 pr_flag-Werte


`PR_ISSYS`	Der Prozess ist ein Systemprozess.
`PR_VFORKP`	Der Prozess ist der übergeordnete Prozess eines vfork(2)-Unterprozesses.
`PR_FORK`	Der Modus inherit-on-fork des Prozesses ist gesetzt.
`PR_RLC`	Der Modus run-on-last-close des Prozesses ist gesetzt.
`PR_KLC`	Der Modus kill-on-last-close des Prozesses ist gesetzt.
`PR_ASYNC`	Der Modus asynchronous-stop des Prozesses ist gesetzt.
`PR_MSACCT`	Die Mikrostatusabrechnung (microstate accounting) ist im Prozess aktiviert.
`PR_MSFORK`	Die Mikrostatusabrechnung des Prozesses wird bei fork vererbt.
`PR_BPTADJ`	Der Modus breakpoint-adjustment des Prozesses ist gesetzt.
`PR_PTRACE`	Der Modus ptrace(3C)-compatibility des Prozesses ist gesetzt.
`PR_STOPPED`	Der Thread ist ein angehaltener LWP.
`PR_ISTOP`	Der Thread ist ein an einem Ereignis von Interesse angehaltener LWP.
`PR_DSTOP`	Der Thread ist ein LWP, für den eine stop-Direktive in Kraft ist.
`PR_STEP`	Der Thread ist ein LWP, für den eine single-step-Direktive in Kraft ist.
`PR_ASLEEP`	Der Thread ist ein LWP in unterbrechbarem Schlafzustand innerhalb eines Systemaufrufs.
`PR_DETACH`	Der Thread ist ein gesonderter LWP. Informationen hierzu finden Sie unter pthread_create(3C) und pthread_join(3C).
`PR_DAEMON`	Der Thread ist ein Dämon-LWP. Siehe hierzu pthread_create(3C).
`PR_AGENT`	Der Thread ist der Agent-LWP für den Prozess.
`PR_IDLE`	Der Thread ist der Leerlauf-Thread für eine CPU. Es laufen nur dann Leerlauf-Threads auf einer CPU, wenn die Ausführungswarteschlangen für die CPU leer sind.

Das Feld pr_addr ist die Adresse einer privaten Datenstruktur im Kernel, die den Thread darstellt. Die Datenstruktur ist privat, aber das Feld pr_addr kann für die gesamte Lebensdauer eines Threads als eindeutiges Symbol für diesen verwendet werden.

Das Feld pr_wchan wird gesetzt, wenn sich der Thread an einem Synchronisierungsobjekt schlafen legt. Die Bedeutung des Felds pr_wchan ist der Kernel-Implementierung vorbehalten, aber das Feld kann als eindeutiges Symbol für das Synchronisierungsobjekt verwendet werden.

Das Feld pr_stype wird gesetzt, wenn sich der Thread an einem Synchronisierungsobjekt schlafen legt. Die möglichen Werte für das Feld pr_stype sehen Sie in Tabelle 25–4.

Tabelle 25–4 pr_stype-Werte


`SOBJ_MUTEX`	Mutex-Synchronisierungsobjekt für Kernel. Dient zur Serialisierung des Zugriffs auf gemeinsame Datenbereiche im Kernel. In Kapitel 18Der Provider `lockstat` und mutex_init(9F) finden Sie ausführliche Informationen zu Mutex-Synchronisierungsobjekten für den Kernel.
`SOBJ_RWLOCK`	Leser/Schreiber-Synchronisierungsobjekt für Kernel. Dient zum Synchronisieren des Zugriffs auf gemeinsame Objekte im Kernel, die mehrere Leser gleichzeitig oder einen einzigen Schreiber zulassen können. In ·Kapitel 18Der Provider `lockstat` und rwlock(9F) finden Sie ausführliche Informationen zu Leser/Schreiber-Synchronisierungsobjekten für den Kernel.
`SOBJ_CV`	Bedingungsvariablen-Synchronisierungsobjekt. Eine Bedingungsvariable ist darauf ausgerichtet, auf unbestimmte Zeit darauf zu warten, dass eine bestimmte Bedingung eintritt. Bedingungsvariablen dienen in der Regel zum Synchronisieren anderer Vorgänge als den Zugriffen auf gemeinsame Datenbereiche und stellen den Mechanismus dar, der allgemein verwendet wird, wenn ein Prozess einen programmgesteuerten Wartezustand auf unbestimmte Zeit annimmt. Dabei handelt es sich beispielsweise um das Blockieren in poll(2), pause(2), wait(3C) usw.
`SOBJ_SEMA`	Semaphoren-Synchronisierungsobjekt. Ein Allzweck-Synchronisierungsobjekt, das, wie auch Bedingungsvariablenobjekte, keinen Besitz kennt. Da der Aspekt des Besitzes zum Implementieren der Prioritätsvererbung im Solaris-Kernel erforderlich ist, verbietet das Fehlen dieses Aspekts in Semaphorenobjekten eine weite Verbreitung dieser Objekte. Ausführliche Informationen finden Sie im Abschnitt semaphore(9F).
`SOBJ_USER`	Ein Synchronisierungsobjekt auf Benutzerebene Sämtliche Blockierungen von Synchronisierungsobjekten auf Benutzerebene werden mit `SOBJ_USER`-Synchronisierungsobjekten behandelt. Zu den Synchronisierungsobjekten auf Benutzerebene gehören die mit mutex_init(3C), sema_init(3C), rwlock_init(3C), cond_init(3C) und deren POSIX-Pendants erzeugten Objekte.
`SOBJ_USER_PI`	Ein Synchronisierungsobjekt auf Benutzerebene, das die Prioritätsvererbung implementiert. Einige Synchronisierungsobjekte auf Benutzerebene, die zusätzliche Benutzerinformationen bieten, ermöglichen die Prioritätsvererbung. So kann beispielsweise für Mutex-Objekte, die mit pthread_mutex_init(3C) erzeugt wurden, anhand von pthread_mutexattr_setprotocol(3C) die Prioritätsvererbung erreicht werden.
`SOBJ_SHUTTLE`	Ein Shuttle-Synchronisierungsobjekt Shuttle-Objekte dienen zum Implementieren von Doors. Näheres hierzu siehe door_create(3DOOR).

Das Feld pr_state wird auf einen der Werte in Tabelle 25–5 gesetzt. In Klammern sehen Sie das entsprechende Zeichen, auf das das Feld pr_sname gesetzt wird.

Tabelle 25–5 pr_state-Werte


`SSLEEP` (`S`)	Der Thread schläft. Der Prüfpunkt `sched:::sleep` wird ausgelöst, unmittelbar bevor der Status eines Threads in `SSLEEP` übergeht.
`SRUN` (`R`)	Der Thread ist lauffähig, läuft aber derzeit nicht. Der Prüfpunkt `sched:::enqueue` wird ausgelöst, unmittelbar bevor der Status eines Threads in `SRUN` übergeht.
`SZOMB` (`Z`)	Der Thread ist ein Zombie-LWP.
`SSTOP` (`T`)	Der Thread wurde entweder durch eine explizite proc(4)-Direktive oder einen anderen Anhaltemechanismus angehalten.
`SIDL` (`I`)	Der Thread befindet sich in einem Zwischenstatus der Prozesserzeugung.
`SONPROC` (`O`)	Der Thread läuft auf einer CPU. Der Prüfpunkt `sched:::on-cpu` wird im Kontext des `SONPROC`-Threads kurz nach dem Übergang des Thread-Status in `SONPROC` ausgelöst.

`psinfo_t`

Einige proc-Prüfpunkte besitzen ein Argument des Typs psinfo_t, wobei es sich um eine in proc(4) dokumentierte Struktur handelt. Die den DTrace-Verbrauchern zur Verfügung stehende Definition der Struktur psinfo_t lautet:

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;

Das Feld pr_dmodel wird entweder auf PR_MODEL_ILP32 (bezeichnet einen 32-Bit-Prozess) oder auf PR_MODEL_LP64 (bezeichnet einen 64-Bit-Prozess) gesetzt.