mars/kernel/lib_log.c

546 lines
13 KiB
C
Raw Normal View History

2014-11-21 10:51:34 +00:00
/*
* MARS Long Distance Replication Software
*
* This file is part of MARS project: http://schoebel.github.io/mars/
*
* Copyright (C) 2010-2014 Thomas Schoebel-Theuer
* Copyright (C) 2011-2014 1&1 Internet AG
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
2011-03-10 11:40:06 +00:00
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/bio.h>
2012-02-02 15:36:57 +00:00
//#define BRICK_DEBUGGING
//#define MARS_DEBUGGING
//#define IO_DEBUGGING
2012-02-06 10:40:42 +00:00
#include "lib_log.h"
2019-02-11 21:39:47 +00:00
#include "brick_wait.h"
2012-02-02 15:36:57 +00:00
atomic_t global_mref_flying = ATOMIC_INIT(0);
EXPORT_SYMBOL_GPL(global_mref_flying);
void exit_logst(struct log_status *logst)
{
int count = 0;
log_flush(logst);
while (atomic_read(&logst->mref_flying) > 0) {
if (!count++)
MARS_DBG("waiting for IO terminating...");
brick_msleep(500);
}
2012-02-02 15:36:57 +00:00
if (logst->read_mref) {
MARS_DBG("putting read_mref\n");
GENERIC_INPUT_CALL(logst->input, mref_put, logst->read_mref);
logst->read_mref = NULL;
}
if (logst->log_mref) {
MARS_DBG("putting log_mref\n");
GENERIC_INPUT_CALL(logst->input, mref_put, logst->log_mref);
logst->log_mref = NULL;
}
}
EXPORT_SYMBOL_GPL(exit_logst);
void init_logst(struct log_status *logst, struct mars_input *input, loff_t start_pos, loff_t end_pos)
2011-03-10 11:40:06 +00:00
{
exit_logst(logst);
2011-07-28 11:41:06 +00:00
memset(logst, 0, sizeof(struct log_status));
2011-03-10 11:40:06 +00:00
logst->input = input;
logst->brick = input->brick;
logst->start_pos = start_pos;
2011-03-18 13:15:40 +00:00
logst->log_pos = start_pos;
logst->end_pos = end_pos;
2011-03-22 14:36:26 +00:00
init_waitqueue_head(&logst->event);
2011-03-10 11:40:06 +00:00
}
EXPORT_SYMBOL_GPL(init_logst);
2011-04-08 09:52:46 +00:00
#define MARS_LOG_CB_MAX 32
2011-03-11 13:57:54 +00:00
struct log_cb_info {
2011-03-27 15:18:38 +00:00
struct mref_object *mref;
struct log_status *logst;
2011-05-26 14:32:32 +00:00
struct semaphore mutex;
atomic_t refcount;
int nr_cb;
2011-03-11 13:57:54 +00:00
void (*endios[MARS_LOG_CB_MAX])(void *private, int error);
void *privates[MARS_LOG_CB_MAX];
};
2011-05-26 14:32:32 +00:00
static
void put_log_cb_info(struct log_cb_info *cb_info)
{
if (atomic_dec_and_test(&cb_info->refcount)) {
2011-08-12 11:09:48 +00:00
brick_mem_free(cb_info);
2011-05-26 14:32:32 +00:00
}
}
2012-02-06 10:40:42 +00:00
static
2013-01-03 09:12:20 +00:00
void _do_callbacks(struct log_cb_info *cb_info, int error)
2012-02-06 10:40:42 +00:00
{
int i;
down(&cb_info->mutex);
for (i = 0; i < cb_info->nr_cb; i++) {
void (*end_fn)(void *private, int error);
end_fn = cb_info->endios[i];
cb_info->endios[i] = NULL;
if (end_fn) {
end_fn(cb_info->privates[i], error);
}
}
up(&cb_info->mutex);
}
2011-03-11 13:57:54 +00:00
static
2011-04-08 09:52:46 +00:00
void log_write_endio(struct generic_callback *cb)
2011-03-10 11:40:06 +00:00
{
2011-03-11 13:57:54 +00:00
struct log_cb_info *cb_info = cb->cb_private;
struct log_status *logst;
2011-03-18 13:15:40 +00:00
LAST_CALLBACK(cb);
2011-03-18 13:15:40 +00:00
CHECK_PTR(cb_info, err);
2011-03-27 15:18:38 +00:00
if (cb_info->mref) {
mars_trace(cb_info->mref, "log_endio");
mars_log_trace(cb_info->mref);
}
2011-11-14 14:21:15 +00:00
logst = cb_info->logst;
CHECK_PTR(logst, done);
2011-05-26 14:32:32 +00:00
MARS_IO("nr_cb = %d\n", cb_info->nr_cb);
2011-04-08 09:52:46 +00:00
2013-01-03 09:12:20 +00:00
_do_callbacks(cb_info, cb->cb_error);
2011-11-14 14:21:15 +00:00
done:
2011-05-26 14:32:32 +00:00
put_log_cb_info(cb_info);
2012-12-11 12:51:07 +00:00
atomic_dec(&logst->mref_flying);
atomic_dec(&global_mref_flying);
2019-02-11 21:39:47 +00:00
if (logst->signal_event && logst->signal_flag)
brick_wake(logst->signal_event, *(logst->signal_flag));
2012-12-11 15:33:26 +00:00
2011-03-18 13:15:40 +00:00
return;
err:
MARS_FAT("internal pointer corruption\n");
2011-03-10 11:40:06 +00:00
}
2011-03-11 13:57:54 +00:00
2011-03-22 14:36:26 +00:00
void log_flush(struct log_status *logst)
2011-03-11 13:57:54 +00:00
{
struct mref_object *mref = logst->log_mref;
2011-05-26 14:32:32 +00:00
struct log_cb_info *cb_info;
2012-12-31 17:45:16 +00:00
int align_size;
2011-03-11 13:57:54 +00:00
int gap;
2011-05-13 11:19:28 +00:00
if (!mref || !logst->count)
2011-03-11 13:57:54 +00:00
return;
gap = 0;
2012-12-31 17:45:16 +00:00
align_size = (logst->align_size / PAGE_SIZE) * PAGE_SIZE;
if (align_size > 0) {
2011-03-22 14:36:26 +00:00
// round up to next alignment border
2012-12-31 17:45:16 +00:00
int align_offset = logst->offset & (align_size-1);
2011-03-18 13:15:40 +00:00
if (align_offset > 0) {
2011-03-29 14:40:40 +00:00
int restlen = mref->ref_len - logst->offset;
2012-12-31 17:45:16 +00:00
gap = align_size - align_offset;
if (unlikely(gap > restlen)) {
2011-03-29 14:40:40 +00:00
gap = restlen;
2011-03-22 14:36:26 +00:00
}
2011-03-18 13:15:40 +00:00
}
2011-03-11 13:57:54 +00:00
}
2011-03-22 14:36:26 +00:00
if (gap > 0) {
// don't leak information from kernelspace
memset(mref->ref_data + logst->offset, 0, gap);
2011-03-11 13:57:54 +00:00
logst->offset += gap;
}
2011-03-22 14:36:26 +00:00
mref->ref_len = logst->offset;
memcpy(&logst->log_pos_stamp, &logst->tmp_pos_stamp, sizeof(logst->log_pos_stamp));
2011-03-11 13:57:54 +00:00
2011-05-26 14:32:32 +00:00
cb_info = logst->private;
2011-03-11 13:57:54 +00:00
logst->private = NULL;
SETUP_CALLBACK(mref, log_write_endio, cb_info);
cb_info->logst = logst;
2011-03-11 13:57:54 +00:00
mref->ref_rw = 1;
2011-03-27 15:18:38 +00:00
mars_trace(mref, "log_flush");
atomic_inc(&logst->mref_flying);
atomic_inc(&global_mref_flying);
2011-03-11 13:57:54 +00:00
GENERIC_INPUT_CALL(logst->input, mref_io, mref);
GENERIC_INPUT_CALL(logst->input, mref_put, mref);
logst->log_pos += logst->offset;
2011-03-11 13:57:54 +00:00
logst->offset = 0;
2011-05-13 11:19:28 +00:00
logst->count = 0;
2011-03-11 13:57:54 +00:00
logst->log_mref = NULL;
2011-05-26 14:32:32 +00:00
put_log_cb_info(cb_info);
2011-03-11 13:57:54 +00:00
}
EXPORT_SYMBOL_GPL(log_flush);
2011-03-10 11:40:06 +00:00
void *log_reserve(struct log_status *logst, struct log_header *lh)
{
2011-03-11 13:57:54 +00:00
struct log_cb_info *cb_info = logst->private;
2011-03-10 11:40:06 +00:00
struct mref_object *mref;
void *data;
2011-03-27 15:18:38 +00:00
short total_len = lh->l_len + OVERHEAD;
2011-03-10 11:40:06 +00:00
int offset;
2011-03-11 13:57:54 +00:00
int status;
2011-03-10 11:40:06 +00:00
if (unlikely(lh->l_len <= 0 || lh->l_len > logst->max_size)) {
MARS_ERR("trying to write %d bytes, max allowed = %d\n", lh->l_len, logst->max_size);
2012-12-10 15:42:48 +00:00
goto err;
}
2012-02-06 12:00:26 +00:00
MARS_IO("reserving %d bytes at %lld\n", lh->l_len, logst->log_pos);
2011-03-10 11:40:06 +00:00
2011-03-29 14:40:40 +00:00
mref = logst->log_mref;
if ((mref && total_len > mref->ref_len - logst->offset)
2011-05-26 14:32:32 +00:00
|| !cb_info || cb_info->nr_cb >= MARS_LOG_CB_MAX) {
2011-03-22 14:36:26 +00:00
log_flush(logst);
2011-03-10 11:40:06 +00:00
}
2011-03-11 13:57:54 +00:00
mref = logst->log_mref;
if (!mref) {
if (unlikely(logst->private)) {
MARS_ERR("oops\n");
2011-08-12 11:09:48 +00:00
brick_mem_free(logst->private);
2011-03-11 13:57:54 +00:00
}
2011-08-12 11:09:48 +00:00
logst->private = brick_zmem_alloc(sizeof(struct log_cb_info));
2011-03-11 13:57:54 +00:00
if (unlikely(!logst->private)) {
MARS_ERR("no memory\n");
goto err;
}
2011-03-27 15:18:38 +00:00
cb_info = logst->private;
2011-05-26 14:32:32 +00:00
sema_init(&cb_info->mutex, 1);
atomic_set(&cb_info->refcount, 2);
2011-03-10 11:40:06 +00:00
2012-02-02 15:25:43 +00:00
mref = mars_alloc_mref(logst->brick);
2011-03-11 13:57:54 +00:00
if (unlikely(!mref)) {
MARS_ERR("no mref\n");
goto err;
}
2011-03-27 15:18:38 +00:00
cb_info->mref = mref;
2011-03-11 13:57:54 +00:00
mref->ref_pos = logst->log_pos;
2012-12-31 17:45:16 +00:00
mref->ref_len = logst->chunk_size ? logst->chunk_size : total_len;
2011-03-11 13:57:54 +00:00
mref->ref_may_write = WRITE;
2011-03-29 14:40:40 +00:00
mref->ref_prio = logst->io_prio;
2011-03-10 11:40:06 +00:00
2011-06-30 13:15:52 +00:00
for (;;) {
status = GENERIC_INPUT_CALL(logst->input, mref_get, mref);
if (likely(status >= 0)) {
break;
}
if (status != -ENOMEM && status != -EAGAIN) {
MARS_ERR("mref_get() failed, status = %d\n", status);
goto err_free;
}
brick_msleep(100);
2011-03-11 13:57:54 +00:00
}
2011-03-27 15:18:38 +00:00
mars_trace(mref, "log_start");
2011-03-11 13:57:54 +00:00
if (unlikely(mref->ref_len < total_len)) {
MARS_ERR("ref_len = %d total_len = %d\n", mref->ref_len, total_len);
goto put;
}
logst->offset = 0;
logst->log_mref = mref;
2011-03-10 11:40:06 +00:00
}
2011-03-11 13:57:54 +00:00
offset = logst->offset;
2011-03-10 11:40:06 +00:00
data = mref->ref_data;
DATA_PUT(data, offset, START_MAGIC);
DATA_PUT(data, offset, (char)FORMAT_VERSION);
logst->validflag_offset = offset;
DATA_PUT(data, offset, (char)0); // valid_flag
DATA_PUT(data, offset, total_len); // start of next header
DATA_PUT(data, offset, lh->l_stamp.tv_sec);
DATA_PUT(data, offset, lh->l_stamp.tv_nsec);
DATA_PUT(data, offset, lh->l_pos);
logst->reallen_offset = offset;
DATA_PUT(data, offset, lh->l_len);
DATA_PUT(data, offset, (short)0); // spare
DATA_PUT(data, offset, (int)0); // spare
2011-03-10 11:40:06 +00:00
DATA_PUT(data, offset, lh->l_code);
DATA_PUT(data, offset, (short)0); // spare
2011-03-10 11:40:06 +00:00
// remember the last timestamp
memcpy(&logst->tmp_pos_stamp, &lh->l_stamp, sizeof(logst->tmp_pos_stamp));
2011-03-10 11:40:06 +00:00
logst->payload_offset = offset;
logst->payload_len = lh->l_len;
return data + offset;
put:
GENERIC_INPUT_CALL(logst->input, mref_put, mref);
2011-03-29 14:40:40 +00:00
logst->log_mref = NULL;
2011-03-10 11:40:06 +00:00
return NULL;
err_free:
mars_free_mref(mref);
2011-03-24 16:05:46 +00:00
if (logst->private) {
2011-04-08 09:52:46 +00:00
// TODO: if callbacks are already registered, call them here with some error code
2011-08-12 11:09:48 +00:00
brick_mem_free(logst->private);
2011-03-24 16:05:46 +00:00
logst->private = NULL;
}
2011-03-10 11:40:06 +00:00
err:
return NULL;
}
EXPORT_SYMBOL_GPL(log_reserve);
2013-01-03 09:12:20 +00:00
bool log_finalize(struct log_status *logst, int len, void (*endio)(void *private, int error), void *private)
2011-03-10 11:40:06 +00:00
{
struct mref_object *mref = logst->log_mref;
2011-03-11 13:57:54 +00:00
struct log_cb_info *cb_info = logst->private;
2011-03-10 11:40:06 +00:00
struct timespec now;
void *data;
int offset;
2011-03-29 14:40:40 +00:00
int restlen;
2011-05-26 14:32:32 +00:00
int nr_cb;
int crc;
2011-03-10 11:40:06 +00:00
bool ok = false;
CHECK_PTR(mref, err);
2011-03-29 14:40:40 +00:00
if (unlikely(len > logst->payload_len)) {
MARS_ERR("trying to write more than reserved (%d > %d)\n", len, logst->payload_len);
goto err;
}
restlen = mref->ref_len - logst->offset;
if (unlikely(len + END_OVERHEAD > restlen)) {
MARS_ERR("trying to write more than available (%d > %d)\n", len, (int)(restlen - END_OVERHEAD));
2011-03-11 13:57:54 +00:00
goto err;
}
2011-05-26 14:32:32 +00:00
if (unlikely(!cb_info || cb_info->nr_cb >= MARS_LOG_CB_MAX)) {
2011-03-11 13:57:54 +00:00
MARS_ERR("too many endio() calls\n");
goto err;
2011-03-10 11:40:06 +00:00
}
data = mref->ref_data;
crc = 0;
if (logst->do_crc) {
unsigned char checksum[mars_digest_size];
mars_digest(checksum, data + logst->payload_offset, len);
crc = *(int*)checksum;
}
2011-03-10 11:40:06 +00:00
/* Correct the length in the header.
*/
offset = logst->reallen_offset;
DATA_PUT(data, offset, (short)len);
2011-03-10 11:40:06 +00:00
/* Write the trailer.
*/
offset = logst->payload_offset + len;
DATA_PUT(data, offset, END_MAGIC);
DATA_PUT(data, offset, crc);
2011-03-10 11:40:06 +00:00
DATA_PUT(data, offset, (char)1); // valid_flag copy
DATA_PUT(data, offset, (char)0); // spare
DATA_PUT(data, offset, (short)0); // spare
2013-01-04 21:11:22 +00:00
DATA_PUT(data, offset, logst->seq_nr + 1);
2017-04-15 06:21:21 +00:00
get_lamport(NULL, &now); // when the log entry was ready.
2011-03-10 11:40:06 +00:00
DATA_PUT(data, offset, now.tv_sec);
DATA_PUT(data, offset, now.tv_nsec);
2011-03-29 14:40:40 +00:00
if (unlikely(offset > mref->ref_len)) {
2013-01-04 21:11:22 +00:00
MARS_FAT("length calculation was wrong: %d > %d\n", offset, mref->ref_len);
2011-03-29 14:40:40 +00:00
goto err;
}
2011-03-11 13:57:54 +00:00
logst->offset = offset;
2011-03-10 11:40:06 +00:00
/* This must come last. In case of incomplete
2011-03-27 15:18:38 +00:00
* or even overlapping disk transfers, this indicates
2011-03-10 11:40:06 +00:00
* the completeness / integrity of the payload at
* the time of starting the transfer.
*/
offset = logst->validflag_offset;
DATA_PUT(data, offset, (char)1);
2011-05-26 14:32:32 +00:00
nr_cb = cb_info->nr_cb++;
cb_info->endios[nr_cb] = endio;
cb_info->privates[nr_cb] = private;
2011-03-10 11:40:06 +00:00
2013-01-04 21:11:22 +00:00
// report success
logst->seq_nr++;
2011-05-13 11:19:28 +00:00
logst->count++;
2011-03-10 11:40:06 +00:00
ok = true;
2011-03-11 13:57:54 +00:00
2011-03-10 11:40:06 +00:00
err:
return ok;
}
EXPORT_SYMBOL_GPL(log_finalize);
2011-03-22 14:36:26 +00:00
static
2011-04-08 09:52:46 +00:00
void log_read_endio(struct generic_callback *cb)
2011-03-18 13:15:40 +00:00
{
2011-03-22 14:36:26 +00:00
struct log_status *logst = cb->cb_private;
LAST_CALLBACK(cb);
2011-03-22 14:36:26 +00:00
CHECK_PTR(logst, err);
logst->error_code = cb->cb_error;
logst->got = true;
wake_up_interruptible(&logst->event);
return;
err:
MARS_FAT("internal pointer corruption\n");
2011-03-18 13:15:40 +00:00
}
2011-03-22 14:36:26 +00:00
int log_read(struct log_status *logst, bool sloppy, struct log_header *lh, void **payload, int *payload_len)
2011-03-18 13:15:40 +00:00
{
2011-04-08 09:52:46 +00:00
struct mref_object *mref;
int old_offset;
2011-04-08 09:52:46 +00:00
int status;
restart:
status = 0;
mref = logst->read_mref;
if (!mref || logst->do_free) {
loff_t this_len;
2011-04-08 09:52:46 +00:00
if (mref) {
GENERIC_INPUT_CALL(logst->input, mref_put, mref);
logst->read_mref = NULL;
logst->log_pos += logst->offset;
2011-04-08 09:52:46 +00:00
logst->offset = 0;
}
this_len = logst->end_pos - logst->log_pos;
if (this_len > logst->chunk_size) {
this_len = logst->chunk_size;
} else if (unlikely(this_len <= 0)) {
MARS_ERR("tried bad IO len %lld, start_pos = %lld log_pos = %lld end_pos = %lld\n", this_len, logst->start_pos, logst->log_pos, logst->end_pos);
status = -EOVERFLOW;
goto done;
}
2012-02-02 15:25:43 +00:00
mref = mars_alloc_mref(logst->brick);
2011-03-22 14:36:26 +00:00
if (unlikely(!mref)) {
MARS_ERR("no mref\n");
2011-03-27 15:18:38 +00:00
goto done;
2011-03-22 14:36:26 +00:00
}
mref->ref_pos = logst->log_pos;
mref->ref_len = this_len;
2011-05-19 11:36:00 +00:00
mref->ref_prio = logst->io_prio;
2011-03-22 14:36:26 +00:00
status = GENERIC_INPUT_CALL(logst->input, mref_get, mref);
if (unlikely(status < 0)) {
2011-04-08 09:52:46 +00:00
if (status != -ENODATA) {
MARS_ERR("mref_get() failed, status = %d\n", status);
}
2011-03-27 15:18:38 +00:00
goto done_free;
2011-03-22 14:36:26 +00:00
}
if (unlikely(mref->ref_len <= OVERHEAD)) { // EOF
status = 0;
goto done_put;
}
2011-03-22 14:36:26 +00:00
SETUP_CALLBACK(mref, log_read_endio, logst);
2011-04-08 09:52:46 +00:00
mref->ref_rw = READ;
2011-03-22 14:36:26 +00:00
logst->offset = 0;
logst->got = false;
2011-04-08 09:52:46 +00:00
logst->do_free = false;
2011-03-22 14:36:26 +00:00
GENERIC_INPUT_CALL(logst->input, mref_io, mref);
wait_event_interruptible_timeout(logst->event, logst->got, 60 * HZ);
status = -ETIME;
2011-03-22 14:36:26 +00:00
if (!logst->got)
2011-04-08 09:52:46 +00:00
goto done_put;
2011-03-22 14:36:26 +00:00
status = logst->error_code;
if (status < 0)
2011-04-08 09:52:46 +00:00
goto done_put;
2011-03-22 14:36:26 +00:00
logst->read_mref = mref;
}
status = log_scan(mref->ref_data + logst->offset,
mref->ref_len - logst->offset,
mref->ref_pos,
logst->offset,
sloppy,
lh,
payload,
payload_len,
&logst->seq_nr);
2011-03-29 14:40:40 +00:00
if (unlikely(status == 0)) {
MARS_ERR("bad logfile scan\n");
status = -EINVAL;
}
if (unlikely(status < 0)) {
2011-04-08 09:52:46 +00:00
goto done_put;
2011-03-22 14:36:26 +00:00
}
// memoize success
2011-03-27 15:18:38 +00:00
logst->offset += status;
if (logst->offset + (logst->max_size + OVERHEAD) * 2 >= mref->ref_len) {
2011-04-08 09:52:46 +00:00
logst->do_free = true;
2011-03-27 15:18:38 +00:00
}
2011-03-22 14:36:26 +00:00
2011-04-08 09:52:46 +00:00
done:
if (status == -ENODATA) {
status = 0; // indicates EOF
}
return status;
done_put:
old_offset = logst->offset;
2011-03-22 14:36:26 +00:00
if (mref) {
GENERIC_INPUT_CALL(logst->input, mref_put, mref);
2011-03-27 15:18:38 +00:00
logst->read_mref = NULL;
logst->log_pos += logst->offset;
2011-04-08 09:52:46 +00:00
logst->offset = 0;
2011-03-22 14:36:26 +00:00
}
if (status == -EAGAIN && old_offset > 0) {
2011-04-08 09:52:46 +00:00
goto restart;
}
goto done;
done_free:
if (mref) {
mars_free_mref(mref);
}
logst->read_mref = NULL;
goto done;
2011-03-18 13:15:40 +00:00
}
EXPORT_SYMBOL_GPL(log_read);
2011-03-10 11:40:06 +00:00
////////////////// module init stuff /////////////////////////
2011-08-25 10:16:32 +00:00
int __init init_log_format(void)
2011-03-10 11:40:06 +00:00
{
MARS_INF("init_log_format()\n");
return 0;
}
2014-04-23 11:16:26 +00:00
void exit_log_format(void)
2011-03-10 11:40:06 +00:00
{
MARS_INF("exit_log_format()\n");
}