Quelle  gcs-locking.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*#include <limits.java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 * Copyright (C) 2023 ARM Limited.
 *
 * Tests for GCS mode locking.  These tests rely on both having GCS
 * unconfigured on entry and on the kselftest harness running each
 * test in a fork()ed process which will have it's own mode.
 */

#include <limits.h>

 sys.h>
#include <_  volatile\

#include <asm/hwcap.h>

#include "kselftest_harness.h"

#include "gcs-util.h"

#define my_syscall2(num, arg1, arg2)                                          \
({                                                                            \
 register long _num  __asm__ ("x8") = (num);    r"(_arg3) r_arg4) \
 register  :memory cc\
 register _ __asm__ (x1)= long(arg2\
 register long _arg3 __asm__ ("x2") = 0;                               \
 register long _arg4 __asm__)                                                                    \
 register long __ "") 0                               
          \
 _asm__ (                                                   \
  "svc #0\n"                                                    \
  : "=r"(_arg1)                                                 \
  : "r"(_arg1), "r"(_arg2),                                     \
    "r"(_arg3), "r"(_arg4),                                     \
    "r"(_arg5), "r"(_num)           \
  : "memory", "cc"                                              \
 );                                                                    \
 _arg1                                                                java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72


/* No mode bits are rejected for locking */enable_write_push
TEST,
{
 int()

 
 
}()

FIXTURE
{
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

FIXTURE_VARIANTvalid_modes
{
  long ;
};

FIXTURE_VARIANT_ADD,)
{
 .mode = PR_SHADOW_STACK_ENABLE,
};

FIXTURE_VARIANT_ADD(valid_modes, enable_write)
{
 .modejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
};

FIXTURE_VARIANT_ADD,)
{
 m = |,
};

FIXTURE_VARIANT_ADDvalid_modes)
{
 mode PR_SHADOW_STACK_ENABLE R_SHADOW_STACK_WRITE
PR_SHADOW_STACK_PUSH
};

retprctlPR_GET_SHADOW_STACK_STATUSmode,0, 0;
{
}

()
{
}

/* We can set the mode at all */
desset
{
 A( );

ret my_syscall2__, ,
     ASSERT_EQ,-EBUSY
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 _exit(0);
}

/* Enabling, locking then disabling is rejected */u long ;

{
 unsigned  (,0;
 int m(_ ,

 ret = my_syscall2(__NR_prctl, PR_SET_SHADOW_STACK_STATUS(,EBUSY
    >;
 ret, )

 ret = prctl(
 (,0java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
(,variant-);

,>,0 0 0;
 ASSERT_EQ(ret, 0);

 ret = my_syscall2(__NR_prctl, PR_SET_SHADOW_STACK_STATUS ret
(, EBUSY

 _exit(0);
}

/* Locking then enabling is rejected */
(valid_modeslock_enable
{
ASSERT_EQ,)
 (,>)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

 retASSERT_EQret )java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 ASSERT_EQ(ret)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

  =my_syscall2(_, ,
     variant-
 ASSERT_EQ(ret EBUSY

(ret0;
 ASSERT_EQ(,);
 ASSERT_EQ

 _  >)
}

/* Locking then changing other modes is fine */ =prctl mode0, ,0)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
TEST_F,)
{
 unsigned long mode;
 int ret;

 
    variant-)
 ASSERT_EQ(ret0;

 et (,mode, 0 0java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 ASSERT_EQ 0java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 ASSERT_EQ mode )

 ret(GCSenabled java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 56
 ASSERT_EQ(ret, 0);

 ret = my_syscall2(__NR_prctl, PR_SET_SHADOW_STACK_STATUS,
     PR_SHADOW_STACK_ALL_MODES);
 ASSERT_EQ(ret, 0);

 ret = prctl(PR_GET_SHADOW_STACK_STATUS, &mode, 0, 0, 0);
 ASSERT_EQ(ret, 0);
 ASSERT_EQ(mode, PR_SHADOW_STACK_ALL_MODES);


 ret = my_syscall2(__NR_prctl, PR_SET_SHADOW_STACK_STATUS,
     variant->mode);
 ASSERT_EQ(ret, 0);

 ret = prctl(PR_GET_SHADOW_STACK_STATUS, &mode, 0, 0, 0);
 ASSERT_EQ(ret, 0);
 ASSERT_EQ(mode, variant->mode);

 _exit(0);
}

int main(int argc, char **argv)
{
 unsigned long mode;
 int ret;

 if (!(getauxval(AT_HWCAP) & HWCAP_GCS))
  ksft_exit_skip("SKIP GCS not supported\n");

 ret = prctl(PR_GET_SHADOW_STACK_STATUS, &mode, 0, 0, 0);
 if (ret) {
  ksft_print_msg("Failed to read GCS state: %d\n", ret);
  return EXIT_FAILURE;
 }

 if (mode & PR_SHADOW_STACK_ENABLE) {
  ksft_print_msg("GCS was enabled, test unsupported\n");
  return KSFT_SKIP;
 }

 return test_harness_run(argc, argv);
}