powerpc/security/uaccess_flush.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002
0003 /*
0004  * Copyright 2018 IBM Corporation.
0005  * Copyright 2020 Canonical Ltd.
0006  */
0007
0008 #define __SANE_USERSPACE_TYPES__
0009
0010 #include <sys/types.h>
0011 #include <stdint.h>
0012 #include <malloc.h>
0013 #include <unistd.h>
0014 #include <signal.h>
0015 #include <stdlib.h>
0016 #include <string.h>
0017 #include <stdio.h>
0018 #include "utils.h"
0019 #include "flush_utils.h"
0020
0021 int uaccess_flush_test(void)
0022 {
0023     char *p;
0024     int repetitions = 10;
0025     int fd, passes = 0, iter, rc = 0;
0026     struct perf_event_read v;
0027     __u64 l1d_misses_total = 0;
0028     unsigned long iterations = 100000, zero_size = 24 * 1024;
0029     unsigned long l1d_misses_expected;
0030     int rfi_flush_orig;
0031     int entry_flush_orig;
0032     int uaccess_flush, uaccess_flush_orig;
0033
0034     SKIP_IF(geteuid() != 0);
0035
0036     // The PMU event we use only works on Power7 or later
0037     SKIP_IF(!have_hwcap(PPC_FEATURE_ARCH_2_06));
0038
0039     if (read_debugfs_file("powerpc/rfi_flush", &rfi_flush_orig) < 0) {
0040         perror("Unable to read powerpc/rfi_flush debugfs file");
0041         SKIP_IF(1);
0042     }
0043
0044     if (read_debugfs_file("powerpc/entry_flush", &entry_flush_orig) < 0) {
0045         perror("Unable to read powerpc/entry_flush debugfs file");
0046         SKIP_IF(1);
0047     }
0048
0049     if (read_debugfs_file("powerpc/uaccess_flush", &uaccess_flush_orig) < 0) {
0050         perror("Unable to read powerpc/entry_flush debugfs file");
0051         SKIP_IF(1);
0052     }
0053
0054     if (rfi_flush_orig != 0) {
0055         if (write_debugfs_file("powerpc/rfi_flush", 0) < 0) {
0056             perror("error writing to powerpc/rfi_flush debugfs file");
0057             FAIL_IF(1);
0058         }
0059     }
0060
0061     if (entry_flush_orig != 0) {
0062         if (write_debugfs_file("powerpc/entry_flush", 0) < 0) {
0063             perror("error writing to powerpc/entry_flush debugfs file");
0064             FAIL_IF(1);
0065         }
0066     }
0067
0068     uaccess_flush = uaccess_flush_orig;
0069
0070     fd = perf_event_open_counter(PERF_TYPE_HW_CACHE, PERF_L1D_READ_MISS_CONFIG, -1);
0071     FAIL_IF(fd < 0);
0072
0073     p = (char *)memalign(zero_size, CACHELINE_SIZE);
0074
0075     FAIL_IF(perf_event_enable(fd));
0076
0077     // disable L1 prefetching
0078     set_dscr(1);
0079
0080     iter = repetitions;
0081
0082     /*
0083      * We expect to see l1d miss for each cacheline access when entry_flush
0084      * is set. Allow a small variation on this.
0085      */
0086     l1d_misses_expected = iterations * (zero_size / CACHELINE_SIZE - 2);
0087
0088 again:
0089     FAIL_IF(perf_event_reset(fd));
0090
0091     syscall_loop_uaccess(p, iterations, zero_size);
0092
0093     FAIL_IF(read(fd, &v, sizeof(v)) != sizeof(v));
0094
0095     if (uaccess_flush && v.l1d_misses >= l1d_misses_expected)
0096         passes++;
0097     else if (!uaccess_flush && v.l1d_misses < (l1d_misses_expected / 2))
0098         passes++;
0099
0100     l1d_misses_total += v.l1d_misses;
0101
0102     while (--iter)
0103         goto again;
0104
0105     if (passes < repetitions) {
0106         printf("FAIL (L1D misses with uaccess_flush=%d: %llu %c %lu) [%d/%d failures]\n",
0107                uaccess_flush, l1d_misses_total, uaccess_flush ? '<' : '>',
0108                uaccess_flush ? repetitions * l1d_misses_expected :
0109                repetitions * l1d_misses_expected / 2,
0110                repetitions - passes, repetitions);
0111         rc = 1;
0112     } else {
0113         printf("PASS (L1D misses with uaccess_flush=%d: %llu %c %lu) [%d/%d pass]\n",
0114                uaccess_flush, l1d_misses_total, uaccess_flush ? '>' : '<',
0115                uaccess_flush ? repetitions * l1d_misses_expected :
0116                repetitions * l1d_misses_expected / 2,
0117                passes, repetitions);
0118     }
0119
0120     if (uaccess_flush == uaccess_flush_orig) {
0121         uaccess_flush = !uaccess_flush_orig;
0122         if (write_debugfs_file("powerpc/uaccess_flush", uaccess_flush) < 0) {
0123             perror("error writing to powerpc/uaccess_flush debugfs file");
0124             return 1;
0125         }
0126         iter = repetitions;
0127         l1d_misses_total = 0;
0128         passes = 0;
0129         goto again;
0130     }
0131
0132     perf_event_disable(fd);
0133     close(fd);
0134
0135     set_dscr(0);
0136
0137     if (write_debugfs_file("powerpc/rfi_flush", rfi_flush_orig) < 0) {
0138         perror("unable to restore original value of powerpc/rfi_flush debugfs file");
0139         return 1;
0140     }
0141
0142     if (write_debugfs_file("powerpc/entry_flush", entry_flush_orig) < 0) {
0143         perror("unable to restore original value of powerpc/entry_flush debugfs file");
0144         return 1;
0145     }
0146
0147     if (write_debugfs_file("powerpc/uaccess_flush", uaccess_flush_orig) < 0) {
0148         perror("unable to restore original value of powerpc/uaccess_flush debugfs file");
0149         return 1;
0150     }
0151
0152     return rc;
0153 }
0154
0155 int main(int argc, char *argv[])
0156 {
0157     return test_harness(uaccess_flush_test, "uaccess_flush_test");
0158 }