From 0a3577c161bc1e23c8d4f4a70dff4c1cc5a2c363 Mon Sep 17 00:00:00 2001
From: Niels de Vos <ndevos@redhat.com>
Date: Thu, 6 Apr 2017 15:11:00 +0200
Subject: [PATCH 615/616] io-stats: use gf_atomic_t instead of partial atomic
variables
io-stats should not use the legacy __sync_*() builtin functions for
doing atomic operations. Instead, it should use the gf_atomic_t type and
macros for any of the statistics it calculates. This makes sure that the
behaviour is the same on all architectures.
Also the __sync_*() builtins are being deprecated with __atomic_*()
functions. The "atomic.h" header will be one of the very few places
where these builtin functions are used and the feature checking will be
needed.
While replacing many of the uint64_t types, it seemed that locking
around some of the statements is not needed anymore (done automatically
with the GF_ATOMIC_*() macros). This resulted in quite some removal and
cleanup of those BUMP_*() macros. It seemed appropriate to make these
macros normal functions and let the compiler decide on inlining them.
This caused some existing functions to be shuffled around.
>Reviewed-on: https://review.gluster.org/17009
>URL: https://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html
>Smoke: Gluster Build System <jenkins@build.gluster.org>
>NetBSD-regression: NetBSD Build System <jenkins@build.gluster.org>
>CentOS-regression: Gluster Build System <jenkins@build.gluster.org>
>Reviewed-by: Amar Tumballi <amarts@redhat.com>
>Reviewed-by: Jeff Darcy <jeff@pl.atyp.us>
Change-Id: I7c4f3df1832eae51debda2b127b943e14546b605
BUG: 1475721
Signed-off-by: Niels de Vos <ndevos@redhat.com>
Reviewed-on: https://code.engineering.redhat.com/gerrit/117185
Tested-by: Atin Mukherjee <amukherj@redhat.com>
Reviewed-by: Atin Mukherjee <amukherj@redhat.com>
---
xlators/debug/io-stats/src/io-stats.c | 747 ++++++++++++++++++----------------
1 file changed, 392 insertions(+), 355 deletions(-)
diff --git a/xlators/debug/io-stats/src/io-stats.c b/xlators/debug/io-stats/src/io-stats.c
index 46e1272..92f05e5 100644
--- a/xlators/debug/io-stats/src/io-stats.c
+++ b/xlators/debug/io-stats/src/io-stats.c
@@ -42,6 +42,7 @@
#define MAX_LIST_MEMBERS 100
#define DEFAULT_PWD_BUF_SZ 16384
#define DEFAULT_GRP_BUF_SZ 16384
+#define IOS_BLOCK_COUNT_SIZE 32
typedef enum {
IOS_STATS_TYPE_NONE,
@@ -70,7 +71,7 @@ struct ios_stat {
gf_lock_t lock;
uuid_t gfid;
char *filename;
- uint64_t counters [IOS_STATS_TYPE_MAX];
+ gf_atomic_t counters[IOS_STATS_TYPE_MAX];
struct ios_stat_lat thru_counters [IOS_STATS_THRU_MAX];
int refcnt;
};
@@ -115,12 +116,12 @@ struct ios_lat {
};
struct ios_global_stats {
- uint64_t data_written;
- uint64_t data_read;
- uint64_t block_count_write[32];
- uint64_t block_count_read[32];
- uint64_t fop_hits[GF_FOP_MAXVALUE];
- uint64_t upcall_hits[GF_UPCALL_FLAGS_MAXVALUE];
+ gf_atomic_t data_written;
+ gf_atomic_t data_read;
+ gf_atomic_t block_count_write[IOS_BLOCK_COUNT_SIZE];
+ gf_atomic_t block_count_read[IOS_BLOCK_COUNT_SIZE];
+ gf_atomic_t fop_hits[GF_FOP_MAXVALUE];
+ gf_atomic_t upcall_hits[GF_UPCALL_FLAGS_MAXVALUE];
struct timeval started_at;
struct ios_lat latency[GF_FOP_MAXVALUE];
uint64_t nr_opens;
@@ -164,10 +165,10 @@ struct ios_conf {
struct ios_fd {
char *filename;
- uint64_t data_written;
- uint64_t data_read;
- uint64_t block_count_write[32];
- uint64_t block_count_read[32];
+ gf_atomic_t data_written;
+ gf_atomic_t data_read;
+ gf_atomic_t block_count_write[IOS_BLOCK_COUNT_SIZE];
+ gf_atomic_t block_count_read[IOS_BLOCK_COUNT_SIZE];
struct timeval opened_at;
};
@@ -244,26 +245,10 @@ is_fop_latency_started (call_frame_t *frame)
conf = this->private; \
if (!conf) \
break; \
- conf->cumulative.fop_hits[GF_FOP_##op]++; \
- conf->incremental.fop_hits[GF_FOP_##op]++; \
+ GF_ATOMIC_INC (conf->cumulative.fop_hits[GF_FOP_##op]); \
+ GF_ATOMIC_INC (conf->incremental.fop_hits[GF_FOP_##op]);\
} while (0)
-#if defined(HAVE_SYNC_BUILTINS)
-/* FIXME: use gf_atomic_t from libglusterfs/src/atomic.h
- *
- * This is currently not behaving correctly. Values are going out of sync in
- * the case where HAVE_SYNC_BUILTINS are available, but are updated under a
- * single lock for other cases.
- */
-#define STATS_LOCK(x)
-#define STATS_UNLOCK(x)
-#define STATS_ADD(x,i) __sync_add_and_fetch (&x, i)
-#else
-#define STATS_LOCK(x) LOCK (x)
-#define STATS_UNLOCK(x) UNLOCK (x)
-#define STATS_ADD(x,i) (x) += (i)
-#endif
-
#define UPDATE_PROFILE_STATS(frame, op) \
do { \
struct ios_conf *conf = NULL; \
@@ -271,85 +256,12 @@ is_fop_latency_started (call_frame_t *frame)
if (!is_fop_latency_started (frame)) \
break; \
conf = this->private; \
- STATS_LOCK (&conf->lock); \
- { \
- if (conf && conf->measure_latency && \
- conf->count_fop_hits) { \
- BUMP_FOP(op); \
- gettimeofday (&frame->end, NULL); \
- update_ios_latency (conf, frame, GF_FOP_##op);\
- } \
+ if (conf && conf->measure_latency && \
+ conf->count_fop_hits) { \
+ BUMP_FOP (op); \
+ gettimeofday (&frame->end, NULL); \
+ update_ios_latency (conf, frame, GF_FOP_##op); \
} \
- STATS_UNLOCK (&conf->lock); \
- } while (0)
-
-#define BUMP_READ(fd, len) \
- do { \
- struct ios_conf *conf = NULL; \
- struct ios_fd *iosfd = NULL; \
- int lb2 = 0; \
- \
- conf = this->private; \
- lb2 = log_base2 (len); \
- ios_fd_ctx_get (fd, this, &iosfd); \
- if (!conf) \
- break; \
- \
- STATS_LOCK (&conf->lock); \
- { \
- STATS_ADD (conf->cumulative.data_read, len); \
- STATS_ADD (conf->incremental.data_read, len); \
- STATS_ADD (conf->cumulative.block_count_read[lb2], 1); \
- STATS_ADD (conf->incremental.block_count_read[lb2], 1);\
- \
- if (iosfd) { \
- STATS_ADD (iosfd->data_read, len); \
- STATS_ADD (iosfd->block_count_read[lb2], 1); \
- } \
- } \
- STATS_UNLOCK (&conf->lock); \
- } while (0)
-
-#define BUMP_WRITE(fd, len) \
- do { \
- struct ios_conf *conf = NULL; \
- struct ios_fd *iosfd = NULL; \
- int lb2 = 0; \
- \
- conf = this->private; \
- lb2 = log_base2 (len); \
- ios_fd_ctx_get (fd, this, &iosfd); \
- if (!conf) \
- break; \
- STATS_LOCK (&conf->lock); \
- { \
- STATS_ADD (conf->cumulative.data_written, len); \
- STATS_ADD (conf->incremental.data_written, len); \
- STATS_ADD (conf->cumulative.block_count_write[lb2], 1);\
- STATS_ADD (conf->incremental.block_count_write[lb2], 1);\
- \
- if (iosfd) { \
- STATS_ADD (iosfd->data_written, len); \
- STATS_ADD (iosfd->block_count_write[lb2], 1); \
- } \
- } \
- STATS_UNLOCK (&conf->lock); \
- } while (0)
-
-#define BUMP_STATS(iosstat, type) \
- do { \
- struct ios_conf *conf = NULL; \
- uint64_t value = 0; \
- \
- conf = this->private; \
- \
- LOCK(&iosstat->lock); \
- { \
- value = STATS_ADD (iosstat->counters[type], 1); \
- } \
- UNLOCK (&iosstat->lock); \
- ios_stat_add_to_list (&conf->list[type], \
- value, iosstat); \
} while (0)
#define BUMP_THROUGHPUT(iosstat, type) \
@@ -368,7 +280,7 @@ is_fop_latency_started (call_frame_t *frame)
throughput = op_ret / elapsed; \
\
conf = this->private; \
- STATS_LOCK (&iosstat->lock); \
+ LOCK (&iosstat->lock); \
{ \
if (iosstat->thru_counters[type].throughput \
<= throughput) { \
@@ -379,26 +291,14 @@ is_fop_latency_started (call_frame_t *frame)
flag = 1; \
} \
} \
- STATS_UNLOCK (&iosstat->lock); \
+ UNLOCK (&iosstat->lock); \
if (flag) \
ios_stat_add_to_list (&conf->thru_list[type], \
throughput, iosstat); \
} while (0)
-#define BUMP_UPCALL(event) \
- do { \
- struct ios_conf *conf = NULL; \
- \
- conf = this->private; \
- if (!conf) \
- break; \
- if (conf->count_fop_hits) { \
- conf->cumulative.upcall_hits[event]++; \
- conf->incremental.upcall_hits[event]++; \
- } \
- } while (0)
-int
+static int
ios_fd_ctx_get (fd_t *fd, xlator_t *this, struct ios_fd **iosfd)
{
uint64_t iosfd64 = 0;
@@ -414,8 +314,7 @@ ios_fd_ctx_get (fd_t *fd, xlator_t *this, struct ios_fd **iosfd)
}
-
-int
+static int
ios_fd_ctx_set (fd_t *fd, xlator_t *this, struct ios_fd *iosfd)
{
uint64_t iosfd64 = 0;
@@ -427,7 +326,8 @@ ios_fd_ctx_set (fd_t *fd, xlator_t *this, struct ios_fd *iosfd)
return ret;
}
-int
+
+static int
ios_stat_ref (struct ios_stat *iosstat)
{
LOCK (&iosstat->lock);
@@ -439,7 +339,8 @@ ios_stat_ref (struct ios_stat *iosstat)
return iosstat->refcnt;
}
-int
+
+static int
ios_stat_unref (struct ios_stat *iosstat)
{
int cleanup = 0;
@@ -465,101 +366,8 @@ ios_stat_unref (struct ios_stat *iosstat)
return 0;
}
-int
-ios_inode_ctx_set (inode_t *inode, xlator_t *this, struct ios_stat *iosstat)
-{
- uint64_t iosstat64 = 0;
- int ret = 0;
-
- ios_stat_ref (iosstat);
- iosstat64 = (unsigned long )iosstat;
- ret = inode_ctx_put (inode, this, iosstat64);
- return ret;
-}
-
-int
-ios_inode_ctx_get (inode_t *inode, xlator_t *this, struct ios_stat **iosstat)
-{
- uint64_t iosstat64 = 0;
- unsigned long iosstatlong = 0;
- int ret = 0;
-
- ret = inode_ctx_get (inode, this, &iosstat64);
- iosstatlong = iosstat64;
- if (ret != -1)
- *iosstat = (void *) iosstatlong;
-
- return ret;
-
-}
-
-/*
- * So why goto all this trouble? Why not just queue up some samples in
- * a big list and malloc away? Well malloc is expensive relative
- * to what we are measuring, so cannot have any malloc's (or worse
- * callocs) in our measurement code paths. Instead, we are going to
- * pre-allocate a circular buffer and collect a maximum number of samples.
- * Prior to dumping them all we'll create a new buffer and swap the
- * old buffer with the new, and then proceed to dump the statistics
- * in our dump thread.
- *
- */
-ios_sample_buf_t *
-ios_create_sample_buf (size_t buf_size)
-{
- ios_sample_buf_t *ios_sample_buf = NULL;
- ios_sample_t *ios_samples = NULL;
-
- ios_sample_buf = GF_CALLOC (1,
- sizeof (*ios_sample_buf),
- gf_io_stats_mt_ios_sample_buf);
- if (!ios_sample_buf)
- goto err;
-
- ios_samples = GF_CALLOC (buf_size,
- sizeof (*ios_samples),
- gf_io_stats_mt_ios_sample);
-
- if (!ios_samples)
- goto err;
-
- ios_sample_buf->ios_samples = ios_samples;
- ios_sample_buf->size = buf_size;
- ios_sample_buf->pos = 0;
- ios_sample_buf->observed = 0;
- ios_sample_buf->collected = 0;
-
- return ios_sample_buf;
-err:
- GF_FREE (ios_sample_buf);
- return NULL;
-}
-
-void
-ios_destroy_sample_buf (ios_sample_buf_t *ios_sample_buf)
-{
- GF_FREE (ios_sample_buf->ios_samples);
- GF_FREE (ios_sample_buf);
-}
static int
-ios_init_sample_buf (struct ios_conf *conf)
-{
- int32_t ret = -1;
-
- GF_ASSERT (conf);
- LOCK (&conf->lock);
- conf->ios_sample_buf = ios_create_sample_buf (
- conf->ios_sample_buf_size);
- if (!conf->ios_sample_buf)
- goto out;
- ret = 0;
-out:
- UNLOCK (&conf->lock);
- return ret;
-}
-
-int
ios_stat_add_to_list (struct ios_stat_head *list_head, uint64_t value,
struct ios_stat *iosstat)
{
@@ -654,6 +462,180 @@ out:
return 0;
}
+
+static void
+ios_bump_read (xlator_t *this, fd_t *fd, size_t len)
+{
+ struct ios_conf *conf = NULL;
+ struct ios_fd *iosfd = NULL;
+ int lb2 = 0;
+
+ conf = this->private;
+ lb2 = log_base2 (len);
+ ios_fd_ctx_get (fd, this, &iosfd);
+ if (!conf)
+ return;
+
+ GF_ATOMIC_ADD (conf->cumulative.data_read, len);
+ GF_ATOMIC_ADD (conf->incremental.data_read, len);
+ GF_ATOMIC_INC (conf->cumulative.block_count_read[lb2]);
+ GF_ATOMIC_INC (conf->incremental.block_count_read[lb2]);
+
+ if (iosfd) {
+ GF_ATOMIC_ADD (iosfd->data_read, len);
+ GF_ATOMIC_INC (iosfd->block_count_read[lb2]);
+ }
+}
+
+
+static void
+ios_bump_write (xlator_t *this, fd_t *fd, size_t len)
+{
+ struct ios_conf *conf = NULL;
+ struct ios_fd *iosfd = NULL;
+ int lb2 = 0;
+
+ conf = this->private;
+ lb2 = log_base2 (len);
+ ios_fd_ctx_get (fd, this, &iosfd);
+ if (!conf)
+ return;
+
+ GF_ATOMIC_ADD (conf->cumulative.data_written, len);
+ GF_ATOMIC_ADD (conf->incremental.data_written, len);
+ GF_ATOMIC_INC (conf->cumulative.block_count_write[lb2]);
+ GF_ATOMIC_INC (conf->incremental.block_count_write[lb2]);
+
+ if (iosfd) {
+ GF_ATOMIC_ADD (iosfd->data_written, len);
+ GF_ATOMIC_INC (iosfd->block_count_write[lb2]);
+ }
+}
+
+
+static void
+ios_bump_upcall (xlator_t *this, gf_upcall_flags_t event)
+{
+ struct ios_conf *conf = NULL;
+
+ conf = this->private;
+ if (!conf)
+ return;
+ if (conf->count_fop_hits) {
+ GF_ATOMIC_INC (conf->cumulative.upcall_hits[event]);
+ GF_ATOMIC_INC (conf->incremental.upcall_hits[event]);
+ }
+}
+
+
+static void
+ios_bump_stats (xlator_t *this, struct ios_stat *iosstat,
+ ios_stats_type_t type)
+{
+ struct ios_conf *conf = NULL;
+ uint64_t value = 0;
+
+ conf = this->private;
+
+ value = GF_ATOMIC_INC (iosstat->counters[type]);
+ ios_stat_add_to_list (&conf->list[type], value, iosstat);
+}
+
+
+int
+ios_inode_ctx_set (inode_t *inode, xlator_t *this, struct ios_stat *iosstat)
+{
+ uint64_t iosstat64 = 0;
+ int ret = 0;
+
+ ios_stat_ref (iosstat);
+ iosstat64 = (unsigned long) iosstat;
+ ret = inode_ctx_put (inode, this, iosstat64);
+ return ret;
+}
+
+int
+ios_inode_ctx_get (inode_t *inode, xlator_t *this, struct ios_stat **iosstat)
+{
+ uint64_t iosstat64 = 0;
+ unsigned long iosstatlong = 0;
+ int ret = 0;
+
+ ret = inode_ctx_get (inode, this, &iosstat64);
+ iosstatlong = iosstat64;
+ if (ret != -1)
+ *iosstat = (void *) iosstatlong;
+
+ return ret;
+
+}
+
+/*
+ * So why goto all this trouble? Why not just queue up some samples in
+ * a big list and malloc away? Well malloc is expensive relative
+ * to what we are measuring, so cannot have any malloc's (or worse
+ * callocs) in our measurement code paths. Instead, we are going to
+ * pre-allocate a circular buffer and collect a maximum number of samples.
+ * Prior to dumping them all we'll create a new buffer and swap the
+ * old buffer with the new, and then proceed to dump the statistics
+ * in our dump thread.
+ *
+ */
+ios_sample_buf_t *
+ios_create_sample_buf (size_t buf_size)
+{
+ ios_sample_buf_t *ios_sample_buf = NULL;
+ ios_sample_t *ios_samples = NULL;
+
+ ios_sample_buf = GF_CALLOC (1,
+ sizeof (*ios_sample_buf),
+ gf_io_stats_mt_ios_sample_buf);
+ if (!ios_sample_buf)
+ goto err;
+
+ ios_samples = GF_CALLOC (buf_size,
+ sizeof (*ios_samples),
+ gf_io_stats_mt_ios_sample);
+
+ if (!ios_samples)
+ goto err;
+
+ ios_sample_buf->ios_samples = ios_samples;
+ ios_sample_buf->size = buf_size;
+ ios_sample_buf->pos = 0;
+ ios_sample_buf->observed = 0;
+ ios_sample_buf->collected = 0;
+
+ return ios_sample_buf;
+err:
+ GF_FREE (ios_sample_buf);
+ return NULL;
+}
+
+void
+ios_destroy_sample_buf (ios_sample_buf_t *ios_sample_buf)
+{
+ GF_FREE (ios_sample_buf->ios_samples);
+ GF_FREE (ios_sample_buf);
+}
+
+static int
+ios_init_sample_buf (struct ios_conf *conf)
+{
+ int32_t ret = -1;
+
+ GF_ASSERT (conf);
+ LOCK (&conf->lock);
+ conf->ios_sample_buf = ios_create_sample_buf (
+ conf->ios_sample_buf_size);
+ if (!conf->ios_sample_buf)
+ goto out;
+ ret = 0;
+out:
+ UNLOCK (&conf->lock);
+ return ret;
+}
+
static int
ios_stats_cleanup (xlator_t *this, inode_t *inode)
{
@@ -808,7 +790,7 @@ io_stats_dump_global_to_json_logfp (xlator_t *this,
int ret = 1; /* Default to error */
int rw_size;
char *rw_unit = NULL;
- long fop_hits;
+ uint64_t fop_hits;
float fop_lat_ave;
float fop_lat_min;
float fop_lat_max;
@@ -847,24 +829,26 @@ io_stats_dump_global_to_json_logfp (xlator_t *this,
if (interval == -1) {
ios_log (this, logfp,
- "\"%s.%s.read_%d%s\": \"%"PRId64"\",",
+ "\"%s.%s.read_%d%s\": \"%"GF_PRI_ATOMIC"\",",
key_prefix, str_prefix, rw_size, rw_unit,
- stats->block_count_read[i]);
+ GF_ATOMIC_GET (stats->block_count_read[i]));
ios_log (this, logfp,
- "\"%s.%s.write_%d%s\": \"%"PRId64"\",",
+ "\"%s.%s.write_%d%s\": \"%"GF_PRI_ATOMIC"\",",
key_prefix, str_prefix, rw_size, rw_unit,
- stats->block_count_write[i]);
+ GF_ATOMIC_GET (stats->block_count_write[i]));
} else {
ios_log (this, logfp,
"\"%s.%s.read_%d%s_per_sec\": \"%0.2lf\",",
key_prefix, str_prefix, rw_size, rw_unit,
- (double)(stats->block_count_read[i] /
- interval_sec));
+ (double)
+ (GF_ATOMIC_GET (stats->block_count_read[i]) /
+ interval_sec));
ios_log (this, logfp,
"\"%s.%s.write_%d%s_per_sec\": \"%0.2lf\",",
key_prefix, str_prefix, rw_size, rw_unit,
- (double)(stats->block_count_write[i] /
- interval_sec));
+ (double)
+ (GF_ATOMIC_GET (stats->block_count_write[i]) /
+ interval_sec));
}
}
@@ -883,12 +867,11 @@ io_stats_dump_global_to_json_logfp (xlator_t *this,
lc_fop_name[j] = tolower (lc_fop_name[j]);
}
- fop_hits = 0;
+ fop_hits = GF_ATOMIC_GET (stats->fop_hits[i]);
fop_lat_ave = 0.0;
fop_lat_min = 0.0;
fop_lat_max = 0.0;
- if (stats->fop_hits[i]) {
- fop_hits = stats->fop_hits[i];
+ if (fop_hits) {
if (stats->latency[i].avg) {
fop_lat_ave = stats->latency[i].avg;
fop_lat_min = stats->latency[i].min;
@@ -897,7 +880,7 @@ io_stats_dump_global_to_json_logfp (xlator_t *this,
}
if (interval == -1) {
ios_log (this, logfp,
- "\"%s.%s.fop.%s.count\": \"%"PRId64"\",",
+ "\"%s.%s.fop.%s.count\": \"%"GF_PRI_ATOMIC"\",",
key_prefix, str_prefix, lc_fop_name,
fop_hits);
} else {
@@ -923,10 +906,10 @@ io_stats_dump_global_to_json_logfp (xlator_t *this,
for (j = 0; lc_fop_name[j]; j++) {
lc_fop_name[j] = tolower (lc_fop_name[j]);
}
- fop_hits = stats->upcall_hits[i];
+ fop_hits = GF_ATOMIC_GET (stats->upcall_hits[i]);
if (interval == -1) {
ios_log (this, logfp,
- "\"%s.%s.fop.%s.count\": \"%"PRId64"\",",
+ "\"%s.%s.fop.%s.count\": \"%"GF_PRI_ATOMIC"\",",
key_prefix, str_prefix, lc_fop_name,
fop_hits);
} else {
@@ -941,10 +924,12 @@ io_stats_dump_global_to_json_logfp (xlator_t *this,
ios_log (this, logfp, "\"%s.%s.uptime\": \"%"PRId64"\",",
key_prefix, str_prefix,
(uint64_t) (now->tv_sec - stats->started_at.tv_sec));
- ios_log (this, logfp, "\"%s.%s.bytes_read\": \"%"PRId64"\",",
- key_prefix, str_prefix, stats->data_read);
- ios_log (this, logfp, "\"%s.%s.bytes_written\": \"%"PRId64"\"",
- key_prefix, str_prefix, stats->data_written);
+ ios_log (this, logfp, "\"%s.%s.bytes_read\": \""
+ "%"GF_PRI_ATOMIC"\",", key_prefix, str_prefix,
+ GF_ATOMIC_GET (stats->data_read));
+ ios_log (this, logfp, "\"%s.%s.bytes_written\": \""
+ "%"GF_PRI_ATOMIC"\"", key_prefix, str_prefix,
+ GF_ATOMIC_GET (stats->data_written));
} else {
ios_log (this, logfp,
"\"%s.%s.sample_interval_sec\": \"%0.2lf\",",
@@ -952,12 +937,12 @@ io_stats_dump_global_to_json_logfp (xlator_t *this,
interval_sec);
ios_log (this, logfp,
"\"%s.%s.bytes_read_per_sec\": \"%0.2lf\",",
- key_prefix, str_prefix,
- (double)(stats->data_read / interval_sec));
+ key_prefix, str_prefix, (double)
+ (GF_ATOMIC_GET (stats->data_read) / interval_sec));
ios_log (this, logfp,
"\"%s.%s.bytes_written_per_sec\": \"%0.2lf\"",
- key_prefix, str_prefix,
- (double)(stats->data_written / interval_sec));
+ key_prefix, str_prefix, (double)
+ (GF_ATOMIC_GET (stats->data_written) / interval_sec));
}
ios_log (this, logfp, "}");
@@ -1204,6 +1189,9 @@ io_stats_dump_global_to_logfp (xlator_t *this, struct ios_global_stats *stats,
char str_header[128] = {0};
char str_read[128] = {0};
char str_write[128] = {0};
+ uint64_t fop_hits = 0;
+ uint64_t block_count_read = 0;
+ uint64_t block_count_write = 0;
conf = this->private;
@@ -1214,31 +1202,32 @@ io_stats_dump_global_to_logfp (xlator_t *this, struct ios_global_stats *stats,
interval);
ios_log (this, logfp, " Duration : %"PRId64" secs",
(uint64_t) (now->tv_sec - stats->started_at.tv_sec));
- ios_log (this, logfp, " BytesRead : %"PRId64,
- stats->data_read);
- ios_log (this, logfp, " BytesWritten : %"PRId64"\n",
- stats->data_written);
+ ios_log (this, logfp, " BytesRead : %"GF_PRI_ATOMIC,
+ GF_ATOMIC_GET (stats->data_read));
+ ios_log (this, logfp, " BytesWritten : %"GF_PRI_ATOMIC"\n",
+ GF_ATOMIC_GET (stats->data_written));
snprintf (str_header, sizeof (str_header), "%-12s %c", "Block Size", ':');
snprintf (str_read, sizeof (str_read), "%-12s %c", "Read Count", ':');
snprintf (str_write, sizeof (str_write), "%-12s %c", "Write Count", ':');
index = 14;
- for (i = 0; i < 32; i++) {
- if ((stats->block_count_read[i] == 0) &&
- (stats->block_count_write[i] == 0))
+ for (i = 0; i < IOS_BLOCK_COUNT_SIZE; i++) {
+ block_count_read = GF_ATOMIC_GET (stats->block_count_read[i]);
+ block_count_write = GF_ATOMIC_GET (stats->block_count_write[i]);
+ if ((block_count_read == 0) && (block_count_write == 0))
continue;
per_line++;
snprintf (str_header+index, sizeof (str_header)-index,
"%16dB+", (1<<i));
- if (stats->block_count_read[i])
+ if (block_count_read)
snprintf (str_read+index, sizeof (str_read)-index,
- "%18"PRId64, stats->block_count_read[i]);
+ "%18"PRId64, block_count_read);
else snprintf (str_read+index, sizeof (str_read)-index,
"%18s", "0");
- if (stats->block_count_write[i])
+ if (block_count_write)
snprintf (str_write+index, sizeof (str_write)-index,
- "%18"PRId64, stats->block_count_write[i]);
+ "%18"GF_PRI_ATOMIC, block_count_write);
else snprintf (str_write+index, sizeof (str_write)-index,
"%18s", "0");
@@ -1277,22 +1266,25 @@ io_stats_dump_global_to_logfp (xlator_t *this, struct ios_global_stats *stats,
"-----------", "-----------", "-----------");
for (i = 0; i < GF_FOP_MAXVALUE; i++) {
- if (stats->fop_hits[i] && !stats->latency[i].avg)
- ios_log (this, logfp, "%-13s %10"PRId64" %11s "
+ fop_hits = GF_ATOMIC_GET (stats->fop_hits[i]);
+ if (fop_hits && !stats->latency[i].avg)
+ ios_log (this, logfp, "%-13s %10"GF_PRI_ATOMIC" %11s "
"us %11s us %11s us", gf_fop_list[i],
- stats->fop_hits[i], "0", "0", "0");
- else if (stats->fop_hits[i] && stats->latency[i].avg)
- ios_log (this, logfp, "%-13s %10"PRId64" %11.2lf us "
- "%11.2lf us %11.2lf us", gf_fop_list[i],
- stats->fop_hits[i], stats->latency[i].avg,
- stats->latency[i].min, stats->latency[i].max);
+ fop_hits, "0", "0", "0");
+ else if (fop_hits && stats->latency[i].avg)
+ ios_log (this, logfp, "%-13s %10"GF_PRI_ATOMIC" "
+ "%11.2lf us %11.2lf us %11.2lf us",
+ gf_fop_list[i], fop_hits,
+ stats->latency[i].avg, stats->latency[i].min,
+ stats->latency[i].max);
}
for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) {
- if (stats->upcall_hits[i])
+ fop_hits = GF_ATOMIC_GET (stats->upcall_hits[i]);
+ if (fop_hits)
ios_log (this, logfp, "%-13s %10"PRId64" %11s "
"us %11s us %11s us", gf_upcall_list[i],
- stats->upcall_hits[i], "0", "0", "0");
+ fop_hits, "0", "0", "0");
}
ios_log (this, logfp, "------ ----- ----- ----- ----- ----- ----- ----- "
@@ -1365,6 +1357,7 @@ io_stats_dump_global_to_dict (xlator_t *this, struct ios_global_stats *stats,
uint64_t sec = 0;
int i = 0;
uint64_t count = 0;
+ uint64_t fop_hits = 0;
GF_ASSERT (stats);
GF_ASSERT (now);
@@ -1392,27 +1385,29 @@ io_stats_dump_global_to_dict (xlator_t *this, struct ios_global_stats *stats,
memset (key, 0, sizeof (key));
snprintf (key, sizeof (key), "%d-total-read", interval);
- ret = dict_set_uint64 (dict, key, stats->data_read);
+ ret = dict_set_uint64 (dict, key, GF_ATOMIC_GET (stats->data_read));
if (ret) {
gf_log (this->name, GF_LOG_ERROR, "failed to set total "
- "read(%d) - %"PRId64, interval, stats->data_read);
+ "read(%d) - %"GF_PRI_ATOMIC, interval,
+ GF_ATOMIC_GET (stats->data_read));
goto out;
}
memset (key, 0, sizeof (key));
snprintf (key, sizeof (key), "%d-total-write", interval);
- ret = dict_set_uint64 (dict, key, stats->data_written);
+ ret = dict_set_uint64 (dict, key, GF_ATOMIC_GET (stats->data_written));
if (ret) {
gf_log (this->name, GF_LOG_ERROR, "failed to set total "
- "write(%d) - %"PRId64, interval, stats->data_written);
+ "write(%d) - %"GF_PRI_ATOMIC, interval,
+ GF_ATOMIC_GET (stats->data_written));
goto out;
}
for (i = 0; i < 32; i++) {
- if (stats->block_count_read[i]) {
+ count = GF_ATOMIC_GET (stats->block_count_read[i]);
+ if (count) {
memset (key, 0, sizeof (key));
snprintf (key, sizeof (key), "%d-read-%d", interval,
(1 << i));
- count = stats->block_count_read[i];
ret = dict_set_uint64 (dict, key, count);
if (ret) {
gf_log (this->name, GF_LOG_ERROR, "failed to "
@@ -1423,11 +1418,11 @@ io_stats_dump_global_to_dict (xlator_t *this, struct ios_global_stats *stats,
}
}
- for (i = 0; i < 32; i++) {
- if (stats->block_count_write[i]) {
+ for (i = 0; i < IOS_BLOCK_COUNT_SIZE; i++) {
+ count = GF_ATOMIC_GET (stats->block_count_write[i]);
+ if (count) {
snprintf (key, sizeof (key), "%d-write-%d", interval,
(1<<i));
- count = stats->block_count_write[i];
ret = dict_set_uint64 (dict, key, count);
if (ret) {
gf_log (this->name, GF_LOG_ERROR, "failed to "
@@ -1439,14 +1434,15 @@ io_stats_dump_global_to_dict (xlator_t *this, struct ios_global_stats *stats,
}
for (i = 0; i < GF_FOP_MAXVALUE; i++) {
- if (stats->fop_hits[i] == 0)
+ fop_hits = GF_ATOMIC_GET (stats->fop_hits[i]);
+ if (fop_hits == 0)
continue;
snprintf (key, sizeof (key), "%d-%d-hits", interval, i);
- ret = dict_set_uint64 (dict, key, stats->fop_hits[i]);
+ ret = dict_set_uint64 (dict, key, fop_hits);
if (ret) {
- gf_log (this->name, GF_LOG_ERROR, "failed to "
- "set %s-fop-hits: %"PRIu64, gf_fop_list[i],
- stats->fop_hits[i]);
+ gf_log (this->name, GF_LOG_ERROR, "failed to set "
+ "%s-fop-hits: %"GF_PRI_ATOMIC, gf_fop_list[i],
+ fop_hits);
goto out;
}
@@ -1478,15 +1474,15 @@ io_stats_dump_global_to_dict (xlator_t *this, struct ios_global_stats *stats,
}
}
for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++) {
- if (stats->upcall_hits[i] == 0)
+ fop_hits = GF_ATOMIC_GET (stats->upcall_hits[i]);
+ if (fop_hits == 0)
continue;
snprintf (key, sizeof (key), "%d-%d-upcall-hits", interval, i);
- ret = dict_set_uint64 (dict, key, stats->upcall_hits[i]);
+ ret = dict_set_uint64 (dict, key, fop_hits);
if (ret) {
gf_log (this->name, GF_LOG_ERROR, "failed to "
"set %s-upcall-hits: %"PRIu64,
- gf_upcall_list[i],
- stats->upcall_hits[i]);
+ gf_upcall_list[i], fop_hits);
goto out;
}
}
@@ -1572,8 +1568,8 @@ io_stats_dump (xlator_t *this, struct ios_dump_args *args,
gf1_cli_info_op op, gf_boolean_t is_peek)
{
struct ios_conf *conf = NULL;
- struct ios_global_stats cumulative = {0, };
- struct ios_global_stats incremental = {0, };
+ struct ios_global_stats cumulative = {{0,}, };
+ struct ios_global_stats incremental = {{0,}, };
int increment = 0;
struct timeval now;
@@ -1626,6 +1622,10 @@ io_stats_dump_fd (xlator_t *this, struct ios_fd *iosfd)
uint64_t sec = 0;
uint64_t usec = 0;
int i = 0;
+ uint64_t data_read = 0;
+ uint64_t data_written = 0;
+ uint64_t block_count_read = 0;
+ uint64_t block_count_write = 0;
conf = this->private;
@@ -1658,27 +1658,29 @@ io_stats_dump_fd (xlator_t *this, struct ios_fd *iosfd)
" Lifetime : %"PRId64"secs, %"PRId64"usecs",
sec, usec);
- if (iosfd->data_read)
+ data_read = GF_ATOMIC_GET (iosfd->data_read);
+ if (data_read)
gf_log (this->name, GF_LOG_INFO,
- " BytesRead : %"PRId64" bytes",
- iosfd->data_read);
+ " BytesRead : %"PRId64" bytes", data_read);
- if (iosfd->data_written)
+ data_written = GF_ATOMIC_GET (iosfd->data_written);
+ if (data_written)
gf_log (this->name, GF_LOG_INFO,
" BytesWritten : %"PRId64" bytes",
- iosfd->data_written);
+ data_written);
for (i = 0; i < 32; i++) {
- if (iosfd->block_count_read[i])
- gf_log (this->name, GF_LOG_INFO,
- " Read %06db+ : %"PRId64,
- (1 << i), iosfd->block_count_read[i]);
+ block_count_read = GF_ATOMIC_GET (iosfd->block_count_read[i]);
+ if (block_count_read)
+ gf_log (this->name, GF_LOG_INFO, " Read %06db+ :"
+ "%"PRId64, (1 << i), block_count_read);
}
- for (i = 0; i < 32; i++) {
- if (iosfd->block_count_write[i])
+ for (i = 0; i < IOS_BLOCK_COUNT_SIZE; i++) {
+ block_count_write = GF_ATOMIC_GET (iosfd->block_count_write[i]);
+ if (block_count_write)
gf_log (this->name, GF_LOG_INFO,
"Write %06db+ : %"PRId64,
- (1 << i), iosfd->block_count_write[i]);
+ (1 << i), block_count_write);
}
return 0;
}
@@ -1744,7 +1746,8 @@ update_ios_latency_stats (struct ios_global_stats *stats, double elapsed,
avg = stats->latency[op].avg;
- stats->latency[op].avg = avg + (elapsed - avg) / stats->fop_hits[op];
+ stats->latency[op].avg = avg + (elapsed - avg) /
+ GF_ATOMIC_GET (stats->fop_hits[op]);
}
int
@@ -1886,6 +1889,29 @@ unlock_list_head:
return ret;
}
+static struct ios_stat*
+ios_init_iosstat (xlator_t *this, char *path, uuid_t gfid, inode_t *inode)
+{
+ struct ios_stat *iosstat = NULL;
+ int i = 0;
+
+ iosstat = GF_CALLOC (1, sizeof (*iosstat), gf_io_stats_mt_ios_stat);
+ if (!iosstat)
+ goto out;
+
+ iosstat->filename = gf_strdup (path);
+ gf_uuid_copy (iosstat->gfid, gfid);
+ LOCK_INIT (&iosstat->lock);
+
+ for (i = 0; i < IOS_STATS_TYPE_MAX; i++)
+ GF_ATOMIC_INIT (iosstat->counters[i], 0);
+
+ ios_inode_ctx_set (inode, this, iosstat);
+
+out:
+ return iosstat;
+}
+
int
io_stats_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, fd_t *fd,
@@ -1930,15 +1956,9 @@ io_stats_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
}
UNLOCK (&conf->lock);
- iosstat = GF_CALLOC (1, sizeof (*iosstat), gf_io_stats_mt_ios_stat);
- if (!iosstat) {
+ iosstat = ios_init_iosstat (this, path, buf->ia_gfid, inode);
+ if (!iosstat)
GF_FREE (path);
- goto unwind;
- }
- iosstat->filename = gf_strdup (path);
- gf_uuid_copy (iosstat->gfid, buf->ia_gfid);
- LOCK_INIT (&iosstat->lock);
- ios_inode_ctx_set (fd->inode, this, iosstat);
unwind:
UPDATE_PROFILE_STATS (frame, CREATE);
@@ -1952,10 +1972,11 @@ int
io_stats_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
{
- struct ios_fd *iosfd = NULL;
- char *path = NULL;
- struct ios_stat *iosstat = NULL;
+ struct ios_fd *iosfd = NULL;
+ char *path = NULL;
+ struct ios_stat *iosstat = NULL;
struct ios_conf *conf = NULL;
+ int i = 0;
conf = this->private;
path = frame->local;
@@ -1976,20 +1997,20 @@ io_stats_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
}
iosfd->filename = path;
+ GF_ATOMIC_INIT (iosfd->data_read, 0);
+ GF_ATOMIC_INIT (iosfd->data_written, 0);
+ for (i = 0; i < IOS_BLOCK_COUNT_SIZE; i++) {
+ GF_ATOMIC_INIT (iosfd->block_count_write[i], 0);
+ GF_ATOMIC_INIT (iosfd->block_count_read[i], 0);
+ }
gettimeofday (&iosfd->opened_at, NULL);
ios_fd_ctx_set (fd, this, iosfd);
ios_inode_ctx_get (fd->inode, this, &iosstat);
if (!iosstat) {
- iosstat = GF_CALLOC (1, sizeof (*iosstat),
- gf_io_stats_mt_ios_stat);
- if (iosstat) {
- iosstat->filename = gf_strdup (path);
- gf_uuid_copy (iosstat->gfid, fd->inode->gfid);
- LOCK_INIT (&iosstat->lock);
- ios_inode_ctx_set (fd->inode, this, iosstat);
- }
+ iosstat = ios_init_iosstat (this, path, fd->inode->gfid,
+ fd->inode);
}
LOCK (&conf->lock);
@@ -2002,8 +2023,8 @@ io_stats_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
}
UNLOCK (&conf->lock);
if (iosstat) {
- BUMP_STATS (iosstat, IOS_STATS_TYPE_OPEN);
- iosstat = NULL;
+ ios_bump_stats (this, iosstat, IOS_STATS_TYPE_OPEN);
+ iosstat = NULL;
}
unwind:
UPDATE_PROFILE_STATS (frame, OPEN);
@@ -2039,16 +2060,16 @@ io_stats_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
if (op_ret > 0) {
len = iov_length (vector, count);
- BUMP_READ (fd, len);
+ ios_bump_read (this, fd, len);
}
UPDATE_PROFILE_STATS (frame, READ);
ios_inode_ctx_get (fd->inode, this, &iosstat);
if (iosstat) {
- BUMP_STATS (iosstat, IOS_STATS_TYPE_READ);
- BUMP_THROUGHPUT (iosstat, IOS_STATS_THRU_READ);
- iosstat = NULL;
+ ios_bump_stats (this, iosstat, IOS_STATS_TYPE_READ);
+ BUMP_THROUGHPUT (iosstat, IOS_STATS_THRU_READ);
+ iosstat = NULL;
}
STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno,
@@ -2072,7 +2093,7 @@ io_stats_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
frame->local = NULL;
ios_inode_ctx_get (inode, this, &iosstat);
if (iosstat) {
- BUMP_STATS (iosstat, IOS_STATS_TYPE_WRITE);
+ ios_bump_stats (this, iosstat, IOS_STATS_TYPE_WRITE);
BUMP_THROUGHPUT (iosstat, IOS_STATS_THRU_WRITE);
inode = NULL;
iosstat = NULL;
@@ -2101,8 +2122,8 @@ io_stats_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
ios_inode_ctx_get (inode, this, &iosstat);
if (iosstat) {
- BUMP_STATS (iosstat, IOS_STATS_TYPE_READDIRP);
- iosstat = NULL;
+ ios_bump_stats (this, iosstat, IOS_STATS_TYPE_READDIRP);
+ iosstat = NULL;
}
STACK_UNWIND_STRICT (readdirp, frame, op_ret, op_errno, buf, xdata);
@@ -2226,7 +2247,6 @@ io_stats_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
struct iatt *preparent, struct iatt *postparent,
dict_t *xdata)
{
- struct ios_stat *iosstat = NULL;
char *path = frame->local;
if (!path)
@@ -2236,13 +2256,8 @@ io_stats_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
if (op_ret < 0)
goto unwind;
- iosstat = GF_CALLOC (1, sizeof (*iosstat), gf_io_stats_mt_ios_stat);
- if (iosstat) {
- LOCK_INIT (&iosstat->lock);
- iosstat->filename = gf_strdup(path);
- gf_uuid_copy (iosstat->gfid, buf->ia_gfid);
- ios_inode_ctx_set (inode, this, iosstat);
- }
+ /* allocate a struct ios_stat and set the inode ctx */
+ ios_init_iosstat (this, path, buf->ia_gfid, inode);
unwind:
/* local is assigned with path */
@@ -2292,7 +2307,7 @@ io_stats_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
ret = ios_inode_ctx_get (fd->inode, this, &iosstat);
if (!ret)
- BUMP_STATS (iosstat, IOS_STATS_TYPE_OPENDIR);
+ ios_bump_stats (this, iosstat, IOS_STATS_TYPE_OPENDIR);
unwind:
STACK_UNWIND_STRICT (opendir, frame, op_ret, op_errno, fd, xdata);
@@ -2930,7 +2945,7 @@ io_stats_writev (call_frame_t *frame, xlator_t *this,
frame->local = fd->inode;
len = iov_length (vector, count);
- BUMP_WRITE (fd, len);
+ ios_bump_write (this, fd, len);
START_FOP_LATENCY (frame);
STACK_WIND (frame, io_stats_writev_cbk,
@@ -3704,23 +3719,23 @@ io_priv (xlator_t *this)
if(!conf->count_fop_hits || !conf->measure_latency)
return -1;
- gf_proc_dump_write("cumulative.data_read", "%"PRIu64,
- conf->cumulative.data_read);
- gf_proc_dump_write("cumulative.data_written", "%"PRIu64,
- conf->cumulative.data_written);
+ gf_proc_dump_write ("cumulative.data_read", "%"GF_PRI_ATOMIC,
+ GF_ATOMIC_GET (conf->cumulative.data_read));
+ gf_proc_dump_write ("cumulative.data_written", "%"GF_PRI_ATOMIC,
+ GF_ATOMIC_GET (conf->cumulative.data_written));
- gf_proc_dump_write("incremental.data_read", "%"PRIu64,
- conf->incremental.data_read);
- gf_proc_dump_write("incremental.data_written", "%"PRIu64,
- conf->incremental.data_written);
+ gf_proc_dump_write ("incremental.data_read", "%"GF_PRI_ATOMIC,
+ GF_ATOMIC_GET (conf->incremental.data_read));
+ gf_proc_dump_write ("incremental.data_written", "%"GF_PRI_ATOMIC,
+ GF_ATOMIC_GET (conf->incremental.data_written));
snprintf (key_prefix_cumulative, GF_DUMP_MAX_BUF_LEN, "%s.cumulative",
- this->name);
+ this->name);
snprintf (key_prefix_incremental, GF_DUMP_MAX_BUF_LEN, "%s.incremental",
- this->name);
+ this->name);
for (i = 0; i < GF_FOP_MAXVALUE; i++) {
- count = conf->cumulative.fop_hits[i];
+ count = GF_ATOMIC_GET (conf->cumulative.fop_hits[i]);
total = conf->cumulative.latency[i].total;
min = conf->cumulative.latency[i].min;
max = conf->cumulative.latency[i].max;
@@ -3732,7 +3747,7 @@ io_priv (xlator_t *this)
gf_proc_dump_write (key,"%"PRId64",%"PRId64",%.03f,%.03f,%.03f",
count, total, min, max, avg);
- count = conf->incremental.fop_hits[i];
+ count = GF_ATOMIC_GET (conf->incremental.fop_hits[i]);
total = conf->incremental.latency[i].total;
min = conf->incremental.latency[i].min;
max = conf->incremental.latency[i].max;
@@ -3862,6 +3877,28 @@ ios_conf_destroy (struct ios_conf *conf)
GF_FREE(conf);
}
+static void
+ios_init_stats (struct ios_global_stats *stats)
+{
+ int i = 0;
+
+ GF_ATOMIC_INIT (stats->data_read, 0);
+ GF_ATOMIC_INIT (stats->data_written, 0);
+
+ for (i = 0; i < IOS_BLOCK_COUNT_SIZE; i++) {
+ GF_ATOMIC_INIT (stats->block_count_write[i], 0);
+ GF_ATOMIC_INIT (stats->block_count_read[i], 0);
+ }
+
+ for (i = 0; i < GF_FOP_MAXVALUE; i++)
+ GF_ATOMIC_INIT (stats->fop_hits[i], 0);
+
+ for (i = 0; i < GF_UPCALL_FLAGS_MAXVALUE; i++)
+ GF_ATOMIC_INIT (stats->upcall_hits[i], 0);
+
+ gettimeofday (&stats->started_at, NULL);
+}
+
int
init (xlator_t *this)
{
@@ -3912,8 +3949,8 @@ init (xlator_t *this)
LOCK_INIT (&conf->lock);
LOCK_INIT (&conf->ios_sampling_lock);
- gettimeofday (&conf->cumulative.started_at, NULL);
- gettimeofday (&conf->incremental.started_at, NULL);
+ ios_init_stats (&conf->cumulative);
+ ios_init_stats (&conf->incremental);
ret = ios_init_top_stats (conf);
if (ret)
@@ -4119,24 +4156,24 @@ notify (xlator_t *this, int32_t event, void *data, ...)
break;
case GF_EVENT_UPCALL:
up_data = (struct gf_upcall *)data;
- BUMP_UPCALL (GF_UPCALL);
+ ios_bump_upcall (this, GF_UPCALL);
switch (up_data->event_type) {
case GF_UPCALL_RECALL_LEASE:
- BUMP_UPCALL (GF_UPCALL_LEASE_RECALL);
+ ios_bump_upcall (this, GF_UPCALL_LEASE_RECALL);
break;
case GF_UPCALL_CACHE_INVALIDATION:
up_ci = (struct gf_upcall_cache_invalidation *)up_data->data;
if (up_ci->flags & (UP_XATTR | UP_XATTR_RM))
- BUMP_UPCALL (GF_UPCALL_CI_XATTR);
+ ios_bump_upcall (this, GF_UPCALL_CI_XATTR);
if (up_ci->flags & IATT_UPDATE_FLAGS)
- BUMP_UPCALL (GF_UPCALL_CI_STAT);
+ ios_bump_upcall (this, GF_UPCALL_CI_STAT);
if (up_ci->flags & UP_RENAME_FLAGS)
- BUMP_UPCALL (GF_UPCALL_CI_RENAME);
+ ios_bump_upcall (this, GF_UPCALL_CI_RENAME);
if (up_ci->flags & UP_FORGET)
- BUMP_UPCALL (GF_UPCALL_CI_FORGET);
+ ios_bump_upcall (this, GF_UPCALL_CI_FORGET);
if (up_ci->flags & UP_NLINK)
- BUMP_UPCALL (GF_UPCALL_CI_NLINK);
+ ios_bump_upcall (this, GF_UPCALL_CI_NLINK);
break;
default:
gf_msg_debug (this->name, 0, "Unknown upcall event "
--
1.8.3.1