blob: 1bfae02f38519dcf40c7d0af304930f1b1a71ed5 [file] [log] [blame]
/*
* MMC-based transactional key-value store
*
* Copyright (C) 2010 Google, Inc.
* Author: Bill he <yuegui.he@amlogic.com>
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
*/
#include <flash_ts.h>
#include <mmc_ts.h>
#include <common.h>
#include <malloc.h>
#include <mmc.h>
#include <partition_table.h>
#include <emmc_partitions.h>
#include <asm/arch/cpu_sdio.h>
#include <asm/arch/sd_emmc.h>
#include <linux/sizes.h>
#include <amlogic/aml_mmc.h>
#define DRV_DESC "MMC-based key-value storage"
/* Internal state */
struct mmc_ts_priv {
struct mutex lock;
struct mmc *mmc;
struct partitions *part_info;
/* chunk size, >= sizeof(struct mmc_ts) */
size_t chunk;
int mmc_read_write_unit;
/* current record offset within mmc partition device */
loff_t offset;
/* fts partition offset on*/
u64 mmc_ts_offset;
/* fts partition size */
u64 mmc_ts_size;
/* mmc dev*/
int dev;
/* in-memory copy of mmc content */
struct flash_ts cache;
/* temporary buffers
* - one backup for failure rollback
* - another for read-after-write verification
*/
struct flash_ts cache_tmp_backup;
struct flash_ts cache_tmp_verify;
};
static struct mmc_ts_priv *__ts;
static inline void __mmc_ts_put(struct mmc_ts_priv *ts)
{
mutex_unlock(&ts->lock);
}
static void set_to_default_empty_state(struct mmc_ts_priv *ts)
{
ts->offset = ts->part_info->size - ts->chunk;
ts->cache.version = 0;
ts->cache.len = 1;
ts->cache.magic = FLASH_TS_MAGIC;
ts->cache.data[0] = '\0';
}
static struct mmc_ts_priv *__mmc_ts_get(void)
{
struct mmc_ts_priv *ts = __ts;
if (likely(ts)) {
mutex_lock(&ts->lock);
} else {
printk(KERN_ERR DRV_NAME ": not initialized yet\n");
}
return ts;
}
static char *mmc_ts_find(struct mmc_ts_priv *ts, const char *key, size_t key_len)
{
char *s = ts->cache.data;
while (*s) {
if (!strncmp(s, key, key_len)) {
if (s[key_len] == '=')
return s;
}
s += strlen(s) + 1;
}
return NULL;
}
static inline u32 mmc_ts_check_header(const struct flash_ts *cache)
{
if (cache->magic == FLASH_TS_MAGIC &&
cache->version &&
cache->len && cache->len <= sizeof(cache->data) &&
/* check correct null-termination */
!cache->data[cache->len - 1] &&
(cache->len == 1 || !cache->data[cache->len - 2])) {
/* all is good */
return cache->version;
}
return 0;
}
static int mmc_ts_read(int dev, struct mmc_ts_priv *ts, loff_t off, void *buf, size_t size, u64 part_start_offset)
{
ulong start_blk;
struct mmc *mmc = ts->mmc;
void *addr_byte, *addr = buf, *addr_tmp;
u64 cnt = 0, sz_byte = 0, n = 0, blk = 0;
mmc = find_mmc_device(dev);
if(!mmc) {
return 1;
}
mmc_init(mmc);
/* blk shift : normal is 9 */
int blk_shift = 0;
blk_shift = ffs(mmc->read_bl_len) - 1;
/* start blk offset */
blk = (part_start_offset + off) >> blk_shift;
/* seziof(ts->cache_tmp_verify) = cnt * ts->chunk + sz_byte */
cnt = size >> blk_shift;
sz_byte = size - (cnt << blk_shift);
/* read cnt* ts->chunk bytes */
n = mmc->block_dev.block_read(dev, blk, cnt, addr);
/* read sz_byte bytes */
if ((n == cnt) && (sz_byte != 0)) {
//printf("sz_byte=%#llx bytes\n",sz_byte);
addr_tmp = malloc(mmc->read_bl_len);
addr_byte = (void *)(addr+cnt*(mmc->read_bl_len));
start_blk = blk+cnt;
if (addr_tmp == NULL) {
printf("mmc read: malloc fail\n");
free(addr);
return 1;
}
if (mmc->block_dev.block_read(dev, start_blk, 1, addr_tmp) != 1) { // read 1 block
free(addr_tmp);
printf("mmc read 1 block fail\n");
return 1;
}
memcpy(addr_byte, addr_tmp, sz_byte);
free(addr_tmp);
}
return 0;
}
static int mmc_is_blank(const void *buf, size_t size)
{
size_t i;
const unsigned int *data = (const unsigned int *)buf;
size /= sizeof(data[0]);
for (i = 0; i < size; i++)
if (data[i] != 0xffffffff)
return 0;
return 1;
}
static int __init mmc_ts_scan(struct mmc_ts_priv *ts, int dev)
{
struct mmc *mmc = ts->mmc;
int res;
loff_t off = 0;
struct flash_ts tmp_scan_backup;
u64 mmc_ts_size = ts->mmc_ts_size;
u64 part_start_offset = ts->mmc_ts_offset;
void *scan_addr = (void *) &tmp_scan_backup;
memset(&tmp_scan_backup, 0, sizeof(tmp_scan_backup));
mmc_init(mmc);
do {
/* read FLASH_TS_MAX_DATA_SIZE data to ts->cache_tmp_verify */
res = mmc_ts_read(dev, ts, off, scan_addr, sizeof(tmp_scan_backup), part_start_offset);
if (!res) {
/* check data struct */
u32 version = mmc_ts_check_header(scan_addr);
if (version > 0) {
if (version > ts->cache.version) {
memcpy(&ts->cache, scan_addr, sizeof(tmp_scan_backup));
ts->offset = off;
}
break;
} else if (0 == version && mmc_is_blank(&tmp_scan_backup, sizeof(tmp_scan_backup))) {
off = (off + ts->mmc->erase_grp_size) & ~(ts->mmc->erase_grp_size - 1);
} else {
off += ts->chunk;
}
} else {
off += ts->chunk;
}
} while(off < mmc_ts_size) ;/* while done*/
return res;
}
static int mmc_write(int dev, struct mmc_ts_priv *ts, loff_t off, void *buf, size_t size, u64 part_start_offset)
{
ulong start_blk;
struct mmc *mmc = ts->mmc;
void *addr_byte, *addr_tmp, *addr, *addr_read;
u64 cnt = 0, sz_byte = 0, n = 0, blk = 0, res;
struct flash_ts tmp_write_backup, tmp_read_backup;
/*********init local data struct**************/
memset(&tmp_write_backup, 0, sizeof(tmp_write_backup));
memset(&tmp_read_backup, 0, sizeof(tmp_read_backup));
memcpy(&tmp_write_backup, buf, size);
addr = (void *) &tmp_write_backup;
addr_read = (void *) &tmp_read_backup;
/********************************************/
mmc = find_mmc_device(dev);
if(!mmc) {
return 1;
}
mmc_init(mmc);
/* blk shift : normal is 9 */
int blk_shift = 0;
blk_shift = ffs(mmc->read_bl_len) - 1;
/* start blk offset */
blk = (part_start_offset + off) >> blk_shift;
/* seziof(ts->cache_tmp_verify) = cnt * ts->chunk + sz_byte */
cnt = size >> blk_shift;
sz_byte = size - (cnt << blk_shift);
n = mmc->block_dev.block_write(dev, blk, cnt, addr);
//write sz_byte bytes
if ((n == cnt) && (sz_byte != 0)) {
// printf("sz_byte=%#llx bytes\n",sz_byte);
addr_tmp = malloc(mmc->write_bl_len);
addr_byte = (void*)(addr+cnt*(mmc->write_bl_len));
start_blk = blk+cnt;
if (addr_tmp == NULL) {
printf("mmc write: malloc fail\n");
return 1;
}
if (mmc->block_dev.block_read(dev, start_blk, 1, addr_tmp) != 1) { // read 1 block
free(addr_tmp);
printf("mmc read 1 block fail\n");
return 1;
}
memcpy(addr_tmp, addr_byte, sz_byte);
if (mmc->block_dev.block_write(dev, start_blk, 1, addr_tmp) != 1) { // write 1 block
free(addr_tmp);
printf("mmc write 1 block fail\n");
return 1;
}
free(addr_tmp);
}
res = mmc_ts_read(dev, ts, off, addr_read, sizeof(tmp_read_backup), part_start_offset);
if (!res) {
if (! memcmp(&tmp_write_backup, &tmp_read_backup, size)) {
memcpy(&ts->cache, &tmp_write_backup, size);
printk("key write successfull!\n");
return 0;
} else {
printk("%s:%d error!\n", __func__, __LINE__);
return -1;
}
} else {
printk("check key failure!\n");
printk("%s:%d error!\n", __func__, __LINE__);
return -2;
}
return 0;
}
static int mmc_ts_commit(struct mmc_ts_priv *ts)
{
int res;
int dev = ts->dev;
u64 part_start_offset = ts->mmc_ts_offset;
res = mmc_write(dev,ts, 0, &ts->cache, sizeof(ts->cache), part_start_offset);
return res;
}
int mmc_ts_set(const char *key, const char *value)
{
int res;
char *p;
struct mmc_ts_priv *ts;
size_t klen = strlen(key);
size_t vlen = strlen(value);
ts = __mmc_ts_get();
if (unlikely(!ts))
return -EINVAL;
/* save current cache contents so we can restore it on failure */
memcpy(&ts->cache_tmp_backup, &ts->cache, sizeof(ts->cache_tmp_backup));
p = mmc_ts_find(ts, key, klen);
if (p) {
/* we are replacing existing entry,
* empty value (vlen == 0) removes entry completely.
*/
size_t cur_len = strlen(p) + 1;
size_t new_len = vlen ? klen + 1 + vlen + 1 : 0;
if (cur_len != new_len) {
/* we need to move stuff around */
if ((ts->cache.len - cur_len) + new_len >
sizeof(ts->cache.data))
goto no_space;
memmove(p + new_len, p + cur_len,
ts->cache.len - (p - ts->cache.data + cur_len));
ts->cache.len = (ts->cache.len - cur_len) + new_len;
} else if (!strcmp(p + klen + 1, value)) {
/* skip update if new value is the same as the old one */
res = 0;
goto out;
}
if (vlen) {
p += klen + 1;
memcpy(p, value, vlen);
p[vlen] = '\0';
}
} else {
size_t len = klen + 1 + vlen + 1;
/* don't do anything if value is empty */
if (!vlen) {
res = 0;
goto out;
}
if (ts->cache.len + len > sizeof(ts->cache.data))
goto no_space;
/* add new entry at the end */
p = ts->cache.data + ts->cache.len - 1;
memcpy(p, key, klen);
p += klen;
*p++ = '=';
memcpy(p, value, vlen);
p += vlen;
*p++ = '\0';
*p = '\0';
ts->cache.len += len;
}
++ts->cache.version;
res = mmc_ts_commit(ts);
if (unlikely(res))
memcpy(&ts->cache, &ts->cache_tmp_backup, sizeof(ts->cache));
goto out;
no_space:
printk(KERN_WARNING DRV_NAME ": no space left for '%s=%s'\n",
key, value);
res = -ENOSPC;
out:
__mmc_ts_put(ts);
return res;
}
void mmc_ts_get(const char *key, char *value, unsigned int size)
{
const char *p;
struct mmc_ts_priv *ts;
size_t klen = strlen(key);
BUG_ON(!size);
*value = '\0';
ts = __mmc_ts_get();
if (unlikely(!ts))
return;
p = mmc_ts_find(ts, key, klen);
if (p)
strlcpy(value, p + klen + 1, size);
__mmc_ts_put(ts);
}
/* Round-up to the next power-of-2,
* from "Hacker's Delight" by Henry S. Warren.
*/
static inline u32 clp2(u32 x)
{
--x;
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
return x + 1;
}
int mmc_ts_init(void)
{
int res,dev;
struct mmc *mmc;
struct mmc_ts_priv *ts;
struct partitions *part_info = NULL;
// get dev by name
dev = find_dev_num_by_partition_name(CONFIG_FLASH_TS_PARTITION);
if (dev < 0) {
printf("Cannot find dev.\n");
return 1;
}
mmc = find_mmc_device(dev);
if(!mmc) {
return 1;
}
//init mmc
mmc_init(mmc);
//init fts data struct
ts = kzalloc(sizeof(*ts), GFP_KERNEL);
if (unlikely(!ts)) {
res = -ENOMEM;
printk(KERN_ERR DRV_NAME ": failed to allocate memory\n");
}
mutex_init(&ts->lock);
ts->mmc = mmc;
ts->mmc_read_write_unit = ts->mmc->read_bl_len;
ts->chunk = clp2((sizeof(struct flash_ts) + ts->mmc->read_bl_len - 1) &
~(ts->mmc->read_bl_len - 1));
/* dev*/
ts->dev = dev;
/* get fts part info*/
part_info = find_mmc_partition_by_name(CONFIG_FLASH_TS_PARTITION);
if (part_info == NULL) {
printf("get partition info failed !!\n");
kfree(ts);
return -1;
}
/* init partiton info to ts data struct*/
ts->part_info = part_info;
ts->mmc_ts_offset = ts->part_info->offset;
ts->mmc_ts_size = ts->part_info->size;
/* default empty state */
set_to_default_empty_state(ts);
/* scan mmc partition for the most recent record */
res = mmc_ts_scan(ts, dev);
if (unlikely(res))
goto out_free;
if (ts->cache.version)
printk(KERN_INFO DRV_NAME ": v%u loaded from 0x%08llx\n",
ts->cache.version, ts->offset);
res = misc_register(&mmc_ts_miscdev);
if (unlikely(res))
goto out_free;
__ts = ts;
out_free:
kfree(ts);
return 0;
}