LCOV - code coverage report
Current view: top level - arch/x86/kernel - paravirt.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 31 66 47.0 %
Date: 2022-03-28 13:20:08 Functions: 7 14 50.0 %
Branches: 5 18 27.8 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /*  Paravirtualization interfaces
       3                 :            :     Copyright (C) 2006 Rusty Russell IBM Corporation
       4                 :            : 
       5                 :            : 
       6                 :            :     2007 - x86_64 support added by Glauber de Oliveira Costa, Red Hat Inc
       7                 :            : */
       8                 :            : 
       9                 :            : #include <linux/errno.h>
      10                 :            : #include <linux/init.h>
      11                 :            : #include <linux/export.h>
      12                 :            : #include <linux/efi.h>
      13                 :            : #include <linux/bcd.h>
      14                 :            : #include <linux/highmem.h>
      15                 :            : #include <linux/kprobes.h>
      16                 :            : 
      17                 :            : #include <asm/bug.h>
      18                 :            : #include <asm/paravirt.h>
      19                 :            : #include <asm/debugreg.h>
      20                 :            : #include <asm/desc.h>
      21                 :            : #include <asm/setup.h>
      22                 :            : #include <asm/pgtable.h>
      23                 :            : #include <asm/time.h>
      24                 :            : #include <asm/pgalloc.h>
      25                 :            : #include <asm/irq.h>
      26                 :            : #include <asm/delay.h>
      27                 :            : #include <asm/fixmap.h>
      28                 :            : #include <asm/apic.h>
      29                 :            : #include <asm/tlbflush.h>
      30                 :            : #include <asm/timer.h>
      31                 :            : #include <asm/special_insns.h>
      32                 :            : #include <asm/tlb.h>
      33                 :            : #include <asm/io_bitmap.h>
      34                 :            : 
      35                 :            : /*
      36                 :            :  * nop stub, which must not clobber anything *including the stack* to
      37                 :            :  * avoid confusing the entry prologues.
      38                 :            :  */
      39                 :            : extern void _paravirt_nop(void);
      40                 :            : asm (".pushsection .entry.text, \"ax\"\n"
      41                 :            :      ".global _paravirt_nop\n"
      42                 :            :      "_paravirt_nop:\n\t"
      43                 :            :      "ret\n\t"
      44                 :            :      ".size _paravirt_nop, . - _paravirt_nop\n\t"
      45                 :            :      ".type _paravirt_nop, @function\n\t"
      46                 :            :      ".popsection");
      47                 :            : 
      48                 :         30 : void __init default_banner(void)
      49                 :            : {
      50                 :         30 :         printk(KERN_INFO "Booting paravirtualized kernel on %s\n",
      51                 :            :                pv_info.name);
      52                 :         30 : }
      53                 :            : 
      54                 :            : /* Undefined instruction for dealing with missing ops pointers. */
      55                 :            : static const unsigned char ud2a[] = { 0x0f, 0x0b };
      56                 :            : 
      57                 :            : struct branch {
      58                 :            :         unsigned char opcode;
      59                 :            :         u32 delta;
      60                 :            : } __attribute__((packed));
      61                 :            : 
      62                 :        990 : static unsigned paravirt_patch_call(void *insn_buff, const void *target,
      63                 :            :                                     unsigned long addr, unsigned len)
      64                 :            : {
      65                 :        990 :         const int call_len = 5;
      66                 :        990 :         struct branch *b = insn_buff;
      67                 :        990 :         unsigned long delta = (unsigned long)target - (addr+call_len);
      68                 :            : 
      69         [ -  + ]:        990 :         if (len < call_len) {
      70                 :          0 :                 pr_warn("paravirt: Failed to patch indirect CALL at %ps\n", (void *)addr);
      71                 :            :                 /* Kernel might not be viable if patching fails, bail out: */
      72                 :          0 :                 BUG_ON(1);
      73                 :            :         }
      74                 :            : 
      75                 :        990 :         b->opcode = 0xe8; /* call */
      76                 :        990 :         b->delta = delta;
      77                 :        990 :         BUILD_BUG_ON(sizeof(*b) != call_len);
      78                 :            : 
      79                 :        990 :         return call_len;
      80                 :            : }
      81                 :            : 
      82                 :            : #ifdef CONFIG_PARAVIRT_XXL
      83                 :            : /* identity function, which can be inlined */
      84                 :            : u64 notrace _paravirt_ident_64(u64 x)
      85                 :            : {
      86                 :            :         return x;
      87                 :            : }
      88                 :            : 
      89                 :            : static unsigned paravirt_patch_jmp(void *insn_buff, const void *target,
      90                 :            :                                    unsigned long addr, unsigned len)
      91                 :            : {
      92                 :            :         struct branch *b = insn_buff;
      93                 :            :         unsigned long delta = (unsigned long)target - (addr+5);
      94                 :            : 
      95                 :            :         if (len < 5) {
      96                 :            : #ifdef CONFIG_RETPOLINE
      97                 :            :                 WARN_ONCE(1, "Failing to patch indirect JMP in %ps\n", (void *)addr);
      98                 :            : #endif
      99                 :            :                 return len;     /* call too long for patch site */
     100                 :            :         }
     101                 :            : 
     102                 :            :         b->opcode = 0xe9;    /* jmp */
     103                 :            :         b->delta = delta;
     104                 :            : 
     105                 :            :         return 5;
     106                 :            : }
     107                 :            : #endif
     108                 :            : 
     109                 :            : DEFINE_STATIC_KEY_TRUE(virt_spin_lock_key);
     110                 :            : 
     111                 :         30 : void __init native_pv_lock_init(void)
     112                 :            : {
     113         [ -  + ]:         30 :         if (!boot_cpu_has(X86_FEATURE_HYPERVISOR))
     114                 :          0 :                 static_branch_disable(&virt_spin_lock_key);
     115                 :         30 : }
     116                 :            : 
     117                 :       1020 : unsigned paravirt_patch_default(u8 type, void *insn_buff,
     118                 :            :                                 unsigned long addr, unsigned len)
     119                 :            : {
     120                 :            :         /*
     121                 :            :          * Neat trick to map patch type back to the call within the
     122                 :            :          * corresponding structure.
     123                 :            :          */
     124                 :       1020 :         void *opfunc = *((void **)&pv_ops + type);
     125                 :       1020 :         unsigned ret;
     126                 :            : 
     127         [ -  + ]:       1020 :         if (opfunc == NULL)
     128                 :            :                 /* If there's no function, patch it with a ud2a (BUG) */
     129                 :          0 :                 ret = paravirt_patch_insns(insn_buff, len, ud2a, ud2a+sizeof(ud2a));
     130         [ +  + ]:       1020 :         else if (opfunc == _paravirt_nop)
     131                 :            :                 ret = 0;
     132                 :            : 
     133                 :            : #ifdef CONFIG_PARAVIRT_XXL
     134                 :            :         /* identity functions just return their single argument */
     135                 :            :         else if (opfunc == _paravirt_ident_64)
     136                 :            :                 ret = paravirt_patch_ident_64(insn_buff, len);
     137                 :            : 
     138                 :            :         else if (type == PARAVIRT_PATCH(cpu.iret) ||
     139                 :            :                  type == PARAVIRT_PATCH(cpu.usergs_sysret64))
     140                 :            :                 /* If operation requires a jmp, then jmp */
     141                 :            :                 ret = paravirt_patch_jmp(insn_buff, opfunc, addr, len);
     142                 :            : #endif
     143                 :            :         else
     144                 :            :                 /* Otherwise call the function. */
     145                 :        990 :                 ret = paravirt_patch_call(insn_buff, opfunc, addr, len);
     146                 :            : 
     147                 :       1020 :         return ret;
     148                 :            : }
     149                 :            : 
     150                 :          0 : unsigned paravirt_patch_insns(void *insn_buff, unsigned len,
     151                 :            :                               const char *start, const char *end)
     152                 :            : {
     153                 :          0 :         unsigned insn_len = end - start;
     154                 :            : 
     155                 :            :         /* Alternative instruction is too large for the patch site and we cannot continue: */
     156         [ #  # ]:          0 :         BUG_ON(insn_len > len || start == NULL);
     157                 :            : 
     158                 :          0 :         memcpy(insn_buff, start, insn_len);
     159                 :            : 
     160                 :          0 :         return insn_len;
     161                 :            : }
     162                 :            : 
     163                 :     315980 : static void native_flush_tlb(void)
     164                 :            : {
     165                 :     315980 :         __native_flush_tlb();
     166                 :     315980 : }
     167                 :            : 
     168                 :            : /*
     169                 :            :  * Global pages have to be flushed a bit differently. Not a real
     170                 :            :  * performance problem because this does not happen often.
     171                 :            :  */
     172                 :       2224 : static void native_flush_tlb_global(void)
     173                 :            : {
     174                 :       2224 :         __native_flush_tlb_global();
     175                 :       2224 : }
     176                 :            : 
     177                 :    5595911 : static void native_flush_tlb_one_user(unsigned long addr)
     178                 :            : {
     179                 :    5595911 :         __native_flush_tlb_one_user(addr);
     180                 :    5595911 : }
     181                 :            : 
     182                 :            : struct static_key paravirt_steal_enabled;
     183                 :            : struct static_key paravirt_steal_rq_enabled;
     184                 :            : 
     185                 :          0 : static u64 native_steal_clock(int cpu)
     186                 :            : {
     187                 :          0 :         return 0;
     188                 :            : }
     189                 :            : 
     190                 :            : /* These are in entry.S */
     191                 :            : extern void native_iret(void);
     192                 :            : extern void native_usergs_sysret64(void);
     193                 :            : 
     194                 :            : static struct resource reserve_ioports = {
     195                 :            :         .start = 0,
     196                 :            :         .end = IO_SPACE_LIMIT,
     197                 :            :         .name = "paravirt-ioport",
     198                 :            :         .flags = IORESOURCE_IO | IORESOURCE_BUSY,
     199                 :            : };
     200                 :            : 
     201                 :            : /*
     202                 :            :  * Reserve the whole legacy IO space to prevent any legacy drivers
     203                 :            :  * from wasting time probing for their hardware.  This is a fairly
     204                 :            :  * brute-force approach to disabling all non-virtual drivers.
     205                 :            :  *
     206                 :            :  * Note that this must be called very early to have any effect.
     207                 :            :  */
     208                 :          0 : int paravirt_disable_iospace(void)
     209                 :            : {
     210                 :          0 :         return request_resource(&ioport_resource, &reserve_ioports);
     211                 :            : }
     212                 :            : 
     213                 :            : static DEFINE_PER_CPU(enum paravirt_lazy_mode, paravirt_lazy_mode) = PARAVIRT_LAZY_NONE;
     214                 :            : 
     215                 :          0 : static inline void enter_lazy(enum paravirt_lazy_mode mode)
     216                 :            : {
     217         [ #  # ]:          0 :         BUG_ON(this_cpu_read(paravirt_lazy_mode) != PARAVIRT_LAZY_NONE);
     218                 :            : 
     219                 :          0 :         this_cpu_write(paravirt_lazy_mode, mode);
     220                 :            : }
     221                 :            : 
     222                 :          0 : static void leave_lazy(enum paravirt_lazy_mode mode)
     223                 :            : {
     224         [ #  # ]:          0 :         BUG_ON(this_cpu_read(paravirt_lazy_mode) != mode);
     225                 :            : 
     226                 :          0 :         this_cpu_write(paravirt_lazy_mode, PARAVIRT_LAZY_NONE);
     227                 :            : }
     228                 :            : 
     229                 :          0 : void paravirt_enter_lazy_mmu(void)
     230                 :            : {
     231                 :          0 :         enter_lazy(PARAVIRT_LAZY_MMU);
     232                 :          0 : }
     233                 :            : 
     234                 :          0 : void paravirt_leave_lazy_mmu(void)
     235                 :            : {
     236                 :          0 :         leave_lazy(PARAVIRT_LAZY_MMU);
     237                 :          0 : }
     238                 :            : 
     239                 :          0 : void paravirt_flush_lazy_mmu(void)
     240                 :            : {
     241                 :          0 :         preempt_disable();
     242                 :            : 
     243                 :          0 :         if (paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU) {
     244                 :          0 :                 arch_leave_lazy_mmu_mode();
     245                 :          0 :                 arch_enter_lazy_mmu_mode();
     246                 :            :         }
     247                 :            : 
     248                 :          0 :         preempt_enable();
     249                 :          0 : }
     250                 :            : 
     251                 :            : #ifdef CONFIG_PARAVIRT_XXL
     252                 :            : void paravirt_start_context_switch(struct task_struct *prev)
     253                 :            : {
     254                 :            :         BUG_ON(preemptible());
     255                 :            : 
     256                 :            :         if (this_cpu_read(paravirt_lazy_mode) == PARAVIRT_LAZY_MMU) {
     257                 :            :                 arch_leave_lazy_mmu_mode();
     258                 :            :                 set_ti_thread_flag(task_thread_info(prev), TIF_LAZY_MMU_UPDATES);
     259                 :            :         }
     260                 :            :         enter_lazy(PARAVIRT_LAZY_CPU);
     261                 :            : }
     262                 :            : 
     263                 :            : void paravirt_end_context_switch(struct task_struct *next)
     264                 :            : {
     265                 :            :         BUG_ON(preemptible());
     266                 :            : 
     267                 :            :         leave_lazy(PARAVIRT_LAZY_CPU);
     268                 :            : 
     269                 :            :         if (test_and_clear_ti_thread_flag(task_thread_info(next), TIF_LAZY_MMU_UPDATES))
     270                 :            :                 arch_enter_lazy_mmu_mode();
     271                 :            : }
     272                 :            : #endif
     273                 :            : 
     274                 :          0 : enum paravirt_lazy_mode paravirt_get_lazy_mode(void)
     275                 :            : {
     276   [ #  #  #  # ]:          0 :         if (in_interrupt())
     277                 :            :                 return PARAVIRT_LAZY_NONE;
     278                 :            : 
     279                 :          0 :         return this_cpu_read(paravirt_lazy_mode);
     280                 :            : }
     281                 :            : 
     282                 :            : struct pv_info pv_info = {
     283                 :            :         .name = "bare hardware",
     284                 :            : #ifdef CONFIG_PARAVIRT_XXL
     285                 :            :         .kernel_rpl = 0,
     286                 :            :         .shared_kernel_pmd = 1, /* Only used when CONFIG_X86_PAE is set */
     287                 :            : 
     288                 :            : #ifdef CONFIG_X86_64
     289                 :            :         .extra_user_64bit_cs = __USER_CS,
     290                 :            : #endif
     291                 :            : #endif
     292                 :            : };
     293                 :            : 
     294                 :            : /* 64-bit pagetable entries */
     295                 :            : #define PTE_IDENT       __PV_IS_CALLEE_SAVE(_paravirt_ident_64)
     296                 :            : 
     297                 :            : struct paravirt_patch_template pv_ops = {
     298                 :            :         /* Init ops. */
     299                 :            :         .init.patch             = native_patch,
     300                 :            : 
     301                 :            :         /* Time ops. */
     302                 :            :         .time.sched_clock       = native_sched_clock,
     303                 :            :         .time.steal_clock       = native_steal_clock,
     304                 :            : 
     305                 :            :         /* Cpu ops. */
     306                 :            :         .cpu.io_delay           = native_io_delay,
     307                 :            : 
     308                 :            : #ifdef CONFIG_PARAVIRT_XXL
     309                 :            :         .cpu.cpuid              = native_cpuid,
     310                 :            :         .cpu.get_debugreg       = native_get_debugreg,
     311                 :            :         .cpu.set_debugreg       = native_set_debugreg,
     312                 :            :         .cpu.read_cr0           = native_read_cr0,
     313                 :            :         .cpu.write_cr0          = native_write_cr0,
     314                 :            :         .cpu.write_cr4          = native_write_cr4,
     315                 :            :         .cpu.wbinvd             = native_wbinvd,
     316                 :            :         .cpu.read_msr           = native_read_msr,
     317                 :            :         .cpu.write_msr          = native_write_msr,
     318                 :            :         .cpu.read_msr_safe      = native_read_msr_safe,
     319                 :            :         .cpu.write_msr_safe     = native_write_msr_safe,
     320                 :            :         .cpu.read_pmc           = native_read_pmc,
     321                 :            :         .cpu.load_tr_desc       = native_load_tr_desc,
     322                 :            :         .cpu.set_ldt            = native_set_ldt,
     323                 :            :         .cpu.load_gdt           = native_load_gdt,
     324                 :            :         .cpu.load_idt           = native_load_idt,
     325                 :            :         .cpu.store_tr           = native_store_tr,
     326                 :            :         .cpu.load_tls           = native_load_tls,
     327                 :            : #ifdef CONFIG_X86_64
     328                 :            :         .cpu.load_gs_index      = native_load_gs_index,
     329                 :            : #endif
     330                 :            :         .cpu.write_ldt_entry    = native_write_ldt_entry,
     331                 :            :         .cpu.write_gdt_entry    = native_write_gdt_entry,
     332                 :            :         .cpu.write_idt_entry    = native_write_idt_entry,
     333                 :            : 
     334                 :            :         .cpu.alloc_ldt          = paravirt_nop,
     335                 :            :         .cpu.free_ldt           = paravirt_nop,
     336                 :            : 
     337                 :            :         .cpu.load_sp0           = native_load_sp0,
     338                 :            : 
     339                 :            : #ifdef CONFIG_X86_64
     340                 :            :         .cpu.usergs_sysret64    = native_usergs_sysret64,
     341                 :            : #endif
     342                 :            :         .cpu.iret               = native_iret,
     343                 :            :         .cpu.swapgs             = native_swapgs,
     344                 :            : 
     345                 :            : #ifdef CONFIG_X86_IOPL_IOPERM
     346                 :            :         .cpu.update_io_bitmap   = native_tss_update_io_bitmap,
     347                 :            : #endif
     348                 :            : 
     349                 :            :         .cpu.start_context_switch       = paravirt_nop,
     350                 :            :         .cpu.end_context_switch         = paravirt_nop,
     351                 :            : 
     352                 :            :         /* Irq ops. */
     353                 :            :         .irq.save_fl            = __PV_IS_CALLEE_SAVE(native_save_fl),
     354                 :            :         .irq.restore_fl         = __PV_IS_CALLEE_SAVE(native_restore_fl),
     355                 :            :         .irq.irq_disable        = __PV_IS_CALLEE_SAVE(native_irq_disable),
     356                 :            :         .irq.irq_enable         = __PV_IS_CALLEE_SAVE(native_irq_enable),
     357                 :            :         .irq.safe_halt          = native_safe_halt,
     358                 :            :         .irq.halt               = native_halt,
     359                 :            : #endif /* CONFIG_PARAVIRT_XXL */
     360                 :            : 
     361                 :            :         /* Mmu ops. */
     362                 :            :         .mmu.flush_tlb_user     = native_flush_tlb,
     363                 :            :         .mmu.flush_tlb_kernel   = native_flush_tlb_global,
     364                 :            :         .mmu.flush_tlb_one_user = native_flush_tlb_one_user,
     365                 :            :         .mmu.flush_tlb_others   = native_flush_tlb_others,
     366                 :            :         .mmu.tlb_remove_table   =
     367                 :            :                         (void (*)(struct mmu_gather *, void *))tlb_remove_page,
     368                 :            : 
     369                 :            :         .mmu.exit_mmap          = paravirt_nop,
     370                 :            : 
     371                 :            : #ifdef CONFIG_PARAVIRT_XXL
     372                 :            :         .mmu.read_cr2           = __PV_IS_CALLEE_SAVE(native_read_cr2),
     373                 :            :         .mmu.write_cr2          = native_write_cr2,
     374                 :            :         .mmu.read_cr3           = __native_read_cr3,
     375                 :            :         .mmu.write_cr3          = native_write_cr3,
     376                 :            : 
     377                 :            :         .mmu.pgd_alloc          = __paravirt_pgd_alloc,
     378                 :            :         .mmu.pgd_free           = paravirt_nop,
     379                 :            : 
     380                 :            :         .mmu.alloc_pte          = paravirt_nop,
     381                 :            :         .mmu.alloc_pmd          = paravirt_nop,
     382                 :            :         .mmu.alloc_pud          = paravirt_nop,
     383                 :            :         .mmu.alloc_p4d          = paravirt_nop,
     384                 :            :         .mmu.release_pte        = paravirt_nop,
     385                 :            :         .mmu.release_pmd        = paravirt_nop,
     386                 :            :         .mmu.release_pud        = paravirt_nop,
     387                 :            :         .mmu.release_p4d        = paravirt_nop,
     388                 :            : 
     389                 :            :         .mmu.set_pte            = native_set_pte,
     390                 :            :         .mmu.set_pte_at         = native_set_pte_at,
     391                 :            :         .mmu.set_pmd            = native_set_pmd,
     392                 :            : 
     393                 :            :         .mmu.ptep_modify_prot_start     = __ptep_modify_prot_start,
     394                 :            :         .mmu.ptep_modify_prot_commit    = __ptep_modify_prot_commit,
     395                 :            : 
     396                 :            : #if CONFIG_PGTABLE_LEVELS >= 3
     397                 :            : #ifdef CONFIG_X86_PAE
     398                 :            :         .mmu.set_pte_atomic     = native_set_pte_atomic,
     399                 :            :         .mmu.pte_clear          = native_pte_clear,
     400                 :            :         .mmu.pmd_clear          = native_pmd_clear,
     401                 :            : #endif
     402                 :            :         .mmu.set_pud            = native_set_pud,
     403                 :            : 
     404                 :            :         .mmu.pmd_val            = PTE_IDENT,
     405                 :            :         .mmu.make_pmd           = PTE_IDENT,
     406                 :            : 
     407                 :            : #if CONFIG_PGTABLE_LEVELS >= 4
     408                 :            :         .mmu.pud_val            = PTE_IDENT,
     409                 :            :         .mmu.make_pud           = PTE_IDENT,
     410                 :            : 
     411                 :            :         .mmu.set_p4d            = native_set_p4d,
     412                 :            : 
     413                 :            : #if CONFIG_PGTABLE_LEVELS >= 5
     414                 :            :         .mmu.p4d_val            = PTE_IDENT,
     415                 :            :         .mmu.make_p4d           = PTE_IDENT,
     416                 :            : 
     417                 :            :         .mmu.set_pgd            = native_set_pgd,
     418                 :            : #endif /* CONFIG_PGTABLE_LEVELS >= 5 */
     419                 :            : #endif /* CONFIG_PGTABLE_LEVELS >= 4 */
     420                 :            : #endif /* CONFIG_PGTABLE_LEVELS >= 3 */
     421                 :            : 
     422                 :            :         .mmu.pte_val            = PTE_IDENT,
     423                 :            :         .mmu.pgd_val            = PTE_IDENT,
     424                 :            : 
     425                 :            :         .mmu.make_pte           = PTE_IDENT,
     426                 :            :         .mmu.make_pgd           = PTE_IDENT,
     427                 :            : 
     428                 :            :         .mmu.dup_mmap           = paravirt_nop,
     429                 :            :         .mmu.activate_mm        = paravirt_nop,
     430                 :            : 
     431                 :            :         .mmu.lazy_mode = {
     432                 :            :                 .enter          = paravirt_nop,
     433                 :            :                 .leave          = paravirt_nop,
     434                 :            :                 .flush          = paravirt_nop,
     435                 :            :         },
     436                 :            : 
     437                 :            :         .mmu.set_fixmap         = native_set_fixmap,
     438                 :            : #endif /* CONFIG_PARAVIRT_XXL */
     439                 :            : 
     440                 :            : #if defined(CONFIG_PARAVIRT_SPINLOCKS)
     441                 :            :         /* Lock ops. */
     442                 :            : #ifdef CONFIG_SMP
     443                 :            :         .lock.queued_spin_lock_slowpath = native_queued_spin_lock_slowpath,
     444                 :            :         .lock.queued_spin_unlock        =
     445                 :            :                                 PV_CALLEE_SAVE(__native_queued_spin_unlock),
     446                 :            :         .lock.wait                      = paravirt_nop,
     447                 :            :         .lock.kick                      = paravirt_nop,
     448                 :            :         .lock.vcpu_is_preempted         =
     449                 :            :                                 PV_CALLEE_SAVE(__native_vcpu_is_preempted),
     450                 :            : #endif /* SMP */
     451                 :            : #endif
     452                 :            : };
     453                 :            : 
     454                 :            : #ifdef CONFIG_PARAVIRT_XXL
     455                 :            : /* At this point, native_get/set_debugreg has real function entries */
     456                 :            : NOKPROBE_SYMBOL(native_get_debugreg);
     457                 :            : NOKPROBE_SYMBOL(native_set_debugreg);
     458                 :            : NOKPROBE_SYMBOL(native_load_idt);
     459                 :            : #endif
     460                 :            : 
     461                 :            : EXPORT_SYMBOL(pv_ops);
     462                 :            : EXPORT_SYMBOL_GPL(pv_info);

Generated by: LCOV version 1.14