ceph/src/rgw/rgw_cache.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3
   4 #include "rgw_cache.h"
   5
   6 #include <errno.h>
   7
   8 #define dout_subsys ceph_subsys_rgw
   9
  10 using namespace std;
  11
  12 int ObjectCache::get(const string& name, ObjectCacheInfo& info, uint32_t mask, rgw_cache_entry_info *cache_info)
  13 {
  14   RWLock::RLocker l(lock);
  15
  16   if (!enabled) {
  17     return -ENOENT;
  18   }
  19
  20   auto iter = cache_map.find(name);
  21   if (iter == cache_map.end() ||
  22       (expiry.count() &&
  23        (ceph::coarse_mono_clock::now() - iter->second.info.time_added) > expiry)) {
  24     ldout(cct, 10) << "cache get: name=" << name << " : miss" << dendl;
  25     if (perfcounter)
  26       perfcounter->inc(l_rgw_cache_miss);
  27     return -ENOENT;
  28   }
  29
  30   ObjectCacheEntry *entry = &iter->second;
  31
  32   if (lru_counter - entry->lru_promotion_ts > lru_window) {
  33     ldout(cct, 20) << "cache get: touching lru, lru_counter=" << lru_counter
  34                    << " promotion_ts=" << entry->lru_promotion_ts << dendl;
  35     lock.unlock();
  36     lock.get_write(); /* promote lock to writer */
  37
  38     /* need to redo this because entry might have dropped off the cache */
  39     iter = cache_map.find(name);
  40     if (iter == cache_map.end()) {
  41       ldout(cct, 10) << "lost race! cache get: name=" << name << " : miss" << dendl;
  42       if(perfcounter) perfcounter->inc(l_rgw_cache_miss);
  43       return -ENOENT;
  44     }
  45
  46     entry = &iter->second;
  47     /* check again, we might have lost a race here */
  48     if (lru_counter - entry->lru_promotion_ts > lru_window) {
  49       touch_lru(name, *entry, iter->second.lru_iter);
  50     }
  51   }
  52
  53   ObjectCacheInfo& src = iter->second.info;
  54   if ((src.flags & mask) != mask) {
  55     ldout(cct, 10) << "cache get: name=" << name << " : type miss (requested=0x"
  56                    << std::hex << mask << ", cached=0x" << src.flags
  57                    << std::dec << ")" << dendl;
  58     if(perfcounter) perfcounter->inc(l_rgw_cache_miss);
  59     return -ENOENT;
  60   }
  61   ldout(cct, 10) << "cache get: name=" << name << " : hit (requested=0x"
  62                  << std::hex << mask << ", cached=0x" << src.flags
  63                  << std::dec << ")" << dendl;
  64
  65   info = src;
  66   if (cache_info) {
  67     cache_info->cache_locator = name;
  68     cache_info->gen = entry->gen;
  69   }
  70   if(perfcounter) perfcounter->inc(l_rgw_cache_hit);
  71
  72   return 0;
  73 }
  74
  75 bool ObjectCache::chain_cache_entry(list<rgw_cache_entry_info *>& cache_info_entries, RGWChainedCache::Entry *chained_entry)
  76 {
  77   RWLock::WLocker l(lock);
  78
  79   if (!enabled) {
  80     return false;
  81   }
  82
  83   list<rgw_cache_entry_info *>::iterator citer;
  84
  85   list<ObjectCacheEntry *> cache_entry_list;
  86
  87   /* first verify that all entries are still valid */
  88   for (citer = cache_info_entries.begin(); citer != cache_info_entries.end(); ++citer) {
  89     rgw_cache_entry_info *cache_info = *citer;
  90
  91     ldout(cct, 10) << "chain_cache_entry: cache_locator=" << cache_info->cache_locator << dendl;
  92     map<string, ObjectCacheEntry>::iterator iter = cache_map.find(cache_info->cache_locator);
  93     if (iter == cache_map.end()) {
  94       ldout(cct, 20) << "chain_cache_entry: couldn't find cache locator" << dendl;
  95       return false;
  96     }
  97
  98     ObjectCacheEntry *entry = &iter->second;
  99
 100     if (entry->gen != cache_info->gen) {
 101       ldout(cct, 20) << "chain_cache_entry: entry.gen (" << entry->gen << ") != cache_info.gen (" << cache_info->gen << ")" << dendl;
 102       return false;
 103     }
 104
 105     cache_entry_list.push_back(entry);
 106   }
 107
 108
 109   chained_entry->cache->chain_cb(chained_entry->key, chained_entry->data);
 110
 111   list<ObjectCacheEntry *>::iterator liter;
 112
 113   for (liter = cache_entry_list.begin(); liter != cache_entry_list.end(); ++liter) {
 114     ObjectCacheEntry *entry = *liter;
 115
 116     entry->chained_entries.push_back(make_pair(chained_entry->cache, chained_entry->key));
 117   }
 118
 119   return true;
 120 }
 121
 122 void ObjectCache::put(const string& name, ObjectCacheInfo& info, rgw_cache_entry_info *cache_info)
 123 {
 124   RWLock::WLocker l(lock);
 125
 126   if (!enabled) {
 127     return;
 128   }
 129
 130   ldout(cct, 10) << "cache put: name=" << name << " info.flags=0x"
 131                  << std::hex << info.flags << std::dec << dendl;
 132
 133   const std::pair<std::map<std::string,
 134                            ObjectCacheEntry>::iterator, bool>& emp_pair
 135     = cache_map.emplace(name, ObjectCacheEntry{});
 136   ObjectCacheEntry& entry = emp_pair.first->second;
 137   bool inserted = emp_pair.second;
 138   entry.info.time_added = ceph::coarse_mono_clock::now();
 139   if (inserted) {
 140     entry.lru_iter = lru.end();
 141   }
 142   ObjectCacheInfo& target = entry.info;
 143
 144   invalidate_lru(entry);
 145
 146   entry.chained_entries.clear();
 147   entry.gen++;
 148
 149   touch_lru(name, entry, entry.lru_iter);
 150
 151   target.status = info.status;
 152
 153   if (info.status < 0) {
 154     target.flags = 0;
 155     target.xattrs.clear();
 156     target.data.clear();
 157     return;
 158   }
 159
 160   if (cache_info) {
 161     cache_info->cache_locator = name;
 162     cache_info->gen = entry.gen;
 163   }
 164
 165   target.flags |= info.flags;
 166
 167   if (info.flags & CACHE_FLAG_META)
 168     target.meta = info.meta;
 169   else if (!(info.flags & CACHE_FLAG_MODIFY_XATTRS))
 170     target.flags &= ~CACHE_FLAG_META; // non-meta change should reset meta
 171
 172   if (info.flags & CACHE_FLAG_XATTRS) {
 173     target.xattrs = info.xattrs;
 174     map<string, bufferlist>::iterator iter;
 175     for (iter = target.xattrs.begin(); iter != target.xattrs.end(); ++iter) {
 176       ldout(cct, 10) << "updating xattr: name=" << iter->first << " bl.length()=" << iter->second.length() << dendl;
 177     }
 178   } else if (info.flags & CACHE_FLAG_MODIFY_XATTRS) {
 179     map<string, bufferlist>::iterator iter;
 180     for (iter = info.rm_xattrs.begin(); iter != info.rm_xattrs.end(); ++iter) {
 181       ldout(cct, 10) << "removing xattr: name=" << iter->first << dendl;
 182       target.xattrs.erase(iter->first);
 183     }
 184     for (iter = info.xattrs.begin(); iter != info.xattrs.end(); ++iter) {
 185       ldout(cct, 10) << "appending xattr: name=" << iter->first << " bl.length()=" << iter->second.length() << dendl;
 186       target.xattrs[iter->first] = iter->second;
 187     }
 188   }
 189
 190   if (info.flags & CACHE_FLAG_DATA)
 191     target.data = info.data;
 192
 193   if (info.flags & CACHE_FLAG_OBJV)
 194     target.version = info.version;
 195 }
 196
 197 bool ObjectCache::remove(const string& name)
 198 {
 199   RWLock::WLocker l(lock);
 200
 201   if (!enabled) {
 202     return false;
 203   }
 204
 205   map<string, ObjectCacheEntry>::iterator iter = cache_map.find(name);
 206   if (iter == cache_map.end())
 207     return false;
 208
 209   ldout(cct, 10) << "removing " << name << " from cache" << dendl;
 210   ObjectCacheEntry& entry = iter->second;
 211
 212   for (list<pair<RGWChainedCache *, string> >::iterator iiter = entry.chained_entries.begin();
 213        iiter != entry.chained_entries.end(); ++iiter) {
 214     RGWChainedCache *chained_cache = iiter->first;
 215     chained_cache->invalidate(iiter->second);
 216   }
 217
 218   remove_lru(name, iter->second.lru_iter);
 219   cache_map.erase(iter);
 220   return true;
 221 }
 222
 223 void ObjectCache::touch_lru(const string& name, ObjectCacheEntry& entry,
 224                             std::list<string>::iterator& lru_iter)
 225 {
 226   while (lru_size > (size_t)cct->_conf->rgw_cache_lru_size) {
 227     list<string>::iterator iter = lru.begin();
 228     if ((*iter).compare(name) == 0) {
 229       /*
 230        * if the entry we're touching happens to be at the lru end, don't remove it,
 231        * lru shrinking can wait for next time
 232        */
 233       break;
 234     }
 235     map<string, ObjectCacheEntry>::iterator map_iter = cache_map.find(*iter);
 236     ldout(cct, 10) << "removing entry: name=" << *iter << " from cache LRU" << dendl;
 237     if (map_iter != cache_map.end()) {
 238       ObjectCacheEntry& entry = map_iter->second;
 239       invalidate_lru(entry);
 240       cache_map.erase(map_iter);
 241     }
 242     lru.pop_front();
 243     lru_size--;
 244   }
 245
 246   if (lru_iter == lru.end()) {
 247     lru.push_back(name);
 248     lru_size++;
 249     lru_iter--;
 250     ldout(cct, 10) << "adding " << name << " to cache LRU end" << dendl;
 251   } else {
 252     ldout(cct, 10) << "moving " << name << " to cache LRU end" << dendl;
 253     lru.erase(lru_iter);
 254     lru.push_back(name);
 255     lru_iter = lru.end();
 256     --lru_iter;
 257   }
 258
 259   lru_counter++;
 260   entry.lru_promotion_ts = lru_counter;
 261 }
 262
 263 void ObjectCache::remove_lru(const string& name,
 264                              std::list<string>::iterator& lru_iter)
 265 {
 266   if (lru_iter == lru.end())
 267     return;
 268
 269   lru.erase(lru_iter);
 270   lru_size--;
 271   lru_iter = lru.end();
 272 }
 273
 274 void ObjectCache::invalidate_lru(ObjectCacheEntry& entry)
 275 {
 276   for (list<pair<RGWChainedCache *, string> >::iterator iter = entry.chained_entries.begin();
 277        iter != entry.chained_entries.end(); ++iter) {
 278     RGWChainedCache *chained_cache = iter->first;
 279     chained_cache->invalidate(iter->second);
 280   }
 281 }
 282
 283 void ObjectCache::set_enabled(bool status)
 284 {
 285   RWLock::WLocker l(lock);
 286
 287   enabled = status;
 288
 289   if (!enabled) {
 290     do_invalidate_all();
 291   }
 292 }
 293
 294 void ObjectCache::invalidate_all()
 295 {
 296   RWLock::WLocker l(lock);
 297
 298   do_invalidate_all();
 299 }
 300
 301 void ObjectCache::do_invalidate_all()
 302 {
 303   cache_map.clear();
 304   lru.clear();
 305
 306   lru_size = 0;
 307   lru_counter = 0;
 308   lru_window = 0;
 309
 310   for (list<RGWChainedCache *>::iterator iter = chained_cache.begin(); iter != chained_cache.end(); ++iter) {
 311     (*iter)->invalidate_all();
 312   }
 313 }
 314
 315 void ObjectCache::chain_cache(RGWChainedCache *cache) {
 316   RWLock::WLocker l(lock);
 317   chained_cache.push_back(cache);
 318 }
 319