1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef XEN_OPS_H 3 #define XEN_OPS_H 4 5 #include <linux/init.h> 6 #include <linux/clocksource.h> 7 #include <linux/irqreturn.h> 8 #include <linux/linkage.h> 9 10 #include <xen/interface/xenpmu.h> 11 #include <xen/xen-ops.h> 12 13 #include <asm/page.h> 14 15 #include <trace/events/xen.h> 16 17 /* These are code, but not functions. Defined in entry.S */ 18 extern const char xen_failsafe_callback[]; 19 20 void xen_entry_SYSENTER_compat(void); 21 #ifdef CONFIG_X86_64 22 void xen_entry_SYSCALL_64(void); 23 void xen_entry_SYSCALL_compat(void); 24 #endif 25 26 extern void *xen_initial_gdt; 27 28 struct trap_info; 29 void xen_copy_trap_info(struct trap_info *traps); 30 31 DECLARE_PER_CPU_ALIGNED(struct vcpu_info, xen_vcpu_info); 32 DECLARE_PER_CPU(unsigned long, xen_cr3); 33 34 extern struct start_info *xen_start_info; 35 extern struct shared_info xen_dummy_shared_info; 36 extern struct shared_info *HYPERVISOR_shared_info; 37 38 void xen_setup_mfn_list_list(void); 39 void xen_build_mfn_list_list(void); 40 void xen_setup_machphys_mapping(void); 41 void xen_setup_kernel_pagetable(pgd_t *pgd, unsigned long max_pfn); 42 void __init xen_reserve_special_pages(void); 43 void __init xen_pt_check_e820(void); 44 45 void xen_mm_pin_all(void); 46 void xen_mm_unpin_all(void); 47 #ifdef CONFIG_X86_64 48 void __init xen_relocate_p2m(void); 49 #endif 50 51 bool __init xen_is_e820_reserved(phys_addr_t start, phys_addr_t size); 52 unsigned long __ref xen_chk_extra_mem(unsigned long pfn); 53 void __init xen_inv_extra_mem(void); 54 void __init xen_remap_memory(void); 55 phys_addr_t __init xen_find_free_area(phys_addr_t size); 56 char * __init xen_memory_setup(void); 57 void __init xen_arch_setup(void); 58 void xen_banner(void); 59 void xen_enable_sysenter(void); 60 void xen_enable_syscall(void); 61 void xen_vcpu_restore(void); 62 63 void xen_hvm_init_shared_info(void); 64 void xen_unplug_emulated_devices(void); 65 66 void __init xen_build_dynamic_phys_to_machine(void); 67 void __init xen_vmalloc_p2m_tree(void); 68 69 void xen_init_irq_ops(void); 70 void xen_setup_timer(int cpu); 71 void xen_setup_runstate_info(int cpu); 72 void xen_teardown_timer(int cpu); 73 void xen_setup_cpu_clockevents(void); 74 void xen_save_time_memory_area(void); 75 void xen_restore_time_memory_area(void); 76 void xen_init_time_ops(void); 77 void xen_hvm_init_time_ops(void); 78 79 bool xen_vcpu_stolen(int vcpu); 80 81 void xen_vcpu_setup(int cpu); 82 void xen_vcpu_info_reset(int cpu); 83 void xen_setup_vcpu_info_placement(void); 84 85 #ifdef CONFIG_SMP 86 void xen_smp_init(void); 87 void __init xen_hvm_smp_init(void); 88 89 extern cpumask_var_t xen_cpu_initialized_map; 90 #else 91 static inline void xen_smp_init(void) {} 92 static inline void xen_hvm_smp_init(void) {} 93 #endif 94 95 #ifdef CONFIG_PARAVIRT_SPINLOCKS 96 void __init xen_init_spinlocks(void); 97 void xen_init_lock_cpu(int cpu); 98 void xen_uninit_lock_cpu(int cpu); 99 #else 100 static inline void xen_init_spinlocks(void) 101 { 102 } 103 static inline void xen_init_lock_cpu(int cpu) 104 { 105 } 106 static inline void xen_uninit_lock_cpu(int cpu) 107 { 108 } 109 #endif 110 111 struct dom0_vga_console_info; 112 113 #ifdef CONFIG_XEN_DOM0 114 void __init xen_init_vga(const struct dom0_vga_console_info *, size_t size, 115 struct screen_info *); 116 #else 117 static inline void __init xen_init_vga(const struct dom0_vga_console_info *info, 118 size_t size, struct screen_info *si) 119 { 120 } 121 #endif 122 123 void xen_add_preferred_consoles(void); 124 125 void __init xen_init_apic(void); 126 127 #ifdef CONFIG_XEN_EFI 128 extern void xen_efi_init(struct boot_params *boot_params); 129 #else 130 static inline void __init xen_efi_init(struct boot_params *boot_params) 131 { 132 } 133 #endif 134 135 __visible void xen_irq_enable_direct(void); 136 __visible void xen_irq_disable_direct(void); 137 __visible unsigned long xen_save_fl_direct(void); 138 139 __visible unsigned long xen_read_cr2(void); 140 __visible unsigned long xen_read_cr2_direct(void); 141 142 /* These are not functions, and cannot be called normally */ 143 __visible void xen_iret(void); 144 145 extern int xen_panic_handler_init(void); 146 147 int xen_cpuhp_setup(int (*cpu_up_prepare_cb)(unsigned int), 148 int (*cpu_dead_cb)(unsigned int)); 149 150 void xen_pin_vcpu(int cpu); 151 152 void xen_emergency_restart(void); 153 void xen_force_evtchn_callback(void); 154 155 #ifdef CONFIG_XEN_PV 156 void xen_pv_pre_suspend(void); 157 void xen_pv_post_suspend(int suspend_cancelled); 158 void xen_start_kernel(struct start_info *si); 159 #else 160 static inline void xen_pv_pre_suspend(void) {} 161 static inline void xen_pv_post_suspend(int suspend_cancelled) {} 162 #endif 163 164 #ifdef CONFIG_XEN_PVHVM 165 void xen_hvm_post_suspend(int suspend_cancelled); 166 #else 167 static inline void xen_hvm_post_suspend(int suspend_cancelled) {} 168 #endif 169 170 /* 171 * The maximum amount of extra memory compared to the base size. The 172 * main scaling factor is the size of struct page. At extreme ratios 173 * of base:extra, all the base memory can be filled with page 174 * structures for the extra memory, leaving no space for anything 175 * else. 176 * 177 * 10x seems like a reasonable balance between scaling flexibility and 178 * leaving a practically usable system. 179 */ 180 #define EXTRA_MEM_RATIO (10) 181 182 void xen_add_extra_mem(unsigned long start_pfn, unsigned long n_pfns); 183 184 struct dentry * __init xen_init_debugfs(void); 185 186 enum pt_level { 187 PT_PGD, 188 PT_P4D, 189 PT_PUD, 190 PT_PMD, 191 PT_PTE 192 }; 193 194 bool __set_phys_to_machine(unsigned long pfn, unsigned long mfn); 195 void set_pte_mfn(unsigned long vaddr, unsigned long pfn, pgprot_t flags); 196 unsigned long xen_read_cr2_direct(void); 197 void xen_init_mmu_ops(void); 198 void xen_hvm_init_mmu_ops(void); 199 200 /* Multicalls */ 201 struct multicall_space 202 { 203 struct multicall_entry *mc; 204 void *args; 205 }; 206 207 /* Allocate room for a multicall and its args */ 208 struct multicall_space __xen_mc_entry(size_t args); 209 210 DECLARE_PER_CPU(unsigned long, xen_mc_irq_flags); 211 212 /* Call to start a batch of multiple __xen_mc_entry()s. Must be 213 paired with xen_mc_issue() */ 214 static inline void xen_mc_batch(void) 215 { 216 unsigned long flags; 217 218 /* need to disable interrupts until this entry is complete */ 219 local_irq_save(flags); 220 trace_xen_mc_batch(xen_get_lazy_mode()); 221 __this_cpu_write(xen_mc_irq_flags, flags); 222 } 223 224 static inline struct multicall_space xen_mc_entry(size_t args) 225 { 226 xen_mc_batch(); 227 return __xen_mc_entry(args); 228 } 229 230 /* Flush all pending multicalls */ 231 void xen_mc_flush(void); 232 233 /* Issue a multicall if we're not in a lazy mode */ 234 static inline void xen_mc_issue(unsigned mode) 235 { 236 trace_xen_mc_issue(mode); 237 238 if ((xen_get_lazy_mode() & mode) == 0) 239 xen_mc_flush(); 240 241 /* restore flags saved in xen_mc_batch */ 242 local_irq_restore(this_cpu_read(xen_mc_irq_flags)); 243 } 244 245 /* Set up a callback to be called when the current batch is flushed */ 246 void xen_mc_callback(void (*fn)(void *), void *data); 247 248 /* 249 * Try to extend the arguments of the previous multicall command. The 250 * previous command's op must match. If it does, then it attempts to 251 * extend the argument space allocated to the multicall entry by 252 * arg_size bytes. 253 * 254 * The returned multicall_space will return with mc pointing to the 255 * command on success, or NULL on failure, and args pointing to the 256 * newly allocated space. 257 */ 258 struct multicall_space xen_mc_extend_args(unsigned long op, size_t arg_size); 259 260 /* Do percpu data initialization for multicalls. */ 261 void mc_percpu_init(unsigned int cpu); 262 263 extern bool is_xen_pmu; 264 265 irqreturn_t xen_pmu_irq_handler(int irq, void *dev_id); 266 #ifdef CONFIG_XEN_HAVE_VPMU 267 void xen_pmu_init(int cpu); 268 void xen_pmu_finish(int cpu); 269 #else 270 static inline void xen_pmu_init(int cpu) {} 271 static inline void xen_pmu_finish(int cpu) {} 272 #endif 273 bool pmu_msr_read(unsigned int msr, uint64_t *val, int *err); 274 bool pmu_msr_write(unsigned int msr, uint32_t low, uint32_t high, int *err); 275 int pmu_apic_update(uint32_t reg); 276 unsigned long long xen_read_pmc(int counter); 277 278 #ifdef CONFIG_SMP 279 280 void asm_cpu_bringup_and_idle(void); 281 asmlinkage void cpu_bringup_and_idle(void); 282 283 extern void xen_send_IPI_mask(const struct cpumask *mask, 284 int vector); 285 extern void xen_send_IPI_mask_allbutself(const struct cpumask *mask, 286 int vector); 287 extern void xen_send_IPI_allbutself(int vector); 288 extern void xen_send_IPI_all(int vector); 289 extern void xen_send_IPI_self(int vector); 290 291 extern int xen_smp_intr_init(unsigned int cpu); 292 extern void xen_smp_intr_free(unsigned int cpu); 293 int xen_smp_intr_init_pv(unsigned int cpu); 294 void xen_smp_intr_free_pv(unsigned int cpu); 295 296 void xen_smp_count_cpus(void); 297 void xen_smp_cpus_done(unsigned int max_cpus); 298 299 void xen_smp_send_reschedule(int cpu); 300 void xen_smp_send_call_function_ipi(const struct cpumask *mask); 301 void xen_smp_send_call_function_single_ipi(int cpu); 302 303 void __noreturn xen_cpu_bringup_again(unsigned long stack); 304 305 struct xen_common_irq { 306 int irq; 307 char *name; 308 }; 309 #else /* CONFIG_SMP */ 310 311 static inline int xen_smp_intr_init(unsigned int cpu) 312 { 313 return 0; 314 } 315 static inline void xen_smp_intr_free(unsigned int cpu) {} 316 317 static inline int xen_smp_intr_init_pv(unsigned int cpu) 318 { 319 return 0; 320 } 321 static inline void xen_smp_intr_free_pv(unsigned int cpu) {} 322 static inline void xen_smp_count_cpus(void) { } 323 #endif /* CONFIG_SMP */ 324 325 #endif /* XEN_OPS_H */ 326