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;
}
}
}
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;
}
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;
}
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 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);
}
}
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;
}
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;
}
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;
}
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_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_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);
}
}
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_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);
}
}
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;
}
int
rtems_bsd_rc_conf_service_remove(const char* name)
{
rtems_chain_node* node = rtems_chain_first(&services);
const rtems_chain_node* tail = rtems_chain_tail(&services);
while (node != tail) {
service* srv = (service*) node;
if (strcasecmp(name, srv->name) == 0) {
rtems_chain_extract(&srv->node);
free((void*) srv->control);
free((void*) srv->name);
free(srv);
return 0;
}
node = rtems_chain_next(node);
}
errno = ENOENT;
return -1;
}
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;
}
void*
rtems_rap_find (const char* name)
{
rtems_rap_data_t* rap = rtems_rap_lock ();
rtems_chain_node* node;
node = rtems_chain_first (&rap->apps);
while (!rtems_chain_is_tail (&rap->apps, node))
{
rtems_rap_app_t* app = (rtems_rap_app_t*) node;
if (rtems_rap_match_name (app, name))
{
rtems_rap_unlock ();
return app;
}
node = rtems_chain_next (node);
}
rtems_rap_unlock ();
return NULL;
}
bool
rtems_rtl_unresolved_add (rtems_rtl_obj_t* obj,
const uint16_t flags,
const char* name,
const uint16_t sect,
const rtems_rtl_word_t* rel)
{
rtems_rtl_unresolved_t* unresolved;
rtems_chain_node* node;
rtems_rtl_unresolv_block_t* block;
rtems_rtl_unresolv_rec_t* rec;
int name_index;
size_t name_recs;
if (rtems_rtl_trace (RTEMS_RTL_TRACE_UNRESOLVED))
printf ("rtl: unresolv: add: %s(s:%d) -> %s\n",
rtems_rtl_obj_oname (obj), sect, name);
unresolved = rtems_rtl_unresolved ();
if (!unresolved)
return false;
/*
* Find the first block with a spare record.
*/
node = rtems_chain_first (&unresolved->blocks);
block = NULL;
while (!rtems_chain_is_tail (&unresolved->blocks, node))
{
block = (rtems_rtl_unresolv_block_t*) node;
if (block->recs < unresolved->block_recs)
break;
block = NULL;
node = rtems_chain_next (node);
}
/*
* No blocks with any spare records, allocate a new block.
*/
if (!block)
{
block = rtems_rtl_unresolved_block_alloc (unresolved);
if (!block)
return false;
}
name_index = rtems_rtl_unresolved_find_name (unresolved, name, true);
name_recs = rtems_rtl_unresolved_name_recs (name);
/*
* An index less than 0 means the name is present and "0 - index" is the next
* index to use.
*/
if (name_index < 0)
{
rtems_rtl_unresolv_block_t* name_block = block;
/*
* Is there enough room to fit the name ? It not add a new block.
*/
if (name_recs > (unresolved->block_recs - block->recs))
{
name_block = rtems_rtl_unresolved_block_alloc (unresolved);
if (!name_block)
return false;
}
rec = rtems_rtl_unresolved_rec_first_free (name_block);
rec->type = rtems_rtl_unresolved_name;
rec->rec.name.refs = 1;
rec->rec.name.length = strlen (name) + 1;
memcpy ((void*) &rec->rec.name.name[0], name, rec->rec.name.length + 1);
block->recs += name_recs;
name_index = 0 - name_index;
/*
* If the name block is the reloc block and it is full allocate a new
* block for the relocation record.
*/
if ((block == name_block) && (block->recs >= unresolved->block_recs))
{
block = rtems_rtl_unresolved_block_alloc (unresolved);
if (!block)
return false;
}
}
rec = rtems_rtl_unresolved_rec_first_free (block);
rec->type = rtems_rtl_unresolved_reloc;
rec->rec.reloc.obj = obj;
rec->rec.reloc.flags = flags;
rec->rec.reloc.name = name_index;
rec->rec.reloc.sect = sect;
rec->rec.reloc.rel[0] = rel[0];
rec->rec.reloc.rel[1] = rel[1];
rec->rec.reloc.rel[2] = rel[2];
++block->recs;
return true;
}
