View difference between Paste ID: RMAb7Ejf 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;      /* Contains valid and up-to-date data for the specified sector */
     bool free;       /* Not expected to be needed again, should be reclaimed preferably */
     int locks;       /* Number of users of this buffer */
     bool exclusive;  /* Locked for exclusive access, usually for writing */
     bool dirty;      /* Needs to be written back before it can be reclaimed */
     bool consistent; /* Allowed to be written back in its current state */
     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];
 }
 
 /* Blocks the current thread until a buffer becomes free, unlocked or consistent,
    up to the specified number of ticks. Use TIMEOUT_BLOCK to block forever.
    Please note that this will release the mutex while blocking! */
 static void sectorcache_wait_block(int timeout)
 {
     mutex_unlock(&sectorcache_mutex);
     wakeup_wait(&sectorcache_block, timeout);
     mutex_lock(&sectorcache_mutex);
 }
 
 /* Tries to find a valid buffer for the specified sector.
    Returns its handle, or null if it couldn't find one.
    Please note that this doesn't check whether that buffer is locked.
    The mutex must have been locked by the caller before calling this. */
 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;
 }
 
 /* Tries to find a reclaimable buffer.
    Returns its handle, or null if it couldn't find one.
    Please note that this doesn't mark the buffer as used and doesn't
    check whether that buffer needs to be written back first.
    The mutex must have been locked by the caller before calling this. */
 static struct sectorcache_entry* sectorcache_find_free(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);
 
 /* Indicate that the buffer will need to be written back before it can be reclaimed */
 int sectorcache_markdirty(struct sectorcache_entry* handle)
 {
     mutex_lock(&sectorcache_mutex);
     handle->dirty = true;
     mutex_unlock(&sectorcache_mutex);
 }
 
 /* Indicate that the buffer may not be written back until it has been
    marked as consistent again. (Prevents syncing during inactivity)
    Release this as soon as possible. */
 int sectorcache_markinconsistent(struct sectorcache_entry* handle)
 {
     mutex_lock(&sectorcache_mutex);
     handle->consistent = false;
     mutex_unlock(&sectorcache_mutex);
 }
 
 /* Indicate that the buffer may not be written back again. */
 int sectorcache_markconsistent(struct sectorcache_entry* handle)
 {
     mutex_lock(&sectorcache_mutex);
     handle->consistent = true;
     mutex_unlock(&sectorcache_mutex);
     wakeup_signal(&sectorcache_block);
 }
 
 /* Write back the sector. Will mark it as consistent.
    Make sure it is marked as consistent before calling this internally. */
 int sectorcache_clean(struct sectorcache_entry* handle);
 
 /* Write back everything that's dirty,
    and flush the storage layer if wanted.
    This may block for several seconds! */
 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(TIMEOUT_BLOCK);
                     retry = true;
                 }
                 sectorcache_clean(&sectorcache_entry[i]);
             }
     }
 #ifdef HAVE_STORAGE_FLUSH
     if (flushstorage) storage_flush();
 #endif
     mutex_unlock(&sectorcache_mutex);
 }
 
 /* Invalidate the whole cache for the drive, used by hotplug and USB.
    Will panic if there are still handles open for this drive. */
 int sectorcache_invalidate(IF_MD2(int drive));