The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/i386/include/cpufunc.h

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 1993 The Regents of the University of California.
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  * 4. Neither the name of the University nor the names of its contributors
   14  *    may be used to endorse or promote products derived from this software
   15  *    without specific prior written permission.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   27  * SUCH DAMAGE.
   28  *
   29  * $FreeBSD: releng/10.2/sys/i386/include/cpufunc.h 276084 2014-12-22 21:32:39Z jhb $
   30  */
   31 
   32 /*
   33  * Functions to provide access to special i386 instructions.
   34  * This in included in sys/systm.h, and that file should be
   35  * used in preference to this.
   36  */
   37 
   38 #ifndef _MACHINE_CPUFUNC_H_
   39 #define _MACHINE_CPUFUNC_H_
   40 
   41 #ifndef _SYS_CDEFS_H_
   42 #error this file needs sys/cdefs.h as a prerequisite
   43 #endif
   44 
   45 #ifdef XEN
   46 extern void xen_cli(void);
   47 extern void xen_sti(void);
   48 extern u_int xen_rcr2(void);
   49 extern void xen_load_cr3(u_int data);
   50 extern void xen_tlb_flush(void);
   51 extern void xen_invlpg(u_int addr);
   52 extern void write_eflags(u_int eflags);
   53 extern u_int read_eflags(void);
   54 #endif
   55 
   56 struct region_descriptor;
   57 
   58 #define readb(va)       (*(volatile uint8_t *) (va))
   59 #define readw(va)       (*(volatile uint16_t *) (va))
   60 #define readl(va)       (*(volatile uint32_t *) (va))
   61 
   62 #define writeb(va, d)   (*(volatile uint8_t *) (va) = (d))
   63 #define writew(va, d)   (*(volatile uint16_t *) (va) = (d))
   64 #define writel(va, d)   (*(volatile uint32_t *) (va) = (d))
   65 
   66 #if defined(__GNUCLIKE_ASM) && defined(__CC_SUPPORTS___INLINE)
   67 
   68 static __inline void
   69 breakpoint(void)
   70 {
   71         __asm __volatile("int $3");
   72 }
   73 
   74 static __inline u_int
   75 bsfl(u_int mask)
   76 {
   77         u_int   result;
   78 
   79         __asm("bsfl %1,%0" : "=r" (result) : "rm" (mask) : "cc");
   80         return (result);
   81 }
   82 
   83 static __inline u_int
   84 bsrl(u_int mask)
   85 {
   86         u_int   result;
   87 
   88         __asm("bsrl %1,%0" : "=r" (result) : "rm" (mask) : "cc");
   89         return (result);
   90 }
   91 
   92 static __inline void
   93 clflush(u_long addr)
   94 {
   95 
   96         __asm __volatile("clflush %0" : : "m" (*(char *)addr));
   97 }
   98 
   99 static __inline void
  100 clts(void)
  101 {
  102 
  103         __asm __volatile("clts");
  104 }
  105 
  106 static __inline void
  107 disable_intr(void)
  108 {
  109 #ifdef XEN
  110         xen_cli();
  111 #else   
  112         __asm __volatile("cli" : : : "memory");
  113 #endif
  114 }
  115 
  116 static __inline void
  117 do_cpuid(u_int ax, u_int *p)
  118 {
  119         __asm __volatile("cpuid"
  120                          : "=a" (p[0]), "=b" (p[1]), "=c" (p[2]), "=d" (p[3])
  121                          :  "" (ax));
  122 }
  123 
  124 static __inline void
  125 cpuid_count(u_int ax, u_int cx, u_int *p)
  126 {
  127         __asm __volatile("cpuid"
  128                          : "=a" (p[0]), "=b" (p[1]), "=c" (p[2]), "=d" (p[3])
  129                          :  "" (ax), "c" (cx));
  130 }
  131 
  132 static __inline void
  133 enable_intr(void)
  134 {
  135 #ifdef XEN
  136         xen_sti();
  137 #else
  138         __asm __volatile("sti");
  139 #endif
  140 }
  141 
  142 static __inline void
  143 cpu_monitor(const void *addr, u_long extensions, u_int hints)
  144 {
  145 
  146         __asm __volatile("monitor"
  147             : : "a" (addr), "c" (extensions), "d" (hints));
  148 }
  149 
  150 static __inline void
  151 cpu_mwait(u_long extensions, u_int hints)
  152 {
  153 
  154         __asm __volatile("mwait" : : "a" (hints), "c" (extensions));
  155 }
  156 
  157 static __inline void
  158 lfence(void)
  159 {
  160 
  161         __asm __volatile("lfence" : : : "memory");
  162 }
  163 
  164 static __inline void
  165 mfence(void)
  166 {
  167 
  168         __asm __volatile("mfence" : : : "memory");
  169 }
  170 
  171 #ifdef _KERNEL
  172 
  173 #define HAVE_INLINE_FFS
  174 
  175 static __inline int
  176 ffs(int mask)
  177 {
  178         /*
  179          * Note that gcc-2's builtin ffs would be used if we didn't declare
  180          * this inline or turn off the builtin.  The builtin is faster but
  181          * broken in gcc-2.4.5 and slower but working in gcc-2.5 and later
  182          * versions.
  183          */
  184          return (mask == 0 ? mask : (int)bsfl((u_int)mask) + 1);
  185 }
  186 
  187 #define HAVE_INLINE_FLS
  188 
  189 static __inline int
  190 fls(int mask)
  191 {
  192         return (mask == 0 ? mask : (int)bsrl((u_int)mask) + 1);
  193 }
  194 
  195 #endif /* _KERNEL */
  196 
  197 static __inline void
  198 halt(void)
  199 {
  200         __asm __volatile("hlt");
  201 }
  202 
  203 static __inline u_char
  204 inb(u_int port)
  205 {
  206         u_char  data;
  207 
  208         __asm __volatile("inb %w1, %0" : "=a" (data) : "Nd" (port));
  209         return (data);
  210 }
  211 
  212 static __inline u_int
  213 inl(u_int port)
  214 {
  215         u_int   data;
  216 
  217         __asm __volatile("inl %w1, %0" : "=a" (data) : "Nd" (port));
  218         return (data);
  219 }
  220 
  221 static __inline void
  222 insb(u_int port, void *addr, size_t count)
  223 {
  224         __asm __volatile("cld; rep; insb"
  225                          : "+D" (addr), "+c" (count)
  226                          : "d" (port)
  227                          : "memory");
  228 }
  229 
  230 static __inline void
  231 insw(u_int port, void *addr, size_t count)
  232 {
  233         __asm __volatile("cld; rep; insw"
  234                          : "+D" (addr), "+c" (count)
  235                          : "d" (port)
  236                          : "memory");
  237 }
  238 
  239 static __inline void
  240 insl(u_int port, void *addr, size_t count)
  241 {
  242         __asm __volatile("cld; rep; insl"
  243                          : "+D" (addr), "+c" (count)
  244                          : "d" (port)
  245                          : "memory");
  246 }
  247 
  248 static __inline void
  249 invd(void)
  250 {
  251         __asm __volatile("invd");
  252 }
  253 
  254 static __inline u_short
  255 inw(u_int port)
  256 {
  257         u_short data;
  258 
  259         __asm __volatile("inw %w1, %0" : "=a" (data) : "Nd" (port));
  260         return (data);
  261 }
  262 
  263 static __inline void
  264 outb(u_int port, u_char data)
  265 {
  266         __asm __volatile("outb %0, %w1" : : "a" (data), "Nd" (port));
  267 }
  268 
  269 static __inline void
  270 outl(u_int port, u_int data)
  271 {
  272         __asm __volatile("outl %0, %w1" : : "a" (data), "Nd" (port));
  273 }
  274 
  275 static __inline void
  276 outsb(u_int port, const void *addr, size_t count)
  277 {
  278         __asm __volatile("cld; rep; outsb"
  279                          : "+S" (addr), "+c" (count)
  280                          : "d" (port));
  281 }
  282 
  283 static __inline void
  284 outsw(u_int port, const void *addr, size_t count)
  285 {
  286         __asm __volatile("cld; rep; outsw"
  287                          : "+S" (addr), "+c" (count)
  288                          : "d" (port));
  289 }
  290 
  291 static __inline void
  292 outsl(u_int port, const void *addr, size_t count)
  293 {
  294         __asm __volatile("cld; rep; outsl"
  295                          : "+S" (addr), "+c" (count)
  296                          : "d" (port));
  297 }
  298 
  299 static __inline void
  300 outw(u_int port, u_short data)
  301 {
  302         __asm __volatile("outw %0, %w1" : : "a" (data), "Nd" (port));
  303 }
  304 
  305 static __inline void
  306 ia32_pause(void)
  307 {
  308         __asm __volatile("pause");
  309 }
  310 
  311 static __inline u_int
  312 #ifdef XEN
  313 _read_eflags(void)
  314 #else   
  315 read_eflags(void)
  316 #endif
  317 {
  318         u_int   ef;
  319 
  320         __asm __volatile("pushfl; popl %0" : "=r" (ef));
  321         return (ef);
  322 }
  323 
  324 static __inline uint64_t
  325 rdmsr(u_int msr)
  326 {
  327         uint64_t rv;
  328 
  329         __asm __volatile("rdmsr" : "=A" (rv) : "c" (msr));
  330         return (rv);
  331 }
  332 
  333 static __inline uint64_t
  334 rdpmc(u_int pmc)
  335 {
  336         uint64_t rv;
  337 
  338         __asm __volatile("rdpmc" : "=A" (rv) : "c" (pmc));
  339         return (rv);
  340 }
  341 
  342 static __inline uint64_t
  343 rdtsc(void)
  344 {
  345         uint64_t rv;
  346 
  347         __asm __volatile("rdtsc" : "=A" (rv));
  348         return (rv);
  349 }
  350 
  351 static __inline uint32_t
  352 rdtsc32(void)
  353 {
  354         uint32_t rv;
  355 
  356         __asm __volatile("rdtsc" : "=a" (rv) : : "edx");
  357         return (rv);
  358 }
  359 
  360 static __inline void
  361 wbinvd(void)
  362 {
  363         __asm __volatile("wbinvd");
  364 }
  365 
  366 static __inline void
  367 #ifdef XEN
  368 _write_eflags(u_int ef)
  369 #else
  370 write_eflags(u_int ef)
  371 #endif
  372 {
  373         __asm __volatile("pushl %0; popfl" : : "r" (ef));
  374 }
  375 
  376 static __inline void
  377 wrmsr(u_int msr, uint64_t newval)
  378 {
  379         __asm __volatile("wrmsr" : : "A" (newval), "c" (msr));
  380 }
  381 
  382 static __inline void
  383 load_cr0(u_int data)
  384 {
  385 
  386         __asm __volatile("movl %0,%%cr0" : : "r" (data));
  387 }
  388 
  389 static __inline u_int
  390 rcr0(void)
  391 {
  392         u_int   data;
  393 
  394         __asm __volatile("movl %%cr0,%0" : "=r" (data));
  395         return (data);
  396 }
  397 
  398 static __inline u_int
  399 rcr2(void)
  400 {
  401         u_int   data;
  402 
  403 #ifdef XEN
  404         return (xen_rcr2());
  405 #endif
  406         __asm __volatile("movl %%cr2,%0" : "=r" (data));
  407         return (data);
  408 }
  409 
  410 static __inline void
  411 load_cr3(u_int data)
  412 {
  413 #ifdef XEN
  414         xen_load_cr3(data);
  415 #else
  416         __asm __volatile("movl %0,%%cr3" : : "r" (data) : "memory");
  417 #endif
  418 }
  419 
  420 static __inline u_int
  421 rcr3(void)
  422 {
  423         u_int   data;
  424 
  425         __asm __volatile("movl %%cr3,%0" : "=r" (data));
  426         return (data);
  427 }
  428 
  429 static __inline void
  430 load_cr4(u_int data)
  431 {
  432         __asm __volatile("movl %0,%%cr4" : : "r" (data));
  433 }
  434 
  435 static __inline u_int
  436 rcr4(void)
  437 {
  438         u_int   data;
  439 
  440         __asm __volatile("movl %%cr4,%0" : "=r" (data));
  441         return (data);
  442 }
  443 
  444 static __inline uint64_t
  445 rxcr(u_int reg)
  446 {
  447         u_int low, high;
  448 
  449         __asm __volatile("xgetbv" : "=a" (low), "=d" (high) : "c" (reg));
  450         return (low | ((uint64_t)high << 32));
  451 }
  452 
  453 static __inline void
  454 load_xcr(u_int reg, uint64_t val)
  455 {
  456         u_int low, high;
  457 
  458         low = val;
  459         high = val >> 32;
  460         __asm __volatile("xsetbv" : : "c" (reg), "a" (low), "d" (high));
  461 }
  462 
  463 /*
  464  * Global TLB flush (except for thise for pages marked PG_G)
  465  */
  466 static __inline void
  467 invltlb(void)
  468 {
  469 #ifdef XEN
  470         xen_tlb_flush();
  471 #else   
  472         load_cr3(rcr3());
  473 #endif
  474 }
  475 
  476 /*
  477  * TLB flush for an individual page (even if it has PG_G).
  478  * Only works on 486+ CPUs (i386 does not have PG_G).
  479  */
  480 static __inline void
  481 invlpg(u_int addr)
  482 {
  483 
  484 #ifdef XEN
  485         xen_invlpg(addr);
  486 #else
  487         __asm __volatile("invlpg %0" : : "m" (*(char *)addr) : "memory");
  488 #endif
  489 }
  490 
  491 static __inline u_short
  492 rfs(void)
  493 {
  494         u_short sel;
  495         __asm __volatile("movw %%fs,%0" : "=rm" (sel));
  496         return (sel);
  497 }
  498 
  499 static __inline uint64_t
  500 rgdt(void)
  501 {
  502         uint64_t gdtr;
  503         __asm __volatile("sgdt %0" : "=m" (gdtr));
  504         return (gdtr);
  505 }
  506 
  507 static __inline u_short
  508 rgs(void)
  509 {
  510         u_short sel;
  511         __asm __volatile("movw %%gs,%0" : "=rm" (sel));
  512         return (sel);
  513 }
  514 
  515 static __inline uint64_t
  516 ridt(void)
  517 {
  518         uint64_t idtr;
  519         __asm __volatile("sidt %0" : "=m" (idtr));
  520         return (idtr);
  521 }
  522 
  523 static __inline u_short
  524 rldt(void)
  525 {
  526         u_short ldtr;
  527         __asm __volatile("sldt %0" : "=g" (ldtr));
  528         return (ldtr);
  529 }
  530 
  531 static __inline u_short
  532 rss(void)
  533 {
  534         u_short sel;
  535         __asm __volatile("movw %%ss,%0" : "=rm" (sel));
  536         return (sel);
  537 }
  538 
  539 static __inline u_short
  540 rtr(void)
  541 {
  542         u_short tr;
  543         __asm __volatile("str %0" : "=g" (tr));
  544         return (tr);
  545 }
  546 
  547 static __inline void
  548 load_fs(u_short sel)
  549 {
  550         __asm __volatile("movw %0,%%fs" : : "rm" (sel));
  551 }
  552 
  553 static __inline void
  554 load_gs(u_short sel)
  555 {
  556         __asm __volatile("movw %0,%%gs" : : "rm" (sel));
  557 }
  558 
  559 static __inline void
  560 lidt(struct region_descriptor *addr)
  561 {
  562         __asm __volatile("lidt (%0)" : : "r" (addr));
  563 }
  564 
  565 static __inline void
  566 lldt(u_short sel)
  567 {
  568         __asm __volatile("lldt %0" : : "r" (sel));
  569 }
  570 
  571 static __inline void
  572 ltr(u_short sel)
  573 {
  574         __asm __volatile("ltr %0" : : "r" (sel));
  575 }
  576 
  577 static __inline u_int
  578 rdr0(void)
  579 {
  580         u_int   data;
  581         __asm __volatile("movl %%dr0,%0" : "=r" (data));
  582         return (data);
  583 }
  584 
  585 static __inline void
  586 load_dr0(u_int dr0)
  587 {
  588         __asm __volatile("movl %0,%%dr0" : : "r" (dr0));
  589 }
  590 
  591 static __inline u_int
  592 rdr1(void)
  593 {
  594         u_int   data;
  595         __asm __volatile("movl %%dr1,%0" : "=r" (data));
  596         return (data);
  597 }
  598 
  599 static __inline void
  600 load_dr1(u_int dr1)
  601 {
  602         __asm __volatile("movl %0,%%dr1" : : "r" (dr1));
  603 }
  604 
  605 static __inline u_int
  606 rdr2(void)
  607 {
  608         u_int   data;
  609         __asm __volatile("movl %%dr2,%0" : "=r" (data));
  610         return (data);
  611 }
  612 
  613 static __inline void
  614 load_dr2(u_int dr2)
  615 {
  616         __asm __volatile("movl %0,%%dr2" : : "r" (dr2));
  617 }
  618 
  619 static __inline u_int
  620 rdr3(void)
  621 {
  622         u_int   data;
  623         __asm __volatile("movl %%dr3,%0" : "=r" (data));
  624         return (data);
  625 }
  626 
  627 static __inline void
  628 load_dr3(u_int dr3)
  629 {
  630         __asm __volatile("movl %0,%%dr3" : : "r" (dr3));
  631 }
  632 
  633 static __inline u_int
  634 rdr4(void)
  635 {
  636         u_int   data;
  637         __asm __volatile("movl %%dr4,%0" : "=r" (data));
  638         return (data);
  639 }
  640 
  641 static __inline void
  642 load_dr4(u_int dr4)
  643 {
  644         __asm __volatile("movl %0,%%dr4" : : "r" (dr4));
  645 }
  646 
  647 static __inline u_int
  648 rdr5(void)
  649 {
  650         u_int   data;
  651         __asm __volatile("movl %%dr5,%0" : "=r" (data));
  652         return (data);
  653 }
  654 
  655 static __inline void
  656 load_dr5(u_int dr5)
  657 {
  658         __asm __volatile("movl %0,%%dr5" : : "r" (dr5));
  659 }
  660 
  661 static __inline u_int
  662 rdr6(void)
  663 {
  664         u_int   data;
  665         __asm __volatile("movl %%dr6,%0" : "=r" (data));
  666         return (data);
  667 }
  668 
  669 static __inline void
  670 load_dr6(u_int dr6)
  671 {
  672         __asm __volatile("movl %0,%%dr6" : : "r" (dr6));
  673 }
  674 
  675 static __inline u_int
  676 rdr7(void)
  677 {
  678         u_int   data;
  679         __asm __volatile("movl %%dr7,%0" : "=r" (data));
  680         return (data);
  681 }
  682 
  683 static __inline void
  684 load_dr7(u_int dr7)
  685 {
  686         __asm __volatile("movl %0,%%dr7" : : "r" (dr7));
  687 }
  688 
  689 static __inline u_char
  690 read_cyrix_reg(u_char reg)
  691 {
  692         outb(0x22, reg);
  693         return inb(0x23);
  694 }
  695 
  696 static __inline void
  697 write_cyrix_reg(u_char reg, u_char data)
  698 {
  699         outb(0x22, reg);
  700         outb(0x23, data);
  701 }
  702 
  703 static __inline register_t
  704 intr_disable(void)
  705 {
  706         register_t eflags;
  707 
  708         eflags = read_eflags();
  709         disable_intr();
  710         return (eflags);
  711 }
  712 
  713 static __inline void
  714 intr_restore(register_t eflags)
  715 {
  716         write_eflags(eflags);
  717 }
  718 
  719 #else /* !(__GNUCLIKE_ASM && __CC_SUPPORTS___INLINE) */
  720 
  721 int     breakpoint(void);
  722 u_int   bsfl(u_int mask);
  723 u_int   bsrl(u_int mask);
  724 void    clflush(u_long addr);
  725 void    clts(void);
  726 void    cpuid_count(u_int ax, u_int cx, u_int *p);
  727 void    disable_intr(void);
  728 void    do_cpuid(u_int ax, u_int *p);
  729 void    enable_intr(void);
  730 void    halt(void);
  731 void    ia32_pause(void);
  732 u_char  inb(u_int port);
  733 u_int   inl(u_int port);
  734 void    insb(u_int port, void *addr, size_t count);
  735 void    insl(u_int port, void *addr, size_t count);
  736 void    insw(u_int port, void *addr, size_t count);
  737 register_t      intr_disable(void);
  738 void    intr_restore(register_t ef);
  739 void    invd(void);
  740 void    invlpg(u_int addr);
  741 void    invltlb(void);
  742 u_short inw(u_int port);
  743 void    lidt(struct region_descriptor *addr);
  744 void    lldt(u_short sel);
  745 void    load_cr0(u_int cr0);
  746 void    load_cr3(u_int cr3);
  747 void    load_cr4(u_int cr4);
  748 void    load_dr0(u_int dr0);
  749 void    load_dr1(u_int dr1);
  750 void    load_dr2(u_int dr2);
  751 void    load_dr3(u_int dr3);
  752 void    load_dr4(u_int dr4);
  753 void    load_dr5(u_int dr5);
  754 void    load_dr6(u_int dr6);
  755 void    load_dr7(u_int dr7);
  756 void    load_fs(u_short sel);
  757 void    load_gs(u_short sel);
  758 void    ltr(u_short sel);
  759 void    outb(u_int port, u_char data);
  760 void    outl(u_int port, u_int data);
  761 void    outsb(u_int port, const void *addr, size_t count);
  762 void    outsl(u_int port, const void *addr, size_t count);
  763 void    outsw(u_int port, const void *addr, size_t count);
  764 void    outw(u_int port, u_short data);
  765 u_int   rcr0(void);
  766 u_int   rcr2(void);
  767 u_int   rcr3(void);
  768 u_int   rcr4(void);
  769 uint64_t rdmsr(u_int msr);
  770 uint64_t rdpmc(u_int pmc);
  771 u_int   rdr0(void);
  772 u_int   rdr1(void);
  773 u_int   rdr2(void);
  774 u_int   rdr3(void);
  775 u_int   rdr4(void);
  776 u_int   rdr5(void);
  777 u_int   rdr6(void);
  778 u_int   rdr7(void);
  779 uint64_t rdtsc(void);
  780 u_char  read_cyrix_reg(u_char reg);
  781 u_int   read_eflags(void);
  782 u_int   rfs(void);
  783 uint64_t rgdt(void);
  784 u_int   rgs(void);
  785 uint64_t ridt(void);
  786 u_short rldt(void);
  787 u_short rtr(void);
  788 void    wbinvd(void);
  789 void    write_cyrix_reg(u_char reg, u_char data);
  790 void    write_eflags(u_int ef);
  791 void    wrmsr(u_int msr, uint64_t newval);
  792 
  793 #endif  /* __GNUCLIKE_ASM && __CC_SUPPORTS___INLINE */
  794 
  795 void    reset_dbregs(void);
  796 
  797 #ifdef _KERNEL
  798 int     rdmsr_safe(u_int msr, uint64_t *val);
  799 int     wrmsr_safe(u_int msr, uint64_t newval);
  800 #endif
  801 
  802 #endif /* !_MACHINE_CPUFUNC_H_ */

Cache object: 5c5a393ab48489a3890e7041d45a7aaa


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.