PageRenderTime 36ms CodeModel.GetById 15ms RepoModel.GetById 0ms app.codeStats 0ms

/arch/s390/kvm/gaccess.h

https://bitbucket.org/cresqo/cm7-p500-kernel
C Header | 279 lines | 198 code | 70 blank | 11 comment | 45 complexity | a9ddd220d9a814279f54ac7899328f45 MD5 | raw file
Possible License(s): LGPL-2.0, AGPL-1.0, GPL-2.0 
    

  1. /*
    2. 

  2.  * gaccess.h -  access guest memory
    3. 

  3.  *
    4. 

  4.  * Copyright IBM Corp. 2008,2009
    5. 

  5.  *
    6. 

  6.  * This program is free software; you can redistribute it and/or modify
    7. 

  7.  * it under the terms of the GNU General Public License (version 2 only)
    8. 

  8.  * as published by the Free Software Foundation.
    9. 

  9.  *
    10. 

  10.  *    Author(s): Carsten Otte <cotte@de.ibm.com>
    11. 

  11.  */
    12. 

  12. 

  13. #ifndef __KVM_S390_GACCESS_H
    14. 

  14. #define __KVM_S390_GACCESS_H
    15. 

  15. 

  16. #include <linux/compiler.h>
    17. 

  17. #include <linux/kvm_host.h>
    18. 

  18. #include <asm/uaccess.h>
    19. 

  19. #include "kvm-s390.h"
    20. 

  20. 

  21. static inline void __user *__guestaddr_to_user(struct kvm_vcpu *vcpu,
    22. 

  22. 					       unsigned long guestaddr)
    23. 

  23. {
    24. 

  24. 	unsigned long prefix  = vcpu->arch.sie_block->prefix;
    25. 

  25. 	unsigned long origin  = vcpu->arch.sie_block->gmsor;
    26. 

  26. 	unsigned long memsize = kvm_s390_vcpu_get_memsize(vcpu);
    27. 

  27. 

  28. 	if (guestaddr < 2 * PAGE_SIZE)
    29. 

  29. 		guestaddr += prefix;
    30. 

  30. 	else if ((guestaddr >= prefix) && (guestaddr < prefix + 2 * PAGE_SIZE))
    31. 

  31. 		guestaddr -= prefix;
    32. 

  32. 

  33. 	if (guestaddr > memsize)
    34. 

  34. 		return (void __user __force *) ERR_PTR(-EFAULT);
    35. 

  35. 

  36. 	guestaddr += origin;
    37. 

  37. 

  38. 	return (void __user *) guestaddr;
    39. 

  39. }
    40. 

  40. 

  41. static inline int get_guest_u64(struct kvm_vcpu *vcpu, unsigned long guestaddr,
    42. 

  42. 				u64 *result)
    43. 

  43. {
    44. 

  44. 	void __user *uptr = __guestaddr_to_user(vcpu, guestaddr);
    45. 

  45. 

  46. 	BUG_ON(guestaddr & 7);
    47. 

  47. 

  48. 	if (IS_ERR((void __force *) uptr))
    49. 

  49. 		return PTR_ERR((void __force *) uptr);
    50. 

  50. 

  51. 	return get_user(*result, (unsigned long __user *) uptr);
    52. 

  52. }
    53. 

  53. 

  54. static inline int get_guest_u32(struct kvm_vcpu *vcpu, unsigned long guestaddr,
    55. 

  55. 				u32 *result)
    56. 

  56. {
    57. 

  57. 	void __user *uptr = __guestaddr_to_user(vcpu, guestaddr);
    58. 

  58. 

  59. 	BUG_ON(guestaddr & 3);
    60. 

  60. 

  61. 	if (IS_ERR((void __force *) uptr))
    62. 

  62. 		return PTR_ERR((void __force *) uptr);
    63. 

  63. 

  64. 	return get_user(*result, (u32 __user *) uptr);
    65. 

  65. }
    66. 

  66. 

  67. static inline int get_guest_u16(struct kvm_vcpu *vcpu, unsigned long guestaddr,
    68. 

  68. 				u16 *result)
    69. 

  69. {
    70. 

  70. 	void __user *uptr = __guestaddr_to_user(vcpu, guestaddr);
    71. 

  71. 

  72. 	BUG_ON(guestaddr & 1);
    73. 

  73. 

  74. 	if (IS_ERR(uptr))
    75. 

  75. 		return PTR_ERR(uptr);
    76. 

  76. 

  77. 	return get_user(*result, (u16 __user *) uptr);
    78. 

  78. }
    79. 

  79. 

  80. static inline int get_guest_u8(struct kvm_vcpu *vcpu, unsigned long guestaddr,
    81. 

  81. 			       u8 *result)
    82. 

  82. {
    83. 

  83. 	void __user *uptr = __guestaddr_to_user(vcpu, guestaddr);
    84. 

  84. 

  85. 	if (IS_ERR((void __force *) uptr))
    86. 

  86. 		return PTR_ERR((void __force *) uptr);
    87. 

  87. 

  88. 	return get_user(*result, (u8 __user *) uptr);
    89. 

  89. }
    90. 

  90. 

  91. static inline int put_guest_u64(struct kvm_vcpu *vcpu, unsigned long guestaddr,
    92. 

  92. 				u64 value)
    93. 

  93. {
    94. 

  94. 	void __user *uptr = __guestaddr_to_user(vcpu, guestaddr);
    95. 

  95. 

  96. 	BUG_ON(guestaddr & 7);
    97. 

  97. 

  98. 	if (IS_ERR((void __force *) uptr))
    99. 

  99. 		return PTR_ERR((void __force *) uptr);
    100. 

  100. 

  101. 	return put_user(value, (u64 __user *) uptr);
    102. 

  102. }
    103. 

  103. 

  104. static inline int put_guest_u32(struct kvm_vcpu *vcpu, unsigned long guestaddr,
    105. 

  105. 				u32 value)
    106. 

  106. {
    107. 

  107. 	void __user *uptr = __guestaddr_to_user(vcpu, guestaddr);
    108. 

  108. 

  109. 	BUG_ON(guestaddr & 3);
    110. 

  110. 

  111. 	if (IS_ERR((void __force *) uptr))
    112. 

  112. 		return PTR_ERR((void __force *) uptr);
    113. 

  113. 

  114. 	return put_user(value, (u32 __user *) uptr);
    115. 

  115. }
    116. 

  116. 

  117. static inline int put_guest_u16(struct kvm_vcpu *vcpu, unsigned long guestaddr,
    118. 

  118. 				u16 value)
    119. 

  119. {
    120. 

  120. 	void __user *uptr = __guestaddr_to_user(vcpu, guestaddr);
    121. 

  121. 

  122. 	BUG_ON(guestaddr & 1);
    123. 

  123. 

  124. 	if (IS_ERR((void __force *) uptr))
    125. 

  125. 		return PTR_ERR((void __force *) uptr);
    126. 

  126. 

  127. 	return put_user(value, (u16 __user *) uptr);
    128. 

  128. }
    129. 

  129. 

  130. static inline int put_guest_u8(struct kvm_vcpu *vcpu, unsigned long guestaddr,
    131. 

  131. 			       u8 value)
    132. 

  132. {
    133. 

  133. 	void __user *uptr = __guestaddr_to_user(vcpu, guestaddr);
    134. 

  134. 

  135. 	if (IS_ERR((void __force *) uptr))
    136. 

  136. 		return PTR_ERR((void __force *) uptr);
    137. 

  137. 

  138. 	return put_user(value, (u8 __user *) uptr);
    139. 

  139. }
    140. 

  140. 

  141. 

  142. static inline int __copy_to_guest_slow(struct kvm_vcpu *vcpu,
    143. 

  143. 				       unsigned long guestdest,
    144. 

  144. 				       const void *from, unsigned long n)
    145. 

  145. {
    146. 

  146. 	int rc;
    147. 

  147. 	unsigned long i;
    148. 

  148. 	const u8 *data = from;
    149. 

  149. 

  150. 	for (i = 0; i < n; i++) {
    151. 

  151. 		rc = put_guest_u8(vcpu, guestdest++, *(data++));
    152. 

  152. 		if (rc < 0)
    153. 

  153. 			return rc;
    154. 

  154. 	}
    155. 

  155. 	return 0;
    156. 

  156. }
    157. 

  157. 

  158. static inline int copy_to_guest(struct kvm_vcpu *vcpu, unsigned long guestdest,
    159. 

  159. 				const void *from, unsigned long n)
    160. 

  160. {
    161. 

  161. 	unsigned long prefix  = vcpu->arch.sie_block->prefix;
    162. 

  162. 	unsigned long origin  = vcpu->arch.sie_block->gmsor;
    163. 

  163. 	unsigned long memsize = kvm_s390_vcpu_get_memsize(vcpu);
    164. 

  164. 

  165. 	if ((guestdest < 2 * PAGE_SIZE) && (guestdest + n > 2 * PAGE_SIZE))
    166. 

  166. 		goto slowpath;
    167. 

  167. 

  168. 	if ((guestdest < prefix) && (guestdest + n > prefix))
    169. 

  169. 		goto slowpath;
    170. 

  170. 

  171. 	if ((guestdest < prefix + 2 * PAGE_SIZE)
    172. 

  172. 	    && (guestdest + n > prefix + 2 * PAGE_SIZE))
    173. 

  173. 		goto slowpath;
    174. 

  174. 

  175. 	if (guestdest < 2 * PAGE_SIZE)
    176. 

  176. 		guestdest += prefix;
    177. 

  177. 	else if ((guestdest >= prefix) && (guestdest < prefix + 2 * PAGE_SIZE))
    178. 

  178. 		guestdest -= prefix;
    179. 

  179. 

  180. 	if (guestdest + n > memsize)
    181. 

  181. 		return -EFAULT;
    182. 

  182. 

  183. 	if (guestdest + n < guestdest)
    184. 

  184. 		return -EFAULT;
    185. 

  185. 

  186. 	guestdest += origin;
    187. 

  187. 

  188. 	return copy_to_user((void __user *) guestdest, from, n);
    189. 

  189. slowpath:
    190. 

  190. 	return __copy_to_guest_slow(vcpu, guestdest, from, n);
    191. 

  191. }
    192. 

  192. 

  193. static inline int __copy_from_guest_slow(struct kvm_vcpu *vcpu, void *to,
    194. 

  194. 					 unsigned long guestsrc,
    195. 

  195. 					 unsigned long n)
    196. 

  196. {
    197. 

  197. 	int rc;
    198. 

  198. 	unsigned long i;
    199. 

  199. 	u8 *data = to;
    200. 

  200. 

  201. 	for (i = 0; i < n; i++) {
    202. 

  202. 		rc = get_guest_u8(vcpu, guestsrc++, data++);
    203. 

  203. 		if (rc < 0)
    204. 

  204. 			return rc;
    205. 

  205. 	}
    206. 

  206. 	return 0;
    207. 

  207. }
    208. 

  208. 

  209. static inline int copy_from_guest(struct kvm_vcpu *vcpu, void *to,
    210. 

  210. 				  unsigned long guestsrc, unsigned long n)
    211. 

  211. {
    212. 

  212. 	unsigned long prefix  = vcpu->arch.sie_block->prefix;
    213. 

  213. 	unsigned long origin  = vcpu->arch.sie_block->gmsor;
    214. 

  214. 	unsigned long memsize = kvm_s390_vcpu_get_memsize(vcpu);
    215. 

  215. 

  216. 	if ((guestsrc < 2 * PAGE_SIZE) && (guestsrc + n > 2 * PAGE_SIZE))
    217. 

  217. 		goto slowpath;
    218. 

  218. 

  219. 	if ((guestsrc < prefix) && (guestsrc + n > prefix))
    220. 

  220. 		goto slowpath;
    221. 

  221. 

  222. 	if ((guestsrc < prefix + 2 * PAGE_SIZE)
    223. 

  223. 	    && (guestsrc + n > prefix + 2 * PAGE_SIZE))
    224. 

  224. 		goto slowpath;
    225. 

  225. 

  226. 	if (guestsrc < 2 * PAGE_SIZE)
    227. 

  227. 		guestsrc += prefix;
    228. 

  228. 	else if ((guestsrc >= prefix) && (guestsrc < prefix + 2 * PAGE_SIZE))
    229. 

  229. 		guestsrc -= prefix;
    230. 

  230. 

  231. 	if (guestsrc + n > memsize)
    232. 

  232. 		return -EFAULT;
    233. 

  233. 

  234. 	if (guestsrc + n < guestsrc)
    235. 

  235. 		return -EFAULT;
    236. 

  236. 

  237. 	guestsrc += origin;
    238. 

  238. 

  239. 	return copy_from_user(to, (void __user *) guestsrc, n);
    240. 

  240. slowpath:
    241. 

  241. 	return __copy_from_guest_slow(vcpu, to, guestsrc, n);
    242. 

  242. }
    243. 

  243. 

  244. static inline int copy_to_guest_absolute(struct kvm_vcpu *vcpu,
    245. 

  245. 					 unsigned long guestdest,
    246. 

  246. 					 const void *from, unsigned long n)
    247. 

  247. {
    248. 

  248. 	unsigned long origin  = vcpu->arch.sie_block->gmsor;
    249. 

  249. 	unsigned long memsize = kvm_s390_vcpu_get_memsize(vcpu);
    250. 

  250. 

  251. 	if (guestdest + n > memsize)
    252. 

  252. 		return -EFAULT;
    253. 

  253. 

  254. 	if (guestdest + n < guestdest)
    255. 

  255. 		return -EFAULT;
    256. 

  256. 

  257. 	guestdest += origin;
    258. 

  258. 

  259. 	return copy_to_user((void __user *) guestdest, from, n);
    260. 

  260. }
    261. 

  261. 

  262. static inline int copy_from_guest_absolute(struct kvm_vcpu *vcpu, void *to,
    263. 

  263. 					   unsigned long guestsrc,
    264. 

  264. 					   unsigned long n)
    265. 

  265. {
    266. 

  266. 	unsigned long origin  = vcpu->arch.sie_block->gmsor;
    267. 

  267. 	unsigned long memsize = kvm_s390_vcpu_get_memsize(vcpu);
    268. 

  268. 

  269. 	if (guestsrc + n > memsize)
    270. 

  270. 		return -EFAULT;
    271. 

  271. 

  272. 	if (guestsrc + n < guestsrc)
    273. 

  273. 		return -EFAULT;
    274. 

  274. 

  275. 	guestsrc += origin;
    276. 

  276. 

  277. 	return copy_from_user(to, (void __user *) guestsrc, n);
    278. 

  278. }
    279. 

  279. #endif
    280. 

  280.