Qu'est-ce que c'est que la mémoire kernel ? (ou virtuelle)

Version imprimable

09/12/2008, 17h01
dva2tlse

Qu'est-ce que c'est que la mémoire kernel ? (ou virtuelle)

Bonjour,
ma question concerne une machine sun fire 68000 sous sunOS 5.8; je voudrais savoir comment faire pour convertir une adresse kernel virtuelle qui vaut ADDR en une adresse physique que je note addr.

Et ensuite, comment faire pour voir, en C, ce que contient cette case mémoire ?

Selon ce que je sais du contenu de la case mémoire, et éventuellement des suivantes, je compte utiliser un des pointeurs suivants :
int *pint;
float *pfloat;
long *plong;
long long *pll;

Mais comment faire pour donner au pointeur que j'utilise la valeur addr précédemment déterminée ?
Suffit il de faire (par exemple) pfloat=addr;

Et ensuite pour le déréférencer et voir le contenu de addr, puis je faire ceci :
printf("addr vaut %d et contient %f.\n", addr, *pfloat);

Ça fait plein de questions dans un seul post, mais je suis vraiment bloqué à ce niveau de débutant,
merci de m'aider,
David
09/12/2008, 18h43
Emmanuel Delahaye
Citation:

Envoyé par dva2tlse

ma question concerne une machine sun fire 68000 sous sunOS 5.8; je voudrais savoir comment faire pour convertir une adresse kernel virtuelle qui vaut ADDR en une adresse physique que je note addr.

Ce n'est absolument pas une question de langage C, mais de programmation système sous ton OS particulier.

http://www.developpez.net/forums/f55...tres-systemes/

Citation:

Et ensuite, comment faire pour voir, en C, ce que contient cette case mémoire ?

Si il s'agit d'une adresse, elle doit être dans un pointeur. On utilise alors printf() avec "%p" et le cast (void *)

Exemple :
Code:

1 2 3 4 5 6 7 8 9 10 #include <stdio.h> int main (void) { int x; int *p = &x; printf ("p = %p\n", (void *) p); return 0; }
Code:

1 2 3 4 p = 0022FF44 Process returned 0 (0x0) execution time : 0.033 s Press any key to continue.
Citation:

Selon ce que je sais du contenu de la case mémoire, et éventuellement des suivantes, je compte utiliser un des pointeurs suivants :
int *pint;
float *pfloat;
long *plong;
long long *pll;

Mais comment faire pour donner au pointeur que j'utilise la valeur addr précédemment déterminée ?
Suffit il de faire (par exemple) pfloat=addr;

Cette manière d'initialiser un pointeur ne fait pas partie des manières décrites par le langage C. Le comportement est donc indéfini.

Ce peut être techniquement possible, mais rien ne dit que le résultat sera valide. Je n'ai pas bien compris ce que tu cherches à faire, mais les OS modernes interdisent à un processus d'accéder aux données d'un autre processus.

Citation:

Et ensuite pour le déréférencer et voir le contenu de addr, puis je faire ceci :

Code:

printf("addr vaut %d et contient %f.\n", addr, *pfloat);

Code:

printf("addr vaut %p et contient %f.\n", (void *) pfloat, *pfloat);

mais sans aucune garantie de fonctionnement, notamment si la valeur de addr appartient à un autre processus...
09/12/2008, 19h48
dva2tlse

Merci Émmanuel,
je devine que tu penses à un autre post que j'ai fait, où il est effectivement question de plusieurs processus dont j'aimerais que l'un d'entre eux puisse lire certaines donnés d'un autre, et même si possible les modifier.
Cependant ici je voudrais juste combler partiellement mes assez profondes lacunes en C, mais ta réponse ne m'éclaire pas sur les choses suivantes :

Citation:

"Cette manière d'initialiser un pointeur ne fait pas partie des manières décrites par le langage C. Le comportement est donc indéfini."

Comment faut-il donc faire pour initialiser un pointeur à une valeur qu'on veut lui imposer ?
David
PS: je vais effectivement me tourner vers le forum Solaris pour ma question qui ne concerne pas exactement Solaris.
09/12/2008, 20h06
Emmanuel Delahaye
Citation:

Envoyé par dva2tlse

je devine que tu penses à un autre post que j'ai fait,<...>

Je ne sais pas. Je réponds sur plusieurs forums et je ne lis pas les pseudos. je ne lis que la question. De plus je n'ai aucune mémoire, pour ça ...

Citation:

Comment faut-il donc faire pour initialiser un pointeur à une valeur qu'on veut lui imposer ?

Ca dépend de l'implémentation. Lire la doc de ton compilateur.

Souvent, ceci fonctionne :
Code:

1 2 T *p = (T*) 12345;
Evidemment, il faut que 12345 soit un entier qui représente une adresse valide du processus courant. Si ce n'est pas le cas, le comportement est indéterminé.

En principe, on a pas à faire ce genre de manip (et tout est fait coté système, pour la rendre caduque...). Je ne comprends toujours pas ce que tu veux faire, et je crois que tu n'as toujours compris qu'on ne pouvait pas accéder aux données d'un autre processus.
10/12/2008, 10h02
matafan

Citation:

Envoyé par dva2tlse

Merci Émmanuel,
je devine que tu penses à un autre post que j'ai fait, où il est effectivement question de plusieurs processus dont j'aimerais que l'un d'entre eux puisse lire certaines donnés d'un autre, et même si possible les modifier.

Tu cherches à faire quoi exactement ? Si tu veux que des données soient accessibles à deux processus, la bonne solution est de les placer en mémoire partagée.

Maintenant, si tu veux depuis un processus A accéder à n'importe quelle donnée d'un processus B, c'est une autre histoire, mais en tout cas le coup de passer par une adresse physique n'est clairement pas la bonne solution. Je vois deux solutions :

1) Utiliser ptrace()

2) Utiliser /proc. Sous /proc/PID tu as un fichier qui représente l'adress space d'un processus. Si tu as les droits, tu peux lire et même modifier ce fichier. Pour accéder depuis un processus A à une donnée située dans un processus B à l'adress b, il suffit de lire/écrire dans ce fichier à l'offset b.
10/12/2008, 11h05
souviron34

il y a aussi simplement utiliser la partie commune disque (les COMMON en Fortran, Pascal, et autres).

Il existe physiquement une partie système qui est reservée spécifiquement... :)

Le tout est de trouver comment y accéder avec ton OS et/ou ton langage...
10/12/2008, 11h27
Emmanuel Delahaye

Citation:

Envoyé par souviron34

Il existe physiquement une partie système qui est reservée spécifiquement... :)

C'est pas sûr du tout... Ca dépend complètement du système.
10/12/2008, 11h33
souviron34

Citation:

Envoyé par Emmanuel Delahaye

C'est pas sûr du tout... Ca dépend complètement du système.

Et si tu prends un compilo Fortran, tu dois bien pouvoir déclarer des COMMON BLOCK DATA non , puisque c'est dans le langage ?

Donc vraisemblablement sur tous les OS où un compilo Fortran est dispo...
10/12/2008, 11h40
Emmanuel Delahaye

Citation:

Envoyé par souviron34

Et si tu prends un compilo Fortran, tu dois bien pouvoir déclarer des COMMON BLOCK DATA non , puisque c'est dans le langage ?

Donc vraisemblablement sur tous les OS où un compilo Fortran est dispo...

Je ne connais pas FORTRAN et je n'ai pas le souvenir d'une telle chose en Pascal. Quelle est la spécification de cette zone de données ? Ce n'est pas l'équivalent de la mémoire partagée entre processus (SHM) ?
10/12/2008, 12h53
souviron34

Citation:

Envoyé par Emmanuel Delahaye

Je ne connais pas FORTRAN et je n'ai pas le souvenir d'une telle chose en Pascal. Quelle est la spécification de cette zone de données ? Ce n'est pas l'équivalent de la mémoire partagée entre processus (SHM) ?

si, sauf que c'est sur disque dur. Pas besoin de synchro et d'autre choses... Les déclarations de variables font que ce bloc est reservé par le système (bloc nommé), et accessible par tous les processus le déclarant. Tout programme modifiant une des valeurs la modifie automatiquement pour les autres..

L'instruction COMMON existe aussi en Pascal, bien que peu (pas) documentée / enseignée / utilisée.

EDIT :

je ne suis pas certain (cela fait longtemps que je n'ai plus programmé en Fortran) que le partage puisse se faire entre processus... mais il me semble... En tous cas je suis certain que c'était physiquement situé sur le disque dur.

Et en ce qui concerne Pascal, c'était le cas il y a 15 ans. Je n'ai plus pratiqué depuis, il est possible (vraisemblable ?) que cela n'existe plus. Je me souviens que j'avais eu beaucoup de mal à trouver, mais cela existait.. Je pourrais sans doute retrouver la référence si cela intéresse quelqu'un...
10/12/2008, 18h15
dva2tlse

Merci beaucoup à tous les trois, matafan, Émmanuel et souviron34, de vous être penchés sur mon histoire.
Je confirme qu'en fortran, que je connais bien mieux que le C, les COMMON sont des blocs d'echange qui peuvent passer par le disque, mais je n'ai jamais eu vent que ça puisse servir d'un processus à l'autre.
Par contre la mémoire partagée dont vous parlez à plusieurs reprises, ça me fait une piste d'investigations dont je ne souçonnais même pas l'existence.
en tous cas merci encore à tous les trois, mais je viens d'apprendre aujourd'hui que je ne travaillerai peut-être plus à l'avenir avec cette fameuse bécane, donc le problème reste en suspens quelques jours.
David
13/12/2008, 10h20
dva2tlse

Bonjour à tous; pour matafan et souviron34 qui sont déjà intervenus dans ce fil de discussion, sachez que je l'ai "un tout petit peu" poursuivi ici (http://www.developpez.net/forums/d65...uestions-pave/).
Et je me suis aperçu ce matin au boulot, où j'ai appris finalement que je risquais de n'être en face de l'émulateur de la sun fire que jusqu'à Noël, puis je devrais basculer sur une AIX, donc matafan pourra me conseiller, mais je ne crois pas qu'il y ait dans cet OS de structure cred qu'on puisse modifier une fois qu'on l'a trouvée, donc il faudra que je trouve autre chose après quoi assouvir ma soif d'apprendre.
Ceci dit, je me suis aperçu ce matin que ce que je cherchais à faire pour consulter la structure proc d'un process et y lire l'adresse de la structure cred de ce même process pour essayer de la changer, ...donc tout cela n'est jamais que de l'édition de mémoire, ce qui ne devrait pas être sorcier à faire.
Alors j'ai juste besoin de savoir comment faire pour lire ce que contient une certaine case mémoire dont j'ai l'adresse sous un forme ou une autre.
David
13/12/2008, 10h27
Emmanuel Delahaye

Citation:

Envoyé par dva2tlse

Ceci dit, je me suis aperçu ce matin que ce que je cherchais à faire pour consulter la structure proc d'un process et y lire l'adresse de la structure cred de ce même process pour essayer de la changer, ...donc tout cela n'est jamais que de l'édition de mémoire, ce qui ne devrait pas être sorcier à faire.
Alors j'ai juste besoin de savoir comment faire pour lire ce que contient une certaine case mémoire dont j'ai l'adresse sous un forme ou une autre.
David

J'ai rarement vu quelqu'un d'aussi têtu... On se tue à t'expliquer que dans les systèmes modernes tout est mis en oeuvre pour que la mémoire soit segmentée par processus (Memory Management Unit ou MMU) et que tout débordement soit sanctionné, et tu insistes, pour des raisons obscures, à vouloir essayer de passer outre... Tu n'as vraiment rien d'autre à faire ?
13/12/2008, 11h12
dva2tlse

Mais oui bien sûr que je suis têtu, même que j'ai pris un sérieux coup sur la tête qui à fait six semaines et demie de coma il y a bientôt quinze ans, et ça n'a même pas réussi à me casser complètement la calebasse tellement elle est dure. (ce dont je ne suis tout de même que moderément fier parce que c'est parfois pesant pour ne pas dire plus...)
Cet aparté mis à part, il existe bien des choses comme hexedit qui font grosso-modo ce que je veux; donc en demandant ici je tente d'éviter d'avoir à me plonger dans les sources de cette chose qui risquent d'être un peu obtuses pour moi.
En utilisant ptrace et en créant un process fils de celui qui inspecte, je devrais bien avoir le droit de scrutationner ce qui m'intéresse, mais il me manque de savoir comment.
David
13/12/2008, 11h42
Emmanuel Delahaye

Citation:

Envoyé par dva2tlse

Cet aparté mis à part, il existe bien des choses comme hexedit qui font grosso-modo ce que je veux; donc en demandant ici je tente d'éviter d'avoir à me plonger dans les sources de cette chose qui risquent d'être un peu obtuses pour moi.

Faut savoir ce que tu veux...

Citation:

En utilisant ptrace et en créant un process fils de celui qui inspecte, je devrais bien avoir le droit de scrutationner ce qui m'intéresse, mais il me manque de savoir comment.

J'ai du mal à comprendre ce qui t'intéresse vraiment...

Ca y'est, la mémoire m'est revenue...

http://www.developpez.net/forums/d60...ession-telnet/

Tu cherches vraiment à faire des choses bizarres...

Oui Émmanuel, il y avait ça :

Citation:

Ca y'est, la mémoire m'est revenue...

http://www.developpez.net/forums/d60...ession-telnet/

Tu cherches vraiment à faire des choses bizarres...

oui pour les choses bizarres, mais j'ai abandonné (sans y être arrivé) l'idée de réinventer la roue puisque ma nana m'a convaincu que c'était inutile quand c'est disponible ailleurs, mais il y a aussi ça :

Citation:

Donc disons que je voudrais changer la valeur du membre cr_uid de la structure cred attachée à la cmdtool (shell dans un fenêtre autonome) que j'ai créée par fork en tant que fille d'un programme en C. (il est bien évident que si j'arrive un jour à modifier ce terme qui donne ses droits à ma shell, je ne ferai pas de bêtises puisque ce serait comme scier la branche sur laquelle je suis assis pour travailler gentiment, mais cela m'impose d'apprendre plein de choses que d'essayer, alors que dix sept ans du même boulot ne me font plus tellement apprendre de nouveauté)

[.../...]

Citation:

cette adresse est le début de la structure "proc" attachée à la cmdtool-fille, et un membre de cette structure est un pointeur vers la structure cred qui donne les droits à la cmdtool.

Donc ma tête dure me pousse toujours dans la même direction, qui est :
-1°) de forker un petit programme en C,
-2°) de laisser le fils se faire tracer par le père,
-3°) que le père lise l'adresse de la structure proc du fils, (pour l'instant je ne sais obtenir que l'adresse kernel, ou virtuelle, de la structure proc du fils, mais j'ai bon espoir qu'une âme généreuse me présente un moyen de convertir celle ci en adresse physique, par exemple dans ce post où me sont revenus à l'esprit des souvenirs des tout débuts de la micro-informatique personnelle : http://www.developpez.net/forums/d65...nel-virtuelle/ )
-4°) que le pére lise dans cette structure proc l'adresse de la structure cred du fils (par ptrace(PTRACE_PEEKDATA...),
-5°) que le père modifie dans cette structure cred associée au fils le membre cr_uid par ptrace(PTRACE_POKEDATA...),
-6°) puis enfin que le fils crée une cmdtool qui hériterait de ses droits modifiés héhop.
Merci Émmanuel de m'avoir plus ou moins involontairement possé à écrire ce pseudo-code, puisque je vais vite tenter de le faire fonctionner sur mon linux, et dès que je serais au boulot avec la sun au bout de mon émulateur, j'essayerai tout cela.

Mais une petite question quand même dans ce post : comment est il possible qu'un OS se reconnaisse de lui même pour faire la compilation conditionnelle qui convient ?
Pour l'instant j'ai
Code:

1 2 // #define LINUX #define sunOS
et selon celle des deux lignes qui est commentée, chez moi ou au boulot, la compilation crée des programmes un peu différents :
Code:

1 2 3 4 #ifdef sunOS #include "/local/patch/Solaris/8_Recommended/108528-29/SUNWhea/reloc/usr/include/sys/proc.h" #include "/usr/include/sys/cred.h" #endif
et un peu plus loin
Code:

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 #ifdef LINUX typedef struct cred { // uint_t cr_ref; // reference count int cr_ref; // reference count uid_t cr_uid; // effective user id gid_t cr_gid; // effective group id uid_t cr_ruid; // real user id gid_t cr_rgid; // real group id uid_t cr_suid; // "saved" user id (from exec) } cred; typedef struct proc { // /* // * Fields requiring no explicit locking // */ struct vnode *p_exec; // pointer to a.out vnode struct as *p_as; // process adr_process space pointer struct plock *p_lockp; // ptr to proc struct's mutex lock // kmutex_t p_crlock; // lock for p_cred int p_crlock; // lock for p_cred struct cred *p_cred; // process credentials } proc; #endif // struct proc myproc, *pstproc; struct cred mycred, *pstcred; // #ifdef LINUX pstproc=&myproc; pstcred=&mycred; myproc.p_cred=pstcred; // ce n'est pas initialisé, mais c'est juste pour voir. mycred.cr_ref=1; mycred.cr_uid=2; mycred.cr_gid=3; mycred.cr_ruid=4; mycred.cr_rgid=5; mycred.cr_suid=6; #endif
Donc selon la igne qui est commentée, entre linux et sunOS, et que ceci est compilé chez moi ou au boulot, les vraies structures proc et cred de sunOS sont utilisées, ou des remplaçants bidon pour que le code tourne aussi sous linux et que je puisse essayer de le mettre au point. (avec mes faibles connaissances et votre aide qui les renforce merci)
Existe-t'il une variable d'environnement quelconque que l'on pourrait obtenir par getenv(), puis tester pour sélectionner quelle compilation faire ?
Je crois que ça existe pour choisir entre linux et windows, et qu'un même code puisse être compilé sous les deux environnements. (même si dans mon cas précis la compilation sous linux n'aurait pas le même effet sur les droits de ma shell finale, mais ça me permettrait de tester plein de code chez moi)
Merci d'avoir lu jusqu'ici ce qui se trouve être encore un bon bout de pavé,
David

13/12/2008, 16h43
Emmanuel Delahaye

Citation:

Envoyé par dva2tlse

Donc ma tête dure me pousse toujours dans la même direction, qui est :
-1°) de forker un petit programme en C,
-2°) de laisser le fils se faire tracer par le père,

Je ne sais pas trop ce que ça veut dire, mais admettons...

Citation:

-3°) que le père lise l'adresse de la structure proc du fils, (pour l'instant je ne sais obtenir que l'adresse kernel, ou virtuelle, de la structure proc du fils, mais j'ai bon espoir qu'une âme généreuse me présente un moyen de convertir celle ci en adresse physique<...>

Je ne sais pas combien de fois il va falloir te répéter qu'un processus ne peut pas accéder aux données d'un autre processus par des moyens conventionnels. C'est pourtant simple à comprendre. Telle quelle (langage C) ta manip est vouée à l'échec. Point.

Il existe peut être des moyens non conventionnels qui dépendent étroitement de la machine et du système avec laquelle tu travailles, mais ce n'est pas sur un forum C que tu auras la réponse. Il faut demander à des gens hyper pointus sur ton système (et SunOS n'a rien à voir avec Linux).

Citation:

Mais une petite question quand même dans ce post : comment est il possible qu'un OS se reconnaisse de lui même pour faire la compilation conditionnelle qui convient ?

Ca n'a rien à voir avec l'OS, mais avec le compilateur qui a été installé sur telle ou telle machine pour tel ou tel OS. Un compilateur est compilé pour une machine et un OS donné. Il sait donc quelle macro globale il doit définir. Si elle manque, on peut toujours l'ajouter dans la configuration du projet.
13/12/2008, 18h59
dva2tlse

Code:

un processus ne peut pas accéder aux données d'un autre processus par des moyens conventionnels

Eh bien je voudrais utiliser des moyens non conventionels, cela ne m'empêchera pas de dormir, comme ptrace qui permet à un père d'examiner des données de son fils si j'ai bien tout compris.

Citation:

Ca n'a rien à voir avec l'OS, mais avec le compilateur qui a été installé sur telle ou telle machine pour tel ou tel OS

Admettons, mais je voudrais simplement savoir si un moyen existe pour que le programme sache "de lui même", ou par le biais des variables d'environnement, sur quelle machine il est en train d'être compilé.

@+
13/12/2008, 19h10
Emmanuel Delahaye

Citation:

Envoyé par dva2tlse

Code:

un processus ne peut pas accéder aux données d'un autre processus par des moyens conventionnels

Eh bien je voudrais utiliser des moyens non conventionels, cela ne m'empêchera pas de dormir, comme ptrace qui permet à un père d'examiner des données de son fils si j'ai bien tout compris.

Tu as l'air de dire que le code de Ptrace est 'trop fort pour toi'... C'est pourtant ce genre de méthodes non conventionnelles qu'il faut acquérir auprès des quelques gourous qui les maitrisent... Encore une fois, ce n'est pas l'objet de ce forum...

Citation:

Admettons, mais je voudrais simplement savoir si un moyen existe pour que le programme sache "de lui même", ou par le biais des variables d'environnement, sur quelle machine il est en train d'être compilé.

Cette question est absurde. Un programme "en train d'être compilé" n'est pas en train de s'exécuter... Je ne comprend pas le but de la question.

C'est le compilateur qui utilise ses macros internes ou définies par l'utilisateur avec -Dmymacro). L'existence de ces macros dépend donc du compilateur utilisé à certain moment sur une certaine machine. Ca n'a rien à voir avec l'exécution. Un programme C ne peut pas savoir de façon portable sur quel système il s'exécute. Par contre, on peut créer une macro globale qui donne l'indication. Après, il faut être clair dans la gestion de ses projets. Il n'existe pas d'autorité supérieure qui attribue un code système universel connu de tous. On peut le regretter, ce serait peut être un travail à confier à l'ISO via POSIX... De toutes façons, c'est rarement utile.
13/12/2008, 19h32
dva2tlse

Code:

le but de la question

c'est que, par exemple sur la sun,

Code:

getenv("OSVER")-> 5.8

par exemple (s'il existe une variable d'environnement de ce nom et ayant cette valeur) et alors je peux faire un

Code:

#define sunOS

qui me permettra après test de compiler ce qu'il est opportun de faire.
Je relis et comprends ton énervement apparent à propos de la confusion que je fais entre temps d'exécution contre compilation; donc ce qu'il me faut si ça existe, c'est que le préprocesseur ait un moyen de savoir sur quelle machine il est; existerait il quelque chose comme #getenv() ?
merci.
13/12/2008, 20h02
orfix

Citation:

Envoyé par dva2tlse

Code:

#define sunOS

<...>
donc ce qu'il me faut si ça existe, c'est que le préprocesseur ait un moyen de savoir sur quelle machine il est
<...>

Ceci peut être utile ? LIEN
13/12/2008, 22h10
Médinoc

Tu cherches à faire un debugger, en fait?
14/12/2008, 08h45
dva2tlse

por ssmario2, oui merci c'est exactement ce que je cherche; donc je n'ai plus qu'à tester l'existence de telle ou telle macro qui sera là sous linux ou sous sunOS héhop le tour est joué ça me compile ce qu'il faut pour l'OS qui a défini les macros.

pour médinoc, oui cela ressemble un peu à un debugger, dans la mesure où je voudrais consulter la valeur de certaines données en mémoire, et les modifier.

Merci à tous les deux.
14/12/2008, 11h03
Emmanuel Delahaye

Citation:

Envoyé par dva2tlse

Code:

le but de la question

c'est que, par exemple sur la sun,

Code:

getenv("OSVER")-> 5.8

par exemple (s'il existe une variable d'environnement de ce nom et ayant cette valeur) et alors je peux faire un

Code:

#define sunOS

qui me permettra après test de compiler ce qu'il est opportun de faire.

As-tu saisi que la compilation se faisait avant l'exécution ?

Citation:

Je relis et comprends ton énervement apparent à propos de la confusion que je fais entre temps d'exécution contre compilation; donc ce qu'il me faut si ça existe, c'est que le préprocesseur ait un moyen de savoir sur quelle machine il est; existerait il quelque chose comme #getenv() ?
merci.

Non, parce qu'encore une fois c'est un problème de compilateur et pas d'environnement. Le préprocesseur n'a que faire de la machine qui sert à compiler. Dans l'industrie, il est fréquent de faire de la 'cross compilation', c'est à dire de générer du code sur une machine A à destination d'une machine B. La machine B n'a que faire de la machine A. Ce qui importe au compikateur c'est de savoir qu'il est en rain de compiler pour une machine B. C'est tout ce qui compte.

Tu raisonnes de travers. Prend du recul.
14/12/2008, 11h44
dva2tlse

pour Émmanuel :

Citation:

Envoyé par dva2tlse

Je relis et comprends ton agacement apparent à propos de la confusion que je fais entre temps d'exécution contre compilation; donc ce qu'il me faut si ça existe, c'est que le préprocesseur ait un moyen de savoir sur quelle machine il est.

La réponse que j'ai eue de la part de ssmario2 me convient tout à fait, merci.
18/12/2008, 20h33
dva2tlse

Ouf, j'ai enfin lu aujourd'hui, dans un man de kernel,
que j'avais en fait depuis toujours à ma disposition dans la machines,
ce qu'était exactement le kernel ou noyau : "The operating system image,
or kernel, is the collection of software made up of the core image files
(unix and genunix) of all of the modules loaded at any instant in time.
The system will not function without a kernel to control it."

Mais maintenant pourquoi ce kernel-noyau voit il la structure proc de
mon process en utilisant une adresse virtuelle et non physique ?
Et qu'est cette adresse virtuelle par rapport à l'autre ?

Dynamic address translation (merci gogol et wikipedia)
While executing an instruction a CPU fetches an instruction located at a particular virtual address or fetches data from a specific virtual address or stores data to a particular virtual address, the virtual address must be translated to the corresponding physical address. This is done by a hardware component, sometimes called a memory management unit, which looks up the real address (from the page table) corresponding to a virtual address and passes the real address to the parts of the CPU which execute instructions. If the page tables indicate that the virtual memory page is not currently in real memory, the hardware raises a page fault exception (special internal signal) which invokes the paging supervisor component of the operating system

Cela me rapelle un temps déjà un peu éloigné, où la plus grosse bécane
que j'avais à ma disposition pour tourner mes calculs était un microvax 3100,
auquel j'imagine que des PC actuels doivent mettre une gentille pâtée
en terme de puissance de calcul.
Et sur le vax il y avait un certain fichier PAGEFILE.SYS, fichier de pagination,
dont la taille était assez critique, et avec lequel je me suis pas mal bagarré
pour que mes calculs tournent et le mieux possible. À ce que je sais ça correspond
plus ou mois au fichier de swap des machines nux, et cela constitue cette foutue
mémoire virtuelle dont je cherche à comprendre le pourquoi du comment depuis quelques
temps, à cause de cette foutue structure proc dont je n'ai qu'une adresse qui semble
être virtuelle.

Donc je n'ai peut-être pas besoin de passer par ptrace (ni de m'attirer les foudres d'Émmanuel)
pour lire puis modifier les structures proc et cred qui m'intéressent.

Post sans question puisque j'ai tout compris; David

PS Euh... au fait j'y pense, y aurait il un moyen de convertir l'une en l'autre ?
18/12/2008, 23h39
matafan

La structure proc, tu ne la lira pas en allant triffouiller dans l'address space du process qui t'intéresse. Un process n'a pas accès à sa propre structure proc. Lire une structure proc suppose de lire de la mémoire kernel, ce qui peut se faire avec /dev/kmem, ou peut-être avec ptrace (je ne connais pas vraiment ptrace), ou peut-être avec un éventuel system call non documenté qui ferait ça. Il y a une autre personne sur ce forum qui cherche à faire le même genre de truc.
19/12/2008, 14h59
dva2tlse

pour matafan :

Citation:

Un process n'a pas accès à sa propre structure proc

ça c'est embêtant; mais sais tu si une quelconque structure est stockée en mémoire après une certaine en-tête qui me permettrait de la reconnaître, ou veux tu dire que mon process n'a carrément pas accès a ses propres données et qu'il me faut trouver autre chose qu'essayer de la reconnaître dans l'ensemble de la mémoire à laquelle mon processus a accés par memchr ou équivalent ?
Je vais essayer de trouver l'autre type dont tu parles et ses messages.
David
19/12/2008, 15h47
matafan

Ah ben non en fait je crois que c'était toi l'autre persone en question :lol:
Ce qui fait que ça fais un mois que je te répète la même chose.
19/12/2008, 16h10
dva2tlse

en effet tu t'es déjà adressé à moi il y a plus ou moins un mois dans un autre fil de discussion qui avait également trait aux structures cred et proc, mais il n'avait pas été question qu'un processus n'ait pas accès à sa propre structure proc.
Il n'était question que d'adresse, dont tu me disais que celle que j'obtiens par "ps -o user,pid,addr,args -p PID_de_ma_kshell" était probablement virtuelle, et c'est pour ça que j'ai désormais besoin d'un moyen de conversion vers l'adresse physique pour lire ce qu'elle contient dans un premier temps.
Mais si je ne peux pas y lire ça ne va plus du tout; et cela me semble contraire à ce que j'ai lu dans l'article de bandit qui est ici : http://sobrique.livejournal.com/34889.html . Contrairement au type de l'article je n'ai pas accès à la console, donc je voudrais passer par un programme en C, ce qui m'impose d'apprendre à m'en servir correctement.
David
19/12/2008, 16h24
matafan

J'ai parcouru rapidement l'article. Je ne connais pas les environment Sun mais comme il parle de ‘break’ sequence qui ouvre un ‘OK’ prompt, et vu ce qu'il dit ensuite, ça ressemble un peu à KDB (kernel debugger) sur AIX. Je pense que son "OK prompt" lui permet comme KDB de manipuler les données kernel. Mais ce n'est pas le genre de chose que tu peux faire directement en user space.

C'est ce que j'essaie de te faire comprendre depuis le début : on ne peux pas accéder à un structure proc de manière conventionelle en user space. C'est pour ça que je t'ai parlé de /dev/kmem, qui permet d'accéder à la mémoire kernel.

Ensuite je ne sais pas si c'est le cas sur Solaris, mais sous AIX les structures cred sont extrèmement sensibles et "volatiles". On ne peut pas y accéder, même en lecture, sans prendre les locks qui vont bien, sous peine de lire des données bidon.
19/12/2008, 16h32
Jean-Marc.Bourguet

Citation:

Envoyé par dva2tlse

Contrairement au type de l'article je n'ai pas accès à la console, donc je voudrais passer par un programme en C, ce qui m'impose d'apprendre à m'en servir correctement.

Quand tu es sur la console (et uniquement quand c'est la console) d'une sun, tu as une combinaison de touche (STOP-A) qui te place dans un interpreteur Forth qui fonctionne indépendamment de l'OS (sur un PC, c'est comme si le BIOS n'etait pas courcircuite la plupart du temps par les OS et comportait un interpreteur Forth). Pas de chance, ca ne marchera pas sans cela.
19/12/2008, 17h45
dva2tlse

Citation:

Quand tu es sur la console (et uniquement quand c'est la console) d'une sun [.../...] indépendamment de l'OS

Bon ben ça a bien l'air d'être mort; alors maintenant il va falloir que j'ouvre un autre fil pour apprendre comment lire ce qui est contenu dans une adresse mémoire passée en argument à un programme, parce que ça a aiguisé ma soif d'apprendre, cette babiole.
David

Citation:

Envoyé par dva2tlse

Bon ben ça a bien l'air d'être mort; alors maintenant il va falloir que j'ouvre un autre fil pour apprendre comment lire ce qui est contenu dans une adresse mémoire passée en argument à un programme, parce que ça a aiguisé ma soif d'apprendre, cette babiole.
David

Moi, je fais comme ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
/* http://emmanuel-delahaye.developpez.com/clib.htm */
#include "ed/inc/sys.h"
 
#include <stdio.h>
 
int x = 1234;
 
int main (void)
{
static double y = 123.45;
char z[] = "Hello world";
int n = 4;
int *p = malloc(sizeof *p * n);
 
 
SYS_dump (&x, sizeof x);
SYS_dump (&y, sizeof y);
SYS_dump (z, sizeof z);
SYS_dump (p, sizeof n);
 
   return 0;
}

(exécuté dans Code::Blocks)

Code:

1
2
3
4
5
6
7
8
 
00402000 D2 04 00 00                                      '....'
00402008 CD CC CC CC CC DC 5E 40                          '......^@'
0022FF30 48 65 6C 6C 6F 20 77 6F 72 6C 64 00              'Hello world.'
008429D0 F8 0E 84 00                                      '....'
 
Process returned 0 (0x0)   execution time : 0.043 s
Press any key to continue.

mais évidemment, ça ne concerne que la mémoire du processus.

Le même code exécuté en mode console :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
Microsoft Windows [version 6.0.6001]
Copyright (c) 2006 Microsoft Corporation. Tous droits réservés.
 
C:\Users\Emmanuel>cd\dev
 
C:\dev>cd hello
 
C:\dev\hello>cd bin
 
C:\dev\hello\bin>cd debug
 
C:\dev\hello\bin\Debug>hello
00402000 D2 04 00 00                                      '....'
00402008 CD CC CC CC CC DC 5E 40                          '......^@'
0022FF30 48 65 6C 6C 6F 20 77 6F 72 6C 64 00              'Hello world.'
00270FA8 70 28 27 00                                      'p('.'
 
C:\dev\hello\bin\Debug>

19/12/2008, 18h07
matafan

Citation:

Envoyé par dva2tlse

comment lire ce qui est contenu dans une adresse mémoire passée en argument à un programme

Tel quel, ça ne veut rien dire. Une adresse mémoire n'a de sens que dans l'address space d'un process. Il n'y a pas d'adresse "absolue" en user space. Par contre un process A peut tout à fait, s'il a les droits qui vont bien, aller lire (ou même écrire) à l'adresse x d'un process B, par les moyens que je t'ai déjà donné (ptrace ou /proc). A condition bien sûr que x soit une adresse valide dans l'address space de B.
19/12/2008, 18h54
dva2tlse

ouh là, merci à vous deux Émmanuel et matafan; alors comme ça, il suffit que je fasse semblant de jeter l'éponge et je me retrouve avec bien ce que je voulais savoir.
merci,
David (qui part une semaine en vacances)(ski, nautique alors, vers Guérande)
19/12/2008, 19h17
Médinoc

Dommage que tu ne sois pas sous Windows. Là, il y a un moyen simple de lire la mémoire d'un process appartenant au même utilisateur que le process qui lit (ou bien, n'importe quel process si tu as le bon privilège d'administrateur).

Mais ça ne te donne pas pour autant accès à la mémoire Kernel... (sous Windows, il s'agit des 2Go supérieurs de la mémoire virtuelle du process: Un process y a accès seulement en mode kernel, et c'est partagé entre tous les process)