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 "qemu/target-info.h" 25 #include "hw/boards.h" 26 #include "kvm_arm.h" 27 #include "qapi/error.h" 28 #include "qapi/visitor.h" 29 #include "qapi/qobject-input-visitor.h" 30 #include "qapi/qapi-commands-machine.h" 31 #include "qapi/qapi-commands-misc-arm.h" 32 #include "qobject/qdict.h" 33 #include "qom/qom-qobject.h" 34 #include "cpu.h" 35 36 static GICCapability *gic_cap_new(int version) 37 { 38 GICCapability *cap = g_new0(GICCapability, 1); 39 cap->version = version; 40 /* by default, support none */ 41 cap->emulated = false; 42 cap->kernel = false; 43 return cap; 44 } 45 46 static inline void gic_cap_kvm_probe(GICCapability *v2, GICCapability *v3) 47 { 48 #ifdef CONFIG_KVM 49 int fdarray[3]; 50 51 if (!kvm_arm_create_scratch_host_vcpu(fdarray, NULL)) { 52 return; 53 } 54 55 /* Test KVM GICv2 */ 56 if (kvm_device_supported(fdarray[1], KVM_DEV_TYPE_ARM_VGIC_V2)) { 57 v2->kernel = true; 58 } 59 60 /* Test KVM GICv3 */ 61 if (kvm_device_supported(fdarray[1], KVM_DEV_TYPE_ARM_VGIC_V3)) { 62 v3->kernel = true; 63 } 64 65 kvm_arm_destroy_scratch_host_vcpu(fdarray); 66 #endif 67 } 68 69 GICCapabilityList *qmp_query_gic_capabilities(Error **errp) 70 { 71 GICCapabilityList *head = NULL; 72 GICCapability *v2 = gic_cap_new(2), *v3 = gic_cap_new(3); 73 74 v2->emulated = true; 75 v3->emulated = true; 76 77 gic_cap_kvm_probe(v2, v3); 78 79 QAPI_LIST_PREPEND(head, v2); 80 QAPI_LIST_PREPEND(head, v3); 81 82 return head; 83 } 84 85 QEMU_BUILD_BUG_ON(ARM_MAX_VQ > 16); 86 87 /* 88 * These are cpu model features we want to advertise. The order here 89 * matters as this is the order in which qmp_query_cpu_model_expansion 90 * will attempt to set them. If there are dependencies between features, 91 * then the order that considers those dependencies must be used. 92 */ 93 static const char *cpu_model_advertised_features[] = { 94 "aarch64", "pmu", "sve", 95 "sve128", "sve256", "sve384", "sve512", 96 "sve640", "sve768", "sve896", "sve1024", "sve1152", "sve1280", 97 "sve1408", "sve1536", "sve1664", "sve1792", "sve1920", "sve2048", 98 "kvm-no-adjvtime", "kvm-steal-time", 99 "pauth", "pauth-impdef", "pauth-qarma3", "pauth-qarma5", 100 NULL 101 }; 102 103 CpuModelExpansionInfo *qmp_query_cpu_model_expansion(CpuModelExpansionType type, 104 CpuModelInfo *model, 105 Error **errp) 106 { 107 CpuModelExpansionInfo *expansion_info; 108 const QDict *qdict_in; 109 QDict *qdict_out; 110 ObjectClass *oc; 111 Object *obj; 112 const char *name; 113 int i; 114 115 if (type != CPU_MODEL_EXPANSION_TYPE_FULL) { 116 error_setg(errp, "The requested expansion type is not supported"); 117 return NULL; 118 } 119 120 if (!kvm_enabled() && !strcmp(model->name, "host")) { 121 error_setg(errp, "The CPU type '%s' requires KVM", model->name); 122 return NULL; 123 } 124 125 oc = cpu_class_by_name(TYPE_ARM_CPU, model->name); 126 if (!oc) { 127 error_setg(errp, "The CPU type '%s' is not a recognized ARM CPU type", 128 model->name); 129 return NULL; 130 } 131 132 if (kvm_enabled()) { 133 bool supported = false; 134 135 if (!strcmp(model->name, "host") || !strcmp(model->name, "max")) { 136 /* These are kvmarm's recommended cpu types */ 137 supported = true; 138 } else if (current_machine->cpu_type) { 139 const char *cpu_type = current_machine->cpu_type; 140 int len = strlen(cpu_type) - strlen(ARM_CPU_TYPE_SUFFIX); 141 142 if (strlen(model->name) == len && 143 !strncmp(model->name, cpu_type, len)) { 144 /* KVM is enabled and we're using this type, so it works. */ 145 supported = true; 146 } 147 } 148 if (!supported) { 149 error_setg(errp, "We cannot guarantee the CPU type '%s' works " 150 "with KVM on this host", model->name); 151 return NULL; 152 } 153 } 154 155 obj = object_new(object_class_get_name(oc)); 156 157 if (model->props) { 158 Visitor *visitor; 159 Error *err = NULL; 160 161 visitor = qobject_input_visitor_new(model->props); 162 if (!visit_start_struct(visitor, "model.props", NULL, 0, errp)) { 163 visit_free(visitor); 164 object_unref(obj); 165 return NULL; 166 } 167 168 qdict_in = qobject_to(QDict, model->props); 169 i = 0; 170 while ((name = cpu_model_advertised_features[i++]) != NULL) { 171 if (qdict_get(qdict_in, name)) { 172 if (!object_property_set(obj, name, visitor, &err)) { 173 break; 174 } 175 } 176 } 177 178 if (!err) { 179 visit_check_struct(visitor, &err); 180 } 181 if (!err) { 182 arm_cpu_finalize_features(ARM_CPU(obj), &err); 183 } 184 visit_end_struct(visitor, NULL); 185 visit_free(visitor); 186 if (err) { 187 object_unref(obj); 188 error_propagate(errp, err); 189 return NULL; 190 } 191 } else { 192 arm_cpu_finalize_features(ARM_CPU(obj), &error_abort); 193 } 194 195 expansion_info = g_new0(CpuModelExpansionInfo, 1); 196 expansion_info->model = g_malloc0(sizeof(*expansion_info->model)); 197 expansion_info->model->name = g_strdup(model->name); 198 199 qdict_out = qdict_new(); 200 201 i = 0; 202 while ((name = cpu_model_advertised_features[i++]) != NULL) { 203 ObjectProperty *prop = object_property_find(obj, name); 204 if (prop) { 205 QObject *value; 206 207 assert(prop->get); 208 value = object_property_get_qobject(obj, name, &error_abort); 209 210 qdict_put_obj(qdict_out, name, value); 211 } 212 } 213 214 if (!qdict_size(qdict_out)) { 215 qobject_unref(qdict_out); 216 } else { 217 expansion_info->model->props = QOBJECT(qdict_out); 218 } 219 220 object_unref(obj); 221 222 return expansion_info; 223 } 224 225 static void arm_cpu_add_definition(gpointer data, gpointer user_data) 226 { 227 ObjectClass *oc = data; 228 CpuDefinitionInfoList **cpu_list = user_data; 229 CpuDefinitionInfo *info; 230 const char *typename; 231 232 typename = object_class_get_name(oc); 233 info = g_malloc0(sizeof(*info)); 234 info->name = cpu_model_from_type(typename); 235 info->q_typename = g_strdup(typename); 236 237 QAPI_LIST_PREPEND(*cpu_list, info); 238 } 239 240 CpuDefinitionInfoList *qmp_query_cpu_definitions(Error **errp) 241 { 242 CpuDefinitionInfoList *cpu_list = NULL; 243 GSList *list; 244 245 list = object_class_get_list(target_cpu_type(), false); 246 g_slist_foreach(list, arm_cpu_add_definition, &cpu_list); 247 g_slist_free(list); 248 249 return cpu_list; 250 } 251