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