target-arm: Set CPU has_el3 prop during virt init

[qemu.git] / arch_init.c

diff --git a/arch_init.c b/arch_init.c
index 685ba0e268c8eba72c8fbd91a63518c5d7bc45cd..7680d28be47b7c9e696fba0303daa8aaae08b150 100644 (file)
--- a/arch_init.c
+++ b/arch_init.c
@@ -104,6 +104,8 @@ int graphic_depth = 32;
 #define QEMU_ARCH QEMU_ARCH_XTENSA
 #elif defined(TARGET_UNICORE32)
 #define QEMU_ARCH QEMU_ARCH_UNICORE32
 #define QEMU_ARCH QEMU_ARCH_XTENSA
 #elif defined(TARGET_UNICORE32)
 #define QEMU_ARCH QEMU_ARCH_UNICORE32

+#elif defined(TARGET_TRICORE)
+#define QEMU_ARCH QEMU_ARCH_TRICORE

 #endif
 
 const uint32_t arch_type = QEMU_ARCH;
 #endif
 
 const uint32_t arch_type = QEMU_ARCH;


@@ -484,15 +486,23 @@ static void migration_bitmap_sync_range(ram_addr_t start, ram_addr_t length)
 
 
 /* Needs iothread lock! */
 
 
 /* Needs iothread lock! */

+/* Fix me: there are too many global variables used in migration process. */
+static int64_t start_time;
+static int64_t bytes_xfer_prev;
+static int64_t num_dirty_pages_period;
+
+static void migration_bitmap_sync_init(void)
+{
+    start_time = 0;
+    bytes_xfer_prev = 0;
+    num_dirty_pages_period = 0;
+}

 
 static void migration_bitmap_sync(void)
 {
     RAMBlock *block;
     uint64_t num_dirty_pages_init = migration_dirty_pages;
     MigrationState *s = migrate_get_current();
 
 static void migration_bitmap_sync(void)
 {
     RAMBlock *block;
     uint64_t num_dirty_pages_init = migration_dirty_pages;
     MigrationState *s = migrate_get_current();

-    static int64_t start_time;
-    static int64_t bytes_xfer_prev;
-    static int64_t num_dirty_pages_period;

     int64_t end_time;
     int64_t bytes_xfer_now;
     static uint64_t xbzrle_cache_miss_prev;
     int64_t end_time;
     int64_t bytes_xfer_now;
     static uint64_t xbzrle_cache_miss_prev;


@@ -739,7 +749,6 @@ static void migration_end(void)
     XBZRLE_cache_lock();
     if (XBZRLE.cache) {
         cache_fini(XBZRLE.cache);
     XBZRLE_cache_lock();
     if (XBZRLE.cache) {
         cache_fini(XBZRLE.cache);

-        g_free(XBZRLE.cache);

         g_free(XBZRLE.encoded_buf);
         g_free(XBZRLE.current_buf);
         XBZRLE.cache = NULL;
         g_free(XBZRLE.encoded_buf);
         g_free(XBZRLE.current_buf);
         XBZRLE.cache = NULL;


@@ -773,6 +782,7 @@ static int ram_save_setup(QEMUFile *f, void *opaque)
     mig_throttle_on = false;
     dirty_rate_high_cnt = 0;
     bitmap_sync_count = 0;
     mig_throttle_on = false;
     dirty_rate_high_cnt = 0;
     bitmap_sync_count = 0;

+    migration_bitmap_sync_init();

 
     if (migrate_use_xbzrle()) {
         XBZRLE_cache_lock();
 
     if (migrate_use_xbzrle()) {
         XBZRLE_cache_lock();


@@ -975,12 +985,12 @@ static int load_xbzrle(QEMUFile *f, ram_addr_t addr, void *host)
     xh_len = qemu_get_be16(f);
 
     if (xh_flags != ENCODING_FLAG_XBZRLE) {
     xh_len = qemu_get_be16(f);
 
     if (xh_flags != ENCODING_FLAG_XBZRLE) {

-        fprintf(stderr, "Failed to load XBZRLE page - wrong compression!\n");
+        error_report("Failed to load XBZRLE page - wrong compression!");

         return -1;
     }
 
     if (xh_len > TARGET_PAGE_SIZE) {
         return -1;
     }
 
     if (xh_len > TARGET_PAGE_SIZE) {

-        fprintf(stderr, "Failed to load XBZRLE page - len overflow!\n");
+        error_report("Failed to load XBZRLE page - len overflow!");

         return -1;
     }
     /* load data and decode */
         return -1;
     }
     /* load data and decode */


@@ -989,7 +999,7 @@ static int load_xbzrle(QEMUFile *f, ram_addr_t addr, void *host)
     /* decode RLE */
     if (xbzrle_decode_buffer(xbzrle_decoded_buf, xh_len, host,
                              TARGET_PAGE_SIZE) == -1) {
     /* decode RLE */
     if (xbzrle_decode_buffer(xbzrle_decoded_buf, xh_len, host,
                              TARGET_PAGE_SIZE) == -1) {

-        fprintf(stderr, "Failed to load XBZRLE page - decode error!\n");
+        error_report("Failed to load XBZRLE page - decode error!");

         return -1;
     }
 
         return -1;
     }
 


@@ -1005,8 +1015,8 @@ static inline void *host_from_stream_offset(QEMUFile *f,
     uint8_t len;
 
     if (flags & RAM_SAVE_FLAG_CONTINUE) {
     uint8_t len;
 
     if (flags & RAM_SAVE_FLAG_CONTINUE) {

-        if (!block) {
-            fprintf(stderr, "Ack, bad migration stream!\n");
+        if (!block || block->length <= offset) {
+            error_report("Ack, bad migration stream!");

             return NULL;
         }
 
             return NULL;
         }
 


@@ -1018,11 +1028,12 @@ static inline void *host_from_stream_offset(QEMUFile *f,
     id[len] = 0;
 
     QTAILQ_FOREACH(block, &ram_list.blocks, next) {
     id[len] = 0;
 
     QTAILQ_FOREACH(block, &ram_list.blocks, next) {

-        if (!strncmp(id, block->idstr, sizeof(id)))
+        if (!strncmp(id, block->idstr, sizeof(id)) && block->length > offset) {

             return memory_region_get_ram_ptr(block->mr) + offset;
             return memory_region_get_ram_ptr(block->mr) + offset;

+        }

     }
 
     }
 

-    fprintf(stderr, "Can't find block %s!\n", id);
+    error_report("Can't find block %s!", id);

     return NULL;
 }
 
     return NULL;
 }
 


@@ -1039,33 +1050,33 @@ void ram_handle_compressed(void *host, uint8_t ch, uint64_t size)
 
 static int ram_load(QEMUFile *f, void *opaque, int version_id)
 {
 
 static int ram_load(QEMUFile *f, void *opaque, int version_id)
 {

-    ram_addr_t addr;
-    int flags, ret = 0;
-    int error;
+    int flags = 0, ret = 0;

     static uint64_t seq_iter;
 
     seq_iter++;
 
     if (version_id != 4) {
         ret = -EINVAL;
     static uint64_t seq_iter;
 
     seq_iter++;
 
     if (version_id != 4) {
         ret = -EINVAL;

-        goto done;

     }
 
     }
 

-    do {
-        addr = qemu_get_be64(f);
+    while (!ret && !(flags & RAM_SAVE_FLAG_EOS)) {
+        ram_addr_t addr, total_ram_bytes;
+        void *host;
+        uint8_t ch;

 
 

+        addr = qemu_get_be64(f);

         flags = addr & ~TARGET_PAGE_MASK;
         addr &= TARGET_PAGE_MASK;
 
         flags = addr & ~TARGET_PAGE_MASK;
         addr &= TARGET_PAGE_MASK;
 

-        if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
+        switch (flags & ~RAM_SAVE_FLAG_CONTINUE) {
+        case RAM_SAVE_FLAG_MEM_SIZE:

             /* Synchronize RAM block list */
             /* Synchronize RAM block list */

-            char id[256];
-            ram_addr_t length;
-            ram_addr_t total_ram_bytes = addr;
-
-            while (total_ram_bytes) {
+            total_ram_bytes = addr;
+            while (!ret && total_ram_bytes) {

                 RAMBlock *block;
                 uint8_t len;
                 RAMBlock *block;
                 uint8_t len;

+                char id[256];
+                ram_addr_t length;

 
                 len = qemu_get_byte(f);
                 qemu_get_buffer(f, (uint8_t *)id, len);
 
                 len = qemu_get_byte(f);
                 qemu_get_buffer(f, (uint8_t *)id, len);


@@ -1075,72 +1086,77 @@ static int ram_load(QEMUFile *f, void *opaque, int version_id)
                 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
                     if (!strncmp(id, block->idstr, sizeof(id))) {
                         if (block->length != length) {
                 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
                     if (!strncmp(id, block->idstr, sizeof(id))) {
                         if (block->length != length) {

-                            fprintf(stderr,
-                                    "Length mismatch: %s: " RAM_ADDR_FMT
-                                    " in != " RAM_ADDR_FMT "\n", id, length,
-                                    block->length);
+                            error_report("Length mismatch: %s: 0x" RAM_ADDR_FMT
+                                         " in != 0x" RAM_ADDR_FMT, id, length,
+                                         block->length);

                             ret =  -EINVAL;
                             ret =  -EINVAL;

-                            goto done;

                         }
                         break;
                     }
                 }
 
                 if (!block) {
                         }
                         break;
                     }
                 }
 
                 if (!block) {

-                    fprintf(stderr, "Unknown ramblock \"%s\", cannot "
-                            "accept migration\n", id);
+                    error_report("Unknown ramblock \"%s\", cannot "
+                                 "accept migration", id);

                     ret = -EINVAL;
                     ret = -EINVAL;

-                    goto done;

                 }
 
                 total_ram_bytes -= length;
             }
                 }
 
                 total_ram_bytes -= length;
             }

-        }
-
-        if (flags & RAM_SAVE_FLAG_COMPRESS) {
-            void *host;
-            uint8_t ch;
-
+            break;
+        case RAM_SAVE_FLAG_COMPRESS:

             host = host_from_stream_offset(f, addr, flags);
             if (!host) {
             host = host_from_stream_offset(f, addr, flags);
             if (!host) {

+                error_report("Illegal RAM offset " RAM_ADDR_FMT, addr);

                 ret = -EINVAL;
                 ret = -EINVAL;

-                goto done;
+                break;

             }
 
             ch = qemu_get_byte(f);
             ram_handle_compressed(host, ch, TARGET_PAGE_SIZE);
             }
 
             ch = qemu_get_byte(f);
             ram_handle_compressed(host, ch, TARGET_PAGE_SIZE);

-        } else if (flags & RAM_SAVE_FLAG_PAGE) {
-            void *host;
-
+            break;
+        case RAM_SAVE_FLAG_PAGE:

             host = host_from_stream_offset(f, addr, flags);
             if (!host) {
             host = host_from_stream_offset(f, addr, flags);
             if (!host) {

+                error_report("Illegal RAM offset " RAM_ADDR_FMT, addr);

                 ret = -EINVAL;
                 ret = -EINVAL;

-                goto done;
+                break;

             }
 
             qemu_get_buffer(f, host, TARGET_PAGE_SIZE);
             }
 
             qemu_get_buffer(f, host, TARGET_PAGE_SIZE);

-        } else if (flags & RAM_SAVE_FLAG_XBZRLE) {
-            void *host = host_from_stream_offset(f, addr, flags);
+            break;
+        case RAM_SAVE_FLAG_XBZRLE:
+            host = host_from_stream_offset(f, addr, flags);

             if (!host) {
             if (!host) {

+                error_report("Illegal RAM offset " RAM_ADDR_FMT, addr);

                 ret = -EINVAL;
                 ret = -EINVAL;

-                goto done;
+                break;

             }
 
             if (load_xbzrle(f, addr, host) < 0) {
             }
 
             if (load_xbzrle(f, addr, host) < 0) {

+                error_report("Failed to decompress XBZRLE page at "
+                             RAM_ADDR_FMT, addr);
+                ret = -EINVAL;
+                break;
+            }
+            break;
+        case RAM_SAVE_FLAG_EOS:
+            /* normal exit */
+            break;
+        default:
+            if (flags & RAM_SAVE_FLAG_HOOK) {
+                ram_control_load_hook(f, flags);
+            } else {
+                error_report("Unknown combination of migration flags: %#x",
+                             flags);

                 ret = -EINVAL;
                 ret = -EINVAL;

-                goto done;

             }
             }

-        } else if (flags & RAM_SAVE_FLAG_HOOK) {
-            ram_control_load_hook(f, flags);

         }
         }

-        error = qemu_file_get_error(f);
-        if (error) {
-            ret = error;
-            goto done;
+        if (!ret) {
+            ret = qemu_file_get_error(f);

         }
         }

-    } while (!(flags & RAM_SAVE_FLAG_EOS));
+    }

 
 

-done:

     DPRINTF("Completed load of VM with exit code %d seq iteration "
             "%" PRIu64 "\n", ret, seq_iter);
     return ret;
     DPRINTF("Completed load of VM with exit code %d seq iteration "
             "%" PRIu64 "\n", ret, seq_iter);
     return ret;


@@ -1243,12 +1259,11 @@ void select_soundhw(const char *optarg)
 
             if (!c->name) {
                 if (l > 80) {
 
             if (!c->name) {
                 if (l > 80) {

-                    fprintf(stderr,
-                            "Unknown sound card name (too big to show)\n");
+                    error_report("Unknown sound card name (too big to show)");

                 }
                 else {
                 }
                 else {

-                    fprintf(stderr, "Unknown sound card name `%.*s'\n",
-                            (int) l, p);
+                    error_report("Unknown sound card name `%.*s'",
+                                 (int) l, p);

                 }
                 bad_card = 1;
             }
                 }
                 bad_card = 1;
             }


@@ -1271,13 +1286,13 @@ void audio_init(void)
         if (c->enabled) {
             if (c->isa) {
                 if (!isa_bus) {
         if (c->enabled) {
             if (c->isa) {
                 if (!isa_bus) {

-                    fprintf(stderr, "ISA bus not available for %s\n", c->name);
+                    error_report("ISA bus not available for %s", c->name);

                     exit(1);
                 }
                 c->init.init_isa(isa_bus);
             } else {
                 if (!pci_bus) {
                     exit(1);
                 }
                 c->init.init_isa(isa_bus);
             } else {
                 if (!pci_bus) {

-                    fprintf(stderr, "PCI bus not available for %s\n", c->name);
+                    error_report("PCI bus not available for %s", c->name);

                     exit(1);
                 }
                 c->init.init_pci(pci_bus);
                     exit(1);
                 }
                 c->init.init_pci(pci_bus);


@@ -1334,11 +1349,6 @@ void cpudef_init(void)
 #endif
 }
 
 #endif
 }
 

-int tcg_available(void)
-{
-    return 1;
-}
-

 int kvm_available(void)
 {
 #ifdef CONFIG_KVM
 int kvm_available(void)
 {
 #ifdef CONFIG_KVM