Skip to content

Commit

Permalink
staging: android: persistent_ram: refactor ecc support
Browse files Browse the repository at this point in the history 
Remove CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION and related
 #ifdefs.  Also allow persistent ram zones without ecc enabled.
For some use cases, like the data portion of the upcoming
persistent_vars patches, or a persistent ftrace ringbuffer,
ecc on every update is too expensive.

CC: Greg KH <gregkh@linuxfoundation.org>
CC: Android Kernel Team <kernel-team@android.com>
Signed-off-by: Colin Cross <ccross@android.com>
Signed-off-by: John Stultz <john.stultz@linaro.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
  • Loading branch information
Colin Cross authored and Greg Kroah-Hartman committed Mar 8, 2012
1 parent c672528 commit 9cc05ad
Show file tree
Hide file tree
Showing 4 changed files with 143 additions and 147 deletions.
37 changes: 3 additions & 34 deletions drivers/staging/android/Kconfig
View file
Original file line number Diff line number Diff line change
Expand Up @@ -27,47 +27,16 @@ config ANDROID_LOGGER

config ANDROID_PERSISTENT_RAM
bool
select REED_SOLOMON
select REED_SOLOMON_ENC8
select REED_SOLOMON_DEC8

config ANDROID_RAM_CONSOLE
bool "Android RAM buffer console"
depends on !S390 && !UML
select ANDROID_PERSISTENT_RAM
default n

menuconfig ANDROID_RAM_CONSOLE_ERROR_CORRECTION
bool "Android RAM Console Enable error correction"
default n
depends on ANDROID_PERSISTENT_RAM
select REED_SOLOMON
select REED_SOLOMON_ENC8
select REED_SOLOMON_DEC8

if ANDROID_RAM_CONSOLE_ERROR_CORRECTION

config ANDROID_RAM_CONSOLE_ERROR_CORRECTION_DATA_SIZE
int "Android RAM Console Data data size"
default 128
help
Must be a power of 2.

config ANDROID_RAM_CONSOLE_ERROR_CORRECTION_ECC_SIZE
int "Android RAM Console ECC size"
default 16

config ANDROID_RAM_CONSOLE_ERROR_CORRECTION_SYMBOL_SIZE
int "Android RAM Console Symbol size"
default 8

config ANDROID_RAM_CONSOLE_ERROR_CORRECTION_POLYNOMIAL
hex "Android RAM Console Polynomial"
default 0x19 if (ANDROID_RAM_CONSOLE_ERROR_CORRECTION_SYMBOL_SIZE = 4)
default 0x29 if (ANDROID_RAM_CONSOLE_ERROR_CORRECTION_SYMBOL_SIZE = 5)
default 0x61 if (ANDROID_RAM_CONSOLE_ERROR_CORRECTION_SYMBOL_SIZE = 6)
default 0x89 if (ANDROID_RAM_CONSOLE_ERROR_CORRECTION_SYMBOL_SIZE = 7)
default 0x11d if (ANDROID_RAM_CONSOLE_ERROR_CORRECTION_SYMBOL_SIZE = 8)

endif # ANDROID_RAM_CONSOLE_ERROR_CORRECTION

config ANDROID_TIMED_OUTPUT
bool "Timed output class driver"
default y
Expand Down
239 changes: 130 additions & 109 deletions drivers/staging/android/persistent_ram.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,13 +16,10 @@
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/rslib.h>
#include <linux/slab.h>
#include "persistent_ram.h"

#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
#include <linux/rslib.h>
#endif

struct persistent_ram_buffer {
uint32_t sig;
uint32_t start;
Expand All @@ -34,106 +31,184 @@ struct persistent_ram_buffer {

static LIST_HEAD(zone_list);

#define ECC_BLOCK_SIZE CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION_DATA_SIZE
#define ECC_SIZE CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION_ECC_SIZE
#define ECC_SYMSIZE CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION_SYMBOL_SIZE
#define ECC_POLY CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION_POLYNOMIAL

#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
static void persistent_ram_encode_rs8(struct persistent_ram_zone *prz,
uint8_t *data, size_t len, uint8_t *ecc)
{
int i;
uint16_t par[ECC_SIZE];
uint16_t par[prz->ecc_size];

/* Initialize the parity buffer */
memset(par, 0, sizeof(par));
encode_rs8(prz->rs_decoder, data, len, par, 0);
for (i = 0; i < ECC_SIZE; i++)
for (i = 0; i < prz->ecc_size; i++)
ecc[i] = par[i];
}

static int persistent_ram_decode_rs8(struct persistent_ram_zone *prz,
void *data, size_t len, uint8_t *ecc)
{
int i;
uint16_t par[ECC_SIZE];
for (i = 0; i < ECC_SIZE; i++)
uint16_t par[prz->ecc_size];

for (i = 0; i < prz->ecc_size; i++)
par[i] = ecc[i];
return decode_rs8(prz->rs_decoder, data, par, len,
NULL, 0, NULL, 0, NULL);
}
#endif

static void persistent_ram_update(struct persistent_ram_zone *prz,
const void *s, unsigned int count)
static void persistent_ram_update_ecc(struct persistent_ram_zone *prz,
unsigned int count)
{
struct persistent_ram_buffer *buffer = prz->buffer;
#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
uint8_t *buffer_end = buffer->data + prz->buffer_size;
uint8_t *block;
uint8_t *par;
int size = ECC_BLOCK_SIZE;
#endif
memcpy(buffer->data + buffer->start, s, count);
#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
block = buffer->data + (buffer->start & ~(ECC_BLOCK_SIZE - 1));
int ecc_block_size = prz->ecc_block_size;
int ecc_size = prz->ecc_size;
int size = prz->ecc_block_size;

if (!prz->ecc)
return;

block = buffer->data + (buffer->start & ~(ecc_block_size - 1));
par = prz->par_buffer +
(buffer->start / ECC_BLOCK_SIZE) * ECC_SIZE;
(buffer->start / ecc_block_size) * prz->ecc_size;
do {
if (block + ECC_BLOCK_SIZE > buffer_end)
if (block + ecc_block_size > buffer_end)
size = buffer_end - block;
persistent_ram_encode_rs8(prz, block, size, par);
block += ECC_BLOCK_SIZE;
par += ECC_SIZE;
block += ecc_block_size;
par += ecc_size;
} while (block < buffer->data + buffer->start + count);
#endif
}

static void persistent_ram_update_header(struct persistent_ram_zone *prz)
static void persistent_ram_update_header_ecc(struct persistent_ram_zone *prz)
{
#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
struct persistent_ram_buffer *buffer = prz->buffer;

if (!prz->ecc)
return;

persistent_ram_encode_rs8(prz, (uint8_t *)buffer, sizeof(*buffer),
prz->par_header);
#endif
}

static void __init
persistent_ram_save_old(struct persistent_ram_zone *prz)
static void persistent_ram_ecc_old(struct persistent_ram_zone *prz)
{
struct persistent_ram_buffer *buffer = prz->buffer;
size_t old_log_size = buffer->size;
char *dest;
#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
uint8_t *block;
uint8_t *par;

if (!prz->ecc)
return;

block = buffer->data;
par = prz->par_buffer;
while (block < buffer->data + buffer->size) {
int numerr;
int size = ECC_BLOCK_SIZE;
int size = prz->ecc_block_size;
if (block + size > buffer->data + prz->buffer_size)
size = buffer->data + prz->buffer_size - block;
numerr = persistent_ram_decode_rs8(prz, block, size, par);
if (numerr > 0) {
#if 0
pr_info("persistent_ram: error in block %p, %d\n",
pr_devel("persistent_ram: error in block %p, %d\n",
block, numerr);
#endif
prz->corrected_bytes += numerr;
} else if (numerr < 0) {
#if 0
pr_info("persistent_ram: uncorrectable error in block %p\n",
pr_devel("persistent_ram: uncorrectable error in block %p\n",
block);
#endif
prz->bad_blocks++;
}
block += ECC_BLOCK_SIZE;
par += ECC_SIZE;
block += prz->ecc_block_size;
par += prz->ecc_size;
}
}

static int persistent_ram_init_ecc(struct persistent_ram_zone *prz,
size_t buffer_size)
{
int numerr;
struct persistent_ram_buffer *buffer = prz->buffer;
int ecc_blocks;

if (!prz->ecc)
return 0;

prz->ecc_block_size = 128;
prz->ecc_size = 16;
prz->ecc_symsize = 8;
prz->ecc_poly = 0x11d;

ecc_blocks = DIV_ROUND_UP(prz->buffer_size, prz->ecc_block_size);
prz->buffer_size -= (ecc_blocks + 1) * prz->ecc_size;

if (prz->buffer_size > buffer_size) {
pr_err("persistent_ram: invalid size %zu, non-ecc datasize %zu\n",
buffer_size, prz->buffer_size);
return -EINVAL;
}

prz->par_buffer = buffer->data + prz->buffer_size;
prz->par_header = prz->par_buffer + ecc_blocks * prz->ecc_size;

/*
* first consecutive root is 0
* primitive element to generate roots = 1
*/
prz->rs_decoder = init_rs(prz->ecc_symsize, prz->ecc_poly, 0, 1,
prz->ecc_size);
if (prz->rs_decoder == NULL) {
pr_info("persistent_ram: init_rs failed\n");
return -EINVAL;
}
#endif

prz->corrected_bytes = 0;
prz->bad_blocks = 0;

numerr = persistent_ram_decode_rs8(prz, buffer, sizeof(*buffer),
prz->par_header);
if (numerr > 0) {
pr_info("persistent_ram: error in header, %d\n", numerr);
prz->corrected_bytes += numerr;
} else if (numerr < 0) {
pr_info("persistent_ram: uncorrectable error in header\n");
prz->bad_blocks++;
}

return 0;
}

ssize_t persistent_ram_ecc_string(struct persistent_ram_zone *prz,
char *str, size_t len)
{
ssize_t ret;

if (prz->corrected_bytes || prz->bad_blocks)
ret = snprintf(str, len, ""
"\n%d Corrected bytes, %d unrecoverable blocks\n",
prz->corrected_bytes, prz->bad_blocks);
else
ret = snprintf(str, len, "\nNo errors detected\n");

return ret;
}

static void persistent_ram_update(struct persistent_ram_zone *prz,
const void *s, unsigned int count)
{
struct persistent_ram_buffer *buffer = prz->buffer;
memcpy(buffer->data + buffer->start, s, count);
persistent_ram_update_ecc(prz, count);
}

static void __init
persistent_ram_save_old(struct persistent_ram_zone *prz)
{
struct persistent_ram_buffer *buffer = prz->buffer;
size_t old_log_size = buffer->size;
char *dest;

persistent_ram_ecc_old(prz);

dest = kmalloc(old_log_size, GFP_KERNEL);
if (dest == NULL) {
Expand Down Expand Up @@ -173,30 +248,11 @@ int persistent_ram_write(struct persistent_ram_zone *prz,
buffer->start += c;
if (buffer->size < prz->buffer_size)
buffer->size += c;
persistent_ram_update_header(prz);
persistent_ram_update_header_ecc(prz);

return count;
}

ssize_t persistent_ram_ecc_string(struct persistent_ram_zone *prz,
char *str, size_t len)
{
#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
ssize_t ret;

if (prz->corrected_bytes || prz->bad_blocks)
ret = snprintf(str, len, ""
"\n%d Corrected bytes, %d unrecoverable blocks\n",
prz->corrected_bytes, prz->bad_blocks);
else
ret = snprintf(str, len, "\nNo errors detected\n");

return ret;
#else
return 0;
#endif
}

size_t persistent_ram_old_size(struct persistent_ram_zone *prz)
{
return prz->old_log_size;
Expand All @@ -215,12 +271,10 @@ void persistent_ram_free_old(struct persistent_ram_zone *prz)
}

static int __init __persistent_ram_init(struct persistent_ram_zone *prz,
void __iomem *mem, size_t buffer_size)
void __iomem *mem, size_t buffer_size, bool ecc)
{
struct persistent_ram_buffer *buffer = mem;
#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
int numerr;
#endif
int ret;

INIT_LIST_HEAD(&prz->node);

Expand All @@ -233,43 +287,10 @@ static int __init __persistent_ram_init(struct persistent_ram_zone *prz,
return -EINVAL;
}

#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
prz->buffer_size -= (DIV_ROUND_UP(prz->buffer_size,
ECC_BLOCK_SIZE) + 1) * ECC_SIZE;

if (prz->buffer_size > buffer_size) {
pr_err("persistent_ram: buffer %p, invalid size %zu, non-ecc datasize %zu\n",
buffer, buffer_size, prz->buffer_size);
return -EINVAL;
}

prz->par_buffer = buffer->data + prz->buffer_size;
prz->par_header = prz->par_buffer +
DIV_ROUND_UP(prz->buffer_size, ECC_BLOCK_SIZE) * ECC_SIZE;


/* first consecutive root is 0
* primitive element to generate roots = 1
*/
prz->rs_decoder = init_rs(ECC_SYMSIZE, ECC_POLY, 0, 1, ECC_SIZE);
if (prz->rs_decoder == NULL) {
pr_info("persistent_ram: init_rs failed\n");
return -EINVAL;
}

prz->corrected_bytes = 0;
prz->bad_blocks = 0;

numerr = persistent_ram_decode_rs8(prz, buffer, sizeof(*buffer),
prz->par_header);
if (numerr > 0) {
pr_info("persistent_ram: error in header, %d\n", numerr);
prz->corrected_bytes += numerr;
} else if (numerr < 0) {
pr_info("persistent_ram: uncorrectable error in header\n");
prz->bad_blocks++;
}
#endif
prz->ecc = ecc;
ret = persistent_ram_init_ecc(prz, buffer_size);
if (ret)
return ret;

if (buffer->sig == PERSISTENT_RAM_SIG) {
if (buffer->size > prz->buffer_size
Expand All @@ -296,7 +317,7 @@ static int __init __persistent_ram_init(struct persistent_ram_zone *prz,
}

int __init persistent_ram_init_ringbuffer(struct persistent_ram_zone *prz,
void __iomem *mem, size_t buffer_size)
void __iomem *mem, size_t buffer_size, bool ecc)
{
return __persistent_ram_init(prz, mem, buffer_size);
return __persistent_ram_init(prz, mem, buffer_size, true);
}
Loading

0 comments on commit 9cc05ad

Please sign in to comment.