spi-topcliff-pch: add recovery processing in case wait-event timeout
[zen-stable.git] / arch / x86 / xen / xen-asm_32.S
blobb040b0e518caf0a0fe382999b36c2c04e7344860
1 /*
2  * Asm versions of Xen pv-ops, suitable for either direct use or
3  * inlining.  The inline versions are the same as the direct-use
4  * versions, with the pre- and post-amble chopped off.
5  *
6  * This code is encoded for size rather than absolute efficiency, with
7  * a view to being able to inline as much as possible.
8  *
9  * We only bother with direct forms (ie, vcpu in pda) of the
10  * operations here; the indirect forms are better handled in C, since
11  * they're generally too large to inline anyway.
12  */
14 #include <asm/thread_info.h>
15 #include <asm/processor-flags.h>
16 #include <asm/segment.h>
18 #include <xen/interface/xen.h>
20 #include "xen-asm.h"
23  * Force an event check by making a hypercall, but preserve regs
24  * before making the call.
25  */
26 check_events:
27         push %eax
28         push %ecx
29         push %edx
30         call xen_force_evtchn_callback
31         pop %edx
32         pop %ecx
33         pop %eax
34         ret
37  * We can't use sysexit directly, because we're not running in ring0.
38  * But we can easily fake it up using iret.  Assuming xen_sysexit is
39  * jumped to with a standard stack frame, we can just strip it back to
40  * a standard iret frame and use iret.
41  */
42 ENTRY(xen_sysexit)
43         movl PT_EAX(%esp), %eax                 /* Shouldn't be necessary? */
44         orl $X86_EFLAGS_IF, PT_EFLAGS(%esp)
45         lea PT_EIP(%esp), %esp
47         jmp xen_iret
48 ENDPROC(xen_sysexit)
51  * This is run where a normal iret would be run, with the same stack setup:
52  *      8: eflags
53  *      4: cs
54  *      esp-> 0: eip
55  *
56  * This attempts to make sure that any pending events are dealt with
57  * on return to usermode, but there is a small window in which an
58  * event can happen just before entering usermode.  If the nested
59  * interrupt ends up setting one of the TIF_WORK_MASK pending work
60  * flags, they will not be tested again before returning to
61  * usermode. This means that a process can end up with pending work,
62  * which will be unprocessed until the process enters and leaves the
63  * kernel again, which could be an unbounded amount of time.  This
64  * means that a pending signal or reschedule event could be
65  * indefinitely delayed.
66  *
67  * The fix is to notice a nested interrupt in the critical window, and
68  * if one occurs, then fold the nested interrupt into the current
69  * interrupt stack frame, and re-process it iteratively rather than
70  * recursively.  This means that it will exit via the normal path, and
71  * all pending work will be dealt with appropriately.
72  *
73  * Because the nested interrupt handler needs to deal with the current
74  * stack state in whatever form its in, we keep things simple by only
75  * using a single register which is pushed/popped on the stack.
76  */
77 ENTRY(xen_iret)
78         /* test eflags for special cases */
79         testl $(X86_EFLAGS_VM | XEN_EFLAGS_NMI), 8(%esp)
80         jnz hyper_iret
82         push %eax
83         ESP_OFFSET=4    # bytes pushed onto stack
85         /*
86          * Store vcpu_info pointer for easy access.  Do it this way to
87          * avoid having to reload %fs
88          */
89 #ifdef CONFIG_SMP
90         GET_THREAD_INFO(%eax)
91         movl TI_cpu(%eax), %eax
92         movl __per_cpu_offset(,%eax,4), %eax
93         mov xen_vcpu(%eax), %eax
94 #else
95         movl xen_vcpu, %eax
96 #endif
98         /* check IF state we're restoring */
99         testb $X86_EFLAGS_IF>>8, 8+1+ESP_OFFSET(%esp)
101         /*
102          * Maybe enable events.  Once this happens we could get a
103          * recursive event, so the critical region starts immediately
104          * afterwards.  However, if that happens we don't end up
105          * resuming the code, so we don't have to be worried about
106          * being preempted to another CPU.
107          */
108         setz XEN_vcpu_info_mask(%eax)
109 xen_iret_start_crit:
111         /* check for unmasked and pending */
112         cmpw $0x0001, XEN_vcpu_info_pending(%eax)
114         /*
115          * If there's something pending, mask events again so we can
116          * jump back into xen_hypervisor_callback. Otherwise do not
117          * touch XEN_vcpu_info_mask.
118          */
119         jne 1f
120         movb $1, XEN_vcpu_info_mask(%eax)
122 1:      popl %eax
124         /*
125          * From this point on the registers are restored and the stack
126          * updated, so we don't need to worry about it if we're
127          * preempted
128          */
129 iret_restore_end:
131         /*
132          * Jump to hypervisor_callback after fixing up the stack.
133          * Events are masked, so jumping out of the critical region is
134          * OK.
135          */
136         je xen_hypervisor_callback
138 1:      iret
139 xen_iret_end_crit:
140 .section __ex_table, "a"
141         .align 4
142         .long 1b, iret_exc
143 .previous
145 hyper_iret:
146         /* put this out of line since its very rarely used */
147         jmp hypercall_page + __HYPERVISOR_iret * 32
149         .globl xen_iret_start_crit, xen_iret_end_crit
152  * This is called by xen_hypervisor_callback in entry.S when it sees
153  * that the EIP at the time of interrupt was between
154  * xen_iret_start_crit and xen_iret_end_crit.  We're passed the EIP in
155  * %eax so we can do a more refined determination of what to do.
157  * The stack format at this point is:
158  *      ----------------
159  *       ss             : (ss/esp may be present if we came from usermode)
160  *       esp            :
161  *       eflags         }  outer exception info
162  *       cs             }
163  *       eip            }
164  *      ---------------- <- edi (copy dest)
165  *       eax            :  outer eax if it hasn't been restored
166  *      ----------------
167  *       eflags         }  nested exception info
168  *       cs             }   (no ss/esp because we're nested
169  *       eip            }    from the same ring)
170  *       orig_eax       }<- esi (copy src)
171  *       - - - - - - - -
172  *       fs             }
173  *       es             }
174  *       ds             }  SAVE_ALL state
175  *       eax            }
176  *        :             :
177  *       ebx            }<- esp
178  *      ----------------
180  * In order to deliver the nested exception properly, we need to shift
181  * everything from the return addr up to the error code so it sits
182  * just under the outer exception info.  This means that when we
183  * handle the exception, we do it in the context of the outer
184  * exception rather than starting a new one.
186  * The only caveat is that if the outer eax hasn't been restored yet
187  * (ie, it's still on stack), we need to insert its value into the
188  * SAVE_ALL state before going on, since it's usermode state which we
189  * eventually need to restore.
190  */
191 ENTRY(xen_iret_crit_fixup)
192         /*
193          * Paranoia: Make sure we're really coming from kernel space.
194          * One could imagine a case where userspace jumps into the
195          * critical range address, but just before the CPU delivers a
196          * GP, it decides to deliver an interrupt instead.  Unlikely?
197          * Definitely.  Easy to avoid?  Yes.  The Intel documents
198          * explicitly say that the reported EIP for a bad jump is the
199          * jump instruction itself, not the destination, but some
200          * virtual environments get this wrong.
201          */
202         movl PT_CS(%esp), %ecx
203         andl $SEGMENT_RPL_MASK, %ecx
204         cmpl $USER_RPL, %ecx
205         je 2f
207         lea PT_ORIG_EAX(%esp), %esi
208         lea PT_EFLAGS(%esp), %edi
210         /*
211          * If eip is before iret_restore_end then stack
212          * hasn't been restored yet.
213          */
214         cmp $iret_restore_end, %eax
215         jae 1f
217         movl 0+4(%edi), %eax            /* copy EAX (just above top of frame) */
218         movl %eax, PT_EAX(%esp)
220         lea ESP_OFFSET(%edi), %edi      /* move dest up over saved regs */
222         /* set up the copy */
223 1:      std
224         mov $PT_EIP / 4, %ecx           /* saved regs up to orig_eax */
225         rep movsl
226         cld
228         lea 4(%edi), %esp               /* point esp to new frame */
229 2:      jmp xen_do_upcall