Added support for @Volume= in remap.config

Author: zwoop

doc/admin-guide/files/records.yaml.en.rst

@@ -2737,13 +2737,23 @@ RAM Cache
    Alternatively, it can be set to a fixed value such as
    **20GB** (21474836480)
 
+   This global setting can be overridden on a per-volume basis using the
+   ``ram_cache_size`` parameter in :file:`volume.config`. Per-volume
+   allocations are subtracted from the total RAM cache size before
+   distributing the remainder among volumes without explicit settings.
+
 .. ts:cv:: CONFIG proxy.config.cache.ram_cache_cutoff INT 4194304
 
    Objects greater than this size will not be kept in the RAM cache.
    This should be set high enough to keep objects accessed frequently
    in memory in order to improve performance.
    **4MB** (4194304)
 
+   This global setting can be overridden on a per-volume basis using the
+   ``ram_cache_cutoff`` parameter in :file:`volume.config`. When set,
+   the per-volume cutoff takes precedence over this global setting for
+   that specific volume.
+
 .. ts:cv:: CONFIG proxy.config.cache.ram_cache.algorithm INT 1
 
    Two distinct RAM caches are supported, the default (1) being the simpler

doc/admin-guide/files/remap.config.en.rst

@@ -455,6 +455,51 @@ will pass "1" and "2" to plugin1.so and "3" to plugin2.so.
 
 This will pass "1" and "2" to plugin1.so and "3" to plugin2.so
 
+.. _remap-config-cache-volume-selection:
+
+Cache Volume Selection
+======================
+
+The ``@volume`` directive allows you to override the default cache volume selection
+for specific remap rules, bypassing the hostname-based volume selection configured in
+:file:`hosting.config`. This provides fine-grained control over which cache volumes
+are used for different URL patterns.
+
+Format
+------
+
+::
+
+    @volume=<volume_number>
+
+Where ``<volume_number>`` is the volume number as configured in :file:`volume.config`.
+Volume numbers must be between 1 and 255 (volume 0 is reserved and not usable).
+
+Examples
+--------
+
+::
+
+    # Route API requests to dedicated high-performance volume (volume 4)
+    map https://api.example.com/ https://api-origin.example.com/ @volume=4
+
+    # Everything gets the default volume allocations (hashing)
+    map https://www.example.com/ https://origin.example.com/
+
+Behavior
+--------
+
+- If the specified volume number is invalid (greater than the number of configured volumes),
+  the system falls back to hostname-based volume selection with a warning logged.
+- The ``@volume`` directive takes precedence over :file:`hosting.config` rules.
+- Volume override works with all cache operations including reads, writes, and deletes.
+- This feature integrates with per-volume RAM cache settings configured in :file:`volume.config`.
+
+.. note::
+
+   When using ``@volume``, ensure that the target volume has appropriate disk space and
+   performance characteristics for the expected traffic patterns.
+
 .. _remap-config-named-filters:
 
 NextHop Selection Strategies

include/iocore/cache/Cache.h

@@ -83,9 +83,9 @@ struct CacheProcessor : public Processor {
   Action *scan(Continuation *cont, std::string_view hostname = std::string_view{}, int KB_per_second = SCAN_KB_PER_SECOND);
   Action *lookup(Continuation *cont, const HttpCacheKey *key, CacheFragType frag_type = CACHE_FRAG_TYPE_HTTP);
   Action *open_read(Continuation *cont, const HttpCacheKey *key, CacheHTTPHdr *request, const HttpConfigAccessor *params,
-                    CacheFragType frag_type = CACHE_FRAG_TYPE_HTTP);
+                    CacheFragType frag_type = CACHE_FRAG_TYPE_HTTP, int volume_override = -1);
   Action *open_write(Continuation *cont, const HttpCacheKey *key, CacheHTTPInfo *old_info, time_t pin_in_cache = 0,
-                     CacheFragType frag_type = CACHE_FRAG_TYPE_HTTP);
+                     CacheFragType frag_type = CACHE_FRAG_TYPE_HTTP, int volume_override = -1);
   Action *remove(Continuation *cont, const HttpCacheKey *key, CacheFragType frag_type = CACHE_FRAG_TYPE_HTTP);
 
   /** Mark physical disk/device/file as offline.

include/proxy/http/HttpTransact.h

@@ -704,8 +704,10 @@ class HttpTransact
 
     MgmtByte cache_open_write_fail_action = 0;
 
-    HttpConfigParams           *http_config_param = nullptr;
-    CacheLookupInfo             cache_info;
+    HttpConfigParams *http_config_param = nullptr;
+    CacheLookupInfo   cache_info;
+
+    int                         cache_volume_override = -1;
     ResolveInfo                 dns_info;
     RedirectInfo                redirect_info;
     ConnectionTracker::TxnState outbound_conn_track_state;

include/proxy/http/remap/RemapConfig.h

@@ -40,6 +40,7 @@ class UrlRewrite;
 #define REMAP_OPTFLG_INTERNAL         0x0080u     /* only allow internal requests to hit this remap */
 #define REMAP_OPTFLG_IN_IP            0x0100u     /* "in_ip=" option (used for ACL filtering)*/
 #define REMAP_OPTFLG_STRATEGY         0x0200u     /* "strategy=" the name of the nexthop selection strategy */
+#define REMAP_OPTFLG_VOLUME           0x0400u     /* "volume=" cache volume override */
 #define REMAP_OPTFLG_MAP_ID           0x0800u     /* associate a map ID with this rule */
 #define REMAP_OPTFLG_INVERT           0x80000000u /* "invert" the rule (for src_ip and src_ip_category at least) */
 #define REMAP_OPTFLG_ALL_FILTERS \

include/proxy/http/remap/UrlMapping.h

@@ -112,7 +112,8 @@ class url_mapping
   bool              ip_allow_check_enabled_p = false;
   acl_filter_rule  *filter                   = nullptr; // acl filtering (linked list of rules)
   LINK(url_mapping, link);                              // For use with the main Queue linked list holding all the mapping
-  NextHopSelectionStrategy *strategy = nullptr;
+  NextHopSelectionStrategy *strategy     = nullptr;
+  int                       cache_volume = -1;
   std::string               remapKey;
   std::atomic<uint64_t>     _hitCount = 0; // counter can overflow
 

src/iocore/cache/Cache.cc

@@ -529,15 +529,15 @@ Cache::scan(Continuation *cont, std::string_view hostname, int KB_per_second) co
 
 Action *
 Cache::open_read(Continuation *cont, const CacheKey *key, CacheHTTPHdr *request, const HttpConfigAccessor *params,
-                 CacheFragType type, std::string_view hostname) const
+                 CacheFragType type, std::string_view hostname, int volume_override) const
 {
   if (!CacheProcessor::IsCacheReady(type)) {
     cont->handleEvent(CACHE_EVENT_OPEN_READ_FAILED, reinterpret_cast<void *>(-ECACHE_NOT_READY));
     return ACTION_RESULT_DONE;
   }
   ink_assert(caches[type] == this);
 
-  StripeSM     *stripe = key_to_stripe(key, hostname);
+  StripeSM     *stripe = key_to_stripe(key, hostname, volume_override);
   Dir           result, *last_collision = nullptr;
   ProxyMutex   *mutex = cont->mutex.get();
   OpenDirEntry *od    = nullptr;
@@ -603,8 +603,8 @@ Cache::open_read(Continuation *cont, const CacheKey *key, CacheHTTPHdr *request,
 
 // main entry point for writing of http documents
 Action *
-Cache::open_write(Continuation *cont, const CacheKey *key, CacheHTTPInfo *info, time_t apin_in_cache, CacheFragType type,
-                  std::string_view hostname) const
+Cache::open_write(Continuation *cont, const CacheKey *key, CacheHTTPInfo *old_info, time_t pin_in_cache, CacheFragType type,
+                  std::string_view hostname, int volume_override) const
 {
   if (!CacheProcessor::IsCacheReady(type)) {
     cont->handleEvent(CACHE_EVENT_OPEN_WRITE_FAILED, reinterpret_cast<void *>(-ECACHE_NOT_READY));
@@ -613,7 +613,7 @@ Cache::open_write(Continuation *cont, const CacheKey *key, CacheHTTPInfo *info,
 
   ink_assert(caches[type] == this);
   intptr_t err        = 0;
-  int      if_writers = reinterpret_cast<uintptr_t>(info) == CACHE_ALLOW_MULTIPLE_WRITES;
+  int      if_writers = reinterpret_cast<uintptr_t>(old_info) == CACHE_ALLOW_MULTIPLE_WRITES;
   CacheVC *c          = new_CacheVC(cont);
   c->vio.op           = VIO::WRITE;
   c->first_key        = *key;
@@ -629,10 +629,10 @@ Cache::open_write(Continuation *cont, const CacheKey *key, CacheHTTPInfo *info,
   } while (DIR_MASK_TAG(c->key.slice32(2)) == DIR_MASK_TAG(c->first_key.slice32(2)));
   c->earliest_key  = c->key;
   c->frag_type     = CACHE_FRAG_TYPE_HTTP;
-  c->stripe        = key_to_stripe(key, hostname);
+  c->stripe        = key_to_stripe(key, hostname, volume_override);
   StripeSM *stripe = c->stripe;
-  c->info          = info;
-  if (c->info && reinterpret_cast<uintptr_t>(info) != CACHE_ALLOW_MULTIPLE_WRITES) {
+  c->info          = old_info;
+  if (c->info && reinterpret_cast<uintptr_t>(old_info) != CACHE_ALLOW_MULTIPLE_WRITES) {
     /*
        Update has the following code paths :
        a) Update alternate header only :
@@ -664,17 +664,17 @@ Cache::open_write(Continuation *cont, const CacheKey *key, CacheHTTPInfo *info,
     c->f.update = 1;
     c->op_type  = static_cast<int>(CacheOpType::Update);
     DDbg(dbg_ctl_cache_update, "Update called");
-    info->object_key_get(&c->update_key);
+    old_info->object_key_get(&c->update_key);
     ink_assert(!(c->update_key.is_zero()));
-    c->update_len = info->object_size_get();
+    c->update_len = old_info->object_size_get();
   } else {
     c->op_type = static_cast<int>(CacheOpType::Write);
   }
 
   ts::Metrics::Gauge::increment(cache_rsb.status[c->op_type].active);
   ts::Metrics::Gauge::increment(stripe->cache_vol->vol_rsb.status[c->op_type].active);
   // coverity[Y2K38_SAFETY:FALSE]
-  c->pin_in_cache = static_cast<uint32_t>(apin_in_cache);
+  c->pin_in_cache = static_cast<uint32_t>(pin_in_cache);
 
   {
     CACHE_TRY_LOCK(lock, c->stripe->mutex, cont->mutex->thread_holding);
@@ -745,41 +745,70 @@ CacheVConnection::CacheVConnection() : VConnection(nullptr) {}
 
 // if generic_host_rec.stripes == nullptr, what do we do???
 StripeSM *
-Cache::key_to_stripe(const CacheKey *key, std::string_view hostname) const
+Cache::key_to_stripe(const CacheKey *key, std::string_view hostname, int volume_override) const
 {
   ReplaceablePtr<CacheHostTable>::ScopedReader hosttable(&this->hosttable);
 
-  uint32_t               h          = (key->slice32(2) >> DIR_TAG_WIDTH) % STRIPE_HASH_TABLE_SIZE;
-  unsigned short        *hash_table = hosttable->gen_host_rec.vol_hash_table;
-  const CacheHostRecord *host_rec   = &hosttable->gen_host_rec;
+  uint32_t               h               = (key->slice32(2) >> DIR_TAG_WIDTH) % STRIPE_HASH_TABLE_SIZE;
+  unsigned short        *hash_table      = hosttable->gen_host_rec.vol_hash_table;
+  const CacheHostRecord *host_rec        = &hosttable->gen_host_rec;
+  StripeSM              *selected_stripe = nullptr;
+  bool                   remap_selection = false;
+
+  if (volume_override > 0) {
+    for (int i = 0; i < host_rec->num_cachevols; i++) {
+      if (host_rec->cp[i] && host_rec->cp[i]->vol_number == volume_override) {
+        for (int j = 0; j < host_rec->num_vols; j++) {
+          if (host_rec->stripes[j] && host_rec->stripes[j]->cache_vol &&
+              host_rec->stripes[j]->cache_vol->vol_number == volume_override) {
+            selected_stripe = host_rec->stripes[j];
+            remap_selection = true;
+            break;
+          }
+        }
+        break;
+      }
+    }
+
+    if (!selected_stripe) {
+      Warning("Invalid volume override %d, volume configured but no stripes available. Falling back to hostname-based selection.",
+              volume_override);
+    }
+  }
 
-  if (hosttable->m_numEntries > 0 && !hostname.empty()) {
+  // Normal hostname-based volume selection (if no valid override)
+  if (!selected_stripe && hosttable->m_numEntries > 0 && !hostname.empty()) {
     CacheHostResult res;
+
     hosttable->Match(hostname, &res);
     if (res.record) {
       unsigned short *host_hash_table = res.record->vol_hash_table;
+
       if (host_hash_table) {
-        if (dbg_ctl_cache_hosting.on()) {
-          char format_str[50];
-          snprintf(format_str, sizeof(format_str), "Volume: %%xd for host: %%.%ds", static_cast<int>(hostname.length()));
-          Dbg(dbg_ctl_cache_hosting, format_str, res.record, hostname.data());
-        }
-        return res.record->stripes[host_hash_table[h]];
+        Dbg(dbg_ctl_cache_hosting, "Volume: %p for host: %.*s", res.record, static_cast<int>(hostname.length()), hostname.data());
+        selected_stripe = res.record->stripes[host_hash_table[h]];
       }
     }
   }
-  if (hash_table) {
-    if (dbg_ctl_cache_hosting.on()) {
-      char format_str[50];
-      snprintf(format_str, sizeof(format_str), "Generic volume: %%xd for host: %%.%ds", static_cast<int>(hostname.length()));
-      Dbg(dbg_ctl_cache_hosting, format_str, host_rec, hostname.data());
+
+  // Generic/default volume selection (if no hostname match in hosting)
+  if (!selected_stripe) {
+    if (hash_table) {
+      selected_stripe = host_rec->stripes[hash_table[h]];
+    } else {
+      selected_stripe = host_rec->stripes[0];
     }
-    return host_rec->stripes[hash_table[h]];
-  } else {
-    return host_rec->stripes[0];
   }
-}
 
+  if (dbg_ctl_cache_hosting.on() && selected_stripe && selected_stripe->cache_vol) {
+    Dbg(dbg_ctl_cache_hosting, "Cache volume selected: %d (%s) for key=%08x%08x hostname='%.*s' %s",
+        selected_stripe->cache_vol->vol_number,
+        selected_stripe->cache_vol->ramcache_enabled ? "ramcache_enabled" : "ramcache_disabled", key->slice32(0), key->slice32(1),
+        static_cast<int>(hostname.length()), hostname.data(), remap_selection ? "(remap)" : "(calculated)");
+  }
+
+  return selected_stripe;
+}
 int
 FragmentSizeUpdateCb(const char * /* name ATS_UNUSED */, RecDataT /* data_type ATS_UNUSED */, RecData data,
                      void * /* cookie ATS_UNUSED */)

src/iocore/cache/CacheProcessor.cc

@@ -412,18 +412,18 @@ CacheProcessor::lookup(Continuation *cont, const HttpCacheKey *key, CacheFragTyp
 
 Action *
 CacheProcessor::open_read(Continuation *cont, const HttpCacheKey *key, CacheHTTPHdr *request, const HttpConfigAccessor *params,
-                          CacheFragType type)
+                          CacheFragType frag_type, int volume_override)
 {
-  return caches[type]->open_read(cont, &key->hash, request, params, type,
-                                 std::string_view{key->hostname, static_cast<std::string_view::size_type>(key->hostlen)});
+  return caches[frag_type]->open_read(cont, &key->hash, request, params, frag_type,
+                                      std::string_view{key->hostname, static_cast<size_t>(key->hostlen)}, volume_override);
 }
 
 Action *
 CacheProcessor::open_write(Continuation *cont, const HttpCacheKey *key, CacheHTTPInfo *old_info, time_t pin_in_cache,
-                           CacheFragType type)
+                           CacheFragType frag_type, int volume_override)
 {
-  return caches[type]->open_write(cont, &key->hash, old_info, pin_in_cache, type,
-                                  std::string_view{key->hostname, static_cast<std::string_view::size_type>(key->hostlen)});
+  return caches[frag_type]->open_write(cont, &key->hash, old_info, pin_in_cache, frag_type,
+                                       std::string_view{key->hostname, static_cast<size_t>(key->hostlen)}, volume_override);
 }
 
 //----------------------------------------------------------------------------

src/iocore/cache/P_CacheInternal.h

@@ -465,9 +465,10 @@ struct Cache {
   Action *scan(Continuation *cont, std::string_view hostname = std::string_view{}, int KB_per_second = 2500) const;
 
   Action     *open_read(Continuation *cont, const CacheKey *key, CacheHTTPHdr *request, const HttpConfigAccessor *params,
-                        CacheFragType type, std::string_view hostname = std::string_view{}) const;
+                        CacheFragType type, std::string_view hostname = std::string_view{}, int volume_override = -1) const;
   Action     *open_write(Continuation *cont, const CacheKey *key, CacheHTTPInfo *old_info, time_t pin_in_cache = 0,
-                         CacheFragType type = CACHE_FRAG_TYPE_HTTP, std::string_view hostname = std::string_view{}) const;
+                         CacheFragType type = CACHE_FRAG_TYPE_HTTP, std::string_view hostname = std::string_view{},
+                         int volume_override = -1) const;
   static void generate_key(CryptoHash *hash, CacheURL *url);
   static void generate_key(HttpCacheKey *hash, CacheURL *url, bool ignore_query = false, cache_generation_t generation = -1);
 
@@ -480,7 +481,7 @@ struct Cache {
 
   int open_done();
 
-  StripeSM *key_to_stripe(const CacheKey *key, std::string_view hostname) const;
+  StripeSM *key_to_stripe(const CacheKey *key, std::string_view hostname, int volume_override = -1) const;
 
   Cache() {}
 };

src/proxy/http/HttpCacheSM.cc

@@ -317,12 +317,20 @@ HttpCacheSM::_schedule_read_retry()
 Action *
 HttpCacheSM::do_cache_open_read(const HttpCacheKey &key)
 {
+  Action *action_handle = nullptr;
+
   open_read_tries++;
   ink_assert(pending_action == nullptr);
 
   // Initialising read-while-write-inprogress flag
   this->readwhilewrite_inprogress = false;
-  Action *action_handle           = cacheProcessor.open_read(this, &key, this->read_request_hdr, &http_params);
+
+  if (master_sm && master_sm->t_state.cache_volume_override > 0) {
+    action_handle = cacheProcessor.open_read(this, &key, this->read_request_hdr, &http_params, CACHE_FRAG_TYPE_HTTP,
+                                             master_sm->t_state.cache_volume_override);
+  } else {
+    action_handle = cacheProcessor.open_read(this, &key, this->read_request_hdr, &http_params);
+  }
 
   if (action_handle != ACTION_RESULT_DONE) {
     pending_action           = action_handle;
@@ -416,9 +424,15 @@ HttpCacheSM::open_write(const HttpCacheKey *key, URL *url, HTTPHdr *request, Cac
     return ACTION_RESULT_DONE;
   }
 
-  // INKqa11166
   CacheHTTPInfo *info          = allow_multiple ? reinterpret_cast<CacheHTTPInfo *>(CACHE_ALLOW_MULTIPLE_WRITES) : old_info;
-  Action        *action_handle = cacheProcessor.open_write(this, key, info, pin_in_cache);
+  Action        *action_handle = nullptr;
+
+  if (master_sm && master_sm->t_state.cache_volume_override > 0) {
+    action_handle =
+      cacheProcessor.open_write(this, key, info, pin_in_cache, CACHE_FRAG_TYPE_HTTP, master_sm->t_state.cache_volume_override);
+  } else {
+    action_handle = cacheProcessor.open_write(this, key, info, pin_in_cache);
+  }
 
   if (action_handle != ACTION_RESULT_DONE) {
     pending_action           = action_handle;