PageRenderTime 6435ms CodeModel.GetById 26ms RepoModel.GetById 0ms app.codeStats 1ms

/SPECS/linux/0008-Drivers-hv-vmbus-Use-all-supported-IC-versions-to-ne.patch

https://gitlab.com/unofficial-mirrors/vmware-photon
Patch | 492 lines | 455 code | 37 blank | 0 comment | 0 complexity | e44632561d786c98eef5e8a2d587c413 MD5 | raw file
    

  1. From 66955115f0d8764a93c4ec9291d917d4a8be3e8f Mon Sep 17 00:00:00 2001
    2. 

  2. From: Alex Ng <alexng@messages.microsoft.com>
    3. 

  3. Date: Sat, 28 Jan 2017 12:37:17 -0700
    4. 

  4. Subject: [PATCH 08/13] Drivers: hv: vmbus: Use all supported IC versions to
    5. 

  5.  negotiate
    6. 

  6. 

  7. Previously, we were assuming that each IC protocol version was tied to a
    8. 

  8. specific host version. For example, some Windows 10 preview hosts only
    9. 

  9. support v3 TimeSync even though driver assumes v4 is supported by all
    10. 

  10. Windows 10 hosts.
    11. 

  11. 

  12. The guest will stop trying to negotiate even though older supported
    13. 

  13. versions may still be offered by the host.
    14. 

  14. 

  15. Make IC version negotiation more robust by going through all versions
    16. 

  16. that are supported by the guest.
    17. 

  17. 

  18. Fixes: 3da0401b4d0e ("Drivers: hv: utils: Fix the mapping between host
    19. 

  19. version and protocol to use")
    20. 

    21. 

  21. Reported-by: Rolf Neugebauer <rolf.neugebauer@docker.com>
    22. 

  22. Signed-off-by: Alex Ng <alexng@messages.microsoft.com>
    23. 

  23. Signed-off-by: K. Y. Srinivasan <kys@microsoft.com>
    24. 

  24. Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
    25. 

  25. Origin: git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
    26. 

  26. (cherry picked from commit a1656454131880980bc3a5313c8bf66ef5990c91)
    27. 

  27. ---
    28. 

  28.  drivers/hv/channel_mgmt.c | 80 +++++++++++++++++++++++++++-------------
    29. 

  29.  drivers/hv/hv_fcopy.c     | 20 +++++++---
    30. 

  30.  drivers/hv/hv_kvp.c       | 41 +++++++++------------
    31. 

  31.  drivers/hv/hv_snapshot.c  | 18 +++++++--
    32. 

  32.  drivers/hv/hv_util.c      | 94 +++++++++++++++++++++++++----------------------
    33. 

  33.  include/linux/hyperv.h    |  7 ++--
    34. 

  34.  6 files changed, 154 insertions(+), 106 deletions(-)
    35. 

  35. 

  36. diff --git a/drivers/hv/channel_mgmt.c b/drivers/hv/channel_mgmt.c
    37. 

  37. index 8df02f3ca0b2..e7949b64bfbc 100644
    38. 

  38. --- a/drivers/hv/channel_mgmt.c
    39. 

  39. +++ b/drivers/hv/channel_mgmt.c
    40. 

  40. @@ -202,33 +202,34 @@ static u16 hv_get_dev_type(const struct vmbus_channel *channel)
    41. 

  41.   * @buf: Raw buffer channel data
    42. 

  42.   *
    43. 

  43.   * @icmsghdrp is of type &struct icmsg_hdr.
    44. 

  44. - * @negop is of type &struct icmsg_negotiate.
    45. 

  45.   * Set up and fill in default negotiate response message.
    46. 

  46.   *
    47. 

  47. - * The fw_version specifies the  framework version that
    48. 

  48. - * we can support and srv_version specifies the service
    49. 

  49. - * version we can support.
    50. 

  50. + * The fw_version and fw_vercnt specifies the framework version that
    51. 

  51. + * we can support.
    52. 

  52. + *
    53. 

  53. + * The srv_version and srv_vercnt specifies the service
    54. 

  54. + * versions we can support.
    55. 

  55. + *
    56. 

  56. + * Versions are given in decreasing order.
    57. 

  57. + *
    58. 

  58. + * nego_fw_version and nego_srv_version store the selected protocol versions.
    59. 

  59.   *
    60. 

  60.   * Mainly used by Hyper-V drivers.
    61. 

  61.   */
    62. 

  62.  bool vmbus_prep_negotiate_resp(struct icmsg_hdr *icmsghdrp,
    63. 

  63. -				struct icmsg_negotiate *negop, u8 *buf,
    64. 

  64. -				int fw_version, int srv_version)
    65. 

  65. +				u8 *buf, const int *fw_version, int fw_vercnt,
    66. 

  66. +				const int *srv_version, int srv_vercnt,
    67. 

  67. +				int *nego_fw_version, int *nego_srv_version)
    68. 

  68.  {
    69. 

  69.  	int icframe_major, icframe_minor;
    70. 

  70.  	int icmsg_major, icmsg_minor;
    71. 

  71.  	int fw_major, fw_minor;
    72. 

  72.  	int srv_major, srv_minor;
    73. 

  73. -	int i;
    74. 

  74. +	int i, j;
    75. 

  75.  	bool found_match = false;
    76. 

  76. +	struct icmsg_negotiate *negop;
    77. 

  77.  
    78. 

  78.  	icmsghdrp->icmsgsize = 0x10;
    79. 

  79. -	fw_major = (fw_version >> 16);
    80. 

  80. -	fw_minor = (fw_version & 0xFFFF);
    81. 

  81. -
    82. 

  82. -	srv_major = (srv_version >> 16);
    83. 

  83. -	srv_minor = (srv_version & 0xFFFF);
    84. 

  84. -
    85. 

  85.  	negop = (struct icmsg_negotiate *)&buf[
    86. 

  86.  		sizeof(struct vmbuspipe_hdr) +
    87. 

  87.  		sizeof(struct icmsg_hdr)];
    88. 

  88. @@ -244,13 +245,22 @@ bool vmbus_prep_negotiate_resp(struct icmsg_hdr *icmsghdrp,
    89. 

  89.  	 * support.
    90. 

  90.  	 */
    91. 

  91.  
    92. 

  92. -	for (i = 0; i < negop->icframe_vercnt; i++) {
    93. 

  93. -		if ((negop->icversion_data[i].major == fw_major) &&
    94. 

  94. -		   (negop->icversion_data[i].minor == fw_minor)) {
    95. 

  95. -			icframe_major = negop->icversion_data[i].major;
    96. 

  96. -			icframe_minor = negop->icversion_data[i].minor;
    97. 

  97. -			found_match = true;
    98. 

  98. +	for (i = 0; i < fw_vercnt; i++) {
    99. 

  99. +		fw_major = (fw_version[i] >> 16);
    100. 

  100. +		fw_minor = (fw_version[i] & 0xFFFF);
    101. 

  101. +
    102. 

  102. +		for (j = 0; j < negop->icframe_vercnt; j++) {
    103. 

  103. +			if ((negop->icversion_data[j].major == fw_major) &&
    104. 

  104. +			    (negop->icversion_data[j].minor == fw_minor)) {
    105. 

  105. +				icframe_major = negop->icversion_data[j].major;
    106. 

  106. +				icframe_minor = negop->icversion_data[j].minor;
    107. 

  107. +				found_match = true;
    108. 

  108. +				break;
    109. 

  109. +			}
    110. 

  110.  		}
    111. 

  111. +
    112. 

  112. +		if (found_match)
    113. 

  113. +			break;
    114. 

  114.  	}
    115. 

  115.  
    116. 

  116.  	if (!found_match)
    117. 

  117. @@ -258,14 +268,26 @@ bool vmbus_prep_negotiate_resp(struct icmsg_hdr *icmsghdrp,
    118. 

  118.  
    119. 

  119.  	found_match = false;
    120. 

  120.  
    121. 

  121. -	for (i = negop->icframe_vercnt;
    122. 

  122. -		 (i < negop->icframe_vercnt + negop->icmsg_vercnt); i++) {
    123. 

  123. -		if ((negop->icversion_data[i].major == srv_major) &&
    124. 

  124. -		   (negop->icversion_data[i].minor == srv_minor)) {
    125. 

  125. -			icmsg_major = negop->icversion_data[i].major;
    126. 

  126. -			icmsg_minor = negop->icversion_data[i].minor;
    127. 

  127. -			found_match = true;
    128. 

  128. +	for (i = 0; i < srv_vercnt; i++) {
    129. 

  129. +		srv_major = (srv_version[i] >> 16);
    130. 

  130. +		srv_minor = (srv_version[i] & 0xFFFF);
    131. 

  131. +
    132. 

  132. +		for (j = negop->icframe_vercnt;
    133. 

  133. +			(j < negop->icframe_vercnt + negop->icmsg_vercnt);
    134. 

  134. +			j++) {
    135. 

  135. +
    136. 

  136. +			if ((negop->icversion_data[j].major == srv_major) &&
    137. 

  137. +				(negop->icversion_data[j].minor == srv_minor)) {
    138. 

  138. +
    139. 

  139. +				icmsg_major = negop->icversion_data[j].major;
    140. 

  140. +				icmsg_minor = negop->icversion_data[j].minor;
    141. 

  141. +				found_match = true;
    142. 

  142. +				break;
    143. 

  143. +			}
    144. 

  144.  		}
    145. 

  145. +
    146. 

  146. +		if (found_match)
    147. 

  147. +			break;
    148. 

  148.  	}
    149. 

  149.  
    150. 

  150.  	/*
    151. 

  151. @@ -282,6 +304,12 @@ bool vmbus_prep_negotiate_resp(struct icmsg_hdr *icmsghdrp,
    152. 

  152.  		negop->icmsg_vercnt = 1;
    153. 

  153.  	}
    154. 

  154.  
    155. 

  155. +	if (nego_fw_version)
    156. 

  156. +		*nego_fw_version = (icframe_major << 16) | icframe_minor;
    157. 

  157. +
    158. 

  158. +	if (nego_srv_version)
    159. 

  159. +		*nego_srv_version = (icmsg_major << 16) | icmsg_minor;
    160. 

  160. +
    161. 

  161.  	negop->icversion_data[0].major = icframe_major;
    162. 

  162.  	negop->icversion_data[0].minor = icframe_minor;
    163. 

  163.  	negop->icversion_data[1].major = icmsg_major;
    164. 

  164. diff --git a/drivers/hv/hv_fcopy.c b/drivers/hv/hv_fcopy.c
    165. 

  165. index e47d8c9db03a..0a315e6aa589 100644
    166. 

  166. --- a/drivers/hv/hv_fcopy.c
    167. 

  167. +++ b/drivers/hv/hv_fcopy.c
    168. 

  168. @@ -31,6 +31,16 @@
    169. 

  169.  #define WIN8_SRV_MINOR		1
    170. 

  170.  #define WIN8_SRV_VERSION	(WIN8_SRV_MAJOR << 16 | WIN8_SRV_MINOR)
    171. 

  171.  
    172. 

  172. +#define FCOPY_VER_COUNT 1
    173. 

  173. +static const int fcopy_versions[] = {
    174. 

  174. +	WIN8_SRV_VERSION
    175. 

  175. +};
    176. 

  176. +
    177. 

  177. +#define FW_VER_COUNT 1
    178. 

  178. +static const int fw_versions[] = {
    179. 

  179. +	UTIL_FW_VERSION
    180. 

  180. +};
    181. 

  181. +
    182. 

  182.  /*
    183. 

  183.   * Global state maintained for transaction that is being processed.
    184. 

  184.   * For a class of integration services, including the "file copy service",
    185. 

  185. @@ -228,8 +238,6 @@ void hv_fcopy_onchannelcallback(void *context)
    186. 

  186.  	u64 requestid;
    187. 

  187.  	struct hv_fcopy_hdr *fcopy_msg;
    188. 

  188.  	struct icmsg_hdr *icmsghdr;
    189. 

  189. -	struct icmsg_negotiate *negop = NULL;
    190. 

  190. -	int util_fw_version;
    191. 

  191.  	int fcopy_srv_version;
    192. 

  192.  
    193. 

  193.  	if (fcopy_transaction.state > HVUTIL_READY)
    194. 

  194. @@ -243,10 +251,10 @@ void hv_fcopy_onchannelcallback(void *context)
    195. 

  195.  	icmsghdr = (struct icmsg_hdr *)&recv_buffer[
    196. 

  196.  			sizeof(struct vmbuspipe_hdr)];
    197. 

  197.  	if (icmsghdr->icmsgtype == ICMSGTYPE_NEGOTIATE) {
    198. 

  198. -		util_fw_version = UTIL_FW_VERSION;
    199. 

  199. -		fcopy_srv_version = WIN8_SRV_VERSION;
    200. 

  200. -		vmbus_prep_negotiate_resp(icmsghdr, negop, recv_buffer,
    201. 

  201. -				util_fw_version, fcopy_srv_version);
    202. 

  202. +		vmbus_prep_negotiate_resp(icmsghdr, recv_buffer,
    203. 

  203. +				fw_versions, FW_VER_COUNT,
    204. 

  204. +				fcopy_versions, FCOPY_VER_COUNT,
    205. 

  205. +				NULL, &fcopy_srv_version);
    206. 

  206.  	} else {
    207. 

  207.  		fcopy_msg = (struct hv_fcopy_hdr *)&recv_buffer[
    208. 

  208.  				sizeof(struct vmbuspipe_hdr) +
    209. 

  209. diff --git a/drivers/hv/hv_kvp.c b/drivers/hv/hv_kvp.c
    210. 

  210. index 3abfc5983c97..2cc670442f6c 100644
    211. 

  211. --- a/drivers/hv/hv_kvp.c
    212. 

  212. +++ b/drivers/hv/hv_kvp.c
    213. 

  213. @@ -46,6 +46,19 @@
    214. 

  214.  #define WIN8_SRV_MINOR   0
    215. 

  215.  #define WIN8_SRV_VERSION     (WIN8_SRV_MAJOR << 16 | WIN8_SRV_MINOR)
    216. 

  216.  
    217. 

  217. +#define KVP_VER_COUNT 3
    218. 

  218. +static const int kvp_versions[] = {
    219. 

  219. +	WIN8_SRV_VERSION,
    220. 

  220. +	WIN7_SRV_VERSION,
    221. 

  221. +	WS2008_SRV_VERSION
    222. 

  222. +};
    223. 

  223. +
    224. 

  224. +#define FW_VER_COUNT 2
    225. 

  225. +static const int fw_versions[] = {
    226. 

  226. +	UTIL_FW_VERSION,
    227. 

  227. +	UTIL_WS2K8_FW_VERSION
    228. 

  228. +};
    229. 

  229. +
    230. 

  230.  /*
    231. 

  231.   * Global state maintained for transaction that is being processed. For a class
    232. 

  232.   * of integration services, including the "KVP service", the specified protocol
    233. 

  233. @@ -610,8 +623,6 @@ void hv_kvp_onchannelcallback(void *context)
    234. 

  234.  	struct hv_kvp_msg *kvp_msg;
    235. 

  235.  
    236. 

  236.  	struct icmsg_hdr *icmsghdrp;
    237. 

  237. -	struct icmsg_negotiate *negop = NULL;
    238. 

  238. -	int util_fw_version;
    239. 

  239.  	int kvp_srv_version;
    240. 

  240.  	static enum {NEGO_NOT_STARTED,
    241. 

  241.  		     NEGO_IN_PROGRESS,
    242. 

  242. @@ -640,28 +651,10 @@ void hv_kvp_onchannelcallback(void *context)
    243. 

  243.  			sizeof(struct vmbuspipe_hdr)];
    244. 

  244.  
    245. 

  245.  		if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {
    246. 

  246. -			/*
    247. 

  247. -			 * Based on the host, select appropriate
    248. 

  248. -			 * framework and service versions we will
    249. 

  249. -			 * negotiate.
    250. 

  250. -			 */
    251. 

  251. -			switch (vmbus_proto_version) {
    252. 

  252. -			case (VERSION_WS2008):
    253. 

  253. -				util_fw_version = UTIL_WS2K8_FW_VERSION;
    254. 

  254. -				kvp_srv_version = WS2008_SRV_VERSION;
    255. 

  255. -				break;
    256. 

  256. -			case (VERSION_WIN7):
    257. 

  257. -				util_fw_version = UTIL_FW_VERSION;
    258. 

  258. -				kvp_srv_version = WIN7_SRV_VERSION;
    259. 

  259. -				break;
    260. 

  260. -			default:
    261. 

  261. -				util_fw_version = UTIL_FW_VERSION;
    262. 

  262. -				kvp_srv_version = WIN8_SRV_VERSION;
    263. 

  263. -			}
    264. 

  264. -			vmbus_prep_negotiate_resp(icmsghdrp, negop,
    265. 

  265. -				 recv_buffer, util_fw_version,
    266. 

  266. -				 kvp_srv_version);
    267. 

  267. -
    268. 

  268. +			vmbus_prep_negotiate_resp(icmsghdrp,
    269. 

  269. +				 recv_buffer, fw_versions, FW_VER_COUNT,
    270. 

  270. +				 kvp_versions, KVP_VER_COUNT,
    271. 

  271. +				 NULL, &kvp_srv_version);
    272. 

  272.  		} else {
    273. 

  273.  			kvp_msg = (struct hv_kvp_msg *)&recv_buffer[
    274. 

  274.  				sizeof(struct vmbuspipe_hdr) +
    275. 

  275. diff --git a/drivers/hv/hv_snapshot.c b/drivers/hv/hv_snapshot.c
    276. 

  276. index 4e543dbb731a..d14f10b924a0 100644
    277. 

  277. --- a/drivers/hv/hv_snapshot.c
    278. 

  278. +++ b/drivers/hv/hv_snapshot.c
    279. 

  279. @@ -31,6 +31,16 @@
    280. 

  280.  #define VSS_MINOR  0
    281. 

  281.  #define VSS_VERSION    (VSS_MAJOR << 16 | VSS_MINOR)
    282. 

  282.  
    283. 

  283. +#define VSS_VER_COUNT 1
    284. 

  284. +static const int vss_versions[] = {
    285. 

  285. +	VSS_VERSION
    286. 

  286. +};
    287. 

  287. +
    288. 

  288. +#define FW_VER_COUNT 1
    289. 

  289. +static const int fw_versions[] = {
    290. 

  290. +	UTIL_FW_VERSION
    291. 

  291. +};
    292. 

  292. +
    293. 

  293.  /*
    294. 

  294.   * Timeout values are based on expecations from host
    295. 

  295.   */
    296. 

  296. @@ -297,7 +307,6 @@ void hv_vss_onchannelcallback(void *context)
    297. 

  297.  
    298. 

  298.  
    299. 

  299.  	struct icmsg_hdr *icmsghdrp;
    300. 

  300. -	struct icmsg_negotiate *negop = NULL;
    301. 

  301.  
    302. 

  302.  	if (vss_transaction.state > HVUTIL_READY)
    303. 

  303.  		return;
    304. 

  304. @@ -310,9 +319,10 @@ void hv_vss_onchannelcallback(void *context)
    305. 

  305.  			sizeof(struct vmbuspipe_hdr)];
    306. 

  306.  
    307. 

  307.  		if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {
    308. 

  308. -			vmbus_prep_negotiate_resp(icmsghdrp, negop,
    309. 

  309. -				 recv_buffer, UTIL_FW_VERSION,
    310. 

  310. -				 VSS_VERSION);
    311. 

  311. +			vmbus_prep_negotiate_resp(icmsghdrp,
    312. 

  312. +				 recv_buffer, fw_versions, FW_VER_COUNT,
    313. 

  313. +				 vss_versions, VSS_VER_COUNT,
    314. 

  314. +				 NULL, NULL);
    315. 

  315.  		} else {
    316. 

  316.  			vss_msg = (struct hv_vss_msg *)&recv_buffer[
    317. 

  317.  				sizeof(struct vmbuspipe_hdr) +
    318. 

  318. diff --git a/drivers/hv/hv_util.c b/drivers/hv/hv_util.c
    319. 

  319. index e7707747f56d..f3797c07be10 100644
    320. 

  320. --- a/drivers/hv/hv_util.c
    321. 

  321. +++ b/drivers/hv/hv_util.c
    322. 

  322. @@ -57,7 +57,31 @@
    323. 

  323.  static int sd_srv_version;
    324. 

  324.  static int ts_srv_version;
    325. 

  325.  static int hb_srv_version;
    326. 

  326. -static int util_fw_version;
    327. 

  327. +
    328. 

  328. +#define SD_VER_COUNT 2
    329. 

  329. +static const int sd_versions[] = {
    330. 

  330. +	SD_VERSION,
    331. 

  331. +	SD_VERSION_1
    332. 

  332. +};
    333. 

  333. +
    334. 

  334. +#define TS_VER_COUNT 3
    335. 

  335. +static const int ts_versions[] = {
    336. 

  336. +	TS_VERSION,
    337. 

  337. +	TS_VERSION_3,
    338. 

  338. +	TS_VERSION_1
    339. 

  339. +};
    340. 

  340. +
    341. 

  341. +#define HB_VER_COUNT 2
    342. 

  342. +static const int hb_versions[] = {
    343. 

  343. +	HB_VERSION,
    344. 

  344. +	HB_VERSION_1
    345. 

  345. +};
    346. 

  346. +
    347. 

  347. +#define FW_VER_COUNT 2
    348. 

  348. +static const int fw_versions[] = {
    349. 

  349. +	UTIL_FW_VERSION,
    350. 

  350. +	UTIL_WS2K8_FW_VERSION
    351. 

  351. +};
    352. 

  352.  
    353. 

  353.  static void shutdown_onchannelcallback(void *context);
    354. 

  354.  static struct hv_util_service util_shutdown = {
    355. 

  355. @@ -118,7 +142,6 @@ static void shutdown_onchannelcallback(void *context)
    356. 

  356.  	struct shutdown_msg_data *shutdown_msg;
    357. 

  357.  
    358. 

  358.  	struct icmsg_hdr *icmsghdrp;
    359. 

  359. -	struct icmsg_negotiate *negop = NULL;
    360. 

  360.  
    361. 

  361.  	vmbus_recvpacket(channel, shut_txf_buf,
    362. 

  362.  			 PAGE_SIZE, &recvlen, &requestid);
    363. 

  363. @@ -128,9 +151,14 @@ static void shutdown_onchannelcallback(void *context)
    364. 

  364.  			sizeof(struct vmbuspipe_hdr)];
    365. 

  365.  
    366. 

  366.  		if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {
    367. 

  367. -			vmbus_prep_negotiate_resp(icmsghdrp, negop,
    368. 

  368. -					shut_txf_buf, util_fw_version,
    369. 

  369. -					sd_srv_version);
    370. 

  370. +			if (vmbus_prep_negotiate_resp(icmsghdrp, shut_txf_buf,
    371. 

  371. +					fw_versions, FW_VER_COUNT,
    372. 

  372. +					sd_versions, SD_VER_COUNT,
    373. 

  373. +					NULL, &sd_srv_version)) {
    374. 

  374. +				pr_info("Shutdown IC version %d.%d\n",
    375. 

  375. +					sd_srv_version >> 16,
    376. 

  376. +					sd_srv_version & 0xFFFF);
    377. 

  377. +			}
    378. 

  378.  		} else {
    379. 

  379.  			shutdown_msg =
    380. 

  380.  				(struct shutdown_msg_data *)&shut_txf_buf[
    381. 

  381. @@ -253,7 +281,6 @@ static void timesync_onchannelcallback(void *context)
    382. 

  382.  	struct ictimesync_data *timedatap;
    383. 

  383.  	struct ictimesync_ref_data *refdata;
    384. 

  384.  	u8 *time_txf_buf = util_timesynch.recv_buffer;
    385. 

  385. -	struct icmsg_negotiate *negop = NULL;
    386. 

  386.  
    387. 

  387.  	vmbus_recvpacket(channel, time_txf_buf,
    388. 

  388.  			 PAGE_SIZE, &recvlen, &requestid);
    389. 

  389. @@ -263,12 +290,14 @@ static void timesync_onchannelcallback(void *context)
    390. 

  390.  				sizeof(struct vmbuspipe_hdr)];
    391. 

  391.  
    392. 

  392.  		if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {
    393. 

  393. -			vmbus_prep_negotiate_resp(icmsghdrp, negop,
    394. 

  394. -						time_txf_buf,
    395. 

  395. -						util_fw_version,
    396. 

  396. -						ts_srv_version);
    397. 

  397. -			pr_info("Using TimeSync version %d.%d\n",
    398. 

  398. -				ts_srv_version >> 16, ts_srv_version & 0xFFFF);
    399. 

  399. +			if (vmbus_prep_negotiate_resp(icmsghdrp, time_txf_buf,
    400. 

  400. +						fw_versions, FW_VER_COUNT,
    401. 

  401. +						ts_versions, TS_VER_COUNT,
    402. 

  402. +						NULL, &ts_srv_version)) {
    403. 

  403. +				pr_info("TimeSync version %d.%d\n",
    404. 

  404. +					ts_srv_version >> 16,
    405. 

  405. +					ts_srv_version & 0xFFFF);
    406. 

  406. +			}
    407. 

  407.  		} else {
    408. 

  408.  			if (ts_srv_version > TS_VERSION_3) {
    409. 

  409.  				refdata = (struct ictimesync_ref_data *)
    410. 

  410. @@ -312,7 +341,6 @@ static void heartbeat_onchannelcallback(void *context)
    411. 

  411.  	struct icmsg_hdr *icmsghdrp;
    412. 

  412.  	struct heartbeat_msg_data *heartbeat_msg;
    413. 

  413.  	u8 *hbeat_txf_buf = util_heartbeat.recv_buffer;
    414. 

  414. -	struct icmsg_negotiate *negop = NULL;
    415. 

  415.  
    416. 

  416.  	while (1) {
    417. 

  417.  
    418. 

  418. @@ -326,9 +354,16 @@ static void heartbeat_onchannelcallback(void *context)
    419. 

  419.  				sizeof(struct vmbuspipe_hdr)];
    420. 

  420.  
    421. 

  421.  		if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {
    422. 

  422. -			vmbus_prep_negotiate_resp(icmsghdrp, negop,
    423. 

  423. -				hbeat_txf_buf, util_fw_version,
    424. 

  424. -				hb_srv_version);
    425. 

  425. +			if (vmbus_prep_negotiate_resp(icmsghdrp,
    426. 

  426. +					hbeat_txf_buf,
    427. 

  427. +					fw_versions, FW_VER_COUNT,
    428. 

  428. +					hb_versions, HB_VER_COUNT,
    429. 

  429. +					NULL, &hb_srv_version)) {
    430. 

  430. +
    431. 

  431. +				pr_info("Heartbeat version %d.%d\n",
    432. 

  432. +					hb_srv_version >> 16,
    433. 

  433. +					hb_srv_version & 0xFFFF);
    434. 

  434. +			}
    435. 

  435.  		} else {
    436. 

  436.  			heartbeat_msg =
    437. 

  437.  				(struct heartbeat_msg_data *)&hbeat_txf_buf[
    438. 

  438. @@ -378,33 +413,6 @@ static int util_probe(struct hv_device *dev,
    439. 

  439.  
    440. 

  440.  	hv_set_drvdata(dev, srv);
    441. 

  441.  
    442. 

  442. -	/*
    443. 

  443. -	 * Based on the host; initialize the framework and
    444. 

  444. -	 * service version numbers we will negotiate.
    445. 

  445. -	 */
    446. 

  446. -	switch (vmbus_proto_version) {
    447. 

  447. -	case (VERSION_WS2008):
    448. 

  448. -		util_fw_version = UTIL_WS2K8_FW_VERSION;
    449. 

  449. -		sd_srv_version = SD_VERSION_1;
    450. 

  450. -		ts_srv_version = TS_VERSION_1;
    451. 

  451. -		hb_srv_version = HB_VERSION_1;
    452. 

  452. -		break;
    453. 

  453. -	case VERSION_WIN7:
    454. 

  454. -	case VERSION_WIN8:
    455. 

  455. -	case VERSION_WIN8_1:
    456. 

  456. -		util_fw_version = UTIL_FW_VERSION;
    457. 

  457. -		sd_srv_version = SD_VERSION;
    458. 

  458. -		ts_srv_version = TS_VERSION_3;
    459. 

  459. -		hb_srv_version = HB_VERSION;
    460. 

  460. -		break;
    461. 

  461. -	case VERSION_WIN10:
    462. 

  462. -	default:
    463. 

  463. -		util_fw_version = UTIL_FW_VERSION;
    464. 

  464. -		sd_srv_version = SD_VERSION;
    465. 

  465. -		ts_srv_version = TS_VERSION;
    466. 

  466. -		hb_srv_version = HB_VERSION;
    467. 

  467. -	}
    468. 

  468. -
    469. 

  469.  	ret = vmbus_open(dev->channel, 4 * PAGE_SIZE, 4 * PAGE_SIZE, NULL, 0,
    470. 

  470.  			srv->util_cb, dev->channel);
    471. 

  471.  	if (ret)
    472. 

  472. diff --git a/include/linux/hyperv.h b/include/linux/hyperv.h
    473. 

  473. index 489ad74c1e6e..956acfc93487 100644
    474. 

  474. --- a/include/linux/hyperv.h
    475. 

  475. +++ b/include/linux/hyperv.h
    476. 

  476. @@ -1453,9 +1453,10 @@ struct hyperv_service_callback {
    477. 

  477.  };
    478. 

  478.  
    479. 

  479.  #define MAX_SRV_VER	0x7ffffff
    480. 

  480. -extern bool vmbus_prep_negotiate_resp(struct icmsg_hdr *,
    481. 

  481. -					struct icmsg_negotiate *, u8 *, int,
    482. 

  482. -					int);
    483. 

  483. +extern bool vmbus_prep_negotiate_resp(struct icmsg_hdr *icmsghdrp, u8 *buf,
    484. 

  484. +				const int *fw_version, int fw_vercnt,
    485. 

  485. +				const int *srv_version, int srv_vercnt,
    486. 

  486. +				int *nego_fw_version, int *nego_srv_version);
    487. 

  487.  
    488. 

  488.  void hv_event_tasklet_disable(struct vmbus_channel *channel);
    489. 

  489.  void hv_event_tasklet_enable(struct vmbus_channel *channel);
    490. 

  490. -- 
    491. 

  491. 2.13.0
    492. 

  492. 

  493.