VMBus channel interrupts re-balancing
cover VMBus channel interrupts re-balancing
The RFC introduces constructs to re-balance the channel interrupts at CPU hotplug and at device hotplug operations, the latter being indeed "closure/opening operations" to enable the re-balancing also in cases when the device is just being closed/re-opened (as in "ethtool -L").
These changes originated from (and address /try to resolve) two known limitations of the current interrupts-to-CPUs mapping scheme, that is,
(1) the "static" nature of this mapping scheme (that, e.g., can end up preventing the hot removal of certain CPUs) and (2) the lack of global visibility in such scheme (where devices/channels are mapped only "one at a time"/as they are offered, with the end result that globally the various interrupts are not always evenly spread across CPUs).
Andrea Parri (Microsoft) (2):
Drivers: hv: vmbus: Re-balance channel interrupts across CPUs at CPU
hotplug
Drivers: hv: vmbus: Re-balance channel interrupts across CPUs at
device hotplug
drivers/hv/channel.c | 81 ++++++++++++ drivers/hv/channel_mgmt.c | 263 ++++++++++++++++++++++++++++++++++++++ drivers/hv/connection.c | 32 +++-- drivers/hv/hv.c | 62 +++++---- drivers/hv/hyperv_vmbus.h | 78 +++++++++++ drivers/hv/vmbus_drv.c | 45 ++----- include/linux/hyperv.h | 26 ++++ kernel/cpu.c | 1 + 8 files changed, 523 insertions(+), 65 deletions(-)
Signature · 1 line
2.25.1
RFC PATCH 1/2 Drivers: hv: vmbus: Re-balance channel interrupts across CPUs at CPU hotplug
CPU hot removals and additions present an opportunity for (re-)balancing the channel interrupts across the available CPUs. Current code does not balance the interrupts at CPU hotplug; furthermore/consequently, the hot removal path currently fails (to remove the specified CPU) whenever some interrupt is bound to the CPU to be removed and the VMBus is connected.
Address such issues by implementing vmbus_balance_vp_indexes_at_cpuhp():
invoke this primitive to balance the channel interrupts across available CPUs at CPU hotplug operations. In the hot removal path, such primitive will (try to) move/balance interrupts out of the to-be-removed CPU so as to meet the user request to hot remove the CPU.
The balancing algorithm distributes the channel interrupts evenly across the available CPUs and NUMA nodes; to do so, it introduces and maintains per-device and per-connection channel statistics/counts to keep track of the (current) assignments of the channels to the CPUs/nodes. By design, only "performance"-critical channels/devices are "balanced".
The proposed algorithm relies on the (recently introduced) capability to reassign a channel interrupt to a CPU (cf., the CHANNELMSG_MODIFYCHANNEL message type). As such, the new balancing process is effective starting with VMBus version 4.1 (no changes in semantics or behavior are intended for VMBus versions lower than 4.1).
--- drivers/hv/channel.c | 38 +++++++ drivers/hv/channel_mgmt.c | 219 ++++++++++++++++++++++++++++++++++++++ drivers/hv/connection.c | 23 ++-- drivers/hv/hv.c | 62 ++++++----- drivers/hv/hyperv_vmbus.h | 72 +++++++++++++ drivers/hv/vmbus_drv.c | 45 +++----- include/linux/hyperv.h | 22 +++- kernel/cpu.c | 1 + 8 files changed, 416 insertions(+), 66 deletions(-)
drivers/hv/channel.c +38 -0
@@ -18,6 +18,7 @@#include <linux/uio.h> #include <linux/interrupt.h> #include <asm/page.h> +#include <asm/mshyperv.h> #include "hyperv_vmbus.h"
@@ -317,6 +318,43 @@ int vmbus_send_modifychannel(u32 child_relid, u32 target_vp) }EXPORT_SYMBOL_GPL (vmbus_send_modifychannel); +bool vmbus_modifychannel (struct vmbus_channel *channel, +u32 origin_cpu,u32 target_cpu) +{ +if (vmbus_send_modifychannel (channel->offermsg.child_relid, +hv_cpu_number_to_vp_number (target_cpu))) +return false; + +/* +* Warning. At this point, there is *no* guarantee that the host will +* have successfully processed the vmbus_send_modifychannel() request. +* See the header comment of vmbus_send_modifychannel() for more info. +* +* Lags in the processing of the above vmbus_send_modifychannel() can +* result in missed interrupts if the "old" target CPU is taken offline +* before Hyper-V starts sending interrupts to the "new" target CPU. +* But apart from this offlining scenario, the code tolerates such +* lags. It will function correctly even if a channel interrupt comes +* in on a CPU that is different from the channel target_cpu value. +*/ + + channel->target_cpu = target_cpu; + channel->target_vp =hv_cpu_number_to_vp_number (target_cpu); + channel->numa_node =cpu_to_node (target_cpu); + +/* See init_vp_index(). */ +if (hv_is_perf_channel (channel)) +hv_update_alloced_cpus (origin_cpu, target_cpu); + +/* Currently set only for storvsc channels. */ +if (channel->change_target_cpu_callback) { + (*channel->change_target_cpu_callback)(channel, + origin_cpu, target_cpu); + } + +return true; +} +/* * create_gpadl_header - Creates a gpadl for the specified buffer */
drivers/hv/channel_mgmt.c +219 -0
241 lines not on this page · raw message
drivers/hv/connection.c +15 -8
@@ -183,6 +183,18 @@ int vmbus_connect(void)spin_lock_init (&vmbus_connection.channelmsg_lock);INIT_LIST_HEAD (&vmbus_connection.chn_list); + + vmbus_connection.channels =kcalloc (MAX_CHANNEL_RELIDS , +sizeof (struct vmbus_channel *), +GFP_KERNEL ); +if (vmbus_connection.channels ==NULL ) { + ret = -ENOMEM ; + goto cleanup; + } + +if (alloc_chn_counts (&vmbus_connection.chn_cnt)) + goto cleanup; +mutex_init (&vmbus_connection.channel_mutex);/*
@@ -248,14 +260,6 @@ int vmbus_connect(void)pr_info ("Vmbus version:%d.%d\n" , version >>16 , version &0xFFFF ); - vmbus_connection.channels =kcalloc (MAX_CHANNEL_RELIDS , -sizeof (struct vmbus_channel *), -GFP_KERNEL ); -if (vmbus_connection.channels ==NULL ) { - ret = -ENOMEM ; - goto cleanup; - } -kfree (msginfo);return 0 ;
@@ -295,6 +299,9 @@ void vmbus_disconnect(void)hv_free_hyperv_page ((unsigned long )vmbus_connection.monitor_pages[1 ]); vmbus_connection.monitor_pages[0 ] =NULL ; vmbus_connection.monitor_pages[1 ] =NULL ; + +free_chn_counts (&vmbus_connection.chn_cnt); +kfree (vmbus_connection.channels); }/*
drivers/hv/hv.c +37 -25
88 lines not on this page · raw message
drivers/hv/hyperv_vmbus.h +72 -0
96 lines not on this page · raw message
drivers/hv/vmbus_drv.c +13 -32
70 lines not on this page · raw message
include/linux/hyperv.h +21 -1
@@ -1175,6 +1175,12 @@ struct hv_driver { }; +/* For channel-interrupts balancing. */ +struct vmbus_channel_counts { +unsigned int *cpu; +unsigned int *node; +}; +/* Base device object */ struct hv_device {/* the device type id of this device */
@@ -1191,9 +1197,21 @@ struct hv_device {struct vmbus_channel *channel;struct kset *channels_kset; +/* +* Channel counts used by the channel-interrupts balancing scheme: +* +* - chn_cnt.cpu[cpu], the number of channel interrupts of this +* device assigned to CPU #cpu; +* +* - chn_cnt.node[node], the number of channel interrupts of this +* device assigned to NUMA node #node. +* +* The counts refer to "open" *and "performance" channels only. +*/ +struct vmbus_channel_counts chn_cnt; +/* place holder to keep track of the dir for hv device in debugfs */ struct dentry *debug_dir; - };
@@ -1523,6 +1541,8 @@ extern __u32 vmbus_proto_version;int vmbus_send_tl_connect_request (const guid_t *shv_guest_servie_id,const guid_t *shv_host_servie_id);int vmbus_send_modifychannel (u32 child_relid,u32 target_vp); +bool vmbus_modifychannel (struct vmbus_channel *channel, +u32 origin_cpu,u32 target_cpu);void vmbus_set_event (struct vmbus_channel *channel);/* Get the start of the ring buffer. */
kernel/cpu.c +1 -0
@@ -328,6 +328,7 @@ void lockdep_assert_cpus_held(void)percpu_rwsem_assert_held (&cpu_hotplug_lock); } +EXPORT_SYMBOL_GPL (lockdep_assert_cpus_held);static void lockdep_acquire_cpus_lock (void ) {
Signature · 1 line
2.25.1
RE: [RFC PATCH 1/2] Drivers: hv: vmbus: Re-balance channel interrupts across CPUs at CPU hotplug
From: Andrea Parri (Microsoft) <[email protected]> Sent: Tuesday, May 26, 2020 3:32 PM
Quoted 114 lines
CPU hot removals and additions present an opportunity for (re-)balancing the channel interrupts across the available CPUs. Current code does not balance the interrupts at CPU hotplug; furthermore/consequently, the hot removal path currently fails (to remove the specified CPU) whenever some interrupt is bound to the CPU to be removed and the VMBus is connected.
Address such issues by implementing
vmbus_balance_vp_indexes_at_cpuhp():
invoke this primitive to balance the channel interrupts across available CPUs at CPU hotplug operations. In the hot removal path, such primitive will (try to) move/balance interrupts out of the to-be-removed CPU so as to meet the user request to hot remove the CPU.The balancing algorithm distributes the channel interrupts evenly across the available CPUs and NUMA nodes; to do so, it introduces and maintains per-device and per-connection channel statistics/counts to keep track of the (current) assignments of the channels to the CPUs/nodes. By design, only "performance"-critical channels/devices are "balanced".
The proposed algorithm relies on the (recently introduced) capability to reassign a channel interrupt to a CPU (cf., the
CHANNELMSG_MODIFYCHANNELmessage type). As such, the new balancing process is effective starting with VMBus version 4.1 (no changes in semantics or behavior are intended for VMBus versions lower than 4.1).Suggested-by Nuno Das Neves <[email protected]>Signed-off-by Andrea Parri (Microsoft) <[email protected]>--- drivers/hv/channel.c | 38 +++++++ drivers/hv/channel_mgmt.c | 219 ++++++++++++++++++++++++++++++++++++++ drivers/hv/connection.c | 23 ++-- drivers/hv/hv.c | 62 ++++++----- drivers/hv/hyperv_vmbus.h | 72 +++++++++++++ drivers/hv/vmbus_drv.c | 45 +++----- include/linux/hyperv.h | 22 +++- kernel/cpu.c | 1 + 8 files changed, 416 insertions(+), 66 deletions(-)drivers/hv/channel.c +38
-0@@ -18,6 +18,7 @@#include <linux/uio.h> #include <linux/interrupt.h> #include <asm/page.h> +#include <asm/mshyperv.h> #include "hyperv_vmbus.h" @@ -317,6 +318,43 @@ int vmbus_send_modifychannel(u32 child_relid, u32 target_vp) }EXPORT_SYMBOL_GPL (vmbus_send_modifychannel); +bool vmbus_modifychannel (struct vmbus_channel *channel, +u32 origin_cpu,u32 target_cpu) +{ +if (vmbus_send_modifychannel (channel->offermsg.child_relid, +hv_cpu_number_to_vp_number (target_cpu))) +return false; + +/* +* Warning. At this point, there is *no* guarantee that the host will +* have successfully processed the vmbus_send_modifychannel() request. +* See the header comment of vmbus_send_modifychannel() for more info. +* +* Lags in the processing of the above vmbus_send_modifychannel() can +* result in missed interrupts if the "old" target CPU is taken offline +* before Hyper-V starts sending interrupts to the "new" target CPU. +* But apart from this offlining scenario, the code tolerates such +* lags. It will function correctly even if a channel interrupt comes +* in on a CPU that is different from the channel target_cpu value. +*/ + + channel->target_cpu = target_cpu; + channel->target_vp =hv_cpu_number_to_vp_number (target_cpu); + channel->numa_node =cpu_to_node (target_cpu); + +/* See init_vp_index(). */ +if (hv_is_perf_channel (channel)) +hv_update_alloced_cpus (origin_cpu, target_cpu); + +/* Currently set only for storvsc channels. */ +if (channel->change_target_cpu_callback) { + (*channel->change_target_cpu_callback)(channel, + origin_cpu, target_cpu); + } + +return true; +} +/* * create_gpadl_header - Creates a gpadl for the specified buffer */ drivers/hv/channel_mgmt.c +4
-0@@ -497,10 +497,14 @@ static void vmbus_add_channel_work(struct work_struct *work)/* * Start the process of binding the primary channel to the driver */ + +/* See vmbus_balance_vp_indexes_at_cpuhp(). */ +mutex_lock (&vmbus_connection.channel_mutex); newchannel->device_obj =vmbus_device_create ( &newchannel->offermsg.offer.if_type, &newchannel->offermsg.offer.if_instance, newchannel); +mutex_unlock (&vmbus_connection.channel_mutex);if (!newchannel->device_obj) goto err_deq_chan;
drivers/hv/channel_mgmt.c static void vmbus_add_channel_work(struct work_struct *work) · line 523
Quoted 5 lines
drivers/hv/channel_mgmt.c +2
-0@@ -515,6 +519,8 @@ static void vmbus_add_channel_work(struct work_struct *work)if (ret !=0 ) {pr_err ("unable to add child device object (relid %d)\n" , newchannel->offermsg.child_relid); +if (hv_is_perf_channel (newchannel)) +free_chn_counts (&newchannel->device_obj->chn_cnt);
You could drop the "if" condition and just always call free_chn_counts() since it will do the right thing for non-perf channels where the memory was never allocated.
Quoted 57 lines
drivers/hv/channel_mgmt.c +49
-0kfree (newchannel->device_obj); goto err_deq_chan; }@@ -667,6 +673,219 @@ static void vmbus_process_offer(struct vmbus_channel *newchannel)queue_work (wq, &newchannel->add_channel_work); } +static void filter_on_cpus (cpumask_var_t cpu_msk, +struct vmbus_channel_counts *chn_cnt) +{ +unsigned int min_cnt =MAX_CHANNEL_RELIDS ; +unsigned int cpu; + +for_each_cpu (cpu, cpu_msk) { +unsigned int cnt = chn_cnt->cpu[cpu]; + +if (cnt < min_cnt) + min_cnt = cnt; + } + +for_each_cpu (cpu, cpu_msk) { +if (chn_cnt->cpu[cpu] > min_cnt) +cpumask_clear_cpu (cpu, cpu_msk); + } +} + +static void filter_on_nodes (cpumask_var_t cpu_msk, +struct vmbus_channel_counts *chn_cnt) +{ +unsigned int min_cnt =MAX_CHANNEL_RELIDS ; +unsigned int cpu; + +for_each_cpu (cpu, cpu_msk) { +unsigned int node =cpu_to_node (cpu); +unsigned int cnt = chn_cnt->node[node]; + +if (cnt < min_cnt) + min_cnt = cnt; + + cpu =cpumask_last (cpumask_of_node (node)); + } + +for_each_cpu (cpu, cpu_msk) { +unsigned int node =cpu_to_node (cpu); +const struct cpumask *msk_node =cpumask_of_node (node); + +if (chn_cnt->node[node] > min_cnt) +cpumask_andnot (cpu_msk, cpu_msk, msk_node); + + cpu =cpumask_last (msk_node); + } +} + +static inline void __filter_vp_index (struct vmbus_channel_counts *chn_cnt, +cpumask_var_t cpu_msk) +{
drivers/hv/channel_mgmt.c static void vmbus_process_offer(struct vmbus_channel · line 735
Quoted 10 lines
drivers/hv/channel_mgmt.c +10
-0+filter_on_cpus (cpu_msk, chn_cnt); +filter_on_nodes (cpu_msk, chn_cnt); +} + +static void filter_vp_index (struct hv_device *hv_dev,cpumask_var_t cpu_msk) +{ +/* +* The selection of the target CPUs is performed in two domains, +* the device domain and the connection domain. At each domain, +* in turn, invalid CPUs are filtered out at two levels, the CPU
I would drop the word "invalid". You are filtering out CPUs that meet the criteria in the sentence starting after the colon below.
Quoted 23 lines
drivers/hv/channel_mgmt.c +23
-0+* level and the NUMA-node level: CPUs corresponding to channel +* counts *greater* than the minimum channel count for the given +* level/domain are cleared in the mask of candidate target CPUs. +*/ + +__filter_vp_index (&hv_dev->chn_cnt, cpu_msk); +__filter_vp_index (&vmbus_connection.chn_cnt, cpu_msk); +} + +static void balance_vp_index (struct vmbus_channel *chn, +struct hv_device *hv_dev,cpumask_var_t cpu_msk) +{ +u32 cur_cpu = chn->target_cpu, tgt_cpu = cur_cpu; + +if (chn->state !=CHANNEL_OPENED_STATE ) { +/* +* The channel may never have been opened or it may be in +* a closed/closing state; if so, do not touch the target +* CPU of this channel. +*/ + goto update_chn_cnts; + } +
drivers/hv/channel_mgmt.c static void vmbus_process_offer(struct vmbus_channel *newchannel) · line 767
Quoted 10 lines
drivers/hv/channel_mgmt.c +10
-0+/* +* The channel was open, and it will remain open until we release +* channel_mutex, cf. the use of channel_mutex and channel->state +* in vmbus_disconnect_ring() -> vmbus_close_internal(). +*/ + +if (!hv_is_perf_channel (chn)) { +/* +* Only used by the CPU hot removal path, remark that +* the connect CPU can not go offline.
To be super explicit in the comment: If the channel is not a performance channel, then it does not participate in the balancing, and we move it back to interrupting the VMBUS_CONNECT_CPU for lack of a better choice. Because non-perf channels are initially set to interrupt the VMBUS_CONNECT_CPU, the only way a non-perf channel could be found in this state (i.e., set to a CPU other than VMBUS_CONNECT_CPU) is a manual change through the sysfs interface.
Quoted 89 lines
drivers/hv/channel_mgmt.c +89
-0+*/ + tgt_cpu =VMBUS_CONNECT_CPU ; + goto modify_vp_index; + } + +/* +* Retrieve the new "candidate" target CPUs for this channel +* /device; see the inline comments in filter_vp_index() for +* a high-level description of this algorithm. +*/ +filter_vp_index (hv_dev, cpu_msk); + +/* +* (Try to) preserve the channel's CPU and NUMA node affinities +* respectively: +*/ + +if (cpumask_test_cpu (cur_cpu, cpu_msk)) + goto update_chn_cnts; + +/* +* If we reach here, a modification of the channel's target CPU +* is "needed". +*/ + + tgt_cpu =cpumask_first_and (cpumask_of_node (cpu_to_node (cur_cpu)), + cpu_msk); +if (tgt_cpu < nr_cpu_ids) + goto modify_vp_index; + +/* +* It was not possible to preserve this channel's CPU and NUMA +* node affinities; pick the "first" candidate target CPU (the +* CPU mask can not be empty). +*/ + tgt_cpu =cpumask_first (cpu_msk); + +modify_vp_index: +if (!vmbus_modifychannel (chn, cur_cpu, tgt_cpu)) + tgt_cpu = cur_cpu; + +update_chn_cnts: +/* Do not account for non-"perf" channels in chn_cnt. */ +if (!hv_is_perf_channel (chn)) +return ; + +inc_chn_counts (&hv_dev->chn_cnt, tgt_cpu); +inc_chn_counts (&vmbus_connection.chn_cnt, tgt_cpu); +} + +void vmbus_balance_vp_indexes_at_cpuhp (unsigned int cpu,bool add) +{ +struct vmbus_channel *chn, *sc; +cpumask_var_t cpu_msk; + +lockdep_assert_cpus_held (); +lockdep_assert_held (&vmbus_connection.channel_mutex); + +WARN_ON (!cpumask_test_cpu (cpu, cpu_online_mask)); + +/* See the header comment for vmbus_send_modifychannel(). */ +if (vmbus_proto_version <VERSION_WIN10_V4_1 ) +return ; + +if (!alloc_cpumask_var (&cpu_msk,GFP_KERNEL )) +return ; + +reset_chn_counts (&vmbus_connection.chn_cnt); + +list_for_each_entry (chn, &vmbus_connection.chn_list, listentry) { +struct hv_device *dev = chn->device_obj; + +/* +* The device may not have been allocated/assigned to +* the primary channel yet; if so, do not balance the +* channels associated to this device. If dev != NULL, +* the synchronization on channel_mutex ensures that +* the device's chn_cnt has been (properly) allocated +* *and* initialized, cf. vmbus_add_channel_work(). +*/ +if (dev ==NULL ) +continue ; + +/* +* By design, non-"perf" channels do not take part in +* the balancing process. +* +* The user may have assigned some non-"perf" channel +* to this CPU. To satisfy the user's request to hot
drivers/hv/channel_mgmt.c static void vmbus_process_offer(struct vmbus_channel *newchannel) · line 866
Quoted 10 lines
drivers/hv/channel_mgmt.c +10
-0+* remove the CPU, we will re-assign such channels to +* the connect CPU; cf. balance_vp_index(). +*/ +if (!hv_is_perf_channel (chn)) { +if (add) +continue ; +/* +* Assume that the non-"perf" channel has no +* sub-channels. +*/
The "if" statement below could use a bit further explanation to help the reader. :-) If this non-perf channel is assigned to some CPU other than the one we are hot-removing, then we execute the "continue" statement and leave its target CPU unchanged. But if it is assigned to the CPU we are hot removing, then we need to move the channel to some other CPU.
I'm also not clear on how the above comment about having no sub-channels is relevant. Maybe a bit more explanation would help.
Quoted 82 lines
drivers/hv/channel_mgmt.c +22
-0+if (chn->target_cpu != cpu) +continue ; + }else { +reset_chn_counts (&dev->chn_cnt); + } + +cpumask_copy (cpu_msk, cpu_online_mask); +if (!add) +cpumask_clear_cpu (cpu, cpu_msk); +balance_vp_index (chn, dev, cpu_msk); + +list_for_each_entry (sc, &chn->sc_list, sc_list) { +cpumask_copy (cpu_msk, cpu_online_mask); +if (!add) +cpumask_clear_cpu (cpu, cpu_msk); +balance_vp_index (sc, dev, cpu_msk); + } + } + +free_cpumask_var (cpu_msk); +} +/* * We use this state to statically distribute the channel interrupt load. */
drivers/hv/connection.c +15
-8@@ -183,6 +183,18 @@ int vmbus_connect(void)spin_lock_init (&vmbus_connection.channelmsg_lock);INIT_LIST_HEAD (&vmbus_connection.chn_list); + + vmbus_connection.channels =kcalloc (MAX_CHANNEL_RELIDS , +sizeof (struct vmbus_channel *), +GFP_KERNEL ); +if (vmbus_connection.channels ==NULL ) { + ret = -ENOMEM ; + goto cleanup; + } + +if (alloc_chn_counts (&vmbus_connection.chn_cnt)) + goto cleanup; +mutex_init (&vmbus_connection.channel_mutex);/* @@ -248,14 +260,6 @@ int vmbus_connect(void)pr_info ("Vmbus version:%d.%d\n" , version >>16 , version &0xFFFF ); - vmbus_connection.channels =kcalloc (MAX_CHANNEL_RELIDS , -sizeof (struct vmbus_channel *), -GFP_KERNEL ); -if (vmbus_connection.channels ==NULL ) { - ret = -ENOMEM ; - goto cleanup; - } -kfree (msginfo);return 0 ;@@ -295,6 +299,9 @@ void vmbus_disconnect(void)hv_free_hyperv_page ((unsigned long )vmbus_connection.monitor_pages[1 ]); vmbus_connection.monitor_pages[0 ] =NULL ; vmbus_connection.monitor_pages[1 ] =NULL ; + +free_chn_counts (&vmbus_connection.chn_cnt); +kfree (vmbus_connection.channels); }/* drivers/hv/hv.c +1
-0@@ -198,6 +198,20 @@ void hv_synic_enable_regs(unsigned int cpu)int hv_synic_init (unsigned int cpu) { +/*
drivers/hv/hv.c void hv_synic_enable_regs(unsigned int cpu) · line 211
Quoted 10 lines
drivers/hv/hv.c +10
-0+* The CPU has been hot added: try to re-balance the channels +* across the online CPUs (including "this" CPU), provided that +* the VMBus is connected; in part., avoid the re-balancing at +* the very first CPU initialization. +* +* See also inline comments in hv_synic_cleanup(). +*/ +if (vmbus_connection.conn_state ==CONNECTED ) { +mutex_lock (&vmbus_connection.channel_mutex); +vmbus_balance_vp_indexes_at_cpuhp (cpu, true);
Does the target CPU have its bit in cpu_online_mask set at the time this is executed? reset_chn_counts() does a for_each_online_cpu() loop, and we want to make sure the count for this CPU gets reset to zero.
Quoted 185 lines
drivers/hv/hv.c +26
-25+mutex_unlock (&vmbus_connection.channel_mutex); + } +hv_synic_enable_regs (cpu);hv_stimer_legacy_init (cpu,VMBUS_MESSAGE_SINT );@@ -243,10 +257,6 @@ void hv_synic_disable_regs(unsigned int cpu)int hv_synic_cleanup (unsigned int cpu) { -struct vmbus_channel *channel, *sc; -bool channel_found = false; -unsigned long flags; -/* * Hyper-V does not provide a way to change the connect CPU once * it is set; we must prevent the connect CPU from going offline. @@ -254,35 +264,37 @@ int hv_synic_cleanup(unsigned int cpu)if (cpu ==VMBUS_CONNECT_CPU )return -EBUSY ; +mutex_lock (&vmbus_connection.channel_mutex); +/* +* The CPU is being hot removed: re-balance the channels across +* the online CPUs but excluding "this" CPU. +* +* Note. We do not roll back on failure; IOW, we may end up with +* situations where the (re-)balancing process failed but some of +* the channels have been re-assigned to different CPUs. +* +* Also, the balancing process makes no attempt to re-assign "non- +* open" channels, that is, it only applies to channels which are +* found in CHANNEL_OPENED_STATE. +*/ +vmbus_balance_vp_indexes_at_cpuhp (cpu, false); +/* * Search for channels which are bound to the CPU we're about to * cleanup. In case we find one and vmbus is still connected, we * fail; this will effectively prevent CPU offlining. -* -* TODO: Re-bind the channels to different CPUs. */ -mutex_lock (&vmbus_connection.channel_mutex); -list_for_each_entry (channel, &vmbus_connection.chn_list, listentry) { -if (channel->target_cpu == cpu) { - channel_found = true; -break ; - } -spin_lock_irqsave (&channel->lock, flags); -list_for_each_entry (sc, &channel->sc_list, sc_list) { -if (sc->target_cpu == cpu) { - channel_found = true; -break ; - } - } -spin_unlock_irqrestore (&channel->lock, flags); -if (channel_found) -break ; +if (hv_is_busy_cpu (cpu) && vmbus_connection.conn_state ==CONNECTED ) { +/* +* The CPU was busy, and we are going to prevent it from +* going offline; balance the channels accordingly. +*/ +vmbus_balance_vp_indexes_at_cpuhp (cpu, true); +mutex_unlock (&vmbus_connection.channel_mutex); +return -EBUSY ; }mutex_unlock (&vmbus_connection.channel_mutex); -if (channel_found && vmbus_connection.conn_state ==CONNECTED ) -return -EBUSY ; -hv_stimer_legacy_cleanup (cpu);hv_synic_disable_regs (cpu);drivers/hv/hyperv_vmbus.h +72
-0@@ -18,6 +18,7 @@#include <linux/atomic.h> #include <linux/hyperv.h> #include <linux/interrupt.h> +#include <linux/slab.h> #include "hv_trace.h" @@ -250,6 +251,19 @@ struct vmbus_connection {/* Array of channels */ struct vmbus_channel **channels; +/* +* Channel counts used by the channel-interrupts balancing scheme: +* +* - chn_cnt.cpu[cpu], the number of channel interrupts assigned +* to CPU #cpu; +* +* - chn_cnt.node[node], the number of channel interrupts assigned +* to NUMA node #node. +* +* The counts refer to "open" *and "performance" channels only. +*/ +struct vmbus_channel_counts chn_cnt; +/* * An offer message is handled first on the work_queue, and then * is further handled on handle_primary_chan_wq or @@ -344,6 +358,8 @@ struct vmbus_channel *relid2channel(u32 relid);void vmbus_free_channels (void ); +void vmbus_balance_vp_indexes_at_cpuhp (unsigned int cpu,bool add); +/* Connection interface */ int vmbus_connect (void );@@ -443,6 +459,62 @@ static inline void hv_update_alloced_cpus(unsigned int old_cpu,hv_clear_alloced_cpu (old_cpu); } +static inline bool hv_is_busy_cpu (unsigned int cpu) +{ +struct vmbus_channel *channel, *sc; + +lockdep_assert_held (&vmbus_connection.channel_mutex); +/* +* List additions/deletions as well as updates of the target CPUs are +* protected by channel_mutex. +*/ +list_for_each_entry (channel, &vmbus_connection.chn_list, listentry) { +if (channel->target_cpu == cpu) +return true; +list_for_each_entry (sc, &channel->sc_list, sc_list) { +if (sc->target_cpu == cpu) +return true; + } + } +return false; +} + +static inline int alloc_chn_counts (struct vmbus_channel_counts *chn_cnt) +{ + chn_cnt->cpu =kcalloc (nr_cpu_ids,sizeof (unsigned int ),GFP_KERNEL ); +if (chn_cnt->cpu ==NULL ) +return -ENOMEM ; + + chn_cnt->node =kcalloc (nr_node_ids,sizeof (unsigned int ),GFP_KERNEL ); +if (chn_cnt->node ==NULL ) +return -ENOMEM ; + +return 0 ; +} + +static inline void inc_chn_counts (struct vmbus_channel_counts *chn_cnt, +unsigned int cpu) +{ + chn_cnt->cpu[cpu] +=1 ; + chn_cnt->node[cpu_to_node (cpu)] +=1 ; +} + +static inline void reset_chn_counts (struct vmbus_channel_counts *chn_cnt) +{ +unsigned int i; + +for_each_online_cpu (i) + chn_cnt->cpu[i] =0 ; +for_each_online_node (i) + chn_cnt->node[i] =0 ; +} + +static inline void free_chn_counts (struct vmbus_channel_counts *chn_cnt) +{ +kfree (chn_cnt->cpu); +kfree (chn_cnt->node); +} +#ifdef CONFIG_HYPERV_TESTING int hv_debug_add_dev_dir (struct hv_device *dev);drivers/hv/vmbus_drv.c +0
-0
drivers/hv/vmbus_drv.c static void vmbus_device_release(struct device *device) · line 985
Quoted 6 lines
drivers/hv/vmbus_drv.c +3
-0@@ -980,6 +980,9 @@ static void vmbus_device_release(struct device *device)mutex_lock (&vmbus_connection.channel_mutex);hv_process_channel_removal (channel);mutex_unlock (&vmbus_connection.channel_mutex); + +if (hv_is_perf_channel (channel)) +free_chn_counts (&hv_dev->chn_cnt);
Again, can drop the 'if' statement.
Quoted 130 lines
drivers/hv/vmbus_drv.c +10
-32kfree (hv_dev); }@@ -1745,38 +1748,8 @@ static ssize_t target_cpu_store(struct vmbus_channel *channel,if (target_cpu == origin_cpu) goto cpu_store_unlock; -if (vmbus_send_modifychannel (channel->offermsg.child_relid, -hv_cpu_number_to_vp_number (target_cpu))) { +if (!vmbus_modifychannel (channel, origin_cpu, target_cpu)) ret = -EIO ; - goto cpu_store_unlock; - } - -/* -* Warning. At this point, there is *no* guarantee that the host will -* have successfully processed the vmbus_send_modifychannel() request. -* See the header comment of vmbus_send_modifychannel() for more info. -* -* Lags in the processing of the above vmbus_send_modifychannel() can -* result in missed interrupts if the "old" target CPU is taken offline -* before Hyper-V starts sending interrupts to the "new" target CPU. -* But apart from this offlining scenario, the code tolerates such -* lags. It will function correctly even if a channel interrupt comes -* in on a CPU that is different from the channel target_cpu value. -*/ - - channel->target_cpu = target_cpu; - channel->target_vp =hv_cpu_number_to_vp_number (target_cpu); - channel->numa_node =cpu_to_node (target_cpu); - -/* See init_vp_index(). */ -if (hv_is_perf_channel (channel)) -hv_update_alloced_cpus (origin_cpu, target_cpu); - -/* Currently set only for storvsc channels. */ -if (channel->change_target_cpu_callback) { - (*channel->change_target_cpu_callback)(channel, - origin_cpu, target_cpu); - } cpu_store_unlock:mutex_unlock (&vmbus_connection.channel_mutex);@@ -1972,6 +1945,15 @@ struct hv_device *vmbus_device_create(const guid_t *type,guid_copy (&child_device_obj->dev_instance, instance); child_device_obj->vendor_id =0x1414 ;/* MSFT vendor ID */ +if (!hv_is_perf_channel (channel)) +return child_device_obj; + +if (alloc_chn_counts (&child_device_obj->chn_cnt)) { +free_chn_counts (&child_device_obj->chn_cnt); +kfree (child_device_obj); +return NULL ; + } +return child_device_obj; }@@ -2616,7 +2598,6 @@ static void __exit vmbus_exit(void)hv_debug_rm_all_dir ();vmbus_free_channels (); -kfree (vmbus_connection.channels);if (ms_hyperv.misc_features &HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE ) {kmsg_dump_unregister (&hv_kmsg_dumper);include/linux/hyperv.h +21
-1@@ -1175,6 +1175,12 @@ struct hv_driver { }; +/* For channel-interrupts balancing. */ +struct vmbus_channel_counts { +unsigned int *cpu; +unsigned int *node; +}; +/* Base device object */ struct hv_device {/* the device type id of this device */ @@ -1191,9 +1197,21 @@ struct hv_device {struct vmbus_channel *channel;struct kset *channels_kset; +/* +* Channel counts used by the channel-interrupts balancing scheme: +* +* - chn_cnt.cpu[cpu], the number of channel interrupts of this +* device assigned to CPU #cpu; +* +* - chn_cnt.node[node], the number of channel interrupts of this +* device assigned to NUMA node #node. +* +* The counts refer to "open" *and "performance" channels only. +*/ +struct vmbus_channel_counts chn_cnt; +/* place holder to keep track of the dir for hv device in debugfs */ struct dentry *debug_dir; - };@@ -1523,6 +1541,8 @@ extern __u32 vmbus_proto_version;int vmbus_send_tl_connect_request (const guid_t *shv_guest_servie_id,const guid_t *shv_host_servie_id);int vmbus_send_modifychannel (u32 child_relid,u32 target_vp); +bool vmbus_modifychannel (struct vmbus_channel *channel, +u32 origin_cpu,u32 target_cpu);void vmbus_set_event (struct vmbus_channel *channel);/* Get the start of the ring buffer. */ kernel/cpu.c +1
-1@@ -328,6 +328,7 @@ void lockdep_assert_cpus_held(void)percpu_rwsem_assert_held (&cpu_hotplug_lock); } +EXPORT_SYMBOL_GPL (lockdep_assert_cpus_held);static void lockdep_acquire_cpus_lock (void ) { --2.25.1
Re: [RFC PATCH 1/2] Drivers: hv: vmbus: Re-balance channel interrupts across CPUs at CPU hotplug
Quoted 10 lines
drivers/hv/channel_mgmt.c static void vmbus_add_channel_work(struct work_struct *work) · line 523
Quoted 6 lines
drivers/hv/channel_mgmt.c +2
-0@@ -515,6 +519,8 @@ static void vmbus_add_channel_work(struct work_struct *work)if (ret !=0 ) {pr_err ("unable to add child device object (relid %d)\n" , newchannel->offermsg.child_relid); +if (hv_is_perf_channel (newchannel)) +free_chn_counts (&newchannel->device_obj->chn_cnt);You could drop the "if" condition and just always call
free_chn_counts()since it will do the right thing for non-perf channels where the memory was never allocated.
Well, AFAICT, the above would do the "right" thing for non-perf channels without calling kfree() twice. ;-) It would also serve as a hard-coded "reminder" of the fact that there is no alloc_chn_counts() for them. No strong opinions though, will drop for the next submission...
Quoted 9 lines
drivers/hv/channel_mgmt.c static void vmbus_process_offer(struct vmbus_channel *newchannel) · line 734
Quoted 6 lines
drivers/hv/channel_mgmt.c +6
-0+static void filter_vp_index (struct hv_device *hv_dev,cpumask_var_t cpu_msk) +{ +/* +* The selection of the target CPUs is performed in two domains, +* the device domain and the connection domain. At each domain, +* in turn, invalid CPUs are filtered out at two levels, the CPU I would drop the word "invalid". You are filtering out CPUs that meet the criteria in the sentence starting after the colon below.
Agreed, will drop.
Quoted 25 lines
Quoted 14 lines
drivers/hv/channel_mgmt.c +14
-0+static void balance_vp_index (struct vmbus_channel *chn, +struct hv_device *hv_dev,cpumask_var_t cpu_msk) +{ +u32 cur_cpu = chn->target_cpu, tgt_cpu = cur_cpu; + +if (chn->state !=CHANNEL_OPENED_STATE ) { +/* +* The channel may never have been opened or it may be in +* a closed/closing state; if so, do not touch the target +* CPU of this channel. +*/ + goto update_chn_cnts; + } +drivers/hv/channel_mgmt.c static void vmbus_process_offer(struct vmbus_channel *newchannel) · line 767
Quoted 10 lines
drivers/hv/channel_mgmt.c +10
-0+/* +* The channel was open, and it will remain open until we release +* channel_mutex, cf. the use of channel_mutex and channel->state +* in vmbus_disconnect_ring() -> vmbus_close_internal(). +*/ + +if (!hv_is_perf_channel (chn)) { +/* +* Only used by the CPU hot removal path, remark that +* the connect CPU can not go offline.
Quoted 7 lines
To be super explicit in the comment: If the channel is not a performance channel, then it does not participate in the balancing, and we move it back to interrupting the
VMBUS_CONNECT_CPUfor lack of a better choice. Because non-perf channels are initially set to interrupt theVMBUS_CONNECT_CPU, the only way a non-perf channel could be found in this state (i.e., set to a CPU other thanVMBUS_CONNECT_CPU) is a manual change through the sysfs interface.
The comment was indeed rather meant to make explicit a "please go read the caller, carefully..." where, among other things, at least parts of the remarks you pointed out above are spelled out. But I won't be the one stingy with comments! ;-) Will apply, thanks for the suggestion.
Quoted 57 lines
Quoted 39 lines
drivers/hv/channel_mgmt.c +39
-0+void vmbus_balance_vp_indexes_at_cpuhp (unsigned int cpu,bool add) +{ +struct vmbus_channel *chn, *sc; +cpumask_var_t cpu_msk; + +lockdep_assert_cpus_held (); +lockdep_assert_held (&vmbus_connection.channel_mutex); + +WARN_ON (!cpumask_test_cpu (cpu, cpu_online_mask)); + +/* See the header comment for vmbus_send_modifychannel(). */ +if (vmbus_proto_version <VERSION_WIN10_V4_1 ) +return ; + +if (!alloc_cpumask_var (&cpu_msk,GFP_KERNEL )) +return ; + +reset_chn_counts (&vmbus_connection.chn_cnt); + +list_for_each_entry (chn, &vmbus_connection.chn_list, listentry) { +struct hv_device *dev = chn->device_obj; + +/* +* The device may not have been allocated/assigned to +* the primary channel yet; if so, do not balance the +* channels associated to this device. If dev != NULL, +* the synchronization on channel_mutex ensures that +* the device's chn_cnt has been (properly) allocated +* *and* initialized, cf. vmbus_add_channel_work(). +*/ +if (dev ==NULL ) +continue ; + +/* +* By design, non-"perf" channels do not take part in +* the balancing process. +* +* The user may have assigned some non-"perf" channel +* to this CPU. To satisfy the user's request to hot drivers/hv/channel_mgmt.c static void vmbus_process_offer(struct vmbus_channel *newchannel) · line 866
Quoted 10 lines
drivers/hv/channel_mgmt.c +10
-0+* remove the CPU, we will re-assign such channels to +* the connect CPU; cf. balance_vp_index(). +*/ +if (!hv_is_perf_channel (chn)) { +if (add) +continue ; +/* +* Assume that the non-"perf" channel has no +* sub-channels. +*/ The "if" statement below could use a bit further explanation to help the reader. :-) If this non-perf channel is assigned to some CPU other than the one we are hot-removing, then we execute the "continue" statement and leave its target CPU unchanged. But if it is assigned to the CPU we are hot removing, then we need to move the channel to some other CPU.
Quoted 3 lines
I'm also not clear on how the above comment about having no sub-channels is relevant. Maybe a bit more explanation would help.
That comment was meant to simply stress the fact that we can "continue" without looping over/checking the sub-channels, because we know that the channel in question has no sub-channels. ;-) (BTW, for the very same reason, we have no "if (!hv_is_perf_channel(sc))..." in the loop below.)
So, maybe something like:
/*
* If this non-"perf" channel is assigned to some...
* [your text/explanation above].
*/
if (chn->target_cpu != cpu) {
/*
* Non-"perf" channels have no sub-channels:
* no need to loop over sc_list.
*/
continue;
}??
Quoted 32 lines
Quoted 32 lines
drivers/hv/channel_mgmt.c +28
-0+if (chn->target_cpu != cpu) +continue ; + }else { +reset_chn_counts (&dev->chn_cnt); + } + +cpumask_copy (cpu_msk, cpu_online_mask); +if (!add) +cpumask_clear_cpu (cpu, cpu_msk); +balance_vp_index (chn, dev, cpu_msk); + +list_for_each_entry (sc, &chn->sc_list, sc_list) { +cpumask_copy (cpu_msk, cpu_online_mask); +if (!add) +cpumask_clear_cpu (cpu, cpu_msk); +balance_vp_index (sc, dev, cpu_msk); + } + } + +free_cpumask_var (cpu_msk); +}int hv_synic_init (unsigned int cpu) { +/* +* The CPU has been hot added: try to re-balance the channels +* across the online CPUs (including "this" CPU), provided that +* the VMBus is connected; in part., avoid the re-balancing at +* the very first CPU initialization. +* +* See also inline comments in hv_synic_cleanup().
Quoted 8 lines
drivers/hv/hv.c void hv_synic_enable_regs(unsigned int cpu) · line 211
Quoted 4 lines
drivers/hv/hv.c +4
-0+*/ +if (vmbus_connection.conn_state ==CONNECTED ) { +mutex_lock (&vmbus_connection.channel_mutex); +vmbus_balance_vp_indexes_at_cpuhp (cpu, true);Does the target CPU have its bit in
cpu_online_maskset at the time this is executed?reset_chn_counts()does afor_each_online_cpu()loop, and we want to make sure the count for this CPU gets reset to zero.
Yes, it does: We're here (in CPUHP_AP_ONLINE_DYN) near the end of the "CPU-online" process; IIUC, the bit in question is set earlier in this process/before the CPU reaches CPUHP_AP_ONLINE_IDLE.
So, yeah, I think I would agree in saying that that:
WARN_ON(!cpumask_test_cpu(cpu, cpu_online_mask));
(in vmbus_balance_vp_indexes_at_cpuhp()) is more about "paranoid" (for future changes/uses) than anything else. I'm keeping that for now.
Quoted 9 lines
drivers/hv/vmbus_drv.c static void vmbus_device_release(struct device *device) · line 985
Quoted 7 lines
drivers/hv/vmbus_drv.c +3
-0@@ -980,6 +980,9 @@ static void vmbus_device_release(struct device *device)mutex_lock (&vmbus_connection.channel_mutex);hv_process_channel_removal (channel);mutex_unlock (&vmbus_connection.channel_mutex); + +if (hv_is_perf_channel (channel)) +free_chn_counts (&hv_dev->chn_cnt);Again, can drop the 'if' statement.
As mentioned above, either way works for me. Will drop it for the next version.
Thanks,
Andrea
RFC PATCH 2/2 Drivers: hv: vmbus: Re-balance channel interrupts across CPUs at device hotplug
In reply to Andrea Parri (Microsoft)Device hot removals and additions (closure and opening) also present a valid opportunity for (re-)balancing the channel interrupts across the available CPUs. Current code balances interrupts as they are offered, but it does not modify the interrupts-to-CPUs assignment if interrupts are "rescinded"/removed from the system. Moreover, in case of channel /device offers, the interrupt assignments are performed *one at a time* and without full visibility into other channels/devices; the result is that, globally, interrupts are sometimes not evenly spread across CPUs.
Introduce the vmbus_balance_vp_indexes_at_devhp() primitive to balance the channel interrupts across online CPUs at device hotplug operations. The primitive triggers a "full" balancing of the interrupts across the online CPUs and NUMA nodes. The balancing process at device addition/ opening is deferred to a delayed work, to give channels of such device more chances to be opened. As in vmbus_balance_vp_indexes_at_cpuhp(), the balancing is applied to "performance" channels only, and it relies on the (new) capability to re-assign a channel interrupt.
--- drivers/hv/channel.c | 43 ++++++++++++++++++++++++++++++++ drivers/hv/channel_mgmt.c | 52 ++++++++++++++++++++++++++++++++++++--- drivers/hv/connection.c | 9 +++++++ drivers/hv/hyperv_vmbus.h | 6 +++++ include/linux/hyperv.h | 6 +++++ 5 files changed, 112 insertions(+), 4 deletions(-)
drivers/hv/channel.c +43 -0
@@ -11,6 +11,7 @@#include <linux/kernel.h> #include <linux/sched.h> #include <linux/wait.h> +#include <linux/cpu.h> #include <linux/mm.h> #include <linux/slab.h> #include <linux/module.h>
@@ -112,6 +113,19 @@ int vmbus_alloc_ring(struct vmbus_channel *newchannel, }EXPORT_SYMBOL_GPL (vmbus_alloc_ring); +static void vmbus_add_device_work (struct work_struct *work) +{ +struct hv_device *hv_dev = + container_of((struct delayed_work *)work, struct hv_device, + add_device_work); + +cpus_read_lock (); +mutex_lock (&vmbus_connection.channel_mutex); +vmbus_balance_vp_indexes_at_devhp (hv_dev, true); +mutex_unlock (&vmbus_connection.channel_mutex); +cpus_read_unlock (); +} +static int __vmbus_open (struct vmbus_channel *newchannel,void *userdata,u32 userdatalen,void (*onchannelcallback)(void *context),void *context)
@@ -217,6 +231,24 @@ static int __vmbus_open(struct vmbus_channel *newchannel, } newchannel->state =CHANNEL_OPENED_STATE ; +/* +* If this is a primary channel and a "perf" channel, queue the +* add_device_work to balance the channels of the device across +* the online CPUs; the queueing delay should be greater than +* the "typical" time required to open such channels, since the +* balancing will only apply to *open* channels. The closure +* path will wait for our work to complete and start a new re- +* balancing, cf. vmbus_disconnect_ring(). +*/ +if (newchannel->primary_channel ==NULL && +hv_is_perf_channel (newchannel)) { +struct delayed_work *dwork = + &newchannel->device_obj->add_device_work; + +INIT_DELAYED_WORK (dwork, vmbus_add_device_work); +queue_delayed_work (vmbus_connection.handle_dev_wq, dwork, +8 *HZ ); + }kfree (open_info);return 0 ;
@@ -750,6 +782,8 @@ static int vmbus_close_internal(struct vmbus_channel *channel)/* disconnect ring - close all channels */ int vmbus_disconnect_ring (struct vmbus_channel *channel) { +struct hv_device *hv_dev = channel->device_obj; +bool perf_chn =hv_is_perf_channel (channel);struct vmbus_channel *cur_channel, *tmp;int ret;
@@ -773,9 +807,18 @@ int vmbus_disconnect_ring(struct vmbus_channel *channel)/* * Now close the primary. */ + +/* See inline comment in __vmbus_open(). */ +if (perf_chn) +cancel_delayed_work_sync (&hv_dev->add_device_work); + +cpus_read_lock ();mutex_lock (&vmbus_connection.channel_mutex); +if (perf_chn) +vmbus_balance_vp_indexes_at_devhp (hv_dev, false); ret =vmbus_close_internal (channel);mutex_unlock (&vmbus_connection.channel_mutex); +cpus_read_unlock ();return ret; }
drivers/hv/channel_mgmt.c +48 -4
64 lines not on this page · raw message
drivers/hv/connection.c +9 -0
@@ -179,6 +179,12 @@ int vmbus_connect(void) goto cleanup; } + vmbus_connection.handle_dev_wq =create_workqueue ("hv_device" ); +if (!vmbus_connection.handle_dev_wq) { + ret = -ENOMEM ; + goto cleanup; + } +INIT_LIST_HEAD (&vmbus_connection.chn_msg_list);spin_lock_init (&vmbus_connection.channelmsg_lock);
@@ -281,6 +287,9 @@ void vmbus_disconnect(void)*/ vmbus_initiate_unload (false); +if (vmbus_connection.handle_dev_wq) +destroy_workqueue (vmbus_connection.handle_dev_wq); +if (vmbus_connection.handle_sub_chan_wq)destroy_workqueue (vmbus_connection.handle_sub_chan_wq);
drivers/hv/hyperv_vmbus.h +6 -0
@@ -272,6 +272,11 @@ struct vmbus_connection {struct workqueue_struct *work_queue;struct workqueue_struct *handle_primary_chan_wq;struct workqueue_struct *handle_sub_chan_wq; +/* +* Handling device hotplug/addition work, cf. add_device_work from +* struct hv_device. +*/ +struct workqueue_struct *handle_dev_wq;/* * The number of sub-channels and hv_sock channels that should be
@@ -358,6 +363,7 @@ struct vmbus_channel *relid2channel(u32 relid);void vmbus_free_channels (void ); +void vmbus_balance_vp_indexes_at_devhp (struct hv_device *hv_dev,bool add);void vmbus_balance_vp_indexes_at_cpuhp (unsigned int cpu,bool add);/* Connection interface */
include/linux/hyperv.h +6 -0
@@ -1212,6 +1212,12 @@ struct hv_device {/* place holder to keep track of the dir for hv device in debugfs */ struct dentry *debug_dir; + +/* +* Balance the channel interrupts across the online CPUs at device +* hotplug/addition. +*/ +struct delayed_work add_device_work; };
Signature · 1 line
2.25.1
Quoted 7 lines
These changes originated from (and address /try to resolve) two known limitations of the current interrupts-to-CPUs mapping scheme, that is,
(1) the "static" nature of this mapping scheme (that, e.g., can end up preventing the hot removal of certain CPUs) and (2) the lack of global visibility in such scheme (where devices/channels are mapped only "one at a time"/as they are offered, with the end result that globally the various interrupts are not always evenly spread across CPUs).
One thing I didn't mention here is that, well, we probably don't want any of this when CONFIG_SMP=n: clearly, I didn't pay much attention to (optimize) this config in this RFC (FWIW, neither seems to do the current mapping scheme) but I'll look into this if there is interest on this regard (once back from vacation of course ;-) and, probably, at the cost of adding some #ifdeffery to this RFC).
Thanks,
Andrea