1 /*
2  * Copyright (C) 2015 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #pragma once
18 
19 #include <errno.h>
20 #include <string.h>
21 #include <sys/cdefs.h>
22 #include <sys/mman.h>
23 #include <sys/user.h>
24 
25 #include <async_safe/log.h>
26 
27 #include "platform/bionic/macros.h"
28 
29 template <typename T>
30 union WriteProtectedContents {
31   T value;
32   char padding[PAGE_SIZE];
33 
34   WriteProtectedContents() = default;
35   BIONIC_DISALLOW_COPY_AND_ASSIGN(WriteProtectedContents);
36 } __attribute__((aligned(PAGE_SIZE)));
37 
38 // Write protected wrapper class that aligns its contents to a page boundary,
39 // and sets the memory protection to be non-writable, except when being modified
40 // explicitly.
41 template <typename T>
42 class WriteProtected {
43  public:
44   static_assert(sizeof(T) < PAGE_SIZE,
45                 "WriteProtected only supports contents up to PAGE_SIZE");
46   static_assert(__is_pod(T), "WriteProtected only supports POD contents");
47 
48   WriteProtected() = default;
49   BIONIC_DISALLOW_COPY_AND_ASSIGN(WriteProtected);
50 
initialize()51   void initialize() {
52     // Not strictly necessary, but this will hopefully segfault if we initialize
53     // multiple times by accident.
54     memset(&contents, 0, sizeof(contents));
55     set_protection(PROT_READ);
56   }
57 
58   const T* operator->() {
59     return &contents.value;
60   }
61 
62   const T& operator*() {
63     return contents.value;
64   }
65 
66   template <typename Mutator>
mutate(Mutator mutator)67   void mutate(Mutator mutator) {
68     set_protection(PROT_READ | PROT_WRITE);
69     mutator(&contents.value);
70     set_protection(PROT_READ);
71   }
72 
73  private:
74   WriteProtectedContents<T> contents;
75 
set_protection(int prot)76   void set_protection(int prot) {
77     auto addr = &contents;
78 #if __has_feature(hwaddress_sanitizer)
79     // The mprotect system call does not currently untag pointers, so do it
80     // ourselves.
81     addr = untag_address(addr);
82 #endif
83     if (mprotect(reinterpret_cast<void*>(addr), PAGE_SIZE, prot) == -1) {
84       async_safe_fatal("WriteProtected mprotect %x failed: %s", prot, strerror(errno));
85     }
86   }
87 };
88