You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
118 lines
2.5 KiB
118 lines
2.5 KiB
#include <limits.h>
|
|
#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include <bitops.h>
|
|
#include <flash.h>
|
|
#include <ftl.h>
|
|
#include <macros.h>
|
|
|
|
#include "gc.h"
|
|
#include "map.h"
|
|
|
|
int ftl_read(struct ftl_map *map, void *data, size_t len, uint32_t va)
|
|
{
|
|
int ret;
|
|
uint32_t page;
|
|
|
|
if ((ret = trace_path(map, NULL, &page, va)) < 0) {
|
|
memset(data, 0, len);
|
|
return ret;
|
|
}
|
|
|
|
if (!data)
|
|
return 0;
|
|
|
|
return flash_read(map->dev, page << map->log2_page_size, data,
|
|
min(map->log2_page_size, len));
|
|
}
|
|
|
|
int ftl_write(struct ftl_map *map, uint32_t va, const uint8_t *data)
|
|
{
|
|
struct ftl_page_desc page_desc;
|
|
int ret;
|
|
|
|
if (va >= ftl_get_capacity(map) &&
|
|
!is_aligned(va, 1 << map->log2_page_size))
|
|
return -1;
|
|
|
|
if ((ret = trace_path(map, &page_desc, NULL, va)) < 0 &&
|
|
ret != -ERR_NOT_FOUND)
|
|
return -1;
|
|
|
|
if (ret == -ERR_NOT_FOUND)
|
|
++map->nused_pages;
|
|
|
|
page_desc.nused_pages = map->nused_pages;
|
|
|
|
return write_upage(map, data, &page_desc);
|
|
}
|
|
|
|
int ftl_trim(struct ftl_map *map, uint32_t va)
|
|
{
|
|
struct ftl_page_desc page_desc, alt_page_desc;
|
|
size_t level, i;
|
|
uint32_t alt_va, page;
|
|
int ret;
|
|
|
|
if ((ret = trace_path(map, &page_desc, &page, va)) < 0) {
|
|
if (ret == -ERR_NOT_FOUND)
|
|
return 0;
|
|
|
|
return ret;
|
|
}
|
|
|
|
--map->nused_pages;
|
|
|
|
for (i = 0; i < 32; ++i) {
|
|
level = 32 - i - 1;
|
|
|
|
if ((alt_va = page_desc.subtrees[level]) != UINT32_MAX)
|
|
break;
|
|
}
|
|
|
|
if (i == 32) {
|
|
map->root = UINT32_MAX;
|
|
|
|
memset(&page_desc, 0xff, sizeof page_desc);
|
|
page_desc.nused_pages = 0;
|
|
|
|
return write_upage(map, NULL, &page_desc);
|
|
}
|
|
|
|
if (read_page_desc(map, &alt_page_desc, alt_va) < 0)
|
|
return -1;
|
|
|
|
page_desc.va = alt_page_desc.va;
|
|
page_desc.nused_pages = map->nused_pages;
|
|
page_desc.subtrees[level] = UINT32_MAX;
|
|
|
|
for (i = level + 1; i < 32; ++i) {
|
|
page_desc.subtrees[i] = alt_page_desc.subtrees[i];
|
|
}
|
|
|
|
if (flash_copy(map->dev, map->head << map->log2_page_size,
|
|
page << map->log2_page_size, 1 << map->log2_page_size) < 0)
|
|
return -1;
|
|
|
|
return write_upage(map, NULL, &page_desc);
|
|
}
|
|
|
|
/* Returns the amount of used pages with a unique virtual address multiplied by
|
|
* the page size as the size of used space on the device.
|
|
*/
|
|
uint32_t ftl_get_size(const struct ftl_map *map)
|
|
{
|
|
return map->nused_pages << map->log2_page_size;
|
|
}
|
|
|
|
/* The capacity of the device is the total amount of user pages minus a block
|
|
* worth of user pages for garbage collection.
|
|
*/
|
|
uint32_t ftl_get_capacity(const struct ftl_map *map)
|
|
{
|
|
return ((map->nblocks - 1) << map->log2_block_size) -
|
|
((map->nblocks - 1) << map->log2_page_size);
|
|
}
|
|
|