1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2009, Microsoft Corporation. 4 * 5 * Authors: 6 * Haiyang Zhang <haiyangz@microsoft.com> 7 * Hank Janssen <hjanssen@microsoft.com> 8 */ 9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 10 11 #include <linux/kernel.h> 12 #include <linux/mm.h> 13 #include <linux/slab.h> 14 #include <linux/vmalloc.h> 15 #include <linux/hyperv.h> 16 #include <linux/version.h> 17 #include <linux/random.h> 18 #include <linux/clockchips.h> 19 #include <clocksource/hyperv_timer.h> 20 #include <asm/mshyperv.h> 21 #include "hyperv_vmbus.h" 22 23 /* The one and only */ 24 struct hv_context hv_context; 25 26 /* 27 * hv_init - Main initialization routine. 28 * 29 * This routine must be called before any other routines in here are called 30 */ 31 int hv_init(void) 32 { 33 hv_context.cpu_context = alloc_percpu(struct hv_per_cpu_context); 34 if (!hv_context.cpu_context) 35 return -ENOMEM; 36 return 0; 37 } 38 39 /* 40 * hv_post_message - Post a message using the hypervisor message IPC. 41 * 42 * This involves a hypercall. 43 */ 44 int hv_post_message(union hv_connection_id connection_id, 45 enum hv_message_type message_type, 46 void *payload, size_t payload_size) 47 { 48 struct hv_input_post_message *aligned_msg; 49 struct hv_per_cpu_context *hv_cpu; 50 u64 status; 51 52 if (payload_size > HV_MESSAGE_PAYLOAD_BYTE_COUNT) 53 return -EMSGSIZE; 54 55 hv_cpu = get_cpu_ptr(hv_context.cpu_context); 56 aligned_msg = hv_cpu->post_msg_page; 57 aligned_msg->connectionid = connection_id; 58 aligned_msg->reserved = 0; 59 aligned_msg->message_type = message_type; 60 aligned_msg->payload_size = payload_size; 61 memcpy((void *)aligned_msg->payload, payload, payload_size); 62 63 status = hv_do_hypercall(HVCALL_POST_MESSAGE, aligned_msg, NULL); 64 65 /* Preemption must remain disabled until after the hypercall 66 * so some other thread can't get scheduled onto this cpu and 67 * corrupt the per-cpu post_msg_page 68 */ 69 put_cpu_ptr(hv_cpu); 70 71 return status & 0xFFFF; 72 } 73 74 int hv_synic_alloc(void) 75 { 76 int cpu; 77 struct hv_per_cpu_context *hv_cpu; 78 79 /* 80 * First, zero all per-cpu memory areas so hv_synic_free() can 81 * detect what memory has been allocated and cleanup properly 82 * after any failures. 83 */ 84 for_each_present_cpu(cpu) { 85 hv_cpu = per_cpu_ptr(hv_context.cpu_context, cpu); 86 memset(hv_cpu, 0, sizeof(*hv_cpu)); 87 } 88 89 hv_context.hv_numa_map = kcalloc(nr_node_ids, sizeof(struct cpumask), 90 GFP_KERNEL); 91 if (hv_context.hv_numa_map == NULL) { 92 pr_err("Unable to allocate NUMA map\n"); 93 goto err; 94 } 95 96 for_each_present_cpu(cpu) { 97 hv_cpu = per_cpu_ptr(hv_context.cpu_context, cpu); 98 99 tasklet_init(&hv_cpu->msg_dpc, 100 vmbus_on_msg_dpc, (unsigned long) hv_cpu); 101 102 hv_cpu->synic_message_page = 103 (void *)get_zeroed_page(GFP_ATOMIC); 104 if (hv_cpu->synic_message_page == NULL) { 105 pr_err("Unable to allocate SYNIC message page\n"); 106 goto err; 107 } 108 109 hv_cpu->synic_event_page = (void *)get_zeroed_page(GFP_ATOMIC); 110 if (hv_cpu->synic_event_page == NULL) { 111 pr_err("Unable to allocate SYNIC event page\n"); 112 goto err; 113 } 114 115 hv_cpu->post_msg_page = (void *)get_zeroed_page(GFP_ATOMIC); 116 if (hv_cpu->post_msg_page == NULL) { 117 pr_err("Unable to allocate post msg page\n"); 118 goto err; 119 } 120 121 INIT_LIST_HEAD(&hv_cpu->chan_list); 122 } 123 124 return 0; 125 err: 126 /* 127 * Any memory allocations that succeeded will be freed when 128 * the caller cleans up by calling hv_synic_free() 129 */ 130 return -ENOMEM; 131 } 132 133 134 void hv_synic_free(void) 135 { 136 int cpu; 137 138 for_each_present_cpu(cpu) { 139 struct hv_per_cpu_context *hv_cpu 140 = per_cpu_ptr(hv_context.cpu_context, cpu); 141 142 free_page((unsigned long)hv_cpu->synic_event_page); 143 free_page((unsigned long)hv_cpu->synic_message_page); 144 free_page((unsigned long)hv_cpu->post_msg_page); 145 } 146 147 kfree(hv_context.hv_numa_map); 148 } 149 150 /* 151 * hv_synic_init - Initialize the Synthetic Interrupt Controller. 152 * 153 * If it is already initialized by another entity (ie x2v shim), we need to 154 * retrieve the initialized message and event pages. Otherwise, we create and 155 * initialize the message and event pages. 156 */ 157 void hv_synic_enable_regs(unsigned int cpu) 158 { 159 struct hv_per_cpu_context *hv_cpu 160 = per_cpu_ptr(hv_context.cpu_context, cpu); 161 union hv_synic_simp simp; 162 union hv_synic_siefp siefp; 163 union hv_synic_sint shared_sint; 164 union hv_synic_scontrol sctrl; 165 166 /* Setup the Synic's message page */ 167 hv_get_simp(simp.as_uint64); 168 simp.simp_enabled = 1; 169 simp.base_simp_gpa = virt_to_phys(hv_cpu->synic_message_page) 170 >> PAGE_SHIFT; 171 172 hv_set_simp(simp.as_uint64); 173 174 /* Setup the Synic's event page */ 175 hv_get_siefp(siefp.as_uint64); 176 siefp.siefp_enabled = 1; 177 siefp.base_siefp_gpa = virt_to_phys(hv_cpu->synic_event_page) 178 >> PAGE_SHIFT; 179 180 hv_set_siefp(siefp.as_uint64); 181 182 /* Setup the shared SINT. */ 183 hv_get_synint_state(VMBUS_MESSAGE_SINT, shared_sint.as_uint64); 184 185 shared_sint.vector = HYPERVISOR_CALLBACK_VECTOR; 186 shared_sint.masked = false; 187 if (ms_hyperv.hints & HV_DEPRECATING_AEOI_RECOMMENDED) 188 shared_sint.auto_eoi = false; 189 else 190 shared_sint.auto_eoi = true; 191 192 hv_set_synint_state(VMBUS_MESSAGE_SINT, shared_sint.as_uint64); 193 194 /* Enable the global synic bit */ 195 hv_get_synic_state(sctrl.as_uint64); 196 sctrl.enable = 1; 197 198 hv_set_synic_state(sctrl.as_uint64); 199 } 200 201 int hv_synic_init(unsigned int cpu) 202 { 203 hv_synic_enable_regs(cpu); 204 205 hv_stimer_init(cpu); 206 207 return 0; 208 } 209 210 /* 211 * hv_synic_cleanup - Cleanup routine for hv_synic_init(). 212 */ 213 void hv_synic_disable_regs(unsigned int cpu) 214 { 215 union hv_synic_sint shared_sint; 216 union hv_synic_simp simp; 217 union hv_synic_siefp siefp; 218 union hv_synic_scontrol sctrl; 219 220 hv_get_synint_state(VMBUS_MESSAGE_SINT, shared_sint.as_uint64); 221 222 shared_sint.masked = 1; 223 224 /* Need to correctly cleanup in the case of SMP!!! */ 225 /* Disable the interrupt */ 226 hv_set_synint_state(VMBUS_MESSAGE_SINT, shared_sint.as_uint64); 227 228 hv_get_simp(simp.as_uint64); 229 simp.simp_enabled = 0; 230 simp.base_simp_gpa = 0; 231 232 hv_set_simp(simp.as_uint64); 233 234 hv_get_siefp(siefp.as_uint64); 235 siefp.siefp_enabled = 0; 236 siefp.base_siefp_gpa = 0; 237 238 hv_set_siefp(siefp.as_uint64); 239 240 /* Disable the global synic bit */ 241 hv_get_synic_state(sctrl.as_uint64); 242 sctrl.enable = 0; 243 hv_set_synic_state(sctrl.as_uint64); 244 } 245 246 int hv_synic_cleanup(unsigned int cpu) 247 { 248 struct vmbus_channel *channel, *sc; 249 bool channel_found = false; 250 unsigned long flags; 251 252 /* 253 * Search for channels which are bound to the CPU we're about to 254 * cleanup. In case we find one and vmbus is still connected we need to 255 * fail, this will effectively prevent CPU offlining. There is no way 256 * we can re-bind channels to different CPUs for now. 257 */ 258 mutex_lock(&vmbus_connection.channel_mutex); 259 list_for_each_entry(channel, &vmbus_connection.chn_list, listentry) { 260 if (channel->target_cpu == cpu) { 261 channel_found = true; 262 break; 263 } 264 spin_lock_irqsave(&channel->lock, flags); 265 list_for_each_entry(sc, &channel->sc_list, sc_list) { 266 if (sc->target_cpu == cpu) { 267 channel_found = true; 268 break; 269 } 270 } 271 spin_unlock_irqrestore(&channel->lock, flags); 272 if (channel_found) 273 break; 274 } 275 mutex_unlock(&vmbus_connection.channel_mutex); 276 277 if (channel_found && vmbus_connection.conn_state == CONNECTED) 278 return -EBUSY; 279 280 hv_stimer_cleanup(cpu); 281 282 hv_synic_disable_regs(cpu); 283 284 return 0; 285 } 286