Discussion :

[dva2tlse]

Bonsoir,
le problème qui se pose à moi concerne une machine SUN (sun fire 68000 sous sunOS 5.8) dont le processeur est un sparc 64 bits.
Je voudrais lire les termes d'un structure nommée proc, dont un exemplaire est attaché à chacun de mes process; prenons ma shell ksh par exemple.
Si dans ma shell je tape :
$ ps -o user,pid,addr,args -p $$
la machine me répond : (sachant que le $$ qui est passé en argument à ps est remplacé par le PID de ma shell)
USER PID ADDR CMD
moi 6914 30029089570 /bin/ksh
et le ADDR en question est l'adresse en mémoire de la structure proc qui m'intéresse.
Un utilisateur du forum (merci matafan) m'a indiqué d'aller lire le pseudo-device /dev/kmem avec l'offset en question pour y trouver la structure; c'est ce que j'essaye de faire de la façon suivante, mais comment être sûr que le résultat est bon ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
main(int argc, char *argv[])
{
    char xadrstproc[20];
    int kmem = open("/dev/kmem", "r+");
    long long adrstproc;
    struct proc myproc, *pstproc;
    printf("\nadrstproc         =%s (%%s)\n", argv[1]); // ceci est l'adresse ascii.
    // essai de conversion en hexa de argv[1] en la préfixant par "0x" :
    sprintf(xadrstproc, "0x%s", argv[1]); // ceci est la conversion de l'adresse ascii.
    printf("xadrstproc        =%s (%%s)\n", xadrstproc); // ceci est l'adresse ascii.
    adrstproc=strtol(xadrstproc, NULL, 0); // enfournage de la chaine ascii dans un long long.
    printf("adrstproc         =%lld (%%lld)\n", adrstproc); // ceci est l'adresse décimale.
    printf("adrstproc         =%llu (%%llu)\n", adrstproc); // ceci est l'adresse unsigned.
    printf("adrstproc         =%llx (%%llx)\n\n", adrstproc); // ceci est l'adresse hexa.
    //
    lseek64(kmem, adrstproc, SEEK_SET);  // ceci passe par /dev/kmem
    read(kmem, &myproc, sizeof myproc); // Et avec un peu de chance tu te retrouves
    //                                 // avec la structure proc de ton process dans myproc.
    // accès aux membres :
    printf("myproc.p_exec     =%llu (%%llu)\n" ,myproc.p_exec);
    printf("myproc.p_as       =%llu (%%llu)\n", myproc.p_as);
}

Le résultat que ça me donne est le suivant mais je ne sais pas quoi en penser; en particulier au début, la méthode de conversion de l'adresse que me donne ps, en un long long qui me sert d'offset est elle bonne : (faut il utiliser strtol ou strtoll, et quelle est la longueur d'un mot ?)

Code :

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

1
2
3
4
5
6
7
8
9
10
 ./cred `ps -o user,pid,addr,args -p $$ |grep st13277 | awk '{print $3}'`
 
adrstproc         =3003414caa0 (%s)
xadrstproc        =0x3003414caa0 (%s)
adrstproc         =2147483647 (%lld)
adrstproc         =2147483647 (%llu)
adrstproc         =7fffffff (%llx)
 
myproc.p_exec     =18428420643713188848 (%llu)
myproc.p_as       =18389270457723664980 (%llu)

Merci de m'avoir lu jusqu'ici et d'essayer de me donner des indications pour avancer,
David

[Emmanuel Delahaye]

[/CODE]
Le résultat que ça me donne est le suivant mais je ne sais pas quoi en penser; en particulier au début, la méthode de conversion de l'adresse que me donne ps, en un long long qui me sert d'offset est elle bonne : (faut il utiliser strtol ou strtoll, et quelle est la longueur d'un mot ?)

Code :

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

1
2
3
4
5
6
7
8
9
10
 ./cred `ps -o user,pid,addr,args -p $$ |grep st13277 | awk '{print $3}'`
 
adrstproc         =3003414caa0 (%s)
xadrstproc        =0x3003414caa0 (%s)
adrstproc         =2147483647 (%lld)
adrstproc         =2147483647 (%llu)
adrstproc         =7fffffff (%llx)
 
myproc.p_exec     =18428420643713188848 (%llu)
myproc.p_as       =18389270457723664980 (%llu)

Merci de m'avoir lu jusqu'ici et d'essayer de me donner des indications pour avancer,

La seule façon portable d'afficher une adresse correctement est d'utiliser "%p" avec (void*).

Code :

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

    printf("adrstproc = %p\n", (void *) adrstproc);

[dva2tlse]

Merci Émmanuel, ceci me permettra d'afficher la valeur de l'adresse une fois que j'en serai sûr, mais est-ce que la méthode que j'utilise pour l'obtenir à partir de la chaine ascii est bonne ?
J'ai `ps -o user,pid,addr,args -p $$ |grep st13277 | awk '{print $3}'` qui donne un longue chaine ascii, "3003414caa0", donc est-il judicieux de la préfixer par "0x" et de donner le tout en argument à strtol pour en faire un long long ? Et comme la machine est en 64 bits, faut-il fair strtol ou strtoll, et est-ce un long ou un long long ?
David (qui pose des questions terre-à-terre)
PS. C'est seulement après que je pourrai utiliser %p au lieu des diverses choses que je faisais. Merci.

[Emmanuel Delahaye]

Merci Émmanuel, ceci me permettra d'afficher la valeur de l'adresse une fois que j'en serai sûr, mais est-ce que la méthode que j'utilise pour l'obtenir à partir de la chaine ascii est bonne ?
J'ai `ps -o user,pid,addr,args -p $$ |grep st13277 | awk '{print $3}'` qui donne un longue chaine ascii, "3003414caa0", donc est-il judicieux de la préfixer par "0x" et de donner le tout en argument à strtol pour en faire un long long ? Et comme la machine est en 64 bits, faut-il fair strtol ou strtoll, et est-ce un long ou un long long ?
David (qui pose des questions terre-à-terre)
PS. C'est seulement après que je pourrai utiliser %p au lieu des diverses choses que je faisais. Merci.

En admettant que l'adresse puisse être représentée de la sorte et sa traduction en valeur numérique ait un sens, qui te dit que cette adresse est valide dans le contexte où tu veux l'utiliser ? Je ne sais pas trop ce que tu veux faire, mais en mode utilisateur, un processus n'a pas le droit d'accéder aux données d'un autre processus...

[dva2tlse]

Bonsoir Émmanuel,
il est bien évident que je ne cherche pas à modifier d'aucune façon un process appartenant à quelqu'un d'autre.
La structure proc qui m'intéresse est associée à une korn shell qui m'appartient À MOI, donc il n'y a pas de problèmes de droits, mais je vois maintenant que tu dis qu'"un processus n'a pas le droit d'accéder aux données d'un autre processus" et cela me dérange plus.
Cependant je veux essayer d'y accéder. (tel le St Thomas moyen, ce n'est que quand j'aurai VU que cette structure est illisible, que j'y croirais)
Merci de t'intéresser un peu à mon histoire et de m'avoir donné une piste d'exploration qui donne ceci :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
$ cc cred.c -o cred
$ ./cred `ps -o user,pid,addr,args -p $$ |grep st13277 | awk '{print $3}'`
 
argv[1]           =3003414caa0 (%s)
xadrstproc      =0x3003414caa0 (%s)
adrstproc         =2147483647 (%lld)
adrstproc         =2147483647 (%llu)
adrstproc         =7fffffff (%llx)
adrstproc         =7fffffff (%p)
 
myproc.p_exec     =18428420643713188848 (%llu)
myproc.p_exec     =ffbee6f0 (%p)
myproc.p_as       =18389270457723664980 (%llu)
myproc.p_as       =ff33d00c (%p)
myproc.p_cred     =18392125219406101076 (%llu)
myproc.p_cred     =ff3df470 (%p)

J'ai essayé le cast (void *) avec %p pour afficher les pointeurs, mais il semble n'afficher que du 32 bits alors que les entiers que j'affiche par ailleurs semblent être sur 64 bits; y aurait-il 32 autres bits de poids plus fort qui se cachent quelquepart ?
Mais avant tout, c'est bien ma shell qui donne l'adresse de sa propre structure proc, donc un process fils pourrait quand même bien aller y lire; j'essaye de reproduire le boulot d'un collègue qui y est bien arrivé.
Bon, ça n'avance pas tellement, mais j'ai au moins la satisfaction d'avoir un problème à régler, ce qui n'est pas souvent le cas dans ce même boulot que je fais depuis plus de dix-huit ans.
David
PS: les différents membres de myproc semblent appartenir à une structure myproc que j'ai eue de la façon suivante :

Code :

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

1
2
3
4
5
6
7
8
    lseek64(kmem, adrstproc, SEEK_SET);  // ceci passe par /dev/kmem
    read(kmem, &myproc, sizeof myproc); // Et avec un peu de chance tu te retrouves avec
    //                                 // la structure proc de ton process dans myproc.
    // accès aux membres :
    printf("myproc.p_exec     =%llu (%%llu)\n", myproc.p_exec);
    printf("myproc.p_exec     =%p (%%p)\n", (void *) myproc.p_exec);
    printf("myproc.p_as       =%llu (%%llu)\n", myproc.p_as);
    printf("myproc.p_as       =%p (%%p)\n", (void *) myproc.p_as);

[matafan]

J'ai essayé le cast (void *) avec %p pour afficher les pointeurs, mais il semble n'afficher que du 32 bits alors que les entiers que j'affiche par ailleurs semblent être sur 64 bits; y aurait-il 32 autres bits de poids plus fort qui se cachent quelquepart ?

C'est probablement parce que tu as compilé ton programme en 32 bits. Je t'avais bien dit de compiler ton programme en 64 bits ! Si tu compiles ton programme en 32 bits, non seulement %p ne va t'afficher ce qu'il faut (ça ce n'est pas grave), mais surtout tu va aller lire les différents champs aux mauvais offset.

[matafan]

En admettant que l'adresse puisse être représentée de la sorte et sa traduction en valeur numérique ait un sens, qui te dit que cette adresse est valide dans le contexte où tu veux l'utiliser ? Je ne sais pas trop ce que tu veux faire, mais en mode utilisateur, un processus n'a pas le droit d'accéder aux données d'un autre processus...

Ce qu'il fait ce n'est pas simplement aller lire à l'adresse indiquée. Il va lire le fichier /dev/kmem à l'offset qu'il a récupéré dans la sortie du ps.

[dva2tlse]

Alors pour ceux qui suivent un peu mon histoire (ou qui tombent ici par hasard), j'ai eu la riche idée aujourd'hui au boulot de mettre des tests d'erreur par ci par là, accompagnés de perror, et ça me dit "permission denied" pour le open(/dev/kmem... ), ce qui n'a pas grand chose d'étonnant vu que la mémoire doit bien contenir certaines choses sur lesquelles je n'ai pas droit de regard; et par suite, le llseek me dit "bad formed number" à propos du descripteur de fichier puisque le open n'a pas abouti.

mais en mode utilisateur, un processus n'a pas le droit d'accéder aux données d'un autre processus...

Tu n'étais pas loin du compte.

Ceci dit, je ne rends pas les armes, et je vais faire quelques essais sur mon linux avec mon fils qui est là ce soir, et qui apprendra à cette occasion qu'il peut y avoir des pères et des fils ici aussi, puisque je compte essayer d'utiliser ptrace(PTRACE_PEEK... ) pour essayer de reconnaitre ma structure proc; je mets le sujet comme délesté, mais si jamais quiconque sait comment acceder uniquement à la mémoire qui est ma mienne, merci de me MP.
Bonsoir et merci à matafan et Émmanuel qui m'ont appris plusieurs choses donc ce fil n'aura pas été totalement inutile.
David

[Emmanuel Delahaye]

je mets le sujet comme délesté,

Attention, délesté, ça veut dire poubelle . Tu confirmes ou tu voulais dire résolu ?