priv.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772
  1. /*
  2. * handling privileged instructions
  3. *
  4. * Copyright IBM Corp. 2008, 2013
  5. *
  6. * This program is free software; you can redistribute it and/or modify
  7. * it under the terms of the GNU General Public License (version 2 only)
  8. * as published by the Free Software Foundation.
  9. *
  10. * Author(s): Carsten Otte <cotte@de.ibm.com>
  11. * Christian Borntraeger <borntraeger@de.ibm.com>
  12. */
  13. #include <linux/kvm.h>
  14. #include <linux/gfp.h>
  15. #include <linux/errno.h>
  16. #include <linux/compat.h>
  17. #include <asm/asm-offsets.h>
  18. #include <asm/facility.h>
  19. #include <asm/current.h>
  20. #include <asm/debug.h>
  21. #include <asm/ebcdic.h>
  22. #include <asm/sysinfo.h>
  23. #include <asm/pgtable.h>
  24. #include <asm/pgalloc.h>
  25. #include <asm/io.h>
  26. #include <asm/ptrace.h>
  27. #include <asm/compat.h>
  28. #include "gaccess.h"
  29. #include "kvm-s390.h"
  30. #include "trace.h"
  31. static int handle_set_prefix(struct kvm_vcpu *vcpu)
  32. {
  33. u64 operand2;
  34. u32 address = 0;
  35. u8 tmp;
  36. vcpu->stat.instruction_spx++;
  37. if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
  38. return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
  39. operand2 = kvm_s390_get_base_disp_s(vcpu);
  40. /* must be word boundary */
  41. if (operand2 & 3)
  42. return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
  43. /* get the value */
  44. if (get_guest(vcpu, address, (u32 __user *) operand2))
  45. return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
  46. address = address & 0x7fffe000u;
  47. /* make sure that the new value is valid memory */
  48. if (copy_from_guest_absolute(vcpu, &tmp, address, 1) ||
  49. (copy_from_guest_absolute(vcpu, &tmp, address + PAGE_SIZE, 1)))
  50. return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
  51. kvm_s390_set_prefix(vcpu, address);
  52. VCPU_EVENT(vcpu, 5, "setting prefix to %x", address);
  53. trace_kvm_s390_handle_prefix(vcpu, 1, address);
  54. return 0;
  55. }
  56. static int handle_store_prefix(struct kvm_vcpu *vcpu)
  57. {
  58. u64 operand2;
  59. u32 address;
  60. vcpu->stat.instruction_stpx++;
  61. if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
  62. return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
  63. operand2 = kvm_s390_get_base_disp_s(vcpu);
  64. /* must be word boundary */
  65. if (operand2 & 3)
  66. return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
  67. address = vcpu->arch.sie_block->prefix;
  68. address = address & 0x7fffe000u;
  69. /* get the value */
  70. if (put_guest(vcpu, address, (u32 __user *)operand2))
  71. return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
  72. VCPU_EVENT(vcpu, 5, "storing prefix to %x", address);
  73. trace_kvm_s390_handle_prefix(vcpu, 0, address);
  74. return 0;
  75. }
  76. static int handle_store_cpu_address(struct kvm_vcpu *vcpu)
  77. {
  78. u64 useraddr;
  79. vcpu->stat.instruction_stap++;
  80. if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
  81. return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
  82. useraddr = kvm_s390_get_base_disp_s(vcpu);
  83. if (useraddr & 1)
  84. return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
  85. if (put_guest(vcpu, vcpu->vcpu_id, (u16 __user *)useraddr))
  86. return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
  87. VCPU_EVENT(vcpu, 5, "storing cpu address to %llx", useraddr);
  88. trace_kvm_s390_handle_stap(vcpu, useraddr);
  89. return 0;
  90. }
  91. static int handle_skey(struct kvm_vcpu *vcpu)
  92. {
  93. vcpu->stat.instruction_storage_key++;
  94. if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
  95. return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
  96. vcpu->arch.sie_block->gpsw.addr =
  97. __rewind_psw(vcpu->arch.sie_block->gpsw, 4);
  98. VCPU_EVENT(vcpu, 4, "%s", "retrying storage key operation");
  99. return 0;
  100. }
  101. static int handle_tpi(struct kvm_vcpu *vcpu)
  102. {
  103. struct kvm_s390_interrupt_info *inti;
  104. u64 addr;
  105. int cc;
  106. addr = kvm_s390_get_base_disp_s(vcpu);
  107. if (addr & 3)
  108. return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
  109. cc = 0;
  110. inti = kvm_s390_get_io_int(vcpu->kvm, vcpu->run->s.regs.crs[6], 0);
  111. if (!inti)
  112. goto no_interrupt;
  113. cc = 1;
  114. if (addr) {
  115. /*
  116. * Store the two-word I/O interruption code into the
  117. * provided area.
  118. */
  119. if (put_guest(vcpu, inti->io.subchannel_id, (u16 __user *)addr)
  120. || put_guest(vcpu, inti->io.subchannel_nr, (u16 __user *)(addr + 2))
  121. || put_guest(vcpu, inti->io.io_int_parm, (u32 __user *)(addr + 4)))
  122. return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
  123. } else {
  124. /*
  125. * Store the three-word I/O interruption code into
  126. * the appropriate lowcore area.
  127. */
  128. put_guest(vcpu, inti->io.subchannel_id, (u16 __user *) __LC_SUBCHANNEL_ID);
  129. put_guest(vcpu, inti->io.subchannel_nr, (u16 __user *) __LC_SUBCHANNEL_NR);
  130. put_guest(vcpu, inti->io.io_int_parm, (u32 __user *) __LC_IO_INT_PARM);
  131. put_guest(vcpu, inti->io.io_int_word, (u32 __user *) __LC_IO_INT_WORD);
  132. }
  133. kfree(inti);
  134. no_interrupt:
  135. /* Set condition code and we're done. */
  136. vcpu->arch.sie_block->gpsw.mask &= ~(3ul << 44);
  137. vcpu->arch.sie_block->gpsw.mask |= (cc & 3ul) << 44;
  138. return 0;
  139. }
  140. static int handle_tsch(struct kvm_vcpu *vcpu)
  141. {
  142. struct kvm_s390_interrupt_info *inti;
  143. inti = kvm_s390_get_io_int(vcpu->kvm, 0,
  144. vcpu->run->s.regs.gprs[1]);
  145. /*
  146. * Prepare exit to userspace.
  147. * We indicate whether we dequeued a pending I/O interrupt
  148. * so that userspace can re-inject it if the instruction gets
  149. * a program check. While this may re-order the pending I/O
  150. * interrupts, this is no problem since the priority is kept
  151. * intact.
  152. */
  153. vcpu->run->exit_reason = KVM_EXIT_S390_TSCH;
  154. vcpu->run->s390_tsch.dequeued = !!inti;
  155. if (inti) {
  156. vcpu->run->s390_tsch.subchannel_id = inti->io.subchannel_id;
  157. vcpu->run->s390_tsch.subchannel_nr = inti->io.subchannel_nr;
  158. vcpu->run->s390_tsch.io_int_parm = inti->io.io_int_parm;
  159. vcpu->run->s390_tsch.io_int_word = inti->io.io_int_word;
  160. }
  161. vcpu->run->s390_tsch.ipb = vcpu->arch.sie_block->ipb;
  162. kfree(inti);
  163. return -EREMOTE;
  164. }
  165. static int handle_io_inst(struct kvm_vcpu *vcpu)
  166. {
  167. VCPU_EVENT(vcpu, 4, "%s", "I/O instruction");
  168. if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
  169. return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
  170. if (vcpu->kvm->arch.css_support) {
  171. /*
  172. * Most I/O instructions will be handled by userspace.
  173. * Exceptions are tpi and the interrupt portion of tsch.
  174. */
  175. if (vcpu->arch.sie_block->ipa == 0xb236)
  176. return handle_tpi(vcpu);
  177. if (vcpu->arch.sie_block->ipa == 0xb235)
  178. return handle_tsch(vcpu);
  179. /* Handle in userspace. */
  180. return -EOPNOTSUPP;
  181. } else {
  182. /*
  183. * Set condition code 3 to stop the guest from issueing channel
  184. * I/O instructions.
  185. */
  186. vcpu->arch.sie_block->gpsw.mask &= ~(3ul << 44);
  187. vcpu->arch.sie_block->gpsw.mask |= (3 & 3ul) << 44;
  188. return 0;
  189. }
  190. }
  191. static int handle_stfl(struct kvm_vcpu *vcpu)
  192. {
  193. unsigned int facility_list;
  194. int rc;
  195. vcpu->stat.instruction_stfl++;
  196. if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
  197. return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
  198. /* only pass the facility bits, which we can handle */
  199. facility_list = S390_lowcore.stfl_fac_list & 0xff82fff3;
  200. rc = copy_to_guest(vcpu, offsetof(struct _lowcore, stfl_fac_list),
  201. &facility_list, sizeof(facility_list));
  202. if (rc)
  203. return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
  204. VCPU_EVENT(vcpu, 5, "store facility list value %x", facility_list);
  205. trace_kvm_s390_handle_stfl(vcpu, facility_list);
  206. return 0;
  207. }
  208. static void handle_new_psw(struct kvm_vcpu *vcpu)
  209. {
  210. /* Check whether the new psw is enabled for machine checks. */
  211. if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_MCHECK)
  212. kvm_s390_deliver_pending_machine_checks(vcpu);
  213. }
  214. #define PSW_MASK_ADDR_MODE (PSW_MASK_EA | PSW_MASK_BA)
  215. #define PSW_MASK_UNASSIGNED 0xb80800fe7fffffffUL
  216. #define PSW_ADDR_24 0x0000000000ffffffUL
  217. #define PSW_ADDR_31 0x000000007fffffffUL
  218. static int is_valid_psw(psw_t *psw) {
  219. if (psw->mask & PSW_MASK_UNASSIGNED)
  220. return 0;
  221. if ((psw->mask & PSW_MASK_ADDR_MODE) == PSW_MASK_BA) {
  222. if (psw->addr & ~PSW_ADDR_31)
  223. return 0;
  224. }
  225. if (!(psw->mask & PSW_MASK_ADDR_MODE) && (psw->addr & ~PSW_ADDR_24))
  226. return 0;
  227. if ((psw->mask & PSW_MASK_ADDR_MODE) == PSW_MASK_EA)
  228. return 0;
  229. return 1;
  230. }
  231. int kvm_s390_handle_lpsw(struct kvm_vcpu *vcpu)
  232. {
  233. psw_t *gpsw = &vcpu->arch.sie_block->gpsw;
  234. psw_compat_t new_psw;
  235. u64 addr;
  236. if (gpsw->mask & PSW_MASK_PSTATE)
  237. return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
  238. addr = kvm_s390_get_base_disp_s(vcpu);
  239. if (addr & 7)
  240. return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
  241. if (copy_from_guest(vcpu, &new_psw, addr, sizeof(new_psw)))
  242. return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
  243. if (!(new_psw.mask & PSW32_MASK_BASE))
  244. return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
  245. gpsw->mask = (new_psw.mask & ~PSW32_MASK_BASE) << 32;
  246. gpsw->mask |= new_psw.addr & PSW32_ADDR_AMODE;
  247. gpsw->addr = new_psw.addr & ~PSW32_ADDR_AMODE;
  248. if (!is_valid_psw(gpsw))
  249. return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
  250. handle_new_psw(vcpu);
  251. return 0;
  252. }
  253. static int handle_lpswe(struct kvm_vcpu *vcpu)
  254. {
  255. psw_t new_psw;
  256. u64 addr;
  257. if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
  258. return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
  259. addr = kvm_s390_get_base_disp_s(vcpu);
  260. if (addr & 7)
  261. return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
  262. if (copy_from_guest(vcpu, &new_psw, addr, sizeof(new_psw)))
  263. return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
  264. vcpu->arch.sie_block->gpsw = new_psw;
  265. if (!is_valid_psw(&vcpu->arch.sie_block->gpsw))
  266. return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
  267. handle_new_psw(vcpu);
  268. return 0;
  269. }
  270. static int handle_stidp(struct kvm_vcpu *vcpu)
  271. {
  272. u64 operand2;
  273. vcpu->stat.instruction_stidp++;
  274. if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
  275. return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
  276. operand2 = kvm_s390_get_base_disp_s(vcpu);
  277. if (operand2 & 7)
  278. return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
  279. if (put_guest(vcpu, vcpu->arch.stidp_data, (u64 __user *)operand2))
  280. return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
  281. VCPU_EVENT(vcpu, 5, "%s", "store cpu id");
  282. return 0;
  283. }
  284. static void handle_stsi_3_2_2(struct kvm_vcpu *vcpu, struct sysinfo_3_2_2 *mem)
  285. {
  286. struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
  287. int cpus = 0;
  288. int n;
  289. spin_lock(&fi->lock);
  290. for (n = 0; n < KVM_MAX_VCPUS; n++)
  291. if (fi->local_int[n])
  292. cpus++;
  293. spin_unlock(&fi->lock);
  294. /* deal with other level 3 hypervisors */
  295. if (stsi(mem, 3, 2, 2))
  296. mem->count = 0;
  297. if (mem->count < 8)
  298. mem->count++;
  299. for (n = mem->count - 1; n > 0 ; n--)
  300. memcpy(&mem->vm[n], &mem->vm[n - 1], sizeof(mem->vm[0]));
  301. mem->vm[0].cpus_total = cpus;
  302. mem->vm[0].cpus_configured = cpus;
  303. mem->vm[0].cpus_standby = 0;
  304. mem->vm[0].cpus_reserved = 0;
  305. mem->vm[0].caf = 1000;
  306. memcpy(mem->vm[0].name, "KVMguest", 8);
  307. ASCEBC(mem->vm[0].name, 8);
  308. memcpy(mem->vm[0].cpi, "KVM/Linux ", 16);
  309. ASCEBC(mem->vm[0].cpi, 16);
  310. }
  311. static int handle_stsi(struct kvm_vcpu *vcpu)
  312. {
  313. int fc = (vcpu->run->s.regs.gprs[0] & 0xf0000000) >> 28;
  314. int sel1 = vcpu->run->s.regs.gprs[0] & 0xff;
  315. int sel2 = vcpu->run->s.regs.gprs[1] & 0xffff;
  316. unsigned long mem = 0;
  317. u64 operand2;
  318. int rc = 0;
  319. vcpu->stat.instruction_stsi++;
  320. VCPU_EVENT(vcpu, 4, "stsi: fc: %x sel1: %x sel2: %x", fc, sel1, sel2);
  321. if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
  322. return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
  323. if (fc > 3) {
  324. vcpu->arch.sie_block->gpsw.mask |= 3ul << 44; /* cc 3 */
  325. return 0;
  326. }
  327. if (vcpu->run->s.regs.gprs[0] & 0x0fffff00
  328. || vcpu->run->s.regs.gprs[1] & 0xffff0000)
  329. return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
  330. if (fc == 0) {
  331. vcpu->run->s.regs.gprs[0] = 3 << 28;
  332. vcpu->arch.sie_block->gpsw.mask &= ~(3ul << 44); /* cc 0 */
  333. return 0;
  334. }
  335. operand2 = kvm_s390_get_base_disp_s(vcpu);
  336. if (operand2 & 0xfff)
  337. return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
  338. switch (fc) {
  339. case 1: /* same handling for 1 and 2 */
  340. case 2:
  341. mem = get_zeroed_page(GFP_KERNEL);
  342. if (!mem)
  343. goto out_no_data;
  344. if (stsi((void *) mem, fc, sel1, sel2))
  345. goto out_no_data;
  346. break;
  347. case 3:
  348. if (sel1 != 2 || sel2 != 2)
  349. goto out_no_data;
  350. mem = get_zeroed_page(GFP_KERNEL);
  351. if (!mem)
  352. goto out_no_data;
  353. handle_stsi_3_2_2(vcpu, (void *) mem);
  354. break;
  355. }
  356. if (copy_to_guest_absolute(vcpu, operand2, (void *) mem, PAGE_SIZE)) {
  357. rc = kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
  358. goto out_exception;
  359. }
  360. trace_kvm_s390_handle_stsi(vcpu, fc, sel1, sel2, operand2);
  361. free_page(mem);
  362. vcpu->arch.sie_block->gpsw.mask &= ~(3ul << 44);
  363. vcpu->run->s.regs.gprs[0] = 0;
  364. return 0;
  365. out_no_data:
  366. /* condition code 3 */
  367. vcpu->arch.sie_block->gpsw.mask |= 3ul << 44;
  368. out_exception:
  369. free_page(mem);
  370. return rc;
  371. }
  372. static const intercept_handler_t b2_handlers[256] = {
  373. [0x02] = handle_stidp,
  374. [0x10] = handle_set_prefix,
  375. [0x11] = handle_store_prefix,
  376. [0x12] = handle_store_cpu_address,
  377. [0x29] = handle_skey,
  378. [0x2a] = handle_skey,
  379. [0x2b] = handle_skey,
  380. [0x30] = handle_io_inst,
  381. [0x31] = handle_io_inst,
  382. [0x32] = handle_io_inst,
  383. [0x33] = handle_io_inst,
  384. [0x34] = handle_io_inst,
  385. [0x35] = handle_io_inst,
  386. [0x36] = handle_io_inst,
  387. [0x37] = handle_io_inst,
  388. [0x38] = handle_io_inst,
  389. [0x39] = handle_io_inst,
  390. [0x3a] = handle_io_inst,
  391. [0x3b] = handle_io_inst,
  392. [0x3c] = handle_io_inst,
  393. [0x5f] = handle_io_inst,
  394. [0x74] = handle_io_inst,
  395. [0x76] = handle_io_inst,
  396. [0x7d] = handle_stsi,
  397. [0xb1] = handle_stfl,
  398. [0xb2] = handle_lpswe,
  399. };
  400. int kvm_s390_handle_b2(struct kvm_vcpu *vcpu)
  401. {
  402. intercept_handler_t handler;
  403. /*
  404. * A lot of B2 instructions are priviledged. Here we check for
  405. * the privileged ones, that we can handle in the kernel.
  406. * Anything else goes to userspace.
  407. */
  408. handler = b2_handlers[vcpu->arch.sie_block->ipa & 0x00ff];
  409. if (handler)
  410. return handler(vcpu);
  411. return -EOPNOTSUPP;
  412. }
  413. static int handle_epsw(struct kvm_vcpu *vcpu)
  414. {
  415. int reg1, reg2;
  416. kvm_s390_get_regs_rre(vcpu, &reg1, &reg2);
  417. /* This basically extracts the mask half of the psw. */
  418. vcpu->run->s.regs.gprs[reg1] &= 0xffffffff00000000;
  419. vcpu->run->s.regs.gprs[reg1] |= vcpu->arch.sie_block->gpsw.mask >> 32;
  420. if (reg2) {
  421. vcpu->run->s.regs.gprs[reg2] &= 0xffffffff00000000;
  422. vcpu->run->s.regs.gprs[reg2] |=
  423. vcpu->arch.sie_block->gpsw.mask & 0x00000000ffffffff;
  424. }
  425. return 0;
  426. }
  427. #define PFMF_RESERVED 0xfffc0101UL
  428. #define PFMF_SK 0x00020000UL
  429. #define PFMF_CF 0x00010000UL
  430. #define PFMF_UI 0x00008000UL
  431. #define PFMF_FSC 0x00007000UL
  432. #define PFMF_NQ 0x00000800UL
  433. #define PFMF_MR 0x00000400UL
  434. #define PFMF_MC 0x00000200UL
  435. #define PFMF_KEY 0x000000feUL
  436. static int handle_pfmf(struct kvm_vcpu *vcpu)
  437. {
  438. int reg1, reg2;
  439. unsigned long start, end;
  440. vcpu->stat.instruction_pfmf++;
  441. kvm_s390_get_regs_rre(vcpu, &reg1, &reg2);
  442. if (!MACHINE_HAS_PFMF)
  443. return kvm_s390_inject_program_int(vcpu, PGM_OPERATION);
  444. if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
  445. return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
  446. if (vcpu->run->s.regs.gprs[reg1] & PFMF_RESERVED)
  447. return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
  448. /* Only provide non-quiescing support if the host supports it */
  449. if (vcpu->run->s.regs.gprs[reg1] & PFMF_NQ && !test_facility(14))
  450. return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
  451. /* No support for conditional-SSKE */
  452. if (vcpu->run->s.regs.gprs[reg1] & (PFMF_MR | PFMF_MC))
  453. return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
  454. start = vcpu->run->s.regs.gprs[reg2] & PAGE_MASK;
  455. switch (vcpu->run->s.regs.gprs[reg1] & PFMF_FSC) {
  456. case 0x00000000:
  457. end = (start + (1UL << 12)) & ~((1UL << 12) - 1);
  458. break;
  459. case 0x00001000:
  460. end = (start + (1UL << 20)) & ~((1UL << 20) - 1);
  461. break;
  462. /* We dont support EDAT2
  463. case 0x00002000:
  464. end = (start + (1UL << 31)) & ~((1UL << 31) - 1);
  465. break;*/
  466. default:
  467. return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
  468. }
  469. while (start < end) {
  470. unsigned long useraddr;
  471. useraddr = gmap_translate(start, vcpu->arch.gmap);
  472. if (IS_ERR((void *)useraddr))
  473. return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
  474. if (vcpu->run->s.regs.gprs[reg1] & PFMF_CF) {
  475. if (clear_user((void __user *)useraddr, PAGE_SIZE))
  476. return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
  477. }
  478. if (vcpu->run->s.regs.gprs[reg1] & PFMF_SK) {
  479. if (set_guest_storage_key(current->mm, useraddr,
  480. vcpu->run->s.regs.gprs[reg1] & PFMF_KEY,
  481. vcpu->run->s.regs.gprs[reg1] & PFMF_NQ))
  482. return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
  483. }
  484. start += PAGE_SIZE;
  485. }
  486. if (vcpu->run->s.regs.gprs[reg1] & PFMF_FSC)
  487. vcpu->run->s.regs.gprs[reg2] = end;
  488. return 0;
  489. }
  490. static const intercept_handler_t b9_handlers[256] = {
  491. [0x8d] = handle_epsw,
  492. [0x9c] = handle_io_inst,
  493. [0xaf] = handle_pfmf,
  494. };
  495. int kvm_s390_handle_b9(struct kvm_vcpu *vcpu)
  496. {
  497. intercept_handler_t handler;
  498. /* This is handled just as for the B2 instructions. */
  499. handler = b9_handlers[vcpu->arch.sie_block->ipa & 0x00ff];
  500. if (handler)
  501. return handler(vcpu);
  502. return -EOPNOTSUPP;
  503. }
  504. int kvm_s390_handle_lctl(struct kvm_vcpu *vcpu)
  505. {
  506. int reg1 = (vcpu->arch.sie_block->ipa & 0x00f0) >> 4;
  507. int reg3 = vcpu->arch.sie_block->ipa & 0x000f;
  508. u64 useraddr;
  509. u32 val = 0;
  510. int reg, rc;
  511. vcpu->stat.instruction_lctl++;
  512. if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
  513. return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
  514. useraddr = kvm_s390_get_base_disp_rs(vcpu);
  515. if (useraddr & 3)
  516. return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
  517. VCPU_EVENT(vcpu, 5, "lctl r1:%x, r3:%x, addr:%llx", reg1, reg3,
  518. useraddr);
  519. trace_kvm_s390_handle_lctl(vcpu, 0, reg1, reg3, useraddr);
  520. reg = reg1;
  521. do {
  522. rc = get_guest(vcpu, val, (u32 __user *) useraddr);
  523. if (rc)
  524. return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
  525. vcpu->arch.sie_block->gcr[reg] &= 0xffffffff00000000ul;
  526. vcpu->arch.sie_block->gcr[reg] |= val;
  527. useraddr += 4;
  528. if (reg == reg3)
  529. break;
  530. reg = (reg + 1) % 16;
  531. } while (1);
  532. return 0;
  533. }
  534. static int handle_lctlg(struct kvm_vcpu *vcpu)
  535. {
  536. int reg1 = (vcpu->arch.sie_block->ipa & 0x00f0) >> 4;
  537. int reg3 = vcpu->arch.sie_block->ipa & 0x000f;
  538. u64 useraddr;
  539. int reg, rc;
  540. vcpu->stat.instruction_lctlg++;
  541. if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
  542. return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
  543. useraddr = kvm_s390_get_base_disp_rsy(vcpu);
  544. if (useraddr & 7)
  545. return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
  546. reg = reg1;
  547. VCPU_EVENT(vcpu, 5, "lctlg r1:%x, r3:%x, addr:%llx", reg1, reg3,
  548. useraddr);
  549. trace_kvm_s390_handle_lctl(vcpu, 1, reg1, reg3, useraddr);
  550. do {
  551. rc = get_guest(vcpu, vcpu->arch.sie_block->gcr[reg],
  552. (u64 __user *) useraddr);
  553. if (rc)
  554. return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
  555. useraddr += 8;
  556. if (reg == reg3)
  557. break;
  558. reg = (reg + 1) % 16;
  559. } while (1);
  560. return 0;
  561. }
  562. static const intercept_handler_t eb_handlers[256] = {
  563. [0x2f] = handle_lctlg,
  564. [0x8a] = handle_io_inst,
  565. };
  566. int kvm_s390_handle_eb(struct kvm_vcpu *vcpu)
  567. {
  568. intercept_handler_t handler;
  569. handler = eb_handlers[vcpu->arch.sie_block->ipb & 0xff];
  570. if (handler)
  571. return handler(vcpu);
  572. return -EOPNOTSUPP;
  573. }
  574. static int handle_tprot(struct kvm_vcpu *vcpu)
  575. {
  576. u64 address1, address2;
  577. struct vm_area_struct *vma;
  578. unsigned long user_address;
  579. vcpu->stat.instruction_tprot++;
  580. if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
  581. return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
  582. kvm_s390_get_base_disp_sse(vcpu, &address1, &address2);
  583. /* we only handle the Linux memory detection case:
  584. * access key == 0
  585. * guest DAT == off
  586. * everything else goes to userspace. */
  587. if (address2 & 0xf0)
  588. return -EOPNOTSUPP;
  589. if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_DAT)
  590. return -EOPNOTSUPP;
  591. down_read(&current->mm->mmap_sem);
  592. user_address = __gmap_translate(address1, vcpu->arch.gmap);
  593. if (IS_ERR_VALUE(user_address))
  594. goto out_inject;
  595. vma = find_vma(current->mm, user_address);
  596. if (!vma)
  597. goto out_inject;
  598. vcpu->arch.sie_block->gpsw.mask &= ~(3ul << 44);
  599. if (!(vma->vm_flags & VM_WRITE) && (vma->vm_flags & VM_READ))
  600. vcpu->arch.sie_block->gpsw.mask |= (1ul << 44);
  601. if (!(vma->vm_flags & VM_WRITE) && !(vma->vm_flags & VM_READ))
  602. vcpu->arch.sie_block->gpsw.mask |= (2ul << 44);
  603. up_read(&current->mm->mmap_sem);
  604. return 0;
  605. out_inject:
  606. up_read(&current->mm->mmap_sem);
  607. return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
  608. }
  609. int kvm_s390_handle_e5(struct kvm_vcpu *vcpu)
  610. {
  611. /* For e5xx... instructions we only handle TPROT */
  612. if ((vcpu->arch.sie_block->ipa & 0x00ff) == 0x01)
  613. return handle_tprot(vcpu);
  614. return -EOPNOTSUPP;
  615. }
  616. static int handle_sckpf(struct kvm_vcpu *vcpu)
  617. {
  618. u32 value;
  619. if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
  620. return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
  621. if (vcpu->run->s.regs.gprs[0] & 0x00000000ffff0000)
  622. return kvm_s390_inject_program_int(vcpu,
  623. PGM_SPECIFICATION);
  624. value = vcpu->run->s.regs.gprs[0] & 0x000000000000ffff;
  625. vcpu->arch.sie_block->todpr = value;
  626. return 0;
  627. }
  628. static const intercept_handler_t x01_handlers[256] = {
  629. [0x07] = handle_sckpf,
  630. };
  631. int kvm_s390_handle_01(struct kvm_vcpu *vcpu)
  632. {
  633. intercept_handler_t handler;
  634. handler = x01_handlers[vcpu->arch.sie_block->ipa & 0x00ff];
  635. if (handler)
  636. return handler(vcpu);
  637. return -EOPNOTSUPP;
  638. }