View difference between Paste ID: LshWrjr6 and

-
+/*
 The cache needs to be able to provide the following operating modes:
 - read sector(s) to an already allocated buffer
   NOTE: we can provide an hint to cache whether the sectors should be cached or not if it's not already in the cache
 - write sectors(s) from an already filled buffer
   NOTE: same remark
 - read a sector and lock a buffer to it
 - flag a locked sector as dirty
 - clean a locked sector (write it back if needed)
 - flag a locked sector as inconsistent (prevent writeback)
 - remove an inconsistency flag (should be done ASAP)
 - unlock a sector (maybe with a flag if it should be cleaned or not)
 - clean everything (and optionally flush the storage layer)
 - invalidate everything? (if we respect locks, this might cause deadlocks, if not, it might cause all hell of trouble. yet, we need this, to clean things out after e.g. changing microsd cards. just fail (and block card removal) if there are still open handles?)
 */
 
 struct sectorcache_entry
 {
     bool valid;
     bool free;
     int locks;
     bool exclusive;
     bool dirty;
     bool consistent;
     IF_MD2(int drive;)
     unsigned long sector;
     unsigned char* buffer;
 };
 
 static struct mutex sectorcache_mutex SHAREDBSS_ATTR;
 static struct wakeup sectorcache_block SHAREDBSS_ATTR;
 static int sectorcache_replace_idx;
 static struct sectorcache_entry[SECTORCACHE_SIZE];
 static unsigned char sectorcache_buffer[SECTORCACHE_SIZE][SECTOR_SIZE];
 
 void sectorcache_init(void)
 {
     int i;
     sectorcache_replace_idx = 0;
     memset(sectorcache_entry, 0, sizeof(sectorcache_entry));
     mutex_init(&sectorcache_mutex);
     wakeup_init(&sectorcache_block);
     for (i = 0; i < SECTORCACHE_SIZE; i++)
         sectorcache_entry[i].buffer = sectorcache_buffer[i];
 }
 
 static void sectorcache_wait_block()
 {
     mutex_unlock(&sectorcache_mutex);
     wakeup_wait(&sectorcache_block, TIMEOUT_BLOCK);
     mutex_lock(&sectorcache_mutex);
 }
 
 static struct sectorcache_entry* sectorcache_find_entry(IF_MD2(int drive,) unsigned long sector)
 {
     int i;
     for (i = 0; i < SECTORCACHE_SIZE; i++)
         if (sectorcache_entry[i].valid && sectorcache_entry[i].sector == sector
             IF_MD2( && sectorcache_entry[i].drive == drive))
             return &sectorcache_entry[i];
     return null;
 }
 
 static struct sectorcache_entry* sectorcache_allocate_entry(void)
 {
     int i, idx;
     sectorcache_replace_idx++;
     for (int i = 0; i < SECTORCACHE_SIZE; i++)
     {
         idx = (sectorcache_replace_idx + i) % SECTORCACHE_SIZE;
         if (!sectorcache_entry[idx].valid)
             return &sectorcache_entry[idx];
     }
     for (int i = 0; i < SECTORCACHE_SIZE; i++)
     {
         idx = (sectorcache_replace_idx + i) % SECTORCACHE_SIZE;
         if (sectorcache_entry[idx].free)
             return &sectorcache_entry[idx];
     }
     for (int i = 0; i < SECTORCACHE_SIZE; i++)
     {
         idx = (sectorcache_replace_idx + i) % SECTORCACHE_SIZE;
         if (!sectorcache_entry[idx].locks)
             return &sectorcache_entry[idx];
     }
     return null;
 }
 
 int sectorcache_readthrough(IF_MD2(int drive,) unsigned long start, int count, void* buf, bool keepincache);
 int sectorcache_writethrough(IF_MD2(int drive,) unsigned long start, int count, const void* buf, bool keepincache);
 int sectorcache_lock(IF_MD2(int drive,) unsigned long sector, struct sectorcache_entry** handle, bool exclusive);
 int sectorcache_unlock(struct sectorcache_entry** handle, bool clean, bool keepincache);
 
 int sectorcache_markdirty(struct sectorcache_entry* handle)
 {
     mutex_lock(&sectorcache_mutex);
     handle->dirty = true;
     mutex_unlock(&sectorcache_mutex);
 }
 
 int sectorcache_markinconsistent(struct sectorcache_entry* handle)
 {
     mutex_lock(&sectorcache_mutex);
     handle->consistent = false;
     mutex_unlock(&sectorcache_mutex);
 }
 
 int sectorcache_markconsistent(struct sectorcache_entry* handle)
 {
     mutex_lock(&sectorcache_mutex);
     handle->consistent = true;
     mutex_unlock(&sectorcache_mutex);
     wakeup_signal(&sectorcache_block);
 }
 
 int sectorcache_clean(struct sectorcache_entry* handle);
 
 int sectorcache_clean_all(bool flushstorage)
 {
     int i;
     bool retry = true;
     mutex_lock(&sectorcache_mutex);
     while (retry)
     {
         retry = false;
         for (i = 0; i < SECTORCACHE_SIZE; i++)
             if (sectorcache_entry[i].dirty)
             {
                 if (!sectorcache_entry[i].consistent)
                 {
                     sectorcache_wait_block();
                     retry = true;
                 }
                 sectorcache_clean(&sectorcache_entry[i]);
             }
     }
 #ifdef HAVE_STORAGE_FLUSH
     if (flushstorage) storage_flush();
 #endif
     mutex_unlock(&sectorcache_mutex);
 }
 
 int sectorcache_invalidate(IF_MD2(int drive));