1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * * Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * * Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in 12 * the documentation and/or other materials provided with the 13 * distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 18 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 19 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 22 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 25 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #pragma once 30 31 #include <pthread.h> 32 #include <signal.h> 33 #include <stdint.h> 34 #include <unistd.h> 35 36 #include <atomic> 37 #include <memory> 38 #include <mutex> 39 #include <string> 40 #include <vector> 41 42 #include <platform/bionic/macros.h> 43 44 class RecordEntry { 45 public: 46 RecordEntry(); 47 virtual ~RecordEntry() = default; 48 49 virtual bool Write(int fd) const = 0; 50 51 protected: 52 pid_t tid_; 53 54 private: 55 BIONIC_DISALLOW_COPY_AND_ASSIGN(RecordEntry); 56 }; 57 58 class ThreadCompleteEntry : public RecordEntry { 59 public: 60 ThreadCompleteEntry() = default; 61 virtual ~ThreadCompleteEntry() = default; 62 63 bool Write(int fd) const override; 64 65 private: 66 BIONIC_DISALLOW_COPY_AND_ASSIGN(ThreadCompleteEntry); 67 }; 68 69 class AllocEntry : public RecordEntry { 70 public: 71 explicit AllocEntry(void* pointer, uint64_t st, uint64_t et); 72 virtual ~AllocEntry() = default; 73 74 protected: 75 void* pointer_; 76 77 // The start/end time of this operation. 78 uint64_t start_ns_; 79 uint64_t end_ns_; 80 81 private: 82 BIONIC_DISALLOW_COPY_AND_ASSIGN(AllocEntry); 83 }; 84 85 class MallocEntry : public AllocEntry { 86 public: 87 MallocEntry(void* pointer, size_t size, uint64_t st, uint64_t et); 88 virtual ~MallocEntry() = default; 89 90 bool Write(int fd) const override; 91 92 protected: 93 size_t size_; 94 95 private: 96 BIONIC_DISALLOW_COPY_AND_ASSIGN(MallocEntry); 97 }; 98 99 class FreeEntry : public AllocEntry { 100 public: 101 explicit FreeEntry(void* pointer, uint64_t st, uint64_t et); 102 virtual ~FreeEntry() = default; 103 104 bool Write(int fd) const override; 105 106 private: 107 BIONIC_DISALLOW_COPY_AND_ASSIGN(FreeEntry); 108 }; 109 110 class CallocEntry : public MallocEntry { 111 public: 112 CallocEntry(void* pointer, size_t nmemb, size_t size, uint64_t st, uint64_t et); 113 virtual ~CallocEntry() = default; 114 115 bool Write(int fd) const override; 116 117 protected: 118 size_t nmemb_; 119 120 private: 121 BIONIC_DISALLOW_COPY_AND_ASSIGN(CallocEntry); 122 }; 123 124 class ReallocEntry : public MallocEntry { 125 public: 126 ReallocEntry(void* pointer, size_t size, void* old_pointer, uint64_t st, uint64_t et); 127 virtual ~ReallocEntry() = default; 128 129 bool Write(int fd) const override; 130 131 protected: 132 void* old_pointer_; 133 134 private: 135 BIONIC_DISALLOW_COPY_AND_ASSIGN(ReallocEntry); 136 }; 137 138 // aligned_alloc, posix_memalign, memalign, pvalloc, valloc all recorded with this class. 139 class MemalignEntry : public MallocEntry { 140 public: 141 MemalignEntry(void* pointer, size_t size, size_t alignment, uint64_t st, uint64_t et); 142 virtual ~MemalignEntry() = default; 143 144 bool Write(int fd) const override; 145 146 protected: 147 size_t alignment_; 148 149 private: 150 BIONIC_DISALLOW_COPY_AND_ASSIGN(MemalignEntry); 151 }; 152 153 class Config; 154 155 class RecordData { 156 public: 157 RecordData(); 158 virtual ~RecordData(); 159 160 bool Initialize(const Config& config); 161 162 void AddEntry(const RecordEntry* entry); 163 void AddEntryOnly(const RecordEntry* entry); 164 key()165 pthread_key_t key() { return key_; } 166 167 private: 168 static void WriteData(int, siginfo_t*, void*); 169 static RecordData* record_obj_; 170 171 void WriteEntries(); 172 173 std::mutex entries_lock_; 174 pthread_key_t key_; 175 std::vector<std::unique_ptr<const RecordEntry>> entries_; 176 size_t cur_index_; 177 std::string dump_file_; 178 179 BIONIC_DISALLOW_COPY_AND_ASSIGN(RecordData); 180 }; 181