Skip to content

Commit

Permalink
vmbus: put related per-cpu variable together
Browse files Browse the repository at this point in the history 
The hv_context structure had several arrays which were per-cpu
and was allocating small structures (tasklet_struct). Instead use
a single per-cpu array.

Signed-off-by: Stephen Hemminger <[email protected]>
Signed-off-by: K. Y. Srinivasan <[email protected]>
Signed-off-by: Greg Kroah-Hartman <[email protected]>
  • Loading branch information
@shemminger @gregkh
shemminger authored and gregkh committed Feb 14, 2017
1 parent 51c6ce2 commit 37cdd99
Show file tree
Hide file tree
Showing 5 changed files with 143 additions and 134 deletions.
35 changes: 22 additions & 13 deletions drivers/hv/channel_mgmt.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -353,9 +353,10 @@ static void free_channel(struct vmbus_channel *channel)
static void percpu_channel_enq(void *arg)
{
struct vmbus_channel *channel = arg;
int cpu = smp_processor_id();
struct hv_per_cpu_context *hv_cpu
= this_cpu_ptr(hv_context.cpu_context);

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

static void percpu_channel_deq(void *arg)
Expand All @@ -379,19 +380,21 @@ static void vmbus_release_relid(u32 relid)

void hv_event_tasklet_disable(struct vmbus_channel *channel)
{
struct tasklet_struct *tasklet;
tasklet = hv_context.event_dpc[channel->target_cpu];
tasklet_disable(tasklet);
struct hv_per_cpu_context *hv_cpu;

hv_cpu = per_cpu_ptr(hv_context.cpu_context, channel->target_cpu);
tasklet_disable(&hv_cpu->event_dpc);
}

void hv_event_tasklet_enable(struct vmbus_channel *channel)
{
struct tasklet_struct *tasklet;
tasklet = hv_context.event_dpc[channel->target_cpu];
tasklet_enable(tasklet);
struct hv_per_cpu_context *hv_cpu;

hv_cpu = per_cpu_ptr(hv_context.cpu_context, channel->target_cpu);
tasklet_enable(&hv_cpu->event_dpc);

/* In case there is any pending event */
tasklet_schedule(tasklet);
tasklet_schedule(&hv_cpu->event_dpc);
}

void hv_process_channel_removal(struct vmbus_channel *channel, u32 relid)
Expand Down Expand Up @@ -726,9 +729,12 @@ static void vmbus_wait_for_unload(void)
break;

for_each_online_cpu(cpu) {
page_addr = hv_context.synic_message_page[cpu];
msg = (struct hv_message *)page_addr +
VMBUS_MESSAGE_SINT;
struct hv_per_cpu_context *hv_cpu
= per_cpu_ptr(hv_context.cpu_context, cpu);

page_addr = hv_cpu->synic_message_page;
msg = (struct hv_message *)page_addr
+ VMBUS_MESSAGE_SINT;

message_type = READ_ONCE(msg->header.message_type);
if (message_type == HVMSG_NONE)
Expand All @@ -752,7 +758,10 @@ static void vmbus_wait_for_unload(void)
* messages after we reconnect.
*/
for_each_online_cpu(cpu) {
page_addr = hv_context.synic_message_page[cpu];
struct hv_per_cpu_context *hv_cpu
= per_cpu_ptr(hv_context.cpu_context, cpu);

page_addr = hv_cpu->synic_message_page;
msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
msg->header.message_type = HVMSG_NONE;
}
Expand Down
20 changes: 9 additions & 11 deletions drivers/hv/connection.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -93,12 +93,10 @@ static int vmbus_negotiate_version(struct vmbus_channel_msginfo *msginfo,
* all the CPUs. This is needed for kexec to work correctly where
* the CPU attempting to connect may not be CPU 0.
*/
if (version >= VERSION_WIN8_1) {
msg->target_vcpu = hv_context.vp_index[get_cpu()];
put_cpu();
} else {
if (version >= VERSION_WIN8_1)
msg->target_vcpu = hv_context.vp_index[smp_processor_id()];
else
msg->target_vcpu = 0;
}

/*
* Add to list before we send the request since we may
Expand Down Expand Up @@ -269,12 +267,12 @@ void vmbus_disconnect(void)
*/
static struct vmbus_channel *pcpu_relid2channel(u32 relid)
{
struct hv_per_cpu_context *hv_cpu
= this_cpu_ptr(hv_context.cpu_context);
struct vmbus_channel *found_channel = NULL;
struct vmbus_channel *channel;
struct vmbus_channel *found_channel = NULL;
int cpu = smp_processor_id();
struct list_head *pcpu_head = &hv_context.percpu_list[cpu];

list_for_each_entry(channel, pcpu_head, percpu_list) {
list_for_each_entry(channel, &hv_cpu->chan_list, percpu_list) {
if (channel->offermsg.child_relid == relid) {
found_channel = channel;
break;
Expand Down Expand Up @@ -379,6 +377,7 @@ static void process_chn_event(u32 relid)
*/
void vmbus_on_event(unsigned long data)
{
struct hv_per_cpu_context *hv_cpu = (void *)data;
unsigned long *recv_int_page;
u32 maxbits, relid;

Expand All @@ -391,8 +390,7 @@ void vmbus_on_event(unsigned long data)
* can be directly checked to get the id of the channel
* that has the interrupt pending.
*/
int cpu = smp_processor_id();
void *page_addr = hv_context.synic_event_page[cpu];
void *page_addr = hv_cpu->synic_event_page;
union hv_synic_event_flags *event
= (union hv_synic_event_flags *)page_addr +
VMBUS_MESSAGE_SINT;
Expand Down
130 changes: 57 additions & 73 deletions drivers/hv/hv.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -49,24 +49,13 @@ struct hv_context hv_context = {
*/
int hv_init(void)
{

memset(hv_context.synic_event_page, 0, sizeof(void *) * NR_CPUS);
memset(hv_context.synic_message_page, 0,
sizeof(void *) * NR_CPUS);
memset(hv_context.post_msg_page, 0,
sizeof(void *) * NR_CPUS);
memset(hv_context.vp_index, 0,
sizeof(int) * NR_CPUS);
memset(hv_context.event_dpc, 0,
sizeof(void *) * NR_CPUS);
memset(hv_context.msg_dpc, 0,
sizeof(void *) * NR_CPUS);
memset(hv_context.clk_evt, 0,
sizeof(void *) * NR_CPUS);

if (!hv_is_hypercall_page_setup())
return -ENOTSUPP;

hv_context.cpu_context = alloc_percpu(struct hv_per_cpu_context);
if (!hv_context.cpu_context)
return -ENOMEM;

return 0;
}

Expand All @@ -79,25 +68,24 @@ int hv_post_message(union hv_connection_id connection_id,
enum hv_message_type message_type,
void *payload, size_t payload_size)
{

struct hv_input_post_message *aligned_msg;
struct hv_per_cpu_context *hv_cpu;
u64 status;

if (payload_size > HV_MESSAGE_PAYLOAD_BYTE_COUNT)
return -EMSGSIZE;

aligned_msg = (struct hv_input_post_message *)
hv_context.post_msg_page[get_cpu()];

hv_cpu = get_cpu_ptr(hv_context.cpu_context);
aligned_msg = hv_cpu->post_msg_page;
aligned_msg->connectionid = connection_id;
aligned_msg->reserved = 0;
aligned_msg->message_type = message_type;
aligned_msg->payload_size = payload_size;
memcpy((void *)aligned_msg->payload, payload, payload_size);
put_cpu_ptr(hv_cpu);

status = hv_do_hypercall(HVCALL_POST_MESSAGE, aligned_msg, NULL);

put_cpu();
return status & 0xFFFF;
}

Expand Down Expand Up @@ -154,8 +142,6 @@ static void hv_init_clockevent_device(struct clock_event_device *dev, int cpu)

int hv_synic_alloc(void)
{
size_t size = sizeof(struct tasklet_struct);
size_t ced_size = sizeof(struct clock_event_device);
int cpu;

hv_context.hv_numa_map = kzalloc(sizeof(struct cpumask) * nr_node_ids,
Expand All @@ -166,80 +152,68 @@ int hv_synic_alloc(void)
}

for_each_present_cpu(cpu) {
hv_context.event_dpc[cpu] = kmalloc(size, GFP_ATOMIC);
if (hv_context.event_dpc[cpu] == NULL) {
pr_err("Unable to allocate event dpc\n");
goto err;
}
tasklet_init(hv_context.event_dpc[cpu], vmbus_on_event, cpu);

hv_context.msg_dpc[cpu] = kmalloc(size, GFP_ATOMIC);
if (hv_context.msg_dpc[cpu] == NULL) {
pr_err("Unable to allocate event dpc\n");
goto err;
}
tasklet_init(hv_context.msg_dpc[cpu], vmbus_on_msg_dpc, cpu);

hv_context.clk_evt[cpu] = kzalloc(ced_size, GFP_ATOMIC);
if (hv_context.clk_evt[cpu] == NULL) {
struct hv_per_cpu_context *hv_cpu
= per_cpu_ptr(hv_context.cpu_context, cpu);

memset(hv_cpu, 0, sizeof(*hv_cpu));
tasklet_init(&hv_cpu->event_dpc,
vmbus_on_event, (unsigned long) hv_cpu);
tasklet_init(&hv_cpu->msg_dpc,
vmbus_on_msg_dpc, (unsigned long) hv_cpu);

hv_cpu->clk_evt = kzalloc(sizeof(struct clock_event_device),
GFP_KERNEL);
if (hv_cpu->clk_evt == NULL) {
pr_err("Unable to allocate clock event device\n");
goto err;
}
hv_init_clockevent_device(hv_cpu->clk_evt, cpu);

hv_init_clockevent_device(hv_context.clk_evt[cpu], cpu);

hv_context.synic_message_page[cpu] =
hv_cpu->synic_message_page =
(void *)get_zeroed_page(GFP_ATOMIC);

if (hv_context.synic_message_page[cpu] == NULL) {
if (hv_cpu->synic_message_page == NULL) {
pr_err("Unable to allocate SYNIC message page\n");
goto err;
}

hv_context.synic_event_page[cpu] =
(void *)get_zeroed_page(GFP_ATOMIC);

if (hv_context.synic_event_page[cpu] == NULL) {
hv_cpu->synic_event_page = (void *)get_zeroed_page(GFP_ATOMIC);
if (hv_cpu->synic_event_page == NULL) {
pr_err("Unable to allocate SYNIC event page\n");
goto err;
}

hv_context.post_msg_page[cpu] =
(void *)get_zeroed_page(GFP_ATOMIC);

if (hv_context.post_msg_page[cpu] == NULL) {
hv_cpu->post_msg_page = (void *)get_zeroed_page(GFP_ATOMIC);
if (hv_cpu->post_msg_page == NULL) {
pr_err("Unable to allocate post msg page\n");
goto err;
}

INIT_LIST_HEAD(&hv_context.percpu_list[cpu]);
INIT_LIST_HEAD(&hv_cpu->chan_list);
}

return 0;
err:
return -ENOMEM;
}

static void hv_synic_free_cpu(int cpu)
{
kfree(hv_context.event_dpc[cpu]);
kfree(hv_context.msg_dpc[cpu]);
kfree(hv_context.clk_evt[cpu]);
if (hv_context.synic_event_page[cpu])
free_page((unsigned long)hv_context.synic_event_page[cpu]);
if (hv_context.synic_message_page[cpu])
free_page((unsigned long)hv_context.synic_message_page[cpu]);
if (hv_context.post_msg_page[cpu])
free_page((unsigned long)hv_context.post_msg_page[cpu]);
}

void hv_synic_free(void)
{
int cpu;

for_each_present_cpu(cpu) {
struct hv_per_cpu_context *hv_cpu
= per_cpu_ptr(hv_context.cpu_context, cpu);

if (hv_cpu->synic_event_page)
free_page((unsigned long)hv_cpu->synic_event_page);
if (hv_cpu->synic_message_page)
free_page((unsigned long)hv_cpu->synic_message_page);
if (hv_cpu->post_msg_page)
free_page((unsigned long)hv_cpu->post_msg_page);
}

kfree(hv_context.hv_numa_map);
for_each_present_cpu(cpu)
hv_synic_free_cpu(cpu);
}

/*
Expand All @@ -251,6 +225,8 @@ void hv_synic_free(void)
*/
int hv_synic_init(unsigned int cpu)
{
struct hv_per_cpu_context *hv_cpu
= per_cpu_ptr(hv_context.cpu_context, cpu);
union hv_synic_simp simp;
union hv_synic_siefp siefp;
union hv_synic_sint shared_sint;
Expand All @@ -260,15 +236,15 @@ int hv_synic_init(unsigned int cpu)
/* Setup the Synic's message page */
hv_get_simp(simp.as_uint64);
simp.simp_enabled = 1;
simp.base_simp_gpa = virt_to_phys(hv_context.synic_message_page[cpu])
simp.base_simp_gpa = virt_to_phys(hv_cpu->synic_message_page)
>> PAGE_SHIFT;

hv_set_simp(simp.as_uint64);

/* Setup the Synic's event page */
hv_get_siefp(siefp.as_uint64);
siefp.siefp_enabled = 1;
siefp.base_siefp_gpa = virt_to_phys(hv_context.synic_event_page[cpu])
siefp.base_siefp_gpa = virt_to_phys(hv_cpu->synic_event_page)
>> PAGE_SHIFT;

hv_set_siefp(siefp.as_uint64);
Expand Down Expand Up @@ -305,7 +281,7 @@ int hv_synic_init(unsigned int cpu)
* Register the per-cpu clockevent source.
*/
if (ms_hyperv.features & HV_X64_MSR_SYNTIMER_AVAILABLE)
clockevents_config_and_register(hv_context.clk_evt[cpu],
clockevents_config_and_register(hv_cpu->clk_evt,
HV_TIMER_FREQUENCY,
HV_MIN_DELTA_TICKS,
HV_MAX_MAX_DELTA_TICKS);
Expand All @@ -322,8 +298,12 @@ void hv_synic_clockevents_cleanup(void)
if (!(ms_hyperv.features & HV_X64_MSR_SYNTIMER_AVAILABLE))
return;

for_each_present_cpu(cpu)
clockevents_unbind_device(hv_context.clk_evt[cpu], cpu);
for_each_present_cpu(cpu) {
struct hv_per_cpu_context *hv_cpu
= per_cpu_ptr(hv_context.cpu_context, cpu);

clockevents_unbind_device(hv_cpu->clk_evt, cpu);
}
}

/*
Expand Down Expand Up @@ -372,8 +352,12 @@ int hv_synic_cleanup(unsigned int cpu)

/* Turn off clockevent device */
if (ms_hyperv.features & HV_X64_MSR_SYNTIMER_AVAILABLE) {
clockevents_unbind_device(hv_context.clk_evt[cpu], cpu);
hv_ce_shutdown(hv_context.clk_evt[cpu]);
struct hv_per_cpu_context *hv_cpu
= this_cpu_ptr(hv_context.cpu_context);

clockevents_unbind_device(hv_cpu->clk_evt, cpu);
hv_ce_shutdown(hv_cpu->clk_evt);
put_cpu_ptr(hv_cpu);
}

hv_get_synint_state(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT,
Expand Down
Loading

0 comments on commit 37cdd99

Please sign in to comment.