/* * 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. */ #include #include #include #include //#define BRICK_DEBUGGING //#define MARS_DEBUGGING //#define IO_DEBUGGING #include "lib_log.h" #include "brick_wait.h" __u32 enabled_log_compressions = 0; __u32 used_log_compression = 0; 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); } if (logst->read_mref) { MARS_DBG("putting read_mref\n"); GENERIC_INPUT_CALL_VOID(logst->input, mref_put, logst->read_mref); logst->read_mref = NULL; } if (logst->log_mref) { MARS_DBG("putting log_mref\n"); GENERIC_INPUT_CALL_VOID(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) { exit_logst(logst); memset(logst, 0, sizeof(struct log_status)); logst->input = input; logst->brick = input->brick; logst->start_pos = start_pos; logst->log_pos = start_pos; logst->end_pos = end_pos; init_waitqueue_head(&logst->event); } EXPORT_SYMBOL_GPL(init_logst); #define MARS_LOG_CB_MAX 32 struct log_cb_info { struct mref_object *mref; struct log_status *logst; struct semaphore mutex; atomic_t refcount; int nr_cb; void (*endios[MARS_LOG_CB_MAX])(void *private, int error); void *privates[MARS_LOG_CB_MAX]; }; static void put_log_cb_info(struct log_cb_info *cb_info) { if (atomic_dec_and_test(&cb_info->refcount)) { brick_mem_free(cb_info); } } static void _do_callbacks(struct log_cb_info *cb_info, int error) { 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); } static void log_write_endio(struct generic_callback *cb) { struct log_cb_info *cb_info = cb->cb_private; struct log_status *logst; LAST_CALLBACK(cb); CHECK_PTR(cb_info, err); if (cb_info->mref) { mars_trace(cb_info->mref, "log_endio"); mars_log_trace(cb_info->mref); } logst = cb_info->logst; CHECK_PTR(logst, done); MARS_IO("nr_cb = %d\n", cb_info->nr_cb); _do_callbacks(cb_info, cb->cb_error); done: put_log_cb_info(cb_info); atomic_dec(&logst->mref_flying); atomic_dec(&global_mref_flying); if (logst->signal_event && logst->signal_flag) brick_wake(logst->signal_event, *(logst->signal_flag)); return; err: MARS_FAT("internal pointer corruption\n"); } static int log_compress(struct log_status *logst, int len, int *padded_len, __u32 *result_flags) { struct mref_object *mref = logst->log_mref; void *inplace_buf; void *compr_buf; int compr_len; int res; if (unlikely(!mref || !mref->ref_data || len <= 0)) return 0; compr_len = len + compress_overhead; compr_buf = brick_mem_alloc(compr_len); inplace_buf = mref->ref_data + logst->payload_offset; res = mars_compress(inplace_buf, len, compr_buf, compr_len, enabled_log_compressions, result_flags); /* pad the resulting length */ if (res > 0) { int pad_len = ((res + (_LOG_PAD - 1)) / _LOG_PAD) * _LOG_PAD; /* Did compression pay off? */ if (pad_len < len) { *padded_len = pad_len; used_log_compression = *result_flags; memcpy(inplace_buf, compr_buf, res); } else { *padded_len = len; res = 0; } } brick_mem_free(compr_buf); return res; } void log_flush(struct log_status *logst) { struct mref_object *mref = logst->log_mref; struct log_cb_info *cb_info; int align_size; int gap; if (!mref || !logst->count) return; gap = 0; align_size = (logst->align_size / PAGE_SIZE) * PAGE_SIZE; if (align_size > 0) { // round up to next alignment border int align_offset = logst->offset & (align_size-1); if (align_offset > 0) { int restlen = mref->ref_len - logst->offset; gap = align_size - align_offset; if (unlikely(gap > restlen)) { gap = restlen; } } } if (gap > 0) { // don't leak information from kernelspace memset(mref->ref_data + logst->offset, 0, gap); logst->offset += gap; } mref->ref_len = logst->offset; memcpy(&logst->log_pos_stamp, &logst->tmp_pos_stamp, sizeof(logst->log_pos_stamp)); cb_info = logst->private; logst->private = NULL; SETUP_CALLBACK(mref, log_write_endio, cb_info); cb_info->logst = logst; mref->ref_flags |= MREF_WRITE | MREF_MAY_WRITE; mars_trace(mref, "log_flush"); atomic_inc(&logst->mref_flying); atomic_inc(&global_mref_flying); GENERIC_INPUT_CALL_VOID(logst->input, mref_io, mref); GENERIC_INPUT_CALL_VOID(logst->input, mref_put, mref); logst->log_pos += logst->offset; logst->offset = 0; logst->count = 0; logst->log_mref = NULL; put_log_cb_info(cb_info); } EXPORT_SYMBOL_GPL(log_flush); void *log_reserve(struct log_status *logst, struct log_header *lh) { struct log_cb_info *cb_info = logst->private; struct mref_object *mref; void *data; short total_len = lh->l_len + OVERHEAD; int offset; int status; 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); goto err; } MARS_IO("reserving %d bytes at %lld\n", lh->l_len, logst->log_pos); mref = logst->log_mref; if ((mref && total_len > mref->ref_len - logst->offset) || !cb_info || cb_info->nr_cb >= MARS_LOG_CB_MAX) { log_flush(logst); } mref = logst->log_mref; if (!mref) { if (unlikely(logst->private)) { MARS_ERR("oops\n"); brick_mem_free(logst->private); } logst->private = brick_zmem_alloc(sizeof(struct log_cb_info)); if (unlikely(!logst->private)) { MARS_ERR("no memory\n"); goto err; } cb_info = logst->private; sema_init(&cb_info->mutex, 1); atomic_set(&cb_info->refcount, 2); mref = mars_alloc_mref(logst->brick); if (unlikely(!mref)) { MARS_ERR("no mref\n"); goto err; } cb_info->mref = mref; mref->ref_pos = logst->log_pos; mref->ref_len = logst->chunk_size ? logst->chunk_size : total_len; mref->ref_flags = MREF_MAY_WRITE; mref->ref_prio = logst->io_prio; 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); } mars_trace(mref, "log_start"); 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; } offset = logst->offset; 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 logst->totallen_offset = offset; 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); logst->decompresslen_offset = offset; DATA_PUT(data, offset, (short)0); /* placeholder */ DATA_PUT(data, offset, (int)0); // spare DATA_PUT(data, offset, lh->l_code); DATA_PUT(data, offset, (short)0); // spare // remember the last timestamp memcpy(&logst->tmp_pos_stamp, &lh->l_stamp, sizeof(logst->tmp_pos_stamp)); logst->payload_offset = offset; logst->payload_len = lh->l_len; return data + offset; put: GENERIC_INPUT_CALL_VOID(logst->input, mref_put, mref); logst->log_mref = NULL; return NULL; err_free: mars_free_mref(mref); if (logst->private) { // TODO: if callbacks are already registered, call them here with some error code brick_mem_free(logst->private); } err: return NULL; } EXPORT_SYMBOL_GPL(log_reserve); /* Unfortunately, the old logfile format had only 32 bit * (4 byte) checksums. * By converting the unused l_written to a checksum, we now * can use 16 bytes. * TODO: new backwards-compatible logfile format with even bigger * checksums (32 bytes). */ static void fold_crc(void *src, void *dst) { int i; memset(dst, 0, LOG_CHKSUM_SIZE); for (i = 0; i < MARS_DIGEST_SIZE; i += LOG_CHKSUM_SIZE) { *(__u64*)dst ^= *(__u64*)(src + i); *(__u64*)(dst + sizeof(__u64)) ^= *(__u64*)(src + i + sizeof(__u64)); } } bool log_finalize(struct log_status *logst, int len, void (*endio)(void *private, int error), void *private) { struct mref_object *mref = logst->log_mref; struct log_cb_info *cb_info = logst->private; void *data; int offset; int restlen; int decompr_len; int padded_len; int nr_cb; unsigned char crc[LOG_CHKSUM_SIZE] = {}; __u32 old_crc = 0; __u32 check_flags; __u16 crc_flags; bool ok = false; CHECK_PTR(mref, err); 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)); goto err; } if (unlikely(!cb_info || cb_info->nr_cb >= MARS_LOG_CB_MAX)) { MARS_ERR("too many endio() calls\n"); goto err; } data = mref->ref_data; check_flags = 0; /* Run the CRC on the _original_ data, before compression */ { unsigned char checksum[MARS_DIGEST_SIZE]; check_flags |= mars_digest(usable_digest_mask & ~disabled_log_digests, &used_log_digest, checksum, data + logst->payload_offset, len); if (check_flags & MREF_CHKSUM_MD5_OLD) old_crc = *(__u32*)checksum; else fold_crc(checksum, crc); } /* * Important: when somebody else would be later unable to decompress, * it will then automatically result in a CRC mismatch. */ decompr_len = 0; padded_len = len; if (logst->do_compress) { __u32 new_check_flags = check_flags; int new_len = log_compress(logst, len, &padded_len, &new_check_flags); /* When compression did not pay off, treat as uncompressed */ if (new_len > 0) { check_flags = new_check_flags; /* exchange the lengths */ decompr_len = len; len = new_len; } } /* * We have only 16 flag bits in the traditional * logfile format, which is in production over * years. To remain compatible, we strip off * non-checksum related bits. */ crc_flags = check_flags >> _MREF_CHKSUM_MD5_OLD; /* Correct the length in the header. */ offset = logst->decompresslen_offset; DATA_PUT(data, offset, (short)decompr_len); offset = logst->reallen_offset; DATA_PUT(data, offset, (short)len); offset = logst->totallen_offset; DATA_PUT(data, offset, (short)(padded_len + OVERHEAD)); /* Write the trailer. */ offset = logst->payload_offset + padded_len; DATA_PUT(data, offset, END_MAGIC); DATA_PUT(data, offset, old_crc); DATA_PUT(data, offset, (char)1); // valid_flag copy DATA_PUT(data, offset, (char)0); // spare DATA_PUT(data, offset, crc_flags); DATA_PUT(data, offset, logst->seq_nr + 1); memcpy(data + offset, crc, LOG_CHKSUM_SIZE); offset += LOG_CHKSUM_SIZE; if (unlikely(offset > mref->ref_len)) { MARS_FAT("length calculation was wrong: %d > %d\n", offset, mref->ref_len); goto err; } logst->offset = offset; /* This must come last. In case of incomplete * or even overlapping disk transfers, this indicates * the completeness / integrity of the payload at * the time of starting the transfer. */ offset = logst->validflag_offset; barrier(); DATA_PUT(data, offset, (char)1); nr_cb = cb_info->nr_cb++; cb_info->endios[nr_cb] = endio; cb_info->privates[nr_cb] = private; // report success logst->seq_nr++; logst->count++; ok = true; err: return ok; } EXPORT_SYMBOL_GPL(log_finalize); static void log_read_endio(struct generic_callback *cb) { struct log_status *logst = cb->cb_private; LAST_CALLBACK(cb); CHECK_PTR(logst, err); logst->posix_error_code = cb->cb_error; logst->got = true; wake_up_interruptible(&logst->event); return; err: MARS_FAT("internal pointer corruption\n"); } int log_read(struct log_status *logst, bool sloppy, struct log_header *lh, void **payload, int *payload_len, void **dealloc) { struct mref_object *mref; int old_offset; int status; *dealloc = NULL; restart: status = 0; mref = logst->read_mref; if (!mref || logst->do_free) { loff_t this_len; if (mref) { GENERIC_INPUT_CALL_VOID(logst->input, mref_put, mref); logst->read_mref = NULL; logst->log_pos += logst->offset; 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; } mref = mars_alloc_mref(logst->brick); if (unlikely(!mref)) { MARS_ERR("no mref\n"); goto done; } mref->ref_pos = logst->log_pos; mref->ref_len = this_len; mref->ref_prio = logst->io_prio; status = GENERIC_INPUT_CALL(logst->input, mref_get, mref); if (unlikely(status < 0)) { if (status != -ENODATA) { MARS_ERR("mref_get() failed, status = %d\n", status); } goto done_free; } if (unlikely(mref->ref_len <= OVERHEAD)) { // EOF status = 0; goto done_put; } SETUP_CALLBACK(mref, log_read_endio, logst); logst->offset = 0; logst->got = false; logst->do_free = false; GENERIC_INPUT_CALL_VOID(logst->input, mref_io, mref); wait_event_interruptible_timeout(logst->event, logst->got, 60 * HZ); status = -ETIME; if (!logst->got) goto done_put; status = logst->posix_error_code; if (status < 0) goto done_put; if (mref->ref_len < this_len) { /* Short read. May happen when logfiles are * truncated underneath. */ logst->end_pos = logst->log_pos + mref->ref_len; } 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, dealloc, &logst->seq_nr, &logst->mars_error_code, &logst->byte_code); if (unlikely(status == 0)) { MARS_ERR("bad logfile scan\n"); status = -EINVAL; if (!logst->mars_error_code) logst->mars_error_code = -MARS_ERR_NOSCAN; goto done_put; } if (unlikely(status < 0)) { goto done_put; } // memoize success logst->offset += status; if (logst->offset + (logst->max_size + OVERHEAD) * 2 >= mref->ref_len) { logst->do_free = true; } done: if (status == -ENODATA) { status = 0; // indicates EOF } return status; done_put: old_offset = logst->offset; if (mref) { GENERIC_INPUT_CALL_VOID(logst->input, mref_put, mref); logst->read_mref = NULL; logst->log_pos += logst->offset; logst->offset = 0; } if (status == -EAGAIN && old_offset > 0) { if (*dealloc) { brick_mem_free(*dealloc); } goto restart; } goto done; done_free: if (mref) { mars_free_mref(mref); } logst->read_mref = NULL; goto done; } static int _check_crc(struct log_header *lh, void *crc, void *crc_buf, int crc_len, __u32 check_flags, int *mars_error_code) { __u32 invalid_check_flags; bool is_invalid = false; bool did_simple_retry = false; int did_iterative_retry = 0; int bit; int res; retry: res = -EBADMSG; if (check_flags & (MREF_CHKSUM_ANY - MREF_CHKSUM_MD5_OLD)) { unsigned char checksum[MARS_DIGEST_SIZE]; unsigned char check_crc[LOG_CHKSUM_SIZE]; mars_digest(check_flags, &used_log_digest, checksum, crc_buf, crc_len); fold_crc(checksum, check_crc); if (!memcmp(crc, check_crc, LOG_CHKSUM_SIZE)) res = 0; } else if (lh->l_crc_old) { unsigned char checksum[MARS_DIGEST_SIZE]; __u32 old_crc; mars_digest(check_flags, &used_log_digest, checksum, crc_buf, crc_len); old_crc = *(int*)checksum; if (old_crc == lh->l_crc_old) res = 0; } else if (!did_iterative_retry) { invalid_check_flags = check_flags; is_invalid = true; } /* simple retry method */ if (unlikely(res && !did_simple_retry)) { did_simple_retry = true; MARS_WRN("RETRY crc check flags=0x%x crc_len=%d\n", check_flags, crc_len); check_flags |= usable_digest_mask; cond_resched(); goto retry; } /* when simple retry failed: try the painful iterative method */ if (unlikely(res)) { /* We are desperate. We want to recover as much data * as possible. Performance does no longer matter. * Try to _wildly_ _guess_ what check_flags might by usable. */ if (!did_iterative_retry) { bit = find_first_bit((void *)&usable_digest_mask, sizeof(usable_digest_mask)); } else { int next_bit = find_next_bit((void *)&usable_digest_mask, sizeof(usable_digest_mask), bit + 1); if (next_bit <= bit) goto failed; bit = next_bit; } if (bit >= 32) goto failed; check_flags = (1 << bit); if (!(check_flags & usable_digest_mask)) goto failed; did_iterative_retry++; cond_resched(); goto retry; failed: MARS_WRN("ITERATIVE RETRY %d failed\n", did_iterative_retry); } if (is_invalid) { if (!*mars_error_code) *mars_error_code = -MARS_ERR_CRC_FLAGS; MARS_ERR("Found invalid crc flags=0x%x retried=%d+%d\n", invalid_check_flags, did_simple_retry, did_iterative_retry); } else if (res < 0 && !*mars_error_code) *mars_error_code = -MARS_ERR_CRC_MISMATCH; return res; } static int classify_bad_magic(unsigned long long this_magic, unsigned char *found_byte_code, int *mars_error_code) { unsigned long long shifter; unsigned char pattern; unsigned char byte; int j; /* Variant 1: * Zero is assumed to be recoverable. */ if (!this_magic) return -ERESTART; /* Variant 2: * Repeated bytewise patterns are assumed * to point at * (a) uninitialized (or defective) disk data. * (b) problems in RAID hardware, drivers, DMA, etc. * (c) CONFIG_DEBUG_PAGEALLOC or similar * kernel-level sisters (also MARS-specific * ones like CONFIG_MARS_DEBUG_MEM and * sisters). */ shifter = this_magic; pattern = (unsigned char)shifter; for (j = 1; j < sizeof(shifter); j++) { shifter >>= 8; byte = shifter; if (byte != pattern) goto no_repeat; } *found_byte_code = byte; if (!*mars_error_code) *mars_error_code = -MARS_ERR_MAGIC_REPEATED; return -EBADMSG; no_repeat: /* Last resort: * not enough knowledge what might have happened before. */ if (!*mars_error_code) *mars_error_code = -MARS_ERR_MAGIC_BAD; return -EBADRQC; } #define RECORD_ERR(code) \ if (!*mars_error_code) \ *mars_error_code = (code) int log_scan(void *buf, int len, loff_t file_pos, int file_offset, bool sloppy, struct log_header *lh, void **payload, int *payload_len, void **dealloc, unsigned int *seq_nr, int *mars_error_code, int *byte_code) { bool dirty = false; unsigned char start_byte_code = 0; int offset; int i; *payload = NULL; *payload_len = 0; for (i = 0; i < len && i <= len - OVERHEAD; i += sizeof(long)) { unsigned char crc[LOG_CHKSUM_SIZE]; unsigned long long start_magic; char format_version; char valid_flag; short total_len; unsigned long long end_magic; char valid_copy; __u32 check_flags; int restlen = 0; int crc_len; int decompr_len; int found_offset; int crc_status; int advance; void *new_buf = NULL; void *crc_buf; offset = i; if (unlikely(i > 0 && !sloppy)) { MARS_ERR(SCAN_TXT "detected a hole / bad data >= %d\n", SCAN_PAR, i); RECORD_ERR(-MARS_ERR_SCAN_HOLE); return -EBADMSG; } DATA_GET(buf, offset, start_magic); if (unlikely(start_magic != START_MAGIC)) { /* Skip any zeros without notice. * This may be used for future extensions, like * padding at certain places of logfiles. */ if (start_magic != 0) { dirty = true; classify_bad_magic(start_magic, &start_byte_code, mars_error_code); if (start_byte_code && !*byte_code) { *byte_code = start_byte_code; MARS_WRN(SCAN_TXT "found repeated byte pattern 0x%02x", SCAN_PAR, start_byte_code); } } continue; } restlen = len - i; if (unlikely(restlen < START_OVERHEAD)) { MARS_WRN(SCAN_TXT "magic found, but restlen is too small\n", SCAN_PAR); return -EAGAIN; } DATA_GET(buf, offset, format_version); if (unlikely(format_version != FORMAT_VERSION)) { MARS_ERR(SCAN_TXT "found unknown data format %d\n", SCAN_PAR, (int)format_version); RECORD_ERR(-MARS_ERR_SCAN_FORMAT); return -EBADMSG; } DATA_GET(buf, offset, valid_flag); if (unlikely(!valid_flag)) { MARS_WRN(SCAN_TXT "data is explicitly marked invalid (was there a short write?)\n", SCAN_PAR); RECORD_ERR(-MARS_ERR_SCAN_INVAL); continue; } DATA_GET(buf, offset, total_len); if (unlikely(!total_len)) { MARS_WRN(SCAN_TXT "advance is zero\n", SCAN_PAR); RECORD_ERR(-MARS_ERR_SCAN_ZERO); return -ERESTART; } if (unlikely(total_len < 0)) { MARS_WRN(SCAN_TXT "advance %d is wrong\n", SCAN_PAR, total_len); RECORD_ERR(-MARS_ERR_SCAN_NEGATIVE); return -EBADMSG; } if (unlikely(total_len > restlen)) { MARS_WRN(SCAN_TXT "total_len = %d but available data restlen = %d. Was the logfile truncated?\n", SCAN_PAR, total_len, restlen); RECORD_ERR(-MARS_ERR_SCAN_BADLEN); return -EAGAIN; } memset(lh, 0, sizeof(struct log_header)); DATA_GET(buf, offset, lh->l_stamp.tv_sec); DATA_GET(buf, offset, lh->l_stamp.tv_nsec); DATA_GET(buf, offset, lh->l_pos); DATA_GET(buf, offset, lh->l_len); DATA_GET(buf, offset, lh->l_decompress_len); offset += 4; // skip spare DATA_GET(buf, offset, lh->l_code); offset += 2; // skip spare found_offset = offset; advance = total_len - OVERHEAD; if (unlikely(advance <= 0)) { MARS_WRN(SCAN_TXT "advance %d is too small\n", SCAN_PAR, advance); RECORD_ERR(-MARS_ERR_SCAN_ADVANCE); return -ERESTART; } offset += advance; restlen = len - offset; if (unlikely(restlen < END_OVERHEAD)) { MARS_WRN(SCAN_TXT "restlen %d is too small\n", SCAN_PAR, restlen); RECORD_ERR(-MARS_ERR_SCAN_RESTLEN); return -EAGAIN; } DATA_GET(buf, offset, end_magic); if (unlikely(end_magic != END_MAGIC)) { unsigned char end_byte_code = 0; int err; MARS_WRN(SCAN_TXT "bad end_magic 0x%llx, is the logfile truncated?\n", SCAN_PAR, end_magic); err = classify_bad_magic(end_magic, &end_byte_code, mars_error_code); if (end_byte_code && !*byte_code) { *byte_code = end_byte_code; MARS_WRN(SCAN_TXT "found repeated byte pattern 0x%02x", SCAN_PAR, end_byte_code); } return err; } DATA_GET(buf, offset, lh->l_crc_old); DATA_GET(buf, offset, valid_copy); if (unlikely(valid_copy != 1)) { MARS_WRN(SCAN_TXT "found data marked as uncompleted / invalid, len = %d, valid_flag = %d\n", SCAN_PAR, lh->l_len, (int)valid_copy); RECORD_ERR(-MARS_ERR_SCAN_INCOMPL); return -EBADMSG; } // skip spares offset += 1; DATA_GET(buf, offset, lh->l_crc_flags); DATA_GET(buf, offset, lh->l_seq_nr); memcpy(crc, buf + offset, LOG_CHKSUM_SIZE); offset += LOG_CHKSUM_SIZE; if (unlikely(lh->l_seq_nr > *seq_nr + 1 && lh->l_seq_nr && *seq_nr)) { MARS_ERR(SCAN_TXT "record sequence number %u mismatch, expected was %u\n", SCAN_PAR, lh->l_seq_nr, *seq_nr + 1); RECORD_ERR(-MARS_ERR_SCAN_SEQ_FW); return -EBADMSG; } else if (unlikely(lh->l_seq_nr != *seq_nr + 1 && lh->l_seq_nr && *seq_nr)) { MARS_WRN(SCAN_TXT "record sequence number %u mismatch, expected was %u\n", SCAN_PAR, lh->l_seq_nr, *seq_nr + 1); /* Theoretically, a backskip of sequence number * can be tolerated, if it is really true. * We may use this in future, e.g. for propagation * of updated records. * It may also happen in some future record patterns. */ RECORD_ERR(-MARS_ERR_SCAN_SEQ_BW); } *seq_nr = lh->l_seq_nr; /* * We have only 16 flag bits in the traditional * logfile format, which is in production over * years. To remain compatible, we strip off * non-checksum related bits. */ check_flags = (((__u32)lh->l_crc_flags) << _MREF_CHKSUM_MD5_OLD) & (available_digest_mask | available_compression_mask); /* compatibility with old logfiles during upgrade */ if (!check_flags) check_flags = MREF_CHKSUM_MD5_OLD; decompr_len = lh->l_decompress_len; crc_len = lh->l_len; if (decompr_len > 0 && unlikely(decompr_len > MARS_MAX_COMPR_SIZE || decompr_len <= crc_len || (decompr_len % 512) != 0)) { MARS_ERR(SCAN_TXT "implausible decompr_len: %d ~~ %d\n", SCAN_PAR, decompr_len, crc_len); RECORD_ERR(-MARS_ERR_DECOMPR_BADLEN); return -EBADMSG; } if (unlikely(crc_len > MARS_MAX_COMPR_SIZE)) { MARS_ERR(SCAN_TXT "implausible crc_len: %d > %ld\n", SCAN_PAR, crc_len, MARS_MAX_COMPR_SIZE); RECORD_ERR(-MARS_ERR_DECOMPR_TOOBIG); return -EBADMSG; } crc_buf = buf + found_offset; if ((check_flags & MREF_COMPRESS_ANY) && decompr_len > 0) { new_buf = mars_decompress(crc_buf, crc_len, NULL, decompr_len, check_flags); if (likely(new_buf)) { *dealloc = new_buf; crc_buf = new_buf; crc_len = decompr_len; } else { MARS_ERR(SCAN_TXT "decompression 0x%x failure len=%d/%d\n", SCAN_PAR, check_flags, crc_len, decompr_len); RECORD_ERR(-MARS_ERR_DECOMPR_FAIL); return -EBADMSG; } } crc_status = _check_crc(lh, crc, crc_buf, crc_len, check_flags, mars_error_code); if (crc_status) { MARS_ERR(SCAN_TXT "data checksumming mismatch, flags=0x%x len=%d/%d err=%d\n", SCAN_PAR, check_flags, lh->l_len, crc_len, crc_status); return -EBADMSG; } // last check if (unlikely(total_len != offset - i)) { MARS_ERR(SCAN_TXT "internal size mismatch: %d != %d\n", SCAN_PAR, total_len, offset - i); RECORD_ERR(-MARS_ERR_SCAN_SIZE); return -EBADMSG; } // Success... *payload = crc_buf; *payload_len = crc_len; // don't cry when nullbytes have been skipped if (i > 0 && dirty) { MARS_WRN(SCAN_TXT "skipped %d dirty bytes to find valid data\n", SCAN_PAR, i); if (start_byte_code && !*byte_code) { *byte_code = start_byte_code; MARS_WRN("found repeated byte pattern 0x%02x", start_byte_code); } } return offset; } MARS_ERR("could not find any useful data within len=%d bytes\n", len); RECORD_ERR(-MARS_ERR_SCAN_GARBAGE); return -EAGAIN; } ////////////////// module init stuff ///////////////////////// int __init init_log_format(void) { MARS_INF("init_log_format()\n"); return 0; } void exit_log_format(void) { MARS_INF("exit_log_format()\n"); }