Introduced memory ranges.

git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@406 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a

1 files changed, 216 insertions, 15 deletions

diff --git a/src/arch/vmpa.c b/src/arch/vmpa.c
index c3cf17e..6f305fb 100644
--- a/src/arch/vmpa.c
+++ b/src/arch/vmpa.c
@@ -34,9 +34,14 @@
 
 
 
+/* ---------------------------------------------------------------------------------- */
+/*                        DEFINITION D'UNE POSITION EN MEMOIRE                        */
+/* ---------------------------------------------------------------------------------- */
+
+
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : addr = élément à initialiser.                                *
+*  Paramètres  : addr = élément à initialiser. [OUT]                          *
 *                phy  = position dans la mémoire physique.                    *
 *                virt = adresse dans la mémoire virtuelle.                    *
 *                                                                             *
@@ -48,7 +53,7 @@
 *                                                                             *
 ******************************************************************************/
 
-void init_vmpa(vmpa2t *addr, off_t phy, uint64_t virt)
+void init_vmpa(vmpa2t *addr, phys_t phy, virt_t virt)
 {
     addr->physical = phy;
     addr->virtual = virt;
@@ -69,7 +74,7 @@ void init_vmpa(vmpa2t *addr, off_t phy, uint64_t virt)
 *                                                                             *
 ******************************************************************************/
 
-vmpa2t *make_vmpa(off_t phy, uint64_t virt)
+vmpa2t *make_vmpa(phys_t phy, virt_t virt)
 {
     vmpa2t *result;                         /* Structure à retourner       */
 
@@ -212,7 +217,6 @@ int cmp_vmpa(const vmpa2t *a, const vmpa2t *b)
 }
 
 
-
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : addr = élément à modifier.                                   *
@@ -226,7 +230,7 @@ int cmp_vmpa(const vmpa2t *a, const vmpa2t *b)
 *                                                                             *
 ******************************************************************************/
 
-void advance_vmpa(vmpa2t *addr, off_t qty)
+void advance_vmpa(vmpa2t *addr, phys_t qty)
 {
     if (addr->physical != VMPA_NO_PHYSICAL)
         addr->physical += qty;
@@ -250,9 +254,9 @@ void advance_vmpa(vmpa2t *addr, off_t qty)
 *                                                                             *
 ******************************************************************************/
 
-off_t compute_vmpa_diff(const vmpa2t *a, const vmpa2t *b)
+phys_t compute_vmpa_diff(const vmpa2t *a, const vmpa2t *b)
 {
-    off_t result;                           /* Valeur à retourner          */
+    phys_t result;                          /* Valeur à retourner          */
 
     result = VMPA_NO_PHYSICAL;
 
@@ -260,7 +264,7 @@ off_t compute_vmpa_diff(const vmpa2t *a, const vmpa2t *b)
         result = (b->physical > a->physical ? b->physical - a->physical : a->physical- b->physical);
 
     else if (a->virtual != VMPA_NO_VIRTUAL && b->virtual != VMPA_NO_VIRTUAL)
-        result = (off_t)(b->virtual > a->virtual ? b->virtual - a->virtual : a->virtual- b->virtual);
+        result = (phys_t)(b->virtual > a->virtual ? b->virtual - a->virtual : a->virtual- b->virtual);
 
     return result;
 
@@ -283,15 +287,15 @@ off_t compute_vmpa_diff(const vmpa2t *a, const vmpa2t *b)
 
 bool recv_vmpa(vmpa2t *addr, int fd, int flags)
 {
-    uint64_t val64;                         /* Valeur sur 64 bits          */
+    virt_t val64;                           /* Valeur sur 64 bits          */
     bool status;                            /* Bilan d'une réception       */
 
-    status = safe_recv(fd, &val64, sizeof(uint64_t), flags);
+    status = safe_recv(fd, &val64, sizeof(virt_t), flags);
     if (!status) return false;
 
     addr->physical = be64toh(val64);
 
-    status = safe_recv(fd, &val64, sizeof(uint64_t), flags);
+    status = safe_recv(fd, &val64, sizeof(virt_t), flags);
     if (!status) return false;
 
     addr->virtual = be64toh(val64);
@@ -319,10 +323,10 @@ bool send_vmpa(const vmpa2t *addr, int fd, int flags)
 {
     bool status;                            /* Bilan d'une émission        */
 
-    status = safe_send(fd, (uint64_t []) { htobe64(addr->physical) }, sizeof(uint64_t), flags);
+    status = safe_send(fd, (virt_t []) { htobe64(addr->physical) }, sizeof(virt_t), flags);
     if (!status) return false;
 
-    status = safe_send(fd, (uint64_t []) { htobe64(addr->virtual) }, sizeof(uint64_t), flags);
+    status = safe_send(fd, (virt_t []) { htobe64(addr->virtual) }, sizeof(virt_t), flags);
     if (!status) return false;
 
     return true;
@@ -446,7 +450,7 @@ char *vmpa2_virt_to_string(const vmpa2t *addr, MemoryDataSize msize, char buffer
 
 vmpa2t *string_to_vmpa_phy(const char *buffer)
 {
-    off_t physical;                         /* Position à retrouver        */
+    phys_t physical;                        /* Position à retrouver        */
 
     physical = strtoull(buffer, NULL, 16);
 
@@ -469,10 +473,207 @@ vmpa2t *string_to_vmpa_phy(const char *buffer)
 
 vmpa2t *string_to_vmpa_virt(const char *buffer)
 {
-    uint64_t virtual;                       /* Adresse à retrouver         */
+    virt_t virtual;                         /* Adresse à retrouver         */
 
     virtual = strtoull(buffer, NULL, 16);
 
     return make_vmpa(VMPA_NO_PHYSICAL, virtual);
 
 }
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                          DEFINITION D'UNE ZONE EN MEMOIRE                          */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : range  = plage à initialiser. [OUT]                          *
+*                addr   = position de départ dans la mémoire.                 *
+*                length = taille de la plage à constituer.                    *
+*                                                                             *
+*  Description : Initialise une plage dans l'espace mémoire/physique.         *
+*                                                                             *
+*  Retour      : Place définie en mémoire.                                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void init_mrange(mrange_t *range, const vmpa2t *addr, phys_t length)
+{
+    copy_vmpa(&range->addr, addr);
+
+    range->length = length;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : dest = structure de destination pour la copie.               *
+*                src  = structure de source pour la copie.                    *
+*                                                                             *
+*  Description : Copie la définition d'une plage mémoire dans une autre.      *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void copy_mrange(mrange_t *dest, const mrange_t *src)
+{
+    copy_vmpa(&dest->addr, &src->addr);
+
+    dest->length = src->length;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : a = première définition à analyser.                          *
+*                b = seconde définition à analyser.                           *
+*                                                                             *
+*  Description : Compare deux couvertures mémoire selon leurs propriétés.     *
+*                                                                             *
+*  Retour      : Bilan de la comparaison : -1, 0 ou 1 (-1 par défaut).        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+int cmp_mrange(const mrange_t *a, const mrange_t *b)
+{
+    int result;                             /* Bilan à retourner           */
+
+    result = cmp_vmpa(&a->addr, &b->addr);
+
+    if (result == 0)
+    {
+        if (a->length < b->length)
+            result = -1;
+        else if (a->length > b->length)
+            result = 1;
+        else
+            result = 0;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : range = zone mémoire à consulter.                            *
+*                addr  = localisation mémoire à analyser.                     *
+*                                                                             *
+*  Description : Indique si une localisation est incluse dans une zone ou non.*
+*                                                                             *
+*  Retour      : Bilan de la consultation.                                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool mrange_contains_addr(const mrange_t *range, const vmpa2t *addr)
+{
+    bool result;                            /* Bilan à retourner           */
+    int ret;                                /* Bilan d'une comparaison     */
+    phys_t diff;                            /* Espace entre deux adresses  */
+
+    ret = cmp_vmpa(&range->addr, addr);
+
+    if (ret <= -1)
+    {
+        diff = compute_vmpa_diff(&range->addr, addr);
+        result = (diff < range->length);
+    }
+
+    else if (ret == 0)
+        result = true;
+
+    else
+        result = false;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : rane   = emplacement virtuel ou physique à traiter.          *
+*                msize  = taille de cette adresse, réelle ou désirée.         *
+*                start  = indique si le début ou la fin est à imprimer.       *
+*                buffer = tampon de sortie utilisé à constituer. [OUT]        *
+*                length = transmission de la taille du résultat ou NULL. [OUT]*
+*                                                                             *
+*  Description : Transforme un emplacement physique en chaîne de caractères.  *
+*                                                                             *
+*  Retour      : Chaîne de caractères constituée.                             *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+char *mrange_phys_to_string(const mrange_t *range, MemoryDataSize msize, bool start, char buffer[VMPA_MAX_LEN], size_t *length)
+{
+    vmpa2t tmp;
+
+    if (start)
+        vmpa2_phys_to_string(&range->addr, msize, buffer, length);
+
+    else
+    {
+        copy_vmpa(&tmp, &range->addr);
+        advance_vmpa(&tmp, range->length);
+
+        vmpa2_phys_to_string(&tmp, msize, buffer, length);
+
+    }
+
+    return buffer;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : rane   = emplacement virtuel ou physique à traiter.          *
+*                msize  = taille de cette adresse, réelle ou désirée.         *
+*                start  = indique si le début ou la fin est à imprimer.       *
+*                buffer = tampon de sortie utilisé à constituer. [OUT]        *
+*                length = transmission de la taille du résultat ou NULL. [OUT]*
+*                                                                             *
+*  Description : Transforme un emplacement virtuel en chaîne de caractères.   *
+*                                                                             *
+*  Retour      : Chaîne de caractères constituée.                             *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+char *mrange_virt_to_string(const mrange_t *range, MemoryDataSize msize, bool start, char buffer[VMPA_MAX_LEN], size_t *length)
+{
+    vmpa2t tmp;
+
+    if (start)
+        vmpa2_virt_to_string(&range->addr, msize, buffer, length);
+
+    else
+    {
+        copy_vmpa(&tmp, &range->addr);
+        advance_vmpa(&tmp, range->length);
+
+        vmpa2_virt_to_string(&tmp, msize, buffer, length);
+
+    }
+
+    return buffer;
+
+}