arch/x86/hyperv/hv_proc.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/types.h>
   3 #include <linux/vmalloc.h>
   4 #include <linux/mm.h>
   5 #include <linux/clockchips.h>
   6 #include <linux/acpi.h>
   7 #include <linux/hyperv.h>
   8 #include <linux/slab.h>
   9 #include <linux/cpuhotplug.h>
  10 #include <linux/minmax.h>
  11 #include <asm/hypervisor.h>
  12 #include <asm/mshyperv.h>
  13 #include <asm/apic.h>
  14
  15 #include <asm/trace/hyperv.h>
  16
  17 /*
  18  * See struct hv_deposit_memory. The first u64 is partition ID, the rest
  19  * are GPAs.
  20  */
  21 #define HV_DEPOSIT_MAX (HV_HYP_PAGE_SIZE / sizeof(u64) - 1)
  22
  23 /* Deposits exact number of pages. Must be called with interrupts enabled.  */
  24 int hv_call_deposit_pages(int node, u64 partition_id, u32 num_pages)
  25 {
  26         struct page **pages, *page;
  27         int *counts;
  28         int num_allocations;
  29         int i, j, page_count;
  30         int order;
  31         u64 status;
  32         int ret;
  33         u64 base_pfn;
  34         struct hv_deposit_memory *input_page;
  35         unsigned long flags;
  36
  37         if (num_pages > HV_DEPOSIT_MAX)
  38                 return -E2BIG;
  39         if (!num_pages)
  40                 return 0;
  41
  42         /* One buffer for page pointers and counts */
  43         page = alloc_page(GFP_KERNEL);
  44         if (!page)
  45                 return -ENOMEM;
  46         pages = page_address(page);
  47
  48         counts = kcalloc(HV_DEPOSIT_MAX, sizeof(int), GFP_KERNEL);
  49         if (!counts) {
  50                 free_page((unsigned long)pages);
  51                 return -ENOMEM;
  52         }
  53
  54         /* Allocate all the pages before disabling interrupts */
  55         i = 0;
  56
  57         while (num_pages) {
  58                 /* Find highest order we can actually allocate */
  59                 order = 31 - __builtin_clz(num_pages);
  60
  61                 while (1) {
  62                         pages[i] = alloc_pages_node(node, GFP_KERNEL, order);
  63                         if (pages[i])
  64                                 break;
  65                         if (!order) {
  66                                 ret = -ENOMEM;
  67                                 num_allocations = i;
  68                                 goto err_free_allocations;
  69                         }
  70                         --order;
  71                 }
  72
  73                 split_page(pages[i], order);
  74                 counts[i] = 1 << order;
  75                 num_pages -= counts[i];
  76                 i++;
  77         }
  78         num_allocations = i;
  79
  80         local_irq_save(flags);
  81
  82         input_page = *this_cpu_ptr(hyperv_pcpu_input_arg);
  83
  84         input_page->partition_id = partition_id;
  85
  86         /* Populate gpa_page_list - these will fit on the input page */
  87         for (i = 0, page_count = 0; i < num_allocations; ++i) {
  88                 base_pfn = page_to_pfn(pages[i]);
  89                 for (j = 0; j < counts[i]; ++j, ++page_count)
  90                         input_page->gpa_page_list[page_count] = base_pfn + j;
  91         }
  92         status = hv_do_rep_hypercall(HVCALL_DEPOSIT_MEMORY,
  93                                      page_count, 0, input_page, NULL);
  94         local_irq_restore(flags);
  95         if (!hv_result_success(status)) {
  96                 pr_err("Failed to deposit pages: %lld\n", status);
  97                 ret = hv_result(status);
  98                 goto err_free_allocations;
  99         }
 100
 101         ret = 0;
 102         goto free_buf;
 103
 104 err_free_allocations:
 105         for (i = 0; i < num_allocations; ++i) {
 106                 base_pfn = page_to_pfn(pages[i]);
 107                 for (j = 0; j < counts[i]; ++j)
 108                         __free_page(pfn_to_page(base_pfn + j));
 109         }
 110
 111 free_buf:
 112         free_page((unsigned long)pages);
 113         kfree(counts);
 114         return ret;
 115 }
 116
 117 int hv_call_add_logical_proc(int node, u32 lp_index, u32 apic_id)
 118 {
 119         struct hv_add_logical_processor_in *input;
 120         struct hv_add_logical_processor_out *output;
 121         u64 status;
 122         unsigned long flags;
 123         int ret = HV_STATUS_SUCCESS;
 124         int pxm = node_to_pxm(node);
 125
 126         /*
 127          * When adding a logical processor, the hypervisor may return
 128          * HV_STATUS_INSUFFICIENT_MEMORY. When that happens, we deposit more
 129          * pages and retry.
 130          */
 131         do {
 132                 local_irq_save(flags);
 133
 134                 input = *this_cpu_ptr(hyperv_pcpu_input_arg);
 135                 /* We don't do anything with the output right now */
 136                 output = *this_cpu_ptr(hyperv_pcpu_output_arg);
 137
 138                 input->lp_index = lp_index;
 139                 input->apic_id = apic_id;
 140                 input->flags = 0;
 141                 input->proximity_domain_info.domain_id = pxm;
 142                 input->proximity_domain_info.flags.reserved = 0;
 143                 input->proximity_domain_info.flags.proximity_info_valid = 1;
 144                 input->proximity_domain_info.flags.proximity_preferred = 1;
 145                 status = hv_do_hypercall(HVCALL_ADD_LOGICAL_PROCESSOR,
 146                                          input, output);
 147                 local_irq_restore(flags);
 148
 149                 if (hv_result(status) != HV_STATUS_INSUFFICIENT_MEMORY) {
 150                         if (!hv_result_success(status)) {
 151                                 pr_err("%s: cpu %u apic ID %u, %lld\n", __func__,
 152                                        lp_index, apic_id, status);
 153                                 ret = hv_result(status);
 154                         }
 155                         break;
 156                 }
 157                 ret = hv_call_deposit_pages(node, hv_current_partition_id, 1);
 158         } while (!ret);
 159
 160         return ret;
 161 }
 162
 163 int hv_call_create_vp(int node, u64 partition_id, u32 vp_index, u32 flags)
 164 {
 165         struct hv_create_vp *input;
 166         u64 status;
 167         unsigned long irq_flags;
 168         int ret = HV_STATUS_SUCCESS;
 169         int pxm = node_to_pxm(node);
 170
 171         /* Root VPs don't seem to need pages deposited */
 172         if (partition_id != hv_current_partition_id) {
 173                 /* The value 90 is empirically determined. It may change. */
 174                 ret = hv_call_deposit_pages(node, partition_id, 90);
 175                 if (ret)
 176                         return ret;
 177         }
 178
 179         do {
 180                 local_irq_save(irq_flags);
 181
 182                 input = *this_cpu_ptr(hyperv_pcpu_input_arg);
 183
 184                 input->partition_id = partition_id;
 185                 input->vp_index = vp_index;
 186                 input->flags = flags;
 187                 input->subnode_type = HvSubnodeAny;
 188                 if (node != NUMA_NO_NODE) {
 189                         input->proximity_domain_info.domain_id = pxm;
 190                         input->proximity_domain_info.flags.reserved = 0;
 191                         input->proximity_domain_info.flags.proximity_info_valid = 1;
 192                         input->proximity_domain_info.flags.proximity_preferred = 1;
 193                 } else {
 194                         input->proximity_domain_info.as_uint64 = 0;
 195                 }
 196                 status = hv_do_hypercall(HVCALL_CREATE_VP, input, NULL);
 197                 local_irq_restore(irq_flags);
 198
 199                 if (hv_result(status) != HV_STATUS_INSUFFICIENT_MEMORY) {
 200                         if (!hv_result_success(status)) {
 201                                 pr_err("%s: vcpu %u, lp %u, %lld\n", __func__,
 202                                        vp_index, flags, status);
 203                                 ret = hv_result(status);
 204                         }
 205                         break;
 206                 }
 207                 ret = hv_call_deposit_pages(node, partition_id, 1);
 208
 209         } while (!ret);
 210
 211         return ret;
 212 }
 213