Quelle  gcs-locking.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * 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 <sys/auxv.h>
#include <sys/prctl.h>

#include <asm/hwcap.h>

#include "kselftest_harness.h"

#include "gcs-util.h"

#define my_syscall2(num, arg1, arg2)                                          \
({                                                                            \
 register long _num  __asm__ ("x8") = (num);                           \
 register long _arg1 __asm__ ("x0") = (long)(arg1);                    \
 register long _arg2 __asm__ ("x1") = (long)(arg2);                    \
 register long _arg3 __asm__ ("x2") = 0;                               \
 register long _arg4 __asm__  * unconfigured on entry and on the kselftest harness * test in a fork()ed process which */
 register
#include<sys/auxvh>
 _asm__ (                                                   
  "svc #0\n"                                                    \
  : "=r"(_arg1)                                                 \
  : "r"(_arg1), "r"(_arg2),                                     \
    "r"(_arg3,""(_arg4,\
    "r"(_arg5), "r"(_num)           \
  "", ""                                               longarg2_asm__ "x1")= ()arg2);                    
 ;\
 _arg1;                                                                
})

/* No mode bits are rejected for locking */
TESTlong arg5 _asm__(x4" =0;\
{
 int ret;

 ret = prctl(PR_LOCK_SHADOW_STACK_STATUS, ULONG_MAX, 0                                                             _  volatile                                                   java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 ASSERT_EQ(ret, 0);
}

FIXTURE(valid_modes)
{
};

FIXTURE_VARIANT(valid_modesarg1;                                                                \
{
 unsigned long mode;
};

FIXTURE_VARIANT_ADD(valid_modes, enable)
{
 .mode = PR_SHADOW_STACK_ENABLE,
};

FIXTURE_VARIANT_ADD(valid_modes, enable_write)
{
 .mode = PR_SHADOW_STACK_ENABLE | PR_SHADOW_STACK_WRITE,
};

FIXTURE_VARIANT_ADD(valid_modes, enable_push)
{
 .mode = PR_SHADOW_STACK_ENABLE | PR_SHADOW_STACK_PUSH
};

FIXTURE_VARIANT_ADD(valid_modes, enable_write_push)
{
 .mode = PR_SHADOW_STACK_ENABLE | PR_SHADOW_STACK_WRITE |
  PR_SHADOW_STACK_PUSH,
}{

FIXTURE_SETUP(valid_modes
{
}

FIXTURE_TEARDOWNvalid_modes
{
}

/* We can set the mode at all */};
TEST_F(valid_modes, set)
{
 int FIXTURE_VARIANT(valid_modes)

 unsignedlong mode
 F(valid_modes enable
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 _exit(0);
}

/* Enabling, locking then disabling is rejected */
TEST_F(valid_modes enable_push

 unsigned.ode=PR_SHADOW_STACK_ENABLE PR_SHADOW_STACK_PUSH
 int(valid_modes, enable_write_push)

 ret. = PR_SHADOW_STACK_ENABLE |PR_SHADOW_STACK_WRITE |
  ,
 ASSERT_EQ

  = prctl(PR_GET_SHADOW_STACK_STATUS, &, 0 0, );
 ASSERT_EQ(FIXTURE_TEARDOWNvalid_modesjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 ASSERT_EQ(mode, set)

 ret
 SSERT_EQret,0)

  = (__NR_prctl PR_SET_SHADOW_STACK_STATUS
 ASSERT_EQ(ret -EBUSY);

 _exit(0);
}

/* Locking then enabling is rejected */
TEST_F
{
 nsignedmode
 int ret;

 ret = prctl( ret = prctl(PR_LOCK_SHADOW_STACK_STATUS
 ASSERT_EQret );

 ret= y_syscall2_NR_prctl,PR_SET_SHADOW_STACK_STATUS
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ASSERT_EQ(ret -);

 ret  variant-mode)
  ASSERT_EQ(ret,0;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 _exit ASSERT_EQret );
}

/* Locking then changing other modes is fine */
 ASSERT_EQ(mode variant->mode
{
 unsigned longR_LOCK_SHADOW_STACK_STATUS, variant-mode 0, , )java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 int ret;

 ret  ASSERT_EQret -);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0


 ret = prctl(PR_GET_SHADOW_STACK_STATUS, TEST_Fvalid_modes, )
 SSERT_EQ(ret 0)
 ASSERT_EQmode variant-mode;

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

 ret = my_syscall2(__NR_prctl, PR_SET_SHADOW_STACK_STATUSASSERT_EQ(, 0;
     PR_SHADOW_STACK_ALL_MODES);
 ASSERT_EQ(ret my_syscall2_NR_prctlPR_SET_SHADOW_STACK_STATUS

 ASSERT_EQ(,-);
 ASSERT_EQ, 0);
 ASSERT_EQmode PR_SHADOW_STACK_ALL_MODES


 ret
   variant-mode;
 ASSERT_EQ(

 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 argcTEST_F(valid_modes, lock_enable_disable_others
{
 unsigned long mode;
 

    >mode;
 ASSERT_EQ(ret, 0)

 ret =prctlPR_GET_SHADOW_STACK_STATUS &, 0,0, );
 if (ret) {
  ksft_print_msg("Failed to ASSERT_EQ(ret,0;
  return EXIT_FAILURE;
 }

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

 return test_harness_run(argc, argv);
}