linux/tools/testing/selftests/powerpc/syscalls/rtas_filter.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * Copyright 2005-2020 IBM Corporation.
   4 *
   5 * Includes code from librtas (https://github.com/ibm-power-utilities/librtas/)
   6 */
   7
   8#include <byteswap.h>
   9#include <stdint.h>
  10#include <inttypes.h>
  11#include <stdio.h>
  12#include <string.h>
  13#include <sys/syscall.h>
  14#include <sys/types.h>
  15#include <unistd.h>
  16#include <stdarg.h>
  17#include <stdlib.h>
  18#include <fcntl.h>
  19#include <errno.h>
  20#include "utils.h"
  21
  22#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
  23#define cpu_to_be32(x)          bswap_32(x)
  24#define be32_to_cpu(x)          bswap_32(x)
  25#else
  26#define cpu_to_be32(x)          (x)
  27#define be32_to_cpu(x)          (x)
  28#endif
  29
  30#define RTAS_IO_ASSERT  -1098   /* Unexpected I/O Error */
  31#define RTAS_UNKNOWN_OP -1099   /* No Firmware Implementation of Function */
  32#define BLOCK_SIZE 4096
  33#define PAGE_SIZE 4096
  34#define MAX_PAGES 64
  35
  36static const char *ofdt_rtas_path = "/proc/device-tree/rtas";
  37
  38typedef __be32 uint32_t;
  39struct rtas_args {
  40        __be32 token;
  41        __be32 nargs;
  42        __be32 nret;
  43        __be32 args[16];
  44        __be32 *rets;     /* Pointer to return values in args[]. */
  45};
  46
  47struct region {
  48        uint64_t addr;
  49        uint32_t size;
  50        struct region *next;
  51};
  52
  53int read_entire_file(int fd, char **buf, size_t *len)
  54{
  55        size_t buf_size = 0;
  56        size_t off = 0;
  57        int rc;
  58
  59        *buf = NULL;
  60        do {
  61                buf_size += BLOCK_SIZE;
  62                if (*buf == NULL)
  63                        *buf = malloc(buf_size);
  64                else
  65                        *buf = realloc(*buf, buf_size);
  66
  67                if (*buf == NULL)
  68                        return -ENOMEM;
  69
  70                rc = read(fd, *buf + off, BLOCK_SIZE);
  71                if (rc < 0)
  72                        return -EIO;
  73
  74                off += rc;
  75        } while (rc == BLOCK_SIZE);
  76
  77        if (len)
  78                *len = off;
  79
  80        return 0;
  81}
  82
  83static int open_prop_file(const char *prop_path, const char *prop_name, int *fd)
  84{
  85        char *path;
  86        int len;
  87
  88        /* allocate enough for two string, a slash and trailing NULL */
  89        len = strlen(prop_path) + strlen(prop_name) + 1 + 1;
  90        path = malloc(len);
  91        if (path == NULL)
  92                return -ENOMEM;
  93
  94        snprintf(path, len, "%s/%s", prop_path, prop_name);
  95
  96        *fd = open(path, O_RDONLY);
  97        free(path);
  98        if (*fd < 0)
  99                return -errno;
 100
 101        return 0;
 102}
 103
 104static int get_property(const char *prop_path, const char *prop_name,
 105                        char **prop_val, size_t *prop_len)
 106{
 107        int rc, fd;
 108
 109        rc = open_prop_file(prop_path, prop_name, &fd);
 110        if (rc)
 111                return rc;
 112
 113        rc = read_entire_file(fd, prop_val, prop_len);
 114        close(fd);
 115
 116        return rc;
 117}
 118
 119int rtas_token(const char *call_name)
 120{
 121        char *prop_buf = NULL;
 122        size_t len;
 123        int rc;
 124
 125        rc = get_property(ofdt_rtas_path, call_name, &prop_buf, &len);
 126        if (rc < 0) {
 127                rc = RTAS_UNKNOWN_OP;
 128                goto err;
 129        }
 130
 131        rc = be32_to_cpu(*(int *)prop_buf);
 132
 133err:
 134        free(prop_buf);
 135        return rc;
 136}
 137
 138static int read_kregion_bounds(struct region *kregion)
 139{
 140        char *buf;
 141        int fd;
 142        int rc;
 143
 144        fd = open("/proc/ppc64/rtas/rmo_buffer", O_RDONLY);
 145        if (fd < 0) {
 146                printf("Could not open rmo_buffer file\n");
 147                return RTAS_IO_ASSERT;
 148        }
 149
 150        rc = read_entire_file(fd, &buf, NULL);
 151        close(fd);
 152        if (rc) {
 153                free(buf);
 154                return rc;
 155        }
 156
 157        sscanf(buf, "%" SCNx64 " %x", &kregion->addr, &kregion->size);
 158        free(buf);
 159
 160        if (!(kregion->size && kregion->addr) ||
 161            (kregion->size > (PAGE_SIZE * MAX_PAGES))) {
 162                printf("Unexpected kregion bounds\n");
 163                return RTAS_IO_ASSERT;
 164        }
 165
 166        return 0;
 167}
 168
 169static int rtas_call(const char *name, int nargs,
 170                     int nrets, ...)
 171{
 172        struct rtas_args args;
 173        __be32 *rets[16];
 174        int i, rc, token;
 175        va_list ap;
 176
 177        va_start(ap, nrets);
 178
 179        token = rtas_token(name);
 180        if (token == RTAS_UNKNOWN_OP) {
 181                // We don't care if the call doesn't exist
 182                printf("call '%s' not available, skipping...", name);
 183                rc = RTAS_UNKNOWN_OP;
 184                goto err;
 185        }
 186
 187        args.token = cpu_to_be32(token);
 188        args.nargs = cpu_to_be32(nargs);
 189        args.nret = cpu_to_be32(nrets);
 190
 191        for (i = 0; i < nargs; i++)
 192                args.args[i] = (__be32) va_arg(ap, unsigned long);
 193
 194        for (i = 0; i < nrets; i++)
 195                rets[i] = (__be32 *) va_arg(ap, unsigned long);
 196
 197        rc = syscall(__NR_rtas, &args);
 198        if (rc) {
 199                rc = -errno;
 200                goto err;
 201        }
 202
 203        if (nrets) {
 204                *(rets[0]) = be32_to_cpu(args.args[nargs]);
 205
 206                for (i = 1; i < nrets; i++) {
 207                        *(rets[i]) = args.args[nargs + i];
 208                }
 209        }
 210
 211err:
 212        va_end(ap);
 213        return rc;
 214}
 215
 216static int test(void)
 217{
 218        struct region rmo_region;
 219        uint32_t rmo_start;
 220        uint32_t rmo_end;
 221        __be32 rets[1];
 222        int rc;
 223
 224        // Test a legitimate harmless call
 225        // Expected: call succeeds
 226        printf("Test a permitted call, no parameters... ");
 227        rc = rtas_call("get-time-of-day", 0, 1, rets);
 228        printf("rc: %d\n", rc);
 229        FAIL_IF(rc != 0 && rc != RTAS_UNKNOWN_OP);
 230
 231        // Test a prohibited call
 232        // Expected: call returns -EINVAL
 233        printf("Test a prohibited call... ");
 234        rc = rtas_call("nvram-fetch", 0, 1, rets);
 235        printf("rc: %d\n", rc);
 236        FAIL_IF(rc != -EINVAL && rc != RTAS_UNKNOWN_OP);
 237
 238        // Get RMO
 239        rc = read_kregion_bounds(&rmo_region);
 240        if (rc) {
 241                printf("Couldn't read RMO region bounds, skipping remaining cases\n");
 242                return 0;
 243        }
 244        rmo_start = rmo_region.addr;
 245        rmo_end = rmo_start + rmo_region.size - 1;
 246        printf("RMO range: %08x - %08x\n", rmo_start, rmo_end);
 247
 248        // Test a permitted call, user-supplied size, buffer inside RMO
 249        // Expected: call succeeds
 250        printf("Test a permitted call, user-supplied size, buffer inside RMO... ");
 251        rc = rtas_call("ibm,get-system-parameter", 3, 1, 0, cpu_to_be32(rmo_start),
 252                       cpu_to_be32(rmo_end - rmo_start + 1), rets);
 253        printf("rc: %d\n", rc);
 254        FAIL_IF(rc != 0 && rc != RTAS_UNKNOWN_OP);
 255
 256        // Test a permitted call, user-supplied size, buffer start outside RMO
 257        // Expected: call returns -EINVAL
 258        printf("Test a permitted call, user-supplied size, buffer start outside RMO... ");
 259        rc = rtas_call("ibm,get-system-parameter", 3, 1, 0, cpu_to_be32(rmo_end + 1),
 260                       cpu_to_be32(4000), rets);
 261        printf("rc: %d\n", rc);
 262        FAIL_IF(rc != -EINVAL && rc != RTAS_UNKNOWN_OP);
 263
 264        // Test a permitted call, user-supplied size, buffer end outside RMO
 265        // Expected: call returns -EINVAL
 266        printf("Test a permitted call, user-supplied size, buffer end outside RMO... ");
 267        rc = rtas_call("ibm,get-system-parameter", 3, 1, 0, cpu_to_be32(rmo_start),
 268                       cpu_to_be32(rmo_end - rmo_start + 2), rets);
 269        printf("rc: %d\n", rc);
 270        FAIL_IF(rc != -EINVAL && rc != RTAS_UNKNOWN_OP);
 271
 272        // Test a permitted call, fixed size, buffer end outside RMO
 273        // Expected: call returns -EINVAL
 274        printf("Test a permitted call, fixed size, buffer end outside RMO... ");
 275        rc = rtas_call("ibm,configure-connector", 2, 1, cpu_to_be32(rmo_end - 4000), 0, rets);
 276        printf("rc: %d\n", rc);
 277        FAIL_IF(rc != -EINVAL && rc != RTAS_UNKNOWN_OP);
 278
 279        return 0;
 280}
 281
 282int main(int argc, char *argv[])
 283{
 284        return test_harness(test, "rtas_filter");
 285}
 286
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.