1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include "qemu/osdep.h"
19#include "qemu/error-report.h"
20#include "exec/address-spaces.h"
21#include "cpu.h"
22#include "internal.h"
23#include "kvm_s390x.h"
24#include "sysemu/kvm.h"
25#include "sysemu/tcg.h"
26#include "exec/exec-all.h"
27#include "trace.h"
28#include "hw/hw.h"
29#include "hw/s390x/storage-keys.h"
30
31
32#define FS_READ 0x800
33#define FS_WRITE 0x400
34
35static void trigger_access_exception(CPUS390XState *env, uint32_t type,
36 uint64_t tec)
37{
38 S390CPU *cpu = env_archcpu(env);
39
40 if (kvm_enabled()) {
41 kvm_s390_access_exception(cpu, type, tec);
42 } else {
43 CPUState *cs = env_cpu(env);
44 if (type != PGM_ADDRESSING) {
45 stq_phys(cs->as, env->psa + offsetof(LowCore, trans_exc_code), tec);
46 }
47 trigger_pgm_exception(env, type);
48 }
49}
50
51
52static bool is_low_address(uint64_t addr)
53{
54 return addr <= 511 || (addr >= 4096 && addr <= 4607);
55}
56
57
58static bool lowprot_enabled(const CPUS390XState *env, uint64_t asc)
59{
60 if (!(env->cregs[0] & CR0_LOWPROT)) {
61 return false;
62 }
63 if (!(env->psw.mask & PSW_MASK_DAT)) {
64 return true;
65 }
66
67
68 switch (asc) {
69 case PSW_ASC_PRIMARY:
70 return !(env->cregs[1] & ASCE_PRIVATE_SPACE);
71 case PSW_ASC_SECONDARY:
72 return !(env->cregs[7] & ASCE_PRIVATE_SPACE);
73 case PSW_ASC_HOME:
74 return !(env->cregs[13] & ASCE_PRIVATE_SPACE);
75 default:
76
77 error_report("unsupported addressing mode");
78 exit(1);
79 }
80}
81
82
83
84
85
86target_ulong mmu_real2abs(CPUS390XState *env, target_ulong raddr)
87{
88 if (raddr < 0x2000) {
89 return raddr + env->psa;
90 } else if (raddr >= env->psa && raddr < env->psa + 0x2000) {
91 return raddr - env->psa;
92 }
93 return raddr;
94}
95
96static inline bool read_table_entry(CPUS390XState *env, hwaddr gaddr,
97 uint64_t *entry)
98{
99 CPUState *cs = env_cpu(env);
100
101
102
103
104
105
106
107
108 if (unlikely(address_space_read(cs->as, gaddr, MEMTXATTRS_UNSPECIFIED,
109 entry, sizeof(*entry)) !=
110 MEMTX_OK)) {
111 return false;
112 }
113 *entry = be64_to_cpu(*entry);
114 return true;
115}
116
117static int mmu_translate_asce(CPUS390XState *env, target_ulong vaddr,
118 uint64_t asc, uint64_t asce, target_ulong *raddr,
119 int *flags, int rw)
120{
121 const bool edat1 = (env->cregs[0] & CR0_EDAT) &&
122 s390_has_feat(S390_FEAT_EDAT);
123 const bool edat2 = edat1 && s390_has_feat(S390_FEAT_EDAT_2);
124 const bool iep = (env->cregs[0] & CR0_IEP) &&
125 s390_has_feat(S390_FEAT_INSTRUCTION_EXEC_PROT);
126 const int asce_tl = asce & ASCE_TABLE_LENGTH;
127 const int asce_p = asce & ASCE_PRIVATE_SPACE;
128 hwaddr gaddr = asce & ASCE_ORIGIN;
129 uint64_t entry;
130
131 if (asce & ASCE_REAL_SPACE) {
132
133 *raddr = vaddr;
134 return 0;
135 }
136
137 switch (asce & ASCE_TYPE_MASK) {
138 case ASCE_TYPE_REGION1:
139 if (VADDR_REGION1_TL(vaddr) > asce_tl) {
140 return PGM_REG_FIRST_TRANS;
141 }
142 gaddr += VADDR_REGION1_TX(vaddr) * 8;
143 break;
144 case ASCE_TYPE_REGION2:
145 if (VADDR_REGION1_TX(vaddr)) {
146 return PGM_ASCE_TYPE;
147 }
148 if (VADDR_REGION2_TL(vaddr) > asce_tl) {
149 return PGM_REG_SEC_TRANS;
150 }
151 gaddr += VADDR_REGION2_TX(vaddr) * 8;
152 break;
153 case ASCE_TYPE_REGION3:
154 if (VADDR_REGION1_TX(vaddr) || VADDR_REGION2_TX(vaddr)) {
155 return PGM_ASCE_TYPE;
156 }
157 if (VADDR_REGION3_TL(vaddr) > asce_tl) {
158 return PGM_REG_THIRD_TRANS;
159 }
160 gaddr += VADDR_REGION3_TX(vaddr) * 8;
161 break;
162 case ASCE_TYPE_SEGMENT:
163 if (VADDR_REGION1_TX(vaddr) || VADDR_REGION2_TX(vaddr) ||
164 VADDR_REGION3_TX(vaddr)) {
165 return PGM_ASCE_TYPE;
166 }
167 if (VADDR_SEGMENT_TL(vaddr) > asce_tl) {
168 return PGM_SEGMENT_TRANS;
169 }
170 gaddr += VADDR_SEGMENT_TX(vaddr) * 8;
171 break;
172 }
173
174 switch (asce & ASCE_TYPE_MASK) {
175 case ASCE_TYPE_REGION1:
176 if (!read_table_entry(env, gaddr, &entry)) {
177 return PGM_ADDRESSING;
178 }
179 if (entry & REGION_ENTRY_I) {
180 return PGM_REG_FIRST_TRANS;
181 }
182 if ((entry & REGION_ENTRY_TT) != REGION_ENTRY_TT_REGION1) {
183 return PGM_TRANS_SPEC;
184 }
185 if (VADDR_REGION2_TL(vaddr) < (entry & REGION_ENTRY_TF) >> 6 ||
186 VADDR_REGION2_TL(vaddr) > (entry & REGION_ENTRY_TL)) {
187 return PGM_REG_SEC_TRANS;
188 }
189 if (edat1 && (entry & REGION_ENTRY_P)) {
190 *flags &= ~PAGE_WRITE;
191 }
192 gaddr = (entry & REGION_ENTRY_ORIGIN) + VADDR_REGION2_TX(vaddr) * 8;
193
194 case ASCE_TYPE_REGION2:
195 if (!read_table_entry(env, gaddr, &entry)) {
196 return PGM_ADDRESSING;
197 }
198 if (entry & REGION_ENTRY_I) {
199 return PGM_REG_SEC_TRANS;
200 }
201 if ((entry & REGION_ENTRY_TT) != REGION_ENTRY_TT_REGION2) {
202 return PGM_TRANS_SPEC;
203 }
204 if (VADDR_REGION3_TL(vaddr) < (entry & REGION_ENTRY_TF) >> 6 ||
205 VADDR_REGION3_TL(vaddr) > (entry & REGION_ENTRY_TL)) {
206 return PGM_REG_THIRD_TRANS;
207 }
208 if (edat1 && (entry & REGION_ENTRY_P)) {
209 *flags &= ~PAGE_WRITE;
210 }
211 gaddr = (entry & REGION_ENTRY_ORIGIN) + VADDR_REGION3_TX(vaddr) * 8;
212
213 case ASCE_TYPE_REGION3:
214 if (!read_table_entry(env, gaddr, &entry)) {
215 return PGM_ADDRESSING;
216 }
217 if (entry & REGION_ENTRY_I) {
218 return PGM_REG_THIRD_TRANS;
219 }
220 if ((entry & REGION_ENTRY_TT) != REGION_ENTRY_TT_REGION3) {
221 return PGM_TRANS_SPEC;
222 }
223 if (edat2 && (entry & REGION3_ENTRY_CR) && asce_p) {
224 return PGM_TRANS_SPEC;
225 }
226 if (edat1 && (entry & REGION_ENTRY_P)) {
227 *flags &= ~PAGE_WRITE;
228 }
229 if (edat2 && (entry & REGION3_ENTRY_FC)) {
230 if (iep && (entry & REGION3_ENTRY_IEP)) {
231 *flags &= ~PAGE_EXEC;
232 }
233 *raddr = (entry & REGION3_ENTRY_RFAA) |
234 (vaddr & ~REGION3_ENTRY_RFAA);
235 return 0;
236 }
237 if (VADDR_SEGMENT_TL(vaddr) < (entry & REGION_ENTRY_TF) >> 6 ||
238 VADDR_SEGMENT_TL(vaddr) > (entry & REGION_ENTRY_TL)) {
239 return PGM_SEGMENT_TRANS;
240 }
241 gaddr = (entry & REGION_ENTRY_ORIGIN) + VADDR_SEGMENT_TX(vaddr) * 8;
242
243 case ASCE_TYPE_SEGMENT:
244 if (!read_table_entry(env, gaddr, &entry)) {
245 return PGM_ADDRESSING;
246 }
247 if (entry & SEGMENT_ENTRY_I) {
248 return PGM_SEGMENT_TRANS;
249 }
250 if ((entry & SEGMENT_ENTRY_TT) != SEGMENT_ENTRY_TT_SEGMENT) {
251 return PGM_TRANS_SPEC;
252 }
253 if ((entry & SEGMENT_ENTRY_CS) && asce_p) {
254 return PGM_TRANS_SPEC;
255 }
256 if (entry & SEGMENT_ENTRY_P) {
257 *flags &= ~PAGE_WRITE;
258 }
259 if (edat1 && (entry & SEGMENT_ENTRY_FC)) {
260 if (iep && (entry & SEGMENT_ENTRY_IEP)) {
261 *flags &= ~PAGE_EXEC;
262 }
263 *raddr = (entry & SEGMENT_ENTRY_SFAA) |
264 (vaddr & ~SEGMENT_ENTRY_SFAA);
265 return 0;
266 }
267 gaddr = (entry & SEGMENT_ENTRY_ORIGIN) + VADDR_PAGE_TX(vaddr) * 8;
268 break;
269 }
270
271 if (!read_table_entry(env, gaddr, &entry)) {
272 return PGM_ADDRESSING;
273 }
274 if (entry & PAGE_ENTRY_I) {
275 return PGM_PAGE_TRANS;
276 }
277 if (entry & PAGE_ENTRY_0) {
278 return PGM_TRANS_SPEC;
279 }
280 if (entry & PAGE_ENTRY_P) {
281 *flags &= ~PAGE_WRITE;
282 }
283 if (iep && (entry & PAGE_ENTRY_IEP)) {
284 *flags &= ~PAGE_EXEC;
285 }
286
287 *raddr = entry & TARGET_PAGE_MASK;
288 return 0;
289}
290
291static void mmu_handle_skey(target_ulong addr, int rw, int *flags)
292{
293 static S390SKeysClass *skeyclass;
294 static S390SKeysState *ss;
295 uint8_t key;
296 int rc;
297
298 if (unlikely(addr >= ram_size)) {
299 return;
300 }
301
302 if (unlikely(!ss)) {
303 ss = s390_get_skeys_device();
304 skeyclass = S390_SKEYS_GET_CLASS(ss);
305 }
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326 rc = skeyclass->get_skeys(ss, addr / TARGET_PAGE_SIZE, 1, &key);
327 if (rc) {
328 trace_get_skeys_nonzero(rc);
329 return;
330 }
331
332 switch (rw) {
333 case MMU_DATA_LOAD:
334 case MMU_INST_FETCH:
335
336
337
338
339
340 if (!(key & SK_C)) {
341 *flags &= ~PAGE_WRITE;
342 }
343 break;
344 case MMU_DATA_STORE:
345 key |= SK_C;
346 break;
347 default:
348 g_assert_not_reached();
349 }
350
351
352 key |= SK_R;
353
354 rc = skeyclass->set_skeys(ss, addr / TARGET_PAGE_SIZE, 1, &key);
355 if (rc) {
356 trace_set_skeys_nonzero(rc);
357 }
358}
359
360
361
362
363
364
365
366
367
368
369
370int mmu_translate(CPUS390XState *env, target_ulong vaddr, int rw, uint64_t asc,
371 target_ulong *raddr, int *flags, uint64_t *tec)
372{
373 uint64_t asce;
374 int r;
375
376 *tec = (vaddr & TARGET_PAGE_MASK) | (asc >> 46) |
377 (rw == MMU_DATA_STORE ? FS_WRITE : FS_READ);
378 *flags = PAGE_READ | PAGE_WRITE | PAGE_EXEC;
379
380 if (is_low_address(vaddr & TARGET_PAGE_MASK) && lowprot_enabled(env, asc)) {
381
382
383
384
385
386
387
388
389 *flags |= PAGE_WRITE_INV;
390 if (is_low_address(vaddr) && rw == MMU_DATA_STORE) {
391
392 *tec |= 0x80;
393 return PGM_PROTECTION;
394 }
395 }
396
397 vaddr &= TARGET_PAGE_MASK;
398
399 if (!(env->psw.mask & PSW_MASK_DAT)) {
400 *raddr = vaddr;
401 goto nodat;
402 }
403
404 switch (asc) {
405 case PSW_ASC_PRIMARY:
406 asce = env->cregs[1];
407 break;
408 case PSW_ASC_HOME:
409 asce = env->cregs[13];
410 break;
411 case PSW_ASC_SECONDARY:
412 asce = env->cregs[7];
413 break;
414 case PSW_ASC_ACCREG:
415 default:
416 hw_error("guest switched to unknown asc mode\n");
417 break;
418 }
419
420
421 r = mmu_translate_asce(env, vaddr, asc, asce, raddr, flags, rw);
422 if (unlikely(r)) {
423 return r;
424 }
425
426
427 if (unlikely(rw == MMU_DATA_STORE && !(*flags & PAGE_WRITE))) {
428
429 *tec |= 0x4;
430 return PGM_PROTECTION;
431 }
432
433
434 if (unlikely(rw == MMU_INST_FETCH && !(*flags & PAGE_EXEC))) {
435
436 *tec |= 0x84;
437 return PGM_PROTECTION;
438 }
439
440nodat:
441
442 *raddr = mmu_real2abs(env, *raddr);
443
444 mmu_handle_skey(*raddr, rw, flags);
445 return 0;
446}
447
448
449
450
451
452
453static int translate_pages(S390CPU *cpu, vaddr addr, int nr_pages,
454 target_ulong *pages, bool is_write, uint64_t *tec)
455{
456 uint64_t asc = cpu->env.psw.mask & PSW_MASK_ASC;
457 CPUS390XState *env = &cpu->env;
458 int ret, i, pflags;
459
460 for (i = 0; i < nr_pages; i++) {
461 ret = mmu_translate(env, addr, is_write, asc, &pages[i], &pflags, tec);
462 if (ret) {
463 return ret;
464 }
465 if (!address_space_access_valid(&address_space_memory, pages[i],
466 TARGET_PAGE_SIZE, is_write,
467 MEMTXATTRS_UNSPECIFIED)) {
468 *tec = 0;
469 return PGM_ADDRESSING;
470 }
471 addr += TARGET_PAGE_SIZE;
472 }
473
474 return 0;
475}
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492int s390_cpu_virt_mem_rw(S390CPU *cpu, vaddr laddr, uint8_t ar, void *hostbuf,
493 int len, bool is_write)
494{
495 int currlen, nr_pages, i;
496 target_ulong *pages;
497 uint64_t tec;
498 int ret;
499
500 if (kvm_enabled()) {
501 ret = kvm_s390_mem_op(cpu, laddr, ar, hostbuf, len, is_write);
502 if (ret >= 0) {
503 return ret;
504 }
505 }
506
507 nr_pages = (((laddr & ~TARGET_PAGE_MASK) + len - 1) >> TARGET_PAGE_BITS)
508 + 1;
509 pages = g_malloc(nr_pages * sizeof(*pages));
510
511 ret = translate_pages(cpu, laddr, nr_pages, pages, is_write, &tec);
512 if (ret) {
513 trigger_access_exception(&cpu->env, ret, tec);
514 } else if (hostbuf != NULL) {
515
516 for (i = 0; i < nr_pages; i++) {
517 currlen = MIN(len, TARGET_PAGE_SIZE - (laddr % TARGET_PAGE_SIZE));
518 cpu_physical_memory_rw(pages[i] | (laddr & ~TARGET_PAGE_MASK),
519 hostbuf, currlen, is_write);
520 laddr += currlen;
521 hostbuf += currlen;
522 len -= currlen;
523 }
524 }
525
526 g_free(pages);
527 return ret;
528}
529
530void s390_cpu_virt_mem_handle_exc(S390CPU *cpu, uintptr_t ra)
531{
532
533#ifdef CONFIG_TCG
534 if (tcg_enabled()) {
535 cpu_loop_exit_restore(CPU(cpu), ra);
536 }
537#endif
538}
539
540
541
542
543
544
545
546
547
548int mmu_translate_real(CPUS390XState *env, target_ulong raddr, int rw,
549 target_ulong *addr, int *flags, uint64_t *tec)
550{
551 const bool lowprot_enabled = env->cregs[0] & CR0_LOWPROT;
552
553 *flags = PAGE_READ | PAGE_WRITE | PAGE_EXEC;
554 if (is_low_address(raddr & TARGET_PAGE_MASK) && lowprot_enabled) {
555
556 *flags |= PAGE_WRITE_INV;
557 if (is_low_address(raddr) && rw == MMU_DATA_STORE) {
558
559 *tec = (raddr & TARGET_PAGE_MASK) | FS_WRITE | 0x80;
560 return PGM_PROTECTION;
561 }
562 }
563
564 *addr = mmu_real2abs(env, raddr & TARGET_PAGE_MASK);
565
566 mmu_handle_skey(*addr, rw, flags);
567 return 0;
568}
569