Return to memmap.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / seabios / src

Annotation of qemu/roms/seabios/src/memmap.c, revision 1.1.1.6

1.1       root        1: // Support for building memory maps suitable for int 15 e820 calls.
                      2: //
                      3: // Copyright (C) 2008,2009  Kevin O'Connor <[email protected]>
                      4: //
                      5: // This file may be distributed under the terms of the GNU LGPLv3 license.
                      6: 
                      7: #include "memmap.h" // struct e820entry
                      8: #include "util.h" // dprintf.h
                      9: #include "biosvar.h" // SET_EBDA
                     10: 
                     11: 
                     12: /****************************************************************
                     13:  * e820 memory map
                     14:  ****************************************************************/
                     15: 
                     16: // Remove an entry from the e820_list.
                     17: static void
                     18: remove_e820(int i)
                     19: {
                     20:     e820_count--;
                     21:     memmove(&e820_list[i], &e820_list[i+1]
                     22:             , sizeof(e820_list[0]) * (e820_count - i));
                     23: }
                     24: 
                     25: // Insert an entry in the e820_list at the given position.
                     26: static void
                     27: insert_e820(int i, u64 start, u64 size, u32 type)
                     28: {
                     29:     if (e820_count >= CONFIG_MAX_E820) {
1.1.1.3   root       30:         warn_noalloc();
1.1       root       31:         return;
                     32:     }
                     33: 
                     34:     memmove(&e820_list[i+1], &e820_list[i]
                     35:             , sizeof(e820_list[0]) * (e820_count - i));
                     36:     e820_count++;
                     37:     struct e820entry *e = &e820_list[i];
                     38:     e->start = start;
                     39:     e->size = size;
                     40:     e->type = type;
                     41: }
                     42: 
1.1.1.5   root       43: static const char *
                     44: e820_type_name(u32 type)
                     45: {
1.1.1.6 ! root       46:     switch (type) {
        !            47:     case E820_RAM:      return "RAM";
        !            48:     case E820_RESERVED: return "RESERVED";
        !            49:     case E820_ACPI:     return "ACPI";
        !            50:     case E820_NVS:      return "NVS";
        !            51:     case E820_UNUSABLE: return "UNUSABLE";
        !            52:     case E820_HOLE:     return "HOLE";
        !            53:     default:            return "UNKNOWN";
        !            54:     }
1.1.1.5   root       55: }
                     56: 
1.1       root       57: // Show the current e820_list.
                     58: static void
1.1.1.2   root       59: dump_map(void)
1.1       root       60: {
                     61:     dprintf(1, "e820 map has %d items:\n", e820_count);
                     62:     int i;
                     63:     for (i=0; i<e820_count; i++) {
                     64:         struct e820entry *e = &e820_list[i];
                     65:         u64 e_end = e->start + e->size;
1.1.1.6 ! root       66:         dprintf(1, "  %d: %016llx - %016llx = %d %s\n", i
        !            67:                 , e->start, e_end, e->type, e820_type_name(e->type));
1.1       root       68:     }
                     69: }
                     70: 
                     71: // Add a new entry to the list.  This scans for overlaps and keeps the
                     72: // list sorted.
                     73: void
                     74: add_e820(u64 start, u64 size, u32 type)
                     75: {
                     76:     dprintf(8, "Add to e820 map: %08x %08x %d\n", (u32)start, (u32)size, type);
                     77: 
                     78:     if (! size)
                     79:         // Huh?  Nothing to do.
                     80:         return;
                     81: 
                     82:     // Find position of new item (splitting existing item if needed).
                     83:     u64 end = start + size;
                     84:     int i;
                     85:     for (i=0; i<e820_count; i++) {
                     86:         struct e820entry *e = &e820_list[i];
                     87:         u64 e_end = e->start + e->size;
                     88:         if (start > e_end)
                     89:             continue;
                     90:         // Found position - check if an existing item needs to be split.
                     91:         if (start > e->start) {
                     92:             if (type == e->type) {
                     93:                 // Same type - merge them.
                     94:                 size += start - e->start;
                     95:                 start = e->start;
                     96:             } else {
                     97:                 // Split existing item.
                     98:                 e->size = start - e->start;
                     99:                 i++;
                    100:                 if (e_end > end)
                    101:                     insert_e820(i, end, e_end - end, e->type);
                    102:             }
                    103:         }
                    104:         break;
                    105:     }
                    106:     // Remove/adjust existing items that are overlapping.
                    107:     while (i<e820_count) {
                    108:         struct e820entry *e = &e820_list[i];
                    109:         if (end < e->start)
                    110:             // No overlap - done.
                    111:             break;
                    112:         u64 e_end = e->start + e->size;
                    113:         if (end >= e_end) {
                    114:             // Existing item completely overlapped - remove it.
                    115:             remove_e820(i);
                    116:             continue;
                    117:         }
                    118:         // Not completely overlapped - adjust its start.
                    119:         e->start = end;
                    120:         e->size = e_end - end;
                    121:         if (type == e->type) {
                    122:             // Same type - merge them.
                    123:             size += e->size;
                    124:             remove_e820(i);
                    125:         }
                    126:         break;
                    127:     }
                    128:     // Insert new item.
                    129:     if (type != E820_HOLE)
                    130:         insert_e820(i, start, size, type);
                    131:     //dump_map();
                    132: }
                    133: 
                    134: // Report on final memory locations.
                    135: void
1.1.1.2   root      136: memmap_finalize(void)
1.1       root      137: {
                    138:     dump_map();
                    139: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.