common-user/host/mips/safe-syscall.inc.S

   1 /*
   2  * safe-syscall.inc.S : host-specific assembly fragment
   3  * to handle signals occurring at the same time as system calls.
   4  * This is intended to be included by common-user/safe-syscall.S
   5  *
   6  * Written by Richard Henderson <richard.henderson@linaro.org>
   7  * Copyright (C) 2021 Linaro, Inc.
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  10  * See the COPYING file in the top-level directory.
  11  */
  12
  13 #include "sys/regdef.h"
  14 #include "sys/asm.h"
  15
  16         .text
  17         .set    nomips16
  18         .set    reorder
  19
  20         .global safe_syscall_start
  21         .global safe_syscall_end
  22         .type   safe_syscall_start, @function
  23         .type   safe_syscall_end, @function
  24
  25         /*
  26          * This is the entry point for making a system call. The calling
  27          * convention here is that of a C varargs function with the
  28          * first argument an 'int *' to the signal_pending flag, the
  29          * second one the system call number (as a 'long'), and all further
  30          * arguments being syscall arguments (also 'long').
  31          */
  32
  33 #if _MIPS_SIM == _ABIO32
  34 /* 8 * 4 = 32 for outgoing parameters; 1 * 4 for s0 save; 1 * 4 for align. */
  35 #define FRAME    40
  36 #define OFS_S0   32
  37 #else
  38 /* 1 * 8 for s0 save; 1 * 8 for align. */
  39 #define FRAME    16
  40 #define OFS_S0   0
  41 #endif
  42
  43
  44 NESTED(safe_syscall_base, FRAME, ra)
  45         .cfi_startproc
  46         PTR_ADDIU sp, sp, -FRAME
  47         .cfi_adjust_cfa_offset FRAME
  48         REG_S   s0, OFS_S0(sp)
  49         .cfi_rel_offset s0, OFS_S0
  50 #if _MIPS_SIM == _ABIO32
  51         /*
  52          * The syscall calling convention is nearly the same as C:
  53          * we enter with a0 == &signal_pending
  54          *               a1 == syscall number
  55          *               a2, a3, stack == syscall arguments
  56          *               and return the result in a0
  57          * and the syscall instruction needs
  58          *               v0 == syscall number
  59          *               a0 ... a3, stack == syscall arguments
  60          *               and returns the result in v0
  61          * Shuffle everything around appropriately.
  62          */
  63         move    s0, a0          /* signal_pending pointer */
  64         move    v0, a1          /* syscall number */
  65         move    a0, a2          /* syscall arguments */
  66         move    a1, a3
  67         lw      a2, FRAME+16(sp)
  68         lw      a3, FRAME+20(sp)
  69         lw      t4, FRAME+24(sp)
  70         lw      t5, FRAME+28(sp)
  71         lw      t6, FRAME+32(sp)
  72         lw      t7, FRAME+40(sp)
  73         sw      t4, 16(sp)
  74         sw      t5, 20(sp)
  75         sw      t6, 24(sp)
  76         sw      t7, 28(sp)
  77 #else
  78         /*
  79          * The syscall calling convention is nearly the same as C:
  80          * we enter with a0 == &signal_pending
  81          *               a1 == syscall number
  82          *               a2 ... a7 == syscall arguments
  83          *               and return the result in a0
  84          * and the syscall instruction needs
  85          *               v0 == syscall number
  86          *               a0 ... a5 == syscall arguments
  87          *               and returns the result in v0
  88          * Shuffle everything around appropriately.
  89          */
  90         move    s0, a0          /* signal_pending pointer */
  91         move    v0, a1          /* syscall number */
  92         move    a0, a2          /* syscall arguments */
  93         move    a1, a3
  94         move    a2, a4
  95         move    a3, a5
  96         move    a4, a6
  97         move    a5, a7
  98 #endif
  99
 100         /*
 101          * This next sequence of code works in conjunction with the
 102          * rewind_if_safe_syscall_function(). If a signal is taken
 103          * and the interrupted PC is anywhere between 'safe_syscall_start'
 104          * and 'safe_syscall_end' then we rewind it to 'safe_syscall_start'.
 105          * The code sequence must therefore be able to cope with this, and
 106          * the syscall instruction must be the final one in the sequence.
 107          */
 108 safe_syscall_start:
 109         /* If signal_pending is non-zero, don't do the call */
 110         lw      t1, 0(s0)
 111         bnez    t1, 2f
 112         syscall
 113 safe_syscall_end:
 114
 115         /* code path for having successfully executed the syscall */
 116         REG_L   s0, OFS_S0(sp)
 117         PTR_ADDIU sp, sp, FRAME
 118         .cfi_remember_state
 119         .cfi_adjust_cfa_offset -FRAME
 120         .cfi_restore s0
 121         bnez    a3, 1f
 122         jr      ra
 123         .cfi_restore_state
 124
 125         /* code path when we didn't execute the syscall */
 126 2:      REG_L   s0, OFS_S0(sp)
 127         PTR_ADDIU sp, sp, FRAME
 128         .cfi_adjust_cfa_offset -FRAME
 129         .cfi_restore s0
 130         li      v0, QEMU_ERESTARTSYS
 131
 132         /* code path setting errno */
 133         /*
 134          * We didn't setup GP on entry, optimistic of the syscall success.
 135          * We must do so now to load the address of the helper, as required
 136          * by the ABI, into t9.
 137          *
 138          * Note that SETUP_GPX and SETUP_GPX64 are themselves conditional,
 139          * so we can simply let the one that's not empty succeed.
 140          */
 141 1:      USE_ALT_CP(t0)
 142         SETUP_GPX(t1)
 143         SETUP_GPX64(t0, t1)
 144         move    a0, v0
 145         PTR_LA  t9, safe_syscall_set_errno_tail
 146         jr      t9
 147
 148         .cfi_endproc
 149 END(safe_syscall_base)