static void test_chain_first_and_last(void)
{
rtems_chain_control chain;
rtems_chain_node node1, node2;
rtems_chain_node *cnode;
rtems_chain_initialize_empty( &chain );
rtems_chain_append( &chain, &node1 );
rtems_chain_insert( &node1, &node2 );
puts( "INIT - Verify rtems_chain_is_first" );
cnode = rtems_chain_first(&chain);
rtems_test_assert( rtems_chain_is_first( cnode ) );
puts( "INIT - Verify rtems_chain_is_last" );
cnode = rtems_chain_last(&chain);
rtems_test_assert( rtems_chain_is_last( cnode ) );
cnode = rtems_chain_get_first_unprotected( &chain );
rtems_test_assert( cnode == &node1 );
cnode = rtems_chain_first( &chain );
rtems_test_assert( cnode == &node2 );
cnode = rtems_chain_last( &chain );
rtems_test_assert( cnode == &node2 );
}
bool
rtems_rtl_unresolved_interate (rtems_rtl_unresolved_iterator_t iterator,
void* data)
{
rtems_rtl_unresolved_t* unresolved = rtems_rtl_unresolved ();
if (unresolved)
{
rtems_chain_node* node = rtems_chain_first (&unresolved->blocks);
while (!rtems_chain_is_tail (&unresolved->blocks, node))
{
rtems_rtl_unresolv_block_t* block = (rtems_rtl_unresolv_block_t*) node;
rtems_rtl_unresolv_rec_t* rec = rtems_rtl_unresolved_rec_first (block);
while (!rtems_rtl_unresolved_rec_is_last (block, rec))
{
if (iterator (rec, data))
return true;
rec = rtems_rtl_unresolved_rec_next (rec);
}
node = rtems_chain_next (node);
}
}
return false;
}
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
rtems_chain_control *chain = &filesystem_chain;
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
node = rtems_chain_first( chain );
!rtems_chain_is_tail( chain, node ) && !stop;
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
}
rtems_libio_unlock();
}
return stop;
}
static IMFS_jnode_t *IMFS_search_in_directory(
IMFS_directory_t *dir,
const char *token,
size_t tokenlen
)
{
if ( rtems_filesystem_is_current_directory( token, tokenlen ) ) {
return &dir->Node;
} else {
if ( rtems_filesystem_is_parent_directory( token, tokenlen ) ) {
return dir->Node.Parent;
} else {
rtems_chain_control *entries = &dir->Entries;
rtems_chain_node *current = rtems_chain_first( entries );
rtems_chain_node *tail = rtems_chain_tail( entries );
while ( current != tail ) {
IMFS_jnode_t *entry = (IMFS_jnode_t *) current;
bool match = entry->namelen == tokenlen
&& memcmp( entry->name, token, tokenlen ) == 0;
if ( match ) {
return entry;
}
current = rtems_chain_next( current );
}
return NULL;
}
}
}
static IMFS_jnode_t *IMFS_search_in_directory(
IMFS_jnode_t *dir,
const char *token,
size_t tokenlen
)
{
if ( rtems_filesystem_is_current_directory( token, tokenlen ) ) {
return dir;
} else {
if ( rtems_filesystem_is_parent_directory( token, tokenlen ) ) {
return dir->Parent;
} else {
rtems_chain_control *entries = &dir->info.directory.Entries;
rtems_chain_node *current = rtems_chain_first( entries );
rtems_chain_node *tail = rtems_chain_tail( entries );
while ( current != tail ) {
IMFS_jnode_t *entry = (IMFS_jnode_t *) current;
bool match = strncmp( entry->name, token, tokenlen ) == 0
&& entry->name [tokenlen] == '\0';
if ( match ) {
return entry;
}
current = rtems_chain_next( current );
}
return NULL;
}
}
}
rtems_aio_request_chain *
rtems_aio_search_fd (rtems_chain_control *chain, int fildes, int create)
{
rtems_aio_request_chain *r_chain;
rtems_chain_node *node;
node = rtems_chain_first (chain);
r_chain = (rtems_aio_request_chain *) node;
while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
r_chain = (rtems_aio_request_chain *) node;
}
if (r_chain->fildes == fildes)
r_chain->new_fd = 0;
else {
if (create == 0)
r_chain = NULL;
else {
r_chain = malloc (sizeof (rtems_aio_request_chain));
rtems_chain_initialize_empty (&r_chain->perfd);
if (rtems_chain_is_empty (chain))
rtems_chain_prepend (chain, &r_chain->next_fd);
else
rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd);
r_chain->new_fd = 1;
r_chain->fildes = fildes;
}
}
return r_chain;
}
static void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
AIO_printf ("First in chain \n");
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
!rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
}
rtems_chain_insert (node->previous, &req->next_prio);
}
}
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
return AIO_ALLDONE;
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
rtems_rtl_obj_sym_t*
rtems_rtl_symbol_global_find (const char* name)
{
rtems_rtl_symbols_t* symbols;
uint_fast32_t hash;
rtems_chain_control* bucket;
rtems_chain_node* node;
symbols = rtems_rtl_global_symbols ();
hash = rtems_rtl_symbol_hash (name);
bucket = &symbols->buckets[hash % symbols->nbuckets];
node = rtems_chain_first (bucket);
while (!rtems_chain_is_tail (bucket, node))
{
rtems_rtl_obj_sym_t* sym = (rtems_rtl_obj_sym_t*) node;
/*
* Use the hash. I could add this to the symbol but it uses more memory.
*/
if (strcmp (name, sym->name) == 0)
return sym;
node = rtems_chain_next (node);
}
return NULL;
}
static int
rtems_rtl_unresolved_find_name (rtems_rtl_unresolved_t* unresolved,
const char* name,
bool update_refcount)
{
size_t length = strlen (name);
int index = 1;
rtems_chain_node* node = rtems_chain_first (&unresolved->blocks);
while (!rtems_chain_is_tail (&unresolved->blocks, node))
{
rtems_rtl_unresolv_block_t* block = (rtems_rtl_unresolv_block_t*) node;
rtems_rtl_unresolv_rec_t* rec = rtems_rtl_unresolved_rec_first (block);
while (!rtems_rtl_unresolved_rec_is_last (block, rec))
{
if (rec->type == rtems_rtl_unresolved_name)
{
if ((rec->rec.name.length == length)
&& (strcmp (rec->rec.name.name, name)))
{
if (update_refcount)
++rec->rec.name.refs;
return index;
}
++index;
}
rec = rtems_rtl_unresolved_rec_next (rec);
}
node = rtems_chain_next (node);
}
return 0 - index;
}
static rtems_task
rc_conf_worker(rtems_task_argument task_argument)
{
rtems_bsd_rc_conf* rc_conf = (rtems_bsd_rc_conf*) task_argument;
rtems_chain_node* node = rtems_chain_first(&services);
int r = 0;
int error;
/*
* Check for a syslog priority before any services are run.
*/
rc_conf_syslog(rc_conf);
if (rc_conf->verbose)
printf("rc.conf: running\n");
while (!rtems_chain_is_tail(&services, node)) {
service* srv = (service*) node;
int rr;
if (strcmp("network", srv->name) != 0)
printf("Starting %s.\n", srv->name);
rr = srv->entry(rc_conf);
if (rr < 0) {
fprintf(stderr,
"error: bsd service: %s: %s\n", srv->name, strerror(errno));
if (r == 0) {
r = rr;
error = errno;
}
}
node = rtems_chain_next(node);
}
if (rc_conf->verbose)
printf("rc.conf: services done\n");
lock(rc_conf);
if (r < 0)
rc_conf->error_code = error;
/*
* If there is a waiter signal else clean up because the waiter has gone.
*/
if (rc_conf->waiter != 0) {
rtems_event_send(rc_conf->waiter, RTEMS_EVENT_1);
unlock(rc_conf);
}
else {
unlock(rc_conf);
rc_conf_destroy(rc_conf);
}
if (rc_conf->verbose)
printf("rc.conf: finished\n");
rtems_task_delete(RTEMS_SELF);
}
static size_t
rtems_rtl_obj_sections_loader (uint32_t mask,
rtems_rtl_obj_t* obj,
int fd,
uint8_t* base,
rtems_rtl_obj_sect_handler_t handler,
void* data)
{
rtems_chain_control* sections = &obj->sections;
rtems_chain_node* node = rtems_chain_first (sections);
size_t base_offset = 0;
bool first = true;
while (!rtems_chain_is_tail (sections, node))
{
rtems_rtl_obj_sect_t* sect = (rtems_rtl_obj_sect_t*) node;
if ((sect->size != 0) && ((sect->flags & mask) != 0))
{
if (!first)
base_offset = rtems_rtl_sect_align (base_offset, sect->alignment);
sect->base = base + base_offset;
if (rtems_rtl_trace (RTEMS_RTL_TRACE_LOAD_SECT))
printf ("rtl: loading: %s -> %8p (%zi)\n",
sect->name, sect->base, sect->size);
if ((sect->flags & RTEMS_RTL_OBJ_SECT_LOAD) == RTEMS_RTL_OBJ_SECT_LOAD)
{
if (!handler (obj, fd, sect, data))
{
sect->base = 0;
return false;
}
}
else if ((sect->flags & RTEMS_RTL_OBJ_SECT_ZERO) == RTEMS_RTL_OBJ_SECT_ZERO)
{
memset (base + base_offset, 0, sect->size);
}
else
{
sect->base = 0;
rtems_rtl_set_error (errno, "section has no load op");
return false;
}
base_offset += sect->size;
first = false;
}
node = rtems_chain_next (node);
}
return true;
}
static void test_imfs_make_generic_node_errors(void)
{
int rv = 0;
const char *path = "generic";
rtems_chain_control *chain = &rtems_filesystem_mount_table;
rtems_filesystem_mount_table_entry_t *mt_entry =
(rtems_filesystem_mount_table_entry_t *) rtems_chain_first(chain);
const char *type = mt_entry->type;
void *opaque = NULL;
errno = 0;
rv = IMFS_make_generic_node(
path,
S_IFCHR | S_IRWXU | S_IRWXG | S_IRWXO,
&node_invalid_control,
NULL
);
rtems_test_assert(rv == -1);
rtems_test_assert(errno == EINVAL);
errno = 0;
rv = IMFS_make_generic_node(
path,
S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO,
&node_control,
NULL
);
rtems_test_assert(rv == -1);
rtems_test_assert(errno == EINVAL);
mt_entry->type = "XXX";
errno = 0;
rv = IMFS_make_generic_node(
path,
S_IFCHR | S_IRWXU | S_IRWXG | S_IRWXO,
&node_control,
NULL
);
rtems_test_assert(rv == -1);
rtems_test_assert(errno == ENOTSUP);
mt_entry->type = type;
opaque = rtems_heap_greedy_allocate(NULL, 0);
errno = 0;
rv = IMFS_make_generic_node(
path,
S_IFCHR | S_IRWXU | S_IRWXG | S_IRWXO,
&node_control,
NULL
);
rtems_test_assert(rv == -1);
rtems_test_assert(errno == ENOMEM);
rtems_heap_greedy_free(opaque);
}
void
rtems_rtl_unresolved_table_close (rtems_rtl_unresolved_t* unresolved)
{
rtems_chain_node* node = rtems_chain_first (&unresolved->blocks);
while (!rtems_chain_is_tail (&unresolved->blocks, node))
{
rtems_chain_node* next = rtems_chain_next (node);
free (node);
node = next;
}
}
void
rtems_rtl_obj_erase_sections (rtems_rtl_obj_t* obj)
{
rtems_chain_node* node = rtems_chain_first (&obj->sections);
while (!rtems_chain_is_tail (&obj->sections, node))
{
rtems_rtl_obj_sect_t* sect = (rtems_rtl_obj_sect_t*) node;
rtems_chain_node* next_node = rtems_chain_next (node);
rtems_chain_extract (node);
rtems_rtl_alloc_del (RTEMS_RTL_ALLOC_OBJECT, (void*) sect->name);
rtems_rtl_alloc_del (RTEMS_RTL_ALLOC_OBJECT, sect);
node = next_node;
}
}
static void edma_interrupt_error_handler(void *arg)
{
rtems_chain_control *chain = &edma_channel_chain;
rtems_chain_node *node = rtems_chain_first(chain);
uint32_t error_channels [] = {
#if EDMA_GROUP_COUNT >= 1
EDMA.ERL.R
#endif
#if EDMA_GROUP_COUNT >= 2
, EDMA.ERH.R
#endif
#if EDMA_GROUP_COUNT >= 3
, EDMA_B.ERL.R
#endif
};
uint32_t error_status [] = {
#if EDMA_GROUP_COUNT >= 1
EDMA.ESR.R
#endif
#if EDMA_GROUP_COUNT >= 3
, EDMA_B.ESR.R
#endif
};
#if EDMA_GROUP_COUNT >= 1
EDMA.ERL.R = error_channels [0];
#endif
#if EDMA_GROUP_COUNT >= 2
EDMA.ERH.R = error_channels [1];
#endif
#if EDMA_GROUP_COUNT >= 3
EDMA_B.ERL.R = error_channels [2];
#endif
while (!rtems_chain_is_tail(chain, node)) {
edma_channel_context *ctx = (edma_channel_context *) node;
unsigned channel_index = edma_channel_index_of_tcd(ctx->edma_tcd);
unsigned group_index = EDMA_GROUP_INDEX(channel_index);
unsigned group_bit = EDMA_GROUP_BIT(channel_index);
if ((error_channels [group_index] & group_bit) != 0) {
unsigned module_index = EDMA_MODULE_INDEX(channel_index);
(*ctx->done)(ctx, error_status [module_index]);
}
node = rtems_chain_next(node);
}
}
bool
rtems_rtl_chain_iterate (rtems_chain_control* chain,
rtems_chain_iterator iterator,
void* data)
{
rtems_chain_node* node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_node* next_node = rtems_chain_next (node);
if (!iterator (node, data))
return false;
node = next_node;
}
return true;
}
rtems_task Init(
rtems_task_argument ignored
)
{
rtems_chain_control chain1;
rtems_chain_node *p;
test_node node1, node2;
int id;
TEST_BEGIN();
puts( "Init - Initialize chain empty" );
rtems_chain_initialize_empty( &chain1 );
/* verify that the chain append and insert work */
puts( "INIT - Verify rtems_chain_insert" );
node1.id = 1;
node2.id = 2;
rtems_chain_append( &chain1, &node1.Node );
rtems_chain_insert( &node1.Node, &node2.Node );
for ( p = rtems_chain_first(&chain1), id = 1 ;
!rtems_chain_is_tail(&chain1, p) ;
p = p->next , id++ ) {
test_node *t = (test_node *)p;
if ( id > 2 ) {
puts( "INIT - TOO MANY NODES ON CHAIN" );
rtems_test_exit(0);
}
if ( t->id != id ) {
puts( "INIT - ERROR ON CHAIN ID MISMATCH" );
rtems_test_exit(0);
}
}
test_chain_first_and_last();
test_chain_with_empty_check();
test_chain_with_notification();
test_chain_get_with_wait();
test_chain_control_layout();
test_chain_control_initializer();
test_chain_node_count();
test_chain_insert_ordered();
test_chain_iterator();
TEST_END();
rtems_test_exit(0);
}
static void
rtems_bsd_dump_sx(void)
{
rtems_chain_control *chain = &rtems_bsd_sx_chain;
rtems_chain_node *node = rtems_chain_first(chain);
printf("sx dump:\n");
while (!rtems_chain_is_tail(chain, node)) {
struct lock_object *lo = (struct lock_object *) node;
printf("\t%s: 0x%08x\n", lo->lo_name, lo->lo_id);
node = rtems_chain_next(node);
}
}
rtems_rfs_file_shared*
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
return shared;
node = rtems_chain_next (node);
}
return NULL;
}
static void
rtems_bsd_dump_thread(void)
{
rtems_chain_control *chain = &rtems_bsd_thread_chain;
rtems_chain_node *node = rtems_chain_first(chain);
printf("thread dump:\n");
while (!rtems_chain_is_tail(chain, node)) {
struct thread *td = (struct thread *) node;
printf("\t%s: 0x%08x\n", td->td_name, td->td_id);
node = rtems_chain_next(node);
}
}
static void
rtems_bsd_dump_condvar(void)
{
rtems_chain_control *chain = &rtems_bsd_condvar_chain;
rtems_chain_node *node = rtems_chain_first(chain);
printf("condvar dump:\n");
while (!rtems_chain_is_tail(chain, node)) {
struct cv *cv = (struct cv *) node;
printf("\t%s: 0x%08x\n", cv->cv_description, cv->cv_id);
node = rtems_chain_next(node);
}
}
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
rtems_chain_control *chain;
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
req->aiocbp->return_value = -1;
free (req);
}
}
static void
rtems_aio_move_to_work (rtems_aio_request_chain *r_chain)
{
rtems_aio_request_chain *temp;
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
!rtems_chain_is_tail (&aio_request_queue.work_req, node)) {
node = rtems_chain_next (node);
temp = (rtems_aio_request_chain *) node;
}
rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd);
}
static void
rtems_rtl_obj_run_cdtors (rtems_rtl_obj_t* obj, uint32_t mask)
{
rtems_chain_node* node = rtems_chain_first (&obj->sections);
while (!rtems_chain_is_tail (&obj->sections, node))
{
rtems_rtl_obj_sect_t* sect = (rtems_rtl_obj_sect_t*) node;
if ((sect->flags & mask) == mask)
{
rtems_rtl_cdtor_t* handler;
size_t handlers = sect->size / sizeof (rtems_rtl_cdtor_t);
int c;
for (c = 0, handler = sect->base; c < handlers; ++c)
if (*handler)
(*handler) ();
}
node = rtems_chain_next (node);
}
}
static rtems_rap_app_t*
rtems_rap_check_handle (void* handle)
{
rtems_rap_app_t* app;
rtems_chain_node* node;
app = handle;
node = rtems_chain_first (&rap_.apps);
while (!rtems_chain_is_tail (&rap_.apps, node))
{
rtems_rap_app_t* check = (rtems_rap_app_t*) node;
if (check == app)
return app;
node = rtems_chain_next (node);
}
return NULL;
}
static bool
rtems_rtl_obj_section_handler (uint32_t mask,
rtems_rtl_obj_t* obj,
int fd,
rtems_rtl_obj_sect_handler_t handler,
void* data)
{
rtems_chain_node* node = rtems_chain_first (&obj->sections);
while (!rtems_chain_is_tail (&obj->sections, node))
{
rtems_rtl_obj_sect_t* sect = (rtems_rtl_obj_sect_t*) node;
if ((sect->flags & mask) != 0)
{
if (!handler (obj, fd, sect, data))
return false;
}
node = rtems_chain_next (node);
}
return true;
}
bool
rtems_rap_iterate (rtems_rap_iterator_t iterator)
{
rtems_rap_data_t* rap = rtems_rap_lock ();
rtems_chain_node* node;
bool result = true;
node = rtems_chain_first (&rap->apps);
while (!rtems_chain_is_tail (&rap->apps, node))
{
rtems_rap_app_t* app = (rtems_rap_app_t*) node;
result = iterator (app);
if (!result)
break;
node = rtems_chain_next (node);
}
rtems_rap_unlock ();
return result;
}
static rtems_termios_device_node *
rtems_termios_find_device_node(
rtems_device_major_number major,
rtems_device_minor_number minor
)
{
rtems_chain_node *tail = rtems_chain_tail(&rtems_termios_devices);
rtems_chain_node *current = rtems_chain_first(&rtems_termios_devices);
while (current != tail) {
rtems_termios_device_node *device_node =
(rtems_termios_device_node *) current;
if (device_node->major == major && device_node->minor == minor) {
return device_node;
}
current = rtems_chain_next(current);
}
return NULL;
}
bool rtems_filesystem_mount_iterate(
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
node = rtems_chain_first( &mount_chain );
!rtems_chain_is_tail( &mount_chain, node ) && !stop;
node = rtems_chain_next( node )
) {
const rtems_filesystem_mount_table_entry_t *mt_entry =
(rtems_filesystem_mount_table_entry_t *) node;
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
