~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/s390/kvm/intercept.c

Version: ~ [ linux-5.14-rc3 ] ~ [ linux-5.13.5 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.53 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.135 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.198 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.240 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.276 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.276 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  2 /*
  3  * in-kernel handling for sie intercepts
  4  *
  5  * Copyright IBM Corp. 2008, 2014
  6  *
  7  *    Author(s): Carsten Otte <cotte@de.ibm.com>
  8  *               Christian Borntraeger <borntraeger@de.ibm.com>
  9  */
 10 
 11 #include <linux/kvm_host.h>
 12 #include <linux/errno.h>
 13 #include <linux/pagemap.h>
 14 
 15 #include <asm/kvm_host.h>
 16 #include <asm/asm-offsets.h>
 17 #include <asm/irq.h>
 18 #include <asm/sysinfo.h>
 19 
 20 #include "kvm-s390.h"
 21 #include "gaccess.h"
 22 #include "trace.h"
 23 #include "trace-s390.h"
 24 
 25 u8 kvm_s390_get_ilen(struct kvm_vcpu *vcpu)
 26 {
 27         struct kvm_s390_sie_block *sie_block = vcpu->arch.sie_block;
 28         u8 ilen = 0;
 29 
 30         switch (vcpu->arch.sie_block->icptcode) {
 31         case ICPT_INST:
 32         case ICPT_INSTPROGI:
 33         case ICPT_OPEREXC:
 34         case ICPT_PARTEXEC:
 35         case ICPT_IOINST:
 36                 /* instruction only stored for these icptcodes */
 37                 ilen = insn_length(vcpu->arch.sie_block->ipa >> 8);
 38                 /* Use the length of the EXECUTE instruction if necessary */
 39                 if (sie_block->icptstatus & 1) {
 40                         ilen = (sie_block->icptstatus >> 4) & 0x6;
 41                         if (!ilen)
 42                                 ilen = 4;
 43                 }
 44                 break;
 45         case ICPT_PROGI:
 46                 /* bit 1+2 of pgmilc are the ilc, so we directly get ilen */
 47                 ilen = vcpu->arch.sie_block->pgmilc & 0x6;
 48                 break;
 49         }
 50         return ilen;
 51 }
 52 
 53 static int handle_noop(struct kvm_vcpu *vcpu)
 54 {
 55         switch (vcpu->arch.sie_block->icptcode) {
 56         case 0x10:
 57                 vcpu->stat.exit_external_request++;
 58                 break;
 59         default:
 60                 break; /* nothing */
 61         }
 62         return 0;
 63 }
 64 
 65 static int handle_stop(struct kvm_vcpu *vcpu)
 66 {
 67         struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
 68         int rc = 0;
 69         uint8_t flags, stop_pending;
 70 
 71         vcpu->stat.exit_stop_request++;
 72 
 73         /* delay the stop if any non-stop irq is pending */
 74         if (kvm_s390_vcpu_has_irq(vcpu, 1))
 75                 return 0;
 76 
 77         /* avoid races with the injection/SIGP STOP code */
 78         spin_lock(&li->lock);
 79         flags = li->irq.stop.flags;
 80         stop_pending = kvm_s390_is_stop_irq_pending(vcpu);
 81         spin_unlock(&li->lock);
 82 
 83         trace_kvm_s390_stop_request(stop_pending, flags);
 84         if (!stop_pending)
 85                 return 0;
 86 
 87         if (flags & KVM_S390_STOP_FLAG_STORE_STATUS) {
 88                 rc = kvm_s390_vcpu_store_status(vcpu,
 89                                                 KVM_S390_STORE_STATUS_NOADDR);
 90                 if (rc)
 91                         return rc;
 92         }
 93 
 94         if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm))
 95                 kvm_s390_vcpu_stop(vcpu);
 96         return -EOPNOTSUPP;
 97 }
 98 
 99 static int handle_validity(struct kvm_vcpu *vcpu)
100 {
101         int viwhy = vcpu->arch.sie_block->ipb >> 16;
102 
103         vcpu->stat.exit_validity++;
104         trace_kvm_s390_intercept_validity(vcpu, viwhy);
105         KVM_EVENT(3, "validity intercept 0x%x for pid %u (kvm 0x%pK)", viwhy,
106                   current->pid, vcpu->kvm);
107 
108         /* do not warn on invalid runtime instrumentation mode */
109         WARN_ONCE(viwhy != 0x44, "kvm: unhandled validity intercept 0x%x\n",
110                   viwhy);
111         return -EINVAL;
112 }
113 
114 static int handle_instruction(struct kvm_vcpu *vcpu)
115 {
116         vcpu->stat.exit_instruction++;
117         trace_kvm_s390_intercept_instruction(vcpu,
118                                              vcpu->arch.sie_block->ipa,
119                                              vcpu->arch.sie_block->ipb);
120 
121         switch (vcpu->arch.sie_block->ipa >> 8) {
122         case 0x01:
123                 return kvm_s390_handle_01(vcpu);
124         case 0x82:
125                 return kvm_s390_handle_lpsw(vcpu);
126         case 0x83:
127                 return kvm_s390_handle_diag(vcpu);
128         case 0xaa:
129                 return kvm_s390_handle_aa(vcpu);
130         case 0xae:
131                 return kvm_s390_handle_sigp(vcpu);
132         case 0xb2:
133                 return kvm_s390_handle_b2(vcpu);
134         case 0xb6:
135                 return kvm_s390_handle_stctl(vcpu);
136         case 0xb7:
137                 return kvm_s390_handle_lctl(vcpu);
138         case 0xb9:
139                 return kvm_s390_handle_b9(vcpu);
140         case 0xe3:
141                 return kvm_s390_handle_e3(vcpu);
142         case 0xe5:
143                 return kvm_s390_handle_e5(vcpu);
144         case 0xeb:
145                 return kvm_s390_handle_eb(vcpu);
146         default:
147                 return -EOPNOTSUPP;
148         }
149 }
150 
151 static int inject_prog_on_prog_intercept(struct kvm_vcpu *vcpu)
152 {
153         struct kvm_s390_pgm_info pgm_info = {
154                 .code = vcpu->arch.sie_block->iprcc,
155                 /* the PSW has already been rewound */
156                 .flags = KVM_S390_PGM_FLAGS_NO_REWIND,
157         };
158 
159         switch (vcpu->arch.sie_block->iprcc & ~PGM_PER) {
160         case PGM_AFX_TRANSLATION:
161         case PGM_ASX_TRANSLATION:
162         case PGM_EX_TRANSLATION:
163         case PGM_LFX_TRANSLATION:
164         case PGM_LSTE_SEQUENCE:
165         case PGM_LSX_TRANSLATION:
166         case PGM_LX_TRANSLATION:
167         case PGM_PRIMARY_AUTHORITY:
168         case PGM_SECONDARY_AUTHORITY:
169         case PGM_SPACE_SWITCH:
170                 pgm_info.trans_exc_code = vcpu->arch.sie_block->tecmc;
171                 break;
172         case PGM_ALEN_TRANSLATION:
173         case PGM_ALE_SEQUENCE:
174         case PGM_ASTE_INSTANCE:
175         case PGM_ASTE_SEQUENCE:
176         case PGM_ASTE_VALIDITY:
177         case PGM_EXTENDED_AUTHORITY:
178                 pgm_info.exc_access_id = vcpu->arch.sie_block->eai;
179                 break;
180         case PGM_ASCE_TYPE:
181         case PGM_PAGE_TRANSLATION:
182         case PGM_REGION_FIRST_TRANS:
183         case PGM_REGION_SECOND_TRANS:
184         case PGM_REGION_THIRD_TRANS:
185         case PGM_SEGMENT_TRANSLATION:
186                 pgm_info.trans_exc_code = vcpu->arch.sie_block->tecmc;
187                 pgm_info.exc_access_id  = vcpu->arch.sie_block->eai;
188                 pgm_info.op_access_id  = vcpu->arch.sie_block->oai;
189                 break;
190         case PGM_MONITOR:
191                 pgm_info.mon_class_nr = vcpu->arch.sie_block->mcn;
192                 pgm_info.mon_code = vcpu->arch.sie_block->tecmc;
193                 break;
194         case PGM_VECTOR_PROCESSING:
195         case PGM_DATA:
196                 pgm_info.data_exc_code = vcpu->arch.sie_block->dxc;
197                 break;
198         case PGM_PROTECTION:
199                 pgm_info.trans_exc_code = vcpu->arch.sie_block->tecmc;
200                 pgm_info.exc_access_id  = vcpu->arch.sie_block->eai;
201                 break;
202         default:
203                 break;
204         }
205 
206         if (vcpu->arch.sie_block->iprcc & PGM_PER) {
207                 pgm_info.per_code = vcpu->arch.sie_block->perc;
208                 pgm_info.per_atmid = vcpu->arch.sie_block->peratmid;
209                 pgm_info.per_address = vcpu->arch.sie_block->peraddr;
210                 pgm_info.per_access_id = vcpu->arch.sie_block->peraid;
211         }
212         return kvm_s390_inject_prog_irq(vcpu, &pgm_info);
213 }
214 
215 /*
216  * restore ITDB to program-interruption TDB in guest lowcore
217  * and set TX abort indication if required
218 */
219 static int handle_itdb(struct kvm_vcpu *vcpu)
220 {
221         struct kvm_s390_itdb *itdb;
222         int rc;
223 
224         if (!IS_TE_ENABLED(vcpu) || !IS_ITDB_VALID(vcpu))
225                 return 0;
226         if (current->thread.per_flags & PER_FLAG_NO_TE)
227                 return 0;
228         itdb = (struct kvm_s390_itdb *)vcpu->arch.sie_block->itdba;
229         rc = write_guest_lc(vcpu, __LC_PGM_TDB, itdb, sizeof(*itdb));
230         if (rc)
231                 return rc;
232         memset(itdb, 0, sizeof(*itdb));
233 
234         return 0;
235 }
236 
237 #define per_event(vcpu) (vcpu->arch.sie_block->iprcc & PGM_PER)
238 
239 static int handle_prog(struct kvm_vcpu *vcpu)
240 {
241         psw_t psw;
242         int rc;
243 
244         vcpu->stat.exit_program_interruption++;
245 
246         if (guestdbg_enabled(vcpu) && per_event(vcpu)) {
247                 rc = kvm_s390_handle_per_event(vcpu);
248                 if (rc)
249                         return rc;
250                 /* the interrupt might have been filtered out completely */
251                 if (vcpu->arch.sie_block->iprcc == 0)
252                         return 0;
253         }
254 
255         trace_kvm_s390_intercept_prog(vcpu, vcpu->arch.sie_block->iprcc);
256         if (vcpu->arch.sie_block->iprcc == PGM_SPECIFICATION) {
257                 rc = read_guest_lc(vcpu, __LC_PGM_NEW_PSW, &psw, sizeof(psw_t));
258                 if (rc)
259                         return rc;
260                 /* Avoid endless loops of specification exceptions */
261                 if (!is_valid_psw(&psw))
262                         return -EOPNOTSUPP;
263         }
264         rc = handle_itdb(vcpu);
265         if (rc)
266                 return rc;
267 
268         return inject_prog_on_prog_intercept(vcpu);
269 }
270 
271 /**
272  * handle_external_interrupt - used for external interruption interceptions
273  *
274  * This interception only occurs if the CPUSTAT_EXT_INT bit was set, or if
275  * the new PSW does not have external interrupts disabled. In the first case,
276  * we've got to deliver the interrupt manually, and in the second case, we
277  * drop to userspace to handle the situation there.
278  */
279 static int handle_external_interrupt(struct kvm_vcpu *vcpu)
280 {
281         u16 eic = vcpu->arch.sie_block->eic;
282         struct kvm_s390_irq irq;
283         psw_t newpsw;
284         int rc;
285 
286         vcpu->stat.exit_external_interrupt++;
287 
288         rc = read_guest_lc(vcpu, __LC_EXT_NEW_PSW, &newpsw, sizeof(psw_t));
289         if (rc)
290                 return rc;
291         /* We can not handle clock comparator or timer interrupt with bad PSW */
292         if ((eic == EXT_IRQ_CLK_COMP || eic == EXT_IRQ_CPU_TIMER) &&
293             (newpsw.mask & PSW_MASK_EXT))
294                 return -EOPNOTSUPP;
295 
296         switch (eic) {
297         case EXT_IRQ_CLK_COMP:
298                 irq.type = KVM_S390_INT_CLOCK_COMP;
299                 break;
300         case EXT_IRQ_CPU_TIMER:
301                 irq.type = KVM_S390_INT_CPU_TIMER;
302                 break;
303         case EXT_IRQ_EXTERNAL_CALL:
304                 irq.type = KVM_S390_INT_EXTERNAL_CALL;
305                 irq.u.extcall.code = vcpu->arch.sie_block->extcpuaddr;
306                 rc = kvm_s390_inject_vcpu(vcpu, &irq);
307                 /* ignore if another external call is already pending */
308                 if (rc == -EBUSY)
309                         return 0;
310                 return rc;
311         default:
312                 return -EOPNOTSUPP;
313         }
314 
315         return kvm_s390_inject_vcpu(vcpu, &irq);
316 }
317 
318 /**
319  * Handle MOVE PAGE partial execution interception.
320  *
321  * This interception can only happen for guests with DAT disabled and
322  * addresses that are currently not mapped in the host. Thus we try to
323  * set up the mappings for the corresponding user pages here (or throw
324  * addressing exceptions in case of illegal guest addresses).
325  */
326 static int handle_mvpg_pei(struct kvm_vcpu *vcpu)
327 {
328         unsigned long srcaddr, dstaddr;
329         int reg1, reg2, rc;
330 
331         kvm_s390_get_regs_rre(vcpu, &reg1, &reg2);
332 
333         /* Make sure that the source is paged-in */
334         rc = guest_translate_address(vcpu, vcpu->run->s.regs.gprs[reg2],
335                                      reg2, &srcaddr, GACC_FETCH);
336         if (rc)
337                 return kvm_s390_inject_prog_cond(vcpu, rc);
338         rc = kvm_arch_fault_in_page(vcpu, srcaddr, 0);
339         if (rc != 0)
340                 return rc;
341 
342         /* Make sure that the destination is paged-in */
343         rc = guest_translate_address(vcpu, vcpu->run->s.regs.gprs[reg1],
344                                      reg1, &dstaddr, GACC_STORE);
345         if (rc)
346                 return kvm_s390_inject_prog_cond(vcpu, rc);
347         rc = kvm_arch_fault_in_page(vcpu, dstaddr, 1);
348         if (rc != 0)
349                 return rc;
350 
351         kvm_s390_retry_instr(vcpu);
352 
353         return 0;
354 }
355 
356 static int handle_partial_execution(struct kvm_vcpu *vcpu)
357 {
358         vcpu->stat.exit_pei++;
359 
360         if (vcpu->arch.sie_block->ipa == 0xb254)        /* MVPG */
361                 return handle_mvpg_pei(vcpu);
362         if (vcpu->arch.sie_block->ipa >> 8 == 0xae)     /* SIGP */
363                 return kvm_s390_handle_sigp_pei(vcpu);
364 
365         return -EOPNOTSUPP;
366 }
367 
368 /*
369  * Handle the sthyi instruction that provides the guest with system
370  * information, like current CPU resources available at each level of
371  * the machine.
372  */
373 int handle_sthyi(struct kvm_vcpu *vcpu)
374 {
375         int reg1, reg2, r = 0;
376         u64 code, addr, cc = 0, rc = 0;
377         struct sthyi_sctns *sctns = NULL;
378 
379         if (!test_kvm_facility(vcpu->kvm, 74))
380                 return kvm_s390_inject_program_int(vcpu, PGM_OPERATION);
381 
382         kvm_s390_get_regs_rre(vcpu, &reg1, &reg2);
383         code = vcpu->run->s.regs.gprs[reg1];
384         addr = vcpu->run->s.regs.gprs[reg2];
385 
386         vcpu->stat.instruction_sthyi++;
387         VCPU_EVENT(vcpu, 3, "STHYI: fc: %llu addr: 0x%016llx", code, addr);
388         trace_kvm_s390_handle_sthyi(vcpu, code, addr);
389 
390         if (reg1 == reg2 || reg1 & 1 || reg2 & 1)
391                 return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
392 
393         if (code & 0xffff) {
394                 cc = 3;
395                 rc = 4;
396                 goto out;
397         }
398 
399         if (addr & ~PAGE_MASK)
400                 return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
401 
402         sctns = (void *)get_zeroed_page(GFP_KERNEL);
403         if (!sctns)
404                 return -ENOMEM;
405 
406         cc = sthyi_fill(sctns, &rc);
407 
408 out:
409         if (!cc) {
410                 r = write_guest(vcpu, addr, reg2, sctns, PAGE_SIZE);
411                 if (r) {
412                         free_page((unsigned long)sctns);
413                         return kvm_s390_inject_prog_cond(vcpu, r);
414                 }
415         }
416 
417         free_page((unsigned long)sctns);
418         vcpu->run->s.regs.gprs[reg2 + 1] = rc;
419         kvm_s390_set_psw_cc(vcpu, cc);
420         return r;
421 }
422 
423 static int handle_operexc(struct kvm_vcpu *vcpu)
424 {
425         psw_t oldpsw, newpsw;
426         int rc;
427 
428         vcpu->stat.exit_operation_exception++;
429         trace_kvm_s390_handle_operexc(vcpu, vcpu->arch.sie_block->ipa,
430                                       vcpu->arch.sie_block->ipb);
431 
432         if (vcpu->arch.sie_block->ipa == 0xb256)
433                 return handle_sthyi(vcpu);
434 
435         if (vcpu->arch.sie_block->ipa == 0 && vcpu->kvm->arch.user_instr0)
436                 return -EOPNOTSUPP;
437         rc = read_guest_lc(vcpu, __LC_PGM_NEW_PSW, &newpsw, sizeof(psw_t));
438         if (rc)
439                 return rc;
440         /*
441          * Avoid endless loops of operation exceptions, if the pgm new
442          * PSW will cause a new operation exception.
443          * The heuristic checks if the pgm new psw is within 6 bytes before
444          * the faulting psw address (with same DAT, AS settings) and the
445          * new psw is not a wait psw and the fault was not triggered by
446          * problem state.
447          */
448         oldpsw = vcpu->arch.sie_block->gpsw;
449         if (oldpsw.addr - newpsw.addr <= 6 &&
450             !(newpsw.mask & PSW_MASK_WAIT) &&
451             !(oldpsw.mask & PSW_MASK_PSTATE) &&
452             (newpsw.mask & PSW_MASK_ASC) == (oldpsw.mask & PSW_MASK_ASC) &&
453             (newpsw.mask & PSW_MASK_DAT) == (oldpsw.mask & PSW_MASK_DAT))
454                 return -EOPNOTSUPP;
455 
456         return kvm_s390_inject_program_int(vcpu, PGM_OPERATION);
457 }
458 
459 int kvm_handle_sie_intercept(struct kvm_vcpu *vcpu)
460 {
461         int rc, per_rc = 0;
462 
463         if (kvm_is_ucontrol(vcpu->kvm))
464                 return -EOPNOTSUPP;
465 
466         switch (vcpu->arch.sie_block->icptcode) {
467         case ICPT_EXTREQ:
468         case ICPT_IOREQ:
469                 return handle_noop(vcpu);
470         case ICPT_INST:
471                 rc = handle_instruction(vcpu);
472                 break;
473         case ICPT_PROGI:
474                 return handle_prog(vcpu);
475         case ICPT_EXTINT:
476                 return handle_external_interrupt(vcpu);
477         case ICPT_WAIT:
478                 return kvm_s390_handle_wait(vcpu);
479         case ICPT_VALIDITY:
480                 return handle_validity(vcpu);
481         case ICPT_STOP:
482                 return handle_stop(vcpu);
483         case ICPT_OPEREXC:
484                 rc = handle_operexc(vcpu);
485                 break;
486         case ICPT_PARTEXEC:
487                 rc = handle_partial_execution(vcpu);
488                 break;
489         case ICPT_KSS:
490                 rc = kvm_s390_skey_check_enable(vcpu);
491                 break;
492         default:
493                 return -EOPNOTSUPP;
494         }
495 
496         /* process PER, also if the instrution is processed in user space */
497         if (vcpu->arch.sie_block->icptstatus & 0x02 &&
498             (!rc || rc == -EOPNOTSUPP))
499                 per_rc = kvm_s390_handle_per_ifetch_icpt(vcpu);
500         return per_rc ? per_rc : rc;
501 }
502 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp