arch/x86/include/sys/segments.h

   1 /*
   2  * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
   3  */
   4 /*
   5  * Copyright 2018 Joyent, Inc.
   6  */
   7
   8 #ifndef _SYS_SEGMENTS_H
   9 #define _SYS_SEGMENTS_H
  10
  11 #ifdef  __cplusplus
  12 extern "C" {
  13 #endif
  14
  15 /*
  16  * Copyright (c) 1989, 1990 William F. Jolitz
  17  * Copyright (c) 1990 The Regents of the University of California.
  18  * All rights reserved.
  19  *
  20  * This code is derived from software contributed to Berkeley by
  21  * William Jolitz.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  * 1. Redistributions of source code must retain the above copyright
  27  *    notice, this list of conditions and the following disclaimer.
  28  * 2. Redistributions in binary form must reproduce the above copyright
  29  *    notice, this list of conditions and the following disclaimer in the
  30  *    documentation and/or other materials provided with the distribution.
  31  * 3. All advertising materials mentioning features or use of this software
  32  *    must display the following acknowledgement:
  33  *      This product includes software developed by the University of
  34  *      California, Berkeley and its contributors.
  35  * 4. Neither the name of the University nor the names of its contributors
  36  *    may be used to endorse or promote products derived from this software
  37  *    without specific prior written permission.
  38  *
  39  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  40  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  42  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  43  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  44  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  45  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  46  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  47  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  48  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  49  * SUCH DAMAGE.
  50  *
  51  *      from: @(#)segments.h    7.1 (Berkeley) 5/9/91
  52  * $FreeBSD: src/sys/i386/include/segments.h,v 1.34 2003/09/10 01:07:04
  53  * jhb Exp $
  54  *
  55  * 386 Segmentation Data Structures and definitions
  56  *      William F. Jolitz (william@ernie.berkeley.edu) 6/20/1989
  57  */
  58
  59 #include <sys/tss.h>
  60
  61 /*
  62  * Selector register format
  63  * CS, DS, ES, FS, GS, SS
  64  *
  65  *  15                  3  2  1 0
  66  * +---------------------+---+----+
  67  * |          SI         |TI |RPL |
  68  * +---------------------+---+----+
  69  *
  70  * SI  = selector index
  71  * TI  = table indicator (0 = GDT, 1 = LDT)
  72  * RPL = requestor privilege level
  73  */
  74 #if !defined(_ASM) || defined(__GNUC_AS__)
  75 #define IDXTOSEL(s)     ((s) << 3)              /* index to selector */
  76 #define SEL_GDT(s, r)   (IDXTOSEL(s) | r)       /* global sel */
  77 #else
  78 #define IDXTOSEL(s)     [s << 3]
  79 #define SEL_GDT(s, r)   [IDXTOSEL(s) | r]
  80 #endif
  81
  82 #define SELTOIDX(s)     ((s) >> 3)      /* selector to index */
  83
  84 /*
  85  * SEL_(KPL,UPL,XPL) is the RPL or DPL value for code and data selectors
  86  * and their descriptors respectively.
  87  *
  88  * TRP_(KPL,UPL,XPL) is used to indicate the DPL for system gates only.
  89  *
  90  * This distinction is important to support para-virt guests on the
  91  * 64-bit hypervisor. Both guest kernel and user run in ring 3 and the
  92  * hypervisor runs in ring 0. When the kernel creates its trap and
  93  * interrupt gates it needs a way to prevent any arbitrary int $n
  94  * instruction from entering a gate that is not expected. The hypervisor
  95  * allows these gates to have a DPL from 1 to 3. By creating gates
  96  * with a DPL below user (ring 3) the int $n will generate a #gp fault
  97  * which the hypervisor catches and forwards to the guest.
  98  */
  99 #if defined(__xpv)
 100
 101 #define SEL_XPL         0               /* hypervisor privilege level */
 102 #define SEL_KPL         3               /* both kernel and user in ring 3 */
 103 #define TRP_KPL         1               /* system gate priv (user blocked) */
 104 #define TRP_XPL         0               /* system gate priv (hypervisor) */
 105
 106 #define IST_DBG         0
 107
 108 #else   /* __xpv */
 109
 110 #define SEL_KPL         0               /* kernel privilege level on metal */
 111 #define TRP_KPL         SEL_KPL         /* system gate priv (user blocked) */
 112
 113
 114 #define IST_DF          1
 115 #define IST_NMI         2
 116 #define IST_MCE         3
 117 #define IST_DBG         4
 118 #define IST_NESTABLE    5
 119 #define IST_DEFAULT     6
 120
 121 #endif  /* __xpv */
 122
 123 #define IST_NONE        0
 124
 125 #define SEL_UPL         3               /* user priority level */
 126 #define TRP_UPL         3               /* system gate priv (user allowed) */
 127 #define SEL_TI_LDT      4               /* local descriptor table */
 128 #define SEL_LDT(s)      (IDXTOSEL(s) | SEL_TI_LDT | SEL_UPL)    /* local sel */
 129 #define CPL_MASK        3               /* RPL mask for selector */
 130 #define SELISLDT(s)     (((s) & SEL_TI_LDT) == SEL_TI_LDT)
 131 #define SELISUPL(s)     (((s) & CPL_MASK) == SEL_UPL)
 132
 133 #ifndef _ASM
 134
 135 typedef uint16_t        selector_t;     /* selector reigster */
 136
 137 /*
 138  * Hardware descriptor table register format for GDT and IDT.
 139  */
 140 #if defined(__amd64)
 141
 142 #pragma pack(2)
 143 typedef struct {
 144         uint16_t dtr_limit;     /* table limit */
 145         uint64_t dtr_base;      /* table base address  */
 146 } desctbr_t;
 147 #pragma pack()
 148
 149 #elif defined(__i386)
 150
 151 #pragma pack(2)
 152 typedef struct {
 153         uint16_t dtr_limit;     /* table limit */
 154         uint32_t dtr_base;      /* table base address  */
 155 } desctbr_t;
 156 #pragma pack()
 157
 158 #endif  /* __i386 */
 159
 160 /*
 161  * Functions for loading and storing descriptor table
 162  * registers.
 163  */
 164 extern void rd_idtr(desctbr_t *);
 165 extern void wr_idtr(desctbr_t *);
 166 extern void rd_gdtr(desctbr_t *);
 167 extern void wr_gdtr(desctbr_t *);
 168 extern void wr_ldtr(selector_t);
 169 extern selector_t rd_ldtr(void);
 170 extern void wr_tsr(selector_t);
 171 extern void kmdb_enter(void);
 172
 173 #if defined(__amd64)
 174
 175 /*
 176  * inlines for update_segregs
 177  */
 178 extern void __set_ds(selector_t);
 179 extern void __set_es(selector_t);
 180 extern void __set_fs(selector_t);
 181 extern void __set_gs(selector_t);
 182 extern void __swapgs(void);
 183 #endif  /* __amd64 */
 184
 185 #if defined(__amd64)
 186 extern void load_segment_registers(selector_t, selector_t, selector_t,
 187     selector_t);        /* (alphabetical) */
 188 #elif defined(__i386)
 189 extern void load_segment_registers(selector_t, selector_t, selector_t,
 190     selector_t, selector_t, selector_t);        /* (alphabetical) */
 191 #endif  /* __i386 */
 192
 193 selector_t get_cs_register();
 194
 195 #if !defined(__amd64)
 196
 197 /*
 198  * User segment descriptors (code and data).
 199  * Legacy mode 64-bits wide.
 200  */
 201 typedef struct user_desc {
 202         uint32_t usd_lolimit:16;        /* segment limit 15:0 */
 203         uint32_t usd_lobase:16;         /* segment base 15:0 */
 204         uint32_t usd_midbase:8;         /* segment base 23:16 */
 205         uint32_t usd_type:5;            /* segment type, includes S bit */
 206         uint32_t usd_dpl:2;             /* segment descriptor priority level */
 207         uint32_t usd_p:1;               /* segment descriptor present */
 208         uint32_t usd_hilimit:4;         /* segment limit 19:16 */
 209         uint32_t usd_avl:1;             /* available to sw, but not used */
 210         uint32_t usd_reserved:1;        /* unused, ignored */
 211         uint32_t usd_def32:1;           /* default 32 vs 16 bit operand */
 212         uint32_t usd_gran:1;            /* limit units (bytes vs pages) */
 213         uint32_t usd_hibase:8;          /* segment base 31:24 */
 214 } user_desc_t;
 215
 216 #define USEGD_GETBASE(usd)              ((usd)->usd_lobase |            \
 217                                         (usd)->usd_midbase << 16 |      \
 218                                         (usd)->usd_hibase << (16 + 8))
 219
 220 #define USEGD_SETBASE(usd, b)           ((usd)->usd_lobase = (b),       \
 221                                         (usd)->usd_midbase = (b) >> 16, \
 222                                         (usd)->usd_hibase = (b) >> (16 + 8))
 223
 224 #define USEGD_GETLIMIT(usd)             ((usd)->usd_lolimit |           \
 225                                         (usd)->usd_hilimit << 16)
 226
 227 #define USEGD_SETLIMIT(usd, lim)        ((usd)->usd_lolimit = lim,      \
 228                                         (usd)->usd_hilimit = lim >> 16)
 229
 230 #define USD_TYPESHIFT                   5       /* size of usd_type field */
 231
 232 #else   /* __amd64 */
 233
 234 /*
 235  * User segment descriptors.
 236  * Long mode 64-bits wide.
 237  *
 238  * In 32-bit compatibility mode (%cs:usd_long=0) all fields are interpreted
 239  * as in legacy mode for both code and data.
 240  *
 241  * In 64-bit mode (%cs:usd_long=1) code segments only have the conforming
 242  * bit in usd_type, usd_dpl, usd_p, usd_long and usd_def32=0. usd_def32
 243  * must be zero in 64-bit mode. Setting it to 1 is reserved for future use.
 244  * All other fields are loaded but ignored by hardware.
 245  *
 246  * 64-bit data segments only have usd_p. All other fields are loaded but
 247  * ignored by hardware when in 64-bit mode.
 248  */
 249 typedef struct user_desc {
 250         uint64_t usd_lolimit:16;        /* segment limit 15:0 */
 251         uint64_t usd_lobase:16;         /* segment base 15:0 */
 252         uint64_t usd_midbase:8;         /* segment base 23:16 */
 253         uint64_t usd_type:5;            /* segment type, includes S bit */
 254         uint64_t usd_dpl:2;             /* segment descriptor priority level */
 255         uint64_t usd_p:1;               /* segment descriptor present */
 256         uint64_t usd_hilimit:4;         /* segment limit 19:16 */
 257         uint64_t usd_avl:1;             /* available to sw, but not used */
 258         uint64_t usd_long:1;            /* long mode (%cs only) */
 259         uint64_t usd_def32:1;           /* default 32 vs 16 bit operand */
 260         uint64_t usd_gran:1;            /* limit units (bytes vs page) */
 261         uint64_t usd_hibase:8;          /* segment base 31:24 */
 262 } user_desc_t;
 263
 264 #define USEGD_GETBASE(usd)              ((usd)->usd_lobase |            \
 265                                         (usd)->usd_midbase << 16 |      \
 266                                         (usd)->usd_hibase << (16 + 8))
 267
 268 #define USEGD_SETBASE(usd, b)           ((usd)->usd_lobase = (b),       \
 269                                         (usd)->usd_midbase = (b) >> 16, \
 270                                         (usd)->usd_hibase = (b) >> (16 + 8))
 271
 272 #define USEGD_GETLIMIT(usd)             ((usd)->usd_lolimit |           \
 273                                         (usd)->usd_hilimit << 16)
 274
 275 #define USEGD_SETLIMIT(usd, lim)        ((usd)->usd_lolimit = lim,      \
 276                                         (usd)->usd_hilimit = lim >> 16)
 277
 278 #define USD_TYPESHIFT                   5       /* size of usd_type field */
 279
 280 #endif /* __amd64 */
 281
 282 #if !defined(__amd64)
 283
 284 /*
 285  * System segment descriptors for LDT and TSS segments.
 286  * Legacy mode 64-bits wide.
 287  */
 288 typedef struct system_desc {
 289         uint32_t ssd_lolimit:16;        /* segment limit 15:0 */
 290         uint32_t ssd_lobase:16;         /* segment base 15:0 */
 291         uint32_t ssd_midbase:8;         /* segment base 23:16 */
 292         uint32_t ssd_type:4;            /* segment type */
 293         uint32_t ssd_zero:1;            /* must be zero */
 294         uint32_t ssd_dpl:2;             /* segment descriptor priority level */
 295         uint32_t ssd_p:1;               /* segment descriptor present */
 296         uint32_t ssd_hilimit:4;         /* segment limit 19:16 */
 297         uint32_t ssd_avl:1;             /* available to sw, but not used */
 298         uint32_t ssd_reserved:2;        /* unused, ignored */
 299         uint32_t ssd_gran:1;            /* limit unit (bytes vs pages) */
 300         uint32_t ssd_hibase:8;          /* segment base 31:24 */
 301 } system_desc_t;
 302
 303 #else   /* __amd64 */
 304
 305 /*
 306  * System segment descriptors for LDT and TSS segments.
 307  * Long mode 128-bits wide.
 308  *
 309  * 32-bit LDT and TSS descriptor types are redefined to 64-bit equivalents.
 310  * All other legacy types are reserved and illegal.
 311  */
 312 typedef struct system_desc {
 313         uint64_t ssd_lolimit:16;        /* segment limit 15:0 */
 314         uint64_t ssd_lobase:16;         /* segment base 15:0 */
 315         uint64_t ssd_midbase:8;         /* segment base 23:16 */
 316         uint64_t ssd_type:4;            /* segment type */
 317         uint64_t ssd_zero1:1;           /* must be zero */
 318         uint64_t ssd_dpl:2;             /* segment descriptor priority level */
 319         uint64_t ssd_p:1;               /* segment descriptor present */
 320         uint64_t ssd_hilimit:4;         /* segment limit 19:16 */
 321         uint64_t ssd_avl:1;             /* available to sw, but not used */
 322         uint64_t ssd_resv1:2;           /* unused, ignored */
 323         uint64_t ssd_gran:1;            /* limit unit (bytes vs pages) */
 324         uint64_t ssd_hibase:8;          /* segment base 31:24 */
 325         uint64_t ssd_hi64base:32;       /* segment base 63:32 */
 326         uint64_t ssd_resv2:8;           /* unused, ignored */
 327         uint64_t ssd_zero2:5;           /* must be zero */
 328         uint64_t ssd_resv3:19;          /* unused, ignored */
 329 } system_desc_t;
 330
 331 #endif  /* __amd64 */
 332
 333 #define SYSSEGD_SETLIMIT(ssd, lim)      ((ssd)->ssd_lolimit = lim,      \
 334                                         (ssd)->ssd_hilimit = lim >> 16)
 335
 336 #define SYSSEGD_GETLIMIT(ssd)           (((ssd)->ssd_hilimit << 16) |   \
 337                                         (ssd)->ssd_lolimit)
 338
 339 #if !defined(__amd64)
 340
 341 /*
 342  * System gate segment descriptors for interrupt, trap, call and task gates.
 343  * Legacy mode 64-bits wide.
 344  */
 345 typedef struct gate_desc {
 346         uint32_t sgd_looffset:16;       /* segment code offset 15:0 */
 347         uint32_t sgd_selector:16;       /* target code or task selector */
 348         uint32_t sgd_stkcpy:5;          /* number of stack wds to cpy */
 349         uint32_t sgd_resv:3;            /* unused, ignored */
 350         uint32_t sgd_type:5;            /* segment type, includes S bit */
 351         uint32_t sgd_dpl:2;             /* segment descriptor priority level */
 352         uint32_t sgd_p:1;               /* segment descriptor present */
 353         uint32_t sgd_hioffset:16;       /* code seg off 31:16 */
 354 } gate_desc_t;
 355
 356 #define GATESEG_GETOFFSET(sgd)  ((uintptr_t)((sgd)->sgd_looffset |      \
 357                                 (sgd)->sgd_hioffset << 16))
 358
 359 #else   /* __amd64 */
 360
 361 /*
 362  * System segment descriptors for interrupt, trap and call gates.
 363  * Long mode 128-bits wide.
 364  *
 365  * 32-bit interrupt, trap and call gate types are redefined to 64-bit
 366  * equivalents. Task gates along with all other legacy types are reserved
 367  * and illegal.
 368  */
 369 typedef struct gate_desc {
 370         uint64_t sgd_looffset:16;       /* segment code offset 15:0 */
 371         uint64_t sgd_selector:16;       /* target code or task selector */
 372         uint64_t sgd_ist:3;             /* IST table index */
 373         uint64_t sgd_resv1:5;           /* unused, ignored */
 374         uint64_t sgd_type:5;            /* segment type, includes S bit */
 375         uint64_t sgd_dpl:2;             /* segment descriptor priority level */
 376         uint64_t sgd_p:1;               /* segment descriptor present */
 377         uint64_t sgd_hioffset:16;       /* segment code offset 31:16 */
 378         uint64_t sgd_hi64offset:32;     /* segment code offset 63:32 */
 379         uint64_t sgd_resv2:8;           /* unused, ignored */
 380         uint64_t sgd_zero:5;            /* call gate only: must be zero */
 381         uint64_t sgd_resv3:19;          /* unused, ignored */
 382 } gate_desc_t;
 383
 384 #define GATESEG_GETOFFSET(sgd)  ((uintptr_t)((sgd)->sgd_looffset |      \
 385                                 (sgd)->sgd_hioffset << 16 |             \
 386                                 (uint64_t)((sgd)->sgd_hi64offset) << 32))
 387
 388 #endif  /* __amd64 */
 389
 390 /*
 391  * functions for initializing and updating segment descriptors.
 392  */
 393 #if defined(__amd64)
 394
 395 extern void set_usegd(user_desc_t *, uint_t, void *, size_t, uint_t, uint_t,
 396     uint_t, uint_t);
 397
 398 #elif defined(__i386)
 399
 400 extern void set_usegd(user_desc_t *, void *, size_t, uint_t, uint_t,
 401     uint_t, uint_t);
 402
 403 #endif  /* __i386 */
 404
 405 extern uint_t idt_vector_to_ist(uint_t);
 406
 407 extern void set_gatesegd(gate_desc_t *, void (*)(void), selector_t,
 408     uint_t, uint_t, uint_t);
 409
 410 extern void set_syssegd(system_desc_t *, void *, size_t, uint_t, uint_t);
 411
 412 extern void *get_ssd_base(system_desc_t *);
 413
 414 extern void gdt_update_usegd(uint_t, user_desc_t *);
 415
 416 extern int ldt_update_segd(user_desc_t *, user_desc_t *);
 417
 418 #if defined(__xpv)
 419
 420 extern int xen_idt_to_trap_info(uint_t, gate_desc_t *, void *);
 421 extern void xen_idt_write(gate_desc_t *, uint_t);
 422
 423 #endif  /* __xen */
 424
 425 void init_boot_gdt(user_desc_t *);
 426
 427 #endif  /* _ASM */
 428
 429 /*
 430  * Common segment parameter defintions for granularity, default
 431  * operand size and operaton mode.
 432  */
 433 #define SDP_BYTES       0       /* segment limit scaled to bytes */
 434 #define SDP_PAGES       1       /* segment limit scaled to pages */
 435 #define SDP_OP32        1       /* code and data default operand = 32 bits */
 436 #define SDP_LONG        1       /* long mode code segment (64 bits) */
 437 #define SDP_SHORT       0       /* compat/legacy code segment (32 bits) */
 438 /*
 439  * System segments and gate types.
 440  *
 441  * In long mode i386 32-bit ldt, tss, call, interrupt and trap gate
 442  * types are redefined into 64-bit equivalents.
 443  */
 444 #define SDT_SYSNULL      0      /* system null */
 445 #define SDT_SYS286TSS    1      /* system 286 TSS available */
 446 #define SDT_SYSLDT       2      /* system local descriptor table */
 447 #define SDT_SYS286BSY    3      /* system 286 TSS busy */
 448 #define SDT_SYS286CGT    4      /* system 286 call gate */
 449 #define SDT_SYSTASKGT    5      /* system task gate */
 450 #define SDT_SYS286IGT    6      /* system 286 interrupt gate */
 451 #define SDT_SYS286TGT    7      /* system 286 trap gate */
 452 #define SDT_SYSNULL2     8      /* system null again */
 453 #define SDT_SYSTSS       9      /* system TSS available */
 454 #define SDT_SYSNULL3    10      /* system null again */
 455 #define SDT_SYSTSSBSY   11      /* system TSS busy */
 456 #define SDT_SYSCGT      12      /* system call gate */
 457 #define SDT_SYSNULL4    13      /* system null again */
 458 #define SDT_SYSIGT      14      /* system interrupt gate */
 459 #define SDT_SYSTGT      15      /* system trap gate */
 460
 461 /*
 462  * Memory segment types.
 463  *
 464  * While in long mode expand-down, writable and accessed type field
 465  * attributes are ignored. Only the conforming bit is loaded by hardware
 466  * for long mode code segment descriptors.
 467  */
 468 #define SDT_MEMRO       16      /* read only */
 469 #define SDT_MEMROA      17      /* read only accessed */
 470 #define SDT_MEMRW       18      /* read write */
 471 #define SDT_MEMRWA      19      /* read write accessed */
 472 #define SDT_MEMROD      20      /* read only expand dwn limit */
 473 #define SDT_MEMRODA     21      /* read only expand dwn limit accessed */
 474 #define SDT_MEMRWD      22      /* read write expand dwn limit */
 475 #define SDT_MEMRWDA     23      /* read write expand dwn limit accessed */
 476 #define SDT_MEME        24      /* execute only */
 477 #define SDT_MEMEA       25      /* execute only accessed */
 478 #define SDT_MEMER       26      /* execute read */
 479 #define SDT_MEMERA      27      /* execute read accessed */
 480 #define SDT_MEMEC       28      /* execute only conforming */
 481 #define SDT_MEMEAC      29      /* execute only accessed conforming */
 482 #define SDT_MEMERC      30      /* execute read conforming */
 483 #define SDT_MEMERAC     31      /* execute read accessed conforming */
 484
 485 /* These bits are within the "type" field, like the values above. */
 486 #define SDT_A           0x01    /* accessed bit */
 487 #define SDT_S           0x10    /* S-bit at the top of "type" for usegs */
 488
 489 /*
 490  * Entries in the Interrupt Descriptor Table (IDT)
 491  */
 492 #define IDT_DE          0       /* #DE: Divide Error */
 493 #define IDT_DB          1       /* #DB: Debug */
 494 #define IDT_NMI         2       /* Nonmaskable External Interrupt */
 495 #define IDT_BP          3       /* #BP: Breakpoint */
 496 #define IDT_OF          4       /* #OF: Overflow */
 497 #define IDT_BR          5       /* #BR: Bound Range Exceeded */
 498 #define IDT_UD          6       /* #UD: Undefined/Invalid Opcode */
 499 #define IDT_NM          7       /* #NM: No Math Coprocessor */
 500 #define IDT_DF          8       /* #DF: Double Fault */
 501 #define IDT_FPUGP       9       /* Coprocessor Segment Overrun */
 502 #define IDT_TS          10      /* #TS: Invalid TSS */
 503 #define IDT_NP          11      /* #NP: Segment Not Present */
 504 #define IDT_SS          12      /* #SS: Stack Segment Fault */
 505 #define IDT_GP          13      /* #GP: General Protection Fault */
 506 #define IDT_PF          14      /* #PF: Page Fault */
 507 #define IDT_MF          16      /* #MF: FPU Floating-Point Error */
 508 #define IDT_AC          17      /* #AC: Alignment Check */
 509 #define IDT_MC          18      /* #MC: Machine Check */
 510 #define IDT_XF          19      /* #XF: SIMD Floating-Point Exception */
 511 #define NIDT            256     /* size in entries of IDT */
 512
 513 /*
 514  * Entries in the Global Descriptor Table (GDT)
 515  *
 516  * We make sure to space the system descriptors (LDT's, TSS')
 517  * such that they are double gdt slot aligned. This is because
 518  * in long mode system segment decriptors expand to 128 bits.
 519  *
 520  * GDT_LWPFS and GDT_LWPGS must be the same for both 32 and 64-bit
 521  * kernels. See setup_context in libc. 64-bit processes must set
 522  * %fs or %gs to null selector to use 64-bit fsbase or gsbase
 523  * respectively.
 524  */
 525 #define GDT_NULL        0       /* null */
 526 #define GDT_B32DATA     1       /* dboot 32 bit data descriptor */
 527 #define GDT_B32CODE     2       /* dboot 32 bit code descriptor */
 528 #define GDT_B16CODE     3       /* bios call 16 bit code descriptor */
 529 #define GDT_B16DATA     4       /* bios call 16 bit data descriptor */
 530 #define GDT_B64CODE     5       /* dboot 64 bit code descriptor */
 531 #define GDT_BGSTMP      7       /* kmdb descriptor only used early in boot */
 532 #define GDT_CPUID       16      /* store numeric id of current CPU */
 533
 534 #if defined(__amd64)
 535
 536 #define GDT_KCODE       6       /* kernel code seg %cs */
 537 #define GDT_KDATA       7       /* kernel data seg %ds */
 538 #define GDT_U32CODE     8       /* 32-bit process on 64-bit kernel %cs */
 539 #define GDT_UDATA       9       /* user data seg %ds (32 and 64 bit) */
 540 #define GDT_UCODE       10      /* native user code  seg %cs */
 541 #define GDT_LDT         12      /* (12-13) LDT for current process */
 542 #define GDT_KTSS        14      /* (14-15) kernel tss */
 543 #define GDT_FS          GDT_NULL /* kernel %fs segment selector */
 544 #define GDT_GS          GDT_NULL /* kernel %gs segment selector */
 545 #define GDT_LWPFS       55      /* lwp private %fs segment selector (32-bit) */
 546 #define GDT_LWPGS       56      /* lwp private %gs segment selector (32-bit) */
 547 #define GDT_BRANDMIN    57      /* first entry in GDT for brand usage */
 548 #define GDT_BRANDMAX    61      /* last entry in GDT for brand usage */
 549 #define NGDT            62      /* number of entries in GDT */
 550
 551 /*
 552  * This selector is only used in the temporary GDT used to bring additional
 553  * CPUs from 16-bit real mode into long mode in real_mode_start().
 554  */
 555 #define TEMPGDT_KCODE64 1       /* 64-bit code selector */
 556
 557 #elif defined(__i386)
 558
 559 #define GDT_LDT         40      /* LDT for current process */
 560 #define GDT_KTSS        42      /* kernel tss */
 561 #define GDT_KCODE       43      /* kernel code seg %cs */
 562 #define GDT_KDATA       44      /* kernel data seg %ds */
 563 #define GDT_UCODE       45      /* native user code  seg %cs */
 564 #define GDT_UDATA       46      /* user data seg %ds (32 and 64 bit) */
 565 #define GDT_DBFLT       47      /* double fault #DF selector */
 566 #define GDT_FS          53      /* kernel %fs segment selector */
 567 #define GDT_GS          54      /* kernel %gs segment selector */
 568 #define GDT_LWPFS       55      /* lwp private %fs segment selector */
 569 #define GDT_LWPGS       56      /* lwp private %gs segment selector */
 570 #define GDT_BRANDMIN    57      /* first entry in GDT for brand usage */
 571 #define GDT_BRANDMAX    61      /* last entry in GDT for brand usage */
 572 #if !defined(__xpv)
 573 #define NGDT            90      /* number of entries in GDT */
 574 #else
 575 #define NGDT            512     /* single 4K page for the hypervisor */
 576 #endif
 577
 578 #endif  /* __i386 */
 579
 580 /*
 581  * Convenient selector definitions.
 582  */
 583
 584 /*
 585  * XXPV 64 bit Xen only allows the guest %cs/%ss be the private ones it
 586  * provides, not the ones we create for ourselves.  See FLAT_RING3_CS64 in
 587  * public/arch-x86_64.h
 588  *
 589  * 64-bit Xen runs paravirtual guests in ring 3 but emulates them running in
 590  * ring 0 by clearing CPL in %cs value pushed on guest exception stacks.
 591  * Therefore we will have KCS_SEL value indicate ring 0 and use that everywhere
 592  * in the kernel. But in the few files where we initialize segment registers or
 593  * create and update descriptors we will explicity OR in SEL_KPL (ring 3) for
 594  * kernel %cs. See desctbls.c for an example.
 595  */
 596
 597 #if defined(__xpv) && defined(__amd64)
 598 #define KCS_SEL         0xe030          /* FLAT_RING3_CS64 & 0xFFF0 */
 599 #define KDS_SEL         0xe02b          /* FLAT_RING3_SS64 */
 600 #else
 601 #define KCS_SEL         SEL_GDT(GDT_KCODE, SEL_KPL)
 602 #define KDS_SEL         SEL_GDT(GDT_KDATA, SEL_KPL)
 603 #endif
 604
 605 #define UCS_SEL         SEL_GDT(GDT_UCODE, SEL_UPL)
 606 #if defined(__amd64)
 607 #define TEMP_CS64_SEL   SEL_GDT(TEMPGDT_KCODE64, SEL_KPL)
 608 #define U32CS_SEL       SEL_GDT(GDT_U32CODE, SEL_UPL)
 609 #endif
 610
 611 #define UDS_SEL         SEL_GDT(GDT_UDATA, SEL_UPL)
 612 #define ULDT_SEL        SEL_GDT(GDT_LDT, SEL_KPL)
 613 #define KTSS_SEL        SEL_GDT(GDT_KTSS, SEL_KPL)
 614 #define DFTSS_SEL       SEL_GDT(GDT_DBFLT, SEL_KPL)
 615 #define KFS_SEL         0
 616 #define KGS_SEL         SEL_GDT(GDT_GS, SEL_KPL)
 617 #define LWPFS_SEL       SEL_GDT(GDT_LWPFS, SEL_UPL)
 618 #define LWPGS_SEL       SEL_GDT(GDT_LWPGS, SEL_UPL)
 619 #define BRANDMIN_SEL    SEL_GDT(GDT_BRANDMIN, SEL_UPL)
 620 #define BRANDMAX_SEL    SEL_GDT(GDT_BRANDMAX, SEL_UPL)
 621
 622 #define B64CODE_SEL     SEL_GDT(GDT_B64CODE, SEL_KPL)
 623 #define B32CODE_SEL     SEL_GDT(GDT_B32CODE, SEL_KPL)
 624 #define B32DATA_SEL     SEL_GDT(GDT_B32DATA, SEL_KPL)
 625 #define B16CODE_SEL     SEL_GDT(GDT_B16CODE, SEL_KPL)
 626 #define B16DATA_SEL     SEL_GDT(GDT_B16DATA, SEL_KPL)
 627
 628 /*
 629  * Temporary %gs descriptor used by kmdb with -d option. Only lives
 630  * in boot's GDT and is not copied into kernel's GDT from boot.
 631  */
 632 #define KMDBGS_SEL      SEL_GDT(GDT_BGSTMP, SEL_KPL)
 633
 634 /*
 635  * Selector used for kdi_idt when kmdb has taken over the IDT.
 636  */
 637 #if defined(__amd64)
 638 #define KMDBCODE_SEL    B64CODE_SEL
 639 #else
 640 #define KMDBCODE_SEL    B32CODE_SEL
 641 #endif
 642
 643 /*
 644  * Entries in default Local Descriptor Table (LDT) for every process.
 645  */
 646 #define LDT_SYSCALL     0       /* call gate for libc.a (obsolete) */
 647 #define LDT_SIGCALL     1       /* EOL me, call gate for static sigreturn */
 648 #define LDT_RESVD1      2       /* old user %cs */
 649 #define LDT_RESVD2      3       /* old user %ds */
 650 #define LDT_ALTSYSCALL  4       /* alternate call gate for system calls */
 651 #define LDT_ALTSIGCALL  5       /* EOL me, alternate call gate for sigreturn */
 652 #define LDT_UDBASE      6       /* user descriptor base index */
 653 #define MINNLDT         512     /* Current min solaris ldt size (1 4K page) */
 654 #define MAXNLDT         8192    /* max solaris ldt size (16 4K pages) */
 655
 656 #ifdef _KERNEL
 657 #define LDT_CPU_SIZE    (16 * 4096)     /* Size of kernel per-CPU allocation */
 658 #endif
 659
 660 #ifndef _ASM
 661
 662 extern  gate_desc_t     *idt0;
 663 extern  desctbr_t       idt0_default_reg;
 664 extern  user_desc_t     *gdt0;
 665
 666 extern user_desc_t      zero_udesc;
 667 extern user_desc_t      null_udesc;
 668 extern system_desc_t    null_sdesc;
 669
 670 #if defined(__amd64)
 671 extern user_desc_t      zero_u32desc;
 672 #endif
 673 #if defined(__amd64)
 674 extern user_desc_t      ucs_on;
 675 extern user_desc_t      ucs_off;
 676 extern user_desc_t      ucs32_on;
 677 extern user_desc_t      ucs32_off;
 678 #endif  /* __amd64 */
 679
 680 extern tss_t *ktss0;
 681
 682 #if defined(__i386)
 683 extern tss_t *dftss0;
 684 #endif  /* __i386 */
 685
 686 extern void div0trap(), dbgtrap(), nmiint(), brktrap(), ovflotrap();
 687 extern void boundstrap(), invoptrap(), ndptrap();
 688 #if !defined(__xpv)
 689 extern void syserrtrap();
 690 #endif
 691 extern void invaltrap(), invtsstrap(), segnptrap(), stktrap();
 692 extern void gptrap(), pftrap(), ndperr();
 693 extern void overrun(), resvtrap();
 694 extern void _start(), cmnint();
 695 extern void achktrap(), mcetrap();
 696 extern void xmtrap();
 697 extern void fasttrap();
 698 extern void dtrace_ret();
 699
 700 /* KPTI trampolines */
 701 extern void tr_invaltrap();
 702 extern void tr_div0trap(), tr_dbgtrap(), tr_nmiint(), tr_brktrap();
 703 extern void tr_ovflotrap(), tr_boundstrap(), tr_invoptrap(), tr_ndptrap();
 704 #if !defined(__xpv)
 705 extern void tr_syserrtrap();
 706 #endif
 707 extern void tr_invaltrap(), tr_invtsstrap(), tr_segnptrap(), tr_stktrap();
 708 extern void tr_gptrap(), tr_pftrap(), tr_ndperr();
 709 extern void tr_overrun(), tr_resvtrap();
 710 extern void tr_achktrap(), tr_mcetrap();
 711 extern void tr_xmtrap();
 712 extern void tr_fasttrap();
 713 extern void tr_dtrace_ret();
 714
 715 #if !defined(__amd64)
 716 extern void pentium_pftrap();
 717 #endif
 718
 719 extern uint64_t kpti_enable;
 720
 721 #endif /* _ASM */
 722
 723 #ifdef  __cplusplus
 724 }
 725 #endif
 726
 727 #endif /* _SYS_SEGMENTS_H */