static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
rtems_rfs_buffer* buffer;
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
while (!rtems_chain_is_empty (chain))
{
buffer = (rtems_rfs_buffer*) rtems_chain_get_unprotected (chain);
(*count)--;
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
rrc = rc;
}
return rrc;
}
static void *_Malloc_Get_deferred_free( void )
{
rtems_interrupt_lock_context lock_context;
void *p;
rtems_interrupt_lock_acquire( &_Malloc_GC_lock, &lock_context );
p = rtems_chain_get_unprotected( &_Malloc_GC_list );
rtems_interrupt_lock_release( &_Malloc_GC_lock, &lock_context );
return p;
}
static printer_task_buffer *printer_task_get_buffer(
rtems_printer_task_context *ctx,
rtems_chain_control *chain
)
{
rtems_interrupt_lock_context lock_context;
printer_task_buffer *buffer;
printer_task_acquire( ctx, &lock_context );
buffer = (printer_task_buffer *) rtems_chain_get_unprotected( chain );
printer_task_release( ctx, &lock_context );
return buffer;
}
static bsp_interrupt_server_entry *bsp_interrupt_server_get_entry(void)
{
rtems_interrupt_level level;
bsp_interrupt_server_entry *e;
rtems_interrupt_disable(level);
e = (bsp_interrupt_server_entry *)
rtems_chain_get_unprotected(&bsp_interrupt_server_chain);
if (e != NULL) {
e->node.next = NULL;
}
rtems_interrupt_enable(level);
return e;
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
rtems_rfs_buffer_bnum (handle),
rtems_rfs_buffer_dirty (handle) ? "(dirty)" : "",
rtems_rfs_buffer_refs (handle),
rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
if (rtems_rfs_buffer_refs (handle) > 0)
rtems_rfs_buffer_refs_down (handle);
if (rtems_rfs_buffer_refs (handle) == 0)
{
rtems_chain_extract_unprotected (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
if (rtems_rfs_fs_no_local_cache (fs))
{
handle->buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (handle->buffer,
rtems_rfs_buffer_dirty (handle));
}
else
{
/*
* If the total number of held buffers is higher than the configured
* value remove a buffer from the queue with the most buffers and
* release. The buffers are held on the queues with the newest at the
* head.
*
* This code stops a large series of transactions causing all the
* buffers in the cache being held in queues of this file system.
*/
if ((fs->release_count +
fs->release_modified_count) >= fs->max_held_buffers)
{
rtems_rfs_buffer* buffer;
bool modified;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
printf ("rtems-rfs: buffer-release: local cache overflow:"
" %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
if (fs->release_count > fs->release_modified_count)
{
buffer = (rtems_rfs_buffer*)
rtems_chain_get_unprotected (&fs->release);
fs->release_count--;
modified = false;
}
else
{
buffer = (rtems_rfs_buffer*)
rtems_chain_get_unprotected (&fs->release_modified);
fs->release_modified_count--;
modified = true;
}
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
}
if (rtems_rfs_buffer_dirty (handle))
{
rtems_chain_append_unprotected (&fs->release_modified,
rtems_rfs_buffer_link (handle));
fs->release_modified_count++;
}
else
{
rtems_chain_append_unprotected (&fs->release,
rtems_rfs_buffer_link (handle));
fs->release_count++;
}
}
}
handle->buffer = NULL;
}
return rc;
}
