Improved the code for handling vmpa_t definitions.

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

1 files changed, 146 insertions, 100 deletions

diff --git a/src/arch/vmpa.c b/src/arch/vmpa.c
index 4ee0b99..93bbfc8 100644
--- a/src/arch/vmpa.c
+++ b/src/arch/vmpa.c
@@ -33,35 +33,52 @@
 
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : addr = élément à initialiser.                                *
+*                phy  = position dans la mémoire physique.                    *
+*                virt = adresse dans la mémoire virtuelle.                    *
+*                                                                             *
+*  Description : Initialise une localisation dans l'espace mémoire/physique.  *
+*                                                                             *
+*  Retour      : Adressage alloué en mémoire.                                 *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
+void init_vmpa(vmpa2t *addr, off_t phy, uint64_t virt)
+{
+    addr->physical = phy;
+    addr->virtual = virt;
 
+}
 
 
-#if 0
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : src = définition à copier.                                   *
+*  Paramètres  : phy  = position dans la mémoire physique.                    *
+*                virt = adresse dans la mémoire virtuelle.                    *
 *                                                                             *
-*  Description : Crée la copie d'un adressage mémoire en local.               *
+*  Description : Crée une localisation dans l'adressage mémoire.              *
 *                                                                             *
-*  Retour      : Adressage alloué sur la pile.                                *
+*  Retour      : Adressage alloué en mémoire.                                 *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-inline vmpa2t *local_dup_vmpa(const vmpa2t *src)
+vmpa2t *make_vmpa(off_t phy, uint64_t virt)
 {
-    vmpa2t *result;                         /* Adressage à retourner       */
+    vmpa2t *result;                         /* Structure à retourner       */
 
-    result = alloca(sizeof(vmpa2t));
+    result = (vmpa2t *)calloc(1, sizeof(vmpa2t));
 
-    copy_vmpa(result, src);
+    init_vmpa(result, phy, virt);
 
     return result;
 
 }
-#endif
 
 
 /******************************************************************************
@@ -80,92 +97,133 @@ inline vmpa2t *local_dup_vmpa(const vmpa2t *src)
 void copy_vmpa(vmpa2t *dest, const vmpa2t *src)
 {
     dest->physical = src->physical;
-    dest->virtual= src->virtual;
-
-    dest->last_phys_size = src->last_phys_size;
-    dest->last_virt_size = src->last_virt_size;
-
-    strncpy(dest->phys_cache, src->phys_cache, VMPA_MAX_SIZE);
-    dest->phys_cache[VMPA_MAX_SIZE - 1] = '\0';
-
-    strncpy(dest->virt_cache, src->virt_cache, VMPA_MAX_SIZE);
-    dest->virt_cache[VMPA_MAX_SIZE - 1] = '\0';
+    dest->virtual = src->virtual;
 
 }
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : a = première définition à analyser.                          *
+*                b = seconde définition à analyser.                           *
+*                                                                             *
+*  Description : Compare entre elles deux adresses physiques.                 *
+*                                                                             *
+*  Retour      : Bilan de la comparaison : -1, 0 ou 1.                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
+int cmp_vmpa_by_phy(const vmpa2t *a, const vmpa2t *b)
+{
+    int result;                             /* Bilan à retourner           */
 
+    if (a->physical != VMPA_NO_PHYSICAL && b->physical != VMPA_NO_PHYSICAL)
+    {
+        if (a->physical < b->physical) result = -1;
+        else if (a->physical > b->physical) result = 1;
+        else result = 0;
+    }
+    else
+    {
+        if (a->physical == VMPA_NO_PHYSICAL && b->physical == VMPA_NO_PHYSICAL) result = 0;
+        else if (a->physical == VMPA_NO_PHYSICAL) result = -1;
+        else result = 1;
+    }
 
+    return result;
 
-
-
-
-
-
-
+}
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : phy  = position dans la mémoire physique.                    *
-*                virt = adresse dans la mémoire virtuelle.                    *
+*  Paramètres  : a = première définition à analyser.                          *
+*                b = seconde définition à analyser.                           *
 *                                                                             *
-*  Description : Crée une localisation dans l'adressage mémoire.              *
+*  Description : Compare entre elles deux adresses virtuelles.                *
 *                                                                             *
-*  Retour      : Adressage alloué en mémoire.                                 *
+*  Retour      : Bilan de la comparaison : -1, 0 ou 1.                        *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-vmpa2t *make_vmpa(off_t phy, uint64_t virt)
+int cmp_vmpa_by_virt(const vmpa2t *a, const vmpa2t *b)
 {
-    vmpa2t *result;                         /* Structure à retourner       */
-
-    result = (vmpa2t *)calloc(1, sizeof(vmpa2t));
+    int result;                             /* Bilan à retourner           */
 
-    result->physical = phy;
-    result->virtual = virt;
+    if (a->virtual != VMPA_NO_VIRTUAL && b->virtual != VMPA_NO_VIRTUAL)
+    {
+        if (a->virtual < b->virtual) result = -1;
+        else if (a->virtual > b->virtual) result = 1;
+        else result = 0;
+    }
+    else
+    {
+        if (a->virtual == VMPA_NO_VIRTUAL && b->virtual == VMPA_NO_VIRTUAL) result = 0;
+        else if (a->virtual == VMPA_NO_VIRTUAL) result = -1;
+        else result = 1;
+    }
 
     return result;
 
 }
 
 
-
-
-
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : addr = élément à initialiser.                                *
-*                phy  = position dans la mémoire physique.                    *
-*                virt = adresse dans la mémoire virtuelle.                    *
+*  Paramètres  : addr = élément à modifier.                                   *
+*                qty  = quantité d'unités de décallage.                       *
 *                                                                             *
-*  Description : Initialise une localisation dans l'espace mémoire/physique.  *
+*  Description : Décalle une position d'une certaine quantité.                *
 *                                                                             *
-*  Retour      : Adressage alloué en mémoire.                                 *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-void init_vmpa(vmpa2t *addr, off_t phy, uint64_t virt)
+void advance_vmpa(vmpa2t *addr, off_t qty)
 {
-    addr->physical = phy;
-    addr->virtual = virt;
+    if (addr->physical != VMPA_NO_PHYSICAL)
+        addr->physical += qty;
 
+    if (addr->virtual != VMPA_NO_VIRTUAL)
+        addr->virtual =+ qty;
 
+}
 
-    MDS_UNDEFINED;
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : a = première élément à venir consulter.                      *
+*                b = second élément à traiter en parallèle.                   *
+*                                                                             *
+*  Description : Calcule au mieux la distance entre deux coordonnées.         *
+*                                                                             *
+*  Retour      : Distance absolue entre deux localisations.                   *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
+off_t compute_vmpa_diff(const vmpa2t *a, const vmpa2t *b)
+{
+    off_t result;                           /* Valeur à retourner          */
 
-}
+    result = VMPA_NO_PHYSICAL;
 
+    if (a->physical != VMPA_NO_PHYSICAL && b->physical != VMPA_NO_PHYSICAL)
+        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);
 
+    return result;
 
+}
 
 
 /******************************************************************************
@@ -235,6 +293,7 @@ bool send_vmpa(const vmpa2t *addr, int fd, int flags)
 *                                                                             *
 *  Paramètres  : addr   = adresse virtuelle ou physique à traiter.            *
 *                msize  = taille de cette adresse, réelle ou désirée.         *
+*                buffer = tampon de sortie utilisé à constituer. [OUT]        *
 *                length = transmission de la taille du résultat ou NULL. [OUT]*
 *                                                                             *
 *  Description : Transforme une adresse physique en chaîne de caractères.     *
@@ -245,45 +304,38 @@ bool send_vmpa(const vmpa2t *addr, int fd, int flags)
 *                                                                             *
 ******************************************************************************/
 
-const char *vmpa2_phys_to_string(vmpa2t *addr, MemoryDataSize msize, size_t *length)
+char *vmpa2_phys_to_string(const vmpa2t *addr, MemoryDataSize msize, char buffer[VMPA_MAX_LEN], size_t *length)
 {
     size_t ret;                             /* Retour de l'impression      */
 
-    if (addr->phys_cache[0] == '\0' || addr->last_phys_size != msize)
+    switch (msize)
     {
-        switch (msize)
-        {
-            case MDS_8_BITS:
-                ret = snprintf(addr->phys_cache, VMPA_MAX_SIZE,"0x%02" PRIx64, addr->physical);
-                break;
-
-            case MDS_16_BITS:
-                ret = snprintf(addr->phys_cache, VMPA_MAX_SIZE, "0x%04" PRIx64, addr->physical);
-                break;
-
-            case MDS_32_BITS:
-                ret = snprintf(addr->phys_cache, VMPA_MAX_SIZE, "0x%08" PRIx64, addr->physical);
-                break;
+        case MDS_8_BITS:
+            ret = snprintf(buffer, VMPA_MAX_SIZE,"0x%02" PRIx64, addr->physical);
+            break;
 
-            case MDS_64_BITS:
-                ret = snprintf(addr->phys_cache, VMPA_MAX_SIZE, "0x%016" PRIx64, addr->physical);
-                break;
+        case MDS_16_BITS:
+            ret = snprintf(buffer, VMPA_MAX_SIZE, "0x%04" PRIx64, addr->physical);
+            break;
 
-            default:
-                ret = snprintf(addr->phys_cache, VMPA_MAX_SIZE, "???");
-                break;
+        case MDS_32_BITS:
+            ret = snprintf(buffer, VMPA_MAX_SIZE, "0x%08" PRIx64, addr->physical);
+            break;
 
-        }
+        case MDS_64_BITS:
+            ret = snprintf(buffer, VMPA_MAX_SIZE, "0x%016" PRIx64, addr->physical);
+            break;
 
-        addr->last_phys_size = msize;
-        addr->last_phys_len = ret;
+        default:
+            ret = snprintf(buffer, VMPA_MAX_SIZE, "???");
+            break;
 
     }
 
     if (length != NULL)
-        *length = addr->last_phys_size;
+        *length = ret;
 
-    return addr->phys_cache;
+    return buffer;
 
 }
 
@@ -292,6 +344,7 @@ const char *vmpa2_phys_to_string(vmpa2t *addr, MemoryDataSize msize, size_t *len
 *                                                                             *
 *  Paramètres  : addr   = adresse virtuelle ou physique à traiter.            *
 *                msize  = taille de cette adresse, réelle ou désirée.         *
+*                buffer = tampon de sortie utilisé à constituer. [OUT]        *
 *                length = transmission de la taille du résultat ou NULL. [OUT]*
 *                                                                             *
 *  Description : Transforme une adresse virtuelle en chaîne de caractères.    *
@@ -302,44 +355,37 @@ const char *vmpa2_phys_to_string(vmpa2t *addr, MemoryDataSize msize, size_t *len
 *                                                                             *
 ******************************************************************************/
 
-const char *vmpa2_virt_to_string(vmpa2t *addr, MemoryDataSize msize, size_t *length)
+char *vmpa2_virt_to_string(const vmpa2t *addr, MemoryDataSize msize, char buffer[VMPA_MAX_LEN], size_t *length)
 {
     size_t ret;                             /* Retour de l'impression      */
 
-    if (addr->virt_cache[0] == '\0' || addr->last_virt_size != msize)
+    switch (msize)
     {
-        switch (msize)
-        {
-            case MDS_8_BITS:
-                ret = snprintf(addr->virt_cache, VMPA_MAX_SIZE,"0x%02" PRIx64, addr->virtual);
-                break;
-
-            case MDS_16_BITS:
-                ret = snprintf(addr->virt_cache, VMPA_MAX_SIZE, "0x%04" PRIx64, addr->virtual);
-                break;
-
-            case MDS_32_BITS:
-                ret = snprintf(addr->virt_cache, VMPA_MAX_SIZE, "0x%08" PRIx64, addr->virtual);
-                break;
+        case MDS_8_BITS:
+            ret = snprintf(buffer, VMPA_MAX_SIZE,"0x%02" PRIx64, addr->virtual);
+            break;
 
-            case MDS_64_BITS:
-                ret = snprintf(addr->virt_cache, VMPA_MAX_SIZE, "0x%016" PRIx64, addr->virtual);
-                break;
+        case MDS_16_BITS:
+            ret = snprintf(buffer, VMPA_MAX_SIZE, "0x%04" PRIx64, addr->virtual);
+            break;
 
-            default:
-                ret = snprintf(addr->virt_cache, VMPA_MAX_SIZE, "???");
-                break;
+        case MDS_32_BITS:
+            ret = snprintf(buffer, VMPA_MAX_SIZE, "0x%08" PRIx64, addr->virtual);
+            break;
 
-        }
+        case MDS_64_BITS:
+            ret = snprintf(buffer, VMPA_MAX_SIZE, "0x%016" PRIx64, addr->virtual);
+            break;
 
-        addr->last_virt_size = msize;
-        addr->last_virt_len = ret;
+        default:
+            ret = snprintf(buffer, VMPA_MAX_SIZE, "???");
+            break;
 
     }
 
     if (length != NULL)
-        *length = addr->last_virt_size;
+        *length = ret;
 
-    return addr->virt_cache;
+    return buffer;
 
 }