usr/src/uts/intel/brand/common/brand_asm.h

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
  23  */
  24
  25 #ifndef _COMMON_BRAND_ASM_H
  26 #define _COMMON_BRAND_ASM_H
  27
  28 #ifdef  __cplusplus
  29 extern "C" {
  30 #endif
  31
  32 #ifndef lint
  33
  34 #include <sys/asm_linkage.h>
  35 #include <sys/privregs.h>
  36 #include <sys/segments.h>
  37 #include "assym.h"
  38
  39 #endif  /* lint */
  40
  41 #ifdef _ASM     /* The remainder of this file is only for assembly files */
  42
  43 #if defined(__amd64)
  44 /*
  45  * Common to all 64-bit callbacks:
  46  *
  47  * We're running on the kernel's %gs.
  48  *
  49  * We return directly to userland, bypassing the _update_sregs logic, so
  50  * the routine must NOT do anything that could cause a context switch.
  51  *
  52  * %rax - syscall number
  53  *
  54  * When called, all general registers, except for %r15, are as they were when
  55  * the user process made the system call.  %r15 is available to the callback as
  56  * a scratch register.  If the callback returns to the kernel path, %r15 does
  57  * not have to be restored to the user value.  If the callback returns to the
  58  * userlevel emulation code, the callback should restore %r15 if the emulation
  59  * depends on the original userlevel value.
  60  *
  61  * 64-BIT INTERPOSITION STACK
  62  * On entry to the callback the stack looks like this:
  63  *         --------------------------------------
  64  *      32 | callback pointer                   |
  65  *      24 | saved stack pointer                |
  66  *    | 16 | lwp pointer                        |
  67  *    v  8 | user return address                |
  68  *       0 | BRAND_CALLBACK()'s return addr     |
  69  *         --------------------------------------
  70  */
  71
  72 #define V_COUNT 5
  73 #define V_END           (CLONGSIZE * 5)
  74 #define V_SSP           (CLONGSIZE * 3)
  75 #define V_LWP           (CLONGSIZE * 2)
  76 #define V_URET_ADDR     (CLONGSIZE * 1)
  77 #define V_CB_ADDR       (CLONGSIZE * 0)
  78
  79 #define SP_REG          %rsp
  80 #define SCR_REG         %r15
  81 #define SCR_REGB        %r15b
  82 #define SYSCALL_REG     %rax
  83
  84 /*
  85  * 64-BIT INT STACK
  86  * For int callbacks (e.g. int91) the saved stack pointer (V_SSP) points at
  87  * the state saved when we took the interrupt:
  88  *         --------------------------------------
  89  *    | 32 | user's %ss                         |
  90  *    | 24 | user's %esp                        |
  91  *    | 16 | EFLAGS register                    |
  92  *    v  8 | user's %cs                         |
  93  *       0 | user's %eip (user return address)  |
  94  *         --------------------------------------
  95  */
  96 #define V_U_EIP         (CLONGSIZE * 0)
  97
  98 #else   /* !__amd64 */
  99 /*
 100  * 32-BIT INTERPOSITION STACK
 101  * When our syscall interposition callback entry point gets invoked the
 102  * stack looks like this:
 103  *         --------------------------------------
 104  *    | 16 | 'scratch space'                    |
 105  *    | 12 | user's %ebx                        |
 106  *    |  8 | user's %gs selector                |
 107  *    v  4 | lwp pointer                        |
 108  *       0 | callback wrapper return addr       |
 109  *         --------------------------------------
 110  */
 111
 112 #define V_COUNT 5
 113 #define V_END           (CLONGSIZE * 5)
 114 #define V_U_EBX         (CLONGSIZE * 3)
 115 #define V_LWP           (CLONGSIZE * 1)
 116 #define V_CB_ADDR       (CLONGSIZE * 0)
 117
 118 #define SP_REG          %esp
 119 #define SCR_REG         %ebx
 120 #define SCR_REGB        %bl
 121 #define SYSCALL_REG     %eax
 122
 123 /*
 124  * 32-BIT INT STACK
 125  * For the lcall handler for 32-bit OS (i.e. xxx_brand_syscall_callback)
 126  * above the stack contents common to all callbacks is the int/lcall-specific
 127  * state:
 128  *         --------------------------------------
 129  *    | 36 | user's %ss                         |
 130  *    | 32 | user's %esp                        |
 131  *    | 28 | EFLAGS register                    |
 132  *    v 24 | user's %cs                         |
 133  *      20 | user's %eip (user return address)  |
 134  *         --------------------------------------
 135  */
 136 #define V_U_EIP         (V_END + (CLONGSIZE * 0))
 137
 138 #endif  /* !__amd64 */
 139
 140 /*
 141  * The following macros allow us to access to variables/parameters passed
 142  * in on the stack.  They take the following variables:
 143  *      sp      - a register with the current stack pointer value
 144  *      pcnt    - the number of words currently pushed onto the stack
 145  *      var     - the variable to lookup
 146  *      reg     - a register to read the variable into, or
 147  *                a register to write to the variable
 148  */
 149 #define V_OFFSET(pcnt, var)                                             \
 150         (var + (pcnt * CLONGSIZE))
 151
 152 #define GET_V(sp, pcnt, var, reg)                                       \
 153         mov     V_OFFSET(pcnt, var)(sp), reg
 154
 155 #define SET_V(sp, pcnt, var, reg)                                       \
 156         mov     reg, V_OFFSET(pcnt, var)(sp)
 157
 158 #define GET_PROCP(sp, pcnt, reg)                                        \
 159         GET_V(sp, pcnt, V_LWP, reg);            /* get lwp pointer */   \
 160         mov     LWP_PROCP(reg), reg             /* get proc pointer */
 161
 162 #define GET_P_BRAND_DATA(sp, pcnt, reg)                                 \
 163         GET_PROCP(sp, pcnt, reg);                                       \
 164         mov     P_BRAND_DATA(reg), reg          /* get p_brand_data */
 165
 166 /*
 167  * Each of the following macros returns to the standard syscall codepath if
 168  * it detects that this process is not able, or intended, to emulate this
 169  * system call.  They all assume that the routine provides a 'bail-out'
 170  * label of '9'.
 171  */
 172
 173 /*
 174  * See if this process has a user-space handler registered for it.  For the
 175  * brand, the per-process brand data holds the address of the handler.
 176  * As shown in the stack diagrams above, the callback code leaves the lwp
 177  * pointer at well-defined offsets, so check if proc_data_t->X_handler is
 178  * non-NULL.  For each brand, the handler parameter refers to the brand's
 179  * user-space handler variable name.
 180  */
 181 #define CHECK_FOR_HANDLER(scr, handler)                                 \
 182         GET_P_BRAND_DATA(SP_REG, 0, scr);       /* get p_brand_data */  \
 183         cmp     $0, scr;                                                \
 184         je      9f;                                                     \
 185         cmp     $0, handler(scr);               /* check handler */     \
 186         je      9f
 187
 188 /*
 189  * If the system call number is >= 1024, then it is coming from the
 190  * emulation support library.  As such we should handle it natively instead
 191  * of sending it back to the emulation library.
 192  */
 193 #define CHECK_FOR_NATIVE(reg)           \
 194         cmp     $1024, reg;             \
 195         jl      1f;                     \
 196         sub     $1024, reg;             \
 197         jmp     9f;                     \
 198 1:
 199
 200 /*
 201  * Check to see if we want to interpose on this system call.  If not, we
 202  * jump back into the normal syscall path and pretend nothing happened.
 203  * This macro is usable for brands which have the same number of syscalls
 204  * as the base OS.
 205  */
 206 #define CHECK_FOR_INTERPOSITION(emul_table, call, scr, scr_low)         \
 207         cmp     $NSYSCALL, call;        /* is 0 <= syscall <= MAX? */   \
 208         ja      9f;                     /* no, take normal ret path */  \
 209         lea     emul_table, scr;                                        \
 210         /*CSTYLED*/                                                     \
 211         mov     (scr), scr;                                             \
 212         add     call, scr;                                              \
 213         /*CSTYLED*/                                                     \
 214         movb    (scr), scr_low;                                         \
 215         cmpb    $0, scr_low;                                            \
 216         je      9f                      /* no, take normal ret path */
 217
 218 #define CALLBACK_PROLOGUE(emul_table, handler, call, scr, scr_low)      \
 219         CHECK_FOR_HANDLER(scr, handler);                                \
 220         CHECK_FOR_NATIVE(call);                                         \
 221         CHECK_FOR_INTERPOSITION(emul_table, call, scr, scr_low)
 222
 223 /*
 224  * Rather than returning to the instruction after the syscall, we need to
 225  * transfer control into the brand library's handler table at
 226  * table_addr + (16 * syscall_num), thus encoding the system call number in the
 227  * instruction pointer.  The CALC_TABLE_ADDR macro performs that calculation.
 228  *
 229  * This macro assumes the syscall number is in SYSCALL_REG and it clobbers
 230  * that register.  It leaves the calculated handler table return address in
 231  * the scratch reg.
 232  */
 233 #define CALC_TABLE_ADDR(scr, handler)                                   \
 234         GET_P_BRAND_DATA(SP_REG, 0, scr); /* get p_brand_data ptr */    \
 235         mov     handler(scr), scr;      /* get p_brand_data->XX_handler */ \
 236         shl     $4, SYSCALL_REG;        /* syscall_num * 16 */          \
 237         add     SYSCALL_REG, scr        /* leave return addr in scr reg. */
 238
 239 #endif  /* _ASM */
 240
 241 #ifdef  __cplusplus
 242 }
 243 #endif
 244
 245 #endif  /* _COMMON_BRAND_ASM_H */