Return to linuxbios_info.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / libopenbios

Annotation of qemu/roms/openbios/libopenbios/linuxbios_info.c, revision 1.1

1.1     ! root        1: /* Adapted from Etherboot 5.1.8 */
        !             2: 
        !             3: #include "config.h"
        !             4: #include "sysinclude.h"
        !             5: #include "asm/types.h"
        !             6: #include "asm/io.h"
        !             7: #include "linuxbios.h"
        !             8: #include "libopenbios/ipchecksum.h"
        !             9: #include "libopenbios/sys_info.h"
        !            10: 
        !            11: #ifdef CONFIG_DEBUG_BOOT
        !            12: #define debug printk
        !            13: #else
        !            14: #define debug(x...)
        !            15: #endif
        !            16: 
        !            17: #define for_each_lbrec(head, rec) \
        !            18:        for(rec = (struct lb_record *)(((char *)head) + sizeof(*head)); \
        !            19:                (((char *)rec) < (((char *)head) + sizeof(*head) + head->table_bytes))  && \
        !            20:                (rec->size >= 1) && \
        !            21:                ((((char *)rec) + rec->size) <= (((char *)head) + sizeof(*head) + head->table_bytes)); \
        !            22:                rec = (struct lb_record *)(((char *)rec) + rec->size))
        !            23: 
        !            24: static void convert_memmap(struct lb_memory *lbmem, struct sys_info *info)
        !            25: {
        !            26:     int lbcount;
        !            27:     int i;
        !            28: 
        !            29:     lbcount = lbmem->size / sizeof(struct lb_memory_range);
        !            30:     info->memrange = malloc(lbcount * sizeof(struct memrange));
        !            31:     info->n_memranges = 0;
        !            32:     for (i = 0; i < lbcount; i++) {
        !            33:        debug("%#016llx %#016llx %d\n",
        !            34:               (long long)lbmem->map[i].start, (long long)lbmem->map[i].size,
        !            35:               (int) lbmem->map[i].type);
        !            36:        if (lbmem->map[i].type != LB_MEM_RAM)
        !            37:            continue;
        !            38:        info->memrange[info->n_memranges].base = lbmem->map[i].start;
        !            39:        info->memrange[info->n_memranges].size = lbmem->map[i].size;
        !            40:        info->n_memranges++;
        !            41:     }
        !            42: }
        !            43: 
        !            44: static int read_lbtable(struct lb_header *head, struct sys_info *info)
        !            45: {
        !            46:        int retval = 0;
        !            47: 
        !            48:        /* Read linuxbios tables... */
        !            49:        struct lb_record *rec;
        !            50: 
        !            51:        for_each_lbrec(head, rec) {
        !            52:                switch(rec->tag) {
        !            53:                case LB_TAG_MEMORY:
        !            54:                        convert_memmap((struct lb_memory *) rec, info);
        !            55:                        retval = 1;
        !            56:                        break;
        !            57:                };
        !            58:        }
        !            59:        return retval;
        !            60: }
        !            61: 
        !            62: static unsigned long count_lb_records(void *start, unsigned long length)
        !            63: {
        !            64:        struct lb_record *rec;
        !            65:        void *end;
        !            66:        unsigned long count;
        !            67:        count = 0;
        !            68:        end = ((char *)start) + length;
        !            69:        for(rec = start; ((void *)rec < end) &&
        !            70:                ((signed long)rec->size <=
        !            71:                  ((signed long)end - (signed long)rec));
        !            72:                rec = (void *)(((char *)rec) + rec->size)) {
        !            73:                count++;
        !            74:        }
        !            75:        return count;
        !            76: }
        !            77: 
        !            78: static int find_lb_table(void *start, void *end, struct lb_header **result)
        !            79: {
        !            80:        unsigned char *ptr;
        !            81:        /* For now be stupid.... */
        !            82:        for(ptr = start; (void *)ptr < end; ptr += 16) {
        !            83:                struct lb_header *head = (struct lb_header *)ptr;
        !            84:                if (    (head->signature[0] != 'L') ||
        !            85:                        (head->signature[1] != 'B') ||
        !            86:                        (head->signature[2] != 'I') ||
        !            87:                        (head->signature[3] != 'O')) {
        !            88:                        continue;
        !            89:                }
        !            90:                if (head->header_bytes != sizeof(*head))
        !            91:                        continue;
        !            92:                debug("Found canidate at: %p\n", head);
        !            93:                if (ipchksum((uint16_t *)head, sizeof(*head)) != 0)
        !            94:                        continue;
        !            95:                debug("header checksum o.k.\n");
        !            96:                if (ipchksum((uint16_t *)(ptr + sizeof(*head)), head->table_bytes) !=
        !            97:                        head->table_checksum) {
        !            98:                        continue;
        !            99:                }
        !           100:                debug("table checksum o.k.\n");
        !           101:                if (count_lb_records(ptr + sizeof(*head), head->table_bytes) !=
        !           102:                        head->table_entries) {
        !           103:                        continue;
        !           104:                }
        !           105:                debug("record count o.k.\n");
        !           106:                *result = head;
        !           107:                return 1;
        !           108:        };
        !           109:        return 0;
        !           110: }
        !           111: 
        !           112: void collect_linuxbios_info(struct sys_info *info)
        !           113: {
        !           114:        struct lb_header *lb_table;
        !           115:        int found;
        !           116:        debug("Searching for LinuxBIOS tables...\n");
        !           117:        found = 0;
        !           118:        if (!found) {
        !           119:                found = find_lb_table(phys_to_virt(0x00000), phys_to_virt(0x01000), &lb_table);
        !           120:        }
        !           121:        if (!found) {
        !           122:                found = find_lb_table(phys_to_virt(0xf0000), phys_to_virt(0x100000), &lb_table);
        !           123:        }
        !           124:        if (!found)
        !           125:                return;
        !           126: 
        !           127:        debug("Found LinuxBIOS table at: %p\n", lb_table);
        !           128:        info->firmware = "LinuxBIOS";
        !           129:        read_lbtable(lb_table, info);
        !           130: }

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