LCOV - code coverage report
Current view: top level - arch/x86/kernel - process_64.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 141 236 59.7 %
Date: 2022-03-28 15:32:58 Functions: 9 20 45.0 %
Branches: 44 123 35.8 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :  *  Copyright (C) 1995  Linus Torvalds
       4                 :            :  *
       5                 :            :  *  Pentium III FXSR, SSE support
       6                 :            :  *      Gareth Hughes <gareth@valinux.com>, May 2000
       7                 :            :  *
       8                 :            :  *  X86-64 port
       9                 :            :  *      Andi Kleen.
      10                 :            :  *
      11                 :            :  *      CPU hotplug support - ashok.raj@intel.com
      12                 :            :  */
      13                 :            : 
      14                 :            : /*
      15                 :            :  * This file handles the architecture-dependent parts of process handling..
      16                 :            :  */
      17                 :            : 
      18                 :            : #include <linux/cpu.h>
      19                 :            : #include <linux/errno.h>
      20                 :            : #include <linux/sched.h>
      21                 :            : #include <linux/sched/task.h>
      22                 :            : #include <linux/sched/task_stack.h>
      23                 :            : #include <linux/fs.h>
      24                 :            : #include <linux/kernel.h>
      25                 :            : #include <linux/mm.h>
      26                 :            : #include <linux/elfcore.h>
      27                 :            : #include <linux/smp.h>
      28                 :            : #include <linux/slab.h>
      29                 :            : #include <linux/user.h>
      30                 :            : #include <linux/interrupt.h>
      31                 :            : #include <linux/delay.h>
      32                 :            : #include <linux/export.h>
      33                 :            : #include <linux/ptrace.h>
      34                 :            : #include <linux/notifier.h>
      35                 :            : #include <linux/kprobes.h>
      36                 :            : #include <linux/kdebug.h>
      37                 :            : #include <linux/prctl.h>
      38                 :            : #include <linux/uaccess.h>
      39                 :            : #include <linux/io.h>
      40                 :            : #include <linux/ftrace.h>
      41                 :            : #include <linux/syscalls.h>
      42                 :            : 
      43                 :            : #include <asm/pgtable.h>
      44                 :            : #include <asm/processor.h>
      45                 :            : #include <asm/fpu/internal.h>
      46                 :            : #include <asm/mmu_context.h>
      47                 :            : #include <asm/prctl.h>
      48                 :            : #include <asm/desc.h>
      49                 :            : #include <asm/proto.h>
      50                 :            : #include <asm/ia32.h>
      51                 :            : #include <asm/syscalls.h>
      52                 :            : #include <asm/debugreg.h>
      53                 :            : #include <asm/switch_to.h>
      54                 :            : #include <asm/xen/hypervisor.h>
      55                 :            : #include <asm/vdso.h>
      56                 :            : #include <asm/resctrl_sched.h>
      57                 :            : #include <asm/unistd.h>
      58                 :            : #include <asm/fsgsbase.h>
      59                 :            : #ifdef CONFIG_IA32_EMULATION
      60                 :            : /* Not included via unistd.h */
      61                 :            : #include <asm/unistd_32_ia32.h>
      62                 :            : #endif
      63                 :            : 
      64                 :            : #include "process.h"
      65                 :            : 
      66                 :            : /* Prints also some state that isn't saved in the pt_regs */
      67                 :         15 : void __show_regs(struct pt_regs *regs, enum show_regs_mode mode)
      68                 :            : {
      69                 :         15 :         unsigned long cr0 = 0L, cr2 = 0L, cr3 = 0L, cr4 = 0L, fs, gs, shadowgs;
      70                 :         15 :         unsigned long d0, d1, d2, d3, d6, d7;
      71                 :         15 :         unsigned int fsindex, gsindex;
      72                 :         15 :         unsigned int ds, es;
      73                 :            : 
      74                 :         15 :         show_iret_regs(regs);
      75                 :            : 
      76         [ -  + ]:         15 :         if (regs->orig_ax != -1)
      77                 :          0 :                 pr_cont(" ORIG_RAX: %016lx\n", regs->orig_ax);
      78                 :            :         else
      79                 :         15 :                 pr_cont("\n");
      80                 :            : 
      81                 :         15 :         printk(KERN_DEFAULT "RAX: %016lx RBX: %016lx RCX: %016lx\n",
      82                 :            :                regs->ax, regs->bx, regs->cx);
      83                 :         15 :         printk(KERN_DEFAULT "RDX: %016lx RSI: %016lx RDI: %016lx\n",
      84                 :            :                regs->dx, regs->si, regs->di);
      85                 :         15 :         printk(KERN_DEFAULT "RBP: %016lx R08: %016lx R09: %016lx\n",
      86                 :            :                regs->bp, regs->r8, regs->r9);
      87                 :         15 :         printk(KERN_DEFAULT "R10: %016lx R11: %016lx R12: %016lx\n",
      88                 :            :                regs->r10, regs->r11, regs->r12);
      89                 :         15 :         printk(KERN_DEFAULT "R13: %016lx R14: %016lx R15: %016lx\n",
      90                 :            :                regs->r13, regs->r14, regs->r15);
      91                 :            : 
      92         [ +  - ]:         15 :         if (mode == SHOW_REGS_SHORT)
      93                 :            :                 return;
      94                 :            : 
      95         [ -  + ]:         15 :         if (mode == SHOW_REGS_USER) {
      96                 :          0 :                 rdmsrl(MSR_FS_BASE, fs);
      97                 :          0 :                 rdmsrl(MSR_KERNEL_GS_BASE, shadowgs);
      98                 :          0 :                 printk(KERN_DEFAULT "FS:  %016lx GS:  %016lx\n",
      99                 :            :                        fs, shadowgs);
     100                 :          0 :                 return;
     101                 :            :         }
     102                 :            : 
     103                 :         15 :         asm("movl %%ds,%0" : "=r" (ds));
     104                 :         15 :         asm("movl %%es,%0" : "=r" (es));
     105                 :         15 :         asm("movl %%fs,%0" : "=r" (fsindex));
     106                 :         15 :         asm("movl %%gs,%0" : "=r" (gsindex));
     107                 :            : 
     108                 :         15 :         rdmsrl(MSR_FS_BASE, fs);
     109                 :         15 :         rdmsrl(MSR_GS_BASE, gs);
     110                 :         15 :         rdmsrl(MSR_KERNEL_GS_BASE, shadowgs);
     111                 :            : 
     112                 :         15 :         cr0 = read_cr0();
     113                 :         15 :         cr2 = read_cr2();
     114                 :         15 :         cr3 = __read_cr3();
     115                 :         15 :         cr4 = __read_cr4();
     116                 :            : 
     117                 :         15 :         printk(KERN_DEFAULT "FS:  %016lx(%04x) GS:%016lx(%04x) knlGS:%016lx\n",
     118                 :            :                fs, fsindex, gs, gsindex, shadowgs);
     119                 :         15 :         printk(KERN_DEFAULT "CS:  %04lx DS: %04x ES: %04x CR0: %016lx\n", regs->cs, ds,
     120                 :            :                         es, cr0);
     121                 :         15 :         printk(KERN_DEFAULT "CR2: %016lx CR3: %016lx CR4: %016lx\n", cr2, cr3,
     122                 :            :                         cr4);
     123                 :            : 
     124         [ +  - ]:         15 :         get_debugreg(d0, 0);
     125         [ +  - ]:         15 :         get_debugreg(d1, 1);
     126         [ +  - ]:         15 :         get_debugreg(d2, 2);
     127         [ +  - ]:         15 :         get_debugreg(d3, 3);
     128         [ +  - ]:         15 :         get_debugreg(d6, 6);
     129         [ +  - ]:         15 :         get_debugreg(d7, 7);
     130                 :            : 
     131                 :            :         /* Only print out debug registers if they are in their non-default state. */
     132         [ +  - ]:         15 :         if (!((d0 == 0) && (d1 == 0) && (d2 == 0) && (d3 == 0) &&
     133         [ -  + ]:         15 :             (d6 == DR6_RESERVED) && (d7 == 0x400))) {
     134                 :          0 :                 printk(KERN_DEFAULT "DR0: %016lx DR1: %016lx DR2: %016lx\n",
     135                 :            :                        d0, d1, d2);
     136                 :          0 :                 printk(KERN_DEFAULT "DR3: %016lx DR6: %016lx DR7: %016lx\n",
     137                 :            :                        d3, d6, d7);
     138                 :            :         }
     139                 :            : 
     140         [ -  + ]:         15 :         if (boot_cpu_has(X86_FEATURE_OSPKE))
     141                 :          0 :                 printk(KERN_DEFAULT "PKRU: %08x\n", read_pkru());
     142                 :            : }
     143                 :            : 
     144                 :     141444 : void release_thread(struct task_struct *dead_task)
     145                 :            : {
     146         [ -  + ]:     141444 :         WARN_ON(dead_task->mm);
     147                 :     141444 : }
     148                 :            : 
     149                 :            : enum which_selector {
     150                 :            :         FS,
     151                 :            :         GS
     152                 :            : };
     153                 :            : 
     154                 :            : /*
     155                 :            :  * Saves the FS or GS base for an outgoing thread if FSGSBASE extensions are
     156                 :            :  * not available.  The goal is to be reasonably fast on non-FSGSBASE systems.
     157                 :            :  * It's forcibly inlined because it'll generate better code and this function
     158                 :            :  * is hot.
     159                 :            :  */
     160                 :    1581488 : static __always_inline void save_base_legacy(struct task_struct *prev_p,
     161                 :            :                                              unsigned short selector,
     162                 :            :                                              enum which_selector which)
     163                 :            : {
     164                 :    1581488 :         if (likely(selector == 0)) {
     165                 :            :                 /*
     166                 :            :                  * On Intel (without X86_BUG_NULL_SEG), the segment base could
     167                 :            :                  * be the pre-existing saved base or it could be zero.  On AMD
     168                 :            :                  * (with X86_BUG_NULL_SEG), the segment base could be almost
     169                 :            :                  * anything.
     170                 :            :                  *
     171                 :            :                  * This branch is very hot (it's hit twice on almost every
     172                 :            :                  * context switch between 64-bit programs), and avoiding
     173                 :            :                  * the RDMSR helps a lot, so we just assume that whatever
     174                 :            :                  * value is already saved is correct.  This matches historical
     175                 :            :                  * Linux behavior, so it won't break existing applications.
     176                 :            :                  *
     177                 :            :                  * To avoid leaking state, on non-X86_BUG_NULL_SEG CPUs, if we
     178                 :            :                  * report that the base is zero, it needs to actually be zero:
     179                 :            :                  * see the corresponding logic in load_seg_legacy.
     180                 :            :                  */
     181                 :            :         } else {
     182                 :            :                 /*
     183                 :            :                  * If the selector is 1, 2, or 3, then the base is zero on
     184                 :            :                  * !X86_BUG_NULL_SEG CPUs and could be anything on
     185                 :            :                  * X86_BUG_NULL_SEG CPUs.  In the latter case, Linux
     186                 :            :                  * has never attempted to preserve the base across context
     187                 :            :                  * switches.
     188                 :            :                  *
     189                 :            :                  * If selector > 3, then it refers to a real segment, and
     190                 :            :                  * saving the base isn't necessary.
     191                 :            :                  */
     192                 :          0 :                 if (which == FS)
     193                 :          0 :                         prev_p->thread.fsbase = 0;
     194                 :            :                 else
     195                 :          0 :                         prev_p->thread.gsbase = 0;
     196                 :            :         }
     197                 :            : }
     198                 :            : 
     199                 :     790744 : static __always_inline void save_fsgs(struct task_struct *task)
     200                 :            : {
     201                 :     790744 :         savesegment(fs, task->thread.fsindex);
     202                 :     790744 :         savesegment(gs, task->thread.gsindex);
     203                 :     790744 :         save_base_legacy(task, task->thread.fsindex, FS);
     204         [ -  + ]:     790744 :         save_base_legacy(task, task->thread.gsindex, GS);
     205                 :            : }
     206                 :            : 
     207                 :            : #if IS_ENABLED(CONFIG_KVM)
     208                 :            : /*
     209                 :            :  * While a process is running,current->thread.fsbase and current->thread.gsbase
     210                 :            :  * may not match the corresponding CPU registers (see save_base_legacy()). KVM
     211                 :            :  * wants an efficient way to save and restore FSBASE and GSBASE.
     212                 :            :  * When FSGSBASE extensions are enabled, this will have to use RD{FS,GS}BASE.
     213                 :            :  */
     214                 :            : void save_fsgs_for_kvm(void)
     215                 :            : {
     216                 :            :         save_fsgs(current);
     217                 :            : }
     218                 :            : EXPORT_SYMBOL_GPL(save_fsgs_for_kvm);
     219                 :            : #endif
     220                 :            : 
     221                 :     260310 : static __always_inline void loadseg(enum which_selector which,
     222                 :            :                                     unsigned short sel)
     223                 :            : {
     224                 :     260310 :         if (which == FS)
     225                 :     260310 :                 loadsegment(fs, sel);
     226                 :            :         else
     227                 :          0 :                 load_gs_index(sel);
     228                 :            : }
     229                 :            : 
     230                 :    1581488 : static __always_inline void load_seg_legacy(unsigned short prev_index,
     231                 :            :                                             unsigned long prev_base,
     232                 :            :                                             unsigned short next_index,
     233                 :            :                                             unsigned long next_base,
     234                 :            :                                             enum which_selector which)
     235                 :            : {
     236                 :    1581488 :         if (likely(next_index <= 3)) {
     237                 :            :                 /*
     238                 :            :                  * The next task is using 64-bit TLS, is not using this
     239                 :            :                  * segment at all, or is having fun with arcane CPU features.
     240                 :            :                  */
     241   [ +  +  +  - ]:    1581488 :                 if (next_base == 0) {
     242                 :            :                         /*
     243                 :            :                          * Nasty case: on AMD CPUs, we need to forcibly zero
     244                 :            :                          * the base.
     245                 :            :                          */
     246   [ -  +  -  -  :    1146125 :                         if (static_cpu_has_bug(X86_BUG_NULL_SEG)) {
                   +  - ]
     247                 :          0 :                                 loadseg(which, __USER_DS);
     248                 :          0 :                                 loadseg(which, next_index);
     249                 :            :                         } else {
     250                 :            :                                 /*
     251                 :            :                                  * We could try to exhaustively detect cases
     252                 :            :                                  * under which we can skip the segment load,
     253                 :            :                                  * but there's really only one case that matters
     254                 :            :                                  * for performance: if both the previous and
     255                 :            :                                  * next states are fully zeroed, we can skip
     256                 :            :                                  * the load.
     257                 :            :                                  *
     258                 :            :                                  * (This assumes that prev_base == 0 has no
     259                 :            :                                  * false positives.  This is the case on
     260                 :            :                                  * Intel-style CPUs.)
     261                 :            :                                  */
     262   [ +  +  -  + ]:    1146125 :                                 if (likely(prev_index | next_index | prev_base))
     263                 :     120002 :                                         loadseg(which, next_index);
     264                 :            :                         }
     265                 :            :                 } else {
     266   [ -  +  -  - ]:     435363 :                         if (prev_index != next_index)
     267                 :          0 :                                 loadseg(which, next_index);
     268                 :     435363 :                         wrmsrl(which == FS ? MSR_FS_BASE : MSR_KERNEL_GS_BASE,
     269                 :            :                                next_base);
     270                 :            :                 }
     271                 :            :         } else {
     272                 :            :                 /*
     273                 :            :                  * The next task is using a real segment.  Loading the selector
     274                 :            :                  * is sufficient.
     275                 :            :                  */
     276                 :          0 :                 loadseg(which, next_index);
     277                 :            :         }
     278                 :            : }
     279                 :            : 
     280                 :     790744 : static __always_inline void x86_fsgsbase_load(struct thread_struct *prev,
     281                 :            :                                               struct thread_struct *next)
     282                 :            : {
     283                 :     790744 :         load_seg_legacy(prev->fsindex, prev->fsbase,
     284                 :     790744 :                         next->fsindex, next->fsbase, FS);
     285                 :     790744 :         load_seg_legacy(prev->gsindex, prev->gsbase,
     286         [ +  - ]:     790744 :                         next->gsindex, next->gsbase, GS);
     287                 :            : }
     288                 :            : 
     289                 :          0 : static unsigned long x86_fsgsbase_read_task(struct task_struct *task,
     290                 :            :                                             unsigned short selector)
     291                 :            : {
     292                 :          0 :         unsigned short idx = selector >> 3;
     293                 :          0 :         unsigned long base;
     294                 :            : 
     295         [ #  # ]:          0 :         if (likely((selector & SEGMENT_TI_MASK) == 0)) {
     296         [ #  # ]:          0 :                 if (unlikely(idx >= GDT_ENTRIES))
     297                 :            :                         return 0;
     298                 :            : 
     299                 :            :                 /*
     300                 :            :                  * There are no user segments in the GDT with nonzero bases
     301                 :            :                  * other than the TLS segments.
     302                 :            :                  */
     303         [ #  # ]:          0 :                 if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX)
     304                 :            :                         return 0;
     305                 :            : 
     306                 :          0 :                 idx -= GDT_ENTRY_TLS_MIN;
     307                 :          0 :                 base = get_desc_base(&task->thread.tls_array[idx]);
     308                 :            :         } else {
     309                 :            : #ifdef CONFIG_MODIFY_LDT_SYSCALL
     310                 :          0 :                 struct ldt_struct *ldt;
     311                 :            : 
     312                 :            :                 /*
     313                 :            :                  * If performance here mattered, we could protect the LDT
     314                 :            :                  * with RCU.  This is a slow path, though, so we can just
     315                 :            :                  * take the mutex.
     316                 :            :                  */
     317                 :          0 :                 mutex_lock(&task->mm->context.lock);
     318                 :          0 :                 ldt = task->mm->context.ldt;
     319         [ #  # ]:          0 :                 if (unlikely(idx >= ldt->nr_entries))
     320                 :            :                         base = 0;
     321                 :            :                 else
     322                 :          0 :                         base = get_desc_base(ldt->entries + idx);
     323                 :          0 :                 mutex_unlock(&task->mm->context.lock);
     324                 :            : #else
     325                 :            :                 base = 0;
     326                 :            : #endif
     327                 :            :         }
     328                 :            : 
     329                 :            :         return base;
     330                 :            : }
     331                 :            : 
     332                 :          0 : unsigned long x86_fsbase_read_task(struct task_struct *task)
     333                 :            : {
     334                 :          0 :         unsigned long fsbase;
     335                 :            : 
     336         [ #  # ]:          0 :         if (task == current)
     337                 :          0 :                 fsbase = x86_fsbase_read_cpu();
     338         [ #  # ]:          0 :         else if (task->thread.fsindex == 0)
     339                 :          0 :                 fsbase = task->thread.fsbase;
     340                 :            :         else
     341                 :          0 :                 fsbase = x86_fsgsbase_read_task(task, task->thread.fsindex);
     342                 :            : 
     343                 :          0 :         return fsbase;
     344                 :            : }
     345                 :            : 
     346                 :          0 : unsigned long x86_gsbase_read_task(struct task_struct *task)
     347                 :            : {
     348                 :          0 :         unsigned long gsbase;
     349                 :            : 
     350         [ #  # ]:          0 :         if (task == current)
     351                 :          0 :                 gsbase = x86_gsbase_read_cpu_inactive();
     352         [ #  # ]:          0 :         else if (task->thread.gsindex == 0)
     353                 :          0 :                 gsbase = task->thread.gsbase;
     354                 :            :         else
     355                 :          0 :                 gsbase = x86_fsgsbase_read_task(task, task->thread.gsindex);
     356                 :            : 
     357                 :          0 :         return gsbase;
     358                 :            : }
     359                 :            : 
     360                 :        112 : void x86_fsbase_write_task(struct task_struct *task, unsigned long fsbase)
     361                 :            : {
     362         [ #  # ]:          0 :         WARN_ON_ONCE(task == current);
     363                 :            : 
     364                 :        112 :         task->thread.fsbase = fsbase;
     365                 :        112 : }
     366                 :            : 
     367                 :          0 : void x86_gsbase_write_task(struct task_struct *task, unsigned long gsbase)
     368                 :            : {
     369         [ #  # ]:          0 :         WARN_ON_ONCE(task == current);
     370                 :            : 
     371                 :          0 :         task->thread.gsbase = gsbase;
     372                 :          0 : }
     373                 :            : 
     374                 :            : static void
     375                 :     140308 : start_thread_common(struct pt_regs *regs, unsigned long new_ip,
     376                 :            :                     unsigned long new_sp,
     377                 :            :                     unsigned int _cs, unsigned int _ss, unsigned int _ds)
     378                 :            : {
     379         [ -  + ]:     140308 :         WARN_ON_ONCE(regs != current_pt_regs());
     380                 :            : 
     381      [ -  -  + ]:     140308 :         if (static_cpu_has(X86_BUG_NULL_SEG)) {
     382                 :            :                 /* Loading zero below won't clear the base. */
     383                 :          0 :                 loadsegment(fs, __USER_DS);
     384                 :          0 :                 load_gs_index(__USER_DS);
     385                 :            :         }
     386                 :            : 
     387                 :     140308 :         loadsegment(fs, 0);
     388                 :     140308 :         loadsegment(es, _ds);
     389                 :     140308 :         loadsegment(ds, _ds);
     390                 :     140308 :         load_gs_index(0);
     391                 :            : 
     392                 :     140308 :         regs->ip             = new_ip;
     393                 :     140308 :         regs->sp             = new_sp;
     394                 :     140308 :         regs->cs             = _cs;
     395                 :     140308 :         regs->ss             = _ss;
     396                 :     140308 :         regs->flags          = X86_EFLAGS_IF;
     397                 :     140308 : }
     398                 :            : 
     399                 :            : void
     400                 :     140308 : start_thread(struct pt_regs *regs, unsigned long new_ip, unsigned long new_sp)
     401                 :            : {
     402                 :     140308 :         start_thread_common(regs, new_ip, new_sp,
     403                 :            :                             __USER_CS, __USER_DS, 0);
     404                 :     140308 : }
     405                 :            : EXPORT_SYMBOL_GPL(start_thread);
     406                 :            : 
     407                 :            : #ifdef CONFIG_COMPAT
     408                 :          0 : void compat_start_thread(struct pt_regs *regs, u32 new_ip, u32 new_sp)
     409                 :            : {
     410         [ #  # ]:          0 :         start_thread_common(regs, new_ip, new_sp,
     411                 :            :                             test_thread_flag(TIF_X32)
     412                 :            :                             ? __USER_CS : __USER32_CS,
     413                 :            :                             __USER_DS, __USER_DS);
     414                 :          0 : }
     415                 :            : #endif
     416                 :            : 
     417                 :            : /*
     418                 :            :  *      switch_to(x,y) should switch tasks from x to y.
     419                 :            :  *
     420                 :            :  * This could still be optimized:
     421                 :            :  * - fold all the options into a flag word and test it with a single test.
     422                 :            :  * - could test fs/gs bitsliced
     423                 :            :  *
     424                 :            :  * Kprobes not supported here. Set the probe on schedule instead.
     425                 :            :  * Function graph tracer not supported too.
     426                 :            :  */
     427                 :            : __visible __notrace_funcgraph struct task_struct *
     428                 :     790744 : __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
     429                 :            : {
     430                 :     790744 :         struct thread_struct *prev = &prev_p->thread;
     431                 :     790744 :         struct thread_struct *next = &next_p->thread;
     432                 :     790744 :         struct fpu *prev_fpu = &prev->fpu;
     433                 :     790744 :         struct fpu *next_fpu = &next->fpu;
     434                 :     790744 :         int cpu = smp_processor_id();
     435                 :            : 
     436                 :     790744 :         WARN_ON_ONCE(IS_ENABLED(CONFIG_DEBUG_ENTRY) &&
     437                 :            :                      this_cpu_read(irq_count) != -1);
     438                 :            : 
     439         [ +  + ]:     790744 :         if (!test_thread_flag(TIF_NEED_FPU_LOAD))
     440                 :     436285 :                 switch_fpu_prepare(prev_fpu, cpu);
     441                 :            : 
     442                 :            :         /* We must save %fs and %gs before load_TLS() because
     443                 :            :          * %fs and %gs may be cleared by load_TLS().
     444                 :            :          *
     445                 :            :          * (e.g. xen_load_tls())
     446                 :            :          */
     447         [ -  + ]:     790744 :         save_fsgs(prev_p);
     448                 :            : 
     449                 :            :         /*
     450                 :            :          * Load TLS before restoring any segments so that segment loads
     451                 :            :          * reference the correct GDT entries.
     452                 :            :          */
     453                 :     790744 :         load_TLS(next, cpu);
     454                 :            : 
     455                 :            :         /*
     456                 :            :          * Leave lazy mode, flushing any hypercalls made here.  This
     457                 :            :          * must be done after loading TLS entries in the GDT but before
     458                 :            :          * loading segments that might reference them.
     459                 :            :          */
     460                 :     790744 :         arch_end_context_switch(next_p);
     461                 :            : 
     462                 :            :         /* Switch DS and ES.
     463                 :            :          *
     464                 :            :          * Reading them only returns the selectors, but writing them (if
     465                 :            :          * nonzero) loads the full descriptor from the GDT or LDT.  The
     466                 :            :          * LDT for next is loaded in switch_mm, and the GDT is loaded
     467                 :            :          * above.
     468                 :            :          *
     469                 :            :          * We therefore need to write new values to the segment
     470                 :            :          * registers on every context switch unless both the new and old
     471                 :            :          * values are zero.
     472                 :            :          *
     473                 :            :          * Note that we don't need to do anything for CS and SS, as
     474                 :            :          * those are saved and restored as part of pt_regs.
     475                 :            :          */
     476                 :     790744 :         savesegment(es, prev->es);
     477         [ -  + ]:     790744 :         if (unlikely(next->es | prev->es))
     478                 :          0 :                 loadsegment(es, next->es);
     479                 :            : 
     480                 :     790744 :         savesegment(ds, prev->ds);
     481         [ -  + ]:     790744 :         if (unlikely(next->ds | prev->ds))
     482                 :          0 :                 loadsegment(ds, next->ds);
     483                 :            : 
     484         [ +  - ]:     790744 :         x86_fsgsbase_load(prev, next);
     485                 :            : 
     486                 :            :         /*
     487                 :            :          * Switch the PDA and FPU contexts.
     488                 :            :          */
     489                 :     790744 :         this_cpu_write(current_task, next_p);
     490                 :     790744 :         this_cpu_write(cpu_current_top_of_stack, task_top_of_stack(next_p));
     491                 :            : 
     492                 :     790744 :         switch_fpu_finish(next_fpu);
     493                 :            : 
     494                 :            :         /* Reload sp0. */
     495                 :     790744 :         update_task_stack(next_p);
     496                 :            : 
     497                 :     790744 :         switch_to_extra(prev_p, next_p);
     498                 :            : 
     499      [ +  -  - ]:     790744 :         if (static_cpu_has_bug(X86_BUG_SYSRET_SS_ATTRS)) {
     500                 :            :                 /*
     501                 :            :                  * AMD CPUs have a misfeature: SYSRET sets the SS selector but
     502                 :            :                  * does not update the cached descriptor.  As a result, if we
     503                 :            :                  * do SYSRET while SS is NULL, we'll end up in user mode with
     504                 :            :                  * SS apparently equal to __USER_DS but actually unusable.
     505                 :            :                  *
     506                 :            :                  * The straightforward workaround would be to fix it up just
     507                 :            :                  * before SYSRET, but that would slow down the system call
     508                 :            :                  * fast paths.  Instead, we ensure that SS is never NULL in
     509                 :            :                  * system call context.  We do this by replacing NULL SS
     510                 :            :                  * selectors at every context switch.  SYSCALL sets up a valid
     511                 :            :                  * SS, so the only way to get NULL is to re-enter the kernel
     512                 :            :                  * from CPL 3 through an interrupt.  Since that can't happen
     513                 :            :                  * in the same task as a running syscall, we are guaranteed to
     514                 :            :                  * context switch between every interrupt vector entry and a
     515                 :            :                  * subsequent SYSRET.
     516                 :            :                  *
     517                 :            :                  * We read SS first because SS reads are much faster than
     518                 :            :                  * writes.  Out of caution, we force SS to __KERNEL_DS even if
     519                 :            :                  * it previously had a different non-NULL value.
     520                 :            :                  */
     521                 :     790744 :                 unsigned short ss_sel;
     522                 :     790744 :                 savesegment(ss, ss_sel);
     523         [ +  + ]:     790744 :                 if (ss_sel != __KERNEL_DS)
     524                 :      47347 :                         loadsegment(ss, __KERNEL_DS);
     525                 :            :         }
     526                 :            : 
     527                 :            :         /* Load the Intel cache allocation PQR MSR. */
     528                 :     790744 :         resctrl_sched_in();
     529                 :            : 
     530                 :     790744 :         return prev_p;
     531                 :            : }
     532                 :            : 
     533                 :     140308 : void set_personality_64bit(void)
     534                 :            : {
     535                 :            :         /* inherit personality from parent */
     536                 :            : 
     537                 :            :         /* Make sure to be in 64bit mode */
     538                 :     140308 :         clear_thread_flag(TIF_IA32);
     539                 :     140308 :         clear_thread_flag(TIF_ADDR32);
     540                 :     140308 :         clear_thread_flag(TIF_X32);
     541                 :            :         /* Pretend that this comes from a 64bit execve */
     542         [ +  - ]:     140308 :         task_pt_regs(current)->orig_ax = __NR_execve;
     543                 :     140308 :         current_thread_info()->status &= ~TS_COMPAT;
     544                 :            : 
     545                 :            :         /* Ensure the corresponding mm is not marked. */
     546         [ +  - ]:     140308 :         if (current->mm)
     547                 :     140308 :                 current->mm->context.ia32_compat = 0;
     548                 :            : 
     549                 :            :         /* TBD: overwrites user setup. Should have two bits.
     550                 :            :            But 64bit processes have always behaved this way,
     551                 :            :            so it's not too bad. The main problem is just that
     552                 :            :            32bit children are affected again. */
     553                 :     140308 :         current->personality &= ~READ_IMPLIES_EXEC;
     554                 :     140308 : }
     555                 :            : 
     556                 :            : static void __set_personality_x32(void)
     557                 :            : {
     558                 :            : #ifdef CONFIG_X86_X32
     559                 :            :         clear_thread_flag(TIF_IA32);
     560                 :            :         set_thread_flag(TIF_X32);
     561                 :            :         if (current->mm)
     562                 :            :                 current->mm->context.ia32_compat = TIF_X32;
     563                 :            :         current->personality &= ~READ_IMPLIES_EXEC;
     564                 :            :         /*
     565                 :            :          * in_32bit_syscall() uses the presence of the x32 syscall bit
     566                 :            :          * flag to determine compat status.  The x86 mmap() code relies on
     567                 :            :          * the syscall bitness so set x32 syscall bit right here to make
     568                 :            :          * in_32bit_syscall() work during exec().
     569                 :            :          *
     570                 :            :          * Pretend to come from a x32 execve.
     571                 :            :          */
     572                 :            :         task_pt_regs(current)->orig_ax = __NR_x32_execve | __X32_SYSCALL_BIT;
     573                 :            :         current_thread_info()->status &= ~TS_COMPAT;
     574                 :            : #endif
     575                 :            : }
     576                 :            : 
     577                 :          0 : static void __set_personality_ia32(void)
     578                 :            : {
     579                 :            : #ifdef CONFIG_IA32_EMULATION
     580                 :          0 :         set_thread_flag(TIF_IA32);
     581                 :          0 :         clear_thread_flag(TIF_X32);
     582         [ #  # ]:          0 :         if (current->mm)
     583                 :          0 :                 current->mm->context.ia32_compat = TIF_IA32;
     584                 :          0 :         current->personality |= force_personality32;
     585                 :            :         /* Prepare the first "return" to user space */
     586                 :          0 :         task_pt_regs(current)->orig_ax = __NR_ia32_execve;
     587                 :          0 :         current_thread_info()->status |= TS_COMPAT;
     588                 :            : #endif
     589                 :          0 : }
     590                 :            : 
     591                 :          0 : void set_personality_ia32(bool x32)
     592                 :            : {
     593                 :            :         /* Make sure to be in 32bit mode */
     594                 :          0 :         set_thread_flag(TIF_ADDR32);
     595                 :            : 
     596         [ #  # ]:          0 :         if (x32)
     597                 :            :                 __set_personality_x32();
     598                 :            :         else
     599                 :          0 :                 __set_personality_ia32();
     600                 :          0 : }
     601                 :            : EXPORT_SYMBOL_GPL(set_personality_ia32);
     602                 :            : 
     603                 :            : #ifdef CONFIG_CHECKPOINT_RESTORE
     604                 :            : static long prctl_map_vdso(const struct vdso_image *image, unsigned long addr)
     605                 :            : {
     606                 :            :         int ret;
     607                 :            : 
     608                 :            :         ret = map_vdso_once(image, addr);
     609                 :            :         if (ret)
     610                 :            :                 return ret;
     611                 :            : 
     612                 :            :         return (long)image->size;
     613                 :            : }
     614                 :            : #endif
     615                 :            : 
     616                 :     140420 : long do_arch_prctl_64(struct task_struct *task, int option, unsigned long arg2)
     617                 :            : {
     618                 :     140420 :         int ret = 0;
     619                 :            : 
     620   [ -  +  -  -  :     140420 :         switch (option) {
                      - ]
     621                 :            :         case ARCH_SET_GS: {
     622   [ #  #  #  #  :          0 :                 if (unlikely(arg2 >= TASK_SIZE_MAX))
                      # ]
     623                 :            :                         return -EPERM;
     624                 :            : 
     625                 :          0 :                 preempt_disable();
     626                 :            :                 /*
     627                 :            :                  * ARCH_SET_GS has always overwritten the index
     628                 :            :                  * and the base. Zero is the most sensible value
     629                 :            :                  * to put in the index, and is the only value that
     630                 :            :                  * makes any sense if FSGSBASE is unavailable.
     631                 :            :                  */
     632         [ #  # ]:          0 :                 if (task == current) {
     633                 :          0 :                         loadseg(GS, 0);
     634                 :          0 :                         x86_gsbase_write_cpu_inactive(arg2);
     635                 :            : 
     636                 :            :                         /*
     637                 :            :                          * On non-FSGSBASE systems, save_base_legacy() expects
     638                 :            :                          * that we also fill in thread.gsbase.
     639                 :            :                          */
     640                 :          0 :                         task->thread.gsbase = arg2;
     641                 :            : 
     642                 :            :                 } else {
     643                 :          0 :                         task->thread.gsindex = 0;
     644         [ #  # ]:          0 :                         x86_gsbase_write_task(task, arg2);
     645                 :            :                 }
     646                 :          0 :                 preempt_enable();
     647                 :          0 :                 break;
     648                 :            :         }
     649                 :            :         case ARCH_SET_FS: {
     650                 :            :                 /*
     651                 :            :                  * Not strictly needed for %fs, but do it for symmetry
     652                 :            :                  * with %gs
     653                 :            :                  */
     654   [ -  -  +  +  :     140420 :                 if (unlikely(arg2 >= TASK_SIZE_MAX))
                      - ]
     655                 :            :                         return -EPERM;
     656                 :            : 
     657                 :     140420 :                 preempt_disable();
     658                 :            :                 /*
     659                 :            :                  * Set the selector to 0 for the same reason
     660                 :            :                  * as %gs above.
     661                 :            :                  */
     662         [ +  + ]:     140420 :                 if (task == current) {
     663                 :     140308 :                         loadseg(FS, 0);
     664                 :     140308 :                         x86_fsbase_write_cpu(arg2);
     665                 :            : 
     666                 :            :                         /*
     667                 :            :                          * On non-FSGSBASE systems, save_base_legacy() expects
     668                 :            :                          * that we also fill in thread.fsbase.
     669                 :            :                          */
     670                 :     140308 :                         task->thread.fsbase = arg2;
     671                 :            :                 } else {
     672                 :        112 :                         task->thread.fsindex = 0;
     673         [ -  + ]:        112 :                         x86_fsbase_write_task(task, arg2);
     674                 :            :                 }
     675                 :     140420 :                 preempt_enable();
     676                 :     140420 :                 break;
     677                 :            :         }
     678                 :          0 :         case ARCH_GET_FS: {
     679                 :          0 :                 unsigned long base = x86_fsbase_read_task(task);
     680                 :            : 
     681                 :          0 :                 ret = put_user(base, (unsigned long __user *)arg2);
     682                 :          0 :                 break;
     683                 :            :         }
     684                 :          0 :         case ARCH_GET_GS: {
     685                 :          0 :                 unsigned long base = x86_gsbase_read_task(task);
     686                 :            : 
     687                 :          0 :                 ret = put_user(base, (unsigned long __user *)arg2);
     688                 :          0 :                 break;
     689                 :            :         }
     690                 :            : 
     691                 :            : #ifdef CONFIG_CHECKPOINT_RESTORE
     692                 :            : # ifdef CONFIG_X86_X32_ABI
     693                 :            :         case ARCH_MAP_VDSO_X32:
     694                 :            :                 return prctl_map_vdso(&vdso_image_x32, arg2);
     695                 :            : # endif
     696                 :            : # if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION
     697                 :            :         case ARCH_MAP_VDSO_32:
     698                 :            :                 return prctl_map_vdso(&vdso_image_32, arg2);
     699                 :            : # endif
     700                 :            :         case ARCH_MAP_VDSO_64:
     701                 :            :                 return prctl_map_vdso(&vdso_image_64, arg2);
     702                 :            : #endif
     703                 :            : 
     704                 :            :         default:
     705                 :            :                 ret = -EINVAL;
     706                 :            :                 break;
     707                 :            :         }
     708                 :            : 
     709                 :     140420 :         return ret;
     710                 :            : }
     711                 :            : 
     712                 :     280616 : SYSCALL_DEFINE2(arch_prctl, int, option, unsigned long, arg2)
     713                 :            : {
     714                 :     140308 :         long ret;
     715                 :            : 
     716                 :     140308 :         ret = do_arch_prctl_64(current, option, arg2);
     717         [ -  + ]:     140308 :         if (ret == -EINVAL)
     718                 :          0 :                 ret = do_arch_prctl_common(current, option, arg2);
     719                 :            : 
     720                 :     140308 :         return ret;
     721                 :            : }
     722                 :            : 
     723                 :            : #ifdef CONFIG_IA32_EMULATION
     724                 :          0 : COMPAT_SYSCALL_DEFINE2(arch_prctl, int, option, unsigned long, arg2)
     725                 :            : {
     726                 :          0 :         return do_arch_prctl_common(current, option, arg2);
     727                 :            : }
     728                 :            : #endif
     729                 :            : 
     730                 :          0 : unsigned long KSTK_ESP(struct task_struct *task)
     731                 :            : {
     732                 :          0 :         return task_pt_regs(task)->sp;
     733                 :            : }

Generated by: LCOV version 1.14