bsd/tests/bsd_tests.c

   1 /*
   2  * Copyright (c) 2019 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28
  29 #include <tests/ktest.h>
  30 #include <tests/xnupost.h>
  31 #include <kern/assert.h>
  32 #include <sys/param.h>
  33 #include <sys/kernel.h>
  34 #include <sys/types.h>
  35 #include <sys/kdebug.h>
  36 #include <libkern/libkern.h>
  37 #include <kern/kalloc.h>
  38 #include <sys/cdefs.h>
  39 #include <libkern/version.h>
  40 #include <kern/clock.h>
  41 #include <kern/kern_cdata.h>
  42 #include <pexpert/pexpert.h>
  43
  44
  45 #if !(DEVELOPMENT || DEBUG)
  46 #error "Testing is not enabled on RELEASE configurations"
  47 #endif
  48
  49 #ifdef __arm64__
  50 extern kern_return_t arm64_lock_test(void);
  51 #endif
  52 kern_return_t kalloc_test(void);
  53 kern_return_t ipi_test(void);
  54 #if defined(KERNEL_INTEGRITY_CTRR)
  55 extern kern_return_t ctrr_test(void);
  56 #endif
  57 #if __ARM_PAN_AVAILABLE__
  58 extern kern_return_t arm64_late_pan_test(void);
  59 #endif
  60 #if HAS_TWO_STAGE_SPR_LOCK
  61 extern kern_return_t arm64_spr_lock_test(void);
  62 #endif
  63 extern kern_return_t copyio_test(void);
  64
  65 struct xnupost_test bsd_post_tests[] = {
  66 #ifdef __arm64__
  67         XNUPOST_TEST_CONFIG_BASIC(arm64_lock_test),
  68 #endif
  69 #if defined(KERNEL_INTEGRITY_CTRR)
  70         XNUPOST_TEST_CONFIG_BASIC(ctrr_test),
  71 #endif
  72 #if __ARM_PAN_AVAILABLE__
  73         XNUPOST_TEST_CONFIG_BASIC(arm64_late_pan_test),
  74 #endif
  75         XNUPOST_TEST_CONFIG_BASIC(kalloc_test),
  76         XNUPOST_TEST_CONFIG_BASIC(ipi_test),
  77 #if HAS_TWO_STAGE_SPR_LOCK
  78         XNUPOST_TEST_CONFIG_BASIC(arm64_spr_lock_test),
  79 #endif
  80         XNUPOST_TEST_CONFIG_BASIC(copyio_test),
  81 };
  82
  83 uint32_t bsd_post_tests_count = sizeof(bsd_post_tests) / sizeof(xnupost_test_data_t);
  84
  85 extern uint64_t last_loaded_timestamp; /* updated by OSKext::load() */
  86 extern uint64_t kernel_post_args;
  87 int
  88 bsd_list_tests()
  89 {
  90         if (kernel_post_args == 0) {
  91                 return 0;
  92         }
  93
  94         uint64_t prev_load_time    = last_loaded_timestamp;
  95         int no_load_counter        = 5;
  96         int absolute_break_counter = 15;
  97         int delay_duration_usecs   = 300000; /* 0.3 second for kext loading to stabilize */
  98
  99         while (no_load_counter > 0) {
 100                 printf("bsd_list_tests:INFO waiting for %d usecs\n", delay_duration_usecs);
 101                 printf("bsd_list_tests: prev: %llu current: %llu\n", prev_load_time, last_loaded_timestamp);
 102
 103                 delay(delay_duration_usecs);
 104                 absolute_break_counter -= 1;
 105
 106                 if (absolute_break_counter <= 0) {
 107                         printf("bsd_list_tests: WARNING: Waiting beyond normal time for stabilizing kext loading\n");
 108                         break;
 109                 }
 110
 111                 if (prev_load_time == last_loaded_timestamp) {
 112                         no_load_counter -= 1;
 113                         printf("bsd_list_tests: INFO: no new kexts loaded. remaining checks: %d\n", no_load_counter);
 114                 }
 115
 116                 prev_load_time = last_loaded_timestamp;
 117         }
 118
 119         return xnupost_list_tests(bsd_post_tests, bsd_post_tests_count);
 120 }
 121
 122 int
 123 bsd_do_post()
 124 {
 125         return xnupost_run_tests(bsd_post_tests, bsd_post_tests_count);
 126 }
 127
 128 kern_return_t
 129 kalloc_test()
 130 {
 131         uint64_t * data_ptr;
 132         size_t alloc_size;
 133
 134         T_LOG("Running kalloc test.\n");
 135
 136         alloc_size = sizeof(uint64_t);
 137         data_ptr = kalloc(alloc_size);
 138         T_ASSERT_NOTNULL(data_ptr, "kalloc sizeof(uint64_t) return not null");
 139         kfree(data_ptr, alloc_size);
 140
 141         alloc_size = 3544;
 142         data_ptr = kalloc(alloc_size);
 143         T_ASSERT_NOTNULL(data_ptr, "kalloc 3544 return not null");
 144         kfree(data_ptr, alloc_size);
 145
 146         return KERN_SUCCESS;
 147 }
 148
 149 /* kcdata type definition */
 150 #define XNUPOST_TNAME_MAXLEN 132
 151
 152 struct kcdata_subtype_descriptor kc_xnupost_test_def[] = {
 153         {.kcs_flags = KCS_SUBTYPE_FLAGS_NONE, .kcs_elem_type = KC_ST_UINT16, .kcs_elem_offset = 0, .kcs_elem_size = sizeof(uint16_t), .kcs_name = "config"},
 154         {.kcs_flags = KCS_SUBTYPE_FLAGS_NONE, .kcs_elem_type = KC_ST_UINT16, .kcs_elem_offset = 1 * sizeof(uint16_t), .kcs_elem_size = sizeof(uint16_t), .kcs_name = "test_num"},
 155         {.kcs_flags = KCS_SUBTYPE_FLAGS_NONE, .kcs_elem_type = KC_ST_INT32, .kcs_elem_offset = 2 * sizeof(uint16_t), .kcs_elem_size = sizeof(int32_t), .kcs_name = "retval"},
 156         {.kcs_flags = KCS_SUBTYPE_FLAGS_NONE, .kcs_elem_type = KC_ST_INT32, .kcs_elem_offset = 2 * sizeof(uint16_t) + sizeof(int32_t), .kcs_elem_size = sizeof(int32_t), .kcs_name = "expected_retval"},
 157         {.kcs_flags = KCS_SUBTYPE_FLAGS_NONE, .kcs_elem_type = KC_ST_UINT64, .kcs_elem_offset = 2 * (sizeof(uint16_t) + sizeof(int32_t)), .kcs_elem_size = sizeof(uint64_t), .kcs_name = "begin_time"},
 158         {.kcs_flags = KCS_SUBTYPE_FLAGS_NONE, .kcs_elem_type = KC_ST_UINT64, .kcs_elem_offset = 2 * (sizeof(uint16_t) + sizeof(int32_t)) + sizeof(uint64_t), .kcs_elem_size = sizeof(uint64_t), .kcs_name = "end_time"},
 159         {.kcs_flags = KCS_SUBTYPE_FLAGS_ARRAY,
 160          .kcs_elem_type = KC_ST_CHAR,
 161          .kcs_elem_offset = 2 * (sizeof(uint16_t) + sizeof(int32_t) + sizeof(uint64_t)),
 162          .kcs_elem_size = KCS_SUBTYPE_PACK_SIZE(XNUPOST_TNAME_MAXLEN * sizeof(char), sizeof(char)),
 163          .kcs_name = "test_name"}
 164 };
 165
 166 const uint32_t kc_xnupost_test_def_count = sizeof(kc_xnupost_test_def) / sizeof(struct kcdata_subtype_descriptor);
 167
 168 kern_return_t xnupost_copyout_test(xnupost_test_t t, mach_vm_address_t outaddr);
 169
 170 int
 171 xnupost_copyout_test(xnupost_test_t t, mach_vm_address_t outaddr)
 172 {
 173         /* code to copyout test config */
 174         int kret         = 0;
 175         uint32_t namelen = 0;
 176
 177         kret = copyout(&t->xt_config, outaddr, sizeof(uint16_t));
 178         if (kret) {
 179                 return kret;
 180         }
 181         outaddr += sizeof(uint16_t);
 182
 183         kret = copyout(&t->xt_test_num, outaddr, sizeof(uint16_t));
 184         if (kret) {
 185                 return kret;
 186         }
 187         outaddr += sizeof(uint16_t);
 188
 189         kret = copyout(&t->xt_retval, outaddr, sizeof(uint32_t));
 190         if (kret) {
 191                 return kret;
 192         }
 193         outaddr += sizeof(uint32_t);
 194
 195         kret = copyout(&t->xt_expected_retval, outaddr, sizeof(uint32_t));
 196         if (kret) {
 197                 return kret;
 198         }
 199         outaddr += sizeof(uint32_t);
 200
 201         kret = copyout(&t->xt_begin_time, outaddr, sizeof(uint64_t));
 202         if (kret) {
 203                 return kret;
 204         }
 205         outaddr += sizeof(uint64_t);
 206
 207         kret = copyout(&t->xt_end_time, outaddr, sizeof(uint64_t));
 208         if (kret) {
 209                 return kret;
 210         }
 211         outaddr += sizeof(uint64_t);
 212
 213         namelen = strnlen(t->xt_name, XNUPOST_TNAME_MAXLEN);
 214         kret = copyout(t->xt_name, outaddr, namelen);
 215         if (kret) {
 216                 return kret;
 217         }
 218         outaddr += namelen;
 219
 220         return 0;
 221 }
 222
 223 uint32_t
 224 xnupost_get_estimated_testdata_size(void)
 225 {
 226         uint32_t total_tests = bsd_post_tests_count + kernel_post_tests_count;
 227         uint32_t elem_size = kc_xnupost_test_def[kc_xnupost_test_def_count - 1].kcs_elem_offset +
 228             kcs_get_elem_size(&kc_xnupost_test_def[kc_xnupost_test_def_count - 1]);
 229         uint32_t retval = 1024; /* account for type definition and mach timebase */
 230         retval += 1024;         /* kernel version and boot-args string data */
 231         retval += (total_tests * elem_size);
 232
 233         return retval;
 234 }
 235
 236 int
 237 xnupost_export_testdata(void * outp, uint32_t size, uint32_t * lenp)
 238 {
 239         struct kcdata_descriptor kcd;
 240         mach_vm_address_t user_addr        = 0;
 241         mach_vm_address_t tmp_entry_addr   = 0;
 242         kern_return_t kret                 = 0;
 243         uint32_t i                         = 0;
 244         char kctype_name[32]               = "xnupost_test_config";
 245         mach_timebase_info_data_t timebase = {0, 0};
 246         uint32_t length_to_copy            = 0;
 247
 248 #define RET_IF_OP_FAIL                                                                                       \
 249         do {                                                                                                     \
 250                 if (kret != KERN_SUCCESS) {                                                                          \
 251                         return (kret == KERN_NO_ACCESS) ? EACCES : ((kret == KERN_RESOURCE_SHORTAGE) ? ENOMEM : EINVAL); \
 252                 }                                                                                                    \
 253         } while (0)
 254
 255         kret = kcdata_memory_static_init(&kcd, (mach_vm_address_t)outp, KCDATA_BUFFER_BEGIN_XNUPOST_CONFIG, size, KCFLAG_USE_COPYOUT);
 256         RET_IF_OP_FAIL;
 257
 258         /* add mach timebase info */
 259         clock_timebase_info(&timebase);
 260         kret = kcdata_get_memory_addr(&kcd, KCDATA_TYPE_TIMEBASE, sizeof(timebase), &user_addr);
 261         RET_IF_OP_FAIL;
 262         kret = copyout(&timebase, user_addr, sizeof(timebase));
 263         RET_IF_OP_FAIL;
 264
 265         /* save boot-args and osversion string */
 266         length_to_copy = MIN((uint32_t)(strlen(version) + 1), OSVERSIZE);
 267         kret           = kcdata_get_memory_addr(&kcd, STACKSHOT_KCTYPE_OSVERSION, length_to_copy, &user_addr);
 268         RET_IF_OP_FAIL;
 269         kret = copyout(&version[0], user_addr, length_to_copy);
 270         RET_IF_OP_FAIL;
 271
 272         length_to_copy = MIN((uint32_t)(strlen(PE_boot_args()) + 1), BOOT_LINE_LENGTH);
 273         kret           = kcdata_get_memory_addr(&kcd, STACKSHOT_KCTYPE_BOOTARGS, length_to_copy, &user_addr);
 274         RET_IF_OP_FAIL;
 275         kret = copyout(PE_boot_args(), user_addr, length_to_copy);
 276         RET_IF_OP_FAIL;
 277
 278         /* add type definition to buffer */
 279         kret = kcdata_add_type_definition(&kcd, XNUPOST_KCTYPE_TESTCONFIG, kctype_name, &kc_xnupost_test_def[0],
 280             kc_xnupost_test_def_count);
 281         RET_IF_OP_FAIL;
 282
 283         /* add the tests to buffer as array */
 284         uint32_t total_tests = bsd_post_tests_count + kernel_post_tests_count;
 285         uint32_t elem_size = kc_xnupost_test_def[kc_xnupost_test_def_count - 1].kcs_elem_offset +
 286             kcs_get_elem_size(&kc_xnupost_test_def[kc_xnupost_test_def_count - 1]);
 287
 288         kret = kcdata_get_memory_addr_for_array(&kcd, XNUPOST_KCTYPE_TESTCONFIG, elem_size, total_tests, &user_addr);
 289         RET_IF_OP_FAIL;
 290
 291         for (i = 0; i < bsd_post_tests_count; i++) {
 292                 tmp_entry_addr = (mach_vm_address_t)((uint64_t)(user_addr) + (uint64_t)(i * elem_size));
 293                 kret           = xnupost_copyout_test(&bsd_post_tests[i], tmp_entry_addr);
 294                 RET_IF_OP_FAIL;
 295         }
 296         user_addr = (mach_vm_address_t)((uint64_t)(user_addr) + (uint64_t)(i * elem_size));
 297
 298         for (i = 0; i < kernel_post_tests_count; i++) {
 299                 tmp_entry_addr = (mach_vm_address_t)((uint64_t)(user_addr) + (uint64_t)(i * elem_size));
 300                 kret           = xnupost_copyout_test(&kernel_post_tests[i], tmp_entry_addr);
 301                 RET_IF_OP_FAIL;
 302         }
 303
 304         if (kret == KERN_SUCCESS && lenp != NULL) {
 305                 *lenp = (uint32_t)kcdata_memory_get_used_bytes(&kcd);
 306         }
 307         RET_IF_OP_FAIL;
 308
 309 #undef RET_IF_OP_FAIL
 310         return kret;
 311 }
 312
 313 int
 314 xnupost_reset_all_tests(void)
 315 {
 316         xnupost_reset_tests(&bsd_post_tests[0], bsd_post_tests_count);
 317         xnupost_reset_tests(&kernel_post_tests[0], kernel_post_tests_count);
 318         return 0;
 319 }