Board.KolibriOS.org

#define BLOCK_SIZE    64
#define BLOCK_SHIFT    6
#define CACHE_SIZE    64
#define SECTOR_SIZE  512

size_t  _stdcall ahci_adjust_cache_size(void* userdata, size_t suggested_size)
{
    printf("LRU cache %dx%dKB size %d\n",CACHE_SIZE,BLOCK_SIZE/2, CACHE_SIZE*BLOCK_SIZE*SECTOR_SIZE);
    return 0; //suggested_size;
}

typedef struct
{
    struct list_head lru_list;
    struct list_head key_list;
    int64_t start;
    char   *mem;
    void   *r;
}dcache_t;

dcache_t dcache[CACHE_SIZE];

struct list_head key_hash[CACHE_SIZE];

struct list_head dcache_lru;

int init_dcache()
{
    int i;
    char *mem;

    mem = KernelAlloc(CACHE_SIZE*BLOCK_SIZE*SECTOR_SIZE);

    if(mem == NULL)
        return -ENOMEM;

    for(i = 0; i < CACHE_SIZE; i++)
        INIT_LIST_HEAD(&key_hash[i]);

    INIT_LIST_HEAD(&dcache_lru);

    for(i = 0; i < CACHE_SIZE; i++)
    {
        INIT_LIST_HEAD(&dcache[i].key_list);

        dcache[i].mem = mem + i * BLOCK_SIZE * SECTOR_SIZE;
        list_add_tail(&dcache[i].lru_list, &dcache_lru);
    }

    return 0;
};


int _stdcall dcache_disk_read(void* userdata, void* buffer, int64_t startsector, int* numsectors)
{
    int i, key;
    int64_t sector;
    int     offset;
    dcache_t *cache, *tmp_cache;

//    return ahci_disk_read(userdata, buffer, startsector, *numsectors);

    for(i = 0; i < *numsectors; i++)
    {
        sector = (startsector + i) & ~((u64)BLOCK_SIZE - 1);
        offset = (startsector + i) & (BLOCK_SIZE - 1);

        key = (sector >> BLOCK_SHIFT) & (CACHE_SIZE - 1);

        cache = NULL;

        list_for_each_entry(tmp_cache, &key_hash[key], key_list)
        {
            if(tmp_cache->start == sector)
            {
                cache = tmp_cache;
                list_del(&cache->lru_list);
                break;
            }
        };

        if(cache == NULL)
        {
            cache = container_of(dcache_lru.next, dcache_t, lru_list);
            list_del(&cache->key_list);
            list_del(&cache->lru_list);

            ahci_disk_read(userdata, cache->mem, sector, BLOCK_SIZE);
            cache->start = sector;
            list_add_tail(&cache->key_list, &key_hash[key]);
        }

        list_add_tail(&cache->lru_list, &dcache_lru);

        memcpy((char*)buffer + i * SECTOR_SIZE, cache->mem + offset *SECTOR_SIZE, SECTOR_SIZE);
    };

    return 0;
};