Sécurité du pointeur

Si vous êtes un programmeur C ou C++, vous pouvez être quelque peu inquiet après avoir lu la section précédente car vous savez qu'une mauvaise utilisation de pointeurs dans vos programmes peut entraîner leur panne. DTrace est un environnement puissant et sécurisé permettant d'exécuter vos programmes D là où des erreurs ne peuvent pas entraîner de panne des programmes. Vous pouvez en effet rédiger un programme D avec bogue, mais les accès d'un pointeur D non valide n'entraîneront pas une défaillance ou une panne de DTrace ou du noyau du système d'exploitation. Le logiciel DTrace détectera plutôt tous les accès de pointeur non valides, désactivera votre instrumentation, et vous signalera le problème pour débogage.

Si vous avez programmé en langage Java, vous savez probablement que ce langage ne prend pas en charge les pointeurs pour ces mêmes raisons de sécurité. Des pointeurs sont nécessaires dans D car ils font intrinsèquement partie de la mise en œuvre du système d'exploitation dans C, mais DTrace met en œuvre le même type de mécanisme de sécurité rencontré dans le langage de programmation Java empêchant une détérioration des programmes avec bogue eux-mêmes ou les uns par rapport aux autres. Les rapports d'erreurs DTrace sont similaires à l'environnement d'exécution du langage de programmation Java qui détecte une erreur de programmation et qui vous signale une exception.

Pour consulter la gestion et les rapports d'erreurs DTrace, rédigez un programme D incorrect utilisant des pointeurs. Dans un éditeur, entrez le programme D suivant et enregistrez-le sous un fichier nommé badptr.d :

Exemple 5–1 badptr.d : démonstration de la gestion d'erreurs DTrace

BEGIN
{
	x = (int *)NULL;
	y = *x;
	trace(y);
}

Le programme badptr.d crée un pointeur D nommé x qui pointe sur int. Le programme assigne à ce pointeur la valeur spéciale de pointeur non valide NULL, qui est un alias intégré pour l'adresse 0. Par convention, l'adresse 0 est toujours définie comme non valide, de façon à ce que NULL soit utilisé en tant valeur sentinelle dans les programmes en langages C et D. Le programme utilise une expression de forçage de type pour convertir NULL en pointeur sur un entier. Le programme déréférence alors le pointeur à l'aide de l'expression *x et attribue le résultat à une autre variable y, puis tente de suivre y. Une fois le programme D exécuté, DTrace détecte un accès de pointeur non valide lorsque l'instruction y = *x est exécutée et signale l'erreur suivante :

# dtrace -s badptr.d
dtrace: script '/dev/stdin' matched 1 probe
CPU     ID                    FUNCTION:NAME
dtrace: error on enabled probe ID 1 (ID 1: dtrace:::BEGIN): invalid address
(0x0) in action #2 at DIF offset 4
dtrace: 1 error on CPU 0
^C
#

L'autre problème pouvant survenir des programmes utilisant des pointeurs non valides est une erreur d'alignement. Par convention architecturale, des objets de données fondamentaux comme des entiers sont alignés dans la mémoire en fonction de leur taille. Par exemple, des entiers 2 octets sont alignés sur des adresses qui sont des multiples d'entiers 2, 4 octets par multiples de 4, etc. Si vous déréférencez un pointeur sur un entier 4 octets et que votre adresse de pointeur est une valeur non valide autre qu'un multiple de 4, votre accès échouera et renverra une erreur d'alignement. Les erreurs d'alignement dans D indiquent quasiment toujours que votre pointeur comporte une valeur non valide ou corrompue en raison d'un bogue dans votre programme D. Vous pouvez créer un exemple d'erreur d'alignement en changeant le code source de badptr.d pour utiliser l'adresse (int *)2 plutôt que NULL. int étant de 4 octets et 2 n'étant pas un multiple de 4, l'expression *x entraîne une erreur d'alignement DTrace.

Pour plus d'informations sur le mécanisme d'erreur DTrace, reportez-vous à la section Sonde ERROR.