1 /* 2 * QEMU S/390 CPU 3 * 4 * Copyright (c) 2009 Ulrich Hecht 5 * Copyright (c) 2011 Alexander Graf 6 * Copyright (c) 2012 SUSE LINUX Products GmbH 7 * Copyright (c) 2012 IBM Corp. 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, see <http://www.gnu.org/licenses/>. 21 */ 22 23 #include "qemu/osdep.h" 24 #include "qapi/error.h" 25 #include "cpu.h" 26 #include "internal.h" 27 #include "kvm_s390x.h" 28 #include "sysemu/kvm.h" 29 #include "sysemu/reset.h" 30 #include "qemu/timer.h" 31 #include "qemu/error-report.h" 32 #include "qemu/module.h" 33 #include "trace.h" 34 #include "qapi/visitor.h" 35 #include "qapi/qapi-types-machine.h" 36 #include "qapi/qapi-visit-run-state.h" 37 #include "sysemu/hw_accel.h" 38 #include "hw/qdev-properties.h" 39 #ifndef CONFIG_USER_ONLY 40 #include "hw/hw.h" 41 #include "hw/boards.h" 42 #include "sysemu/arch_init.h" 43 #include "sysemu/sysemu.h" 44 #include "sysemu/tcg.h" 45 #endif 46 #include "fpu/softfloat.h" 47 48 #define CR0_RESET 0xE0UL 49 #define CR14_RESET 0xC2000000UL; 50 51 static void s390_cpu_set_pc(CPUState *cs, vaddr value) 52 { 53 S390CPU *cpu = S390_CPU(cs); 54 55 cpu->env.psw.addr = value; 56 } 57 58 static bool s390_cpu_has_work(CPUState *cs) 59 { 60 S390CPU *cpu = S390_CPU(cs); 61 62 /* STOPPED cpus can never wake up */ 63 if (s390_cpu_get_state(cpu) != S390_CPU_STATE_LOAD && 64 s390_cpu_get_state(cpu) != S390_CPU_STATE_OPERATING) { 65 return false; 66 } 67 68 if (!(cs->interrupt_request & CPU_INTERRUPT_HARD)) { 69 return false; 70 } 71 72 return s390_cpu_has_int(cpu); 73 } 74 75 #if !defined(CONFIG_USER_ONLY) 76 /* S390CPUClass::load_normal() */ 77 static void s390_cpu_load_normal(CPUState *s) 78 { 79 S390CPU *cpu = S390_CPU(s); 80 cpu->env.psw.addr = ldl_phys(s->as, 4) & PSW_MASK_ESA_ADDR; 81 cpu->env.psw.mask = PSW_MASK_32 | PSW_MASK_64; 82 s390_cpu_set_state(S390_CPU_STATE_OPERATING, cpu); 83 } 84 #endif 85 86 /* S390CPUClass::cpu_reset() */ 87 static void s390_cpu_reset(CPUState *s) 88 { 89 S390CPU *cpu = S390_CPU(s); 90 S390CPUClass *scc = S390_CPU_GET_CLASS(cpu); 91 CPUS390XState *env = &cpu->env; 92 93 env->pfault_token = -1UL; 94 env->bpbc = false; 95 scc->parent_reset(s); 96 cpu->env.sigp_order = 0; 97 s390_cpu_set_state(S390_CPU_STATE_STOPPED, cpu); 98 } 99 100 /* S390CPUClass::initial_reset() */ 101 static void s390_cpu_initial_reset(CPUState *s) 102 { 103 S390CPU *cpu = S390_CPU(s); 104 CPUS390XState *env = &cpu->env; 105 106 s390_cpu_reset(s); 107 /* initial reset does not clear everything! */ 108 memset(&env->start_initial_reset_fields, 0, 109 offsetof(CPUS390XState, end_reset_fields) - 110 offsetof(CPUS390XState, start_initial_reset_fields)); 111 112 /* architectured initial values for CR 0 and 14 */ 113 env->cregs[0] = CR0_RESET; 114 env->cregs[14] = CR14_RESET; 115 116 /* architectured initial value for Breaking-Event-Address register */ 117 env->gbea = 1; 118 119 env->pfault_token = -1UL; 120 121 /* tininess for underflow is detected before rounding */ 122 set_float_detect_tininess(float_tininess_before_rounding, 123 &env->fpu_status); 124 125 /* Reset state inside the kernel that we cannot access yet from QEMU. */ 126 if (kvm_enabled()) { 127 kvm_s390_reset_vcpu(cpu); 128 } 129 } 130 131 /* CPUClass:reset() */ 132 static void s390_cpu_full_reset(CPUState *s) 133 { 134 S390CPU *cpu = S390_CPU(s); 135 S390CPUClass *scc = S390_CPU_GET_CLASS(cpu); 136 CPUS390XState *env = &cpu->env; 137 138 scc->parent_reset(s); 139 cpu->env.sigp_order = 0; 140 s390_cpu_set_state(S390_CPU_STATE_STOPPED, cpu); 141 142 memset(env, 0, offsetof(CPUS390XState, end_reset_fields)); 143 144 /* architectured initial values for CR 0 and 14 */ 145 env->cregs[0] = CR0_RESET; 146 env->cregs[14] = CR14_RESET; 147 148 #if defined(CONFIG_USER_ONLY) 149 /* user mode should always be allowed to use the full FPU */ 150 env->cregs[0] |= CR0_AFP; 151 if (s390_has_feat(S390_FEAT_VECTOR)) { 152 env->cregs[0] |= CR0_VECTOR; 153 } 154 #endif 155 156 /* architectured initial value for Breaking-Event-Address register */ 157 env->gbea = 1; 158 159 env->pfault_token = -1UL; 160 161 /* tininess for underflow is detected before rounding */ 162 set_float_detect_tininess(float_tininess_before_rounding, 163 &env->fpu_status); 164 165 /* Reset state inside the kernel that we cannot access yet from QEMU. */ 166 if (kvm_enabled()) { 167 kvm_s390_reset_vcpu(cpu); 168 } 169 } 170 171 #if !defined(CONFIG_USER_ONLY) 172 static void s390_cpu_machine_reset_cb(void *opaque) 173 { 174 S390CPU *cpu = opaque; 175 176 run_on_cpu(CPU(cpu), s390_do_cpu_full_reset, RUN_ON_CPU_NULL); 177 } 178 #endif 179 180 static void s390_cpu_disas_set_info(CPUState *cpu, disassemble_info *info) 181 { 182 info->mach = bfd_mach_s390_64; 183 info->print_insn = print_insn_s390; 184 } 185 186 static void s390_cpu_realizefn(DeviceState *dev, Error **errp) 187 { 188 CPUState *cs = CPU(dev); 189 S390CPUClass *scc = S390_CPU_GET_CLASS(dev); 190 #if !defined(CONFIG_USER_ONLY) 191 S390CPU *cpu = S390_CPU(dev); 192 #endif 193 Error *err = NULL; 194 195 /* the model has to be realized before qemu_init_vcpu() due to kvm */ 196 s390_realize_cpu_model(cs, &err); 197 if (err) { 198 goto out; 199 } 200 201 #if !defined(CONFIG_USER_ONLY) 202 MachineState *ms = MACHINE(qdev_get_machine()); 203 unsigned int max_cpus = ms->smp.max_cpus; 204 if (cpu->env.core_id >= max_cpus) { 205 error_setg(&err, "Unable to add CPU with core-id: %" PRIu32 206 ", maximum core-id: %d", cpu->env.core_id, 207 max_cpus - 1); 208 goto out; 209 } 210 211 if (cpu_exists(cpu->env.core_id)) { 212 error_setg(&err, "Unable to add CPU with core-id: %" PRIu32 213 ", it already exists", cpu->env.core_id); 214 goto out; 215 } 216 217 /* sync cs->cpu_index and env->core_id. The latter is needed for TCG. */ 218 cs->cpu_index = cpu->env.core_id; 219 #endif 220 221 cpu_exec_realizefn(cs, &err); 222 if (err != NULL) { 223 goto out; 224 } 225 226 #if !defined(CONFIG_USER_ONLY) 227 qemu_register_reset(s390_cpu_machine_reset_cb, cpu); 228 #endif 229 s390_cpu_gdb_init(cs); 230 qemu_init_vcpu(cs); 231 232 /* 233 * KVM requires the initial CPU reset ioctl to be executed on the target 234 * CPU thread. CPU hotplug under single-threaded TCG will not work with 235 * run_on_cpu(), as run_on_cpu() will not work properly if called while 236 * the main thread is already running but the CPU hasn't been realized. 237 */ 238 if (kvm_enabled()) { 239 run_on_cpu(cs, s390_do_cpu_full_reset, RUN_ON_CPU_NULL); 240 } else { 241 cpu_reset(cs); 242 } 243 244 scc->parent_realize(dev, &err); 245 out: 246 error_propagate(errp, err); 247 } 248 249 static GuestPanicInformation *s390_cpu_get_crash_info(CPUState *cs) 250 { 251 GuestPanicInformation *panic_info; 252 S390CPU *cpu = S390_CPU(cs); 253 254 cpu_synchronize_state(cs); 255 panic_info = g_malloc0(sizeof(GuestPanicInformation)); 256 257 panic_info->type = GUEST_PANIC_INFORMATION_TYPE_S390; 258 #if !defined(CONFIG_USER_ONLY) 259 panic_info->u.s390.core = cpu->env.core_id; 260 #else 261 panic_info->u.s390.core = 0; /* sane default for non system emulation */ 262 #endif 263 panic_info->u.s390.psw_mask = cpu->env.psw.mask; 264 panic_info->u.s390.psw_addr = cpu->env.psw.addr; 265 panic_info->u.s390.reason = cpu->env.crash_reason; 266 267 return panic_info; 268 } 269 270 static void s390_cpu_get_crash_info_qom(Object *obj, Visitor *v, 271 const char *name, void *opaque, 272 Error **errp) 273 { 274 CPUState *cs = CPU(obj); 275 GuestPanicInformation *panic_info; 276 277 if (!cs->crash_occurred) { 278 error_setg(errp, "No crash occurred"); 279 return; 280 } 281 282 panic_info = s390_cpu_get_crash_info(cs); 283 284 visit_type_GuestPanicInformation(v, "crash-information", &panic_info, 285 errp); 286 qapi_free_GuestPanicInformation(panic_info); 287 } 288 289 static void s390_cpu_initfn(Object *obj) 290 { 291 CPUState *cs = CPU(obj); 292 S390CPU *cpu = S390_CPU(obj); 293 294 cpu_set_cpustate_pointers(cpu); 295 cs->halted = 1; 296 cs->exception_index = EXCP_HLT; 297 object_property_add(obj, "crash-information", "GuestPanicInformation", 298 s390_cpu_get_crash_info_qom, NULL, NULL, NULL, NULL); 299 s390_cpu_model_register_props(obj); 300 #if !defined(CONFIG_USER_ONLY) 301 cpu->env.tod_timer = 302 timer_new_ns(QEMU_CLOCK_VIRTUAL, s390x_tod_timer, cpu); 303 cpu->env.cpu_timer = 304 timer_new_ns(QEMU_CLOCK_VIRTUAL, s390x_cpu_timer, cpu); 305 s390_cpu_set_state(S390_CPU_STATE_STOPPED, cpu); 306 #endif 307 } 308 309 static void s390_cpu_finalize(Object *obj) 310 { 311 #if !defined(CONFIG_USER_ONLY) 312 S390CPU *cpu = S390_CPU(obj); 313 314 qemu_unregister_reset(s390_cpu_machine_reset_cb, cpu); 315 g_free(cpu->irqstate); 316 #endif 317 } 318 319 #if !defined(CONFIG_USER_ONLY) 320 static bool disabled_wait(CPUState *cpu) 321 { 322 return cpu->halted && !(S390_CPU(cpu)->env.psw.mask & 323 (PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK)); 324 } 325 326 static unsigned s390_count_running_cpus(void) 327 { 328 CPUState *cpu; 329 int nr_running = 0; 330 331 CPU_FOREACH(cpu) { 332 uint8_t state = S390_CPU(cpu)->env.cpu_state; 333 if (state == S390_CPU_STATE_OPERATING || 334 state == S390_CPU_STATE_LOAD) { 335 if (!disabled_wait(cpu)) { 336 nr_running++; 337 } 338 } 339 } 340 341 return nr_running; 342 } 343 344 unsigned int s390_cpu_halt(S390CPU *cpu) 345 { 346 CPUState *cs = CPU(cpu); 347 trace_cpu_halt(cs->cpu_index); 348 349 if (!cs->halted) { 350 cs->halted = 1; 351 cs->exception_index = EXCP_HLT; 352 } 353 354 return s390_count_running_cpus(); 355 } 356 357 void s390_cpu_unhalt(S390CPU *cpu) 358 { 359 CPUState *cs = CPU(cpu); 360 trace_cpu_unhalt(cs->cpu_index); 361 362 if (cs->halted) { 363 cs->halted = 0; 364 cs->exception_index = -1; 365 } 366 } 367 368 unsigned int s390_cpu_set_state(uint8_t cpu_state, S390CPU *cpu) 369 { 370 trace_cpu_set_state(CPU(cpu)->cpu_index, cpu_state); 371 372 switch (cpu_state) { 373 case S390_CPU_STATE_STOPPED: 374 case S390_CPU_STATE_CHECK_STOP: 375 /* halt the cpu for common infrastructure */ 376 s390_cpu_halt(cpu); 377 break; 378 case S390_CPU_STATE_OPERATING: 379 case S390_CPU_STATE_LOAD: 380 /* 381 * Starting a CPU with a PSW WAIT bit set: 382 * KVM: handles this internally and triggers another WAIT exit. 383 * TCG: will actually try to continue to run. Don't unhalt, will 384 * be done when the CPU actually has work (an interrupt). 385 */ 386 if (!tcg_enabled() || !(cpu->env.psw.mask & PSW_MASK_WAIT)) { 387 s390_cpu_unhalt(cpu); 388 } 389 break; 390 default: 391 error_report("Requested CPU state is not a valid S390 CPU state: %u", 392 cpu_state); 393 exit(1); 394 } 395 if (kvm_enabled() && cpu->env.cpu_state != cpu_state) { 396 kvm_s390_set_cpu_state(cpu, cpu_state); 397 } 398 cpu->env.cpu_state = cpu_state; 399 400 return s390_count_running_cpus(); 401 } 402 403 int s390_set_memory_limit(uint64_t new_limit, uint64_t *hw_limit) 404 { 405 if (kvm_enabled()) { 406 return kvm_s390_set_mem_limit(new_limit, hw_limit); 407 } 408 return 0; 409 } 410 411 void s390_set_max_pagesize(uint64_t pagesize, Error **errp) 412 { 413 if (kvm_enabled()) { 414 kvm_s390_set_max_pagesize(pagesize, errp); 415 } 416 } 417 418 void s390_cmma_reset(void) 419 { 420 if (kvm_enabled()) { 421 kvm_s390_cmma_reset(); 422 } 423 } 424 425 int s390_assign_subch_ioeventfd(EventNotifier *notifier, uint32_t sch_id, 426 int vq, bool assign) 427 { 428 if (kvm_enabled()) { 429 return kvm_s390_assign_subch_ioeventfd(notifier, sch_id, vq, assign); 430 } else { 431 return 0; 432 } 433 } 434 435 void s390_crypto_reset(void) 436 { 437 if (kvm_enabled()) { 438 kvm_s390_crypto_reset(); 439 } 440 } 441 442 void s390_enable_css_support(S390CPU *cpu) 443 { 444 if (kvm_enabled()) { 445 kvm_s390_enable_css_support(cpu); 446 } 447 } 448 #endif 449 450 static gchar *s390_gdb_arch_name(CPUState *cs) 451 { 452 return g_strdup("s390:64-bit"); 453 } 454 455 static Property s390x_cpu_properties[] = { 456 #if !defined(CONFIG_USER_ONLY) 457 DEFINE_PROP_UINT32("core-id", S390CPU, env.core_id, 0), 458 #endif 459 DEFINE_PROP_END_OF_LIST() 460 }; 461 462 static void s390_cpu_class_init(ObjectClass *oc, void *data) 463 { 464 S390CPUClass *scc = S390_CPU_CLASS(oc); 465 CPUClass *cc = CPU_CLASS(scc); 466 DeviceClass *dc = DEVICE_CLASS(oc); 467 468 device_class_set_parent_realize(dc, s390_cpu_realizefn, 469 &scc->parent_realize); 470 dc->props = s390x_cpu_properties; 471 dc->user_creatable = true; 472 473 scc->parent_reset = cc->reset; 474 #if !defined(CONFIG_USER_ONLY) 475 scc->load_normal = s390_cpu_load_normal; 476 #endif 477 scc->cpu_reset = s390_cpu_reset; 478 scc->initial_cpu_reset = s390_cpu_initial_reset; 479 cc->reset = s390_cpu_full_reset; 480 cc->class_by_name = s390_cpu_class_by_name, 481 cc->has_work = s390_cpu_has_work; 482 #ifdef CONFIG_TCG 483 cc->do_interrupt = s390_cpu_do_interrupt; 484 #endif 485 cc->dump_state = s390_cpu_dump_state; 486 cc->get_crash_info = s390_cpu_get_crash_info; 487 cc->set_pc = s390_cpu_set_pc; 488 cc->gdb_read_register = s390_cpu_gdb_read_register; 489 cc->gdb_write_register = s390_cpu_gdb_write_register; 490 #ifndef CONFIG_USER_ONLY 491 cc->get_phys_page_debug = s390_cpu_get_phys_page_debug; 492 cc->vmsd = &vmstate_s390_cpu; 493 cc->write_elf64_note = s390_cpu_write_elf64_note; 494 #ifdef CONFIG_TCG 495 cc->cpu_exec_interrupt = s390_cpu_exec_interrupt; 496 cc->debug_excp_handler = s390x_cpu_debug_excp_handler; 497 cc->do_unaligned_access = s390x_cpu_do_unaligned_access; 498 #endif 499 #endif 500 cc->disas_set_info = s390_cpu_disas_set_info; 501 #ifdef CONFIG_TCG 502 cc->tcg_initialize = s390x_translate_init; 503 cc->tlb_fill = s390_cpu_tlb_fill; 504 #endif 505 506 cc->gdb_num_core_regs = S390_NUM_CORE_REGS; 507 cc->gdb_core_xml_file = "s390x-core64.xml"; 508 cc->gdb_arch_name = s390_gdb_arch_name; 509 510 s390_cpu_model_class_register_props(oc); 511 } 512 513 static const TypeInfo s390_cpu_type_info = { 514 .name = TYPE_S390_CPU, 515 .parent = TYPE_CPU, 516 .instance_size = sizeof(S390CPU), 517 .instance_init = s390_cpu_initfn, 518 .instance_finalize = s390_cpu_finalize, 519 .abstract = true, 520 .class_size = sizeof(S390CPUClass), 521 .class_init = s390_cpu_class_init, 522 }; 523 524 static void s390_cpu_register_types(void) 525 { 526 type_register_static(&s390_cpu_type_info); 527 } 528 529 type_init(s390_cpu_register_types) 530