Discussion :

[MrPacane]

Bonjour,

Je dois déterminer approximativement les adresses limites du segment stack dans la mémoire virtuelle d'un processus. Voici ce que j'ai tenté de faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
char *debut = alloca(1); // allocation d'un octet sur le stack
char *fin = debut;
 
while (alloca(1) != NULL) // on répète tant qu'il reste de l'espace
fin--; // le segment stack grossit vers le bas alors on décrémente
 
printf("Début du stack: %p", debut);
printf("Fin du stack: %p", fin);

Malheureusement, j'obtiens toujours une "segmentation fault", comme si je dépassais les limites... Des idées?

Merci à l'avance pour votre aide !

[phi1981]

Je ne sais pas précisément pourquoi ça plante, mais ce qui est certain c'est qu'appeler printf() utilise la stack, donc si tu n'as plus de stack disponible tu ne peux meme pas l'appeler.

Sous Unix, getrlimit() peut t'aider à récupérer cette information je pense.

[MrPacane]

Je ne sais pas précisément pourquoi ça plante, mais ce qui est certain c'est qu'appeler printf() utilise la stack, donc si tu n'as plus de stack disponible tu ne peux meme pas l'appeler.

Je n'avais pas pensé à ça! Tu as raison, c'est probablement printf() qui fait planter mon programme... Je vais essayer de copier *fin puis utiliser free() pour faire un peu d'espace sur le stack.

Sous Unix, getrlimit() peut t'aider à récupérer cette information je pense.

J'essaie de le faire sans utiliser getrlimit().

[phi1981]

alloca() et free() n'ont rien à voir !!
pour libérer la mémoire allouée par alloca, tu dois simplement sortir du bloc.

la doc d'alloca dit explicitement que si tu causes un stack overflow, le résultat est indéterminé. ça peut être fun à faire, mais j'espère que tu comptes pas utiliser ce code en production.

[MrPacane]

alloca() et free() n'ont rien à voir !!
pour libérer la mémoire allouée par alloca, tu dois simplement sortir du bloc.

Donc quelque chose comme ça devrait fonctionner?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
char *depart = alloca(1);
char *fin = depart;
 
if (fin != NULL)
{
while (alloca(1) != NULL)
fin--;
}
 
printf("Fin du stack : %p", fin);

Autrement dit, à l'extérieur du if() l'espace alloué par alloca() est libéré?

la doc d'alloca dit explicitement que si tu causes un stack overflow, le résultat est indéterminé. ça peut être fun à faire, mais j'espère que tu comptes pas utiliser ce code en production.

Non, simple exercice !

[Médinoc]

J'ignore si alloca() est libéré en fin de bloc ou de fonction; tu devras peut-être faire une fonction pour lire, qui retournerait sa valeur.

De plus, évite de compter simplement les allocations, à cause des histoires d'alignement.

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void compter_memoire(void **ppDepart, void **ppFin)
{
	void *pAlloc;
	*ppDepart = &ppFin;
	while((pAlloc=alloca(1)) != NULL)
		*ppFin = pAlloc;
}
 
void test_memoire()
{
	void *pDepart;
	void *pFin;
	compter_memoire(&pDepart, &pFin);
	printf("Fin du stack : %p", pFin);
}

[MrPacane]

Le while() ne termine jamais...

Je ne crois pas qu'on puisse mettre alloca() dans une condition car lorsque la fonction ne réussit pas, son comportement est indéterminé...

The alloca() function returns a pointer to the beginning of the allocated space. If the allocation causes stack overflow, program behavior is undefined.

http://www.kernel.org/doc/man-pages/.../alloca.3.html

[Celelibi]

Faire du alloca jusqu'à plus soif est définitivement une très mauvaise idée. Sous Linux, ton processus va être simplement killé dès que tu vas taper la limite. alloca ne renvoi jamais NULL.

Quitte à être non portable, tu peux essayer de taper dans /proc/self/maps et trouver la ligne [stack].
Cela dit, il est probable que Linux t'alloue une ou plusieurs pages mémoire supplémentaires quand tu atteints la limite.
T'as aussi /proc/self/limits qui contient directement les mêmes informations que getrlimit.

Si tu tiens vraiment à jouer avec alloca, il va falloir mettre un handler sur le SIGSEGV et définir une stack séparée pour le gérer (puisque t'as plus de place sur la stack de base).

Moi ce que je me demande, c'est pourquoi tu as besoin de déterminer les limites de la stack ?