initial commit
[freebsd-arm:freebsd-arm.git] / amd64 / amd64 / support.S
1 /*-
2  * Copyright (c) 2003 Peter Wemm.
3  * Copyright (c) 1993 The Regents of the University of California.
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  * 4. Neither the name of the University nor the names of its contributors
15  *    may be used to endorse or promote products derived from this software
16  *    without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28  * SUCH DAMAGE.
29  *
30  * $FreeBSD$
31  */
32
33 #include "opt_ddb.h"
34
35 #include <machine/asmacros.h>
36 #include <machine/intr_machdep.h>
37 #include <machine/pmap.h>
38
39 #include "assym.s"
40
41         .data
42         ALIGN_DATA
43         .globl  intrcnt, eintrcnt
44 intrcnt:
45         .space  INTRCNT_COUNT * 8
46 eintrcnt:
47
48         .globl  intrnames, eintrnames
49 intrnames:
50         .space  INTRCNT_COUNT * (MAXCOMLEN + 1)
51 eintrnames:
52
53         .text
54
55 /*
56  * bcopy family
57  * void bzero(void *buf, u_int len)
58  */
59
60 /* done */
61 ENTRY(bzero)
62         movq    %rsi,%rcx
63         xorl    %eax,%eax
64         shrq    $3,%rcx
65         cld
66         rep
67         stosq
68         movq    %rsi,%rcx
69         andq    $7,%rcx
70         rep
71         stosb
72         ret
73 END(bzero)
74         
75 /* Address: %rdi */
76 ENTRY(pagezero)
77         movq    $-PAGE_SIZE,%rdx
78         subq    %rdx,%rdi
79         xorl    %eax,%eax
80 1:
81         movnti  %rax,(%rdi,%rdx)
82         movnti  %rax,8(%rdi,%rdx)
83         movnti  %rax,16(%rdi,%rdx)
84         movnti  %rax,24(%rdi,%rdx)
85         addq    $32,%rdx
86         jne     1b
87         sfence
88         ret
89 END(pagezero)
90
91 ENTRY(bcmp)
92         movq    %rdx,%rcx
93         shrq    $3,%rcx
94         cld                                     /* compare forwards */
95         repe
96         cmpsq
97         jne     1f
98
99         movq    %rdx,%rcx
100         andq    $7,%rcx
101         repe
102         cmpsb
103 1:
104         setne   %al
105         movsbl  %al,%eax
106         ret
107 END(bcmp)
108
109 /*
110  * bcopy(src, dst, cnt)
111  *       rdi, rsi, rdx
112  *  ws@tools.de     (Wolfgang Solfrank, TooLs GmbH) +49-228-985800
113  */
114 ENTRY(bcopy)
115         xchgq   %rsi,%rdi
116         movq    %rdx,%rcx
117
118         movq    %rdi,%rax
119         subq    %rsi,%rax
120         cmpq    %rcx,%rax                       /* overlapping && src < dst? */
121         jb      1f
122
123         shrq    $3,%rcx                         /* copy by 64-bit words */
124         cld                                     /* nope, copy forwards */
125         rep
126         movsq
127         movq    %rdx,%rcx
128         andq    $7,%rcx                         /* any bytes left? */
129         rep
130         movsb
131         ret
132
133         /* ALIGN_TEXT */
134 1:
135         addq    %rcx,%rdi                       /* copy backwards */
136         addq    %rcx,%rsi
137         decq    %rdi
138         decq    %rsi
139         andq    $7,%rcx                         /* any fractional bytes? */
140         std
141         rep
142         movsb
143         movq    %rdx,%rcx                       /* copy remainder by 32-bit words */
144         shrq    $3,%rcx
145         subq    $7,%rsi
146         subq    $7,%rdi
147         rep
148         movsq
149         cld
150         ret
151 END(bcopy)
152         
153 /*
154  * Note: memcpy does not support overlapping copies
155  */
156 ENTRY(memcpy)
157         movq    %rdx,%rcx
158         shrq    $3,%rcx                         /* copy by 64-bit words */
159         cld                                     /* copy forwards */
160         rep
161         movsq
162         movq    %rdx,%rcx
163         andq    $7,%rcx                         /* any bytes left? */
164         rep
165         movsb
166         ret
167 END(memcpy)
168
169 /*
170  * pagecopy(%rdi=from, %rsi=to)
171  */
172 ENTRY(pagecopy)
173         movq    $-PAGE_SIZE,%rax
174         movq    %rax,%rdx
175         subq    %rax,%rdi
176         subq    %rax,%rsi
177 1:
178         prefetchnta (%rdi,%rax)
179         addq    $64,%rax
180         jne     1b
181 2:
182         movq    (%rdi,%rdx),%rax
183         movnti  %rax,(%rsi,%rdx)
184         movq    8(%rdi,%rdx),%rax
185         movnti  %rax,8(%rsi,%rdx)
186         movq    16(%rdi,%rdx),%rax
187         movnti  %rax,16(%rsi,%rdx)
188         movq    24(%rdi,%rdx),%rax
189         movnti  %rax,24(%rsi,%rdx)
190         addq    $32,%rdx
191         jne     2b
192         sfence
193         ret
194 END(pagecopy)
195
196 /* fillw(pat, base, cnt) */  
197 /*       %rdi,%rsi, %rdx */
198 ENTRY(fillw)
199         movq    %rdi,%rax   
200         movq    %rsi,%rdi
201         movq    %rdx,%rcx
202         cld
203         rep
204         stosw
205         ret
206 END(fillw)
207
208 /*****************************************************************************/
209 /* copyout and fubyte family                                                 */
210 /*****************************************************************************/
211 /*
212  * Access user memory from inside the kernel. These routines should be
213  * the only places that do this.
214  *
215  * These routines set curpcb->onfault for the time they execute. When a
216  * protection violation occurs inside the functions, the trap handler
217  * returns to *curpcb->onfault instead of the function.
218  */
219
220 /*
221  * copyout(from_kernel, to_user, len)  - MP SAFE
222  *         %rdi,        %rsi,    %rdx
223  */
224 ENTRY(copyout)
225         movq    PCPU(CURPCB),%rax
226         movq    $copyout_fault,PCB_ONFAULT(%rax)
227         testq   %rdx,%rdx                       /* anything to do? */
228         jz      done_copyout
229
230         /*
231          * Check explicitly for non-user addresses.  If 486 write protection
232          * is being used, this check is essential because we are in kernel
233          * mode so the h/w does not provide any protection against writing
234          * kernel addresses.
235          */
236
237         /*
238          * First, prevent address wrapping.
239          */
240         movq    %rsi,%rax
241         addq    %rdx,%rax
242         jc      copyout_fault
243 /*
244  * XXX STOP USING VM_MAXUSER_ADDRESS.
245  * It is an end address, not a max, so every time it is used correctly it
246  * looks like there is an off by one error, and of course it caused an off
247  * by one error in several places.
248  */
249         movq    $VM_MAXUSER_ADDRESS,%rcx
250         cmpq    %rcx,%rax
251         ja      copyout_fault
252
253         xchgq   %rdi,%rsi
254         /* bcopy(%rsi, %rdi, %rdx) */
255         movq    %rdx,%rcx
256
257         shrq    $3,%rcx
258         cld
259         rep
260         movsq
261         movb    %dl,%cl
262         andb    $7,%cl
263         rep
264         movsb
265
266 done_copyout:
267         xorl    %eax,%eax
268         movq    PCPU(CURPCB),%rdx
269         movq    %rax,PCB_ONFAULT(%rdx)
270         ret
271
272         ALIGN_TEXT
273 copyout_fault:
274         movq    PCPU(CURPCB),%rdx
275         movq    $0,PCB_ONFAULT(%rdx)
276         movq    $EFAULT,%rax
277         ret
278 END(copyout)
279
280 /*
281  * copyin(from_user, to_kernel, len) - MP SAFE
282  *        %rdi,      %rsi,      %rdx
283  */
284 ENTRY(copyin)
285         movq    PCPU(CURPCB),%rax
286         movq    $copyin_fault,PCB_ONFAULT(%rax)
287         testq   %rdx,%rdx                       /* anything to do? */
288         jz      done_copyin
289
290         /*
291          * make sure address is valid
292          */
293         movq    %rdi,%rax
294         addq    %rdx,%rax
295         jc      copyin_fault
296         movq    $VM_MAXUSER_ADDRESS,%rcx
297         cmpq    %rcx,%rax
298         ja      copyin_fault
299
300         xchgq   %rdi,%rsi
301         movq    %rdx,%rcx
302         movb    %cl,%al
303         shrq    $3,%rcx                         /* copy longword-wise */
304         cld
305         rep
306         movsq
307         movb    %al,%cl
308         andb    $7,%cl                          /* copy remaining bytes */
309         rep
310         movsb
311
312 done_copyin:
313         xorl    %eax,%eax
314         movq    PCPU(CURPCB),%rdx
315         movq    %rax,PCB_ONFAULT(%rdx)
316         ret
317
318         ALIGN_TEXT
319 copyin_fault:
320         movq    PCPU(CURPCB),%rdx
321         movq    $0,PCB_ONFAULT(%rdx)
322         movq    $EFAULT,%rax
323         ret
324 END(copyin)
325
326 /*
327  * casuword32.  Compare and set user integer.  Returns -1 or the current value.
328  *        dst = %rdi, old = %rsi, new = %rdx
329  */
330 ENTRY(casuword32)
331         movq    PCPU(CURPCB),%rcx
332         movq    $fusufault,PCB_ONFAULT(%rcx)
333
334         movq    $VM_MAXUSER_ADDRESS-4,%rax
335         cmpq    %rax,%rdi                       /* verify address is valid */
336         ja      fusufault
337
338         movl    %esi,%eax                       /* old */
339 #ifdef SMP
340         lock
341 #endif
342         cmpxchgl %edx,(%rdi)                    /* new = %edx */
343
344         /*
345          * The old value is in %eax.  If the store succeeded it will be the
346          * value we expected (old) from before the store, otherwise it will
347          * be the current value.
348          */
349
350         movq    PCPU(CURPCB),%rcx
351         movq    $0,PCB_ONFAULT(%rcx)
352         ret
353 END(casuword32)
354
355 /*
356  * casuword.  Compare and set user word.  Returns -1 or the current value.
357  *        dst = %rdi, old = %rsi, new = %rdx
358  */
359 ENTRY(casuword)
360         movq    PCPU(CURPCB),%rcx
361         movq    $fusufault,PCB_ONFAULT(%rcx)
362
363         movq    $VM_MAXUSER_ADDRESS-4,%rax
364         cmpq    %rax,%rdi                       /* verify address is valid */
365         ja      fusufault
366
367         movq    %rsi,%rax                       /* old */
368 #ifdef SMP
369         lock
370 #endif
371         cmpxchgq %rdx,(%rdi)                    /* new = %rdx */
372
373         /*
374          * The old value is in %eax.  If the store succeeded it will be the
375          * value we expected (old) from before the store, otherwise it will
376          * be the current value.
377          */
378
379         movq    PCPU(CURPCB),%rcx
380         movq    $fusufault,PCB_ONFAULT(%rcx)
381         movq    $0,PCB_ONFAULT(%rcx)
382         ret
383 END(casuword)
384
385 /*
386  * Fetch (load) a 64-bit word, a 32-bit word, a 16-bit word, or an 8-bit
387  * byte from user memory.  All these functions are MPSAFE.
388  * addr = %rdi
389  */
390
391 ALTENTRY(fuword64)
392 ENTRY(fuword)
393         movq    PCPU(CURPCB),%rcx
394         movq    $fusufault,PCB_ONFAULT(%rcx)
395
396         movq    $VM_MAXUSER_ADDRESS-8,%rax
397         cmpq    %rax,%rdi                       /* verify address is valid */
398         ja      fusufault
399
400         movq    (%rdi),%rax
401         movq    $0,PCB_ONFAULT(%rcx)
402         ret
403 END(fuword64)   
404 END(fuword)
405
406 ENTRY(fuword32)
407         movq    PCPU(CURPCB),%rcx
408         movq    $fusufault,PCB_ONFAULT(%rcx)
409
410         movq    $VM_MAXUSER_ADDRESS-4,%rax
411         cmpq    %rax,%rdi                       /* verify address is valid */
412         ja      fusufault
413
414         movl    (%rdi),%eax
415         movq    $0,PCB_ONFAULT(%rcx)
416         ret
417 END(fuword32)
418
419 /*
420  * fuswintr() and suswintr() are specialized variants of fuword16() and
421  * suword16(), respectively.  They are called from the profiling code,
422  * potentially at interrupt time.  If they fail, that's okay; good things
423  * will happen later.  They always fail for now, until the trap code is
424  * able to deal with this.
425  */
426 ALTENTRY(suswintr)
427 ENTRY(fuswintr)
428         movq    $-1,%rax
429         ret
430 END(suswintr)
431 END(fuswintr)
432
433 ENTRY(fuword16)
434         movq    PCPU(CURPCB),%rcx
435         movq    $fusufault,PCB_ONFAULT(%rcx)
436
437         movq    $VM_MAXUSER_ADDRESS-2,%rax
438         cmpq    %rax,%rdi
439         ja      fusufault
440
441         movzwl  (%rdi),%eax
442         movq    $0,PCB_ONFAULT(%rcx)
443         ret
444 END(fuword16)
445
446 ENTRY(fubyte)
447         movq    PCPU(CURPCB),%rcx
448         movq    $fusufault,PCB_ONFAULT(%rcx)
449
450         movq    $VM_MAXUSER_ADDRESS-1,%rax
451         cmpq    %rax,%rdi
452         ja      fusufault
453
454         movzbl  (%rdi),%eax
455         movq    $0,PCB_ONFAULT(%rcx)
456         ret
457 END(fubyte)
458
459         ALIGN_TEXT
460 fusufault:
461         movq    PCPU(CURPCB),%rcx
462         xorl    %eax,%eax
463         movq    %rax,PCB_ONFAULT(%rcx)
464         decq    %rax
465         ret
466
467 /*
468  * Store a 64-bit word, a 32-bit word, a 16-bit word, or an 8-bit byte to
469  * user memory.  All these functions are MPSAFE.
470  * addr = %rdi, value = %rsi
471  */
472 ALTENTRY(suword64)
473 ENTRY(suword)
474         movq    PCPU(CURPCB),%rcx
475         movq    $fusufault,PCB_ONFAULT(%rcx)
476
477         movq    $VM_MAXUSER_ADDRESS-8,%rax
478         cmpq    %rax,%rdi                       /* verify address validity */
479         ja      fusufault
480
481         movq    %rsi,(%rdi)
482         xorl    %eax,%eax
483         movq    PCPU(CURPCB),%rcx
484         movq    %rax,PCB_ONFAULT(%rcx)
485         ret
486 END(suword64)
487 END(suword)
488
489 ENTRY(suword32)
490         movq    PCPU(CURPCB),%rcx
491         movq    $fusufault,PCB_ONFAULT(%rcx)
492
493         movq    $VM_MAXUSER_ADDRESS-4,%rax
494         cmpq    %rax,%rdi                       /* verify address validity */
495         ja      fusufault
496
497         movl    %esi,(%rdi)
498         xorl    %eax,%eax
499         movq    PCPU(CURPCB),%rcx
500         movq    %rax,PCB_ONFAULT(%rcx)
501         ret
502 END(suword32)
503
504 ENTRY(suword16)
505         movq    PCPU(CURPCB),%rcx
506         movq    $fusufault,PCB_ONFAULT(%rcx)
507
508         movq    $VM_MAXUSER_ADDRESS-2,%rax
509         cmpq    %rax,%rdi                       /* verify address validity */
510         ja      fusufault
511
512         movw    %si,(%rdi)
513         xorl    %eax,%eax
514         movq    PCPU(CURPCB),%rcx               /* restore trashed register */
515         movq    %rax,PCB_ONFAULT(%rcx)
516         ret
517 END(suword16)
518
519 ENTRY(subyte)
520         movq    PCPU(CURPCB),%rcx
521         movq    $fusufault,PCB_ONFAULT(%rcx)
522
523         movq    $VM_MAXUSER_ADDRESS-1,%rax
524         cmpq    %rax,%rdi                       /* verify address validity */
525         ja      fusufault
526
527         movl    %esi,%eax
528         movb    %al,(%rdi)
529         xorl    %eax,%eax
530         movq    PCPU(CURPCB),%rcx               /* restore trashed register */
531         movq    %rax,PCB_ONFAULT(%rcx)
532         ret
533 END(subyte)
534
535 /*
536  * copyinstr(from, to, maxlen, int *lencopied) - MP SAFE
537  *           %rdi, %rsi, %rdx, %rcx
538  *
539  *      copy a string from from to to, stop when a 0 character is reached.
540  *      return ENAMETOOLONG if string is longer than maxlen, and
541  *      EFAULT on protection violations. If lencopied is non-zero,
542  *      return the actual length in *lencopied.
543  */
544 ENTRY(copyinstr)
545         movq    %rdx,%r8                        /* %r8 = maxlen */
546         movq    %rcx,%r9                        /* %r9 = *len */
547         xchgq   %rdi,%rsi                       /* %rdi = from, %rsi = to */
548         movq    PCPU(CURPCB),%rcx
549         movq    $cpystrflt,PCB_ONFAULT(%rcx)
550
551         movq    $VM_MAXUSER_ADDRESS,%rax
552
553         /* make sure 'from' is within bounds */
554         subq    %rsi,%rax
555         jbe     cpystrflt
556
557         /* restrict maxlen to <= VM_MAXUSER_ADDRESS-from */
558         cmpq    %rdx,%rax
559         jae     1f
560         movq    %rax,%rdx
561         movq    %rax,%r8
562 1:
563         incq    %rdx
564         cld
565
566 2:
567         decq    %rdx
568         jz      3f
569
570         lodsb
571         stosb
572         orb     %al,%al
573         jnz     2b
574
575         /* Success -- 0 byte reached */
576         decq    %rdx
577         xorl    %eax,%eax
578         jmp     cpystrflt_x
579 3:
580         /* rdx is zero - return ENAMETOOLONG or EFAULT */
581         movq    $VM_MAXUSER_ADDRESS,%rax
582         cmpq    %rax,%rsi
583         jae     cpystrflt
584 4:
585         movq    $ENAMETOOLONG,%rax
586         jmp     cpystrflt_x
587
588 cpystrflt:
589         movq    $EFAULT,%rax
590
591 cpystrflt_x:
592         /* set *lencopied and return %eax */
593         movq    PCPU(CURPCB),%rcx
594         movq    $0,PCB_ONFAULT(%rcx)
595
596         testq   %r9,%r9
597         jz      1f
598         subq    %rdx,%r8
599         movq    %r8,(%r9)
600 1:
601         ret
602 END(copyinstr)
603
604 /*
605  * copystr(from, to, maxlen, int *lencopied) - MP SAFE
606  *         %rdi, %rsi, %rdx, %rcx
607  */
608 ENTRY(copystr)
609         movq    %rdx,%r8                        /* %r8 = maxlen */
610
611         xchgq   %rdi,%rsi
612         incq    %rdx
613         cld
614 1:
615         decq    %rdx
616         jz      4f
617         lodsb
618         stosb
619         orb     %al,%al
620         jnz     1b
621
622         /* Success -- 0 byte reached */
623         decq    %rdx
624         xorl    %eax,%eax
625         jmp     6f
626 4:
627         /* rdx is zero -- return ENAMETOOLONG */
628         movq    $ENAMETOOLONG,%rax
629
630 6:
631
632         testq   %rcx,%rcx
633         jz      7f
634         /* set *lencopied and return %rax */
635         subq    %rdx,%r8
636         movq    %r8,(%rcx)
637 7:
638         ret
639 END(copystr)
640
641 /*
642  * Handling of special amd64 registers and descriptor tables etc
643  * %rdi
644  */
645 /* void lgdt(struct region_descriptor *rdp); */
646 ENTRY(lgdt)
647         /* reload the descriptor table */
648         lgdt    (%rdi)
649
650         /* flush the prefetch q */
651         jmp     1f
652         nop
653 1:
654         movl    $KDSEL,%eax
655         movl    %eax,%ds
656         movl    %eax,%es
657         movl    %eax,%fs        /* Beware, use wrmsr to set 64 bit base */
658         movl    %eax,%gs
659         movl    %eax,%ss
660
661         /* reload code selector by turning return into intersegmental return */
662         popq    %rax
663         pushq   $KCSEL
664         pushq   %rax
665         MEXITCOUNT
666         lretq
667 END(lgdt)
668
669 /*****************************************************************************/
670 /* setjump, longjump                                                         */
671 /*****************************************************************************/
672
673 ENTRY(setjmp)
674         movq    %rbx,0(%rdi)                    /* save rbx */
675         movq    %rsp,8(%rdi)                    /* save rsp */
676         movq    %rbp,16(%rdi)                   /* save rbp */
677         movq    %r12,24(%rdi)                   /* save r12 */
678         movq    %r13,32(%rdi)                   /* save r13 */
679         movq    %r14,40(%rdi)                   /* save r14 */
680         movq    %r15,48(%rdi)                   /* save r15 */
681         movq    0(%rsp),%rdx                    /* get rta */
682         movq    %rdx,56(%rdi)                   /* save rip */
683         xorl    %eax,%eax                       /* return(0); */
684         ret
685 END(setjmp)
686
687 ENTRY(longjmp)
688         movq    0(%rdi),%rbx                    /* restore rbx */
689         movq    8(%rdi),%rsp                    /* restore rsp */
690         movq    16(%rdi),%rbp                   /* restore rbp */
691         movq    24(%rdi),%r12                   /* restore r12 */
692         movq    32(%rdi),%r13                   /* restore r13 */
693         movq    40(%rdi),%r14                   /* restore r14 */
694         movq    48(%rdi),%r15                   /* restore r15 */
695         movq    56(%rdi),%rdx                   /* get rta */
696         movq    %rdx,0(%rsp)                    /* put in return frame */
697         xorl    %eax,%eax                       /* return(1); */
698         incl    %eax
699         ret
700 END(longjmp)
701
702 /*
703  * Support for BB-profiling (gcc -a).  The kernbb program will extract
704  * the data from the kernel.
705  */
706
707         .data
708         ALIGN_DATA
709         .globl bbhead
710 bbhead:
711         .quad 0
712
713         .text
714 NON_GPROF_ENTRY(__bb_init_func)
715         movq    $1,(%rdi)
716         movq    bbhead,%rax
717         movq    %rax,32(%rdi)
718         movq    %rdi,bbhead
719         NON_GPROF_RET
720
721 /*
722  * Support for reading MSRs in the safe manner.
723  */
724 ENTRY(rdmsr_safe)
725 /* int rdmsr_safe(u_int msr, uint64_t *data) */
726         movq    PCPU(CURPCB),%r8
727         movq    $msr_onfault,PCB_ONFAULT(%r8)
728         movl    %edi,%ecx
729         rdmsr                   /* Read MSR pointed by %ecx. Returns
730                                    hi byte in edx, lo in %eax */
731         salq    $32,%rdx        /* sign-shift %rdx left */
732         cltq                    /* sign-extend %eax -> %rax */
733         orq     %rdx,%rax
734         movq    %rax,(%rsi)
735         xorq    %rax,%rax
736         movq    %rax,PCB_ONFAULT(%r8)
737         ret
738
739 /*
740  * Support for writing MSRs in the safe manner.
741  */
742 ENTRY(wrmsr_safe)
743 /* int wrmsr_safe(u_int msr, uint64_t data) */
744         movq    PCPU(CURPCB),%r8
745         movq    $msr_onfault,PCB_ONFAULT(%r8)
746         movl    %edi,%ecx
747         movl    %esi,%eax
748         sarq    $32,%rsi
749         movl    %esi,%edx
750         wrmsr                   /* Write MSR pointed by %ecx. Accepts
751                                    hi byte in edx, lo in %eax. */
752         xorq    %rax,%rax
753         movq    %rax,PCB_ONFAULT(%r8)
754         ret
755
756 /*
757  * MSR operations fault handler
758  */
759         ALIGN_TEXT
760 msr_onfault:
761         movq    $0,PCB_ONFAULT(%r8)
762         movl    $EFAULT,%eax
763         ret