void ovs_flow_stats_get(struct sw_flow *flow, struct ovs_flow_stats *ovs_stats,
unsigned long *used, __be16 *tcp_flags)
{
int cpu, cur_cpu;
*used = 0;
*tcp_flags = 0;
memset(ovs_stats, 0, sizeof(*ovs_stats));
if (!flow->stats.is_percpu) {
stats_read(flow->stats.stat, ovs_stats, used, tcp_flags);
} else {
cur_cpu = get_cpu();
for_each_possible_cpu(cpu) {
struct flow_stats *stats;
if (cpu == cur_cpu)
local_bh_disable();
stats = per_cpu_ptr(flow->stats.cpu_stats, cpu);
stats_read(stats, ovs_stats, used, tcp_flags);
if (cpu == cur_cpu)
local_bh_enable();
}
put_cpu();
}
}
/* zero all the stats structures */
void
stats_zero(void)
{
int dir;
unsigned i;
char *fname;
fname = format("%s/stats", cache_dir);
x_unlink(fname);
free(fname);
for (dir = 0; dir <= 0xF; dir++) {
struct counters *counters = counters_init(STATS_END);
fname = format("%s/%1x/stats", cache_dir, dir);
if (lockfile_acquire(fname, lock_staleness_limit)) {
stats_read(fname, counters);
for (i = 0; stats_info[i].message; i++) {
if (!(stats_info[i].flags & FLAG_NOZERO)) {
counters->data[stats_info[i].stat] = 0;
}
}
stats_write(fname, counters);
lockfile_release(fname);
}
counters_free(counters);
free(fname);
}
}
static void
stats_collect(struct counters *counters, time_t *last_updated)
{
struct stat st;
unsigned zero_timestamp = 0;
*last_updated = 0;
// Add up the stats in each directory.
for (int dir = -1; dir <= 0xF; dir++) {
char *fname;
if (dir == -1) {
fname = format("%s/stats", conf->cache_dir);
} else {
fname = format("%s/%1x/stats", conf->cache_dir, dir);
}
counters->data[STATS_ZEROTIMESTAMP] = 0; // Don't add
stats_read(fname, counters);
zero_timestamp = MAX(counters->data[STATS_ZEROTIMESTAMP], zero_timestamp);
if (stat(fname, &st) == 0 && st.st_mtime > *last_updated) {
*last_updated = st.st_mtime;
}
free(fname);
}
counters->data[STATS_ZEROTIMESTAMP] = zero_timestamp;
}
// Zero all the stats structures.
void
stats_zero(void)
{
assert(conf);
char *fname = format("%s/stats", conf->cache_dir);
x_unlink(fname);
free(fname);
time_t timestamp = time(NULL);
for (int dir = 0; dir <= 0xF; dir++) {
struct counters *counters = counters_init(STATS_END);
struct stat st;
fname = format("%s/%1x/stats", conf->cache_dir, dir);
if (stat(fname, &st) != 0) {
// No point in trying to reset the stats file if it doesn't exist.
free(fname);
continue;
}
if (lockfile_acquire(fname, lock_staleness_limit)) {
stats_read(fname, counters);
for (unsigned i = 0; stats_info[i].message; i++) {
if (!(stats_info[i].flags & FLAG_NOZERO)) {
counters->data[stats_info[i].stat] = 0;
}
}
counters->data[STATS_ZEROTIMESTAMP] = timestamp;
stats_write(fname, counters);
lockfile_release(fname);
}
counters_free(counters);
free(fname);
}
}
/* sum and display the total stats for all cache dirs */
void
stats_summary(struct conf *conf)
{
int dir, i;
struct counters *counters = counters_init(STATS_END);
assert(conf);
/* add up the stats in each directory */
for (dir = -1; dir <= 0xF; dir++) {
char *fname;
if (dir == -1) {
fname = format("%s/stats", conf->cache_dir);
} else {
fname = format("%s/%1x/stats", conf->cache_dir, dir);
}
stats_read(fname, counters);
free(fname);
}
printf("cache directory %s\n", conf->cache_dir);
printf("primary config %s\n",
primary_config_path ? primary_config_path : "");
printf("secondary config (readonly) %s\n",
secondary_config_path ? secondary_config_path : "");
/* and display them */
for (i = 0; stats_info[i].message; i++) {
enum stats stat = stats_info[i].stat;
if (stats_info[i].flags & FLAG_NEVER) {
continue;
}
if (counters->data[stat] == 0 && !(stats_info[i].flags & FLAG_ALWAYS)) {
continue;
}
printf("%s ", stats_info[i].message);
if (stats_info[i].fn) {
stats_info[i].fn(counters->data[stat]);
printf("\n");
} else {
printf("%8u\n", counters->data[stat]);
}
}
if (conf->max_files != 0) {
printf("max files %8u\n", conf->max_files);
}
if (conf->max_size != 0) {
printf("max cache size ");
display_size(conf->max_size);
printf("\n");
}
counters_free(counters);
}
/* Get the per directory limits */
void
stats_get_obsolete_limits(const char *dir, unsigned *maxfiles, uint64_t *maxsize)
{
struct counters *counters = counters_init(STATS_END);
char *sname = format("%s/stats", dir);
stats_read(sname, counters);
*maxfiles = counters->data[STATS_OBSOLETE_MAXFILES];
*maxsize = (uint64_t)counters->data[STATS_OBSOLETE_MAXSIZE] * 1024;
free(sname);
counters_free(counters);
}
/* Get the per directory limits */
void
stats_get_limits(const char *dir, unsigned *maxfiles, unsigned *maxsize)
{
struct counters *counters = counters_init(STATS_END);
char *sname = format("%s/stats", dir);
stats_read(sname, counters);
*maxfiles = counters->data[STATS_MAXFILES];
*maxsize = counters->data[STATS_MAXSIZE];
free(sname);
counters_free(counters);
}
// Count directory cleanup run.
void
stats_add_cleanup(const char *dir, unsigned count)
{
struct counters *counters = counters_init(STATS_END);
char *statsfile = format("%s/stats", dir);
if (lockfile_acquire(statsfile, lock_staleness_limit)) {
stats_read(statsfile, counters);
counters->data[STATS_NUMCLEANUPS] += count;
stats_write(statsfile, counters);
lockfile_release(statsfile);
}
free(statsfile);
counters_free(counters);
}
static bool stats_top_round(struct top_context *ctx)
{
#define TOP_CMD "EXPORT\tsession\tconnected\n"
const char *const *args;
pool_t tmp_pool;
if (write_full(ctx->fd, TOP_CMD, strlen(TOP_CMD)) < 0)
i_fatal("write(%s) failed: %m", ctx->path);
/* read header */
if (ctx->headers != NULL) {
args = read_next_line(ctx->input);
if (args == NULL)
i_fatal("read(%s) unexpectedly disconnected", ctx->path);
if (*args == NULL)
return TRUE;
if (str_array_length(args) != ctx->headers_count)
i_fatal("headers changed");
} else {
ctx->headers = p_read_next_line(default_pool, ctx->input);
if (ctx->headers == NULL)
i_fatal("read(%s) unexpectedly disconnected", ctx->path);
if (*ctx->headers == NULL) {
i_free_and_null(ctx->headers);
return FALSE;
}
ctx->headers_count = str_array_length((void *)ctx->headers);
if (!stats_header_find(ctx, "last_update", &ctx->last_update_idx))
i_fatal("last_update header missing");
if (!stats_header_find(ctx, "user", &ctx->user_idx))
i_fatal("user header missing");
stats_top_get_sorting(ctx);
}
array_clear(&ctx->lines);
p_clear(ctx->prev_pool);
tmp_pool = ctx->prev_pool;
ctx->prev_pool = ctx->cur_pool;
ctx->cur_pool = tmp_pool;
ctx->flip = !ctx->flip;
stats_read(ctx);
stats_drop_stale(ctx);
sort_ctx = ctx;
array_sort(&ctx->lines, *ctx->lines_sort);
sort_ctx = NULL;
return TRUE;
}
// Set the per-directory sizes.
void
stats_set_sizes(const char *dir, unsigned num_files, uint64_t total_size)
{
struct counters *counters = counters_init(STATS_END);
char *statsfile = format("%s/stats", dir);
if (lockfile_acquire(statsfile, lock_staleness_limit)) {
stats_read(statsfile, counters);
counters->data[STATS_NUMFILES] = num_files;
counters->data[STATS_TOTALSIZE] = total_size / 1024;
stats_write(statsfile, counters);
lockfile_release(statsfile);
}
free(statsfile);
counters_free(counters);
}
/* sum and display the total stats for all cache dirs */
void stats_summary(void)
{
int dir, i;
unsigned counters[STATS_END];
memset(counters, 0, sizeof(counters));
/* add up the stats in each directory */
for (dir=-1;dir<=0xF;dir++) {
char *fname;
if (dir == -1) {
x_asprintf(&fname, "%s/stats", cache_dir);
} else {
x_asprintf(&fname, "%s/%1x/stats", cache_dir, dir);
}
stats_read(fname, counters);
free(fname);
/* oh what a nasty hack ... */
if (dir == -1) {
counters[STATS_MAXSIZE] = 0;
}
}
printf("cache directory %s\n", cache_dir);
/* and display them */
for (i=0;stats_info[i].message;i++) {
enum stats stat = stats_info[i].stat;
if (counters[stat] == 0 &&
!(stats_info[i].flags & FLAG_ALWAYS)) {
continue;
}
printf("%s ", stats_info[i].message);
if (stats_info[i].fn) {
stats_info[i].fn(counters[stat]);
printf("\n");
} else {
printf("%8u\n", counters[stat]);
}
}
}
/* sum and display the total stats for all cache dirs */
void
stats_summary(void)
{
int dir, i;
struct counters *counters = counters_init(STATS_END);
/* add up the stats in each directory */
for (dir = -1; dir <= 0xF; dir++) {
char *fname;
if (dir == -1) {
fname = format("%s/stats", cache_dir);
} else {
fname = format("%s/%1x/stats", cache_dir, dir);
}
stats_read(fname, counters);
free(fname);
/* oh what a nasty hack ... */
if (dir == -1) {
counters->data[STATS_MAXSIZE] = 0;
}
}
printf("cache directory %s\n", cache_dir);
/* and display them */
for (i = 0; stats_info[i].message; i++) {
enum stats stat = stats_info[i].stat;
if (counters->data[stat] == 0 && !(stats_info[i].flags & FLAG_ALWAYS)) {
continue;
}
printf("%s ", stats_info[i].message);
if (stats_info[i].fn) {
stats_info[i].fn(counters->data[stat]);
printf("\n");
} else {
printf("%8u\n", counters->data[stat]);
}
}
counters_free(counters);
}
/* set the per directory limits */
int
stats_set_limits(long maxfiles, long maxsize)
{
int dir;
if (maxfiles != -1) {
maxfiles /= 16;
}
if (maxsize != -1) {
maxsize /= 16;
}
if (create_dir(cache_dir) != 0) {
return 1;
}
/* set the limits in each directory */
for (dir = 0; dir <= 0xF; dir++) {
char *fname, *cdir;
cdir = format("%s/%1x", cache_dir, dir);
if (create_dir(cdir) != 0) {
free(cdir);
return 1;
}
fname = format("%s/stats", cdir);
free(cdir);
if (lockfile_acquire(fname, lock_staleness_limit)) {
struct counters *counters = counters_init(STATS_END);
stats_read(fname, counters);
if (maxfiles != -1) {
counters->data[STATS_MAXFILES] = maxfiles;
}
if (maxsize != -1) {
counters->data[STATS_MAXSIZE] = maxsize;
}
stats_write(fname, counters);
lockfile_release(fname);
counters_free(counters);
}
free(fname);
}
return 0;
}
/* cleanup in all cache subdirs */
void cleanup_all(const char *dir)
{
unsigned counters[STATS_END];
char *dname, *sfile;
int i;
for (i = 0; i <= 0xF; i++) {
x_asprintf(&dname, "%s/%1x", dir, i);
x_asprintf(&sfile, "%s/%1x/stats", dir, i);
memset(counters, 0, sizeof(counters));
stats_read(sfile, counters);
cleanup_dir(dname,
counters[STATS_MAXFILES],
counters[STATS_MAXSIZE]);
free(dname);
free(sfile);
}
}
// Write counter updates in counter_updates to disk.
void
stats_flush(void)
{
assert(conf);
if (!conf->stats) {
return;
}
if (!counter_updates) {
return;
}
bool should_flush = false;
for (int i = 0; i < STATS_END; ++i) {
if (counter_updates->data[i] > 0) {
should_flush = true;
break;
}
}
if (!should_flush) {
return;
}
if (!stats_file) {
char *stats_dir;
// A NULL stats_file means that we didn't get past calculate_object_hash(),
// so we just choose one of stats files in the 16 subdirectories.
stats_dir = format("%s/%x", conf->cache_dir, hash_from_int(getpid()) % 16);
stats_file = format("%s/stats", stats_dir);
free(stats_dir);
}
if (!lockfile_acquire(stats_file, lock_staleness_limit)) {
return;
}
struct counters *counters = counters_init(STATS_END);
stats_read(stats_file, counters);
for (int i = 0; i < STATS_END; ++i) {
counters->data[i] += counter_updates->data[i];
}
stats_write(stats_file, counters);
lockfile_release(stats_file);
if (!str_eq(conf->log_file, "") || conf->debug) {
for (int i = 0; i < STATS_END; ++i) {
if (counter_updates->data[stats_info[i].stat] != 0
&& !(stats_info[i].flags & FLAG_NOZERO)) {
cc_log("Result: %s", stats_info[i].message);
}
}
}
char *subdir = dirname(stats_file);
bool need_cleanup = false;
if (conf->max_files != 0
&& counters->data[STATS_NUMFILES] > conf->max_files / 16) {
cc_log("Need to clean up %s since it holds %u files (limit: %u files)",
subdir,
counters->data[STATS_NUMFILES],
conf->max_files / 16);
need_cleanup = true;
}
if (conf->max_size != 0
&& counters->data[STATS_TOTALSIZE] > conf->max_size / 1024 / 16) {
cc_log("Need to clean up %s since it holds %u KiB (limit: %lu KiB)",
subdir,
counters->data[STATS_TOTALSIZE],
(unsigned long)conf->max_size / 1024 / 16);
need_cleanup = true;
}
if (need_cleanup) {
clean_up_dir(conf, subdir, conf->limit_multiple);
}
free(subdir);
counters_free(counters);
}
// Sum and display the total stats for all cache dirs.
void
stats_summary(struct conf *conf)
{
struct counters *counters = counters_init(STATS_END);
assert(conf);
// Add up the stats in each directory.
for (int dir = -1; dir <= 0xF; dir++) {
char *fname;
if (dir == -1) {
fname = format("%s/stats", conf->cache_dir);
} else {
fname = format("%s/%1x/stats", conf->cache_dir, dir);
}
stats_read(fname, counters);
free(fname);
}
printf("cache directory %s\n", conf->cache_dir);
printf("primary config %s\n",
primary_config_path ? primary_config_path : "");
printf("secondary config (readonly) %s\n",
secondary_config_path ? secondary_config_path : "");
// ...and display them.
for (int i = 0; stats_info[i].message; i++) {
enum stats stat = stats_info[i].stat;
if (stats_info[i].flags & FLAG_NEVER) {
continue;
}
if (counters->data[stat] == 0 && !(stats_info[i].flags & FLAG_ALWAYS)) {
continue;
}
printf("%s ", stats_info[i].message);
if (stats_info[i].fn) {
stats_info[i].fn(counters->data[stat]);
printf("\n");
} else {
printf("%8u\n", counters->data[stat]);
}
if (stat == STATS_TOCACHE) {
unsigned direct = counters->data[STATS_CACHEHIT_DIR];
unsigned preprocessed = counters->data[STATS_CACHEHIT_CPP];
unsigned hit = direct + preprocessed;
unsigned miss = counters->data[STATS_TOCACHE];
unsigned total = hit + miss;
double percent = total > 0 ? (100.0f * hit) / total : 0.0f;
printf("cache hit rate %6.2f %%\n", percent);
}
}
if (conf->max_files != 0) {
printf("max files %8u\n", conf->max_files);
}
if (conf->max_size != 0) {
printf("max cache size ");
display_size(conf->max_size);
printf("\n");
}
counters_free(counters);
}
/*
* Write counter updates in counter_updates to disk.
*/
void
stats_flush(void)
{
struct counters *counters;
bool need_cleanup = false;
bool should_flush = false;
int i;
extern char *cache_logfile;
if (getenv("CCACHE_NOSTATS")) return;
init_counter_updates();
for (i = 0; i < STATS_END; ++i) {
if (counter_updates->data[i] > 0) {
should_flush = true;
break;
}
}
if (!should_flush) return;
if (!stats_file) {
char *stats_dir;
/*
* A NULL stats_file means that we didn't get past calculate_object_hash(),
* so we just choose one of stats files in the 16 subdirectories.
*/
if (!cache_dir) return;
stats_dir = format("%s/%x", cache_dir, hash_from_int(getpid()) % 16);
stats_file = format("%s/stats", stats_dir);
create_dir(stats_dir);
free(stats_dir);
}
if (!lockfile_acquire(stats_file, lock_staleness_limit)) {
return;
}
counters = counters_init(STATS_END);
stats_read(stats_file, counters);
for (i = 0; i < STATS_END; ++i) {
counters->data[i] += counter_updates->data[i];
}
stats_write(stats_file, counters);
lockfile_release(stats_file);
if (cache_logfile) {
for (i = 0; i < STATS_END; ++i) {
if (counter_updates->data[stats_info[i].stat] != 0
&& !(stats_info[i].flags & FLAG_NOZERO)) {
cc_log("Result: %s", stats_info[i].message);
}
}
}
if (counters->data[STATS_MAXFILES] != 0 &&
counters->data[STATS_NUMFILES] > counters->data[STATS_MAXFILES]) {
need_cleanup = true;
}
if (counters->data[STATS_MAXSIZE] != 0 &&
counters->data[STATS_TOTALSIZE] > counters->data[STATS_MAXSIZE]) {
need_cleanup = true;
}
if (need_cleanup) {
char *p = dirname(stats_file);
cleanup_dir(p,
counters->data[STATS_MAXFILES],
counters->data[STATS_MAXSIZE]);
free(p);
}
}
/*
* Write counter updates in counter_updates to disk.
*/
void
stats_flush(void)
{
struct counters *counters;
bool need_cleanup = false;
bool should_flush = false;
int i;
assert(conf);
if (!conf->stats) {
return;
}
if (!counter_updates) {
return;
}
for (i = 0; i < STATS_END; ++i) {
if (counter_updates->data[i] > 0) {
should_flush = true;
break;
}
}
if (!should_flush) {
return;
}
if (!stats_file) {
char *stats_dir;
/*
* A NULL stats_file means that we didn't get past calculate_object_hash(),
* so we just choose one of stats files in the 16 subdirectories.
*/
stats_dir = format("%s/%x", conf->cache_dir, hash_from_int(getpid()) % 16);
stats_file = format("%s/stats", stats_dir);
free(stats_dir);
}
if (!lockfile_acquire(stats_file, lock_staleness_limit)) {
return;
}
counters = counters_init(STATS_END);
stats_read(stats_file, counters);
for (i = 0; i < STATS_END; ++i) {
counters->data[i] += counter_updates->data[i];
}
stats_write(stats_file, counters);
lockfile_release(stats_file);
if (!str_eq(conf->log_file, "")) {
for (i = 0; i < STATS_END; ++i) {
if (counter_updates->data[stats_info[i].stat] != 0
&& !(stats_info[i].flags & FLAG_NOZERO)) {
cc_log("Result: %s", stats_info[i].message);
}
}
}
if (conf->max_files != 0
&& counters->data[STATS_NUMFILES] > conf->max_files / 16) {
need_cleanup = true;
}
if (conf->max_size != 0
&& counters->data[STATS_TOTALSIZE] > conf->max_size / 1024 / 16) {
need_cleanup = true;
}
if (need_cleanup) {
char *p = dirname(stats_file);
cleanup_dir(conf, p);
free(p);
}
counters_free(counters);
}
