channel_mgmt.c 29.0 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/*
 * Copyright (c) 2009, Microsoft Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 * Place - Suite 330, Boston, MA 02111-1307 USA.
 *
 * Authors:
 *   Haiyang Zhang <haiyangz@microsoft.com>
 *   Hank Janssen  <hjanssen@microsoft.com>
 */
21 22
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

23
#include <linux/kernel.h>
24 25
#include <linux/sched.h>
#include <linux/wait.h>
26
#include <linux/mm.h>
27
#include <linux/slab.h>
28
#include <linux/list.h>
29
#include <linux/module.h>
30
#include <linux/completion.h>
31
#include <linux/delay.h>
32
#include <linux/hyperv.h>
33

34
#include "hyperv_vmbus.h"
35

36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
static void init_vp_index(struct vmbus_channel *channel, u16 dev_type);

static const struct vmbus_device vmbus_devs[] = {
	/* IDE */
	{ .dev_type = HV_IDE,
	  HV_IDE_GUID,
	  .perf_device = true,
	},

	/* SCSI */
	{ .dev_type = HV_SCSI,
	  HV_SCSI_GUID,
	  .perf_device = true,
	},

	/* Fibre Channel */
	{ .dev_type = HV_FC,
	  HV_SYNTHFC_GUID,
	  .perf_device = true,
	},

	/* Synthetic NIC */
	{ .dev_type = HV_NIC,
	  HV_NIC_GUID,
	  .perf_device = true,
	},

	/* Network Direct */
	{ .dev_type = HV_ND,
	  HV_ND_GUID,
	  .perf_device = true,
	},

	/* PCIE */
	{ .dev_type = HV_PCIE,
	  HV_PCIE_GUID,
	  .perf_device = true,
	},

	/* Synthetic Frame Buffer */
	{ .dev_type = HV_FB,
	  HV_SYNTHVID_GUID,
	  .perf_device = false,
	},

	/* Synthetic Keyboard */
	{ .dev_type = HV_KBD,
	  HV_KBD_GUID,
	  .perf_device = false,
	},

	/* Synthetic MOUSE */
	{ .dev_type = HV_MOUSE,
	  HV_MOUSE_GUID,
	  .perf_device = false,
	},

	/* KVP */
	{ .dev_type = HV_KVP,
	  HV_KVP_GUID,
	  .perf_device = false,
	},

	/* Time Synch */
	{ .dev_type = HV_TS,
	  HV_TS_GUID,
	  .perf_device = false,
	},

	/* Heartbeat */
	{ .dev_type = HV_HB,
	  HV_HEART_BEAT_GUID,
	  .perf_device = false,
	},

	/* Shutdown */
	{ .dev_type = HV_SHUTDOWN,
	  HV_SHUTDOWN_GUID,
	  .perf_device = false,
	},

	/* File copy */
	{ .dev_type = HV_FCOPY,
	  HV_FCOPY_GUID,
	  .perf_device = false,
	},

	/* Backup */
	{ .dev_type = HV_BACKUP,
	  HV_VSS_GUID,
	  .perf_device = false,
	},

	/* Dynamic Memory */
	{ .dev_type = HV_DM,
	  HV_DM_GUID,
	  .perf_device = false,
	},

	/* Unknown GUID */
	{ .dev_type = HV_UNKOWN,
	  .perf_device = false,
	},
};

static u16 hv_get_dev_type(const uuid_le *guid)
{
	u16 i;

	for (i = HV_IDE; i < HV_UNKOWN; i++) {
		if (!uuid_le_cmp(*guid, vmbus_devs[i].guid))
			return i;
	}
	pr_info("Unknown GUID: %pUl\n", guid);
	return i;
}
152

153
/**
154
 * vmbus_prep_negotiate_resp() - Create default response for Hyper-V Negotiate message
155 156 157 158 159 160
 * @icmsghdrp: Pointer to msg header structure
 * @icmsg_negotiate: Pointer to negotiate message structure
 * @buf: Raw buffer channel data
 *
 * @icmsghdrp is of type &struct icmsg_hdr.
 * @negop is of type &struct icmsg_negotiate.
161 162
 * Set up and fill in default negotiate response message.
 *
163 164 165
 * The fw_version specifies the  framework version that
 * we can support and srv_version specifies the service
 * version we can support.
166 167 168
 *
 * Mainly used by Hyper-V drivers.
 */
169
bool vmbus_prep_negotiate_resp(struct icmsg_hdr *icmsghdrp,
170
				struct icmsg_negotiate *negop, u8 *buf,
171
				int fw_version, int srv_version)
172
{
173 174 175 176
	int icframe_major, icframe_minor;
	int icmsg_major, icmsg_minor;
	int fw_major, fw_minor;
	int srv_major, srv_minor;
177
	int i;
178
	bool found_match = false;
179

180
	icmsghdrp->icmsgsize = 0x10;
181 182 183 184 185
	fw_major = (fw_version >> 16);
	fw_minor = (fw_version & 0xFFFF);

	srv_major = (srv_version >> 16);
	srv_minor = (srv_version & 0xFFFF);
186

187 188 189
	negop = (struct icmsg_negotiate *)&buf[
		sizeof(struct vmbuspipe_hdr) +
		sizeof(struct icmsg_hdr)];
190

191 192 193 194 195
	icframe_major = negop->icframe_vercnt;
	icframe_minor = 0;

	icmsg_major = negop->icmsg_vercnt;
	icmsg_minor = 0;
196 197 198 199 200 201 202

	/*
	 * Select the framework version number we will
	 * support.
	 */

	for (i = 0; i < negop->icframe_vercnt; i++) {
203 204 205 206 207 208
		if ((negop->icversion_data[i].major == fw_major) &&
		   (negop->icversion_data[i].minor == fw_minor)) {
			icframe_major = negop->icversion_data[i].major;
			icframe_minor = negop->icversion_data[i].minor;
			found_match = true;
		}
209 210
	}

211 212 213 214 215
	if (!found_match)
		goto fw_error;

	found_match = false;

216 217
	for (i = negop->icframe_vercnt;
		 (i < negop->icframe_vercnt + negop->icmsg_vercnt); i++) {
218 219 220 221 222 223
		if ((negop->icversion_data[i].major == srv_major) &&
		   (negop->icversion_data[i].minor == srv_minor)) {
			icmsg_major = negop->icversion_data[i].major;
			icmsg_minor = negop->icversion_data[i].minor;
			found_match = true;
		}
224
	}
225

226
	/*
227
	 * Respond with the framework and service
228 229
	 * version numbers we can support.
	 */
230 231 232 233 234 235 236 237 238 239 240 241 242 243 244

fw_error:
	if (!found_match) {
		negop->icframe_vercnt = 0;
		negop->icmsg_vercnt = 0;
	} else {
		negop->icframe_vercnt = 1;
		negop->icmsg_vercnt = 1;
	}

	negop->icversion_data[0].major = icframe_major;
	negop->icversion_data[0].minor = icframe_minor;
	negop->icversion_data[1].major = icmsg_major;
	negop->icversion_data[1].minor = icmsg_minor;
	return found_match;
245
}
246

247
EXPORT_SYMBOL_GPL(vmbus_prep_negotiate_resp);
248

249
/*
250
 * alloc_channel - Allocate and initialize a vmbus channel object
251
 */
252
static struct vmbus_channel *alloc_channel(void)
253
{
254
	static atomic_t chan_num = ATOMIC_INIT(0);
255
	struct vmbus_channel *channel;
256

257
	channel = kzalloc(sizeof(*channel), GFP_ATOMIC);
258 259 260
	if (!channel)
		return NULL;

261
	channel->id = atomic_inc_return(&chan_num);
262
	spin_lock_init(&channel->inbound_lock);
263
	spin_lock_init(&channel->lock);
264 265

	INIT_LIST_HEAD(&channel->sc_list);
266
	INIT_LIST_HEAD(&channel->percpu_list);
267 268 269 270

	return channel;
}

271
/*
272
 * free_channel - Release the resources used by the vmbus channel object
273
 */
274
static void free_channel(struct vmbus_channel *channel)
275
{
276
	kfree(channel);
277 278
}

279 280 281 282 283 284 285
static void percpu_channel_enq(void *arg)
{
	struct vmbus_channel *channel = arg;
	int cpu = smp_processor_id();

	list_add_tail(&channel->percpu_list, &hv_context.percpu_list[cpu]);
}
286

287 288 289 290 291 292
static void percpu_channel_deq(void *arg)
{
	struct vmbus_channel *channel = arg;

	list_del(&channel->percpu_list);
}
293

294

295
static void vmbus_release_relid(u32 relid)
296
{
297
	struct vmbus_channel_relid_released msg;
298

299
	memset(&msg, 0, sizeof(struct vmbus_channel_relid_released));
300
	msg.child_relid = relid;
301 302
	msg.header.msgtype = CHANNELMSG_RELID_RELEASED;
	vmbus_post_msg(&msg, sizeof(struct vmbus_channel_relid_released));
303
}
304

305 306 307 308 309 310
void hv_process_channel_removal(struct vmbus_channel *channel, u32 relid)
{
	unsigned long flags;
	struct vmbus_channel *primary_channel;

	vmbus_release_relid(relid);
311

312
	BUG_ON(!channel->rescind);
313
	BUG_ON(!mutex_is_locked(&vmbus_connection.channel_mutex));
314

315 316
	if (channel->target_cpu != get_cpu()) {
		put_cpu();
317 318
		smp_call_function_single(channel->target_cpu,
					 percpu_channel_deq, channel, true);
319
	} else {
320
		percpu_channel_deq(channel);
321 322
		put_cpu();
	}
323

324 325
	if (channel->primary_channel == NULL) {
		list_del(&channel->listentry);
326 327

		primary_channel = channel;
328 329
	} else {
		primary_channel = channel->primary_channel;
330
		spin_lock_irqsave(&primary_channel->lock, flags);
331
		list_del(&channel->sc_list);
332
		primary_channel->num_sc--;
333
		spin_unlock_irqrestore(&primary_channel->lock, flags);
334
	}
335 336 337 338 339 340 341 342

	/*
	 * We need to free the bit for init_vp_index() to work in the case
	 * of sub-channel, when we reload drivers like hv_netvsc.
	 */
	cpumask_clear_cpu(channel->target_cpu,
			  &primary_channel->alloced_cpus_in_node);

343
	free_channel(channel);
344
}
345

346 347
void vmbus_free_channels(void)
{
348 349 350 351
	struct vmbus_channel *channel, *tmp;

	list_for_each_entry_safe(channel, tmp, &vmbus_connection.chn_list,
		listentry) {
352
		/* hv_process_channel_removal() needs this */
353
		channel->rescind = true;
354 355 356 357 358

		vmbus_device_unregister(channel->device_obj);
	}
}

359
/*
360
 * vmbus_process_offer - Process the offer by creating a channel/device
361
 * associated with this offer
362
 */
363
static void vmbus_process_offer(struct vmbus_channel *newchannel)
364
{
365
	struct vmbus_channel *channel;
366
	bool fnew = true;
367
	unsigned long flags;
368
	u16 dev_type;
369
	int ret;
370

371
	/* Make sure this is a new offer */
372
	mutex_lock(&vmbus_connection.channel_mutex);
373

374
	list_for_each_entry(channel, &vmbus_connection.chn_list, listentry) {
375 376 377 378
		if (!uuid_le_cmp(channel->offermsg.offer.if_type,
			newchannel->offermsg.offer.if_type) &&
			!uuid_le_cmp(channel->offermsg.offer.if_instance,
				newchannel->offermsg.offer.if_instance)) {
379
			fnew = false;
380 381 382 383
			break;
		}
	}

384
	if (fnew)
385
		list_add_tail(&newchannel->listentry,
386
			      &vmbus_connection.chn_list);
387

388
	mutex_unlock(&vmbus_connection.channel_mutex);
389

390
	if (!fnew) {
391 392 393 394 395 396 397 398
		/*
		 * Check to see if this is a sub-channel.
		 */
		if (newchannel->offermsg.offer.sub_channel_index != 0) {
			/*
			 * Process the sub-channel.
			 */
			newchannel->primary_channel = channel;
399
			spin_lock_irqsave(&channel->lock, flags);
400
			list_add_tail(&newchannel->sc_list, &channel->sc_list);
401
			channel->num_sc++;
402
			spin_unlock_irqrestore(&channel->lock, flags);
403 404 405
		} else
			goto err_free_chan;
	}
406

407 408 409
	dev_type = hv_get_dev_type(&newchannel->offermsg.offer.if_type);

	init_vp_index(newchannel, dev_type);
410

411 412 413 414 415 416 417 418
	if (newchannel->target_cpu != get_cpu()) {
		put_cpu();
		smp_call_function_single(newchannel->target_cpu,
					 percpu_channel_enq,
					 newchannel, true);
	} else {
		percpu_channel_enq(newchannel);
		put_cpu();
419 420
	}

421 422 423 424 425 426 427
	/*
	 * This state is used to indicate a successful open
	 * so that when we do close the channel normally, we
	 * can cleanup properly
	 */
	newchannel->state = CHANNEL_OPEN_STATE;

428 429 430 431 432 433
	if (!fnew) {
		if (channel->sc_creation_callback != NULL)
			channel->sc_creation_callback(newchannel);
		return;
	}

434 435 436
	/*
	 * Start the process of binding this offer to the driver
	 * We need to set the DeviceObject field before calling
437
	 * vmbus_child_dev_add()
438
	 */
439
	newchannel->device_obj = vmbus_device_create(
440 441
		&newchannel->offermsg.offer.if_type,
		&newchannel->offermsg.offer.if_instance,
442
		newchannel);
443
	if (!newchannel->device_obj)
444
		goto err_deq_chan;
445

446
	newchannel->device_obj->device_id = dev_type;
447 448 449 450 451
	/*
	 * Add the new device to the bus. This will kick off device-driver
	 * binding which eventually invokes the device driver's AddDevice()
	 * method.
	 */
452 453 454 455 456
	mutex_lock(&vmbus_connection.channel_mutex);
	ret = vmbus_device_register(newchannel->device_obj);
	mutex_unlock(&vmbus_connection.channel_mutex);

	if (ret != 0) {
457 458 459 460 461
		pr_err("unable to add child device object (relid %d)\n",
			newchannel->offermsg.child_relid);
		kfree(newchannel->device_obj);
		goto err_deq_chan;
	}
462
	return;
463

464
err_deq_chan:
465 466
	vmbus_release_relid(newchannel->offermsg.child_relid);

467
	mutex_lock(&vmbus_connection.channel_mutex);
468
	list_del(&newchannel->listentry);
469
	mutex_unlock(&vmbus_connection.channel_mutex);
470 471 472 473 474 475 476 477 478 479

	if (newchannel->target_cpu != get_cpu()) {
		put_cpu();
		smp_call_function_single(newchannel->target_cpu,
					 percpu_channel_deq, newchannel, true);
	} else {
		percpu_channel_deq(newchannel);
		put_cpu();
	}

480 481
err_free_chan:
	free_channel(newchannel);
482 483
}

484 485 486
/*
 * We use this state to statically distribute the channel interrupt load.
 */
487
static int next_numa_node_id;
488 489 490

/*
 * Starting with Win8, we can statically distribute the incoming
491 492 493 494 495 496 497 498
 * channel interrupt load by binding a channel to VCPU.
 * We do this in a hierarchical fashion:
 * First distribute the primary channels across available NUMA nodes
 * and then distribute the subchannels amongst the CPUs in the NUMA
 * node assigned to the primary channel.
 *
 * For pre-win8 hosts or non-performance critical channels we assign the
 * first CPU in the first NUMA node.
499
 */
500
static void init_vp_index(struct vmbus_channel *channel, u16 dev_type)
501 502
{
	u32 cur_cpu;
503
	bool perf_chn = vmbus_devs[dev_type].perf_device;
504 505 506
	struct vmbus_channel *primary = channel->primary_channel;
	int next_node;
	struct cpumask available_mask;
507
	struct cpumask *alloced_mask;
508 509 510 511 512 513 514 515 516

	if ((vmbus_proto_version == VERSION_WS2008) ||
	    (vmbus_proto_version == VERSION_WIN7) || (!perf_chn)) {
		/*
		 * Prior to win8, all channel interrupts are
		 * delivered on cpu 0.
		 * Also if the channel is not a performance critical
		 * channel, bind it to cpu 0.
		 */
517
		channel->numa_node = 0;
518
		channel->target_cpu = 0;
519
		channel->target_vp = hv_context.vp_index[0];
520
		return;
521
	}
522 523

	/*
524 525 526 527 528
	 * We distribute primary channels evenly across all the available
	 * NUMA nodes and within the assigned NUMA node we will assign the
	 * first available CPU to the primary channel.
	 * The sub-channels will be assigned to the CPUs available in the
	 * NUMA node evenly.
529
	 */
530 531 532 533 534 535 536 537 538 539 540 541
	if (!primary) {
		while (true) {
			next_node = next_numa_node_id++;
			if (next_node == nr_node_ids)
				next_node = next_numa_node_id = 0;
			if (cpumask_empty(cpumask_of_node(next_node)))
				continue;
			break;
		}
		channel->numa_node = next_node;
		primary = channel;
	}
542
	alloced_mask = &hv_context.hv_numa_map[primary->numa_node];
543

544
	if (cpumask_weight(alloced_mask) ==
545
	    cpumask_weight(cpumask_of_node(primary->numa_node))) {
546
		/*
547 548
		 * We have cycled through all the CPUs in the node;
		 * reset the alloced map.
549
		 */
550
		cpumask_clear(alloced_mask);
551 552
	}

553
	cpumask_xor(&available_mask, alloced_mask,
554 555
		    cpumask_of_node(primary->numa_node));

556
	cur_cpu = -1;
557 558 559 560 561 562 563 564 565 566 567

	/*
	 * Normally Hyper-V host doesn't create more subchannels than there
	 * are VCPUs on the node but it is possible when not all present VCPUs
	 * on the node are initialized by guest. Clear the alloced_cpus_in_node
	 * to start over.
	 */
	if (cpumask_equal(&primary->alloced_cpus_in_node,
			  cpumask_of_node(primary->numa_node)))
		cpumask_clear(&primary->alloced_cpus_in_node);

568 569 570 571 572 573 574 575 576
	while (true) {
		cur_cpu = cpumask_next(cur_cpu, &available_mask);
		if (cur_cpu >= nr_cpu_ids) {
			cur_cpu = -1;
			cpumask_copy(&available_mask,
				     cpumask_of_node(primary->numa_node));
			continue;
		}

577 578 579 580 581 582 583
		/*
		 * NOTE: in the case of sub-channel, we clear the sub-channel
		 * related bit(s) in primary->alloced_cpus_in_node in
		 * hv_process_channel_removal(), so when we reload drivers
		 * like hv_netvsc in SMP guest, here we're able to re-allocate
		 * bit from primary->alloced_cpus_in_node.
		 */
584 585 586 587 588 589 590 591
		if (!cpumask_test_cpu(cur_cpu,
				&primary->alloced_cpus_in_node)) {
			cpumask_set_cpu(cur_cpu,
					&primary->alloced_cpus_in_node);
			cpumask_set_cpu(cur_cpu, alloced_mask);
			break;
		}
	}
592

593 594
	channel->target_cpu = cur_cpu;
	channel->target_vp = hv_context.vp_index[cur_cpu];
595 596
}

597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630
static void vmbus_wait_for_unload(void)
{
	int cpu = smp_processor_id();
	void *page_addr = hv_context.synic_message_page[cpu];
	struct hv_message *msg = (struct hv_message *)page_addr +
				  VMBUS_MESSAGE_SINT;
	struct vmbus_channel_message_header *hdr;
	bool unloaded = false;

	while (1) {
		if (msg->header.message_type == HVMSG_NONE) {
			mdelay(10);
			continue;
		}

		hdr = (struct vmbus_channel_message_header *)msg->u.payload;
		if (hdr->msgtype == CHANNELMSG_UNLOAD_RESPONSE)
			unloaded = true;

		msg->header.message_type = HVMSG_NONE;
		/*
		 * header.message_type needs to be written before we do
		 * wrmsrl() below.
		 */
		mb();

		if (msg->header.message_flags.msg_pending)
			wrmsrl(HV_X64_MSR_EOM, 0);

		if (unloaded)
			break;
	}
}

631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646
/*
 * vmbus_unload_response - Handler for the unload response.
 */
static void vmbus_unload_response(struct vmbus_channel_message_header *hdr)
{
	/*
	 * This is a global event; just wakeup the waiting thread.
	 * Once we successfully unload, we can cleanup the monitor state.
	 */
	complete(&vmbus_connection.unload_event);
}

void vmbus_initiate_unload(void)
{
	struct vmbus_channel_message_header hdr;

647 648 649 650
	/* Pre-Win2012R2 hosts don't support reconnect */
	if (vmbus_proto_version < VERSION_WIN8_1)
		return;

651 652 653 654 655
	init_completion(&vmbus_connection.unload_event);
	memset(&hdr, 0, sizeof(struct vmbus_channel_message_header));
	hdr.msgtype = CHANNELMSG_UNLOAD;
	vmbus_post_msg(&hdr, sizeof(struct vmbus_channel_message_header));

656 657 658 659 660 661 662 663
	/*
	 * vmbus_initiate_unload() is also called on crash and the crash can be
	 * happening in an interrupt context, where scheduling is impossible.
	 */
	if (!in_interrupt())
		wait_for_completion(&vmbus_connection.unload_event);
	else
		vmbus_wait_for_unload();
664 665
}

666
/*
667
 * vmbus_onoffer - Handler for channel offers from vmbus in parent partition.
668 669
 *
 */
670
static void vmbus_onoffer(struct vmbus_channel_message_header *hdr)
671
{
672
	struct vmbus_channel_offer_channel *offer;
673
	struct vmbus_channel *newchannel;
674

675
	offer = (struct vmbus_channel_offer_channel *)hdr;
676

677
	/* Allocate the channel object and save this offer. */
678
	newchannel = alloc_channel();
679
	if (!newchannel) {
680
		pr_err("Unable to allocate channel object\n");
681 682 683
		return;
	}

684 685 686 687 688 689 690
	/*
	 * By default we setup state to enable batched
	 * reading. A specific service can choose to
	 * disable this prior to opening the channel.
	 */
	newchannel->batched_reading = true;

691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710
	/*
	 * Setup state for signalling the host.
	 */
	newchannel->sig_event = (struct hv_input_signal_event *)
				(ALIGN((unsigned long)
				&newchannel->sig_buf,
				HV_HYPERCALL_PARAM_ALIGN));

	newchannel->sig_event->connectionid.asu32 = 0;
	newchannel->sig_event->connectionid.u.id = VMBUS_EVENT_CONNECTION_ID;
	newchannel->sig_event->flag_number = 0;
	newchannel->sig_event->rsvdz = 0;

	if (vmbus_proto_version != VERSION_WS2008) {
		newchannel->is_dedicated_interrupt =
				(offer->is_dedicated_interrupt != 0);
		newchannel->sig_event->connectionid.u.id =
				offer->connection_id;
	}

711
	memcpy(&newchannel->offermsg, offer,
712
	       sizeof(struct vmbus_channel_offer_channel));
713 714
	newchannel->monitor_grp = (u8)offer->monitorid / 32;
	newchannel->monitor_bit = (u8)offer->monitorid % 32;
715

716
	vmbus_process_offer(newchannel);
717 718
}

719
/*
720
 * vmbus_onoffer_rescind - Rescind offer handler.
721 722 723
 *
 * We queue a work item to process this offer synchronously
 */
724
static void vmbus_onoffer_rescind(struct vmbus_channel_message_header *hdr)
725
{
726
	struct vmbus_channel_rescind_offer *rescind;
727
	struct vmbus_channel *channel;
728 729
	unsigned long flags;
	struct device *dev;
730

731
	rescind = (struct vmbus_channel_rescind_offer *)hdr;
732 733

	mutex_lock(&vmbus_connection.channel_mutex);
734
	channel = relid2channel(rescind->child_relid);
735

736
	if (channel == NULL) {
737 738 739 740 741
		/*
		 * This is very impossible, because in
		 * vmbus_process_offer(), we have already invoked
		 * vmbus_release_relid() on error.
		 */
742
		goto out;
743
	}
744

745 746 747 748 749
	spin_lock_irqsave(&channel->lock, flags);
	channel->rescind = true;
	spin_unlock_irqrestore(&channel->lock, flags);

	if (channel->device_obj) {
750 751
		if (channel->chn_rescind_callback) {
			channel->chn_rescind_callback(channel);
752
			goto out;
753
		}
754 755 756 757 758 759 760 761 762 763 764 765
		/*
		 * We will have to unregister this device from the
		 * driver core.
		 */
		dev = get_device(&channel->device_obj->device);
		if (dev) {
			vmbus_device_unregister(channel->device_obj);
			put_device(dev);
		}
	} else {
		hv_process_channel_removal(channel,
			channel->offermsg.child_relid);
766
	}
767 768 769 770 771 772 773 774 775 776 777 778 779 780 781

out:
	mutex_unlock(&vmbus_connection.channel_mutex);
}

void vmbus_hvsock_device_unregister(struct vmbus_channel *channel)
{
	mutex_lock(&vmbus_connection.channel_mutex);

	BUG_ON(!is_hvsock_channel(channel));

	channel->rescind = true;
	vmbus_device_unregister(channel->device_obj);

	mutex_unlock(&vmbus_connection.channel_mutex);
782
}
783 784
EXPORT_SYMBOL_GPL(vmbus_hvsock_device_unregister);

785

786
/*
787 788
 * vmbus_onoffers_delivered -
 * This is invoked when all offers have been delivered.
789 790 791
 *
 * Nothing to do here.
 */
792
static void vmbus_onoffers_delivered(
793
			struct vmbus_channel_message_header *hdr)
794 795 796
{
}

797
/*
798
 * vmbus_onopen_result - Open result handler.
799 800 801 802 803
 *
 * This is invoked when we received a response to our channel open request.
 * Find the matching request, copy the response and signal the requesting
 * thread.
 */
804
static void vmbus_onopen_result(struct vmbus_channel_message_header *hdr)
805
{
806
	struct vmbus_channel_open_result *result;
807 808 809
	struct vmbus_channel_msginfo *msginfo;
	struct vmbus_channel_message_header *requestheader;
	struct vmbus_channel_open_channel *openmsg;
810
	unsigned long flags;
811

812
	result = (struct vmbus_channel_open_result *)hdr;
813

814 815 816
	/*
	 * Find the open msg, copy the result and signal/unblock the wait event
	 */
817
	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
818

819 820
	list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
				msglistentry) {
821
		requestheader =
822
			(struct vmbus_channel_message_header *)msginfo->msg;
823

824
		if (requestheader->msgtype == CHANNELMSG_OPENCHANNEL) {
825
			openmsg =
826 827 828 829
			(struct vmbus_channel_open_channel *)msginfo->msg;
			if (openmsg->child_relid == result->child_relid &&
			    openmsg->openid == result->openid) {
				memcpy(&msginfo->response.open_result,
830
				       result,
831 832 833
				       sizeof(
					struct vmbus_channel_open_result));
				complete(&msginfo->waitevent);
834 835 836 837
				break;
			}
		}
	}
838
	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
839 840
}

841
/*
842
 * vmbus_ongpadl_created - GPADL created handler.
843 844 845 846 847
 *
 * This is invoked when we received a response to our gpadl create request.
 * Find the matching request, copy the response and signal the requesting
 * thread.
 */
848
static void vmbus_ongpadl_created(struct vmbus_channel_message_header *hdr)
849
{
850 851 852 853
	struct vmbus_channel_gpadl_created *gpadlcreated;
	struct vmbus_channel_msginfo *msginfo;
	struct vmbus_channel_message_header *requestheader;
	struct vmbus_channel_gpadl_header *gpadlheader;
854
	unsigned long flags;
855

856
	gpadlcreated = (struct vmbus_channel_gpadl_created *)hdr;
857

858 859 860 861
	/*
	 * Find the establish msg, copy the result and signal/unblock the wait
	 * event
	 */
862
	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
863

864 865
	list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
				msglistentry) {
866
		requestheader =
867
			(struct vmbus_channel_message_header *)msginfo->msg;
868

869
		if (requestheader->msgtype == CHANNELMSG_GPADL_HEADER) {
870 871 872
			gpadlheader =
			(struct vmbus_channel_gpadl_header *)requestheader;

873 874 875 876
			if ((gpadlcreated->child_relid ==
			     gpadlheader->child_relid) &&
			    (gpadlcreated->gpadl == gpadlheader->gpadl)) {
				memcpy(&msginfo->response.gpadl_created,
877
				       gpadlcreated,
878 879 880
				       sizeof(
					struct vmbus_channel_gpadl_created));
				complete(&msginfo->waitevent);
881 882 883 884
				break;
			}
		}
	}
885
	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
886 887
}

888
/*
889
 * vmbus_ongpadl_torndown - GPADL torndown handler.
890 891 892 893 894
 *
 * This is invoked when we received a response to our gpadl teardown request.
 * Find the matching request, copy the response and signal the requesting
 * thread.
 */
895
static void vmbus_ongpadl_torndown(
896
			struct vmbus_channel_message_header *hdr)
897
{
898 899 900 901
	struct vmbus_channel_gpadl_torndown *gpadl_torndown;
	struct vmbus_channel_msginfo *msginfo;
	struct vmbus_channel_message_header *requestheader;
	struct vmbus_channel_gpadl_teardown *gpadl_teardown;
902
	unsigned long flags;
903

904
	gpadl_torndown = (struct vmbus_channel_gpadl_torndown *)hdr;
905 906 907 908

	/*
	 * Find the open msg, copy the result and signal/unblock the wait event
	 */
909
	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
910

911 912
	list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
				msglistentry) {
913
		requestheader =
914
			(struct vmbus_channel_message_header *)msginfo->msg;
915

916
		if (requestheader->msgtype == CHANNELMSG_GPADL_TEARDOWN) {
917 918
			gpadl_teardown =
			(struct vmbus_channel_gpadl_teardown *)requestheader;
919

920 921
			if (gpadl_torndown->gpadl == gpadl_teardown->gpadl) {
				memcpy(&msginfo->response.gpadl_torndown,
922
				       gpadl_torndown,
923 924 925
				       sizeof(
					struct vmbus_channel_gpadl_torndown));
				complete(&msginfo->waitevent);
926 927 928 929
				break;
			}
		}
	}
930
	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
931 932
}

933
/*
934
 * vmbus_onversion_response - Version response handler
935 936 937 938 939
 *
 * This is invoked when we received a response to our initiate contact request.
 * Find the matching request, copy the response and signal the requesting
 * thread.
 */
940
static void vmbus_onversion_response(
941
		struct vmbus_channel_message_header *hdr)
942
{
943 944 945
	struct vmbus_channel_msginfo *msginfo;
	struct vmbus_channel_message_header *requestheader;
	struct vmbus_channel_version_response *version_response;
946
	unsigned long flags;
947

948
	version_response = (struct vmbus_channel_version_response *)hdr;
949
	spin_lock_irqsave(&vmbus_connection.channelmsg_lock, flags);
950

951 952
	list_for_each_entry(msginfo, &vmbus_connection.chn_msg_list,
				msglistentry) {
953
		requestheader =
954
			(struct vmbus_channel_message_header *)msginfo->msg;
955

956 957 958
		if (requestheader->msgtype ==
		    CHANNELMSG_INITIATE_CONTACT) {
			memcpy(&msginfo->response.version_response,
959
			      version_response,
960
			      sizeof(struct vmbus_channel_version_response));
961
			complete(&msginfo->waitevent);
962 963
		}
	}
964
	spin_unlock_irqrestore(&vmbus_connection.channelmsg_lock, flags);
965 966
}

967
/* Channel message dispatch table */
968
struct vmbus_channel_message_table_entry
969
	channel_message_table[CHANNELMSG_COUNT] = {
970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986
	{CHANNELMSG_INVALID,			0, NULL},
	{CHANNELMSG_OFFERCHANNEL,		0, vmbus_onoffer},
	{CHANNELMSG_RESCIND_CHANNELOFFER,	0, vmbus_onoffer_rescind},
	{CHANNELMSG_REQUESTOFFERS,		0, NULL},
	{CHANNELMSG_ALLOFFERS_DELIVERED,	1, vmbus_onoffers_delivered},
	{CHANNELMSG_OPENCHANNEL,		0, NULL},
	{CHANNELMSG_OPENCHANNEL_RESULT,		1, vmbus_onopen_result},
	{CHANNELMSG_CLOSECHANNEL,		0, NULL},
	{CHANNELMSG_GPADL_HEADER,		0, NULL},
	{CHANNELMSG_GPADL_BODY,			0, NULL},
	{CHANNELMSG_GPADL_CREATED,		1, vmbus_ongpadl_created},
	{CHANNELMSG_GPADL_TEARDOWN,		0, NULL},
	{CHANNELMSG_GPADL_TORNDOWN,		1, vmbus_ongpadl_torndown},
	{CHANNELMSG_RELID_RELEASED,		0, NULL},
	{CHANNELMSG_INITIATE_CONTACT,		0, NULL},
	{CHANNELMSG_VERSION_RESPONSE,		1, vmbus_onversion_response},
	{CHANNELMSG_UNLOAD,			0, NULL},
987
	{CHANNELMSG_UNLOAD_RESPONSE,		1, vmbus_unload_response},
988 989 990 991
	{CHANNELMSG_18,				0, NULL},
	{CHANNELMSG_19,				0, NULL},
	{CHANNELMSG_20,				0, NULL},
	{CHANNELMSG_TL_CONNECT_REQUEST,		0, NULL},
992 993
};

994
/*
995
 * vmbus_onmessage - Handler for channel protocol messages.
996 997 998
 *
 * This is invoked in the vmbus worker thread context.
 */
999
void vmbus_onmessage(void *context)
1000
{
1001
	struct hv_message *msg = context;
1002
	struct vmbus_channel_message_header *hdr;
1003 1004
	int size;

1005 1006
	hdr = (struct vmbus_channel_message_header *)msg->u.payload;
	size = msg->header.payload_size;
1007

1008
	if (hdr->msgtype >= CHANNELMSG_COUNT) {
1009
		pr_err("Received invalid channel message type %d size %d\n",
1010
			   hdr->msgtype, size);
1011
		print_hex_dump_bytes("", DUMP_PREFIX_NONE,
1012
				     (unsigned char *)msg->u.payload, size);
1013 1014 1015
		return;
	}

1016 1017
	if (channel_message_table[hdr->msgtype].message_handler)
		channel_message_table[hdr->msgtype].message_handler(hdr);
1018
	else
1019
		pr_err("Unhandled channel message type %d\n", hdr->msgtype);
1020 1021
}

1022
/*
1023
 * vmbus_request_offers - Send a request to get all our pending offers.
1024
 */
1025
int vmbus_request_offers(void)
1026
{
1027
	struct vmbus_channel_message_header *msg;
1028
	struct vmbus_channel_msginfo *msginfo;
1029
	int ret;
1030

1031
	msginfo = kmalloc(sizeof(*msginfo) +
1032 1033
			  sizeof(struct vmbus_channel_message_header),
			  GFP_KERNEL);
1034
	if (!msginfo)
1035
		return -ENOMEM;
1036

1037
	msg = (struct vmbus_channel_message_header *)msginfo->msg;
1038

1039
	msg->msgtype = CHANNELMSG_REQUESTOFFERS;
1040 1041


1042
	ret = vmbus_post_msg(msg,
1043 1044
			       sizeof(struct vmbus_channel_message_header));
	if (ret != 0) {
1045
		pr_err("Unable to request offers - %d\n", ret);
1046

1047 1048
		goto cleanup;
	}
1049

1050
cleanup:
1051
	kfree(msginfo);
1052 1053 1054 1055

	return ret;
}

1056 1057
/*
 * Retrieve the (sub) channel on which to send an outgoing request.
1058 1059
 * When a primary channel has multiple sub-channels, we try to
 * distribute the load equally amongst all available channels.
1060 1061 1062 1063
 */
struct vmbus_channel *vmbus_get_outgoing_channel(struct vmbus_channel *primary)
{
	struct list_head *cur, *tmp;
1064
	int cur_cpu;
1065 1066
	struct vmbus_channel *cur_channel;
	struct vmbus_channel *outgoing_channel = primary;
1067 1068
	int next_channel;
	int i = 1;
1069 1070 1071 1072

	if (list_empty(&primary->sc_list))
		return outgoing_channel;

1073 1074 1075 1076 1077 1078 1079
	next_channel = primary->next_oc++;

	if (next_channel > (primary->num_sc)) {
		primary->next_oc = 0;
		return outgoing_channel;
	}

1080 1081
	cur_cpu = hv_context.vp_index[get_cpu()];
	put_cpu();
1082 1083 1084 1085 1086 1087 1088 1089
	list_for_each_safe(cur, tmp, &primary->sc_list) {
		cur_channel = list_entry(cur, struct vmbus_channel, sc_list);
		if (cur_channel->state != CHANNEL_OPENED_STATE)
			continue;

		if (cur_channel->target_vp == cur_cpu)
			return cur_channel;

1090 1091
		if (i == next_channel)
			return cur_channel;
1092

1093
		i++;
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139
	}

	return outgoing_channel;
}
EXPORT_SYMBOL_GPL(vmbus_get_outgoing_channel);

static void invoke_sc_cb(struct vmbus_channel *primary_channel)
{
	struct list_head *cur, *tmp;
	struct vmbus_channel *cur_channel;

	if (primary_channel->sc_creation_callback == NULL)
		return;

	list_for_each_safe(cur, tmp, &primary_channel->sc_list) {
		cur_channel = list_entry(cur, struct vmbus_channel, sc_list);

		primary_channel->sc_creation_callback(cur_channel);
	}
}

void vmbus_set_sc_create_callback(struct vmbus_channel *primary_channel,
				void (*sc_cr_cb)(struct vmbus_channel *new_sc))
{
	primary_channel->sc_creation_callback = sc_cr_cb;
}
EXPORT_SYMBOL_GPL(vmbus_set_sc_create_callback);

bool vmbus_are_subchannels_present(struct vmbus_channel *primary)
{
	bool ret;

	ret = !list_empty(&primary->sc_list);

	if (ret) {
		/*
		 * Invoke the callback on sub-channel creation.
		 * This will present a uniform interface to the
		 * clients.
		 */
		invoke_sc_cb(primary);
	}

	return ret;
}
EXPORT_SYMBOL_GPL(vmbus_are_subchannels_present);
1140 1141 1142 1143 1144 1145 1146

void vmbus_set_chn_rescind_callback(struct vmbus_channel *channel,
		void (*chn_rescind_cb)(struct vmbus_channel *))
{
	channel->chn_rescind_callback = chn_rescind_cb;
}
EXPORT_SYMBOL_GPL(vmbus_set_chn_rescind_callback);