IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

 C Discussion :

Comment en être sûr ?


Sujet :

C

  1. #1
    Membre habitué
    Homme Profil pro
    ingénieur calcul
    Inscrit en
    Décembre 2007
    Messages
    363
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 59
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : ingénieur calcul
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Décembre 2007
    Messages : 363
    Points : 180
    Points
    180
    Par défaut [résolu] Comment en être sûr ?
    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
    P.S. Dis Toto, pourquoi l'univers existe-t'il ?
    Je vais y réfléchir avec Morphée et lui dès avant 22h55, donc ici, il faut se causer avant.

  2. #2
    Expert éminent sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Points : 20 985
    Points
    20 985
    Par défaut
    Citation Envoyé par dva2tlse Voir le message
    [/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);
    Pas de Wi-Fi à la maison : CPL

  3. #3
    Membre habitué
    Homme Profil pro
    ingénieur calcul
    Inscrit en
    Décembre 2007
    Messages
    363
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 59
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : ingénieur calcul
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Décembre 2007
    Messages : 363
    Points : 180
    Points
    180
    Par défaut
    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.
    P.S. Dis Toto, pourquoi l'univers existe-t'il ?
    Je vais y réfléchir avec Morphée et lui dès avant 22h55, donc ici, il faut se causer avant.

  4. #4
    Expert éminent sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Points : 20 985
    Points
    20 985
    Par défaut
    Citation Envoyé par dva2tlse Voir le message
    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...
    Pas de Wi-Fi à la maison : CPL

  5. #5
    Membre habitué
    Homme Profil pro
    ingénieur calcul
    Inscrit en
    Décembre 2007
    Messages
    363
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 59
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : ingénieur calcul
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Décembre 2007
    Messages : 363
    Points : 180
    Points
    180
    Par défaut
    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);
    P.S. Dis Toto, pourquoi l'univers existe-t'il ?
    Je vais y réfléchir avec Morphée et lui dès avant 22h55, donc ici, il faut se causer avant.

  6. #6
    Membre émérite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Octobre 2008
    Messages
    1 515
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 45
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Octobre 2008
    Messages : 1 515
    Points : 2 505
    Points
    2 505
    Par défaut
    Citation Envoyé par Emmanuel Delahaye Voir le message
    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.

  7. #7
    Membre émérite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Octobre 2008
    Messages
    1 515
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 45
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Octobre 2008
    Messages : 1 515
    Points : 2 505
    Points
    2 505
    Par défaut
    Citation Envoyé par dva2tlse Voir le message
    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.

  8. #8
    Membre habitué
    Homme Profil pro
    ingénieur calcul
    Inscrit en
    Décembre 2007
    Messages
    363
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 59
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : ingénieur calcul
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Décembre 2007
    Messages : 363
    Points : 180
    Points
    180
    Par défaut
    non, je l'ai bien compilé en 64 bits avec le "cc" de la bécane, qui me donne ceci mais ça marche quand .même
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    $ cc cred.c -o cred                                         l
    "cred.c", line 4: warning: invalid white space character in directive
    "cred.c", line 5: warning: invalid white space character in directive
    "cred.c", line 5: warning: #include of /usr/include/... may be non-portable
    "cred.c", line 6: warning: invalid white space character in directive
    "cred.c", line 7: warning: invalid white space character in directive
    "cred.c", line 8: warning: invalid white space character in directive
    "cred.c", line 9: warning: invalid white space character in directive
    "cred.c", line 10: warning: invalid white space character in directive
    $
    alors que quand je compile avec gcc, qui doit être en 32 bits, il me signale des incongruités de longueur que j'ai retrouvé par chace parce que ce matin j'ai eu le temps de me renvoyer chez moi l'ensemble de ce que ça avait donné :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    $ gcc cred.c -o cred
    cred.c: In function `main':
    cred.c:25: warning: cast to pointer from integer of different size
    cred.c:53: warning: cast from pointer to integer of different size
    $
    Le cc que j'ai utilisé pour compiler mon code ne donne pas ce genre d'erreurs, alors que faire ?
    David (merci encore)
    P.S. Dis Toto, pourquoi l'univers existe-t'il ?
    Je vais y réfléchir avec Morphée et lui dès avant 22h55, donc ici, il faut se causer avant.

  9. #9
    Membre émérite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Octobre 2008
    Messages
    1 515
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 45
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Octobre 2008
    Messages : 1 515
    Points : 2 505
    Points
    2 505
    Par défaut
    Avec gcc il faut ajouter l'option -m64 pour compiler en 64 bits. Avec le cc de Solaris il y a certainement une option similaire. Je ne connais pas Solaris mais il est possible qu'il ne compile pas en 64 bits par défaut (sous AIX, xlc compile en 32 bits même sur archi 64 bits, même avec un kenrel 64 bits, et il faut ajouter -q64 pour compiler en 64 bits).

  10. #10
    Membre habitué
    Homme Profil pro
    ingénieur calcul
    Inscrit en
    Décembre 2007
    Messages
    363
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 59
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : ingénieur calcul
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Décembre 2007
    Messages : 363
    Points : 180
    Points
    180
    Par défaut
    Ok matafan, j'avais déjà essayé le -m64 avec gcc, mais il me répond que l'option n'est pas installée ou quelque chose du même genre qui m'a fait abandonner et essayer de repasser au cc de la machine en pensant qu'il ferait d'office une compilation en 64 bits; d'après ce que tu me dis il est possible que ce ne soit pas le cas, donc je vais essayer de trouver sur le net quelle option lui est nécessaire pour l'utiliser dès lundi matin, et si mes recherches font chou blanc j'essaierai de trouver du temps pour chercher au boulot directement sur la bécane.
    Merci encore (je me répète, mais tes affirmations me permettent d'avancer plutot que de tourner en rond comme je le ferais tout seul)
    David
    PS je n'ai rien encore trouvé (samedi 15h15) à propos de la compilation en 64 bits par le cc de sunOs, mais un post de HARDWARE.fr parle de sunOS 5.8 et de compilation 64 bits, y compris de lseek64 et aussi de fopen64, mais pas d'options spéciales à la compilation pour travailler en 64 bits; donc il me faut essayer le fopen64.
    PS2 un quart d'heure plus tard :
    GCC options Meaning
    gcc 32-bit code
    gcc -O3 Optimized 32-bit code
    gcc -O3 -mcpu=v9 Optimized 64-bit code

    CC options Meaning
    CC 32-bit code
    CC -O5 Optimized 32-bit code
    CC -O5 -xarch=v9 Optimized 64-bit code
    P.S. Dis Toto, pourquoi l'univers existe-t'il ?
    Je vais y réfléchir avec Morphée et lui dès avant 22h55, donc ici, il faut se causer avant.

  11. #11
    Membre habitué
    Homme Profil pro
    ingénieur calcul
    Inscrit en
    Décembre 2007
    Messages
    363
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 59
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : ingénieur calcul
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Décembre 2007
    Messages : 363
    Points : 180
    Points
    180
    Par défaut
    Bonsoir matafan, j'espère que tu vas passer par ici ce lundi soir parce que j'ai de nouvelles interrogations; mais avant elles, un petit point de ce que me donne mon code : après plusieurs essais, il semble que ni le lseek64 ni le open64 ne fonctionnent vraiment ou ne soient utiles; open64 est inconnu de ld mais pas d'erreur dans cc, et lseek64 ne change rien par rapport à lseek.
    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 -xarch=v9                                     
    "cred.c", line 13: warning: #include of /usr/include/... may be non-portable
    $ ./cred `ps -o user,pid,addr,args -p $$ |grep moi | awk '{print $3}'`
     
            Hello, cred !
     
    argv[1]           =3002ca51540 (%s)
    xadrstproc      =0x3002ca51540 (%s)
    adrstproc         =3299283899712 (%lld)
    adrstproc         =3299283899712 (%llu)
    adrstproc         =3002ca51540 (%llx)
    adrstproc         =3002ca51540 (%p)
      pstproc         =3002ca51540 (%p)
     
    Segmentation Fault(coredump)
    $
    Alors ce qui me plait c'est qu'enfin j'ai un pointeur vers un structure proc qui contient l'adresse passée en argument au tout début; et la "segmentation fault" se produit dans une des instructions suivantes puisque celle d'encore après est un printf que l'on ne voit pas.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    pstproc = (struct proc *)adrstproc;  // celle là marche
    printf("pstproc         =%p (%%p)\n\n", pstproc); // ici aussi, la dernière.
    printf("pstproc->p_exec=%llx\n", pstproc->p_exec); // gamelle ici; pourtant pstproc
    printf("pstproc->p_as=%llx\n", pstproc->p_as); // pointe vers une structure proc !
    //
    lseek(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.
    Il faut que je revérifie tout de même si lseek64 n'éviterait pas cette gamelle parce que je crois que je l'ai remplacé par lseek avant que ne se produise l'arrêt. Mais peut être y a-t'il une erreur évidente (mais pas pour moi) qui explique l'arrêt, et la verrais tu ?
    David
    P.S. Dis Toto, pourquoi l'univers existe-t'il ?
    Je vais y réfléchir avec Morphée et lui dès avant 22h55, donc ici, il faut se causer avant.

  12. #12
    Membre émérite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Octobre 2008
    Messages
    1 515
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 45
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Octobre 2008
    Messages : 1 515
    Points : 2 505
    Points
    2 505
    Par défaut
    Mais ta structure tu la lit dans le fichier /dev/kmem, ou tu déréférence simplement l'adresse qui vient du ps (dans ce cas c'est normal que ça segfault, rien ne te garenti qu'il y a quelque chose à cette adresse là pour ton processus) ? Met un peu plus de code parce que là on ne voit pas trop ce que tu fais.

    Pour ce qui est du seek, si tu es en 64 bits alors llseek sevrait être équivalent à lseek64. L'important c'est que l'offset de la fonction que tu utilises soit un entier 64 bits.

  13. #13
    Membre habitué
    Homme Profil pro
    ingénieur calcul
    Inscrit en
    Décembre 2007
    Messages
    363
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 59
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : ingénieur calcul
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Décembre 2007
    Messages : 363
    Points : 180
    Points
    180
    Par défaut
    Ok merci alors j'essaie de mettre un peu plus de code intéressant sans pour autant tout noyer sous les tonnes de printf que je mets pour essayer de tout suivre pas à pas.
    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
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    // cc cred.c -o cred -xarch=v9
    // ./cred `ps -o user,pid,addr,args -p $$ |grep st13277 | awk '{print $3}'`
    //
    #include "/local/patch/Solaris/8_Recommended/108528-29/SUNWhea/reloc/usr/include/sys/proc.h"
    #include "/usr/include/sys/cred.h"
    //
    #include <stdio.h>
    #include <stdlib.h>
    #include <sys/ptrace.h>
    #include <sys/types.h>
    #include <unistd.h>
    //
    main(int argc, char *argv[])
    {
        char xadrstproc[20];
        int kmem = open("/dev/kmem", "r+");
        long adrstproc;
        long adrstcred;
        //
        struct proc myproc, *pstproc;
        struct cred mycred, *pstcred;
        //
        printf("\n\tHello, cred !\n\n"); // S d'ouverture de /dev/kmem en open64. -> NAN
        //
        printf("\nargv[1]           =%s (%%s)\n", argv[1]); // ceci est l'argument ascii du prog.
        // essai de conversion en hexa de argv[1] :
        sprintf(xadrstproc, "0x%s", argv[1]); // ceci est la conversion de l'adresse ascii de la stucture proc.
        printf("xadrstproc      =%s (%%s)\n", xadrstproc); // ceci est l'argument ascii préfixé par 0x.
        adrstproc=strtol(xadrstproc, NULL, 0); // enfournage de la chaine ascii dans un (long) long.
        printf("adrstproc         =%lld (%%lld)\n", adrstproc); // ceci est l'adr. déci la stucture proc.
        printf("adrstproc         =%llu (%%llu)\n", adrstproc); // ceci est l'adresse u-s de la stucture proc.
        printf("adrstproc         =%llx (%%llx)\n", adrstproc); // ceci est l'adresse hexa de la stucture proc.
        printf("adrstproc         =%p (%%p)\n\n", (void *) adrstproc); // ceci est un ptr vers la stucture proc.
        //
        pstproc = (struct proc *)adrstproc; 
        printf("pstproc         =%p (%%p)\n\n", pstproc);
        printf("pstproc->p_exec=%llx\n", pstproc->p_exec);
        printf("pstproc->p_as=%llx\n", pstproc->p_as);
        //
        lseek(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);
        // et aussi ensuite :
        // printf("myproc.p_lockp    =%llu (%%llu)\n", myproc.p_lockp);
        // le  membre suivant ne m'intéresse pas non plus : kmutex_t p_crlock; /* lock for p_cred */
        //
        printf("myproc.p_cred     =%llu (%%llu)\n", myproc.p_cred); // ce cinquième membre de "proc"
        printf("myproc.p_cred     =%p (%%p)\n\n", (void *) myproc.p_cred); //  est un ptr vers "cred".
    Voilà, j'ai assez peu nettoyé finalement, mais ça me parait assez clair quand même; merci,
    David
    P.S. Dis Toto, pourquoi l'univers existe-t'il ?
    Je vais y réfléchir avec Morphée et lui dès avant 22h55, donc ici, il faut se causer avant.

  14. #14
    Membre habitué
    Homme Profil pro
    ingénieur calcul
    Inscrit en
    Décembre 2007
    Messages
    363
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 59
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : ingénieur calcul
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Décembre 2007
    Messages : 363
    Points : 180
    Points
    180
    Par défaut
    alors maintenant ta question :
    Je lis dans /dev/kmem, et je me sers de l'adresse que ps me donne, après confirmation que c'est de l'hexa par sprintf qui la préfixe par 0x; donc je me sers de cette adresse comme offset pour lseek.

    Le déréférencement simple, j'ai essayé mais ça ne marche pas.

    David
    P.S. Dis Toto, pourquoi l'univers existe-t'il ?
    Je vais y réfléchir avec Morphée et lui dès avant 22h55, donc ici, il faut se causer avant.

  15. #15
    Membre habitué
    Homme Profil pro
    ingénieur calcul
    Inscrit en
    Décembre 2007
    Messages
    363
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 59
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : ingénieur calcul
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Décembre 2007
    Messages : 363
    Points : 180
    Points
    180
    Par défaut
    Bonsoir matafan si tu passes par ici,
    j'espère que tu n'as pas perdu de temps avec la recherche de l'erreur dans le code que j'ai laissé dernièrement, parce qu'il n'y avait qu'une stupide (comme toujours une fois qu'on a trouvé) demande d'affichage de quelque chose qui n'était pas encore défini.
    J'ai utilisé llseek pour que la lecture se positionne au bon endroit dans kmem, et ce qui se passe est pourtant que je n'y ai pas encore accès :
    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
    $ cc cred.c -o cred -xarch=v9                                     
    "cred.c", line 13: warning: #include of /usr/include/... may be non-portable
    $ ./cred `ps -o user,pid,addr,args -p $$ |grep moi| awk '{print $3}'` 
     
            Hello, cred !
     
     
      argv[1]         =3002ca51540 (%s)
    0xadrstproc     =0x3002ca51540 (%s)
      adrstproc       =3002ca51540 (%llx)
      adrstproc       =3002ca51540 (%p)
      ptrstproc       =3002ca51540 (%p)
     
    myproc.p_exec     =0 (%llu)
    myproc.p_exec     =0 (%p)
    myproc.p_as       =0 (%llu)
    myproc.p_as       =0 (%p)
    myproc.p_cred     =0 (%llu)
    myproc.p_cred     =0 (%p)
     
    $
    Je laisse encore une fois le bout de code qui lit dans /dev/kmem en espérant que tu y verras matière à m'aider à avancer.
    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
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    // gcc cred.c -o cred
    // cc cred.c -o cred -xarch=v9
    // ./cred `ps -o user,pid,addr,args -p $$ |grep st13277 | awk '{print $3}'`
    // ./cred 30029089570
    //
    #include "/local/patch/Solaris/8_Recommended/108528-29/SUNWhea/reloc/usr/include/sys/proc.h"
    #include "/usr/include/sys/cred.h"
    //
    #include <stdio.h>
    #include <stdlib.h>
    #include <sys/ptrace.h>
    #include <sys/types.h>
    #include <unistd.h>
    //
    main(int argc, char *argv[])
    {
        char xadrstproc[20];
        int kmem = open("/dev/kmem", "r+");
        long adrstproc;
        long adrstcred;
        //
        struct proc myproc, *pstproc;
        struct cred mycred, *pstcred;
        // 
        printf("\n\tHello, cred !\n\n");
        //
        printf("\nargv[1]           =%s (%%s)\n", argv[1]); // ceci est l'argument ascii du prog.
        sprintf(xadrstproc, "0x%s", argv[1]); // ceci est la conversion de l'adresse ascii de la stucture proc.
        printf("xadrstproc      =%s (%%s)\n", xadrstproc); // ceci est l'argument ascii préfixé par 0x.
        adrstproc=strtol(xadrstproc, NULL, 0); // enfournage de la chaine ascii dans un (long) long.
        printf("adrstproc         =%lld (%%lld)\n", adrstproc); // ceci est l'adr. déci la stucture proc.
        printf("adrstproc         =%llu (%%llu)\n", adrstproc); // ceci est l'adresse u-s de la stucture proc.
        printf("adrstproc         =%llx (%%llx)\n", adrstproc); // ceci est l'adresse hexa de la stucture proc.
        printf("adrstproc         =%p (%%p)\n\n", (void *) adrstproc); // ceci est un ptr vers la stucture proc.
        //
        pstproc = (struct proc *)adrstproc; 
        printf("pstproc         =%p (%%p)\n\n", pstproc);
        printf("pstproc->p_exec=%llx\n", pstproc->p_exec);
        printf("pstproc->p_as=%llx\n", pstproc->p_as);
        //
        llseek(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);
        // et aussi ensuite :
        // printf("myproc.p_lockp    =%llu (%%llu)\n", myproc.p_lockp);
        // le  membre suivant ne m'intéresse pas non plus : kmutex_t p_crlock; /* lock for p_cred */
        //
        printf("myproc.p_cred     =%llu (%%llu)\n", myproc.p_cred); // ce cinquième membre de "proc"
        printf("myproc.p_cred     =%p (%%p)\n\n", (void *) myproc.p_cred); //  est un ptr vers "cred".
        printf("pstproc         =%p (%%p)\n\n", pstproc);
        //
        printf("pstproc->p_exec=%llx\n", pstproc->p_exec);
        printf("pstproc->p_as=%llx\n", pstproc->p_as);
        //
        printf("\n");
    }
    //
    // gcc cred.c -o cred
    // gcc cred.c -o cred -O3 -mcpu=v9
    // cc cred.c -o cred -O5 -xarch=v9
    // ./cred `ps -o user,pid,addr,args -p $$ |grep st13277 | awk '{print $3}'`
    Bon, alors encore une fois "au secours", comment pourrais-je lire dans cette satanée structure proc ?
    merci d'essayer de me répondre,
    David
    P.S. Dis Toto, pourquoi l'univers existe-t'il ?
    Je vais y réfléchir avec Morphée et lui dès avant 22h55, donc ici, il faut se causer avant.

  16. #16
    Membre émérite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Octobre 2008
    Messages
    1 515
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 45
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Octobre 2008
    Messages : 1 515
    Points : 2 505
    Points
    2 505
    Par défaut
    Il faudrait que tu test la valeur de retour du open et du read, peut-être qu'ils échouent. Sinon, c'est peut-être simplement que les infos que tu cherches ne sont pas dans /dev/kmem.

    Tu devrais aussi ouvrir un nouveau sujet en expliquant quelles infos tu cherches à obtenir. Peut-être que quelqu'un saura comment faire ça proprement.

  17. #17
    Membre habitué
    Homme Profil pro
    ingénieur calcul
    Inscrit en
    Décembre 2007
    Messages
    363
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 59
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : ingénieur calcul
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Décembre 2007
    Messages : 363
    Points : 180
    Points
    180
    Par défaut
    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.

    Citation Envoyé par Emmanuel Delahaye Voir le message
    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
    P.S. Dis Toto, pourquoi l'univers existe-t'il ?
    Je vais y réfléchir avec Morphée et lui dès avant 22h55, donc ici, il faut se causer avant.

  18. #18
    Expert éminent sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Points : 20 985
    Points
    20 985
    Par défaut
    Citation Envoyé par dva2tlse Voir le message
    je mets le sujet comme délesté,
    Attention, délesté, ça veut dire poubelle . Tu confirmes ou tu voulais dire résolu ?
    Pas de Wi-Fi à la maison : CPL

  19. #19
    Membre émérite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Octobre 2008
    Messages
    1 515
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 45
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Octobre 2008
    Messages : 1 515
    Points : 2 505
    Points
    2 505
    Par défaut
    Il faut bien sûr être root pour lire /dev/kmem.

  20. #20
    Membre habitué
    Homme Profil pro
    ingénieur calcul
    Inscrit en
    Décembre 2007
    Messages
    363
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 59
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : ingénieur calcul
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Décembre 2007
    Messages : 363
    Points : 180
    Points
    180
    Par défaut
    pour Émmanuel, en effet, je ne souhaite pas que ce sujet parte à la poub', mais cela est un peu incongru de marquer comme tel une histoire qui finit en cul-de-sac. Alors allons y quand même pour [résolu] bien que ça me gêne un peu.

    pour matafan, ben oui ! merci et bonsoir, et à bientôt pêut-être pour quand j'y verrai un peu plus clair dans ma tentative d'utilisation de ptrace et que je pourrai demander intelligemment de l'aide.
    David
    P.S. Dis Toto, pourquoi l'univers existe-t'il ?
    Je vais y réfléchir avec Morphée et lui dès avant 22h55, donc ici, il faut se causer avant.

+ Répondre à la discussion
Cette discussion est résolue.
Page 1 sur 2 12 DernièreDernière

Discussions similaires

  1. Réponses: 9
    Dernier message: 24/06/2008, 10h31
  2. En tant qu'étudiant, comment être rémuneré ?
    Par Bridou dans le forum Etudes
    Réponses: 12
    Dernier message: 29/11/2005, 09h03
  3. [CF][C#/PPC] Comment être à l'écouter d'une touche du clavier ?
    Par freddyboy dans le forum Windows Mobile
    Réponses: 6
    Dernier message: 18/05/2005, 17h32
  4. Comment être sure que mon appli prenne le focus ?
    Par AmaX dans le forum Composants VCL
    Réponses: 2
    Dernier message: 21/12/2002, 15h00

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo