pdns/dnsdist-idstate.hh

   1 /*
   2  * This file is part of PowerDNS or dnsdist.
   3  * Copyright -- PowerDNS.COM B.V. and its contributors
   4  *
   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.
   8  *
   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.
  12  *
  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.
  17  *
  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.
  21  */
  22 #pragma once
  23
  24 #include "config.h"
  25 #include "dnsname.hh"
  26 #include "dnsdist-protocols.hh"
  27 #include "gettime.hh"
  28 #include "iputils.hh"
  29 #include "uuid-utils.hh"
  30
  31 struct ClientState;
  32 struct DOHUnit;
  33 class DNSCryptQuery;
  34 class DNSDistPacketCache;
  35
  36 using QTag = std::unordered_map<string, string>;
  37
  38 struct StopWatch
  39 {
  40   StopWatch(bool realTime = false) :
  41     d_needRealTime(realTime)
  42   {
  43   }
  44
  45   void start()
  46   {
  47     d_start = getCurrentTime();
  48   }
  49
  50   void set(const struct timespec& from)
  51   {
  52     d_start = from;
  53   }
  54
  55   double udiff() const
  56   {
  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;
  59   }
  60
  61   double udiffAndSet()
  62   {
  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;
  65     d_start = now;
  66     return ret;
  67   }
  68
  69   struct timespec getStartTime() const
  70   {
  71     return d_start;
  72   }
  73
  74   struct timespec d_start
  75   {
  76     0, 0
  77   };
  78
  79 private:
  80   struct timespec getCurrentTime() const
  81   {
  82     struct timespec now;
  83     if (gettime(&now, d_needRealTime) < 0) {
  84       unixDie("Getting timestamp");
  85     }
  86     return now;
  87   }
  88
  89   bool d_needRealTime;
  90 };
  91
  92 /* g++ defines __SANITIZE_THREAD__
  93    clang++ supports the nice __has_feature(thread_sanitizer),
  94    let's merge them */
  95 #if defined(__has_feature)
  96 #if __has_feature(thread_sanitizer)
  97 #define __SANITIZE_THREAD__ 1
  98 #endif
  99 #endif
 100
 101 struct InternalQueryState
 102 {
 103   static void DeleterPlaceHolder(DOHUnit*)
 104   {
 105   }
 106
 107   InternalQueryState() :
 108     du(std::unique_ptr<DOHUnit, void (*)(DOHUnit*)>(nullptr, DeleterPlaceHolder))
 109   {
 110     origDest.sin4.sin_family = 0;
 111   }
 112
 113   InternalQueryState(InternalQueryState&& rhs) = default;
 114   InternalQueryState& operator=(InternalQueryState&& rhs) = default;
 115
 116   InternalQueryState(const InternalQueryState& orig) = delete;
 117   InternalQueryState& operator=(const InternalQueryState& orig) = delete;
 118
 119   boost::optional<Netmask> subnet{boost::none}; // 40
 120   ComboAddress origRemote; // 28
 121   ComboAddress origDest; // 28
 122   ComboAddress hopRemote;
 123   ComboAddress hopLocal;
 124   DNSName qname; // 24
 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   boost::optional<uint32_t> tempFailureTTL{boost::none}; // 8
 131   ClientState* cs{nullptr}; // 8
 132   std::unique_ptr<DOHUnit, void (*)(DOHUnit*)> du; // 8
 133   uint32_t cacheKey{0}; // 4
 134   uint32_t cacheKeyNoECS{0}; // 4
 135   // DoH-only */
 136   uint32_t cacheKeyUDP{0}; // 4
 137   uint32_t ttlCap{0}; // cap the TTL _after_ inserting into the packet cache // 4
 138   int backendFD{-1}; // 4
 139   int delayMsec{0};
 140   uint16_t qtype{0}; // 2
 141   uint16_t qclass{0}; // 2
 142   // origID is in network-byte order
 143   uint16_t origID{0}; // 2
 144   uint16_t origFlags{0}; // 2
 145   uint16_t cacheFlags{0}; // DNS flags as sent to the backend // 2
 146   uint16_t udpPayloadSize{0}; // Max UDP payload size from the query // 2
 147   dnsdist::Protocol protocol; // 1
 148   boost::optional<boost::uuids::uuid> uniqueId{boost::none}; // 17 (placed here to reduce the space lost to padding)
 149   bool ednsAdded{false};
 150   bool ecsAdded{false};
 151   bool skipCache{false};
 152   bool dnssecOK{false};
 153   bool useZeroScope{false};
 154   bool forwardedOverUDP{false};
 155 };
 156
 157 struct IDState
 158 {
 159   IDState()
 160   {
 161   }
 162
 163   IDState(const IDState& orig) = delete;
 164   IDState(IDState&& rhs) noexcept :
 165     internal(std::move(rhs.internal))
 166   {
 167     inUse.store(rhs.inUse.load());
 168     age.store(rhs.age.load());
 169   }
 170
 171   IDState& operator=(IDState&& rhs) noexcept
 172   {
 173     inUse.store(rhs.inUse.load());
 174     age.store(rhs.age.load());
 175     internal = std::move(rhs.internal);
 176     return *this;
 177   }
 178
 179   bool isInUse() const
 180   {
 181     return inUse;
 182   }
 183
 184   /* For performance reasons we don't want to use a lock here, but that means
 185      we need to be very careful when modifying this value. Modifications happen
 186      from:
 187      - one of the UDP or DoH 'client' threads receiving a query, selecting a backend
 188        then picking one of the states associated to this backend (via the idOffset).
 189        Most of the time this state should not be in use and usageIndicator is -1, but we
 190        might not yet have received a response for the query previously associated to this
 191        state, meaning that we will 'reuse' this state and erase the existing state.
 192        If we ever receive a response for this state, it will be discarded. This is
 193        mostly fine for UDP except that we still need to be careful in order to miss
 194        the 'outstanding' counters, which should only be increased when we are picking
 195        an empty state, and not when reusing ;
 196        For DoH, though, we have dynamically allocated a DOHUnit object that needs to
 197        be freed, as well as internal objects internals to libh2o.
 198      - one of the UDP receiver threads receiving a response from a backend, picking
 199        the corresponding state and sending the response to the client ;
 200      - the 'healthcheck' thread scanning the states to actively discover timeouts,
 201        mostly to keep some counters like the 'outstanding' one sane.
 202
 203      We have two flags:
 204      - inUse tells us if there currently is a in-flight query whose state is stored
 205        in this state
 206      - locked tells us whether someone currently owns the state, so no-one else can touch
 207        it
 208   */
 209   InternalQueryState internal;
 210   std::atomic<uint16_t> age{0};
 211
 212   class StateGuard
 213   {
 214   public:
 215     StateGuard(IDState& ids) :
 216       d_ids(ids)
 217     {
 218     }
 219     ~StateGuard()
 220     {
 221       d_ids.release();
 222     }
 223     StateGuard(const StateGuard&) = delete;
 224     StateGuard(StateGuard&&) = delete;
 225     StateGuard& operator=(const StateGuard&) = delete;
 226     StateGuard& operator=(StateGuard&&) = delete;
 227
 228   private:
 229     IDState& d_ids;
 230   };
 231
 232   [[nodiscard]] std::optional<StateGuard> acquire()
 233   {
 234     bool expected = false;
 235     if (locked.compare_exchange_strong(expected, true)) {
 236       return std::optional<StateGuard>(*this);
 237     }
 238     return std::nullopt;
 239   }
 240
 241   void release()
 242   {
 243     locked.store(false);
 244   }
 245
 246   std::atomic<bool> inUse{false}; // 1
 247
 248 private:
 249   std::atomic<bool> locked{false}; // 1
 250 };