2 * This file is part of PowerDNS or dnsdist.
3 * Copyright -- PowerDNS.COM B.V. and its contributors
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * In addition, for the avoidance of any doubt, permission is granted to
10 * link this program with OpenSSL and to (re)distribute the binaries
11 * produced as the result of such linking.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
26 #include "dnsdist-protocols.hh"
29 #include "uuid-utils.hh"
34 class DNSDistPacketCache;
36 using QTag = std::unordered_map<string, string>;
40 StopWatch(bool realTime = false) :
41 d_needRealTime(realTime)
47 d_start = getCurrentTime();
50 void set(const struct timespec& from)
57 struct timespec now = getCurrentTime();
58 return 1000000.0 * (now.tv_sec - d_start.tv_sec) + (now.tv_nsec - d_start.tv_nsec) / 1000.0;
63 struct timespec now = getCurrentTime();
64 auto ret = 1000000.0 * (now.tv_sec - d_start.tv_sec) + (now.tv_nsec - d_start.tv_nsec) / 1000.0;
69 struct timespec getStartTime() const
74 struct timespec d_start
80 struct timespec getCurrentTime() const
83 if (gettime(&now, d_needRealTime) < 0) {
84 unixDie("Getting timestamp");
92 /* g++ defines __SANITIZE_THREAD__
93 clang++ supports the nice __has_feature(thread_sanitizer),
95 #if defined(__has_feature)
96 #if __has_feature(thread_sanitizer)
97 #define __SANITIZE_THREAD__ 1
101 struct InternalQueryState
103 static void DeleterPlaceHolder(DOHUnit*)
107 InternalQueryState() :
108 du(std::unique_ptr<DOHUnit, void (*)(DOHUnit*)>(nullptr, DeleterPlaceHolder))
110 origDest.sin4.sin_family = 0;
113 InternalQueryState(InternalQueryState&& rhs) = default;
114 InternalQueryState& operator=(InternalQueryState&& rhs) = default;
116 InternalQueryState(const InternalQueryState& orig) = delete;
117 InternalQueryState& operator=(const InternalQueryState& orig) = delete;
119 boost::optional<Netmask> subnet{boost::none}; // 40
120 ComboAddress origRemote; // 28
121 ComboAddress origDest; // 28
122 ComboAddress hopRemote;
123 ComboAddress hopLocal;
125 std::string poolName; // 24
126 StopWatch queryRealTime{true}; // 16
127 std::shared_ptr<DNSDistPacketCache> packetCache{nullptr}; // 16
128 std::unique_ptr<DNSCryptQuery> dnsCryptQuery{nullptr}; // 8
129 std::unique_ptr<QTag> qTag{nullptr}; // 8
130 std::unique_ptr<PacketBuffer> d_packet; // Initial packet, so we can restart the query from the response path if needed // 8
131 boost::optional<uint32_t> tempFailureTTL{boost::none}; // 8
132 ClientState* cs{nullptr}; // 8
133 std::unique_ptr<DOHUnit, void (*)(DOHUnit*)> du; // 8
134 uint32_t cacheKey{0}; // 4
135 uint32_t cacheKeyNoECS{0}; // 4
137 uint32_t cacheKeyUDP{0}; // 4
138 uint32_t ttlCap{0}; // cap the TTL _after_ inserting into the packet cache // 4
139 int backendFD{-1}; // 4
141 uint16_t qtype{0}; // 2
142 uint16_t qclass{0}; // 2
143 // origID is in network-byte order
144 uint16_t origID{0}; // 2
145 uint16_t origFlags{0}; // 2
146 uint16_t cacheFlags{0}; // DNS flags as sent to the backend // 2
147 uint16_t udpPayloadSize{0}; // Max UDP payload size from the query // 2
148 dnsdist::Protocol protocol; // 1
149 boost::optional<boost::uuids::uuid> uniqueId{boost::none}; // 17 (placed here to reduce the space lost to padding)
150 bool ednsAdded{false};
151 bool ecsAdded{false};
152 bool skipCache{false};
153 bool dnssecOK{false};
154 bool useZeroScope{false};
155 bool forwardedOverUDP{false};
156 bool selfGenerated{false};
165 IDState(const IDState& orig) = delete;
166 IDState(IDState&& rhs) noexcept :
167 internal(std::move(rhs.internal))
169 inUse.store(rhs.inUse.load());
170 age.store(rhs.age.load());
173 IDState& operator=(IDState&& rhs) noexcept
175 inUse.store(rhs.inUse.load());
176 age.store(rhs.age.load());
177 internal = std::move(rhs.internal);
186 /* For performance reasons we don't want to use a lock here, but that means
187 we need to be very careful when modifying this value. Modifications happen
189 - one of the UDP or DoH 'client' threads receiving a query, selecting a backend
190 then picking one of the states associated to this backend (via the idOffset).
191 Most of the time this state should not be in use and usageIndicator is -1, but we
192 might not yet have received a response for the query previously associated to this
193 state, meaning that we will 'reuse' this state and erase the existing state.
194 If we ever receive a response for this state, it will be discarded. This is
195 mostly fine for UDP except that we still need to be careful in order to miss
196 the 'outstanding' counters, which should only be increased when we are picking
197 an empty state, and not when reusing ;
198 For DoH, though, we have dynamically allocated a DOHUnit object that needs to
199 be freed, as well as internal objects internals to libh2o.
200 - one of the UDP receiver threads receiving a response from a backend, picking
201 the corresponding state and sending the response to the client ;
202 - the 'healthcheck' thread scanning the states to actively discover timeouts,
203 mostly to keep some counters like the 'outstanding' one sane.
206 - inUse tells us if there currently is a in-flight query whose state is stored
208 - locked tells us whether someone currently owns the state, so no-one else can touch
211 InternalQueryState internal;
212 std::atomic<uint16_t> age{0};
217 StateGuard(IDState& ids) :
225 StateGuard(const StateGuard&) = delete;
226 StateGuard(StateGuard&&) = delete;
227 StateGuard& operator=(const StateGuard&) = delete;
228 StateGuard& operator=(StateGuard&&) = delete;
234 [[nodiscard]] std::optional<StateGuard> acquire()
236 bool expected = false;
237 if (locked.compare_exchange_strong(expected, true)) {
238 return std::optional<StateGuard>(*this);
248 std::atomic<bool> inUse{false}; // 1
251 std::atomic<bool> locked{false}; // 1