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