cregit-Linux how code gets into the kernel

Release 4.17 drivers/hv/hv.c

Directory: drivers/hv
/*
 * 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>
 *
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/hyperv.h>
#include <linux/version.h>
#include <linux/random.h>
#include <linux/clockchips.h>
#include <asm/mshyperv.h>
#include "hyperv_vmbus.h"

/* The one and only */

struct hv_context hv_context = {
	.synic_initialized	= false,
};

/*
 * If false, we're using the old mechanism for stimer0 interrupts
 * where it sends a VMbus message when it expires. The old
 * mechanism is used when running on older versions of Hyper-V
 * that don't support Direct Mode. While Hyper-V provides
 * four stimer's per CPU, Linux uses only stimer0.
 */

static bool direct_mode_enabled;

static int stimer0_irq;

static int stimer0_vector;


#define HV_TIMER_FREQUENCY (10 * 1000 * 1000) 
/* 100ns period */

#define HV_MAX_MAX_DELTA_TICKS 0xffffffff

#define HV_MIN_DELTA_TICKS 1

/*
 * hv_init - Main initialization routine.
 *
 * This routine must be called before any other routines in here are called
 */

int hv_init(void) { hv_context.cpu_context = alloc_percpu(struct hv_per_cpu_context); if (!hv_context.cpu_context) return -ENOMEM; direct_mode_enabled = ms_hyperv.misc_features & HV_X64_STIMER_DIRECT_MODE_AVAILABLE; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Hank Janssen1128.21%111.11%
Stephen Hemminger923.08%111.11%
K. Y. Srinivasan923.08%444.44%
Michael Kelley820.51%111.11%
Haiyang Zhang12.56%111.11%
Greg Kroah-Hartman12.56%111.11%
Total39100.00%9100.00%

/* * hv_post_message - Post a message using the hypervisor message IPC. * * This involves a hypercall. */
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; 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); status = hv_do_hypercall(HVCALL_POST_MESSAGE, aligned_msg, NULL); /* Preemption must remain disabled until after the hypercall * so some other thread can't get scheduled onto this cpu and * corrupt the per-cpu post_msg_page */ put_cpu_ptr(hv_cpu); return status & 0xFFFF; }

Contributors

PersonTokensPropCommitsCommitProp
Hank Janssen5243.70%16.67%
Haiyang Zhang2016.81%320.00%
Stephen Hemminger1512.61%16.67%
Greg Kroah-Hartman119.24%533.33%
K. Y. Srinivasan108.40%213.33%
Michael Kelley65.04%16.67%
Jake Oshins43.36%16.67%
Dan Carpenter10.84%16.67%
Total119100.00%15100.00%

/* * ISR for when stimer0 is operating in Direct Mode. Direct Mode * does not use VMbus or any VMbus messages, so process here and not * in the VMbus driver code. */
static void hv_stimer0_isr(void) { struct hv_per_cpu_context *hv_cpu; hv_cpu = this_cpu_ptr(hv_context.cpu_context); hv_cpu->clk_evt->event_handler(hv_cpu->clk_evt); add_interrupt_randomness(stimer0_vector, 0); }

Contributors

PersonTokensPropCommitsCommitProp
Michael Kelley40100.00%1100.00%
Total40100.00%1100.00%


static int hv_ce_set_next_event(unsigned long delta, struct clock_event_device *evt) { u64 current_tick; WARN_ON(!clockevent_state_oneshot(evt)); current_tick = hyperv_cs->read(NULL); current_tick += delta; hv_init_timer(HV_X64_MSR_STIMER0_COUNT, current_tick); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
K. Y. Srinivasan4590.00%360.00%
Viresh Kumar48.00%120.00%
Thomas Gleixner12.00%120.00%
Total50100.00%5100.00%


static int hv_ce_shutdown(struct clock_event_device *evt) { hv_init_timer(HV_X64_MSR_STIMER0_COUNT, 0); hv_init_timer_config(HV_X64_MSR_STIMER0_CONFIG, 0); if (direct_mode_enabled) hv_disable_stimer0_percpu_irq(stimer0_irq); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Viresh Kumar2567.57%125.00%
Michael Kelley924.32%125.00%
K. Y. Srinivasan38.11%250.00%
Total37100.00%4100.00%


static int hv_ce_set_oneshot(struct clock_event_device *evt) { union hv_timer_config timer_cfg; timer_cfg.as_uint64 = 0; timer_cfg.enable = 1; timer_cfg.auto_enable = 1; if (direct_mode_enabled) { /* * When it expires, the timer will directly interrupt * on the specified hardware vector/IRQ. */ timer_cfg.direct_mode = 1; timer_cfg.apic_vector = stimer0_vector; hv_enable_stimer0_percpu_irq(stimer0_irq); } else { /* * When it expires, the timer will generate a VMbus message, * to be handled by the normal VMbus interrupt handler. */ timer_cfg.direct_mode = 0; timer_cfg.sintx = VMBUS_MESSAGE_SINT; } hv_init_timer_config(HV_X64_MSR_STIMER0_CONFIG, timer_cfg.as_uint64); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
K. Y. Srinivasan4047.06%250.00%
Michael Kelley4047.06%125.00%
Viresh Kumar55.88%125.00%
Total85100.00%4100.00%


static void hv_init_clockevent_device(struct clock_event_device *dev, int cpu) { dev->name = "Hyper-V clockevent"; dev->features = CLOCK_EVT_FEAT_ONESHOT; dev->cpumask = cpumask_of(cpu); dev->rating = 1000; /* * Avoid settint dev->owner = THIS_MODULE deliberately as doing so will * result in clockevents_config_and_register() taking additional * references to the hv_vmbus module making it impossible to unload. */ dev->set_state_shutdown = hv_ce_shutdown; dev->set_state_oneshot = hv_ce_set_oneshot; dev->set_next_event = hv_ce_set_next_event; }

Contributors

PersonTokensPropCommitsCommitProp
K. Y. Srinivasan5185.00%133.33%
Viresh Kumar813.33%133.33%
Vitaly Kuznetsov11.67%133.33%
Total60100.00%3100.00%


int hv_synic_alloc(void) { int cpu; hv_context.hv_numa_map = kzalloc(sizeof(struct cpumask) * nr_node_ids, GFP_KERNEL); if (hv_context.hv_numa_map == NULL) { pr_err("Unable to allocate NUMA map\n"); goto err; } for_each_present_cpu(cpu) { 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->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_cpu->synic_message_page = (void *)get_zeroed_page(GFP_ATOMIC); if (hv_cpu->synic_message_page == NULL) { pr_err("Unable to allocate SYNIC message page\n"); goto err; } 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_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_cpu->chan_list); } if (direct_mode_enabled && hv_setup_stimer0_irq(&stimer0_irq, &stimer0_vector, hv_stimer0_isr)) goto err; return 0; err: return -ENOMEM; }

Contributors

PersonTokensPropCommitsCommitProp
K. Y. Srinivasan10539.77%533.33%
Stephen Hemminger5420.45%16.67%
Hank Janssen4416.67%213.33%
Michael Kelley186.82%16.67%
Jason (Hui) Wang176.44%16.67%
Greg Kroah-Hartman145.30%16.67%
Vitaly Kuznetsov62.27%213.33%
Haiyang Zhang51.89%16.67%
Jia-Ju Bai10.38%16.67%
Total264100.00%15100.00%


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); }

Contributors

PersonTokensPropCommitsCommitProp
Jason (Hui) Wang3236.36%114.29%
Stephen Hemminger2831.82%114.29%
K. Y. Srinivasan2730.68%457.14%
Felipe Pena11.14%114.29%
Total88100.00%7100.00%

/* * hv_synic_init - Initialize the Synthetic Interrupt Controller. * * If it is already initialized by another entity (ie x2v shim), we need to * retrieve the initialized message and event pages. Otherwise, we create and * initialize the message and event pages. */
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; union hv_synic_scontrol sctrl; /* Setup the Synic's message page */ hv_get_simp(simp.as_uint64); simp.simp_enabled = 1; 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_cpu->synic_event_page) >> PAGE_SHIFT; hv_set_siefp(siefp.as_uint64); /* Setup the shared SINT. */ hv_get_synint_state(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, shared_sint.as_uint64); shared_sint.vector = HYPERVISOR_CALLBACK_VECTOR; shared_sint.masked = false; if (ms_hyperv.hints & HV_X64_DEPRECATING_AEOI_RECOMMENDED) shared_sint.auto_eoi = false; else shared_sint.auto_eoi = true; hv_set_synint_state(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, shared_sint.as_uint64); /* Enable the global synic bit */ hv_get_synic_state(sctrl.as_uint64); sctrl.enable = 1; hv_set_synic_state(sctrl.as_uint64); hv_context.synic_initialized = true; /* * Register the per-cpu clockevent source. */ if (ms_hyperv.features & HV_X64_MSR_SYNTIMER_AVAILABLE) clockevents_config_and_register(hv_cpu->clk_evt, HV_TIMER_FREQUENCY, HV_MIN_DELTA_TICKS, HV_MAX_MAX_DELTA_TICKS); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Hank Janssen8539.53%15.26%
K. Y. Srinivasan4520.93%842.11%
Haiyang Zhang2511.63%315.79%
Stephen Hemminger209.30%15.26%
Jason (Hui) Wang209.30%15.26%
Greg Kroah-Hartman94.19%315.79%
Vitaly Kuznetsov73.26%15.26%
Bill Pemberton41.86%15.26%
Total215100.00%19100.00%

/* * hv_synic_clockevents_cleanup - Cleanup clockevent devices */
void hv_synic_clockevents_cleanup(void) { int cpu; if (!(ms_hyperv.features & HV_X64_MSR_SYNTIMER_AVAILABLE)) return; if (direct_mode_enabled) hv_remove_stimer0_irq(stimer0_irq); 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); } }

Contributors

PersonTokensPropCommitsCommitProp
Vitaly Kuznetsov3456.67%250.00%
Stephen Hemminger1728.33%125.00%
Michael Kelley915.00%125.00%
Total60100.00%4100.00%

/* * hv_synic_cleanup - Cleanup routine for hv_synic_init(). */
int hv_synic_cleanup(unsigned int cpu) { union hv_synic_sint shared_sint; union hv_synic_simp simp; union hv_synic_siefp siefp; union hv_synic_scontrol sctrl; struct vmbus_channel *channel, *sc; bool channel_found = false; unsigned long flags; if (!hv_context.synic_initialized) return -EFAULT; /* * 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 need to * fail, this will effectively prevent CPU offlining. There is no way * we can re-bind channels to different CPUs for now. */ 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; } mutex_unlock(&vmbus_connection.channel_mutex); if (channel_found && vmbus_connection.conn_state == CONNECTED) return -EBUSY; /* Turn off clockevent device */ if (ms_hyperv.features & HV_X64_MSR_SYNTIMER_AVAILABLE) { 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, shared_sint.as_uint64); shared_sint.masked = 1; /* Need to correctly cleanup in the case of SMP!!! */ /* Disable the interrupt */ hv_set_synint_state(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, shared_sint.as_uint64); hv_get_simp(simp.as_uint64); simp.simp_enabled = 0; simp.base_simp_gpa = 0; hv_set_simp(simp.as_uint64); hv_get_siefp(siefp.as_uint64); siefp.siefp_enabled = 0; siefp.base_siefp_gpa = 0; hv_set_siefp(siefp.as_uint64); /* Disable the global synic bit */ hv_get_synic_state(sctrl.as_uint64); sctrl.enable = 0; hv_set_synic_state(sctrl.as_uint64); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Vitaly Kuznetsov17456.31%525.00%
Hank Janssen7624.60%15.00%
Stephen Hemminger206.47%15.00%
Haiyang Zhang185.83%420.00%
Greg Kroah-Hartman113.56%315.00%
K. Y. Srinivasan82.59%420.00%
Bill Pemberton10.32%15.00%
Viresh Kumar10.32%15.00%
Total309100.00%20100.00%


Overall Contributors

PersonTokensPropCommitsCommitProp
K. Y. Srinivasan37025.55%2032.79%
Hank Janssen28319.54%23.28%
Vitaly Kuznetsov22315.40%711.48%
Stephen Hemminger16311.26%11.64%
Michael Kelley14510.01%23.28%
Haiyang Zhang745.11%46.56%
Jason (Hui) Wang694.77%11.64%
Greg Kroah-Hartman584.01%1422.95%
Viresh Kumar432.97%11.64%
Bill Pemberton80.55%23.28%
Jake Oshins40.28%11.64%
Tejun Heo30.21%11.64%
Felipe Pena10.07%11.64%
Dan Carpenter10.07%11.64%
Thomas Gleixner10.07%11.64%
Jia-Ju Bai10.07%11.64%
Joe Perches10.07%11.64%
Total1448100.00%61100.00%
Directory: drivers/hv
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.