Return to paravirt.h CVS log

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

Annotation of qemu/roms/seabios/src/paravirt.h, revision 1.1.1.3

1.1       root        1: #ifndef __PV_H
                      2: #define __PV_H
                      3: 
                      4: #include "util.h"
                      5: 
                      6: /* This CPUID returns the signature 'KVMKVMKVM' in ebx, ecx, and edx.  It
                      7:  * should be used to determine that a VM is running under KVM.
                      8:  */
                      9: #define KVM_CPUID_SIGNATURE     0x40000000
                     10: 
                     11: static inline int kvm_para_available(void)
                     12: {
                     13:     unsigned int eax, ebx, ecx, edx;
                     14:     char signature[13];
                     15: 
                     16:     cpuid(KVM_CPUID_SIGNATURE, &eax, &ebx, &ecx, &edx);
                     17:     memcpy(signature + 0, &ebx, 4);
                     18:     memcpy(signature + 4, &ecx, 4);
                     19:     memcpy(signature + 8, &edx, 4);
                     20:     signature[12] = 0;
                     21: 
                     22:     if (strcmp(signature, "KVMKVMKVM") == 0)
                     23:         return 1;
                     24: 
                     25:     return 0;
                     26: }
                     27: 
                     28: #define QEMU_CFG_SIGNATURE             0x00
                     29: #define QEMU_CFG_ID                    0x01
                     30: #define QEMU_CFG_UUID                  0x02
                     31: #define QEMU_CFG_NUMA                  0x0d
                     32: #define QEMU_CFG_BOOT_MENU             0x0e
                     33: #define QEMU_CFG_MAX_CPUS              0x0f
                     34: #define QEMU_CFG_FILE_DIR               0x19
                     35: #define QEMU_CFG_ARCH_LOCAL            0x8000
                     36: #define QEMU_CFG_ACPI_TABLES           (QEMU_CFG_ARCH_LOCAL + 0)
                     37: #define QEMU_CFG_SMBIOS_ENTRIES                (QEMU_CFG_ARCH_LOCAL + 1)
                     38: #define QEMU_CFG_IRQ0_OVERRIDE         (QEMU_CFG_ARCH_LOCAL + 2)
1.1.1.2   root       39: #define QEMU_CFG_E820_TABLE            (QEMU_CFG_ARCH_LOCAL + 3)
1.1       root       40: 
                     41: extern int qemu_cfg_present;
                     42: 
                     43: void qemu_cfg_port_probe(void);
                     44: int qemu_cfg_show_boot_menu(void);
                     45: void qemu_cfg_get_uuid(u8 *uuid);
                     46: int qemu_cfg_irq0_override(void);
                     47: u16 qemu_cfg_acpi_additional_tables(void);
                     48: u16 qemu_cfg_next_acpi_table_len(void);
                     49: void *qemu_cfg_next_acpi_table_load(void *addr, u16 len);
                     50: u16 qemu_cfg_smbios_entries(void);
                     51: size_t qemu_cfg_smbios_load_field(int type, size_t offset, void *addr);
                     52: int qemu_cfg_smbios_load_external(int type, char **p, unsigned *nr_structs,
                     53:                                   unsigned *max_struct_size, char *end);
                     54: int qemu_cfg_get_numa_nodes(void);
                     55: void qemu_cfg_get_numa_data(u64 *data, int n);
                     56: u16 qemu_cfg_get_max_cpus(void);
                     57: 
                     58: typedef struct QemuCfgFile {
                     59:     u32  size;        /* file size */
                     60:     u16  select;      /* write this to 0x510 to read it */
                     61:     u16  reserved;
                     62:     char name[56];
                     63: } QemuCfgFile;
                     64: 
1.1.1.2   root       65: struct e820_reservation {
                     66:     u64 address;
                     67:     u64 length;
                     68:     u32 type;
                     69: };
                     70: 
                     71: u32 qemu_cfg_next_prefix_file(const char *prefix, u32 prevselect);
                     72: u32 qemu_cfg_find_file(const char *name);
                     73: int qemu_cfg_size_file(u32 select);
1.1.1.3 ! root       74: const char* qemu_cfg_name_file(u32 select);
1.1.1.2   root       75: int qemu_cfg_read_file(u32 select, void *dst, u32 maxlen);
                     76: 
                     77: // Wrappers that select cbfs or qemu_cfg file interface.
                     78: static inline u32 romfile_findprefix(const char *prefix, u32 previd) {
                     79:     if (CONFIG_COREBOOT)
                     80:         return (u32)cbfs_findprefix(prefix, (void*)previd);
                     81:     return qemu_cfg_next_prefix_file(prefix, previd);
                     82: }
                     83: static inline u32 romfile_find(const char *name) {
                     84:     if (CONFIG_COREBOOT)
                     85:         return (u32)cbfs_finddatafile(name);
                     86:     return qemu_cfg_find_file(name);
                     87: }
                     88: static inline u32 romfile_size(u32 fileid) {
                     89:     if (CONFIG_COREBOOT)
                     90:         return cbfs_datasize((void*)fileid);
                     91:     return qemu_cfg_size_file(fileid);
                     92: }
                     93: static inline int romfile_copy(u32 fileid, void *dst, u32 maxlen) {
                     94:     if (CONFIG_COREBOOT)
                     95:         return cbfs_copyfile((void*)fileid, dst, maxlen);
                     96:     return qemu_cfg_read_file(fileid, dst, maxlen);
                     97: }
1.1.1.3 ! root       98: static inline const char* romfile_name(u32 fileid) {
        !            99:     if (CONFIG_COREBOOT)
        !           100:         return cbfs_filename((void*)fileid);
        !           101:     return qemu_cfg_name_file(fileid);
        !           102: }
        !           103: void *romfile_loadfile(const char *name, int *psize);
1.1.1.2   root      104: 
                    105: u32 qemu_cfg_e820_entries(void);
                    106: void* qemu_cfg_e820_load_next(void *addr);
1.1       root      107: 
                    108: #endif

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