1 /* 2 * QEMU monitor.c for ARM. 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a copy 5 * of this software and associated documentation files (the "Software"), to deal 6 * in the Software without restriction, including without limitation the rights 7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 8 * copies of the Software, and to permit persons to whom the Software is 9 * furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice shall be included in 12 * all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 20 * THE SOFTWARE. 21 */ 22 23 #include "qemu/osdep.h" 24 #include "hw/boards.h" 25 #include "kvm_arm.h" 26 #include "qapi/error.h" 27 #include "qapi/visitor.h" 28 #include "qapi/qobject-input-visitor.h" 29 #include "qapi/qapi-commands-machine.h" 30 #include "qapi/qapi-commands-misc-arm.h" 31 #include "qobject/qdict.h" 32 #include "qom/qom-qobject.h" 33 #include "cpu.h" 34 35 static GICCapability *gic_cap_new(int version) 36 { 37 GICCapability *cap = g_new0(GICCapability, 1); 38 cap->version = version; 39 /* by default, support none */ 40 cap->emulated = false; 41 cap->kernel = false; 42 return cap; 43 } 44 45 static inline void gic_cap_kvm_probe(GICCapability *v2, GICCapability *v3) 46 { 47 #ifdef CONFIG_KVM 48 int fdarray[3]; 49 50 if (!kvm_arm_create_scratch_host_vcpu(fdarray, NULL)) { 51 return; 52 } 53 54 /* Test KVM GICv2 */ 55 if (kvm_device_supported(fdarray[1], KVM_DEV_TYPE_ARM_VGIC_V2)) { 56 v2->kernel = true; 57 } 58 59 /* Test KVM GICv3 */ 60 if (kvm_device_supported(fdarray[1], KVM_DEV_TYPE_ARM_VGIC_V3)) { 61 v3->kernel = true; 62 } 63 64 kvm_arm_destroy_scratch_host_vcpu(fdarray); 65 #endif 66 } 67 68 GICCapabilityList *qmp_query_gic_capabilities(Error **errp) 69 { 70 GICCapabilityList *head = NULL; 71 GICCapability *v2 = gic_cap_new(2), *v3 = gic_cap_new(3); 72 73 v2->emulated = true; 74 v3->emulated = true; 75 76 gic_cap_kvm_probe(v2, v3); 77 78 QAPI_LIST_PREPEND(head, v2); 79 QAPI_LIST_PREPEND(head, v3); 80 81 return head; 82 } 83 84 QEMU_BUILD_BUG_ON(ARM_MAX_VQ > 16); 85 86 /* 87 * These are cpu model features we want to advertise. The order here 88 * matters as this is the order in which qmp_query_cpu_model_expansion 89 * will attempt to set them. If there are dependencies between features, 90 * then the order that considers those dependencies must be used. 91 */ 92 static const char *cpu_model_advertised_features[] = { 93 "aarch64", "pmu", "sve", 94 "sve128", "sve256", "sve384", "sve512", 95 "sve640", "sve768", "sve896", "sve1024", "sve1152", "sve1280", 96 "sve1408", "sve1536", "sve1664", "sve1792", "sve1920", "sve2048", 97 "kvm-no-adjvtime", "kvm-steal-time", 98 "pauth", "pauth-impdef", "pauth-qarma3", "pauth-qarma5", 99 NULL 100 }; 101 102 CpuModelExpansionInfo *qmp_query_cpu_model_expansion(CpuModelExpansionType type, 103 CpuModelInfo *model, 104 Error **errp) 105 { 106 CpuModelExpansionInfo *expansion_info; 107 const QDict *qdict_in; 108 QDict *qdict_out; 109 ObjectClass *oc; 110 Object *obj; 111 const char *name; 112 int i; 113 114 if (type != CPU_MODEL_EXPANSION_TYPE_FULL) { 115 error_setg(errp, "The requested expansion type is not supported"); 116 return NULL; 117 } 118 119 if (!kvm_enabled() && !strcmp(model->name, "host")) { 120 error_setg(errp, "The CPU type '%s' requires KVM", model->name); 121 return NULL; 122 } 123 124 oc = cpu_class_by_name(TYPE_ARM_CPU, model->name); 125 if (!oc) { 126 error_setg(errp, "The CPU type '%s' is not a recognized ARM CPU type", 127 model->name); 128 return NULL; 129 } 130 131 if (kvm_enabled()) { 132 bool supported = false; 133 134 if (!strcmp(model->name, "host") || !strcmp(model->name, "max")) { 135 /* These are kvmarm's recommended cpu types */ 136 supported = true; 137 } else if (current_machine->cpu_type) { 138 const char *cpu_type = current_machine->cpu_type; 139 int len = strlen(cpu_type) - strlen(ARM_CPU_TYPE_SUFFIX); 140 141 if (strlen(model->name) == len && 142 !strncmp(model->name, cpu_type, len)) { 143 /* KVM is enabled and we're using this type, so it works. */ 144 supported = true; 145 } 146 } 147 if (!supported) { 148 error_setg(errp, "We cannot guarantee the CPU type '%s' works " 149 "with KVM on this host", model->name); 150 return NULL; 151 } 152 } 153 154 obj = object_new(object_class_get_name(oc)); 155 156 if (model->props) { 157 Visitor *visitor; 158 Error *err = NULL; 159 160 visitor = qobject_input_visitor_new(model->props); 161 if (!visit_start_struct(visitor, "model.props", NULL, 0, errp)) { 162 visit_free(visitor); 163 object_unref(obj); 164 return NULL; 165 } 166 167 qdict_in = qobject_to(QDict, model->props); 168 i = 0; 169 while ((name = cpu_model_advertised_features[i++]) != NULL) { 170 if (qdict_get(qdict_in, name)) { 171 if (!object_property_set(obj, name, visitor, &err)) { 172 break; 173 } 174 } 175 } 176 177 if (!err) { 178 visit_check_struct(visitor, &err); 179 } 180 if (!err) { 181 arm_cpu_finalize_features(ARM_CPU(obj), &err); 182 } 183 visit_end_struct(visitor, NULL); 184 visit_free(visitor); 185 if (err) { 186 object_unref(obj); 187 error_propagate(errp, err); 188 return NULL; 189 } 190 } else { 191 arm_cpu_finalize_features(ARM_CPU(obj), &error_abort); 192 } 193 194 expansion_info = g_new0(CpuModelExpansionInfo, 1); 195 expansion_info->model = g_malloc0(sizeof(*expansion_info->model)); 196 expansion_info->model->name = g_strdup(model->name); 197 198 qdict_out = qdict_new(); 199 200 i = 0; 201 while ((name = cpu_model_advertised_features[i++]) != NULL) { 202 ObjectProperty *prop = object_property_find(obj, name); 203 if (prop) { 204 QObject *value; 205 206 assert(prop->get); 207 value = object_property_get_qobject(obj, name, &error_abort); 208 209 qdict_put_obj(qdict_out, name, value); 210 } 211 } 212 213 if (!qdict_size(qdict_out)) { 214 qobject_unref(qdict_out); 215 } else { 216 expansion_info->model->props = QOBJECT(qdict_out); 217 } 218 219 object_unref(obj); 220 221 return expansion_info; 222 } 223 224 static void arm_cpu_add_definition(gpointer data, gpointer user_data) 225 { 226 ObjectClass *oc = data; 227 CpuDefinitionInfoList **cpu_list = user_data; 228 CpuDefinitionInfo *info; 229 const char *typename; 230 231 typename = object_class_get_name(oc); 232 info = g_malloc0(sizeof(*info)); 233 info->name = cpu_model_from_type(typename); 234 info->q_typename = g_strdup(typename); 235 236 QAPI_LIST_PREPEND(*cpu_list, info); 237 } 238 239 CpuDefinitionInfoList *qmp_query_cpu_definitions(Error **errp) 240 { 241 CpuDefinitionInfoList *cpu_list = NULL; 242 GSList *list; 243 244 list = object_class_get_list(TYPE_ARM_CPU, false); 245 g_slist_foreach(list, arm_cpu_add_definition, &cpu_list); 246 g_slist_free(list); 247 248 return cpu_list; 249 } 250