static void bdbuf_tests_task_0_test_6 (bdbuf_task_control* tc) { rtems_status_code sc; bool passed; int i; rtems_bdbuf_buffer* bd; rtems_chain_control buffers; /* * Set task control's passed to false to handle a timeout. */ tc->passed = false; passed = true; /* * Clear any disk settings. */ bdbuf_clear_disk_driver_watch (tc); bdbuf_set_disk_driver_action (tc, BDBUF_DISK_NOOP); /* * Get the blocks 0 -> 4 and hold them. */ rtems_chain_initialize_empty (&buffers); for (i = 0; (i < 5) && passed; i++) { dev_t device = rtems_filesystem_make_dev_t (tc->major, tc->minor); bdbuf_test_printf ("%s: rtems_bdbuf_read[%d]: ", tc->name, i); sc = rtems_bdbuf_get (device, i, &bd); if (!bdbuf_test_print_sc (sc, true)) passed = false; rtems_chain_append (&buffers, &bd->link); } for (i = 0; (i < 4) && passed; i++) { bdbuf_test_printf ("%s: rtems_bdbuf_release_modified[%d]: ", tc->name, i); bd = (rtems_bdbuf_buffer*) rtems_chain_get (&buffers); passed = bdbuf_test_print_sc (rtems_bdbuf_release_modified (bd), true); } if (passed) { bdbuf_test_printf ("%s: rtems_bdbuf_sync[%d]: ", tc->name, i); bd = (rtems_bdbuf_buffer*) rtems_chain_get (&buffers); passed = bdbuf_test_print_sc (rtems_bdbuf_sync (bd), true); } tc->passed = passed; tc->test = 0; }
/* fat_shutdown_drive -- * Free all allocated resources and synchronize all necessary data * * PARAMETERS: * mt_entry - mount table entry * * RETURNS: * RC_OK on success, or -1 if error occured * and errno set appropriately */ int fat_shutdown_drive(rtems_filesystem_mount_table_entry_t *mt_entry) { int rc = RC_OK; fat_fs_info_t *fs_info = mt_entry->fs_info; int i = 0; if (fs_info->vol.type & FAT_FAT32) { rc = fat_fat32_update_fsinfo_sector(mt_entry, fs_info->vol.free_cls, fs_info->vol.next_cl); if ( rc != RC_OK ) rc = -1; } fat_buf_release(fs_info); if (rtems_bdbuf_syncdev(fs_info->vol.dd) != RTEMS_SUCCESSFUL) rc = -1; for (i = 0; i < FAT_HASH_SIZE; i++) { rtems_chain_node *node = NULL; rtems_chain_control *the_chain = fs_info->vhash + i; while ( (node = rtems_chain_get(the_chain)) != NULL ) free(node); } for (i = 0; i < FAT_HASH_SIZE; i++) { rtems_chain_node *node = NULL; rtems_chain_control *the_chain = fs_info->rhash + i; while ( (node = rtems_chain_get(the_chain)) != NULL ) free(node); } free(fs_info->vhash); free(fs_info->rhash); free(fs_info->uino); free(fs_info->sec_buf); close(fs_info->vol.fd); if (rc) errno = EIO; return rc; }
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 (chain); (*count)--; buffer->user = (void*) 0; rc = rtems_rfs_buffer_io_release (buffer, modified); if ((rc > 0) && (rrc == 0)) rrc = rc; } return rrc; }
void malloc_deferred_frees_process(void) { rtems_chain_node *to_be_freed; /* * If some free's have been deferred, then do them now. */ while ((to_be_freed = rtems_chain_get(&RTEMS_Malloc_GC_list)) != NULL) free(to_be_freed); }
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 (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 (&fs->release); fs->release_count--; modified = false; } else { buffer = (rtems_rfs_buffer*) rtems_chain_get (&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 (&fs->release_modified, rtems_rfs_buffer_link (handle)); fs->release_modified_count++; } else { rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle)); fs->release_count++; } } } handle->buffer = NULL; } return rc; }
/** * Get all the blocks in the pool and hold them. Wake the master to tell it was * have the buffers then wait for the master to tell us to release them. */ static void bdbuf_tests_task_0_test_4 (bdbuf_task_control* tc) { rtems_status_code sc; bool passed; size_t i; rtems_bdbuf_buffer* bd; rtems_chain_control buffers; size_t num = bdbuf_test_buffer_count (); /* * Set task control's passed to false to handle a timeout. */ tc->passed = false; passed = true; /* * Clear any disk settings. */ bdbuf_clear_disk_driver_watch (tc); bdbuf_set_disk_driver_action (tc, BDBUF_DISK_NOOP); /* * Get the blocks 0 -> 4 and hold them. */ rtems_chain_initialize_empty (&buffers); for (i = 0; (i < num) && passed; i++) { bdbuf_test_printf ("%s: rtems_bdbuf_read[%d]: ", tc->name, i); sc = rtems_bdbuf_read (tc->dd, i, &bd); if (!bdbuf_test_print_sc (sc, true)) passed = false; rtems_chain_append (&buffers, &bd->link); } /* * Wake the master to tell it we have the buffers. */ bdbuf_send_wait_event (tc->name, "wake master", tc->master); if (passed) { bdbuf_sleep (250); bdbuf_set_disk_driver_watch (tc, num / 2); /* * Release half the buffers, wait 500msecs then release the * remainder. This tests the swap out timer on each buffer. */ bdbuf_test_printf ("%s: rtems_bdbuf_release_modified[0]: unblocks task 1\n", tc->name); bd = (rtems_bdbuf_buffer*) rtems_chain_get (&buffers); sc = rtems_bdbuf_release_modified (bd); bdbuf_test_printf ("%s: rtems_bdbuf_release_modified[0]: ", tc->name); passed = bdbuf_test_print_sc (sc, true); if (passed) { for (i = 1; (i < (num / 2)) && passed; i++) { bdbuf_test_printf ("%s: rtems_bdbuf_release_modified[%d]: " \ "unblocks task 1\n", tc->name, i); bd = (rtems_bdbuf_buffer*) rtems_chain_get (&buffers); sc = rtems_bdbuf_release_modified (bd); bdbuf_test_printf ("%s: rtems_bdbuf_release_modified[%d]: ", tc->name, i); passed = bdbuf_test_print_sc (sc, true); if (!passed) break; } if (passed) { passed = bdbuf_disk_driver_watch_wait (tc, BDBUF_SECONDS (5)); if (passed) { bdbuf_sleep (500); bdbuf_set_disk_driver_watch (tc, num / 2); for (i = 0; (i < (num / 2)) && passed; i++) { bdbuf_test_printf ("%s: rtems_bdbuf_release_modified[%d]: ", tc->name, i + (num / 2)); bd = (rtems_bdbuf_buffer*) rtems_chain_get (&buffers); passed = bdbuf_test_print_sc (rtems_bdbuf_release_modified (bd), true); if (!passed) break; } passed = bdbuf_disk_driver_watch_wait (tc, BDBUF_SECONDS (5)); if (passed) { if (!rtems_chain_is_empty (&buffers)) { passed = false; bdbuf_test_printf ("%s: buffer chain not empty\n", tc->name); } } } } } } tc->passed = passed; tc->test = 0; }
/** * Get the blocks 0 -> 4 and hold them. Wake the master to tell it was have the * buffers then wait for the master to tell us to release a single buffer. * Task 1 will be block waiting for each buffer. It is a higher priority. */ static void bdbuf_tests_task_0_test_2 (bdbuf_task_control* tc) { rtems_status_code sc; bool passed; int i; rtems_bdbuf_buffer* bd; rtems_chain_control buffers; /* * Set task control's passed to false to handle a timeout. */ tc->passed = false; passed = true; /* * Get the blocks 0 -> 4 and hold them. */ rtems_chain_initialize_empty (&buffers); for (i = 0; (i < 5) && passed; i++) { bdbuf_test_printf ("%s: rtems_bdbuf_get[%d]: ", tc->name, i); sc = rtems_bdbuf_get (tc->dd, i, &bd); if (!bdbuf_test_print_sc (sc, true)) passed = false; rtems_chain_append (&buffers, &bd->link); } /* * Wake the master to tell it we have the buffers. */ bdbuf_send_wait_event (tc->name, "wake master", tc->master); if (passed) { /* * For each buffer we hold wait until the master wakes us * and then return it. Task 2 will block waiting for this * buffer. It is a higher priority task. */ for (i = 0; (i < 5) && passed; i++) { sc = bdbuf_wait (tc->name, BDBUF_SECONDS (5)); if (sc != RTEMS_SUCCESSFUL) { bdbuf_test_printf ("%s: wait failed: ", tc->name); bdbuf_test_print_sc (sc, true); passed = false; break; } else { bdbuf_test_printf ("%s: rtems_bdbuf_release[%d]: unblocks task 1\n", tc->name, i); bd = (rtems_bdbuf_buffer*) rtems_chain_get (&buffers); sc = rtems_bdbuf_release (bd); bdbuf_test_printf ("%s: rtems_bdbuf_release[%d]: ", tc->name, i); if (!bdbuf_test_print_sc (sc, true)) { passed = false; break; } } } } tc->passed = passed; tc->test = 0; }
static void bdbuf_tests_task_0_test_8 (bdbuf_task_control* tc) { rtems_status_code sc; bool passed; int i; rtems_bdbuf_buffer* bd; rtems_chain_control buffers; rtems_chain_node* node; rtems_chain_node* pnode; /* * Set task control's passed to false to handle a timeout. */ tc->passed = false; passed = true; /* * Clear any disk settings. */ bdbuf_clear_disk_driver_watch (tc); bdbuf_set_disk_driver_action (tc, BDBUF_DISK_NOOP); /* * Get the blocks 0 -> 4 and hold them. */ rtems_chain_initialize_empty (&buffers); for (i = 0; (i < 5) && passed; i++) { bdbuf_test_printf ("%s: rtems_bdbuf_read[%d]: ", tc->name, i); sc = rtems_bdbuf_get (tc->dd, i, &bd); if (!bdbuf_test_print_sc (sc, true)) passed = false; rtems_chain_append (&buffers, &bd->link); } node = rtems_chain_tail (&buffers); node = node->previous; bd = (rtems_bdbuf_buffer*) node; pnode = node->previous; rtems_chain_extract (node); node = pnode; bdbuf_test_printf ("%s: rtems_bdbuf_release_modified[4]: ", tc->name); passed = bdbuf_test_print_sc (rtems_bdbuf_release_modified (bd), true); bd = (rtems_bdbuf_buffer*) node; pnode = node->previous; rtems_chain_extract (node); node = pnode; bdbuf_test_printf ("%s: rtems_bdbuf_release_modified[3]: ", tc->name); passed = bdbuf_test_print_sc (rtems_bdbuf_release_modified (bd), true); for (i = 0; (i < 3) && passed; i++) { bdbuf_test_printf ("%s: rtems_bdbuf_release_modified[%d]: ", tc->name, i); bd = (rtems_bdbuf_buffer*) rtems_chain_get (&buffers); passed = bdbuf_test_print_sc (rtems_bdbuf_release_modified (bd), true); } if (passed) { /* * Check the block order. */ bdbuf_set_disk_driver_action (tc, BDBUF_DISK_BLOCKS_INORDER); bdbuf_test_printf ("%s: rtems_bdbuf_syncdev[%d:%d]: checking order\n", tc->name, i, tc->major, tc->minor); sc = rtems_bdbuf_syncdev (tc->dd); bdbuf_test_printf ("%s: rtems_bdbuf_syncdev[%d:%d]: ", tc->name, i, tc->major, tc->minor); passed = bdbuf_test_print_sc (sc, true); } tc->passed = passed; tc->test = 0; }