target/i386/cpu-sysemu.c

   1 /*
   2  *  i386 CPUID, CPU class, definitions, models: sysemu-only code
   3  *
   4  *  Copyright (c) 2003 Fabrice Bellard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "qemu/osdep.h"
  21 #include "cpu.h"
  22 #include "sysemu/xen.h"
  23 #include "sysemu/whpx.h"
  24 #include "kvm/kvm_i386.h"
  25 #include "qapi/error.h"
  26 #include "qapi/qapi-visit-run-state.h"
  27 #include "qapi/qmp/qdict.h"
  28 #include "qom/qom-qobject.h"
  29 #include "qapi/qapi-commands-machine-target.h"
  30 #include "hw/qdev-properties.h"
  31
  32 #include "exec/address-spaces.h"
  33 #include "hw/i386/apic_internal.h"
  34
  35 #include "cpu-internal.h"
  36
  37 /* Return a QDict containing keys for all properties that can be included
  38  * in static expansion of CPU models. All properties set by x86_cpu_load_model()
  39  * must be included in the dictionary.
  40  */
  41 static QDict *x86_cpu_static_props(void)
  42 {
  43     FeatureWord w;
  44     int i;
  45     static const char *props[] = {
  46         "min-level",
  47         "min-xlevel",
  48         "family",
  49         "model",
  50         "stepping",
  51         "model-id",
  52         "vendor",
  53         "lmce",
  54         NULL,
  55     };
  56     static QDict *d;
  57
  58     if (d) {
  59         return d;
  60     }
  61
  62     d = qdict_new();
  63     for (i = 0; props[i]; i++) {
  64         qdict_put_null(d, props[i]);
  65     }
  66
  67     for (w = 0; w < FEATURE_WORDS; w++) {
  68         FeatureWordInfo *fi = &feature_word_info[w];
  69         int bit;
  70         for (bit = 0; bit < 64; bit++) {
  71             if (!fi->feat_names[bit]) {
  72                 continue;
  73             }
  74             qdict_put_null(d, fi->feat_names[bit]);
  75         }
  76     }
  77
  78     return d;
  79 }
  80
  81 /* Add an entry to @props dict, with the value for property. */
  82 static void x86_cpu_expand_prop(X86CPU *cpu, QDict *props, const char *prop)
  83 {
  84     QObject *value = object_property_get_qobject(OBJECT(cpu), prop,
  85                                                  &error_abort);
  86
  87     qdict_put_obj(props, prop, value);
  88 }
  89
  90 /* Convert CPU model data from X86CPU object to a property dictionary
  91  * that can recreate exactly the same CPU model.
  92  */
  93 static void x86_cpu_to_dict(X86CPU *cpu, QDict *props)
  94 {
  95     QDict *sprops = x86_cpu_static_props();
  96     const QDictEntry *e;
  97
  98     for (e = qdict_first(sprops); e; e = qdict_next(sprops, e)) {
  99         const char *prop = qdict_entry_key(e);
 100         x86_cpu_expand_prop(cpu, props, prop);
 101     }
 102 }
 103
 104 /* Convert CPU model data from X86CPU object to a property dictionary
 105  * that can recreate exactly the same CPU model, including every
 106  * writeable QOM property.
 107  */
 108 static void x86_cpu_to_dict_full(X86CPU *cpu, QDict *props)
 109 {
 110     ObjectPropertyIterator iter;
 111     ObjectProperty *prop;
 112
 113     object_property_iter_init(&iter, OBJECT(cpu));
 114     while ((prop = object_property_iter_next(&iter))) {
 115         /* skip read-only or write-only properties */
 116         if (!prop->get || !prop->set) {
 117             continue;
 118         }
 119
 120         /* "hotplugged" is the only property that is configurable
 121          * on the command-line but will be set differently on CPUs
 122          * created using "-cpu ... -smp ..." and by CPUs created
 123          * on the fly by x86_cpu_from_model() for querying. Skip it.
 124          */
 125         if (!strcmp(prop->name, "hotplugged")) {
 126             continue;
 127         }
 128         x86_cpu_expand_prop(cpu, props, prop->name);
 129     }
 130 }
 131
 132 static void object_apply_props(Object *obj, QDict *props, Error **errp)
 133 {
 134     const QDictEntry *prop;
 135
 136     for (prop = qdict_first(props); prop; prop = qdict_next(props, prop)) {
 137         if (!object_property_set_qobject(obj, qdict_entry_key(prop),
 138                                          qdict_entry_value(prop), errp)) {
 139             break;
 140         }
 141     }
 142 }
 143
 144 /* Create X86CPU object according to model+props specification */
 145 static X86CPU *x86_cpu_from_model(const char *model, QDict *props, Error **errp)
 146 {
 147     X86CPU *xc = NULL;
 148     X86CPUClass *xcc;
 149     Error *err = NULL;
 150
 151     xcc = X86_CPU_CLASS(cpu_class_by_name(TYPE_X86_CPU, model));
 152     if (xcc == NULL) {
 153         error_setg(&err, "CPU model '%s' not found", model);
 154         goto out;
 155     }
 156
 157     xc = X86_CPU(object_new_with_class(OBJECT_CLASS(xcc)));
 158     if (props) {
 159         object_apply_props(OBJECT(xc), props, &err);
 160         if (err) {
 161             goto out;
 162         }
 163     }
 164
 165     x86_cpu_expand_features(xc, &err);
 166     if (err) {
 167         goto out;
 168     }
 169
 170 out:
 171     if (err) {
 172         error_propagate(errp, err);
 173         object_unref(OBJECT(xc));
 174         xc = NULL;
 175     }
 176     return xc;
 177 }
 178
 179 CpuModelExpansionInfo *
 180 qmp_query_cpu_model_expansion(CpuModelExpansionType type,
 181                                                       CpuModelInfo *model,
 182                                                       Error **errp)
 183 {
 184     X86CPU *xc = NULL;
 185     Error *err = NULL;
 186     CpuModelExpansionInfo *ret = g_new0(CpuModelExpansionInfo, 1);
 187     QDict *props = NULL;
 188     const char *base_name;
 189
 190     xc = x86_cpu_from_model(model->name,
 191                             model->has_props ?
 192                                 qobject_to(QDict, model->props) :
 193                                 NULL, &err);
 194     if (err) {
 195         goto out;
 196     }
 197
 198     props = qdict_new();
 199     ret->model = g_new0(CpuModelInfo, 1);
 200     ret->model->props = QOBJECT(props);
 201     ret->model->has_props = true;
 202
 203     switch (type) {
 204     case CPU_MODEL_EXPANSION_TYPE_STATIC:
 205         /* Static expansion will be based on "base" only */
 206         base_name = "base";
 207         x86_cpu_to_dict(xc, props);
 208     break;
 209     case CPU_MODEL_EXPANSION_TYPE_FULL:
 210         /* As we don't return every single property, full expansion needs
 211          * to keep the original model name+props, and add extra
 212          * properties on top of that.
 213          */
 214         base_name = model->name;
 215         x86_cpu_to_dict_full(xc, props);
 216     break;
 217     default:
 218         error_setg(&err, "Unsupported expansion type");
 219         goto out;
 220     }
 221
 222     x86_cpu_to_dict(xc, props);
 223
 224     ret->model->name = g_strdup(base_name);
 225
 226 out:
 227     object_unref(OBJECT(xc));
 228     if (err) {
 229         error_propagate(errp, err);
 230         qapi_free_CpuModelExpansionInfo(ret);
 231         ret = NULL;
 232     }
 233     return ret;
 234 }
 235
 236 void cpu_clear_apic_feature(CPUX86State *env)
 237 {
 238     env->features[FEAT_1_EDX] &= ~CPUID_APIC;
 239 }
 240
 241 bool cpu_is_bsp(X86CPU *cpu)
 242 {
 243     return cpu_get_apic_base(cpu->apic_state) & MSR_IA32_APICBASE_BSP;
 244 }
 245
 246 /* TODO: remove me, when reset over QOM tree is implemented */
 247 void x86_cpu_machine_reset_cb(void *opaque)
 248 {
 249     X86CPU *cpu = opaque;
 250     cpu_reset(CPU(cpu));
 251 }
 252
 253 APICCommonClass *apic_get_class(void)
 254 {
 255     const char *apic_type = "apic";
 256
 257     /* TODO: in-kernel irqchip for hvf */
 258     if (kvm_apic_in_kernel()) {
 259         apic_type = "kvm-apic";
 260     } else if (xen_enabled()) {
 261         apic_type = "xen-apic";
 262     } else if (whpx_apic_in_platform()) {
 263         apic_type = "whpx-apic";
 264     }
 265
 266     return APIC_COMMON_CLASS(object_class_by_name(apic_type));
 267 }
 268
 269 void x86_cpu_apic_create(X86CPU *cpu, Error **errp)
 270 {
 271     APICCommonState *apic;
 272     ObjectClass *apic_class = OBJECT_CLASS(apic_get_class());
 273
 274     cpu->apic_state = DEVICE(object_new_with_class(apic_class));
 275
 276     object_property_add_child(OBJECT(cpu), "lapic",
 277                               OBJECT(cpu->apic_state));
 278     object_unref(OBJECT(cpu->apic_state));
 279
 280     qdev_prop_set_uint32(cpu->apic_state, "id", cpu->apic_id);
 281     /* TODO: convert to link<> */
 282     apic = APIC_COMMON(cpu->apic_state);
 283     apic->cpu = cpu;
 284     apic->apicbase = APIC_DEFAULT_ADDRESS | MSR_IA32_APICBASE_ENABLE;
 285 }
 286
 287 void x86_cpu_apic_realize(X86CPU *cpu, Error **errp)
 288 {
 289     APICCommonState *apic;
 290     static bool apic_mmio_map_once;
 291
 292     if (cpu->apic_state == NULL) {
 293         return;
 294     }
 295     qdev_realize(DEVICE(cpu->apic_state), NULL, errp);
 296
 297     /* Map APIC MMIO area */
 298     apic = APIC_COMMON(cpu->apic_state);
 299     if (!apic_mmio_map_once) {
 300         memory_region_add_subregion_overlap(get_system_memory(),
 301                                             apic->apicbase &
 302                                             MSR_IA32_APICBASE_BASE,
 303                                             &apic->io_memory,
 304                                             0x1000);
 305         apic_mmio_map_once = true;
 306      }
 307 }
 308
 309 GuestPanicInformation *x86_cpu_get_crash_info(CPUState *cs)
 310 {
 311     X86CPU *cpu = X86_CPU(cs);
 312     CPUX86State *env = &cpu->env;
 313     GuestPanicInformation *panic_info = NULL;
 314
 315     if (env->features[FEAT_HYPERV_EDX] & HV_GUEST_CRASH_MSR_AVAILABLE) {
 316         panic_info = g_malloc0(sizeof(GuestPanicInformation));
 317
 318         panic_info->type = GUEST_PANIC_INFORMATION_TYPE_HYPER_V;
 319
 320         assert(HV_CRASH_PARAMS >= 5);
 321         panic_info->u.hyper_v.arg1 = env->msr_hv_crash_params[0];
 322         panic_info->u.hyper_v.arg2 = env->msr_hv_crash_params[1];
 323         panic_info->u.hyper_v.arg3 = env->msr_hv_crash_params[2];
 324         panic_info->u.hyper_v.arg4 = env->msr_hv_crash_params[3];
 325         panic_info->u.hyper_v.arg5 = env->msr_hv_crash_params[4];
 326     }
 327
 328     return panic_info;
 329 }
 330 void x86_cpu_get_crash_info_qom(Object *obj, Visitor *v,
 331                                 const char *name, void *opaque,
 332                                 Error **errp)
 333 {
 334     CPUState *cs = CPU(obj);
 335     GuestPanicInformation *panic_info;
 336
 337     if (!cs->crash_occurred) {
 338         error_setg(errp, "No crash occured");
 339         return;
 340     }
 341
 342     panic_info = x86_cpu_get_crash_info(cs);
 343     if (panic_info == NULL) {
 344         error_setg(errp, "No crash information");
 345         return;
 346     }
 347
 348     visit_type_GuestPanicInformation(v, "crash-information", &panic_info,
 349                                      errp);
 350     qapi_free_GuestPanicInformation(panic_info);
 351 }
 352