granicus.if.org Git - strace/blob - tests/pkey_mprotect.c

   1 /*
   2  * Check decoding of pkey_mprotect syscall.
   3  *
   4  * Copyright (c) 2016 Eugene Syromyatnikov <evgsyr@gmail.com>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. The name of the author may not be used to endorse or promote products
  16  *    derived from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include "tests.h"
  31
  32 #include <asm/unistd.h>
  33
  34 #if defined __NR_pkey_mprotect
  35
  36 # include <stdio.h>
  37 # include <unistd.h>
  38
  39 #include <sys/mman.h>
  40
  41 # include "kernel_types.h"
  42
  43 const char *
  44 sprintptr(kernel_ulong_t ptr)
  45 {
  46         static char buf[sizeof(ptr) * 2 + sizeof("0x")];
  47
  48         if (ptr)
  49                 snprintf(buf, sizeof(buf), "%#llx", (unsigned long long) ptr);
  50         else
  51                 return "NULL";
  52
  53         return buf;
  54 }
  55
  56 int
  57 main(void)
  58 {
  59         static const kernel_ulong_t ptrs[] = {
  60                 0,
  61                 (kernel_ulong_t) 0xfacebeef00000000ULL,
  62                 (kernel_ulong_t) 0xbadc0dedda7a1057ULL,
  63         };
  64         static const kernel_ulong_t sizes[] = {
  65                 0,
  66                 (kernel_ulong_t) 0xfacebeef00000000ULL,
  67                 (kernel_ulong_t) 0xfedcba9876543210ULL,
  68                 (kernel_ulong_t) 0x123456789abcdef0ULL,
  69                 (kernel_ulong_t) 0xbadc0dedda7a1057ULL,
  70         };
  71         static const struct {
  72                 kernel_ulong_t val;
  73                 const char *str;
  74         } prots[] = {
  75                 { ARG_STR(PROT_READ) },
  76                 /* For now, only 0x0300001f are used */
  77                 { (kernel_ulong_t) 0xdeadfeed00ca7500ULL,
  78                         sizeof(kernel_ulong_t) > sizeof(int) ?
  79                         "0xdeadfeed00ca7500 /* PROT_??? */" :
  80                         "0xca7500 /* PROT_??? */" },
  81                 { ARG_STR(PROT_READ|PROT_WRITE|0xface00) },
  82         };
  83         static const kernel_ulong_t pkeys[] = {
  84                 0,
  85                 -1LL,
  86                 (kernel_ulong_t) 0xface1e55,
  87                 (kernel_ulong_t) 0xbadc0ded00000001,
  88         };
  89
  90         long rc;
  91         unsigned int i;
  92         unsigned int j;
  93         unsigned int k;
  94         unsigned int l;
  95
  96         for (i = 0; i < ARRAY_SIZE(ptrs); i++) {
  97                 for (j = 0; j < ARRAY_SIZE(sizes); j++) {
  98                         for (k = 0; k < ARRAY_SIZE(prots); k++) {
  99                                 for (l = 0; l < ARRAY_SIZE(pkeys); l++) {
 100                                         rc = syscall(__NR_pkey_mprotect,
 101                                                      ptrs[i], sizes[j],
 102                                                      prots[k].val, pkeys[l]);
 103                                         printf("pkey_mprotect(%s, %llu, %s, %d)"
 104                                                " = %s\n",
 105                                                sprintptr(ptrs[i]),
 106                                                (unsigned long long) sizes[j],
 107                                                prots[k].str, (int) pkeys[l],
 108                                                sprintrc(rc));
 109                                 }
 110                         }
 111                 }
 112         }
 113
 114         puts("+++ exited with 0 +++");
 115
 116         return 0;
 117 }
 118
 119 #else
 120
 121 SKIP_MAIN_UNDEFINED("__NR_pkey_mprotect");
 122
 123 #endif