x86/entry/entry_64.S

945  * only on return from non-NMI IST interrupts that came
1111 	 * the iretq it performs will take us out of NMI context.
1113 	 * NMI is using the top of the stack of the previous NMI. We
1114 	 * can't let it execute because the nested NMI will corrupt the
1115 	 * stack of the previous NMI. NMI handlers are not re-entrant
1122 	 *  is an NMI stack.
1123 	 *  If the variable is not set and the stack is not the NMI
1129 	 *    o Continue processing the NMI
1130 	 *  If the variable is set or the previous stack is the NMI stack:
1132 	 *    o return back to the first NMI
1134 	 * Now on exit of the first NMI, we first clear the stack variable
1135 	 * The NMI stack will tell any nested NMIs at that point that it is
1137 	 * a nested NMI that updated the copy interrupt stack frame, a
1139 	 * NMI.
1157 	 * NMI from user mode.  We need to run on the thread stack, but we
1164 	 * stacks lest we corrupt the "NMI executing" variable.
1189 	 * done with the NMI stack.
1213 	 * | "NMI executing" variable                                |
1217 	 * | iret RFLAGS      } by a nested NMI to force another     |
1223 	 * | outermost RFLAGS      } NMI processing is done.         |
1235 	 * That will either return for real or it will loop back into NMI
1244 	 * Determine whether we're a nested NMI.
1247 	 * end_repeat_nmi, then we are a nested NMI.  We must not
1249 	 * the outer NMI.  That's okay; the outer NMI handler is
1251 	 * the outer NMI.
1263 	 * Now check "NMI executing".  If it's set, then we're nested.
1264 	 * This will not detect if we interrupted an outer NMI just
1271 	 * Now test if the previous stack was an NMI stack.  This covers
1272 	 * the case where we interrupt an outer NMI after it clears
1273 	 * "NMI executing" but before IRET.  We need to be careful, though:
1274 	 * there is one case in which RSP could point to the NMI stack
1275 	 * despite there being no NMI active: naughty userspace controls
1280 	 * "NMI executing".
1283 	/* Compare the NMI stack (rdx) with the stack we came from (4*8(%rsp)) */
1285 	/* If the stack pointer is above the NMI stack, this is a normal NMI */
1290 	/* If it is below the NMI stack, it is a normal NMI */
1293 	/* Ah, it is within the NMI stack. */
1298 	/* This is a nested NMI. */
1303 	 * iteration of NMI handling.
1326 	/* Make room for "NMI executing". */
1359 	 * If there was a nested NMI, the first NMI's iret will return
1361 	 * nested NMI. The nested NMI checks the interrupted RIP to see
1363 	 * it will just return, as we are about to repeat an NMI anyway.
1365 	 * NMI will update.
1368 	 * we're repeating an NMI, gsbase has the same value that it had on
1370 	 * gsbase if needed before we call exc_nmi().  "NMI executing"
1373 	movq	$1, 10*8(%rsp)		/* Set "NMI executing". */
1389 	 * Everything below this point can be preempted by a nested NMI.
1390 	 * If this happens, then the inner NMI will change the "iret"
1397 	 * as we should not be calling schedule in NMI context.
1398 	 * Even with normal interrupts enabled. An NMI should not be
1445 	 * Clear "NMI executing".  Set DF first so that we can easily
1454 	movq	$0, 5*8(%rsp)		/* clear "NMI executing" */
1458 	 * NMI in kernel after user state is restored. For an unprivileged user
1463 	 * iretq reads the "iret" frame and exits the NMI stack in a