arch/x86/kernel/fpu/core.c

   1 /*
   2  *  Copyright (C) 1994 Linus Torvalds
   3  *
   4  *  Pentium III FXSR, SSE support
   5  *  General FPU state handling cleanups
   6  *      Gareth Hughes <gareth@valinux.com>, May 2000
   7  */
   8 #include <asm/fpu/internal.h>
   9 #include <asm/fpu/regset.h>
  10 #include <asm/fpu/signal.h>
  11 #include <asm/fpu/types.h>
  12 #include <asm/traps.h>
  13 #include <asm/irq_regs.h>
  14
  15 #include <linux/hardirq.h>
  16 #include <linux/pkeys.h>
  17
  18 #define CREATE_TRACE_POINTS
  19 #include <asm/trace/fpu.h>
  20
  21 /*
  22  * Represents the initial FPU state. It's mostly (but not completely) zeroes,
  23  * depending on the FPU hardware format:
  24  */
  25 union fpregs_state init_fpstate __read_mostly;
  26
  27 /*
  28  * Track whether the kernel is using the FPU state
  29  * currently.
  30  *
  31  * This flag is used:
  32  *
  33  *   - by IRQ context code to potentially use the FPU
  34  *     if it's unused.
  35  *
  36  *   - to debug kernel_fpu_begin()/end() correctness
  37  */
  38 static DEFINE_PER_CPU(bool, in_kernel_fpu);
  39
  40 /*
  41  * Track which context is using the FPU on the CPU:
  42  */
  43 DEFINE_PER_CPU(struct fpu *, fpu_fpregs_owner_ctx);
  44
  45 static void kernel_fpu_disable(void)
  46 {
  47         WARN_ON_FPU(this_cpu_read(in_kernel_fpu));
  48         this_cpu_write(in_kernel_fpu, true);
  49 }
  50
  51 static void kernel_fpu_enable(void)
  52 {
  53         WARN_ON_FPU(!this_cpu_read(in_kernel_fpu));
  54         this_cpu_write(in_kernel_fpu, false);
  55 }
  56
  57 static bool kernel_fpu_disabled(void)
  58 {
  59         return this_cpu_read(in_kernel_fpu);
  60 }
  61
  62 static bool interrupted_kernel_fpu_idle(void)
  63 {
  64         return !kernel_fpu_disabled();
  65 }
  66
  67 /*
  68  * Were we in user mode (or vm86 mode) when we were
  69  * interrupted?
  70  *
  71  * Doing kernel_fpu_begin/end() is ok if we are running
  72  * in an interrupt context from user mode - we'll just
  73  * save the FPU state as required.
  74  */
  75 static bool interrupted_user_mode(void)
  76 {
  77         struct pt_regs *regs = get_irq_regs();
  78         return regs && user_mode(regs);
  79 }
  80
  81 /*
  82  * Can we use the FPU in kernel mode with the
  83  * whole "kernel_fpu_begin/end()" sequence?
  84  *
  85  * It's always ok in process context (ie "not interrupt")
  86  * but it is sometimes ok even from an irq.
  87  */
  88 bool irq_fpu_usable(void)
  89 {
  90         return !in_interrupt() ||
  91                 interrupted_user_mode() ||
  92                 interrupted_kernel_fpu_idle();
  93 }
  94 EXPORT_SYMBOL(irq_fpu_usable);
  95
  96 static void __kernel_fpu_begin(void)
  97 {
  98         struct fpu *fpu = &current->thread.fpu;
  99
 100         WARN_ON_FPU(!irq_fpu_usable());
 101
 102         kernel_fpu_disable();
 103
 104         if (fpu->initialized) {
 105                 /*
 106                  * Ignore return value -- we don't care if reg state
 107                  * is clobbered.
 108                  */
 109                 copy_fpregs_to_fpstate(fpu);
 110         } else {
 111                 __cpu_invalidate_fpregs_state();
 112         }
 113 }
 114
 115 static void __kernel_fpu_end(void)
 116 {
 117         struct fpu *fpu = &current->thread.fpu;
 118
 119         if (fpu->initialized)
 120                 copy_kernel_to_fpregs(&fpu->state);
 121
 122         kernel_fpu_enable();
 123 }
 124
 125 void kernel_fpu_begin(void)
 126 {
 127         preempt_disable();
 128         __kernel_fpu_begin();
 129 }
 130 EXPORT_SYMBOL_GPL(kernel_fpu_begin);
 131
 132 void kernel_fpu_end(void)
 133 {
 134         __kernel_fpu_end();
 135         preempt_enable();
 136 }
 137 EXPORT_SYMBOL_GPL(kernel_fpu_end);
 138
 139 /*
 140  * Save the FPU state (mark it for reload if necessary):
 141  *
 142  * This only ever gets called for the current task.
 143  */
 144 void fpu__save(struct fpu *fpu)
 145 {
 146         WARN_ON_FPU(fpu != &current->thread.fpu);
 147
 148         preempt_disable();
 149         trace_x86_fpu_before_save(fpu);
 150         if (fpu->initialized) {
 151                 if (!copy_fpregs_to_fpstate(fpu)) {
 152                         copy_kernel_to_fpregs(&fpu->state);
 153                 }
 154         }
 155         trace_x86_fpu_after_save(fpu);
 156         preempt_enable();
 157 }
 158 EXPORT_SYMBOL_GPL(fpu__save);
 159
 160 /*
 161  * Legacy x87 fpstate state init:
 162  */
 163 static inline void fpstate_init_fstate(struct fregs_state *fp)
 164 {
 165         fp->cwd = 0xffff037fu;
 166         fp->swd = 0xffff0000u;
 167         fp->twd = 0xffffffffu;
 168         fp->fos = 0xffff0000u;
 169 }
 170
 171 void fpstate_init(union fpregs_state *state)
 172 {
 173         if (!static_cpu_has(X86_FEATURE_FPU)) {
 174                 fpstate_init_soft(&state->soft);
 175                 return;
 176         }
 177
 178         memset(state, 0, fpu_kernel_xstate_size);
 179
 180         if (static_cpu_has(X86_FEATURE_XSAVES))
 181                 fpstate_init_xstate(&state->xsave);
 182         if (static_cpu_has(X86_FEATURE_FXSR))
 183                 fpstate_init_fxstate(&state->fxsave);
 184         else
 185                 fpstate_init_fstate(&state->fsave);
 186 }
 187 EXPORT_SYMBOL_GPL(fpstate_init);
 188
 189 int fpu__copy(struct fpu *dst_fpu, struct fpu *src_fpu)
 190 {
 191         dst_fpu->last_cpu = -1;
 192
 193         if (!src_fpu->initialized || !static_cpu_has(X86_FEATURE_FPU))
 194                 return 0;
 195
 196         WARN_ON_FPU(src_fpu != &current->thread.fpu);
 197
 198         /*
 199          * Don't let 'init optimized' areas of the XSAVE area
 200          * leak into the child task:
 201          */
 202         memset(&dst_fpu->state.xsave, 0, fpu_kernel_xstate_size);
 203
 204         /*
 205          * Save current FPU registers directly into the child
 206          * FPU context, without any memory-to-memory copying.
 207          *
 208          * ( The function 'fails' in the FNSAVE case, which destroys
 209          *   register contents so we have to copy them back. )
 210          */
 211         if (!copy_fpregs_to_fpstate(dst_fpu)) {
 212                 memcpy(&src_fpu->state, &dst_fpu->state, fpu_kernel_xstate_size);
 213                 copy_kernel_to_fpregs(&src_fpu->state);
 214         }
 215
 216         trace_x86_fpu_copy_src(src_fpu);
 217         trace_x86_fpu_copy_dst(dst_fpu);
 218
 219         return 0;
 220 }
 221
 222 /*
 223  * Activate the current task's in-memory FPU context,
 224  * if it has not been used before:
 225  */
 226 void fpu__initialize(struct fpu *fpu)
 227 {
 228         WARN_ON_FPU(fpu != &current->thread.fpu);
 229
 230         if (!fpu->initialized) {
 231                 fpstate_init(&fpu->state);
 232                 trace_x86_fpu_init_state(fpu);
 233
 234                 trace_x86_fpu_activate_state(fpu);
 235                 /* Safe to do for the current task: */
 236                 fpu->initialized = 1;
 237         }
 238 }
 239 EXPORT_SYMBOL_GPL(fpu__initialize);
 240
 241 /*
 242  * This function must be called before we read a task's fpstate.
 243  *
 244  * There's two cases where this gets called:
 245  *
 246  * - for the current task (when coredumping), in which case we have
 247  *   to save the latest FPU registers into the fpstate,
 248  *
 249  * - or it's called for stopped tasks (ptrace), in which case the
 250  *   registers were already saved by the context-switch code when
 251  *   the task scheduled out - we only have to initialize the registers
 252  *   if they've never been initialized.
 253  *
 254  * If the task has used the FPU before then save it.
 255  */
 256 void fpu__prepare_read(struct fpu *fpu)
 257 {
 258         if (fpu == &current->thread.fpu) {
 259                 fpu__save(fpu);
 260         } else {
 261                 if (!fpu->initialized) {
 262                         fpstate_init(&fpu->state);
 263                         trace_x86_fpu_init_state(fpu);
 264
 265                         trace_x86_fpu_activate_state(fpu);
 266                         /* Safe to do for current and for stopped child tasks: */
 267                         fpu->initialized = 1;
 268                 }
 269         }
 270 }
 271
 272 /*
 273  * This function must be called before we write a task's fpstate.
 274  *
 275  * If the task has used the FPU before then invalidate any cached FPU registers.
 276  * If the task has not used the FPU before then initialize its fpstate.
 277  *
 278  * After this function call, after registers in the fpstate are
 279  * modified and the child task has woken up, the child task will
 280  * restore the modified FPU state from the modified context. If we
 281  * didn't clear its cached status here then the cached in-registers
 282  * state pending on its former CPU could be restored, corrupting
 283  * the modifications.
 284  */
 285 void fpu__prepare_write(struct fpu *fpu)
 286 {
 287         /*
 288          * Only stopped child tasks can be used to modify the FPU
 289          * state in the fpstate buffer:
 290          */
 291         WARN_ON_FPU(fpu == &current->thread.fpu);
 292
 293         if (fpu->initialized) {
 294                 /* Invalidate any cached state: */
 295                 __fpu_invalidate_fpregs_state(fpu);
 296         } else {
 297                 fpstate_init(&fpu->state);
 298                 trace_x86_fpu_init_state(fpu);
 299
 300                 trace_x86_fpu_activate_state(fpu);
 301                 /* Safe to do for stopped child tasks: */
 302                 fpu->initialized = 1;
 303         }
 304 }
 305
 306 /*
 307  * 'fpu__restore()' is called to copy FPU registers from
 308  * the FPU fpstate to the live hw registers and to activate
 309  * access to the hardware registers, so that FPU instructions
 310  * can be used afterwards.
 311  *
 312  * Must be called with kernel preemption disabled (for example
 313  * with local interrupts disabled, as it is in the case of
 314  * do_device_not_available()).
 315  */
 316 void fpu__restore(struct fpu *fpu)
 317 {
 318         fpu__initialize(fpu);
 319
 320         /* Avoid __kernel_fpu_begin() right after fpregs_activate() */
 321         kernel_fpu_disable();
 322         trace_x86_fpu_before_restore(fpu);
 323         fpregs_activate(fpu);
 324         copy_kernel_to_fpregs(&fpu->state);
 325         trace_x86_fpu_after_restore(fpu);
 326         kernel_fpu_enable();
 327 }
 328 EXPORT_SYMBOL_GPL(fpu__restore);
 329
 330 /*
 331  * Drops current FPU state: deactivates the fpregs and
 332  * the fpstate. NOTE: it still leaves previous contents
 333  * in the fpregs in the eager-FPU case.
 334  *
 335  * This function can be used in cases where we know that
 336  * a state-restore is coming: either an explicit one,
 337  * or a reschedule.
 338  */
 339 void fpu__drop(struct fpu *fpu)
 340 {
 341         preempt_disable();
 342
 343         if (fpu == &current->thread.fpu) {
 344                 if (fpu->initialized) {
 345                         /* Ignore delayed exceptions from user space */
 346                         asm volatile("1: fwait\n"
 347                                      "2:\n"
 348                                      _ASM_EXTABLE(1b, 2b));
 349                         fpregs_deactivate(fpu);
 350                 }
 351         }
 352
 353         fpu->initialized = 0;
 354
 355         trace_x86_fpu_dropped(fpu);
 356
 357         preempt_enable();
 358 }
 359
 360 /*
 361  * Clear FPU registers by setting them up from
 362  * the init fpstate:
 363  */
 364 static inline void copy_init_fpstate_to_fpregs(void)
 365 {
 366         if (use_xsave())
 367                 copy_kernel_to_xregs(&init_fpstate.xsave, -1);
 368         else if (static_cpu_has(X86_FEATURE_FXSR))
 369                 copy_kernel_to_fxregs(&init_fpstate.fxsave);
 370         else
 371                 copy_kernel_to_fregs(&init_fpstate.fsave);
 372
 373         if (boot_cpu_has(X86_FEATURE_OSPKE))
 374                 copy_init_pkru_to_fpregs();
 375 }
 376
 377 /*
 378  * Clear the FPU state back to init state.
 379  *
 380  * Called by sys_execve(), by the signal handler code and by various
 381  * error paths.
 382  */
 383 void fpu__clear(struct fpu *fpu)
 384 {
 385         WARN_ON_FPU(fpu != &current->thread.fpu); /* Almost certainly an anomaly */
 386
 387         fpu__drop(fpu);
 388
 389         /*
 390          * Make sure fpstate is cleared and initialized.
 391          */
 392         if (static_cpu_has(X86_FEATURE_FPU)) {
 393                 preempt_disable();
 394                 fpu__initialize(fpu);
 395                 user_fpu_begin();
 396                 copy_init_fpstate_to_fpregs();
 397                 preempt_enable();
 398         }
 399 }
 400
 401 /*
 402  * x87 math exception handling:
 403  */
 404
 405 int fpu__exception_code(struct fpu *fpu, int trap_nr)
 406 {
 407         int err;
 408
 409         if (trap_nr == X86_TRAP_MF) {
 410                 unsigned short cwd, swd;
 411                 /*
 412                  * (~cwd & swd) will mask out exceptions that are not set to unmasked
 413                  * status.  0x3f is the exception bits in these regs, 0x200 is the
 414                  * C1 reg you need in case of a stack fault, 0x040 is the stack
 415                  * fault bit.  We should only be taking one exception at a time,
 416                  * so if this combination doesn't produce any single exception,
 417                  * then we have a bad program that isn't synchronizing its FPU usage
 418                  * and it will suffer the consequences since we won't be able to
 419                  * fully reproduce the context of the exception.
 420                  */
 421                 if (boot_cpu_has(X86_FEATURE_FXSR)) {
 422                         cwd = fpu->state.fxsave.cwd;
 423                         swd = fpu->state.fxsave.swd;
 424                 } else {
 425                         cwd = (unsigned short)fpu->state.fsave.cwd;
 426                         swd = (unsigned short)fpu->state.fsave.swd;
 427                 }
 428
 429                 err = swd & ~cwd;
 430         } else {
 431                 /*
 432                  * The SIMD FPU exceptions are handled a little differently, as there
 433                  * is only a single status/control register.  Thus, to determine which
 434                  * unmasked exception was caught we must mask the exception mask bits
 435                  * at 0x1f80, and then use these to mask the exception bits at 0x3f.
 436                  */
 437                 unsigned short mxcsr = MXCSR_DEFAULT;
 438
 439                 if (boot_cpu_has(X86_FEATURE_XMM))
 440                         mxcsr = fpu->state.fxsave.mxcsr;
 441
 442                 err = ~(mxcsr >> 7) & mxcsr;
 443         }
 444
 445         if (err & 0x001) {      /* Invalid op */
 446                 /*
 447                  * swd & 0x240 == 0x040: Stack Underflow
 448                  * swd & 0x240 == 0x240: Stack Overflow
 449                  * User must clear the SF bit (0x40) if set
 450                  */
 451                 return FPE_FLTINV;
 452         } else if (err & 0x004) { /* Divide by Zero */
 453                 return FPE_FLTDIV;
 454         } else if (err & 0x008) { /* Overflow */
 455                 return FPE_FLTOVF;
 456         } else if (err & 0x012) { /* Denormal, Underflow */
 457                 return FPE_FLTUND;
 458         } else if (err & 0x020) { /* Precision */
 459                 return FPE_FLTRES;
 460         }
 461
 462         /*
 463          * If we're using IRQ 13, or supposedly even some trap
 464          * X86_TRAP_MF implementations, it's possible
 465          * we get a spurious trap, which is not an error.
 466          */
 467         return 0;
 468 }