~ps10gel/ubuntu/xenial/trafficserver/6.2.0

int cache_config_read_while_writer = 0;

char cache_system_config_directory[PATH_NAME_MAX + 1];

int cache_config_mutex_retry_delay = 2;

 

// Globals

 

  }

};

 

void cplist_init();

static void cplist_update();

int cplist_reconfigure();

    start = volume - 1;

    end = volume;

  }

  for (int i = start; i < end; i++) {

    if (!DISK_BAD(gvol[i]->disk)) {

      if (!gvol[i]->header->cycle)

  if (new_value) {

    float http_bg_fill;

 

    if (http_bg_fill > 0.0) {

      Note("to enable reading while writing a document, %s should be 0.0: read while writing disabled",

           "proxy.config.http.background_fill_completed_threshold");

    ainfo->object_key_set(earliest_key);

    // don't know the total len yet

  }

  alternate.copy_shallow(ainfo);

  ainfo->clear();

}

  verify_cache_api();

#endif

 

  start_internal_flags = flags;

  clear = !!(flags & PROCESSOR_RECONFIGURE) || auto_clear_flag;

  fix = !!(flags & PROCESSOR_FIX);

        }

        off_t skip = ROUND_TO_STORE_BLOCK((sd->offset < START_POS ? START_POS + sd->alignment : sd->offset));

        blocks = blocks - ROUND_TO_STORE_BLOCK(sd->offset + skip);

        gdisks[gndisks]->open(path, blocks, skip, sector_size, fd, clear);

        gndisks++;

      }

    } else {

      switch (cache_config_ram_cache_compress) {

        default:

          Fatal("unknown RAM cache compression type: %d", cache_config_ram_cache_compress);

        case CACHE_COMPRESSION_FASTLZ:

          break;

        case CACHE_COMPRESSION_LIBZ:

    aio->aiocb.aio_buf = &(init_info->vol_h_f[i * STORE_BLOCK_SIZE]);

    aio->aiocb.aio_nbytes = footerlen;

    aio->action = this;

    aio->then = (i < 3) ? &(init_info->vol_aio[i + 1]) : 0;

  }

  return 0;

}

 

    init_info->vol_aio[2].aiocb.aio_offset = ss + dirlen - footerlen;

 

    SET_HANDLER(&Vol::handle_recover_write_dir);

    ink_assert(ink_aio_write(init_info->vol_aio));

    return EVENT_CONT;

  }

 

  AIOCallback *op;

  VolHeaderFooter *hf[4];

  switch (event) {

  case AIO_EVENT_DONE:

    op = (AIOCallback *) data;

    for (int i = 0; i < 4; i++) {

      delete init_info;

      init_info = 0;

    }

    return EVENT_DONE;

  }

  return EVENT_DONE;

}

        char message[128];

        snprintf(message, sizeof(message), "Error accessing Disk %s", d->path);

        Warning("%s", message);

      } else if (!DISK_BAD_SIGNALLED(d)) {

 

        char message[128];

        snprintf(message, sizeof(message), "too many errors accessing disk %s: declaring disk bad", d->path);

        Warning("%s", message);

        /* subtract the disk space that was being used from  the cache size stat */

        // dir entries stat

        int p;

  total_nvol = 0;

  total_good_nvol = 0;

 

  Debug("cache_init", "Cache::open - proxy.config.cache.min_average_object_size = %d",

        (int)cache_config_min_average_object_size);

 

            blocks = q->b->len;

 

            bool vol_clear = clear || d->cleared || q->new_block;

            cp->vols[vol_no]->init(d->path, blocks, q->b->offset, vol_clear);

            vol_no++;

            cache_size += blocks;

          }

bool

CacheVC::is_pread_capable()

{

}

 

#define STORE_COLLISION 1

        if (checksum != doc->checksum) {

          Note("cache: checksum error for [%" PRIu64 " %" PRIu64 "] len %d, hlen %d, disk %s, offset %" PRIu64 " size %zu",

               doc->first_key.b[0], doc->first_key.b[1],

          doc->magic = DOC_CORRUPT;

          okay = 0;

        }

      full_disks += 1;

      if (full_disks == gndisks) {

        char config_file[PATH_NAME_MAX];

        if (cp->size)

          Warning("not enough space to increase volume: [%d] to size: [%" PRId64 "]",

                  volume_number, (int64_t)((to_create + cp->size) >> (20 - STORE_BLOCK_SHIFT)));

 

  cache_rsb = RecAllocateRawStatBlock((int) cache_stat_count);

 

  Debug("cache_init", "proxy.config.cache.ram_cache.size = %" PRId64 " = %" PRId64 "Mb",

        cache_config_ram_cache_size, cache_config_ram_cache_size / (1024 * 1024));

 

 

  Debug("cache_init", "proxy.config.cache.limits.http.max_alts = %d", cache_config_http_max_alts);

 

  Debug("cache_init", "cache_config_ram_cache_cutoff = %" PRId64 " = %" PRId64 "Mb",

        cache_config_ram_cache_cutoff, cache_config_ram_cache_cutoff / (1024 * 1024));

 

  Debug("cache_init", "proxy.config.cache.permit.pinning = %d", cache_config_permit_pinning);

 

  Debug("cache_init", "proxy.config.cache.dir.sync_frequency = %d", cache_config_dir_sync_frequency);

 

  Debug("cache_init", "proxy.config.cache.vary_on_user_agent = %d", cache_config_vary_on_user_agent);

 

  Debug("cache_init", "proxy.config.cache.select_alternate = %d", cache_config_select_alternate);

 

  Debug("cache_init", "proxy.config.cache.max_doc_size = %d = %dMb",

        cache_config_max_doc_size, cache_config_max_doc_size / (1024 * 1024));

 

  Debug("cache_init", "proxy.config.cache.mutex_retry_delay = %dms", cache_config_mutex_retry_delay);

 

  // This is just here to make sure IOCORE "standalone" works, it's usually configured in RecordsConfig.cc

  if (cache_system_config_directory[0] != '/') {

    // Not an absolute path so use system one

    Layout::get()->relative(cache_system_config_directory, sizeof(cache_system_config_directory), cache_system_config_directory);

  }

  // TODO: These are left here, since they are only registered if HIT_EVACUATE is enabled.

#ifdef HIT_EVACUATE

  Debug("cache_init", "proxy.config.cache.hit_evacuate_percent = %d", cache_config_hit_evacuate_percent);

 

  Debug("cache_init", "proxy.config.cache.hit_evacuate_size_limit = %d", cache_config_hit_evacuate_size_limit);

#endif

 

 

  if (cache_config_target_fragment_size == 0)

    cache_config_target_fragment_size = DEFAULT_TARGET_FRAGMENT_SIZE;

 

  //  # 0 - MD5 hash

  //  # 1 - MMH hash

  Debug("cache_init", "proxy.config.cache.url_hash_method = %d", url_hash_method);

#endif

 

  Debug("cache_init", "proxy.config.cache.max_disk_errors = %d", cache_config_max_disk_errors);

 

  Debug("cache_init", "proxy.config.cache.agg_write_backlog = %d", cache_config_agg_write_backlog);

 

  Debug("cache_init", "proxy.config.cache.enable_checksum = %d", cache_config_enable_checksum);

 

  Debug("cache_init", "proxy.config.cache.alt_rewrite_max_size = %d", cache_config_alt_rewrite_max_size);

 

  cache_config_read_while_writer = validate_rww(cache_config_read_while_writer);

  Debug("cache_init", "proxy.config.cache.enable_read_while_writer = %d", cache_config_read_while_writer);

 

  register_cache_stats(cache_rsb, "proxy.process.cache");

  if (theCacheStore.n_disks == 0) {

    char p[PATH_NAME_MAX + 1];

    snprintf(p, sizeof(p), "%s/", cache_system_config_directory);

    if (p[strlen(p) - 1] == '/' || p[strlen(p) - 1] == '\\') {

      ink_strlcat(p, "storage.config", sizeof(p));

    }