static
void aio_sync_all(struct aio_output *output, struct list_head *tmp_list)
{
unsigned long long latency;
int err;
output->fdsync_active = true;
atomic_inc(&output->total_fdsync_count);
latency = TIME_STATS(
&timings[2],
err = aio_sync(output->mf->mf_filp)
);
threshold_check(&aio_sync_threshold, latency);
output->fdsync_active = false;
wake_up_interruptible_all(&output->fdsync_event);
if (err < 0) {
MARS_ERR("FDSYNC error %d\n", err);
}
/* Signal completion for the whole list.
* No locking needed, it's on the stack.
*/
_complete_all(tmp_list, output, err);
}
static int aio_submit(struct aio_output *output, struct aio_mref_aspect *mref_a, bool use_fdsync)
{
struct mref_object *mref = mref_a->object;
mm_segment_t oldfs;
int res;
struct iocb iocb = {
.aio_data = (__u64)mref_a,
.aio_lio_opcode = use_fdsync ? IOCB_CMD_FDSYNC : (mref->ref_rw != 0 ? IOCB_CMD_PWRITE : IOCB_CMD_PREAD),
.aio_fildes = output->fd,
.aio_buf = (unsigned long)mref->ref_data,
.aio_nbytes = mref->ref_len,
.aio_offset = mref->ref_pos,
// .aio_reqprio = something(mref->ref_prio) field exists, but not yet implemented in kernelspace :(
};
struct iocb *iocbp = &iocb;
unsigned long long latency;
mars_trace(mref, "aio_submit");
if (unlikely(output->fd < 0)) {
MARS_ERR("bad fd = %d\n", output->fd);
res = -EBADF;
goto done;
}
oldfs = get_fs();
set_fs(get_ds());
latency = TIME_STATS(&timings[mref->ref_rw & 1], res = sys_io_submit(output->ctxp, 1, &iocbp));
set_fs(oldfs);
threshold_check(&aio_submit_threshold, latency);
atomic_inc(&output->total_submit_count);
if (likely(res >= 0)) {
atomic_inc(&output->submit_count);
} else if (likely(res == -EAGAIN)) {
atomic_inc(&output->total_again_count);
} else {
MARS_ERR("error = %d\n", res);
}
done:
return res;
}
static int aio_submit_dummy(struct aio_output *output)
{
mm_segment_t oldfs;
int res;
int dummy;
struct iocb iocb = {
.aio_buf = (__u64)&dummy,
};
struct iocb *iocbp = &iocb;
oldfs = get_fs();
set_fs(get_ds());
res = sys_io_submit(output->ctxp, 1, &iocbp);
set_fs(oldfs);
if (likely(res >= 0)) {
atomic_inc(&output->submit_count);
}
return res;
}
static
int aio_start_thread(
struct aio_output *output,
struct aio_threadinfo *tinfo,
int(*fn)(void*),
char class)
{
int j;
for (j = 0; j < MARS_PRIO_NR; j++) {
INIT_LIST_HEAD(&tinfo->mref_list[j]);
}
tinfo->output = output;
spin_lock_init(&tinfo->lock);
init_waitqueue_head(&tinfo->event);
init_waitqueue_head(&tinfo->terminate_event);
tinfo->terminated = false;
tinfo->thread = brick_thread_create(fn, tinfo, "mars_aio_%c%d", class, output->index);
if (unlikely(!tinfo->thread)) {
MARS_ERR("cannot create thread\n");
return -ENOENT;
}
return 0;
}
static
void aio_stop_thread(struct aio_output *output, int i, bool do_submit_dummy)
{
struct aio_threadinfo *tinfo = &output->tinfo[i];
if (tinfo->thread) {
MARS_DBG("stopping thread %d ...\n", i);
brick_thread_stop_nowait(tinfo->thread);
// workaround for waking up the receiver thread. TODO: check whether signal handlong could do better.
if (do_submit_dummy) {
MARS_DBG("submitting dummy for wakeup %d...\n", i);
use_fake_mm();
aio_submit_dummy(output);
if (likely(current->mm)) {
unuse_fake_mm();
}
}
// wait for termination
MARS_DBG("waiting for thread %d ...\n", i);
wait_event_interruptible_timeout(
tinfo->terminate_event,
tinfo->terminated,
(60 - i * 2) * HZ);
if (likely(tinfo->terminated)) {
brick_thread_stop(tinfo->thread);
} else {
MARS_ERR("thread %d did not terminate - leaving a zombie\n", i);
}
}
}
static
int aio_sync(struct file *file)
{
int err;
switch (aio_sync_mode) {
case 1:
#if defined(S_BIAS) || (defined(RHEL_MAJOR) && (RHEL_MAJOR < 7))
err = vfs_fsync_range(file, file->f_path.dentry, 0, LLONG_MAX, 1);
#else
err = vfs_fsync_range(file, 0, LLONG_MAX, 1);
#endif
break;
case 2:
#if defined(S_BIAS) || (defined(RHEL_MAJOR) && (RHEL_MAJOR < 7))
err = vfs_fsync_range(file, file->f_path.dentry, 0, LLONG_MAX, 0);
#else
err = vfs_fsync_range(file, 0, LLONG_MAX, 0);
#endif
break;
default:
err = filemap_write_and_wait_range(file->f_mapping, 0, LLONG_MAX);
}
return err;
}
int main(int argc, char *argv[])
{
int retc = 0;
int ret;
char *hostfile = NULL;
char *cachefile = NULL;
char *xml = NULL;
char *xmlfile = NULL;
int cachefd = -1;
char value[64];
char units[64];
int retry_count = 0, ret2;
if (get_config(argc, argv) < 0) {
retc = 2;
goto cleanup;
}
if (config.heartbeat > 0) {
debug("Checking heartbeat for %s with threshold %d\n",
config.host, config.heartbeat);
} else {
debug("Checking %s for %s metric\n",
config.host, config.metric);
}
hostfile = get_full_cache_path(config.cachepath, config.host);
cachefile = get_full_cache_path(config.cachepath, config.cachename);
retry:
debug("Checking cache at %s\n", cachefile);
ret = check_cache_age(cachefile);
if (ret < 0) {
printf("ERROR: Unable to check cache age.\n");
retc = 2;
goto cleanup;
}
if (ret < config.max_age) {
debug("Cache age is %d\n", ret);
} else {
debug("Cache age greater than configured max (%d >= %d)\n", ret, config.max_age);
debug("Connecting to %s on port %d\n", config.gmetad_host, config.gmetad_port);
ret = fetch_xml(config.gmetad_host, config.gmetad_port, &xml);
if (ret < 0) {
printf("ERROR: Unable to get XML data: %d.\n", ret);
retc = 2;
goto cleanup;
}
debug("Read %d bytes from %s\n", ret, config.gmetad_host);
if (config.dump) {
xmlfile = calloc((strlen(config.cachepath) + 9), sizeof(char));
sprintf(xmlfile, "%s/dump.xml", config.cachepath);
debug("Dumping XML to %s\n", xmlfile);
if (write_xml(xml, ret, xmlfile) < 0) {
printf("ERROR: Unable to dump XML.\n");
retc = 2;
goto cleanup;
}
}
ret2 = get_cache_lock(cachefile, &cachefd);
if (ret2 < 0) {
if (retry_count == MAX_RETRY) {
printf("ERROR: Unable to get cache lock after retrying %d times. Stale lock?", retry_count);
retc = 2;
goto cleanup;
} else {
backoff(retry_count / 2.0);
}
retry_count++;
goto retry;
}
debug("Parsing XML into %s\n", config.cachepath);
ret = parse_xml_to_cache(xml, ret, config.cachepath, cachefile);
if (ret < 0) {
printf("ERROR: Unable to parse XML.\n");
retc = 2;
goto cleanup;
}
touch_cache_lock(cachefile);
release_cache_lock(cachefile, &cachefd);
}
if (config.heartbeat > 0) {
strcpy(config.metric, "#REPORTED");
}
if (locate_hostfile(hostfile) < 0) {
printf("CRITICAL - Unable to locate cache file for %s\n", config.host);
retc = 2;
goto cleanup;
}
debug("Fetching %s metric from cache at %s\n", config.metric, hostfile);
ret = fetch_value_from_cache(hostfile, config.metric, value, units);
if (ret < 0) {
printf("CRITICAL - Unable to read cache at %s\n", hostfile);
retc = 2;
goto cleanup;
} else if (ret == 0) {
printf("CRITICAL - Metric %s not found\n", config.metric);
retc = 2;
goto cleanup;
}
debug("Checking...\n");
if (config.heartbeat > 0) {
int diff = time(NULL) - strtol(value, NULL, 10);
if (diff > config.heartbeat) {
printf("CRITICAL - %d over threshold %d\n", diff, config.heartbeat);
retc = 2;
goto cleanup;
} else {
printf("OK - %d\n", diff);
goto cleanup;
}
}
if (threshold_check(config.critical, value)) {
printf("CRITICAL - %s %s\n", value, units);
retc = 2;
} else {
if (threshold_check(config.warning, value)) {
printf("WARNING - %s %s\n", value, units);
retc = 1;
} else {
printf("OK - %s %s\n", value, units);
}
}
cleanup:
if (cachefd >= 0) {
release_cache_lock(cachefile, &cachefd);
}
if (xml != NULL)
free(xml);
if (xmlfile != NULL)
free(xmlfile);
if (hostfile != NULL)
free(hostfile);
if (cachefile != NULL)
free(cachefile);
exit(retc);
}